Reconhecimento de estrelas usando visão computacional (OpenCV): 11 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Este instrutível descreverá como criar um programa de visão por computador para identificar automaticamente os padrões de estrelas em uma imagem. O método usa a biblioteca OpenCV (Open-Source Computer Vision) para criar um conjunto de cascatas HAAR treinadas que podem ser usadas para reconhecer padrões estelares específicos. Embora este guia esteja no contexto de reconhecimento de padrão de estrela, o processo OpenCV que descrevo pode ser aplicado a outros aplicativos também - portanto, espero que seja útil!

O projeto está resumido neste vídeo:

Por que escrevi este instrutível?

1. Acredito que o método de identificação de padrão de estrela que estou desenvolvendo tem potencial para ser aplicado a uma ampla gama de projetos de astronomia amadores - seja orientação do telescópio, classificação automática de imagem ou mesmo, em última instância, um sensor de estrela em um código aberto ou CubeSat amador.
2. Existem muitos bons instructables OpenCV aqui, mas mesmo assim eu achei um processo muito difícil de aprender inicialmente, então espero que este guia seja uma boa referência para outras pessoas que procuram treinar classificadores HAAR para OpenCV (não necessariamente relacionado com astronomia, talvez!).
3. Não sou um programador treinado, então este projeto realmente aumentou meu entendimento. Esperançosamente, ao escrever este Instructable, outros criadores mais experientes serão inspirados a trabalhar neste conceito e contribuir com o GitHub e isso pode ser instruído por meio de comentários nesta página.
4. Astronomia amadora e métodos de orientação são de grande interesse para mim, veja meu instrutível anterior com um Arduino Star-Finder para telescópios.

A foto da capa deste Instructable é de um projeto conceito 3U CubeSat do qual participei. Usei-o para ilustrar isso, já que a aplicação original do sistema de reconhecimento de estrelas por visão por computador era para ser um sensor de orientação para CubeSats feitos por amadores, usando uma câmera Raspberry Pi V2. Existem muitas outras aplicações potenciais do reconhecimento de estrelas por visão computacional, eu acredito, mas acho que esta é a mais legal!

Um pequeno glossário:

Aprender sobre visão computacional fica mais lento devido à quantidade estúpida de termos especializados usados, então vou definir alguns para nós aqui:

Cascade - Um classificador treinado para identificar um objeto de destino específico.

Marcador Fiducial - Um marcador que adiciona um ponto de referência visual a uma imagem.

HAAR - Os recursos do tipo Haar são um tipo de recurso de imagem usado para treinamento do classificador.

OpenCV - Open Source Computer Vision, uma biblioteca de ferramentas de visão computacional.

Stellarium - Software de astronomia de código aberto.

Etapa 1: Requisitos

OpenCV é uma biblioteca baseada em Linux, então embora seja supostamente possível operá-la bem no Windows, você terá muito mais facilidade em executá-la em um ambiente Linux (tire isso de mim e muitos dias tentando fazê-la funcionar totalmente Janelas!). Como experiência, baixei e executei o OpenCV no meu Raspberry Pi 3B +, que foi bem-sucedido, embora o treinamento do classificador seja um processo muito intensivo de RAM, então se você deseja fazê-lo em qualquer velocidade, o caminho recomendado é contratar um servidor virtual Linux (o que pode ser surpreendentemente barato, na verdade) por alguns dias / semanas / meses e use isso como um ambiente dedicado no qual executar o treinamento do classificador. Você poderá controlar o servidor a partir de um PC com Windows usando um cliente SSH como o Putty. Uma vez que as cascatas são treinadas usando o VPS, elas podem ser baixadas para o seu PC com Windows e o Python pode ser usado para executar o programa de reconhecimento de imagem em um ambiente Windows.

Servidor Virtual Linux:

Um Linux Virtual Server (VPS) é necessário para realizar os processos de treinamento em cascata HAAR. Inicialmente, contratei um servidor com 8 GB de RAM e Ubuntu 16.04.6 (LTS) x64, e depois um segundo para dobrar a taxa em que eu poderia treinar cascatas, embora você só precise de um mínimo de uma

Programas:

• Stellarium - este é um software de planetário / astronomia virtual, disponível gratuitamente. Ele será usado para reunir imagens de estrelas simuladas para uso em testes.
• Putty - Este é um cliente SSH usado para controlar o VPS via linha de comando.
• WinSCP - usado para realizar a transferência de arquivos do PC com Windows.

Etapa 2: configuração de VPS

Há um pequeno processo de configuração para colocar o VPS em funcionamento. Na primeira vez, pode demorar um pouco para você, mas não será muito complicado se você seguir as etapas com atenção. Este tutorial foi uma ótima referência para mim, recomendo que você leia isso também enquanto trabalha com este instrutível. Ele cobre as especificidades dos comandos do Linux linha por linha, o que é necessário seguir à risca.

Grosso modo, o processo envolve:

1. Criação de servidor Linux com versão correta do Ubuntu.
2. Atualizando e atualizando o servidor.
3. Criação de um diretório de espaço de trabalho, no qual o OpenCV é instalado.
4. Instalação de alguns fundamentos, nomeadamente um compilador, várias bibliotecas e ligações Python.

Após este estágio, você está pronto para começar a se preparar para o processo de treinamento.

Etapa 3: O Processo

Todo o processo de visão computacional usando cascatas HAAR é bastante confuso no início, então esta etapa descreve a lógica com um pouco mais de detalhes:

Processo Básico

1. Existe um conjunto de dados de imagens negativas, consistindo em vários milhares de imagens que não contêm o objeto de interesse. Isso precisará ser carregado no VPS.
2. Uma única imagem positiva é criada contendo o objeto de interesse. Isso também precisará ser carregado no VPS.
3. A única imagem positiva é distorcida, deformada, girada, etc., por um conjunto de parâmetros escolhidos e sobreposta em uma seleção de imagens negativas. Esta é uma forma artificial de criar um grande conjunto de dados positivos a partir de uma única imagem. (Para outras aplicações do mundo real, como a identificação de um gato, você poderia simplesmente usar vários milhares de imagens de gatos, mas esse método nem sempre é apropriado se você não tiver um conjunto tão grande de imagens positivas. A abordagem artificial usada aqui será menos eficaz, mas é a única opção para um caso de uso como este).
4. É executado um processo de treinamento, que funciona em etapas. Cada estágio treinará uma cascata para identificar diferentes recursos do tipo HAAR nos conjuntos de imagens. Cada estágio leva exponencialmente mais tempo para ser concluído, e a eficácia do classificador aumenta a cada vez (também é possível over-train apenas para você saber!).
5. Uma única cascata treinada será capaz de procurar um único objeto de destino. Se desejar identificar vários objetos exclusivos, você precisará de uma cascata treinada para cada um. Neste caso, treinei cerca de 50 cascatas diferentes para padrões de estrelas únicos, para criar um conjunto que pudesse cobrir o hemisfério celestial norte.
6. Por último, é usado um programa de detecção que executa cada cascata de um conjunto contra uma imagem de entrada. A cascata procurará seu determinado objeto de destino na imagem de entrada.
7. Se for bem-sucedido, o objeto de destino será identificado na imagem de entrada.

n.b. se usado em um contexto de orientação de satélite, por exemplo, uma imagem seria capturada usando uma câmera integrada. As estrelas mais brilhantes dessa imagem serão identificadas e os marcadores serão sobrepostos nessas posições. Esta imagem então é apresentada ao conjunto de cascatas treinadas, que testarão para ver se a imagem de entrada contém algum dos objetos alvo. Se um positivo verdadeiro for detectado, então a posição angular de uma constelação conhecida é descoberta em relação aos eixos do corpo do satélite.

Etapa 4: negativos e positivos

Negativos

Um aspecto realmente importante do treinamento em cascata é ter o maior conjunto de dados de imagens negativas possível. Estamos falando de milhares, idealmente dezenas de milhares de imagens. Não importa o que eles contêm, o objetivo é apenas fornecer uma variedade de informações visuais. A pasta Classifier Training contém uma variedade de conjuntos de dados de imagens negativas diferentes que eu compilei. Inicialmente, eles eram compostos apenas de imagens simuladas de campos estelares coletadas do Stellarium, mas depois aumentei o conjunto de dados com tantas imagens aleatórias quanto pude encontrar (sim, incluindo minhas fotos de férias …). O maior conjunto de dados inclui quase 9.000 imagens, que foi o maior que criei até agora. Usando isso, você vai economizar compilando o seu próprio.

Positivos

A imagem positiva (que é o padrão de estrela-alvo que a cascata será treinada para reconhecer) começa como uma captura de tela de um padrão de estrela no Stellarium. Um programa python então identifica as estrelas mais brilhantes na imagem e sobrepõe os marcadores (explicados mais tarde neste manual) nessas posições das estrelas. Essa imagem é então reduzida para 50x50 pixels. Isso é pequeno, mas o tempo de treinamento necessário para as cascatas aumentará exponencialmente à medida que esse tamanho aumenta e, portanto, esse é um bom compromisso entre qualidade e tempo.

Etapa 5: Controle de Stellarium

A pasta Stellarium Scripts do repositório GitHub contém três programas que escrevi para controlar o uso do Stellarium. Para usá-los, coloque-os na pasta de scripts da pasta de instalação do Stellarium. Para executá-los, você pode abrir a janela de scripts de dentro do menu Stellarium, ou apenas clicando duas vezes no programa na pasta de scripts, o que iniciará o Stellarium e executará imediatamente o programa selecionado.

thesis_4 e thesis_5 capturam cerca de 2.000 imagens de cada um dos hemisférios celestes norte e sul, respectivamente. Estes foram usados para formar bancos de dados de imagens negativas, para treinar contra as imagens positivas. A distinção entre norte e sul era uma maneira simples de garantir que o padrão de estrela alvo (positivo) não estaria presente no conjunto de dados negativo, treinando os padrões de estrelas do hemisfério norte contra o conjunto de dados de imagem do hemisfério celestial sul e vice-versa. (Se uma imagem positiva também estiver presente no conjunto de dados de imagens negativas, isso afetará a qualidade do classificador).

thesis_setup também é útil - configura o Stellarium para ser apropriado para capturar imagens - as imagens usadas para simular uma visão do Espaço. Ele executa ações como ocultar menus, linhas de grade, rótulos etc. automaticamente para evitar que você precise cada vez que quiser capturar uma imagem.

Etapa 6: Homem-foguete

As primeiras cascatas que treinei não conseguiram identificar corretamente nenhum padrão estelar. Eles não eram confiáveis e estavam muito sujeitos a falsos positivos. Minha suposição era que efetivamente as imagens do campo estelar do Stellarium (basicamente apenas pontos brancos em um fundo preto) simplesmente não continham informações visuais suficientes para conter recursos do tipo HAAR suficientes para um treinamento de classificador bem-sucedido. Acho que era tarde da noite, mas decidi tentar escrever um programa para colocar automaticamente uma pequena imagem em miniatura sobre a localização de cada estrela brilhante em uma imagem de campo estelar.

Elton

Este foi um teste bobo, mas ao adicionar uma pequena imagem do rosto de Elton John a cada localização de estrela brilhante, treinando o classificador contra esta imagem positiva e, em seguida, executando as cascatas contra a imagem original, foi muito mais eficaz em encontrar corretamente o padrão certo. Eu sabia que estava no caminho certo!

Etapa 7: Marcadores Fiduciais

