TextureSignalProcessing

KO | EN

gitlite — search

#python #react #typescript #javascript #nodejs #rust #dart #flutter #golang #template #cli #nextjs

TextureSignalProcessing

★ 76 Open GitHub ↗

Gradient-Domain Processing within a Texture Atlas

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<center><h2>Gradient Domain Texture Processing (Version 9.60)</h2></center>
<center>
<a href="#LINKS">links</a>
<a href="#EXECUTABLES">executables</a>
<a href="#USAGE">usage</a>
<a href="#LIBRARY">library</a>
<a href="#COMPILATION">compilation</a>
<a href="#CHANGES">changes</a>
<a href="#SUPPORT">support</a>
</center>
<hr>
This software supports gradient-domain signal processing within a texture atlas. Supported applications include:
<UL>
<LI>(localized) texture smoothing and sharpening
<LI>vector-field visualization akin to line-integral convolution
<LI>computation of single-source geodesics
<LI>simulation of reaction-diffusion following the Gray-Scott model
<LI>dilation of texture into the gutter
<LI>masking of gutter/interior/boundary texels
<LI>solving for the smoothest interpolant within a prescribed subset of texels
</UL>
<hr>
<a name="LINKS">LINKS</a> 
<ul>
Papers:
<a href="http://www.cs.jhu.edu/~misha/MyPapers/SIG18.pdf">[Prada, Kazhdan, Chuang, and Hoppe, 2018]</a>,
<a href="https://en.wikipedia.org/wiki/Line_integral_convolution">[Cabral and Leedom, 1993]</a>,
<a href="https://www.cs.cmu.edu/~kmcrane/Projects/HeatMethod/">[Crane, Weischedel, and Wardetzky, 2013]</a>
 
Executables: 
<a href="TSP.x64.zip">Win64</a> 
Source Code:
<a href="TSP.Source.zip">ZIP</a> <a href="https://github.com/mkazhdan/TextureSignalProcessing">GitHub</a> 
Data:
<A HREF="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/TSP.Data.zip">ZIP</A> 
Older Versions:
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.55/">V9.55</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.50/">V9.50</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.10/">V9.10</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.05/">V9.05</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.00/">V9.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version8.00/">V8.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version7.00/">V7.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version6.06/">V6.06</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version6.00/">V6.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version5.01/">V5.01</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version5.00/">V5.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.75/">V4.75</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.60/">V4.60</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.50/">V4.50</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.08/">V4.08</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.07/">V4.07</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.06/">V4.06</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.05/">V4.05</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.03/">V4.03</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.02/">V4.02</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.01/">V4.01</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.00/">V4.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version3.00/">V3.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version2.00/">V2.00</a>,
<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version1.00/">V1.00</a>
</ul>
<hr>
<a name="EXECUTABLES">EXECUTABLES</a> 
<ul>
These applications support reading in textures meshes in one of two formats:
<UL>
<LI><A href="http://www.cc.gatech.edu/projects/large_models/ply.html">PLY</A> (to support multiple charts, texture is assumed to be encoded at wedges/corners rather than vertices.)
<LI><A HREF="https://www.fileformat.info/format/wavefrontobj/egff.htm">Wavefront OBJ</A>
</UL>
Input textures are assumed to be images in png, jpg, or jpeg format.

<dl>
<details>
<summary>
TextureFiltering:
Supports the (localized) smoothing and sharpening of a texture by solving a screened Poisson equation which gives the signal whose values match the input and whose gradients match the modulated gradients of the input. If no output texture is specified, the executable will launch an interactive viewer that supports local "painting" of gradient modulation values and prescription of a global interpolation weight. 
In the interactive viewer the modulation can be set globally by dragging the slider on the top left. 
The modulation can be set locally by holding the [SHIFT] key down and either dragging with the left mouse button (to smooth) or the right mouse button (to sharpen).
</summary>
<dt>--in &lt;input mesh and texture names&gt;</dt>
<dd> These two strings specify the the names of the mesh and the texture image.
</dd>

<dt>[--out &lt;output texture&gt;]</dt>
<dd> This string is the name of the file to which the processed texture will be written.
</dd>

<dt>[--outVCycles &lt;output v-cycles&gt;]</dt>
<dd> This integer specifies the number of v-cycles to use if the processed texture is output to a file and a direct solver is not used.
The default value for this parameter is 6.
</dd>

