针对大数据的种子点生长——分块生长的策略

最新推荐文章于 2024-09-23 15:09:01 发布
最新推荐文章于 2024-09-23 15:09:01 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 图像处理 文章标签： 图像处理 三维图像 种子点生长 大数据 泛洪法

前言

　　在之前的种子点生长系列中，探讨了使用三种提取图像中内容部分种子点生长算法，分别是泛洪法、扫描线法和区段法。我们知道这三种算法在空间上都需要占用三维图像的空间以及相应的位图标记表的空间。有时，我们需要处理一些体积相当大的数据，这些数据都是内存中无法放下的，如数十数百GB的数据，想要获得其中图像内容信息，一般需要对图像进行分块生长。

　　本文使用一种比较直接的思路对数据进行分块，然后探讨分块生长时的算法逻辑以及相关的内存管理策略。

 

 

图像分块方式——Block

　　首先直观的分法是将三维图像分成若干等大小的长方体，比如长宽高分别为width、height、depth的大数据三维图像，可以人为指定一个小块的大小如subwidth、subheight、subdepth，就可以把大的三维图像切成这样相等的若干个小长方体。当然如果不是能被整除的边长最后在图像的边缘处会出现较小的长方体。这样的分块，需要保证每一块的大小是内存所能接受的，也就是说假如在内存限制的场合下只具有max的字节可供分配，那么subwidth、subheight、subdepth三者的乘积再乘以图像像素的size之后的大小一定要小于max。下图使用二维图像示意这种划分的方式：

　　在这种分块方式下，种子点生长的过程就是从块内生长到块间生长的反复的过程，下图展示了这样的一个过程：

　　大概的思路就是在块内采用种子点生长算法，在需要在相邻的块内继续寻找的时候就即时加载新的块数据，这些详细的逻辑会在下文探讨。

　　这种长方体的分块方式优点是直观，缺点是对加载新数据的方式没有进行更好的优化。在“图像数据的组织方式”这篇文章里谈到，由于三维图像都是使用一维数组来储存数据，所以在X方向的像素在数组中是相邻存储的，而Y方向连续的像素实际上在数组中相差width的距离，而Z方向连续的像素则相差width*height的距离。所以在一个尺寸为W*H*D的三维数据中，起点为(x,y, z)，尺寸为w*h*d的子长方体的数据 其实并不是在原图像的一维数组中是连续的空间。而是只有如下的区段是连续的：

(x,y,z)~(x+w-1,y,z)
(x,y+1,z)~(x+w-1,y+1,z)
...
(x,y+h-1,z)~(x+w-1,y+h-1,z)
...
(x,y+h-1,z+d-1)~(x+w-1,y+h-1,z+d-1)

 　　也就是说，假如一个从外部存储器提取文件内容的接口，要求传入需要段的起始偏移量和字节个数，那么为了填充一个子长方体，需要调用这样的接口w*d次。所以这样的分块方法其实对于加载数据的接口而言是很不友好的。所以为了照顾三维图像这种按一维数组存储的这种普遍的方式，引入了按层来分块的机制。

 

 

图像分块方式——layer

　　按层来分块其实是按Block来分块的一种特殊的方式，一个层就相当于一个长宽等于原图像长宽，但高度只是原图像高度一段的Block。当然，这样的层也要满足长宽高的乘积小于一定的值才能在内存中能够放下。所以在相同的条件下，使用Block的话小长方体的高度选择会比Layer要灵活一些。下图就是按层来对图像分块的示意图。

　　那么分层之后的种子生长过程就大概如下图的GIF所述的那样，就是一层一层的扩散了。

　　用层来代替块虽然少了灵活性，但是对于加载新块的接口来说就方便了很多，比如在一个W*H*D的三维图像中起始偏移为z，厚度为d的层，他的数据就是从（0，0，z）到（w-1，h-1，z+d-1）这个空间映射到一维数组上是一个连续的，索引从z*W*D到(z+d-1)*W*D。这样每次加载新块都只需要调用一次读取的接口就行了。无形中减少了IO增加了效率。本文主要就针对这种分层生长的方式来探讨如何进行大数据的种子点生长。

 

 

LargeImage与Layer的抽象

　　那么现在就把三维图像W*H*D数据分成若干W*H*d的层，这个d就是层的高度，当然允许最后一层厚度不足d，针对这样的层再特殊对待就是。所以先介绍使用c#实现的Layer类和LargeImage类。

　　首先是Layer类，这个类需要保存所有和一个层有关的信息，比如这个层的尺寸和偏移，当然为了方便，还可以记下这个层在所有层中的索引，层的总数。当然由于每个层在进行层内生长时需要访问位图标记表，所以在这个层里保留位图标记表的引用，当然不要初始化这个表，而是应该在首次用到这个表的时候再初始化。

复制代码 
public class Layer
{
    public int AllWidth;
    public int AllHeight;
    public int AllDepth;
    public int stz;//z起始偏移
    public int edz;//z结束偏移
    public int subDepth;
    public FlagMap3d Flag;//相应位图标记
    public int indexZ;//自己是第多少个
    public int AllLayerCount;
    public int actualDepth { get { return edz - stz + 1; } }//实际高度，考虑到最后一个层高度可能不够
    public int visitcount;
    public Layer(int allwidth, int allheight, int alldepth,int subDepth,int stz, int edz)
    {
        this.AllWidth = allwidth;
        this.AllHeight = allheight;
        this.AllDepth = alldepth;
        this.stz = stz;
        this.subDepth = subDepth;
        this.edz = edz;
        Flag = null;
        indexZ = -1;
        visitcount = 0;
    }

    public FlagMap3d GetAndInitFlag()
    {
        if (Flag != null)
            return Flag;
        else
        {
            Flag = new FlagMap3d(AllWidth,AllHeight,actualDepth);
            return Flag;
        }
    }//第一次访问时初始化
    public override string ToString()
    {
        return string.Format("[{0}*{1},{2}~{3}]", AllWidth, AllHeight, stz, edz);
    }
    public bool HasPoint(Int16Triple seed)
    {
        return seed.X >= 0 && seed.X <= AllWidth-1 && seed.Y >= 0 && seed.Y <= AllHeight-1 && seed.Z >= stz && seed.Z <= edz;
    }//检测一个点是否在该层
    public bool HasLowerLayer()
    {
        return this.indexZ > 0;
    }//检测自己上面是不是还有一层
    public bool HasUpperLayer()
    {
        return this.indexZ < AllLayerCount - 1;
    }//检测自己下面是不是还有一层
} 
复制代码

　　之后是包含这些层的LargeImage类，这个类存储了层的列表，以及三维图像的描述信息，当然不会包括三维图像的具体数据，因为这个类所表示的图像应该是足够大以至于内存放不下的。这个类同时提供了方法用于创建层。

复制代码 
public class LargeImage
{
    int width;
    int height;
    int depth;
    int subDepth;
    Layer[] layers;
    int layerCount;
    public int GetLayerCount()
    {
        return layerCount;
    }
    public int GetLayerDepth()
    {
        return subDepth;
    }
    public int GetWidth()
    {
        return width;
    }
    public int GetHeight()
    {
        return height;
    }
    public int GetDepth()
    {
        return depth;
    }
    public LargeImage(int width, int height, int depth)
    {
        this.width = width;
        this.height = height;
        this.depth = depth;
    }
    public void CreateLayers(int subDepth)
    {
        if (!(subDepth <= depth))
            throw new Exception();
        this.subDepth = subDepth;
        layerCount = (depth % subDepth == 0) ? (depth / subDepth) : (depth / subDepth + 1);
        layers = new Layer[layerCount];
        for (int k = 0; k < layerCount; k++)
        {
            Layer b = new Layer(width, height, depth, subDepth, k * subDepth,(k + 1) * subDepth - 1);
            layers[k] = b;
            layers[k].indexZ = k;
            layers[k].AllLayerCount = layerCount;
            if (layers[k].edz > depth - 1)
                layers[k].edz = depth - 1;
        }
    }
    public Layer GetLayer(int k)
    {
        if (k < 0 || k >= GetLayerCount())
            return null;
        return layers[k];
    }
    public int GetLayerIndex(Int16Triple innerPoint)
    {
        for (int k = 0; k < layerCount; k++)
        {
            Layer b = this.GetLayer(k);
            if (b.HasPoint(innerPoint))
            {
                return k;
            }
        }
        throw new Exception();
    }
}
复制代码

 

 

 

 

层内生长与边界记录

　　容易想到，整个体数据的生长结果是层内生长的结果的合集。对于用户来说，他们手上只能提供一个大的三维图像以及一个种子点Seed。假如图像不大，完全可以对三维图像采用三种种子点生长算法中的一种来获取生长后的区域。但是在图像大了之后，只有每一层的数据能依次加载入内存，而且内存里最多同时存有一层的数据，这样的话只能先对包含种子点的层进行生长，然后根据生长到的边界来判断下一步可能包含区域的层，再加载这个层的数据。这也是大数据种子点生长的主要逻辑。

　　那么下面就说明如何在层内生长中进行边界记录。层内生长可以采用泛洪法、扫描线法、区段法三种中的任何一种，但是采用任何一种，边界标记方式都是不一样的，这里笔者采用了泛洪法和区段法来实现层内生长和边界记录。

　　首先是泛洪法，为泛洪法的输入输出设置一个结构来传入其所需要的参数和存储其需要的结果，即FloodFillInput结构和FloodFillResult结构。

复制代码 
public struct FloodFillResult
{
    //public List<Int16Triple> resultPointSet;
    public int resultCount;
    public List<Int16Triple>[] boundaryRequestPoints;//存储越界点的列表 上越界点存在第0个，下越界点存第1个
    public bool GetNeedsSeekLower()
    {
        return boundaryRequestPoints[0].Count > 0;
    }//返回是否需要往上层找
    public bool GetNeedsSeekUpper()
    {
        return boundaryRequestPoints[1].Count > 0;
    }//返回是否需要往下层找
    public void Init()
    {
        boundaryRequestPoints = new List<Int16Triple>[2];
        for (int i = 0; i < 2; i++)
        {
            boundaryRequestPoints[i] = new List<Int16Triple>();
        }
        //resultPointSet = new List<Int16Triple>();
        resultCount = 0;
    }
    public void Clear()
    {
        //r//esultPointSet = 0;
        boundaryRequestPoints[0] = null;
        boundaryRequestPoints[1] = null;
    }
}
public struct FloodFillInput
{
    public byte[] data;
    public int width;
    public int height;
    public int depth;
    public FlagMap3d flag;
    public List<Int16Triple> overstepList;
    public bool recordUpper;
    public bool recordLower;
    public bool IsFirst;
    public FloodFillInput(byte[] data, int width, int height, int depth, FlagMap3d flag, List<Int16Triple> overstepList, bool recordUpper, bool recordLower, bool isfirst)
    {
        this.data = data;
        this.width = width;
        this.height = height;
        this.depth = depth;
        this.flag = flag;
        this.overstepList = overstepList;
        for (int i = 0; i < overstepList.Count; i++)
        {
            if (!(overstepList[i].X >= 0 && overstepList[i].X < width && overstepList[i].Y >= 0 && overstepList[i].Y < height && overstepList[i].Z >= 0 && overstepList[i].Z < depth))
            {
                throw new Exception();
            }
        }//确保越界点都确实在这层里
        this.recordLower = recordLower;
        this.recordUpper = recordUpper;
        this.IsFirst = isfirst;
    }
    public void Clear()
    {
        data = null;
        flag = null;
        overstepList = null;
    }
}//存储输入参数 
复制代码

　　可以看出在FloodFillResult结构中存储了边界点，即在执行泛洪过程中，检查到的超出了本层但处在更上一层或者更下一层的点。

　　下面的示意图展示了泛洪法的超出边界的点，这些点用橙色标记，他们的坐标通过转换之后就会成为新的层中的点坐标，而其中可能存在符合要求的点，就会成为新层中进行泛洪法的种子点。

　　下面的代码是层内执行泛洪法的类FloodFillBase，可以看出在需到了边界的时候在else情况里有不同于原来针对小数据泛洪法的逻辑，即将越界点进行了存储：

复制代码 
public class FloodFillBase
{
    protected int width;
    protected int height;
    protected int depth;
    protected byte[] data;
    protected FlagMap3d flagsMap;
    protected Container_Queue<Int16Triple> queue;
    //protected List<Int16Triple> result = new List<Int16Triple>();
    protected int resultCount = 0;
    public FloodFillBase()
    {
        queue = new Container_Queue<Int16Triple>();
    }
    public FloodFillResult ExecuteSeededGrow(FloodFillInput input)
    {
        queue.Clear();
        //result.Clear();
        resultCount = 0;
        this.width = input.width;
        this.height = input.height;
        this.depth = input.depth;
        this.flagsMap = input.flag;
        this.data = input.data;
        List<Int16Triple> oversteps = input.overstepList;
        FloodFillResult ret = new FloodFillResult();
        ret.Init();
        Int16Triple[] adjPoints6 = new Int16Triple[6];
        if (!input.IsFirst)
        {
            for (int i = 0; i < oversteps.Count; i++)
            {
                if (!flagsMap.GetFlagOn(oversteps[i].X, oversteps[i].Y, oversteps[i].Z) && IncludeConditionMeets(oversteps[i]))
                {
                    flagsMap.SetFlagOn(oversteps[i].X, oversteps[i].Y, oversteps[i].Z, true);
                    Process(oversteps[i]);
                    InitAdj6(adjPoints6, oversteps[i]);
                    for (int adjIndex = 0; adjIndex < 6; adjIndex++)
                    {
                        Int16Triple t = adjPoints6[adjIndex];
                        if (t.X < width && t.X >= 0 && t.Y < height && t.Y >= 0 && t.Z < depth && t.Z >= 0)
                        {
                            int indext = t.X + width * t.Y + width * height * t.Z;
                            if (!flagsMap.GetFlagOn(t.X ,t.Y ,t.Z) && IncludeConditionMeets(t))
                            {
                                flagsMap.SetFlagOn(t.X, t.Y, t.Z, true);
                                queue.Push(t);
                                Process(t);
                            }
                        }
                    }
                }//首次生长需要避免让越界种子点又重新回溯到原先的层
            }
        }
        else
        {
            //以下是第一次生长的时候种子点不需要担心回溯
            if (oversteps.Count != 1) { throw new Exception(); }
            for (int i = 0; i < oversteps.Count; i++)
            {
                if (!flagsMap.GetFlagOn(oversteps[i].X,oversteps[i].Y,oversteps[i].Z) && IncludeConditionMeets(oversteps[i]))
                {
                    flagsMap.SetFlagOn(oversteps[i].X, oversteps[i].Y, oversteps[i].Z, true);
                    queue.Push(oversteps[i]);
                    Process(oversteps[i]);
                }
            }
        }
        while (!queue.Empty())
        {
            Int16Triple p = queue.Pop();
            InitAdj6(adjPoints6, p);
            for (int adjIndex = 0; adjIndex < 6; adjIndex++)
            {
                Int16Triple t = adjPoints6[adjIndex];
                if (t.X < width && t.X >= 0 && t.Y < height && t.Y >= 0 && t.Z < depth && t.Z >= 0)
                {
                    int indext = t.X + width * t.Y + width * height * t.Z;
                    if (!flagsMap.GetFlagOn(t.X, t.Y, t.Z) && IncludeConditionMeets(t))
                    {
                        flagsMap.SetFlagOn(t.X, t.Y, t.Z, true);
                        queue.Push(t);
                        Process(t);
                    }
                }
                else
                {
                    if (input.recordLower && t.Z < 0)
                    {
                        if (t.Z != -1) { throw new Exception(); }
                        ret.boundaryRequestPoints[0].Add(t);
                        continue;
                    }
                    if (input.recordUpper && t.Z >= depth)
                    {
                        if (t.Z > depth) { throw new Exception(); }
                        ret.boundaryRequestPoints[1].Add(t);
                        continue;
                    }
                }
            }
        }
        //ret.resultPointSet = this.result;
        ret.resultCount = this.resultCount;
        return ret;
    }
    protected virtual void Process(Int16Triple t)
    {
        //result.Add(t);
        resultCount++;
    }
    protected virtual bool IncludeConditionMeets(Int16Triple t)
    {
        throw new Exception();
    }
    protected void InitAdj6(Int16Triple[] adjPoints6, Int16Triple p)
    {
        adjPoints6[0].X = p.X - 1;
        adjPoints6[0].Y = p.Y;
        adjPoints6[0].Z = p.Z;

        adjPoints6[1].X = p.X + 1;
        adjPoints6[1].Y = p.Y;
        adjPoints6[1].Z = p.Z;

        adjPoints6[2].X = p.X;
        adjPoints6[2].Y = p.Y - 1;
        adjPoints6[2].Z = p.Z;

        adjPoints6[3].X = p.X;
        adjPoints6[3].Y = p.Y + 1;
        adjPoints6[3].Z = p.Z;


        adjPoints6[4].X = p.X;
        adjPoints6[4].Y = p.Y;
        adjPoints6[4].Z = p.Z - 1;

        adjPoints6[5].X = p.X;
        adjPoints6[5].Y = p.Y;
        adjPoints6[5].Z = p.Z + 1;
    }
} 
复制代码

　　存储越界点之后，层间生长的逻辑会根据当前层生长情况来决定是否提请相邻层的数据进行生长。这里需要注意一个问题，在检测出越界点中符合纳入条件的种子点后，我们会发现这些种子点的邻域中也会含有在原来层中存在的越界点，而这些“原越界点”是在原层中已经被考察过的点，所以有必要避免重新回溯这些点，所以在第一次入队时有额外的逻辑确保这一点。下图指示这一现象：

　　其中绿色框住的点是由黑色层产生的越界点，将这些越界点在浅蓝色层进行生长，会再次访问到红色框原层的点，而这其实是不必要的，需要避免他。避免的方法就是在越界点中找到种子点后先不入队而是使用其在层内的邻域入队，这样就避免了这种回溯。

　　下面介绍层间生长的逻辑。

 

 

层间生长

　　层间生长的逻辑也十分类似与一个小的泛洪法。首先建一个用来存储参数的结构，之后就是层间生长的主逻辑。

复制代码 
public class LargeSeededGrowManager_FloodFill
{
    #region Static
    struct LayerDataAndInput
    {
        public Layer layer;
        public FloodFillInput input;
        public LayerDataAndInput(Layer layer,FloodFillInput input)
        {
            this.layer = layer;
            this.input = input;
        }
    }
    #endregion
    LargeImage image;
    Container_Stack<LayerDataAndInput> queue;
    byte[] buffer;
    FloodFillBase seedGrowExecutor;
    DataFiller dataProvider;
    public List<Int16Triple> resultSet=new List<Int16Triple>();
    public int resultCount = 0;
    public LargeSeededGrowManager_FloodFill()
    {
           
    }
    public void SetScale(int width, int height, int depth,int subDepth)
    {
        this.image = new LargeImage(width, height, depth);
        SetLayerSize(subDepth);
    }
    private void SetLayerSize(int subdepth)
    {
        image.CreateLayers(subdepth);
        buffer = new byte[image.GetWidth() * image.GetHeight() * subdepth];
    }
    public void SetExecutor(FloodFillBase grower)
    {
        this.seedGrowExecutor = grower;
    }
    public void SetDataProvider(DataFiller df)
    {
        dataProvider = df;
    }
    public void ExecuteSeededGrow(Int16Triple firstseed)
    {
        if (buffer == null||seedGrowExecutor==null||dataProvider==null)
            throw new Exception();
        queue = new Container_Stack<LayerDataAndInput>();
        Layer firstLayer = GetFirstLayer(firstseed);
        FloodFillInput firstInput = new FloodFillInput
            (buffer, firstLayer.AllWidth, firstLayer.AllHeight, firstLayer.actualDepth, firstLayer.GetAndInitFlag(), 
            new List<Int16Triple>() {ConvertGlobalCoodToLayerCoold(firstLayer,firstseed)},
            firstLayer.HasUpperLayer(),firstLayer.HasLowerLayer(),true);
        queue.Push(new LayerDataAndInput(firstLayer,firstInput));
        while (!queue.Empty())
        {
            LayerDataAndInput sgi = queue.Pop();
            Layer layer = sgi.layer;
            layer.visitcount++;
            FloodFillInput input = sgi.input;
            FillLayerData(layer);
            FloodFillResult ret1 = seedGrowExecutor.ExecuteSeededGrow(input);
            input.overstepList.Clear();
            //ConvertLayerCoordsToGlobalCoords(layer,ret1.resultPointSet);
            //resultSet.AddRange(ret1.resultPointSet);
            resultCount += ret1.resultCount;
            if (ret1.GetNeedsSeekLower())
            {
                Layer lowerlayer = image.GetLayer(layer.indexZ - 1);
                if (lowerlayer == null)
                {
                    ret1.boundaryRequestPoints[0].Clear();
                    continue;
                }
                ConvertOtherLayerCoordsToThisLayerCoords(layer,lowerlayer, ret1.boundaryRequestPoints[0]);
                FloodFillInput newinput = new FloodFillInput
                    (buffer, lowerlayer.AllWidth, lowerlayer.AllHeight, lowerlayer.actualDepth, lowerlayer.GetAndInitFlag(),
                    ret1.boundaryRequestPoints[0], lowerlayer.HasUpperLayer(), lowerlayer.HasLowerLayer(),false);
                queue.Push(new LayerDataAndInput(lowerlayer, newinput));
            }
            if (ret1.GetNeedsSeekUpper())
            {
                Layer upperlayer = image.GetLayer(layer.indexZ + 1);
                if (upperlayer == null)
                {
                    ret1.boundaryRequestPoints[1].Clear();
                    continue;
                }
                ConvertOtherLayerCoordsToThisLayerCoords(layer,upperlayer, ret1.boundaryRequestPoints[1]);
                FloodFillInput newinput = new FloodFillInput
                    (buffer, upperlayer.AllWidth, upperlayer.AllHeight, upperlayer.actualDepth, upperlayer.GetAndInitFlag(),
                    ret1.boundaryRequestPoints[1], upperlayer.HasUpperLayer(), upperlayer.HasLowerLayer(),false);
                queue.Push(new LayerDataAndInput(upperlayer, newinput));
            }
        }

    }
    private Layer GetFirstLayer(Int16Triple seed)
    {
        if(seed.X<0||seed.X>image.GetWidth()||seed.Y<0||seed.Y>image.GetHeight()||seed.Z<0||seed.Z>image.GetDepth())
            throw new Exception();
        int index=image.GetLayerIndex(seed);
        return image.GetLayer(index);
    }
    private void FillLayerData(Layer b)
    {
        dataProvider.LoadLayerData(buffer, b.stz, b.edz);
    }

    private Int16Triple ConvertGlobalCoodToLayerCoold(Layer thislayer, Int16Triple globalCoord)
    {
        return new Int16Triple(globalCoord.X, globalCoord.Y, globalCoord.Z - thislayer.stz);
    }
    private void ConvertLayerCoordsToGlobalCoords(Layer thislayer, List<Int16Triple> adjSeedList)
    {
        for (int i = 0; i < adjSeedList.Count; i++)
        {
            Int16Triple old = adjSeedList[i];
            old.Z += thislayer.stz;
            adjSeedList[i] = old;
        }
    }
    private void ConvertOtherLayerCoordsToThisLayerCoords(Layer thislayer, Layer other, List<Int16Triple> adjSeedList)
    {
        for (int i = 0; i < adjSeedList.Count; i++)
        {
            Int16Triple old = adjSeedList[i];
            old.Z += (thislayer.stz - other.stz);
            adjSeedList[i] = old;
        }
    }
} 
复制代码

　　简单的用文字来描述这样的逻辑：

  1. 首先针对已经分层完毕的图像，找到种子点所在的那一层，使用该种子点初始化泛洪法输入参数，将输入参数和相应的层放入队列
  2. 如果队列不空，进入循环
    1. 取出输入参数和层
    2. 根据层信息提请改层图像数据和标记表数据
    3. 使用输入参数和数据执行层内生长，获得生长结果
    4. 考察生长结果，若其中包含上一层越界点，则将这些越界点坐标进行转换后创建新输入参数，将其和相应层加入队列
    5. 考察生长结果，若其中包含下一层越界点，则将这些越界点坐标进行转换后创建新输入参数，将其和相应层加入队列
  3. 结束循环

　　下图使用二维图像的例子来说明层间生长，其中红色的线是层间的分割线，每一层的实点用不同的蓝色标志，而越界点使用绿色框标注，咖啡色为最初的种子点：

　　对于层间生长需要注意问题如下：

  • 一、不能将越界点直接当种子点在新层中生长，而应该从中筛选出符合纳入条件的点。
  • 二、可能有层的数据会被不止一次加载。
  • 三、每个层的位图标记表会在第一次访问该层时创建。所以没有扩散到的层永远不会有 位图标记表被初始化。
  • 四、如果认为层的位图标记表所在的空间也很可观，可以采取额外的措施将位图标记表 也进行外部存储，相应的机制本文暂不讨论。
  • 五、代码中提请数据的时机也可以进一步优化，本文中是在每个层被队列弹出后即加载 其数据，实际上可以在验证其存在有效种子点后再加载。

 

 

相应的区段法的代码

　　基于区段法的大数据生长逻辑和基于泛洪法的是一致的，不同点就是由于区段法的单位是区段而不再是点，所以泛洪法使用的越界点的概念到了区段法中就成了越界区段。相应的代码如下：

