Hair - Computer Graphics

Peter HU, Nov 2024.

Dataset

• head mesh: avatar online
• USC-HairSalon (2015)
  • online game assets
  • ELECTRONIC ARTS, 2014
  • Newsea SIMS
• Single-view-hair (2015)

Codebase

• PERM (2024)
  • augment USC-HairSalon
• CT2Hair (2023)
• HAAR (2023)
  • NeuralHaircut (2023) for strand-based prior model;
• Hairstep (2023)

others: Embodied Hands (MANO) & Body (SMPL)

Representation

TODO: more recent papers, relationship with renderer, conversion between reps.

• hairstyling (modeling) + hair simulation + hair rendering
• Shape category: long, curly or wavy hair / short, straight
• A Survey on Hair Modeling: Styling, Simulation, and Rendering, K. Ward et al., 2007
• A Survey of Image-Based Techniques for Hair Modeling, Y. Bao, 2018
• Tutorial
  • Kajiya Kay Model, Modified Marschner Model
  • Advanced Techniques in Real-time Hair Rendering and Simulation, Siggraph Course 2010

Geometric based

poly line: a set of connected line segments

To reduce the large number, key/guide hairs + population

• a portion of all hair strands (key hairs) and
• populating the rest based on the explicitly modeled ones.

Single Strand Interpolation creates hair strands around each explicitly modeled curve based on the shape of the curve. Wisps and generalized cylinder based techniques use this approach for generating a complete hair model.

Multi Strand Interpolation creates hair strands in-between a number of explicitly modeled curves by interpolating their shapes.

cons: limited hairstyles, lack details

curve

curve + thickness, e.g. sine waves, B-spline, Catmull-Rom spline

It ignores the details of the tubular shape of hair fibers, which is often unimportant, because, in most cases, the projected thickness of a hair strand is less than the size of a pixel on the screen.

Rendering (line segment and cylinder)

reference: Rendering fur with three dimensional textures, J. T. Kajiya, 1989

the first shading model for hair rendering, widely cited.

• the diffuse component: the Lambert shading model w.r.t small cylinder by integration.
• the specular component: an ad hoc model for for cylindrical surfaces similar to the Phong light reflection model.
  • or (unnecessarily) convert the surface micro-geometry to be represented in the volume directly to lighting models.

u-shaped strips

reference: An Enhanced Framework for Real-time Hair Animation, W. Liang et al., 2003.

Real-time conversion that project each vertex onto the scalp (spheres) and connect the vertices with their projections.

thin shell volume

reference: A Thin Shell Volume for Modeling Human Hair, T. Kim et al., 2000.

surface + cylinder + particles (under constraints for hair-hair interaction)

Rendering

• shading model (line segment, see above).
• antialiasing (line segment) via super-sampling, where each time shifting the image plane slightly.

wisp

reference: A system of 3D hair style synthesis based on the wisp model, L. Chen et al., 1999.

cylinder or trigonal prism

Rendering

The illumination is given by ambient, diffuse and specular terms, $\theta$ is the angle between incoming light and normal, $\phi$ is the angle between normal and view point,

$$C_h = L_a K_a + \sum_i L_i [K_d \cos\theta + K_s \sin^n(\theta+\phi-\pi)]$$

• for dry and black hair, reduce the weight of $K_s$ and $K_a$ but emphasize $K_d$.
• This lighting model still has its limitations, however, such as the lack of a back light visual effect.
• compute for three control lines of each wisp + interpolation for those strands within one wisp.

Modified shadow Z-buffering method (shadow mask).

