Als großer Fan des Rubik's Cube und der coolen Kunst habe ich daran gearbeitet, beides zu kombinieren, um ein paar wirklich coole Sachen zu machen. Lösen von Rubiks Miniaturwürfeln, um rudimentäre Pixel bei der Bildung von Rubiks Würfelkunst zu bilden. Beispiele für solche Kunstwerke finden Sie unter folgendem Link: http://google.com/search?q=rubik%27s+cube+art

Der Zweck dieses Code Golf besteht nun darin, Code zu erstellen, der ein Bild als Eingabe akzeptiert und es dann auf folgende Weise konvertiert:

Das Bild wird zunächst auf websichere Graustufenfarben reduziert. Der Grund dafür ist, dass wir die websichere Graustufenpalette (dh 000000, 333333, 666666, 999999, CCCCCC und FFFFFF) isolieren müssen. Ein Algorithmus zur kolorimetrischen Konvertierung in Graustufen ist verfügbar unter: http://en.wikipedia.org/wiki/Grayscale#Colorimetric_.28luminance-preserving.29_conversion_to_grayscale , falls Sie dies als Inspiration verwenden möchten.

Man würde dann die Graustufen auf die entsprechenden Farben rendern. Kurz gesagt: 000000 bezieht sich auf Rubiks Blau, 333333 auf Rubiks Rot, 666666 auf Rubiks Grün, 999999 auf Rubiks Orange, CCCCCC auf Rubiks Gelb und FFFFFF auf Rubiks Weiß.

Ich würde es vorziehen, wenn der resultierende Code von der Palette des Fotos direkt in Rubiks Farben gerendert werden kann. Die zweistufige Methode von der Konvertierung in web-sichere Graustufen und dann in die entsprechende Rubik-Palette dient nur dazu, Ihnen eine Vorstellung von der Logik zu geben, die hinter dem Prozess steckt.

Die tatsächlichen RGB-Werte für die Rubik-Palette müssen den folgenden Angaben entsprechen:

• Rot: # C41E3A
• Grün: # 009E60
• Blau: # 0051BA
• Orange: # FF5800
• Gelb: # FFD500
• Weiß: #FFFFFF

Um Ihnen ein Beispiel zu geben, habe ich Abraham Lincolns Kopf aus dem folgenden Bild abgeschnitten und den Algorithmus so gerendert, dass er Folgendes ergibt :

Das Raster ist vorhanden, damit Sie sehen können, wie die einzelnen Rubik-Miniaturwürfel konfiguriert werden müssten, um das Bild zu erstellen. Die wahre Größe des resultierenden Bildes beträgt 45 x 45 Pixel, was bedeutet, dass (45/3) * (45/3) = 15 * 15 = 225 Miniaturwürfel von Rubik verwendet würden, um dieses Bild zu erstellen. Ich erwarte nicht, dass Sie das resultierende Bild mit einem Gitter präsentieren, wie ich es habe.

Das ist also erforderlich:

1. Das von diesem Algorithmus zu verarbeitende Bild muss x Pixel breit und y Pixel hoch sein, sodass x und y ein Vielfaches von 3 sind. Dies erleichtert das Rendern als Teil eines Rubik's Cube-Mosaiks. Wenn Ihr Bild sehr groß ist, empfiehlt es sich, es vor der Verarbeitung auf etwa 45 x 45 bis 75 x 75 zu verkleinern. Beachten Sie, dass diese Größenänderungskomponente OPTIONAL ist.

2. Das Bild muss in die sextakolorierte Rubik-Cube-Palette konvertiert werden, um das Mosaik zu erstellen.