<dt>[--interpolation &lt;interpolation weight&gt;]</dt>
<dd> This floating point values gives the interpolation weight. 
The default value for this parameter is 1000.
</dd>

<dt>[--modulation &lt;gradient modulation&gt;]</dt>
<dd> This floating point values gives the (uniform) gradient modulation. 
The default value for this parameter is 1.
</dd>

</dd><dt>[--jitter &lt;random seed&gt;]</dt>
<dd> If specified, this integer value is used to seed the random number generation for jittering. (This is used to avoid singular situations when mesh vertices fall directly on edges in the texture grid. In such a situation, the executable will issue a warning "Zero row at index ...".)
</dd>

</dd><dt>[--useDirectSolver]</dt>
<dd> If enabled, this flag specifies that a direct solver should be used (instead of the default multigrid solver).
</dd>

</dd><dt>[--sanityCheck]</dt>
<dd> If enabled, this flag specifies that sanity-checks should be run to confirm that the texture-mapping is valid (e.g. that flipped triangles do not extend beyond the boundaries of the charts) and an exception is thrown if the mapping is found to be invalid.
</dd>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
TextureStitching:
Supports the stitching together of multiple (possibly overlapping) textures by solving a screened Poisson equation with value constraints defined by the input texture.
The interactive viewer runs in two modes:
<OL>
<LI> A user specifies a single composite texture and (optionally) a mask file indicating when texels in the composite come from the same source.
In this case gradient constraints are obtained by copying gradients from the composite whenever the two texels defining an edge come from the same source, and setting the gradient constraint to zero along edges coming from different sources. If no mask file is provided, a default mask is created by assigning texels the same color if and only if they are covered by the same chart. 
The viewer shows the stitched texture on the left and the composite texture on the right.
<LI> A user specifies multiple partial texture files and corresponding confidence masks.
In this case gradient constraints are obtained by blending gradients from the different inputs, weighted by confidence, and setting gradients to zero in regions where there are no textures with non-zero confidence.
The viewer shows the stitched texture on the left and a partial texture on the right. The user can selectively replace blended value/gradient constraints with the values/gradients from the partial texture by holding the [SHIFT] key down and dragging over the region to be in-painted.
</OL>
</summary>
<dt>--in &lt;input mesh and composite texture&gt;</dt>
<dd> These two strings specify the names of the mesh and the texture image.
</dd>

<dt>[--mask &lt;input mask&gt;]</dt>
<dd> This string specifies the name of the mask image. 
Black pixels in the mask file should be used to denote regions where the texel value is unkown. (Results may be unpredictable if it is encoded using lossy compression.)
</dd>

<dt>[--out &lt;output texture&gt;]</dt>
<dd> This string is the name of the file to which the stitched texture will be written.
</dd>

<dt>[--outVCycles &lt;output v-cycles&gt;]</dt>
<dd> This integer specifies the number of v-cycles to use if the stitched texture is output to a file and a direct solver is not used. 
The default value for this parameter is 6.
</dd>

<dt>[--interpolation &lt;interpolation weight&gt;]</dt>
<dd> This floating point values gives the interpolation weight. 
The default value for this parameter is 100.
</dd>

</dd><dt>[--multi]</dt>
<dd> If enabled, this flag specifies that the second and third arguments to the --in parameter are to be interpreted as format specifiers for the textures confidence map files. 
Note: If this flat is enabled, the input masks must be specified using the --mask parameter.
</dd>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
LineIntegralConvolution:
Supports the <a href="https://en.wikipedia.org/wiki/Line_integral_convolution">line-integral-convolution</A> visualization of a vector-field through <A HREF="https://dl.acm.org/citation.cfm?id=614456">anisotropic diffusion</A> by defining a new metric on the surface that stretches distances along the vector-field values, diffusing a random color texture with respect to the new anisotropic metric, and then sharpening the resulting signal.
If no output texture is specified, the executable will launch an interactive viewer that supports iteratively stepping through the diffusion. 
Hit [SPACE] to start the iterative solver or hit "+" to advance one iteration at a time.
</summary>
<dt>--in &lt;input mesh name&gt;</dt>
<dd> This string specifies the name of the mesh.
</dd>

