void SpanningTree()
    {
        var points = RandomPoints(400);

        var vertices = points
                       .Select(p => new Vertex()
        {
            Location = p
        })
                       .ToList();

        var triangulation = Triangulation.CreateDelaunay <Vertex, Face>(vertices);
        var edges         = triangulation.Cells.SelectMany(f => f.GetEdges())
                            .Distinct()
                            .Where(e => e.Length < 0.2f);

        var edgeList = edges.ToList();
        var graph    = edgeList.ToUndirectedGraph <Vertex, Edge>();
        var tree     = graph.MinimumSpanningTreePrim(GetWeight).ToList();


        foreach (var edge in edgeList)
        {
            edge.Value = 0.3f;
        }

        foreach (var edge in tree)
        {
            edge.Value = 1.0f;
        }

        SetMeshFromEdges(edgeList);
        PaintEdges(edgeList);
    }
Beispiel #2
0
        /// <summary>
        /// Triangulate cell with the provided vertices.
        /// </summary>
        /// <param name="vertices">The vertices of the cell.</param>
        /// <returns>The triangulation.</returns>
        private IEnumerable <DefaultTriangulationCell <MIVertex> > Triangulate(List <Vector3D> vertices)
        {
            IEnumerable <DefaultTriangulationCell <MIVertex> > triangles = null;

            // Convert vertices to objects that work with MIConvexHull library
            MIVertex[] miVertices = new MIVertex[vertices.Count];
            for (int i = 0; i < vertices.Count; i++)
            {
                miVertices[i] = new MIVertex(vertices[i].X, vertices[i].Y, vertices[i].Z);
            }

            if (vertices.Count == 4)
            {
                // MIConvexHull library cannot create a triangulation from a single tetrahedron
                triangles = new List <DefaultTriangulationCell <MIVertex> >()
                {
                    new DefaultTriangulationCell <MIVertex>()
                    {
                        Vertices = miVertices
                    }
                };
            }
            else
            {
                // More vertices are OK so let the library to triangulate them
                var triangulation = Triangulation.CreateDelaunay(miVertices);
                triangles = triangulation.Cells;
            }

            return(triangles);
        }
Beispiel #3
0
        public static Vector2 GetSpawnPoint()
        {
            var vertices      = new Vertex2[4 + spaceships.Count + shots.Count];
            var index         = 0;
            var spaceHalfSize = Game.Size / 2;

            vertices[index++] = new Vertex2(-spaceHalfSize.x, -spaceHalfSize.y);
            vertices[index++] = new Vertex2(spaceHalfSize.x, -spaceHalfSize.y);
            vertices[index++] = new Vertex2(-spaceHalfSize.x, spaceHalfSize.y);
            vertices[index++] = new Vertex2(spaceHalfSize.x, spaceHalfSize.y);
            foreach (var obj in spaceships)
            {
                vertices[index++] = new Vertex2(obj.Position.x, obj.Position.y);
            }
            foreach (var obj in shots)
            {
                vertices[index++] = new Vertex2(obj.Position.x, obj.Position.y);
            }
            var   triangulation = Triangulation.CreateDelaunay <Vertex2, Cell2>(vertices);
            Cell2 maxTriangle   = triangulation.Cells.First();
            float maxArea       = 0;

            foreach (var triangle in triangulation.Cells)
            {
                var area = triangle.Area;
                if (area > maxArea)
                {
                    maxArea     = area;
                    maxTriangle = triangle;
                }
            }
            return(maxTriangle.Centroid);
        }
        /// <summary>
        /// returns a list of points of tetrahedrons in a given point cloud
        /// </summary>
        /// <param name="pointCloud">input point cloud</param>
        /// <returns>list of tetrahedrons</returns>
        public static List <List <Point> > calculateDelaunayTrianglePoints(PointCloud pointCloud)
        {
            List <List <Point> > retList = new List <List <Point> >();

            try
            {
                //create vertex list
                HashSet <Vertex> vertices = new HashSet <Vertex>();
                foreach (Point p in pointCloud.pointcloud_hs)
                {
                    vertices.Add(new Vertex(p.point.X, p.point.Y, p.point.Z));
                }

                //calculate tetrahedrons
                var tetrahedrons = Triangulation.CreateDelaunay <Vertex, Tetrahedron>(vertices).Cells;

                foreach (var c in tetrahedrons)
                {
                    List <Point> pL = new List <Point>();
                    for (int i = 0; i < 4; i++)
                    {
                        Point p = new Point(new ANX.Framework.Vector3((float)c.Vertices[i].Position[0], (float)c.Vertices[i].Position[1], (float)c.Vertices[i].Position[2]));
                        pL.Add(p);
                    }
                    retList.Add(pL);
                }
            }
            catch (Exception) { throw; }
            return(retList);
        }
