Limite adaptável OpenCV em Python com cv2.adaptiveThreshold()

Introdução

Thresholding é uma técnica simples e eficiente para realizar a segmentação básica em uma imagem e binarizá-la (transformá-la em uma imagem binária) onde os pixels são 0 or 1 (ou 255 se você estiver usando números inteiros para representá-los).

Normalmente, você pode usar o limiar para realizar uma segmentação simples de plano de fundo em uma imagem e se resume a variantes de uma técnica simples para cada pixel:

if pixel_value > threshold:
    pixel_value = MAX
else:
    pixel_value = 0

O limiar simples tem problemas gritantes e requer uma entrada bastante pura, o que o torna não tão prático para muitos casos de uso. O principal ofensor é um limite global que é aplicado à imagem inteira, enquanto as imagens raramente são uniformes o suficiente para que os limites gerais funcionem, a menos que sejam artificiais.

Um limite global funcionaria bem na separação de caracteres em um livro preto e branco, em páginas digitalizadas. Um limite global provavelmente falhará em uma imagem de telefone dessa mesma página, pois as condições de iluminação podem ser variáveis ​​entre as partes da página, tornando um ponto de corte global muito sensível aos dados reais.

Para combater isso - podemos empregar local limites, usando uma técnica conhecida como limiar adaptativo. Em vez de tratar todas as partes da imagem com a mesma regra, podemos alterar o limite para cada Área Local que lhe parece adequado. Isso torna o limiar parcialmente invariável a mudanças na iluminação, ruído e outros fatores. Embora muito mais útil do que o limiar global, o limiar em si é uma técnica limitada e rígida e é melhor aplicada para ajudar no pré-processamento de imagens (especialmente quando se trata de identificar imagens a serem descartadas), em vez de segmentação.

Para aplicativos mais delicados que exigem contexto, é melhor empregar técnicas mais avançadas, incluindo aprendizado profundo, que tem impulsionado os recentes avanços em visão computacional.

Limite adaptativo com OpenCV

Vamos carregar uma imagem com condições de iluminação variáveis, onde uma parte da imagem está em mais foco que a outra, com a foto sendo tirada de um ângulo. Uma foto que tirei do Harold McGee's “Sobre comida e culinária” servirá muito bem!

