C++ Can'；t在C+中找不到正确的洪水填充实施起始值+；

我正在尝试使用flood fill的队列实现来填充轮廓之外的所有内容。但是，我在推断要添加到队列的起点时遇到了一些问题

我定义了一个名为tmpSlice的400*400的新双精度函数，并用零填充它。然后我用标签值1.0映射轮廓。这部分很好用

当我必须将一个起点推到队列上时，问题就会出现。最好的情况是推到左上角或0点

但是，如果不出现分段错误，我无法将0作为起点。我目前正在推160000，这是tmpSlice的大小，这是我能够插入的唯一一个没有错误的数字。 但是，当我将160000推到队列上时，在执行洪水填充之后，我运行从0到160000的循环（在代码底部）

此循环应将值为0和1的所有内容着色为1，值为2的所有内容应为0。但目前，tmpSlice中的所有内容的值均为0，但原始轮廓的值为1

对于澄清，2表示轮廓的外部，1表示轮廓的边界，0表示轮廓的内部

所以基本上洪水填充对我的数据集tmpSlice没有任何作用。我认为这是因为在队列中插入了起始点，但我还不能插入任何有效的值

想法？ 附言 我仅限于使用新的double，因为vector:：std不能与我正在使用的minc库中的某些函数一起使用

     /* Flood fill */
     //Colour we are looking for as background
     int TargetColour = 0.0;
     //The new colour we will write
     int NewColour = 2.0;
     //create set to secure unique entries into the queue, otherwise we etc. insert the 9th element in a 3x3 array 6 times.
     set < int > Set;
     //Create queue
     queue < int > MyQue;
     //Insert first point into the queue
     MyQue.push(sizes[1]*sizes[2]);
     int Node;
     //While loop for iterating over the nodes.
     while (!MyQue.empty()){
         //Set front element to Node, and pop the front element from queue
         Node = MyQue.front();
         MyQue.pop();

         //Change the colour to newcolour
         tmpSlice[Node] = NewColour;
         //Define the Node directions
         int WestNode = Node-1;
         int EastNode = Node+1;


         //sizes are the lengths x,y
         int NorthNode = Node-sizes[1];
         int SouthNode = Node+sizes[2];

         //Boundary checks
         EastNodeBoundaryCheck = floor((Node-sizes[1]*sizes[2]*floor(Node/(sizes[1]*sizes[2])))/sizes[1]) == floor((EastNode-sizes[1]*sizes[2]*floor(EastNode/(sizes[1]*sizes[2])))/sizes[1]);
         SouthNodeBoundaryCheck = floor(Node / (sizes[1]*sizes[2])) == floor(SouthNode / (sizes[1]*sizes[2]));
         WestNodeBoundaryCheck = floor((Node-sizes[1]*sizes[2]*floor(Node/(sizes[1]*sizes[2])))/sizes[1]) == floor((WestNode-sizes[1]*sizes[2]*floor(WestNode/(sizes[1]*sizes[2])))/sizes[1]);
         NorthNodeBoundaryCheck = floor(Node / (sizes[1]*sizes[2])) == floor(NorthNode / (sizes[1]*sizes[2]));


         //East Node
         if (Set.insert(EastNode).second) {
            if (tmpSlice[EastNode] == TargetColour && EastNodeBoundaryCheck == 1){
                MyQue.push(EastNode);
             }
          }

            //South Node
         if (Set.insert(SouthNode).second) {
            if (tmpSlice[SouthNode] == TargetColour && SouthNodeBoundaryCheck == 1){
                MyQue.push(SouthNode);
            }
         }

         //West Node
         if (Set.insert(WestNode).second) {
          if (tmpSlice[WestNode] == TargetColour && WestNodeBoundaryCheck == 1){
                MyQue.push(WestNode);
           }
        }

         //North Node
         if (Set.insert(NorthNode).second) {
            if (tmpSlice[NorthNode] == TargetColour && NorthNodeBoundaryCheck == 1){
                MyQue.push(NorthNode);
                }
        }


    }

    // Insert the colored points as 0 and everything else as 1
    for(i = 0; i < sizes[1]*sizes[2]; i++){
        if(tmpSlice[i] == 0.0 || 1.0){
            slab[first_voxel_at_slice + i] = 1.0;
        }
        if(tmpSlice[i] == 2.0){
            slab[first_voxel_at_slice + i] = 0.0;
        }
 }

