Next version

First version

CMakeLists.txt

@@ -56,6 +56,20 @@ set_property (GLOBAL PROPERTY OCC_VERSION_MAJOR ${OCC_VERSION_MAJOR})
 set_property (GLOBAL PROPERTY OCC_VERSION_MINOR ${OCC_VERSION_MINOR})
 set_property (GLOBAL PROPERTY OCC_VERSION_MAINTENANCE ${OCC_VERSION_MAINTENANCE})
 
+# set soversion variable determining compatibility version on platforms with symlinks
+# 0 - for empty, 1 - for major, 2 - for major.minor, 3 - for major.minor.maintenance
+if (NOT BUILD_SOVERSION_NUMBERS)
+  set (BUILD_SOVERSION_NUMBERS "0" CACHE STRING "${BUILD_SOVERSION_NUMBERS_DESCR}" FORCE)
+  SET_PROPERTY(CACHE BUILD_SOVERSION_NUMBERS PROPERTY STRINGS 0 1 2 3)
+
+  # update default state of soversion on different platforms
+  if (WIN32 OR ANDROID OR EMSCRIPTEN)
+    set (BUILD_SOVERSION_NUMBERS 0)
+  else()
+    set (BUILD_SOVERSION_NUMBERS 2)
+  endif()
+endif()
+
 set (INSTALL_TEST_CASES OFF CACHE BOOL "${INSTALL_TEST_CASES_DESCR}")
 
 # Regeneration of OCCT resource files
@@ -1225,7 +1239,7 @@ foreach (OCCT_CONFIGURATION ${CMAKE_CONFIGURATION_TYPES})
 endforeach()
 # install OpenCASCADE config file with compile definitions and C/C++ flags ONLY for current configuration
 install (CODE "string (TOLOWER \"\${CMAKE_INSTALL_CONFIG_NAME}\" CMAKE_INSTALL_CONFIG_NAME_LOWER)")
-install (CODE "configure_file(\"${CMAKE_BINARY_DIR}/OpenCASCADECompileDefinitionsAndFlags-\${CMAKE_INSTALL_CONFIG_NAME_LOWER}.cmake\" \"${INSTALL_DIR}/${INSTALL_DIR_CMAKE}/OpenCASCADECompileDefinitionsAndFlags-\${CMAKE_INSTALL_CONFIG_NAME_LOWER}.cmake\" COPYONLY)")
+install (CODE "file(INSTALL FILES \"${CMAKE_BINARY_DIR}/OpenCASCADECompileDefinitionsAndFlags-\${CMAKE_INSTALL_CONFIG_NAME_LOWER}.cmake\" DESTINATION \"${INSTALL_DIR}/${INSTALL_DIR_CMAKE}/\" TYPE FILE)")
 
 foreach (OCCT_MODULE ${OCCT_MODULES})
   if (BUILD_MODULE_${OCCT_MODULE})

adm/UDLIST

@@ -454,6 +454,7 @@ t TKRWMesh
 n RWGltf
 n RWMesh
 n RWObj
+n RWPly
 n DFBrowser
 n DFBrowserPane
 n DFBrowserPaneXDE

adm/cmake/occt_defs_flags.cmake

@@ -25,6 +25,9 @@ if (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
 endif()
 
 if (MSVC)
+  # suppress C26812 on VS2019/C++20 (prefer 'enum class' over 'enum')
+  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fp:precise /wd\"26812\"")
+  # suppress warning on using portable non-secure functions in favor of non-portable secure ones
   add_definitions (-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE)
 else()
   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions -fPIC")

adm/cmake/occt_toolkit.cmake

@@ -255,7 +255,8 @@ else()
            EXPORT OpenCASCADE${CURRENT_MODULE}Targets
            RUNTIME DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}"
            ARCHIVE DESTINATION "${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}"
-           LIBRARY DESTINATION "${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}")
+           LIBRARY DESTINATION "${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}"
+           INCLUDES DESTINATION ${INSTALL_DIR_INCLUDE})
 
   if (NOT WIN32)
     if (BUILD_SHARED_LIBS AND NOT "${BUILD_SHARED_LIBRARY_NAME_POSTFIX}" STREQUAL "")
@@ -280,14 +281,17 @@ get_property (OCC_VERSION_MAJOR GLOBAL PROPERTY OCC_VERSION_MAJOR)
 get_property (OCC_VERSION_MINOR GLOBAL PROPERTY OCC_VERSION_MINOR)
 get_property (OCC_VERSION_MAINTENANCE GLOBAL PROPERTY OCC_VERSION_MAINTENANCE)
 
