4 interesantes técnicas de procesamiento de imágenes usando JES

JES le permite crear sus propios filtros de imagen en solo unas pocas líneas de código.

JES es un entorno de programación que incluye un espacio de programación y su propia línea de comandos. Puede usar JES para editar imágenes, videos y audio.

Hay muchas formas diferentes de editar una foto usando JES. Esto incluye agregar un filtro de escala de grises o un filtro negativo. También puede reflejar una imagen o mejorar un color específico.

Cómo crear imágenes en escala de grises

Muchos software de edición de fotos fácil de usar le permite editar imágenes en una variedad de formas. Uno de estos incluye agregar un filtro de escala de grises. En JES, puede editar imágenes para usar un filtro de escala de grises cambiando el color de cada píxel para usar blanco, gris o negro.

JES utiliza el lenguaje de programación Jython, que es muy similar a Python y sigue las mismas reglas de sangría. Puedes mirar algunos de ellos si lo necesitas. comandos útiles de Python para principiantes para ponerte al día.

Cree una nueva función llamada makeGrayscalePicture():
```
 def makeGrayscalePicture(): 
```
Dentro de la nueva función, use la función pickAFile() para pedirle al usuario que seleccione una imagen. Utilice la función makePicture() para crear un objeto de imagen a partir del archivo seleccionado:
```
 file = pickAFile() 
pic = makePicture(file) 
```
Obtenga una matriz de todos los píxeles dentro de la imagen seleccionada usando la función GetPixels():
```
 pixels = getPixels(pic) 
```
Use un bucle for para recorrer cada píxel de la imagen:
```
 for pixel in pixels: 
```
Obtenga el valor RGB del píxel dentro del bucle for. Puede almacenar los valores rojo, verde y azul del color en diferentes variables.
```
 r = getRed(pixel)
g = getGreen(pixel)
b = getBlue(pixel) 
```
Calcular el valor medio de cada color. Puedes hacer esto sumando los valores rojo, verde y azul y dividiendo el total por 3:
```
 average = (r + g + b) / 3  
```
Establezca todos los valores de rojo, verde y azul en el mismo valor. Esto hará que el píxel sea gris.
```
 setRed(pixel, average)
setGreen(pixel, average)
setBlue(pixel, average) 
```
Muestre la imagen después del bucle for:
```
 show(pic) 
```
Haz click en eso Descarga el programa botón ubicado entre el área de programación y la línea de comando.
Ejecute la función usando el campo de línea de comando:
```
 makeGrayscalePicture() 
```
Utilice el explorador de archivos para seleccionar una imagen. Hacer clic Abierto.
Espere hasta que la función termine de procesar la imagen. Se abrirá una nueva ventana para mostrar la nueva imagen en escala de grises.

Cómo crear imágenes negativas

Una imagen negativa es una imagen en la que las partes claras de la fotografía se oscurecen y las partes oscuras aparecen más claras. Puede crear este efecto cambiando los valores de rojo, verde y azul de cada píxel.

Cree una nueva función llamada makeNegativePicture():
```
 def makeNegativePicture(): 
```
Dentro de la nueva función, use la función pickAFile() para pedirle al usuario que seleccione una imagen. Utilice la función makePicture() para crear un objeto de imagen a partir del archivo seleccionado:
```
 file = pickAFile() 
pic = makePicture(file) 
```
Obtenga una matriz de todos los píxeles dentro de la imagen seleccionada usando la función GetPixels():
```
 pixels = getPixels(pic) 
```
Use un bucle for para recorrer cada píxel de la imagen:
```
 for pixel in pixels: 
```
Obtenga los valores de rojo, verde y azul para un píxel dentro de un bucle for:
```
 r = getRed(pixel)
g = getGreen(pixel)
b = getBlue(pixel) 
```
Obtenga el valor opuesto de un color en el espectro RGB para crear un efecto negativo. Por ejemplo, si el valor rojo es 100, el valor opuesto será 255 – 100, que es 155.
```
 newRed = 255 - r
newBlue = 255 - g
newGreen = 255 - b 
```

Reemplace el color del píxel con los nuevos valores rojo, verde y azul:

 setRed(pixel, newRed)
setBlue(pixel, newBlue)
setGreen(pixel, newGreen)

Muestre la imagen después del bucle for:
```
 show(pic) 
```
Haz click en eso Descarga el programa botón ubicado entre el área de programación y la línea de comando.
Ejecute makeNegativePicture() desde la línea de comando:
```
 makeNegativePicture() 
```
Utilice el explorador de archivos para seleccionar una imagen. Hacer clic Abierto.
Se abrirá una nueva ventana para mostrar la imagen negativa.

