HmacManager

HmacManager

Resumo

O editor de Downcodes traz para você o HmacManager, uma ferramenta de autenticação HMAC para aplicativos ASP.NET Core, fornecendo integração perfeita e forte segurança para seus aplicativos.

Características

Autenticação HMAC: HmacManager fornece autenticação HMAC, permitindo adicionar uma camada de autenticação segura à sua API ASP.NET Core.

Configuração fácil: com opções de configuração simples, você pode integrar rapidamente a autenticação HMAC em seus aplicativos.

Opções de personalização: HmacManager oferece opções de personalização para que você possa configurá-lo de acordo com suas necessidades.

Segurança aprimorada: a autenticação HMAC aprimora a segurança de sua API usando o algoritmo de hash HMAC para autenticar solicitações.

Instalação

HmacManager está disponível no NuGet.

`bash

dotnet adicionar pacote HmacManager

`

Recursos

Leitura adicional: Documentação oficial

Código de exemplo: repositório GitHub

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 avançado de detecção de alvos em tempo real executado na estrutura Darknet.

1. Artigos

YOLOv7: Link do artigo

Scaled-YOLOv4: link de papel

YOLOv4: link do artigo

YOLOv3: link do artigo

2. Informações Gerais

A estrutura Darknet/YOLO continua a superar outras estruturas e versões YOLO em velocidade e precisão.

A estrutura é totalmente gratuita e de código aberto. Você pode integrar Darknet/YOLO em projetos e produtos existentes, incluindo produtos comerciais, sem licenciamento ou taxas.

Darknet V3 ("Jazz"), lançado em outubro de 2024, pode executar com precisão vídeos de conjuntos de dados LEGO em até 1000 FPS ao usar uma GPU NVIDIA RTX 3090, o que significa que cada quadro de vídeo leva 1 milissegundo ou menos para ser lido, redimensionado e processado pelo Darknet. /YOLO em segundos.

Junte-se ao servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW

A versão CPU do Darknet/YOLO pode ser executada em dispositivos simples, como Raspberry Pi, servidores em nuvem, servidores Colab, desktops, laptops e equipamentos de treinamento de última geração. A versão GPU do Darknet/YOLO requer uma GPU com suporte NVIDIA CUDA.

Darknet/YOLO é conhecido por funcionar bem em Linux, Windows e Mac. Veja as instruções de construção abaixo.

3. Versão Darknet

Versão 0.x: A ferramenta Darknet original escrita por Joseph Redmon em 2013-2017 não tem número de versão.

Versão 1.x: O próximo repositório Darknet popular mantido por Alexey Bochkovskiy entre 2017-2021 também não tem número de versão.

Versão 2.x ("OAK"): O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette desde 2023 é o primeiro a ter um comando de versão. De 2023 até o final de 2024, retorna para a versão 2.x “OAK”.

Versão 3.x (“JAZZ”): Próxima fase de desenvolvimento começando em meados de 2024, com lançamento em outubro de 2024. O comando version agora retorna 3.x "JAZZ".

4. Pesos pré-treino MSCOCO

Por conveniência, várias versões populares do YOLO são pré-treinadas no conjunto de dados MSCOCO. Este conjunto de dados contém 80 categorias e pode ser visto no arquivo de texto cfg/coco.names.

Existem outros conjuntos de dados mais simples e pesos pré-treinados disponíveis para testar Darknet/YOLO, como LEGO Gears e Rolodex. Consulte as perguntas frequentes do Darknet/YOLO para obter detalhes.

Os pesos pré-treinados do MSCOCO podem ser baixados de vários locais diferentes ou deste repositório:

* YOLOv2 (novembro de 2016)

*YOLOv2-tiny

*YOLOv2-completo

* YOLOv3 (maio de 2018)

* YOLOv3-tiny

*YOLOv3-completo

* YOLOv4 (maio de 2020)

* YOLOv4-tiny

*YOLOv4-completo

* YOLOv7 (agosto de 2022)

* YOLOv7-tiny

*YOLOv7-completo

Os pesos pré-treinados da MSCOCO são apenas para fins de demonstração. Os arquivos .cfg e .names correspondentes estão localizados no diretório cfg. Comando 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