Embora os 'Eltons' provassem a teoria, eu precisava de um marcador que tivesse simetria rotacional completa, de modo que o padrão de estrela aparecesse o mesmo, não importando a orientação em que fosse apresentado. Testei uma variedade de tipos de marcadores e descobri que o tipo no canto inferior direito era mais eficaz, com anéis pretos e brancos contrastantes. O programa python apresentado na pasta positiva do repositório GitHub mostra como as estrelas mais brilhantes em uma determinada imagem são identificadas e esses marcadores são automaticamente sobrepostos nessas posições. Agora criamos uma representação dos principais padrões de estrelas que podem ser treinados.

Etapa 8: Usando Cascades

Depois de treinar um conjunto de cascatas, você precisa saber como usá-las para identificar um objeto em uma imagem!

Olhe para a pasta Star Identification do GitHub, onde você encontrará o programa cascade_test19.py. Esse programa de nome cativante pega um conjunto de cascatas de uma determinada pasta e as executa em uma imagem de entrada e relata as detecções feitas. A função 'detectMultiScale' é o núcleo disso e leva uma variedade de argumentos que definem o processo de detecção. Alterá-los é fundamental para o desempenho do classificador em cascata, e mais discussão sobre isso pode ser encontrada na etapa a seguir, onde veremos como eliminar falsos positivos.

Isso poderia ser aplicado em um sistema de orientação de satélite correlacionando o valor do pixel no centro da caixa delimitadora à coordenada celestial Ra / Dec do padrão de estrela identificado e, em seguida, correlacionando isso ao deslocamento angular do centro da imagem (câmera eixo). A partir disso, usando uma compreensão da distorção da lente (aproximada a uma projeção gnomônica), o ângulo do satélite pode ser encontrado a partir de apenas duas identificações positivas.

Etapa 9: como permanecer positivo sobre os falsos positivos

Essas duas imagens mostram os resultados do teste do conjunto em cascata em uma imagem idêntica, mas com parâmetros diferentes. Obviamente, a primeira imagem contém a identificação verdadeira, mas também um número enorme de falsos positivos, enquanto a segunda imagem contém apenas a identificação correta.

O programa cascade_test19.py dentro da pasta Star Identification do repositório GitHub usa dois métodos para classificar os resultados. Em primeiro lugar, a função detectMultiScale define um Miminum e Tamanho máximo do resultado que pode ser encontrado, o que é sensato, como o tamanho aproximado do padrão de estrela alvo dentro da janela (para a lente e ampliação fornecidas - minhas imagens simuladas do Stellarium usam as propriedades de a câmera Raspberry Pi V2) é conhecida. Em segundo lugar, o código selecionará o resultado com a caixa delimitadora maior (dentro dos limites anteriores). Nos testes, descobriu-se que era o verdadeiro positivo. Em terceiro lugar, o programa define um mínimo 'levelWeights' (efetivamente 'valor de confiança') que é necessário para tratar este ID como um verdadeiro positivo. Por este método, as cascatas foram eficazes em encontrar o resultado correto.

Assim como as imagens do campo de estrelas, também testei isso com fotos da minha mesa, por exemplo, cascatas de treinamento para identificar meu caderno, caneca etc., para praticar a eliminação de falsos positivos. Os métodos acima funcionaram bem em todas as circunstâncias, o que foi encorajador.

Etapa 10: Discussão

Áreas para melhoria

Este tem sido um projeto complexo para mim e realmente aumentou minha compreensão do assunto. Foram necessários vários meses de trabalho quase em tempo integral para levar o projeto até o ponto em que posso compartilhá-lo com você, mas há muito mais trabalho a ser feito para melhorar o desempenho do método. Da forma como está, pode funcionar bem dentro de certas restrições. Eu tenho trabalhado para identificar quais áreas estão precisando de trabalho adicional e espero poder dedicar algum tempo tratando delas nos próximos meses. Eles são:

Ângulo - Esta é uma área complexa, a ideia de que os resultados dos classificadores devem ser rotacionalmente invariantes, ou seja, deve-se identificar com confiabilidade o padrão de estrela alvo independente do ângulo em que é apresentada a imagem contendo o padrão de estrela alvo. Uma cascata treinada usando uma imagem de entrada em uma única orientação não será capaz de identificar essa imagem em orientações aleatórias, portanto, a variação do ângulo positivo da imagem deve ser introduzida no processo de treinamento para treinar cascatas que podem aceitar um intervalo de ângulos de entrada. O parâmetro 'maxzangle' nos comandos de treinamento em cascata leva um argumento em radianos, que controla um limite do ângulo em que a imagem positiva de entrada será sobreposta nas imagens negativas fornecidas, de modo que o conjunto de imagens positivas resultante conterá uma gama de orientações de a imagem positiva. No entanto, à medida que esse maxzangle aumenta, a taxa de aceitação (em termos gerais, qualidade) da cascata reduzirá drasticamente. Eu acredito que a solução é treinar cascatas usando um banco de dados significativamente maior de imagens negativas do que o que eu estava usando para garantir que um classificador em cascata de boa qualidade possa ser criado, mesmo incorporando uma grande propagação de orientação.

Outra solução potencial seria treinar várias cascatas para um alvo específico, cada cascata governando uma certa parte de uma rotação completa de 360 graus. Dessa forma, a qualidade de cada cascata pode ser mantida em alto nível, mas por outro lado, isso resultará em muito mais cascatas e, portanto, o processo de identificação será mais lento.

O parâmetro 'levelWeight', que é um valor fornecido pela função 'detectMultiScale', é análogo a um valor de confiança na detecção que foi feita. Estudando isso, foi criado o gráfico acima, que mostra como a confiança da identificação positiva diminui drasticamente à medida que a orientação da imagem aumenta em qualquer direção, confirmando os pensamentos de que este é um ponto fraco.

Posicionamento de pixels - Um ponto muito mais simples, mas também problemático, é o posicionamento de pixels, ilustrado pelas duas imagens a seguir, mostrando uma visão ampliada de uma imagem de estrela, de modo que os pixels individuais de duas estrelas possam ser vistos claramente. O processo de erosão usado no programa para remover todas as estrelas da imagem, exceto as mais brilhantes, manterá a primeira estrela e descartará a segunda, apesar de terem o mesmo brilho. A razão para isso é que a primeira estrela está centrada em um pixel, enquanto a segunda não é assim. A função de erosão retira anéis concêntricos de pixels ao redor do pixel central de um grupo e, portanto, a primeira estrela fará com que o pixel central sobreviva à função de erosão, mas a segunda estrela será completamente removida da imagem. Portanto, os marcadores fiduciais serão colocados apenas na primeira estrela, e não na segunda. Isso causará inconsistências relacionadas a quais estrelas brilhantes em um determinado campo de estrelas receberão marcadores (e, portanto, serão comparadas aos classificadores treinados) - portanto, é possível que uma observação positiva correta não seja possível.

Etapa 11: última palavra

Obrigado por ler meu instrutível, espero que você tenha achado este projeto intrigante. Trabalhar nisso tem sido um processo muito interessante, já se passou mais de um ano desde que comecei a trabalhar no conceito, e estou animado com os resultados até agora. Pela literatura que li, este é um conceito bastante original e, com mais desenvolvimento, certamente pode ser aplicado em uma variedade de aplicações para astronomia amadora ou mais.

Este projeto foi uma grande curva de aprendizado para mim e, portanto, espero que alguns leitores com mais experiência em programação possam se inspirar a contribuir com a continuação do projeto por meio da página do GitHub e que possamos continuar a desenvolver essa ferramenta de código aberto. Estou ansioso para ler quaisquer comentários que você possa ter, mas por favor, não faça muitas perguntas difíceis!

Vice-campeão no desafio espacial