tessl/pypi-dlib

A modern C++ toolkit containing machine learning algorithms and tools for creating complex software to solve real world problems

—

Pending

Overview

Eval results

Files

Geometric Operations

Name: tessl/pypi-dlib
Author: tessl

Rectangle manipulation, line operations, transformations, and geometric utilities for computer vision applications and spatial computations.

Capabilities

Rectangle Operations

Rectangle classes for representing and manipulating rectangular regions with comprehensive geometric operations.

class rectangle:
    """Rectangular area with integer coordinates."""
    
    def __init__(self, left: int, top: int, right: int, bottom: int):
        """Create rectangle from coordinates."""
    
    def __init__(self, drectangle_obj: drectangle):
        """Create from floating point rectangle."""
    
    def __init__(self):
        """Create empty rectangle."""
    
    def left(self) -> int:
        """Get left coordinate."""
    
    def top(self) -> int:
        """Get top coordinate."""
    
    def right(self) -> int:
        """Get right coordinate."""
    
    def bottom(self) -> int:
        """Get bottom coordinate."""
    
    def width(self) -> int:
        """Get rectangle width."""
    
    def height(self) -> int:
        """Get rectangle height."""
    
    def area(self) -> int:
        """Get rectangle area."""
    
    def tl_corner(self) -> point:
        """Get top-left corner point."""
    
    def tr_corner(self) -> point:
        """Get top-right corner point."""
    
    def bl_corner(self) -> point:
        """Get bottom-left corner point."""
    
    def br_corner(self) -> point:
        """Get bottom-right corner point."""
    
    def is_empty(self) -> bool:
        """Check if rectangle is empty."""
    
    def center(self) -> point:
        """Get center point as integer coordinates."""
    
    def dcenter(self) -> dpoint:
        """Get center point as float coordinates."""
    
    def contains(self, point_obj) -> bool:
        """Check if point is inside rectangle."""
    
    def contains(self, rect: rectangle) -> bool:
        """Check if rectangle is inside this rectangle."""
    
    def intersect(self, rect: rectangle) -> rectangle:
        """Get intersection with another rectangle."""

class drectangle:
    """Rectangular area with floating point coordinates."""
    
    def __init__(self, left: float, top: float, right: float, bottom: float):
        """Create rectangle from coordinates."""
    
    def __init__(self, rectangle_obj: rectangle):
        """Create from integer rectangle."""
    
    def __init__(self):
        """Create empty rectangle."""
    
    def left(self) -> float:
        """Get left coordinate."""
    
    def top(self) -> float:
        """Get top coordinate."""
    
    def right(self) -> float:
        """Get right coordinate."""
    
    def bottom(self) -> float:
        """Get bottom coordinate."""
    
    def width(self) -> float:
        """Get rectangle width."""
    
    def height(self) -> float:
        """Get rectangle height."""
    
    def area(self) -> float:
        """Get rectangle area."""
    
    def tl_corner(self) -> dpoint:
        """Get top-left corner point."""
    
    def tr_corner(self) -> dpoint:
        """Get top-right corner point."""
    
    def bl_corner(self) -> dpoint:
        """Get bottom-left corner point."""
    
    def br_corner(self) -> dpoint:
        """Get bottom-right corner point."""
    
    def is_empty(self) -> bool:
        """Check if rectangle is empty."""
    
    def center(self) -> point:
        """Get center point as integer coordinates."""
    
    def dcenter(self) -> dpoint:
        """Get center point as float coordinates."""
    
    def contains(self, point_obj) -> bool:
        """Check if point is inside rectangle."""
    
    def contains(self, rect: drectangle) -> bool:
        """Check if rectangle is inside this rectangle."""
    
    def intersect(self, rect: drectangle) -> drectangle:
        """Get intersection with another rectangle."""

Usage Example:

import dlib

# Create rectangles
rect1 = dlib.rectangle(10, 20, 100, 80)
rect2 = dlib.drectangle(15.5, 25.5, 95.5, 75.5)

# Basic properties
print(f"Area: {rect1.area()}")  # 5400
print(f"Width: {rect1.width()}, Height: {rect1.height()}")  # 90, 60
print(f"Center: {rect1.dcenter()}")  # (55.0, 50.0)

# Corner points
tl = rect1.tl_corner()  # Top-left: (10, 20)
br = rect1.br_corner()  # Bottom-right: (100, 80)

# Containment tests
point_inside = dlib.point(50, 50)
print(rect1.contains(point_inside))  # True

# Intersection
intersection = rect1.intersect(dlib.rectangle(50, 50, 150, 100))

Rectangle Container Types

Container classes for managing collections of rectangles.

class rectangles:
    """Array of rectangle objects."""
    
    def clear(self):
        """Remove all rectangles."""
    
    def resize(self, size: int):
        """Resize container."""
    
    def extend(self, rect_list: list):
        """Add rectangles from list."""

class rectangless:
    """Array of arrays of rectangle objects."""
    
    def clear(self):
        """Remove all rectangle arrays."""
    
    def resize(self, size: int):
        """Resize container."""
    
    def extend(self, rectangles_list: list):
        """Add rectangle arrays from list."""

Rectangle Manipulation Functions

Utility functions for creating and manipulating rectangles.

def translate_rect(rect: rectangle, offset: point) -> rectangle:
    """
    Move rectangle by offset.
    
    Args:
        rect: Rectangle to translate
        offset: Translation offset
    
    Returns:
        Translated rectangle
    """

def shrink_rect(rect: rectangle, amount: int) -> rectangle:
    """
    Shrink rectangle border by amount.
    
    Args:
        rect: Rectangle to shrink
        amount: Amount to shrink each side
    
    Returns:
        Shrunk rectangle
    """

def grow_rect(rect: rectangle, amount: int) -> rectangle:
    """
    Expand rectangle border by amount.
    
    Args:
        rect: Rectangle to expand
        amount: Amount to expand each side
    
    Returns:
        Expanded rectangle
    """

def scale_rect(rect: rectangle, scale: float) -> rectangle:
    """
    Scale rectangle by factor.
    
    Args:
        rect: Rectangle to scale
        scale: Scale factor
    
    Returns:
        Scaled rectangle
    """

def centered_rect(center: point, width: int, height: int) -> rectangle:
    """
    Create rectangle centered at point.
    
    Args:
        center: Center point
        width: Rectangle width
        height: Rectangle height
    
    Returns:
        Centered rectangle
    """

def centered_rect(rect: rectangle, width: int, height: int) -> rectangle:
    """
    Create rectangle centered at rectangle center.
    
    Args:
        rect: Reference rectangle for center
        width: New rectangle width
        height: New rectangle height
    
    Returns:
        Centered rectangle
    """

def centered_rects(centers: points, width: int, height: int) -> rectangles:
    """
    Create multiple centered rectangles.
    
    Args:
        centers: Center points
        width: Rectangle width
        height: Rectangle height
    
    Returns:
        Array of centered rectangles
    """

def center(rect: rectangle) -> point:
    """
    Get rectangle center point.
    
    Args:
        rect: Rectangle
    
    Returns:
        Center point
    """

Usage Example:

import dlib

# Create base rectangle
rect = dlib.rectangle(10, 10, 90, 60)

# Manipulate rectangles
moved_rect = dlib.translate_rect(rect, dlib.point(20, 30))
bigger_rect = dlib.grow_rect(rect, 10)
smaller_rect = dlib.shrink_rect(rect, 5)

# Create centered rectangles
center_point = dlib.point(100, 100)
centered = dlib.centered_rect(center_point, 50, 30)

# Multiple centered rectangles
centers = dlib.points()
centers.extend([dlib.point(50, 50), dlib.point(150, 100)])
rects = dlib.centered_rects(centers, 40, 40)

Rectangle Filtering

Kalman filter for tracking rectangles over time with configurable noise parameters.

class rect_filter:
    """Kalman filter for tracking rectangles."""
    
    def __init__(self, measurement_noise: float, typical_acceleration: float, max_measurement_deviation: float):
        """
        Initialize rectangle filter.
        
        Args:
            measurement_noise: Expected measurement noise level
            typical_acceleration: Expected acceleration magnitude
            max_measurement_deviation: Maximum allowed measurement deviation
        """
    
    def measurement_noise(self) -> float:
        """Get measurement noise parameter."""
    
    def typical_acceleration(self) -> float:
        """Get typical acceleration parameter."""
    
    def max_measurement_deviation(self) -> float:
        """Get max measurement deviation parameter."""
    
    def __call__(self, rect: rectangle) -> rectangle:
        """
        Filter rectangle measurement.
        
        Args:
            rect: Measured rectangle
        
        Returns:
            Filtered rectangle
        """

