Questa sfida riguarda lo spostamento graduale delle tonalità in un'immagine per creare belle immagini come questa:

( originale )

Sfida

Scrivi un programma o una funzione che accetta due numeri interi non negativi e un'immagine in qualsiasi formato di file immagine comune di tua scelta (puoi prendere un percorso per l'immagine o i dati dell'immagine grezza).

Chiameremo il primo numero intero i cicli e il secondo numero intero il offset .

Definiremo anche il passaggio in virgola mobile come cicli 360 volte divisi per l'area dell'immagine, oppure step = 360 * cycles / (image width * image height).

Per ogni pixel P nell'immagine, spostando una riga alla volta, da sinistra a destra, dall'alto verso il basso (ovvero nell'ordine di lettura se i pixel fossero lettere), procedi come segue:

1. Aumenta la tonalità di P di offset gradi (passando da 360 a 0 se necessario).

2. Quindi aumentare l' offset per passo .

Salva, visualizza o visualizza in modo grezzo l'immagine risultante in qualsiasi formato di file immagine comune.

Questa procedura aumenta in modo incrementale la tonalità di tutti i pixel dell'immagine, facendo cicli a ciclo completo attorno all'arcobaleno di tonalità , iniziando a compensare inizialmente la tonalità per offset .

Quando i cicli sono 1 e l' offset è 0, come nell'immagine Notte stellata sopra, le righe superiore e inferiore di pixel non hanno praticamente alcun cambiamento di tonalità ma tra un ciclo a colori e l'altro.

Dettagli

• I cicli possono essere qualsiasi numero intero non negativo ma si può presumere che l' offset sia compreso tra 0 e 359 inclusi.

• Quando i cicli sono 0, ogni pixel dell'immagine avrà la sua tonalità spostata di esattamente l' offset poiché anche il passaggio deve essere 0. (In questo caso se offset è 0, l'immagine non cambia affatto.)

• È possibile supporre che cicli e offset siano immessi come float se lo si desidera (ovvero 1.0anziché 1). (Mi rendo conto che non devono essere affatto numeri interi, rende la sfida più semplice.)

• "Tonalità" si riferisce alla versione dello spazio colore RGB, comune nei modelli di colore HSL / HSV .

Esempi

Originale:

Cicli = 1, offset = 0:

Cicli = 1, offset = 180:

Originale:

Cicli = 2, offset = 60:

Originale:

(Grazie ArtOfCode .)

Cicli = 1, offset = 120:

Originale:

(Grazie Doorknob .)

Cicli = 1, offset = 0:

Cicli = 4, offset = 0:

Cicli = 200, offset = 0:

Cicli = 30000, offset = 0:

(Queste immagini potrebbero non essere perfette per i pixel a causa della compressione di imgur.)

punteggio

Vince il codice più breve in byte. Tiebreaker è la risposta più votata.

Le risposte che pubblicano le loro immagini di prova dall'aspetto accattivante otterranno da me più punti brownie.

Pyth, 86 byte, programma completo

=N.tE7=Z*6*.n0cEl.n'zMmhtS[0255ss*VG.>+Lc-1.tH1 3[.tH1Kc.tH0@3 2_K)d)3.wmmgk~-NZd'z

Pyth non ha conversioni di spazio colore integrate: questo è il vero affare.

Accetta input nel seguente formato su stdin:

input_filename.png
offset
cycles

L'immagine di output viene scritta in o.png.

Funziona ruotando il cubo di colore attorno alla sua diagonale, quindi bloccando tutti i valori al di fuori dell'intervallo.

Se aè l'angolo da ruotare, ed r, g, bè il colore di input, calcoliamo il nuovo colore r', g', b'per:

o = cos(a), i = sin(a) / sqrt(3)
n = (1 - o) / 3
m = [n + o, n - i, n + i]
clamp(c) = max(0, min(255, c))
r' = clamp(r*m[0] + g*m[1] + b*m[2])
g' = clamp(r*m[2] + g*m[0] + b*m[1])
b' = clamp(r*m[1] + g*m[2] + b*m[0])

Python, 379 byte

from PIL.Image import*
from colorsys import*
def f(H,c,I):
 i=open(I);x,y=i.size;S=1.*c/(x*y);r,g,b=i.split();R=[];G=[];B=[]
 for x,y,z in zip(r.getdata(),g.getdata(),b.getdata()):
  e=255.;h,s,v=rgb_to_hsv(x/e,y/e,z/e);t=hsv_to_rgb(h+H,s,v);H=H+S%1.;x,y,z=[int(x*e)for x in t];R.append(x);G.append(y);B.append(z)
 p=Image.putdata;p(r,R);p(g,G);p(b,B);return merge('RGB',(r,g,b))

Questo porta a un .jpginput come input. Non funzionerà con png, anche se puoi cambiare r,g,b=i.split();in r,g,b=i.split()[:3];per caricare un'immagine png.

Ecco alcune immagini:

Originale:

Offset: 0, Cicli: 4

Originale:

Offset 0, 1 ciclo:

Originale:

Offset 0, 2,5 cicli:

Java (programma completo), 491 488 byte (grazie a @Geobits)

import java.awt.*;import java.io.*;import static javax.imageio.ImageIO.*;class Q{public static void main(String[]v)throws Exception{File f=new File(v[2]);java.awt.image.BufferedImage b=read(f);for(int i=0,j,h=b.getHeight(),w=b.getWidth();i<h;i++)for(j=0;j<w;){Color c=new Color(b.getRGB(j,i));float[]a=new float[3];c.RGBtoHSB(c.getRed(),c.getGreen(),c.getBlue(),a);b.setRGB(j++,i,c.HSBtoRGB((a[0]+Float.valueOf(v[1])/360+(i*w+j)*Float.valueOf(v[0])/w/h)%1,a[1],a[2]));}write(b,"png",f);}}

Ungolfed

import java.awt.*;
import java.io.*;

import static javax.imageio.ImageIO.*;

class A79200 {
    public static void main(String[] v) throws Exception {
        File file = new File(v[2]);
        java.awt.image.BufferedImage image = read(file);
        for (int i = 0, j, height = image.getHeight(), width = image.getWidth(); i < height; i++)
            for (j = 0; j < width; ) {
                Color color = new Color(image.getRGB(j, i));
                float[] arr = new float[3];
                color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), arr);
                image.setRGB(j++, i, color.HSBtoRGB((arr[0] + Float.valueOf(v[1]) / 360 + (i * width + j) * Float.valueOf(v[0]) / width / height) % 1, arr[1], arr[2]));
            }
        write(image, "png", file);
    }
}

Spiegazione

• Utilizzo: abbastanza semplice. Compila con java -c Q.java. Corri con java Q <cycles> <offset> <imagepath>. Sostituirà l'immagine esistente, quindi fai attenzione.

• All'inizio stavo per fare una soluzione solo con metodo, ma non sapevo come gestire le importazioni, quindi ho pensato che sarei diventato completamente java , questo probabilmente non vincerà comunque: ^)

risultati:

Image 1: 1 cycle, 0 offset

Image 1: 1 cycle, 180 offset

Image 2: 2 cycles, 60 offset

Image 3: 1 cycle, 120 offset

Image 4: 1 cycle, 0 offset

Image 4: 4 cycles, 0 offset

Image 4: 200 cycles, 0 offset

Bonus: The Starry Night, 1 cycle, 0 offset