<jupyter_start><jupyter_text>Computer Vision – Litghning & Color Spaces  Lightning Comprender el papel que juegan las condiciones de iluminación en el desarrollo de un sistema de visión por computadora. Y analizaremos los cuatro espacios de color primarios que encontraremos en la visión artificial: RGB, HSV, L * a * b * y escala de grises (que técnicamente no es un espacio de color, pero se usa en muchas aplicaciones de visión artificial). El campo de la visión por ordenador se está expandiendo y evolucionando rápidamente. Todos los días estamos viendo nuevos avances en el campo que una vez pensamos que eran imposibles. Estamos viendo que el aprendizaje profundo clasifica las imágenes con una precisión asombrosamente alta. Pequeñas computadoras pequeñas, como la Raspberry Pi, pueden usarse para construir sistemas de vigilancia. Y la industria está viendo cada vez más aplicaciones comerciales de visión computacional puestas en el mercado. Y mientras el campo está creciendo, cambiando y evolucionando, pero hay que decir que hay una constante absoluta que nunca cambiará: cada algoritmo, aplicación y sistema de visión de computadora jamás desarrollado y que se desarrollará dependerá de la calidad de las imágenes ingresadas a el sistema. Sin duda, podremos hacer que nuestros sistemas sean más robustos en relación con las condiciones de iluminación deficientes, pero nunca podremos superar una imagen capturada en condiciones inferiores. **La iluminación puede significar la diferencia entre el éxito y el fracaso del algoritmo de visión de su computadora.** En general, sus condiciones de iluminación deben tener tres objetivos principales. Vamos a revisarlos a continuación. - **Alto contraste:** Tenemos que maximizar el contraste entre las regiones de interés en nuestras imagenes (es decir, los "objetos" que deseamos detectar, extraer, describir, clasificar, manipular, etc. debemos tener un contraste suficientemente alto del resto de la imagen para que sean fácilmente detectables).- **Generalizable:** Las condiciones de iluminación deben ser lo suficientemente consistentes como para que funcionen bien de un "objeto" al siguiente. Si nuestro objetivo es identificar varias troncos por ejemplo en Idom, nuestras condiciones de iluminación deberían ser lo suficientemente generalizadas para facilitar la identificación del tronco, ya sea que estemos examinando un tronco de otro tipo, con mas cantidad de troncos alrededor o mas alejado obteniendo mas panorama del alrededor del objeto.- **Estable:** Tenemos que tener condiciones de iluminación estables, consistentes y repetibles. Pienso que es el santo grial del desarrollo de aplicaciones de visión artificial. Sin embargo, a menudo es difícil (si no imposible) garantizarlo, esto es especialmente cierto si estamos desarrollando algoritmos de visión artificial diseñados para funcionar en condiciones de iluminación exterior. A medida que cambia la hora del día, las nubes pasan sobre el sol y comienza a llover, nuestras condiciones de iluminación obviamente cambiarán esto es muy importante para el proyecto de Idom.**CONSEJO. Tenemos que esforzarnos lo más posible por obtener las condiciones de iluminación ideales incluso antes de escribir una sola línea de código. Creo que es sustancialmente más beneficioso (y más fácil) controlar (o al menos reconocer) nuestras condiciones de iluminación que escribir un código para compensar una iluminación inferior.**  Setup<jupyter_code>import cv2
from skimage.filters import threshold_local

image = cv2.imread("C:/Users/algonzalez/source/repos/Computer_Vision/1_Basics_of_Computer_Vision/images/IMG_1009.JPG")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Original", image)
cv2.waitKey(0)
cv2.destroyAllWindows()<jupyter_output><empty_output><jupyter_text>RGB Space Para definir un color en el modelo de color RGB, todo lo que tenemos que hacer es definir la cantidad de rojo, verde y azul que contiene un solo píxel. Cada canal rojo, verde y azul puede tener valores definidos en el rango [0, 255] (para un total de 256 "sombras"), donde 0 indica que no hay representación y 255 demuestra la representación completa. Dado que un color RGB se define como una tupla de 3 valores, con cada valor en el rango [0, 255], podemos pensar en el cubo que contiene 256 x 256 x 256 = 16,777,216 colores posibles, dependiendo de cuánto rojo, verde , y azul colocamos.<jupyter_code># loop sobre cada uno de los canales
for (name, chan) in zip(("B", "G", "R"), cv2.split(image)):
    cv2.imshow(name, chan)

cv2.waitKey(0)
cv2.destroyAllWindows()<jupyter_output><empty_output><jupyter_text>HSV Space El espacio de color HSV transforma el espacio de color RGB, remodelando como un cilindro en lugar de un cubo: Como vimos en la sección RGB, el "blanco" o "luminosidad" de un color es una combinación aditiva de cada componente Rojo, Verde y Azul. Pero ahora, en el espacio de color HSV, la luminosidad tiene su propia dimensión separada.- **Tono:** cual color "puro" estamos examinando. Por ejemplo, todas las sombras y tonos del color "rojo" tendrán el mismo tono.- **Saturación:** cómo "blanco" es el color. Un color totalmente saturado sería "puro", como en "rojo puro". Y un color con saturación cero sería blanco puro. - **Valor:** El valor nos permite controlar la luminosidad de nuestro color. Un valor de cero indicaría negro puro, mientras que aumentar el valor produciría colores más claros. Es importante tener en cuenta que las diferentes bibliotecas de visión artificial usarán diferentes rangos para representar cada uno de los componentes de Tono, Saturación y Valor.Si bien el espacio de color RGB es fácil de entender, no es intuitivo al definir los tonos exactos de un color o al especificar un rango de colores en particular. Por otro lado, el espacio de color HSV es más intuitivo, pero no hace el mejor trabajo al representar cómo los humanos ven e interpretan los colores en las imágenes. Ahí es donde entra en juego el espacio de color L * a * b *, su objetivo es imitar la metodología en la que los humanos ven e interpretan el color.<jupyter_code>hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
cv2.imshow("HSV", hsv)

# loop sobre cada uno de los canales de HSV
for (name, chan) in zip(("H", "S", "V"), cv2.split(hsv)):
    cv2.imshow(name, chan)

cv2.waitKey(0)
cv2.destroyAllWindows()<jupyter_output><empty_output><jupyter_text>L*a*b - **Canal L:** La “luminosidad” del píxel. Este valor sube y baja del eje vertical, blanco a negro, con grises neutros en el centro del eje. - **a-channel:** se origina en el centro del canal L y define el verde puro en un extremo del espectro y el rojo puro en el otro. canal - **b:** También se origina en el centro del canal L, pero es perpendicular al canal a. El canal B define azul puro en uno de los espectros y amarillo puro en el otro.Similar a nuestro ejemplo de HSV, tenemos el canal L* que se dedica a mostrar qué tan claro es un píxel dado. El a * y el b * luego determinan el tono y el color del píxel.<jupyter_code>lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
cv2.imshow("L*a*b*", lab)

# loop sobre cada uno de los canales de "L*a*b*
for (name, chan) in zip(("L*", "a*", "b*"), cv2.split(lab)):
    cv2.imshow(name, chan)

cv2.waitKey(0)
cv2.destroyAllWindows()<jupyter_output><empty_output><jupyter_text>Grayscale space Las imágenes en escala de grises son imágenes de un solo canal con valores de píxeles en el rango [0, 255] (es decir, 256 valores únicos). No confundir con imágenes en blanco y negro que únicamente tienen un rango de valores de 0 o 255. Este espacio de color nos permite conservar la memoria y ser más eficientes computacionalmente.<jupyter_code>gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Original", image)
cv2.imshow("Grayscale", gray)
cv2.waitKey(0)
cv2.destroyAllWindows()<jupyter_output><empty_output><jupyter_text>Split and merge colors<jupyter_code>import numpy as np

(B, G, R) = cv2.split(image)

# Mostrar cada cana de manera individual
cv2.imshow("Red", R)
cv2.imshow("Green", G)
cv2.imshow("Blue", B)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Merge de los canales de nuevo
merged = cv2.merge([B, G, R])
cv2.imshow("Merged", merged)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Visualizar cada canal con su color
zeros = np.zeros(image.shape[:2], dtype = "uint8")
cv2.imshow("Red", cv2.merge([zeros, zeros, R]))
cv2.imshow("Green", cv2.merge([zeros, G, zeros]))
cv2.imshow("Blue", cv2.merge([B, zeros, zeros]))
cv2.waitKey(0)
cv2.destroyAllWindows()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.06756598240469208, 'fraction_numerical': 0.01313782991202346, 'mean_word_length': 5.246153846153846, 'pattern_counts': {'":': 0, '<': 25, '<?xml version=': 0, '>': 25, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '447990', 'license': 'MIT', 'n_tokens_mistral': 2827, 'n_tokens_neox': 2756, 'n_words': 1192, 'path': '1_Basics_of_Computer_Vision/color_spaces_lightning.ipynb', 'repo_name': 'alexandergg/Computer-Vision-Fundamentals', 'size': '8525'}