Upload folder using huggingface_hub

app.py

@@ -1,94 +1,90 @@
+
 from fastapi import FastAPI, UploadFile, File
-from fastapi.responses import FileResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-import json
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+import os
 
 app = FastAPI()
-app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
-def parse_dcm_assembly(uploaded_file):
-    lines = uploaded_file.file.read().decode("utf-8").splitlines()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True,
+    allow_methods=["*"], allow_headers=["*"],
+)
 
-    geometry = {}
-    parts = []
-    constraints = {}
+@app.get("/")
+def serve_frontend():
+    return FileResponse("index.html")
 
-    temp_geom = {}
-    temp_part = {}
-    temp_constraint = {}
-    current_class = None
+@app.post("/parse")
+async def parse_file(file: UploadFile = File(...)):
+    content = await file.read()
+    return JSONResponse(content=parse_dcm_assembly(content))
 
-    plane_label_map = {}
-    plane_point_map = {}
+def parse_dcm_assembly(file_bytes):
+    lines = file_bytes.decode("utf-8").splitlines()
+    blocks, current = [], []
 
     for line in lines:
-        line = line.strip()
         if line.startswith("CLASS"):
-            parts_line = line.split()
-            current_class = parts_line[1]
-            current_id = int(parts_line[2])
-            if current_class == "PLANE":
-                temp_geom = {"tag": current_id}
-            elif current_class == "WORK_PLANE":
-                temp_geom["tag"] = current_id
-            elif current_class == "SET":
-                temp_part = {"member_tags": []}
-            elif current_class == "CONSTRAINT":
-                temp_constraint = {}
-        elif current_class == "PLANE":
-            if line.startswith("FBASE_POINT"):
-                temp_geom["base_point"] = tuple(map(float, line.split()[1:]))
-            elif line.startswith("FNORMAL"):
-                temp_geom["normal"] = tuple(map(float, line.split()[1:]))
-            elif line.startswith("FIN_SET"):
-                plane_point_map[temp_geom["tag"]] = temp_geom
-        elif current_class == "WORK_PLANE":
-            if line.startswith("FMY_PLANE TAG"):
-                temp_geom["plane_tag"] = int(line.split()[-1])
-            elif line.startswith("DCM3_TEXT_LABEL"):
-                temp_geom["label"] = line.split(" ", 1)[1].strip()
-            elif line == "#":
-                tag = temp_geom.get("plane_tag")
-                if tag is not None:
-                    plane_label_map[tag] = temp_geom.get("label", "")
-        elif current_class == "SET":
-            if line.startswith("DCM3_TEXT_LABEL"):
-                temp_part["name"] = line.split(" ", 1)[1].strip()
-            elif line.startswith("FMEMBER TAGS"):
-                tags = list(map(int, line.split()[2:]))
-                temp_part["member_tags"].extend(tags)
-            elif line == "#":
-                parts.append(temp_part)
-        elif current_class == "CONSTRAINT":
-            if line.startswith("FEND_1 TAG"):
-                temp_constraint["from"] = int(line.split()[-1])
-            elif line.startswith("FEND_2 TAG"):
-                temp_constraint["to"] = int(line.split()[-1])
-            elif line.startswith("DCM3_TEXT_LABEL"):
-                temp_constraint["label"] = line.split(" ", 1)[1].strip()
-            elif line == "#":
-                if "from" in temp_constraint and "to" in temp_constraint:
-                    constraints[(temp_constraint["from"], temp_constraint["to"])] = temp_constraint["label"]
+            if current:
+                blocks.append(current)
+                current = []
+        current.append(line.strip())
+    if current: blocks.append(current)
+
+    parts, geometry, constraints = [], {}, []
+    plane_map, tag_to_plane, label_map = {}, {}, {}
+
+    for block in blocks:
+        head = block[0]
+        if "CLASS SET " in head:
+            part, members = {}, []
+            for line in block:
+                if "DCM3_TEXT_LABEL" in line:
+                    part['name'] = line.split("DCM3_TEXT_LABEL", 1)[1].strip()
+                elif "FMEMBER TAGS" in line:
+                    members = list(map(int, line.split()[2:]))
+            if 'name' in part:
+                part['member_tags'] = members
+                parts.append(part)
+
+        elif "CLASS PLANE " in head:
+            pid = int(head.split()[-1])
+            base, norm = None, None
+            for line in block:
+                if "FBASE_POINT" in line:
+                    base = tuple(map(float, line.split()[1:]))
+                elif "FNORMAL" in line:
+                    norm = tuple(map(float, line.split()[1:]))
+            if base and norm:
+                plane_map[pid] = {'base_point': base, 'normal': norm}
 
-    final_geometry = {}
-    for tag, data in plane_point_map.items():
-        final_geometry[tag] = {
-            "base_point": data["base_point"],
-            "normal": data["normal"],
-            "label": plane_label_map.get(tag, "")
-        }
+        elif "CLASS WORK_PLANE " in head:
+            wid = int(head.split()[-1])
+            tag, label = None, None
+            for line in block:
+                if "FMY_PLANE TAG" in line:
+                    tag = int(line.split()[-1])
+                elif "DCM3_TEXT_LABEL" in line:
+                    label = line.split("DCM3_TEXT_LABEL", 1)[1].strip()
+            if tag:
+                tag_to_plane[wid] = tag
+                label_map[wid] = label
 
-    constraint_list = [{"from": f, "to": t, "label": lbl} for (f, t), lbl in constraints.items()]
+        elif "CLASS CONSTRAINT " in head:
+            con = {}
+            for line in block:
+                if "FEND_1 TAG" in line:
+                    con['from'] = int(line.split()[-1])
+                elif "FEND_2 TAG" in line:
+                    con['to'] = int(line.split()[-1])
+                elif "DCM3_TEXT_LABEL" in line:
+                    con['label'] = line.split("DCM3_TEXT_LABEL", 1)[1].strip()
+            if con: constraints.append(con)
 
