Procedural Texturing of Solid Wood with Knots

Abstract

We present a procedural framework for modeling the annual ring pattern of solid wood with knots. Although wood texturing is a well-studied topic, there have been few previous attempts at modeling knots inside the wood texture. Our method takes the skeletal structure of a tree log as input and produces a three-dimensional scalar field representing the time of added growth, which defines the volumetric annual ring pattern. First, separate fields are computed around each strand of the skeleton, i.e., the stem and each knot. The strands are then merged into a single field using smooth minimums. We further suggest techniques for controlling the smooth minimum to adjust the balance of smoothness and reproduce the distortion effects observed around dead knots. Our method is implemented as a shader program running on a GPU with computation times of approximately 0.5 s per image and an input data size of 600 KB. We present rendered images of solid wood from pine and spruce as well as plywood and cross-laminated timber (CLT). Our results were evaluated by wood experts, who confirmed the plausibility of the rendered annual ring patterns.
Link to code: https://github.com/marialarsson/procedural_knots.

Full text

Procedural Texturing of Solid Wood with Knots
MARIA LARSSON, The University of Tokyo, Japan
TAKASHI IJIRI, Shibaura Institute of Technology, Japan
HIRONORI YOSHIDA, Future University Hakodate, Japan
JOHANNES A. J. HUBER, Luleå University of Technology, Sweden
MAGNUS FREDRIKSSON, Luleå University of Technology, Sweden
OLOF BROMAN, Luleå University of Technology, Sweden
TAKEO IGARASHI, The University of Tokyo, Japan
a. c.
Wood color map
Renderd image
Reference photo
d.b.
Fig. 1. Rendered images aimed at reproducing the annual ring paerns observed in the reference photographs, created using our procedural framework for
texturing knoed wood. Each 1200 ×1200 pixel sized image was rendered within 0.5 s, based on 600 KB color and geometry data.
We present a procedural framework for modeling the annual ring pattern
of solid wood with knots. Although wood texturing is a well-studied topic,
there have been few previous attempts at modeling knots inside the wood
texture. Our method takes the skeletal structure of a tree log as input and
produces a three-dimensional scalar eld representing the time of added
growth, which denes the volumetric annual ring pattern. First, separate
elds are computed around each strand of the skeleton, i.e., the stem and each
knot. The strands are then merged into a single eld using smooth minimums.
We further suggest techniques for controlling the smooth minimum to adjust
the balance of smoothness and reproduce the distortion eects observed
around dead knots. Our method is implemented as a shader program running
on a GPU with computation times of approximately 0.5 s per image and an
input data size of 600 KB. We present rendered images of solid wood from
pine and spruce as well as plywood and cross-laminated timber (CLT). Our
results were evaluated by wood experts, who conrmed the plausibility of
the rendered annual ring patterns.
Link to code: https://github.com/marialarsson/procedural_knots.
Authors’ addresses: Maria Larsson, The University of Tokyo, Japan, ma.ka.larsson@
gmail.com; Takashi Ijiri, Shibaura Institute of Technology, Japan, takashi.ijiri@riken.jp;
Hironori Yoshida, Future University Hakodate, Japan, hyoshida@hy-ma.com; Johannes
A. J. Huber, Luleå University of Technology, Sweden, johannes.huber@ltu.se; Magnus
Fredriksson, Luleå University of Technology, Sweden, magnus.1.fredriksson@ltu.se;
Olof Broman, Luleå University of Technology, Sweden, olof.broman@ltu.se; Takeo
Igarashi, The University of Tokyo, Japan, takeo@acm.org.
©2022 Copyright held by the owner/author(s). Publication rights licensed to ACM.
This is the author’s version of the work. It is posted here for your personal use. Not for
redistribution. The denitive Version of Record was published in ACM Transactions on
Graphics, https://doi.org/10.1145/3528223.3530081.
CCS Concepts: •Computing methodologies
→
Volumetric models;
Texturing.
Additional Key Words and Phrases: procedural texturing, volumetric textur-
ing, natural phenomena, wood, smooth minimum, distance eld
ACM Reference Format:
Maria Larsson, Takashi Ijiri, Hironori Yoshida, Johannes A. J. Huber, Magnus
Fredriksson, Olof Broman, and Takeo Igarashi. 2022. Procedural Texturing
of Solid Wood with Knots. ACM Trans. Graph. 41, 4, Article 45 (July 2022),
9 pages. https://doi.org/10.1145/3528223.3530081
1 INTRODUCTION
Knots are commonly seen on wooden surfaces, including structural
building members, wall panelling, ooring, and table tops. Knots are
caused by branches growing out from the stem of the tree, which
leave traces inside the wood. They cause complex distortions to the
otherwise relatively straight stem grain, giving rise to distinctive
annual ring patterns. Depending on the direction in which the knot
faces the surface, its appearance changes from a circular spot to a
curved cone (Fig. 2). Moreover, during the lifetime of a tree, a branch
might die, which aects the shape of the knot and its impact on
the stem grain. Knots are particularly characteristic of softwood,
which is wood from conifer trees (e.g., pine and spruce). Such trees
typically have many branches growing out from their main stem,
giving rise to dense knot patterns in the wood texture. Nonetheless,
hardwoods (e.g., oak) often have knots in their textures as well.
The level set method was successfully applied to model annual
ring patterns by simulating the gradual expansion of trees [Kratt
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

45:2 •Larsson, et al.
et al
.
2015; Mann et al
.
2006; Sellier et al
.
2011]. Although this
method is suitable for handling complex geometries including graft-
ing points and dying knots, as a growth model that evolves over
many time steps and necessitates calculating and storing every point
in the tree at a given resolution, it is computationally inecient
for surface texturing. Conversely, procedural texturing calculates
only the points of interest (the visible pixels on the surface of the
object being rendered) and does so on demand (during rendering)
without storing all pixel colors as a volumetric raster image in the
texture memory, making it computationally ecient and therefore a
popular method for modeling volumetric materials including wood
[Gardner 1984, 1985; Peachey 1985]. Previous research on procedural
modeling of wood have successfully reproduced features such as
rays and pores [Liu et al
.
2016]. However, knots have yet to receive
signicant attention.
Therefore, we propose a method to procedurally model the volu-
metric annual ring pattern of knotted wood. The texture is struc-
tured around a grafted skeleton and we consider both alive and
dead knots. We encode the internal and external geometries of an
input tree log geometry in a series of image maps. By referring to
these images, we calculate scalar elds of time (distance divided
by the local speed of growth) around each strand of the internal
grafted skeleton. The time elds are then merged using smooth
minimums. Up to this point, our procedure is similar to previous
methods developed for tree modeling and layered solid models in
general [Cutler et al
.
2002; Perlin 1985; Pirk et al
.
2012]. However,
we go further in modeling the details of the stem-to-knot unions.
Specically, we suggest techniques for ne-tuning the balance of
smoothness and for handling dead knots, including smoothness
inversion and buttery distortions, mimicking patterns observed
in real wood. The nal output image is rendered by converting the
time eld values into pixel colors by sampling a wood color map.
To illustrate the feasibility of our method, we implemented a
shader program running on a graphics processing unit (GPU) and
produce a number of rendered images. For the images presented in
this paper, the computation times were typically less than 1 s and the
typical texture memory data size for a tree log geometry and wood
colors was 600 KB, demonstrating the time- and space-eciency of
our method. We present a variety of solid wood textures with knots
from pine and spruce. By modifying the texture coordinates of the
input 3D model, we also reproduce the appearance of processed
wood materials, specically plywood and cross-laminated timber
(CLT). The visual quality of our results were evaluated by asking
wood experts to rate and comment on the plausibility of the annual
ring patterns in a number of rendered images.
Finally, for possible applications, knotted wood textures is of par-
ticular interest for creating computer visualizations of architecture
and furniture designs. Potential industrial applications also exists.
a. b. c. d. e.
Fig. 2. Knot in various cuts [Forest Products Laboratory - USDA 2010].
For example, our model makes it possible to visualize virtually cut
planks based on skeleton data extracted from computed tomography
(CT) scans of tree logs, which can facilitate the selection of logs at a
wood mill.
2 RELATED WORK
2.1 Texture synthesis
A popular approach to producing high-quality texture images is
texture synthesis. Texture synthesis methods take a small exemplar
image as input and produce similar looking texture images of arbi-
trary sizes. Both 2D and 3D texture synthesis methods have been
proposed for wood textures [Henzler et al
.
2020; Kopf et al
.
2007].
A limitation with texture synthesis methods is memory eciency.
They store the synthesis result as a raster image, which requires
signicant memory to represent a large 3D volume, such as that of
a tree log. As a more critical limitation, standard texture synthesis
methods look at local features only. Although these models tend
to work well for uniform materials like gravel, they fail to recon-
struct global structures like the internal grafted skeleton of knotted
wood. In another study, multiple texture patches were placed to
model anisotropic materials, including wood [Takayama et al
.
2008].
However, with this patch-based approach, the annual rings become
discontinuous around boundaries of neighboring patches. Another
work on macrostructured texture synthesis distributes particles on
a surface with 2D texture coordinates, modelling knots as circular
spots [Dischler and Ghazanfarpour 1999]. Whereas this method is
arguably sucient for recreating the appearance of knots that are
cut in the traversal plane (Fig. 2a), it cannot recreate the appearance
of knots that are cut other directions (Fig. 2b-e), for which it would
be necessary to model their volumetric structure.
2.2 Procedural modeling and texturing
Procedural texturing is already a widely used technique for textur-
ing solid wood. State-of-art research handles rays and pores as well
as complex features caused by waving or spiraling behaviours of
specic hardwood species and considers ber directions, whereas
knots and splits remain as open topics of future work [Liu et al
.
2016;
Marschner et al
.
2005]. There are also several node-based editors
for procedural textures, such as Blender, that allow for interactive
editing of volumetric eects. Using such tools, knots would typically
be modelled by randomly distributing dots inside a standard wood
texture, and then adding deformations around them by noise or o-
setting. However, without organizing the texture around an internal
grafted skeleton, the relationship between the knots and the stem is
incorrect, e.g., the knots start growing anywhere rather than at the
pith (the central core of the stem skeleton). This limitation would
be particularly obvious when the wood is cut at or near the pith,
where the grafting point is revealed (Fig. 2e).
For materials and shapes other than wood, distance elds and
smooth minimums have been used for procedural texturing and
implicit modeling in general. Some research has proposed the use
of 3D distance elds for procedural texturing [Oliveira et al
.
2010].
Others have used 2D distance elds with smooth minimums to cre-
ate abstract patterns [Ehren Choy 2016]. Another study proposed
a general framework for the procedural modeling of layered solid
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

Procedural Texturing of Solid Wood with Knots •45:3
models including the minimum unions of solids [Cutler et al
.
2002].
Furthermore, the smooth minimum is commonly used for the im-
plicit geometry modeling of surfaces [Angles et al
.
2017; Gourmel
et al
.
2013; Quilez 2013]. The originality of our method compared to
these approaches is its application to volumetric knotted wood as
well as the specic techniques we propose to control the smooth
minimum to reproduce the observed eects.
2.3 Tree growth simulation
The growth of trees is divided into primary and secondary systems,
referred to as apical and cambial growth, respectively. Apical growth
elongates the tree and produces new strands of branches in various
directions. This type of growth is often modeled using L-systems or
the deformation of an input skeleton [Ijiri et al
.
2006; Lam and King
2005; Lindenmayer 1968; Pirk et al
.
2012]. Cambial growth adds a
layer of new material over the entire exterior surface of the tree
each year. This mode of growth is the main area of interest for this
paper, because the annual expansion in thickness gives rise to the
annual ring pattern. Previous studies have modeled cambial growth
using the level set method to simulate the annual expansion of a tree
based on various local conditions, such as sunlight, nutrition, and
the presence of obstacles [Kratt et al
.
2015; Mann et al
.
2006; Sellier
et al
.
2011]. These models handle complex and multi-stranded tree
skeletons, including knots. Mann et al. even considered dead knots
[Mann et al
.
2006]. However, the level set method is a growth model
where the shape expands over many time steps, and thus it tends to
be computationally expensive.
3 OBSERVATIONS
A knot starts growing from the pith of the stem and has a more
or less pronounced curvature pointing up or down. The speed of
growth of the volume expansion (added yearly thickness) is higher
for the stem than the knots, resulting in denser annual rings inside
the knots in comparison to the stem. In the presence of knots, the
stem grain is distorted when the bers of the stem are forced to
deviate from their otherwise relatively vertical path. Moreover, at
a given point, a knot is alive or dead, which aects its appearance
and distortion eect (Fig. 3).
Alive Alive
Dead
Dead
Outline
Side view Front viewSide view close-up
Fig. 3. Photographs of pine wood with knots.
3.1 Alive knots
An alive knot is intergrown with the stem, i.e., the stem grain ows
into the knot and becomes a part of it. The radius of the llet of
the stem-to-knot transition gradually increases over time; at an
older age close to the pith of the tree, the radius is smaller, and at
a younger age, the radius is larger [Foley 2003]. Moreover, knots
have a darker color than the stem grain.
3.2 Dead knots
After a branch dies, it stops growing in thickness. A dead knot is no
longer intergrown, and the deformation eect on the surrounding
grain decreases. Close to the edge of the knot, the smoothness tends
to invert, i.e., starts pointing inward toward the pith of the tree.
Moreover, buttery patterns occasionally appear around recently
dead knots. To understand the internal geometry that causes these
patterns, we CT scanned samples of wood (Fig. 4). The scans show
that the grain deformation is stronger above and below the knot
compared to the sides. We therefore conclude that buttery patterns
are caused by a nonuniform deformation around the axis of the knot.
Moreover, a dead knot darkens over time, and takes an outline.
Front view Top viewSide view
Fig. 4. CT-scan images of a wood sample with a buerfly distortion paern.
4 METHOD AND IMPLEMENTATION
The proposed method takes a 3D surface model as well as the inter-
nal and external geometry of a tree log as inputs and renders the
3D model with a knotted wood grain texture (Fig. 5). The procedure
rst calculates the time elds around each strand, i.e., the stem and
each knot (Sec. 4.1). Second, the time elds are combined using
smooth minimums while considering whether each knot is alive
or dead at the given point in time (Sec. 4.2). Third, the time val-
ues are translated into wood colors by sampling a wood color map
and additionally darkening the knots (Sec. 4.3). Finally, we present
the input tree log data and how they are encoded into images (Sec.
4.4). The process was written in OpenGL Shading Language (GLSL)
using less than 500 lines of code of the fragment shader, in which
the procedure is executed. The Phong lighting model was used for
illumination [Phong 1975].
Rendered
image
Wood color map
Knot mapsStem map
3D model Knot time
field (×n)
Stem time
field
Output
Inputs via
texture
memory
(Secs. 4.3-4.4)
Input Procedure (Secs. 4.1-4.2)
Combined
time fields
smin
Fig. 5. Overview of the proposed system.
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

