예제 #1
0
        public List <Point3d> toPoints()
        {
            if (segments == null || segments.Count <= 0)
            {
                return(null);
            }
            List <Point3d> r           = new List <Point3d>();
            TBPoint        start       = this.startPoint;
            LoopSeg        previousSeg = segments[0];

            r.Add(start.acPoint);
            r.AddRange(previousSeg.getInnerPoints());
            LoopSeg nextSeg = previousSeg;

            for (int i = 1; i < segments.Count; i++)
            {
                nextSeg = segments[i];

                r.Add(nextSeg.startPoint.acPoint);
                r.AddRange(nextSeg.getInnerPoints());
                previousSeg = nextSeg;
            }
            r.Add(nextSeg.endPoint.acPoint);
            return(r);
        }
예제 #2
0
        public double scanAngle(TBPLineSegment second, TBPoint interPoint)
        {
            Point3d        p1, p2, p3;
            TBPLineSegment s1 = null;
            TBPLineSegment s2 = null;

            if ((interPoint == this.StartPoint) && (this.StartPoint == second.StartPoint))
            {
                s1 = this.newReverse();
                s2 = second;
            }
            else if ((interPoint == this.StartPoint) && (this.StartPoint == second.EndPoint))
            {
                s1 = this.newReverse();
                s2 = second.newReverse();
            }
            else if ((interPoint == this.EndPoint) && (this.EndPoint == second.StartPoint))
            {
                s1 = this;
                s2 = second;
            }
            else if ((interPoint == this.EndPoint) && (this.EndPoint == second.EndPoint))
            {
                s1 = this;
                s2 = second.newReverse();
            }
            p1 = s1.acPline.GetPointAtParameter(this.acPline.EndParam - 1);
            p2 = s1.EndPoint.acPoint;
            p3 = s2.acPline.GetPointAtParameter(1);
            return(AngleUtil.scanAngle(p1, p2, p3));
        }
예제 #3
0
        public TBPoint nextPoint(TBPoint previousPoint)
        {
            TBPoint r;

            nextPointDic.TryGetValue(previousPoint, out r);
            if (r != null)
            {
                this.nextPointDic[previousPoint] = null;
            }
            return(r);

            if (previousPoint == this.StartPoint)
            {
                if ((hadProcessed & 1) == 1)
                {
                    return(null);
                }
                return(this.EndPoint);
            }
            else if (previousPoint == this.EndPoint)
            {
                if ((hadProcessed & 2) == 2)
                {
                    return(null);
                }
                return(this.StartPoint);
            }
            else
            {
                throw new System.Exception("TBPLineSegment 117");
            }
        }
예제 #4
0
 public TBPLineSegment(Polyline3d pl, TBPoint s, TBPoint e)
 {
     acPline      = pl;
     startPoint   = s;
     endPoint     = e;
     nextPointDic = new Dictionary <TBPoint, TBPoint>();
     nextPointDic.Add(startPoint, endPoint);
     nextPointDic.Add(endPoint, startPoint);
 }
예제 #5
0
        public static Loop getBoundary(TBPLineSegment startSeg, object userData)
        {
            Editor ed         = Application.DocumentManager.MdiActiveDocument.Editor;
            Loop   resultLoop = new Loop();

            resultLoop.userData = userData;
            List <LoopSeg> loopSegs = resultLoop.segments;
            //result2 = new List<Point3d>();
            //result.Add(startSeg);
            double         scanAngle   = 0;
            TBPLineSegment previousSeg = startSeg;
            TBPoint        startPoint;
            TBPoint        nextp = startSeg.nextPoint(out startPoint);

            if (nextp == null)
            {
                return(null);
            }
            scanAngle += startSeg.scanAngle(startPoint);
            //result2.Add(startPoint.acPoint);
            loopSegs.Add(new LoopSeg(startSeg, startPoint));
            resultLoop.startPoint = startPoint;
            while (nextp != null)
            {
                TBPLineSegment nextSeg = nextp.nextSegment(previousSeg);
                if (nextSeg == startSeg)
                {
                    throw new System.Exception("TraceBoundary 39");
                }
                scanAngle += nextSeg.scanAngle(nextp);
                scanAngle += previousSeg.scanAngle(nextSeg, nextp);
                loopSegs.Add(new LoopSeg(nextSeg, nextp));
                nextp = nextSeg.nextPoint(nextp);
                if (nextp == null)
                {
                    return(null);
                    //throw new System.Exception("TraceBoundary 44");
                }
                previousSeg = nextSeg;
                if (nextp == startPoint)
                {
                    scanAngle += previousSeg.scanAngle(startSeg, startPoint);
                    break;
                }
            }
            resultLoop.scanAngle = scanAngle;
            if (resultLoop.segments.Count <= 1)
            {
            }
            if (scanAngle <= 0)
            {
                ed.WriteMessage("\nangle:" + scanAngle + "\n" + startSeg.toString());
            }
            return(resultLoop);
        }
