/**
 * Bin every CPU sample produced by {@link read_atlas_to_samples} into a
 * sparse uniform voxel grid, accumulating position / normal / albedo /
 * ORM weighted by sample count. Empty cells are dropped, so the output
 * size scales with surface coverage, not with grid_resolution^3.
 *
 * Accumulation rules:
 *   - position: simple mean of sample positions in the cell (gives a
 *     slight bias inwards on slanted surfaces but is C0 across cells)
 *   - normal:   vector sum, normalised at output time (handles
 *     multiple-orientation surfaces inside one cell — surfels with
 *     opposing normals cancel, which is what voxel-LOD wants)
 *   - albedo:   simple mean
 *   - ORM:      simple mean per channel
 *
 * Voxel size is computed from the bounding box and the requested grid
 * resolution along the longest axis. Cells are addressed by integer
 * (ix, iy, iz) so two samples in the same cell hash identically.
 *
 * @param {object} params
 * @param {Float32Array} params.samples         interleaved [pos, normal, albedo, orm]
 * @param {number} params.sample_count          number of valid samples in `samples`
 * @param {number[]} params.bounds_min          [x, y, z]
 * @param {number[]} params.bounds_max          [x, y, z]
 * @param {number} params.grid_resolution       cells along the longest axis
 * @returns {{
 *     points: Float32Array,
 *     point_count: number,
 *     voxel_size: number
 * }}
 */
export function voxelize_samples({ samples, sample_count, bounds_min, bounds_max, grid_resolution }: {
    samples: Float32Array;
    sample_count: number;
    bounds_min: number[];
    bounds_max: number[];
    grid_resolution: number;
}): {
    points: Float32Array;
    point_count: number;
    voxel_size: number;
};
//# sourceMappingURL=voxelize_samples.d.ts.map