Opencv Basics 55 - Obtención de los valores propios y ejemplos de contornos

Algunas características de atributos del propio contorno y las características de los objetos rodeados por el contorno son de gran importancia para describir la imagen. Esta sección presenta varias características de atributos del propio contorno y las características de los objetos rodeados por el contorno.

relación de aspecto

La relación de aspecto (AspectRation) se puede utilizar para describir el contorno. Por ejemplo, la relación de aspecto de un contorno rectangular es:

宽高比 = 宽度（Width）/高度（Height）

Ejemplo: Escriba un programa para calcular la relación de aspecto de un contorno rectangular.

import cv2
o = cv2.imread('cc.bmp')
cv2.imshow("original",o)
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
x,y,w,h = cv2.boundingRect(contours[0])
cv2.rectangle(o,(x,y),(x+w,y+h),(255,255,255),3)
aspectRatio = float(w)/h

print(aspectRatio)
cv2.imshow("result",o)
cv2.waitKey()
cv2.destroyAllWindows()

Resultados de ejecución:
al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

2.1506849315068495

Se puede ver que la relación de aspecto del contorno es de aproximadamente 2.

Extensión (la relación entre el área del contorno y el área del límite rectangular (cuadro delimitador rectangular, contorno rectangular))

La imagen y sus características de contorno se pueden describir utilizando la relación Extensión del área de contorno al área del límite rectangular (cuadro delimitador rectangular, contorno rectangular) . El método de cálculo es:

Ejemplo: Calcule la relación entre el área del contorno de una imagen y su área delimitada rectangular.

import cv2
o = cv2.imread('cc.bmp')
cv2.imshow("original",o)
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
x,y,w,h = cv2.boundingRect(contours[0])
cv2.drawContours(o,contours[0],-1,(0,0,255),3)
cv2.rectangle(o,(x,y),(x+w,y+h),(255,0,0),3)
#----------------计算轮廓的面积与边界矩形的面积-------------------------
rectArea=w*h
cntArea=cv2.contourArea(contours[0])

extend=float(cntArea)/rectArea
print(extend)
cv2.imshow("result",o)
cv2.waitKey()
cv2.destroyAllWindows()

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

0.6717127650292296

Se puede ver que la relación entre el área del contorno de la imagen y el área del límite del rectángulo en este ejemplo es de aproximadamente 0,7.

Solidez (relación entre el área del contorno y el área convexa del casco)

La relación entre el área del contorno y el área del casco convexo se puede utilizar en Solidity para medir las características de imágenes, contornos y cascos convexos. Su método de cálculo es:

Ejemplo: Escriba un programa para calcular la relación del área del contorno de una imagen al área del casco convexo.

import cv2
o = cv2.imread('hand.bmp')
cv2.imshow("original",o)
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy =cv2.findContours(binary,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(o,contours[0],-1,(0,0,255),3)
cntArea=cv2.contourArea(contours[0])
hull = cv2.convexHull(contours[0])
hullArea = cv2.contourArea(hull)
cv2.polylines(o, [hull], True, (0, 255, 0), 2)
solidity=float(cntArea)/hullArea
print(solidity)
cv2.imshow("result",o)
cv2.waitKey()
cv2.destroyAllWindows()

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

0.6752344564084751

Se puede ver que la relación entre el área del contorno y el área del casco convexo de la imagen en este ejemplo es de aproximadamente 0,7.

es la razón del área de verde a rojo

Diámetro equivalente

El valor propio de un perfil se puede medir por el diámetro equivalente, que es el diámetro de un círculo igual al área del perfil. Su fórmula de cálculo es:

Ejemplo: Calcula el diámetro de un círculo con la misma área que el contorno y dibuja un círculo con la misma área que el contorno.

import cv2
import numpy as np
o = cv2.imread('cc.bmp')
cv2.imshow("original",o)
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
 cv2.CHAIN_APPROX_SIMPLE)

cv2.drawContours(o,contours[0],-1,(0,0,255),3)
cntArea=cv2.contourArea(contours[0])
equiDiameter = np.sqrt(4*cntArea/np.pi)
print(equiDiameter)
cv2.circle(o,(100,100),int(equiDiameter/2),(0,0,255),3) #展示等直径大小的圆
cv2.imshow("result",o)
cv2.waitKey()
cv2.destroyAllWindows()

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

