méthode de différence absolue absolue pour projet de stabilisation vidéo en C++/CLI

Question

J'essaie d'implémenter un projet de stabilisation vidéo en C++/cli. Tout d'abord, j'ai des séquences d'images bmp, et j'ai trouvé des vecteurs de mouvement qui montrent la distance entre les pixels chaque image. Par exemple j'ai 256 * 256 image, j'ai choisi la région 200 * 200 dans le premier cadre d'image et le second cadre d'image. Et j'ai trouvé combien de pixel bougent entre la première région et la deuxième région. Quand l'algorithme est passé à la dernière image work.Eventually, j'ai obtenu des vecteurs de mouvement. J'ai fait cette opération en utilisant la méthode absolue absolue. Cela a fonctionné, mais trop bloc slowly.My exemple de code est ici, je trouve qu'un seul vecteur premier indice de mouvement (direction x et direction y):

//M:image height =256 

//N.image width =256 

//BS:block size=218 


//selecting and reading first and second image frame 



frame = 1; 

s1 = "C:\\bike\\" + frame + ".bmp"; 
image = gcnew System::Drawing::Bitmap(s1, true); 

s2 = "C:\\bike\\" + (frame + 1) + ".bmp"; 
image2 = gcnew System::Drawing::Bitmap(s2, true); 

for (b = 0; b < M; b++){ 
    for (a = 0; a < N; a++) 
{ 
    System::Drawing::Color BitmapColor = image->GetPixel(a, b); 
I1[b][a] = (double)((BitmapColor . R * 0.3) + (BitmapColor . G * 0.59) + (BitmapColor . B * 0.11)); 
} 
} 

for (b = 0; b < M; b++){ 
    for (a = 0; a < N; a++) 
{ 
    System::Drawing::Color BitmapColor = image2->GetPixel(a, b); 
I2[b][a] = (double)((BitmapColor . R * 0.3) + (BitmapColor . G * 0.59) + (BitmapColor . B * 0.11)); 
} 
} 



//finding blocks 

a = 0; 
for (i = 19; i < 237; i++){ 
    b = 0; 
    for (j = 19; j < 237; j++){ 

     Blocks[a][b] = I2[i][j]; 
     b++; 
    } 
    a++; 
} 


//finding motion vectors according to the mean absolute differences 


//MAD method 

for (m = 0; m < (M - BS); m++){ 
    for (n = 0; n < (N - BS); n++){ 

     toplam = 0; 
     for (i = 0; i < BS; i++){ 

      for (j = 0; j < BS; j++){ 

       toplam += fabs(I1[m + i][n + j] - Blocks[i][j]); 


      } 
     } 


// finding vectors 

     if (difference < mindifference) { 
      mindifference = difference; 
      MV_x = m; 
      MV_y = n; 
     } 


    } 
} 

Cet exemple de code worked.But cela est très slowly.I besoin d'implémenter l'optimisation du code. Comment est-ce que je peux faire ceci sans employer pour des cycles, tels que je fais l'indexation en C++/cli comme des codes de MATLAB (ex I1 (1:20) = 100).

Pourriez-vous m'aider s'il vous plaît?

Cordialement ...

Answer 1

Un couple de choses que vous devez noter:

d'abord, les boucles en C++ ne sont pas lent par rapport aux fonctions intégrées. Dans MatLab, moins il y a d'opérations, mieux c'est. Il est donc préférable d'appeler des fonctions intégrées qui sont une seule opération effectuée avec du code optimisé. En C++, votre code est optimisé également avec les fonctions intégrées. Le GetPixel est extrêmement lent. Essayez plutôt Bitmap.LockBits. Ironiquement, cela semble contredire mon affirmation précédente, mais en réalité ce n'est pas parce que la boucle LockBits est plus rapide que la boucle, mais parce que GetPixel utilise une méthode différente beaucoup plus lente.

Une fois que vous passez à LockBits, vous pouvez probablement doubler ou tripler votre vitesse à nouveau par la boucle un peu dérouler, si le compilateur ne fait pas déjà. Enfin, assurez-vous de bien utiliser la localisation du cache. Essayez les deux ordres de bouclage (par exemple for (a...) for (b...) et for (b...) for (a...)) et mesurez le temps de chacun pour déterminer lequel est le plus rapide.