예제 #6
0
        public void calcIntersection(TBPLine tbpline)
        {
            Point3dCollection result = new Point3dCollection();

            acPline.IntersectWith(tbpline.acPline, Intersect.OnBothOperands, new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, 1)), result, (IntPtr)0, (IntPtr)0);
            for (int i = 0; i < result.Count; i++)
            {
                Point3d p   = result[i];
                TBPoint tbp = TBPoint.getNewTBPoint(p);

                this.addIntersectPoint(tbp);
                tbpline.addIntersectPoint(tbp);
            }
        }
예제 #7
0
 public LoopSeg(TBPLineSegment seg, TBPoint startP)
 {
     segment = seg;
     if (startP == seg.StartPoint)
     {
         direction = LineDirection.positive;
     }
     else if (startP == seg.EndPoint)
     {
         direction = LineDirection.negtive;
     }
     else
     {
         throw new System.Exception("BoundarySeg.cs 39");
     }
 }
예제 #8
0
 public double scanAngle(TBPoint startp)
 {//闭合情况下,没有计算末尾到开始的角度
     if (startp == this.StartPoint)
     {
         return(this.scanAngle());
     }
     else if (startp == this.EndPoint)
     {
         TBPLineSegment reverse = this.newReverse();
         return(reverse.scanAngle());
     }
     else
     {
         throw new System.Exception("TBPLineSegment 69");
     }
 }
예제 #9
0
        public List <Point3d> getInnerPoints(TBPoint startp)
        {
            TBPLineSegment seg = this;

            if (startp == this.StartPoint)
            {
            }
            else if (startp == this.EndPoint)
            {
                seg = this.newReverse();
            }
            else
            {
                return(null);
            }
            return(seg.getInnerPoints());
        }
예제 #10
0
        private void caclParams()
        {
            for (int i = 0; i < intersectPoints.Count; i++)
            {
                TBPoint p     = intersectPoints[i];
                double  param = this.acPline.GetParameterAtPoint(p.acPoint);
                if (param < 0)
                {
                    //throw new System.Exception("TBPLine 97");
                }
                if (Math.Abs(param) < 1e-10)
                {
                    param = 0;
                }

                p.TempParam = param;
            }
        }
예제 #11
0
        public void addIntersectPoint(TBPoint p)
        {
            int i = intersectPoints.FindIndex(item =>
            {
                TBPoint p2 = item as TBPoint;
                if ((Math.Abs(p.acPoint.X - p2.acPoint.X) < 1e-10) &&
                    (Math.Abs(p.acPoint.Y - p2.acPoint.Y) < 1e-10))
                {
                    return(true);
                }
                return(false);
            });

            if (i < 0)
            {
                intersectPoints.Add(p);
                return;
            }
        }
예제 #12
0
        public TBPoint nextPoint(int i, out TBPoint start)
        {
            start = null;
            if (i != 1 && i != 2)
            {
                return(null);
            }
            TBPoint p = null;

            hadProcessed |= i;
            if (i == 1)
            {
                p     = this.EndPoint;
                start = this.StartPoint;
            }
            else if (i == 2)
            {
                p     = this.StartPoint;
                start = this.EndPoint;
            }

            return(p);
        }
예제 #13
0
        public TBPoint nextPoint(out TBPoint start)
        {
            TBPoint r = null;

            start = null;
            r     = this.nextPointDic[startPoint];
            if (r != null)
            {
                start = startPoint;
                this.nextPointDic[startPoint] = null;
            }
            else
            {
                r = this.nextPointDic[endPoint];
                if (r != null)
                {
                    start = endPoint;
                    this.nextPointDic[endPoint] = null;
                }
            }
            return(r);

            if ((hadProcessed & 1) == 0)
            {
                r = nextPoint(1, out start);
                if (r == null)
                {
                    r = nextPoint(2, out start);
                }
            }
            else if ((hadProcessed & 2) == 0)
            {
                r = nextPoint(2, out start);
            }
            return(r);
        }
예제 #14
0
 public TBPLineComparer(TBPoint p)
 {
     startPoint = p;
 }
