使图像的对象彼此最接近

debugcn 发表于 Dev

布鲁诺·米格尔·贡萨尔维斯

我在PIL方面没有太多经验，我从一堆显微镜图像单元中编辑了这些图像，每个图像蒙版的图像尺寸均为30x30。我一直在努力将这些单元格放置在尽可能彼此不重叠的黑色背景中。

我的代码如下：

def spread_circles(circles, rad, iterations,step):
    radsqr = rad**2
    for i in range(iterations):
        for ix,c in enumerate(circles):
            vecs = c-circles
            dists = np.sum((vecs)**2,axis=1)
            if len(dists)>0:
                push = (vecs[dists<radsqr,:].T*dists[dists<radsqr]).T
                push = np.sum(push,axis=0)
                pushmag = np.sum(push*push)**0.5
                if pushmag>0:
                    push = push/pushmag*step
                    circles[ix]+=push
    return circles



def gen_image(sample,n_iter, height=850, width = 850, max_shape=30, num_circles=150):
    circles = np.random.uniform(low=max_shape,high=height-max_shape,size=(num_circles,2))   
    circles = spread_circles(circles, max_shape, n_iter, 1).astype(int)
    img = Image.new(mode='F',size=(height,width),color=0).convert('RGBA')
    final1 = Image.new("RGBA", size=(height,width))
    final1.paste(img, (0,0), img)
    for n,c in enumerate(circles):
        foreground = sample[n]       
        final1.paste(foreground, (c[0],c[1]), foreground)     
    return final1

但是，如果我进行几次迭代，就很难避免重叠，如果我增加迭代次数，它们将变得过于稀疏，如下所示：

我想要的是类似于我绘制的红色圆圈内的内容：

我需要它们尽可能接近它们，就像瓷砖一样。我怎样才能做到这一点？

马克·谢切尔

我已经开始考虑这一点，并且已经实施了一些策略。任何其他想获得一些乐趣的人都非常欢迎借用，窃取，使用或破解我可以使用的任何代码！明天我可能会再玩些。

#!/usr/bin/env python3

from PIL import Image, ImageOps
import numpy as np
from glob import glob
import math

def checkCoverage(im):
   """Determines percentage of image that is cells rather than background"""
   N = np.count_nonzero(im)
   return N * 100 / im.size


def loadImages():
   """Load all cell images in current directory into list of trimmed Numpy arrays"""
   images = []
   for filename in glob('*.png'):
      # Open and convert to greyscale
      im = Image.open(filename).convert('L')
      # Trim to bounding box
      im = im.crop(im.getbbox())
      images.append(np.array(im))
   return images

def Strategy1():
   """Get largest image and pad all images to that size - at least it will tesselate perfectly"""
   images = loadImages()
   N = len(images)
   # Find height of tallest image and width of widest image
   maxh = max(im.shape[0] for im in images)
   maxw = max(im.shape[1] for im in images)
   # Determine how many images we will pack across and down the output image - could be improved
   Nx = int(math.sqrt(N))+1
   Ny = int(N/Nx)+1
   print(f'Padding {N} images each to height:{maxh} x width:{maxw}')
   # Create output image
   res = Image.new('L', (Nx*maxw,Ny*maxh), color=0)
   # Pack all images from list onto regular grid
   x, y = 0, 0
   for im in images:
      this = Image.fromarray(im)
      h, w = im.shape
      # Pack this image into top-left of its grid-cell, unless
      # a) in first row, in which case pack to bottom
      # b) in first col, in which case pack to right
      thisx = x*maxw
      thisy = y*maxh
      if y==0:
         thisy += maxh - h
      if x==0:
         thisx += maxw - w
      res.paste(this, (thisx,thisy))
      x += 1
      if x==Nx:
         x  = 0
         y += 1

   # Trim extraneous black edges
   res = res.crop(res.getbbox())
   # Save as JPEG so we don't find it as a PNG in next strategy
   res.save('strategy1.jpg')
   cov = checkCoverage(np.array(res))
   print(f'Strategy1 coverage: {cov}')


def Strategy2():
   """Rotate all images to portrait (tall rather than wide) and order by height so we tend to stack equal height images side-by-side"""
   tmp = loadImages()
   # Recreate list with all images in portrait format, i.e. tall
   portrait = []
   for im in tmp:
      if im.shape[0] >= im.shape[1]:
         # Already portrait, add as-is
         portrait.append(im)
      else:
         # Landscape, so rotate
         portrait.append(np.rot90(im))
   images = sorted(portrait, key=lambda x: x.shape[0], reverse=True)
   N = len(images)
   maxh, maxw = 31, 31
   # Determine how many images we will pack across and down the output image
   Nx = int(math.sqrt(N))+1
   Ny = int(N/Nx)+1
   print(f'Packing images by height')
   # Create output image
   resw, resh = Nx*maxw, Ny*maxh
   res = Image.new('L', (resw,resh), color=0)
   # Pack all from list 
   xpos, ypos = 0, 0
   # Pack first row L->R, second row R->L and alternate
   packToRight = True
   for im in images:
      thisw, thish = im.shape
      this = Image.fromarray(im)
      if packToRight:
         if xpos+thisw < resw:
            # If it fits to the right, pack it there
            res.paste(this,(xpos,ypos))
            xpos += thisw
         else:
            # Else start a new row, pack at right end and continue packing to left
            packToRight = False
            res.paste(this,(resw-thisw,ypos))
            ypos = res.getbbox()[3]
      else:
         if xpos>thisw:
            # If it fits to the left, pack it there
            res.paste(this,(xpos-thisw,ypos))
            xpos -= thisw
         else:
            # Else start a new row, pack at left end and continue packing to right
            ypos = res.getbbox()[3]
            packToRight = True
            res.paste(this,(0,ypos))

   # Trim any black edges
   res = res.crop(res.getbbox())
   # Save as JPEG so we don't find it as a PNG in next strategy
   res.save('strategy2.jpg')
   cov = checkCoverage(np.array(res))
   print(f'Strategy2 coverage: {cov}')

Strategy1()
Strategy2()

Strategy1的覆盖率为42％：