Votre tâche consiste à créer un programme qui prend une image avec contour en noir et blanc (les images ci-dessous sont illustrées ci-dessous) et la remplit de couleur. C'est à vous de choisir comment vous séparez chaque région et de quelle couleur le remplir (vous pouvez même utiliser un GNA).

Par exemple:

Comme vous pouvez le constater, je suis clairement un artiste d’un calibre supérieur en ce qui concerne MS Paint.

Notation

Ceci est un concours de popularité, donc la réponse avec le plus grand nombre de votes nets gagne. Les électeurs sont encouragés à juger les réponses par

• Critère d'entrée: toute image composée d'un fond blanc / gris clair et de contours noirs / gris foncé
• Comment bien la coloration est faite; signifiant que peu ou pas de zones sont blanches contrairement à ce qui précède (à moins que vous n'utilisiez manifestement le blanc, par exemple pour les nuages)
• Personnalisabilité des couleurs utilisées dans certaines sections
• Comment le système fonctionne-t-il sur une gamme d'images différentes (de détails variables)
• Postez combien de temps votre programme prend par image. Nous ne jouons peut-être pas du code-golf, mais un code plus court, plus rapide et plus efficace devrait être considéré comme meilleur.
• La nouvelle image doit-elle être affichée à l'écran ou dans un fichier (pas plus de 2 Mo pour pouvoir être affichée dans la réponse)
• Veuillez justifier pourquoi vous avez choisi de générer ce type d'image et commenter / expliquer le fonctionnement de votre code
• L'applicabilité de la couleur utilisée à la forme respective à laquelle elle est liée (palette de couleurs réaliste, c'est-à-dire que l'herbe est verte, les clôtures en bois sont marron, etc.)

  "Je pourrais colorier chaque zone de manière aléatoire, mais si je pouvais identifier la" barrière "et la rendre de la même couleur, alors c'est quelque chose qui mérite des upvotes." - NathanMerrill

Comme il s’agit d’ un concours de popularité, vous pouvez également en juger par:

• Attrait général (qualité de l'image)
• Flair artistique; si vous pouvez programmer une coloration d'ombrage ou d'aquarelle, etc.

En général, la plus petite image produite (taille de fichier) de la plus haute qualité, avec le programme à jeun et le vote du public le plus élevé, l'emportera.

Si vous pensez que d'autres spécifications de jugement devraient être utilisées, merci de les recommander dans les commentaires de ce message.

Exemples

Je ne possède rien; tous les exemples d'images sont d'une licence Creative Commons.

Source: https://pixabay.com/ro/stejar-arbore-schi%C5%A3%C4%83-natura-303890/ Source: http://www.freestockphotos.biz/stockphoto/10665 Source: http: / /crystal-rose1981.deviantart.com/art/Dragon-Tattoo-Outline-167320011 Source: http://jaclynonacloudlines.deviantart.com/art/Gryphon-Lines-PF-273195317 Source: http://captaincyprus.deviantart.com / art / Dragon-OutLine-331748686 Source: http://electric-meat.deviantart.com/art/A-Heroes-Farewell-280271639 Source: http://movillefacepalmplz.deviantart.com/art/Background-The-Pumpkin -Fermes-de-bons-vieux-jours-342865938

EDIT: En raison de l’anti-aliasing sur les lignes générant des pixels non noirs / blancs et certaines images pouvant contenir du gris au lieu de noir / blanc, vous pouvez tenter de l’aborder en prime. Cela devrait être assez facile à mon avis.

Aérographie spectrale (Python, PIL, Scipy)

Ceci utilise un algorithme mathématique sophistiqué pour produire un non-sens coloré. L'algorithme est lié à l'algorithme PageRank de Google, mais pour les pixels au lieu des pages Web.

J'ai choisi cette approche parce que je pensais que, contrairement aux méthodes basées sur le remplissage par inondation, elle pourrait peut-être gérer des images telles que le poulet et l'arbre, où certaines formes ne sont pas entièrement délimitées par des lignes noires. Comme vous pouvez le constater, cela fonctionne en quelque sorte, même s'il a également tendance à colorer différentes parties du ciel de différentes couleurs.

Pour les mathématiciens, il s’agit essentiellement de construire le graphe de contiguïté des pixels tout en image, puis de rechercher les 25 premiers vecteurs propres du graphe laplacien. (Sauf que ce n'est pas tout à fait parce que nous incluons les pixels sombres, nous donnons simplement un poids inférieur à leurs connexions. Cela aide à traiter l'antialiasing et semble également donner de meilleurs résultats en général.) Ayant trouvé les vecteurs propres, cela crée une combinaison linéaire aléatoire d'entre eux, pondérés par leurs valeurs propres inverses, pour former les composantes RVB de l'image de sortie.

Dans l'intérêt du temps de calcul, l'image est réduite avant de faire tout cela, puis redimensionnée, puis multipliée par l'image d'origine. Néanmoins, il ne fonctionne pas rapidement, prenant entre 2 et 10 minutes environ sur ma machine, en fonction de l'image d'entrée, bien que, pour une raison quelconque, le poulet ait pris 17 minutes.

En fait, il pourrait être possible de transformer cette idée en quelque chose d’utile en créant une application interactive permettant de contrôler la couleur et l’intensité de chacun des vecteurs propres. De cette façon, vous pouvez masquer celles qui divisent le ciel en différentes sections et créer des atténuations dans celles qui décrivent les caractéristiques pertinentes de l'image. Mais je n'ai pas l'intention de le faire moi-même :)

Voici les images de sortie:

(Cela n'a pas très bien fonctionné sur les citrouilles, alors je l'ai omis.)

Et voici le code:

import sys
from PIL import Image
import numpy as np
import scipy.sparse as sp
import scipy.sparse.linalg as spl
import os
import time

start_time = time.time()

filename = sys.argv[1]
img = Image.open(filename)
orig_w, orig_h = img.size

# convert to monochrome and remove any alpha channel
# (quite a few of the inputs are transparent pngs)
img = img.convert('LA')
pix = img.load()
for x in range(orig_w):
    for y in range(orig_h):
        l, a = pix[x,y]
        l = (255-a) + a*l/255
        a = 255
        pix[x,y] = l,a
img = img.convert('L')

orig_img = img.copy()

# resize to 300 pixels wide - you can get better results by increasing this,
# but it takes ages to run
orig_w, orig_h = img.size
print "original size:", str(orig_w)+ ', ' + str(orig_h)
new_w = 300
img = img.resize((new_w, orig_h*new_w/orig_w), Image.ANTIALIAS)

pix = img.load()
w, h = img.size
print "resizing to", str(w)+', '+str(h)

def coords_to_index(x, y):
    return x*h+y

def index_to_coords(i):
    return (int(i/h), i%h)

print "creating matrix"

A = sp.lil_matrix((w*h,w*h))

def setlink(p1x, p1y, p2x, p2y):
    i = coords_to_index(p1x,p1y)
    j = coords_to_index(p2x,p2y)
    ci = pix[p1x,p1y]/255.
    cj = pix[p2x,p2y]/255.
    if ci*cj > 0.9:
        c = 1
    else:
        c =  0.01
    A[i,j] = c
    return c

for x in range(w):
    for y in range(h):
        d = 0.
        if x>0:
            d += setlink(x,y,x-1,y)
        if x<w-1:
            d += setlink(x,y,x+1,y)
        if y>0:
            d += setlink(x,y,x,y-1)
        if y<h-1:
            d += setlink(x,y,x,y+1)
        i = coords_to_index(x,y)
        A[i,i] = -d

A = A.tocsr()

# the greater this number, the more details it will pick up on. But it increases
# execution time, and after a while increasing it won't make much difference
n_eigs = 25

print "finding eigenvectors (this may take a while)"
L, V = spl.eigsh(A, k=n_eigs, tol=1e-12, which='LA')

print "found eigenvalues", L

out = Image.new("RGB", (w, h), "white")
out_pix = out.load()

print "painting picutre"

V = np.real(V)
n = np.size(V,0)
R = np.zeros(n)
G = np.zeros(n)
B = np.zeros(n)

for k in range(n_eigs-1):
    weight = 1./L[k]
    R = R + V[:,k]*np.random.randn()*weight
    G = G + V[:,k]*np.random.randn()*weight
    B = B + V[:,k]*np.random.randn()*weight

R -= np.min(R)
G -= np.min(G)
B -= np.min(B)
R /= np.max(R)
G /= np.max(G)
B /= np.max(B)

for x in range(w):
    for y in range(h):
        i = coords_to_index(x,y)
        r = R[i]
        g = G[i]
        b = B[i]
        pixval = tuple(int(v*256) for v in (r,g,b))
        out_pix[x,y] = pixval

out = out.resize((orig_w, orig_h), Image.ANTIALIAS)
out_pix = out.load()
orig_pix = orig_img.load()

for x in range(orig_w):
    for y in range(orig_h):
        r,g,b = out_pix[x,y]
        i = orig_pix[x,y]/255.
        out_pix[x,y] = tuple(int(v*i) for v in (r,g,b))

fname, extension = os.path.splitext(filename)
out.save('out_' + fname + '.png')

print("completed in %s seconds" % (time.time() - start_time))

Python 2 + PIL aussi, mon premier livre de coloriage

import sys, random
from PIL import Image

def is_whitish(color):
    return sum(color)>500

def get_zone(image, point, mask):
    pixels = image.load()
    w, h = image.size
    s = [point]
    while s:
        x, y = current = s.pop()
        mask[current] = 255
        yield current
        s+=[(i,j) for (i,j) in [(x,y-1),(x,y+1),(x-1,y),(x+1,y)] if 0<=i<w and 0<=j<h and mask[i,j]==0 and is_whitish(pixels[i,j])]

def get_zones(image):
    pixels = I.load()
    mask = Image.new('1',image.size).load()
    w,h = image.size
    for y in range(h):
        for x in range(w):
            p = x,y
            if mask[p]==0 and is_whitish(pixels[p]):
                yield get_zone(image, p, mask)



def apply_gradient(image, mincolor, maxcolor, points):
    minx = min([x for x,y in points])
    maxx = max([x for x,y in points])
    miny = min([y for x,y in points])
    maxy = max([y for x,y in points])
    if minx == maxx or miny==maxy:
        return
    diffx, diffy = (maxx - minx), (maxy-miny)
    stepr = (maxcolor[0] - mincolor[0] * 1.0) / diffy
    stepg = (maxcolor[1] - mincolor[1] * 1.0) / diffy
    stepb = (maxcolor[2] - mincolor[2] * 1.0) / diffy
    r,g,b = mincolor
    w, h = (abs(diffx+1),abs(diffy+1))
    tmp = Image.new('RGB', (w,h))
    tmppixels = tmp.load()
    for y in range(h):
        for x in range(w):
            tmppixels[x,y] = int(r), int(g), int(b)
        r+=stepr; g+=stepg; b+=stepb
    pixels = image.load()
    minx, miny = abs(minx), abs(miny)
    for x,y in points:
        try:
        pixels[x,y] = tmppixels[x-minx, y-miny]
    except Exception, e:
            pass

def colors_seq():
   yield (0,255,255)
   c = [(255,0,0),(0,255,0),(0,0,139)]
   i=0
   while True:i%=len(c);yield c[i];i+=1

def colorize(image):
    out = image.copy()
        COLORS = colors_seq()
    counter = 0
    for z in get_zones(image):
        c1 = COLORS.next()
        c2 = (0,0,0) if counter == 0 else (255,255,255)
        if counter % 2 == 1:
            c2, c1 = c1, c2
        apply_gradient(out, c1, c2, list(z))
        counter +=1
    return out

if __name__ == '__main__':
    I = Image.open(sys.argv[-1]).convert('RGB')
    colorize(I).show()

J'ai fait à peu près la même chose que CarpetPython, sauf que je remplis la région de "dégradés" et utilise un cycle de couleur différent.

Mes plus beaux coloriages:

Temps de calcul sur ma machine:

• image 1 (dragon chinois): utilisateurs réels de 0m2.862s 0m2.801s sys 0m0.061s

• image 2 (gryffon): real 0m0.991s 0m0.963s sys 0m0.029s sys

• image 3 (dragon unicornish): vrais utilisateurs 0m2.260s 0m2.239s sys 0m0.021s

Python 2 et PIL: des mondes psychédéliques

J'ai utilisé un algorithme simple pour remplir chaque zone blanche d'une couleur provenant d'une palette de cycles. Le résultat est très coloré, mais pas très réaliste.

Notez que les parties "blanches" de ces images ne sont pas très blanches. Vous devrez également tester les nuances de gris.

Code en Python 2.7:

import sys
from PIL import Image

WHITE = 200 * 3
cs = [60, 90, 120, 150, 180]
palette = [(199,199,199)] + [(R,G,B) for R in cs for G in cs for B in cs]

def fill(p, color):
    perim = {p}
    while perim:
        p = perim.pop()
        pix[p] = color
        x,y = p
        for u,v in [(x+dx, y+dy) for dx,dy in [(-1,0), (1,0), (0,1), (0,-1)]]:
            if 0 <= u < W and 0 <= v < H and sum(pix[(u,v)]) >= WHITE:
                perim.add((u,v))

for fname in sys.argv[1:]:
    print 'Processing', fname
    im = Image.open(fname)
    W,H = im.size
    pix = im.load()
    colornum = 0
    for y in range(H):
        for x in range(W):
            if sum(pix[(x,y)]) >= WHITE:
                thiscolor = palette[colornum % len(palette)]
                fill((x,y), thiscolor)
                colornum += 1
    im.save('out_' + fname)

Exemple d'images:

Matlab

function [output_image] = m3(input_file_name)
a=imread(input_file_name);
b=im2bw(a,0.85);
c=bwlabel(b);
h=vision.BlobAnalysis;
h.MaximumCount=10000;
ar=power(double(step(h,b)),0.15);
ar=[ar(1:max(max(c))),0];
f=cat(3,mod((ar(c+(c==0))-min(ar(1:end-1)))/ ...
    (max(ar(1:end-1))-min(ar(1:end-1)))*0.9+0.8,1),c*0+1,c*0+1);
g=hsv2rgb(f);
output_image=g.*cat(3,c~=0,c~=0,c~=0);

Nous utilisons l’espace colorimétrique HSV et choisissons chaque teinte des régions en fonction de sa taille relative entre les régions blanches. La plus grande région sera bleue ( Hue = 0.7) et la plus petite, violette ( Hue = 0.8). Les régions situées entre ces deux tailles se voient attribuer des teintes dans la plage 0.7 -> 1=0 -> 0.8. La teinte de la plage est sélectionnée linéairement par rapport à la fonction area^0.15. La saturation et la valeur sont toujours de 1 pour chaque pixel non noir.

Il faut moins d’une seconde pour colorer une image.

Les 3 images avec les régions fermées où l'algorithme fonctionne correctement:

Et le reste des images:

Sur ces images, il y a de grandes régions connectées blanches qui devraient idéalement être colorées par plusieurs couleurs (ce problème a été joliment résolu dans la solution de Nathaniel .

Python 3 avec oreiller

Le code est un peu long à inclure dans cette réponse, mais voici l'essentiel .

1. Prenez l'image d'entrée et, si elle possède un canal alpha, composez-la sur un fond blanc. (Nécessaire au moins pour l'image de poulet, car toute l'image était en noir et se distinguait uniquement par la transparence. Il n'était donc pas utile de supprimer l'alpha.)
2. Convertir le résultat en niveaux de gris; nous ne voulons pas que des artefacts de compression ou d'anti-crénelage, ou des lignes grises qui ne sont pas tout à fait grises, nous gâchent.
3. Créez une copie à deux niveaux (noir et blanc) du résultat. Les nuances de gris sont converties en noir ou en blanc en fonction d'un seuil de coupure configurable entre le blanc et la nuance la plus sombre de l'image.
4. Remplissez chaque zone blanche de l'image. Les couleurs sont choisies au hasard, en utilisant une palette sélectionnable qui prend en compte l'emplacement du point de départ pour l'opération de remplissage.
5. Remplissez les lignes noires avec les couleurs de leur voisin le plus proche. Cela nous aide à réintroduire l'anti-aliasing, en empêchant chaque région colorée d'être bordée de noir.
6. Prenez l’image en niveaux de gris de l’étape 2 et créez-en un masque alpha: la couleur la plus sombre est totalement opaque, la couleur la plus claire est totalement transparente.
7. Composez l'image en niveaux de gris sur l'image colorée de l'étape 5 à l'aide de ce masque alpha.

Malheureusement, ces dernières étapes n’ont toujours pas permis d’éliminer les «halos» plus clairs qui sont visibles dans les régions de couleur plus foncée, mais ils ont fait une différence notable, au moins. Le traitement d'images n'a jamais été mon domaine d'étude, donc je sais qu'il existe des algorithmes plus performants et plus efficaces pour faire ce que j'ai essayé de faire ici ... mais bon.

Jusqu'à présent, il n'y a que deux palettes sélectionnables pour l'étape 4: une palette purement aléatoire et une palette très "naturelle" qui essaie d'associer la couleur du ciel aux coins supérieurs, la couleur de l'herbe aux coins inférieurs, le brun (roches ou bois). ) couleurs au milieu de chaque côté et couleurs variées au centre. Le succès a été ... limité.

Usage:

usage: paint_by_prog.py [-h] [-p PALETTE] [-t THRESHOLD] [-f | -F] [-d]
                        FILE [FILE ...]

Paint one or more line-art images.

positional arguments:
  FILE                  one or more image filenames

optional arguments:
  -h, --help            show this help message and exit
  -p PALETTE, --palette PALETTE
                        a palette from which to choose colours; one of
                        "random" (the default) or "natural"
  -t THRESHOLD, --threshold THRESHOLD
                        the lightness threshold between outlines and paintable
                        areas (a proportion from 0 to 1)
  -f, --proper-fill     fill under black lines with proper nearest-neighbour
                        searching (slow)
  -F, ---no-proper-fill
                        fill under black lines with approximate nearest-
                        neighbour searching (fast)
  -d, --debug           output debugging information

Échantillons:

paint_by_prog.py -t 0.7 Gryphon-Lines.png

paint_by_prog.py Dragon-Tattoo-Outline.jpg

paint_by_prog.py -t 0.85 -p natural The-Pumpkin-Farm-of-Good-old-Days.jpg

paint_by_prog.py -t 0.7 Dragon-OutLine.jpg

paint_by_prog.py stejar-arbore-schiţă-natura.png

Le poulet n'a pas l'air très beau et mon dernier résultat pour l'image de Link n'est pas le meilleur; celui qui provenait d'une version précédente du code était en grande partie jaune pâle et avait une atmosphère de désert intéressante à ce sujet ...

Performance:

Chaque image prend quelques secondes à traiter avec les paramètres par défaut, ce qui signifie qu'un algorithme approximatif du plus proche voisin est utilisé pour l'étape 5. Le vrai voisin le plus proche est nettement plus lent, prenant peut-être une demi-minute (je ne l'ai pas encore chronométré).

Java

Sélection aléatoire des couleurs parmi votre choix de palette.

Avertissement: La région trouve actuellement très lente, à moins que les régions blanches soient inhabituellement petites.

import java.awt.Color;
import java.awt.image.*;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.function.Supplier;

import javax.imageio.ImageIO;


public class Colorer{
    public static boolean isProbablyWhite(int x,int y){
        Color c=new Color(image.getRGB(x, y));
        if(c.getRed()<240)return false;
        if(c.getBlue()<240)return false;
        if(c.getGreen()<240)return false;
        return true;
    }
    static class Point{
        int x,y;
        public boolean equals(Object o){
            if(o instanceof Point){
                Point p=(Point)o;
                return x==p.x&&y==p.y;
            }
            return false;
        }
        public Point(int x,int y){
            this.x=x;
            this.y=y;
        }
    }
    static BufferedImage image;
    static int W,H;
    public static void check(Point p,List<Point>l1,List<Point>l2,List<Point>l3){
        if(!isProbablyWhite(p.x,p.y))return;
        if(l1.contains(p))return;
        if(l2.contains(p))return;
        if(l3.contains(p))return;
        l1.add(p);
    }
    public static void process(int x,int y,Color c){
        List<Point>plist=new LinkedList<>();
        int rgb=c.getRGB();
        plist.add(new Point(x,y));
        List<Point>l3=new LinkedList<>();
        int k=0;
        for(int i=0;i<W*H;i++){
            System.out.println(k=l3.size());
            List<Point>l2=new LinkedList<>();
            for(Point p:plist){
                int x1=p.x;
                int y1=p.y;
                if(x1>0){
                    check(new Point(x1-1,y1),l2,plist,l3);
                }
                if(y1>0){
                    check(new Point(x1,y1-1),l2,plist,l3);
                }
                if(x1<W-1){
                    check(new Point(x1+1,y1),l2,plist,l3);
                }
                if(y1<H-1){
                    check(new Point(x1,y1+1),l2,plist,l3);
                }
            }
            while(!plist.isEmpty()){
                l3.add(plist.remove(0));
            }
            if(l3.size()==k)break;
            plist=l2;
        }
        plist=l3;
        for(Point p:plist){
            image.setRGB(p.x,p.y,rgb);
        }
    }
    public static void main(String[]args) throws Exception{
        Random rand=new Random();
        List<Supplier<Color>>colgen=new ArrayList<>();
        colgen.add(()->{return new Color(rand.nextInt(20),50+rand.nextInt(200),70+rand.nextInt(180));});
        colgen.add(()->{return new Color(rand.nextInt(20),rand.nextInt(40),70+rand.nextInt(180));});
        colgen.add(()->{return new Color(150+rand.nextInt(90),10+rand.nextInt(120),rand.nextInt(5));});
        colgen.add(()->{int r=rand.nextInt(200);return new Color(r,r,r);});
        colgen.add(()->{return Arrays.asList(new Color(255,0,0),new Color(0,255,0),new Color(0,0,255)).get(rand.nextInt(3));});
        colgen.add(()->{return Arrays.asList(new Color(156,189,15),new Color(140,173,15),new Color(48,98,48),new Color(15,56,15)).get(rand.nextInt(4));});
        Scanner in=new Scanner(System.in);
        image=ImageIO.read(new File(in.nextLine()));
        final Supplier<Color>sup=colgen.get(in.nextInt());
        W=image.getWidth();
        H=image.getHeight();
        for(int x=0;x<W;x++){
            for(int y=0;y<H;y++){
                if(isProbablyWhite(x,y))process(x,y,sup.get());
            }
        }
        ImageIO.write(image,"png",new File("out.png"));
    }
}

Requiert deux entrées: le nom de fichier et l'ID de palette. Inclut une correction d'anticrénelage, mais n'inclut pas de logique pour les pixels transparents.

Les palettes suivantes sont actuellement reconnues:

0: Blue and greeen
1: Blue
2: Red
3: Greyscale
4: Three-color Red, Green, and Blue
5: Classic Game Boy pallette (four shades of green)

Résultats:

Dragon, palette Game Boy:

L'autre dragon, palette bleu + vert:

GOL Nature morte Mona Lisa (telle que rendue par ce programme ), palette tricolore: