Almost every multipurpose scientific
visualization and visual analytics tool allows to build volumetric surfaces to
graphically represent functional dependencies expressed as . When it is about scientific experiments, very often f is a
table of discrete values obtained during measurements or mathematical modeling.
Thereby the sample rate of f is limited by the experiment’s circumstances
and the result surface may become very rough. While the most popular rendering
technique nowadays is polygonalization, the visual quality of corresponding
images with low sample rates of f become unacceptable (see Fig. 1a).
The one has to apply some smoothing interpolation to the set of values to
achieve attractive and observable results.
One of the most popular ways in computer
graphics to create smooth surface according to the discrete set of points is to
build NURBS [1]. However, this way is often inappropriate for visual
analytics needs, because NURBS surface does not contain the original point set
using it as vertices of bounding lattice (as shown in Fig. 1b) and thereby
does not really reflect the process under analysis.
The other way is to use smooth
(continuously differentiable) interpolation functions like, for example,
Hermite splines [2]. But this way in turn often gives socalled outliers:
misplaced extremes on the surface, which do not belong to the original point
set (as shown in Fig. 1c). Sometimes it is all right to have these
outliers for sake of surface smoothness, but in some specific situations this
can be a critical issue in terms of visual analytics. For example, if f
is a table of temperature measurements across some area, the Fig. 1c will
deliver potentially false information about the raise of temperature between two
points in topright corner. Especially if the samples of f are actually
close to each other, the oscillation like in Fig. 1c is in fact very
improbable and highly unwanted by showing continuously distributed values.
a b c
Fig. 1. Surface (painted blue) constructed
by the set of control points (painted red) using different approaches: linear
interpolation (a), NURBS (b), Hermite splines (c).
This paper addresses the problem of
building the sleekappearing 3D surface with no misplaced extremes according to
the discrete set of points. While this problem is indeed crucial for solving
several tasks of visual analytics, many visualization systems lack the
efficient implementation of such kind smoothing. In the previous work [3] 2D
case was considered and the solution for building sleek 2D curves according to
the discrete point set was proposed. The present work is an improvement and
generalization of that approach to the 3D case.
The surface ksmoothness is normally
defined as the ability to be continuously differentiated k times, C^{k},
k > 0. Alternatively, according to E. Weisstein, a
surface parameterized in variables u and v is called smooth if
the tangent vectors and in the u and v directions satisfy [4].
However when it comes to the visualization
and, in particular, visual analytics, the most important is how the surface is
perceived and whether it can deliver proper information to the person examining
the data. The perception in general is subjective, but it is based on the shape
and the shading. While mathematically smooth surfaces are perceived
sleek, the surfaces with derivative discontinuities (socalled C^{0}surfaces)
are not necessary perceived creasy. Moreover, if the shape is actually creasy,
the proper shading can effectively mask it (which is widely used in computer
graphics to perform visually attractive presentation of lowpolygon
approximations of 3D models).
Taking into account the visual analytics
needs, the list of quality criteria for the surface built by the discrete set
of points , , is pretty the same as the list of quality criteria for curves in [3]:
1.
The surface should be an interpolation of , this means, it should contain .
2.
The surface should be perceived as sleek as
possible: there should be no noticeable creases, or their number should be
minimal.
3.
There should be no misplaced extremes on the
surface: minimum and maximum on the should be in border points
and the surface should not oscillate in the defined area.
4.
There should be no selfintersections on the
surface if the corresponding linearly interpolated surface has no ones.
5.
The surface should not oscillate in the vertical
direction and for each should not intersect the
bounding box with the sides parallel to vertical axis and containing .
6.
The building algorithm should be as efficient as
possible.
The logic behind these criteria is
described in detail in [3] related to the 2D curves and can be transferred as
is to the 3D case.
Smoothing algorithms may spawn misplaced
extremes in different combinations of neighbor points, so it is matter of
elaborate testing to prove that the particular algorithm gives stable results.
Table 1 contains the data set used in this paper for demonstration purposes.
This data set is quite random (the data are generated artificially), but it
clearly shows the misplaced extremes problem in all the algorithms the
developed one is compared to.
Table 1.
Data set used for demonstration purposes