45:4 •Larsson, et al.
4.1 Representation of annual rings
We dene the volumetric texture of the wood grain using a 3D
scalar eld representing the time when the growth occurred, which
we refer to as a time eld (Fig. 6). A tree grows from the center
outwards, and thus the time value is 0.0 along the pith of the tree,
and 1.0 on the exterior surface. An annual ring between can be seen
as an isocurve of the time eld, i.e., a curve implicitly dened by a
constant value (e.g., 0.4). The magnitude of the gradient (or distance
between annual rings) varies with the speed of the growth.
Time fieldWood grain
0.33 < t < 0.40
0.40 < t < 0.47
t=0.0 1.0
Fig. 6. Time field representation of wood grain.
4.1.1 Time field calculation. Time values are rst calculated sepa-
rately for each skeleton strand as the distance to the strand divided
by the speed of growth in the current direction. Or, in other words,
given the world coordinates of a point (
𝑃∈R3
) on a 3D model, the
time value (𝑡) for a skeleton strand is dened by
𝑡=
𝑑𝑖𝑠 𝑡 (𝑆, 𝑃 )
𝑣(𝑆, 𝛽 )(1)
where
𝑆∈R3
is the point on the strand nearest to
𝑃
, and
𝑣(𝑆, 𝛽 )
is
the speed of growth at point
𝑆
on the strand in the orientation
𝛽
of
𝑃around the strand.
Exact computation of the closest point
𝑆
is costly. Therefore, we
apply a simplication to take a pseudo-nearest point. For the stem,
we dene the pseudo-nearest point as the point on the stem skeleton
with equal height (
𝑧
) as
𝑃
. For knots, the pseudo-nearest point on
the branch skeleton is the point at an equal distance (
𝑑
) from the
stem as
𝑃
. Variation of the speed of growth is dened explicitly for
the stem through the outer shape of the input tree log geometry
(see Sec. 4.4). The speed of growth of the knots is set to a fraction of
the speed for the stem and, additionally, a variation is created inside
the procedure using periodic Perlin noise [Perlin 1985, 2002].
4.2 Stem-to-knot transition
The smooth minimum is commonly used to create unions with a
continuous seam between implicitly dened surfaces (Fig. 7, left).
When applied to time eld volumes, it creates a continuous seam
between each layer (Fig. 7, right).
Distance fields
(isocurve at 1.0)
da
db
da, dbmin(da,db)smin(da,db,k) ta, tbmin(ta,tb)smin(ta,tb,k)
Time fields (isocurves at 0.4, 0.8, ... 2.0)
tatb
Fig. 7. Minimums and smooth minimums of distance and time fields.
There are several established functions for smooth minimum
unions, including exponential,polynomial, and power smooth mini-
mums, which result in dierent shapes of the llets (Fig. 8) [Quilez
2013]. Among these, we use the power smooth minimum for two
reasons. First, there are no artifacts caused by negative values at
the skeleton grafting points, unlike for the exponential and polyno-
mial smooth minimums. Second, with the power smooth minimum,
the smoothness naturally increases over time, i.e., the radius of the
union is smaller closer to the pith and larger further out in the tree,
which is consistent with behaviour observed in real wood (see Sec.
3.1).
exponential_
smin(t
s
,t
b
,k)
k=8.0
polynomial_
smin(ts,tb,k)
k=0.4
power_
smin(ts,tb,k)
k=2.0
Our choice
Artifact Artifact
Increasing
radius
Fig. 8. Results of dierent smooth minimum functions.
The equation of the power smooth minimum function smin is
𝑠𝑚𝑖𝑛(𝑡𝑎, 𝑡𝑏, 𝑘)= 𝑡𝑘
𝑎𝑡𝑘
𝑏
𝑡𝑘
𝑎+𝑡𝑘
𝑏!1
𝑘
[𝑄𝑢𝑖𝑙𝑒𝑧 2013](2)
where
𝑡𝑎
and
𝑡𝑏
are scalar values at a point in the eld, and
𝑘
is a pa-
rameter that controls the degree of smoothness. A smaller
𝑘
results
in a softer union, whereas a larger value creates a sharper union. We
introduce a technique to ne-tune the shape of the smooth union by
adapting the parameter value (
𝑘
) within a eld (see Sec. 4.2.1). Fur-
thermore, we refer to the dierence between the smooth minimum
and minimum as the amount of smoothing (𝛿):
𝛿=𝑠𝑚𝑖𝑛(𝑡𝑎, 𝑡𝑏, 𝑘) − 𝑚𝑖𝑛(𝑡𝑎, 𝑡𝑏)(3)
This value (
𝛿
) is useful for the analytical purpose of visualizing the
amount of smoothing (e.g., red gradient in Fig. 9). Moreover, we
introduce a second technique to adjust the shape of the smooth
minimum by modifying 𝛿:
𝑠𝑚𝑖𝑛′(𝑡𝑎, 𝑡𝑏, 𝑘)=𝑚𝑖𝑛 (𝑡𝑎, 𝑡𝑏) + 𝛿′(4)
In particular, we use this technique for controlling the direction of
the grain distortion around a dead knot (see Sec. 4.2.2). We also use
the amount of smoothing (
𝛿
) to handle many knots with individual
smoothness properties in a single texture (see Sec. 4.2.3).
4.2.1 Modelling an alive knot. When joining the time elds of a knot
and the stem by the power smooth minimum, it naturally creates
the appearance of an alive knot: the thickness of the knot increases
with time and the knot is intergrown with the stem. However, we
want to adjust the balance of smoothness to create a sharper edge
of the knot without reducing its distortion eect in the stem. This is
achieved by an adaptive
𝑘
-value; we set a higher
𝑘𝑏
inside the knot
(for a tighter edge) and a lower
𝑘𝑠
outside the knot (for a stronger
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

Procedural Texturing of Solid Wood with Knots •45:5
distortion eect). We create a smooth transition between these two
𝑘
-targets based on the variable
𝑡Δ
, which is the signed dierence
between the time values of the stem (
𝑡𝑠
) and knot (
𝑡𝑏
). The result
is a more dened knot edge with a maintained distortion eect
compared to a constant 𝑘(Fig. 9).
smin(t
s
,t
b
,k(
tΔ
))
Constant k Adaptive k
δ δ
k
k(
tΔ
)
Ours
0.0
5.0
k=0.0
δ=-1.0
smin(ts,tb,k)
More
defined
edge
Maintained
impact
Fig. 9. An adaptive k-value (right) creates a more defined knot edge with
maintained distortion impact, in comparison to a constant k-value (le).
4.2.2 Modelling a dead knot. To make a knot stop growing in thick-
ness from when it dies (
𝑡†
), the expansion of the knot is gradually
decreased from this point onward to counteract the natural increase
in thickness (Fig. 10). Furthermore, we want to control the llet
around a dead knot such that the overall distortion eect decreases
and the direction of the llet changes close to the edge of the knot.
By adjusting the parameter
𝑘
, it is possible to increase or decrease
the smoothing eect, but not to invert it. Thus, another technique is
required. Building on Eq. 4, the amount of smoothing (
𝛿
) is modied
by scaling it by a factor
𝑓
. When scaled by a negative value, the
smoothness inverts. The factor
𝑓
is calculated as a function of two
variables: time since death (
𝑡†Δ
) and orientation around the knot
axis (
𝛽
). The time since death (
𝑡†Δ
) is used as a variable to gradually
change the direction of the smoothness with increased distance
from the point of death. The orientation (
𝛽
) is used to create a non-
uniform deformation around the knot axis to produce a buttery
pattern.
smin(ts,tb,k(tΔ))
if <t†
else
Result
smin(ts,tb’,k(tΔ)),
f(t†Δ,β)*δ
Alive
Dead
Fig. 10. Modelling a dead knot.
The value of interest for the next step in the calculation (joining
multiple knots to the stem, Sec. 4.2.3) is the modied amount of
smoothing (
𝛿′
), the complete calculation of which is summarized as
𝛿′=(𝑠𝑚𝑖𝑛(𝑡𝑠, 𝑡𝑏, 𝑘 (𝑡Δ)) − 𝑚𝑖𝑛(𝑡𝑠, 𝑡𝑏),if alive
𝑓(𝑡†Δ, 𝛽)·(𝑠𝑚𝑖𝑛(𝑡𝑠, 𝑡 ′
𝑏, 𝑘 (𝑡Δ)) − 𝑚𝑖𝑛(𝑡𝑠, 𝑡 ′
𝑏)),otherwise
(5)
4.2.3 Multiple knots. Finally, we want to merge multiple knots to
the stem. It is possible to extend the equation of the power smooth
minimum to perform a union between more than two elds at once
[Quilez 2013]. However, this is problematic in our case because it
does not allow us to control the smoothness individually for each
knot. Sequential smooth minimums are also problematic because the
order matters. Our solution is to calculate the modied smoothing
value (
𝛿′
𝑖
) for each pairwise
𝑖
-th knot and stem union separately, as
shown in Eq. 5 and add their sum to the regular minimum of all
knots (Fig. 11):
𝑠𝑚𝑖𝑛′(𝑡𝑠, 𝑡𝑏1, .. .,𝑡𝑏𝑛)=𝑚𝑖𝑛(𝑡𝑠, 𝑡𝑏1, ..., 𝑡𝑏𝑛) +
𝑛

𝑖=1
𝛿′
𝑖(6)
t1
t2
min(ts,tb1)
min(ts,tb2’)
min(ts,tb1,tb2’) δ1+δ2
δ1
δ2
Final result
1 2 3
4 5 6
9 8 7
Fig. 11. Joining the stem and multiple knots (Eq. 6).
4.3 Color rendering
To translate the time eld into wood colors, we map it to a one-
dimensional wood color map, i.e., an array of pixels. The wood
color map contains color information ranging from the pith to the
outer surface of the tree. It can be sampled from a picture of a stem
(Fig. 12), procedurally synthesized (using a separate process), or
manually designed using photo editing software. Furthermore, the
color of the knots are darkened during the procedure by subtracting
an arbitrary color inside the knots. In addition, we add an outline
around a dead knot, the thickness of which is varied with periodic
Perlin noise for a natural appearance.
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

45:6 •Larsson, et al.
Time field value: 0.0
Tree age (years): 0.0
1.0
28.0
0.5
6.0
Fig. 12. Wood color map.
4.4 Input tree log data
The input tree log data consist of its internal grafting skeleton, its
outer surface, and the point of dying of each knot. These data are
encoded in image les, which are uploaded to the texture memory
and sampled during the procedure. An advantage of using an input
geometry instead of generating it inside the procedure is portability
(saving instances of trees). This setup allows feeding data that have
been extracted from CT-scan slices of tree logs as input into the
procedure. The main benets of encoding the geometry in images
as opposed to text les, for example, are compactness and visual
verication. To avoid aliasing, the value ranges are kept as narrow
as possible and the image maps are sampled with a bi-cubic function.
The total size of the four image maps describing the input geometry
is approximately 400 KB in our current implementation (excluding
200 KB for the wood color data).
4.4.1 Stem geometry. The skeleton strand and outer surface of the
stem are encoded in an image, referred to as the stem map (Table
1 and Fig. 13). The horizontal image axis corresponds to the ori-
entation around the tree (
𝜔
), and the vertical axis corresponds to
the height inside the tree (
𝑧
). The pixel values encode the x- and
y-coordinates of the pith point, and the local stem radius. The pith
point varies with height (
𝑧
) but is constant along each row (the ro-
tation around the tree does not change the pith point), whereas the
local radius varies with the height (
𝑧
) and orientation (
𝜔
). The pro-
posed data structure is based on research documenting CT-scanned
timber logs [Grönlund et al
.
1995]. We currently use an RGB texture
image with a pixel resolution of 128 ×512 for the stem geometry.
Table 1. Geometric data encoded in the stem map.
Image Data Range
Axis X Rotation (𝜔) 0.0 to 2𝜋
YHeight (𝑧) 0.0 to ℎ
Color
RPith point x (𝑆𝑥)−0.5·𝑟𝑠𝑚𝑖𝑛 to 0.5·𝑟𝑠𝑚𝑖𝑛
GPith point y (𝑆𝑦)−0.5·𝑟𝑠𝑚𝑖𝑛 to 0.5·𝑟𝑠𝑚𝑖𝑛
BRadius (𝑟𝑠)𝑟𝑠𝑚𝑖𝑛 to 𝑟𝑠𝑚𝑎𝑥
ω
ω
z z
rs
Srmax
rmin
Fig. 13. Tree stem geometry and stem map.
4.4.2 Knot geometries. We encode the geometries of the knots in
three image maps: the knot height,knot orientation, and knot state
maps (Table 2 and Fig. 14). For these maps, the horizontal image axis
corresponds to the distance from the pith (
𝑑
), and the vertical image
axis to the knot index. For a particular knot index and distance from
the pith, the knot skeleton point is given by its height in the tree (
𝑧
)
and orientation around the vertical axis (
𝜔
), which are sampled from
the knot height and knot orientation maps, respectively. Both the
height and orientation values change with distance from the pith as
the height-wise curvature and rotational twist of the knot progress
(Fig. 14). The third map—the knot state map—indicates when the
knot is alive or dead. This data structure used to describe the knots
builds on knot formulas developed by Grönlund et al. and rened
by Andreu et al. and Johansson et al. to document structural timber
[Andreu and Rinnhofer 2003; Grönlund et al
.
1995; Johansson et al
.
2013]. We currently use three RGB images with a pixel resolution
of 32 ×256 for the knot geometries.
Table 2. Geometric data encoded in the three knot maps.
Image Data Range
All Axis X Pith distance (𝑑) 0.0 to 𝑟𝑠𝑚𝑎𝑥
YKnot index 1 to n
Knot
Color
RStart (𝑧0) 0.0 to ℎ
height GIncrease (𝑧+) 0.0 to 𝑟𝑠𝑚𝑖𝑛
map BDecrease (𝑧−) 0.0 to 𝑟𝑠𝑚𝑖𝑛
Knot
Color
RStart (𝜔0) 0.0 to 2𝜋
orientation GLeft (𝜔𝑐𝑐𝑤 ) 0.0 to 0.5𝜋
map BRight (𝜔𝑐𝑤 ) 0.0 to 0.5𝜋
Knot state
Color
RAlive T/F
map GTime of death (𝑡†) 0.0 to 1.0
d
Height (z)
Knot index
Knot index
d d
Orientation (ω) State
d
ω
z
1
23
4
5
...
...
nn-1
n-2
d
Fig. 14. Knot geometries and knot maps.
5 RESULTS
Our results consist of rendered images. First, we show dierent cut-
outs of the same tree geometry (Fig. 15). This result demonstrates
that, unlike previous texturing methods that distribute circular knots
spot-wise on a surface based on 2D texture coordinates [Dischler
and Ghazanfarpour 1999], our method recreates the appearance of
knots that are cut along their skeletons, and thus have a curved
conical prole. In another result, to demonstrate the expressiveness
of our model, we rendered the same cut-out with randomized knot
skeletons and parameters (Fig. 16). This shows that diverse shapes
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

Procedural Texturing of Solid Wood with Knots •45:7
and sizes of knots emerge by varying their curvatures and positions,
as well as speed of growth and time of death. Moreover, to show that
our method eciently handles many and diverse knots in a texture
that spans over a larger portion of a tree, we also present long
planks. These were rendered based on captured data extracted from
CT-scan slices from pine and spruce.
1
Furthermore, we present four
rendered images aimed at reproducing the grain patterns and colors
of reference photographs (Fig. 1). Specically, we reconstructed a)
wood with longitudinal cut thought a knot transitioning from alive
to dead, b) a buttery pattern around a dead knot, c) a knot located
at the boarder between the heart- and sapwood, and d) a typical
grouping pattern of multiple knots. For these rendered images, the
wood color maps were created using a separate small program that
exports a 1D wood grain pattern based on sample colors. We loaded
the captured data from a pine tree and manually searched for a good
position inside the tree. We occasionally changed the geometrical
data manually, such as the angular position of a knot, to better
match the reference image.
Finally, we show that our method can easily be extended for
representing common softwood products, namely CLT and plywood.
To produce these textures, we use the same pine tree geometry as
in Fig. 17a, but manipulate the input texture coordinates. First, for
CLT, the texture coordinates were oset and rotated orthogonality
to achieve a tiling eect (Fig. 18a). We also added noise to the colors
to achieve a contrast between neighboring planks. Second, plywood
(and also wood veneer) is manufactured through the rotational
cutting of a tree log. Therefore, to recreate the plywood texture,
the texture coordinates of the input 3D model were unrolled in a
corresponding manner (Fig. 18b).
The typical computation time for the rendered images presented
in this paper was under 1 s, using a texture memory of up to 600
KB. All images were rendered using a laptop computer with a 1.3
GHz CPU and GPUs of 15.8 and 19.8 GB.
6 EVALUATION
Our results were qualitatively evaluated by 10 wood experts from
academia (80%) and industry (20%). Their expertise include timber
grading, timber log scanning, mechanics of wood, as well as image
analysis of wood. Using an online questionnaire, we asked them to
rate and comment on the plausibility of the annual ring patterns
in four rendered still images (Figs. 1a, 1b, 1d, and 17b). Although
explicitly asked to comment on the shape of the annual ring pattern,
which is the primary focus of the current work, the experts often
mentioned colors in their answers. The average rating was 3.8 out
of 5 (1 = strongly disagree, 5 = strongly agree). The most highly
rated (4.0/5) image is shown in Fig. 1d. Expert 7 commented that the
annual ring pattern appears to be correct, while the knot color is
too dark. The second highest rated (3.9/5) rendered image is shown
in Fig. 1a. Expert 5 stated that this image shows a “very realistic
transition from a sound [alive] to dead knot.” The third highest rated
(3.7/5) image was the buttery pattern shown in Fig. 1b. Expert 3
stated that “one of the buttery wings should be a little larger than the
other,” whereas Expert 5 thought the distortion looked too regular.
1
Wereceived this data directly from the computed tomography (CT) laborator y, division
of Wood Science and Technology, Luleå Technical University, Sweden.
Fig. 15. Rendered images of dierent portions of a tree with constant pa-
rameters and knot skeleton
Fig. 16. Rendered images of same portion of a tree, with randomized pa-
rameters and knot skeletons (same wood color map).
a. Pine
b. Spruce
Renderd images of planks
Input tree log geometry
Fig. 17. Rendered images of planks and their corresponding input tree log
geometries that have been extracted from CT-scan data.
b. Plywood/veneera. Cross-laminated timber (CLT)
Fig. 18. Rendered images of sowood products.
The lowest rated (3.4/5) set of images was the spruce planks shown
in Fig. 17b, for which the experts cited an excessively light color
of the sapwood and an overly dark color of the knots. In summary,
the experts found the modelled annual ring patterns plausible. They
indicated that the results could be improved applying more noise to
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

