4 técnicas interessantes de processamento de imagens usando JES

JES permite criar seus próprios filtros de imagem em apenas algumas linhas de código.

JES é um ambiente de programação que inclui uma área de programação e sua própria linha de comando. Você pode usar JES para editar imagens, vídeos e sons.

Existem muitas maneiras diferentes de editar uma foto usando JES. Isso inclui adicionar um filtro de escala de cinza ou um filtro negativo. Você também pode espelhar a imagem ou aprimorar uma cor específica.

Como criar imagens em tons de cinza

Muitos aplicativos de edição de fotos fáceis de usar permitem editar imagens de diferentes maneiras. Uma delas inclui a adição de um filtro de escala de cinza. No JES, você pode editar imagens para usar um filtro de escala de cinza alterando a cor de cada pixel para branco, cinza ou preto.

JES utiliza a linguagem de programação Jython, que é muito semelhante ao Python e segue as mesmas regras de indentação. Se necessário, você pode consultar alguns comandos úteis do Python para iniciantes para se atualizar.

Crie uma nova função chamada makeGrayscalePicture():
```
def makeGrayscalePicture():
```
Dentro da nova função, use a função pickAFile() para pedir ao usuário para selecionar uma imagem. Use a função makePicture() para criar um objeto de imagem a partir do arquivo selecionado:
```
file = pickAFile() 
pic = makePicture(file)
```
Use a função getPixels() para obter um array de todos os pixels dentro da imagem selecionada:
```
pixels = getPixels(pic)
```
Use um loop for para percorrer cada pixel da imagem:
```
for pixel in pixels:
```
Dentro do loop for, obtenha o valor RGB do pixel. Você pode armazenar os valores de vermelho, verde e azul da cor em diferentes variáveis.
```
r = getRed(pixel)
g = getGreen(pixel)
b = getBlue(pixel)
```
Calcule o valor médio de cada cor. Você pode fazer isso somando os valores de vermelho, verde e azul e dividindo o total por 3:
```
average = (r + g + b) / 3 
```
Defina todos os valores de vermelho, verde e azul com o mesmo valor. Isso tornará o pixel cinza.
```
setRed(pixel, average)
setGreen(pixel, average)
setBlue(pixel, average)
```
Após o loop for, exiba a imagem:
```
show(pic)
```
Clique no botão Carregar Programa, localizado entre a área de programação e a linha de comando.
Execute a função usando a área da linha de comando:
```
makeGrayscalePicture()
```
Use o explorador de arquivos para selecionar uma imagem. Clique em Abrir.
Aguarde a função terminar de processar a imagem. Uma nova janela será aberta para exibir a nova imagem em tons de cinza.

Como criar imagens negativas

Uma imagem negativa é aquela em que as áreas claras da foto aparecem escurecidas e as partes escuras da foto parecem mais claras. Você pode criar esse efeito modificando os valores de vermelho, verde e azul de cada pixel.

Crie uma nova função chamada makeNegativePicture():
```
def makeNegativePicture():
```
Dentro da nova função, use a função pickAFile() para pedir ao usuário para selecionar uma imagem. Use a função makePicture() para criar um objeto de imagem a partir do arquivo selecionado:
```
file = pickAFile() 
pic = makePicture(file)
```
Use a função getPixels() para obter um array de todos os pixels dentro da imagem selecionada:
```
pixels = getPixels(pic)
```
Use um loop for para percorrer cada pixel da imagem:
```
for pixel in pixels:
```
Dentro do loop for, obtenha os valores de vermelho, verde e azul para o pixel:
```
r = getRed(pixel)
g = getGreen(pixel)
b = getBlue(pixel)
```
Para criar o efeito negativo, obtenha o valor oposto da cor no espectro RGB. Por exemplo, se o valor vermelho for 100, o valor oposto seria 255 - 100, que é 155.
```
newRed = 255 - r
newBlue = 255 - g
newGreen = 255 - b
```

Substitua a cor do pixel pelos novos valores de vermelho, verde e azul:

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

Após o loop for, exiba a imagem:
```
show(pic)
```
Clique no botão Carregar Programa, localizado entre a área de programação e a linha de comando.
Execute a função makeNegativePicture() na linha de comando:
```
makeNegativePicture()
```
Use o explorador de arquivos para selecionar uma imagem. Clique em Abrir.
Uma nova janela será aberta para exibir a imagem negativa.

