svgmapviewer-tools-floors 0.0.1

package/inkscape/extensions/resolve_labels.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+import inkex.command
+
+import daijimaps
+import daijimaps.resolve_labels
+
+
+PX_PER_MM = 3.779527559
+
+
+class ResolveLabels(daijimaps.resolve_labels.ResolveLabels):
+    _bounding_boxes: dict[str, inkex.BoundingBox] = {}
+
+    def _exec_query_all(self) -> str:
+        return inkex.command.call(
+            "inkscape",
+            "--query-all",
+            self.document_path(),
+        )
+
+    def _load_bounding_boxes(self) -> None:
+        self._bounding_boxes = {}
+        query_all_result = self._exec_query_all()
+        # self.msg(f"query_all_result: {query_all_result}")
+        for line in query_all_result.splitlines():
+            if len(line) == 0:
+                continue
+            try:
+                (id, x, y, width, height) = line.split(",")
+                bb = inkex.BoundingBox.new_xywh(
+                    float(x), float(y), float(width), float(height)
+                )
+                self._bounding_boxes[id] = bb
+            except Exception as e:
+                self.msg(f"failed to parse --query-all result: {line}: {e}")
+
+    def _move_resolved_name(
+        self,
+        names_group: inkex.Group,
+        unresolved_names_group: inkex.Group,
+        astr: str,
+        name: str,
+    ) -> None:
+        label = f"{name} @ {astr}"
+        ((x, y), _bb, _href) = self._addresses[astr]
+        daijimaps.move_name(unresolved_names_group, names_group, name, label, x, y)
+
+    def _move_resolved_names(
+        self, names_group: inkex.Group, unresolved_names_group: inkex.Group
+    ) -> None:
+        self.msg(f"drawing result {self._tmp_resolved_names}")
+        for name, astrs in self._tmp_resolved_names.items():
+            for astr in astrs:
+                self._move_resolved_name(
+                    names_group, unresolved_names_group, astr, name
+                )
+        self._sort_children(names_group)
+
+    def _process_addresses(self, node) -> None:
+        self.msg("=== resolve: start")
+
+        self._load_bounding_boxes()
+        # self.msg(f"_bounding_boxes: {self._bounding_boxes}")
+
+        names_group = self._prepare_names_group(node)
+        if names_group is None:
+            self.msg("(Names) group does not exist!")
+            return
+
+        unresolved_labels_group = self._prepare_unresolved_labels_group(node)
+        if unresolved_labels_group is None:
+            self.msg("(Unresolved Labels) group does not exist!")
+            return
+
+        labels_group = self._prepare_labels_group(node)
+        if labels_group is None:
+            self.msg("(Labels) group does not exist!")
+            return
+
+        # self.msg(f"_unresolved_labels: {self._unresolved_labels}")
+
+        for name, text_element in self._unresolved_labels.items():
+            addresses = self._resolved_names.get(name)
+            if addresses is None:
+                self.msg(f"_unresolved_labels: {name} {text_element}: no resolved name")
+                continue
+            bb = self._bounding_boxes.get(text_element.get_id())
+            if bb is None:
+                self.msg(f"_unresolved_labels: {name} {text_element}: no bounding box")
+                continue
+            c = bb.center
+            if c is None:
+                self.msg(f"_unresolved_labels: {name} {text_element}: no center")
+                continue
+            # XXX TODO Support multiple addresses for a name
+            (address, xy) = addresses[0]
+            if address is None:
+                self.msg(f"_unresolved_labels: {name} {text_element}: no address")
+                continue
+            (x, y) = xy
+            dcx = - c.x / PX_PER_MM  # XXX unit
+            dcy = - c.y / PX_PER_MM  # XXX unit
+            self.msg(f"_unresolved_labels: {name}@{xy} -> {c} ({x + dcx}, {y + dcy})")
+            t = text_element.transform
+            t2 = (
+                #t.add_translate(dcx, dcy).add_translate(x, y)
+                #if t is not None
+                #else
+                inkex.Transform(f"translate({x},{y}) translate({dcx},{dcy})")
+            )
+            text_element.transform = t2
+            text_element.set("data-x", str(x))
+            text_element.set("data-y", str(y))
+
+            text_element.label = f"{name} @ {address}"
+
+            parent = text_element.getparent()
+            if parent is not None:
+                parent.remove(text_element)
+            labels_group.append(text_element)
+
+        # resolve labels!
+        self._resolve_labels()
+
+        # self._move_resolved_names(names_group, unresolved_names_group)
+
+        # self._read_resolved_names(names_group)
+        # self._save_resolved_names()
+        # self._read_unresolved_names(unresolved_names_group)
+        # self._save_unresolved_names()
+
+        # self._save_floors_addresses()
+        # self._save_floors_names()
+
+        self.msg("=== resolve: end")
+
+
+if __name__ == "__main__":
+    ResolveLabels().run()

package/inkscape/extensions/resolve_shops.inx

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Address: Resolve: Resolve shops</name>
+    <id>daijimaps.resolve_shops</id>
+    <label>Address: Resolve: Resolve shop names to addresses.</label>
+    <param name="tab" type="notebook">
+        <page name="Options" gui-text="Options">
+            <param name="floor" type="string" gui-text="Target floor (regular expression)">.</param>
+        </page>
+    </param>
+    <effect needs-live-preview="false">
+        <object-type>all</object-type>
+        <effects-menu>
+          <submenu name="Daiji Maps"/>
+        </effects-menu>
+    </effect>
+    <script>
+        <command location="inx" interpreter="python">resolve_shops.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/resolve_shops.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+import daijimaps
+
+
+class ResolveShops(daijimaps.ResolveNames):
+    def _move_resolved_name(
+        self,
+        names_group: inkex.Group,
+        unresolved_names_group: inkex.Group,
+        astr: str,
+        name: str,
+    ) -> None:
+        label = f"{name} @ {astr}"
+        ((x, y), _bb, _href) = self._addresses[astr]
+        daijimaps.move_name(unresolved_names_group, names_group, name, label, x, y)
+
+    def _move_resolved_names(
+        self, names_group: inkex.Group, unresolved_names_group: inkex.Group
+    ) -> None:
+        self.msg(f"drawing result {self._tmp_resolved_names}")
+        for name, astrs in self._tmp_resolved_names.items():
+            for astr in astrs:
+                self._move_resolved_name(
+                    names_group, unresolved_names_group, astr, name
+                )
+        self._sort_children(names_group)
+
+    def _process_addresses(self, node) -> None:
+        self.msg("=== resolve: start")
+
+        names_group = self._prepare_names_group(node)
+        unresolved_names_group = self._prepare_unresolved_names_group(node)
+
+        if names_group is None:
+            self.msg("(Names) group does not exist!")
+            return
+        if unresolved_names_group is None:
+            self.msg("(Unresolved Names) group does not exist!")
+            return
+
+        # resolve names!
+        self._resolve_names()
+
+        self._move_resolved_names(names_group, unresolved_names_group)
+
+        self._read_resolved_names(names_group)
+        self._save_resolved_names()
+        self._read_unresolved_names(unresolved_names_group)
+        self._save_unresolved_names()
+
+        self._save_floors_addresses()
+        self._save_floors_names()
+
+        self.msg("=== resolve: end")
+
+    # XXX
+    def _post_layers(self) -> None:
+        if self.options.floor != ".":
+            # avoid incomplete links
+            self.msg("=== resolve facility links: skip")
+            return
+        self.msg("=== resolve facility links: start")
+        self._collect_links()
+        self._save_links()
+        self.msg("=== resolve facility links: end")
+
+
+if __name__ == "__main__":
+    ResolveShops().run()

