Entrada

O nome de um arquivo no formato gráfico de varredura de sua escolha. O formato escolhido deve suportar pelo menos 8 bits por canal e 3 canais.

Resultado

Um arquivo no mesmo formato, com as mesmas dimensões e pixels que o primeiro, mas cujos pixels são agrupados em ordem decrescente do número de vezes que ocorrem, classificados da esquerda para a direita, de cima para baixo.

• Se certas cores de pixels aparecerem o mesmo número de vezes, a ordem delas não será especificada.
• Você não deve sobrescrever o arquivo de entrada (use um nome de arquivo diferente para a saída).
• Toda e qualquer biblioteca de processamento de imagens de terceiros é permitida.

Exemplo

Produzirá resultados semelhantes a:

Especialmente nas partes inferiores da imagem, algumas variações podem ocorrer, devido a diferentes rompimentos entre cores de igual frequência.

J, 94 81 bytes

Uma função que pega o nome de um arquivo PNG (sem canal de transparência) e grava o resultado no nome do arquivo de entrada precedido por "o".

f=.3 :0
load'graphics/png'
(($a)$#/|:\:~(#,{.)/.~,a=.readpng y)writepng'o',y
)

Método

• Crie uma lista de todos os números de cores e o número de aparências
• Classifique a lista pelo número de aparências
• Multiplique cada número de cor igual às suas aparências
• Remodelar a nova lista para a forma da imagem original

Mathematica, 125 123 bytes

