![]() |
Open CASCADE Technology
7.6.0
|
|
Welcome to Open CASCADE Technology (OCCT), a software development platform providing services for 3D surface and solid modeling, CAD data exchange, and visualization. Most of OCCT functionality is available in the form of C++ libraries. OCCT can be best applied in development of software dealing with 3D modeling (CAD), manufacturing / measuring (CAM) or numerical simulation (CAE).
Open CASCADE Technology (OCCT) is an object-oriented C++ class library designed for rapid production of sophisticated domain-specific CAD/CAM/CAE applications.
A typical application developed using OCCT deals with two or three-dimensional (2D or 3D) geometric modeling in general-purpose or specialized Computer Aided Design (CAD) systems, manufacturing or analysis applications, simulation applications, or even illustration tools.
OCCT library is designed to be truly modular and extensible, providing C++ classes for:
The C++ classes and other types are grouped into packages. Packages are organized into toolkits (libraries), to which you can link your application. Finally, toolkits are grouped into seven modules.
This modular structure is illustrated in the diagram below.
In addition, Open CASCADE Test Harness, also called Draw, provides an entry point to the library and can be used as a testing tool for its modules.
Foundation Classes module contains data structures and services used by higher-level Open CASCADE Technology classes:
This module also provides a variety of general-purpose services, such as:
See the details in Foundation Classes User's Guide
Modeling Data supplies data structures to implement boundary representation (BRep) of objects in 3D. In BRep the shape is represented as an aggregation of geometry within topology. The geometry is understood as a mathematical description of a shape, e.g. as curves and surfaces (simple or canonical, Bezier, NURBS, etc). The topology is a data structure binding geometrical objects together.
Geometry types and utilities provide geometric data structures and services for:
Topology defines relationships between simple geometric entities. A shape, which is a basic topological entity, can be divided into components (sub-shapes):
Complex shapes can be defined as assemblies (compounds) of simpler entities.
See the details in Modeling Data User's Guide
3D geometric models can be stored in OCCT native BREP format. See BREP Format Description White Paper for details on the format.
Modeling Algorithms module groups a wide range of topological and geometric algorithms used in geometric modeling. Basically, there are two groups of algorithms in Open CASCADE Technology:
Low-level geometric tools provide the algorithms, which:
Low-level topological tools provide the algorithms, which:
Top-level API provides the following functionality:
See Boolean Operations User's Guide for detailed documentation.
See the details in Modeling Algorithms User's Guide.
Mesh toolkit provides the functionality to work with tessellated representations of objects in form of triangular facets. This toolkit contains:
Open CASCADE SAS also offers Advanced Mesh Products:
Visualization module provides ready-to-use algorithms to create graphic presentations from various objects: shapes, meshes, etc.
In Open CASCADE Technology visualization is based on the separation of CAD data and its graphical presentation. The module also supports a fast and powerful interactive selection mechanism.
Visualization module relies on the following key toolkits:
While low-level API operates with primitive arrays (triangles, lines, points), the higher level includes services for building presentations for B-Rep shapes (shaded and wireframe). A comprehensive list of standard interactive objects includes topological shape, mesh presentation, various dimensions, manipulators and others. It provides a solid basis for rapid application development, while flexible and extensible API allows development of highly customized application-specific presentations.
Here are a few examples of OCCT Visualization features:
For more details, see Visualization User's Guide.
The visualization of OCCT topological shapes by means of VTK library provided by VIS component is described in a separate VTK Integration Services User's Guide.
Data Exchange allows developing OCCT-based applications that can interact with other CAD systems by writing and reading CAD models to and from external data.
Data Exchange is organized in a modular way as a set of interfaces that comply with various CAD formats: IGES, STEP, STL, VRML, etc. The interfaces allow software based on OCCT to exchange data with various CAD/PDM software packages, maintaining a good level of interoperability. This module handles various problems of interoperability between CAD systems, caused by differences in model validity criteria and requirements to internal representation.
These components are based on the same architecture as interfaces with STEP and IGES.
Shape Healing library provides algorithms to correct and adapt the geometry and topology of shapes imported to OCCT from other CAD systems.
Shape Healing algorithms include, but are not limited to, the following operations:
Each sub-domain of Shape Healing has its own scope of functionality:
Sub-domain | Description | Impact on the shape |
---|---|---|
Analysis | Explores shape properties, computes shape features, detects violation of OCCT requirements. | The shape itself is not modified. |
Fixing | Fixes the shape to meet the OCCT requirements. | The shape may change its original form: modification, removal or creation of sub-shapes, etc.) |
Upgrade | Improves the shape to fit some particular algorithms. | The shape is replaced with a new one, but geometrically they are the same. |
Customization | Modifies the shape representation to fit specific needs. | The shape is not modified, only the mathematical form of its internal representation is changed. |
Processing | Mechanism of shape modification via a user-editable resource file. |
For more details, refer to Shape Healing User's guide.
Open CASCADE Application Framework (OCAF) handles Application Data basing on the Application/Document paradigm. It uses an associativity engine to simplify the development of a CAD application thanks to the following ready-to-use features and services:
Since OCAF handles the application structure, the only development task is the creation of application-specific data and GUIs.
OCAF differs from any other CAD framework in the organization of application data, as there the data structures are based on reference keys rather than on shapes. In a model, such attributes as shape data, color and material are attached to an invariant structure, which is deeper than the shapes. A shape object becomes the value of Shape attribute, in the same way as an integer number is the value of Integer attribute and a string is the value of Name attribute.
OCAF organizes and embeds these attributes in a document. OCAF documents, in their turn, are managed by an OCAF application.
For more details, see OCAF User's Guide.
Test Harness or Draw is a convenient testing tool for OCCT libraries. It can be used to test and prototype various algorithms before building an entire application. It includes:
The viewers support operations such as zoom, pan, rotation and full-screen views.
The basic commands provide general-purpose services such as:
In addition, Test Harness provides commands to create and manipulate curves and surfaces (geometry) and shapes, access visualization services, work with OCAF documents, perform data exchange, etc.
You can add custom commands to test or demonstrate any new functionalities, which you develop.
For more details, see Draw Test Harness Manual.
Open CASCADE Technology is designed to be highly portable and is known to work on wide range of platforms. Current version is officially certified on Windows (x86-64), Linux (x86-64), OS X / macOS (x86-64, arm64), Android (arm64), and iOS (arm64) platforms.
The tables below describe the recommended software configurations for which OCCT is certified to work.
OS | Compiler |
---|---|
Windows | Microsoft Visual Studio: 2010 SP1, 2012 Update 4, 2013 Update 5, 2015 Update 3, 2017 1, 2019 , LLVM (ClangCL), GCC 4.3+ (Mingw-w64) |
Linux | GNU gcc 4.3+ LLVM CLang 3.6+ |
OS X / macOS | XCode 6 or newer |
Android | NDK r12, GNU gcc 4.9 or newer |
Web | Emscripten SDK 1.39 or newer (CLang) |
1) VC++ 141 64-bit is used for regular testing and for building binary package of official release of OCCT on Windows.
The following third-party libraries and tools are not included in OCCT sources but are either required or can be optionally used for the indicated components of OCCT. They are not needed if relevant component is not needed.
Note that pre-built packages of many of the listed libraries are available at https://www.opencascade.com/content/3rd-party-components
Component | Where to find | Used for | Required or optional |
---|---|---|---|
CMake 2.8+ | https://cmake.org/ | Build from sources | Optional |
Intel TBB 4.x or later | https://www.threadingbuildingblocks.org/ | All | Optional (advanced parallelization of algorithms) |
OpenGL 3.3+, OpenGL ES 2.0+ | System | Visualization | Required |
OpenVR 1.10+ | https://github.com/ValveSoftware/openvr | Visualization | Optional (VR support) |
Direct3D 9 | Windows | Visualization | Optional (integration with GUI using Direct3D) |
FreeType 2.4+ | https://www.freetype.org/download.html | Visualization | Optional (text rendering) |
FreeImage 3.17+ | https://sourceforge.net/projects/freeimage/files | Visualization | Optional (support of common 2D graphic formats) |
FFmpeg 3.1+ | https://www.ffmpeg.org/download.html | Visualization | Optional (video recording) |
VTK 6.1+ | https://www.vtk.org/download/ | Visualization | Optional (VTK integration) |
Flex 2.6.4+ and Bison 3.7.1+ | https://sourceforge.net/projects/winflexbison/ | Data Exchange | Optional (update of STEP and ExprIntrp parsers) |
RapidJSON 1.1+ | https://rapidjson.org/ | Data Exchange | Optional (reading glTF files) |
Draco 1.4.1+ | https://github.com/google/draco | Data Exchange | Optional (reading compressed glTF files) |
Tcl/Tk 8.6.3+ or ActiveTcl 8.6 | https://www.tcl.tk/software/tcltk/download.html https://www.activestate.com/activetcl/downloads | DRAW Test Harness | Required |
Qt Desktop: Qt 4.8.6+ Android: Qt 5.3.2+ | https://www.qt.io/download/ | Samples and demos | Optional (Qt samples) |
Doxygen 1.8.5+ | https://www.doxygen.nl/download.html | Documentation | Required |
Graphviz 2.38+ | https://graphviz.org/ | Documentation | Optional (dependency graphs) |
Component | Requirement |
---|---|
Minimum memory | 512 MB, 1 GB recommended |
Free disk space (complete installation) | 1,5 GB approx. |
On desktop, 3D viewer for optimal performance requires graphics processing unit (GPU) supporting OpenGL 3.3 or above. Ray tracing requires OpenGL 4.0+ or OpenGL 3.3+ with GL_ARB_texture_buffer_object_rgb32 extension. Textures within ray tracing will be available only when GL_ARB_bindless_texture extension is provided by driver.
On mobile platforms, OpenGL ES 2.0+ is required for 3D viewer (OpenGL ES 3.1+ is recommended). Ray tracing requires OpenGL ES 3.2. Some old hardware might be unable to execute complex GLSL programs (e.g. with high number of light sources, clipping planes).
OCCT 3D Viewer, in general, supports wide range of graphics hardware - from very old to new. Therefore, if you observe some unexpected visual issues - first check for OpenGL driver update (or firmware update in case of mobile platforms); but beware that driver update might also come with new bugs. Don't forget to report these bugs to vendors.
OCCT can be downloaded from https://www.opencascade.com/content/latest-release
In most cases you would want to rebuild OCCT from sources on your platform (OS, compiler) before using it in your project, to ensure binary compatibility and appropriate configuration of the library. See Build, Debug and Upgrade for instructions on building OCCT from sources on supported platforms.
The following subsections describe how OCCT can be installed from ready-to-use packages on different platforms.
On Windows Open CASCADE Technology with binaries precompiled by Visual C++ 2017 can be installed using installation procedure available on official download page.
Recommendation:
If you have a previous version of OCCT installed on your station, and you do not plan to use it along with the new version, you might want to uninstall the previous version (using Control Panel, Add/Remove Programs) before the installation of this new version, to avoid possible problems (conflict of system variables, paths, etc).
Full OCCT installation with reference documentation requires 1.8 Gb on disk.
When the installation is complete, you will find the directories for 3rd party products (some might be absent in case of custom installation) and the main OCCT directory:
The contents of the OCCT-7.4.0 directory (called further "OCCT root", or $CASROOT) are as follows:
OCCT is available as package "opencascade" in official repositories of many Linux distributions.
See https://repology.org/project/opencascade/versions for overview of available repositories.
On macOS, OCCT is available in Homebrew (https://formulae.brew.sh/formula/opencascade) and MacPorts (https://ports.macports.org/port/opencascade/summary) repositories.
To run any Open CASCADE Technology application you need to set the environment variables.
You can define the environment variables with env.bat script located in the $CASROOT folder. This script accepts two arguments to be used: the version of Visual Studio (vc10 – vc142) and the architecture (win32 or win64).
The additional environment settings necessary for compiling OCCT libraries and samples by Microsoft Visual Studio can be set using script custom.bat located in the same folder. You might need to edit this script to correct the paths to third-party libraries if they are installed on your system in a non-default location.
Script msvc.bat can be used with the same arguments for immediate launch of Visual Studio for (re)compiling OCCT.
If OCCT was built by Code::Blocks, you can define the environment variables with env_cbp.sh or custom_cbp.sh script.
If OCCT was built by Automake, you can define the environment variables with env_amk.sh or custom_amk.sh script.
The scripts are located in the OCCT root folder.
Open CASCADE Technology and all materials, including this documentation, is Copyright (c) 1999-2020 by OPEN CASCADE S.A.S. All rights reserved.
Open CASCADE Technology is free software; you can redistribute it and / or modify it under the terms of the GNU Lesser General Public License (LGPL) version 2.1, with additional exception.
Note that LGPL imposes some obligations on the application linked with Open CASCADE Technology. If you wish to use OCCT in a proprietary application, please pay a special attention to address the requirements of LGPL section 6. At minimum the following should be considered:
If you want to use Open CASCADE Technology without being bound by LGPL requirements, please contact Open CASCADE company for a commercial license.
Note that Open CASCADE Technology is provided on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND. The entire risk related to any use of the OCCT code and materials is on you. See the license text for formal disclaimer.
The following parties are acknowledged for producing tools which are used within Open CASCADE Technology libraries or for release preparation.
You are hereby informed that all rights to the software listed below belong to its respective authors and such software may not be freely available and/or be free of charge for any kind of use or purpose. We strongly recommend that you carefully read the license of these products and, in case you need any further information, directly contact their authors.
Qt is a cross-platform application framework that is widely used for developing application software with graphical user interface (GUI). Qt is free and open source software distributed under the terms of the GNU Lesser General Public License. In OCCT Qt is used for programming samples. If you need further information on Qt, refer to Qt Homepage (https://www.qt.io/)
Tcl is a high-level programming language. Tk is a graphical user interface (GUI) toolkit, with buttons, menus, listboxes, scrollbars, and so on. Taken together Tcl and Tk provide a solution to develop cross-platform graphical user interfaces with a native look and feel. Tcl/Tk is under copyright by Scriptics Corp., Sun Microsystems, and other companies. However, Tcl/Tk is an open source, and the copyright allows you to use, modify, and redistribute Tcl/Tk for any purpose, without an explicit license agreement and without paying any license fees or royalties. To use Tcl/Tk, refer to the Licensing Terms (https://www.tcl.tk/software/tcltk/license.html).
FreeType 2 is developed by Antoine Leca, David Turner, Werner Lemberg and others. It is a software font engine that is designed to be small, efficient, highly customizable and portable while capable of producing high-quality output (glyph images). This product can be used in graphic libraries, display servers, font conversion tools, text image generation tools, and many other products. FreeType 2 is released under two open-source licenses: BSD-like FreeType License and the GPL (https://www.freetype.org/license.html).
Intel(R) Threading Building Blocks (TBB) offers a rich and complete approach to expressing parallelism in a C++ program. It is a library that helps you to take advantage of multi-core processor performance without having to be a threading expert. Threading Building Blocks is not just a threads-replacement library. It represents a higher-level, task-based parallelism that abstracts platform details and threading mechanisms for scalability and performance. TBB version 2017 is available under Apache 2.0 license, while older versions until 4.4 are available under GPLv2 license with the runtime exception (https://www.threadingbuildingblocks.org).
OpenGL is an industry standard API for 3D graphics used by OCCT for implementation of 3D viewer. OpenGL specification is developed by the Khronos group, https://www.khronos.org/opengl/. OCCT code includes header file glext.h obtained from Khronos web site.
OpenVR is an API and runtime that allows access to VR hardware from multiple vendors without requiring that applications have specific knowledge of the hardware they are targeting. OpenVR is optionally used by OCCT for VR support. OpenVR is released under BSD-like license (https://github.com/ValveSoftware/openvr/blob/master/LICENSE).
VTK – The Visualization Toolkit (VTK) is an open-source, freely available software system for 3D computer graphics, image processing and visualization. OCCT VIS component provides adaptation functionality for visualization of OCCT topological shapes by means of VTK library. If you need further information on VTK, refer to VTK Homepage https://www.vtk.org/.
Doxygen developed by Dimitri van Heesch is open source documentation system for C++, C, Java, Objective-C, Python, IDL, PHP and C#. This product is used in Open CASCADE Technology for automatic creation of Technical Documentation from C++ header files. If you need further information on Doxygen, refer to https://www.stack.nl/~dimitri/doxygen/index.html.
Graphviz is open source graph visualization software developed by John Ellson, Emden Gansner, Yifan Hu and Arif Bilgin. Graph visualization is representiation of structured information as diagrams of abstract graphs and networks. This product is used together with Doxygen in Open CASCADE Technology for automatic creation of Technical Documentation (generation of dependency graphs). Current versions of Graphviz are licensed on an open source basis under The Eclipse Public License (EPL) (https://www.graphviz.org/license/).
Inno Setup is a free script-driven installation system created in CodeGear Delphi by Jordan Russell. In OCCT Inno Setup is used to create Installation Wizard on Windows. It is licensed under Inno Setup License (http://www.jrsoftware.org/files/is/license.txt).
FreeImage is an Open Source library supporting popular graphics image formats, such as PNG, BMP, JPEG, TIFF, and others used by multimedia applications. This library is developed by Hervé Drolon and Floris van den Berg. FreeImage is easy to use, fast, multithreading safe, compatible with all 32-bit or 64-bit versions of Windows, and cross-platform (works both with Linux and Mac OS X). FreeImage is optionally used by OCCT to work with images, on conditions of the FreeImage Public License (FIPL) (https://freeimage.sourceforge.net/freeimage-license.txt).
FFmpeg is an Open Source framework supporting various image, video and audio codecs. FFmpeg is optionally used by OCCT for video recording, on LGPL conditions (https://www.ffmpeg.org/legal.html).
David M. Gay's floating point routines (dtoa.c) are used for fast reading of floating point values from text strings. These routines are available under MIT-like license (see https://www.netlib.org/fp/).
Flex is a generator of lexical analyzers (scanners), available under BSD license (https://github.com/westes/flex).
GNU Bison is a parser generator used (together with Flex) for implementation of reader of STEP file format and parser of expressions. It is available under GNU GPL v3 license (https://www.gnu.org/software/bison/).
Delabella is an open-source, cross-platform implementation of the Newton Apple Wrapper algorithm producing 2D Delaunay triangulation. Delabella is used by BRepMesh as one of alternative 2D triangulation algorithms. Delabella is licensed under the MIT license (https://github.com/msokalski/delabella).
CMake is an open-source, cross-platform family of tools designed to build, test and package software. CMake is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of your choice. OCCT uses CMake as a build system. CMake is available under BSD 3-Clause license. See more at https://cmake.org/
Cotire (compile time reducer) is a CMake module that speeds up the build process of CMake based build systems by fully automating techniques as precompiled header usage and single compilation unit builds for C and C++. Cotire is included in OCCT repository and used optionally by OCCT CMake scripts to accelerate builds by use of precompiled headers. Cotire is licensed under the MIT license (https://github.com/sakra/cotire/blob/master/license).
MikTEX is up-to-date implementation of TeX/LaTeX and related programs for Windows. It is used for generation of User and Developer Guides in PDF format. See https://miktex.org for information on this tool.
RapidJSON is an Open Source JSON parser and generator for C++. RapidJSON is optionally used by OCCT for reading glTF files (https://rapidjson.org/).
Draco is an Open Source JSON parser and generator for C++. Draco is optionally used by OCCT for reading glTF files using KHR_draco_mesh_compression extension (https://github.com/google/draco). Draco is available under Apache 2.0 license.
DejaVu fonts are a font family based on the Vera Fonts under a permissive license (MIT-like, https://dejavu-fonts.github.io/License.html). DejaVu Sans (basic Latin sub-set) is used by OCCT as fallback font when no system font is available.
Adobe Systems, Inc. provides Adobe Reader, which can be used to view files in Portable Document Format (PDF).
CAS.CADE and Open CASCADE are registered trademarks of OPEN CASCADE S.A.S.
Linux is a registered trademark of Linus Torvalds.
Windows is a registered trademark of Microsoft Corporation in the United States and other countries.
Mac, OS X, macOS, and the Mac logo are trademarks of Apple Inc., registered in the U.S. and other countries.
Android is a trademark of Google LLC.