`

Observe que deve-se treinar sua própria rede. MSCOCO é frequentemente usado para confirmar se está tudo bem.

5. Construir

Vários métodos de construção do passado (pré-2023) foram fundidos numa solução unificada. Darknet requer C++17 ou superior, OpenCV e uso de CMake para gerar os arquivos de projeto necessários.

Você não precisa saber C++ para construir, instalar ou executar Darknet/YOLO, assim como não precisa ser mecânico para dirigir um carro.

5.1 Google Colab

As instruções do Google Colab são iguais às instruções do Linux. Vários notebooks Jupyter mostram como realizar determinadas tarefas, como treinar uma nova rede.

Consulte o notebook no subdiretório colab ou siga as instruções do Linux abaixo.

5.2 Método Linux CMake

Tutorial de construção Darknet no Linux

`bash

sudo apt-get install build-essential git libopencv-dev cmake mkdir ~/srccd ~/src git clone https://github.com/hank-ai/darknetcd darknet mkdir buildcd build cmake -DCMAKEBUILDTYPE=Release .. make -j4 package sudo dpkg -i darknet-VERSION.deb

`

5.3 Método CMake do Windows

Estas instruções pressupõem uma nova instalação do Windows 11 22H2.

`bash

winget instalar Git.Git winget instalar Kitware.CMake winget instalar nsis.nsis winget instalar Microsoft.VisualStudio.2022.Community

`

Em seguida, precisamos modificar a instalação do Visual Studio para incluir suporte para aplicativos C++:

* Clique no menu Iniciar do Windows e execute o instalador do Visual Studio.

* Clique em "Editar".

* Selecione "Desenvolvimento desktop usando C++".

* Clique em “Editar” no canto inferior direito e depois clique em “Sim”.

Depois que tudo for baixado e instalado, clique novamente no menu “Iniciar do Windows” e selecione “Prompt de comando do desenvolvedor para VS 2022”. Não use o PowerShell para executar essas etapas ou você terá problemas!

Usuários avançados:

* Além de executar o prompt de comando do desenvolvedor, você também pode usar um prompt de comando normal ou ssh para o dispositivo e executar manualmente "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".

Depois de seguir as instruções acima e executar o prompt de comando do desenvolvedor (não o PowerShell!), Execute o seguinte comando para instalar o Microsoft VCPKG, que será usado para construir o OpenCV:

`bash

cd c: mkdir c: srccd c: src git clone https://github.com/microsoft/vcpkgcd 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

`

Seja paciente com esta última etapa, pois ela leva muito tempo para ser executada. Requer baixar e construir muitas coisas.

Usuários avançados:

* Observe que existem muitos outros módulos opcionais que você pode querer adicionar ao construir o OpenCV. Execute .vcpkg.exe e pesquise opencv para ver a lista completa.

Opcional: se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN neste momento. Se instalado, o Darknet usará sua GPU para acelerar o processamento de imagens (e vídeos).

Você deve excluir o arquivo CMakeCache.txt do diretório de construção Darknet para forçar o CMake a reencontrar todos os arquivos necessários.

Lembre-se de reconstruir o Darknet.

Darknet pode funcionar sem ele, mas se você quiser treinar uma rede personalizada, você precisa de CUDA ou CUDA+cuDNN.

Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.

Visite https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview para fazer download e instale o cuDNN.

Depois de instalar o CUDA, certifique-se de executar nvcc.exe e nvidia-smi.exe. Pode ser necessário modificar a variável PATH.

Após baixar o cuDNN, descompacte-o e copie os diretórios bin, include e lib para C:/Arquivos de Programas/NVIDIA GPU Computing Toolkit/CUDA/[versão]/. Pode ser necessário substituir alguns arquivos.

Se você instalar CUDA ou CUDA+cuDNN posteriormente ou se atualizar para uma versão mais recente do software NVIDIA:

* CUDA deve ser instalado após o Visual Studio. Se você atualizar o Visual Studio, lembre-se de reinstalar o CUDA.

Depois que todas as etapas anteriores forem concluídas com sucesso, você precisará clonar o Darknet e construí-lo. Nesta etapa também precisamos informar ao CMake onde o vcpkg está localizado para que ele possa encontrar o OpenCV e outras dependências:

`bash

cd c:src git clone https://github.com/hank-ai/darknet.gitcd darknetmkdir buildcd build cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake .. msbuild. exe /property:Platform=x64;Configuration=Liberar /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj

`

Se você encontrar erros sobre alguma DLL CUDA ou cuDNN ausente (por exemplo, cublas64_12.dll), copie manualmente o arquivo CUDA .dll para o mesmo diretório de saída que Darknet.exe. Por exemplo:

`bash

copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease

`

(Aqui está um exemplo! Verifique qual versão você está executando e execute o comando apropriado para a versão que você instalou.)

Depois que os arquivos forem copiados, execute novamente o último comando msbuild.exe para gerar o pacote de instalação do NSIS:

`bash

msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj

`

Usuários avançados:

* Observe que a saída do comando cmake é o arquivo de solução normal do Visual Studio, Darknet.sln. Se você for um desenvolvedor de software que usa frequentemente a GUI do Visual Studio em vez de msbuild.exe para criar projetos, poderá ignorar a linha de comando e carregar o projeto Darknet no Visual Studio.

Agora você deve ter este arquivo pronto para ser executado: C: srcDarknetbuildsrc-cliReleasedarknet.exe. Execute o seguinte comando para testar: Versão C:srcDarknetbuildsrc-cliReleasedarknet.exe.

Para instalar corretamente Darknet, bibliotecas, incluir arquivos e DLLs necessárias, execute o assistente de instalação NSIS criado na etapa anterior. Veja o arquivo darknet-VERSION.exe no diretório de construção. Por exemplo:

`bash

darknet-2.0.31-win64.exe

`

A instalação do pacote de instalação NSIS irá:

* Crie um diretório chamado 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, como os do OpenCV.

* Instale os arquivos Darknet .dll, .lib e .h necessários para usar darknet.dll de outros aplicativos.

* Instale o arquivo .cfg do modelo.

Você terminou agora! Após a conclusão do assistente de instalação, Darknet será instalado em C:Program FilesDarknet. Execute o seguinte comando para testar: Versão C:Program FilesDarknetbindarknet.exe.

Se você não possui C:/Program Files/darknet/bin/darknet.exe, você não o instalou, apenas o construiu! Certifique-se de navegar em cada painel do Assistente de Instalação NSIS na etapa anterior.

6. Use Darknet

6.1CLI

A seguir não está uma lista completa de todos os comandos suportados pelo Darknet.

Além da CLI Darknet, observe também a CLI do projeto DarkHelp, que fornece uma alternativa à CLI Darknet/YOLO. DarkHelp CLI também possui algumas melhorias não encontradas no Darknet. Você pode usar o Darknet CLI e o DarkHelp CLI juntos, eles não são mutuamente exclusivos.

Para a maioria dos comandos mostrados abaixo, você precisará de um arquivo .weights com os arquivos .names e .cfg correspondentes. Você mesmo pode treinar a rede (altamente recomendado!) Ou pode baixar redes neurais que foram treinadas por outras pessoas e estão disponíveis gratuitamente na Internet. Exemplos de conjuntos de dados de pré-treinamento incluem:

* LEGO Gears (encontre objetos nas imagens)

* Rolodex (encontre texto na imagem)

* MSCOCO (detecção de alvo padrão de 80 categorias)

Os comandos a serem executados incluem:

* Liste alguns comandos e opções possíveis que podem ser executados:

`bash

ajuda darknet

`

*Verifique a versão:

`bash

versão darknet

`

* Use imagens para previsão:

`bash

V2: teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg

V3: darknet02displayannotatedimages cars.cfg image1.jpg

DarkHelp: DarkHelp cars.cfg cars_best.weights image1.jpg

`

* Coordenadas de saída:

`bash

V2: teste de detector darknet Animals.data Animals.cfg Animalsbest.weights -extoutput dog.jpg

V3: darknet01inference_images animais cachorro.jpg

DarkHelp: DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg

`

*Usar vídeo:

`bash

V2: demonstração do detector darknet animais.dados animais.cfg animaisbest.weights -extoutput test.mp4

V3: darknet03display_videos animais.cfg teste.mp4

DarkHelp: DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4

`

* Leitura da webcam:

`bash

V2: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0

V3: animais darknet08display_webcam

`

* Salve os resultados em vídeo:

`bash

V2: demonstração do detector darknet animais.dados animais.cfg animaismelhores.pesos teste.mp4 -outfilename res.avi

V3: darknet05processvideosanimais multithreaded.cfg animais.nomes animais_best.teste de pesos.mp4

DarkHelp: DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4

`

*JSON:

`bash

V2: demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput

V3: darknet06imagestojson animais image1.jpg

DarkHelp: DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg

`

* Execute em GPUs específicas:

`bash

V2: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -i 1 test.mp4

`

* Verifique a precisão da rede neural:

`bash

