pyblend2d 0.21.2__py3-none-any.whl

blend2d/__init__.py

@@ -0,0 +1,284 @@
+"""
+PyBlend: High-Performance 2D Vector Graphics Engine for Python powered by Blend2D.
+"""
+
+from blend2d.enums import (
+    Format,
+    CompOp,
+    FillRule,
+    GeometryType,
+    ExtendMode,
+    GradientType,
+    StrokeCap,
+    StrokeCapPosition,
+    StrokeJoin,
+    StrokeTransformOrder,
+    TransformOp,
+    ClipOp,
+    FlattenMode,
+    RenderingEngine,
+    ResultCode,
+    ContextHint,
+    RenderingQuality,
+    GradientQuality,
+    PatternQuality,
+    RuntimeInfoType,
+    RuntimeCpuArch,
+    RuntimeCpuFeatures,
+)
+from blend2d.ffi import Blend2DError
+from blend2d.geometry import (
+    Point,
+    PointI,
+    Size,
+    SizeI,
+    Rect,
+    RectI,
+    Box,
+    BoxI,
+    Circle,
+    Ellipse,
+    RoundRect,
+    Triangle,
+    Arc,
+    Line,
+)
+from blend2d.matrix import Matrix2D
+from blend2d.color import (
+    Rgba32,
+    Rgba,
+    parse_color,
+    NAMED_COLORS,
+)
+from blend2d.image import Image
+from blend2d.path import Path
+from blend2d.style import (
+    Gradient,
+    LinearGradient,
+    RadialGradient,
+    ConicGradient,
+    Pattern,
+)
+from blend2d.font import (
+    FontFace,
+    Font,
+    FontMetrics,
+    TextMetrics,
+)
+from blend2d.context import Context
+from blend2d.diagnostics import (
+    diagnose_environment,
+    print_diagnostic_report,
+    get_error_details,
+    get_runtime_info,
+)
+from blend2d import svg
+from blend2d.svg import SvgContext, export_svg
+from blend2d import video
+from blend2d.video import (
+    VideoWriter,
+    VideoReader,
+    record_animation,
+    detect_hardware_encoders,
+    VideoError,
+    CodecNotFoundError,
+    FrameFormatError,
+)
+from blend2d import shapgeo
+from blend2d.shapgeo import (
+    GeoCanvas,
+    GeoTransform,
+    from_shapely,
+    from_geojson,
+    from_wkt,
+    render_gdf,
+    auto_bounds,
+    read_file,
+    read_shapefile,
+    read_geojson,
+    proj,
+    Transformer,
+    to_web_mercator,
+    to_wgs84,
+    reproject_gdf,
+    downloader,
+    download_dataset,
+    load_dataset,
+    register_dataset,
+)
+from blend2d import motion
+from blend2d.motion import (
+    Timeline,
+    Easing,
+    Spring,
+    CubicBezier,
+    trim_path,
+    PathFollower,
+    PathMorph,
+    ParticleSystem,
+    Camera2D,
+    PerspectiveCamera,
+    render_globe,
+    Node,
+    Layer,
+    Scene,
+)
+from blend2d import fx
+from blend2d.fx import (
+    FXPipeline,
+    gaussian_blur,
+    box_blur,
+    bloom,
+    neon_glow,
+    drop_shadow,
+    chromatic_aberration,
+    vignette,
+    film_grain,
+    color_grade,
+    grayscale,
+    invert,
+    sepia,
+    scanlines,
+    glitch_displacement,
+)
+
+# Alias geo -> shapgeo for developer convenience
+geo = shapgeo
+
+__version__ = "0.21.2"
+__author__ = "Islam Arifi, PyBlend Team, Blend2D Authors"
+
+__all__ = [
+    # Core
+    "Image",
+    "Context",
+    "Path",
+    "Blend2DError",
+    # Post-Processing FX Engine
+    "fx",
+    "FXPipeline",
+    "gaussian_blur",
+    "box_blur",
+    "bloom",
+    "neon_glow",
+    "drop_shadow",
+    "chromatic_aberration",
+    "vignette",
+    "film_grain",
+    "color_grade",
+    "grayscale",
+    "invert",
+    "sepia",
+    "scanlines",
+    "glitch_displacement",
+    # Motion Graphics & Animation Engine
+    "motion",
+    "Timeline",
+    "Easing",
+    "Spring",
+    "CubicBezier",
+    "trim_path",
+    "PathFollower",
+    "PathMorph",
+    "ParticleSystem",
+    "Camera2D",
+    "PerspectiveCamera",
+    "render_globe",
+    "Node",
+    "Layer",
+    "Scene",
+    # Geospatial (GeoPandas & Shapely C++ Engine)
+    "shapgeo",
+    "geo",
+    "GeoCanvas",
+    "GeoTransform",
+    "from_shapely",
+    "from_geojson",
+    "from_wkt",
+    "render_gdf",
+    "auto_bounds",
+    "read_file",
+    "read_shapefile",
+    "read_geojson",
+    "proj",
+    "Transformer",
+    "to_web_mercator",
+    "to_wgs84",
+    "reproject_gdf",
+    "downloader",
+    "download_dataset",
+    "load_dataset",
+    # Video & Native FFmpeg Engine
+    "video",
+    "VideoWriter",
+    "VideoReader",
+    "record_animation",
+    "detect_hardware_encoders",
+    "VideoError",
+    "CodecNotFoundError",
+    "FrameFormatError",
+    # SVG Vector Export
+    "svg",
+    "SvgContext",
+    "export_svg",
+    # Diagnostics & Troubleshooting
+    "diagnose_environment",
+    "print_diagnostic_report",
+    "get_error_details",
+    "get_runtime_info",
+    # Styles
+    "Gradient",
+    "LinearGradient",
+    "RadialGradient",
+    "ConicGradient",
+    "Pattern",
+    # Colors
+    "Rgba32",
+    "Rgba",
+    "parse_color",
+    "NAMED_COLORS",
+    # Typography
+    "FontFace",
+    "Font",
+    "FontMetrics",
+    "TextMetrics",
+    # Geometry
+    "Point",
+    "PointI",
+    "Size",
+    "SizeI",
+    "Rect",
+    "RectI",
+    "Box",
+    "BoxI",
+    "Circle",
+    "Ellipse",
+    "RoundRect",
+    "Triangle",
+    "Arc",
+    "Line",
+    "Matrix2D",
+    # Enums
+    "Format",
+    "CompOp",
+    "FillRule",
+    "GeometryType",
+    "ExtendMode",
+    "GradientType",
+    "StrokeCap",
+    "StrokeCapPosition",
+    "StrokeJoin",
+    "StrokeTransformOrder",
+    "TransformOp",
+    "ClipOp",
+    "FlattenMode",
+    "RenderingEngine",
+    "ResultCode",
+    "ContextHint",
+    "RenderingQuality",
+    "GradientQuality",
+    "PatternQuality",
+    "RuntimeInfoType",
+    "RuntimeCpuArch",
+    "RuntimeCpuFeatures",
+]

