SPOMSO 1.2.1__tar.gz

SPOMSO-1.2.1/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

SPOMSO-1.2.1/LICENSE_NOTICE

@@ -0,0 +1,3 @@
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+You should have received a copy of the GNU Lesser General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

SPOMSO-1.2.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: SPOMSO
+Version: 1.2.1
+Summary: SPOMSO
+Home-page: https://github.com/peterropac/Aegolius/tree/main/Code
+Author: Peter Ropač
+Author-email: <peter.ropac@fmf.uni-lj.si>
+Keywords: python,geometry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+License-File: LICENSE_NOTICE
+Requires-Dist: numpy
+Requires-Dist: scipy
+
+Python package for generating geometry with SDFs.

SPOMSO-1.2.1/SPOMSO.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: SPOMSO
+Version: 1.2.1
+Summary: SPOMSO
+Home-page: https://github.com/peterropac/Aegolius/tree/main/Code
+Author: Peter Ropač
+Author-email: <peter.ropac@fmf.uni-lj.si>
+Keywords: python,geometry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+License-File: LICENSE_NOTICE
+Requires-Dist: numpy
+Requires-Dist: scipy
+
+Python package for generating geometry with SDFs.

SPOMSO-1.2.1/SPOMSO.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE
+LICENSE_NOTICE
+setup.py
+SPOMSO.egg-info/PKG-INFO
+SPOMSO.egg-info/SOURCES.txt
+SPOMSO.egg-info/dependency_links.txt
+SPOMSO.egg-info/requires.txt
+SPOMSO.egg-info/top_level.txt
+spomso/__init__.py
+spomso/cores/__init__.py
+spomso/cores/combine.py
+spomso/cores/geom.py
+spomso/cores/geom_2d.py
+spomso/cores/geom_3d.py
+spomso/cores/geom_core_2d_direct.py
+spomso/cores/geom_core_3d_direct.py
+spomso/cores/geom_vector.py
+spomso/cores/geom_vector_special.py
+spomso/cores/helper_functions.py
+spomso/cores/modifications.py
+spomso/cores/post_processing.py
+spomso/cores/sdf_2D.py
+spomso/cores/sdf_3D.py
+spomso/cores/transformations.py
+spomso/cores/vector_functions.py
+spomso/cores/vector_functions_special.py
+spomso/cores/vector_modification_functions.py
+spomso/jax_cores/__init__.py
+spomso/jax_cores/sdf_core_jax.py

SPOMSO-1.2.1/SPOMSO.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

SPOMSO-1.2.1/SPOMSO.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+scipy

SPOMSO-1.2.1/SPOMSO.egg-info/top_level.txt

@@ -0,0 +1 @@
+spomso

SPOMSO-1.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

SPOMSO-1.2.1/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+VERSION = '1.2.1'
+DESCRIPTION = 'SPOMSO'
+LONG_DESCRIPTION = 'Python package for generating geometry with SDFs.'
+
+# Setting up
+setup(
+    name="SPOMSO",
+    version=VERSION,
+    author="Peter Ropač",
+    author_email="<peter.ropac@fmf.uni-lj.si>",
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    url='https://github.com/peterropac/Aegolius/tree/main/Code',
+    packages=find_packages(),
+    install_requires=['numpy', 'scipy'],
+    keywords=['python', 'geometry'],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Education",
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ]
+)

SPOMSO-1.2.1/spomso/cores/__init__.py

