Beispiel #1
0
        protected int FindXLeft(int x, int y, int z)
        {
            int xleft = x - 1;

            while (true)
            {
                if (xleft == -1 || flagsMap.GetFlagOn(xleft, y, z))
                {
                    if (xleft == -1)
                    {
                        OnOverstepX0PointFound(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);
        }
 private Block GetFirstBlock(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();
     Int16Triple index = image.GetBlockIndex(seed);
     return image.GetBlock(index.X, index.Y, index.Z);
 }
Beispiel #3
0
        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;
        }
Beispiel #4
0
        public Mesh GenerateSurface()
        {
            d  = bmp.depth;
            h  = bmp.height;
            w  = bmp.width;
            wh = w * h;
            Int16Triple[] temp = new Int16Triple[8];
            Mesh          m    = new Mesh();

            OriginalTriangle[]      tempTriangles = new OriginalTriangle[4];
            SMCTriangleNetHashTable hash          = new SMCTriangleNetHashTable(0, 0, w, h);

            for (int k = 0; k <= d - 1; k++)
            {
                for (int j = 0; j <= h - 1; j++)
                {
                    for (int i = 0; i <= w - 1; i++)
                    {
                        byte value = GetConfig(temp, bmp, i, j, k);
                        if (value == 0 || value == 255)
                        {
                            continue;
                        }
                        int tcount = ExtractTriangles(temp, value, i, j, k, tempTriangles);
                        for (int tindex = 0; tindex < tcount; tindex++)
                        {
                            MergeTriangleIntoMesh(m, hash, tempTriangles[tindex]);
                        }
                    }
                }
                hash.IncreaseIndex();
            }
            return(m);
        }
Beispiel #5
0
        }//get copnfig

        private void ExtractTriangles(ref Cube cube, byte value, MeshBuilder_FloatVertex builder)
        {
            if (MCTable.TriTable[value, 0] != -1)
            {
                int index = 0;
                while (MCTable.TriTable[value, index] != -1)
                {
                    int e0index = MCTable.TriTable[value, index];
                    int e1index = MCTable.TriTable[value, index + 1];
                    int e2index = MCTable.TriTable[value, index + 2];

                    Int16Triple e0p0 = cube.cubeImageIndices[Cube.EdgeIndexToEdgeVertexIndex[e0index, 0]];
                    Int16Triple e0p1 = cube.cubeImageIndices[Cube.EdgeIndexToEdgeVertexIndex[e0index, 1]];

                    Int16Triple e1p0 = cube.cubeImageIndices[Cube.EdgeIndexToEdgeVertexIndex[e1index, 0]];
                    Int16Triple e1p1 = cube.cubeImageIndices[Cube.EdgeIndexToEdgeVertexIndex[e1index, 1]];

                    Int16Triple e2p0 = cube.cubeImageIndices[Cube.EdgeIndexToEdgeVertexIndex[e2index, 0]];
                    Int16Triple e2p1 = cube.cubeImageIndices[Cube.EdgeIndexToEdgeVertexIndex[e2index, 1]];

                    Point3d e0pm = GetIntersetedPoint(e0p0, e0p1);
                    Point3d e1pm = GetIntersetedPoint(e1p0, e1p1);
                    Point3d e2pm = GetIntersetedPoint(e2p0, e2p1);

                    builder.AddTriangle(e0pm, e1pm, e2pm);

                    index += 3;
                }
            }
        }//extract triangles and put them into mesh builder
Beispiel #6
0
        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 (IncludePredicate(xleft, y, z))
                    {
                        Int16Triple t = new Int16Triple(xleft, y, z);
                        flagsMap.SetFlagOn(xleft, y, z, true);
                        Process(t);
                        xleft--;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return(xleft + 1);
        }
Beispiel #7
0
        }//区段法的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))
                {
                    if (xright == data.width)
                    {
                        OnOverstepX2PointFound(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);
        }
Beispiel #8
0
 protected virtual void ExcuteFloodFill(BitMap3d data, Int16Triple seed)
 {
     this.bmp = data;
     data.ResetVisitCount();
     flagsMap = new FlagMap3d(data.width, data.height, data.depth);
     Int16Triple[] adjPoints6 = new Int16Triple[6];
     flagsMap.SetFlagOn(seed.X, seed.Y, seed.Z, true);
     container.Push(seed);
     Process(seed);
     while (!container.Empty())
     {
         Int16Triple p = container.Pop();
         InitAdj6(ref adjPoints6, ref p);
         for (int adjIndex = 0; adjIndex < 6; adjIndex++)
         {
             Int16Triple t = adjPoints6[adjIndex];
             if (t.X < data.width && t.X >= 0 && t.Y < data.height && t.Y >= 0 && t.Z < data.depth && t.Z >= 0)
             {
                 if (!flagsMap.GetFlagOn(t.X, t.Y, t.Z) && IncludePredicate(t))
                 {
                     flagsMap.SetFlagOn(t.X, t.Y, t.Z, true);
                     container.Push(t);
                     Process(t);
                 }
             }
         }
     }
     return;
 }
Beispiel #9
0
        }//区段法的CheckRange 注意与扫描线的CheckRange的不同

        protected int FindXRight(int x, int y, int z)
        {
            int xright = x + 1;

            while (true)
            {
                if (xright == bmp.width || flagsMap.GetFlagOn(xright, y, z))
                {
                    break;
                }
                else
                {
                    if (IncludePredicate(xright, y, z))
                    {
                        Int16Triple t = new Int16Triple(xright, y, z);
                        flagsMap.SetFlagOn(xright, y, z, true);
                        Process(t);
                        xright++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return(xright - 1);
        }
        }//CheckRange操作

        protected int FindXLeft(Int16Triple p)
        {
            int xleft = p.X - 1;

            while (true)
            {
                if (xleft == -1 || flagsMap.GetFlagOn(xleft, p.Y, p.Z))
                {
                    break;
                }
                else
                {
                    byte value = bmp.GetPixel(xleft, p.Y, p.Z);
                    if (IncludePredicate(xleft, p.Y, p.Z))
                    {
                        Int16Triple t = new Int16Triple(xleft, p.Y, p.Z);
                        flagsMap.SetFlagOn(xleft, p.Y, p.Z, true);
                        Process(t);
                        xleft--;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return(xleft + 1);
        }//FindXLeft操作
 protected virtual void ExcuteScanlineFill(BitMap3d data, Int16Triple seed)
 {
     this.bmp = data;
     data.ResetVisitCount();
     flagsMap = new FlagMap3d(data.width, data.height, data.depth);
     flagsMap.SetFlagOn(seed.X, seed.Y, seed.Z, true);
     container.Push(seed);
     Process(seed);
     while (!container.Empty())
     {
         Int16Triple p      = container.Pop();
         int         xleft  = FindXLeft(p);
         int         xright = FindXRight(p);
         if (p.Y - 1 >= 0)
         {
             CheckRange(xleft, xright, p.Y - 1, p.Z);
         }
         if (p.Y + 1 < data.height)
         {
             CheckRange(xleft, xright, p.Y + 1, p.Z);
         }
         if (p.Z - 1 >= 0)
         {
             CheckRange(xleft, xright, p.Y, p.Z - 1);
         }
         if (p.Z + 1 < data.depth)
         {
             CheckRange(xleft, xright, p.Y, p.Z + 1);
         }
     }
 }//该函数为扫描线法主体
        }//FindXLeft操作

        protected int FindXRight(Int16Triple p)
        {
            int xright = p.X + 1;

            while (true)
            {
                if (xright == bmp.width || flagsMap.GetFlagOn(xright, p.Y, p.Z))
                {
                    break;
                }
                else
                {
                    byte value = bmp.GetPixel(xright, p.Y, p.Z);
                    if (IncludePredicate(xright, p.Y, p.Z))
                    {
                        Int16Triple t = new Int16Triple(xright, p.Y, p.Z);
                        flagsMap.SetFlagOn(xright, p.Y, p.Z, true);
                        Process(t);
                        xright++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return(xright - 1);
        }//FindXRight操作
Beispiel #13
0
 public void ClearAll()
 {
     data   = null;
     width  = -1;
     height = -1;
     depth  = -1;
     data   = null;
     seed   = new Int16Triple(-1, -1, -1);
     mask   = null;
     if (overstepPointList != null)
     {
         for (int i = 0; i < 2; i++)
         {
             if (overstepPointList[i] != null)
             {
                 overstepPointList[i].Clear();
             }
         }
     }
     if (overstepRangeList != null)
     {
         for (int i = 0; i < 4; i++)
         {
             if (overstepRangeList[i] != null)
             {
                 overstepRangeList[i].Clear();
             }
         }
     }
     overstepPointList = null;
     overstepRangeList = null;
 }
        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 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;
     }
 }
        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));
        }
Beispiel #18
0
 public SpanFillInput()
 {
     this.data              = null;
     this.width             = -1;
     this.height            = -1;
     this.depth             = -1;
     this.overstepPointList = null;
     this.overstepRangeList = null;
     this.seed              = new Int16Triple(-1, -1, -1);
     this.mask              = null;
 }
 public FloodFillInput()
 {
     this.data         = null;
     this.flagsMap     = null;
     this.width        = -1;
     this.height       = -1;
     this.depth        = -1;
     this.overstepList = null;
     this.seed         = new Int16Triple(-1, -1, -1);
     this.mask         = null;
 }
Beispiel #20
0
 private void ConvertThisBlockCoordsToOtherBlockCoords(Block thisblock, Block other, List <Int16Triple> pList)
 {
     for (int i = 0; i < pList.Count; i++)
     {
         Int16Triple old = pList[i];
         old.X   += (thisblock.stx - other.stx);
         old.Y   += (thisblock.sty - other.sty);
         old.Z   += (thisblock.stz - other.stz);
         pList[i] = old;
     }
 }
Beispiel #21
0
 private void ConvertBlockCoordsToGlobalCoords(Block thisblock, List <Int16Triple> pList)
 {
     for (int i = 0; i < pList.Count; i++)
     {
         Int16Triple old = pList[i];
         old.X   += thisblock.stx;
         old.Y   += thisblock.sty;
         old.Z   += thisblock.stz;
         pList[i] = old;
     }
 }
Beispiel #22
0
 //public List<Int16Triple>[] boundaryOverstepOutside;
 public BlockIR_FF()
 {
     boundarySeedsInside = new List <Int16Triple> [6];
     //boundaryOverstepOutside = new List<Int16Triple>[6];
     for (int i = 0; i < 6; i++)
     {
         boundarySeedsInside[i] = new List <Int16Triple>();
         //boundaryOverstepOutside[i] = new List<Int16Triple>();
     }
     singleSeed = new Int16Triple(-1, -1, -1);
 }
Beispiel #23
0
 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();
 }
 public BlockIR_SP()
 {
     boundarySeedXsInside = new List<Int16Triple>[2];
     boundaryRangesYZInside = new List<Range>[4];
     for (int i = 0; i < 2; i++)
     {
         boundarySeedXsInside[i] = new List<Int16Triple>();
     }
     for (int i = 0; i < 4; i++)
     {
         boundaryRangesYZInside[i] = new List<Range>();
     }
     singleSeed = new Int16Triple(-1, -1, -1);
 }
Beispiel #25
0
        private void ProcessFirstSeed(SpanFillInput input)
        {
            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);
        }
