按数字绘画(使用编程,而不是数字)


56

您的任务是创建一个程序,该程序采用黑白轮廓图像(下面是示例图像)并用彩色填充。取决于您如何划分每个区域以及用哪种颜色填充(您甚至可以使用RNG)。

例如:

输出示例1

如您所见,在涉及MS Paint时,我显然是高级人才。


计分

这是一次人气竞赛,因此以最多净票数赢得答案。鼓励选民通过以下方式判断答案

  • 输入标准:任何包含白色/浅灰色背景和黑色/深灰色轮廓的图像
  • 着色效果如何;表示与上述区域不同的是很少或没有白色区域(除非您显然打算使用白色区域,例如用于云层)
  • 某些部分使用的颜色的可定制性
  • 系统在一系列不同图像(细节不同)上的工作情况
  • 发布您的程序每个图像花费多长时间。我们可能不喜欢打代码,但是较短,更快和更高效的代码应该被认为是更好的代码
  • 应该将新图像输出到屏幕上或文件中(不大于2MB,以便可以在答案中显示)
  • 请说明为什么选择输出为该图像类型并注释/解释代码的工作原理
  • 适用于所绑定的各种形状的颜色(逼真的配色方案,例如草为绿色,木栅栏为棕色等)

    “我可以为每个区域随机着色,但是如果我能识别出“围栏”并使其具有相似的颜色,那是值得赞扬的东西。” -内森·梅里尔

鉴于这一次人气竞赛,您还可以选择通过以下方式进行判断:

  • 总体吸引力(图像看起来有多好)
  • 艺术天赋;如果您可以使用阴影或水彩风格的着色等进行编程

通常,以斋戒的程序和最高的公众投票会获得最高质量的最小输出图像(文件大小)。

如果您认为应该使用其他判断规范,请在本文的评论中推荐它们。


例子

我什么都不拥有;所有示例图片均具有知识共享许可。

示例1黑色/白色 来源:https 示例2黑色/白色 : //pixabay.com/ro/stejar-arbore-schi%C5%A3%C4%83-natura-303890/ 示例3黑色/白色 来源:http: //www.freestockphotos.biz/stockphoto/10665来源:http:// /crystal-rose1981.deviantart.com/art/Dragon-Tattoo-Outline-167320011示例4黑色/白色 来源:http://jaclynonacloudlines.deviantart.com/art/Gryphon-Lines-PF-273195317 示例5黑色/白色 来源:http://captaincyprus.deviantart.com /艺术/龙轮廓-331748686 示例6黑色/白色 来源:http://electric-meat.deviantart.com/art/A-Heroes-Farewell-280271639 示例7黑色/白色 来源:http://movillefacepalmplz.deviantart.com/art/Background-The-Pumpkin农场的美好时光342865938


编辑:由于行上的抗锯齿导致非黑色/白色像素和一些可能包含灰色而不是黑色/白色的图像,因此,您可以尝试应对这种挑战。我认为这应该很容易。


4
致所有人:请不要以“艺术竞赛”的形式
投票

16
欢迎来到PPCG!我为您鼓足勇气,不仅有勇气让您的第一篇文章成为挑战,而且不仅是流行音乐挑战,而且是艺术挑战。祝你好运,我祝你一切顺利,如果你坚持下去,我想你会走的很远。
AdmBorkBork '16

4
@OliverGriffin我投票反对关闭和也,我在你为你链接的图像已经添加。您可以根据需要删除评论。
Addison Crump

2
我终于找到了一种可能不会堆栈溢出的方法,但是现在它的运行速度很慢。
SuperJedi224 '16

4
我已投票决定重新提出您的问题,并将-1更改为+1。做好工作编辑并添加其他信息。此外,我为您如此热烈接受社区批评表示赞赏。欢迎来到PPCG!希望你喜欢它。
扎克·盖茨

Answers:


30

光谱喷枪(Python,PIL,scipy)

这使用了复杂的数学算法来产生色彩丰富的废话。该算法与Google的PageRank算法有关,但适用于像素而不是网页。

我之所以采用这种方法,是因为我认为与基于洪水填充的方法不同,它可能能够处理像鸡和树这样的图像,其中的形状并没有完全被黑线包围。如您所见,虽然它也倾向于在天空的不同部分以不同的颜色进行着色,但它确实可以工作

对于具有数学思维的人:它的工作本质上是构造图像中while像素的邻接图,然后找到图拉普拉斯算子的前25个特征向量。(除了不尽然,因为我们确实包括了深色像素,我们只是给它们的连接赋予了较低的权重。这有助于处理抗锯齿,并且总体上似乎也可以提供更好的结果。)找到特征向量之后,它创建了一个由它们的反特征值加权对它们进行随机线性组合,以形成输出图像的RGB分量。

为了计算时间,在执行所有这些操作之前先将图像缩小,然后再次放大,然后再乘以原始图像。尽管如此,它仍然无法快速运行,在我的机器上大约要花费2到10分钟,具体取决于输入的图像,尽管由于某种原因,鸡肉只花了17分钟。

通过制作一个交互式应用程序,您可以在其中控制每个特征向量的颜色和强度,实际上有可能将这个想法变成有用的东西。这样,您可以淡出将天空划分为不同部分的图像,并淡入那些可以吸收图像相关特征的图像。但是我没有计划自己做:)

以下是输出图像:

在此处输入图片说明

在此处输入图片说明

在此处输入图片说明

在此处输入图片说明

在此处输入图片说明

(在南瓜上效果不佳,所以我省略了那个。)

这是代码:

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

4
这真的很酷。到目前为止可能是我的最爱之一。您在处理抗锯齿和开放区域方面做得非常出色,最后有人在Link中着色!(在等待之前:-P 保存 到桌面)我不知道我的老英语老师会说些什么作为静态图像……“它显示了他内心的两面,一方面是和平,另一方面是和平。其他则是争取和平的必要斗争”。我对《塞尔达传说》游戏的热爱已经足够了……花了这么长时间真的很可惜。生成的文件有多大?Ps爱情图片4&5
OliverGriffin

2
@donbright可以理解特征向量的三年级生的确是个非常聪明的孩子-我不确定我是否可以在该级别上解释算法。但是无论如何,让我尝试:假设我们将图片打印到一块坚硬的金属板上。然后,我们小心翼翼地剪掉所有黑色线条,并用更具弹性的东西(例如弹性)替换它们。因此,白色部分是金属板,黑色部分是柔性织物。接下来,我们将整个东西悬挂在绳子上,让它自由移动。现在,如果我们敲击金属板,它们将会振动……
纳撒尼尔

2
@donbright(续)...根据您敲打金属板的方式,它会以不同的方式振动。也许有时候只有一个金属零件会振动,而其他金属零件则不振动,但是在其他时候(因为它们是通过弹性连接的),碰到一块板也会开始使另一块运动。这些不同的振动方式称为振动模式。该程序模拟了该金属板的某些振动模式,但是与其产生声音,而是使用它们来确定绘制哪种颜色。
纳撒尼尔(Nathaniel)'18年

2
@donbright您还可以在此处看到更多有关可视化金属板振动的信息。
纳撒尼尔(Nathaniel)'18年

2
@donbright(这种较技术性的解释也可能会让您有些失落,但这种解释很有用,因为板的振动模式也是使用特征向量计算来计算的。尽管这可能与我的代码不太相同-我(不确定)
。–纳撒尼尔(Nathaniel

25

Python 2 + PIL也是我的第一本图画书

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

除了用“渐变”填充区域并使用不同的颜色循环外,我所做的工作与CarpetPython完全相同。

我最宏伟的色彩: 在此处输入图片说明 在此处输入图片说明 在此处输入图片说明

我机器上的计算时间:

  • 图像1(中国龙):真实0m2.862s用户0m2.801s sys 0m0.061s

  • 图片2(gryffon):真实0m0.991s用户0m0.963s sys 0m0.029s

  • 图像3(独角兽龙):真实0m2.260s用户0m2.239s sys 0m0.021s


不错的渐变!当您将for循环粘贴在for循环内而第一个没有其他内容时,您是否不需要进一步缩进?
奥利弗

当然可以!这是复制/粘贴问题...
节食者

23

Python 2和PIL:迷幻世界

我使用了一种简单的算法,使用自行车调色板中的颜色来填充每个白色区域。结果是非常多彩的,但不是很逼真的。

请注意,这些图片中的“白色”部分不是很白。您也需要测试灰色阴影。

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)

图片示例:

彩龙

LSD上的南瓜


3
可怕的是颜色实际上似乎起作用。您为每个图像着色需要多长时间?文件有多大?
奥利弗

1
该程序在大约2秒钟内为每个图像着色。输出图像尺寸与输入文件相同。文件大小通常比原始文件小10%到40%(可能是因为使用了不同的jpeg压缩设置)。
逻辑骑士

3
代码的简短程度给我留下了深刻的印象!我还喜欢您如何有效地限制可使用的颜色,从而保持固定的托盘状态。我实际上真的很喜欢它,有点像垃圾(是正确的词?我不是艺术家)的氛围。
奥利弗

@OliverGriffin,很高兴您喜欢它。我的目标是创建一个没有亮色或暗色但仍具有一定对比度的调色板。该颜色范围似乎具有最令人愉悦的效果。
逻辑骑士

11

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

我们使用HSV色彩空间,并根据白色区域之间的相对大小选择每个区域的色相。最大的区域将是蓝色(Hue = 0.7),最小的区域将是紫色(Hue = 0.8)。这两个大小之间的区域的色相范围为0.7 -> 1=0 -> 0.8。根据功能线性选择范围上的色相area^0.15。对于每个非黑色像素,饱和度和值始终为1。

彩色图像所需的时间少于1秒。

该算法可正常工作的3个具有封闭区域的图片:

龙

另一条龙

也许是另一条龙

其余图片:

龙

另一条龙

也许是另一条龙

在这些图像上有大的白色连通区域,应该用多种颜色理想地着色(此问题在Nathaniel的解决方案中很好地解决了。


精美的短代码提供了一些漂亮的色彩协调结果!我喜欢您如何使用该区域来确定色调。处理平均图像需要花费多长时间?为什么在某些更详细的图像上不起作用?面积是否太小?
OliverGriffin '16

1
@OliverGriffin在我的帖子中Anwered并添加了其余图像。
randomra

7

带有枕头的Python 3

包含在此答案中的代码有点长,但这是要点

  1. 拍摄输入图像,如果它具有alpha通道,则将其合成到白色背景上。(至少对于鸡肉图像而言,这是必需的,因为整个图像是黑色的,仅通过透明度来区分,因此简单地放置Alpha并没有帮助。)
  2. 将结果转换为灰度;我们不希望压缩或抗锯齿伪像,也不希望灰白的线条弄乱我们。
  3. 创建结果的双层(黑白)副本。根据图像中白色和最暗阴影之间的可配置截止阈值,将灰色阴影转换为黑色或白色。
  4. 泛洪填充图像的每个白色区域。使用可选择的调色板随机选择颜色,该调色板考虑了注水填充操作起点的位置。
  5. 用最邻近的颜色填充黑线。通过避免每个彩色区域都被锯齿状黑色边框包围,这有助于我们重新引入抗锯齿功能。
  6. 从第2步中获取灰度图像,并从中制作一个alpha蒙版:最暗的颜色完全不透明,最亮的颜色完全透明。
  7. 使用此Alpha蒙版将灰度图像合成到步骤5的彩色图像上。

不幸的是,最后几步仍然没有消除在较暗的区域中可见的较轻的“光晕”,但至少它们已经产生了显着的变化。图像处理从来都不是我的研究领域,所以据我所知,有更成功,更高效的算法可以完成我在这里尝试做的事情……但是,好吧。

到目前为止,第4步只有两个可选调色板:一个是纯随机调色板,一个是非常粗糙的“自然”调色板,试图将天空色分配给上角,将草色分配给下角,棕色(岩石或木头) )的颜色设置到每边的中间,中间的颜色则不同。成功一直...有限。


用法:

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

样品:

paint_by_prog.py -t 0.7 Gryphon-Lines.png 彩色狮ry

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 彩色的grunge龙

paint_by_prog.py stejar-arbore-schiţă-natura.png 彩色的树,看起来很像旗

这只鸡看起来不太好,我对链接图像的最新结果也不是最好。来自较早版本代码的代码主要是浅黄色,并具有有趣的沙漠氛围。


性能:

每个图像使用默认设置都需要花费几秒钟的时间来处理,这意味着第5步使用了近似的最近邻居算法。真正的最近邻居要慢得多,可能要花半分钟的时间(我实际上没有计时)。


第一张图片看起来很棒,尤其是那只棕色的眼睛。做得好。我也为您获得绿草,南瓜的棕色田野和紫色的云而称赞。
OliverGriffin

3

爪哇

从您选择的调色板中随机选择颜色。

警告:除非白色区域异常小,否则区域查找目前非常缓慢。

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

需要两个输入:文件名和调色板ID。包括一些抗锯齿校正,但不包括透明像素的逻辑。

当前可以识别以下调色板:

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)

结果:

龙,游戏男孩调色板:

在此处输入图片说明

另一条龙,蓝色+绿色调色板:

在此处输入图片说明

GOL静物蒙娜丽莎(由该程序渲染),三色调色板:

在此处输入图片说明


+1可定制颜色!:)如果您可以解决抗锯齿问题,那就更好了。您输出这些图像花了多长时间?
奥利弗
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.