@jgphilpott/polytree 0.0.9 → 0.1.1

package/polytree.bundle.js

@@ -309,7 +309,7 @@ if (typeof module !== 'undefined' && module.exports) {
 // === BUFFER UTILITIES ===
 
 // Simple LRU cache for intersection results to improve performance.
-var calculateWindingNumberFromBuffer, checkMemoryUsage, clearGeometryCache, clearIntersectionCache, createIntersectionCacheKey, createVector2Buffer, createVector3Buffer, disposePolytreeResources, extractCoordinatesFromArray, geometryCache, geometryCacheKeys, handleIntersectingPolytrees, intersectionCache, intersectionCacheKeys, operationCounter, prepareTriangleBufferFromPolygons, roundPointCoordinates, sortRaycastIntersectionsByDistance, splitPolygonByPlane, splitPolygonVertexArray, testPolygonInsideUsingWindingNumber, testRayTriangleIntersection;
+var calculateWindingNumberFromBuffer, checkMemoryUsage, clearGeometryCache, clearIntersectionCache, createIntersectionCacheKey, createVector2Buffer, createVector3Buffer, disposePolytreeResources, extractCoordinatesFromArray, geometryCache, geometryCacheKeys, handleIntersectingPolytrees, intersectionCache, intersectionCacheKeys, operationCounter, prepareTriangleBufferFromPolygons, roundPointCoordinates, signedVolumeOfTriangle, sortRaycastIntersectionsByDistance, splitPolygonByPlane, splitPolygonVertexArray, testPolygonInsideUsingWindingNumber, testRayTriangleIntersection;
 
 intersectionCache = new Map();
 
@@ -488,29 +488,17 @@ splitPolygonByPlane = function(polygon, plane, result = []) {
   switch (polygonType) {
     case POLYGON_COPLANAR:
       returnPolygon.type = plane.normal.dot(polygon.plane.normal) > 0 ? "coplanar-front" : "coplanar-back";
-      if (DEBUG_VERBOSE_LOGGING) {
-        console.log("Polygon classified as COPLANAR, debug color:", DEBUG_COLOR_COPLANAR.toString(16));
-      }
       result.push(returnPolygon);
       break;
     case POLYGON_FRONT:
       returnPolygon.type = "front";
       result.push(returnPolygon);
-      if (DEBUG_VERBOSE_LOGGING) {
-        console.log("Polygon classified as FRONT, debug color:", DEBUG_COLOR_FRONT.toString(16));
-      }
       break;
     case POLYGON_BACK:
       returnPolygon.type = "back";
       result.push(returnPolygon);
-      if (DEBUG_VERBOSE_LOGGING) {
-        console.log("Polygon classified as BACK, debug color:", DEBUG_COLOR_BACK.toString(16));
-      }
       break;
     case POLYGON_SPANNING:
-      if (DEBUG_VERBOSE_LOGGING) {
-        console.log("Polygon classified as SPANNING, debug color:", DEBUG_COLOR_SPANNING.toString(16));
-      }
       frontVertices = [];
       backVertices = [];
 // Process each edge to build front and back vertex lists.
@@ -719,10 +707,7 @@ prepareTriangleBufferFromPolygons = function(polygonArray) {
 
 // @return Vector3 intersection point or null if no intersection.
 testRayTriangleIntersection = function(ray, triangle, targetVector = new Vector3()) {
-  var determinant, firstBarycentricCoordinate, intersectionDistance, inverseDeterminant, result, secondBarycentricCoordinate;
-  if (DEBUG_VERBOSE_LOGGING) {
-    console.log("Testing ray-triangle intersection with ray origin:", ray.origin, "direction:", ray.direction);
-  }
+  var determinant, firstBarycentricCoordinate, intersectionDistance, inverseDeterminant, secondBarycentricCoordinate;
   // Calculate triangle edge vectors.
   rayTriangleEdge1.subVectors(triangle.b, triangle.a);
   rayTriangleEdge2.subVectors(triangle.c, triangle.a);
@@ -750,19 +735,7 @@ testRayTriangleIntersection = function(ray, triangle, targetVector = new Vector3
   intersectionDistance = inverseDeterminant * rayTriangleEdge2.dot(rayTriangleQVector);
   // Check if intersection is in front of ray origin.
   if (intersectionDistance > RAY_INTERSECTION_EPSILON) {
-    result = targetVector.copy(ray.direction).multiplyScalar(intersectionDistance).add(ray.origin);
-    if (DEBUG_INTERSECTION_VERIFICATION) {
-      console.log("Ray-triangle intersection verified:", {
-        distance: intersectionDistance,
-        point: result,
-        triangle: {
-          a: triangle.a,
-          b: triangle.b,
-          c: triangle.c
-        }
-      });
-    }
-    return result;
+    return targetVector.copy(ray.direction).multiplyScalar(intersectionDistance).add(ray.origin);
   }
   return null;
 };
@@ -777,8 +750,7 @@ testRayTriangleIntersection = function(ray, triangle, targetVector = new Vector3
 // @param polytreeB - Second polytree for intersection processing.
 // @param processBothDirections - Whether to process intersections in both directions.
 handleIntersectingPolytrees = function(polytreeA, polytreeB, processBothDirections = true) {
-  var endTime, polytreeABuffer, polytreeBBuffer, startTime;
-  startTime = DEBUG_PERFORMANCE_TIMING ? performance.now() : 0;
+  var polytreeABuffer, polytreeBBuffer;
   operationCounter++; // Increment operation counter and check for GC threshold.
   if (operationCounter >= GARBAGE_COLLECTION_THRESHOLD) {
     operationCounter = 0;
@@ -806,15 +778,27 @@ handleIntersectingPolytrees = function(polytreeA, polytreeB, processBothDirectio
     polytreeABuffer = void 0;
   }
   if (polytreeBBuffer !== void 0) {
-    polytreeBBuffer = void 0;
-  }
-  if (DEBUG_PERFORMANCE_TIMING) {
-    endTime = performance.now();
-    polytreeBBuffer = void 0;
-    return console.log(`handleIntersectingPolytrees took ${endTime - startTime} milliseconds`);
+    return polytreeBBuffer = void 0;
   }
 };
 
+// Calculate the signed volume of a tetrahedron formed by the origin and three triangle vertices.
+// This is used for volume calculations of 3D geometries by summing the signed volumes of all triangles in the mesh.
+
+// The formula is: V = (1/6) * dot(v1, cross(v2, v3))
+// where v1, v2, v3 are the three vertices of the triangle.
+
+// @param vertex1 - First vertex of the triangle (Vector3).
+// @param vertex2 - Second vertex of the triangle (Vector3).
+// @param vertex3 - Third vertex of the triangle (Vector3).
+
+// @return Signed volume of the tetrahedron formed by origin and the three vertices.
+signedVolumeOfTriangle = function(vertex1, vertex2, vertex3) {
+  // Use temporary vectors to avoid creating new objects
+  temporaryVector3Primary.copy(vertex2).cross(vertex3);
+  return vertex1.dot(temporaryVector3Primary) / 6.0;
+};
+
 // Dispose of polytree resources to prevent memory leaks.
 // This utility safely calls the delete method on polytree instances
 // if the disposal feature is enabled in the Polytree configuration.
@@ -2390,6 +2374,533 @@ Polytree.fromMesh = function(obj, objectIndex, polytree = new Polytree(), buildT
   }
   return polytree;
 };
+
+// Calculate the surface area of a Three.js mesh or geometry.
+// This method extracts triangles from the geometry and sums their areas using Three.js Triangle.getArea().
+
+// @param meshOrGeometry - Three.js mesh or BufferGeometry to calculate surface area for.
+
+// @return Total surface area as a number.
+Polytree.getSurface = function(meshOrGeometry) {
+  var geometry, i, index, k, posattr, ref, surface, triangle, v1, v1Index, v2, v2Index, v3, v3Index;
+  surface = 0;
+  if (!meshOrGeometry) {
+    throw new Error("Input is required.");
+  }
+  // Extract geometry from mesh if needed.
+  geometry = meshOrGeometry.geometry ? meshOrGeometry.geometry : meshOrGeometry;
+  if (!(geometry && geometry.attributes)) {
+    throw new Error("No geometry found.");
+  }
+  posattr = geometry.attributes.position; // Extract position and index attributes.
+  if (!posattr) {
+    throw new Error("Geometry has no position attribute.");
+  }
+  // Generate index array (explicit or implicit).
+  index = geometry.index ? geometry.index.array : Array((posattr.array.length / posattr.itemSize) | 0).fill().map(function(_, i) {
+    return i;
+  });
+// Process each triangle in the geometry.
+  for (i = k = 0, ref = index.length; k < ref; i = k += 3) {
+    // Extract triangle vertices.
+    v1Index = index[i + 0] * 3;
+    v2Index = index[i + 1] * 3;
+    v3Index = index[i + 2] * 3;
+    v1 = new Vector3(posattr.array[v1Index], posattr.array[v1Index + 1], posattr.array[v1Index + 2]);
+    v2 = new Vector3(posattr.array[v2Index], posattr.array[v2Index + 1], posattr.array[v2Index + 2]);
+    v3 = new Vector3(posattr.array[v3Index], posattr.array[v3Index + 1], posattr.array[v3Index + 2]);
+    // Create triangle and add its area to the total surface area.
+    triangle = new Triangle(v1, v2, v3);
+    surface += triangle.getArea();
+  }
+  return surface;
+};
+
+// Instance method: Calculate the surface area of a mesh or geometry.
+// Usage: polytree.getSurface(meshOrGeometry)
+Polytree.prototype.getSurface = function(meshOrGeometry) {
+  return Polytree.getSurface(meshOrGeometry);
+};
+
+// Calculate the volume of a 3D geometry using the divergence theorem.
+// This method accepts either a Three.js Mesh or BufferGeometry and returns
+// the total volume by summing the signed volumes of all triangular faces.
+
+// @param input - Either a Three.js Mesh object or BufferGeometry to calculate volume for.
+
+// @return The volume of the geometry as a number.
+Polytree.getVolume = function(input) {
+  var bufferGeometry, face, faces, geometry, index, k, l, position, ref, ref1, v1, v2, v3, volume;
+  volume = 0;
+  v1 = new Vector3();
+  v2 = new Vector3();
+  v3 = new Vector3();
+  // Handle different input types.
+  geometry = null;
+  if (input.isMesh) {
+    geometry = input.geometry;
+  } else if (input.isBufferGeometry) {
+    geometry = input;
+  } else {
+    throw new Error("Input must be a Three.js Mesh or BufferGeometry.");
+  }
+  // Ensure we have a BufferGeometry.
+  bufferGeometry = (typeof geometry.toBuffer === "function" ? geometry.toBuffer() : void 0) || geometry;
+  if (!bufferGeometry.isBufferGeometry) {
+    throw new Error("Unable to convert input to BufferGeometry.");
+  }
+  position = bufferGeometry.attributes.position;
+  if (!position) {
+    return 0; // No position data means no volume.
+  }
+  if (bufferGeometry.index) {
+    // Indexed geometry - use index buffer.
+    index = bufferGeometry.index;
+    faces = index.count / 3;
+    for (face = k = 0, ref = faces; (0 <= ref ? k < ref : k > ref); face = 0 <= ref ? ++k : --k) {
+      v1.fromBufferAttribute(position, index.array[face * 3 + 0]);
+      v2.fromBufferAttribute(position, index.array[face * 3 + 1]);
+      v3.fromBufferAttribute(position, index.array[face * 3 + 2]);
+      volume += signedVolumeOfTriangle(v1, v2, v3);
+    }
+  } else {
+    // Non-indexed geometry - use vertex order directly.
+    faces = position.count / 3;
+    for (face = l = 0, ref1 = faces; (0 <= ref1 ? l < ref1 : l > ref1); face = 0 <= ref1 ? ++l : --l) {
+      v1.fromBufferAttribute(position, face * 3 + 0);
+      v2.fromBufferAttribute(position, face * 3 + 1);
+      v3.fromBufferAttribute(position, face * 3 + 2);
+      volume += signedVolumeOfTriangle(v1, v2, v3);
+    }
+  }
+  return Math.abs(volume); // Return absolute value for total volume.
+};
+
+
+// Instance method: Calculate the volume of a mesh or geometry.
+// Usage: polytree.getVolume(meshOrGeometry)
+Polytree.prototype.getVolume = function(input) {
+  return Polytree.getVolume(input);
+};
+// Generated by CoffeeScript 2.7.0
+// Spatial query utilities for enhanced Polytree functionality.
+// These methods provide advanced spatial querying capabilities useful for 3D printing,
+// CAD operations, and general-purpose geometric analysis beyond basic CSG.
+
+// Inspired by three-mesh-bvh spatial query capabilities.
+
+// Helper function to convert various input types to polytree.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance.
+
+// @return Object with polytree and shouldCleanup flag, or null if invalid input.
+var convertToPolytree;
+
+convertToPolytree = function(input) {
+  var tempMaterial, tempMesh;
+  if (!input) {
+    return null;
+  }
+  if (input.isPolytree) {
+    return {
+      polytree: input,
+      shouldCleanup: false
+    };
+  } else if (input.isMesh) {
+    return {
+      polytree: Polytree.fromMesh(input),
+      shouldCleanup: true
+    };
+  } else if (input.isBufferGeometry) {
+    // Create a temporary mesh from BufferGeometry.
+    // Use a simple material object instead of MeshBasicMaterial constructor.
+    tempMaterial = {
+      isMaterial: true,
+      type: "MeshBasicMaterial"
+    };
+    tempMesh = new Mesh(input, tempMaterial);
+    return {
+      polytree: Polytree.fromMesh(tempMesh),
+      shouldCleanup: true
+    };
+  } else {
+    return null;
+  }
+};
+
+// Find the closest point on any triangle surface to the given point.
+// This is essential for collision detection, mesh repair, and support structure generation.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to query.
+// @param targetPoint - Vector3 point to find closest point to.
+// @param target - Optional object to store result data.
+// @param maxDistance - Maximum search distance (Infinity by default).
+
+// @return Object with point, distance, and triangle properties or null if none found.
+Polytree.closestPointToPoint = function(input, targetPoint, target = {}, maxDistance = 2e308) {
+  var closestDistance, closestPoint, closestTriangle, currentDistance, j, len, polytree, result, shouldCleanup, testTriangle, triangle, trianglePoint, triangles;
+  if (!(input && targetPoint)) {
+    return null;
+  }
+  // Handle different input types - convert to polytree if needed.
+  result = convertToPolytree(input);
+  if (!result) {
+    return null;
+  }
+  ({polytree, shouldCleanup} = result);
+  closestDistance = maxDistance;
+  closestPoint = null;
+  closestTriangle = null;
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    // Create temporary triangle for calculations.
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    // Calculate closest point on triangle to target point.
+    trianglePoint = new Vector3();
+    testTriangle.closestPointToPoint(targetPoint, trianglePoint);
+    // Calculate distance to this point.
+    currentDistance = trianglePoint.distanceTo(targetPoint);
+    if (currentDistance < closestDistance) {
+      closestDistance = currentDistance;
+      closestPoint = trianglePoint.clone();
+      closestTriangle = triangle;
+    }
+  }
+  if (closestPoint) {
+    target.point = closestPoint;
+    target.distance = closestDistance;
+    target.triangle = closestTriangle;
+    // Clean up temporary polytree if created.
+    shouldCleanup && polytree.delete();
+    return target;
+  }
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return null;
+};
+
+// Calculate the shortest distance from a point to any surface in the geometry.
+// Useful for distance field generation and proximity analysis.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to query.
+// @param targetPoint - Vector3 point to calculate distance to.
+
+// @return Distance value as number, or Infinity if no surfaces found.
+Polytree.distanceToPoint = function(input, targetPoint) {
+  var result;
+  result = Polytree.closestPointToPoint(input, targetPoint);
+  return (result != null ? result.distance : void 0) || 2e308;
+};
+
+// Test if a sphere intersects with the geometry.
+// Useful for collision detection and proximity testing.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to test against.
+// @param sphere - Sphere object with center and radius properties.
+
+// @return Boolean indicating intersection.
+Polytree.intersectsSphere = function(input, sphere) {
+  var closestPoint, distance, j, len, polytree, result, shouldCleanup, testTriangle, triangle, triangles;
+  if (!(input && sphere)) {
+    return false;
+  }
+  // Handle different input types - convert to polytree if needed.
+  result = convertToPolytree(input);
+  if (!result) {
+    return false;
+  }
+  ({polytree, shouldCleanup} = result);
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    // Simple sphere-triangle intersection: check if sphere center is close to triangle.
+    closestPoint = new Vector3();
+    testTriangle.closestPointToPoint(sphere.center, closestPoint);
+    distance = closestPoint.distanceTo(sphere.center);
+    if (distance <= sphere.radius) {
+      // Clean up temporary polytree if created.
+      shouldCleanup && polytree.delete();
+      return true;
+    }
+  }
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return false;
+};
+
+// Test if a bounding box intersects with the geometry.
+// Useful for broad-phase collision detection and spatial partitioning.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to test against.
+// @param boundingBox - Box3 object defining the bounding volume.
+
+// @return Boolean indicating intersection.
+Polytree.intersectsBox = function(input, boundingBox) {
+  var j, len, polytree, result, shouldCleanup, testTriangle, triangle, triangles;
+  if (!(input && boundingBox)) {
+    return false;
+  }
+  // Handle different input types - convert to polytree if needed.
+  result = convertToPolytree(input);
+  if (!result) {
+    return false;
+  }
+  ({polytree, shouldCleanup} = result);
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    if (boundingBox.intersectsTriangle(testTriangle)) {
+      // Clean up temporary polytree if created.
+      shouldCleanup && polytree.delete();
+      return true;
+    }
+  }
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return false;
+};
+
+// Find all intersection points between a plane and the mesh surface.
+// This is the core functionality needed for 3D printing slicing operations.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to slice.
+// @param plane - Plane object defining the slicing plane.
+// @param target - Optional array to store intersection line segments.
+
+// @return Array of Line3 objects representing intersection segments.
+Polytree.intersectPlane = function(input, plane, target = []) {
+  var edge, endDist, endPoint, intersectionPoint, intersectionPoints, j, k, len, len1, polytree, result, shouldCleanup, startDist, startPoint, t, testTriangle, triangle, triangleEdges, triangles;
+  if (!(input && plane)) {
+    return target;
+  }
+  // Handle different input types - convert to polytree if needed.
+  result = convertToPolytree(input);
+  if (!result) {
+    return target;
+  }
+  ({polytree, shouldCleanup} = result);
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    intersectionPoints = [];
+    // Test each edge of the triangle against the plane.
+    triangleEdges = [[triangle.a, triangle.b], [triangle.b, triangle.c], [triangle.c, triangle.a]];
+    for (k = 0, len1 = triangleEdges.length; k < len1; k++) {
+      edge = triangleEdges[k];
+      startPoint = edge[0];
+      endPoint = edge[1];
+      // Calculate distances to plane manually (since bundle context may not have plane methods).
+      // Distance = normal.dot(point) + constant
+      startDist = plane.normal.dot(startPoint) + plane.constant;
+      endDist = plane.normal.dot(endPoint) + plane.constant;
+      // Check if edge crosses the plane (different signs).
+      if ((startDist * endDist) < 0) {
+        // Calculate intersection point using linear interpolation.
+        t = startDist / (startDist - endDist);
+        intersectionPoint = new Vector3();
+        intersectionPoint.lerpVectors(startPoint, endPoint, t);
+        intersectionPoints.push(intersectionPoint);
+      }
+    }
+    // If we have exactly 2 intersection points, create a line segment.
+    if (intersectionPoints.length === 2) {
+      target.push(new Line3(intersectionPoints[0], intersectionPoints[1]));
+    }
+  }
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return target;
+};
+
+// Create a series of parallel plane intersections for layer-by-layer slicing.
+// Essential for 3D printing applications where the model needs to be sliced
+// into horizontal layers at regular intervals.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to slice.
+// @param layerHeight - Height between each slice layer.
+// @param minZ - Starting Z coordinate for slicing.
+// @param maxZ - Ending Z coordinate for slicing.
+// @param normal - Optional plane normal vector (defaults to Z-up).
+
+// @return Array of arrays, each containing Line3 segments for that layer.
+Polytree.sliceIntoLayers = function(input, layerHeight, minZ, maxZ, normal = new Vector3(0, 0, 1)) {
+  var currentZ, edge, endDist, endPoint, intersectionPoint, intersectionPoints, j, k, layerSegments, layers, len, len1, planeConstant, planeNormal, polytree, result, shouldCleanup, startDist, startPoint, t, triangle, triangleEdges, triangles;
+  if (!(input && layerHeight > 0 && minZ < maxZ)) {
+    return [];
+  }
+  // Convert input to polytree once at the beginning.
+  result = convertToPolytree(input);
+  if (!result) {
+    return [];
+  }
+  ({polytree, shouldCleanup} = result);
+  layers = [];
+  currentZ = minZ;
+  while (currentZ <= maxZ) {
+    // Create plane at current height using manual plane equation.
+    // Since bundle context may not have proper Plane constructor access.
+    planeNormal = normal.clone();
+    planeConstant = -currentZ;
+    // Use manual plane-triangle intersection instead of Plane object.
+    layerSegments = [];
+    triangles = polytree.getTriangles();
+    for (j = 0, len = triangles.length; j < len; j++) {
+      triangle = triangles[j];
+      intersectionPoints = [];
+      // Test each edge of the triangle against the plane.
+      triangleEdges = [[triangle.a, triangle.b], [triangle.b, triangle.c], [triangle.c, triangle.a]];
+      for (k = 0, len1 = triangleEdges.length; k < len1; k++) {
+        edge = triangleEdges[k];
+        startPoint = edge[0];
+        endPoint = edge[1];
+        // Calculate distances to plane manually.
+        startDist = planeNormal.dot(startPoint) + planeConstant;
+        endDist = planeNormal.dot(endPoint) + planeConstant;
+        // Check if edge crosses the plane (different signs).
+        if ((startDist * endDist) < 0) {
+          // Calculate intersection point using linear interpolation.
+          t = startDist / (startDist - endDist);
+          intersectionPoint = new Vector3();
+          intersectionPoint.lerpVectors(startPoint, endPoint, t);
+          intersectionPoints.push(intersectionPoint);
+        }
+      }
+      // If we have exactly 2 intersection points, create a line segment.
+      if (intersectionPoints.length === 2) {
+        layerSegments.push(new Line3(intersectionPoints[0], intersectionPoints[1]));
+      }
+    }
+    layers.push(layerSegments);
+    currentZ += layerHeight;
+  }
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return layers;
+};
+
+// Perform a generic spatial query using a custom callback function.
+// This provides flexibility for implementing custom spatial operations.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to query.
+// @param queryCallback - Function that tests each triangle and returns boolean.
+// @param collectCallback - Optional function to collect/process matching triangles.
+
+// @return Array of results from collectCallback, or array of matching triangles.
+Polytree.shapecast = function(input, queryCallback, collectCallback = null) {
+  var j, len, polytree, result, results, shouldCleanup, testTriangle, triangle, triangles;
+  if (!(input && queryCallback)) {
+    return [];
+  }
+  // Handle different input types - convert to polytree if needed.
+  result = convertToPolytree(input);
+  if (!result) {
+    return [];
+  }
+  ({polytree, shouldCleanup} = result);
+  results = [];
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    if (queryCallback(testTriangle, triangle)) {
+      if (collectCallback) {
+        result = collectCallback(testTriangle, triangle);
+        if (result != null) {
+          results.push(result);
+        }
+      } else {
+        results.push(triangle);
+      }
+    }
+  }
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return results;
+};
+
+// Find all triangles within a specified distance of a target point.
+// Useful for local mesh operations and region-based analysis.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to search.
+// @param targetPoint - Vector3 center point for the search.
+// @param searchRadius - Maximum distance from point to include triangles.
+
+// @return Array of triangles within the search radius.
+Polytree.getTrianglesNearPoint = function(input, targetPoint, searchRadius) {
+  if (!(input && targetPoint && searchRadius > 0)) {
+    return [];
+  }
+  return Polytree.shapecast(input, function(testTriangle, originalTriangle) {
+    // Check if any vertex of the triangle is within the search radius.
+    return testTriangle.a.distanceTo(targetPoint) <= searchRadius || testTriangle.b.distanceTo(targetPoint) <= searchRadius || testTriangle.c.distanceTo(targetPoint) <= searchRadius;
+  });
+};
+
+// Calculate approximate volume using monte carlo sampling.
+// Useful for complex geometries where analytical volume calculation is difficult.
+
+// @param input - Three.js Mesh, BufferGeometry, or Polytree instance to analyze.
+// @param sampleCount - Number of random samples to use (default 10000).
+// @param boundingBox - Optional bounding box for sampling region.
+
+// @return Estimated volume as number.
+Polytree.estimateVolumeViaSampling = function(input, sampleCount = 10000, boundingBox = null) {
+  var boxSize, boxVolume, i, identityMatrix, insideCount, intersections, j, k, len, polytree, ref, result, samplePoint, shouldCleanup, testRay, triangle, triangles, volumeRatio;
+  if (!input) {
+    return 0;
+  }
+  // Handle different input types - convert to polytree if needed.
+  result = convertToPolytree(input);
+  if (!result) {
+    return 0;
+  }
+  ({polytree, shouldCleanup} = result);
+  // Use polytree bounding box if none provided.
+  if (!boundingBox) {
+    boundingBox = new Box3();
+    triangles = polytree.getTriangles();
+    for (j = 0, len = triangles.length; j < len; j++) {
+      triangle = triangles[j];
+      boundingBox.expandByPoint(triangle.a);
+      boundingBox.expandByPoint(triangle.b);
+      boundingBox.expandByPoint(triangle.c);
+    }
+  }
+  // Calculate bounding box volume for scaling.
+  boxSize = new Vector3();
+  boundingBox.getSize(boxSize);
+  boxVolume = boxSize.x * boxSize.y * boxSize.z;
+  if (boxVolume === 0) {
+    return 0;
+  }
+  insideCount = 0;
+// Test random points inside bounding box.
+  for (i = k = 0, ref = sampleCount; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    // Generate random point in bounding box.
+    samplePoint = new Vector3(boundingBox.min.x + Math.random() * boxSize.x, boundingBox.min.y + Math.random() * boxSize.y, boundingBox.min.z + Math.random() * boxSize.z);
+    // Test if point is inside the mesh using ray casting.
+    testRay = new Ray(samplePoint, new Vector3(1, 0, 0));
+    // Create a simple identity matrix manually to avoid Three.js import issues.
+    identityMatrix = {
+      elements: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+      isMatrix4: true
+    };
+    intersections = polytree.rayIntersect(testRay, identityMatrix);
+    if (intersections.length % 2 === 1) {
+      // Point is inside if odd number of intersections.
+      insideCount++;
+    }
+  }
+  // Calculate volume ratio and scale by bounding box volume.
+  volumeRatio = insideCount / sampleCount;
+  // Clean up temporary polytree if created.
+  shouldCleanup && polytree.delete();
+  return volumeRatio * boxVolume;
+};
 // Generated by CoffeeScript 2.7.0
 // ============================================================================
 // Unite CSG Operation for Polytree
@@ -3671,9 +4182,6 @@ Notes:
 var constructIntersection, intersectionTestEdge2D, intersectionTestVertex2D, isUniqueTriangle, isValidTriangle, pointInTriangleInclusive2D, pointOnSegmentInclusive2D, pointsEqual2D, resolveCoplanarTriangleIntersection, resolveTriangleIntersection, triangleIntersectionCCW2D, triangleIntersectsTriangle, triangleOrientation2D, trianglesOverlap2D;
 
 isValidTriangle = function(triangle) {
-  if (DEBUG_GEOMETRY_VALIDATION) {
-    console.log("Validating triangle:", triangle.a, triangle.b, triangle.c);
-  }
   if (triangle.a.equals(triangle.b)) {
     return false;
   }
@@ -3683,9 +4191,6 @@ isValidTriangle = function(triangle) {
   if (triangle.b.equals(triangle.c)) {
     return false;
   }
-  if (DEBUG_GEOMETRY_VALIDATION) {
-    console.log("Triangle validation passed.");
-  }
   return true;
 };
 
@@ -4412,3 +4917,7 @@ module.exports.intersectionTestVertex2D = intersectionTestVertex2D;
 // === INTERSECTION CONSTRUCTION ===
 // Low-level intersection construction utilities for building intersection results.
 module.exports.constructIntersection = constructIntersection;
+
+// === VOLUME CALCULATION UTILITIES ===
+// Helper functions for calculating volumes of 3D geometries.
+module.exports.signedVolumeOfTriangle = signedVolumeOfTriangle;