144 lines
4.2 KiB
Python
144 lines
4.2 KiB
Python
# from alpha_shape import alpha_shape
|
|
from math import hypot
|
|
from PIL import Image
|
|
import noise
|
|
|
|
class Layer(object):
|
|
def translate(self, x, y):
|
|
return Translate(self, x, y)
|
|
def scale(self, x, y):
|
|
return Scale(self, x, y)
|
|
def power(self, power):
|
|
return Power(self, power)
|
|
def add(self, other):
|
|
return Add(self, other)
|
|
def subtract(self, other):
|
|
return Subtract(self, other)
|
|
def multiply(self, other):
|
|
return Multiply(self, other)
|
|
def threshold(self, threshold):
|
|
return Threshold(self, threshold)
|
|
def clamp(self, lo=0, hi=1):
|
|
return Clamp(self, lo, hi)
|
|
def normalize(self, lo, hi, new_lo, new_hi):
|
|
return Normalize(self, lo, hi, new_lo, new_hi)
|
|
def filter_points(self, points, lo, hi):
|
|
return [(x, y) for x, y in points if lo <= self.get(x, y) < hi]
|
|
def alpha_shape(self, points, lo, hi, alpha):
|
|
points = self.filter_points(points, lo, hi)
|
|
return alpha_shape(points, alpha)
|
|
def save(self, path, x1, y1, x2, y2, scale=1, lo=0, hi=1):
|
|
w = int(round((x2 - x1) * scale))
|
|
h = int(round((y2 - y1) * scale))
|
|
data = bytearray(w * h)
|
|
for y in range(h):
|
|
for x in range(w):
|
|
sx = x1 + (x2 - x1) * x / (w - 1)
|
|
sy = y1 + (y2 - y1) * y / (h - 1)
|
|
v = (self.get(sx, sy) - lo) / (hi - lo)
|
|
v = max(0, min(255, int(v * 255)))
|
|
data[y*w+x] = v
|
|
# for y in range(y1, y2):
|
|
# for x in range(x1, x2):
|
|
# v = (self.get(x, y) - lo) / (hi - lo)
|
|
# v = max(0, min(255, int(v * 255)))
|
|
# data[y*w+x] = v
|
|
im = Image.frombytes('L', (w, h), bytes(data))
|
|
im.save(path, 'png')
|
|
|
|
class Constant(Layer):
|
|
def __init__(self, value):
|
|
self.value = value
|
|
def get(self, x, y):
|
|
return self.value
|
|
|
|
class Noise(Layer):
|
|
def __init__(self, octaves=1):
|
|
self.octaves = octaves
|
|
def get(self, x, y):
|
|
return noise.snoise2(x, y, self.octaves)
|
|
|
|
class Translate(Layer):
|
|
def __init__(self, layer, x, y):
|
|
self.layer = layer
|
|
self.x = x
|
|
self.y = y
|
|
def get(self, x, y):
|
|
return self.layer.get(self.x + x, self.y + y)
|
|
|
|
class Scale(Layer):
|
|
def __init__(self, layer, x, y):
|
|
self.layer = layer
|
|
self.x = x
|
|
self.y = y
|
|
def get(self, x, y):
|
|
return self.layer.get(self.x * x, self.y * y)
|
|
|
|
class Power(Layer):
|
|
def __init__(self, layer, power):
|
|
self.layer = layer
|
|
self.power = power
|
|
def get(self, x, y):
|
|
return self.layer.get(x, y) ** self.power
|
|
|
|
class Add(Layer):
|
|
def __init__(self, a, b):
|
|
self.a = a
|
|
self.b = b
|
|
def get(self, x, y):
|
|
return self.a.get(x, y) + self.b.get(x, y)
|
|
|
|
class Subtract(Layer):
|
|
def __init__(self, a, b):
|
|
self.a = a
|
|
self.b = b
|
|
def get(self, x, y):
|
|
return self.a.get(x, y) - self.b.get(x, y)
|
|
|
|
class Multiply(Layer):
|
|
def __init__(self, a, b):
|
|
self.a = a
|
|
self.b = b
|
|
def get(self, x, y):
|
|
return self.a.get(x, y) * self.b.get(x, y)
|
|
|
|
class Threshold(Layer):
|
|
def __init__(self, layer, threshold):
|
|
self.layer = layer
|
|
self.threshold = threshold
|
|
def get(self, x, y):
|
|
return 0 if self.layer.get(x, y) < self.threshold else 1
|
|
|
|
class Clamp(Layer):
|
|
def __init__(self, layer, lo=0, hi=1):
|
|
self.layer = layer
|
|
self.lo = lo
|
|
self.hi = hi
|
|
def get(self, x, y):
|
|
v = self.layer.get(x, y)
|
|
v = min(v, self.hi)
|
|
v = max(v, self.lo)
|
|
return v
|
|
|
|
class Normalize(Layer):
|
|
def __init__(self, layer, lo, hi, new_lo, new_hi):
|
|
self.layer = layer
|
|
self.lo = lo
|
|
self.hi = hi
|
|
self.new_lo = new_lo
|
|
self.new_hi = new_hi
|
|
def get(self, x, y):
|
|
v = self.layer.get(x, y)
|
|
p = (v - self.lo) / (self.hi - self.lo)
|
|
v = self.new_lo + p * (self.new_hi - self.new_lo)
|
|
return v
|
|
|
|
class Distance(Layer):
|
|
def __init__(self, x, y, maximum, gamma=1):
|
|
self.x = x
|
|
self.y = y
|
|
self.maximum = maximum
|
|
self.gamma = gamma
|
|
def get(self, x, y):
|
|
return (hypot(x - self.x, y - self.y) / self.maximum) ** self.gamma
|