public bool IsPointInOnFace(TopoDSFace aF, gpPnt2d aP2D)
 {
     return(IntTools_Context_IsPointInOnFace15F1B95A(Instance, aF.Instance, aP2D.Instance));
 }
示例#2
0
 public bool IsOut(gpPnt2d P)
 {
     return(Bnd_Box2d_IsOut6203658C(Instance, P.Instance));
 }
 public int AddVertex(gpPnt aVertice, gpDir aNormal, gpPnt2d aTexel)
 {
     return(Graphic3d_ArrayOfPrimitives_AddVertex640114B2(Instance, aVertice.Instance, aNormal.Instance, aTexel.Instance));
 }
 public TopAbsState StatePointFace(TopoDSFace aF, gpPnt2d aP2D)
 {
     return((TopAbsState)IntTools_Context_StatePointFace15F1B95A(Instance, aF.Instance, aP2D.Instance));
 }
示例#5
0
 public void D1(double U, gpPnt2d P, gpVec2d V)
 {
     Adaptor2d_HCurve2d_D1EF1CEF4A(Instance, U, P.Instance, V.Instance);
 }
 public int AddVertex(gpPnt aVertice, gpPnt2d aTexel)
 {
     return(Graphic3d_ArrayOfPrimitives_AddVertexB9E79A6(Instance, aVertice.Instance, aTexel.Instance));
 }
 public void Set2dPoints(gpPnt2d P2df1, gpPnt2d P2dl1, gpPnt2d P2df2, gpPnt2d P2dl2)
 {
     ChFiDS_SurfData_Set2dPoints79D6D16B(Instance, P2df1.Instance, P2dl1.Instance, P2df2.Instance, P2dl2.Instance);
 }
示例#8
0
 public void Add(gpPnt2d P)
 {
     Bnd_Box2d_Add6203658C(Instance, P.Instance);
 }
 public static void SetUVPoints(TopoDSEdge E, TopoDSFace F, gpPnt2d PFirst, gpPnt2d PLast)
 {
     BRep_Tool_SetUVPoints6AA8D466(E.Instance, F.Instance, PFirst.Instance, PLast.Instance);
 }
        public override List <SolverPreviewObject> InterestingShapeAroundPoint(gpPln planeOfTheView, Point3D point)
        {
            //var qosLock = QosFactory.Instance.Get(QosNames.SameCoordinateMatchLock);
            var zoom = CoreGlobalPreferencesSingleton.Instance.ZoomLevel * _precision;
            //qosLock.Begin();
            var axis = new gpAx2();

            axis.Axis = (planeOfTheView.Axis);
            var pointOnPlane = GeomUtils.Point3DTo2D(axis, point);
            var solutions    = new SortedDictionary <double, SolverEdgeTwoPointsResult>();

            foreach (var geometricObject in LastGeometry)
            {
                foreach (var pnt in geometricObject.Points)
                {
                    var result = GeomUtils.ProjectPointOnPlane(pnt.Point.GpPnt, planeOfTheView, Precision.Confusion);
                    if (Math.Abs(result.X - pnt.Point.GpPnt.X) > Precision.Confusion ||
                        Math.Abs(result.Y - pnt.Point.GpPnt.Y) > Precision.Confusion ||
                        Math.Abs(result.Z - pnt.Point.GpPnt.Z) > Precision.Confusion)
                    {
                        continue;
                    }

                    var planePnt             = GeomUtils.Point3DTo2D(axis, pnt.Point);
                    var xDistance            = Math.Abs(pointOnPlane.X - planePnt.X);
                    var solutionPointOnPlane = new gpPnt2d(pointOnPlane.X, pointOnPlane.Y);
                    var solutionPoint        = new Point3D(point.GpPnt);

                    if (xDistance <= zoom)
                    {
                        solutionPointOnPlane.X = (planePnt.X);
                        solutionPoint          = new Point3D(GeomUtils.Point2DTo3D(axis, solutionPointOnPlane));
                        solutions[xDistance]   = new SolverEdgeTwoPointsResult(solutionPoint, pnt.Point, Color.Blue)
                        {
                            Type = "Same coordinate match"
                        };
                    }
                    else
                    {
                        var yDistance = Math.Abs(pointOnPlane.Y - planePnt.Y);
                        if (yDistance <= zoom)
                        {
                            solutionPointOnPlane.Y = (planePnt.Y);
                            solutionPoint          = new Point3D(GeomUtils.Point2DTo3D(axis, solutionPointOnPlane));
                            solutions[yDistance]   = new SolverEdgeTwoPointsResult(solutionPoint, pnt.Point, Color.Blue)
                            {
                                Type = "Same coordinate match"
                            };
                        }
                    }
                }
            }
            //qosLock.End();

            if (solutions.Count == 0)
            {
                return(new List <SolverPreviewObject>());
            }
            var SolverPreviewObjects = new List <SolverPreviewObject>();

            foreach (var s in solutions)
            {
                SolverPreviewObjects.Add(s.Value);
            }
            return(SolverPreviewObjects);
        }
示例#11
0
 public static void SetUVPoints(TopoDSEdge E, GeomSurface S, TopLocLocation L, gpPnt2d PFirst, gpPnt2d PLast)
 {
     BRep_Tool_SetUVPointsCD33147E(E.Instance, S.Instance, L.Instance, PFirst.Instance, PLast.Instance);
 }
示例#12
0
 public void D3(double U, gpPnt2d P, gpVec2d V1, gpVec2d V2, gpVec2d V3)
 {
     Adaptor2d_HCurve2d_D3A3CC6934(Instance, U, P.Instance, V1.Instance, V2.Instance, V3.Instance);
 }
示例#13
0
 public void D2(double U, gpPnt2d P, gpVec2d V1, gpVec2d V2)
 {
     Adaptor2d_HCurve2d_D2DCE527F4(Instance, U, P.Instance, V1.Instance, V2.Instance);
 }
示例#14
0
 public void Set(gpPnt2d P)
 {
     Bnd_Box2d_Set6203658C(Instance, P.Instance);
 }
示例#15
0
 public TopAbsState ClassifyUVPoint(gpPnt2d Puv)
 {
     return((TopAbsState)IntCurvesFace_Intersector_ClassifyUVPoint6203658C(Instance, Puv.Instance));
 }
示例#16
0
 public void Set(gpPnt2d P, gpDir2d D)
 {
     Bnd_Box2d_Set2E9C6BD1(Instance, P.Instance, D.Instance);
 }
 public void SetVertexTexel(int anIndex, gpPnt2d aTexel)
 {
     Graphic3d_ArrayOfPrimitives_SetVertexTexel5174DA04(Instance, anIndex, aTexel.Instance);
 }
示例#18
0
 public void Add(gpPnt2d P, gpDir2d D)
 {
     Bnd_Box2d_Add2E9C6BD1(Instance, P.Instance, D.Instance);
 }
示例#19
0
 public void D0(double U, gpPnt2d P)
 {
     Adaptor2d_HCurve2d_D0F34E6A40(Instance, U, P.Instance);
 }