void DebugDrawTestTri(PenDrawingPath pdPath, Vector2f offset, int ientry, int iexit, float size = 50f, float dark = .5f, bool inverted = false)
        {
            IsoTriangle <PixelTriData> tri = new IsoTriangle <PixelTriData>
            {
                _base    = offset + Vector2f.AxisX * size / 2f,
                dims     = new Vector2f(size, size * TriUtil.RootThree / 2f),
                inverted = inverted
            };

            tri.Add(new PixelTriData(new PixelV {
                pos   = tri.Centroid,
                color = new Color(dark, dark, dark, 1f)
            }));


            var triCross = new TriCrosshatch <PixelTriData>(this, tri);

            triCross.DrawTriSpiral(pdPath, ientry, iexit);
        }
 private bool TriShouldSplit(IsoTriangle <PixelTriData> tri)
 {
     return
         (minDeviationThreshold + deviationSpread * grayscaleToDeviationCurve01.Evaluate((float)tri.onlineNormalEstimator.mean()) <
          tri.onlineNormalEstimator.standardDeviationUnbiased());
 }
Esempio n. 3
0
        public static List <IsoSurface> CalculateIsoSurface(this Mesh self, double numberOfSurfaces, int dataIndex)
        {
            double minOfData = self.GetMinimumBounds(dataIndex);
            double maxOfData = self.GetMaximumBounds(dataIndex);

            double            interval    = Mathf.SliceInterval(numberOfSurfaces, minOfData, maxOfData);
            List <IsoSurface> meshSurface = new List <IsoSurface>();

            if (interval == 0)
            {
                return(meshSurface);
            }

            for (double isoValue = minOfData + interval / 2; isoValue <= maxOfData; isoValue += interval)
            {
                IsoSurface finalSurface = new IsoSurface();
                foreach (Zone zone in self.Zones)
                {
                    foreach (Element element in zone.Elements)
                    {
                        double[] dataArray = new double[8];

                        for (int index = 0; index < element.VertInOrder.Length; index++)
                        {
                            uint vertex = element.VertInOrder[index];

                            dataArray[index] = (zone.Vertices[vertex].Data[dataIndex]);
                        }
                        byte caseNumber = ISOSurface.GetElementCase(dataArray, isoValue);

                        int[] caseEdges = ISOSurface.GetCaseEdges(caseNumber);
                        for (int i = 0; i < caseEdges.Length - 1; i += 3)
                        {
                            if (caseEdges[i] != -1 && caseEdges[i + 1] != -1 && caseEdges[i + 2] != -1)
                            {
                                Edge   firstEdge           = ISOSurface.GetEdgePoints(caseEdges[i]);
                                Point3 firstEdgeFinalPoint = firstEdge.GetIsoValuePoint(zone, element, isoValue,
                                                                                        dataIndex);

                                Edge   secondEdge           = ISOSurface.GetEdgePoints(caseEdges[i + 1]);
                                Point3 secondEdgeFinalPoint = secondEdge.GetIsoValuePoint(zone, element, isoValue,
                                                                                          dataIndex);

                                Edge   thirdEdge           = ISOSurface.GetEdgePoints(caseEdges[i + 2]);
                                Point3 thirdEdgeFinalPoint = thirdEdge.GetIsoValuePoint(zone, element, isoValue,
                                                                                        dataIndex);

                                IsoTriangle resultTriangle = new IsoTriangle(firstEdgeFinalPoint, secondEdgeFinalPoint,
                                                                             thirdEdgeFinalPoint)
                                {
                                    Color = ColorUtility.CalculateColor(isoValue, minOfData, maxOfData)
                                };

                                finalSurface.AddTriangle(resultTriangle);
                            }
                        }
                    }
                }
                meshSurface.Add(finalSurface);
            }
            return(meshSurface);
        }
 public TriCrosshatch(SCTriangleCrosshatchGenerator generator, IsoTriangle <T> tri)
 {
     this.generator = generator;
     this.tri       = tri;
 }