Esempio n. 1
0
        //--------------------------------------------------------------------------------------------------

        void _AddBSplineCurve(Geom2d_BSplineCurve bspline, double first, double last)
        {
            // Cut spline
            bspline = Geom2dConvert.SplitBSplineCurve(bspline, first, last, 0.00001);

            if (_Document.Flags.HasFlag(DxfFlags.ExportSplineAsPolygon))
            {
                _AddPolygonCurve(bspline);
                return;
            }

            if (bspline.Degree() > 3)
            {
                // Try to reduce the order of the curve
                var continuity = bspline.Continuity();
                if (continuity != GeomAbs_Shape.GeomAbs_C0)
                {
                    continuity = GeomAbs_Shape.GeomAbs_C1;
                }

                var converter = new Geom2dConvert_ApproxCurve(bspline, _Precision * 10.0, continuity, 100, 3);
                if (!(converter.IsDone() && converter.HasResult()))
                {
                    Messages.Warning("DxfExporter: BSpline curve has an undecreasable degree of " + bspline.Degree() + ".");
                    return;
                }

                bspline = converter.Curve();
            }

            var knotSource  = bspline.KnotSequence();
            var knots       = new double[knotSource.Length()];
            int sourceStart = knotSource.Lower();

            for (int i = 0; i < knots.Length; i++)
            {
                knots[i] = knotSource.Value(sourceStart + i);
            }

            var points  = new Pnt2d[bspline.NbPoles()];
            var weights = new double[points.Length];

            for (int i = 0; i < bspline.NbPoles(); i++)
            {
                points[i]  = bspline.Pole(i + 1);
                weights[i] = bspline.Weight(i + 1);
            }

            var flags = DxfDomSpline.SplineFlags.None;

            if (bspline.IsRational())
            {
                flags = flags.Added(DxfDomSpline.SplineFlags.IsRational);
            }

            var entity = new DxfDomSpline(_CurrentLayer, bspline.Degree(), knots, points, weights, flags);

            _Document.Entities.Add(entity);
        }
Esempio n. 2
0
        //--------------------------------------------------------------------------------------------------

        void _AddBSplineCurve(Geom2d_BSplineCurve geom2dBSpline)
        {
            var converter = new Geom2dConvert_BSplineCurveToBezierCurve(geom2dBSpline);

            for (int i = 1; i <= converter.NbArcs(); i += 1)
            {
                var arc = converter.Arc(i);
                _AddBezierCurve(arc, arc.FirstParameter(), arc.LastParameter());
            }
        }
Esempio n. 3
0
        //--------------------------------------------------------------------------------------------------

        protected void AddBSplineCurve(Geom2d_BSplineCurve geom2DBSpline, double first, double last, bool reverse)
        {
            var converter = new Geom2dConvert_BSplineCurveToBezierCurve(geom2DBSpline, first, last, 0.001 /*Precision.PConfusion() * 10*/);

            if (reverse)
            {
                for (int i = converter.NbArcs(); i >= 1; i -= 1)
                {
                    var arc = converter.Arc(i);
                    AddBezierCurve(arc, arc.FirstParameter(), arc.LastParameter(), true);
                }
            }
            else
            {
                for (int i = 1; i <= converter.NbArcs(); i += 1)
                {
                    var arc = converter.Arc(i);
                    AddBezierCurve(arc, arc.FirstParameter(), arc.LastParameter(), false);
                }
            }
        }
Esempio n. 4
0
 public void SetValue(int theIndex, Geom2d_BSplineCurve theItem)
 {
     throw new NotImplementedException();
 }
 public Geom2dConvert_BSplineCurveKnotSplitting(Geom2d_BSplineCurve Bas_isCurve, int ContinuityRange)
     : base()
 {
     throw new NotImplementedException();
 }
 public void FixTangentOnCurve(Geom2d_BSplineCurve theCurve, bool FirstFlag, bool LastFlag)
 {
     throw new NotImplementedException();
 }
Esempio n. 7
0
 public Geom2d_BSplineCurve Solution(Geom2d_BSplineCurve BS, double TolPoles)
 {
     throw new NotImplementedException();
 }
 public Geom2dConvert_BSplineCurveToBezierCurve(Geom2d_BSplineCurve Bas_isCurve)
     : base()
 {
     throw new NotImplementedException();
 }
Esempio n. 9
0
 public Geom2d_BSplineCurve SplitBSplineCurve(Geom2d_BSplineCurve C, int FromK1, int ToK2, bool SameOrientation)
 {
     throw new NotImplementedException();
 }
Esempio n. 10
0
 public bool C0BSplineToSequenceOfC1BSplineCurve(Geom2d_BSplineCurve BS,
                                                 TColGeom2d_HSequenceOfBoundedCurve seqBS)
 {
     throw new NotImplementedException();
 }
Esempio n. 11
0
 public void ApproxBSplineCurve(Geom2d_BSplineCurve bspline, TColGeom2d_SequenceOfCurve seq)
 {
     throw new NotImplementedException();
 }
Esempio n. 12
0
 public TColGeom2d_HArray1OfBSplineCurve(int theLower, int theUpper, Geom2d_BSplineCurve theValue)
     : base()
 {
     throw new NotImplementedException();
 }
