svgmapviewer-tools-floors 0.0.1

package/inkscape/extensions/daijimaps/__init__.py

@@ -0,0 +1,72 @@
+from .address_tree import AddressTree
+
+from .generate_addresses import GenerateAddresses
+
+from .guards import (
+    isBaseElement,
+    isCircle,
+    isEllipse,
+    isGroup,
+    isRectangle,
+    isTextElement,
+    isUse,
+)
+
+from .name import draw_label, draw_name, move_name, preferInt, read_name, redraw_name
+
+from .renumber import renumber_group
+
+from .resolve_names import ResolveNames
+
+from .save_addresses import SaveAddresses
+
+from .types import (
+    Address,
+    AddressNames,
+    AddressString,
+    Addresses,
+    Name,
+    NameAddresses,
+    NameString,
+    Names,
+    XY,
+)
+
+
+__all__ = [
+    # .address_tree
+    AddressTree,
+    # .generate_addresses
+    GenerateAddresses,
+    # .guards
+    isBaseElement,
+    isCircle,
+    isEllipse,
+    isGroup,
+    isRectangle,
+    isTextElement,
+    isUse,
+    # .name
+    draw_label,
+    draw_name,
+    move_name,
+    preferInt,
+    read_name,
+    redraw_name,
+    # .renumber
+    renumber_group,
+    # .resolve_names
+    ResolveNames,
+    # .save_addresses
+    SaveAddresses,
+    # .types
+    Address,
+    AddressNames,
+    AddressString,
+    Addresses,
+    Name,
+    NameAddresses,
+    NameString,
+    Names,
+    XY,
+]

