282 lines
9.0 KiB
Python
282 lines
9.0 KiB
Python
# Source: https://github.com/python/pyperformance
|
|
# License: MIT
|
|
|
|
# create chaosgame-like fractals
|
|
# Copyright (C) 2005 Carl Friedrich Bolz
|
|
|
|
import math
|
|
import random
|
|
|
|
|
|
class GVector(object):
|
|
def __init__(self, x=0, y=0, z=0):
|
|
self.x = x
|
|
self.y = y
|
|
self.z = z
|
|
|
|
def Mag(self):
|
|
return math.sqrt(self.x ** 2 + self.y ** 2 + self.z ** 2)
|
|
|
|
def dist(self, other):
|
|
return math.sqrt(
|
|
(self.x - other.x) ** 2 + (self.y - other.y) ** 2 + (self.z - other.z) ** 2
|
|
)
|
|
|
|
def __add__(self, other):
|
|
if not isinstance(other, GVector):
|
|
raise ValueError("Can't add GVector to " + str(type(other)))
|
|
v = GVector(self.x + other.x, self.y + other.y, self.z + other.z)
|
|
return v
|
|
|
|
def __sub__(self, other):
|
|
return self + other * -1
|
|
|
|
def __mul__(self, other):
|
|
v = GVector(self.x * other, self.y * other, self.z * other)
|
|
return v
|
|
|
|
__rmul__ = __mul__
|
|
|
|
def linear_combination(self, other, l1, l2=None):
|
|
if l2 is None:
|
|
l2 = 1 - l1
|
|
v = GVector(
|
|
self.x * l1 + other.x * l2, self.y * l1 + other.y * l2, self.z * l1 + other.z * l2
|
|
)
|
|
return v
|
|
|
|
def __str__(self):
|
|
return "<%f, %f, %f>" % (self.x, self.y, self.z)
|
|
|
|
def __repr__(self):
|
|
return "GVector(%f, %f, %f)" % (self.x, self.y, self.z)
|
|
|
|
|
|
class Spline(object):
|
|
"""Class for representing B-Splines and NURBS of arbitrary degree"""
|
|
|
|
def __init__(self, points, degree, knots):
|
|
"""Creates a Spline.
|
|
|
|
points is a list of GVector, degree is the degree of the Spline.
|
|
"""
|
|
if len(points) > len(knots) - degree + 1:
|
|
raise ValueError("too many control points")
|
|
elif len(points) < len(knots) - degree + 1:
|
|
raise ValueError("not enough control points")
|
|
last = knots[0]
|
|
for cur in knots[1:]:
|
|
if cur < last:
|
|
raise ValueError("knots not strictly increasing")
|
|
last = cur
|
|
self.knots = knots
|
|
self.points = points
|
|
self.degree = degree
|
|
|
|
def GetDomain(self):
|
|
"""Returns the domain of the B-Spline"""
|
|
return (self.knots[self.degree - 1], self.knots[len(self.knots) - self.degree])
|
|
|
|
def __call__(self, u):
|
|
"""Calculates a point of the B-Spline using de Boors Algorithm"""
|
|
dom = self.GetDomain()
|
|
if u < dom[0] or u > dom[1]:
|
|
raise ValueError("Function value not in domain")
|
|
if u == dom[0]:
|
|
return self.points[0]
|
|
if u == dom[1]:
|
|
return self.points[-1]
|
|
I = self.GetIndex(u)
|
|
d = [self.points[I - self.degree + 1 + ii] for ii in range(self.degree + 1)]
|
|
U = self.knots
|
|
for ik in range(1, self.degree + 1):
|
|
for ii in range(I - self.degree + ik + 1, I + 2):
|
|
ua = U[ii + self.degree - ik]
|
|
ub = U[ii - 1]
|
|
co1 = (ua - u) / (ua - ub)
|
|
co2 = (u - ub) / (ua - ub)
|
|
index = ii - I + self.degree - ik - 1
|
|
d[index] = d[index].linear_combination(d[index + 1], co1, co2)
|
|
return d[0]
|
|
|
|
def GetIndex(self, u):
|
|
dom = self.GetDomain()
|
|
for ii in range(self.degree - 1, len(self.knots) - self.degree):
|
|
if u >= self.knots[ii] and u < self.knots[ii + 1]:
|
|
I = ii
|
|
break
|
|
else:
|
|
I = dom[1] - 1
|
|
return I
|
|
|
|
def __len__(self):
|
|
return len(self.points)
|
|
|
|
def __repr__(self):
|
|
return "Spline(%r, %r, %r)" % (self.points, self.degree, self.knots)
|
|
|
|
|
|
def write_ppm(im, w, h, filename):
|
|
with open(filename, "wb") as f:
|
|
f.write(b"P6\n%i %i\n255\n" % (w, h))
|
|
for j in range(h):
|
|
for i in range(w):
|
|
val = im[j * w + i]
|
|
c = val * 255
|
|
f.write(b"%c%c%c" % (c, c, c))
|
|
|
|
|
|
class Chaosgame(object):
|
|
def __init__(self, splines, thickness, subdivs):
|
|
self.splines = splines
|
|
self.thickness = thickness
|
|
self.minx = min([p.x for spl in splines for p in spl.points])
|
|
self.miny = min([p.y for spl in splines for p in spl.points])
|
|
self.maxx = max([p.x for spl in splines for p in spl.points])
|
|
self.maxy = max([p.y for spl in splines for p in spl.points])
|
|
self.height = self.maxy - self.miny
|
|
self.width = self.maxx - self.minx
|
|
self.num_trafos = []
|
|
maxlength = thickness * self.width / self.height
|
|
for spl in splines:
|
|
length = 0
|
|
curr = spl(0)
|
|
for i in range(1, subdivs + 1):
|
|
last = curr
|
|
t = 1 / subdivs * i
|
|
curr = spl(t)
|
|
length += curr.dist(last)
|
|
self.num_trafos.append(max(1, int(length / maxlength * 1.5)))
|
|
self.num_total = sum(self.num_trafos)
|
|
|
|
def get_random_trafo(self):
|
|
r = random.randrange(int(self.num_total) + 1)
|
|
l = 0
|
|
for i in range(len(self.num_trafos)):
|
|
if r >= l and r < l + self.num_trafos[i]:
|
|
return i, random.randrange(self.num_trafos[i])
|
|
l += self.num_trafos[i]
|
|
return len(self.num_trafos) - 1, random.randrange(self.num_trafos[-1])
|
|
|
|
def transform_point(self, point, trafo=None):
|
|
x = (point.x - self.minx) / self.width
|
|
y = (point.y - self.miny) / self.height
|
|
if trafo is None:
|
|
trafo = self.get_random_trafo()
|
|
start, end = self.splines[trafo[0]].GetDomain()
|
|
length = end - start
|
|
seg_length = length / self.num_trafos[trafo[0]]
|
|
t = start + seg_length * trafo[1] + seg_length * x
|
|
basepoint = self.splines[trafo[0]](t)
|
|
if t + 1 / 50000 > end:
|
|
neighbour = self.splines[trafo[0]](t - 1 / 50000)
|
|
derivative = neighbour - basepoint
|
|
else:
|
|
neighbour = self.splines[trafo[0]](t + 1 / 50000)
|
|
derivative = basepoint - neighbour
|
|
if derivative.Mag() != 0:
|
|
basepoint.x += derivative.y / derivative.Mag() * (y - 0.5) * self.thickness
|
|
basepoint.y += -derivative.x / derivative.Mag() * (y - 0.5) * self.thickness
|
|
else:
|
|
# can happen, especially with single precision float
|
|
pass
|
|
self.truncate(basepoint)
|
|
return basepoint
|
|
|
|
def truncate(self, point):
|
|
if point.x >= self.maxx:
|
|
point.x = self.maxx
|
|
if point.y >= self.maxy:
|
|
point.y = self.maxy
|
|
if point.x < self.minx:
|
|
point.x = self.minx
|
|
if point.y < self.miny:
|
|
point.y = self.miny
|
|
|
|
def create_image_chaos(self, w, h, iterations, rng_seed):
|
|
# Always use the same sequence of random numbers
|
|
# to get reproductible benchmark
|
|
random.seed(rng_seed)
|
|
|
|
im = bytearray(w * h)
|
|
point = GVector((self.maxx + self.minx) / 2, (self.maxy + self.miny) / 2, 0)
|
|
for _ in range(iterations):
|
|
point = self.transform_point(point)
|
|
x = (point.x - self.minx) / self.width * w
|
|
y = (point.y - self.miny) / self.height * h
|
|
x = int(x)
|
|
y = int(y)
|
|
if x == w:
|
|
x -= 1
|
|
if y == h:
|
|
y -= 1
|
|
im[(h - y - 1) * w + x] = 1
|
|
|
|
return im
|
|
|
|
|
|
###########################################################################
|
|
# Benchmark interface
|
|
|
|
bm_params = {
|
|
(100, 50): (0.25, 100, 50, 50, 50, 1234),
|
|
(1000, 1000): (0.25, 200, 400, 400, 1000, 1234),
|
|
(5000, 1000): (0.25, 400, 500, 500, 7000, 1234),
|
|
}
|
|
|
|
|
|
def bm_setup(params):
|
|
splines = [
|
|
Spline(
|
|
[
|
|
GVector(1.597, 3.304, 0.0),
|
|
GVector(1.576, 4.123, 0.0),
|
|
GVector(1.313, 5.288, 0.0),
|
|
GVector(1.619, 5.330, 0.0),
|
|
GVector(2.890, 5.503, 0.0),
|
|
GVector(2.373, 4.382, 0.0),
|
|
GVector(1.662, 4.360, 0.0),
|
|
],
|
|
3,
|
|
[0, 0, 0, 1, 1, 1, 2, 2, 2],
|
|
),
|
|
Spline(
|
|
[
|
|
GVector(2.805, 4.017, 0.0),
|
|
GVector(2.551, 3.525, 0.0),
|
|
GVector(1.979, 2.620, 0.0),
|
|
GVector(1.979, 2.620, 0.0),
|
|
],
|
|
3,
|
|
[0, 0, 0, 1, 1, 1],
|
|
),
|
|
Spline(
|
|
[
|
|
GVector(2.002, 4.011, 0.0),
|
|
GVector(2.335, 3.313, 0.0),
|
|
GVector(2.367, 3.233, 0.0),
|
|
GVector(2.367, 3.233, 0.0),
|
|
],
|
|
3,
|
|
[0, 0, 0, 1, 1, 1],
|
|
),
|
|
]
|
|
|
|
chaos = Chaosgame(splines, params[0], params[1])
|
|
image = None
|
|
|
|
def run():
|
|
nonlocal image
|
|
_, _, width, height, iter, rng_seed = params
|
|
image = chaos.create_image_chaos(width, height, iter, rng_seed)
|
|
|
|
def result():
|
|
norm = params[4]
|
|
# Images are not the same when floating point behaviour is different,
|
|
# so return percentage of pixels that are set (rounded to int).
|
|
# write_ppm(image, params[2], params[3], 'out-.ppm')
|
|
pix = int(100 * sum(image) / len(image))
|
|
return norm, pix
|
|
|
|
return run, result
|