blend2d/color.py

@@ -0,0 +1,202 @@
+"""
+Color Representation and Utilities for Blend2D.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Union, Tuple, Sequence
+from blend2d.ffi import BLRgba32, BLRgba64, BLRgba
+
+
+NAMED_COLORS = {
+    "black": 0xFF000000,
+    "white": 0xFFFFFFFF,
+    "red": 0xFFFF0000,
+    "green": 0xFF008000,
+    "lime": 0xFF00FF00,
+    "blue": 0xFF0000FF,
+    "yellow": 0xFFFFFF00,
+    "cyan": 0xFF00FFFF,
+    "aqua": 0xFF00FFFF,
+    "magenta": 0xFFFF00FF,
+    "fuchsia": 0xFFFF00FF,
+    "transparent": 0x00000000,
+    "gray": 0xFF808080,
+    "grey": 0xFF808080,
+    "darkgray": 0xFFA9A9A9,
+    "darkgrey": 0xFFA9A9A9,
+    "lightgray": 0xFFD3D3D3,
+    "lightgrey": 0xFFD3D3D3,
+    "orange": 0xFFFFA500,
+    "coral": 0xFFFF7F50,
+    "purple": 0xFF800080,
+    "pink": 0xFFFFC0CB,
+    "navy": 0xFF000080,
+    "teal": 0xFF008080,
+    "olive": 0xFF808000,
+    "maroon": 0xFF800000,
+    "silver": 0xFFC0C0C0,
+    "gold": 0xFFFFD700,
+    "indigo": 0xFF4B0082,
+    "violet": 0xFFEE82EE,
+    "brown": 0xFFA52A2A,
+    "khaki": 0xFFF0E68C,
+    "lavender": 0xFFE6E6FA,
+    "salmon": 0xFFFA8072,
+    "plum": 0xFFDDA0DD,
+    "turquoise": 0xFF40E0D0,
+    "crimson": 0xFFDC143C,
+}
+
+
+@dataclass
+class Rgba32:
+    """32-bit ARGB color (uint32)."""
+    value: int = 0xFF000000
+
+    def __init__(
+        self,
+        r_or_value: Union[int, Sequence[int]] = 0xFF000000,
+        g: Optional[int] = None,
+        b: Optional[int] = None,
+        a: Optional[int] = None
+    ):
+        if isinstance(r_or_value, (tuple, list)):
+            vals = r_or_value
+            r = vals[0]
+            g = vals[1]
+            b = vals[2]
+            a = vals[3] if len(vals) > 3 else 255
+            self.value = ((int(a) & 0xFF) << 24) | ((int(r) & 0xFF) << 16) | ((int(g) & 0xFF) << 8) | (int(b) & 0xFF)
+        elif g is not None or b is not None or a is not None:
+            r = int(r_or_value)
+            g_val = int(g) if g is not None else 0
+            b_val = int(b) if b is not None else 0
+            a_val = int(a) if a is not None else 255
+            self.value = ((a_val & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g_val & 0xFF) << 8) | (b_val & 0xFF)
+        else:
+            self.value = int(r_or_value) & 0xFFFFFFFF
+
+    @property
+    def a(self) -> int:
+        return (self.value >> 24) & 0xFF
+
+    @property
+    def r(self) -> int:
+        return (self.value >> 16) & 0xFF
+
+    @property
+    def g(self) -> int:
+        return (self.value >> 8) & 0xFF
+
+    @property
+    def b(self) -> int:
+        return self.value & 0xFF
+
+    def to_c(self) -> BLRgba32:
+        return BLRgba32(self.value)
+
+    @classmethod
+    def from_c(cls, c: BLRgba32) -> Rgba32:
+        return cls(c.value)
+
+    @classmethod
+    def from_rgba(cls, r: int, g: int, b: int, a: int = 255) -> Rgba32:
+        val = ((int(a) & 0xFF) << 24) | ((int(r) & 0xFF) << 16) | ((int(g) & 0xFF) << 8) | (int(b) & 0xFF)
+        return cls(val)
+
+    @classmethod
+    def from_hex(cls, hex_str: str) -> Rgba32:
+        s = hex_str.strip().lstrip("#")
+        try:
+            if len(s) == 3:  # RGB
+                r = int(s[0] * 2, 16)
+                g = int(s[1] * 2, 16)
+                b = int(s[2] * 2, 16)
+                return cls.from_rgba(r, g, b, 255)
+            elif len(s) == 4:  # RGBA
+                r = int(s[0] * 2, 16)
+                g = int(s[1] * 2, 16)
+                b = int(s[2] * 2, 16)
+                a = int(s[3] * 2, 16)
+                return cls.from_rgba(r, g, b, a)
+            elif len(s) == 6:  # RRGGBB
+                r = int(s[0:2], 16)
+                g = int(s[2:4], 16)
+                b = int(s[4:6], 16)
+                return cls.from_rgba(r, g, b, 255)
+            elif len(s) == 8:  # RRGGBBAA
+                r = int(s[0:2], 16)
+                g = int(s[2:4], 16)
+                b = int(s[4:6], 16)
+                a = int(s[6:8], 16)
+                return cls.from_rgba(r, g, b, a)
+        except ValueError:
+            pass
+        raise ValueError(f"Invalid hex color string: '{hex_str}'")
+
+    def __repr__(self) -> str:
+        return f"Rgba32(r={self.r}, g={self.g}, b={self.b}, a={self.a}, hex=#{self.value:08X})"
+
+
+@dataclass
+class Rgba:
+    """Floating point RGBA color (0.0 - 1.0)."""
+    r: float = 0.0
+    g: float = 0.0
+    b: float = 0.0
+    a: float = 1.0
+
+    def to_c(self) -> BLRgba:
+        return BLRgba(float(self.r), float(self.g), float(self.b), float(self.a))
+
+    @classmethod
+    def from_c(cls, c: BLRgba) -> Rgba:
+        return cls(c.r, c.g, c.b, c.a)
+
+    def to_rgba32(self) -> Rgba32:
+        return Rgba32.from_rgba(
+            int(min(max(self.r, 0.0), 1.0) * 255),
+            int(min(max(self.g, 0.0), 1.0) * 255),
+            int(min(max(self.b, 0.0), 1.0) * 255),
+            int(min(max(self.a, 0.0), 1.0) * 255),
+        )
+
+
+ColorLike = Union[Rgba32, Rgba, int, str, Tuple[int, int, int], Tuple[int, int, int, int], Sequence[float]]
+
+
+def parse_color(color: ColorLike) -> Rgba32:
+    """Universal color parser returning a 32-bit Rgba32 instance."""
+    if isinstance(color, Rgba32):
+        return color
+    if isinstance(color, Rgba):
+        return color.to_rgba32()
+    if isinstance(color, int):
+        return Rgba32(color)
+    if isinstance(color, str):
+        color_lower = color.lower().strip()
+        if color_lower in NAMED_COLORS:
+            return Rgba32(NAMED_COLORS[color_lower])
+        if color.startswith("#"):
+            return Rgba32.from_hex(color)
+        # Try hex even without # if 6 or 8 hex digits
+        if len(color) in (3, 4, 6, 8) and all(c in "0123456789abcdefABCDEF" for c in color):
+            return Rgba32.from_hex(color)
+        raise ValueError(f"Unknown color name or invalid hex string: '{color}'")
+    if isinstance(color, (tuple, list)):
+        if all(isinstance(x, float) and 0.0 <= x <= 1.0 for x in color):
+            # Float normalized colors
+            r = int(color[0] * 255)
+            g = int(color[1] * 255)
+            b = int(color[2] * 255)
+            a = int(color[3] * 255) if len(color) > 3 else 255
+            return Rgba32.from_rgba(r, g, b, a)
+        else:
+            r = int(color[0])
+            g = int(color[1])
+            b = int(color[2])
+            a = int(color[3]) if len(color) > 3 else 255
+            return Rgba32.from_rgba(r, g, b, a)
+
+    raise TypeError(f"Cannot convert type {type(color)} to a valid Blend2D Color.")