9464919793

Committed 11 Jun 2024 11:44AM UTC coverage: 89.566% (-0.1%) from 89.672%

Build # 9464919793

Build Type

Pull #8944

github

Committed by

web-flow

Commit Message

Merge 91e3239ff into 93518480a

Pull Request Pull Request #8944: CARTO HeatmapTileLayer implement autoscaling

Run Details

6355 of 6992 branches covered (90.89%)

Branch coverage included in aggregate %.

68 of 173 new or added lines in 4 files covered. (39.31%)

4 existing lines in 1 file now uncovered.

52489 of 58707 relevant lines covered (89.41%)

6566.05 hits per line

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

90.21

/modules/carto/src/layers/heatmap.ts

import type {ShaderPass} from '@luma.gl/shadertools';
import {random} from '@luma.gl/shadertools';
import {Color} from '@deck.gl/core';
const glsl = (s: TemplateStringsArray) => `${s}`;

/**
 * @filter       Heatmap
 * @param radiusPixels Blur radius in pixels, controls smoothness of heatmap
 * @param colorDomain Domain to apply to values prior to applying color scale
 * @param color1-6 Colors to use in color scale
 */

const fs = glsl`\
uniform heatmapUniforms {
  vec2 delta;
  float radiusPixels;
  vec2 colorDomain;
  vec3 color1;
  vec3 color2;
  vec3 color3;
  vec3 color4;
  vec3 color5;
  vec3 color6;
  float intensity;
  float opacity;
} heatmap;

const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);

vec3 colorGradient(float value) {
  vec3 c1;
  vec3 c2;
  vec2 range;
  if (value < STOPS.x) {
    range = vec2(0.0, STOPS.x);
    c1 = heatmap.color1; c2 = heatmap.color2;
  } else if (value < STOPS.y) {
    range = STOPS.xy;
    c1 = heatmap.color2; c2 = heatmap.color3;
  } else if (value < STOPS.z) {
    range = STOPS.yz;
    c1 = heatmap.color3; c2 = heatmap.color4;
  } else if (value < STOPS.w) {
    range = STOPS.zw;
    c1 = heatmap.color4; c2 = heatmap.color5;
  } else if (value < 1.0 ) {
    range = vec2(STOPS.w, 1.0);
    c1 = heatmap.color5; c2 = heatmap.color6;
  } else {
    // Fade out to white
    range = vec2(1.0, 10.0);
    c1 = heatmap.color6; c2 = vec3(255.0);
  }

  float f = (value - range.x) / (range.y - range.x);
  return mix(c1, c2, f) / 255.0;
}

const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
const float MAX_VAL = SHIFT.z * 255.0;
const float SCALE = MAX_VAL / 8.0;
vec4 pack(float value) {
  return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
}
float unpack(vec3 color) {
  return 255.0 * dot(color, SHIFT);
}

vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  bool firstPass = (heatmap.delta.y < 0.5);
  float accumulator = 0.0;

  // Randomize the lookup values to hide the fixed number of samples
  float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);

  // Controls quality of heatmap, larger values increase quality at expense of performance
  float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);

  // Gaussian normalization parameters
  float sigma = SUPPORT / 3.0;
  float a = -0.5 / (sigma * sigma);
  float w0 = 0.3989422804014327 / sigma; // 1D normalization
  for (float t = -SUPPORT; t <= SUPPORT; t++) {
    vec2 percent = (t * heatmap.delta + offset - 0.5) / SUPPORT;
    vec2 delta = percent * heatmap.radiusPixels / texSize;
    vec4 offsetColor = texture(source, texCoord + delta);

    // Unpack float
    float value = unpack(offsetColor.rgb);

    // Gaussian
    float weight = w0 * exp(a * t * t);
    
    accumulator += value * weight;
  }

  if (firstPass) {
    return pack(accumulator);
  }

  // Undo scaling to obtain normalized density
  float density = 10.0 * heatmap.intensity * accumulator / SCALE;
 
  // Domain also in normalized density units
  vec2 domain = heatmap.colorDomain;

  // Apply domain
  float f = (density - domain[0]) / (domain[1] - domain[0]);

  // sqrt/log scaling??
  // float f = (log(density) - log(domain[0] + 1.0)) / (log(domain[1] + 1.0) - log(domain[0] + 1.0));
  // f = sqrt(f);

  // Color map
  vec4 color = vec4(0.0);
  color.rgb = colorGradient(f);

  color.a = smoothstep(0.0, 0.1, f);
  color.a = pow(color.a, 1.0 / 2.2);
  color.a *= heatmap.opacity;

  return color;
}
`;

