Za pomocą Algodoo i Paint wykonałem te sześć monochromatycznych obrazów o wymiarach 300 × 300 i czterech wygodnych kształtach:

Ta klasa obrazów ma następujące właściwości:

• Są one zawsze w rozmiarze 300 × 300 pikseli, monochromatyczne (tylko czarno-białe) i mają dokładnie cztery białe obszary odpowiadające kwadratowi, okręgowi, trójkątowi i zębatce.
• Kształty nigdy się nie nakładają ani nie dotykają się, ani nie dotykają obramowania obrazu ani nie wychodzą poza granice.
• Kształty zawsze mają ten sam rozmiar, ale można je dowolnie obracać i ustawiać.

(Kształty mają również równe obszary, chociaż przy takim rastrowaniu ich liczba pikseli prawdopodobnie nie będzie dokładnie równa.)

Wyzwanie

Napisz najkrótszy możliwy program lub funkcję, która pobierze nazwę pliku takiego obrazu i zamieni wszystkie białe piksele ...

• czerwony, (255, 0, 0)jeśli są na kwadracie.
• niebieski, (0, 0, 255)jeśli są w kole.
• zielony, (0, 255, 0)jeśli są w trójkącie.
• żółty, (255, 255, 0)jeśli są na biegu.

na przykład

Detale

Twój program powinien działać skutecznie dla wszystkich możliwych obrazów wejściowych. (Wprowadzone zostaną tylko prawidłowe obrazy monochromatyczne 300 × 300). Sześć obrazów, które przedstawiłem, są jedynie przykładami, możesz nie zakodować na stałe ich wyników w swoim programie.

Nie wolno używać bibliotek lub funkcji komputerowych, wbudowanych ani zewnętrznych. Chodzi o to, aby to zrobić za pomocą własnych operacji na poziomie pikseli. Możesz użyć bibliotek obrazów, które po prostu pozwalają otwierać i modyfikować obrazy (np. PIL dla Pythona).

Możesz używać dowolnych popularnych bezstratnych formatów plików obrazu do wprowadzania i wyprowadzania, o ile trzymasz się schematu kolorów.

Możesz pobrać nazwę pliku obrazu jako argument funkcji, ze standardowego wejścia lub z wiersza poleceń. Obraz wyjściowy można zapisać w nowym pliku, tym samym pliku lub po prostu wyświetlić.

Punktacja

Zgłoszenie z najmniejszą liczbą bajtów wygrywa. Mogę przetestować zgłoszenia za pomocą dodatkowych zdjęć, aby ustalić ich ważność.

J - 246,224 185 bajtów

load'viewmat'
(viewmat~0,(255*4 3$_2|.#:3720)/:/:@(<([:}.(>./%+/%#)@:(+/&:*:@(-"1)+/%#)@(4$.$.@:=)&>)<"0@~.@,))@(~.@,i.])@(>./**@{.)@((0,(,-)#:>:i.3)&|.)^:_@(*i.@:$)@(0<readimg_jqtide_)

To była świetna zabawa!

Ponownie wykorzystałem część połączonych komponentów, której użyłem do wyzwania „Jestem w największym pokoju” , i zastosowałem stosunek między średnią a maksymalną odległością wszystkich punktów do centrum każdego komponentu. Postawiłem na to, ponieważ jest ona niezmienna zarówno pod względem skali, jak i rotacji, i najwyraźniej wystarczająco dobra, aby rozróżnić kształty, które zostały podane. Ranking tej wartości od niskiej do wysokiej daje mi koło zamówienia, koło zębate, kwadrat i trójkąt, używane do permutacji mapy kolorów.

Wyświetla wynik za pomocą dodatku viewmap. Nie użyto żadnych przyborników oprócz odczytu i wyjścia plików.

Wytrzymałość nie wydaje się być wymogiem, to usuwa 18 bajtów. 2 więcej niepotrzebne przestrzenie zastąpione &.>przez &>w ratioa &.:o &:w dcent przez kolejne 2 bajty.

Ogromny wzrost zarówno krótkości, jak i wydajności compdzięki zmianie biegów zamiast cut( ;.). W ten sposób obraz jest replikowany i przesuwany we wszystkich 8 kierunkach zamiast skanowania go za pomocą okna 3x3.

Ta idfunkcja była absurdalnie skomplikowana pod względem tego, co musiała zrobić. Teraz przypisuje identyfikatory do pikseli w obiektach poprzez pomnożenie obrazu przez tablicę unikalnych liczb, a tym samym ustawienie BG na zero.

Kod nieco bardziej wyjaśniony:

load'viewmat'                                 NB. display only
imnames =: < ;. _2 (0 : 0)
C6IKR.png
DLM3y.png
F1ZDM.png
Oa2O1.png
YZfc6.png
chJFi.png
)

images =: (0<readimg_jqtide_) each imnames    NB. read all images in boxed array

id =: *i.@:$                                  NB. NB. assign one number to each non-background (non-zero) pixel
comp =: (>./ * *@{.)@shift^:_@id              NB. 8 connected neighbor using shift
  shift =: (>,{,~<0 _1 1)&|.                  NB. generate the original, and 8 shifted versions (automatically padding and cropping).
result =: comp each images                    NB. Execute comp verb for each image
col =: (~.@, i. ])                            NB. Color: give each component and BG a separate color.

NB. BG in 0, 0 Get all max distance to center % mean distance to center ratios
ratio  =: (< ([:}.rat@:dcent@getInd &>)  <"0@~.@,)
  getInd =: 4 $. $.@:=                        NB. get indices for component y in array x
  dcent  =: +/&.:*:@(-"1) +/%#                NB. distence from center each point
  rat    =: >./ % +/%#                        NB. ratio from distances

cm=: (255*4 3$_2|.#:3720)                     NB. colormap (except black).
(viewmat~ 0,cm /: /:@ratio )@col each result  NB. for each image, show the result, permuting the colormap according to ratio's

NB. almostgolf this
P1 =: (>./**@{.)@((0,(,-)#:>:i.3)&|.)^:_@(*i.@:$)@(0<readimg_jqtide_) NB. reading till components
P2 =: (<([:}.(>./%+/%#)@:(+/&:*:@(-"1)+/%#)@(4$.$.@:=)&>)<"0@~.@,) NB. recognition: get fraction mean vs max distance to center per component, toss BG.     
P3 =: (viewmat~0,(255*4 3$_2|.#:3720)/:/:@P2)@(~.@,i.])@P1    NB. piece together : permute colormap, display components

NB. seriousgolf
load'viewmat'
f =:(viewmat~0,(255*4 3$_2|.#:3720)/:/:@(<([:}.(>./%+/%#)@:(+/&:*:@(-"1)+/%#)@(4$.$.@:=)&>)<"0@~.@,))@(~.@,i.])@((>./**@{.)@shift^:_)@(*i.@:$)@(0<readimg_jqtide_)
NB. example usage:
f&> imnames NB. do for all images

Ten jest nieco długi, aby szczegółowo wyjaśnić, ale zrobi to, jeśli będzie zainteresowanie.

Mathematica, 459 392 bajtów

f=(d=ImageData@Import@#/.{a_,_,_}:>a;(For[a={};b={#&@@d~Position~1},b!={},c=#&@@b;b=Rest@b;d[[##&@@c]]=0;a~AppendTo~c;If[Extract[d,c+#]==1,b=b⋃{c+#}]&/@{e={1,0},-e,e={0,1},-e}];m=1.Mean@a;m=#-m&/@a;n=Count[Partition[Norm/@SortBy[m,ArcTan@@#&],300,1,1],l_/;l[[150]]==Max@l];(d[[##&@@#]]=Round[n^.68])&/@a)&/@Range@4;Image[d/.n_Integer:>{{0,0,0},,{0,1,0},{1,0,0},,,,{1,1,0},{0,0,1}}[[n+1]]])&

Nie golfowany:

f = (
 d = ImageData@Import@# /. {a_, _, _} :> a;
 (
    For[a = {}; b = {# & @@ d~Position~1},
     b != {},
     c = # & @@ b;
     b = Rest@b;
     d[[## & @@ c]] = 0;
     a~AppendTo~c;
     If[Extract[d, c + #] == 1, 
        b = b ⋃ {c + #}] & /@ {e = {1, 0}, -e, e = {0, 1}, -e}
     ];
    m = 1. Mean@a; m = # - m & /@ a;
    n = 
     Count[Partition[Norm /@ SortBy[m, ArcTan @@ # &], 300, 1, 1], 
      l_ /; l[[150]] == Max@l];
    (d[[## & @@ #]] = Round[n^.68]) & /@ a
    ) & /@ Range@4;
 Image[d /. 
   n_Integer :> {{0, 0, 0}, , {0, 1, 0}, {1, 0, 0}, , , , {1, 1, 
       0}, {0, 0, 1}}[[n + 1]]]
) &

Mógłbym zaoszczędzić 6 bajtów, zamieniając się m=1.Mean@a;m=#-m&/@a;w m=#-Mean@a&/@a;, ale to znacznie skraca czas wykonania, co jest denerwujące dla testowania. (Zauważ, że są to dwie optymalizacje: wyciągnięcie obliczenia Mean@apoza pętlą i użycie dokładnych typów symbolicznych zamiast liczb zmiennoprzecinkowych. Co ciekawe, użycie dokładnych typów jest o wiele bardziej znaczące niż obliczanie średniej w każdej iteracji.)

To jest podejście numer trzy:

• Wykryj obszary przez zalanie.
• Znajdź przybliżone centrum każdego obszaru, uśredniając wszystkie współrzędne pikseli.

• Teraz dla wszystkich pikseli w kształcie wykreślmy odległość od kąta względem kąta do tego środka:

  

  Trójkąt ma 3 wyraźne maksima, kwadrat 4, koło zębate 16, a koło ma tony, ze względu na aliasing wahań wokół stałego promienia.

• Znajdujemy liczbę maksimów, patrząc na plasterki o wielkości 300 pikseli (uporządkowane według kąta), i liczymy plasterki, w których piksel w pozycji 150jest maksymalny.
• Następnie po prostu kolorujemy wszystkie piksele w zależności od liczby pików (okrąg ma wartość powyżej 16 i zwykle daje około 20 pików, ze względu na rozmiar plasterków).

Dla przypomnienia, jeśli użyję pomysłu Ella i po prostu posortuję regiony według największej odległości między dowolnym pikselem a środkiem, mogę to zrobić w 342 bajtach:

f=(d=ImageData@Import@#/.{a_,_,_}:>a;MapIndexed[(d[[##&@@#]]=#&@@#2)&,SortBy[(For[a={};b={#&@@d~Position~1},b!={},c=#&@@b;b=Rest@b;d[[##&@@c]]=0;a~AppendTo~c;If[Extract[d,c+#]==1,b=b⋃{c+#}]&/@{e={1,0},-e,e={0,1},-e}];a)&/@Range@4,(m=Mean@#;Max[1.Norm[#-m]&/@#])&],{2}];Image[d/.n_Integer:>{{0,0,0},{0,0,1},{1,1,0},{1,0,0},{0,1,0}}[[n+1]]])&

Ale nie zamierzam z tym konkurować, dopóki wszyscy inni używają swoich własnych oryginalnych algorytmów, zamiast grać w golfa algorytmami innych.

Java, 1204 1132 1087 1076

Aby udowodnić sobie, że mogę to zrobić.

Dołączyłem import tuż obok deklaracji funkcji; aby to zadziałało, musiałyby znajdować się poza klasą:

import java.awt.*;import java.awt.image.*;import java.io.*;import java.util.*;import javax.imageio.*;

BufferedImage i;Set<Point>Q;void p(String a)throws Exception{i=new BufferedImage(302,302,1);i.getGraphics().drawImage(ImageIO.read(new File(a)),1,1,null);Set<Set<Point>>S=new HashSet<>();for(int y=0;y<300;y++){for(int x=0;x<300;x++){if(!G(x,y)){Point p=new Point(x,y);Q=new HashSet<>();if(!S.stream().anyMatch(s->s.contains(p)))S.add(f(x,y));}}}Object[]o=S.stream().sorted((p,P)->c(p)-c(P)).toArray();s(o[0],255);s(o[1],255<<16);s(o[2],0xFF00);s(o[3],0xFFFF00);ImageIO.write(i.getSubimage(1,1,300,300),"png",new File(a));}boolean G(int x,int y){return i.getRGB(x,y)!=-1;}Set<Point>f(int x,int y){Point p=new Point(x,y);if(!Q.contains(p)&&!G(x,y)){Q.add(p);f(x-1,y);f(x+1,y);f(x,y-1);f(x,y+1);}return Q;}int c(Set<Point>s){return(int)s.stream().filter(p->G(p.x-2,p.y-1)||G(p.x-2,p.y+1)||G(p.x+1,p.y-2)||G(p.x-1,p.y-2)||G(p.x+2,p.y-1)||G(p.x+2,p.y+1)||G(p.x+1,p.y+2)||G(p.x-1,p.y+2)).count();}void s(Object o,int c){((Set<Point>)o).stream().forEach(p->{i.setRGB(p.x,p.y,c);});}

Niegolfowane (i możliwe do uruchomienia; tj. Dodana płyta kotła)

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.HashSet;
import java.util.Set;
import javax.imageio.ImageIO;

public class SquareCircleTriangleGear {
    public static void main(String[]args){
        try {
            new SquareCircleTriangleGear().p("filepath");
        } catch (Exception ex) {
        }
    }
    BufferedImage i;
    Set<Point>Q;
    void p(String a)throws Exception{
        i = new BufferedImage(302,302,BufferedImage.TYPE_INT_RGB);
        i.getGraphics().drawImage(ImageIO.read(new File(a)),1,1,null);
        Set<Set<Point>>set=new HashSet<>();
        for(int y=0;y<300;y++){
            for(int x = 0;x<300;x++){
                if(i.getRGB(x,y)==-1){
                    Point p = new Point(x,y);
                    Q=new HashSet<>();
                    if(!set.stream().anyMatch((s)->s.contains(p))){
                        set.add(fill(x,y));
                    }
                }
            }
        }
        Object[]o=set.stream().sorted((p,P)->c(p)-c(P)).toArray();
        s(o[0],0x0000FF);
        s(o[1],0xFF0000);
        s(o[2],0x00FF00);
        s(o[3],0xFFFF00);
        ImageIO.write(i.getSubImage(1,1,300,300), "png", new File(a));
    }
    Set<Point>fill(int x, int y){
        Point p=new Point(x,y);
        if(!Q.contains(p)&&!i.getRGB(x,y)!=-1) {
        Q.add(p);
            fill(x-1,y);
            fill(x+1,y);
            fill(x,y-1);
            fill(x,y+1);
        }
        return Q;
    }
    int c(Set<Point>s){return (int)s.stream().filter(p->isBoundary(p.x,p.y)).count();}
    boolean isBoundary(int x, int y){
        return i.getRGB(x-2,y-1)!=-1||i.getRGB(x-2,y+1)!=-1||i.getRGB(x+1,y-2)!=-1||
               i.getRGB(x-1,y-2)!=-1||i.getRGB(x+2,y-1)!=-1||i.getRGB(x+2,y+1)!=-1||
               i.getRGB(x+1,y+2)!=-1||i.getRGB(x-1,y+2)!=-1;
    }
    void s(Object o,int c){
        ((Set<Point>)o).stream().forEach(p->{i.setRGB(p.x,p.y,c);});
    }
}

Działa to poprzez iterowanie każdego piksela obrazu i wypełnianie zalewaniem za każdym razem, gdy docieramy do „dziury”. Każdy wynik wypełnienia dodajemy jako Set<Point>do Set. Następnie określamy, który kształt jest który. Odbywa się to poprzez sprawdzenie liczby pikseli brzegowych kształtu. Zdefiniowałem granicę jako ruch rycerza od czarnej płytki, ponieważ pozostałaby ona bardziej stała między rotacjami i tym podobne. Kiedy to robimy, staje się jasne, że kształty można sortować według tej wartości: koło, kwadrat, trójkąt, koło zębate. Więc sortuję i ustawiam wszystkie piksele tego kształtu na właściwy kolor.

Zauważ, że obraz, do którego piszę, nie jest pobierany bezpośrednio z pliku, ponieważ gdybym to zrobił, Java traktowałaby obraz jako czarno-biały, a wypełnienie kolorami nie działałoby. Więc muszę stworzyć własny obraz z TYPE_INT_RGB(który jest 1). Zauważ też, że obraz, nad którym pracuję, jest 302autorstwa 302; Dzieje się tak, aby algorytm odległości rycerza nie musiał się martwić próbą odczytania obrazu poza granicami. Naprawiam tę rozbieżność, dzwoniąc i.getSubImage(1,1,300,300). _{Uwaga: mogłem zapomnieć o rozwiązaniu tego problemu podczas przesyłania zdjęć, w których to przypadkach obrazy są o 2 piksele za szerokie, ale poza tym powinny być poprawne}

Funkcja zastąpi plik, do którego ścieżka została przekazana. Dane wyjściowe:

Pyton, 571 567 528 bajtów

Podobnie jak w rozwiązaniu Quincunx, zaczyna się od wypełnienia każdego kształtu indeksem od 1 do 4. Następnie określa tożsamość kształtów na podstawie promienia ich ograniczającego okręgu. Paleta kolorów jest odpowiednio skonstruowana, a obraz jest zapisywany jako obraz w kolorze indeksowanym.

EDYCJA: Pominięto fakt, że kształty mają gwarancję, że nie dotykają ramki obrazu. Zatem jest krótszy!

from PIL.Image import*;from numpy import*
I=open(sys.argv[1]).convert("P")
D=list(I.getdata())
W=300;R=range(W*W);N=range(5)
O=[[0,i,array([0,0])]for i in N];n=0
for i in R:
 if D[i]>4:
    n+=1;S=[i]
    while S:
     j=S.pop()
     if D[j]>4:D[j]=n;O[n][0]+=1;O[n][2]+=j%W,j/W;S+=[j+1,j-1,j+W,j-W]
for o in O[1:]:o[2]/=o[0];o[0]=0
for i in R:
 if D[i]:o=O[D[i]];v=(i%W,i/W)-o[2];o[0]=max(o[0],dot(v,v))
O.sort()
C=[0]*5+[255]*3+[0,255,0,0]*2;P=C[:]
for i in N:j=3*O[i][1];P[j:j+3]=C[3*i:3*i+3]
I.putdata(D);I.putpalette(P);I.save("o.png")

Pobiera wejściową nazwę pliku w wierszu poleceń i zapisuje dane wyjściowe w o.png.

Mathematica 225

Aktualizacja :

PO zdecydował, że to podejście wykorzystuje funkcje widzenia komputerowego, więc nie jest już aktywne. Zostawię to jednak opublikowane. Być może ktoś może go zainteresować.

f@i_ := (m = MorphologicalComponents[ImageData@i];
Image@Partition[Flatten[(m)] /. 
   Append[ ReplacePart[SortBy[ComponentMeasurements[m, "Circularity"], Last], 
   {{1, 2} -> Yellow, {2, 2} -> Green, {3, 2} -> Red, {4, 2} -> Blue}], 0 -> Black], 
Dimensions[m][[2]]])

ImageData zwraca obraz jako macierz zer i jedynek.

Flatten konwertuje tę macierz na listę.

Morphological Componentsznajduje 4 klastry pikseli i przypisuje odrębną liczbę całkowitą 1, 2, 3, 4 do każdego piksela zgodnie z klastrem. 0 jest zarezerwowane dla (czarnego) tła.

ComponentMeasurements sprawdza kołowość klastrów.

Od najbardziej do najmniej okrągłego zawsze będzie: koło, kwadrat, trójkąt i koło zębate.

ReplacePart zastępuje każdą liczbę całkowitą składową odpowiednim kolorem RGB, stosując sortowanie według kołowości.

Partition...Dimensions[m][[2]] pobiera listę kolorów pikseli i zwraca macierz o takich samych wymiarach jak obraz wejściowy.

Image konwertuje matrycę kolorów pikseli na kolorowy obraz.

{f[img1],f[img2],f[img3],f[img4]}

Mathematica, 354 345 314 291 288

Wciąż gra w golfa, może zostać skrócony o kilka znaków, ale wydajność staje się nie do zniesienia. Używa wariancji do identyfikacji kształtów:

f=(w=Position[z=ImageData@Import@#,1];r=Nearest;v@x_:=Variance@N[Norm[Mean@x-#]&/@x];Image[Plus@@(ReplacePart[0z/. 0->{0,0,0},#->r[{108,124,196,115}->List@@@{Blue,Red,Green,Yellow},v@#][[1]]]&/@Rest@NestList[(m=r[w=w~Complement~#];FixedPoint[Union@@(m[#,{8,2}]&/@#)&,{#&@@w}])&,{},4])])&

Z odstępami:

f = (w = Position[z = ImageData@Import@#, 1];
     r = Nearest; 
     v@x_ := Variance@N[Norm[Mean@x - #] & /@ x];
     Image[Plus @@ (ReplacePart[ 0 z /. 0 -> {0, 0, 0}, # -> r[{108, 124, 196, 115} -> 
                                              List @@@ {Blue, Red, Green, Yellow}, v@#][[1]]] & /@
     Rest@NestList[(m = r[w = w~ Complement~#];
                   FixedPoint[Union @@ (m[#, {8, 2}] & /@ #) &, {# & @@ w}]) &
                   , {}, 4])]) &

Testowanie:

s = {"http://i.stack.imgur.com/Oa2O1.png", "http://i.stack.imgur.com/C6IKR.png", 
     "http://i.stack.imgur.com/YZfc6.png", "http://i.stack.imgur.com/F1ZDM.png", 
     "http://i.stack.imgur.com/chJFi.png", "http://i.stack.imgur.com/DLM3y.png"};
Partition[f /@ s, 3] // Grid

Tutaj jest całkowicie bez golfa. Dodają wyjaśnienia później:

findOneZone[{universe_List, lastZone_List}] :=
 Module[{newUniverse, proximityFindFunc, seedElement},
  newUniverse = Complement[universe, lastZone];
  proximityFindFunc = Nearest@newUniverse;
  seedElement = {First@newUniverse};
  {newUniverse, FixedPoint[Union @@ (proximityFindFunc[#, {8, 2}] & /@ #) &, seedElement]}]

colorAssign[zone_List] :=
 Module[{
   vlist = {108, 124, 196, 115},
   cols = List @@@ {Blue, Red, Green, Yellow},
   centerVariance},
  centerVariance[x_List] := Variance@N[Norm[Mean@x - #] & /@ x];
  First@Nearest[vlist -> cols, centerVariance@zone]]

colorRules[zones_List] := (# -> colorAssign[#] & /@ zones)

main[urlName_String] := 
 Module[{pixels, FgPixelPositions, rawZones, zones},
  pixels = ImageData@Import@urlName;
  FgPixelPositions = Position[pixels, 1];
  (*fill and separate the regions*)
  rawZones = NestList[findOneZone[#] &, {FgPixelPositions, {}}, 4];
  zones = Rest[rawZones][[All, 2]];
  (*Identify,colorize and render*)
  Image@ReplacePart[ConstantArray[{0, 0, 0}, Dimensions@pixels], 
    colorRules[zones]]]

s = {"http://i.stack.imgur.com/Oa2O1.png"};
main /@ s

Python, 579 577 554 514 502 501 bajtów

Dla każdego kształtu wypełnij go, a następnie oblicz odległość między środkiem ciężkości a najdalszym punktem.

wtedy rzeczywista powierzchnia kształtu jest porównywana z powierzchnią trójkąta, kwadratu, tarczy lub koła, które miałyby ten sam rozmiar.

import matematyki ; z PIL . Import obrazu *; A , R , _ , I = abs , zakres ( 300 ), 255 , otwarty ( sys . Argv [ 1 ]). konwersja ( „P” ); Q = ja . Obciążenie () dla j w R : dla i w R : jeśli Q [ 

 
  i , j ] == _ : 
   X , Y , s , z , p = 0 , 0 , 0 , [], [( i , j )] podczas gdy p : 
    a , b = n = p . Pop () czy nie ( P [ N !] = _ lub n w Z ) 
     X + = ; Y + =
   
     b ; z + = [ n ]; p + = [( a , b - 1 ), ( a + 1 , b ), ( a , b + 1 ), ( a - 1 , b )]; s + = 1 
   r = max ([ mat . hipot . ( X / s - x , Y / s - y ) dla x , y w z ]); C = { 1 : ( s - ( 1,4 * R ) ** 2 ), 2 : ( a - R * R / 3 ), 3 : ( y - Math . Pi * R * R ), 4 : ( s - 2,5 * r * r )} dla p w z
   : 
    P [ t ] = min ( C , klucz = C . Dostać ) 
I . putpalette ([ 0 , 0 , 0 , _ ] * 3 + [ _ , _ , 0 ]) 
I . pokaż ()

C # 1086 bajtów

Jeszcze jedno rozwiązanie wypełniające, tylko dla przypomnienia, ponieważ nie ma tutaj wersji C #. Podobnie jak Quincunx, chciałem udowodnić, że potrafię to zrobić i jego podejście do Javy nie ma większych trudności.

• To rozwiązanie nie korzysta z żadnej rekurencji (ale stosu), ponieważ ciągle napotykałem przepływy stosów.
• Wykrywanie pikseli granicznych jest uproszczone poprzez spojrzenie na 4 kolejne piksele, jeśli którykolwiek z nich jest czarny, prąd jest pikselem granicznym.

Akceptuje każdy format obrazu.

• Parametr 1 = InputPath
• Parametr 2 = OutputPath

Prawdopodobnie można go rozebrać o kilka znaków, usuwając wszystkie elementy statyczne i tworząc instancję programu.

Wersja do odczytu:

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

class Program
{
    static Bitmap img;
    static int w, h;
    static ISet<Point> pointsDone = new HashSet<Point>();
    static void Main(string[] a)
    {
        img = new Bitmap(a[0]);
        w = img.Width;
        h = img.Height;
        Bitmap clone = new Bitmap(w,h, PixelFormat.Format32bppArgb);
        Graphics.FromImage(clone).DrawImage(img, 0, 0, w, h);
        img = clone;




        Color[] colors = new[] { Color.Blue, Color.Red, Color.Green, Color.Yellow };

        var shapes = new List<ISet<Tuple<bool, Point>>>();
        for(int x=0;x<w;x++)
            for (int y = 0; y < h; y++)
            {
                Point p = new Point(x, y);
                if (pointsDone.Add(p) && _isWhitePixel(p))
                    shapes.Add(_detectShape(p));
            }
        int index = 0;
        foreach (var shp in shapes.OrderBy(shp => shp.Count(item => item.Item1)))
        {
            foreach (var pixel in shp)
                img.SetPixel(pixel.Item2.X, pixel.Item2.Y, colors[index]);
            index++;
        }

        img.Save(a[1]);
    }

    private static ISet<Tuple<bool, Point>> _detectShape(Point p)
    {
        var todo = new Stack<Point>(new[] { p });
        var shape = new HashSet<Tuple<bool, Point>>();
        do
        {
            p = todo.Pop();
            var isBorderPixel = false;
            foreach (var n in new[] { new Point(p.X + 1, p.Y), new Point(p.X - 1, p.Y), new Point(p.X, p.Y + 1), new Point(p.X, p.Y - 1) })
                if (_isWhitePixel(n))
                {
                    if (pointsDone.Add(n))
                        todo.Push(n);
                }
                else isBorderPixel = true; // We know we are at the border of the shape
            shape.Add(Tuple.Create(isBorderPixel, p));

        } while (todo.Count > 0);
        return shape;
    }

    static bool _isWhitePixel(Point p)
    {
        return img.GetPixel(p.X, p.Y).ToArgb() == Color.White.ToArgb();
    }
}

Gra w golfa:

using System;using System.Collections.Generic;using System.Drawing;using System.Drawing.Imaging;using System.Linq;class P{static Bitmap a;static int w,h;static ISet<Point> d=new HashSet<Point>();static void Main(string[] q){a=new Bitmap(q[0]);w=a.Width;h=a.Height;var c=new Bitmap(w,h,PixelFormat.Format32bppArgb);Graphics.FromImage(c).DrawImage(a,0,0,w,h);a=c;var e=new[]{Color.Blue,Color.Red,Color.Green,Color.Yellow};var f=new List<ISet<dynamic>>();for(int x=0;x<w;x++)for(int y=0;y<h;y++){Point p=new Point(x,y);if (d.Add(p)&&v(p))f.Add(u(p));}int i=0;foreach(var s in f.OrderBy(s=>s.Count(item=>item.b))){foreach(var x in s)a.SetPixel(x.p.X,x.p.Y,e[i]);i++;}a.Save(q[1]);}private static ISet<dynamic> u(Point p){var t=new Stack<Point>(new[]{p});var s=new HashSet<dynamic>();do{p=t.Pop();var b=false;foreach(var n in new[]{new Point(p.X+1,p.Y),new Point(p.X-1,p.Y),new Point(p.X,p.Y+1),new Point(p.X,p.Y-1)})if(v(n)){if (d.Add(n))t.Push(n);}else b=true;s.Add(new{b,p});}while (t.Count>0);return s;}static bool v(Point p){return a.GetPixel(p.X,p.Y).ToArgb()==Color.White.ToArgb();}}