• 3D data $x,y,z$ instead of depth. Assigning an effective radius to every point, we union these balls, forming a mask-like.
• Complexity $O(\# \text{ objects}) \rightarrow O(\# \text{ 2D array})$.

Artificial objects (e.g. hair pins, hair bands, ponytails, and braids)

• give some wisps a certain restriction. These wisps are required to pass through a region of 3D space.
  • For example, we can get a ponytail if we let the control lines of a group of wisps pass through a little circle behind the CG character's head.
  • Handling a braid is a little tricky. A braid is heavier and stiffer than a single hair strand or wisp. It basically consists three wisps. A repeated loop changes the positions of these three wisps. (However, they do not really have to be three individual wisps. They may be just three branches of one wisp. They may also consist of several wisps separately.)

generalized cylinder

reference: Interactive Multiresolution Hair Modeling and Editing T. Kim et al., 2002

With a space curve $\mathbf{C}(t)$ and series of contours $\mathbf{R}(\theta, t)$ along the curve, GC defines the boundary of a hair cluster when $r=1$,

$$\mathbf(r, \theta, t) = \mathbf{C}(t) + r \mathbf{R}(\theta, t) [\mathbf{N}(t) \cos\theta + \mathbf{B}(t) \sin\theta]$$

, where we define coordinate frame of the curve $T(t)$ to be the tangent vector, $N(t)$ to be the principal normal vector, and $B(t)$ to be the bi-normal vector. $\theta$ as the angle around the tangent vector $T$, starting from the principal normal $N$.

• auxiliary scale: add scale $s_N, s_B$ to two orthogonal directions.
• auxiliary twist: $\hat{\theta} = \theta + \mathbf{W(t)}$, updating the rotating angles of contours along the curve.

$$\mathbf{R}(\theta, t) [ s_N \cdot \mathbf{N}(t) \cos\hat{\theta} + s_B \cdot \mathbf{B}(t) \sin\hat{\theta} ]$$

When $t=0$, the hair strand is on the scalp (head model). Catmull-Rom spline curve for smoothness.

multi-resolution: after GC, he/she subdivides each hair cluster, adding more detail until the desired appearance is achieved.

Rendering:

• OpenGL poly line
• shading: use the model for line segment (see above) and disable the lighting calculation in OpenGL.
  • The shaded color is computed at each point of the line segments and colors are interpolated with OpenGL.
  • Other shading models such as that in [Goldman 1997] could be equally applicable.
• self-shadowing: use opacity shadow maps algorithm [Kim and Neumann 2001], a fast approximation of deep shadow maps [Lokovic and Veach 2000].
  • since shadows are view-independent, they can be computed once and cached for reuse while the user interactively changes views.
• antialiasing: drawing order based on the distance from the camera, inspired by [Levoy and Whitted 1985].
  • OpenGL antialiased line drawing option alone is not sufficient.

mesh

reference: Hair mesh, C. Yuksel et al, 2009

Layers of polygonal meshes set $\sum_{k=0}^N F^{k}$, which typically contain quadrilateral or triangular faces, with no restrictions on the types of polygons used. Layer at $k$ has one-to-one correspondence to a face at $k+1$.

• support Face Delete, Layer Insert / Remove, Edge/ Vertex Separate.

Volumetric based

basic element: voxels grid or bounding box.

pros: efficient spatial-aware intermediate representation to encode hair, for all sorts of downstream tasks.

cons: when hair animates, such volumes should be updated for every frame, making pre-filtering inefficient.

reference: Hair-GAN: Recovering 3D hair structure from a single image..., M. Zhang, 2019, etc. [full lists at PERM (2024) §2. related work.]

3D volumetric field, grid of shape $n_x \times n_y \times n_z= 128 \times 192 \times 128$, aligned each hair model to a unified bust model within a volumetric bounding box.

• occupancy field (binary True and False), confidence map for reverse work
• flow vector field / orientation field
  • see above
• hierarchical (top-down approach)
  • see above multi-resolution

Vector field (points)

For each grid vertex $\mathbf{v_i}$, Laplace operator $\Delta(\mathbf{v_i}) = \sum_{j \in N(i)} (\mathbf{t_j}-\mathbf{t_i})$ is adopted in mesh editing for smooth deformation. Minimize with constraint index set $C$,

$$E(\mathbf{t_1}, ..., \mathbf{t_n}) = \sum_i || \Delta (\mathbf{t_i}) ||^2 + \omega \sum_{i \in C} || \mathbf{t_i} - \mathbf{c_i} ||^2$$

• weighted tangent vectors, $grad(f) = \nabla f$
• iteratively re-weighted least square of a linear system

reference: Example-Based Hair Geometry Synthesis, L. Wang, 2009

• (achieved) First, when hair roots are close on the scalp surface, corresponding strands tend to form wisps with similar geometry.
• (aim to solve) Second, every hair strand has a curved trajectory in the hair volume and ( those from different hair roots, but) spatially close portions of the trajectories tend to share similar tangent vectors. <- added

Volume density function

reference: Hypertexture, K. Perlin, 1989.

Rendering

Volume rendering with

• object density functions $D(x) \in [0,1], x \in \mathbb{R^3}$
• density modulation functions for soft regions $D(x) \in (0,1)$.
  • bias to push up/down, variance gain (gradient flatter or steeper), noise, turbulence, $|x|$, $sin(x)$.

$$\text{Hypertexture} = f_n ( . . . . f_2 (f_1 (f_0 (D(x)))))$$

Pros: a significant reduction of storage requirements + naturalness of the transparent property of hair regions.

Cons: relatively slow rendering performance $O(n^3)$, typically a few hours as originally reported (1999); despite its power, one does not have an explicit control over its shape, but

reference: The Cluster Hair Model, X. Yang et al., 2000.

Embed a volume density model into a generalized cylinder.

• Each cluster is first approximated by a polygonal boundary (mask).
• When a ray hits the polygonal surface, predefined density functions are used to accumulate density. By approximating the high frequency detail with volume density functions, the method produces antialiased images of hair clusters.
• Cons: this method does not allowchanges in the density functions, making hairs appear as if they always stay together.

Complex fluid flow

reference: Interactive Hair Styler based on Fluid Flow, S. Hadap et al., 2000, P87.

explicit control + reduce complexity + volumetric

Ideal flow with elements: stream + source / vortex

• incompressible (density won't change)
• stable, inviscid (no viscosity)
• ir-rotational

Laplace equation (PDE) $\nabla^2 \phi = 0$, where potential $\phi$ and velocity $\vec{V} = \nabla \phi$.

• complex flow, i.e. linear combination $\sum_i \vec{V_i}$ defined by user (as the sum of sols to PDE is also a valid sol.)
• small sources along the the boundary panel $p_i$, each having $\lambda_j$ contributions, $\sum_j \lambda_j \vec{S_j}$ (obstacle avoidance)
  • $\vec{V(p_i)} \cdot \hat{n_i} = b_i$, streamline will be parallel to the boundary surface, except the starting point.
  • solve $\lambda_j$, given the other variables are const.
  • compute for the coarse grid and subdivision flow for points within (cheaper computation) and combine with volume density function (noise / perturbations).

Rendering

volume rendering / visualization techniques

Texture based

Texture mapping the surfaces with hair images and using alpha mapping to create fake illusion of hair strands.

Conversion

reference: Single-view hair modeling using a hairstyle database, Hu et al., 2015

Pose transformation (fixed standard head model) via translating, rotating and/or scaling. (flipping symmetrically in the end)

Mesh ---- uniform sampling -----> hair strands ----> 3D orientation field -----> hair strands

Each strand is represented as a set of equally spaced sample points. Guided by the diffused 3D orientation field, smoothly diffuse the field into the entire 3D volume as proposed by Paris et al. [2008].

reference: Hair-GAN: Recovering 3D hair structure from a single image..., M. Zhang, 2019

polygon-strips --------> dense 3D orientation volume

Low-quality hair

• idea1: texture based (IQOO 13 hardware)
• idea2: downsample hair + boundary (guide strands)
• idea3: sketch from users.
• idea4: fitting to surface (with somehow good quality)
  • it is very difficult to get realistic results with surface approximations of hair for most hair models.

Renderer

High-quality hair

• Blender (ok, mesh 1GB...)
• Mitsuba (doesn't support)
• poly line in OpenGL (TODO)

Rendering techniques

• shading model (diffuse + specular)
  • Kajiya Kay Model (1989), Modified Marschner (2003) Model
  • modified illumination for line segment, cylinder
• multiple scattering
  • path tracing ~ 100 hours
  • photon mapping ~ 1.5 hours
  • spherical harmonics in a grid ~ 30 minutes
  • dual scattering ~ 20 fps
• shadow
  • depth test or z-buffer (with modification)
  • deep shadow maps [Lokovic and Veach 2000]
  • opacity shadow maps algorithm [Kim and Neumann 2001]
  • density clustering [Mertens et al. 2004]
  • deep opacity maps [Yuksel et al. 2008]
  • self-shadowing is essential for volumetric hair.
• antialiasing
  • since hair strands are very thin, it is important to draw them smoothly with correct filtering.
  • depend on the drawing order [McReynolds 1997]
• color and texture
  • artificial objects (e.g. hair pins, hair bands, ponytails, and braids)
  • interpolated colors
• level of detail (LOD)

Blender conversion steps

1. Verify the Converted Hair

   After converting hair (via Object > Convert > Mesh or similar), inspect the result in Edit Mode. You will see vertices along the strands but no faces or thickness.

2. Convert to Curve

   Select the hair mesh in Object Mode. Go to the Object menu: Object > Convert To > Curve from Mesh/Text. This converts the vertex strands into curves, making them easier to manipulate.

3. Add Thickness to the Curves

   Go to the Object Data Properties (the green curve icon in the Properties Panel). Under the Geometry section, locate the Bevel subsection. Adjust the Depth value to add thickness to the strands. Use the Resolution slider to refine the shape.

4. Convert Back to Mesh (Optional)

   Once the curves have the desired thickness, convert them back to a mesh: Object > Convert To > Mesh from Curve/Meta/Surf/Text.