package/inkscape/extensions/unresolve_labels.inx

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Address: Resolve: Un-resolve labels</name>
+    <id>daijimaps.unresolve_labels</id>
+    <label>Address: Resolve: Un-resolve shop labels to addresses.</label>
+    <param name="tab" type="notebook">
+        <page name="Options" gui-text="Options">
+            <param name="floor" type="string" gui-text="Target floor (regular expression)">.</param>
+        </page>
+    </param>
+    <effect needs-live-preview="false">
+        <object-type>all</object-type>
+        <effects-menu>
+          <submenu name="Daiji Maps"/>
+        </effects-menu>
+    </effect>
+    <script>
+        <command location="inx" interpreter="python">unresolve_labels.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/unresolve_labels.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+import daijimaps.name
+import daijimaps.resolve_labels
+
+
+class UnresolveLabels(daijimaps.resolve_labels.ResolveLabels):
+    def _move_resolved_label(
+        self,
+        labels_group: inkex.Group,
+        unresolved_labels_group: inkex.Group,
+        new_name: str,
+        t: inkex.TextElement,
+    ) -> None:
+        old_name = t.label
+        daijimaps.name.move_label(
+            labels_group, unresolved_labels_group, old_name, new_name
+        )
+
+    def _move_resolved_labels(
+        self, labels_group: inkex.Group, unresolved_labels_group: inkex.Group
+    ) -> None:
+        for name, t in self._resolved_labels.items():
+            self.msg(f"moving label: {name}")
+            self._move_resolved_label(labels_group, unresolved_labels_group, name, t)
+        self._sort_children(unresolved_labels_group)
+
+    def _process_addresses(self, node: inkex.Group) -> None:
+        self.msg("=== unresolve: start")
+
+        unresolved_labels_group = self._prepare_unresolved_labels_group(node)
+        labels_group = self._prepare_labels_group(node)
+
+        if labels_group is None:
+            self.msg("(Labels) group does not exist!")
+            return
+        if unresolved_labels_group is None:
+            self.msg("(Unresolved Labels) group does not exist!")
+            return
+
+        self._move_resolved_labels(labels_group, unresolved_labels_group)
+
+        # self._read_unresolved_labels(unresolved_labels_group)
+        # self._read_resolved_labels(labels_group)
+
+        self.msg("=== unresolve: end")
+
+
+if __name__ == "__main__":
+    UnresolveLabels().run()

package/inkscape/extensions/unresolve_shops.inx

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Address: Resolve: Un-resolve shops</name>
+    <id>daijimaps.unresolve_shops</id>
+    <label>Address: Resolve: Un-resolve shop names to addresses.</label>
+    <param name="tab" type="notebook">
+        <page name="Options" gui-text="Options">
+            <param name="floor" type="string" gui-text="Target floor (regular expression)">.</param>
+        </page>
+    </param>
+    <effect needs-live-preview="false">
+        <object-type>all</object-type>
+        <effects-menu>
+          <submenu name="Daiji Maps"/>
+        </effects-menu>
+    </effect>
+    <script>
+        <command location="inx" interpreter="python">unresolve_shops.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/unresolve_shops.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+import daijimaps
+
+
+class UnresolveShops(daijimaps.ResolveNames):
+    def _move_unresolved_name(
+        self,
+        names_group: inkex.Group,
+        unresolved_names_group: inkex.Group,
+        name: str,
+        address: daijimaps.AddressString | None,
+        x: float,
+        y: float,
+    ) -> None:
+        label = name if address is None else f"{name} @ {address}"
+        daijimaps.move_name(names_group, unresolved_names_group, label, name, x, y)
+
+    def _move_unresolved_names(
+        self, names_group: inkex.Group, unresolved_names_group: inkex.Group
+    ) -> None:
+        for name, addresses in self._resolved_names.items():
+            for address, (x, y) in addresses:
+                self._move_unresolved_name(
+                    names_group, unresolved_names_group, name, address, x, y
+                )
+        self._sort_children(unresolved_names_group)
+
+    def _process_addresses(self, node: inkex.Group) -> None:
+        self.msg("=== unresolve: start")
+
+        names_group = self._prepare_names_group(node)
+        unresolved_names_group = self._prepare_unresolved_names_group(node)
+
+        if names_group is None:
+            self.msg("(Names) group does not exist!")
+            return
+        if unresolved_names_group is None:
+            self.msg("(Unresolved Names) group does not exist!")
+            return
+
+        self._move_unresolved_names(names_group, unresolved_names_group)
+
+        self._read_resolved_names(names_group)
+        self._save_resolved_names()
+        self._read_unresolved_names(unresolved_names_group)
+        self._save_unresolved_names()
+
+        self.msg("=== unresolve: end")
+
+
+if __name__ == "__main__":
+    UnresolveShops().run()