mapa do detector darknet driving.data driving.cfg driving_best.weights ... 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

`

* Verifique a precisão mAP@IoU=75:

`bash

mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75

`

* O recálculo dos pontos de ancoragem é melhor feito no DarkMark, pois ele será executado 100 vezes seguidas e selecionará o melhor ponto de ancoragem de todos os pontos de ancoragem calculados. No entanto, se você deseja executar uma versão mais antiga no Darknet:

`bash

detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256

`

* Treine nova rede:

`bash

cd ~/nn/animals/ detector darknet -map -dont_show trem animais.data animais.cfg

`

6.2 Treinamento

Links rápidos para partes relevantes do FAQ Darknet/YOLO:

* Como devo configurar meus arquivos e diretórios?

*Qual perfil devo usar?

* Qual comando devo usar ao treinar minha própria rede?

Crie todos os arquivos Darknet necessários usando DarkMark, que é a maneira mais fácil de anotar e treinar. Esta é definitivamente a forma recomendada para treinar novas redes neurais.

Se desejar configurar manualmente os vários arquivos para treinar uma rede personalizada:

* Crie uma nova pasta para armazenar os arquivos. Para este exemplo, será criada uma rede neural para detectar animais, então será criado o seguinte diretório: ~/nn/animals/.

* Copie um dos arquivos de configuração Darknet que deseja usar como modelo. Por exemplo, consulte cfg/yolov4-tiny.cfg. Coloque-o na pasta que você criou. Para este exemplo, agora temos ~/nn/animals/animals.cfg.

* Crie um arquivo de texto Animals.names na mesma pasta onde você colocou o arquivo de configuração. Para este exemplo, agora temos ~/nn/animals/animals.names.

* Use um editor de texto para editar o arquivo pets.names. Liste as categorias que deseja usar. Você precisa exatamente de uma entrada por linha, sem linhas em branco e sem comentários. Neste exemplo, o arquivo .names conterá exatamente 4 linhas:

`

cachorro

gato

pássaro

cavalo

`

* Crie um arquivo de texto Animals.data na mesma pasta. Para este exemplo, o arquivo .data conterá:

`

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

`

* Crie uma pasta para armazenar suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset. Cada imagem requer um arquivo .txt correspondente que descreve as anotações dessa imagem. O formato dos arquivos de comentários .txt é muito específico. Você não pode criar esses arquivos manualmente porque cada anotação precisa conter as coordenadas precisas da anotação. Consulte DarkMark ou outro software semelhante para fazer anotações em suas imagens. O formato de anotação YOLO é descrito nas Perguntas frequentes do Darknet/YOLO.

* Crie arquivos de texto "treinados" e "válidos" nomeados no arquivo .data. Esses dois arquivos de texto precisam listar separadamente todas as imagens que Darknet deve usar para treinar e validar ao calcular o mAP%. Exatamente uma imagem por linha. Caminhos e nomes de arquivos podem ser relativos ou absolutos.

* Use um editor de texto para modificar seu arquivo .cfg.

* Certifique-se de lote=64.

* Preste atenção às subdivisões. Dependendo do tamanho da rede e da quantidade de memória disponível na GPU, pode ser necessário aumentar as subdivisões. O melhor valor a ser usado é 1, então comece com ele. Se você não conseguir usar 1, consulte as Perguntas frequentes do Darknet/YOLO.

Observe que maxbatches=…. Um bom valor para começar é 2.000 vezes o número de categorias. Neste exemplo temos 4 animais, então 4 2.000 = 8.000. Isso significa que usaremos maxbatches=8000.

* Nota passos =..... Isso deve ser definido como 80% e 90% de maxbatches. Para este exemplo, usaremos steps=6400,7200 já que maxbatches está definido como 8000.

* Observe largura=... e altura=..... Estas são dimensões de rede. O FAQ Darknet/YOLO explica como calcular o tamanho ideal a ser usado.

* Pesquise todas as instâncias das linhas classes=... e modifique-as com o número de classes no arquivo .names. Para este exemplo usaremos classes=4.

Pesquisa instâncias de todas as linhas filter=... na seção [convolutional] antes de cada seção [yolo]. O valor a ser usado é (número de categorias + 5) 3. Isso significa que, para este exemplo, (4 + 5) * 3 = 27. Portanto, usaremos filter=27 na linha correspondente.

* Comece a treinar! Execute o seguinte comando:

`bash

