Miglior algoritmo per la stabilizzazione video

Question

Sto creando un programma per stabilizzare il flusso video. Al momento, il mio programma funziona in base all'algoritmo di correlazione di fase. Sto calcolando un offset tra due immagini: base e corrente. Quindi correggo l'immagine corrente in base alle nuove coordinate. Questo programma funziona, ma il risultato non è soddisfacente. I link correlati che potresti scoprire che il video trattato appare indesiderabile e scuotere l'intero video stanno peggiorando.
Orininal video
Unshaked video
C'è la mia realizzazione corrente:
Calcolo di offset tra le immagini:

Point2d calculate_offset_phase_optimized(Mat one, Mat& two) { 

    if(two.type() != CV_64F) { 
    cvtColor(two, two, CV_BGR2GRAY); 
    two.convertTo(two, CV_64F); 
    } 

    cvtColor(one, one, CV_BGR2GRAY); 
    one.convertTo(one, CV_64F); 

    return phaseCorrelate(one, two); 

} 

spostamento dell'immagine secondo questa coordinata:

void move_image_roi_alt(Mat& img, Mat& trans, const Point2d& offset) { 

    trans = Mat::zeros(img.size(), img.type()); 
    img(
    Rect(
     _0(static_cast<int>(offset.x)), 
     _0(static_cast<int>(offset.y)), 
     img.cols-abs(static_cast<int>(offset.x)), 
     img.rows-abs(static_cast<int>(offset.y)) 
    ) 
).copyTo(trans(
    Rect(
     _0ia(static_cast<int>(offset.x)), 
     _0ia(static_cast<int>(offset.y)), 
     img.cols-abs(static_cast<int>(offset.x)), 
     img.rows-abs(static_cast<int>(offset.y)) 
    ) 
)); 
} 

int _0(const int x) { 
    return x < 0 ? 0 : x; 
} 

int _0ia(const int x) { 
    return x < 0 ? abs(x) : 0; 
} 

stavo guardando attraverso gli autori del documento stabilizzatore di YouTube e l'algoritmo basato sul rilevamento degli angoli sembrava interessante, ma non sono del tutto chiaro come funziona. Quindi la mia domanda è come risolvere efficacemente questo problema. Una delle condizioni - il programma verrà eseguito su computer più lenti, quindi algoritmi pesanti potrebbero non essere adatti.
Grazie!
P.S. Mi scuso per eventuali errori nel testo - si tratta di una traduzione automatica.

Answer 1

È possibile utilizzare i descrittori di immagine come SIFT in ciascun frame e calcolare robustmatches tra i frame. Quindi puoi calcolare homography tra i frame e usarli per allinearli. L'utilizzo di funzionalità sparse può portare a un'implementazione più rapida rispetto all'utilizzo di una correlazione densa.

In alternativa, se si conosce il camera parameters è possibile calculate 3D positions dei punti e delle telecamere e riproffare le immagini su un piano di proiezione stabile. Nel risultato, si ottiene anche uno sparse 3D reconstruction della scena (un po 'impreciso, di solito deve essere optimized utilizzabile). Questo è ciò ad es. Autostitch farebbe, ma è piuttosto difficile da implementare, tuttavia.

Si noti che i parametri della telecamera possono anche essere calculated, ma che è ancora più difficile.

Answer 2

OpenCV può fare per voi in 3 linee di codice (è sicuramente via più breve, può essere anche il migliore):

t = estimateRigidTransform(newFrame, referenceFrame, 0); // 0 means not all transformations (5 of 6) 
if(!t.empty()){  
    warpAffine(newFrame, stableFrame, t, Size(newFrame.cols, newFrame.rows)); // stableFrame should be stable now 
} 

È possibile disattivare un qualche tipo di trasformazioni modificando matrice T, è può portare a risultati più stabili. È solo un'idea di base, quindi puoi modificarla nel modo desiderato: cambia riferimentoFrame, set regolare di parametri di trasformazione dalla matrice t ecc.