3. Das resultierende Bild muss nach der Verarbeitung eine gültige Grafikdatei sein. Um zu beweisen, dass Ihr Code funktioniert, führen Sie ihn gegen ein Bild eines Präsidenten der Vereinigten Staaten von Amerika oder eines bekannten Hollywood-Stars aus. Ich habe in meinem Beispiel bereits Abraham Lincoln verwendet, daher kann dieser Präsident nicht mehr verwendet werden. Stellen Sie sicher, dass Sie die Sprache, die Sie verwendet haben, die Byteanzahl sowie den Präsidenten / Prominenten angeben, der zum Testen Ihres Codes verwendet wurde, einschließlich vor und nach den Aufnahmen ...

4. Jeder Beitrag muss einen eindeutigen Präsidenten / Prominenten als Testfall haben. Ich akzeptiere keine Duplikate. Dadurch wird sichergestellt, dass keine doppelten Ergebnisse zum Testen verschiedener Codeeinträge verwendet werden. Es ist alles sehr gut zu sagen, dass Ihr Code funktioniert, es ist eine andere Sache, um es zu beweisen.

5. Kürzester Code gewinnt.

Ich ändere dies in einen Beliebtheitswettbewerb. Ich möchte lieber sehen, wer dies tun kann, ohne an der Byte-Zählung teilnehmen zu müssen. Also werde ich dies zusammen mit einer Prämie nach dem 28. Februar 2014 vergeben.

Imagemagick (108)

Version: ImageMagick 6.8.7-7 Q16 x86_64 27.11.2013

Der folgende Aufruf:

$ convert -resize 75x75 -fx "q=p.intensity;q<1/6?#0051BA:q<2/6?#C41E3A:q<3/6?#009e60:q<4/6?#ff5800:q<5/6?#FFD500:#FFF" input output

wo inputund outputmüssen für die Eingabe und Ausgabe Dateinamen geändert werden.

Ich habe nur die Zeichen zwischen -resizeund gezählt #FFF". Wenn Sie der Meinung sind, dass dies ungültig ist, können Sie dies gerne kommentieren.

Ich habe Lenna als Bild benutzt (sie ist in einem Playboy aufgetreten, und jeder, der das tut, sollte als Hollywood-Berühmtheit gelten, oder?)

Eingang:

Ausgabe:

$ convert -resize 75x75 -fx "q=p.intensity;q<1/6?#0051BA:q<2/6?#C41E3A:q<3/6?#009e60:q<4/6?#ff5800:q<5/6?#FFD500:#FFF" Lenna.png LennaRubik.png

Ausgabe vergrößert:

Anmerkungen: Gemäß den imagemagick-Dokumenten kann eine Anweisung nicht mehr als einen bedingten Operator enthalten, der Aufruf scheint jedoch weiterhin einwandfrei zu funktionieren. Daher wurde dies wahrscheinlich behoben und die Dokumente wurden einfach nicht aktualisiert.

Laufende Identifizierung auf dem Ergebnisbild (um zu zeigen, dass die Farben in der Tat in Ordnung sind):

$ identify -verbose LennaRubik.png
  (...)   
  Colors: 6
  Histogram:
       338: (  0, 81,186) #0051BA srgb(0,81,186)
      1652: (  0,158, 96) #009E60 srgb(0,158,96)
      1187: (196, 30, 58) #C41E3A srgb(196,30,58)
      1674: (255, 88,  0) #FF5800 srgb(255,88,0)
       706: (255,213,  0) #FFD500 srgb(255,213,0)
        68: (255,255,255) #FFFFFF white
  (...)

Wenn Sie denken, Lenna zählt nicht zu den richtigen Prominenten, dann ist hier Bruce Willis:

Mathematica

Wir werden mit einer quadratischen Region aus einer US-Briefmarke mit Greta Garbo arbeiten. Es wird als bezeichnet j.