Beispiel #26
0
        }//get copnfig

        private void ExtractTriangles(ref Cube cube, byte value, MeshBuilder_IntegerVertex builder)
        {
            if (SMCTable.TableFat[value, 0] != -1)
            {
                int index = 0;
                while (SMCTable.TableFat[value, index] != -1)
                {
                    Int16Triple t0 = cube.cubeImageIndices[SMCTable.TableFat[value, index]];
                    Int16Triple t1 = cube.cubeImageIndices[SMCTable.TableFat[value, index + 1]];
                    Int16Triple t2 = cube.cubeImageIndices[SMCTable.TableFat[value, index + 2]];
                    builder.AddTriangle(t0, t1, t2);
                    //builder.AddTriangle(new Point3d(t0.X,t0.Y,t0.Z), new Point3d(t1.X,t1.Y,t1.Z), new Point3d(t2.X,t2.Y,t2.Z ));
                    index += 3;
                }
            }
        }//extract triangles and put them into meshbuilder
Beispiel #27
0
 public Int16Triple GetBlockIndex(Int16Triple seed)
 {
     for (int i = 0; i < rowCount; i++)
     {
         for (int j = 0; j < columnCount; j++)
         {
             for (int k = 0; k < layerCount; k++)
             {
                 if (blocksMap[i, j, k].HasPoint(seed))
                 {
                     return(new Int16Triple(i, j, k));
                 }
             }
         }
     }
     throw new Exception();
 }
