0

我一直在使用 openCV 使用 ColorSegmentationAlgorithm。我完成了分割,但现在我正在按颜色收集图片上的对象。为了做到这一点,我在 RLE 中压缩了图像的“行”,并用指针相互引用。

在这一点上(我认为)一切都很好,因为我在控制台上打印了 RLE 中压缩的“集群”的结果,一切似乎都很好。然后我查看结构列表以创建一个代表对象的新变量(带有弹跳盒、质心等)。但是,问题来了,我现在不知道为什么在“随机情况”中调用指针的内容时加载错误(就像变量被转移一样):例如,如果结构具有以下内容:

(int i, int je, int js, "pointer" *child) --> {1, 1, 1, 0x0AB0231A}

它已加载 --> {1, 0x0AB0231A, 1, 1}

如果下一个“孩子”被调用,那么它会引发分段错误(核心转储)错误

所以......这是代码的一部分:

struct LineObjRLE {
    unsigned int i;
    unsigned int js;
    unsigned int je;
    unsigned int size;
    unsigned int color;
    struct LineObjRLE *parent;
    struct LineObjRLE *child;
};

struct LineObjRLE auxRLE = aRLE[i][j];
vector<struct LineObjRLE> obj;
while (1) {
    obj.push_back(auxRLE);
    printf("auxRLE: parent: %d  --  child: %d\n",
            auxRLE.parent, auxRLE.child);
    if (auxRLE.child == NULL)
        break;
    auxRLE = *auxRLE.child;
}
  • aRLE(RLE 数组)是在分割时创建的向量变量。

在这里我得到了一些结果:(指针显示为int,但它们是正确的)

---------------------------------
k: 1 
auxRLE: parent: 0  --  child: 55035088
auxRLE: parent: 55036080  --  child: 55505600
auxRLE: parent: 55035088  --  child: 0
---------------------------------
k: 2 
auxRLE: parent: 0  --  child: 55035248
auxRLE: parent: 0  --  child: 0
---------------------------------
k: 3 
auxRLE: parent: 0  --  child: 55035288
auxRLE: parent: 55036200  --  child: 55505720
auxRLE: parent: 55035288  --  child: 0
---------------------------------
k: 4 
auxRLE: parent: 0  --  child: 55035528
auxRLE: parent: 0  --  child: 55505840
auxRLE: parent: 55035528  --  child: 0
---------------------------------
k: 5 
auxRLE: parent: 0  --  child: 55035688
auxRLE: parent: 0  --  child: 0
---------------------------------
k: 6 
auxRLE: parent: 0  --  child: 55035808
auxRLE: parent: 18  --  child: 6
Segmentation fault (core dumped)

当我之前描述的“转变”发生时,就会发生分段。当我检查结构的所有内容时,我看到结构的其他变量中的指针和指针具有其他值(因此指向 6 或 18 会产生错误)。

PD:我没有保存“父母”指针,而是只使用“孩子”方向来查看结构。

我希望我能解释一下自己,有人可以帮助我。提前致谢!

