codewave-openclaw-installer 2.1.13 → 2.2.0

package/skills/ppt-master/scripts/drawio_to_svg.py

@@ -1,458 +0,0 @@
-#!/usr/bin/env python3
-"""
-drawio_to_svg.py - Convert draw.io XML to PPT Master compatible SVG.
-
-Parses a .drawio file and renders it as a standalone SVG at 1280x720
-(16:9 PPT format), compatible with the PPT Master pipeline.
-
-This does NOT require draw.io Desktop installed. It directly parses
-the mxGraph XML and renders nodes/edges as SVG elements.
-
-Usage:
-    python drawio_to_svg.py <input.drawio> -o <output.svg>
-    python drawio_to_svg.py <input.drawio> -o <output.svg> --width 1280 --height 720
-    python drawio_to_svg.py <input.drawio> -o <output.svg> --title "System Architecture"
-    python drawio_to_svg.py <input.drawio> -o <output.svg> --background "#ffffff" --padding 40
-"""
-
-import sys
-import re
-import argparse
-import xml.etree.ElementTree as ET
-from dataclasses import dataclass, field
-from typing import Optional
-
-
-@dataclass
-class NodeInfo:
-    id: str
-    label: str
-    x: float
-    y: float
-    width: float
-    height: float
-    style: dict = field(default_factory=dict)
-    parent: str = "1"
-
-
-@dataclass
-class EdgeInfo:
-    id: str
-    label: str
-    source: str
-    target: str
-    style: dict = field(default_factory=dict)
-
-
-def parse_style(style_str: str) -> dict:
-    """Parse mxGraph style string into dict."""
-    result = {}
-    if not style_str:
-        return result
-    for part in style_str.rstrip(";").split(";"):
-        if "=" in part:
-            k, v = part.split("=", 1)
-            result[k.strip()] = v.strip()
-        elif part.strip():
-            result[part.strip()] = True
-    return result
-
-
-def parse_drawio(filepath: str):
-    """Parse a .drawio file and return nodes and edges."""
-    with open(filepath, "r", encoding="utf-8") as f:
-        tree = ET.parse(f)
-    root = tree.getroot()
-
-    nodes = {}
-    edges = []
-    groups = {}
-
-    for diagram in root.findall(".//diagram"):
-        for cell in diagram.iter("mxCell"):
-            cell_id = cell.get("id", "")
-            if cell_id in ("0", "1"):
-                continue
-
-            parent = cell.get("parent", "1")
-            style = parse_style(cell.get("style", ""))
-            value = cell.get("value", "")
-            geo = cell.find("mxGeometry")
-
-            if cell.get("vertex") == "1":
-                x = float(geo.get("x", "0")) if geo is not None else 0
-                y = float(geo.get("y", "0")) if geo is not None else 0
-                w = float(geo.get("width", "120")) if geo is not None else 120
-                h = float(geo.get("height", "60")) if geo is not None else 60
-
-                if "container" in style:
-                    groups[cell_id] = NodeInfo(cell_id, value, x, y, w, h, style, parent)
-                else:
-                    nodes[cell_id] = NodeInfo(cell_id, value, x, y, w, h, style, parent)
-
-            elif cell.get("edge") == "1":
-                edges.append(EdgeInfo(cell_id, value,
-                                      cell.get("source", ""),
-                                      cell.get("target", ""),
-                                      style))
-
-        # Also check <object> elements (N2G format)
-        for obj in diagram.iter("object"):
-            obj_id = obj.get("id", "")
-            value = obj.get("label", "")
-            inner = obj.find("mxCell")
-            if inner is None:
-                continue
-
-            style = parse_style(inner.get("style", ""))
-            parent = inner.get("parent", "1")
-            geo = inner.find("mxGeometry")
-
-            if inner.get("vertex") == "1":
-                x = float(geo.get("x", "0")) if geo is not None else 0
-                y = float(geo.get("y", "0")) if geo is not None else 0
-                w = float(geo.get("width", "120")) if geo is not None else 120
-                h = float(geo.get("height", "60")) if geo is not None else 60
-                nodes[obj_id] = NodeInfo(obj_id, value, x, y, w, h, style, parent)
-
-            elif inner.get("edge") == "1":
-                edges.append(EdgeInfo(obj_id, value,
-                                      inner.get("source", obj.get("source", "")),
-                                      inner.get("target", obj.get("target", "")),
-                                      style))
-
-    # Resolve relative positions for grouped nodes
-    for nid, node in nodes.items():
-        if node.parent in groups:
-            g = groups[node.parent]
-            node.x += g.x
-            node.y += g.y
-
-    return nodes, edges, groups
-
-
-def color_from_style(style: dict, key: str, default: str) -> str:
-    return style.get(key, default)
-
-
-def get_shape_type(style: dict) -> str:
-    """Determine shape type from style dict."""
-    shape = style.get("shape", "")
-    if "cylinder" in shape or "cylinder3" in str(style):
-        return "cylinder"
-    if "cloud" in shape:
-        return "cloud"
-    if "rhombus" in style or "diamond" in str(style):
-        return "diamond"
-    if "ellipse" in style:
-        return "ellipse"
-    if "hexagon" in shape:
-        return "hexagon"
-    if style.get("rounded"):
-        return "rounded"
-    return "rect"
-
-
-def svg_shape(node: NodeInfo, svg_lines: list):
-    """Render a node as SVG elements."""
-    x, y, w, h = node.x, node.y, node.width, node.height
-    fill = color_from_style(node.style, "fillColor", "#dae8fc")
-    stroke = color_from_style(node.style, "strokeColor", "#6c8ebf")
-    shape = get_shape_type(node.style)
-    stroke_w = "1.5"
-
-    if shape == "cylinder":
-        # Cylinder: rect + top/bottom ellipse
-        ry = min(12, h * 0.15)
-        svg_lines.append(f'  <rect x="{x}" y="{y + ry}" width="{w}" height="{h - 2*ry}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-        svg_lines.append(f'  <ellipse cx="{x + w/2}" cy="{y + ry}" rx="{w/2}" ry="{ry}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-        svg_lines.append(f'  <ellipse cx="{x + w/2}" cy="{y + h - ry}" rx="{w/2}" ry="{ry}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-    elif shape == "ellipse" or shape == "cloud":
-        svg_lines.append(f'  <ellipse cx="{x + w/2}" cy="{y + h/2}" rx="{w/2}" ry="{h/2}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-    elif shape == "diamond":
-        cx, cy = x + w/2, y + h/2
-        points = f"{cx},{y} {x+w},{cy} {cx},{y+h} {x},{cy}"
-        svg_lines.append(f'  <polygon points="{points}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-    elif shape == "hexagon":
-        dx = w * 0.15
-        points = f"{x+dx},{y} {x+w-dx},{y} {x+w},{y+h/2} {x+w-dx},{y+h} {x+dx},{y+h} {x},{y+h/2}"
-        svg_lines.append(f'  <polygon points="{points}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-    elif shape == "rounded":
-        r = min(12, w * 0.1, h * 0.2)
-        svg_lines.append(f'  <rect x="{x}" y="{y}" width="{w}" height="{h}" rx="{r}" ry="{r}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-    else:
-        svg_lines.append(f'  <rect x="{x}" y="{y}" width="{w}" height="{h}" '
-                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
-
-    # Label
-    label = node.label.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-    if label:
-        font_size = 12
-        svg_lines.append(f'  <text x="{x + w/2}" y="{y + h/2}" '
-                         f'text-anchor="middle" dominant-baseline="central" '
-                         f'font-family="Helvetica, Arial, sans-serif" font-size="{font_size}" '
-                         f'fill="#333333">{label}</text>')
-
-
-def svg_edge(edge: EdgeInfo, nodes: dict, svg_lines: list):
-    """Render an edge as orthogonal polyline for cleaner look."""
-    src = nodes.get(edge.source)
-    tgt = nodes.get(edge.target)
-    if not src or not tgt:
-        return
-
-    # Center points
-    sx = src.x + src.width / 2
-    sy = src.y + src.height / 2
-    tx = tgt.x + tgt.width / 2
-    ty = tgt.y + tgt.height / 2
-
-    stroke = color_from_style(edge.style, "strokeColor", "#666666")
-    dash = ""
-    if edge.style.get("dashed"):
-        pattern = edge.style.get("dashPattern", "8 8")
-        dash = f' stroke-dasharray="{pattern}"'
-
-    # Determine best connection ports (top/bottom/left/right of each node)
-    dy = ty - sy
-    dx = tx - sx
-
-    # Choose vertical-first routing (most common for TB layouts)
-    if abs(dy) > 10:
-        # Connect bottom of src to top of tgt (or top to bottom if reversed)
-        if dy > 0:
-            # src above tgt
-            p1x, p1y = sx, src.y + src.height  # bottom of src
-            p4x, p4y = tx, tgt.y                # top of tgt
-        else:
-            # src below tgt
-            p1x, p1y = sx, src.y                # top of src
-            p4x, p4y = tx, tgt.y + tgt.height   # bottom of tgt
-
-        # Midpoint Y for the horizontal segment
-        mid_y = (p1y + p4y) / 2
-
-        # Build orthogonal path: vertical → horizontal → vertical
-        if abs(p1x - p4x) < 3:
-            # Nodes are vertically aligned, straight line
-            points = f"{p1x:.1f},{p1y:.1f} {p4x:.1f},{p4y:.1f}"
-        else:
-            points = f"{p1x:.1f},{p1y:.1f} {p1x:.1f},{mid_y:.1f} {p4x:.1f},{mid_y:.1f} {p4x:.1f},{p4y:.1f}"
-    else:
-        # Horizontal connection (same layer)
-        if dx > 0:
-            p1x, p1y = src.x + src.width, sy   # right of src
-            p4x, p4y = tgt.x, ty               # left of tgt
-        else:
-            p1x, p1y = src.x, sy               # left of src
-            p4x, p4y = tgt.x + tgt.width, ty   # right of tgt
-
-        if abs(p1y - p4y) < 3:
-            points = f"{p1x:.1f},{p1y:.1f} {p4x:.1f},{p4y:.1f}"
-        else:
-            mid_x = (p1x + p4x) / 2
-            points = f"{p1x:.1f},{p1y:.1f} {mid_x:.1f},{p1y:.1f} {mid_x:.1f},{p4y:.1f} {p4x:.1f},{p4y:.1f}"
-
-    # Arrow head (small triangle at end point)
-    has_arrow = edge.style.get("endArrow", "classic") != "none"
-    arrow_svg = ""
-    if has_arrow:
-        # Parse last two points to determine arrow direction
-        pts = points.strip().split()
-        if len(pts) >= 2:
-            last = pts[-1].split(",")
-            prev = pts[-2].split(",")
-            lx, ly = float(last[0]), float(last[1])
-            px, py = float(prev[0]), float(prev[1])
-            adx, ady = lx - px, ly - py
-            length = max((adx**2 + ady**2)**0.5, 0.001)
-            # Normalize
-            ux, uy = adx/length, ady/length
-            # Arrow triangle (size 8)
-            sz = 8
-            # Perpendicular
-            rx, ry = -uy * sz * 0.5, ux * sz * 0.5
-            # Arrow base point
-            bx, by = lx - ux * sz, ly - uy * sz
-            arrow_svg = (f'  <polygon points="{lx:.1f},{ly:.1f} {bx+rx:.1f},{by+ry:.1f} '
-                         f'{bx-rx:.1f},{by-ry:.1f}" fill="{stroke}" />')
-
-    svg_lines.append(f'  <polyline points="{points}" fill="none" '
-                     f'stroke="{stroke}" stroke-width="1.5"{dash} stroke-linejoin="round" />')
-    if arrow_svg:
-        svg_lines.append(arrow_svg)
-
-    # Edge label - position at midpoint of the polyline path
-    if edge.label:
-        pts = [tuple(map(float, p.split(","))) for p in points.strip().split()]
-        if len(pts) >= 2:
-            mid_idx = len(pts) // 2
-            if len(pts) % 2 == 0:
-                lx = (pts[mid_idx-1][0] + pts[mid_idx][0]) / 2
-                ly = (pts[mid_idx-1][1] + pts[mid_idx][1]) / 2
-            else:
-                lx, ly = pts[mid_idx]
-            ly -= 8
-            label = edge.label.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-            svg_lines.append(f'  <rect x="{lx-len(label)*3.5-4}" y="{ly-10}" '
-                             f'width="{len(label)*7+8}" height="16" rx="3" fill="white" fill-opacity="0.85" />')
-            svg_lines.append(f'  <text x="{lx}" y="{ly}" text-anchor="middle" dominant-baseline="central" '
-                             f'font-family="Helvetica, Arial, sans-serif" font-size="11" '
-                             f'fill="{stroke}">{label}</text>')
-
-
-def clip_to_rect(sx, sy, tx, ty, node):
-    """Clip a line from (sx,sy) toward (tx,ty) to the boundary of node's rect."""
-    cx = node.x + node.width / 2
-    cy = node.y + node.height / 2
-    dx = tx - sx
-    dy = ty - sy
-    if abs(dx) < 0.001 and abs(dy) < 0.001:
-        return sx, sy
-
-    hw = node.width / 2
-    hh = node.height / 2
-
-    # Find intersection with rect boundary
-    t_vals = []
-    if abs(dx) > 0.001:
-        t_vals.append(hw / abs(dx))
-    if abs(dy) > 0.001:
-        t_vals.append(hh / abs(dy))
-    if t_vals:
-        t = min(t_vals)
-        return cx + dx * t * (1 if dx > 0 else -1) / max(abs(dx), 0.001) * min(hw, abs(dx) * t), \
-               cy + dy * t * (1 if dy > 0 else -1) / max(abs(dy), 0.001) * min(hh, abs(dy) * t)
-    return sx, sy
-
-
-def clip_to_rect(sx, sy, tx, ty, node: NodeInfo):
-    """Clip point (sx, sy) to boundary of node rect, coming from direction of (tx, ty)."""
-    cx = node.x + node.width / 2
-    cy = node.y + node.height / 2
-    dx = tx - cx
-    dy = ty - cy
-
-    if abs(dx) < 0.01 and abs(dy) < 0.01:
-        return sx, sy
-
-    hw = node.width / 2
-    hh = node.height / 2
-
-    # Parametric intersection
-    scale_x = abs(dx / hw) if hw > 0 else 999
-    scale_y = abs(dy / hh) if hh > 0 else 999
-    scale = max(scale_x, scale_y)
-
-    if scale < 0.01:
-        return sx, sy
-
-    return cx + dx / scale, cy + dy / scale
-
-
-def render_svg(nodes: dict, edges: list, groups: dict,
-               width: int = 1280, height: int = 720,
-               title: str = "", bg: str = "#ffffff",
-               padding: int = 40) -> str:
-    """Render parsed drawio data as SVG string."""
-
-    # Auto-scale to fit canvas
-    if nodes:
-        all_items = list(nodes.values()) + list(groups.values())
-        min_x = min(n.x for n in all_items)
-        min_y = min(n.y for n in all_items)
-        max_x = max(n.x + n.width for n in all_items)
-        max_y = max(n.y + n.height for n in all_items)
-
-        content_w = max_x - min_x
-        content_h = max_y - min_y
-        avail_w = width - 2 * padding
-        avail_h = height - 2 * padding - (40 if title else 0)
-
-        scale = min(avail_w / max(content_w, 1), avail_h / max(content_h, 1), 2.0)
-
-        offset_x = padding + (avail_w - content_w * scale) / 2 - min_x * scale
-        offset_y = padding + (40 if title else 0) + (avail_h - content_h * scale) / 2 - min_y * scale
-
-        # Apply transform
-        for n in nodes.values():
-            n.x = n.x * scale + offset_x
-            n.y = n.y * scale + offset_y
-            n.width *= scale
-            n.height *= scale
-        for g in groups.values():
-            g.x = g.x * scale + offset_x
-            g.y = g.y * scale + offset_y
-            g.width *= scale
-            g.height *= scale
-
-    lines = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}" width="{width}" height="{height}">',
-        f'  <rect width="{width}" height="{height}" fill="{bg}" />',
-    ]
-
-    # Title
-    if title:
-        lines.append(f'  <text x="{width/2}" y="32" text-anchor="middle" '
-                     f'font-family="Helvetica, Arial, sans-serif" font-size="20" '
-                     f'font-weight="bold" fill="#333333">{title}</text>')
-
-    # Groups (background)
-    for g in groups.values():
-        r = 8
-        fill = color_from_style(g.style, "fillColor", "#f5f5f5")
-        stroke = color_from_style(g.style, "strokeColor", "#999999")
-        lines.append(f'  <rect x="{g.x}" y="{g.y}" width="{g.width}" height="{g.height}" '
-                     f'rx="{r}" fill="{fill}" stroke="{stroke}" stroke-width="1" '
-                     f'stroke-dasharray="4 4" />')
-        if g.label:
-            label = g.label.replace("&", "&amp;").replace("<", "&lt;")
-            lines.append(f'  <text x="{g.x + 10}" y="{g.y + 18}" '
-                         f'font-family="Helvetica, Arial, sans-serif" font-size="13" '
-                         f'font-weight="bold" fill="#666666">{label}</text>')
-
-    # Edges (behind nodes)
-    for e in edges:
-        svg_edge(e, nodes, lines)
-
-    # Nodes (on top)
-    for n in nodes.values():
-        svg_shape(n, lines)
-
-    lines.append('</svg>')
-    return "\n".join(lines)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Convert draw.io to PPT-compatible SVG")
-    parser.add_argument("input", help="Input .drawio file")
-    parser.add_argument("-o", "--output", required=True, help="Output .svg file")
-    parser.add_argument("--width", type=int, default=1280, help="SVG width (default: 1280)")
-    parser.add_argument("--height", type=int, default=720, help="SVG height (default: 720)")
-    parser.add_argument("--title", default="", help="Diagram title")
-    parser.add_argument("--background", default="#ffffff", help="Background color")
-    parser.add_argument("--padding", type=int, default=40, help="Padding around content")
-    args = parser.parse_args()
-
-    nodes, edges, groups = parse_drawio(args.input)
-    svg = render_svg(nodes, edges, groups,
-                     width=args.width, height=args.height,
-                     title=args.title, bg=args.background,
-                     padding=args.padding)
-
-    with open(args.output, "w", encoding="utf-8") as f:
-        f.write(svg)
-
-    print(f"✅ Converted: {args.output}")
-    print(f"   Canvas: {args.width}x{args.height}, Nodes: {len(nodes)}, Edges: {len(edges)}")
-
-
-if __name__ == "__main__":
-    main()