From af6f6cfaacb2c9c2de9cc203d191c301dbb0506e Mon Sep 17 00:00:00 2001 From: vsr Date: Mon, 1 Jun 2015 16:56:12 +0300 Subject: [PATCH 1/1] Initial repository creation --- CANRECPlugin_version.h.in | 41 ++ CMakeLists.txt | 227 ++++++++ COPYING | 504 ++++++++++++++++++ INSTALL | 111 ++++ README | 117 ++++ SalomeCANRECPLUGINConfig.cmake.in | 113 ++++ adm_local/CMakeLists.txt | 20 + adm_local/cmake_files/CMakeLists.txt | 31 ++ adm_local/cmake_files/FindCR.cmake | 58 ++ .../cmake_files/FindSalomeCANRECPLUGIN.cmake | 34 ++ adm_local/cmake_files/FindSalomeCR.cmake | 26 + doc/CMakeLists.txt | 20 + doc/salome/CMakeLists.txt | 21 + doc/salome/examples/CMakeLists.txt | 21 + doc/salome/examples/canrecplugindemo.py | 26 + doc/salome/gui/CANRECPLUGIN/CMakeLists.txt | 52 ++ doc/salome/gui/CANRECPLUGIN/doxyfile.in | 114 ++++ doc/salome/gui/CANRECPLUGIN/doxyfile_py.in | 160 ++++++ .../CANRECPLUGIN/images/canrec_plugin_dlg.png | Bin 0 -> 11273 bytes doc/salome/gui/CANRECPLUGIN/images/head.png | Bin 0 -> 78545 bytes .../input/canrecplugin_python_interface.doc | 17 + .../input/canrecplugin_usage_page.doc | 26 + doc/salome/gui/CANRECPLUGIN/input/index.doc | 15 + .../gui/CANRECPLUGIN/static/footer.html | 13 + .../gui/CANRECPLUGIN/static/header.html.in | 23 + .../gui/CANRECPLUGIN/static/header_py.html.in | 24 + .../gui/CANRECPLUGIN/static/salome_extra.css | 29 + doc/salome/gui/CMakeLists.txt | 20 + idl/CANRECPlugin.idl | 49 ++ idl/CMakeLists.txt | 48 ++ resources/CANRECPlugin.xml | 41 ++ resources/CMakeLists.txt | 33 ++ resources/SalomeApp.xml | 32 ++ resources/canonicalrecognition.png | Bin 0 -> 767 bytes resources/select1.png | Bin 0 -> 1143 bytes resources/tree_canonicalrecognition.png | Bin 0 -> 577 bytes src/CANRECPLUGINEngine/CANRECPluginEngine.cxx | 30 ++ src/CANRECPLUGINEngine/CANRECPluginEngine.hxx | 33 ++ .../CANRECPluginEngine_IOperations_i.cc | 76 +++ .../CANRECPluginEngine_IOperations_i.hh | 51 ++ .../CANRECPluginEngine_OperationsCreator.cc | 58 ++ .../CANRECPluginEngine_OperationsCreator.hh | 49 ++ .../CANRECPluginImpl_Driver.cxx | 142 +++++ .../CANRECPluginImpl_Driver.hxx | 44 ++ .../CANRECPluginImpl_ICanRec.hxx | 51 ++ .../CANRECPluginImpl_IOperations.cxx | 103 ++++ .../CANRECPluginImpl_IOperations.hxx | 40 ++ .../CANRECPluginImpl_Types.hxx | 30 ++ .../CANRECPluginImpl_license.h.in | 25 + src/CANRECPLUGINEngine/CMakeLists.txt | 81 +++ src/CANRECPLUGINGUI/CANRECPluginGUI.cxx | 98 ++++ src/CANRECPLUGINGUI/CANRECPluginGUI.h | 37 ++ ...ANRECPluginGUI_CanonicalRecognitionDlg.cxx | 311 +++++++++++ .../CANRECPluginGUI_CanonicalRecognitionDlg.h | 70 +++ src/CANRECPLUGINGUI/CMakeLists.txt | 103 ++++ .../resources/CANRECPlugin_images.ts | 19 + .../resources/CANRECPlugin_msg_en.ts | 66 +++ .../resources/CANRECPlugin_msg_fr.ts | 66 +++ .../resources/CANRECPlugin_msg_ja.ts | 66 +++ src/CANRECPLUGIN_PY/CANRECPluginBuilder.py | 76 +++ src/CANRECPLUGIN_PY/CMakeLists.txt | 31 ++ src/CANRECPLUGIN_PY/__init__.py | 22 + src/CMakeLists.txt | 24 + 63 files changed, 3868 insertions(+) create mode 100644 CANRECPlugin_version.h.in create mode 100644 CMakeLists.txt create mode 100644 COPYING create mode 100644 INSTALL create mode 100644 README create mode 100644 SalomeCANRECPLUGINConfig.cmake.in create mode 100644 adm_local/CMakeLists.txt create mode 100644 adm_local/cmake_files/CMakeLists.txt create mode 100644 adm_local/cmake_files/FindCR.cmake create mode 100644 adm_local/cmake_files/FindSalomeCANRECPLUGIN.cmake create mode 100644 adm_local/cmake_files/FindSalomeCR.cmake create mode 100644 doc/CMakeLists.txt create mode 100644 doc/salome/CMakeLists.txt create mode 100644 doc/salome/examples/CMakeLists.txt create mode 100644 doc/salome/examples/canrecplugindemo.py create mode 100644 doc/salome/gui/CANRECPLUGIN/CMakeLists.txt create mode 100644 doc/salome/gui/CANRECPLUGIN/doxyfile.in create mode 100644 doc/salome/gui/CANRECPLUGIN/doxyfile_py.in create mode 100644 doc/salome/gui/CANRECPLUGIN/images/canrec_plugin_dlg.png create mode 100644 doc/salome/gui/CANRECPLUGIN/images/head.png create mode 100644 doc/salome/gui/CANRECPLUGIN/input/canrecplugin_python_interface.doc create mode 100644 doc/salome/gui/CANRECPLUGIN/input/canrecplugin_usage_page.doc create mode 100644 doc/salome/gui/CANRECPLUGIN/input/index.doc create mode 100644 doc/salome/gui/CANRECPLUGIN/static/footer.html create mode 100644 doc/salome/gui/CANRECPLUGIN/static/header.html.in create mode 100644 doc/salome/gui/CANRECPLUGIN/static/header_py.html.in create mode 100644 doc/salome/gui/CANRECPLUGIN/static/salome_extra.css create mode 100644 doc/salome/gui/CMakeLists.txt create mode 100644 idl/CANRECPlugin.idl create mode 100644 idl/CMakeLists.txt create mode 100644 resources/CANRECPlugin.xml create mode 100644 resources/CMakeLists.txt create mode 100644 resources/SalomeApp.xml create mode 100644 resources/canonicalrecognition.png create mode 100644 resources/select1.png create mode 100644 resources/tree_canonicalrecognition.png create mode 100644 src/CANRECPLUGINEngine/CANRECPluginEngine.cxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginEngine.hxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.cc create mode 100644 src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.hh create mode 100644 src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.cc create mode 100644 src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.hh create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.cxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.hxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_ICanRec.hxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.cxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.hxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_Types.hxx create mode 100644 src/CANRECPLUGINEngine/CANRECPluginImpl_license.h.in create mode 100644 src/CANRECPLUGINEngine/CMakeLists.txt create mode 100644 src/CANRECPLUGINGUI/CANRECPluginGUI.cxx create mode 100644 src/CANRECPLUGINGUI/CANRECPluginGUI.h create mode 100644 src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.cxx create mode 100644 src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.h create mode 100644 src/CANRECPLUGINGUI/CMakeLists.txt create mode 100644 src/CANRECPLUGINGUI/resources/CANRECPlugin_images.ts create mode 100644 src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_en.ts create mode 100644 src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_fr.ts create mode 100644 src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_ja.ts create mode 100644 src/CANRECPLUGIN_PY/CANRECPluginBuilder.py create mode 100644 src/CANRECPLUGIN_PY/CMakeLists.txt create mode 100644 src/CANRECPLUGIN_PY/__init__.py create mode 100644 src/CMakeLists.txt diff --git a/CANRECPlugin_version.h.in b/CANRECPlugin_version.h.in new file mode 100644 index 0000000..7baffbc --- /dev/null +++ b/CANRECPlugin_version.h.in @@ -0,0 +1,41 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGIN_VERSION_H) +#define __CANRECPLUGIN_VERSION_H + +/*! + Specify version of SALOME CANRECPLUGIN module, as follows + + CANRECPLUGIN_VERSION_MAJOR : (integer) number identifying major version + CANRECPLUGIN_VERSION_MINOR : (integer) number identifying minor version + CANRECPLUGIN_VERSION_MAINTENANCE : (integer) number identifying maintenance version + CANRECPLUGIN_VERSION_STR : (string) complete version number "major.minor.maintenance" + CANRECPLUGIN_VERSION : (hex) complete version number (major << 16) + (minor << 8) + maintenance + CANRECPLUGIN_DEVELOPMENT : (integer) indicates development version when set to 1 +*/ + +#define CANRECPLUGIN_VERSION_MAJOR @SALOMECANRECPLUGIN_MAJOR_VERSION@ +#define CANRECPLUGIN_VERSION_MINOR @SALOMECANRECPLUGIN_MINOR_VERSION@ +#define CANRECPLUGIN_VERSION_MAINTENANCE @SALOMECANRECPLUGIN_PATCH_VERSION@ +#define CANRECPLUGIN_VERSION_STR "@SALOMECANRECPLUGIN_VERSION@" +#define CANRECPLUGIN_VERSION @SALOMECANRECPLUGIN_XVERSION@ +#define CANRECPLUGIN_DEVELOPMENT @SALOMECANRECPLUGIN_VERSION_DEV@ + +#endif // __CANRECPLUGIN_VERSION_H diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..be217c3 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,227 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8 FATAL_ERROR) +PROJECT(SalomeCANRECPLUGIN C CXX) + +# Ensure a proper linker behavior: +CMAKE_POLICY(SET CMP0003 NEW) + +# Versioning +# ========== +# Project name, upper case +STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC) + +SET(${PROJECT_NAME_UC}_MAJOR_VERSION 7) +SET(${PROJECT_NAME_UC}_MINOR_VERSION 6) +SET(${PROJECT_NAME_UC}_PATCH_VERSION 0) +SET(${PROJECT_NAME_UC}_VERSION + ${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION}) +SET(${PROJECT_NAME_UC}_VERSION_DEV 0) + +# Find KERNEL +# =========== +SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR} CACHE PATH "Path to the SALOME KERNEL") +IF(EXISTS ${KERNEL_ROOT_DIR}) + LIST(APPEND CMAKE_MODULE_PATH "${KERNEL_ROOT_DIR}/salome_adm/cmake_files") + INCLUDE(SalomeMacros) + FIND_PACKAGE(SalomeKERNEL REQUIRED) + KERNEL_WITH_CORBA() #check whether KERNEL is built with CORBA + ADD_DEFINITIONS(${KERNEL_DEFINITIONS}) + INCLUDE_DIRECTORIES(${KERNEL_INCLUDE_DIRS}) +ELSE(EXISTS ${KERNEL_ROOT_DIR}) + MESSAGE(FATAL_ERROR "We absolutely need a SALOME KERNEL, please define KERNEL_ROOT_DIR") +ENDIF(EXISTS ${KERNEL_ROOT_DIR}) + +# Platform setup +# ============== +INCLUDE(SalomeSetupPlatform) # From KERNEL +# Always build libraries as shared objects: +SET(BUILD_SHARED_LIBS TRUE) +# Local macros: +LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/adm_local/cmake_files") + +# Find GEOM +# ========= +SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR} CACHE PATH "Path to the SALOME Geometry") +IF(EXISTS ${GEOM_ROOT_DIR}) + LIST(APPEND CMAKE_MODULE_PATH "${GEOM_ROOT_DIR}/adm_local/cmake_files") + FIND_PACKAGE(SalomeGEOM REQUIRED) + ADD_DEFINITIONS(${GEOM_DEFINITIONS}) + INCLUDE_DIRECTORIES(${GEOM_INCLUDE_DIRS}) +ELSE(EXISTS ${GEOM_ROOT_DIR}) + MESSAGE(FATAL_ERROR "We absolutely need a SALOME Geometry, please define GEOM_ROOT_DIR") +ENDIF(EXISTS ${GEOM_ROOT_DIR}) + +# User options +# ============ +OPTION(SALOME_BUILD_GUI "Enable GUI" ${SALOME_GEOM_BUILD_GUI}) +OPTION(SALOME_BUILD_DOC "Generate SALOME CANRECPLUGIN documentation" ON) +OPTION(SALOME_BUILD_TESTS "Build SALOME tests" ON) +OPTION(CANREC_LICENSE "OCCT Canonical recognition license key" "") + +# Find GUI (optional) +# =================== +IF(SALOME_BUILD_GUI) + SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR} CACHE PATH "Path to the SALOME GUI") + IF(EXISTS ${GUI_ROOT_DIR}) + LIST(APPEND CMAKE_MODULE_PATH "${GUI_ROOT_DIR}/adm_local/cmake_files") + FIND_PACKAGE(SalomeGUI) + FULL_GUI(TRUE) # check whether GUI is built in full mode and with CORBA + ELSE(EXISTS ${GUI_ROOT_DIR}) + MESSAGE(FATAL_ERROR "We absolutely need a SALOME GUI, please define GUI_ROOT_DIR") + ENDIF(EXISTS ${GUI_ROOT_DIR}) + IF(NOT SALOME_GEOM_BUILD_GUI) + MESSAGE(FATAL_ERROR "SALOME Geometry module is built without GUI") + ENDIF(NOT SALOME_GEOM_BUILD_GUI) + SALOME_LOG_OPTIONAL_PACKAGE(SalomeGUI SALOME_BUILD_GUI) +ENDIF(SALOME_BUILD_GUI) + +IF(SALOME_BUILD_TESTS) + ENABLE_TESTING() +ENDIF() + +IF(CANREC_LICENSE) + ADD_DEFINITIONS(-DCANREC_HASLICENSE) +ELSE() + MESSAGE(WARNING "OCCT Canonical recognition license key is not specified! Runtime license will be required!") +ENDIF() + +# Pre-requisites +# ============== +FIND_PACKAGE(SalomePython REQUIRED) +FIND_PACKAGE(SalomeCAS REQUIRED) +FIND_PACKAGE(SalomeCR REQUIRED) +FIND_PACKAGE(SalomeOmniORB REQUIRED) +FIND_PACKAGE(SalomeOmniORBPy REQUIRED) +IF(SALOME_BUILD_GUI) + FIND_PACKAGE(SalomeQt4 REQUIRED COMPONENTS QtCore QtGui) +ENDIF(SALOME_BUILD_GUI) +IF(SALOME_BUILD_DOC) + FIND_PACKAGE(SalomeDoxygen) + SALOME_LOG_OPTIONAL_PACKAGE(Doxygen SALOME_BUILD_DOC) +ENDIF() + +# Detection summary: +SALOME_PACKAGE_REPORT_AND_CHECK() + +# Directories +# =========== +SET(SALOME_INSTALL_BINS "${SALOME_INSTALL_BINS}" CACHE PATH "Install path: SALOME binaries") +SET(SALOME_INSTALL_LIBS "${SALOME_INSTALL_LIBS}" CACHE PATH "Install path: SALOME libs") +SET(SALOME_INSTALL_IDLS "${SALOME_INSTALL_IDLS}" CACHE PATH "Install path: SALOME IDL files") +SET(SALOME_INSTALL_HEADERS "${SALOME_INSTALL_HEADERS}" CACHE PATH "Install path: SALOME headers") +SET(SALOME_INSTALL_SCRIPT_SCRIPTS "${SALOME_INSTALL_SCRIPT_SCRIPTS}" CACHE PATH + "Install path: SALOME scripts") +SET(SALOME_INSTALL_SCRIPT_DATA "${SALOME_INSTALL_SCRIPT_DATA}" CACHE PATH + "Install path: SALOME script data") +SET(SALOME_INSTALL_SCRIPT_PYTHON "${SALOME_INSTALL_SCRIPT_PYTHON}" CACHE PATH + "Install path: SALOME Python scripts") +SET(SALOME_INSTALL_PYTHON "${SALOME_INSTALL_PYTHON}" CACHE PATH "Install path: SALOME Python stuff") +SET(SALOME_INSTALL_PYTHON_SHARED "${SALOME_INSTALL_PYTHON_SHARED}" CACHE PATH + "Install path: SALOME Python shared modules") +SET(SALOME_INSTALL_CMAKE_LOCAL "${SALOME_INSTALL_CMAKE_LOCAL}" CACHE PATH + "Install path: local SALOME CMake files") +SET(SALOME_INSTALL_RES "${SALOME_INSTALL_RES}" CACHE PATH "Install path: SALOME resources") +SET(SALOME_INSTALL_DOC "${SALOME_INSTALL_DOC}" CACHE PATH "Install path: SALOME documentation") + +# Specific to CANRECPLUGIN: +SET(SALOME_CANRECPLUGIN_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/canrecplugin" CACHE PATH + "Install path: SALOME CANRECPLUGIN specific data") + +MARK_AS_ADVANCED(SALOME_INSTALL_BINS SALOME_INSTALL_LIBS SALOME_INSTALL_IDLS SALOME_INSTALL_HEADERS) +MARK_AS_ADVANCED(SALOME_INSTALL_SCRIPT_SCRIPTS SALOME_INSTALL_SCRIPT_DATA SALOME_INSTALL_SCRIPT_PYTHON) +MARK_AS_ADVANCED(SALOME_INSTALL_PYTHON SALOME_INSTALL_PYTHON_SHARED) +MARK_AS_ADVANCED(SALOME_INSTALL_CMAKE_LOCAL SALOME_INSTALL_RES SALOME_INSTALL_DOC) +MARK_AS_ADVANCED(SALOME_CANRECPLUGIN_INSTALL_RES_DATA) + +# Accumulate environment variables for CANRECPLUGIN module +SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_PYTHON}) +SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_LIBS}) + +# Sources +# ======= +ADD_SUBDIRECTORY(idl) +ADD_SUBDIRECTORY(adm_local) +ADD_SUBDIRECTORY(resources) +ADD_SUBDIRECTORY(src) +IF(SALOME_BUILD_DOC) + ADD_SUBDIRECTORY(doc) +ENDIF(SALOME_BUILD_DOC) + +# Header configuration +# ==================== +SALOME_XVERSION(${PROJECT_NAME}) +SALOME_CONFIGURE_FILE(CANRECPlugin_version.h.in CANRECPlugin_version.h INSTALL ${SALOME_INSTALL_HEADERS}) + +# Configuration export +# (here only the level 1 prerequisites are exposed) +# ==================== +INCLUDE(CMakePackageConfigHelpers) + +# List of targets in this project we want to make visible to the rest of the world. +# They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup" +SET(_${PROJECT_NAME}_exposed_targets + SalomeIDLCANRECPlugin CANRECPluginEngine +) + +IF(SALOME_BUILD_GUI) + LIST(APPEND _${PROJECT_NAME}_exposed_targets + CANRECPluginGUI + ) +ENDIF(SALOME_BUILD_GUI) + +# Add all targets to the build-tree export set +EXPORT(TARGETS ${_${PROJECT_NAME}_exposed_targets} + FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake) + +# Ensure the variables are always defined for the configure: +SET(KERNEL_ROOT_DIR "${KERNEL_ROOT_DIR}") +SET(GUI_ROOT_DIR "${GUI_ROOT_DIR}") +SET(GEOM_ROOT_DIR "${GEOM_ROOT_DIR}") +SET(CR_ROOT_DIR "${CR_ROOT_DIR}") +SET(OCCLICENSE_ROOT_DIR "${OCCLICENSE_ROOT_DIR}") + +SET(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include") + +# Build variables that will be expanded when configuring SalomeConfig.cmake: +SALOME_CONFIGURE_PREPARE(CR) + +CONFIGURE_PACKAGE_CONFIG_FILE(${PROJECT_NAME}Config.cmake.in + ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake + INSTALL_DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}" + PATH_VARS CONF_INCLUDE_DIRS SALOME_INSTALL_CMAKE_LOCAL CMAKE_INSTALL_PREFIX + KERNEL_ROOT_DIR GUI_ROOT_DIR GEOM_ROOT_DIR CR_ROOT_DIR OCCLICENSE_ROOT_DIR) + +WRITE_BASIC_PACKAGE_VERSION_FILE(${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake + VERSION ${${PROJECT_NAME_UC}_VERSION} + COMPATIBILITY AnyNewerVersion) + +# Install the CMake configuration files: +INSTALL(FILES + "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" + "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" + DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}") + +# Install the export set for use with the install-tree +INSTALL(EXPORT ${PROJECT_NAME}TargetGroup DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}" + FILE ${PROJECT_NAME}Targets.cmake) + +# Install README file +INSTALL(FILES README DESTINATION ${SALOME_CANRECPLUGIN_INSTALL_RES_DATA}) diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..b1e3f5a --- /dev/null +++ b/COPYING @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..c92f465 --- /dev/null +++ b/INSTALL @@ -0,0 +1,111 @@ +************************* +Installation Instructions +************************* + +Copyright (C) 2014-2015 OPEN CASCADE + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See http://www.salome-platform.org or email : webmaster.salome@opencascade.com + +============== +Pre-requisites +============== + +OCCT Canonical recognition (CANREC) plugin for SALOME Geometry module requires: + +- SALOME, at least KERNEL and GEOM modules (http://www.salome-platform.org). +- Open CASCADE Technology and OCCT Canonical recognition (CR) product + (http://www.opencascade.org). +- Other pre-requisite products, according to the SALOME pre-requisites list. + +================== +Basic Installation +================== + +The build procedure of the CANREC plugin for SALOME Geometry module is +created using CMake build system. +In order to build the plugin you have to do the following actions: + +1. Set an environment to point to the OCCT Canonical recognition product, +for example: + + - for csh: + + % setenv CR_ROOT_DIR /path/to/the/CR-6.9.0 + % setenv LD_LIBRARY_PATH ${CR_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + + - for bash: + + % export CR_ROOT_DIR=/path/to/the/CR-6.9.0 + % export LD_LIBRARY_PATH=${CR_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + + Note, that OCCT CR product requires OCCT license library. + Normally OCCT license library is distributed with OCCT CR + product, but it can also be distributed separately. In latter + case you might need to set-up environment to point to the OCCT + license library, as follows: + + - for csh: + + % setenv OCCLICENSE_ROOT_DIR /path/to/the/OCCLicense-6.9.0 + % setenv LD_LIBRARY_PATH ${OCCLICENSE_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + + - for bash: + + % export OCCLICENSE_ROOT_DIR=/path/to/the/OCCLicense-6.9.0 + % export LD_LIBRARY_PATH=${OCCLICENSE_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + +2. Create a build directory (in the example below, it is assumed + that this directory is created at the same level as sources + directory CANRECPLUGIN_SRC), for example: + + % mkdir CANRECPLUGIN_BUILD + +3. Configure the build procedure: + + % cd CANRECPLUGIN_BUILD + % cmake -DCMAKE_BUILD_TYPE= -DCMAKE_INSTALL_PREFIX= ../CANRECPLUGIN_SRC + + where + - is either Release or Debug; + - is a destination folder to install CANREC plugin. + + By default (if CMAKE_INSTALL_PREFIX option is not given), CANREC plugin will be + configured for installation to the /usr directory that requires root + permissions to complete the installation. + +4. Build and install CANREC plugin: + + % make + % make install + + This will install CANREC plugin to the specified + with cmake command on previous step. + +=================== +Custom installation +=================== + +For setting unusual options for compilation or linking run the following +commands o get details on some of the pertinent environment variables: + + % cd CANRECPLUGIN_BUILD + % ccmake ../CANRECPLUGIN_SRC + +You can also use other options of cmake command to customize +your installation. Learn more about available options by running + + % cmake --help diff --git a/README b/README new file mode 100644 index 0000000..898d7be --- /dev/null +++ b/README @@ -0,0 +1,117 @@ +****** +README +****** + +Copyright (C) 2014-2015 OPEN CASCADE + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See http://www.salome-platform.org or email : webmaster.salome@opencascade.com + +============ +Introduction +============ + +This is an implementation of OCCT Canonical recognition (CANREC) interface +to be used as plugin for SALOME Geometry module. It provides functionality +to convert, if possible, a NURBS geometry (B-Spline / Bezier curve or surface) +to its analytical form (primitive curve or surface). +Please visit http://www.opencascade.org/support/products/canrec/ for more details +about OCCT Canonical recognition component. + +============ +Installation +============ + +See the INSTALL file for more information. + +===== +Usage +===== + +1. Set environment (DO NOT FORGET to correct path) + + * Set CANRECPLUGIN_ROOT_DIR variable that should point to the CANREC plugin + installation directory. It is required for SALOME Geometry module to + automatically detect a plugin (see APPENDIX below). For example: + + - for csh: + + % setenv CANRECPLUGIN_ROOT_DIR /path/to/the/CANRECPLUGIN + + - for bash: + + % export CANRECPLUGIN_ROOT_DIR=/path/to/the/CANRECPLUGIN + + * Set LD_LIBRARY_PATH variable to point to the OCCT Canonical + recognition product libraries, for example: + + - for csh: + + % setenv CR_ROOT_DIR /path/to/the/CR-6.9.0 + % setenv LD_LIBRARY_PATH ${CR_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + + - for bash: + + % export CR_ROOT_DIR=/path/to/the/CR-6.9.0 + % export LD_LIBRARY_PATH=${CR_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + + * OCCT Canonical recognition product requires also an OCCT license + library. Normally OCCT license library is distributed with OCCT CR + product, but it can also be distributed separately. In latter + case you might need to set-up environment to point to the OCCT + license library, as follows: + + - for csh: + + % setenv OCCLICENSE_ROOT_DIR /path/to/the/OCCLicense-6.9.0 + % setenv LD_LIBRARY_PATH ${OCCLICENSE_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + + - for bash: + + % export OCCLICENSE_ROOT_DIR=/path/to/the/OCCLicense-6.9.0 + % export LD_LIBRARY_PATH=${OCCLICENSE_ROOT_DIR}/lib:${LD_LIBRARY_PATH} + +2. Usage in SALOME + + * Run SALOME and activate Geometry module. + + * Invoke Canonical Recognition operation + + Menu New Entity - Advanced - Canonical Recognition + + In the "Canonical Recognition Construction" dialog box specify input shape, + tolerance value and, optionally, switch on/off "Merge surfaces" and "Merge curves" + check boxes. Press "Apply" or "Apply and Close' button to start canonical recognition + operation. + The result of the operation will be published in the study. + +=============== +Troubleshooting +=============== + +Please, send a mail to webmaster.salome@opencascade.com + +======== +APPENDIX +======== + +Since SALOME version 7.4.0, Geometry module implements a mechanism to +automatically detect plugins. To set-up the plug-in to SALOME Geometry +module, it is just necessary to set CANRECPLUGIN_ROOT_DIR environment +variable to point to the installation directory of CANREC plugin as described +in paragraph "Usage" above. + +SALOME CANREC plugin supports SALOME 7.6.0 and newer. diff --git a/SalomeCANRECPLUGINConfig.cmake.in b/SalomeCANRECPLUGINConfig.cmake.in new file mode 100644 index 0000000..d484ad7 --- /dev/null +++ b/SalomeCANRECPLUGINConfig.cmake.in @@ -0,0 +1,113 @@ +# Config file for the @PROJECT_NAME@ package +# It defines the following variables: +# Specific to the pacakge @PROJECT_NAME@ itself: +# @PROJECT_NAME_UC@_ROOT_DIR_EXP - the root path of the installation providing this CMake file +# + +############################################################### +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +### Initialisation performed by CONFIGURE_PACKAGE_CONFIG_FILE: +@PACKAGE_INIT@ + +# Load the dependencies for the libraries of @PROJECT_NAME@ +# (contains definitions for IMPORTED targets). This is only +# imported if we are not built as a subproject (in this case targets are already there) +IF(NOT TARGET CANRECPluginEngine AND NOT @PROJECT_NAME@_BINARY_DIR) + INCLUDE("@PACKAGE_SALOME_INSTALL_CMAKE_LOCAL@/@PROJECT_NAME@Targets.cmake") +ENDIF() + +# Package root dir: +SET_AND_CHECK(CANRECPLUGIN_ROOT_DIR_EXP "@PACKAGE_CMAKE_INSTALL_PREFIX@") + +# Include directories +SET_AND_CHECK(CANRECPLUGIN_INCLUDE_DIRS "${CANRECPLUGIN_ROOT_DIR_EXP}/@SALOME_INSTALL_HEADERS@") +SET(CANRECPLUGIN_INCLUDE_DIRS "${CANRECPLUGIN_INCLUDE_DIRS};@_SalomeCANRECPLUGIN_EXTRA_HEADERS@") + +# Package specific environment variables +@_SalomeCANRECPLUGIN_EXTRA_ENV_FULL@ + +#### Now the specificities + +# Options exported by the package: +SET(SALOME_CANRECPLUGIN_BUILD_DOC @SALOME_BUILD_DOC@) +SET(SALOME_CANRECPLUGIN_BUILD_TESTS @SALOME_BUILD_TESTS@) +SET(SALOME_CANRECPLUGIN_BUILD_GUI @SALOME_BUILD_GUI@) + +# Level 1 prerequisites: +SET_AND_CHECK(KERNEL_ROOT_DIR_EXP "@PACKAGE_KERNEL_ROOT_DIR@") +SET_AND_CHECK(GUI_ROOT_DIR_EXP "@PACKAGE_GUI_ROOT_DIR@") +SET_AND_CHECK(GEOM_ROOT_DIR_EXP "@PACKAGE_GEOM_ROOT_DIR@") +SET_AND_CHECK(CR_ROOT_DIR_EXP "@PACKAGE_CR_ROOT_DIR@") +SET_AND_CHECK(OCCLICENSE_ROOT_DIR_EXP "@PACKAGE_OCCLICENSE_ROOT_DIR@") + +# For all prerequisites, load the corresponding targets if the package was used +# in CONFIG mode. This ensures dependent projects link correctly +# without having to set LD_LIBRARY_PATH: +SET(_PREREQ @_PREREQ_LIST@) +SET(_PREREQ_CONFIG_DIR @_PREREQ_DIR_LIST@) +SET(_PREREQ_COMPONENTS "@_PREREQ_COMPO_LIST@") +LIST(LENGTH _PREREQ_CONFIG_DIR _list_len) +IF(NOT _list_len EQUAL 0) + # Another CMake stupidity - FOREACH(... RANGE r) generates r+1 numbers ... + MATH(EXPR _range "${_list_len}-1") + FOREACH(_p RANGE ${_range}) + LIST(GET _PREREQ ${_p} _pkg ) + LIST(GET _PREREQ_CONFIG_DIR ${_p} _pkg_dir) + LIST(GET _PREREQ_COMPONENTS ${_p} _pkg_compo) + MESSAGE(STATUS "===> Reloading targets from ${_pkg} ...") + IF(NOT _pkg_compo) + FIND_PACKAGE(${_pkg} REQUIRED NO_MODULE + PATHS "${_pkg_dir}" + NO_DEFAULT_PATH) + ELSE() + STRING(REPLACE "," ";" _compo_lst "${_pkg_compo}") + MESSAGE(STATUS "===> (components: ${_pkg_compo})") + FIND_PACKAGE(${_pkg} REQUIRED NO_MODULE + COMPONENTS ${_compo_lst} + PATHS "${_pkg_dir}" + NO_DEFAULT_PATH) + ENDIF() + ENDFOREACH() +ENDIF() + +# Installation directories +SET(SALOME_INSTALL_BINS "@SALOME_INSTALL_BINS@") +SET(SALOME_INSTALL_LIBS "@SALOME_INSTALL_LIBS@") +SET(SALOME_INSTALL_IDLS "@SALOME_INSTALL_IDLS@") +SET(SALOME_INSTALL_HEADERS "@SALOME_INSTALL_HEADERS@") +SET(SALOME_INSTALL_SCRIPT_SCRIPTS "@SALOME_INSTALL_SCRIPT_SCRIPTS@") +SET(SALOME_INSTALL_SCRIPT_DATA "@SALOME_INSTALL_SCRIPT_DATA@") +SET(SALOME_INSTALL_SCRIPT_PYTHON "@SALOME_INSTALL_SCRIPT_PYTHON@") +SET(SALOME_INSTALL_PYTHON "@SALOME_INSTALL_PYTHON@") +SET(SALOME_INSTALL_PYTHON_SHARED "@SALOME_INSTALL_PYTHON_SHARED@") +SET(SALOME_INSTALL_CMAKE_LOCAL "@SALOME_INSTALL_CMAKE_LOCAL@") +SET(SALOME_INSTALL_RES "@SALOME_INSTALL_RES@") +SET(SALOME_INSTALL_DOC "@SALOME_INSTALL_DOC@") + +# Include GEOM targets if they were not already loaded: +IF(NOT (TARGET GEOMEngine)) + INCLUDE("${GEOM_ROOT_DIR_EXP}/${SALOME_INSTALL_CMAKE}/SalomeGEOMTargets.cmake") +ENDIF() + +# Exposed CANRECPLUGIN targets: +SET(CANRECPLUGIN_SalomeIDlCANRECPlugin SalomeIDLCANRECPlugin) +SET(CANRECPLUGIN_CANRECPluginEngine CANRECPluginEngine) +SET(CANRECPLUGIN_CANRECPluginGUI CANRECPluginGUI) diff --git a/adm_local/CMakeLists.txt b/adm_local/CMakeLists.txt new file mode 100644 index 0000000..aa826d5 --- /dev/null +++ b/adm_local/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +ADD_SUBDIRECTORY(cmake_files) diff --git a/adm_local/cmake_files/CMakeLists.txt b/adm_local/cmake_files/CMakeLists.txt new file mode 100644 index 0000000..69122b0 --- /dev/null +++ b/adm_local/cmake_files/CMakeLists.txt @@ -0,0 +1,31 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +# =============================================================== +# Files to be installed +# =============================================================== + +# These files are data, module or lib files +SET(_adm_data + FindCR.cmake + FindSalomeCR.cmake + FindSalomeCANRECPLUGIN.cmake +) + +INSTALL(FILES ${_adm_data} DESTINATION ${SALOME_INSTALL_CMAKE_LOCAL}) diff --git a/adm_local/cmake_files/FindCR.cmake b/adm_local/cmake_files/FindCR.cmake new file mode 100644 index 0000000..3f7544b --- /dev/null +++ b/adm_local/cmake_files/FindCR.cmake @@ -0,0 +1,58 @@ +# - Find OCCT Canonical recognition (CR) product +# Sets the following variables: +# CR_INCLUDE_DIRS - path to the OCCT CR include directory +# CR_LIBRARIES - path to the OCCT CR libraries to be linked against +# + +######################################################################### +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +# ------ + +MESSAGE(STATUS "Check for OCCT Canonical recognition product ...") + +# ------ + +SET(CR_ROOT_DIR $ENV{CR_ROOT_DIR}) +SET(OCCLICENSE_ROOT_DIR $ENV{OCCLICENSE_ROOT_DIR}) + +IF(CR_ROOT_DIR) + LIST(APPEND CMAKE_PREFIX_PATH "${CR_ROOT_DIR}") +ENDIF(CR_ROOT_DIR) +IF(OCCLICENSE_ROOT_DIR) + LIST(APPEND CMAKE_PREFIX_PATH "${OCCLICENSE_ROOT_DIR}") +ENDIF(OCCLICENSE_ROOT_DIR) + +FIND_PATH(CR_INCLUDE_DIRS ShapeConvert.hxx PATH_SUFFIXES inc) +FIND_PATH(OCCTLICENSE_INCLUDE_DIRS OCCLicense_Activate.hxx PATH_SUFFIXES inc) +IF(OCCTLICENSE_INCLUDE_DIRS) + LIST(APPEND CR_INCLUDE_DIRS ${OCCTLICENSE_INCLUDE_DIRS}) +ENDIF(OCCTLICENSE_INCLUDE_DIRS) + +FIND_LIBRARY(CR_TKCR NAMES TKCR) +FIND_LIBRARY(CRKOCCLicense NAMES TKOCCLicense) + +SET(CR_LIBRARIES + ${CR_TKCR} + ${CR_TKOCCLicense} +) + +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(CR REQUIRED_VARS CR_INCLUDE_DIRS CR_LIBRARIES) diff --git a/adm_local/cmake_files/FindSalomeCANRECPLUGIN.cmake b/adm_local/cmake_files/FindSalomeCANRECPLUGIN.cmake new file mode 100644 index 0000000..b6c3593 --- /dev/null +++ b/adm_local/cmake_files/FindSalomeCANRECPLUGIN.cmake @@ -0,0 +1,34 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +IF(NOT SalomeCANRECPLUGIN_FIND_QUIETLY) + MESSAGE(STATUS "Looking for Salome CANRECPLUGIN ...") +ENDIF() + +SET(CMAKE_PREFIX_PATH "${CANRECPLUGIN_ROOT_DIR}") + +SALOME_FIND_PACKAGE(SalomeCANRECPLUGIN SalomeCANRECPLUGIN CONFIG) + +IF(NOT SalomeCANRECPLUGIN_FIND_QUIETLY) + MESSAGE(STATUS "Found Salome CANRECPLUGIN: ${CANRECPLUGIN_ROOT_DIR}") +ENDIF() + +FOREACH(_res ${SalomeCANRECPLUGIN_EXTRA_ENV}) + SALOME_ACCUMULATE_ENVIRONMENT(${_res} "${SalomeCANRECPLUGIN_EXTRA_ENV_${_res}}") +ENDFOREACH() diff --git a/adm_local/cmake_files/FindSalomeCR.cmake b/adm_local/cmake_files/FindSalomeCR.cmake new file mode 100644 index 0000000..4be5750 --- /dev/null +++ b/adm_local/cmake_files/FindSalomeCR.cmake @@ -0,0 +1,26 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(CR CR_INCLUDE_DIRS 1) +MARK_AS_ADVANCED(CR_INCLUDE_DIRS CR_LIBRARIES) + +IF(CR_FOUND) + SALOME_ACCUMULATE_HEADERS(CR_INCLUDE_DIRS) + SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH ${CR_LIBRARIES}) +ENDIF() diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 0000000..0fd283b --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +ADD_SUBDIRECTORY(salome) diff --git a/doc/salome/CMakeLists.txt b/doc/salome/CMakeLists.txt new file mode 100644 index 0000000..9965b85 --- /dev/null +++ b/doc/salome/CMakeLists.txt @@ -0,0 +1,21 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +ADD_SUBDIRECTORY(examples) +ADD_SUBDIRECTORY(gui) diff --git a/doc/salome/examples/CMakeLists.txt b/doc/salome/examples/CMakeLists.txt new file mode 100644 index 0000000..4615f07 --- /dev/null +++ b/doc/salome/examples/CMakeLists.txt @@ -0,0 +1,21 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +FILE(GLOB files "${CMAKE_CURRENT_SOURCE_DIR}/*.py") +INSTALL(FILES ${files} DESTINATION ${SALOME_INSTALL_DOC}/examples/CANRECPLUGIN) diff --git a/doc/salome/examples/canrecplugindemo.py b/doc/salome/examples/canrecplugindemo.py new file mode 100644 index 0000000..c88ff1e --- /dev/null +++ b/doc/salome/examples/canrecplugindemo.py @@ -0,0 +1,26 @@ +# Canonical Recognition +import os +import salome +salome.salome_init() +from salome.geom import geomBuilder +import GEOM +geompy = geomBuilder.New( salome.myStudy ) + +# Import Shape +path = os.path.join(os.getenv("DATA_DIR"), "Shapes/Iges/geom.igs") +shape_igs = geompy.ImportIGES(path) + +# Build Canonical Recognition +shape_cr = geompy.MakeCanonicalRecognition(shape_igs, True, True, 0.01) + +# Publish in the study +geompy.addToStudy( shape_igs, 'Import from IGS' ) +geompy.addToStudy( shape_cr, 'Canonical Recognition' ) + +# Print what is information +print "=========================================================" +print "Information about original shape:" +print geompy.WhatIs(shape_igs) +print "=========================================================" +print "Information about converted shape:" +print geompy.WhatIs(shape_cr) diff --git a/doc/salome/gui/CANRECPLUGIN/CMakeLists.txt b/doc/salome/gui/CANRECPLUGIN/CMakeLists.txt new file mode 100644 index 0000000..3174136 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/CMakeLists.txt @@ -0,0 +1,52 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +SALOME_CONFIGURE_FILE(doxyfile.in doxyfile) +SALOME_CONFIGURE_FILE(doxyfile_py.in doxyfile_py) +SALOME_CONFIGURE_FILE(static/header.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header.html) +SALOME_CONFIGURE_FILE(static/header_py.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header_py.html) + +# Generate a temporary python file, needed for the generation of the documentation +# of the plugin. +SALOME_ACCUMULATE_ENVIRONMENT(GEOM_PluginsList NOCHECK CANRECPlugin) +SET(_plugins_cmd_options ${GEOM_ROOT_DIR}/bin/salome/collect_geom_methods.py -d -o tmp/geomBuilder.py CANRECPlugin) +SALOME_GENERATE_ENVIRONMENT_SCRIPT(_plugins_cmd env_script "${PYTHON_EXECUTABLE}" "${_plugins_cmd_options}") + +SET(kernel_file "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py") +IF(WIN32) + STRING(REPLACE "/" "\\" kernel_file ${kernel_file}) +ENDIF(WIN32) + +ADD_CUSTOM_TARGET(usr_docs ${CMAKE_COMMAND} -E make_directory tmp + COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp/CANRECPluginBuilder.py ${CMAKE_SOURCE_DIR}/src/CANRECPLUGIN_PY/CANRECPluginBuilder.py + COMMAND ${_plugins_cmd} + COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py + COMMAND ${DOXYGEN_EXECUTABLE} doxyfile + COMMAND ${CMAKE_COMMAND} -E remove_directory tmp + VERBATIM + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} +) + +INSTALL(CODE "EXECUTE_PROCESS(COMMAND \"${CMAKE_COMMAND}\" --build ${PROJECT_BINARY_DIR} --target usr_docs)") +INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CANRECPLUGIN DESTINATION ${SALOME_INSTALL_DOC}/gui) +INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/CANRECPLUGIN) +INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/CANRECPLUGIN/canrecpluginpy_doc) + +SET(make_clean_files CANRECPLUGIN canrecpluginpy_doc.tag) +SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${make_clean_files}") diff --git a/doc/salome/gui/CANRECPLUGIN/doxyfile.in b/doc/salome/gui/CANRECPLUGIN/doxyfile.in new file mode 100644 index 0000000..b9b1884 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/doxyfile.in @@ -0,0 +1,114 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- +PROJECT_NAME = "SALOME CANRECPLUGIN User's Guide" +OUTPUT_DIRECTORY = CANRECPLUGIN +CREATE_SUBDIRS = NO +OUTPUT_LANGUAGE = English +TAB_SIZE = 5 + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- +QUIET = NO +WARNINGS = YES + +#--------------------------------------------------------------------------- +#Input related options +#--------------------------------------------------------------------------- +INPUT = @CMAKE_CURRENT_SOURCE_DIR@/input +FILE_PATTERNS = *.doc +EXCLUDE = +IMAGE_PATH = @CMAKE_CURRENT_SOURCE_DIR@/images +EXAMPLE_PATH = @CMAKE_SOURCE_DIR@/doc/salome/examples + +#--------------------------------------------------------------------------- +#HTML related options +#--------------------------------------------------------------------------- +GENERATE_HTML = YES +HTML_OUTPUT = . +HTML_HEADER = @CMAKE_CURRENT_BINARY_DIR@/static/header.html +HTML_FOOTER = @CMAKE_CURRENT_SOURCE_DIR@/static/footer.html +HTML_EXTRA_STYLESHEET = @CMAKE_CURRENT_SOURCE_DIR@/static/salome_extra.css +TOC_EXPAND = YES +DISABLE_INDEX = NO +GENERATE_TREEVIEW = YES +TREEVIEW_WIDTH = 300 + + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool... +#--------------------------------------------------------------------------- +CLASS_DIAGRAMS = NO +HIDE_UNDOC_RELATIONS = NO +HAVE_DOT = NO +CLASS_GRAPH = NO +COLLABORATION_GRAPH = NO +GROUP_GRAPHS = NO +UML_LOOK = NO +TEMPLATE_RELATIONS = NO +INCLUDE_GRAPH = NO +INCLUDED_BY_GRAPH = NO +CALL_GRAPH = NO +GRAPHICAL_HIERARCHY = NO +DIRECTORY_GRAPH = NO +DOT_IMAGE_FORMAT = jpg +DOT_FONTNAME = Arial +DOT_PATH =. +DOTFILE_DIRS =. +MAX_DOT_GRAPH_WIDTH = 1024 +MAX_DOT_GRAPH_HEIGHT = 1200 +MAX_DOT_GRAPH_DEPTH = 0 +DOT_TRANSPARENT = NO +DOT_MULTI_TARGETS = NO + + +GENERATE_LEGEND = NO +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +#SORT related options +#--------------------------------------------------------------------------- +SORT_GROUP_NAMES = NO + +#--------------------------------------------------------------------------- +#LaTeX related option +#--------------------------------------------------------------------------- +GENERATE_LATEX = NO +EXTRA_PACKAGES = amsmath + +#--------------------------------------------------------------------------- +#RTF related options +#--------------------------------------------------------------------------- +GENERATE_RTF = NO + +#--------------------------------------------------------------------------- +#External reference options +#--------------------------------------------------------------------------- + +TAGFILES = canrecpluginpy_doc.tag=../CANRECPLUGIN/canrecpluginpy_doc +SEARCHENGINE = YES + +#--------------------------------------------------------------------------- +#Custom commands +#--------------------------------------------------------------------------- +ALIASES += tui_script{1}="\include \1 Download this script" diff --git a/doc/salome/gui/CANRECPLUGIN/doxyfile_py.in b/doc/salome/gui/CANRECPLUGIN/doxyfile_py.in new file mode 100644 index 0000000..4d83e28 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/doxyfile_py.in @@ -0,0 +1,160 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- +PROJECT_NAME = "SALOME CANRECPLUGIN User's Guide" +OUTPUT_DIRECTORY = CANRECPLUGIN +CREATE_SUBDIRS = NO +OUTPUT_LANGUAGE = English +USE_WINDOWS_ENCODING = NO +BRIEF_MEMBER_DESC = YES +REPEAT_BRIEF = YES +ALWAYS_DETAILED_SEC = YES +INLINE_INHERITED_MEMB = YES +FULL_PATH_NAMES = NO +SHORT_NAMES = NO +JAVADOC_AUTOBRIEF = YES +MULTILINE_CPP_IS_BRIEF = NO +DETAILS_AT_TOP = NO +INHERIT_DOCS = YES +SEPARATE_MEMBER_PAGES = NO +TAB_SIZE = 5 +OPTIMIZE_OUTPUT_FOR_C = YES +OPTIMIZE_OUTPUT_JAVA = YES +BUILTIN_STL_SUPPORT = NO +DISTRIBUTE_GROUP_DOC = NO +SUBGROUPING = YES + +#--------------------------------------------------------------------------- +# Build related options +#--------------------------------------------------------------------------- +EXTRACT_ALL = YES +EXTRACT_PRIVATE = YES +EXTRACT_STATIC = NO +EXTRACT_LOCAL_CLASSES = YES +EXTRACT_LOCAL_METHODS = NO +HIDE_UNDOC_MEMBERS = NO +HIDE_UNDOC_CLASSES = NO +HIDE_FRIEND_COMPOUNDS = NO +HIDE_IN_BODY_DOCS = NO +INTERNAL_DOCS = YES +CASE_SENSE_NAMES = YES +HIDE_SCOPE_NAMES = YES +SHOW_INCLUDE_FILES = YES +INLINE_INFO = YES +SORT_MEMBER_DOCS = NO +SORT_BRIEF_DOCS = NO +SORT_BY_SCOPE_NAME = NO +GENERATE_TODOLIST = YES +GENERATE_TESTLIST = YES +GENERATE_BUGLIST = YES +GENERATE_DEPRECATEDLIST= YES +MAX_INITIALIZER_LINES = 25 +SHOW_USED_FILES = NO +SHOW_DIRECTORIES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- +SOURCE_BROWSER = NO +INLINE_SOURCES = NO +STRIP_CODE_COMMENTS = YES +REFERENCED_BY_RELATION = NO +REFERENCES_RELATION = YES +USE_HTAGS = NO +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- +QUIET = NO +WARNINGS = YES +WARN_IF_UNDOCUMENTED = YES +WARN_IF_DOC_ERROR = YES +WARN_NO_PARAMDOC = NO +EXCLUDE_SYMLINKS = NO +EXAMPLE_RECURSIVE = NO + +#--------------------------------------------------------------------------- +#Input related options +#--------------------------------------------------------------------------- +INPUT = tmp @CMAKE_SOURCE_DIR@/idl/CANRECPlugin.idl +FILE_PATTERNS = +IMAGE_PATH = @CMAKE_CURRENT_SOURCE_DIR@/images +RECURSIVE = NO +EXAMPLE_PATH = @CMAKE_SOURCE_DIR@/src/CANRECPLUGIN_PY + +#--------------------------------------------------------------------------- +#HTML related options +#--------------------------------------------------------------------------- +GENERATE_HTML = YES +HTML_OUTPUT = canrecpluginpy_doc +HTML_HEADER = @CMAKE_CURRENT_BINARY_DIR@/static/header_py.html +HTML_FOOTER = @CMAKE_CURRENT_SOURCE_DIR@/static/footer.html +HTML_EXTRA_STYLESHEET = @CMAKE_CURRENT_SOURCE_DIR@/static/salome_extra.css +TOC_EXPAND = YES +DISABLE_INDEX = NO +GENERATE_TREEVIEW = YES +TREEVIEW_WIDTH = 300 + +#--------------------------------------------------------------------------- +#LaTeX related option +#--------------------------------------------------------------------------- +GENERATE_LATEX = NO + +#--------------------------------------------------------------------------- +#RTF related options +#--------------------------------------------------------------------------- +GENERATE_RTF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- +CLASS_DIAGRAMS = NO +HIDE_UNDOC_RELATIONS = NO +HAVE_DOT = YES +CLASS_GRAPH = YES +COLLABORATION_GRAPH = NO +GROUP_GRAPHS = NO +UML_LOOK = NO +TEMPLATE_RELATIONS = YES +INCLUDE_GRAPH = YES +INCLUDED_BY_GRAPH = YES +CALL_GRAPH = NO +GRAPHICAL_HIERARCHY = YES +DIRECTORY_GRAPH = YES +DOT_IMAGE_FORMAT = png +DOT_FONTNAME = Arial +DOT_PATH = +DOTFILE_DIRS = +MAX_DOT_GRAPH_WIDTH = 1024 +MAX_DOT_GRAPH_HEIGHT = 1024 +MAX_DOT_GRAPH_DEPTH = 1000 +DOT_TRANSPARENT = NO +DOT_MULTI_TARGETS = NO +GENERATE_LEGEND = NO +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +#External reference options +#--------------------------------------------------------------------------- +GENERATE_TAGFILE = canrecpluginpy_doc.tag +SEARCHENGINE = YES diff --git a/doc/salome/gui/CANRECPLUGIN/images/canrec_plugin_dlg.png b/doc/salome/gui/CANRECPLUGIN/images/canrec_plugin_dlg.png new file mode 100644 index 0000000000000000000000000000000000000000..1c724a937f2de304e5876f157f8c08416a5d6394 GIT binary patch literal 11273 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 D4zrO! literal 0 HcmV?d00001 diff --git a/doc/salome/gui/CANRECPLUGIN/input/canrecplugin_python_interface.doc b/doc/salome/gui/CANRECPLUGIN/input/canrecplugin_python_interface.doc new file mode 100644 index 0000000..a575278 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/input/canrecplugin_python_interface.doc @@ -0,0 +1,17 @@ +/*! + +\page canrecplugin_python_interface_page Python Interface + +Python package CANRECPluginBuilder provides a function that performs +canonical recognition of the B-Spline / Bezier curve or surface. + +CANRECPLUGIN plugin dynamically adds this method to the geomBuilder class. + +Below you can see an example of usage of the CANRECPluginBuilder package for performing +of the canonical recognition: + +\anchor canrec_example +

