trouver l'intersection de deux lignes tracées à l'aide de houghlines opencv

Vous ne voulez pas d'obtenir les intersections des lignes parallèles; seules les intersections des lignes verticales avec ceux des lignes horizontales. Aussi, puisque vous avez la ligne verticale, calcul de la pente sera susceptible d'entraîner l'explosion ou inf pentes, de sorte que vous ne devriez pas utiliser la y = mx+b équations. Vous devez faire deux choses:

1. Segment de vos lignes en deux catégories en fonction de leur angle.
2. Calculer les points d'intersection de chaque ligne dans une seule classe pour les lignes dans les autres classes.

Avec HoughLines, vous avez déjà le résultat comme rho, theta de sorte que vous pouvez facilement segment en deux classes d'angle avec theta. Vous pouvez l'utiliser pour, par exemple, cv2.kmeans() avec theta que vos données que vous voulez partager.

Alors, pour calculer les intersections, vous pouvez utiliser la formule pour calculer les intersections de deux points de chaque ligne. Vous êtes déjà calculer de deux points de chaque ligne: (x1, y1), (x2, y2) de sorte que vous pouvez simplement stocker et de les utiliser. Edit: en Fait, comme on le voit ci-dessous dans mon code, il y a une formule que vous pouvez utiliser pour calculer les intersections de lignes avec le rho, theta forme que HoughLines donne.

J'ai répondu à une question similaire avant avec du code python que vous pouvez vérifier; note ce a l'aide de HoughLinesP qui vous donne seulement des segments de ligne.

---

Exemple de Code

Vous ne fournissez pas votre image d'origine donc je ne peux pas l'utiliser. Au lieu de cela, je vais utiliser la norme de sudoku image utilisée par OpenCV sur leur Hough transformer et seuillage tutoriels:

Tout d'abord, nous allons viens de lire cette image et de binariser l'aide de seuillage adaptatif comme ce qui est utilisé dans ce tutoriel OpenCV:

import cv2
import numpy as np

