नंबरों द्वारा पेंट


42

आपको एक सही रंग छवि दी गई है। आपका काम इस छवि है, जो लगता है कि इसे का उपयोग चित्रित किया गया था का एक संस्करण उत्पन्न करने के लिए है रंग-दर-संख्या (, बच्चों की गतिविधियों नहीं Nonograms)। छवि के साथ, आपको दो पैरामीटर दिए गए हैं: पी , रंग पैलेट का अधिकतम आकार (यानी उपयोग करने के लिए अलग-अलग रंगों की अधिकतम संख्या), और एन , कोशिकाओं की अधिकतम संख्या का उपयोग करने के लिए। आपका एल्गोरिथ्म है नहीं सभी का उपयोग करने के पी रंग और एन कोशिकाओं है, लेकिन यह है कि अधिक से अधिक उपयोग नहीं करना चाहिए। आउटपुट इमेज में इनपुट के समान आयाम होने चाहिए।

एक सेल को पिक्सेल के एक सन्निहित क्षेत्र के रूप में परिभाषित किया गया है, जिसमें सभी का रंग समान है। केवल एक कोने पर स्पर्श करने वाले पिक्सेल को सन्निहित नहीं माना जाता है। कोशिकाओं में छेद हो सकते हैं।

संक्षेप में, आप केवल एन फ्लैट-शेडेड / सॉलिड-कलर क्षेत्रों और P अलग-अलग रंगों के साथ इनपुट इमेज को अनुमानित करते हैं।

बस मापदंडों की कल्पना करने के लिए, यहां एक बहुत ही सरल उदाहरण है (कोई विशेष इनपुट छवि के लिए, मेरी पागल पेंट कौशल दिखावा)। निम्नलिखित छवि में P = 6 और N = 11 है :

यहाँ छवि विवरण दर्ज करें

यहाँ आपके एल्गोरिथ्म का परीक्षण करने के लिए कुछ चित्र दिए गए हैं (अधिकतर हमारे सामान्य संदिग्ध)। बड़े संस्करणों के लिए चित्रों पर क्लिक करें।

महान लहर मूंगा - चट्टान इंद्रधनुष तारों भरी रात नदी भूरे भालू झरना एक प्रकार का बंदर केकड़ा नेबुला अमेरिकन गोथिक मोना लीसा चीख

कृपया विभिन्न मापदंडों के लिए मुट्ठी भर परिणाम शामिल करें। यदि आप बड़ी संख्या में परिणाम दिखाना चाहते हैं, तो आप जवाबों के आकार को उचित रखने के लिए imgur.com पर एक गैलरी बना सकते हैं । वैकल्पिक रूप से, अपनी पोस्ट में थंबनेल डालें और उन्हें बड़ी छवियों के लिंक बनाएं, जैसे मैंने ऊपर किया था। इसके अलावा, यदि आपको कुछ अच्छा लगता है, तो अन्य परीक्षण छवियों का उपयोग करने के लिए स्वतंत्र महसूस करें।

मुझे लगता है कि एन , 500 , पी ~ 30 के आसपास के पैरामीटर वास्तविक पेंट-बाय-नंबर टेम्पलेट्स के समान होंगे।

यह एक लोकप्रियता प्रतियोगिता है, इसलिए सबसे शुद्ध वोटों के साथ जवाब जीत जाता है। मतदाताओं को जवाब देने के लिए प्रोत्साहित किया जाता है

  • मूल चित्र कितने अच्छे हैं।
  • एल्गोरिथ्म विभिन्न प्रकार की छवियों पर कितनी अच्छी तरह काम करता है (चित्र आमतौर पर तस्वीरों की तुलना में आसान होते हैं)।
  • एल्गोरिथ्म कितनी अच्छी तरह से प्रतिबंधात्मक मापदंडों के साथ काम करता है।
  • कोशिका के आकार को कैसे कार्बनिक / सुचारू बनाते हैं।

परिणामों को मान्य करने के लिए मैं निम्नलिखित गणित लिपि का उपयोग करूंगा:

image = <pastedimagehere> // ImageData;
palette = Union[Join @@ image];
Print["P = ", Length@palette];
grid = GridGraph[Reverse@Most@Dimensions@image];
image = Flatten[image /. Thread[palette -> Range@Length@palette]];
Print["N = ", 
 Length@ConnectedComponents[
   Graph[Cases[EdgeList[grid], 
     m_ <-> n_ /; image[[m]] == image[[n]]]]]]

Sp3000, PIL का उपयोग करके पाइथन 2 में एक वेरिफ़ायर लिखने के लिए पर्याप्त था, जो आपको इस पास्टबिन में मिलता है


2
सबसे कुशल बात नहीं है, लेकिन यहाँ एक पायथन 2 पीआईएल सत्यापनकर्ता है
Sp3000

कितना प्यारा सवाल है, लेकिन मुझे उम्मीद थी कि हम उचित "पेंट बाय नंबर्स" संस्करण भी देखेंगे। यह संख्याओं के साथ है, इसलिए मैं उत्तर का उपयोग कर सकता हूं :)

@ लिम्बिक मैं मूल रूप से इसे शामिल करना चाहता था, लेकिन मुझे लगा कि यह प्रश्न के दिलचस्प हिस्से से विचलित है। हालाँकि, सबमिशन में से किसी एक का आउटपुट लेना और टेम्प्लेट में बदलना कठिन नहीं होना चाहिए।
मार्टिन एंडर

यह एक आकर्षक पोस्ट है। क्या किसी ने नंबर द्वारा वास्तविक पेंट की तरह रंग संख्याओं को जोड़ने का अतिरिक्त कदम उठाया है?
बी ब्लेयर

जवाबों:


39

पीआईएल ( गैलरी ) के साथ अजगर 2

from __future__ import division
from PIL import Image
import random, math, time
from collections import Counter, defaultdict, namedtuple

"""
Configure settings here
"""

INFILE = "spheres.png"
OUTFILE_STEM = "out"
P = 30
N = 300
OUTPUT_ALL = True # Whether to output the image at each step

FLOOD_FILL_TOLERANCE = 10
CLOSE_CELL_TOLERANCE = 5
SMALL_CELL_THRESHOLD = 10
FIRST_PASS_N_RATIO = 1.5
K_MEANS_TRIALS = 30
BLUR_RADIUS = 2
BLUR_RUNS = 3

"""
Color conversion functions
"""

X = xrange

# http://www.easyrgb.com/?X=MATH    
def rgb2xyz(rgb):
 r,g,b=rgb;r/=255;g/=255;b/=255;r=((r+0.055)/1.055)**2.4 if r>0.04045 else r/12.92
 g=((g+0.055)/1.055)**2.4 if g>0.04045 else g/12.92;b=((b+0.055)/1.055)**2.4 if b>0.04045 else b/12.92
 r*=100;g*=100;b*=100;x=r*0.4124+g*0.3576+b*0.1805;y=r*0.2126+g*0.7152+b*0.0722
 z=r*0.0193+g*0.1192+b*0.9505;return(x,y,z)
def xyz2lab(xyz):
 x,y,z=xyz;x/=95.047;y/=100;z/=108.883;x=x**(1/3)if x>0.008856 else 7.787*x+16/116
 y=y**(1/3)if y>0.008856 else 7.787*y+16/116;z=z**(1/3)if z>0.008856 else 7.787*z + 16/116
 L=116*y-16;a=500*(x-y);b=200*(y-z);return(L,a,b)
def rgb2lab(rgb):return xyz2lab(rgb2xyz(rgb))
def lab2xyz(lab):
 L,a,b=lab;y=(L+16)/116;x=a/500+y;z=y-b/200;y=y**3 if y**3>0.008856 else(y-16/116)/7.787
 x=x**3 if x**3>0.008856 else (x-16/116)/7.787;z=z**3 if z**3>0.008856 else(z-16/116)/7.787
 x*=95.047;y*=100;z*=108.883;return(x,y,z)
def xyz2rgb(xyz):
 x,y,z=xyz;x/=100;y/=100;z/=100;r=x*3.2406+y*-1.5372+z*-0.4986
 g=x*-0.9689+y*1.8758+z*0.0415;b=x*0.0557+y*-0.2040+z*1.0570
 r=1.055*(r**(1/2.4))-0.055 if r>0.0031308 else 12.92*r;g=1.055*(g**(1/2.4))-0.055 if g>0.0031308 else 12.92*g
 b=1.055*(b**(1/2.4))-0.055 if b>0.0031308 else 12.92*b;r*=255;g*=255;b*=255;return(r,g,b)
def lab2rgb(lab):rgb=xyz2rgb(lab2xyz(lab));return tuple([int(round(x))for x in rgb])

"""
Stage 1: Read in image and convert to CIELAB
"""

total_time = time.time()

im = Image.open(INFILE)
width, height = im.size

if OUTPUT_ALL:
  im.save(OUTFILE_STEM + "0.png")
  print "Saved image %s0.png" % OUTFILE_STEM

def make_pixlab_map(im):
  width, height = im.size
  pixlab_map = {}

  for i in X(width):
    for j in X(height):
      pixlab_map[(i, j)] = rgb2lab(im.getpixel((i, j)))

  return pixlab_map

pixlab_map = make_pixlab_map(im)

print "Stage 1: CIELAB conversion complete"

"""
Stage 2: Partitioning the image into like-colored cells using flood fill
"""

def d(color1, color2):
  return (abs(color1[0]-color2[0])**2 + abs(color1[1]-color2[1])**2 + abs(color1[2]-color2[2])**2)**.5

def neighbours(pixel):
  results = []

  for neighbour in [(pixel[0]+1, pixel[1]), (pixel[0]-1, pixel[1]),
            (pixel[0], pixel[1]+1), (pixel[0], pixel[1]-1)]:

    if 0 <= neighbour[0] < width and 0 <= neighbour[1] < height:
      results.append(neighbour)

  return results

def flood_fill(start_pixel):
  to_search = {start_pixel}
  cell = set()
  searched = set()
  start_color = pixlab_map[start_pixel]

  while to_search:
    pixel = to_search.pop()

    if d(start_color, pixlab_map[pixel]) < FLOOD_FILL_TOLERANCE:
      cell.add(pixel)
      unplaced_pixels.remove(pixel)

      for n in neighbours(pixel):
        if n in unplaced_pixels and n not in cell and n not in searched:
          to_search.add(n)

    else:
      searched.add(pixel)

  return cell

# These two maps are inverses, pixel/s <-> number of cell containing pixel
cell_sets = {}
pixcell_map = {}
unplaced_pixels = {(i, j) for i in X(width) for j in X(height)}

while unplaced_pixels:
  start_pixel = unplaced_pixels.pop()
  unplaced_pixels.add(start_pixel)
  cell = flood_fill(start_pixel)

  cellnum = len(cell_sets)
  cell_sets[cellnum] = cell

  for pixel in cell:
    pixcell_map[pixel] = cellnum

print "Stage 2: Flood fill partitioning complete, %d cells" % len(cell_sets)

"""
Stage 3: Merge cells with less than a specified threshold amount of pixels to reduce the number of cells
     Also good for getting rid of some noise
"""

def mean_color(cell, color_map):
  L_sum = 0
  a_sum = 0
  b_sum = 0

  for pixel in cell:
    L, a, b = color_map[pixel]
    L_sum += L
    a_sum += a
    b_sum += b

  return L_sum/len(cell), a_sum/len(cell), b_sum/len(cell)

def remove_small(cell_size):
  if len(cell_sets) <= N:
    return

  small_cells = []

  for cellnum in cell_sets:
    if len(cell_sets[cellnum]) <= cell_size:
      small_cells.append(cellnum)

  for cellnum in small_cells:
    neighbour_cells = []

    for cell in cell_sets[cellnum]:
      for n in neighbours(cell):
        neighbour_reg = pixcell_map[n]

        if neighbour_reg != cellnum:
          neighbour_cells.append(neighbour_reg)

    closest_cell = max(neighbour_cells, key=neighbour_cells.count)

    for cell in cell_sets[cellnum]:
      pixcell_map[cell] = closest_cell

    if len(cell_sets[closest_cell]) <= cell_size:
      small_cells.remove(closest_cell)

    cell_sets[closest_cell] |= cell_sets[cellnum]
    del cell_sets[cellnum]

    if len(cell_sets) <= N:
      return

for cell_size in X(1, SMALL_CELL_THRESHOLD):
  remove_small(cell_size)

if OUTPUT_ALL:
  frame_im = Image.new("RGB", im.size)

  for cellnum in cell_sets:
    cell_color = mean_color(cell_sets[cellnum], pixlab_map)

    for pixel in cell_sets[cellnum]:
      frame_im.putpixel(pixel, lab2rgb(cell_color))

  frame_im.save(OUTFILE_STEM + "1.png")
  print "Saved image %s1.png" % OUTFILE_STEM

print "Stage 3: Small cell merging complete, %d cells" % len(cell_sets)

"""
Stage 4: Close color merging
"""

cell_means = {}

for cellnum in cell_sets:
  cell_means[cellnum] = mean_color(cell_sets[cellnum], pixlab_map)

n_graph = defaultdict(set)

for i in X(width):
  for j in X(height):
    pixel = (i, j)
    cell = pixcell_map[pixel]

    for n in neighbours(pixel):
      neighbour_cell = pixcell_map[n]

      if neighbour_cell != cell:
        n_graph[cell].add(neighbour_cell)
        n_graph[neighbour_cell].add(cell)

def merge_cells(merge_from, merge_to):
  merge_from_cell = cell_sets[merge_from]

  for pixel in merge_from_cell:
    pixcell_map[pixel] = merge_to

  del cell_sets[merge_from]
  del cell_means[merge_from]

  n_graph[merge_to] |= n_graph[merge_from]
  n_graph[merge_to].remove(merge_to)

  for n in n_graph[merge_from]:
    n_graph[n].remove(merge_from)

    if n != merge_to:
      n_graph[n].add(merge_to)

  del n_graph[merge_from]

  cell_sets[merge_to] |= merge_from_cell
  cell_means[merge_to] = mean_color(cell_sets[merge_to], pixlab_map)

# Go through the cells from largest to smallest. Keep replenishing the list while we can still merge.
last_time = time.time()
to_search = sorted(cell_sets.keys(), key=lambda x:len(cell_sets[x]), reverse=True)
full_list = True

while len(cell_sets) > N and to_search:
  if time.time() - last_time > 15:
    last_time = time.time()
    print "Close color merging... (%d cells remaining)" % len(cell_sets)

  while to_search:
    cellnum = to_search.pop()
    close_cells = []

    for neighbour_cellnum in n_graph[cellnum]:
      if d(cell_means[cellnum], cell_means[neighbour_cellnum]) < CLOSE_CELL_TOLERANCE:
        close_cells.append(neighbour_cellnum)

    if close_cells:
      for neighbour_cellnum in close_cells:
        merge_cells(neighbour_cellnum, cellnum)

        if neighbour_cellnum in to_search:
          to_search.remove(neighbour_cellnum)

      break

  if full_list == True:
    if to_search:
      full_list = False

  else:
    if not to_search:
      to_search = sorted(cell_sets.keys(), key=lambda x:len(cell_sets[x]), reverse=True)
      full_list = True

if OUTPUT_ALL:
  frame_im = Image.new("RGB", im.size)

  for cellnum in cell_sets:
    cell_color = cell_means[cellnum]

    for pixel in cell_sets[cellnum]:
      frame_im.putpixel(pixel, lab2rgb(cell_color))

  frame_im.save(OUTFILE_STEM + "2.png")
  print "Saved image %s2.png" % OUTFILE_STEM

print "Stage 4: Close color merging complete, %d cells" % len(cell_sets)

"""
Stage 5: N-merging - merge until <= N cells
     Want to merge either 1) small cells or 2) cells close in color
"""

# Weight score between neighbouring cells by 1) size of cell and 2) color difference
def score(cell1, cell2):
  return d(cell_means[cell1], cell_means[cell2]) * len(cell_sets[cell1])**.5

n_scores = {}

for cellnum in cell_sets:
  for n in n_graph[cellnum]:
    n_scores[(n, cellnum)] = score(n, cellnum)

last_time = time.time()

while len(cell_sets) > N * FIRST_PASS_N_RATIO:
  if time.time() - last_time > 15:
    last_time = time.time()
    print "N-merging... (%d cells remaining)" % len(cell_sets)

  merge_from, merge_to = min(n_scores, key=lambda x: n_scores[x])

  for n in n_graph[merge_from]:
    del n_scores[(merge_from, n)]
    del n_scores[(n, merge_from)]

  merge_cells(merge_from, merge_to)

  for n in n_graph[merge_to]:
    n_scores[(n, merge_to)] = score(n, merge_to)
    n_scores[(merge_to, n)] = score(merge_to, n)

if OUTPUT_ALL:
  frame_im = Image.new("RGB", im.size)

  for cellnum in cell_sets:
    cell_color = cell_means[cellnum]

    for pixel in cell_sets[cellnum]:
      frame_im.putpixel(pixel, lab2rgb(cell_color))

  frame_im.save(OUTFILE_STEM + "3.png")
  print "Saved image %s3.png" % OUTFILE_STEM

del n_graph, n_scores

print "Stage 5: N-merging complete, %d cells" % len(cell_sets)

"""
Stage 6: P merging - use k-means
"""

def form_clusters(centroids):
  clusters = defaultdict(set)

  for cellnum in cell_sets:
    # Add cell to closest centroid.
    scores = []

    for centroid in centroids:
      scores.append((d(centroid, cell_means[cellnum]), centroid))

    scores.sort()
    clusters[scores[0][1]].add(cellnum)

  return clusters

def calculate_centroid(cluster):
  L_sum = 0
  a_sum = 0
  b_sum = 0

  weighting = 0

  for cellnum in cluster:
    # Weight based on cell size
    color = cell_means[cellnum]
    cell_weight = len(cell_sets[cellnum])**.5

    L_sum += color[0]*cell_weight
    a_sum += color[1]*cell_weight
    b_sum += color[2]*cell_weight

    weighting += cell_weight

  return (L_sum/weighting, a_sum/weighting, b_sum/weighting)

def db_index(clusters):
  # Davies-Bouldin index
  scatter = {}

  for centroid, cluster in clusters.items():
    scatter_score = 0

    for cellnum in cluster:
      scatter_score += d(cell_means[cellnum], centroid) * len(cell_sets[cellnum])**.5

    scatter_score /= len(cluster)
    scatter[centroid] = scatter_score**2 # Mean squared distance

  index = 0

  for ci, cluster in clusters.items():
    dist_scores = []

    for cj in clusters:
      if ci != cj:
        dist_scores.append((scatter[ci] + scatter[cj])/d(ci, cj))

    index += max(dist_scores)

  return index

best_clusters = None
best_index = None

for i in X(K_MEANS_TRIALS):  
  centroids = {cell_means[cellnum] for cellnum in random.sample(cell_sets, P)}
  converged = False

  while not converged:
    clusters = form_clusters(centroids)
    new_centroids = {calculate_centroid(cluster) for cluster in clusters.values()}

    if centroids == new_centroids:
      converged = True

    centroids = new_centroids

  index = db_index(clusters)

  if best_index is None or index < best_index:
    best_index = index
    best_clusters = clusters

del cell_means
newpix_map = {}

for centroid, cluster in best_clusters.items():
  for cellnum in cluster:
    for pixel in cell_sets[cellnum]:
      newpix_map[pixel] = centroid

if OUTPUT_ALL:
  frame_im = Image.new("RGB", im.size)

  for pixel in newpix_map:
    frame_im.putpixel(pixel, lab2rgb(newpix_map[pixel]))

  frame_im.save(OUTFILE_STEM + "4.png")
  print "Saved image %s4.png" % OUTFILE_STEM

print "Stage 6: P-merging complete"

"""
Stage 7: Approximate Gaussian smoothing
     See http://blog.ivank.net/fastest-gaussian-blur.html
"""

# Hindsight tells me I should have used a class. I hate hindsight.
def vec_sum(vectors):
  assert(vectors and all(len(v) == len(vectors[0]) for v in vectors))
  return tuple(sum(x[i] for x in vectors) for i in X(len(vectors[0])))

def linear_blur(color_list):
  # Can be made faster with an accumulator
  output = []

  for i in X(len(color_list)):
    relevant_pixels = color_list[max(i-BLUR_RADIUS+1, 0):i+BLUR_RADIUS]
    pixsum = vec_sum(relevant_pixels)
    output.append(tuple(pixsum[i]/len(relevant_pixels) for i in X(3)))

  return output

def horizontal_blur():
  for row in X(height):
    colors = [blurpix_map[(i, row)] for i in X(width)]
    colors = linear_blur(colors)

    for i in X(width):
      blurpix_map[(i, row)] = colors[i]

def vertical_blur():
  for column in X(width):
    colors = [blurpix_map[(column, j)] for j in X(height)]
    colors = linear_blur(colors)

    for j in X(height):
      blurpix_map[(column, j)] = colors[j]

blurpix_map = {}

for i in X(width):
  for j in X(height):
    blurpix_map[(i, j)] = newpix_map[(i, j)]

for i in X(BLUR_RUNS):
  vertical_blur()
  horizontal_blur()

# Pixel : color of smoothed image
smoothpix_map = {}

for i in X(width):
  for j in X(height):
    pixel = (i, j)
    blur_color = blurpix_map[pixel]
    nearby_colors = {newpix_map[pixel]}

    for n in neighbours(pixel):
      nearby_colors.add(newpix_map[n])

    smoothpix_map[pixel] = min(nearby_colors, key=lambda x: d(x, blur_color))

del newpix_map, blurpix_map

if OUTPUT_ALL:
  frame_im = Image.new("RGB", im.size)

  for pixel in smoothpix_map:
    frame_im.putpixel(pixel, lab2rgb(smoothpix_map[pixel]))

  frame_im.save(OUTFILE_STEM + "5.png")
  print "Saved image %s5.png" % OUTFILE_STEM

print "Stage 7: Smoothing complete"

"""
Stage 8: Flood fill pass 2
     Code copy-and-paste because I'm lazy
"""

def flood_fill(start_pixel):
  to_search = {start_pixel}
  cell = set()
  searched = set()
  start_color = smoothpix_map[start_pixel]

  while to_search:
    pixel = to_search.pop()

    if start_color == smoothpix_map[pixel]:
      cell.add(pixel)
      unplaced_pixels.remove(pixel)

      for n in neighbours(pixel):
        if n in unplaced_pixels and n not in cell and n not in searched:
          to_search.add(n)

    else:
      searched.add(pixel)

  return cell

cell_sets = {}
pixcell_map = {}
unplaced_pixels = {(i, j) for i in X(width) for j in X(height)}

while unplaced_pixels:
  start_pixel = unplaced_pixels.pop()
  unplaced_pixels.add(start_pixel)
  cell = flood_fill(start_pixel)

  cellnum = len(cell_sets)
  cell_sets[cellnum] = cell

  for pixel in cell:
    pixcell_map[pixel] = cellnum

cell_colors = {}

for cellnum in cell_sets:
  cell_colors[cellnum] = smoothpix_map[next(iter(cell_sets[cellnum]))]

print "Stage 8: Flood fill pass 2 complete, %d cells" % len(cell_sets)

"""
Stage 9: Small cell removal pass 2
"""

def score(cell1, cell2):
  return d(cell_colors[cell1], cell_colors[cell2]) * len(cell_sets[cell1])**.5

def remove_small(cell_size):  
  small_cells = []

  for cellnum in cell_sets:
    if len(cell_sets[cellnum]) <= cell_size:
      small_cells.append(cellnum)

  for cellnum in small_cells:
    neighbour_cells = []

    for cell in cell_sets[cellnum]:
      for n in neighbours(cell):
        neighbour_reg = pixcell_map[n]

        if neighbour_reg != cellnum:
          neighbour_cells.append(neighbour_reg)

    closest_cell = max(neighbour_cells, key=neighbour_cells.count)

    for cell in cell_sets[cellnum]:
      pixcell_map[cell] = closest_cell

    if len(cell_sets[closest_cell]) <= cell_size:
      small_cells.remove(closest_cell)

    cell_color = cell_colors[closest_cell]

    for pixel in cell_sets[cellnum]:
      smoothpix_map[pixel] = cell_color

    cell_sets[closest_cell] |= cell_sets[cellnum]
    del cell_sets[cellnum]
    del cell_colors[cellnum]

for cell_size in X(1, SMALL_CELL_THRESHOLD):
  remove_small(cell_size)

if OUTPUT_ALL:
  frame_im = Image.new("RGB", im.size)

  for pixel in smoothpix_map:
    frame_im.putpixel(pixel, lab2rgb(smoothpix_map[pixel]))

  frame_im.save(OUTFILE_STEM + "6.png")
  print "Saved image %s6.png" % OUTFILE_STEM

print "Stage 9: Small cell removal pass 2 complete, %d cells" % len(cell_sets)

"""
Stage 10: N-merging pass 2
     Necessary as stage 7 might generate *more* cells
"""

def merge_cells(merge_from, merge_to):
  merge_from_cell = cell_sets[merge_from]

  for pixel in merge_from_cell:
    pixcell_map[pixel] = merge_to

  del cell_sets[merge_from]
  del cell_colors[merge_from]

  n_graph[merge_to] |= n_graph[merge_from]
  n_graph[merge_to].remove(merge_to)

  for n in n_graph[merge_from]:
    n_graph[n].remove(merge_from)

    if n != merge_to:
      n_graph[n].add(merge_to)

  del n_graph[merge_from]

  cell_color = cell_colors[merge_to]

  for pixel in merge_from_cell:
    smoothpix_map[pixel] = cell_color

  cell_sets[merge_to] |= merge_from_cell

n_graph = defaultdict(set)

for i in X(width):
  for j in X(height):
    pixel = (i, j)
    cell = pixcell_map[pixel]

    for n in neighbours(pixel):
      neighbour_cell = pixcell_map[n]

      if neighbour_cell != cell:
        n_graph[cell].add(neighbour_cell)
        n_graph[neighbour_cell].add(cell)

n_scores = {}

for cellnum in cell_sets:
  for n in n_graph[cellnum]:
    n_scores[(n, cellnum)] = score(n, cellnum)

last_time = time.time()

while len(cell_sets) > N:
  if time.time() - last_time > 15:
    last_time = time.time()
    print "N-merging (pass 2)... (%d cells remaining)" % len(cell_sets)

  merge_from, merge_to = min(n_scores, key=lambda x: n_scores[x])

  for n in n_graph[merge_from]:
    del n_scores[(merge_from, n)]
    del n_scores[(n, merge_from)]

  merge_cells(merge_from, merge_to)

  for n in n_graph[merge_to]:
    n_scores[(n, merge_to)] = score(n, merge_to)
    n_scores[(merge_to, n)] = score(merge_to, n)

print "Stage 10: N-merging pass 2 complete, %d cells" % len(cell_sets)

"""
Stage last: Output the image!
"""

test_im = Image.new("RGB", im.size)

for i in X(width):
  for j in X(height):
    test_im.putpixel((i, j), lab2rgb(smoothpix_map[(i, j)]))

if OUTPUT_ALL:
  test_im.save(OUTFILE_STEM + "7.png")
else:
  test_im.save(OUTFILE_STEM + ".png")

print "Done! (Time taken: {})".format(time.time() - total_time)

समय सुधारें! यह अपडेट छवियों को कम फजी दिखने के लिए एक सरल स्मूथिंग एल्गोरिदम की सुविधा देता है। अगर मैं फिर से अपडेट करता हूं, तो मुझे अपने कोड का एक अच्छा हिस्सा फिर से बदलना होगा, क्योंकि यह गन्दा हो रहा है और मैं एचडी 2 एफएफ एक एफडब्ल्यू thngs 2 mke टी चार लिम को चमकता हूं।

मैंने सेल के आकार के आधार पर k- साधन वज़न के रंग भी बनाए हैं, जो अधिक प्रतिबंधात्मक मापदंडों (जैसे निहारिका और अमेरिकी गोथिक के पिचफोर्क का केंद्र) के लिए कुछ विवरण खो देता है, लेकिन समग्र रंग विकल्प को तेज और अच्छा बनाता है। दिलचस्प है, यह पी = 5 के लिए किरणित क्षेत्रों के लिए पूरी पृष्ठभूमि खो देता है।

एल्गोरिथम सारांश:

  1. पिक्सेल को CIELAB रंग स्थान में बदलें : CIELAB RGB से बेहतर मानव दृष्टि का अनुमान लगाता है। मूल रूप से मैंने एचएसएल (ह्यू, संतृप्ति, लपट) का इस्तेमाल किया था , लेकिन इसकी दो समस्याएं थीं - सफेद / ग्रे / काले रंग की धुंध अपरिभाषित है, और ह्यू को उन डिग्री में मापा जाता है जो चारों ओर लपेटते हैं, जिससे k- साधनों का उपयोग करना मुश्किल हो जाता है।
  2. बाढ़ भराव का उपयोग करके छवि को समान रंगों वाली कोशिकाओं में विभाजित करें: एक पिक्सेल को सेल में नहीं चुनें और एक निर्दिष्ट सहिष्णुता का उपयोग करके बाढ़ भरें। दो रंगों के बीच की दूरी को मापने के लिए मैं मानक यूक्लिडियन मानक का उपयोग करता हूं। इस विकी लेख पर अधिक जटिल सूत्र उपलब्ध हैं ।
  3. अपने पड़ोसियों के साथ छोटी कोशिकाओं को मिलाएं : बाढ़ भराव 1 या 2 पिक्सेल कोशिकाओं का एक बहुत उत्पन्न करता है - सबसे आसन्न पिक्सल के साथ पड़ोसी सेल के साथ एक निर्दिष्ट आकार से कम कोशिकाओं को मर्ज करता है। यह काफी कोशिकाओं की संख्या को कम करता है, बाद के चरणों के लिए समय में सुधार करता है।
  4. समान रूप से रंग वाले क्षेत्रों को मिलाएं : घटते आकार के क्रम में कोशिकाओं से गुजरें। यदि किसी भी पड़ोसी सेल का मतलब एक निश्चित दूरी से कम रंग है, तो कोशिकाओं को मर्ज करें। कोशिकाओं के माध्यम से जा रहा जब तक कोई और विलय नहीं किया जा सकता है।
  5. मर्ज तब तक करें जब तक हमारे पास 1.5N से कम सेल (एन-मर्जिंग) न हों : सेल के आकार और रंग अंतर के आधार पर स्कोरिंग का उपयोग करते हुए एक साथ कोशिकाओं को मिलाएं, जब तक कि हमारे पास अधिकतम 1.5N सेल न हों। जैसा कि हम बाद में फिर से विलय करेंगे, हम लेवे की थोड़ी अनुमति देते हैं।
  6. जब तक हमारे पास पी रंग से कम नहीं हो जाते, तब तक मर्ज करें, जिसका उपयोग k- मीन्स (P-मर्जिंग) का उपयोग करें: सेल रंगों के आधार पर वज़निंग सेल रंगों के क्लस्टरिंग को उत्पन्न करने के लिए कुछ निर्दिष्ट संख्या में k-मतलब क्लस्टरिंग एल्गोरिथ्म का उपयोग करें । प्रत्येक क्लस्टरिंग को डेविस-बोल्डिन इंडेक्स की भिन्नता के आधार पर स्कोर करें और उपयोग करने के लिए सबसे अच्छी क्लस्टरिंग चुनें।
  7. अनुमानित गाऊसी चौरसाई : गौसियन धुंधला (अनुमानित विवरण ) अनुमानित करने के लिए कई रैखिक ब्लर्स का उपयोग करें । फिर प्रत्येक पिक्सेल के लिए, पूर्व-धुंधली छवि में अपने और अपने पड़ोसियों के रंग को अपने रंग के सबसे करीब से चुनें। यदि मैं अभी तक इष्टतम एल्गोरिथ्म को लागू करने के लिए आवश्यक हो तो इस भाग को अधिक समय-वार अनुकूलित किया जा सकता है।
  8. नए क्षेत्रों में काम करने के लिए एक और बाढ़ भरें पास : यह आवश्यक है क्योंकि पिछले चरण वास्तव में अधिक सेल उत्पन्न कर सकते हैं।
  9. एक और छोटी सेल मर्जिंग पास करें
  10. एक और एन-मर्जिंग पास करें : इस बार हम 1.5N के बजाय एन कोशिकाओं तक जाते हैं।

प्रत्येक छवि के लिए प्रसंस्करण का समय उसके आकार और जटिलता पर निर्भर करता है, जिसमें परीक्षण छवियों के लिए 20 सेकंड से 7 मिनट तक का समय होता है।

क्योंकि एल्गोरिथ्म यादृच्छिकता का उपयोग करता है (जैसे विलय, k- साधन), आप अलग-अलग रन पर अलग-अलग परिणाम प्राप्त कर सकते हैं। यहाँ भालू की छवि के लिए दो रन की तुलना N = 50 और P = 10 के साथ की गई है:

एफ म


नोट: नीचे सभी चित्र लिंक हैं। इनमें से अधिकांश चित्र पहले रन से सीधे हैं, लेकिन अगर मुझे आउटपुट पसंद नहीं आया, तो मैंने खुद को निष्पक्ष होने के लिए तीन प्रयासों तक की अनुमति दी।

एन = 50, पी = 10

एल म ए आर क घ ओ w n जी ओ एल

एन = 500, पी = 30

च । । । : ( ए ए ए ए ए ए

लेकिन मैं बहुत आलसी हूं जब रंगों से रंगना आता है, तो बस मनोरंजन के लिए ...

एन = 20, पी = 5

ए ए ए ए ए ए ए ए ए ए ए ए

इसके अतिरिक्त, यह देखने में मनोरंजक है कि जब आप N = 500, P = 30 में 1 मिलियन रंगों को निचोड़ने की कोशिश करते हैं तो क्या होता है :

ए

यहाँ एनिमेटेड GIF प्रारूप में एन = 500 और पी = 30 के साथ पानी के नीचे की छवि के लिए एल्गोरिथ्म का एक कदम दर कदम चलना है:

ए


मैंने यहां एल्गोरिथम के पिछले संस्करणों के लिए एक गैलरी भी बनाई है । यहाँ पिछले संस्करण से मेरे पसंदीदा में से कुछ है (जब से नेबुला में अधिक सितारे थे और भालू ने फरारी देखी थी)

ए ए


अगर किसी को एक्सेप्टेंस मिल रहा है जब प्रोग्राम की पिक्सेल को अनपैक करने की कोशिश कर रहा है, तो ऐसा लगता है कि im = im.convert("RGB")कुछ पिक्स के लिए इसकी जरूरत है। मुझे लगता है मैं कोड थोड़ा पुनर्गठन के बाद में डाल देंगे।
Sp3000

15

पीआईएल के साथ अजगर 2

इसके अलावा एक पायथन समाधान और शायद बहुत काम प्रगति पर है:

from PIL import Image, ImageFilter
import random

def draw(file_name, P, N, M=3):
    img = Image.open(file_name, 'r')
    pixels = img.load()
    size_x, size_y = img.size

    def dist(c1, c2):
        return (c1[0]-c2[0])**2+(c1[1]-c2[1])**2+(c1[2]-c2[2])**2

    def mean(colours):
        n = len(colours)
        r = sum(c[0] for c in colours)//n
        g = sum(c[1] for c in colours)//n
        b = sum(c[2] for c in colours)//n
        return (r,g,b)

    def colourize(colour, palette):
        return min(palette, key=lambda c: dist(c, colour))

    def cluster(colours, k, max_n=10000, max_i=10):
        colours = random.sample(colours, max_n)
        centroids = random.sample(colours, k)
        i = 0
        old_centroids = None
        while not(i>max_i or centroids==old_centroids):
            old_centroids = centroids
            i += 1
            labels = [colourize(c, centroids) for c in colours]
            centroids = [mean([c for c,l in zip(colours, labels)
                               if l is cen]) for cen in centroids]
        return centroids

    all_coords = [(x,y) for x in xrange(size_x) for y in xrange(size_y)]
    all_colours = [pixels[x,y] for x,y in all_coords]
    palette = cluster(all_colours, P)
    print 'clustered'

    for x,y in all_coords:
        pixels[x,y] = colourize(pixels[x,y], palette)
    print 'colourized'

    median_filter = ImageFilter.MedianFilter(size=M)
    img = img.filter(median_filter)
    pixels = img.load()
    for x,y in all_coords:
        pixels[x,y] = colourize(pixels[x,y], palette)
    print 'median filtered'

    def neighbours(edge, outer, colour=None):
        return set((x+a,y+b) for x,y in edge
                   for a,b in ((1,0), (-1,0), (0,1), (0,-1))
                   if (x+a,y+b) in outer
                   and (colour==None or pixels[(x+a,y+b)]==colour))

    def cell(centre, rest):
        colour = pixels[centre]
        edge = set([centre])
        region = set()
        while edge:
            region |= edge
            rest = rest-edge
            edge = set(n for n in neighbours(edge, rest, colour))
        return region, rest

    print 'start segmentation:'
    rest = set(all_coords)
    cells = []
    while rest:
        centre = random.sample(rest, 1)[0]
        region, rest = cell(centre, rest-set(centre))
        cells += [region]
        print '%d pixels remaining'%len(rest)
    cells = sorted(cells, key=len, reverse=True)
    print 'segmented (%d segments)'%len(cells)

    print 'start merging:'
    while len(cells)>N:
        small_cell = cells.pop()
        n = neighbours(small_cell, set(all_coords)-small_cell)
        for big_cell in cells:
            if big_cell & n:
                big_cell |= small_cell
                break
        print '%d segments remaining'%len(cells)
    print 'merged'

    for cell in cells:
        colour = colourize(mean([pixels[x,y] for x,y in cell]), palette)
        for x,y in cell:
            pixels[x,y] = colour
    print 'colorized again'

    img.save('P%d N%d '%(P,N)+file_name)
    print 'saved'

draw('a.png', 11, 500, 1)

एल्गोरिथ्म SP3000 की तुलना में एक अलग दृष्टिकोण का अनुसरण करता है, पहले रंगों से शुरू होता है:

  • पी- रंगों का एक रंग पैलेट k- साधन क्लस्टरिंग द्वारा ढूंढें और इस कम पैलेट में छवि को पेंट करें।

  • कुछ शोर से छुटकारा पाने के लिए एक मामूली माध्य फ़िल्टर लागू करें।

  • सभी मोनोक्रोमैटिक कोशिकाओं की एक सूची बनाएं और इसे आकार के अनुसार क्रमबद्ध करें।

  • अपने सबसे बड़े पड़ोसी के साथ सबसे छोटी कोशिकाओं को तब तक मिलाएं जब तक कि केवल एन कोशिकाएं शेष न हों।

परिणामों की गति और गुणवत्ता दोनों के मामले में सुधार की काफी गुंजाइश है। विशेष रूप से सेल विलय कदम कई मिनट तक ले सकता है और इष्टतम परिणामों से बहुत दूर देता है।


पी = 5, एन = 45

पी = 5, एन = 45पी = 5, एन = 45

पी = 10, एन = 50

पी = 10, एन = 50पी = 10, एन = 50पी = 10, एन = 50पी = 10, एन = 50

पी = 4, एन = 250

पी = 4, एन = 250पी = 4, एन = 250

पी = 11, एन = 500

पी = 11, एन = 500पी = 11, एन = 500


मैंने पहले उसी दृष्टिकोण के बारे में उपयोग करने की कोशिश की (एक कैनवस पर जावास्क्रिप्ट में करने की कोशिश की), लेकिन आखिरकार यह बहुत लंबा रास्ता तय कर रहा था, इसलिए यह देखना वास्तव में अच्छा है कि यह कैसा दिख सकता है, अच्छा काम!
18

बहुत अच्छा काम। मुझे 20 कोशिकाओं वाला भालू बहुत पसंद था।
डेविड डिक

15

मेथेमेटिका

फिलहाल, यह गाऊसी फिल्टर में उपयोग किए जाने वाले रंगों और गाऊसी त्रिज्या की संख्या को लेता है। जितना बड़ा दायरा, रंगों का धुंधला और विलय उतना ही बड़ा।

क्योंकि यह कोशिकाओं की संख्या के इनपुट की अनुमति नहीं देता है, यह चुनौती की बुनियादी आवश्यकताओं में से एक को पूरा नहीं करता है।

आउटपुट में प्रत्येक रंग के लिए कोशिकाओं की संख्या और कोशिकाओं की कुल संख्या भी शामिल है।

quantImg[img_,nColours_,gaussR_]:=ColorQuantize[GaussianFilter[img,gaussR],nColours,
Dithering-> False]

colours[qImg_]:=Union[Flatten[ImageData[qImg],1]]

showColors[image_,nColors_,gaussR_]:=
   Module[{qImg,colors,ca,nCells},
   qImg=quantImg[image,nColors,gaussR];
   colors=colours[qImg];
   ca=ConstantArray[0,Reverse@ImageDimensions[image]];
   nCells[qImgg_,color_]:=
   Module[{r},
   r=ReplacePart[ca,Position[ImageData@qImg,color]/.{a_,b_}:> ({a,b}->1)];
   (*ArrayPlot[r,ColorRules->{1\[Rule]RGBColor[color],0\[Rule]White}];*)
   m=MorphologicalComponents[r];
   {RGBColor@color,Max[Union@Flatten[m,1]]}];
   s=nCells[qImg,#]&/@colors;
   Grid[{
    {Row[{s}]}, {Row[{"cells:\t\t",Tr[s[[All,2]]]}]},{Row[{"colors:\t\t",nColors}]},
    {Row[{"Gauss. Radius: ", gaussR}]}},Alignment->Left]]

अपडेट करें

quantImage2इनपुट के रूप में वांछित संख्या कोशिकाओं को निर्दिष्ट करने की अनुमति देता है। यह एक बेहतरीन गॉसियन रेडियस को निर्धारित करता है कि जब तक कोई करीबी मैच नहीं मिलता तब तक अधिक रेडी के साथ परिदृश्यों के माध्यम से लूपिंग करता है।

quantImage2 आउटपुट (चित्र, अनुरोधित सेल, प्रयुक्त सेल, त्रुटि, गाऊसी रेडियस का उपयोग)।

हालांकि, यह बहुत धीमा है। समय बचाने के लिए, आप एक प्रारंभिक त्रिज्या के साथ शुरू कर सकते हैं, जिसका डिफ़ॉल्ट मान 0 है।

gaussianRadius[img_,nCol_,nCells_,initialRadius_:0]:=
Module[{radius=initialRadius,nc=10^6,results={},r},
While[nc>nCells,(nc=numberOfCells[ape,nColors,radius]);
results=AppendTo[results,{nColors,radius,nc}];radius++];
r=results[[{-2,-1}]];
Nearest[r[[All,3]],200][[1]];
Cases[r,{_,_,Nearest[r[[All,3]],nCells][[1]]}][[1,2]]
]

quantImg2[img_,nColours_,nCells1_,initialRadius_:0]:={ColorQuantize[GaussianFilter[img,
g=gaussianRadius[img,nColours,nCells1,initialRadius]],nColours,Dithering->False],
nCells1,nn=numberOfCells[img,nColours,g],N[(nn-nCells1)/nCells1],g}

उदाहरण जिसके लिए हम आउटपुट में वांछित कोशिकाओं की संख्या निर्दिष्ट करते हैं।

उदाहरण 25 रंगों के साथ 90 कोशिकाओं का अनुरोध करता है। समाधान 88 कोशिकाओं, 2% त्रुटि देता है। समारोह ने 55 के गॉसियन त्रिज्या को चुना। (विकृति के बहुत सारे)।

सर्वोच्च


उदाहरण जिसके लिए इनपुट में गॉसियन त्रिज्या शामिल है, लेकिन कोशिकाओं की संख्या नहीं।

25 कलर्स, 5 पिक्सल का गाऊसी दायरा

nColors = 25;
gR = 5;
quantImg[balls, nColors, gR]

गेंदों


तीन रंग, 17 पिक्सेल का त्रिज्या

nColors=3;gaussianRadius=17;
showColors[wave,nColors,gaussianRadius]
quantImg[wave,nColors,gaussianRadius]

तरंग ३ १ 17


बीस रंग, 17 पिक्सेल का त्रिज्या

हमने रंगों की संख्या बढ़ाई लेकिन फोकस नहीं किया। कोशिकाओं की संख्या में वृद्धि पर ध्यान दें।

लहर २


सिक्स कलर्स, 4 पिक्सल का त्रिज्या

nColors=6;gaussianRadius=4;
showColors[wave,nColors,gaussianRadius]
quantImg[wave,nColors,gaussianRadius]

wave3


nColors = 6; gaussianRadius = 17;
showColors[ape, nColors, gaussianRadius]
quantImg[ape, nColors, gaussianRadius]

एप १


nColors = 6; gaussianRadius = 3;
showColors[ape, nColors, gaussianRadius]
quantImg[ape, nColors, gaussianRadius]

एप २


तारों भरी रात

केवल 6 रंगों और 60 कोशिकाओं के साथ। रंगों में एक रंग बेमेल है जो showColorsइसका उपयोग करता है। (पीला 5 रंगों में से नहीं दिखता है, लेकिन इसका उपयोग ड्राइंग में किया जाता है।) मैं देखूंगा कि क्या मैं इसका पता लगा सकता हूं।

तारों वाली रात 1


यह बिल्कुल भव्य है, और प्रतिबंधात्मक मापदंडों के लिए वास्तव में अच्छी तरह से काम करता है। कोशिकाओं की संख्या को एक पैरामीटर में बदलने का कोई मौका? (मुझे लगता है कि आप कोशिकाओं की संख्या से त्रिज्या के लिए कुछ अनुमान हमेशा पा सकते हैं, इसे लागू करें, और फिर सीमा से नीचे होने तक छोटी कोशिकाओं को मर्ज करें।)
मार्टिन एंडर

showColorsरंगों और राडियों की संख्या के माध्यम से लूपिंग की तालिका बनाना संभव है , और उन संयोजनों को चुनना जो वांछित कोशिकाओं की संख्या के सबसे करीब आते हैं। यकीन नहीं है कि अगर मेरे पास फिलहाल ऐसा करने के लिए गैस है। शायद बाद में।
19

यकीन है, मुझे पता है अगर तुम करते हो। (मैं अन्य छवियों के लिए कुछ और परिणाम देखना पसंद करूंगा। :))
मार्टिन एंडर

2
कोई बात नहीं। नियमों से खेलने के लिए धन्यवाद। ;)
मार्टिन एंडर

