Deteção de pontos característicos

Tutorial em vídeo 16 - Deteção e armazenamento de pontos característicos: https://singtown.com/learn/50021/

Comparação entre correspondência de modelos e deteção de pontos característicos:

• Correspondência de modelos (find_temolate) utiliza o algoritmo NCC, que só consegue corresponder padrões que tenham basicamente o mesmo tamanho e ângulo da imagem do modelo. As limitações são relativamente grandes. Se o padrão alvo no campo de visão for ligeiramente maior ou menor do que a imagem do modelo, a correspondência pode não ser bem-sucedida.

• A correspondência de modelos é adequada para situações em que a distância entre a câmara e o objeto alvo é fixa e não é necessário movimento dinâmico. Por exemplo, é adequada para a deteção de objetos específicos numa linha de montagem, mas não para um carro seguir uma bola de voleibol em movimento (porque a distância entre a bola em movimento e a câmara é dinâmica, o tamanho da bola visto pela câmara vai mudar e não será exatamente igual à imagem do modelo).

• Para correspondência em vários ângulos e tamanhos, pode tentar guardar vários modelos e utilizar a Correspondência de vários modelos.

• Deteção de pontos característicos (find_keypoint): Se acabou de iniciar a execução do programa, a rotina extrai a primeira imagem como a característica do objeto alvo, e kpts1 guarda essa característica. Por predefinição, corresponderá a várias escalas e ângulos da característica alvo, e não apenas ao tamanho e ângulo guardados inicialmente. É mais flexível do que a correspondência de modelos e não precisa de guardar várias imagens de modelo como na correspondência de vários modelos.

• A deteção de pontos característicos também pode guardar as características alvo com antecedência. Isto não era recomendado anteriormente porque a interferência da luz ambiente e outros fatores podiam causar características diferentes sob luzes diferentes de cada vez que o programa era executado, reduzindo o grau de correspondência. No entanto, na versão mais recente do firmware foram adicionados ajustes de exposição, balanço de brancos e valor de ganho automático. O valor de exposição e o valor de balanço de brancos podem ser definidos manualmente, o que reduz relativamente a interferência da luz. Pode também tentar guardar as características alvo com antecedência.

Deteção de pontos característicos

Esta rotina é a 09-feature-Detection-keypoints.py\ Esta rotina utiliza o algoritmo FAST/AGAST para extração de características e seguimento de alvos, e suporta apenas imagens em escala de cinza.

Nota: Esta rotina vai considerar o objeto que aparecer nos primeiros dez segundos do programa como a característica alvo. Coloque o objeto alvo no centro da câmara no início do programa até aparecer o canto característico, o que prova que a característica alvo foi identificada e registada.

Durante o processo de correspondência, se aparecer uma cruz e um retângulo no ecrã, isso prova que a correspondência foi bem-sucedida.

# Exemplo de deteção de um objeto específico utilizando pontos característicos.
# Mostre um objeto à câmara e depois execute este script. Um conjunto de
# pontos-chave será extraído uma vez e depois seguido nos fotogramas
# seguintes. Se quiser um novo conjunto de pontos-chave, execute o script
# novamente.
# Nota: consulte a documentação para ajustar find_keypoints e match_keypoints.
import csi, time, image
csi0 = csi.CSI()

# Reinicia o sensor
csi0.reset()

# Definições do sensor
csi0.framesize(csi.VGA)
csi0.window((320, 240))
csi0.pixformat(csi.GRAYSCALE)

csi0.snapshot(time = 2000)
csi0.auto_gain(False)

#Desenha os pontos-chave
def draw_keypoints(img, kpts):
    if kpts:
        print(kpts)
        img.draw_keypoints(kpts)
        img = csi0.snapshot()
        time.sleep_ms(1000)

kpts1 = None
#kpts1 guarda a característica do objeto alvo; é possível importar a característica de um ficheiro, mas isso não é recomendado.
#kpts1 = image.load_descriptor("/desc.orb")
#img = csi0.snapshot()
#draw_keypoints(img, kpts1)

clock = time.clock()

while (True):
    clock.tick()
    img = csi0.snapshot()
    if (kpts1 == None):
        #Se o programa acabou de começar a correr, extrai a imagem inicial como a característica do objeto alvo, e kpts1 guarda essa característica.
        #Por predefinição, corresponderá a várias escalas da característica alvo, e não apenas ao tamanho guardado inicialmente; é mais flexível do que a correspondência de modelos.
        # NOTA: Por predefinição, find_keypoints devolve pontos-chave multiescala extraídos de uma pirâmide de imagens.
        kpts1 = img.find_keypoints(max_keypoints=150, threshold=10, scale_factor=1.2)
        #image.find_keypoints(roi=Auto, threshold=20, normalized=False, scale_factor=1.5, max_keypoints=100, corner_detector=CORNER_AGAST)
        #roi representa a região de reconhecimento, é um tuplo (x,y,w,h), por predefinição igual ao tamanho de framesize.
        #threshold é um limiar entre 0~255, usado para controlar o número de cantos detetados. Com a deteção AGAST predefinida, este limiar ronda os 20. Com a deteção FAST, ronda os 60~80. Quanto menor o limiar, mais cantos são obtidos.
        #normalized é um valor booleano, por predefinição False, e permite corresponder a várias escalas da característica alvo (mais flexível do que a correspondência de modelos NCC). Se definido como True, desativa os resultados multiescala da deteção de pontos-chave e corresponde apenas a uma escala da característica alvo (semelhante à correspondência de modelos), mas a velocidade de cálculo será um pouco maior.
        #scale_factor é um número de vírgula flutuante maior que 1.0. Quanto maior este valor, mais rápida é a deteção, mas a precisão da correspondência diminui. Em geral, o valor ideal ronda 1.35~1.5.
        #max_keypoints é o número máximo de pontos-chave que podem ser extraídos de um objeto. Se um objeto tiver demasiados pontos-chave e isso esgotar a memória RAM, reduza este valor.
        #corner_detector é o algoritmo usado na deteção de pontos-chave, por predefinição o algoritmo AGAST. O algoritmo FAST é mais rápido, mas a precisão diminui.
        draw_keypoints(img, kpts1)
        #Desenha a característica alvo neste momento
    else:
        #Ao corresponder com a característica alvo inicial, normalized=True por predefinição, correspondendo apenas a uma escala da característica alvo.
        # NOTA: Ao extrair pontos-chave para corresponder ao primeiro descritor, usamos normalized=True para extrair
        # pontos-chave apenas da primeira escala, que corresponderá a uma das escalas do primeiro descritor.
        kpts2 = img.find_keypoints(max_keypoints=150, threshold=10, normalized=True)
        #Se o objeto característico for detetado
        if (kpts2):
            #Corresponde a semelhança entre a característica atualmente encontrada e a característica alvo inicial
            match = image.match_descriptor(kpts1, kpts2, threshold=85)
            #image.match_descriptor(descriptor0, descriptor1, threshold=70, filter_outliers=False). Esta função devolve um objeto kptmatch.
            #threshold define a precisão da correspondência, usado para filtrar correspondências ambíguas. Quanto menor o valor, maior a precisão. O intervalo do limiar é 0~100, por predefinição 70
            #filter_outliers está desativado por predefinição.

            #match.count é o número aproximado de pontos-chave correspondidos entre kpt1 e kpt2.
            #Se for maior que 10, prova que as duas características são semelhantes, correspondência bem-sucedida.
            if (match.count>10):
                # Se tivermos pelo menos n "boas correspondências"
                # Desenha o retângulo delimitador e a cruz.
                #Desenha uma cruz e um retângulo no centro da característica alvo correspondida.
                img.draw_rectangle(match.rect)
                img.draw_cross((match.cx, match.cy), size=10)

            #match.theta é o ângulo de rotação do objeto característico correspondido em relação ao objeto alvo.
            print(kpts2, "matched:%d dt:%d"%(match.count, match.theta))
            #Não é recomendado usar draw_keypoints para desenhar os cantos característicos.
            # NOTA: descomente se quiser desenhar os pontos-chave
            #img.draw_keypoints(kpts2, size=KEYPOINTS_SIZE, matched=True)

    # Desenha o FPS
    #Imprime a taxa de fotogramas.
    img.draw_string((0, 0), "FPS:%.2f"%(clock.fps()))

O efeito de execução do programa: