я треугольная тесселяция, подобная той, что показана на рисунке.

ДаноN количество треугольников в тесселяции, у меня естьN X 3 X 3 массив, который хранит(x, y, z) координаты всех трех вершин каждого треугольника. Моя цель - найти для каждого треугольника соседний треугольник, имеющий одинаковое ребро. Это сложная часть всей установки, что я не повторяю количество соседей. Это если треугольникj был уже посчитан как сосед треугольникаiтогда треугольникi не следует снова считать соседом по треугольникуj, Таким образом, я хотел бы иметь карту, хранящую список соседей для каждого индексного треугольника. Если я начну с треугольника в индексеiзатем индексi будет иметь трех соседей, а у всех остальных будет два или меньше. В качестве иллюстрации предположим, что у меня есть массив, в котором хранятся вершины треугольника:

import numpy as np
vertices = np.array([[[2.0, 1.0, 3.0],[3.0, 1.0, 2.0],[1.2, 2.5, -2.0]],
                     [[3.0, 1.0, 2.0],[1.0, 2.0, 3.0],[1.2, -2.5, -2.0]],
                     [[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[3.0, 1.0, 2.0]],
                     [[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[2.2, 2.0, 1.0]],
                     [[1.0, 2.0, 3.0],[2.2, 2.0, 1.0],[4.0, 1.0, 0.0]],
                     [[2.0, 1.0, 3.0],[2.2, 2.0, 1.0],[-4.0, 1.0, 0.0]]])

Предположим, я начинаю отсчет с индекса вершины2то есть с вершинами[[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[3.0, 1.0, 2.0]]тогда я хотел бы, чтобы мой вывод был примерно таким:

neighbour = [[], [], [0, 1, 3], [4, 5], [], []].

Обновить: Следуя ответу @ Ajax1234, я думаю, что хороший способ хранения результатов такой же, как и то, что продемонстрировал @ Ajax1234. Однако в этом выводе есть двусмысленность, в том смысле, что невозможно узнать, чей сосед какой. Хотя пример массива не очень хорош, у меня есть фактические вершины из икосаэдра, но если я начну с заданного треугольника, у меня гарантированно будет 3 соседа для первого и два соседа для отдыха (пока все треугольники не будут исчерпаны) , В связи с этим, предположим, у меня есть следующий массив:

vertices1 = [[[2, 1, 3], [3, 1, 2], [1, 2, -2]], 
            [[3, 1, 2], [1, 2, 3], [1, -2, 2]], 
            [[1, 2, 3], [2, 1, 3], [3, 1, 2]], 
            [[1, 2, 3], [2, 1, 3], [2, 2, 1]],
            [[1, 2, 3], [2, 2, 1], [4, 1, 0]], 
            [[2, 1, 3], [2, 2, 1], [-4, 1, 0]],
            [[3, 1, 3], [2, 2, 1], [-4, 1, 0]],
            [[8, 1, 2], [1, 2, 3], [1, -2, 2]]]

Алгоритм BFS, показанный в ответе ниже @ Ajax1234, дает вывод

[0, 1, 3, 7, 4, 5, 6]

в то время как если я просто поменяю местами позицию последнего элемента, так что

vertices2 = [[[2, 1, 3], [3, 1, 2], [1, 2, -2]], 
            [[3, 1, 2], [1, 2, 3], [1, -2, 2]], 
            [[1, 2, 3], [2, 1, 3], [3, 1, 2]], 
            [[1, 2, 3], [2, 1, 3], [2, 2, 1]],
            [[1, 2, 3], [2, 2, 1], [4, 1, 0]], 
            [[8, 1, 2], [1, 2, 3], [1, -2, 2]],
            [[2, 1, 3], [2, 2, 1], [-4, 1, 0]],
            [[3, 1, 3], [2, 2, 1], [-4, 1, 0]]]

который дает вывод

[0, 1, 3, 4, 5, 6, 7].

Это несколько двусмысленно, поскольку позиции в гирде совсем не изменились, их просто поменяли местами. Поэтому я хотел бы иметь последовательный способ поиска. Например, первый поиск соседей по индексу 2 дает[0, 1, 3] для обоихvertices1 а такжеvertices2Теперь я хотел бы, чтобы поиск был по индексу 0, который ничего не находит и, следовательно, перейти к следующему элементу 1 должен найти индекс7 заvertices1 и индекс5 заvertices2, Таким образом, выходной ток должен быть[0, 1, 3, 7], [0, 1, 3, 5] заvertices1 а такжеvertices2 соответственно. Далее мы идем в указатель3, и так далее. После того, как мы исчерпали весь поиск, окончательный результат для первого должен быть

[0, 1, 3, 7, 4, 5, 6]

и что для второго должно

[0, 1, 3, 5, 4, 6, 7].

Каков был бы эффективный способ достичь этого?