У меня треугольная тесселяция, как показано на рисунке.
Учитывая N
количество треугольников в тесселяции, у меня есть массив NX 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].
Каким будет эффективный способ достичь этого?