16861002932

Committed 10 Aug 2025 11:45AM UTC coverage: 51.305% (-22.6%) from 73.868%

Build # 16861002932

Build Type

Pull #2416

github

Committed by

web-flow

Commit Message

Merge 92c90562d into f90a93cf3

Pull Request Pull Request #2416: chore: Tests for texture reads

Coverage Stats

595 of 835 branches covered (71.26%)

Branch coverage included in aggregate %.

66 of 101 new or added lines in 7 files covered. (65.35%)

8541 existing lines in 129 files now uncovered.

18683 of 36740 relevant lines covered (50.85%)

11.74 hits per line

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

34.38

/modules/arrow/src/attribute-utils/attribute-utils.ts

// luma.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import {TypedArray} from '@math.gl/types';

/**
 * Expand an array from "one element per geometry" to "one element per coordinate"
 *
 * @param input: the input array to expand
 * @param size : the number of nested elements in the input array per geometry. So for example, for RGB data this would be 3, for RGBA this would be 4. For radius, this would be 1.
 * @param geomOffsets : an offsets array mapping from the geometry to the coordinate indexes. So in the case of a LineStringArray, this is retrieved directly from the GeoArrow storage. In the case of a PolygonArray, this comes from the resolved indexes that need to be given to the SolidPolygonLayer anyways.
 *
 * @return values expanded to be per-coordinate
 */
export function expandArrayToCoords<T extends TypedArray>(
  input: T,
  size: number,
  geomOffsets: Int32Array
): T {
  const numCoords = geomOffsets[geomOffsets.length - 1];
  // @ts-expect-error
  const outputArray: T = new input.constructor(numCoords * size);

  // geomIdx is an index into the geomOffsets array
  // geomIdx is also the geometry/table index
  for (let geomIdx = 0; geomIdx < geomOffsets.length - 1; geomIdx++) {
    // geomOffsets maps from the geometry index to the coord index
    // So here we get the range of coords that this geometry covers
    const lastCoordIdx = geomOffsets[geomIdx];
    const nextCoordIdx = geomOffsets[geomIdx + 1];

    // Iterate over this range of coord indices
    for (let coordIdx = lastCoordIdx; coordIdx < nextCoordIdx; coordIdx++) {
      // Iterate over size
      for (let i = 0; i < size; i++) {
        // Copy from the geometry index in `input` to the coord index in
        // `output`
        outputArray[coordIdx * size + i] = input[geomIdx * size + i];
      }
    }
  }

  return outputArray;
}

/**
 * Invert offsets so that lookup can go in the opposite direction
 */
export function invertOffsets(offsets: Int32Array): Uint32Array {
  const largestOffset = offsets[offsets.length - 1];

  const invertedOffsets = new Uint32Array(largestOffset);
  for (let arrayIdx = 0; arrayIdx < offsets.length - 1; arrayIdx++) {
    const thisOffset = offsets[arrayIdx];
    const nextOffset = offsets[arrayIdx + 1];
    for (let offset = thisOffset; offset < nextOffset; offset++) {
      invertedOffsets[offset] = arrayIdx;
    }
  }

  return invertedOffsets;
}

1	// luma.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	import {TypedArray} from '@math.gl/types';	1✔
6		1✔
7	/**	1✔
8	* Expand an array from "one element per geometry" to "one element per coordinate"	1✔
9	*	1✔
10	* @param input: the input array to expand	1✔
11	* @param size : the number of nested elements in the input array per geometry. So for example, for RGB data this would be 3, for RGBA this would be 4. For radius, this would be 1.	1✔
12	* @param geomOffsets : an offsets array mapping from the geometry to the coordinate indexes. So in the case of a LineStringArray, this is retrieved directly from the GeoArrow storage. In the case of a PolygonArray, this comes from the resolved indexes that need to be given to the SolidPolygonLayer anyways.	1✔
13	*	1✔
14	* @return values expanded to be per-coordinate	1✔
15	*/	1✔
16	export function expandArrayToCoords<T extends TypedArray>(	1✔
UNCOV 17	input: T,	×
UNCOV 18	size: number,	×
UNCOV 19	geomOffsets: Int32Array	×
UNCOV 20	): T {	×
UNCOV 21	const numCoords = geomOffsets[geomOffsets.length - 1];	×
UNCOV 22	// @ts-expect-error	×
UNCOV 23	const outputArray: T = new input.constructor(numCoords * size);	×
UNCOV 24		×
UNCOV 25	// geomIdx is an index into the geomOffsets array	×
UNCOV 26	// geomIdx is also the geometry/table index	×
UNCOV 27	for (let geomIdx = 0; geomIdx < geomOffsets.length - 1; geomIdx++) {	×
UNCOV 28	// geomOffsets maps from the geometry index to the coord index	×
UNCOV 29	// So here we get the range of coords that this geometry covers	×
UNCOV 30	const lastCoordIdx = geomOffsets[geomIdx];	×
UNCOV 31	const nextCoordIdx = geomOffsets[geomIdx + 1];	×
UNCOV 32		×
UNCOV 33	// Iterate over this range of coord indices	×
UNCOV 34	for (let coordIdx = lastCoordIdx; coordIdx < nextCoordIdx; coordIdx++) {	×
UNCOV 35	// Iterate over size	×
UNCOV 36	for (let i = 0; i < size; i++) {	×
UNCOV 37	// Copy from the geometry index in `input` to the coord index in	×
UNCOV 38	// `output`	×
UNCOV 39	outputArray[coordIdx * size + i] = input[geomIdx * size + i];	×
UNCOV 40	}	×
UNCOV 41	}	×
UNCOV 42	}	×
UNCOV 43		×
UNCOV 44	return outputArray;	×
UNCOV 45	}	×
46		1✔
47	/**	1✔
48	* Invert offsets so that lookup can go in the opposite direction	1✔
49	*/	1✔
50	export function invertOffsets(offsets: Int32Array): Uint32Array {	1✔
51	const largestOffset = offsets[offsets.length - 1];	×
52		×
53	const invertedOffsets = new Uint32Array(largestOffset);	×
54	for (let arrayIdx = 0; arrayIdx < offsets.length - 1; arrayIdx++) {	×
55	const thisOffset = offsets[arrayIdx];	×
56	const nextOffset = offsets[arrayIdx + 1];	×
57	for (let offset = thisOffset; offset < nextOffset; offset++) {	×
58	invertedOffsets[offset] = arrayIdx;	×
59	}	×
60	}	×
61		×
62	return invertedOffsets;	×
63	}	×

visgl / luma.gl / 16861002932

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