Trouver des angles d'un polygone représenté par une région de masque

C'est un peu similaire à ce que @AndyL suggéré. Cependant, je suis en utilisant la limite de signature en coordonnées polaires au lieu de la tangente.

Remarque que je commence par l'extraction des bords, l'obtention de la frontière, puis de les convertir à la signature. Enfin, nous trouvons les points sur la frontière qui sont les plus éloignés du centre de gravité, ces points constituent les coins trouvé. (Alternativement, nous pouvons également détecter les pics dans la signature pour les coins).

Ce qui suit est une mise en œuvre complète:

I = imread('oxyjj.png');
if ndims(I)==3
I = rgb2gray(I);
end
subplot(221), imshow(I), title('org')
%%# Process Image
%# edge detection
BW = edge(I, 'sobel');
subplot(222), imshow(BW), title('edge')
%# dilation-erosion
se = strel('disk', 2);
BW = imdilate(BW,se);
BW = imerode(BW,se);
subplot(223), imshow(BW), title('dilation-erosion')
%# fill holes
BW = imfill(BW, 'holes');
subplot(224), imshow(BW), title('fill')
%# get boundary
B = bwboundaries(BW, 8, 'noholes');
B = B{1};
%%# boudary signature
%# convert boundary from cartesian to ploar coordinates
objB = bsxfun(@minus, B, mean(B));
[theta, rho] = cart2pol(objB(:,2), objB(:,1));
%# find corners
%#corners = find( diff(diff(rho)>0) < 0 );     %# find peaks
[~,order] = sort(rho, 'descend');
corners = order(1:10);
%# plot boundary signature + corners
figure, plot(theta, rho, '.'), hold on
plot(theta(corners), rho(corners), 'ro'), hold off
xlim([-pi pi]), title('Boundary Signature'), xlabel('\theta'), ylabel('\rho')
%# plot image + corners
figure, imshow(BW), hold on
plot(B(corners,2), B(corners,1), 's', 'MarkerSize',10, 'MarkerFaceColor','r')
hold off, title('Corners')

EDIT:
En réponse à Jacob commentaire, je dois préciser que j'ai d'abord essayé de trouver les pics de la signature à l'aide de la première/deuxième dérivés, mais a fini par prendre le plus de N points. 10 était juste une ad-hoc de la valeur, et qu'il serait difficile de généraliser (j'ai essayé de prendre 4 de même que le nombre de coins, mais il ne couvre pas tous d'entre eux). Je pense que l'idée de clustering pour supprimer les doublons vaut la peine de regarder dans.

Aussi loin que je le vois, le problème avec la 1ère approche est que si vous intrigue rho sans prendre θ en compte, vous obtiendrez une forme différente (pas les mêmes pics), depuis le vitesse qui nous trace la limite est différente et dépend de la courbure. Si nous pouvions comprendre comment normaliser cet effet, nous pouvons obtenir des résultats plus précis à l'aide de produits dérivés.

OriginalL'auteur Amro

J'aime résoudre ce problème en travaillant avec une limite, car il réduit cette 2D à partir d'un problème à un problème 1D.

Utilisation bwtraceboundary() de la trousse à outils de traitement d'image pour extraire une liste de points sur la frontière. Puis de convertir la limite dans une série de vecteurs tangents (il y a un certain nombre de façons de le faire, on pourrait subrtact l'
ième point le long de la frontière de la i+deltaème point.) Une fois que vous avez une liste de vecteurs, de prendre le produit scalaire des vecteurs adjacents. Les quatre points avec le plus petit point des produits sont vos coins!

Si vous voulez que votre algorithme de travailler sur les polygones avec un abritrary nombre de sommets, puis il suffit de chercher point des produits qui sont d'un certain nombre d'écarts-types en dessous de la médiane produit scalaire.

OriginalL'auteur AndyL

Voici un exemple d'utilisation de Ruby et HornetsEye. Fondamentalement, le programme crée un histogramme de la quantised gradient de Sobel orientation pour trouver dominante orientations. Si les quatre orientations dominantes sont trouvés, les lignes sont montés et les intersections entre les lignes sont supposés être les coins de la projection de rectangle.

#!/usr/bin/env ruby
require 'hornetseye'
include Hornetseye
Q = 36
img = MultiArray.load_ubyte 'http://imgur.com/oxyjj.png'
dx, dy = 8, 6
box = [ dx ... 688, dy ... 473 ]
crop = img[ *box ]
crop.show
s0, s1 = crop.sobel( 0 ), crop.sobel( 1 )
mag = Math.sqrt s0 ** 2 + s1 ** 2
mag.normalise.show
arg = Math.atan2 s1, s0
msk = mag >= 500
arg_q = ( ( arg.mask( msk ) / Math::PI + 1 ) * Q / 2 ).to_int % Q
hist = arg_q.hist_weighted Q, mag.mask( msk )
segments = ( hist >= hist.max / 4 ).components
lines = arg_q.map segments
lines.unmask( msk ).normalise.show
if segments.max == 4
pos = MultiArray.scomplex *crop.shape
pos.real = MultiArray.int( *crop.shape ).indgen! % crop.shape[0]
pos.imag = MultiArray.int( *crop.shape ).indgen! /crop.shape[0]
weights = lines.hist( 5 ).major 1.0
centre = lines.hist_weighted( 5, pos.mask( msk ) ) / weights
vector = pos.mask( msk ) - lines.map( centre )
orientation = lines.hist_weighted( 5, vector ** 2 ) ** 0.5
corner = Sequence[ *( 0 ... 4 ).collect do |i|
i1, i2 = i + 1, ( i + 1 ) % 4 + 1
l1, a1, l2, a2 = centre[i1], orientation[i1], centre[i2], orientation[i2]
( l1 * a1.conj * a2 - l2 * a1 * a2.conj -
l1.conj * a1 * a2 + l2.conj * a1 * a2 ) /
( a1.conj * a2 - a1 * a2.conj )
end ] 
result = MultiArray.ubytergb( *img.shape ).fill! 128
result[ *box ] = crop
corner.to_a.each do |c|
result[ c.real.to_i + dx - 1 .. c.real.to_i + dx + 1,
c.imag.to_i + dy - 1 .. c.imag.to_i + dy + 1 ] = RGB 255, 0, 0
end
result.show
end

OriginalL'auteur wedesoft