Camar

on: An Open-source Visualization Tool for the Quality Inspection

of Polygonal and Polyhedral Meshes

Aldo Canepa

, Gonzalo Infante

, Nancy Hitschfeld

and Claudio Lobos

Departamento de Ciencias de la Computaci

on, FCFM, Universidad de Chile, Santiago, Chile

Departamento de Inform

atica, Universidad T

ecnica Federico Santa Mar

ıa, Santiago, Chile

Keywords:

Polygonal Meshes, Polyhedral Meshes, Quality Criteria, Data Visualization, GLSL.

Abstract:

The numerical simulation of phenomena requires a good quality discretization (mesh) of the domain. De-

pending on the problem to be simulated, the mesh has to fulﬁl different quality criteria. Because of geometry

restrictions or point density requirements, several mesh elements might not satisfy the required quality criteria

and sometimes it is also not required that all elements fulﬁl them. Then, it would be helpful to know where

unwanted elements are located in order to see if they need to be repaired or not. That is why a visualization

tool that allows the user to inspect a mesh before a simulation is performed can be useful to prevent simulation

problems. Moreover, if data from simulations is available, the visualization of geometrical properties together

with simulation data could be also helpful to understand not expected results. These challenges have motivated

us to develop Camar

on, a visualization tool for large surface and volume meshes described in this paper. The

surface meshes can be composed any polygonal cell and the 3D meshes can include any convex polyhedral

cell. This tool was implemented in C++ and the OpenGL Shading Language (GLSL). We discuss the design

and implementation issues that make our software portable, extensible and different from other visualization

tools. We also compare the performance between Camar

on and GeomView, TetView and MeshLab.

1 INTRODUCTION

The numerical simulation of complex objects requires

a good domain discretization (mesh). In 2D, meshes

are usually composed of triangles and/or quadrilater-

als and, in less frequent cases, of convex polygons.

In 3D, meshes are commonly composed of tetrahedra

and/or hexahedra. In case of mixed element meshes,

pyramids, prisms and other convex polyhedra might

also be included. A good quality mesh depends on

the problem to be solved and the chosen numerical

method. Different quality criteria have been deﬁned

using geometric properties of the mesh elements such

as minimum (dihedral) angle, maximum (dihedral)

angle, and aspect ratio, among others. Quality criteria

are used to control the reﬁnement and improvement

process of a mesh. Because of geometry restrictions

or point density requirements, frequently not all mesh

elements fulﬁl the quality criteria required by the user.

It would be helpful to know where bad elements are

located in order to try to improve them. That is why

a visualization tool that allows the user to inspect a

mesh before a simulation is performed can be useful

to prevent simulation problems.

Currently, there are several open-source visualiza-

tion tools, some of them only dedicated to visualize

the spatial discretization and others to visualize sci-

entiﬁc data together with the mesh. Both types of

visualization tools render meshes composed of only

one element type or a limited type of elements, and

are usually associated to a mesh generator. For ex-

ample, TetView (Si, 2013) is related to the tetrahe-

dral mesh generator TetGen (Si, 2015) and it is able

to visualize tetrahedral meshes. GeomView (Amenta

et al., 1995) was specially designed for the visualiza-

tion of surface meshes composed of any polygonal

cell. A tool that integrates mesh generation and vi-

sualization is MeshLab (Cignoni et al., 2008). It is

oriented to generate, repair and process 3D triangu-

lar meshes. MayaVi (Ramachandran and Varoquaux,

2011), VisIt (Childs et al., 2011; VisIt, 2015) and Par-

aView (Henderson and Ahrens, 2004) are popular vi-

sualization tools oriented to visualize large datasets

by providing techniques to analyze them. These last

tools are implemented on VTK (Vtk, 2015; Hanwell

et al., 2015), a software system that supports a vari-

ety of visualization algorithms including scalar, vec-

tor, tensor, texture, and volumetric methods. None of

130

Canepa, A., Infante, G., Hitschfeld, N. and Lobos, C.

Camarón: An Open-source Visualization Tool for the Quality Inspection of Polygonal and Polyhedral Meshes.

DOI: 10.5220/0005830501280135