1
मुझे गोले पसंद आ रहे हैं! वे अच्छे और गोल हैं
Sp3000

9

पीआईएल के साथ अजगर 2

यह अभी भी कुछ हद तक प्रगति पर है। इसके अलावा, नीचे दिए गए कोड स्पेगेटी की एक भयानक गड़बड़ है, और इसे एक प्रेरणा के रूप में उपयोग नहीं किया जाना चाहिए। :)

from PIL import Image, ImageFilter
from math import sqrt
from copy import copy
from random import shuffle, choice, seed

IN_FILE = "input.png"
OUT_FILE = "output.png"

LOGGING = True
GRAPHICAL_LOGGING = False
LOG_FILE_PREFIX = "out"
LOG_FILE_SUFFIX = ".png"
LOG_ROUND_INTERVAL = 150
LOG_FLIP_INTERVAL = 40000

N = 500
P = 30
BLUR_RADIUS = 3
FILAMENT_ROUND_INTERVAL = 5
seed(0) # Random seed

print("Opening input file...")

image = Image.open(IN_FILE).filter(ImageFilter.GaussianBlur(BLUR_RADIUS))
pixels = {}
width, height = image.size

for i in range(width):
    for j in range(height):
        pixels[(i, j)] = image.getpixel((i, j))

def dist_rgb((a,b,c), (d,e,f)):
    return (a-d)**2 + (b-e)**2 + (c-f)**2

def nbors((x,y)):
    if 0 < x:
        if 0 < y:
            yield (x-1,y-1)
        if y < height-1:
            yield (x-1,y+1)
    if x < width - 1:
        if 0 < y:
            yield (x+1,y-1)
        if y < height-1:
            yield (x+1,y+1)

def full_circ((x,y)):
    return ((x+1,y), (x+1,y+1), (x,y+1), (x-1,y+1), (x-1,y), (x-1,y-1), (x,y-1), (x+1,y-1))

class Region:

    def __init__(self):
        self.points = set()
        self.size = 0
        self.sum = (0,0,0)

    def flip_point(self, point):
        sum_r, sum_g, sum_b = self.sum
        r, g, b = pixels[point]
        if point in self.points:
            self.sum = (sum_r - r, sum_g - g, sum_b - b)
            self.size -= 1
            self.points.remove(point)
        else:
            self.sum = (sum_r + r, sum_g + g, sum_b + b)
            self.size += 1
            self.points.add(point)

    def mean_with(self, color):
        if color is None:
            s = float(self.size)
            r, g, b = self.sum
        else:
            s = float(self.size + 1)
            r, g, b = map(lambda a,b: a+b, self.sum, color)
        return (r/s, g/s, b/s)

print("Initializing regions...")

aspect_ratio = width / float(height)
a = int(sqrt(N)*aspect_ratio)
b = int(sqrt(N)/aspect_ratio)

num_components = a*b
owners = {}
regions = [Region() for i in range(P)]
borders = set()

nodes = [(i,j) for i in range(a) for j in range(b)]
shuffle(nodes)
node_values = {(i,j):None for i in range(a) for j in range(b)}

for i in range(P):
    node_values[nodes[i]] = regions[i]

for (i,j) in nodes[P:]:
    forbiddens = set()
    for node in (i,j-1), (i,j+1), (i-1,j), (i+1,j):
        if node in node_values and node_values[node] is not None:
            forbiddens.add(node_values[node])
    node_values[(i,j)] = choice(list(set(regions) - forbiddens))

for (i,j) in nodes:
    for x in range((width*i)/a, (width*(i+1))/a):
        for y in range((height*j)/b, (height*(j+1))/b):
            owner = node_values[(i,j)]
            owner.flip_point((x,y))
            owners[(x,y)] = owner

def recalc_borders(point = None):
    global borders
    if point is None:
        borders = set()
        for i in range(width):
            for j in range(height):
                if (i,j) not in borders:
                    owner = owner_of((i,j))
                    for pt in nbors((i,j)):
                        if owner_of(pt) != owner:
                            borders.add((i,j))
                            borders.add(pt)
                            break
    else:
        for pt in nbors(point):
            owner = owner_of(pt)
            for pt2 in nbors(pt):
                if owner_of(pt2) != owner:
                    borders.add(pt)
                    break
            else:
                borders.discard(pt)

def owner_of(point):
    if 0 <= point[0] < width and 0 <= point[1] < height:
        return owners[point]
    else:
        return None

# Status codes for analysis
SINGLETON = 0
FILAMENT = 1
SWAPPABLE = 2
NOT_SWAPPABLE = 3

def analyze_nbors(point):
    owner = owner_of(point)
    circ = a,b,c,d,e,f,g,h = full_circ(point)
    oa,ob,oc,od,oe,of,og,oh = map(owner_of, circ)
    nbor_owners = set([oa,oc,oe,og])
    if owner not in nbor_owners:
        return SINGLETON, owner, nbor_owners - set([None])
    if oc != oe == owner == oa != og != oc:
        return FILAMENT, owner, set([og, oc]) - set([None])
    if oe != oc == owner == og != oa != oe:
        return FILAMENT, owner, set([oe, oa]) - set([None])
    last_owner = oa
    flips = {last_owner:0}
    for (corner, side, corner_owner, side_owner) in (b,c,ob,oc), (d,e,od,oe), (f,g,of,og), (h,a,oh,oa):
        if side_owner not in flips:
            flips[side_owner] = 0
        if side_owner != corner_owner or side_owner != last_owner:
            flips[side_owner] += 1
            flips[last_owner] += 1
        last_owner = side_owner
    candidates = set(own for own in flips if flips[own] == 2 and own is not None)
    if owner in candidates:
        return SWAPPABLE, owner, candidates - set([owner])
    return NOT_SWAPPABLE, None, None

print("Calculating borders...")

recalc_borders()

print("Deforming regions...")

def assign_colors():
    used_colors = {}
    for region in regions:
        r, g, b = region.mean_with(None)
        r, g, b = int(round(r)), int(round(g)), int(round(b))
        if (r,g,b) in used_colors:
            for color in sorted([(r2, g2, b2) for r2 in range(256) for g2 in range(256) for b2 in range(256)], key=lambda color: dist_rgb(color, (r,g,b))):
                if color not in used_colors:
                    used_colors[color] = region.points
                    break
        else:
            used_colors[(r,g,b)] = region.points
    return used_colors

