Сначала необходимо проверить, что треугольники (полигоны) образуют поверхность, вернее поверхности без включения одинаковых ребер.
Для этого необходимо проверить вхождение каждого ребра не более чем в 2-а треугольника. Если ребро входит более 2-х раз - исходные данные не корректные.

Далее начиная с первого треугольника:

• Если для текущего треугольника имеется хоть одно запомненное ребро, то помечаем треугольник +, если все имеющиеся ребра с обратным порядком вершин, или -, если все имеющиеся ребра прямой порядок вершин. Если порядок вершин разный - петля Мебиуса. Если нет ни одного ребра помечаем треугольник +.
• Для + запоминаем ребра с имеющимся порядком вершин, для - с обратным.

+ и - и есть порядок обхода.

Всё.

Да, так называемый "non-manifold" (mesh). Ну придется считать 3-е и др входящие ребра открытыми (а шо делать?)

Ничего не понял. Для тр-ка всегда имеются 3 ребра, на то он и тр-к. Можно капитальнее? Ребра строим или как? Если да, то какая это структура? Спасибо

Ну хорошо, от вертекса получили список тр-ков в которые он входит. Довольно хлопотно, ну ладно, а дальше-то что?

Существует глобальный массив треугольников, которому можно сопоставить глобальные массивы ребер и вершин. Здесь нас интересуют ребра.
По мере обхода треугольников, заполняем вспомогательный глобальный массив ребер. Могу предложить хранение глобального массива ребер, например, в виде QHash< QPair<int, int>, Edge >.
Это наиболее универсальный способ, но может быть и более оптимальный (например, Edge[N][N] будет эффективнее, но затраты по памяти больше; или можно разреженную матрицу взять и т.п.).

Структура struct Edge{ int m_counter; ... }; включает счетчик вхождений в треугольники.

typedef QHash< QPair<int, int>, Edge > Edges;

рассмотрим i-й треугольник, пусть l, m, n - вершины

- пытаемся найти ребро (l,m) в глобальном массиве данных по ключу QPair<int, int>( l,m ) или QPair<int, int>( m, l )
- пытаемся найти ребро (m,n) в глобальном массиве данных по ключу QPair<int, int>( m,n ) или QPair<int, int>( n,m )
- пытаемся найти ребро (n,l) в глобальном массиве данных по ключу QPair<int, int>( n,l ) или QPair<int, int>( l,n )

-- если ребер в глобальном массиве нет, запоминаем, что данный треугольник имеет прямой порядок вершин.
-- если есть хотя бы одно ребро в глобальном массиве, то - порядок прямой, если все ребра найдены вторым способом; порядок обратный, если все ребра найдены первым способом; неоднозначность (петля), если ребра найдены разным способом.

- вносим информацию о ребрах в глобальный массив (увеличиваем счетчик использования ребер в анализе)
-- если найденный порядок обхода прямой, увеличиваем счетчик первым способом (для  (l,m), (m,n), (n,l)), если обратный то вторым (для (m,l), (n,m), (l,n)).
-- если нужно, включаем в структуру Edge дополнительную информацию (например, номера вершин, номера треугольников и т.п.)
-- если счетчик превысил 2, то ребро принадлежит более, чем двум треугольникам, следовательно фигура образует не анализируемый случай поверхности.


Здесь нужно вводить какие-то дополнительные критерии для однозначного определения топологии (), возможно из специфики решаемой задачи.

ИМХО, если, структура решает необходимую задачу с требуемой производительностью, то она вполне применима. Но "хозяин - барин". 


Здесь требуется небольшая коррекция алгоритма - нужно организовать порядок обхода треугольников, начиная с соседей.

* Для этого нужно сначала сформировать глобальный массив ребер.
* Затем - цикл по всем треугольникам
** задаем/определяем порядок обхода вершин треугольника (1)
** если треугольникам просматривали
*** если порядок обхода не изменился, то переходим к следующей
*** иначе реагируем на некорректную структуру (сообщаем об ошибке, или исправляем, или удаляем треугольник, или др.)
** цикл по всем ребрам треугольника
*** определяем смежный треугольник для данного и переходим к (1)

Здесь получается рекурсия, от которой можно и избавиться.