[300 rotinas OpenCV] 243. Algoritmo FAST para detecção de recursos

"300 rotinas OpenCV de youcans - catálogo geral"

[300 rotinas OpenCV de youcans] 243. Algoritmo FAST para detecção de recursos

6.6.1 Introdução ao Algoritmo FAST

FAST (Features From Accelerated Segment Test) é um algoritmo de detecção de ponto de recurso que é usado para extração de recursos, mas não envolve descrição de recursos.

SIFT e SURF requerem uma grande quantidade de computação, o que torna difícil atender aos requisitos de tempo real. Edward Rosten propôs o algoritmo de detecção de recursos FAST em 2006. O algoritmo FAST discrimina pontos de recursos comparando resultados com pixels circunferenciais, com velocidade de cálculo rápida e alta repetibilidade, o que é muito adequado para processamento de vídeo em tempo real.

O algoritmo FAST define um canto como um pixel que provavelmente será um canto se diferir significativamente de vários pixels em sua vizinhança.

Portanto, 16 pontos de pixel são tomados uniformemente no círculo centrado no ponto de pixel. Se a diferença entre os valores de pixel de N pixels consecutivos e o ponto central for maior que o limite definido, o pixel central é determinado como um ponto de canto . Existem dois casos específicos, um é que N pixels consecutivos são mais brilhantes que o ponto central, e o outro é que N pixels consecutivos são mais escuros que o ponto central, e a diferença de brilho é maior que o limite definido t.

A fim de melhorar a eficiência de detecção, um grande número de pontos não angulares pode ser eliminado por meio de triagem preliminar: se N = 12, três dos quatro pontos de interseção entre a circunferência e o eixo vertical do eixo horizontal devem atender ao brilho acima condições de diferença. Calcule a diferença de pixel entre p1, p9, p5, p13 e o ponto central p. Se pelo menos 3 diferenças de pixel atenderem à condição de limite, eles serão usados ​​como pontos candidatos, caso contrário, serão rejeitados.

No OpenCV, os dois pontos de interseção do eixo horizontal e do eixo vertical são respectivamente detectados para triagem preliminar: (1) Calcular a diferença de pixel entre p1, p9 e o ponto central p, e remover se a condição de limiar não for atendida; ( 2) Calcule p5, p13 A diferença de pixel com o ponto central p, se não atender a condição de limite, será rejeitada.

As etapas de implementação do algoritmo FAST são:

(1) Defina o limite de comparação t, que é usado para comparar se a diferença de valores de pixel é grande o suficiente.

(2) Construa uma janela móvel, selecione 16 pixels do círculo com o pixel p como centro e raio 3, numerado p1~p16.

(3) Calcule a diferença de pixel entre o pixel pk e o ponto central p e compare: $({eu}_{pk}-{EU}_{}>t)ou(eu{}_{}-{EU}_{pk}>t)$

3.1 Calcule a diferença de pixel entre p1, p9, p5, p13 e p. Se pelo menos 3 das diferenças de pixel forem maiores que o limite t (ou menor que -t), então P é um ponto candidato, caso contrário, p não é um ponto de recurso;

3.2 Se p for um ponto candidato, calcule a diferença de pixel entre p1~p16 e o ​​ponto central p. Se a diferença de pixel de pelo menos 9 (ou 12) pontos em uma linha for maior que o limite t (ou menor que -t ), então P é um ponto característico .

(4) Supressão de valor não máximo: Se houver vários pontos de característica na vizinhança, apenas o ponto de característica com o maior valor de resposta é retido.

Vantagens e desvantagens do algoritmo FAST:

(1) O algoritmo FAST é simples e rápido, muito mais rápido que outros algoritmos;

(2) O algoritmo FAST é muito sensível à influência do ruído, e o tamanho do limiar t tem grande influência nos resultados;

(3) O algoritmo básico FAST não gera recursos multiescala, nem possui informações de orientação, portanto, não possui invariância de escala e invariância de rotação.