const defaultColorRange: Color[] = [
  [255, 255, 178],
  [254, 217, 118],
  [254, 178, 76],
  [253, 141, 60],
  [240, 59, 32],
  [189, 0, 38]
];

export type HeatmapProps = {
  /**
   * Radius of the heatmap blur in pixels, to which the weight of a cell is distributed.
   *
   * @default 20
   */
  radiusPixels?: number;
  /**
   * Controls how weight values are mapped to the `colorRange`, as an array of two numbers [`minValue`, `maxValue`].
   *
   * @default [0, 1]
   */
  colorDomain?: [number, number];
  /**
   * Specified as an array of colors [color1, color2, ...].
   *
   * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
   */
  colorRange: Color[];
  /**
   * Value that is multiplied with the total weight at a pixel to obtain the final weight. A value larger than 1 biases the output color towards the higher end of the spectrum, and a value less than 1 biases the output color towards the lower end of the spectrum.
   */
  intensity?: number;
  opacity: number;
};

export type HeatmapUniforms = {
  delta?: [number, number];
  radiusPixels?: number;
  colorDomain?: [number, number];
  color1?: [number, number, number];
  color2?: [number, number, number];
  color3?: [number, number, number];
  color4?: [number, number, number];
  color5?: [number, number, number];
  color6?: [number, number, number];
  intensity: number;
  opacity?: number;
};

export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
  name: 'heatmap',
  uniformPropTypes: {
    delta: {value: [0, 1]},
    radiusPixels: {value: 20, min: 0, softMax: 100},
    colorDomain: {value: [0, 1]},
    color1: {value: [0, 0, 0]},
    color2: {value: [0, 0, 0]},
    color3: {value: [0, 0, 0]},
    color4: {value: [0, 0, 0]},
    color5: {value: [0, 0, 0]},
    color6: {value: [0, 0, 0]},
    intensity: {value: 1, min: 0.1, max: 10},
    opacity: {value: 1, min: 0, max: 1}
  },
  uniformTypes: {
    delta: 'vec2<f32>',
    radiusPixels: 'f32',
    colorDomain: 'vec2<f32>',
    color1: 'vec3<f32>',
    color2: 'vec3<f32>',
    color3: 'vec3<f32>',
    color4: 'vec3<f32>',
    color5: 'vec3<f32>',
    color6: 'vec3<f32>',
    intensity: 'f32',
    opacity: 'f32'
  },
  getUniforms: opts => {
    const {
      delta = [1, 0],
      colorRange = defaultColorRange,
      radiusPixels = 20,
      colorDomain = [0, 1],
      intensity = 1,
      opacity = 1
    } = opts as HeatmapProps & {delta: [number, number]};
    const [color1, color2, color3, color4, color5, color6] = colorRange;
    return {
      delta,
      color1,
      color2,
      color3,
      color4,
      color5,
      color6,
      radiusPixels,
      colorDomain,
      intensity,
      opacity
    };
  },
  dependencies: [random],
  fs,
  passes: [
    {sampler: true, uniforms: {delta: [1, 0]}},
    {sampler: true, uniforms: {delta: [0, 1]}}
  ]
};

1	import type {ShaderPass} from '@luma.gl/shadertools';	1✔
2	import {random} from '@luma.gl/shadertools';	1✔
3	import {Color} from '@deck.gl/core';	1✔
4	const glsl = (s: TemplateStringsArray) => `${s}`;	1✔
5		1✔
6	/**	1✔
7	* @filter Heatmap	1✔
8	* @param radiusPixels Blur radius in pixels, controls smoothness of heatmap	1✔
9	* @param colorDomain Domain to apply to values prior to applying color scale	1✔
10	* @param color1-6 Colors to use in color scale	1✔
11	*/	1✔
12		1✔
13	const fs = glsl`\	1✔
14	uniform heatmapUniforms {	1✔
15	vec2 delta;	1✔
16	float radiusPixels;	1✔
17	vec2 colorDomain;	1✔
18	vec3 color1;	1✔
19	vec3 color2;	1✔
20	vec3 color3;	1✔
21	vec3 color4;	1✔
22	vec3 color5;	1✔
23	vec3 color6;	1✔
24	float intensity;	1✔
25	float opacity;	1✔
26	} heatmap;	1✔
27		1✔
28	const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);	1✔
29		1✔
30	vec3 colorGradient(float value) {	1✔
31	vec3 c1;	1✔
32	vec3 c2;	1✔
33	vec2 range;	1✔
34	if (value < STOPS.x) {	1✔
35	range = vec2(0.0, STOPS.x);	1✔
36	c1 = heatmap.color1; c2 = heatmap.color2;	1✔
37	} else if (value < STOPS.y) {	1✔
38	range = STOPS.xy;	1✔
39	c1 = heatmap.color2; c2 = heatmap.color3;	1✔
40	} else if (value < STOPS.z) {	1✔
41	range = STOPS.yz;	1✔
42	c1 = heatmap.color3; c2 = heatmap.color4;	1✔
43	} else if (value < STOPS.w) {	1✔
44	range = STOPS.zw;	1✔
45	c1 = heatmap.color4; c2 = heatmap.color5;	1✔
46	} else if (value < 1.0 ) {	1✔
47	range = vec2(STOPS.w, 1.0);	1✔
48	c1 = heatmap.color5; c2 = heatmap.color6;	1✔
49	} else {	1✔
50	// Fade out to white	1✔
51	range = vec2(1.0, 10.0);	1✔
52	c1 = heatmap.color6; c2 = vec3(255.0);	1✔
53	}	1✔
54		1✔
55	float f = (value - range.x) / (range.y - range.x);	1✔
56	return mix(c1, c2, f) / 255.0;	1✔
57	}	1✔
58		1✔
59	const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);	1✔
60	const float MAX_VAL = SHIFT.z * 255.0;	1✔
61	const float SCALE = MAX_VAL / 8.0;	1✔
62	vec4 pack(float value) {	1✔
63	return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;	1✔
64	}	1✔
65	float unpack(vec3 color) {	1✔
66	return 255.0 * dot(color, SHIFT);	1✔
67	}	1✔
68		1✔
69	vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {	1✔
70	bool firstPass = (heatmap.delta.y < 0.5);	1✔
71	float accumulator = 0.0;	1✔
72		1✔
73	// Randomize the lookup values to hide the fixed number of samples	1✔
74	float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);	1✔
75		1✔
76	// Controls quality of heatmap, larger values increase quality at expense of performance	1✔
77	float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);	1✔
78		1✔
79	// Gaussian normalization parameters	1✔
80	float sigma = SUPPORT / 3.0;	1✔
81	float a = -0.5 / (sigma * sigma);	1✔
82	float w0 = 0.3989422804014327 / sigma; // 1D normalization	1✔
83	for (float t = -SUPPORT; t <= SUPPORT; t++) {	1✔
84	vec2 percent = (t * heatmap.delta + offset - 0.5) / SUPPORT;	1✔
85	vec2 delta = percent * heatmap.radiusPixels / texSize;	1✔
86	vec4 offsetColor = texture(source, texCoord + delta);	1✔
87		1✔
88	// Unpack float	1✔
89	float value = unpack(offsetColor.rgb);	1✔
90		1✔
91	// Gaussian	1✔
92	float weight = w0 * exp(a * t * t);	1✔
93		1✔
94	accumulator += value * weight;	1✔
95	}	1✔
96		1✔
97	if (firstPass) {	1✔
98	return pack(accumulator);	1✔
99	}	1✔
100		1✔
101	// Undo scaling to obtain normalized density	1✔
102	float density = 10.0 * heatmap.intensity * accumulator / SCALE;	1✔
103		1✔
104	// Domain also in normalized density units	1✔
105	vec2 domain = heatmap.colorDomain;	1✔
106		1✔
107	// Apply domain	1✔
108	float f = (density - domain[0]) / (domain[1] - domain[0]);	1✔
109		1✔
110	// sqrt/log scaling??	1✔
111	// float f = (log(density) - log(domain[0] + 1.0)) / (log(domain[1] + 1.0) - log(domain[0] + 1.0));	1✔
112	// f = sqrt(f);	1✔
113		1✔
114	// Color map	1✔
115	vec4 color = vec4(0.0);	1✔
116	color.rgb = colorGradient(f);	1✔
117		1✔
118	color.a = smoothstep(0.0, 0.1, f);	1✔
119	color.a = pow(color.a, 1.0 / 2.2);	1✔
120	color.a *= heatmap.opacity;	1✔
121		1✔
122	return color;	1✔
123	}	1✔
124	`;	1✔
125		1✔
126	const defaultColorRange: Color[] = [	1✔
127	[255, 255, 178],	1✔
128	[254, 217, 118],	1✔
129	[254, 178, 76],	1✔
130	[253, 141, 60],	1✔
131	[240, 59, 32],	1✔
132	[189, 0, 38]	1✔
133	];	1✔
134		1✔
135	export type HeatmapProps = {	1✔
136	/**	1✔
137	* Radius of the heatmap blur in pixels, to which the weight of a cell is distributed.	1✔
138	*	1✔
139	* @default 20	1✔
140	*/	1✔
141	radiusPixels?: number;	1✔
142	/**	1✔
143	* Controls how weight values are mapped to the `colorRange`, as an array of two numbers [`minValue`, `maxValue`].	1✔
144	*	1✔
145	* @default [0, 1]	1✔
146	*/	1✔
147	colorDomain?: [number, number];	1✔
148	/**	1✔
149	* Specified as an array of colors [color1, color2, ...].	1✔
150	*	1✔
151	* @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)	1✔
152	*/	1✔
153	colorRange: Color[];	1✔
154	/**	1✔
155	* Value that is multiplied with the total weight at a pixel to obtain the final weight. A value larger than 1 biases the output color towards the higher end of the spectrum, and a value less than 1 biases the output color towards the lower end of the spectrum.	1✔
156	*/	1✔
157	intensity?: number;	1✔
158	opacity: number;	1✔
159	};	1✔
160		1✔
161	export type HeatmapUniforms = {	1✔
162	delta?: [number, number];	1✔
163	radiusPixels?: number;	1✔
164	colorDomain?: [number, number];	1✔
165	color1?: [number, number, number];	1✔
166	color2?: [number, number, number];	1✔
167	color3?: [number, number, number];	1✔
168	color4?: [number, number, number];	1✔
169	color5?: [number, number, number];	1✔
170	color6?: [number, number, number];	1✔
171	intensity: number;	1✔
172	opacity?: number;	1✔
173	};	1✔
174		1✔
175	export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {	1✔
176	name: 'heatmap',	1✔
177	uniformPropTypes: {	1✔
178	delta: {value: [0, 1]},	1✔
179	radiusPixels: {value: 20, min: 0, softMax: 100},	1✔
180	colorDomain: {value: [0, 1]},	1✔
181	color1: {value: [0, 0, 0]},	1✔
182	color2: {value: [0, 0, 0]},	1✔
183	color3: {value: [0, 0, 0]},	1✔
184	color4: {value: [0, 0, 0]},	1✔
185	color5: {value: [0, 0, 0]},	1✔
186	color6: {value: [0, 0, 0]},	1✔
187	intensity: {value: 1, min: 0.1, max: 10},	1✔
188	opacity: {value: 1, min: 0, max: 1}	1✔
189	},	1✔
190	uniformTypes: {	1✔
191	delta: 'vec2<f32>',	1✔
192	radiusPixels: 'f32',	1✔
193	colorDomain: 'vec2<f32>',	1✔
194	color1: 'vec3<f32>',	1✔
195	color2: 'vec3<f32>',	1✔
196	color3: 'vec3<f32>',	1✔
197	color4: 'vec3<f32>',	1✔
198	color5: 'vec3<f32>',	1✔
199	color6: 'vec3<f32>',	1✔
200	intensity: 'f32',	1✔
201	opacity: 'f32'	1✔
202	},	1✔
203	getUniforms: opts => {	1✔
204	const {	×
205	delta = [1, 0],	×
206	colorRange = defaultColorRange,	×
207	radiusPixels = 20,	×
208	colorDomain = [0, 1],	×
NEW 209	intensity = 1,	×
210	opacity = 1	×
211	} = opts as HeatmapProps & {delta: [number, number]};	×
212	const [color1, color2, color3, color4, color5, color6] = colorRange;	×
213	return {	×
214	delta,	×
215	color1,	×
216	color2,	×
217	color3,	×
218	color4,	×
219	color5,	×
220	color6,	×
221	radiusPixels,	×
222	colorDomain,	×
NEW UNCOV 223	intensity,	×
UNCOV 224	opacity	×
UNCOV 225	};	×
UNCOV 226	},	×
227	dependencies: [random],	1✔
228	fs,	1✔
229	passes: [	1✔
230	{sampler: true, uniforms: {delta: [1, 0]}},	1✔
231	{sampler: true, uniforms: {delta: [0, 1]}}	1✔
232	]	1✔
233	};	1✔

visgl / deck.gl / 9464919793

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