x = 0

x = 1

x = 2

x = 3

x = 4

x = 5

x = 6

z = 0

1.321

1.657

1.165

1.215

1.623

1.236

1.657

z = 1

1.265

1.654

1.154

1.165

1.153

1.648

1.654

z = 2

1.324

1.264

1.547

1.125

1.246

1.465

1.264

z = 3

1.165

1.654

1.125

1.154

1.315

1.135

1.654

z = 4

1.157

1.654

1.165

1.300

1.136

1.168

1.654

z = 5

1.215

1.658

1.184

1.156

1.163

1.185

1.658

It should be stressed, that while the
proposed algorithm has no misplaced extremes on this particular data set, it is
not at all the proof of its stability, because this data set does not cover all
possible combinations of points positions. The stability of the proposed method
was proven by solving the realworld visual analytics tasks, see the Section 6.
The problem of creating smoothed versions
of rough surfaces relates not only to the scientific visualization and visual
analytics, but also to other branches of computer graphics and computational
geometry (including photorealistic rendering, computeraided design, etc.). In
polygonbased 3D graphics the smoothing of surfaces is all about subdivision
– representing surfaces with more polygons than the origin point cloud ensures.
In terms of mathematics, there are generally two types of subdivision: approximation
and interpolation.
Approximation does not necessary contain
the original set of points. The basics of approximation are described in
details by C.T. Loop [5]. The examples of this approach are NURBS surfaces
with their different modifications (like TSplines [6]). Modern 3D
graphics editors implement similar algorithms, for example, CatmullClark
subdivision [7] used in Blender [8]. But the problem of these methods is always
the same: approximated surfaces are typically enclosed in the original ones as
it is shown in [5] and can be seen in Fig. 2. This means, they do not suit
the very first criteria mentioned in the Section 2.
Fig. 2. Surface built by test point set
and subdivided with CatmullClark algorithm in Blender.
Interpolated surfaces meet the first
criterion containing their control points. The interpolation algorithms can
widely vary. The most popular are based on the cubic polynomials, like cubic
Hermite interpolation mentioned above. The variety and variability of
interpolation approaches gives the ground to create a custom algorithm that
could meet all the criteria formulated.
There are several methods of monotone
interpolation in 3D space. For example, the works by M. Abbas et al. [9] and L.
AllemandGiorgis et al. [10] cover C^{1}continuous smooth
interpolation of gridded data, ensuring absence of misplaced extremes inside
the input data domain. These methods normally meet all the criteria indicated
in the Section 2, but being restricted by C^{1}continuity
they are unable to handle cornercases like very steep slopes (for example,
data sets of with nonfunctional dependency, where some neighbor points have
the same abscissa). Also, as it is shown below, these methods are not yet
integrated into the popular scientific visualization and visual analytics
software.
In case the interpolation between 4 control
points P_{1}, P_{2}, P_{3}, P_{4}
is known and represented as curves c_{0}(s), c_{1}(s),
d_{0}(t), d_{1}(t), , c_{0}(0) = d_{0}(0) = P_{1}, c_{0}(1)
= d_{1}(0) = P_{2}, c_{1}(0) = d_{0}(1)
= P_{3}, c_{1}(1) = d_{1}(1) = P_{4}, the
Coons patch [11] can be constructed to build the smooth surface between
these curves using the following formula:
,
(1)
where I
represents some interpolation and B represents biinterpolation.
The interpolation method can vary. For
example, in case of linear interpolation for I and correspondingly
bilinear for B, the components of formula (1) yield in the following:
,
,
.
The result surface is called bilinearly
blended Coons patch. An example is shown in Fig. 3.
Fig. 3. Bilinearly blended Coons patch.
Discussed Coons patch exactly meets its
boundary curves, but if multiple patches are joined, they do not necessarily
have the same tangent planes at joint curves leading to the creases along those curves. To fix this problem, I can be cubic and B
– bicubic interpolation. To find the exact representation of I and B,
cubic Hermite splines can be used with the weights chosen to match the partial
derivatives at the corners. The result is called bicubically blended Coons
patch.
Coons patch is a handy tool to build the
surface that potentially can meet the criteria mentioned
in the Section 2, but the problem is to find the
corresponding curves between control points.
The modern scientific visualization
software that is capable of 3D rendering normally provides functions to build
surfaces by given set of points. The most popular tools provide automatic
smoothing as well.
One of the most popular and powerful
systems incorporating huge amount of mathematical solvers and providing a lot
of visualization capabilities is Wolfram Mathematica [12]. Among other
functions, it allows building surfaces by the discrete set of points. There are
two interpolation modes available: Hermite (function Interpolation with
parameter Method>"Hermite") and Bspline [13] (function Interpolation with
parameter Method>"Spline"). The results of both applied to the testing data set from the Section 3 are shown in Fig. 4.
a b
Fig. 4. Surface built by Wolfram
Mathematica using Hermite interpolation (a) and Bspline interpolation (b).
As it can be seen from the figure, Hermite
interpolation (the exact weights are not mentioned in the documentation of
Mathematica) is better than Bspline interpolation according to the criteria
mentioned in the Section 2, but still has some
false extremes (for example, in topright corner).
A lot of scientific visualization software utilize
VTK library [14] under the hood, for example ParaView [15] and its
lightweight version for mobile devices KiwiViewer [16]. VTK supports wide
range of rendering techniques and data visualization function. It provides abstract
class vtkSubdivisionFilter to generalize approximation and interpolation algorithms for
building surfaces. Currently, 3 methods are included in the VTK core: vtkLoopSubdivisionFilter that implements smoothing algorithm introduced by C.T. Loop [5], vtkButterflySubdivisionFilter that implements socalled butterfly scheme introduces by D. Zorin
et al. [17] and vtkLinearSubdivisionFilter that implements regular linear interpolation (the surface is not
smoothed). The rendering results of all these methods applied to the testing
data set are shown in Fig. 5.
a b c
Fig. 5. Surfaces built by VTK using Loop’s
algorithm (a), butterfly algorithm (b) and linear interpolation (c).
As seen from Fig. 5, Loop’s method
behaves like NURBS: the surface does not contain the control points. Thereby,
this method does not meet the very first criterion. The butterfly filter suites the first criterion, but spawns misplaced
extremes and oscillations. The linear subdivision filter does not build sleek
surface. Consequently, VTK does not provide the desired smoothing function.
The next popular library for scientific
visualization is MathGL [18]. This library is not as versatile as VTK
concentrating on the charts only, but it is also used in a wide range of
applications requiring highquality visualization. MathGL generally provides
two ways to build the surface by the discrete set of points: splinebased
interpolation (accessible with the refill function) and linear interpolation
(accessible with the datagrid function). The rendering results are shown in Fig. 6.
a b
Fig. 6. Surfaces built by MathGL using
spline interpolation (a) and linear interpolation (b).
The shape of surface in Fig. 6a is
very similar with the one in Fig. 4b. Probably, similar approaches are
used. As in the previously considered software, MathGL either builds the
surface that is not perceived sleek, or spawns misplaced extremes and
oscillations.
Taking into account the above mentioned
examples it can be stated that the misplaced extremes of smooth surfaces are
still an issue, even in the worldleading visualization software solutions.
Thereby the problem of creating the algorithm meeting all the criteria from the
Section 2 is an
important task in scientific visualization and visual analytics.
In the previous research we developed an
algorithm of building sleek 2D curves without misplaced extremes [3]. The
curves consist of cubic Bezier segments with the intermediate control points
calculated using a set of heuristics. Taking this algorithm as a background, we
propose its 3D generalization.
Assume having – a set of input points
distributed in as a regular grid in 3D space. Lets assume for disambiguation,
that this grid is distributed in XOZ and Y is vertical axis. Building
a smooth surface according to this point set consists of the following
highlevel steps:
1.
For , build a smooth curve by the points , . This curve consists of m – 1 Bezier segments
denoted as .
2.
For , build a smooth curve by the points , . This curve consists of n – 1 Bezier segments denoted
as .
3.
For , build a Coons patch based
on curves , , , with the constant resolution . Currently no special heuristics for calculating R are
developed and it is just an external algorithm parameter.
4.
Triangulate the set of points built in step 3.
As long as the input point set is assumed to be a regular grid, the
triangulation is trivial.
5.
Calculate vertex normals using smoothing groups
algorithm.
6.
Additionally smooth the field of normals with
Gaussian blur function.
The asymptotic complexity of this algorithm
is O(mn), which suites the mentioned criteria of efficiency. The
result of this algorithm applied to the testing data set is shown in
Fig. 7.
Fig. 7. Surface built by the proposed
algorithm.
As it can be seen from the figure, neither
misplaced extremes nor oscillations are presented. The above steps are
described in details in the upcoming subsections. The results are discussed in the
Section 6.
As a first step of building result surface,
its 2D slices are considered and each slice is treated as a piecewisedefined Bezier curve. The key contribution of [3] is
the way to calculate intermediate control points , , and to join the neighbor Bezier segments and without visible crease as shown in
Fig. 8a (this figure is extracted from [3] for the sake of clarity). To
ensure the absence of misplaced extremes and oscillations on the result curve,
the following conditions should be fulfilled for each segment:
1.
The points and should lay on the tangent to the result curve
in the point .
2.
The lengths of
tangent vectors should be equal: .
3.
The intermediate
control points and should belong to the areas and respectively depicted
in Fig. 8b.
a b
Fig. 8. Joining of two Bezier curves (a)
and areas the intermediate control points belong to (b).
The algorithm of meeting the above
conditions proposed in [3] is presented in pseudo code in Listing 1. It
must be noted, that these conditions altogether generally lead to the curve of
smoothness order 0, so formally speaking this curve is not smooth. The creases
on the curve appear in the corner cases like equal abscissa of
neighbor points or transition from one “plateau” (sequence
of points with equal ordinate) to another. The algorithms ensuring
smoothness order 1 and higher spawn misplaced extremes in these cases, but our
algorithm does not. Instead, it “breaks” the formal smoothness locally in
corner cases. Because normally the number of
creases is low, the result curve is perceived sleek, which exactly matches the
desired criteria of quality.
Listing 1. Pseudo code of the sleek curve building algorithm.
1.
Input: array of 2D points , .
2.
Let represent the tangent to the Bezier segment in its starting point.
The initial value is zero vector.
3.
Let represent the tangent to the Bezier segment in its ending point.
The initial value is zero vector.
4.
Let represent the vector from the previous point to the current one.
5.
Let represent the vector from the current point to the next one: .
6.
For each :
6.1. Reuse the previously calculated tangent: .
6.2. Reuse the previously calculated vector: .
6.3. Calculate the denormalized difference: .
6.4. Calculate new :
6.4.1.
If , then:
6.4.1.1.
.
6.4.1.2.
If or , then .
6.4.1.3.
Else if or , then .
6.4.1.4.
Else .
6.4.2.
Else .
6.5. Clamp and to the areas and respectively:
6.5.1.
If , then .
6.5.2.
If , then .
6.5.3.
If , then .
6.5.4.
If , then .
6.6. Let be the flag indicating whether .
6.7. Let be the flag indicating whether .
6.8. Calculate and – lengths of the corresponding tangents for the current Bezier
segment (assuming – algorithm’s parameter):
6.8.1.
If is true, then , else .
6.8.2.
If is true, then , else .
6.8.3.
If , then:
6.8.3.1.
If , then , else .
6.8.4.
If , then:
6.8.4.1.
If , then , else .
6.8.5.
If both and are false, then:
6.8.5.1.
Let .
6.8.5.2.
If , then:
6.8.5.2.1.
Let .
6.8.5.2.2.
If and , then:
6.8.5.2.2.1.
If , then , else .
6.8.6. Create the Bezier segment with the following control points: , , , .
According to the assumption, the input
points are distributed in the regular grid. Each cell of this grid is an area
between 4 neighbor points bounded with 4 corresponding Bezier segments obtained
in the previous steps. To build the result surface, each cell is treated as a
Coons patch and the intermediate points inside this cell are calculated
according to the formula (1) with the resolution R, which means, new points are emitted.
To ensure better shading of the result
surface, its wireframe should be as close to the regular grid as possible.
However, each cell is bounded by parametric Bezier segments, and the result
points depend nonlinearly on the
parameter. This means, if
the parameter changes linearly, X and Z coordinates of result
points change nonlinearly. To
ensure a regular grid, the parameter should be changed in a nonlinear way.
The cubic Bezier
segment is calculated as follows:
,
(2)
where , are the points from the input data set,
, are the intermediate control points calculated according to the
algorithm shown in Listing 1,
.
Each bounding curve is parallel to either X
or Zaxis being a part of regular grid. This means, only the pairs {X,
Y} or {Z, Y} are calculated by (2).
Consider the curve parallel to Xaxis.
Zcoordinates of its points are all the same and X changes
according to (2). Lets assume, the parameter t is changed linearly from
0 to 1 with the step ^{1}/_{R}. To ensure linear
changing of Xcoordinate, should be calculated using the new parameter that should be found by solving the following equation:
.
(3)
This equation can be solved by wellknown Cardan
formula. After this, the points become equidistant in Xdirection. The similar calculations
are applied to the curves parallel to Zaxis. As a result, the regular wireframe
for each Coons patch is ensured.
The next problem to be solved is the
joining of neighbor patches. Using the bilinear blending in formula (1) results
in the surface shown in Fig. 9. The field of normals is calculated using
trivial smoothing groups algorithm [19]: each vertex normal is an average
of normals of incident triangles.
a b
Fig. 9. Surface built using bilinearly blended
Coons patches without marks (a) and with the visible creases marked by ovals
(b).
As it can be seen, the creases are visible
disturbing the sleek appearance (for the sake of clarity, the most problematic
places are marked with ovals in the Fig. 9b). The common solution of this
problem is using bicubic blending instead of bilinear one.
The cubic interpolation can be expressed by
the following formula [20]:
(4)
Bicubic interpolation yields in the
following [20]:
(5)
The bicubic blending in formula (1) is the
based on formulas (4) and (5). The nontrivial part is that this kind of blending
requires neighbor curves to build the current patch as shown in the
Fig. 10.
Fig. 10. Bicubically blended Coons patch
with the neighbor curve segments that are used in bicubic interpolation.
In the corner cases, where some of , , , do not exist (on the surface’ boundary), the nonexisting segments
are assumed to be equal to , , , respectively for the sake of unification.
The result of bicubically blended Coons
patches is shown in the Fig. 11.
a b
Fig. 11. Surface built using bicubically blended
Coons patches without marks (a) and with the visible creases marked by ovals
(b).
As it can be seen, the quality gets higher,
but still is not high enough. The problem is, that the initial curves indeed
have noncontinuous derivative in these places. While they are perceived sleek
when viewed in 2D, the shading of corresponding 3D surface makes the creases remarkable,
because it is calculated by nonsmooth normals’ field.
The possible solutions are either to
increase the radius of smoothing groups used for calculating vertex normals, or
to perform artificial smoothing of normals’ field.
We decided to remove the creases by
applying the smoothing to the field of normals. This approach appears more
flexible because enables different smoothing functions. We have chosen Gaussian
blur filter, because it effectively smooths out the values preserving the high influence
of the median and thereby not spoiling the surface’ curvature information
represented by the field of normals.
We apply the Gaussian blur filter as a
convolution like it is traditionally done in image processing. The vertex
normals are processed componentwise. To build the convolution kernel, the
following formula is used:
,
(6)
where r is
the blur radius,
– indices of kernel items.
The kernel is not normalized; instead, the
normals are renormalized after blurring.
The radius r is a parameter to be
tuned. It affects the strength of blur; therefore it should be big enough to
remove the creases, but not too big to preserve the curvature information of
the surface (or the shading gets unnatural because the normal won’t reflect the
actual surface shape). Obviously this parameter depends on the resolution,
because the bigger is the resolution, the more vertex normals are on the
surface, the bigger should be the kernel to cover the areas with the creases.
We conducted a lot of experiments and found out, that the acceptable balance
between smoothness and correct shape shading is achieved when the radius is
about one fifth of the resolution. So, we propose the following formula:
.
(7)
For example, for the resolution 17 the
kernel radius will be 3. The result rendering after smoothing the normals field
with Gaussian filter using the mentioned parameters is presented in
Fig. 12.
a b
Fig. 12. Surface built using bicubically blended
Coons patches and Gaussian filtering of the normals field without marks (a) and
with the ovals marking the places the creases used to be in the previous steps
(b).
We consider the visual quality of the
obtained result high enough.
As demonstrated on the test data set, the
proposed method allows building the surfaces perceived sleek and having no
misplaced extremes. The core of the developed algorithm is the method of
building sleek 2D curves avoiding misplaced extremes that we proposed more than
a year ago [3]. Since then, this algorithm was intensively tested in the
production by visualizing different realworld data within the multiplatform
charting library NChart3D [21] and scientific visualization system SciVi [22].
The proposed generalization of this algorithm to the 3D case is as well integrated
into both NChart3D and SciVi. It already runs in production delivering
highquality results.
According to this testing we can state that
the proposed solution completely suites the criteria mentioned in the Section 2 and is thereby applicable for solving the
corresponding scientific visualization and visual analytics tasks.
The proposed algorithm has the following
limitation: it assumes, the points of the input set are distributed in the
regular grid, covering this grid completely without tears. To bypass this
limitation, some kind of regularization should be applied to the initial data
set as a preprocessing stage. The regularization can be based on interpolation
to fill up the tears in the grid. However in the case of unstructured
(irregular) grid or a sparse grid the proposed method in its current form is
hardly usable.
In the present work we considered the
problem of highquality graphical representation of functional dependencies
expressed as . By investigating the wellknown software capable of 3D surface
building and rendering we found out that the misplaced extremes and
oscillations are an issue of almost all modern interpolation techniques in 3D
case.
We proposed an approach to build sleek 3D
surfaces interpolating the given discrete set of points and avoiding misplaced
extremes and oscillations. This approach ensures rendering results of high
visual quality and can be used by solving scientific visualization and visual
analytics tasks. The developed algorithm was integrated into the software
NChart3D and SciVi and used in solving realworld visualization tasks in
various application domains. During its usage in the production it proved its
correctness and stability.
The only limitation is the requirement that
the input data should be presented in a form of a regular grid. As a future
work we plan to investigate the possible ways to bypass this limitation without
much computational effort.
The authors’ implementation of the proposed
algorithm written in C++ is available on GitHub under terms of MIT license [23]:
https://github.com/icosaeder/sleeksurface.
1.
Weisstein, E.W. NURBS Surface [Electronic
Resource] // MathWorld – A Wolfram Web Resource. URL: http://mathworld.wolfram.com/NURBSSurface.html
(last accessed 01.09.2018).
2.
Spitzbart, A. A Generalization of Hermite's
Interpolation Formula // The American Mathematical Monthly. – Mathematical
Association of America, 1960. – Vol. 67, No. 1. – PP. 42–46.
3.
Ryabinin, K.V. Visualization of Smooth
Curves without Misplaced Extremes Based on Discrete Point Set // Scientific
Visualization. – National Research Nuclear University “MEPhI”, 2017. – Q. 1,
Vol. 9, No. 1. – PP. 50–72.
4.
Weisstein, E.W. Smooth Surface [Electronic
Resource] // MathWorld – A Wolfram Web Resource. URL: http://mathworld.wolfram.com/SmoothSurface.html
(last accessed 01.09.2018).
5.
Loop, C.T. Smooth Subdivision Surfaces
Based on Triangles // Master Thesis. – Department of Mathimetics, University of
Utah, 1987. – 74 P.
6.
Sederberg, T.W., Zheng, J., Bakenov, A., Nasri,
A. Tsplines and TNURCCs // ACM Transactions on Graphics. – 2003. – 22, 3
(July). – PP. 477–484.
7.
Catmull, E., Clark, J. Recursively
generated Bspline surfaces on arbitrary topological meshes // ComputerAided
Design. – Elsevier, 1978. – Vol. 10 I. 6. – PP. 350–355. DOI: 10.1016/00104485(78)901100.
8.
Blender 3D Editor [Electronic Resource]. URL: https://www.blender.org/ (last accessed
01.09.2018).
9.
Abbas, M., Majid, A.A., Awang, M.N.H.,
Ali J.M. MonotonicityPreserving Rational BiCubic Spline Surface
Interpolation // ScienceAsia. – 2014. – Vol. 40S. – PP. 22–30. DOI: 10.2306/scienceasia15131874.2014.40S.022.
10. AllemandGiorgis, L., Bonneau, G.P., Hahmann, S., Vivodtzev, F.
Piecewise Polynomial Monotonic Interpolation of 2D Gridded Data // Topological
and Statistical Methods for Complex Data – Springer, 2014. – PP. 73–91.
11. Coons, S.A. Surfaces for ComputerAided Design of Space Forms
// Technical Report. – Project MAC, MIT, 1967. –
105 P.
12. Wolfram Mathematica [Electronic Resource]. URL: https://www.wolfram.com/mathematica/ (last accessed 01.09.2018).
13. Lee, E.T.Y. A Simplified BSpline Computation
Routine // Computing. – Springer, 1982. – Vol. 29, I. 4. – PP. 365–371.
14. VTK Library [Electronic Resource].
URL: https://www.vtk.org/ (last
accessed 01.09.2018).
15. ParaView Scientific Visualization
System [Electronic Resource]. URL: https://www.paraview.org/ (last
accessed 01.09.2018).
16. KiwiViewer Scientific Visualization
System [Electronic Resource]. URL: https://www.kitware.com/kiwiviewer/ (last
accessed 01.09.2018).
17. Zorin, D., Schröder, P., Sweldens, W. Interpolating
Subdivision for Meshes with Arbitrary Topology // SIGGRAPH’96 Proceedings of
the 23^{rd} annual conference on Computer graphics and interactive
techniques. – ACM, 1996. – PP. 189–192.
18. MathGL Library [Electronic Resource]. URL: http://mathgl.sourceforge.net/doc_en/Main.html (last accessed 01.09.2018).
19. Ryabinin, K.V. Virtual Reality and Multimedia. Building a
Virtual World with OpenGL // Tutorial Book. – Perm State University, 2018. –
100 p.
20. Breeuwsma, P. Cubic interpolation [Electronic Resource]. URL: http://www.paulinternet.nl/?page=bicubic (last accessed 01.09.2018).
21. Ryabinin, K.V. Development of Multiplatform Charting Library //
Scientific Visualization. – National Research Nuclear
University “MEPhI”, 2014. – Q. 1, Vol. 6. No. 1. – PP. 51–67.
22. Ryabinin, K.V., Chuprina, S.I. Development of
OntologyBased Multiplatform Adaptive Scientific Visualization System //
Journal of Computational Science. – Elsevier, 2015. – Vol. 10. – P. 370–381.
23. The MIT License [Electronic Resource]. URL: https://opensource.org/licenses/MIT
(last accessed 01.09.2018).