feat: simple draw

fix algorithm detail error.

packages/client/src/views/VisualView.vue

@@ -1,11 +1,29 @@
 <script setup lang="ts">
 import { NButton } from 'naive-ui'
+import { ref } from 'vue'
 
 import { taskForwardIndex } from '@/data'
 
 import NavigationButtons from '@/components/NavigationButtons.vue'
 import MainLayout from '@/layout/MainLayout.vue'
 
+type VertInfo = {
+  name: string
+  x: number
+  y: number
+}
+
+type EdgeInfo = {
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+}
+
+const vertInfo = ref<VertInfo[]>([])
+
+const edgeInfo = ref<EdgeInfo[]>([])
+
 function render() {
   const vertIndex = Object.keys(taskForwardIndex.value)
   const edges: number[] = []
@@ -15,7 +33,45 @@ function render() {
       edges.push(vertIndex.indexOf(to))
     }
   }
-  Module.layoutGraph(vertIndex.length, edges, vertIndex)
+  const result = Module.layoutGraph(vertIndex.length, edges, vertIndex)
+  const vertArray: VertInfo[] = []
+  const vertMapper: Record<string, VertInfo> = {}
+  const edgeArray: EdgeInfo[] = []
+  for (const part of result) {
+    for (const [yy, layer] of part.entries()) {
+      for (const [xx, id] of layer.entries()) {
+        const vi: VertInfo = {
+          name: vertIndex[id],
+          x: xx,
+          y: yy
+        }
+        vertMapper[vertIndex[id]] = vi
+        vertArray.push(vi)
+      }
+    }
+  }
+  for (const from of vertIndex) {
+    const vf = vertMapper[from]
+    for (const to of taskForwardIndex.value[from]) {
+      const vt = vertMapper[to]
+      edgeArray.push({
+        x1: vf.x,
+        y1: vf.y,
+        x2: vt.x,
+        y2: vt.y
+      })
+    }
+  }
+  vertInfo.value = vertArray
+  edgeInfo.value = edgeArray
+}
+
+function mX(x: number) {
+  return x * 40 + 20
+}
+
+function mY(y: number) {
+  return y * 40 + 20
 }
 </script>
 
@@ -25,5 +81,28 @@ function render() {
       <NavigationButtons></NavigationButtons>
       <NButton @click="render">计算</NButton>
     </template>
+
+    <div>
+      <svg width="1000" height="1000">
+        <circle
+          v-for="info in vertInfo"
+          :key="info.name"
+          :cx="mX(info.x)"
+          :cy="mY(info.y)"
+          r="5"
+          fill="wheat"
+          @mouseover="() => console.log(info.name)"
+        ></circle>
+        <line
+          v-for="(info, idx) in edgeInfo"
+          :key="idx"
+          :x1="mX(info.x1)"
+          :y1="mY(info.y1)"
+          :x2="mX(info.x2)"
+          :y2="mY(info.y2)"
+          style="stroke: rgb(0, 0, 0); stroke-width: 1"
+        ></line>
+      </svg>
+    </div>
   </MainLayout>
 </template>

packages/client/src/wasm.d.ts

@@ -1,3 +1,7 @@
 declare const Module: {
-  layoutGraph: (vertCount: number, edges: number[], names: string[]) => void
+  layoutGraph: (
+    vertCount: number,
+    edges: number[],
+    names: string[]
+  ) => number[][][]
 }

render/layering.cpp

@@ -1,5 +1,7 @@
 #include "graph.h"
 
+#include <stdio.h>
+
 std::vector<std::vector<int>> getNaiveLayer(const Graph &edges) {
   int n = edges.size();
   std::vector<int> inbound(n, 0);
@@ -89,10 +91,16 @@ void compactLayer(const Graph &edges, std::map<int, int> &layer) {
         }
       }
     }
+    int delta;
     if (vis[findFrom]) {
-      layer[findTo] = layer[findFrom] + 1;
+      delta = layer[findTo] - (layer[findFrom] + 1);
     } else {
-      layer[findFrom] = layer[findTo] - 1;
+      delta = layer[findFrom] - (layer[findTo] - 1);
+    }
+    for (int i = 0; i < n; i++) {
+      if (vis[i]) {
+        layer[i] += delta;
+      }
     }
   }
 }

render/main.cpp

@@ -25,8 +25,8 @@ void dumpGraph(const Graph &edges) {
   printf("dump graph end\n");
 }
 
-void layoutGraph(int n, const emscripten::val &v_edges,
-                 const emscripten::val &v_names) {
+emscripten::val layoutGraph(int n, const emscripten::val &v_edges,
+                            const emscripten::val &v_names) {
   auto edgeVerts = convertToVector<int>(v_edges);
   auto names = convertToVector<std::string>(v_names);
   std::vector<std::set<int>> edges(n);
@@ -54,6 +54,8 @@ void layoutGraph(int n, const emscripten::val &v_edges,
 
   auto vertsGroups = splitGraph(buildIndirectGraph(edges));
 
+  emscripten::val result = emscripten::val::array();
+
   for (const auto &toMain : vertsGroups) {
     int m = toMain.size();
     std::vector<int> toSub(n, -1);
@@ -69,30 +71,30 @@ void layoutGraph(int n, const emscripten::val &v_edges,
 
     auto initLayers = getNaiveLayer(subGraph);
     std::map<int, int> layer;
-    printf("dump naive layer\n");
     for (int i = 0; i < initLayers.size(); i++) {
-      printf("%d:", i);
       for (auto v : initLayers[i]) {
         layer[v] = i;
-        printf(" %s", names[toMain[v]].c_str());
       }
-      puts("");
     }
     compactLayer(subGraph, layer);
 
-    printf("dump compact layer\n");
     std::map<int, std::set<int>> flatLayer;
     for (auto [vt, lv] : layer) {
       flatLayer[lv].insert(vt);
     }
+
+    emscripten::val partResult = emscripten::val::array();
     for (const auto &[lv, vts] : flatLayer) {
-      printf("%d:", lv);
+      emscripten::val row = emscripten::val::array(); // printf("%d:", lv);
       for (auto v : vts) {
-        printf(" %s", names[toMain[v]].c_str());
+        row.call<void>("push", toMain[v]);
       }
-      puts("");
+      partResult.call<void>("push", row);
     }
+    result.call<void>("push", partResult);
   }
+
+  return result;
 }
 
 EMSCRIPTEN_BINDINGS(my_module) {