作为魔方和酷艺术的忠实拥护者，我一直在努力将两者结合起来以做一些非常酷的事情。从根本上解决微型魔方的多维数据集以形成魔方艺术形式的基本像素。可以通过以下链接查看此类艺术品的示例：http : //google.com/search?q=rubik%27s+cube+ art

现在，此Code Golf的目的是创建接受图像作为输入的代码，然后按以下方式进行转换：

图像最初被还原为网络安全的灰度颜色。这背后的原因是因为我们需要隔离网络安全的灰度调色板（即000000、333333、666666、999999，CCCCCC和FFFFFF）。有关比色法转换为灰度的方法的算法，请访问：http : //en.wikipedia.org/wiki/Grayscale#Colorimetric_.28luminance-preserving.29_conversion_to_grayscale，如果您希望以此为灵感。

然后可以将灰度渲染为适当的颜色。快速分解：000000表示Rubik的蓝色，333333表示Rubik的红色，666666表示Rubik的绿色，999999表示Rubik的橙色，CCCCCC表示Rubik的黄色，FFFFFF表示Rubik的白色。

我希望您生成的代码可以从照片的调色板直接呈现为Rubik的颜色。从转换为网络安全的灰度然后再转换为相应的Rubik调色板的两阶段方法只是为了使您了解该过程背后的逻辑，但是，如果您更轻松地做到这一点，则可以这样做。

Rubik调色板的实际RGB值必须符合以下条件：

• 红色：＃C41E3A
• 绿色：＃009E60
• 蓝色：＃0051BA
• 橙色：＃FF5800
• 黄色：＃FFD500
• 白色：#FFFFFF

举一个例子，我从下图裁剪了亚伯拉罕·林肯的头像：，并渲染了算法以产生以下内容：

网格在那里，您可以看到如何配置每个单独的微型Rubik立方体以组成图像。生成的图像的真实大小为45像素乘45像素，这意味着（45/3）*（45/3）= 15 * 15 = 225微型Rubik立方体将用于制作此图像。我不希望您像我一样用网格显示结果图像。

所以这是必需的：

1. 此算法要处理的图像必须为x像素宽x y像素高，以使x和y为3的倍数。这有助于简化作为Rubik立方体镶嵌的一部分进行渲染的过程。如果图像很大，建议在处理之前将其缩小到45 x 45至75 x 75左右。请记住，此调整大小组件是可选的。

2. 需要将图像转换为六色魔方的调色板，以创建马赛克。

3. 处理后，生成的图像必须是有效的图形文件。为了证明您的代码有效，请将其与美利坚合众国总统之一或好莱坞著名名人的形象进行对比。在我的示例中，我已经使用过亚伯拉罕·林肯，因此不再可以使用此总裁。确保提供您使用的语言，字节数以及用于测试代码的主席/名人，包括拍摄前后。

4. 每个条目都必须有一个唯一的总裁/名人作为测试用例。我不会重复。这将确保重复的结果不会用于测试不同的代码条目。可以说您的代码有效，这是另一回事。

5.最短的代码获胜。

我正在将其更改为一场人气竞赛...我宁愿看看谁能做到而不必在字节数上进行竞争...因此，我将在2014年2月28日之后颁发这笔赏金。

Imagemagick（108）

版本：ImageMagick 6.8.7-7 Q16 x86_64 2013-11-27

以下调用：

$ 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

输入和输出文件名的位置input和output必须修改。

我只计算了-resize和之间的字符#FFF"，如果您认为这是无效的，请随时发表评论。

我用琳娜（Lenna）作为形象（她出现在《花花公子》中，任何这样做的人都应该算作好莱坞名人，对吧？）

输入：

输出：

$ 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

输出扩大：

注意：根据imagemagick文档，您在一条语句中不能有多个条件运算符，但是该调用似乎仍然可以正常工作，因此可能此问题已解决，文档并未更新。

在结果图像上运行识别（显示颜色确实很好）：

$ 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
  (...)

如果您认为莱纳（Lenna）不算是应有的名流，那么这里就是布鲁斯·威利斯（Bruce Willis）：

Mathematica

我们将处理带有Greta Garbo的美国邮票中的正方形区域。称为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]]

函数f具有3个参数：

• i 指的是图像
• rs，栅格大小
• m，是一个布尔变量，用于指定是否应使用网格线。（默认设置为True）。

使用15、30、45和75的栅格大小：

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

我无法想象会有这么多人用一块魔方来制造魔方！尽管如此，有趣的练习。

玩转颜色

这来自早先的条目。代码略有不同。 Graphics用于代替ArrayPlot。另外，即使它不是正方形，我们也会使用完整的图章。

Rubrik多维数据集颜色有6！= 720个排列。

下面显示上一行的中心图像（下面设置6张图像）。当灰度值从最暗到最浅排列时，颜色为{r，gr，b，o，y，w}。尽管如此，其他变体仍然有效。

i 是灰度的原始图像。

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 是完整的Greta Garbo邮票的原始灰度图像。

