egeometry 0.2.0__tar.gz → 0.3.0__tar.gz

{egeometry-0.2.0 → egeometry-0.3.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: egeometry
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python geometry library.
 Author: Erik Soma
 Author-email: stillusingirc@gmail.com
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: emath (>=0.1.10,<0.2.0)
+Requires-Dist: emath (>=0.1.13,<0.2.0)

{egeometry-0.2.0 → egeometry-0.3.0}/pyproject.toml

@@ -1,16 +1,16 @@
 [tool.poetry]
 name = "egeometry"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python geometry library."
 authors = ["Erik Soma <stillusingirc@gmail.com>"]
 
 [tool.poetry.build]
 generate-setup-file = false
-script = "build.py"
+script = "buildscript.py"
 
 [tool.poetry.dependencies]
 python = "^3.12"
-emath = "^0.1.10"
+emath = "^0.1.13"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "7.4.3"

egeometry-0.3.0/src/egeometry/__init__.py

@@ -0,0 +1,33 @@
+# generated from codegen/templates/__init__.py
+
+from __future__ import annotations
+
+__all__ = [
+    "DRectangle",
+    "DRectangleOverlappable",
+    "FRectangle",
+    "FRectangleOverlappable",
+    "IRectangle",
+    "IRectangleOverlappable",
+    "DCircle",
+    "DCircleOverlappable",
+    "FCircle",
+    "FCircleOverlappable",
+    "ICircle",
+    "ICircleOverlappable",
+]
+
+
+# egeometry
+from ._dcircle import DCircle
+from ._dcircle import DCircleOverlappable
+from ._drectangle import DRectangle
+from ._drectangle import DRectangleOverlappable
+from ._fcircle import FCircle
+from ._fcircle import FCircleOverlappable
+from ._frectangle import FRectangle
+from ._frectangle import FRectangleOverlappable
+from ._icircle import ICircle
+from ._icircle import ICircleOverlappable
+from ._irectangle import IRectangle
+from ._irectangle import IRectangleOverlappable

egeometry-0.3.0/src/egeometry/_dcircle.py

@@ -0,0 +1,79 @@
+# generated from codegen/templates/_circle.py
+
+from __future__ import annotations
+
+__all__ = ["DCircle", "DCircleOverlappable"]
+
+# egeometry
+from ._drectangle import DRectangle
+
+# emath
+from emath import DVector2
+
+# python
+from typing import Protocol
+
+
+class DCircleOverlappable(Protocol):
+    def overlaps_d_circle(self, other: DCircle) -> bool:
+        ...
+
+
+class DCircle:
+    __slots__ = ["_bounding_box", "_position", "_radius"]
+
+    def __init__(self, position: DVector2, radius: float):
+        if radius <= 0:
+            raise ValueError("radius must be > 0")
+        self._position = position
+        self._radius = radius
+        self._bounding_box = DRectangle(position - radius, DVector2(radius * 2))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DCircle):
+            return False
+        return self._position == other._position and self._radius == other._radius
+
+    def overlaps(self, other: DVector2 | DCircleOverlappable) -> bool:
+        if isinstance(other, DVector2):
+            return self.overlaps_d_vector_2(other)
+        try:
+            other_overlaps = other.overlaps_d_circle
+        except AttributeError:
+            raise TypeError(other)
+        return other_overlaps(self)
+
+    def overlaps_d_circle(self, other: DCircle) -> bool:
+        min_distance = self._radius + other._radius
+        distance = round(DVector2(*self._position).distance(DVector2(*other._position)))
+        return distance < min_distance
+
+    def overlaps_d_rectangle(self, other: DRectangle) -> bool:
+        rect_center = DVector2(*other.position) + (DVector2(*other.size) * 0.5)
+        f_position = DVector2(*self._position)
+        diff = f_position - rect_center
+        closest_rect_point = DVector2(
+            min(max(diff.x, other.position.x), other.extent.x),
+            min(max(diff.y, other.position.y), other.extent.y),
+        )
+        closest_rect_point_distance = round(f_position.distance(closest_rect_point))
+        return closest_rect_point_distance < self._radius
+
+    def overlaps_d_vector_2(self, other: DVector2) -> bool:
+        distance = round(DVector2(*self._position).distance(DVector2(*other)))
+        return distance < self._radius
+
+    def translate(self, translation: DVector2) -> DCircle:
+        return DCircle(self._position + translation, self._radius)
+
+    @property
+    def bounding_box(self) -> DRectangle:
+        return self._bounding_box
+
+    @property
+    def position(self) -> DVector2:
+        return self._position
+
+    @property
+    def radius(self) -> float:
+        return self._radius

