Ejemplo n.º 1
0
        private void BuildAndEnterSketch(Document document)
        {
            var sketchCreator     = new SketchCreator(document);
            var currentSketch     = sketchCreator.CurrentSketch;
            var sketchNodeBuilder = new NodeBuilder(currentSketch);

            Document.Transact();

            Log.InfoFormat("StartSketch - Command line input");
            var firstvector    = new gpDir(Points[1].GpPnt.X - Points[0].GpPnt.X, Points[1].GpPnt.Y - Points[0].GpPnt.Y, Points[1].GpPnt.Z - Points[0].GpPnt.Z);
            var secondvector   = new gpDir(Points[2].GpPnt.X - Points[0].GpPnt.X, Points[2].GpPnt.Y - Points[0].GpPnt.Y, Points[2].GpPnt.Z - Points[0].GpPnt.Z);
            var normal         = firstvector.Crossed(secondvector);
            var _normalOnPlane = new gpAx1(Points[0].GpPnt, normal);
            var sketchAx2      = new gpAx2();

            sketchAx2.Axis = (_normalOnPlane);
            var plane = new gpPln(new gpAx3(sketchAx2));

            Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.SetPlane, plane);
            sketchNodeBuilder[0].Axis3D = new Axis(sketchNodeBuilder[0].Axis3D.Location, new Point3D(new gpPnt(_normalOnPlane.Direction.XYZ)));
            HighlightCurrentSketchNodes(sketchNodeBuilder.Node);
            NodeBuilderUtils.HidePlanes(Document);
            Document.Commit("sketch created");
            AddNodeToTree(sketchNodeBuilder.Node);
            Document.Transact();
            Document.Root.Get <DocumentContextInterpreter>().ActiveSketch = sketchNodeBuilder.Node.Index;
            _sketchButton.Block();
            Document.Commit("Started editing sketch");
        }
 public ParallelLineMatch(GeometricSolver solver, double precision)
     : base(solver)
 {
     _precision = precision;
     _oxDir     = gp.OX.Direction;
     _oyDir     = gp.OY.Direction;
     _ozDir     = gp.OZ.Direction;
 }
Ejemplo n.º 3
0
        private bool AxisParallel(Point3D currentPoint, Point3D initialPosition, double angleRange)
        {
            if (currentPoint.IsEqual(initialPosition))
            {
                return(false);
            }
            var direction = new gpDir(new gpVec(initialPosition.GpPnt, currentPoint.GpPnt));

            return(_axisDirection.IsParallel(direction, angleRange));
        }
Ejemplo n.º 4
0
        public int Box(double x, double y, double z, double x1, double y1, double z1, double x3, double y3, double z3,
                       double height)
        {
            var dir    = new gpDir(x1, y1, z1);
            var axis   = new gpAx1(new gpPnt(x, y, z), dir);
            var point3 = new Point3D(x3, y3, z3);

            var node = TreeUtils.AddBox(Document, axis, point3, height);

            return(node.Index);
        }
Ejemplo n.º 5
0
 public void StartDragging(SceneSelectedEntity handleNode)
 {
     IsDragging = true;
     if (SelectedEntity.ShapeType == TopAbsShapeEnum.TopAbs_FACE)
     {
         selectedShape    = SelectedEntity.TargetShape();
         prevFaceCount    = -1;
         initialDirection = GeomUtils.ExtractDirection(SelectedEntity.TargetShape());
         DraggingIndex    = 0;// _handles[FunctionNames.AxisHandle];
     }
 }
Ejemplo n.º 6
0
        public override bool Execute()
        {
            var position  = Dependency[0].TransformedPoint3D;
            var direction = new gpDir(Dependency[1].TransformedPoint3D.GpPnt.XYZ);

            var line       = new GeomLine(new gpLin(position.GpPnt, direction));
            var helperLine = OccShapeCreatorCode.BuildDottedLine(line);

            Interactive = helperLine;
            return(true);
        }
        /// <summary>
        ///   Detects paralellism with axis
        /// </summary>
        /// <param name = "currentPoint"></param>
        /// <param name = "initialPosition"></param>
        /// <returns></returns>
        public SolverPreviewObject AxisParallel(Point3D currentPoint, Point3D initialPosition)
        {
            var direction = new gpDir(new gpVec(initialPosition.GpPnt, currentPoint.GpPnt));

            var axisDirection = _oxDir;

            if (axisDirection.IsParallel(direction, _precision))
            {
                var point = GetOtherPoint(initialPosition, currentPoint, axisDirection);
                if (point == null)
                {
                    return(null);
                }
                var solverPoint = new SolverEdgeTwoPointsResult(point.Value, initialPosition, Color.Red)
                {
                    Type = "Parallel X"
                };
                return(solverPoint);
            }
            axisDirection = _oyDir;
            if (axisDirection.IsParallel(direction, _precision))
            {
                //return ProjectPointOnDirection(initialPosition, currentPoint, axisDirection, Color.Green);
                var point = GetOtherPoint(initialPosition, currentPoint, axisDirection);
                if (point == null)
                {
                    return(null);
                }
                var solverPoint = new SolverEdgeTwoPointsResult(point.Value, initialPosition, Color.Red)
                {
                    Type = "Parallel Y"
                };
                return(solverPoint);
            }
            axisDirection = _ozDir;
            if (axisDirection.IsParallel(direction, _precision))
            {
                //return ProjectPointOnDirection(initialPosition, currentPoint, axisDirection, Color.Blue);
                var point = GetOtherPoint(initialPosition, currentPoint, axisDirection);
                if (point == null)
                {
                    return(null);
                }
                var solverPoint = new SolverEdgeTwoPointsResult(point.Value, initialPosition, Color.Red)
                {
                    Type = "Parallel Z"
                };
                return(solverPoint);
            }

            return(null);
        }
Ejemplo n.º 8
0
        private static double GetPreviousMajorRadius(NodeBuilder builder)
        {
            bool   reversed;
            gpDir  dirX = null;
            gpDir  dirY = null;
            double previousMinorRadius;
            double previousMajorRadius;

            TreeUtils.ComputeEllipseRadiuses(builder[0].TransformedPoint3D, builder[1].TransformedPoint3D, builder[2].TransformedPoint3D,
                                             out previousMinorRadius, out previousMajorRadius, out reversed,
                                             ref dirX, ref dirY);
            return(previousMajorRadius);
        }
        /// <summary>
        ///   Detects paralellism with axis
        /// </summary>
        /// <param name = "currentPoint"></param>
        /// <param name = "initialPosition"></param>
        /// <returns></returns>
        private SolverPreviewObject AxisParallel(Point3D currentPoint, Point3D initialPosition)
        {
            var direction = new gpDir(new gpVec(initialPosition.GpPnt, currentPoint.GpPnt));

            foreach (var dir in _directions)
            {
                if (dir.IsParallel(direction, _precision))
                {
                    return(ParallelLineMatch.ProjectPointOnDirection(initialPosition, currentPoint, dir, Color.Black));
                }
            }
            return(null);
        }
