Używanie funkcji SciPy DCT do tworzenia 2D DCT-II

Question

Tworzę 2D DCT-II w labview, ale chcę mieć możliwość sprawdzenia, czy moje wyniki są poprawne. SciPy ma ładną funkcję DCT, która domyślnie obsługuje DCT-II, ale jest 1D.

Chcę, aby działało na tablicę 2D. W tym celu DCT musi zostać zastosowany do kolumn, a następnie DCT musi zostać ponownie zastosowany do wierszy tego wyniku.

Nie jestem pewien, jakiej funkcji chcę użyć, aby to zrobić. Próbowałem np.rot90 który obraca tablicy numpy 90 stopni w lewo, co następuje:

import numpy as np 
from scipy.fftpack import dct 

a = np.array([[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0], 
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0]]) 

b = dct(np.rot90(dct(a),3)) 

Jednak ten wyprowadza następujące:

array([[ 1152.  ,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ -412.30867345,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ 0.  ,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ -43.10110726,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ 0.  ,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ -12.85778584,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ 0.  ,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ], 
     [ -3.24494866,  0.  ,  0.  ,  0.  , 
      0.  ,  0.  ,  0.  ,  0.  ]]) 

myślę że rot90 nie jest właściwa funkcja robić to, co Chcę to zrobić, może jest lepszy?

Answer 1

Nie sądzę, że obrót jest tym, czego potrzebujesz, ponieważ konwertuje wiersze w kolumny, ale również zakłóca porządek danych. Zamiast tego użyj np.transpose.

Aby zastosować DCT najpierw przez kolumny, a następnie przez rzędy, byś zrobił coś takiego:

dct(dct(a.T).T) 

Tylna .T jest równoważna np.transpose. Zwróć uwagę, że musisz cofnąć transpozycję po operowaniu na kolumnach, aby uzyskać powrót wyrównany do kolejnych wierszy.

Nie sądzę, że kolejność, w której stosuje się DCT, czyli kolumny następnie wiersze vs. rzędy kolumn następnie czyni żadnej różnicy, ale można dostać wiersze następnie kolumny jak:

dct(dct(a).T).T 

Answer 2

@ Odpowiedź Jaime jest w porządku. Dodam, że dct ma argument axis tylko w tym celu. Najpierw zastosuj ją wzdłuż, powiedzmy, osi 0, a następnie wzdłuż osi 1 wyniku:

In [30]: from scipy.fftpack import dct 

In [31]: a.shape 
Out[31]: (8, 8) 

In [32]: t1 = dct(dct(a, axis=0), axis=1) 

In [33]: t2 = dct(dct(a.T).T) 

In [34]: np.abs(t1 - t2).max() 
Out[34]: 0.0