<dt>[--inVF &lt;vector-field file&gt;]</dt>
<DD>This string specifies the file containing the vector-field for visualization. (If this parameter is not specified, the principal curvature direction is used.) 
This file is assumed to be in binary, with the first four bytes storing an integer representing the number of vectors (this should be equal to the number of triangles in the mesh) followed by the list of vectors.
The latter are encoded using double-precision floating point values and should be 8*num_triangles*dim bytes, with num_triangles the number of triangles/vectors and dim the dimension of vector-field. (The value of dim is equal to two if the --intrinsicVF is specified an three otherwise.)
</DD>

</dd><dt>[--intrinsicVF]</dt>
<dd> If enabled and a vector-field is specified, this flag indicates that the vector values are represented with two values per vector, using an intrinsic frame. Specifically, for triangle ( v0 , v1 , v2 ), the two-dimensional coefficients ( x , y ) correspond to the three-dimensional tangent vector ( x&middot;(v1-v0) , y&middot;(v2-v0) ).
</dd>

<dt>[--out &lt;output texture&gt;]</dt>
<dd> This string is the name of the file to which the line-integral-convolution texture will be written.
</dd>

<dt>[--licInterpolation &lt;line-integral-convolution interpolation weight&gt;]</dt>
<dd> This floating point values gives the interpolation weight used for the line-integral-convolution. 
The default value for this parameter is 10000.
</dd>

<dt>[--sharpInterpolation &lt;sharpening interpolation weight&gt;]</dt>
<dd> This floating point values gives the interpolation weight used for sharpening the line-integral-convolution results. 
The default value for this parameter is 10000.
</dd>

<dt>[--modulation &lt;sharpening gradient modulation&gt;]</dt>
<dd> This floating point values gives the gradient modulation used for sharpening the line-integral-convolution results. 
The default value for this parameter is 100.
</dd>

<dt>[--width &lt;output texture width&gt;]</dt>
<dd> This integers specifies the width of the output texture.
The default value for this parameter is 2048.
</dd>

<dt>[--height &lt;output texture height&gt;]</dt>
<dd> This integers specifies the height of the output texture.
The default value for this parameter is 2048.
</dd>

</dd><dt>[--minor]</dt>
<dd> If enabled, this flag specifies that the directions of minimal principal curvature should be used to define the vector-field (instead of the default maximal principal curvature directions).
</dd>

</dd><dt>[--useDirectSolver]</dt>
<dd> If enabled, this flag specifies that a direct solver should be used (instead of the default multigrid solver).
</dd>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
Geodesics:
An interactive tool for visualization of single-source geodesics using the <A HREF="https://www.cs.cmu.edu/~kmcrane/Projects/HeatMethod/">heat method</A>. 
In the interactive viewer the source can be set by holding the [SHIFT] key down and clicking/dragging with either mouse button.
</summary>
<dt>--in &lt;input mesh name&gt;</dt>
<dd> This string specifies the the name of the mesh.
</dd>

<dt>[--interpolation &lt;diffusion interpolation weight&gt;]</dt>
<dd> This floating point values gives the interpolation weight used for diffusing the initial delta function. 
The default value for this parameter is 10000.
</dd>

<dt>[--width &lt;output texture width&gt;]</dt>
<dd> This integers specifies the width of the output texture.
The default value for this parameter is 1024.
</dd>

<dt>[--height &lt;output texture height&gt;]</dt>
<dd> This integers specifies the height of the output texture.
The default value for this parameter is 1024.
</dd>

</dd><dt>[--useDirectSolver]</dt>
<dd> If enabled, this flag specifies that a direct solver should be used (instead of the default multigrid solver).
</dd>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
ReactionDiffusion:
Performs simulation of reaction-diffusion based on the <A HREF="http://www.karlsims.com/rd.html">Gray-Scott model</A>.
If no output texture is specified, the executable will launch an interactive viewer that supports iteratively stepping through the reaction-diffusion process. 
Hit [SPACE] to start the reaction-diffusion process or hit "+" to advance one step at a time.
</summary>
<dt>--in &lt;input mesh name&gt;</dt>
<dd> This string specifies the the name of the mesh.
</dd>

<dt>[--out &lt;output texture&gt;]</dt>
<dd> This string is the name of the file to which the reaction-diffusion texture will be written.
</dd>

<dt>[--outSteps &lt;output reaction-diffusion steps&gt;]</dt>
<dd> This integer specifies the number of reaction-diffusion steps to be taken.
The default value for this parameter is 1000.
</dd>