Ejemplo n.º 10
0
        private void SetSecondPointDraggingHandle(gpVec vectorV2V1, Mouse3DPosition vertex, Point3D secondPoint)
        {
            if (_secondPointProjectionDirection == null)
            {
                _secondPointProjectionDirection = new gpDir(vectorV2V1);
            }
            var secondPointProjectionPlane = new gpPln(vertex.Point.GpPnt, _secondPointProjectionDirection);
            var secondProjectedPoint       = GeomUtils.ProjectPointOnPlane(secondPoint.GpPnt, secondPointProjectionPlane,
                                                                           Precision.Confusion);

            Dependency[1].TransformedPoint3D = new Point3D(secondProjectedPoint);
            Dependency[2].TransformedPoint3D = vertex.Point;
        }
        public static Point3D?ProjectPointOnLine(Point3D firstLinePoint, gpDir lineDirection, Point3D pointToProject)
        {
            // Make a parallel line with this line starting from the initial point
            var projectionLine  = new gceMakeLin(firstLinePoint.GpPnt, lineDirection).Value;
            var geomLine        = new GeomLine(projectionLine);
            var projectionPoint = new GeomAPIProjectPointOnCurve(pointToProject.GpPnt, geomLine);

            if (projectionPoint.NbPoints > 0)
            {
                return(new Point3D(projectionPoint.NearestPoint));
            }

            return(null);
        }
        private Point3D?GetOtherPoint(Point3D firstLinePoint, Point3D secondLinePoint,
                                      gpDir direction)
        {
            // Make a parallel line with this line starting from the initial point
            var parallelLine    = new gceMakeLin(firstLinePoint.GpPnt, direction).Value;
            var geomLine        = new GeomLine(parallelLine);
            var projectionPoint = new GeomAPIProjectPointOnCurve(secondLinePoint.GpPnt, geomLine);

            if (projectionPoint.NbPoints <= 0)
            {
                return(null);
            }
            return(new Point3D(projectionPoint.NearestPoint));
        }
        /// <summary>
        ///   Builds a rectangle from 2 points received as parameter.
        ///   Rectangle:
        ///   P2--------P3
        ///   P1--------P4
        /// </summary>
        /// <param name = "firstPoint"></param>
        /// <param name = "thirdPoint"></param>
        /// <param name = "direction"></param>
        /// <returns></returns>
        public static TopoDSFace BuildRectangle(gpPnt firstPoint, gpPnt thirdPoint, gpDir direction)
        {
            // Check for point coincidence
            if (firstPoint.IsEqual(thirdPoint, Precision.Confusion))
            {
                return(null);
            }

            var secondPoint = new gpPnt();
            var fourthPoint = new gpPnt();

            GeomUtils.CalculateRectangleVertexes(firstPoint, thirdPoint, direction, ref secondPoint, ref fourthPoint);
            return(BuildRectangle(new Point3D(firstPoint), new Point3D(secondPoint), new Point3D(fourthPoint)));
        }
Ejemplo n.º 14
0
        private static gpPln BuildNormalPlane(gpDir dir, Axis gravityAxis)
        {
            var gravityCenter = gravityAxis.Location;
            var plane         = new gpPln(gravityCenter.GpPnt, dir);
            var newPoint      = gravityCenter;

            newPoint.X += 1;
            newPoint.Y += 2;
            newPoint.Z += 3;
            var result      = GeomUtils.ProjectPointOnPlane(newPoint.GpPnt, plane, Precision.Confusion);
            var resultPlane = GeomUtils.BuildPlane(gravityCenter, new Point3D(result),
                                                   gravityAxis.Location.AddCoordinate(gravityAxis.Direction));

            return(resultPlane);
        }
Ejemplo n.º 15
0
        public static Node AddSketchNode(Document document, Point3D point1, Point3D point2, Point3D point3)
        {
            //var sketchCreator = new SketchCreator(document);
            //var currentSketch = sketchCreator.CurrentSketch;
            var sketchNodeBuilder = new NodeBuilder(document, FunctionNames.Sketch);
            var firstvector       = new gpDir(point2.GpPnt.X - point1.GpPnt.X, point2.GpPnt.Y - point1.GpPnt.Y, point2.GpPnt.Z - point1.GpPnt.Z);
            var secondvector      = new gpDir(point3.GpPnt.X - point1.GpPnt.X, point3.GpPnt.Y - point1.GpPnt.Y, point3.GpPnt.Z - point1.GpPnt.Z);
            var normal            = firstvector.Crossed(secondvector);
            var _normalOnPlane    = new gpAx1(point1.GpPnt, normal);
            var sketchAx2         = new gpAx2();

            sketchAx2.Axis = (_normalOnPlane);
            sketchNodeBuilder[0].TransformedAxis3D = _normalOnPlane;

            return(!sketchNodeBuilder.ExecuteFunction() ? null : sketchNodeBuilder.Node);
        }
