Implementing Line and Segment classes

src/ansys/geometry/core/__init__.py

@@ -13,6 +13,7 @@
     import importlib_metadata
 
 __version__ = importlib_metadata.version(__name__.replace(".", "-"))
+"""The installed version of PyGeometry."""
 
 
 # Units

src/ansys/geometry/core/misc/__init__.py

@@ -2,15 +2,25 @@
 from ansys.geometry.core.misc.checks import (
     check_is_float_int,
     check_is_pint_unit,
+    check_is_point,
+    check_is_unitvector,
+    check_is_vector,
     check_ndarray_is_float_int,
+    check_ndarray_is_non_none,
+    check_ndarray_is_non_zero,
     check_pint_unit_compatibility,
     check_type_equivalence,
 )
 
 __all__ = [
     "check_is_float_int",
     "check_is_pint_unit",
+    "check_is_point",
+    "check_is_vector",
+    "check_is_unitvector",
+    "check_ndarray_is_float_int",
+    "check_ndarray_is_non_none",
+    "check_ndarray_is_non_zero",
     "check_pint_unit_compatibility",
     "check_type_equivalence",
-    "check_ndarray_is_float_int",
 ]

src/ansys/geometry/core/misc/checks.py

@@ -30,6 +30,102 @@ def check_is_float_int(param: object, param_name: Optional[Union[str, None]] = N
         )
 
 
+def check_is_point(
+    param: object, param_name: Optional[Union[str, None]] = None, only_3d: bool = False
+) -> None:
+    """
+    Checks if the parameter provided is a ``Point3D`` or ``Point2D``.
+
+    Parameters
+    ----------
+    param : object
+        Object instance to be checked.
+    param_name : str or None, optional
+        The object instance name (if any). By default, ``None``.
+    only_3d : bool
+        Only consider ``Point3D`` for checking.
+
+    Raises
+    ------
+    TypeError
+        In case the parameter is not a ``Point3D`` or a ``Point2D``.
+    """
+    from ansys.geometry.core.primitives.point import Point2D, Point3D
+
+    consider = (Point3D) if only_3d else (Point2D, Point3D)
+    point_type = "Point3D" if only_3d else "Point3D or Point2D"
+    if not isinstance(param, consider):
+        raise TypeError(
+            f"The parameter provided should be a {point_type} object."
+            if param_name is None
+            else f"The parameter '{param_name}' should be a {point_type} object."
+        )
+
+
+def check_is_vector(
+    param: object, param_name: Optional[Union[str, None]] = None, only_3d: bool = False
+) -> None:
+    """
+    Checks if the parameter provided is a ``Vector3D`` or ``Vector2D``.
+
+    Parameters
+    ----------
+    param : object
+        Object instance to be checked.
+    param_name : str or None, optional
+        The object instance name (if any). By default, ``None``.
+    only_3d : bool
+        Only consider ``Vector3D`` for checking.
+
+    Raises
+    ------
+    TypeError
+        In case the parameter is not a ``Vector3D`` or a ``Vector2D``.
+    """
+    from ansys.geometry.core.primitives.vector import Vector2D, Vector3D
+
+    consider = (Vector3D) if only_3d else (Vector2D, Vector3D)
+    point_type = "Vector3D" if only_3d else "Vector3D or Vector2D"
+    if not isinstance(param, consider):
+        raise TypeError(
+            f"The parameter provided should be a {point_type} object."
+            if param_name is None
+            else f"The parameter '{param_name}' should be a {point_type} object."
+        )
+
+
+def check_is_unitvector(
+    param: object, param_name: Optional[Union[str, None]] = None, only_3d: bool = False
+) -> None:
+    """
+    Checks if the parameter provided is a ``UnitVector3D`` or ``UnitVector2D``.
+
+    Parameters
+    ----------
+    param : object
+        Object instance to be checked.
+    param_name : str or None, optional
+        The object instance name (if any). By default, ``None``.
+    only_3d : bool
+        Only consider ``UnitVector3D`` for checking.
+
+    Raises
+    ------
+    TypeError
+        In case the parameter is not a ``UnitVector3D`` or a ``UnitVector2D``.
+    """
+    from ansys.geometry.core.primitives.vector import UnitVector2D, UnitVector3D
+
+    consider = (UnitVector3D) if only_3d else (UnitVector2D, UnitVector3D)
+    point_type = "UnitVector3D" if only_3d else "UnitVector3D or UnitVector2D"
+    if not isinstance(param, consider):
+        raise TypeError(
+            f"The parameter provided should be a {point_type} object."
+            if param_name is None
+            else f"The parameter '{param_name}' should be a {point_type} object."
+        )
+
+
 def check_ndarray_is_float_int(
     param: np.ndarray, param_name: Optional[Union[str, None]] = None
 ) -> None:
@@ -59,6 +155,58 @@ def check_ndarray_is_float_int(
         )
 
 
+def check_ndarray_is_non_none(
+    param: np.ndarray, param_name: Optional[Union[str, None]] = None
+) -> None:
+    """
+    Checks if the :class:`numpy.ndarray` is not None-valued.
+
+    Parameters
+    ----------
+    param : ~numpy.ndarray
+        :class:`numpy.ndarray` instance to be checked.
+    param_name : str or None, optional
+        The :class:`numpy.ndarray` instance name (if any). By default, ``None``.
+
+    Raises
+    ------
+    TypeError
+        In case the :class:`numpy.ndarray` is None-valued.
+    """
+    if all(value == None for value in param):
+        raise ValueError(
+            f"The numpy.ndarray provided should not be a None numpy.ndarray."
+            if param_name is None
+            else f"The numpy.ndarray '{param_name}' should not be a None numpy.ndarray."
+        )
+
+
+def check_ndarray_is_non_zero(
+    param: np.ndarray, param_name: Optional[Union[str, None]] = None
+) -> None:
+    """
+    Checks if the :class:`numpy.ndarray` is not zero-valued.
+
+    Parameters
+    ----------
+    param : ~numpy.ndarray
+        :class:`numpy.ndarray` instance to be checked.
+    param_name : str or None, optional
+        The :class:`numpy.ndarray` instance name (if any). By default, ``None``.
+
+    Raises
+    ------
+    TypeError
+        In case the :class:`numpy.ndarray` is zero-valued.
+    """
+    if all(value == 0 for value in param):
+        raise ValueError(
+            f"The numpy.ndarray provided should not be a zeroes numpy.ndarray."
+            if param_name is None
+            else f"The numpy.ndarray '{param_name}' should not be a zeroes numpy.ndarray."
+        )
+
+
 def check_is_pint_unit(param: object, param_name: Optional[Union[str, None]] = None) -> None:
     """
     Checks if the parameter provided is a :class:`pint.Unit`.

src/ansys/geometry/core/primitives/vector.py

@@ -90,10 +90,18 @@ def __ne__(self, other: "Vector3D") -> bool:
         """Not equals operator for ``Vector3D``."""
         return not self == other
 
-    def __mul__(self, other: "Vector3D") -> Real:
-        """Overload * operator with dot product."""
-        check_type_equivalence(other, self)
-        return self.dot(other)
+    def __mul__(self, other: Union["Vector3D", Real]) -> Real:
+        """Overload * operator with dot product.
+
+        Note
+        ----
+        Also admits scalar multiplication.
+        """
+        if isinstance(other, (int, float)):
+            return np.multiply(self, other)
+        else:
+            check_type_equivalence(other, self)
+            return self.dot(other)
 
     def __mod__(self, other: "Vector3D") -> "Vector3D":
         """Overload % operator with cross product."""
@@ -165,9 +173,17 @@ def __ne__(self, other: "Vector2D") -> bool:
         return not self == other
 
     def __mul__(self, other: "Vector2D") -> Real:
-        """Overload * operator with dot product."""
-        check_type_equivalence(other, self)
-        return self.dot(other)
+        """Overload * operator with dot product.
+
+        Note
+        ----
+        Also admits scalar multiplication.
+        """
+        if isinstance(other, (int, float)):
+            return np.multiply(self, other)
+        else:
+            check_type_equivalence(other, self)
+            return self.dot(other)
 
 
 class UnitVector3D(Vector3D):

src/ansys/geometry/core/sketch/__init__.py

@@ -1,7 +1,7 @@
 """PyGeometry sketching subpackage."""
 
 from ansys.geometry.core.sketch.circle import CircleSketch
-from ansys.geometry.core.sketch.line import LineSketch
+from ansys.geometry.core.sketch.line import Line, Segment
 from ansys.geometry.core.sketch.sketch import Sketch
 
-__all__ = ["Sketch", "CircleSketch", "LineSketch"]
+__all__ = ["Sketch", "CircleSketch", "Line", "Segment"]

src/ansys/geometry/core/sketch/curve.py

@@ -17,7 +17,7 @@ def __init__(self, points: Sequence[Point2D], origin: Point2D):
         points : Sequence[Point2D]
             A list of points defining the sketch curve.
         origin : Point2D
-            A ``Point2D`` representing the origin of the ellipse.
+            A ``Point2D`` representing the origin of the curve.
 
         """
         self._points = points
@@ -42,7 +42,7 @@ def origin(self) -> Point2D:
         Returns
         -------
         Point2D
-            A ``Point2D`` instance representing the center of the sketch curve
+            A ``Point2D`` instance representing the center of the sketch curve.
 
         """
         return self._origin