45:8 •Larsson, et al.
the distortions, especially around the knots. It was further suggested
that the coloring need more ne-tuning. Refer to the supplementary
materials for the complete questionnaire and answers.
7 LIMITATIONS AND FUTURE WORK
The limitations of our model are as follows. Branches can naturally
fall o or be pruned. It is non-trivial to make the breaking o point
look natural inside the wood texture and thus we left this for future
work. Moreover, our current model cannot selectively change the
growth speed at an arbitrary year of an arbitrary height or angle.
Related to this limitation, the wood grain colors and number of
year rings do not change with height in our model, whereas in
reality, the top of a tree will have fewer annual rings and a larger
proportion of sapwood to heartwood in comparison to the bottom
of a tree. Furthermore, it is possible to add various features to make
the results of our function appear more like real wood, including
cracks, rays, pores, ber directions, as well as more high-frequency
detail in the annual ring pattern. Also, our model does not currently
include a reectance model (BRDF).
A general drawback of procedural models is that the visual result
of editing parameters is hard to predict. The results presented in
this paper are produced by the authors who have developed an
intuition for how to edit the parameters to achieve desired eects,
making the process of designing a texture rather eortless. It would
be more challenging for a novice user to reconstruct a knotted
wood texture with a specic intention. For such users, a parameter
overview in Appendix A is useful as a guide. Also, the almost instant
rendering time facilitates the trail and error process. Nonetheless,
future work might extend our method with an interface that enables
more intuitive texture design. Another direction for future work is
to use our modelling framework as a basis for the simulation of the
mechanical properties of knotted wood.
ACKNOWLEDGMENTS
This work was supported by a collaborative research fund between
Mercari Inc. R4D and RIISE, University of Tokyo, JST ACT-X Grant
Number JPMJAX210P, Japan, JST CREST Grant Number JPMJCR17A1,
Japan, and JST ACT-I Grant Number JPMJPR17UT, Japan. We would
further like to thank the anonymous reviewers and the participants
of the expert evaluation for their constructive feedback.
REFERENCES
Jean Philippe Andreu and Alfred Rinnhofer. 2003. Modeling knot geometry in norway
spruce from industrial CT images. Lecture Notes in Computer Science (including
subseries Lecture Notes in Articial Intelligence and Lecture Notes in Bioinformatics)
2749 (2003). https://doi.org/10.1007/3-540- 45103-x{_}104
Baptiste Angles, Marco Tarini, Brian Wyvill, Loïc Barthe, and Andrea Tagliasacchi.
2017. Sketch-based implicit blending. In ACM Transactions on Graphics, Vol. 36.
https://doi.org/10.1145/3130800.3130825
Barbara Cutler, Julie Dorsey, Leonard McMillan, Matthias Müller, and Robert Jagnow.
2002. A procedural approach to authoring solid models. In Proceedings of the 29th
Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’02.
https://doi.org/10.1145/566570.566581
Jean Michel Dischler and Djamchid Ghazanfarpour. 1999. Interactive image-based
modeling of macrostructured textures. IEEE Computer Graphics and Applications 19,
1 (1999). https://doi.org/10.1109/38.736470
Ehren Choy. 2016. Smooth Signed Distance Field Textures. Ph. D. Dissertation. Carleton
University, Ottawa.
Christina Foley. 2003. Modeling the eects of knots in Structural Timber. Ph. D. Disserta-
tion. Lund University. https://lup.lub.lu.se/search/publication/f026a551- 2812-4539-
98a2-0e7ee2ca4d5f
Forest Products Laboratory - USDA. 2010. Wood Handbook: Wood as an Engineering
Material.
Georey Y. Gardner. 1984. SIMULATION OF NATURAL SCENES USING TEXTURED
QUADRIC SURFACES. Computer Graphics (ACM) 18, 3 (1984). https://doi.org/10.
1145/964965.808572
Georey Y. Gardner. 1985. VISUAL SIMULATION OF CLOUDS. Computer Graphics
(ACM) 19, 3 (1985). https://doi.org/10.1145/325165.325248
Olivier Gourmel, Loic Barthe, Marie Paule Cani, Brian Wyvill, Adrien Bernhardt, Math-
ias Paulin, and Herbert Grasberger. 2013. A gradient-based implicit blend. ACM
Transactions on Graphics 32, 2 (2013). https://doi.org/10.1145/2451236.2451238
Anders Grönlund, Lars Björklund, Stig Grundberg, and Göran Berggren. 1995. Manual
för furustambank. Technical Report. Luleå Technical University.
Philipp Henzler, Niloy J. Mitra, and Tobias Ritschel. 2020. Learning a Neural 3D Texture
Space from 2D Exemplars. In Proceedings of the IEEE Computer Society Conference
on Computer Vision and Pattern Recognition. IEEE Computer Society, 8353–8361.
https://doi.org/10.1109/CVPR42600.2020.00838
Takashi Ijiri, Shigeru Owada, and Takeo Igarashi. 2006. The sketch L-system: Global
control of tree modeling using free-form strokes. In Lecture Notes in Computer
Science (including subseries Lecture Notes in Articial Intelligence and Lecture Notes
in Bioinformatics), Vol. 4073 LNCS. https://doi.org/10.1007/11795018{_}13
Erik Johansson, Dennis Johansson, Johan Skog, and Magnus Fredriksson. 2013. Auto-
mated knot detection for high speed computed tomography on Pinus sylvestris L.
and Picea abies (L.) Karst. using ellipse tting in concentric surfaces. Computers
and Electronics in Agriculture (2013). https://doi.org/10.1016/j.compag.2013.06.003
Johannes Kopf, Chi Wing Fu, Daniel Cohen-Or, Oliver Deussen, Dani Lischinski, and
Tien Tsin Wong. 2007. Solid texture synthesis from 2D exemplars. ACM Transactions
on Graphics (2007). https://doi.org/10.1145/1276377.1276380
J. Kratt, M. Spicker, A. Guayaquil, M. Fiser, S. Pirk, O. Deussen, J. C. Hart, and B. Benes.
2015. Woodication: User-Controlled Cambial Growth Modeling. In Computer
Graphics Forum, Vol. 34. https://doi.org/10.1111/cgf.12566
Z. Lam and Scott A. King. 2005. Simulating tree growth based on internal and envi-
ronmental factors. In Proceedings - GRAPHITE 2005 - 3rd International Conference
on Computer Graphics and Interactive Techniques in Australasia and Southeast Asia.
https://doi.org/10.1145/1101389.1101406
Aristid Lindenmayer. 1968. Mathematical models for cellular interactions in develop-
ment I. Filaments with one-sided inputs. Journal of Theoretical Biology 18, 3 (1968).
https://doi.org/10.1016/0022-5193(68)90079- 9
Albert Julius Liu, Zhao Dong, Miloš Hašan, and Steve Marschner. 2016. Simulating
the structure and texture of solid wood. ACM Transactions on Graphics (2016).
https://doi.org/10.1145/2980179.2980255
Joanne Mann, Mike Plank, and Andy Wilkins. 2006. Tree growth and wood formation
— applications of anisotropic surface growth. In Proceedings of the Mathematics in
Industry Study Group. 153–192.
Stephen R. Marschner, Stephen H. Westin, Adam Arbree, and Jonathan T. Moon. 2005.
Measuring and modeling the appearance of nished wood. In ACM Transactions on
Graphics. https://doi.org/10.1145/1073204.1073254
Guilherme N. Oliveira, Rafael P. Torchelsen, João L.D. Comba, Marcelo Walter, and
Rui Bastos. 2010. Geotextures: A multi-source geodesic distance eld approach for
procedural texturing of complex meshes. In Proceedings - 23rd SIBGRAPI Conference
on Graphics, Patterns and Images, SIBGRAPI 2010. https://doi.org/10.1109/SIBGRAPI.
2010.25
Darwyn R. Peachey. 1985. SOLID TEXTURING OF COMPLEX SURFACES. Computer
Graphics (ACM) 19, 3 (1985). https://doi.org/10.1145/325165.325246
Ken Perlin. 1985. An Image Synthesizer. In Proceedings of the 12th Annual Conference
on Computer Graphics and Interactive Techniques (SIGGRAPH ’85). Association for
Computing Machinery, New York, NY, USA, 287–296. https://doi.org/10.1145/
325334.325247
Ken Perlin. 2002. Improving Noise. In Proceedings of the 29th Annual Conference on
Computer Graphics and Interactive Techniques (San Antonio, Texas) (SIGGRAPH
’02). Association for Computing Machinery, New York, NY, USA, 681–682. https:
//doi.org/10.1145/566570.566636
Bui Tuong Phong. 1975. Illumination for Computer Generated Pictures. Commun. ACM
18, 6 (1975). https://doi.org/10.1145/360825.360839
Sören Pirk, Ondrej Stava, Julian Kratt, Michel Abdul Massih Said, Boris Neubert,
Radomír Měch, Bedrich Benes, and Oliver Deussen. 2012. Plastic trees: Interactive
self-adapting botanical tree models. ACM Transactions on Graphics 31, 4 (2012).
https://doi.org/10.1145/2185520.2185546
Inigo Quilez. 2013. Smooth minimum. https://www.iquilezles.org/www/articles/smin/
smin.htm
Damien Sellier, Michael J. Plank, and Jonathan J. Harrington. 2011. A mathematical
framework for modelling cambial surface evolution using a level set method. Annals
of Botany 108, 6 (2011). https://doi.org/10.1093/aob/mcr067
Kenshi Takayama, Makoto Okabe, Takashi Ijiri, and Takeo Igarashi. 2008. Lapped solid
textures: Filling a model with anisotropic textures. ACM Transactions on Graphics
27, 3 (2008). https://doi.org/10.1145/1360612.1360652
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.

