コード例 #1
0
ファイル: IsEqual.cs プロジェクト: BHoM/Rhinoceros_Toolkit
        /***************************************************/

        public static bool IsEqual(this BHG.PolyCurve bhCurve, RHG.PolyCurve rhCurve, double tolerance = BHG.Tolerance.Distance)
        {
            if (bhCurve == null & rhCurve == null)
            {
                return(true);
            }

            bool equal = true;
            List <BHG.ICurve> bhCurves = bhCurve.Curves;

            rhCurve.RemoveNesting();
            RHG.Curve[] rhCurves = rhCurve.Explode();

            if (bhCurves.Count != rhCurves.Length)
            {
                return(false);
            }

            for (int i = 0; i < bhCurves.Count; i++)
            {
                equal &= bhCurves[i].IIsEqual(rhCurves[i], tolerance);
            }

            return(equal);
        }
コード例 #2
0
ファイル: FromRC.cs プロジェクト: lulzzz/Nucleus
 /// <summary>
 /// Convert a RhinoCommon PolyCurve to a Nucleus one
 /// </summary>
 /// <param name="polyCurve"></param>
 /// <returns></returns>
 public static PolyCurve Convert(RC.PolyCurve polyCurve)
 {
     if (polyCurve != null)
     {
         PolyCurve  result  = new PolyCurve();
         RC.Curve[] subCrvs = polyCurve.Explode();
         foreach (RC.Curve subCrv in subCrvs)
         {
             Curve crv = Convert(subCrv);
             if (crv != null)
             {
                 result.Add(crv);
             }
         }
         return(result);
     }
     return(null);
 }
コード例 #3
0
ファイル: FromRhino.cs プロジェクト: BHoM/Rhinoceros_Toolkit
        /***************************************************/

        public static BHG.ICurve FromRhino(this RHG.PolyCurve polyCurve)
        {
            if (polyCurve == null)
            {
                return(null);
            }

            polyCurve.RemoveNesting();
            if (polyCurve.IsPolyline())
            {
                RHG.Polyline polyline;
                polyCurve.TryGetPolyline(out polyline);
                return(polyline.FromRhino());
            }
            else
            {
                return new BHG.PolyCurve {
                           Curves = polyCurve.Explode().Select(x => x.FromRhino()).ToList()
                }
            };
        }
コード例 #4
0
 internal static IfcIndexedPolyCurve Convert(DatabaseIfc db, PolyCurve polycurve, bool twoD)
 {
     double tol = db.Tolerance;
     Curve[] segments = polycurve.Explode();
     PolyCurve pc = new PolyCurve();
     foreach (Curve s in segments)
     {
         if (s.IsLinear(tol))
             pc.Append(new Line(s.PointAtStart, s.PointAtEnd));
         else
         {
             Arc a = Arc.Unset;
             if (s.TryGetArc(out a, tol))
                 pc.Append(a);
             else
                 return null;
         }
     }
     List<IfcSegmentIndexSelect> segs = new List<IfcSegmentIndexSelect>();
     IfcCartesianPointList cpl = null;
     bool closed = pc.PointAtStart.DistanceTo(pc.PointAtEnd) < tol;
     if (twoD)
     {
         Point2d pt = new Point2d(pc.PointAtStart.X, pc.PointAtStart.Y);
         int pcounter = 1;
         List<Point2d> pts = new List<Point2d>();
         pts.Add(pt);
         IfcLineIndex li = null;
         for (int icounter = 0; icounter < pc.SegmentCount; icounter++)
         {
             Curve c = pc.SegmentCurve(icounter);
             if (c.IsLinear(tol) && c.PointAtStart.DistanceTo(c.PointAtEnd) < tol)
                 continue;
             if (c.IsLinear(tol))
             {
                 if (closed && icounter + 1 == segments.Length)
                 {
                     if (li != null)
                         li.mIndices.Add(1);
                     else
                         li = new IfcLineIndex(pcounter, 1);
                 }
                 else
                 {
                     pts.Add(new Point2d(c.PointAtEnd.X, c.PointAtEnd.Y));
                     if (li != null)
                         li.mIndices.Add(++pcounter);
                     else
                         li = new IfcLineIndex(pcounter++, pcounter);
                 }
             }
             else
             {
                 if (li != null)
                 {
                     segs.Add(li);
                     li = null;
                 }
                 Point3d tp = c.PointAt(c.Domain.Mid);
                 pts.Add(new Point2d(tp.X, tp.Y));
                 if (closed && icounter + 1 == segments.Length)
                     segs.Add(new IfcArcIndex(pcounter++, pcounter++, 1));
                 else
                 {
                     pts.Add(new Point2d(c.PointAtEnd.X, c.PointAtEnd.Y));
                     segs.Add(new IfcArcIndex(pcounter++, pcounter++, pcounter));
                 }
             }
         }
         if (li != null)
             segs.Add(li);
         cpl = new IfcCartesianPointList2D(db, pts.ToArray());
     }
     else
     {
         Point3d pt = pc.PointAtStart;
         int pcounter = 1;
         List<Point3d> pts = new List<Point3d>();
         pts.Add(pt);
         List<IfcSegmentIndexSelect> sis = new List<IfcSegmentIndexSelect>(segments.Length);
         IfcLineIndex li = null;
         for (int icounter = 0; icounter < pc.SegmentCount; icounter++)
         {
             Curve c = pc.SegmentCurve(icounter);
             if (c.IsLinear(tol) && c.PointAtStart.DistanceTo(c.PointAtEnd) < tol)
                 continue;
             if (c.IsLinear(tol))
             {
                 if (closed && icounter + 1 == segments.Length)
                 {
                     if (li != null)
                         li.mIndices.Add(0);
                     else
                         li = new IfcLineIndex(pcounter, 0);
                 }
                 else
                 {
                     pts.Add(c.PointAtEnd);
                     if (li != null)
                         li.mIndices.Add(++pcounter);
                     else
                         li = new IfcLineIndex(pcounter++, pcounter);
                 }
             }
             else
             {
                 if (li != null)
                 {
                     segs.Add(li);
                     li = null;
                 }
                 pts.Add(c.PointAt(c.Domain.Mid));
                 if (closed && icounter + 1 == segments.Length)
                     segs.Add(new IfcArcIndex(pcounter++, pcounter, 0));
                 else
                 {
                     pts.Add(c.PointAtEnd);
                     segs.Add(new IfcArcIndex(pcounter++, pcounter++, pcounter));
                 }
             }
         }
         if (li != null)
             segs.Add(li);
         cpl = new IfcCartesianPointList3D(db, pts.ToArray());
     }
     return new IfcIndexedPolyCurve(cpl, segs) { };
 }