@@ -0,0 +1,67 @@
+# Copyright (C) 2024 Peter Ropač
+# This file is part of SPOMSO.
+# SPOMSO is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+# SPOMSO is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public License along with SPOMSO. If not, see <https://www.gnu.org/licenses/>.
+
+from .combine import CombineGeometry, smoothmax_boltz, smoothmin_poly2, smoothmin_poly3
+from .transformations import EuclideanTransform, EuclideanTransformPoints
+from .modifications import ModifyObject, ModifyVectorObject
+from .geom import GenericGeometry, Points
+from .helper_functions import resolution_conversion, generate_grid
+from .helper_functions import smarter_reshape, vector_smarter_reshape, nd_vector_smarter_reshape
+from .post_processing import sigmoid_falloff, positive_sigmoid_falloff, capped_exponential
+from .post_processing import linear_falloff, relu, smooth_relu, slowstart
+from .post_processing import hard_binarization
+from .post_processing import gaussian_boundary, gaussian_falloff
+from .post_processing import conv_averaging, conv_edge_detection
+from .post_processing import custom_post_process
+from .post_processing import PostProcess
+
+from .sdf_2D import sdf_circle, sdf_segment_2d, sdf_box_2d, sdf_rounded_box_2d, sdf_triangle_2d
+from .sdf_2D import sdf_arc, sdf_sector, sdf_inf_sector, sdf_ngon
+from .sdf_2D import sdf_segmented_curve_2d, sdf_segmented_line_2d, sdf_parametric_curve_2d
+from .sdf_2D import sdf_point_cloud_2d
+
+from .geom_2d import Circle, NGon, Rectangle, RoundedRectangle, Segment, Triangle, Sector, InfiniteSector, Arc
+from .geom_2d import ParametricCurve, SegmentedParametricCurve, SegmentedLine
+from .geom_2d import PointCloud2D
+
+from .sdf_3D import sdf_sphere, sdf_cylinder, sdf_box, sdf_torus, sdf_chainlink, sdf_braid, sdf_arc_3d
+from .sdf_3D import sdf_plane, sudf_plane, sdf_segment_3d
+from .sdf_3D import sdf_cone, sdf_oriented_infinite_cone, sdf_infinite_cone, sdf_solid_angle
+from .sdf_3D import sdf_triangle_3d, sdf_quad_3d
+from .sdf_3D import sdf_segmented_line_3d, sdf_segmented_curve_3d, sdf_parametric_curve_3d
+from .sdf_3D import sdf_x, sdf_y, sdf_z
+from .sdf_3D import sdf_point_cloud_3d
+
+from .geom_3d import InfiniteCylinder, Cylinder, Sphere, Box, Plane, OrientedPlane, Line, Triangle3D, Quad
+from .geom_3d import Torus, ChainLink, Braid, Arc3D, Cone, InfiniteCone, OrientedInfiniteCone
+from .geom_3d import ParametricCurve3D, SegmentedParametricCurve3D, SegmentedLine3D
+from .geom_3d import X, Y, Z
+
+from .vector_functions import cartesian_define, spherical_define, cylindrical_define
+from .vector_functions import radial_vector_field_spherical
+from .vector_functions import radial_vector_field_cylindrical, hyperbolic_vector_field_cylindrical
+from .vector_functions import aar_vector_field_cylindrical, awn_vector_field_cylindrical
+from .vector_functions import vortex_vector_field_cylindrical, aav_vector_field_cylindrical
+from .vector_functions import x_vector_field, y_vector_field, z_vector_field
+from .vector_functions import from_sdf
+from .geom_vector_special import lcwg1_p1, lcwg1_m1, lcwg1_2d
+from .vector_functions_special import compute_crossings_2d
+
+from .vector_modification_functions import batch_normalize
+from .vector_modification_functions import add_vectors, subtract_vectors, rescale_vectors
+from .vector_modification_functions import rotate_vectors_phi, rotate_vectors_theta
+from .vector_modification_functions import rotate_vectors_x_axis, rotate_vectors_y_axis, rotate_vectors_z_axis
+from .vector_modification_functions import rotate_vectors_axis
+from .vector_modification_functions import revolve_field_x, revolve_field_y, revolve_field_z
+
+from .geom_vector import CartesianVectorField, CylindricalVectorField, SphericalVectorField
+from .geom_vector import RadialSphericalVectorField
+from .geom_vector import RadialCylindricalVectorField, HyperbolicCylindricalVectorField
+from .geom_vector import AngledRadialCylindricalVectorField, WindingCylindricalVectorField
+from .geom_vector import VortexCylindricalVectorField, AngledVortexCylindricalVectorField
+from .geom_vector import XVectorField, YVectorField, ZVectorField
+from .geom_vector import VectorFieldFromSDF
+from .geom_vector_special import LCWG2D, LCWG3Dp1, LCWG3Dm1

SPOMSO-1.2.1/spomso/cores/combine.py

