svgmapviewer-tools-floors 0.0.1

package/inkscape/extensions/daijimaps/resolve_labels.py

@@ -0,0 +1,65 @@
+import inkex
+import inkex.command
+
+from .resolve_names import ResolveNames
+
+# from .save_addresses import SaveAddresses
+from .types import (
+    AddressNames,
+)
+
+
+class ResolveLabels(ResolveNames):
+    # - read (Names)
+    # - read (Unresolved Labels)
+    # - match them by name
+
+    _unresolved_labels: dict[str, inkex.TextElement] = {}
+    _resolved_labels: dict[str, inkex.TextElement] = {}
+
+    unresolved_labels: AddressNames = {}
+    resolved_labels: AddressNames = {}
+
+    def _resolve_labels(self) -> None:
+        self.msg("=== resolve labels: start")
+        self.msg("=== resolve labels: end")
+
+    def _read_unresolved_labels(self, node: inkex.Group) -> None:
+        for child in list(node):
+            if not isinstance(child, inkex.TextElement):
+                # XXX msg
+                continue
+            name = child.get("inkscape:label")
+            if not name:
+                self.msg(f"loading (Unresolved Labels): {child.label}: failed")
+                continue
+            if name in self._unresolved_labels:
+                self.msg(f"duplicate label: {name}")
+                continue
+            self._unresolved_labels[name] = child
+
+    def _read_resolved_labels(self, node: inkex.Group) -> None:
+        for child in list(node):
+            if not isinstance(child, inkex.TextElement):
+                # XXX msg
+                continue
+            if not child.label:
+                self.msg(f"loading (Labels): {child}: failed")
+                continue
+            name = child.label.split(" @ ")[0]
+            if name in self._resolved_labels:
+                self.msg(f"duplicate label: {name}")
+                continue
+            self._resolved_labels[name] = child
+
+    def _prepare_unresolved_labels_group(self, layer) -> None | inkex.Group:
+        unresolved_labels_group = self._find_or_make_group(layer, "(Unresolved Labels)")
+        if unresolved_labels_group is not None:
+            self._read_unresolved_labels(unresolved_labels_group)
+        return unresolved_labels_group
+
+    def _prepare_labels_group(self, layer) -> None | inkex.Group:
+        labels_group = self._find_or_make_group(layer, "(Labels)")
+        if labels_group is not None:
+            self._read_resolved_labels(labels_group)
+        return labels_group

package/inkscape/extensions/daijimaps/resolve_names.py

@@ -0,0 +1,170 @@
+import json
+import os
+
+import inkex
+import inkex.command
+
+from .common import a2astr, a2v, xy2v, V
+from .name import read_name
+from .save_addresses import SaveAddresses
+from .types import (
+    AddressNames,
+    AddressString,
+    FloorsAddressesJson,
+    FloorsNamesJson,
+    NameAddresses,
+    TmpNameAddress,
+    TmpNameCoords,
+)
+
+
+class ResolveNames(SaveAddresses):
+    _resolved_names: NameAddresses = {}
+    _resolved_addresses: AddressNames = {}
+    _unresolved_names: NameAddresses = {}
+    _unresolved_addresses: AddressNames = {}
+    # _tmp_unresolved_name_coords: TmpNameCoords = {}
+    _tmp_resolved_names: TmpNameAddress = {}
+
+    def _exec_resolve(self) -> str:
+        exe: str = "%s/../resolve-addresses" % os.path.dirname(__file__)
+        return inkex.command.call(
+            exe,
+            self._layerPaths["addresses"],
+            self._layerPaths["tmpUnresolvedNames"],
+            self._layerPaths["tmpResolvedNames"],
+        )
+
+    def _read_names(self, node: inkex.Group) -> tuple[NameAddresses, AddressNames]:
+        name_addresses: NameAddresses = {}
+        address_names: AddressNames = {}
+        for child in list(node):
+            if not isinstance(child, inkex.TextElement):
+                # XXX msg
+                continue
+            shop = read_name(child)
+            if not shop:
+                self.msg(f"loading (Names): {child.label}: failed")
+                continue
+            (address, name, xy) = shop
+            # name -> (address, xy)
+            # address can be None
+            if name not in name_addresses:
+                name_addresses[name] = []
+            name_addresses[name].append((address, xy))
+            # address -> (name, xy)
+            # address must not be None
+            if address is None:
+                self.msg(f"skipping a resolved name without address: {name}")
+                continue
+            if address not in address_names:
+                address_names[address] = []
+            address_names[address].append((name, xy))
+
+        return (name_addresses, address_names)
+
+    def _read_resolved_names(self, node: inkex.Group) -> AddressNames:
+        (name_addresses, address_names) = self._read_names(node)
+        self._resolved_names = name_addresses
+        self._resolved_addresses = address_names
+        return address_names
+
+    def _read_unresolved_names(self, node: inkex.Group) -> NameAddresses:
+        (name_addresses, address_names) = self._read_names(node)
+        self._unresolved_names = name_addresses
+        self._unresolved_addresses = address_names
+        return name_addresses
+
+    def _load_tmp_resolved_names(self) -> None:
+        p = self._layerPaths["tmpResolvedNames"]
+        assert p is not None, "tmp resolved_names.json path is unspecified"
+        with open(p, mode="r", encoding="utf-8") as f:
+            # XXX
+            # XXX
+            # XXX
+            # XXX validate
+            j = json.load(f)
+            # XXX
+            # XXX
+            # XXX
+            self._tmp_resolved_names = j
+
+    def _get_tmp_unresolved_names(self) -> TmpNameCoords:
+        j: TmpNameCoords = {}
+        for name in self._unresolved_names:
+            xys: list[V] = list(map(a2v, self._unresolved_names[name]))
+            j[name] = xys
+        return j
+
+    def _get_floors_addresses(self) -> FloorsAddressesJson:
+        j: FloorsAddressesJson = {}
+        for astr in self._addresses:
+            ((x, y), _bb, _url) = self._addresses[astr]
+            j[astr] = xy2v(x, y)
+        return j
+
+    def _get_floors_names(self) -> FloorsNamesJson:
+        j: FloorsNamesJson = {}
+        for name in self._resolved_names:
+            aa = self._resolved_names[name]
+            xs: list[AddressString | None] = list(map(a2astr, aa))
+            j[name] = [x for x in xs if x is not None]
+        return j
+
+    def _save_resolved_names(self) -> None:
+        j: NameAddresses = self._resolved_names
+        p = self._layerPaths["resolvedNames"]
+        makedirsAndDump(p, j)
+
+    def _save_unresolved_names(self) -> None:
+        j: NameAddresses = self._unresolved_names
+        p = self._layerPaths["unresolvedNames"]
+        makedirsAndDump(p, j)
+
+    def _save_tmp_unresolved_names(self) -> None:
+        j: TmpNameCoords = self._get_tmp_unresolved_names()
+        p = self._layerPaths["tmpUnresolvedNames"]
+        makedirsAndDump(p, j)
+
+    def _save_floors_addresses(self) -> None:
+        j: FloorsAddressesJson = self._get_floors_addresses()
+        p = self._layerPaths["floorsAddresses"]
+        makedirsAndDump(p, j)
+
+    def _save_floors_names(self) -> None:
+        j: FloorsNamesJson = self._get_floors_names()
+        p = self._layerPaths["floorsNames"]
+        makedirsAndDump(p, j)
+
+    def _prepare_names_group(self, layer) -> inkex.Group | None:
+        names_group = self._find_or_make_group(layer, "(Names)")
+        self.msg(f"_process_addresses: names {names_group}")
+        if names_group is not None:
+            self._read_resolved_names(names_group)
+        else:
+            self._resolved_names = {}
+        return names_group
+
+    def _prepare_unresolved_names_group(self, layer) -> inkex.Group | None:
+        unresolved_names_group = self._find_or_make_group(layer, "(Unresolved Names)")
+        self.msg(f"_process_addresses: unresolved_names {unresolved_names_group}")
+        if unresolved_names_group is not None:
+            self._read_unresolved_names(unresolved_names_group)
+        else:
+            self._unresolved_names = {}
+        return unresolved_names_group
+
+    def _resolve_names(self):
+        self._save_tmp_unresolved_names()
+        self._exec_resolve()
+        self._load_tmp_resolved_names()
+
+
+def makedirsAndDump(p: str, j: dict) -> None:
+    d = os.path.dirname(p)
+    os.makedirs(d, exist_ok=True)
+    with open(p, mode="w", encoding="utf-8") as f:
+        json.dump(j, f, indent=2, ensure_ascii=False)
+
+
+__all__ = [ResolveNames]

package/inkscape/extensions/daijimaps/save_addresses.py

@@ -0,0 +1,274 @@
+import json
+import os
+import re
+from typing import Any
+
+import inkex
+
+from .address_tree import AddressTree
+from .common import xy2v
+from .guards import isCircle, isEllipse, isGroup, isRectangle, isUse
+from .types import AddressCoords, AddressString, Box, FacilitiesJson, FloorsInfoJson, V
+from .visit_parents import Tree, Parents
+
+
+class SaveAddresses(AddressTree):
+    def _prefix_fixup(self, prefix: str) -> str:
+        self.msg("=== _prefix_fixup@SaveAddresses")
+        # XXX
+        res = re.sub(r"-Content-", "-", prefix)
+        self.msg(f"=== _prefix_fixup@SaveAddresses: {res}")
+        return res
+
+    def _build_prefix(self, parents: list[inkex.Group]) -> str | None:
+        self.msg("=== _build_prefix@SaveAddresses")
+        plabels = [p.label for p in parents if isinstance(p.label, str)]
+        # all parents MUST have a label!
+        if None in plabels:
+            return None
+        prefix = "-".join(plabels)
+        sep = "-" if prefix != "" else ""
+        res = self._prefix_fixup(f"{self._global_prefix}{prefix}{sep}")
+        self.msg(f"=== _build_prefix@SaveAddresses: {res}")
+        return res
+
+    def _save_address2(self, astr: AddressString, px, py, bb, href) -> None:
+        self.msg(f"=== _save_address@SaveAddresses: {astr} @ {px},{py}")
+        p = (px, py)
+        self._addresses[astr] = (p, bb, href)
+        self._all_addresses[astr] = (p, bb, href)
+        if p not in self._points:
+            self._points[p] = []
+        self._points[p].append(astr)
+        if p not in self._all_points:
+            self._all_points[p] = []
+        self._all_points[p].append(astr)
+
+    def _save_address1(self, node: inkex.BaseElement, prefix: str, label: str) -> None:
+        astr = f"{prefix}{label}-{node.label}"
+        self.msg(f"=== _save_address1: {astr}")
+        bb: inkex.BoundingBox = node.shape_box()
+        c: inkex.ImmutableVector2d | None = None
+        p: inkex.ImmutableVector2d | None = None
+        tx = node.composed_transform()
+        if isUse(node):
+            x = float(node.get("x") or 0)
+            y = float(node.get("y") or 0)
+            c = inkex.ImmutableVector2d(x, y)
+        elif isCircle(node):
+            c = node.center
+        elif isEllipse(node):
+            c = node.center
+        if c is not None and bb is not None:
+            p = tx.apply_to_point(c)
+            hwh = (bb.width + bb.height) * 0.5
+            w = min(bb.width, hwh)
+            dx = (w * 0.8 - bb.width) * 0.5
+            bb = bb.resize(dx, 0)
+        if p is not None:
+            self._save_address2(astr, p.x, p.y, bb, node.href)
+
+    def _save_addresses(self, node: inkex.Group, prefix: str, label: str) -> None:
+        self.msg("=== _save_addresses@SaveAddresses")
+        for child in list(node):
+            if not isinstance(child, inkex.BaseElement):
+                continue
+            if label is None or child.label is None:
+                continue
+            self._save_address1(child, prefix, label)
+
+    def _visitor_node_branch_save_address(self, node: Tree, parents: Parents) -> None:
+        self.msg("=== _visitor_node_branch_save_address@SaveAddresses")
+        if node.label:
+            prefix = self._build_prefix(parents)
+            if prefix is not None:
+                self._save_addresses(node, prefix, node.label)
+
+    def _visitor_node_branch(self, node: Tree, parents: Parents) -> None:
+        self.msg("=== _visitor_node_branch@SaveAddresses")
+        self._visitor_node_branch_save_address(node, parents)
+
+    def _sort_children(self, node: inkex.Group) -> None:
+        self.msg("=== _sort_children@SaveAddresses")
+        children: dict[str, list[inkex.BaseElement]] = {}
+        for a in list(node):
+            if isinstance(a, inkex.Group) and a.label:
+                node.remove(a)
+                # a.label looks like: "Sov. @ A4F-Shops-1-3"
+                if a.label not in children:
+                    children[a.label] = []
+                children[a.label].append(a)
+        # assume alphabetical order
+        labels = sorted(children.keys(), key=lambda label: str.lower(label))
+        for label in labels:
+            for a in children[label]:
+                node.append(a)
+
+    def _get_addresses_coords(self) -> AddressCoords:
+        j: AddressCoords = {}
+        for astr, ((x, y), _bb, _href) in self._addresses.items():
+            j[astr] = xy2v(x, y)
+        return j
+
+    def _get_origin(self) -> V | None:
+        origins: Any = self.svg.xpath(
+            '//*[@*[name()="inkscape:label"]="(Assets)"]/*[@*[name()="inkscape:label"]="(Origin)"]'
+        )
+        if not isinstance(origins, list) or len(origins) != 1:
+            self.msg("_get_origin: not found!")
+            return None
+        origin = list(origins)[0]
+        if not isCircle(origin):
+            self.msg("_get_origin: not circle!")
+            return None
+        c: inkex.ImmutableVector2d = origin.center
+        j: V = {
+            "x": c.x,
+            "y": c.y,
+        }
+        return j
+
+    def _get_viewbox(self, name="(ViewBox)") -> Box | None:
+        viewboxes: Any = self.svg.xpath(
+            f'//*[@*[name()="inkscape:label"]="(Assets)"]/*[@*[name()="inkscape:label"]="{name}"]'
+        )
+        if not isinstance(viewboxes, list) or len(viewboxes) != 1:
+            self.msg(f"_get_viewbox: not found! (name={name})")
+            return None
+        viewbox = list(viewboxes)[0]
+        if not isRectangle(viewbox):
+            self.msg(f"_get_viewbox: not rectangle! (name={name})")
+            return None
+        j: Box = {
+            "x": viewbox.left,
+            "y": viewbox.top,
+            "width": viewbox.width,
+            "height": viewbox.height,
+        }
+        return j
+
+    def _get_bbox(self):
+        return self._get_viewbox(name="(BoundingBox)")
+
+    def _get_floor(self, e: Any) -> tuple[str, FloorsInfoJson] | None:
+        if not isGroup(e):
+            self.msg(f"_get_floors: not group! ({e})")
+            return None
+        label = e.label
+        if label is None:
+            self.msg(f"_get_floors: no label! ({e})")
+            return None
+        # find 'Content'
+        subelems = e.xpath("./*[@*[name()='inkscape:label']='Content']")
+        if not isinstance(subelems, list) or len(subelems) != 1:
+            self.msg(f"_get_floors: not found! {subelems}")
+            return None
+        content = subelems[0]
+        if not isGroup(content):
+            self.msg(f"_get_floors: not group! ({content})")
+            return None
+        id = content.get_id()
+        return (
+            label,
+            {
+                "contentId": id,
+            },
+        )
+
+    def _get_floors(self) -> dict[str, FloorsInfoJson] | None:
+        elems: Any = self.svg.xpath("/*/*[@*[name()='inkscape:groupmode']='layer']")
+        if not isinstance(elems, list):
+            self.msg(f"_get_floors: not found! {elems}")
+            return None
+        layers: dict[str, FloorsInfoJson] = {}
+        for e in elems:
+            res = self._get_floor(e)
+            if res is None:
+                continue
+            (label, info) = res
+            layers[label] = info
+        return layers
+
+    def _save_addresses_coords(self, node):
+        j: AddressCoords = self._get_addresses_coords()
+        p = self._layerPaths["addresses"]
+        makedirsAndDump(p, j)
+
+    def _save_origin(self):
+        j: V | None = self._get_origin()
+        if j is None:
+            return
+        p = self._paths["origin"]
+        makedirsAndDump(p, dict(j))
+
+    def _save_viewbox(self):
+        j: Box | None = self._get_viewbox()
+        if j is None:
+            return
+        p = self._paths["viewbox"]
+        makedirsAndDump(p, dict(j))
+
+    def _save_bbox(self):
+        j: Box | None = self._get_bbox()
+        if j is None:
+            return
+        p = self._paths["bbox"]
+        makedirsAndDump(p, dict(j))
+
+    def _save_floors(self):
+        j: dict[str, FloorsInfoJson] | None = self._get_floors()
+        if j is None:
+            return
+        p = self._paths["floors"]
+        makedirsAndDump(p, dict(j))
+
+    def _post_collect_addresses(self, node):
+        self.msg("=== _post_collect_addresses@SaveAddresses")
+
+        self._save_addresses_coords(node)
+        self._save_origin()
+        self._save_viewbox()
+        self._save_bbox()
+        self._save_floors()
+
+        self.msg("=== _post_collect_addresses@SaveAddresses")
+
+    def _collect_links(self) -> None:
+        self.msg("=== _collect_links@SaveAddresses")
+        n = 1
+        for p in self._all_points:
+            if len(p) == 1:
+                continue
+            xs: list[AddressString] = [
+                a for a in self._all_points[p] if re.match("^.*-Facilities-.*$", a)
+            ]
+            if len(xs) <= 1:
+                continue
+            # XXX check kind (e.g. Elevator, Stairs)
+            # XXX don't hardcode
+            xxs: list[AddressString] = [
+                x for x in xs if re.match("^.*(Elevator|Stairs).*$", x)
+            ]
+            if len(xxs) <= 1:
+                continue
+            self.msg(f"links: {p}: {self._all_points[p]}")
+            self._links[str(n)] = xxs
+            n = n + 1
+
+    def _save_links(self) -> None:
+        self.msg("=== _save_links@SaveAddresses")
+        j: FacilitiesJson = {"biLinks": self._links}
+
+        p = self._paths["facilities"]
+        assert isinstance(p, str)
+        makedirsAndDump(p, dict(j))
+
+
+def makedirsAndDump(p: str, j: dict) -> None:
+    d = os.path.dirname(p)
+    os.makedirs(d, exist_ok=True)
+    with open(p, mode="w", encoding="utf-8") as f:
+        json.dump(j, f, indent=2, ensure_ascii=False)
+
+
+__all__ = [SaveAddresses]

