Three.js 剖切面后的点编组

我找到了物体和平面之间的所有交点，就像在这张大图中一样。但是现在我想把这些点连接起来（分成单独的阵列），在平面经过的地方，再把它们连接起来。我试图通过距离将它们连接起来，但这并没有产生有效的效果

//SORT POINTS DISTANCE
var pointsArray = []; //point after intersection
var sortedPoints = [];
var sortedPointsDis = [];

sortedPoints.push( pointsArray.pop() );

while( pointsArray.length ) {
  var distance = sortedPoints[sortedPoints.length - 1].distanceTo( pointsArray[0] );
  var index = 0;
  for(var i = 1; i < pointsArray.length; i++) {
      var tempDistance = sortedPoints[sortedPoints.length - 1].distanceTo( pointsArray[i] );
      if( tempDistance < distance ) {
          distance = tempDistance;
          index = i;
      }
  }
  sortedPoints.push( pointsArray.splice(index, 1)[0] );
  sortedPointsDis.push( distance );
 }

 //GROUP POINTS
 var result = [[]];

 for(var i = 0; i < sortedPoints.length; i++) {
  var lastArr = result[result.length - 1];
  if( lastArr.length < 3 ) {
      lastArr.push( sortedPoints[i] );
  } else {
      var distance = lastArr[0].distanceTo( sortedPoints[i] );
      if( distance < sortedPointsDis[i - 1] ) {
          result.push([]);
          lastArr = result[result.length - 1];
      }
      lastArr.push(sortedPoints[i]);
  }
}

//排序点距离
var pointsArray=[]//交叉点后的点
var分类点数=[]；
var sortedPointsDis=[]；
sortedPoints.push（pointsArray.pop（））；
while（pointsArray.length）{
var distance=sortedPoints[sortedPoints.length-1].distanceTo（pointsArray[0]）；
var指数=0；
对于（变量i=1；i

。

---

思想？例子？提前感谢您的回复

所以，是的，这个答案基于并扩展了它。解决方案比较粗糙，可以进行优化

我使用了修改后的

.equals（）

方法

THREE.Vector3（）

（我希望它（或类似的东西）有一天会成为核心的一部分，因为它是一个非常有用的功能），取自：

如何获取轮廓以及如何绘制轮廓：

var contours = getContours(pointsOfIntersection.vertices, [], true);

contours.forEach(cntr => {
    let cntrGeom = new THREE.Geometry();
    cntrGeom.vertices = cntr;
    let contour = new THREE.Line(cntrGeom, new THREE.LineBasicMaterial({
      color: Math.random() * 0xffffff
    }));
    scene.add(contour);
  });

在哪里

函数获取轮廓（点、轮廓、首次运行）{
log（“firstRun:”，firstRun）；
设等高线=[]；
//找到轮廓的第一条线
设firstPointIndex=0；
设secondPointIndex=0；
让第一点，第二点；
for（设i=0；i{allChecked+=p.checked==true？1:0；}）；
log（“allChecked:，allChecked==points.length”）；
if（allChecked！=points.length）{返回getContours（points，contours，false）；}
回归等值线；
}
函数getContour（当前点、点、轮廓）{
设p1Index=getNearestPointIndex（当前点，点）；
设p1=点[p1Index]；
p1.checked=true；
设p2Index=getPairIndex（p1，p1Index，点）；
设p2=点[p2Index]；
p2.checked=true；
设isClosed=p2。等于（轮廓[0]，公差）；
如果（！isClosed）{
contour.push（p2.clone（））；
返回getContour（p2，点，轮廓）；
}否则{
contour.push（contour[0].clone（））；
回归曲线；
}
}
函数getNearestPointIndex（点，点）{
设指数=0；
for（设i=0；i

---

示例r87。

酷。非常感谢你！由于这是一次计算，在加载时，我认为这是一个很好的解决方案和很好的解释^^这对我来说是可行的。再次感谢。

function setPointOfIntersection(line, plane, faceIdx) {
  pointOfIntersection = plane.intersectLine(line);
  if (pointOfIntersection) {
    let p = pointOfIntersection.clone();
    p.faceIndex = faceIdx;
    p.checked = false;
    pointsOfIntersection.vertices.push(p);
  };
}

var contours = getContours(pointsOfIntersection.vertices, [], true);

contours.forEach(cntr => {
    let cntrGeom = new THREE.Geometry();
    cntrGeom.vertices = cntr;
    let contour = new THREE.Line(cntrGeom, new THREE.LineBasicMaterial({
      color: Math.random() * 0xffffff
    }));
    scene.add(contour);
  });

function getContours(points, contours, firstRun) {
  console.log("firstRun:", firstRun);

  let contour = [];

  // find first line for the contour
  let firstPointIndex = 0;
  let secondPointIndex = 0;
  let firsPoint, secondPoint;
  for (let i = 0; i < points.length; i++) {
    if (points[i].checked == true) continue;
    firstPointIndex = i;
    firstPoint = points[firstPointIndex];
    firstPoint.checked = true;
    secondPointIndex = getPairIndex(firstPoint, firstPointIndex, points);
    secondPoint = points[secondPointIndex];
    secondPoint.checked = true;
    contour.push(firstPoint.clone());
    contour.push(secondPoint.clone());
    break;
  }

  contour = getContour(secondPoint, points, contour);
  contours.push(contour);
  let allChecked = 0;
  points.forEach(p => { allChecked += p.checked == true ? 1 : 0; });
  console.log("allChecked: ", allChecked == points.length);
  if (allChecked != points.length) { return getContours(points, contours, false); }
  return contours;
}

function getContour(currentPoint, points, contour){
  let p1Index = getNearestPointIndex(currentPoint, points);
  let p1 = points[p1Index];
  p1.checked = true;
  let p2Index = getPairIndex(p1, p1Index, points);
  let p2 = points[p2Index]; 
  p2.checked = true;
  let isClosed = p2.equals(contour[0], tolerance);
  if (!isClosed) {
    contour.push(p2.clone());
    return getContour(p2, points, contour);
  } else {
    contour.push(contour[0].clone());
    return contour;
  }
}

function getNearestPointIndex(point, points){
  let index = 0;
  for (let i = 0; i < points.length; i++){
    let p = points[i];
    if (p.checked == false && p.equals(point, tolerance)){ 
      index = i;
      break;
    }
  }
  return index;
}

function getPairIndex(point, pointIndex, points) {
  let index = 0;
  for (let i = 0; i < points.length; i++) {
    let p = points[i];
    if (i != pointIndex && p.checked == false && p.faceIndex == point.faceIndex) {
      index = i;
      break;
    }
  }
  return index;
}