LeftOf() публичный статический Метод

public static LeftOf ( Vector3 p1, Vector3 p2, Vector3 p3 ) : bool
p1 Vector3
p2 Vector3
p3 Vector3
Результат bool
Пример #1
0
    // Aka Jarvis march
    public static List <Vector3> GiftWrapping(List <Vector3> positions)
    {
        // Find leftmost point
        int leftMostPoint = 0;

        for (int i = 1; i < positions.Count; i++)
        {
            if (positions[i].x < positions[leftMostPoint].x)
            {
                leftMostPoint = i;
            }
        }
        int pointOnHull = leftMostPoint;

        Debug.Log("leftMostPoint " + leftMostPoint);
        int            endPoint = 0;
        List <Vector3> res      = new List <Vector3>();

        do
        {
            Debug.Log("Add " + pointOnHull);
            res.Add(positions[pointOnHull]);
            endPoint = pointOnHull == 0?1:0;
            for (int j = 0; j < positions.Count; j++)
            {
                if (j != pointOnHull && HMeshMath.LeftOf(positions[pointOnHull], positions[endPoint], positions[j]))
                {
                    endPoint = j;
                }
            }
            pointOnHull = endPoint;
        } while (endPoint != leftMostPoint);
        return(res);
    }
 static Face FindTriangleWithinPoint(HMesh mesh, Vector3 pos)
 {
     foreach (var face in mesh.GetFaces())
     {
         var edges = face.Circulate();
         var p1    = edges[0].vert.position;
         var p2    = edges[1].vert.position;
         var p3    = edges[2].vert.position;
         Debug.LogWarning("Points " + p1 + ", " + p2 + ", " + p3);
         if (HMeshMath.LeftOf(p1, p2, pos) && HMeshMath.LeftOf(p2, p3, pos) && HMeshMath.LeftOf(p3, p1, pos))
         {
             return(face);
         }
     }
     Debug.LogWarning("Cannot find triangle");
     return(null);
 }
Пример #3
0
    public static List <Vector3> AklToussaintHeuristic(List <Vector3> positions)
    {
        int maxX = 0, maxY = 0, minX = 0, minY = 0;


        for (int i = 0; i < positions.Count; i++)
        {
            if (positions[i].x < positions[minX].x)
            {
                minX = i;
            }
            if (positions[i].x > positions[maxX].x)
            {
                maxX = i;
            }
            if (positions[i].y < positions[minY].y)
            {
                minY = i;
            }
            if (positions[i].y > positions[maxY].y)
            {
                maxY = i;
            }
        }
        List <int> points = new List <int>();

        points.Add(minX);
        if (!points.Contains(minY))
        {
            points.Add(minY);
        }
        if (!points.Contains(maxX))
        {
            points.Add(maxX);
        }
        if (!points.Contains(maxY))
        {
            points.Add(maxY);
        }

        if (points.Count <= 2)
        {
            return(positions);
        }

        Gizmos.color = Color.green;
        for (int i = 0; i < points.Count; i++)
        {
            Gizmos.DrawLine(positions[points[i]] + Vector3.one * 0.01f, positions[points[(i + 1) % points.Count]] + Vector3.one * 0.01f);
        }

        List <Vector3> res = new List <Vector3>();

        for (int i = 0; i < positions.Count; i++)
        {
            if (points.Contains(i))
            {
                res.Add(positions[i]);
            }
            else
            {
                bool inside = true;
                for (int j = 0; j < points.Count && inside; j++)
                {
                    inside = HMeshMath.LeftOf(positions[points[j]], positions[points[(j + 1) % points.Count]], positions[i]);
                }
                if (!inside)
                {
                    res.Add(positions[i]);
                }
            }
        }

        return(res);
    }