COMPAS 2.1.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (468) hide show
  1. compas/__init__.py +274 -0
  2. compas/__main__.py +31 -0
  3. compas/_iotools.py +80 -0
  4. compas/_os.py +746 -0
  5. compas/colors/__init__.py +14 -0
  6. compas/colors/cmcrameri/acton.txt +256 -0
  7. compas/colors/cmcrameri/actonS.txt +100 -0
  8. compas/colors/cmcrameri/bam.txt +256 -0
  9. compas/colors/cmcrameri/bamO.txt +256 -0
  10. compas/colors/cmcrameri/bamako.txt +256 -0
  11. compas/colors/cmcrameri/bamakoS.txt +100 -0
  12. compas/colors/cmcrameri/batlow.txt +256 -0
  13. compas/colors/cmcrameri/batlowK.txt +256 -0
  14. compas/colors/cmcrameri/batlowS.txt +100 -0
  15. compas/colors/cmcrameri/batlowW.txt +256 -0
  16. compas/colors/cmcrameri/berlin.txt +256 -0
  17. compas/colors/cmcrameri/bilbao.txt +256 -0
  18. compas/colors/cmcrameri/bilbaoS.txt +100 -0
  19. compas/colors/cmcrameri/broc.txt +256 -0
  20. compas/colors/cmcrameri/brocO.txt +256 -0
  21. compas/colors/cmcrameri/buda.txt +256 -0
  22. compas/colors/cmcrameri/budaS.txt +100 -0
  23. compas/colors/cmcrameri/bukavu.txt +256 -0
  24. compas/colors/cmcrameri/cork.txt +256 -0
  25. compas/colors/cmcrameri/corkO.txt +256 -0
  26. compas/colors/cmcrameri/davos.txt +256 -0
  27. compas/colors/cmcrameri/davosS.txt +100 -0
  28. compas/colors/cmcrameri/devon.txt +256 -0
  29. compas/colors/cmcrameri/devonS.txt +100 -0
  30. compas/colors/cmcrameri/fes.txt +256 -0
  31. compas/colors/cmcrameri/grayC.txt +256 -0
  32. compas/colors/cmcrameri/grayCS.txt +100 -0
  33. compas/colors/cmcrameri/hawaii.txt +256 -0
  34. compas/colors/cmcrameri/hawaiiS.txt +100 -0
  35. compas/colors/cmcrameri/imola.txt +256 -0
  36. compas/colors/cmcrameri/imolaS.txt +100 -0
  37. compas/colors/cmcrameri/lajolla.txt +256 -0
  38. compas/colors/cmcrameri/lajollaS.txt +100 -0
  39. compas/colors/cmcrameri/lapaz.txt +256 -0
  40. compas/colors/cmcrameri/lapazS.txt +100 -0
  41. compas/colors/cmcrameri/lisbon.txt +256 -0
  42. compas/colors/cmcrameri/nuuk.txt +256 -0
  43. compas/colors/cmcrameri/nuukS.txt +100 -0
  44. compas/colors/cmcrameri/oleron.txt +256 -0
  45. compas/colors/cmcrameri/oslo.txt +256 -0
  46. compas/colors/cmcrameri/osloS.txt +100 -0
  47. compas/colors/cmcrameri/roma.txt +256 -0
  48. compas/colors/cmcrameri/romaO.txt +256 -0
  49. compas/colors/cmcrameri/tofino.txt +256 -0
  50. compas/colors/cmcrameri/tokyo.txt +256 -0
  51. compas/colors/cmcrameri/tokyoS.txt +100 -0
  52. compas/colors/cmcrameri/turku.txt +256 -0
  53. compas/colors/cmcrameri/turkuS.txt +100 -0
  54. compas/colors/cmcrameri/vanimo.txt +256 -0
  55. compas/colors/cmcrameri/vik.txt +256 -0
  56. compas/colors/cmcrameri/vikO.txt +256 -0
  57. compas/colors/color.py +1118 -0
  58. compas/colors/colordict.py +103 -0
  59. compas/colors/colormap.py +306 -0
  60. compas/colors/html_colors.py +149 -0
  61. compas/colors/mpl_colormap.py +1064 -0
  62. compas/data/__init__.py +31 -0
  63. compas/data/coercion.py +71 -0
  64. compas/data/conftest.py +10 -0
  65. compas/data/data.py +342 -0
  66. compas/data/encoders.py +240 -0
  67. compas/data/exceptions.py +2 -0
  68. compas/data/json.py +240 -0
  69. compas/data/samples/boxes.obj +250 -0
  70. compas/data/samples/butt_model.obj +2829 -0
  71. compas/data/samples/cone.stl +0 -0
  72. compas/data/samples/cube.off +16 -0
  73. compas/data/samples/cube_ascii.stl +56114 -0
  74. compas/data/samples/cube_binary.stl +0 -0
  75. compas/data/samples/cube_binary_2.stl +0 -0
  76. compas/data/samples/doosabin.json +1 -0
  77. compas/data/samples/faces.obj +63 -0
  78. compas/data/samples/faces_big.obj +9663 -0
  79. compas/data/samples/faces_reversed.obj +63 -0
  80. compas/data/samples/fink.obj +135 -0
  81. compas/data/samples/grid_irregular.obj +303 -0
  82. compas/data/samples/hypar.obj +148 -0
  83. compas/data/samples/lines.json +1 -0
  84. compas/data/samples/lines.obj +282 -0
  85. compas/data/samples/lines_big.obj +40322 -0
  86. compas/data/samples/lines_bigger.obj +161282 -0
  87. compas/data/samples/lines_noleaves.obj +422 -0
  88. compas/data/samples/mesh.obj +874 -0
  89. compas/data/samples/mesh_100_faces.json +1893 -0
  90. compas/data/samples/mesh_110_faces.json +2081 -0
  91. compas/data/samples/open_edges.obj +424 -0
  92. compas/data/samples/point.json +1 -0
  93. compas/data/samples/quadmesh.obj +183 -0
  94. compas/data/samples/quadmesh_planar.obj +181 -0
  95. compas/data/samples/saddle.obj +314 -0
  96. compas/data/samples/spline.obj +72 -0
  97. compas/data/samples/tubemesh.json +1 -0
  98. compas/data/samples/tubemesh.obj +378 -0
  99. compas/data/samples/tubemesh.off +374 -0
  100. compas/data/samples/tubemesh.ply +551 -0
  101. compas/data/schema.py +137 -0
  102. compas/data/validators.py +243 -0
  103. compas/datastructures/__init__.py +75 -0
  104. compas/datastructures/_mutablemapping.py +148 -0
  105. compas/datastructures/assembly/__init__.py +0 -0
  106. compas/datastructures/assembly/assembly.py +234 -0
  107. compas/datastructures/assembly/exceptions.py +6 -0
  108. compas/datastructures/assembly/part.py +228 -0
  109. compas/datastructures/attributes.py +85 -0
  110. compas/datastructures/cell_network/__init__.py +0 -0
  111. compas/datastructures/cell_network/cell_network.py +4190 -0
  112. compas/datastructures/datastructure.py +309 -0
  113. compas/datastructures/graph/__init__.py +0 -0
  114. compas/datastructures/graph/duality.py +197 -0
  115. compas/datastructures/graph/graph.py +2478 -0
  116. compas/datastructures/graph/operations/__init__.py +0 -0
  117. compas/datastructures/graph/operations/join.py +124 -0
  118. compas/datastructures/graph/operations/split.py +63 -0
  119. compas/datastructures/graph/planarity.py +292 -0
  120. compas/datastructures/graph/smoothing.py +59 -0
  121. compas/datastructures/mesh/__init__.py +0 -0
  122. compas/datastructures/mesh/conway.py +553 -0
  123. compas/datastructures/mesh/duality.py +104 -0
  124. compas/datastructures/mesh/mesh.py +5103 -0
  125. compas/datastructures/mesh/operations/__init__.py +0 -0
  126. compas/datastructures/mesh/operations/collapse.py +350 -0
  127. compas/datastructures/mesh/operations/extrude.py +0 -0
  128. compas/datastructures/mesh/operations/insert.py +120 -0
  129. compas/datastructures/mesh/operations/merge.py +83 -0
  130. compas/datastructures/mesh/operations/split.py +263 -0
  131. compas/datastructures/mesh/operations/substitute.py +37 -0
  132. compas/datastructures/mesh/operations/swap.py +62 -0
  133. compas/datastructures/mesh/operations/weld.py +107 -0
  134. compas/datastructures/mesh/remesh.py +234 -0
  135. compas/datastructures/mesh/slice.py +170 -0
  136. compas/datastructures/mesh/smoothing.py +187 -0
  137. compas/datastructures/mesh/subdivision.py +754 -0
  138. compas/datastructures/tree/__init__.py +0 -0
  139. compas/datastructures/tree/tree.py +504 -0
  140. compas/datastructures/volmesh/__init__.py +0 -0
  141. compas/datastructures/volmesh/volmesh.py +4203 -0
  142. compas/files/__init__.py +27 -0
  143. compas/files/_xml/__init__.py +0 -0
  144. compas/files/_xml/xml_cli.py +213 -0
  145. compas/files/_xml/xml_cpython.py +32 -0
  146. compas/files/_xml/xml_pre_38.py +58 -0
  147. compas/files/_xml/xml_shared.py +40 -0
  148. compas/files/gltf/__init__.py +0 -0
  149. compas/files/gltf/constants.py +59 -0
  150. compas/files/gltf/data_classes.py +657 -0
  151. compas/files/gltf/extensions.py +317 -0
  152. compas/files/gltf/gltf.py +92 -0
  153. compas/files/gltf/gltf_children.py +64 -0
  154. compas/files/gltf/gltf_content.py +615 -0
  155. compas/files/gltf/gltf_exporter.py +465 -0
  156. compas/files/gltf/gltf_mesh.py +273 -0
  157. compas/files/gltf/gltf_node.py +348 -0
  158. compas/files/gltf/gltf_parser.py +115 -0
  159. compas/files/gltf/gltf_reader.py +310 -0
  160. compas/files/gltf/gltf_scene.py +125 -0
  161. compas/files/gltf/helpers.py +59 -0
  162. compas/files/obj.py +680 -0
  163. compas/files/off.py +296 -0
  164. compas/files/ply.py +697 -0
  165. compas/files/stl.py +436 -0
  166. compas/files/xml.py +328 -0
  167. compas/geometry/__init__.py +772 -0
  168. compas/geometry/_core/__init__.py +0 -0
  169. compas/geometry/_core/_algebra.py +2826 -0
  170. compas/geometry/_core/angles.py +408 -0
  171. compas/geometry/_core/centroids.py +573 -0
  172. compas/geometry/_core/distance.py +895 -0
  173. compas/geometry/_core/normals.py +149 -0
  174. compas/geometry/_core/nurbs.py +367 -0
  175. compas/geometry/_core/predicates_2.py +582 -0
  176. compas/geometry/_core/predicates_3.py +1111 -0
  177. compas/geometry/_core/quaternions.py +196 -0
  178. compas/geometry/_core/size.py +204 -0
  179. compas/geometry/_core/tangent.py +56 -0
  180. compas/geometry/_core/transformations.py +1121 -0
  181. compas/geometry/_core/transformations_numpy.py +279 -0
  182. compas/geometry/bbox.py +145 -0
  183. compas/geometry/bbox_numpy.py +306 -0
  184. compas/geometry/bestfit.py +77 -0
  185. compas/geometry/bestfit_numpy.py +259 -0
  186. compas/geometry/booleans.py +297 -0
  187. compas/geometry/booleans_shapely.py +147 -0
  188. compas/geometry/brep/__init__.py +112 -0
  189. compas/geometry/brep/brep.py +1131 -0
  190. compas/geometry/brep/edge.py +302 -0
  191. compas/geometry/brep/errors.py +22 -0
  192. compas/geometry/brep/face.py +329 -0
  193. compas/geometry/brep/loop.py +87 -0
  194. compas/geometry/brep/trim.py +46 -0
  195. compas/geometry/brep/vertex.py +46 -0
  196. compas/geometry/contours.py +32 -0
  197. compas/geometry/curves/__init__.py +0 -0
  198. compas/geometry/curves/arc.py +429 -0
  199. compas/geometry/curves/bezier.py +345 -0
  200. compas/geometry/curves/circle.py +500 -0
  201. compas/geometry/curves/conic.py +16 -0
  202. compas/geometry/curves/curve.py +614 -0
  203. compas/geometry/curves/ellipse.py +408 -0
  204. compas/geometry/curves/hyperbola.py +336 -0
  205. compas/geometry/curves/line.py +431 -0
  206. compas/geometry/curves/nurbs.py +412 -0
  207. compas/geometry/curves/parabola.py +256 -0
  208. compas/geometry/curves/polyline.py +724 -0
  209. compas/geometry/frame.py +769 -0
  210. compas/geometry/geometry.py +296 -0
  211. compas/geometry/hull.py +146 -0
  212. compas/geometry/hull_numpy.py +82 -0
  213. compas/geometry/icp_numpy.py +104 -0
  214. compas/geometry/interpolation_barycentric.py +38 -0
  215. compas/geometry/interpolation_coons.py +102 -0
  216. compas/geometry/interpolation_tweening.py +87 -0
  217. compas/geometry/intersection.py +121 -0
  218. compas/geometry/intersections.py +1105 -0
  219. compas/geometry/kdtree.py +153 -0
  220. compas/geometry/offset.py +208 -0
  221. compas/geometry/pca_numpy.py +87 -0
  222. compas/geometry/plane.py +657 -0
  223. compas/geometry/point.py +664 -0
  224. compas/geometry/pointcloud.py +409 -0
  225. compas/geometry/polygon.py +473 -0
  226. compas/geometry/polyhedron.py +650 -0
  227. compas/geometry/projection.py +155 -0
  228. compas/geometry/quadmesh_planarize.py +30 -0
  229. compas/geometry/quadmesh_planarize_none.py +114 -0
  230. compas/geometry/quaternion.py +544 -0
  231. compas/geometry/reflection.py +102 -0
  232. compas/geometry/rotation.py +354 -0
  233. compas/geometry/scale.py +100 -0
  234. compas/geometry/shapes/__init__.py +0 -0
  235. compas/geometry/shapes/box.py +747 -0
  236. compas/geometry/shapes/capsule.py +472 -0
  237. compas/geometry/shapes/cone.py +309 -0
  238. compas/geometry/shapes/cylinder.py +355 -0
  239. compas/geometry/shapes/shape.py +300 -0
  240. compas/geometry/shapes/sphere.py +362 -0
  241. compas/geometry/shapes/torus.py +294 -0
  242. compas/geometry/shear.py +115 -0
  243. compas/geometry/surfaces/__init__.py +0 -0
  244. compas/geometry/surfaces/conical.py +166 -0
  245. compas/geometry/surfaces/cylindrical.py +251 -0
  246. compas/geometry/surfaces/extrusion.py +0 -0
  247. compas/geometry/surfaces/nurbs.py +380 -0
  248. compas/geometry/surfaces/planar.py +223 -0
  249. compas/geometry/surfaces/revolution.py +0 -0
  250. compas/geometry/surfaces/spherical.py +259 -0
  251. compas/geometry/surfaces/surface.py +689 -0
  252. compas/geometry/surfaces/toroidal.py +198 -0
  253. compas/geometry/transformation.py +554 -0
  254. compas/geometry/translation.py +104 -0
  255. compas/geometry/triangulation_delaunay.py +102 -0
  256. compas/geometry/triangulation_earclip.py +300 -0
  257. compas/geometry/trimesh_curvature.py +113 -0
  258. compas/geometry/trimesh_descent_numpy.py +26 -0
  259. compas/geometry/trimesh_geodistance.py +35 -0
  260. compas/geometry/trimesh_gradient_numpy.py +74 -0
  261. compas/geometry/trimesh_isolines.py +41 -0
  262. compas/geometry/trimesh_matrices.py +31 -0
  263. compas/geometry/trimesh_matrices_numpy.py +191 -0
  264. compas/geometry/trimesh_parametrisation.py +55 -0
  265. compas/geometry/trimesh_pull_points_numpy.py +216 -0
  266. compas/geometry/trimesh_remeshing.py +97 -0
  267. compas/geometry/trimesh_samplepoints_numpy.py +108 -0
  268. compas/geometry/trimesh_slicing.py +28 -0
  269. compas/geometry/trimesh_smoothing_numpy.py +34 -0
  270. compas/geometry/vector.py +889 -0
  271. compas/itertools.py +441 -0
  272. compas/linalg.py +634 -0
  273. compas/matrices.py +314 -0
  274. compas/plugins.py +488 -0
  275. compas/rpc/__init__.py +20 -0
  276. compas/rpc/__main__.py +77 -0
  277. compas/rpc/dispatcher.py +181 -0
  278. compas/rpc/errors.py +11 -0
  279. compas/rpc/proxy.py +437 -0
  280. compas/rpc/server.py +79 -0
  281. compas/rpc/services/__init__.py +0 -0
  282. compas/rpc/services/default.py +87 -0
  283. compas/rpc/services/watcher.py +43 -0
  284. compas/scene/__init__.py +56 -0
  285. compas/scene/assemblyobject.py +3 -0
  286. compas/scene/context.py +154 -0
  287. compas/scene/descriptors/__init__.py +0 -0
  288. compas/scene/descriptors/attribute.py +30 -0
  289. compas/scene/descriptors/color.py +91 -0
  290. compas/scene/descriptors/colordict.py +101 -0
  291. compas/scene/descriptors/protocol.py +12 -0
  292. compas/scene/exceptions.py +7 -0
  293. compas/scene/geometryobject.py +58 -0
  294. compas/scene/graphobject.py +173 -0
  295. compas/scene/meshobject.py +238 -0
  296. compas/scene/scene.py +144 -0
  297. compas/scene/sceneobject.py +253 -0
  298. compas/scene/volmeshobject.py +252 -0
  299. compas/tolerance.py +879 -0
  300. compas/topology/__init__.py +45 -0
  301. compas/topology/combinatorics.py +108 -0
  302. compas/topology/connectivity.py +129 -0
  303. compas/topology/orientation.py +204 -0
  304. compas/topology/traversal.py +567 -0
  305. compas/utilities/__init__.py +25 -0
  306. compas/utilities/azync.py +155 -0
  307. compas/utilities/datetime.py +40 -0
  308. compas/utilities/decorators.py +136 -0
  309. compas/utilities/remote.py +54 -0
  310. compas/utilities/ssh.py +169 -0
  311. compas-2.1.1.dist-info/AUTHORS.md +42 -0
  312. compas-2.1.1.dist-info/LICENSE +21 -0
  313. compas-2.1.1.dist-info/METADATA +132 -0
  314. compas-2.1.1.dist-info/RECORD +468 -0
  315. compas-2.1.1.dist-info/WHEEL +5 -0
  316. compas-2.1.1.dist-info/entry_points.txt +2 -0
  317. compas-2.1.1.dist-info/top_level.txt +4 -0
  318. compas_blender/__init__.py +250 -0
  319. compas_blender/collections.py +130 -0
  320. compas_blender/conversions/__init__.py +48 -0
  321. compas_blender/conversions/breps.py +0 -0
  322. compas_blender/conversions/colors.py +23 -0
  323. compas_blender/conversions/curves.py +125 -0
  324. compas_blender/conversions/geometry.py +161 -0
  325. compas_blender/conversions/meshes.py +148 -0
  326. compas_blender/conversions/surfaces.py +48 -0
  327. compas_blender/conversions/transformations.py +46 -0
  328. compas_blender/data.py +30 -0
  329. compas_blender/geometry/__init__.py +14 -0
  330. compas_blender/geometry/booleans.py +100 -0
  331. compas_blender/install.py +338 -0
  332. compas_blender/objects.py +326 -0
  333. compas_blender/print_python_path.py +18 -0
  334. compas_blender/scene/__init__.py +116 -0
  335. compas_blender/scene/boxobject.py +64 -0
  336. compas_blender/scene/capsuleobject.py +73 -0
  337. compas_blender/scene/circleobject.py +53 -0
  338. compas_blender/scene/coneobject.py +70 -0
  339. compas_blender/scene/curveobject.py +58 -0
  340. compas_blender/scene/cylinderobject.py +70 -0
  341. compas_blender/scene/frameobject.py +105 -0
  342. compas_blender/scene/graphobject.py +257 -0
  343. compas_blender/scene/lineobject.py +60 -0
  344. compas_blender/scene/meshobject.py +508 -0
  345. compas_blender/scene/planeobject.py +81 -0
  346. compas_blender/scene/pointcloudobject.py +67 -0
  347. compas_blender/scene/pointobject.py +71 -0
  348. compas_blender/scene/polygonobject.py +57 -0
  349. compas_blender/scene/polyhedronobject.py +57 -0
  350. compas_blender/scene/polylineobject.py +54 -0
  351. compas_blender/scene/sceneobject.py +249 -0
  352. compas_blender/scene/sphereobject.py +72 -0
  353. compas_blender/scene/surfaceobject.py +54 -0
  354. compas_blender/scene/torusobject.py +73 -0
  355. compas_blender/scene/vectorobject.py +69 -0
  356. compas_blender/scene/volmeshobject.py +475 -0
  357. compas_blender/utilities/__init__.py +38 -0
  358. compas_blender/utilities/drawing.py +768 -0
  359. compas_ghpython/__init__.py +124 -0
  360. compas_ghpython/components/Compas_FromJson/code.py +18 -0
  361. compas_ghpython/components/Compas_Info/code.py +15 -0
  362. compas_ghpython/components/Compas_RpcCall/code.py +31 -0
  363. compas_ghpython/components/Compas_ToJson/code.py +19 -0
  364. compas_ghpython/components/Compas_ToRhinoGeometry/code.py +15 -0
  365. compas_ghpython/components/__init__.py +99 -0
  366. compas_ghpython/install.py +29 -0
  367. compas_ghpython/scene/__init__.py +115 -0
  368. compas_ghpython/scene/boxobject.py +40 -0
  369. compas_ghpython/scene/brepobject.py +40 -0
  370. compas_ghpython/scene/capsuleobject.py +41 -0
  371. compas_ghpython/scene/circleobject.py +40 -0
  372. compas_ghpython/scene/coneobject.py +40 -0
  373. compas_ghpython/scene/curveobject.py +42 -0
  374. compas_ghpython/scene/cylinderobject.py +38 -0
  375. compas_ghpython/scene/ellipseobject.py +40 -0
  376. compas_ghpython/scene/frameobject.py +67 -0
  377. compas_ghpython/scene/graphobject.py +77 -0
  378. compas_ghpython/scene/lineobject.py +39 -0
  379. compas_ghpython/scene/meshobject.py +137 -0
  380. compas_ghpython/scene/planeobject.py +61 -0
  381. compas_ghpython/scene/pointobject.py +38 -0
  382. compas_ghpython/scene/polygonobject.py +48 -0
  383. compas_ghpython/scene/polyhedronobject.py +48 -0
  384. compas_ghpython/scene/polylineobject.py +39 -0
  385. compas_ghpython/scene/sceneobject.py +12 -0
  386. compas_ghpython/scene/sphereobject.py +39 -0
  387. compas_ghpython/scene/surfaceobject.py +42 -0
  388. compas_ghpython/scene/torusobject.py +39 -0
  389. compas_ghpython/scene/vectorobject.py +51 -0
  390. compas_ghpython/scene/volmeshobject.py +154 -0
  391. compas_ghpython/sets.py +83 -0
  392. compas_ghpython/timer.py +36 -0
  393. compas_ghpython/uninstall.py +31 -0
  394. compas_ghpython/utilities/__init__.py +33 -0
  395. compas_ghpython/utilities/drawing.py +457 -0
  396. compas_rhino/__init__.py +607 -0
  397. compas_rhino/conduits/__init__.py +16 -0
  398. compas_rhino/conduits/base.py +121 -0
  399. compas_rhino/conduits/faces.py +91 -0
  400. compas_rhino/conduits/labels.py +102 -0
  401. compas_rhino/conduits/lines.py +109 -0
  402. compas_rhino/conduits/points.py +111 -0
  403. compas_rhino/conversions/__init__.py +168 -0
  404. compas_rhino/conversions/breps.py +122 -0
  405. compas_rhino/conversions/curves.py +453 -0
  406. compas_rhino/conversions/docobjects.py +0 -0
  407. compas_rhino/conversions/exceptions.py +7 -0
  408. compas_rhino/conversions/extrusions.py +80 -0
  409. compas_rhino/conversions/geometry.py +187 -0
  410. compas_rhino/conversions/meshes.py +281 -0
  411. compas_rhino/conversions/shapes.py +291 -0
  412. compas_rhino/conversions/surfaces.py +355 -0
  413. compas_rhino/conversions/transformations.py +45 -0
  414. compas_rhino/geometry/__init__.py +44 -0
  415. compas_rhino/geometry/booleans.py +118 -0
  416. compas_rhino/geometry/brep/__init__.py +40 -0
  417. compas_rhino/geometry/brep/brep.py +554 -0
  418. compas_rhino/geometry/brep/builder.py +184 -0
  419. compas_rhino/geometry/brep/edge.py +202 -0
  420. compas_rhino/geometry/brep/face.py +285 -0
  421. compas_rhino/geometry/brep/loop.py +129 -0
  422. compas_rhino/geometry/brep/trim.py +99 -0
  423. compas_rhino/geometry/brep/vertex.py +76 -0
  424. compas_rhino/geometry/curves/__init__.py +43 -0
  425. compas_rhino/geometry/curves/curve.py +382 -0
  426. compas_rhino/geometry/curves/nurbs.py +298 -0
  427. compas_rhino/geometry/surfaces/__init__.py +50 -0
  428. compas_rhino/geometry/surfaces/nurbs.py +370 -0
  429. compas_rhino/geometry/surfaces/surface.py +407 -0
  430. compas_rhino/geometry/trimesh_curvature.py +344 -0
  431. compas_rhino/geometry/trimesh_slicing.py +65 -0
  432. compas_rhino/install.py +382 -0
  433. compas_rhino/install_plugin.py +169 -0
  434. compas_rhino/install_with_pip.py +20 -0
  435. compas_rhino/layers.py +347 -0
  436. compas_rhino/objects.py +1141 -0
  437. compas_rhino/print_python_path.py +18 -0
  438. compas_rhino/scene/__init__.py +123 -0
  439. compas_rhino/scene/boxobject.py +44 -0
  440. compas_rhino/scene/brepobject.py +41 -0
  441. compas_rhino/scene/capsuleobject.py +45 -0
  442. compas_rhino/scene/circleobject.py +43 -0
  443. compas_rhino/scene/coneobject.py +43 -0
  444. compas_rhino/scene/curveobject.py +43 -0
  445. compas_rhino/scene/cylinderobject.py +43 -0
  446. compas_rhino/scene/ellipseobject.py +44 -0
  447. compas_rhino/scene/frameobject.py +99 -0
  448. compas_rhino/scene/graphobject.py +364 -0
  449. compas_rhino/scene/helpers.py +33 -0
  450. compas_rhino/scene/lineobject.py +43 -0
  451. compas_rhino/scene/meshobject.py +673 -0
  452. compas_rhino/scene/planeobject.py +71 -0
  453. compas_rhino/scene/pointobject.py +43 -0
  454. compas_rhino/scene/polygonobject.py +45 -0
  455. compas_rhino/scene/polyhedronobject.py +45 -0
  456. compas_rhino/scene/polylineobject.py +43 -0
  457. compas_rhino/scene/sceneobject.py +123 -0
  458. compas_rhino/scene/sphereobject.py +43 -0
  459. compas_rhino/scene/surfaceobject.py +42 -0
  460. compas_rhino/scene/torusobject.py +43 -0
  461. compas_rhino/scene/vectorobject.py +49 -0
  462. compas_rhino/scene/volmeshobject.py +518 -0
  463. compas_rhino/ui.py +114 -0
  464. compas_rhino/uninstall.py +243 -0
  465. compas_rhino/uninstall_plugin.py +91 -0
  466. compas_rhino/utilities/__init__.py +37 -0
  467. compas_rhino/utilities/constructors.py +71 -0
  468. compas_rhino/utilities/drawing.py +1081 -0
