SplineLib: A Modern Multi-Purpose C++ Spline Library

02/27/2020 ∙ by Markus Frings, et al. ∙ RWTH Aachen University 0

This paper provides the description of a novel, multi-purpose spline library. In accordance with the increasingly diverse modes of usage of splines, it is multi-purpose in the sense that it supports geometry representation, finite element analysis, and optimization. The library features reading and writing for various file formats and a wide range of spline manipulation algorithms. Further, a new efficient and objective-oriented algorithm for B-spline basis function evaluation is included. All features are available by a spline-type independent interface. The library is written in modern C++ with CMake as build system. This enables it for usage in typical scientific applications. It is provided as open-source library.



There are no comments yet.


page 11

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Engineering design has to rely on a number of contributing aspects: innovation, designing, geometry representation, computing, planning, and predetermination of product properties Conrad2004 . An important helper tool in this process is Computer Aided Design (CAD) software. CAD is utilized to convey design information from the designer to the manufacturer. As such, it has long ago replaced manual drawings. While the way geometry is represented within CAD systems has remained unaltered for decades now, the role of the CAD software in the design process has indeed changed. The trend certainly moves towards a more holistic design process, which includes also the steps of purchasing, manufacturing, and sales. Furthermore—at least within the research community—CAD systems have become closely intertwined with analysis and optimization steps.

Given the importance of CAD software, we will now repeat the key ideas of geometry representation within this context. A type of geometry representation common to most CAD systems are splines and in particular Non-Uniform Rational B-splines (NURBS). As illustrated in Rogers2001 , the success of this spline type in CAD goes back to Versprille Versprille:1975aa as well as Tiller and Piegl Tiller:1983aa ; Piegl1987 . As a member of the category of parametric geometry representations, NURBS can easily represent multi-valued functions. Further, they feature a high level of smoothness and differentiability. They are invariant under affine transformations and provide local control over geometry. Finally, they are able to represent free-form shapes and—in the engineering context so important—conic sections Rogers2001 . Common exchange formats for NURBS are IGES Smith:1986sm or STEP pratt2001introduction .

In 2005, Hughes et. al introduced the concept of isogeometric analysis (IGA). Here, the key idea is the use of spline functions as interpolation functions for the unknown solution in a finite element context. Originally conceived to bridge the gap between CAD and analysis, the concept soon proved to be advantageous also solely from the analysis point of view. As detailed in


, key advantages of the IGA approach are: (1) exact (as in CAD-conforming) geometry representation; (2) user-controlled smoothness and continuity of the basis; (3) in general higher accuracy per degree of freedom; (4) in general variation diminishing property. IGA has been applied to many different fields, including phase field methods for the Cahn-Hilliard equations

Gomez2008 , brittle fracture Borden2012 , topology optimization Dede2012 , or fluid-structure-interaction Hsu2012 ; Hosters2018 .

Another field of research that can profit largely from spline representations is shape optimization. Here, a geometry representation based on splines not only ensures easy incorporation into the standard design and manufacturing process, but also provides a means to include shape constraints into the parameterization. Shape optimization with splines in the form of free-form deformation is for example demonstrated in salmoiraghi2018free , spline boundary representations are utilized in hirschler2018isogeometric ; herrema2017framework ; lian2016implementation ; fusseder2015fundamental ; kostas2015ship .

In view of the requirements of CAD, IGA, and shape optimizations, the aim of this work is to propose an open source C++ spline library. One question the reader might ask at this point is: “Where is the need for yet another spline library?”. Naturally, we are aware of the manifold spline libraries relying on a variety of programming languages and licensing concepts. However, these libraries usually focus on one specific application. In contrast, this library aims to be applicable to all three application areas mentioned above.

The predecessor of the proposed library was an in-house development written in FORTRAN. It was essential in a variety of scientific publications, addressing shape optimization and IGA within the context of numerical flow simulations (e.g., siegbert2013design ; siegbert2015individualized ). However, it turned out that there is a high demand for a multi-purpose spline library in the scientific computing community. Therefore, the development of a new C++ spline library was published as open source project under the LPGL3 license. All experiences made while developing the FORTRAN library were used to improve the new development.

Besides a wide range of different functionality, also requirements regarding programming language, build system, and supported computer systems were taken into account. The proposed spline library is fully written in modern C++, a programming language increasingly replacing FORTRAN in the scientific community. We point out that it is easily possible to couple C++ code to other scientific programming languages like Python or FORTRAN. With the intention of developing a state-of-the-art library, the most recent C++-17 standard is used. As a result, the library can make use of modern object oriented designs; but the recent standard also requires a recent compiler. However, almost every system can be equipped with a recent Clang, GCC, or Intel compiler.

As build system, CMake Kitware:2012 is used. This system is available for most high-performance computing (HPC) machines. However, on HPC machines it is crucial to install software with all its dependencies. The more dependencies a software package requires, the more complicated the installation becomes. Fortunately, Gamblin et. al. Gamblin:2015aa made a great effort in the last years to develop Spack as a dependency manager for scientific software. The proposed software library comes with support for Spack. Therefore, installation of the library and all its dependencies is quite simple. That makes the software usable for a wide range of scientists without caring about dependencies.

To maintain a high software quality, SplineLib is tested by means of the Google testing framework Civil:2013 . This is combined with continuous integration and a test coverage that is in the area of 100%. The resulting number of tests simultaneously serves as a set of examples on how to use the library. There is no need to read a large documentation. Instead, the user can look for a test case suitable to the application at hand.

The paper provides an overview over the main features and implementational constituents of SplineLib. It concludes with two basic sample test cases from the area of IGA and shape optimization.

2 Splines

This section gives a brief introduction into the definition of splines. A detailed description of splines—as well as corresponding properties and algorithms—can be found in Piegl:2012aa .

In general, splines map from a parametric space to a physical space. Let there are basis functions defined in the parameter space. In the -dimensional physical space , a control point is associated with each basis function. A parametric coordinate is mapped to the physical space by (1) evaluating each basis function at ; (2) multiplying these values with the corresponding control points; (3) summing up all products:

The definitions of the various spline types differ in the way the parametric space and the basis functions are defined. SplineLib currently supports B-splines and the related NURBS, but implementation of further spline techniques is envisaged. From the class of these splines, solely the so-called clamped splines are considered. Clamped splines are those that interpolate their boundary control points exactly.

For simplicity, the current description is restricted to one-dimensional splines as higher dimensional splines (surfaces, volumes, etc.) are constructed by using tensor products of one-dimensional splines. In contrast, the software library at hand supports splines of arbitrary dimension because the parametric dimensionality is implemented as a template parameter.

The parametric space is defined by a knot vector

. A knot vector is a non-decreasing sequence of real numbers (potentially non-uniformly spaced):

where is called a knot. Based on the knot vector , the -th knot span is defined as:


A knot span is called non-zero if . Given these knot spans, the B-spline basis functions are defined from basis functions of degree zero by using the Cox-de Boor recursion formula:


The number of control points for a spline of degree is given as

Note that the fraction can occur in Eq. (2) if a knot vector contains the same knot times. This ratio is defined to be zero:

Given these basis functions, a -th degree B-spline curve can be written as


It is well-known that B-splines have their limitations if geometries become more complex. For example, it is not possible to exactly represent a circle by a B-spline curve. NURBS overcome this limitation Versprille:1975aa ; Tiller:1983aa . In contrast to B-splines, NURBS map to a weighted physical space. Utilizing the B-spline basis functions, a NURBS curve is defined as


where are the weights assigned to the control points. Introducing

Eq. (4) can be rewritten as

This form resembles the B-spline definition in Eq. (3) with the exception of the definition of basis functions.

In the spline library both types of splines can be accessed by a common spline interface. This allows for a spline-type independent code development. Even new spline types as for example T-splines or PB-splines can be used without any relevant modifications if they are implemented within a later release of the software.

3 Implementation: Evaluation of B-Spline Basis Functions

There are manifold ways in which Eq. (2) can be translated into a computer algorithm. Two key issues to keep in mind are possible repetitive evaluations of individual components and the occurrence of zero values in the denominator.

A commonly used and very efficient procedural algorithm for evaluating the B-spline basis functions is considered in Piegl:2012aa . In contrast to such procedural algorithms, the algorithm proposed here benefits from an object-oriented approach. Its design is based on the idea of reflecting the evaluation procedure in a data structure. Furthermore, it only checks once for zero denominators. The key ideas are outlined in the next two sections.

3.1 Data Structure for B-Spline Basis Functions

Reviewing the definition of the B-spline basis functions in Eq. (2) gives rise to the present design idea illustrated in Fig. 1: There are two types of B-spline basis functions that need to be distinguished, viz., of degree and of degree . The former are jump functions. Instead, evaluating the -th B-spline basis function of degree requires a linear combination of the two basis functions and .

An abstract base class BasisFunction defines the common interface of B-spline basis functions of arbitrary degree . The basis function is characterized by its degree_ and its support specified by start_knot_ and end_knot_. The support starts with the -th knot span (cf. Eq. (1)) and covers knot spans. Therefore, it is usually given as . In the special case that equals the last knot of the knot vector , must be included in the support (cf. second case of Eq. (1)). Thus, the support is given as if end_knot_is_last_knot_ is set to true during the construction of an object of type BasisFunction.

Both ZeroDegreeBSplineBasisFunction and BSplineBasisFunction derive from this abstract class. The former implements a step function whose support is a single knot span. It represents the base case of the recursion. The latter takes the linear combination in the Cox-de Boor recursion formula Eq. (2) into account by storing pointers to objects of the basis functions of lower degree and in left_lower_degree_ and right_lower_degree_, respectively. As the associated denominators only depend on the knot vector, they do not change for a specific BSplineBasisFunction. Hence, their adequately inverted values are computed during construction using InvWithPosZeroDenom and stored in left_denom_inv_ and right_denom_inv_.

When the factory function CreateDynamic is called with a knot vector kv, a knot span start_support (corresponding to the start of the basis function’s support), and a degree deg, the object hierarchy is constructed. An object of type ZeroDegreeBSplineBasisFunction or BSplineBasisFunction is created depending on whether deg is equal to zero or not. Within the constructor of BSplineBasisFunction, the two objects for both lower degree B-spline basis functions are instantiated.

Figure 1: UML class diagram for B-spline basis functions.

The B-spline basis functions’ derivatives of arbitrary degree can also be computed by linearly combining corresponding derivatives of lower order B-spline basis functions. Therefore, the proposed data structure is also well-suited for computing derivatives of arbitrary degree.

3.2 Evaluation Algorithm

The methods Eval or EvalDeriv of a BSplineBasisFunction evaluate the function or its derivatives of arbitrary degree deriv at a parametric coordinate pc, respectively. Within those two, IsCoordInSup is called to check if pc is contained in the support of the BasisFunction object. If the parametric coordinate is not contained in the support, evaluating the functions and their derivatives yields zero. Otherwise, EvalOnSup or EvalDerivOnSup are called. Their actual implementations are provided by ZeroDegreeBSplineBasisFunction and BSplineBasisFunction.

Since ZeroDegreeBSplineBasisFunction is a jump function, it evaluates on its support simply to one while all derivatives are equal zero. In contrast, evaluating a BSplineBasisFunction involves two non-trivial ingredients (cf. Eq. (2)): First, computing both fractions; second, evaluating the lower degree B-spline basis functions and . The two fractions are computed by calling CompLeftQuot and CompRightQuot. Each method utilizes start_knot_ or end_knot_ to evaluate the numerator. Next, its product with the values of the inverted denominator stored in left_denom_inv or right_denom_inv is computed. These results are then multiplied with the values of the lower degree functions—accessed through left_lower_degree_ and right_lower_degree_—and, finally, added.

4 SplineLib Features

This section describes the main utility functions of SplineLib: Input/Output and spline manipulation. Again, the multi-purpose idea has been emphasized.

4.1 Input and Output

SplineLib supports the four different file formats ITD, IGES, VTK and XML. ITD is the native file format used in IRIT. The application IRIT is a free-form geometric modeling environment developed by Elber Irit15 . It supports modeling of rational and non-rational B-spline curves, surfaces, and trivariate volumes. The latter is a feature almost unique to IRIT. In the past, IRIT has been utilized in connection with IGA antolin2019isogeometric ; antolin2019optimizing ; massarwi2016b .

A similar format to ITD is based on Extensible Markup Language (XML). The XML-type data format for storing spline geometrical and related data was native to the FORTRAN library developed at the Chair for Computational Analysis of Technical Systems. The XML format stores splines of arbitrary degree and dimension. It was mainly developed in an IGA context. Therefore, it can be used to store the spline geometry together with additional data. The data can be defined as element data or control point data. For practical reasons, it is only implemented for dimensions up to four. This allows for typical three-dimensional computations as well as four-dimensional space-time computations, where time is handled as additional dimension. However, SplineLib can easily be extended to support higher dimensions. Parsing and writing XML files is built on top of the open-source library pugixml pugixml .

Initial Graphics Exchange Specification (IGES) Smith:1983aa is another file format that allows the digital exchange of geometry information among CAD systems. The IGES format was introduced in 1979 and became the standard for transferring multi-dimensional models between CAD programs. Although there are newer formats nowadays, it is still widely used. Therefore, supporting IGES enables SplineLib to import and export data, that is relevant in industry. IGES itself supports not only spline geometries, but also other types of data. These are for example color information, meshes, and polylines. The SplineLib implementation, however, focuses on NURBS and B-spline curves and surfaces. All other IGES entries are ignored.

For post-processing data from computational fluid dynamics, an often used tool is Paraview Ahrens:2005aa

. Paraview is an open-source software for data visualization and analysis. It is built on top of the Visualization Toolkit (VTK)

Schroeder:1999aa . VTK provides its own file format. Although it cannot represent splines, they can be visualized by converting them into a mesh. As meshes cannot be transformed back into splines, SplineLib only provides a VTK writer and no reader. This writer can be used to convert data obtained by SplineLib into mesh data for visualization and analysis. The SplineLib API provides the user with the possibility to decide on the resolution of the mesh. Thus, it can be adjusted to the relevant data. The VTK export does not only convert the geometry, but can also add further element or control point data to the VTK file. As a result, this exporter can be used to visualize data obtained by optimization or IGA with the well-developed tools for post-processing.

SplineLib also provides an interface to convert data between these different formats. This functionality closes the gap between the different application areas.

4.2 Spline Manipulation

In addition to the support of multiple file formats, the second main feature implemented in SplineLib are the two most fundamental geometric algorithms for splines: (1) knot insertion/removal, and (2) subdivision.

Knot insertion is a means of improving the local control of the spline properties. Key to knot insertion is that it only acts on the parametric representation: It is important that the global geometry of the spline remains unaltered. In order to achieve this, new control points need to be inserted and others repositioned. The algorithm in SplineLib has been adapted from Piegl:2012aa . In particular, the adaption concerns the spline dimension, which in SplineLib is implemented as template parameter.

In a similar fashion, knots can be removed. Note that in contrast to knot insertion—depending on the specific scenario—knot removal may not be possible without altering the spline geometry. In those cases, deviations (in terms of Euclidean distance) of the altered spline from the original one are bounded by a user-specified tolerance.

One particular extension of knot insertion is spline subdivision. It relies on inserting the same knot repeatedly, until -continuity is reached. At this point, the splines can be separated by splitting the original knot vector. Also this algorithm has been extended to arbitrary dimension.

5 Application Examples

This final section is devoted to two application examples: IGA and optimization.

5.1 Iga

In order to demonstrate the applicability of SplineLib to solve partial differential equations (PDEs) using IGA, we consider Poisson’s equation. The general boundary value problem is given as:

with unknown function , source term , the computational domain with boundary and constants , , and some function . In the following, we restrict ourselves to homogeneous Dirichlet boundary conditions ( and ). Furthermore, we assume a constant source term of . The weak form is obtained by multiplication of the PDE with an arbitrary weighting function and integration over the computational domain . Following Galerkin’s method, the same function space is used for both the solution candidate and the weighting function. The finite-dimensional subspace is represented by the spline basis function. Considering the rational basis function , the discrete weak form reads

Note in particular that this approach uses the isoparametric principal, where the same basis functions are used for geometry representation and analysis. Element-wise integration, i.e., integration on tensor-products of non-zero knot spans, by means of Gaussian quadrature then leads to