egeometry-0.3.0/src/egeometry/_drectangle.py

@@ -0,0 +1,84 @@
+# generated from codegen/templates/_rectangle.py
+
+from __future__ import annotations
+
+__all__ = ["DRectangle", "DRectangleOverlappable"]
+
+# emath
+from emath import DVector2
+
+# python
+from typing import Protocol
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # egeometry
+    from ._dcircle import DCircle
+
+
+class DRectangleOverlappable(Protocol):
+    def overlaps_d_rectangle(self, other: DRectangle) -> bool:
+        ...
+
+
+class DRectangle:
+    __slots__ = ["_extent", "_position", "_size"]
+
+    def __init__(self, position: DVector2, size: DVector2):
+        if size <= DVector2(0):
+            raise ValueError("each size dimension must be > 0")
+        self._position = position
+        self._size = size
+        self._extent = self._position + self._size
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DRectangle):
+            return False
+        return self._position == other._position and self._size == other._size
+
+    def overlaps(self, other: DVector2 | DRectangleOverlappable) -> bool:
+        if isinstance(other, DVector2):
+            return self.overlaps_d_vector_2(other)
+        try:
+            other_overlaps = other.overlaps_d_rectangle
+        except AttributeError:
+            raise TypeError(other)
+        return other_overlaps(self)
+
+    def overlaps_d_circle(self, other: DCircle) -> bool:
+        return other.overlaps_d_rectangle(self)
+
+    def overlaps_d_rectangle(self, other: DRectangle) -> bool:
+        return not (
+            self._position.x >= other._extent.x
+            or self._extent.x <= other._position.x
+            or self._position.y >= other._extent.y
+            or self._extent.y <= other._position.y
+        )
+
+    def overlaps_d_vector_2(self, other: DVector2) -> bool:
+        return (
+            other.x >= self._position.x
+            and other.x < self._extent.x
+            and other.y >= self._position.y
+            and other.y < self._extent.y
+        )
+
+    def translate(self, translation: DVector2) -> DRectangle:
+        return DRectangle(self._position + translation, self._size)
+
+    @property
+    def bounding_box(self) -> DRectangle:
+        return self
+
+    @property
+    def extent(self) -> DVector2:
+        return self._extent
+
+    @property
+    def position(self) -> DVector2:
+        return self._position
+
+    @property
+    def size(self) -> DVector2:
+        return self._size

egeometry-0.3.0/src/egeometry/_fcircle.py

@@ -0,0 +1,80 @@
+# generated from codegen/templates/_circle.py
+
+from __future__ import annotations
+
+__all__ = ["FCircle", "FCircleOverlappable"]
+
+# egeometry
+from ._frectangle import FRectangle
+
+# emath
+from emath import DVector2
+from emath import FVector2
+
+# python
+from typing import Protocol
+
+
+class FCircleOverlappable(Protocol):
+    def overlaps_f_circle(self, other: FCircle) -> bool:
+        ...
+
+
+class FCircle:
+    __slots__ = ["_bounding_box", "_position", "_radius"]
+
+    def __init__(self, position: FVector2, radius: float):
+        if radius <= 0:
+            raise ValueError("radius must be > 0")
+        self._position = position
+        self._radius = radius
+        self._bounding_box = FRectangle(position - radius, FVector2(radius * 2))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FCircle):
+            return False
+        return self._position == other._position and self._radius == other._radius
+
+    def overlaps(self, other: FVector2 | FCircleOverlappable) -> bool:
+        if isinstance(other, FVector2):
+            return self.overlaps_f_vector_2(other)
+        try:
+            other_overlaps = other.overlaps_f_circle
+        except AttributeError:
+            raise TypeError(other)
+        return other_overlaps(self)
+
+    def overlaps_f_circle(self, other: FCircle) -> bool:
+        min_distance = self._radius + other._radius
+        distance = round(DVector2(*self._position).distance(DVector2(*other._position)))
+        return distance < min_distance
+
+    def overlaps_f_rectangle(self, other: FRectangle) -> bool:
+        rect_center = DVector2(*other.position) + (DVector2(*other.size) * 0.5)
+        f_position = DVector2(*self._position)
+        diff = f_position - rect_center
+        closest_rect_point = DVector2(
+            min(max(diff.x, other.position.x), other.extent.x),
+            min(max(diff.y, other.position.y), other.extent.y),
+        )
+        closest_rect_point_distance = round(f_position.distance(closest_rect_point))
+        return closest_rect_point_distance < self._radius
+
+    def overlaps_f_vector_2(self, other: FVector2) -> bool:
+        distance = round(DVector2(*self._position).distance(DVector2(*other)))
+        return distance < self._radius
+
+    def translate(self, translation: FVector2) -> FCircle:
+        return FCircle(self._position + translation, self._radius)
+
+    @property
+    def bounding_box(self) -> FRectangle:
+        return self._bounding_box
+
+    @property
+    def position(self) -> FVector2:
+        return self._position
+
+    @property
+    def radius(self) -> float:
+        return self._radius

egeometry-0.3.0/src/egeometry/_frectangle.py

@@ -0,0 +1,84 @@
+# generated from codegen/templates/_rectangle.py
+
+from __future__ import annotations
+
+__all__ = ["FRectangle", "FRectangleOverlappable"]
+
+# emath
+from emath import FVector2
+
+# python
+from typing import Protocol
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # egeometry
+    from ._fcircle import FCircle
+
+
+class FRectangleOverlappable(Protocol):
+    def overlaps_f_rectangle(self, other: FRectangle) -> bool:
+        ...
+
+
+class FRectangle:
+    __slots__ = ["_extent", "_position", "_size"]
+
+    def __init__(self, position: FVector2, size: FVector2):
+        if size <= FVector2(0):
+            raise ValueError("each size dimension must be > 0")
+        self._position = position
+        self._size = size
+        self._extent = self._position + self._size
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FRectangle):
+            return False
+        return self._position == other._position and self._size == other._size
+
+    def overlaps(self, other: FVector2 | FRectangleOverlappable) -> bool:
+        if isinstance(other, FVector2):
+            return self.overlaps_f_vector_2(other)
+        try:
+            other_overlaps = other.overlaps_f_rectangle
+        except AttributeError:
+            raise TypeError(other)
+        return other_overlaps(self)
+
+    def overlaps_f_circle(self, other: FCircle) -> bool:
+        return other.overlaps_f_rectangle(self)
+
+    def overlaps_f_rectangle(self, other: FRectangle) -> bool:
+        return not (
+            self._position.x >= other._extent.x
+            or self._extent.x <= other._position.x
+            or self._position.y >= other._extent.y
+            or self._extent.y <= other._position.y
+        )
+
+    def overlaps_f_vector_2(self, other: FVector2) -> bool:
+        return (
+            other.x >= self._position.x
+            and other.x < self._extent.x
+            and other.y >= self._position.y
+            and other.y < self._extent.y
+        )
+
+    def translate(self, translation: FVector2) -> FRectangle:
+        return FRectangle(self._position + translation, self._size)
+
+    @property
+    def bounding_box(self) -> FRectangle:
+        return self
+
+    @property
+    def extent(self) -> FVector2:
+        return self._extent
+
+    @property
+    def position(self) -> FVector2:
+        return self._position
+
+    @property
+    def size(self) -> FVector2:
+        return self._size