Cómo realzar un color específico en una imagen

También puede usar JES para mejorar colores específicos de una imagen. Por ejemplo, puede duplicar el valor rojo de cada píxel para que la imagen parezca más roja.

Cree una nueva función llamada alterReds():
```
 def alterReds(): 
```
Dentro de la nueva función, use la función pickAFile() para pedirle al usuario que seleccione una imagen. Utilice la función makePicture() para crear un objeto de imagen a partir del archivo seleccionado:
```
 file = pickAFile() 
pic = makePicture(file) 
```
Obtenga una matriz de todos los píxeles dentro de la imagen seleccionada usando la función GetPixels():
```
 pixels = getPixels(pic) 
```
Use un bucle for para recorrer cada píxel de la imagen:
```
 for pixel in pixels: 
```
Obtenga solo el valor rojo del píxel dentro del bucle for:
```
r = getRed(pixel)
```
Duplique el valor rojo y guárdelo en una nueva variable:
```
 enhancedRed = r*2  
```
Reemplace el valor rojo del píxel con un valor nuevo y mejorado. Por ejemplo, si el valor RGB original del píxel era rgb(100, 50, 50), el nuevo valor será rgb(200, 50, 50).
```
 setRed(pixel, enhancedRed) 
```
Muestre la imagen después del bucle for:
```
 show(pic) 
```
Haz click en eso Descarga el programa botón ubicado entre el área de programación y la línea de comando.
Ejecute la función usando el campo de línea de comando:
```
 alterReds() 
```
Utilice el explorador de archivos para seleccionar una imagen. Hacer clic Abierto.
Se abrirá una nueva ventana para mostrar la imagen editada.

Cómo reflejar una imagen

Para reflejar una imagen, cada píxel del lado izquierdo de la imagen debe coincidir exactamente con el píxel opuesto del lado derecho.

Un ejemplo de un reflejo de imagen de playa

Puede hacerlo creando una nueva imagen en blanco con un fondo blanco. Luego puede copiar cada píxel para crear una nueva imagen reflejada.

Crea una nueva función llamada mirror():
```
 def mirror(): 
```
Dentro de la nueva función, use la función pickAFile() para pedirle al usuario que seleccione una imagen. Utilice la función makePicture() para crear un objeto de imagen a partir del archivo seleccionado:
```
 file = pickAFile() 
pic = makePicture(file)  
```
Obtenga la altura y el ancho de la imagen seleccionada:
```
 width = getWidth(pic)
height = getHeight(pic) 
```
Utilice la función makeEmptyPicture() para crear una imagen vacía. Una imagen en blanco es una imagen con un fondo blanco. Duplique el ancho para que quepa la imagen original a la izquierda y la imagen convertida a la derecha:
```
 mirroredPic = makeEmptyPicture(width*2, height) 
```

Cree un ciclo for para recorrer cada coordenada x e y de la imagen original. Dentro del ciclo for, obtenga el píxel almacenado en esa ubicación:

 for x in range(0, width):
    for y in range(0, height):
        originalPix = getPixel(pic, x, y)

Todavía dentro del bucle for, obtenga el píxel en la nueva imagen vacía en la misma ubicación x e y. Este será el lado izquierdo de la imagen reflejada:
```
 leftMirrorPixel = getPixel(mirroredPic, x, y)  
```
Copie el color del píxel original al píxel a la izquierda de la nueva imagen:
```
 setColor(leftMirrorPixel, getColor(originalPix)) 
```
Haz lo mismo para el lado derecho. la coordenada y será la misma. Dado que la coordenada x estará en el lado derecho, reste la coordenada x del ancho total de la nueva imagen reflejada:
```
 rightMirrorPixel = getPixel(mirroredPic, (width*2)-x-1, y) 
```
Copie el color del píxel original al píxel a la derecha de la nueva imagen:
```
 setColor(rightMirrorPixel, getColor(originalPix)) 
```
Muestre la imagen después del bucle for:
```
 show(mirroredPic) 
```
Haz click en eso Descarga el programa botón ubicado entre el área de programación y la línea de comando.
Ejecute la función mirror() desde la línea de comando:
```
 mirror() 
```
Utilice el explorador de archivos para seleccionar una imagen. Hacer clic Abierto.
Se abrirá una nueva ventana para mostrar la imagen reflejada.

Edición de imágenes usando JES

Ahora espero que entiendas cómo editar fotos en JES usando diferentes métodos. Estas no son las únicas técnicas que puede aplicar a las fotos, por lo que puede experimentar más con otras posibilidades en JES.

Si desea mejorar sus habilidades con Python, los proyectos cortos y divertidos son una excelente manera de comprender los conceptos básicos de Python.