Beispiel #5
0
        static TimeSpan TestNDDelau(int dim, int numVert, double size)
        {
            var vertices = CreateRandomVertices(dim, numVert, size);

            return(RunComputation(() =>
            {
                var r = Triangulation.CreateDelaunay(vertices);
                Console.WriteLine(r.Cells.Count());
                return r;
            }));
        }
Beispiel #6
0
        /// <summary>
        /// Ring:划分Delaunay三角网,结果保存于tsData
        /// </summary>
        /// <param name="depth">深度</param>
        /// <param name="interpolateFunc">插值函数</param>
        public void MeshRing(
            double depth,
            Func <IList <Point>, double, double, double, double> interpolateFunc)
        {
            try
            {
                triangulations = Triangulation.CreateDelaunay(this.allVerticesList);


                this.TsData.VerticesList = new List <Point3D>(this.allVerticesList.Count);
                this.TsData.TriLinksList = new List <TriLink>(this.triangulations.Cells.Count());

                // 以Dict记录三角形的编号
                int num = 1;
                foreach (var cell in this.triangulations.Cells)
                {
                    for (int i = 0; i < 3; ++i)
                    {
                        var v = cell.Vertices[i];
                        if (!this.vertexnumDictionary.ContainsKey(v))
                        {
                            this.vertexnumDictionary.Add(v, num++);
                        }
                    }

                    // 根据编号写ts的TriLinksList
                    this.TsData.TriLinksList.Add(new TriLink
                    {
                        VertexA = this.vertexnumDictionary[cell.Vertices[0]],
                        VertexB = this.vertexnumDictionary[cell.Vertices[1]],
                        VertexC = this.vertexnumDictionary[cell.Vertices[2]]
                    });
                }

                // 写ts的VerticesList, 并插值Z
                foreach (var kv in this.vertexnumDictionary.OrderBy(n => n.Value))
                {
                    var vPos = kv.Key.Position;
                    var x    = vPos[0];
                    var y    = vPos[1];
                    var z    = interpolateFunc(this.edgeVerticesList, depth, x, y);

                    this.TsData.VerticesList.Add(new Point3D(x, y, z));
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return;
            }
        }
Beispiel #7
0
    IEnumerable <Edge> DelaunayEdges()
    {
        var points   = go.Select(l => l.transform.position).ToList();
        var vertices = points.Select(p => new Vertex()
        {
            Location = p
        }).ToList();

        var delaunay = Triangulation.CreateDelaunay <Vertex, Face>(vertices);
        var edges    = delaunay.Cells
                       .SelectMany(c => c.GetEdges())
                       .Distinct();

        return(edges);
    }
 private void FindDelaunayClick(object sender, RoutedEventArgs e)
 {
     try
     {
         var now = DateTime.Now;
         Del_tetras = Triangulation.CreateDelaunay(vertices).Cells.ToList();
         var interval = DateTime.Now - now;
         UpdateTimer(interval);
         btnDisplay.IsEnabled = btnDisplay.IsDefault = true;
         CVXvertices          = null; CVXfaces = null; Voro_edges = null; Voro_nodes = null;
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Information);
     }
 }
    IEnumerable <Edge> DelaunayEdges(float maxLength)
    {
        var points   = GetPoints(1_000);
        var vertices = points.Select(p => new Vertex()
        {
            Location = p
        }).ToList();
        var delaunay = Triangulation.CreateDelaunay <Vertex, Face>(vertices);

        var edges = delaunay.Cells
                    .SelectMany(c => c.GetEdges())
                    .Distinct()
                    .Where(e => e.Length < maxLength);

        return(edges);
    }
        /// <summary>
        /// creates a set of tetrahedrons from a given point cloud
        /// </summary>
        /// <param name="pPointCloud">the point cloud</param>
        /// <returns>a list of tetrahedrons</returns>
        static List <Tetrahedron> createDelaunayTetrahedrons(PointCloud pPointCloud)
        {
            //vars
            List <Tetrahedron> retVal = new List <Tetrahedron>();

            try
            {
                //create vertex list
                HashSet <Vertex> vertices = new HashSet <Vertex>();
                foreach (Point p in pPointCloud.pointcloud_hs)
                {
                    vertices.Add(new Vertex(p.point.X, p.point.Y, p.point.Z));
                }
                retVal = Triangulation.CreateDelaunay <Vertex, Tetrahedron>(vertices).Cells.ToList();
            }
            catch (Exception) { throw; }

            return(retVal);
        }
    void BunnyEdges()
    {
        var points = RandomPoints(400);

        var vertices = points
                       .Select(p => new Vertex()
        {
            Location = p
        })
                       .ToList();

        var triangulation = Triangulation.CreateDelaunay <Vertex, Face>(vertices);
        var edges         = triangulation.Cells.SelectMany(f => f.GetEdges());

        edges = edges.Where(e => e.Length < 0.2f);
        var edgeList = edges.ToList();

        SetMeshFromEdges(edgeList);
        PaintEdges(edgeList);
    }
    IEnumerator DepthFirstSearchAnimated()
    {
        var points = RandomPoints(400);

        var vertices = points
                       .Select(p => new Vertex()
        {
            Location = p
        })
                       .ToList();

        var triangulation = Triangulation.CreateDelaunay <Vertex, Face>(vertices);
        var edges         = triangulation.Cells.SelectMany(f => f.GetEdges())
                            .Distinct()
                            .Where(e => e.Length < 0.2f);

        var edgeList = edges.ToList();

        SetMeshFromEdges(edgeList);

        var graph = edgeList.ToUndirectedGraph <Vertex, Edge>();

        var sequence = new List <Edge>();

        var s = new UndirectedDepthFirstSearchAlgorithm <Vertex, Edge>(graph);

        s.ExamineEdge += (o, e) => sequence.Add(e.Edge);
        s.Compute(graph.Vertices.First());

        foreach (var edge in edgeList)
        {
            edge.Value = 0.3f;
        }

        foreach (var edge in sequence)
        {
            edge.Value = 1;
            PaintEdges(edgeList);
            yield return(new WaitForSeconds(0.05f));
        }
    }
Beispiel #13
0
        /// <summary>
        /// Creates a triangulation of random data.
        /// For larger data sets it might be a good idea to separate the triangulation calculation
        /// from creating the visual so that the triangulation can be computed on a separate threat.
        /// </summary>
        /// <param name="count">Number of vertices to generate</param>
        /// <param name="radius">Radius of the vertices</param>
        /// <param name="uniform"></param>
        /// <returns>Triangulation</returns>
        public static RandomTriangulation Create(int count, double radius, bool uniform)
        {
            Random        rnd = new Random();
            List <Vertex> vertices;

            if (!uniform)
            {
                // generate some random points
                Func <double> nextRandom = () => 2 * radius * rnd.NextDouble() - radius;
                vertices = Enumerable.Range(0, count)
                           .Select(_ => new Vertex(nextRandom(), nextRandom(), nextRandom()))
                           .ToList();
            }
            else
            {
                vertices = new List <Vertex>();
                int    d  = Math.Max((int)Math.Ceiling(Math.Sqrt(count)) / 2, 3);
                double cs = 2 * radius / (d - 1);
                for (int i = 0; i < d; i++)
                {
                    for (int j = 0; j < d; j++)
                    {
                        for (int k = 0; k < d; k++)
                        {
                            vertices.Add(new Vertex(cs * i - cs * (d - 1) / 2, cs * j - cs * (d - 1) / 2, cs * k - cs * (d - 1) / 2));
                        }
                    }
                }
            }

            // calculate the triangulation
            var config = !uniform
               ? new TriangulationComputationConfig()
               : new TriangulationComputationConfig
            {
                PointTranslationType   = PointTranslationType.TranslateInternal,
                PlaneDistanceTolerance = 0.000001,
                // the translation radius should be lower than PlaneDistanceTolerance / 2
                PointTranslationGenerator = TriangulationComputationConfig.RandomShiftByRadius(0.0000001, 0)
            };

            var tetrahedrons = Triangulation.CreateDelaunay <Vertex, Tetrahedron>(vertices, config).Cells;

            // create a model for each tetrahedron, pick a random color
            Model3DGroup model = new Model3DGroup();

            foreach (var t in tetrahedrons)
            {
                var color = Color.FromArgb((byte)255, (byte)rnd.Next(256), (byte)rnd.Next(256), (byte)rnd.Next(256));
                model.Children.Add(t.CreateModel(color, radius));
            }

            //var redMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Red),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //var greenMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Green),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //var blueMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Blue),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //CylinderMesh c = new CylinderMesh() { Length = 10, Radius = 0.5 };
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = greenMaterial });
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = redMaterial, Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), 90)) });
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = blueMaterial, Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), 90)) });

            var triangulation = new RandomTriangulation();

            triangulation.tetrahedrons = tetrahedrons;

            // assign the Visual3DModel property of the ModelVisual3D class
            triangulation.Visual3DModel = model;

            return(triangulation);
        }
        /// <summary>
        /// Creates a triangulation of random data.
        /// For larger data sets it might be a good idea to separate the triangulation calculation
        /// from creating the visual so that the triangulation can be computed on a separate threat.
        /// </summary>
        /// <param name="count">Number of vertices to generate</param>
        /// <param name="radius">Radius of the vertices</param>
        /// <param name="uniform"></param>
        /// <returns>Triangulation</returns>
        public static RandomTriangulation Create(int count, double radius, bool uniform, string[] textValue)
        {
            Random        rnd      = new Random();
            List <Vertex> vertices = new List <Vertex>();

            if (!uniform)
            {
                // generate some random points
                //Func<double> nextRandom = () => 2 * radius * rnd.NextDouble() - radius;
                //vertices = Enumerable.Range(0, count)
                //    .Select(_ => new Vertex(nextRandom(), nextRandom(), nextRandom()))
                //    .ToList();
                for (int i = 0; i < textValue.Length; i += 3)
                {
                    vertices.Add(new Vertex(Convert.ToDouble(textValue[i]), Convert.ToDouble(textValue[i + 1]), Convert.ToDouble(textValue[i + 2])));
                }
            }
            else
            {
                vertices = new List <Vertex>();
                int    d  = Math.Max((int)Math.Ceiling(Math.Sqrt(count)) / 2, 3);
                double cs = 2 * radius / (d - 1);
                for (int i = 0; i < d; i++)
                {
                    for (int j = 0; j < d; j++)
                    {
                        for (int k = 0; k < d; k++)
                        {
                            vertices.Add(new Vertex(cs * i - cs * (d - 1) / 2, cs * j - cs * (d - 1) / 2, cs * k - cs * (d - 1) / 2));
                        }
                    }
                }
            }
            var tetrahedrons = Triangulation.CreateDelaunay <Vertex, Tetrahedron>(vertices).Cells;

            // create a model for each tetrahedron, pick a random color
            Model3DGroup model = new Model3DGroup();

            foreach (var t in tetrahedrons)
            {
                var color = Color.FromArgb((byte)255, (byte)rnd.Next(256), (byte)rnd.Next(256), (byte)rnd.Next(256));
                model.Children.Add(t.CreateModel(color, radius));
            }

            //var redMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Red),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //var greenMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Green),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //var blueMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Blue),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //CylinderMesh c = new CylinderMesh() { Length = 10, Radius = 0.5 };
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = greenMaterial });
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = redMaterial, Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), 90)) });
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = blueMaterial, Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), 90)) });

            var triangulation = new RandomTriangulation();

            triangulation.tetrahedrons = tetrahedrons;

            int OBJIndex = 1, OBJTextureIndex = 1;
            Dictionary <string, OBJNormalVertex> OBJNormalVertexList = new Dictionary <string, OBJNormalVertex>();
            Dictionary <string, string>          OBJTextureKeyList = new Dictionary <string, string>();
            Dictionary <string, int>             OBJTextureList = new Dictionary <string, int>();

            foreach (var Element in vertices)
            {
                string textVertex  = string.Format("v {0} {1} {2}", Element.Position[0], Element.Position[1], Element.Position[2]);
                string textTexture = string.Format("vt {0} {1}", (Element.Position[0] + 50) / 100, (Element.Position[1] + 50) / 100);

                OBJTextureKeyList.Add(textVertex, textTexture);
                OBJNormalVertexList.Add(textVertex, new OBJNormalVertex(OBJIndex++, 0, new double[] { 0, 0, 0 }, ""));

                if (OBJTextureList.ContainsKey(textTexture) == false)
                {
                    OBJTextureList.Add(textTexture, OBJTextureIndex++);
                }
            }

            foreach (var Element in tetrahedrons)
            {
                for (int i = 0; i < 3; i++)
                {
                    string textVertex = string.Format("v {0} {1} {2}", Element.Vertices[i].Position[0], Element.Vertices[i].Position[1], Element.Vertices[i].Position[2]);

                    OBJNormalVertexList[textVertex].count++;
                    OBJNormalVertexList[textVertex].NormalVertex[0] += Element.Normal[0];
                    OBJNormalVertexList[textVertex].NormalVertex[1] += Element.Normal[1];
                    OBJNormalVertexList[textVertex].NormalVertex[2] += Element.Normal[2];
                }
            }

            foreach (var Element in OBJNormalVertexList)
            {
                Element.Value.ArrangeNormalVertex();
            }

            using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\DEVMF\Desktop\File\VS\MIConvexHull-master\MIConvexHull-master\Examples\7DelaunayWPF\output.txt"))
            {
                foreach (var Element in OBJNormalVertexList)
                {
                    file.WriteLine(Element.Key);
                }
                file.WriteLine();

                foreach (var Element in OBJNormalVertexList)
                {
                    file.WriteLine(Element.Value.NormalVertexQuery);
                }
                file.WriteLine();

                foreach (var Element in OBJTextureList)
                {
                    file.WriteLine(Element.Key);
                }
                file.WriteLine();

                foreach (var Element in tetrahedrons)
                {
                    string query1 = string.Format("v {0} {1} {2}", Element.Vertices[0].Position[0], Element.Vertices[0].Position[1], Element.Vertices[0].Position[2]);
                    string query2 = string.Format("v {0} {1} {2}", Element.Vertices[1].Position[0], Element.Vertices[1].Position[1], Element.Vertices[1].Position[2]);
                    string query3 = string.Format("v {0} {1} {2}", Element.Vertices[2].Position[0], Element.Vertices[2].Position[1], Element.Vertices[2].Position[2]);

                    string face1 = string.Format("{0}/{1}/{2}", OBJNormalVertexList[query1].index, OBJTextureList[OBJTextureKeyList[query1]], OBJNormalVertexList[query1].index);
                    string face2 = string.Format("{0}/{1}/{2}", OBJNormalVertexList[query2].index, OBJTextureList[OBJTextureKeyList[query2]], OBJNormalVertexList[query2].index);
                    string face3 = string.Format("{0}/{1}/{2}", OBJNormalVertexList[query3].index, OBJTextureList[OBJTextureKeyList[query3]], OBJNormalVertexList[query3].index);

                    string face = string.Format("f {0} {1} {2}", face1, face2, face3);

                    file.WriteLine(face);
                }
            }

            //foreach (var Element in OBJVertexAndVormalVertex)
            //    if (Element.Value.isNegative)
            //        OBJVertexTexture.Add(Element.Value.vertexTexture, VTindex++);

            // assign the Visual3DModel property of the ModelVisual3D class
            triangulation.Visual3DModel = model;

            return(triangulation);
        }
        /// <summary>
        /// Triangulate cell with the provided vertices.
        /// </summary>
        /// <param name="vertices">The vertices of the cell.</param>
        /// <returns>The triangulation.</returns>
        private IEnumerable <DefaultTriangulationCell <MIVertex> > Triangulate(List <Vector2D> vertices)
        {
            if (vertices.Count == 3)
            {
                // Convert vertices to objects that work with MIConvexHull library
                MIVertex[] miVertices = new MIVertex[vertices.Count];
                for (int i = 0; i < vertices.Count; i++)
                {
                    miVertices[i] = new MIVertex(vertices[i].X, vertices[i].Y);
                }

                // MIConvexHull library cannot create a triangulation from a single triangle
                return(new List <DefaultTriangulationCell <MIVertex> >()
                {
                    new DefaultTriangulationCell <MIVertex>()
                    {
                        Vertices = miVertices
                    }
                });
            }
            else if (vertices.Count == 4)
            {
                // There are problems with 4 vertices in MIConvexHull algorithms. There are multiple issues on their github

                Vector2D average = new Vector2D();

                for (int i = 0; i < vertices.Count; i++)
                {
                    average.X += vertices[i].X;
                    average.Y += vertices[i].Y;
                }

                average.X /= vertices.Count;
                average.Y /= vertices.Count;

                // Convert vertices to objects that work with MIConvexHull library
                List <MIVertex> miVertices = new List <MIVertex>(vertices.Count);
                for (int i = 0; i < vertices.Count; i++)
                {
                    miVertices.Add(new MIVertex(vertices[i].X, vertices[i].Y));
                }

                miVertices.Sort(Comparer <MIVertex> .Create((item1, item2) => {
                    var position1 = item1.Position;
                    var position2 = item2.Position;

                    double a1 = ((Math.Atan2(position1[0] - average.X, position1[1] - average.Y) * 180 / Math.PI) + 360) % 360;
                    double a2 = ((Math.Atan2(position2[0] - average.X, position2[1] - average.Y) * 180 / Math.PI) + 360) % 360;
                    return((int)(a1 - a2));
                }));

                var triangles = new List <DefaultTriangulationCell <MIVertex> >();

                for (int i = 1; i < miVertices.Count - 1; i++)
                {
                    MIVertex[] tempVertices = { miVertices[0], miVertices[i], miVertices[i + 1] };
                    triangles.Add(new DefaultTriangulationCell <MIVertex>()
                    {
                        Vertices = tempVertices
                    });
                }

                return(triangles);
            }
            else
            {
                // Convert vertices to objects that work with MIConvexHull library
                MIVertex[] miVertices = new MIVertex[vertices.Count];
                for (int i = 0; i < vertices.Count; i++)
                {
                    miVertices[i] = new MIVertex(vertices[i].X, vertices[i].Y);
                }

                // More vertices are OK so let the library to triangulate them
                var triangulation = Triangulation.CreateDelaunay(miVertices);
                return(triangulation.Cells);
            }
        }
