amélioration de la vitesse du programme: vitesse vectorielle, vitesse du bloc mémoire

Question

Je suis en train de lire 17 images (24 bits, 1200 x 1600). La lecture des 17 images me coûte environ 0,078 sec Cependant, je voudrais convertir ce bloc de mémoire qui est la taille de 5760000 en une taille d'image en noir et blanc de 192000 pour faire mon edge_detection laplacien. En ce moment je suis en utilisant la méthode suivante:

images.resize(rows * cols); 
images.reserve(rows * cols); 

for(int z = 0; z < rows * cols; z ++){ 
    pix.blue = (int) *(pChar + z * 3); 
    pix.green = (int) *(pChar + z * 3 + 1); 
    pix.red = (int) *(pChar + z * 3 + 2); 
    pix.black_white = pix.blue * .11 + pix.green * .59 + pix.red *.3; 
    images.at(z).black_white = pix.blue * .11 + pix.green * .59 + pix.red *.3; 
} 

Ce processus mais la lecture du bloc de mémoire pChar et l'écriture dans un format vectoriel de 1.920.000 me coûte un temps total de 2.262 secondes pour lire 17 images. Y a-t-il un moyen plus rapide d'aborder cela?

J'ai essayé d'utiliser un code différent ci-dessous, mais le pChar2 continue à me dire qu'il a un badptr en mode débogage pour VS2010: (data_grey, pChar variable pChar2 est un * unsigned char)

pChar = (unsigned char*) malloc (sizeof(char)*3*rows*cols); 
pChar2 = (unsigned char*) malloc (sizeof(char) * rows * cols); 
fread(pChar, sizeof(char), 3*rows*cols, bmpInput); 
images.at(i).data = pChar; 

for(int z = 0; z < rows * cols; z ++){ 
    pix.blue = (int) *(pChar + z * 3); 
    pix.green = (int) *(pChar + z * 3 + 1); 
    pix.red = (int) *(pChar + z * 3 + 2); 
    pix.black_white = pix.blue * .11 + pix.green * .59 + pix.red *.3; 
    pChar2 += (unsigned char) pix.black_white; 
} 
    images.at(i).data_grey = pChar2; 

Ma pensée est que je peux écrire dans le bloc de mémoire de pChar2 d'une manière incorrecte. Mais cette 2ème méthode était beaucoup plus rapide, donc je me demandais comment je devais le réparer. Ce serait idéal si j'avais un bloc de mémoire en noir et blanc pour images.at (i) .data_grey. Je veux surtout faire ça parce que c'était beaucoup plus rapide que les vecteurs mais y at-il quelque chose que j'ai fait de mal sur le code vectoriel qui le rend si lent en comparaison? (Je trouve des vecteurs plus facile à utiliser personnellement, mais si je dois vitesse je vais vraiment mal si face à travailler avec des blocs de mémoire si elle est censée être plus rapide)

Answer 1

Je pense que ce que vous devez faire est de changer

pChar2 += (unsigned char) pix.black_white; 

à

pChar2[z] = (unsigned char) pix.black_white; 

en supposant que vous essayez de ce que je pense que vous essayez de le faire (attribuer une valeur au bloc de mémoire pChar2 est pointé du puis déplacez le pointeur vers la mémoire suivante 8bit bloquer?)

Answer 2

N'utilisez pas l'accesseur d'élément de vérification des limites at(). Cela vérifiera votre index à chaque fois, car il doit lancer une exception si vous utilisez un index hors-limites. Cela ne devrait jamais arriver parce que vous avez initialement redimensionné votre vecteur. Par conséquent, vous devez utiliser l'opérateur [] sans vérification de limite.

Vous pouvez également écrire directement dans le vecteur comme un tableau C. Certains puristes pourraient se fâcher à ce sujet, mais je pense que ça va avec les vecteurs:

images.resize(rows*cols); 
unsigned char *bwPixel = &images[0]; 

for(...) 
{ 
    // ... 
    *bwPixel++ = (unsigned char) (pix.blue * .11 + pix.green * .59 + pix.red *.3); 
}