Segmentação de imagem usando opencv

Nos tutoriais anteriores, usamos o OpenCV para processamento básico de imagens e fizemos algumas operações de edição de imagens avançadas. Como sabemos, OpenCV é uma biblioteca Open Source Commuter Vision que possui interfaces C ++, Python e Java e oferece suporte a Windows, Linux, Mac OS, iOS e Android. Portanto, ele pode ser facilmente instalado no Raspberry Pi com ambiente Python e Linux. E o Raspberry Pi com OpenCV e câmera conectada pode ser usado para criar muitos aplicativos de processamento de imagem em tempo real, como detecção de rosto, bloqueio de rosto, rastreamento de objetos, detecção de placa de carro, sistema de segurança residencial, etc. Neste tutorial aprenderemos como fazer segmentação de imagens usando OpenCV. As operações que vamos realizar estão listadas abaixo:

• Segmentação e contornos
• Hierarquia e modo de recuperação
• Aproximando contornos e encontrando seu casco convexo
• Conex Hull
• Contorno correspondente
• Identificação de formas (círculo, retângulo, triângulo, quadrado, estrela)
• Detecção de linha
• Detecção de blob
• Filtrando os blobs - contando círculos e elipses

1. Segmentação e contornos

A segmentação de imagens é um processo pelo qual particionamos as imagens em diferentes regiões. Já os contornos são as linhas ou curvas contínuas que limitam ou cobrem todo o limite de um objeto em uma imagem. E, aqui, usaremos a técnica de segmentação de imagens chamada contornos para extrair as partes de uma imagem.

Além disso, os contornos são muito importantes em

• Detecção de objetos
• Análise de forma

E eles têm um amplo campo de aplicação da análise de imagens do mundo real à análise de imagens médicas, como em ressonâncias magnéticas

Vamos saber como implementar contornos em opencv, extraindo contornos de quadrados.

import cv2 import numpy as np

Vamos carregar uma imagem simples com 3 quadrados pretos

image = cv2.imread ('squares.jpg') cv2.imshow ('imagem de entrada', imagem) cv2.waitKey (0)

Tons de cinza

cinza = cv2.cvtColor (imagem, cv2.COLOR_BGR2GRAY)

Encontre bordas sagazes

edged = cv2.Canny (cinza, 30,200 ) cv2.imshow ('arestas', edged) cv2.waitKey (0)

Encontrando contornos

# use uma cópia de sua imagem, por exemplo - edged.copy (), visto que encontrar contornos altera a imagem # temos que adicionar _, antes dos contornos como um argumento vazio devido à atualização da versão do OpenCV _, contours, hierarchy = cv2.findContours (edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('as arestas após o contorno', edged) cv2.waitKey (0)

Imprimir o arquivo de contorno para saber quais contornos são compostos por

print (contours) print ('Números de contornos encontrados =' + str (len (contours)))

Desenhe todos os contornos

# use -1 como o terceiro parâmetro para desenhar todos os contornos cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Saída do console -],],], …,],],]], dtype = int32), array (],],

], …,

],],]], dtype = int32), array (],],], …,],],]], dtype = int32)]

Números de contornos encontrados = 3. Portanto, encontramos um total de três contornos.

Agora, no código acima, também imprimimos o arquivo de contorno usando , este arquivo mostra como esses contornos se parecem, conforme impresso na saída do console acima.

Na saída do console acima, temos uma matriz que se parece com as coordenadas dos pontos x, y. O OpenCV armazena contornos em uma lista de listas. Podemos simplesmente mostrar a saída do console acima da seguinte maneira:

CONTORNO 1 CONTORNO 2 CONTORNO 3

], array (], array (],],],],],],],

…,…,…,],],],],],],]], dtype = int32),]], dtype = int32),]], dtype = int32)]

Agora, como usamos a função de comprimento no arquivo de contorno, obtemos o comprimento igual a 3, isso significa que havia três listas de listas naquele arquivo, ou seja, três contornos.

Agora, imagine que o CONTORNO 1 é o primeiro elemento desse array e essa lista contém a lista de todas as coordenadas e essas coordenadas são os pontos ao longo dos contornos que acabamos de ver, como as caixas retangulares verdes.

Existem diferentes métodos para armazenar essas coordenadas e são chamados de métodos de aproximação; basicamente, os métodos de aproximação são de dois tipos

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE armazena todos os pontos de fronteira, mas não precisamos necessariamente de todos os pontos de fronteira, se o ponto formar uma linha reta, precisamos apenas do ponto inicial e final nessa linha.