Beispiel #16
0
        /// <summary>
        /// Creates a triangulation of random data.
        /// For larger data sets it might be a good idea to separate the triangulation calculation
        /// from creating the visual so that the triangulation can be computed on a separate threat.
        /// </summary>
        /// <param name="count">Number of vertices to generate</param>
        /// <param name="radius">Radius of the vertices</param>
        /// <returns>Triangulation</returns>
        public static RandomTriangulation Create(int count, double radius)
        {
            Random rnd = new Random();

            // generate some random points
            Func <double> nextRandom = () => 2 * radius * rnd.NextDouble() - radius;
            var           vertices   = Enumerable.Range(0, count)
                                       .Select(_ => new Vertex(nextRandom(), nextRandom(), nextRandom()))
                                       .ToList();

            //var vertices = new List<Vertex>();
            //int d = 4;
            //double cs = 10.0;
            //for (int i = 0; i < d; i++)
            //{
            //    for (int j = 0; j < d; j++)
            //    {
            //        for (int k = 0; k < d; k++)
            //        {
            //            //vertices.Add(new Vertex(10 * i - 20 + rnd.NextDouble(), 10 * j - 20 - rnd.NextDouble(), 10 * k - 20 + rnd.NextDouble()));
            //            vertices.Add(new Vertex(-10 * i, 10 * j, 10 * k));
            //        }
            //    }
            //}

            // calculate the triangulation
            var tetrahedrons = Triangulation.CreateDelaunay <Vertex, Tetrahedron>(vertices).Cells;

            // create a model for each tetrahedron, pick a random color
            Model3DGroup model = new Model3DGroup();

            foreach (var t in tetrahedrons)
            {
                var color = Color.FromArgb((byte)255, (byte)rnd.Next(256), (byte)rnd.Next(256), (byte)rnd.Next(256));
                model.Children.Add(t.CreateModel(color, radius));
            }

            //var redMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Red),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //var greenMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Green),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //var blueMaterial = new MaterialGroup
            //{
            //    Children = new MaterialCollection
            //    {
            //        new DiffuseMaterial(Brushes.Blue),
            //        // give it some shine
            //        new SpecularMaterial(Brushes.LightYellow, 2.0)
            //    }
            //};

            //CylinderMesh c = new CylinderMesh() { Length = 10, Radius = 0.5 };
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = greenMaterial });
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = redMaterial, Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), 90)) });
            //model.Children.Add(new GeometryModel3D { Geometry = c.Geometry, Material = blueMaterial, Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), 90)) });

            var triangulation = new RandomTriangulation();

            triangulation.tetrahedrons = tetrahedrons;

            // assign the Visual3DModel property of the ModelVisual3D class
            triangulation.Visual3DModel = model;

            return(triangulation);
        }
Beispiel #17
0
        static TimeSpan TestNDDelau(int dim, int numVert, double size)
        {
            var vertices = CreateRandomVertices(dim, numVert, size);

            return(RunComputation(() => Triangulation.CreateDelaunay(vertices)));
        }