Function computeNormalizeScale

src/utils/sim3dNormalization.ts:47–99

(
  reconstruction: Reconstruction,
  extent = 10,
  minPercentile = 0.1,
  maxPercentile = 0.9,
  useImages = true
)

 * Reference: colmap/scene/reconstruction.cc Normalize()
 */
export function computeNormalizeScale(
  reconstruction: Reconstruction,
  extent = 10,
  minPercentile = 0.1,
  maxPercentile = 0.9,
  useImages = true
): Sim3d {
  const coordsX: number[] = [];
  const coordsY: number[] = [];
  const coordsZ: number[] = [];

  if (useImages) {
    for (const image of reconstruction.images.values()) {
      const pos = getImageWorldPosition(image);
      coordsX.push(pos.x);
      coordsY.push(pos.y);
      coordsZ.push(pos.z);
    }
  } else if (reconstruction.points3D) {
    for (const point3D of reconstruction.points3D.values()) {
      coordsX.push(point3D.xyz[0]);
      coordsY.push(point3D.xyz[1]);
      coordsZ.push(point3D.xyz[2]);
    }
  }

  if (coordsX.length === 0) {
    return identitySim3d();
  }

  const minX = percentile(coordsX, minPercentile);
  const maxX = percentile(coordsX, maxPercentile);
  const minY = percentile(coordsY, minPercentile);
  const maxY = percentile(coordsY, maxPercentile);
  const minZ = percentile(coordsZ, minPercentile);
  const maxZ = percentile(coordsZ, maxPercentile);

  const centerX = (minX + maxX) / 2;
  const centerY = (minY + maxY) / 2;
  const centerZ = (minZ + maxZ) / 2;

  const diagonal = Math.sqrt(
    Math.pow(maxX - minX, 2) + Math.pow(maxY - minY, 2) + Math.pow(maxZ - minZ, 2)
  );

  const scale = diagonal > 1e-6 ? extent / diagonal : 1;

  return {
    scale,
    rotation: new THREE.Quaternion(),
    translation: new THREE.Vector3(-centerX * scale, -centerY * scale, -centerZ * scale),
  };
}

function percentile(arr: number[], p: number): number {
  const sorted = [...arr].sort((a, b) => a - b);