-if (ANDROID)
-  # do not append version to the filename
-  set_target_properties (${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${PRECOMPILED_DEFS}")
-else()
-  set_target_properties (${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${PRECOMPILED_DEFS}"
-                                                    SOVERSION     "${OCC_VERSION_MAJOR}"
-                                                    VERSION       "${OCC_VERSION_MAJOR}.${OCC_VERSION_MINOR}.${OCC_VERSION_MAINTENANCE}")
+set (OCC_SOVERSION "")
+if (BUILD_SOVERSION_NUMBERS GREATER 2)
+  set (OCC_SOVERSION "${OCC_VERSION_MAJOR}.${OCC_VERSION_MINOR}.${OCC_VERSION_MAINTENANCE}")
+elseif (BUILD_SOVERSION_NUMBERS GREATER 1)
+  set (OCC_SOVERSION "${OCC_VERSION_MAJOR}.${OCC_VERSION_MINOR}")
+elseif (BUILD_SOVERSION_NUMBERS GREATER 0)
+  set (OCC_SOVERSION "${OCC_VERSION_MAJOR}")
 endif()
+set_target_properties (${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${PRECOMPILED_DEFS}"
+                                                  SOVERSION     "${OCC_SOVERSION}"
+                                                  VERSION       "${OCC_VERSION_MAJOR}.${OCC_VERSION_MINOR}.${OCC_VERSION_MAINTENANCE}")
 
 set (USED_TOOLKITS_BY_CURRENT_PROJECT)
 set (USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT)

adm/cmake/vardescr.cmake

@@ -28,6 +28,9 @@ Applies only for Debug configuration.")
 set (BUILD_SHARED_LIBRARY_NAME_POSTFIX_DESCR
 "Append the postfix to names of output libraries")
 
+set (BUILD_SOVERSION_NUMBERS_DESCR
+"Version numbers to put into SONAME: 0 - for empty, 1 - for major, 2 - for major.minor, 3 - for major.minor.maintenance")
+
 set (BUILD_RELEASE_DISABLE_EXCEPTIONS_DESCR
 "Disables exceptions like Standard_OutOfRange in Release builds.
 Defines No_Exception macros for Release builds when enabled (default).

adm/qmake/OccToolkit.pri

@@ -132,21 +132,31 @@ for (aPackage, aPackages) {
   }
 }
 
-# extend clean with versioned .so files
 !win32 {
   aVerList = $$split(VERSION, ".")
   aVerMaj = $$member(aVerList, 0)
   aVerMin = $$member(aVerList, 1)
   aVerMic = $$member(aVerList, 2)
+
   equals(TEMPLATE, app) {
     QMAKE_CLEAN += $$DESTDIR/$${TARGET}
   } else {
     mac {
+      # override qmake soname versionong logic
+      QMAKE_LFLAGS_SONAME =
+      QMAKE_LFLAGS += -Wl,-soname=lib$${TARGET}.dylib.$${aVerMaj}.$${aVerMin}
+
+      # extend clean with versioned .dylib files
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.dylib
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.$${aVerMaj}.dylib
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.$${aVerMaj}.$${aVerMin}.dylib
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.$${aVerMaj}.$${aVerMin}.$${aVerMic}.dylib
     } else {
+      # override qmake soname versionong logic
+      QMAKE_LFLAGS_SONAME =
+      QMAKE_LFLAGS += -Wl,-soname=lib$${TARGET}.so.$${aVerMaj}.$${aVerMin}
+
+      # extend clean with versioned .so files
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.so
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.so.$${aVerMaj}
       QMAKE_CLEAN += $$DESTDIR/lib$${TARGET}.so.$${aVerMaj}.$${aVerMin}

adm/templates/template.vc10

@@ -100,7 +100,7 @@
       <ProgramDataBaseFileName>.\..\..\..\win32\__VCVER__\obj\__TKNAM__/</ProgramDataBaseFileName>
       <WarningLevel>Level4</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <FloatingPointModel>Precise</FloatingPointModel>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       __VCMPL32__
@@ -148,7 +148,7 @@
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <FloatingPointModel>Precise</FloatingPointModel>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
@@ -196,7 +196,7 @@
       <ProgramDataBaseFileName>.\..\..\..\win64\__VCVER__\obj\__TKNAM__/</ProgramDataBaseFileName>
       <WarningLevel>Level4</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <FloatingPointModel>Precise</FloatingPointModel>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       __VCMPL64__
@@ -244,7 +244,7 @@
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <FloatingPointModel>Precise</FloatingPointModel>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>

adm/templates/template.vc10x

@@ -95,7 +95,7 @@
       <ProgramDataBaseFileName>.\..\..\..\win32\__VCVER__\obj\__XQTNAM__/</ProgramDataBaseFileName>
       <WarningLevel>Level4</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <FloatingPointModel>Precise</FloatingPointModel>__VCMPL32__
     </ClCompile>
     <ResourceCompile>
@@ -140,7 +140,7 @@
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <FloatingPointModel>Precise</FloatingPointModel>__VCMPL32__
     </ClCompile>
@@ -185,7 +185,7 @@
       <ProgramDataBaseFileName>.\..\..\..\win64\__VCVER__\obj\__XQTNAM__/</ProgramDataBaseFileName>
       <WarningLevel>Level4</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <FloatingPointModel>Precise</FloatingPointModel>__VCMPL64__
     </ClCompile>
     <ResourceCompile>
@@ -229,7 +229,7 @@
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
-      <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>26812</DisableSpecificWarnings>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <FloatingPointModel>Precise</FloatingPointModel>__VCMPL64__
     </ClCompile>

dox/build/build_3rdparty/building_3rdparty.md

@@ -2,60 +2,48 @@
 ==============================================
 @tableofcontents
 
-On Windows, the easiest way to install third-party libraries is to download archive with pre-built binaries from https://opencascade.com/content/3rd-party-components.
-On Linux and OS X, it is recommended to use the version installed in the system natively.
+On Windows, the easiest way to install third-party libraries is to download archive with pre-built binaries from https://dev.opencascade.org/resources/download/3rd-party-components.
+On Linux and macOS, it is recommended to use the version installed in the system natively.
 
 @section dev_guides__building_3rdparty_win_1 Windows
 
-This document presents guidelines for building third-party products used by Open CASCADE Technology (OCCT) and samples on Windows platform. It is assumed that you are already familiar with MS Visual Studio / Visual C++. 
+This section presents guidelines for building third-party products used by Open CASCADE Technology (OCCT) and samples on Windows platform.
+It is assumed that you are already familiar with MS Visual Studio / Visual C++.
 
-You need to use the same version of MS Visual Studio for building all third-party products and OCCT itself, in order to receive a consistent set of run-time binaries. 
+You need to use the same version of MS Visual Studio for building all third-party products and OCCT itself, in order to receive a consistent set of runtime binaries.
 
-The links for downloading the third-party products are available at https://opencascade.com/content/3rd-party-components.
-
-There are two types of third-party products used  by OCCT: 
-
-* Mandatory  products: 
-	* Tcl/Tk 8.5 -- 8.6;
-	* FreeType 2.4.10 -- 2.5.3.
-* Optional  products:
-	* TBB 3.x -- 4.x;
-	* FreeImage 3.14.1 -- 3.16.0;
-	* VTK 6.1.0.
-
-It is recommended to create a separate new folder on your workstation, where you will unpack the downloaded archives of the third-party  products, and where you will build these products (for example, *c:\\occ3rdparty*). 
-
-Further in this document, this folder is referred to as *3rdparty*. 
+It is recommended to create a separate new folder on your workstation, where you will unpack the downloaded archives of the third-party products, and where you will build these products (for example, `c:/occ3rdparty`).
+Further in this document, this folder is referred to as `3rdparty`.
 
 @subsection dev_guides__building_3rdparty_win_2 Tcl/Tk
 
 Tcl/Tk is required for DRAW test harness.
 
 **Installation from sources: Tcl**
-  
+
 Download the necessary archive from https://www.tcl.tk/software/tcltk/download.html and unpack it.
   
-1. In the *win* sub-directory, edit file *buildall.vc.bat*:
+1. In the `win` sub-directory, edit file `buildall.vc.bat`:
 
-   * Edit the line "call ... vcvars32.bat" to have correct path to the version of Visual Studio to be used for building, for instance:
+   * Edit the line `"call ... vcvars32.bat"` to have correct path to the version of Visual Studio to be used for building, for instance:
 
          call "%VS80COMNTOOLS%\vsvars32.bat"
 
      If you are building 64-bit version, set environment accordingly, e.g.:
 
          call "%VS80COMNTOOLS%\..\..\VC\vcvarsall.bat" amd64
-     
-   * Define variable *INSTALLDIR* pointing to directory where Tcl/Tk will be installed, e.g.:
+
+   * Define variable `INSTALLDIR` pointing to directory where Tcl/Tk will be installed, e.g.:
 
          set INSTALLDIR=D:\OCCT\3rdparty\tcltk-86-32
 
-   * Add option *install* to the first command line calling *nmake*:
+   * Add option `install` to the first command line calling `nmake`:
 
          nmake -nologo -f makefile.vc release htmlhelp install %1
 
-   * Remove second call to *nmake* (building statically linked executable)
+   * Remove second call to `nmake` (building statically linked executable)
 
-2. Edit file *rules.vc* replacing line 
+2. Edit file `rules.vc` replacing line
 
        SUFX	    = tsgx
 
@@ -65,21 +53,18 @@ Download the necessary archive from https://www.tcl.tk/software/tcltk/download.h
 
    This is to avoid extra prefix 't' in the library name, which is not recognized by default by OCCT build tools.
 
-
 3. By default, Tcl uses dynamic version of run-time library (MSVCRT), which must be installed on the system where Tcl will be used.
    You may wish to link Tcl library with static version of run-time to avoid this dependency.
    For that:
 
-   * Edit file *makefile.vc* replacing strings "crt = -MD" by "crt = -MT"
+   * Edit file `makefile.vc` replacing strings `"crt = -MD"` by `"crt = -MT"`
 
-   * Edit source file *tclMain.c* (located in folder *generic*) commenting out forward declaration of function *isatty()*.
+   * Edit source file `tclMain.c` (located in folder `generic`) commenting out forward declaration of function `isatty()`.
 
+4. In the command prompt, run `buildall.vc.bat`<br>
+   You might need to run this script twice to have `tclsh` executable installed; check subfolder `bin` of specified installation path to verify this.
 
-4. In the command prompt, run *buildall.vc.bat*
-
-   You might need to run this script twice to have *tclsh* executable installed; check subfolder *bin* of specified installation path to verify this.
-
-5. For convenience of use, we recommend making a copy of *tclsh* executable created in subfolder *bin* of *INSTALLDIR* and named with Tcl version number suffix, as *tclsh.exe* (with no suffix)
+5. For convenience of use, we recommend making a copy of `tclsh` executable created in subfolder `bin` of `INSTALLDIR` and named with Tcl version number suffix, as `tclsh.exe` (with no suffix)
 
        > cd D:\OCCT\3rdparty\tcltk-86-32\bin
        > cp tclsh86.exe tclsh.exe
@@ -87,190 +72,153 @@ Download the necessary archive from https://www.tcl.tk/software/tcltk/download.h
 **Installation from sources: Tk**
   
 Download the necessary archive from https://www.tcl.tk/software/tcltk/download.html and unpack it.
+Apply the same steps as described for building Tcl above, with the same `INSTALLDIR`.
+Note that Tk produces its own executable, called `wish`.
 
-Apply the same steps as described for building Tcl above, with the same INSTALLDIR.
-Note that Tk produces its own executable, called *wish*. 
-
-You might need to edit default value of *TCLDIR* variable defined in *buildall.vc.bat* (should be not necessary if you unpack both Tcl and Tk sources in the same folder).
+You might need to edit default value of `TCLDIR` variable defined in `buildall.vc.bat` (should be not necessary if you unpack both Tcl and Tk sources in the same folder).
 
 @subsection dev_guides__building_3rdparty_win_2_2 FreeType
 
-FreeType is required for text display in a 3D viewer. You can download its sources from https://sourceforge.net/projects/freetype/files/
+FreeType is required for text display in a 3D viewer.
+You can download its sources from https://freetype.org/
 
-### The building procedure
+1. Unpack the downloaded archive of FreeType product into the `3rdparty` folder.
+   As a result, you will get a folder named, for example, `3rdparty/freetype-2.4.10`.
+   Further in this document, this folder is referred to as `freetype`.
 
-1. Unpack the downloaded archive of FreeType product into the *3rdparty*  folder. As a result, you will get a folder named, for example, *3rdparty\\freetype-2.4.10*.  Further in this document, this folder is referred to as *freetype*. 
-   
-2. Open the solution file *freetype\\builds\\win32\\vc20xx\\freetype.sln*  in Visual Studio. Here *vc20xx* stands for your version of Visual Studio. 
+2. Open the solution file `freetype/builds/win32/vc20xx/freetype.sln` in Visual Studio.
+   Here `vc20xx` stands for your version of Visual Studio.
 
-3. Select the configuration to build: either Debug or Release. 
+3. Select the configuration to build: either `Debug` or `Release`.
 
-4. Build  the *freetype* project. 
+4. Build the `freetype` project.<br>
+   As a result, you will get a `freetype` import library (`.lib`) in the `freetype/obj/win32/vc20xx` folder.
 
-   As a result, you will get a  freetype import library (.lib) in the *freetype\\obj\\win32\\vc20xx*  folder.  
-
-
-5. If you build FreeType for a 64 bit platform, select in the main menu **Build - Configuration Manager**  and add *x64* platform to the solution configuration by copying the settings from Win32 platform: 
+5. If you build FreeType for a 64 bit platform, select in the main menu `Build - Configuration Manager`
+   and add `x64` platform to the solution configuration by copying the settings from `Win32` platform:
 
    @figure{/build/build_3rdparty/images/3rdparty_image001.png}
 
-   Update the value of the Output File for  x64 configuration: 
+   Update the value of the Output File for `x64` configuration:
 
    @figure{/build/build_3rdparty/images/3rdparty_image003.png}
 
-   Build the *freetype* project. 
+   Build the `freetype` project.<br>
+   As a result, you will obtain a 64 bit import library (`.lib`) file in the `freetype/x64/vc20xx` folder.
+   To build FreeType as a dynamic library (`.dll`) follow steps 6, 7 and 8 of this procedure.
 
-   As a result, you will obtain a 64 bit import library (.lib) file in the *freetype\\x64\\vc20xx*  folder. 
+6. Open menu Project-> Properties-> Configuration  Properties-> General and change option `Configuration Type` to `Dynamic Library (.dll)`.
+7. Edit file `freetype/include/freetype/config/ftoption.h`:<br>
+   in line 255, uncomment the definition of macro `FT_EXPORT` and change it as follows:
 
-   To build FreeType as a dynamic library (.dll) follow steps 6, 7 and 8 of this procedure. 
+       #define FT_EXPORT(x)   __declspec(dllexport) x
 
-6. Open menu Project-> Properties-> Configuration  Properties-> General and change option **Configuration Type** to *Dynamic  Library (.dll)*. 
-7. Edit file *freetype\\include\\freetype\\config\\ftoption.h*:  
-  
-   in line 255, uncomment the definition of macro *FT_EXPORT* and change it as follows: 
+8. Build the `freetype` project.<br>
+   As a result, you will obtain the files of the import library (`.lib`) and the dynamic library (`.dll`) in folders `freetype/objs/release` or `freetype/objs/debug`.
+   If you build for a 64 bit platform, follow step 5 of the procedure.
 
-       #define FT_EXPORT(x)   __declspec(dllexport) x 
-
-8. Build  the *freetype* project. 
-
-   As a result, you will obtain the files of the import  library (.lib) and the dynamic library (.dll)   in folders <i>freetype  \\objs\\release</i> or <i>\\objs\\debug </i>. 
-   
-   If you build for a 64 bit platform, follow step 5 of the procedure. 
-
-   To facilitate the use of FreeType libraries in OCCT with minimal adjustment of build procedures, it is recommended to copy the include files and libraries of FreeType into a separate folder, named according to the pattern: *freetype-compiler-bitness-building mode*, where: 
-   * **compiler** is *vc8* or *vc9* or *vc10* or *vc11*; 
-   * **bitness**  is *32* or *64*;
-   * **building mode** is *opt* (for Release) or *deb* (for Debug). 
-    
-   The *include* subfolder should be copied as is, while libraries should be renamed to *freetype.lib* and *freetype.dll* (suffixes removed) and placed to subdirectories *lib *and  *bin*, respectively. If the Debug configuration is built, the Debug libraries should be put into subdirectories *libd* and *bind*. 
+   To facilitate the use of FreeType libraries in OCCT with minimal adjustment of build procedures,
+   it is recommended to copy the include files and libraries of FreeType into a separate folder, named according to the pattern `freetype-compiler-bitness-building mode`, where:
+   * `compiler` is `vc8` or `vc9` or `vc10` or `vc11`;
+   * `bitness`  is `32` or `64`;
+   * `building mode` is `opt` (for `Release`) or `deb` (for `Debug`).
 
+   The `include` subfolder should be copied as is, while libraries should be renamed to `freetype.lib` and `freetype.dll` (suffixes removed) and placed to subdirectories `lib` and `bin`, respectively.
+   If the `Debug` configuration is built, the Debug libraries should be put into subdirectories `libd` and `bind`.
 
 @subsection dev_guides__building_3rdparty_win_3_1 TBB
 
-This third-party product is installed with binaries 
-from the archive that can be downloaded from https://github.com/intel/tbb.
-Go to the **Download** page, find the  release version you need  (e.g. *tbb30_018oss*) and pick the archive for Windows  platform. 
+This third-party product is installed with binaries from the archive that can be downloaded from https://github.com/intel/tbb.
+Go to the **Download** page, find the release version you need (e.g. `tbb30_018oss`) and pick the archive for Windows platform.
 
-Unpack the downloaded  archive of TBB product into the *3rdparty* folder. 
+Unpack the downloaded archive of TBB product into the `3rdparty` folder.
 
-Further in this document,  this folder is referred to as *tbb*. 
+Further in this document, this folder is referred to as `tbb`.
 
 @subsection dev_guides__building_3rdparty_win_3_3 FreeImage
 
-This third-party product should be built as a dynamically loadable library (.dll file). 
-You can download its sources from 
+This third-party product should be built as a dynamically loadable library (`.dll` file).
+You can download its sources from
 https://sourceforge.net/projects/freeimage/files/Source%20Distribution/
 
-### The building procedure: 
+1. Unpack the downloaded archive of FreeImage product into `3rdparty` folder.<br>
+   As a result, you should have a folder named `3rdparty/FreeImage`.
+   Rename it according to the rule: `freeimage-platform-compiler-building mode`, where
 
-1. Unpack the  downloaded archive of FreeImage product into *3rdparty* folder. 
-  
-   As a result, you should have a folder named *3rdparty\\FreeImage*. 
-  
-   Rename it according to the rule: *freeimage-platform-compiler-building  mode*, where 
-   
-   * **platform**  is *win32* or *win64*; 
-   * **compiler**  is *vc8* or *vc9* or *vc10* or *vc11*; 
-   * **building  mode** is *opt* (for release) or *deb* (for debug) 
+   * `platform`  is `win32` or `win64`;
+   * `compiler`  is `vc8` or `vc9` or `vc10` or `vc11`;
+   * `building mode` is *opt* (for release) or `deb` (for debug)
 
-   Further in this  document, this folder is referred to as *freeimage*. 
+   Further in this document, this folder is referred to as `freeimage`.
 
-2. Open the solution file *freeimage\\FreeImage.*.sln* in your Visual Studio. 
-  
-   If you use a Visual Studio version higher than VC++ 2008, apply conversion of the workspace. 
-   Such conversion should be suggested automatically by Visual  Studio. 
-    
-3. Select a  configuration to build. 
+2. Open the solution file `freeimage/FreeImage.*.sln` in your Visual Studio.<br>
+   If you use a Visual Studio version higher than VC++ 2008, apply conversion of the workspace.
+   Such conversion should be suggested automatically by Visual Studio.
 
-   - Choose **Release**  if you are building Release binaries. 
-   - Choose **Debug** if you are building  Debug binaries. 
+3. Select a configuration to build.
+   - Choose `Release` if you are building Release binaries.
+   - Choose `Debug` if you are building Debug binaries.
 
-   *Note:* 
+   *Note:*
+
+   If you want to build a debug version of FreeImage binaries then you need to rename the following files in FreeImage projects:
 
-   If you want to  build a debug version of FreeImage binaries then you need to rename the following files in FreeImage and FreeimagePlus projects:
-   
    Project -> Properties -> Configuration Properties -> Linker -> General -> Output File
 
-       FreeImage*d*.dll  to FreeImage.dll 
-       FreeImagePlus*d*.dll to FreeImagePlus.dll 
+       FreeImage*d*.dll  to FreeImage.dll
 
    Project -> Properties -> Configuration Properties -> Linker -> Debugging-> Generate Program Database File
 
-       FreeImage*d*.pdb  to FreeImage.pdb 
-       FreeImagePlus*d*.pdb to FreeImagePlus.pdb 
+       FreeImage*d*.pdb  to FreeImage.pdb
 
    Project -> Properties -> Configuration Properties -> Linker -> Advanced-Import Library
 
-       FreeImage*d*.lib  to FreeImage.lib 
-       FreeImagePlus*d*.lib  to FreeImagePlus.lib 
+       FreeImage*d*.lib  to FreeImage.lib
 
-   Project -> Properties -> Configuration Properties -> Build Events -> Post -> Build Event -> Command Line 
+   Project -> Properties -> Configuration Properties -> Build Events -> Post -> Build Event -> Command Line
 
-       FreeImage*d*.dll     to FreeImage.dll 
-       FreeImage*d*.lib     to FreeImage.lib 
-       FreeImagePlus*d*.dll to FreeImagePlus.dll 
-       FreeImagePlus*d*.lib to FreeImagePlus.lib 
+       FreeImage*d*.dll     to FreeImage.dll
+       FreeImage*d*.lib     to FreeImage.lib
 
-   Additionally, rename in project FreeImagePlus 
-   
-   Project -> Properties -> Configuration  Properties -> Linker -> Input -> Additional Dependencies 
+   Additionally, rename in project FreeImagePlus
 
-       from FreeImage*d*.lib to FreeImage.lib 
+   Project -> Properties -> Configuration  Properties -> Linker -> Input -> Additional Dependencies
 
-4. Select a platform to build. 
+       from FreeImage*d*.lib to FreeImage.lib
 
-   - Choose *Win32* if you are building for a 32 bit platform. 
-   - Choose *x64* if you are building for a 64 bit platform. 
+4. Select a platform to build.
+   - Choose `Win32` if you are building for a 32 bit platform.
+   - Choose `x64` if you are building for a 64 bit platform.
 
-5. Start the building process. 
-
-   As a result, you should have the  library files of FreeImage product  in *freeimage\\Dist* folder (*FreeImage.dll* and *FreeImage.lib*) and in *freeimage\\Wrapper\\FreeImagePlus\\dist* folder (*FreeImagePlus.dll* and *FreeImagePlus.lib*).
+5. Start the building process.<br>
+   As a result, you should have the library files of FreeImage product in `freeimage/Dist` folder (`FreeImage.dll` and `FreeImage.lib`).
 
 @subsection dev_guides__building_3rdparty_win_3_4 VTK
 
-VTK is an open-source, freely available software system for 3D computer graphics, image processing and visualization. VTK Integration Services component provides adaptation functionality for visualization of OCCT topological shapes by means of VTK library.
+VTK Integration Services component provides adaptation functionality for visualization of OCCT topological shapes by means of VTK library.
 
-### The building procedure:
-
-1. Download the necessary archive from https://www.vtk.org/VTK/resources/software.html and unpack it into *3rdparty* folder.
-
-   As a result, you will get a folder named, for example, <i>3rdparty\VTK-6.1.0.</i>
-
-   Further in this document, this folder is referred to as *VTK*.
+1. Download the necessary archive from https://www.vtk.org/VTK/resources/software.html and unpack it into `3rdparty` folder.<br>
+   As a result, you will get a folder named, for example, `3rdparty/VTK-6.1.0`.
+   Further in this document, this folder is referred to as `VTK`.
 
 2. Use CMake to generate VS projects for building the library:
-   - Start CMake-GUI and select VTK folder as source path, and the folder of your choice for VS project and intermediate build data.
+   - Start CMake-GUI and select `VTK` folder as source path, and the folder of your choice for VS project and intermediate build data.
    - Click **Configure**.
    - Select the VS version to be used from the ones you have installed (we recommend using VS 2015) and the architecture (32 or 64-bit).
-   - Generate VS projects with default CMake options. The open solution *VTK.sln* will be generated in the build folder.
+   - Generate VS projects with default CMake options. The open solution `VTK.sln` will be generated in the build folder.
 
 3. Build project VTK in Release mode.
 
-
 @section build_3rdparty_linux Linux
 
-This document presents additional guidelines for building third-party 
-products used by Open CASCADE Technology and samples on Linux platform. 
-
-The links for downloading the third-party products are available on the web site at 
-https://opencascade.com/content/3rd-party-components.
-
-There are two types of third-party products, which are  necessary to build OCCT: 
-  
-* Mandatory  products: 
-	* Tcl/Tk 8.5 - 8.6;  
-	* FreeType 2.4.10 - 2.5.3;
-* Optional  products: 
-	* TBB 3.x - 4.x;
-	* FreeImage 3.14.1 - 3.16.0;
-	* VTK 6.1.0.
+This section presents additional guidelines for building third-party products used by Open CASCADE Technology and samples on Linux platform.
 
 @subsection dev_guides__building_3rdparty_linux_4 Installation From Official Repositories
 
 **Debian-based distributives**
 
-All 3rd-party products required for building of OCCT could be installed
-from official repositories. You may install them from console using apt-get utility:
+All 3rd-party products required for building of OCCT could be installed from official repositories.
+You may install them from console using apt-get utility:
 
     sudo apt-get install tcllib tklib tcl-dev tk-dev libfreetype-dev libx11-dev libgl1-mesa-dev libfreeimage-dev
     sudo apt-get install rapidjson-dev libdraco-dev
@@ -279,148 +227,148 @@ Building is possible with C++ compliant compiler:
 
     sudo apt-get install g++
 
-@subsection dev_guides__building_3rdparty_linux_2_1 Tcl/Tk 
+@subsection dev_guides__building_3rdparty_linux_2_1 Tcl/Tk
 
-Tcl/Tk is required for DRAW test harness. 
+Tcl/Tk is required for DRAW test harness.
 
 **Installation from sources: Tcl**
-  
+
 Download the necessary archive from https://www.tcl.tk/software/tcltk/download.html and unpack it.
-  
-1. Enter the unix sub-directory of the directory where the Tcl source  files are located <i>(TCL_SRC_DIR)</i>. 
 
-       cd TCL_SRC_DIR/unix   
+1. Enter the `unix` sub-directory of the directory where the Tcl source files are located (`TCL_SRC_DIR`).
 
-2. Run the *configure* command:
+       cd TCL_SRC_DIR/unix
 
-       configure --enable-gcc  --enable-shared --enable-threads --prefix=TCL_INSTALL_DIR   
+2. Run the `configure` command:
 
-   For a 64 bit platform also add <i>--enable-64bit</i> option to the command line. 
-  
-3. If the configure command has finished successfully, start  the building process:
-  
-       make   
+       configure --enable-gcc  --enable-shared --enable-threads --prefix=TCL_INSTALL_DIR
 
-4. If building is finished successfully, start the installation of Tcl. 
-   All binary and service files of the product will be copied to the directory defined by *TCL_INSTALL_DIR* 
+   For a 64 bit platform also add `--enable-64bit` option to the command line.
 
-       make install   
+3. If the configure command has finished successfully, start the building process:
+
+       make
+
+4. If building is finished successfully, start the installation of Tcl.
+   All binary and service files of the product will be copied to the directory defined by `TCL_INSTALL_DIR`
+
+       make install
 
 **Installation from sources: Tk**
-  
+
 Download the necessary archive from https://www.tcl.tk/software/tcltk/download.html and unpack it.
   
-1. Enter the unix sub-directory of the directory where the Tk source files are located <i>(TK_SRC_DIR)</i> 
+1. Enter the `unix` sub-directory of the directory where the Tk source files are located (`TK_SRC_DIR`)
 
-       cd TK_SRC_DIR/unix   
+       cd TK_SRC_DIR/unix
 
-2. Run the configure command, where <i>TCL_LIB_DIR</i> is *TCL_INSTALL_DIR/lib*.
+2. Run the `configure` command, where `TCL_LIB_DIR` is `TCL_INSTALL_DIR/lib`.
 
-       configure --enable-gcc  --enable-shared --enable-threads --with-tcl=TCL_LIB_DIR  --prefix=TK_INSTALL_DIR   
+       configure --enable-gcc  --enable-shared --enable-threads --with-tcl=TCL_LIB_DIR  --prefix=TK_INSTALL_DIR
 
-   For a 64 bit platform also add <i>--enable-64bit</i> option to the  command line. 
+   For a 64 bit platform also add `--enable-64bit` option to the command line.
 
-3. If the configure command has finished successfully, start the building process: 
+3. If the configure command has finished successfully, start the building process:
 
-       make   
+       make
 
-4. If the building has finished successfully, start the installation of Tk. 
-   All binary and service files of the product will be copied 
-   to the directory defined by *TK_INSTALL_DIR* (usually it is *TCL_INSTALL_DIR*) 
+4. If the building has finished successfully, start the installation of Tk.
+   All binary and service files of the product will be copied
+   to the directory defined by `TK_INSTALL_DIR` (usually it is `TCL_INSTALL_DIR`)
 
-       make install   
+       make install
 
 @subsection dev_guides__building_3rdparty_linux_2_2 FreeType
 
-FreeType is required for text display in the 3D viewer. 
-Download the necessary archive from https://sourceforge.net/projects/freetype/files/ and unpack it.
-  
-1. Enter the directory where the source files of FreeType  are located <i>(FREETYPE_SRC_DIR)</i>. 
+FreeType is required for text display in the 3D viewer.
+Download the necessary archive from https://freetype.org/ and unpack it.
+
+1. Enter the directory where the source files of FreeType are located (`FREETYPE_SRC_DIR`).
 
        cd FREETYPE_SRC_DIR   
 
-2. Run the *configure* command: 
-  
-       configure  --prefix=FREETYPE_INSTALL_DIR   
+2. Run the `configure` command:
 
-   For a 64 bit platform also add <i>CFLAGS='-m64 -fPIC'  CPPFLAGS='-m64 -fPIC'</i> option to the command line. 
-    
-3. If the *configure* command has finished successfully, start  the building process: 
+       configure  --prefix=FREETYPE_INSTALL_DIR
 
-       make   
+   For a 64 bit platform also add `CFLAGS='-m64 -fPIC'  CPPFLAGS='-m64 -fPIC'` option to the command line.
 
-4. If the building has finished successfully, start the installation of FreeType. 
-   All binary and service files of the product will be copied to the directory defined by *FREETYPE_INSTALL_DIR* 
-    
-       make install   
+3. If the `configure` command has finished successfully, start the building process:
+
+       make
+
+4. If the building has finished successfully, start the installation of FreeType.
+   All binary and service files of the product will be copied to the directory defined by `FREETYPE_INSTALL_DIR`
+
+       make install
 
-    
 @subsection dev_guides__building_3rdparty_linux_3_1 TBB
 
-This third-party product is  installed with binaries from the archive that can be downloaded from https://github.com/intel/tbb.
-Go to the **Download** page, find the  release version you need and pick the archive for Linux platform.
+This third-party product is installed with binaries from the archive that can be downloaded from https://github.com/intel/tbb.
+Go to the **Download** page, find the release version you need and pick the archive for Linux platform.
 To install, unpack the downloaded archive of TBB product.
 
 @subsection dev_guides__building_3rdparty_linux_3_3 FreeImage
 
-Download the necessary archive from https://sourceforge.net/projects/freeimage/files/Source%20Distribution/
-and unpack it. The directory with unpacked sources is  further referred to as *FREEIMAGE_SRC_DIR*. 
-  
-1. Modify *FREEIMAGE_SRC_DIR/Source/OpenEXR/Imath/ImathMatrix.h*: 
-   In line 60 insert the following: 
+Download the necessary archive from https://sourceforge.net/projects/freeimage/files/Source%20Distribution/ and unpack it.
+The directory with unpacked sources is  further referred to as `FREEIMAGE_SRC_DIR`.
 
-       #include string.h   
+1. Modify `FREEIMAGE_SRC_DIR/Source/OpenEXR/Imath/ImathMatrix.h`:<br>
+   In line 60 insert the following:
 
-2. Enter the directory where the source files of FreeImage are located <i>(FREEIMAGE_SRC_DIR)</i>. 
-  
-       cd FREEIMAGE_SRC_DIR   
+       #include string.h
 
-3. Run the building process 
-  
-       make   
+2. Enter the directory where the source files of FreeImage are located (`FREEIMAGE_SRC_DIR`).
 
-4. Run the installation process 
+       cd FREEIMAGE_SRC_DIR
 
-   a. If you have the permission to write into directories <i>/usr/include</i> and <i>/usr/lib</i>, run the following command: 
+3. Run the building process
+
+       make
+
+4. Run the installation process
+
+   a. If you have the permission to write into directories `/usr/include` and `/usr/lib`, run the following command:
+
+          make install
+
+   b. If you do not have this permission, you need to modify file `FREEIMAGE_SRC_DIR/Makefile.gnu`:
 
-          make install   
-   b. If you do not have this permission, you need to modify file *FREEIMAGE_SRC_DIR/Makefile.gnu*: 
-  
       Change lines 7-9 from:
-  
-          DESTDIR ?= /   
-          INCDIR  ?= $(DESTDIR)/usr/include   
-          INSTALLDIR  ?= $(DESTDIR)/usr/lib   
 
-      to: 
+          DESTDIR ?= /
+          INCDIR  ?= $(DESTDIR)/usr/include
+          INSTALLDIR  ?= $(DESTDIR)/usr/lib
 
-          DESTDIR  ?= $(DESTDIR)   
-          INCDIR  ?= $(DESTDIR)/include   
-          INSTALLDIR  ?= $(DESTDIR)/lib   
-
-      Change lines 65-67 from: 
-
-          install  -m 644 -o root -g root $(HEADER) $(INCDIR)   
-          install  -m 644 -o root -g root $(STATICLIB) $(INSTALLDIR)   
-          install  -m 755 -o root -g root $(SHAREDLIB) $(INSTALLDIR)   
-  
       to:
 
-          install  -m 755 $(HEADER) $(INCDIR)   
-          install  -m 755 $(STATICLIB) $(INSTALLDIR)   
+          DESTDIR  ?= $(DESTDIR)
+          INCDIR  ?= $(DESTDIR)/include
+          INSTALLDIR  ?= $(DESTDIR)/lib
+
+      Change lines 65-67 from:
+
+          install  -m 644 -o root -g root $(HEADER) $(INCDIR)
+          install  -m 644 -o root -g root $(STATICLIB) $(INSTALLDIR)
+          install  -m 755 -o root -g root $(SHAREDLIB) $(INSTALLDIR)
+
+      to:
+
+          install  -m 755 $(HEADER) $(INCDIR)
+          install  -m 755 $(STATICLIB) $(INSTALLDIR)
           install  -m 755 $(SHAREDLIB) $(INSTALLDIR)
 
-      Change line 70 from: 
+      Change line 70 from:
 
           ldconfig
 
       to:
   
-          \#ldconfig   
-    
-   Then run the installation process by the following command: 
+          \#ldconfig
 
-        make DESTDIR=FREEIMAGE_INSTALL_DIR  install   
+   Then run the installation process by the following command:
+
+        make DESTDIR=FREEIMAGE_INSTALL_DIR  install
 
 5. Clean temporary files
 
@@ -428,201 +376,180 @@ and unpack it. The directory with unpacked sources is  further referred to as *F
 
 @subsection dev_guides__building_3rdparty_linux_3_4 VTK
 
-You can download VTK sources from https://www.vtk.org/VTK/resources/software.html
-
-### The building procedure:
-
 Download the necessary archive from https://www.vtk.org/VTK/resources/software.html and unpack it.
 
-1. Install or build *cmake* product from the source file.
-2. Start *cmake* in GUI mode with the directory where the source files of *VTK* are located:
+1. Install or build `cmake` product from the source file.
+2. Start `cmake` in GUI mode with the directory where the source files of *VTK* are located:
 
        ccmake VTK_SRC_DIR
 
-   * Press <i>[c]</i> to make the  initial configuration
-   * Define the necessary options in *VTK_INSTALL_PREFIX*
-   * Press <i>[c]</i> to make the final  configuration
-   * Press <i>[g]</i> to generate  Makefile and exit
+   * Press `[c]` to make the initial configuration
+   * Define the necessary options in `VTK_INSTALL_PREFIX`
+   * Press `[c]` to make the final configuration
+   * Press `[g]` to generate `Makefile` and exit
 
 3. Start the building of VTK:
 
        make
 
-4. Start the installation of VTK. Binaries will be installed according to the *VTK_INSTALL_PREFIX* option.
+4. Start the installation of VTK. Binaries will be installed according to the `VTK_INSTALL_PREFIX` option.
 
        make install
 
 @section build_3rdparty_macos Mac OS X
 
-This document presents additional guidelines for building third-party products 
-used by Open CASCADE Technology and samples on Mac OS X platform (10.6.4  and later). 
+This section presents additional guidelines for building third-party products
+used by Open CASCADE Technology and samples on Mac OS X platform (10.6.4 and later).
 
-The links for downloading the third-party products are available at https://opencascade.com/content/3rd-party-components.
+@subsection dev_guides__building_3rdparty_osx_2_1 Tcl/Tk
 
-There are two types of third-party products, which are  necessary to build OCCT: 
-  
-* Mandatory  products: 
-	* Tcl/Tk 8.5 - 8.6;
-	* FreeType 2.4.10 - 2.5.3.
-* Optional  products: 
-	* TBB 3.x - 4.x;
-	* FreeImage 3.14.1 - 3.16.0
-  
+Tcl/Tk is required for DRAW test harness.
 
-@subsection dev_guides__building_3rdparty_osx_2_1 Tcl/Tk 8.5 
-
-Tcl/Tk is required for DRAW test harness. Version 8.5 or  8.6 can be used with OCCT. 
-
-**Installation from sources: Tcl 8.5**
+**Installation from sources: Tcl**
 
 Download the necessary archive from https://www.tcl.tk/software/tcltk/download.html and unpack it.
 
-1. Enter the *macosx* sub-directory of the directory where the Tcl source files are located <i>(TCL_SRC_DIR)</i>. 
+1. Enter the `macosx` sub-directory of the directory where the Tcl source files are located (`TCL_SRC_DIR`).
 
-       cd TCL_SRC_DIR/macosx   
+       cd TCL_SRC_DIR/macosx
 
-2. Run the *configure* command 
+2. Run the `configure` command
 
-       configure --enable-gcc  --enable-shared --enable-threads --prefix=TCL_INSTALL_DIR   
+       configure --enable-gcc  --enable-shared --enable-threads --prefix=TCL_INSTALL_DIR
 
-   For a 64 bit platform also add <i>--enable-64bit</i> option to the command line. 
+   For a 64 bit platform also add `--enable-64bit` option to the command line.
 
-3. If the *configure* command has finished successfully, start the building process 
+3. If the `configure` command has finished successfully, start the building process
 
-       make   
-  
-4. If building is finished successfully, start the installation of Tcl. 
-   All binary and service files of the product will be copied to the directory defined by *TCL_INSTALL_DIR*. 
+       make
 
-       make install   
+4. If building is finished successfully, start the installation of Tcl.
+   All binary and service files of the product will be copied to the directory defined by `TCL_INSTALL_DIR`.
 
-**Installation from sources: Tk 8.5**
+       make install
+
+**Installation from sources: Tk**
 
 Download the necessary archive from https://www.tcl.tk/software/tcltk/download.html and unpack it.
 
-1. Enter the *macosx* sub-directory of the directory where the  source files of Tk are located <i>(TK_SRC_DIR)</i>. 
+1. Enter the `macosx` sub-directory of the directory where the source files of Tk are located (`TK_SRC_DIR`).
 
-       cd TK_SRC_DIR/macosx   
+       cd TK_SRC_DIR/macosx
 
-2. Run the *configure* command, where TCL_LIB_DIR is  TCL_INSTALL_DIR/lib 
+2. Run the `configure` command, where `TCL_LIB_DIR` is `TCL_INSTALL_DIR/lib`
 
-       configure --enable-gcc --enable-shared --enable-threads --with-tcl=TCL_LIB_DIR --prefix=TK_INSTALL_DIR   
+       configure --enable-gcc --enable-shared --enable-threads --with-tcl=TCL_LIB_DIR --prefix=TK_INSTALL_DIR
 
-	For a 64 bit platform also add <i>--enable-64bit</i> option to the  command line. 
+   For a 64 bit platform also add `--enable-64bit` option to the command line.
 
-3. If the *configure* command has finished successfully, start the building process:
+3. If the `configure` command has finished successfully, start the building process:
 
-       make   
+       make
 
-4. If the building has finished successfully, start the  installation of Tk. All binary and service files of the product will be copied to the directory defined by *TK_INSTALL_DIR* (usually it is TCL_INSTALL_DIR) 
+4. If the building has finished successfully, start the installation of Tk.
+   All binary and service files of the product will be copied to the directory defined by `TK_INSTALL_DIR` (usually it is `TCL_INSTALL_DIR`).
 
-       make install   
+       make install
 
-@subsection dev_guides__building_3rdparty_osx_2_2 FreeType 2.4.10
-  
-FreeType is required for text display in the 3D viewer. 
+@subsection dev_guides__building_3rdparty_osx_2_2 FreeType
 
-Download the necessary archive from https://sourceforge.net/projects/freetype/files/ and unpack it.
+FreeType is required for text display in the 3D viewer.
+Download the necessary archive from https://freetype.org/ and unpack it.
 
-1. Enter the directory where the source files of FreeType  are located <i>(FREETYPE_SRC_DIR)</i>. 
+1. Enter the directory where the source files of FreeType are located (`FREETYPE_SRC_DIR`).
 
-       cd FREETYPE_SRC_DIR   
+       cd FREETYPE_SRC_DIR
 
-2. Run the *configure* command 
-  
-       configure  --prefix=FREETYPE_INSTALL_DIR   
+2. Run the `configure` command
 
-   For a 64 bit platform also add <i>CFLAGS='-m64 -fPIC'  CPPFLAGS='-m64 -fPIC'</i> option to the command line. 
+       configure  --prefix=FREETYPE_INSTALL_DIR
 
-3. If the *configure* command has finished successfully, start  the building process 
+   For a 64 bit platform also add `CFLAGS='-m64 -fPIC'  CPPFLAGS='-m64 -fPIC'` option to the command line.
 
-       make   
+3. If the `configure` command has finished successfully, start the building process
 
-4. If building has finished successfully, start the installation of FreeType. 
-   All binary and service files of the product will be copied to the directory defined by *FREETYPE_INSTALL_DIR*.
+       make
 
-       make install   
-    
-@subsection dev_guides__building_3rdparty_osx_3_1 TBB 3.x or 4.x
+4. If building has finished successfully, start the installation of FreeType.
+   All binary and service files of the product will be copied to the directory defined by `FREETYPE_INSTALL_DIR`.
 
-This third-party product is installed with binaries from the archive 
-that can be downloaded from https://github.com/intel/tbb.
-Go to the **Download** page, find the release version you need (e.g. *tbb30_018oss*) 
-and  pick the archive for Mac OS X platform. 
-To install, unpack the downloaded archive of TBB 3.0 product (*tbb30_018oss_osx.tgz*).
+       make install
 
-@subsection dev_guides__building_3rdparty_osx_3_3 FreeImage 3.14.1 or 3.15.x
+@subsection dev_guides__building_3rdparty_osx_3_1 TBB
 
-Download the necessary archive from 
+This third-party product is installed with binaries from the archive that can be downloaded from https://github.com/intel/tbb.
+Go to the **Download** page, find the release version you need (e.g. `tbb30_018oss`) and pick the archive for Mac OS X platform.
+To install, unpack the downloaded archive of TBB product (`tbb30_018oss_osx.tgz`).
+
+@subsection dev_guides__building_3rdparty_osx_3_3 FreeImage
+
+Download the necessary archive from
 https://sourceforge.net/projects/freeimage/files/Source%20Distribution/
-and unpack it. The directory with unpacked sources is  further referred to as *FREEIMAGE_SRC_DIR*.  
+and unpack it. The directory with unpacked sources is further referred to as `FREEIMAGE_SRC_DIR`.
 
-Note that for building FreeImage on Mac OS X 10.7 you should replace *Makefile.osx* 
-in *FREEIMAGE_SRC_DIR* by the corrected file, which you can find in attachment to issue #22811 in OCCT Mantis bug tracker 
-(https://tracker.dev.opencascade.org/file_download.php?file_id=6937&type=bug).
+Note that for building FreeImage on Mac OS X 10.7 you should replace `Makefile.osx`
+in `FREEIMAGE_SRC_DIR` by the corrected file, which you can find in attachment to issue [`#22811`](https://tracker.dev.opencascade.org/file_download.php?file_id=6937&type=bug) in OCCT Mantis bug tracker.
 
-1. If you build FreeImage 3.15.x you can skip this  step. 
-   Modify <i>FREEIMAGE_SRC_DIR/Source/OpenEXR/Imath/ImathMatrix.h:</i> 
-  
-   In line 60 insert the following: 
+1. If you build FreeImage 3.15.x you can skip this step.
 
-       #include string.h 
+   Modify `FREEIMAGE_SRC_DIR/Source/OpenEXR/Imath/ImathMatrix.h:`<br>
+   In line 60 insert the following:
 
-   Modify <i>FREEIMAGE_SRC_DIR/Source/FreeImage/PluginTARGA.cpp:</i> 
-  
-   In line 320 replace: 
+       #include string.h
 
-       SwapShort(value); 
+   Modify `FREEIMAGE_SRC_DIR/Source/FreeImage/PluginTARGA.cpp`:<br>
+   In line 320 replace:
 
-   with: 
+       SwapShort(value);
 
-       SwapShort(&value); 
+   with:
 
-2. Enter the directory where the source files of FreeImage  are located <i>(FREEIMAGE_SRC_DIR)</i>. 
+       SwapShort(&value);
 
-       cd FREEIMAGE_SRC_DIR 
+2. Enter the directory where the source files of FreeImage are located (`FREEIMAGE_SRC_DIR`).
+
+       cd FREEIMAGE_SRC_DIR
 
 3. Run the building process 
 
-       make   
+       make
 
-4. Run the installation process 
-   
-   1. If you have the permission to write into <i>/usr/local/include</i>  and <i>/usr/local/lib</i> directories, run the following command: 
+4. Run the installation process
 
-          make install   
+   1. If you have the permission to write into `/usr/local/include` and `/usr/local/lib` directories, run the following command:
 
-   2. If you do not have this permission, you need to modify file *FREEIMAGE_SRC_DIR/Makefile.osx*: 
+          make install
 
-      Change line 49 from:     
+   2. If you do not have this permission, you need to modify file `FREEIMAGE_SRC_DIR/Makefile.osx`:<br>
+      Change line 49 from:
 
           PREFIX ?= /usr/local
 
       to:
-   
-          PREFIX  ?= $(PREFIX) 
 
-      Change lines 65-69 from: 
+          PREFIX  ?= $(PREFIX)
 
-          install -d -m 755 -o  root -g wheel $(INCDIR) $(INSTALLDIR) 
-          install  -m 644 -o root -g wheel $(HEADER) $(INCDIR) 
-          install  -m 644 -o root -g wheel $(SHAREDLIB) $(STATICLIB) $(INSTALLDIR) 
-          ranlib  -sf $(INSTALLDIR)/$(STATICLIB) 
-          ln  -sf $(SHAREDLIB) $(INSTALLDIR)/$(LIBNAME) 
-    
-      to: 
+      Change lines 65-69 from:
 
-          install  -d $(INCDIR) $(INSTALLDIR) 
-          install  -m 755 $(HEADER) $(INCDIR) 
-          install  -m 755 $(STATICLIB) $(INSTALLDIR) 
-          install  -m 755 $(SHAREDLIB) $(INSTALLDIR) 
-          ln  -sf $(SHAREDLIB) $(INSTALLDIR)/$(VERLIBNAME)  
+          install -d -m 755 -o  root -g wheel $(INCDIR) $(INSTALLDIR)
+          install  -m 644 -o root -g wheel $(HEADER) $(INCDIR)
+          install  -m 644 -o root -g wheel $(SHAREDLIB) $(STATICLIB) $(INSTALLDIR)
+          ranlib  -sf $(INSTALLDIR)/$(STATICLIB)
+          ln  -sf $(SHAREDLIB) $(INSTALLDIR)/$(LIBNAME)
+
+      to:
+
+          install  -d $(INCDIR) $(INSTALLDIR)
+          install  -m 755 $(HEADER) $(INCDIR)
+          install  -m 755 $(STATICLIB) $(INSTALLDIR)
+          install  -m 755 $(SHAREDLIB) $(INSTALLDIR)
+          ln  -sf $(SHAREDLIB) $(INSTALLDIR)/$(VERLIBNAME)
           ln  -sf $(VERLIBNAME) $(INSTALLDIR)/$(LIBNAME)
 
-      Then run the installation process by the following command: 
-  
-          make PREFIX=FREEIMAGE_INSTALL_DIR  install 
-  
-5. Clean temporary files 
-  
+      Then run the installation process by the following command:
+
+          make PREFIX=FREEIMAGE_INSTALL_DIR  install
+
+5. Clean temporary files
+
        make clean

dox/upgrade/upgrade.md

@@ -2333,3 +2333,8 @@ Applications extending OCCT 3D Viewer and calling OpenGL functions directly (lik
 This header, as well as `OpenGl_GlCore20.hxx` and similar, no more include system OpenGL / OpenGL ES headers to define function table.
 Application code calling OpenGL functions directly should be changed to either use `OpenGl_Context::core11fwd` (as designed)
 or to include system OpenGL headers in advance (with help of `OpenGl_GlNative.hxx`).
+
+@subsection upgrade_occt770_tooltriangulatedshape StdPrs_ToolTriangulatedShape
+
+Method `StdPrs_ToolTriangulatedShape::Normal()` has been removed.
+Please use `BRepLib_ToolTriangulatedShape::ComputeNormals()` to fill in normal attributes in triangulation and fetch them directly using `Poly_Triangulation::Normal()`.

samples/OCCTOverview/code/Sample2D_Face.h

@@ -25,6 +25,7 @@
 #include <AIS_InteractiveObject.hxx>
 #include <Geom2d_TrimmedCurve.hxx>
 #include <Graphic3d_ArrayOfPolylines.hxx>
+#include <Graphic3d_AspectLine3d.hxx>
 #include <TopoDS_Face.hxx>
 #include <TColGeom_SequenceOfCurve.hxx>
 

samples/OCCTOverview/code/Sample2D_Image.cxx

@@ -26,9 +26,7 @@
 #include <BRepBuilderAPI_MakeWire.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
 #include <gp_Pnt.hxx>
-#include <Graphic3d_Texture1D.hxx>
-#include <Graphic3d_Texture1Dsegment.hxx>
-#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_Texture2D.hxx>
 #include <Image_AlienPixMap.hxx>
 #include <Prs3d_ShadingAspect.hxx>
 #include <TopoDS_Edge.hxx>
@@ -81,7 +79,7 @@ void Sample2D_Image::SetContext (const Handle(AIS_InteractiveContext)& theContex
   this->Set(TopoDS_Shape(myFace));
 
   myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
-  Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(myFilename);
+  Handle(Graphic3d_Texture2D) aTexture = new Graphic3d_Texture2D (myFilename);
   aTexture->DisableModulate();
   myDrawer->ShadingAspect()->Aspect()->SetTextureMap (aTexture);
   myDrawer->ShadingAspect()->Aspect()->SetTextureMapOn();

samples/OCCTOverview/code/Sample2D_Markers.h

@@ -24,6 +24,7 @@
 
 #include <AIS_InteractiveObject.hxx>
 #include <Graphic3d_ArrayOfPoints.hxx>
+#include <Graphic3d_AspectMarker3d.hxx>
 
 //! AIS AIS interactive object for sample 2D marker
 class Sample2D_Markers : public AIS_InteractiveObject

src/AIS/AIS_LightSource.hxx

@@ -17,6 +17,8 @@
 #define _AIS_LightSource_HeaderFile
 
 #include <AIS_InteractiveObject.hxx>
+#include <Graphic3d_AspectLine3d.hxx>
+#include <Graphic3d_AspectMarker3d.hxx>
 #include <SelectMgr_EntityOwner.hxx>
 
 class Select3D_SensitiveSphere;

src/AIS/AIS_MouseGesture.hxx

@@ -34,6 +34,8 @@ enum AIS_MouseGesture
   AIS_MouseGesture_Pan,             //!< view panning gesture
   AIS_MouseGesture_RotateOrbit,     //!< orbit rotation gesture
   AIS_MouseGesture_RotateView,      //!< view  rotation gesture
+  AIS_MouseGesture_Drag,            //!< object dragging;
+                                    //!  press button to start, move mouse to define rectangle, release to finish
 };
 
 //! Map defining mouse gestures.

src/AIS/AIS_TexturedShape.cxx

@@ -22,7 +22,7 @@
 #include <Graphic3d_AspectFillArea3d.hxx>
 #include <Graphic3d_Group.hxx>
 #include <Graphic3d_StructureManager.hxx>
-#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_Texture2D.hxx>
 #include <Message.hxx>
 #include <Message_Messenger.hxx>
 #include <Prs3d_Drawer.hxx>
@@ -278,17 +278,17 @@ void AIS_TexturedShape::updateAttributes (const Handle(Prs3d_Presentation)& theP
     TCollection_AsciiString aTextureDesc;
     if (!myTexturePixMap.IsNull())
     {
-      myTexture = new Graphic3d_Texture2Dmanual (myTexturePixMap);
+      myTexture = new Graphic3d_Texture2D (myTexturePixMap);
       aTextureDesc = " (custom image)";
     }
     else if (myPredefTexture != Graphic3d_NOT_2D_UNKNOWN)
     {
-      myTexture = new Graphic3d_Texture2Dmanual (myPredefTexture);
+      myTexture = new Graphic3d_Texture2D (myPredefTexture);
       aTextureDesc = TCollection_AsciiString(" (predefined texture ") + myTexture->GetId() + ")";
     }
     else
     {
-      myTexture = new Graphic3d_Texture2Dmanual (myTextureFile.ToCString());
+      myTexture = new Graphic3d_Texture2D (myTextureFile.ToCString());
       aTextureDesc = TCollection_AsciiString(" (") + myTextureFile + ")";
     }
 

src/AIS/AIS_TexturedShape.hxx

@@ -18,6 +18,7 @@
 
 #include <AIS_Shape.hxx>
 #include <gp_Pnt2d.hxx>
+#include <Graphic3d_NameOfTexture2D.hxx>
 #include <Image_PixMap.hxx>
 #include <Standard_Type.hxx>
 #include <TCollection_AsciiString.hxx>
@@ -26,7 +27,7 @@
 #include <PrsMgr_PresentationManager.hxx>
 
 class Graphic3d_AspectFillArea3d;
-class Graphic3d_Texture2Dmanual;
+class Graphic3d_Texture2D;
 
 //! This class allows to map textures on shapes.
 //! Presentations modes AIS_WireFrame (0) and AIS_Shaded (1) behave in the same manner as in AIS_Shape,
@@ -184,7 +185,7 @@ protected: //! @name overridden methods
 
 protected: //! @name presentation fields
 
-  Handle(Graphic3d_Texture2Dmanual)  myTexture;
+  Handle(Graphic3d_Texture2D)        myTexture;
   Handle(Graphic3d_AspectFillArea3d) myAspect;
 
 protected: //! @name texture source fields

src/AIS/AIS_ViewController.cxx

@@ -92,6 +92,7 @@ AIS_ViewController::AIS_ViewController()
   myTouchPanThresholdPx      (4.0f),
   myTouchZoomThresholdPx     (6.0f),
   myTouchZoomRatio           (0.13f),
+  myTouchDraggingThresholdPx (6.0f),
   //
   myNbTouchesLast (0),
   myUpdateStartPointPan  (true),
@@ -116,22 +117,37 @@ AIS_ViewController::AIS_ViewController()
   myRubberBand->SetDisplayMode (0);
   myRubberBand->SetMutable (true);
 
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_LeftButton,                           AIS_MouseGesture_RotateOrbit);
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_CTRL,   AIS_MouseGesture_Zoom);
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_SHIFT,  AIS_MouseGesture_Pan);
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_ALT,    AIS_MouseGesture_SelectRectangle);
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_ALT | Aspect_VKeyFlags_SHIFT, AIS_MouseGesture_SelectRectangle);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton,
+                          AIS_MouseGesture_RotateOrbit);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_CTRL,
+                          AIS_MouseGesture_Zoom);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_SHIFT,
+                          AIS_MouseGesture_Pan);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_ALT,
+                          AIS_MouseGesture_SelectRectangle);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_ALT | (Standard_UInteger )Aspect_VKeyFlags_SHIFT,
+                          AIS_MouseGesture_SelectRectangle);
 
-  myMouseSelectionSchemes.Bind (Aspect_VKeyMouse_LeftButton,                          AIS_SelectionScheme_Replace);
-  myMouseSelectionSchemes.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_ALT,   AIS_SelectionScheme_Replace);
-  myMouseSelectionSchemes.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_SHIFT, AIS_SelectionScheme_XOR);
-  myMouseSelectionSchemes.Bind (Aspect_VKeyMouse_LeftButton | Aspect_VKeyFlags_ALT | Aspect_VKeyFlags_SHIFT, AIS_SelectionScheme_XOR);
+  myMouseSelectionSchemes.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton,
+                                AIS_SelectionScheme_Replace);
+  myMouseSelectionSchemes.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_ALT,
+                                AIS_SelectionScheme_Replace);
+  myMouseSelectionSchemes.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_SHIFT,
+                                AIS_SelectionScheme_XOR);
+  myMouseSelectionSchemes.Bind ((Standard_UInteger )Aspect_VKeyMouse_LeftButton | (Standard_UInteger )Aspect_VKeyFlags_ALT | (Standard_UInteger )Aspect_VKeyFlags_SHIFT,
+                                AIS_SelectionScheme_XOR);
 
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_RightButton,                          AIS_MouseGesture_Zoom);
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_RightButton | Aspect_VKeyFlags_CTRL,  AIS_MouseGesture_RotateOrbit);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_RightButton,
+                          AIS_MouseGesture_Zoom);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_RightButton | (Standard_UInteger )Aspect_VKeyFlags_CTRL,
+                          AIS_MouseGesture_RotateOrbit);
 
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_MiddleButton,                         AIS_MouseGesture_Pan);
-  myMouseGestureMap.Bind (Aspect_VKeyMouse_MiddleButton | Aspect_VKeyFlags_CTRL, AIS_MouseGesture_Pan);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_MiddleButton,
+                          AIS_MouseGesture_Pan);
+  myMouseGestureMap.Bind ((Standard_UInteger )Aspect_VKeyMouse_MiddleButton | (Standard_UInteger )Aspect_VKeyFlags_CTRL,
+                          AIS_MouseGesture_Pan);
+
+  myMouseGestureMapDrag.Bind (Aspect_VKeyMouse_LeftButton, AIS_MouseGesture_Drag);
 
   myXRTeleportHaptic.Duration  = 3600.0f;
   myXRTeleportHaptic.Frequency = 0.1f;