/*洪水填充*/
//我们正在寻找的颜色作为背景
int TARGETCOLOR=0.0；
//我们要写的新颜色
int newcolor=2.0；
//创建集合以保护队列中的唯一条目，否则我们等。在3x3数组中插入第9个元素6次。
setset；
//创建队列
队列MyQue；
//将第一个点插入队列
MyQue.push（尺寸[1]*尺寸[2]）；
int节点；
//While循环用于在节点上迭代。
而（！MyQue.empty（））{
//将前端元素设置为节点，并从队列中弹出前端元素
Node=MyQue.front（）；
MyQue.pop（）；
//把颜色换成新颜色
tmpSlice[Node]=newcolor；
//定义节点方向
int-WestNode=Node-1；
int EastNode=节点+1；
//尺寸是x，y的长度
int NorthNode=节点大小[1]；
int SouthNode=节点+大小[2]；
//边界检查
EastNodeBondaryCheck=楼层（（节点尺寸[1]*尺寸[2]*楼层（节点/（尺寸[1]*尺寸[2]））/尺寸[1]）==楼层（（EastNode尺寸[1]*尺寸[2]*楼层（EastNode/（尺寸[1]*尺寸[2]））/尺寸[1]）；
SouthNodeBoundaryCheck=楼层（节点/（尺寸[1]*尺寸[2]）==楼层（SouthNode/（尺寸[1]*尺寸[2]）；
WestNodeBondaryCheck=楼层（（节点尺寸[1]*尺寸[2]*楼层（节点/（尺寸[1]*尺寸[2]））/尺寸[1]）==楼层（（WestNode尺寸[1]*尺寸[2]*楼层（WestNode/（尺寸[1]*尺寸[2]））/尺寸[1]）；
NorthNodeBondaryCheck=楼层（节点/（尺寸[1]*尺寸[2]）==楼层（NorthNode/（尺寸[1]*尺寸[2]）；
//东节点
if（Set.insert（EastNode.second）{
如果（tmpSlice[EastNode]==targetColor&&EastNodeBondaryCheck==1）{
MyQue.push（东节点）；
}
}
//南节点
if（Set.insert（SouthNode.second）{
if（tmpSlice[SouthNode]==targetColor&&SouthNodeBondaryCheck==1）{
MyQue.push（南节点）；
}
}
//西节点
if（Set.insert（WestNode.second）{
如果（tmpSlice[WestNode]==targetColor&&WestNodeBondaryCheck==1）{
MyQue.push（WestNode）；
}
}
//北交点
if（Set.insert（NorthNode.second）{
if（tmpSlice[NorthNode]==targetColor&&NorthNodeBondaryCheck==1）{
MyQue.push（北节点）；
}
}
}
//将彩色点插入为0，其他所有点插入为1
对于（i=0；i

我在回答评论时自己找到了答案：-） 我需要检查第一行的NorthNode是否大于0，以避免分段错误

         //North Node
         if (Set.insert(NorthNode).second) {
             if (NorthNode > 0){
                 if (tmpSlice[NorthNode] == TargetColour && NorthNodeBoundaryCheck == 1){
                         MyQue.push(NorthNode);
                     }
             }
        }

---

什么类型的尺码[]？@em2er对不起，我的错。它们是int，在我的测试用例中是400和400。如果我删除

tmpSlice[NorthNode]==targetColor

，我似乎能够将0插入起点。显然，我无法检查

tmpSlice[-399]

的值，这实际上是有意义的。但是，现在轮廓的底部消失了。考虑到节点的类型是int，并且大小[]，为什么要使用

地板（节点/（大小[1]*大小[2]）

？如果int除以更大的int，则结果始终为0，否则结果将被忽略。下限用于浮点值，在您的使用方式中没有意义。@em2er，很抱歉给您带来不便，我实际上刚刚解决了它，我需要将0推到队列中，并在尝试检查值之前检查north节点是否大于0。非常感谢您让我思考尺码，这让我得到了答案：-）