复制代码 
enum ParentDirections
{
    Y0 = 1, Y2 = 2, Z0 = 3, Z2 = 4, Non = 5
}
enum ExtendTypes
{
    LeftRequired = 1, RightRequired = 2, AllRez = 3, UnRez = 4
}
struct Span
{
    public int XLeft;
    public int XRight;
    public int Y;
    public int Z;
    public ExtendTypes Extended;
    public ParentDirections ParentDirection;
}
struct Range
{
    public int XLeft;
    public int XRight;
    public int Y;
    public int Z;
    public Range(int xleft, int xright, int y, int z)
    {
        this.XLeft = xleft;
        this.XRight = xright;
        this.Y = y;
        this.Z = z;
    }
}
struct SpanFillResult
{
    //public List<Int16Triple> resultPointSet;
    public int resultCount;
    public List<Range>[] boundaryRequestPoints;
    public bool GetNeedsSeekLower()
    {
        return boundaryRequestPoints[0].Count > 0;
    }
    public bool GetNeedsSeekUpper()
    {
        return boundaryRequestPoints[1].Count > 0;
    }
    public void Init()
    {
        boundaryRequestPoints = new List<Range>[2];
        for (int i = 0; i < 2; i++)
        {
            boundaryRequestPoints[i] = new List<Range>();
        }
        //resultPointSet = new List<Int16Triple>();
    }
    public void Clear()
    {
        //resultPointSet = null;
        boundaryRequestPoints[0] = null;
        boundaryRequestPoints[1] = null;
    }
}
struct SpanFillInput
{
    public byte[] data;
    public int width;
    public int height;
    public int depth;
    public FlagMap3d flag;
    public List<Range> spanlist;
    public Int16Triple seed;
    public bool recordUpper;
    public bool recordLower;
    public bool IsFirst;
    public SpanFillInput(byte[] data, int width, int height, int depth, FlagMap3d flag, List<Range> spanList, Int16Triple seed, bool recordUpper, bool recordLower, bool isfirst)
    {
        this.data = data;
        this.width = width;
        this.height = height;
        this.depth = depth;
        this.flag = flag;
        this.spanlist = spanList;
        this.seed = seed;
        if(spanlist!=null)
            for (int i = 0; i < spanlist.Count; i++)
            {
                if (!(spanlist[i].Y >= 0 && spanlist[i].Y < height && spanlist[i].Z >= 0 && spanlist[i].Z < depth))
                {
                    throw new Exception();
                }
            }
        this.recordLower = recordLower;
        this.recordUpper = recordUpper;
        this.IsFirst = isfirst;
    }
    public void Clear()
    {
        data = null;
        flag = null;
        spanlist = null;
    }
}
class SpanFillBase
{
    public SpanFillBase()
    {
        container = new Container_Stack<Span>();
    }
    protected BitMap3d data;
    protected FlagMap3d flagsMap;
    protected Container<Span> container;//以Span为单位的Queue或Stack容器
    //protected List<Int16Triple> result = new List<Int16Triple>();
    protected int resultCount = 0;
    public virtual SpanFillResult ExecuteSeededGrow(SpanFillInput input)
    {
        this.data = new BitMap3d(input.data, input.width, input.height, input.depth);
        flagsMap = input.flag;
        //result.Clear()
        resultCount = 0;
        container.Clear();
        SpanFillResult ret = new SpanFillResult();
        ret.Init();
        if (input.IsFirst)
        {
            Int16Triple seed = input.seed;
            Process(seed);
            flagsMap.SetFlagOn(seed.X, seed.Y, seed.Z, true);
            Span seedspan = new Span();
            seedspan.XLeft = seed.X;
            seedspan.XRight = seed.X;
            seedspan.Y = seed.Y;
            seedspan.Z = seed.Z;
            seedspan.ParentDirection = ParentDirections.Non;
            seedspan.Extended = ExtendTypes.UnRez;
            container.Push(seedspan);
        }
        else
        {
            ParentDirections p=(input.spanlist[0].Z==0)?ParentDirections.Z0:ParentDirections.Z2;
            for (int i = 0; i < input.spanlist.Count; i++)
            {
                Range r = input.spanlist[i];
                CheckRange(r.XLeft, r.XRight, r.Y,r.Z,p);
            }
        }

        while (!container.Empty())
        {
            Span span = container.Pop();
            #region AllRez
            if (span.Extended == ExtendTypes.AllRez)
            {
                if (span.ParentDirection == ParentDirections.Y2)
                {
                    if (span.Y - 1 >= 0)//[spx-spy,y-1,z]
                        CheckRange(span.XLeft, span.XRight, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Z - 1 >= 0)//[spx-spy,y,z-1]
                        CheckRange(span.XLeft, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(span.XLeft, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)//[spx-spy,y,z+1]
                        CheckRange(span.XLeft, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(span.XLeft, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Y0)
                {
                    if (span.Y + 1 < data.height)//[spx-spy,y+1,z]
                        CheckRange(span.XLeft, span.XRight, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)//[spx-spy,y,z-1]
                        CheckRange(span.XLeft, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(span.XLeft, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)//[spx-spy,y,z+1]
                        CheckRange(span.XLeft, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(span.XLeft, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0, ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z2)
                {
                    if (span.Y - 1 >= 0)//[spx-spy,y-1,z]
                        CheckRange(span.XLeft, span.XRight, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)//[spx-spy,y+1,z]
                        CheckRange(span.XLeft, span.XRight, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)//[spx-spy,y,z-1]
                        CheckRange(span.XLeft, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(span.XLeft, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2 ,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z0)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(span.XLeft, span.XRight, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(span.XLeft, span.XRight, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z + 1 < data.depth)
                        CheckRange(span.XLeft, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(span.XLeft, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                throw new Exception();
            }
            #endregion
            #region UnRez
            if (span.Extended == ExtendTypes.UnRez)
            {
                int xl = FindXLeft(span.XLeft, span.Y, span.Z);
                int xr = FindXRight(span.XRight, span.Y, span.Z);
                if (span.ParentDirection == ParentDirections.Y2)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(xl, xr, span.Y - 1, span.Z, ParentDirections.Y2);
                    if (span.Y + 1 < data.height)
                    {
                        if (xl != span.XLeft)
                            CheckRange(xl, span.XLeft, span.Y + 1, span.Z, ParentDirections.Y0);
                        if (span.XRight != xr)
                            CheckRange(span.XRight, xr, span.Y + 1, span.Z, ParentDirections.Y0);
                    }
                    if (span.Z - 1 >= 0)
                        CheckRange(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Y0)
                {
                    if (span.Y + 1 < data.height)
                        CheckRange(xl, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Y - 1 >= 0)
                    {
                        if (xl != span.XLeft)
                            CheckRange(xl, span.XLeft, span.Y - 1, span.Z, ParentDirections.Y2);
                        if (span.XRight != xr)
                            CheckRange(span.XRight, xr, span.Y - 1, span.Z, ParentDirections.Y2);
                    }

                    if (span.Z - 1 >= 0)
                        CheckRange(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z2)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(xl, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(xl, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                        CheckRange(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                    {
                        if (xl != span.XLeft)
                            CheckRange(xl, span.XLeft, span.Y, span.Z + 1, ParentDirections.Z0);
                        if (span.XRight != xr)
                            CheckRange(span.XRight, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    }
                    else
                    {
                            if (xl != span.XLeft)
                                OnOverstepSpanFound(xl, span.XLeft, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                            if (span.XRight != xr)
                                OnOverstepSpanFound(span.XRight, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    }
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z0)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(xl, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(xl, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                    {
                        if (xl != span.XLeft)
                            CheckRange(xl, span.XLeft, span.Y, span.Z - 1, ParentDirections.Z2);
                        if (span.XRight != xr)
                            CheckRange(span.XRight, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    }
                    else
                    {
                            if (xl != span.XLeft)
                            OnOverstepSpanFound(xl, span.XLeft, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);
                        if (span.XRight != xr)
                            OnOverstepSpanFound(span.XRight, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);
                    }

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0, ref ret);

                    continue;
                }
                if (span.ParentDirection == ParentDirections.Non)
                {
                    if (span.Y + 1 < data.height)
                        CheckRange(xl, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Y - 1 >= 0)
                        CheckRange(xl, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Z - 1 >= 0)
                        CheckRange(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                throw new Exception();
            }
            #endregion
            #region LeftRequired
            if (span.Extended == ExtendTypes.LeftRequired)
            {
                int xl = FindXLeft(span.XLeft, span.Y, span.Z);
                if (span.ParentDirection == ParentDirections.Y2)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(xl, span.XRight, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height && xl != span.XLeft)
                        CheckRange(xl, span.XLeft, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                        CheckRange(xl, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Y0)
                {
                    if (span.Y - 1 >= 0 && xl != span.XLeft)
                        CheckRange(xl, span.XLeft, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(xl, span.XRight, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                        CheckRange(xl, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z2)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(xl, span.XRight, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(xl, span.XRight, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                        CheckRange(xl, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(xl, span.XRight, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth && xl != span.XLeft)
                        CheckRange(xl, span.XLeft, span.Y, span.Z + 1, ParentDirections.Z0);
                    else if(xl != span.XLeft) OnOverstepSpanFound(xl, span.XLeft, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z0)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(xl, span.XRight, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(xl, span.XRight, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0 && xl != span.XLeft)
                        CheckRange(xl, span.XLeft, span.Y, span.Z - 1, ParentDirections.Z2);
                    else if( xl != span.XLeft) OnOverstepSpanFound(xl, span.XLeft, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(xl, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(xl, span.XRight, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                throw new Exception();
            }
            #endregion
            #region RightRequired
            if (span.Extended == ExtendTypes.RightRequired)
            {
                int xr = FindXRight(span.XRight, span.Y, span.Z);

                if (span.ParentDirection == ParentDirections.Y2)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(span.XLeft, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height && span.XRight != xr)
                        CheckRange(span.XRight, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                        CheckRange(span.XLeft, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(span.XLeft, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(span.XLeft, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(span.XLeft, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }

                if (span.ParentDirection == ParentDirections.Y0)
                {
                    if (span.Y + 1 < data.height)
                        CheckRange(span.XLeft, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Y - 1 >= 0 && span.XRight != xr)
                        CheckRange(span.XRight, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Z - 1 >= 0)
                        CheckRange(span.XLeft, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(span.XLeft, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(span.XLeft, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(span.XLeft, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z2)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(span.XLeft, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(span.XLeft, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0)
                        CheckRange(span.XLeft, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else OnOverstepSpanFound(span.XLeft, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth && span.XRight != xr)
                        CheckRange(span.XRight, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else if(span.XRight != xr) OnOverstepSpanFound(span.XRight, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                if (span.ParentDirection == ParentDirections.Z0)
                {
                    if (span.Y - 1 >= 0)
                        CheckRange(span.XLeft, xr, span.Y - 1, span.Z, ParentDirections.Y2);

                    if (span.Y + 1 < data.height)
                        CheckRange(span.XLeft, xr, span.Y + 1, span.Z, ParentDirections.Y0);

                    if (span.Z - 1 >= 0 && span.XRight != xr)
                        CheckRange(span.XRight, xr, span.Y, span.Z - 1, ParentDirections.Z2);
                    else if( span.XRight != xr) OnOverstepSpanFound(span.XRight, xr, span.Y, span.Z - 1, ParentDirections.Z2,ref ret);

                    if (span.Z + 1 < data.depth)
                        CheckRange(span.XLeft, xr, span.Y, span.Z + 1, ParentDirections.Z0);
                    else OnOverstepSpanFound(span.XLeft, xr, span.Y, span.Z + 1, ParentDirections.Z0,ref ret);
                    continue;
                }
                throw new Exception();
            }
            #endregion
        }
        //ret.resultPointSet = this.result;
        ret.resultCount = this.resultCount;
        return ret;
    }
    protected void CheckRange(int xleft, int xright, int y, int z, ParentDirections ptype)
    {
        for (int i = xleft; i <= xright; )
        {
            if ((!flagsMap.GetFlagOn(i, y, z)) && IncludeConditionMeets(i, y, z))
            {
                int lb = i;
                int rb = i + 1;
                while (rb <= xright && (!flagsMap.GetFlagOn(rb, y, z)) && IncludeConditionMeets(rb, y, z))
                {
                    rb++;
                }
                rb--;

                Span span = new Span();
                span.XLeft = lb;
                span.XRight = rb;
                span.Y = y;
                span.Z = z;
                if (lb == xleft && rb == xright)
                {
                    span.Extended = ExtendTypes.UnRez;
                }
                else if (rb == xright)
                {
                    span.Extended = ExtendTypes.RightRequired;
                }
                else if (lb == xleft)
                {
                    span.Extended = ExtendTypes.LeftRequired;
                }
                else
                {
                    span.Extended = ExtendTypes.AllRez;
                }
                span.ParentDirection = ptype;
                for (int j = lb; j <= rb; j++)
                {
                    flagsMap.SetFlagOn(j, y, z, true);
                    Process(new Int16Triple(j, y, z));
                }
                container.Push(span);

                i = rb + 1;
            }
            else
            {
                i++;
            }
        }
    }//区段法的CheckRange 注意与扫描线的CheckRange的不同
    protected int FindXRight(int x, int y, int z)
    {
        int xright = x + 1;
        while (true)
        {
            if (xright == data.width || flagsMap.GetFlagOn(xright, y, z))
            {
                break;
            }
            else
            {
                if (IncludeConditionMeets(xright, y, z))
                {
                    Int16Triple t = new Int16Triple(xright, y, z);
                    flagsMap.SetFlagOn(xright, y, z, true);
                    Process(t);
                    xright++;
                }
                else
                {
                    break;
                }
            }
        }
        return xright - 1;
    }
    protected int FindXLeft(int x, int y, int z)
    {
        int xleft = x - 1;
        while (true)
        {
            if (xleft == -1 || flagsMap.GetFlagOn(xleft, y, z))
            {
                break;
            }
            else
            {
                if (IncludeConditionMeets(xleft, y, z))
                {
                    Int16Triple t = new Int16Triple(xleft, y, z);
                    flagsMap.SetFlagOn(xleft, y, z, true);
                    Process(t);
                    xleft--;
                }
                else
                {
                    break;
                }
            }
        }
        return xleft + 1;
    }
    protected virtual bool IncludeConditionMeets(int x, int y, int z)
    {
        throw new Exception();
        //byte v = bmp.GetPixel(x, y, z);
        //return v > min && v < max;
    }
    protected virtual void Process(Int16Triple p)
    {
        resultCount++;
        // result.Add(p);
    }
    protected void OnOverstepSpanFound(int xleft, int xright, int y, int z, ParentDirections ptype,ref SpanFillResult ret)
    {
        if (z == -1)
        {
            Range r = new Range(xleft, xright, y, z);
            ret.boundaryRequestPoints[0].Add(r);
        }
        else if (z == data.depth)
        {
            Range r = new Range(xleft, xright, y, z);
            ret.boundaryRequestPoints[1].Add(r);
        }
        else
            throw new Exception();
    }
}
复制代码
复制代码 
class LargeSeededGrowManager_SpanFill
{
    #region Static
    struct LayerDataAndInput
    {
        public Layer layer;
        public SpanFillInput input;
        public LayerDataAndInput(Layer layer, SpanFillInput input)
        {
            this.layer = layer;
            this.input = input;
        }
    }
    #endregion
    LargeImage image;
    Container_Stack<LayerDataAndInput> queue;
    byte[] buffer;
    SpanFillBase seedGrowExecutor;
    DataFiller dataProvider;
    //public List<Int16Triple> resultSet=new List<Int16Triple>();
    public int resultCount = 0;
    public LargeSeededGrowManager_SpanFill()
    {
           
    }
    public void SetScale(int width, int height, int depth,int subDepth)
    {
        this.image = new LargeImage(width, height, depth);
        SetLayerSize(subDepth);
    }
    private void SetLayerSize(int subdepth)
    {
        image.CreateLayers(subdepth);
        buffer = new byte[image.GetWidth() * image.GetHeight() * subdepth];
    }
    public void SetExecutor(SpanFillBase grower)
    {
        this.seedGrowExecutor = grower;
    }
    public void SetDataProvider(DataFiller df)
    {
        dataProvider = df;
    }
    public void ExecuteSeededGrow(Int16Triple firstseed)
    {
        if (buffer == null||seedGrowExecutor==null||dataProvider==null)
            throw new Exception();
        queue = new Container_Stack<LayerDataAndInput>();
        Layer firstLayer = GetFirstLayer(firstseed);
        SpanFillInput firstInput = new SpanFillInput
            (buffer, firstLayer.AllWidth, firstLayer.AllHeight, firstLayer.actualDepth, firstLayer.GetAndInitFlag(),
            new List<Range>(), ConvertGlobalCoodToLayerCoold(firstLayer,firstseed), firstLayer.HasUpperLayer(), firstLayer.HasLowerLayer(), true);
        queue.Push(new LayerDataAndInput(firstLayer,firstInput));
        while (!queue.Empty())
        {
            LayerDataAndInput sgi = queue.Pop();
            Layer layer = sgi.layer;
            layer.visitcount++;
            SpanFillInput input = sgi.input;
            FillLayerData(layer);
            SpanFillResult ret1 = seedGrowExecutor.ExecuteSeededGrow(input);
            input.spanlist.Clear();
            //ConvertLayerCoordsToGlobalCoords(layer,ret1.resultPointSet);
            // resultSet.AddRange(ret1.resultPointSet);
            resultCount += ret1.resultCount;
            if (ret1.GetNeedsSeekLower())
            {
                Layer lowerlayer = image.GetLayer(layer.indexZ - 1);
                if (lowerlayer == null)
                {
                    ret1.boundaryRequestPoints[0].Clear();
                    continue;
                }
                ConvertOtherLayerCoordsToThisLayerCoords(layer,lowerlayer, ret1.boundaryRequestPoints[0]);
                SpanFillInput newinput = new SpanFillInput
                    (buffer, lowerlayer.AllWidth, lowerlayer.AllHeight, lowerlayer.actualDepth, lowerlayer.GetAndInitFlag(),
                    ret1.boundaryRequestPoints[0],input.seed,lowerlayer.HasUpperLayer(), lowerlayer.HasLowerLayer(),false);
                queue.Push(new LayerDataAndInput(lowerlayer, newinput));
            }
            if (ret1.GetNeedsSeekUpper())
            {
                Layer upperlayer = image.GetLayer(layer.indexZ + 1);
                if (upperlayer == null)
                {
                    ret1.boundaryRequestPoints[1].Clear();
                    continue;
                }
                ConvertOtherLayerCoordsToThisLayerCoords(layer, upperlayer, ret1.boundaryRequestPoints[1]);
                SpanFillInput newinput = new SpanFillInput
                    (buffer, upperlayer.AllWidth, upperlayer.AllHeight, upperlayer.actualDepth, upperlayer.GetAndInitFlag(),
                    ret1.boundaryRequestPoints[1],input.seed, upperlayer.HasUpperLayer(), upperlayer.HasLowerLayer(),false);
                queue.Push(new LayerDataAndInput(upperlayer, newinput));
            }
        }

    }
    private Layer GetFirstLayer(Int16Triple seed)
    {
        if(seed.X<0||seed.X>image.GetWidth()||seed.Y<0||seed.Y>image.GetHeight()||seed.Z<0||seed.Z>image.GetDepth())
            throw new Exception();
        int index=image.GetLayerIndex(seed);
        return image.GetLayer(index);
    }
    private void FillLayerData(Layer b)
    {
        dataProvider.LoadLayerData(buffer, b.stz, b.edz);
    }
    private Int16Triple ConvertGlobalCoodToLayerCoold(Layer thislayer, Int16Triple globalCoord)
    {
        return new Int16Triple(globalCoord.X, globalCoord.Y, globalCoord.Z - thislayer.stz);
    }
    private void ConvertLayerCoordsToGlobalCoords(Layer thislayer, List<Int16Triple> adjSeedList)
    {
        for (int i = 0; i < adjSeedList.Count; i++)
        {
            Int16Triple old = adjSeedList[i];
            old.Z += thislayer.stz;
            adjSeedList[i] = old;
        }
    }
    private void ConvertOtherLayerCoordsToThisLayerCoords(Layer thislayer, Layer other, List<Range> adjSeedList)
    {
        for (int i = 0; i < adjSeedList.Count; i++)
        {
            Range old = adjSeedList[i];
            old.Z += (thislayer.stz - other.stz);
            adjSeedList[i] = old;
        }
    }

}
复制代码

 

 

 

算法正确性测试

　　由于笔者的测试条件有限，没办法进行真实大数据的测试，所以采用了模拟数据的方式，主要目的是为了验证算法的正确性。

　　算法采用了Lobster数据和Engine数据，分别是泛洪法，泛洪分割生长，区段法，区段法分割生长，测试结果的截图如下图所示：

　　本算法的代码可以从https://github.com/chnhideyoshi/SeededGrow2d下载。

FreemanLu
关注
专栏目录
大数据平台建设关键技术
leveretz的博客
02-22 8623
平台关键技术设计 架构风格 云计算 Google在2006年率先提出“云计算”的概念。所谓“云计算”，是一种大规模的分布式模型，通过网络将抽象的､可伸缩的､便于管理的数据能源､服务､存储方式等传递给终端用户。狭义云计算是指IT基础设施的交付和使用模式，指通过网络以按照需求量的方式和易扩展的方式获得所需资源。广义云计算指服务交付和使用模式，指通过网络以按照需求量和易扩展方式获得所需服务。 目前，云计算可以认为包含3个层次的内容：基础设施即服务（IaaS）､平台即服务（PaaS）和软件即服务（Sa.
分布式计算、云计算与大数据
weixin_45956703的博客
12-03 1898
分布式计算 定义： 分布式计算是研究把一个需要非常巨大的计算能力解决的问题分成许多小的部分，然后把这些部分分配给许多计算机进行处理，最后把各部分的计算结果合并起来得到的最终成果（分而治之）。 分布式计算的优缺点： 优点： 1、低廉的计算机价格和网络访问的可用性 2、资源共享 3、可伸缩性 4、容错性 缺点： 1、多点故障 2、安全性低 分布式计算的相关形式： 1、单机计算：利用单台计算机进行计算，...
改进的种子区域生长算法
05-23
站里这方面资源不多，特别是种子区域生长方面的很少，上传一个算一个吧
种子点生长算法（上）——二维种子点生长
qq_36955294的博客
12-10 4059
本文只用作笔记，方便日后查阅。 种子点生长算法上——二维种子点生长 　　下文提到的种子点生长算法，包括泛洪法，扫描线法，区段法三种。文本先从最简单的泛洪法入手介绍种子点生长算法的相关概念。之后进一步讨论了扫描线法和区段法，同时提供了实验数据验证其中的一些结论。本文按照如下的结构来介绍： 泛洪法 扫描线法 区段法 算法分析对比以及实验 一、泛洪法 　　1.简介 　　泛洪法，又叫Floodfill算法，属于图像处理算法，是从图像中寻找连通区域的经典算法。因其思路类似洪水从一个区域扩散到所有能.
三维种子点生长算法（以及Python递归深度问题）
咸鱼的技术博客
11-27 1385
通常在二维中有8邻域方法，三维中有6邻域与26邻域方法。本文实现了三维种子点生长的6邻域算法。种子点生长算法本质上是对图像的连通部分进行遍历，因此可以分别利用深度优先搜索与广度优先搜索的图遍历算法实现。其中，，当三维图形较大的时候，随着递归层数的加深，计算机堆栈区内存不足会导致程序无法继续，两种算法的都是高效的图遍历算法，都可以的遍历。
泛洪法与SMC算法的综合使用
u013339596的专栏
02-13 3051
前言 　　本文是继承自之前的种子点生长系列文章和网格生成算法系列文章，主要介绍一种综合两类算法的思路的方法，实现了对种子生长区域的较为快速的网格生成，算法中大量使用查找表来实现代码的简化和运行效率的提高。本文介绍的方法采用了泛洪法结合SMC算法来实现对单联通区域的网格生成。这两种方法的结合具有一定的代表性。   单联通区域的网格生成 　　根据之前的文章介绍可以知道，种子
区域生长算法，种子点选取
04-14
区域生长种子点选取，种子点变换生长，种子点变换生长，种子点变换生长，种子点变换生长，种子点变换生长，种子点变换生长，种子点变换生长
Oracle——多表查询
JAVA之迷
07-23 715
本次预计讲解的知识点 1、 多表查询的操作、限制、笛卡尔积的问题； 2、 统计函数及分组统计的操作； 3、 子查询的操作，并且结合限定查询、数据排序、多表查询、统计查询一起完成各个复杂查询的操作； 一、多表查询的基本概念 在之前所使用的查询操作之中，都是从一张表之中查询出所需要的内容，那么如果现在一个查询语句需要显示多张表的数据，则就必须应用到多表查询的操作，而多表查询的语法如下：
Elasticsearch技术解析与实战
最新发布
modouwu的博客
09-23 588
启动发现当Elasticsearch节点启动时，它会尝试连接到配置中的种子节点列表中的每个节点。如果节点是首次启动或需要加入一个新的集群，它会通过种子节点列表来发现集群中的其他节点。Ping操作节点之间通过Ping操作来确认彼此的存在和状态。Elasticsearch会定期向集群中的其他节点发送Ping请求，以检测节点是否仍然在线。构建集群视图通过Ping操作，每个节点都能构建出集群的完整视图，包括集群中所有节点的信息。
三维区域生长
01-23
区域生长（region growing）是指将成组的像素或区域发展成更大区域的过程。从种子点的集合开始，从这些点的区域增长是通过将与每个种子点有相似属性像强度、灰度级、纹理颜色等的相邻像素合并到此区域。
算法介绍 | 泛洪算法（Flood fill Algorithm）
Eason_Y的博客
11-10 6942
图像分割经典算法--《泛洪算法》（Flood Fill）
图像分割经典算法--《泛洪算法》（Flood Fill）
热门推荐
mmm_jsw的博客
11-04 1万+
1.算法介绍 泛洪算法——Flood Fill，（也称为种子填充——Seed Fill）是一种算法，用于确定连接到多维数组中给定节点的区域。 它被用在油漆程序的“桶”填充工具中，用于填充具有不同颜色的连接的，颜色相似的区域，并且在诸如围棋（Go）和扫雷（Minesweeper）之类的游戏中用于确定哪些块被清除。泛洪算法的基本原理就是从一个像素点出发，以此向周边的像素点扩充着色，直到图形的边界。 ...
种子点生长算法上——二维种子点生长
u013339596的专栏
02-13 3296
下文提到的种子点生长算法，包括泛洪法，扫描线法，区段法三种。文本先从最简单的泛洪法入手介绍种子点生长算法的相关概念。之后进一步讨论了扫描线法和区段法，同时提供了实验数据验证其中的一些结论。本文按照如下的结构来介绍： 泛洪法扫描线法区段法算法分析对比以及实验 一、泛洪法 　　1.简介 　　泛洪法，又叫Floodfill算法，属于图像处理算法，是从图像中寻找连通区域的经典算法。
HDFS块分配策略
breakout_alex的博客
07-24 1133
HDFS块分配策略 注：上图提到的远程机架与本地机架是相对于找到的第一个副本的目标节点来说。 一个客户端a机器发起请求分配块请求，NN接收到请求后，执行如下块分配流程： 1）如果a不是一个DataNode，则在集群范围内随机选择一个节点作为目标节点，否则执行下面的2,3步骤； 2）判断a机器是否符合存储数据块的目标节点，如果符合，第一个块副本分配完毕； 3）如果a机器不符合作为目标节点，则在于与a机器同机架范围内寻找，如果找到目标节点，第一个块副本分配完毕； 4）如果在同一个机架内...
种子点生长算法下——三维种子点生长
u013339596的专栏
02-13 4026
上一篇文章“二维种子点生长研究”介绍了二维种子点生长，对于平面图像，二维种子点生长其实很容易理解，其典型应用是“油漆桶”。例如在一个具有多片联通区域的二维图上，我们能用油漆桶寻找所需要的单片联通区域。 　　至于三维种子点生长，其目的与二维种子点生长一样，都是要找出图像中的联通区域。三维图像由于其多了一维，所以三维的联通区域就不太好用二维图片来查看了。关于三位图片的介绍可以参考第一篇“
RAG的5种文本分块策略#Text Splitting
shadowcz007的博客
01-16 6261
你是否曾经尝试将一段很长的文本输入ChatGPT，却被告知文本太长了？或者你是否试图让你的应用程序具有更好的长期记忆，但效果还不够好？提高大语言模型性能的一个有效的策略是将大型数据分割成较小的部分。这个过程被称为分割或分块（Text Splitting）。在这个教程中，介绍了文本分割的5种方法。我阅读后做了些精简，分享给大家，原文可以文末查看原链接。Text Splitting文本分割的方法方法...
【OpenCv】图像分割——分水岭算法
weixin_53598445的博客
03-25 8601
文章目录1 原理2 算法改进3 API4 实例 1 原理   分水岭分割方法，是一种基于拓扑理论的数学形态学的分割方法，其基本思想是把图像看作是测地学上的拓扑地貌，图像中每一点像素的灰度值表示该点的海拔高度，每一个局部极小值及其影响区域称为集水盆，而集水盆的边界则形成分水岭。分水岭的概念和形成可以通过模拟浸入过程来说明。在每一个局部极小值表面，刺穿一个小孔，然后把整个模型慢慢浸入水中，随着浸入的加深，每一个局部极小值的影响域慢慢向外扩展，在两个集水盆汇合处构筑大坝，即形成分水岭。这种方法也称作泛洪法，对应的
区域生长法快速入门，不带种子点的选取
青山渺渺
05-05 4614
这里实现的区域生长法，是最原始的区域生长法，基本原理是判断像素点的强度值是和种子点的强度值差是否小于阈值，如果小于阈值则被标记。 实现过程中利用了栈的先进后出的思想，将8邻域中符合生长要求的点压入栈，然后依次取出，然后在取出的点的基础上对8邻域再次进行生长。 学习部分 1、获取像素点坐标值 分成两种，第一种是利用指针来取值的，第二种是利用点来访问强度值的，可以使用pt点，也可以使用x，y的...
浅读K-means
weixin_30606461的博客
09-06 111
百度百科释义为 　　K-means算法是硬聚类算法，是典型的基于原型的目标函数聚类方法的代表，它是数据点到原型的某种距离作为优化的目标函数，利用函数求极值的方法得到迭代运算的调整规则。K-means算法以欧式距离作为相似度测度，它是求对应某一初始聚类中心向量V最优分类，使得评价指标J最小。算法采用误差平方和准则函数作为聚类准则函数。 　　在数据挖掘中，K-Means算法是一种cluste...
提升小波与动态两阈值分块角点检测算法
本文提出了一种新颖的角点检测算法，该算法结合了提升小波变换和动态两阈值分块策略，以提高运算速度和角点定位的准确性。提升小波变换是一种高效的小波分解方法，相比于传统的小波变换，提升小波在计算上更为快速且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值