In Proceedings of the 11th Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP 2016) - Volume 1: GRAPP, pages 130-137

ISBN: 978-989-758-175-5

them allow the user interactive evaluation of the geo-

metrical mesh quality and the visualization of meshes

composed of any convex polyhedral cells. Note that

the use of different element types reduces the amount

of edges, faces and elements in the ﬁnal mesh that is

why the generation of polyhedral meshes is starting to

be considered (Garimella et al., 2013; Contreras and

Hitschfeld-Kahler, 2014).

In this paper, we present the design and imple-

mentation of an open-source portable and extensible

visualization tool for large polygonal and polyhedral

meshes. The current implementation allows the user

to: (1) open and save a mesh from/to formats such

as OFF, PLY, M3d, Ansys, TRI and Visf. Visf is

an own binary format, designed to handle polyhedral

meshes. It is an extension of the OFF format that

can also store neighboring information, (2) apply to

the mesh several rendering strategies such as ﬂat and

Phong shading, property and data visualization ren-

dering, (3) evaluate the mesh using known quality cri-

teria such as minimum and maximum (dihedral) an-

gle, aspect ratio and volume, (4) select mesh elements

that fulﬁl speciﬁc quality criteria or intersect a prim-

itive such as a sphere, a set of polygons deﬁning a

convex polyhedron, or a set of planes, and (5) gener-

ate statistics to identify if the mesh has the expected

quality or not. The tool was implemented in C++ and

GLSL (Wolf, 2011). We did not implemented this

tool on VTK because we wanted to use as efﬁcient

as possible the computational resources and permit

the visualization of non-manifold meshes. We also

wanted to design an extensible software in selection,

rendering and evaluation strategies. The results of a

performance and memory usage comparison among

Camar

on, GeomView, TetView and MeshLab shows

that our tool is faster but uses more memory than the

other tools.

This paper is organized as follows: in Section 2

we introduce the motivation and challenges of our

work. In section 3 we describe the tool architec-

ture, in particular, the methodology we have followed,

and design and implementation issues. In section 4

we compare Camar

on with Meshlab, GeomView and

TetView both in performance and memory usage and

in Section 5 we include the conclusions and future

work.

2 MOTIVATION AND

CHALLENGES

We are interested in developing new algorithms for

the generation of polyhedral meshes for different kind

of applications. Each application usually requires that

the mesh fulﬁlls particular quality criteria, but some-

times it is difﬁcult or impossible to generate only

good quality elements. Through the visual inspection

of a mesh it can be detected where bad quality ele-

ments are located and decide if the mesh still needs

improvements or it can be already used. In order to

support this kind of inspection of a mesh, we have de-

cided to develop a new visualization tool where a user

can:

• Handle any element shape (convex polygons and

polyhedra)

• Apply the most known quality criteria

• Generate statistics about the quality of the ele-

ments

• Detect where unwanted elements are

• Apply different rendering strategies

• Select mesh elements through several selection

strategies

• Visualize large meshes

• Open and save meshes stored in the most known

formats

In addition, it is important for us to develop soft-

ware that is portable and easy to extend in quality

criteria, input/output formats, rendering and selection

strategies.

3 TOOL ARCHITECTURE

This section starts with the description of the method-

ology we have used to develop Camar

on, then contin-

ues with main aspects of the design and ﬁnishes with

implementation details and the user interface.

3.1 Methodology

In this work, we take advantage of our experience

developing extensible object-oriented software for

building families of meshing tools (Bastarrica and

Hitschfeld-Kahler, 2006; Rossel et al., 2014). Our

design considers (1) types and subtyping to model

the objects whose instances can evolve in time (Hal-

bert and O’Brien, 1987), (2) guidelines to write good

classes (Eli

ens, 1995) and (3) the use of design pat-

terns (Gamma et al., 1995) and good software engi-

neering practices (Lethbridge and Lagani

ere, 2005).

These three points helped us to build software easy

to understand, maintain and extend. Together with

Singleton and Factory Method, the following design

patterns are used:

Camarón: An Open-source Visualization Tool for the Quality Inspection of Polygonal and Polyhedral Meshes

131

• Strategy: to easy add and interchange different al-

gorithms to solve a similar problem