img = cv2.imread('book.jpg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)

Agora, usando limiares regulares, podemos tentar separar as letras do fundo, pois há uma clara diferença de cor entre elas. Todas as cores de papel serão tratadas como plano de fundo. Como não sabemos realmente qual deve ser o limite - vamos aplicar o método de Otsu para encontrar um bom valor, antecipando que a imagem é um pouco bimodal (dominada principalmente por duas cores):

img = cv2.imread('book.jpg')


gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

ret, mask = cv2.threshold(blurred, 0, 255, cv2.THRESH_OTSU)
print(f'Threshold: {ret}')

fig, ax = plt.subplots(1, 2, figsize=(12, 5))
ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
ax[1].imshow(cv2.cvtColor(mask, cv2.COLOR_BGR2RGB))

Vamos dar uma olhada no resultado:

Ai. A parte esquerda do texto está principalmente desbotada, a sombra ao redor da calha comeu totalmente uma parte da imagem e o texto está muito saturado! Esta é uma imagem “em estado selvagem”, e regras gerais, como limites globais, não funcionam bem. Qual deve ser o limite? Depende da parte da imagem!

A cv2.adaptiveThreshold() método nos permite fazer exatamente isso:

cv2.adaptiveThreshold(img, 
                      max_value, 
                      adaptive_method, 
                      threshold_method, 
                      block_size, 
                      C)

A adaptive_method pode ser um cv2.ADAPTIVE_THRESH_MEAN_C or cv2.ADAPTIVE_THRESH_GAUSSIAN_C, Onde C é o último argumento que você definiu. Ambos os métodos calculam o limiar de acordo com os vizinhos do pixel em questão, onde o block_size determina o número de vizinhos a serem considerados (a área do bairro).

ADAPTIVE_THRESH_MEAN_C toma a média dos vizinhos e deduz C, enquanto ADAPTIVE_THRESH_GAUSSIAN_C leva a soma ponderada gaussiana dos vizinhos e deduz C.

Também permite definir uma estratégia de binarização, mas limita-se a THRESH_BINARY e THRESH_BINARY_INV, e alternar entre eles alternará efetivamente o que é "plano de fundo" e o que é "primeiro plano".

O método apenas retorna a máscara para a imagem – não o código de retorno e a máscara. Vamos tentar segmentar os caracteres na mesma imagem de antes, usando limiares adaptáveis:

img = cv2.imread('book.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)


mask = cv2.adaptiveThreshold(blurred, 
                              255, 
                              cv2.ADAPTIVE_THRESH_MEAN_C, 
                              cv2.THRESH_BINARY, 
                              31, 
                              10)


fig, ax = plt.subplots(1, 2, figsize=(12, 5))
ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
ax[1].imshow(cv2.cvtColor(mask, cv2.COLOR_BGR2RGB))
plt.tight_layout()

Isso resulta em uma imagem muito mais clara:

Observação: A block_size argumento deve ser um número ímpar.

Da mesma forma, podemos aplicar o limiar gaussiano:

mask = cv2.adaptiveThreshold(blurred, 
                              255, 
                              cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
                              cv2.THRESH_BINARY, 
                              31, 
                              10)

O que também produz uma imagem bastante satisfatória no final:

Tanto o tamanho do bloco (área vizinha) quanto C são hiperparâmetros para ajustar aqui. Experimente valores diferentes e escolha aquele que funciona melhor na sua imagem. Em geral, o limiar gaussiano é menos sensível ao ruído e produzirá imagens um pouco mais sombrias e limpas, mas isso varia e depende da entrada.

Limitações do Limite Adaptativo

Com o limiar adaptativo, conseguimos evitar a limitação abrangente do limiar, mas ainda é relativamente rígido e não funciona muito bem para entradas coloridas. Por exemplo, se carregarmos uma imagem de tesoura e um pequeno kit com cores diferentes, mesmo o limiar adaptativo terá problemas para segmentá-lo corretamente, com certos recursos escuros sendo delineados, mas sem considerar objetos inteiros:

Se ajustarmos o tamanho do bloco e C, podemos fazer com que ele considere patches maiores como parte do mesmo objeto, mas depois teremos problemas ao fazer os tamanhos vizinhos muito global, voltando aos mesmos problemas abrangentes com o limite global:

Conclusão

Nos últimos anos, a segmentação binária (como o que fizemos aqui) e a segmentação multi-rótulo (onde você pode ter um número arbitrário de classes codificadas) foram modeladas com sucesso com redes de aprendizado profundo, que são muito mais poderosas e flexíveis. Além disso, eles podem codificar o contexto global e local nas imagens que estão segmentando. A desvantagem é que você precisa de dados para treiná-los, além de tempo e experiência.

Para limites simples e rápidos, você pode usar o OpenCV e combater algumas das limitações usando limites adaptativos em vez de estratégias de limites globais. Para uma segmentação precisa em nível de produção, convém usar redes neurais.

Indo além - Aprendizado profundo prático para visão computacional

Sua natureza curiosa faz você querer ir mais longe? Recomendamos verificar nosso Para: “Aprendizado Profundo Prático para Visão Computacional com Python”.

Outro curso de visão computacional?

Não faremos classificação de dígitos MNIST ou moda MNIST. Eles cumpriram sua parte há muito tempo. Muitos recursos de aprendizado estão se concentrando em conjuntos de dados básicos e arquiteturas básicas antes de permitir que arquiteturas de caixa preta avançadas carreguem o fardo do desempenho.

Queremos focar em desmistificação, praticidade, compreensão, intuição e projetos reais. Quero aprender como você pode fazer a diferença? Vamos levá-lo em um passeio desde a maneira como nossos cérebros processam imagens para escrever um classificador de aprendizado profundo de nível de pesquisa para câncer de mama até redes de aprendizado profundo que “alucinam”, ensinando os princípios e a teoria por meio de trabalho prático, equipando você com o know-how e ferramentas para se tornar um especialista na aplicação de aprendizado profundo para resolver a visão computacional.

O que tem dentro?

• Os primeiros princípios da visão e como os computadores podem ser ensinados a “ver”
• Diferentes tarefas e aplicações de visão computacional
• As ferramentas do comércio que facilitarão seu trabalho
• Encontrar, criar e utilizar conjuntos de dados para visão computacional
• A teoria e aplicação das Redes Neurais Convolucionais
• Lidar com mudança de domínio, coocorrência e outros vieses em conjuntos de dados
• Transferir Aprendizagem e utilizar o tempo de treinamento e recursos computacionais de outros para seu benefício
• Construindo e treinando um classificador de câncer de mama de última geração
• Como aplicar uma dose saudável de ceticismo às ideias dominantes e entender as implicações de técnicas amplamente adotadas
• Visualizando o “espaço conceitual” de um ConvNet usando t-SNE e PCA
• Estudos de caso de como as empresas usam técnicas de visão computacional para obter melhores resultados
• Avaliação adequada do modelo, visualização do espaço latente e identificação da atenção do modelo
• Realizando pesquisas de domínio, processando seus próprios conjuntos de dados e estabelecendo testes de modelo
• Arquiteturas de ponta, a progressão das ideias, o que as torna únicas e como implementá-las
• KerasCV – uma biblioteca WIP para criar pipelines e modelos de última geração
• Como analisar e ler artigos e implementá-los você mesmo
• Selecionando modelos dependendo da sua aplicação
• Criando um pipeline de aprendizado de máquina de ponta a ponta
• Paisagem e intuição na detecção de objetos com R-CNNs, RetinaNets, SSDs e YOLO mais rápidos
• Segmentação de instância e semântica
• Reconhecimento de objetos em tempo real com YOLOv5
• Treinamento de detectores de objetos YOLOv5
• Trabalhando com Transformers usando KerasNLP (biblioteca WIP de força da indústria)
• Integrando Transformers com ConvNets para gerar legendas de imagens
• Deepdream
• Otimização de modelo de Deep Learning para visão computacional