Spaces:
Running
Running
| """Typography formatting and fitting helpers.""" | |
| from __future__ import annotations | |
| import re | |
| def resolve_text_positions( | |
| *, | |
| figure_height: float, | |
| text_rect_y: float, | |
| text_rect_height: float, | |
| title_y: float, | |
| subtitle_y: float, | |
| caption_y: float, | |
| coordinates_y: float, | |
| title_size: float, | |
| subtitle_size: float, | |
| caption_size: float, | |
| coordinate_size: float, | |
| has_title: bool, | |
| has_subtitle: bool, | |
| has_caption: bool, | |
| show_coordinates: bool, | |
| ) -> dict[str, float]: | |
| """Keep poster text boxes separated when the figure becomes short and wide. | |
| Layout coordinates are normalized to the figure. Font sizes are points, so | |
| their normalized height changes with the physical figure height. Computing | |
| the stack from those two units prevents the fixed portrait coordinates from | |
| causing overlap in landscape posters. | |
| """ | |
| if figure_height <= 0: | |
| raise ValueError("Figure height must be greater than zero.") | |
| gap = 0.012 | |
| def normalized_height(size: float) -> float: | |
| return size / 72 / figure_height | |
| heights = { | |
| "title": normalized_height(title_size), | |
| "subtitle": normalized_height(subtitle_size), | |
| "caption": normalized_height(caption_size), | |
| "coordinates": normalized_height(coordinate_size), | |
| } | |
| positions = { | |
| "title": title_y, | |
| "subtitle": subtitle_y, | |
| "caption": caption_y, | |
| "coordinates": coordinates_y, | |
| } | |
| active = [ | |
| ("title", title_y, has_title), | |
| ("subtitle", subtitle_y, has_subtitle), | |
| ("caption", caption_y, has_caption), | |
| ("coordinates", coordinates_y, show_coordinates), | |
| ] | |
| previous_key: str | None = None | |
| for key, desired, enabled in active: | |
| if not enabled: | |
| continue | |
| if previous_key is not None: | |
| desired = min( | |
| desired, | |
| positions[previous_key] | |
| - heights[previous_key] / 2 | |
| - gap | |
| - heights[key] / 2, | |
| ) | |
| positions[key] = desired | |
| previous_key = key | |
| if has_title: | |
| top_limit = text_rect_y + text_rect_height - heights["title"] / 2 | |
| positions["title"] = min(positions["title"], top_limit) | |
| if has_title and has_subtitle: | |
| title_bottom = positions["title"] - heights["title"] / 2 | |
| subtitle_top = positions["subtitle"] + heights["subtitle"] / 2 | |
| positions["divider"] = (title_bottom + subtitle_top) / 2 | |
| elif has_title: | |
| positions["divider"] = positions["title"] - heights["title"] / 2 - gap / 2 | |
| else: | |
| positions["divider"] = subtitle_y | |
| return positions | |
| def has_chinese(text: str) -> bool: | |
| """Return whether text contains a CJK Unified Ideograph.""" | |
| return any("\u4e00" <= char <= "\u9fff" for char in text) | |
| def format_coordinates(latitude: float, longitude: float) -> str: | |
| """Format signed coordinates with cardinal directions.""" | |
| lat_direction = "N" if latitude >= 0 else "S" | |
| lon_direction = "E" if longitude >= 0 else "W" | |
| return f"{abs(latitude):.4f}° {lat_direction} / {abs(longitude):.4f}° {lon_direction}" | |
| def apply_letter_spacing(text: str, spacing: float) -> str: | |
| """Approximate tracking for Latin text without altering CJK text.""" | |
| if spacing <= 0 or has_chinese(text): | |
| return text | |
| gap = " " if spacing < 0.16 else " " | |
| return gap.join(text.upper()) | |
| def safe_slug(value: str, fallback: str = "map-poster") -> str: | |
| """Create a readable Unicode-safe filename slug.""" | |
| value = value.replace("_", "-") | |
| value = re.sub(r"[^\w\-]+", "-", value.strip().lower(), flags=re.UNICODE) | |
| value = re.sub(r"-+", "-", value).strip("-_") | |
| return value[:80] or fallback | |
| def safe_ascii_slug(value: str, fallback: str = "map-poster") -> str: | |
| """Create an ASCII-only filename slug by dropping non-ASCII characters. | |
| Used to build the Latin-1-safe ``filename=`` fallback of an HTTP | |
| ``Content-Disposition`` header, while ``safe_slug`` keeps the readable | |
| Unicode form transported through RFC 5987 ``filename*``. | |
| """ | |
| value = value.replace("_", "-") | |
| value = re.sub(r"[^A-Za-z0-9]+", "-", value.strip().lower()) | |
| value = re.sub(r"-+", "-", value).strip("-_") | |
| return value[:80] or fallback | |
| def fitted_font_size(text: str, requested: float, max_units: float, minimum: float = 18) -> float: | |
| """Return a deterministic first-pass title size for a bounded layout region.""" | |
| if not text: | |
| return requested | |
| units = sum(1.0 if has_chinese(char) else 0.62 for char in text) | |
| if units <= max_units: | |
| return requested | |
| return max(minimum, requested * max_units / units) | |