6.6.2 Classe FastFeatureDetector no OpenCV

O OpenCV fornece uma grande variedade de algoritmos de detecção de recursos e herda a classe cv::Feature2D, usando uma definição e encapsulamento unificados.

O OpenCV fornece a classe cv::FastFeatureDetector para implementar o método FastFeatureDetector, herda a classe cv::Feature2D e a cria através do método create static.

O construtor da classe FastFeatureDetector é:

static Ptr< FastFeatureDetector >
cv::FastFeatureDetector::create (int threshold=10, bool nonmaxSuppression=true, FastFeatureDetector::DetectorType type=FastFeatureDetector::TYPE_9_16)

Na linguagem Python, o OpenCV fornece a função de interface cv.FastFeatureDetector.create() da classe FastFeatureDetector para instanciar a classe FastFeatureDetector.

cv.FastFeatureDetector.create([, threshold=10, nonmaxSuppression=true, type=FastFeatureDetector::TYPE_9_16]) → retval
cv.FastFeatureDetector_create([, threshold=10, nonmaxSuppression=true, type=FastFeatureDetector::TYPE_9_16]) → retval
FastFeatureDetector.detect(image, [, mask]) → keypoints 

Descrição do parâmetro:

• imagem: imagem de entrada, canal único
• keypoints : keypoints detectados, é uma estrutura de dados especial que inclui as seguintes propriedades:
  • Ponto2f pt: coordenadas
  • tamanho do flutuador: o diâmetro da vizinhança do ponto-chave
  • ângulo de flutuação: a direção do ponto chave, o valor é [0, 360)
  • resposta float: a força de resposta do ponto-chave
  • int oitava: o grupo de pirâmides de imagem onde os pontos-chave estão localizados
  • int class_id: o número de id do ponto chave
• limite: limite de diferença t, opcional, valor padrão é 10
• nonmaxSuppression: se a supressão não máxima deve ser executada, opcional, o padrão é true
• tipo: tipo de esquema de detecção, valor padrão TYPE_9_16
  • FastFeatureDetector::TYPE_9_16, indicando que 16 pixels na circunferência / 9 pixels consecutivos atendem às condições
  • FastFeatureDetector::TYPE_7_12, indicando que 12 pixels na circunferência / 7 pixels consecutivos atendem às condições
  • FastFeatureDetector::TYPE_5_8, indicando que 8 pixels na circunferência/5 pixels consecutivos atendem às condições
• mask: imagem de máscara, canal único de 8 bits, especifica a área para encontrar pontos-chave, opcional

Precauções:

• A função cv.FastFeatureDetector.create() instancia a classe FastFeatureDetector e constrói um objeto FastFeatureDetector.
• O valor do limiar de diferença é muito importante, o que afeta seriamente o resultado da detecção.