• Visitor: to separate algorithms/strategies (class

Visitor) from the objects (class Element) to be ap-

plied. The methods of the classes that extends El-

ement use Double Dispatch in order to apply the

right Visitor method during execution time.

Double Dispatch is a technique that helps one to

choose what function to execute, when there exist sev-

eral with the same name, depending on the objects in-

volved in the call during the execution time.

3.2 Design

In order to build a visualization tool that can render

point clouds, polygonal and polyhedral meshes, we

have modeled the basic element by the class Element,

from which inherits the classes Point, Polygon and

Polyhedron. From Polygon inherits the class Trian-

gle and Quadrilateral, because this allows us to handle

efﬁciently triangular and quadrilateral meshes. From

Polyhedron inherits Tetrahedron and Hexahedron in

case of tetrahedral or hexahedral meshes are drawn.

To manage several input/output formats, render-

ing algorithms, selection modes and evaluation strate-

gies we used the Strategy pattern. For example,

we have designed the abstract class EvaluationStrat-

egy to apply any quality criterion to the individual

mesh element types. From EvaluationStrategy in-

herits MinimumAngle and MaximumDihedralAngle,

among others.

The selection strategies can be applied to the

whole mesh or to a subset of elements that was al-

ready selected. We created the class SelectionStrategy

from which inherits SelectById and SelectByProp-

erty, among others. SelectById allows a user to select

elements by using their indices and SelectByProperty

to select the elements that fulﬁl or not the speciﬁed

quality criterion. The Visitor pattern is implemented

between the selection strategies and the mesh ele-

ments so that by using the Double Dispatch technique

the right strategy is applied to a particular mesh ele-

ment.

The rendering strategies are also modeled in a

similar way. There exists a base class called Ren-

dererStrategy and several subclasses that implements

speciﬁc rendering algorithms. For example, Normal-

Renderer displays the model with normal vectors at

each face vertex and PropertyRenderer draws each el-

ement with different colors according to the values of

the applied quality criterion. For rendering the part

of a model that intersects 3D convex shapes, we de-

sign the class ConvexGeometryIntersectionRenderer

which inherits from RendererStrategy and Selection-

Strategy. The idea was to use the speciﬁed 3D convex

geometry for both to compute and render its intersec-

tion with the mesh and to select elements.

In order to extend the software without modifying

the user interface or already implemented classes we

have implemented dynamic registers. Each registry

class is modeled with the Singleton pattern so that

only one instance of each of them is created. Each

extensible module must have an associated registry

class. So, there exist the ModelLoadingFactory class,

the RendererRegistry class and the SelectionStrate-

gyRegistry class, among others. All these registries

inherit from a RegistryTemplate class, which stores

the different class instances associated to a key and a

priority queue that allows the programmer to organize

the order in which the different strategies will appear

in the user interface.

Finally, a Controller class, contains references to

all registry classes and is in charge of coordinating all

the operations according to the user requests.

3.3 Implementation

3.3.1 General Issues

Meshes are expected to be composed of convex poly-

gons and convex polyhedra. If non convex elements

are included, some rendering errors can appear. Since

in this application all geometrical properties remain

constant while the same model is displayed, we send

the computed values once to the GPU and keep them

in the VRAM until a new model is loaded. We man-

age attributes per triangle vertex in order to store dif-

ferent attributes when the same vertex belongs to sev-

eral triangles. So two triangles that share a vertex can

be rendered, for example, with a different ﬂat color.

The polygons of surface meshes or the polygonal

faces of polyhedra are triangulated ﬁrst before send-

ing their information to the VRAM, because GPUs

only manage triangles. Each renderer class has a con-

ﬁguration widget, which allows the user to choose

colors and other attributes for the selected and unse-

lected elements. Each renderer has an associated Ver-

tex shader, Fragment shader and Geometry shader if

it is required. Several shaders to render the models

were taken from the book (Wolf, 2011).

In order to develop software independent of the

platform, we decided to use the Glew library (the

OpenGL Extension Wrangler library) (Glew, 2012).

This library provides efﬁcient mechanisms to obtain

which OpenGL functionalities are available on target

GPU hardware. QtCreator was used to build the user

interface.

