Mirroring delle immagini in Python

Question

Sto realizzando un mirroring dell'immagine su assi orizzontali e verticali. Ora farò la diagonale.

Avevo fatto la larghezza hori e verti due per i loop che nello scenario hori passano attraverso tutti i pixel in altezza e solo la metà dei pixel in larghezza. Quindi ottiene il colore del pixel e imposta lo stesso colore sul pixel sull'altro lato. Passando da getWidth (foto) al centro.

Quindi ho il mio specchio nel mezzo della foto. Come fare in modo diagonale?

Modifica:

img_src = makePicture(pickAFile())
W = getWidth(img_src)
H = getHeight(img_src)

for x in range(W):
        for y in range(H):
                p = getPixel(img_src, x, y)
                colorInSrc = getColor( getPixel(img_src, x, y) )
                destPixel = getPixel(img_src, H-y-1, W-x-1)
                setColor(destPixel, colorInSrc)

Answer 1

Se ho capito correttamente ciò di cui hai bisogno è "capovolgere" l'immagine in diagonale. Dal momento che ce ne sono due, presumo che intendi quello che va dal fondo sinistro a quello superiore destro.

Per passare da questa diagonale devi trasformare ogni riga dalla sorgente in colonne nella destinazione. La parte sinistra delle righe diventerà la parte inferiore delle nuove colonne. Anche la riga più in alto diventerà la colonna più a destra. Dovrai fare questo pixel per pixel sull'intera immagine. Tieni inoltre presente che la larghezza e l'altezza dell'immagine verranno scambiate.

Modifica : un piccolo esempio. Supponi di iniziare con un'immagine larga 5 pixel e alta 3 pixel (5x3). Dovrai creare una nuova immagine vuota larga 3 pixel e alta 5 pixel.

Se inizi la numerazione dei pixel dall'angolo in alto a sinistra con (0,0), questo pixel finirà con (2,4) nella nuova immagine, il pixel (1,0) terminerà con (2,3) e così via.

Se la larghezza e l'altezza originali sono W e H, dovresti usare qualcosa del genere:

for x in xrange(W):
    for y in xrange(H):
        p = img_src.getpixel(x, y)
        img_dest.setpixel(H-y-1, W-x-1)

Dovrebbe funzionare, ma non è stato testato.

Answer 2

Usando PIL (la libreria di imaging Python) questo è un compito relativamente semplice. Si noti tuttavia che l'immagine di output è quadrata, quindi non della stessa dimensione dell'immagine originale.

Ecco il codice:

from PIL import Image, ImageDraw

# load the image, create the mirrored image, and the result placeholder
img    = Image.open('img.png')
mirror = img.transpose(Image.FLIP_LEFT_RIGHT).transpose(Image.ROTATE_90)
sz     = max(img.size + mirror.size)
result = Image.new(img.mode, (sz,sz))
result.paste(img, (0,0)+img.size)

# now paste the mirrored image, but with a triangular binary mask
mask = Image.new('1', mirror.size)
draw = ImageDraw.Draw(mask)
draw.polygon([0,0,0,sz,sz,sz], outline='white', fill='white')
result.paste(mirror, (0,0)+mirror.size, mask)

# clean up and save the result
del mirror, mask, draw
result.save('result.png')

Answer 3

Non è davvero una domanda Python, vero?

La soluzione più semplice sarebbe quella di specchiare prima in orizzontale e poi in verticale. Un altro sarebbe cambiare le righe di pixel con le colonne.

O per fare il tuo algoritmo ma cambia i pixel da sinistra in alto a in basso a destra ...

Answer 4

Ecco come eseguire il mirroring in diagonale in JES; Funziona solo con un'immagine quadrata:

def mirrorDiagonal(picture):
  for sourceX in range(0,getWidth(picture)):
    for sourceY in range (0,getHeight(picture)):
      pex=getPixel(picture,sourceY,sourceX) 
      pix=getPixel(picture, sourceX,sourceY)
      color=getColor(pix)
      setColor(pex,color)
  show(picture)