Rotina 14.25: algoritmo FAST para detecção de recursos

    # 14.25 特征检测之 FAST 算子
    # # 读取基准图像
    img = cv.imread("../images/Circuit04.png", flags=1)  # 基准图像
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)  # (425, 558)
    height, width = gray.shape[:2]
    print("shape of image: ", height, width)

    fast = cv.FastFeatureDetector_create()  # 初始化 FAST 对象
    # 默认值：threshold=10, nonmaxSuppression=true, type=FastFeatureDetector::TYPE_9_16
    kpNMS1 = fast.detect(img, None)  # 检测关键点
    imgFASTnms1 = cv.drawKeypoints(img, kpNMS1, None, color=(255, 0, 0))
    # 关闭非极大抑制
    fast.setNonmaxSuppression(0)  # nonmaxSuppression=false
    kp1 = fast.detect(img, None)
    imgFAST1 = cv.drawKeypoints(img, kp1, None, color=(255, 0, 0))
    print("\nthreshold: {}".format(fast.getThreshold()))
    print("num of Keypoints without NMS: {}".format(len(kp1)))
    print("num of Keypoints with NMS: {}".format(len(kpNMS1)))

    fastT2 = cv.FastFeatureDetector_create(threshold=20)  # 设置差分阈值为 20
    kpNMS2 = fastT2.detect(img, None)  # 检测关键点
    imgFASTnms2 = cv.drawKeypoints(img, kpNMS2, None, color=(255, 0, 0))
    # 关闭非极大抑制
    fastT2.setNonmaxSuppression(0)  # nonmaxSuppression=false
    kp2 = fastT2.detect(img, None)
    imgFAST2 = cv.drawKeypoints(img, kp2, None, color=(255, 0, 0))
    print("\nthreshold: {}".format(fastT2.getThreshold()))
    print("num of Keypoints without NMS: {}".format(len(kp2)))
    print("num of Keypoints with NMS: {}".format(len(kpNMS2)))

    fastT3 = cv.FastFeatureDetector_create(threshold=40)  # 设置差分阈值为 40
    kpNMS3 = fastT3.detect(img, None)  # 检测关键点
    imgFASTnms3 = cv.drawKeypoints(img, kpNMS3, None, color=(255, 0, 0))
    # 关闭非极大抑制
    fastT3.setNonmaxSuppression(0)  # nonmaxSuppression=false
    kp3 = fastT3.detect(img, None)
    imgFAST3 = cv.drawKeypoints(img, kp3, None, color=(255, 0, 0))
    print("\nthreshold: {}".format(fastT3.getThreshold()))
    print("num of Keypoints without NMS: {}".format(len(kp3)))
    print("num of Keypoints with NMS: {}".format(len(kpNMS3)))

    plt.figure(figsize=(9, 6))
    plt.subplot(231), plt.title("FAST without NMS (t=10)")
    plt.axis('off'), plt.imshow(cv.cvtColor(imgFAST1, cv.COLOR_BGR2RGB))
    plt.subplot(232), plt.title("FAST without NMS (t=20)")
    plt.axis('off'), plt.imshow(cv.cvtColor(imgFAST2, cv.COLOR_BGR2RGB))
    plt.subplot(233), plt.title("FAST without NMS (t=40)")
    plt.axis('off'), plt.imshow(cv.cvtColor(imgFAST3, cv.COLOR_BGR2RGB))
    plt.subplot(234), plt.title("FAST with NMS (t=10)")
    plt.axis('off'), plt.imshow(cv.cvtColor(imgFASTnms1, cv.COLOR_BGR2RGB))
    plt.subplot(235), plt.title("FAST with NMS (t=20)")
    plt.axis('off'), plt.imshow(cv.cvtColor(imgFASTnms2, cv.COLOR_BGR2RGB))
    plt.subplot(236), plt.title("FAST with NMS (t=40)")
    plt.axis('off'), plt.imshow(cv.cvtColor(imgFASTnms3, cv.COLOR_BGR2RGB))
    plt.tight_layout()
    plt.show()

resultado da operação:

limite: 10
número de pontos-chave sem NMS: 12100
número de pontos-chave com NMS: 3704

limite: 20
número de pontos-chave sem NMS: 5591
número de pontos-chave com NMS: 1892

limite: 40
número de pontos-chave sem NMS: 1974
número de pontos-chave com NMS: 840

参考文献：Edward Rosten e Tom Drummond, “Machine learning for high speed corner detection” na 9ª Conferência Europeia sobre Visão Computacional, vol. 1, 2006, pp. 430–443.

【Fim desta seção】

Declaração de direitos autorais:
Youcans@xupt trabalhos originais, reimpressões devem ser marcadas com o link original: (https://blog.csdn.net/youcans/article/details/127333535)
Copyright 2022 youcans, XUPT Crated
: 2022-10-15

240. Detecção de Canto Shi-Tomas em OpenCV
241. Transformação de Característica Invariante de Escala (SIFT)
242. Algoritmo Acelerado de Detecção de Característica Robusta (SURF)
243. Algoritmo FAST para Detecção de Característica