99.00522529212108

Se puede ver que el diámetro de un círculo igual al área del contorno en este ejemplo es de aproximadamente 99.

dirección

En OpenCV, la función cv2.fitEllipse() se puede usar para construir la elipse de ajuste óptimo y también puede devolver información como el punto central, la longitud del eje y el ángulo de rotación de la elipse en el valor de retorno. Usando este formulario, información como la dirección de la elipse se puede obtener de manera más intuitiva.
El formato de sintaxis de la función cv2.fitEllipse() que devuelve cada valor de atributo es:

(x,y),(MA,ma),ángulo = cv2.fitEllipse(cnt)

Los significados de varios valores devueltos en la fórmula son los siguientes:

• (x,y): El punto central de la elipse.
• (MA,ma): La longitud de los ejes horizontal y vertical de la elipse.
• ángulo: El ángulo de rotación de la elipse.

Ejemplo: Observar los diferentes valores de retorno de la función cv2.fitEllipse()

import cv2
o = cv2.imread('cc.bmp')

cv2.imshow("original",o)
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)

ellipse = cv2.fitEllipse(contours[0])
retval=cv2.fitEllipse(contours[0])
print("单个返回值形式：")
print("retval=\n",retval)
(x,y),(MA,ma),angle = cv2.fitEllipse(contours[0])
print("三个返回值形式：")
print("(x,y)=(",x,y,")")
print("(MA,ma)=(",MA,ma,")")
print("angle=",angle)
cv2.ellipse(o,ellipse,(0,0,255),2)
cv2.imshow("result",o)
cv2.waitKey()
cv2.destroyAllWindows()

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

单个返回值形式：
retval=
((276.2112731933594, 139.6067352294922), (63.01350021362305,
166.72308349609375), 82.60102844238281)
三个返回值形式：
(x,y)=( 276.2112731933594 139.6067352294922 )
(MA,ma)=( 63.01350021362305 166.72308349609375 )
angle= 82.60102844238281

Como se puede ver en los resultados de ejecución anteriores, los valores devueltos por la función cv2.fitEllipse() en diferentes formas son los mismos.

Máscaras y píxeles

A veces, deseamos obtener una imagen de máscara de un objeto y sus puntos correspondientes. La Sección 51 introduce que establecer el grosor del parámetro de ancho de contorno de la función cv2.drawContours() en "-1" puede obtener el contorno sólido de un objeto específico, es decir, la máscara de un objeto específico.

Además, también podemos querer obtener la información de ubicación específica de los píxeles de contorno. Esta sección describe cómo obtener la información de posición de píxel de los contornos (sólidos y huecos).

En general, el contorno es un punto de píxel distinto de cero en la imagen, y la información de posición del punto de píxel del contorno se puede obtener de dos formas.

Una es usar funciones Numpy y la otra es usar funciones OpenCV.
1. Utilice la función Numpy para obtener los puntos de píxeles del contorno.
La función numpy.nonzero() puede averiguar la posición de los elementos distintos de cero en la matriz, pero su valor de retorno muestra las filas y las columnas por separado
.
Por ejemplo, aplique la función numpy.nonzero() a la siguiente matriz a:

a=
[[0 0 0 1 0]
[0 0 1 0 1]
[0 0 1 1 1]
[1 0 0 0 0]
[1 0 0 0 1]]

La información de posición de los elementos distintos de cero en la matriz a devuelta es:
(array([0, 1, 1, 2, 2, 2, 3, 4, 4], dtype=int64), array([3, 2, 4, 2, 3, 4, 0,
0, 4], dtype=int64))
Use la función numpy.transpose() para procesar el valor de retorno anterior y luego obtenga las coordenadas de estos puntos en forma de (x, y):

[[0 3] [1 2] [1 4] [2 2] [2 3] [2 4] [3 0] [4 0] [4 4]]

Ejemplo: use funciones Numpy para obtener la información de ubicación de elementos de valor distinto de cero en una matriz.

el código se muestra a continuación:

import numpy as np
#------------生成一个元素都是零值的数组 a-------------------
a=np.zeros((5,5),dtype=np.uint8)
#-------随机将其中 10 个位置上的数值设置为 1------------
#---times 控制次数
#---i,j 是随机生成的行、列位置

#---a[i,j]=1,将随机挑选出来的位置上的值设置为 1
for times in range(10):
 i=np.random.randint(0,5)
 j=np.random.randint(0,5)
 a[i,j]=1