f[i_,rs_,m_:True]:=
Module[{(*rs=rastersize-4*)r={0.77,0.12,0.23},gr={0,0.62,0.38},b={0,0.32,0.73},o={1,0.35,0},y={1,0.84,0},w={1,1,1},
c1={r,gr,b,o,y,w},grayGreta,garboColors},
grayGreta=(*Reverse@*)ImageData[ColorQuantize[Rasterize[i,(*ImageResolution \[Rule]15*)RasterSize->rs+1,ImageSize->rs],6]];
garboColors=Union@Flatten[grayGreta,1];
ArrayPlot[grayGreta/.Thread[garboColors-> RGBColor@@@c1],
Mesh->If[m==True,{rs-1,rs-1},None],MeshStyle->Black]]

Die Funktion f akzeptiert 3 Parameter:

• i was sich auf das Bild bezieht
• rs, die Rastergröße
• mEine boolesche Variable, die angibt, ob Netzlinien verwendet werden sollen. (Die Standardeinstellung ist True).

Verwenden der Rastergrößen 15, 30, 45 und 75:

GraphicsGrid[{{f[j, 15], f[j, 30]}, {f[j, 45], f[j, 75]}}, ImageSize -> 800]

Ich kann mir nicht vorstellen, dass jemand den Würfel einer Rubrik mit so vielen Stücken macht! Trotzdem interessante Übung.

Mit Farben spielen

Dies ist aus einem früheren Eintrag. Der Code ist etwas anders. Graphicswird anstelle von verwendetArrayPlot . Wir verwenden auch den vollen Stempel, obwohl er nicht quadratisch ist.

Es gibt 6! = 720 Permutationen der Rubrikenfarben.

Im Folgenden wird das mittlere Bild der oberen Reihe angezeigt (stellen Sie 6 Bilder unten ein). Wenn die Graustufenwerte von dunkel bis hell angeordnet sind, sind die Farben {r, gr, b, o, y, w}. Andere Variationen funktionieren trotzdem.

i ist das Originalbild in Graustufen.

Graphics[Raster[(g=Reverse@ImageData[ColorQuantize[Rasterize[i,RasterSize->75],6]])
/.Thread[Union@Flatten[g,1]-> {{7,1,2},{0,6,4},{0,3,7},{10,4,0},{10,8,0},{10,10,10}}/10]]]

i ist das ursprüngliche Graustufenbild der vollständigen Greta Garbo-Marke.