egeometry-0.3.0/src/egeometry/_icircle.py

@@ -0,0 +1,80 @@
+# generated from codegen/templates/_circle.py
+
+from __future__ import annotations
+
+__all__ = ["ICircle", "ICircleOverlappable"]
+
+# egeometry
+from ._irectangle import IRectangle
+
+# emath
+from emath import DVector2
+from emath import IVector2
+
+# python
+from typing import Protocol
+
+
+class ICircleOverlappable(Protocol):
+    def overlaps_i_circle(self, other: ICircle) -> bool:
+        ...
+
+
+class ICircle:
+    __slots__ = ["_bounding_box", "_position", "_radius"]
+
+    def __init__(self, position: IVector2, radius: int):
+        if radius <= 0:
+            raise ValueError("radius must be > 0")
+        self._position = position
+        self._radius = radius
+        self._bounding_box = IRectangle(position - radius, IVector2(radius * 2))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ICircle):
+            return False
+        return self._position == other._position and self._radius == other._radius
+
+    def overlaps(self, other: IVector2 | ICircleOverlappable) -> bool:
+        if isinstance(other, IVector2):
+            return self.overlaps_i_vector_2(other)
+        try:
+            other_overlaps = other.overlaps_i_circle
+        except AttributeError:
+            raise TypeError(other)
+        return other_overlaps(self)
+
+    def overlaps_i_circle(self, other: ICircle) -> bool:
+        min_distance = self._radius + other._radius
+        distance = round(DVector2(*self._position).distance(DVector2(*other._position)))
+        return distance < min_distance
+
+    def overlaps_i_rectangle(self, other: IRectangle) -> bool:
+        rect_center = DVector2(*other.position) + (DVector2(*other.size) * 0.5)
+        f_position = DVector2(*self._position)
+        diff = f_position - rect_center
+        closest_rect_point = DVector2(
+            min(max(diff.x, other.position.x), other.extent.x),
+            min(max(diff.y, other.position.y), other.extent.y),
+        )
+        closest_rect_point_distance = round(f_position.distance(closest_rect_point))
+        return closest_rect_point_distance < self._radius
+
+    def overlaps_i_vector_2(self, other: IVector2) -> bool:
+        distance = round(DVector2(*self._position).distance(DVector2(*other)))
+        return distance < self._radius
+
+    def translate(self, translation: IVector2) -> ICircle:
+        return ICircle(self._position + translation, self._radius)
+
+    @property
+    def bounding_box(self) -> IRectangle:
+        return self._bounding_box
+
+    @property
+    def position(self) -> IVector2:
+        return self._position
+
+    @property
+    def radius(self) -> int:
+        return self._radius

egeometry-0.3.0/src/egeometry/_irectangle.py