<dt>[--width &lt;output texture width&gt;]</dt>
<dd> This integers specifies the width of the output texture.
The default value for this parameter is 512.
</dd>

<dt>[--height &lt;output texture height&gt;]</dt>
<dd> This integers specifies the height of the output texture.
The default value for this parameter is 512.
</dd>

</dd><dt>[--dots]</dt>
<dd> If enabled, this flag specifies that the feed/kill parameters for dot-formation should be used. Otherwise, the feed/kill parameters for stripes are used.
</dd>

</dd><dt>[--useDirectSolver]</dt>
<dd> If enabled, this flag specifies that a direct solver should be used (instead of the default multigrid solver).
</dd>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
TextureDilation:
Dilates the texture by sampling across the chart seam and pulling interpolated texture values into the gutter texels.
</summary>
<dt>--in &lt;input mesh and texture names&gt;</dt>
<dd> These two strings specify the the names of the mesh and the texture image.
</dd>

<dt>[--out &lt;output texture mask&gt;]</dt>
<dd> This string is the name of the file to which the dilated texture will be written.
</dd>

<dt>[--radius &lt;dilation radius&gt;]</dt>
<dd> This integer values gives the radius by which the texture should be dilated. 
The default value for this parameter is 0, indicating no dilation.
</dd>

<dt>[--verbose]</dt>
<dd> If this flag is enabled, performance information is printed to <CODE>stdout</CODE>.
</dd>
</dl>
</ul>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
TextureMasking:
Identifies the active texels within a texture mask of prescribed resolution, with gutter texels rendered in red and texels supporting a triangle rendered in blue.
</summary>
<dt>--in &lt;input mesh name&gt;</dt>
<dd> This string specifies the the name of the mesh.
</dd>

<dt>--res &lt;texture width and texture height&gt;</dt>
<dd> These two integers specify the width and height of the mask.
</dd>

<dt>[--out &lt;output texture mask&gt;]</dt>
<dd> This string is the name of the file to which the texture mask will be written.
</dd>

<dt>[--rasterizer]</dt>
<dd> This integer specifies the type of information to be rasterized. Valid values are:
<UL>
<LI>0: active -- all texels whose support overlaps the texture atlas
<LI>1: boundary -- all texels whose support overlaps the texture chart boundaries
<LI>2: id -- colors texels by the triangle covering them
<LI>3: node incidence count (unsigned) -- colors texels by the number of triangles sitting over them
<LI>4: node incidence count (signed) -- colors texels by the number of positively oriented triangles over them, minus the number of negatively oriented triangles over them
</UL>
The default value for this parameter is 0 (active)
</dd>

</details>
</dl>
</ul>

<ul>
<dl>
<details>
<summary>
SeamStitcher:
Ensures an as-smooth-as-possible transition, either across chart boundaries or in regions expressly specified by an input mask, by replacing the values of texels with values minimizing the Dirichlet energy (subject to the constraint that the values of other texels remaine fixed).
</summary>
<dt>--in &lt;input mesh and texture&gt;</dt>
<dd> These two strings specify the names of the mesh and the texture image.
</dd>

<dt>[--mask &lt;input mask&gt;]</dt>
<dd> This string specifies the name of the mask image used to define texels whose value is to be replaced. 
Black pixels in the mask file indicate that the associated texels values should be updated to produce an as-smooth-as-possible image. (Results may be unpredictable if it is encoded using lossy compression.) 
If specified, the mask resolution should match that of the input texture. 
If not specified, values of texels at chart boundaries will be updated.
</dd>

<dt>[--out &lt;output texture&gt;]</dt>
<dd> This string is the name of the file to which the smoothed texture will be written.
</dd>

<dt>[--exterior]</dt>
<dd> If this flag is enabled (and a --mask parmeter is not specified), only the values of boundary texels whose centers are outside the charts are updated.
</dd>

<dt>[--verbose]</dt>
<dd> If this flag is enabled, performance information is printed to <CODE>stdout</CODE>.
</dd>

</details>
</dl>
</ul>

<hr>
<a name="USAGE">USAGE EXAMPLES (WITH SAMPLE DATA)</a> 
For testing purposes, a number of <A HREF="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/TSP.Data.zip">textured mapped models</A> are provided (using the .ply extension).
Of these, David and Julius include normal maps (using the .normap extension), Fertility includes the eight harmonic vector-fields (using the .vf extension), and Rooster uses (partial) texture maps as well as a mask image and confidence maps.

<ul>

<dl>
<details>
<summary>
TextureFiltering
</summary>
To run this executable you must specify the input mesh as well as the texture itself:
<blockquote><code>% Bin/*/TextureFiltering --in ../TSP.Data/David/david.ply ../TSP.Data/David/david.normap</code></blockquote>
This opens a viewer allowing the user to prescribe both global gradient modulation weights (through the slider) and local modulation weights (through a paint-brush interface, by depressing the [SHIFT] key and dragging with the left mouse button to smooth and the right mouse button to sharpen). 
You can also bypass the viewer and output a globally sharpened/smoothed texture to a file:
<blockquote><code>% Bin/*/TextureFiltering --in ../TSP.Data/Julius/julius.ply ../TSP.Data/Julius/julius.normap --out julius.smooth.normap --modulation 0 --interpolation 100</code></blockquote>
Here a modulation weight less than 1 indicates that gradients should be dampened (resulting in smoothing) and a small interpolation weight reduces the interpolation penalty, exaggerating the smoothing.
</details>
</dl>

<dl>
<details>
<summary>
TextureStitching
</summary>
This viewer can be run in one of two modes:
<OL>
<LI>
In addition to the input mesh, specify a (single) composite texture and mask.
If adjacent texels share the same mask color, they are assumed to come from the same source, and the gradient between them is preserved.
Otherwise, the gradient is set to zero. Additionally, a mask color of black is reserved to indicate that the texel value is unknown. 
For example, running
<blockquote><code>% Bin/*/TextureFiltering --in Rooster/rooster.ply ../TSP.Data/Rooster/texels.png --mask ../TSP.Data/Rooster/mask.png</code></blockquote>
opens a viewer showing the stitched texture on the left and the composite texture on the right.
<LI>
In addition to the input mesh, specify (multiple) partial textures and associated confidence maps.
The code blends the gradients in regions of overlap, with weights determined by the mask.
Texel and confidence file names are specified using integer format specifiers, with zero-indexing.
Colors are transformed to scalar confidence values by computing the gray-scale value and normalizing to the range [0,1]. 
For example, running
<blockquote><code>% Bin/*/TextureFiltering --in Rooster/rooster.ply ../TSP.Data/Rooster/texels-%02d.png --mask ../TSP.Data/Rooster/mask-%02d.png --multi</code></blockquote>
opens a viewer showing the stitched texture on the left and the first partial textures on the right. 
Pressing the 't' key toggles forward through the partial textures and pressing 'T' toggles backwards. 
Holding [SHIFT] and clicking on the stitched model replaces the blended gradients under the paint-brush with the gradients from the currently visualized partial-texture. 
</OL>
You can also bypass the viewer and output the stitched texture to a file:
<blockquote><code>% Bin/*/TextureStitching --in Rooster/rooster.ply ../TSP.Data/Rooster/texels-%02d.png --mask ../TSP.Data/Rooster/mask-%02d.png --multi --out stitched.png</code></blockquote>
</details>
</dl>

<dl>
<details>
<summary>
LineIntegralConvolution
</summary>
To run this executable you must specify the input mesh:
<blockquote><code>% Bin/*/LineIntegralConvolution --in ../TSP.Data/Fertility/fertility.ply</code></blockquote>
This opens a viewer visualizing a vector-field by performing anisotropic diffusion to simulate line-integral-convolution. (To start the iterative solver, press the [SPACE] key.) By default, the vector-field used is defined by the (maximal) principal curvature directions. 
You can also explicitly prescribe the vector-field:
<blockquote><code>% Bin/*/LineIntegralConvolution --in ../TSP.Data/Fertility/fertility.ply --inVF ../TSP.Data/Fertility/harmonic-001.vf --intrinsicVF</code></blockquote>
(The --intrinsicVF flag is required because the vector-field in the file is represented using two intrinsic coordinates per triangle instead of three extrinsic ones.) 
You can also bypass the viewer and output the line-integral-convolution texture to a file:
<blockquote><code>% Bin/*/LineIntegralConvolution --in ../TSP.Data/Hand/hand.ply --minimal --out hand.minimal.jpg</code></blockquote>
Here a visualization of the minimal principal curvature directions is written out as a texture image.
</details>
</dl>

