Почему алгоритм марширующих кубов оставляет дыры позади? - PullRequest
0 голосов
/ 18 февраля 2020

Я только что сделал алгоритм марширующих кубов, и через 2 дня я увидел некоторые отверстия во мне sh.

Hole in marching cubes

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class MarchinCubes : MonoBehaviour
{
    public int size = 1;
    public float surfaceValue = .5f;

    public int xOffset = 0;
    public int yOffset = 0;
    public int zOffset = 0;

    public float zoom = 1;
    public bool interpolation;
    public bool shading;
    public bool autoUpdate;

    public bool sphereValues;

    void Start()
    {
        xOffset = (int)transform.position.x;
        yOffset = (int)transform.position.y;
        zOffset = (int)transform.position.z;

        Starter();
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.U) || autoUpdate)
        {
            xOffset = (int)transform.position.x;
            yOffset = (int)transform.position.y;
            zOffset = (int)transform.position.z;

            Starter();

            Vector3 position = transform.position;

            Vector3 newPosition = new Vector3(Mathf.Floor(position.x), Mathf.Floor(position.y), Mathf.Floor(position.z));

            transform.position = newPosition;
        }
    }

    void Starter()
    {
        int pointSize = size + 1;
        float[][][] values = sphereValues ? sphere(pointSize) : Perlin(pointSize);

        Mesh mesh = CreateMesh(values, pointSize - 1);

        mesh.RecalculateNormals();
        GetComponent<MeshFilter>().mesh = mesh;
    }

    float[][][] sphere(int size)
    {
        float[][][] values = initializeFloatArray(size);

        for (int x = 0; x < size; x++)
        {
            for (int y = 0; y < size; y++)
            {
                for (int z = 0; z < size; z++)
                {
                    values[x][y][z] = 10 - distance(x, y, z, size / 2, size / 2, size / 2);
                }
            }
        }

        return values;
    }

    float distance(float x, float y, float z, float xCenter, float yCenter, float zCenter)
    {
        return Mathf.Sqrt(Mathf.Pow(x - xCenter, 2) + Mathf.Pow(y - yCenter, 2) + Mathf.Pow(z - zCenter, 2));
    }

    float[][][] Perlin(int size)
    {
        float[][][] values = initializeFloatArray(size);

        for (int x = 0; x < size; x++)
        {
            for (int y = 0; y < size; y++)
            {
                for (int z = 0; z < size; z++)
                {
                    if (x == 0 || x == size - 1 || y == 0 || y == size - 1 ||z == 0 || z == size - 1)
                    {
                        values[x][y][z] = 0;
                    }
                    else
                    {
                        values[x][y][z] = (GetPerlin(x, y, z, 40f) + GetPerlin(x, y, z, 20f)) / 2;
                    }
                }
            }
        }

        return values;
    }

    float GetPerlin(int xInt, int yInt, int zInt, float divider)
    {
        float z = (zInt + zOffset) / divider;
        float y = (yInt + yOffset) / divider;
        float x = (xInt + xOffset) / divider;

        float zy = Mathf.PerlinNoise(x, y);
        float zx = Mathf.PerlinNoise(x, z);
        float yx = Mathf.PerlinNoise(y, z);
        float yz = Mathf.PerlinNoise(y, x);
        float xz = Mathf.PerlinNoise(z, x);
        float xy = Mathf.PerlinNoise(z, y);

        return (xy + xz + yz + yx + zx + zy) / 6;
    }

    float[][][] initializeFloatArray(int size)
    {
        float[][][] values = new float[size][][];

        for (int x = 0; x < size; x++)
        {
            values[x] = new float[size][];

            for (int i = 0; i < size; i++)
            {
                values[x][i] = new float[size];
            }
        }

        return values;
    }

    Mesh CreateMesh(float[][][] values, int size)
    {
        Vector3[] vertices = initializeVector3Array(size * 2 + 1, size * 2 + 1, size * 2 + 1);
        int[] triangles = new int[size * size * size * 3 * 2];
        Mesh mesh = new Mesh();

        int triangleCount = 0;

        for (int x = 0; x < size; x++)
        {
            for (int y = 0; y < size; y++)
            {
                for (int z = 0; z < size; z++)
                {
                    int[] triangleTable = table[getTriangleIndex(
                        new[] {
                            values[x][y][z],
                            values[x + 1][y][z],
                            values[x + 1][y][z + 1],
                            values[x][y][z + 1],
                            values[x][y + 1][z],
                            values[x + 1][y + 1][z],
                            values[x + 1][y + 1][z + 1],
                            values[x][y + 1][z + 1]
                        },
                        surfaceValue)];

                    int[] trianglesToAdd = new int[triangleTable.Length];

                    for (int i = 0; i < triangleTable.Length; i += 3)
                    {
                        trianglesToAdd[i] = getVertexIndex(x, y, z, triangleTable[i], size * 2 + 2);
                        trianglesToAdd[i + 1] = getVertexIndex(x, y, z, triangleTable[i + 1], size * 2 + 2);
                        trianglesToAdd[i + 2] = getVertexIndex(x, y, z, triangleTable[i + 2], size * 2 + 2);
                    }

                    for (int i = 0; i < trianglesToAdd.Length; i++)
                    {
                        triangles[triangleCount] = trianglesToAdd[i];
                        triangleCount++;
                    }
                }
            }
        }

        if (interpolation)
        {
            vertices = addIndterpolation(vertices, size * 2 + 2, values, surfaceValue);
        }

        vertices = ScaleVertices(vertices);

        if (shading == false)
        {
            RemakeMeshToDiscrete(vertices, triangles, out vertices, out triangles);
        }

        mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;

        mesh.vertices = vertices;
        mesh.triangles = triangles;

        return mesh;
    }

    Vector3[] ScaleVertices(Vector3[] vertices)
    {
        for (int i = 0; i < vertices.Length; i++)
        {
            vertices[i].x = vertices[i].x / transform.localScale.x;
            vertices[i].y = vertices[i].y / transform.localScale.y;
            vertices[i].z = vertices[i].z / transform.localScale.z;
        }
        return vertices;
    }

    void RemakeMeshToDiscrete(Vector3[] vert, int[] trig, out Vector3[] outVertices, out int[] outTriangles)
    {
        Vector3[] vertDiscrete = new Vector3[trig.Length];
        int[] trigDiscrete = new int[trig.Length];
        for (int i = 0; i < trig.Length; i++)
        {
            vertDiscrete[i] = vert[trig[i]];
            trigDiscrete[i] = i;
        }
        outVertices = vertDiscrete;
        outTriangles = trigDiscrete;
    }

    Vector3[] addIndterpolation(Vector3[] array, int sizeVertices, float[][][] values, float surfaceValue)
    {
        int sizeValues = values.Length;
        for (int x = 0; x < sizeValues - 1; x++)
        {
            for (int y = 0; y < sizeValues - 1; y++)
            {
                for (int z = 0; z < sizeValues - 1; z++)
                {
                    int arrayCords = z * 2 + y * sizeVertices * 2 + x * sizeVertices * sizeVertices * 2;

                    float value = values[x][y][z];
                    float valueZ = values[x + 1][y][z];
                    float valueY = values[x][y + 1][z];
                    float valueX = values[x][y][z + 1];

                    float interpolationValueX = Mathf.Abs(surfaceValue - value) / (Mathf.Abs(surfaceValue - value) + Mathf.Abs(surfaceValue - valueX));
                    float interpolationValueY = Mathf.Abs(surfaceValue - value) / (Mathf.Abs(surfaceValue - value) + Mathf.Abs(surfaceValue - valueY));
                    float interpolationValueZ = Mathf.Abs(surfaceValue - value) / (Mathf.Abs(surfaceValue - value) + Mathf.Abs(surfaceValue - valueZ));

                    array[arrayCords + 1] += new Vector3(0, 0, interpolationValueX - .5f);

                    array[arrayCords + sizeVertices] += new Vector3(0, interpolationValueY - .5f, 0);

                    array[arrayCords + sizeVertices * sizeVertices] += new Vector3(interpolationValueZ - .5f, 0, 0);
                }
            }
        }

        return array;
    }

    int getVertexIndex(int z, int y, int x, int cubeValue, int size)
    {
        int[][] vertecieValues = new[] {
            new []{1, 0, 0 },
            new []{2, 0, 1 },
            new []{1, 0, 2 },
            new []{0, 0, 1 },
            new []{1, 2, 0 },
            new []{2, 2, 1 },
            new []{1, 2, 2 },
            new []{0, 2, 1 },
            new []{0, 1, 0 },
            new []{2, 1, 0 },
            new []{2, 1, 2 },
            new []{0, 1, 2 }
        };

        int xReturn = z * 2 * size * size;
        int yReturn = y * 2 * size;
        int zReturn = x * 2;
        return xReturn + vertecieValues[cubeValue][0] * size * size + yReturn + vertecieValues[cubeValue][1] * size + zReturn + vertecieValues[cubeValue][2];
    }

    int getTriangleIndex(float[] values, float surfaceValue)
    {
        int index = 0;

        for (int i = 0; i < 8; i++)
        {
            if (values[i] > surfaceValue)
            {
                index |= 1 << i;
            }
        }
        return index;
    }

    Vector3[] initializeVector3Array(int Xsize, int Ysize, int Zsize)
    {
        Vector3[] array = new Vector3[(Xsize + 1) * (Ysize + 1) * (Zsize + 1)];
        int count = 0;
        for (int x = 0; x < Xsize + 1; x++)
        {
            for (int y = 0; y < Ysize + 1; y++)
            {
                for (int z = 0; z < Zsize + 1; z++)
                {
                    array[count] = new Vector3(x / 2f, y / 2f, z / 2f);
                    count++;
                }
            }
        }

        return array;
    }

    int[][] table = new int[][] {
        new int[] { },
        new int[] { 8, 3, 0},
        new int[] { 9, 0, 1},
        new int[] { 8, 3, 1, 8, 1, 9},
        new int[] {10, 1, 2},
        new int[] { 8, 3, 0, 1, 2,10},
        new int[] { 9, 0, 2, 9, 2,10},
        new int[] { 3, 2, 8, 2,10, 8, 8,10, 9},
        new int[] {11, 2, 3},
        new int[] {11, 2, 0,11, 0, 8},
        new int[] {11, 2, 3, 0, 1, 9},
        new int[] { 2, 1,11, 1, 9,11,11, 9, 8},
        new int[] {10, 1, 3,10, 3,11},
        new int[] { 1, 0,10, 0, 8,10,10, 8,11},
        new int[] { 0, 3, 9, 3,11, 9, 9,11,10},
        new int[] { 8,10, 9, 8,11,10},
        new int[] { 8, 4, 7},
        new int[] { 3, 0, 4, 3, 4, 7},
        new int[] { 1, 9, 0, 8, 4, 7},
        new int[] { 9, 4, 1, 4, 7, 1, 1, 7, 3},
        new int[] {10, 1, 2, 8, 4, 7},
        new int[] { 2,10, 1, 0, 4, 7, 0, 7, 3},
        new int[] { 4, 7, 8, 0, 2,10, 0,10, 9},
        new int[] { 2, 7, 3, 2, 9, 7, 7, 9, 4, 2,10, 9},
        new int[] { 2, 3,11, 7, 8, 4},
        new int[] { 7,11, 4,11, 2, 4, 4, 2, 0},
        new int[] { 3,11, 2, 4, 7, 8, 9, 0, 1},
        new int[] { 2, 7,11, 2, 1, 7, 1, 4, 7, 1, 9, 4},
        new int[] { 8, 4, 7,11,10, 1,11, 1, 3},
        new int[] {11, 4, 7, 1, 4,11, 1,11,10, 1, 0, 4},
        new int[] { 3, 8, 0, 7,11, 4,11, 9, 4,11,10, 9},
        new int[] { 7,11, 4, 4,11, 9,11,10, 9},
        new int[] { 9, 5, 4},
        new int[] { 3, 0, 8, 4, 9, 5},
        new int[] { 5, 4, 0, 5, 0, 1},
        new int[] { 4, 8, 5, 8, 3, 5, 5, 3, 1},
        new int[] { 2,10, 1, 9, 5, 4},
        new int[] { 0, 8, 3, 5, 4, 9,10, 1, 2},
        new int[] {10, 5, 2, 5, 4, 2, 2, 4, 0},
        new int[] { 3, 4, 8, 3, 2, 4, 2, 5, 4, 2,10, 5},
        new int[] {11, 2, 3, 9, 5, 4},
        new int[] { 9, 5, 4, 8,11, 2, 8, 2, 0},
        new int[] { 3,11, 2, 1, 5, 4, 1, 4, 0},
        new int[] { 8, 5, 4, 2, 5, 8, 2, 8,11, 2, 1, 5},
        new int[] { 5, 4, 9, 1, 3,11, 1,11,10},
        new int[] { 0, 9, 1, 4, 8, 5, 8,10, 5, 8,11,10},
        new int[] { 3, 4, 0, 3,10, 4, 4,10, 5, 3,11,10},
        new int[] { 4, 8, 5, 5, 8,10, 8,11,10},
        new int[] { 9, 5, 7, 9, 7, 8},
        new int[] { 0, 9, 3, 9, 5, 3, 3, 5, 7},
        new int[] { 8, 0, 7, 0, 1, 7, 7, 1, 5},
        new int[] { 1, 7, 3, 1, 5, 7},
        new int[] { 1, 2,10, 5, 7, 8, 5, 8, 9},
        new int[] { 9, 1, 0,10, 5, 2, 5, 3, 2, 5, 7, 3},
        new int[] { 5, 2,10, 8, 2, 5, 8, 5, 7, 8, 0, 2},
        new int[] {10, 5, 2, 2, 5, 3, 5, 7, 3},
        new int[] {11, 2, 3, 8, 9, 5, 8, 5, 7},
        new int[] { 9, 2, 0, 9, 7, 2, 2, 7,11, 9, 5, 7},
        new int[] { 0, 3, 8, 2, 1,11, 1, 7,11, 1, 5, 7},
        new int[] { 2, 1,11,11, 1, 7, 1, 5, 7},
        new int[] { 3, 9, 1, 3, 8, 9, 7,11,10, 7,10, 5},
        new int[] { 9, 1, 0,10, 7,11,10, 5, 7},
        new int[] { 3, 8, 0, 7,10, 5, 7,11,10},
        new int[] {11, 5, 7,11,10, 5},
        new int[] {10, 6, 5},
        new int[] { 8, 3, 0,10, 6, 5},
        new int[] { 0, 1, 9, 5,10, 6},
        new int[] {10, 6, 5, 9, 8, 3, 9, 3, 1},
        new int[] { 1, 2, 6, 1, 6, 5},
        new int[] { 0, 8, 3, 2, 6, 5, 2, 5, 1},
        new int[] { 5, 9, 6, 9, 0, 6, 6, 0, 2},
        new int[] { 9, 6, 5, 3, 6, 9, 3, 9, 8, 3, 2, 6},
        new int[] { 3,11, 2,10, 6, 5},
        new int[] { 6, 5,10, 2, 0, 8, 2, 8,11},
        new int[] { 1, 9, 0, 6, 5,10,11, 2, 3},
        new int[] { 1,10, 2, 5, 9, 6, 9,11, 6, 9, 8,11},
        new int[] {11, 6, 3, 6, 5, 3, 3, 5, 1},
        new int[] { 0, 5, 1, 0,11, 5, 5,11, 6, 0, 8,11},
        new int[] { 0, 5, 9, 0, 3, 5, 3, 6, 5, 3,11, 6},
        new int[] { 5, 9, 6, 6, 9,11, 9, 8,11},
        new int[] {10, 6, 5, 4, 7, 8},
        new int[] { 5,10, 6, 7, 3, 0, 7, 0, 4},
        new int[] { 5,10, 6, 0, 1, 9, 8, 4, 7},
        new int[] { 4, 5, 9, 6, 7,10, 7, 1,10, 7, 3, 1},
        new int[] { 7, 8, 4, 5, 1, 2, 5, 2, 6},
        new int[] { 4, 1, 0, 4, 5, 1, 6, 7, 3, 6, 3, 2},
        new int[] { 9, 4, 5, 8, 0, 7, 0, 6, 7, 0, 2, 6},
        new int[] { 4, 5, 9, 6, 3, 2, 6, 7, 3},
        new int[] { 7, 8, 4, 2, 3,11,10, 6, 5},
        new int[] {11, 6, 7,10, 2, 5, 2, 4, 5, 2, 0, 4},
        new int[] {11, 6, 7, 8, 0, 3, 1,10, 2, 9, 4, 5},
        new int[] { 6, 7,11, 1,10, 2, 9, 4, 5},
        new int[] { 6, 7,11, 4, 5, 8, 5, 3, 8, 5, 1, 3},
        new int[] { 6, 7,11, 4, 1, 0, 4, 5, 1},
        new int[] { 4, 5, 9, 3, 8, 0,11, 6, 7},
        new int[] { 9, 4, 5, 7,11, 6},
        new int[] {10, 6, 4,10, 4, 9},
        new int[] { 8, 3, 0, 9,10, 6, 9, 6, 4},
        new int[] { 1,10, 0,10, 6, 0, 0, 6, 4},
        new int[] { 8, 6, 4, 8, 1, 6, 6, 1,10, 8, 3, 1},
        new int[] { 9, 1, 4, 1, 2, 4, 4, 2, 6},
        new int[] { 1, 0, 9, 3, 2, 8, 2, 4, 8, 2, 6, 4},
        new int[] { 2, 4, 0, 2, 6, 4},
        new int[] { 3, 2, 8, 8, 2, 4, 2, 6, 4},
        new int[] { 2, 3,11, 6, 4, 9, 6, 9,10},
        new int[] { 0,10, 2, 0, 9,10, 4, 8,11, 4,11, 6},
        new int[] {10, 2, 1,11, 6, 3, 6, 0, 3, 6, 4, 0},
        new int[] {10, 2, 1,11, 4, 8,11, 6, 4},
        new int[] { 1, 4, 9,11, 4, 1,11, 1, 3,11, 6, 4},
        new int[] { 0, 9, 1, 4,11, 6, 4, 8,11},
        new int[] {11, 6, 3, 3, 6, 0, 6, 4, 0},
        new int[] { 8, 6, 4, 8,11, 6},
        new int[] { 6, 7,10, 7, 8,10,10, 8, 9},
        new int[] { 9, 3, 0, 6, 3, 9, 6, 9,10, 6, 7, 3},
        new int[] { 6, 1,10, 6, 7, 1, 7, 0, 1, 7, 8, 0},
        new int[] { 6, 7,10,10, 7, 1, 7, 3, 1},
        new int[] { 7, 2, 6, 7, 9, 2, 2, 9, 1, 7, 8, 9},
        new int[] { 1, 0, 9, 3, 6, 7, 3, 2, 6},
        new int[] { 8, 0, 7, 7, 0, 6, 0, 2, 6},
        new int[] { 2, 7, 3, 2, 6, 7},
        new int[] { 7,11, 6, 3, 8, 2, 8,10, 2, 8, 9,10},
        new int[] {11, 6, 7,10, 0, 9,10, 2, 0},
        new int[] { 2, 1,10, 7,11, 6, 8, 0, 3},
        new int[] { 1,10, 2, 6, 7,11},
        new int[] { 7,11, 6, 3, 9, 1, 3, 8, 9},
        new int[] { 9, 1, 0,11, 6, 7},
        new int[] { 0, 3, 8,11, 6, 7},
        new int[] {11, 6, 7},
        new int[] {11, 7, 6},
        new int[] { 0, 8, 3,11, 7, 6},
        new int[] { 9, 0, 1,11, 7, 6},
        new int[] { 7, 6,11, 3, 1, 9, 3, 9, 8},
        new int[] { 1, 2,10, 6,11, 7},
        new int[] { 2,10, 1, 7, 6,11, 8, 3, 0},
        new int[] {11, 7, 6,10, 9, 0,10, 0, 2},
        new int[] { 7, 6,11, 3, 2, 8, 8, 2,10, 8,10, 9},
        new int[] { 2, 3, 7, 2, 7, 6},
        new int[] { 8, 7, 0, 7, 6, 0, 0, 6, 2},
        new int[] { 1, 9, 0, 3, 7, 6, 3, 6, 2},
        new int[] { 7, 6, 2, 7, 2, 9, 2, 1, 9, 7, 9, 8},
        new int[] { 6,10, 7,10, 1, 7, 7, 1, 3},
        new int[] { 6,10, 1, 6, 1, 7, 7, 1, 0, 7, 0, 8},
        new int[] { 9, 0, 3, 6, 9, 3, 6,10, 9, 6, 3, 7},
        new int[] { 6,10, 7, 7,10, 8,10, 9, 8},
        new int[] { 8, 4, 6, 8, 6,11},
        new int[] {11, 3, 6, 3, 0, 6, 6, 0, 4},
        new int[] { 0, 1, 9, 4, 6,11, 4,11, 8},
        new int[] { 1, 9, 4,11, 1, 4,11, 3, 1,11, 4, 6},
        new int[] {10, 1, 2,11, 8, 4,11, 4, 6},
        new int[] {10, 1, 2,11, 3, 6, 6, 3, 0, 6, 0, 4},
        new int[] { 0, 2,10, 0,10, 9, 4,11, 8, 4, 6,11},
        new int[] { 2,11, 3, 6, 9, 4, 6,10, 9},
        new int[] { 3, 8, 2, 8, 4, 2, 2, 4, 6},
        new int[] { 2, 0, 4, 2, 4, 6},
        new int[] { 1, 9, 0, 3, 8, 2, 2, 8, 4, 2, 4, 6},
        new int[] { 9, 4, 1, 1, 4, 2, 4, 6, 2},
        new int[] { 8, 4, 6, 8, 6, 1, 6,10, 1, 8, 1, 3},
        new int[] { 1, 0,10,10, 0, 6, 0, 4, 6},
        new int[] { 8, 0, 3, 9, 6,10, 9, 4, 6},
        new int[] {10, 4, 6,10, 9, 4},
        new int[] { 9, 5, 4, 7, 6,11},
        new int[] { 4, 9, 5, 3, 0, 8,11, 7, 6},
        new int[] { 6,11, 7, 4, 0, 1, 4, 1, 5},
        new int[] { 6,11, 7, 4, 8, 5, 5, 8, 3, 5, 3, 1},
        new int[] { 6,11, 7, 1, 2,10, 9, 5, 4},
        new int[] {11, 7, 6, 8, 3, 0, 1, 2,10, 9, 5, 4},
        new int[] {11, 7, 6,10, 5, 2, 2, 5, 4, 2, 4, 0},
        new int[] { 7, 4, 8, 2,11, 3,10, 5, 6},
        new int[] { 4, 9, 5, 6, 2, 3, 6, 3, 7},
        new int[] { 9, 5, 4, 8, 7, 0, 0, 7, 6, 0, 6, 2},
        new int[] { 4, 0, 1, 4, 1, 5, 6, 3, 7, 6, 2, 3},
        new int[] { 7, 4, 8, 5, 2, 1, 5, 6, 2},
        new int[] { 4, 9, 5, 6,10, 7, 7,10, 1, 7, 1, 3},
        new int[] { 5, 6,10, 0, 9, 1, 8, 7, 4},
        new int[] { 5, 6,10, 7, 0, 3, 7, 4, 0},
        new int[] {10, 5, 6, 4, 8, 7},
        new int[] { 5, 6, 9, 6,11, 9, 9,11, 8},
        new int[] { 0, 9, 5, 0, 5, 3, 3, 5, 6, 3, 6,11},
        new int[] { 0, 1, 5, 0, 5,11, 5, 6,11, 0,11, 8},
        new int[] {11, 3, 6, 6, 3, 5, 3, 1, 5},
        new int[] { 1, 2,10, 5, 6, 9, 9, 6,11, 9,11, 8},
        new int[] { 1, 0, 9, 6,10, 5,11, 3, 2},
        new int[] { 6,10, 5, 2, 8, 0, 2,11, 8},
        new int[] { 3, 2,11,10, 5, 6},
        new int[] { 9, 5, 6, 3, 9, 6, 3, 8, 9, 3, 6, 2},
        new int[] { 5, 6, 9, 9, 6, 0, 6, 2, 0},
        new int[] { 0, 3, 8, 2, 5, 6, 2, 1, 5},
        new int[] { 1, 6, 2, 1, 5, 6},
        new int[] {10, 5, 6, 9, 3, 8, 9, 1, 3},
        new int[] { 0, 9, 1, 5, 6,10},
        new int[] { 8, 0, 3,10, 5, 6},
        new int[] {10, 5, 6},
        new int[] {11, 7, 5,11, 5,10},
        new int[] { 3, 0, 8, 7, 5,10, 7,10,11},
        new int[] { 9, 0, 1,10,11, 7,10, 7, 5},
        new int[] { 3, 1, 9, 3, 9, 8, 7,10,11, 7, 5,10},
        new int[] { 2,11, 1,11, 7, 1, 1, 7, 5},
        new int[] { 0, 8, 3, 2,11, 1, 1,11, 7, 1, 7, 5},
        new int[] { 9, 0, 2, 9, 2, 7, 2,11, 7, 9, 7, 5},
        new int[] {11, 3, 2, 8, 5, 9, 8, 7, 5},
        new int[] {10, 2, 5, 2, 3, 5, 5, 3, 7},
        new int[] { 5,10, 2, 8, 5, 2, 8, 7, 5, 8, 2, 0},
        new int[] { 9, 0, 1,10, 2, 5, 5, 2, 3, 5, 3, 7},
        new int[] { 1,10, 2, 5, 8, 7, 5, 9, 8},
        new int[] { 1, 3, 7, 1, 7, 5},
        new int[] { 8, 7, 0, 0, 7, 1, 7, 5, 1},
        new int[] { 0, 3, 9, 9, 3, 5, 3, 7, 5},
        new int[] { 9, 7, 5, 9, 8, 7},
        new int[] { 4, 5, 8, 5,10, 8, 8,10,11},
        new int[] { 3, 0, 4, 3, 4,10, 4, 5,10, 3,10,11},
        new int[] { 0, 1, 9, 4, 5, 8, 8, 5,10, 8,10,11},
        new int[] { 5, 9, 4, 1,11, 3, 1,10,11},
        new int[] { 8, 4, 5, 2, 8, 5, 2,11, 8, 2, 5, 1},
        new int[] { 3, 2,11, 1, 4, 5, 1, 0, 4},
        new int[] { 9, 4, 5, 8, 2,11, 8, 0, 2},
        new int[] {11, 3, 2, 9, 4, 5},
        new int[] { 3, 8, 4, 3, 4, 2, 2, 4, 5, 2, 5,10},
        new int[] {10, 2, 5, 5, 2, 4, 2, 0, 4},
        new int[] { 0, 3, 8, 5, 9, 4,10, 2, 1},
        new int[] { 2, 1,10, 9, 4, 5},
        new int[] { 4, 5, 8, 8, 5, 3, 5, 1, 3},
        new int[] { 5, 0, 4, 5, 1, 0},
        new int[] { 3, 8, 0, 4, 5, 9},
        new int[] { 9, 4, 5},
        new int[] { 7, 4,11, 4, 9,11,11, 9,10},
        new int[] { 3, 0, 8, 7, 4,11,11, 4, 9,11, 9,10},
        new int[] {11, 7, 4, 1,11, 4, 1,10,11, 1, 4, 0},
        new int[] { 8, 7, 4,11, 1,10,11, 3, 1},
        new int[] { 2,11, 7, 2, 7, 1, 1, 7, 4, 1, 4, 9},
        new int[] { 3, 2,11, 4, 8, 7, 9, 1, 0},
        new int[] { 7, 4,11,11, 4, 2, 4, 0, 2},
        new int[] { 2,11, 3, 7, 4, 8},
        new int[] { 2, 3, 7, 2, 7, 9, 7, 4, 9, 2, 9,10},
        new int[] { 4, 8, 7, 0,10, 2, 0, 9,10},
        new int[] { 2, 1,10, 0, 7, 4, 0, 3, 7},
        new int[] {10, 2, 1, 8, 7, 4},
        new int[] { 9, 1, 4, 4, 1, 7, 1, 3, 7},
        new int[] { 1, 0, 9, 8, 7, 4},
        new int[] { 3, 4, 0, 3, 7, 4},
        new int[] { 8, 7, 4},
        new int[] { 8, 9,10, 8,10,11},
        new int[] { 0, 9, 3, 3, 9,11, 9,10,11},
        new int[] { 1,10, 0, 0,10, 8,10,11, 8},
        new int[] {10, 3, 1,10,11, 3},
        new int[] { 2,11, 1, 1,11, 9,11, 8, 9},
        new int[] {11, 3, 2, 0, 9, 1},
        new int[] {11, 0, 2,11, 8, 0},
        new int[] {11, 3, 2},
        new int[] { 3, 8, 2, 2, 8,10, 8, 9,10},
        new int[] { 9, 2, 0, 9,10, 2},
        new int[] { 8, 0, 3, 1,10, 2},
        new int[] {10, 2, 1},
        new int[] { 8, 1, 3, 8, 9, 1},
        new int[] { 9, 1, 0},
        new int[] { 8, 0, 3},
        new int[] {}
    };
}

I знаю, что код действительно грязный, но проблема, вероятно, в методе CreateMe sh или в таблице триангуляции.

Кто-то знает, почему там появляется дыра? У меня есть таблица триангуляции из inte rnet.

Спасибо.

1 Ответ

0 голосов
/ 20 февраля 2020

Я исправил это с помощью новой таблицы триангуляции. Спасибо за вашу помощь.

...