where denotes the element number, the integration points, and the indices of the non-zero basis functions and are the integration weights. The resulting linear equation system is solved using Armadillo sanderson2016armadillo ; sanderson2018user , an open-source linear algebra library. More details on the formation of the linear equation system and IGA in general are provided in Hughes:2005 .

The IGA framework based on SplineLib distinguishes itself from other IGA codes by the implementation of the parametric dimensionality of the spline as template parameter. Thereby, the user is enabled to solve PDEs on splines of arbitrary dimensionality using the same code.

The functionality of the IGA framework was verified using analytical solutions provided in elman and solutions computed using finite element solvers. To demonstrate the capability to compute solutions for problems of higher dimensionality, the solution of the given reference problem is approximated inside the unit cube . This problem is equivalent to finding the temperature distribution inside a cube with uniform heating and faces that are kept at zero temperature. To visualize the solution, three slices through the cube are created normal to the -, - and -axis. These slices are shown in Fig. 2. The temperature distribution is equal on all slices and is equal to the solution that would be obtained for the same boundary value problem on the square plate . The highest temperature is reached in the center of the cube and decreases when getting closer to the boundary of the cube. The temperature distribution is spherically symmetric.

The IGA framework in SplineLib can certainly also be used for much more complex geometries. A simple example is used here, since the exact solution of this problem can be represented using a series expansion. This is not the case for complex geometries.

Figure 2: Solution of the reference problem on the unit cube.

5.2 Optimization

A simple shape optimization problem is considered to demonstrate the value of SplineLib’s functionalities. The shape to optimize is a second-degree B-spline curve with the following properties: The knot vector is given as

and the shape is represented by the three two-dimensional control points