#-------打印数组 a，观察数组 a 内值的情况-----------
print("a=\n",a)
#------查找数组 a 内非零值的位置信息------------
loc=np.transpose(np.nonzero(a))
#-----输出数组 a 内非零值的位置信息------------
print("a 内非零值的位置:\n",loc)

Ejecutar el programa anterior mostrará los siguientes resultados:

a=
[[1 1 0 0 0]
[1 1 0 1 1]
[1 0 0 0 0]
[0 0 0 1 0]
[1 1 0 0 0]]
a 内非零值的位置:
[[0 0]
[0 1]
[1 0]
[1 1]
[1 3]
[1 4]
[2 0]
[3 3]
[4 0]
[4 1]]

Ejemplo: use funciones Numpy para obtener ubicaciones de puntos de contorno dentro de una imagen.

import cv2
import numpy as np
#-----------------读取原始图像----------------------
o = cv2.imread('cc.bmp')
cv2.imshow("original",o)
#-----------------获取轮廓------------------------
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
cnt=contours[0]

#-----------------绘制空心轮廓------------------------
mask1 = np.zeros(gray.shape,np.uint8)
cv2.drawContours(mask1,[cnt],0,255,2)
pixelpoints1 = np.transpose(np.nonzero(mask1))
print("pixelpoints1.shape=",pixelpoints1.shape)
print("pixelpoints1=\n",pixelpoints1)
cv2.imshow("mask1",mask1)
#-----------------绘制实心轮廓---------------------
mask2 = np.zeros(gray.shape,np.uint8)
cv2.drawContours(mask2,[cnt],0,255,-1)
pixelpoints2 = np.transpose(np.nonzero(mask2))
print("pixelpoints2.shape=",pixelpoints2.shape)
print("pixelpoints2=\n",pixelpoints2)
cv2.imshow("mask2",mask2)
#-----------------释放窗口------------------------
cv2.waitKey()
cv2.destroyAllWindows()

• A la izquierda está la imagen o.
• En el medio está la máscara de imagen de contorno hueco1.
• La imagen de la derecha es la máscara2 de imagen de contorno sólido.

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

pixelpoints1.shape= (1400, 2)
pixelpoints1=
 [[106 292]
 [106 293]
 [106 294]
 ...
 [180 222]
 [180 223]
 [180 224]]
pixelpoints2.shape= (7892, 2)
pixelpoints2=
 [[107 293]
 [107 294]
 [107 295]
 ...
 [179 221]
 [179 222]
 [179 223]]

Obtener puntos de contorno usando funciones de OpenCV

OpenCV proporciona funciones cv2.findNonZero()para encontrar el índice de un elemento distinto de cero. La sintaxis de esta función es:

idx = cv2.findNonZero( src )

En la fórmula:

• idx es el valor devuelto, que indica la posición de índice del elemento distinto de cero. Cabe señalar que en el índice devuelto, cada elemento corresponde al formato de (número de columna, número de fila).
• src es un parámetro que indica la imagen para encontrar elementos distintos de cero.

Ejemplo: use la función OpenCV cv2.findNonZero() para obtener valores distintos de cero en una matriz.

el código se muestra a continuación:

import cv2
import numpy as np
#------------生成一个元素都是零值的数组 a-------------------
a=np.zeros((5,5),dtype=np.uint8)
#-------随机将其中 10 个位置上的值设置为 1------------
#---times 控制次数
#---i,j 是随机生成的行、列位置
#---a[i,j]=1,将随机挑选出来的位置上的值设置为 1
for times in range(10):
 i=np.random.randint(0,5)
 j=np.random.randint(0,5)
 a[i,j]=1
#-------打印数组 a，观察数组 a 内值的情况-----------
print("a=\n",a)
#------查找数组 a 内非零值的位置信息------------
loc = cv2.findNonZero(a)
#-----输出数组 a 内非零值的位置信息------------
print("a 内非零值的位置:\n",loc)

Ejecutar el programa anterior mostrará los siguientes resultados:

a=
 [[1 1 0 0 0]
 [0 0 0 0 1]
 [0 0 1 1 0]
 [0 0 0 0 1]
 [0 0 0 0 0]]
a 内非零值的位置:
 [[[0 0]]

 [[1 0]]

 [[4 1]]

 [[2 2]]

 [[3 2]]

 [[4 3]]]

Ejemplo: use la función OpenCV cv2.findNonZero() para obtener la posición de los puntos de contorno dentro de una imagen.

import cv2
import numpy as np
#-----------------读取原始图像----------------------
o = cv2.imread('cc.bmp')
cv2.imshow("original",o)
#-----------------获取轮廓------------------------
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
cnt=contours[0]
#-----------------绘制空心轮廓------------------------
mask1 = np.zeros(gray.shape,np.uint8)
cv2.drawContours(mask1,[cnt],0,255,2)
pixelpoints1 = cv2.findNonZero(mask1)
print("pixelpoints1.shape=",pixelpoints1.shape)
print("pixelpoints1=\n",pixelpoints1)
cv2.imshow("mask1",mask1)
#-----------------绘制实心轮廓---------------------
mask2 = np.zeros(gray.shape,np.uint8)
cv2.drawContours(mask2,[cnt],0,255,-1)
pixelpoints2 = cv2.findNonZero(mask2)
print("pixelpoints2.shape=",pixelpoints2.shape)
print("pixelpoints2=\n",pixelpoints2)
cv2.imshow("mask2",mask2)
#-----------------释放窗口------------------------
cv2.waitKey()
cv2.destroyAllWindows()

• La imagen de la izquierda es la imagen original o.
• En el medio está la máscara de imagen de contorno hueco1.
• La imagen de la derecha es la máscara2 de imagen de contorno sólido.
  
  Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

pixelpoints1.shape= (1400, 1, 2)
pixelpoints1=
[[[292 106]]
[[293 106]]
[[294 106]]
...
[[222 180]]
[[223 180]]
[[224 180]]]
pixelpoints2.shape= (7892, 1, 2)
pixelpoints2=
[[[293 107]]
[[294 107]]
[[295 107]]
...
[[221 179]]
[[222 179]]
[[223 179]]]

Valores máximos y mínimos y sus ubicaciones

OpenCV proporciona la función cv2.minMaxLoc(), que se utiliza para encontrar el valor máximo, el valor mínimo y su ubicación dentro del objeto especificado
. La sintaxis de esta función es:

min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(imgray,máscara = máscara)

El valor devuelto en la fórmula es:

• min_val: valor mínimo.

• max_val: el valor máximo.

• min_loc: La ubicación del valor mínimo.

• max_loc: La ubicación del valor máximo.
  Los parámetros en la fórmula son los siguientes:

• imgray: Imagen de un solo canal.

• máscara: máscara. Al usar la imagen de la máscara, se puede obtener la información de mayor valor en el área especificada por la máscara.

Ejemplo: use la función cv2.minMaxLoc() para encontrar el valor máximo, el valor mínimo y su posición en el área especificada por la máscara dentro de la imagen.

import cv2
import numpy as np
o = cv2.imread('ct.png')
cv2.imshow("original",o)
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
cnt=contours[2] #coutours[0]、coutours[1]是左侧字母 R
#--------使用掩模获取感兴趣区域的最值-----------------
#需要注意函数 minMaxLoc 处理的对象为灰度图像，本例中处理的对象为灰度图像 gray
#如果希望获取彩色图像的最值，需要提取各个通道图像，为每个通道独立计算最值
mask = np.zeros(gray.shape,np.uint8)
mask=cv2.drawContours(mask,[cnt],-1,255,-1)
minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(gray,mask = mask)
print("minVal=",minVal)
print("maxVal=",maxVal)
print("minLoc=",minLoc)
print("maxLoc=",maxLoc)
#--------使用掩模获取感兴趣区域并显示-----------------
masko = np.zeros(o.shape,np.uint8)
masko=cv2.drawContours(masko,[cnt],-1,(255,255,255),-1)
loc=cv2.bitwise_and(o,masko)
cv2.imshow("mask",loc)
#显示灰度结果
#loc=cv2.bitwise_and(gray,mask)
#cv2.imshow("mask",loc)
#--------释放窗口-----------------
cv2.waitKey()
cv2.destroyAllWindows()

Ejemplo de imagen original

• A la izquierda está la imagen o.
• La imagen de la derecha es la máscara de imagen de máscara.
  

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

minVal= 42.0
maxVal= 200.0
minLoc= (87, 90)
maxLoc= (90, 110)

