Photo-Composition-Designer 0.0.7__py3-none-any.whl

Photo_Composition_Designer/tools/GeoPlotter.py

@@ -0,0 +1,211 @@
+import math
+from pathlib import Path
+
+import geopandas as gpd
+import matplotlib.colors as mcolors
+import matplotlib.pyplot as plt
+from shapely.geometry import Point
+
+from path_handler import get_base_path
+
+
+class GeoPlotter:
+    """
+    Class for plotting a map section with optional layers such as federal states or bodies of water.
+    """
+
+    def __init__(
+        self,
+        minimalExtension=5,
+        size=(400, 400),
+        background_color="black",
+        border_color="white",
+        line_width=0.4,
+    ):
+        base_path = get_base_path() / "res/maps"
+
+        countries_shp = base_path / "ne_50m_admin_0_countries/ne_50m_admin_0_countries.shp"
+        lakes_shp = (
+            base_path / "ne_50m_rivers_lake_centerlines_scale_rank/"
+            "ne_50m_rivers_lake_centerlines_scale_rank.shp"
+        )
+
+        self.shapefile_path = countries_shp
+        self.minimalExtension = minimalExtension
+        self.size = size
+        self.background_color = self._normalize_color(background_color)
+        self.border_color = self._normalize_color(border_color)
+        self.line_width = line_width * size[1] / 100
+        self.size_marker = 0.25 * size[1] * size[1] / 100
+        self.layers = {}
+
+        # Zusätzliche Layer hinzufügen
+        lakes_shp = Path(lakes_shp).resolve()
+        self._addLayer("lakes", lakes_shp, color="royalblue", edgecolor="blue", alpha=1.0)
+
+    @staticmethod
+    def _normalize_color(color):
+        """
+        Normalizes the background color to the range 0-1, if necessary.
+        :param color: Color as name, hex value or (R, G, B) tuple in the range 0-255.
+        :return: Color in Matplotlib-compatible format.
+        """
+        if isinstance(color, tuple) and len(color) == 3:
+            return tuple(c / 255 for c in color)
+        return color
+
+    @staticmethod
+    def _create_geodataframe(coordinates: list[tuple[float, float]]):
+        """
+        Creates a GeoDataFrame from GPS coordinates.
+        :param coordinates: List of (latitude, longitude) tuples.
+        :return: GeoDataFrame with points.
+        """
+
+        gdf = gpd.GeoDataFrame(
+            {"geometry": [Point(lon, lat) for lat, lon in coordinates]},
+            crs="EPSG:4326",
+        )
+        return gdf
+
+    def _calculate_bounds(self, geo_df):
+        """
+        Calculates the boundaries of the map section with a buffer.
+        :param geo_df: GeoDataFrame with points.
+        :return: Boundaries as (minx, miny, maxx, maxy).
+        """
+        bounds = geo_df.total_bounds  # (minx, miny, maxx, maxy)
+
+        # Calculate the height of the section based on the buffer
+
+        height_deg = abs(bounds[3] - bounds[1]) / 2
+        if height_deg < self.minimalExtension / 2:
+            height_deg = self.minimalExtension / 2
+        height_deg += self.minimalExtension / 8  # minimal margin
+
+        # Calculate the average width (average width of the points in the GeoDataFrame)
+        mid_lat = (
+            bounds[1] + bounds[3]
+        ) / 2  # Average value of the miny and maxy coordinates (latitude)
+        mid_lon = (
+            bounds[0] + bounds[2]
+        ) / 2  # Average value of minx and maxx coordinates (longitude)
+
+        lat_dis_per_deg = 111.32  # Spacing Latitude circle
+        # Calculate the width of the section taking into account the latitude
+        lon_dis_per_deg = lat_dis_per_deg * math.cos(
+            math.radians(mid_lat)
+        )  # Longitude distance in km
+        # Calculate the latitude based on the resolution and the actual longitude distance
+        width_deg = lat_dis_per_deg * height_deg * self.size[0] / self.size[1] / lon_dis_per_deg
+
+        return (
+            min(bounds[0], mid_lon - width_deg),
+            mid_lat - height_deg,
+            max(bounds[2], mid_lon + width_deg),
+            mid_lat + height_deg,
+        )
+
+    def _addLayer(self, name, shapefile_path, color="blue", edgecolor="black", alpha=0.5):
+        """
+        Adds a layer such as federal states or bodies of water.
+
+        :param name: Name of the layer.
+        :param shapefile_path: Path to the shapefile of the layer.
+        :param color: Fill color of the layer.
+        :param edgecolor: Color of the edges.
+        :param alpha: Transparency of the layer.
+        """
+        gdf = gpd.read_file(shapefile_path)
+        self.layers[name] = {
+            "gdf": gdf,
+            "color": color,
+            "edgecolor": edgecolor,
+            "alpha": alpha,
+        }
+
+    def renderMap(self, coordinates: list[tuple[float, float]]):
+        """
+        Creates a map section as a plotable object.
+        :param coordinates: List of (latitude, longitude) tuples.
+        :return: Plottable matplotlib.pyplot object.
+        """
+        # Shapefile für Ländergrenzen laden
+        world = gpd.read_file(self.shapefile_path)
+        size_marker = self.size_marker
+
+        # Kartengrenzen berechnen
+        if not coordinates:
+            points_gdf = self._create_geodataframe([(51.0504, 13.7373)])
+            self.minimalExtension = 25
+            bounds = self._calculate_bounds(points_gdf)
+            size_marker = 0
+        else:
+            # GeoDataFrame für GPS-Punkte erstellen
+            points_gdf = self._create_geodataframe(coordinates)
+            bounds = self._calculate_bounds(points_gdf)
+
+        # Karte plotten
+        fig, ax = plt.subplots(figsize=(self.size[0] / 100, self.size[1] / 100), tight_layout=True)
+        fig.patch.set_facecolor(self.background_color)
+        ax.set_facecolor(self.background_color)
+        plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
+
+        # Ländergrenzen plotten
+        # Shading of the land area for better contrast to the background
+        bg_color = (
+            mcolors.to_rgb(self.background_color)
+            if isinstance(self.background_color, str)
+            else self.background_color
+        )
+        map_land_color = tuple([x - 0.10 if x >= 0.5 else x + 0.10 for x in bg_color])
+        world.plot(
+            ax=ax,
+            color=map_land_color,
+            edgecolor=self.border_color,
+            linewidth=self.line_width * 1.0,
+        )
+
+        # Zusätzliche Layer plotten - außer im großen Europa-Plot
+        if coordinates:
+            for layer_name, layer_data in self.layers.items():
+                layer_data["gdf"].plot(
+                    ax=ax,
+                    markersize=self.size_marker,
+                    color=layer_data["color"],
+                    edgecolor=layer_data["edgecolor"],
+                    alpha=layer_data["alpha"],
+                    linewidth=self.line_width,
+                    label=layer_name,
+                )
+
+        points_gdf.plot(ax=ax, marker="o", color="red", edgecolors="red", markersize=size_marker)
+
+        # Set axes to the calculated limits
+        ax.set_xlim(bounds[0], bounds[2])
+        ax.set_ylim(bounds[1], bounds[3])
+
+        # Remove axes and edge
+        ax.axis("off")
+
+        return plt
+
+
+if __name__ == "__main__":
+    output_dir = Path.cwd()  # Speichert die Bilder im aktuellen Arbeitsverzeichnis
+
+    for size in range(100, 900, 200):
+        plotter = GeoPlotter(size=(size, size))
+
+        gps_coords = [
+            (51.0504, 13.7373),  # Dresden
+            (51.3397, 12.3731),  # Leipzig
+            (50.8278, 12.9214),  # Chemnitz
+            (51.1079, 17.0441),  # Breslau
+            (52.5200, 13.5156),  # Berlin
+        ]
+
+        map_plt = plotter.renderMap(gps_coords)
+
+        map_plt.savefig(output_dir / f"map_{size}.jpg", bbox_inches=None)
+        plt.close()

Photo_Composition_Designer/tools/Helpers.py

@@ -0,0 +1,18 @@
+from PIL import ImageFont
+
+
+# --- geometry helpers -----------------------------------------------------
+def mm_to_px(mm: float | int, dpi: float | int = 300) -> int:
+    """Convert millimeters to pixels based on DPI."""
+    return int(round(float(mm) * dpi / 25.4))
+
+
+# --- font helpers ---------------------------------------------------------
+
+
+def load_font(name: str = "DejaVuSans.ttf", size: int = 10) -> ImageFont.FreeTypeFont:
+    """Load a default TTF font, safely falling back to PIL's default."""
+    try:
+        return ImageFont.truetype(name, size)
+    except Exception:
+        return ImageFont.load_default()

Photo_Composition_Designer/tools/ImageDistributor.py

@@ -0,0 +1,153 @@
+import random
+from collections import defaultdict, deque
+from datetime import datetime, timedelta
+
+from Photo_Composition_Designer.common.Photo import Photo
+
+
+class ImageDistributor:
+    def __init__(self, photos: list[Photo], distributions_count: int):
+        self.photos = photos
+        self.sorted_photos = sorted(photos, key=lambda photo: photo.get_date() or datetime.min)
+
+        self.distribution_count = distributions_count
+
+    def distribute_equally(self) -> list[list[Photo]]:
+        """
+        Verteilt die Bilder möglichst gleichmäßig auf die gewünschte Anzahl von Gruppen.
+        """
+        grouped_images = []  # Liste von Listen für die Verteilung
+
+        # Anzahl der Bilder pro Gruppe berechnen
+        images_per_group = len(self.sorted_photos) // self.distribution_count
+        extra_images = (
+            len(self.sorted_photos) % self.distribution_count
+        )  # Falls es nicht exakt aufgeht
+
+        photo_queue = deque(self.sorted_photos)  # Nutzt deque für effiziente Pop-Operationen
+
+        for i in range(self.distribution_count):
+            group_size = images_per_group + (
+                1 if i < extra_images else 0
+            )  # Extra-Bilder gleichmäßig verteilen
+            grouped_images.append([photo_queue.popleft() for _ in range(group_size) if photo_queue])
+
+        return grouped_images
+
+    def distribute_randomly(self, allowed_delta: int = 1) -> list[list[Photo]]:
+        """
+        Ähnlich wie distribute_equally, aber mit einem gewissen Zufallseffekt,
+        sodass die Anzahl der Bilder pro Gruppe leicht variieren kann.
+        Die Reihenfolge bleibt sortiert, und ein Zufalls-Seed sorgt für Reproduzierbarkeit.
+        """
+        random.seed(11)  # Fester Seed für reproduzierbare Ergebnisse
+        grouped_images = []
+        photo_queue = deque(self.sorted_photos)  # Nutzt deque für effizientes Entfernen
+        remaining_images = len(photo_queue)
+        remaining_groups = self.distribution_count
+
+        for _i in range(self.distribution_count - 1):
+            images_per_group = remaining_images // remaining_groups
+            group_size = max(
+                1, images_per_group + random.choice(range(-allowed_delta, allowed_delta + 1))
+            )
+            grouped_images.append(
+                [photo_queue.popleft() for _ in range(min(group_size, remaining_images))]
+            )
+            remaining_images -= len(grouped_images[-1])
+            remaining_groups -= 1
+
+        # Alle verbleibenden Bilder der letzten Gruppe zuweisen
+        grouped_images.append(list(photo_queue))
+
+        return grouped_images
+
+    def distribute_group_matching_dates(
+        self, allowed_over_saturation: int = 2, allowed_under_saturation: int = 1
+    ) -> list[list[Photo]]:
+        """
+        Gruppiert Bilder mit demselben Datum zusammen,
+        während eine Über- oder Unterfüllung pro Gruppe erlaubt ist.
+        Bilder eines Tages können auf mehrere Gruppen aufgeteilt werden.
+        """
+        grouped_images = []
+        date_groups = defaultdict(list)
+
+        # Gruppiere Bilder nach ihrem Datum
+        for img in self.sorted_photos:
+            date_groups[img.get_date()].append(img)
+
+        sorted_dates = sorted(date_groups.keys())
+        remaining_images = sum(len(v) for v in date_groups.values())
+        remaining_groups = self.distribution_count
+
+        while sorted_dates and remaining_groups > 0:
+            avg_per_group = remaining_images // remaining_groups
+            current_group = []
+            current_date = sorted_dates[0]
+
+            # Füge das erste Bild des Tages hinzu
+            current_group.append(date_groups[current_date].pop(0))
+            if not date_groups[current_date]:
+                sorted_dates.pop(0)  # Datum entfernen, wenn keine Bilder mehr vorhanden sind
+
+            while sorted_dates:
+                next_date = sorted_dates[0]
+
+                if (
+                    not self.is_same_calendar_week(current_date, next_date)
+                    and len(current_group) >= avg_per_group - allowed_under_saturation
+                ):
+                    # Dieses Datum gehört nicht zur gleichen Woche & Gruppe ist ausreichend voll
+                    break
+                elif len(current_group) >= avg_per_group + allowed_over_saturation:
+                    # Gruppe hat das erlaubte Maximum erreicht
+                    break
+                else:
+                    current_group.append(date_groups[next_date].pop(0))
+                    if not date_groups[next_date]:
+                        sorted_dates.pop(0)
+
+            grouped_images.append(current_group)
+            remaining_images -= len(current_group)
+            remaining_groups -= 1
+
+        # Falls noch Bilder übrig sind, der letzten Gruppe zuweisen
+        if sorted_dates:
+            for remaining_date in sorted_dates:
+                grouped_images[-1].extend(date_groups[remaining_date])
+
+        return grouped_images
+
+    def get_monday_of_same_week(self, date: datetime) -> datetime:
+        return date - timedelta(days=date.weekday())
+
+    def is_same_calendar_week(self, date1: datetime, date2: datetime) -> bool:
+        """
+        Prüft, ob zwei Datumswerte in der gleichen Kalenderwoche liegen.
+        Berücksichtigt dabei das Jahr und die Kalenderwochen-Nummer.
+        """
+        return date1.isocalendar()[:2] == date2.isocalendar()[:2]
+
+    def distribute_by_week(self, start_date: datetime) -> list[list[Photo]]:
+        grouped_images = []
+
+        for week in range(self.distribution_count):
+            week_start = start_date + timedelta(weeks=week)
+            week_end = week_start + timedelta(days=6)
+
+            # Fotos auswählen, die in diese Woche passen
+            photos_in_week = [
+                photo
+                for photo in self.sorted_photos
+                if week_start.date() <= photo.get_date().date() <= week_end.date()
+            ]
+
+            # Entferne gefilterte Fotos aus der Hauptliste
+            self.sorted_photos = [
+                photo for photo in self.sorted_photos if photo not in photos_in_week
+            ]
+
+            grouped_images.append(photos_in_week)
+
+        return grouped_images

firewall_handler.py

@@ -0,0 +1,198 @@
+import os
+import socket
+import subprocess
+import sys
+import traceback
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+class FirewallHandler:
+    """Handles firewall detection and configuration for network access."""
+
+    def __init__(self, logger=None):
+        self.logger = logger
+        self.test_urls = [
+            "http://httpbin.org/get",
+            "http://www.google.com",
+            "https://httpbin.org/get",
+            "https://www.google.com",
+        ]
+        self.srtm_urls = [
+            "https://cloud.sdsc.edu/v1/AUTH_opentopography/Raster/SRTM_GL1/",
+            "http://cloud.sdsc.edu/v1/AUTH_opentopography/Raster/SRTM_GL1/",
+        ]
+
+    def check_network_access(self, timeout: int = 5) -> bool:
+        """Check if network access is available."""
+        self.logger.info("Checking network connectivity...")
+
+        # First check basic connectivity
+        if not self._check_basic_connectivity():
+            self.logger.warning("Basic network connectivity failed")
+            return False
+
+        # Then check HTTP access
+        if not self._check_http_access(timeout):
+            self.logger.warning("HTTP access failed")
+            return False
+
+        # Finally check SRTM-specific URLs
+        if not self._check_srtm_access(timeout):
+            self.logger.warning("SRTM service access failed")
+            return False
+
+        self.logger.info("Network access verified successfully")
+        return True
+
+    def _check_basic_connectivity(self) -> bool:
+        """Check basic network connectivity using socket."""
+        try:
+            # Try to connect to DNS servers
+            for host, port in [("8.8.8.8", 53), ("1.1.1.1", 53)]:
+                try:
+                    with socket.create_connection((host, port), timeout=3):
+                        return True
+                except (TimeoutError, OSError):
+                    continue
+            return False
+        except Exception as e:
+            self.logger.debug(f"Basic connectivity check failed: {e}")
+            return False
+
+    def _check_http_access(self, timeout: int) -> bool:
+        """Check HTTP access to common websites."""
+        for url in self.test_urls:
+            try:
+                with urllib.request.urlopen(url, timeout=timeout) as response:
+                    if response.status == 200:
+                        self.logger.debug(f"HTTP access confirmed via {url}")
+                        return True
+            except (TimeoutError, urllib.error.URLError, urllib.error.HTTPError) as e:
+                self.logger.debug(f"HTTP access failed for {url}: {e}")
+                continue
+        return False
+
+    def _check_srtm_access(self, timeout: int) -> bool:
+        """Check access to SRTM-specific URLs."""
+        for url in self.srtm_urls:
+            try:
+                with urllib.request.urlopen(url, timeout=timeout) as response:
+                    if response.status in [200, 403]:  # 403 is expected for directory listing
+                        self.logger.debug(f"SRTM access confirmed via {url}")
+                        return True
+            except (TimeoutError, urllib.error.URLError, urllib.error.HTTPError) as e:
+                self.logger.debug(f"SRTM access failed for {url}: {e}")
+                continue
+        return False
+
+    def handle_firewall_issue(self):
+        """Handle firewall issues by attempting to create rules and inform user."""
+        self.logger.info("Attempting to resolve firewall issues...")
+
+        # Get current executable path
+        exe_path = self._get_executable_path()
+        if not exe_path:
+            self.logger.error("Could not determine executable path")
+            self._show_manual_instructions()
+            return
+
+        # Try to create firewall rules
+        if self._is_windows():
+            self._handle_windows_firewall(exe_path)
+        else:
+            self._handle_linux_firewall(exe_path)
+
+    def _get_executable_path(self) -> str | None:
+        """Get the path of the current executable."""
+        try:
+            if getattr(sys, "frozen", False):
+                # PyInstaller executable
+                return sys.executable
+            else:
+                # Python script
+                return sys.executable
+        except Exception as e:
+            self.logger.error(f"Error getting executable path: {e}")
+            return None
+
+    def _is_windows(self) -> bool:
+        """Check if running on Windows."""
+        return os.name == "nt"
+
+    def _handle_windows_firewall(self, exe_path: str):
+        """Handle Windows firewall configuration."""
+        self.logger.info("Attempting to configure Windows Firewall...")
+
+        app_name = Path(exe_path).stem
+
+        # Commands to add firewall rules
+        commands = [
+            # Inbound rule
+            [
+                "netsh",
+                "advfirewall",
+                "firewall",
+                "add",
+                "rule",
+                f"name={app_name}_Inbound",
+                "dir=in",
+                "action=allow",
+                f"program={exe_path}",
+                "enable=yes",
+            ],
+            # Outbound rule
+            [
+                "netsh",
+                "advfirewall",
+                "firewall",
+                "add",
+                "rule",
+                f"name={app_name}_Outbound",
+                "dir=out",
+                "action=allow",
+                f"program={exe_path}",
+                "enable=yes",
+            ],
+        ]
+
+        success = False
+        for cmd in commands:
+            try:
+                result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+                self.logger.info(
+                    f"Firewall rule added successfully: {' '.join(cmd)} result: {result}"
+                )
+                success = True
+            except subprocess.CalledProcessError as e:
+                self.logger.warning(f"Failed to add firewall rule: {e}")
+                self.logger.debug(f"Command: {' '.join(cmd)}")
+                self.logger.debug(f"Error output: {e.stderr}")
+            except Exception as e:
+                self.logger.error(f"Unexpected error adding firewall rule: {e}")
+                self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+
+        if success:
+            self.logger.info(
+                "Windows Firewall rules added successfully. Please restart the application."
+            )
+        else:
+            self.logger.warning("Failed to automatically configure Windows Firewall.")
+            self._show_manual_instructions()
+
+    def _handle_linux_firewall(self, exe_path: str):
+        """Handle Linux firewall configuration."""
+        self.logger.info("Detected Linux system. Firewall configuration may be needed.")
+        self._show_manual_instructions()
+
+    def _show_manual_instructions(self):
+        """Show general manual instructions"""
+        self.logger.info(
+            "Please check your firewall settings and ensure the application has network access.\n"
+            "Refer to the documentation for manual configuration steps."
+            "quick solution:"
+            "Start your EXE as administrator:"
+            "Right-click on EXE → Run as administrator"
+            "Or temporarily deactivate the firewall:"
+        )