jerboapy 0.2rc332__cp313-cp313-win_amd64.whl

jerboapy/__init__.py

@@ -0,0 +1,31 @@
+import importlib.metadata
+
+# # Importation du module C++ généré par pybind11
+# from .jerboapy_bin import *
+
+# # Lecture automatique des métadonnées depuis pyproject.toml
+# __version__ = importlib.metadata.version("jerboapy")
+# __description__ = importlib.metadata.metadata("jerboapy")["Summary"]
+# __author__ = importlib.metadata.metadata("jerboapy")["Authors"]
+# __license__ = importlib.metadata.metadata("jerboapy")["License"]
+
+# Importation du module C++ généré par pybind11
+from .jerboapy_bin import *
+
+# Gestion sécurisée des métadonnées
+try:
+    import importlib.metadata
+    __version__ = importlib.metadata.version("jerboapy")
+    __description__ = importlib.metadata.metadata("jerboapy")["Summary"]
+    __author__ = importlib.metadata.metadata("jerboapy")["Author-Email"]
+    if not __author__:
+        __author__ = importlib.metadata.metadata("jerboapy")["Author"]
+    __license__ = importlib.metadata.metadata("jerboapy")["License-Expression"]
+    if not __license__:
+        __license__ = importlib.metadata.metadata("jerboapy")["License"]
+except (ImportError, importlib.metadata.PackageNotFoundError):
+    # Valeurs par défaut si le package n'est pas installé
+    __version__ = "X.X.X-dev"
+    __description__ = "Jerboa C++ bindings for Python (dev version without metadata)"
+    __author__ = "Hakim"
+    __license__ = "GPL-3.0-or-later"

jerboapy-0.2rc332.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: jerboapy
+Version: 0.2rc332
+Summary: Bindings C++ avec pybind11 de Jerboa
+Author-email: Hakim Belhaouari <hakim.belhaouari@univ-poitiers.fr>
+License-Expression: GPL-3.0-or-later
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: ext
+Requires-Dist: pyvista[trame]; extra == "ext"
+Requires-Dist: trame; extra == "ext"
+Requires-Dist: numpy; extra == "ext"
+Requires-Dist: tqdm; extra == "ext"
+Dynamic: license-file
+
+# Jerboapy
+
+This project is a port of the Jerboa C++ implementation to Python. It is a pybind11 binding to the Jerboa C++ library, which is located in the `jerboa-cpp` directory. The goal of this project is to provide a Python interface for users who prefer to work in Python while leveraging the performance and capabilities of the Jerboa C++ library.
+
+Currently it proves a 3D modeler (understanding that there is an alpha_3 links in their gmaps). 
+
+## Installation
+
+
+To install the required dependencies, run:
+
+```bash
+pip install jerboapy
+```
+
+### Optional: 3D visualization and advanced features
+
+If you want to use the 3D visualization features and advanced coordinate/color classes, install the extra `ext`:
+
+```bash
+pip install jerboapy[ext]
+```
+
+This will install additional dependencies for graphical display and advanced geometry. The extra `ext` enables:
+
+- **3D visualization** (with PyVista and Trame)
+- The module `jerboa_ext` with:
+  - `Point3`: class for 3D coordinates
+  - `Color4`: class for RGBA color management
+
+You can then use these classes for embedding coordinates and managing colors in your models.
+
+## Usage
+
+Provide an example of how to use your project:
+
+```python
+from jerboapy import *
+
+# Example usage
+modeler = Modeler3D()
+```

jerboapy-0.2rc332.dist-info/RECORD

@@ -0,0 +1,15 @@
+jerboapy/__init__.py,sha256=BwH2vmd8gtuluqjBRAOh47eFE3_RNBMxd3E7dwy65W0,1364
+jerboapy/jerboapy_bin.cp311-win_amd64.pyd,sha256=jzW7WK3qRAkAEVA8uYkVSgSKIMxoTf1sSR1aDwPSgGQ,5337948
+jerboapy/jerboapy_bin.cp312-win_amd64.pyd,sha256=KPq85nb4gS70_vM7W18ChI8lr94m-2hZdKGDZGh93pE,5346094
+jerboapy/jerboapy_bin.cp313-win_amd64.pyd,sha256=KsQgXWS49ej5st1zKMHar6P3V1vVaz1B1aQtPZ5M6nw,5346092
+jerboapy-0.2rc332.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+jerboapy_ext/Color4.py,sha256=UjBUEZfNh1PIBjVzq1SoXc4CNc_eMGQW0ykqV1WL5OQ,4589
+jerboapy_ext/Point3.py,sha256=rvmwLO1PkbqDGQoZrjx8lKzlsCGbsXFOqqDQOAmsuOQ,7936
+jerboapy_ext/__init__.py,sha256=eBQcF_RN2xGtUv3VH4SLC4W9C6BbA0ocQA8V3j-c_kg,441
+jerboapy_ext/render.py,sha256=ass7pAWSg3-RuCEhs1Qw8Bx9mBjAiwjgmC6G0r5Z9n8,7525
+jerboapy_ext/rules.py,sha256=bVI3pwDn_zQnSTJVf9sLJYmDk7SNrTUVIU7dDFHcaYw,24112
+jerboapy_ext/utils.py,sha256=YV6e52wD3xDaD4IZbyw2RPVXOqn07Uena5rOaRZNO_s,6952
+jerboapy-0.2rc332.dist-info/METADATA,sha256=aIkkhV1rZYr28aHhfncoEcOjJmRlEue-Nl4ljgXhcqY,1810
+jerboapy-0.2rc332.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
+jerboapy-0.2rc332.dist-info/top_level.txt,sha256=Yp6MLfErdDW3Ysd_UZnBjTlaeLGx46jrJFqxU8-o1Q0,22
+jerboapy-0.2rc332.dist-info/RECORD,,

jerboapy-0.2rc332.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

jerboapy-0.2rc332.dist-info/licenses/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.

jerboapy-0.2rc332.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+jerboapy
+jerboapy_ext

jerboapy_ext/Color4.py

@@ -0,0 +1,175 @@
+import numpy as np
+from typing import List
+
+class Color4:
+    EPSILON = 1e-2
+    BRIGHTER = 20
+    DARKER = -20
+
+    # Pré-définition des couleurs standards
+    RED = None
+    GREEN = None
+    BLUE = None
+    LIGHTGRAY = None
+    BLACK = None
+    WHITE = None
+    MAGENTA = None
+    YELLOW = None
+    CYAN = None
+    GRAY = None
+    DARKGRAY = None
+    LIGHTGRAY = None
+    ORANGE = None
+    PINK = None
+    PURPLE = None
+    BROWN = None
+    LIME = None
+    TEAL = None
+    NAVY = None
+    OLIVE = None
+    SILVER = None
+    GOLD = None
+    CORAL = None
+    INDIGO = None
+    LAVENDER = None
+    MAROON = None
+    CHOCOLATE = None
+    SALMON = None
+    SKYBLUE = None
+    IVORY = None
+    AQUA = None
+
+    def __init__(self, r: float, g: float, b: float, a: float = 1.0):
+        self.rgba = np.array([r, g, b, a], dtype=np.float32)
+
+    def copy(self) -> 'Color4':
+        return Color4(*self.rgba)
+
+    def toNumpy(self) -> np.ndarray:
+        return self.rgba
+
+    def r(self) -> float:
+        return self.rgba[0]
+
+    def g(self) -> float:
+        return self.rgba[1]
+
+    def b(self) -> float:
+        return self.rgba[2]
+
+    def a(self) -> float:
+        return self.rgba[3]
+
+    def getR(self) -> float:
+        return self.r()
+
+    def setR(self, r: float):
+        self.rgba[0] = r
+
+    def getG(self) -> float:
+        return self.g()
+
+    def setG(self, g: float):
+        self.rgba[1] = g
+
+    def getB(self) -> float:
+        return self.b()
+
+    def setB(self, b: float):
+        self.rgba[2] = b
+
+    def getA(self) -> float:
+        return self.a()
+
+    def setA(self, a: float):
+        self.rgba[3] = a
+
+    def setRGB(self, r: float, g: float, b: float, a: float = None):
+        self.rgba[:3] = [r, g, b]
+        if a is not None:
+            self.rgba[3] = a
+
+    def equals(self, obj: object) -> bool:
+        if not isinstance(obj, Color4):
+            return False
+        return np.allclose(self.rgba, obj.rgba, atol=self.EPSILON)
+
+    @staticmethod
+    def middle(a: 'Color4', b: 'Color4') -> 'Color4':
+        return Color4(*(a.rgba + b.rgba) / 2)
+
+    @staticmethod
+    def middle_list(colors: List['Color4']) -> 'Color4':
+        rgba_sum = np.sum([color.rgba for color in colors], axis=0)
+        return Color4(*(rgba_sum / len(colors)))
+
+    def __str__(self) -> str:
+        return f"Color4(r={self.r()}, g={self.g()}, b={self.b()}, a={self.a()})"
+
+    @staticmethod
+    def make(r: float, g: float, b: float, a: float = 1.0) -> 'Color4':
+        return Color4(r, g, b, a)
+
+    @staticmethod
+    def randomColor() -> 'Color4':
+        return Color4(*np.random.rand(3), 1.0)
+
+    @staticmethod
+    def darker(color: 'Color4') -> 'Color4':
+        factor = 0.8
+        return Color4(*(color.rgba[:3] * factor), color.a())
+
+    def brighter(self, i: float = 1.2) -> 'Color4':
+        return Color4(
+            *np.clip(self.rgba[:3] * i, 0.0, 1.0),
+            self.a()
+        )
+
+    def toGray(self) -> 'Color4':
+        gray = 0.299 * self.r() + 0.587 * self.g() + 0.114 * self.b()
+        return Color4(gray, gray, gray, self.a())
+
+    def scale(self, d: float):
+        self.rgba[:3] *= d
+
+    def scaleAdd(self, r: float):
+        self.rgba[:3] += r
+
+    def compareTo(self, o: 'Color4') -> int:
+        if self.equals(o):
+            return 0
+        return -1 if np.sum(self.rgba[:3]) < np.sum(o.rgba[:3]) else 1
+
+
+# Initialisation des couleurs standards
+Color4.RED = Color4(1.0, 0.0, 0.0)
+Color4.GREEN = Color4(0.0, 1.0, 0.0)
+Color4.BLUE = Color4(0.0, 0.0, 1.0)
+Color4.LIGHTGRAY = Color4(0.5, 0.5, 0.5)
+Color4.BLACK = Color4(0.0, 0.0, 0.0)
+Color4.WHITE = Color4(1.0, 1.0, 1.0)
+Color4.MAGENTA = Color4(1.0, 0.0, 1.0)
+Color4.YELLOW = Color4(1.0, 1.0, 0.0)
+Color4.CYAN = Color4(0.0, 1.0, 1.0)
+Color4.GRAY = Color4(0.5, 0.5, 0.5)
+Color4.DARKGRAY = Color4(0.25, 0.25, 0.25)
+Color4.LIGHTGRAY = Color4(0.75, 0.75, 0.75)
+Color4.ORANGE = Color4(1.0, 0.5, 0.0)
+Color4.PINK = Color4(1.0, 0.75, 0.8)
+Color4.PURPLE = Color4(0.5, 0.0, 0.5)
+Color4.BROWN = Color4(0.65, 0.16, 0.16)
+Color4.LIME = Color4(0.0, 1.0, 0.0)
+Color4.TEAL = Color4(0.0, 0.5, 0.5)
+Color4.NAVY = Color4(0.0, 0.0, 0.5)
+Color4.OLIVE = Color4(0.5, 0.5, 0.0)
+Color4.SILVER = Color4(0.75, 0.75, 0.75)
+Color4.GOLD = Color4(1.0, 0.84, 0.0)
+Color4.CORAL = Color4(1.0, 0.5, 0.31)
+Color4.INDIGO = Color4(0.29, 0.0, 0.51)
+Color4.LAVENDER = Color4(0.9, 0.9, 0.98)
+Color4.MAROON = Color4(0.5, 0.0, 0.0)
+Color4.CHOCOLATE = Color4(0.82, 0.41, 0.12)
+Color4.SALMON = Color4(0.98, 0.5, 0.45)
+Color4.SKYBLUE = Color4(0.53, 0.81, 0.92)
+Color4.IVORY = Color4(1.0, 1.0, 0.94)
+Color4.AQUA = Color4(0.0, 1.0, 1.0)

jerboapy_ext/Point3.py

@@ -0,0 +1,231 @@
+import numpy as np
+from typing import List, Collection, Union, Set
+
+class Point3:
+    EPSILON = 1e-3
+    sqrt2 = np.sqrt(2.0)
+    sqrt1_2 = 1.0 / sqrt2
+    ZERO = None  # Will be initialized later as Point3(0, 0, 0)
+    PI = 3.141592653589793
+
+    def __init__(self, x=0.0, y=None, z=None):
+        if isinstance(x, Point3) and isinstance(y, Point3):
+            # Cas où deux objets Point3 sont passés
+            a, b = x, y
+            self.x = b.x - a.x
+            self.y = b.y - a.y
+            self.z = b.z - a.z
+        elif y is None and z is None:
+            # Cas où un seul argument est passé (x, y, z par défaut à 0.0)
+            self.x = x
+            self.y = 0.0
+            self.z = 0.0
+        else:
+            # Cas où trois arguments sont passés
+            self.x = x
+            self.y = y
+            self.z = z
+
+    def toNumpy(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z], dtype=np.float32)
+
+    @staticmethod
+    def toDegree(rad: float) -> float:
+        return np.degrees(rad)
+
+    @staticmethod
+    def toRadian(deg: float) -> float:
+        return np.radians(deg)
+
+    @staticmethod
+    def CentreCercle3Point(a: 'Point3', b: 'Point3', c: 'Point3') -> 'Point3':
+        # Calculate the midpoints of AB and BC
+        mid_ab = Point3.linear(a, b, 0.5)
+        mid_bc = Point3.linear(b, c, 0.5)
+
+        # Calculate the normal vectors to AB and BC
+        ab = b.sub(a)
+        bc = c.sub(b)
+        normal_ab = Point3(-ab.y, ab.x, 0)
+        normal_bc = Point3(-bc.y, bc.x, 0)
+
+        # Solve for the intersection of the two lines
+        # Line 1: mid_ab + t * normal_ab
+        # Line 2: mid_bc + s * normal_bc
+        # We solve for t and s such that the two lines intersect
+        A = np.array([
+            [normal_ab.x, -normal_bc.x],
+            [normal_ab.y, -normal_bc.y]
+        ])
+        B = np.array([
+            mid_bc.x - mid_ab.x,
+            mid_bc.y - mid_ab.y
+        ])
+
+        try:
+            t, _ = np.linalg.solve(A, B)
+        except np.linalg.LinAlgError:
+            raise ValueError("The points are collinear and do not define a unique circle.")
+
+        # Calculate the center of the circle
+        center = Point3(
+            mid_ab.x + t * normal_ab.x,
+            mid_ab.y + t * normal_ab.y,
+            0
+        )
+        return center
+
+    def equals(self, o: object) -> bool:
+        if not isinstance(o, Point3):
+            return False
+        return np.isclose(self.x, o.x, atol=self.EPSILON) and \
+               np.isclose(self.y, o.y, atol=self.EPSILON) and \
+               np.isclose(self.z, o.z, atol=self.EPSILON)
+
+    def get(self, i: int) -> float:
+        return [self.x, self.y, self.z][i]
+
+    def add(self, p: 'Point3') -> 'Point3':
+        # print(f"Adding Point3: ({self.x}, {self.y}, {self.z}) + ({p.x}, {p.y}, {p.z})")
+        return Point3(self.x + p.x, self.y + p.y, self.z + p.z)
+
+    def add_const(self, n: 'Point3') -> 'Point3':
+        return self.add(n)
+
+    def sub(self, p: 'Point3') -> 'Point3':
+        return Point3(self.x - p.x, self.y - p.y, self.z - p.z)
+
+    def scale(self, v: float) -> 'Point3':
+        # print(f"Scaling Point3: ({self.x}, {self.y}, {self.z}) by {v}")
+        return Point3(self.x * v, self.y * v, self.z * v)
+
+    def div(self, v: float) -> 'Point3':
+        return Point3(self.x / v, self.y / v, self.z / v)
+
+    def dot(self, p: 'Point3') -> float:
+        return self.x * p.x + self.y * p.y + self.z * p.z
+
+    def cross(self, v: 'Point3') -> 'Point3':
+        cross_product = np.cross([self.x, self.y, self.z], [v.x, v.y, v.z])
+        return Point3(*cross_product)
+
+    def norm(self) -> float:
+        return np.sqrt(self.x**2 + self.y**2 + self.z**2)
+
+    def norm2(self) -> float:
+        return self.x**2 + self.y**2 + self.z**2
+
+    def normalize(self):
+        n = self.norm()
+        if n > 0:
+            self.x /= n
+            self.y /= n
+            self.z /= n
+        return self
+
+    def distance(self, p: 'Point3') -> float:
+        return np.sqrt((self.x - p.x)**2 + (self.y - p.y)**2 + (self.z - p.z)**2)
+
+    def copy(self) -> 'Point3':
+        return Point3(self.x, self.y, self.z)
+
+    def __str__(self) -> str:
+        return f"Point3({self.x}, {self.y}, {self.z})"
+
+    @staticmethod
+    def middle(points: Union[List['Point3'], Collection['Point3'], 'Point3']) -> 'Point3':
+        if isinstance(points, Point3):
+            # Si un seul point est fourni, on le retourne directement
+            return points
+        elif isinstance(points, (list, set, tuple)):
+            # Si une collection de points est fournie, on calcule le barycentre
+            x_sum = sum(p.x for p in points)
+            y_sum = sum(p.y for p in points)
+            z_sum = sum(p.z for p in points)
+            count = len(points)
+            if count == 0:
+                raise ValueError("La collection de points est vide.")
+            return Point3(x_sum / count, y_sum / count, z_sum / count)
+        else:
+            raise TypeError("L'argument doit être un Point3 ou une collection de Point3.")
+
+    @staticmethod
+    def barycenter(a: 'Point3', ca: float, b: 'Point3', cb: float) -> 'Point3':
+        total_weight = ca + cb
+        if total_weight == 0:
+            raise ValueError("The sum of weights (ca + cb) must not be zero.")
+        x = (a.x * ca + b.x * cb) / total_weight
+        y = (a.y * ca + b.y * cb) / total_weight
+        z = (a.z * ca + b.z * cb) / total_weight
+        return Point3(x, y, z)
+
+    @staticmethod
+    def clamp(val: float, min_val: float, max_val: float) -> float:
+        return max(min(val, max_val), min_val)
+
+    def isInside(self, a: 'Point3', b: 'Point3') -> bool:
+        return a.x <= self.x <= b.x and a.y <= self.y <= b.y and a.z <= self.z <= b.z
+
+    def compareTo(self, o: 'Point3') -> int:
+        if self.equals(o):
+            return 0
+        return -1 if self.norm() < o.norm() else 1
+
+    @staticmethod
+    def min(a: 'Point3', b: 'Point3') -> 'Point3':
+        return Point3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z))
+
+    @staticmethod
+    def max(a: 'Point3', b: 'Point3') -> 'Point3':
+        return Point3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z))
+
+    @staticmethod
+    def linear(a: 'Point3', b: 'Point3', k: float) -> 'Point3':
+        return Point3(a.x + k * (b.x - a.x), a.y + k * (b.y - a.y), a.z + k * (b.z - a.z))
+    
+    def __add__(self, other):
+        if isinstance(other, Point3):
+            return Point3(self.x + other.x, self.y + other.y, self.z + other.z)
+        return NotImplemented
+
+    def __sub__(self, other):
+        if isinstance(other, Point3):
+            return Point3(self.x - other.x, self.y - other.y, self.z - other.z)
+        return NotImplemented
+
+    def __mul__(self, other):
+        if isinstance(other, (int, float)):
+            return Point3(self.x * other, self.y * other, self.z * other)
+        return NotImplemented
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        if isinstance(other, (int, float)):
+            return Point3(self.x / other, self.y / other, self.z / other)
+        return NotImplemented
+
+    def __eq__(self, other):
+        if not isinstance(other, Point3):
+            return False
+        return self.equals(other)
+
+    def __neg__(self):
+        return Point3(-self.x, -self.y, -self.z)
+    def __iter__(self):
+        yield self.x
+        yield self.y
+        yield self.z
+    def __array__(self, dtype=None):
+        if dtype is None:
+            dtype = np.float32
+        return np.array([self.x, self.y, self.z], dtype=dtype)
+
+    # def __add__(self, other):
+    #     if isinstance(other, Point3):
+    #         return Point3(self.x + other.x, self.y + other.y, self.z + other.z)
+    #     raise TypeError("Unsupported operand type(s) for +: 'Point3' and '{}'".format(type(other).__name__))
+
+# Initialize the ZERO constant
+Point3.ZERO = Point3(0.0, 0.0, 0.0)