@@ -0,0 +1,84 @@
+# generated from codegen/templates/_rectangle.py
+
+from __future__ import annotations
+
+__all__ = ["IRectangle", "IRectangleOverlappable"]
+
+# emath
+from emath import IVector2
+
+# python
+from typing import Protocol
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # egeometry
+    from ._icircle import ICircle
+
+
+class IRectangleOverlappable(Protocol):
+    def overlaps_i_rectangle(self, other: IRectangle) -> bool:
+        ...
+
+
+class IRectangle:
+    __slots__ = ["_extent", "_position", "_size"]
+
+    def __init__(self, position: IVector2, size: IVector2):
+        if size <= IVector2(0):
+            raise ValueError("each size dimension must be > 0")
+        self._position = position
+        self._size = size
+        self._extent = self._position + self._size
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, IRectangle):
+            return False
+        return self._position == other._position and self._size == other._size
+
+    def overlaps(self, other: IVector2 | IRectangleOverlappable) -> bool:
+        if isinstance(other, IVector2):
+            return self.overlaps_i_vector_2(other)
+        try:
+            other_overlaps = other.overlaps_i_rectangle
+        except AttributeError:
+            raise TypeError(other)
+        return other_overlaps(self)
+
+    def overlaps_i_circle(self, other: ICircle) -> bool:
+        return other.overlaps_i_rectangle(self)
+
+    def overlaps_i_rectangle(self, other: IRectangle) -> bool:
+        return not (
+            self._position.x >= other._extent.x
+            or self._extent.x <= other._position.x
+            or self._position.y >= other._extent.y
+            or self._extent.y <= other._position.y
+        )
+
+    def overlaps_i_vector_2(self, other: IVector2) -> bool:
+        return (
+            other.x >= self._position.x
+            and other.x < self._extent.x
+            and other.y >= self._position.y
+            and other.y < self._extent.y
+        )
+
+    def translate(self, translation: IVector2) -> IRectangle:
+        return IRectangle(self._position + translation, self._size)
+
+    @property
+    def bounding_box(self) -> IRectangle:
+        return self
+
+    @property
+    def extent(self) -> IVector2:
+        return self._extent
+
+    @property
+    def position(self) -> IVector2:
+        return self._position
+
+    @property
+    def size(self) -> IVector2:
+        return self._size

egeometry-0.2.0/build.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-__all__ = ()
-
-# egeometry
-# codegen
-from codegen import generate_geometry_files
-
-# python
-import os
-from pathlib import Path
-
-
-def _build() -> None:
-    if os.environ.get("EGEOMETRY_GENERATE_GEOMETRY_FILES", "1") == "1":
-        generate_geometry_files(Path("src/egeometry"))
-
-
-if __name__ == "__main__":
-    _build()

egeometry-0.2.0/src/egeometry/__init__.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-__all__ = [
-    "DRectangle2d",
-    "FRectangle2d",
-]
-
-
-# egeometry
-from ._drectangle2d import DRectangle2d
-from ._frectangle2d import FRectangle2d

egeometry-0.2.0/src/egeometry/_drectangle2d.py

@@ -1,40 +0,0 @@
-# generated from codegen/templates/_rectangle_2d.cpp
-
-from __future__ import annotations
-
-__all__ = ["DRectangle2d"]
-
-# emath
-from emath import DVector2
-
-
-class DRectangle2d:
-    __slots__ = ["_extent", "_position", "_size"]
-
-    def __init__(self, position: DVector2, size: DVector2):
-        if size <= DVector2(0):
-            raise ValueError("each size dimension must be > 0")
-        self._position = position
-        self._size = size
-        self._extent = self._position + self._size
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, DRectangle2d):
-            return False
-        return self._position == other._position and self._size == other._size
-
-    @property
-    def bounding_box(self) -> DRectangle2d:
-        return self
-
-    @property
-    def extent(self) -> DVector2:
-        return self._extent
-
-    @property
-    def position(self) -> DVector2:
-        return self._position
-
-    @property
-    def size(self) -> DVector2:
-        return self._size

egeometry-0.2.0/src/egeometry/_frectangle2d.py

@@ -1,40 +0,0 @@
-# generated from codegen/templates/_rectangle_2d.cpp
-
-from __future__ import annotations
-
-__all__ = ["FRectangle2d"]
-
-# emath
-from emath import FVector2
-
-
-class FRectangle2d:
-    __slots__ = ["_extent", "_position", "_size"]
-
-    def __init__(self, position: FVector2, size: FVector2):
-        if size <= FVector2(0):
-            raise ValueError("each size dimension must be > 0")
-        self._position = position
-        self._size = size
-        self._extent = self._position + self._size
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, FRectangle2d):
-            return False
-        return self._position == other._position and self._size == other._size
-
-    @property
-    def bounding_box(self) -> FRectangle2d:
-        return self
-
-    @property
-    def extent(self) -> FVector2:
-        return self._extent
-
-    @property
-    def position(self) -> FVector2:
-        return self._position
-
-    @property
-    def size(self) -> FVector2:
-        return self._size