Como aprimorar uma cor específica em uma imagem

Você também pode usar JES para aprimorar cores específicas de uma imagem. Por exemplo, você pode dobrar o valor do vermelho de cada pixel para fazer a imagem parecer mais vermelha.

Crie uma nova função chamada alterReds():
```
def alterReds():
```
Dentro da nova função, use a função pickAFile() para pedir ao usuário para selecionar uma imagem. Use a função makePicture() para criar um objeto de imagem a partir do arquivo selecionado:
```
file = pickAFile() 
pic = makePicture(file)
```
Use a função getPixels() para obter um array de todos os pixels dentro da imagem selecionada:
```
pixels = getPixels(pic)
```
Use um loop for para percorrer cada pixel da imagem:
```
for pixel in pixels:
```
Dentro do loop for, obtenha apenas o valor vermelho do pixel:
```
r = getRed(pixel)
```
Dobre o valor vermelho e armazene-o em uma nova variável:
```
enhancedRed = r*2 
```
Substitua o valor vermelho do pixel pelo novo valor aprimorado. Por exemplo, se o valor RGB original do pixel fosse rgb(100, 50, 50), o novo valor seria rgb(200, 50, 50).
```
setRed(pixel, enhancedRed)
```
Após o loop for, exiba a imagem:
```
show(pic)
```
Clique no botão Carregar Programa, localizado entre a área de programação e a linha de comando.
Execute a função usando a área da linha de comando:
```
alterReds()
```
Use o explorador de arquivos para selecionar uma imagem. Clique em Abrir.
Uma nova janela será aberta para exibir a imagem editada.

Como espelhar uma imagem

Para espelhar uma imagem, cada pixel do lado esquerdo da imagem deve corresponder exatamente ao pixel oposto do lado direito.

Você pode fazer isso criando uma nova imagem vazia com fundo branco. Você pode então copiar cada pixel para criar a nova imagem espelhada.

Crie uma nova função chamada mirror():
```
def mirror():
```
Dentro da nova função, use a função pickAFile() para pedir ao usuário para selecionar uma imagem. Use a função makePicture() para criar um objeto de imagem a partir do arquivo selecionado:
```
file = pickAFile() 
pic = makePicture(file) 
```
Obtenha a altura e largura da imagem selecionada:
```
width = getWidth(pic)
height = getHeight(pic)
```
Use a função makeEmptyPicture() para criar uma imagem em branco. Uma imagem em branco é uma imagem com fundo branco. Dobre a largura para que você possa ajustar a imagem original no lado esquerdo e a imagem invertida no lado direito:
```
mirroredPic = makeEmptyPicture(width*2, height)
```
Crie um loop for para percorrer cada coordenada xey da imagem original. Dentro do loop for, obtenha o pixel armazenado naquele local:
```
for x in range(0, width):
    for y in range(0, height):
        originalPix = getPixel(pic, x, y)
```
Ainda dentro do loop for, obtenha o pixel na nova imagem em branco no mesmo local xey. Este será o lado esquerdo da imagem espelhada:
```
leftMirrorPixel = getPixel(mirroredPic, x, y) 
```
Copie a cor do pixel original para o pixel do lado esquerdo da nova imagem:
```
setColor(leftMirrorPixel, getColor(originalPix))
```
Faça a mesma coisa para o lado direito. A coordenada y será a mesma. Como a coordenada x estará no lado direito, subtraia a coordenada x da largura total da nova imagem espelhada:
```
rightMirrorPixel = getPixel(mirroredPic, (width*2)-x-1, y)
```
Copie a cor do pixel original para o pixel do lado direito da nova imagem:
```
setColor(rightMirrorPixel, getColor(originalPix))
```
Após o loop for, exiba a imagem:
```
show(mirroredPic)
```
Clique no botão Carregar Programa, localizado entre a área de programação e a linha de comando.
Execute a função mirror() na linha de comando:
```
mirror()
```
Use o explorador de arquivos para selecionar uma imagem. Clique em Abrir.
Uma nova janela será aberta para exibir a imagem espelhada.

Editando Imagens Usando JES

Agora você espera que você entenda como editar fotos no JES usando uma variedade de técnicas. Estas não são as únicas técnicas que você pode aplicar em fotos, então você pode experimentar mais outras possibilidades no JES.