├── .github
└── workflows
│ └── build-and-test.yml
├── .gitignore
├── LICENSE
├── README.md
├── __init__.py
├── assets
├── cylinder_gyroid_honeycomb.png
├── geo_nodes.png
├── lattice.blend
├── lattice.png
└── tpms.blend
├── pyproject.toml
├── src
└── blender_tpms
│ ├── __init__.py
│ ├── interface.py
│ ├── material.py
│ ├── properties.py
│ ├── tpms
│ ├── __init__.py
│ ├── surfaces.py
│ └── tpms.py
│ └── ui.py
└── tests
├── test_interface.py
├── test_operators.py
├── test_surfaces.py
└── test_tpms.py
/.github/workflows/build-and-test.yml:
--------------------------------------------------------------------------------
1 | name: Build and Test
2 |
3 | on:
4 | workflow_dispatch:
5 | pull_request:
6 | push:
7 | branches:
8 | - "*"
9 |
10 | schedule:
11 | - cron: "0 0 * * 0"
12 |
13 | jobs:
14 | build-and-test:
15 | runs-on: ${{ matrix.os }}
16 | strategy:
17 | fail-fast: false
18 | matrix:
19 | os: ["ubuntu-latest", "macos-latest", "windows-latest"]
20 | python-version: ["3.10", "3.11"]
21 |
22 | steps:
23 | - uses: actions/checkout@v4
24 |
25 | - uses: actions/setup-python@v5
26 | with:
27 | python-version: ${{ matrix.python-version }}
28 | cache: "pip"
29 |
30 | - name: Install
31 | run: |
32 | pip install uv
33 | uv pip install --system blender_tpms@. bpy pytest
34 |
35 | - name: Test
36 | run: pytest tests
37 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | .coverage
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 |
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # TPMS generator
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 | 
11 |
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 |
--------------------------------------------------------------------------------