cv2.CHAIN_APPROX_SIMPLE em vez disso fornece apenas os pontos inicial e final dos contornos delimitadores, o resultado é um armazenamento muito mais eficiente de informações de contorno.

_, contornos, hierarquia = cv2.findContours (edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

No código acima, cv2.RETR_EXTERNAL é o modo de recuperação, enquanto cv2.CHAIN_APPROX_NONE é

o método de aproximação.

Portanto, aprendemos sobre contornos e método de aproximação, agora vamos explorar a hierarquia e o modo de recuperação.

2. Hierarquia e modo de recuperação

O modo de recuperação define a hierarquia em contornos como subcontornos, ou contorno externo ou todos os contornos.

Agora, existem quatro modos de recuperação classificados nos tipos de hierarquia.

cv2.RETR_LIST - recupera todos os contornos.

cv2.RETR_EXTERNAL - recupera apenas contornos externos ou externos.

cv2.RETR_CCOMP - recupera tudo em uma hierarquia de 2 níveis.

cv2.RETR_TREE - recupera tudo em uma hierarquia completa.

A hierarquia é armazenada no seguinte formato

Agora vamos ilustrar a diferença entre os dois primeiros modos de recuperação, cv2.RETR_LIST e cv2.RETR_EXTERNAL.

import cv2 import numpy as np

Vamos carregar uma imagem simples com 3 quadrados pretos

image = cv2.imread ('square donut.jpg') cv2.imshow ('input image', image) cv2.waitKey (0)

Tons de cinza

cinza = cv2.cvtColor (imagem, cv2.COLOR_BGR2GRAY)

Encontre Canny Edges

edged = cv2.Canny (cinza, 30,200 ) cv2.imshow ('arestas', edged) cv2.waitKey (0)

Encontrando Contornos

# use uma cópia de sua imagem, por exemplo - edged.copy (), uma vez que encontrar contornos altera a imagem # temos que adicionar _, antes dos contornos como um argumento vazio devido à atualização da versão cv aberta _, contornos, hierarquia = cv2.findContours (edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('bordas sagazes após contorno', edged) cv2.waitKey (0)

Imprimir o arquivo de contorno para saber o que os contornos compõem.

print (contours) print ('Números de contornos encontrados =' + str (len (contours)))

Desenhe todos os contornos

# use -1 como o terceiro parâmetro para desenhar todos os contornos cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows

import cv2 import numpy as np

Vamos carregar uma imagem simples com 3 quadrados pretos

image = cv2.imread ('square donut.jpg') cv2.imshow ('input image', image) cv2.waitKey (0)

Tons de cinza

cinza = cv2.cvtColor (imagem, cv2.COLOR_BGR2GRAY)

Encontre bordas sagazes

edged = cv2.Canny (cinza, 30,200 ) cv2.imshow ('arestas', edged) cv2.waitKey (0)

Encontrando contornos

# use uma cópia de sua imagem, por exemplo - edged.copy (), visto que encontrar contornos altera a imagem # temos que adicionar _, antes dos contornos como um argumento vazio devido ao upgrade da versão cv aberta _, contornos, hierarquia = cv2.findContours (edged, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('arestas após contorno', edged) cv2.waitKey (0)

Imprimir o arquivo de contorno para saber o que os contornos compõem.

print (contours) print ('Números de contornos encontrados =' + str (len (contours)))

Desenhe todos os contornos

# use -1 como o terceiro parâmetro para desenhar todos os contornos cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Assim, através da demonstração dos códigos acima, pudemos ver claramente a diferença entre cv2.RETR_LIST e cv2.RETR_EXTERNNAL , em cv2.RETR_EXTERNNAL apenas os contornos externos estão sendo levados em consideração enquanto os contornos internos estão sendo ignorados.

Enquanto em cv2.RETR_LIST, contornos internos também estão sendo levados em consideração.

3. Aproximando os contornos e encontrando seu casco convexo

Ao aproximar contornos, uma forma de contorno é aproximada sobre outra forma de contorno, que pode não ser muito semelhante à primeira forma de contorno.

Para aproximação usamos approxPolyDP função de openCV que é explicado abaixo

cv2.approxPolyDP (contorno, precisão de aproximação, fechado)

Parâmetros:

• Contorno - é o contorno individual que desejamos aproximar.
• Precisão de aproximação - parâmetro importante para determinar a precisão da aproximação, valores pequenos fornecem uma aproximação precisa, valores grandes fornecem informações mais genéricas. Uma boa regra geral é menos de 5% do perímetro do contorno.
• Fechado - um valor booleano que indica se o contorno aproximado pode ser aberto ou fechado.

Vamos tentar aproximar a figura simples de uma casa

import numpy como np import cv2

Carregue a imagem e guarde uma cópia

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('imagem original', orig_image) cv2.waitKey (0)

Escala de cinza e binariza a imagem

cinza = cv2.cvtColor (imagem, cv2.COLOR_BGR2GRAY) ret, limiar = cv2.threshold (cinza, 127.255, cv2.THRESH_BINARY_INV)

Encontre contornos

_, contornos, hierarquia = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Itere por cada contorno e calcule seu retângulo delimitador

para c em contornos: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (orig_image, (x, y), (x + w, y + h), (0,0,255), 2) cv2.imshow ('Reto delimitador', orig_image) cv2.waitKey (0)

Itere em cada contorno e calcule o contorno aproximado

para c em contornos:

#calcular a precisão como uma porcentagem da precisão do perímetro do contorno = 0,03 * cv2.arcLength (c, Verdadeiro) aprox = cv2.approxPolyDP (c, precisão, Verdadeiro) cv2.drawContours (imagem,, 0, (0,255,0), 2) cv2.imshow ('Approx polyDP', imagem) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Casco Convexo

O casco convexo é basicamente as bordas externas, representadas pelo desenho de linhas sobre uma determinada figura.

Pode ser o menor polígono que pode caber ao redor do próprio objeto.

import cv2 import numpy as np image = cv2.imread ('star.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('original image', image) cv2.waitKey (0)

Limiar a imagem

ret, thresh = cv2.threshold (cinza, 176,255,0)

Encontre contornos

_, contornos, hierarquia = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Classifique os contornos por área e, em seguida, remova o maior contorno do quadro

n = len (contornos) -1 contornos = classificado (contornos, chave = cv2.contourArea, reverso = Falso)

Repita os contornos e desenhe o casco convexo

para c em contornos:

casco = cv2.convexHull (c) cv2.drawContours (imagem,, 0, (0,255,0), 2) cv2.imshow ('casco convexo', imagem) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Correspondência de contorno por formas

cv2.matchShapes (modelo de contorno, método de contorno, parâmetro de método)

Saída - valor de correspondência (valor inferior significa uma correspondência mais próxima)

modelo de contorno - Este é o nosso contorno de referência que estamos tentando encontrar em uma nova imagem.

contorno - O contorno individual que estamos comparando.

Método - Tipo de correspondência de contorno (1,2,3).

parâmetro do método - deixe sozinho como 0,0 (não utilizado em python opencv)

import cv2 import numpy as np

Carregar o modelo de forma ou imagem de referência

template = cv2.imread ('star.jpg', 0) cv2.imshow ('template', template) cv2.waitKey (0)

Carregue a imagem de destino com as formas que estamos tentando combinar

target = cv2.imread ('shapestomatch.jpg') gray = cv2.cvtColor (target, cv2.COLOR_BGR2GRAY)

Limite ambas as imagens antes de usar cv2.findContours

ret, thresh1 = cv2.threshold (modelo, 127,255,0) ret, thresh2 = cv2.threshold (cinza, 127,255,0)

Encontre contornos no modelo

_, contours, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # precisamos classificar os contornos por área para que possamos remover o maior contorno que é

Contorno da imagem

Sort_contours = Sorted (contours, key = cv2.contourArea, reverse = True) # extraímos o segundo maior contorno que será o contorno do nosso template tempelate_contour = contours #extrair os contornos da segunda imagem alvo _, contours, hierarchy = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) para c em contornos: #iterate em cada contorno na imagem alvo e use cv2.matchShape para comparar a forma de contorno match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("match") #if match value for menor que 0,15 if match <0,16: mais próximo_contorno = c else: mais próximo_contorno = cv2.drawContours (target,, - 1, (0,255,0), 3) cv2.imshow ('output',alvo) cv2.waitKey (0) cv2.destroyAllWindows ()

Saída do console -

0,16818605122199104

0,19946910256158912

0,18949760627309664

0,11101058276281539

Existem três métodos diferentes com funções matemáticas diferentes, podemos experimentar cada método substituindo apenas cv2.matchShapes (tempelate_contour, c, 1, 0.0) os valores do método que variam de 1,2 e 3, para cada valor você obterá uma correspondência diferente valores na saída do console.

6. Identificação de formas (círculo, retângulo, triângulo, quadrado, estrela)

O OpenCV também pode ser usado para detectar diferentes tipos de formas automaticamente na imagem. Usando o código abaixo, seremos capazes de detectar círculo, retângulo, triângulo, quadrado e estrelas da imagem.

import cv2 import numpy as np

Carregar e depois imagens em escala de cinza

image = cv2.imread ('shapes.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('identificando formas', imagem) cv2.waitKey (0) ret, thresh = cv2.threshold (cinza, 127.255,1)

Extraia contornos

_, contornos, hierarquia = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Para cnt em contornos:

Obtenha polígonos aproximados approx = cv2.approxPolyDP (cnt, 0,01 * cv2.arcLength (cnt, True), True) if len (approx) == 3: shape_name = "Triangle" cv2.drawContours (image,, 0, (0,255, 0), - 1)

encontre o centro do contorno para colocar o texto no centro

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (aprox) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Verifique se o polígono de quatro lados é quadrado ou retângulo

# cv2.boundingRect retorna a largura e altura esquerdas em pixels, começando do # canto superior esquerdo, para quadrado seria aproximadamente o mesmo se abs (wh) <= 3: shape_name = "square" #encontrar o centro do contorno para colocar o texto center cv2.drawContours (image,, 0, (0,125,255), - 1) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "Reactangle" #find contorno center para colocar o texto no centro cv2.drawContours (image,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagem, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox) == 10: shape_name = 'Estrela' cv2.drawContours (image,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox)> = 15: shape_name = 'círculo' cv2.drawContours (imagem,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagem, nome_forma, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identificando formas', imagem) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Detecção de linha

A detecção de linha é um conceito muito importante no OpenCV e tem um uso promissor no mundo real. Carros autônomos usam algoritmos de detecção de linha para a detecção de faixas e estradas.

Na detecção de linha, vamos lidar com dois algoritmos,

• Algoritmo Hough Line
• Algoritmo Probalistic Hough Line.

Você pode ter se lembrado da representação da linha da matemática do ensino médio com a equação, y = mx + c.

Porém, na linha OpenCV é representado de outra forma

A equação acima ρ = xcosӨ + ysincosӨ é a representação OpenCV da linha, em que ρ é a distância perpendicular da linha desde a origem e Ө é o ângulo formado pela normal desta linha até a origem (medido em radianos, em que 1pi radianos / 180 = 1 grau).

A função OpenCV para a detecção de linha é dada como

cv2.HoughLines (imagem binarizada, ρ precisão, Ө precisão, limite), em que o limite é o voto mínimo para ser considerado uma linha.

Agora vamos detectar linhas para uma imagem de caixa com a ajuda da função de linha de Hough do opencv.

import cv2 import numpy as np image = cv2.imread ('box.jpg')

Extração de tons de cinza e bordas perspicazes

cinza = cv2.cvtColor (imagem, cv2.COLOR_BGR2GRAY) bordas = cv2.Canny (cinza, 100,170, apertureSize = 3)

Execute linhas Hough usando precisão rho de 1 pixel

#theta precisão de (np.pi / 180) que é de 1 grau #line threshold é definido como 240 (número de pontos na linha) lines = cv2.HoughLines (bordas, 1, np.pi / 180, 240) #we iterate através de cada linha e converter no formato #required by cv2.lines (ou seja, exigindo pontos finais) para i no intervalo (0, len (linhas)): para rho, theta em linhas: a = np.cos (theta) b = np.sin (theta) x0 = a * rho y0 = b * rho x1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.line (imagem, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('linhas de peso', imagem) cv2.waitKey (0) cv2.destroyAllWindows ()

Agora vamos repetir a detecção acima da linha com outro algoritmo da linha de Hough probabilística.

A ideia por trás da linha de Hough probabilística é pegar um subconjunto aleatório de pontos suficientes para a detecção da linha.

A função OpenCV para a linha Hough probabilística é representada como cv2.HoughLinesP (imagem binarizada, precisão ρ, precisão Ө, limite, comprimento mínimo da linha, intervalo máximo da linha)

Agora vamos detectar as linhas de caixa com a ajuda das linhas de Hough probabilísticas.

import cv2 import numpy as np

Extração de arestas em tons de cinza

image = cv2.imread ('box.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) edge = cv2.Canny (grey, 50,150, apertureSize = 3) # novamente usamos as mesmas precisões rho e theta #however, especificamos um voto mínimo (pts ao longo da linha) de 100 # e comprimento mínimo da linha de 5 pixels e intervalo máximo entre as linhas de 10 pixels linhas = cv2.HoughLinesP (bordas, 1, np.pi / 180,100,100,10) para i no intervalo (0, len (linhas)): para x1, y1, x2, y2 nas linhas: cv2.line (imagem, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', image) cv2.waitKey (0) cv2.destroyAllWindows

8. Detecção de blob

Os blobs podem ser descritos como um grupo de pixels conectados que compartilham uma propriedade comum. O método para usar o detector de blob OpenCV é descrito neste fluxograma.

Para desenhar os pontos-chave, usamos cv2.drawKeypoints que leva os seguintes argumentos.

cv2.drawKeypoints (imagem de entrada, pontos-chave, blank_output_array, cor, sinalizadores)

onde as bandeiras poderiam estar

cv2.DRAW_MATCHES_FLAGS_DEFAULT

cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS

cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG

cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS

e em branco aqui nada mais é do que uma matriz de zeros

Agora vamos realizar a detecção de bolhas em uma imagem de girassóis, onde as bolhas seriam as partes centrais da flor, pois são comuns entre todas as flores.

import cv2 import numpy as np image = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

Configurar detector com parâmetros padrão

detector = cv2.SimpleBlobDetector_create ()

Detectar blobs

pontos-chave = detector.detect (imagem)

Desenhe manchas detectadas como círculos vermelhos

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS garanta que o #tamanho do círculo corresponda ao tamanho do blob em branco = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagem, pontos chave, em branco, (0,255,255), cv2.DRAW_MATCHES_FLAGS_DEFAULT)

Mostrar pontos chave

cv2.imshow ('blobs', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Mesmo que o código funcione bem, algumas das manchas são perdidas devido ao tamanho irregular das flores, pois as flores na frente são grandes em comparação com as flores no final.

9. Filtrando os Blobs - Contando Círculos e Elipses

Podemos usar parâmetros para filtrar os blobs de acordo com sua forma, tamanho e cor. Para usar parâmetros com detector de blob, usamos a função OpenCV's

cv2.SimpleBlobDetector_Params ()

Veremos como filtrar os blobs principalmente por estes quatro parâmetros listados abaixo:

Área

params.filterByArea = True / False params.minArea = pixels params.maxArea = pixels

Circularidade

params.filterByCircularity = True / False params.minCircularity = 1 sendo perfeito, 0 sendo oposto

Convexidade - Área da bolha / área do casco convexo

params.filterByConvexity = True / False params.minConvexity = Area

Inércia

params.filterByInertia = True / False params.minInertiaRatio = 0,01

Agora vamos tentar filtrar os blobs pelos parâmetros mencionados acima

import cv2 import numpy as np image = cv2.imread ('blobs.jpg') cv2.imshow ('imagem original', imagem) cv2.waitKey (0)

Inicialize o detector usando os parâmetros padrão

detector = cv2.SimpleBlobDetector_create ()

Detectar blobs

pontos-chave = detector.detect (imagem)

Desenhe bolhas em nossa imagem como círculos vermelhos

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagem, pontos-chave, em branco, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (pontos-chave) text = "número total de blobs" + str (len (pontos-chave)) cv2.putText (blobs, texto, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Exibir imagem com pontos-chave de blob

cv2.imshow ('blob usando parâmetros padrão', blobs) cv2.waitKey (0)

Defina nossos parâmetros de filtragem

#initialize configuração do parâmetro usando cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Definir parâmetros de filtragem de área

params.filterByArea = True params.minArea = 100

Definir parâmetros de filtragem de circularidade

params.filterByCircularity = True params.minCircularity = 0,9

Definir parâmetro de filtragem de convexidade

params.filterByConvexity = False params.minConvexity = 0.2

Definir parâmetro de filtragem de inércia

params.filterByInertia = True params.minInertiaRatio = 0,01

Criar detector com parâmetro

detector = cv2.SimpleBlobDetector_create (params)

Detectar blobs

pontos-chave = detector.detect (imagem)

Desenhe manchas nas imagens como círculos vermelhos

em branco = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagem, pontos-chave, em branco, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (pontos-chave) text = "número total de blobs circulares" + str (len (pontos-chave)) cv2.putText (blobs, text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Mostrar blobs

cv2.imshow ('filtrando blobs circulares', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Portanto, é assim que a segmentação de imagens pode ser feita no Python-OpenCV. Para entender melhor a visão computacional e o OpenCV, leia os artigos anteriores (Introdução ao OpenCV Python e Manipulações de imagem no OpenCV Python e você será capaz de fazer algo legal com a Visão computacional.