@@ -181,6 +197,53 @@ void AIS_ViewController::FlushViewEvents (const Handle(AIS_InteractiveContext)&
 {
   flushBuffers (theCtx, theView);
   flushGestures(theCtx, theView);
+
+  if (theView->IsSubview())
+  {
+    // move input coordinates inside the view
+    const Graphic3d_Vec2i aDelta = theView->View()->SubviewTopLeft();
+    if (myGL.MoveTo.ToHilight || myGL.Dragging.ToStart)
+    {
+      myGL.MoveTo.Point -= aDelta;
+    }
+    if (myGL.Panning.ToStart)
+    {
+      myGL.Panning.PointStart -= aDelta;
+    }
+    if (myGL.Dragging.ToStart)
+    {
+      myGL.Dragging.PointStart -= aDelta;
+    }
+    if (myGL.Dragging.ToMove)
+    {
+      myGL.Dragging.PointTo -= aDelta;
+    }
+    if (myGL.OrbitRotation.ToStart)
+    {
+      myGL.OrbitRotation.PointStart -= Graphic3d_Vec2d (aDelta);
+    }
+    if (myGL.OrbitRotation.ToRotate)
+    {
+      myGL.OrbitRotation.PointTo -= Graphic3d_Vec2d (aDelta);
+    }
+    if (myGL.ViewRotation.ToStart)
+    {
+      myGL.ViewRotation.PointStart -= Graphic3d_Vec2d (aDelta);
+    }
+    if (myGL.ViewRotation.ToRotate)
+    {
+      myGL.ViewRotation.PointTo -= Graphic3d_Vec2d (aDelta);
+    }
+    for (Graphic3d_Vec2i& aPntIter : myGL.Selection.Points)
+    {
+      aPntIter -= aDelta;
+    }
+    for (Aspect_ScrollDelta& aZoomIter : myGL.ZoomActions)
+    {
+      aZoomIter.Point -= aDelta;
+    }
+  }
+
   if (theToHandle)
   {
     HandleViewEvents (theCtx, theView);
@@ -261,12 +324,21 @@ void AIS_ViewController::flushBuffers (const Handle(AIS_InteractiveContext)& ,
     myUI.Dragging.ToStop = false;
     myGL.Dragging.ToStop = true;
   }
-  else if (myUI.Dragging.ToStart)
+  else
   {
-    myUI.Dragging.ToStart = false;
-    myGL.Dragging.ToStart = true;
-    myGL.Dragging.PointStart = myUI.Dragging.PointStart;
+    if (myUI.Dragging.ToStart)
+    {
+      myUI.Dragging.ToStart = false;
+      myGL.Dragging.ToStart = true;
+      myGL.Dragging.PointStart = myUI.Dragging.PointStart;
+    }
+    if (myUI.Dragging.ToMove)
+    {
+      myUI.Dragging.ToMove = false;
+      myGL.Dragging.ToMove = true;
+    }
   }
+
   myGL.Dragging.PointTo = myUI.Dragging.PointTo;
 
   if (myUI.OrbitRotation.ToStart)
@@ -351,6 +423,7 @@ void AIS_ViewController::flushGestures (const Handle(AIS_InteractiveContext)& ,
         const Graphic3d_Vec2d aRotDelta = aTouch.To - myGL.OrbitRotation.PointStart;
         myGL.OrbitRotation.ToRotate = true;
         myGL.OrbitRotation.PointTo  = myGL.OrbitRotation.PointStart + aRotDelta * aRotAccel;
+        myGL.Dragging.ToMove = true;
         myGL.Dragging.PointTo.SetValues ((int )aTouch.To.x(), (int )aTouch.To.y());
       }
       else
@@ -358,6 +431,7 @@ void AIS_ViewController::flushGestures (const Handle(AIS_InteractiveContext)& ,
         const Graphic3d_Vec2d aRotDelta = aTouch.To - myGL.ViewRotation.PointStart;
         myGL.ViewRotation.ToRotate = true;
         myGL.ViewRotation.PointTo = myGL.ViewRotation.PointStart + aRotDelta * aRotAccel;
+        myGL.Dragging.ToMove = true;
         myGL.Dragging.PointTo.SetValues ((int )aTouch.To.x(), (int )aTouch.To.y());
       }
 
@@ -780,6 +854,19 @@ bool AIS_ViewController::UpdateMouseButtons (const Graphic3d_Vec2i& thePoint,
           UpdatePolySelection (thePoint, true);
           break;
         }
+        case AIS_MouseGesture_Drag:
+        {
+          if (myToAllowDragging)
+          {
+            myUI.Dragging.ToStart = true;
+            myUI.Dragging.PointStart = thePoint;
+          }
+          else
+          {
+            myMouseActiveGesture = AIS_MouseGesture_NONE;
+          }
+          break;
+        }
         case AIS_MouseGesture_NONE:
         {
           break;
@@ -787,12 +874,19 @@ bool AIS_ViewController::UpdateMouseButtons (const Graphic3d_Vec2i& thePoint,
       }
     }
 
-    if (theButtons == Aspect_VKeyMouse_LeftButton
-     && theModifiers == Aspect_VKeyFlags_NONE
-     && myToAllowDragging)
+    AIS_MouseGesture aSecGesture = AIS_MouseGesture_NONE;
+    if (myMouseGestureMapDrag.Find (theButtons | theModifiers, aSecGesture))
     {
-      myUI.Dragging.ToStart = true;
-      myUI.Dragging.PointStart = thePoint;
+      if (aSecGesture == AIS_MouseGesture_Drag
+       && myToAllowDragging)
+      {
+        myUI.Dragging.ToStart = true;
+        myUI.Dragging.PointStart = thePoint;
+        if (myMouseActiveGesture == AIS_MouseGesture_NONE)
+        {
+          myMouseActiveGesture = aSecGesture;
+        }
+      }
     }
   }
 
@@ -916,7 +1010,8 @@ bool AIS_ViewController::UpdateMousePosition (const Graphic3d_Vec2i& thePoint,
       const double aRotTol = theIsEmulated
                            ? double(myTouchToleranceScale) * myTouchRotationThresholdPx
                            : 0.0;
-      if (double (Abs (aDelta.x()) + Abs (aDelta.y())) > aRotTol)
+      const Graphic3d_Vec2d aDeltaF (aDelta);
+      if (Abs (aDeltaF.x()) + Abs (aDeltaF.y()) > aRotTol)
       {
         const double aRotAccel = myNavigationMode == AIS_NavigationMode_FirstPersonWalk ? myMouseAccel : myOrbitAccel;
         const Graphic3d_Vec2i aRotDelta = thePoint - myMousePressPoint;
@@ -932,6 +1027,8 @@ bool AIS_ViewController::UpdateMousePosition (const Graphic3d_Vec2i& thePoint,
           myUI.ViewRotation.PointTo = Graphic3d_Vec2d (myMousePressPoint.x(), myMousePressPoint.y())
                                     + Graphic3d_Vec2d (aRotDelta.x(), aRotDelta.y()) * aRotAccel;
         }
+
+        myUI.Dragging.ToMove  = true;
         myUI.Dragging.PointTo = thePoint;
 
         myMouseProgressPoint = thePoint;
@@ -967,7 +1064,8 @@ bool AIS_ViewController::UpdateMousePosition (const Graphic3d_Vec2i& thePoint,
       const double aPanTol = theIsEmulated
                            ? double(myTouchToleranceScale) * myTouchPanThresholdPx
                            : 0.0;
-      if (double (Abs (aDelta.x()) + Abs (aDelta.y())) > aPanTol)
+      const Graphic3d_Vec2d aDeltaF (aDelta);
+      if (Abs (aDeltaF.x()) + Abs (aDeltaF.y()) > aPanTol)
       {
         if (myUpdateStartPointPan)
         {
@@ -991,6 +1089,31 @@ bool AIS_ViewController::UpdateMousePosition (const Graphic3d_Vec2i& thePoint,
       }
       break;
     }
+    case AIS_MouseGesture_Drag:
+    {
+      if (!myToAllowDragging)
+      {
+        break;
+      }
+
+      const double aDragTol = theIsEmulated
+                            ? double(myTouchToleranceScale) * myTouchDraggingThresholdPx
+                            : 0.0;
+      if (double (Abs (aDelta.x()) + Abs (aDelta.y())) > aDragTol)
+      {
+        const double aRotAccel = myNavigationMode == AIS_NavigationMode_FirstPersonWalk ? myMouseAccel : myOrbitAccel;
+        const Graphic3d_Vec2i aRotDelta = thePoint - myMousePressPoint;
+        myUI.ViewRotation.ToRotate = true;
+        myUI.ViewRotation.PointTo = Graphic3d_Vec2d (myMousePressPoint.x(), myMousePressPoint.y())
+                                  + Graphic3d_Vec2d (aRotDelta.x(), aRotDelta.y()) * aRotAccel;
+        myUI.Dragging.ToMove  = true;
+        myUI.Dragging.PointTo = thePoint;
+
+        myMouseProgressPoint = thePoint;
+        toUpdateView = true;
+      }
+      break;
+    }
     default:
     {
       break;
@@ -1508,10 +1631,11 @@ void AIS_ViewController::handleZoom (const Handle(V3d_View)& theView,
 
     Graphic3d_Vec2i aWinSize;
     theView->Window()->Size (aWinSize.x(), aWinSize.y());
-    const Graphic3d_Vec2d aPanFromCenterPx (double(theParams.Point.x()) - 0.5 * double(aWinSize.x()),
-                                            double(aWinSize.y() - theParams.Point.y() - 1) - 0.5 * double(aWinSize.y()));
-    aDxy.x() += -aViewDims1.X() * aPanFromCenterPx.x() / double(aWinSize.x());
-    aDxy.y() += -aViewDims1.Y() * aPanFromCenterPx.y() / double(aWinSize.y());
+    const Graphic3d_Vec2d aWinSizeF (aWinSize);
+    const Graphic3d_Vec2d aPanFromCenterPx (double(theParams.Point.x()) - 0.5 * aWinSizeF.x(),
+                                            aWinSizeF.y() - double(theParams.Point.y()) - 1.0 - 0.5 * aWinSizeF.y());
+    aDxy.x() += -aViewDims1.X() * aPanFromCenterPx.x() / aWinSizeF.x();
+    aDxy.y() += -aViewDims1.Y() * aPanFromCenterPx.y() / aWinSizeF.y();
   }
 
   //theView->Translate (aCam, aDxy.x(), aDxy.y());
@@ -2566,6 +2690,17 @@ void AIS_ViewController::OnSelectionChanged (const Handle(AIS_InteractiveContext
   //
 }
 
+// =======================================================================
+// function : OnSubviewChanged
+// purpose  :
+// =======================================================================
+void AIS_ViewController::OnSubviewChanged (const Handle(AIS_InteractiveContext)& ,
+                                           const Handle(V3d_View)& ,
+                                           const Handle(V3d_View)& )
+{
+  //
+}
+
 // =======================================================================
 // function : OnObjectDragged
 // purpose  :
@@ -2913,8 +3048,7 @@ void AIS_ViewController::handleDynamicHighlight (const Handle(AIS_InteractiveCon
       myGL.OrbitRotation.ToRotate = false;
       myGL.ViewRotation .ToRotate = false;
     }
-    else if (myGL.OrbitRotation.ToRotate
-          || myGL.ViewRotation.ToRotate)
+    else if (myGL.Dragging.ToMove)
     {
       OnObjectDragged (theCtx, theView, AIS_DragAction_Update);
       myGL.OrbitRotation.ToRotate = false;
@@ -2942,6 +3076,8 @@ void AIS_ViewController::handleMoveTo (const Handle(AIS_InteractiveContext)& the
 void AIS_ViewController::handleViewRedraw (const Handle(AIS_InteractiveContext)& ,
                                            const Handle(V3d_View)& theView)
 {
+  Handle(V3d_View) aParentView = theView->IsSubview() ? theView->ParentView() : theView;
+
   // manage animation state
   if (!myViewAnimation.IsNull()
    && !myViewAnimation->IsStopped())
@@ -2969,31 +3105,82 @@ void AIS_ViewController::handleViewRedraw (const Handle(AIS_InteractiveContext)&
     myToAskNextFrame = true;
   }
 
-  for (V3d_ListOfViewIterator aViewIter (theView->Viewer()->ActiveViewIterator()); aViewIter.More(); aViewIter.Next())
+  for (int aSubViewPass = 0; aSubViewPass < 2; ++aSubViewPass)
   {
-    const Handle(V3d_View)& aView = aViewIter.Value();
-    if (aView->IsInvalidated()
-     || (myToAskNextFrame && aView == theView))
+    const bool isSubViewPass = (aSubViewPass == 0);
+    for (V3d_ListOfViewIterator aViewIter (theView->Viewer()->ActiveViewIterator()); aViewIter.More(); aViewIter.Next())
     {
-      if (aView->ComputedMode())
+      const Handle(V3d_View)& aView = aViewIter.Value();
+      if (isSubViewPass
+      && !aView->IsSubview())
       {
-        aView->Update();
+        for (const Handle(V3d_View)& aSubviewIter : aView->Subviews())
+        {
+          if (aSubviewIter->Viewer() != theView->Viewer())
+          {
+            if (aSubviewIter->IsInvalidated())
+            {
+              if (aSubviewIter->ComputedMode())
+              {
+                aSubviewIter->Update();
+              }
+              else
+              {
+                aSubviewIter->Redraw();
+              }
+            }
+            else if (aSubviewIter->IsInvalidatedImmediate())
+            {
+              aSubviewIter->RedrawImmediate();
+            }
+          }
+        }
+        continue;
       }
-      else
+      else if (!isSubViewPass
+             && aView->IsSubview())
       {
-        aView->Redraw();
+        continue;
+      }
+
+      if (aView->IsInvalidated()
+       || (myToAskNextFrame && aView == theView))
+      {
+        if (aView->ComputedMode())
+        {
+          aView->Update();
+        }
+        else
+        {
+          aView->Redraw();
+        }
+
+        if (aView->IsSubview())
+        {
+          aView->ParentView()->InvalidateImmediate();
+        }
+      }
+      else if (aView->IsInvalidatedImmediate())
+      {
+        if (aView->IsSubview())
+        {
+          aView->ParentView()->InvalidateImmediate();
+        }
+
+        aView->RedrawImmediate();
       }
     }
-    else if (aView->IsInvalidatedImmediate())
-    {
-      aView->RedrawImmediate();
-    }
+  }
+  if (theView->IsSubview()
+   && theView->Viewer() != aParentView->Viewer())
+  {
+    aParentView->RedrawImmediate();
   }
 
   if (myToAskNextFrame)
   {
     // ask more frames
-    theView->Window()->InvalidateContent (Handle(Aspect_DisplayConnection)());
+    aParentView->Window()->InvalidateContent (Handle(Aspect_DisplayConnection)());
   }
 }
 
@@ -3238,6 +3425,36 @@ void AIS_ViewController::HandleViewEvents (const Handle(AIS_InteractiveContext)&
 {
   const bool wasImmediateUpdate = theView->SetImmediateUpdate (false);
 
+  Handle(V3d_View) aPickedView;
+  if (theView->IsSubview()
+  || !theView->Subviews().IsEmpty())
+  {
+    // activate another subview on mouse click
+    bool toPickSubview = false;
+    Graphic3d_Vec2i aClickPoint;
+    if (myGL.Selection.Tool == AIS_ViewSelectionTool_Picking
+    && !myGL.Selection.Points.IsEmpty())
+    {
+      aClickPoint = myGL.Selection.Points.Last();
+      toPickSubview = true;
+    }
+    else if (!myGL.ZoomActions.IsEmpty())
+    {
+      //aClickPoint = myGL.ZoomActions.Last().Point;
+      //toPickSubview = true;
+    }
+
+    if (toPickSubview)
+    {
+      if (theView->IsSubview())
+      {
+        aClickPoint += theView->View()->SubviewTopLeft();
+      }
+      Handle(V3d_View) aParent = !theView->IsSubview() ? theView : theView->ParentView();
+      aPickedView = aParent->PickSubview (aClickPoint);
+    }
+  }
+
   handleViewOrientationKeys (theCtx, theView);
   const AIS_WalkDelta aWalk = handleNavigationKeys (theCtx, theView);
   handleXRInput (theCtx, theView, aWalk);
@@ -3255,6 +3472,12 @@ void AIS_ViewController::HandleViewEvents (const Handle(AIS_InteractiveContext)&
 
   theView->SetImmediateUpdate (wasImmediateUpdate);
 
+  if (!aPickedView.IsNull()
+    && aPickedView != theView)
+  {
+    OnSubviewChanged (theCtx, theView, aPickedView);
+  }
+
   // make sure to not process the same events twice
   myGL.Reset();
   myToAskNextFrame = false;

src/AIS/AIS_ViewController.hxx

@@ -492,6 +492,12 @@ public:
                                                 const Handle(V3d_View)& theView,
                                                 AIS_DragAction theAction);
 
+  //! Callback called by HandleViewEvents() on Selection of another (sub)view.
+  //! This method is expected to be called from rendering thread.
+  Standard_EXPORT virtual void OnSubviewChanged (const Handle(AIS_InteractiveContext)& theCtx,
+                                                 const Handle(V3d_View)& theOldView,
+                                                 const Handle(V3d_View)& theNewView);
+
   //! Pick closest point under mouse cursor.
   //! This method is expected to be called from rendering thread.
   //! @param thePnt   [out] result point
@@ -757,6 +763,7 @@ protected: //! @name mouse input variables
   Standard_ShortReal  myScrollZoomRatio;          //!< distance ratio for mapping mouse scroll event to zoom; 15.0 by default
 
   AIS_MouseGestureMap myMouseGestureMap;          //!< map defining mouse gestures
+  AIS_MouseGestureMap myMouseGestureMapDrag;      //!< secondary map defining mouse gestures for dragging
   AIS_MouseGesture    myMouseActiveGesture;       //!< initiated mouse gesture (by pressing mouse button)
   AIS_MouseSelectionSchemeMap
                       myMouseSelectionSchemes;    //!< map defining selection schemes bound to mouse + modifiers
@@ -777,6 +784,7 @@ protected: //! @name multi-touch input variables
   Standard_ShortReal  myTouchPanThresholdPx;      //!< threshold for starting two-touch panning      gesture in pixels;  4 by default
   Standard_ShortReal  myTouchZoomThresholdPx;     //!< threshold for starting two-touch zoom (pitch) gesture in pixels;  6 by default
   Standard_ShortReal  myTouchZoomRatio;           //!< distance ratio for mapping two-touch zoom (pitch) gesture from pixels to zoom; 0.13 by default
+  Standard_ShortReal  myTouchDraggingThresholdPx; //!< distance for starting one-touch dragging gesture in pixels;  6 by default
 
   Aspect_Touch        myTouchClick;               //!< single touch position for handling clicks
   OSD_Timer           myTouchDoubleTapTimer;      //!< timer for handling double tap

src/AIS/AIS_ViewInputBuffer.hxx

@@ -87,12 +87,13 @@ public:
   struct _draggingParams
   {
     bool            ToStart;    //!< start dragging
+    bool            ToMove;     //!< perform dragging
     bool            ToStop;     //!< stop  dragging
     bool            ToAbort;    //!< abort dragging (restore previous position)
     Graphic3d_Vec2i PointStart; //!< drag start point
     Graphic3d_Vec2i PointTo;    //!< drag end point
 
-    _draggingParams() : ToStart (false), ToStop (false), ToAbort (false) {}
+    _draggingParams() : ToStart (false), ToMove (false), ToStop (false), ToAbort (false) {}
   } Dragging;
 
   struct _orbitRotation
@@ -141,6 +142,7 @@ public:
     Panning.ToStart  = false;
     Panning.ToPan    = false;
     Dragging.ToStart = false;
+    Dragging.ToMove  = false;
     Dragging.ToStop  = false;
     Dragging.ToAbort = false;
     OrbitRotation.ToStart  = false;

src/AIS/AIS_XRTrackedDevice.cxx

@@ -15,6 +15,7 @@
 
 #include <Graphic3d_ArrayOfSegments.hxx>
 #include <Graphic3d_ArrayOfTriangles.hxx>
+#include <Graphic3d_Texture2Dmanual.hxx>
 #include <Graphic3d_Group.hxx>
 #include <Image_Texture.hxx>
 #include <Prs3d_LineAspect.hxx>
@@ -23,14 +24,14 @@
 #include <SelectMgr_EntityOwner.hxx>
 
 //! Texture holder.
-class AIS_XRTrackedDevice::XRTexture : public Graphic3d_Texture2Dmanual
+class AIS_XRTrackedDevice::XRTexture : public Graphic3d_Texture2D
 {
 public:
 
   //! Constructor.
   XRTexture (const Handle(Image_Texture)& theImageSource,
              const Graphic3d_TextureUnit theUnit = Graphic3d_TextureUnit_BaseColor)
-  : Graphic3d_Texture2Dmanual (""), myImageSource (theImageSource)
+  : Graphic3d_Texture2D (""), myImageSource (theImageSource)
   {
     if (!theImageSource->TextureId().IsEmpty())
     {

src/Adaptor3d/Adaptor3d_CurveOnSurface.cxx

@@ -99,10 +99,10 @@ static gp_Parab to3d(const gp_Pln& Pl, const gp_Parab2d& P)
   return gp_Parab(to3d(Pl,P.Axis()),P.Focal());
 }
 
-static gp_Vec SetLinearForm(const gp_Vec2d DW, const gp_Vec2d D2W,const gp_Vec2d D3W,
-			    const gp_Vec D1U,  const gp_Vec D1V,  const gp_Vec D2U,
-			    const gp_Vec D2V,  const gp_Vec D2UV, const gp_Vec D3U,
-			    const gp_Vec D3V,  const gp_Vec D3UUV,const gp_Vec D3UVV)
+static gp_Vec SetLinearForm(const gp_Vec2d& DW,  const gp_Vec2d& D2W,  const gp_Vec2d& D3W,
+                            const gp_Vec&   D1U, const gp_Vec&   D1V,  const gp_Vec&   D2U,
+                            const gp_Vec&   D2V, const gp_Vec&   D2UV, const gp_Vec&   D3U,
+                            const gp_Vec&   D3V, const gp_Vec&   D3UUV,const gp_Vec&   D3UVV)
 {gp_Vec V31, V32, V33, V34,V3 ;
  V31.SetLinearForm(DW.X(),D1U,
 		   D2W.X()*DW.X(),D2U,

src/Adaptor3d/Adaptor3d_Surface.hxx

@@ -114,19 +114,20 @@ public:
   Standard_EXPORT virtual Standard_Boolean IsVPeriodic() const;
   
   Standard_EXPORT virtual Standard_Real VPeriod() const;
-  
+
   //! Computes the point of parameters U,V on the surface.
+  //! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
   Standard_EXPORT virtual gp_Pnt Value (const Standard_Real U, const Standard_Real V) const;
-  
+
   //! Computes the point of parameters U,V on the surface.
   Standard_EXPORT virtual void D0 (const Standard_Real U, const Standard_Real V, gp_Pnt& P) const;
   
-  //! Computes the point  and the first derivatives on
-  //! the surface.
-  //! Raised   if  the continuity  of   the  current
-  //! intervals is not C1.
+  //! Computes the point  and the first derivatives on the surface.
+  //! Raised if the continuity of the current intervals is not C1.
+  //!
+  //! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
   Standard_EXPORT virtual void D1 (const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V) const;
-  
+
   //! Computes   the point,  the  first  and  second
   //! derivatives on the surface.
   //! Raised  if   the   continuity   of the current

src/Adaptor3d/Adaptor3d_TopolTool.cxx

@@ -30,34 +30,6 @@ IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_TopolTool,Standard_Transient)
 
 #define myInfinite Precision::Infinite()
 
-static void GetConeApexParam(const gp_Cone& C, Standard_Real& U, Standard_Real& V)
-{
-  const gp_Ax3& Pos = C.Position();
-  Standard_Real Radius = C.RefRadius();
-  Standard_Real SAngle = C.SemiAngle();
-  const gp_Pnt& P = C.Apex();
- 
-  gp_Trsf T;
-  T.SetTransformation (Pos);
-  gp_Pnt Ploc = P.Transformed (T);
-
-  if(Ploc.X() ==0.0  &&  Ploc.Y()==0.0 ) {
-    U = 0.0;
-  }
-  else if ( -Radius > Ploc.Z()* Tan(SAngle) ) {
-    // the point is at the `wrong` side of the apex
-    U = atan2(-Ploc.Y(), -Ploc.X());
-  }
-  else {
-    U = atan2(Ploc.Y(),Ploc.X());
-  }
-  if      (U < -1.e-16)  U += (M_PI+M_PI);
-  else if (U < 0)        U = 0;
-
-  V =  sin(SAngle) * ( Ploc.X() * cos(U) + Ploc.Y() * sin(U) - Radius)
-    + cos(SAngle) * Ploc.Z();
-}
-
 
 Adaptor3d_TopolTool::Adaptor3d_TopolTool ()
 : myNbSamplesU(-1),
@@ -1376,3 +1348,39 @@ Standard_Boolean Adaptor3d_TopolTool::IsUniformSampling() const
     return Standard_False;
   return Standard_True;
 }
+
+//=======================================================================
+//function : GetConeApexParam
+//purpose  : Computes the cone's apex parameters
+//=======================================================================
+void Adaptor3d_TopolTool::GetConeApexParam (const gp_Cone& theC, Standard_Real& theU, Standard_Real& theV)
+{
+  const gp_Ax3& Pos = theC.Position();
+  Standard_Real Radius = theC.RefRadius();
+  Standard_Real SAngle = theC.SemiAngle();
+  const gp_Pnt& P = theC.Apex();
+
+  gp_Trsf T;
+  T.SetTransformation(Pos);
+  gp_Pnt Ploc = P.Transformed(T);
+
+  if (Ploc.X() == 0.0 && Ploc.Y() == 0.0)
+  {
+    theU = 0.0;
+  }
+  else if (-Radius > Ploc.Z() * Tan(SAngle))
+  {
+    // the point is at the `wrong` side of the apex
+    theU = atan2(-Ploc.Y(), -Ploc.X());
+  }
+  else
+  {
+    theU = atan2(Ploc.Y(), Ploc.X());
+  }
+
+  if (theU < -1.e-16)  theU += (M_PI + M_PI);
+  else if (theU < 0)   theU = 0;
+
+  theV = sin(SAngle) * (Ploc.X() * cos(theU) + Ploc.Y() * sin(theU) - Radius)
+         + cos(SAngle) * Ploc.Z();
+}

src/Adaptor3d/Adaptor3d_TopolTool.hxx

@@ -146,6 +146,12 @@ public:
   //! Returns true if provide uniform sampling of points.
   Standard_EXPORT virtual Standard_Boolean IsUniformSampling() const;
 
+  //! Computes the cone's apex parameters.
+  //! @param[in] theC conical surface
+  //! @param[in] theU U parameter of cone's apex
+  //! @param[in] theV V parameter of cone's apex
+  Standard_EXPORT static void GetConeApexParam (const gp_Cone& theC, Standard_Real& theU, Standard_Real& theV);
+
   DEFINE_STANDARD_RTTIEXT(Adaptor3d_TopolTool,Standard_Transient)
 
 protected:

src/Approx/Approx_SameParameter.cxx

@@ -108,7 +108,7 @@ void Approx_SameParameter_Evaluator::Evaluate (Standard_Integer *,/*Dimension*/
 //purpose  : 
 //=======================================================================
 static void ProjectPointOnCurve(const Standard_Real      InitValue,
-                                const gp_Pnt             APoint,
+                                const gp_Pnt&            APoint,
                                 const Standard_Real      Tolerance,
                                 const Standard_Integer   NumIteration,
                                 const Adaptor3d_Curve&   Curve,

src/Aspect/Aspect_Window.hxx

@@ -40,18 +40,58 @@ class Aspect_Window : public Standard_Transient
   DEFINE_STANDARD_RTTIEXT(Aspect_Window, Standard_Transient)
 public:
 
-  //! Modifies the window background.
-  Standard_EXPORT void SetBackground (const Aspect_Background& ABack);
+  //! Returns True if the window <me> is virtual
+  Standard_EXPORT Standard_Boolean IsVirtual() const;
+
+  //! Setup the virtual state
+  Standard_EXPORT void SetVirtual (const Standard_Boolean theVirtual);
+
+  //! Returns window top-left corner.
+  Graphic3d_Vec2i TopLeft() const
+  {
+    Graphic3d_Vec2i aTopLeft, aBotRight;
+    Position (aTopLeft.x(), aTopLeft.y(), aBotRight.x(), aBotRight.y());
+    return aTopLeft;
+  }
+
+  //! Returns window dimensions.
+  Graphic3d_Vec2i Dimensions() const
+  {
+    Graphic3d_Vec2i aSize;
+    Size (aSize.x(), aSize.y());
+    return aSize;
+  }
+
+  //! Returns connection to Display or NULL.
+  const Handle(Aspect_DisplayConnection)& DisplayConnection() const { return myDisplay; }
+
+  //! Returns the window background.
+  Standard_EXPORT Aspect_Background Background() const;
+
+  //! Returns the current image background fill mode.
+  Standard_EXPORT Aspect_FillMethod BackgroundFillMethod() const;
+
+  //! Returns the window gradient background.
+  Standard_EXPORT Aspect_GradientBackground GradientBackground() const;
 
   //! Modifies the window background.
-  Standard_EXPORT void SetBackground (const Quantity_Color& color);
+  Standard_EXPORT void SetBackground (const Aspect_Background& theBack);
+
+  //! Modifies the window background.
+  Standard_EXPORT void SetBackground (const Quantity_Color& theColor);
 
   //! Modifies the window gradient background.
-  Standard_EXPORT void SetBackground (const Aspect_GradientBackground& ABackground);
+  Standard_EXPORT void SetBackground (const Aspect_GradientBackground& theBackground);
 
   //! Modifies the window gradient background.
   Standard_EXPORT void SetBackground (const Quantity_Color& theFirstColor, const Quantity_Color& theSecondColor, const Aspect_GradientFillMethod theFillMethod);
 
+public:
+
+  //! Returns True if the window <me> is opened
+  //! and False if the window is closed.
+  Standard_EXPORT virtual Standard_Boolean IsMapped() const = 0;
+
   //! Opens the window <me>.
   Standard_EXPORT virtual void Map() const = 0;
 
@@ -65,25 +105,6 @@ public:
   //! and returns TRUE if the window is mapped at screen.
   Standard_EXPORT virtual Standard_Boolean DoMapping() const = 0;
 
-  //! Returns the window background.
-  Standard_EXPORT Aspect_Background Background() const;
-
-  //! Returns the current image background fill mode.
-  Standard_EXPORT Aspect_FillMethod BackgroundFillMethod() const;
-
-  //! Returns the window gradient background.
-  Standard_EXPORT Aspect_GradientBackground GradientBackground() const;
-
-  //! Returns True if the window <me> is opened
-  //! and False if the window is closed.
-  Standard_EXPORT virtual Standard_Boolean IsMapped() const = 0;
-
-  //! Returns True if the window <me> is virtual
-  Standard_EXPORT Standard_Boolean IsVirtual() const;
-
-  //! Setup the virtual state
-  Standard_EXPORT void SetVirtual (const Standard_Boolean theVirtual);
-
   //! Returns The Window RATIO equal to the physical
   //! WIDTH/HEIGHT dimensions
   Standard_EXPORT virtual Standard_Real Ratio() const = 0;
@@ -103,9 +124,6 @@ public:
   //! Returns native Window FB config (GLXFBConfig on Xlib)
   Standard_EXPORT virtual Aspect_FBConfig NativeFBConfig() const = 0;
 
-  //! Returns connection to Display or NULL.
-  const Handle(Aspect_DisplayConnection)& DisplayConnection() const { return myDisplay; }
-
   //! Sets window title.
   virtual void SetTitle (const TCollection_AsciiString& theTitle) { (void )theTitle; }
 

src/BOPAlgo/BOPAlgo_PaveFiller.hxx

@@ -525,7 +525,7 @@ protected:
   Standard_EXPORT void UpdateEdgeTolerance(const Standard_Integer nE,
                                            const Standard_Real aTolNew);
 
-  Standard_EXPORT void RemovePaveBlocks(const TColStd_MapOfInteger theEdges);
+  Standard_EXPORT void RemovePaveBlocks(const TColStd_MapOfInteger& theEdges);
 
   Standard_EXPORT void CorrectToleranceOfSE();
 

src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx

@@ -3394,7 +3394,7 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
 //function : RemovePaveBlocks
 //purpose  : 
 //=======================================================================
-void BOPAlgo_PaveFiller::RemovePaveBlocks(const TColStd_MapOfInteger theEdges)
+void BOPAlgo_PaveFiller::RemovePaveBlocks(const TColStd_MapOfInteger& theEdges)
 {
   // Remove all pave blocks referring to input edges:
   //

src/BRepAdaptor/BRepAdaptor_Surface.hxx

@@ -141,17 +141,18 @@ public:
   virtual Standard_Real VPeriod() const Standard_OVERRIDE { return mySurf.VPeriod(); }
 
   //! Computes the point of parameters U,V on the surface.
+  //! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
   Standard_EXPORT gp_Pnt Value (const Standard_Real U, const Standard_Real V) const Standard_OVERRIDE;
-  
+
   //! Computes the point of parameters U,V on the surface.
   Standard_EXPORT void D0 (const Standard_Real U, const Standard_Real V, gp_Pnt& P) const Standard_OVERRIDE;
-  
-  //! Computes the point  and the first derivatives on
-  //! the surface.
-  //! Raised   if  the continuity  of   the  current
-  //! intervals is not C1.
+
+  //! Computes the point  and the first derivatives on the surface.
+  //! Raised if the continuity of the current intervals is not C1.
+  //!
+  //! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
   Standard_EXPORT void D1 (const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V) const Standard_OVERRIDE;
-  
+
   //! Computes   the point,  the  first  and  second
   //! derivatives on the surface.
   //! Raised  if   the   continuity   of the current

src/BRepAlgo/BRepAlgo_NormalProjection.cxx

@@ -334,7 +334,7 @@ void BRepAlgo_NormalProjection::SetDefaultParams()
 	  
 	  if(Only2d && Only3d) {
 	    BRepLib_MakeEdge MKed(GeomAdaptor::MakeCurve(hcur->Curve()), 
-				  Ufin, Udeb);
+				  Udeb, Ufin);
 	    prj = MKed.Edge();
 	    BB.UpdateEdge(TopoDS::Edge(prj), 
 			  PCur2d, 

src/BRepCheck/BRepCheck_Edge.cxx

@@ -148,15 +148,14 @@ void BRepCheck_Edge::Minimum()
         BRepCheck::Add(lst,BRepCheck_InvalidRange);
       }
       else {
-        IsCurve3D = myCref->IsCurve3D();
-        if (IsCurve3D) {
+        if (myCref->IsCurve3D()) {
           // eap 6 Jun 2002 occ332
           // better transform C3d instead of transforming Surf upto C3d initial location,
           // on transformed BSpline surface 'same parameter' may seem wrong
           TopLoc_Location L = myShape.Location() * myCref->Location();
           Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
-              (myCref->Curve3D()->Transformed
-              (/*myCref->Location()*/L.Transformation()));
+            (myCref->Curve3D()->Transformed
+            (/*myCref->Location()*/L.Transformation()));
           Standard_Boolean IsPeriodic = C3d->IsPeriodic();
           Standard_Real aPeriod = RealLast();
           if(IsPeriodic)
@@ -187,8 +186,9 @@ void BRepCheck_Edge::Minimum()
           }
           else
           {
-            TopoDS_Shape aShape;
-            myHCurve = GetEdgeCurve(aShape);
+            GeomAdaptor_Curve GAC3d(C3d, C3d->TransformedParameter(First, L.Transformation()),
+                                       C3d->TransformedParameter(Last, L.Transformation()));
+            myHCurve = new GeomAdaptor_Curve(GAC3d);
           }
         }
         else { // curve on surface
@@ -226,8 +226,11 @@ void BRepCheck_Edge::Minimum()
           }
           else
           {
-            TopoDS_Shape aShape;
-            myHCurve = GetEdgeCurve(aShape);
+            Handle(GeomAdaptor_Surface) GAHSref = new GeomAdaptor_Surface(Sref);
+            Handle(Geom2dAdaptor_Curve) GHPCref = 
+              new Geom2dAdaptor_Curve(PCref,First,Last);
+            Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
+            myHCurve = new Adaptor3d_CurveOnSurface(ACSref);
           }
         }
       }
@@ -298,7 +301,6 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
         return;
       }
       //  Modified by skv - Tue Apr 27 11:48:14 2004 End
-      myHCurve = GetEdgeCurve(S);
       Standard_Real First = myHCurve->FirstParameter();
       Standard_Real Last  = myHCurve->LastParameter();
 
@@ -370,7 +372,7 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
             Handle(Geom_Surface) Sb = cr->Surface();
             Sb = Handle(Geom_Surface)::DownCast
               //	      (Su->Transformed(L.Transformation()));
-              (Su->Transformed(/*L*/TFloc.Transformation()));
+              (Su->Transformed(/*L*/(Floc * TFloc).Transformation()));
             Handle(Geom2d_Curve) PC = cr->PCurve();
             Handle(GeomAdaptor_Surface) GAHS = new GeomAdaptor_Surface(Sb);
             Handle(Geom2dAdaptor_Curve) GHPC = new Geom2dAdaptor_Curve(PC,f,l);
@@ -438,7 +440,7 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
           // plan en position
           if (myGctrl) {
             P = Handle(Geom_Plane)::
-              DownCast(P->Transformed(/*L*/TFloc.Transformation()));// eap occ332
+              DownCast(P->Transformed(/*L*/(Floc * TFloc).Transformation()));// eap occ332
             //on projette Cref sur ce plan
             Handle(GeomAdaptor_Surface) GAHS = new GeomAdaptor_Surface(P);
 
@@ -546,64 +548,6 @@ Standard_Boolean BRepCheck_Edge::GeometricControls() const
   return myGctrl;
 }
 
-
-//=======================================================================
-//function : GetEdgeCurve
-//purpose  : 
-//=======================================================================
-
-Handle(Adaptor3d_Curve) BRepCheck_Edge::GetEdgeCurve(const TopoDS_Shape& theShape)
-{
-  Handle(Adaptor3d_Curve) aLocalCurve;
-  Handle(BRep_GCurve) GCref(Handle(BRep_GCurve)::DownCast(myCref));
-  Standard_Real First, Last;
-  GCref->Range(First, Last);
-  if (IsCurve3D)
-  {
-
-    TopLoc_Location L = myShape.Location() * myCref->Location();
-    Handle(Geom_Curve) C3d;
-    if (!theShape.IsNull())
-    {
-      C3d = Handle(Geom_Curve)::DownCast
-        (myCref->Curve3D()->Transformed
-        (/*myCref->Location()*/L.Predivided(theShape.Location()).Transformation()));
-    }
-    else
-    {
-      C3d = Handle(Geom_Curve)::DownCast
-        (myCref->Curve3D()->Transformed
-        (/*myCref->Location()*/L.Transformation()));
-    }
-    GeomAdaptor_Curve GAC3d(C3d, C3d->TransformedParameter(First, L.Transformation()),
-                               C3d->TransformedParameter(Last, L.Transformation()));
-    aLocalCurve = new GeomAdaptor_Curve(GAC3d);
-  }
-  else
-  {
-    Handle(Geom_Surface) Sref = myCref->Surface();
-    if (!theShape.IsNull())
-    {
-      Sref = Handle(Geom_Surface)::DownCast
-        (Sref->Transformed(myCref->Location().Predivided(theShape.Location()).Transformation()));
-    }
-    else
-    {
-      Sref = Handle(Geom_Surface)::DownCast
-        (Sref->Transformed(myCref->Location().Transformation()));
-    }
-    const Handle(Geom2d_Curve)& PCref = myCref->PCurve();
-    Handle(GeomAdaptor_Surface) GAHSref = new GeomAdaptor_Surface(Sref);
-    Handle(Geom2dAdaptor_Curve) GHPCref =
-      new Geom2dAdaptor_Curve(PCref, First, Last);
-    Adaptor3d_CurveOnSurface ACSref(GHPCref, GAHSref);
-    aLocalCurve = new Adaptor3d_CurveOnSurface(ACSref);
-  }
-
-  return aLocalCurve;
-}
-
-
 //=======================================================================
 //function :   SetStatus
 //purpose  : 

src/BRepCheck/BRepCheck_Edge.hxx

@@ -45,11 +45,6 @@ public:
   
   Standard_EXPORT Standard_Boolean GeometricControls() const;
   
-  //! Creates a 3d curve or surface on a curve by subtracting the location of the face
-  //! @param[in] theShape input shape to get the location from it
-  //! @return a 3d curve or curve on a surface
-  Standard_EXPORT Handle(Adaptor3d_Curve) GetEdgeCurve(const TopoDS_Shape& theShape);
-  
   Standard_EXPORT void GeometricControls (const Standard_Boolean B);
   
   Standard_EXPORT Standard_Real Tolerance();
@@ -86,7 +81,6 @@ private:
   Handle(Adaptor3d_Curve) myHCurve;
   Standard_Boolean myGctrl;
   Standard_Boolean myIsExactMethod;
-  Standard_Boolean IsCurve3D;
 };
 
 #endif // _BRepCheck_Edge_HeaderFile

src/BRepCheck/BRepCheck_Wire.cxx

@@ -31,11 +31,13 @@
 #include <BRepCheck_ListOfStatus.hxx>
 #include <BRepCheck_Wire.hxx>
 #include <BRepTools_WireExplorer.hxx>
+#include <BRepTools.hxx>
 #include <ElCLib.hxx>
 #include <Geom2d_Curve.hxx>
 #include <Geom2dAdaptor_Curve.hxx>
 #include <Geom2dInt_GInter.hxx>
 #include <Geom_Curve.hxx>
+#include <Geom_RectangularTrimmedSurface.hxx>
 #include <gp_Lin.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Pnt2d.hxx>
@@ -114,6 +116,11 @@ static Standard_Boolean GetPnt2d(const TopoDS_Vertex    &theVertex,
 				 const TopoDS_Edge      &theEdge,
 				 const TopoDS_Face      &theFace,
 				       gp_Pnt2d         &aPnt);
+
+static void DefinePeriods(const TopoDS_Face& theFace,
+                          Standard_Real&     theUperiod,
+                          Standard_Real&     theVperiod);
+
 //  Modified by Sergey KHROMOV - Wed May 22 10:44:08 2002 End
 
 //=======================================================================
@@ -419,12 +426,24 @@ Standard_Boolean IsDistanceIn2DTolerance (const BRepAdaptor_Surface& aFaceSurfac
                                           const gp_Pnt2d& thePnt,
                                           const gp_Pnt2d& thePntRef,
                                           const Standard_Real aTol3d,
+                                          const Standard_Boolean theIsOnSingularity,
 #ifdef OCCT_DEBUG
                                           const Standard_Boolean PrintWarnings = Standard_True)
 #else
                                           const Standard_Boolean = Standard_True)
 #endif
 {
+  gp_Pnt aP;
+  gp_Vec aDU, aDV;
+  Standard_Real um = (thePnt.X() + thePntRef.X()) / 2.;
+  Standard_Real vm = (thePnt.Y() + thePntRef.Y()) / 2.;
+  aFaceSurface.D1(um, vm, aP, aDU, aDV);
+  Standard_Real aMDU = aDU.Magnitude();
+  Standard_Real aMDV = aDV.Magnitude();
+  if (!theIsOnSingularity ||
+      (aMDU > Precision::Confusion() && aMDV > Precision::Confusion()))
+    return Standard_True; //we are not in singularity
+  
   Standard_Real dumax = 0.01 * (aFaceSurface.LastUParameter() - aFaceSurface.FirstUParameter());
   Standard_Real dvmax = 0.01 * (aFaceSurface.LastVParameter() -	aFaceSurface.FirstVParameter());
   Standard_Real dumin = Abs(thePnt.X() - thePntRef.X());
@@ -453,17 +472,17 @@ Standard_Boolean IsDistanceIn2DTolerance (const BRepAdaptor_Surface& aFaceSurfac
 #endif
   dumax = aFaceSurface.UResolution(aTol3d);
   dvmax = aFaceSurface.VResolution(aTol3d);
-  gp_Pnt aP;
-  gp_Vec aDU, aDV;
-  Standard_Real um = (thePnt.X() + thePntRef.X()) / 2.;
-  Standard_Real vm = (thePnt.Y() + thePntRef.Y()) / 2.;
-  aFaceSurface.D1(um, vm, aP, aDU, aDV);
-  Standard_Real aMDU = aDU.Magnitude();
+  //gp_Pnt aP;
+  //gp_Vec aDU, aDV;
+  //Standard_Real um = (thePnt.X() + thePntRef.X()) / 2.;
+  //Standard_Real vm = (thePnt.Y() + thePntRef.Y()) / 2.;
+  //aFaceSurface.D1(um, vm, aP, aDU, aDV);
+  //Standard_Real aMDU = aDU.Magnitude();
   if (aMDU > Precision::Confusion())
   {
     dumax = Max((aTol3d / aMDU), dumax);
   }
-  Standard_Real aMDV = aDV.Magnitude();
+  //Standard_Real aMDV = aDV.Magnitude();
   if (aMDV > Precision::Confusion())
   {
     dvmax = Max((aTol3d / aMDV), dvmax);
@@ -676,7 +695,14 @@ BRepCheck_Status BRepCheck_Wire::Closed2d(const TopoDS_Face& theFace,
   gp_Pnt aPntRef = BRep_Tool::Pnt(aFirstVertex);
   gp_Pnt aPnt		 = BRep_Tool::Pnt(aWireExp.CurrentVertex());
 
-  if (!(IsDistanceIn2DTolerance(aFaceSurface, aP_first, aP_last, aTol3d)))
+  Standard_Real aUperiod = 0., aVperiod = 0.;
+  DefinePeriods (theFace, aUperiod, aVperiod);
+
+  if ((aUperiod != 0. && Abs(aP_first.X() - aP_last.X()) > aUperiod/2) ||
+      (aVperiod != 0. && Abs(aP_first.Y() - aP_last.Y()) > aVperiod/2))
+    aClosedStat = BRepCheck_NotClosed;
+
+  if (!(IsDistanceIn2DTolerance(aFaceSurface, aP_first, aP_last, aTol3d, Standard_True)))
     aClosedStat = BRepCheck_NotClosed;
 
   if(!IsDistanceIn3DTolerance(aPntRef, aPnt, aTol3d))
@@ -1710,10 +1736,24 @@ void ChoixUV(const TopoDS_Vertex& theVertex,
   if (aVOrientation != anEdgOrientation)
     aDerRef.Reverse();
 
+  //Check if there is a seam edge in the list
+  Standard_Real aUperiod = 0., aVperiod = 0.;
+  DefinePeriods (theFace, aUperiod, aVperiod);
+  Standard_Boolean anIsOnSingularity = Standard_False;
+  for (It.Initialize(theLOfShape); It.More(); It.Next())
+  {
+    TopoDS_Edge anEdge = TopoDS::Edge (It.Value());
+    if (BRep_Tool::Degenerated (anEdge))
+    {
+      anIsOnSingularity = Standard_True;
+      break;
+    }
+  }
+
   It.Initialize(theLOfShape);
 
   for (; It.More(); It.Next())
-    {
+  {
     anIndex++;
     const TopoDS_Edge& anE=TopoDS::Edge(It.Value());
     C2d = BRep_Tool::CurveOnSurface(anE, theFace, aFirstParam, aLastParam);
@@ -1724,7 +1764,11 @@ void ChoixUV(const TopoDS_Vertex& theVertex,
     aParam =(aVOrientation != anE.Orientation()) ? aFirstParam : aLastParam;
     aPnt = aCA.Value(aParam);
 
-    if(!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d, Standard_False))
+    if ((aUperiod != 0. && Abs(aPnt.X() - aPntRef.X()) > aUperiod/2) ||
+        (aVperiod != 0. && Abs(aPnt.Y() - aPntRef.Y()) > aVperiod/2))
+      continue;
+
+    if(!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d, anIsOnSingularity, Standard_False))
       continue;
 
     CurveDirForParameter(aCA, aParam, aPnt, aDer);
@@ -1743,22 +1787,22 @@ void ChoixUV(const TopoDS_Vertex& theVertex,
       anAngle += 2.*M_PI;
 
     if ( theFace.Orientation() == TopAbs_FORWARD )
-      {
+    {
       if ( anAngle < aMinAngle )
-        {
+      {
         anIndMin = anIndex;
         aMinAngle = anAngle;
-        }
       }
+    }
     else //theFace.Orientation() != TopAbs_FORWARD
-      {
+    {
       if ( anAngle > aMaxAngle )
-        {
+      {
         anIndMin = anIndex;
         aMaxAngle = anAngle;
-        }
       }
-    }//end of for
+    }
+  }//end of for
 
 // Update edge
   if (anIndMin == 0)
@@ -1770,7 +1814,7 @@ void ChoixUV(const TopoDS_Vertex& theVertex,
       if(anEFound.IsNull() || BRep_Tool::Degenerated(theEdge) ||
                                   BRep_Tool::Degenerated(anEFound))
         IsFound = Standard_False; //bad
-      else if (!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d))
+      else if (!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d, Standard_True))
         IsFound = Standard_False; //bad
       else 
         // clousureness in 3D
@@ -1959,3 +2003,20 @@ static Standard_Boolean IsClosed2dForPeriodicFace
   return Standard_True;
 }
 //  Modified by Sergey KHROMOV - Thu Jun 20 10:58:05 2002 End
+
+void DefinePeriods(const TopoDS_Face& theFace,
+                   Standard_Real&     theUperiod,
+                   Standard_Real&     theVperiod)
+{
+  theUperiod = theVperiod = 0.;
+  
+  Handle(Geom_Surface) aSurf = BRep_Tool::Surface (theFace);
+  if (aSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
+    aSurf = (Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurf))->BasisSurface();
+  Standard_Real aUmin, aUmax, aVmin, aVmax;
+  aSurf->Bounds (aUmin, aUmax, aVmin, aVmax);
+  if (aSurf->IsUClosed())
+    theUperiod = aUmax - aUmin;
+  if (aSurf->IsVClosed())
+    theVperiod = aVmax - aVmin;
+}

src/BRepFill/BRepFill_Sweep.cxx

@@ -861,7 +861,8 @@ static Standard_Boolean Filling(const TopoDS_Shape& EF,
   Prof2 = BRep_Tool::Curve(E2, f2, l2);
 
   // Indeed, both Prof1 and Prof2 are the same curves but in different positions
-
+  // Prof1's param domain may equals to Prof2's param domain *(-1), which means EF.Orientation() == EL.Orientation()
+  Standard_Boolean bSameCurveDomain = EF.Orientation() != EL.Orientation();
   gp_Pnt P1, P2, P;
 
   // Choose the angle of opening
@@ -887,7 +888,8 @@ static Standard_Boolean Filling(const TopoDS_Shape& EF,
     }
   }
 
-  const gp_Pnt aP2 = Prof2->Value(aPrm[aMaxIdx]).Transformed(aTf);
+  const Standard_Real aPrm2[] = { f2, 0.5*(f2 + l2), l2 };
+  const gp_Pnt aP2 = Prof2->Value(aPrm2[bSameCurveDomain ? aMaxIdx : 2 - aMaxIdx]).Transformed(aTf);
   const gp_Vec2d aV1(aP1[aMaxIdx].Z(), aP1[aMaxIdx].X());
   const gp_Vec2d aV2(aP2.Z(), aP2.X());
   if (aV1.SquareMagnitude() <= gp::Resolution() ||

src/BRepLib/BRepLib.cxx

@@ -1960,6 +1960,12 @@ public:
     return aDeriv.Transformed(mySurfaceTrsf);
   }
 
+  gp_Dir Normal()
+  {
+    gp_Dir aNormal = mySurfaceProps.Normal();
+    return aNormal.Transformed(mySurfaceTrsf);
+  }
+
   // Calculate principal curvatures, which consist of minimal and maximal normal curvatures and
   // the directions on the tangent plane (principal direction) where the extremums are reached
   void Curvature(gp_Dir& thePrincipalDir1, Standard_Real& theCurvature1,
@@ -1998,32 +2004,63 @@ private:
 //purpose  : check the angle at the border between two squares.
 //           Two shares should have a shared front edge.
 //=======================================================================
-static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
-                              const TopoDS_Face& F1,
-                              const TopoDS_Face& F2,
-                              const Standard_Real theAngleTol)
+GeomAbs_Shape BRepLib::ContinuityOfFaces(const TopoDS_Edge&  theEdge,
+                                         const TopoDS_Face&  theFace1,
+                                         const TopoDS_Face&  theFace2,
+                                         const Standard_Real theAngleTol)
 {
-  Standard_Boolean isSeam = F1.IsEqual(F2);
+  Standard_Boolean isSeam = theFace1.IsEqual(theFace2);
 
-  TopoDS_Edge E = Ed;
+  TopoDS_Edge anEdgeInFace1, anEdgeInFace2;
+  Handle(Geom2d_Curve) aCurve1, aCurve2;
+  
+  Standard_Real aFirst, aLast;
+  
+  if (!theFace1.IsSame (theFace2) &&
+      BRep_Tool::IsClosed (theEdge, theFace1) &&
+      BRep_Tool::IsClosed (theEdge, theFace2))
+  {
+    //Find the edge in the face 1: this edge will have correct orientation
+    TopoDS_Face aFace1 = theFace1;
+    aFace1.Orientation (TopAbs_FORWARD);
+    TopExp_Explorer anExplo (aFace1, TopAbs_EDGE);
+    for (; anExplo.More(); anExplo.Next())
+    {
+      const TopoDS_Edge& anEdge = TopoDS::Edge (anExplo.Current());
+      if (anEdge.IsSame (theEdge))
+      {
+        anEdgeInFace1 = anEdge;
+        break;
+      }
+    }
+    if (anEdgeInFace1.IsNull())
+      return GeomAbs_C0;
+    
+    aCurve1 = BRep_Tool::CurveOnSurface (anEdgeInFace1, aFace1, aFirst, aLast);
+    TopoDS_Face aFace2 = theFace2;
+    aFace2.Orientation (TopAbs_FORWARD);
+    anEdgeInFace2 = anEdgeInFace1;
+    anEdgeInFace2.Reverse();
+    aCurve2 = BRep_Tool::CurveOnSurface (anEdgeInFace2, aFace2, aFirst, aLast);
+  }
+  else
+  {
+    // Obtaining of pcurves of edge on two faces.
+    anEdgeInFace1 = anEdgeInFace2 = theEdge;
+    aCurve1 = BRep_Tool::CurveOnSurface (anEdgeInFace1, theFace1, aFirst, aLast);
+    //For the case of seam edge
+    if (theFace1.IsSame(theFace2))
+      anEdgeInFace2.Reverse();
+    aCurve2 = BRep_Tool::CurveOnSurface (anEdgeInFace2, theFace2, aFirst, aLast);
+  }
 
-  // Check if pcurves exist on both faces of edge
-  Standard_Real aFirst,aLast;
-  E.Orientation(TopAbs_FORWARD);
-  Handle(Geom2d_Curve) aCurve1 = BRep_Tool::CurveOnSurface(E, F1, aFirst, aLast);
-  if(aCurve1.IsNull())
-    return GeomAbs_C0;
-
-  if (isSeam)
-    E.Orientation(TopAbs_REVERSED);
-  Handle(Geom2d_Curve) aCurve2 = BRep_Tool::CurveOnSurface(E, F2, aFirst, aLast);
-  if(aCurve2.IsNull())
+  if (aCurve1.IsNull() || aCurve2.IsNull())
     return GeomAbs_C0;
 
   TopLoc_Location aLoc1, aLoc2;
-  Handle(Geom_Surface) aSurface1 = BRep_Tool::Surface(F1, aLoc1);
+  Handle(Geom_Surface) aSurface1 = BRep_Tool::Surface (theFace1, aLoc1);
   const gp_Trsf& aSurf1Trsf = aLoc1.Transformation();
-  Handle(Geom_Surface) aSurface2 = BRep_Tool::Surface(F2, aLoc2);
+  Handle(Geom_Surface) aSurface2 = BRep_Tool::Surface (theFace2, aLoc2);
   const gp_Trsf& aSurf2Trsf = aLoc2.Transformation();
 
   if (aSurface1->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
@@ -2040,11 +2077,11 @@ static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
     return GeomAbs_CN;
   }
 
-  SurfaceProperties aSP1(aSurface1, aSurf1Trsf, aCurve1, F1.Orientation() == TopAbs_REVERSED);
-  SurfaceProperties aSP2(aSurface2, aSurf2Trsf, aCurve2, F2.Orientation() == TopAbs_REVERSED);
+  SurfaceProperties aSP1(aSurface1, aSurf1Trsf, aCurve1, theFace1.Orientation() == TopAbs_REVERSED);
+  SurfaceProperties aSP2(aSurface2, aSurf2Trsf, aCurve2, theFace2.Orientation() == TopAbs_REVERSED);
 
   Standard_Real f, l, eps;
-  BRep_Tool::Range(E,f,l);
+  BRep_Tool::Range (theEdge,f,l);
   Extrema_LocateExtPC ext;
   Handle(BRepAdaptor_Curve) aHC2;
 
@@ -2055,7 +2092,6 @@ static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
   const Standard_Real anAngleTol2 = theAngleTol * theAngleTol;
 
   gp_Vec aDer1, aDer2;
-  gp_Vec aNorm1;
   Standard_Real aSqLen1, aSqLen2;
   gp_Dir aCrvDir1[2], aCrvDir2[2];
   Standard_Real aCrvLen1[2], aCrvLen2[2];
@@ -2083,13 +2119,26 @@ static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
     aDer2 = aSP2.Derivative();
     aSqLen2 = aDer2.SquareMagnitude();
     Standard_Boolean isSmoothSuspect = (aDer1.CrossSquareMagnitude(aDer2) <= anAngleTol2 * aSqLen1 * aSqLen2);
+    if (isSmoothSuspect)
+    {
+      gp_Dir aNormal1 = aSP1.Normal();
+      if (theFace1.Orientation() == TopAbs_REVERSED)
+        aNormal1.Reverse();
+      gp_Dir aNormal2 = aSP2.Normal();
+      if (theFace2.Orientation() == TopAbs_REVERSED)
+        aNormal2.Reverse();
+      
+      if (aNormal1 * aNormal2 < 0.)
+        return GeomAbs_C0;
+    }
+    
     if (!isSmoothSuspect)
     {
       // Refine by projection
       if (aHC2.IsNull())
       {
         // adaptor for pcurve on the second surface
-        aHC2 = new BRepAdaptor_Curve (E, F2);
+        aHC2 = new BRepAdaptor_Curve (anEdgeInFace2, theFace2);
         ext.Initialize(*aHC2, f, l, Precision::PConfusion());
       }
       ext.Perform(aSP1.Value(), u);
@@ -2285,9 +2334,8 @@ void BRepLib::EncodeRegularity(TopoDS_Edge& E,
   BRep_Builder B;
   if(BRep_Tool::Continuity(E,F1,F2)<=GeomAbs_C0){
     try {
-      GeomAbs_Shape aCont = tgtfaces(E, F1, F2, TolAng);
+      GeomAbs_Shape aCont = ContinuityOfFaces(E, F1, F2, TolAng);
       B.Continuity(E,F1,F2,aCont);
-      
     }
     catch(Standard_Failure const&)
     {

src/BRepLib/BRepLib.hxx

@@ -202,7 +202,14 @@ public:
   //! orientation to have  matter in the solid. Returns
   //! False if the solid is unOrientable (open or incoherent)
   Standard_EXPORT static Standard_Boolean OrientClosedSolid (TopoDS_Solid& solid);
-  
+
+  //! Returns the order of continuity between two faces
+  //! connected by an edge
+  Standard_EXPORT static GeomAbs_Shape ContinuityOfFaces(const TopoDS_Edge&  theEdge,
+                                                         const TopoDS_Face&  theFace1,
+                                                         const TopoDS_Face&  theFace2,
+                                                         const Standard_Real theAngleTol);
+
   //! Encodes the Regularity of edges on a Shape.
   //! Warning: <TolAng> is an angular tolerance, expressed in Rad.
   //! Warning: If the edges's regularity are coded before, nothing

src/BRepLib/BRepLib_FindSurface.cxx

@@ -205,10 +205,10 @@ static void fillParams (const TColStd_Array1OfReal& theKnots,
   theParams.Append (theParMax);
 }
 
-static void fillPoints (const BRepAdaptor_Curve& theCurve,
-                        const NCollection_Vector<Standard_Real> theParams,
-                        TColgp_SequenceOfPnt& thePoints,
-                        TColStd_SequenceOfReal& theWeights)
+static void fillPoints (const BRepAdaptor_Curve&                 theCurve,
+                        const NCollection_Vector<Standard_Real>& theParams,
+                        TColgp_SequenceOfPnt&                    thePoints,
+                        TColStd_SequenceOfReal&                  theWeights)
 {
   Standard_Real aDistPrev = 0., aDistNext;
   gp_Pnt aPPrev (theCurve.Value (theParams (0))), aPNext;

src/BRepLib/BRepLib_PointCloudShape.cxx

@@ -0,0 +1,307 @@
+// Copyright (c) 2021 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BRepLib_PointCloudShape.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRepGProp.hxx>
+#include <BRepLib_ToolTriangulatedShape.hxx>
+#include <BRepTools.hxx>
+#include <BRepTopAdaptor_FClass2d.hxx>
+#include <Geom_Surface.hxx>
+#include <GProp_GProps.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <Precision.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Shape.hxx>
+
+#include <random>
+
+// =======================================================================
+// function : BRepLib_PointCloudShape
+// purpose  :
+// =======================================================================
+BRepLib_PointCloudShape::BRepLib_PointCloudShape (const TopoDS_Shape& theShape,
+                                                  const Standard_Real theTol)
+: myShape (theShape),
+  myDist (0.0),
+  myTol (theTol),
+  myNbPoints (0)
+{
+  //
+}
+
+// =======================================================================
+// function : ~BRepLib_PointCloudShape
+// purpose  :
+// =======================================================================
+BRepLib_PointCloudShape::~BRepLib_PointCloudShape()
+{
+  //
+}
+
+// =======================================================================
+// function : NbPointsByDensity
+// purpose  :
+// =======================================================================
+Standard_Integer BRepLib_PointCloudShape::NbPointsByDensity (const Standard_Real theDensity)
+{
+  clear();
+  Standard_Real aDensity = (theDensity < Precision::Confusion() ? computeDensity() : theDensity);
+  if (aDensity < Precision::Confusion())
+  {
+    return 0;
+  }
+
+  Standard_Integer aNbPoints = 0;
+  for (TopExp_Explorer aExpF(myShape, TopAbs_FACE); aExpF.More(); aExpF.Next())
+  {
+    Standard_Real anArea = faceArea(aExpF.Current());
+
+    Standard_Integer aNbPnts = Max ((Standard_Integer)std::ceil(anArea / theDensity), 1);
+    myFacePoints.Bind(aExpF.Current(), aNbPnts);
+    aNbPoints+= aNbPnts;
+  }
+  return aNbPoints;
+}
+
+// =======================================================================
+// function : GeneratePointsByDensity
+// purpose  :
+// =======================================================================
+Standard_Boolean BRepLib_PointCloudShape::GeneratePointsByDensity (const Standard_Real theDensity)
+{
+  if (myFacePoints.IsEmpty())
+  {
+    if (NbPointsByDensity (theDensity) == 0)
+    {
+      return Standard_False;
+    }
+  }
+
+  Standard_Integer aNbAdded = 0;
+  for (TopExp_Explorer aExpF (myShape, TopAbs_FACE); aExpF.More(); aExpF.Next())
+  {
+    if (addDensityPoints (aExpF.Current()))
+    {
+      aNbAdded++;
+    }
+  }
+  return (aNbAdded > 0);
+}
+
+// =======================================================================
+// function : GeneratePointsByTriangulation
+// purpose  :
+// =======================================================================
+Standard_Boolean BRepLib_PointCloudShape::GeneratePointsByTriangulation()
+{
+  clear();
+
+  Standard_Integer aNbAdded = 0;
+  for (TopExp_Explorer aExpF (myShape, TopAbs_FACE); aExpF.More(); aExpF.Next())
+  {
+    if (addTriangulationPoints (aExpF.Current()))
+    {
+      aNbAdded++;
+    }
+  }
+  return (aNbAdded > 0);
+}
+
+// =======================================================================
+// function : faceArea
+// purpose  :
+// =======================================================================
+Standard_Real BRepLib_PointCloudShape::faceArea (const TopoDS_Shape& theShape)
+{
+  Standard_Real anArea = 0.0;
+  if (myFaceArea.Find (theShape, anArea))
+  {
+    return anArea;
+  }
+
+  GProp_GProps aFaceProps;
+  BRepGProp::SurfaceProperties (theShape, aFaceProps);
+  anArea = aFaceProps.Mass();
+  myFaceArea.Bind (theShape, anArea);
+  return anArea;
+}
+
+// =======================================================================
+// function : computeDensity
+// purpose  :
+// =======================================================================
+Standard_Real BRepLib_PointCloudShape::computeDensity()
+{
+  // at first step find the face with smallest area
+  Standard_Real anAreaMin = Precision::Infinite();
+  for (TopExp_Explorer aExpF (myShape, TopAbs_FACE); aExpF.More(); aExpF.Next())
+  {
+    Standard_Real anArea = faceArea (aExpF.Current());
+    if (anArea < myTol * myTol)
+    {
+      continue;
+    }
+
+    if (anArea < anAreaMin)
+    {
+      anAreaMin = anArea;
+    }
+  }
+  return anAreaMin * 0.1;
+}
+
+// =======================================================================
+// function : NbPointsByTriangulation
+// purpose  :
+// =======================================================================
+Standard_Integer BRepLib_PointCloudShape::NbPointsByTriangulation() const
+{
+  // at first step find the face with smallest area
+  Standard_Integer aNbPoints = 0;
+  for (TopExp_Explorer aExpF (myShape, TopAbs_FACE); aExpF.More(); aExpF.Next())
+  {
+    TopLoc_Location aLoc;
+    Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (TopoDS::Face (aExpF.Current()), aLoc);
+    if (aTriangulation.IsNull())
+    {
+      continue;
+    }
+
+    aNbPoints += aTriangulation->NbNodes();
+  }
+  return aNbPoints;
+}
+
+// =======================================================================
+// function : addDensityPoints
+// purpose  :
+// =======================================================================
+Standard_Boolean BRepLib_PointCloudShape::addDensityPoints (const TopoDS_Shape& theFace)
+{
+  //addition of the points with specified density on the face by random way
+  Standard_Integer aNbPnts = (myFacePoints.IsBound (theFace) ? myFacePoints.Find (theFace) : 0);
+  if (aNbPnts == 0)
+  {
+    return Standard_False;
+  }
+
+  TopoDS_Face aFace = TopoDS::Face (theFace);
+  Standard_Real anUMin = 0.0, anUMax = 0.0, aVMin = 0.0, aVMax = 0.0;
+  BRepTools::UVBounds (aFace, anUMin, anUMax, aVMin, aVMax);
+  BRepTopAdaptor_FClass2d aClassifier (aFace, Precision::Confusion());
+
+  TopLoc_Location aLoc = theFace.Location();
+  const gp_Trsf& aTrsf = aLoc.Transformation();
+  TopLoc_Location aLoc1;
+  Handle(Geom_Surface) aSurf = BRep_Tool::Surface (aFace, aLoc1);
+  if (aSurf.IsNull())
+  {
+    return Standard_False;
+  }
+
+  std::mt19937 aRandomGenerator(0);
+  std::uniform_real_distribution<> anUDistrib(anUMin, anUMax);
+  std::uniform_real_distribution<> aVDistrib (aVMin,  aVMax);
+  for (Standard_Integer nbCurPnts = 1; nbCurPnts <= aNbPnts;)
+  {
+    const Standard_Real aU = anUDistrib(aRandomGenerator);
+    const Standard_Real aV = aVDistrib (aRandomGenerator);
+    gp_Pnt2d aUVNode (aU, aV);
+    const TopAbs_State  aState = aClassifier.Perform (aUVNode);
+    if (aState == TopAbs_OUT)
+    {
+      continue;
+    }
+
+    nbCurPnts++;
+
+    gp_Pnt aP1;
+    gp_Vec dU, dV;
+    aSurf->D1 (aU, aV, aP1, dU, dV);
+
+    gp_Vec aNorm = dU ^ dV;
+    if (aFace.Orientation() == TopAbs_REVERSED)
+    {
+      aNorm.Reverse();
+    }
+    const Standard_Real aNormMod = aNorm.Magnitude();
+    if (aNormMod > gp::Resolution())
+    {
+      aNorm /= aNormMod;
+    }
+    if (myDist > Precision::Confusion())
+    {
+      std::uniform_real_distribution<> aDistanceDistrib (0.0, myDist);
+      gp_XYZ aDeflPoint =  aP1.XYZ() + aNorm.XYZ() * aDistanceDistrib (aRandomGenerator);
+      aP1.SetXYZ (aDeflPoint);
+    }
+    aP1.Transform (aTrsf);
+    if (aNormMod > gp::Resolution())
+    {
+      aNorm = gp_Dir (aNorm).Transformed (aTrsf);
+    }
+    addPoint (aP1, aNorm, aUVNode, aFace);
+  }
+  return Standard_True;
+}
+
+// =======================================================================
+// function : addTriangulationPoints
+// purpose  :
+// =======================================================================
+Standard_Boolean  BRepLib_PointCloudShape::addTriangulationPoints (const TopoDS_Shape& theFace)
+{
+  TopLoc_Location aLoc;
+  TopoDS_Face aFace = TopoDS::Face (theFace);
+  Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aLoc);
+  if (aTriangulation.IsNull())
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc1;
+  Handle(Geom_Surface) aSurf = BRep_Tool::Surface (aFace, aLoc1);
+  const gp_Trsf& aTrsf = aLoc.Transformation();
+
+  BRepLib_ToolTriangulatedShape::ComputeNormals (aFace, aTriangulation);
+  Standard_Boolean aHasUVNode = aTriangulation->HasUVNodes();
+  for (Standard_Integer aNodeIter = 1; aNodeIter <= aTriangulation->NbNodes(); ++aNodeIter)
+  {
+    gp_Pnt aP1     = aTriangulation->Node  (aNodeIter);
+    gp_Dir aNormal = aTriangulation->Normal(aNodeIter);
+    if (!aLoc.IsIdentity())
+    {
+      aP1    .Transform (aTrsf);
+      aNormal.Transform (aTrsf);
+    }
+
+    const gp_Pnt2d anUVNode = aHasUVNode ? aTriangulation->UVNode (aNodeIter) : gp_Pnt2d();
+    addPoint (aP1, aNormal, anUVNode, aFace);
+  }
+  return Standard_True;
+}
+
+// =======================================================================
+// function : clear
+// purpose  :
+// =======================================================================
+void BRepLib_PointCloudShape::clear()
+{
+  myFaceArea.Clear();
+  myFacePoints.Clear();
+}

src/BRepLib/BRepLib_PointCloudShape.hxx

@@ -0,0 +1,116 @@
+// Copyright (c) 2021 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BRepLib_PointCloudShape_HeaderFile
+#define _BRepLib_PointCloudShape_HeaderFile
+
+#include <TopTools_DataMapOfShapeInteger.hxx>
+#include <TopTools_DataMapOfShapeReal.hxx>
+#include <Quantity_Color.hxx>
+#include <Precision.hxx>
+
+//! This tool is intended to get points from shape with specified distance from shape along normal.
+//! Can be used to simulation of points obtained in result of laser scan of shape.
+//! There are 2 ways for generation points by shape:
+//! 1. Generation points with specified density
+//! 2. Generation points using triangulation Nodes
+//! Generation of points by density using the GeneratePointsByDensity() function is not thread safe.
+class BRepLib_PointCloudShape
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  //! Constructor initialized by shape
+  Standard_EXPORT BRepLib_PointCloudShape (const TopoDS_Shape& theShape = TopoDS_Shape(),
+                                           const Standard_Real theTol = Precision::Confusion());
+
+  //! Virtual destructor
+  Standard_EXPORT virtual ~BRepLib_PointCloudShape();
+
+  //! Return loaded shape.
+  const TopoDS_Shape& Shape() const { return myShape; }
+
+  //! Set shape.
+  void SetShape (const TopoDS_Shape& theShape) { myShape = theShape; }
+
+  //! Return tolerance.
+  Standard_Real Tolerance() const { return myTol; }
+
+  //! Set tolerance.
+  void SetTolerance (Standard_Real theTol) { myTol = theTol; }
+
+  //! Returns value of the distance to define deflection of points from shape along normal to shape; 0.0 by default.
+  Standard_Real GetDistance() const { return myDist; }
+
+  //! Sets value of the distance to define deflection of points from shape along normal to shape.
+  //! Negative values of theDist parameter are ignored.
+  void SetDistance (const Standard_Real theDist) { myDist = theDist; }
+
+  //! Returns size of the point cloud for specified density.
+  Standard_EXPORT Standard_Integer NbPointsByDensity (const Standard_Real theDensity = 0.0);
+
+  //! Returns size of the point cloud for using triangulation.
+  Standard_EXPORT Standard_Integer NbPointsByTriangulation() const;
+
+  //! Computes points with specified density for initial shape.
+  //! If parameter Density is equal to 0 then density will be computed automatically by criterion:
+  //! - 10 points per minimal unreduced face area.
+  //!
+  //! Note: this function should not be called from concurrent threads without external lock.
+  Standard_EXPORT Standard_Boolean GeneratePointsByDensity (const Standard_Real theDensity = 0.0);
+
+  //! Get points from triangulation existing in the shape.
+  Standard_EXPORT Standard_Boolean GeneratePointsByTriangulation();
+
+protected:
+
+  //! Compute area of the specified face.
+  Standard_EXPORT Standard_Real faceArea (const TopoDS_Shape& theShape);
+
+  //! Computes default density points per face.
+  Standard_EXPORT Standard_Real computeDensity();
+
+  //! Adds points to face in accordance with the specified density randomly in the specified range [0, Dist].
+  Standard_EXPORT Standard_Boolean addDensityPoints (const TopoDS_Shape& theFace);
+
+  //! Adds points to face by nodes of the existing triangulation randomly in the specified range [0, Dist].
+  Standard_EXPORT Standard_Boolean addTriangulationPoints (const TopoDS_Shape& theFace);
+
+protected:
+
+  //! Method to clear maps.
+  Standard_EXPORT virtual void clear();
+
+  //! Method to add point, normal to surface in this point and face for which point computed.
+  //! @param[in] thePoint 3D point on the surface
+  //! @param[in] theNorm  surface normal at this point
+  //! @param[in] theUV    surface UV parameters
+  //! @param[in] theFace  surface (face) definition
+  Standard_EXPORT virtual void addPoint (const gp_Pnt& thePoint,
+                                         const gp_Vec& theNorm,
+                                         const gp_Pnt2d& theUV,
+                                         const TopoDS_Shape& theFace) = 0;
+
+protected:
+
+  TopoDS_Shape  myShape;
+  Standard_Real myDist;
+  Standard_Real myTol;
+  TopTools_DataMapOfShapeReal    myFaceArea;
+  TopTools_DataMapOfShapeInteger myFacePoints;
+  Standard_Integer myNbPoints;
+
+};
+
+#endif // _BRepLib_PointCloudShape_HeaderFile

src/BRepLib/BRepLib_ToolTriangulatedShape.cxx

@@ -0,0 +1,83 @@
+// Copyright (c) 2021 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BRepLib_ToolTriangulatedShape.hxx>
+
+#include <BRep_Tool.hxx>
+#include <GeomLib.hxx>
+#include <Poly.hxx>
+#include <Poly_Connect.hxx>
+#include <Precision.hxx>
+#include <TopLoc_Location.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
+
+// =======================================================================
+// function : ComputeNormals
+// purpose  :
+// =======================================================================
+void BRepLib_ToolTriangulatedShape::ComputeNormals (const TopoDS_Face& theFace,
+                                                    const Handle(Poly_Triangulation)& theTris,
+                                                    Poly_Connect& thePolyConnect)
+{
+  if (theTris.IsNull()
+   || theTris->HasNormals())
+  {
+    return;
+  }
+
+  // take in face the surface location
+  const TopoDS_Face    aZeroFace = TopoDS::Face (theFace.Located (TopLoc_Location()));
+  Handle(Geom_Surface) aSurf     = BRep_Tool::Surface (aZeroFace);
+  if (!theTris->HasUVNodes() || aSurf.IsNull())
+  {
+    // compute normals by averaging triangulation normals sharing the same vertex
+    Poly::ComputeNormals (theTris);
+    return;
+  }
+
+  const Standard_Real aTol = Precision::Confusion();
+  Standard_Integer aTri[3];
+  gp_Dir aNorm;
+  theTris->AddNormals();
+  for (Standard_Integer aNodeIter = 1; aNodeIter <= theTris->NbNodes(); ++aNodeIter)
+  {
+    // try to retrieve normal from real surface first, when UV coordinates are available
+    if (GeomLib::NormEstim (aSurf, theTris->UVNode (aNodeIter), aTol, aNorm) > 1)
+    {
+      if (thePolyConnect.Triangulation() != theTris)
+      {
+        thePolyConnect.Load (theTris);
+      }
+
+      // compute flat normals
+      gp_XYZ eqPlan (0.0, 0.0, 0.0);
+      for (thePolyConnect.Initialize (aNodeIter); thePolyConnect.More(); thePolyConnect.Next())
+      {
+        theTris->Triangle (thePolyConnect.Value()).Get (aTri[0], aTri[1], aTri[2]);
+        const gp_XYZ v1 (theTris->Node (aTri[1]).Coord() - theTris->Node (aTri[0]).Coord());
+        const gp_XYZ v2 (theTris->Node (aTri[2]).Coord() - theTris->Node (aTri[1]).Coord());
+        const gp_XYZ vv = v1 ^ v2;
+        const Standard_Real aMod = vv.Modulus();
+        if (aMod >= aTol)
+        {
+          eqPlan += vv / aMod;
+        }
+      }
+      const Standard_Real aModMax = eqPlan.Modulus();
+      aNorm = (aModMax > aTol) ? gp_Dir (eqPlan) : gp::DZ();
+    }
+
+    theTris->SetNormal (aNodeIter, aNorm);
+  }
+}

src/BRepLib/BRepLib_ToolTriangulatedShape.hxx

@@ -0,0 +1,50 @@
+// Copyright (c) 2021 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BrepLib_ToolTriangulatedShape_HeaderFile
+#define _BrepLib_ToolTriangulatedShape_HeaderFile
+
+#include <Poly_Connect.hxx>
+#include <Poly_Triangulation.hxx>
+
+class TopoDS_Face;
+class Poly_Triangulation;
+
+//! Provides methods for calculating normals to Poly_Triangulation of TopoDS_Face.
+class BRepLib_ToolTriangulatedShape
+{
+public:
+
+  //! Computes nodal normals for Poly_Triangulation structure using UV coordinates and surface.
+  //! Does nothing if triangulation already defines normals.
+  //! @param[in] theFace the face
+  //! @param[in] theTris the definition of a face triangulation
+  static void ComputeNormals (const TopoDS_Face& theFace,
+                              const Handle(Poly_Triangulation)& theTris)
+  {
+    Poly_Connect aPolyConnect;
+    ComputeNormals (theFace, theTris, aPolyConnect);
+  }
+
+  //! Computes nodal normals for Poly_Triangulation structure using UV coordinates and surface.
+  //! Does nothing if triangulation already defines normals.
+  //! @param[in] theFace the face
+  //! @param[in] theTris the definition of a face triangulation
+  //! @param[in,out] thePolyConnect optional, initialized tool for exploring triangulation
+  Standard_EXPORT static void ComputeNormals (const TopoDS_Face& theFace,
+                                              const Handle(Poly_Triangulation)& theTris,
+                                              Poly_Connect& thePolyConnect);
+
+};
+
+#endif

src/BRepLib/FILES

@@ -30,8 +30,12 @@ BRepLib_MakeVertex.hxx
 BRepLib_MakeWire.cxx
 BRepLib_MakeWire.hxx
 BRepLib_MakeWire_1.cxx
+BRepLib_PointCloudShape.hxx
+BRepLib_PointCloudShape.cxx
 BRepLib_ShapeModification.hxx
 BRepLib_ShellError.hxx
+BRepLib_ToolTriangulatedShape.hxx
+BRepLib_ToolTriangulatedShape.cxx
 BRepLib_ValidateEdge.cxx
 BRepLib_ValidateEdge.hxx
 BRepLib_WireError.hxx

src/BRepPrimAPI/BRepPrimAPI_MakeRevolution.cxx

@@ -29,7 +29,7 @@
 //purpose  : 
 //=======================================================================
 static Handle(Geom2d_Curve) Project(const Handle(Geom_Curve)& M,
-				    const gp_Ax3 Axis)
+                                    const gp_Ax3&             Axis)
 {
   Handle(Geom2d_Curve) C;
   C = GeomProjLib::Curve2d(M,new Geom_Plane(Axis));

src/BRepTest/BRepTest_FeatureCommands.cxx

@@ -42,6 +42,7 @@
 #include <LocOpe_FindEdgesInFace.hxx>
 
 #include <BRepOffset_MakeOffset.hxx>
+#include <BRepOffsetAPI_MakeOffsetShape.hxx>
 #include <BRepOffset_MakeSimpleOffset.hxx>
 #include <BRep_Builder.hxx>
 #include <DBRep.hxx>
@@ -976,6 +977,81 @@ Standard_Integer thickshell(Draw_Interpretor& theCommands,
   return 0;
 }
 
+//=======================================================================
+//function : mkoffsetshape
+//purpose :
+//=======================================================================
+static Standard_Integer mkoffsetshape(Draw_Interpretor& theDI,
+  Standard_Integer  theArgNb,
+  const char**      theArgVec)
+{
+  if (theArgNb < 4)
+  {
+    return 0;
+  }
+  TopoDS_Shape aShape = DBRep::Get(theArgVec[2]);
+  if (aShape.IsNull())
+  {
+    theDI << "Shape is null";
+    return 1;
+  }
+  Standard_Real anOffVal = Draw::Atof(theArgVec[3]);
+  BRepOffsetAPI_MakeOffsetShape aMaker;
+  if (theArgNb == 4)
+  {
+    aMaker.PerformBySimple(aShape, anOffVal);
+  }
+  else
+  {
+    Standard_Real aTol = Draw::Atof(theArgVec[4]);
+
+    Standard_Boolean anInt = Standard_False;
+    if (theArgNb > 5)
+    {
+      if ((Draw::Atof(theArgVec[5]) == 1))
+      {
+        anInt = Standard_True;
+      }
+    }
+
+    Standard_Boolean aSelfInt = Standard_False;
+    if (theArgNb > 6)
+    {
+      if (Draw::Atof(theArgVec[6]) == 1)
+      {
+        aSelfInt = Standard_True;
+      }
+    }
+
+    GeomAbs_JoinType aJoin = GeomAbs_Arc;
+    if (theArgNb > 7)
+    {
+      if (!strcmp(theArgVec[7], "i"))
+      {
+        aJoin = GeomAbs_Intersection;
+      }
+    }
+
+    Standard_Boolean aRemIntEdges = Standard_False;
+    if (theArgNb > 8)
+    {
+      if (Draw::Atof(theArgVec[8]) == 1)
+      {
+        aRemIntEdges = Standard_True;
+      }
+    }
+    aMaker.PerformByJoin(aShape, anOffVal, aTol, BRepOffset_Skin, anInt, aSelfInt, aJoin, aRemIntEdges);
+  }
+  
+  if (!aMaker.IsDone())
+  {
+    theDI << " Error: Offset is not done.\n";
+    return 1;
+  }
+  DBRep::Set(theArgVec[1], aMaker.Shape());
+  return 0;
+}
+
 //=======================================================================
 //function : offsetshape
 //purpose  : 
@@ -2477,6 +2553,10 @@ void BRepTest::FeatureCommands(Draw_Interpretor& theCommands)
     "thickshell r shape offset [jointype [tol] ]",
     __FILE__, thickshell, g);
 
+  theCommands.Add("mkoffsetshape",
+    "mkoffsetshape r shape offset [Tol] [Intersection(0/1)] [SelfInter(0/1)] [JoinType(a/i)] [RemoveInternalEdges(0/1)]",
+    __FILE__, mkoffsetshape, g);
+
   theCommands.Add("offsetshape",
     "offsetshape r shape offset [tol] [face ...]",
     __FILE__, offsetshape, g);

src/BRepTools/BRepTools.cxx

@@ -695,7 +695,7 @@ Standard_Boolean  BRepTools::Write (const TopoDS_Shape& theShape,
                                     const Message_ProgressRange& theProgress)
 {
   const Handle(OSD_FileSystem)& aFileSystem = OSD_FileSystem::DefaultFileSystem();
-  std::shared_ptr<std::ostream> aStream = aFileSystem->OpenOStream (theFile, std::ios::out);
+  std::shared_ptr<std::ostream> aStream = aFileSystem->OpenOStream (theFile, std::ios::out | std::ios::binary);
   if (aStream.get() == NULL || !aStream->good())
   {
     return Standard_False;

src/BRepTools/BRepTools_WireExplorer.cxx

@@ -54,6 +54,29 @@ static Standard_Real GetNextParamOnPC(const Handle(Geom2d_Curve)& aPC,
 				      const Standard_Real& tolV,
 				      const Standard_Boolean& reverse);
 
+static Standard_Real LocalUresol (const TopoDS_Vertex& theVertex,
+                                  const TopoDS_Face&   theFace,
+                                  const gp_Pnt2d&      theP2d1,
+                                  const gp_Pnt2d&      theP2d2)
+{
+  Standard_Real aResol = -1;
+
+  BRepAdaptor_Surface aBAsurf (theFace, Standard_False);
+  if (aBAsurf.GetType() == GeomAbs_Sphere)
+  {
+    Standard_Real aRadius = aBAsurf.Sphere().Radius();
+    Standard_Real aVmid = (theP2d1.Y() + theP2d2.Y())/2.;
+    Standard_Real aLocalRad = aRadius * Cos(aVmid);
+    if (aLocalRad > Precision::Confusion())
+    {
+      Standard_Real aTolVertex = BRep_Tool::Tolerance (theVertex);
+      aResol = aTolVertex / aLocalRad;
+    }
+  }
+
+  return aResol;
+}
+
 //=======================================================================
 //function : BRepTools_WireExplorer
 //purpose  : 
@@ -536,56 +559,56 @@ void  BRepTools_WireExplorer::Next()
         it.Initialize(l);
         while( it.More() )
         {
-	        const TopoDS_Edge& E = TopoDS::Edge(it.Value());
-	        if( E.IsSame(myEdge) )
-	        {
-	          it.Next();
-	          k++;
-	          continue;
-	        }
-  		
-	        TopoDS_Vertex aVert1, aVert2;
-	        TopExp::Vertices (E, aVert1, aVert2, Standard_True);
-	        if( aVert1.IsNull() || aVert2.IsNull() )
+          const TopoDS_Edge& E = TopoDS::Edge(it.Value());
+          if( E.IsSame(myEdge) )
           {
             it.Next();
             k++;
             continue;
           }
-  		
-	        aPCurve = BRep_Tool::CurveOnSurface (E, myFace, dfFPar, dfLPar);
-	        if( aPCurve.IsNull() )
+          
+          TopoDS_Vertex aVert1, aVert2;
+          TopExp::Vertices (E, aVert1, aVert2, Standard_True);
+          if( aVert1.IsNull() || aVert2.IsNull() )
           {
             it.Next();
             k++;
             continue;
           }
-    		
-	        gp_Pnt2d aPEb, aPEe;
-	        if( aVert1.IsSame(aVert2) == isDegenerated )
-	        {
-	          if( E.Orientation() == TopAbs_REVERSED )
-	            aPCurve->D0(dfLPar, aPEb);
-	          else	
-	            aPCurve->D0(dfFPar, aPEb);
-
-	          if( Abs(dfLPar-dfFPar) > Precision::PConfusion() )
-	          {
-		          isrevese = ( E.Orientation() == TopAbs_REVERSED );
-		          isrevese = !isrevese;
-		          Standard_Real aEPm = GetNextParamOnPC(aPCurve,aPEb,dfFPar,dfLPar,myTolU,myTolV,isrevese);
-        			
-		          aPCurve->D0 (aEPm, aPEe);
+          
+          aPCurve = BRep_Tool::CurveOnSurface (E, myFace, dfFPar, dfLPar);
+          if( aPCurve.IsNull() )
+          {
+            it.Next();
+            k++;
+            continue;
+          }
+          
+          gp_Pnt2d aPEb, aPEe;
+          if( aVert1.IsSame(aVert2) == isDegenerated )
+          {
+            if( E.Orientation() == TopAbs_REVERSED )
+              aPCurve->D0(dfLPar, aPEb);
+            else	
+              aPCurve->D0(dfFPar, aPEb);
+            
+            if( Abs(dfLPar-dfFPar) > Precision::PConfusion() )
+            {
+              isrevese = ( E.Orientation() == TopAbs_REVERSED );
+              isrevese = !isrevese;
+              Standard_Real aEPm = GetNextParamOnPC(aPCurve,aPEb,dfFPar,dfLPar,myTolU,myTolV,isrevese);
+              
+              aPCurve->D0 (aEPm, aPEe);
               if(aPEb.SquareDistance(aPEe) <= gp::Resolution())
               {
                 //seems to be very short curve
                 gp_Vec2d aD;
                 aPCurve->D1(aEPm, aPEe, aD);
-	              if( E.Orientation() == TopAbs_REVERSED )
+                if( E.Orientation() == TopAbs_REVERSED )
                   aPEe.SetXY(aPEb.XY()-aD.XY());
-	              else	
+                else	
                   aPEe.SetXY(aPEb.XY()+aD.XY());
-
+                
                 if(aPEb.SquareDistance(aPEe) <= gp::Resolution())
                 {
                   it.Next();
@@ -593,35 +616,39 @@ void  BRepTools_WireExplorer::Next()
                   continue;
                 }
               }
-		          gp_Vec2d anEDir(aPEb, aPEe);
-		          dfCurAngle = Abs( anEDir.Angle(anERefDir) );
-	          }
-
-	          if( dfCurAngle <= dfMinAngle )
-	          {
-		          Standard_Real d = PRef.SquareDistance(aPEb);
-		          if( d <= Precision::PConfusion() )
-		            d = 0.;
-		          if( Abs(aPEb.X()-PRef.X()) < myTolU  &&  Abs(aPEb.Y()-PRef.Y()) < myTolV )
-		          {
-		            if( d <= dmin )
-		            {
-			            dfMinAngle = dfCurAngle;
-			            kMin = k;
-			            dmin = d;
-		            }
-		          }
-	          }
-	        }
-	        it.Next();
-	        k++;
+              gp_Vec2d anEDir(aPEb, aPEe);
+              dfCurAngle = Abs( anEDir.Angle(anERefDir) );
+            }
+            
+            if( dfCurAngle <= dfMinAngle )
+            {
+              Standard_Real d = PRef.SquareDistance(aPEb);
+              if( d <= Precision::PConfusion() )
+                d = 0.;
+              //jgv
+              Standard_Real aLocalUresol = LocalUresol (myVertex, myFace, PRef, aPEb);
+              aLocalUresol = Max (aLocalUresol, myTolU);
+              /////
+              if( Abs(aPEb.X()-PRef.X()) < aLocalUresol  &&  Abs(aPEb.Y()-PRef.Y()) < myTolV )
+              {
+                if( d <= dmin )
+                {
+                  dfMinAngle = dfCurAngle;
+                  kMin = k;
+                  dmin = d;
+                }
+              }
+            }
+          }
+          it.Next();
+          k++;
         }// while it
 
         if( kMin == 0 )
         {
-	        isDegenerated = Standard_False;
-	        k = 1;
-	        dmin = RealLast();
+          isDegenerated = Standard_False;
+          k = 1;
+          dmin = RealLast();
         }
         else
           break;

src/BinTools/BinTools_ShapeSetBase.cxx

@@ -28,7 +28,7 @@ const Standard_CString BinTools_ShapeSetBase::THE_ASCII_VERSIONS[BinTools_Format
 //function : operator << (gp_Pnt)
 //purpose  : 
 //=======================================================================
-Standard_OStream& operator << (Standard_OStream& OS, const gp_Pnt P)
+Standard_OStream& operator << (Standard_OStream& OS, const gp_Pnt& P)
 {
   BinTools::PutReal (OS, P.X());
   BinTools::PutReal (OS, P.Y());

src/BinTools/BinTools_ShapeSetBase.hxx

@@ -27,7 +27,7 @@ class TopoDS_Shape;
 class gp_Pnt;
 
 //! Writes to the stream a gp_Pnt data
-Standard_OStream& operator << (Standard_OStream& OS, const gp_Pnt P);
+Standard_OStream& operator << (Standard_OStream& OS, const gp_Pnt& P);
 
 //! Computes a hash code for the given value of the uint64_t type, in range [1, theUpperBound]
 inline Standard_Integer HashCode (const uint64_t theValue, const Standard_Integer theUpperBound)

src/Bnd/Bnd_Box.cxx

@@ -46,7 +46,7 @@ Bnd_Box::Bnd_Box()
 //function : Bnd_Box
 //purpose  : 
 //=======================================================================
-Bnd_Box::Bnd_Box (const gp_Pnt theMin, const gp_Pnt theMax)
+Bnd_Box::Bnd_Box (const gp_Pnt& theMin, const gp_Pnt& theMax)
 : Gap (0.0)
 {
   SetVoid();

src/Bnd/Bnd_Box.hxx

@@ -71,7 +71,7 @@ public:
   //! Creates a bounding box, it contains:
   //! -   minimum/maximum point of bounding box,
   //! The constructed box is qualified Void. Its gap is null.
-  Standard_EXPORT Bnd_Box (const gp_Pnt theMin, const gp_Pnt theMax);
+  Standard_EXPORT Bnd_Box (const gp_Pnt& theMin, const gp_Pnt& theMax);
 
   //! Sets this bounding box so that it covers the whole of 3D space.
   //! It is infinitely long in all directions.

src/BndLib/BndLib_Add3dCurve.cxx

@@ -217,7 +217,7 @@ void BndLib_Add3dCurve::Add( const Adaptor3d_Curve& C,
 	  if(Bsaux->LastParameter()  < U2 ) u2  = Bsaux->LastParameter();
 	  //  modified by NIZHNY-EAP Fri Dec  3 14:29:18 1999 ___END___
 	}
-        Standard_Real aSegmentTol = Precision::PConfusion();
+        Standard_Real aSegmentTol = 2. * Precision::PConfusion();
         if (Abs(u2 - u1) < aSegmentTol)
           aSegmentTol = Abs(u2 - u1) * 0.01;
 	Bsaux->Segment(u1, u2, aSegmentTol);

src/BndLib/BndLib_AddSurface.cxx

@@ -798,7 +798,7 @@ public:
 private:
   SurfMaxMinCoord & operator = (const SurfMaxMinCoord & theOther);
 
-  Standard_Boolean CheckInputData(const math_Vector theParams)
+  Standard_Boolean CheckInputData(const math_Vector& theParams)
   {
     if (theParams(1) < myUMin || 
         theParams(1) > myUMax || 

src/CDF/CDF_Store.cxx

@@ -78,19 +78,11 @@ Standard_Boolean  CDF_Store::SetFolder(const Standard_ExtString aFolder) {
 Standard_Boolean  CDF_Store::SetFolder(const TCollection_ExtendedString& aFolder) {
 
   TCollection_ExtendedString theFolder(aFolder);
-  Standard_Integer l = theFolder.Length();
+  Standard_Integer aLen = theFolder.Length();
 
-  // if the last character is the folder separator (which is always the first character)
-  // it is removed.
-	// This is correct for Unix systems but not for Windows! VMS and MAC? Thomas Haller, 23.11.01
-  if(l > 1) {
-#ifndef _WIN32
-    if(theFolder.Value(l) == theFolder.Value(1)) theFolder.Trunc(l-1);
-#else
-	if (theFolder.Value(l) == '/' || theFolder.Value(l) == '\\')
-		theFolder.Trunc(l-1);
-#endif
-  }
+  // if the last character is the folder separator, remove it.
+  if (aLen > 1 && (theFolder.Value(aLen) == '/' || theFolder.Value(aLen) == '\\'))
+    theFolder.Trunc(aLen-1);
 
   if(theMetaDataDriver->FindFolder(theFolder))  {
     myCurrentDocument->SetRequestedFolder(theFolder);

src/ChFi3d/ChFi3d.cxx

@@ -134,12 +134,12 @@ ChFiDS_TypeOfConcavity ChFi3d::DefineConnectType(const TopoDS_Edge&     E,
 //function : IsTangentFaces
 //purpose  : 
 //=======================================================================
-Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
-                                        const TopoDS_Face& theFace1,
-                                        const TopoDS_Face& theFace2,
-                                        const GeomAbs_Shape Order)
+Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge&  theEdge,
+                                        const TopoDS_Face&  theFace1,
+                                        const TopoDS_Face&  theFace2,
+                                        const GeomAbs_Shape theOrder)
 {
-  if (Order == GeomAbs_G1 && BRep_Tool::Continuity(theEdge, theFace1, theFace2) != GeomAbs_C0)
+  if (theOrder == GeomAbs_G1 && BRep_Tool::Continuity(theEdge, theFace1, theFace2) != GeomAbs_C0)
     return Standard_True;
 
   Standard_Real TolC0 = Max(0.001, 1.5*BRep_Tool::Tolerance(theEdge));
@@ -147,15 +147,46 @@ Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
   Standard_Real aFirst;
   Standard_Real aLast;
 
-  // Obtaining of pcurves of edge on two faces.
-  const Handle(Geom2d_Curve) aC2d1 = BRep_Tool::CurveOnSurface
-    (theEdge, theFace1, aFirst, aLast);
-  //For the case of seam edge
-  TopoDS_Edge EE = theEdge;
-  if (theFace1.IsSame(theFace2))
-    EE.Reverse();
-  const Handle(Geom2d_Curve) aC2d2 = BRep_Tool::CurveOnSurface
-    (EE, theFace2, aFirst, aLast);
+  Handle(Geom2d_Curve) aC2d1, aC2d2;
+  
+  if (!theFace1.IsSame (theFace2) &&
+      BRep_Tool::IsClosed (theEdge, theFace1) &&
+      BRep_Tool::IsClosed (theEdge, theFace2))
+  {
+    //Find the edge in the face 1: this edge will have correct orientation
+    TopoDS_Edge anEdgeInFace1;
+    TopoDS_Face aFace1 = theFace1;
+    aFace1.Orientation (TopAbs_FORWARD);
+    TopExp_Explorer anExplo (aFace1, TopAbs_EDGE);
+    for (; anExplo.More(); anExplo.Next())
+    {
+      const TopoDS_Edge& anEdge = TopoDS::Edge (anExplo.Current());
+      if (anEdge.IsSame (theEdge))
+      {
+        anEdgeInFace1 = anEdge;
+        break;
+      }
+    }
+    if (anEdgeInFace1.IsNull())
+      return Standard_False;
+    
+    aC2d1 = BRep_Tool::CurveOnSurface (anEdgeInFace1, aFace1, aFirst, aLast);
+    TopoDS_Face aFace2 = theFace2;
+    aFace2.Orientation (TopAbs_FORWARD);
+    anEdgeInFace1.Reverse();
+    aC2d2 = BRep_Tool::CurveOnSurface (anEdgeInFace1, aFace2, aFirst, aLast);
+  }
+  else
+  {
+    // Obtaining of pcurves of edge on two faces.
+    aC2d1 = BRep_Tool::CurveOnSurface (theEdge, theFace1, aFirst, aLast);
+    //For the case of seam edge
+    TopoDS_Edge EE = theEdge;
+    if (theFace1.IsSame(theFace2))
+      EE.Reverse();
+    aC2d2 = BRep_Tool::CurveOnSurface (EE, theFace2, aFirst, aLast);
+  }
+  
   if (aC2d1.IsNull() || aC2d2.IsNull())
     return Standard_False;
 
@@ -186,15 +217,19 @@ Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
     if (i == aNbSamples) aPar = aLast;
 
     LocalAnalysis_SurfaceContinuity aCont(aC2d1, aC2d2, aPar,
-      aSurf1, aSurf2, Order,
+      aSurf1, aSurf2, theOrder,
       0.001, TolC0, 0.1, 0.1, 0.1);
     if (!aCont.IsDone())
     {
+      if (theOrder == GeomAbs_C2 &&
+          aCont.StatusError() == LocalAnalysis_NullSecondDerivative)
+        continue;
+      
       nbNotDone++;
       continue;
     }
 
-    if (Order == GeomAbs_G1)
+    if (theOrder == GeomAbs_G1)
     {
       if (!aCont.IsG1())
         return Standard_False;

src/ChFi3d/ChFi3d_Builder_C1.cxx

@@ -1502,12 +1502,12 @@ static Standard_Boolean  containE(const TopoDS_Face & F1,
 //           <tol> from <Param>, check points between <Pf> and <Pl>
 //=======================================================================
 
-static Standard_Boolean IsShrink(const Geom2dAdaptor_Curve PC,
-                                 const Standard_Real       Pf,
-                                 const Standard_Real       Pl,
-                                 const Standard_Real       Param,
-                                 const Standard_Boolean    isU,
-                                 const Standard_Real       tol)
+static Standard_Boolean IsShrink(const Geom2dAdaptor_Curve& PC,
+                                 const Standard_Real        Pf,
+                                 const Standard_Real        Pl,
+                                 const Standard_Real        Param,
+                                 const Standard_Boolean     isU,
+                                 const Standard_Real        tol)
 {
   switch (PC.GetType()) {
   case GeomAbs_Line: {
@@ -1997,6 +1997,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
       if ((possible1 && possible2) || (!possible1 && !possible2) || (nbarete > 4)) {
 	while (!trouve) {
 	  nb++;
+	  if (nb>=nn) throw Standard_Failure("IntersectionAtEnd : the max number of faces reached");
 	  if (nb!=1) F3=Face[nb-2];
 	  Face[nb-1]=F3;
 	  if (CV1.Arc().IsSame(edgelibre1))

src/ChFi3d/ChFi3d_ChBuilder_C3.cxx

@@ -60,10 +60,10 @@
 //           la distance de PntD par rapport au plan passant par les trois 
 //           points PntA, PntB, PntC
 //=======================================================================
-static Standard_Boolean CoPlanar(const gp_Pnt  PntA,
-	            const gp_Pnt  PntB,
-		    const gp_Pnt  PntC,
-		    const gp_Pnt  PntD)
+static Standard_Boolean CoPlanar(const gp_Pnt& PntA,
+                                 const gp_Pnt& PntB,
+                                 const gp_Pnt& PntC,
+                                 const gp_Pnt& PntD)
 {
   gp_Vec vecAB(PntA, PntB);
   gp_Vec vecAC(PntA, PntC);

src/D3DHost/D3DHost_FrameBuffer.cxx

@@ -195,7 +195,7 @@ Standard_Boolean D3DHost_FrameBuffer::InitD3dInterop (const Handle(OpenGl_Contex
 
   const OpenGl_TextureFormat aDepthFormat = OpenGl_TextureFormat::FindSizedFormat (theCtx, myDepthFormat);
   if (aDepthFormat.IsValid()
-  && !myDepthStencilTexture->Init (theCtx, aDepthFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TOT_2D))
+  && !myDepthStencilTexture->Init (theCtx, aDepthFormat, Graphic3d_Vec2i (aSizeX, aSizeY), Graphic3d_TypeOfTexture_2D))
   {
     Release (theCtx.get());
     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,

src/D3DHost/D3DHost_View.cxx

@@ -128,7 +128,8 @@ IDirect3DSurface9* D3DHost_View::D3dColorSurface() const
 // function : SetWindow
 // purpose  :
 // =======================================================================
-void D3DHost_View::SetWindow (const Handle(Aspect_Window)& theWindow,
+void D3DHost_View::SetWindow (const Handle(Graphic3d_CView)& theParentVIew,
+                              const Handle(Aspect_Window)& theWindow,
                               const Aspect_RenderingContext theContext)
 {
   if (!myD3dWglFbo.IsNull())
@@ -142,7 +143,7 @@ void D3DHost_View::SetWindow (const Handle(Aspect_Window)& theWindow,
     myD3dDevice = NULL;
   }
 
-  OpenGl_View::SetWindow (theWindow, theContext);
+  OpenGl_View::SetWindow (theParentVIew, theWindow, theContext);
 
   if (!myWindow.IsNull())
   {

src/D3DHost/D3DHost_View.hxx

@@ -44,12 +44,8 @@ public:
   Standard_EXPORT virtual void ReleaseGlResources (const Handle(OpenGl_Context)& theCtx) Standard_OVERRIDE;
 
   //! Creates and maps rendering window to the view.
-  //! @param theWindow [in] the window.
-  //! @param theContext [in] the rendering context. If NULL the context will be created internally.
-  //! @param theDisplayCB [in] the display callback function. If is not a NULL value, then the callback will be
-  //! invoked at the end of the OCC graphic traversal and just before the swap of buffers.
-  //! @param theClientData [in] the client data for the callback.
-  Standard_EXPORT virtual void SetWindow (const Handle(Aspect_Window)&  theWindow,
+  Standard_EXPORT virtual void SetWindow (const Handle(Graphic3d_CView)& theParentVIew,
+                                          const Handle(Aspect_Window)& theWindow,
                                           const Aspect_RenderingContext theContext) Standard_OVERRIDE;
 
   //! Resizes the window.

src/DPrsStd/DPrsStd_AISViewerCommands.cxx

@@ -56,7 +56,7 @@ static Standard_Integer DPrsStd_AISInitViewer (Draw_Interpretor& theDI,
   TCollection_AsciiString   aViewName = TCollection_AsciiString ("Driver1/Document_") + theArgVec[1] + "/View1";
   if (!TPrsStd_AISViewer::Find (aRoot, aDocViewer))
   {
-    ViewerTest::ViewerInit (0, 0, 0, 0, aViewName.ToCString(), "");
+    ViewerTest::ViewerInit (aViewName);
     aDocViewer = TPrsStd_AISViewer::New (aRoot, ViewerTest::GetAISContext());
   }
 

src/DRAWEXE/DRAWEXE.cxx

@@ -18,6 +18,7 @@
 #include <DrawTrSurf.hxx>
 #include <Message.hxx>
 #include <Message_PrinterOStream.hxx>
+#include <Message_PrinterSystemLog.hxx>
 #include <NCollection_IndexedMap.hxx>
 #include <OSD.hxx>
 #include <OSD_Thread.hxx>

src/Draw/Draw_BasicCommands.cxx

@@ -75,146 +75,150 @@ static OSD_Timer aTimer;
 
 extern Standard_Boolean Draw_Chrono;
 
-static Standard_Integer chronom(Draw_Interpretor& di,
-				Standard_Integer n,const char** a)
+static Standard_Integer dchronom (Draw_Interpretor& theDI,
+                                  Standard_Integer theNbArgs,
+                                  const char** theArgVec)
 {
-  if ((n == 1) || (*a[1] == '0') || (*a[1] == '1')) {
-    if (n == 1)
+  if (theNbArgs == 1
+   || (theNbArgs == 2
+    && (*theArgVec[1] == '0'
+     || *theArgVec[1] == '1')))
+  {
+    if (theNbArgs == 1)
+    {
       Draw_Chrono = !Draw_Chrono;
+    }
     else
-      Draw_Chrono = (*a[1] == '1');
+    {
+      Draw_Chrono = (*theArgVec[1] == '1');
+    }
 
-    if (Draw_Chrono) di << "Chronometers activated.\n";
-    else di << "Chronometers deactivated.\n";
+    theDI << (Draw_Chrono
+           ? "Chronometers activated.\n"
+           : "Chronometers deactivated.\n");
+    return 0;
   }
-  else {
-    Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
-    Handle(Draw_Chronometer) C;
-    if (!D.IsNull()) {
-      C = Handle(Draw_Chronometer)::DownCast(D);
-    }
-    if (C.IsNull()) {
-      C = new Draw_Chronometer();
-    Draw::Set(a[1],C,Standard_False);
-    }
-    if (n <= 2) {
-      C->Timer().Reset();
-    }
-    else {
-      for (Standard_Integer anIter = 2; anIter < n; ++anIter)
-      {
-        TCollection_AsciiString anArg (a[anIter]);
-        anArg.LowerCase();
 
-        if (anArg == "reset")
-        {
-          C->Timer().Reset();
-        }
-        else if (anArg == "restart")
-        {
-          C->Timer().Restart();
-        }
-        else if (anArg == "start")
-        {
-          C->Timer().Start();
-        }
-        else if (anArg == "stop")
-        {
-          C->Timer().Stop();
-        }
-        else if (anArg == "show")
-        {
-          C->Timer().Show();
-        }
-        else if (anArg == "counter")
-        {
-          Standard_Real aSeconds,aCPUtime;
-          Standard_Integer aMinutes, aHours;
-          C->Timer().Show(aSeconds,aMinutes,aHours,aCPUtime);
-          std::cout << "COUNTER " << a[++anIter] << ": " << aCPUtime << "\n";
-        }
-        else
-        {
-          std::cerr << "Unknown argument '" << a[anIter] << "'!\n";
-        }
+  const char* aTimerName = theArgVec[1];
+  Handle(Draw_Chronometer) aChronom;
+  if (Handle(Draw_Drawable3D) aDrawable = Draw::Get (aTimerName))
+  {
+    aChronom = Handle(Draw_Chronometer)::DownCast (aDrawable);
+  }
+  if (aChronom.IsNull())
+  {
+    aChronom = new Draw_Chronometer();
+    Draw::Set (aTimerName, aChronom, false);
+  }
+
+  if (theNbArgs <= 2)
+  {
+    aChronom->Timer().Reset();
+    return 0;
+  }
+
+  const bool toShowCout = (TCollection_AsciiString (theArgVec[0]) == "chrono");
+  int aNbPuts = false;
+  for (Standard_Integer anIter = 2; anIter < theNbArgs; ++anIter)
+  {
+    TCollection_AsciiString anArg (theArgVec[anIter]);
+    anArg.LowerCase();
+    if (anArg == "-reset"
+     || anArg == "reset")
+    {
+      aChronom->Timer().Reset();
+    }
+    else if (anArg == "-restart"
+          || anArg == "restart")
+    {
+      aChronom->Timer().Restart();
+    }
+    else if (anArg == "-start"
+          || anArg == "-resume"
+          || anArg == "start")
+    {
+      aChronom->Timer().Start();
+    }
+    else if (anArg == "-stop"
+          || anArg == "-pause"
+          || anArg == "stop")
+    {
+      aChronom->Timer().Stop();
+    }
+    else if (anArg == "-show"
+          || anArg == "show")
+    {
+      if (toShowCout)
+      {
+        aChronom->Timer().Show (std::cout);
       }
+      else
+      {
+        Standard_SStream aStream;
+        aChronom->Timer().Show (aStream);
+        theDI << aStream;
+      }
+    }
+    else if (anIter + 1 < theNbArgs
+          && (anArg == "-counter"
+           || anArg == "counter"))
+    {
+      Standard_Real aSeconds = 0.0, aCPUtime = 0.0;
+      Standard_Integer aMinutes = 0, aHours = 0;
+      aChronom->Timer().Show (aSeconds, aMinutes, aHours, aCPUtime);
+      if (toShowCout)
+      {
+        std::cout << "COUNTER " << theArgVec[++anIter] << ": " << aCPUtime << "\n";
+      }
+      else
+      {
+        theDI << "COUNTER " << theArgVec[++anIter] << ": " << aCPUtime << "\n";
+      }
+    }
+    else if (anArg == "-elapsed")
+    {
+      if (++aNbPuts > 1) { theDI << " "; }
+      theDI << aChronom->Timer().ElapsedTime();
+    }
+    else if (anArg == "-cpu"
+          || anArg == "-usercpu"
+          || anArg == "-cpuuser")
+    {
+      if (++aNbPuts > 1) { theDI << " "; }
+      theDI << aChronom->Timer().UserTimeCPU();
+    }
+    else if (anArg == "-systemcpu"
+          || anArg == "-syscpu"
+          || anArg == "-cpusystem"
+          || anArg == "-cpusys")
+    {
+      if (++aNbPuts > 1) { theDI << " "; }
+      theDI << aChronom->Timer().SystemTimeCPU();
+    }
+    else if (anArg == "-thread"
+          || anArg == "-threadonly")
+    {
+      bool isThreadOnly = Draw::ParseOnOffIterator (theNbArgs, theArgVec, anIter);
+      aChronom->Timer().Stop();
+      aChronom->Timer().Reset();
+      aChronom->Timer().SetThisThreadOnly (isThreadOnly);
+    }
+    else if (anArg == "-process")
+    {
+      bool isProcessTime = Draw::ParseOnOffIterator (theNbArgs, theArgVec, anIter);
+      aChronom->Timer().Stop();
+      aChronom->Timer().Reset();
+      aChronom->Timer().SetThisThreadOnly (!isProcessTime);
+    }
+    else
+    {
+      theDI << "Syntax error at '" << theArgVec[anIter] << "'\n";
+      return 1;
     }
   }
   return 0;
 }
 
-static Standard_Integer dchronom(Draw_Interpretor& theDI,
-				 Standard_Integer n,const char** a)
-{
-  if ((n == 1) || (*a[1] == '0') || (*a[1] == '1')) {
-    if (n == 1)
-      Draw_Chrono = !Draw_Chrono;
-    else
-      Draw_Chrono = (*a[1] == '1');
-
-    if (Draw_Chrono) theDI << "Chronometers activated.\n";
-    else theDI << "Chronometers deactivated.\n";
-  }
-  else {
-    Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
-    Handle(Draw_Chronometer) C;
-    if (!D.IsNull()) {
-      C = Handle(Draw_Chronometer)::DownCast(D);
-    }
-    if (C.IsNull()) {
-      C = new Draw_Chronometer();
-      Draw::Set(a[1],C,Standard_False);
-    }
-    if (n <= 2) {
-      C->Timer().Reset();
-    }
-    else {
-      for (Standard_Integer anIter = 2; anIter < n; ++anIter)
-      {
-        TCollection_AsciiString anArg (a[anIter]);
-        anArg.LowerCase();
-
-        if (anArg == "reset")
-        {
-          C->Timer().Reset();
-        }
-        else if (anArg == "restart")
-        {
-          C->Timer().Restart();
-        }
-        else if (anArg == "start")
-        {
-          C->Timer().Start();
-        }
-        else if (anArg == "stop")
-        {
-          C->Timer().Stop();
-        }
-        else if (anArg == "show")
-        {
-          Standard_SStream ss;
-          C->Timer().Show(ss);
-          theDI << ss;
-        }
-        else if (anArg == "counter")
-        {
-          Standard_Real aSeconds,aCPUtime;
-          Standard_Integer aMinutes, aHours;
-          C->Timer().Show(aSeconds,aMinutes,aHours,aCPUtime);
-          theDI << "COUNTER " << a[++anIter] << ": " << aCPUtime << "\n";
-        }
-        else
-        {
-          theDI << "Unknown argument '" << a[anIter] << "'!\n";
-        }
-      }
-    }
-  }
-  return 0;
-}
-
-
-
 //=======================================================================
 //function : ifbatch
 //purpose  : 
@@ -878,7 +882,8 @@ static int dmeminfo (Draw_Interpretor& theDI,
     }
     else
     {
-      std::cerr << "Unknown argument '" << theArgVec[anIter] << "'!\n";
+      theDI << "Syntax error at '" << theArgVec[anIter] << "'!\n";
+      return 1;
     }
   }
 
@@ -1304,11 +1309,33 @@ void Draw::BasicCommands(Draw_Interpretor& theCommands)
 		  __FILE__,Draw_wait,g);
   theCommands.Add("cpulimit","cpulimit [nbseconds], no args remove limits",
 		  __FILE__,cpulimit,g);
-  theCommands.Add("chrono","chrono [name action [action...]] \n  Operates named timer.\n"
-                           "  Supported actions: reset, start, stop, restart, show, counter [text].\n"
-                           "  Without arguments enables / disables global timer for all DRAW commands.",
-		  __FILE__,chronom,g);
-  theCommands.Add("dchrono","see help of chrono command",
+
+  const char* aChronoHelp =
+            "chrono Name [-start] [-stop] [-reset] [-restart] [-counter Text]"
+    "\n\t\t:             [-show] [-elapsed] [-userCPU] [-sysCPU]"
+    "\n\t\t:             [-thread|-process {0|1}]"
+    "\n\t\t: Operates named timer:"
+    "\n\t\t:   -start   starts (resumes) timer"
+    "\n\t\t:   -stop    stops  (pauses)  timer"
+    "\n\t\t:   -reset   resets timer progress"
+    "\n\t\t:   -restart resets and starts timer"
+    "\n\t\t:   -show    prints timer progress"
+    "\n\t\t:           ('dchrono' puts into Tcl, 'chrono' puts into std::cout)"
+    "\n\t\t:   -elapsed prints elapsed    time in seconds"
+    "\n\t\t:   -userCPU prints user   CPU time in seconds"
+    "\n\t\t:   -sysCPU  prints system CPU time in seconds"
+    "\n\t\t:   -counter prints 'COUNTER <Text>'"
+    "\n\t\t:   -thread  stops timer and sets measuring of CPU time for this thread only (FALSE by default)"
+    "\n\t\t:   -process stops timer and sets measuring of CPU time for all  threads (TRUE by default)"
+    "\n\t\t: Without arguments enables / disables global timer for all DRAW commands."
+    "\n\t\t:   chrono {0|1}"
+    "\n\t\t: Typical usage:"
+    "\n\t\t:   chrono t -restart"
+    "\n\t\t:   <algorithm>"
+    "\n\t\t:   chrono t -stop -show";
+  theCommands.Add("chrono", aChronoHelp,
+		  __FILE__,dchronom,g);
+  theCommands.Add("dchrono", aChronoHelp,
 		  __FILE__,dchronom,g);
   theCommands.Add("mallochook",
                   "debug memory allocation/deallocation, w/o args for help",

src/Draw/Draw_Chronometer.cxx

@@ -14,69 +14,50 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-
 #include <Draw_Chronometer.hxx>
-#include <Draw_Display.hxx>
-#include <Draw_Drawable3D.hxx>
-#include <OSD_Timer.hxx>
-#include <Standard_Type.hxx>
 
-IMPLEMENT_STANDARD_RTTIEXT(Draw_Chronometer,Draw_Drawable3D)
+#include <Draw_Display.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(Draw_Chronometer, Draw_Drawable3D)
 
 //=======================================================================
 //function : Draw_Chronometer
-//purpose  : 
+//purpose  :
 //=======================================================================
 Draw_Chronometer::Draw_Chronometer() 
 {
+  //
 }
 
-
-//=======================================================================
-//function : Timer
-//purpose  : 
-//=======================================================================
-
-OSD_Timer&  Draw_Chronometer::Timer()
-{
-  return myTimer;
-}
-
-
-
 //=======================================================================
 //function : DrawOn
-//purpose  : 
+//purpose  :
 //=======================================================================
-
-void  Draw_Chronometer::DrawOn(Draw_Display&)const 
+void Draw_Chronometer::DrawOn (Draw_Display& ) const
 {
+  //
 }
 
-
 //=======================================================================
 //function : Copy
-//purpose  : 
+//purpose  :
 //=======================================================================
-
-Handle(Draw_Drawable3D)  Draw_Chronometer::Copy()const 
+Handle(Draw_Drawable3D) Draw_Chronometer::Copy() const
 {
   Handle(Draw_Chronometer) C = new Draw_Chronometer();
   return C;
 }
 
-
 //=======================================================================
 //function : Dump
-//purpose  : 
+//purpose  :
 //=======================================================================
-
-void  Draw_Chronometer::Dump(Standard_OStream& S)const 
+void  Draw_Chronometer::Dump (Standard_OStream& S) const
 {
-  S << "Chronometer : ";
+  S << "Chronometer, ";
+  myTimer.Show (S);
 }
 
-
 //=======================================================================
 //function : Whatis
 //purpose  : 

src/Draw/Draw_Chronometer.hxx

@@ -17,32 +17,25 @@
 #ifndef _Draw_Chronometer_HeaderFile
 #define _Draw_Chronometer_HeaderFile
 
-#include <Standard.hxx>
-
-#include <OSD_Timer.hxx>
 #include <Draw_Drawable3D.hxx>
-#include <Standard_OStream.hxx>
-#include <Draw_Interpretor.hxx>
-class Draw_Display;
+#include <OSD_Timer.hxx>
 
-
-class Draw_Chronometer;
 DEFINE_STANDARD_HANDLE(Draw_Chronometer, Draw_Drawable3D)
 
 //! Class to store chronometer variables.
 class Draw_Chronometer : public Draw_Drawable3D
 {
-
+  DEFINE_STANDARD_RTTIEXT(Draw_Chronometer, Draw_Drawable3D)
 public:
 
-  
   Standard_EXPORT Draw_Chronometer();
-  
-  Standard_EXPORT OSD_Timer& Timer();
-  
-  //! Does nothhing,
+
+  //! Return timer.
+  OSD_Timer& Timer() { return myTimer; }
+
+  //! Does nothing,
   Standard_EXPORT void DrawOn (Draw_Display& dis) const Standard_OVERRIDE;
-  
+
   //! For variable copy.
   Standard_EXPORT virtual Handle(Draw_Drawable3D) Copy() const Standard_OVERRIDE;
   
@@ -52,28 +45,10 @@ public:
   //! For variable whatis command.
   Standard_EXPORT virtual void Whatis (Draw_Interpretor& I) const Standard_OVERRIDE;
 
-
-
-
-  DEFINE_STANDARD_RTTIEXT(Draw_Chronometer,Draw_Drawable3D)
-
-protected:
-
-
-
-
 private:
 
-
   OSD_Timer myTimer;
 
-
 };
 
-
-
-
-
-
-
 #endif // _Draw_Chronometer_HeaderFile

src/Draw/Draw_VariableCommands.cxx

@@ -92,7 +92,7 @@ static Standard_Integer save (Draw_Interpretor& theDI,
 
   const char* aName = theArgVec[2];
   const Handle(OSD_FileSystem)& aFileSystem = OSD_FileSystem::DefaultFileSystem();
-  std::shared_ptr<std::ostream> aStream = aFileSystem->OpenOStream (aName, std::ios::out);
+  std::shared_ptr<std::ostream> aStream = aFileSystem->OpenOStream (aName, std::ios::out | std::ios::binary);
   aStream->precision (15);
   if (aStream.get() == NULL || !aStream->good())
   {

src/DrawResources/TestCommands.tcl

@@ -1402,10 +1402,10 @@ proc _run_test {scriptsdir group gridname casefile echo} {
         append stats "MEMORY DELTA: [expr ($memuse - $membase) / 1024] KiB\n"
     }
     uplevel dchrono _timer stop
-    set time [uplevel dchrono _timer show]
-    if { [regexp -nocase {CPU user time:[ \t]*([0-9.e-]+)} $time res cpu_usr] } {
-        append stats "TOTAL CPU TIME: $cpu_usr sec\n"
-    }
+    set cpu_usr [uplevel dchrono _timer -userCPU]
+    set elps    [uplevel dchrono _timer -elapsed]
+    append stats "TOTAL CPU TIME: $cpu_usr sec\n"
+    append stats "ELAPSED TIME: $elps sec\n"
     if { $dlog_exists && ! $echo } {
         dlog add $stats
     } else {

src/ElSLib/ElSLib.cxx

@@ -176,6 +176,8 @@ gp_Vec ElSLib::ConeDN (const Standard_Real    U,
    }
    else if(Nv == 1) { 
      Xdir.Multiply(sin(SAngle));
+     if (Nu == 0)
+       Xdir.Add(Pos.Direction().XYZ() * cos(SAngle));
      return gp_Vec(Xdir);     
    }
    return gp_Vec(0.0,0.0,0.0);

src/Extrema/Extrema_ExtCC.cxx

@@ -602,6 +602,9 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
     const Bnd_Range aRange(theUt21, theUt22);
     Bnd_Range aProjRng1;
 
+    // Precision of the calculation depends on circles radii
+    const Standard_Real aPrecision = Max(Epsilon(myC[0]->Circle().Radius()), Epsilon(myC[1]->Circle().Radius()));
+
     // Project arc of the 1st circle between points theUt11 and theUt12 to the
     // 2nd circle. It is necessary to chose correct arc from two possible ones.
 
@@ -663,7 +666,7 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
       //    myIsParallel = TRUE and only the least distance will be returned.
       //4. Arcs are not parallel. Then several (or single) extremas will be returned.
 
-      if (aRng.Delta() > Precision::Angular())
+      if (aRng.Delta() > Precision::Confusion())
       {
         Standard_Real aPar = 0.0;
         aRng.GetIntermediatePoint(0.5, aPar);
@@ -678,7 +681,7 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
           aMinSqD = Min(aMinSqD, ExtPCir.SquareDistance(anExtID));
         }
 
-        if (aMinSqD <= aMinSquareDist + 10.* Epsilon(1. + aMinSqD))
+        if (aMinSqD <= aMinSquareDist + (1. + aMinSqD) * aPrecision)
         {
           ClearSolutions();
           mySqDist.Append(aMinSqD);
@@ -703,7 +706,6 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
             break;
           }
         }
-
         //Nearer solution can be found
       }
       else if (!aRng.IsVoid())
@@ -779,7 +781,7 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
             imin = k;
           }
         }
-        if (aDmin <= aMinSquareDist + 10.* Epsilon(1. + aDmin))
+        if (aDmin <= aMinSquareDist + (1. + aDmin) * aPrecision)
         {
           if (imin == 0)
           {

src/Extrema/Extrema_GenExtCC.gxx

@@ -163,7 +163,6 @@ static Standard_Real ProjPOnC(const Pnt& theP,
       if (aD < aDist)
         aDist = aD;
     }
-    aDist = sqrt(aDist);
   }
   return aDist;
 }
@@ -340,10 +339,20 @@ void Extrema_GenExtCC::Perform()
       aNbInter[1] = anIntervals2->Length() - 1;
     }
   }
+  if (C1.IsClosed() && aNbInter[0] == 1)
+  {
+    ChangeIntervals(anIntervals1, 3);
+    aNbInter[0] = anIntervals1->Length() - 1;
+  }
+  if (C2.IsClosed() && aNbInter[1] == 1)
+  {
+    ChangeIntervals(anIntervals2, 3);
+    aNbInter[1] = anIntervals2->Length() - 1;
+  }
 
   // Lipchitz constant computation.
   const Standard_Real aMaxLC = 10000.;
-  Standard_Real aLC = 9.0; // Default value.
+  Standard_Real aLC = 100.0; // Default value.
   const Standard_Real aMaxDer1 = 1.0 / C1.Resolution(1.0);
   const Standard_Real aMaxDer2 = 1.0 / C2.Resolution(1.0);
   Standard_Real aMaxDer = Max(aMaxDer1, aMaxDer2) * Sqrt(2.0);
@@ -383,6 +392,43 @@ void Extrema_GenExtCC::Perform()
   }
 
   Extrema_GlobOptFuncCCC2 aFunc (C1, C2);
+  if (aLC < aMaxLC || aMaxDer > aMaxLC)
+  {
+    //Estimation of Lipschitz constant by gradient of optimization function 
+    //using sampling in parameter space.
+    math_Vector aT(1, 2), aG(1, 2);
+    Standard_Real aF, aMaxG = 0.;
+    Standard_Real t1, t2, dt1, dt2;
+    Standard_Integer n1 = 21, n2 = 21, i1, i2;
+    dt1 = (C1.LastParameter() - C1.FirstParameter()) / (n1 - 1);
+    dt2 = (C2.LastParameter() - C2.FirstParameter()) / (n2 - 1);
+    for (i1 = 1, t1 = C1.FirstParameter(); i1 <= n1; ++i1, t1 += dt1)
+    {
+      aT(1) = t1;
+      for (i2 = 1, t2 = C2.FirstParameter(); i2 <= n2; ++i2, t2 += dt2)
+      {
+        aT(2) = t2;
+        aFunc.Values(aT, aF, aG);
+        Standard_Real aMod = aG(1)*aG(1) + aG(2)*aG(2);
+        aMaxG = Max(aMaxG, aMod);
+      }
+    }
+    aMaxG = Sqrt(aMaxG);
+    if (aMaxG > aMaxDer)
+    {
+      aLC = Min(aMaxG, aMaxLC);
+      isConstLockedFlag = Standard_True;
+    }
+    if (aMaxG > 100. * aMaxLC)
+    {
+      aLC = 100. * aMaxLC;
+      isConstLockedFlag = Standard_True;
+    }
+    else if (aMaxG < 0.1 * aMaxDer)
+    {
+      isConstLockedFlag = Standard_True;
+    }
+  }
   math_GlobOptMin aFinder(&aFunc, myLowBorder, myUppBorder, aLC);
   aFinder.SetLipConstState(isConstLockedFlag);
   aFinder.SetContinuity(aContinuity == GeomAbs_C2 ? 2 : 1);
@@ -518,7 +564,6 @@ void Extrema_GenExtCC::Perform()
     aVec(2) = (aCurrent.Y() + aNext.Y()) * 0.5;
 
     aFunc.Value(aVec, aVal);
-
     if (Abs(aVal - aF) < Precision::Confusion())
     {
       // It seems the parallel segment is found.

src/Extrema/Extrema_GenExtCS.cxx

@@ -120,6 +120,15 @@ Extrema_GenExtCS::Extrema_GenExtCS()
 {
 }
 
+// =======================================================================
+// function : ~Extrema_GenExtCS
+// purpose  :
+// =======================================================================
+Extrema_GenExtCS::~Extrema_GenExtCS()
+{
+  //
+}
+
 //=======================================================================
 //function : Extrema_GenExtCS
 //purpose  : 

src/Extrema/Extrema_GenExtCS.hxx

@@ -35,9 +35,12 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
+  //! Empty constructor.
   Standard_EXPORT Extrema_GenExtCS();
-  
+
+  //! Destructor.
+  Standard_EXPORT ~Extrema_GenExtCS();
+
   //! It calculates all the distances.
   //! The function F(u,v)=distance(S1(u1,v1),S2(u2,v2)) has an
   //! extremum when gradient(F)=0. The algorithm searches

src/Extrema/Extrema_GenExtPS.cxx

@@ -224,7 +224,19 @@ Extrema_GenExtPS::Extrema_GenExtPS()
   myAlgo = Extrema_ExtAlgo_Grad;
 }
 
+// =======================================================================
+// function : ~Extrema_GenExtPS
+// purpose  :
+// =======================================================================
+Extrema_GenExtPS::~Extrema_GenExtPS()
+{
+  //
+}
 
+// =======================================================================
+// function : Extrema_GenExtPS
+// purpose  :
+// =======================================================================
 Extrema_GenExtPS::Extrema_GenExtPS (const gp_Pnt&          P,
                                     const Adaptor3d_Surface& S,
                                     const Standard_Integer NbU, 
@@ -703,23 +715,114 @@ void Extrema_GenExtPS::BuildGrid(const gp_Pnt &thePoint)
   }
 }
 
-// Parametrization of the sample
+static Standard_Real LengthOfIso(const Adaptor3d_Surface& theS, const GeomAbs_IsoType theIso,
+  const Standard_Real thePar1, const Standard_Real thePar2,
+  const Standard_Integer theNbPnts,  const Standard_Real thePar)
+{
+  Standard_Real aLen = 0.;
+  Standard_Integer i;
+  Standard_Real dPar = (thePar2 - thePar1) / (theNbPnts - 1);
+  gp_Pnt aP1, aP2;
+  Standard_Real aPar = thePar1 + dPar;
+  if(theIso == GeomAbs_IsoU)
+  {
+    aP1 = theS.Value(thePar, thePar1);
+  }
+  else
+  {
+    aP1 = theS.Value(thePar1, thePar);
+  }
+
+  for (i = 2; i <= theNbPnts; ++i)
+  {
+    if (theIso == GeomAbs_IsoU)
+    {
+      aP2 = theS.Value(thePar, aPar);
+    }
+    else
+    {
+      aP2 = theS.Value(aPar, thePar);
+    }
+    aLen += aP1.Distance(aP2);
+    aP1 = aP2;
+    aPar += dPar;
+  }
+  return aLen;
+}
+static void CorrectNbSamples(const Adaptor3d_Surface& theS, 
+  const Standard_Real theU1, const Standard_Real theU2, Standard_Integer& theNbU, 
+  const Standard_Real theV1, const Standard_Real theV2, Standard_Integer& theNbV)
+{
+  Standard_Real aMinLen = 1.e-3;
+  Standard_Integer nbp = Min(23, theNbV);
+  Standard_Real aLenU1 = LengthOfIso(theS, GeomAbs_IsoU, theV1, theV2, nbp, theU1);
+  if (aLenU1 <= aMinLen)
+  {
+    Standard_Real aL = LengthOfIso(theS, GeomAbs_IsoU, theV1, theV2, nbp, .7*theU1 + 0.3*theU2);
+    aLenU1 = Max(aL, aLenU1);
+  }
+  Standard_Real aLenU2 = LengthOfIso(theS, GeomAbs_IsoU, theV1, theV2, nbp, theU2);
+  if (aLenU2 <= aMinLen)
+  {
+    Standard_Real aL = LengthOfIso(theS, GeomAbs_IsoU, theV1, theV2, nbp, .3*theU1 + 0.7*theU2);
+    aLenU2 = Max(aL, aLenU2);
+  }
+  nbp = Min(23, theNbV);
+  Standard_Real aLenV1 = LengthOfIso(theS, GeomAbs_IsoV, theU1, theU2, nbp, theV1);
+  if (aLenV1 <= aMinLen)
+  {
+    Standard_Real aL = LengthOfIso(theS, GeomAbs_IsoV, theU1, theU2, nbp, .7*theV1 + 0.3*theV2);
+    aLenV1 = Max(aL, aLenV1);
+  }
+  Standard_Real aLenV2 = LengthOfIso(theS, GeomAbs_IsoV, theU1, theU2, nbp, theV2);
+  if (aLenV2 <= aMinLen)
+  {
+    Standard_Real aL = LengthOfIso(theS, GeomAbs_IsoV, theU1, theU2, nbp, .3*theV1 + 0.7*theV2);
+    aLenV2 = Max(aL, aLenV2);
+  }
+  //
+  Standard_Real aStepV1 = aLenU1 / theNbV;
+  Standard_Real aStepV2 = aLenU2 / theNbV;
+  Standard_Real aStepU1 = aLenV1 / theNbU;
+  Standard_Real aStepU2 = aLenV2 / theNbU;
+
+  Standard_Real aMaxStepV = Max(aStepV1, aStepV2);
+  Standard_Real aMaxStepU = Max(aStepU1, aStepU2);
+  //
+  Standard_Real aRatio = aMaxStepV / aMaxStepU;
+  if (aRatio > 10.)
+  {
+    Standard_Integer aMult = RealToInt(Log(aRatio) );
+    if(aMult > 1)
+      theNbV *= aMult;
+  }
+  else if (aRatio < 0.1)
+  {
+    Standard_Integer aMult = RealToInt( - Log(aRatio));
+    if(aMult > 1)
+      theNbV *= aMult;
+  }
+
+}
 void Extrema_GenExtPS::BuildTree()
 {
   // if tree already exists, assume it is already correctly filled
-  if ( ! mySphereUBTree.IsNull() )
+  if (!mySphereUBTree.IsNull())
     return;
 
-   if (myS->GetType() == GeomAbs_BSplineSurface) {
-     Handle(Geom_BSplineSurface) aBspl = myS->BSpline();
-     Standard_Integer aUValue = aBspl->UDegree() * aBspl->NbUKnots();
-     Standard_Integer aVValue = aBspl->VDegree() * aBspl->NbVKnots();
-     if (aUValue > myusample)
-       myusample = aUValue;
-     if (aVValue > myvsample)
-       myvsample = aVValue;
-   }
-
+  if (myS->GetType() == GeomAbs_BSplineSurface) {
+    Handle(Geom_BSplineSurface) aBspl = myS->BSpline();
+    Standard_Integer aUValue = aBspl->UDegree() * aBspl->NbUKnots();
+    Standard_Integer aVValue = aBspl->VDegree() * aBspl->NbVKnots();
+    // 300 is value, which is used for singular points (see Extrema_ExtPS.cxx::Initialize(...))
+    if (aUValue > myusample)
+      myusample = Min(aUValue, 300);
+    if (aVValue > myvsample)
+      myvsample = Min(aVValue, 300);
+  }
+  //
+  CorrectNbSamples(*myS, myumin, myusup, myusample, myvmin, myvsup, myvsample);
+  //
   Standard_Real PasU = myusup - myumin;
   Standard_Real PasV = myvsup - myvmin;
   Standard_Real U0 = PasU / myusample / 100.;

src/Extrema/Extrema_GenExtPS.hxx

@@ -37,8 +37,12 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
+  //! Empty constructor.
   Standard_EXPORT Extrema_GenExtPS();
-  
+
+  //! Destructor.
+  Standard_EXPORT ~Extrema_GenExtPS();
+
   //! It calculates all the distances.
   //! The function F(u,v)=distance(P,S(u,v)) has an
   //! extremum when gradient(F)=0. The algorithm searches

src/Extrema/Extrema_GenExtSS.cxx

@@ -118,6 +118,15 @@ Extrema_GenExtSS::Extrema_GenExtSS()
   myInit = Standard_False;
 }
 
+// =======================================================================
+// function : ~Extrema_GenExtSS
+// purpose  :
+// =======================================================================
+Extrema_GenExtSS::~Extrema_GenExtSS()
+{
+  //
+}
+
 //=======================================================================
 //function : Extrema_GenExtSS
 //purpose  : 

src/Extrema/Extrema_GenExtSS.hxx

@@ -36,9 +36,12 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
+  //! Empty constructor.
   Standard_EXPORT Extrema_GenExtSS();
-  
+
+  //! Destructor.
+  Standard_EXPORT ~Extrema_GenExtSS();
+
   //! It calculates all the distances.
   //! The function F(u,v)=distance(S1(u1,v1),S2(u2,v2)) has an
   //! extremum when gradient(F)=0. The algorithm searches

src/Extrema/Extrema_GlobOptFuncCC.cxx

@@ -43,7 +43,7 @@ static Standard_Boolean _Value(const Adaptor3d_Curve& C1,
     return Standard_False;
   }
 
-  F = C2.Value(v).Distance(C1.Value(u));
+  F = C2.Value(v).SquareDistance(C1.Value(u));
   return Standard_True;
 }
 
@@ -64,7 +64,7 @@ static Standard_Boolean _Value(const Adaptor2d_Curve2d& C1,
     return Standard_False;
   }
 
-  F = C2.Value(v).Distance(C1.Value(u));
+  F = C2.Value(v).SquareDistance(C1.Value(u));
   return Standard_True;
 }
 
@@ -89,13 +89,14 @@ static Standard_Boolean _Gradient(const Adaptor3d_Curve& C1,
 
   C1.D1(X(1), C1D0, C1D1);
   C2.D1(X(2), C2D0, C2D1);
-
+  
   G(1) = - (C2D0.X() - C1D0.X()) * C1D1.X() 
          - (C2D0.Y() - C1D0.Y()) * C1D1.Y() 
          - (C2D0.Z() - C1D0.Z()) * C1D1.Z();
   G(2) =   (C2D0.X() - C1D0.X()) * C2D1.X() 
          + (C2D0.Y() - C1D0.Y()) * C2D1.Y() 
          + (C2D0.Z() - C1D0.Z()) * C2D1.Z();
+  G *= 2.;
   return Standard_True;
 }
 
@@ -121,8 +122,11 @@ static Standard_Boolean _Gradient(const Adaptor2d_Curve2d& C1,
 
   G(1) = - (C2D0.X() - C1D0.X()) * C1D1.X() 
          - (C2D0.Y() - C1D0.Y()) * C1D1.Y();
+
   G(2) =   (C2D0.X() - C1D0.X()) * C2D1.X() 
          + (C2D0.Y() - C1D0.Y()) * C2D1.Y();
+  G *= 2.;
+
   return Standard_True;
 }
 
@@ -166,6 +170,7 @@ static Standard_Boolean _Hessian (const Adaptor3d_Curve& C1,
            + (C2D0.X() - C1D0.X()) * C2D2.X() 
            + (C2D0.Y() - C1D0.Y()) * C2D2.Y() 
            + (C2D0.Z() - C1D0.Z()) * C2D2.Z();
+  H *= 2.;
   return Standard_True;
 }
 
@@ -204,10 +209,11 @@ static Standard_Boolean _Hessian (const Adaptor2d_Curve2d& C1,
            + C2D1.Y() * C2D1.Y() 
            + (C2D0.X() - C1D0.X()) * C2D2.X() 
            + (C2D0.Y() - C1D0.Y()) * C2D2.Y();
+  H *= 2.;
   return Standard_True;
 }
 
-// C0
+//C0
 
 //=======================================================================
 //function : Extrema_GlobOptFuncCCC0
@@ -415,6 +421,5 @@ Standard_Boolean Extrema_GlobOptFuncCCC2::Values(const math_Vector& X,Standard_R
   else
     isHessianComputed = _Hessian(*myC1_2d, *myC2_2d, X, H);
 
-
   return (Value(X, F) && Gradient(X, G) && isHessianComputed);
 }

src/FEmTool/FEmTool_Assembly.cxx

@@ -16,11 +16,9 @@
 
 
 #include <FEmTool_Assembly.hxx>
-#include <FEmTool_ListIteratorOfListOfVectors.hxx>
 #include <FEmTool_ListOfVectors.hxx>
 #include <FEmTool_ProfileMatrix.hxx>
 #include <math_Matrix.hxx>
-#include <Standard_DimensionError.hxx>
 #include <Standard_DomainError.hxx>
 #include <StdFail_NotDone.hxx>
 #include <TColStd_HArray1OfReal.hxx>

src/FEmTool/FEmTool_Assembly.hxx

@@ -23,7 +23,6 @@
 
 #include <TColStd_Array2OfInteger.hxx>
 #include <FEmTool_HAssemblyTable.hxx>
-#include <Standard_Boolean.hxx>
 #include <math_Vector.hxx>
 #include <FEmTool_SeqOfLinConstr.hxx>
 #include <TColStd_SequenceOfReal.hxx>

src/FEmTool/FEmTool_Curve.cxx

@@ -20,10 +20,8 @@
 
 #include <FEmTool_Curve.hxx>
 #include <PLib.hxx>
-#include <PLib_Base.hxx>
 #include <PLib_HermitJacobi.hxx>
 #include <PLib_JacobiPolynomial.hxx>
-#include <Standard_DimensionError.hxx>
 #include <Standard_Type.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(FEmTool_Curve,Standard_Transient)

src/FEmTool/FEmTool_ElementaryCriterion.cxx

@@ -17,8 +17,6 @@
 
 #include <FEmTool_ElementaryCriterion.hxx>
 #include <math_Matrix.hxx>
-#include <Standard_DomainError.hxx>
-#include <Standard_NotImplemented.hxx>
 #include <Standard_Type.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(FEmTool_ElementaryCriterion,Standard_Transient)

src/FEmTool/FEmTool_ElementaryCriterion.hxx

@@ -18,7 +18,6 @@
 #define _FEmTool_ElementaryCriterion_HeaderFile
 
 #include <Standard.hxx>
-#include <Standard_Type.hxx>
 
 #include <TColStd_HArray2OfReal.hxx>
 #include <Standard_Real.hxx>

src/FEmTool/FEmTool_ElementsOfRefMatrix.hxx

@@ -23,7 +23,6 @@
 
 #include <Standard_Integer.hxx>
 #include <math_FunctionSet.hxx>
-#include <Standard_Boolean.hxx>
 #include <math_Vector.hxx>
 class PLib_Base;
 

src/FEmTool/FEmTool_LinearFlexion.cxx

@@ -24,7 +24,6 @@
 #include <math_Vector.hxx>
 #include <PLib.hxx>
 #include <PLib_HermitJacobi.hxx>
-#include <PLib_JacobiPolynomial.hxx>
 #include <Standard_ConstructionError.hxx>
 #include <Standard_DomainError.hxx>
 #include <Standard_NotImplemented.hxx>

src/FEmTool/FEmTool_LinearFlexion.hxx

@@ -25,7 +25,6 @@
 #include <FEmTool_ElementaryCriterion.hxx>
 #include <GeomAbs_Shape.hxx>
 #include <TColStd_HArray2OfInteger.hxx>
-#include <Standard_Real.hxx>
 #include <math_Vector.hxx>
 
 

src/FEmTool/FEmTool_LinearJerk.cxx

@@ -24,7 +24,6 @@
 #include <math_Vector.hxx>
 #include <PLib.hxx>
 #include <PLib_HermitJacobi.hxx>
-#include <PLib_JacobiPolynomial.hxx>
 #include <Standard_ConstructionError.hxx>
 #include <Standard_DomainError.hxx>
 #include <Standard_NotImplemented.hxx>

src/FEmTool/FEmTool_LinearJerk.hxx

@@ -25,7 +25,6 @@
 #include <FEmTool_ElementaryCriterion.hxx>
 #include <GeomAbs_Shape.hxx>
 #include <TColStd_HArray2OfInteger.hxx>
-#include <Standard_Real.hxx>
 #include <math_Vector.hxx>
 
 

src/FEmTool/FEmTool_LinearTension.cxx

@@ -24,7 +24,6 @@
 #include <math_Vector.hxx>
 #include <PLib.hxx>
 #include <PLib_HermitJacobi.hxx>
-#include <PLib_JacobiPolynomial.hxx>
 #include <Standard_ConstructionError.hxx>
 #include <Standard_DomainError.hxx>
 #include <Standard_NotImplemented.hxx>

src/FEmTool/FEmTool_LinearTension.hxx

@@ -25,7 +25,6 @@
 #include <FEmTool_ElementaryCriterion.hxx>
 #include <GeomAbs_Shape.hxx>
 #include <TColStd_HArray2OfInteger.hxx>
-#include <Standard_Real.hxx>
 #include <math_Vector.hxx>
 
 

src/FEmTool/FEmTool_ProfileMatrix.hxx

@@ -18,12 +18,10 @@
 #define _FEmTool_ProfileMatrix_HeaderFile
 
 #include <Standard.hxx>
-#include <Standard_Type.hxx>
 
 #include <TColStd_Array2OfInteger.hxx>
 #include <TColStd_HArray1OfReal.hxx>
 #include <TColStd_HArray1OfInteger.hxx>
-#include <Standard_Boolean.hxx>
 #include <FEmTool_SparseMatrix.hxx>
 #include <TColStd_Array1OfInteger.hxx>
 #include <Standard_Real.hxx>

src/FEmTool/FEmTool_SparseMatrix.cxx

@@ -17,6 +17,5 @@
 
 #include <FEmTool_SparseMatrix.hxx>
 #include <Standard_Type.hxx>
-#include <StdFail_NotDone.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(FEmTool_SparseMatrix,Standard_Transient)

src/FEmTool/FEmTool_SparseMatrix.hxx

@@ -18,12 +18,10 @@
 #define _FEmTool_SparseMatrix_HeaderFile
 
 #include <Standard.hxx>
-#include <Standard_Type.hxx>
 
 #include <Standard_Transient.hxx>
 #include <Standard_Real.hxx>
 #include <Standard_Integer.hxx>
-#include <Standard_Boolean.hxx>
 #include <math_Vector.hxx>
 
 

src/FSD/FSD_BinaryFile.hxx

@@ -23,7 +23,6 @@
 #include <Storage_Error.hxx>
 #include <Storage_OpenMode.hxx>
 #include <Storage_Data.hxx>
-#include <Standard_Boolean.hxx>
 #include <Storage_Position.hxx>
 #include <Standard_Integer.hxx>
 #include <TColStd_SequenceOfAsciiString.hxx>

src/FSD/FSD_FStream.hxx

@@ -15,7 +15,6 @@
 #ifndef _FSD_FStream_HeaderFile
 #define _FSD_FStream_HeaderFile
 
-#include <stdio.h>
 #include <Standard_Stream.hxx>
 
 typedef std::fstream FSD_FStream;

src/FairCurve/FairCurve_Batten.cxx

@@ -22,7 +22,6 @@
 
 #include <BSplCLib.hxx>
 #include <FairCurve_Batten.hxx>
-#include <FairCurve_BattenLaw.hxx>
 #include <FairCurve_EnergyOfBatten.hxx>
 #include <FairCurve_Newton.hxx>
 #include <Geom2d_BSplineCurve.hxx>

src/FairCurve/FairCurve_Batten.hxx

@@ -23,8 +23,6 @@
 
 #include <FairCurve_AnalysisCode.hxx>
 #include <gp_Pnt2d.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
 #include <Standard_Integer.hxx>
 #include <TColgp_HArray1OfPnt2d.hxx>
 #include <TColStd_HArray1OfReal.hxx>

src/FairCurve/FairCurve_DistributionOfJerk.cxx

@@ -23,7 +23,6 @@
 
 
 #include <BSplCLib.hxx>
-#include <FairCurve_BattenLaw.hxx>
 #include <FairCurve_DistributionOfJerk.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_XY.hxx>

src/FairCurve/FairCurve_DistributionOfJerk.hxx

@@ -26,7 +26,6 @@
 #include <Standard_Integer.hxx>
 #include <TColStd_HArray1OfReal.hxx>
 #include <TColgp_HArray1OfPnt2d.hxx>
-#include <Standard_Boolean.hxx>
 #include <math_Vector.hxx>
 
 

src/FairCurve/FairCurve_DistributionOfSagging.cxx

@@ -20,7 +20,6 @@
 
 
 #include <BSplCLib.hxx>
-#include <FairCurve_BattenLaw.hxx>
 #include <FairCurve_DistributionOfSagging.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_XY.hxx>