rayzee 9.4.1 → 9.5.0

package/src/Processor/AtmosphereModel.js

@@ -311,8 +311,7 @@ function transmittanceSpectrum( coefficients, depth ) {
 
 }
 
-// Hestroffer & Magnan 1998: I(µ)/I(1) = µ^α, α = −0.023 + 0.292 / λ[µm], at each primary's centroid.
-export const LIMB_DARKENING_EXPONENT = [ 610, 550, 465 ].map( l => - 0.023 + 0.292 / ( l / 1000 ) );
+export { LIMB_DARKENING_EXPONENT } from './SolarLimb.js';
 
 /** Solid angle of a cone of the given half-angle, without the cancellation `2π(1 − cos)` suffers. */
 export function coneSolidAngle( halfAngle ) {

package/src/Processor/BVHBuilder.js

@@ -1,4 +1,3 @@
-import { TreeletOptimizer } from './TreeletOptimizer.js';
 import { ReinsertionOptimizer } from './ReinsertionOptimizer.js';
 // Logger is worker-safe (globalThis only, storage access guarded), unlike Constants.js below.
 import { createLogger, fmt } from '../utils/Logger.js';
@@ -104,23 +103,11 @@ export class BVHBuilder {
 			totalSplitAttempts: 0,
 			mortonSortTime: 0,
 			totalBuildTime: 0,
-			treeletOptimizationTime: 0,
-			treeletsProcessed: 0,
-			treeletsImproved: 0,
-			averageSAHImprovement: 0,
 			reinsertionOptimizationTime: 0,
 			reinsertionsApplied: 0,
 			reinsertionIterations: 0
 		};
 
-		// Off: repairs LBVH trees, so on this binned-SAH build it buys 0.005% tree SAH for 72%
-		// of build time.
-		this.enableTreeletOptimization = false;
-		this.treeletSize = 5;
-		this.treeletOptimizationPasses = 1;
-		this.treeletMinImprovement = 0.02;
-		this.treeletComplexityThreshold = 50000;
-
 		// Reinsertion optimization configuration
 		this.enableReinsertionOptimization = true;
 		this.reinsertionBatchSizeRatio = 0.02;
@@ -201,22 +188,6 @@ export class BVHBuilder {
 
 	}
 
-	setTreeletConfig( config ) {
-
-		if ( config.enabled !== undefined ) this.enableTreeletOptimization = config.enabled;
-		if ( config.size !== undefined ) this.treeletSize = Math.max( 3, Math.min( 12, config.size ) );
-		if ( config.passes !== undefined ) this.treeletOptimizationPasses = Math.max( 1, Math.min( 3, config.passes ) );
-		if ( config.minImprovement !== undefined ) this.treeletMinImprovement = Math.max( 0.001, config.minImprovement );
-		if ( config.complexityThreshold !== undefined ) this.treeletComplexityThreshold = config.complexityThreshold;
-
-	}
-
-	disableTreeletOptimization() {
-
-		this.enableTreeletOptimization = false;
-
-	}
-
 	setReinsertionConfig( config ) {
 
 		if ( config.enabled !== undefined ) this.enableReinsertionOptimization = config.enabled;
@@ -442,7 +413,7 @@ export class BVHBuilder {
 
 					worker.onmessage = ( e ) => {
 
-						const { bvhData, triangles: transferredTriangles, originalToBvh, error, progress, treeletStats } = e.data;
+						const { bvhData, triangles: transferredTriangles, originalToBvh, error, progress, splitStats } = e.data;
 
 						if ( error ) {
 
@@ -459,9 +430,9 @@ export class BVHBuilder {
 
 						}
 
-						if ( treeletStats ) {
+						if ( splitStats ) {
 
-							this.splitStats = treeletStats;
+							this.splitStats = splitStats;
 
 						}
 
@@ -493,12 +464,6 @@ export class BVHBuilder {
 						depth,
 						reportProgress: !! progressCallback,
 						sharedReorderBuffer,
-						treeletOptimization: {
-							enabled: this.enableTreeletOptimization,
-							size: this.treeletSize,
-							passes: this.treeletOptimizationPasses,
-							minImprovement: this.treeletMinImprovement
-						},
 						reinsertionOptimization: {
 							enabled: this.enableReinsertionOptimization,
 							batchSizeRatio: this.reinsertionBatchSizeRatio,
@@ -571,10 +536,6 @@ export class BVHBuilder {
 			totalSplitAttempts: 0,
 			mortonSortTime: 0,
 			totalBuildTime: 0,
-			treeletOptimizationTime: 0,
-			treeletsProcessed: 0,
-			treeletsImproved: 0,
-			averageSAHImprovement: 0,
 			reinsertionOptimizationTime: 0,
 			reinsertionsApplied: 0,
 			reinsertionIterations: 0,
@@ -608,58 +569,7 @@ export class BVHBuilder {
 		const root = this.buildNodeRecursive( 0, n, depth, progressCallback );
 		this.splitStats.sahBuildTime = performance.now() - sahStart;
 
-		// Phase 4: Treelet optimization
-		if ( this.enableTreeletOptimization && this.totalTriangles > 1000 ) {
-
-			const isLargeScene = this.totalTriangles > this.treeletComplexityThreshold;
-			const adaptiveTreeletSize = isLargeScene ? 3 : this.treeletSize;
-
-			const optimizer = new TreeletOptimizer( this.traversalCost, this.intersectionCost );
-			optimizer.setTreeletSize( adaptiveTreeletSize );
-			optimizer.setMinImprovement( this.treeletMinImprovement );
-
-			const optimizationStartTime = performance.now();
-
-			for ( let pass = 0; pass < this.treeletOptimizationPasses; pass ++ ) {
-
-				const passCallback = progressCallback ? ( status ) => {
-
-					progressCallback( `Treelet optimization pass ${pass + 1}/${this.treeletOptimizationPasses}: ${status}` );
-
-				} : null;
-
-				try {
-
-					optimizer.optimizeBVH( root, passCallback );
-
-				} catch ( error ) {
-
-					log.error( `treelet optimizer failed in pass ${pass + 1}:`, error );
-					break;
-
-				}
-
-				// optimizeBVH resets stats internally, so afterStats reflects this pass only
-				const afterStats = optimizer.getStatistics();
-				const passTime = performance.now() - optimizationStartTime;
-				if ( ( afterStats.treeletsImproved === 0 && pass > 0 ) || passTime > 15000 ) {
-
-					break;
-
-				}
-
-			}
-
-			const treeletTime = performance.now() - optimizationStartTime;
-			this.splitStats.treeletOptimizationTime = treeletTime;
-			const treeletStats = optimizer.getStatistics();
-			this.splitStats.treeletsProcessed = treeletStats.treeletsProcessed;
-			this.splitStats.treeletsImproved = treeletStats.treeletsImproved;
-			this.splitStats.averageSAHImprovement = treeletStats.averageSAHImprovement;
-
-		}
-
-		// Phase 4b: Reinsertion optimization (Meister & Bittner)
+		// Phase 4: Reinsertion optimization (Meister & Bittner)
 		if ( this.enableReinsertionOptimization && this.totalTriangles > 1000 ) {
 
 			const reinsertionOptimizer = new ReinsertionOptimizer( this.traversalCost, this.intersectionCost );
@@ -728,7 +638,6 @@ export class BVHBuilder {
 		log.debug(
 			`${fmt.n( n )} tris → ${fmt.n( this.totalNodes )} nodes in ${fmt.ms( total )}` +
 			` | SAH ${s.sahSplits} objMed ${s.objectMedianSplits} spatMed ${s.spatialMedianSplits} failed ${s.failedSplits}` +
-			( s.treeletsProcessed ? ` | treelets ${s.treeletsImproved}/${s.treeletsProcessed} improved` : '' ) +
 			( s.reinsertionsApplied ? ` | reinsertions ${s.reinsertionsApplied}` : '' )
 		);
 

package/src/Processor/EnvironmentExactTable.js

@@ -0,0 +1,187 @@
+/**
+ * An environment's sampling table: piecewise constant over cells of at most EXACT_TABLE_MAX_WIDTH × half that,
+ * so a direction's density is its cell's share, read back from the same cumulative sums it is drawn from.
+ * MIS-compensated (Karlík et al. 2019): each texel weighs what it has above the mean, and BSDF-sampled rays
+ * cover the rest. Drawn by inverting the sums, which keeps the samples' stratification (an alias table does not:
+ * it doubled a furnace's noise). Two guides per entry (Chen & Hsu's cutpoints, GUIDES_PER_ENTRY) land most
+ * draws on their entry at once. Pure math: CDFWorker runs it too.
+ */
+
+export const EXACT_TABLE_MAX_WIDTH = 1024;
+
+// Every cell keeps this share of the mean, so light tracing or NEE alone covers the whole sphere.
+const FLOOR = 1e-4;
+
+/** Guides per running-sum entry: step g of n · GUIDES_PER_ENTRY points at the first entry above it. */
+export const GUIDES_PER_ENTRY = 2;
+
+/** Cells the table has for a width × height environment; TSL/Environment.js derives the same. */
+export function exactTableSize( width, height ) {
+
+	const k = Math.max( 1, Math.ceil( width / EXACT_TABLE_MAX_WIDTH ) );
+	return { k, width: Math.ceil( width / k ), height: Math.ceil( height / k ) };
+
+}
+
+// For each of m equal steps of an n-entry running sum, the first entry above the step's start; n − 1 past the end.
+function cutpoints( cdf, offset, n, out, outOffset, m ) {
+
+	let x = 0;
+	for ( let g = 0; g < m; g ++ ) {
+
+		while ( x < n - 1 && cdf[ offset + x ] <= g / m ) x ++;
+		out[ outOffset + g ] = x;
+
+	}
+
+}
+
+/**
+ * @param {Float32Array} floatData - RGBA, row 0 the nadir
+ * @param {{ filtered?: boolean }} [options] - filtered false: each texel weighs as itself (the physical sky's GPU twin)
+ * @returns {{ exactWidth: number, exactHeight: number, exactConditional: Float32Array, exactMarginal: Float32Array,
+ *   exactRowGuide: Float32Array, exactMarginalGuide: Float32Array, radianceIntegral: number }}
+ *   each row's running sum over its cells and the rows' over all, both ending at 1, and their guides (GUIDES_PER_ENTRY
+ *   an entry); ∫ luminance dω.
+ */
+export function buildExactEnvironmentTable( floatData, width, height, { filtered = true } = {} ) {
+
+	const { k, width: w, height: h } = exactTableSize( width, height );
+	const lum = new Float32Array( width * height );
+	let raw = 0;
+	for ( let y = 0; y < height; y ++ ) {
+
+		const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
+		for ( let x = 0; x < width; x ++ ) {
+
+			const i = 4 * ( y * width + x );
+			const l = 0.2126 * floatData[ i ] + 0.7152 * floatData[ i + 1 ] + 0.0722 * floatData[ i + 2 ];
+			lum[ y * width + x ] = Number.isFinite( l ) && l > 0 ? l : 0;
+			raw += lum[ y * width + x ] * sinTheta;
+
+		}
+
+	}
+
+	// Each texel weighs as the bilinear filter's mean over it — 1/8, 6/8, 1/8 of its neighbours along each axis — so
+	// a cell has weight wherever the filtered map has light, and a sharp texel's neighbours only their share of it.
+	const TAP = [ 1 / 8, 6 / 8, 1 / 8 ];
+	const eachTexel = ( visit ) => {
+
+		for ( let y = 0; y < height; y ++ ) {
+
+			const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
+			const row = Math.floor( y / k ) * w;
+			const ys = [ Math.max( y - 1, 0 ), y, Math.min( y + 1, height - 1 ) ];
+			for ( let x = 0; x < width; x ++ ) {
+
+				let value = lum[ y * width + x ];
+				if ( filtered ) {
+
+					const xs = [ ( x + width - 1 ) % width, x, ( x + 1 ) % width ];
+					value = 0;
+					for ( let j = 0; j < 3; j ++ ) for ( let i = 0; i < 3; i ++ ) value += TAP[ j ] * TAP[ i ] * lum[ ys[ j ] * width + xs[ i ] ];
+
+				}
+
+				visit( row + Math.floor( x / k ), value * sinTheta );
+
+			}
+
+		}
+
+	};
+
+	let filteredTotal = 0;
+	eachTexel( ( cell, weight ) => void ( filteredTotal += weight ) );
+	const mean = filteredTotal / ( width * height );
+	const cells = new Float64Array( w * h );
+	let compensated = 0;
+	eachTexel( ( cell, weight ) => {
+
+		cells[ cell ] += Math.max( weight - mean, 0 );
+		compensated += Math.max( weight - mean, 0 );
+
+	} );
+	// A flat map has nothing above its mean: then the raw weights.
+	if ( ! ( compensated > 0 ) ) {
+
+		cells.fill( 0 );
+		eachTexel( ( cell, weight ) => void ( cells[ cell ] += weight ) );
+
+	}
+
+	const floor = filteredTotal > 0 ? FLOOR * filteredTotal / ( w * h ) : 0;
+	const exactConditional = new Float32Array( w * h );
+	const exactMarginal = new Float32Array( h );
+	const rowSums = new Float64Array( h );
+	let total = 0;
+	for ( let y = 0; y < h; y ++ ) {
+
+		let sum = 0;
+		for ( let x = 0; x < w; x ++ ) sum += cells[ y * w + x ] + floor;
+		let cumulative = 0;
+		for ( let x = 0; x < w; x ++ ) {
+
+			cumulative += cells[ y * w + x ] + floor;
+			exactConditional[ y * w + x ] = sum > 0 ? ( x === w - 1 ? 1 : cumulative / sum ) : 0;
+
+		}
+
+		rowSums[ y ] = sum;
+		total += sum;
+
+	}
+
+	let cumulative = 0;
+	for ( let y = 0; y < h; y ++ ) {
+
+		cumulative += rowSums[ y ];
+		exactMarginal[ y ] = total > 0 ? ( y === h - 1 ? 1 : cumulative / total ) : 0;
+
+	}
+
+	const G = GUIDES_PER_ENTRY;
+	const exactRowGuide = new Float32Array( G * w * h );
+	const exactMarginalGuide = new Float32Array( G * h );
+	for ( let y = 0; y < h; y ++ ) cutpoints( exactConditional, y * w, w, exactRowGuide, G * y * w, G * w );
+	cutpoints( exactMarginal, 0, h, exactMarginalGuide, 0, G * h );
+
+	return {
+		exactWidth: w, exactHeight: h, exactConditional, exactMarginal, exactRowGuide, exactMarginalGuide,
+		radianceIntegral: 2 * Math.PI * Math.PI * raw / ( width * height ),
+	};
+
+}
+
+/**
+ * The table as the CDF texture holds it, ( w + 1 ) × h RGBA floats: texel ( x, y ) holds row y's entry x — its running
+ * sum, the one below it (0 at the first), and the guides of steps 2x and 2x + 1 — and texel ( w, y ) the rows' entry y
+ * likewise. TSL/Environment.js reads this layout.
+ */
+export function packExactTable( { exactWidth: w, exactHeight: h, exactConditional, exactMarginal, exactRowGuide, exactMarginalGuide } ) {
+
+	const stride = w + 1;
+	const data = new Float32Array( 4 * stride * h );
+	for ( let y = 0; y < h; y ++ ) {
+
+		let o = 4 * y * stride;
+		for ( let x = 0, i = y * w; x < w; x ++, i ++, o += 4 ) {
+
+			data[ o ] = exactConditional[ i ];
+			data[ o + 1 ] = x > 0 ? exactConditional[ i - 1 ] : 0;
+			data[ o + 2 ] = exactRowGuide[ 2 * i ];
+			data[ o + 3 ] = exactRowGuide[ 2 * i + 1 ];
+
+		}
+
+		data[ o ] = exactMarginal[ y ];
+		data[ o + 1 ] = y > 0 ? exactMarginal[ y - 1 ] : 0;
+		data[ o + 2 ] = exactMarginalGuide[ 2 * y ];
+		data[ o + 3 ] = exactMarginalGuide[ 2 * y + 1 ];
+
+	}
+
+	return { data, width: stride, height: h };
+
+}

package/src/Processor/EquirectHDRInfo.js

@@ -1,44 +1,7 @@
 import { DataUtils, HalfFloatType, FloatType, SRGBColorSpace } from 'three';
 import CDFWorker from './Workers/CDFWorker.js?worker&inline';
 import { createWorker } from '../Platform.js';
-
-/**
- * Binary search to find the closest index
- */
-function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
-
-	let lower = offset;
-	let upper = offset + count - 1;
-
-	while ( lower < upper ) {
-
-		const mid = ( lower + upper ) >> 1;
-
-		if ( array[ mid ] < targetValue ) {
-
-			lower = mid + 1;
-
-		} else {
-
-			upper = mid;
-
-		}
-
-	}
-
-	return lower - offset;
-
-}
-
-/**
- * Calculate luminance from RGB values
- */
-function colorToLuminance( r, g, b ) {
-
-	// https://en.wikipedia.org/wiki/Relative_luminance
-	return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-
-}
+import { buildExactEnvironmentTable } from './EnvironmentExactTable.js';
 
 /**
  * sRGB to linear conversion (IEC 61966-2-1 transfer function)
@@ -154,27 +117,24 @@ export function extractFloatData( envMap ) {
 }
 
 /**
- * EquirectHDRInfo - Importance sampling data for equirectangular HDR maps
- *
- * Builds inverted marginal and conditional CDFs from an HDR environment map.
- * Outputs Float32Arrays consumed directly by StorageInstancedBufferAttribute
- * on the GPU — no intermediate DataTexture or HalfFloat conversion needed.
- *
- * Supports two modes:
- * - `updateFrom(hdr)`: synchronous, runs on main thread
- * - `updateFromAsync(hdr)`: offloads CDF math to a Web Worker
+ * EquirectHDRInfo - an equirectangular environment's sampling table (EnvironmentExactTable.js), built on the
+ * main thread (`updateFrom`) or in CDFWorker (`updateFromAsync`). `totalSum` is the map's ∫ luminance dω, 0
+ * when there is nothing to sample.
  */
 export class EquirectHDRInfo {
 
 	constructor() {
 
-		// Placeholder data matching the default storage buffer sizes in PathTracer
-		this.marginalData = new Float32Array( [ 0, 1 ] );
-		this.conditionalData = new Float32Array( [ 0, 0, 1, 1 ] );
 		this.totalSum = 0;
-		this.compensationDelta = 0;
 		this.width = 0;
 		this.height = 0;
+		this.exactConditional = null;
+		this.exactMarginal = null;
+		this.exactRowGuide = null;
+		this.exactMarginalGuide = null;
+		this.exactWidth = 0;
+		this.exactHeight = 0;
+		this.radianceIntegral = 0;
 
 		this._worker = null;
 
@@ -182,8 +142,10 @@ export class EquirectHDRInfo {
 
 	dispose() {
 
-		this.marginalData = null;
-		this.conditionalData = null;
+		this.exactConditional = null;
+		this.exactMarginal = null;
+		this.exactRowGuide = null;
+		this.exactMarginalGuide = null;
 
 		if ( this._worker ) {
 
@@ -194,28 +156,28 @@ export class EquirectHDRInfo {
 
 	}
 
+	_adopt( table, width, height ) {
+
+		Object.assign( this, table );
+		this.width = width;
+		this.height = height;
+		this.totalSum = table.radianceIntegral;
+
+	}
+
 	/**
-	 * Synchronous CDF build on main thread (fallback path).
+	 * Synchronous build on the main thread (fallback path).
 	 */
 	updateFrom( hdr ) {
 
 		const { floatData, width, height } = extractFloatData( hdr );
-
-		const result = EquirectHDRInfo.computeCDF( floatData, width, height );
-
-		this.marginalData = result.marginalData;
-		this.conditionalData = result.conditionalData;
-		this.totalSum = result.totalSum;
-		this.compensationDelta = result.compensationDelta;
-		this.width = width;
-		this.height = height;
+		this._adopt( buildExactEnvironmentTable( floatData, width, height ), width, height );
 
 	}
 
 	/**
-	 * Async CDF build offloaded to a Web Worker.
-	 * Float extraction (HalfFloat → Float32) runs on main thread (needs Three.js DataUtils),
-	 * then the pure-math CDF computation runs off-thread.
+	 * The build offloaded to a Web Worker. Float extraction (HalfFloat → Float32) runs on the main thread
+	 * (it needs three's DataUtils); the table's math runs off it.
 	 * @returns {Promise<void>}
 	 */
 	async updateFromAsync( hdr ) {
@@ -253,12 +215,8 @@ export class EquirectHDRInfo {
 
 			} );
 
-			this.marginalData = result.marginalData;
-			this.conditionalData = result.conditionalData;
-			this.totalSum = result.totalSum;
-			this.compensationDelta = result.compensationDelta;
-			this.width = result.width;
-			this.height = result.height;
+			const { width: w, height: h, ...table } = result;
+			this._adopt( table, w, h );
 
 		} finally {
 
@@ -273,155 +231,4 @@ export class EquirectHDRInfo {
 
 	}
 
-	/**
-	 * Pure-math CDF computation. Used by both the sync path and CDFWorker.
-	 * Static so it can be called without an instance.
-	 */
-	static computeCDF( floatData, width, height ) {
-
-		const numPixels = width * height;
-
-		// Pass 1: compute per-pixel luminance weighted by sin(theta) and raw total sum.
-		// sin(theta) compensates for the equirectangular projection: pixels near the poles
-		// cover less solid angle, so weighting by sin(theta) makes the CDF proportional to
-		// luminance per solid angle rather than luminance per pixel.
-		const pixelWeights = new Float32Array( numPixels );
-		let rawTotalSum = 0.0;
-
-		for ( let y = 0; y < height; y ++ ) {
-
-			const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
-
-			for ( let x = 0; x < width; x ++ ) {
-
-				const i = y * width + x;
-				const w = colorToLuminance(
-					floatData[ 4 * i ],
-					floatData[ 4 * i + 1 ],
-					floatData[ 4 * i + 2 ],
-				) * sinTheta;
-				pixelWeights[ i ] = w;
-				rawTotalSum += w;
-
-			}
-
-		}
-
-		// MIS Compensation (Karlík et al. 2019, Eq. 14)
-		// With equal sample allocation (c_I = 0.5): delta = 2*(1 - 0.5)*meanWeight = meanWeight
-		// Subtracting mean sharpens the env map PDF, reducing oversampling
-		// of dim regions already well-covered by BSDF sampling.
-		const meanWeight = rawTotalSum / numPixels;
-		let compensatedTotalSum = 0.0;
-
-		for ( let i = 0; i < numPixels; i ++ ) {
-
-			pixelWeights[ i ] = Math.max( 0, pixelWeights[ i ] - meanWeight );
-			compensatedTotalSum += pixelWeights[ i ];
-
-		}
-
-		// Fall back to raw weights if compensation zeroed everything (uniform env map)
-		const useCompensation = compensatedTotalSum > 0;
-		const totalSumValue = useCompensation ? compensatedTotalSum : rawTotalSum;
-		const compensationDelta = useCompensation ? meanWeight : 0;
-
-		if ( ! useCompensation ) {
-
-			for ( let y = 0; y < height; y ++ ) {
-
-				const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
-
-				for ( let x = 0; x < width; x ++ ) {
-
-					const i = y * width + x;
-					pixelWeights[ i ] = colorToLuminance(
-						floatData[ 4 * i ],
-						floatData[ 4 * i + 1 ],
-						floatData[ 4 * i + 2 ],
-					) * sinTheta;
-
-				}
-
-			}
-
-		}
-
-		// Pass 2: build conditional and marginal CDFs from (compensated) weights
-		const cdfConditional = new Float32Array( numPixels );
-		const cdfMarginal = new Float32Array( height );
-
-		let cumulativeWeightMarginal = 0.0;
-
-		for ( let y = 0; y < height; y ++ ) {
-
-			let cumulativeRowWeight = 0.0;
-			for ( let x = 0; x < width; x ++ ) {
-
-				const i = y * width + x;
-				cumulativeRowWeight += pixelWeights[ i ];
-				cdfConditional[ i ] = cumulativeRowWeight;
-
-			}
-
-			// Normalize row CDF to [0, 1]
-			if ( cumulativeRowWeight !== 0 ) {
-
-				for ( let i = y * width, l = y * width + width; i < l; i ++ ) {
-
-					cdfConditional[ i ] /= cumulativeRowWeight;
-
-				}
-
-			}
-
-			cumulativeWeightMarginal += cumulativeRowWeight;
-			cdfMarginal[ y ] = cumulativeWeightMarginal;
-
-		}
-
-		// Normalize marginal CDF to [0, 1]
-		if ( cumulativeWeightMarginal !== 0 ) {
-
-			for ( let i = 0, l = cdfMarginal.length; i < l; i ++ ) {
-
-				cdfMarginal[ i ] /= cumulativeWeightMarginal;
-
-			}
-
-		}
-
-		// Create inverted CDF arrays (Float32 directly for storage buffers)
-		const marginalData = new Float32Array( height );
-		const conditionalData = new Float32Array( numPixels );
-
-		// Invert marginal CDF
-		for ( let i = 0; i < height; i ++ ) {
-
-			const dist = ( i + 1 ) / height;
-			const row = binarySearchFindClosestIndexOf( cdfMarginal, dist );
-
-			marginalData[ i ] = ( row + 0.5 ) / height;
-
-		}
-
-		// Invert conditional CDFs
-		for ( let y = 0; y < height; y ++ ) {
-
-			for ( let x = 0; x < width; x ++ ) {
-
-				const i = y * width + x;
-				const dist = ( x + 1 ) / width;
-				const col = binarySearchFindClosestIndexOf( cdfConditional, dist, y * width, width );
-
-				conditionalData[ i ] = ( col + 0.5 ) / width;
-
-			}
-
-		}
-
-		return { marginalData, conditionalData, totalSum: totalSumValue, compensationDelta };
-
-	}
-
 }