From 74a3cfada25755ea30e8e38b3f0cb08ec80913d1 Mon Sep 17 00:00:00 2001 From: chk <79915315+ChKendel@users.noreply.github.com> Date: Wed, 10 Jun 2026 20:41:42 +0200 Subject: [PATCH] x-axis justierung: lines 3 --- public/boardViewer.html | 48 +++++++++++++++++ public/calibration.js | 74 ++++++++++++++++++++++++++ public/calibration_xaxis.html | 10 ++++ server/editRobot.js | 99 +++++++++++++++++++++++++++++++++++ server/server.js | 27 +++++++++- 5 files changed, 257 insertions(+), 1 deletion(-) diff --git a/public/boardViewer.html b/public/boardViewer.html index 62efad3..e0ecbb5 100644 --- a/public/boardViewer.html +++ b/public/boardViewer.html @@ -666,6 +666,54 @@ function buildCompareLines() { if (onlyCompare.length) parts.push(`nur Vergleich: ${onlyCompare.join(' ')}`); if (noMatch.length) parts.push(`nur Basis: ${noMatch.join(' ')}`); vlog(parts.join(' | '), matchedIds.length ? 'ok' : 'warn'); + + // ── Bewegungsanalyse: mittlerer Verschiebungsvektor → Abweichung von X-Achse ── + if (matchedIds.length > 0) { + // Summe aller Verschiebungsvektoren (in Roboter-Koordinaten mm) + let sx = 0, sy = 0, sz = 0; + for (const cm of _compareFremdMarkers) { + const pm = primaryMap.get(cm.marker_id); + if (!pm) continue; + const [pmx, pmy, pmz] = pm.position_mm.map(Number); + const [cmx, cmy, cmz] = cm.position_mm.map(Number); + sx += cmx - pmx; sy += cmy - pmy; sz += cmz - pmz; + } + const n = matchedIds.length; + const dx = sx / n, dy = sy / n, dz = sz / n; + const dist = Math.sqrt(dx*dx + dy*dy + dz*dz); + + if (dist > 0.01) { // mindestens 0.01 mm Bewegung + // Einheitsvektor – immer in Richtung positives X zeigen (konsistente Vorzeichen) + let vx = dx/dist, vy = dy/dist, vz = dz/dist; + if (vx < 0) { vx = -vx; vy = -vy; vz = -vz; } + + // Abweichungswinkel zur X-Achse [1,0,0] in Roboter-Koordinaten + // horizontal (XY-Ebene, Rotation um Z): positiv = nach Y (rückwärts) verschoben + // vertikal (XZ-Ebene, Rotation um Y): positiv = nach oben (+Z) verschoben + const degXY = Math.atan2(vy, vx) * 180 / Math.PI; + const degXZ = Math.atan2(vz, vx) * 180 / Math.PI; + + const fmt = v => (v >= 0 ? '+' : '') + v.toFixed(3) + '°'; + const good = Math.abs(degXY) < 0.5 && Math.abs(degXZ) < 0.5; + + vlog(`Bewegung: ⌀${dist.toFixed(2)} mm dir=[${vx.toFixed(4)}, ${vy.toFixed(4)}, ${vz.toFixed(4)}] (${n} Marker)`); + vlog(`Abw. von X-Achse: horizontal(XY) ${fmt(degXY)} vertikal(XZ) ${fmt(degXZ)}`, good ? 'ok' : 'warn'); + + // Parent informieren → aktiviert "X-Achse übernehmen"-Button + window.parent.postMessage({ + type: 'xaxis-measurement', + direction: [vx, vy, vz], + angleXY: degXY, + angleXZ: degXZ, + numMarkers: n, + distMm: dist, + }, '*'); + } else { + vlog(`Bewegung zu klein (${dist.toFixed(3)} mm) – Winkelberechnung übersprungen`, 'warn'); + // Messung ungültig → Parent mitteilen + window.parent.postMessage({ type: 'xaxis-measurement', direction: null }, '*'); + } + } } // ── Daten laden ─────────────────────────────────────────────────────────────── diff --git a/public/calibration.js b/public/calibration.js index f8beea6..dfda969 100644 --- a/public/calibration.js +++ b/public/calibration.js @@ -420,6 +420,80 @@ function initXAxis() { btn.disabled = false; } }); + + // ── X-Achse übernehmen ──────────────────────────────────────────────────── + // Empfängt postMessage aus dem eingebetteten boardViewer-iframe. + let _xaxisDirection = null; // zuletzt gemessene Richtung [vx,vy,vz] + + const adoptBtn = document.getElementById('btn-xaxis-adopt'); + + function onXaxisMessage(e) { + // Nachricht muss vom boardViewer-iframe stammen + const frame = document.getElementById('xaxis-viewer-frame'); + if (!frame || e.source !== frame.contentWindow) return; + const msg = e.data; + if (!msg || msg.type !== 'xaxis-measurement') return; + + if (Array.isArray(msg.direction)) { + _xaxisDirection = msg.direction; + const fmt = v => (v >= 0 ? '+' : '') + v.toFixed(3) + '°'; + logX(`📐 Messung empfangen: dir=[${msg.direction.map(v => v.toFixed(4)).join(', ')}]` + + ` XY=${fmt(msg.angleXY)} XZ=${fmt(msg.angleXZ)}` + + ` (${msg.numMarkers} Marker, Ø${msg.distMm.toFixed(1)} mm)`); + if (adoptBtn) { + adoptBtn.disabled = false; + adoptBtn.style.opacity = '1'; + adoptBtn.style.cursor = 'pointer'; + adoptBtn.title = `X-Achse übernehmen (dir=[${_xaxisDirection.map(v => v.toFixed(4)).join(', ')}])`; + } + } else { + // Ungültige / zu kleine Bewegung → Button sperren + _xaxisDirection = null; + if (adoptBtn) { + adoptBtn.disabled = true; + adoptBtn.style.opacity = '.45'; + adoptBtn.style.cursor = 'not-allowed'; + adoptBtn.title = 'Noch keine gültige Messung verfügbar'; + } + } + } + + window.addEventListener('message', onXaxisMessage); + + if (adoptBtn) { + adoptBtn.addEventListener('click', async () => { + if (!_xaxisDirection) return; + const fmt = v => (v >= 0 ? '+' : '') + v.toFixed(4); + logX(`🔄 Übernehme X-Achse: dir=[${_xaxisDirection.map(fmt).join(', ')}] …`); + adoptBtn.disabled = true; + adoptBtn.style.opacity = '.45'; + try { + const r = await fetch('/api/robot/adopt-x-axis', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ direction: _xaxisDirection }), + }); + const data = await r.json(); + if (!r.ok) { + logX(`❌ Fehler: ${data.error ?? r.status}`); + return; + } + logX(`✅ X-Achse gespeichert — ${data.numChanged} Marker rotiert`); + logX(` Ursprung (A0-Schwerpunkt): [${data.origin.join(', ')}] mm`); + logX(` Neue X-Achse: [${data.newXAxis.join(', ')}]` + + ` Korr. XY=${(data.angleXYdeg >= 0 ? '+' : '') + data.angleXYdeg}°` + + ` XZ=${(data.angleXZdeg >= 0 ? '+' : '') + data.angleXZdeg}°`); + // Viewer neu laden damit die aktualisierten Positionen sichtbar werden + const frame = document.getElementById('xaxis-viewer-frame'); + if (frame?.contentWindow) frame.contentWindow.postMessage({ type: 'reload' }, '*'); + } catch (err) { + logX(`❌ Netzwerkfehler: ${err}`); + } finally { + adoptBtn.disabled = false; + adoptBtn.style.opacity = '1'; + } + }); + } } // ── Tab: Board (shared helpers) ─────────────────────────────────────────────── diff --git a/public/calibration_xaxis.html b/public/calibration_xaxis.html index 53572b4..b8cfaa5 100644 --- a/public/calibration_xaxis.html +++ b/public/calibration_xaxis.html @@ -45,6 +45,16 @@ Rechts ➡ +
+ + + Übernimmt die gemessene Richtung (aus Basis- und Vergleichs-Run) als X-Achse in robot.json + +
diff --git a/server/editRobot.js b/server/editRobot.js index 723942e..ced4116 100644 --- a/server/editRobot.js +++ b/server/editRobot.js @@ -389,3 +389,102 @@ export async function assignMarkerId(robotPath, { markerId, set, link, extraMark change: { action: 'added', markerId: id, oldLink: null, oldSet: '', newLink: link, newSet: set ?? '' }, }; } + +// ── Aktion 5: X-Achse übernehmen ───────────────────────────────────────────── + +/** + * Rotiert alle Marker-Positionen in robot.json so, dass die übergebene Richtung + * zur neuen X-Achse [1,0,0] wird. Rotation um den Schwerpunkt aller A0-Marker + * (Origin bleibt erhalten). + * + * direction: [vx, vy, vz] – gemessene Ist-X-Richtung in Roboter-Koordinaten + * + * Algorithmus: + * 1. Normalisiere direction, ggf. Vorzeichen so dass vx > 0 + * 2. Baue Orthonormalbasis: x_new = v, + * z_new = Gram-Schmidt([0,0,1] gegen v), + * y_new = cross(z_new, x_new) + * 3. Rotationsmatrix R (old→new): Zeilen = [x_new, y_new, z_new] + * 4. p_new = origin + R * (p_old − origin) + */ +export async function adoptXAxis(robotPath, { direction }) { + const [vx, vy, vz] = direction.map(Number); + const len = Math.sqrt(vx * vx + vy * vy + vz * vz); + if (len < 1e-9) throw new Error('Richtungsvektor zu klein (fast Null-Vektor).'); + + // Normalisieren, immer positive X-Komponente + let nx = vx / len, ny = vy / len, nz = vz / len; + if (nx < 0) { nx = -nx; ny = -ny; nz = -nz; } + + // ── Orthonormalbasis ────────────────────────────────────────────────────── + // Z_new: Gram-Schmidt von [0,0,1] gegen x_new + const dotZ = nz; // dot([0,0,1], [nx,ny,nz]) + let zx = -dotZ * nx, zy = -dotZ * ny, zz = 1 - dotZ * nz; + let zlen = Math.sqrt(zx * zx + zy * zy + zz * zz); + if (zlen < 1e-9) { + // Sonderfall: x_new fast parallel zu Z – Fallback auf [0,1,0] + const dotY = ny; + zx = -dotY * nx; zy = 1 - dotY * ny; zz = -dotY * nz; + zlen = Math.sqrt(zx * zx + zy * zy + zz * zz); + } + zx /= zlen; zy /= zlen; zz /= zlen; + + // Y_new = cross(z_new, x_new) [rechte-Hand-Regel: ẑ × x̂ = ŷ] + const yx = zy * nz - zz * ny; + const yy = zz * nx - zx * nz; + const yz = zx * ny - zy * nx; + + // Rotationsfunktion: p_rot = R * p (R hat Zeilen = neue Achsen in alten Koordinaten) + function rotVec(px, py, pz) { + return [ + nx * px + ny * py + nz * pz, // neue X-Komponente + yx * px + yy * py + yz * pz, // neue Y-Komponente + zx * px + zy * py + zz * pz, // neue Z-Komponente + ]; + } + + const robot = await readRobot(robotPath); + const links = robot.links ?? {}; + + // ── Ursprung: Schwerpunkt aller A0-Marker ──────────────────────────────── + const a0Pos = []; + for (const ld of Object.values(links)) { + for (const m of (ld.markers ?? [])) { + if (m.set === 'A0' && Array.isArray(m.position) && m.position.length >= 3) { + a0Pos.push(m.position.map(Number)); + } + } + } + let ox = 0, oy = 0, oz = 0; + if (a0Pos.length > 0) { + for (const [px, py, pz] of a0Pos) { ox += px; oy += py; oz += pz; } + ox /= a0Pos.length; oy /= a0Pos.length; oz /= a0Pos.length; + } + + // ── Alle Marker rotieren ────────────────────────────────────────────────── + let numChanged = 0; + for (const ld of Object.values(links)) { + for (const m of (ld.markers ?? [])) { + if (!Array.isArray(m.position) || m.position.length < 3) continue; + const [px, py, pz] = m.position.map(Number); + const [rx, ry, rz] = rotVec(px - ox, py - oy, pz - oz); + m.position = [ + Math.round((ox + rx) * 100) / 100, + Math.round((oy + ry) * 100) / 100, + Math.round((oz + rz) * 100) / 100, + ]; + numChanged++; + } + } + + robot.links = links; + await writeRobot(robotPath, robot); + + return { + numChanged, + origin: [ox, oy, oz].map(v => Math.round(v * 10) / 10), + newXAxis: [nx, ny, nz].map(v => Math.round(v * 10000) / 10000), + angleXYdeg: Math.round(Math.atan2(ny, nx) * 18000 / Math.PI) / 100, + angleXZdeg: Math.round(Math.atan2(nz, nx) * 18000 / Math.PI) / 100, + }; +} diff --git a/server/server.js b/server/server.js index 789000f..79d93e9 100755 --- a/server/server.js +++ b/server/server.js @@ -8,7 +8,7 @@ import { fileURLToPath } from 'url'; import process from 'process'; import { spawn } from 'child_process'; import { WebcamClient } from './webcamClient.js'; -import { assignByZRange, removeMarkerAssignment, alignSetToMeasured, assignMarkerId } from './editRobot.js'; +import { assignByZRange, removeMarkerAssignment, alignSetToMeasured, assignMarkerId, adoptXAxis } from './editRobot.js'; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); @@ -864,6 +864,31 @@ app.post('/api/robot/assign-id', async (req, res) => { } }); +/** + * POST /api/robot/adopt-x-axis + * Dreht alle Marker-Positionen in robot.json so, dass die gemessene Richtung + * zur neuen X-Achse [1,0,0] wird. Rotation um den A0-Schwerpunkt. + * Body: { direction: [vx, vy, vz] } + */ +app.post('/api/robot/adopt-x-axis', async (req, res) => { + try { + const { direction } = req.body ?? {}; + if (!Array.isArray(direction) || direction.length < 3) { + return res.status(400).json({ error: '"direction" muss ein Array [vx,vy,vz] sein.' }); + } + const result = await adoptXAxis(ROBOT_JSON, { direction }); + console.log( + `robot/adopt-x-axis dir=[${direction.map(v => Number(v).toFixed(4)).join(', ')}]` + + ` → ${result.numChanged} Marker, Ursprung=[${result.origin.join(', ')}]` + + ` XY=${result.angleXYdeg}° XZ=${result.angleXZdeg}°`, + ); + return res.json(result); + } catch (err) { + console.error('robot/adopt-x-axis error:', err); + return res.status(500).json({ error: String(err) }); + } +}); + /** * POST /api/calibration/upload-npz * Liest {camera}_calibration.npz aus der aktuellen Session und