geomlib 0.1.0__tar.gz

geomlib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victor Phung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

geomlib-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: geomlib
+Version: 0.1.0
+Summary: A computational geometry library for Python
+Author: Victor Phung
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.25
+Dynamic: license-file
+
+# geomlib
+
+A lightweight computational geometry library for Python.
+
+## Features
+
+- Points and vectors
+- Lines and segments
+- Circles
+- Triangle centers (incenter, circumcenter, orthocenter, Lemoine point)
+- Convex hull
+- Rotating calipers
+- Minimum bounding rectangle
+
+## Installation
+
+```bash
+pip install geomlib

geomlib-0.1.0/README.md

@@ -0,0 +1,18 @@
+# geomlib
+
+A lightweight computational geometry library for Python.
+
+## Features
+
+- Points and vectors
+- Lines and segments
+- Circles
+- Triangle centers (incenter, circumcenter, orthocenter, Lemoine point)
+- Convex hull
+- Rotating calipers
+- Minimum bounding rectangle
+
+## Installation
+
+```bash
+pip install geomlib

geomlib-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "geomlib"
+version = "0.1.0"
+description = "A computational geometry library for Python"
+readme = "README.md"
+authors = [{name="Victor Phung"}]
+license = {text = "MIT"}
+requires-python = ">=3.9"
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "numpy>=1.25",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

geomlib-0.1.0/setup.cfg

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

geomlib-0.1.0/src/geomlib/__init__.py

@@ -0,0 +1,24 @@
+from .point import Point
+from .line import Line
+from .circle import Circle
+from .triangle import Triangle
+from .vector import Vector
+from .segment import Segment
+from .polygon import Polygon
+
+from .utils import cross_product, is_collinear, is_concyclic, closest_pair
+
+# Expose the public API
+__all__ = [
+    "Point",
+    "Line",
+    "Circle",
+    "Triangle",
+    "Vector",
+    "Segment",
+    "Polygon",
+    "cross_product",
+    "is_collinear",
+    "is_concyclic",
+    "closest_pair"
+]

geomlib-0.1.0/src/geomlib/circle.py

@@ -0,0 +1,199 @@
+from geomlib.point import Point
+from geomlib.line import Line
+from geomlib.constants import EPS
+import math
+
+class Circle:
+    __slots__ = ['center', 'radius']
+    
+    def __init__(self, center: Point, radius: float):
+        if radius < 0:
+            raise ValueError("Radius must be non-negative")
+        self.center = center
+        self.radius = radius
+
+    @staticmethod
+    def from_points(p1: Point, p2: Point, p3: Point) -> 'Circle':
+        """
+        Returns a Circle object that passes through three points p1, p2, and p3.
+        """
+        A = 2 * (p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y))
+        if abs(A) < EPS:
+            raise ValueError("The three points are collinear.")
+        
+        B = (p1.x ** 2 + p1.y ** 2) * (p2.y - p3.y) + (p2.x ** 2 + p2.y ** 2) * (p3.y - p1.y) + (p3.x ** 2 + p3.y ** 2) * (p1.y - p2.y)
+        C = (p1.x ** 2 + p1.y ** 2) * (p3.x - p2.x) + (p2.x ** 2 + p2.y ** 2) * (p1.x - p3.x) + (p3.x ** 2 + p3.y ** 2) * (p2.x - p1.x)
+        
+        center_x = -B / A
+        center_y = -C / A
+        center = Point(center_x, center_y)
+        radius = center.distance_to(p1)
+        return Circle(center, radius)
+    
+    def diameter(self) -> float:
+        """
+        Returns the diameter of the circle.
+        """
+        return 2 * self.radius
+    
+    def point_at_angle(self, angle: float) -> Point:
+        """
+        Returns the point on the circle at the given angle (in radians).
+
+        Parameters
+        ----------
+        angle : float
+            The angle (in radians) at which to find the point.
+
+        Returns
+        -------
+        Point
+            The point on the circle at the given angle.
+        """
+        return Point(
+            self.center.x + self.radius * math.cos(angle),
+            self.center.y + self.radius * math.sin(angle)
+        )
+    
+    def arc_length(self, angle: float) -> float:
+        """
+        Parameters
+        ----------
+        angle : float
+            The angle (in radians) of the arc.
+
+        Returns
+        -------
+        float
+            The length of the arc.
+        """
+        return self.radius * angle
+
+    def get_intersection(self, other: 'Circle') -> list[Point]:
+        """
+        Find the intersections of two circles.
+
+        Parameters
+        ----------
+        other : Circle
+            The other circle to find the intersections with.
+
+        Returns
+        -------
+        list[Point]
+            A list of up to two points that are the intersections of the two circles.
+        """
+        
+        d = self.center.distance_to(other.center)
+        if d > self.radius + other.radius + EPS:
+            return []  # No intersection
+        if d < abs(self.radius - other.radius) - EPS:
+            return []  # One circle is inside the other
+        if d < EPS:
+            return []
+        
+        a = (self.radius ** 2 - other.radius ** 2 + d ** 2) / (2 * d)
+        h = math.sqrt(max(0, self.radius ** 2 - a ** 2))
+        x = self.center.x + a * (other.center.x - self.center.x) / d
+        y = self.center.y + a * (other.center.y - self.center.y) / d
+        intersection1 = Point(x + h * (other.center.y - self.center.y) / d, y - h * (other.center.x - self.center.x) / d)
+        intersection2 = Point(x - h * (other.center.y - self.center.y) / d, y + h * (other.center.x - self.center.x) / d)
+        
+        if h < EPS:
+            return [intersection1]  # One intersection (tangent)
+        
+        return [intersection1, intersection2]
+
+    def get_intersection_with_line(self, line: Line) -> list[Point]:
+        d = line.distance_to_point(self.center)
+
+        if d > self.radius + EPS:
+            return []
+
+        # projection of center onto line
+        denom = line.a * line.a + line.b * line.b
+        t = -(line.a*self.center.x + line.b*self.center.y + line.c) / denom
+
+        foot = Point(
+            self.center.x + line.a*t,
+            self.center.y + line.b*t
+        )
+
+        if abs(d - self.radius) < EPS:
+            return [foot]
+
+        offset = math.sqrt(self.radius**2 - d**2)
+
+        direction = line.get_direction_vector().normalize()
+
+        p1 = foot + direction * offset
+        p2 = foot - direction * offset
+
+        return [p1, p2]
+
+    def contains(self, point: Point) -> bool:
+        """
+        Check if a point is contained within the circle.
+
+        Parameters
+        ----------
+        point : Point
+            The point to check.
+
+        Returns
+        -------
+        bool
+            True if the point is contained within the circle, False otherwise.
+        """
+        return self.center.distance_to(point) <= self.radius + EPS
+    
+    def intersects(self, other: 'Circle') -> bool:
+        """
+        Check if two circles intersect.
+
+        Parameters
+        ----------
+        other : Circle
+            The other circle to check intersection with.
+
+        Returns
+        -------
+        bool
+            True if the two circles intersect, False otherwise.
+        """
+        return self.center.distance_to(other.center) <= self.radius + other.radius + EPS
+    
+    def area(self) -> float:
+        """
+        Calculate the area of the circle.
+
+        Returns
+        -------
+        float
+            The area of the circle.
+        """
+        return math.pi * self.radius ** 2
+    
+    def perimeter(self) -> float:
+        """
+        Calculate the perimeter of the circle.
+
+        Returns
+        -------
+        float
+            The perimeter of the circle.
+        """
+        return 2 * math.pi * self.radius
+    
+    def __str__(self) -> str:
+        return f"Circle(center={self.center}, radius={self.radius})"
+    
+    def __repr__(self):
+        return f"Circle({self.center!r}, {self.radius})"
+    
+    def __eq__(self, other) -> bool:
+        return self.center == other.center and abs(self.radius - other.radius) < EPS
+    
+    def __ne__(self, other) -> bool:
+        return not self == other
+    

geomlib-0.1.0/src/geomlib/constants.py

@@ -0,0 +1 @@
+EPS = 1e-12

geomlib-0.1.0/src/geomlib/line.py

@@ -0,0 +1,113 @@
+from geomlib.point import Point
+from geomlib.vector import Vector
+from geomlib.constants import EPS
+import math
+
+class Line:
+    __slots__ = ['a', 'b', 'c']
+
+    def __init__(self, p: Point, q: Point):
+        if p == q:
+            raise ValueError("Cannot define line from identical points")
+        
+        self.a = p.y - q.y
+        self.b = q.x - p.x
+        self.c = p.x * q.y - q.x * p.y
+
+    @staticmethod
+    def from_coeff(a: float, b: float, c: float) -> "Line":
+        line = Line.__new__(Line)
+        line.a = a
+        line.b = b
+        line.c = c
+        return line
+
+    @staticmethod
+    def from_point_and_normal_vector(p: Point, n: Vector) -> "Line":
+        a = n.x
+        b = n.y
+        c = -(a * p.x + b * p.y)
+        return Line.from_coeff(a, b, c)
+    
+    def intersect(self, other: "Line") -> Point:
+        """
+        Compute the intersection point of two lines.
+
+        :param other: The other line to intersect with.
+        :type other: Line
+        :return: The intersection point of the two lines, or None if the lines are parallel.
+        :rtype: Point or None
+        """
+        det = self.a * other.b - other.a * self.b
+        if abs(det) < EPS:
+            return None  # Lines are parallel
+        
+        x = (self.b * other.c - other.b * self.c) / det
+        y = (self.c * other.a - other.c * self.a) / det
+        return Point(x, y)
+    
+    def distance_to_point(self, point: Point) -> float:
+        """
+        Compute the distance from a point to a line.
+
+        :param point: The point to compute the distance to.
+        :type point: Point
+        :return: The distance from the point to the line.
+        :rtype: float
+        """
+        return abs(self.a * point.x + self.b * point.y + self.c) / math.hypot(self.a, self.b)
+
+    def get_normal_vector(self) -> Vector:
+        """
+        Return a vector perpendicular to the line.
+
+        The returned vector is of the same magnitude as the line, but is perpendicular to it.
+
+        :return: A vector perpendicular to the line.
+        :rtype: Vector
+        """
+        return Vector(self.a, self.b)
+    
+    def get_direction_vector(self) -> Vector:
+        """
+        Return a vector parallel to the line.
+
+        The returned vector is of the same magnitude as the line, but is parallel to it.
+
+        :return: A vector parallel to the line.
+        :rtype: Vector
+        """
+        return Vector(self.b, -self.a)
+    
+    def contains(self, point: Point) -> bool:
+        """
+        Check if a point lies on the line.
+
+        :param point: The point to check.
+        :type point: Point
+        :return: True if the point lies on the line, False otherwise.
+        :rtype: bool
+        """
+        return abs(self.a * point.x + self.b * point.y + self.c) / math.hypot(self.a, self.b) < EPS
+
+    def __eq__(self, other):
+        if not isinstance(other, Line):
+            return NotImplemented
+
+        return (
+            abs(self.a * other.b - other.a * self.b) < EPS and
+            abs(self.a * other.c - other.a * self.c) < EPS and
+            abs(self.b * other.c - other.b * self.c) < EPS
+        )
+    
+    def __ne__(self, other):
+        if isinstance(other, Line):
+            return not self.__eq__(other)
+        return NotImplemented
+    
+    def __str__(self):
+        return f"{self.a}x + {self.b}y + {self.c} = 0"
+
+    def __repr__(self):
+        return f"Line({self.a}, {self.b}, {self.c})"
+    

geomlib-0.1.0/src/geomlib/point.py

@@ -0,0 +1,136 @@
+from typing import TYPE_CHECKING
+import math
+from geomlib.constants import EPS
+
+# avoid circular import
+if TYPE_CHECKING:
+    from geomlib.vector import Vector
+
+class Point:
+    __slots__ = ["x", "y"]
+
+    def __init__(self, x: float, y: float):
+        self.x = x
+        self.y = y
+
+    def distance_to(self, other: 'Point') -> float:
+        """
+        Calculate the Euclidean distance between two points self and other.
+
+        :param other: The other point to calculate the distance to.
+        :type other: Point
+        :return: The Euclidean distance between self and other.
+        :rtype: float
+        :raises TypeError: If other is not a Point instance.
+        """
+        if isinstance(other, Point):
+            return math.hypot(self.x - other.x, self.y - other.y)
+        raise TypeError("Distance can only be calculated between two Point instances")
+    
+    def cross3(self, A: 'Point', B: 'Point') -> float:
+        """
+        Calculate the cross product of the vectors self->A and self->B.
+        
+        The cross product is positive if B is to the left of A (counter-clockwise direction),
+        negative if B is to the right of A (clockwise direction), and zero if A, B and self are collinear.
+        
+        :return: The cross product of the vectors self->A and self->B.
+        :rtype: float
+        """
+        return (A.x - self.x) * (B.y - self.y) - (A.y - self.y) * (B.x - self.x)
+
+    def cross(self, other: 'Point') -> float:
+        """
+        Return the 2D cross product of vectors from the origin to self and other.
+        Equivalent to determinant |self other|.
+
+        :return: The cross product of the vectors self->other.
+        :rtype: float
+        """
+        if isinstance(other, Point):
+            return self.x * other.y - self.y * other.x
+        return NotImplemented
+    
+    def midpoint(self, other):
+        """
+        Calculate the midpoint between two points self and other.
+
+        :param other: The other point to calculate the midpoint with.
+        :type other: Point
+        :return: The midpoint between self and other.
+        :rtype: Point
+        """
+        return (self + other) / 2
+    
+    def norm(self):
+        """
+        Calculate the Euclidean norm of the point self.
+
+        :return: The Euclidean norm of the point self.
+        :rtype: float
+        """
+        return math.hypot(self.x, self.y)
+    
+    def rotate(self, angle: float, in_radian: bool = False) -> 'Point':
+        """
+        Rotate the point self by an angle in either degrees or radians.
+
+        :param angle: The angle to rotate the point by.
+        :type angle: float
+        :param in_radian: If the angle is given in radians (True) or degrees (False).
+        :type in_radian: bool
+        :return: The rotated point.
+        :rtype: Point
+        :raises TypeError: If angle is not a float instance.
+        """
+        if not in_radian:
+            angle = math.radians(angle)
+        return Point(self.x * math.cos(angle) - self.y * math.sin(angle), self.x * math.sin(angle) + self.y * math.cos(angle))
+
+    def __add__(self, other):
+        if isinstance(other, Vector):
+            return Point(self.x + other.x, self.y + other.y)
+        return NotImplemented
+    
+    def __sub__(self, other):
+        if isinstance(other, Point):
+            return Vector(self.x - other.x, self.y - other.y)
+        if isinstance(other, Vector):
+            return Point(self.x - other.x, self.y - other.y)
+        return NotImplemented
+    
+    def __mul__(self, other):
+        if isinstance(other, (int, float)):
+            return Point(self.x * other, self.y * other)
+        return NotImplemented
+    
+    def __rmul__(self, other):
+        return self.__mul__(other)
+    
+    def __truediv__(self, other):
+        if isinstance(other, (int, float)):
+            if other == 0:
+                raise ZeroDivisionError("Cannot divide by zero")
+            return Point(self.x / other, self.y / other)
+        return NotImplemented
+    
+    def __eq__(self, other):
+        if isinstance(other, Point):
+            return abs(self.x - other.x) < EPS and abs(self.y - other.y) < EPS
+        return NotImplemented
+    
+    def __ne__(self, other):
+        if isinstance(other, Point):
+            return not self.__eq__(other)
+        return NotImplemented
+
+    def __str__(self):
+        return f"({self.x}, {self.y})"
+    
+    def __repr__(self):
+        return f"Point({self.x}, {self.y})"
+    
+    def __lt__(self, other):
+        if not isinstance(other, Point):
+            return NotImplemented
+        return (self.x, self.y) < (other.x, other.y)