basic-cad-tool-merge-lines.js

// Note to self.   Select "line" items in Doc tree > run addMergedLines
// No tolerance yet
// operator has to select lines that belong to the same "shape"
// manually - sorted needs to learn to find all that has matching start/end - then reprocess remainders again creating multiple polylines as it goes so you
// can even use Select All, it should filter for 2-point vectors (lines), etc

function addMergedLines() {

  // var lines = []
  var toolpath = new THREE.Group();


  for (i = 0; i < objectsInScene.length; i++) {
    var obj = objectsInScene[i];
    obj.traverse(function(child) {
      if (child.userData.selected) {
        var copy = child.clone()
        //console.log("copy:", copy)
        if (copy.geometry.vertices.length < 3) {
          copy.userData.closed = false
        } else if (copy.geometry.vertices.length > 2) {
          var d = distanceFormula(copy.geometry.vertices[0].x, copy.geometry.vertices[copy.geometry.vertices.length - 1].x, copy.geometry.vertices[0].y, copy.geometry.vertices[copy.geometry.vertices.length - 1].y)
          console.log(d)
          if (d < 0.1) {
            copy.userData.closed = true
          } else {
            copy.userData.closed = false
          }
        }
        copy.position.copy(obj.position);
        toolpath.add(copy);
        // lines.push(copy)
      }
    });
  };


  // get it as Clipper paths
  var newClipperPaths = getClipperPaths(toolpath);
  console.log(JSON.stringify(newClipperPaths))
  var sortedPaths = sortClipperPaths(newClipperPaths)
  console.log(JSON.stringify(sortedPaths))

  var fileObject = new THREE.Group();
  // Create a new geometry
  var mergedGeometry = new THREE.Geometry();

  sortedPaths.forEach(function(coord) {
    mergedGeometry.vertices.push(new THREE.Vector3(coord.X, coord.Y, 0));
  });
  // add geometry


  var material = new THREE.MeshBasicMaterial({
    color: 0xffff00,
    side: THREE.DoubleSide
  });
  var mergedPath = new THREE.Line(mergedGeometry, material);
  mergedPath.name = "Merged Lines"
  fileObject.add(mergedPath);
  fileObject.name = "Merged Lines" + Math.random()

  objectsInScene.push(fileObject)
  setTimeout(function() {
    fillTree();
    changePositionToGeoTranslate();
    resetView();
  }, 250);
}

// function sortClipperPath(clipperPath) {
//   // Create a map to store the starting and ending points of each segment
//   const startPoints = new Map();
//   const endPoints = new Map();
//
//   // Iterate through each segment and store their start and end points
//   clipperPath.forEach(segment => {
//     console.log(segment)
//     const startPoint = segment[0];
//     const endPoint = segment[1];
//
//     const startPointKey = `${startPoint.X},${startPoint.Y}`;
//     const endPointKey = `${endPoint.X},${endPoint.Y}`;
//
//     // Store start and end points in respective maps
//     if (!startPoints.has(startPointKey)) {
//       startPoints.set(startPointKey, segment);
//     }
//     if (!endPoints.has(endPointKey)) {
//       endPoints.set(endPointKey, segment);
//     }
//   });
//
//   // Reorder the segments to form a continuous path
//   const sortedPath = [];
//   let currentSegment = clipperPath[0];
//   sortedPath.push(currentSegment);
//   clipperPath.splice(0, 1); // Remove the first segment from the original array
//
//   while (clipperPath.length > 0) {
//     const endPoint = currentSegment[1];
//     const endPointKey = `${endPoint.X},${endPoint.Y}`;
//
//     // Find the next segment whose start point matches the current segment's end point
//     const nextSegment = startPoints.get(endPointKey);
//
//     // If next segment is found, add it to the sorted path and remove it from the original array
//     if (nextSegment) {
//       sortedPath.push(nextSegment);
//       clipperPath.splice(clipperPath.indexOf(nextSegment), 1);
//       currentSegment = nextSegment;
//     } else {
//       // If no next segment is found, break the loop
//       break;
//     }
//   }
//
//   // Flatten the sorted path into a single array
//   const flattenedPath = sortedPath.reduce((acc, segment) => {
//     acc.push(segment[0], segment[1]);
//     return acc;
//   }, []);
//
//   return flattenedPath;
// }

// function sortClipperPath(clipperPath, threshold = 0.1) {
//   // Create a map to store the starting and ending points of each segment
//   const startPoints = new Map();
//   const endPoints = new Map();
//
//   // Helper function to check if two points are approximately equal within the threshold
//   const arePointsApproximatelyEqual = (point1, point2) => {
//     return Math.abs(point1.X - point2.X) < threshold && Math.abs(point1.Y - point2.Y) < threshold;
//   };
//
//   // Iterate through each segment and store their start and end points
//   clipperPath.forEach(segment => {
//     const startPoint = segment[0];
//     const endPoint = segment[1];
//
//     const startPointKey = `${startPoint.X},${startPoint.Y}`;
//     const endPointKey = `${endPoint.X},${endPoint.Y}`;
//
//     // Store start and end points in respective maps
//     if (!startPoints.has(startPointKey)) {
//       startPoints.set(startPointKey, segment);
//     }
//     if (!endPoints.has(endPointKey)) {
//       endPoints.set(endPointKey, segment);
//     }
//   });
//
//   // Reorder the segments to form a continuous path
//   const sortedPath = [];
//   let currentSegment = clipperPath[0];
//   sortedPath.push(currentSegment);
//   clipperPath.splice(0, 1); // Remove the first segment from the original array
//
//   while (clipperPath.length > 0) {
//     const endPoint = currentSegment[1];
//     const endPointKey = `${endPoint.X},${endPoint.Y}`;
//
//     // Find the next segment whose start point approximately matches the current segment's end point
//     let nextSegment = null;
//     for (const [key, segment] of startPoints) {
//       const startPoint = segment[0];
//       if (arePointsApproximatelyEqual(startPoint, endPoint)) {
//         nextSegment = segment;
//         break;
//       }
//     }
//
//     // If next segment is found, add it to the sorted path and remove it from the original array
//     if (nextSegment) {
//       sortedPath.push(nextSegment);
//       clipperPath.splice(clipperPath.indexOf(nextSegment), 1);
//       currentSegment = nextSegment;
//     } else {
//       // If no next segment is found, break the loop
//       break;
//     }
//   }
//
//   // Flatten the sorted path into a single array
//   const flattenedPath = sortedPath.reduce((acc, segment) => {
//     acc.push(segment[0], segment[1]);
//     return acc;
//   }, []);
//
//   return flattenedPath;
// }

function sortClipperPaths(clipperPaths, threshold = 0.1) {
  // Create a map to store the starting and ending points of each segment
  const startPoints = new Map();
  const endPoints = new Map();

  // Helper function to check if two points are approximately equal within the threshold
  const arePointsApproximatelyEqual = (point1, point2) => {
    return point1 && point2 && Math.abs(point1.X - point2.X) < threshold && Math.abs(point1.Y - point2.Y) < threshold;
  };

  // Populate startPoints and endPoints maps for all segments
  clipperPaths.forEach(path => {
    path.forEach(segment => {
      const startPoint = segment[0];
      const endPoint = segment[1];

      const startPointKey = startPoint ? `${startPoint.X},${startPoint.Y}` : null;
      const endPointKey = endPoint ? `${endPoint.X},${endPoint.Y}` : null;

      // Store start and end points in respective maps
      if (startPointKey && !startPoints.has(startPointKey)) {
        startPoints.set(startPointKey, segment);
      }
      if (endPointKey && !endPoints.has(endPointKey)) {
        endPoints.set(endPointKey, segment);
      }
    });
  });

  // Reorder the segments to form continuous paths
  const sortedPaths = [];

  // Function to find the closest unmatched point
  const findClosestUnmatchedPoint = (point, pointsMap, usedSegments) => {
    let closestDistance = Infinity;
    let closestSegment = null;

    for (const [key, segment] of pointsMap) {
      if (!usedSegments.has(segment)) {
        const startPoint = segment[0];
        if (!startPoint) continue; // Skip if startPoint is undefined
        const distance = Math.sqrt(Math.pow(startPoint.X - point.X, 2) + Math.pow(startPoint.Y - point.Y, 2));
        if (distance < closestDistance) {
          closestDistance = distance;
          closestSegment = segment;
        }
      }
    }
    return closestSegment;
  };

  // Iterate through each path
  clipperPaths.forEach(path => {
    const usedSegments = new Set(); // Tracks used segments in the current path
    const sortedPath = [];

    let currentSegment = path[0];
    sortedPath.push(currentSegment);
    usedSegments.add(currentSegment);

    // Process each segment in the path
    while (sortedPath.length < path.length) {
      const endPoint = currentSegment[1];
      if (!endPoint) break; // Exit loop if endPoint is undefined
      const endPointKey = `${endPoint.X},${endPoint.Y}`;

      // Find the next segment whose start point approximately matches the current segment's end point
      let nextSegment = null;
      if (startPoints.has(endPointKey)) {
        nextSegment = startPoints.get(endPointKey);
      } else {
        // If no exact match found, find the closest unmatched point
        nextSegment = findClosestUnmatchedPoint(endPoint, startPoints, usedSegments);
      }

      // If next segment is found, add it to the sorted path
      if (nextSegment) {
        sortedPath.push(nextSegment);
        usedSegments.add(nextSegment);
        currentSegment = nextSegment;
      } else {
        // If no next segment is found, break the loop
        break;
      }
    }

    sortedPaths.push(sortedPath);
  });

  // Flatten the sorted paths into single arrays
  const flattenedPaths = sortedPaths.map(path => {
    return path.reduce((acc, segment) => {
      acc.push(segment[0], segment[1]);
      return acc;
    }, []);
  });

  return flattenedPaths;
}


function tryFixGeometry(object) {
  getClipperPaths(object)
  console.log("Clipper Path", JSON.stringify(clipperPaths));
  var sortedPaths = sortClipperPath(clipperPaths)
  console.log("Clipper Path", JSON.stringify(sortedPaths));
  return sortedPaths
}

function getClipperPaths(object) {
  object.updateMatrix();
  var grp = object;
  var clipperPaths = [];
  grp.traverse(function(child) {
    // console.log('Traverse: ', child)
    if (child.name == "inflatedGroup") {
      console.log("this is the inflated path from a previous run. ignore.");
      return;
    } else if (child.type == "Line") {
      // let's inflate the path for this line. it may not be closed
      // so we need to check that.
      var clipperArr = [];
      // Fix world Coordinates
      for (j = 0; j < child.geometry.vertices.length; j++) {
        var localPt = child.geometry.vertices[j];
        var worldPt = child.localToWorld(localPt.clone());
        var xpos = worldPt.x; // + (sizexmax /2);
        var ypos = worldPt.y; // + (sizeymax /2);

        var xpos_offset = (parseFloat(child.position.x.toFixed(3)));
        var ypos_offset = (parseFloat(child.position.y.toFixed(3)));

        if (child.geometry.type == "CircleGeometry") {
          xpos = (xpos + xpos_offset);
          ypos = (ypos + ypos_offset);
        }
        clipperArr.push({
          X: xpos,
          Y: ypos
        });
      }
      clipperPaths.push(clipperArr);
    } else {
      // console.log("type of ", child.type, " being skipped");
    }
  });
  return clipperPaths
}