<dl>
<details>
<summary>
Geodesics
</summary>
To run this executable you must specify the input mesh:
<blockquote><code>% Bin/*/Geodesics --in ../TSP.Data/Bunny/bunny.ply</code></blockquote>
This opens a viewer allowing the user to prescribe the source of the geodesic by holding the [SHIFT] button and clicking on the source location with either mouse button.
</details>
</dl>

<dl>
<details>
<summary>
ReactionDiffusion
</summary>
To run this executable you must specify the input mesh:
<blockquote><code>% Bin/*/ReactionDiffusion --in ../TSP.Data/Camel/camel.ply</code></blockquote>
This opens a viewer visualizing the "stripes" reaction-diffusion process. (To start the process, press the [SPACE] key.) 
You can also bypass the viewer and output the reaction-diffusion texture to a file:
<blockquote><code>% Bin/*/ReactionDiffusion --in ../TSP.Data/David/david.ply --out david.dots.jpg --dots --outSteps 2000</code></blockquote>
Here a "dots" pattern is written out to an image. (Empirically, we have found that this reaction-diffusion process takes more steps to converge, hence the larger number of steps.)
</details>
</dl>

</ul>

<hr>
<a name="library">HEADER-ONLY LIBRARY</a> 
<UL>
<DL>
include/Src/GradientDomain.h
In addition to executables, the gradient-domain processing code can be interfaced through either the <CODE>GradientDomain</CODE> class or the <CODE>HierarchicalGradientDomain</CODE> class declared in <CODE>include/Src/GradientDomain.h</CODE>.
<UL>

<DETAILS>
<SUMMARY>
<CODE>GradientDomain</CODE>:
Once constructed, this object can be used to query the active texels/edges, as well as create the standard mass/stiffness/divergence matrices and apply the mass/stiffness/operators to the texel data. In the descriptions below, the template parameter <CODE>Real</CODE> is the floating point type used to represent data (typically <code>double</code>) and <CODE>Solver</CODE> is the class used to factor and solve the sparse system of linear equations (<CODE>Eigen::SimplicialLDLT</CODE> by default).
</SUMMARY>
Code Description: 
<UL>
The code performs basic gradient domain processing applications including texture smoothing/sharpening and stitching.
This is done by solving for the output texture values which simultaneouly fit value and derivative constraints.
<UL>
<LI> Value constraints are described by specifying the desired values at the texels, defined to be the input texel values.
<LI> Gradient constraints are described by specifying the desired differences across edges between texels, defined to be the dampened/amplified differences between input texture values (and zerod out if the texels come from different patches, in the case of stitching).
</UL>
</UL>

Code walk-through: 
<UL>
 The details of the implementation can be found in the <code>GradientDomain.example.cpp</code> code.
 <UL>
 <LI>Lines 113-125: The texture-mapped geometry and the texture image (as well as a mask image describing when texels belong to the same patch, for stitching) are read in.
 <LI>Lines 143-157: The <CODE>GradientDomain</CODE> object is constructed, passing in the resolution of the mesh as well as functor giving the indices of embedding/texture-vertices for each corner, functors giving the positions of embedding/texture-vertices, the texture image resolution, and the number of quadrature points per triangle used for integration (valid values are 1, 3, 6, 12, 24, and 32).
 <LI>Lines 161-166: The input texture values are read from the image into a <CODE>std::vector</CODE>, using the member functions <CODE>GradientDomain::numNodes</CODE> to get the number of (active) texels in the texture map and <CODE>GradientDomain::node</CODE> to get the coordinates of the texel within the image.
 <LI>Lines 168-195: The constraints to the linear system are constructed, specifying the target values and gradients:
 <UL>
 <LI>Lines 172-173: The target value constraints are constructed by applying the mass matrix to the input texel values.
 <LI>Lines 175-190: The target gradient constraints are obtained by computing the target per-edge differences and then computing the divergence:
 <UL>
 <LI>Lines 177-186: The target edge differences are obtained by iterating over the edges, computing the difference between the input texel values at the end-points, and scaling by the gradient modulation value (and zeroing out the difference in the case the end-points are assigned different IDs, in the case of stiching). To this end, the member function <CODE>GradientDomain::numEdges</CODE> gives the number of edges, and the member function <CODE>GradientDomain::edge</CODE> returns the indices of the edge's two end-points.
 <LI>Lines 188-189: The target gradient constraints are obtained applying the divergence operator to the computed edge differences.
 </UL>
 <LI>Lines 192-193: The target value and gradient weights are combined using the weights specified by the user.
 </UL>
 <LI>Lines 197-199: The system matrix is constructed by taking the weighted combination of the mass and stiffness matrices (using the same weights for combining the value and gradient constraints).
 <LI>Lines 201-211: The system matrix is factored.
 <LI>Lines 213-221: The values for the individual image channels are computed by solving the linear system.
 <LI>Lines 223-228: The output texel values are written from the <CODE>std::vector</CODE> back into the texture image.
 </UL>
</UL>

Assumptions: 
<UL>
The code make a number of assumptions about the input geometry:
<UL>
<LI>The code should support non-injective texture mappings.
<LI>For numerical purposes neither surface nor texture triangles should be degenerate.
<LI>The indexing of surface vertices is such that the topology implied by the vertex indexing matches that of the surface.
<LI>The indexing of texture vertices is such that the topology implied by the vertex indexing matches the toplogy of the texture atlas. (i.e. A single surface vertex can be associated with different texture vertices if the associated corners are in different charts.)
</UL>
</UL>
</DETAILS>

<DETAILS>
<SUMMARY>
<CODE>HierarchicalGradientDomain</CODE>:
This class derives from <CODE>GradientDomain</CODE> and additionally supports an iterative multigrid solver for computing the solution to the gradient domain problem without requiring a potentially expensive matrix factorization.
</SUMMARY>
The interface is simlar to that of <CODE>GradientDomain</CODE> and the details of the implementation can be found in <CODE>HierarchicalGradientDomain.example.cpp</CODE>. What follows is a list of the minor changes needed in order to access and use the hierarchical solver:
<UL>
<LI>Line 152-167: The interface uses the class <CODE>HierarchicalGradientDomain</CODE>, whose constructor takes an additional parameter describing the number of levels in the multigrid hierarchy. 
Note: Because the class is also responsible for relaxing the gradient-domain system, it is templated off the type of the direct solver used to solve the system at the coarsest resolution (second argument) and the type of data being solved for (third argument). 
[Compare to Lines 143-157 of <CODE>GradientDomainExample.cpp</CODE>]
<LI>Line 170: The <CODE>HierarchicalGradientDomain</CODE> class maintains its own constraint and solution vectors. So rather than allocating the constraint and solution vectors separately, the interface uses pointers to the data maintained in the <CODE>hgd</code> object. 
[Compare to Line 159 of <CODE>GradientDomainExample.cpp</CODE>]
<LI>Lines 208-210: The <CODE>HierarchicalGradientDomain</CODE> class maintains its own representation of the system matrix. This is initialized by specifying the mass and stiffness weights for the system. 
[Compare to Lines 197-199 of <CODE>GradientDomainExample.cpp</CODE>]
<LI>Line 212-214: The solution is relaxed by running the prescribed number of v-cycles with the prescribed number of Gauss-Seidel relaxations per hierarchy level. 
[Compare to Lines 201-221 of <CODE>GradientDomainExample.cpp</CODE>]
</UL>
</DETAILS>
</UL>

</DL>
</UL>

<hr>
<details>
<summary>
<a name="COMPILATION">COMPILATION AND EXECUTION</a> 
</summary>
<UL>
<LI>The Windows executables require both the glew and glut dynamically linked libraries to run. These can be found <A HREF="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/TSP.DLLs.zip">here</A> and should be included either in the directory with the executables, or in the directory from which the executables are run.</LI>
<LI>Compiling under Windows requires both the glew and glut libraries. These can be found <A HREF="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/TSP.LIBs.zip">here</A> and should be placed in the output directory for linkage.</LI></LI>
<LI>Compilation requires a linear solver. By default, we use the <CODE>LDLt</CODE> implementation provided by <A HREF="https://eigen.tuxfamily.org/">Eigen</A>. If you have <A HREF="https://www.intel.com/content/www/us/en/docs/oneapi/programming-guide/2024-1/intel-oneapi-math-kernel-library-onemkl.html">Intel's oneMKL</A>, we encourage you to use Eigen's <CODE>Pardiso</CODE> implementation. To to this you will need to enable the <CODE>USE_EIGEN_PARDISO</CODE> flag in <CODE>include/Src/PreProcessing.h</CODE>
</UL>
</details>

<hr>
<details>
<summary>
<a name="CHANGES">HISTORY OF CHANGES</a> 
</summary>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version2.00/">Version 2.00</a>:
<ul>
<li> Added support for reaction-diffusion based on the Gray-Scott model.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version3.00/">Version 3.00</a>:
<ul>
<li> Added support for texture stitching.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.00/">Version 4.00</a>:
<ul>
<li> Added <CODE>Makefile.no_visual</CODE> to allow building texture filtering/stitching applications without visualizations.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.01/">Version 4.01</a>:
<ul>
<li> Added support for reading <code>.obj</code> files.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.02/">Version 4.02</a>:
<ul>
<li> Added support for mask visualization.
<li> Switched exceptions to warnings.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.03/">Version 4.03</a>:
<ul>
<li> Added support for segment boundary dilation in the <CODE>TextureStitching</CODE> code.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.05/">Version 4.05</a>:
<ul>
<li> Modified the <code>--jitter</code> flag to take a random seed.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.06/">Version 4.06</a>:
<ul>
<li> Added support for visualizing weights when using multi-stitching.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.07/">Version 4.07</a>:
<ul>
<li> Added support for providing a separate low-frequency signal for texture processing.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.08/">Version 4.08</a>:
<ul>
<li> Removing numerical issues in loop construction.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.50/">Version 4.50</a>:
<ul>
<li> Code clean-up
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.60/">Version 4.60</a>:
<ul>
<li> Added --mask for specifying mask(s) to support default cross-chart smoothing.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version4.75/">Version 4.75</a>:
<ul>
<li> Added support for 16-bit png files.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version5.00/">Version 5.00</a>:
<ul>
<li> Separated out OpenMP depeendency.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version5.01/">Version 5.01</a>:
<ul>
<li> Add support for processing polygonal (i.e. not necessarily triangular) faces.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version6.00/">Version 6.00</a>:
<ul>
<li> Add funcionality for dilating the texture map and masking out active texels.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version6.05/">Version 6.05</a>:
<ul>
<li> Fixed off-by-half-pixel issue with texture rasterization.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version6.06/">Version 6.06</a>:
<ul>
<LI> Cleaned up texture dilation
<LI> Made non-template, header-only functions <code>inline</code>.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version7.00/">Version 7.00</a>:
<ul>
<LI> Modified to support non-bijectve texture maps.
<LI> Removed dependence on <CODE>Triangle</CODE> code.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version8.00/">Version 8.00</a>:
<ul>
<LI> Added header-only library for standard geometry-prcoessing interfaces, wrapped in <CODE>include/Src/GradientDomain.h</CODE>
<LI> Added example code showing how to use the libary in <CODE>GradientDomain.example.cpp</CODE>.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.00/">Version 9.00</a>:
<ul>
<LI> Added <CODE>SeamStitcher</CODE> executable.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.05/">Version 9.05</a>:
<ul>
<LI> Added the option to provide a mask to the <CODE>SeamStitcher</CODE> executable to indicate which texels are to be locked.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.10/">Version 9.10</a>:
<ul>
<LI> Added options for <CODE>TextureMasking</CODE>.
<LI> Added more numerical stability.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.10/">Version 9.10</a>:
<ul>
<LI> Added header-only library for a multigrid solver supporting standard geometry-prcoessing interfaces, wrapped in <CODE>include/Src/GradientDomain.h</CODE>
<LI> Added example code showing how to use the libary in <CODE>HierarchicalGradientDomain.example.cpp</CODE>.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.55/">Version 9.55</a>:
<ul>
<LI> Added support for reading/writing <CODE>.exr</CODE> images.
</ul>

<a href="http://www.cs.jhu.edu/~misha/Code/TextureSignalProcessing/Version9.60/">Version 9.60</a>:
<ul>
<LI> Added <CODE>--sanityCheck</CODE> flag to support testing if the texture mapping is corrupted.
</ul>

</details>

<hr>
<a name="SUPPORT">SUPPORT</a> 
This work genersouly supported by NSF grant #1422325.

TextureSignalProcessing

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README