Rasterize[garbo,RasterSize->75 Rastert das Bild in ein 75 x 75-Array.

ColorQuantize[<>, 6] reduziert die Graustufenwerte auf einen Satz von 6.

ImageDataRuft das Datenarray aus dem Bild ab. es kommt auf den Kopf.

Reverse Kippt das Datenfeld und damit das Bild mit der rechten Seite nach oben.

garboColors sind die 6 Graustufenwerte im quantisierten Bild.

Graphics[Raster zeigt das endgültige Bild an.

rubrikColors sind RGB-Werte der 6 Rubrik Würfelfarben.

Verschiedene Farbpermutationen von Rot, Grün, Blau, Orange, Gelb und Weiß sind angegeben.

r={0.77,0.12,0.23};gr={0,0.62,0.38};b={0,0.32,0.73};o={1,0.35,0};y={1,0.84,0};w={1,1,1};
c1={r,gr,b,o,y,w};
c2={r,b,gr,o,y,w};
c3={b,r,gr,o,y,w};
c4={gr,b,r,o,y,w};
c5={b,r,gr,y,o,w};

Und der Code:

grayGreta=Reverse@ImageData[ColorQuantize[Rasterize[i,RasterSize->75],6]];
garboColors=Union@Flatten[grayGreta,1];
Grid[{{i,
Graphics[Raster[grayGreta/.Thread[garboColors-> c1]]],
Graphics[Raster[grayGreta/.Thread[garboColors-> c2]]]},
{Graphics[Raster[grayGreta/.Thread[garboColors-> c3]]],
Graphics[Raster[grayGreta/.Thread[garboColors-> c4]]],
Graphics[Raster[grayGreta/.Thread[garboColors-> c5]]]}}]

Garbos in Hülle und Fülle

Hier sind 72 (von 720) Bildern von Greta Garbo, die die Würfelfarben der 6 Abschnitte verwenden. Manche Bilder funktionieren besser als andere, findest du nicht?

GraphicsGrid@Partition[(Graphics[Raster[grayGreta /. Thread[garboColors -> #]]] & 
/@ Take[Permutations[{r, gr, b, o, y, w}, {6}], 72]), 12]

Smalltalk (Smalltalk / X), 289 139 *

Eingabe: i; Ausgabe: r

r:=i magnifiedTo:75@75.
r colorMapProcessing:[:c||b|b:=c brightness.Color rgbValue:(#(16r0051BA 16rC41E3A 16r009e60 16rff5800 16rFFD500 16rFFFFFF)at:(b*6)ceiling)]

Eingang:

Ausgabe:

vergrößert:

(für alle Jugendlichen: das ist NICHT Madonna ;-)

[*] Ich habe die Vergrößerung nicht auf 75x75 (die erste Zeile) gezählt - hätte eine bereits veränderte Größe als Eingabe verwenden können. Hoffe das ist ok mit dir.

Postscript und TRUE Rubik Farben! ;-)

Nun, diese Lösung ist hier ein wenig unangebracht, da sie sich auf einen hochspezialisierten Bereich beschränkt. Aber nach viel Frust mit zB "Weird Numbers Question" (da ich nicht in der Lage war, etwas praktisch funktionierendes zu produzieren) entschied ich mich, etwas zu veröffentlichen und zog es so aus meinem Stapel von halbfertigen Skizzen heraus und machte es präsentabel.

Die Lösung nutzt die Tatsache aus, dass in der ersten Überarbeitung dieser Frage die erforderlichen Farben durch Verknüpfung mit einer Site definiert werden, in der eindeutig angegeben ist, dass Pantone (R) -Farben verwendet werden sollen und RGB-Farben nur Näherungswerte sind. Dann dachte ich, warum sollte ich Annäherungen machen, wenn ich echte Farben machen kann? - :)

10 dict begin
/Size 75 def
/Names  [(PMS 012C) (PMS 021C) (PMS 347C)   (PMS 200C)    (PMS 293C)   ] def
/Colors [[0 .16 1 0][0 .65 1 0][1 0 .39 .38][0 .9 .72 .28][1 .56 0 .27]] def
<</PageSize [Size dup]>> setpagedevice
Size dup scale
true setoverprint
(%stdin) (r) file 100 string readline pop 
(r) file <</CloseSource true>>/DCTDecode filter
0 1000000 string 
dup <</CloseTarget true>>/NullEncode filter 
{
    3 index 3 string readstring
    {
        4 -1 roll 1 add 4 1 roll
        {} forall
        0.11 mul exch 0.59 mul add exch 0.3 mul add cvi
        1 index exch write
    } {pop exit} ifelse
} loop
closefile
0 3 -1 roll getinterval
exch closefile
/data exch def
/n data length sqrt cvi def
1 1 Names length {
    /N exch def
    { 
        dup N Names length 1 add div gt 
            {N 1 add Names length 1 add div gt 
                {1} {0} ifelse} 
            {pop 1} 
        ifelse
    } settransfer
    [/Separation Names N 1 sub get /DeviceCMYK {
        Colors N 1 sub get 
        { 1 index mul exch } forall pop
    }] setcolorspace
    <<
        /ImageType        1
        /Width            n
        /Height           n
        /ImageMatrix      [n 0 0 n neg 0 n]
        /BitsPerComponent 8
        /Decode           [0 1]
        /DataSource       data
    >> image
} for
showpage
end

Dieser Code soll als zB gespeichert rubik.psund dann mit der üblichen Beschwörung an Ghostscript weitergeleitet werden:

gs -q -sDEVICE=psdcmyk -o out.psd rubik.ps

Es wartet dann in der nächsten Zeile auf die Eingabe des JPG-Dateinamens zB

kelly.jpg

Wenn alles gut geht, wird die Ausgabe in einer out.psdDatei gespeichert.

Die Eingabe muss im quadratischen RGB-JPEG-Format (beliebig groß) erfolgen, die Ausgabe erfolgt in PSD-Format mit Sonderfarbkanälen. Sie benötigen Photoshop, um die Datei anzuzeigen. Wenn Sie das GS-Gerät psdcmykauf ein anderes Gerät umstellen, wird nichts Nutzbares erzeugt. JPEG als Eingabe - weil der Postscript-Interpreter den Datenstrom direkt daraus decodieren kann. Quadratische Form - da das Programm sqrtdie Breite (und Höhe) des Bildes anhand der Länge der Zeichenfolge ermittelt.

Die ersten Zeilen definieren die Ausgabebildgröße (kann von Standard 75 geändert werden) und die Farbpalette (Farben und deren Anzahl können ebenfalls geändert werden). Alles andere ist nicht fest programmiert, denke ich.

Was ist los? Ein Strom von RGB-Triplets wird im laufenden Betrieb in eine Folge von Graustufenwerten konvertiert (mit einer einfachen Formel). Das übliche 8-Bit-Halbtonbildwörterbuch wird erstellt und verwendet, um 5 identische Bilder in 5 SeparationFarbräumen übereinander zu malen . Der Trick besteht darin, Übertragungsfunktionen vor jedem Aufruf des imageOperators anzuwenden . Beispiel: Bei gelber Farbe gibt diese Funktion 0 für Eingabewerte nur im Bereich von 0,167 bis 0,333 und 1 für andere Werte zurück.

Eingang:

Screenshot der in Photoshop geöffneten Ausgabe 75x75, 800% vergrößert:

Und Photoshop-Kanäle-Palette:

C #

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        unchecked
        {
            var t = new[] { 0xFFC41E3A, 0xFF009E60, 0xFF0051BA, 0xFFFF5800, 0xFFFFD500, 0xFFFFFFFF }.Select(v => Color.FromArgb((int)v)).ToArray();
            var o = new Bitmap(Bitmap.FromFile(args[1]));
            var m = double.Parse(args[0]);
            var r = Math.Min(m / o.Width, m / o.Height);
            var w = (int)(o.Width * r);
            var h = (int)(o.Height * r);

            o = new Bitmap(o, w - (w % 3), h - (h % 3));
            for (int y = 0; y < o.Height; y++)
                for (int x = 0; x < o.Width; x++)
                    o.SetPixel(x, y, N(o.GetPixel(x, y), t));
            o.Save(args[2], ImageFormat.Png);
        }
    }

    static Color N(Color c, Color[] t)
    {
        return t.OrderBy(v => Math.Abs(W(v) - W(c))).First();
    }

    static double W(Color c)
    {
        return .11 * c.B + .59 * c.G + .30 * c.R;
    }
}

Sie müssen es mit 3 Parametern ausführen:

foo.exe 75 d:\test.jpg d:\out.png

Wo 75ist max. width / height d:\test.jpgist die Eingabedatei und d:\out.pngdie Ausgabedatei.

Ausgabe für verschiedene Bilder in diesem Wettbewerb:

Meine eigene Berühmtheit:

Ausgabe:

Andere Größen (größer als 75 x 75) führen jedoch zu besseren Bildern:

Und wenn wir bei den Präsidenten bleiben:

Da dies kein (mehr?) Codegolf ist, habe ich mich nicht darum gekümmert, den Code zu stark zu "minimieren". Da in den Anweisungen nicht ausdrücklich erwähnt wurde, dass das Bild die gleiche Breite wie die Höhe (Quadrat) haben muss, habe ich mich nicht darum gekümmert, es zu beschneiden. Ich tun , aber sicher, dass das Bild ein Vielfaches von 3 Pixel breit / hoch. Wenn Sie quadratische Bilder wünschen, verwenden Sie quadratische Eingaben . Der Algorithmus ist alles andere als optimal.

Ein paar mehr (da die Leute Hot Chicks / Internet Heroes mehr befürworten )

Brainfuck

++++[->+[,.----------]<]>>>>---->->++++++++++>>------------>+++>+++>--
--->++++++[->+++++<]---->+[-<+++++++<+++<+++++<+++<+++<++++++<++++++<+
<++>>>>>>>>>]<[<]<<,+[,<++++++>[>++++++[->+++++++<]>+[<<[->]>[<]>-]<<<
->]+<[-[-[-[-[[-].>>>>>>>>.<.<<<<<<-<]>[->>>>>[.<]<<]<]>[-.>>>[>]<<<.<
.[<]<<]<]>[--.+>>>[>]<<.[<].<<]<]>[--.+>>>[>]<.[<].<<]<]>[--...+],,+]

Dies erfordert einen BF-Interpreter / Compiler, der -1 als EOF hat und der mehr als 8-Bit-Zellen hat, WENN eines der roten Pixel 255 ist. Andernfalls wird es vorzeitig beendet, da es nicht in der Lage sein wird, zwischen EOF und Wert 0xFF zu unterscheiden . Mit jitbf haben Sie alles, was die Maschine als Ganzzahl hat, und können dies tun, um -1 als EOF zu erzwingen:

jitbf --eof -1 rubiks.bf < angelina.pnm > angelina-rubix.pnm

Das gerenderte Bilddateiformat ist die vollständige RGB-PNM-Datei (P6), roh als Option in Gimp.

Es wird nur der grüne Kanal verwendet (eine der vielen Möglichkeiten, ein Farbbild in Graustufen umzuwandeln). Der Wert wird um 43 verringert, ohne dass der Wert unter Null verringert wird, um herauszufinden, welche Rubiks-Farbe verwendet werden soll, und ein Schalter gibt die richtige RBG-Farbe aus, die entspricht.

Bild von Angelina Jolie von Hackers (1995) auf 75x75 verkleinert und mit der Applikation verarbeitet:

Gleiche, nur ich habe die Originalgröße verwendet :

Und da ich hellsichtig bin, ist hier auch ein Präsident:

Ziel c

Ich habe diese Herausforderung letzte Nacht gesehen und hatte eine etwas verwirrende Zeit damit -[NSArray indexOfObject:inSortedRange:options:usingComparator:], daher die Verzögerung.

- (UIImage  *)rubiksImage:(UIImage *)inputImg
{
    //Thank you http://stackoverflow.com/a/11687434/1153630 for the greyscale code
    CGRect imageRect = CGRectMake(0, 0, inputImg.size.width, inputImg.size.height);

    int width = imageRect.size.width;
    int height = imageRect.size.height;

    uint32_t *pixels = (uint32_t*)malloc(width * height * sizeof(uint32_t));

    memset(pixels, 0, width * height * sizeof(uint32_t));

    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    CGContextRef context = CGBitmapContextCreate(pixels, width, height, 8, width * sizeof(uint32_t), colorSpace, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedLast);

    CGContextDrawImage(context, imageRect, [inputImg CGImage]);

    const int RED = 1;
    const int GREEN = 2;
    const int BLUE = 3;

    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            uint8_t* rgbaPixel = (uint8_t*)&pixels[y * width + x];
            uint32_t grayPixel = 0.3 * rgbaPixel[RED] + 0.59 * rgbaPixel[GREEN] + 0.11 * rgbaPixel[BLUE];

            NSArray *r = [self rubixColorFromGrey:grayPixel];

            rgbaPixel[RED] = [r[2] integerValue];
            rgbaPixel[GREEN] = [r[1] integerValue];
            rgbaPixel[BLUE] = [r[0] integerValue];
        }
    }

    CGImageRef newCGImage = CGBitmapContextCreateImage(context);

    CGContextRelease(context);
    CGColorSpaceRelease(colorSpace);
    free(pixels);

    UIImage* newUIImage = [UIImage imageWithCGImage:newCGImage];

    CGImageRelease(newCGImage);

    return newUIImage;
}

- (NSArray *)rubixColorFromGrey:(uint32_t)p
{
    NSArray *colors = @[@0, @51, @102, @153, @204, @255];

    NSUInteger index = [colors indexOfObject:@(p)
                               inSortedRange:NSMakeRange(0, colors.count)
                                     options:NSBinarySearchingInsertionIndex | NSBinarySearchingFirstEqual
                             usingComparator:^(id a, id b) {
                                return [a compare:b];
                             }];
    switch (index) {
        case 0:
            return rgb(0, 81, 186);
            break;
        case 1:
            return rgb(196, 30, 58);
            break;
        case 2:
            return rgb(0, 156, 96);
            break;
        case 3:
            return rgb(255, 82, 0);
            break;
        case 4:
            return rgb(255, 213, 0);
            break;
        case 5:
            return rgb(255, 255, 255);
            break;

        default:
            break;
    }

    return colors; //go wild
}

NSArray *rgb(int r, int g, int b)
{
    return @[@(r), @(g), @(b)];
}

Ich habe es auf meinem iPad so ausgeführt:

UIImageView *img = [[UIImageView alloc] initWithImage:[self rubiksImage:[UIImage imageNamed:@"danny.png"]]];
[img setCenter:self.view.center];
[self.view addSubview:img];

Vorher Nachher

Vorher Nachher

Python

Format: python rubik.py <input> <max_cubes> <output> .

Wandelt Pixel in Graustufen um, indem der vorgeschlagene Algorithmus verwendet wird.

import Image, sys

def rubik(x, max_cubes = 25):

    img = x
    max_cubes *= 3

    if x.size[0] > max_cubes or x.size[1] > max_cubes:

        print "Resizing image...",

        if x.size[0] > x.size[1]:
            img = x.resize((max_cubes, int(max_cubes * float(x.size[1]) / x.size[0])), Image.ANTIALIAS)
        else:
            img = x.resize((int((max_cubes * float(x.size[0]) / x.size[1])), max_cubes), Image.ANTIALIAS)

    if x.size[0] % 3 or x.size[1] % 3:
        print "Sizes aren't multiples of 3"
        return

    print "Image resized to %i x %i pixels" % img.size

    out = Image.new('RGB', img.size)

    print "Converting image...",

    for x in xrange(out.size[0]):
        for y in xrange(out.size[1]):
            r, g, b = img.getpixel((x, y))
            if r == g == b == 255:
                out.putpixel((x,y), (255, 255, 255))
            else:
                l = 0.2126 * r + 0.7152 * g + 0.0722 * b
                l /= 255
                out.putpixel((x,y), (
                        (0x00, 0x51, 0xBA),
                        (0xC4, 0x1E, 0x3A),
                        (0x00, 0x9E, 0x60),
                        (0xFF, 0x58, 0x00),
                        (0xFF, 0xD5, 0x00)
                    )[int(5 * (l <= 0.0031308 and 12.92 * l  or 1.055 * l ** (1/2.4) - 0.055))])

    print "Image converted successfully."

    print "Stats:"
    h, v = img.size[0] / 3, img.size[1] / 3
    print "   ", h, "horiz. Rubik cubes"
    print "   ", v, "vert. Rubik cubes"
    print "   ", h * v, "total Rubik cubes"

    return out.resize((out.size[0], out.size[1]))

if __name__ == "__main__":
    rubik(Image.open(sys.argv[1]).convert("RGB"), int(sys.argv[2])).save(sys.argv[3])

Eingang:

_{(Quelle: ilmamilio.it )}

Ausgabe mit max_cubes = 25:

Ausgabe mit max_cubes = 75:

Ausgabe mit max_cubes = 225: