C ++: OpenCV: itération rapide des pixels

Je vais essayer d'obtenir BGR valeurs à partir d'un flux de l'image de la webcam. Je suis une violation d'accès mémoire parce que je ne suis pas en utilisant le pointeur correctement dans le imbriqués pour la boucle, mais je ne sais pas ce que la syntaxe devrait être. Je ne peux pas trouver de la documentation qui est assez spécifique à l'apparence de base de la tâche que je suis en train de faire.

En plus de problèmes qu'il violation d'accès mémoire, je veux aussi être en mesure de modifier chaque pixel à la volée sans avoir à faire une copie en profondeur, mais ne savons pas ce qu'il a de la syntaxe doit être pour cela aussi.

C'est le code que j'ai pour l'instant:

int main(int argc, char** argv)
{

    int c;
    Mat img;
    VideoCapture capture(0);
    namedWindow("mainWin", CV_WINDOW_AUTOSIZE);
    bool readOk = true;

    while (capture.isOpened()) {

        readOk = capture.read(img);

        //make sure we grabbed the frame successfully 
        if (!readOk) {
            std::cout << "No frame" << std::endl;
            break;
        }

        int nChannels = img.channels();
        int nRows = img.rows;
        int nCols = img.cols * nChannels;

        if (img.isContinuous())
        {
            nCols *= nRows;
            nRows = 1;
        }

        int i, j;
        uchar r, g, b;
        for (i = 0; i < nRows; ++i)
        {
            for (j = 0; j < nCols; ++j)
            {
                r = img.ptr<uchar>(i)[nChannels*j + 2];
                g = img.ptr<uchar>(i)[nChannels*j + 1];
                b = img.ptr<uchar>(i)[nChannels*j + 0];
            }
        }

        if (!img.empty()) imshow("mainWin", img);
        c = waitKey(10);
        if (c == 27)
            break;
    }
}

source d'informationauteur user2514676

  1. 24

    Votre boucle de recherche n'est pas correct. Vous devez être seulement obtenir un pointeur vers la ligne une fois par ligne.
    Puisque les pixels sont 3 quantités de l'octet, il est plus facile de les traiter comme un Vec3b.

    Vous devriez avoir quelque chose comme

        uchar r, g, b;
    for (int i = 0; i < img.rows; ++i)
    {
        cv::Vec3b* pixel = img.ptr<cv::Vec3b>(i); //point to first pixel in row
        for (int j = 0; j < img.cols; ++j)
        {
            r = pixel[j][2];
            g = pixel[j][1];
            b = pixel[j][0];
        }
    }

    OU

        uchar r, g, b;
    for (int i = 0; i < img.rows; ++i)
    {
        uchar* pixel = img.ptr<uchar>(i);  //point to first color in row
        for (int j = 0; j < img.cols; ++j)
        {
            b = *pixel++;
            g = *pixel++;
            r = *pixel++;
        }
    }

    NOTE

    Il est assez fréquent de voir des Mat::at() utilisé pour accéder aux pixels de manière séquentielle comme:

        //DON'T DO THIS!
    uchar r, g, b;
    for (int i = 0; i < img.rows; ++i)
    {
        for (int j = 0; j < img.cols; ++j)
        {
            cv::Vec3b pixel = img.at<cv::Vec3b>(i, j); 
            r = pixel[2];
            g = pixel[1];
            b = pixel[0];
        }
    }

    Cependant de telles utilisations inappropriées.
    Pour chaque pixel de l'accès, at() besoins de calculer un index en multipliant le nombre de ligne et de longueur de ligne - et sur l'ensemble de l'image que le calcul peut entraîner des temps de traitement beaucoup plus lent qu'avec le code ci-dessus (où ptr() un équivalent de calcul une fois par ligne.
    En outre, dans le mode de débogage at() a une affirmation qui le rend beaucoup plus lent encore.

    Si vous êtes sûr qu'il n'y est pas de rembourrage entre les lignes, il est possible d'aller plus vite en éliminant l'appel à ptr(). Dans ce cas, le pixel pointeur dans la deuxième boucle ci-dessus sera, après la fin de chaque ligne, indiquer au début de la ligne suivante. Mais qui ne fonctionneront pas si votre Tapis est par exemple une certaine région de l'intérêt de certains autres Mat.

    D'autre part, si vous aviez accès à des pixels sur un mode aléatoire, plutôt que d'analyser de manière séquentielle, comme ci-dessus, at() est alors très approprié.