def find_optimal_rect_filter(rects: rectangles, smoothness: float = 1.0) -> rect_filter:
    """
    Find optimal rectangle filter parameters.
    
    Args:
        rects: Sequence of rectangle measurements
        smoothness: Smoothness parameter (higher = smoother)
    
    Returns:
        Optimally configured rectangle filter
    """

Usage Example:

import dlib

# Create filter for rectangle tracking
rect_filter = dlib.rect_filter(
    measurement_noise=10.0,
    typical_acceleration=0.1, 
    max_measurement_deviation=3.0
)

# Track rectangles over time
measurements = [
    dlib.rectangle(100, 100, 150, 140),
    dlib.rectangle(102, 103, 152, 143),
    dlib.rectangle(105, 106, 155, 146)
]

filtered_rects = []
for rect in measurements:
    filtered = rect_filter(rect)
    filtered_rects.append(filtered)

# Or find optimal parameters automatically
optimal_filter = dlib.find_optimal_rect_filter(measurements, smoothness=2.0)

Line Operations

2D line representation and geometric operations for line-based computations.

class line:
    """2D line representation."""
    
    def __init__(self):
        """Create empty line."""
    
    def __init__(self, p1: point, p2: point):
        """Create line from two points."""
    
    p1: point  # First endpoint
    p2: point  # Second endpoint
    
    @property
    def normal(self) -> dpoint:
        """Unit normal vector to the line."""

def signed_distance_to_line(line_obj: line, point_obj: point) -> float:
    """
    Compute signed distance from point to line.
    
    Args:
        line_obj: Line
        point_obj: Point
    
    Returns:
        Signed distance (positive on one side, negative on other)
    """

def distance_to_line(line_obj: line, point_obj: point) -> float:
    """
    Compute absolute distance from point to line.
    
    Args:
        line_obj: Line
        point_obj: Point
    
    Returns:
        Absolute distance
    """

def reverse(line_obj: line) -> line:
    """
    Reverse line direction.
    
    Args:
        line_obj: Input line
    
    Returns:
        Line with reversed direction
    """

def intersect(line_a: line, line_b: line) -> point:
    """
    Find intersection point of two lines.
    
    Args:
        line_a: First line
        line_b: Second line
    
    Returns:
        Intersection point
    """

def angle_between_lines(line_a: line, line_b: line) -> float:
    """
    Compute angle between lines in degrees.
    
    Args:
        line_a: First line
        line_b: Second line
    
    Returns:
        Angle in degrees
    """

def count_points_on_side_of_line(
    line_obj: line, 
    reference_point: point, 
    points_list: points, 
    dist_thresh_min: float = 0.0, 
    dist_thresh_max: float = float('inf')
) -> int:
    """
    Count points on same side of line as reference point.
    
    Args:
        line_obj: Reference line
        reference_point: Reference point to determine side
        points_list: Points to test
        dist_thresh_min: Minimum distance threshold
        dist_thresh_max: Maximum distance threshold
    
    Returns:
        Number of points on same side within distance thresholds
    """

def count_points_between_lines(
    line1: line, 
    line2: line, 
    reference_point: point, 
    points_list: points
) -> int:
    """
    Count points between two lines.
    
    Args:
        line1: First line
        line2: Second line  
        reference_point: Reference point
        points_list: Points to test
    
    Returns:
        Number of points between the lines
    """

Usage Example:

import dlib

# Create lines
p1, p2 = dlib.point(0, 0), dlib.point(100, 100)
p3, p4 = dlib.point(0, 100), dlib.point(100, 0)

line1 = dlib.line(p1, p2)
line2 = dlib.line(p3, p4)

# Line operations
intersection = dlib.intersect(line1, line2)  # Should be (50, 50)
angle = dlib.angle_between_lines(line1, line2)  # 90 degrees

# Distance calculations
test_point = dlib.point(25, 75)
distance = dlib.distance_to_line(line1, test_point)
signed_dist = dlib.signed_distance_to_line(line1, test_point)

# Point counting
points_list = dlib.points()
points_list.extend([dlib.point(10, 10), dlib.point(90, 90), dlib.point(10, 90)])
ref_point = dlib.point(0, 50)

count = dlib.count_points_on_side_of_line(line1, ref_point, points_list)

Projective Transformations

Projective transformation estimation and application for perspective correction and geometric rectification.

class point_transform_projective:
    """Projective transformation for point mapping."""
    
    def __init__(self):
        """Create identity transformation."""
    
    def __call__(self, point_obj: point) -> dpoint:
        """
        Apply transformation to point.
        
        Args:
            point_obj: Input point
        
        Returns:
            Transformed point
        """

def find_projective_transform(from_points: points, to_points: points) -> point_transform_projective:
    """
    Find projective transformation from point correspondences.
    
    Args:
        from_points: Source points (at least 4 points)
        to_points: Destination points (same number as from_points)
    
    Returns:
        Projective transformation object
    """

def inv(transform: point_transform_projective) -> point_transform_projective:
    """
    Compute inverse of projective transformation.
    
    Args:
        transform: Input transformation
    
    Returns:
        Inverse transformation
    """

Vector Operations

Mathematical operations on points and vectors for geometric computations.

def dot(vector1, vector2) -> float:
    """
    Compute dot product of two vectors/points.
    
    Args:
        vector1: First vector (point or dpoint)
        vector2: Second vector (point or dpoint)
    
    Returns:
        Dot product
    """

def length(point_obj) -> float:
    """
    Compute vector length/magnitude.
    
    Args:
        point_obj: Point or vector
    
    Returns:
        Length of vector
    """

def polygon_area(points_list: points) -> float:
    """
    Calculate area of polygon defined by points.
    
    Args:
        points_list: Polygon vertices in order
    
    Returns:
        Polygon area (positive for counter-clockwise, negative for clockwise)
    """

Usage Examples:

Perspective Correction

import dlib
import cv2

# Load image with perspective distortion
img = cv2.imread("document.jpg")

# Define source corners (distorted quadrilateral)
src_corners = dlib.points()
src_corners.extend([
    dlib.point(120, 150),  # Top-left
    dlib.point(380, 100),  # Top-right
    dlib.point(400, 350),  # Bottom-right
    dlib.point(100, 400)   # Bottom-left
])

# Define target corners (rectangular)
dst_corners = dlib.points()
dst_corners.extend([
    dlib.point(0, 0),      # Top-left
    dlib.point(300, 0),    # Top-right
    dlib.point(300, 400),  # Bottom-right
    dlib.point(0, 400)     # Bottom-left
])

# Find projective transformation
transform = dlib.find_projective_transform(src_corners, dst_corners)

# Apply transformation to image using extract_image_4points
corners_list = [src_corners[i] for i in range(4)]
corrected = dlib.extract_image_4points(img, corners_list, 400, 300)

# Display results
win = dlib.image_window(corrected, "Perspective Corrected")
win.wait_until_closed()

Geometric Analysis

import dlib

# Create polygon points
polygon = dlib.points()
polygon.extend([
    dlib.point(0, 0),
    dlib.point(100, 0),
    dlib.point(100, 100),
    dlib.point(0, 100)
])

# Calculate polygon area
area = dlib.polygon_area(polygon)
print(f"Polygon area: {area}")  # 10000 (100x100 square)

# Vector operations
v1 = dlib.point(3, 4)
v2 = dlib.point(1, 2)

dot_product = dlib.dot(v1, v2)  # 3*1 + 4*2 = 11
vector_length = dlib.length(v1)  # sqrt(3^2 + 4^2) = 5.0

print(f"Dot product: {dot_product}")
print(f"Vector length: {vector_length}")

Transformation Chain

import dlib

# Define transformation points
src_points = dlib.points()
src_points.extend([
    dlib.point(0, 0),
    dlib.point(100, 0),
    dlib.point(100, 100),
    dlib.point(0, 100)
])

dst_points = dlib.points()
dst_points.extend([
    dlib.point(50, 25),
    dlib.point(150, 50),
    dlib.point(125, 150),
    dlib.point(25, 125)
])

# Create transformation
transform = dlib.find_projective_transform(src_points, dst_points)

# Apply to new points
test_point = dlib.point(50, 50)  # Center of source square
transformed = transform(test_point)
print(f"Transformed point: {transformed}")

# Create inverse transformation
inverse_transform = dlib.inv(transform)
back_transformed = inverse_transform(transformed)
print(f"Back-transformed point: {back_transformed}")  # Should be close to (50, 50)

The geometric operations provide fundamental spatial computation capabilities essential for computer vision, image rectification, spatial analysis, and geometric transformations. These operations form the foundation for many advanced computer vision algorithms and spatial reasoning tasks.

Install with Tessl CLI