@@ -0,0 +1,158 @@
+# Copyright (C) 2024 Peter Ropač
+# This file is part of SPOMSO.
+# SPOMSO is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+# SPOMSO is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public License along with SPOMSO. If not, see <https://www.gnu.org/licenses/>.
+
+import numpy as np
+from spomso.cores.geom import GenericGeometry
+from typing import Callable
+
+def smoothmin_poly2(x, y, a):
+    # https://iquilezles.org/articles/smin/
+    h = np.maximum(a - np.abs(x - y), 0.0)/a
+    return np.minimum(x, y) - h * h * a/4.0
+
+
+def smoothmin_poly3(x, y, a):
+    # https://iquilezles.org/articles/smin/
+    if not a == 0.0:
+        h = np.maximum(a - np.abs(x - y), 0.0)/a
+        return np.minimum(x, y) - h * h * h * a / 6.0
+    else:
+        return np.minimum(y, y)
+
+
+def smoothmax_boltz(x, y, width):
+    # https: // en.wikipedia.org / wiki / Smooth_maximum
+    exp1 = np.exp(x/width)
+    exp2 = np.exp(y/width)
+
+    return (x*exp1 + y*exp2)/(exp1 + exp2)
+
+
+class CombineGeometry:
+    """Class containing all the possible combination operations which can be applied to a scalar fields.
+
+        Attributes:
+            operations: Dictionary containing all the possible non-parametric operations.
+            parametric_operations: Dictionary containing all the possible parametric operations.
+
+        Args:
+            operation_type: Type of operation with which two or more geometric objects are combined.
+        """
+
+    def __init__(self, operation_type: str):
+        self.operation_type: str = operation_type
+        self._combined_geometry: Callable[[np.ndarray, tuple], np.ndarray] = None
+        self.operations: dict = {"UNION2": lambda obj1, obj2: np.minimum(obj1, obj2),
+                                 "UNION": lambda *objs: np.amin(objs, axis=0),
+                                 "SUBTRACT2": lambda obj1, obj2: np.maximum(obj1, -obj2),
+                                 "INTERSECT2": lambda obj1, obj2: np.maximum(obj1, obj2),
+                                 "INTERSECT": lambda *objs: np.amax(objs, axis=0),
+                                 }
+
+        self.parametric_operations: dict = {"SMOOTH_UNION2_2": lambda obj1, obj2, width: smoothmin_poly2(obj1,
+                                                                                                         obj2,
+                                                                                                         width),
+                                            "SMOOTH_UNION2": lambda obj1, obj2, width: smoothmin_poly3(obj1,
+                                                                                                       obj2,
+                                                                                                       width),
+                                            "SMOOTH_INTERSECT2": lambda obj1, obj2, width: -smoothmin_poly3(-obj1,
+                                                                                                            -obj2,
+                                                                                                            width),
+                                            "SMOOTH_INTERSECT2_BOLTZMANN": lambda obj1, obj2, width: smoothmax_boltz(obj1,
+                                                                                                                     obj2,
+                                                                                                                     width),
+                                            "SMOOTH_SUBTRACT2": lambda obj1, obj2, width: -smoothmin_poly3(-obj1,
+                                                                                                           obj2,
+                                                                                                           width),
+                                            "SMOOTH_SUBTRACT2_BOLTZMANN": lambda obj1, obj2, width: smoothmax_boltz(obj1,
+                                                                                                                    -obj2,
+                                                                                                                    width)
+                                      }
+
+    @property
+    def available_operations(self) -> list:
+        """
+        Available types of operations.
+        
+        Returns:
+             List of available operations.
+        """
+        operations_list = list(self.operations.keys())
+        print(f"Available non-parametric operations are: {operations_list}")
+        return operations_list
+
+    @property
+    def available_parametric_operations(self) -> list:
+        """
+        Available types of operations which require a parameter.
+        
+        Returns:
+              List of available parametric operations.
+        """
+        operations_list = list(self.parametric_operations.keys())
+        print(f"Available parametric operations are: {operations_list}")
+        return operations_list
+
+    @property
+    def combined_geometry(self) -> Callable[[np.ndarray, tuple], np.ndarray]:
+        """
+        Returns the SDF of the combined geometries,
+        which can be used to create a new geometry using GenericGeometry class.
+        
+        Returns:
+              SDF of the combined geometries
+        """
+        return self._combined_geometry
+
+    def combine(self, *combined_objects: object) -> GenericGeometry:
+        """
+        Combines 2 or more geometric objects together.
+
+        Args:
+            combined_objects: Tuple containing geometric objects.
+        
+        Returns:
+              New geometric object.
+        """
+        if self.operation_type not in self.operations.keys():
+            raise SyntaxError(f"{self.operation_type} is not an implemented non-parametric operation.",
+                              f"Possible operations are {self.operations.keys}")
+
+        def new_geo_object(co, *params):
+            sdfs = []
+            for cobject in combined_objects:
+                sdf_ = cobject.propagate(co, ())
+                sdfs.append(sdf_)
+
+            return self.operations[self.operation_type](*sdfs)
+
+        self._combined_geometry = new_geo_object
+        return GenericGeometry(new_geo_object, ())
+
+    def combine_parametric(self, *combined_objects: object, parameters: tuple | float | int) -> GenericGeometry:
+        """
+        Combines 2 or more geometric objects together, based on the parameters of the operations.
+        Args:
+            combined_objects: Tuple containing geometric objects.
+            parameters: Parameters of the operation.
+        
+        Returns:
+              New geometric object.
+        """
+        if self.operation_type not in self.parametric_operations.keys():
+            raise SyntaxError(f"{self.operation_type} is not an implemented parametric operation.",
+                              f"Possible parametric operations are {self.parametric_operations.keys}")
+
+        def new_geo_object(co, *params):
+            sdfs = []
+            for cobject in combined_objects:
+                sdf_ = cobject.propagate(co, ())
+                sdfs.append(sdf_)
+
+            return self.parametric_operations[self.operation_type](*sdfs, parameters)
+
+        self._combined_geometry = new_geo_object
+        return GenericGeometry(new_geo_object, ())