Esempio n. 13
0
        //--------------------------------------------------------------------------------------------------

        public static bool RenderBSplineCurve(IDrawingRenderer renderer, Geom2d_BSplineCurve bspline, double first, double last, bool reverse)
        {
            if (renderer.Capabilities.BSplineCurveMaxDegree > 0)
            {
                bspline = Geom2dConvert.SplitBSplineCurve(bspline, first, last, 0.00001);

                if (bspline.Degree() > renderer.Capabilities.BSplineCurveMaxDegree)
                {
                    // Try to reduce the order of the curve
                    var continuity = bspline.Continuity();
                    if (continuity != GeomAbs_Shape.GeomAbs_C0)
                    {
                        continuity = GeomAbs_Shape.GeomAbs_C1;
                    }

                    var converter = new Geom2dConvert_ApproxCurve(bspline, 0.0001, continuity, 100, 3);
                    if (!(converter.IsDone() && converter.HasResult()))
                    {
                        Messages.Warning("BrepRenderHelper: BSpline curve has an undecreasable degree of " + bspline.Degree() + ".");
                        return(false);
                    }

                    bspline = converter.Curve();
                }

                var knotSource  = bspline.KnotSequence();
                var knots       = new double[knotSource.Length()];
                int sourceStart = knotSource.Lower();
                for (int i = 0; i < knots.Length; i++)
                {
                    knots[i] = knotSource.Value(sourceStart + i);
                }

                var points  = new Pnt2d[bspline.NbPoles()];
                var weights = new double[points.Length];
                for (int i = 0; i < bspline.NbPoles(); i++)
                {
                    points[i]  = bspline.Pole(i + 1);
                    weights[i] = bspline.Weight(i + 1);
                }

                renderer.BSplineCurve(bspline.Degree(), knots, points, weights, bspline.IsRational());
                return(true);
            }
            else
            {
                // Cannot render BSpline, Try bezier
                var  converter = new Geom2dConvert_BSplineCurveToBezierCurve(bspline, first, last, 0.001 /*Precision.PConfusion() * 10*/);
                bool result    = true;

                if (reverse)
                {
                    for (int i = converter.NbArcs(); i >= 1; i -= 1)
                    {
                        var arc = converter.Arc(i);
                        result &= RenderBezierCurve(renderer, arc, arc.FirstParameter(), arc.LastParameter(), true);
                    }
                }
                else
                {
                    for (int i = 1; i <= converter.NbArcs(); i += 1)
                    {
                        var arc = converter.Arc(i);
                        result &= RenderBezierCurve(renderer, arc, arc.FirstParameter(), arc.LastParameter(), false);
                    }
                }

                return(result);
            }
        }
Esempio n. 14
0
 public TColGeom2d_Array1OfBSplineCurve(Geom2d_BSplineCurve theBegin, int theLower, int theUpper)
     : base()
 {
     throw new NotImplementedException();
 }
Esempio n. 15
0
 public Geom2d_BSplineCurve SplitBSplineCurve(Geom2d_BSplineCurve C, int FromK1, int ToK2)
 {
     throw new NotImplementedException();
 }
Esempio n. 16
0
 public void Init(Geom2d_BSplineCurve theValue)
 {
     throw new NotImplementedException();
 }
Esempio n. 17
0
 public Geom2d_BSplineCurve SplitBSplineCurve(Geom2d_BSplineCurve C, double FromU1, double ToU2,
                                              double ParametricTolerance)
 {
     throw new NotImplementedException();
 }
 public Geom2dConvert_BSplineCurveToBezierCurve(Geom2d_BSplineCurve Bas_isCurve, double U1, double U2,
                                                double ParametricTolerance)
     : base()
 {
     throw new NotImplementedException();
 }
Esempio n. 19
0
 public void C0BSplineToC1BSplineCurve(Geom2d_BSplineCurve BS, double Tolerance)
 {
     throw new NotImplementedException();
 }
Esempio n. 20
0
 public Geom2d_BSplineCurve Solution(Geom2d_BSplineCurve BS)
 {
     throw new NotImplementedException();
 }
Esempio n. 21
0
 public void C0BSplineToArrayOfC1BSplineCurve(Geom2d_BSplineCurve BS, TColGeom2d_HArray1OfBSplineCurve tabBS,
                                              double AngularTolerance, double Tolerance)
 {
     throw new NotImplementedException();
 }
 public GeomLib_Check2dBSplineCurve(Geom2d_BSplineCurve Curve, double Tolerance, double AngularTolerance)
     : base()
 {
     throw new NotImplementedException();
 }
Esempio n. 23
0
 public void SetBSpline(Geom2d_BSplineCurve C)
 {
     throw new NotImplementedException();
 }
Esempio n. 24
0
 public void Add(Geom2d_BSplineCurve FirstCurve, Geom2d_BSplineCurve SecondCurve, bool After)
 {
     throw new NotImplementedException();
 }
Esempio n. 25
0
 public bool SimplifyBSpline2d(Geom2d_BSplineCurve theBSpline2d, double theTolerance)
 {
     throw new NotImplementedException();
 }