img = cv2.imread('sudoku.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.medianBlur(gray, 5)
adapt_type = cv2.ADAPTIVE_THRESH_GAUSSIAN_C
thresh_type = cv2.THRESH_BINARY_INV
bin_img = cv2.adaptiveThreshold(blur, 255, adapt_type, thresh_type, 11, 2)

Alors nous trouverons la Hough lignes avec cv2.HoughLines():

rho, theta, thresh = 2, np.pi/180, 400
lines = cv2.HoughLines(bin_img, rho, theta, thresh)

Maintenant, si nous voulons trouver les intersections, vraiment nous voulons trouver les intersections seulement des lignes perpendiculaires. Nous ne voulons pas que les intersections de la plupart des lignes parallèles. Nous avons donc besoin de segmenter nos lignes. Dans cet exemple particulier, vous peut facilement vérifier que la ligne est horizontale ou verticale basée sur un test simple; les lignes verticales ont un theta de autour de 0 ou 180; les lignes horizontales ont une theta autour de 90. Toutefois, si vous voulez un segment sur la base d'un nombre arbitraire d'angles, automatiquement, sans que vous la définition de ces angles, je pense que la meilleure idée est d'utiliser cv2.kmeans().

Il est une chose la plus délicate à obtenir le droit. HoughLines renvoie des lignes dans rho, theta forme (Hesse forme normale), et le theta retournée est entre 0 et 180 degrés, et les lignes autour de 180 et 0 degrés sont similaires (ils sont tous les deux proches de l'horizontale des lignes), nous avons donc besoin d'un moyen d'obtenir cette périodicité dans kmeans.

Si nous tracé de l'angle sur le cercle unité, mais de multiplier l'angle par deux, puis les angles à l'origine autour de 180 degrés deviendra près de 360 degrés et devra donc x, y valeurs sur le cercle unité près le même pour les angles à 0. Donc, nous pouvons obtenir quelques belles "proximité" ici, en traçant des 2*angle avec les coordonnées sur le cercle unité. Ensuite, nous pouvons exécuter cv2.kmeans() sur ces points, et le segment automatiquement avec toutefois de nombreuses pièces que nous voulons.

Nous allons donc créer une fonction pour faire la segmentation:

from collections import defaultdict
def segment_by_angle_kmeans(lines, k=2, **kwargs):
    """Groups lines based on angle with k-means.

    Uses k-means on the coordinates of the angle on the unit circle 
    to segment `k` angles inside `lines`.
    """

    # Define criteria = (type, max_iter, epsilon)
    default_criteria_type = cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER
    criteria = kwargs.get('criteria', (default_criteria_type, 10, 1.0))
    flags = kwargs.get('flags', cv2.KMEANS_RANDOM_CENTERS)
    attempts = kwargs.get('attempts', 10)

    # returns angles in [0, pi] in radians
    angles = np.array([line[0][1] for line in lines])
    # multiply the angles by two and find coordinates of that angle
    pts = np.array([[np.cos(2*angle), np.sin(2*angle)]
                    for angle in angles], dtype=np.float32)

    # run kmeans on the coords
    labels, centers = cv2.kmeans(pts, k, None, criteria, attempts, flags)[1:]
    labels = labels.reshape(-1)  # transpose to row vec

    # segment lines based on their kmeans label
    segmented = defaultdict(list)
    for i, line in zip(range(len(lines)), lines):
        segmented[labels[i]].append(line)
    segmented = list(segmented.values())
    return segmented

Maintenant pour l'utiliser, il suffit de l'appeler:

segmented = segment_by_angle_kmeans(lines)

Ce qui est bien c'est là que l'on peut spécifier un nombre arbitraire de groupes en spécifiant l'argument optionnel k (par défaut, k = 2 donc je n'ai pas le spécifier ici).

Si nous avons tracé les lignes de chaque groupe avec une couleur différente:

Et maintenant tout ce qui reste est de trouver les points d'intersection de chaque ligne dans le premier groupe, à l'intersection de chaque ligne dans le deuxième groupe. Depuis les lignes sont dans la Hesse forme normale, il y a une belle algèbre linéaire formule pour le calcul de l'intersection des lignes à partir de ce formulaire. Voir ici. Nous allons créer deux fonctions ici; celle qui la trouve à l'intersection de deux lignes, et une fonction qui parcourt toutes les lignes dans les groupes et l'utilise de plus simple fonction de deux lignes:

def intersection(line1, line2):
    """Finds the intersection of two lines given in Hesse normal form.

    Returns closest integer pixel locations.
    See https://stackoverflow.com/a/383527/5087436
    """
    rho1, theta1 = line1[0]
    rho2, theta2 = line2[0]
    A = np.array([
        [np.cos(theta1), np.sin(theta1)],
        [np.cos(theta2), np.sin(theta2)]
    ])
    b = np.array([[rho1], [rho2]])
    x0, y0 = np.linalg.solve(A, b)
    x0, y0 = int(np.round(x0)), int(np.round(y0))
    return [[x0, y0]]


def segmented_intersections(lines):
    """Finds the intersections between groups of lines."""

    intersections = []
    for i, group in enumerate(lines[:-1]):
        for next_group in lines[i+1:]:
            for line1 in group:
                for line2 in next_group:
                    intersections.append(intersection(line1, line2)) 

    return intersections

Ensuite pour l'utiliser, il est tout simplement:

intersections = segmented_intersections(segmented)

Et le traçage de toutes les intersections, nous obtenons:

---

Comme mentionné ci-dessus, ce code peut segment des lignes en plus de deux groupes d'angles ainsi. Ici, il est en cours d'exécution sur un dessinés à la main en triangle, et de calculer les points d'intersection de la détection des lignes avec k=3:

Tout d'abord, vous avez besoin pour améliorer la sortie de la transformation de Hough (j'ai l'habitude de le faire par k-means clustering basé sur certains critères, par exemple, de la pente et/ou des centroïdes des segments). Dans votre problème, par exemple, il semble que la pente de toutes les lignes est généralement dans le voisinage de 0, 180, 90 degrés, de sorte que vous pouvez faire de clustering sur cette base.

Ensuite, il ya deux façons que vous pouvez obtenir des points d'intersection(qui est techniquement le même):

1. Les équations dans Bhupen de réponse.
2. À l'aide d'une géométrie de la bibliothèque comme Galbées ou SymPy. L'avantage de le faire avec une géométrie de la bibliothèque, c'est que vous avez accès à une variété d'outils que vous pourriez avoir besoin plus tard dans le développement, à l'intersection, l'interpolation, l'enveloppe convexe, etc. etc.)

P. S. bien faite est un wrapper autour d'un puissant C++ de la géométrie de la bibliothèque, mais SymPy est pur Python. Vous pouvez prendre cela en considération dans le cas où votre application est critique.