Beispiel #28
0
 public void ExcuteSpanFill_Stack(BitMap3d data, Int16Triple seed)
 {
     watch.Start();
     container = new Container_Stack <Span>();
     base.ExcuteSpanFill(data, seed);
     watch.Stop();
     report.time = watch.ElapsedMilliseconds;
     report.result_point_count   = count;
     report.bmp_get_count        = data.action_get_count;
     report.bmp_set_count        = data.action_set_count;
     report.container_pop_count  = container.action_pop_count;
     report.container_push_count = container.action_push_count;
     report.container_max_size   = container.max_contain_count;
     report.flag_get_count       = flagsMap.action_get_count;
     report.flag_set_count       = flagsMap.action_set_count;
     return;
 }
Beispiel #29
0
        private int ExtractTriangles(Int16Triple[] temp, byte value, int indexInWidth, int indexInHeight, int indexInDepth, OriginalTriangle[] result)
        {
            int tcount = 0;

            if (SMCTable.TableFat[value, 0] != -1)
            {
                int index = 0;
                while (SMCTable.TableFat[value, index] != -1)
                {
                    Int16Triple t0 = temp[SMCTable.TableFat[value, index]];
                    Int16Triple t1 = temp[SMCTable.TableFat[value, index + 1]];
                    Int16Triple t2 = temp[SMCTable.TableFat[value, index + 2]];
                    result[tcount] = new OriginalTriangle(t0.X, t0.Y, t0.Z, t1.X, t1.Y, t1.Z, t2.X, t2.Y, t2.Z);
                    tcount++;
                    index += 3;
                }
            }
            return(tcount);
        }
 public void ClearAll()
 {
     data     = null;
     width    = -1;
     height   = -1;
     depth    = -1;
     data     = null;
     seed     = new Int16Triple(-1, -1, -1);
     mask     = null;
     flagsMap = null;
     if (overstepList != null)
     {
         for (int i = 0; i < 6; i++)
         {
             overstepList[i].Clear();
         }
     }
     overstepList = null;
 }