代码:

    while (waitKey(1)) {

        t1 = clock(); // Time counter1
        device >> frame; // Get the frame from the camera
        imshow("Ori", frame); // Show the original frame
        //medianBlur(frame, frame, 5);
        imageBGR2HSV(&frame); // Transform image from BGR to HSV

        int n = frame.channels(); // Count the number of image's channels to use the pointer

        int color;
        short int js, colorRLE = -1, jRLE = -1; // Variables for RLE encode
        for (int i = 0; i < frame.rows; i++) {
            uchar* ptr = frame.ptr<uchar>(i); // Pointer to i row
            vector<struct LineObjRLE> temp;
            for (int j = 0; j < frame.cols; j++) {
                // Proximate the color to a cluster
                color = CS.whichColorHSV(
                        (color3cInt ) { ptr[n * j], ptr[n * j + 1], ptr[n
                                        * j + 2] });
                // RLE encoding
                if (!j) {
                    colorRLE = color;
                    jRLE = 1;
                    js = 0;
                } else {
                    if (j == frame.cols - 1) {
                        temp.push_back((LineObjRLE ) { i, js, j, j - js, color,
                                NULL, NULL });
                    } else if (color == colorRLE) {
                        jRLE = jRLE + 1;
                    } else if (color != colorRLE) {
                        temp.push_back((LineObjRLE ) { i, js, j, j - js, color,
                                NULL, NULL });
                        colorRLE = color;
                        jRLE = 1;
                        js = j;
                    }
                }
                // Change the color (Improve assigning directly the BGR color, save from using imageHSV2BGR)
                if (color != -1) {
                    ptr[n * j] = CS.ColorCluster[color].a;
                    ptr[n * j + 1] = CS.ColorCluster[color].b;
                    ptr[n * j + 2] = CS.ColorCluster[color].c;
                } else {
                    ptr[n * j] = CS.ColorCluster[0].a;
                    ptr[n * j + 1] = CS.ColorCluster[0].b;
                    ptr[n * j + 2] = CS.ColorCluster[0].c;
                }
            }
            aRLE.push_back(temp);
            if (i) { // Except the first line that can't be child of any object (only parent) start joining objects grouped in LineObjRLE variables
                unsigned int j = 0, jp = 0; // Pointer to current and previous LineObjRLE
                unsigned int pp = aRLE[i - 1][jp].size, pc = aRLE[i][j].size; // Pointer to previous and current col
                bool end = false; // Flag to manage the loop
                while (!end) {
                    if ((aRLE[i - 1][jp].je > aRLE[i][j].js
                            && aRLE[i - 1][jp].js < aRLE[i][j].je)
                            && aRLE[i - 1][jp].color == aRLE[i][j].color) {
                        aRLE[i][j].parent = &(aRLE[i - 1][jp]);
                        aRLE[i - 1][jp].child = &(aRLE[i][j]);
                        //printf("Parent is %d and says that child is: %d\n", &aRLE[i - 1][jp], aRLE[i - 1][jp].child);
                        //printf("Child is %d and says that parent is: %d\n", &aRLE[i][j], aRLE[i][j].parent);
                    }
                    if (j == aRLE[i].size() - 1 || jp == aRLE[i - 1].size() - 1)
                        end = true;
                    if (pp > pc) {
                        pc += aRLE[i][j].size;
                        j++;
                    } else {
                        pp += aRLE[i - 1][jp].size;
                        jp++;
                    }
                }
            }
        }
        // Run vertically to identifies the parents of the objects

        int k = 0; //Index for final object
        for (unsigned int i = 0; i < aRLE.size(); i++) {
            for (unsigned int j = 0; j < aRLE.at(i).size(); j++) {
                if (aRLE[i][j].parent == NULL && aRLE[i][j].child != NULL) {
                    printf("---------------------------------\n");
                    printf("k: %d \n", k);
                    printf("aRLE: parent: %d  --  child: %d\n",
                            aRLE[i][j].parent, aRLE[i][j].child);
                    // Grow from the seed
                    struct LineObjRLE auxRLE = aRLE[i][j];
                    vector<struct LineObjRLE> obj;
                    while (1) {
                        obj.push_back(auxRLE);
                        printf("auxRLE: parent: %d  --  child: %d\n",
                                auxRLE.parent, auxRLE.child);
                        if (auxRLE.child == NULL)
                            break;
                        auxRLE = *auxRLE.child;
                    }
                    k = k + 1;
                }
            }
        }

        // Calculate increment of time
        t2 = clock();
        float dif = (((float) t2 - (float) t1) / 1000000.0F) * 1000;
        printf("FINISHED IN %f \n", dif);

        imageHSV2BGR(&frame);

        imshow("Viewer", frame); // Show the image segmented
        aRLE.clear();
        objs.clear();
    }
    return 0;
}
4

1 回答 1

1

查看代码,您似乎正在将指向对象的指针存储在std::vector<RLE>. 例如,我发现:

aRLE[i][j].parent = &(aRLE[i - 1][jp]);

同时,我没有看到任何aRLE.reserve()可以确保在添加新对象时不会重新定位对象的调用。我怀疑,向量需要重新分配内存,释放已经指向的内存,你会得到一堆过时的指针。

如果您创建过时的指针,测试该理论的最简单方法是:

  • 如果您提前知道数据结构的最终大小,则可以std::vector<T>::reserve(size_type n)用来告诉数据结构分配足够的空间来容纳n元素。
  • 如果您不知道大小,但只需要看起来像数组的东西,并且只在末尾或开头追加,则可以替换std::vector<RLE>std::deque<RLE>:虽然在任一端添加对象可能会更改迭代器,但不会更改物体的位置。
于 2013-08-11T22:18:34.080 回答