Curl Noise Jittering

We propose a method for implicitly generating blue noise point sets. Our method is based on the observations that curl noise vector fields are volume-preserving and that jittering can be construed as moving points along the streamlines of a vector field. We demonstrate that the volume preservation keeps the points well separated when jittered using a curl noise vector field. At the same time, the anisotropy that stems from regular lattices is significantly reduced by such jittering. In combination, these properties entail that jittering by curl noise effectively transforms a regular lattice into a point set with blue noise properties. Our implicit method does not require computing the point set in advance. This makes our technique valuable when an arbitrarily large set of points with blue noise properties is needed. We compare our method to several other methods based on jittering as well as other methods for blue noise point set generation. Finally, we show several applications of curl noise jittering in two and three dimensions.

Figure 1: Points on a lattice are displaced by advecting them along a curl noise vector field.It is possible to efficiently find the closest jittered point to a given query point, and the jittered points have blue noise properties.The jittered points can be used for sampling, procedural texturing, or defining cellular materials (in 2D or 3D).The images on the right show a procedural texture based on Worley noise and a copper foam generated from our curl noise jittered points.

ABSTRACT
We propose a method for implicitly generating blue noise point sets.Our method is based on the observations that curl noise vector fields are volume-preserving and that jittering can be construed as moving points along the streamlines of a vector field.We demonstrate that the volume preservation keeps the points well separated when jittered using a curl noise vector field.At the same time, the anisotropy that stems from regular lattices is significantly reduced by such jittering.In combination, these properties entail that jittering by curl noise effectively transforms a regular lattice into a point set with blue noise properties.Our implicit method does not require computing the point set in advance.This makes our technique valuable when an arbitrarily large set of points with blue noise properties is needed.We compare our method to several other methods based on jittering as well as other methods for blue noise point set generation.Finally, we show several applications of curl noise jittering in two and three dimensions.

INTRODUCTION
Sampling points in a 2D or a 3D domain is a common task in computer graphics.Several applications favor so-called blue noise sampling [Ulichney 1988].Since colors of noise are defined in analogy with colors of light, blue means that the spectrum of the noise predominantly contains high frequencies.Spatially, this translates to point samples spread isotropically and evenly over the domain so that no two points are too close together.When using point collections for applications such as procedural generation of cellular materials or foams, distributing scattered objects, or sampling, broadly, blueness is an important property.
Poisson disk sampling [Cook 1986], also known as random sequential adsorption [Feder 1980], is a classical algorithm for computing a blue noise sampling.The principle is to generate random points but reject anyone too close to a previously added point.Figure 4 (rightmost column) shows an example of a Poisson disk sampling.Compared to jittering points on a regular grid, the corresponding frequency spectrum is "bluer", i.e., there is a wider gap between the central peak and the halo of noise surrounding it.
The rejection scheme used in the original Poisson disk sampling is slow -especially as the domain starts filling up, and more sampled points are likely to be rejected.Subsequent works have significantly improved computational efficiency and blue noise sampling quality.However, almost all approaches require the entire point set to be computed and stored.This is unsuitable for applications where we only seek to determine a small subset of sample points or where storing the entire point set is infeasible.Applications that require this property usually resort to approaches based on jittering, where points within a grid are randomly perturbed within each grid cell [Cook 1986].This makes it possible to find the closest sample by inspecting only the jittered positions of lattice points within a certain distance of the query point, and the positions of the rest of the points do not need to be computed.
In this paper, we refer to a method for generating a point collection as implicit when it provides the point closest to a query point without generating the entire collection and independently of the size of the collection.Our key insight is that displacing the points of a regular lattice along a curl noise [Bridson et al. 2007] vector field enhances the blue noise sampling quality (Figure 1).Since the displacements are small, our method can be considered a jittering approach, and it is possible to define an implicit method for generating point collections jittered by curl noise.
Curl noise is a divergence-free vector noise designed to emulate the velocity field of incompressible, turbulent fluids.Because curl noise is divergence-free, it contains neither sources nor sinks, which is important for our purposes.We carefully choose the curl noise parameters to achieve a balanced tradeoff between point set quality and computational efficiency.Notably, our method significantly improves the blue noise quality compared to prior works based on jittered grid sampling (see Figure 4).
An implementation of our method can be found at https://github.com/jonasmb/curlnoisejittering.
In summary, we provide the following contributions: • Curl Noise Jittering (CNJ): an implicit method for computing 2D and 3D blue noise point distributions.• A study of the suitable parameters of CNJ to improve sampling quality while preserving computational efficiency.• An evaluation of the benefits of CNJ for implicit material modeling and rendering.