Rasterize[garbo,RasterSize->75 将图像光栅化为75 x 75阵列。

ColorQuantize[<>, 6] 将灰度值减少到6。

ImageData从图像中检索数据数组；它倒过来了。

Reverse 翻转数据数组，因此图片正面朝上。

garboColors 是量化图像中的6个灰度值。

Graphics[Raster 显示最终图像。

rubrikColors 是6个Rubrik立方体颜色的RGB值。

给出了红色，绿色，蓝色，橙色，黄色和白色的各种颜色排列。

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};

和代码：

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]]]}}]

嘉宝嘉豪

这是使用6种Rubrik多维数据集颜色的Greta Garbo的72张照片（共720张）。有些图像比其他图像效果更好，您不觉得吗？

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

Smalltalk（Smalltalk / X），289139 *

输入：i; 输出：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)]

输入：

输出：

放大：

（对于所有年轻人：这不是麦当娜;-)

[*]我尚未将放大倍数计算为75x75（第一行）-可以使用已经调整大小的输入。希望你能接受。

后记和TRUE Rubik颜色！;-)

嗯，此解决方案在这里有点偏离主题，因为它局限于某些高度专业化的领域。但是，在对“奇怪的数字问题”（无法产生实际可行的东西）感到无奈之后，我决定发表一些东西，因此将其从我的半成品涂鸦中剔除，使其可以展示。

该解决方案利用了一个事实，即该问题的第一个修订版通过链接到站点来定义所需的颜色，其中明确指出要使用Pantone（R）颜色，而RGB颜色仅是近似值。然后我想，为什么我可以做近似色，而我可以做真正的颜色？-：）

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

此代码将另存为，例如rubik.ps，然后以通常的方式将其馈送到Ghostscript：

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

然后，它在下一行等待您输入JPG文件名，例如

kelly.jpg

如果一切顺利，则将输出保存到out.psd文件中。

输入必须是方形RGB JPEG（任何大小），输出是具有专色通道的PSD。您将需要Photoshop来查看文件。将GS设备从更改psdcmyk为其他任何设备都将无法使用。JPEG作为输入-因为后记解释器可以直接解码来自其中的数据流。方形-因为程序依靠sqrt字符串长度来查找图像的宽度（和高度）。

第一行定义输出图像的大小（可以从默认值75更改）和调色板（颜色及其编号也可以更改）。我认为其他任何事情都不是硬编码的。

这是怎么回事？RGB三元组流被快速转换为灰度值字符串（具有简单的公式），并建立了常用的8位连续色调图像字典，并用于在5个Separation颜色空间中将5个相同的图像彼此绘制。诀窍是在每次调用image运算符之前应用传递函数。例如，对于黄色油漆，此函数仅针对输入值在0.167 .. 0.333范围内的值返回0，否则返回1。

输入：

在Photoshop中打开的输出75x75的屏幕截图，放大了800％：

和Photoshop通道调色板：

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;
    }
}

您需要使用3个参数运行它：

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

哪里75是最大。宽度/高度，d:\test.jpg是输入文件，d:\out.png是输出文件。

此竞赛中各种图像的输出：

我自己的名人：

输出：

但是，其他尺寸（大于75x75）也会产生更好的图像：

而且，如果我们坚持使用总统：

由于这不是（更长的？）代码高尔夫，所以我不必费心“最小化”代码。另外，由于说明中没有特别提及，图像的宽度必须与高度（正方形）相同，所以我不会为裁剪而烦恼。我这样做，但要确保图像是3个像素宽/高的多。如果要使用正方形图像，请使用正方形输入。该算法远非最佳。

更多一些（因为人们更多支持热门小鸡/网络英雄）

脑干

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

这需要一个BF解释器/编译器，其EOF值为-1，并且如果红色像素之一为255，则其具有高于8位的单元。否则它将停止过早，因为它将无法在EOF和值0xFF之间进行区别。使用jitbf，您可以拥有机器具有的整数大小，并且可以强制-1作为EOF：

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

渲染的图像文件格式是完整的RGB PNM文件（P6），原始是Gimp中的选项。

它仅使用绿色通道（这是将彩色图像转换为灰度的多种方法之一）。它将值减少43，而不会将值减少到零以下，以找出要使用的颜色，并具有一个开关，可以打印出对应的正确RBG颜色。

来自Hackers（1995）的Angelina Jolie的图像缩小到75x75，并通过以下应用程序进行了处理：

一样，只有我用了原始尺寸：

而且由于我很通情达理，所以也有一位总统：

目标C

昨晚我看到了这个挑战，并且与之度过了那么一点混乱的时间-[NSArray indexOfObject:inSortedRange:options:usingComparator:]，因此拖延了。

- (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)];
}

我像这样在iPad上运行它：

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

之前 之后

之前 之后

蟒蛇

格式：python rubik.py <input> <max_cubes> <output>。

使用建议的算法将像素转换为灰度。

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])

输入：

_{（来源：ilmamilio.it）}

输出max_cubes = 25：

输出max_cubes = 75：

输出max_cubes = 225：