public static dynamic GetTSObject(VertexEnumerator dynObject)
 {
     if (dynObject is null)
     {
         return(null);
     }
     return(dynObject.teklaObject);
 }
Example #2
0
        private void WriteGeometry(XmlTextWriter writer, Part part, Model myModel)
        {
            if (part != null)
            {
                WorkPlaneHandler    planeHandler = myModel.GetWorkPlaneHandler();
                TransformationPlane CurrentPlane = planeHandler.GetCurrentTransformationPlane();

                writer.WriteStartElement("Part", null);
                writer.WriteAttributeString("id", part.Identifier.ID.ToString());
                writer.WriteElementString("name", part.Name);
                writer.WriteElementString("material", part.Material.MaterialString);
                writer.WriteStartElement("profile", null);
                writer.WriteElementString("name", part.Profile.ProfileString);
                writer.WriteEndElement();

                Solid          solid      = part.GetSolid() as Solid;
                FaceEnumerator myFaceEnum = solid.GetFaceEnumerator();
                writer.WriteStartElement("Solid", null);
                while (myFaceEnum.MoveNext())
                {
                    Face myFace = myFaceEnum.Current as Face;
                    if (myFace != null)
                    {
                        writer.WriteStartElement("Face", null);
                        LoopEnumerator myLoopEnum = myFace.GetLoopEnumerator();
                        while (myLoopEnum.MoveNext())
                        {
                            Loop myLoop = myLoopEnum.Current as Loop;
                            if (myLoop != null)
                            {
                                writer.WriteStartElement("Loop", null);
                                VertexEnumerator myVertexEnum = myLoop.GetVertexEnumerator() as VertexEnumerator;
                                while (myVertexEnum.MoveNext())
                                {
                                    Point myVertex = myVertexEnum.Current as Point;
                                    if (myVertex != null)
                                    {
                                        writer.WriteStartElement("Vertex", null);
                                        writer.WriteElementString("X", myVertex.X.ToString("#.##"));
                                        writer.WriteElementString("Y", myVertex.Y.ToString("#.##"));
                                        writer.WriteElementString("Z", myVertex.Z.ToString("#.##"));
                                        writer.WriteEndElement(); // End Vertex
                                    }
                                }
                                writer.WriteEndElement(); // End Loop
                            }
                        }
                        writer.WriteEndElement(); //  End Face
                    }
                }
                writer.WriteEndElement(); // End Solid

                planeHandler.SetCurrentTransformationPlane(CurrentPlane);
                writer.WriteEndElement();
            }
        }
        public static List <Point> ToList(this VertexEnumerator vertexEnumerator)
        {
            var vertexes = new List <Point>();

            while (vertexEnumerator.MoveNext())
            {
                var vertex = vertexEnumerator.Current;
                vertexes.Add(vertex);
            }
            return(vertexes);
        }
Example #4
0
        internal static Dictionary <Plane, Face> GetGeometricPlane(Solid solid)
        {
            FaceEnumerator           FaceEnum = solid.GetFaceEnumerator();
            Dictionary <Plane, Face> Planes   = new Dictionary <Plane, Face>();

            while (FaceEnum.MoveNext())
            {
                List <Point> PlaneVertexes = new List <Point>();

                Face face = FaceEnum.Current as Face;

                LoopEnumerator Loops = face.GetLoopEnumerator();

                while (Loops.MoveNext())
                {
                    Loop             loop     = Loops.Current as Loop;
                    VertexEnumerator vertexes = loop.GetVertexEnumerator();

                    while (vertexes.MoveNext())
                    {
                        Point Vertex = vertexes.Current as Point;
                        if (!PlaneVertexes.Contains(Vertex))
                        {
                            if (PlaneVertexes.Count != 3 || (PlaneVertexes.Count == 3 && !ArePointAligned(PlaneVertexes[0], PlaneVertexes[1], Vertex)))
                            {
                                PlaneVertexes.Add(Vertex);
                            }

                            if (PlaneVertexes.Count == 3)
                            {
                                Vector Vector1 = new Vector(PlaneVertexes[1].X - PlaneVertexes[0].X, PlaneVertexes[1].Y - PlaneVertexes[0].Y,
                                                            PlaneVertexes[1].Z - PlaneVertexes[0].Z);
                                Vector Vector2 = new Vector(PlaneVertexes[2].X - PlaneVertexes[0].X, PlaneVertexes[2].Y - PlaneVertexes[0].Y,
                                                            PlaneVertexes[2].Z - PlaneVertexes[0].Z);

                                Plane plane = new Plane
                                {
                                    Origin = PlaneVertexes[0],
                                    AxisX  = Vector1,
                                    AxisY  = Vector2
                                };
                                Planes.Add(plane, face);
                                break;
                            }
                        }
                    }
                    break;
                }
            }
            return(Planes);
        }
        internal static Dictionary <Plane, Face> GetGeometricPlanes(Solid solid)
        {
            // Face(삼각면)
            FaceEnumerator           faceEnum = solid.GetFaceEnumerator();
            Dictionary <Plane, Face> planes   = new Dictionary <Plane, Face>();

            while (faceEnum.MoveNext())
            {
                List <Point> planeVertexes = new List <Point>();

                Face face = faceEnum.Current as Face;

                LoopEnumerator loops = face.GetLoopEnumerator();
                while (loops.MoveNext())
                {
                    Loop             loop     = loops.Current as Loop;
                    VertexEnumerator vertexes = loop.GetVertexEnumerator();

                    while (vertexes.MoveNext())
                    {
                        Point vertex = vertexes.Current as Point;
                        if (!planeVertexes.Contains(vertex))
                        {
                            //Three Points form a plane and they cannot be aligned.
                            if (planeVertexes.Count != 3 ||
                                (planeVertexes.Count == 3 && !ArePointAligned(planeVertexes[0], planeVertexes[1], vertex)))
                            {
                                planeVertexes.Add(vertex);
                            }

                            if (planeVertexes.Count == 3)
                            {
                                Vector vector1 = new Vector(planeVertexes[1].X - planeVertexes[0].X, planeVertexes[1].Y - planeVertexes[0].Y, planeVertexes[1].Z - planeVertexes[0].Z);
                                Vector vector2 = new Vector(planeVertexes[2].X - planeVertexes[0].X, planeVertexes[2].Y - planeVertexes[0].Y, planeVertexes[2].Z - planeVertexes[0].Z);

                                Plane plane = new Plane();
                                plane.Origin = planeVertexes[0];
                                plane.AxisX  = vector1;
                                plane.AxisY  = vector2;
                                planes.Add(plane, face);
                                break;
                            }
                        }
                    }
                    break;
                }
            }
            return(planes);
        }
        private static void DrawMesh(Face face)
        {
            GraphicsDrawer graphicsDrawer = new GraphicsDrawer();
            Mesh           mesh           = new Mesh();
            LoopEnumerator loops          = face.GetLoopEnumerator();

            loops.MoveNext();
            Loop             loop     = loops.Current as Loop;
            VertexEnumerator vertexes = loop.GetVertexEnumerator();

            while (vertexes.MoveNext())
            {
                mesh.AddPoint(vertexes.Current as Point);
            }

            for (int index = 0; index < mesh.Points.Count - 2; index++)
            {
                mesh.AddTriangle(index, index + 1, index + 2);
                mesh.AddTriangle(index + 2, index + 1, index);
            }

            graphicsDrawer.DrawMeshSurface(mesh, new Color(1, 0, 0));
        }