cd ~/nn/animals/ detector darknet -map -dont_show trem animais.data animais.cfg

`

* Por favor, aguarde. Os melhores pesos serão salvos como Animals_best.weights. E você pode observar o andamento do treinamento visualizando o arquivo chart.png. Consulte o FAQ Darknet/YOLO para parâmetros adicionais que você pode querer usar ao treinar uma nova rede.

* Se quiser ver mais detalhes durante o treinamento, adicione o parâmetro --verbose. Por exemplo:

`bash

detector darknet -map -dont_show --verbose trem animais.data animais.cfg

`

7. Outras ferramentas e links

Para gerenciar seu projeto Darknet/YOLO, anotar imagens, validar suas anotações e gerar os arquivos necessários para treinamento com Darknet, consulte DarkMark.

Para obter uma alternativa poderosa à Darknet CLI, para usar imagens lado a lado, rastreamento de objetos em vídeo ou para obter uma API C++ poderosa que pode ser facilmente usada em aplicativos comerciais, consulte DarkHelp.

Consulte as Perguntas frequentes do Darknet/YOLO para obter ajuda para responder às suas perguntas.

Confira os diversos tutoriais e vídeos de exemplo no canal de Stéphane no YouTube.

Se você tiver dúvidas de suporte ou quiser conversar com outros usuários Darknet/YOLO, entre no servidor Darknet/YOLO Discord.

8. Roteiro

Última atualização em 30/10/2024:

* Concluído

* Substituído qsort() por std::sort() durante o treinamento (algum outro código obscuro ainda existe)

* Livre-se de check_mistakes, getchar() e system()

* Converta Darknet para usar um compilador C++ (g++ no Linux, VisualStudio no Windows)

* Corrigir compilação do Windows

* Corrigir suporte a Python

* Construir biblioteca darknet

* Reative os rótulos nas previsões (código "alfabeto")

* Reative o código CUDA/GPU

* Reative o CUDNN

* Reative a metade CUDNN

* Não codifique a arquitetura CUDA

* Melhores informações sobre a versão CUDA

* Reative o AVX

* Remova a solução antiga e o Makefile

* Torne o OpenCV não opcional

* Remova a dependência da antiga biblioteca pthread

* Excluir STB

* Reescreva CMakeLists.txt para usar a nova detecção CUDA

* Removido o antigo código do "alfabeto" e excluído mais de 700 imagens em dados/rótulos

*Construir código-fonte externo

* Possui melhor saída de número de versão

* Otimização de desempenho relacionada ao treinamento (tarefa em andamento)

* Otimização de desempenho relacionada à inferência (tarefa em andamento)

* Use referências de passagem por valor sempre que possível

* Limpe arquivos .hpp

* Reescrever darknet.h

Não lance cv::Mat para void, use-o como um objeto C++ adequado

* Corrija ou mantenha o uso consistente de estruturas internas de imagem

* Corrigir a construção do dispositivo Jetson com arquitetura ARM

*É improvável que os dispositivos Jetson originais sejam consertados, pois não são mais suportados pela NVIDIA (sem compilador C++17)

* Novo dispositivo Jetson Orin agora em execução

* Corrigir API Python na V3

* Precisa de melhor suporte para Python (algum desenvolvedor de Python quer ajudar?)

* Metas de curto prazo

* Substitua printf() por std::cout (trabalho em andamento)

* Confira o suporte para câmeras Zed antigas

* Análise de linha de comando melhor e mais consistente (trabalho em andamento)

* Metas de médio prazo

Remova todos os códigos de caracteres e substitua por std::string

* Não esconda avisos e limpe os avisos do compilador (trabalho em andamento)

* Melhor uso de cv::Mat em vez de estruturas de imagem personalizadas em C (trabalho em andamento)

* Substitua a funcionalidade de lista antiga por std::vector ou std::list

* Corrigido suporte para imagens em tons de cinza de 1 canal

* Adicionado suporte para imagens de canais N onde N > 3 (por exemplo, imagens com profundidade extra ou canais quentes)

* Limpeza contínua de código (em andamento)

* Metas de longo prazo

* Corrija problemas de CUDA/CUDNN em todas as GPUs

* Reescreva o código CUDA + cuDNN

* Considere adicionar suporte para GPUs que não sejam NVIDIA

* Caixa delimitadora girada ou alguma forma de suporte de "ângulo"

*Pontos-chave/esqueleto

* Mapa de calor (trabalho em andamento)

* Dividir