def make_image(colors):
    img = Image.new("RGB", image.size)
    for color in colors:
        for point in colors[color]:
            img.putpixel(point, color)
    return img

# Round status labels
FULL_ROUND = 0
NEIGHBOR_ROUND = 1
FILAMENT_ROUND = 2

max_filament = None
next_search = set()
rounds = 0
points_flipped = 0
singletons = 0
filaments = 0
flip_milestone = 0
logs = 0

while True:
    if LOGGING and (rounds % LOG_ROUND_INTERVAL == 0 or points_flipped >= flip_milestone):
        print("Round %d of deformation:\n %d edit(s) so far, of which %d singleton removal(s) and %d filament cut(s)."%(rounds, points_flipped, singletons, filaments))
        while points_flipped >= flip_milestone: flip_milestone += LOG_FLIP_INTERVAL
        if GRAPHICAL_LOGGING:
            make_image(assign_colors()).save(LOG_FILE_PREFIX + str(logs) + LOG_FILE_SUFFIX)
            logs += 1
    if max_filament is None or (round_status == NEIGHBOR_ROUND and rounds%FILAMENT_ROUND_INTERVAL != 0):
        search_space, round_status = (next_search & borders, NEIGHBOR_ROUND) if next_search else (copy(borders), FULL_ROUND)
        next_search = set()
        max_filament = None
    else:
        round_status = FILAMENT_ROUND
        search_space = set([max_filament[0]]) & borders
    search_space = list(search_space)
    shuffle(search_space)
    for point in search_space:
        status, owner, takers = analyze_nbors(point)
        if (status == FILAMENT and num_components < N) or status in (SINGLETON, SWAPPABLE):
            color = pixels[point]
            takers_list = list(takers)
            shuffle(takers_list)
            for taker in takers_list:
                dist = dist_rgb(color, owner.mean_with(None)) - dist_rgb(color, taker.mean_with(color))
                if dist > 0:
                    if status != FILAMENT or round_status == FILAMENT_ROUND:
                        found = True
                        owner.flip_point(point)
                        taker.flip_point(point)
                        owners[point] = taker
                        recalc_borders(point)
                        next_search.add(point)
                        for nbor in full_circ(point):
                            next_search.add(nbor)
                        points_flipped += 1
                    if status == FILAMENT:
                        if round_status == FILAMENT_ROUND:
                            num_components += 1
                            filaments += 1
                        elif max_filament is None or max_filament[1] < dist:
                            max_filament = (point, dist)
                    if status == SINGLETON:
                        num_components -= 1
                        singletons += 1
                    break
    rounds += 1
    if round_status == FILAMENT_ROUND:
        max_filament = None
    if round_status == FULL_ROUND and max_filament is None and not next_search:
        break

print("Deformation completed after %d rounds:\n %d edit(s), of which %d singleton removal(s) and %d filament cut(s)."%(rounds, points_flipped, singletons, filaments))

print("Assigning colors...")

used_colors = assign_colors()

print("Producing output...")

make_image(used_colors).save(OUT_FILE)

print("Done!")

यह काम किस प्रकार करता है

कार्यक्रम कैनवास को Pक्षेत्रों में विभाजित करता है , जिनमें से प्रत्येक में छेद के बिना कुछ संख्या में कोशिकाएं होती हैं। प्रारंभ में, कैनवास को लगभग अनुमानित वर्गों में विभाजित किया गया है, जो कि क्षेत्रों को यादृच्छिक रूप से सौंपा गया है। फिर, इन क्षेत्रों को एक पुनरावृत्त प्रक्रिया में "विकृत" किया जाता है, जहां दिए गए पिक्सेल अपने क्षेत्र को बदल सकते हैं यदि

  1. यह परिवर्तन उस क्षेत्र के औसत रंग से पिक्सेल की RGB दूरी को कम करेगा, जिसमें यह है, और
  2. यह कोशिकाओं को तोड़ता या विलय नहीं करता है या उनमें छेद नहीं करता है।

बाद की स्थिति को स्थानीय रूप से लागू किया जा सकता है, इसलिए यह प्रक्रिया सेलुलर ऑटोमेटन की तरह एक सा है। इस तरह, हमें कोई भी पथ-प्रदर्शक या ऐसा करने की ज़रूरत नहीं है, जो प्रक्रिया को बहुत तेज़ कर दे। हालांकि, चूंकि कोशिकाओं को तोड़ा नहीं जा सकता है, उनमें से कुछ लंबे समय तक "फिलामेंट्स" के रूप में समाप्त होते हैं जो अन्य कोशिकाओं को सीमा देते हैं और उनके विकास को रोकते हैं। इसे ठीक करने के लिए, "फिलामेंट कट" नामक एक प्रक्रिया है, जो कभी-कभी दो में एक फिलामेंट के आकार की कोशिका को तोड़ देती है, अगर Nउस समय कोशिकाओं से कम हो । यदि उनका आकार 1 है, तो कोशिकाएँ भी गायब हो सकती हैं और इससे तंतुओं के कटने की गुंजाइश बनती है।

यह प्रक्रिया तब समाप्त होती है जब किसी भी पिक्सेल में क्षेत्रों को स्विच करने के लिए प्रोत्साहन नहीं होता है, और उसके बाद, प्रत्येक क्षेत्र अपने औसत रंग से रंगीन होता है। आमतौर पर आउटपुट में कुछ फिलामेंट्स शेष होंगे, जैसा कि नीचे दिए गए उदाहरणों में देखा जा सकता है, खासकर नेबुला में।

पी = 30, एन = 500

मोना लीसा लंगूर रंगीन गेंदें नाब्युला

अधिक तस्वीरें बाद में।

मेरे कार्यक्रम के कुछ दिलचस्प गुण यह हैं कि यह संभाव्य है, ताकि परिणाम अलग-अलग रनों के बीच भिन्न हो सकते हैं, जब तक कि आप एक ही छद्म आयामी बीज का उपयोग नहीं करते हैं। यादृच्छिकता आवश्यक नहीं है, हालांकि, मैं बस किसी भी आकस्मिक कलाकृतियों से बचना चाहता था जो विशेष रूप से हो सकता है कि पायथन निर्देशांक या कुछ इसी तरह के सेट का पता लगाता है। कार्यक्रम में सभी Pरंगों और लगभग सभी Nकोशिकाओं का उपयोग किया जाता है, और कोशिकाओं में डिज़ाइन द्वारा कभी भी छेद नहीं होते हैं। साथ ही, विरूपण प्रक्रिया काफी धीमी है। मेरी मशीन पर उत्पादन करने के लिए रंगीन गेंदों को लगभग 15 मिनट लगे। उल्टा, आप इसे चालू करते हैंGRAPHICAL_LOGGINGविकल्प, आपको विरूपण प्रक्रिया के चित्रों की एक शांत श्रृंखला मिलेगी। मैंने मोना लिसा को GIF एनीमेशन में बनाया (फ़ाइल का आकार कम करने के लिए 50% सिकुड़ गया)। यदि आप उसके चेहरे और बालों को करीब से देखते हैं, तो आप कार्रवाई में फिलामेंट काटने की प्रक्रिया देख सकते हैं।

यहाँ छवि विवरण दर्ज करें


वाह, ये परिणाम वास्तव में सुंदर लग रहे हैं (हालांकि यह संख्याओं द्वारा चित्रित नहीं है, लेकिन फिर भी बहुत अच्छा है :))।
मार्टिन एंडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.