6

src/services/geometryGenerator.ts

@@ -2,10 +2,52 @@ import * as THREE from 'three';
 import { STLExporter, mergeBufferGeometries } from 'three-stdlib';
 import { AppConfig, LayoutSplits, GeneratedPart, Partition } from '../types';
 
-// --- ТИПЫ ДЛЯ РАСЧЕТА ---
+// Типы для внутреннего решателя
 type Limits = { min: number; max: number };
 type LimitMap = Record<string, Limits>;
 
+// --- SOLVER: Итеративный расчет границ ---
+// Эта функция гарантирует, что стенки не будут торчать друг из друга
+const solveWallLimits = (partitions: Partition[]): LimitMap => {
+    const limits: LimitMap = {};
+    
+    // 1. Инициализация: считаем, что все стенки идут от 0 до 1
+    partitions.forEach(p => { limits[p.id] = { min: 0, max: 1 }; });
+
+    // 2. Итеративное решение (3 прохода достаточно для любой вложенности)
+    for (let pass = 0; pass < 3; pass++) {
+        partitions.forEach(target => {
+            let newMin = 0;
+            let newMax = 1;
+            const center = target.offset; // Положение стенки
+
+            partitions.forEach(obstacle => {
+                if (target.id === obstacle.id) return;
+                if (target.axis === obstacle.axis) return; // Параллельные не мешают
+
+                // Берем АКТУАЛЬНЫЕ границы препятствия с прошлого шага
+                const obsMin = limits[obstacle.id].min;
+                const obsMax = limits[obstacle.id].max;
+
+                // Пересекает ли препятствие путь нашей стенки?
+                // obstacle.offset - это позиция препятствия на нашем пути.
+                // target.offset - это наша позиция. Она должна быть ВНУТРИ длины препятствия.
+                if (target.offset > obsMin && target.offset < obsMax) {
+                    // Препятствие на пути. Где оно?
+                    if (obstacle.offset < center) {
+                        newMin = Math.max(newMin, obstacle.offset);
+                    } else if (obstacle.offset > center) {
+                        newMax = Math.min(newMax, obstacle.offset);
+                    }
+                }
+            });
+
+            limits[target.id] = { min: newMin, max: newMax };
+        });
+    }
+    return limits;
+};
+
 export const calculateParts = (config: AppConfig, splits: LayoutSplits): GeneratedPart[] => {
   const parts: GeneratedPart[] = [];
   const safeX = Array.isArray(splits?.x) ? splits.x : [];
@@ -21,9 +63,9 @@ export const calculateParts = (config: AppConfig, splits: LayoutSplits): Generat
     for (let j = 0; j < yPoints.length - 1; j++) {
       const rawW = (xPoints[i + 1] - xPoints[i]) * config.drawer.width;
       const rawD = (yPoints[j + 1] - yPoints[j]) * config.drawer.depth;
-
-      // Пропускаем слишком маленькие ячейки
-      if (rawW < 10 || rawD < 10) continue;
+      
+      // Игнорируем микро-ячейки
+      if (rawW < 5 || rawD < 5) continue;
 
       const rawX = xPoints[i] * config.drawer.width;
       const rawY = yPoints[j] * config.drawer.depth;
@@ -35,8 +77,6 @@ export const calculateParts = (config: AppConfig, splits: LayoutSplits): Generat
       const realX = rawX + (config.printerTolerance / 2);
       const realY = rawY + (config.printerTolerance / 2);
 
-      if (realWidth < 5 || realDepth < 5) continue;
-
       parts.push({
           id: `part-${partCounter}`,
           name: `Ячейка ${i+1}-${j+1}`,
@@ -60,7 +100,6 @@ const createRoundedRectShape = (width: number, height: number, radius: number):
   const shape = new THREE.Shape();
   const x = -width / 2;
   const y = -height / 2;
-  // Ограничиваем радиус, чтобы не сломать геометрию при маленьких размерах
   const r = Math.min(radius, width / 2 - 0.1, height / 2 - 0.1);
 
   if (r <= 0.1) {
@@ -83,55 +122,29 @@ const createRoundedRectShape = (width: number, height: number, radius: number):
   return shape;
 };
 
-// Форма галтели (вогнутый угол)
+// Форма галтели (вогнутый уголок)
 const createFilletShape = (radius: number): THREE.Shape => {
     const shape = new THREE.Shape();
+    // Рисуем в 1-м квадранте
     shape.moveTo(0, 0);
     shape.lineTo(radius, 0);
-    // Рисуем вогнутую дугу в квадранте (+X, +Y)
     shape.absarc(radius, radius, radius, 1.5 * Math.PI, Math.PI, true);
     shape.lineTo(0, 0);
     return shape;
 };
 
-// --- УМНЫЙ РАСЧЕТ ГРАНИЦ (ДВУХПРОХОДНЫЙ) ---
-const calculateLimits = (target: Partition, allParts: Partition[], limitMap: LimitMap | null) => {
-    let min = 0;
-    let max = 1;
-    const mid = target.offset; // Используем offset как центр для определения стороны
-
-    allParts.forEach(p => {
-        if (p.axis === target.axis) return; // Игнорируем параллельные
-
-        // Получаем границы соседки. Если это второй проход, берем уже рассчитанные.
-        let pMin = p.min ?? 0;
-        let pMax = p.max ?? 1;
-        if (limitMap && limitMap[p.id]) {
-            pMin = limitMap[p.id].min;
-            pMax = limitMap[p.id].max;
-        }
-
-        // Проверяем пересечение
-        if (target.offset > pMin && target.offset < pMax) {
-            if (p.offset < mid) min = Math.max(min, p.offset);
-            else if (p.offset > mid) max = Math.min(max, p.offset);
-        }
-    });
-    return { min, max };
-};
-
 export const createBinGeometry = (
   width: number, depth: number, height: number, thickness: number, radius: number = 0, partitions: Partition[] = []
 ): THREE.BufferGeometry => {
   const geometries: THREE.BufferGeometry[] = [];
 
-  // ДНО
+  // 1. ДНО
   const floorShape = createRoundedRectShape(width, depth, radius);
-  const floorGeo = new THREE.ExtrudeGeometry(floorShape, { depth: thickness, bevelEnabled: false, curveSegments: 16 });
+  const floorGeo = new THREE.ExtrudeGeometry(floorShape, { depth: thickness, bevelEnabled: false });
   floorGeo.rotateX(-Math.PI / 2);
   geometries.push(floorGeo);
 
-  // ВНЕШНИЕ СТЕНКИ
+  // 2. ВНЕШНИЕ СТЕНКИ
   const outerShape = createRoundedRectShape(width, depth, radius);
   const innerRadius = Math.max(0.1, radius - thickness);
   const innerWidth = width - (2 * thickness);
@@ -143,95 +156,95 @@ export const createBinGeometry = (
   }
 
   const wallHeight = height - thickness;
-  const wallGeo = new THREE.ExtrudeGeometry(outerShape, { depth: wallHeight, bevelEnabled: false, curveSegments: 16 });
+  const wallGeo = new THREE.ExtrudeGeometry(outerShape, { depth: wallHeight, bevelEnabled: false });
   wallGeo.rotateX(-Math.PI / 2);
   wallGeo.translate(0, thickness, 0);
   geometries.push(wallGeo);
 
-  // --- РАСЧЕТ ГРАНИЦ ПЕРЕГОРОДОК (2 ПРОХОДА) ---
-  const limitMap: LimitMap = {};
-  // Проход 1: Считаем черновые границы
-  partitions.forEach(p => { limitMap[p.id] = calculateLimits(p, partitions, null); });
-  // Проход 2: Уточняем границы, используя результаты первого прохода
-  partitions.forEach(p => { limitMap[p.id] = calculateLimits(p, partitions, limitMap); });
+  // 3. ВНУТРЕННИЕ ПЕРЕГОРОДКИ (С SOLVER'ом)
+  const limitMap = solveWallLimits(partitions);
 
-  // --- ГЕНЕРАЦИЯ ПЕРЕГОРОДОК ---
   partitions.forEach(p => {
       const { min: pMin, max: pMax } = limitMap[p.id];
+      if (pMax - pMin < 0.01) return; // Слишком короткая
 
-      // Если стенка схлопнулась в ноль или стала отрицательной - пропускаем
-      if (pMax - pMin < 0.01) return;
-      
       const lengthRatio = pMax - pMin;
       const midRatio = pMin + (lengthRatio / 2);
 
       let pWidth = 0, pDepth = 0, pX = 0, pY = 0; 
       
       if (p.axis === 'x') {
+          // Вертикальная
           pWidth = thickness;
           pDepth = lengthRatio * innerDepth; 
           pX = (-innerWidth / 2) + (innerWidth * p.offset);
           pY = (-innerDepth / 2) + (innerDepth * midRatio);
       } else {
+          // Горизонтальная
           pWidth = lengthRatio * innerWidth;
           pDepth = thickness;
           pX = (-innerWidth / 2) + (innerWidth * midRatio);
           pY = (-innerDepth / 2) + (innerDepth * p.offset);
       }
 
-      // Сама стенка (чуть скругленная для красоты)
-      const partShape = createRoundedRectShape(pWidth, pDepth, 0.2); 
-      const partGeo = new THREE.ExtrudeGeometry(partShape, { depth: p.height, bevelEnabled: false, curveSegments: 4 });
+      // Геометрия стенки
+      const partShape = createRoundedRectShape(pWidth, pDepth, 0.2);
+      const partGeo = new THREE.ExtrudeGeometry(partShape, { depth: p.height, bevelEnabled: false });
       partGeo.rotateX(-Math.PI / 2);
       partGeo.translate(pX, thickness, pY);
       geometries.push(partGeo);
 
-      // --- ГАЛТЕЛИ (СКРУГЛЕНИЯ) ---
+      // --- ДОБАВЛЕНИЕ СКРУГЛЕНИЙ (FILLETS) ---
       if (p.rounded && radius > 1) {
-          const filletR = Math.min(radius, 6, thickness * 2); 
-          if (filletR < 0.5) return;
-
+          const filletR = Math.min(radius, 5); 
           const filletShape = createFilletShape(filletR);
-          const filletExtrudeSettings = { depth: p.height, bevelEnabled: false, curveSegments: 12 };
+          const filletExtrude = { depth: p.height, bevelEnabled: false };
 
-          const addFillet = (x: number, y: number, rotation: number) => {
-              const geo = new THREE.ExtrudeGeometry(filletShape, filletExtrudeSettings);
+          const addFillet = (x: number, y: number, rotY: number) => {
+              const geo = new THREE.ExtrudeGeometry(filletShape, filletExtrude);
               geo.rotateX(-Math.PI / 2);
-              geo.rotateY(rotation);     
+              geo.rotateY(rotY); 
               geo.translate(x, thickness, y);
               geometries.push(geo);
           };
 
-          const halfThick = thickness / 2;
+          const h = thickness / 2; // half thickness
 
           if (p.axis === 'x') {
-              // ВЕРТИКАЛЬНАЯ СТЕНКА - Углы были правильные
-              const startY = (-innerDepth / 2) + (innerDepth * pMin);
-              const endY = (-innerDepth / 2) + (innerDepth * pMax);
-              addFillet(pX - halfThick, startY, 0);           // Top-Left
-              addFillet(pX + halfThick, startY, -Math.PI/2);  // Top-Right
-              addFillet(pX - halfThick, endY, Math.PI/2);     // Bottom-Left
-              addFillet(pX + halfThick, endY, Math.PI);       // Bottom-Right
-          } else {
-              // ГОРИЗОНТАЛЬНАЯ СТЕНКА - ИСПРАВЛЕНЫ УГЛЫ
-              const startX = (-innerWidth / 2) + (innerWidth * pMin);
-              const endX = (-innerWidth / 2) + (innerWidth * pMax);
-              
-              // Left End
-              addFillet(startX, pY + halfThick, 0);           // Top-Left
-              addFillet(startX, pY - halfThick, Math.PI/2);   // Bottom-Left
+              // Вертикальная (идет вдоль Z в 3D)
+              const startY = (-innerDepth / 2) + (innerDepth * pMin); // "Верхний" конец (Back)
+              const endY = (-innerDepth / 2) + (innerDepth * pMax);   // "Нижний" конец (Front)
 
-              // Right End
-              addFillet(endX, pY + halfThick, -Math.PI/2);    // Top-Right
-              addFillet(endX, pY - halfThick, Math.PI);       // Bottom-Right
+              // Проверяем, упирается ли она в края или другие стенки? (всегда рисуем, так как solver обрезал)
+              // Скругляем 4 угла стыка
+              
+              // Top End (pMin)
+              addFillet(pX - h, startY, 0);           // Слева, смотрит вверх
+              addFillet(pX + h, startY, -Math.PI/2);  // Справа, смотрит вверх
+
+              // Bottom End (pMax)
+              addFillet(pX - h, endY, Math.PI/2);     // Слева, смотрит вниз
+              addFillet(pX + h, endY, Math.PI);       // Справа, смотрит вниз
+
+          } else {
+              // Горизонтальная (идет вдоль X в 3D)
+              const startX = (-innerWidth / 2) + (innerWidth * pMin); // Левый конец
+              const endX = (-innerWidth / 2) + (innerWidth * pMax);   // Правый конец
+
+              // Left End (pMin)
+              addFillet(startX, pY + h, Math.PI);         // Сверху, смотрит влево (FIXED ANGLE)
+              addFillet(startX, pY - h, Math.PI/2);       // Снизу, смотрит влево (FIXED ANGLE)
+
+              // Right End (pMax)
+              addFillet(endX, pY + h, -Math.PI/2);        // Сверху, смотрит вправо (FIXED ANGLE)
+              addFillet(endX, pY - h, 0);                 // Снизу, смотрит вправо (FIXED ANGLE)
           }
       }
   });
 
   const merged = mergeBufferGeometries(geometries);
   if (merged) merged.computeVertexNormals();
-  // Возвращаем пустой бокс если ничего не сгенерировалось, чтобы не крашить
-  return merged || new THREE.BoxGeometry(0.1, 0.1, 0.1);
+  return merged || new THREE.BoxGeometry(1, 1, 1);
 };
 
 export const generateSTL = (mesh: THREE.Object3D): Uint8Array | string => {