73 lines
2.1 KiB
Python
73 lines
2.1 KiB
Python
|
|
import numpy as np
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# UTILITIES
|
|
# -----------------------------------------------------------------------------
|
|
|
|
def uv_grid(u_domain, v_domain, n_u, n_v):
|
|
"""Computes a triangulation of a u-v patch.
|
|
|
|
Parameters:
|
|
- u_domain : list of floats [u_min, u_max]
|
|
The u domain.
|
|
- v_domain : list of floats [v_min, v_max]
|
|
The v domain.
|
|
- n_u : int
|
|
The number of samplings in u direction.
|
|
- n_v : int
|
|
The number of samplings in v direction.
|
|
|
|
Returns:
|
|
- P : np.array (n_u * n_v, 2)
|
|
The sample points. The i-th row contains the (u, v) coordinates of
|
|
point p_i.
|
|
- F : np.array (2 * (n_u - 1) * (n_v - 1), 3)
|
|
Triangular mesh faces of the points P. This can be used for
|
|
visualization.
|
|
"""
|
|
G = np.arange(n_u * n_v).reshape(n_v, n_u)
|
|
v1 = G[:-1, :-1].flatten()
|
|
v2 = G[:-1, 1:].flatten()
|
|
v3 = G[1:, 1:].flatten()
|
|
v4 = G[1:, :-1].flatten()
|
|
F1 = np.column_stack((v1, v3, v4))
|
|
F2 = np.column_stack((v1, v2, v3))
|
|
F = np.vstack((F1, F2))
|
|
u, v = np.meshgrid(np.linspace(u_domain[0], u_domain[1], n_u),
|
|
np.linspace(v_domain[0], v_domain[1], n_v))
|
|
P = np.column_stack((u.flatten(), v.flatten()))
|
|
return P, F
|
|
|
|
|
|
def bgr_color(values):
|
|
"""Computes bgr colors of some values.
|
|
|
|
Parameters:
|
|
- values * np.array (#values, )
|
|
|
|
Returns:
|
|
- rgb : np.array(#values, 3)
|
|
"""
|
|
val = np.array(values)
|
|
expansion = .5
|
|
X = np.linspace(0, 1, 64)
|
|
increase = 255 * (X ** expansion)
|
|
decrease = increase[::-1]
|
|
one = 255 * np.ones(64)
|
|
zero = np.zeros(64)
|
|
lut = np.ones((256, 3)).astype(float)
|
|
B = np.hstack((one, decrease, zero, zero))
|
|
G = np.hstack((increase, one, one, decrease))
|
|
R = np.hstack((zero, zero, increase, one))
|
|
lut[:, 0] = R / 255
|
|
lut[:, 1] = G / 255
|
|
lut[:, 2] = B / 255
|
|
lut[-1, :] = [255, 0, 255]
|
|
max_val = np.max(np.abs(values))
|
|
if max_val == 0:
|
|
max_val = 1
|
|
val = np.round(val / max_val * 127).astype('i') + 127
|
|
return lut[val]
|