-    return {
-        "geometry": final_geometry,
-        "parts": parts,
-        "constraints": constraint_list
-    }
+    for wid, pid in tag_to_plane.items():
+        if pid in plane_map:
+            geometry[wid] = {**plane_map[pid], 'label': label_map.get(wid)}
 
-@app.post("/upload")
-async def upload_file(file: UploadFile = File(...)):
-    data = parse_dcm_assembly(file)
-    with open("static/parsed_data.json", "w") as f:
-        json.dump({"files": [("red", "blue", data)]}, f)
-    return JSONResponse(content={"status": "ok"})
+    return { "parts": parts, "geometry": geometry, "constraints": constraints }

index.html

@@ -1,3 +1,4 @@
+
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -12,70 +13,93 @@
 </head>
 <body>
   <h1>DCM Assembly Visualizer</h1>
-  <p>Select a file using the backend (upload via /upload endpoint) and refresh this page.</p>
-  <div id="plot">Loading 3D viewer...</div>
+  <input type="file" id="file1" accept=".txt"> File A<br>
+  <input type="file" id="file2" accept=".txt"> File B<br><br>
+  <button onclick="uploadFiles()">Visualize</button>
+  <div id="plot"></div>
 
   <script>
-    async function drawFromServer() {
-      try {
-        const res = await fetch("/parsed_data.json");
-        const payload = await res.json();
-        console.log("Loaded data:", payload);
+    async function uploadFiles() {
+      const file1 = document.getElementById("file1").files[0];
+      const file2 = document.getElementById("file2").files[0];
 
-        let allTraces = [];
+      if (!file1 && !file2) {
+        alert("Please select at least one file.");
+        return;
+      }
 
-        for (const [color, normalColor, data] of payload.files) {
-          for (const [tag, g] of Object.entries(data.geometry)) {
-            const [x, y, z] = g.base_point;
-            const [nx, ny, nz] = g.normal;
+      const traces = [];
 
-            allTraces.push({
-              type: 'scatter3d',
-              mode: 'markers+text',
-              x: [x], y: [y], z: [z],
-              marker: { color: color, size: 5 },
-              text: [g.label || tag],
-              textposition: 'top center'
-            });
+      if (file1) {
+        const data1 = await sendFile(file1);
+        traces.push(...extractTraces(data1, 'File A', 'red', 'blue'));
+      }
 
-            allTraces.push({
-              type: 'scatter3d',
-              mode: 'lines',
-              x: [x, x + nx],
-              y: [y, y + ny],
-              z: [z, z + nz],
-              line: { color: normalColor, width: 2 }
-            });
-          }
+      if (file2) {
+        const data2 = await sendFile(file2);
+        traces.push(...extractTraces(data2, 'File B', 'purple', 'orange'));
+      }
 
-          for (const c of data.constraints) {
-            const g1 = data.geometry[c.from];
-            const g2 = data.geometry[c.to];
-            if (g1 && g2) {
-              const [x1, y1, z1] = g1.base_point;
-              const [x2, y2, z2] = g2.base_point;
-              allTraces.push({
-                type: 'scatter3d',
-                mode: 'lines',
-                x: [x1, x2], y: [y1, y2], z: [z1, z2],
-                line: { color: 'green', dash: 'dot', width: 2 }
-              });
-            }
-          }
-        }
+      Plotly.newPlot('plot', traces, {
+        margin: { t: 30 },
+        scene: { aspectmode: 'data' },
+        title: '3D Assembly Viewer'
+      });
+    }
+
+    async function sendFile(file) {
+      const formData = new FormData();
+      formData.append("file", file);
+      const res = await fetch("/parse", {
+        method: "POST",
+        body: formData
+      });
+      return await res.json();
+    }
+
+    function extractTraces(data, prefix, baseColor, normalColor) {
+      const traces = [];
 
-        Plotly.newPlot('plot', allTraces, {
-          margin: { t: 30 },
-          scene: { aspectmode: 'data' },
-          title: '3D Assembly Viewer'
+      for (const [tag, g] of Object.entries(data.geometry)) {
+        const [x, y, z] = g.base_point;
+        const [nx, ny, nz] = g.normal;
+
+        traces.push({
+          type: 'scatter3d',
+          mode: 'markers+text',
+          x: [x], y: [y], z: [z],
+          marker: { color: baseColor, size: 5 },
+          text: [`${prefix}: ${g.label || tag}`],
+          textposition: 'top center'
+        });
+
+        traces.push({
+          type: 'scatter3d',
+          mode: 'lines',
+          x: [x, x + nx],
+          y: [y, y + ny],
+          z: [z, z + nz],
+          line: { color: normalColor, width: 3 }
         });
-      } catch (e) {
-        console.error("Failed to load or draw", e);
-        document.getElementById("plot").innerText = "Failed to load data or draw. Check console.";
       }
-    }
 
-    drawFromServer();
+      for (const c of data.constraints) {
+        const g1 = data.geometry[c.from];
+        const g2 = data.geometry[c.to];
+        if (g1 && g2) {
+          const [x1, y1, z1] = g1.base_point;
+          const [x2, y2, z2] = g2.base_point;
+          traces.push({
+            type: 'scatter3d',
+            mode: 'lines',
+            x: [x1, x2], y: [y1, y2], z: [z1, z2],
+            line: { color: 'green', dash: 'dot', width: 2 }
+          });
+        }
+      }
+
+      return traces;
+    }
   </script>
 </body>
-</html>
+</html>

requirements.txt

@@ -2,4 +2,3 @@
 fastapi
 uvicorn
 python-multipart
-streamlit