Export["a"<>#,i=ImageData@Import@#;Image@ArrayReshape[Join@@ConstantArray@@@SortBy[Tally[Join@@i],-Last@#&],Dimensions@i]]&

Isso define uma função sem nome que pega o nome do arquivo em qualquer formato de imagem comum e grava o resultado no arquivo com o mesmo nome, mas anexado a. O resultado parece um pouco diferente do OP, já que o Mathematica SortByquebra os vínculos por ordem de classificação padrão, portanto, os bits inferiores onde ocorrem gravatas parecem um pouco mais organizados:

A implementação em si é realmente direta:

• ImageData para obter uma grade de valores de cores.
• Join para achatar a matriz.
• Tally para contar a ocorrência de cada cor.
• SortBy[...,-Last@#&] para classificar por frequências do mais alto para o mais baixo.
• ConstantArraye Joinexpandir os cálculos novamente.
• ArrayReshapepara recuperar a forma da imagem original (obtida com Dimensions).
• Image para converter os dados novamente em um objeto de imagem.

FYI, 22 bytes são usados ​​no arquivo E / S. Uma versão equivalente que pega e retorna um objeto de imagem chega em 103 bytes:

(i=ImageData@#;Image@ArrayReshape[Join@@ConstantArray@@@SortBy[Tally[Join@@i],-Last@#&],Dimensions@i])&

Python2 / PIL, 244 226 225 223 222 202 186 182 170 159

from PIL.Image import*
s=raw_input();i=open(s);g=list(i.getdata());i.putdata(sum([[c[1]]*-c[0]for c in sorted((-g.count(r),r)for r in set(g))],[]));i.save(2*s)

Changelog

<p><b>Edit 1:</b> saved 18 bytes with new algorithm.</p>
<p><b>Edit 2:</b> saved 1 byte with remembering that Python 2 has int division without <code>from __future__ import division</code>. Whoops.</p>
<p><b>Edit 3:</b> saved 2 bytes by swapping <code>cmp</code> for <code>key</code>.</p>
<p><b>Edit 4:</b> saved 1 byte by clever unpacking. <code>w=i.size[0]</code> -> <code>w,h=i.size</code></p>
<p><b>Edit 5:</b> moved <code>list()</code> to an earlier position, drastically improving runtime. No length change.</p>
<p><b>Edit 6:</b> saved 20 bytes by remembering that there is also sequence sorting in Python. Probably slower, but also produces images more like the the Mathematica one.</p>
<p><b>Edit 7:</b> saved 16 bytes by changing <code>putpixel</code> to a list and <code>putdata</code>. Under 200!</p>
<p><b>Edit 8:</b> saved 4 bytes by changing <code>range(...)</code> to <code>...*[0]</code> since we don't need the values.</p>
<p><b>Edit 9:</b> saved 12 bytes by converting the <code>for</code> loop to a <code>sum</code>.</p>
<p><b>Edit 10:</b> saved 11 bytes by noticing that the image size doesn't matter anymore (since edit 7). Whoops v2.0.</p>

Versão mais curta por stokastic , 123

from PIL.Image import*
s=raw_input();i=open(s);d=list(i.getdata());i.putdata(sorted(d,key=lambda D:d.count(D)));i.save(2*s)

Bem, vamos pelo menos tentar, mesmo que já esteja vencido.

É extremamente lento, o Panda processado por vários minutos no meu laptop.

Salva com um nome de arquivo com o nome do arquivo original repetido duas vezes.

Python, 1197 bytes

# -*- coding: utf-8 -*-
from __future__ import division
from collections import Counter
import png
from sys import argv,exit
script,file_name,output_file_name=argv
def group(s,n):
    return zip(*[iter(s)]*n)
def flatten(list_of_lists):
    result=[]
    for lst in list_of_lists:
        result.extend(lst)
    return result
def group_list(old_list,tuples_per_list):
    new_list=[]
    i=1
    appended_row=[]
    for item in old_list:
        appended_row.extend(flatten([item]))
        if i==tuples_per_list:
            new_list.append(appended_row)
            i=1
            appended_row=[]
        else:
            i+=1
    return new_list
input_image=png.Reader(file_name)
image_data=input_image.read()
width=image_data[0]
height=image_data[1]
pixels=list(image_data[2])
if image_data[3]["alpha"]:
    ints_per_colour=4
elif image_data[3]["greyscale"]:
    ints_per_colour=2
else:
    ints_per_colour=3
colours=Counter(colour for row in pixels for colour in group(row,ints_per_colour)).most_common()
pixel_list=flatten([element]*count for element,count in colours)
ordered_rows=group_list(pixel_list,width)
f=open(output_file_name,"wb")
png_object=png.Writer(width,height,greyscale=image_data[3]["greyscale"],alpha=image_data[3]["alpha"])
png_object.write(f,ordered_rows)
f.close()

O pngmódulo que eu usei .

C # 413

Programa completo. Passe o nome do arquivo na linha de comando, a saída será salva no mesmo formato do arquivo "o".

Não usando alguns recursos interessantes do linq, como SelectMany e Enumerable.Range, pois o programa seria mais limpo, mas mais longo.

using System.Collections.Generic;using System.Linq;using System.Drawing;
class P{
static void Main(string[]a){
var d=new Dictionary<Color,int>();var b=new Bitmap(a[0]);
int n,x,y,w=b.Width,h=b.Height;
for (x=w;x-->0;)for(y=h;y-->0;){var p=b.GetPixel(x,y);d[p]=d.ContainsKey(p)?d[p]+1:1;}
y=h;foreach(var q in d.OrderBy(v=>v.Value)){for(n=q.Value;n-->0;){
if(x<=0){x=w;--y;}b.SetPixel(--x, y, q.Key);}}b.Save("o");
}}

Formatação legível, cortesia do VS2010

using System.Collections.Generic;
using System.Linq;
using System.Drawing;

class P
{
    static void Main(string[] a)
    {
        var d = new Dictionary<Color, int>();
        var b = new Bitmap(a[0]);
        int n,x,y,w = b.Width, h=b.Height;

        for (x = w; x-- > 0;)    
            for (y = h; y-- > 0;)
            {
                var p = b.GetPixel(x, y);
                d[p] = d.ContainsKey(p) ? d[p]+1 : 1;
            }
        y = h;
        foreach (var q in d.OrderBy(v => v.Value))
        {
            for (n = q.Value; n-- > 0; )
            {
                if (x <= 0)
                {
                    x = w;
                    --y;
                 }
                 b.SetPixel(--x, y, q.Key);
            }
        }
        b.Save(a[0]+".");
    }
}

Python 2: 191 bytes

Aqui está a minha tentativa. Imaginei que poderia economizar algum espaço usando Counter, mas não acabou tão pequeno quanto a resposta de Pietu1998.

from collections import Counter
from PIL import Image
i=Image.open(raw_input())
s=reduce(lambda x,y:x+y,map(lambda(a,b):[a]*b,Counter(i.getdata()).most_common()))
i.putdata(s)
i.save("o.png")

Saída do Panda