From f04aec9a1b62e772d7a769741d36aff9aa345d7e Mon Sep 17 00:00:00 2001 From: Jan Petykiewicz Date: Sun, 31 Oct 2021 19:00:32 -0700 Subject: [PATCH] rename eps -> foreground --- gridlock/draw.py | 76 ++++++++++++++++++++-------------------- gridlock/examples/ex0.py | 10 +++--- gridlock/grid.py | 2 +- 3 files changed, 44 insertions(+), 44 deletions(-) diff --git a/gridlock/draw.py b/gridlock/draw.py index c8938be..6385213 100644 --- a/gridlock/draw.py +++ b/gridlock/draw.py @@ -15,7 +15,7 @@ from . import GridError # without having to pass `cell_data` again each time? -eps_callable_t = Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray], numpy.ndarray] +foreground_callable_t = Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray], numpy.ndarray] def draw_polygons(self, @@ -24,7 +24,7 @@ def draw_polygons(self, center: numpy.ndarray, polygons: Sequence[numpy.ndarray], thickness: float, - eps: Union[Sequence[Union[float, eps_callable_t]], float, eps_callable_t], + foreground: Union[Sequence[Union[float, foreground_callable_t]], float, foreground_callable_t], ) -> None: """ Draw polygons on an axis-aligned plane. @@ -37,9 +37,9 @@ def draw_polygons(self, (non-closed, clockwise). If Nx3, the `surface_normal` coordinate is ignored. Each polygon must have at least 3 vertices. thickness: Thickness of the layer to draw - eps: Value to draw with ('epsilon'). Can be scalar, callable, or a list + foreground: Value to draw with ('brush color'). Can be scalar, callable, or a list of any of these (1 per grid). Callable values should take an ndarray the shape of the - grid and return an ndarray of equal shape containing the eps value at the given x, y, + grid and return an ndarray of equal shape containing the foreground value at the given x, y, and z (natural, not grid coordinates). Raises: @@ -66,11 +66,11 @@ def draw_polygons(self, raise GridError(malformed + 'must be in plane with surface normal ' + 'xyz'[surface_normal]) - # Broadcast eps where necessary - if numpy.size(eps) == 1: - eps = [eps] * len(cell_data) - elif isinstance(eps, numpy.ndarray): - raise GridError('ndarray not supported for eps') + # Broadcast foreground where necessary + if numpy.size(foreground) == 1: + foreground = [foreground] * len(cell_data) + elif isinstance(foreground, numpy.ndarray): + raise GridError('ndarray not supported for foreground') # ## Compute sub-domain of the grid occupied by polygons # 1) Compute outer bounds (bd) of polygons @@ -103,21 +103,21 @@ def draw_polygons(self, # iterate over grids for i, grid in enumerate(cell_data): - # ## Evaluate or expand eps[i] - if callable(eps[i]): + # ## Evaluate or expand foreground[i] + if callable(foreground[i]): # meshgrid over the (shifted) domain domain = [self.shifted_xyz(i)[k][bdi_min[k]:bdi_max[k]+1] for k in range(3)] (x0, y0, z0) = numpy.meshgrid(*domain, indexing='ij') # evaluate on the meshgrid - eps_i = eps[i](x0, y0, z0) - if not numpy.isfinite(eps_i).all(): - raise GridError(f'Non-finite values in eps[{i}]') - elif numpy.size(eps[i]) != 1: - raise GridError(f'Unsupported eps[{i}]: {type(eps[i])}') + foreground_i = foreground[i](x0, y0, z0) + if not numpy.isfinite(foreground_i).all(): + raise GridError(f'Non-finite values in foreground[{i}]') + elif numpy.size(foreground[i]) != 1: + raise GridError(f'Unsupported foreground[{i}]: {type(foreground[i])}') else: - # eps[i] is scalar non-callable - eps_i = eps[i] + # foreground[i] is scalar non-callable + foreground_i = foreground[i] w_xy = numpy.zeros((bdi_max - bdi_min + 1)[surface].astype(int)) @@ -185,7 +185,7 @@ def draw_polygons(self, # ## Modify the grid g_slice = (i,) + tuple(numpy.s_[bdi_min[a]:bdi_max[a] + 1] for a in range(3)) - cell_data[g_slice] = (1 - w) * cell_data[g_slice] + w * eps_i + cell_data[g_slice] = (1 - w) * cell_data[g_slice] + w * foreground_i def draw_polygon(self, @@ -194,7 +194,7 @@ def draw_polygon(self, center: numpy.ndarray, polygon: numpy.ndarray, thickness: float, - eps: Union[Sequence[Union[float, eps_callable_t]], float, eps_callable_t], + foreground: Union[Sequence[Union[float, foreground_callable_t]], float, foreground_callable_t], ) -> None: """ Draw a polygon on an axis-aligned plane. @@ -207,9 +207,9 @@ def draw_polygon(self, clockwise). If Nx3, the `surface_normal` coordinate is ignored. Must have at least 3 vertices. thickness: Thickness of the layer to draw - eps: Value to draw with ('epsilon'). See `draw_polygons()` for details. + foreground: Value to draw with ('brush color'). See `draw_polygons()` for details. """ - self.draw_polygons(cell_data, surface_normal, center, [polygon], thickness, eps) + self.draw_polygons(cell_data, surface_normal, center, [polygon], thickness, foreground) def draw_slab(self, @@ -217,7 +217,7 @@ def draw_slab(self, surface_normal: int, center: numpy.ndarray, thickness: float, - eps: Union[List[Union[float, eps_callable_t]], float, eps_callable_t], + foreground: Union[List[Union[float, foreground_callable_t]], float, foreground_callable_t], ) -> None: """ Draw an axis-aligned infinite slab. @@ -227,7 +227,7 @@ def draw_slab(self, surface_normal: Axis normal to the plane we're drawing on. Integer in `range(3)`. center: `surface_normal` coordinate value at the center of the slab thickness: Thickness of the layer to draw - eps: Value to draw with ('epsilon'). See `draw_polygons()` for details. + foreground: Value to draw with ('brush color'). See `draw_polygons()` for details. """ # Turn surface_normal into its integer representation if surface_normal not in range(3): @@ -259,14 +259,14 @@ def draw_slab(self, [xyz_max[0], xyz_min[1]], [xyz_min[0], xyz_min[1]]], dtype=float) - self.draw_polygon(cell_data, surface_normal, center_shift, p, thickness, eps) + self.draw_polygon(cell_data, surface_normal, center_shift, p, thickness, foreground) def draw_cuboid(self, cell_data: numpy.ndarray, center: numpy.ndarray, dimensions: numpy.ndarray, - eps: Union[List[Union[float, eps_callable_t]], float, eps_callable_t], + foreground: Union[List[Union[float, foreground_callable_t]], float, foreground_callable_t], ) -> None: """ Draw an axis-aligned cuboid @@ -276,14 +276,14 @@ def draw_cuboid(self, center: 3-element ndarray or list specifying the cuboid's center dimensions: 3-element list or ndarray containing the x, y, and z edge-to-edge sizes of the cuboid - eps: Value to draw with ('epsilon'). See `draw_polygons()` for details. + foreground: Value to draw with ('brush color'). See `draw_polygons()` for details. """ p = numpy.array([[-dimensions[0], +dimensions[1]], [+dimensions[0], +dimensions[1]], [+dimensions[0], -dimensions[1]], [-dimensions[0], -dimensions[1]]], dtype=float) / 2.0 thickness = dimensions[2] - self.draw_polygon(cell_data, 2, center, p, thickness, eps) + self.draw_polygon(cell_data, 2, center, p, thickness, foreground) def draw_cylinder(self, @@ -293,7 +293,7 @@ def draw_cylinder(self, radius: float, thickness: float, num_points: int, - eps: Union[List[Union[float, eps_callable_t]], float, eps_callable_t], + foreground: Union[List[Union[float, foreground_callable_t]], float, foreground_callable_t], ) -> None: """ Draw an axis-aligned cylinder. Approximated by a num_points-gon @@ -305,13 +305,13 @@ def draw_cylinder(self, radius: cylinder radius thickness: Thickness of the layer to draw num_points: The circle is approximated by a polygon with `num_points` vertices - eps: Value to draw with ('epsilon'). See `draw_polygons()` for details. + foreground: Value to draw with ('brush color'). See `draw_polygons()` for details. """ theta = numpy.linspace(0, 2*numpy.pi, num_points, endpoint=False) x = radius * numpy.sin(theta) y = radius * numpy.cos(theta) polygon = numpy.hstack((x[:, None], y[:, None])) - self.draw_polygon(cell_data, surface_normal, center, polygon, thickness, eps) + self.draw_polygon(cell_data, surface_normal, center, polygon, thickness, foreground) def draw_extrude_rectangle(self, @@ -351,7 +351,7 @@ def draw_extrude_rectangle(self, numpy.array([-1, 1, 1, -1], dtype=float) * dim[1]/2.0)).T thickness = distance - eps_func = [] + foreground_func = [] for i, grid in enumerate(cell_data): z = self.pos2ind(rectangle[0, :], i, round_ind=False, check_bounds=False)[direction] @@ -360,19 +360,19 @@ def draw_extrude_rectangle(self, fpart = z - numpy.floor(z) mult = [1-fpart, fpart][::s] # reverses if s negative - eps = mult[0] * grid[tuple(ind)] + foreground = mult[0] * grid[tuple(ind)] ind[direction] += 1 - eps += mult[1] * grid[tuple(ind)] + foreground += mult[1] * grid[tuple(ind)] - def f_eps(xs, ys, zs, i=i, eps=eps) -> numpy.ndarray: + def f_foreground(xs, ys, zs, i=i, foreground=foreground) -> numpy.ndarray: # transform from natural position to index xyzi = numpy.array([self.pos2ind(qrs, which_shifts=i) for qrs in zip(xs.flat, ys.flat, zs.flat)], dtype=int) # reshape to original shape and keep only in-plane components qi, ri = (numpy.reshape(xyzi[:, k], xs.shape) for k in surface) - return eps[qi, ri] + return foreground[qi, ri] - eps_func.append(f_eps) + foreground_func.append(f_foreground) - self.draw_polygon(cell_data, direction, center, p, thickness, eps_func) + self.draw_polygon(cell_data, direction, center, p, thickness, foreground_func) diff --git a/gridlock/examples/ex0.py b/gridlock/examples/ex0.py index 0e1cd86..ca2ef55 100644 --- a/gridlock/examples/ex0.py +++ b/gridlock/examples/ex0.py @@ -6,17 +6,17 @@ if __name__ == '__main__': # xyz = [numpy.arange(-5.0, 6.0), numpy.arange(-4.0, 5.0), [-1.0, 1.0]] # eg = Grid(xyz) # egc = Grid.allocate(0.0) - # # eg.draw_slab(egc, surface_normal=2, center=0, thickness=10, eps=2) + # # eg.draw_slab(egc, surface_normal=2, center=0, thickness=10, foreground=2) # eg.draw_cylinder(egc, surface_normal=2, center=[0, 0, 0], radius=4, - # thickness=10, num_points=1000, eps=1) + # thickness=10, num_points=1000, foreground=1) # eg.visualize_slice(egc, surface_normal=2, center=0, which_shifts=2) # xyz2 = [numpy.arange(-5.0, 6.0), [-1.0, 1.0], numpy.arange(-4.0, 5.0)] # eg2 = Grid(xyz2) # eg2c = Grid.allocate(0.0) - # # eg2.draw_slab(eg2c, surface_normal=2, center=0, thickness=10, eps=2) + # # eg2.draw_slab(eg2c, surface_normal=2, center=0, thickness=10, foreground=2) # eg2.draw_cylinder(eg2c, surface_normal=1, center=[0, 0, 0], - # radius=4, thickness=10, num_points=1000, eps=1.0) + # radius=4, thickness=10, num_points=1000, foreground=1.0) # eg2.visualize_slice(eg2c, surface_normal=1, center=0, which_shifts=1) # n = 20 @@ -37,7 +37,7 @@ if __name__ == '__main__': # eg.draw_slab(Direction.z, 0, 10, 2) eg.save('/home/jan/Desktop/test.pickle') eg.draw_cylinder(egc, surface_normal=2, center=[0, 0, 0], radius=2.0, - thickness=10, num_poitns=1000, eps=1) + thickness=10, num_poitns=1000, foreground=1) eg.draw_extrude_rectangle(egc, rectangle=[[-2, 1, -1], [0, 1, 1]], direction=1, poalarity=+1, distance=5) eg.visualize_slice(egc, surface_normal=2, center=0, which_shifts=2) diff --git a/gridlock/grid.py b/gridlock/grid.py index eda2410..d0a1530 100644 --- a/gridlock/grid.py +++ b/gridlock/grid.py @@ -10,7 +10,7 @@ import copy from . import GridError -eps_callable_type = Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray], numpy.ndarray] +foreground_callable_type = Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray], numpy.ndarray] T = TypeVar('T', bound='Grid')