| import random | |
| import math | |
| from dreamcoder.utilities import * | |
| def simulateWithoutPhysics(plan,ordered=True): | |
| def overlap(b1, | |
| b2): | |
| (x,w,h) = b1 | |
| (x_,y_,w_,h_) = b2 | |
| x1 = x - w/2 | |
| x2 = x + w/2 | |
| x1_ = x_ - w_/2 | |
| x2_ = x_ + w_/2 | |
| if x1_ >= x2 or x1 >= x2_: return None | |
| assert h%2 == 0 and h_%2 == 0 | |
| return y_ + h_//2 + h//2 | |
| def lowestPossibleHeight(b): | |
| h = b[2] | |
| assert h%2 == 0 | |
| return int(h/2) | |
| def placeAtHeight(b,y): | |
| (x,w,h) = b | |
| return (x,y,w,h) | |
| def placeBlock(world, block): | |
| lowest = max([lowestPossibleHeight(block)] + \ | |
| [overlap(block,other) | |
| for other in world | |
| if overlap(block,other) is not None]) | |
| world.append(placeAtHeight(block, lowest)) | |
| w = [] | |
| for p in plan: placeBlock(w,p) | |
| if ordered: w = list(sorted(w)) | |
| return w | |
| def centerTower(t,hand=None, masterPlan=None): | |
| if len(t) == 0: | |
| if hand is None: | |
| return t | |
| else: | |
| return t, hand | |
| def getCenter(t): | |
| x1 = max(x for x, _, _ in t) | |
| x0 = min(x for x, _, _ in t) | |
| c = int((x1 - x0) / 2.0) + x0 | |
| return c | |
| c = getCenter(masterPlan or t) | |
| t = [(x - c, w, h) for x, w, h in t] | |
| if hand is None: | |
| return t | |
| else: | |
| return t, hand - c | |
| def towerLength(t): | |
| if len(t) == 0: return 0 | |
| x1 = max(x for x, _, _ in t) | |
| x0 = min(x for x, _, _ in t) | |
| return x1 - x0 | |
| def towerHeight(t): | |
| y1 = max(y + h/2 for _, y, _, h in t ) | |
| y0 = min(y - h/2 for _, y, _, h in t ) | |
| return y1 - y0 | |
| def renderPlan(plan, resolution=256, window=64, floorHeight=2, borderSize=1, bodyColor=(0.,1.,1.), | |
| borderColor=(1.,0.,0.), | |
| truncate=None, randomSeed=None, | |
| masterPlan=None, | |
| pretty=False, Lego=False, | |
| drawHand=None): | |
| import numpy as np | |
| if Lego: assert pretty | |
| if drawHand is not None and drawHand is not False: | |
| plan, drawHand = centerTower(plan, drawHand, | |
| masterPlan=masterPlan) | |
| else: | |
| plan = centerTower(plan,masterPlan=masterPlan) | |
| world = simulateWithoutPhysics(plan, | |
| ordered=randomSeed is None) | |
| if truncate is not None: world = world[:truncate] | |
| a = np.zeros((resolution, resolution, 3)) | |
| def transform(x,y): | |
| y = resolution - y*resolution/float(window) | |
| x = resolution/2 + x*resolution/float(window) | |
| return int(x + 0.5),int(y + 0.5) | |
| def clip(p): | |
| if p < 0: return 0 | |
| if p >= resolution: return resolution - 1 | |
| return int(p + 0.5) | |
| def clear(x,y): | |
| for xp,yp,wp,hp in world: | |
| if x < xp + wp/2. and \ | |
| x > xp - wp/2. and \ | |
| y < yp + hp/2. and \ | |
| y > yp - hp/2.: | |
| return False | |
| return True | |
| def bump(x,y,c): | |
| size = 0.5*resolution/window | |
| x,y = transform(x,y) | |
| y -= floorHeight | |
| y1 = y | |
| y2 = y - size | |
| x1 = x - size/2 | |
| x2 = x + size/2 | |
| a[clip(y2) : clip(y1), | |
| clip(x1) : clip(x2), | |
| :] = c | |
| if randomSeed is not None: | |
| randomNumbers = random.Random(randomSeed) | |
| def _color(): | |
| if randomSeed is None: | |
| return random.random()*0.7 + 0.3 | |
| else: | |
| return randomNumbers.random()*0.7 + 0.3 | |
| def color(): | |
| return (_color(),_color(),_color()) | |
| def rectangle(x1,x2,y1,y2,c,cp=None): | |
| x1,y1 = transform(x1,y1) | |
| x2,y2 = transform(x2,y2) | |
| y1 -= floorHeight | |
| y2 -= floorHeight | |
| a[clip(y2) : clip(y1), | |
| clip(x1) : clip(x2), | |
| :] = c | |
| if cp is not None: | |
| a[clip(y2 + borderSize) : clip(y1 - borderSize), | |
| clip(x1 + borderSize) : clip(x2 - borderSize), | |
| :] = cp | |
| for x,y,w,h in world: | |
| x1,y1 = x - w/2., y - h/2. | |
| x2,y2 = x + w/2., y + h/2. | |
| if pretty: | |
| thisColor = color() | |
| rectangle(x1,x2,y1,y2, | |
| thisColor) | |
| if Lego: | |
| bumps = w | |
| for nb in range(bumps): | |
| nx = x - w/2. + 0.5 + nb | |
| ny = y + h/2. + 0.00001 | |
| if clear(nx,ny): | |
| bump(nx,ny,thisColor) | |
| else: | |
| rectangle(x1,x2,y1,y2, | |
| borderColor, bodyColor) | |
| a[resolution - floorHeight:,:,:] = 1. | |
| if drawHand is not None: | |
| if not Lego: | |
| dh = 0.25 | |
| rectangle(drawHand - dh, | |
| drawHand + dh, | |
| -99999, 99999, | |
| (0,1,0)) | |
| else: | |
| rectangle(drawHand - 1,drawHand + 1, | |
| 43,45,(1,1,1)) | |
| return a | |