GRAPP 2016 - International Conference on Computer Graphics Theory and Applications

132

3.3.2 Geometric Model Renderers

The property renderer was designed for the visual-

ization of the elements that fulﬁll or not a particu-

lar quality criterion. The user chooses the property

(quality criterion) he or she wants to inspect (mini-

mum angle, aspect ratio, etc) and selects which col-

ors will be used. A new attribute array is created to

store the computed property values for the vertices

and/or triangles. The user deﬁnes three different col-

ors: null for the elements where the property does not

apply, C

max

for elements with the maximum value of

the property and C

min

for elements with the minimum

value of the property. For elements where the prop-

erty has a value between the minimum and maximum,

the color is obtained by doing linear interpolation.

When rendering an intersected model, the 3D con-

vex geometry intersecting a model can stay in a ﬁxed

position or can move with the model. In case the

3D convex geometry moves together with the model,

the intersection is computed only once and the shader

only takes care of rendering the elements by using

other viewing parameters. In case the 3D convex ge-

ometry stays at a ﬁxed position, the associated shader

computes in real time its intersection with the model.

In order to draw the wireframe of the model, the

algorithm described in (Bærentzen et al., 2006) is

used. This algorithm achieves in a single pass to dis-

play the wireframe view of the mesh by handling the

triangles through a geometry shader which calculates

internal triangle distances from each vertex to its cor-

responding opposite edge. The smallest distances are

then ﬁltered in a fragment shader and colored differ-

ent. As result it produces a wireframe view at a fast

rate for large meshes.

3.3.3 Data Visualization Renderers

The isoline renderer uses a geometry shader for

checking if an isoline value is within the bounds of

each assembled triangle primitive. If this is the case,

a new line segment is created by linearly interpolating

the values on the edges of the triangle. The perfor-

mance of the above implementation was poor in prac-

tice and a better solution for processing a large model

is presented in the isosurface renderer description.

The isosurface renderer was implemented using

a processing stage and a render stage. Both stages

are executed on the GPU with their own shaders

programs. The algorithm used to build the isosur-

faces is based on the geometry shader marching cubes

algorithm (Icare3D, 2015). In the ﬁrst stage, Ca-

mar

on subdivides every convex polyhedron into tetra-

hedra in a straightforward way. It then pass them

to a geometry shader as 4-vertex primitives of type

Figure 1: Visualization of an apple model using simultane-

ously three rendering strategies.

GL LINES ADJACENCY. The four vertices are

interpreted as a tetrahedron. Then, up to two triangles

are interpolated per tetrahedron and their vertex po-

sitions are sent to the output of the geometry shader.

Next we use the OpenGLs Transform Feedback func-

tionality to save selected output variables into a buffer

in VRAM. Once the isosurfaces are generated the sec-

ond step takes place to render the new geometries.

Note that the surface generation step is executed only

when the isosurface values are changed by the user or

a new model is loaded. In all other cases like rotation,

zooming or panning only the render stage is applied.

3.4 User Interface

Figure 1 shows the interface of our tool by using a

simple apple model of 1,704 triangles. At the right,

the user can interact with the application. For sur-

face meshes, minimum angle, maximum angle, as-

pect ratio, dihedral angle, and area, among others are

available. Speciﬁc criteria for volume meshes are

edge-radius ratio, aspect ratio, solid angle, and vol-

ume among others. The criteria for surface meshes

can also be applied to the faces of the polyhedra. His-

tograms are generated automatically for any criterion.

Elements can be visualized using different colors ac-

cording to their property value. In Figure 1, the yel-

low triangles are the one whose area is between 12

and 150. The histogram shows that there are more

smaller than larger triangles. The range of area val-

ues is shown below the histogram. To see interior

mesh elements, the mesh can be cut by several con-

vex shapes: sphere, several planes and several poly-

gons deﬁning polyhedron or selected with the mouse.

Several renderers are implemented: Glass ren-

derer, Phong renderer, Normal Vector, Flat renderer,

Property renderer and Intersection renderer, among

others. More than one renderer can be applied at

the same time. For the apple model three render-

Camarón: An Open-source Visualization Tool for the Quality Inspection of Polygonal and Polyhedral Meshes

133