Related Work
In this section, we review and compare prior methods and applications for point sampling in the context of computer graphics.
Poisson disk sampling.A widely used method considers a Poisson disk sampling in which any two points are separated by a minimum distance [Cook 1986] that results in a blue noise sampling.The standard dart-throwing algorithm consists of iteratively placing points that are separated from each other by a minimum distance.Several works have studied efficient algorithms for Poisson disk sampling [Dunbar and Humphreys 2006;Bridson 2007;Wei 2008;Ebeida et al. 2011;Corsini et al. 2012;Yuksel 2015], and most of them are summarized in surveys [Lagae and Dutré 2008;Yan et al. 2015].Poisson disk sampling algorithms are typically iterative processes that do not lend themselves to efficiently determining a subset of points lying in a given subspace.
Optimization-based methods.A broad class of sampling methods seek to optimize the position of a set of points to obtain blue noise.A popular method is Lloyd's algorithm [Lloyd 1982], in which the points are iteratively moved to the centroid of their corresponding Voronoi cells.Lloyd's algorithm was enhanced with the capacityconstrained point distribution method [Balzer et al. 2009] and subsequently improved through the lens of optimal transport [De Goes et al. 2012;Qin et al. 2017].Fattal [2011] introduced an interacting particles model based on statistical mechanics.Similarly, Jiang et al. [2015] proposed a sampling algorithm based on smoothed particle hydrodynamics.Heck et al. [2013] proposed constructing sampling patterns with prescribed spectral properties by iteratively updating the point positions.Recently, Ahmed et al. [2022] presented an optimization method based on placing a set of Gaussian kernels on the sample points and defining an objective function that can be minimized with gradient-descent and that leads to a blue noise distribution.While delivering high-quality results, optimization-based methods eventually become inefficient as the number of samples increases and do not allow efficient retrieval of the points in a given subspace.
Tile-based methods.Another set of methods partitions the 2D space with tiles to sample points.For instance, by subdividing a Penrose tiling [Ostromoukhov et al. 2004], by precomputing and optimizing a set of tiles containing points [Hiller et al. 2001;Lagae and Dutré 2005;Kopf et al. 2006;Ahmed et al. 2017], by tiling with polyominos [Ostromoukhov 2007], hexagons [Wachtel et al. 2014], or AA optimized patterns [Ahmed et al. 2015].To the best of our knowledge, tiling approaches only considered the 2D case since its most typical application is digital half-toning and rendering.
Low-discrepancy sequences.Another class of efficient methods is based on generating so-called low discrepancy sequences, which are of interest for Monte Carlo integration [Pilleboue et al. 2015].Classical examples are the Halton [1964], Hammersley [1964] or Sobol [1967] sequences.Recent work considered scrambled Morton ordering [Ahmed and Wonka 2020], improving Sobol in lower dimensions [Paulin et al. 2021], or optimizing and exploring a space of sequences named dyadic nets [Ahmed and Wonka 2021;Ahmed et al. 2023].It is possible to find the coordinates of a point in a given stratum of a (0, , 2) dyadic net containing 2  points in  () time.This entails that a logarithmic time algorithm for locating the closest point in a dyadic net is feasible, provided that the binary flags that determine the net can be computed in constant time.Unfortunately, this means that an optimized dyadic net, e.g. a Blue Net [Ahmed and Wonka 2021], does not seem to admit an efficient query for the closest lattice point.
Error-diffusion methods.Blue noise is intimately related to the application of digital halftoning [Ulichney 1988], which seeks to depict a grayscale image by varying the size or the distribution of tiny black dots arranged in a regular pattern.Different techniques based on error diffusion [Floyd and Steinberg 1976], in which a quantization error is distributed among pixels, have considered blue noise samplings [Lau et al. 2003;Ostromoukhov 2001].Again, such algorithms are inherently iterative and do not allow for the implicit identification of points in a subset of the space.
Jittered-grid methods.Some approaches have explored how to enhance the original jittering method.For instance, to modify the jittering in order to improve the projected sampling onto the vertical or horizontal line with multi-jittering methods [Chiu et al. 1994;Christensen et al. 2018].Similarly, Kensler [2013] used correlated jittering of rows and columns.Klassen [2000] proposed to smooth the result by considering the average perturbation between the neighbors of a grid cell.Dammertz [2009] considered jittering rank-1 lattices with Lloyd's algorithm.Our method is also an improved jittering method, but it significantly improves the blue noise quality compared to Klassen [2000] and Kensler [2013], see Figure 4.
Jittered grid and procedural noises.Jittered grids have endured the test of time thanks to their efficient, implicit, and simple formulation, and numerous procedural texturing methods use jittering to implicitly retrieve a local neighborhood of samples around a query point.For instance, Worley noise [Worley 1996] and its descendants [Martínez et al. 2016] are examples of procedural cellular structures relying on a jittered grid.Our technique improves the quality of Worley noise, leading to better visual results while incurring a slight loss of efficiency (see Figure 5).Worley noise is one example among many other procedural methods based on jittering that may directly benefit from our method.

CURL NOISE JITTERING IN 2D
We define jittering as the process of displacing the points, , of a regular lattice by a small amount to obtain a less regular set of points,  * .Regular lattices are typically formed as the vertices of tilings of the plane.While quadrangular tilings are often used, we observe that the densest packing of circles [Fejes 1942] is obtained by associating a circle with each vertex of a triangular tiling, which also has six-fold symmetry rather than four-fold.Moreover, initial experiments gave better results for this type of lattice.Hence, we use lattices formed as the vertices of triangular tiling, as shown in Figure 1 (left).
We can obtain the jittered points in two ways.We can generate  * directly by computing the displacement for each point p ∈  and storing the jittered point p * ∈  * .This is the most efficient option if  is known in advance and of acceptable size.However, the benefit of methods based on jittering is that we can generate  * implicitly.Namely, we can find the point p * ∈  * closest to a given query point x without generating  * .
For implicit evaluation, the portion of the lattice that we need to inspect depends on the largest possible jitter displacement, which we will denote the jitter radius,   .Say, p ∈  is the lattice point closest to the query point x.The distance to the corresponding jittered point, p * , is at most   + ∥x − p∥.Thus, the closest jittered point must lie within a disk of radius   + ∥x − p∥ centered at x (see Figure 2).We need to inspect all lattice points whose disks of radius   intersect the disk at x.In practice, this set includes neighbors (i.e., adjacent lattice points), second-order neighbors, and, in rare cases, third-order neighbors of p.
Jittering can be construed as moving the points of the initial lattice along a vector field.Expressed in this fashion, p * is obtained by tracing a streamline starting at p from time  = 0 till  = 1, Closest lattice point in blue.The first-order neighbors are light grey, and the second-order neighbors are dark grey.The closest jittered point must lie within the disk centered on the closest lattice point.where the curve C p is the streamline defined in terms of the differential equation and V is the vector field determining how points are displaced.In the case of traditional random jittering, we can consider V constant within each subdomain.The subdomain would typically be the pixel or, more generally, the Voronoi region around the point.As the streamline tracing method, we choose a 4th order Runge-Kutta method (RK4) [Runge 1895] which improved on taking an Euler step (see Figure 7); a deeper investigation into streamline tracing methods could yield further improvements.
The advantage of interpreting jittering as streamline tracing is that we can now consider ways to obtain vector fields that lead to better blue noise quality.We posit that divergence free vector fields would be advantageous since such vector fields do not contain sources or sinks which, respectively, repel and attract the points, leading to uneven distributions of points.In addition to being divergence-free, the vector field we seek must be noisy in the sense that it has no manifest anisotropy, since this would likely show in the jittered points.In other words, we claim that a noisy but divergence-free vector field can lead to jittered point sets where the points are regularly distributed while the anisotropy of the original grid is greatly reduced.See Section 2.4 for further discussion.
Unfortunately, the requirement that the vector field be divergencefree rules out some apparent candidates.For instance, neither the gradient field of a noise function, nor smoothly interpolating random vectors would produce a divergence-free vector field.

Curl Noise
There is, however, a method for generating noisy yet divergencefree vector fields.This method, due to Bridson et al. [2007], is known as curl noise.The curl, ∇×, of a 3D vector field, For 2D curl noise, we will assume that Φ = [0, 0,  ] for some noise function  : R 3 → R.This means that In other words, since Φ is orthogonal to the -plane, the curl, ∇×Φ, lies in the -plane.Moreover, ∇ × Φ, is known to be divergencefree because of the equality of mixed partial derivatives (Clairaut's Theorem).Due to this property, flows that follow ∇ × Φ are volumepreserving, and for our purposes, this ensures that the vector field is free of sinks and sources.
As an aside, we note that in 2D, the streamlines of ∇×Φ are simply the iso-contours of  , which means that any particle following such a trajectory, with sufficient numerical precision, will eventually return to its starting point.

Curl Noise Jittering
We can now formulate curl noise jittering operationally, where Thus, cnj is governed by three parameters: the noise function  , the noise scale , and finally the time  for which we trace along the streamline.

Noise Functions
The choice of underlying noise function is essential when implementing curl noise and, by extension, curl noise jittering.It is important that the noise function is band limited, stationary, and isotropic [Perlin 1985;Lagae et al. 2010]; it is also a requirement that we can efficiently compute derivatives of the noise function.
We have tested three different noise functions that adhere to these requirements: • Sparse convolution noise (SC) [Lewis 1984[Lewis , 1989].
• Perlin noise [Perlin 1985[Perlin , 2002]].For Perlin noise, we adapt an implementation by Iñigo Quilez1 that includes computation of derivatives.Our implementation of sparse convolution noise is based on a version that can be evaluated locally [Frisvad and Wyvill 2007], and that has been described in a closed formula [Luongo et al. 2020] for which it is easy to find derivatives.Sine functions are easily differentiable.The principle of SoS is to construct an D function by superposing D waves.Max [1981] discusses how this can be used to construct models of water waves, and Schachter [1981] describes a similar model for narrow-band noise.In our formulation, SoS noise is based on waves of the form where  is the amplitude and  is the phase of the wave, while d = 2  n is a frequency vector in which  is the wavelength and n is the unit length direction of the wave.SoS noise is defined by where  is the set of parameter tuples.For each tuple, we generate the parameters by first sampling the random variables,  ∼ N (0, ) from a normal distribution and ,  ∼ U (0, 2) from a uniform distribution.Next, we compute d = ( + ) [cos(), sin()] and  = exp(−2 / 2 ).Thus, the amplitude is largest for waves with a

Quality Measures and Parameter Selection
Curl noise jittering is motivated by the premise that displacing the points of a lattice along a curl noise vector field will imbue the points with blue noise properties.This hypothesis is based on the observation that flow along a curl noise vector field is volume-preserving because the field is divergence-free.While volume preservation does not imply preservation of point distances, it does guarantee that there are no sinks or sources which, respectively, attract or repel the points when transported along the field for a short time.This leads us to assume that the point spacing of the lattice would be preserved to some extent for (short) flows along the vector field.
Yet, the regularity of the lattice, and hence anisotropy, is diminished because the vector field is a noise function.
However, it appears hard to provide a formal argument.Instead, we offer a quantitative metric for blue noise properties.This metric is used to assess the quality of CNJ as well as competing methods and to tune the parameters of our method.Specifically, it is important to select an appropriate time step (as discussed above) and noise scale.If the noise scale is extremely coarse, the lattice is locally translated, and the lattice structure remains visible.In contrast, if the scale is too fine (i.e., the frequency is too high), the method devolves to random jittering.
Our quantitative analysis is based on the point set analysis framework (PSA) [Schlömer and Deussen 2011;Heck et al. 2013], which is commonly used in related work, e.g.[Ahmed et al. 2022].We briefly recall the different metrics in the following.We refer the reader to Heck et al. [2013] for further details.
The power spectrum of a signal, such as a point process, is the Fourier transform of the autocorrelation function of the signal, and it can also be computed directly as the absolute square of the Fourier transform of the signal.Useful statistics can be derived by partitioning the power spectrum into concentric annuli of width Δ, and then averaging the spectrum samples within each annulus   of central radius  [Schlömer and Deussen 2011].The radially averaged power spectrum  (  ) measures the average of the power spectrum in some annulus   .The anisotropy is defined by (  ) =  2 (  )  (  ) , where  2 (  ) is the sample variance of the power spectrum in some annulus   .Lower anisotropy values indicate that the power spectrum is close to being radially symmetric; thus, the resulting point process is close to isotropic.We define the power-weighted mean anisotropy, where the first annulus  = 0 containing the zero frequency is excluded.The largest frequency  so that the average energy in the power spectrum up to  stays below 0.1 is called the effective Nyquist frequency and denoted  eff .Intuitively, frequencies below  eff can be sampled and reconstructed with little error, while frequencies above lead to aliasing.Now, we define the quality of a point set as the ratio of the effective Nyquist frequency to mean  anisotropy, where  is the edge length of the regular lattice, i.e., the distance between two neighboring points.Thus,  is proportional to the effective Nyquist frequency and inversely proportional to the average anisotropy -unless the maximum displacement due to jittering exceeds the edge length of the lattice.Assigning  = 0 for   ≥  is important for the implicit generation of  * : the greater   , the more grid points could beget the closest jittered point.If   < ,  balances the two requirements that the jittered points are well separated ( eff large) and isotropy ( ā small).
In Figure 3,  eff , ā, and  are plotted as a function of time step  and noise scale  for the three noise functions considered.Based on the underlying (30 × 30) grids of quality values, the maximum was found for each function, and the results are presented in Table 1.Perlin noise has the highest quality and is less computationally demanding than the other noise functions.Hence, it was selected for our 2D experiments.Note that the scale  is the ratio of the side length of the Perlin noise grid to the distance between lattice points.

Implementation
The direct 2D method for curl noise jittering was implemented in Python for all three noise functions.Our code interfaces to the PSA library2 , which is used for the quality metric.Our code also interfaces to the CCVT library3 and the dyadic nets4 library, both of which were used for comparison.The performance of the direct methods was evaluated on a single Apple M1 core.
The implicit 2D curl noise jittering method is implemented in GLSL on the ShaderToy platform.This implementation employs only Perlin noise and runs at 2.04 ms per frame in 1080p resolution when using an NVIDIA RTX 3090 GPU.We found that in practice, we do not need to check the distances between lattice points and query points if we jitter all neighbors up to the second order.

Comparisons
Like all methods based on jittering, CNJ places each point without considering the positions of nearby points and can hence be evaluated implicitly.We compare CNJ to two other methods based on jittering and three methods that consider the local neighborhood.The jittering-based methods are clearly the most similar to ours, while methods that consider neighboring points can provide very high quality.We also included iterative curl noise jittering ICNJ in this comparison.The iterative method applies jittering with a time step that is halved in each iteration (and we used 64 iterations).The noise scale is the same for all iterations, but the noise is different each iteration (since we add an offset).
From the category of jittering based methods, we compare against Kensler's correlated multi-jittered (CMJ) sampling approach [Kensler 2013].The principle is that each row and each column is jittered with a sequence of perpendicular displacements.Since the displacements are identical for all rows (columns), neighbors along each row (column) are never closer than the edge length of the grid.We also compare against the smoothed jittering (SJ) of a triangular lattice proposed by Klassen et al. [2000].
From the category of non jittering-based methods, we compare against the Blue Nets (BN) method [Ahmed and Wonka 2021], capacity-constrained Voronoi tessellations (CCVT) [Balzer et al. 2009] and the fast Poisson disk sampling (PDS) method proposed by Robert Bridson [2007].
For each of these seven methods, we show the point clouds and their associated power and radial spectra in Figure 4. We also computed our quality measure,  * , the L2 norm of star-discrepancy [Wang and Sloan 2008], and timings, all averaged over 100 runs.These results are shown in Table 2, which also includes the programming language used.CCVT attains the highest quality.This is unsurprising since this method uses information about the neighborhood to optimize positions.ICNJ and regular CNJ are second and third, respectively.In most cases, the slightly increased quality of ICNJ would not justify the increased computational cost.Blue Nets is only in fourth place due to a comparatively high anisotropy.However, the discrepancy of the Blue Nets method is less than half that of its closest competitor.Low discrepancy is a trait that appears to be shared by (0, , 2) nets in general; such nets can be generated very quickly using the Netshuffle algorithm of Ahmed and Wonka [2021], albeit dyadic nets do not have blue noise properties unless they are optimized.
CNJ and ICNJ are the only methods that can be evaluated implicitly (all based on jittering) with a low anisotropy.In general, isotropy is challenging to achieve with jittering since a regular lattice exhibits high anisotropy.It is perhaps more surprising that while Poisson disk sampling has the lowest anisotropy of all methods, its  eff is also very low, and the overall quality is inferior to CNJ.

Applications and Extensions
Steven Worley [1996] proposed a method for texturing based on distances to randomly scattered points, which can be used to model the appearance of objects with cracked or segmented surfaces.In Worley's original formulation, points were computed on the fly by hashing the value of a grid cell to a random point within each cell.With curl noise jittering, we can produce a more even distribution of points leading, in turn, to a more regular cellular structure than in the original method, as shown in Figure 5.All images in Figure 5 were generated in ShaderToy using the implicit method.In the top row, the color is based purely on the distance to the closest point.In the bottom row, the difference between the distance to the closest and second closest point is used to generate the line color.The position of the closest jittered point is hashed to cell color.
We implemented the direct method in a Blender script to generate a distribution of boxes, see Figure 6 (right).A similar distribution generated by using Blender's built-in Poisson disk sampling is shown on the left.While the differences are subtle, our method seems to produce a slightly more even distribution.

CURL NOISE JITTERING IN 3D
An important difference in 3D is that we need a vector-valued noise (a 3D vector field is needed to take the curl in 3D).In the case of Perlin noise, this means evaluating the function three times with different offsets.For the sum of sines, the three evaluations with different offsets are easily performed in the same sum.Finally, since sparse convolution noise is based on the convolution of randomly placed random impulses, we just need to use random vector-valued impulses, which entails little extra cost.
The initial grid to use for curl noise jittering depends on the desired packing density of the point distribution.If we start from a regular octahedral grid (body centered cubic lattice [Theußl et al. 2001], obtained by inserting a point at the center of each voxel of a cubic grid and using the faces of the cells in the cubic grid as the bases of regular octahedra), we get a denser point distribution than if we start from a cubic grid.The properties of the noise functions also come into play when we work in 3D.We ran a parameter study by rendering out 3D point distributions as collections of spheres.We visually inspected the results to qualitatively assess whether the findings in 2D generalize to 3D.The behavior with different parameters is a bit different in 3D.Perlin noise and SoS seem to more strictly require using the RK4 method to avoid regularities.SoS can occasionally exhibit ripples in the point distribution, but this seems avoidable with well-chosen parameters.Sparse convolution noise is, in that sense, easier to find suitable parameters for in 3D, and it seems to perform reasonably well with an Euler step.If combined with RK4, sparse convolution noise becomes more expensive to evaluate than the other methods.

Implementation
We implemented 3D curl noise jittering in CUDA for NVIDIA OptiX (v7.6) [Parker et al. 2010] and render metals by path tracing of specular materials with a complex index of refraction [Pharr et al. 2023].Sphere tracing [Hart 1996] is used for ray-surface intersection in a signed distance field (SDF).We rendered images using the previously mentioned RTX 3090 GPU.The rendering time for a one sample per pixel (1spp) frame of resolution 720 × 720 is provided for different examples in Figures 8 and 9.

Applications
The ability of our method to produce a point set with blue noise properties makes it suitable for approximate modeling of the jammed hard-particle packings observed in granular materials [Torquato and Stillinger 2010;Meng et al. 2015].As an example, we made a bunny out of tiny spheres and rendered it with the camera at different distances from the object, see Figure 8.We used a regular octahedral lattice as our initial grid, with a total of around 1.3 billion spheres in the entire volume of the bunny.Our implicit method was used with the sum of sines (and RK4) to get an SDF for a stochastic sphere packing with little overlapping of the spheres.
The production of stochastic foam by a random bubble-forming chemical process results in material structures represented well by Voronoi cells [Bogunia et al. 2022].Based on our discussion of the Worley method (see Section 2.7), we believe our method can be used advantageously for the 3D modeling of foams.As an example, we modeled the structure of open-cell aluminum and  copper foams (see Figure 9).For the rendering of the metals, we use available measured complex indices of refraction of oxidized aluminum [Querry 1985] and copper [Glassner 1995].We use the Worley method and find the distances to the nearest points in our point distribution by inspecting the positions of the grid nodes in the first-order neighborhood after being curl noise jittered.Let   ,  = 1, . . ., 4, denote distances from the point of interest x in the volume with  1 being the distance to the closest point and  1 <  2 <  3 <  4 .For the more porous aluminum foam, we use a regular grid and the following formula for conversion to a non-Euclidean signed distance field: The parameters in this model are , which is related to the enclosedness of the cavities, and , which is the thickness of the geometric features.We used  = 1.55 and  = 0.1 for the aluminum foam.In the curl noise jittering, we used sparse convolution noise with an Euler step for this material.
For the copper foam, we use a trabeculum formula by Fabrice Neyret5 .The non-Euclidean signed distance field is then sdf In this case, we used  = 0.06 and CNJ with the octahedral grid as the initial grid (as for the bunny).Figure 10 compares the CNJ of the cubic grid versus the octahedral grid.Visual inspection of the foams as compared with foams obtained using random jitter sampling of one point per voxel in the grid (Figure 9) confirms that our curl noise jittering effectively reduces clustering of points and thus achieves a better model of the real metal foams.

DISCUSSION AND LIMITATIONS
We have demonstrated that creating point sets with blue noise properties is possible using a simple jittering approach.Going forward, this type of point set can more readily be used in real-time applications or where large domains need to be sampled.Of course, applications that need a blue noise sampling large enough that either generating or storing the points would be a limiting factor will benefit the most.However, we note that our method is simple to implement and can be used as a drop-in replacement for applications that already employ jittering.CNJ works in both 2D and 3D, and while we have focused on the 2D case in our analysis, our 3D results indicate that CNJ can be useful for procedural materials with very fine granularity where precomputing blue noise point sets would lead to prohibitive memory consumption.In the future, we are also interested in extending curl noise jittering to other domains.For instance, time-varying noise functions could be useful in certain scenarios.
Our work presupposes that a lattice is given.This does not preclude adaptive curl noise jittering, where the point density depends on, for instance, an underlying image's intensity.However, this would require that the lattice adapts to the intensity, which is not a part of our investigation but might be an avenue for future work.Finally, we would also like to explore the use of other noise functions and streamline tracing methods.We used a cubic grid for the aluminum foam due to its higher porosity and an octahedral grid for the copper foam.The time in the corner is for a 1spp frame.The blue noise properties of our method helps it better avoid point clustering issues.The photos in the rightmost column, courtesy of Beihai Composite Materials (https://www.metalfoamweb.com/),provide some intuition on the appearance of real metal foams.

8Δ CNJ of 8Δ CNJ of 8Δ closeup CNJ of □ closeup CNJ of □ □
Figure 10: To indicate the difference between the cubic grid (□) and the octahedral grid (8Δ), we here show the point distributions for the copper foam scene when using the two different types of initial grid.We tried to obtain a similar result with both grids.Due to the larger distance between the nodes in the cubic grid, we made the grid smaller, applied a larger time step, and decreased the scale in CNJ.The distribution of points is more uneven for the cubic grid.

Figure 2 :
Figure 2: A query point shown (red) in a triangular lattice.

Figure 3 :
Figure 3: From left to right, each row shows the effective Nyquist frequency, the anisotropy, and the derived quality measure, which is simply their ratio, for curl noise jittering based on sparse convolution noise (top), sum-of-sines noise (middle), and Perlin noise (bottom).

Figure 4 :
Figure4: Comparison of our method (far left) to the methods discussed in Section 2.6.We show point sets (top) as well as the power spectrum (zoomed in ×10, middle) and the radial spectrum for each point set (bottom).

Figure 6 :Figure 7 :
Figure 6: In this example, randomly oriented and scaled boxes were placed on a square using Blender's built-in Poisson disk sampling (left) and our CNJ method (right).

Figure 8 :Figure 9 :
Figure 8: Moving closer and closer to a seemingly dusty version of the Stanford bunny (http://graphics.stanford.edu/data/3Dscanrep/).This illustrates our ability to distribute a very large number of points using CNJ w.SoS and RK4.Rendering time for a 1spp frame (left to right): 2.5 s, 4.5 s, 5.4 s, 6.4 s.Rendered here with 3000 samples per pixel.

Table 1 :
Effective Nyquist limit ( eff ), anisotropy ( ā), and quality () for different noise functions and selected pairs of parameters, time step  and noise scale .The best values are in boldface.

Table 2 :
Average results for 100 runs of the tested methods.The statistics shown are: effective Nyquist,  eff , anisotropy, ā, quality, , discrepancy,  * , and time.Methods above the double line can be evaluated implicitly, and methods below cannot.The best values within each of these two categories are in boldface.