Disabled external gits

cs457-gc/assignment_3_1/src/utils.py

@@ -0,0 +1,72 @@
+
+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]