@@ -0,0 +1,754 @@
1
+ from __future__ import absolute_import
2
+ from __future__ import division
3
+ from __future__ import print_function
4
+
5
+ from copy import deepcopy
6
+ from math import cos
7
+ from math import pi
8
+
9
+ from compas.geometry import centroid_points
10
+ from compas.geometry import offset_polygon
11
+ from compas.itertools import iterable_like
12
+ from compas.itertools import pairwise
13
+
14
+
15
+ def subd_factory(cls):
16
+ class SubdMesh(cls):
17
+ _add_vertex = cls.add_vertex
18
+ _add_face = cls.add_face
19
+ _insert_vertex = cls.insert_vertex
20
+
21
+ def add_vertex(self, x, y, z):
22
+ key = self._max_vertex = self._max_vertex + 1
23
+ if key not in self.vertex:
24
+ self.vertex[key] = {}
25
+ self.halfedge[key] = {}
26
+ self.vertex[key] = dict(x=x, y=y, z=z)
27
+ return key
28
+
29
+ def add_face(self, vertices):
30
+ fkey = self._max_face = self._max_face + 1
31
+ self.face[fkey] = vertices
32
+ self.facedata[fkey] = {}
33
+ for i in range(-1, len(vertices) - 1):
34
+ u = vertices[i]
35
+ v = vertices[i + 1]
36
+ self.halfedge[u][v] = fkey
37
+ if u not in self.halfedge[v]:
38
+ self.halfedge[v][u] = None
39
+ return fkey
40
+
41
+ def insert_vertex(self, fkey):
42
+ x, y, z = self.face_center(fkey)
43
+ w = self.add_vertex(x=x, y=y, z=z)
44
+ for u, v in self.face_halfedges(fkey):
45
+ self.add_face([u, v, w])
46
+ del self.face[fkey]
47
+ return w
48
+
49
+ return SubdMesh
50
+
51
+
52
+ def mesh_fast_copy(other):
53
+ SubdMesh = subd_factory(type(other))
54
+ subd = SubdMesh()
55
+ subd.vertex = deepcopy(other.vertex)
56
+ subd.face = deepcopy(other.face)
57
+ subd.facedata = deepcopy(other.facedata)
58
+ subd.halfedge = deepcopy(other.halfedge)
59
+ subd._max_vertex = other._max_vertex
60
+ subd._max_face = other._max_face
61
+ return subd
62
+
63
+
64
+ # distinguish between subd of meshes with and without boundary
65
+ # closed vs. open
66
+ # pay attention to extraordinary points
67
+ # and to special rules on boundaries
68
+ # interpolation vs. approxmation?!
69
+ # add numerical versions to compas.datastructures.mesh.(algorithms.)numerical
70
+ # investigate meaning and definition of limit surface
71
+ # any subd algorithm should return a new subd mesh, leaving the control mesh intact
72
+
73
+
74
+ def mesh_subdivide(mesh, scheme="catmullclark", **options):
75
+ """Subdivide the input mesh.
76
+
77
+ Parameters
78
+ ----------
79
+ mesh : :class:`compas.datastructures.Mesh`
80
+ A mesh object.
81
+ scheme : Literal['tri', 'quad', 'corner', 'catmullclark', 'doosabin', 'frames', 'loop'], optional
82
+ The scheme according to which the mesh should be subdivided.
83
+ **options : dict[str, Any], optional
84
+ Optional additional keyword arguments.
85
+
86
+ Returns
87
+ -------
88
+ :class:`compas.datastructures.Mesh`
89
+ The subdivided mesh.
90
+
91
+ Raises
92
+ ------
93
+ ValueError
94
+ If the scheme is not supported.
95
+
96
+ """
97
+ if scheme == "tri":
98
+ return mesh_subdivide_tri(mesh, **options)
99
+ if scheme == "quad":
100
+ return mesh_subdivide_quad(mesh, **options)
101
+ if scheme == "corner":
102
+ return mesh_subdivide_corner(mesh, **options)
103
+ if scheme == "catmullclark":
104
+ return mesh_subdivide_catmullclark(mesh, **options)
105
+ if scheme == "doosabin":
106
+ return mesh_subdivide_doosabin(mesh, **options)
107
+ if scheme == "frames":
108
+ return mesh_subdivide_frames(mesh, **options)
109
+ if scheme == "loop":
110
+ return trimesh_subdivide_loop(mesh, **options)
111
+
112
+ raise ValueError("Scheme is not supported")
113
+
114
+
115
+ def mesh_subdivide_tri(mesh, k=1):
116
+ """Subdivide a mesh using simple insertion of vertices.
117
+
118
+ Parameters
119
+ ----------
120
+ mesh : :class:`compas.datastructures.Mesh`
121
+ The mesh object that will be subdivided.
122
+ k : int, optional
123
+ The number of levels of subdivision.
124
+
125
+ Returns
126
+ -------
127
+ :class:`compas.datastructures.Mesh`
128
+ A new subdivided mesh.
129
+
130
+ Examples
131
+ --------
132
+ >>> from compas.geometry import Box
133
+ >>> from compas.datastructures import Mesh
134
+ >>> box = Box.from_corner_corner_height([0.0, 0.0, 0.0], [1.0, 1.0, 0.0], 1.0)
135
+ >>> mesh = Mesh.from_shape(box)
136
+ >>> k = 2
137
+ >>> subd = mesh_subdivide_tri(mesh, k=k)
138
+ >>> mesh is subd
139
+ False
140
+ >>> type(mesh) is type(subd)
141
+ True
142
+ >>> k1 = sum(len(mesh.face_vertices(fkey)) for fkey in mesh.faces())
143
+ >>> subd.number_of_faces() == (k1 if k == 1 else k1 * 3 ** (k - 1))
144
+ True
145
+
146
+ """
147
+ cls = type(mesh)
148
+ subd = mesh_fast_copy(mesh)
149
+ for _ in range(k):
150
+ for fkey in list(subd.faces()):
151
+ subd.insert_vertex(fkey)
152
+ return cls.__from_data__(subd.__data__)
153
+
154
+
155
+ def mesh_subdivide_quad(mesh, k=1):
156
+ """Subdivide a mesh such that all faces are quads.
157
+
158
+ Parameters
159
+ ----------
160
+ mesh : :class:`compas.datastructures.Mesh`
161
+ The mesh object that will be subdivided.
162
+ k : int, optional
163
+ The number of levels of subdivision.
164
+
165
+ Returns
166
+ -------
167
+ :class:`compas.datastructures.Mesh`
168
+ A new subdivided mesh.
169
+
170
+ Examples
171
+ --------
172
+ >>> from compas.geometry import Box
173
+ >>> from compas.datastructures import Mesh
174
+ >>> box = Box.from_corner_corner_height([0.0, 0.0, 0.0], [1.0, 1.0, 0.0], 1.0)
175
+ >>> mesh = Mesh.from_shape(box)
176
+ >>> k = 2
177
+ >>> subd = mesh_subdivide_quad(mesh, k=k)
178
+ >>> mesh is subd
179
+ False
180
+ >>> type(mesh) is type(subd)
181
+ True
182
+ >>> subd.number_of_faces() == mesh.number_of_faces() * 4**k
183
+ True
184
+
185
+ """
186
+ cls = type(mesh)
187
+ subd = mesh_fast_copy(mesh)
188
+ for face in subd.faces():
189
+ subd.facedata[face]["path"] = [face]
190
+ for _ in range(k):
191
+ faces = {face: subd.face_vertices(face)[:] for face in subd.faces()}
192
+ face_centroid = {face: subd.face_centroid(face) for face in subd.faces()}
193
+ for edge in list(subd.edges()):
194
+ subd.split_edge(edge, allow_boundary=True)
195
+ for face, vertices in faces.items():
196
+ descendant = {i: j for i, j in subd.face_halfedges(face)}
197
+ ancestor = {j: i for i, j in subd.face_halfedges(face)}
198
+ x, y, z = face_centroid[face]
199
+ c = subd.add_vertex(x=x, y=y, z=z)
200
+ for i, vertex in enumerate(vertices):
201
+ a = ancestor[vertex]
202
+ d = descendant[vertex]
203
+ newface = subd.add_face([a, vertex, d, c])
204
+ subd.facedata[newface]["path"] = subd.facedata[face]["path"] + [i]
205
+ del subd.face[face]
206
+ del subd.facedata[face]
207
+ subd2 = cls.__from_data__(subd.__data__)
208
+ return subd2
209
+
210
+
211
+ def mesh_subdivide_corner(mesh, k=1):
212
+ """Subdivide a mesh by cutting corners.
213
+
214
+ Parameters
215
+ ----------
216
+ mesh : :class:`compas.datastructures.Mesh`
217
+ The mesh object that will be subdivided.
218
+ k : int, optional
219
+ The number of levels of subdivision.
220
+
221
+ Returns
222
+ -------
223
+ :class:`compas.datastructures.Mesh`
224
+ A new subdivided mesh.
225
+
226
+ Notes
227
+ -----
228
+ This is essentially the same as Loop subdivision, but applied to general meshes.
229
+
230
+ """
231
+ cls = type(mesh)
232
+ for _ in range(k):
233
+ subd = mesh_fast_copy(mesh)
234
+ # split every edge
235
+ for edge in list(subd.edges()):
236
+ subd.split_edge(edge, allow_boundary=True)
237
+ # create 4 new faces for every old face
238
+ for fkey in mesh.faces():
239
+ descendant = {i: j for i, j in subd.face_halfedges(fkey)}
240
+ ancestor = {j: i for i, j in subd.face_halfedges(fkey)}
241
+ center = []
242
+ for key in mesh.face_vertices(fkey):
243
+ a = ancestor[key]
244
+ d = descendant[key]
245
+ subd.add_face([a, key, d])
246
+ center.append(a)
247
+ subd.add_face(center)
248
+ del subd.face[fkey]
249
+ mesh = subd
250
+ subd2 = cls.__from_data__(mesh.__data__)
251
+ return subd2
252
+
253
+
254
+ def mesh_subdivide_catmullclark(mesh, k=1, fixed=None):
255
+ """Subdivide a mesh using the Catmull-Clark algorithm.
256
+
257
+ Parameters
258
+ ----------
259
+ mesh : :class:`compas.datastructures.Mesh`
260
+ The mesh object that will be subdivided.
261
+ k : int, optional
262
+ The number of levels of subdivision.
263
+ fixed : list[int], optional
264
+ A list of fixed vertices.
265
+
266
+ Returns
267
+ -------
268
+ :class:`compas.datastructures.Mesh`
269
+ A new subdivided mesh.
270
+
271
+ Notes
272
+ -----
273
+ Note that *Catmull-Clark* subdivision is like *Quad* subdivision, but with
274
+ smoothing after every level of further subdivision. Smoothing is done
275
+ according to the scheme prescribed by the Catmull-Clark algorithm.
276
+
277
+ References
278
+ ----------
279
+ .. [1] Tony DeRose, Michael Kass and Tien Truong.
280
+ Subdivision Surfaces in Character Animation.
281
+ Pixar Animation Studios.
282
+ see https://graphics.pixar.com/library/Geri/paper.pdf
283
+
284
+ Examples
285
+ --------
286
+ >>> from compas.geometry import Box
287
+ >>> from compas.datastructures import Mesh
288
+ >>> box = Box.from_corner_corner_height([0.0, 0.0, 0.0], [1.0, 1.0, 0.0], 1.0)
289
+ >>> mesh = Mesh.from_shape(box)
290
+ >>> k = 2
291
+ >>> subd = mesh_subdivide_catmullclark(mesh, k=k)
292
+ >>> mesh is subd
293
+ False
294
+ >>> type(mesh) is type(subd)
295
+ True
296
+ >>> subd.number_of_faces() == mesh.number_of_faces() * 4**k
297
+ True
298
+
299
+ The algorithm supports "integer creasing" as described in
300
+ Subdivision Surfaces in Character Animation [1]_.
301
+ Creases are supported through the optional edge attribute "crease",
302
+ which can be set to an integer value that defines how sharp the crease is wrt
303
+ the number of subdivision steps.
304
+
305
+ To add an infinitely sharp crease to an edge, set the "crease" attribute of the edge
306
+ to a number higher than the number of subdivision steps.
307
+
308
+ >>> from compas.geometry import Box, dot_vectors
309
+ >>> from compas.datastructures import Mesh
310
+
311
+ >>> cage = Mesh.from_shape(Box.from_width_height_depth(1, 1, 1))
312
+ >>> cage.update_default_edge_attributes({"crease": 0})
313
+ >>> top = sorted(cage.faces(), key=lambda face: dot_vectors(cage.face_normal(face), [0, 0, 1]))[-1]
314
+ >>> cage.edges_attribute("crease", 5, keys=list(cage.face_halfedges(top)))
315
+
316
+ >>> subd = cage.subdivide(k=4)
317
+
318
+ """
319
+ cls = type(mesh)
320
+
321
+ if not fixed:
322
+ fixed = []
323
+ fixed = set(fixed)
324
+
325
+ for _ in range(k):
326
+ subd = mesh_fast_copy(mesh)
327
+
328
+ # keep track of original connectivity and vertex locations
329
+
330
+ # apply quad meshivision scheme
331
+ # keep track of the created edge points that are not on the boundary
332
+ # keep track track of the new edge points on the boundary
333
+ # and their relation to the previous boundary points
334
+
335
+ # quad subdivision
336
+ # ======================================================================
337
+
338
+ edgepoints = []
339
+
340
+ for u, v in mesh.edges():
341
+ w = subd.split_edge((u, v), allow_boundary=True)
342
+ crease = mesh.edge_attribute((u, v), "crease") or 0
343
+
344
+ if crease:
345
+ edgepoints.append([w, True])
346
+ subd.edge_attribute((u, w), "crease", crease - 1)
347
+ subd.edge_attribute((w, v), "crease", crease - 1)
348
+ else:
349
+ edgepoints.append([w, False])
350
+
351
+ fkey_xyz = {fkey: mesh.face_centroid(fkey) for fkey in mesh.faces()}
352
+
353
+ for fkey in mesh.faces():
354
+ descendant = {i: j for i, j in subd.face_halfedges(fkey)}
355
+ ancestor = {j: i for i, j in subd.face_halfedges(fkey)}
356
+
357
+ x, y, z = fkey_xyz[fkey]
358
+ c = subd.add_vertex(x=x, y=y, z=z)
359
+
360
+ for key in mesh.face_vertices(fkey):
361
+ a = ancestor[key]
362
+ d = descendant[key]
363
+
364
+ subd.add_face([a, key, d, c])
365
+
366
+ del subd.face[fkey]
367
+
368
+ # update coordinates
369
+ # ======================================================================
370
+
371
+ # these are the coordinates before updating
372
+
373
+ key_xyz = {key: subd.vertex_coordinates(key) for key in subd.vertex}
374
+
375
+ # move each edge point to the average of the neighboring centroids and
376
+ # the original end points
377
+
378
+ for w, crease in edgepoints:
379
+ if not crease:
380
+ x, y, z = centroid_points([key_xyz[nbr] for nbr in subd.halfedge[w]])
381
+ subd.vertex[w]["x"] = x
382
+ subd.vertex[w]["y"] = y
383
+ subd.vertex[w]["z"] = z
384
+
385
+ # move each vertex to the weighted average of itself, the neighboring
386
+ # centroids and the neighboring mipoints
387
+
388
+ for key in mesh.vertices():
389
+ if key in fixed:
390
+ continue
391
+
392
+ nbrs = mesh.vertex_neighbors(key)
393
+ creases = mesh.edges_attribute("crease", keys=[(key, nbr) for nbr in nbrs])
394
+
395
+ C = sum(1 if crease else 0 for crease in creases)
396
+
397
+ if C < 2:
398
+ fnbrs = [mesh.face_centroid(fkey) for fkey in mesh.vertex_faces(key) if fkey is not None]
399
+ enbrs = [key_xyz[nbr] for nbr in subd.halfedge[key]] # this should be the location of the original neighbour
400
+ n = len(enbrs)
401
+ v = n - 3.0
402
+ F = centroid_points(fnbrs)
403
+ E = centroid_points(enbrs)
404
+ V = key_xyz[key]
405
+ x = (F[0] + 2.0 * E[0] + v * V[0]) / n
406
+ y = (F[1] + 2.0 * E[1] + v * V[1]) / n
407
+ z = (F[2] + 2.0 * E[2] + v * V[2]) / n
408
+ subd.vertex[key]["x"] = x
409
+ subd.vertex[key]["y"] = y
410
+ subd.vertex[key]["z"] = z
411
+
412
+ elif C == 2:
413
+ V = key_xyz[key]
414
+ E = [0, 0, 0]
415
+ for nbr, crease in zip(nbrs, creases):
416
+ if crease:
417
+ x, y, z = key_xyz[nbr]
418
+ E[0] += x
419
+ E[1] += y
420
+ E[2] += z
421
+ x = (6 * V[0] + E[0]) / 8
422
+ y = (6 * V[1] + E[1]) / 8
423
+ z = (6 * V[2] + E[2]) / 8
424
+ subd.vertex[key]["x"] = x
425
+ subd.vertex[key]["y"] = y
426
+ subd.vertex[key]["z"] = z
427
+ else:
428
+ pass
429
+
430
+ mesh = subd
431
+
432
+ subd2 = cls.__from_data__(mesh.__data__)
433
+ return subd2
434
+
435
+
436
+ def mesh_subdivide_doosabin(mesh, k=1, fixed=None):
437
+ """Subdivide a mesh following the doo-sabin scheme.
438
+
439
+ Parameters
440
+ ----------
441
+ mesh : :class:`compas.datastructures.Mesh`
442
+ The mesh object that will be subdivided.
443
+ k : int, optional
444
+ The number of levels of subdivision.
445
+ fixed : list[int], optional
446
+ A list of fixed vertices.
447
+
448
+ Returns
449
+ -------
450
+ :class:`compas.datastructures.Mesh`
451
+ A new subdivided mesh.
452
+
453
+ Examples
454
+ --------
455
+ >>> from compas.geometry import Box
456
+ >>> from compas.datastructures import Mesh
457
+ >>> box = Box.from_corner_corner_height([0.0, 0.0, 0.0], [1.0, 1.0, 0.0], 1.0)
458
+ >>> mesh = Mesh.from_shape(box)
459
+ >>> k = 2
460
+ >>> subd = mesh_subdivide_doosabin(mesh, k=k)
461
+ >>> mesh is subd
462
+ False
463
+ >>> type(mesh) is type(subd)
464
+ True
465
+
466
+ """
467
+ if not fixed:
468
+ fixed = []
469
+
470
+ fixed = set(fixed)
471
+
472
+ cls = type(mesh)
473
+ SubdMesh = subd_factory(cls)
474
+
475
+ for _ in range(k):
476
+ old_xyz = {key: mesh.vertex_coordinates(key) for key in mesh.vertices()}
477
+ fkey_old_new = {fkey: {} for fkey in mesh.faces()}
478
+
479
+ subd = SubdMesh()
480
+
481
+ for fkey in mesh.faces():
482
+ vertices = mesh.face_vertices(fkey)
483
+ n = len(vertices)
484
+
485
+ face = []
486
+
487
+ for i in range(n):
488
+ old = vertices[i]
489
+
490
+ cx, cy, cz = 0, 0, 0
491
+
492
+ for j in range(n):
493
+ x, y, z = old_xyz[vertices[j]]
494
+
495
+ if i == j:
496
+ alpha = (n + 5.0) / (4.0 * n)
497
+ else:
498
+ alpha = (3.0 + 2.0 * cos(2.0 * pi * (i - j) / n)) / (4.0 * n)
499
+
500
+ cx += alpha * x
501
+ cy += alpha * y
502
+ cz += alpha * z
503
+
504
+ new = subd.add_vertex(cx, cy, cz)
505
+ fkey_old_new[fkey][old] = new
506
+
507
+ face.append(new)
508
+
509
+ subd.add_face(face)
510
+
511
+ boundary = set(mesh.vertices_on_boundary())
512
+
513
+ for key in mesh.vertices():
514
+ if key in boundary:
515
+ continue
516
+
517
+ face = [fkey_old_new[fkey][key] for fkey in mesh.vertex_faces(key, ordered=True) if fkey is not None]
518
+
519
+ subd.add_face(face[::-1])
520
+
521
+ edges = set()
522
+
523
+ for u in mesh.halfedge:
524
+ for v in mesh.halfedge[u]:
525
+ if (u, v) in edges:
526
+ continue
527
+
528
+ edges.add((u, v))
529
+ edges.add((v, u))
530
+
531
+ uv_fkey = mesh.halfedge[u][v]
532
+ vu_fkey = mesh.halfedge[v][u]
533
+
534
+ if uv_fkey is None or vu_fkey is None:
535
+ continue
536
+
537
+ face = [
538
+ fkey_old_new[uv_fkey][u],
539
+ fkey_old_new[vu_fkey][u],
540
+ fkey_old_new[vu_fkey][v],
541
+ fkey_old_new[uv_fkey][v],
542
+ ]
543
+ subd.add_face(face)
544
+
545
+ mesh = subd
546
+
547
+ subd2 = cls.__from_data__(mesh.__data__)
548
+ return subd2
549
+
550
+
551
+ def mesh_subdivide_frames(mesh, offset, add_windows=False):
552
+ """Subdivide a mesh by creating offset frames and windows on its faces.
553
+
554
+ Parameters
555
+ ----------
556
+ mesh : :class:`compas.datastructures.Mesh`
557
+ The mesh object to be subdivided.
558
+ offset : float | dict[int, float]
559
+ The offset distance to create the frames.
560
+ A single value will result in a constant offset everywhere.
561
+ A dictionary mapping faces to offset values will be processed accordingly.
562
+ add_windows : bool, optional
563
+ If True, add a window face in the frame opening.
564
+
565
+ Returns
566
+ -------
567
+ :class:`compas.datastructures.Mesh`
568
+ A new subdivided mesh.
569
+
570
+ """
571
+ cls = type(mesh)
572
+ SubdMesh = subd_factory(cls)
573
+
574
+ subd = SubdMesh()
575
+
576
+ # 0. pre-compute offset distances
577
+ if not isinstance(offset, dict):
578
+ distances = iterable_like(mesh.faces(), [offset], offset)
579
+ offset = {fkey: od for fkey, od in zip(mesh.faces(), distances)}
580
+
581
+ # 1. add vertices
582
+ newkeys = {}
583
+ for vkey, attr in mesh.vertices(True):
584
+ newkeys[vkey] = subd.add_vertex(*mesh.vertex_coordinates(vkey))
585
+
586
+ # 2. add faces
587
+ for fkey in mesh.faces():
588
+ face = [newkeys[vkey] for vkey in mesh.face_vertices(fkey)]
589
+ d = offset.get(fkey)
590
+
591
+ # 2a. add face and break if no offset is found
592
+ if d is None:
593
+ subd.add_face(face)
594
+ continue
595
+
596
+ polygon = offset_polygon(mesh.face_coordinates(fkey), d)
597
+
598
+ # 2a. add offset vertices
599
+ window = []
600
+ for xyz in polygon:
601
+ x, y, z = xyz
602
+ new_vkey = subd.add_vertex(x=x, y=y, z=z)
603
+ window.append(new_vkey)
604
+
605
+ # 2b. frame faces
606
+ face = face + face[:1]
607
+ window = window + window[:1]
608
+ for sa, sb in zip(pairwise(face), pairwise(window)):
609
+ subd.add_face([sa[0], sa[1], sb[1], sb[0]])
610
+
611
+ # 2c. window face
612
+ if add_windows:
613
+ subd.add_face(window)
614
+
615
+ return cls.__from_data__(subd.__data__)
616
+
617
+
618
+ def trimesh_subdivide_loop(mesh, k=1, fixed=None):
619
+ """Subdivide a triangle mesh using the Loop algorithm.
620
+
621
+ Parameters
622
+ ----------
623
+ mesh : :class:`compas.datastructures.Mesh`
624
+ The mesh object that will be subdivided.
625
+ k : int, optional
626
+ The number of levels of subdivision.
627
+ fixed : list[int], optional
628
+ A list of fixed vertices.
629
+
630
+ Returns
631
+ -------
632
+ :class:`compas.datastructures.Mesh`
633
+ A new subdivided mesh.
634
+
635
+ Examples
636
+ --------
637
+ Make a low poly mesh from a box shape.
638
+ Triangulate the faces.
639
+
640
+ >>> from compas.geometry import Box
641
+ >>> from compas.datastructures import Mesh
642
+ >>> box = Box.from_corner_corner_height([0.0, 0.0, 0.0], [1.0, 1.0, 0.0], 1.0)
643
+ >>> mesh = Mesh.from_shape(box)
644
+ >>> mesh.quads_to_triangles()
645
+
646
+ Subdivide 2 times.
647
+
648
+ >>> k = 2
649
+ >>> subd = trimesh_subdivide_loop(mesh, k=k)
650
+
651
+ Compare low-poly cage with subdivision mesh.
652
+
653
+ >>> mesh is subd
654
+ False
655
+ >>> type(mesh) is type(subd)
656
+ True
657
+ >>> subd.number_of_faces() == mesh.number_of_faces() * (3 + 1) ** k
658
+ True
659
+
660
+ """
661
+ cls = type(mesh)
662
+
663
+ if not fixed:
664
+ fixed = []
665
+
666
+ fixed = set(fixed)
667
+
668
+ subd = mesh_fast_copy(mesh)
669
+
670
+ for _ in range(k):
671
+ key_xyz = {key: subd.vertex_coordinates(key) for key in subd.vertices()}
672
+ fkey_vertices = {fkey: subd.face_vertices(fkey)[:] for fkey in subd.faces()}
673
+ uv_w = {(u, v): subd.face_vertex_ancestor(fkey, u) for fkey in subd.faces() for u, v in subd.face_halfedges(fkey)}
674
+ boundary = set(subd.vertices_on_boundary())
675
+
676
+ for key in subd.vertices():
677
+ nbrs = subd.vertex_neighbors(key)
678
+
679
+ if key in boundary:
680
+ xyz = key_xyz[key]
681
+
682
+ x = 0.75 * xyz[0]
683
+ y = 0.75 * xyz[1]
684
+ z = 0.75 * xyz[2]
685
+
686
+ for n in nbrs:
687
+ if subd.halfedge[key][n] is None or subd.halfedge[n][key] is None:
688
+ xyz = key_xyz[n]
689
+
690
+ x += 0.125 * xyz[0]
691
+ y += 0.125 * xyz[1]
692
+ z += 0.125 * xyz[2]
693
+
694
+ else:
695
+ n = len(nbrs)
696
+
697
+ if n == 3:
698
+ a = 3.0 / 16.0
699
+ else:
700
+ a = 3.0 / (8 * n)
701
+
702
+ xyz = key_xyz[key]
703
+
704
+ nbrs = [key_xyz[nbr] for nbr in nbrs]
705
+ nbrs = [sum(axis) for axis in zip(*nbrs)]
706
+
707
+ x = (1.0 - n * a) * xyz[0] + a * nbrs[0]
708
+ y = (1.0 - n * a) * xyz[1] + a * nbrs[1]
709
+ z = (1.0 - n * a) * xyz[2] + a * nbrs[2]
710
+
711
+ subd.vertex[key]["x"] = x
712
+ subd.vertex[key]["y"] = y
713
+ subd.vertex[key]["z"] = z
714
+
715
+ edgepoints = {}
716
+
717
+ # odd vertices
718
+ for u, v in list(subd.edges()):
719
+ w = subd.split_edge((u, v), allow_boundary=True)
720
+
721
+ edgepoints[(u, v)] = w
722
+ edgepoints[(v, u)] = w
723
+
724
+ a = key_xyz[u]
725
+ b = key_xyz[v]
726
+
727
+ if (u, v) in uv_w and (v, u) in uv_w:
728
+ c = key_xyz[uv_w[(u, v)]]
729
+ d = key_xyz[uv_w[(v, u)]]
730
+ xyz = [(3.0 / 8.0) * (a[i] + b[i]) + (1.0 / 8.0) * (c[i] + d[i]) for i in range(3)]
731
+
732
+ else:
733
+ xyz = [0.5 * (a[i] + b[i]) for i in range(3)]
734
+
735
+ subd.vertex[w]["x"] = xyz[0]
736
+ subd.vertex[w]["y"] = xyz[1]
737
+ subd.vertex[w]["z"] = xyz[2]
738
+
739
+ # new faces
740
+ for fkey, vertices in fkey_vertices.items():
741
+ u, v, w = vertices
742
+
743
+ uv = edgepoints[(u, v)]
744
+ vw = edgepoints[(v, w)]
745
+ wu = edgepoints[(w, u)]
746
+
747
+ subd.add_face([wu, u, uv])
748
+ subd.add_face([uv, v, vw])
749
+ subd.add_face([vw, w, wu])
750
+ subd.add_face([uv, vw, wu])
751
+
752
+ del subd.face[fkey]
753
+
754
+ return cls.__from_data__(subd.__data__)