where is the design variable for the optimization. The design variable is subject to a bound constraint by . The initial value is . How to construct (as well as evaluate) this initial spline is shown in Fig. 3 (further examples can be found at https://github.com/mfcats/SplineLib/tree/master/example).

array<Degree, 1> degree = Degree2;
KnotVectors<1> knot_vector_ptr =       make_shared<KnotVector>(KnotVector( ParamCoord0, ParamCoord0, ParamCoord0, ParamCoord1, ParamCoord1, ParamCoord1)); vector<ControlPoint> control_points = ControlPoint(-1.0, 0.0), ControlPoint( 0.0, 0.0), ControlPoint( 1.0, 0.0); BSpline<1> b_spline(knot_vector_ptr, degree, control_points); b_spline.Evaluate(ParamCoord0.5, 1);

Figure 3: Initial spline constructed and evaluated in the second dimension at .

The target shape is a parabola given as

Thus, the objective function is the area between the B-spline and the parabola on the interval .

To solve this simple optimization problem, an executable using SplineLib evaluates the objective function for a given control point coordinate . This objective function is coupled to the optimization framework Dakota Adams:2018aa . The gradient-free COBYLA algorithm is applied to the optimization problem. For visualization purposes, VTK output is used. The result of each optimization step is written into a single VTK file.

The result is shown in Fig. 4. The solution converges to the target shape within 32 iterations.

Figure 4: Solution steps for a simple shape optimization problem.

With this example the application of SplineLib in an optimization environment is shown. Due to the amount of supported input and output formats it is a straightforward step to use SplineLib also in more complex and real-world applications.

6 Conclusion

A new multipurpose C++ spline library is presented. The aim of the library is to close the gap between different research fields. Therefore, interfaces to commonly used file formats are provided. With being able to represent not only curves and surfaces, but also splines of higher dimensions, SplineLib can be used in many applications. For the evaluation of basis functions and their derivatives, a newly developed algorithm is facilitated. In this algorithm, the procedural approach of evaluating the basis functions is realized as a data structure. The main application areas SplineLib aims to connect are CAD, IGA, and optimization. How to use SplineLib in these areas is shown in simple application examples.

From this initial state, it is necessary to further develop SplineLib. It is required to make SplineLib more powerful, e.g., by supporting recent spline techniques and incorporating elaborate algorithms. Here, we welcome the input of the community via GitHub (https://github.com/mfcats/SplineLib).


The authors gratefully acknowledge the support of Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under the Collaborative Research Center SFB 1120, subproject B2, the Cluster of Excellence “Integrative Production Technology for High-Wage Countries” EXC 128, and the International Research Training Group “Modern Inverse Problems” 33849990/GRK2379.



  • [1] B. M. Adams, L. E. Bauman, W. J. Bohnhoff, K. R. Dalbey, M. S. Ebeida, J.P. Eddy, M.S. Eldred, P.D. Hough, K.T. Hu, J.D. Jakeman, J.A. Stephens, L.P. Swiler, D.M. Vigil, and T.M. Wildey.

    Dakota, a multilevel parallel object-oriented framework for design optimization, parameter estimation, uncertainty quantification, and sensitivity analysis: Version 6.8 theory manual.

    Technical report, Sandia Technical Report SAND2014-4253, 2018.
  • [2] James Ahrens, Berk Geveci, and Charles Law. Paraview: An end-user tool for large data visualization. The visualization handbook, 717, 2005.
  • [3] Pablo Antolin, Annalisa Buffa, Elaine Cohen, John F Dannenhoffer, Gershon Elber, Stefanie Elgeti, Robert Haimes, and Richard Riesenfeld. Optimizing micro-tiles in micro-structures as a design paradigm. Computer-Aided Design, 2019.
  • [4] Pablo Antolin, Annalisa Buffa, and Massimiliano Martinelli. Isogeometric analysis on v-reps: first results. arXiv preprint arXiv:1903.03362, 2019.
  • [5] M.J. Borden, J. Michael, C.V. Verhoosel, M. Scott, T. J.R. Hughes, and C. Landis. A phase-field description of dynamic brittle fracture. Computer Methods in Applied Mechanics and Engineering, 217:77–95, 2012.
  • [6] Gennadiy Civil. googletest. https://github.com/abseil/googletest, 2018.
  • [7] K.-J. Conrad, editor. Taschenbuch der Konstruktionstechnik. Fachbuchverlag Leipzig, 2004.
  • [8] J. A. Cottrell, T. J. R. Hughes, and Y. Bazilevs. Isogeometric Analysis: Toward Integration of CAD and FEA. John Wiley & Sons, Ltd, 2009.
  • [9] L. Dedè, M.J. Borden, and T.J.R. Hughes. Isogeometric Analysis for Topology Optimization with a Phase Field Model. 19:427–465, 2012.
  • [10] Howard C Elman, David J Silvester, and Andrew J Wathen. Finite elements and fast iterative solvers: with applications in incompressible fluid dynamics. Numerical Mathematics and Scientific Computation, 2014.
  • [11] Daniela Fußeder, Bernd Simeon, and A-V Vuong. Fundamental aspects of shape optimization in the context of isogeometric analysis. Computer Methods in Applied Mechanics and Engineering, 286:313–331, 2015.
  • [12] Todd Gamblin, Matthew LeGendre, Michael R. Collette, Gregory L. Lee, Adam Moody, Bronis R. de Supinski, and Scott Futral. The spack package manager: Bringing order to hpc software chaos. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC ’15, pages 40:1–40:12, New York, NY, USA, 2015. ACM.
  • [13] Héctor Gómez, Victor M Calo, Yuri Bazilevs, and Thomas JR Hughes. Isogeometric analysis of the cahn–hilliard phase-field model. Computer methods in applied mechanics and engineering, 197(49-50):4333–4352, 2008.
  • [14] Austin J Herrema, Nelson M Wiese, Carolyn N Darling, Baskar Ganapathysubramanian, Adarsh Krishnamurthy, and Ming-Chen Hsu. A framework for parametric design optimization using isogeometric analysis. Computer Methods in Applied Mechanics and Engineering, 316:944–965, 2017.
  • [15] Thibaut Hirschler, Robin Bouclier, Arnaud Duval, Thomas Elguedj, and Joseph Morlier. Isogeometric sizing and shape optimization of thin structures with a solid-shell approach. Structural and Multidisciplinary Optimization, pages 1–19, 2018.
  • [16] Norbert Hosters, Jan Helmig, Atanas Stavrev, Marek Behr, and Stefanie Elgeti. Fluid–structure interaction with nurbs-based coupling. Computer Methods in Applied Mechanics and Engineering, 332:520–539, 2018.
  • [17] Ming-Chen Hsu and Yuri Bazilevs. Fluid–structure interaction modeling of wind turbines: simulating the full machine. Computational Mechanics, 50(6):821–833, 2012.
  • [18] T.J.R. Hughes, J.A. Cottrell, and Y. Bazilevs. Isogeometric analysis: CAD, finite elements, NURBS, exact geometry and mesh refinement. Computer Methods in Applied Mechanics and Engineering, 194(39):4135 – 4195, 2005.
  • [19] Irit. Irit 11.0 user’s manual. http://www.cs.technion.ac.il/$$irit, 2015. Technion.
  • [20] Arseny Kapoulkine. pugixml. https://pugixml.org, 2018. [Online; accessed 31-May-2019].
  • [21] Kitware, Inc. CMake. http://cmake.org, 2012.
  • [22] KV Kostas, AI Ginnis, CG Politis, and PD Kaklis. Ship-hull shape optimization with a t-spline based bem–isogeometric solver. Computer Methods in Applied Mechanics and Engineering, 284:611–622, 2015.
  • [23] Haojie Lian, Pierre Kerfriden, and Stéphane PA Bordas. Implementation of regularized isogeometric boundary element methods for gradient-based shape optimization in two-dimensional linear elasticity. International Journal for Numerical Methods in Engineering, 106(12):972–1017, 2016.
  • [24] Fady Massarwi and Gershon Elber. A b-spline based framework for volumetric object modeling. Computer-Aided Design, 78:36–47, 2016.
  • [25] L. Piegl and W. Tiller. Curve and surface constructions using rational b-splines. CAD, 19:485–498, 1987.
  • [26] Les Piegl and Wayne Tiller. The NURBS book. Springer Science & Business Media, 2012.
  • [27] Michael J Pratt. Introduction to iso 10303—the step standard for product data exchange. Journal of Computing and Information Science in Engineering, 1(1):102–103, 2001.
  • [28] D.F. Rogers. An Introduction to NURBS with Historical Perspective. Morgan Kaufmann Publishers, 2001.
  • [29] Filippo Salmoiraghi, Angela Scardigli, Haysam Telib, and Gianluigi Rozza. Free-form deformation, mesh morphing and reduced-order methods: enablers for efficient aerodynamic shape optimisation. International Journal of Computational Fluid Dynamics, 32(4-5):233–247, 2018.
  • [30] Conrad Sanderson and Ryan Curtin. Armadillo: a template-based c++ library for linear algebra. Journal of Open Source Software, 1(2):26, 2016.
  • [31] Conrad Sanderson and Ryan Curtin. A user-friendly hybrid sparse matrix class in c++. In International Congress on Mathematical Software, pages 422–430. Springer, 2018.
  • [32] Will Schroeder, Kenneth M Martin, LS Avila, and CC Law. The VTK user’s guide. Kitware, 1999.
  • [33] Roland Siegbert, Stefanie Elgeti, M Behr, K Kurth, C Windeck, and Ch Hopmann. Design criteria in numerical design of profile extrusion dies. In Key Engineering Materials, volume 554, pages 794–800. Trans Tech Publ, 2013.
  • [34] Roland Siegbert, Nafi Yesildag, Markus Frings, Frank Schmidt, Stefanie Elgeti, Henning Sauerland, Marek Behr, Christian Windeck, Christian Hopmann, Yann Queudeville, et al. Individualized production in die-based manufacturing processes using numerical optimization. The International Journal of Advanced Manufacturing Technology, 80(5-8):851–858, 2015.
  • [35] Brad Smith and Joan Wellington. INITIAL GRAPHICS EXCHANGE SPECIFICATION (IGES), VERSION 3.0. 1986.
  • [36] Bradford M Smith and Joan Wellington. Iges, a key interface specification for cad/calm systems integration. Computer-Aided Geometry Modeling, page 279, 1983.
  • [37] W. Tiller. Rational b-splines for curve and surface representation. IEEE Computer Graphics and Applications, 3:61–69, 06 1983.
  • [38] Kenneth James Versprille. Computer-aided design applications of the rational B-spline approximation form. PhD thesis, Syracuse University, 1975.