self.diffuse(numexpr)
- User
self.diffuse(numexpr)
- Assistant
numexpris a high-performance Python library that allows for fast execution of array expressions, particularly on large arrays. It does this by using a just-in-time (JIT) compiler to optimize the array expressions, and it utilizes multi-threading to take advantage of multiple cores.However, your statement
self.diffuse(numexpr)is unclear in this context as it doesn't follow the standard syntax or usage of thenumexprlibrary. Usually, you would usenumexprto evaluate an expression as a string, like so:import numexpr as ne a = ... # Some large NumPy array b = ... # Another large NumPy array # Using numexpr to compute an element-wise array operation result = ne.evaluate('a + b')If
self.diffuseis meant to be a part of a larger codebase or a method of a class you are working with, we would need more context to provide a meaningful answer. Could you please provide more details about the function or the context in which you are trying to usenumexpr? - User
SPDX-FileCopyrightText: 2017-2022 Blender Foundation
SPDX-License-Identifier: GPL-2.0-or-later
from time import time import unittest import sys import os from random import random as rand, shuffle import numpy as np
numexpr_available = False
def getmemsize(): return 0.0
def getptime(): return time()
class Grid:
def __init__(self, size=10, dtype=np.single): self.center = np.zeros([size, size], dtype) self.water = None self.sediment = None self.scour = None self.flowrate = None self.sedimentpct = None self.sedimentpct = None self.capacity = None self.avalanced = None self.minx = None self.miny = None self.maxx = None self.maxy = None self.zscale = 1 self.maxrss = 0.0 self.sequence = [0, 1, 2, 3] self.watermax = 1.0 self.flowratemax = 1.0 self.scourmax = 1.0 self.sedmax = 1.0 self.scourmin = 1.0 def init_water_and_sediment(self): if self.water is None: self.water = np.zeros(self.center.shape, dtype=np.single) if self.sediment is None: self.sediment = np.zeros(self.center.shape, dtype=np.single) if self.scour is None: self.scour = np.zeros(self.center.shape, dtype=np.single) if self.flowrate is None: self.flowrate = np.zeros(self.center.shape, dtype=np.single) if self.sedimentpct is None: self.sedimentpct = np.zeros(self.center.shape, dtype=np.single) if self.capacity is None: self.capacity = np.zeros(self.center.shape, dtype=np.single) if self.avalanced is None: self.avalanced = np.zeros(self.center.shape, dtype=np.single) def __str__(self): return ''.join(self.__str_iter__(fmt="%.3f")) def __str_iter__(self, fmt): for row in self.center[::]: values = [] for v in row: values.append(fmt % v) yield ' '.join(values) + '\n' @staticmethod def fromFile(filename): if filename == '-': filename = sys.stdin g = Grid() g.center = np.loadtxt(filename, np.single) return g def toFile(self, filename, fmt="%.3f"): if filename == '-': filename = sys.stdout.fileno() with open(filename, "w") as f: for line in self.__str_iter__(fmt): f.write(line) def raw(self, format="%.3f"): fstr = format + " " + format + " " + format + " " a = self.center / self.zscale minx = 0.0 if self.minx is None else self.minx miny = 0.0 if self.miny is None else self.miny maxx = 1.0 if self.maxx is None else self.maxx maxy = 1.0 if self.maxy is None else self.maxy dx = (maxx - minx) / (a.shape[0] - 1) dy = (maxy - miny) / (a.shape[1] - 1) for row in range(a.shape[0] - 1): row0 = miny + row * dy row1 = row0 + dy for col in range(a.shape[1] - 1): col0 = minx + col * dx col1 = col0 + dx yield (fstr % (row0, col0, a[row][col]) + fstr % (row0, col1, a[row][col + 1]) + fstr % (row1, col0, a[row + 1][col]) + "\n") yield (fstr % (row0, col1, a[row][col + 1]) + fstr % (row1, col0, a[row + 1][col]) + fstr % (row1, col1, a[row + 1][col + 1]) + "\n") def toRaw(self, filename, infomap=None): with open(filename if type(filename) == str else sys.stdout.fileno(), "w") as f: f.writelines(self.raw()) if infomap: with open(os.path.splitext(filename)[0] + ".inf" if type(filename) == str else sys.stdout.fileno(), "w") as f: f.writelines("\n".join("%-15s: %s" % t for t in sorted(infomap.items()))) @staticmethod def fromRaw(filename): """initialize a grid from a Blender .raw file. currently supports just rectangular grids of all triangles """ g = Grid.fromFile(filename) # we assume tris and an axis aligned grid g.center = np.reshape(g.center, (-1, 3)) g._sort() return g def _sort(self, expfact): # keep unique vertices only by creating a set and sort first on x then on y coordinate # using rather slow python sort but couldn't wrap my head around np.lexsort verts = sorted(list({tuple(t) for t in self.center[::]})) x = set(c[0] for c in verts) y = set(c[1] for c in verts) nx = len(x) ny = len(y) self.minx = min(x) self.maxx = max(x) self.miny = min(y) self.maxy = max(y) xscale = (self.maxx - self.minx) / (nx - 1) yscale = (self.maxy - self.miny) / (ny - 1) # note: a purely flat plane cannot be scaled if (yscale != 0.0) and (abs(xscale / yscale) - 1.0 > 1e-3): raise ValueError("Mesh spacing not square %d x %d %.4f x %4.f" % (nx, ny, xscale, yscale)) self.zscale = 1.0 if abs(yscale) > 1e-6: self.zscale = 1.0 / yscale # keep just the z-values and null any offset # we might catch a reshape error that will occur if nx*ny != # of vertices # (if we are not dealing with a heightfield but with a mesh with duplicate # x,y coords, like an axis aligned cube self.center = np.array([c[2] for c in verts], dtype=np.single).reshape(nx, ny) self.center = (self.center - np.amin(self.center)) * self.zscale if self.rainmap is not None: rmscale = np.max(self.center) self.rainmap = expfact + (1 - expfact) * (self.center / rmscale) @staticmethod def fromBlenderMesh(me, vg, expfact): g = Grid() g.center = np.asarray(list(tuple(v.co) for v in me.vertices), dtype=np.single) g.rainmap = None if vg is not None: for v in me.vertices: vg.add([v.index], 0.0, 'ADD') g.rainmap = np.asarray(list((v.co[0], v.co[1], vg.weight(v.index)) for v in me.vertices), dtype=np.single) g._sort(expfact) return g def setrainmap(self, rainmap): self.rainmap = rainmap def _verts(self, surface): a = surface / self.zscale minx = 0.0 if self.minx is None else self.minx miny = 0.0 if self.miny is None else self.miny maxx = 1.0 if self.maxx is None else self.maxx maxy = 1.0 if self.maxy is None else self.maxy dx = (maxx - minx) / (a.shape[0] - 1) dy = (maxy - miny) / (a.shape[1] - 1) for row in range(a.shape[0]): row0 = miny + row * dy for col in range(a.shape[1]): col0 = minx + col * dx yield (row0, col0, a[row][col]) def _faces(self): nrow, ncol = self.center.shape for row in range(nrow - 1): for col in range(ncol - 1): vi = row * ncol + col yield (vi, vi + ncol, vi + 1) yield (vi + 1, vi + ncol, vi + ncol + 1) def toBlenderMesh(self, me): # pass me as argument so that we don't need to import bpy and create a dependency # the docs state that from_pydata takes iterators as arguments but it will # fail with generators because it does len(arg) me.from_pydata(list(self._verts(self.center)), [], list(self._faces())) def toWaterMesh(self, me): # pass me as argument so that we don't need to import bpy and create a dependency # the docs state that from_pydata takes iterators as arguments but it will # fail with generators because it does len(arg) me.from_pydata(list(self._verts(self.water)), [], list(self._faces())) def peak(self, value=1): nx, ny = self.center.shape self.center[int(nx / 2), int(ny / 2)] += value def shelf(self, value=1): nx, ny = self.center.shape self.center[:nx / 2] += value def mesa(self, value=1): nx, ny = self.center.shape self.center[nx / 4:3 * nx / 4, ny / 4:3 * ny / 4] += value def random(self, value=1): self.center += np.random.random_sample(self.center.shape) * value def neighborgrid(self): self.up = np.roll(self.center, -1, 0) self.down = np.roll(self.center, 1, 0) self.left = np.roll(self.center, -1, 1) self.right = np.roll(self.center, 1, 1) def zeroedge(self, quantity=None): c = self.center if quantity is None else quantity c[0, :] = 0 c[-1, :] = 0 c[:, 0] = 0 c[:, -1] = 0 def diffuse(self, Kd, IterDiffuse, numexpr): self.zeroedge() c = self.center[1:-1, 1:-1] up = self.center[:-2, 1:-1] down = self.center[2:, 1:-1] left = self.center[1:-1, :-2] right = self.center[1:-1, 2:] if(numexpr and numexpr_available): self.center[1:-1, 1:-1] = ne.evaluate('c + Kd * (up + down + left + right - 4.0 * c)') else: self.center[1:-1, 1:-1] = c + (Kd / IterDiffuse) * (up + down + left + right - 4.0 * c) self.maxrss = max(getmemsize(), self.maxrss) return self.center def avalanche(self, delta, iterava, prob, numexpr): self.zeroedge() c = self.center[1:-1, 1:-1] up = self.center[:-2, 1:-1] down = self.center[2:, 1:-1] left = self.center[1:-1, :-2] right = self.center[1:-1, 2:] where = np.where if(numexpr and numexpr_available): self.center[1:-1, 1:-1] = ne.evaluate('c + where((up -c) > delta ,(up -c -delta)/2, 0) \ + where((down -c) > delta ,(down -c -delta)/2, 0) \ + where((left -c) > delta ,(left -c -delta)/2, 0) \ + where((right-c) > delta ,(right-c -delta)/2, 0) \ + where((up -c) < -delta,(up -c +delta)/2, 0) \ + where((down -c) < -delta,(down -c +delta)/2, 0) \ + where((left -c) < -delta,(left -c +delta)/2, 0) \ + where((right-c) < -delta,(right-c +delta)/2, 0)') else: sa = ( # incoming where((up - c) > delta, (up - c - delta) / 2, 0) + where((down - c) > delta, (down - c - delta) / 2, 0) + where((left - c) > delta, (left - c - delta) / 2, 0) + where((right - c) > delta, (right - c - delta) / 2, 0) # outgoing + where((up - c) < -delta, (up - c + delta) / 2, 0) + where((down - c) < -delta, (down - c + delta) / 2, 0) + where((left - c) < -delta, (left - c + delta) / 2, 0) + where((right - c) < -delta, (right - c + delta) / 2, 0) ) randarray = np.random.randint(0, 100, sa.shape) * 0.01 sa = where(randarray < prob, sa, 0) self.avalanced[1:-1, 1:-1] = self.avalanced[1:-1, 1:-1] + sa / iterava self.center[1:-1, 1:-1] = c + sa / iterava self.maxrss = max(getmemsize(), self.maxrss) return self.center def rain(self, amount=1, variance=0, userainmap=False): self.water += (1.0 - np.random.random(self.water.shape) * variance) * \ (amount if ((self.rainmap is None) or (not userainmap)) else self.rainmap * amount) def spring(self, amount, px, py, radius): # px, py and radius are all fractions nx, ny = self.center.shape rx = max(int(nx * radius), 1) ry = max(int(ny * radius), 1) px = int(nx * px) py = int(ny * py) self.water[px - rx:px + rx + 1, py - ry:py + ry + 1] += amount def river(self, Kc, Ks, Kdep, Ka, Kev, numexpr): zeros = np.zeros where = np.where min = np.minimum max = np.maximum abs = np.absolute arctan = np.arctan sin = np.sin center = (slice(1, -1, None), slice(1, -1, None)) up = (slice(None, -2, None), slice(1, -1, None)) down = (slice(2, None, None), slice(1, -1, None)) left = (slice(1, -1, None), slice(None, -2, None)) right = (slice(1, -1, None), slice(2, None, None)) water = self.water rock = self.center sediment = self.sediment height = rock + water # !! this gives a runtime warning for division by zero verysmallnumber = 0.0000000001 water += verysmallnumber sc = where(water > verysmallnumber, sediment / water, 0) sdw = zeros(water[center].shape) svdw = zeros(water[center].shape) sds = zeros(water[center].shape) angle = zeros(water[center].shape) for d in (up, down, left, right): if(numexpr and numexpr_available): hdd = height[d] hcc = height[center] dw = ne.evaluate('hdd-hcc') inflow = ne.evaluate('dw > 0') wdd = water[d] wcc = water[center] # nested where() represent min() and max() dw = ne.evaluate('where(inflow, where(wdd<dw, wdd, dw), where(-wcc>dw, -wcc, dw))/4.0') sdw = ne.evaluate('sdw + dw') scd = sc[d] scc = sc[center] rockd = rock[d] rockc = rock[center] sds = ne.evaluate('sds + dw * where(inflow, scd, scc)') svdw = ne.evaluate('svdw + abs(dw)') angle = ne.evaluate('angle + arctan(abs(rockd-rockc))') else: dw = (height[d] - height[center]) inflow = dw > 0 dw = where(inflow, min(water[d], dw), max(-water[center], dw)) / 4.0 sdw = sdw + dw sds = sds + dw * where(inflow, sc[d], sc[center]) svdw = svdw + abs(dw) angle = angle + np.arctan(abs(rock[d] - rock[center])) if numexpr and numexpr_available: wcc = water[center] scc = sediment[center] rcc = rock[center] water[center] = ne.evaluate('wcc + sdw') sediment[center] = ne.evaluate('scc + sds') sc = ne.evaluate('where(wcc>0, scc/wcc, 2000*Kc)') fKc = ne.evaluate('Kc*sin(Ka*angle)*svdw') ds = ne.evaluate('where(sc > fKc, -Kd * scc, Ks * svdw)') rock[center] = ne.evaluate('rcc - ds') # there isn't really a bottom to the rock but negative values look ugly rock[center] = ne.evaluate('where(rcc<0,0,rcc)') sediment[center] = ne.evaluate('scc + ds') else: wcc = water[center] scc = sediment[center] rcc = rock[center] water[center] = wcc * (1 - Kev) + sdw sediment[center] = scc + sds sc = where(wcc > 0, scc / wcc, 2 * Kc) fKc = Kc * svdw ds = where(fKc > sc, (fKc - sc) * Ks, (fKc - sc) * Kdep) * wcc self.flowrate[center] = svdw self.scour[center] = ds self.sedimentpct[center] = sc self.capacity[center] = fKc sediment[center] = scc + ds + sds def flow(self, Kc, Ks, Kz, Ka, numexpr): zeros = np.zeros where = np.where min = np.minimum max = np.maximum abs = np.absolute arctan = np.arctan sin = np.sin center = (slice(1, -1, None), slice(1, -1, None)) rock = self.center ds = self.scour[center] rcc = rock[center] rock[center] = rcc - ds * Kz # there isn't really a bottom to the rock but negative values look ugly rock[center] = where(rcc < 0, 0, rcc) def rivergeneration( self, rainamount, rainvariance, userainmap, Kc, Ks, Kdep, Ka, Kev, Kspring, Kspringx, Kspringy, Kspringr, numexpr, ): self.init_water_and_sediment() self.rain(rainamount, rainvariance, userainmap) self.zeroedge(self.water) self.zeroedge(self.sediment) self.river(Kc, Ks, Kdep, Ka, Kev, numexpr) self.watermax = np.max(self.water) def fluvial_erosion( self, rainamount, rainvariance, userainmap, Kc, Ks, Kdep, Ka, Kspring, Kspringx, Kspringy, Kspringr, numexpr, ): self.flow(Kc, Ks, Kdep, Ka, numexpr) self.flowratemax = np.max(self.flowrate) self.scourmax = np.max(self.scour) self.scourmin = np.min(self.scour) self.sedmax = np.max(self.sediment) def analyze(self): self.neighborgrid() # just looking at up and left to avoid needless double calculations slopes = np.concatenate((np.abs(self.left - self.center), np.abs(self.up - self.center))) return '\n'.join(["%-15s: %.3f" % t for t in [ ('height average', np.average(self.center)), ('height median', np.median(self.center)), ('height max', np.max(self.center)), ('height min', np.min(self.center)), ('height std', np.std(self.center)), ('slope average', np.average(slopes)), ('slope median', np.median(slopes)), ('slope max', np.max(slopes)), ('slope min', np.min(slopes)), ('slope std', np.std(slopes)) ]])class TestGrid(unittest.TestCase):
def test_diffuse(self): g = Grid(5) g.peak(1) self.assertEqual(g.center[2, 2], 1.0) g.diffuse(0.1, numexpr=False) for n in [(2, 1), (2, 3), (1, 2), (3, 2)]: self.assertAlmostEqual(g.center[n], 0.1) self.assertAlmostEqual(g.center[2, 2], 0.6) def test_diffuse_numexpr(self): g = Grid(5) g.peak(1) g.diffuse(0.1, numexpr=False) h = Grid(5) h.peak(1) h.diffuse(0.1, numexpr=True) self.assertEqual(list(g.center.flat), list(h.center.flat)) def test_avalanche_numexpr(self): g = Grid(5) g.peak(1) g.avalanche(0.1, numexpr=False) h = Grid(5) h.peak(1) h.avalanche(0.1, numexpr=True) print(g) print(h) np.testing.assert_almost_equal(g.center, h.center)if name == "main":
import argparse parser = argparse.ArgumentParser(description='Erode a terrain while assuming zero boundary conditions.') parser.add_argument('-I', dest='iterations', type=int, default=1, help='the number of iterations') parser.add_argument('-Kd', dest='Kd', type=float, default=0.01, help='Diffusion constant') parser.add_argument('-Kh', dest='Kh', type=float, default=6, help='Maximum stable cliff height') parser.add_argument('-Kp', dest='Kp', type=float, default=0.1, help='Avalanche probability for unstable cliffs') parser.add_argument('-Kr', dest='Kr', type=float, default=0.1, help='Average amount of rain per iteration') parser.add_argument('-Kspring', dest='Kspring', type=float, default=0.0, help='Average amount of wellwater per iteration') parser.add_argument('-Kspringx', dest='Kspringx', type=float, default=0.5, help='relative x position of spring') parser.add_argument('-Kspringy', dest='Kspringy', type=float, default=0.5, help='relative y position of spring') parser.add_argument('-Kspringr', dest='Kspringr', type=float, default=0.02, help='radius of spring') parser.add_argument('-Kdep', dest='Kdep', type=float, default=0.1, help='Sediment deposition constant') parser.add_argument('-Ks', dest='Ks', type=float, default=0.1, help='Soil softness constant') parser.add_argument('-Kc', dest='Kc', type=float, default=1.0, help='Sediment capacity') parser.add_argument('-Ka', dest='Ka', type=float, default=2.0, help='Slope dependency of erosion') parser.add_argument( '-ri', action='store_true', dest='rawin', default=False, help='use Blender raw format for input') parser.add_argument( '-ro', action='store_true', dest='rawout', default=False, help='use Blender raw format for output') parser.add_argument('-i', action='store_true', dest='useinputfile', default=False, help='use an inputfile (instead of just a synthesized grid)') parser.add_argument( '-t', action='store_true', dest='timingonly', default=False, help='do not write anything to an output file') parser.add_argument('-infile', type=str, default="-", help='input filename') parser.add_argument('-outfile', type=str, default="-", help='output filename') parser.add_argument('-Gn', dest='gridsize', type=int, default=20, help='Gridsize (always square)') parser.add_argument('-Gp', dest='gridpeak', type=float, default=0, help='Add peak with given height') parser.add_argument('-Gs', dest='gridshelf', type=float, default=0, help='Add shelve with given height') parser.add_argument('-Gm', dest='gridmesa', type=float, default=0, help='Add mesa with given height') parser.add_argument('-Gr', dest='gridrandom', type=float, default=0, help='Add random values between 0 and given value') parser.add_argument('-m', dest='threads', type=int, default=1, help='number of threads to use') parser.add_argument('-u', action='store_true', dest='unittest', default=False, help='perform unittests') parser.add_argument('-a', action='store_true', dest='analyze', default=False, help='show some statistics of input and output meshes') parser.add_argument('-d', action='store_true', dest='dump', default=False, help='show sediment and water meshes at end of run') parser.add_argument('-n', action='store_true', dest='usenumexpr', default=False, help='use numexpr optimizations') args = parser.parse_args() print("\nInput arguments:") print("\n".join("%-15s: %s" % t for t in sorted(vars(args).items())), file=sys.stderr) if args.unittest: unittest.main(argv=[sys.argv[0]]) sys.exit(0) if args.useinputfile: if args.rawin: grid = Grid.fromRaw(args.infile) else: grid = Grid.fromFile(args.infile) else: grid = Grid(args.gridsize) if args.gridpeak > 0: grid.peak(args.gridpeak) if args.gridmesa > 0: grid.mesa(args.gridmesa) if args.gridshelf > 0: grid.shelf(args.gridshelf) if args.gridrandom > 0: grid.random(args.gridrandom) if args.analyze: print('\nstatistics of the input grid:\n\n', grid.analyze(), file=sys.stderr, sep='') t = getptime() for g in range(args.iterations): if args.Kd > 0: grid.diffuse(args.Kd, args.usenumexpr) if args.Kh > 0 and args.Kp > rand(): grid.avalanche(args.Kh, args.usenumexpr) if args.Kr > 0 or args.Kspring > 0: grid.fluvial_erosion( args.Kr, args.Kc, args.Ks, args.Kdep, args.Ka, args.Kspring, args.Kspringx, args.Kspringy, args.Kspringr, args.usenumexpr, ) t = getptime() - t print("\nElapsed time: %.1f seconds, max memory %.1f Mb.\n" % (t, grid.maxrss), file=sys.stderr) if args.analyze: print('\nstatistics of the output grid:\n\n', grid.analyze(), file=sys.stderr, sep='') if not args.timingonly: if args.rawout: grid.toRaw(args.outfile, vars(args)) else: grid.toFile(args.outfile) if args.dump: print("sediment\n", np.array_str(grid.sediment, precision=3), file=sys.stderr) print("water\n", np.array_str(grid.water, precision=3), file=sys.stderr) print("sediment concentration\n", np.array_str(grid.sediment / grid.water, precision=3), file=sys.stderr) - Assistant
It appears that you've pasted a Python script related to terrain simulation or erosion processes. Within the script, there's a
Gridclass which models a heightfield grid and includes methods for various processes such asdiffuse,avalanche,rain,river, and so on. Thediffusemethod, in particular, seems to be designed to simulate thermal erosion or the diffusion of height values across the terrain grid.Here's the
diffusemethod as given in your code snippet:def diffuse(self, Kd, numexpr): self.zeroedge() c = self.center[1:-1, 1:-1] up = self.center[:-2, 1:-1] down = self.center[2:, 1:-1] left = self.center[1:-1, :-2] right = self.center[1:-1, 2:] if(numexpr and numexpr_available): self.center[1:-1, 1:-1] = ne.evaluate('c + Kd * (up + down + left + right - 4.0 * c)') else: self.center[1:-1, 1:-1] = c + Kd * (up + down + left + right - 4.0 * c) self.maxrss = max(getmemsize(), self.maxrss) return self.centerThe method takes two arguments:
Kd, which appears to be the diffusion rate or constant, andnumexpr, which indicates whether to use thenumexprlibrary for optimized numerical computations.If
numexpris enabled (andnumexpr_availableis True, presumably this would be set elsewhere in the code based on whether thenumexprlibrary is properly installed), the script usesnumexprto evaluate the diffusion expression, which calculates the new height values for the central part of the grid based on neighboring values (up,down,left,right).If
numexpris not enabled, the diffusion is computed using standard NumPy operations.The
diffusemethod is designed to simulate a heat diffusion or blurring effect on the terrain, which is a common operation in terrain generation and erosion simulation to create more natural-looking landscapes.To fully understand the script, it would be essential to study each method of the
Gridclass, and possibly related classes or functions, as well as to see how they interact if there is an overarching simulation loop or application that uses this grid.As it stands, the script is quite detailed and covers several aspects of terrain simulation. If you have any more specific questions about the code or need help with a particular part, please let me know, and I will gladly assist.
- User
import bpy import random import math
SCALE_FACTOR = 4.2 # Scale factor controlling the spacing between buildings PADDING = 50 # Padding value to expand the boundary region
def clear_scene(): bpy.ops.object.select_all(action='DESELECT') bpy.ops.object.select_by_type(type='MESH') bpy.ops.object.delete()
def add_circle(radius): mesh = bpy.data.meshes.new("Circle") obj = bpy.data.objects.new("Circle", mesh) bpy.context.scene.collection.objects.link(obj)
# Set the circle as the active object bpy.context.view_layer.objects.active = obj obj.select_set(True) # Add a simple diffuse material to make the circle visible material = bpy.data.materials.new("CircleMaterial") obj.data.materials.append(material) verts = [] num_segments = 64 for i in range(num_segments): theta = (2 * math.pi) * (i / num_segments) x = radius * math.cos(theta) y = radius * math.sin(theta) z = 0 verts.append((x, y, z)) edges = [(i, (i + 1) % num_segments) for i in range(num_segments)] mesh.from_pydata(verts, [], edges) mesh.update()def is_overlapping(new_location, existing_locations, threshold=10): for existing_location in existing_locations: distance = math.sqrt((new_location[0] - existing_location[0])**2 + (new_location[1] - existing_location[1])**2) if distance < threshold: return True return False
def generate_building(collection_names, min_radius, max_radius, total_buildings): objects = [obj for name in collection_names for obj in bpy.data.collections.get(name, {}).objects] if not objects: return
# Ensure a deterministic number of buildings for each collection num_to_add = total_buildings angle_between_buildings = (2 * math.pi) / num_to_add existing_locations = [] for _ in range(num_to_add): angle = _ * angle_between_buildings radius = random.uniform(min_radius, max_radius) if radius <= 0: # Skip if radius is non-positive continue # Apply padding to expand the boundary region x = (radius * SCALE_FACTOR + PADDING) * math.cos(angle) y = (radius * SCALE_FACTOR + PADDING) * math.sin(angle) selected_obj = random.choice(objects) new_obj = selected_obj.copy() new_location = (x, y, 0) while is_overlapping(new_location, existing_locations): angle = random.uniform(0, 2 * math.pi) radius = random.uniform(min_radius, max_radius) if radius <= 0: # Skip if radius is non-positive continue x = (radius * SCALE_FACTOR + PADDING) * math.cos(angle) y = (radius * SCALE_FACTOR + PADDING) * math.sin(angle) new_location = (x, y, 0) existing_locations.append(new_location) new_obj.location = new_location rotation_angle = random.uniform(0, 2 * math.pi) new_obj.rotation_euler = (0, 0, rotation_angle) bpy.context.scene.collection.objects.link(new_obj)def populate_city_layout(radius_collection_mapping): clear_scene()
# Visualization helper for the largest radius largest_radius = max(radius_collection_mapping.keys()) add_circle(largest_radius + PADDING) # Include padding in the visualization running_ratio_sum = 0 for radius, radius_info in radius_collection_mapping.items(): collection_names = radius_info.get('collections', []) total_buildings = radius_info.get('total_buildings', 0) # Skip the radius if collection names are not found or if it is deactivated if not collection_names or collection_names[0][0] == '#': print(f"Skipping radius {radius}: No collection names found or radius is deactivated.") continue running_ratio_sum += 1 / len(radius_collection_mapping) generate_building(collection_names, radius * 0.75, radius * 1.25, total_buildings) assert abs(running_ratio_sum - 1) < 0.01, f"Total ratio ({running_ratio_sum}) must be close to 1."Specify the mapping of radius to collection names (total buildings for each radius are specified separately)
radius_collection_mapping = { 300: {'collections': ["Large Buildings", "Medium Buildings"], 'total_buildings': 20}, 400: {'collections': ["Medium Buildings", "Small Buildings"], 'total_buildings': 30}, 500: {'collections': ["Small Buildings"], 'total_buildings': 15}, # 600: {'collections': ["Tiny Buildings", "Another Collection"], 'total_buildings': 25}, # 700: {'collections': ["Micro Buildings", "Additional Collection"], 'total_buildings': 18}, # 800: {'collections': ["Nonexistent Collection"], 'total_buildings': 0} # For testing: Nonexistent Collection # Add more collections following the structures above # Prefix a collection name with '#' to deactivate the radius #900: {'collections': ["#CollectionToDeactivate"], 'total_buildings': 0} }
populate_city_layout(radius_collection_mapping)
- Assistant
This Python script is a Blender script designed to procedurally generate and position buildings in a circular city layout. It defines several functions that clear the current Blender scene, create a visual circle, check for overlap between placed buildings, generate buildings within specific constraints, and populate the city layout with buildings according to predefined configuration within
radius_collection_mapping.Here's a brief summary of each function's role:
clear_scene(): Clears the scene of all mesh objects.add_circle(radius): Creates a visual aid in the form of a circle with a givenradius, which could be useful for visualizing the city boundary.is_overlapping(new_location, existing_locations, threshold=10): Checks whether a new proposed location for a building overlaps with existing buildings, based on a distancethreshold.generate_building(collection_names, min_radius, max_radius, total_buildings): Creates a specified number of buildings (total_buildings), picking random object templates from given collections (collection_names), and positions them at a distance from the origin within a specific range (min_radiustomax_radius), ensuring that buildings don't overlap and are evenly spaced within an angular slice.populate_city_layout(radius_collection_mapping): Drives the entire city generation process based on a dictionary (radius_collection_mapping) that maps radii to specific collections of building templates and the number of buildings to generate at that radius.
The
radius_collection_mappingdictionary at the end of the script is the control mapping that determines which collections of building objects (e.g., "Large Buildings", "Medium Buildings", etc.) are associated with each radius from the origin and how many buildings to place at each of those distances.When running the script, it calls
populate_city_layoutwith theradius_collection_mappingdictionary. This function first clears the scene and then iterates through the provided configuration to distribute and generate buildings according to the guidelines.This Blender script assumes that you have collections of pre-modeled buildings available in Blender, organized into collections by size or type.
To run this script in Blender:
- Open Blender.
- Switch to "Scripting" workspace or open a Text Editor pane.
- Paste the code into a new text block.
- Press "Run Script" to execute.
- Ensure that you have collections corresponding to the names specified in the
radius_collection_mappingvariable. If the functions refer to nonexistent collections or objects, you'll need to modify the script to match the actual names used in your Blender project.
Be aware that this script modifies the current scene, so it's a good idea to save your work before running it. Moreover, you must have collections named as referenced in the script for it to work correctly. If you want to experiment with the script, ensure that you have the appropriate collections (or create them for testing purposes).
- User
how can I allow the user to use a grid pattern aswell
- Assistant
To allow the user to use a grid pattern for building placement in addition to the current circular pattern, you would need to modify the script to include the option of generating buildings in a grid layout. To do this, you could create a function for grid-based building generation and then incorporate user input or script arguments to choose between the circular or grid pattern.
Below is an outline of the steps you could take to modify your script.
- Create a new function to generate buildings using a grid pattern:
def generate_building_grid(collection_names, grid_size, total_buildings): if not collection_names: return objects = [obj for name in collection_names for obj in bpy.data.collections.get(name, {}).objects] if not objects: return num_to_add = total_buildings # Calculate the number of buildings along each axis buildings_per_side = int(math.sqrt(num_to_add)) spacing = SCALE_FACTOR # Use the scale factor for distance between buildings for x in range(buildings_per_side): for y in range(buildings_per_side): location = (x * spacing, y * spacing, 0) if is_overlapping(location, existing_locations): continue selected_obj = random.choice(objects) new_obj = selected_obj.copy() new_obj.location = location rotation_angle = random.uniform(0, 2 * math.pi) new_obj.rotation_euler = (0, 0, rotation_angle) bpy.context.scene.collection.objects.link(new_obj) existing_locations.append(location)This function will create a
total_buildingsnumber of buildings positioned in a square grid pattern.- Modify the
populate_city_layoutfunction to include user input or a parameter to choose between circular or grid layout:
def populate_city_layout(radius_collection_mapping, layout_pattern='circle'): clear_scene() if layout_pattern == 'circle': # Implementation for circle layout (existing code) ... elif layout_pattern == 'grid': # Call the grid generation function generate_building_grid(...)- Modify the user's input mechanism or script arguments to accept the layout pattern as an option:
# Add an argument to define layout pattern via command line (or you could use user input option) import argparse parser = argparse.ArgumentParser(description='Generate city layout') parser.add_argument('--pattern', type=str, choices=['circle', 'grid'], default='circle', help='Choose layout pattern') args = parser.parse_args() # Pass the chosen layout pattern to the populate_city_layout function populate_city_layout(radius_collection_mapping, layout_pattern=args.pattern)- Ensure that the
existing_locationslist is accessible by both the circular and grid pattern functions. This may involve defining it at a higher level in the script, passing it as an argument to the functions, or managing it within a class structure.
Please note that these modifications are a high-level guide and will need to be adapted to your specific use case and the rest of your script. You'll need to write the complete
generate_building_gridfunction to fit within the current script structure, handle the placement of buildings correctly without overlap, and ensure the user can easily switch between patterns.