Estrutura de detecção de objetos Darknet e YOLO
!Logotipos Darknet e Hank.ai
Darknet é uma estrutura de rede neural de código aberto escrita em C, C++ e CUDA. YOLO (You Only Look Once) é um sistema de detecção de objetos de última geração em tempo real que roda dentro da estrutura Darknet.
Descubra como Hank.ai está apoiando a comunidade Darknet/YOLO
Explore o site oficial Darknet/YOLO
Consulte as perguntas frequentes abrangentes sobre Darknet/YOLO
Junte-se ao animado servidor Darknet/YOLO Discord
Artigos
1. Artigo YOLOv7
2. Papel em escala YOLOv4
3. Artigo YOLOv4
4. Artigo YOLOv3
Informações gerais
A estrutura Darknet/YOLO continua a ultrapassar os limites do desempenho, fornecendo consistentemente velocidade e precisão, excedendo outras estruturas e versões YOLO. Esta estrutura é totalmente gratuita e de código aberto, permitindo integrar perfeitamente Darknet/YOLO em projetos e produtos existentes, incluindo aplicações comerciais, sem a necessidade de licenciamento ou taxas.
Darknet V3 (“Jazz”), lançado em outubro de 2024, atinge desempenho notável, capaz de processar com precisão vídeos de conjuntos de dados LEGO em até 1000 FPS usando uma GPU NVIDIA RTX 3090. Isso significa que Darknet/YOLO lida com cada quadro de vídeo, incluindo redimensionamento e processamento, em apenas 1 milissegundo ou menos.
Junte-se ao vibrante servidor Darknet/YOLO Discord em https://discord.gg/zSq8rtW para assistência, discussões e para se conectar com outros usuários.
A versão CPU do Darknet/YOLO pode ser executada em diversos dispositivos, incluindo Raspberry Pi, servidores em nuvem e colab, desktops, laptops e equipamentos de treinamento de última geração. A versão GPU do Darknet/YOLO requer uma GPU compatível com CUDA da NVIDIA.
Darknet/YOLO é conhecido por funcionar perfeitamente em Linux, Windows e Mac. Para obter instruções detalhadas, consulte as seções de construção abaixo.
Versão Darknet
1. Versão 0.x: Refere-se à ferramenta Darknet original desenvolvida por Joseph Redmon de 2013 a 2017, que não tinha um número de versão.
2. Versão 1.x: abrange o popular repositório Darknet mantido por Alexey Bochkovskiy entre 2017-2021, também sem um número de versão oficial.
3. Versão 2.x "OAK": Esta versão foi lançada em 2023, patrocinada por Hank.ai e mantida por Stéphane Charette. Foi a primeira vez que o repositório Darknet incorporou um comando de versão.
- O objetivo era minimizar interrupções nas funcionalidades existentes enquanto se familiarizava com a base de código.
- Principais alterações incluídas:
- Sistema de compilação CMake unificado para Windows e Linux
- Conversão de codebase para compilador C++
- Chart.png aprimorado durante o treinamento
- Correções de bugs e otimizações de desempenho, principalmente para redução do tempo de treinamento
- A ramificação final desta base de código foi a versão 2.1 na ramificação v2.
4. Versão 3.x "JAZZ": Esta fase de desenvolvimento começou em meados de 2024 e foi lançada em outubro de 2024. O comando version agora retorna 3.x.
- As alterações nesta versão incluem:
- Remoção de vários comandos desatualizados e sem suporte.
- Otimizações abrangentes de desempenho para treinamento e inferência.
- Modificações na API C legada, exigindo pequenos ajustes para aplicações que utilizam a API Darknet original. A documentação atualizada para a API Darknet V3 C e C++ pode ser encontrada em https://darknetcv.ai/api/api.html.
- Introdução de novas aplicações e exemplos de código no diretório src-examples, acessível em https://darknetcv.ai/api/files.html.
Nota: Para compatibilidade, você sempre pode acessar a ramificação v2 anterior se precisar executar qualquer um desses comandos específicos. Entre em contato conosco se encontrar algum comando ausente e investigaremos sua reintegração.
Pesos pré-treinados MSCOCO
Por conveniência, várias versões populares do YOLO foram pré-treinadas no conjunto de dados MSCOCO. Este conjunto de dados contém 80 classes, que podem ser visualizadas no arquivo de texto cfg/coco.names.
Além do MSCOCO, você pode encontrar outros pesos pré-treinados e conjuntos de dados mais simples para testar Darknet/YOLO, como LEGO Gears e Rolodex. Informações detalhadas podem ser encontradas nas Perguntas frequentes da Darknet/YOLO.
Os pesos pré-treinados do MSCOCO podem ser acessados em vários locais, inclusive neste repositório:
1. YOLOv2 (novembro de 2016)
- yolov2-tiny.pesos
- yolov2-full.weights
2. YOLOv3 (maio de 2018)
- yolov3-tiny.pesos
- yolov3-full.weights
3. YOLOv4 (maio de 2020)
- yolov4-tiny.pesos
- yolov4-full.weights
4. YOLOv7 (agosto de 2022)
- yolov7-tiny.pesos
- yolov7-full.weights
Os pesos pré-treinados da MSCOCO são fornecidos principalmente para fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO estão localizados no diretório cfg.
Comandos de exemplo:
`bash
wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights
darknet02displayannotatedimages coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
`
É essencial compreender que treinar as suas próprias redes é a prática recomendada. MSCOCO é usado principalmente para verificar a operação correta do Darknet/YOLO.
Prédio
Os vários métodos de construção empregados no passado (antes de 2023) foram simplificados em uma solução unificada. Darknet requer C++17 ou mais recente, OpenCV, e utiliza CMake para geração de arquivos de projeto.
Lembre-se de que construir, instalar e executar Darknet/YOLO não requer conhecimento de C++. É como dirigir um carro sem ser mecânico.
Observação: se você estiver se referindo a tutoriais mais antigos com etapas de construção mais complexas ou aqueles que não estão alinhados com este leia-me, prossiga com cuidado. As novas instruções de construção descritas abaixo foram introduzidas em agosto de 2023.
Para obter informações sobre o funcionamento interno da estrutura de detecção de objetos Darknet/YOLO, os desenvolvedores de software são incentivados a visitar https://darknetcv.ai/.
Google Colab
As instruções do Google Colab são idênticas às instruções do Linux. Vários notebooks Jupyter estão disponíveis, demonstrando como realizar tarefas específicas, como treinar uma nova rede.
Explore os blocos de anotações no subdiretório colab ou siga as instruções do Linux fornecidas abaixo.
Método Linux CMake
Tutorial de construção Darknet para Linux
1. Instale dependências:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clonar repositório Darknet:
`bash
mkdir ~/srccd ~/src
clone do git https://github.com/hank-ai/darknet
cd rede escura
`
3. Crie o diretório de construção:
`bash
compilação mkdir buildcd
`
4. Configure usando CMake:
`bash
cmake -DCMAKEBUILDTYPE=Liberar ..
`
5. Construir Darknet:
`bash
faça -j4
`
6. Empacotar e instalar:
`bash
pacote
sudo dpkg -i darknet-VERSION.deb
`
Opcional: instalação CUDA e cuDNN
Para processamento acelerado de imagem e vídeo, você pode instalar opcionalmente CUDA ou CUDA+cuDNN. Darknet aproveitará sua GPU, se disponível.
1. Instale o CUDA:
- Baixe e instale o CUDA em https://developer.nvidia.com/cuda-downloads.
- Certifique-se de poder executar nvcc e nvidia-smi. Pode ser necessário modificar sua variável PATH.
2. Instale o cuDNN:
- Baixe e instale o cuDNN em https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager- visão geral da instalação.
Se você instalar CUDA ou CUDA+cuDNN após a configuração inicial ou atualizar o software NVIDIA:
1. Exclua CMakeCache.txt:
- Remova o arquivo CMakeCache.txt do diretório de compilação Darknet para forçar o CMake a redescobrir todas as dependências.
2. Reconstrua Darknet:
- Repita o cmake e faça os passos acima.
Nota: Estas instruções assumem o Ubuntu 22.04, mas podem ser adaptadas para outras distribuições.
Usuários avançados:
Para criar um arquivo de instalação RPM em vez de um arquivo DEB, modifique as linhas relevantes em CM_package.cmake. Antes de executar o pacote make -j4, atualize estas duas linhas:
`cmake
DEFINIR (CPACK_GENERATOR "DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Para distribuições como Centos e OpenSUSE, ajuste as linhas para:
`cmake
DEFINIR (CPACK_GENERATOR "DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Após a compilação, instale o pacote usando o gerenciador de pacotes da sua distribuição. Por exemplo, em sistemas baseados em Debian:
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Resultado da instalação:
/usr/bin/darknet: O executável padrão do Darknet. Execute a versão darknet para verificar a instalação correta.
/usr/include/darknet.h: A API Darknet para desenvolvedores C, C++ e Python.
/usr/include/darknet_version.h: Contém informações de versão para desenvolvedores.
/usr/lib/libdarknet.so: Biblioteca para vincular projetos C, C++ e Python.
/opt/darknet/cfg/...: Local para todos os modelos .cfg.
Confirmação: Execute a versão darknet em seu terminal para confirmar a instalação bem-sucedida do Darknet.
Método CMake do Windows
Instruções de compilação do Windows (assume Windows 11 22H2)
1. Instale dependências:
`bash
winget instalar Git.Git
winget instalar Kitware.CMake
winget instalar nsis.nsis
instalar winget Microsoft.VisualStudio.2022.Community
`
2. Modifique a instalação do Visual Studio:
- Abra o menu “Iniciar do Windows” e execute o “Visual Studio Installer”.
- Clique em “Modificar”.
- Selecione "Desenvolvimento Desktop com C++".
- Clique em “Modificar” no canto inferior direito e depois em “Sim”.
3. Abra o prompt de comando do desenvolvedor:
- Abra o menu “Iniciar do Windows” e selecione “Prompt de comando do desenvolvedor para VS 2022”. Não use o PowerShell para estas etapas.
4. Instale o Microsoft VCPKG:
`bash
CDC:
mkdir c:srccd c:src
clone do git https://github.com/microsoft/vcpkg
CD vcpkg
bootstrap-vcpkg.bat
.vcpkg.exe integrar instalação
.vcpkg.exe integrar powershell.vcpkg.exe instalar opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
5. Opcional: Instalação CUDA e cuDNN:
- Instale CUDA ou CUDA+cuDNN para aceleração de GPU.
- Siga os mesmos passos das instruções do Linux.
6. Clone Darknet e construa:
`bash
cd c:src
clone do git https://github.com/hank-ai/darknet.git
cd rede escura
compilação mkdir
compilação de CD
cmake -DCMAKEBUILDTYPE=Liberar -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
Se você encontrar erros sobre DLLs CUDA ou cuDNN ausentes (por exemplo, cublas64_12.dll):
1. Copie DLLs CUDA:
- Copie manualmente os arquivos CUDA .dll para o mesmo diretório de saída do Darknet.exe. Por exemplo:
`bash
copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
2. Execute novamente msbuild.exe:
- Execute novamente o último comando msbuild.exe para gerar o pacote de instalação do NSIS.
Usuários avançados:
Em vez do prompt de comando do desenvolvedor, você pode usar um prompt de comando normal ou SSH e executar "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".
O comando cmake gera um arquivo de solução do Visual Studio (Darknet.sln). Se preferir usar a GUI do Visual Studio, carregue o projeto em vez de depender de ferramentas de linha de comando.
Confirmação: Execute a versão C:srcDarknetbuildsrc-cliReleasedarknet.exe para verificar a instalação.
Instale usando o assistente NSIS:
Execute o assistente de instalação do NSIS encontrado no diretório de construção (por exemplo, darknet-VERSION.exe). Isto irá:
- Crie um diretório Darknet (por exemplo, C:Program FilesDarknet).
- Instale o aplicativo CLI, darknet.exe e outros aplicativos de amostra.
- Instale os arquivos .dll de terceiros necessários (por exemplo, do OpenCV).
- Instale arquivos Darknet .dll, .lib e .h para uso em outros aplicativos.
- Instale arquivos .cfg de modelo.
Confirmação: Após a instalação, execute a versão C:Program FilesDarknetbindarknet.exe para confirmar que o Darknet está pronto.
Usando Darknet
CLI
A seguir está uma lista parcial de comandos suportados pelo Darknet.
Além da CLI Darknet, considere a CLI do projeto DarkHelp, que oferece uma CLI alternativa com recursos avançados não disponíveis diretamente na Darknet. Você pode usar as duas CLIs juntas.
Para a maioria dos comandos, você precisará do arquivo .weights junto com seus arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado) ou baixar redes pré-treinadas disponíveis gratuitamente online. Os exemplos incluem:
LEGO Gears (detecção de objetos em imagens)
Rolodex (detecção de texto em imagens)
MSCOCO (detecção de objetos padrão de classe 80)
Comandos CLI Darknet comuns:
1. Obtenha ajuda:
`bash
ajuda darknet
`
2. Verifique a versão:
`bash
versão darknet
`
3. Previsão de imagem:
-V2:
`bash
teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg
`
-V3:
`bash
darknet02displayannotatedimages cars.cfg image1.jpg
`
- DarkHelp:
`bash
DarkHelp carros.cfg carros.cfg carros_best.weights image1.jpg
`
4. Coordenadas de saída:
- V2:
`bash
teste de detector darknet animais.dados animais.cfg animaisbest.weights -extoutput dog.jpg
`
-V3:
`bash
darknet01inference_images animais cachorro.jpg
`
- DarkHelp:
`bash
DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg
`
5. Processamento de vídeo:
-V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights -extoutput test.mp4
`
-V3:
`bash
darknet03display_videos animais.cfg teste.mp4
`
- DarkHelp:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
6. Entrada da webcam:
- V2:
`bash
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
`
-V3:
`bash
darknet08display_webcam animais
`
7. Salve os resultados do vídeo:
- V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test.mp4 -outfilename res.avi
`
-V3:
`bash
darknet05processvideosanimais multithreaded.cfg animais.nomes animais_best.teste de pesos.mp4
`
- DarkHelp:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
8. Saída JSON:
-V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
`
-V3:
`bash
darknet06imagestojson animais imagem1.jpg
`
- DarkHelp:
`bash
DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg
`
9. Seleção de GPU:
-V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4
`
10. Avaliação de precisão da rede:
- Calcular mAP:
`bash
mapa do detector darknet driving.data driving.cfg driving_best.weights ...
`
- Informações detalhadas de precisão:
`bash
Id Nome AvgPrecision TP FN FP TN Precisão ErrorRate Precisão Recall Especificidade FalsePosRate -- ---- ------------ ------ ------ ------ - ----- -------- --------- --------- ------ ----------- -- ---------- 0 veículo 91.2495 32648 3903 5826 65129 0,9095 0,0905 0,8486 0,8932 0,9179 0,0821 1 motocicleta 80,4499 2936 513 569 5393 0,8850 0,1150 0,8377 0,8513 0,9046 0,0954 2 bicicletas 89,0912 570 124 104 3548 0,9475 0,0525 0,8457 0,8213 0,9715 0,0285 3 pessoas 76,7937 7072 1727 2574 27523 0,8894 0,1106 0,7332 0,8037 0,9145 0,0855 4 muitos veículos 64,3089 1068 509 733 11288 0,9087 0,0913 0,5930 0,6772 0,9390 0,0610 5 sinal verde 86,8118 1969 239 510 4116 0,8904 0,1096 0,7943 0,8918 0,8898 0,1102 6 luz amarela 82,0390 126 38 30 1239 0,9525 0,0475 0,8077 0,7683 0,9764 0,0236 7 luz vermelha 94,1033 3449 217 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885
`
- Calcular mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
- Calcular âncoras:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
11. Treine uma nova rede:
`bash
detector darknet -map -dont_show trem animais.data animais.cfg
`
Treinamento
Links essenciais para as perguntas frequentes do Darknet/YOLO:
Configurando arquivos e diretórios
Escolhendo o arquivo de configuração correto
Treinando um comando de rede personalizado
Para anotação e treinamento contínuos, o DarkMark simplifica o processo criando automaticamente todos os arquivos Darknet necessários. O uso do DarkMark é altamente recomendado para treinar uma nova rede neural.
Configuração manual de treinamento:
1. Crie um diretório de projeto:
- Por exemplo, crie um diretório chamado ~/nn/animals/ para detectar animais.
2. Copie o arquivo de configuração:
- Copie um arquivo de configuração Darknet adequado como modelo (por exemplo, cfg/yolov4-tiny.cfg) no diretório do seu projeto. Isso cria ~/nn/animals/animals.cfg.
3. Crie o arquivo pets.names:
- Crie um arquivo de texto chamado pets.names no mesmo diretório.
- Liste as aulas desejadas, uma por linha, sem linhas em branco ou comentários. Por exemplo:
`
cachorro
gato
pássaro
cavalo
`
4. Crie o arquivo pets.data:
- Crie um arquivo de texto chamado animais.data. O conteúdo deve ser:
`
aulas = 4
trem = /home/nomedeusuário/nn/animais/animals_train.txt
válido = /home/nomedeusuário/nn/animals/animals_valid.txt
nomes = /home/nomedeusuário/nn/animais/animais.nomes
backup = /home/nomedeusuário/nn/animais
`
5. Crie o diretório do conjunto de dados:
- Crie um diretório (por exemplo, ~/nn/animals/dataset) para armazenar imagens e anotações. Cada imagem requer um arquivo .txt correspondente definindo suas anotações. O formato é específico e não pode ser criado manualmente. Use DarkMark ou software similar para anotar imagens. O formato de anotação YOLO é explicado nas Perguntas frequentes do Darknet/YOLO.
6. Crie arquivos de treinamento e validação:
- Crie os arquivos Animalstrain.txt e Animalsvalid.txt mencionados no arquivo .data. Esses arquivos listam todas as imagens para treinamento e validação, respectivamente, uma imagem por linha. Os caminhos podem ser relativos ou absolutos.
7. Configure o arquivo .cfg:
- Abra seu arquivo .cfg com um editor de texto.
- Certifique-se de lote=64.
- Ajuste as subdivisões com base nas dimensões da rede e na memória da GPU. Comece com subdivisões=1. Consulte o FAQ Darknet/YOLO para valores alternativos.
- Defina max_batches como 2.000 * número de classes (por exemplo, 8.000 para 4 classes).
- Defina etapas para 80% e 90% de maxbatches (por exemplo, 6400,7200 para maxbatches=8000).
- Configure a largura e a altura (dimensões da rede) usando as diretrizes do Darknet/YOLO FAQ.
- Substitua classes=... pelo número de classes do seu arquivo .names (por exemplo, classes=4).
- Modifique filter=... na seção [convolutional] antes de cada seção [yolo]. Use a fórmula (número de classes + 5) * 3 (por exemplo, filtros=27 para 4 classes).
8. Comece o treinamento:
- Navegue até o diretório do seu projeto:
`bash
cd ~/nn/animais/
`
- Execute o comando de treinamento:
`bash
detector darknet -map -dont_show trem animais.data animais.cfg
`
9. Monitore o progresso:
- Os melhores pesos serão salvos como Animals_best.weights.
- Acompanhe o progresso do treinamento visualizando o arquivo chart.png.
- Consulte as perguntas frequentes do Darknet/YOLO para parâmetros de treinamento adicionais.
10. Treinamento detalhado:
- Para resultados mais detalhados durante o treinamento, inclua o parâmetro --verbose:
`bash
detector darknet -map -dont_show --verbose trem animais.data animais.cfg
`
Outras ferramentas e links
DarkMark: Para gerenciar projetos Darknet/YOLO, anotar imagens, verificar anotações e gerar arquivos de treinamento.
DarkHelp: Fornece uma CLI alternativa robusta para Darknet, agrupamento de imagens, rastreamento de objetos em vídeos e uma API C++ abrangente para aplicações comerciais.
Darknet/YOLO FAQ: Um recurso valioso para responder às suas perguntas.
Canal de Stéphane no YouTube: vários tutoriais e vídeos de exemplo.
Darknet/YOLO Discord Server: Junte-se à comunidade para suporte e discussões.
Roteiro
Última atualização: 30/10/2024
Concluído:
Substituído qsort() por std::sort() durante o treinamento (exceto em alguns casos restantes).
Check_mistakes, getchar() e system() foram removidos.
Darknet convertido para usar o compilador C++ (g++ no Linux, VisualStudio no Windows).
Versão corrigida do Windows.
Suporte Python ativado.
Construiu a biblioteca Darknet.
Rótulos de previsão reativados (usando código "alfabeto").
Código CUDA/GPU reativado.
CUDNN e metade CUDNN reativados.
Arquitetura CUDA codificada removida.
Informações aprimoradas sobre a versão CUDA.
AVX reativado.
Removidas soluções antigas e Makefile.
Tornou o OpenCV não opcional.
Removida a dependência da antiga biblioteca pthread.
STB removido.
CMakeLists.txt reescrito para nova detecção de CUDA.
Removido o antigo código do "alfabeto" e excluído mais de 700 imagens em dados/rótulos.
Construção fora da fonte habilitada.
Saída de número de versão aprimorada.
Implementei otimizações de desempenho durante o treinamento (em andamento).
Implementadas otimizações de desempenho durante a inferência (em andamento).
Empregado passagem por referência sempre que possível.
Arquivos .hpp limpos.
Darknet.h reescrito.
Evitou lançar cv::Mat para void* e usou-o como um objeto C++ adequado.
Corrigido o uso inconsistente da estrutura interna da imagem.
Corrigidos problemas de compilação para dispositivos Jetson baseados em ARM (exceto para modelos Jetson originais não suportados).
Os dispositivos Jetson Orin estão funcionais.
Corrigida a API Python na V3.
Suporte aprimorado a Python (buscando a contribuição de desenvolvedores de Python).
Metas de curto prazo:
Substitua printf() por std::cout (em andamento).
Revisite o suporte para câmeras Zed antigas.
Melhore e garanta consistência na análise de linha de comando (em andamento).
Metas de médio prazo:
Elimine todo o código char* e substitua por std::string.
Exibir avisos e abordar avisos do compilador (em andamento).
Otimize o uso de cv::Mat em vez da estrutura de imagem C personalizada (em andamento).
Substitua a funcionalidade de lista antiga por std::vector ou std::list.
Correção do suporte para imagens em tons de cinza de 1 canal.
Adicione suporte para imagens de canal N (N > 3).
Continue a limpeza contínua do código (em andamento).
Metas de longo prazo:
Resolva problemas de CUDA/CUDNN em todas as GPUs.
Reescreva o código CUDA + cuDNN.
Explore o suporte para GPUs não NVIDIA.
Implemente caixas delimitadoras giradas ou suporte de "ângulo".
Adicione pontos-chave/esqueletos.
Implementar mapas de calor (em andamento).
Introduzir funcionalidade de segmentação.
