svgmapviewer-tools-floors 0.0.1

package/inkscape/extensions/extract_labels.py

@@ -0,0 +1,79 @@
+import json
+import re
+
+import inkex
+
+from daijimaps.guards import isGroup, isTextElement, isTspan
+from daijimaps.types import TextInfoJson, TspanInfoJson
+
+
+layer_label_re = re.compile("^[^(].*$")
+
+
+type Labels = list[TextInfoJson]
+type FloorLabels = dict[str, Labels]
+
+
+class ExtractLabels(inkex.OutputExtension):
+    def add_arguments(self, pars) -> None:
+        pass
+
+    def _textToInfo(self, e: inkex.TextElement) -> TextInfoJson:
+        children = []
+        for child in list(e):
+            if not isTspan(child):
+                continue
+            info: TspanInfoJson = {
+                "attrs": dict(child.attrib.items()),
+                "text": child.text,
+            }
+            children.append(info)
+        info: TextInfoJson = {
+            "attrs": dict(e.attrib.items()),
+            "children": children,
+        }
+        return info
+
+    def _collectLabels(self, layer: inkex.Group) -> Labels | None:
+        j = []
+        xs = layer.xpath(
+            './*[@*[name()="inkscape:label"]="Content"]/*[@*[name()="inkscape:label"]="(Labels)"]'
+        )
+        if not isinstance(xs, list) or len(xs) != 1:
+            xs = layer.xpath(
+                './*[@*[name()="inkscape:label"]="(Labels)"]'
+            )
+            if not isinstance(xs, list) or len(xs) != 1:
+                return None
+        x = xs[0]
+        if not isGroup(x):
+            return None
+        for child in list(x):
+            if not isTextElement(child):
+                continue
+            j.append(self._textToInfo(child))
+        return j
+
+    def _collectFloors(self) -> FloorLabels:
+        j: FloorLabels = {}
+        layers = self.svg.xpath('/*/*[@*[name()="inkscape:groupmode"]="layer"]')
+        for layer in list(layers):
+            if not isGroup(layer):
+                continue
+            label = layer.label
+            if label is None or not layer_label_re.match(label):
+                continue
+            labels = self._collectLabels(layer)
+            if labels is None:
+                continue
+            j[label] = labels
+        return j
+
+    def save(self, stream) -> None:
+        j: FloorLabels = self._collectFloors()
+        b = json.dumps(j, indent=2).encode("utf-8")
+        stream.write(b)
+
+
+if __name__ == "__main__":
+    ExtractLabels().run()

package/inkscape/extensions/fixup_floor_svg.py

@@ -0,0 +1,28 @@
+import inkex
+
+
+class FixupFloorSvg(inkex.EffectExtension):
+    def effect(self) -> None:
+        xs = self.svg.xpath('/*/*/*[@*[name()="inkscape:label"]="Content"]')
+        if isinstance(xs, list) and len(xs) == 1:
+            content = xs[0]
+            if isinstance(content, inkex.Group):
+                # 1. delete display:none
+                floor = content.getparent()
+                if isinstance(floor, inkex.Group):
+                    if "display" in floor.style:
+                        del floor.style["display"]
+
+                # 2. remove Shops
+                for child in list(content):
+                    if child.label == "Shops":
+                        content.remove(child)
+
+                # 3. remove (Labels)
+                for child in list(content):
+                    if child.label == "(Labels)":
+                        content.remove(child)
+
+
+if __name__ == "__main__":
+    FixupFloorSvg().run()

package/inkscape/extensions/fixup_texts.inx

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Fixup: Text: Fixup text/tspan</name>
+    <id>daijimaps.fixup_texts</id>
+    <label>Fixup: Text: Fixup text/tspan.</label>
+    <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">fixup_texts.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/fixup_texts.py

@@ -0,0 +1,110 @@
+import re
+
+import inkex
+
+from daijimaps.guards import isTextElement, isTspan
+
+
+names_label_re = re.compile("^[(].*Names.*[)]$")
+labels_label_re = re.compile("^[(].*Names.*[)]$")
+
+
+# - fix nested tspans
+# - remove tspan's style
+# - remove tspan's dy
+# - trim whitespaces in tspan
+# - remove non-tspan elements (if exists)
+
+
+class FixupTexts(inkex.EffectExtension):
+    def _joinTextTail(self, elem: inkex.Tspan) -> str:
+        texts = []
+        text = elem.text
+        if isinstance(text, str) and len(text) > 0:
+            texts.append(elem.text)
+        tail = elem.tail
+        if isinstance(tail, str) and len(tail) > 0:
+            texts.append(elem.tail)
+        return " ".join(texts)
+
+    def _collectTexts(self, elem: inkex.Tspan) -> str:
+        subtexts: list[str] = []
+        for child in list(elem):
+            self.msg(f"! tspan child (text={child.text} tail={child.tail})")
+            if isTspan(child):
+                text = self._collectTexts(child)
+                self.msg(f"! tspan child (text={text})")
+                if isinstance(text, str) and len(text) > 0:
+                    subtexts.append(text)
+        if len(subtexts) > 0:
+            text = self._joinTextTail(elem)
+            subtexts.append(text)
+            res = " ".join(subtexts)
+            self.msg(f"! merged tspan (res={res})")
+            return res
+        else:
+            res = self._joinTextTail(elem)
+            self.msg(f"! unmerged tspan (res={res})")
+            return res
+
+    def _fixupTspan(self, elem: inkex.Tspan, idx: int) -> None:
+        text = self._collectTexts(elem)
+        text = trim(text)
+        self.msg(f"tspan: {text}")
+        elem.style = None
+        for a in ["x", "y", "dy"]:
+            if a in elem.attrib:
+                del elem.attrib[a]
+        elem.set("x", "0")
+        elem.set("y", f"{idx * 1.25}em")
+        for child in list(elem):
+            self.msg(f"! removing children (id={elem.get_id()})")
+            elem.remove(child)
+        if elem.text != text:
+            self.msg(f"! updating text ({elem.text} -> {text})")
+            elem.text = text
+
+    def _fixupTextElement(self, elem: inkex.TextElement) -> None:
+        parent = elem.getparent()
+        plabel = parent.label
+        if plabel is None:
+            self.msg(f"skipping unknown text (id={elem.get_id()}, label={elem.label})")
+            return
+        self.msg(f"fixing text (id={elem.get_id()}, label={elem.label})")
+        xs = list(elem)
+        if xs == []:
+            t = elem.get_text()
+            if t is not None:
+                e = inkex.Tspan()
+                e.text = t
+                elem.append(e)
+        for i, child in enumerate(xs):
+            self.msg(
+                f"fixing text (id={elem.get_id()}, label={elem.label}) child={child}"
+            )
+            if not isTspan(child):
+                # XXX msg
+                self.msg("! not tspan!")
+                elem.remove(child)
+                continue
+            self._fixupTspan(child, i)
+        elem.text = None
+
+    def effect(self):
+        xs = self.svg.xpath('//*[name()="text"]')
+        if isinstance(xs, list):
+            for elem in list(xs):
+                if not isTextElement(elem):
+                    continue
+                self._fixupTextElement(elem)
+
+
+def trim(s: str) -> str:
+    s = re.sub(r"^ +", "", s)
+    s = re.sub(r" +$", "", s)
+    s = re.sub(r"  +", " ", s)
+    return s
+
+
+if __name__ == "__main__":
+    FixupTexts().run()

package/inkscape/extensions/fixup_tree.inx

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Fixup: Tree: Fixup tree</name>
+    <id>daijimaps.fixup_tree</id>
+    <label>Fixup: Tree: Fixup tree (group/layer).</label>
+    <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">fixup_tree.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/fixup_tree.py

@@ -0,0 +1,17 @@
+import inkex
+
+import daijimaps.address_tree
+import daijimaps.map_layer
+
+
+class FixupTree(daijimaps.address_tree.AddressTree):
+    def _post_layers(self):
+        for layer in self._layers:
+            daijimaps.map_layer.fixup_tree_layer(layer)
+            for child in list(layer):
+                if isinstance(child, inkex.Group) and child.label == "Content":
+                    daijimaps.map_layer.fixup_tree_layer_content(child)
+
+
+if __name__ == "__main__":
+    FixupTree().run()

package/inkscape/extensions/flatten_transform.inx

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Flatten Transform</name>
+    <id>daijimaps.flatten_transform</id>
+    <label>Flatteen tree by merging transforms into leaves.</label>
+    <effect needs-live-preview="false">
+        <object-type>all</object-type>
+        <effects-menu>
+            <submenu name="Daiji Maps">
+                <submenu name="Fixup" />
+            </submenu>
+        </effects-menu>
+    </effect>
+    <script>
+        <command location="inx" interpreter="python">flatten_transform.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/flatten_transform.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import math
+
+import inkex
+
+
+def _is_translate(t: inkex.Transform):
+    return not (math.isclose(t.e, 0) and math.isclose(t.f, 0))
+
+
+def _is_translate_only(t: inkex.Transform):
+    p = [t.a, t.b, t.c, t.d]
+    q = [1, 0, 0, 1]
+    is_unit = all(map(math.isclose, p, q))
+    return is_unit and _is_translate(t)
+
+
+def _translate_x_y(node, t, ax="x", ay="y"):
+    x = node.get(ax) or 0
+    y = node.get(ay) or 0
+    node.set(ax, f"{float(x) + t.e:.3g}")
+    node.set(ay, f"{float(y) + t.f:.3g}")
+    if node.transform:
+        del node.attrib["transform"]
+
+
+def _translate_cx_cy(node, t):
+    _translate_x_y(node, t, "cx", "cy")
+
+
+class FlattenTransform(inkex.EffectExtension):
+    def _flatten_translate(self, node):
+        t = node.transform
+        translate_only = _is_translate_only(t)
+        if translate_only:
+            if isinstance(node, inkex.Use) or isinstance(node, inkex.Rectangle):
+                _translate_x_y(node, t)
+            elif isinstance(node, inkex.Circle) or isinstance(node, inkex.Ellipse):
+                _translate_cx_cy(node, t)
+            elif isinstance(node, inkex.TextElement):
+                _translate_x_y(node, t)
+                for child in list(node):
+                    if isinstance(child, inkex.Tspan) and translate_only:
+                        _translate_x_y(child, t)
+        if isinstance(node, inkex.Group):
+            for child in list(node):
+                self._flatten_translate(child)
+
+    def _flatten_Transform(self, node):
+        node.bake_transforms_recursively()
+        return True
+
+    def effect(self):
+        if self.svg.selection:
+            for node in self.svg.selection.values():
+                self._flatten_Transform(node)
+                self._flatten_translate(node)
+
+
+if __name__ == "__main__":
+    FlattenTransform().run()

package/inkscape/extensions/import_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: Import: Import labels</name>
+    <id>daijimaps.import_labels</id>
+    <label>Address: Import: Import labels.</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">import_labels.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/import_labels.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+import daijimaps
+
+
+class ImportLabels(daijimaps.GenerateAddresses):
+    _group_label = "(Unresolved Labels)"
+    _font_size = 5
+
+    def _get_labels_txt(self, layer_name: str) -> str | None:
+        p = self._get_path(layer_name=layer_name, prefix="labels", suffix="txt")
+        if p is not None:
+            return p
+        return self._get_path(layer_name=layer_name, prefix="names", suffix="txt")
+
+    def _draw_labels(self, aparent, text):
+        g = daijimaps.draw_label(text, self._font_size)
+        aparent.append(g)
+
+    def _generate_addresses(self, layer, layer_name: str):
+        self.msg("=== import labels: _generate_addresses")
+
+        aparent = self._find_or_make_group(layer, self._group_label)
+
+        path = self._get_labels_txt(layer_name)
+        if path is None:
+            self.msg("labels.txt not found!")
+            return
+        with open(path, "r", encoding="utf-8") as fh:
+            texts = [text for text in [line.strip() for line in fh.readlines()]]
+            for text in texts:
+                self._draw_labels(aparent, text)
+
+        layer.append(aparent)
+
+    def _post_process_addresses(self, node: inkex.Group) -> None:
+        super()._post_process_addresses(node)
+        self.msg("=== import labels: _post_process_addresses")
+        for addresses in list(node):
+            if not isinstance(addresses, inkex.Group):
+                continue
+            label = addresses.label
+            if label is not None and label == self._group_label:
+                self._sort_children(addresses)
+        # return super()._post_process_addresses(layer)
+
+
+if __name__ == "__main__":
+    ImportLabels().run()