Example of the canonical recognition operation:

+\tui_script{canrecplugindemo.py} + +*/ diff --git a/doc/salome/gui/CANRECPLUGIN/input/canrecplugin_usage_page.doc b/doc/salome/gui/CANRECPLUGIN/input/canrecplugin_usage_page.doc new file mode 100644 index 0000000..c654a5a --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/input/canrecplugin_usage_page.doc @@ -0,0 +1,26 @@ +/*! + +\page canrecplugin_usage_page Constructing of the Canonical Recognition + +To create a Canonical Recognition in the Main Menu select New Entity - > Advanced - > Canonical Recognition + +This Operation constructs a canonical recognition (convert, if possible, a NURBS geometry B-Spline / Bezier curve or surface +to its analytical form) of an \b Object. To constructs the canonical recognition you need to define the shape. +\n Merge Surfaces checkbox allows to merge surfaces in the result shape. +\n Merge Curves checkbox allows to merge curvies in the result shape. +\n The \b Result of the operation will be any \b GEOM_Object. + +\n TUI Command: geompy.MakeCanonicalRecognition(Shape, MergeSurf, MergeCurves), + where Shape is a shape to be converted into canonical recognition, +MergeSurf and MergeCurv flags to merge surfaces / curves in the result shape. + + +\n Arguments: Name + one object. + +\image html canrec_plugin_dlg.png + +\n \b Example: + +Our TUI Script provide you with useful example of the use of \ref canrec_example "Canonical Recognition". + +*/ diff --git a/doc/salome/gui/CANRECPLUGIN/input/index.doc b/doc/salome/gui/CANRECPLUGIN/input/index.doc new file mode 100644 index 0000000..5e1904a --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/input/index.doc @@ -0,0 +1,15 @@ +/*! + +\mainpage Introduction to CANRECPLUGIN + +\b CANRECPLUGIN plugin provides an integration of OCCT Canonical Recognition product to the SALOME Geometry module. + +It allows to convert, if possible, a NURBS geometry (B-Spline / Bezier curve or surface) to its analytical form +(primitive curve or surface). + +To use functionality of the CANRECPLUGIN refer to \subpage canrecplugin_usage_page. + +Also functionality of the CANRECPLUGIN is accessible via +\subpage canrecplugin_python_interface_page "CANRECPLUGIN Python interface". + +*/ diff --git a/doc/salome/gui/CANRECPLUGIN/static/footer.html b/doc/salome/gui/CANRECPLUGIN/static/footer.html new file mode 100644 index 0000000..a9dd3c1 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/static/footer.html @@ -0,0 +1,13 @@ + + + + + + diff --git a/doc/salome/gui/CANRECPLUGIN/static/header.html.in b/doc/salome/gui/CANRECPLUGIN/static/header.html.in new file mode 100644 index 0000000..1ef8119 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/static/header.html.in @@ -0,0 +1,23 @@ + + + + + + + +$projectname: $title +$title + + + +$treeview +$search +$mathjax + +$extrastylesheet + + +
+ +
Version: @SALOMECANRECPLUGIN_VERSION@
+ diff --git a/doc/salome/gui/CANRECPLUGIN/static/header_py.html.in b/doc/salome/gui/CANRECPLUGIN/static/header_py.html.in new file mode 100644 index 0000000..c57fec5 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/static/header_py.html.in @@ -0,0 +1,24 @@ + + + + + + + +$projectname: $title +$title + + + +$treeview +$search +$mathjax + +$extrastylesheet + + +
+ +
Version: @SALOMECANRECPLUGIN_VERSION@
+ + diff --git a/doc/salome/gui/CANRECPLUGIN/static/salome_extra.css b/doc/salome/gui/CANRECPLUGIN/static/salome_extra.css new file mode 100644 index 0000000..3e8b838 --- /dev/null +++ b/doc/salome/gui/CANRECPLUGIN/static/salome_extra.css @@ -0,0 +1,29 @@ +/* The extra CSS for doxygen 1.8.3.1 */ + +#titlearea { + background-image:url('head.png'); + background-color: #175783; + border: 1px solid; + height: 80px; + background-repeat: no-repeat; + padding: 0px; + margin: 0px; + width: 99.9%; + border-bottom: 1px solid #5373B4; +} + +div.version { + border:1px solid #0000FF; + color: #CCCCCC; + font-family: Arial, Helvetica, sans-serif; + font-size: 9pt; + text-align: center; + width:100px; + -moz-border-radius: 8px; + margin: 5px; +} + +.navpath li.footer { + line-height:15px; + text-align: right; +} \ No newline at end of file diff --git a/doc/salome/gui/CMakeLists.txt b/doc/salome/gui/CMakeLists.txt new file mode 100644 index 0000000..3c315a2 --- /dev/null +++ b/doc/salome/gui/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +ADD_SUBDIRECTORY(CANRECPLUGIN) diff --git a/idl/CANRECPlugin.idl b/idl/CANRECPlugin.idl new file mode 100644 index 0000000..9bdad0a --- /dev/null +++ b/idl/CANRECPlugin.idl @@ -0,0 +1,49 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#ifndef __CANRECPlugin_IDL__ +#define __CANRECPlugin_IDL__ + +#include "GEOM_Gen.idl" + +module CANRECPlugin +{ + /*! + * \brief Interface to Canonical Recognition modeling functions. + */ + interface ICanRecOperations : GEOM::GEOM_IOperations + { + /*! + * \brief Perform, if possible, conversion of NURBS (B-Spline, Bezier) geometry to canonical (analytical) form. + * + * \param theObject the input object (solid, compound, compsolid). + * \param theMergeSurf the flag to switch on/off merging surfaces in the result shape. + * \param theMergeCurves the flag to switch on/off merging curves in the result shape. + * \param theTolerance the tolerance of the canonical recognition operation. + * + * \return New GEOM_Object, containing the canonical recognition of the input object. + */ + GEOM::GEOM_Object MakeCanonicalRecognition ( in GEOM::GEOM_Object theObject, + in boolean theMergeSurf, + in boolean theMergeCurves, + in double theTolerance ); + }; +}; + +#endif // __CANRECPlugin_IDL__ diff --git a/idl/CMakeLists.txt b/idl/CMakeLists.txt new file mode 100644 index 0000000..2da6653 --- /dev/null +++ b/idl/CMakeLists.txt @@ -0,0 +1,48 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +INCLUDE(UseOmniORB) + +INCLUDE_DIRECTORIES( + ${KERNEL_INCLUDE_DIRS} + ${GEOM_INCLUDE_DIRS} + ${OMNIORB_INCLUDE_DIR} + ${CMAKE_CURRENT_BINARY_DIR} +) + +IF(WIN32) + ADD_DEFINITIONS(-DNOGDI) +ENDIF(WIN32) + +SET(SalomeIDLCANRECPlugin_IDLSOURCES + CANRECPlugin.idl +) + +SET(_idl_include_dirs + ${KERNEL_ROOT_DIR}/idl/salome + ${GEOM_ROOT_DIR}/idl/salome +) + +SET(_idl_link_flags + ${KERNEL_SalomeIDLKernel} + ${GEOM_SalomeIDLGEOM} +) + +OMNIORB_ADD_MODULE(SalomeIDLCANRECPlugin "${SalomeIDLCANRECPlugin_IDLSOURCES}" "${_idl_include_dirs}" "${_idl_link_flags}") +INSTALL(TARGETS SalomeIDLCANRECPlugin EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS}) diff --git a/resources/CANRECPlugin.xml b/resources/CANRECPlugin.xml new file mode 100644 index 0000000..e3d34a7 --- /dev/null +++ b/resources/CANRECPlugin.xml @@ -0,0 +1,41 @@ + + + + + + + + + + + + + + + + diff --git a/resources/CMakeLists.txt b/resources/CMakeLists.txt new file mode 100644 index 0000000..a5f6201 --- /dev/null +++ b/resources/CMakeLists.txt @@ -0,0 +1,33 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +SET(_resource_files + CANRECPlugin.xml + SalomeApp.xml +) + +IF(SALOME_BUILD_GUI) + LIST(APPEND _resource_files + canonicalrecognition.png + tree_canonicalrecognition.png + select1.png + ) +ENDIF(SALOME_BUILD_GUI) + +INSTALL(FILES ${_resource_files} DESTINATION ${SALOME_CANRECPLUGIN_INSTALL_RES_DATA}) diff --git a/resources/SalomeApp.xml b/resources/SalomeApp.xml new file mode 100644 index 0000000..6999fdd --- /dev/null +++ b/resources/SalomeApp.xml @@ -0,0 +1,32 @@ + + +
+ +
+
+ + +
+
+ +
+ diff --git a/resources/canonicalrecognition.png b/resources/canonicalrecognition.png new file mode 100644 index 0000000000000000000000000000000000000000..0d70bba3f39a906ffa67a15e4dcfd13f21630085 GIT binary patch literal 767 zcmVPx#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FZT01FZU(%pXi00007bV*G`2i^r5 z4Gt8aC56-g00MtWL_t(I%e9lcYot{e#(yXC8Cis+o7O@CmWynoxR3}o+N2aMWY|o- zTiV)Lh`3-SB9`$#Q1G&{h0U^H69lIW>@?$xI3y!(=^m|&3rzmswz%SP6BJn073{H9UTGqYwz46WVcA_s2XaH zTK}n<(?+FXV?oL%z#266~%nX1SBV}1q*Y$$yckdtb z_~8ctUuFP#o-gA9q?DLWrxZm&p6BfD?vm&Ebte7p{bQu7R$V?gIPi7YqJIAYyHp#YG_{NCFe}TFs!Oy{iAiaj8ZBPn3!oeBhH1JM*yMk&*Kj8* zih{BcB(^m9a|YSV7jqGMcR;_$x?u+clV86D_zifH&F6DcTT;Jx#vpr%ROe`F`|kC{ z!&Ejp{Ojkh0UiMf_&#%Ys_7|PTN$y+(bS-+>tnd%ZarLO(@H-AYTzmGXV^Gko3*|v xzXLPi58xYMk^#4YF>nVM+z?)0z&_#s(m(23^re9B+kOB5002ovPDHLkV1g&nSbP8g literal 0 HcmV?d00001 diff --git a/resources/select1.png b/resources/select1.png new file mode 100644 index 0000000000000000000000000000000000000000..ecb252ab77e4d4b1c8b37de449155e4e77806fd8 GIT binary patch literal 1143 zcmV--1c>{IP)z@;j(q!3lK=n!AY({UO#lFTB>(_`g8%^e{{R4h=>PzA zFaQARU;qF*m;eA5Z<1fdMgRZ*Y z+1|@J&vTys*x8s(A9y&=ABPX$@Ar2R#uxzVK5M}eVA}#m3ZfBZ@`~am4@2{B2*kg@6q&*BNEwM?&B@+_EcgOBFPbq)fl4T!YS@w}t zFVDWmkpfEygkanm1x6e}ti+})Zj&gJl$S{orION^4KN{5Ud{{4>Hywey>xcXnpdU^ zrOY^>9C?&PZQ`Xi@t94l#NwI9rp^VH0yU-aL{&Q7&jSk=qk`z-UEi)-47^pla@I!R z8mbt{@XMVYl*J`Wp1gAbuzXHs^@|Tb`aE;0?qkxevlz^2GOi+>_33PD%CS{TeJaziQldy^CkLzy55TqhE(>~8;uAP9aj#$*8>=mlDV z%OSJ~1Y?1RF1MZ}lj=tKMI0xJ5JCc(Vj=&Y5Te@{(;r&%LUkP>tN;Xn8J(1OKW)?| z(4U<8>jw;m@|$iW5{<`&5INwYG3M{E03-Jja23df6*kw5p4J*;%$DPazoU@LAZ3IZ z6*btlT@k9d8dkC^{H8*i=DM?NOn~qE?Y@`a@O%A60II4V$F}7nA%q2}(3%^n@@h9X zn;R|%hWpWYo>$k_dVI&xgWD)8pG4)ok07Od6>vt(tlM~A*KWEnelv^(3SqH!{b>Uf zl~V8gd%Avi!~U&Q&wrL%CeL_UN;waR@_&yvR44?NWdkTbOZ1|fK+8*w^>#Xem1^}qu>hx~?yEOm+002ov JPDHLkV1g&y5jFq- literal 0 HcmV?d00001 diff --git a/resources/tree_canonicalrecognition.png b/resources/tree_canonicalrecognition.png new file mode 100644 index 0000000000000000000000000000000000000000..9e3a2ec79df4c1606612e75b2fee96b94b5ecde3 GIT binary patch literal 577 zcmV-H0>1r;P)*ih`6%K?fHnK}0YjbaoU$F@hCz6CC^(+yyB@Hl4*$ zIys0A87#GfXpObnrZq1=-phOM`{Q1Rq|$&w4_xkY4)>mOOto62R;zL6_O0_1(nB+uUXA*ER<*37EP0Q)aXAO@SpKa7dWpel&aLq5@A# zhZHLC_`=filbQK*08`PGtBV>PJ&6y2ZnsCP-KC#ps3b-iast+5MQ98sCZn~J187) zZPecZKY`Z(Z-EZb|Hn9txi%Eu1zrJ{fRX{qz;R&gKjk-p6qp`zcL4qXu;v*}MEbSS P00000NkvXXu0mjfB0>Bi literal 0 HcmV?d00001 diff --git a/src/CANRECPLUGINEngine/CANRECPluginEngine.cxx b/src/CANRECPLUGINEngine/CANRECPluginEngine.cxx new file mode 100644 index 0000000..d4d059e --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginEngine.cxx @@ -0,0 +1,30 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "CANRECPluginEngine.hxx" +#include "CANRECPluginEngine_OperationsCreator.hh" + +extern "C" +{ + CANRECPLUGINENGINE_EXPORT + GEOM_GenericOperationsCreator* GetOperationsCreator() + { + return new CANRECPluginEngine_OperationsCreator(); + } +} diff --git a/src/CANRECPLUGINEngine/CANRECPluginEngine.hxx b/src/CANRECPLUGINEngine/CANRECPluginEngine.hxx new file mode 100644 index 0000000..4db53ec --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginEngine.hxx @@ -0,0 +1,33 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINENGINE_HXX) +#define __CANRECPLUGINENGINE_HXX + +#ifdef WIN32 + #if defined CANRECPLUGINENGINE_EXPORTS || defined CANRECPluginEngine_EXPORTS + #define CANRECPLUGINENGINE_EXPORT __declspec( dllexport ) + #else + #define CANRECPLUGINENGINE_EXPORT __declspec( dllimport ) + #endif +#else + #define CANRECPLUGINENGINE_EXPORT +#endif + +#endif // __CANRECPLUGINENGINE_HXX diff --git a/src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.cc b/src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.cc new file mode 100644 index 0000000..e6b3b6e --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.cc @@ -0,0 +1,76 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "CANRECPluginEngine_IOperations_i.hh" +#include "CANRECPluginImpl_IOperations.hxx" + +#include + +CANRECPluginEngine_IOperations_i::CANRECPluginEngine_IOperations_i( PortableServer::POA_ptr thePOA, + GEOM::GEOM_Gen_ptr theEngine, + CANRECPluginImpl_IOperations* theImpl ) + : GEOM_IOperations_i( thePOA, theEngine, theImpl ) +{ + MESSAGE( "CANRECPluginEngine_IOperations_i::CANRECPluginEngine_IOperations_i()" ); +} + +CANRECPluginEngine_IOperations_i::~CANRECPluginEngine_IOperations_i() +{ + MESSAGE( "CANRECPluginEngine_IOperations_i::~CANRECPluginEngine_IOperations_i()" ); +} + +//============================================================================= +/*! + * Create a canonical recognition for the object + * \param theMergeSurf set merging surfaces + * \param theMergeCurves set merging curves + * \param theTolerance set tolerance + * \param theObject is initial object + * \return New GEOM_Object, containing the created shape. + */ +//============================================================================= +GEOM::GEOM_Object_ptr +CANRECPluginEngine_IOperations_i::MakeCanonicalRecognition( GEOM::GEOM_Object_ptr theObject, + CORBA::Boolean theMergeSurf, + CORBA::Boolean theMergeCurves, + CORBA::Double theTolerance ) +{ + // Set a not done flag + GetOperations()->SetNotDone(); + + // Get the reference points + Handle(GEOM_Object) anInitObject = GetObjectImpl( theObject ); + + if ( anInitObject.IsNull() ) return GEOM::GEOM_Object::_nil(); + + // Make Canonical Recognition + Handle(GEOM_Object) anObject = GetOperations()->MakeCanonicalRecognition( anInitObject, + theMergeSurf, + theMergeCurves, + theTolerance ); + if ( !GetOperations()->IsDone() || anObject.IsNull() ) + return GEOM::GEOM_Object::_nil(); + + return GetObject( anObject ); +} + +::CANRECPluginImpl_IOperations* CANRECPluginEngine_IOperations_i::GetOperations() +{ + return (::CANRECPluginImpl_IOperations*)GetImpl(); +} diff --git a/src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.hh b/src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.hh new file mode 100644 index 0000000..419c2c0 --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginEngine_IOperations_i.hh @@ -0,0 +1,51 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINENGINE_IOPERATIONS_HH) +#define __CANRECPLUGINENGINE_IOPERATIONS_HH + +#include +#include CORBA_CLIENT_HEADER(GEOM_Gen) +#include CORBA_SERVER_HEADER(CANRECPlugin) + +#include "CANRECPluginEngine.hxx" + +#include + +class CANRECPluginImpl_IOperations; + +class CANRECPLUGINENGINE_EXPORT CANRECPluginEngine_IOperations_i : + public virtual POA_CANRECPlugin::ICanRecOperations, + public virtual GEOM_IOperations_i +{ + public: + CANRECPluginEngine_IOperations_i( PortableServer::POA_ptr thePOA, + GEOM::GEOM_Gen_ptr theEngine, + CANRECPluginImpl_IOperations* theImpl ); + ~CANRECPluginEngine_IOperations_i(); + + GEOM::GEOM_Object_ptr MakeCanonicalRecognition ( GEOM::GEOM_Object_ptr theObject, + CORBA::Boolean theMergeSurf, + CORBA::Boolean theMergeCurves, + CORBA::Double theTolerance ); + + CANRECPluginImpl_IOperations* GetOperations(); +}; + +#endif // __CANRECPLUGINENGINE_IOPERATIONS_HH diff --git a/src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.cc b/src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.cc new file mode 100644 index 0000000..8a78b2a --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.cc @@ -0,0 +1,58 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com + +#include "CANRECPluginEngine_OperationsCreator.hh" +#include "CANRECPluginEngine_IOperations_i.hh" +#include "CANRECPluginImpl_IOperations.hxx" +#include "CANRECPluginImpl_Driver.hxx" + +#include + +#include + +std::map CANRECPluginEngine_OperationsCreator::_mapOfOperations; + +CANRECPluginEngine_OperationsCreator::CANRECPluginEngine_OperationsCreator() +{ + // Register drivers + TFunction_DriverTable::Get()->AddDriver( CANRECPluginImpl_Driver::GetID(), + new CANRECPluginImpl_Driver() ); +} + +CANRECPluginEngine_OperationsCreator::~CANRECPluginEngine_OperationsCreator() +{ +} + +GEOM_IOperations_i* CANRECPluginEngine_OperationsCreator::Create( PortableServer::POA_ptr thePOA, + int theStudyId, + GEOM::GEOM_Gen_ptr theEngine, + ::GEOMImpl_Gen* theGenImpl ) +{ + Unexpect aCatch(SALOME_SalomeException); + MESSAGE( "CANRECPluginEngine_OperationsCreator::Create" ); + return new CANRECPluginEngine_IOperations_i( thePOA, theEngine, get( theGenImpl, theStudyId ) ); +} + +CANRECPluginImpl_IOperations* CANRECPluginEngine_OperationsCreator::get( ::GEOMImpl_Gen* theGenImpl, + int theStudyId ) +{ + + if ( _mapOfOperations.find( theStudyId ) == _mapOfOperations.end() ) + _mapOfOperations[theStudyId] = new CANRECPluginImpl_IOperations( theGenImpl, theStudyId ); + return _mapOfOperations[theStudyId]; +} diff --git a/src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.hh b/src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.hh new file mode 100644 index 0000000..91c4f52 --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginEngine_OperationsCreator.hh @@ -0,0 +1,49 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com + +#if !defined(__CANRECPLUGINENGINE_OPERATIONSCREATOR_HH) +#define __CANRECPLUGINENGINE_OPERATIONSCREATOR_HH + +#include "CANRECPluginEngine.hxx" +#include +#include + +class GEOMImpl_Gen; +class CANRECPluginImpl_IOperations; + +//===================================================================== +// Operations creator +//===================================================================== +class CANRECPLUGINENGINE_EXPORT CANRECPluginEngine_OperationsCreator : public GEOM_GenericOperationsCreator +{ +public: + CANRECPluginEngine_OperationsCreator(); + ~CANRECPluginEngine_OperationsCreator(); + + virtual GEOM_IOperations_i* Create ( PortableServer::POA_ptr thePOA, + int theStudyId, + GEOM::GEOM_Gen_ptr theEngine, + ::GEOMImpl_Gen* theGenImpl ); +private: + static CANRECPluginImpl_IOperations* get( ::GEOMImpl_Gen* theGenImpl, + int theStudyId ); + + static std::map _mapOfOperations; +}; + +#endif // __CANRECPLUGINENGINE_OPERATIONSCREATOR_HH diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.cxx b/src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.cxx new file mode 100644 index 0000000..107776d --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.cxx @@ -0,0 +1,142 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com + +#include "CANRECPluginImpl_Driver.hxx" +#include "CANRECPluginImpl_Types.hxx" +#include "CANRECPluginImpl_ICanRec.hxx" + +#include + +#include +#include +#include +#include +#include +#include + +#ifdef CANREC_HASLICENSE +#include "CANRECPluginImpl_license.h" +#include +#include +#endif // CANREC_HASLICENSE + +const Standard_GUID& CANRECPluginImpl_Driver::GetID() +{ + static Standard_GUID aGUID("7e1492bb-b4cd-4a40-ad8f-102902b0047e"); + return aGUID; +} + +CANRECPluginImpl_Driver::CANRECPluginImpl_Driver() +{ +} + +CANRECPluginImpl_Driver::~CANRECPluginImpl_Driver() +{ +} + +Standard_Boolean CANRECPluginImpl_Driver::MustExecute( const TFunction_Logbook& ) const +{ + return Standard_True; +} + +void CANRECPluginImpl_Driver::Validate( TFunction_Logbook& ) const +{ +} + +Standard_Integer CANRECPluginImpl_Driver::Execute( TFunction_Logbook& log ) const +{ + if ( Label().IsNull() ) return 0; + Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction( Label() ); + + CANRECPluginImpl_ICanRec aData( aFunction ); + + // Getting data + bool isNeedMergeSurf = aData.GetNeedMergeSurf(); + bool isNeedMergeCurves = aData.GetNeedMergeCurves(); + double aTolerance = aData.GetTolerance(); + Handle(GEOM_Function) anObject = aData.GetObject(); + TopoDS_Shape aShape = anObject->GetValue(); + +#ifdef CANREC_HASLICENSE + try { + OCCLicense_Activate( "CANREC-"OCC_VERSION_STRING, CANREC_LICENSE ); + } + catch (Standard_LicenseError) { + return 0; + } +#endif // CANREC_HASLICENSE + + ShapeConvert_CanonicAPI aRecognizer; + aRecognizer.Tolerance() = aTolerance; + aRecognizer.SurfaceMode() = isNeedMergeSurf; + aRecognizer.CurveMode() = isNeedMergeCurves; + + // 1. Recognizing + aRecognizer.SetShape( aShape ); + aRecognizer.UnifyMode() = false; + aRecognizer.Perform(); + TopoDS_Shape aResultingShape = aRecognizer.Shape(); + + // 2. Sewing + BRepOffsetAPI_Sewing aSewing( aTolerance ); + aSewing.Add( aResultingShape ); + aSewing.Perform(); + aResultingShape = aSewing.SewedShape(); + + // 3.1. Union Surfaces + if ( isNeedMergeSurf ) { + ShapeConvert_UnionFaces aFaceUnifier; + aFaceUnifier.GetTolerance() = aTolerance; + aResultingShape = aFaceUnifier.Perform( aResultingShape ); + } + + // 3.2. Union Curves + if ( isNeedMergeCurves ) { + ShapeConvert_UnionEdges anEdgeUnifier; + aResultingShape = anEdgeUnifier.Perform( aResultingShape, aTolerance ); + } + + if ( aResultingShape.IsNull() ) return 0; + + aFunction->SetValue( aResultingShape ); + + log.SetTouched( Label() ); + + return 1; +} + +bool CANRECPluginImpl_Driver:: +GetCreationInformation( std::string& theOperationName, + std::vector& theParams ) +{ + if ( Label().IsNull() ) return 0; + Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction( Label() ); + + CANRECPluginImpl_ICanRec aCI( aFunction ); + + theOperationName = "CANONICALRECOGNITION"; + AddParam( theParams, PLUGIN_NAME, "CANRECPlugin" ); + AddParam( theParams, "Tolerance", aCI.GetTolerance() ); + AddParam( theParams, "Merge Surfaces", aCI.GetNeedMergeSurf() ); + AddParam( theParams, "Merge Curves", aCI.GetNeedMergeCurves() ); + + return true; +} + +IMPLEMENT_STANDARD_HANDLE( CANRECPluginImpl_Driver, GEOM_BaseDriver ); +IMPLEMENT_STANDARD_RTTIEXT( CANRECPluginImpl_Driver, GEOM_BaseDriver ); diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.hxx b/src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.hxx new file mode 100644 index 0000000..68266ba --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_Driver.hxx @@ -0,0 +1,44 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINIMPL_DRIVER_HXX) +#define __CANRECPLUGINIMPL_DRIVER_HXX + +#include + +DEFINE_STANDARD_HANDLE( CANRECPluginImpl_Driver, GEOM_BaseDriver ); + +class CANRECPluginImpl_Driver : public GEOM_BaseDriver +{ +public: + CANRECPluginImpl_Driver(); + ~CANRECPluginImpl_Driver(); + + static const Standard_GUID& GetID(); + virtual Standard_Integer Execute( TFunction_Logbook& ) const; + Standard_Boolean MustExecute( const TFunction_Logbook& ) const; + virtual void Validate( TFunction_Logbook& ) const; + + virtual bool GetCreationInformation( std::string&, + std::vector& ); + + DEFINE_STANDARD_RTTI( CANRECPluginImpl_Driver ); +}; + +#endif // __CANRECPLUGINIMPL_DRIVER_HXX diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_ICanRec.hxx b/src/CANRECPLUGINEngine/CANRECPluginImpl_ICanRec.hxx new file mode 100644 index 0000000..111aa48 --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_ICanRec.hxx @@ -0,0 +1,51 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINIMPL_ICANREC_HXX) +#define __CANRECPLUGINIMPL_ICANREC_HXX + +#include + +#define CanonicalRecognition_ARG_NeedMergeSurf 1 +#define CanonicalRecognition_ARG_NeedMergeCurves 2 +#define CanonicalRecognition_ARG_Tolerance 3 +#define CanonicalRecognition_ARG_Object 4 + +class CANRECPluginImpl_ICanRec +{ +public: + CANRECPluginImpl_ICanRec(Handle(GEOM_Function) theFunction): _func(theFunction) {} + + void SetNeedMergeSurf(bool theMergeSurf) { _func->SetInteger(CanonicalRecognition_ARG_NeedMergeSurf, (int)theMergeSurf); } + bool GetNeedMergeSurf() { return (bool)_func->GetInteger(CanonicalRecognition_ARG_NeedMergeSurf); } + + void SetNeedMergeCurves(bool theCurves) { _func->SetInteger(CanonicalRecognition_ARG_NeedMergeCurves, (int)theCurves); } + bool GetNeedMergeCurves() { return (bool)_func->GetInteger(CanonicalRecognition_ARG_NeedMergeCurves); } + + void SetTolerance(double theTolerance) { _func->SetReal(CanonicalRecognition_ARG_Tolerance, theTolerance); } + double GetTolerance() { return _func->GetReal(CanonicalRecognition_ARG_Tolerance); } + + void SetObject(Handle(GEOM_Function) anInitialObject) { _func->SetReference(CanonicalRecognition_ARG_Object, anInitialObject); } + Handle(GEOM_Function) GetObject() { return _func->GetReference(CanonicalRecognition_ARG_Object); } + +private: + Handle(GEOM_Function) _func; +}; + +#endif // __CANRECPLUGINIMPL_ICANREC_HXX diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.cxx b/src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.cxx new file mode 100644 index 0000000..9fdb532 --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.cxx @@ -0,0 +1,103 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "CANRECPluginImpl_IOperations.hxx" +#include "CANRECPluginImpl_Driver.hxx" +#include "CANRECPluginImpl_ICanRec.hxx" +#include "CANRECPluginImpl_Types.hxx" + +#include + +#include + +#include + +CANRECPluginImpl_IOperations::CANRECPluginImpl_IOperations( GEOM_Engine* theEngine, int theDocID) + : GEOM_IOperations( theEngine, theDocID ) +{ + MESSAGE( "CANRECPluginImpl_IOperations::CANRECPluginImpl_IOperations()" ); +} + +CANRECPluginImpl_IOperations::~CANRECPluginImpl_IOperations() +{ + MESSAGE( "CANRECPluginImpl_IOperations::~CANRECPluginImpl_IOperations()" ); +} + +//============================================================================= +/*! + * Create a canonical recognition for the object + * \param theMergeSurf set merging surfaces + * \param theMergeCurves set merging curves + * \param theTolerance set tolerance + * \param theObject is initial object + * \return New GEOM_Object, containing the created shape. + */ +//============================================================================= +Handle(GEOM_Object) +CANRECPluginImpl_IOperations::MakeCanonicalRecognition ( Handle(GEOM_Object) theObject, + bool theMergeSurf, + bool theMergeCurves, + double theTolerance ) +{ + SetErrorCode( KO ); + + if ( theObject.IsNull() ) return NULL; + + // Add a new object + Handle(GEOM_Object) aShape = GetEngine()->AddObject( GetDocID(), GEOM_CANONICALRECOGNITION ); + + // Add a new shape function with parameters + Handle(GEOM_Function) aFunction = aShape->AddFunction( CANRECPluginImpl_Driver::GetID(), CANONICALRECOGNITION_OBJ ); + if ( aFunction.IsNull() ) return NULL; + + // Check if the function is set correctly + if ( aFunction->GetDriverGUID() != CANRECPluginImpl_Driver::GetID() ) return NULL; + + Handle(GEOM_Function) aRefFunction = theObject->GetLastFunction(); + + if ( aRefFunction.IsNull() ) return NULL; + + CANRECPluginImpl_ICanRec aData( aFunction ); + aData.SetNeedMergeSurf( theMergeSurf ); + aData.SetNeedMergeCurves( theMergeCurves ); + aData.SetTolerance( theTolerance ); + aData.SetObject( aRefFunction ); + + // Compute the resulting value + try { + OCC_CATCH_SIGNALS; + if ( !GetSolver()->ComputeFunction( aFunction ) ) { + SetErrorCode( "Canonical Recognition driver failed" ); + return NULL; + } + } + catch ( Standard_Failure ) { + Handle(Standard_Failure) aFail = Standard_Failure::Caught(); + SetErrorCode( aFail->GetMessageString() ); + return NULL; + } + + // Make a Python command + GEOM::TPythonDump(aFunction) << aShape << " = " << "geompy.MakeCanonicalRecognition(" << + theObject << ", " << theMergeSurf << ", " << theMergeCurves << ", " << theTolerance << ")"; + + SetErrorCode( OK ); + + return aShape; +} diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.hxx b/src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.hxx new file mode 100644 index 0000000..2d7ba11 --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_IOperations.hxx @@ -0,0 +1,40 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINIMPL_IOPERATIONS_HXX) +#define __CANRECPLUGINIMPL_IOPERATIONS_HXX + +#include +#include + +class GEOM_Engine; + +class CANRECPluginImpl_IOperations: public GEOM_IOperations +{ +public: + Standard_EXPORT CANRECPluginImpl_IOperations( GEOM_Engine* theEngine, int theDocID ); + Standard_EXPORT ~CANRECPluginImpl_IOperations(); + + Standard_EXPORT Handle(GEOM_Object) MakeCanonicalRecognition ( Handle(GEOM_Object) theObject, + bool theMergeSurf, + bool theMergeCurves, + double theTolerance ); +}; + +#endif // __CANRECPLUGINIMPL_IOPERATIONS_HXX diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_Types.hxx b/src/CANRECPLUGINEngine/CANRECPluginImpl_Types.hxx new file mode 100644 index 0000000..59b986d --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_Types.hxx @@ -0,0 +1,30 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com + +#if !defined(__CANRECPLUGINIMPL_TYPES_HXX) +#define __CANRECPLUGINIMPL_TYPES_HXX + +#include + +// Canonical Recognition functions +#define GEOM_CANONICALRECOGNITION (USER_TYPE_EX + 1) + +// Canonical Recognition sub-operations codes +#define CANONICALRECOGNITION_OBJ 1 + +#endif // __CANRECPLUGINIMPL_TYPES_HXX diff --git a/src/CANRECPLUGINEngine/CANRECPluginImpl_license.h.in b/src/CANRECPLUGINEngine/CANRECPluginImpl_license.h.in new file mode 100644 index 0000000..a527c36 --- /dev/null +++ b/src/CANRECPLUGINEngine/CANRECPluginImpl_license.h.in @@ -0,0 +1,25 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINIMPL_LICENSE_H) +#define __CANRECPLUGINIMPL_LICENSE_H + +#define CANREC_LICENSE "@CANREC_LICENSE@" + +#endif // __CANRECPLUGINIMPL_LICENSE_H diff --git a/src/CANRECPLUGINEngine/CMakeLists.txt b/src/CANRECPLUGINEngine/CMakeLists.txt new file mode 100644 index 0000000..56e120a --- /dev/null +++ b/src/CANRECPLUGINEngine/CMakeLists.txt @@ -0,0 +1,81 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +# --- options --- + +# additional include directories +INCLUDE_DIRECTORIES( + ${CAS_INCLUDE_DIRS} + ${CR_INCLUDE_DIRS} + ${OMNIORB_INCLUDE_DIR} + ${KERNEL_INCLUDE_DIRS} + ${GEOM_INCLUDE_DIRS} + ${PROJECT_BINARY_DIR} + ${PROJECT_BINARY_DIR}/idl + ${CMAKE_CURRENT_BINARY_DIR} + ) + +# additional preprocessor / compiler flags +ADD_DEFINITIONS( + ${CAS_DEFINITIONS} + ${OMNIORB_DEFINITIONS} + ) + +# libraries to link to +SET(_link_LIBRARIES + ${CR_LIBRARIES} + ${KERNEL_SALOMEBasics} + ${KERNEL_SALOMELocalTrace} + ${KERNEL_OpUtil} + ${GEOM_SalomeIDLGEOM} + ${GEOM_GEOMEngine} + SalomeIDLCANRECPlugin + ) + +# --- headers --- + +SET(CANRECPluginEngine_HEADERS + CANRECPluginEngine.hxx + CANRECPluginEngine_IOperations_i.hh + CANRECPluginEngine_OperationsCreator.hh + CANRECPluginImpl_Driver.hxx + CANRECPluginImpl_ICanRec.hxx + CANRECPluginImpl_IOperations.hxx + CANRECPluginImpl_Types.hxx + ) +# --- sources --- + +SET(CANRECPluginEngine_SOURCES + CANRECPluginEngine.cxx + CANRECPluginEngine_IOperations_i.cc + CANRECPluginEngine_OperationsCreator.cc + CANRECPluginImpl_Driver.cxx + CANRECPluginImpl_IOperations.cxx + ) + +# --- rules --- + +ADD_LIBRARY(CANRECPluginEngine ${CANRECPluginEngine_SOURCES}) +TARGET_LINK_LIBRARIES(CANRECPluginEngine ${_link_LIBRARIES}) +INSTALL(TARGETS CANRECPluginEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS}) + +INSTALL(FILES ${CANRECPluginEngine_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS}) + +# configure license file +CONFIGURE_FILE(CANRECPluginImpl_license.h.in CANRECPluginImpl_license.h) diff --git a/src/CANRECPLUGINGUI/CANRECPluginGUI.cxx b/src/CANRECPLUGINGUI/CANRECPluginGUI.cxx new file mode 100644 index 0000000..e901115 --- /dev/null +++ b/src/CANRECPLUGINGUI/CANRECPluginGUI.cxx @@ -0,0 +1,98 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "CANRECPluginGUI.h" +#include "CANRECPluginGUI_CanonicalRecognitionDlg.h" + +#include + +#include +#include + +//======================================================================= +// function : CANRECPluginGUI() +// purpose : Constructor +//======================================================================= +CANRECPluginGUI::CANRECPluginGUI( GeometryGUI* parent ) : GEOMPluginGUI( parent ) +{ +} + +//======================================================================= +// function : ~CANRECPluginGUI +// purpose : Destructor +//======================================================================= +CANRECPluginGUI::~CANRECPluginGUI() +{ +} + +//======================================================================= +// function : OnGUIEvent() +// purpose : +//======================================================================= +bool CANRECPluginGUI::OnGUIEvent( int theCommandID, SUIT_Desktop* parent ) +{ + QString cmd; + switch ( theCommandID ) { + case 1: + cmd = "CanonicalRecognition"; + default: + break; + } + return OnGUIEvent( cmd, parent ); +} + +//======================================================================= +// function : OnGUIEvent() +// purpose : +//======================================================================= +bool CANRECPluginGUI::OnGUIEvent( const QString& theCommandID, SUIT_Desktop* parent ) +{ + SalomeApp_Application* app = getGeometryGUI()->getApp(); + if ( !app ) return false; + + getGeometryGUI()->EmitSignalDeactivateDialog(); + + QDialog* aDlg = 0; + + if ( theCommandID == "CanonicalRecognition" ) { + aDlg = new CANRECPluginGUI_CanonicalRecognitionDlg( getGeometryGUI(), parent ); + } + else { + app->putInfo( tr( "GEOM_PRP_COMMAND" ).arg( theCommandID ) ); + } + + if ( aDlg ) + aDlg->show(); + + return true; +} + +//===================================================================================== +// EXPORTED METHODS +//===================================================================================== +extern "C" +{ +#ifdef WIN32 + __declspec( dllexport ) +#endif + GEOMGUI* GetLibGUI( GeometryGUI* parent ) + { + return new CANRECPluginGUI( parent ); + } +} diff --git a/src/CANRECPLUGINGUI/CANRECPluginGUI.h b/src/CANRECPLUGINGUI/CANRECPluginGUI.h new file mode 100644 index 0000000..a544915 --- /dev/null +++ b/src/CANRECPLUGINGUI/CANRECPluginGUI.h @@ -0,0 +1,37 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINGUI_H) +#define __CANRECPLUGINGUI_H + +#include + +class GeometryGUI; + +class CANRECPluginGUI : public GEOMPluginGUI +{ +public: + CANRECPluginGUI( GeometryGUI* ); + ~CANRECPluginGUI(); + + bool OnGUIEvent( int, SUIT_Desktop* ); + bool OnGUIEvent( const QString&, SUIT_Desktop* ); +}; + +#endif // __CANRECPLUGINGUI_H diff --git a/src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.cxx b/src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.cxx new file mode 100644 index 0000000..8de9222 --- /dev/null +++ b/src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.cxx @@ -0,0 +1,311 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "CANRECPluginGUI_CanonicalRecognitionDlg.h" + +// Geometry includes +#include +#include +#include +#include +#include + +# //GUI inludes +#include +#include +#include +#include +#include +#include +#include +#include + +// OCCT Include +#include +#include +#include +#include +#include + +// Qt includes +#include +#include +#include +#include +#include +#include +#include + +#include +#include CORBA_CLIENT_HEADER(CANRECPlugin) + +//================================================================================= +// Constructor +//================================================================================= +CANRECPluginGUI_CanonicalRecognitionDlg::CANRECPluginGUI_CanonicalRecognitionDlg( GeometryGUI* theGeometryGUI, QWidget* parent ) +: GEOMBase_Skeleton(theGeometryGUI, parent, false) +{ + QString aPluginName = "CANRECPlugin"; + QPixmap imageOp (SUIT_Session::session()->resourceMgr()->loadPixmap( aPluginName, tr( "ICO_CANONICALRECOGNITION" ) ) ); + QPixmap image1( SUIT_Session::session()->resourceMgr()->loadPixmap( aPluginName, tr( "ICON_SELECT" ) ) ); + + setWindowTitle(tr("CANONICALRECOGNITION_CANONICALRECOGNITION_TITLE")); + + /***************************************************************/ + + mainFrame()->GroupConstructors->setTitle(tr("GEOM_CANONICALRECOGNITION")); + mainFrame()->RadioButton1->setIcon(imageOp); + + //Hide second and third radio buttons + + mainFrame()->RadioButton2->setAttribute( Qt::WA_DeleteOnClose ); + mainFrame()->RadioButton2->close(); + + mainFrame()->RadioButton3->setAttribute( Qt::WA_DeleteOnClose ); + mainFrame()->RadioButton3->close(); + + mainFrame()->RadioButton3->setAttribute( Qt::WA_DeleteOnClose ); + mainFrame()->RadioButton3->close(); + + //Arguments + QGroupBox* argGroup = new QGroupBox( tr( "CANRECPLUGIN_ARGUMENTS" ), this ); + QGridLayout* lay = new QGridLayout( argGroup ); + + // Object selector + LineEdit1 = new QLineEdit( argGroup ); + LineEdit1->setReadOnly( true ); + PButton1 = new QPushButton( argGroup ); + PButton1->setIcon( image1 ); + PButton1->setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ); + + // 2. Object + QLabel* textLabel1 = new QLabel( argGroup ); + textLabel1->setText( tr( "CANRECPLUGIN_ARG_OBJ" ) ); + + // 3. Tolerance + QLabel* textLabel2 = new QLabel( argGroup ); + textLabel2->setText( tr( "CANRECPLUGIN_ARG_TOLERANCE" ) ); + SpinBoxTol = new SalomeApp_DoubleSpinBox( argGroup ); + SpinBoxTol->setValue( 0.01 ); + initSpinBox(SpinBoxTol, COORD_MIN, COORD_MAX, 0.001, "length_precision" ); + + // 4. Merge sufrace flag + CheckButton1 = new QCheckBox( argGroup ); + CheckButton1->setText( tr( "CANRECPLUGIN_ARG_MERGE_SURF" ) ); + CheckButton1->setChecked( true ); + + // 5. Merge curves flag + CheckButton2 = new QCheckBox( argGroup ); + CheckButton2->setText( tr( "CANRECPLUGIN_ARG_MERGE_CURVES" ) ); + CheckButton2->setChecked( true ); + + lay->addWidget( textLabel1, 0, 0 ); + lay->addWidget( PButton1, 0, 1 ); + lay->addWidget( LineEdit1, 0, 2 ); + + lay->addWidget( textLabel2, 1, 0, 1, 2 ); + lay->addWidget( SpinBoxTol, 1, 2 ); + + lay->addWidget( CheckButton1, 2, 0, 1, 3 ); + lay->addWidget( CheckButton2, 3, 0, 1, 3 ); + + myHelpFileName = "canrecplugin_usage_page.html"; + myHelpContext = aPluginName.toUpper(); + + QVBoxLayout* layout = new QVBoxLayout( centralWidget() ); + layout->setMargin(0); layout->setSpacing(6); + layout->addWidget( argGroup ); + + Init(); +} + +//================================================================================= +// Destructor +//================================================================================= +CANRECPluginGUI_CanonicalRecognitionDlg::~CANRECPluginGUI_CanonicalRecognitionDlg() +{ + // no need to delete child widgets, Qt does it all for us +} + +//================================================================================= +// function : Init() +// purpose : +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::Init() +{ + // Get setting of step value from file configuration + SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr(); + double step = resMgr->doubleValue( "Geometry", "SettingsGeomStep", 100 ); + + // Signal/slot connections + connect( buttonOk(), SIGNAL( clicked() ),this, SLOT( ClickOnOk() ) ); + connect( buttonApply(), SIGNAL( clicked() ),this, SLOT( ClickOnApply() ) ); + connect( myGeomGUI, SIGNAL( SignalDefaultStepValueChanged( double ) ), + this, SLOT( SetDoubleSpinBoxStep( double ) ) ); + connect( myGeomGUI->getApp()->selectionMgr(), + SIGNAL( currentSelectionChanged() ), this, SLOT( SelectionIntoArgument() ) ); + initName( tr( "GEOM_CANONICALRECOGNITION_NAME" ) ); + SelectionIntoArgument(); +} + +//================================================================================= +// function : ClickOnOk() +// purpose : +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::ClickOnOk() +{ + if ( ClickOnApply() ) + ClickOnCancel(); +} + +//================================================================================= +// function : ClickOnCancel() +// purpose : +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::ClickOnCancel() +{ + close(); +} + +//================================================================================= +// function : ClickOnApply() +// purpose : +//================================================================================= +bool CANRECPluginGUI_CanonicalRecognitionDlg::ClickOnApply() +{ + if ( !onAccept() ) + return false; + initName(); + return true; +} + +//================================================================================= +// function : ActivateThisDialog() +// purpose : +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::ActivateThisDialog() +{ + GEOMBase_Skeleton::ActivateThisDialog(); + + connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ), + this, SLOT( SelectionIntoArgument() ) ); + SelectionIntoArgument(); +} + +//================================================================================= +// function : enterEvent [REDEFINED] +// purpose : +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::enterEvent (QEvent*) +{ + if ( !isEnabled() ) + ActivateThisDialog(); +} + +//================================================================================= +// function : createOperation +// purpose : +//================================================================================= +GEOM::GEOM_IOperations_ptr CANRECPluginGUI_CanonicalRecognitionDlg::createOperation() +{ + return getGeomEngine()->GetPluginOperations( getStudyId(), "CANRECPluginEngine" ); +} + +//================================================================================= +// function : isValid +// purpose : +//================================================================================= +bool CANRECPluginGUI_CanonicalRecognitionDlg::isValid( QString& msg ) +{ + bool ok = true; + return ok; +} + +//================================================================================= +// function : execute +// purpose : +//================================================================================= +bool CANRECPluginGUI_CanonicalRecognitionDlg::execute( ObjectList& objects ) +{ + bool res = false; + + GEOM::GEOM_Object_var anObj; + + CANRECPlugin::ICanRecOperations_var anOper = CANRECPlugin::ICanRecOperations::_narrow( getOperation() ); + CORBA::Boolean aMergeSurf = CheckButton1->isChecked(); + CORBA::Boolean aMergeCurves = CheckButton2->isChecked(); + CORBA::Double aTolerance = SpinBoxTol->value(); + + // call engine function + anObj = anOper->MakeCanonicalRecognition( myObject.get(), aMergeSurf, aMergeCurves, aTolerance ); + res = !anObj->_is_nil(); + if ( res && !IsPreview() ) + { + QStringList aParameters; + aParameters << QString( CheckButton1->isChecked() ); + aParameters << QString( CheckButton2->isChecked() ); + aParameters << QString::number( SpinBoxTol->value() ); + aParameters << myObject->GetName(); + + if ( aParameters.count() > 0 ) + anObj->SetParameters( aParameters.join(":").toLatin1().constData() ); + } + + if ( res ) + objects.push_back( anObj._retn() ); + + return res; +} + +//================================================================================= +// function : SelectionIntoArgument() +// purpose : Called when selection as changed or other case +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::SelectionIntoArgument() +{ + QList aTypes; + aTypes << TopAbs_SOLID << TopAbs_COMPOUND << TopAbs_COMPSOLID << TopAbs_SHELL; + QList selected = getSelected( aTypes, -1 ); + if ( !selected.isEmpty() ) + { + myObject = selected.first(); + LineEdit1->setText( myObject->GetName() ); + } + else + LineEdit1->setText( "" ); +} + +//================================================================================= +// function : SetEditCurrentArgument() +// purpose : +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::SetEditCurrentArgument() +{ + if ( sender() == PButton1 ) + LineEdit1->setFocus(); + SelectionIntoArgument(); +} +//================================================================================= +// function : SetDoubleSpinBoxStep() +// purpose : Double spin box management +//================================================================================= +void CANRECPluginGUI_CanonicalRecognitionDlg::SetDoubleSpinBoxStep( double step ) +{ + SpinBoxTol->setSingleStep( step ); +} diff --git a/src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.h b/src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.h new file mode 100644 index 0000000..15ae7a5 --- /dev/null +++ b/src/CANRECPLUGINGUI/CANRECPluginGUI_CanonicalRecognitionDlg.h @@ -0,0 +1,70 @@ +// Copyright (C) 2014-2015 OPEN CASCADE +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#if !defined(__CANRECPLUGINGUI_CANONICALRECONGNITION_H) +#define __CANRECPLUGINGUI_CANONICALRECONGNITION_H + +#include +#include + +class GeometryGUI; +class SalomeApp_DoubleSpinBox; +class QCheckBox; +class QPushButton; +class QLineEdit; +class QGroupBox; + +class CANRECPluginGUI_CanonicalRecognitionDlg : public GEOMBase_Skeleton +{ + Q_OBJECT + +public: + CANRECPluginGUI_CanonicalRecognitionDlg( GeometryGUI*, QWidget* = 0 ); + ~CANRECPluginGUI_CanonicalRecognitionDlg(); + +protected: + virtual GEOM::GEOM_IOperations_ptr createOperation(); + virtual bool isValid( QString& ); + virtual bool execute( ObjectList& ); + +private: + void Init(); + void enterEvent( QEvent* ); + +private slots: + void ClickOnOk(); + virtual void ClickOnCancel(); + bool ClickOnApply(); + + void ActivateThisDialog(); + void SelectionIntoArgument(); + void SetEditCurrentArgument(); + void SetDoubleSpinBoxStep( double ); + +private: + QLineEdit* LineEdit1; + QPushButton* PButton1; + SalomeApp_DoubleSpinBox* SpinBoxTol; + QCheckBox* CheckButton1; + QCheckBox* CheckButton2; + + GEOM::GeomObjPtr myObject; +}; + +#endif // __CANRECPLUGINGUI_CANONICALRECONGNITION_H diff --git a/src/CANRECPLUGINGUI/CMakeLists.txt b/src/CANRECPLUGINGUI/CMakeLists.txt new file mode 100644 index 0000000..3d3cf4d --- /dev/null +++ b/src/CANRECPLUGINGUI/CMakeLists.txt @@ -0,0 +1,103 @@ + # Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +INCLUDE(UseQt4Ext) +INCLUDE(${QT_USE_FILE}) + +# --- options --- +# additional include directories +INCLUDE_DIRECTORIES( + ${CAS_INCLUDE_DIRS} + ${QT_INCLUDES} + ${OMNIORB_INCLUDE_DIR} + ${PYTHON_INCLUDES} + ${KERNEL_INCLUDE_DIRS} + ${GUI_INCLUDE_DIRS} + ${GEOM_INCLUDE_DIRS} + ${PROJECT_BINARY_DIR}/idl +) + +# additional preprocessor / compiler flags +ADD_DEFINITIONS( + ${CAS_DEFINITIONS} + ${QT_DEFINITIONS} + ${OMNIORB_DEFINITIONS} + ${GUI_DEFINITIONS} +) + +# libraries to link to +SET(_link_LIBRARIES +# ${GUI_SalomeApp} +# ${GUI_qtx} +# ${GUI_suit} +# ${GUI_SalomeObject} +# ${GUI_LightApp} +# ${CAS_KERNEL} +# ${GEOM_GEOM} + ${GEOM_GEOMBase} + SalomeIDLCANRECPlugin +) + +# --- headers --- + +# header files / to be processed by moc +SET(_moc_HEADERS + CANRECPluginGUI_CanonicalRecognitionDlg.h +) + +# header files / no moc processed +SET(_other_HEADERS + CANRECPluginGUI.h +) + +SET(CANRECPluginGUI_HEADERS ${_moc_HEADERS} ${_other_HEADERS}) + +# --- sources --- + +# sources / moc wrappings +QT4_WRAP_CPP(_moc_SOURCES ${_moc_HEADERS}) + +# sources / static +SET(_other_SOURCES + CANRECPluginGUI.cxx + CANRECPluginGUI_CanonicalRecognitionDlg.cxx +) + +# --- resources --- + +# resource files / to be processed by lrelease +SET(_ts_RESOURCES + resources/CANRECPlugin_images.ts + resources/CANRECPlugin_msg_en.ts + resources/CANRECPlugin_msg_fr.ts + resources/CANRECPlugin_msg_ja.ts +) + +# sources / to compile +SET(CANRECPluginGUI_SOURCES ${_other_SOURCES} ${_moc_SOURCES}) + +# --- rules --- + +ADD_LIBRARY(CANRECPluginGUI ${CANRECPluginGUI_SOURCES}) +TARGET_LINK_LIBRARIES(CANRECPluginGUI ${_link_LIBRARIES} ) +INSTALL(TARGETS CANRECPluginGUI EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS}) + +INSTALL(FILES ${CANRECPluginGUI_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS}) + +QT4_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_CANRECPLUGIN_INSTALL_RES_DATA}") diff --git a/src/CANRECPLUGINGUI/resources/CANRECPlugin_images.ts b/src/CANRECPLUGINGUI/resources/CANRECPlugin_images.ts new file mode 100644 index 0000000..b13f825 --- /dev/null +++ b/src/CANRECPLUGINGUI/resources/CANRECPlugin_images.ts @@ -0,0 +1,19 @@ + + + + + @default + + ICON_SELECT + select1.png + + + ICO_CANONICALRECOGNITION + canonicalrecognition.png + + + ICON_OBJBROWSER_1001 + tree_canonicalrecognition.png + + + diff --git a/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_en.ts b/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_en.ts new file mode 100644 index 0000000..fba0e94 --- /dev/null +++ b/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_en.ts @@ -0,0 +1,66 @@ + + + + + @default + + TOP_CANONICALRECOGNITION + Canonical Recognition + + + MEN_CANONICALRECOGNITION + Canonical Recognition + + + STB_CANONICALRECOGNITION + Canonical Recognition + + + + CANRECPluginGUI_CanonicalRecognitionDlg + + CANONICALRECOGNITION_CANONICALRECOGNITION_TITLE + Canonical Recognition Construction + + + GEOM_CANONICALRECOGNITION + Canonical Recognition + + + GEOM_CANONICALRECOGNITION_NAME + Canonical recognition + + + GEOM_CANONICALRECOGNITION_RESULT + Result name + + + GEOM_CANONICALRECOGNITION_ARG + Nodes + + + CANRECPLUGIN_NAME + Name + + + CANRECPLUGIN_ARGUMENTS + Arguments + + + CANRECPLUGIN_ARG_MERGE_SURF + Merge Surfaces + + + CANRECPLUGIN_ARG_MERGE_CURVES + Merge Curves + + + CANRECPLUGIN_ARG_OBJ + Object + + + CANRECPLUGIN_ARG_TOLERANCE + Tolerance + + + diff --git a/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_fr.ts b/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_fr.ts new file mode 100644 index 0000000..dbb4d18 --- /dev/null +++ b/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_fr.ts @@ -0,0 +1,66 @@ + + + + + @default + + TOP_CANONICALRECOGNITION + Canonical Recognition + + + MEN_CANONICALRECOGNITION + Canonical Recognition + + + STB_CANONICALRECOGNITION + Canonical Recognition + + + + CANRECPluginGUI_CanonicalRecognitionDlg + + CANONICALRECOGNITION_CANONICALRECOGNITION_TITLE + Canonical Recognition Construction + + + GEOM_CANONICALRECOGNITION + Canonical Recognition + + + GEOM_CANONICALRECOGNITION_NAME + Canonical recognition + + + GEOM_CANONICALRECOGNITION_RESULT + Result name + + + GEOM_CANONICALRECOGNITION_ARG + Nodes + + + CANRECPLUGIN_NAME + Name + + + CANRECPLUGIN_ARGUMENTS + Arguments + + + CANRECPLUGIN_ARG_MERGE_SURF + Merge Surfaces + + + CANRECPLUGIN_ARG_MERGE_CURVES + Merge Curves + + + CANRECPLUGIN_ARG_OBJ + Object + + + CANRECPLUGIN_ARG_TOLERANCE + Tolerance + + + diff --git a/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_ja.ts b/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_ja.ts new file mode 100644 index 0000000..62d5051 --- /dev/null +++ b/src/CANRECPLUGINGUI/resources/CANRECPlugin_msg_ja.ts @@ -0,0 +1,66 @@ + + + + + @default + + TOP_CANONICALRECOGNITION + Canonical Recognition + + + MEN_CANONICALRECOGNITION + Canonical Recognition + + + STB_CANONICALRECOGNITION + Canonical Recognition + + + + CANRECPluginGUI_CanonicalRecognitionDlg + + CANONICALRECOGNITION_CANONICALRECOGNITION_TITLE + Canonical Recognition Construction + + + GEOM_CANONICALRECOGNITION + Canonical Recognition + + + GEOM_CANONICALRECOGNITION_NAME + Canonical recognition + + + GEOM_CANONICALRECOGNITION_RESULT + Result name + + + GEOM_CANONICALRECOGNITION_ARG + Nodes + + + CANRECPLUGIN_NAME + Name + + + CANRECPLUGIN_ARGUMENTS + Arguments + + + CANRECPLUGIN_ARG_MERGE_SURF + Merge Surfaces + + + CANRECPLUGIN_ARG_MERGE_CURVES + Merge Curves + + + CANRECPLUGIN_ARG_OBJ + Object + + + CANRECPLUGIN_ARG_TOLERANCE + Tolerance + + + diff --git a/src/CANRECPLUGIN_PY/CANRECPluginBuilder.py b/src/CANRECPLUGIN_PY/CANRECPluginBuilder.py new file mode 100644 index 0000000..e4c9c01 --- /dev/null +++ b/src/CANRECPLUGIN_PY/CANRECPluginBuilder.py @@ -0,0 +1,76 @@ +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +## +# @package CANRECPluginBuilder +# Python API for the CANRECPLUGIN geometry plug-in module. + +from CANRECPlugin import ICanRecOperations + +# Engine Library Name +__libraryName__ = "CANRECPluginEngine" + +## Get Canonical recognition plugin operations interface +# @return an instance of Canonical recognition plugin operations interface +def GetCANRECOperations(self): + """ + Get Canonical recognition plugin operations interface. + + Returns: + An instance of Canonical recognition plugin operations interface + """ + anOp = self.GetPluginOperations(self.myStudyId, __libraryName__) + return anOp._narrow(ICanRecOperations) + +## Perform, if possible, conversion of NURBS (B-Spline, Bezier) geometry to canonical (analytical) form. +# @param theObj the input object (solid, compound, compsolid). +# @param theMergeSurf the flag to switch on/off merging surfaces in the result shape. +# @param theMergeCurves the flag to switch on/off merging curves in the result shape. +# @param theTolerance the tolerance of the canonical recognition operation. +# @param theName object name when specified, this parameter is used +# for result publication in the study. Otherwise, if automatic +# publication is switched on, default value is used for result name. +# +# @return New GEOM_Object, containing the canonical recognition of the input object. +def MakeCanonicalRecognition(self, theObj, theMergeSurf, theMergeCurves, + theTolerance=0.01, theName=None): + """ + Perform, if possible, conversion of NURBS (B-Spline, Bezier) geometry to canonical (analytical) form. + + Parameters: + theObj the input object (solid, compound, compsolid). + theMergeSurf the flag to switch on/off merging surfaces in the result shape. + theMergeCurves the flag to switch on/off merging curves in the result shape. + theTolerance the tolerance of the canonical recognition operation. + theName object name when specified, this parameter is used + for result publication in the study. Otherwise, if automatic + publication is switched on, default value is used for result name. + + Returns: + New GEOM_Object, containing the canonical recognition of the input object. + """ + from salome.geom.geomBuilder import ParseParameters, RaiseIfFailed + anOp = GetCANRECOperations(self) + theMergeSurf, theMergeCurves, theTolerance, Parameters = ParseParameters(theMergeSurf, theMergeCurves, theTolerance) + anObj = anOp.MakeCanonicalRecognition(theObj, theMergeSurf, theMergeCurves, theTolerance) + RaiseIfFailed("MakeCanonicalRecognition", anOp) + self._autoPublish(anObj, theName, "canonical") + anOp.UnRegister() + return anObj diff --git a/src/CANRECPLUGIN_PY/CMakeLists.txt b/src/CANRECPLUGIN_PY/CMakeLists.txt new file mode 100644 index 0000000..b410ae6 --- /dev/null +++ b/src/CANRECPLUGIN_PY/CMakeLists.txt @@ -0,0 +1,31 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +# --- scripts --- + +# scripts / static +SET(_scripts + __init__.py + CANRECPluginBuilder.py +) + +# --- rules --- + +# install scripts +SALOME_INSTALL_SCRIPTS("${_scripts}" ${SALOME_INSTALL_PYTHON}/salome/CANRECPlugin DEF_PERMS) diff --git a/src/CANRECPLUGIN_PY/__init__.py b/src/CANRECPLUGIN_PY/__init__.py new file mode 100644 index 0000000..4d80ac4 --- /dev/null +++ b/src/CANRECPLUGIN_PY/__init__.py @@ -0,0 +1,22 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +## +# @package CANRECPLUGINBuilder +# Python API for the CANRECPLUGIN geometry plug-in module. diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..13af050 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,24 @@ +# Copyright (C) 2014-2015 OPEN CASCADE +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +ADD_SUBDIRECTORY(CANRECPLUGINEngine) +ADD_SUBDIRECTORY(CANRECPLUGIN_PY) +IF(SALOME_BUILD_GUI) + ADD_SUBDIRECTORY(CANRECPLUGINGUI) +ENDIF(SALOME_BUILD_GUI) -- 2.39.2