Извлечение сегментов из списка 8-связанных пикселей

Используя Mathematica 8, я создал морфологический граф из списка белых пикселей на изображении. Он отлично работает на вашем первом изображении:

Создайте морфологический граф:

graph = MorphologicalGraph[binaryimage];

Затем вы можете запросить интересующие вас свойства графика.

Это дает имена вершин в графе:

vertex = VertexList[graph]

Список ребер:

EdgeList[graph]

И это дает позиции вершины:

pos = PropertyValue[{graph, #}, VertexCoordinates] & /@ vertex

Вот как выглядят результаты для первого изображения:

In[21]:= vertex = VertexList[graph]

Out[21]= {1, 3, 2, 4, 5, 6, 7, 9, 8, 10}

In[22]:= EdgeList[graph]

Out[22]= {1 \[UndirectedEdge] 3, 2 \[UndirectedEdge] 4,  3 \[UndirectedEdge] 4, 
          3 \[UndirectedEdge] 5, 4 \[UndirectedEdge] 6,  6 \[UndirectedEdge] 7, 
          6 \[UndirectedEdge] 9, 8 \[UndirectedEdge] 9,  9 \[UndirectedEdge] 10}

In[26]:= pos = PropertyValue[{graph, #}, VertexCoordinates] & /@ vertex

Out[26]= {{54.5, 191.5}, {98.5, 149.5},  {42.5, 185.5}, 
          {91.5, 138.5}, {132.5, 119.5}, {157.5, 72.5},
          {168.5, 65.5}, {125.5, 52.5},  {114.5, 53.5}, 
          {120.5, 29.5}}

Учитывая документацию, http://reference.wolfram.com/mathematica/ref/MorphologicalGraph.html команда MorphologicalGraph сначала вычисляет скелет путем морфологического прореживания:

skeleton = Thinning[binaryimage, Method -> "Morphological"]

Затем обнаруживаются вершины; это точки ветвления и конечные точки:

verteximage = ImageAdd[
                  MorphologicalTransform[skeleton, "SkeletonEndPoints"],   
                  MorphologicalTransform[skeleton, "SkeletonBranchPoints"]]

А затем вершины связываются после анализа их связности.

Например, можно начать с разрушения структуры вокруг вершины, а затем искать связанные компоненты, открывая ребра графа:

comp = MorphologicalComponents[
           ImageSubtract[
               skeleton, 
               Dilation[vertices, CrossMatrix[1]]]];
Colorize[comp] 

Дьявол кроется в деталях, но это звучит как хорошая отправная точка, если вы хотите разработать собственную реализацию.

Попробуйте математическую морфологию. Сначала вам нужно dilate или close ваше изображение, чтобы заполнить пробелы.

cvDilate(pimg, pimg, NULL, 3);
cvErode(pimg, pimg, NULL);

я получил это изображение

Следующим шагом должно быть применение алгоритма утончения. К сожалению, это не реализовано в OpenCV (у MATLAB есть bwmorph с аргументом thin). Например, с MATLAB я улучшил изображение до этого:

Однако OpenCV имеет все необходимые базовые морфологические операции для реализации прореживания (cvMorphologyEx, cvCreateStructuringElementEx и т. д.).

Еще одна идея.

Говорят, что преобразование расстояния кажется очень полезным в таких задачах. Может быть, так. Рассмотрим функцию cvDistTransform. Он создает такое изображение:

Затем используйте что-то вроде cvAdaptiveThreshold:

Это скелет. Я думаю, вы можете перебрать все связанные белые пиксели, найти кривые и отфильтровать небольшие сегменты.

Я реализовал аналогичный алгоритм раньше, и я сделал это в виде постепенного метода наименьших квадратов. Это сработало довольно хорошо. Псевдокод примерно такой:

L = empty set of line segments
for each white pixel p
  line = new line containing only p
  C = empty set of points
  P = set of all neighboring pixels of p
  while P is not empty
    n = first point in P
    add n to C
    remove n from P
    line' = line with n added to it
    perform a least squares fit of line'
    if MSE(line) < max_mse and d(line, n) < max_distance
      line = line'
      add all neighbors of n that are not in C to P
  if size(line) > min_num_points
    add line to L

где MSE (линия) — среднеквадратическая ошибка линии (сумма по всем точкам на линии квадрата расстояния до наиболее подходящей линии), а d (линия, n) — расстояние от точки n до линии. Хорошие значения для max_distance кажутся пикселями или около того, а max_mse кажется намного меньше и будет зависеть от среднего размера линейных сегментов на вашем изображении. 0,1 или 0,2 пикселя работали на довольно больших изображениях для меня.

Я использовал это на реальных изображениях, предварительно обработанных с помощью оператора Canny, поэтому у меня есть только это. Вот результат вышеописанного алгоритма для изображения:

Алгоритм тоже можно сделать быстрым. Имеющаяся у меня реализация C++ (закрытый исходный код, вызванный моей работой, извините, иначе я бы дал его вам) обработала приведенное выше изображение примерно за 20 миллисекунд. Это включает в себя применение оператора Canny для обнаружения границ, поэтому в вашем случае это должно быть еще быстрее.

Вы можете начать с извлечения прямых линий из изображения контуров, используя HoughLinesP, который предоставляется с openCV:

HoughLinesP(InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength = 0, double maxLineGap = 0)  

Если вы выберете маленькие threshold = 1 и minLineLenght, вы даже можете получить все отдельные элементы. Однако будьте осторожны, так как это дает много результатов, если у вас много краевых пикселей.