3.5.0-rc1
Loading...
Searching...
No Matches
Changelog

Changes since last release

  • General changes
    • none
  • New API functions
    • none
  • TiGLCreator
    • none
  • Build System
    • none
  • Fixes
    • none

Version 3.5.0

2026/09/01

This release adds the system definition introduced in CPACS 3.5 and direct NACA4 profile support in CPACS, geometry/mass-property evaluation for fuselage decks, and leading edge devices (LED), on top of a large set of TiGLCreator usability fixes and a build-system migration to conda-forge (adding Apple Silicon support). TiGL 3.5.0 is conform with CPACS 3.5.1.

  • General changes
    • Update the internal CPACS schema to version 3.5.1 (#1028).
    • Add the new system definition introduced in CPACS v3.5.
    • Add leading edge devices (LED) to TiGL and TiGLCreator (#1101).
    • Add an alternative wing airfoil parametrization that allows specifying NACA4 codes (with trailing edge thickness) directly in CPACS, replacing the previous workaround of writing sampled NACA profiles as point lists and improving surface quality (#1293).
    • Add geometry and mass-property evaluation for fuselage decks (#1298, CPACS#859).
    • Ducts are now also cut out of fuel tank vessels; a duct assembly may exclude a tank by vessel or fuel tank uID (#1416).
    • TiGL can now approximate profile point lists while still interpolating a user-defined subset of points (#1276).
    • CPACS export now uses a more meaningful marker for mirrored objects' uIDs (#1289).
    • Improved flap rendering performance by cutting shapes sequentially instead of fusing them all before cutting (#1265).
  • New API functions
  • TiGLCreator
    • Add a "Display Options" tab to change draw options (e.g. flaps) per component; the configuration stays visible while switching draw options (#1270, #1279).
    • Bi-directional selection of shapes between the 3D viewer and the CPACS tree (#1275).
    • Add a grid resolution setting; grid origin labels now update dynamically with the selected grid plane (XY/XZ/YZ), which is persisted across sessions (#1269).
    • Draw option menus now update when adding new wings or fuselages.
    • Use NACA and standard profiles in the TiGLCreator templates (#1367).
    • Add user-defined spotlights (#1245).
    • Add an option to display the control point net of a component's faces, for debugging (#1260).
    • Disable the "Standardize" menu option until the underlying algorithm is reliable (#1336).
    • Scripting console: add a Color class and setObjectsColor/setObjectsColorRGB to set object colors without a native QColor object (#1222), and app.scene.selectShape to select a shape by its CPACS uID (#1316).
    • app.openFile now accepts a configuration uid (#1309).
    • Make all shapes non-transparent by default again (#1258).
    • Add undo/redo buttons to the toolbar (#1123).
    • Add a scrollbar to the CPACS editor widget so editing works on smaller screens (#1228).
  • Build System
    • Migrated build dependencies from the dlr-sc conda channel to conda-forge, bumping OpenCASCADE 7.6.2 → 7.9.3 and adding osx-arm64 (Apple Silicon) as a supported platform (#1286, #1273, #964).
    • Introduce pixi as a helper to install dependencies and run common development commands.
    • Added python tests to CI
    • Vendored pythonocc-core's SWIG interface sources and the MATLAB SDK headers (no conda-forge equivalents yet) as git submodules, skipped automatically where unavailable (e.g. the MATLAB SDK on Apple Silicon).
    • Include the external CPACS schema tool in the repo and CI to validate an edited CPACS XSD directly (#1420).
  • Fixes
    • Fix TiGLCreator crashing when changing a wing's symmetry plane after undoing a previous symmetry-plane change, and stop CTiglWingHelper::SetTipUid from logging spurious "Unexpected case!" warnings (#1432).
    • Fix mirrored geometry not appearing after enabling a component's symmetry until the file was closed and reopened (#1432).
    • Fix GetSweep/GetDihedral flipping to their complement on wings with exactly 45° dihedral/sweep, due to a platform-dependent rounding tie-break in the major-axis heuristic.
    • Fix several broken fuselage structure Python bindings, including CCPACSFuselageStructure.get_skin() and get_geometry() on skin segments and cargo doors (#1037).
    • Add missing ::generated::CPACSFuselages Python bindings, which had hidden fuselage getters/setters on ::CCPACSFuselage (#1207).
    • Fix too small minimum control point count in the B-spline profile approximation check (#1422).
    • Aircraft fusing no longer fails when a system or deck component (e.g. a lavatory) has no geometry defined; such components now simply contribute no shape. Also fixed a related TiGLCreator crash when triangulating the fused aircraft, and that draw option now consistently shows the symmetries/far-field dialog (#1388).
    • Fix fused CAD export (IGES/STEP/BRep) not resolving intersections between sibling components outside a parent-child relationship (e.g. two tailplanes both attached to the fuselage but also intersecting each other) (#939).
    • Fix BuildWireRectangle throwing on the "circle" limit of a standard rectangle profile.
    • CCPACSPositionings::CreatePositioning now sets a CPACS-conform name (#1378).
    • Fix crash in CTiglWingSectionElement::GetWire when the parent component is a pylon rather than a wing (#1371).
    • Fix error when displaying an aircraft with an engine but no nacelle, or a pylon without segments; these now return null geometry instead of throwing (#779).
    • Fix many CMake and compiler warnings (#1307).
    • CCPACSAircraftModel::GetConfiguration/CCPACSRotorcraftModel::GetConfiguration now throw a CTiglError instead of returning a null reference (#1426).
    • TiGLCreator: Fix incoherent selection between the 3D viewer and the CPACS tree for components without a dedicated editor (e.g. engines and pylons), and a related crash when opening "Display Options" after such a failed selection (#1419).
    • TiGLCreator: Fix selection being off by one click (#1395).
    • TiGLCreator: Fix crash when computing/displaying geometry that throws an OpenCASCADE exception instead of a tigl::CTiglError; an error dialog is shown instead (#1382).
    • TiGLCreator: Fix crash when selecting objects with malformed CPACS geometry; invalid objects are now marked with a warning icon instead (#1375).
    • TiGLCreator: Fix laggy fuselage selection in the CPACS tree; only the wireframe is highlighted now instead of each section individually, also improving performance (#1275).
    • TiGLCreator: Fix wrong behaviour of the wing sweep/dihedral chord-percentage spinbox (#1327).
    • TiGLCreator: Fix hard crash for invalid XML files (#1322).
    • TiGLCreator: Update the modificator widget's references after undo/redo (#1240).
    • TiGLCreator: Fix wrong scaling of the application when the Windows display scale is set to 150% (#1238).
    • TiGLCreator: Fix incorrect invalidation logic of elements, sections and fuselages/wings that could produce invalid geometries for some positioning/transformation combinations (#1209).
    • TiGLCreator: Fix non-unique default names for new fuselages/wings and non-unique section names (#1206, #1213).
    • TiGLCreator: Remove a misleading warning about an airfoil that cannot be added when it already exists (#1234).
    • TiGLCreator: Correct the "New File"/"Open File" icons and add a toolbar button (#1210).
    • TiGLCreator: Fix a Qt bug where hovering over the color chooser dialog selected a color (#1217).
    • TiGLCreator: Auto-append the file extension when saving a screenshot if missing, with a clearer error message (#1296).
    • TiGLCreator: Fix an unhandled exception triggered by the UpperLower wire in CTiglWingProfileNACA (#1366).

Version 3.5.0-rc1

2025/09/22

We are very excited to announce our first official TiGL release containing the implementation of the CPACS Creator. CPACS Creator was a branch of TiGL that allowed modification of CPACS nodes via the C++ and internal Python API as well as via the graphical user interface based on TiGL Viewer. The first pre-release of CPACS Creator was in September 2019. Within the past year we have shifted our focus towards re-integrating CPACS Creator into TiGL. After a few weeks of extensive coding and bug fixing - especially for the GUI, we have finally made the merge.

To highlight this merge and to be faithful to Malo Drougard's original implementation, we have decided to rename TiGLViewer to TiGLCreator. Enjoy!

  • General changes
    • Rename the CPACSCreator/TiGLViewer to TiGLCreator #1137.
    • The CPACS tree stays expanded, even after addition or deletion of wings, fuselages, sections or profiles (#1138)
    • Sections can now be added or deleted using a context menu in the CPACS Tree View (#628)
    • Add the option to set a custom name when a new section is added into fuselages or wings. This user dialog is included within the new-section-dialog (#1141).
    • When adding new sections to wings or fuselages, the sections are reordered from root to tip (resp. nose to rear) according to the segments (#1139)
    • Add the option to set an eta value when a new section is added into fuselages or wings. This user dialog is included within the new-section-dialog (#1133).
  • Fixes
    • Support multiple models in a cpacs file (#1196)
    • Fix hard crash in Redo command, improve error message (#1144).
    • State of QDockWidgets is saved and loaded correctly now when closing and reopening GUI (#1142).
    • Fix hard crash when changing the symmetry axis of a wing in TiGL Creator (#1143)
    • Fix hard crash for configuration without fuselage profiles (#1178)
    • Fix wrong rotation when adding sections (#1168)
    • When adding a new section into an existing wing, the scaling/translation did not seem meaningful. That is due to the fact, that the new element's area was interpolated between the start end end element. However, it does not depend linearly on the element width. Choosing the element width as a target value for the new element should fix this issue (#1108).
    • Redo and Undo commands now update the CPACS configuration, which was previously only true for modifications using the CPACS Editor UI (#1122).
    • Ask the user whether the currently worked on file should be saved before closing. Up to now, the configuration was simply closed resulting in potential data loss (#1090).
    • When a user adds a non-boundary segment to a wing/fuselage, the respective segment is split and a new one is created. After this split, a reordering of the segments is necessary. Otherwise, the segments cannot be lofted and created correctly. That would result in a wrong visualization and errors when trying to build them on user's demand in the tiglviewer. For that reason, the CCPACSFuselageSegments::ReorderSegments() and CPACSWingSegments::ReorderSegments(), respectively, were added within the call of the SplitSegment() function. (#1096)
    • When creating a new file out of a template, the CPACSCreator automatically creates a new .temp file in the template directory. It might be the case that the user does not have write access to this directory, e.g. when TiGL is not configured and built but just downloaded via the installer. On the other hand it does not seem to be reasonable to directly create and store (!) a new file every time the 'new file' command is activated. Now, no temporary file is created. The content of the wanted template is copied into a string which then will be opened and read by tixi. Only if wanted, the resulting and edited CPACS file is stored. (#752)
    • CPACSCreator uses a system-wide config file to store (among many others) the path to the profiles database. If TiGL is built in a second configuration on the same system, the first build will determine the path in this config file. If then later the first build (and path) is removed, TiGL will still try to load the database from this path. A check is included, whether the path exists and should overwrite the config file entry when it does not. (#1087)

Version 3.4.1

2025/09/08

  • New API functions:
  • General changes:
    • Implemented the new CPACS fuelTanks.
    • Use OpenCascade Technology (OCCT) version 7.6.2.
    • Use TiXI version 3.3.1
    • Add support for linking against OpenCascade Technology 7.8.
    • Update the C++ standard to C++17.
    • Added the possibility to switch between two algorithms in the CCSTCurveBuilder. The default algorithm based on a Chebychev approximation results in a small number of control points, but introduces small discontinuities in the curvature. The new option is to use OCCT's GeomAPI_PointsToBSpline, which results in a C3 continuous B-Spline.
    • Deprecation warning: The use of the node cpacsVersion right within the CPACS path /cpacs/header/ is deprecated according to CPACS 3.5. Hence, now a deprecation warning is printed if it is still used (#1126).
  • Fixes:
    • Fix inconsistent parametrization of super ellipse profiles. Before, the super ellipses ware parametrized by arc length, which resulted in different parameters at the four distinct points of the super ellipse. Potential kinks in two super ellipses were not necessarily connected by a v-isoline in the resulting loft. (#1094)
    • CCPACSPositioning was not available via Python bindings since the std::vector<std::unique_ptr<TYPE>> is not exposed to swig. New getter functions have been implemented in CCPACSPositioning.h to make these elements accesible via index, similar to the implementation of for several other classes (#936). For more information see cpacs_tigl_gen issue #59.
    • The tolerance for creating cells via contourCoordinate was reduced for cells in spanwise direction. That fixed a bug that caused cells to overlap potentially. The same reduction was missed in chordwise direction and is added now to avoid the cell overlap in chordwise direction, as well. (#1034)

Version 3.4.0

12/11/2024

  • General changes:
    • Support CPACS 3.4 (#1027)
    • Implemented standard fuselage profiles, i.e. rounded rectangle profiles (#1005) and superellipses (#1021).
    • CPACS allows prescribing kinks at (fuselage) profiles at given parameters. At the same time, guide curves must be prescribed at a relative circumference of the profile, which does not necessarily coincide with the parametrization of the profiles. In consequence, it was nearly impossible for a user to prescribe a guide curve exactly at a profile kink. This was fixed by allowing guide curves to be placed at a curve parameter that coincides with the prescribed parameter in the profile definition. Now guide curves can optionally be prescribed using fromParameter and toParameter instead of fromRelativeCircumference and toRelativeCircumference. (#1015)
  • Fixes:
    • In Debug Mode, the Lofting algorithm now throws an exception, if the generation of the Side Caps fail. The intention behind having the check only in Debug-Mode is that the geometric validity check is very generic and may be too restrictive. In addition, it may be expensive. (#999)
    • Fixed an issue, where approximate reparametrization of a B-Spline Curve resulted in non-negligable geometric changes of the B-Spline, especially if parameters are prescribed for a profile in CPACS. This new reparametrization is incompatible with a previous reparametrization applied to fuselage profiles, that distributed the knots for an overall cleaner geometry. Now the knot distribution is turned off, if parameters are prescribed in CPACS. (#1007)
    • CPACS 3.5 introduces a new way of prescribing the version of the CPACS data set, which means that newer CPACS files could not be interpreted by TiGL anymore. Now, TiGL can open CPACS 3.5 files and raises a warning that the CPACS version is newer than the one supported by TiGL (#1010).
    • Fix hard crash in Wing Geometry generation with cutouts, if there are no cutouts defined in CPACS. (#1023)

Version 3.3.1

14/03/2024

  • General changes:
    • Improve documentation and update installation instructions.
    • TiGL now supports Opencascade Technology 7.6.2 (#973).
    • Extension of the functionality of ::tiglwinginterpolatexsi to work on a single segment that is not part of a component segment (#970). The function is now generalized, so that the start and end uid can be either a segment or component segment and the two do not have to be related to each other.
    • TiGL now supplies an environment.yml file that can be used with conda to install all build requirements of tigl into an Anaconda environment.
    • Renamed the function ::CCPACSConfiguration::GetAirplaneLenth to ::CCPACSConfiguration::GetAirplaneLength (#992).
  • Fixes:
    • Fix bug in guide curve transformation. The rX-Direction was wrongly interpreted with respect to global coordinates, not wing coordinates (#975).
    • Fix for hard crash if guiceCurves node is present but empty in wing segment (#962).
    • Fix bug related to the calculation of Euler angles from a given rotation matrix (#870).
  • TiGLViewer:
    • Improved visual quality of zebra stripes (#974).

Version 3.3.0

02/05/2023

  • General changes:
    • Support CPACS 3.3 (#883). The following CPACS 3.3 functionality is not yet supported: stringerFramePosition definition at fuselage section (#915), landing gears (#908), parametric fuselage profiles (#909).
    • Implemented the upcoming CPACS 3.5 feature for modeling ducts. It allows the user to create duct cutouts in wings and fuselages. TiGL was extended to support ducts and duct assemblies for aircraft configurations. It is to mention, that currently wings and fuselages are the only components that enable duct cutouts (#881).
    • Generate doxygen documentation for all classes, not just the API functions (#943).
  • New API functions:
  • Fixes:
    • Adapt get_tigl_tixi.sh to properly download the tixi3 package for debian (#884).
    • Export fuselages and wings as a whole and not segmentwise in the CAD export of the unfused configuration (#897).
    • Fix typos (#923, #924, #925).
    • Fix bug concerning the conversion of the internal parametrization of the faces of a wing to contour coordinates (#930).
    • Update CI (#918, #839).
    • Fix a compilation error with gcc 12.2 (#948).
    • Fix bug in tiglWingGetSegmentUpperSurfaceAreaTrimmed (#961).
  • TiGLViewer:
    • Implement high dpi screen support (#953).

Version 3.2.3

09/03/2022

  • Fixes:
    • Disabled check, if wing cells can be trimmed rather than cut, even if they are not defined by contour coordinates. This check was put in place for better performance and robustness, because with trimmed curves expensive and error-prone boolean operations can be avoided. However, the current implementation of the check relies on some hard to tune tolerances and led to false positives and thus faulty wing cell geometries (issues #865, #869).
    • Fixed a bug, where the trailing edge of a wing cell could not be defined by referencing a spar (issue #864).
    • The class ::CCPACSEnginePosition has been added to the swig interface (issue #858). Without this it was previously impossible to access the transformed engine nacelle geometrie from Python.

Version 3.2.2

17/11/2021

  • Highlights / General changes:
    • Added support for canard style flaps. This allows to position the hinge points outside of the wing by providing an additional translation vector (issue #816).
  • Fixes:
    • Fixed CPACS versions header not correctly parsed, if the version number contained a patch version (issue #830).
    • Fixed multiple errors that occured during the computation of wing cells (issues #815, #829, #840).
    • Fixed computation of the wing aspect ratio (issue #827).
    • Fixed crashes in TiGL Viewer when displaying control surface devices (issue #851).
    • Improved robustness of export functions. The export now tries to export as much as possible, even if one component failed to built (issue #853).
  • Bindings:
    • Added python 3.9 conda packages
    • Fixed loading python bindings with python 3.8 due to a changed DLL loading policy (issue #842).
    • Fixed a crash in the python bindings due to wrong memory handling (issue #823).

Version 3.2.1

01/07/2021

  • Fixes:
    • Fixed function tiglWingGetSegmentEtaXsi ignoring the GetPointBehaviour that was introduced in TIGL 3.1.0: Since TiGL 3.0.0, the getPoint functions now use the parametrization of the wing surface geometries instead . This behaviour can be switched back to the old bevahiour using tiglWingSetGetPointBehavior. Before fixing now tiglWingGetSegmentEtaXsi, the functions always used the old behaviour such that the back and fort computation etaXsi -> point -> etaXsi did not result in the same values.

Version 3.2.0

28/05/2021

  • Highlights / General changes:
    • Full support of CPACS 3.2
    • TiGL 3.2 is shipped with OpenCASCADE 7.4.0 and is now compatible with pythonOCC 7.4.0. This includes all TiGL releases and Conda packages.
    • Improved computation speed of wing cell geometries.
    • Implemented cell definition with contour coordinates. This feature will be part of CPACS 3.4.
    • A new curve / curve intersection algorithm. This is used e.g. for the computation of curve network interpolation and was necessary due to a regression in OpenCASCADE 7.4.0. The new algorithm is designed to find all intersections between two curves within a user defined tolerance.
  • New API functions:
  • Fixes:
    • Fixed fuselage walls transformation that did not respect the fuselage transformation before.
    • Fixed fuselage profiles, that had different positions than y=0 at start or end point.
    • Fixed crash, if first guide curve point is (0,0,0) or last point is (0,1,0).
    • Fixed wrong position of trailing edge device borders, if referenceUID is referring to a segment.
    • Fixed a bug in tiglWingGetUpperPoint and tiglWingGetLowerPoint, if the leading edge has zero size.
  • Python Bindings:
    • The tigl3 Conda packages depend not on pythonOCC-core 7.4.0. If you plan to migrate your code, please notice that pythonOCC and TiGL don't use OpenCASCADE handles anymore. For more insights, please see here: https://github.com/tpaviot/pythonocc-core/pull/583

Version 3.1.0

27/07/2020

  • General changes:
    • Full support of CPACS 3.1
    • Backport support for control surface devices from TiGL 2. It is now possible to manipulate trailing edge devices with TiGL 3.1 using the TiGL Viewer, the API or the language bindings.
    • Added support for fuselage walls
    • Support for fuselage profiles with kinks.
    • Added support for new symmetry flags inherit and none. The symmetry flag inherit causes a geometric component to inherit the symmetry flag from its parent geometry. This was and still is the default behavior in TiGL. The new symmetry type none allows the addition of components to mirrored geometries without respecting the symmetry of the parent.
    • Substantially improve performance of tiglCheckPointInside.
    • Reduce complexity of the fuselage geometry: The profiles of the fuselage are reparametrized to create simpler a B-spline surface. This will improve robustness of boolean operations and increase the general performance at the cost of a small error in the geometry creation, that should be negligable in most cases.
  • New API functions:
  • Fixes:
    • Fixes compilation errors with MinGW and VS 2019
    • Fixes compilation errors with qt4
    • Fixes compilation errors with OpenCascade 7.4.0 and OCCT 7.2
    • Several fixes to internal python bindings
    • Several fixes to control devices code.
    • Fixes invalid segment meta data in VTK export
    • fixing problem in ReadCPACS when using rotors (invalidation during read of segments caused error in lazy creation of attached rotor blades)
  • TiGLViewer:
    • Back-ported control surfaces to TiGL Viewer and improved design of flap dialog.
    • Added option to draw face boundaries in TiGl Viewer

Version 3.0.0

24/09/2019

  • General Changes:
    • CPACS 3 compatibility, including the new component-segment coordinate-system definition. The new cpacs definition of the wing structure allows more precise modelling of ribs and spars.
    • Guide curve support for wings and fuselages for high-fidelity surface modeling according to the CPACS 3 defintion.
    • Note: TiGL 3 does not yet contain the control surface device modeling. This will be included into TiGL 3.1.
    • New modeling of nacelles.
    • New modeling of pylons.
    • New modeling of fuselage structure elements like doors, beams, frames and pressure bulkheads.
    • Automated creation of CPACS reading and writing routines. This allows much better vality checks of the CPACS document.
    • The "GetPoint" function of wings / fuselages operate now on the actual wing/fuselage shape (e.g. in case of guide curves). Before, these function operated on the linear loft, which is different from the actual shape. To be backwards compatible, tiglWingGetUpperPoint, tiglWingGetLowerPoint, and tiglFuselageGetPoint still use the linear loft by default. If the actual smooth surface is desired, the new function tiglWingSetGetPointBehavior and tiglFuselageSetGetPointBehavior must be used to enable smooth lofts. Note: Using the actual smooth wing shape, tiglWingGetUpperPoint and tiglWingGetLowerPoint do not use the wing chord surface anymore as a reference coordinate system, but relies on the wing surface parametrization. This change was required, since there would be no other way to retrieve points around the leading edge, that is on front of the trapezoidal chord surface.
    • Improved speed of tiglFuselageGetPoint function. Also, the paramter xsi is now interpreted as the relative curve parameter instead of the relative circumference.
    • Improved robustness of fuselage loft computation.
    • The TIGL library was renamed to tigl3. The TIGLViewer was renamed to tiglviewer-3.
    • The windows builds are now using the Visual C++ 2015 Toolchain.
    • TiGL now requires a C++ 11 capable compiler. Minimum required compilers are gcc 4.8 or Visual C++ 2015.
  • New API functions:
  • Changed API:
    • Removed deprectated intersection functions. These include
      • tiglComponentIntersectionLineCount
      • tiglComponentIntersectionPoint
      • tiglComponentIntersectionPoints
    • Removed function tiglExportVTKSetOptions. This is now replaced by tiglSetExportOptions
      • tiglWingGetWettedArea now returns surface area of the wing, if the wing has no parent. Previously this caused a crash.
  • Fixes:
    • TiGL Viewer: Fixed missing fonts on macOS
  • Language bindings:
    • New python bindings allow to access the whole C++ API of TiGL. This bindings can be installed via conda.
    • Python: the tiglwrapper.py module was renamed to tigl3wrapper.py. The Tigl object is renamed to Tigl3.
    • Java: the tigl package moved from de.dlr.sc.tigl to de.dlr.sc.tigl3
  • TiGL Viewer:
    • Display of reflection lines to inspect surface quality.
    • Display of textured surfaces.
    • Angle of perspective can be adjusted using the scripting API with setCameraPosition and setLookAtPosition. This allows e.g. to create videos of the geometry.
    • Option to display face names.
    • Number of U and V iso-lines can be adjusted independently.
    • New design

Version 2.2.3

28/06/2018

  • New API functions:
    • Backport API function tiglCheckPointInside that checks wether a point lies inside a given geometric object
    • New API function tiglGetGuideCurvePoints to obtain the guide curve points on the fuselage/wing for a given guide curve.

Version 2.2.2

11/04/2018

  • General changes:
    • Modelling of control surfaces as trailing and leading edge devices
    • The wing is now written a one entity instead of several segments in the file exports
  • New API functions:
  • Fixes:
    • Fixed bug JAVA bindings getProfileSplines (issue #357)
  • TiGLViewer:
    • The control surface devices can be extended and retracted from inside the GUI
    • Added functions to set camera positions. The following functions where added:
      • setLookAtPosition(x, y, z)
      • setCameraPosition(elevationAngle, azimuthAngle) They can be used from the console to e.g. create movies.

Version 2.2.1

18/08/2017

  • General changes:
    • Improved calculation time of tiglFuselageGetPointAngle by roughly a factor of 30. The results might be a different than in previous versions, but the function should be more robust now.
    • Improved calculation time of tiglFuselageGetPoint by applying caching. This leads only to a benefit in case of a large number of GetPoint calls (~30) per fuselage segment. This will be even improved in TiGL 3.
  • New API functions:
    • New API function tiglExportVTKSetOptions. This function can be used e.g to disable normal vector writing in the VTK export.
  • Changed API:
  • Fixes:
    • Fixed bug, where the VTK export showed no geometry in ParaView
    • Improved accuracy of the VTK export. The digits of points are not truncated anymore to avoid duplicate points
    • Triangles with zero surface are excluded from the VTK export
    • Fixed incorrect face name ordering in WingComponentSegment

Version 2.2.0

23/12/2016

  • Major changes:
    • Added modelling of the wing structure, including ribs and spars . This code was part of a large pull request by Airbus D&S. Currently, the structure is only accessible by the TiGL Viewer. In future releases, we plan to make the structure accessible from the API.
    • Improved Collada export: The export is now conforming with the collada schema and can be displayed with OS X preview.
    • External shapes are added to the exports.
    • Added writing of modified CPACS files. Still, we do not offer yet API functions for modifications. Using the internal API, modifications are already possible.
  • New API functions:
  • TiGLViewer:
    • Visualization of the wing structure.
    • Improved linking and compilation with Qt.
    • Added STL export of the whole aircraft configuration.

Version 2.1.7

22/09/2016

Version 2.1.6

15/07/2015

  • TiGL Viewer:
    • Fixed critical crash on Windows 64 bit systems that occured sporadically on some systems

Version 2.1.5

01/07/2015

  • Changed API:
    • Added an output argument in the function tiglWingComponentSegmentPointGetSegmentEtaXsi that returns the error of the computation.
    • The function tiglWingComponentSegmentGetSegmentIntersection uses a new algorithm that should ensure straight flap leading edges and straight spars. Also, a new parameter hasWarning was added, to inform the user, that the returned segment xsi value is not in the valid range [0,1]. This might be the case, if a spar is partially located outside the wing.
    • Removed macros TIGL_VERSION and TIGL_VERSION_MAJOR from tigl.h. Please use tigl_version.h instead.
  • General changes:
    • External geometries can be included into the CPACS file using a link to a STEP file. The allows e.g. the use of engines and nacelles. (Note: this is not yet included in the CPACS standard)
    • Improved computation of half model fuselage profiles. Now, fuselages are c2 continuous at the symmetry plane.
    • Improved computation speed of tiglWingComponentSegmentGetPoint by a factor of 30 to 600 (depending on the geometry).
    • Reduced execution time of tiglOpenCPACSConfiguration.
    • All TiXI messages (errors/warnings) are now printed to the TiGL log.
    • Ported to OpenCASCADE 6.8.0.
  • New API functions:
  • Fixes:
  • TiGL Viewer:
    • Ported to Qt 5.
    • OpenGL accelerated rubber band selection. This fixes the slow rubber band selection on Linux and the invisible rubber band selection on Mac.
    • Fixed bug when loading a CPACS file with multiple models (thanks Jonas!).
    • Removed support for legacy VRML and CSDFB files.

Version 2.1.4

06/02/2015

  • Changed API:
  • New API functions:
  • Fixes:
    • Fixed some warnings using CMake 3
  • TiGL Viewer:
    • Fixed a crash in case of a missing model UID
    • Fixed a bug, where debugging BREP files where always created on Linux
    • Improved scripting interface for wingGetLower/UpperPointAtDirection to return the error
  • Language bindings:
    • Completed the new Java bindings for TiGL
    • Removed Fortran bindings since nobody is using them

Version 2.1.3

08/12/2014

  • Changed API:
  • General changes:
    • Support for global transformation (translation refType="absGlobal"). Notice: some (incorrect) CPACS models will now look differently.
    • Accurate B-Spline approximation of CST curves using Chebychev approximation.
    • Implemented recursive fusing trimming for the use of e.g. bellyfairings. Added small cpacs example how to model a bellyfairing.
    • Implemented trimming of intersection curves with parent bodies and far fields
    • Improved computation of fuselage positionings. This should improve loading times of configurations with large number of sections, since the algorithmic complexity is reduced.
    • IGES + STEP export: All wing faces are now classified as Top-Wing, Bottom-Wing, or Trailing-Edge.
    • IGES export: Changed units to mm.
    • IGES export: Implemented layers/levels .
    • The OCAF framework is no longer required to build TiGL.
    • The build system now uses the cmake config-style TiXI and OCE search mechanisms.
  • New API functions:
  • Fixes:
  • TiGLViewer:
    • Highly improved scripting console:
      • Script file can be given as command line argument (using option –script)
      • Added function to export all objects to file
      • The main application objects can be scripted (i.e. app, app.viewer, app.scene)
      • Draw shapes, points and vectors from script
      • Make screenshots by command
      • Context menu for copy-paste actions
      • History with recent commands
      • Mouse support
      • More wrapped tigl functions
      • Improved stability
      • Exception handling
      • TiXI errors and warnings are printed on the console now

Added dialog to draw points and vectors.

  • Added dialog for screenshot settings, including option for white background.
  • JPEG and PNG support for background images.
  • Collada export for the complete configuration (i.e. support for multiple objects).

Cleanup of menu entries.

  • Fixed multiple opened CPACS documents in TiGLViewer.
  • Fixed 3D view flickering on Mac OS X with Qt 4.8.6.

Language bindings:

  • Added python 3 support of tiglwrapper.py
  • Improved TiGL library loading error messages in python wrapper
  • New Java bindings. Hand-written high level API not yet complete (not all TiGL functions wrapped). Low level API (autogenerated) can be used instead for unimplemented functions.
  • Added Java example (see share/doc/tigl/examples/JavaDemo.java)

Documentation:

  • Added chapter for TiGL Viewer and the TiGL Viewer scripting console.

Version 2.1.2

17/04/2014

  • Changed API:
  • General changes:
    • Completely reworked boolean operations with the following effects:
      • Fusing the whole plane is faster in many cases and more reliable
      • We keep track of the origins of each trimmed face which helps for the IGES and STEP exports
      • The boolean operations can be debugged now by setting the environment variable TIGL_DEBUG_BOP
    • Completely rewritten STEP and IGES exports:
      • Each face has now an identifier name
      • Inclusion of intersection curves
      • Inclusion of far fields into exports
      • IGES export in non-BREP mode since it is not supported by CATIA
    • Added new demos for C, Python and MATLAB. Please look into the documentation how to run them.
    • Added function for the intersection computation of a geometrical shape with a plane
    • Experimental implementation of wing and fuselage guide curves
    • The mathematical orientation of wing profiles is checked for correctness
    • TiGL requires now at least OpenCASCADE 6.6.0
    • Ported to OpenCASCADE 6.7.0
  • New API functions:
  • Fixes:
    • Fixed a bug in tiglWingComponentSegmentFindSegment
    • Fixed numerical inaccuracy in the projection of points to a wing segment
    • Fixed crash in case of too long UIDs
    • Fixed some memory leaks
  • TiGLViewer:
    • Improved IGES import:
      • Multiple shapes are now imported as separate shapes from IGES files.
      • Fixed wrong scaling when importing IGES files.
    • Improved STEP export:
      • Files are now exported in units of meters instead of millimeters.
    • Improved BREP export and import: compound objects are now decomposed to separate objects.
    • Added method to export fused aircraft to BREP
    • Added method to export wing and fuselage profiles and guide curves to BREP
    • Fixed incorrect units in IGES and STEP export from save-as dialog.
    • General save-as dialog: All visible objects are saved to the file, if no shape is selected. Otherwise, only the selected objects are exported.
    • Added debugging parameters to settings dialog. This includes:
      • Adapting number of displayed iso lines per face
      • Display face numbers
      • Debug boolean operations (if enabled, debugging shapes in BRep format are stored to the current working directory)
    • Added new dialog for shape/shape and shape/plane intersections.
    • Added drag and drop support to TiGLViewer. Files (CPACS, IGES, STEP, BREP) are opened when they are dragged into TiGLViewer.
    • TiGLViewer displays far field after calculating the trimmed aircraft
    • Iso U/V lines are no longer displayed by default. This can be changed in the settings dialog.
    • The fused/trimmed aircraft geometry is displayed using a different color for each component.
    • Added visualization of wing and fuselage guide curves.
    • Fix: Only the first intersection curve was displayed. This is fixed now.
    • New icons

Version 2.1.1

Released: 28/01/2014

Version 2.1.0

Released: 17/01/2014

Version 2.0.7

Released: 21/11/2013

Version 2.0.6

Released: 27/08/2013

Version 2.0.5

Released: 11/06/2013

  • Changed API:
    • Switched to const char * strings
    • tiglWingGetSegmentIndex returns now also the wing index instead of asking for it
    • Removed TiGL wire algorithms switching functions. Now a Bspline wire is used for each profile.
  • General Changes:
    • Symmetry modeling
    • Explicit modeling of the wing leading edge to improve tesselated output (no more leading edge bumps)
    • Explicit modeling of the wing upper and lower shape
    • The fuselage lofting now creates a smooth surface without hard edges (due to fixed OpenCASCADE bug)
    • Completely rewritten VTK export:
      • Full body export including wing segment metadata
      • Fixed lots of errors.
      • Large improvement of calculation times.
      • Provides wing segment metadata in a proper VTK-way, to allow visualization of these data in VTK viewers. Calculation and export of the proper normal vectors.
    • IGES and STEP export with CPACS metadata
    • Collada export for use in 3D rendering programs like Blender
    • MATLAB bindings for TiGL!
    • Completeley rewritten python bindings (e.g. better support for arrays)
    • Added logging framework to write outputs into log files (google-glog)
    • Ported to OpenCASCADE 6.6.0
  • New API functions:
  • Fixes:
    • Intersection calculation used by tiglComponentIntersectionPoint
    • Fixed incorrectly placed fuselage positionings
    • Fixed tiglWingComponentSegmentFindSegment returning segments that don't belong to the component segment
    • Workaround to buggy OpenCASCADE boolean fuse algorithms (which seems to be non-commutative). As a result, the fusing of the whole plane can be slower than before.
    • Removed warning about missing component segments
  • TiGLViewer:
    • Display user defined component segment point
    • Improved speed of intersection calculation
    • Improved speed of shape triangulation
    • Display upper and lower shape of the wing
    • Display of the full model incorporating the symmetry properties of the CPACS components
    • Fixed detection, if CPACS file is changed while displayed in TiGLViewer
    • An optional control file can steer some basic settings like tesselation/triangulation accuracy (e.g. to tune speed of cpacs file opening)
    • STEP export
    • Settings Dialog (tesslation accuracy settings, background...)
    • New icon and color scheme

Version 2.0.4

Released: 17/01/2013

  • New API Functions:
  • Fixes:
  • TiGLViewer:
    • Added scripting interface to TIGLViewer. It is now possible to call TIGL/TIXI functions from within the TIGLViewer. The output is displayed in the console-view. Find more information here.
    • Added context-popup menu on right click. Available actions:
      • Removing of geometric shapes
      • Set transparency level of geometric shapes
      • Set color of selected shapes
      • Set material of selected shapes
      • Set wireframe/shading of selected shapes
    • Works now also in Mac OSX (since opencascade commit 4fe5661 )
    • Added toolbars
    • Added option to load a background image
    • Added autosave of user settings
    • Menus are disabled/enabled depending on dataset
    • Script could be loaded from file via File->open Script
    • Fixed opening from command line
    • Fixed bad font rendering for OpenCascade? > - 6.4.0

Version 2.0.3

Released: 17/01/2013

  • General Changes:
    • Added CCPACSWingSegment::GetChordPoint to internal API
    • Added a simple cpacs data set for accuracy testing
    • Added some accuracy tests for getPoint functions
    • Added support for visual leak detector
    • Changed UnitTesting? Framework to google-test
    • Changed TIGL linking to static for unit tests
    • Added coverage with gcov (gcc only) to project
  • New API Functions:
  • Fixes:
  • TIGLViewer:
    • Menus are enabled/disabled depending on number of wings/fuselages
    • Added close configuration menu entry
    • improved view rotation with middle mouse button

Version 2.0.2

Released: 16/10/2012

  • General Changes:
    • Fixed wing translation bug in TIGLViewer and export Functions
    • Implemented STL import
    • The result of the fused plane calculation is now chached
  • TiGLViewer:
    • Fixed triangulation algorithm (should not crash anymore)
    • Added full plane triangulation
    • Checks in all Selection-Dialogs, if cancel was pressed
    • Added calculation of intersection line of Wing and Fuselage
    • The recently opened folder is now saved

Version 2.0.1

Released: 02/10/2012

  • General Changes:
    • Fixed geometry transformations like sweep angle and dihedral angle rotating sections
    • Fixed scalings that lead to a translation of sections
    • Datasets with CPACS Version < 2.0 are now rejected
    • Calculation of fused fuselage, wing, and airplane should not crash anymore
    • Removed memory leaks
    • Cmake based project files
    • Prepared for OpenCascade? 6.5.3
    • Windows 64 Bit builds available
  • TiGLViewer:
    • Fixed inconsistent hot keys and menu entries for views
    • Console window showing outputs of TIGL and OpenCascade?
    • Wireframe mode
    • Recent Documents menu entry

Version 2.0

  • General Changes:
    • Compatible with CPACS 2.0
    • Corrected the implicit rotation of fuselage and wing profiles. They shouldn't turn from x-y to x-z by TIGL
    • TIGL now uses the coordinate system of parent components for child components. This is only done when parent --> child relations could be figured out via UIDs.
    • Profile points could now also be stored as the vector (x ,y, and z) containing all profile points.
    • Some XPath have changed in CPACS 2.0, for example "sweepangle" is now "sweepAngle". TIGL is taking care of these changes.
  • New API Functions:
  • TiGLViewer:
    • Complete rebuild of TIGLViewer. It is now QT based and platform independent
    • TIGLViewer now updates the view when the cpacs file is changed.

Version 1.0

Released: 31/08/2011

  • Changed API:
    • tiglOpenCpacsConfiguration now opens a configuration without specification if the uid if it is the only one in the data set. Simply take NULL or en empty string as uid argument.
    • Added a Python wrapper for the C-code and DLL handling (no need to manually convert cpython variables to python)
  • New API Functions
    • tiglComponentIntersectionPoint Returns a point on the intersection line of two geometric components. Often there are more one intersection line, therefore you need to specify the line.
    • tiglComponentIntersectionLineCount Returns the number if intersection lines of two geometric components.
    • tiglComponentGetHashCode Computes a hash value to represent a specific shape. The value is computed from the value of the underlying shape reference and the Orientation is not taken into account.
    • tiglFuselageGetMinumumDistanceToGround Returns the point where the distance between the selected fuselage and the ground is at minimum. Fuselage could be turned with a given angle at at given axis, specified by a point and a direction.
  • TIGLViewer
    • now could draw the componentSegment of a selected wing.

Version 0.9

Released: 29/04/2011

  • General Changes:
    • Fixed a bug that leads to strange errors when the first positioning of a Wing is not in the origin and has not innerSectionUID-element.
    • Removed annoying strErr message when a point miss one parameter.
    • TIGL 64-Bit libs are available for linux.
    • TIGL is now able to open rotocraft configurations as well as aircraft