package/inkscape/extensions/import_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: Import: Import shops</name>
+    <id>daijimaps.import_shops</id>
+    <label>Address: Import: Import shop names.</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">import_shops.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/import_shops.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+import daijimaps
+
+
+class ImportShops(daijimaps.GenerateAddresses):
+    _group_label = "(Unresolved Names)"
+
+    def _get_shops_txt(self, layer_name: str):
+        p = self._get_path(layer_name, "names", "txt")
+        if p is None:
+            p = self._get_path(layer_name, "shops", "txt")
+        return p
+
+    def _draw_shop_names(self, aparent, text):
+        g = daijimaps.draw_name(text)
+        aparent.append(g)
+
+    def _generate_addresses(self, layer, layer_name):
+        self.msg("=== import shops: _generate_addresses")
+
+        aparent = self._find_or_make_group(layer, self._group_label)
+
+        path = self._get_shops_txt(layer_name)
+        if path is None:
+            self.msg("shops.txt not found!")
+            return
+        with open(path, "r", encoding="utf-8") as fh:
+            texts = [text for text in [line.strip() for line in fh.readlines()]]
+            for text in texts:
+                self._draw_shop_names(aparent, text)
+
+        layer.append(aparent)
+
+    def _post_process_addresses(self, node) -> None:
+        super()._post_process_addresses(node)
+        self.msg("=== import shops: _post_process_addresses")
+        for addresses in list(node):
+            if "label" in addresses and addresses.label == self._group_label:
+                self._sort_children(addresses)
+
+
+if __name__ == "__main__":
+    ImportShops().run()

package/inkscape/extensions/install.sh

@@ -0,0 +1,14 @@
+DIR=$( inkscape --user-data-directory )/extensions
+
+#rm "${DIR}"/*.inx "${DIR}"/*.py
+cp -p *.inx *.py "${DIR}"
+
+subdirs='
+daijimaps
+'
+
+for subdir in ${subdirs}; do
+  mkdir -p "${DIR}/${subdir}"
+  #rm "${DIR}/${subdir}/"*.py
+  cp -p ${subdir}/*.py "${DIR}/${subdir}"
+done

package/inkscape/extensions/load_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: Load: Load shops</name>
+    <id>daijimaps.load_shops</id>
+    <label>Address: Load: Load 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">load_shops.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/load_shops.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import json
+
+import inkex
+
+import daijimaps
+
+
+class LoadShops(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 _load_resolved_names(self) -> None:
+        with open(self._layerPaths["floorsNames"], mode="r", encoding="utf-8") as f:
+            j = json.load(f)
+            if not isinstance(j, dict):
+                self.msg("invalid floorsNames.json")
+                return
+            for name in j:
+                if not isinstance(name, str):
+                    self.msg("invalid floorsNames.json: name is not string")
+                    return
+                astrs = j[name]
+                if not isinstance(astrs, list):
+                    self.msg("invalid floorsNames.json: astrs is not list")
+                    return
+                for astr in astrs:
+                    if not isinstance(astr, str):
+                        self.msg(
+                            "invalid floorsNames.json: astr is not string (name={name})"
+                        )
+                        return
+            self._tmp_resolved_names = j
+
+    def _process_addresses(self, node) -> None:
+        self.msg("=== load: 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
+
+        # load names!
+        self._load_resolved_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("=== load: end")
+
+
+if __name__ == "__main__":
+    LoadShops().run()

package/inkscape/extensions/renumber_group.inx

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<inkscape-extension xmlns="http://www.inkscape.org/namespace/inkscape/extension">
+    <name>Address: Renumber: Renumber group</name>
+    <id>daijimaps.renumber_group</id>
+    <label>Renumber groups under the selected group.</label>
+    <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">renumber_group.py</command>
+    </script>
+</inkscape-extension>

package/inkscape/extensions/renumber_group.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+import inkex
+
+from daijimaps import renumber_group
+
+
+class RenumberGroup(inkex.EffectExtension):
+    def effect(self):
+        if self.svg.selection:
+            for node in self.svg.selection.values():
+                renumber_group(node)
+
+
+if __name__ == "__main__":
+    RenumberGroup().run()

package/inkscape/extensions/resolve_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: Resolve labels</name>
+    <id>daijimaps.resolve_labels</id>
+    <label>Address: Resolve: Resolve labels to names.</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_labels.py</command>
+    </script>
+</inkscape-extension>