valetudo-map-parser 0.1.8__tar.gz → 0.1.9a1__tar.gz

valetudo_map_parser-0.1.9a1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.3
+Name: valetudo-map-parser
+Version: 0.1.9a1
+Summary: A Python library to parse Valetudo map data returning a PIL Image object.
+License: Apache-2.0
+Author: Sandro Cantarella
+Author-email: gsca075@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Pillow (>=10.3.0)
+Requires-Dist: numpy (>=1.26.4)
+Requires-Dist: scipy (>=1.12.0)
+Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
+Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases
+Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser
+Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
+Description-Content-Type: text/markdown
+
+# Python-package-valetudo-map-parser
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+A Python library that converts Valetudo vacuum JSON map data into PIL (Python Imaging Library) images. This package is primarily developed for and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera) project.
+
+---
+
+### Features:
+- Processes map data from Valetudo-compatible robot vacuums
+- Supports both Hypfer and Rand256 vacuum data formats
+- Renders comprehensive map visualizations including:
+  - Walls and obstacles
+  - Robot position and cleaning path
+  - Room segments and boundaries
+  - Cleaning zones
+  - Virtual restrictions
+  - LiDAR data
+- Provides auto-cropping and dynamic zooming
+- Supports image rotation and aspect ratio management
+- Enables custom color schemes
+- Handles multilingual labels
+- Implements thread-safe data sharing
+
+### Installation:
+```bash
+pip install valetudo_map_parser
+```
+
+### Requirements:
+- Python 3.12 or higher
+- Dependencies:
+  - Pillow (PIL) for image processing
+  - NumPy for array operations
+
+### Usage:
+The library is configured using a dictionary format. See our [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py) for implementation examples.
+
+Key functionalities:
+- Decodes raw data from Rand256 format
+- Processes JSON data from compatible vacuums
+- Returns Pillow PNG images
+- Provides calibration and room property extraction
+- Supports asynchronous operations
+
+### Development Status:
+Current version: 0.1.9.b41
+- Full functionality available in versions >= 0.1.9
+- Actively maintained and enhanced
+- Uses Poetry for dependency management
+- Implements comprehensive testing
+- Enforces code quality through ruff, isort, and pylint
+
+### Contributing:
+Contributions are welcome! You can help by:
+- Submitting code improvements
+- Enhancing documentation
+- Reporting issues
+- Suggesting new features
+
+### Disclaimer:
+This project is provided "as is" without warranty of any kind. Users assume all risks associated with its use.
+
+### License:
+Apache-2.0
+
+---
+For more information about Valetudo, visit [valetudo.cloud](https://valetudo.cloud)
+Integration with Home Assistant: [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera)
+

valetudo_map_parser-0.1.9a1/README.md

@@ -0,0 +1,71 @@
+# Python-package-valetudo-map-parser
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+A Python library that converts Valetudo vacuum JSON map data into PIL (Python Imaging Library) images. This package is primarily developed for and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera) project.
+
+---
+
+### Features:
+- Processes map data from Valetudo-compatible robot vacuums
+- Supports both Hypfer and Rand256 vacuum data formats
+- Renders comprehensive map visualizations including:
+  - Walls and obstacles
+  - Robot position and cleaning path
+  - Room segments and boundaries
+  - Cleaning zones
+  - Virtual restrictions
+  - LiDAR data
+- Provides auto-cropping and dynamic zooming
+- Supports image rotation and aspect ratio management
+- Enables custom color schemes
+- Handles multilingual labels
+- Implements thread-safe data sharing
+
+### Installation:
+```bash
+pip install valetudo_map_parser
+```
+
+### Requirements:
+- Python 3.12 or higher
+- Dependencies:
+  - Pillow (PIL) for image processing
+  - NumPy for array operations
+
+### Usage:
+The library is configured using a dictionary format. See our [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py) for implementation examples.
+
+Key functionalities:
+- Decodes raw data from Rand256 format
+- Processes JSON data from compatible vacuums
+- Returns Pillow PNG images
+- Provides calibration and room property extraction
+- Supports asynchronous operations
+
+### Development Status:
+Current version: 0.1.9.b41
+- Full functionality available in versions >= 0.1.9
+- Actively maintained and enhanced
+- Uses Poetry for dependency management
+- Implements comprehensive testing
+- Enforces code quality through ruff, isort, and pylint
+
+### Contributing:
+Contributions are welcome! You can help by:
+- Submitting code improvements
+- Enhancing documentation
+- Reporting issues
+- Suggesting new features
+
+### Disclaimer:
+This project is provided "as is" without warranty of any kind. Users assume all risks associated with its use.
+
+### License:
+Apache-2.0
+
+---
+For more information about Valetudo, visit [valetudo.cloud](https://valetudo.cloud)
+Integration with Home Assistant: [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera)

{valetudo_map_parser-0.1.8 → valetudo_map_parser-0.1.9a1}/SCR/valetudo_map_parser/__init__.py

@@ -1,33 +1,40 @@
 """Valetudo map parser.
-Version: 0.1.8"""
+Version: 0.1.9"""
 
-from .hypfer_handler import HypferMapImageHandler
-from .rand25_handler import ReImageHandler
+from .config.colors import ColorsManagement
+from .config.drawable import Drawable
+from .config.drawable_elements import DrawableElement, DrawingConfig
+from .config.enhanced_drawable import EnhancedDrawable
 from .config.rand25_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
-from .config.colors import ColorsManagment
-from .config.drawable import Drawable
 from .config.types import (
-    SnapshotStore,
-    UserLanguageStore,
-    RoomStore,
+    CameraModes,
     RoomsProperties,
+    RoomStore,
+    SnapshotStore,
     TrimCropData,
-    CameraModes,
+    UserLanguageStore,
 )
+from .hypfer_handler import HypferMapImageHandler
+from .rand25_handler import ReImageHandler
+from .rooms_handler import RoomsHandler, RandRoomsHandler
+
 
 __all__ = [
+    "RoomsHandler",
+    "RandRoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",
     "CameraShared",
     "CameraSharedManager",
-    "ColorsManagment",
+    "ColorsManagement",
     "Drawable",
+    "DrawableElement",
+    "DrawingConfig",
+    "EnhancedDrawable",
     "SnapshotStore",
     "UserLanguageStore",
-    "UserLanguageStore",
-    "SnapshotStore",
     "RoomStore",
     "RoomsProperties",
     "TrimCropData",

valetudo_map_parser-0.1.9a1/SCR/valetudo_map_parser/config/auto_crop.py

@@ -0,0 +1,346 @@
+"""Auto Crop Class for trimming and zooming images.
+Version: 2024.10.0"""
+
+from __future__ import annotations
+
+import logging
+
+import numpy as np
+from numpy import rot90
+
+from .types import Color, NumpyArray, TrimCropData, TrimsData
+from .utils import BaseHandler
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TrimError(Exception):
+    """Exception raised for errors in the trim process."""
+
+    def __init__(self, message, image):
+        super().__init__(message)
+        self.image = image
+
+
+class AutoCrop:
+    """Auto Crop Class for trimming and zooming images."""
+
+    def __init__(self, handler: BaseHandler):
+        self.auto_crop = None  # auto crop data to be calculate once.
+        self.crop_area = None
+        self.handler = handler
+        trim_data = self.handler.shared.trims.to_dict()  # trims data
+        self.trim_up = trim_data.get("trim_up", 0)  # trim up
+        self.trim_down = trim_data.get("trim_down", 0)  # trim down
+        self.trim_left = trim_data.get("trim_left", 0)  # trim left
+        self.trim_right = trim_data.get("trim_right", 0)  # trim right
+        self.offset_top = self.handler.shared.offset_top  # offset top
+        self.offset_bottom = self.handler.shared.offset_down  # offset bottom
+        self.offset_left = self.handler.shared.offset_left  # offset left
+        self.offset_right = self.handler.shared.offset_right  # offset right
+
+    @staticmethod
+    def validate_crop_dimensions(shared):
+        """Ensure width and height are valid before processing cropping."""
+        if shared.image_ref_width <= 0 or shared.image_ref_height <= 0:
+            _LOGGER.warning(
+                "Auto-crop failed: Invalid dimensions (width=%s, height=%s). Using original image.",
+                shared.image_ref_width,
+                shared.image_ref_height,
+            )
+            return False
+        return True
+
+    def check_trim(
+        self, trimmed_height, trimmed_width, margin_size, image_array, file_name, rotate
+    ):
+        """Check if the trim is okay."""
+        if trimmed_height <= margin_size or trimmed_width <= margin_size:
+            self.crop_area = [0, 0, image_array.shape[1], image_array.shape[0]]
+            self.handler.img_size = (image_array.shape[1], image_array.shape[0])
+            raise TrimError(
+                f"{file_name}: Trimming failed at rotation {rotate}.", image_array
+            )
+
+    def _calculate_trimmed_dimensions(self):
+        """Calculate and update the dimensions after trimming."""
+        trimmed_width = max(
+            1,  # Ensure at least 1px
+            (self.trim_right - self.offset_right) - (self.trim_left + self.offset_left),
+        )
+        trimmed_height = max(
+            1,  # Ensure at least 1px
+            (self.trim_down - self.offset_bottom) - (self.trim_up + self.offset_top),
+        )
+
+        # Ensure shared reference dimensions are updated
+        if hasattr(self.handler.shared, "image_ref_height") and hasattr(
+            self.handler.shared, "image_ref_width"
+        ):
+            self.handler.shared.image_ref_height = trimmed_height
+            self.handler.shared.image_ref_width = trimmed_width
+        else:
+            _LOGGER.warning(
+                "Shared attributes for image dimensions are not initialized."
+            )
+
+        return trimmed_width, trimmed_height
+
+    async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
+        """Load the auto crop data from the Camera config."""
+        _LOGGER.debug("Auto Crop data: %s, %s", str(tdata), str(self.auto_crop))
+        if not self.auto_crop:
+            trims_data = TrimCropData.from_dict(dict(tdata.to_dict())).to_list()
+            (
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
+            ) = trims_data
+            _LOGGER.debug("Auto Crop trims data: %s", trims_data)
+            if trims_data != [0, 0, 0, 0]:
+                self._calculate_trimmed_dimensions()
+            else:
+                trims_data = None
+            return trims_data
+        return None
+
+    def auto_crop_offset(self):
+        """Calculate the offset for the auto crop."""
+        if self.auto_crop:
+            self.auto_crop[0] += self.offset_left
+            self.auto_crop[1] += self.offset_top
+            self.auto_crop[2] -= self.offset_right
+            self.auto_crop[3] -= self.offset_bottom
+
+    async def _init_auto_crop(self):
+        """Initialize the auto crop data."""
+        _LOGGER.debug("Auto Crop Init data: %s", str(self.auto_crop))
+        _LOGGER.debug(
+            "Auto Crop Init trims data: %r", self.handler.shared.trims.to_dict()
+        )
+        if not self.auto_crop:  # and self.handler.shared.vacuum_state == "docked":
+            self.auto_crop = await self._async_auto_crop_data(self.handler.shared.trims)
+            if self.auto_crop:
+                self.auto_crop_offset()
+        else:
+            self.handler.max_frames = 1205
+
+        # Fallback: Ensure auto_crop is valid
+        if not self.auto_crop or any(v < 0 for v in self.auto_crop):
+            _LOGGER.debug("Auto-crop data unavailable. Scanning full image.")
+            self.auto_crop = None
+
+        return self.auto_crop
+
+    async def async_image_margins(
+        self, image_array: NumpyArray, detect_colour: Color
+    ) -> tuple[int, int, int, int]:
+        """Crop the image based on the auto crop area using scipy.ndimage for better performance."""
+        # Import scipy.ndimage here to avoid import at module level
+        from scipy import ndimage
+
+        # Create a binary mask where True = non-background pixels
+        # This is much more memory efficient than storing coordinates
+        mask = ~np.all(image_array == list(detect_colour), axis=2)
+
+        # Use scipy.ndimage.find_objects to efficiently find the bounding box
+        # This returns a list of slice objects that define the bounding box
+        # Label the mask with a single label (1) and find its bounding box
+        labeled_mask = mask.astype(np.int8)  # Convert to int8 (smallest integer type)
+        objects = ndimage.find_objects(labeled_mask)
+
+        if not objects:  # No objects found
+            _LOGGER.warning(
+                "%s: No non-background pixels found in image", self.handler.file_name
+            )
+            # Return full image dimensions as fallback
+            return 0, 0, image_array.shape[1], image_array.shape[0]
+
+        # Extract the bounding box coordinates from the slice objects
+        y_slice, x_slice = objects[0]
+        min_y, max_y = y_slice.start, y_slice.stop - 1
+        min_x, max_x = x_slice.start, x_slice.stop - 1
+
+        _LOGGER.debug(
+            "%s: Found trims max and min values (y,x) (%s, %s) (%s, %s)...",
+            self.handler.file_name,
+            int(max_y),
+            int(max_x),
+            int(min_y),
+            int(min_x),
+        )
+        return min_y, min_x, max_x, max_y
+
+    async def async_check_if_zoom_is_on(
+        self,
+        image_array: NumpyArray,
+        margin_size: int = 100,
+        zoom: bool = False,
+        rand256: bool = False,
+    ) -> NumpyArray:
+        """Check if the image needs to be zoomed."""
+
+        if (
+            zoom
+            and self.handler.shared.vacuum_state == "cleaning"
+            and self.handler.shared.image_auto_zoom
+        ):
+            _LOGGER.debug(
+                "%s: Zooming the image on room %s.",
+                self.handler.file_name,
+                self.handler.robot_in_room["room"],
+            )
+
+            if rand256:
+                trim_left = (
+                    round(self.handler.robot_in_room["right"] / 10) - margin_size
+                )
+                trim_right = (
+                    round(self.handler.robot_in_room["left"] / 10) + margin_size
+                )
+                trim_up = round(self.handler.robot_in_room["down"] / 10) - margin_size
+                trim_down = round(self.handler.robot_in_room["up"] / 10) + margin_size
+            else:
+                trim_left = self.handler.robot_in_room["left"] - margin_size
+                trim_right = self.handler.robot_in_room["right"] + margin_size
+                trim_up = self.handler.robot_in_room["up"] - margin_size
+                trim_down = self.handler.robot_in_room["down"] + margin_size
+
+            # Ensure valid trim values
+            trim_left, trim_right = sorted([trim_left, trim_right])
+            trim_up, trim_down = sorted([trim_up, trim_down])
+
+            # Prevent zero-sized images
+            if trim_right - trim_left < 1 or trim_down - trim_up < 1:
+                _LOGGER.warning(
+                    "Zooming resulted in an invalid crop area. Using full image."
+                )
+                return image_array  # Return original image
+
+            trimmed = image_array[trim_up:trim_down, trim_left:trim_right]
+
+        else:
+            trimmed = image_array[
+                self.auto_crop[1] : self.auto_crop[3],
+                self.auto_crop[0] : self.auto_crop[2],
+            ]
+
+        return trimmed
+
+    async def async_rotate_the_image(
+        self, trimmed: NumpyArray, rotate: int
+    ) -> NumpyArray:
+        """Rotate the image and return the new array."""
+        if rotate == 90:
+            rotated = rot90(trimmed)
+            self.crop_area = [
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
+            ]
+        elif rotate == 180:
+            rotated = rot90(trimmed, 2)
+            self.crop_area = self.auto_crop
+        elif rotate == 270:
+            rotated = rot90(trimmed, 3)
+            self.crop_area = [
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
+            ]
+        else:
+            rotated = trimmed
+            self.crop_area = self.auto_crop
+        return rotated
+
+    async def async_auto_trim_and_zoom_image(
+        self,
+        image_array: NumpyArray,
+        detect_colour: Color = (93, 109, 126, 255),
+        margin_size: int = 0,
+        rotate: int = 0,
+        zoom: bool = False,
+        rand256: bool = False,
+    ):
+        """
+        Automatically crops and trims a numpy array and returns the processed image.
+        """
+        try:
+            self.auto_crop = await self._init_auto_crop()
+            if (self.auto_crop is None) or (self.auto_crop == [0, 0, 0, 0]):
+                _LOGGER.debug("%s: Calculating auto trim box", self.handler.file_name)
+                # Find the coordinates of the first occurrence of a non-background color
+                min_y, min_x, max_x, max_y = await self.async_image_margins(
+                    image_array, detect_colour
+                )
+                # Calculate and store the trims coordinates with margins
+                self.trim_left = int(min_x) - margin_size
+                self.trim_up = int(min_y) - margin_size
+                self.trim_right = int(max_x) + margin_size
+                self.trim_down = int(max_y) + margin_size
+                del min_y, min_x, max_x, max_y
+
+                # Calculate the dimensions after trimming using min/max values
+                trimmed_width, trimmed_height = self._calculate_trimmed_dimensions()
+
+                # Test if the trims are okay or not
+                try:
+                    self.check_trim(
+                        trimmed_height,
+                        trimmed_width,
+                        margin_size,
+                        image_array,
+                        self.handler.file_name,
+                        rotate,
+                    )
+                except TrimError as e:
+                    return e.image
+
+                # Store Crop area of the original image_array we will use from the next frame.
+                self.auto_crop = TrimCropData(
+                    self.trim_left,
+                    self.trim_up,
+                    self.trim_right,
+                    self.trim_down,
+                ).to_list()
+                # Update the trims data in the shared instance
+                self.handler.shared.trims = TrimsData.from_dict(
+                    {
+                        "trim_left": self.trim_left,
+                        "trim_up": self.trim_up,
+                        "trim_right": self.trim_right,
+                        "trim_down": self.trim_down,
+                    }
+                )
+                self.auto_crop_offset()
+            # If it is needed to zoom the image.
+            trimmed = await self.async_check_if_zoom_is_on(
+                image_array, margin_size, zoom, rand256
+            )
+            del image_array  # Free memory.
+            # Rotate the cropped image based on the given angle
+            rotated = await self.async_rotate_the_image(trimmed, rotate)
+            del trimmed  # Free memory.
+            _LOGGER.debug(
+                "%s: Auto Trim Box data: %s", self.handler.file_name, self.crop_area
+            )
+            self.handler.crop_img_size = [rotated.shape[1], rotated.shape[0]]
+            _LOGGER.debug(
+                "%s: Auto Trimmed image size: %s",
+                self.handler.file_name,
+                self.handler.crop_img_size,
+            )
+
+        except RuntimeError as e:
+            _LOGGER.warning(
+                "%s: Error %s during auto trim and zoom.",
+                self.handler.file_name,
+                e,
+                exc_info=True,
+            )
+            return None
+        return rotated

valetudo_map_parser-0.1.9a1/SCR/valetudo_map_parser/config/color_utils.py

@@ -0,0 +1,105 @@
+"""Utility functions for color operations in the map parser."""
+
+from typing import Optional, Tuple
+
+from .colors import ColorsManagement
+from .types import Color, NumpyArray
+
+
+def get_blended_color(
+    x0: int,
+    y0: int,
+    x1: int,
+    y1: int,
+    arr: Optional[NumpyArray],
+    color: Color,
+) -> Color:
+    """
+    Get a blended color for a pixel based on the current element map and the new element to draw.
+
+    This function:
+    1. Gets the background colors at the start and end points (with offset to avoid sampling already drawn pixels)
+    2. Directly blends the foreground color with the background using straight alpha
+    3. Returns the average of the two blended colors
+
+    Returns:
+        Blended RGBA color to use for drawing
+    """
+    # Extract foreground color components
+    fg_r, fg_g, fg_b, fg_a = color
+    fg_alpha = fg_a / 255.0  # Convert to 0-1 range
+
+    # Fast path for fully opaque or transparent foreground
+    if fg_a == 255:
+        return color
+    if fg_a == 0:
+        # Sample background at midpoint
+        mid_x, mid_y = (x0 + x1) // 2, (y0 + y1) // 2
+        if 0 <= mid_y < arr.shape[0] and 0 <= mid_x < arr.shape[1]:
+            return tuple(arr[mid_y, mid_x])
+        return (0, 0, 0, 0)  # Default if out of bounds
+
+    # Calculate direction vector for offset sampling
+    dx = x1 - x0
+    dy = y1 - y0
+    length = max(1, (dx**2 + dy**2) ** 0.5)  # Avoid division by zero
+    offset = 5  # 5-pixel offset to avoid sampling already drawn pixels
+
+    # Calculate offset coordinates for start point (move away from the line)
+    offset_x0 = int(x0 - (offset * dx / length))
+    offset_y0 = int(y0 - (offset * dy / length))
+
+    # Calculate offset coordinates for end point (move away from the line)
+    offset_x1 = int(x1 + (offset * dx / length))
+    offset_y1 = int(y1 + (offset * dy / length))
+
+    # Sample background at offset start point
+    if 0 <= offset_y0 < arr.shape[0] and 0 <= offset_x0 < arr.shape[1]:
+        bg_color_start = arr[offset_y0, offset_x0]
+        # Direct straight alpha blending
+        start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+        start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+        start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+        start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+        start_blended_color = (start_r, start_g, start_b, start_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y0 < arr.shape[0] and 0 <= x0 < arr.shape[1]:
+            bg_color_start = arr[y0, x0]
+            start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+            start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+            start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+            start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+            start_blended_color = (start_r, start_g, start_b, start_a)
+        else:
+            start_blended_color = color
+
+    # Sample background at offset end point
+    if 0 <= offset_y1 < arr.shape[0] and 0 <= offset_x1 < arr.shape[1]:
+        bg_color_end = arr[offset_y1, offset_x1]
+        # Direct straight alpha blending
+        end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+        end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+        end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+        end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+        end_blended_color = (end_r, end_g, end_b, end_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y1 < arr.shape[0] and 0 <= x1 < arr.shape[1]:
+            bg_color_end = arr[y1, x1]
+            end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+            end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+            end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+            end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+            end_blended_color = (end_r, end_g, end_b, end_a)
+        else:
+            end_blended_color = color
+
+    # Use the average of the two blended colors
+    blended_color = (
+        (start_blended_color[0] + end_blended_color[0]) // 2,
+        (start_blended_color[1] + end_blended_color[1]) // 2,
+        (start_blended_color[2] + end_blended_color[2]) // 2,
+        (start_blended_color[3] + end_blended_color[3]) // 2,
+    )
+    return blended_color