예제 #15
0
        public void divide()
        {
            this.SegmentedPlines = new List <TBPLineSegment>();
            ObjectId layerId = My.LayerUtil.CreateLayer("segment", 255, false);

            try
            {
                Document acDoc   = Application.DocumentManager.MdiActiveDocument;
                Database acCurDb = acDoc.Database;

                /*using (Transaction tran = acCurDb.TransactionManager.StartTransaction())
                 * {
                 *  BlockTable bt = tran.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
                 *  BlockTableRecord modelSpace = tran.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;*/
                if (intersectPoints.Count <= 0)
                {
                    return;
                }
                for (int i = 0; i < intersectPoints.Count - 1; i++)
                {
                    TBPoint p1 = intersectPoints[i];
                    TBPoint p2 = intersectPoints[i + 1];

                    Point3dCollection vertexes = new Point3dCollection();
                    //My.MyDBUtility.addPolyline3d(segmentedPl, layerId);
                    //ObjectId oid = modelSpace.AppendEntity(segmentedPl);
                    //tran.AddNewlyCreatedDBObject(segmentedPl, true);
                    vertexes.Add(p1.acPoint);
                    //segmentedPl.AppendVertex(vertex);
                    int n           = 0;
                    int vertexCount = 1;
                    while (true)
                    {
                        double nextP;
                        if (Math.Ceiling(p1.TempParam) - p1.TempParam < 1e-10)
                        {
                            nextP = Math.Ceiling(p1.TempParam) + (++n);
                        }
                        else
                        {
                            nextP = Math.Ceiling(p1.TempParam) + (n++);
                        }

                        if (nextP - p2.TempParam > 1e-10)
                        {
                            break;
                        }
                        else if (Math.Abs(nextP - p2.TempParam) <= 1e-10)
                        {
                            break;
                        }
                        //segmentedPl.AppendVertex(new PolylineVertex3d(acPline.GetPointAtParameter(nextP)));
                        vertexes.Add(acPline.GetPointAtParameter(nextP));
                        vertexCount++;
                    }
                    //segmentedPl.AppendVertex(new PolylineVertex3d(p2.acPoint));
                    vertexes.Add(p2.acPoint);
                    vertexCount++;

                    if (vertexCount >= 2)
                    {
                        Polyline3d     segmentedPl = new Polyline3d(Poly3dType.SimplePoly, vertexes, false);
                        TBPLineSegment tbpline     = new TBPLineSegment(segmentedPl, p1, p2);
                        //tbpline.StartPoint = p1;
                        //tbpline.EndPoint = p2;
                        this.SegmentedPlines.Add(tbpline);
                        //p1.SegmentedPLines.Add(tbpline);
                        //p2.SegmentedPLines.Add(tbpline);
                        p1.addSegment(tbpline);
                        p2.addSegment(tbpline);
                    }
                }
                if (this.isClosed || this.IsLooped)
                {
                    TBPoint p1 = intersectPoints[intersectPoints.Count - 1];

                    Point3dCollection vertexes = new Point3dCollection();
                    vertexes.Add(p1.acPoint);

                    My.PolylineUtil.getPointsBetween2Point(acPline, p1.TempParam, acPline.EndParam, vertexes);
                    vertexes.Add(acPline.StartPoint);

                    TBPoint p2 = intersectPoints[0];
                    My.PolylineUtil.getPointsBetween2Point(acPline, 0, p2.TempParam, vertexes);
                    vertexes.Add(p2.acPoint);

                    if (vertexes.Count >= 2)
                    {
                        Polyline3d     segmentedPl = new Polyline3d(Poly3dType.SimplePoly, vertexes, false);
                        TBPLineSegment tbpline     = new TBPLineSegment(segmentedPl, p1, p2);
                        this.SegmentedPlines.Add(tbpline);
                        p1.addSegment(tbpline);
                        p2.addSegment(tbpline);
                    }
                }


                //tran.Commit();
                //}
            }
            catch (System.Exception ex)
            {
            }
        }
예제 #16
0
        public bool equalTo(TBPoint p2)
        {
            bool r = (Math.Abs(this.acPoint.X - p2.acPoint.X) < 1e-10) && (Math.Abs(this.acPoint.Y - p2.acPoint.Y) < 1e-10);

            return(r);
        }
예제 #17
0
 public TBPLineSegmentComparer(TBPoint p)
 {
     startPoint = p;
 }
예제 #18
0
 public TBPLineSegment(Polyline3d pl)
 {
     this.acPline = pl;
     startPoint   = TBPoint.getNewTBPoint(pl.StartPoint);
     endPoint     = TBPoint.getNewTBPoint(pl.EndPoint);
 }