Figure 2: Visualization of a tetrahedral model using the

Glass and the Intersection renderer.

ers have been applied: (1) the main renderer is al-

ways used when a selection strategy is chosen. In this

case, it draws the yellow triangles, (2) the Flat ren-

derer draws the white triangles and the black edges

and (3) The Normal Vector renderer shows the nor-

mal vectors. Mesh elements can also be selected and

visualized by specifying their vertex, edge, face and

polyhedron indices. This can be appreciated in Fig-

ure 2 that shows a torso model composed of 168,930

points and 1,082,723 tetrahedra. The torso was drawn

by using the Intersection renderer to cut part of its

shoulder and show some interior elements, the Glass

renderer and the renderer to show the indices of some

selected vertices.

In order to illustrate the isoline renderer, we chose

the Dragon mesh from the Standford Repository. The

triangular mesh has 437,645 vertices and 871,414 tri-

angles. The scalar ﬁelds for the models were gener-

ated with a simple pseudo-noise generation algorithm

to ensure the visualization of smooth curves. Figure 3

shows the mesh rendered using gray colors at the left

and the isolines corresponding to 20 scalar values at

the right. In a similar way, Figure 4 shows the applica-

tion of the isosurface renderer to the Permanent Mag-

netic DC motor (pmdc) mesh taken form the Tetview

webpage. The pmdc mesh has 109,189 tetrahedron,

237,291 triangle faces and 27,196 vertices. The iso-

surfaces corresponding to 10 scalar values are shown.

We have also deﬁned and added a new format

called Visf for handling any polyhedral mesh. This

Table 1: Hardware used for testing.

Hardware Detail

CPU Intel Core i5-3210M 2.5 Ghz

GPU Nvidia Geforce GT 650M

Mem 8GB, DDR3, 800 MHz

OS Windows 7

format is similar to the OFF format: after the faces,

the number of polyhedra must be speciﬁed and then

each polyhedron with its number of faces followed by

the face indices. Camar

on can be downloaded from

http://sourceforge.net/p/camaron/code/ci/master/tree

4 EXAMPLES AND EVALUATION

The performance comparison is done by measuring

the number of frames per second each visualization

tool can generate. This value is obtained through

the application Fraps (Fraps, 2012) for MeshLab, Ge-

omView and TetView. The characteristics of the hard-

ware used for testing are shown in Table 1.

4.1 Rendering of Surface Meshes

The surface meshes used for comparison were taken

from free repositories available through the Internet.

The models, number of vertices, number of poly-

gons and formats are shown in Table 2. We chose

these meshes because their vertex number is close to

, i = 12, ..., 22. Table 3 shows the frames per second

measured for each visualization tool. The highest fps

value Fraps gave us while measuring the frame rate of

GeomView, MeshLab and TetView was 60fps. Then

we also consider 60fps as the performance rate when

Camar

on generates frames at a higher rate. We can

observe that Camar

on gets the best performance rates

because it does an intensively used of the GPU and

the others not.

Table 4 shows the amount of RAM used for the

three largest models. Camar

on needs more RAM

space than the other tools because it stores the ge-

ometric properties associated to each quality criteria

and several neighbor relationships between mesh el-

ements in order to compute the properties fast. We

also observe as expected that the amount of memory

increases linearly with the amount of vertices.

4.2 Visualization of Volume Meshes

We generated tetrahedral meshes of size 2

, i =

14, ..., 19 to compare the performance of Camar

and TetView. Figure 5 shows the number of vertices,

GRAPP 2016 - International Conference on Computer Graphics Theory and Applications

134

Figure 3: Isoline Renderer.

Figure 4: Isosurface Renderer.

Table 2: Geometrical information of the surface meshes.

Object Torus Cow Bunny Lucy Ramses Neptuno Thai

Points 4,800 16,612 35,947 262,999 826,266 2,003,932 4,999,996

Polygons 9,600 33,244 69,451 525,814 1,652,528 4,007,872 9,999,754

Format TRI OFF PLY TRI OFF OFF PLY binary

Table 3: Number of frames per second (fps).

TView GView MLab Camar

Torus 60 40 60 60

Cow 60 13 60 60

Bunny 57 6 47 60

Lucy 10 1 7 60

Ramses 5 <1 2 60

Neptuno - <1 1 21

Thai - <1 <1 6.5

triangles and tetrahedra of each sphere. The compari-

son is only between Camar

on and TetView because

Table 4: Use of RAM(MB).

TView GView MLab Camar

Ramses 437 137 281 913

Neptuno - 326 465 2,086

Thai - 806 970 4,645

MeshLab and GeomView were designed to handle

surface meshes.

Figure 5 shows two views of a tetrahedral mesh:

at the left side, the sphere was cut by a plane and the

intersection is shown, and at the right its surface is

displayed. Table 6 shows at the left the frames per

Camarón: An Open-source Visualization Tool for the Quality Inspection of Polygonal and Polyhedral Meshes

135

Table 5: Volume meshes.

Object Sphere 1 Sphere 2 Sphere 3 Sphere 4 Sphere 5 Sphere 6

Points 16,384 32,768 65,536 131,072 262,144 524,288

Polygons 219,642 439,898 882,974 1,768,357 3,540,332 7,085,413

Tetrahedra 109,776 219,890 441,409 884,080 1,770,053 3,542,559

Figure 5: TetView visualization of the Sphere 3 cut by a

plane (left) and its surface (right).

second each visualization tool took to visualize the

cut sphere and at the right the whole sphere. We ob-

serve that TetView shows a good performance while

drawing the whole sphere because in this case does

not process all tetrahedra; it only draws the triangles

at the surface and these are few. Our tool instead al-

ways processes all tetrahedra in parallel and in this

case only draws the ones located at the surface. After

cutting the model, the number of interior triangles to

be rendered increases with the size of the tetrahedral

mesh. That is why our tool shows a better perfor-

mance than TetView. Note that TetView is quite slow

if surface meshes have more than 200,000 points as

shown in Table 3. Then it would be a larger perfor-

mance difference between both visualization tools if

larger surface meshes are drawn.

Table 6: Number of frames per second.

TView Camar

Sphere 1 60:60 60:60

Sphere 2 58:60 60:60

Sphere 3 47:60 60:60

Sphere 4 33.60 60:60

Sphere 5 24:60 22:60

Sphere 6 14:60 9:21

Table 7: RAM usage (MB).

TView Camar

Sphere 4 110 1,346

Sphere 5 170 2,478

Sphere 6 296 4,010

Table 7 shows the amount of RAM used for the

three largest models. With volume meshes, our tool

also requires more RAM than TetView because of the

same reasons given for surface meshes.

5 CONCLUSIONS AND FUTURE

WORK

We have presented the main characteristics of a new

visualization tool designed for the quality inspection

of surface and volume meshes composed of any con-

vex polygons and polyhedra, respectively. This tool

can also render non-manifold meshes and this is use-

ful when partial meshes are built from images. The

software design guarantees that the tool can easy

evolve in new quality criteria, selection and render

strategies, and new input/output formats.

The performance evaluation is still not complete.

Since we have recently added the visualization of

datasets, we also want to do a comparison with some

of the mentioned data visualization tools (ParaView,

VisIt). Until now, we have only compared its perfor-

mance with MeshLab, TetView and GeomView and

shown that our tool can render in real time large sur-

face and volume meshes on standard desktop comput-

ers.

In the near future we plan to visualize data com-

ing from simulations not necessarily associated to the

mesh vertices. The idea is that a user can interactively

detect and analyze how much not so good quality el-

ements affect the simulation results. We also want to

optimize the memory usage as far as possible.

ACKNOWLEDGEMENTS

This work was partially supported by Fonde-

cyt Project N

1120495 and Enlace-Fondecyt

ENL009/15 (VID, University of Chile).

REFERENCES

Amenta, N., Levy, S., Munzner, T., and Phillips, M. (1995).

Geomview: A system for geometric visualization. In

Proceedings of the Eleventh Annual Symposium on

Computational Geometry, SCG ’95, pages 412–413,

http://www.geomview.org. ACM.

Bærentzen, A., Nielsen, S. L., Gjøl, M., Larsen, B. D.,

and Christensen, N. J. (2006). Single-pass wireframe

rendering. In ACM SIGGRAPH 2006 Sketches, SIG-

GRAPH ’06, New York, NY, USA. ACM.

GRAPP 2016 - International Conference on Computer Graphics Theory and Applications

136

Bastarrica, M. C. and Hitschfeld-Kahler, N. (2006). De-

signing a product family of meshing tools. Advances

in Engineering Software, 37(1):1–10.

Childs, H., Brugger, E., Whitlock, B., Meredith, J., Ah-

ern, S., Bonnell, K., Miller, M., Weber, G. H.,

Harrison, C., Pugmire, D., Fogal, T., Garth, C.,

Sanderson, A., Bethel, E. W., Durant, M., Camp,

D., Favre, J. M., R

ubel, O., Navr

atil, P., Wheeler,

M., Selby, P., and Vivodtzev, F. (2011). VisIt:

An End-User Tool For Visualizing and Analyzing

Very Large Data. In Proceedings of SciDAC 2011.

http://press.mcs.anl.gov/scidac2011.

Cignoni, P., Callieri, M., Corsini, M., Dellepiane, M.,

Ganovelli, F., and Ranzuglia, G. (2008). MeshLab:

an Open-Source Mesh Processing Tool. In Scarano,

V., Chiara, R. D., and Erra, U., editors, Eurographics

Italian Chapter Conference. The Eurographics Asso-

ciation.

Contreras, D. and Hitschfeld-Kahler, N. (2014). Genera-

tion of polyhedral delaunay meshes. Procedia Engi-

neering, 82:291 – 300. 23rd International Meshing

Roundtable (IMR23).

Eli

ens, A. (1995). Principles of object-oriented software

development. Addison-Wesley.

Fraps (2012). Realtime Video Capture Software. Beepa, Pty

Lt. http://www.fraps.com.

Gamma, E., Helm, R., Johnson, R., and Vlissides, J. (1995).

Design Patterns: Element of Reusable Object Ori-

ented Software. Addison-Wesley.

Garimella, R. V., Kim, J., and Berndt, M. (2013). Poly-

hedral mesh generation and optimization for non-

manifold domains. In IMR, pages 313–330.

Glew (2012). The OpenGL Extension Wrangler Li-

brary. BSD License, MIT License. http://www.glew.

sourceforge.net.

Halbert, D. and O’Brien, P. (1987). Using types and in-

heritance in object-oriented programming. IEEE Soft-

ware, 4(5):71–79.

Hanwell, M. D., Martin, K. M., Chaudhary, A., and Avila,

L. S. (2015). The visualization toolkit (vtk): Rewrit-

ing the rendering code for modern graphics cards.

SoftwareX, 12:9 – 12.

Henderson, A. and Ahrens, J. (2004). The Paraview guide

: a parallel visualization application. Kitware, Inc.,

New York.

Lethbridge, T. C. and Lagani

ere, R. (2005). Object-oriented

software engineering : practical software develop-

ment using UML and Java. Mc Graw Hill Education.

Ramachandran, P. and Varoquaux, G. (2011). Mayavi: 3D

Visualization of Scientiﬁc Data. Computing in Science

& Engineering, 13(2):40–51.

Rossel, P. O., Bastarrica, M. C., Hitschfeld-Kahler, N.,

ıaz, V., and Medina, M. (2014). Domain modeling

as a basis for building a meshing tool software product

line. Advances in Engineering Software, 70:77–89.

Si, H. (2013). TetGen and TetView software. http://tetgen.

berlios.de.

Si, H. (2015). Tetgen, a delaunay-based quality tetra-

hedral mesh generator. ACM Trans. Math. Softw.,

41(2):11:1–11:36.

VisIt (2015). Open Source, interactive, scalable, visu-

alization, animation and analysis tool. Lawrence

Livermore National Laboratory. https://wci.llnl.gov/

simulation/computer-codes/visit.

Vtk (2015). The visualization toolkit. http://www.vtk.org/.

Wolf, D. (2011). Open Gl 4.0. Shading Language Cook-

book. Birminghang. UK. Pack Publishing ltd.

Camarón: An Open-source Visualization Tool for the Quality Inspection of Polygonal and Polyhedral Meshes

137