Color promedio y escala de grises promedio

OpenCV proporciona 函数 cv2.mean(), para calcular el color promedio o la escala de grises promedio de un objeto. La sintaxis de esta función
es:

mean_val = cv2.mean(im,máscara = máscara)

El valor devuelto en la fórmula es mean_val, que indica el valor medio devuelto.
Los parámetros en la fórmula son los siguientes:

• im: imagen original.
• máscara: máscara.

Ejemplo: Calcule el nivel medio de gris de un objeto utilizando la función cv2.mean().

import cv2
import numpy as np
#--------读取并显示原始图像-----------------
o = cv2.imread('ct.png')
cv2.imshow("original",o)
#--------获取轮廓-----------------
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,
 cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
cnt=contours[2] #coutours[0]、coutours[1]是左侧字母 R
#--------使用掩模获取感兴趣区域的均值-----------------
mask = np.zeros(gray.shape,np.uint8) #构造 mean 所使用的掩模（必须是单通道的）

cv2.drawContours(mask,[cnt],0,(255,255,255),-1)
meanVal = cv2.mean(o,mask = mask) # mask 是一个区域，所以必须是单通道的
print("meanVal=\n",meanVal)
#--------使用掩模获取感兴趣区域并显示-----------------
masko = np.zeros(o.shape,np.uint8)
cv2.drawContours(masko,[cnt],-1,(255,255,255),-1)
loc=cv2.bitwise_and(o,masko)
cv2.imshow("mask",loc)
#--------释放窗口-----------------
cv2.waitKey()
cv2.destroyAllWindows()

• A la izquierda está la imagen o.
• La imagen de la derecha es la región de interés adquirida.

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

meanVal= (85.45594913714805, 85.45594913714805, 85.45594913714805, 0.0)

Como puede verse en los resultados anteriores, la función cv2.mean() puede calcular la media de cada canal. Los 4 valores anteriores son
los valores medios de RGB y canal A (canal alfa) respectivamente. En este ejemplo, los valores de los tres canales RGB son los mismos, por lo que la media calculada también es la misma.

polo

A veces, queremos obtener los puntos extremos de un objeto, como los cuatro
puntos en el extremo izquierdo, en el extremo derecho, en la parte superior y en la parte inferior. OpenCV proporciona funciones correspondientes para encontrar estos puntos, el formato de sintaxis habitual es:

leftmost = tuple(cnt[cnt[:,:,0].argmin()][0])
rightmost = tuple(cnt[cnt[:,:,0].argmax()][0])
topmost = tuple(cnt[cnt[:,:,1].argmin()][0])
bottommost = tuple(cnt[cnt[:,:,1].argmax()][0])

Ejemplo: Calcular puntos extremos en una imagen.

import cv2
import numpy as np
o = cv2.imread('cs.bmp')
#--------获取并绘制轮廓-----------------
gray = cv2.cvtColor(o,cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
mask = np.zeros(gray.shape,np.uint8)
cnt=contours[0]
cv2.drawContours(mask,[cnt],0,255,-1)
#--------计算极值-----------------
leftmost = tuple(cnt[cnt[:,:,0].argmin()][0])
rightmost = tuple(cnt[cnt[:,:,0].argmax()][0])
topmost = tuple(cnt[cnt[:,:,1].argmin()][0])
bottommost = tuple(cnt[cnt[:,:,1].argmax()][0])
#--------打印极值-----------------
print("leftmost=",leftmost)
print("rightmost=",rightmost)
print("topmost=",topmost)
print("bottommost=",bottommost)
#--------绘制说明文字-----------------
font=cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(o,'A',leftmost, font, 1,(0,0,255),2)
cv2.putText(o,'B',rightmost, font, 1,(0,0,255),2)
cv2.putText(o,'C',topmost, font, 1,(0,0,255),2)
cv2.putText(o,'D',bottommost, font, 1,(0,0,255),2)
#--------绘制图像-----------------
cv2.imshow("result",o)
#--------释放窗口-----------------
cv2.waitKey()
cv2.destroyAllWindows()

Entre ellos, los puntos extremos de la imagen son A, B, C y D.

Al mismo tiempo, el programa también mostrará los siguientes resultados de ejecución:

leftmost= (202, 135)
rightmost= (423, 120)
topmost= (369, 69)
bottommost= (216, 179)