| """Generates psychedelic color textures in the spirit of Blender's magic texture shader using Python/Numpy |
| |
| https://github.com/cheind/magic-texture |
| """ |
| from typing import Tuple, Optional |
| import numpy as np |
|
|
|
|
| def coordinate_grid(shape: Tuple[int, int], dtype=np.float32): |
| """Returns a three-dimensional coordinate grid of given shape for use in `magic`.""" |
| x = np.linspace(-1, 1, shape[1], endpoint=True, dtype=dtype) |
| y = np.linspace(-1, 1, shape[0], endpoint=True, dtype=dtype) |
| X, Y = np.meshgrid(x, y) |
| XYZ = np.stack((X, Y, np.ones_like(X)), -1) |
| return XYZ |
|
|
|
|
| def random_transform(coords: np.ndarray, rng: np.random.Generator = None): |
| """Returns randomly transformed coordinates""" |
| H, W = coords.shape[:2] |
| rng = rng or np.random.default_rng() |
| m = rng.uniform(-1.0, 1.0, size=(3, 3)).astype(coords.dtype) |
| return (coords.reshape(-1, 3) @ m.T).reshape(H, W, 3) |
|
|
|
|
| def magic( |
| coords: np.ndarray, |
| depth: Optional[int] = None, |
| distortion: Optional[int] = None, |
| rng: np.random.Generator = None, |
| ): |
| """Returns color magic color texture. |
| |
| The implementation is based on Blender's (https://www.blender.org/) magic |
| texture shader. The following adaptions have been made: |
| - we exchange the nested if-cascade by a probabilistic iterative approach |
| |
| Kwargs |
| ------ |
| coords: HxWx3 array |
| Coordinates transformed into colors by this method. See |
| `magictex.coordinate_grid` to generate the default. |
| depth: int (optional) |
| Number of transformations applied. Higher numbers lead to more |
| nested patterns. If not specified, randomly sampled. |
| distortion: float (optional) |
| Distortion of patterns. Larger values indicate more distortion, |
| lower values tend to generate smoother patterns. If not specified, |
| randomly sampled. |
| rng: np.random.Generator |
| Optional random generator to draw samples from. |
| |
| Returns |
| ------- |
| colors: HxWx3 array |
| Three channel color image in range [0,1] |
| """ |
| rng = rng or np.random.default_rng() |
| if distortion is None: |
| distortion = rng.uniform(1, 4) |
| if depth is None: |
| depth = rng.integers(1, 5) |
|
|
| H, W = coords.shape[:2] |
| XYZ = coords |
| x = np.sin((XYZ[..., 0] + XYZ[..., 1] + XYZ[..., 2]) * distortion) |
| y = np.cos((-XYZ[..., 0] + XYZ[..., 1] - XYZ[..., 2]) * distortion) |
| z = -np.cos((-XYZ[..., 0] - XYZ[..., 1] + XYZ[..., 2]) * distortion) |
|
|
| if depth > 0: |
| x *= distortion |
| y *= distortion |
| z *= distortion |
| y = -np.cos(x - y + z) |
| y *= distortion |
|
|
| xyz = [x, y, z] |
| fns = [np.cos, np.sin] |
| for _ in range(1, depth): |
| axis = rng.choice(3) |
| fn = fns[rng.choice(2)] |
| signs = rng.binomial(n=1, p=0.5, size=4) * 2 - 1 |
|
|
| xyz[axis] = signs[-1] * fn( |
| signs[0] * xyz[0] + signs[1] * xyz[1] + signs[2] * xyz[2] |
| ) |
| xyz[axis] *= distortion |
|
|
| x, y, z = xyz |
| x /= 2 * distortion |
| y /= 2 * distortion |
| z /= 2 * distortion |
| c = 0.5 - np.stack((x, y, z), -1) |
| np.clip(c, 0, 1.0) |
| return c |