Ejemplo n.º 16
0
        private double GetPreviousMajorRadius()
        {
            bool   reversed;
            gpDir  dirX = null;
            gpDir  dirY = null;
            double previousMinorRadius;
            double previousMajorRadius;
            var    firstPoint  = Builder[0].ReferenceBuilder[1].TransformedPoint3D;
            var    secondPoint = Builder[1].ReferenceBuilder[1].TransformedPoint3D;
            var    thirdPoint  = Builder[2].ReferenceBuilder[1].TransformedPoint3D;

            TreeUtils.ComputeEllipseRadiuses(firstPoint, secondPoint, thirdPoint,
                                             out previousMinorRadius, out previousMajorRadius, out reversed,
                                             ref dirX, ref dirY);
            return(previousMajorRadius);
        }
        /// <summary>
        ///   Builds an ellipse from 3 points in space
        /// </summary>
        private static TopoDSWire BuildEllipse(Point3D center, Point3D secondPoint, Point3D thirdPoint)
        {
            double minorRadius;
            double majorRadius;
            bool   reversed;
            gpDir  dirX = null;
            gpDir  dirY = null;

            if (secondPoint.GpPnt.Distance(thirdPoint.GpPnt) < Precision.Confusion)
            {
                return(null);
            }


            if (!TreeUtils.ComputeEllipseRadiuses(center, secondPoint, thirdPoint,
                                                  out minorRadius, out majorRadius, out reversed,
                                                  ref dirX, ref dirY))
            {
                return(null);
            }
            // Build a plane from the 3 points
            var plane = GeomUtils.BuildPlane(center, secondPoint, thirdPoint);
            var ax1   = plane.Axis;
            var ax2   = new gpAx2();

            ax2.Axis     = (ax1);
            ax2.Location = (center.GpPnt);

            // If major and minor radius are reversed also their directions arereversed
            if (!reversed)
            {
                ax2.XDirection = (dirX);
                ax2.YDirection = (dirY);
            }
            else
            {
                ax2.XDirection = (dirY);
                ax2.YDirection = (dirX);
            }

            var ellipse = new GeomEllipse(ax2, majorRadius, minorRadius);
            var edge    = new BRepBuilderAPIMakeEdge(ellipse).Edge;
            var wire    = new BRepBuilderAPIMakeWire(edge).Wire;

            return(wire);
        }
Ejemplo n.º 18
0
        /// <summary>
        ///   Receives click events. Called at mouse down and at mouse up.
        /// </summary>
        /// <param name = "mouseData"></param>
        protected override void OnMouseClick3DAction(Mouse3DPosition mouseData)
        {
            if (!mouseData.MouseDown)
            {
                return;
            }
            AddToPointList(mouseData.Point);
            // Start a line drawing process
            if (Points.Count == 1)
            {
                var face = CurrentFacePicked;
                if (face != null)
                {
                    _direction = GeomUtils.ExtractDirection(face);
                }
                Log.Info("Line Normal - draw line started");
                return;
            }

            // The line drawing finished
            Log.Info("Line Normal - draw line finished");

            // Create line
            var normalPoint = (Point3D)GeomUtils.ProjectPointOnLine(Points[0], _direction, mouseData.Point);

            if (Points[0].IsEqual(normalPoint))
            {
                return;
            }

            InitSession();
            var node = TreeUtils.AddLineToNode(Document, Points[0], normalPoint).Node;

            if (node == null)
            {
                Document.Revert();
                BackToNeutralModifier();
                return;
            }

            // Commit
            CommitFinal("Line Normal");
            _temporary = new NodeBuilder(null);
        }