Procedural Texturing of Solid Wood with Knots •45:9
A PARAMETERS USED IN THE PROCEDURE
Figs. 19-22 show the eect of adjusting the various parameters.
Parameters in Figs. 19a-b, 21a and 22a are controlled via the input
image maps (see Secs. 4.3 and 4.4). Other parameters are scalar
values that can be manually edited to achieve custom eects.
a. Knot skeleton curvature
b. Knot skeleton rotation around stem skeleton axis
vb=0.15
c. Knot speed of growth in thickness parameter (vb)
vb=0.20 vb=0.30
Fig. 19. Knot shape parameters.
k=1.5
a. Power smooth minimum smoothness parameter (k) (constant)
k=2.0 k=5.0
Amount of
smoothing (δ)
ks=1.0
kb=6.0
b. Power smooth minimum smoothness parameter (k(tΔ)) (adaptive)
ks=1.5
kb=5.0
ks=2.0
kb=4.0
Amount of
smoothing (δ)
Fig. 20. Smoothness parameters.
t†=0.05
a. Knot time of death (t†)
t†=0.15 t†=0.25
f=1.0
b. Smoothness inversion factor (f) around dead knot parameter
f=-1.0 Gradual
-0.25<f<1.0
Fig. 21. Dead knot parameters.
a. Wood color map input
0.0
b. Strength of added knot color parameter
1.0 2.0
0.0
c. Strength of dead knot color darkening parameter
2.0 3.0
0.0
d. Dead knot outline thickness parameter
0.015 0.025
Fig. 22. Color inputs and parameters.
ACM Trans. Graph., Vol. 41, No. 4, Article 45. Publication date: July 2022.