package/inkscape/extensions/daijimaps/address_tree.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+from argparse import ArgumentParser
+import inkex
+import re
+import os
+from lxml import etree
+from .visit_parents import _visit_parents, CONT, SKIP, Visit, Tree, Parents
+from .types import AddressPos, JsonGlobalPaths, JsonLayerPaths, Links, PosAddress
+
+
+class AddressTree(inkex.EffectExtension):
+    _layers: list[inkex.Group] = []
+
+    _addresses: AddressPos = {}
+    _all_addresses: AddressPos = {}
+    _points: PosAddress = {}
+    _all_points: PosAddress = {}
+    _links: Links = {}
+
+    # XXX address <g> id
+    # XXX (A)ddress
+    # e.g. `A1F-Shops-1-1`
+    _global_prefix = "A"
+
+    # e.g. `(Contents)`
+    _ignore_pattern = "^[(].*[)]$"
+
+    _layerPaths: JsonLayerPaths
+    _paths: JsonGlobalPaths
+
+    _find_layers_opts = {"skip_ignoring": True}
+
+    def _get_path(self, layer_name: str, prefix: str, suffix: str) -> str | None:
+        assert isinstance(layer_name, str)
+        ps = [
+            f"floors/{layer_name}/{prefix}.{suffix}",
+            f"floors/{prefix}/{layer_name}.{suffix}",
+            f"floors/{layer_name}-{prefix}.{suffix}",
+            f"floors/{prefix}-{layer_name}.{suffix}",
+            f"{layer_name}/{prefix}.{suffix}",
+            f"{prefix}/{layer_name}.{suffix}",
+            f"{layer_name}-{prefix}.{suffix}",
+            f"{prefix}-{layer_name}.{suffix}",
+        ]
+        svg_path: str = self.svg_path()
+        assert isinstance(svg_path, str)
+        for p in ps:
+            path: str = os.path.join(svg_path, p)
+            self.msg(f"_get_path: {path}")
+            if os.access(path, os.R_OK):
+                self.msg(f"_get_path: found: {path}")
+                return path
+        self.msg(f"_get_path: not found: {prefix}, {suffix}")
+        return None
+
+    def _ignoring(self, node):
+        return re.match(self._ignore_pattern, node.label) is not None
+
+    def _visitor_node_branch(self, node: Tree, parents: Parents) -> None:
+        pass
+
+    def _visitor_node_leaf(self, node: Tree, parents: Parents) -> None:
+        pass
+
+    def _visitor(self, node: Tree, parents: Parents) -> Visit:
+        if not isinstance(node, inkex.Group):
+            return SKIP
+        if node.label and self._ignoring(node):
+            return SKIP
+
+        # (T) Leaf (terminal) node?
+        # leaves MUST be <use> and define transform!
+        # XXX why `is not None` doesn't work?
+        leaf = isinstance(node, inkex.Use) and node.transform
+
+        if leaf:
+            self._visitor_node_leaf(node, parents)
+            return SKIP
+        else:
+            self._visitor_node_branch(node, parents)
+            return CONT
+
+    def _pre_collect_addresses(self, node) -> None:
+        pass
+
+    def _collect_addresses(self, node) -> None:
+        self.msg("=== _collect_addresses@AddressTree")
+        self._addresses = {}
+        self._points = {}
+
+        _visit_parents(node, self._visitor)
+
+    def _post_collect_addresses(self, node: inkex.Group) -> None:
+        pass
+
+    def _pre_process_addresses(self, node: inkex.Group) -> None:
+        pass
+
+    def _process_addresses(self, node: inkex.Group) -> None:
+        pass
+
+    def _post_process_addresses(self, node: inkex.Group) -> None:
+        pass
+
+    def _pre_layers(self) -> None:
+        pass
+
+    def _post_layers(self) -> None:
+        pass
+
+    def _find_group(self, layer, label) -> inkex.Group | None:
+        for child in list(layer):
+            if "label" in child:
+                self.msg(f"_find_group: {child.label}")
+            if not isinstance(child, inkex.Group):
+                # XXX msg
+                continue
+            if child.label is None or child.label != label:
+                # XXX msg
+                continue
+            self.msg(f"_find_group: found: {child.label}")
+            return child
+        return None
+
+    def _find_or_make_group(self, layer, label) -> inkex.Layer:
+        group = self._find_group(layer, label)
+        if group is None:
+            group = inkex.Layer()
+            group.label = label
+            layer.append(group)
+        return group
+
+    def _find_layers(self) -> None:
+        self.msg("=== _find_layers")
+        floor_pattern: str = self.options.floor
+
+        assert isinstance(self.document, etree._ElementTree)
+        assert isinstance(floor_pattern, str | None)
+        self._layers: list[inkex.Group] = [
+            node
+            for node in self.document.getroot()
+            if isinstance(node, inkex.Group)
+            if not (
+                node.label
+                and (self._find_layers_opts["skip_ignoring"] and self._ignoring(node))
+            )
+            if (
+                floor_pattern is None
+                or not isinstance(node.label, str)
+                or re.match(floor_pattern, node.label) is not None
+            )
+        ]
+        self.msg(f"=== _find_layers: {self._layers}")
+
+    def _find_assets(self) -> inkex.Group | None:
+        assert isinstance(self.document, etree._ElementTree), ""
+        res: list[inkex.Group] = [
+            node
+            for node in self.document.getroot()
+            if isinstance(node, inkex.Group)
+            if not (node.label and self._ignoring(node))
+            if isinstance(node.label, str)
+            and re.match("^(Assets)$", node.label) is not None
+        ]
+        if len(res) != 1:
+            return None
+        else:
+            return res[0]
+
+    def _set_paths(self, layer_name: str):
+        p = self.svg_path()
+        assert isinstance(p, str)
+
+        j = os.path.join
+        ln = layer_name
+
+        self._layerPaths = {
+            "addresses": j(p, f"addresses/{ln}.json"),
+            "unresolvedNames": j(p, f"unresolved_names/{ln}.json"),
+            "resolvedNames": j(p, f"resolved_names/{ln}.json"),
+            "tmpUnresolvedNames": j("/tmp", f"tmp_unresolved_names_{ln}.json"),
+            "tmpResolvedNames": j("/tmp", f"tmp_resolved_names_{ln}.json"),
+            "floorsAddresses": j(p, f"floors-addresses-{ln}.json"),
+            "floorsNames": j(p, f"floors-names-{ln}.json"),
+        }
+        self._paths = {
+            "bbox": j(p, "bbox.json"),
+            "facilities": j(p, "facilities.json"),
+            "floors": j(p, "floors.json"),
+            "origin": j(p, "origin.json"),
+            "viewbox": j(p, "viewbox.json"),
+        }
+
+    def _handle_layer(self, layer: inkex.Group, layer_name: str) -> None:
+        # XXX set .json paths
+        # input
+        # self._locs_json = os.path.join(self.svg_path(), "build", f"locs_{layer_name}.json")
+        # self._locs_json = os.path.join(self.svg_path(), f"locs.json")
+
+        self._set_paths(layer_name)
+
+        self._pre_collect_addresses(layer)
+        self._collect_addresses(layer)
+        self._post_collect_addresses(layer)
+        self._pre_process_addresses(layer)
+        self._process_addresses(layer)
+        self._post_process_addresses(layer)
+
+    def add_arguments(self, pars: ArgumentParser) -> None:
+        pars.add_argument("--tab", type=str, dest="tab")
+        pars.add_argument("--floor", type=str, default=".")
+        return super().add_arguments(pars)
+
+    def effect(self) -> None:
+        self.msg("==== AddressTree: start")
+        self._find_layers()
+        self._pre_layers()
+        for layer in self._layers:
+            layer_name = layer.label
+            if not isinstance(layer_name, str):
+                continue
+            self._handle_layer(layer, layer_name)
+        self._post_layers()
+        self.msg("==== AddressTree: end")
+
+
+__all__ = [
+    AddressTree,
+]

package/inkscape/extensions/daijimaps/common.py

@@ -0,0 +1,49 @@
+import os
+
+from .types import Address, AddressString, V
+
+
+# XXX prefer 1 to 1.0
+def unround(n: float) -> float:
+    f: float = round(n, ndigits=3)
+    i: float = round(f)
+    return f if f != i else i
+
+
+def xy2v(x, y) -> V:
+    return {
+        "x": unround(x),
+        "y": unround(y),
+        #'w': r3w if r3w != rw else rw,
+    }
+
+
+def a2astr(axy: Address) -> AddressString | None:
+    (astr, _xy) = axy
+    return astr
+
+
+def a2v(axy: Address) -> V:
+    (_a, (x, y)) = axy
+    return xy2v(x, y)
+
+
+def find_layer_file(dir: str, layer: str, prefix: str, suffix: str) -> str | None:
+    ps: list[str] = [
+        f"floors/{layer}/{prefix}.{suffix}",
+        f"floors/{prefix}/{layer}.{suffix}",
+        f"floors/{layer}-{prefix}.{suffix}",
+        f"floors/{prefix}-{layer}.{suffix}",
+        f"{layer}/{prefix}.{suffix}",
+        f"{prefix}/{layer}.{suffix}",
+        f"{layer}-{prefix}.{suffix}",
+        f"{prefix}-{layer}.{suffix}",
+    ]
+    for p in ps:
+        path: str = os.path.join(dir, p)
+        if os.access(path, mode=os.R_OK):
+            return path
+    return None
+
+
+__all__ = [a2astr, a2v, xy2v]

package/inkscape/extensions/daijimaps/generate_addresses.py

@@ -0,0 +1,41 @@
+import inkex
+
+from .save_addresses import SaveAddresses
+
+
+class GenerateAddresses(SaveAddresses):
+    _group_label = "(Addresses)"
+
+    def _cleanup_addresses(self, layer) -> None:
+        for child in list(layer):
+            if "label" in child and child.label == self._group_label:
+                child.delete()
+
+    def _generate_addresses_address(self, aparent, k, x, y, bb, href) -> None:
+        pass
+
+    def _generate_addresses(self, layer, layer_name: str) -> None:
+        self.msg("=== GenerateAddresses: _generate_addresses")
+        if len(self._addresses.items()) == 0:
+            self.msg("_generate_addresses: no items found!")
+            return
+
+        aparent = inkex.Group()
+        aparent.label = self._group_label
+        for k, ((x, y), bb, href) in self._addresses.items():
+            self._generate_addresses_address(aparent, k, x, y, bb, href)
+        layer.append(aparent)
+
+    def _pre_process_addresses(self, node: inkex.Group) -> None:
+        super()._pre_process_addresses(node)
+        self._cleanup_addresses(node)
+
+    def _process_addresses(self, node: inkex.Group) -> None:
+        self.msg("=== GenerateAddresses: _process_addresses")
+        super()._process_addresses(node)
+        name = node.label
+        if isinstance(name, str):
+            self._generate_addresses(node, name)
+
+
+__all__ = [GenerateAddresses]

package/inkscape/extensions/daijimaps/guards.py

@@ -0,0 +1,47 @@
+from typing import Any, TypeGuard
+
+import inkex
+
+
+def isBaseElement(x: Any) -> TypeGuard[inkex.BaseElement]:
+    return isinstance(x, inkex.BaseElement)
+
+
+def isCircle(x: Any) -> TypeGuard[inkex.Circle]:
+    return isinstance(x, inkex.Circle)
+
+
+def isEllipse(x: Any) -> TypeGuard[inkex.Ellipse]:
+    return isinstance(x, inkex.Ellipse)
+
+
+def isGroup(x: Any) -> TypeGuard[inkex.Group]:
+    return isinstance(x, inkex.Group)
+
+
+def isRectangle(x: Any) -> TypeGuard[inkex.Rectangle]:
+    return isinstance(x, inkex.Rectangle)
+
+
+def isTextElement(x: Any) -> TypeGuard[inkex.TextElement]:
+    return isinstance(x, inkex.TextElement)
+
+
+def isTspan(x: Any) -> TypeGuard[inkex.Tspan]:
+    return isinstance(x, inkex.Tspan)
+
+
+def isUse(x: Any) -> TypeGuard[inkex.Use]:
+    return isinstance(x, inkex.Use)
+
+
+__all__ = [
+    isBaseElement,
+    isCircle,
+    isEllipse,
+    isGroup,
+    isRectangle,
+    isTextElement,
+    isTspan,
+    isUse,
+]

package/inkscape/extensions/daijimaps/map_layer.py

@@ -0,0 +1,47 @@
+import inkex
+
+
+def fixup_tree_layer(group: inkex.Group) -> None:
+    layer_names = [
+        "(Names)",
+        "(Unresolved Names)",
+        "(Labels)",
+        "(Unresolved Labels)",
+        "Content",
+        "(Background)",
+    ]
+    for layer_name in layer_names:
+        find_layer_and_change_to_layer(group, layer_name)
+
+
+def fixup_tree_layer_content(group: inkex.Group) -> None:
+    layer_names: list[str] = [
+        "(Labels)",
+        "(Unresolved Labels)",
+        "(Facilities)",
+        "(Shops)",
+        "Facilities",
+        "Shops",
+        "(Barriers)",
+        "(Spaces)",
+        "(Backgrounds)",
+        "(Background)",
+    ]
+    for layer_name in layer_names:
+        find_layer_and_change_to_layer(group, layer_name)
+
+
+def find_layer_and_change_to_layer(group: inkex.Group, name: str) -> None:
+    for child in list(group):
+        if isinstance(child, inkex.Group) and child.label == name:
+            group_to_layer(child)
+
+
+def group_to_layer(group: inkex.Group) -> inkex.Layer:
+    group_mode = group.get("inkscape:groupmode", None)
+    if group_mode != "layer":
+        group.set("inkscape:groupmode", "layer")
+    return group
+
+
+__all__: list[str] = ["fixup_tree_layer", "fixup_tree_layer_content"]

package/inkscape/extensions/daijimaps/name.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+from .types import AddressString, NameString, XY
+
+
+def preferInt(n: float) -> float | int:
+    r: float = round(n)
+    return r if r == n else int(n)
+
+
+def draw_label(text: str, size: float, x: float = 0, y: float = 0) -> inkex.TextElement:
+    t = inkex.TextElement()
+    t.label = text
+    t.update(
+        **{
+            "font-family": "'Noto Sans'",
+            # "-inkscape-font-specification": "'Noto Sans Ultra-Light'",
+            "font-size": f"{size}",
+            "font-weight": "200",
+            "line-height": "1.5",
+            "text-anchor": "middle",
+            "text-align": "center",
+            "writing-mode": "lr-tb",
+            "direction": "ltr",
+            "fill": "#000000",
+            "stroke": "none",
+        }
+    )
+    txts: list[str] = text.split()
+    for txt in txts:
+        ts = inkex.Tspan()
+        ts.text = txt
+        ts.update(
+            **{
+                "dy": 0,
+                "sodipodi:role": "line",
+            }
+        )
+        t.append(ts)
+    return t
+
+
+def draw_name(text: str, x: float = 0, y: float = 0) -> inkex.TextElement:
+    t = inkex.TextElement()
+    t.label = text
+    t.update(
+        **{
+            "x": round(x),
+            "y": round(y),
+            "font-size": "2px",
+            "text-anchor": "middle",
+        }
+    )
+    ts = inkex.Tspan()
+    ts.text = text
+    t.append(ts)
+    return t
+
+
+def redraw_name(
+    t: inkex.TextElement, text: str, x: float = 0, y: float = 0
+) -> inkex.TextElement:
+    t.label = text
+    t.update(
+        **{
+            "x": round(x),
+            "y": round(y),
+            "font-size": "2px",
+            "text-anchor": "middle",
+        }
+    )
+    first = None
+    for ts in t:
+        if first is None:
+            first = ts
+        else:
+            t.remove(ts)
+    if first is not None:
+        first.text = text
+    else:
+        ts = inkex.Tspan()
+        ts.text = text
+        t.append(ts)
+    return t
+
+
+def remove_children_by_label(
+    group: inkex.Group, label: str
+) -> inkex.TextElement | None:
+    for child in group:
+        if not isinstance(child, inkex.TextElement):
+            # XXX msg
+            continue
+        if child.label == label:
+            group.remove(child)
+            return child
+    return None
+
+
+def move_name(
+    old_group: inkex.Group,
+    new_group: inkex.Group,
+    old_name: str,
+    new_name: str,
+    x: float,
+    y: float,
+) -> inkex.Group | None:
+    remove_children_by_label(new_group, new_name)
+    child = remove_children_by_label(old_group, old_name)
+    t = (
+        draw_name(new_name, x, y)
+        if child is None or not isinstance(child, inkex.TextElement)
+        else redraw_name(child, new_name, x, y)
+    )
+    new_group.append(t)
+
+
+type NameEntry = tuple[None | AddressString, NameString, XY]
+
+
+def read_name(node: inkex.BaseElement) -> None | NameEntry:
+    if not isinstance(node, inkex.TextElement):
+        return None
+    assert isinstance(node.label, str)
+    name_and_address: list[str] = node.label.split(" @ ")
+    name: str = name_and_address[0]
+    if len(name_and_address) == 1:
+        address = None
+    else:
+        address: str = name_and_address[1]
+
+    # check "unmoved" node (x == 0 and y == 0 and transform is None)
+    (x, y) = (node.x, node.y)
+    tx = node.transform
+    p = (
+        inkex.Vector2d(0, 0)
+        if (x == 0 and y == 0 and tx is None)
+        else inkex.Vector2d(x, y)
+        if tx is None
+        else tx.apply_to_point(inkex.Vector2d(x, y))
+    )
+    return (address, name, (round(p.x), round(p.y)))
+
+
+def move_label(
+    old_group: inkex.Group,
+    new_group: inkex.Group,
+    old_name: str,
+    new_name: str,
+    x: None | float = None,
+    y: None | float = None,
+) -> inkex.Group | None:
+    remove_children_by_label(new_group, new_name)
+    child = remove_children_by_label(old_group, old_name)
+    if child is None:
+        return
+    child.label = new_name
+    child.transform = None
+    child.set("x", None)
+    child.set("y", None)
+    new_group.append(child)
+
+
+__all__ = [draw_label, draw_name, move_name, read_name, redraw_name, move_label]

package/inkscape/extensions/daijimaps/renumber.py

@@ -0,0 +1,38 @@
+import re
+
+import inkex
+
+import daijimaps
+
+
+# XXX show log?
+def renumber_group(node: inkex.Group):
+    ngroups = 0
+    nnongroups = 0
+    nnames = 0
+    m = re.compile("^[A-Z].*$")
+    for child in list(node):
+        if not daijimaps.isBaseElement(child):
+            continue
+        if isinstance(child, inkex.Group):
+            ngroups = ngroups + 1
+        else:
+            nnongroups = nnongroups + 1
+        label = child.label
+        if label is not None and m.match(label):
+            nnames = nnames + 1
+    # non-mixed children => renumber children
+    if (ngroups == 0 and nnames == 0) or (nnongroups == 0 and nnames == 0):
+        for idx, child in enumerate(list(node)):
+            if not daijimaps.isBaseElement(child):
+                continue
+            child.label = idx + 1
+    # all children are group => recurse into children
+    if nnongroups == 0:
+        for child in list(node):
+            if not daijimaps.isGroup(child):
+                continue
+            renumber_group(child)
+
+
+__all__ = [renumber_group]