Ejemplo n.º 19
0
        public static bool BuildFaceDraft(BRepOffsetAPIDraftAngle draft, TopoDSFace draftedFace,
                                          gpDir draftDirection, double angle, gpPln neutralPlane)
        {
            try
            {
                draft.Add(draftedFace, draftDirection, angle, neutralPlane, true);
                if (!draft.AddDone)
                {
                    //draft.Remove(draftedFace);
                    return(false);
                }
            }
            catch (Exception)
            {
                return(false);
            }

            return(true);
        }
        /// <summary>
        ///   Calculates the projection of the second line point on the direction so that the line created from
        ///   [first point, projection] is parallel with direction.
        /// </summary>
        /// <param name = "firstLinePoint"></param>
        /// <param name = "secondLinePoint"></param>
        /// <param name = "direction"></param>
        /// <param name = "color"></param>
        /// <returns></returns>
        public static SolverPreviewObject ProjectPointOnDirection(Point3D firstLinePoint, Point3D secondLinePoint,
                                                                  gpDir direction, Color color)
        {
            // Make a parallel line with this line starting from the initial point
            var parallelLine    = new gceMakeLin(firstLinePoint.GpPnt, direction).Value;
            var geomLine        = new GeomLine(parallelLine);
            var projectionPoint = new GeomAPIProjectPointOnCurve(secondLinePoint.GpPnt, geomLine);

            if (projectionPoint.NbPoints <= 0)
            {
                return(null);
            }
            var firstParallelPoint  = new Point3D(projectionPoint.NearestPoint);
            var secondParallelPoint = firstLinePoint;
            var solverPoint         = new SolverEdgeTwoPointsResult(firstParallelPoint, secondParallelPoint, color)
            {
                Type = "Parallel Line"
            };

            return(solverPoint);
        }
        private NodeBuilder BuildFloor(ShapeBoundBox bounding)
        {
            var floorRectangle  = new NodeBuilder(_mirrorDocument, FunctionNames.Rectangle);
            var startFloorPoint = new Point3D(bounding.Coordinate.X - _range,
                                              bounding.Coordinate.Y - _range,
                                              bounding.Coordinate.Z);
            var dir           = new gpDir(0, 0, 1);
            var endFloorPoint = new Point3D(
                bounding.Coordinate.X + bounding.Dimensions.X + _range,
                bounding.Coordinate.Y + bounding.Dimensions.Y + _range,
                bounding.Coordinate.Z);

            floorRectangle[0].Axis3D             = new Axis(new gpAx1(startFloorPoint.GpPnt, dir));
            floorRectangle[1].TransformedPoint3D = endFloorPoint;

            floorRectangle.Color        = Color.White;
            floorRectangle.Transparency = 0.8;
            floorRectangle.ExecuteFunction();
            _mirrorDocument.Commit("tranparent floor");
            return(floorRectangle);
        }
Ejemplo n.º 22
0
        /// <summary>
        ///   Calculates the computer radiuses knowing the center position and two points located on the two axis
        /// </summary>
        public static bool ComputeEllipseRadiuses(Point3D center, Point3D secondPoint, Point3D thirdPoint,
                                                  out double minorRadius, out double majorRadius,
                                                  out bool reversed, ref gpDir dirX, ref gpDir dirY)
        {
            // Calculate the major radius
            majorRadius = center.GpPnt.Distance(secondPoint.GpPnt);
            // Calculate also the axis/direction of the major radus
            var vecX = new gpVec(center.GpPnt, secondPoint.GpPnt);

            dirX = new gpDir(vecX);
            var line = new gpLin(center.GpPnt, dirX);

            // Calculate the minor radius
            minorRadius = line.Distance(thirdPoint.GpPnt);
            reversed    = false;
            if (minorRadius < Precision.Confusion || majorRadius < Precision.Confusion)
            {
                return(false);
            }
            // Calculate also the axis/direction of the major radus
            var vecY = new gpVec(center.GpPnt, thirdPoint.GpPnt);
            // We want the direction to be perpendicular on the direction of the major radius
            var vecZ = vecX.Crossed(vecY);

            vecY = vecX.Crossed(vecZ);
            dirY = new gpDir(vecY);

            // Major radius must be bigger than minor radius

            if (minorRadius > majorRadius)
            {
                var aux = majorRadius;
                majorRadius = minorRadius;
                minorRadius = aux;
                reversed    = true;
            }
            return(true);
        }
