Ceetron Desktop Components Functional Overview

This is a high-level functional overview.

Core Component

The Core Component includes basic services for other components, such as classes for handling strings, math, variants, smart pointers, etc. It also includes a system for logging and a system for license control. This component does not depend on OpenGL support.

Features

  • String class with Unicode support. Converts to/from STL string classes std::string and std::wstring
  • Variant and property system
  • Basic math classes for 2D and 3D vectors, 4×4 matrices, symmetric tensors and planes
  • Logging system used by all Ceetron Desktop Components that can be controlled and used in your own application
  • License control. Handles licensing of Ceetron Desktop Components (both evaluation and permanent licenses)

Visualization Component

This component can handle analysis models with 10s of millions of finite elements and more than 1 million geometry parts.

The Ceetron Visualization Component is the main component for visualization applications. It supports simultaneous visualization of multiple data models, multiple viewports, camera positioning and various user interaction mechanisms.

Picture to the right: Ceetron Desktop Components has a rich set of high level features to display quantitative information such as distance between two points, angle between two lines, etc. Information can be display in the geometry using a rich set of annotations.

Shaders are fully implemented to take advantage of the latest developments in graphics hardware and middleware.

The View in the Visualization Component can show models from any of the other components, and can thus combine analytical geometries and FEA analysis meshes creating a more impressive user experience.

Features

  • View
    • Add/remove models
    • Set background color
    • Render view contents to image​
  • Camera
    • Perspective projection (field of view and clipping planes)
    • Parallel projection
    • Explicit setting of viewpoint (‘look at’) and fit view (frame model)
    • Support for rubber-band zoom
    • Extract ray from screen coordinates (used for picking)
  • Overlay items (2D)
    • Axis cross and navigation cube
    • Text box and Images
    • Color legend
  • Markup model
    • Supports display of labels, lines, points, glyphs, triangles etc
    • Used for mark-up items in a scene such as annotations, distance measurements etc.
    • Also used for highlighting elements and other simple drawing

Geometry Component

The Geometry Component offers a data model for geometries containing a large number of parts (grouping of elements, typically with different attributes). The Geometry Component is specifically designed for efficient handling of complex geometries.

  • High Performance model for efficient handling of many parts
  • Handles 1M+ parts
  • Efficient effect system for controlling visual attributes
  • Front and back colors and opacity
  • Easy to override effects
  • Full texture support
  • Simple result visualization via textures​​
    ​

Pictures to the right: The Geometry Component is tailored to handle simulation models with a large number of parts efficiently. Models such as the snow scooter (top right) and the oil rig (bottom right) contains several hundred thousands of parts are handled with little or no overhead compared to a single part model.

UnstructGrid Component

The UnstructGrid Component provides a high-level interface to flexible data structures which allow the user to populate the data model with native finite element model and results data structures and apply an extensive set of feature extraction algorithms to the data. Scalar, vector and tensor results are provided through a high-level programming interface as well as feature extraction algorithms such as cutting planes, isosurfaces, isovolumes, particle traces and other advanced result presentations.

Picture to the right. High level functions for advanced result visualizations are available in the Unstruct Component.A scalar plot (top right) is available using a single function call. Any result visualization can be displayed using e.g. transparency for improved result interpretation for complex geometries.

Features

  • Unstructured FEA meshes:
    • Static geometries
    • Adaptive geometries
    • Transient results
    • Scalar results
    • Vector results
    • Displacement results
    • Rigid body transformation results
    • File and memory-based data sources
  • Feature extraction:​​
    • Cutting planes
    • Isosurfaces and isovolumes
    • Particle traces
    • 3D-Components-DataModelElements_pic
  • Animation
    • All transient results
    • Mode shape animations

Data model

  • Elements with optional IDs and user properties
  • Supported element types (see figures to the right):
    • point (1 node)
    • beam (2 & 3 nodes)
    • triangle (3 & 6 nodes)
    • quad (4, 8 & 9 nodes)
    • tetrahedron (4 & 10 nodes)
    • pyramid (5 & 13 nodes)
    • pentahedron (6 & 15 nodes)
    • hexahedron (8 & 20 nodes)
  • Part binds elements and nodes
  • Geometries consist of a collection of parts
  • Supports multiple geometries per state
    • Allows combination of static and adaptive geometries
  • Polyhedrons (any shape)

Results data model

  • Scalar results (see figure to the right)
    • Mapping: per node, per element, per element node and per element face
  • Vector results (see figure lower right)
    • Mapping: per node, per element, per element node and per element face
  • Symmetric tensor results
  • Displacements
    • Mapping: per node
  • Transformation results
    • Mapping: per part
  • Visibility result
    • Mapping: per element
  • Data model may contain multiple scalar and vector results
  • Supports partial results (results available only for a subset of parts)

Model display (per part setting)

  • Part visible on/off
  • Draw styles
    • Surface, surface with mesh, surface with outline mesh (see pictures to the right)
    • Lines, outline
    • Hidden line
    • Points
  • Toggle result display on/off for
    • Scalars
    • Vectors
    • Displacements
    • Highlight
    • Transparency
    • Smooth shading on/off
    • Part colors with separate front and back colors

Result display

  • Result visualization
    • Scalars: Filled contours (fringes)
    • Vectors: Any number of vector results as vector arrows
  • Scalar settings
    • Set explicit range and auto full range
    • Color scheme (normal, thermal, etc.)
    • Logarithmic scaling
    • Number of color levels, including continuous (smooth)
    • Appearance of legend lines and text (width/color)
    • Show legend on/off
    • Filtering (min/max)
    • Show legend on/off
  • Vector Settings
    • Scaling (absolute or relative to model)
    • Color mode (single color or colored by fringes)
  • Displacement Settings
    • Absolute scaling

Data extraction

  • Cutting planes
    • Compute based on point & normal
    • Show scalar result on plane
    • Show vector result in regular grid
    • Control spacing of regular grid
    • Show plane surface on/off
    • Show the “cut elements mesh”
    • Highlight
  • Isosurfaces
    • Computed based on iso value
    • Show any scalar mapped on the surface
    • Show vectors on isosurface
    • Show isosurface on/off
    • Highlight
  • Isovolumes
    • Computed based on min/max iso value
    • Show any scalar mapped on the surface
    • Show vectors on isosurface
    • Show isovolume on/off
    • Highlight
    • Texture mapping

UI toolkit integration

Ceetron Desktop Components is platform neutral and UI toolkit neutral and can be integrated with any UI toolkit. The only requirement is that the target platform supports OpenGL.

The C++ version is delivered on Windows (32 bit and 64 bit), Linux (64 bit), and Mac OS X. It comes with ready to use platform integration sources and examples/tutorials for Qt (both Qt4 and Qt5), wxWidgets (3.x), MFC and Win32. It can also be integrated with any UI toolkit following the same scheme as demonstrated for example for Qt in the platform integration sources.

The .NET version (32 and 64 bit) of Ceetron Desktop Components has the same performance and capabilities as the C++ version, but has also some extra features (e.g., properties) to help C# developers.​​