package/inkscape/extensions/daijimaps/types.py

@@ -0,0 +1,128 @@
+import inkex
+from typing import TypedDict
+
+
+type Url = str
+
+type AddressPosEntry = tuple[XY, inkex.BoundingBox, Url]
+type AddressPos = dict[AddressString, AddressPosEntry]
+type PosAddress = dict[XY, list[AddressString]]
+
+type AddressString = str
+type NameString = str
+type XY = tuple[float, float]
+
+type Address = tuple[AddressString | None, XY]
+type Addresses = list[Address]
+type NameAddresses = dict[NameString, Addresses]
+
+type Name = tuple[NameString, XY]
+type Names = list[Name]
+type AddressNames = dict[AddressString, Names]
+
+
+class V(TypedDict):
+    x: float
+    y: float
+
+
+class Box(TypedDict):
+    x: float
+    y: float
+    width: float
+    height: float
+
+
+type AddressCoords = dict[AddressString, V]  # addresses.json
+
+type TmpNameCoords = dict[NameString, list[V]]  # tmp_unresolved_addresses.json
+type TmpNameAddress = dict[
+    NameString, list[AddressString]
+]  # tmp_resolved_addresses.json
+
+
+# XXX
+type LinkID = str
+type Links = dict[LinkID, list[AddressString]]
+
+
+# XXX
+class FacilitiesJson(TypedDict):
+    biLinks: Links
+
+
+#
+# JSON for svgmapviewer floors
+#
+type FloorsAddressesJson = dict[AddressString, V]  # floors-1F-addresses.json
+type FloorsNamesJson = dict[NameString, list[AddressString]]  # floors-1F-names.json
+
+
+# XXX
+class FloorsInfoJson(TypedDict):
+    contentId: str
+
+
+class TspanInfoJson(TypedDict):
+    attrs: dict[str, str]
+    text: str
+
+
+class TextInfoJson(TypedDict):
+    attrs: dict[str, str]
+    children: list[TspanInfoJson]
+
+
+#
+# File paths
+#
+class JsonGlobalPaths(TypedDict):
+    facilities: str
+    floors: str
+    origin: str
+    viewbox: str
+    bbox: str
+
+
+#
+# Per-layer file paths
+#
+class JsonLayerPaths(TypedDict):
+    addresses: str
+    unresolvedNames: str
+    resolvedNames: str
+    tmpUnresolvedNames: str
+    tmpResolvedNames: str
+    floorsAddresses: str
+    floorsNames: str
+
+
+__all__ = [
+    # .address_tree
+    Address,
+    AddressNames,
+    AddressPos,
+    AddressPosEntry,
+    AddressString,
+    Addresses,
+    Box,
+    FacilitiesJson,
+    FloorsInfoJson,
+    JsonGlobalPaths,
+    JsonLayerPaths,
+    FloorsAddressesJson,
+    FloorsNamesJson,
+    Links,
+    Name,
+    NameAddresses,
+    NameString,
+    Names,
+    AddressCoords,
+    TextInfoJson,
+    TmpNameCoords,
+    TmpNameAddress,
+    TspanInfoJson,
+    Url,
+    XY,
+    V,
+]

package/inkscape/extensions/daijimaps/visit_parents.py

@@ -0,0 +1,37 @@
+import typing
+from typing import Callable
+import inkex
+
+
+type Cont = typing.Literal[0]
+type Skip = typing.Literal[1]
+type Exit = typing.Literal[2]
+type Visit = Cont | Skip | Exit
+
+type Tree = inkex.Group
+type Parents = list[inkex.Group]
+type Visitor = Callable[[Tree, Parents], Visit]
+
+
+CONT = 0
+SKIP = 1
+EXIT = 2
+
+
+def _visit_parents_inner(tree: Tree, parents: Parents, visitor: Visitor) -> None:
+    res = visitor(tree, parents)
+    if res == SKIP:
+        return
+    parents.append(tree)
+    for child in list(tree):
+        if not isinstance(child, inkex.Group):
+            continue
+        _visit_parents_inner(child, parents, visitor)
+    parents.pop()
+
+
+def _visit_parents(tree: Tree, visitor: Visitor) -> None:
+    _visit_parents_inner(tree, [], visitor)
+
+
+__all__ = [Parents, Tree, Visit, Visitor, CONT, SKIP, EXIT, _visit_parents]