A, imagen extraída en canales RGB, el código es muy simple directa
importación CV2
import sys
importar numpy como NP
image = cv2.imread (sys.argv [1], cv2.IMREAD_COLOR)
b = imagen [:,:, 0]
g = imagen [:,:, 1]
r = imagen [:,:, 2]
Se puede utilizar directamente la función de división de OpenCV
(B, g, r) = cv2.split (imagen)
Rgb obtenido anteriormente son matriz unidimensional, si el cv2.imshow directa ( "b", b), se muestra una escala de grises (0 ~ 255), para visualizar un canal de color correspondiente, también es necesario adicional los dos canales se llenan 0, cómo hacerlo?
(1) se pueden usar cv2 la función de combinación, tal como se presentan canal individual b, esto puede hacer:
image_b = cv2.merge ([b, np.zeros (b.shape, np.uint8), np.zeros (b.shape, np.uint8)])
En donde np.zeros (b.shape, np.uint8) y b representa la creación de una matriz de las mismas dimensiones, los valores iniciales de cada tipo de datos es el valor uint8 0 y la matriz.
(2) también se puede implementar usando funciones dstack numpy proporcionan:
image_b = np.dstack ((b, np.zeros (b.shape, np.uint8), np.zeros (b.shape, np.uint8)))
matriz numpy proporciona muchas funciones de cálculo combinados. Por ejemplo:
np.append ()
np.concatenate ()
np.stack ()
np.hstack ()
np.vstack ()
np.dstack ()
La cual, la función concatenar () es la base de la función, de hecho, * pila () función que es usada concatenar () para lograr. Estas funciones son específicas de lo que significa eso, ir en línea para comprobar debajo de la barra.
He publicado algunos otros de acabado:
-------------------------------------------------- ------
Supongamos que hay dos matrices A, B son:
>>> una
array ([0, 1, 2],
[3, 4, 5],
[6, 7, 8])
>>> b = a * 2
b >>>
array ([0, 2, 4],
[6, 8, 10],
[12, 14, 16])
1, la combinación horizontal
>>> np.hstack ((a, b))
array ([0, 1, 2, 0, 2, 4],
[3, 4, 5, 6, 8, 10],
[6, 7, 8, 12, 14, 16])
>>> np.concatenate ((a, b), eje = 1)
array ([0, 1, 2, 0, 2, 4],
[3, 4, 5, 6, 8, 10],
[6, 7, 8, 12, 14, 16])
2, la combinación verticales
>>> np.vstack ((a, b))
array ([0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[0, 2, 4],
[6, 8, 10],
[12, 14, 16])
>>> np.concatenate ((a, b), eje = 0)
array ([0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[0, 2, 4],
[6, 8, 10],
[12, 14, 16])
3, la profundidad de la combinación: la composición a lo largo de la dirección longitudinal
>>> np.dstack ((a, b))
array ([[0, 0],
[1, 2],
[2, 4],
[3, 6],
[4, 8],
[5, 10],
[6, 12],
[7, 14],
[8, 16]])
4, una combinación de column_stack columna ()
matriz unidimensional: Composición de dirección de la columna
matriz de dos dimensiones: Como con hstack
5, filas de row_stack combinado ()
Esa matriz: una combinación de una dirección de la fila
matriz de dos dimensiones: y como vstack
-------------------------------------------------- ----------
en escala de grises En segundo lugar, el mapa de color se calcula
OpenCV que tienen una función de transferencia directa, pero aquí el método para implementar una costumbre, calculados en escala de grises mapa de color Varios algoritmos tienen como valor medio, valor medio ponderado, el valor máximo de estos algoritmos.
La forma en la fórmula media:
Esto simplemente significa que, para cada valor de cada canal de color BGR multiplica por 0.333 y añadiendo, como resultado del valor de gris de pixel correspondiente.
Ponderación ecuación esquema: componente de valor de cada canal no es necesariamente, para ver cuántas personas les gusta tomar la específica
método de máxima, olvidar, se estima para ver qué canal RGB gran valor, que lo utilizará.
Python cuando se utiliza la fórmula anterior, se observa, el valor de las matrices de punto flotante, flotando punto obtenido (float32), pero es uint8 tipo de valor de escala de grises. Esta función asytpe tiempo viene en conversión práctica, el valor de tipo de matriz.
Detallado El código de escala de grises adquirida se puede encontrar como sigue:
gris = 0,114 * b + 0.587 * g + 0,299 * r
gris = gray.astype (np.uint8)
cv2.imshow ( "gris", gris)
Por último, las pegatinas código detallado:
importación cv2
importación sys
numpy importación como np
si __name__ == "__main__":
si len (sys.argv)> 1:
image = cv2.imread (sys.argv [1], cv2.IMREAD_COLOR)
b = imagen [:,: , 0]
g = imagen [:,:, 1]
r = imagen [:,:, 2]
# (BGR) = cv2.split (imagen)
#image_b = cv2.merge ([b, np.zeros (b. forma, np.uint8), np.zeros (b.shape, np.uint8)])
image_b = np.dstack ((b, np.zeros (b.shape, np.uint8), np.zeros (b.shape , np.uint8)))
cv2.imshow ( "image_b", image_b)
gris = 0,114 * b + 0.587 * g + 0.299 * r
gris = gray.astype (np.uint8)
cv2.imshow ( "gris", gris)
cv2.imshow ( "Imagen", Imagen)
cv2.waitKey (0)
Efectos específicos:
