Detección de esquinas basada en gráfico binario

Breve descripción

La función cv2.goodFeaturesToTrack () se usa para rastrear esquinas en la imagen detectada

parámetro

• image: la imagen de entrada es una imagen de un solo canal de punto flotante de 8 bits o 32 bits, por lo que a veces la imagen en escala de grises maxCorners:
  devuelve el número máximo de puntos de esquina, que es el número más probable de puntos de esquina. Si este parámetro es no mayor que 0, entonces significa que no hay límite en el número de puntos de esquina.
• qualityLevel: El parámetro mínimo aceptable del punto de esquina de la imagen, el valor de medición de la calidad multiplicado por este parámetro es el valor característico mínimo, y los menores a este número serán descartados.
• minDistance: La distancia euclidiana mínima entre los puntos de esquina devueltos.
• máscara: área de detección. Si la imagen no está vacía (debe tener el tipo CV_8UC1 y el mismo tamaño que la imagen), especifica el área del ángulo de detección.
• blockSize: se utiliza para calcular el tamaño de bloque promedio de la matriz de covarianza derivada en la vecindad de cada píxel.
• useHarrisDetector: elija si desea utilizar la detección de esquinas de Harris, el valor predeterminado es falso k: parámetro libre para la detección de Harris.

Código

import cv2
import numpy as np
import scipy.ndimage
import skimage.morphology
import os
import gdalTools


def good_feature_to_track(thin_mask, mask, out_name, save_path):
    """
     Apply the detector on the segmentation map to detect the road junctions as starting points for tracing.
    :param thin_mask: one-pixel width segmentation map
    :param mask: road segmentation map
    :param out_name: filename
    :param save_path: the directory of corner detection results
    :return:
    """
    # set a padding to avoid image edge corners
    padding_x = 64+5
    padding_y = 64

    corners = cv2.goodFeaturesToTrack(thin_mask, 100, 0.1, 10)
    corners = np.int0(corners)
    img = np.zeros((mask.shape[0], mask.shape[1], 3))
    img[:, :, 0] = mask
    img[:, :, 1] = mask
    img[:, :, 2] = mask
    corner_num = 0
    with open(save_path+out_name[:-4]+".txt", "w") as f:
        for i in corners:
            x, y = i.ravel()
            if x < padding_x or x > img.shape[0]-padding_x:
                continue
            if y < padding_y or y > img.shape[1]-padding_y:
                continue

            f.write("{},{}\n".format(x,y))
            cv2.circle(img, (x, y), 6, (0, 0, 255), -1)
            corner_num += 1
    print("total corners number:{}".format(corner_num))
    # cv2.imwrite(save_path+out_name[:-4]+'_with_corners.png', img)
    return img


def thin_image(mask_dir, filename):
    """
    Skeletonize the road segmentation map to a one-pixel width
    :param mask_dir: the directory of road segmentation map
    :param filename: the filename of road segmentation map
    :return: one-pixel width segmentation map
    """
    im = scipy.ndimage.imread(mask_dir + filename)
    im = im > 128
    selem = skimage.morphology.disk(2)
    im = skimage.morphology.binary_dilation(im, selem)
    im = skimage.morphology.thin(im)
    return im.astype(np.uint8) * 255


def mkdir(path):
    if not os.path.exists(path):
        os.mkdir(path)


if __name__ == '__main__':
    import matplotlib.pyplot as plt
    txt_dir = 'corners'
    mkdir(txt_dir)
    mask_dir = 'train_labels/'
    mask_filename = '000000011.tif'
    thin_img = thin_image(mask_dir, mask_filename)
    # mask = cv2.imread(mask_dir + mask_filename, 0)
    im_proj, im_geotrans, im_width, im_height, mask = gdalTools.read_img(mask_dir + mask_filename)
    img = good_feature_to_track(thin_img, mask, mask_filename, txt_dir)
    plt.subplot(121)
    plt.imshow(thin_img * 255)
    plt.subplot(122)
    plt.imshow(img)
    plt.show()