4076206884

Build # 4076206884

Build Type

Pull #1993

github

Committed by GitHub

Commit Message

Merge 3994711c0 into 7f86d26e1

Pull Request Pull Request #1993: WIP Bounding box and calculation of MinMax values

Run Details

3167 of 4888 branches covered (64.79%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 2 files covered. (100.0%)

6977 of 8634 relevant lines covered (80.81%)

1508.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.42

/src/Parser/XbilParser.js

import { readTextureValueWithBilinearFiltering } from 'Utils/DEMUtils';

function minMax4Corners(texture, pitch, options) {
    const u = pitch.x;
    const v = pitch.y;
    const w = pitch.z;
    const z = [
        readTextureValueWithBilinearFiltering(options, texture, u, v),
        readTextureValueWithBilinearFiltering(options, texture, u + w, v),
        readTextureValueWithBilinearFiltering(options, texture, u + w, v + w),
        readTextureValueWithBilinearFiltering(options, texture, u, v + w),
    ].filter(val => val != undefined);

    if (z.length) {
        return { min: Math.min(...z), max: Math.max(...z) };
    } else {
        return {
            min: Infinity,
            max: -Infinity,
        };
    }
}

/**
  * Calculates the minimum maximum texture elevation with xbil data
  *
  * @param      {THREE.Texture}     texture                     The texture to parse
  * @param      {THREE.Vector4}     pitch                       The pitch,  restrict zone to parse
  * @param      {Object}            options                     No data value and clamp values
   * @param      {number}           options.noDataValue         No data value
   * @param      {Object}           [options.clampValues]       The values for clamping
    * @param      {Object}          [options.clampValues.min]   The minimum elevation value after which it will be clamped
    * @param      {Object}          [options.clampValues.max]   The maximum elevation value after which it will be clamped
  * @return     {Object}  The minimum and maximum elevation.
  */
export function computeMinMaxElevation(texture, pitch, options) {
    const { width, height, data } = texture.image;
    if (!data) {
        // Return null values means there's no elevation values.
        // They can't be determined.
        // Don't return 0 because the result will be wrong
        return { min: null, max: null };
    }

    // compute the minimum and maximum elevation on the 4 corners texture.
    let { min, max } = minMax4Corners(texture, pitch, options);

    const sizeX = Math.floor(pitch.z * width);

    if (sizeX > 2) {
        const sizeY = Math.floor(pitch.z * height);
        const xs = Math.floor(pitch.x * width);
        const ys = Math.floor(pitch.y * height);
        const inc = Math.max(Math.floor(sizeX / 32), 2);
        const limX = ys + sizeY;
        for (let y = ys; y < limX; y += inc) {
            const pit = y * (width || 0);
            let x = pit + xs;
            const limX = x + sizeX;
            for (x; x < limX; x += inc) {
                const val = data[x];
                if (val !== options.noDataValue) {
                    max = Math.max(max, val);
                    min = Math.min(min, val);
                }
            }
        }
        if (options.clampValues?.min > min) { min = options.clampValues?.min; }
        if (options.clampValues?.max < max) { max = options.clampValues?.max; }
    }

    if (max === -Infinity || min === Infinity) {
        // Return null values means the elevation values are incoherent
        // They can't be determined.
        // Don't return 0, -Infinity or Infinity because the result will be wrong
        return { min: null, max: null };
    } else {
        return { min, max };
    }
}

// We check if the elevation texture has some significant values through corners
export function checkNodeElevationTextureValidity(data, noDataValue) {
    const l = data.length;
    return data[0] > noDataValue &&
           data[l - 1] > noDataValue &&
           data[Math.sqrt(l) - 1] > noDataValue &&
           data[l - Math.sqrt(l)] > noDataValue;
}

function getIndiceWithPitch(i, pitch, w) {
    // Return corresponding indice in parent tile using pitch
    const currentX = (i % w) / w;  // normalized
    const currentY = Math.floor(i / w) / w; // normalized
    const newX = pitch.x + currentX * pitch.z;
    const newY = pitch.y + currentY * pitch.w;
    const newIndice = Math.floor(newY * w) * w + Math.floor(newX * w);
    return newIndice;
}

// This function replaces noDataValue by significant values from parent texture
export function insertSignificantValuesFromParent(data, dataParent, noDataValue, pitch) {
    for (let i = 0, l = data.length; i < l; ++i) {
        if (data[i] === noDataValue) {
            data[i] = dataParent[getIndiceWithPitch(i, pitch, 256)];
        }
    }
}

1	import { readTextureValueWithBilinearFiltering } from 'Utils/DEMUtils';	1✔
2
3	function minMax4Corners(texture, pitch, options) {
4	const u = pitch.x;	2✔
5	const v = pitch.y;	2✔
6	const w = pitch.z;	2✔
7	const z = [	2✔
8	readTextureValueWithBilinearFiltering(options, texture, u, v),
9	readTextureValueWithBilinearFiltering(options, texture, u + w, v),
10	readTextureValueWithBilinearFiltering(options, texture, u + w, v + w),
11	readTextureValueWithBilinearFiltering(options, texture, u, v + w),
12	].filter(val => val != undefined);	8✔
13
14	if (z.length) {	2!
15	return { min: Math.min(...z), max: Math.max(...z) };	2✔
16	} else {
17	return {	×
18	min: Infinity,
19	max: -Infinity,
20	};
21	}
22	}
23
24	/**
25	* Calculates the minimum maximum texture elevation with xbil data
26	*
27	* @param {THREE.Texture} texture The texture to parse
28	* @param {THREE.Vector4} pitch The pitch, restrict zone to parse
29	* @param {Object} options No data value and clamp values
30	* @param {number} options.noDataValue No data value
31	* @param {Object} [options.clampValues] The values for clamping
32	* @param {Object} [options.clampValues.min] The minimum elevation value after which it will be clamped
33	* @param {Object} [options.clampValues.max] The maximum elevation value after which it will be clamped
34	* @return {Object} The minimum and maximum elevation.
35	*/
36	export function computeMinMaxElevation(texture, pitch, options) {
37	const { width, height, data } = texture.image;	2✔
38	if (!data) {	2!
39	// Return null values means there's no elevation values.
40	// They can't be determined.
41	// Don't return 0 because the result will be wrong
42	return { min: null, max: null };	×
43	}
44
45	// compute the minimum and maximum elevation on the 4 corners texture.
46	let { min, max } = minMax4Corners(texture, pitch, options);	2✔
47
48	const sizeX = Math.floor(pitch.z * width);	2✔
49
50	if (sizeX > 2) {	2!
51	const sizeY = Math.floor(pitch.z * height);	2✔
52	const xs = Math.floor(pitch.x * width);	2✔
53	const ys = Math.floor(pitch.y * height);	2✔
54	const inc = Math.max(Math.floor(sizeX / 32), 2);	2✔
55	const limX = ys + sizeY;
56	for (let y = ys; y < limX; y += inc) {	2✔
57	const pit = y * (width \|\| 0);	34!
58	let x = pit + xs;	34✔
59	const limX = x + sizeX;	34✔
60	for (x; x < limX; x += inc) {	34✔
61	const val = data[x];	1,028✔
62	if (val !== options.noDataValue) {	1,028!
63	max = Math.max(max, val);	1,028✔
64	min = Math.min(min, val);	1,028✔
65	}
66	}
67	}
68	if (options.clampValues?.min > min) { min = options.clampValues?.min; }	2!
69	if (options.clampValues?.max < max) { max = options.clampValues?.max; }	2!
70	}
71
72	if (max === -Infinity \|\| min === Infinity) {	2!
73	// Return null values means the elevation values are incoherent
74	// They can't be determined.
75	// Don't return 0, -Infinity or Infinity because the result will be wrong
76	return { min: null, max: null };	×
77	} else {
78	return { min, max };	2✔
79	}
80	}
81
82	// We check if the elevation texture has some significant values through corners
83	export function checkNodeElevationTextureValidity(data, noDataValue) {
84	const l = data.length;	×
85	return data[0] > noDataValue &&	×
86	data[l - 1] > noDataValue &&
87	data[Math.sqrt(l) - 1] > noDataValue &&
88	data[l - Math.sqrt(l)] > noDataValue;
89	}
90
91	function getIndiceWithPitch(i, pitch, w) {
92	// Return corresponding indice in parent tile using pitch
93	const currentX = (i % w) / w; // normalized
94	const currentY = Math.floor(i / w) / w; // normalized	×
95	const newX = pitch.x + currentX * pitch.z;	×
96	const newY = pitch.y + currentY * pitch.w;	×
97	const newIndice = Math.floor(newY * w) * w + Math.floor(newX * w);	×
98	return newIndice;	×
99	}
100
101	// This function replaces noDataValue by significant values from parent texture
102	export function insertSignificantValuesFromParent(data, dataParent, noDataValue, pitch) {
103	for (let i = 0, l = data.length; i < l; ++i) {	×
104	if (data[i] === noDataValue) {	×
105	data[i] = dataParent[getIndiceWithPitch(i, pitch, 256)];	×
106	}
107	}
108	}

iTowns / itowns / 4076206884

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous