4 |
5 |
6 |
12 | 
13 | 
14 |
15 |
16 |
17 | 
18 | 
19 |
20 |
21 |
22 | 
23 | 
24 |
25 |
26 | ## Triply Periodic Minimal Surface
27 |
28 | How to create a TPMS mesh in Blender:
29 |
30 | https://github.com/kmarchais/blender-tpms/assets/22714778/80af0ecc-1544-418c-bea5-072051c4b2e1
31 |
32 | ## Installation
33 |
34 | > :warning: **Blender 3.6 or higher is required**
35 | >
36 | > :warning: **The installation of this add-on will install the [PyVista](https://docs.pyvista.org/version/stable/) library and its dependencies in your Blender's Python environment**
37 |
38 | - Download the ZIP file from this repository (button `Code > Download ZIP`)
39 | - In Blender, `Edit > Preferences > Add-ons > Install...` find the zip file that you just downloaded and click `Install Add-on`
40 | - Enable the add-on by clicking the checkbox (this will install the required python dependencies)
41 | - You are ready to create TPMS meshes in `Add > Mesh > TPMS`
42 |
43 | ## Coming Soon
44 |
45 | - Lattice structures 
46 | - Graded TPMS (density, size, type)
47 | - Ability to modify the TPMS properties even when the operator is not active anymore
48 |
49 | If you have a specific feature in mind that you would like to have, or if you're particularly interested in one of the features listed above, please let me know.
50 |
51 | ## Useful repository
52 |
53 | - To create TPMS geometries and meshes (including periodical meshes) for simulation with Python, consider using [Microgen](https://github.com/3MAH/microgen)
54 |
--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
1 | """Blender TPMS addon to generate TPMS meshes."""
2 |
3 | try:
4 | import blender_tpms
5 | except ImportError:
6 | import importlib
7 | import site
8 | import subprocess
9 | import sys
10 | from pathlib import Path
11 |
12 | # install the blender_tpms package in blender's python environment
13 | cmd = [
14 | sys.executable,
15 | "-m",
16 | "pip",
17 | "install",
18 | str(Path(__file__).parent),
19 | ]
20 | subprocess.check_call(cmd)
21 |
22 | user_site = site.getusersitepackages()
23 | if user_site not in sys.path:
24 | sys.path.append(user_site)
25 |
26 | importlib.import_module("blender_tpms")
27 |
28 | bl_info = {
29 | "name": "TPMS",
30 | "author": "kmarchais",
31 | "version": (0, 1),
32 | "blender": (3, 6, 0),
33 | "location": "Add > TPMS",
34 | "description": "Create a TPMS mesh",
35 | "warning": "",
36 | "doc_url": "https://github.com/kmarchais/blender-tpms",
37 | "category": "Add Mesh",
38 | }
39 |
40 | import blender_tpms
41 |
42 |
43 | def register() -> None:
44 | """Register the addon."""
45 | blender_tpms.register()
46 |
47 |
48 | def unregister() -> None:
49 | """Unregister the addon."""
50 | blender_tpms.unregister()
51 |
--------------------------------------------------------------------------------
/assets/cylinder_gyroid_honeycomb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kmarchais/blender-tpms/7fbca789781d78bf505cc1a2940503417839c35f/assets/cylinder_gyroid_honeycomb.png
--------------------------------------------------------------------------------
/assets/geo_nodes.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kmarchais/blender-tpms/7fbca789781d78bf505cc1a2940503417839c35f/assets/geo_nodes.png
--------------------------------------------------------------------------------
/assets/lattice.blend:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kmarchais/blender-tpms/7fbca789781d78bf505cc1a2940503417839c35f/assets/lattice.blend
--------------------------------------------------------------------------------
/assets/lattice.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kmarchais/blender-tpms/7fbca789781d78bf505cc1a2940503417839c35f/assets/lattice.png
--------------------------------------------------------------------------------
/assets/tpms.blend:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kmarchais/blender-tpms/7fbca789781d78bf505cc1a2940503417839c35f/assets/tpms.blend
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "blender_tpms"
3 | version = "0.1.0"
4 | description = "TPMS library for the Blender-TPMS addon."
5 | authors = [{ name = "Kevin Marchais", email = "kevin.marchais@hivelix.io" }]
6 | dependencies = ["pyvista"]
7 | readme = "README.md"
8 | requires-python = ">= 3.8"
9 |
10 | [project.optional-dependencies]
11 | dev = [
12 | "bpy",
13 | "blender-stubs",
14 | # "fake-bpy-module-latest", # https://github.com/nutti/fake-bpy-module?tab=readme-ov-file#supported-blender-version
15 | "ruff",
16 | "mypy",
17 | "pytest",
18 | ]
19 |
20 | [build-system]
21 | requires = ["hatchling"]
22 | build-backend = "hatchling.build"
23 |
24 | [tool.hatch.metadata]
25 | allow-direct-references = true
26 |
27 | [tool.hatch.build.targets.wheel]
28 | packages = ["src/blender_tpms"]
29 |
30 | [tool.ruff.lint]
31 | select = ["ALL"]
32 |
--------------------------------------------------------------------------------
/src/blender_tpms/__init__.py:
--------------------------------------------------------------------------------
1 | """Blender TPMS package for the TPMS addon."""
2 |
3 | from .ui import register, unregister
4 |
5 | __all__ = ["register", "unregister"]
6 |
--------------------------------------------------------------------------------
/src/blender_tpms/interface.py:
--------------------------------------------------------------------------------
1 | """Interface between PyVista and Blender."""
2 |
3 | from __future__ import annotations
4 |
5 | from inspect import getmembers, isfunction
6 | from typing import TYPE_CHECKING
7 |
8 | import bpy
9 | import numpy as np
10 |
11 | if TYPE_CHECKING:
12 | import pyvista as pv # pragma: no cover
13 |
14 |
15 | def polydata_to_mesh(polydata: pv.PolyData, mesh_name: str = "Tpms") -> bpy.types.Mesh:
16 | """Convert a vtkPolyData to a mesh."""
17 | faces = []
18 | if not polydata.is_all_triangles:
19 | polydata = polydata.triangulate()
20 | polydata.flip_normals()
21 | faces = np.reshape(polydata.faces, (polydata.n_cells, 4))[:, 1:]
22 |
23 | mesh = bpy.data.meshes.new(mesh_name)
24 | mesh.from_pydata(vertices=polydata.points, edges=[], faces=faces)
25 | mesh.update()
26 |
27 | return mesh
28 |
29 |
30 | def get_all_surfaces() -> list[tuple[str, str, str]]:
31 | """Get all TPMS surfaces."""
32 | from .tpms import surfaces
33 |
34 | functions = getmembers(surfaces, isfunction)
35 | return [(func[0], func[0], func[0]) for func in functions]
36 |
--------------------------------------------------------------------------------
/src/blender_tpms/material.py:
--------------------------------------------------------------------------------
1 | """Material module to visualize the TPMS field on the surface of the mesh."""
2 |
3 | from __future__ import annotations
4 |
5 | from typing import TYPE_CHECKING
6 |
7 | import bpy
8 | import matplotlib.pyplot as plt
9 | import numpy as np
10 |
11 | if TYPE_CHECKING:
12 | from blender_tpms.tpms.tpms import Tpms # pragma: no cover
13 |
14 |
15 | def shader_node_attribute(
16 | material: bpy.types.Material,
17 | attr_name: str,
18 | ) -> bpy.types.ShaderNodeAttribute:
19 | """Create an attribute node to get the TPMS field values."""
20 | attribute_node = material.node_tree.nodes.new("ShaderNodeAttribute")
21 | if not isinstance(attribute_node, bpy.types.ShaderNodeAttribute):
22 | raise TypeError("Shader node is not ShaderNodeAttribute") # pragma: no cover
23 |
24 | attribute_node.attribute_name = attr_name
25 | return attribute_node
26 |
27 |
28 | def shader_node_map_range(
29 | material: bpy.types.Material,
30 | attr_name: str,
31 | tpms: Tpms,
32 | ) -> bpy.types.ShaderNodeMapRange:
33 | """Create a map range node to map the attribute values to the color ramp."""
34 | map_range_node = material.node_tree.nodes.new("ShaderNodeMapRange")
35 | if not isinstance(map_range_node, bpy.types.ShaderNodeMapRange):
36 | raise TypeError("Shader node is not ShaderNodeMapRange") # pragma: no cover
37 |
38 | map_range_node.inputs["From Min"].default_value = np.min(tpms.vtk_mesh[attr_name])
39 | map_range_node.inputs["From Max"].default_value = np.max(tpms.vtk_mesh[attr_name])
40 | return map_range_node
41 |
42 |
43 | def shader_node_val_to_rgb(
44 | material: bpy.types.Material,
45 | colormap: str,
46 | n_colors: int,
47 | ) -> bpy.types.ShaderNodeValToRGB:
48 | """Create a color ramp node with a colormap."""
49 | color_ramp_node = material.node_tree.nodes.new("ShaderNodeValToRGB")
50 |
51 | if not isinstance(color_ramp_node, bpy.types.ShaderNodeValToRGB):
52 | raise TypeError("Shader node is not ShaderNodeVal") # pragma: no cover
53 |
54 | # remove to create it again in the last iteration to have it selected
55 | last_elem = color_ramp_node.color_ramp.elements[-1]
56 | color_ramp_node.color_ramp.elements.remove(last_elem)
57 |
58 | cmap = plt.get_cmap(colormap)
59 | for i in range(n_colors):
60 | location = i / (n_colors - 1)
61 | if i != 0:
62 | color_ramp_node.color_ramp.elements.new(location)
63 | color = [c**2.2 for c in cmap(location)] # sRGB to Linear RGB
64 | color_ramp_node.color_ramp.elements[i].color = color
65 |
66 | color_ramp_node.label = colormap
67 | return color_ramp_node
68 |
69 |
70 | def link_nodes(
71 | material: bpy.types.Material,
72 | bsdf: bpy.types.Node,
73 | attribute_node: bpy.types.Node,
74 | map_range_node: bpy.types.Node,
75 | color_ramp_node: bpy.types.Node,
76 | material_output_node: bpy.types.Node,
77 | ) -> None:
78 | """Link the nodes to create the material."""
79 | material.node_tree.links.new(
80 | attribute_node.outputs["Fac"],
81 | map_range_node.inputs["Value"],
82 | )
83 |
84 | material.node_tree.links.new(
85 | map_range_node.outputs["Result"],
86 | color_ramp_node.inputs["Fac"],
87 | )
88 | material.node_tree.links.new(
89 | color_ramp_node.outputs["Color"],
90 | bsdf.inputs["Base Color"],
91 | )
92 | material.node_tree.links.new(
93 | bsdf.outputs["BSDF"],
94 | material_output_node.inputs["Surface"],
95 | )
96 |
97 |
98 | def move_nodes(
99 | bsdf: bpy.types.Node,
100 | attribute_node: bpy.types.Node,
101 | map_range_node: bpy.types.Node,
102 | color_ramp_node: bpy.types.Node,
103 | ) -> None:
104 | """Move the nodes so they are not on top of each other."""
105 | bsdf.select = False
106 | color_ramp_node.select = False
107 | attribute_node.select = False
108 | map_range_node.select = False
109 |
110 | color_ramp_node.location = (
111 | bsdf.location.x - color_ramp_node.width - 50,
112 | bsdf.location.y,
113 | )
114 |
115 | map_range_node.location = (
116 | color_ramp_node.location.x - map_range_node.width - 50,
117 | bsdf.location.y,
118 | )
119 | attribute_node.location = (
120 | map_range_node.location.x - attribute_node.width - 50,
121 | bsdf.location.y,
122 | )
123 |
124 |
125 | def switch_to_material_shading() -> None:
126 | """Switch to material shading if not already in material or rendered mode."""
127 | for area in bpy.context.screen.areas:
128 | if area.type == "VIEW_3D":
129 | for space in area.spaces:
130 | if (
131 | space.type == "VIEW_3D"
132 | and isinstance(space, bpy.types.SpaceView3D)
133 | and space.shading.type not in ["MATERIAL", "RENDERED"]
134 | ):
135 | space.shading.type = "MATERIAL"
136 | return
137 |
138 |
139 | def create_material(attr_name: str) -> bpy.types.Material:
140 | """Create a new material or get the existing one and activate the nodes."""
141 | if attr_name not in bpy.data.materials:
142 | material = bpy.data.materials.new(name=attr_name)
143 | material = bpy.data.materials[attr_name]
144 | material.use_nodes = True
145 | return material
146 |
147 |
148 | def apply_material(
149 | mesh: bpy.types.Mesh,
150 | tpms: Tpms,
151 | attr_name: str,
152 | colormap: str,
153 | n_colors: int,
154 | ) -> None:
155 | """Apply a material to the mesh based on the TPMS field."""
156 | switch_to_material_shading()
157 |
158 | material = create_material(attr_name)
159 |
160 | bsdf = material.node_tree.nodes["Principled BSDF"]
161 | attribute_node = shader_node_attribute(material, attr_name)
162 | map_range_node = shader_node_map_range(material, attr_name, tpms)
163 | color_ramp_node = shader_node_val_to_rgb(material, colormap, n_colors)
164 | material_output_node = material.node_tree.nodes["Material Output"]
165 |
166 | move_nodes(bsdf, attribute_node, map_range_node, color_ramp_node)
167 |
168 | link_nodes(
169 | material,
170 | bsdf,
171 | attribute_node,
172 | map_range_node,
173 | color_ramp_node,
174 | material_output_node,
175 | )
176 |
177 | bpy.data.objects[mesh.name].data.materials.append(material)
178 |
--------------------------------------------------------------------------------
/src/blender_tpms/properties.py:
--------------------------------------------------------------------------------
1 | """Properties module to define UI's properties."""
2 |
3 | import itertools
4 |
5 | import bpy
6 | from bpy.props import (
7 | BoolProperty,
8 | EnumProperty,
9 | FloatProperty,
10 | FloatVectorProperty,
11 | IntProperty,
12 | IntVectorProperty,
13 | StringProperty,
14 | )
15 |
16 | from blender_tpms.interface import get_all_surfaces
17 |
18 |
19 | class OperatorProperties(bpy.types.PropertyGroup):
20 | """Properties for the TPMS operator."""
21 |
22 | auto_smooth: BoolProperty(
23 | name="Auto Smooth",
24 | description="Auto smooth",
25 | default=True,
26 | options={"SKIP_SAVE"},
27 | )
28 |
29 | material: BoolProperty(
30 | name="Apply Material",
31 | description="Apply material",
32 | default=False,
33 | options={"SKIP_SAVE"},
34 | )
35 |
36 |
37 | class TpmsProperties(bpy.types.PropertyGroup):
38 | """Properties for the TPMS mesh."""
39 |
40 | part: EnumProperty(
41 | items=[
42 | ("sheet", "Sheet", "Sheet"),
43 | ("lower_skeletal", "Lower Skeletal", "Lower Skeletal"),
44 | ("upper_skeletal", "Upper Skeletal", "Upper Skeletal"),
45 | ("skeletals", "Skeletals", "Skeletals"),
46 | ("surface", "Surface", "Surface"),
47 | ],
48 | name="Part",
49 | description="Part of the TPMS to generate",
50 | options={"SKIP_SAVE"},
51 | )
52 |
53 | cell_size: FloatVectorProperty(
54 | name="Cell size",
55 | subtype="XYZ",
56 | description="Dimensions of a unit cell",
57 | default=(1, 1, 1),
58 | min=0,
59 | options={"ANIMATABLE", "SKIP_SAVE"},
60 | )
61 |
62 | repeat_cell: IntVectorProperty(
63 | name="Cell repetition",
64 | subtype="XYZ",
65 | description="Number of repetitions of a cell in each direction",
66 | default=(1, 1, 1),
67 | min=1,
68 | options={"ANIMATABLE", "SKIP_SAVE"},
69 | )
70 |
71 | surface: EnumProperty(
72 | items=get_all_surfaces(),
73 | name="Surface",
74 | description="Tpms surface",
75 | default="gyroid",
76 | options={"SKIP_SAVE"},
77 | )
78 |
79 | swap: EnumProperty(
80 | name="Swap axes",
81 | description="Swap axes",
82 | default="XYZ",
83 | items=[3 * ("".join(xyz),) for xyz in itertools.permutations("XYZ")],
84 | options={"SKIP_SAVE"},
85 | )
86 |
87 | offset: FloatProperty(
88 | name="Offset",
89 | description="Thickness of TPMS",
90 | default=0.3,
91 | min=0.01,
92 | options={"ANIMATABLE", "SKIP_SAVE"},
93 | )
94 |
95 | phase_shift: FloatVectorProperty(
96 | name="Phase shift",
97 | subtype="XYZ",
98 | description="x = x + phi_x, y = y + phi_y, z = z + phi_z",
99 | default=(0, 0, 0),
100 | options={"ANIMATABLE", "SKIP_SAVE"},
101 | )
102 |
103 | resolution: IntProperty(
104 | name="Resolution",
105 | description="Resolution of one unit cell",
106 | default=10,
107 | soft_max=50,
108 | min=10,
109 | options={"ANIMATABLE", "SKIP_SAVE"},
110 | )
111 |
112 | density: StringProperty(
113 | name="Relative density",
114 | description="Relative density of the geometry",
115 | )
116 |
117 |
118 | class CylindricalTpmsProperties(bpy.types.PropertyGroup):
119 | """Properties for the cylindrical TPMS mesh."""
120 |
121 | radius: FloatProperty(
122 | name="Radius",
123 | description="Radius of the cylinder",
124 | default=1,
125 | min=0.5,
126 | options={"ANIMATABLE", "SKIP_SAVE"},
127 | )
128 |
129 |
130 | class SphericalTpmsProperties(bpy.types.PropertyGroup):
131 | """Properties for the spherical TPMS mesh."""
132 |
133 | radius: FloatProperty(
134 | name="Radius",
135 | description="Radius of the sphere",
136 | default=1,
137 | min=0.5,
138 | options={"ANIMATABLE", "SKIP_SAVE"},
139 | )
140 |
141 |
142 | # class TpmsGradingProperties(bpy.types.PropertyGroup):
143 | # surface_grading: StringProperty(
144 | # name="Surface grading",
145 | # description="Surface grading",
146 | # default="sin(x) * cos(y) + sin(y) * cos(z) + sin(z) * cos(x)",
147 | # )
148 |
149 | # offset_grading: StringProperty(
150 | # name="Offset grading",
151 | # description="Offset grading",
152 | # default="(b - a) * x + (a + b) / 2",
153 | # )
154 |
155 | # edges: FloatVectorProperty(
156 | # name="Edges (a, b)",
157 | # description="Min (a) and max (b) offset values",
158 | # size=2,
159 | # default=(0.3, 1.5),
160 | # min=0.01,
161 | # options={'ANIMATABLE'},
162 | # )
163 |
--------------------------------------------------------------------------------
/src/blender_tpms/tpms/__init__.py:
--------------------------------------------------------------------------------
1 | """Tpms subpackage to generate TPMS geometries using PyVista."""
2 |
3 | from . import surfaces
4 | from .tpms import CylindricalTpms, SphericalTpms, Tpms
5 |
6 | __all__ = ["CylindricalTpms", "SphericalTpms", "Tpms", "surfaces"]
7 |
--------------------------------------------------------------------------------
/src/blender_tpms/tpms/surfaces.py:
--------------------------------------------------------------------------------
1 | """Definition of the different TPMS surfaces."""
2 |
3 | import numpy as np
4 | from numpy import cos, pi, sin
5 |
6 |
7 | def gyroid(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
8 | """Gyroid surface."""
9 | return sin(x) * cos(y) + sin(y) * cos(z) + sin(z) * cos(x)
10 |
11 |
12 | def schwarzP(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
13 | """Primitive Schwarz surface."""
14 | return cos(x) + cos(y) + cos(z)
15 |
16 |
17 | def schwarzD(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
18 | """Diamond Schwarz surface."""
19 | a = sin(x) * sin(y) * sin(z)
20 | b = sin(x) * cos(y) * cos(z)
21 | c = cos(x) * sin(y) * cos(z)
22 | d = cos(x) * cos(y) * sin(z)
23 | return a + b + c + d
24 |
25 |
26 | def neovius(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
27 | """Neovius surface."""
28 | a = 3 * cos(x) + cos(y) + cos(z)
29 | b = 4 * cos(x) * cos(y) * cos(z)
30 |
31 | return a + b
32 |
33 |
34 | def schoenIWP(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
35 | """Schoen's IWP surface."""
36 | a = 2 * (cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x))
37 | b = cos(2 * x) + cos(2 * y) + cos(2 * z)
38 |
39 | return a - b
40 |
41 |
42 | def schoenFRD(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
43 | """Schoen's FRD surface."""
44 | a = 4 * cos(x) * cos(y) * cos(z)
45 | b = cos(2 * x) * cos(2 * y) + cos(2 * y) * cos(2 * z) + cos(2 * z) * cos(2 * x)
46 | return a - b
47 |
48 |
49 | def fischerKochS(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
50 | """Fischer-Koch surface."""
51 | a = cos(2 * x) * sin(y) * cos(z)
52 | b = cos(x) * cos(2 * y) * sin(z)
53 | c = sin(x) * cos(y) * cos(2 * z)
54 |
55 | return a + b + c
56 |
57 |
58 | def pmy(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
59 | """Primitive My surface."""
60 | a = 2 * cos(x) * cos(y) * cos(z)
61 | b = sin(2 * x) * sin(y)
62 | c = sin(x) * sin(2 * z)
63 | d = sin(2 * y) * sin(z)
64 |
65 | return a + b + c + d
66 |
67 |
68 | def honeycomb(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
69 | """Honeycomb surface."""
70 | return sin(x) * cos(y + pi / 2.0) + sin(y + pi / 2.0) + cos(z)
71 |
72 |
73 | def lidinoid(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
74 | """Lidinoid surface."""
75 | return (
76 | 0.5
77 | * (
78 | sin(2 * x) * cos(y) * sin(z)
79 | + sin(2 * y) * cos(z) * sin(x)
80 | + sin(2 * z) * cos(x) * sin(y)
81 | )
82 | - 0.5
83 | * (cos(2 * x) * cos(2 * y) + cos(2 * y) * cos(2 * z) + cos(2 * z) * cos(2 * x))
84 | + 0.3
85 | )
86 |
87 |
88 | def split_p(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
89 | """Split P surface."""
90 | return (
91 | 1.1
92 | * (
93 | sin(2 * x) * cos(y) * sin(z)
94 | + sin(2 * y) * cos(z) * sin(x)
95 | + sin(2 * z) * cos(x) * sin(y)
96 | )
97 | - 0.2
98 | * (cos(2 * x) * cos(2 * y) + cos(2 * y) * cos(2 * z) + cos(2 * z) * cos(2 * x))
99 | - 0.4 * (cos(2 * x) + cos(2 * y) + cos(2 * z))
100 | )
101 |
102 |
103 | def honeycomb_gyroid(x: np.ndarray, y: np.ndarray, _: np.ndarray) -> np.ndarray:
104 | """Honeycomb gyroid surface."""
105 | return sin(x) * cos(y) + sin(y) + cos(x)
106 |
107 |
108 | def honeycomb_primitive(x: np.ndarray, y: np.ndarray, _: np.ndarray) -> np.ndarray:
109 | """Honeycomb primitive surface."""
110 | return cos(x) + cos(y)
111 |
112 |
113 | def honeycomb_diamond(x: np.ndarray, y: np.ndarray, _: np.ndarray) -> np.ndarray:
114 | """Honeycomb diamond surface."""
115 | return cos(x) * cos(y) + sin(x) * sin(y) + sin(x) * cos(y) + cos(x) * sin(y)
116 |
117 |
118 | def honeycomb_I(x: np.ndarray, y: np.ndarray, _: np.ndarray) -> np.ndarray:
119 | """Honeycomb I surface."""
120 | return cos(x) * cos(y) + cos(y) + cos(x)
121 |
122 |
123 | def honeycomb_L(x: np.ndarray, y: np.ndarray, _: np.ndarray) -> np.ndarray:
124 | """Honeycomb L surface."""
125 | return 1.1 * (sin(2 * x) * cos(y) + sin(2 * y) * sin(x) + cos(x) * sin(y)) - (
126 | cos(2 * x) * cos(2 * y) + cos(2 * y) + cos(2 * x)
127 | )
128 |
129 |
130 | def SC(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
131 | """Schwarz's surface."""
132 | return (
133 | 2 * (cos(x) + cos(y) + cos(z))
134 | + cos(x) * cos(y)
135 | + cos(y) * cos(z)
136 | + cos(z) * cos(x)
137 | )
138 |
139 |
140 | def I(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
141 | """I surface."""
142 | return cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x)
143 |
144 |
145 | def P(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
146 | """P surface."""
147 | return sin(x) + sin(y) + sin(z)
148 |
149 |
150 | def P_W(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
151 | """P_W surface."""
152 | a = 4 * (cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x))
153 | b = 3 * cos(x) * cos(y) * cos(z)
154 | return a - b
155 |
156 |
157 | def double_gyroid(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
158 | """Double gyroid surface."""
159 | return 2.75 * (
160 | sin(2 * x) * sin(z) * cos(y)
161 | + sin(2 * y) * sin(x) * cos(z)
162 | + sin(2 * z) * sin(y) * cos(x)
163 | ) - (cos(2 * x) * cos(2 * y) + cos(2 * y) * cos(2 * z) + cos(2 * z) * cos(2 * x))
164 |
165 |
166 | def Gprime(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
167 | """G' surface."""
168 | return (
169 | 5
170 | * (
171 | sin(2 * x) * sin(z) * cos(y)
172 | + sin(2 * y) * sin(x) * cos(z)
173 | + sin(2 * z) * sin(y) * cos(x)
174 | )
175 | + cos(2 * x) * cos(2 * y)
176 | + cos(2 * y) * cos(2 * z)
177 | + cos(2 * z) * cos(2 * x)
178 | )
179 |
180 |
181 | def double_diamond(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
182 | """Double diamond surface."""
183 | return (
184 | sin(2 * x) * sin(2 * y)
185 | + sin(2 * y) * sin(2 * z)
186 | + sin(2 * x) * sin(2 * z)
187 | + cos(2 * x) * cos(2 * y) * cos(2 * z)
188 | )
189 |
190 |
191 | def Dprime(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
192 | """D' surface."""
193 | return (
194 | sin(x) * sin(y) * sin(z)
195 | + cos(x) * cos(y) * cos(z)
196 | - (cos(2 * x) * cos(2 * y) + cos(2 * y) * cos(2 * z) + cos(2 * z) * cos(2 * x))
197 | - 0.4
198 | )
199 |
200 |
201 | def doubleP(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
202 | """Double P surface."""
203 | return 0.5 * (cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x)) + 0.2 * (
204 | cos(2 * x) + cos(2 * y) + cos(2 * z)
205 | )
206 |
207 |
208 | def OCTO(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
209 | """Octo surface."""
210 | return (
211 | 4 * (cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x))
212 | - 2.8 * cos(x) * cos(y) * cos(z)
213 | + (cos(x) + cos(y) + cos(z))
214 | + 1.5
215 | )
216 |
217 |
218 | def PN(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
219 | """PN surface."""
220 | return (
221 | 0.6 * (cos(x) * cos(y) * cos(z))
222 | + 0.4 * (cos(x) + cos(y) + cos(z))
223 | + 0.2 * (cos(2 * x) * cos(2 * y) * cos(2 * z))
224 | + 0.2 * (cos(2 * x) + cos(2 * y) + cos(2 * z))
225 | + 0.1 * (cos(3 * x) + cos(3 * y) + cos(3 * z))
226 | + 0.2 * (cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x))
227 | )
228 |
229 |
230 | def KP(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
231 | """KP surface."""
232 | return (
233 | 0.6 * (cos(x) + cos(y) + cos(z))
234 | + 0.7 * (cos(x) * cos(y) + cos(y) * cos(z) + cos(z) * cos(x))
235 | - 0.9 * (cos(2 * x) * cos(2 * y) * cos(2 * z))
236 | + 0.4
237 | )
238 |
239 |
240 | def FRD(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
241 | """FRD surface."""
242 | return (
243 | 8 * cos(x) * cos(y) * cos(z)
244 | + cos(2 * x) * cos(2 * y) * cos(2 * z)
245 | - cos(2 * x) * cos(2 * y)
246 | + cos(2 * y) * cos(2 * z)
247 | + cos(2 * z) * cos(2 * x)
248 | )
249 |
250 |
251 | def splitP(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
252 | """Split P surface."""
253 | return (
254 | 1.1
255 | * (
256 | sin(2 * x) * sin(z) * cos(y)
257 | + sin(2 * y) * sin(x) * cos(z)
258 | + sin(2 * z) * sin(y) * cos(x)
259 | )
260 | - 0.2
261 | * (cos(2 * x) * cos(2 * y) + cos(2 * y) * cos(2 * z) + cos(2 * z) * cos(2 * x))
262 | - 0.4 * (cos(x) + cos(y) + cos(z))
263 | )
264 |
--------------------------------------------------------------------------------
/src/blender_tpms/tpms/tpms.py:
--------------------------------------------------------------------------------
1 | """TPMS geometry generation."""
2 |
3 | from __future__ import annotations
4 |
5 | import itertools
6 | from typing import Callable, Sequence
7 |
8 | import numpy as np
9 | import pyvista as pv
10 |
11 | from blender_tpms.tpms import surfaces
12 |
13 | Field = Callable[[np.ndarray, np.ndarray, np.ndarray], np.ndarray]
14 |
15 | _3D = 3
16 |
17 |
18 | class Tpms:
19 | """Triply periodic minimal surface geometry."""
20 |
21 | def __init__(
22 | self,
23 | part: str = "sheet",
24 | surface: str = "gyroid",
25 | swap: str = "XYZ",
26 | cell_size: float | Sequence[float] | np.ndarray = 1.0,
27 | repeat_cell: int | Sequence[int] | np.ndarray = 1,
28 | resolution: int = 20,
29 | offset: float | Field = 0.0,
30 | phase_shift: float | Sequence[float] | np.ndarray = (0.0, 0.0, 0.0),
31 | ) -> None:
32 | """Create a TPMS geometry."""
33 | if swap not in map("".join, itertools.permutations("XYZ")):
34 | err_msg = "swap must be a permutation of 'XYZ'"
35 | raise ValueError(err_msg)
36 |
37 | self._init_cell_parameters(cell_size, repeat_cell)
38 |
39 | self.part = part
40 | self.surface_function = getattr(surfaces, surface)
41 | self.swap = swap
42 |
43 | self.resolution = resolution
44 | self.offset = offset
45 | self.phase_shift = np.array(phase_shift)
46 |
47 | self.grid: pv.StructuredGrid
48 | self._vtk_mesh = None
49 | self._relative_density = None
50 | self._sheet = None
51 | self._lower_skeletal = None
52 | self._upper_skeletal = None
53 | self._surface = None
54 | self._skeletals = None
55 |
56 | self._compute_tpms_field()
57 |
58 | def _init_cell_parameters(
59 | self,
60 | cell_size: float | Sequence[float] | np.ndarray,
61 | repeat_cell: int | Sequence[int] | np.ndarray,
62 | ) -> None:
63 | """Initialize the cell size and the number of repetitions of the cell."""
64 | if isinstance(cell_size, (float, int)):
65 | self.cell_size = np.array([cell_size, cell_size, cell_size])
66 | elif len(cell_size) == _3D:
67 | self.cell_size = np.array(cell_size)
68 | else:
69 | err_msg = "cell_size must be a float or a sequence of 3 floats"
70 | raise ValueError(err_msg)
71 |
72 | if isinstance(repeat_cell, int):
73 | self.repeat_cell = np.array([repeat_cell, repeat_cell, repeat_cell])
74 | elif len(repeat_cell) == _3D:
75 | self.repeat_cell = np.array(repeat_cell)
76 | else:
77 | err_msg = "repeat_cell must be an int or a sequence of 3 ints"
78 | raise ValueError(err_msg)
79 |
80 | def vtk_sheet(self) -> pv.UnstructuredGrid:
81 | """Sheet surface of the TPMS geometry."""
82 | return self.grid.clip_scalar(scalars="upper_surface").clip_scalar(
83 | scalars="lower_surface",
84 | invert=False,
85 | )
86 |
87 | def vtk_upper_skeletal(self) -> pv.UnstructuredGrid:
88 | """Upper skeletal surface of the TPMS geometry."""
89 | return self.grid.clip_scalar(scalars="upper_surface", invert=False)
90 |
91 | def vtk_lower_skeletal(self) -> pv.UnstructuredGrid:
92 | """Lower skeletal surface of the TPMS geometry."""
93 | return self.grid.clip_scalar(scalars="lower_surface")
94 |
95 | @property
96 | def sheet(self) -> pv.PolyData:
97 | """Sheet surface of the TPMS geometry."""
98 | if self._sheet is not None:
99 | return self._sheet
100 | self._sheet = self.vtk_sheet().extract_surface().clean().triangulate()
101 | return self._sheet
102 |
103 | @property
104 | def lower_skeletal(self) -> pv.PolyData:
105 | """Lower skeletal surface of the TPMS geometry."""
106 | if self._lower_skeletal is not None:
107 | return self._lower_skeletal
108 | self._lower_skeletal = (
109 | self.vtk_lower_skeletal().extract_surface().clean().triangulate()
110 | )
111 | return self._lower_skeletal
112 |
113 | @property
114 | def upper_skeletal(self) -> pv.PolyData:
115 | """Upper skeletal surface of the TPMS geometry."""
116 | if self._upper_skeletal is not None:
117 | return self._upper_skeletal
118 | self._upper_skeletal = (
119 | self.vtk_upper_skeletal().extract_surface().clean().triangulate()
120 | )
121 | return self._upper_skeletal
122 |
123 | @property
124 | def skeletals(self) -> tuple[pv.PolyData, pv.PolyData]:
125 | """Lower and upper skeletal surfaces of the TPMS geometry."""
126 | if self._skeletals is not None:
127 | return self._skeletals
128 | self._skeletals = self.lower_skeletal + self.upper_skeletal
129 | return self._skeletals
130 |
131 | @property
132 | def surface(self) -> pv.PolyData:
133 | """Surface of the TPMS geometry."""
134 | if self._surface is not None:
135 | return self._surface
136 | self._surface = self.grid.contour(
137 | isosurfaces=[0.0],
138 | scalars="surface",
139 | ).extract_surface()
140 | return self._surface
141 |
142 | @property
143 | def vtk_mesh(self) -> pv.PolyData:
144 | """VTK mesh of the TPMS geometry."""
145 | if self._vtk_mesh is not None:
146 | return self._vtk_mesh
147 |
148 | self._compute_tpms_field()
149 |
150 | return getattr(self, self.part)
151 |
152 | @property
153 | def relative_density(self) -> float:
154 | """Relative density of the geometry."""
155 | if self._relative_density is not None:
156 | return self._relative_density
157 | grid_volume = np.prod(self.cell_size) * np.prod(self.repeat_cell)
158 | self._relative_density = self.vtk_mesh.volume / grid_volume
159 | return self._relative_density
160 |
161 | def _create_grid(
162 | self,
163 | x: np.ndarray,
164 | y: np.ndarray,
165 | z: np.ndarray,
166 | ) -> pv.StructuredGrid:
167 | return pv.StructuredGrid(x, y, z)
168 |
169 | def _compute_tpms_field(self) -> None:
170 | linspaces = [
171 | np.linspace(
172 | -0.5 * cell_size_axis * repeat_cell_axis,
173 | 0.5 * cell_size_axis * repeat_cell_axis,
174 | self.resolution * repeat_cell_axis,
175 | )
176 | for repeat_cell_axis, cell_size_axis in zip(
177 | self.repeat_cell,
178 | self.cell_size,
179 | )
180 | ]
181 |
182 | x, y, z = np.meshgrid(*linspaces)
183 |
184 | self.grid = self._create_grid(x, y, z)
185 |
186 | k_x, k_y, k_z = 2.0 * np.pi / self.cell_size
187 | xyz = {
188 | "X": k_x * (x + self.phase_shift[0]),
189 | "Y": k_y * (y + self.phase_shift[1]),
190 | "Z": k_z * (z + self.phase_shift[2]),
191 | }
192 | tpms_field = self.surface_function(*(xyz[axis] for axis in self.swap))
193 |
194 | self.grid["surface"] = tpms_field.ravel(order="F")
195 | self._update_offset(self.offset)
196 |
197 | def _update_offset(self, offset: float | Callable) -> None:
198 | if isinstance(offset, float):
199 | self.offset = offset
200 | elif isinstance(offset, Callable):
201 | self.offset = offset(self.grid.x, self.grid.y, self.grid.z).ravel("F")
202 |
203 | self.grid["lower_surface"] = self.grid["surface"] + 0.5 * self.offset
204 | self.grid["upper_surface"] = self.grid["surface"] - 0.5 * self.offset
205 |
206 |
207 | class CylindricalTpms(Tpms):
208 | """Cylindrical TPMS geometry."""
209 |
210 | def __init__(
211 | self,
212 | radius: float = 1.0,
213 | cell_size: float | Sequence[float] | np.ndarray = 1.0,
214 | repeat_cell: int | Sequence[int] | np.ndarray = 1,
215 | **kwargs,
216 | ) -> None:
217 | """Create a cylindrical TPMS geometry."""
218 | self._init_cell_parameters(cell_size, repeat_cell)
219 |
220 | self.cylinder_radius = radius
221 |
222 | unit_theta = self.cell_size[1] / radius
223 | n_repeat_to_full_circle = int(round(2 * np.pi / unit_theta))
224 | self.unit_theta = 2 * np.pi / n_repeat_to_full_circle
225 | if self.repeat_cell[1] == 0 or self.repeat_cell[1] > n_repeat_to_full_circle:
226 | self.repeat_cell[1] = n_repeat_to_full_circle
227 |
228 | super().__init__(
229 | cell_size=self.cell_size,
230 | repeat_cell=self.repeat_cell,
231 | **kwargs,
232 | )
233 |
234 | @property
235 | def relative_density(self) -> float:
236 | """Relative density of the geometry."""
237 | if self._relative_density is not None:
238 | return self._relative_density
239 | grid_volume = (
240 | self.cylinder_radius
241 | * self.cell_size[0]
242 | * self.unit_theta
243 | * self.cell_size[2]
244 | * np.prod(self.repeat_cell)
245 | )
246 | self._relative_density = self.vtk_mesh.volume / grid_volume
247 | return self._relative_density
248 |
249 | def _create_grid(
250 | self,
251 | x: np.ndarray,
252 | y: np.ndarray,
253 | z: np.ndarray,
254 | ) -> pv.StructuredGrid:
255 | rho = x + self.cylinder_radius
256 | theta = y * self.unit_theta
257 |
258 | return pv.StructuredGrid(rho * np.cos(theta), rho * np.sin(theta), z)
259 |
260 |
261 | class SphericalTpms(Tpms):
262 | """Spherical TPMS geometry."""
263 |
264 | def __init__(
265 | self,
266 | radius: float = 1.0,
267 | cell_size: float | Sequence[float] | np.ndarray = 1.0,
268 | repeat_cell: int | Sequence[int] | np.ndarray = 1,
269 | **kwargs,
270 | ) -> None:
271 | """Create a spherical TPMS geometry."""
272 | self._init_cell_parameters(cell_size, repeat_cell)
273 |
274 | self.sphere_radius = radius
275 |
276 | unit_theta = self.cell_size[1] / radius
277 | n_repeat_theta_to_join = int(np.pi / unit_theta)
278 | self.unit_theta = np.pi / n_repeat_theta_to_join
279 | if self.repeat_cell[1] == 0 or self.repeat_cell[1] > n_repeat_theta_to_join:
280 | self.repeat_cell[1] = n_repeat_theta_to_join
281 |
282 | unit_phi = self.cell_size[2] / radius
283 | n_repeat_phi_to_join = int(2 * np.pi / unit_phi)
284 | self.unit_phi = 2 * np.pi / n_repeat_phi_to_join
285 | if self.repeat_cell[2] == 0 or self.repeat_cell[2] > n_repeat_phi_to_join:
286 | self.repeat_cell[2] = n_repeat_phi_to_join
287 |
288 | super().__init__(
289 | cell_size=self.cell_size,
290 | repeat_cell=self.repeat_cell,
291 | **kwargs,
292 | )
293 |
294 | @property
295 | def relative_density(self) -> float:
296 | """Relative density of the geometry."""
297 | if self._relative_density is not None:
298 | return self._relative_density
299 | self._relative_density = self.vtk_mesh.volume / abs(self.grid.volume)
300 | return self._relative_density
301 |
302 | def _create_grid(
303 | self,
304 | x: np.ndarray,
305 | y: np.ndarray,
306 | z: np.ndarray,
307 | ) -> pv.StructuredGrid:
308 | rho = x + self.sphere_radius
309 | theta = y * self.unit_theta + np.pi / 2.0
310 | phi = z * self.unit_phi
311 |
312 | return pv.StructuredGrid(
313 | rho * np.sin(theta) * np.cos(phi),
314 | rho * np.sin(theta) * np.sin(phi),
315 | rho * np.cos(theta),
316 | )
317 |
318 |
319 | # class GradedTpms(Tpms):
320 | # def __init__(
321 | # self,
322 | # part,
323 | # surface,
324 | # swap,
325 | # cell_size,
326 | # repeat_cell,
327 | # resolution,
328 | # offset,
329 | # phase_shift,
330 | # offset_grading,
331 | # edges,
332 | # ):
333 | # super().__init__(
334 | # part,
335 | # surface,
336 | # swap,
337 | # cell_size,
338 | # repeat_cell,
339 | # resolution,
340 | # offset,
341 | # phase_shift,
342 | # )
343 | # self.offset_grading = offset_grading
344 | # self.edges = edges
345 |
346 |
347 | # def _create_grid(self, x, y, z):
348 | # a = self.edges[0]
349 | # b = self.edges[1]
350 | # self.offset = literal_eval(self.offset_grading)
351 | # return pv.StructuredGrid(x, y, z)
352 |
--------------------------------------------------------------------------------
/src/blender_tpms/ui.py:
--------------------------------------------------------------------------------
1 | """Module for the user interface of the TPMS add-on."""
2 |
3 | from __future__ import annotations
4 |
5 | import bpy
6 | from bpy_extras.object_utils import AddObjectHelper, object_data_add
7 |
8 | from blender_tpms.interface import polydata_to_mesh
9 | from blender_tpms.material import apply_material
10 |
11 | # GradedTpms,
12 | from blender_tpms.properties import (
13 | CylindricalTpmsProperties,
14 | # TpmsGradingProperties,
15 | OperatorProperties,
16 | SphericalTpmsProperties,
17 | TpmsProperties,
18 | )
19 | from blender_tpms.tpms import (
20 | CylindricalTpms,
21 | SphericalTpms,
22 | Tpms,
23 | )
24 |
25 |
26 | def set_shade_auto_smooth() -> None:
27 | """Set the auto smooth shading to the active object."""
28 | angle = 0.523599 # 30 degrees
29 | if bpy.app.version < (4, 1):
30 | bpy.ops.object.shade_smooth(use_auto_smooth=True, auto_smooth_angle=angle)
31 | else:
32 | bpy.ops.object.shade_smooth_by_angle(angle=angle, keep_sharp_edges=True)
33 |
34 |
35 | class OperatorTpms(
36 | bpy.types.Operator,
37 | OperatorProperties,
38 | AddObjectHelper,
39 | TpmsProperties,
40 | ):
41 | """Add a TPMS mesh."""
42 |
43 | bl_idname = "mesh.tpms_add"
44 | bl_label = "TPMS"
45 | bl_options = {"REGISTER", "UNDO"} # noqa: RUF012 (blender uses type hints for another purpose)
46 |
47 | def execute(self, context: bpy.types.Context) -> set[str]:
48 | """Execute the operator."""
49 | tpms = Tpms(
50 | part=self.part,
51 | surface=self.surface,
52 | swap=self.swap,
53 | cell_size=self.cell_size,
54 | repeat_cell=self.repeat_cell,
55 | resolution=self.resolution,
56 | offset=self.offset,
57 | phase_shift=self.phase_shift,
58 | )
59 |
60 | mesh = polydata_to_mesh(tpms.vtk_mesh)
61 |
62 | self.density = f"{tpms.relative_density:.1%}"
63 |
64 | # add the mesh as an object into the scene with this utility module
65 | object_data_add(context, mesh, operator=self)
66 |
67 | attr_name = "surface"
68 | mesh.attributes.new(attr_name, type="FLOAT", domain="POINT")
69 | mesh.attributes[attr_name].data.foreach_set("value", tpms.vtk_mesh[attr_name])
70 |
71 | if self.auto_smooth:
72 | set_shade_auto_smooth()
73 |
74 | if self.material:
75 | apply_material(
76 | mesh=mesh,
77 | tpms=tpms,
78 | attr_name=attr_name,
79 | colormap="coolwarm",
80 | n_colors=9,
81 | )
82 |
83 | return {"FINISHED"}
84 |
85 |
86 | class OperatorCylindricalTpms(
87 | bpy.types.Operator,
88 | OperatorProperties,
89 | AddObjectHelper,
90 | TpmsProperties,
91 | CylindricalTpmsProperties,
92 | ):
93 | """Add a Cylindrical TPMS mesh."""
94 |
95 | bl_idname = "mesh.cylindrical_tpms_add"
96 | bl_label = "Cylindrical TPMS"
97 | bl_options = {"REGISTER", "UNDO"} # noqa: RUF012 (blender uses type hints for another purpose)
98 |
99 | def execute(self, context: bpy.types.Context) -> set[str]:
100 | """Execute the operator."""
101 | tpms = CylindricalTpms(
102 | radius=self.radius,
103 | part=self.part,
104 | surface=self.surface,
105 | swap=self.swap,
106 | cell_size=self.cell_size,
107 | repeat_cell=self.repeat_cell,
108 | resolution=self.resolution,
109 | offset=self.offset,
110 | phase_shift=self.phase_shift,
111 | )
112 |
113 | mesh = polydata_to_mesh(tpms.vtk_mesh)
114 |
115 | self.density = f"{tpms.relative_density:.1%}"
116 |
117 | # add the mesh as an object into the scene with this utility module
118 | object_data_add(context, mesh, operator=self)
119 |
120 | attr_name = "surface"
121 | mesh.attributes.new(attr_name, type="FLOAT", domain="POINT")
122 | mesh.attributes[attr_name].data.foreach_set("value", tpms.vtk_mesh[attr_name])
123 |
124 | if self.auto_smooth:
125 | set_shade_auto_smooth()
126 |
127 | if self.material:
128 | apply_material(
129 | mesh=mesh,
130 | tpms=tpms,
131 | attr_name=attr_name,
132 | colormap="coolwarm",
133 | n_colors=9,
134 | )
135 |
136 | return {"FINISHED"}
137 |
138 |
139 | class OperatorSphericalTpms(
140 | bpy.types.Operator,
141 | OperatorProperties,
142 | AddObjectHelper,
143 | TpmsProperties,
144 | SphericalTpmsProperties,
145 | ):
146 | """Add a Spherical TPMS mesh."""
147 |
148 | bl_idname = "mesh.spherical_tpms_add"
149 | bl_label = "Spherical TPMS"
150 | bl_options = {"REGISTER", "UNDO"} # noqa: RUF012 (blender uses type hints for another purpose)
151 |
152 | def execute(self, context: bpy.types.Context) -> set[str]:
153 | """Execute the operator."""
154 | tpms = SphericalTpms(
155 | radius=self.radius,
156 | part=self.part,
157 | surface=self.surface,
158 | swap=self.swap,
159 | cell_size=self.cell_size,
160 | repeat_cell=self.repeat_cell,
161 | resolution=self.resolution,
162 | offset=self.offset,
163 | phase_shift=self.phase_shift,
164 | )
165 |
166 | mesh = polydata_to_mesh(tpms.vtk_mesh)
167 |
168 | self.density = f"{tpms.relative_density:.1%}"
169 |
170 | # add the mesh as an object into the scene with this utility module
171 | object_data_add(context, mesh, operator=self)
172 |
173 | attr_name = "surface"
174 | mesh.attributes.new(attr_name, type="FLOAT", domain="POINT")
175 | mesh.attributes[attr_name].data.foreach_set("value", tpms.vtk_mesh[attr_name])
176 |
177 | if self.auto_smooth:
178 | set_shade_auto_smooth()
179 |
180 | if self.material:
181 | apply_material(
182 | mesh=mesh,
183 | tpms=tpms,
184 | attr_name=attr_name,
185 | colormap="coolwarm",
186 | n_colors=9,
187 | )
188 |
189 | return {"FINISHED"}
190 |
191 |
192 | # class OperatorGradedTpms(
193 | # bpy.types.Operator,
194 | # OperatorProperties,
195 | # AddObjectHelper,
196 | # TpmsGradingProperties,
197 | # TpmsProperties,
198 | # ):
199 | # """Add a Graded TPMS mesh"""
200 |
201 | # bl_idname = "mesh.graded_tpms_add"
202 | # bl_label = "Graded TPMS"
203 | # bl_options = {"REGISTER", "UNDO"} # noqa: RUF012 (blender uses type hints for another purpose)
204 |
205 | # def execute(self, context):
206 | # tpms = GradedTpms(
207 | # self.part,
208 | # self.surface,
209 | # self.swap,
210 | # self.cell_size,
211 | # self.repeat_cell,
212 | # self.resolution,
213 | # self.offset,
214 | # self.phase_shift,
215 | # self.offset_grading,
216 | # self.edges,
217 | # )
218 |
219 | # mesh = polydata_to_mesh(tpms.vtk_mesh)
220 |
221 | # self.density = f"{tpms.relative_density:.1%}"
222 |
223 | # # add the mesh as an object into the scene with this utility module
224 | # object_data_add(context, mesh, operator=self)
225 |
226 | # attr_name = "surface"
227 | # mesh.attributes.new(attr_name, type="FLOAT", domain="POINT")
228 | # mesh.attributes[attr_name].data.foreach_set("value", tpms.vtk_mesh[attr_name])
229 |
230 | # if self.auto_smooth:
231 | # set_shade_auto_smooth()
232 |
233 | # if self.material:
234 | # apply_material(
235 | # mesh=mesh,
236 | # tpms=tpms,
237 | # attr_name=attr_name,
238 | # colormap="coolwarm",
239 | # n_colors=9,
240 | # )
241 |
242 | # return {"FINISHED"}
243 |
244 |
245 | # class OperatorGradedCylindricalTpms(
246 | # bpy.types.Operator,
247 | # OperatorProperties,
248 | # AddObjectHelper,
249 | # TpmsGradingProperties,
250 | # TpmsProperties,
251 | # CylindricalTpmsProperties,
252 | # ):
253 | # """Add a Graded Cylindrical TPMS mesh"""
254 | # bl_idname = "mesh.cylindrical_graded_tpms_add"
255 | # bl_label = "Graded Cylindrical TPMS"
256 | # bl_options = {'REGISTER', 'UNDO'}
257 |
258 | # def execute(self, context):
259 | # return {'FINISHED'}
260 |
261 |
262 | def menu_func(self, _: bpy.types.Context) -> None:
263 | """Create the main submenu."""
264 | self.layout.menu("OBJECT_MT_tpms_submenu", icon="MESH_CUBE")
265 |
266 |
267 | class OBJECT_MT_tpms_submenu(bpy.types.Menu): # noqa: N801
268 | """Create the TPMS submenu."""
269 |
270 | bl_label = "TPMS"
271 | bl_idname = "OBJECT_MT_tpms_submenu"
272 |
273 | def draw(self, _: bpy.types.Context) -> None:
274 | """Draw the menu."""
275 | layout = self.layout
276 | layout.operator(OperatorTpms.bl_idname, icon="MESH_CUBE")
277 | layout.operator(OperatorCylindricalTpms.bl_idname, icon="MESH_CYLINDER")
278 | layout.operator(OperatorSphericalTpms.bl_idname, icon="MESH_UVSPHERE")
279 | # layout.operator(OperatorGradedTpms.bl_idname, icon='MESH_CUBE')
280 | # layout.operator(OperatorGradedCylindricalTpms.bl_idname, icon='MESH_CYLINDER')
281 |
282 |
283 | def register() -> None:
284 | """Register the UI elements."""
285 | bpy.utils.register_class(OBJECT_MT_tpms_submenu)
286 | bpy.utils.register_class(OperatorTpms)
287 | bpy.utils.register_class(OperatorCylindricalTpms)
288 | bpy.utils.register_class(OperatorSphericalTpms)
289 | # bpy.utils.register_class(OperatorGradedTpms)
290 | # bpy.utils.register_class(OperatorGradedCylindricalTpms)
291 | bpy.types.VIEW3D_MT_mesh_add.append(menu_func)
292 |
293 |
294 | def unregister() -> None:
295 | """Unregister the UI elements."""
296 | bpy.utils.unregister_class(OBJECT_MT_tpms_submenu)
297 | bpy.utils.unregister_class(OperatorTpms)
298 | bpy.utils.unregister_class(OperatorCylindricalTpms)
299 | bpy.utils.unregister_class(OperatorSphericalTpms)
300 | # bpy.utils.unregister_class(OperatorGradedTpms)
301 | # bpy.utils.unregister_class(OperatorGradedCylindricalTpms)
302 | bpy.types.VIEW3D_MT_mesh_add.remove(menu_func)
303 |
--------------------------------------------------------------------------------
/tests/test_interface.py:
--------------------------------------------------------------------------------
1 | import pyvista as pv
2 | from blender_tpms.interface import get_all_surfaces, polydata_to_mesh
3 |
4 | # ruff: noqa: S101
5 |
6 |
7 | def test_polydata_to_mesh() -> None:
8 | """Test polydata_to_mesh function."""
9 | polydata = pv.Cube()
10 | mesh = polydata_to_mesh(polydata, mesh_name="Box")
11 | assert mesh.name == "Box"
12 | assert len(mesh.vertices) == 8
13 | assert len(mesh.polygons) == 12
14 |
15 |
16 | def test_get_all_surfaces() -> None:
17 | """Test get_all_surfaces function."""
18 | surfaces = get_all_surfaces()
19 | assert len(surfaces) == 30
20 | for surface in surfaces:
21 | assert len(surface) == 3
22 | assert isinstance(surface[0], str)
23 | assert isinstance(surface[1], str)
24 | assert isinstance(surface[2], str)
25 | assert surface[0] == surface[1] == surface[2]
26 |
--------------------------------------------------------------------------------
/tests/test_operators.py:
--------------------------------------------------------------------------------
1 | import blender_tpms.tpms
2 | import bpy
3 | from blender_tpms.interface import polydata_to_mesh
4 | from blender_tpms.ui import apply_material, set_shade_auto_smooth
5 |
6 |
7 | def test_auto_smooth() -> None:
8 | tpms = blender_tpms.tpms.Tpms()
9 | mesh = polydata_to_mesh(tpms.sheet, mesh_name="Tpms")
10 |
11 | obj = bpy.data.objects.new(mesh.name, mesh)
12 | bpy.context.collection.objects.link(obj)
13 | bpy.context.view_layer.objects.active = obj
14 | obj.select_set(state=True)
15 |
16 | assert mesh.name == "Tpms"
17 | set_shade_auto_smooth()
18 |
19 |
20 | def test_apply_material() -> None:
21 | tpms = blender_tpms.tpms.Tpms()
22 | mesh = polydata_to_mesh(tpms.sheet, mesh_name="Tpms")
23 |
24 | obj = bpy.data.objects.new(mesh.name, mesh)
25 | bpy.context.collection.objects.link(obj)
26 | bpy.context.view_layer.objects.active = obj
27 | obj.select_set(state=True)
28 |
29 | apply_material(
30 | mesh=mesh,
31 | tpms=tpms,
32 | attr_name="surface",
33 | colormap="coolwarm",
34 | n_colors=9,
35 | )
36 |
--------------------------------------------------------------------------------
/tests/test_surfaces.py:
--------------------------------------------------------------------------------
1 | from inspect import getmembers, isfunction
2 | from typing import Callable
3 |
4 | import numpy as np
5 | import pytest
6 | from blender_tpms.tpms import surfaces
7 |
8 |
9 | @pytest.mark.parametrize(
10 | "surface_function",
11 | [func[1] for func in getmembers(surfaces, isfunction)],
12 | )
13 | def test_surfaces(surface_function: Callable) -> None:
14 | """Test all TPMS surfaces."""
15 | assert -np.inf < surface_function(0, 0, 0) < np.inf
16 |
--------------------------------------------------------------------------------
/tests/test_tpms.py:
--------------------------------------------------------------------------------
1 | from blender_tpms.tpms import CylindricalTpms, SphericalTpms, Tpms
2 |
3 |
4 | def test_tpms() -> None:
5 | tpms = Tpms()
6 | assert tpms is not None
7 | assert tpms.surface is not None
8 | assert tpms.sheet is not None
9 | assert tpms.lower_skeletal is not None
10 | assert tpms.upper_skeletal is not None
11 | assert tpms.skeletals is not None
12 | assert tpms.relative_density > 0
13 | assert tpms.vtk_sheet() is not None
14 | assert tpms.vtk_lower_skeletal() is not None
15 | assert tpms.vtk_upper_skeletal() is not None
16 |
17 |
18 | def test_cylindrical_tpms() -> None:
19 | tpms = CylindricalTpms()
20 |
21 | assert tpms.relative_density > 0
22 |
23 |
24 | def test_spherical_tpms() -> None:
25 | tpms = SphericalTpms()
26 |
27 | assert tpms.relative_density > 0
28 |
--------------------------------------------------------------------------------