diff --git a/src/components/floor-plan/modal/basic/step/ModuleTabContents.jsx b/src/components/floor-plan/modal/basic/step/ModuleTabContents.jsx index 70f1f1ab..24640917 100644 --- a/src/components/floor-plan/modal/basic/step/ModuleTabContents.jsx +++ b/src/components/floor-plan/modal/basic/step/ModuleTabContents.jsx @@ -171,8 +171,9 @@ export default function ModuleTabContents({ tabIndex, addRoof, setAddedRoofs, ro
{/* 2026-06-05 공법 버튼을 배열 인덱스 대신 constTp로 매핑 — API 응답 항목 추가/순서변경(예: 標準施工(Ⅱ) WORK_LV_ID_-2) 시 인덱스 밀림 방지. 운영(구 API)엔 -2가 없어 optional 은 데이터 있을 때만 렌더 */} {[ - { constTp: 'WORK_LV_ID_-1', label: '標準施工(Ⅰ)' }, + // [표시순서변경 2026-06-17] 標準(Ⅱ) 를 標準(Ⅰ) 앞으로 — 사용자 요청 { constTp: 'WORK_LV_ID_-2', label: '標準施工(Ⅱ)', optional: true }, + { constTp: 'WORK_LV_ID_-1', label: '標準施工(Ⅰ)' }, { constTp: 'WORK_LV_ID_1', label: '標準施工' }, { constTp: 'WORK_LV_ID_3', label: '強化施工' }, { constTp: 'WORK_LV_ID_4', label: '多設施工' }, diff --git a/src/components/floor-plan/modal/basic/step/Trestle.jsx b/src/components/floor-plan/modal/basic/step/Trestle.jsx index 98a4c4ee..efe40fce 100644 --- a/src/components/floor-plan/modal/basic/step/Trestle.jsx +++ b/src/components/floor-plan/modal/basic/step/Trestle.jsx @@ -867,8 +867,9 @@ const Trestle = forwardRef((props, ref) => {
{/* 2026-06-05 공법 버튼을 배열 인덱스 대신 constTp로 매핑 — API 응답 항목 추가/순서변경(예: 標準施工(II) WORK_LV_ID_-2) 시 인덱스 밀림 방지. 운영(구 API)엔 -2가 없어 optional 은 데이터 있을 때만 렌더 */} {[ - { constTp: 'WORK_LV_ID_-1', label: `${getMessage('modal.module.basic.setting.module.standard.construction')}(I)` }, + // [표시순서변경 2026-06-17] 標準(II) 를 標準(I) 앞으로 — 사용자 요청 { constTp: 'WORK_LV_ID_-2', label: `${getMessage('modal.module.basic.setting.module.standard.construction')}(II)`, optional: true }, + { constTp: 'WORK_LV_ID_-1', label: `${getMessage('modal.module.basic.setting.module.standard.construction')}(I)` }, { constTp: 'WORK_LV_ID_1', label: getMessage('modal.module.basic.setting.module.standard.construction') }, { constTp: 'WORK_LV_ID_3', label: getMessage('modal.module.basic.setting.module.enforce.construction') }, { constTp: 'WORK_LV_ID_4', label: getMessage('modal.module.basic.setting.module.multiple.construction') }, diff --git a/src/hooks/roofcover/useEavesGableEdit.js b/src/hooks/roofcover/useEavesGableEdit.js index d76900cc..35221da3 100644 --- a/src/hooks/roofcover/useEavesGableEdit.js +++ b/src/hooks/roofcover/useEavesGableEdit.js @@ -2769,6 +2769,416 @@ export function useEavesGableEdit(id) { logger.log('[KERAB-REVERT] applied ' + JSON.stringify({ ok, c1, c2, apex: ridgeAtMid.apex })) if (ok) return } + // [KERAB-VALLEY-EAVES-RULE1 2026-06-16] A/B타입 native 케라바 변(스냅샷·native마루·kLine 전부 없음)의 + // 첫 처마 변환 "씨앗". 양 코너에서 폴리곤 안쪽 45° 힙 2개를 그려 각자 첫 교차(다른 inner line 또는 + // 상대편 roofLine)까지 뻗는다. R3 절삭만 — 반사·힙 사이 마루 생성은 보류(다각형 넓이 의존, 추후 결정). + // 出幅은 일반 라인변경과 동일하게 기존 surgical 로 처리. 게이트: 변 위에 collinear 게이블벽 inner line + // 이 실재할 때만(= 진짜 케라바 기하). 없으면 아래 attr-only 폴백. + { + const EDGE_TOL = 0.5 + const NP = roof.points.length + let edgeIdx = -1 + for (let i = 0; i < NP; i++) { + const p = roof.points[i] + const q = roof.points[(i + 1) % NP] + if ( + (Math.hypot(p.x - c1.x, p.y - c1.y) < EDGE_TOL && Math.hypot(q.x - c2.x, q.y - c2.y) < EDGE_TOL) || + (Math.hypot(p.x - c2.x, p.y - c2.y) < EDGE_TOL && Math.hypot(q.x - c1.x, q.y - c1.y) < EDGE_TOL) + ) { + edgeIdx = i + break + } + } + // 변환되는 게이블 변의 "게이블벽" 전체를 제거한다(사용자 확정 2026-06-16). + // 게이블벽 = 변 c1↔c2(roofLine쪽) 또는 옛 出幅쪽 outerLine 과 같은 무한직선 위의 HIP 세그먼트. + // 변이 게이블일 때만 존재한 구조 → eaves 가 되면 소멸. 한 직선이 ridge 에 의해 여러 세그먼트로 + // 쪼개져 변 구간 밖(아래)까지 뻗기도 한다(예: H-9 = 변 아래 연장). 따라서 변 구간 겹침이 아니라 + // "무한직선 동일선상(양 끝점 수직거리<1)" 전체를 게이블벽으로 본다 — i5(변 위) + i10(변 아래) 모두. + // 이 전체 제거가 ridge(RG-2)의 anchor 를 끊어, 뒤의 dangling 정리에서 RG-2 까지 연쇄 제거된다. + const isCollinearWith = (l, A, B) => { + const dx = B.x - A.x + const dy = B.y - A.y + const lenSq = dx * dx + dy * dy || 1 + const perp = (px, py) => { + const t = ((px - A.x) * dx + (py - A.y) * dy) / lenSq + return Math.hypot(px - (A.x + t * dx), py - (A.y + t * dy)) + } + return perp(l.x1, l.y1) < 1.0 && perp(l.x2, l.y2) < 1.0 + } + // 옛 出幅쪽 수직벽 식별용 — surgical 전 target outerLine 끝점(=出幅 위치) 캡처. + const tA = { x: target.x1, y: target.y1 } + const tB = { x: target.x2, y: target.y2 } + // 게이블벽(HIP)만 직접 제거. native 마루(RIDGE)는 여기서 보존하되, anchor 가 끊겨 dangling 이 + // 되는 ridge(RG-2)는 뒤의 cleanupDangling 이 연쇄 제거한다(사용자 확정 2026-06-16). + const gableWallLines = (roof.innerLines || []).filter( + (l) => + l && l.visible !== false && l.name === LINE_TYPE.SUBLINE.HIP && (isCollinearWith(l, c1, c2) || isCollinearWith(l, tA, tB)), + ) + if (edgeIdx >= 0 && gableWallLines.length > 0) { + target.set({ attributes }) + // 1) 옛 게이블벽 라인 제거 + 짝 확장 helper(extensionLine) 동반 제거. + for (const gw of gableWallLines) { + removeLine(gw) + removeOrphanExtensionsForHip(gw) + } + roof.innerLines = roof.innerLines.filter((l) => !gableWallLines.includes(l)) + // 2) 出幅 반영 (일반 라인변경과 동일 — 기존 surgical, inner line 불변). + applyTargetOffsetSurgical(target, attributes?.offset ?? 0, { skipInnerLines: true }) + // 3) 새 roofLine 코너 (인덱스는 surgical 후에도 안정). + const pts = roof.points + const nA = pts[edgeIdx] + const nB = pts[(edgeIdx + 1) % NP] + const newC1IsA = Math.hypot(nA.x - c1.x, nA.y - c1.y) <= Math.hypot(nA.x - c2.x, nA.y - c2.y) + const idxA = newC1IsA ? edgeIdx : (edgeIdx + 1) % NP + const idxB = newC1IsA ? (edgeIdx + 1) % NP : edgeIdx + const newC1 = pts[idxA] + const newC2 = pts[idxB] + // 폴리곤 중심 (inward 판정용). + let cenX = 0 + let cenY = 0 + for (const p of pts) { + cenX += p.x + cenY += p.y + } + cenX /= pts.length || 1 + cenY /= pts.length || 1 + // 코너의 두 이웃 변 방향 → 폴리곤 안쪽 45° 이등분선 (convex/reflex 모두 안쪽으로 보정). + const inwardDir = (idx) => { + const C = pts[idx] + const prev = pts[(idx - 1 + NP) % NP] + const next = pts[(idx + 1) % NP] + const n1 = Math.hypot(prev.x - C.x, prev.y - C.y) || 1 + const n2 = Math.hypot(next.x - C.x, next.y - C.y) || 1 + let dx = (prev.x - C.x) / n1 + (next.x - C.x) / n2 + let dy = (prev.y - C.y) / n1 + (next.y - C.y) / n2 + const dl = Math.hypot(dx, dy) + if (dl < 1e-6) { + // 일직선(180°) — 변 수직 안쪽 법선. + dx = -(next.y - C.y) / n2 + dy = (next.x - C.x) / n2 + } else { + dx /= dl + dy /= dl + } + if (dx * (cenX - C.x) + dy * (cenY - C.y) < 0) { + dx = -dx + dy = -dy + } + return { x: dx, y: dy } + } + // corner 에서 dir 로 ray → 첫 교차(roofLine 변 + 기존 inner line), 자기 변(t≈0) 제외. + const rayFirstHit = (P, dir) => { + const segHit = (A, B) => { + const ex = B.x - A.x + const ey = B.y - A.y + const den = dir.x * ey - dir.y * ex + if (Math.abs(den) < 1e-9) return Infinity + const t = ((A.x - P.x) * ey - (A.y - P.y) * ex) / den + const u = ((A.x - P.x) * dir.y - (A.y - P.y) * dir.x) / den + if (t > 1.0 && u >= -1e-6 && u <= 1 + 1e-6) return t + return Infinity + } + let best = Infinity + let hit = null + let hitLine = null + for (let i = 0; i < NP; i++) { + const t = segHit(pts[i], pts[(i + 1) % NP]) + if (t < best) { + best = t + hit = { x: P.x + dir.x * t, y: P.y + dir.y * t, line: null, kind: 'roofLine' } + hitLine = null + } + } + for (const il of roof.innerLines || []) { + if (!il || il.visible === false) continue + if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue + const t = segHit({ x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 }) + if (t < best) { + best = t + hit = { x: P.x + dir.x * t, y: P.y + dir.y * t, line: il, kind: il.name } + hitLine = il + } + } + return hit + } + const mkValleyHip = (corner, hit) => { + const arr = [corner.x, corner.y, hit.x, hit.y] + const sz = calcLinePlaneSize({ x1: arr[0], y1: arr[1], x2: arr[2], y2: arr[3] }) + const hip = new QLine(arr, { + parentId: roof.id, + fontSize: roof.fontSize, + stroke: '#1083E3', + strokeWidth: 3, + name: LINE_TYPE.SUBLINE.HIP, + textMode: roof.textMode, + attributes: { roofId: roof.id, type: LINE_TYPE.SUBLINE.HIP, planeSize: sz, actualSize: sz }, + }) + hip.lineName = 'kerabPatternHip' + hip.startPoint = { x: hip.x1, y: hip.y1 } + hip.endPoint = { x: hip.x2, y: hip.y2 } + return hip + } + const addHipFrom = (corner, idx) => { + const dir = inwardDir(idx) + const hit = rayFirstHit(corner, dir) + if (!hit) return { dir, hit: null, hip: null, hitLine: null, hitKind: null } + const h = mkValleyHip(corner, hit) + canvas.add(h) + h.bringToFront() + roof.innerLines.push(h) + return { dir, hit, hip: h, hitLine: hit.line, hitKind: hit.kind } + } + // 임의 방향 ray 로 골짜기 힙 1개 생성(반사 힙용). 첫 교차까지. + const drawHipRay = (from, dir) => { + const hit = rayFirstHit(from, dir) + if (!hit) return null + const h = mkValleyHip(from, hit) + canvas.add(h) + h.bringToFront() + roof.innerLines.push(h) + return { hip: h, hit } + } + // 4) 게이블 구조 잔재 정리 — anchor(게이블벽 HIP) 제거로 dangling 이 된 HIP·확장라인(H-9 등)만 제거. + // ★ 마루(RIDGE)는 절대 제거하지 않는다 — dangling 이어도 보존(사용자 확정 2026-06-16: + // "마루를 지우면 안된다"). RIDGE 는 connectivity 판정에는 포함(다른 HIP 의 접합 대상)하되 + // dangler 후보에서는 제외. VALLEY(골짜기확장)도 vExt 위에서 끝나는 정상 케이스라 제외. + // 새 골짜기 힙 그리기 *전에* 수행해야 raycast 가 깨끗한 기하에 닿아 SHORT-hit 를 피한다. + const cleanupDangling = () => { + const TOL = 2.0 + const rpts = roof.points || [] + const distToSeg = (p, a, b) => { + const ex = b.x - a.x + const ey = b.y - a.y + const l2 = ex * ex + ey * ey || 1 + let t = ((p.x - a.x) * ex + (p.y - a.y) * ey) / l2 + t = Math.max(0, Math.min(1, t)) + return Math.hypot(p.x - (a.x + t * ex), p.y - (a.y + t * ey)) + } + const minEdgeDist = (pt) => { + let m = Infinity + for (let i = 0, j = rpts.length - 1; i < rpts.length; j = i++) { + const d = distToSeg(pt, rpts[j], rpts[i]) + if (d < m) m = d + } + return m + } + const removed = [] + for (let iter = 0; iter < 12; iter++) { + const surv = (roof.innerLines || []).filter( + (l) => + l && + l.visible !== false && + (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE || l.name === LINE_TYPE.SUBLINE.VALLEY), + ) + const ends = [] + for (const l of surv) { + ends.push({ x: l.x1, y: l.y1, line: l }) + ends.push({ x: l.x2, y: l.y2, line: l }) + } + // 마루(RIDGE)·VALLEY 는 dangling 이어도 제거 금지 — HIP 만 제거 후보. + const dangler = surv.find((l) => { + if (l.name !== LINE_TYPE.SUBLINE.HIP) return false + for (const p of [ + { x: l.x1, y: l.y1 }, + { x: l.x2, y: l.y2 }, + ]) { + const onBoundary = rpts.length >= 3 && minEdgeDist(p) <= TOL + const shared = ends.some((e) => e.line !== l && Math.hypot(e.x - p.x, e.y - p.y) < TOL) + if (!onBoundary && !shared) return true + } + return false + }) + if (!dangler) break + removeLine(dangler) + roof.innerLines = roof.innerLines.filter((l) => l !== dangler) + removeOrphanExtensionsForHip(dangler) + removed.push({ n: dangler.name, ln: dangler.lineName || '-', x1: Math.round(dangler.x1), y1: Math.round(dangler.y1), x2: Math.round(dangler.x2), y2: Math.round(dangler.y2) }) + } + return removed + } + const cleaned = cleanupDangling() + const resA = addHipFrom(newC1, idxA) + const resB = addHipFrom(newC2, idxB) + // 5b) 마루(RIDGE) 끝점 상호작용 — anchor 잃은 끝점 해소(사용자 확정 2026-06-16: "RG1(h8) 확장, RG2(b5) 절삭"). + // 규칙: 마루는 절대 삭제 안 함. anchor 잃은(=경계 미접촉 + 다른 선과 미공유) 끝점은 + // · 새 골짜기 힙이 그 마루를 가로지르면 → 교점에서 절삭(trim, 끝점을 교점으로 당김) + // · 가로지르는 힙이 없으면 → 끝점 방향으로 roofLine/다음 라인까지 확장(extend) + const resolveRidgeEndpoints = () => { + const TOL = 2.0 + const rpts = roof.points || [] + const newHips = [resA, resB].map((r) => r && r.hip).filter(Boolean) + const distToSeg = (p, a, b) => { + const ex = b.x - a.x + const ey = b.y - a.y + const l2 = ex * ex + ey * ey || 1 + let t = ((p.x - a.x) * ex + (p.y - a.y) * ey) / l2 + t = Math.max(0, Math.min(1, t)) + return Math.hypot(p.x - (a.x + t * ex), p.y - (a.y + t * ey)) + } + const minEdgeDist = (pt) => { + let m = Infinity + for (let i = 0, j = rpts.length - 1; i < rpts.length; j = i++) { + const d = distToSeg(pt, rpts[j], rpts[i]) + if (d < m) m = d + } + return m + } + // 선분 교차(내부 교점만, 끝점 t∈(eps,1-eps)) + const segInt = (p1, p2, p3, p4) => { + const d1x = p2.x - p1.x + const d1y = p2.y - p1.y + const d2x = p4.x - p3.x + const d2y = p4.y - p3.y + const den = d1x * d2y - d1y * d2x + if (Math.abs(den) < 1e-9) return null + const t = ((p3.x - p1.x) * d2y - (p3.y - p1.y) * d2x) / den + const u = ((p3.x - p1.x) * d1y - (p3.y - p1.y) * d1x) / den + if (t <= 1e-6 || t >= 1 - 1e-6 || u <= 1e-6 || u >= 1 - 1e-6) return null + return { x: p1.x + t * d1x, y: p1.y + t * d1y } + } + // 절삭 전용: 마루(rp→rq)는 내부만, 힙(ha→hb)은 끝점 닿음(T자)까지 허용 + const segIntTrim = (rp, rq, ha, hb) => { + const d1x = rq.x - rp.x + const d1y = rq.y - rp.y + const d2x = hb.x - ha.x + const d2y = hb.y - ha.y + const den = d1x * d2y - d1y * d2x + if (Math.abs(den) < 1e-9) return null + const t = ((ha.x - rp.x) * d2y - (ha.y - rp.y) * d2x) / den + const u = ((ha.x - rp.x) * d1y - (ha.y - rp.y) * d1x) / den + if (t <= 1e-6 || t >= 1 - 1e-6) return null // 마루 내부만 + if (u <= 1e-6 || u >= 1 + 1e-3) return null // 힙 끝점 닿음 허용 + return { x: rp.x + t * d1x, y: rp.y + t * d1y } + } + // 힙의 먼 끝(코너=startPoint 반대쪽 endPoint)을 교차점으로 절삭 + 라벨 갱신 + const trimHipFarEnd = (hip, cross) => { + hip.set({ x2: cross.x, y2: cross.y }) + hip.endPoint = { x: cross.x, y: cross.y } + const nsz = calcLinePlaneSize({ x1: hip.x1, y1: hip.y1, x2: cross.x, y2: cross.y }) + hip.attributes = { ...hip.attributes, planeSize: nsz, actualSize: nsz } + hip.setLength?.() + hip.setCoords?.() + hip.addLengthText?.() + } + const ridges = (roof.innerLines || []).filter((l) => l && l.visible !== false && l.name === LINE_TYPE.SUBLINE.RIDGE) + const allEnds = [] + for (const l of (roof.innerLines || []).filter( + (l) => + l && + l.visible !== false && + (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE || l.name === LINE_TYPE.SUBLINE.VALLEY), + )) { + allEnds.push({ x: l.x1, y: l.y1, line: l }) + allEnds.push({ x: l.x2, y: l.y2, line: l }) + } + const touched = [] + for (const rg of ridges) { + const endsOf = [ + { p: { x: rg.x1, y: rg.y1 }, q: { x: rg.x2, y: rg.y2 }, set: (pt) => rg.set({ x1: pt.x, y1: pt.y }) }, + { p: { x: rg.x2, y: rg.y2 }, q: { x: rg.x1, y: rg.y1 }, set: (pt) => rg.set({ x2: pt.x, y2: pt.y }) }, + ] + for (const { p, q, set } of endsOf) { + const onBoundary = rpts.length >= 3 && minEdgeDist(p) <= TOL + const shared = allEnds.some((e) => e.line !== rg && Math.hypot(e.x - p.x, e.y - p.y) < TOL) + if (onBoundary || shared) continue // anchor 있음 → 그대로 + // (a) 가로지르는 힙 탐색 → 절삭 + let trimPt = null + let trimD = Infinity + for (const h of newHips) { + const ip = segIntTrim(p, q, { x: h.x1, y: h.y1 }, { x: h.x2, y: h.y2 }) + if (!ip) continue + const d = Math.hypot(ip.x - p.x, ip.y - p.y) + if (d < trimD) { + trimD = d + trimPt = ip + } + } + if (trimPt) { + set(trimPt) + touched.push({ act: 'trim', ln: rg.lineName || '-', to: { x: Math.round(trimPt.x), y: Math.round(trimPt.y) } }) + continue + } + // (b) 확장 — q→p 방향으로 첫 교차(roofLine 변 + 다른 inner line, 자기 제외)까지 + const dx = p.x - q.x + const dy = p.y - q.y + const mag = Math.hypot(dx, dy) || 1 + const ux = dx / mag + const uy = dy / mag + const castHit = (A, B) => { + const ip = segInt({ x: q.x, y: q.y }, { x: q.x + ux * 1e5, y: q.y + uy * 1e5 }, A, B) + if (!ip) return Infinity + const t = (ip.x - p.x) * ux + (ip.y - p.y) * uy + return t > 1e-3 ? t : Infinity + } + let best = Infinity + let hit = null + let hitLine = null + for (let i = 0; i < rpts.length; i++) { + const A = rpts[i] + const B = rpts[(i + 1) % rpts.length] + const t = castHit(A, B) + if (t < best) { + best = t + hit = { x: q.x + ux * (mag + t), y: q.y + uy * (mag + t) } + hitLine = null // roofLine 변 + } + } + for (const il of roof.innerLines || []) { + if (!il || il === rg || il.visible === false) continue + if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue + const t = castHit({ x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 }) + if (t < best) { + best = t + hit = { x: q.x + ux * (mag + t), y: q.y + uy * (mag + t) } + hitLine = il + } + } + if (hit) { + set(hit) + touched.push({ act: 'extend', ln: rg.lineName || '-', to: { x: Math.round(hit.x), y: Math.round(hit.y) } }) + // 확장한 마루가 힙 몸통에 닿으면 → 그 힙의 먼 끝(코너 반대쪽)을 교차점으로 절삭(힙은 마루를 넘지 못함) + if (hitLine && hitLine.name === LINE_TYPE.SUBLINE.HIP) { + trimHipFarEnd(hitLine, hit) + touched.push({ act: 'trim-hip', ln: hitLine.lineName || '-', to: { x: Math.round(hit.x), y: Math.round(hit.y) } }) + } + } + } + } + return touched + } + const ridgeOps = resolveRidgeEndpoints() + // 5c) Y 반사 힙 — 새 힙이 *기존 마루(RIDGE)에 직접 부딪힌* 경우만(=raycast hit 가 RIDGE), + // 그 마루를 대칭축으로 반대편 면에 반사 힙 1개 생성(R7: 마루+hip 교점 반사). + // ★ 마루를 *확장*해서 만난 힙(hit 가 roofLine 이던 resA)은 Y 아님 → 반사 안 함(사용자 확정 2026-06-16). + const reflectOps = [] + for (const res of [resA, resB]) { + if (!res || !res.hip || res.hitKind !== LINE_TYPE.SUBLINE.RIDGE || !res.hitLine) continue + const M = { x: res.hit.x, y: res.hit.y } + const rg = res.hitLine + const rlen = Math.hypot(rg.x2 - rg.x1, rg.y2 - rg.y1) || 1 + const rx = (rg.x2 - rg.x1) / rlen + const ry = (rg.y2 - rg.y1) / rlen + // 반사 방향 = reflect(역입사) 마루축 기준. w=역입사(코너→M 반대), v_ref=2(w·r̂)r̂ - w + const wx = -res.dir.x + const wy = -res.dir.y + const dot = wx * rx + wy * ry + const refDir = { x: 2 * dot * rx - wx, y: 2 * dot * ry - wy } + const drawn = drawHipRay(M, refDir) + if (drawn) { + reflectOps.push({ from: { x: Math.round(M.x), y: Math.round(M.y) }, to: { x: Math.round(drawn.hit.x), y: Math.round(drawn.hit.y) } }) + } + } + removeKerabHalfLabels(target.id) + hideOriginalLengthText(target.id, false) + canvas.renderAll() + runKerabRuleCheck(roof, 'valley-eaves-rule1', kerabRevertBeforeSnap) + logger.log( + '[KERAB-VALLEY-EAVES-RULE1] applied ' + + JSON.stringify({ edgeIdx, removed: gableWallLines.length, cleaned, newC1, newC2, resA, resB, ridgeOps, reflectOps }), + ) + return + } + } // [2240 KERAB-ATTR-ONLY 2026-05-19] ridge-at-mid 없음 → forward 가 attribute-only 였음 → 동일 대칭으로 속성만 토글 target.set({ attributes }) applyKerabAttributeOnlyPattern()