Ejemplo n.º 23
0
        private static void SetRadius(NodeBuilder ellipseBuilder, double majorRadius, double minorRadius)
        {
            bool   reversed;
            gpDir  dirX = null;
            gpDir  dirY = null;
            double previousMinorRadius;
            double previousMajorRadius;

            TreeUtils.ComputeEllipseRadiuses(ellipseBuilder[0].TransformedPoint3D, ellipseBuilder[1].TransformedPoint3D,
                                             ellipseBuilder[2].TransformedPoint3D,
                                             out previousMinorRadius, out previousMajorRadius, out reversed,
                                             ref dirX, ref dirY);
            // Calculate the ratio needed to scale the radiuses
            var scaleMajor = majorRadius / previousMajorRadius;
            var scaleMinor = minorRadius / previousMinorRadius;

            var center = ellipseBuilder[0].TransformedPoint3D;

            var translatedPoint  = new Point3D(center.X, center.Y, center.Z);
            var translatedPoint2 = new Point3D(center.X, center.Y, center.Z);

            // If minor radius is smaller than major radius
            if (!reversed)
            {
                translatedPoint = TreeUtils.ScaleSegment(translatedPoint, ellipseBuilder[1].TransformedPoint3D, scaleMajor);
                ellipseBuilder[1].TransformedPoint3D = translatedPoint;
                TreeUtils.ScaleSegment(translatedPoint2, ellipseBuilder[2].TransformedPoint3D, scaleMinor);
                ellipseBuilder[2].TransformedPoint3D = translatedPoint2;
            }
            else
            {
                translatedPoint = TreeUtils.ScaleSegment(translatedPoint, ellipseBuilder[1].TransformedPoint3D, scaleMinor);
                ellipseBuilder[1].TransformedPoint3D = translatedPoint;
                TreeUtils.ScaleSegment(translatedPoint2, ellipseBuilder[2].TransformedPoint3D, scaleMajor);
                ellipseBuilder[2].TransformedPoint3D = translatedPoint2;
            }
        }
Ejemplo n.º 24
0
        private void SetRadius(Double majorRadius, Double minorRadius)
        {
            bool   reversed;
            gpDir  dirX = null;
            gpDir  dirY = null;
            double previousMinorRadius;
            double previousMajorRadius;
            var    firstPoint  = Builder[0].ReferenceBuilder[1].TransformedPoint3D;
            var    secondPoint = Builder[1].ReferenceBuilder[1].TransformedPoint3D;
            var    thirdPoint  = Builder[2].ReferenceBuilder[1].TransformedPoint3D;

            TreeUtils.ComputeEllipseRadiuses(firstPoint, secondPoint, thirdPoint,
                                             out previousMinorRadius, out previousMajorRadius, out reversed,
                                             ref dirX, ref dirY);
            // Calculate the ratio needed to scale the radiuses
            var scaleMajor = majorRadius / previousMajorRadius;
            var scaleMinor = minorRadius / previousMinorRadius;

            var center = firstPoint;

            var translatedPoint  = new Point3D(center.X, center.Y, center.Z);
            var translatedPoint2 = new Point3D(center.X, center.Y, center.Z);

            // If minor radius is smaller than major radius
            if (!reversed)
            {
                Builder[1].ReferenceBuilder[1].TransformedPoint3D = TreeUtils.ScaleSegment(translatedPoint, secondPoint, scaleMajor);
                Builder[2].ReferenceBuilder[1].TransformedPoint3D = TreeUtils.ScaleSegment(translatedPoint2, thirdPoint, scaleMinor);
            }
            else
            {
                Builder[1].ReferenceBuilder[1].TransformedPoint3D = TreeUtils.ScaleSegment(translatedPoint, secondPoint, scaleMinor);
                Builder[2].ReferenceBuilder[1].TransformedPoint3D = TreeUtils.ScaleSegment(translatedPoint2, thirdPoint, scaleMajor);
            }
            NodeBuilderUtils.UpdateSketchesOnFaces(new NodeBuilder(Parent));
        }
Ejemplo n.º 25
0
 public GeomLine(gpPnt P, gpDir V)
     :
     base(Geom_Line_CtorE13B639C(P.Instance, V.Instance))
 {
 }
Ejemplo n.º 26
0
 protected abstract bool LinesAxisMatch(gpDir axisDir, gpDir direction, double angleRange);
Ejemplo n.º 27
0
 public gceMakeLin(gpPnt P, gpDir V)
     :
     base(gce_MakeLin_CtorE13B639C(P.Instance, V.Instance))
 {
 }
 protected override bool LinesAxisMatch(gpDir axisDir, gpDir direction, double angleRange)
 {
     return(axisDir.IsParallel(direction, angleRange));
 }
 public bool Orientate(gpDir aNormal)
 {
     return(Graphic3d_ArrayOfPrimitives_OrientateCEC711A5(Instance, aNormal.Instance));
 }
 public int AddVertex(gpPnt aVertice, gpDir aNormal, gpPnt2d aTexel)
 {
     return(Graphic3d_ArrayOfPrimitives_AddVertex640114B2(Instance, aVertice.Instance, aNormal.Instance, aTexel.Instance));
 }