Update

Removing provider.VRML.OCC.read.memory.limit from the test because this parameter doesn't exist inside the Vrml_ConfigurationNode class

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
+cmake_minimum_required (VERSION 3.1 FATAL_ERROR)
 
 set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/adm/cmake")
 
@@ -6,6 +6,26 @@ set (CMAKE_SUPPRESS_REGENERATION TRUE)
 
 set (CMAKE_CONFIGURATION_TYPES Release Debug RelWithDebInfo CACHE INTERNAL "" FORCE)
 
+# set using C++ standard
+set (BUILD_CPP_STANDARD "C++11" CACHE STRING "Select using c++ standard.")
+set_property(CACHE BUILD_CPP_STANDARD PROPERTY STRINGS "C++11" "C++14" "C++17" "C++20" "C++23")
+
+# Set desired C++ standard
+if     ("${BUILD_CPP_STANDARD}" STREQUAL "C++11")
+  set (CMAKE_CXX_STANDARD 11)
+elseif ("${BUILD_CPP_STANDARD}" STREQUAL "C++14")
+  set (CMAKE_CXX_STANDARD 14)
+elseif ("${BUILD_CPP_STANDARD}" STREQUAL "C++17")
+  set (CMAKE_CXX_STANDARD 17)
+elseif ("${BUILD_CPP_STANDARD}" STREQUAL "C++20")
+  set (CMAKE_CXX_STANDARD 20)
+elseif ("${BUILD_CPP_STANDARD}" STREQUAL "C++23")
+  set (CMAKE_CXX_STANDARD 23)
+else ()
+  message (FATAL_ERROR, "misprint in c++ standard name")
+endif()
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+
 # macro: include patched file if it exists
 macro (OCCT_INCLUDE_CMAKE_FILE BEING_INCLUDED_FILE)
   if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/${BEING_INCLUDED_FILE}.cmake")
@@ -800,6 +820,12 @@ else()
   OCCT_CHECK_AND_UNSET ("3RDPARTY_DOT_EXECUTABLE")
 endif()
 
+# ExpToCasExe
+if (EMSCRIPTEN)
+  list (REMOVE_ITEM BUILD_TOOLKITS TKExpress)
+  list (REMOVE_ITEM BUILD_TOOLKITS ExpToCasExe)
+endif()
+
 # bison
 if (BUILD_YACCLEX)
   OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/bison")

adm/MODULES

@@ -3,5 +3,5 @@ ModelingData TKG2d TKG3d TKGeomBase TKBRep
 ModelingAlgorithms TKGeomAlgo TKTopAlgo TKPrim TKBO TKBool TKHLR TKFillet TKOffset TKFeat TKMesh TKXMesh TKShHealing
 Visualization TKService TKV3d TKOpenGl TKOpenGles TKMeshVS TKIVtk TKD3DHost
 ApplicationFramework TKCDF TKLCAF TKCAF TKBinL TKXmlL TKBin TKXml TKStdL TKStd TKTObj TKBinTObj TKXmlTObj TKVCAF
-DataExchange TKXDE TKXSBase TKSTEPBase TKSTEPAttr TKSTEP209 TKSTEP TKIGES TKXCAF TKXDEIGES TKXDESTEP TKSTL TKVRML TKXmlXCAF TKBinXCAF TKRWMesh TKXDECascade
+DataExchange TKXDE TKXSBase TKSTEPBase TKSTEPAttr TKSTEP209 TKSTEP TKIGES TKXCAF TKXDEIGES TKXDESTEP TKSTL TKVRML TKXmlXCAF TKBinXCAF TKRWMesh TKXDECascade TKExpress ExpToCasExe
 Draw TKDraw TKTopTest TKOpenGlTest TKOpenGlesTest TKD3DHostTest TKViewerTest TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw TKIVtkDraw DRAWEXE

adm/UDLIST

@@ -480,3 +480,6 @@ n TreeModel
 n View
 n ViewControl
 n VInspector
+n Express
+t TKExpress
+x ExpToCasExe

adm/cmake/bison.cmake

@@ -22,6 +22,4 @@ if (3RDPARTY_DIR)
   endforeach()
 endif()
  
-# bison 3.2 is required because it provides options to avoid generation of redundant header
-# files and embedding of local paths in the generated code
-find_package (BISON 3.2)
+find_package (BISON 3.7.4)

adm/cmake/cotire.cmake

@@ -3,7 +3,7 @@
 # See the cotire manual for usage hints.
 #
 #=============================================================================
-# Copyright 2012-2016 Sascha Kratky
+# Copyright 2012-2018 Sascha Kratky
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation
@@ -43,7 +43,7 @@ if (NOT CMAKE_SCRIPT_MODE_FILE)
 endif()
 
 set (COTIRE_CMAKE_MODULE_FILE "${CMAKE_CURRENT_LIST_FILE}")
-set (COTIRE_CMAKE_MODULE_VERSION "1.7.9")
+set (COTIRE_CMAKE_MODULE_VERSION "1.8.1")
 
 # activate select policies
 if (POLICY CMP0025)
@@ -106,6 +106,11 @@ if (POLICY CMP0054)
 	cmake_policy(SET CMP0054 NEW)
 endif()
 
+if (POLICY CMP0055)
+	# strict checking for break() command
+	cmake_policy(SET CMP0055 NEW)
+endif()
+
 include(CMakeParseArguments)
 include(ProcessorCount)
 
@@ -233,10 +238,16 @@ function (cotire_filter_language_source_files _language _target _sourceFilesVar
 			if (_sourceCompileFlags)
 				# add to excluded sources, if file has custom compile flags
 				list (APPEND _excludedSourceFiles "${_sourceFile}")
+			else()
+				get_source_file_property(_sourceCompileOptions "${_sourceFile}" COMPILE_OPTIONS)
+				if (_sourceCompileOptions)
+					# add to excluded sources, if file has list of custom compile options
+					list (APPEND _excludedSourceFiles "${_sourceFile}")
 				else()
 					list (APPEND _sourceFiles "${_sourceFile}")
 				endif()
 			endif()
+		endif()
 	endforeach()
 	if (COTIRE_DEBUG)
 		if (_sourceFiles)
@@ -293,7 +304,7 @@ function (cotire_get_source_file_property_values _valuesVar _property)
 	set (${_valuesVar} ${_values} PARENT_SCOPE)
 endfunction()
 
-function (cotire_resolve_config_properites _configurations _propertiesVar)
+function (cotire_resolve_config_properties _configurations _propertiesVar)
 	set (_properties "")
 	foreach (_property ${ARGN})
 		if ("${_property}" MATCHES "<CONFIG>")
@@ -309,8 +320,8 @@ function (cotire_resolve_config_properites _configurations _propertiesVar)
 	set (${_propertiesVar} ${_properties} PARENT_SCOPE)
 endfunction()
 
-function (cotire_copy_set_properites _configurations _type _source _target)
-	cotire_resolve_config_properites("${_configurations}" _properties ${ARGN})
+function (cotire_copy_set_properties _configurations _type _source _target)
+	cotire_resolve_config_properties("${_configurations}" _properties ${ARGN})
 	foreach (_property ${_properties})
 		get_property(_isSet ${_type} ${_source} PROPERTY ${_property} SET)
 		if (_isSet)
@@ -320,13 +331,18 @@ function (cotire_copy_set_properites _configurations _type _source _target)
 	endforeach()
 endfunction()
 
-function (cotire_get_target_usage_requirements _target _targetRequirementsVar)
+function (cotire_get_target_usage_requirements _target _config _targetRequirementsVar)
 	set (_targetRequirements "")
 	get_target_property(_librariesToProcess ${_target} LINK_LIBRARIES)
 	while (_librariesToProcess)
 		# remove from head
 		list (GET _librariesToProcess 0 _library)
 		list (REMOVE_AT _librariesToProcess 0)
+		if (_library MATCHES "^\\$<\\$<CONFIG:${_config}>:([A-Za-z0-9_:-]+)>$")
+			set (_library "${CMAKE_MATCH_1}")
+		elseif (_config STREQUAL "None" AND _library MATCHES "^\\$<\\$<CONFIG:>:([A-Za-z0-9_:-]+)>$")
+			set (_library "${CMAKE_MATCH_1}")
+		endif()
 		if (TARGET ${_library})
 			list (FIND _targetRequirements ${_library} _index)
 			if (_index LESS 0)
@@ -441,7 +457,7 @@ function (cotire_get_target_compile_flags _config _language _target _flagsVar)
 	# interface compile options from linked library targets
 	if (_target)
 		set (_linkedTargets "")
-		cotire_get_target_usage_requirements(${_target} _linkedTargets)
+		cotire_get_target_usage_requirements(${_target} ${_config} _linkedTargets)
 		foreach (_linkedTarget ${_linkedTargets})
 			get_target_property(_targetOptions ${_linkedTarget} INTERFACE_COMPILE_OPTIONS)
 			if (_targetOptions)
@@ -573,7 +589,7 @@ function (cotire_get_target_include_directories _config _language _target _inclu
 	# interface include directories from linked library targets
 	if (_target)
 		set (_linkedTargets "")
-		cotire_get_target_usage_requirements(${_target} _linkedTargets)
+		cotire_get_target_usage_requirements(${_target} ${_config} _linkedTargets)
 		foreach (_linkedTarget ${_linkedTargets})
 			get_target_property(_linkedTargetType ${_linkedTarget} TYPE)
 			if (CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE AND NOT CMAKE_VERSION VERSION_LESS "3.4.0" AND
@@ -627,7 +643,7 @@ function (cotire_get_target_include_directories _config _language _target _inclu
 	if (CMAKE_${_language}_IMPLICIT_INCLUDE_DIRECTORIES)
 		list (REMOVE_ITEM _includeDirs ${CMAKE_${_language}_IMPLICIT_INCLUDE_DIRECTORIES})
 	endif()
-	if (WIN32)
+	if (WIN32 AND NOT MINGW)
 		# convert Windows paths in include directories to CMake paths
 		if (_includeDirs)
 			set (_paths "")
@@ -703,7 +719,7 @@ function (cotire_get_target_compile_definitions _config _language _target _defin
 	endif()
 	# interface compile definitions from linked library targets
 	set (_linkedTargets "")
-	cotire_get_target_usage_requirements(${_target} _linkedTargets)
+	cotire_get_target_usage_requirements(${_target} ${_config} _linkedTargets)
 	foreach (_linkedTarget ${_linkedTargets})
 		get_target_property(_definitions ${_linkedTarget} INTERFACE_COMPILE_DEFINITIONS)
 		if (_definitions)
@@ -711,7 +727,7 @@ function (cotire_get_target_compile_definitions _config _language _target _defin
 		endif()
 	endforeach()
 	# parse additional compile definitions from target compile flags
-	# and don't look at directory compile definitions, which we already handled
+	# and do not look at directory compile definitions, which we already handled
 	set (_targetFlags "")
 	cotire_get_target_compile_flags("${_config}" "${_language}" "${_target}" _targetFlags)
 	cotire_filter_compile_flags("${_language}" "D" _definitions _ignore ${_targetFlags})
@@ -859,6 +875,9 @@ macro (cotire_set_cmd_to_prologue _cmdVar)
 		list (APPEND ${_cmdVar} "--warn-uninitialized")
 	endif()
 	list (APPEND ${_cmdVar} "-DCOTIRE_BUILD_TYPE:STRING=$<CONFIGURATION>")
+	if (XCODE)
+		list (APPEND ${_cmdVar} "-DXCODE:BOOL=TRUE")
+	endif()
 	if (COTIRE_VERBOSE)
 		list (APPEND ${_cmdVar} "-DCOTIRE_VERBOSE:BOOL=ON")
 	elseif("${CMAKE_GENERATOR}" MATCHES "Makefiles")
@@ -876,6 +895,9 @@ function (cotire_init_compile_cmd _cmdVar _language _compilerLauncher _compilerE
 	if (NOT _compilerArg1)
 		set (_compilerArg1 ${CMAKE_${_language}_COMPILER_ARG1})
 	endif()
+	if (WIN32)
+		file (TO_NATIVE_PATH "${_compilerExe}" _compilerExe)
+	endif()
 	string (STRIP "${_compilerArg1}" _compilerArg1)
 	if ("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")
 		# compiler launcher is only supported for Makefile and Ninja
@@ -902,16 +924,16 @@ function (cotire_add_includes_to_cmd _cmdVar _language _includesVar _systemInclu
 		foreach (_include ${_includeDirs})
 			if (WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
 				file (TO_NATIVE_PATH "${_include}" _include)
-				list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_${_language}_SEP}${_include}")
+				list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_SEP_${_language}}${_include}")
 			else()
 				set (_index -1)
 				if ("${CMAKE_INCLUDE_SYSTEM_FLAG_${_language}}" MATCHES ".+")
 					list (FIND ${_systemIncludesVar} "${_include}" _index)
 				endif()
 				if (_index GREATER -1)
-					list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_SYSTEM_FLAG_${_language}}${_include}")
+					list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_SYSTEM_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_SEP_${_language}}${_include}")
 				else()
-					list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_${_language}_SEP}${_include}")
+					list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_SEP_${_language}}${_include}")
 				endif()
 			endif()
 		endforeach()
@@ -1046,10 +1068,10 @@ macro (cotire_check_ignore_header_file_path _headerFile _headerIsIgnoredVar)
 		set (${_headerIsIgnoredVar} TRUE)
 	elseif (IS_DIRECTORY "${_headerFile}")
 		set (${_headerIsIgnoredVar} TRUE)
-	elseif ("${_headerFile}" MATCHES "\\.\\.|[_-]fixed" AND "${_headerFile}" MATCHES "\\.h$")
-		# heuristic: ignore C headers with embedded parent directory references or "-fixed" or "_fixed" in path
+	elseif ("${_headerFile}" MATCHES "\\.\\.|[_-]fixed")
+		# heuristic: ignore headers with embedded parent directory references or "-fixed" or "_fixed" in path
 		# these often stem from using GCC #include_next tricks, which may break the precompiled header compilation
-		# with the error message "error: no include path in which to search for header.h"
+		# with the error message "error: no include path in which to search for header"
 		set (${_headerIsIgnoredVar} TRUE)
 	else()
 		set (${_headerIsIgnoredVar} FALSE)
@@ -1070,12 +1092,11 @@ endmacro()
 
 macro (cotire_parse_line _line _headerFileVar _headerDepthVar)
 	if (MSVC)
-		# cl.exe /showIncludes output looks different depending on the language pack used, e.g.:
+		# cl.exe /showIncludes produces different output, depending on the language pack used, e.g.:
 		# English: "Note: including file:   C:\directory\file"
 		# German: "Hinweis: Einlesen der Datei:   C:\directory\file"
 		# We use a very general regular expression, relying on the presence of the : characters
 		if (_line MATCHES "( +)([a-zA-Z]:[^:]+)$")
-			# Visual Studio compiler output
 			string (LENGTH "${CMAKE_MATCH_1}" ${_headerDepthVar})
 			get_filename_component(${_headerFileVar} "${CMAKE_MATCH_2}" ABSOLUTE)
 		else()
@@ -1233,11 +1254,19 @@ function (cotire_scan_includes _includesVar)
 		set (${_includesVar} "" PARENT_SCOPE)
 		return()
 	endif()
+	# add source files to be scanned
+	if (WIN32)
+		foreach (_sourceFile ${_existingSourceFiles})
+			file (TO_NATIVE_PATH "${_sourceFile}" _sourceFileNative)
+			list (APPEND _cmd "${_sourceFileNative}")
+		endforeach()
+	else()
 		list (APPEND _cmd ${_existingSourceFiles})
+	endif()
 	if (COTIRE_VERBOSE)
 		message (STATUS "execute_process: ${_cmd}")
 	endif()
-	if (_option_COMPILER_ID MATCHES "MSVC")
+	if (MSVC_IDE OR _option_COMPILER_ID MATCHES "MSVC")
 		# cl.exe messes with the output streams unless the environment variable VS_UNICODE_OUTPUT is cleared
 		unset (ENV{VS_UNICODE_OUTPUT})
 	endif()
@@ -1473,11 +1502,16 @@ function (cotire_generate_prefix_header _prefixFile)
 	if (_unparsedLines)
 		if (COTIRE_VERBOSE OR _scanResult OR NOT _selectedHeaders)
 			list (LENGTH _unparsedLines _skippedLineCount)
-			message (STATUS "${_skippedLineCount} line(s) skipped, see ${_unparsedLinesFile}")
+			if (WIN32)
+				file (TO_NATIVE_PATH "${_unparsedLinesFile}" _unparsedLinesLogPath)
+			else()
+				set (_unparsedLinesLogPath "${_unparsedLinesFile}")
+			endif()
+			message (STATUS "${_skippedLineCount} line(s) skipped, see ${_unparsedLinesLogPath}")
 		endif()
 		string (REPLACE ";" "\n" _unparsedLines "${_unparsedLines}")
 	endif()
-	file (WRITE "${_unparsedLinesFile}" "${_unparsedLines}")
+	file (WRITE "${_unparsedLinesFile}" "${_unparsedLines}\n")
 endfunction()
 
 function (cotire_add_makedep_flags _language _compilerID _compilerVersion _flagsVar)
@@ -1507,7 +1541,7 @@ function (cotire_add_makedep_flags _language _compilerID _compilerVersion _flags
 			# append to list
 			list (APPEND _flags -H -E)
 			if (NOT "${_compilerVersion}" VERSION_LESS "4.3.0")
-				list (APPEND _flags "-fdirectives-only")
+				list (APPEND _flags -fdirectives-only)
 			endif()
 		else()
 			# return as a flag string
@@ -1517,16 +1551,36 @@ function (cotire_add_makedep_flags _language _compilerID _compilerVersion _flags
 			endif()
 		endif()
 	elseif (_compilerID MATCHES "Clang")
+		if (UNIX)
 			# Clang options used
 			# -H print the name of each header file used
 			# -E invoke preprocessor
-		# -fno-color-diagnostics don't prints diagnostics in color
+			# -fno-color-diagnostics do not print diagnostics in color
+			# -Eonly just run preprocessor, no output
 			if (_flags)
 				# append to list
-			list (APPEND _flags -H -E -fno-color-diagnostics)
+				list (APPEND _flags -H -E -fno-color-diagnostics -Xclang -Eonly)
 			else()
 				# return as a flag string
-			set (_flags "-H -E -fno-color-diagnostics")
+				set (_flags "-H -E -fno-color-diagnostics -Xclang -Eonly")
+			endif()
+		elseif (WIN32)
+			# Clang-cl.exe options used
+			# /TC treat all files named on the command line as C source files
+			# /TP treat all files named on the command line as C++ source files
+			# /EP preprocess to stdout without #line directives
+			# -H print the name of each header file used
+			# -fno-color-diagnostics do not print diagnostics in color
+			# -Eonly just run preprocessor, no output
+			set (_sourceFileTypeC "/TC")
+			set (_sourceFileTypeCXX "/TP")
+			if (_flags)
+				# append to list
+				list (APPEND _flags "${_sourceFileType${_language}}" /EP -fno-color-diagnostics -Xclang -H -Xclang -Eonly)
+			else()
+				# return as a flag string
+				set (_flags "${_sourceFileType${_language}} /EP -fno-color-diagnostics -Xclang -H -Xclang -Eonly")
+			endif()
 		endif()
 	elseif (_compilerID MATCHES "Intel")
 		if (WIN32)
@@ -1600,8 +1654,8 @@ function (cotire_add_pch_compilation_flags _language _compilerID _compilerVersio
 				set (_flags "${_flags} /Zm${COTIRE_PCH_MEMORY_SCALING_FACTOR}")
 			endif()
 		endif()
-	elseif (_compilerID MATCHES "GNU|Clang")
-		# GCC / Clang options used
+	elseif (_compilerID MATCHES "GNU")
+		# GCC options used
 		# -x specify the source language
 		# -c compile but do not link
 		# -o place output in file
@@ -1611,11 +1665,55 @@ function (cotire_add_pch_compilation_flags _language _compilerID _compilerVersio
 		set (_xLanguage_CXX "c++-header")
 		if (_flags)
 			# append to list
-			list (APPEND _flags "-x" "${_xLanguage_${_language}}" "-c" "${_prefixFile}" -o "${_pchFile}")
+			list (APPEND _flags -x "${_xLanguage_${_language}}" -c "${_prefixFile}" -o "${_pchFile}")
 		else()
 			# return as a flag string
 			set (_flags "-x ${_xLanguage_${_language}} -c \"${_prefixFile}\" -o \"${_pchFile}\"")
 		endif()
+	elseif (_compilerID MATCHES "Clang")
+		if (UNIX)
+			# Clang options used
+			# -x specify the source language
+			# -c compile but do not link
+			# -o place output in file
+			# -fno-pch-timestamp disable inclusion of timestamp in precompiled headers (clang 4.0.0+)
+			set (_xLanguage_C "c-header")
+			set (_xLanguage_CXX "c++-header")
+			if (_flags)
+				# append to list
+				list (APPEND _flags -x "${_xLanguage_${_language}}" -c "${_prefixFile}" -o "${_pchFile}")
+				if (NOT "${_compilerVersion}" VERSION_LESS "4.0.0")
+					list (APPEND _flags -Xclang -fno-pch-timestamp)
+				endif()
+			else()
+				# return as a flag string
+				set (_flags "-x ${_xLanguage_${_language}} -c \"${_prefixFile}\" -o \"${_pchFile}\"")
+				if (NOT "${_compilerVersion}" VERSION_LESS "4.0.0")
+					set (_flags "${_flags} -Xclang -fno-pch-timestamp")
+				endif()
+			endif()
+		elseif (WIN32)
+			file (TO_NATIVE_PATH "${_prefixFile}" _prefixFileNative)
+			file (TO_NATIVE_PATH "${_pchFile}" _pchFileNative)
+			file (TO_NATIVE_PATH "${_hostFile}" _hostFileNative)
+			# Clang-cl.exe options used
+			# /Yc creates a precompiled header file
+			# /Fp specifies precompiled header binary file name
+			# /FI forces inclusion of file
+			# /Zs syntax check only
+			# /TC treat all files named on the command line as C source files
+			# /TP treat all files named on the command line as C++ source files
+			set (_sourceFileTypeC "/TC")
+			set (_sourceFileTypeCXX "/TP")
+			if (_flags)
+				# append to list
+				list (APPEND _flags "${_sourceFileType${_language}}"
+						"/Yc${_prefixFileNative}" "/Fp${_pchFileNative}" "/FI${_prefixFileNative}" /Zs "${_hostFileNative}")
+			else()
+				# return as a flag string
+				set (_flags "/Yc\"${_prefixFileNative}\" /Fp\"${_pchFileNative}\" /FI\"${_prefixFileNative}\"")
+			endif()
+		endif()
 	elseif (_compilerID MATCHES "Intel")
 		if (WIN32)
 			file (TO_NATIVE_PATH "${_prefixFile}" _prefixFileNative)
@@ -1657,23 +1755,31 @@ function (cotire_add_pch_compilation_flags _language _compilerID _compilerVersio
 			get_filename_component(_pchName "${_pchFile}" NAME)
 			set (_xLanguage_C "c-header")
 			set (_xLanguage_CXX "c++-header")
+			set (_pchSuppressMessages FALSE)
+			if ("${CMAKE_${_language}_FLAGS}" MATCHES ".*-Wno-pch-messages.*")
+				set(_pchSuppressMessages TRUE)
+			endif()
 			if (_flags)
 				# append to list
 				if ("${_language}" STREQUAL "CXX")
 					list (APPEND _flags -Kc++)
 				endif()
-				list (APPEND _flags "-include" "${_prefixFile}" "-pch-dir" "${_pchDir}" "-pch-create" "${_pchName}" "-fsyntax-only" "${_hostFile}")
+				list (APPEND _flags -include "${_prefixFile}" -pch-dir "${_pchDir}" -pch-create "${_pchName}" -fsyntax-only "${_hostFile}")
 				if (NOT "${_compilerVersion}" VERSION_LESS "13.1.0")
-					list (APPEND _flags "-Wpch-messages")
+					if (NOT _pchSuppressMessages)
+						list (APPEND _flags -Wpch-messages)
+					endif()
 				endif()
 			else()
 				# return as a flag string
 				set (_flags "-include \"${_prefixFile}\" -pch-dir \"${_pchDir}\" -pch-create \"${_pchName}\"")
 				if (NOT "${_compilerVersion}" VERSION_LESS "13.1.0")
+					if (NOT _pchSuppressMessages)
 						set (_flags "${_flags} -Wpch-messages")
 					endif()
 				endif()
 			endif()
+		endif()
 	else()
 		message (FATAL_ERROR "cotire: unsupported ${_language} compiler ${_compilerID} version ${_compilerVersion}.")
 	endif()
@@ -1721,23 +1827,48 @@ function (cotire_add_prefix_pch_inclusion_flags _language _compilerID _compilerV
 		# note: ccache requires the -include flag to be used in order to process precompiled header correctly
 		if (_flags)
 			# append to list
-			list (APPEND _flags "-Winvalid-pch" "-include" "${_prefixFile}")
+			list (APPEND _flags -Winvalid-pch -include "${_prefixFile}")
 		else()
 			# return as a flag string
 			set (_flags "-Winvalid-pch -include \"${_prefixFile}\"")
 		endif()
 	elseif (_compilerID MATCHES "Clang")
+		if (UNIX)
 			# Clang options used
 			# -include process include file as the first line of the primary source file
-		# -include-pch include precompiled header file
-		# -Qunused-arguments don't emit warning for unused driver arguments
 			# note: ccache requires the -include flag to be used in order to process precompiled header correctly
 			if (_flags)
 				# append to list
-			list (APPEND _flags "-Qunused-arguments" "-include" "${_prefixFile}")
+				list (APPEND _flags -include "${_prefixFile}")
 			else()
 				# return as a flag string
-			set (_flags "-Qunused-arguments -include \"${_prefixFile}\"")
+				set (_flags "-include \"${_prefixFile}\"")
+			endif()
+		elseif (WIN32)
+			file (TO_NATIVE_PATH "${_prefixFile}" _prefixFileNative)
+			# Clang-cl.exe options used
+			# /Yu uses a precompiled header file during build
+			# /Fp specifies precompiled header binary file name
+			# /FI forces inclusion of file
+			if (_pchFile)
+				file (TO_NATIVE_PATH "${_pchFile}" _pchFileNative)
+				if (_flags)
+					# append to list
+					list (APPEND _flags "/Yu${_prefixFileNative}" "/Fp${_pchFileNative}" "/FI${_prefixFileNative}")
+				else()
+					# return as a flag string
+					set (_flags "/Yu\"${_prefixFileNative}\" /Fp\"${_pchFileNative}\" /FI\"${_prefixFileNative}\"")
+				endif()
+			else()
+				# no precompiled header, force inclusion of prefix header
+				if (_flags)
+					# append to list
+					list (APPEND _flags "/FI${_prefixFileNative}")
+				else()
+					# return as a flag string
+					set (_flags "/FI\"${_prefixFileNative}\"")
+				endif()
+			endif()
 		endif()
 	elseif (_compilerID MATCHES "Intel")
 		if (WIN32)
@@ -1781,24 +1912,32 @@ function (cotire_add_prefix_pch_inclusion_flags _language _compilerID _compilerV
 			if (_pchFile)
 				get_filename_component(_pchDir "${_pchFile}" DIRECTORY)
 				get_filename_component(_pchName "${_pchFile}" NAME)
+				set (_pchSuppressMessages FALSE)
+				if ("${CMAKE_${_language}_FLAGS}" MATCHES ".*-Wno-pch-messages.*")
+					set(_pchSuppressMessages TRUE)
+				endif()
 				if (_flags)
 					# append to list
-					list (APPEND _flags "-include" "${_prefixFile}" "-pch-dir" "${_pchDir}" "-pch-use" "${_pchName}")
+					list (APPEND _flags -include "${_prefixFile}" -pch-dir "${_pchDir}" -pch-use "${_pchName}")
 					if (NOT "${_compilerVersion}" VERSION_LESS "13.1.0")
-						list (APPEND _flags "-Wpch-messages")
+						if (NOT _pchSuppressMessages)
+							list (APPEND _flags -Wpch-messages)
+						endif()
 					endif()
 				else()
 					# return as a flag string
 					set (_flags "-include \"${_prefixFile}\" -pch-dir \"${_pchDir}\" -pch-use \"${_pchName}\"")
 					if (NOT "${_compilerVersion}" VERSION_LESS "13.1.0")
+						if (NOT _pchSuppressMessages)
 							set (_flags "${_flags} -Wpch-messages")
 						endif()
 					endif()
+				endif()
 			else()
 				# no precompiled header, force inclusion of prefix header
 				if (_flags)
 					# append to list
-					list (APPEND _flags "-include" "${_prefixFile}")
+					list (APPEND _flags -include "${_prefixFile}")
 				else()
 					# return as a flag string
 					set (_flags "-include \"${_prefixFile}\"")
@@ -1836,9 +1975,17 @@ function (cotire_precompile_prefix_header _prefixFile _pchFile _hostFile)
 	if (COTIRE_VERBOSE)
 		message (STATUS "execute_process: ${_cmd}")
 	endif()
-	if (_option_COMPILER_ID MATCHES "MSVC")
+	if (MSVC_IDE OR _option_COMPILER_ID MATCHES "MSVC")
 		# cl.exe messes with the output streams unless the environment variable VS_UNICODE_OUTPUT is cleared
 		unset (ENV{VS_UNICODE_OUTPUT})
+	elseif (_option_COMPILER_ID MATCHES "Clang" AND _option_COMPILER_VERSION VERSION_LESS "4.0.0")
+		if (_option_COMPILER_LAUNCHER MATCHES "ccache" OR
+			_option_COMPILER_EXECUTABLE MATCHES "ccache")
+			# Newer versions of Clang embed a compilation timestamp into the precompiled header binary,
+			# which results in "file has been modified since the precompiled header was built" errors if ccache is used.
+			# We work around the problem by disabling ccache upon pre-compiling the prefix header.
+			set (ENV{CCACHE_DISABLE} "true")
+		endif()
 	endif()
 	execute_process(
 		COMMAND ${_cmd}
@@ -1853,7 +2000,7 @@ function (cotire_check_precompiled_header_support _language _target _msgVar)
 	set (_unsupportedCompiler
 		"Precompiled headers not supported for ${_language} compiler ${CMAKE_${_language}_COMPILER_ID}")
 	if (CMAKE_${_language}_COMPILER_ID MATCHES "MSVC")
-		# supported since Visual Studio C++ 6.0
+		# PCH supported since Visual Studio C++ 6.0
 		# and CMake does not support an earlier version
 		set (${_msgVar} "" PARENT_SCOPE)
 	elseif (CMAKE_${_language}_COMPILER_ID MATCHES "GNU")
@@ -1864,8 +2011,16 @@ function (cotire_check_precompiled_header_support _language _target _msgVar)
 			set (${_msgVar} "" PARENT_SCOPE)
 		endif()
 	elseif (CMAKE_${_language}_COMPILER_ID MATCHES "Clang")
-		# all Clang versions have PCH support
+		if (UNIX)
+			# all Unix Clang versions have PCH support
 			set (${_msgVar} "" PARENT_SCOPE)
+		elseif (WIN32)
+			# only clang-cl is supported under Windows
+			get_filename_component(_compilerName "${CMAKE_${_language}_COMPILER}" NAME_WE)
+			if (NOT _compilerName MATCHES "cl$")
+				set (${_msgVar} "${_unsupportedCompiler} version ${CMAKE_${_language}_COMPILER_VERSION}. Use clang-cl instead." PARENT_SCOPE)
+			endif()
+		endif()
 	elseif (CMAKE_${_language}_COMPILER_ID MATCHES "Intel")
 		# Intel PCH support requires version >= 8.0.0
 		if ("${CMAKE_${_language}_COMPILER_VERSION}" VERSION_LESS "8.0.0")
@@ -1876,29 +2031,38 @@ function (cotire_check_precompiled_header_support _language _target _msgVar)
 	else()
 		set (${_msgVar} "${_unsupportedCompiler}." PARENT_SCOPE)
 	endif()
+	# check if ccache is used as a compiler launcher
 	get_target_property(_launcher ${_target} ${_language}_COMPILER_LAUNCHER)
-	if (CMAKE_${_language}_COMPILER MATCHES "ccache" OR _launcher MATCHES "ccache")
+	get_filename_component(_realCompilerExe "${CMAKE_${_language}_COMPILER}" REALPATH)
+	if (_realCompilerExe MATCHES "ccache" OR _launcher MATCHES "ccache")
+		# verify that ccache configuration is compatible with precompiled headers
+		# always check environment variable CCACHE_SLOPPINESS, because earlier versions of ccache
+		# do not report the "sloppiness" setting correctly upon printing ccache configuration
 		if (DEFINED ENV{CCACHE_SLOPPINESS})
-			if (NOT "$ENV{CCACHE_SLOPPINESS}" MATCHES "pch_defines" OR NOT "$ENV{CCACHE_SLOPPINESS}" MATCHES "time_macros")
+			if (NOT "$ENV{CCACHE_SLOPPINESS}" MATCHES "pch_defines" OR
+				NOT "$ENV{CCACHE_SLOPPINESS}" MATCHES "time_macros")
 				set (${_msgVar}
 					"ccache requires the environment variable CCACHE_SLOPPINESS to be set to \"pch_defines,time_macros\"."
 					PARENT_SCOPE)
 			endif()
 		else()
-			if (_launcher MATCHES "ccache")
-				get_filename_component(_ccacheExe "${_launcher}" REALPATH)
+			if (_realCompilerExe MATCHES "ccache")
+				set (_ccacheExe "${_realCompilerExe}")
 			else()
-				get_filename_component(_ccacheExe "${CMAKE_${_language}_COMPILER}" REALPATH)
+				set (_ccacheExe "${_launcher}")
 			endif()
+			# ccache 3.7.0 replaced --print-config with --show-config
+			# use -p instead, which seems to work for all version for now, sigh
 			execute_process(
-				COMMAND "${_ccacheExe}" "--print-config"
+				COMMAND "${_ccacheExe}" "-p"
 				WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
 				RESULT_VARIABLE _result
 				OUTPUT_VARIABLE _ccacheConfig OUTPUT_STRIP_TRAILING_WHITESPACE
 				ERROR_QUIET)
-			if (_result OR NOT
-				_ccacheConfig MATCHES "sloppiness.*=.*time_macros" OR NOT
-				_ccacheConfig MATCHES "sloppiness.*=.*pch_defines")
+			if (_result)
+				set (${_msgVar} "ccache configuration cannot be determined." PARENT_SCOPE)
+			elseif (NOT _ccacheConfig MATCHES "sloppiness.*=.*time_macros" OR
+				NOT _ccacheConfig MATCHES "sloppiness.*=.*pch_defines")
 				set (${_msgVar}
 					"ccache requires configuration setting \"sloppiness\" to be set to \"pch_defines,time_macros\"."
 					PARENT_SCOPE)
@@ -2191,7 +2355,7 @@ function (cotire_generate_target_script _language _configurations _target _targe
 		XCODE MSVC CMAKE_GENERATOR CMAKE_BUILD_TYPE CMAKE_CONFIGURATION_TYPES
 		CMAKE_${_language}_COMPILER_ID CMAKE_${_language}_COMPILER_VERSION
 		CMAKE_${_language}_COMPILER_LAUNCHER CMAKE_${_language}_COMPILER CMAKE_${_language}_COMPILER_ARG1
-		CMAKE_INCLUDE_FLAG_${_language} CMAKE_INCLUDE_FLAG_${_language}_SEP
+		CMAKE_INCLUDE_FLAG_${_language} CMAKE_INCLUDE_FLAG_SEP_${_language}
 		CMAKE_INCLUDE_SYSTEM_FLAG_${_language}
 		CMAKE_${_language}_FRAMEWORK_SEARCH_FLAG
 		CMAKE_${_language}_SYSTEM_FRAMEWORK_SEARCH_FLAG
@@ -2224,8 +2388,9 @@ endfunction()
 
 function (cotire_setup_pch_file_compilation _language _target _targetScript _prefixFile _pchFile _hostFile)
 	set (_sourceFiles ${ARGN})
-	if (CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
-		# for Visual Studio and Intel, we attach the precompiled header compilation to the host file
+	if (CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel" OR
+		(WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "Clang"))
+		# for MSVC, Intel and Clang-cl, we attach the precompiled header compilation to the host file
 		# the remaining files include the precompiled header, see cotire_setup_pch_file_inclusion
 		if (_sourceFiles)
 			set (_flags "")
@@ -2233,6 +2398,9 @@ function (cotire_setup_pch_file_compilation _language _target _targetScript _pre
 				"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${CMAKE_${_language}_COMPILER_VERSION}"
 				"${_prefixFile}" "${_pchFile}" "${_hostFile}" _flags)
 			set_property (SOURCE ${_hostFile} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_flags} ")
+			if (COTIRE_DEBUG)
+				message (STATUS "set_property: SOURCE ${_hostFile} APPEND_STRING COMPILE_FLAGS ${_flags}")
+			endif()
 			set_property (SOURCE ${_hostFile} APPEND PROPERTY OBJECT_OUTPUTS "${_pchFile}")
 			# make object file generated from host file depend on prefix header
 			set_property (SOURCE ${_hostFile} APPEND PROPERTY OBJECT_DEPENDS "${_prefixFile}")
@@ -2270,8 +2438,9 @@ function (cotire_setup_pch_file_compilation _language _target _targetScript _pre
 endfunction()
 
 function (cotire_setup_pch_file_inclusion _language _target _wholeTarget _prefixFile _pchFile _hostFile)
-	if (CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
-		# for Visual Studio and Intel, we include the precompiled header in all but the host file
+	if (CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel" OR
+		(WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "Clang"))
+		# for MSVC, Intel and clang-cl, we include the precompiled header in all but the host file
 		# the host file does the precompiled header compilation, see cotire_setup_pch_file_compilation
 		set (_sourceFiles ${ARGN})
 		list (LENGTH _sourceFiles _numberOfSourceFiles)
@@ -2283,6 +2452,9 @@ function (cotire_setup_pch_file_inclusion _language _target _wholeTarget _prefix
 				"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${CMAKE_${_language}_COMPILER_VERSION}"
 				"${_prefixFile}" "${_pchFile}" _flags)
 			set_property (SOURCE ${_sourceFiles} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_flags} ")
+			if (COTIRE_DEBUG)
+				message (STATUS "set_property: SOURCE ${_sourceFiles} APPEND_STRING COMPILE_FLAGS ${_flags}")
+			endif()
 			# make object files generated from source files depend on precompiled header
 			set_property (SOURCE ${_sourceFiles} APPEND PROPERTY OBJECT_DEPENDS "${_pchFile}")
 		endif()
@@ -2296,6 +2468,9 @@ function (cotire_setup_pch_file_inclusion _language _target _wholeTarget _prefix
 				"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${CMAKE_${_language}_COMPILER_VERSION}"
 				"${_prefixFile}" "${_pchFile}" _flags)
 			set_property (SOURCE ${_sourceFiles} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_flags} ")
+			if (COTIRE_DEBUG)
+				message (STATUS "set_property: SOURCE ${_sourceFiles} APPEND_STRING COMPILE_FLAGS ${_flags}")
+			endif()
 			# mark sources as cotired to prevent them from being used in another cotired target
 			set_source_files_properties(${_sourceFiles} PROPERTIES COTIRE_TARGET "${_target}")
 		endif()
@@ -2313,6 +2488,9 @@ function (cotire_setup_prefix_file_inclusion _language _target _prefixFile)
 		"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${CMAKE_${_language}_COMPILER_VERSION}"
 		"${_prefixFile}" "${_pchFile}" _flags)
 	set_property (SOURCE ${_sourceFiles} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_flags} ")
+	if (COTIRE_DEBUG)
+		message (STATUS "set_property: SOURCE ${_sourceFiles} APPEND_STRING COMPILE_FLAGS ${_flags}")
+	endif()
 	# mark sources as cotired to prevent them from being used in another cotired target
 	set_source_files_properties(${_sourceFiles} PROPERTIES COTIRE_TARGET "${_target}")
 	# make object files generated from source files depend on prefix header
@@ -2402,7 +2580,7 @@ function (cotire_setup_target_pch_usage _languages _target _wholeTarget)
 			message (STATUS "add_custom_command: TARGET ${_target} PRE_BUILD ${_cmds}")
 		endif()
 		# because CMake PRE_BUILD command does not support dependencies,
-		# we check dependencies explicitly in cotire script mode when the pre-build action is run
+		# we check dependencies explicity in cotire script mode when the pre-build action is run
 		add_custom_command(
 			TARGET "${_target}"
 			PRE_BUILD ${_cmds}
@@ -2417,9 +2595,10 @@ function (cotire_setup_target_pch_usage _languages _target _wholeTarget)
 		# if this is a single-language target without any excluded files
 		if (_wholeTarget)
 			set (_language "${_languages}")
-			# for Visual Studio and Intel, precompiled header inclusion is always done on the source file level
+			# for MSVC, Intel and clang-cl, precompiled header inclusion is always done on the source file level
 			# see cotire_setup_pch_file_inclusion
-			if (NOT CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
+			if (NOT CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel" AND NOT
+				(WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "Clang"))
 				get_property(_prefixFile TARGET ${_target} PROPERTY COTIRE_${_language}_PREFIX_HEADER)
 				if (_prefixFile)
 					get_property(_pchFile TARGET ${_target} PROPERTY COTIRE_${_language}_PRECOMPILED_HEADER)
@@ -2428,6 +2607,9 @@ function (cotire_setup_target_pch_usage _languages _target _wholeTarget)
 						"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${CMAKE_${_language}_COMPILER_VERSION}"
 						"${_prefixFile}" "${_pchFile}" _options)
 					set_property(TARGET ${_target} APPEND PROPERTY ${_options})
+					if (COTIRE_DEBUG)
+						message (STATUS "set_property: TARGET ${_target} APPEND PROPERTY ${_options}")
+					endif()
 				endif()
 			endif()
 		endif()
@@ -2454,7 +2636,8 @@ function (cotire_setup_unity_generation_commands _language _target _targetScript
 			set_property (SOURCE "${_unityFile}" PROPERTY OBJECT_DEPENDS ${_objectDependsPaths})
 		endif()
 		if (WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
-			# unity file compilation results in potentially huge object file, thus use /bigobj by default unter MSVC and Windows Intel
+			# unity file compilation results in potentially huge object file,
+			# thus use /bigobj by default unter cl.exe and Windows Intel
 			set_property (SOURCE "${_unityFile}" APPEND_STRING PROPERTY COMPILE_FLAGS "/bigobj")
 		endif()
 		cotire_set_cmd_to_prologue(_unityCmd)
@@ -2660,6 +2843,9 @@ function (cotire_make_target_message _target _languages _disableMsg _targetMsgVa
 		else()
 			set (_targetMsg "${_languagesStr} target ${_target} cotired without unity build.")
 		endif()
+		if (_disableMsg)
+			set (_targetMsg "${_targetMsg} ${_disableMsg}")
+		endif()
 	else()
 		if (_excludedStr)
 			set (_targetMsg "${_languagesStr} target ${_target} cotired ${_excludedStr}.")
@@ -2749,6 +2935,20 @@ function (cotire_choose_target_languages _target _targetLanguagesVar _wholeTarge
 			set (_targetUsePCH FALSE)
 		endif()
 	endif()
+	if (_targetAddSCU)
+		# disable unity builds if automatic Qt processing is used
+		get_target_property(_targetAutoMoc ${_target} AUTOMOC)
+		get_target_property(_targetAutoUic ${_target} AUTOUIC)
+		get_target_property(_targetAutoRcc ${_target} AUTORCC)
+		if (_targetAutoMoc OR _targetAutoUic OR _targetAutoRcc)
+			if (_disableMsg)
+				set (_disableMsg "${_disableMsg} Target uses automatic CMake Qt processing.")
+			else()
+				set (_disableMsg "Target uses automatic CMake Qt processing.")
+			endif()
+			set (_targetAddSCU FALSE)
+		endif()
+	endif()
 	set_property(TARGET ${_target} PROPERTY COTIRE_ENABLE_PRECOMPILED_HEADER ${_targetUsePCH})
 	set_property(TARGET ${_target} PROPERTY COTIRE_ADD_UNITY_BUILD ${_targetAddSCU})
 	cotire_make_target_message(${_target} "${_targetLanguages}" "${_disableMsg}" _targetMsg ${_allExcludedSourceFiles})
@@ -2776,7 +2976,11 @@ function (cotire_compute_unity_max_number_of_includes _target _maxIncludesVar)
 	set (_sourceFiles ${ARGN})
 	get_target_property(_maxIncludes ${_target} COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES)
 	if (_maxIncludes MATCHES "(-j|--parallel|--jobs) ?([0-9]*)")
+		if (DEFINED CMAKE_MATCH_2)
 			set (_numberOfThreads "${CMAKE_MATCH_2}")
+		else()
+			set (_numberOfThreads "")
+		endif()
 		if (NOT _numberOfThreads)
 			# use all available cores
 			ProcessorCount(_numberOfThreads)
@@ -2889,8 +3093,9 @@ function (cotire_setup_pch_target _languages _configurations _target)
 		set (_dependsFiles "")
 		foreach (_language ${_languages})
 			set (_props COTIRE_${_language}_PREFIX_HEADER COTIRE_${_language}_UNITY_SOURCE)
-			if (NOT CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
-				# Visual Studio and Intel only create precompiled header as a side effect
+			if (NOT CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel" AND NOT
+				(WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "Clang"))
+				# MSVC, Intel and clang-cl only create precompiled header as a side effect
 				list (INSERT _props 0 COTIRE_${_language}_PRECOMPILED_HEADER)
 			endif()
 			cotire_get_first_set_property_value(_dependsFile TARGET ${_target} ${_props})
@@ -2938,6 +3143,7 @@ function (cotire_collect_unity_target_sources _target _languages _unityTargetSou
 			list (APPEND _unityTargetSources ${_unityFiles})
 		endif()
 	endforeach()
+	# handle object libraries which are part of the target's sources
 	get_target_property(_linkLibrariesStrategy ${_target} COTIRE_UNITY_LINK_LIBRARIES_INIT)
 	if ("${_linkLibrariesStrategy}" MATCHES "^COPY_UNITY$")
 		cotire_filter_object_libraries(${_target} _objectLibraries ${_targetSourceFiles})
@@ -2982,21 +3188,6 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 	# determine unity target sources
 	set (_unityTargetSources "")
 	cotire_collect_unity_target_sources(${_target} "${_languages}" _unityTargetSources)
-	# handle automatic Qt processing
-	get_target_property(_targetAutoMoc ${_target} AUTOMOC)
-	get_target_property(_targetAutoUic ${_target} AUTOUIC)
-	get_target_property(_targetAutoRcc ${_target} AUTORCC)
-	if (_targetAutoMoc OR _targetAutoUic OR _targetAutoRcc)
-		# if the original target sources are subject to CMake's automatic Qt processing,
-		# also include implicitly generated <targetname>_automoc.cpp file
-		if (CMAKE_VERSION VERSION_LESS "3.8.0")
-			list (APPEND _unityTargetSources "${_target}_automoc.cpp")
-			set_property (SOURCE "${_target}_automoc.cpp" PROPERTY GENERATED TRUE)
-		else()
-			list (APPEND _unityTargetSources "${_target}_autogen/moc_compilation.cpp")
-			set_property (SOURCE "${_target}_autogen/moc_compilation.cpp" PROPERTY GENERATED TRUE)
-		endif()
-	endif()
 	# prevent AUTOMOC, AUTOUIC and AUTORCC properties from being set when the unity target is created
 	set (CMAKE_AUTOMOC OFF)
 	set (CMAKE_AUTOUIC OFF)
@@ -3010,21 +3201,6 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 	else()
 		add_library(${_unityTargetName} ${_unityTargetSubType} EXCLUDE_FROM_ALL ${_unityTargetSources})
 	endif()
-	if ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
-		# depend on original target's automoc target, if it exists
-		if (TARGET ${_target}_automoc)
-			add_dependencies(${_unityTargetName} ${_target}_automoc)
-		endif()
-	else()
-		if (_targetAutoMoc OR _targetAutoUic OR _targetAutoRcc)
-			# depend on the original target's implicitly generated <targetname>_automoc target
-			if (CMAKE_VERSION VERSION_LESS "3.8.0")
-				add_dependencies(${_unityTargetName} ${_target}_automoc)
-			else()
-				add_dependencies(${_unityTargetName} ${_target}_autogen)
-			endif()
-		endif()
-	endif()
 	# copy output location properties
 	set (_outputDirProperties
 		ARCHIVE_OUTPUT_DIRECTORY ARCHIVE_OUTPUT_DIRECTORY_<CONFIG>
@@ -3036,8 +3212,8 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 			set (_outputDir "${COTIRE_UNITY_OUTPUT_DIRECTORY}")
 		else()
 			# append relative COTIRE_UNITY_OUTPUT_DIRECTORY to target's actual output directory
-			cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName} ${_outputDirProperties})
-			cotire_resolve_config_properites("${_configurations}" _properties ${_outputDirProperties})
+			cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName} ${_outputDirProperties})
+			cotire_resolve_config_properties("${_configurations}" _properties ${_outputDirProperties})
 			foreach (_property ${_properties})
 				get_property(_outputDir TARGET ${_target} PROPERTY ${_property})
 				if (_outputDir)
@@ -3057,11 +3233,11 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 				RUNTIME_OUTPUT_DIRECTORY "${_outputDir}")
 		endif()
 	else()
-		cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+		cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 			${_outputDirProperties})
 	endif()
 	# copy output name
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		ARCHIVE_OUTPUT_NAME ARCHIVE_OUTPUT_NAME_<CONFIG>
 		LIBRARY_OUTPUT_NAME LIBRARY_OUTPUT_NAME_<CONFIG>
 		OUTPUT_NAME OUTPUT_NAME_<CONFIG>
@@ -3069,7 +3245,7 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 		PREFIX <CONFIG>_POSTFIX SUFFIX
 		IMPORT_PREFIX IMPORT_SUFFIX)
 	# copy compile stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		COMPILE_DEFINITIONS COMPILE_DEFINITIONS_<CONFIG>
 		COMPILE_FLAGS COMPILE_OPTIONS
 		Fortran_FORMAT Fortran_MODULE_DIRECTORY
@@ -3081,12 +3257,12 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 		C_VISIBILITY_PRESET CXX_VISIBILITY_PRESET VISIBILITY_INLINES_HIDDEN
 		C_CLANG_TIDY CXX_CLANG_TIDY)
 	# copy compile features
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		C_EXTENSIONS C_STANDARD C_STANDARD_REQUIRED
 		CXX_EXTENSIONS CXX_STANDARD CXX_STANDARD_REQUIRED
 		COMPILE_FEATURES)
 	# copy interface stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		COMPATIBLE_INTERFACE_BOOL COMPATIBLE_INTERFACE_NUMBER_MAX COMPATIBLE_INTERFACE_NUMBER_MIN
 		COMPATIBLE_INTERFACE_STRING
 		INTERFACE_COMPILE_DEFINITIONS INTERFACE_COMPILE_FEATURES INTERFACE_COMPILE_OPTIONS
@@ -3094,8 +3270,9 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 		INTERFACE_POSITION_INDEPENDENT_CODE INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
 		INTERFACE_AUTOUIC_OPTIONS NO_SYSTEM_FROM_IMPORTED)
 	# copy link stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
-		BUILD_WITH_INSTALL_RPATH INSTALL_RPATH INSTALL_RPATH_USE_LINK_PATH SKIP_BUILD_RPATH
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
+		BUILD_WITH_INSTALL_RPATH BUILD_WITH_INSTALL_NAME_DIR
+		INSTALL_RPATH INSTALL_RPATH_USE_LINK_PATH SKIP_BUILD_RPATH
 		LINKER_LANGUAGE LINK_DEPENDS LINK_DEPENDS_NO_SHARED
 		LINK_FLAGS LINK_FLAGS_<CONFIG>
 		LINK_INTERFACE_LIBRARIES LINK_INTERFACE_LIBRARIES_<CONFIG>
@@ -3103,18 +3280,18 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 		LINK_SEARCH_START_STATIC LINK_SEARCH_END_STATIC
 		STATIC_LIBRARY_FLAGS STATIC_LIBRARY_FLAGS_<CONFIG>
 		NO_SONAME SOVERSION VERSION
-		LINK_WHAT_YOU_USE)
+		LINK_WHAT_YOU_USE BUILD_RPATH)
 	# copy cmake stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		IMPLICIT_DEPENDS_INCLUDE_TRANSFORM RULE_LAUNCH_COMPILE RULE_LAUNCH_CUSTOM RULE_LAUNCH_LINK)
 	# copy Apple platform specific stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		BUNDLE BUNDLE_EXTENSION FRAMEWORK FRAMEWORK_VERSION INSTALL_NAME_DIR
 		MACOSX_BUNDLE MACOSX_BUNDLE_INFO_PLIST MACOSX_FRAMEWORK_INFO_PLIST MACOSX_RPATH
 		OSX_ARCHITECTURES OSX_ARCHITECTURES_<CONFIG> PRIVATE_HEADER PUBLIC_HEADER RESOURCE XCTEST
-		IOS_INSTALL_COMBINED)
+		IOS_INSTALL_COMBINED XCODE_EXPLICIT_FILE_TYPE XCODE_PRODUCT_TYPE)
 	# copy Windows platform specific stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		GNUtoMS
 		COMPILE_PDB_NAME COMPILE_PDB_NAME_<CONFIG>
 		COMPILE_PDB_OUTPUT_DIRECTORY COMPILE_PDB_OUTPUT_DIRECTORY_<CONFIG>
@@ -3128,15 +3305,19 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 		VS_WINRT_COMPONENT VS_WINRT_EXTENSIONS VS_WINRT_REFERENCES
 		WIN32_EXECUTABLE WINDOWS_EXPORT_ALL_SYMBOLS
 		DEPLOYMENT_REMOTE_DIRECTORY VS_CONFIGURATION_TYPE
-		VS_SDK_REFERENCES)
+		VS_SDK_REFERENCES VS_USER_PROPS VS_DEBUGGER_WORKING_DIRECTORY)
 	# copy Android platform specific stuff
-	cotire_copy_set_properites("${_configurations}" TARGET ${_target} ${_unityTargetName}
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
 		ANDROID_API ANDROID_API_MIN ANDROID_GUI
 		ANDROID_ANT_ADDITIONAL_OPTIONS ANDROID_ARCH ANDROID_ASSETS_DIRECTORIES
 		ANDROID_JAR_DEPENDENCIES ANDROID_JAR_DIRECTORIES ANDROID_JAVA_SOURCE_DIR
 		ANDROID_NATIVE_LIB_DEPENDENCIES ANDROID_NATIVE_LIB_DIRECTORIES
 		ANDROID_PROCESS_MAX ANDROID_PROGUARD ANDROID_PROGUARD_CONFIG_PATH
 		ANDROID_SECURE_PROPS_PATH ANDROID_SKIP_ANT_STEP ANDROID_STL_TYPE)
+	# copy CUDA platform specific stuff
+	cotire_copy_set_properties("${_configurations}" TARGET ${_target} ${_unityTargetName}
+		CUDA_PTX_COMPILATION CUDA_SEPARABLE_COMPILATION CUDA_RESOLVE_DEVICE_SYMBOLS
+		CUDA_EXTENSIONS CUDA_STANDARD CUDA_STANDARD_REQUIRED)
 	# use output name from original target
 	get_target_property(_targetOutputName ${_unityTargetName} OUTPUT_NAME)
 	if (NOT _targetOutputName)
@@ -3150,6 +3331,13 @@ function (cotire_setup_unity_build_target _languages _configurations _target)
 			set_property(TARGET ${_unityTargetName} PROPERTY ENABLE_EXPORTS TRUE)
 		endif()
 	endif()
+	# enable parallel compilation for MSVC
+	if (MSVC AND "${CMAKE_GENERATOR}" MATCHES "Visual Studio")
+		list (LENGTH _unityTargetSources _numberOfUnityTargetSources)
+		if (_numberOfUnityTargetSources GREATER 1)
+			set_property(TARGET ${_unityTargetName} APPEND PROPERTY COMPILE_OPTIONS "/MP")
+		endif()
+	endif()
 	cotire_init_target(${_unityTargetName})
 	cotire_add_to_unity_all_target(${_unityTargetName})
 	set_property(TARGET ${_target} PROPERTY COTIRE_UNITY_TARGET_NAME "${_unityTargetName}")
@@ -3308,6 +3496,13 @@ function (cotire_target_link_libraries _target)
 					message (STATUS "unity target ${_unityTargetName} interface link libraries: ${_unityLinkInterfaceLibraries}")
 				endif()
 			endif()
+			get_target_property(_manualDependencies ${_target} MANUALLY_ADDED_DEPENDENCIES)
+			if (_manualDependencies)
+				cotire_map_libraries("${_linkLibrariesStrategy}" _unityManualDependencies ${_manualDependencies})
+				if (_unityManualDependencies)
+					add_dependencies("${_unityTargetName}" ${_unityManualDependencies})
+				endif()
+			endif()
 		endif()
 	endif()
 endfunction(cotire_target_link_libraries)
@@ -3340,9 +3535,9 @@ function (cotire_init_target _targetName)
 		set_target_properties(${_targetName} PROPERTIES FOLDER "${COTIRE_TARGETS_FOLDER}")
 	endif()
 	set_target_properties(${_targetName} PROPERTIES EXCLUDE_FROM_ALL TRUE)
-	if (MSVC_IDE)
-		set_target_properties(${_targetName} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD TRUE)
-	endif()
+	# if (MSVC_IDE)
+	# 	set_target_properties(${_targetName} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+	# endif()
 endfunction()
 
 function (cotire_add_to_pch_all_target _pchTargetName)
@@ -3604,7 +3799,7 @@ else()
 	set (COTIRE_UNITY_SOURCE_EXCLUDE_EXTENSIONS "m;mm" CACHE STRING
 		"Ignore sources with the listed file extensions from the generated unity source.")
 
-	set (COTIRE_MINIMUM_NUMBER_OF_TARGET_SOURCES "3" CACHE STRING
+	set (COTIRE_MINIMUM_NUMBER_OF_TARGET_SOURCES "2" CACHE STRING
 		"Minimum number of sources in target required to enable use of precompiled header.")
 
 	if (NOT DEFINED COTIRE_MAXIMUM_NUMBER_OF_UNITY_INCLUDES_INIT)
@@ -3703,7 +3898,7 @@ else()
 		FULL_DOCS
 			"The variable can be set to an integer > 0."
 			"If a target contains less than that number of source files, cotire will not enable the use of the precompiled header for the target."
-			"If not defined, defaults to 3."
+			"If not defined, defaults to 2."
 	)
 
 	define_property(

adm/cmake/draco.cmake

@@ -1,4 +1,96 @@
 # Draco - a library for a lossy vertex data compression, used as extension to glTF format.
 # https://github.com/google/draco
 
-THIRDPARTY_PRODUCT("DRACO" "draco/compression/decode.h" "CSF_Draco" "")
+OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_macros")
+
+if (NOT DEFINED INSTALL_DRACO)
+  set (INSTALL_DRACO OFF CACHE BOOL "${INSTALL_DRACO_DESCR}")
+endif()
+
+if (NOT DEFINED 3RDPARTY_DRACO_DIR)
+  set (3RDPARTY_DRACO_DIR "" CACHE PATH "The directory containing Draco")
+endif()
+
+if (NOT DEFINED 3RDPARTY_DRACO_INCLUDE_DIR)
+  set (3RDPARTY_DRACO_INCLUDE_DIR  "" CACHE PATH "The directory containing headers of the Draco")
+endif()
+
+if (NOT DEFINED 3RDPARTY_DRACO_LIBRARY OR NOT 3RDPARTY_DRACO_LIBRARY_DIR OR NOT EXISTS "${3RDPARTY_DRACO_LIBRARY_DIR}")
+  set (3RDPARTY_DRACO_LIBRARY "" CACHE FILEPATH "Draco library"  FORCE)
+endif()
+
+if (NOT DEFINED 3RDPARTY_DRACO_LIBRARY_DIR)
+  set (3RDPARTY_DRACO_LIBRARY_DIR "" CACHE PATH "The directory containing Draco library")
+endif()
+
+if (3RDPARTY_DIR AND EXISTS "${3RDPARTY_DIR}")
+  if (NOT 3RDPARTY_DRACO_DIR OR NOT EXISTS "${3RDPARTY_DRACO_DIR}")
+    FIND_PRODUCT_DIR("${3RDPARTY_DIR}" draco DRACO_DIR_NAME)
+    if (DRACO_DIR_NAME)
+      set (3RDPARTY_DRACO_DIR "${3RDPARTY_DIR}/${DRACO_DIR_NAME}" CACHE PATH "The directory containing Draco" FORCE)
+    endif()
+  endif()
+endif()
+
+if (3RDPARTY_DRACO_DIR AND EXISTS "${3RDPARTY_DRACO_DIR}")
+  set (DRACO_INCLUDE_PATH "${3RDPARTY_DRACO_DIR}/include")
+  set (DRACO_LIBRARY_PATH "${3RDPARTY_DRACO_DIR}/lib")
+endif()
+
+if (NOT 3RDPARTY_DRACO_INCLUDE_DIR)
+  if (DRACO_INCLUDE_PATH AND EXISTS "${DRACO_INCLUDE_PATH}")
+    set (3RDPARTY_DRACO_INCLUDE_DIR "${DRACO_INCLUDE_PATH}" CACHE FILEPATH "The directory containing headers of DRACO" FORCE)
+  endif()
+endif()
+
+if (NOT 3RDPARTY_DRACO_LIBRARY_DIR)
+  if (DRACO_LIBRARY_PATH AND EXISTS "${DRACO_LIBRARY_PATH}")
+    set (3RDPARTY_DRACO_LIBRARY_DIR "${DRACO_LIBRARY_PATH}" CACHE FILEPATH "The directory containing DRACO library" FORCE)
+  endif()
+endif()
+
+if (3RDPARTY_DRACO_INCLUDE_DIR AND EXISTS "${3RDPARTY_DRACO_INCLUDE_DIR}")
+  list (APPEND 3RDPARTY_INCLUDE_DIRS "${3RDPARTY_DRACO_INCLUDE_DIR}")
+else()
+  list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_DRACO_INCLUDE_DIR)
+endif()
+
+if (3RDPARTY_DRACO_DIR AND EXISTS "${3RDPARTY_DRACO_DIR}")
+  if (NOT 3RDPARTY_DRACO_LIBRARY OR NOT EXISTS "${3RDPARTY_DRACO_LIBRARY}")
+    set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
+    set (3RDPARTY_DRACO_LIBRARY "3RDPARTY_DRACO_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to Draco library" FORCE)
+
+    find_library (3RDPARTY_DRACO_LIBRARY NAMES ${CSF_Draco}
+                                         PATHS "${3RDPARTY_DRACO_LIBRARY_DIR}"
+                                         PATH_SUFFIXES lib
+                                         CMAKE_FIND_ROOT_PATH_BOTH
+                                         NO_DEFAULT_PATH)
+    if (3RDPARTY_DRACO_LIBRARY AND EXISTS "${3RDPARTY_DRACO_LIBRARY}")
+      get_filename_component (3RDPARTY_DRACO_LIBRARY_DIR "${3RDPARTY_DRACO_LIBRARY}" PATH)
+      set (3RDPARTY_DRACO_LIBRARY_DIR "${3RDPARTY_DRACO_LIBRARY_DIR}" CACHE FILEPATH "The directory containing Draco library" FORCE)
+    endif()
+  endif()
+endif()
+
+if (3RDPARTY_DRACO_LIBRARY_DIR AND EXISTS "${3RDPARTY_DRACO_LIBRARY_DIR}")
+  list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_DRACO_LIBRARY_DIR}")
+else()
+  list (APPEND 3RDPARTY_NO_LIBS 3RDPARTY_DRACO_LIBRARY_DIR)
+endif()
+
+if (INSTALL_DRACO)
+  get_filename_component(3RDPARTY_DRACO_LIBRARY_REALPATH ${3RDPARTY_DRACO_LIBRARY} REALPATH)
+  if (SINGLE_GENERATOR)
+    install (FILES ${3RDPARTY_DRACO_LIBRARY_REALPATH} DESTINATION "${INSTALL_DIR_LIB}")
+  else()
+    install (FILES ${3RDPARTY_DRACO_LIBRARY_REALPATH}
+             CONFIGURATIONS Release
+             DESTINATION "${INSTALL_DIR_LIB}")
+    install (FILES ${3RDPARTY_DRACO_LIBRARY_REALPATH}
+             CONFIGURATIONS RelWithDebInfo
+             DESTINATION "${INSTALL_DIR_LIB}i")
+    install (FILES ${3RDPARTY_DRACO_LIBRARY_REALPATH}
+             CONFIGURATIONS Debug
+             DESTINATION "${INSTALL_DIR_LIB}d")
+  endif()
+endif()

adm/cmake/flex.cmake

@@ -26,9 +26,7 @@ if (3RDPARTY_DIR)
   endforeach()
 endif()
  
-# flex 2.5.37 is required because closest known lower version, 2.5.3 from WOK 6.8.0,
-# generates code which is unusable on Windows (includes unistd.h without any way to avoid this)
-find_package (FLEX 2.5.37)
+find_package (FLEX 2.6.4)
 
 if (NOT FLEX_FOUND OR NOT FLEX_INCLUDE_DIR OR NOT EXISTS "${FLEX_INCLUDE_DIR}/FlexLexer.h")
   list (APPEND 3RDPARTY_NOT_INCLUDED FLEX_INCLUDE_DIR)

adm/cmake/freetype.cmake

@@ -110,8 +110,19 @@ if (IS_BUILTIN_SEARCH_REQUIRED)
     set (ENV{FREETYPE_DIR} "${3RDPARTY_FREETYPE_DIR}")
   endif()
 
+  unset (FREETYPE_LIBRARY_RELEASE)
   find_package(Freetype)
 
+  # Only for UNIX (not APPLE)
+  if ((NOT WIN32) AND (NOT APPLE))
+    # To avoid linker error on Ubuntu 18.04 and others linux distributives we should
+    # link with freetype library, compiled as Position Independent Code (PIC),
+    # for example, with shared object.
+    if ((DEFINED FREETYPE_LIBRARY_RELEASE) AND (NOT "${FREETYPE_LIBRARY_RELEASE}" STREQUAL "") AND (EXISTS "${FREETYPE_LIBRARY_RELEASE}"))
+      string (REPLACE "\.a" "\.so" FREETYPE_LIBRARY_RELEASE "${FREETYPE_LIBRARY_RELEASE}")
+    endif()
+  endif()
+
   # restore ENV{FREETYPE_DIR}
   if (3RDPARTY_FREETYPE_DIR AND EXISTS "${3RDPARTY_FREETYPE_DIR}")
     set (ENV{FREETYPE_DIR} ${CACHED_FREETYPE_DIR})
@@ -122,7 +133,7 @@ if (IS_BUILTIN_SEARCH_REQUIRED)
     CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FREETYPE_DIR FREETYPE_INCLUDE_DIR_ft2build FILEPATH "The directory containing ft2build.h header")
     CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FREETYPE_DIR FREETYPE_INCLUDE_DIR_freetype2 FILEPATH "The directory containing ftheader.h header")
     if (BUILD_SHARED_LIBS)
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FREETYPE_DIR FREETYPE_LIBRARY FILEPATH "freetype library")
+      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FREETYPE_DIR FREETYPE_LIBRARY_RELEASE FILEPATH "freetype library")
     endif()
   endif()
 
@@ -141,8 +152,8 @@ if (IS_BUILTIN_SEARCH_REQUIRED)
 
   if (BUILD_SHARED_LIBS)
     if (NOT 3RDPARTY_FREETYPE_LIBRARY OR NOT EXISTS "${3RDPARTY_FREETYPE_LIBRARY}")
-      if (FREETYPE_LIBRARY AND EXISTS "${FREETYPE_LIBRARY}")
-        set (3RDPARTY_FREETYPE_LIBRARY  "${FREETYPE_LIBRARY}" CACHE FILEPATH "The path to freetype library" FORCE)
+      if (FREETYPE_LIBRARY_RELEASE AND EXISTS "${FREETYPE_LIBRARY_RELEASE}")
+        set (3RDPARTY_FREETYPE_LIBRARY  "${FREETYPE_LIBRARY_RELEASE}" CACHE FILEPATH "The path to freetype library" FORCE)
       endif()
     endif()
 
@@ -220,7 +231,7 @@ endif()
 # freetype library
 #if (BUILD_SHARED_LIBS)
   if (NOT 3RDPARTY_FREETYPE_LIBRARY OR NOT EXISTS "${3RDPARTY_FREETYPE_LIBRARY}")
-    set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
+    set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib)
 
     set (FREETYPE_PATH_SUFFIXES lib)
     if (ANDROID)
@@ -242,6 +253,16 @@ endif()
                                               CMAKE_FIND_ROOT_PATH_BOTH)
     endif()
 
+    # Only for UNIX (not APPLE)
+    if ((NOT WIN32) AND (NOT APPLE))
+      # To avoid linker error on Ubuntu 18.04 and some others linux distributives we should
+      # link with freetype library, compiled as Position Independent Code (PIC),
+      # for example, with shared object.
+      if ((DEFINED 3RDPARTY_FREETYPE_LIBRARY) AND (NOT "${3RDPARTY_FREETYPE_LIBRARY}" STREQUAL "") AND (EXISTS "${3RDPARTY_FREETYPE_LIBRARY}"))
+        string (REPLACE "\.a" "\.so" 3RDPARTY_FREETYPE_LIBRARY "${3RDPARTY_FREETYPE_LIBRARY}")
+      endif()
+    endif()
+
     if (3RDPARTY_FREETYPE_LIBRARY AND EXISTS "${3RDPARTY_FREETYPE_LIBRARY}")
       get_filename_component (3RDPARTY_FREETYPE_LIBRARY_DIR "${3RDPARTY_FREETYPE_LIBRARY}" PATH)
       set (3RDPARTY_FREETYPE_LIBRARY_DIR "${3RDPARTY_FREETYPE_LIBRARY_DIR}" CACHE PATH "The directory containing freetype library" FORCE)
@@ -350,7 +371,7 @@ endif()
 # unset all redundant variables
 OCCT_CHECK_AND_UNSET(FREETYPE_INCLUDE_DIR_ft2build)
 OCCT_CHECK_AND_UNSET(FREETYPE_INCLUDE_DIR_freetype2)
-OCCT_CHECK_AND_UNSET(FREETYPE_LIBRARY)
+OCCT_CHECK_AND_UNSET(FREETYPE_LIBRARY_RELEASE)
 
 if (BUILD_SHARED_LIBS)
   mark_as_advanced (3RDPARTY_FREETYPE_LIBRARY 3RDPARTY_FREETYPE_DLL)

adm/cmake/occt_defs_flags.cmake

@@ -116,9 +116,9 @@ if (MSVC)
   else()
     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
   endif()
-elseif (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+elseif (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "[Cc][Ll][Aa][Nn][Gg]"))
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
-  if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  if (CMAKE_CXX_COMPILER_ID MATCHES "[Cc][Ll][Aa][Nn][Gg]")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshorten-64-to-32")
   endif()
   if (BUILD_SHARED_LIBS)
@@ -130,14 +130,10 @@ elseif (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMP
   endif()
 endif()
 
-if ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang")
+if (CMAKE_CXX_COMPILER_ID MATCHES "[Cc][Ll][Aa][Nn][Gg]")
   if (APPLE)
     # CLang can be used with both libstdc++ and libc++, however on OS X libstdc++ is outdated.
-    set (CMAKE_CXX_FLAGS "-std=c++0x -stdlib=libc++ ${CMAKE_CXX_FLAGS}")
-  elseif(NOT WIN32)
-    # CLang for Windows (at least CLang 8.0 distributed with VS 2019)
-    # does not support option "-std=c++0x"
-    set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
+    set (CMAKE_CXX_FLAGS "-stdlib=libc++ ${CMAKE_CXX_FLAGS}")
   endif()
   # Optimize size of binaries
   set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
@@ -148,14 +144,10 @@ elseif(MINGW)
   # workaround bugs in mingw with vtable export
   set (CMAKE_SHARED_LINKER_FLAGS "-Wl,--export-all-symbols")
 
-  # Require C++11
-  set (CMAKE_CXX_FLAGS "-std=gnu++0x ${CMAKE_CXX_FLAGS}")
   # Optimize size of binaries
   set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s")
   set (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s")
 elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX)
-  # Require C++11
-  set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
   # Optimize size of binaries
   set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s")
   set (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s")

adm/cmake/occt_macros.cmake

@@ -80,9 +80,9 @@ macro (OCCT_MAKE_COMPILER_SHORT_NAME)
     set (COMPILER gcc)
   elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX)
     set (COMPILER gxx)
-  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  elseif (CMAKE_CXX_COMPILER_ID MATCHES "[Cc][Ll][Aa][Nn][Gg]")
     set (COMPILER clang)
-  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+  elseif (CMAKE_CXX_COMPILER_ID MATCHES "[Ii][Nn][Tt][Ee][Ll]")
     set (COMPILER icc)
   else()
     set (COMPILER ${CMAKE_GENERATOR})
@@ -160,6 +160,8 @@ function (FIND_PRODUCT_DIR ROOT_DIR PRODUCT_NAME RESULT)
   if ("${lower_PRODUCT_NAME}" STREQUAL "egl")
     string (SUBSTRING "${lower_PRODUCT_NAME}" 1 -1 lower_PRODUCT_NAME)
     list (APPEND SEARCH_TEMPLATES "[^gl]+${lower_PRODUCT_NAME}.*")
+  elseif ("${lower_PRODUCT_NAME}" STREQUAL "tbb")
+    list (APPEND SEARCH_TEMPLATES "^.*${lower_PRODUCT_NAME}.*")
   else()
     list (APPEND SEARCH_TEMPLATES "^[^a-zA-Z]*${lower_PRODUCT_NAME}[^a-zA-Z]*${COMPILER}.*${COMPILER_BITNESS}")
     list (APPEND SEARCH_TEMPLATES "^[^a-zA-Z]*${lower_PRODUCT_NAME}[^a-zA-Z]*[0-9.]+.*${COMPILER}.*${COMPILER_BITNESS}")
@@ -589,9 +591,7 @@ macro (OCCT_UPDATE_TARGET_FILE)
   endif()
 
   install (CODE
-  "cmake_policy(PUSH)
-  cmake_policy(SET CMP0007 NEW)
-  string (TOLOWER \"\${CMAKE_INSTALL_CONFIG_NAME}\" CMAKE_INSTALL_CONFIG_NAME_LOWERCASE)
+  "string (TOLOWER \"\${CMAKE_INSTALL_CONFIG_NAME}\" CMAKE_INSTALL_CONFIG_NAME_LOWERCASE)
   file (GLOB ALL_OCCT_TARGET_FILES \"${INSTALL_DIR}/${INSTALL_DIR_CMAKE}/OpenCASCADE*Targets-\${CMAKE_INSTALL_CONFIG_NAME_LOWERCASE}.cmake\")
   foreach(TARGET_FILENAME \${ALL_OCCT_TARGET_FILES})
     file (STRINGS \"\${TARGET_FILENAME}\" TARGET_FILE_CONTENT)
@@ -600,8 +600,7 @@ macro (OCCT_UPDATE_TARGET_FILE)
       string (REGEX REPLACE \"[\\\\]?[\\\$]{OCCT_INSTALL_BIN_LETTER}\" \"\${OCCT_INSTALL_BIN_LETTER}\" line \"\${line}\")
       file (APPEND \"\${TARGET_FILENAME}\" \"\${line}\\n\")
     endforeach()
-  endforeach()
-  cmake_policy(POP)")
+  endforeach()")
 endmacro()
 
 macro (OCCT_INSERT_CODE_FOR_TARGET)
@@ -615,17 +614,14 @@ macro (OCCT_INSERT_CODE_FOR_TARGET)
 endmacro()
 
 macro (OCCT_UPDATE_DRAW_DEFAULT_FILE)
-  install(CODE "cmake_policy(PUSH)
-  cmake_policy(SET CMP0007 NEW)
-  set (DRAW_DEFAULT_FILE_NAME \"${INSTALL_DIR}/${INSTALL_DIR_RESOURCE}/DrawResources/DrawPlugin\")
+  install(CODE "set (DRAW_DEFAULT_FILE_NAME \"${INSTALL_DIR}/${INSTALL_DIR_RESOURCE}/DrawResources/DrawPlugin\")
   file (STRINGS \"\${DRAW_DEFAULT_FILE_NAME}\" DRAW_DEFAULT_CONTENT)
   file (REMOVE \"\${DRAW_DEFAULT_FILE_NAME}\")
   foreach (line IN LISTS DRAW_DEFAULT_CONTENT)
     string (REGEX MATCH \": TK\([a-zA-Z]+\)$\" IS_TK_LINE \"\${line}\")
     string (REGEX REPLACE \": TK\([a-zA-Z]+\)$\" \": TK\${CMAKE_MATCH_1}${BUILD_SHARED_LIBRARY_NAME_POSTFIX}\" line \"\${line}\")
     file (APPEND \"\${DRAW_DEFAULT_FILE_NAME}\" \"\${line}\\n\")
-  endforeach()
-  cmake_policy(POP)")
+  endforeach()")
 endmacro()
 
 macro (OCCT_CREATE_SYMLINK_TO_FILE LIBRARY_NAME LINK_NAME)

adm/cmake/occt_toolkit.cmake

@@ -106,6 +106,12 @@ foreach (OCCT_PACKAGE ${USED_PACKAGES})
               set (BISON_OUTPUT_FILE_EXT "cxx")
             endif()
           endforeach()
+
+          if (EXISTS ${FLEX_BISON_TARGET_DIR}/FlexLexer.h)
+            message (STATUS "Info: remove old FLEX header file: ${FLEX_BISON_TARGET_DIR}/FlexLexer.h")
+            file(REMOVE ${FLEX_BISON_TARGET_DIR}/FlexLexer.h)
+          endif()
+
           file (STRINGS "${CURRENT_FLEX_FILE}" FILE_FLEX_CONTENT)
           foreach (FILE_FLEX_CONTENT_LINE ${FILE_FLEX_CONTENT})
             string (REGEX MATCH "%option c\\+\\+" CXX_FLEX_LANGUAGE_FOUND ${FILE_FLEX_CONTENT_LINE})
@@ -121,6 +127,19 @@ foreach (OCCT_PACKAGE ${USED_PACKAGES})
           set (BISON_OUTPUT_FILE ${CURRENT_BISON_FILE_NAME}.tab.${BISON_OUTPUT_FILE_EXT})
           set (FLEX_OUTPUT_FILE lex.${CURRENT_FLEX_FILE_NAME}.${FLEX_OUTPUT_FILE_EXT})
 
+          if (EXISTS ${FLEX_BISON_TARGET_DIR}/${CURRENT_BISON_FILE_NAME}.tab.${BISON_OUTPUT_FILE_EXT})
+            message (STATUS "Info: remove old output BISON file: ${FLEX_BISON_TARGET_DIR}/${CURRENT_BISON_FILE_NAME}.tab.${BISON_OUTPUT_FILE_EXT}")
+            file(REMOVE ${FLEX_BISON_TARGET_DIR}/${CURRENT_BISON_FILE_NAME}.tab.${BISON_OUTPUT_FILE_EXT})
+          endif()
+          if (EXISTS ${FLEX_BISON_TARGET_DIR}/${CURRENT_BISON_FILE_NAME}.tab.hxx)
+            message (STATUS "Info: remove old output BISON file: ${FLEX_BISON_TARGET_DIR}/${CURRENT_BISON_FILE_NAME}.tab.hxx")
+            file(REMOVE ${FLEX_BISON_TARGET_DIR}/${CURRENT_BISON_FILE_NAME}.tab.hxx)
+          endif()
+          if (EXISTS ${FLEX_BISON_TARGET_DIR}/${FLEX_OUTPUT_FILE})
+            message (STATUS "Info: remove old output FLEX file: ${FLEX_BISON_TARGET_DIR}/${FLEX_OUTPUT_FILE}")
+            file(REMOVE ${FLEX_BISON_TARGET_DIR}/${FLEX_OUTPUT_FILE})
+          endif()
+
           BISON_TARGET (Parser_${CURRENT_BISON_FILE_NAME} ${CURRENT_BISON_FILE} "${FLEX_BISON_TARGET_DIR}/${BISON_OUTPUT_FILE}"
                         COMPILE_FLAGS "-p ${CURRENT_BISON_FILE_NAME} -l -M ${CMAKE_SOURCE_DIR}/${RELATIVE_SOURCES_DIR}/=")
           FLEX_TARGET  (Scanner_${CURRENT_FLEX_FILE_NAME} ${CURRENT_FLEX_FILE} "${FLEX_BISON_TARGET_DIR}/${FLEX_OUTPUT_FILE}"
@@ -226,6 +245,18 @@ endif (USE_QT)
 if (EXECUTABLE_PROJECT)
   add_executable (${PROJECT_NAME} ${USED_SRCFILES} ${USED_INCFILES} ${USED_RCFILE} ${RESOURCE_FILES} ${${PROJECT_NAME}_MOC_FILES})
 
+  if (DEFINED ${PROJECT_NAME}_DISABLE_COTIRE AND ${PROJECT_NAME}_DISABLE_COTIRE)
+    set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_ENABLE_PRECOMPILED_HEADER FALSE)
+    set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
+  else()
+    # To avoid excluding of PROJECT_NAME from cotire tool, we may use cotire
+    # COTIRE_PREFIX_HEADER_IGNORE_PATH instead. But, practically it causes many 'undefined symbols' error.
+    # So, we just exclude PROJECT_NAME from cotire list.
+    # if (DEFINED ${PROJECT_NAME}_COTIRE_IGNORE_PATH)
+    #   set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_PREFIX_HEADER_IGNORE_PATH "${${PROJECT_NAME}_COTIRE_IGNORE_PATH}")
+    # endif()
+  endif()
+
   install (TARGETS ${PROJECT_NAME}
            DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
 
@@ -235,6 +266,18 @@ if (EXECUTABLE_PROJECT)
 else()
   add_library (${PROJECT_NAME} ${USED_SRCFILES} ${USED_INCFILES} ${USED_RCFILE} ${RESOURCE_FILES} ${${PROJECT_NAME}_MOC_FILES})
 
+  if (DEFINED ${PROJECT_NAME}_DISABLE_COTIRE AND ${PROJECT_NAME}_DISABLE_COTIRE)
+    set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_ENABLE_PRECOMPILED_HEADER FALSE)
+    set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
+  else()
+    # To avoid excluding of PROJECT_NAME from cotire tool, we may use cotire
+    # COTIRE_PREFIX_HEADER_IGNORE_PATH instead. But, practically it causes many 'undefined symbols' error.
+    # So, we just exclude PROJECT_NAME from cotire list.
+    # if (DEFINED ${PROJECT_NAME}_COTIRE_IGNORE_PATH)
+    #   set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_PREFIX_HEADER_IGNORE_PATH "${${PROJECT_NAME}_COTIRE_IGNORE_PATH}")
+    # endif()
+  endif()
+
   if (MSVC)
     if (BUILD_FORCE_RelWithDebInfo)
       set (aReleasePdbConf "Release")
@@ -320,10 +363,10 @@ foreach (USED_ITEM ${USED_EXTERNLIB_AND_TOOLKITS})
       else() # get CSF_ value
         set (CURRENT_CSF ${${USED_ITEM}})
         if (NOT "x${CURRENT_CSF}" STREQUAL "x")
-          if ("${CURRENT_CSF}" STREQUAL "CSF_OpenGlLibs")
+          if ("${CURRENT_CSF}" STREQUAL "${CSF_OpenGlLibs}")
             add_definitions (-DHAVE_OPENGL)
           endif()
-          if ("${CURRENT_CSF}" STREQUAL "CSF_OpenGlesLibs")
+          if ("${CURRENT_CSF}" STREQUAL "${CSF_OpenGlesLibs}")
             add_definitions (-DHAVE_GLES2)
           endif()
 

adm/cmake/tbb.cmake

@@ -1,294 +1,240 @@
 # tbb
 
-if (NOT DEFINED INSTALL_TBB AND BUILD_SHARED_LIBS)
-  set (INSTALL_TBB OFF CACHE BOOL "${INSTALL_TBB_DESCR}")
-endif()
-
-# tbb directory
-if (NOT DEFINED 3RDPARTY_TBB_DIR)
-  set (3RDPARTY_TBB_DIR "" CACHE PATH "The directory containing tbb")
-endif()
-
 if (MSVC AND BUILD_SHARED_LIBS)
   add_definitions (-D__TBB_NO_IMPLICIT_LINKAGE)
   add_definitions (-D__TBBMALLOC_NO_IMPLICIT_LINKAGE)
 endif()
 
-# include occt macros. compiler_bitness, os_wiht_bit, compiler
-OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_macros")
+if (NOT DEFINED INSTALL_TBB AND BUILD_SHARED_LIBS)
+  set (INSTALL_TBB OFF CACHE BOOL "${INSTALL_TBB_DESCR}")
+endif()
 
-# specify TBB folder in connectin with 3RDPARTY_DIR
-if (3RDPARTY_DIR AND EXISTS "${3RDPARTY_DIR}")
-  #CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_DIR 3RDPARTY_TBB_DIR PATH "The directory containing tbb")
+# Initialize tbb directory.
+if (NOT DEFINED 3RDPARTY_TBB_DIR)
+  set (3RDPARTY_TBB_DIR "" CACHE PATH "The directory containing tbb")
+endif()
 
-  if (NOT 3RDPARTY_TBB_DIR OR NOT EXISTS "${3RDPARTY_TBB_DIR}")
+if (WIN32)
+  if (NOT DEFINED 3RDPARTY_DIR)
+    message (FATAL_ERROR "3RDPARTY_DIR is not defined.")
+  endif()
+  if ("${3RDPARTY_DIR}" STREQUAL "")
+    message (FATAL_ERROR "3RDPARTY_DIR is empty string.")
+  endif()
+  if (NOT EXISTS "${3RDPARTY_DIR}")
+    message (FATAL_ERROR "3RDPARTY_DIR is not exist.")
+  endif()
+
+  # Below, we have correct 3RDPARTY_DIR.
+
+  # Initialize TBB folder in connectin with 3RDPARTY_DIR.
+  if (("${3RDPARTY_TBB_DIR}" STREQUAL "") OR (NOT EXISTS "${3RDPARTY_TBB_DIR}"))
     FIND_PRODUCT_DIR ("${3RDPARTY_DIR}" TBB TBB_DIR_NAME)
     if (TBB_DIR_NAME)
       set (3RDPARTY_TBB_DIR "${3RDPARTY_DIR}/${TBB_DIR_NAME}" CACHE PATH "The directory containing tbb" FORCE)
     endif()
   endif()
-else()
-  #set (3RDPARTY_TBB_DIR "" CACHE PATH "The directory containing TBB" FORCE)
-endif()
 
+  # Here we have full path name to installation directory of TBB.
+  # Employ it.
+  if (EXISTS "${3RDPARTY_TBB_DIR}")
+    find_package (
+      TBB 2021.5
+      PATHS "${3RDPARTY_TBB_DIR}" NO_DEFAULT_PATH
+      REQUIRED
+      CONFIG)
+
+    # Achive include directory
+    get_target_property (TBB_INCLUDE_DIR TBB::tbb INTERFACE_INCLUDE_DIRECTORIES)
     if (NOT DEFINED 3RDPARTY_TBB_INCLUDE_DIR)
       set (3RDPARTY_TBB_INCLUDE_DIR "" CACHE PATH "The directory containing headers of the TBB")
     endif()
-
-if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-    # check 3RDPARTY_TBB_INCLUDE_DIR for consictency with specified 3RDPARTY_TBB_DIR
-    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_TBB_INCLUDE_DIR PATH "The directory containing headers of the TBB")
-endif()
-
-# tbb.h
-if (NOT 3RDPARTY_TBB_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_TBB_INCLUDE_DIR}")
-
-  set (HEADER_NAMES tbb.h tbb/tbb.h)
-
-  # set 3RDPARTY_TBB_INCLUDE_DIR as notfound, otherwise find_library can't assign a new value to 3RDPARTY_TBB_INCLUDE_DIR
-  set (3RDPARTY_TBB_INCLUDE_DIR "3RDPARTY_TBB_INCLUDE_DIR-NOTFOUND" CACHE PATH "the path to tbb.h" FORCE)
-
-  if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-    find_path (3RDPARTY_TBB_INCLUDE_DIR NAMES ${HEADER_NAMES}
-                                              PATHS ${3RDPARTY_TBB_DIR}
-                                              PATH_SUFFIXES include
-                                              CMAKE_FIND_ROOT_PATH_BOTH
-                                              NO_DEFAULT_PATH)
-  else()
-    find_path (3RDPARTY_TBB_INCLUDE_DIR NAMES ${HEADER_NAMES}
-                                              PATH_SUFFIXES include
-                                              CMAKE_FIND_ROOT_PATH_BOTH)
-  endif()
-endif()
-
-if (3RDPARTY_TBB_INCLUDE_DIR AND EXISTS "${3RDPARTY_TBB_INCLUDE_DIR}")
+    if (EXISTS "${TBB_INCLUDE_DIR}")
+      set (3RDPARTY_TBB_INCLUDE_DIR "${TBB_INCLUDE_DIR}" CACHE PATH "The directory containing headers of the TBB" FORCE)
       list (APPEND 3RDPARTY_INCLUDE_DIRS "${3RDPARTY_TBB_INCLUDE_DIR}")
     else()
       list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_TBB_INCLUDE_DIR)
-
-  set (3RDPARTY_TBB_INCLUDE_DIR "" CACHE PATH "the path to tbb.h" FORCE)
     endif()
 
-# common steps for tbb and tbbmalloc
-macro (TBB_PRODUCT_SEARCH PRODUCT_LIBRARY_NAME)
+    separate_arguments (CSF_TBB)
+    foreach (LIB IN LISTS CSF_TBB)
+      string(TOLOWER "${LIB}" LIB_LOWER)
+      string(TOUPPER "${LIB}" LIB_UPPER)
 
-  string (TOUPPER ${PRODUCT_LIBRARY_NAME} upper_PRODUCT_LIBRARY_NAME)
-
-  # define required tbb/tbbmalloc variables
-  if (NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY OR NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}")
-    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY "" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
+      # Achive *.lib files and directory containing it.
+      get_target_property (TBB_LIB_FILE "TBB::${LIB_LOWER}" IMPORTED_IMPLIB_RELEASE)
+      # Reserve cache variable for *.lib.
+      if (NOT DEFINED 3RDPARTY_${LIB_UPPER}_LIBRARY)
+        set (3RDPARTY_${LIB_UPPER}_LIBRARY "" CACHE FILEPATH "${LIB_UPPER} library (*.lib)")
       endif()
-
-  if (NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR)
-    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library")
+      # Reserve cache variable for directory containing *.lib file.
+      if (NOT DEFINED 3RDPARTY_${LIB_UPPER}_LIBRARY_DIR)
+        set (3RDPARTY_${LIB_UPPER}_LIBRARY_DIR "" CACHE PATH "The directory containing ${LIB_UPPER} library (*.lib)")
       endif()
-
-  if (WIN32)
-    if (NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL OR NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}")
-      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL "" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
-    endif()
-  endif()
-
-  if (WIN32 AND NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR)
-    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library")
-  endif()
-
-  # check 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_ paths for consistency with specified 3RDPARTY_TBB_DIR
-  if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY FILEPATH "the path to ${upper_PRODUCT_LIBRARY_NAME} library")
-
-    if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}")
-      get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}" PATH)
-      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
+      if (EXISTS "${TBB_LIB_FILE}")
+        set (3RDPARTY_${LIB_UPPER}_LIBRARY
+             "${TBB_LIB_FILE}"
+             CACHE FILEPATH
+             "${LIB_UPPER} library (*.lib)"
+             FORCE)
+        get_filename_component (TBB_LIB_FILE_DIRECTORY "${TBB_LIB_FILE}" DIRECTORY)
+        set (3RDPARTY_${LIB_UPPER}_LIBRARY_DIR
+             "${TBB_LIB_FILE_DIRECTORY}"
+             CACHE PATH
+             "The directory containing ${LIB_UPPER} library (*.lib)"
+             FORCE)
+        list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${LIB_UPPER}_LIBRARY_DIR}")
       else()
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library")
+        list (APPEND 3RDPARTY_NO_LIBS 3RDPARTY_${LIB_UPPER}_LIBRARY_DIR)
       endif()
 
-    if (WIN32)
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL FILEPATH "the path to ${upper_PRODUCT_LIBRARY_NAME} shared library")
-
-      if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}")
-        get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}" PATH)
-        set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
+      # Achive *.dll files and directory containing it.
+      get_target_property (TBB_DLL_FILE "TBB::${LIB_LOWER}" IMPORTED_LOCATION_RELEASE)
+      # Reserve cache variable for *.dll.
+      if (NOT DEFINED 3RDPARTY_${LIB_UPPER}_DLL)
+        set (3RDPARTY_${LIB_UPPER}_DLL "" CACHE FILEPATH "${LIB_UPPER} library (*.dll)")
+      endif()
+      # Reserve cache variable for directory containing *.dll file.
+      if (NOT DEFINED 3RDPARTY_${LIB_UPPER}_DLL_DIR)
+        set (3RDPARTY_${LIB_UPPER}_DLL_DIR "" CACHE PATH "The directory containing ${LIB_UPPER} library (*.dll)")
+      endif()
+      if (EXISTS "${TBB_DLL_FILE}")
+        set (3RDPARTY_${LIB_UPPER}_DLL
+             "${TBB_DLL_FILE}"
+             CACHE FILEPATH
+             "${LIB_UPPER} library (*.dll)"
+             FORCE)
+        get_filename_component (TBB_DLL_FILE_DIRECTORY "${TBB_DLL_FILE}" DIRECTORY)
+        set (3RDPARTY_${LIB_UPPER}_DLL_DIR
+             "${TBB_DLL_FILE_DIRECTORY}"
+             CACHE PATH
+             "The directory containing ${LIB_UPPER} library (*.dll)"
+             FORCE)
+        list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_${LIB_UPPER}_DLL_DIR}")
       else()
-
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library")
-      endif()
-    endif()
+        list (APPEND 3RDPARTY_NO_DLLS 3RDPARTY_${LIB_UPPER}_DLL_DIR)
       endif()
 
-  OCCT_MAKE_COMPILER_SHORT_NAME()
-  OCCT_MAKE_COMPILER_BITNESS()
-
-  if (${COMPILER_BITNESS} EQUAL 32)
-    set (${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME ia32)
-  else()
-    set (${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME intel64)
-  endif()
-
-  # tbb/tbbmalloc library
-  if (NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}")
-    
-    set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
-    set (PRODUCT_PATH_SUFFIXES lib ${PRODUCT_LIBRARY_NAME})
-
-    # set 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY
-    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY "3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
-
-    if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-      if (NOT EXISTS "${3RDPARTY_TBB_DIR}/lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER}")
-        if (EXISTS "${3RDPARTY_TBB_DIR}/lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}")
-          file (GLOB ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST "${3RDPARTY_TBB_DIR}/lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/*")
-          if (${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST)
-            list (GET ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST -1 THE_MOST_FRESH_COMPILER_VERSION)
-            if (THE_MOST_FRESH_COMPILER_VERSION)
-              get_filename_component (THE_MOST_FRESH_COMPILER_VERSION_NAME "${THE_MOST_FRESH_COMPILER_VERSION}" NAME)
-              set (PRODUCT_PATH_SUFFIXES lib ${PRODUCT_LIBRARY_NAME} lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${THE_MOST_FRESH_COMPILER_VERSION_NAME})
-            endif()
-          endif()
-        endif()
-      else()
-        set (PRODUCT_PATH_SUFFIXES lib ${PRODUCT_LIBRARY_NAME} lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER})
-      endif()
-
-      find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY ${PRODUCT_LIBRARY_NAME}
-                                         PATHS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}" "${3RDPARTY_TBB_DIR}"
-                                         PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES}
-                                         CMAKE_FIND_ROOT_PATH_BOTH
-                                         NO_DEFAULT_PATH)
-    else()
-      find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY ${PRODUCT_LIBRARY_NAME}
-                                         PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES}
-                                         CMAKE_FIND_ROOT_PATH_BOTH)
-    endif()
-
-    if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}")
-      get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}" PATH)
-      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
-    else()
-      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
-    endif()
-  endif()
-
-  if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}")
-    list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}")
-  else()
-    list (APPEND 3RDPARTY_NO_LIBS 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR)
-
-    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY "" CACHE FILEPATH "The path to ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
-  endif()
-
-  # tbb/tbbmalloc shared library
-  if (WIN32)
-    if (NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}")
-      set (CMAKE_FIND_LIBRARY_SUFFIXES .dll)
-      set (PRODUCT_PATH_SUFFIXES bin)
-
-      # set 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL
-      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL "3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL-NOTFOUND" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
-
-      if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-        if (NOT EXISTS "${3RDPARTY_TBB_DIR}/bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER}")
-          if (EXISTS "${3RDPARTY_TBB_DIR}/bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}")
-            file (GLOB ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST "${3RDPARTY_TBB_DIR}/bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/*")
-            if (${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST)
-              list (GET ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST -1 THE_MOST_FRESH_COMPILER_VERSION)
-              if (THE_MOST_FRESH_COMPILER_VERSION)
-                get_filename_component (THE_MOST_FRESH_COMPILER_VERSION_NAME "${THE_MOST_FRESH_COMPILER_VERSION}" NAME)
-                set (PRODUCT_PATH_SUFFIXES bin bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${THE_MOST_FRESH_COMPILER_VERSION_NAME})
-              endif()
-            endif()
-          endif()
-        else()
-          set (PRODUCT_PATH_SUFFIXES bin bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER})
-        endif()
-
-        if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-          find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL ${PRODUCT_LIBRARY_NAME}
-                                         PATHS "${3RDPARTY_TBB_DIR}"
-                                         PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES}
-                                         NO_DEFAULT_PATH)
-        else()
-          find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL ${PRODUCT_LIBRARY_NAME} PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES})
-        endif()
-
-        if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}")
-          get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}" PATH)
-          set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
-        else()
-          set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
-
-          set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL "" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
-        endif()
-      endif()
-    endif()
-
-    if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR OR EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}")
-      list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}")
-    else()
-      list (APPEND 3RDPARTY_NO_DLLS 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR)
-    endif()
-  endif()
-
-  # install tbb/tbbmalloc
+      # install *.dll (tbb & tbbmalloc)
       if (INSTALL_TBB)
         OCCT_MAKE_OS_WITH_BITNESS()
         OCCT_MAKE_COMPILER_SHORT_NAME()
 
-    if (WIN32)
         if (SINGLE_GENERATOR)
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL} DESTINATION "${INSTALL_DIR_BIN}")
+          install (FILES ${3RDPARTY_${LIB_UPPER}_DLL} DESTINATION "${INSTALL_DIR_BIN}")
         else()
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}
-                 CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR_BIN}")
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}
-                 CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR_BIN}i")
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}
-                 CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR_BIN}d")
-      endif()
-    else()
-      get_filename_component (PRODUCT_LIBRARY_NAME ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY} NAME)
-
-      if (SINGLE_GENERATOR)
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
-                 DESTINATION "${INSTALL_DIR_LIB}"
-                 RENAME ${PRODUCT_LIBRARY_NAME}.2)
-      else()
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
-                 CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR_LIB}"
-                 RENAME ${PRODUCT_LIBRARY_NAME}.2)
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
-                 CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR_LIB}i"
-                 RENAME ${PRODUCT_LIBRARY_NAME}.2)
-        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
-                 CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR_LIB}d"
-                 RENAME ${PRODUCT_LIBRARY_NAME}.2)
+          install (FILES ${3RDPARTY_${LIB_UPPER}_DLL} CONFIGURATIONS Release DESTINATION "${INSTALL_DIR_BIN}")
+          install (FILES ${3RDPARTY_${LIB_UPPER}_DLL} CONFIGURATIONS RelWithDebInfo DESTINATION "${INSTALL_DIR_BIN}i")
+          install (FILES ${3RDPARTY_${LIB_UPPER}_DLL} CONFIGURATIONS Debug DESTINATION "${INSTALL_DIR_BIN}d")
         endif()
       endif()
-  endif()
-  mark_as_advanced (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL)
-endmacro()
-
-#if (BUILD_SHARED_LIBS)
-  separate_arguments (CSF_TBB)
-  foreach (LIB IN LISTS CSF_TBB)
-    TBB_PRODUCT_SEARCH (${LIB})
+      mark_as_advanced (3RDPARTY_${LIB_UPPER}_LIBRARY 3RDPARTY_${LIB_UPPER}_DLL)
     endforeach()
-
     if (INSTALL_TBB)
       set (USED_3RDPARTY_TBB_DIR "")
     else()
-    # the library directory for using by the executable
-    if (WIN32)
+      # the *.dll/*.so* directory for using by the executable
       set (USED_3RDPARTY_TBB_DIR ${3RDPARTY_TBB_DLL_DIR})
+    endif()
   else()
+    message (FATAL_ERROR "Installation directory with TBB is not exist.")
+  endif()
+else ()
+  # NOT WIN32 branch
+  if ((DEFINED 3RDPARTY_DIR) AND (NOT "${3RDPARTY_DIR}" STREQUAL "") AND (EXISTS "${3RDPARTY_DIR}"))
+    # Here, we have correct 3RDPARTY_DIR.
+    # Trying to specify TBB folder in connection with 3RDPARTY_DIR
+    if (("${3RDPARTY_TBB_DIR}" STREQUAL "") OR (NOT EXISTS "${3RDPARTY_TBB_DIR}"))
+      FIND_PRODUCT_DIR ("${3RDPARTY_DIR}" TBB TBB_DIR_NAME)
+      if (TBB_DIR_NAME)
+        set (3RDPARTY_TBB_DIR "${3RDPARTY_DIR}/${TBB_DIR_NAME}" CACHE PATH "The directory containing tbb" FORCE)
+      endif()
+    endif()
+    if ((NOT "${3RDPARTY_TBB_DIR}" STREQUAL "") AND (EXISTS "${3RDPARTY_TBB_DIR}"))
+      # Find TBB 2021.5 in existing directory.
+      find_package (
+      TBB 2021.5
+      PATHS "${3RDPARTY_TBB_DIR}" NO_DEFAULT_PATH
+      REQUIRED
+      CONFIG)
+    else()
+      # Find TBB 2021.5 in system directory.
+      find_package (
+      TBB 2021.5
+      REQUIRED
+      CONFIG)
+    endif()
+  else()
+    # Find TBB 2021.5 in system directory.
+    find_package (
+    TBB 2021.5
+    REQUIRED
+    CONFIG)
+  endif()
+  # TBB has been configured (in other case FATAL_ERROR occures).
+
+  # Achive include directory.
+  get_target_property (TBB_INCLUDE_DIR TBB::tbb INTERFACE_INCLUDE_DIRECTORIES)
+  if (NOT DEFINED 3RDPARTY_TBB_INCLUDE_DIR)
+    set (3RDPARTY_TBB_INCLUDE_DIR "" CACHE PATH "The directory containing headers of the TBB")
+  endif()
+  if (EXISTS "${TBB_INCLUDE_DIR}")
+    set (3RDPARTY_TBB_INCLUDE_DIR "${TBB_INCLUDE_DIR}" CACHE PATH "The directory containing headers of the TBB" FORCE)
+    list (APPEND 3RDPARTY_INCLUDE_DIRS "${3RDPARTY_TBB_INCLUDE_DIR}")
+  else()
+    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_TBB_INCLUDE_DIR)
+  endif()
+
+  separate_arguments (CSF_TBB)
+  foreach (LIB IN LISTS CSF_TBB)
+    string(TOLOWER "${LIB}" LIB_LOWER)
+    string(TOUPPER "${LIB}" LIB_UPPER)
+
+    # Achive *.so files and directory containing it.
+    get_target_property (TBB_SO_FILE "TBB::${LIB_LOWER}" IMPORTED_LOCATION_RELEASE)
+    # Reserve cache variable for *.so.
+    if (NOT DEFINED 3RDPARTY_${LIB_UPPER}_LIBRARY)
+      set (3RDPARTY_${LIB_UPPER}_LIBRARY "" CACHE FILEPATH "${LIB_UPPER} library (*.so)")
+    endif()
+    # Reserve cache variable for directory containing *.so file.
+    if (NOT DEFINED 3RDPARTY_${LIB_UPPER}_LIBRARY_DIR)
+      set (3RDPARTY_${LIB_UPPER}_LIBRARY_DIR "" CACHE PATH "The directory containing ${LIB_UPPER} library (*.so)")
+    endif()
+    if (EXISTS "${TBB_SO_FILE}")
+      set (3RDPARTY_${LIB_UPPER}_LIBRARY
+           "${TBB_SO_FILE}"
+           CACHE FILEPATH
+           "${LIB_UPPER} library (*.so)"
+           FORCE)
+      get_filename_component (TBB_SO_FILE_DIRECTORY "${TBB_SO_FILE}" DIRECTORY)
+      set (3RDPARTY_${LIB_UPPER}_LIBRARY_DIR
+           "${TBB_SO_FILE_DIRECTORY}"
+           CACHE PATH
+           "The directory containing ${LIB_UPPER} library (*.so)"
+           FORCE)
+      list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${LIB_UPPER}_LIBRARY_DIR}")
+    else()
+      list (APPEND 3RDPARTY_NO_LIBS 3RDPARTY_${LIB_UPPER}_LIBRARY_DIR)
+    endif()
+
+    # install *.so* (tbb & tbbmalloc)
+    if (INSTALL_TBB)
+      OCCT_MAKE_OS_WITH_BITNESS()
+      OCCT_MAKE_COMPILER_SHORT_NAME()
+
+      if (SINGLE_GENERATOR)
+        install (FILES ${3RDPARTY_${LIB_UPPER}_LIBRARY} DESTINATION "${INSTALL_DIR_LIB}")
+      else()
+        install (FILES ${3RDPARTY_${LIB_UPPER}_LIBRARY} CONFIGURATIONS Release DESTINATION "${INSTALL_DIR_LIB}")
+        install (FILES ${3RDPARTY_${LIB_UPPER}_LIBRARY} CONFIGURATIONS RelWithDebInfo DESTINATION "${INSTALL_DIR_LIB}i")
+        install (FILES ${3RDPARTY_${LIB_UPPER}_LIBRARY} CONFIGURATIONS Debug DESTINATION "${INSTALL_DIR_LIB}d")
+      endif()
+    endif()
+  endforeach()
+  if (INSTALL_TBB)
+    set (USED_3RDPARTY_TBB_DIR "")
+  else()
+    # the *.so* directory for using by the executable
     set (USED_3RDPARTY_TBB_DIR ${3RDPARTY_TBB_LIBRARY_DIR})
   endif()
 endif()
-#endif()

adm/genconfdeps.tcl

@@ -780,14 +780,14 @@ proc wokdep:SearchTBB {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64
       }
     }
     if { "$::tcl_platform(platform)" == "windows" } {
-      set aTbbDllPath [wokdep:SearchBin "tbb.dll" "$anArchIter"]
+      set aTbbDllPath [wokdep:SearchBin "tbb12.dll" "$anArchIter"]
       if { "$aTbbDllPath" == "" } {
         set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tbb}*] $aVcLib "$anArchIter" ]
-        set aTbbDllPath [wokdep:SearchBin "tbb.dll" "$anArchIter" "$aPath/bin/$aSubDir/$aVcLib"]
+        set aTbbDllPath [wokdep:SearchBin "tbb12.dll" "$anArchIter" "$aPath/bin/$aSubDir/$aVcLib"]
         if { "$aTbbDllPath" != "" } {
           lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin/$aSubDir/$aVcLib"
         } else {
-          lappend anErrBin$anArchIter "Error: 'tbb.dll' not found (Intel TBB)"
+          lappend anErrBin$anArchIter "Error: 'tbb12.dll' not found (Intel TBB)"
           if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
         }
       }

adm/genproj.tcl

@@ -1233,28 +1233,11 @@ proc osutils:convertModules { theModules theSrcDir theSourceDirOther theProjects
       lappend aProjectsInModule($aModule) $aToolKit
       lappend aDependencies [LibToLink $aToolKit $theSrcDir $theSourceDirOther]
     }
-    # executables, assume one project per cxx file...
+    # executables
     foreach aUnit [OS:executable ${aModule}] {
-      set aUnitLoc $aUnit
-      set src_files [_get_used_files $aUnit $theSrcDir false]
-      set aSrcFiles {}
-      foreach s $src_files {
-        regexp {source ([^\s]+)} $s dummy name
-        lappend aSrcFiles $name
-      }
-      foreach aSrcFile $aSrcFiles {
-        set aFileExtension [file extension $aSrcFile]
-        if { $aFileExtension == ".cxx" } {
-          set aPrjName [file rootname $aSrcFile]
-          lappend aProjects $aPrjName
-          lappend aProjectsInModule($aModule) $aPrjName
-          if {[file isdirectory $path/$theSrcDir/$aUnitLoc]} {
-            lappend aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile] $theSrcDir $theSourceDirOther]
-          } else {
-            lappend aDependencies {}
-          }
-        }
-      }
+      lappend aProjects $aUnit
+      lappend aProjectsInModule($aModule) $aUnit
+      lappend aDependencies [LibToLink $aUnit $theSrcDir $theSourceDirOther]
     }
   }
 }
@@ -2110,10 +2093,9 @@ proc osutils:tk:execfiles { theFiles theOutDir theCommand thePrefix theExtension
 # Generate Visual Studio project file for executable
 proc osutils:vcprojx { theVcVer isUWP theOutDir theToolKit theGuidsMap theSrcDir theSourceDirOther } {
   set aVcFiles {}
-  foreach f [osutils:tk:cxxfiles $theToolKit wnt $theSrcDir] {
   set aProjTmpl [osutils:vcproj:readtemplate $theVcVer $isUWP 1]
 
-    set aProjName [file rootname [file tail $f]]
+  set aProjName $theToolKit
   set l_compilable [osutils:compilable wnt]
   regsub -all -- {__XQTNAM__} $aProjTmpl $aProjName aProjTmpl
 
@@ -2142,23 +2124,32 @@ proc osutils:vcprojx { theVcVer isUWP theOutDir theToolKit theGuidsMap theSrcDir
   set aVcFilesCxx(units) ""
   set aVcFilesHxx(units) ""
 
+  if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
+    foreach f [osutils:tk:cxxfiles $theToolKit wnt $theSrcDir] {
       if { ![info exists written([file tail $f])] } {
         set written([file tail $f]) 1
-
-      if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
         append aFilesSection [osutils:vcxproj:cxxfile $f "" 3]
         if { ! [info exists aVcFilesCxx($theToolKit)] } { lappend aVcFilesCxx(units) $theToolKit }
         lappend aVcFilesCxx($theToolKit) $f
+      } else {
+        puts "Warning : in vcproj there are more than one occurrences for [file tail $f]"
+      }
+    }
   } else {
     append aFilesSection "\t\t\t<Filter\n"
     append aFilesSection "\t\t\t\tName=\"$theToolKit\"\n"
     append aFilesSection "\t\t\t\t>\n"
+    foreach f [osutils:tk:cxxfiles $theToolKit wnt $theSrcDir] {
+      if { ![info exists written([file tail $f])] } {
+        set written([file tail $f]) 1
         append aFilesSection [osutils:vcproj:file $theVcVer $f ""]
-        append aFilesSection "\t\t\t</Filter>"
-      }
       } else {
         puts "Warning : in vcproj there are more than one occurrences for [file tail $f]"
       }
+    }
+    append aFilesSection "\t\t\t</Filter>"
+  }
+
   #puts "$aProjTmpl $aFilesSection"
   set anIncPaths "..\\..\\..\\inc"
   regsub -all -- {__TKINC__}  $aProjTmpl $anIncPaths    aProjTmpl
@@ -2201,7 +2192,7 @@ proc osutils:vcprojx { theVcVer isUWP theOutDir theToolKit theGuidsMap theSrcDir
 
     lappend aVcFiles "$aCommonSettingsFile"
   }
-  }
+
   return $aVcFiles
 }
 

dox/build/build_3rdparty/building_3rdparty.md

@@ -128,8 +128,9 @@ You can download its sources from https://freetype.org/
 
 @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/oneapi-src/oneTBB/releases/tag/v2021.5.0.
+Go to the **Download** page, find the release version you need (e.g. `oneTBB 2021.5.0`) and pick the archive for Windows platform.
+To install, unpack the downloaded archive of TBB product (`oneapi-tbb-2021.5.0-win.zip`)
 
 Unpack the downloaded archive of TBB product into the `3rdparty` folder.
 
@@ -304,9 +305,9 @@ Download the necessary archive from https://freetype.org/ and unpack it.
 
 @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.
-To install, unpack the downloaded archive of TBB product.
+This third-party product is installed with binaries from the archive that can be downloaded from https://github.com/oneapi-src/oneTBB/releases/tag/v2021.5.0.
+Go to the **Download** page, find the release version you need (e.g. `oneTBB 2021.5.0`) and pick the archive for Linux platform.
+To install, unpack the downloaded archive of TBB product (`oneapi-tbb-2021.5.0-lin.tgz`).
 
 @subsection dev_guides__building_3rdparty_linux_3_3 FreeImage
 
@@ -477,9 +478,9 @@ Download the necessary archive from https://freetype.org/ and unpack it.
 
 @subsection dev_guides__building_3rdparty_osx_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 Mac OS X platform.
-To install, unpack the downloaded archive of TBB product (`tbb30_018oss_osx.tgz`).
+This third-party product is installed with binaries from the archive that can be downloaded from https://github.com/oneapi-src/oneTBB/releases/tag/v2021.5.0.
+Go to the **Download** page, find the release version you need (e.g. `oneTBB 2021.5.0`) and pick the archive for Mac OS X platform.
+To install, unpack the downloaded archive of TBB product (`oneapi-tbb-2021.5.0-mac.tgz`).
 
 @subsection dev_guides__building_3rdparty_osx_3_3 FreeImage
 

dox/build/build_occt/building_occt.md

@@ -17,7 +17,7 @@ On Linux and macOS we recommend to use libraries maintained by distributive deve
 @section build_occt_win_cmake Building with CMake tool
 
 This chapter describes the [CMake](https://cmake.org/download/)-based build process, which is now suggested as a standard way to produce the binaries of Open CASCADE Technology from sources.
-OCCT requires CMake version 2.8.12 or later.
+OCCT requires CMake version 3.1 or later.
 
 CMake is a tool that generates the actual project files for the selected target build system (e.g. Unix makefiles) or IDE (e.g. Visual Studio 2010).
 Here we describe the build procedure on the example of Windows platform with Visual Studio 2010.
@@ -113,6 +113,7 @@ The following table gives the full list of environment variables used at the con
 | BUILD_PATCH | Path | Points to the directory recognized as a "patch" for OCCT. If specified, the files from this directory take precedence over the corresponding native OCCT sources. This way you are able to introduce patches to Open CASCADE Technology not affecting the original source distribution |
 | BUILD_WITH_DEBUG | Boolean | Enables extended messages of many OCCT algorithms, usually printed to cout. These include messages on internal errors and special cases encountered, timing, etc. |
 | BUILD_ENABLE_FPE_SIGNAL_HANDLER | Boolean | Enable/Disable the floating point exceptions (FPE) during DRAW execution only. Corresponding environment variable (CSF_FPE) can be changed manually in custom.bat/sh scripts without regeneration by CMake. |
+| BUILD_CPP_STANDARD | String | Employ corresponding c++ standard (C++11, C++14, ..C++23) for building OCCT |
 | CMAKE_CONFIGURATION_TYPES | String | Semicolon-separated CMake configurations |
 | INSTALL_DIR          | Path | Points to the installation directory. *INSTALL_DIR* is a synonym of *CMAKE_INSTALL_PREFIX*. The user can specify both *INSTALL_DIR* or *CMAKE_INSTALL_PREFIX* |
 | INSTALL_DIR_BIN      | Path | Relative path to the binaries installation directory (absolute path is ${INSTALL_DIR}/${INSTALL_DIR_BIN}) |

dox/introduction/introduction.md

@@ -341,7 +341,7 @@ The tables below describe the recommended software configurations for which OCCT
 
 | OS        | Compiler |
 | --------- | ----------- |
-| Windows   | Microsoft Visual Studio: 2013 Update 5, 2015 Update 3, 2017 <sup>1</sup>, 2019, 2022 <br>, LLVM (ClangCL), GCC 4.3+ (Mingw-w64)|
+| Windows   | Microsoft Visual Studio: 2015 Update 3, 2017 <sup>1</sup>, 2019, 2022 <br>, LLVM (ClangCL), GCC 4.3+ (Mingw-w64)|
 | Linux     | GNU gcc 4.3+ <br> LLVM CLang 3.6+ |
 | OS X / macOS | XCode 6 or newer |
 | Android   | NDK r12, GNU gcc 4.9 or newer |
@@ -359,8 +359,8 @@ https://dev.opencascade.org/resources/download/3rd-party-components
 
 | Component | Where to find | Used for | Purpose |
 | --------- | ------------- | -------- | -------------------- |
-| CMake 2.8+ | https://cmake.org/ | Configuration | Build from sources |
-| Intel TBB 4.x or later | https://oneapi-src.github.io/oneTBB/ | All | Parallelization of algorithms (alternative to built-in thread pool) |
+| CMake 3.1+ | https://cmake.org/ | Configuration | Build from sources |
+| Intel oneTBB 2021.5.0 | https://github.com/oneapi-src/oneTBB/releases/tag/v2021.5.0 | All | Parallelization of algorithms (alternative to built-in thread pool) |
 | OpenGL 3.3+, OpenGL ES 2.0+ | System | Visualization | Required for using 3D Viewer |
 | OpenVR 1.10+ | https://github.com/ValveSoftware/openvr | Visualization | VR (Virtual Reality) support in 3D Viewer |
 | FreeType 2.4+ | https://www.freetype.org/download.html | Visualization | Text rendering in 3D Viewer |
@@ -572,8 +572,7 @@ FreeType 2 is released under two open-source licenses: BSD-like FreeType License
 It is a library that helps you to take advantage of multi-core processor performance without having to be a threading expert. 
 Threading Building Blocks is not just a threads-replacement library. It represents a higher-level, task-based parallelism that 
 abstracts platform details and threading mechanisms for scalability and performance. 
-TBB version 2017 is available under Apache 2.0 license, while older versions 
-until 4.4 are available under GPLv2 license with the runtime exception (https://www.threadingbuildingblocks.org).
+Intel oneTBB 2021.5.0 is available under Apache 2.0 license (https://www.threadingbuildingblocks.org).
 
 **OpenGL** is an industry standard API for 3D graphics used by OCCT for 
 implementation of 3D viewer. OpenGL specification is developed by the

dox/upgrade/upgrade.md

@@ -2338,3 +2338,8 @@ or to include system OpenGL headers in advance (with help of `OpenGl_GlNative.hx
 
 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()`.
+
+@subsection upgrade_occt770_shapeproximity BRepExtrema_ShapeProximity
+
+A new way of using the `BRepExtrema_ShapeProximity` class was provided for computing a proximity value between two shapes.
+If at initialization of the `BRepExtrema_ShapeProximity` class the *theTolerance* parameter is not defined (Precision::Infinite() by default), the proximity value will be computed.

dox/user_guides/foundation_classes/foundation_classes.md

@@ -1331,7 +1331,7 @@ Therefore if the user of *NCollection* does not specify any allocator as a param
 Nevertheless, it is possible to define a custom *Allocator* type to manage the memory in the most optimal or convenient way for this algorithm.
 
 As one possible choice, the class *NCollection_IncAllocator* is included.
-Unlike *NCollection_BaseAllocator*, the memory is allocated in big blocks (about 20kB) and the allocator keeps track of the amount of occupied memory.
+Unlike *NCollection_BaseAllocator*, the memory is allocated in big blocks (about 12kB) and the allocator keeps track of the amount of occupied memory.
 The method *Allocate* just increments the pointer to non-occupied memory and returns its previous value.
 Memory is only released in the destructor of *NCollection_IncAllocator*, the method *Free* is empty.
 If used properly, this Allocator can greatly improve the performance of specific algorithms.

dox/user_guides/modeling_data/modeling_data.md

@@ -326,7 +326,8 @@ The <i>Geom2dConvert</i> package provides the following:
   * a global function which is used to construct a BSpline curve from a bounded curve based on a 2D curve from the Geom2d package,
   * a splitting algorithm which computes the points at which a 2D BSpline curve should be cut in order to obtain arcs with the same degree of continuity,
   * global functions used to construct the BSpline curves created by this splitting algorithm, or by other types of segmentation of the BSpline curve,
-  * an algorithm which converts a 2D BSpline curve into a series of adjacent Bezier curves.
+  * an algorithm which converts a 2D BSpline curve into a series of adjacent Bezier curves,
+  * an algorithm which converts an arbitrary 2D curve into a series of adjacent 2D circular arcs and 2D linear segments.
 
 The <i>GeomConvert</i> package also provides the following:
 
@@ -339,6 +340,7 @@ The <i>GeomConvert</i> package also provides the following:
   * global functions to construct BSpline surfaces created by this splitting algorithm, or by other types of BSpline surface segmentation,
   * an algorithm, which converts a BSpline surface into a series of adjacent Bezier surfaces,
   * an algorithm, which converts a grid of adjacent Bezier surfaces into a BSpline surface. 
+  * algorithms that converts NURBS, Bezier and other general parametrized curves and surface into anaytical curves and surfaces.
 
 @subsection occt_modat_1_4 Points on Curves
 

dox/user_guides/shape_healing/shape_healing.md

@@ -1007,6 +1007,25 @@ Standard_Integer aNbOffsetSurfaces = aCheckContents.NbOffsetSurf();
 Handle(TopTools_HSequenceOfShape) aSeqFaces = aCheckContents.OffsetSurfaceSec();
 ~~~~
 
+@subsubsection occt_shg_3_2_4 Analysis of shape underlined geometry
+
+Class *ShapeAnalysis_CanonicalRecognition* provides tools that analyze geometry of shape and explore the possibility of converting geometry into a canonical form.
+Canonical forms for curves are lines, circles and ellipses.
+Canonical forms for surfaces are planar, cylindrical, conical and spherical surfaces.
+
+Recognition and converting into canonical form is performed according to maximal deviation criterium: maximal distance between initial and canonical geometrical objects must be less, than given value.
+
+Analysis of curves is allowed for following shapes:
+  * edge - algorithm checks 3d curve of edge
+  * wire - algorithm checks 3d curves of all edges in order to convert them in the same analytical curve
+
+Analysis of surfaces is allowed for following shapes:
+  * face - algorithm checks surface of face
+  * shell - algorithm checks surfaces of all faces in order to convert them in the same analytical surface
+  * edge - algorithm checks all surfaces that are shared by given edge in order convert one of them in analytical surface, which most close to the input sample surface.
+  * wire - the same as for edge, but algorithm checks all edges of wire in order to find analytical surface, which most close to the input sample surface.
+
+
 @section occt_shg_4 Upgrading
 
 Upgrading tools are intended for adaptation of shapes for better use by Open CASCADE Technology or for customization to particular needs, i.e. for export to another system.

get.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+problem_file=upgrade.bat
+
+list="master integration"
+echo "Getting commit hash"
+for name in $list ; do
+    echo $name
+    export shorthash_$name=$(git rev-parse --short $name)
+    echo shorthash_$name=$(eval echo "\$shorthash_${name}")
+done
+
+echo "Getting list of commits between master and integration"
+list=$(git rev-list --ancestry-path ${shorthash_master}..${shorthash_integration})
+
+echo "Getting commit whose hash matches the hash of commit with problematic file"
+for hash in $list ; do    
+    list_changed_files=$(git diff-tree --no-commit-id --name-only -r $hash | sed 's/\// /g' | awk '{ print $NF }')
+    for changed_file in $list_changed_files; do
+        if [ "$problem_file" == "$changed_file" ] ; then
+            echo Reverting: 
+            echo $(git log -1 --format=oneline $hash)
+            # git revert $hash
+            hash=$(echo $hash | head -c 10)
+            echo $hash
+            git rebase --onto $hash^ $hash
+        fi
+    done
+done

samples/CSharp/WPF_D3D/IE_WPF_D3D.csproj

@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>IE_WPF_D3D</RootNamespace>
     <AssemblyName>IE_WPF_D3D</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <WarningLevel>4</WarningLevel>

samples/CSharp/WPF_D3D/app.config

@@ -1,3 +1,3 @@
 <?xml version="1.0"?>
 <configuration>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/></startup></configuration>

samples/CSharp/WPF_WinForms/IE_WPF_WinForms.csproj

@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>IE_WPF_WinForms</RootNamespace>
     <AssemblyName>IE_WPF_WinForms</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <WarningLevel>4</WarningLevel>

samples/CSharp/WPF_WinForms/app.config

@@ -1,3 +1,3 @@
 <?xml version="1.0"?>
 <configuration>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/></startup></configuration>

samples/CSharp/WinForms/IE_WinForms.csproj

@@ -27,7 +27,7 @@
     <UpgradeBackupLocation>
     </UpgradeBackupLocation>
     <OldToolsVersion>3.5</OldToolsVersion>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
     <TargetFrameworkProfile />
     <PublishUrl>publish\</PublishUrl>
     <Install>true</Install>

samples/CSharp/WinForms/app.config

@@ -35,4 +35,4 @@
       </providers>
     </roleManager>
   </system.web>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/></startup></configuration>

samples/glfw/CMakeLists.txt

@@ -4,7 +4,6 @@ project(glfw-occt-demo)
 
 set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/adm/cmake" ${CMAKE_MODULE_PATH})
 
-set(CMAKE_CXX_STANDARD 11)
 set(APP_VERSION_MAJOR 1)
 set(APP_VERSION_MINOR 0)
 set(APP_TARGET glfwocct)

samples/glfw/adm/cmake/FindOpenCASCADE.cmake

@@ -39,9 +39,9 @@ elseif (DEFINED CMAKE_COMPILER_IS_GNUCC)
   set (MY_COMPILER gcc)
 elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX)
   set (MY_COMPILER gcc)
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+elseif (CMAKE_CXX_COMPILER_ID MATCHES "[Cc][Ll][Aa][Nn][Gg]")
   set (MY_COMPILER clang)
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+elseif (CMAKE_CXX_COMPILER_ID MATCHES "[Ii][Nn][Tt][Ee][Ll]")
   set (MY_COMPILER icc)
 else()
   set (MY_COMPILER ${CMAKE_GENERATOR})

samples/java/jniviewer/app/src/main/jni/CMakeLists.txt

@@ -37,7 +37,7 @@ list(APPEND aLibDeps lib_FreeType)
 # system libraries
 list(APPEND aLibDeps EGL GLESv2 log android)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -frtti -fexceptions -fpermissive")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -frtti -fexceptions -fpermissive")
 
 add_library(TKJniSample SHARED ${SOURCE_FILES})
 target_link_libraries(TKJniSample ${aLibDeps})

samples/mfc/standard/01_Geometry/CMakeLists.txt

@@ -1,4 +1,10 @@
-cmake_minimum_required (VERSION 2.6)
+# Caution! Be careful, when increase minimal cmake version:
+# using of newer version may leads (by default) to applying
+# of some new policies. It may break compilation.
+# For canceling of applying new policies use:
+# cmake_policy(PUSH) before `cmake_minimum_required`
+# and cmake_policy(POP) after.
+cmake_minimum_required (VERSION 3.1 FATAL_ERROR)
 
 project (Geometry)
 

samples/mfc/standard/02_Modeling/CMakeLists.txt

@@ -1,4 +1,10 @@
-cmake_minimum_required (VERSION 2.6)
+# Caution! Be careful, when increase minimal cmake version:
+# using of newer version may leads (by default) to applying
+# of some new policies. It may break compilation.
+# For canceling of applying new policies use:
+# cmake_policy(PUSH) before `cmake_minimum_required`
+# and cmake_policy(POP) after.
+cmake_minimum_required (VERSION 3.1 FATAL_ERROR)
 
 project (Modeling)
 

samples/mfc/standard/03_ImportExport/CMakeLists.txt

@@ -1,4 +1,10 @@
-cmake_minimum_required (VERSION 2.6)
+# Caution! Be careful, when increase minimal cmake version:
+# using of newer version may leads (by default) to applying
+# of some new policies. It may break compilation.
+# For canceling of applying new policies use:
+# cmake_policy(PUSH) before `cmake_minimum_required`
+# and cmake_policy(POP) after.
+cmake_minimum_required (VERSION 3.1 FATAL_ERROR)
 
 project (ImportExport)
 

samples/mfc/standard/04_HLR/CMakeLists.txt

@@ -1,4 +1,10 @@
-cmake_minimum_required (VERSION 2.6)
+# Caution! Be careful, when increase minimal cmake version:
+# using of newer version may leads (by default) to applying
+# of some new policies. It may break compilation.
+# For canceling of applying new policies use:
+# cmake_policy(PUSH) before `cmake_minimum_required`
+# and cmake_policy(POP) after.
+cmake_minimum_required (VERSION 3.1 FATAL_ERROR)
 
 project (HLR)
 

samples/mfc/standard/mfcsample/CMakeLists.txt

@@ -1,4 +1,10 @@
-cmake_minimum_required (VERSION 2.6)
+# Caution! Be careful, when increase minimal cmake version:
+# using of newer version may leads (by default) to applying
+# of some new policies. It may break compilation.
+# For canceling of applying new policies use:
+# cmake_policy(PUSH) before `cmake_minimum_required`
+# and cmake_policy(POP) after.
+cmake_minimum_required (VERSION 3.1 FATAL_ERROR)
 
 project (mfcsample)
 

samples/qt/Interface/src/Translate.cxx

@@ -221,7 +221,7 @@ Handle(TopTools_HSequenceOfShape) Translate::importModel( const int format, cons
             shapes = importSTEP( file );
             break;
         }
-    } catch ( Standard_Failure ) {
+    } catch ( const Standard_Failure& ) {
         shapes.Nullify();
     }
     return shapes;
@@ -256,7 +256,7 @@ bool Translate::exportModel( const int format, const QString& file, const Handle
         case FormatSTL:  return exportSTL ( file, shapes );
         case FormatVRML: return exportVRML( file, shapes );
         }
-    } catch ( Standard_Failure ) {
+    } catch ( const Standard_Failure& ) {
         //
     }
     return false;

samples/webgl/CMakeLists.txt

@@ -2,7 +2,6 @@ cmake_minimum_required(VERSION 3.2)
 
 project(occt-webgl-sample)
 
-set(CMAKE_CXX_STANDARD 11)
 set(APP_VERSION_MAJOR 1)
 set(APP_VERSION_MINOR 0)
 set(APP_TARGET occt-webgl-sample)

src/AIS/AIS_Animation.cxx

@@ -251,7 +251,9 @@ void AIS_Animation::Stop()
   myState = AnimationState_Stopped;
   if (!myTimer.IsNull())
   {
+    const Standard_Real anElapsedTime = ElapsedTime();
     myTimer->Stop();
+    myTimer->Seek (Min (Duration(), anElapsedTime));
   }
 
   for (NCollection_Sequence<Handle(AIS_Animation)>::Iterator anIter (myAnimations); anIter.More(); anIter.Next())

src/AIS/AIS_Circle.cxx

@@ -27,6 +27,7 @@
 #include <Prs3d_Presentation.hxx>
 #include <Quantity_Color.hxx>
 #include <Select3D_SensitiveCircle.hxx>
+#include <Select3D_SensitivePoly.hxx>
 #include <SelectMgr_EntityOwner.hxx>
 #include <SelectMgr_Selection.hxx>
 #include <Standard_Type.hxx>
@@ -41,8 +42,8 @@ IMPLEMENT_STANDARD_RTTIEXT(AIS_Circle,AIS_InteractiveObject)
 AIS_Circle::AIS_Circle(const Handle(Geom_Circle)& aComponent):
 AIS_InteractiveObject(PrsMgr_TOP_AllView),
 myComponent(aComponent),
-myUStart(0.),
-myUEnd(2*M_PI),
+myUStart (0.0),
+myUEnd (2.0 * M_PI),
 myCircleIsArc (Standard_False),
 myIsFilledCircleSens (Standard_False)
 {
@@ -60,7 +61,7 @@ AIS_Circle::AIS_Circle(const Handle(Geom_Circle)& theComponent,
   myComponent (theComponent),
   myUStart (theUStart),
   myUEnd (theUEnd),
-  myCircleIsArc (Standard_True),
+  myCircleIsArc (Abs (Abs (theUEnd - theUStart) - 2.0 * M_PI) > gp::Resolution()),
   myIsFilledCircleSens (theIsFilledCircleSens)
 {
 }
@@ -207,13 +208,13 @@ void AIS_Circle::UnsetWidth()
 //function : ComputeCircle
 //purpose  : 
 //=======================================================================
-void AIS_Circle::ComputeCircle( const Handle(Prs3d_Presentation)& aPresentation)
+void AIS_Circle::ComputeCircle (const Handle(Prs3d_Presentation)& thePresentation)
 {
 
   GeomAdaptor_Curve curv(myComponent);
   Standard_Real prevdev = myDrawer->DeviationCoefficient();
   myDrawer->SetDeviationCoefficient (1.e-5);
-  StdPrs_DeflectionCurve::Add(aPresentation,curv,myDrawer);
+  StdPrs_DeflectionCurve::Add (thePresentation, curv, myDrawer);
   myDrawer->SetDeviationCoefficient (prevdev);
 
 }
@@ -223,12 +224,12 @@ void AIS_Circle::ComputeCircle( const Handle(Prs3d_Presentation)& aPresentation)
 
 //purpose  : 
 //=======================================================================
-void AIS_Circle::ComputeArc( const Handle(Prs3d_Presentation)& aPresentation)
+void AIS_Circle::ComputeArc (const Handle(Prs3d_Presentation)& thePresentation)
 {
   GeomAdaptor_Curve curv(myComponent, myUStart, myUEnd);
   Standard_Real prevdev = myDrawer->DeviationCoefficient();
   myDrawer->SetDeviationCoefficient (1.e-5);
-  StdPrs_DeflectionCurve::Add(aPresentation,curv,myDrawer);
+  StdPrs_DeflectionCurve::Add (thePresentation, curv, myDrawer);
   myDrawer->SetDeviationCoefficient (prevdev);
 }
 
@@ -237,27 +238,25 @@ void AIS_Circle::ComputeArc( const Handle(Prs3d_Presentation)& aPresentation)
 //purpose  : 
 //=======================================================================
 
-void AIS_Circle::ComputeCircleSelection(const Handle(SelectMgr_Selection)& aSelection)
+void AIS_Circle::ComputeCircleSelection (const Handle(SelectMgr_Selection)& theSelection)
 {
-  Handle(SelectMgr_EntityOwner) eown = new SelectMgr_EntityOwner(this);
-  Handle(Select3D_SensitiveCircle) seg = new Select3D_SensitiveCircle (eown,
+  Handle(SelectMgr_EntityOwner) anOwner = new SelectMgr_EntityOwner(this);
+  Handle(Select3D_SensitiveCircle) aCirc = new Select3D_SensitiveCircle (anOwner,
                                                                          myComponent->Circ(),
                                                                          myIsFilledCircleSens);
-  aSelection->Add(seg);
+  theSelection->Add (aCirc);
 }
 //=======================================================================
 //function : ComputeArcSelection
 //purpose  : 
 //=======================================================================
 
-void AIS_Circle::ComputeArcSelection(const Handle(SelectMgr_Selection)& aSelection)
+void AIS_Circle::ComputeArcSelection (const Handle(SelectMgr_Selection)& theSelection)
 {
-
-
-  Handle(SelectMgr_EntityOwner) eown = new SelectMgr_EntityOwner(this);
-  Handle(Select3D_SensitiveCircle) seg = new Select3D_SensitiveCircle (eown,
+  Handle(SelectMgr_EntityOwner) anOwner = new SelectMgr_EntityOwner(this);
+  Handle(Select3D_SensitivePoly) aSeg = new Select3D_SensitivePoly (anOwner,
                                                                     myComponent->Circ(),
                                                                     myUStart, myUEnd,
                                                                     myIsFilledCircleSens);
-  aSelection->Add(seg);
+  theSelection->Add (aSeg);
 }

src/AIS/AIS_InteractiveContext.cxx

@@ -1,4 +1,4 @@
-// Created on: 1997-01-17
+// Created on: 1997-01-17
 // Created by: Robert COUBLANC
 // Copyright (c) 1997-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
@@ -1001,6 +1001,14 @@ void AIS_InteractiveContext::RecomputeSelectionOnly (const Handle(AIS_Interactiv
     return;
   }
 
+  TColStd_ListOfInteger aModes;
+  ActivatedModes (theIO, aModes);
+
+  for (TColStd_ListIteratorOfListOfInteger aModesIter (aModes); aModesIter.More(); aModesIter.Next())
+  {
+    mgrSelector->Deactivate (theIO, aModesIter.Value());
+  }
+
   mgrSelector->RecomputeSelection (theIO);
 
   const Handle(AIS_GlobalStatus)* aStatus = myObjects.Seek (theIO);
@@ -1010,10 +1018,7 @@ void AIS_InteractiveContext::RecomputeSelectionOnly (const Handle(AIS_Interactiv
     return;
   }
 
-  TColStd_ListOfInteger aModes;
-  ActivatedModes (theIO, aModes);
-  TColStd_ListIteratorOfListOfInteger aModesIter (aModes);
-  for (; aModesIter.More(); aModesIter.Next())
+  for (TColStd_ListIteratorOfListOfInteger aModesIter (aModes); aModesIter.More(); aModesIter.Next())
   {
     mgrSelector->Activate (theIO, aModesIter.Value());
   }

src/AIS/AIS_Manipulator.cxx

@@ -84,9 +84,8 @@ namespace
   public:
     //! Main constructor.
     ManipSensCircle (const Handle(SelectMgr_EntityOwner)& theOwnerId,
-                     const gp_Circ& theCircle,
-                     const Standard_Integer theNbPnts)
-    : Select3D_SensitiveCircle (theOwnerId, theCircle, Standard_False, theNbPnts),
+                     const gp_Circ& theCircle)
+    : Select3D_SensitiveCircle (theOwnerId, theCircle, Standard_False),
       ManipSensRotation (theCircle.Position().Direction()) {}
 
     //! Checks whether the circle overlaps current selecting volume
@@ -1168,7 +1167,7 @@ void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSe
       }
       // define sensitivity by circle
       const gp_Circ aGeomCircle (gp_Ax2 (gp::Origin(), anAxis.ReferenceAxis().Direction()), anAxis.RotatorDiskRadius());
-      Handle(Select3D_SensitiveCircle) aCircle = new ManipSensCircle (anOwner, aGeomCircle, anAxis.FacettesNumber());
+      Handle(Select3D_SensitiveCircle) aCircle = new ManipSensCircle (anOwner, aGeomCircle);
       aCircle->SetSensitivityFactor (15);
       theSelection->Add (aCircle);
       // enlarge sensitivity by triangulation

src/Adaptor3d/Adaptor3d_Curve.cxx

@@ -13,7 +13,7 @@
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
-
+// branch2
 #include <Adaptor3d_Curve.hxx>
 
 #include <Geom_BezierCurve.hxx>

src/BRepAlgo/BRepAlgo.cxx

@@ -15,8 +15,13 @@
 // commercial license or contractual agreement.
 
 
+#include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
 #include <BRepAdaptor_Curve.hxx>
+#include <BRepAdaptor_Curve2d.hxx>
 #include <BRepAlgo.hxx>
 #include <BRepLib.hxx>
 #include <BRepLib_MakeEdge.hxx>
@@ -25,10 +30,13 @@
 #include <ElCLib.hxx>
 #include <Geom_Curve.hxx>
 #include <Geom_TrimmedCurve.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <Geom2dConvert_ApproxArcsSegments.hxx>
 #include <GeomAbs_CurveType.hxx>
 #include <GeomConvert.hxx>
 #include <GeomConvert_CompCurveToBSplineCurve.hxx>
 #include <GeomLProp.hxx>
+#include <NCollection_Vector.hxx>
 #include <gp_Pnt.hxx>
 #include <Precision.hxx>
 #include <ShapeFix_Shape.hxx>
@@ -40,6 +48,7 @@
 #include <TColStd_SequenceOfBoolean.hxx>
 #include <TColStd_SequenceOfReal.hxx>
 #include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
 #include <TopLoc_Location.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Edge.hxx>
@@ -47,6 +56,166 @@
 #include <TopoDS_Vertex.hxx>
 #include <TopoDS_Wire.hxx>
 
+// The minimal tolerance of approximation (edges can be defined with yet smaller tolerance)
+static const Standard_Real MINIMAL_TOLERANCE = 0.0001;
+
+namespace {
+
+struct OrientedCurve
+{
+  Handle(Geom2d_TrimmedCurve) Curve;
+  Standard_Boolean           IsReverse;
+  inline gp_Pnt2d Point (const Standard_Boolean isEnd) const
+  {
+    if (isEnd == IsReverse)
+      return Curve->StartPoint();
+    return Curve->EndPoint();
+  }  
+};
+
+}
+
+//=======================================================================
+//function : ConvertWire
+//purpose  : 
+//=======================================================================
+
+TopoDS_Wire BRepAlgo::ConvertWire(const TopoDS_Wire&          theWire,
+                                  const Standard_Real         theAngleTol,
+                                  const TopoDS_Face&          theFace)
+{
+  TopoDS_Wire aResult;
+  Standard_Real aMaxTol(0.);
+  const Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace);
+  NCollection_Vector<OrientedCurve> vecCurve;
+
+  BRepTools_WireExplorer anExpE(theWire, theFace);
+  // Explore the edges in the current wire, in their connection order
+  for (; anExpE.More(); anExpE.Next()) {
+    const TopoDS_Edge& anEdge = anExpE.Current();
+    BRepAdaptor_Curve2d aCurve(anEdge, theFace);
+    Standard_Real aTol = BRep_Tool::Tolerance(anEdge);
+    if (aTol < MINIMAL_TOLERANCE)
+      aTol = MINIMAL_TOLERANCE;
+    if (aTol > aMaxTol)
+      aMaxTol = aTol;
+    Geom2dConvert_ApproxArcsSegments anAlgo(aCurve, aTol, theAngleTol);
+    const TColGeom2d_SequenceOfCurve& aResultApprox = anAlgo.GetResult();
+
+    // Form the array of approximated elementary curves
+    if (anEdge.Orientation() == TopAbs_REVERSED) {
+      for (Standard_Integer iCrv = aResultApprox.Length(); iCrv > 0 ; iCrv--) {
+        const Handle(Geom2d_Curve)& aCrv = aResultApprox(iCrv);
+        if (aCrv.IsNull() == Standard_False) {
+          OrientedCurve& anOCurve = vecCurve.Append(OrientedCurve());
+          anOCurve.Curve = Handle(Geom2d_TrimmedCurve)::DownCast(aCrv);
+          anOCurve.IsReverse = Standard_True;
+        }
+      }
+    } else {
+      for (Standard_Integer iCrv = 1; iCrv <= aResultApprox.Length(); iCrv++) {
+        const Handle(Geom2d_Curve)& aCrv = aResultApprox(iCrv);
+        if (aCrv.IsNull() == Standard_False) {
+          OrientedCurve& anOCurve = vecCurve.Append(OrientedCurve());
+          anOCurve.Curve = Handle(Geom2d_TrimmedCurve)::DownCast(aCrv);
+          anOCurve.IsReverse = Standard_False;
+        }
+      }
+    }
+  }
+
+  if (vecCurve.Length() > 0)
+  {
+    // Build the first vertex
+    BRep_Builder aVBuilder;
+    gp_Pnt2d aPnt[2] = {
+      vecCurve(0).Point(Standard_False),
+      vecCurve(vecCurve.Length() - 1).Point(Standard_True)
+    };
+    Standard_Real aDist = aPnt[0].Distance(aPnt[1]);
+    if (aDist > aMaxTol + Precision::Confusion())
+      aDist = Precision::Confusion();
+    else {
+      aDist = 0.5 * aDist + Precision::Confusion();
+      aPnt[0] = 0.5 * (aPnt[0].XY() + aPnt[1].XY());
+    }
+    gp_Pnt aPnt3d;
+    aSurf->D0(aPnt[0].X(), aPnt[0].Y(), aPnt3d);
+    TopoDS_Vertex aFirstVertex;
+    aVBuilder.MakeVertex(aFirstVertex, aPnt3d, aDist);
+
+    // Loop creating edges
+    BRepBuilderAPI_MakeWire aMkWire;
+    TopoDS_Edge anEdgeRes;
+    TopoDS_Vertex aVertex = aFirstVertex;
+    for (Standard_Integer iCrv = 0; iCrv < vecCurve.Length(); iCrv++) {
+      const OrientedCurve& anOCurve = vecCurve(iCrv);
+      TopoDS_Vertex aNextVertex;
+      aPnt[0] = anOCurve.Point(Standard_True);
+      if (iCrv == vecCurve.Length() - 1) {
+        aPnt[1] = vecCurve(0).Point(Standard_False);
+        aDist = aPnt[0].Distance(aPnt[1]);
+        if (aDist > aMaxTol + Precision::Confusion()) {
+          aSurf->D0(aPnt[0].X(), aPnt[0].Y(), aPnt3d);
+          aVBuilder.MakeVertex(aNextVertex, aPnt3d, Precision::Confusion());
+        } else {
+          aNextVertex = aFirstVertex;
+        }
+      } else {
+        aPnt[1] = vecCurve(iCrv + 1).Point(Standard_False);
+        aDist = 0.5 * (aPnt[0].Distance(aPnt[1])) + Precision::Confusion();
+        aPnt[0] = 0.5 * (aPnt[0].XY() + aPnt[1].XY());
+        aSurf->D0(aPnt[0].X(), aPnt[0].Y(), aPnt3d);
+        aVBuilder.MakeVertex(aNextVertex, aPnt3d, aDist);
+      }
+      const Standard_Real aParam[2] = {
+        anOCurve.Curve->FirstParameter(),
+        anOCurve.Curve->LastParameter()
+      };
+      if (anOCurve.IsReverse) {
+        BRepBuilderAPI_MakeEdge aMkEdge(anOCurve.Curve, aSurf, aNextVertex,
+                                        aVertex, aParam[0], aParam[1]);
+        anEdgeRes = aMkEdge.Edge();
+        anEdgeRes.Orientation(TopAbs_REVERSED);
+      } else {
+        BRepBuilderAPI_MakeEdge aMkEdge(anOCurve.Curve, aSurf, aVertex,
+                                        aNextVertex, aParam[0], aParam[1]);
+        anEdgeRes = aMkEdge.Edge();
+      }
+      aVertex = aNextVertex;
+      aMkWire.Add(anEdgeRes);
+    }
+
+    if (aMkWire.IsDone())
+      aResult = aMkWire.Wire();
+  }
+  return aResult;
+}
+
+//=======================================================================
+//function : ConvertFace
+//purpose  : 
+//=======================================================================
+
+TopoDS_Face BRepAlgo::ConvertFace (const TopoDS_Face&  theFace,
+                                   const Standard_Real theAngleTolerance)
+{
+  TopoDS_Face aResult;
+  const Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace);
+  BRepBuilderAPI_MakeFace aMkFace(aSurf,Precision::Confusion());
+
+  TopExp_Explorer anExp(theFace, TopAbs_WIRE);
+  for (; anExp.More(); anExp.Next()) {
+    const TopoDS_Wire& aWire = TopoDS::Wire(anExp.Current());
+    const TopoDS_Wire aNewWire = ConvertWire(aWire, theAngleTolerance, theFace);
+    aMkFace.Add(aNewWire);
+  }
+  if (aMkFace.IsDone()) {
+    aResult = aMkFace.Face();
+  }
+  return aResult;
+}
+
 //=======================================================================
 //function : ConcatenateWire
 //purpose  : 

src/BRepAlgo/BRepAlgo.hxx

@@ -21,6 +21,7 @@
 #include <TopTools_ListOfShape.hxx>
 class TopoDS_Wire;
 class TopoDS_Edge;
+class TopoDS_Face;
 class TopoDS_Shape;
 
 
@@ -44,6 +45,28 @@ public:
   //! resulting curve of the resulting edge may be C0.
   Standard_EXPORT static TopoDS_Edge ConcatenateWireC0 (const TopoDS_Wire& Wire);
 
+  //! Method of wire conversion, calls BRepAlgo_Approx internally.
+  //! @param theWire
+  //!   Input Wire object.
+  //! @param theAngleTolerance
+  //!   Angle (in radians) defining the continuity of the wire: if two vectors
+  //!   differ by less than this angle, the result will be smooth (zero angle of
+  //!   tangent lines between curve elements).
+  //! @return
+  //!   The new TopoDS_Wire object consisting of edges each representing an arc
+  //!   of circle or a linear segment. The accuracy of conversion is defined
+  //!   as the maximal tolerance of edges in theWire.
+  static Standard_EXPORT TopoDS_Wire ConvertWire
+                                (const TopoDS_Wire&  theWire,
+                                 const Standard_Real theAngleTolerance,
+                                 const TopoDS_Face&  theFace);
+
+  //! Method of face conversion. The API corresponds to the method ConvertWire.
+  //! This is a shortcut for calling ConvertWire() for each wire in theFace.
+  static Standard_EXPORT TopoDS_Face ConvertFace
+                                (const TopoDS_Face&  theFace,
+                                 const Standard_Real theAngleTolerance);
+  
   //! Checks if the  shape is "correct". If not, returns
   //! <Standard_False>, else returns <Standard_True>.
   Standard_EXPORT static Standard_Boolean IsValid (const TopoDS_Shape& S);

src/BRepBuilderAPI/BRepBuilderAPI_Copy.cxx

@@ -15,186 +15,8 @@
 // commercial license or contractual agreement.
 
 
-#include <BRep_Tool.hxx>
 #include <BRepBuilderAPI_Copy.hxx>
-#include <BRepTools_Modification.hxx>
-#include <Geom2d_Curve.hxx>
-#include <Geom_Curve.hxx>
-#include <Geom_Surface.hxx>
-#include <gp_Pnt.hxx>
-#include <TopoDS_Shape.hxx>
-#include <TopoDS_Vertex.hxx>
-#include <Poly_Triangulation.hxx>
-
-namespace {
-
-//! Tool class implementing necessary functionality for copying geometry
-class BRepBuilderAPI_Copy_Modification : public BRepTools_Modification 
-{
-public:
-  BRepBuilderAPI_Copy_Modification (const Standard_Boolean copyGeom,
-                                    const Standard_Boolean copyMesh)
-    : myCopyGeom(copyGeom),
-      myCopyMesh(copyMesh)
-  {
-  }
-
-  //! Returns true to indicate the need to copy face;
-  //! copies surface if requested
-  Standard_Boolean NewSurface (const TopoDS_Face& F, Handle(Geom_Surface)& S,
-                               TopLoc_Location& L, Standard_Real& Tol, 
-                               Standard_Boolean& RevWires, Standard_Boolean& RevFace) Standard_OVERRIDE
-  {
-    S = BRep_Tool::Surface(F,L);
-    Tol = BRep_Tool::Tolerance(F);
-    RevWires = RevFace = Standard_False;
-
-    if ( ! S.IsNull() && myCopyGeom )
-      S = Handle(Geom_Surface)::DownCast(S->Copy());
-
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy triangulation;
-  //! copies it if required
-  Standard_Boolean NewTriangulation(const TopoDS_Face& F, Handle(Poly_Triangulation)& T) Standard_OVERRIDE
-  {
-    if (!myCopyMesh
-      && BRep_Tool::IsGeometric (F))
-    {
-      return Standard_False;
-    }
-
-    TopLoc_Location L;
-    T = BRep_Tool::Triangulation(F, L);
-
-    if (T.IsNull())
-      return Standard_False;
-
-    // mesh is copied if and only if the geometry need to be copied too
-    if (myCopyGeom)
-      T = T->Copy();
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy edge;
-  //! copies curves if requested
-  Standard_Boolean NewCurve (const TopoDS_Edge& E, Handle(Geom_Curve)& C,
-                             TopLoc_Location& L, Standard_Real& Tol) Standard_OVERRIDE
-  {
-    Standard_Real f,l;
-    C = BRep_Tool::Curve (E, L, f, l);
-    Tol = BRep_Tool::Tolerance(E);
-
-    if ( ! C.IsNull() && myCopyGeom )
-      C = Handle(Geom_Curve)::DownCast(C->Copy());
-
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy polygon;
-  //! copies it if required
-  Standard_Boolean NewPolygon(const TopoDS_Edge& E, Handle(Poly_Polygon3D)& P) Standard_OVERRIDE
-  {
-    if (!myCopyMesh
-      && BRep_Tool::IsGeometric (E))
-    {
-      return Standard_False;
-    }
-
-    TopLoc_Location aLoc;
-    P = BRep_Tool::Polygon3D(E, aLoc);
-
-    if (P.IsNull())
-      return Standard_False;
-
-    // polygon is copied if and only if the geometry need to be copied too
-    if (myCopyGeom)
-      P = P->Copy();
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy polygon;
-  //! copies it if required
-  Standard_Boolean NewPolygonOnTriangulation(const TopoDS_Edge& E, const TopoDS_Face& F,
-                                             Handle(Poly_PolygonOnTriangulation)& P) Standard_OVERRIDE
-  {
-    if (!myCopyMesh
-      && BRep_Tool::IsGeometric (E))
-    {
-      return Standard_False;
-    }
-
-    TopLoc_Location aLoc;
-    Handle(Poly_Triangulation) aTria = BRep_Tool::Triangulation(F, aLoc);
-    P = BRep_Tool::PolygonOnTriangulation(E, aTria, aLoc);
-
-    if (P.IsNull())
-      return Standard_False;
-
-    // polygon is copied if and only if the geometry need to be copied too
-    if (myCopyGeom)
-      P = P->Copy();
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy vertex
-  Standard_Boolean NewPoint (const TopoDS_Vertex& V, gp_Pnt& P,
-                             Standard_Real& Tol) Standard_OVERRIDE
-  {
-    P = BRep_Tool::Pnt(V);
-    Tol = BRep_Tool::Tolerance(V);
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy edge;
-  //! copies pcurve if requested
-  Standard_Boolean NewCurve2d (const TopoDS_Edge& E, 
-                               const TopoDS_Face& F,
-                               const TopoDS_Edge& /*NewE*/,
-                               const TopoDS_Face& /*NewF*/,
-                               Handle(Geom2d_Curve)& C, 
-                               Standard_Real& Tol) Standard_OVERRIDE
-  {
-    Tol = BRep_Tool::Tolerance(E);
-    Standard_Real f, l;
-    C = BRep_Tool::CurveOnSurface (E, F, f, l);
-
-    if ( ! C.IsNull() && myCopyGeom )
-      C = Handle(Geom2d_Curve)::DownCast (C->Copy());
-
-    return Standard_True;
-  }
-
-  //! Returns true to indicate the need to copy vertex
-  Standard_Boolean NewParameter (const TopoDS_Vertex& V, const TopoDS_Edge& E,
-                                 Standard_Real& P, Standard_Real& Tol) Standard_OVERRIDE
-  {
-    if (V.IsNull()) return Standard_False; // infinite edge may have Null vertex
-
-    Tol = BRep_Tool::Tolerance(V);
-    P = BRep_Tool::Parameter (V, E);
-
-    return Standard_True;
-  }
-
-  //! Returns the  continuity of E between F1 and F2
-  GeomAbs_Shape Continuity (const TopoDS_Edge& E, const TopoDS_Face& F1,
-                            const TopoDS_Face& F2, const TopoDS_Edge&,
-                            const TopoDS_Face&, const TopoDS_Face&) Standard_OVERRIDE
-  {
-    return BRep_Tool::Continuity (E, F1, F2);
-  }
-
-public:
-  DEFINE_STANDARD_RTTI_INLINE(BRepBuilderAPI_Copy_Modification,BRepTools_Modification)
-
-private: 
-  Standard_Boolean myCopyGeom;
-  Standard_Boolean myCopyMesh;
-};
-
-} // anonymous namespace
+#include <BRepTools_CopyModification.hxx>
 
 //=======================================================================
 //function : BRepBuilderAPI_Copy
@@ -203,7 +25,7 @@ private:
 
 BRepBuilderAPI_Copy::BRepBuilderAPI_Copy ()
 {
-  myModification = new BRepBuilderAPI_Copy_Modification(Standard_True, Standard_False);
+  myModification = new BRepTools_CopyModification(Standard_True, Standard_False);
 }
 
 
@@ -214,7 +36,7 @@ BRepBuilderAPI_Copy::BRepBuilderAPI_Copy ()
 
 BRepBuilderAPI_Copy::BRepBuilderAPI_Copy(const TopoDS_Shape& S, const Standard_Boolean copyGeom, const Standard_Boolean copyMesh)
 {
-  myModification = new BRepBuilderAPI_Copy_Modification(copyGeom, copyMesh);
+  myModification = new BRepTools_CopyModification(copyGeom, copyMesh);
   DoModif(S);
 }
 
@@ -226,7 +48,7 @@ BRepBuilderAPI_Copy::BRepBuilderAPI_Copy(const TopoDS_Shape& S, const Standard_B
 
 void BRepBuilderAPI_Copy::Perform(const TopoDS_Shape& S, const Standard_Boolean copyGeom, const Standard_Boolean copyMesh)
 {
-  myModification = new BRepBuilderAPI_Copy_Modification(copyGeom, copyMesh);
+  myModification = new BRepTools_CopyModification(copyGeom, copyMesh);
   NotDone(); // on force la copie si on vient deja d`en faire une
   DoModif(S);
 }

src/BRepBuilderAPI/BRepBuilderAPI_MakeShapeOnMesh.cxx

@@ -0,0 +1,247 @@
+// Created on: 2022-06-30
+// Created by: Alexander MALYSHEV
+// Copyright (c) 2022-2022 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 <BRepBuilderAPI_MakeShapeOnMesh.hxx>
+
+#include <BRep_Builder.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <NCollection_IndexedDataMap.hxx>
+
+namespace
+{
+  //! Structure representing mesh edge.
+  struct Edge
+  {
+    //! Constructor. Sets edge nodes.
+    Edge(const Standard_Integer TheIdx1,
+         const Standard_Integer TheIdx2)
+    : Idx1(Min(TheIdx1, TheIdx2)),
+      Idx2(Max(TheIdx1, TheIdx2))
+    {}
+
+    //! Comparison operator.
+    Standard_Boolean operator<(const Edge& other) const
+    {
+      if (Idx1 <  other.Idx1 ||
+         (Idx1 == other.Idx1 && Idx2 < other.Idx2))
+      {
+        return Standard_True;
+      }
+
+      return Standard_False;
+    }
+
+    //! First index. It is lower or equal than the second.
+    Standard_Integer Idx1;
+
+    //! Second index.
+    Standard_Integer Idx2;
+  };
+
+  //! Hasher of Edge structure.
+  struct EdgeHasher
+  {
+
+    //! Returns hash code for the given edge.
+    static Standard_Integer HashCode(const Edge&            theEdge,
+                                     const Standard_Integer theUpperBound)
+    {
+      // Circle-based collisions.
+      return ::HashCode(theEdge.Idx1 * theEdge.Idx1 + theEdge.Idx2 * theEdge.Idx2, theUpperBound);
+    }
+
+    //! Returns true if two edges are equal.
+    static Standard_Boolean IsEqual(const Edge& theEdge1,
+                                    const Edge& theEdge2)
+    {
+      return theEdge1.Idx1 == theEdge2.Idx1 && theEdge1.Idx2 == theEdge2.Idx2;
+    }
+
+  };
+}
+
+//=======================================================================
+//function : Build
+//purpose  : 
+//=======================================================================
+void BRepBuilderAPI_MakeShapeOnMesh::Build(const Message_ProgressRange& theRange)
+{
+  // Generally, this method guarantees topology sharing by mapping mesh primitives 
+  // into topological counterparts.
+  // mesh points -> topological vertices
+  // mesh edges  -> topological edges
+
+  // Cannot reconstruct anything from null or empty mesh.
+  if (myMesh.IsNull() || myMesh->NbNodes() == 0 || myMesh->NbTriangles() == 0)
+    return;
+
+  const Standard_Integer aNbNodes = myMesh->NbNodes();
+  const Standard_Integer aNbTriangles = myMesh->NbTriangles();
+
+  // We are going to have three loops: iterate once over nodes and iterate twice
+  // over triangles of input mesh.
+  Message_ProgressScope aPS(theRange,
+                            "Per-facet shape construction", 
+                            Standard_Real(aNbNodes + 2 * aNbTriangles));
+
+  // Build shared vertices.
+  NCollection_IndexedDataMap<Standard_Integer, TopoDS_Vertex> aPnt2VertexMap;
+  
+  for (Standard_Integer i = 1; i <= aNbNodes; ++i)
+  {
+    aPS.Next();
+    if (aPS.UserBreak())
+      return;
+
+    const gp_Pnt aP = myMesh->Node(i);
+    const TopoDS_Vertex aV = BRepBuilderAPI_MakeVertex(aP);
+    aPnt2VertexMap.Add(i, aV);
+  }
+
+  // Build shared edges.
+  NCollection_IndexedDataMap<Edge, TopoDS_Edge, EdgeHasher> anEdgeToTEgeMap;
+  for (Standard_Integer i = 1; i <= aNbTriangles; ++i)
+  {
+    aPS.Next();
+    if (aPS.UserBreak())
+      return;
+
+    Standard_Integer anIdx[3];
+    const Poly_Triangle& aTriangle = myMesh->Triangle(i);
+    aTriangle.Get(anIdx[0], anIdx[1], anIdx[2]);
+
+    // Skip degenerated triangles.
+    if (anIdx[0] == anIdx[1] || anIdx[0] == anIdx[2] || anIdx[1] == anIdx[2])
+      continue;
+
+    const gp_Pnt aP1 = myMesh->Node(anIdx[0]);
+    const gp_Pnt aP2 = myMesh->Node(anIdx[1]);
+    const gp_Pnt aP3 = myMesh->Node(anIdx[2]);
+    const Standard_Real aD1 = aP1.SquareDistance(aP2);
+    const Standard_Real aD2 = aP1.SquareDistance(aP3);
+    const Standard_Real aD3 = aP2.SquareDistance(aP3);
+    if (aD1 < gp::Resolution() ||
+        aD2 < gp::Resolution() ||
+        aD3 < gp::Resolution())
+    {
+      continue;
+    }
+
+    // Edges are constructed in forward order for the existing normals orientation.
+    // In Poly_Triangulation, positive direction is defined as cross product:
+    // (aV1, aV2) x (aV1, aV3).
+    const TopoDS_Vertex& aV1 = aPnt2VertexMap.FindFromKey(anIdx[0]);
+    const TopoDS_Vertex& aV2 = aPnt2VertexMap.FindFromKey(anIdx[1]);
+    const TopoDS_Vertex& aV3 = aPnt2VertexMap.FindFromKey(anIdx[2]);
+
+    const Edge aMeshEdge1(anIdx[0], anIdx[1]);
+    const Edge aMeshEdge2(anIdx[1], anIdx[2]);
+    const Edge aMeshEdge3(anIdx[2], anIdx[0]);
+
+    BRepBuilderAPI_MakeEdge aMaker1(aV1, aV2);
+    BRepBuilderAPI_MakeEdge aMaker2(aV2, aV3);
+    BRepBuilderAPI_MakeEdge aMaker3(aV3, aV1);
+
+    TopoDS_Edge aTE1 = aMaker1.Edge();
+    if (anIdx[1] < anIdx[0])
+      aTE1.Reverse();
+
+    TopoDS_Edge aTE2 = aMaker2.Edge();
+    if (anIdx[2] < anIdx[1])
+      aTE2.Reverse();
+
+    TopoDS_Edge aTE3 = aMaker3.Edge();
+    if (anIdx[0] < anIdx[2])
+      aTE3.Reverse();
+
+    anEdgeToTEgeMap.Add(aMeshEdge1, aTE1);
+    anEdgeToTEgeMap.Add(aMeshEdge2, aTE2);
+    anEdgeToTEgeMap.Add(aMeshEdge3, aTE3);
+  }
+
+  // Construct planar faces using shared topology.
+  TopoDS_Compound aResult;
+  BRep_Builder aBB;
+  aBB.MakeCompound(aResult);
+  for (Standard_Integer i = 1; i <= aNbTriangles; ++i)
+  {
+    aPS.Next();
+    if (aPS.UserBreak())
+      return;
+
+    Standard_Integer anIdx[3];
+    const Poly_Triangle& aTriangle = myMesh->Triangle(i);
+    aTriangle.Get(anIdx[0], anIdx[1], anIdx[2]);
+
+    const Edge aMeshEdge1(anIdx[0], anIdx[1]);
+    const Edge aMeshEdge2(anIdx[1], anIdx[2]);
+    const Edge aMeshEdge3(anIdx[2], anIdx[0]);
+    const Standard_Boolean isReversed1 = anIdx[1] < anIdx[0];
+    const Standard_Boolean isReversed2 = anIdx[2] < anIdx[1];
+    const Standard_Boolean isReversed3 = anIdx[0] < anIdx[2];
+
+    // Edges can be skipped in case of mesh defects - topologically or geometrically
+    // degenerated triangles.
+    const Standard_Boolean aHasAllEdges = anEdgeToTEgeMap.Contains(aMeshEdge1) &&
+                                          anEdgeToTEgeMap.Contains(aMeshEdge2) &&
+                                          anEdgeToTEgeMap.Contains(aMeshEdge3) ;
+    if (!aHasAllEdges)
+      continue;
+
+    TopoDS_Edge aTEdge1 = anEdgeToTEgeMap.FindFromKey(aMeshEdge1);
+    if (isReversed1)
+      aTEdge1.Reverse();
+    TopoDS_Edge aTEdge2 = anEdgeToTEgeMap.FindFromKey(aMeshEdge2);
+    if (isReversed2)
+      aTEdge2.Reverse();
+    TopoDS_Edge aTEdge3 = anEdgeToTEgeMap.FindFromKey(aMeshEdge3);
+    if (isReversed3)
+      aTEdge3.Reverse();
+
+    BRepBuilderAPI_MakeWire aWireMaker;
+    aWireMaker.Add(aTEdge1);
+    aWireMaker.Add(aTEdge2);
+    aWireMaker.Add(aTEdge3);
+    const TopoDS_Wire aWire = aWireMaker.Wire();
+
+    // Construct plane explicitly since it is faster than automatic construction
+    // within BRepBuilderAPI_MakeFace.
+    BRepAdaptor_Curve aC1(aTEdge1);
+    BRepAdaptor_Curve aC2(aTEdge2);
+    const gp_Dir aD1 = aC1.Line().Direction();
+    const gp_Dir aD2 = aC2.Line().Direction();
+    gp_XYZ aN = aD1.XYZ().Crossed(aD2.XYZ());
+    if (aN.SquareModulus() < Precision::SquareConfusion())
+      continue;
+    if (aTEdge1.Orientation() == TopAbs_REVERSED)
+      aN.Reverse();
+    if (aTEdge2.Orientation() == TopAbs_REVERSED)
+      aN.Reverse();
+    const gp_Dir aNorm(aN);
+    gp_Pln aPln(myMesh->Node(anIdx[0]), aNorm);
+
+    BRepBuilderAPI_MakeFace aFaceMaker(aPln, aWire);
+    const TopoDS_Face aFace = aFaceMaker.Face();
+
+    aBB.Add(aResult, aFace);
+  }
+
+  this->Done();
+  myShape = aResult;
+}

src/BRepBuilderAPI/BRepBuilderAPI_MakeShapeOnMesh.hxx

@@ -0,0 +1,46 @@
+// Created on: 2022-06-30
+// Created by: Alexander MALYSHEV
+// Copyright (c) 2022-2022 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 _BRepBuilderAPI_MakeShapeOnMesh_HeaderFile
+#define _BRepBuilderAPI_MakeShapeOnMesh_HeaderFile
+
+#include <BRepBuilderAPI_MakeShape.hxx>
+#include <Poly_Triangulation.hxx>
+
+//! Builds shape on per-facet basis on the input mesh. Resulting shape has shared
+//! edges by construction, but no maximization (unify same domain) is applied.
+//! No generation history is provided.
+class BRepBuilderAPI_MakeShapeOnMesh : public BRepBuilderAPI_MakeShape
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  //! Ctor. Sets mesh to process.
+  //! @param theMesh [in] - Mesh to construct shape for.
+  BRepBuilderAPI_MakeShapeOnMesh(const Handle(Poly_Triangulation)& theMesh)
+  : myMesh(theMesh)
+  {}
+
+  //! Builds shape on mesh.
+  Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
+
+private:
+
+  Handle(Poly_Triangulation) myMesh;
+
+};
+
+#endif // _BRepBuilderAPI_MakeShapeOnMesh_HeaderFile

src/BRepBuilderAPI/BRepBuilderAPI_Transform.cxx

@@ -36,13 +36,14 @@ BRepBuilderAPI_Transform::BRepBuilderAPI_Transform (const gp_Trsf& T) :
 //purpose  : 
 //=======================================================================
 
-BRepBuilderAPI_Transform::BRepBuilderAPI_Transform (const TopoDS_Shape& S,
-				      const gp_Trsf& T,
-				      const Standard_Boolean Copy) :
-  myTrsf(T)
+BRepBuilderAPI_Transform::BRepBuilderAPI_Transform (const TopoDS_Shape&    theShape,
+                                                    const gp_Trsf&         theTrsf,
+                                                    const Standard_Boolean theCopyGeom,
+                                                    const Standard_Boolean theCopyMesh)
+  : myTrsf(theTrsf)
 {
-  myModification = new BRepTools_TrsfModification(T);
-  Perform(S,Copy);
+  myModification = new BRepTools_TrsfModification(theTrsf);
+  Perform(theShape, theCopyGeom, theCopyMesh);
 }
 
 
@@ -52,19 +53,21 @@ BRepBuilderAPI_Transform::BRepBuilderAPI_Transform (const TopoDS_Shape& S,
 //purpose  : 
 //=======================================================================
 
-void BRepBuilderAPI_Transform::Perform(const TopoDS_Shape& S,
-				const Standard_Boolean Copy)
+void BRepBuilderAPI_Transform::Perform(const TopoDS_Shape&    theShape,
+                                       const Standard_Boolean theCopyGeom,
+                                       const Standard_Boolean theCopyMesh)
 {
-  myUseModif = Copy || myTrsf.IsNegative() || (Abs(Abs(myTrsf.ScaleFactor()) - 1.) > TopLoc_Location::ScalePrec());
+  myUseModif = theCopyGeom || myTrsf.IsNegative() || (Abs(Abs(myTrsf.ScaleFactor()) - 1.) > TopLoc_Location::ScalePrec());
   if (myUseModif) {
     Handle(BRepTools_TrsfModification) theModif = 
       Handle(BRepTools_TrsfModification)::DownCast(myModification);
     theModif->Trsf() = myTrsf;
-    DoModif(S,myModification);
+    theModif->IsCopyMesh() = theCopyMesh;
+    DoModif(theShape, myModification);
   }
   else {
     myLocation = myTrsf;
-    myShape = S.Moved(myLocation);
+    myShape = theShape.Moved(myLocation);
     Done();
   }
 

src/BRepBuilderAPI/BRepBuilderAPI_Transform.hxx

@@ -50,28 +50,37 @@ public:
   //! to define the shape to transform.
   Standard_EXPORT BRepBuilderAPI_Transform(const gp_Trsf& T);
   
-  //! Creates a transformation from the gp_Trsf <T>, and
-  //! applies it to the shape <S>. If the transformation
+  //! Creates a transformation from the gp_Trsf <theTrsf>, and
+  //! applies it to the shape <theShape>. If the transformation
   //! is  direct   and isometric (determinant  =  1) and
-  //! <Copy> =  Standard_False,  the resulting shape  is
-  //! <S> on   which  a  new  location has    been  set.
+  //! <theCopyGeom> =  Standard_False,  the resulting shape  is
+  //! <theShape> on   which  a  new  location has    been  set.
   //! Otherwise,  the   transformation is applied   on a
-  //! duplication of <S>.
-  Standard_EXPORT BRepBuilderAPI_Transform(const TopoDS_Shape& S, const gp_Trsf& T, const Standard_Boolean Copy = Standard_False);
+  //! duplication of <theShape>.
+  //! If <theCopyMesh> is true, the triangulation will be copied,
+  //! and the copy will be assigned to the result shape.
+  Standard_EXPORT BRepBuilderAPI_Transform(const TopoDS_Shape&    theShape,
+                                           const gp_Trsf&         theTrsf,
+                                           const Standard_Boolean theCopyGeom = Standard_False,
+                                           const Standard_Boolean theCopyMesh = Standard_False);
   
-  //! pplies the geometric transformation defined at the
+  //! Applies the geometric transformation defined at the
   //! time of construction of this framework to the shape S.
   //! - If the transformation T is direct and isometric, in
   //! other words, if the determinant of the vectorial part
-  //! of T is equal to 1., and if Copy equals false (the
+  //! of T is equal to 1., and if theCopyGeom equals false (the
   //! default value), the resulting shape is the same as
   //! the original but with a new location assigned to it.
-  //! -   In all other cases, the transformation is applied to a duplicate of S.
+  //! - In all other cases, the transformation is applied to a duplicate of theShape.
+  //! - If theCopyMesh is true, the triangulation will be copied,
+  //! and the copy will be assigned to the result shape.
   //! Use the function Shape to access the result.
   //! Note: this framework can be reused to apply the same
   //! geometric transformation to other shapes. You only
   //! need to specify them by calling the function Perform again.
-  Standard_EXPORT void Perform (const TopoDS_Shape& S, const Standard_Boolean Copy = Standard_False);
+  Standard_EXPORT void Perform (const TopoDS_Shape&    theShape,
+                                const Standard_Boolean theCopyGeom = Standard_False, 
+                                const Standard_Boolean theCopyMesh = Standard_False);
   
   //! Returns the modified shape corresponding to <S>.
   Standard_EXPORT virtual TopoDS_Shape ModifiedShape (const TopoDS_Shape& S) const Standard_OVERRIDE;

src/BRepBuilderAPI/FILES

@@ -26,6 +26,8 @@ BRepBuilderAPI_MakePolygon.cxx
 BRepBuilderAPI_MakePolygon.hxx
 BRepBuilderAPI_MakeShape.cxx
 BRepBuilderAPI_MakeShape.hxx
+BRepBuilderAPI_MakeShapeOnMesh.cxx
+BRepBuilderAPI_MakeShapeOnMesh.hxx
 BRepBuilderAPI_MakeShell.cxx
 BRepBuilderAPI_MakeShell.hxx
 BRepBuilderAPI_MakeSolid.cxx

src/BRepClass/BRepClass_Intersector.cxx

@@ -197,10 +197,12 @@ Standard_Boolean CheckOn(IntRes2d_IntersectionPoint& thePntInter,
     if (aMinDist <= theTolZ) {
       IntRes2d_Transition aTrOnLin(IntRes2d_Head);
       IntRes2d_Position aPosOnCurve = IntRes2d_Middle;
-      if (Abs(aPar - theDeb) <= Precision::Confusion()) {
+      if ((Abs(aPar - theDeb) <= Precision::Confusion())
+        || (aPar < theDeb)) {
         aPosOnCurve = IntRes2d_Head;
       }
-      else if (Abs(aPar - theFin) <= Precision::Confusion()) {
+      else if ((Abs(aPar - theFin) <= Precision::Confusion()) 
+        || (aPar > theFin)) {
         aPosOnCurve = IntRes2d_End;
       }
       //
@@ -381,8 +383,16 @@ void  BRepClass_Intersector::Perform(const gp_Lin2d& L,
   {
     Standard_Boolean aStatusOn = Standard_False;
     IntRes2d_IntersectionPoint aPntInter;
+    Standard_Real aDebTol = deb;
+    Standard_Real aFinTol = fin;
+    if (aTolZ > Precision::Confusion())
+    {
+      aDebTol = deb - aTolZ;
+      aFinTol = fin + aTolZ;
+    }
+    Geom2dAdaptor_Curve aCurAdaptor(aC2D, aDebTol, aFinTol);
 
-    aStatusOn = CheckOn(aPntInter, F, L, C, aTolZ, fin, deb);
+    aStatusOn = CheckOn(aPntInter, F, L, aCurAdaptor, aTolZ, fin, deb);
     if (aStatusOn)
     {
       Append(aPntInter);

src/BRepExtrema/BRepExtrema_ProximityDistTool.cxx

@@ -0,0 +1,460 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 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 <BRepExtrema_ProximityDistTool.hxx>
+
+#include <BRepAdaptor_Surface.hxx>
+#include <BRep_Tool.hxx>
+#include <gp_Pln.hxx>
+#include <Precision.hxx>
+#include <Poly_Connect.hxx>
+#include <Standard_NullValue.hxx>
+#include <TopoDS.hxx>
+
+//=======================================================================
+//function : BRepExtrema_ProximityDistTool
+//purpose  : Creates new unitialized tool
+//=======================================================================
+BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool()
+: myMinDistance (std::numeric_limits<Standard_Real>::max()),
+  myProxDist (-1.),
+  myPntStatus1 (ProxPnt_Status_UNKNOWN),
+  myPntStatus2 (ProxPnt_Status_UNKNOWN),
+  myNbSamples1 (0),
+  myProxVtxIdx1 (-1)
+{
+}
+
+//=======================================================================
+//function : BRepExtrema_ProximityDistTool
+//purpose  : Creates new tool for the given element sets
+//=======================================================================
+BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                              const Standard_Integer theNbSamples1,
+                                                              const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                              const BRepExtrema_ShapeList& theShapeList1,
+                                                              const BRepExtrema_ShapeList& theShapeList2)
+: myMinDistance (std::numeric_limits<Standard_Real>::max()),
+  myProxDist (-1.),
+  myPntStatus1 (ProxPnt_Status_UNKNOWN),
+  myPntStatus2 (ProxPnt_Status_UNKNOWN),
+  myNbSamples1 (theNbSamples1),
+  myProxVtxIdx1 (-1)
+{
+  LoadTriangleSets (theSet1, theSet2);
+  LoadShapeLists (theShapeList1, theShapeList2);
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given element sets into the tool
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadTriangleSets (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                      const Handle(BRepExtrema_TriangleSet)& theSet2)
+{
+  mySet1 = theSet1;
+  mySet2 = theSet2;
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given list of subshapes into the proximity tool
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                                    const BRepExtrema_ShapeList& theShapeList2)
+{
+  myShapeList1 = theShapeList1;
+  myShapeList2 = theShapeList2;
+}
+//=======================================================================
+//function : Perform
+//purpose  : Performs searching of the proximity distance
+//=======================================================================
+void BRepExtrema_ProximityDistTool::Perform()
+{
+  SetBVHSet (mySet2.get());
+
+  const BVH_Array3d& aVertices1 = mySet1->GetVertices();
+  Standard_Integer aVtxSize = (Standard_Integer)aVertices1.size();
+  Standard_Integer aVtxStep = Max (myNbSamples1 <= 0 ? 1 : aVtxSize / myNbSamples1, 1);
+  for (Standard_Integer aVtxIdx = 0; aVtxIdx < aVtxSize; aVtxIdx += aVtxStep)
+  {
+    myDistance = std::numeric_limits<Standard_Real>::max();
+    myMinDistance = std::numeric_limits<Standard_Real>::max();
+    myIsDone = Standard_False;
+    SetObject (aVertices1[aVtxIdx]);
+
+    ComputeDistance();
+
+    if (!IsDone() && myProxDist < 0.) return;
+
+    if (IsDone() && myDistance > myProxDist)
+    {
+      myPnt1 = aVertices1[aVtxIdx];
+      myPnt2 = myExtremaPoint;
+      myProxDist = myDistance;
+      myProxVtxIdx1 = aVtxIdx;
+      myProxPrjState = myExtPrjState;
+    }
+  }
+
+   myIsDone = myProxDist > -1.;
+
+   if (myIsDone)
+   {
+     DefineStatusProxPnt();
+   }
+}
+
+static Standard_Real pointBoxSquareMaxDistance (const BVH_Vec3d& thePoint,
+                                                const BVH_Vec3d& theCMin,
+                                                const BVH_Vec3d& theCMax)
+{
+  Standard_Real aDist = 0;
+  for (int i = 0; i < 3; ++i)
+  {
+    if (thePoint[i] <= 0.5 * (theCMax[i] + theCMin[i])) { Standard_Real d = theCMax[i] - thePoint[i]; d *= d; aDist += d; }
+    else { Standard_Real d = thePoint[i] - theCMin[i]; d *= d; aDist += d; }
+  }
+  return aDist;
+}
+
+//=======================================================================
+//function : Branch rejection
+//purpose  : Defines the rules for node rejection by bounding box
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::RejectNode (const BVH_Vec3d& theCornerMin,
+                                                            const BVH_Vec3d& theCornerMax,
+                                                            Standard_Real& theMetric) const
+{
+  theMetric = sqrt (BVH_Tools<Standard_Real, 3>::PointBoxSquareDistance (myObject,
+                                                                         theCornerMin,
+                                                                         theCornerMax));
+
+  Standard_Real aMaxMetric = sqrt (pointBoxSquareMaxDistance (myObject,
+                                                              theCornerMin,
+                                                              theCornerMax));
+
+  return theMetric > myDistance || aMaxMetric < myProxDist;
+}
+
+//=======================================================================
+//function : Leaf acceptance
+//purpose  : Defines the rules for leaf acceptance
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::Accept (const Standard_Integer theTrgIdx,
+                                                        const Standard_Real&)
+{
+  BVH_Vec3d aTrgVert1;
+  BVH_Vec3d aTrgVert2;
+  BVH_Vec3d aTrgVert3;
+
+  BVH_PrjState aBVH_PrjState;
+  Standard_Integer aNumberOfFirstNode = -1;
+  Standard_Integer aNumberOfLastNode = -1;
+
+  mySet2->GetVertices (theTrgIdx, aTrgVert1, aTrgVert2, aTrgVert3);
+
+  BVH_Vec3d aNearestPnt = BVH_Tools<Standard_Real, 3>::PointTriangleProjection (myObject,
+                                                                                aTrgVert1, aTrgVert2, aTrgVert3,
+                                                                                &aBVH_PrjState,
+                                                                                &aNumberOfFirstNode, &aNumberOfLastNode);
+
+  PrjState aPrjState (theTrgIdx, aBVH_PrjState, aNumberOfFirstNode, aNumberOfLastNode);
+  BVH_Vec3d aDirect = myObject - aNearestPnt;
+  Standard_Real aSqDistance = aDirect.Dot(aDirect);
+
+  if (aSqDistance > Precision::SquareConfusion()) // point belongs to triangle
+  {
+    const BVH_Vec3d aAB = aTrgVert2 - aTrgVert1;
+
+    BVH_Vec3d aNorm;
+    if (aTrgVert2.IsEqual (aTrgVert3)) // is this degenerate triangle (= segment)
+    {
+      const BVH_Vec3d aAP = myObject - aTrgVert1;
+      aNorm = BVH_Vec3d::Cross (BVH_Vec3d::Cross (aAP, aAB), aAB);
+    }
+    else
+    {
+      const BVH_Vec3d aAC = aTrgVert3 - aTrgVert1;
+      aNorm = BVH_Vec3d::Cross (aAB, aAC);
+    }
+
+    Standard_Real aNormSqLen = aNorm.Dot (aNorm);
+
+    // check if the distance is under perpendicular
+    const BVH_Vec3d aCrossCross = BVH_Vec3d::Cross (aDirect, aNorm);
+    Standard_Real aCrossCrossSqLen = aCrossCross.Dot (aCrossCross);
+    if (aCrossCrossSqLen > Precision::SquareConfusion() * aSqDistance * aNormSqLen)
+    {
+      // the distance is not under perpendicular
+      if (myMinDistance - sqrt (aSqDistance) > Precision::Confusion())
+      {
+        myMinDistance = sqrt (aSqDistance);
+        myMinDistPoint = aNearestPnt;
+        myMinPrjState = aPrjState;
+      }
+
+      return Standard_False;
+    }
+  }
+
+  // the distance is under perpendicular
+  if (myDistance - sqrt (aSqDistance) > Precision::Confusion())
+  {
+    myDistance = sqrt (aSqDistance);
+    myExtremaPoint = aNearestPnt;
+    myExtPrjState = aPrjState;
+
+    return Standard_True;
+  }
+
+  return Standard_False;
+}
+
+//=======================================================================
+//function : ComputeDistance
+//purpose  : Computes the distance between object and BVH tree
+//=======================================================================
+Standard_Real BRepExtrema_ProximityDistTool::ComputeDistance()
+{
+  myIsDone = this->Select() > 0;
+
+  if (!myIsDone)
+  {
+    if (myMinDistance < std::numeric_limits<Standard_Real>::max())
+    {
+      myExtremaPoint = myMinDistPoint;
+      myExtPrjState = myMinPrjState;
+      myIsDone = true;
+    }
+
+    myDistance = myMinDistance;
+  }
+
+  return myDistance;
+}
+
+static Standard_Boolean isNodeOnBorder (const Standard_Integer theNodeIdx, const Handle (Poly_Triangulation)& theTr)
+{
+  Poly_Connect aPolyConnect (theTr);
+
+  Standard_Integer aContTrg; //index of triangle containing exploring node
+  for (aPolyConnect.Initialize (theNodeIdx); aPolyConnect.More(); aPolyConnect.Next())
+  {
+    aContTrg = aPolyConnect.Value();
+
+    Standard_Integer aContTrgNodes[3];
+    theTr->Triangle (aContTrg).Get (aContTrgNodes[0], aContTrgNodes[1], aContTrgNodes[2]); //indices of nodes of the triangle
+
+    Standard_Integer aAdjTrg[3];
+    aPolyConnect.Triangles (aContTrg, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
+  
+    for (Standard_Integer j = 0; j < 3; j++)
+    {
+      Standard_Integer k = (j + 1) % 3;
+      if (aAdjTrg[j] == 0) //free segment of triangle
+      {
+        //aContTrgNodes[j], aContTrgNodes[k] are ends of free segment and it is a part of border
+        if (aContTrgNodes[j] == theNodeIdx || aContTrgNodes[k] == theNodeIdx)
+        {
+          return Standard_True;
+        }
+      }
+    }
+  }
+
+  return Standard_False;
+}
+
+//=======================================================================
+//function : defineStatusProxPnt1
+//purpose  : Defines the status of proximity point from 1st BVH
+//=======================================================================
+void BRepExtrema_ProximityDistTool::defineStatusProxPnt1()
+{
+  Standard_Integer aFaceID1 = mySet1->GetShapeIDOfVtx (myProxVtxIdx1);
+
+  if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_EDGE)
+  {
+    const BVH_Array3d& aVertices1 = mySet1->GetVertices();
+    Standard_Integer aVtxSize = (Standard_Integer)aVertices1.size();
+    Standard_Integer aLastIdx = aVtxSize - 1;
+
+    if ((aVertices1[0] - aVertices1[aLastIdx]).Modulus() < Precision::Confusion()) // if closed
+    {
+      myPntStatus1 = ProxPnt_Status_MIDDLE;
+      return;
+    }
+
+    if (myProxVtxIdx1 == 0 || myProxVtxIdx1 == aLastIdx)
+    {
+      myPntStatus1 = ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      myPntStatus1 = ProxPnt_Status_MIDDLE;
+    }
+  }
+  else if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_FACE)
+  {
+    Standard_Integer aNodeIdx = mySet1->GetVtxIdxInShape (myProxVtxIdx1) + 1;
+
+    TopLoc_Location aLocation;
+    const TopoDS_Face& aF = TopoDS::Face (myShapeList1 (aFaceID1));
+    Handle (Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+
+    if (isNodeOnBorder (aNodeIdx, aTr))
+    {
+      myPntStatus1 = ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      myPntStatus1 = ProxPnt_Status_MIDDLE;
+    }
+  }
+}
+
+//=======================================================================
+//function : defineStatusProxPnt2
+//purpose  : Defines the status of proximity point from 2nd BVH
+//=======================================================================
+void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
+{
+  Standard_Integer aTrgIdx = myProxPrjState.GetTrgIdx();
+  Standard_Integer aFaceID2 = mySet2->GetFaceID (aTrgIdx);
+
+  if (myShapeList2 (aFaceID2).ShapeType() == TopAbs_EDGE)
+  {
+    if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_INNER)
+    {
+      return;
+    }
+    else
+    {
+      const BVH_Array3d& aVertices2 = mySet2->GetVertices();
+      Standard_Integer aVtxSize = (Standard_Integer)aVertices2.size();
+      Standard_Integer aLastIdx = aVtxSize - 1;
+
+      if ((aVertices2[0] - aVertices2[aLastIdx]).Modulus() < Precision::Confusion()) // if closed
+      {
+        myPntStatus2 = ProxPnt_Status_MIDDLE;
+        return;
+      }
+
+      NCollection_Array1<Standard_Integer> aVtxIndicesOfTrg;
+      mySet2->GetVtxIndices (aTrgIdx, aVtxIndicesOfTrg);
+
+      Standard_Integer aFirstNodeNum = myProxPrjState.GetNumberOfFirstNode();
+      Standard_Integer aFirstVtxIdx = aVtxIndicesOfTrg[aFirstNodeNum];
+
+      if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_VERTEX)
+      {
+        if (aFirstVtxIdx == 0 || aFirstVtxIdx == aLastIdx)
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      }
+      else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
+      {
+        Standard_Integer aLastNodeNum = myProxPrjState.GetNumberOfLastNode();
+        Standard_Integer aLastVtxIdx = aVtxIndicesOfTrg[aLastNodeNum];
+
+        // it could be border only in case projection is on a degenerated edge
+        if (aFirstVtxIdx == aLastVtxIdx && (aFirstVtxIdx == 0 || aFirstVtxIdx == aLastIdx))
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      }
+    }
+  }
+  else if (myShapeList2 (aFaceID2).ShapeType() == TopAbs_FACE)
+  {
+    if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_INNER)
+    {
+      myPntStatus2 = ProxPnt_Status_MIDDLE;
+    }
+    else
+    {
+      TopLoc_Location aLocation;
+      const TopoDS_Face& aF = TopoDS::Face (myShapeList2 (aFaceID2));
+      Handle (Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+
+      NCollection_Array1<Standard_Integer> aVtxIndicesOfTrg;
+      mySet2->GetVtxIndices (aTrgIdx, aVtxIndicesOfTrg);
+
+      if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_VERTEX)
+      {
+        Standard_Integer aNodeNum = myProxPrjState.GetNumberOfFirstNode();
+        Standard_Integer aNodeIdx = mySet2->GetVtxIdxInShape (aVtxIndicesOfTrg[aNodeNum]) + 1;
+
+        if (isNodeOnBorder (aNodeIdx, aTr))
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      }
+      else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
+      {
+        myPntStatus2 = ProxPnt_Status_MIDDLE;
+
+        Poly_Connect aPolyConnect (aTr);
+        Standard_Integer aTrgIdxInShape = mySet2->GetTrgIdxInShape (aTrgIdx) + 1;
+
+        Standard_Integer aAdjTrg[3];
+        aPolyConnect.Triangles (aTrgIdxInShape, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
+
+        for (Standard_Integer j = 0; j < 3; j++)
+        {
+          Standard_Integer k = (j + 1) % 3;
+          if (aAdjTrg[j] == 0) //free segment of triangle
+          {
+            //aVtxIndicesOfTrg[j] and aVtxIndicesOfTrg[k] are ends of free segment and it is a part of border
+            if (j == myProxPrjState.GetNumberOfFirstNode() &&
+                k == myProxPrjState.GetNumberOfLastNode())
+            {
+              myPntStatus2 = ProxPnt_Status_BORDER;
+              break;
+            }
+          }
+        }
+      } //else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
+    }
+  } //else if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_FACE)
+}
+
+//=======================================================================
+//function : DefineStatusProxPnt
+//purpose  : Defines the status of proximity points
+//=======================================================================
+void BRepExtrema_ProximityDistTool::DefineStatusProxPnt()
+{
+  // define the status of proximity point from 1st BVH
+  defineStatusProxPnt1();
+
+  // define the status of proximity point from 2nd BVH
+  defineStatusProxPnt2();
+}

src/BRepExtrema/BRepExtrema_ProximityDistTool.hxx

@@ -0,0 +1,200 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 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 _BRepExtrema_ProximityDistTool_HeaderFile
+#define _BRepExtrema_ProximityDistTool_HeaderFile
+
+#include <BRepExtrema_ElementFilter.hxx>
+#include <BRepExtrema_MapOfIntegerPackedMapOfInteger.hxx>
+#include <BRepExtrema_TriangleSet.hxx>
+#include <BVH_Distance.hxx>
+#include <BVH_Tools.hxx>
+
+//! Tool class for computation the proximity distance from first 
+//! primitive set to second one that is the maximal from minimum 
+//! perpendicular distances. If no perpendicular distance is found, the 
+//! minimum distance will be returned.
+//! This tool is not intended to be used independently, and is integrated
+//! in other classes, implementing algorithms based on shape tessellation
+//! (BRepExtrema_ProximityValueTool).
+//! 
+//! Please note that algorithm results are approximate and depend greatly
+//! on the quality of input tessellation(s).
+class BRepExtrema_ProximityDistTool : public BVH_Distance <Standard_Real, 3, BVH_Vec3d, 
+                                                           BRepExtrema_TriangleSet>
+{
+public:
+
+  typedef typename BVH_Tools<Standard_Real, 3>::BVH_PrjStateInTriangle BVH_PrjState;
+
+  enum ProxPnt_Status
+  {
+    ProxPnt_Status_BORDER,
+    ProxPnt_Status_MIDDLE,
+    ProxPnt_Status_UNKNOWN
+  };
+
+public:
+
+  //! Struct with information about projection point state from 2nd BVH,
+  //! providing proximity point of 2nd shape
+  struct PrjState
+  {
+    PrjState()
+    : myTrgIdx (0),
+      myPrjState (BVH_PrjState::BVH_PrjStateInTriangle_INNER),
+      myNumberOfFirstNode (0),
+      myNumberOfLastNode (0)
+    {}
+
+    PrjState (const Standard_Integer theTrgIdx,
+              const BVH_PrjState     thePrjState,
+              const Standard_Integer theNumberOfFirstNode,
+              const Standard_Integer theNumberOfLastNode)
+    : myTrgIdx (theTrgIdx),
+      myPrjState (thePrjState),
+      myNumberOfFirstNode (theNumberOfFirstNode),
+      myNumberOfLastNode (theNumberOfLastNode)
+    {}
+
+    Standard_Integer GetTrgIdx() const { return myTrgIdx; }
+
+    BVH_PrjState GetPrjState() const { return myPrjState; }
+
+    Standard_Integer GetNumberOfFirstNode() const { return myNumberOfFirstNode; }
+
+    Standard_Integer GetNumberOfLastNode() const { return myNumberOfLastNode; }
+
+  private:
+
+    Standard_Integer myTrgIdx; //!< Index of triangle on which the projection is located
+    BVH_PrjState myPrjState; //!< Position of a projection on the triangle (vertex, edge, inner)
+    Standard_Integer myNumberOfFirstNode; //!< The 1st vtx of the triangle edge on which the projection is located
+    Standard_Integer myNumberOfLastNode; //!< The 2nd vtx of the triangle edge on which the projection is located
+  };
+
+public:
+
+  //! Creates new unitialized tool.
+  Standard_EXPORT BRepExtrema_ProximityDistTool();
+
+  //! Creates new tool for the given element sets.
+  Standard_EXPORT BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                 const Standard_Integer theNbSamples1,
+                                                 const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                 const BRepExtrema_ShapeList& theShapeList1,
+                                                 const BRepExtrema_ShapeList& theShapeList2);
+
+public:
+
+  //! Loads the given element sets into the tool.
+  Standard_EXPORT void LoadTriangleSets (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                         const Handle(BRepExtrema_TriangleSet)& theSet2);
+
+  //! Loads the given list of subshapes into the tool.
+  Standard_EXPORT void LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                       const BRepExtrema_ShapeList& theShapeList2);
+
+  //! Performs searching of the proximity distance.
+  Standard_EXPORT void Perform();
+
+public: //! @name Reject/Accept implementations
+
+  //! Defines the rules for node rejection by bounding box.
+  Standard_EXPORT virtual Standard_Boolean RejectNode (const BVH_Vec3d& theCornerMin,
+                                                       const BVH_Vec3d& theCornerMax,
+                                                       Standard_Real& theMetric) const Standard_OVERRIDE;
+
+  //! Defines the rules for leaf acceptance.
+  Standard_EXPORT virtual Standard_Boolean Accept (const Standard_Integer theSgmIdx,
+                                                   const Standard_Real&) Standard_OVERRIDE;
+
+  //! Returns points on triangles sets, which provide the proximity distance.
+  void ProximityPoints (BVH_Vec3d& thePoint1, BVH_Vec3d& thePoint2) const
+  {
+    thePoint1 = myPnt1;
+    thePoint2 = myPnt2;
+  }
+
+  //! Returns status of points on triangles sets, which provide the proximity distance.
+  void ProximityPointsStatus (ProxPnt_Status& thePointStatus1, ProxPnt_Status& thePointStatus2) const
+  {
+    thePointStatus1 = myPntStatus1;
+    thePointStatus2 = myPntStatus2;
+  }
+
+  //! Returns the computed distance
+  Standard_Real ProximityDistance() const { return myProxDist; }
+
+protected:
+
+  //! Computes the distance between object and BVH tree.
+  Standard_EXPORT Standard_Real ComputeDistance();
+
+  //! Defines the status of proximity points.
+  Standard_EXPORT void DefineStatusProxPnt();
+
+private:
+
+  //! Defines the status of proximity point from 1st BVH.
+  void defineStatusProxPnt1();
+
+  //! Defines the status of proximity point from 2nd BVH.
+  void defineStatusProxPnt2();
+
+protected:
+
+  Standard_Real myMinDistance; //!< Minimal distance from point to BVH, could be not equal to myDistance
+  BVH_Vec3d myMinDistPoint; //!< Point on BVH providing the minimal distance
+
+  BVH_Vec3d myExtremaPoint; //!< Point on BVH providing the extrema
+
+  Standard_Real myProxDist; //!< Proximity distance
+
+  //! Proximity points
+  BVH_Vec3d myPnt1, myPnt2;
+
+  //! Proximity points' status
+  ProxPnt_Status myPntStatus1, myPntStatus2;
+
+private:
+
+  //! Set of all mesh elements (triangles) of the 1st shape.
+  Handle(BRepExtrema_TriangleSet) mySet1;
+  //! Set of all mesh elements (triangles) of the 2nd shape.
+  Handle(BRepExtrema_TriangleSet) mySet2;
+
+  //! List of subshapes of the 1st shape.
+  BRepExtrema_ShapeList myShapeList1;
+  //! List of subshapes of the 2nd shape.
+  BRepExtrema_ShapeList myShapeList2;
+
+  Standard_Integer myNbSamples1; //!< Number of samples points on the first shape
+
+  //! Vertex index from 1st BVH corresponding to proximity point of 1st shape
+  Standard_Integer myProxVtxIdx1;
+
+  //! Information of projection point state from 2nd BVH providing proximity point of 2nd shape
+  PrjState myProxPrjState;
+
+  //! Information of projection point state from 2nd BVH providing the extrema
+  PrjState myExtPrjState;
+
+  //! Information of projection point state from 2nd BVH providing the minimal distance
+  PrjState myMinPrjState;
+
+};
+
+#endif // _BRepExtrema_ProximityDistTool_HeaderFile

src/BRepExtrema/BRepExtrema_ProximityValueTool.cxx

@@ -0,0 +1,161 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 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 <BRepExtrema_ProximityValueTool.hxx>
+
+//=======================================================================
+//function : BRepExtrema_ProximityValueTool
+//purpose  : Creates new unitialized proximity tool
+//=======================================================================
+BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool()
+: myDistance (std::numeric_limits<Standard_Real>::max()),
+  myIsDone (Standard_False),
+  myNbSamples1(0),
+  myNbSamples2(0)
+{}
+
+//=======================================================================
+//function : BRepExtrema_ProximityValueTool
+//purpose  : Creates new proximity tool for the given element sets
+//=======================================================================
+BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                                const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                                const BRepExtrema_ShapeList& theShapeList1,
+                                                                const BRepExtrema_ShapeList& theShapeList2)
+: myDistance (std::numeric_limits<Standard_Real>::max()),
+  myIsDone (Standard_False),
+  myNbSamples1(0),
+  myNbSamples2(0)
+{
+  LoadTriangleSets (theSet1, theSet2);
+  LoadShapeLists (theShapeList1, theShapeList2);
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given element sets into the proximity tool
+//=======================================================================
+void BRepExtrema_ProximityValueTool::LoadTriangleSets (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                       const Handle(BRepExtrema_TriangleSet)& theSet2)
+{
+  mySet1 = theSet1;
+  mySet2 = theSet2;
+
+  myIsDone = Standard_False;
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given list of subshapes into the proximity tool
+//=======================================================================
+void BRepExtrema_ProximityValueTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                                     const BRepExtrema_ShapeList& theShapeList2)
+{
+  myShapeList1 = theShapeList1;
+  myShapeList2 = theShapeList2;
+
+  myIsDone = Standard_False;
+}
+
+//=======================================================================
+//function : SetNbSamplePoints
+//purpose  : Sets number of sample points used for proximity calculation for each shape
+//=======================================================================
+void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer theSamples1,
+                                                       const Standard_Integer theSamples2)
+{
+  myNbSamples1 = theSamples1;
+  myNbSamples2 = theSamples2;
+
+  myIsDone = Standard_False;
+}
+
+//=======================================================================
+//function : computeProximityValue
+//purpose  : Returns the computed proximity value from first BVH to another one
+//=======================================================================
+Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                                    const Standard_Integer theNbSamples1,
+                                                                    const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                                    const BRepExtrema_ShapeList& theShapeList1,
+                                                                    const BRepExtrema_ShapeList& theShapeList2,
+                                                                    BVH_Vec3d& thePoint1,
+                                                                    BVH_Vec3d& thePoint2,
+                                                                    ProxPnt_Status& thePointStatus1,
+                                                                    ProxPnt_Status& thePointStatus2) const
+{
+  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theSet2, theShapeList1, theShapeList2);
+  aProxDistTool.Perform();
+
+  if (!aProxDistTool.IsDone())
+    return -1.;
+
+  aProxDistTool.ProximityPoints (thePoint1, thePoint2);
+  aProxDistTool.ProximityPointsStatus (thePointStatus1, thePointStatus2);
+
+  return aProxDistTool.ProximityDistance();
+}
+
+//=======================================================================
+//function : Perform
+//purpose  : Performs the computation of the proximity value
+//=======================================================================
+void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
+{
+  myIsDone = Standard_False;
+
+  // max(min) dist from the 1st shape to the 2nd one
+  BVH_Vec3d aP1_1, aP1_2;
+  ProxPnt_Status aPointStatus1_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
+  ProxPnt_Status aPointStatus1_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
+
+  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, mySet2, myShapeList1, myShapeList2,
+                                                        aP1_1, aP1_2, aPointStatus1_1, aPointStatus1_2);
+
+  if (aProximityDist1 < 0.)
+    return;
+
+  // max(min) dist from the 2nd shape to t he 1st one
+  BVH_Vec3d aP2_1, aP2_2;
+  ProxPnt_Status aPointStatus2_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
+  ProxPnt_Status aPointStatus2_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
+
+  Standard_Real aProximityDist2 = computeProximityDist (mySet2, myNbSamples2, mySet1, myShapeList2, myShapeList1,
+                                                        aP2_2, aP2_1, aPointStatus2_2, aPointStatus2_1);
+
+  if (aProximityDist2 < 0.)
+    return;
+
+  // min dist of the two max(min) dists
+  if (aProximityDist1 < aProximityDist2)
+  {
+    myDistance = aProximityDist1;
+    myPnt1.SetCoord(aP1_1.x(), aP1_1.y(), aP1_1.z());
+    myPnt2.SetCoord(aP1_2.x(), aP1_2.y(), aP1_2.z());
+    myPntStatus1 = aPointStatus1_1;
+    myPntStatus2 = aPointStatus1_2;
+  }
+  else
+  {
+    myDistance = aProximityDist2;
+    myPnt1.SetCoord(aP2_1.x(), aP2_1.y(), aP2_1.z());
+    myPnt2.SetCoord(aP2_2.x(), aP2_2.y(), aP2_2.z());
+    myPntStatus1 = aPointStatus2_1;
+    myPntStatus2 = aPointStatus2_2;
+  }
+
+  myIsDone = Standard_True;
+  theTolerance = myDistance;
+}

src/BRepExtrema/BRepExtrema_ProximityValueTool.hxx

@@ -0,0 +1,126 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 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 _BRepExtrema_ProximityValueTool_HeaderFile
+#define _BRepExtrema_ProximityValueTool_HeaderFile
+
+#include <BRepExtrema_ProximityDistTool.hxx>
+#include <BRepExtrema_TriangleSet.hxx>
+
+//! Tool class for computation of the proximity value from one BVH
+//! primitive set to another, solving max(min) problem.
+//! This tool is not intended to be used independently, and is integrated
+//! in other classes, implementing algorithms based on shape tessellation
+//! (BRepExtrema_ShapeProximity and BRepExtrema_SelfIntersection).
+//! 
+//! Please note that algorithm results are approximate and depend greatly
+//! on the quality of input tessellation(s).
+class BRepExtrema_ProximityValueTool
+{
+public:
+  typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
+
+public:
+
+  //! Creates new unitialized proximity tool.
+  Standard_EXPORT BRepExtrema_ProximityValueTool();
+
+  //! Creates new proximity tool for the given element sets.
+  Standard_EXPORT BRepExtrema_ProximityValueTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                  const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                  const BRepExtrema_ShapeList& theShapeList1,
+                                                  const BRepExtrema_ShapeList& theShapeList2);
+
+public:
+
+  //! Loads the given element sets into the proximity tool.
+  Standard_EXPORT void LoadTriangleSets (const Handle (BRepExtrema_TriangleSet)& theSet1,
+                                         const Handle (BRepExtrema_TriangleSet)& theSet2);
+
+  //! Loads the given list of subshapes into the proximity tool.
+  Standard_EXPORT void LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                       const BRepExtrema_ShapeList& theShapeList2);
+
+  //! Sets number of sample points used for proximity calculation for each shape.
+  //! If number is less or equal zero, all triangulation nodes are used.
+  Standard_EXPORT void SetNbSamplePoints (const Standard_Integer theSamples1 = 0,
+                                          const Standard_Integer theSamples2 = 0);
+
+  //! Performs the computation of the proximity value.
+  Standard_EXPORT void Perform (Standard_Real& theTolerance);
+
+  //! Is proximity test completed?
+  Standard_Boolean IsDone() const { return myIsDone; }
+
+  //! Marks test results as outdated.
+  void MarkDirty() { myIsDone = Standard_False; }
+
+  //! Returns the computed distance.
+  Standard_Real Distance() const { return myDistance; }
+
+  //! Returns points on triangles sets, which provide the proximity distance.
+  void ProximityPoints(gp_Pnt& thePoint1, gp_Pnt& thePoint2) const
+  {
+    thePoint1 = myPnt1;
+    thePoint2 = myPnt2;
+  }
+
+  //! Returns status of points on triangles sets, which provide the proximity distance.
+  void ProximityPointsStatus (ProxPnt_Status& thePointStatus1, ProxPnt_Status& thePointStatus2) const
+  {
+    thePointStatus1 = myPntStatus1;
+    thePointStatus2 = myPntStatus2;
+  }
+
+private:
+
+  //! Returns the computed proximity value from first BVH to another one.
+  Standard_Real computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                      const Standard_Integer theNbSamples1,
+                                      const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                      const BRepExtrema_ShapeList& theShapeList1,
+                                      const BRepExtrema_ShapeList& theShapeList2,
+                                      BVH_Vec3d& thePoint1,
+                                      BVH_Vec3d& thePoint2,
+                                      ProxPnt_Status& thePointStatus1,
+                                      ProxPnt_Status& thePointStatus2) const;
+
+private:
+
+  //! Set of all mesh primitives of the 1st shape.
+  Handle(BRepExtrema_TriangleSet) mySet1;
+  //! Set of all mesh primitives of the 2nd shape.
+  Handle(BRepExtrema_TriangleSet) mySet2;
+
+  //! List of subshapes of the 1st shape.
+  BRepExtrema_ShapeList myShapeList1;
+  //! List of subshapes of the 2nd shape.
+  BRepExtrema_ShapeList myShapeList2;
+
+  Standard_Real myDistance;  //!< Distance
+  Standard_Boolean myIsDone; //!< State of the algorithm
+
+  Standard_Integer myNbSamples1; //!< Number of samples points on the first shape
+  Standard_Integer myNbSamples2; //!< Number of samples points on the second shape
+
+  //! Proximity points
+  gp_Pnt myPnt1, myPnt2;
+
+  //! Proximity points' status
+  ProxPnt_Status myPntStatus1, myPntStatus2;
+
+};
+
+#endif // _BRepExtrema_ProximityValueTool_HeaderFile

src/BRepExtrema/BRepExtrema_SelfIntersection.hxx

@@ -18,6 +18,8 @@
 
 #include <BRepExtrema_OverlapTool.hxx>
 
+#include <TopoDS.hxx>
+
 //! Tool class for detection of self-sections in the given shape.
 //! This class is based on BRepExtrema_OverlapTool and thus uses
 //! shape tessellation to detect incorrect mesh fragments (pairs
@@ -76,7 +78,7 @@ public:
   //! Returns sub-shape from the shape for the given index (started from 0).
   const TopoDS_Face& GetSubShape (const Standard_Integer theID) const
   {
-    return myFaceList.Value (theID);
+    return TopoDS::Face(myFaceList.Value(theID));
   }
 
   //! Returns set of all the face triangles of the shape.

src/BRepExtrema/BRepExtrema_ShapeProximity.cxx

@@ -18,6 +18,28 @@
 #include <Precision.hxx>
 #include <TopExp_Explorer.hxx>
 
+// Assign a map of sub-shapes (edges/faces) of a given shape
+static Standard_Boolean initSubShapes(const TopoDS_Shape&              theShape,
+                                      BRepExtrema_ShapeList&           theSubshapesList,
+                                      Handle(BRepExtrema_TriangleSet)& theTriangleSet)
+{
+  theSubshapesList.Clear();
+
+  for (TopExp_Explorer anIter(theShape, TopAbs_FACE); anIter.More(); anIter.Next())
+  {
+    theSubshapesList.Append(anIter.Current());
+  }
+
+  for (TopExp_Explorer anIter(theShape, TopAbs_EDGE); anIter.More(); anIter.Next())
+  {
+    theSubshapesList.Append(anIter.Current());
+  }
+
+  if (theTriangleSet.IsNull())
+    theTriangleSet = new BRepExtrema_TriangleSet;
+  return theTriangleSet->Init(theSubshapesList);
+}
+
 //=======================================================================
 //function : BRepExtrema_ShapeProximity
 //purpose  : Creates uninitialized proximity tool
@@ -25,7 +47,9 @@
 BRepExtrema_ShapeProximity::BRepExtrema_ShapeProximity (const Standard_Real theTolerance)
 : myTolerance   (theTolerance),
   myElementSet1 (new BRepExtrema_TriangleSet),
-  myElementSet2 (new BRepExtrema_TriangleSet)
+  myElementSet2 (new BRepExtrema_TriangleSet),
+  myNbSamples1  (0),
+  myNbSamples2  (0)
 {
   // Should be initialized later
   myIsInitS1 = myIsInitS2 = Standard_False;
@@ -40,7 +64,9 @@ BRepExtrema_ShapeProximity::BRepExtrema_ShapeProximity (const TopoDS_Shape& theS
                                                         const Standard_Real theTolerance)
 : myTolerance   (theTolerance),
   myElementSet1 (new BRepExtrema_TriangleSet),
-  myElementSet2 (new BRepExtrema_TriangleSet)
+  myElementSet2 (new BRepExtrema_TriangleSet),
+  myNbSamples1  (0),
+  myNbSamples2  (0)
 {
   LoadShape1 (theShape1);
   LoadShape2 (theShape2);
@@ -52,16 +78,18 @@ BRepExtrema_ShapeProximity::BRepExtrema_ShapeProximity (const TopoDS_Shape& theS
 //=======================================================================
 Standard_Boolean BRepExtrema_ShapeProximity::LoadShape1 (const TopoDS_Shape& theShape1)
 {
-  myFaceList1.Clear();
+  myIsInitS1 = initSubShapes(theShape1, myShapeList1, myElementSet1);
 
-  for (TopExp_Explorer anIter (theShape1, TopAbs_FACE); anIter.More(); anIter.Next())
+  if (myTolerance == Precision::Infinite())
   {
-    myFaceList1.Append (static_cast<const TopoDS_Face&> (anIter.Current()));
+    myProxValTool.MarkDirty();
+  }
+  else
+  {
+    myOverlapTool.MarkDirty();
   }
 
-  myOverlapTool.MarkDirty();
-
-  return myIsInitS1 = myElementSet1->Init (myFaceList1);
+  return myIsInitS1;
 }
 
 //=======================================================================
@@ -70,16 +98,18 @@ Standard_Boolean BRepExtrema_ShapeProximity::LoadShape1 (const TopoDS_Shape& the
 //=======================================================================
 Standard_Boolean BRepExtrema_ShapeProximity::LoadShape2 (const TopoDS_Shape& theShape2)
 {
-  myFaceList2.Clear();
+  myIsInitS2 = initSubShapes(theShape2, myShapeList2, myElementSet2);
 
-  for (TopExp_Explorer anIter (theShape2, TopAbs_FACE); anIter.More(); anIter.Next())
+  if (myTolerance == Precision::Infinite())
   {
-    myFaceList2.Append (static_cast<const TopoDS_Face&> (anIter.Current()));
+    myProxValTool.MarkDirty();
+  }
+  else
+  {
+    myOverlapTool.MarkDirty();
   }
 
-  myOverlapTool.MarkDirty();
-
-  return myIsInitS2 = myElementSet2->Init (myFaceList2);
+  return myIsInitS2;
 }
 
 //=======================================================================
@@ -87,6 +117,24 @@ Standard_Boolean BRepExtrema_ShapeProximity::LoadShape2 (const TopoDS_Shape& the
 //purpose  : Performs search of overlapped faces
 //=======================================================================
 void BRepExtrema_ShapeProximity::Perform()
+{
+  if (myTolerance == Precision::Infinite())
+  {
+    if (!myIsInitS1 || !myIsInitS2 || myProxValTool.IsDone())
+    {
+      return;
+    }
+
+    myProxValTool.LoadTriangleSets (myElementSet1,
+                                    myElementSet2);
+    myProxValTool.LoadShapeLists (myShapeList1,
+                                  myShapeList2);
+
+    myProxValTool.Perform (myTolerance);
+    myProxValTool.ProximityPoints(myProxPoint1, myProxPoint2);
+    myProxValTool.ProximityPointsStatus (myProxPntStatus1, myProxPntStatus2);
+  }
+  else
   {
     if (!myIsInitS1 || !myIsInitS2 || myOverlapTool.IsDone())
     {
@@ -98,3 +146,4 @@ void BRepExtrema_ShapeProximity::Perform()
 
     myOverlapTool.Perform (myTolerance);
   }
+}

src/BRepExtrema/BRepExtrema_ShapeProximity.hxx

@@ -16,31 +16,48 @@
 #ifndef _BRepExtrema_ShapeProximity_HeaderFile
 #define _BRepExtrema_ShapeProximity_HeaderFile
 
+#include <NCollection_DataMap.hxx>
+#include <Precision.hxx>
+#include <TColStd_PackedMapOfInteger.hxx>
+
+#include <BRepExtrema_ProximityValueTool.hxx>
+#include <BRepExtrema_TriangleSet.hxx>
 #include <BRepExtrema_OverlapTool.hxx>
 
-//! Tool class for shape proximity detection.
+//! @brief Tool class for shape proximity detection.
+//!
+//! First approach:
 //! For two given shapes and given tolerance (offset from the mesh) the algorithm allows
 //! to determine whether or not they are overlapped. The algorithm input consists of any
 //! shapes which can be decomposed into individual faces (used as basic shape elements).
-//! High performance is achieved through the use of existing triangulation of faces. So
-//! poly triangulation (with the desired deflection) should already be built. Note that
-//! solution is approximate (and corresponds to the deflection used for triangulation).
 //!
 //! The algorithm can be run in two modes. If tolerance is set to zero, the algorithm
 //! will detect only intersecting faces (containing triangles with common points). If
 //! tolerance is set to positive value, the algorithm will also detect faces located
 //! on distance less than the given tolerance from each other.
+//!
+//! Second approach:
+//! Compute the proximity value between two shapes if the tolerance is not defined (Precision::Infinite()).
+//! In this case the proximity value is a minimal thickness of a layer containing both shapes.
+//!
+//! For the both approaches the high performance is achieved through the use of existing
+//! triangulation of faces. So, poly triangulation (with the desired deflection) should already
+//! be built. Note that solution is approximate (and corresponds to the deflection used for
+//! triangulation).
 class BRepExtrema_ShapeProximity
 {
+public:
+  typedef typename BRepExtrema_ProximityValueTool::ProxPnt_Status ProxPnt_Status;
+
 public:
 
   //! Creates empty proximity tool.
-  Standard_EXPORT BRepExtrema_ShapeProximity (const Standard_Real theTolerance = 0.0);
+  Standard_EXPORT BRepExtrema_ShapeProximity (const Standard_Real theTolerance = Precision::Infinite());
 
   //! Creates proximity tool for the given two shapes.
   Standard_EXPORT BRepExtrema_ShapeProximity (const TopoDS_Shape& theShape1,
                                               const TopoDS_Shape& theShape2,
-                                              const Standard_Real theTolerance = 0.0);
+                                              const Standard_Real theTolerance = Precision::Infinite());
 
 public:
 
@@ -56,19 +73,33 @@ public:
     myTolerance = theTolerance;
   }
 
+  //! Returns proximity value calculated for the whole input shapes.
+  Standard_Real Proximity() const
+  {
+    return Tolerance();
+  }
+
   //! Loads 1st shape into proximity tool.
   Standard_EXPORT Standard_Boolean LoadShape1 (const TopoDS_Shape& theShape1);
 
   //! Loads 2nd shape into proximity tool.
   Standard_EXPORT Standard_Boolean LoadShape2 (const TopoDS_Shape& theShape2);
 
+  //! Set number of sample points on the 1st shape used to compute the proximity value.
+  //! In case of 0, all triangulation nodes will be used.
+  void SetNbSamples1(const Standard_Integer theNbSamples) { myNbSamples1 = theNbSamples; }
+
+  //! Set number of sample points on the 2nd shape used to compute the proximity value.
+  //! In case of 0, all triangulation nodes will be used.
+  void SetNbSamples2(const Standard_Integer theNbSamples) { myNbSamples2 = theNbSamples; }
+
   //! Performs search of overlapped faces.
   Standard_EXPORT void Perform();
 
   //! True if the search is completed.
   Standard_Boolean IsDone() const
   { 
-    return myOverlapTool.IsDone();
+    return myOverlapTool.IsDone() || myProxValTool.IsDone();
   }
 
   //! Returns set of IDs of overlapped faces of 1st shape (started from 0).
@@ -84,15 +115,15 @@ public:
   }
 
   //! Returns sub-shape from 1st shape with the given index (started from 0).
-  const TopoDS_Face& GetSubShape1 (const Standard_Integer theID) const
+  const TopoDS_Shape& GetSubShape1 (const Standard_Integer theID) const
   {
-    return myFaceList1.Value (theID);
+    return myShapeList1.Value (theID);
   }
 
   //! Returns sub-shape from 1st shape with the given index (started from 0).
-  const TopoDS_Face& GetSubShape2 (const Standard_Integer theID) const
+  const TopoDS_Shape& GetSubShape2 (const Standard_Integer theID) const
   {
-    return myFaceList2.Value (theID);
+    return myShapeList2.Value (theID);
   }
 
   //! Returns set of all the face triangles of the 1st shape.
@@ -107,6 +138,34 @@ public:
     return myElementSet2;
   }
 
+  //! Returns the point on the 1st shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const gp_Pnt& ProximityPoint1() const
+  {
+    return myProxPoint1;
+  }
+
+  //! Returns the point on the 2nd shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const gp_Pnt& ProximityPoint2() const
+  {
+    return myProxPoint2;
+  }
+
+  //! Returns the status of point on the 1st shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const ProxPnt_Status& ProxPntStatus1() const
+  {
+    return myProxPntStatus1;
+  }
+
+  //! Returns the status of point on the 2nd shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const ProxPnt_Status& ProxPntStatus2() const
+  {
+    return myProxPntStatus2;
+  }
+
 private:
 
   //! Maximum overlapping distance.
@@ -117,19 +176,39 @@ private:
   //! Is the 2nd shape initialized?
   Standard_Boolean myIsInitS2;
 
-  //! List of faces of the 1st shape.
-  BRepExtrema_ShapeList myFaceList1;
-  //! List of faces of the 2nd shape.
-  BRepExtrema_ShapeList myFaceList2;
+  //! List of subshapes of the 1st shape.
+  BRepExtrema_ShapeList myShapeList1;
+  //! List of subshapes of the 2nd shape.
+  BRepExtrema_ShapeList myShapeList2;
 
   //! Set of all the face triangles of the 1st shape.
   Handle(BRepExtrema_TriangleSet) myElementSet1;
   //! Set of all the face triangles of the 2nd shape.
   Handle(BRepExtrema_TriangleSet) myElementSet2;
 
+  //! Number of sample points on the 1st shape used to compute the proximity value
+  //! (if zero (default), all triangulation nodes will be used).
+  Standard_Integer myNbSamples1;
+  //! Number of sample points on the 2nd shape used to compute the proximity value
+  //! (if zero (default), all triangulation nodes will be used).
+  Standard_Integer myNbSamples2;
+
+  //! Reference point of the proximity value on the 1st shape.
+  gp_Pnt myProxPoint1;
+  //! Reference point of the proximity value on the 2st shape.
+  gp_Pnt myProxPoint2;
+
+  //! Status of reference points of the proximity value.
+  ProxPnt_Status myProxPntStatus1, myProxPntStatus2;
+
   //! Overlap tool used for intersection/overlap test.
   BRepExtrema_OverlapTool myOverlapTool;
 
+  //! Shape-shape proximity tool used for computation of
+  //! the minimal diameter of a tube containing both edges or
+  //! the minimal thickness of a shell containing both faces.
+  BRepExtrema_ProximityValueTool myProxValTool;
+
 };
 
 #endif // _BRepExtrema_ShapeProximity_HeaderFile

src/BRepExtrema/BRepExtrema_TriangleSet.cxx

@@ -18,6 +18,7 @@
 #include <BRep_Tool.hxx>
 #include <BVH_LinearBuilder.hxx>
 #include <Poly_Triangulation.hxx>
+#include <TopoDS.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)
 
@@ -114,17 +115,65 @@ void BRepExtrema_TriangleSet::Swap (const Standard_Integer theIndex1, const Stan
 {
   std::swap (myTriangles[theIndex1],
              myTriangles[theIndex2]);
+
+  std::swap (myTrgIdxMap (theIndex1),
+             myTrgIdxMap (theIndex2));
 }
 
 //=======================================================================
 //function : GetFaceID
-//purpose  : Returns face ID of the given triangle
+//purpose  : Returns face ID of the given vertex
 //=======================================================================
 Standard_Integer BRepExtrema_TriangleSet::GetFaceID (const Standard_Integer theIndex) const
 {
   return myTriangles[theIndex].w();
 }
 
+//=======================================================================
+//function : GetShapeIDOfVtx
+//purpose  : Returns shape ID of the given vertex index
+//=======================================================================
+Standard_Integer BRepExtrema_TriangleSet::GetShapeIDOfVtx (const Standard_Integer theIndex) const
+{
+  return myShapeIdxOfVtxVec.Value (theIndex);
+}
+
+//=======================================================================
+//function : GetVtxIdxInShape
+//purpose  : Returns vertex index in tringulation of the shape, which vertex belongs,
+//           with the given vtx ID in whole set
+//=======================================================================
+Standard_Integer BRepExtrema_TriangleSet::GetVtxIdxInShape (const Standard_Integer theIndex) const
+{
+  Standard_Integer aShID = myShapeIdxOfVtxVec.Value (theIndex);
+  Standard_Integer aNumVertices = 0;
+
+  for (Standard_Integer aSIdx = 0; aSIdx < aShID; aSIdx++)
+  {
+    aNumVertices += myNumVtxInShapeVec.Value (aSIdx);
+  }
+
+  return theIndex - aNumVertices;
+}
+
+//=======================================================================
+//function : GetTrgIdxInShape
+//purpose  :  Returns triangle index (before swapping) in tringulation of the shape, which triangle belongs,
+//            with the given trg ID in whole set (after swapping)
+//=======================================================================
+Standard_Integer BRepExtrema_TriangleSet::GetTrgIdxInShape (const Standard_Integer theIndex) const
+{
+  Standard_Integer aShID = GetFaceID (theIndex);
+  Standard_Integer aNumTriangles = 0;
+
+  for (Standard_Integer aSIdx = 0; aSIdx < aShID; aSIdx++)
+  {
+    aNumTriangles += myNumTrgInShapeVec.Value (aSIdx);
+  }
+
+  return myTrgIdxMap (theIndex) - aNumTriangles;
+}
+
 //=======================================================================
 //function : GetVertices
 //purpose  : Returns vertices of the given triangle
@@ -141,6 +190,21 @@ void BRepExtrema_TriangleSet::GetVertices (const Standard_Integer theIndex,
   theVertex3 = myVertexArray[aTriangle.z()];
 }
 
+//=======================================================================
+//function : GetVertices
+//purpose  : Returns vertices of the given triangle
+//=======================================================================
+void BRepExtrema_TriangleSet::GetVtxIndices (const Standard_Integer theIndex,
+                                             NCollection_Array1<Standard_Integer>& theVtxIndices) const
+{
+  BVH_Vec4i aTriangle = myTriangles[theIndex];
+
+  theVtxIndices = NCollection_Array1<Standard_Integer> (0, 2);
+  theVtxIndices.SetValue (0, aTriangle.x());
+  theVtxIndices.SetValue (1, aTriangle.y());
+  theVtxIndices.SetValue (2, aTriangle.z());
+}
+
 //=======================================================================
 //function : Clear
 //purpose  : Clears triangle set data
@@ -158,41 +222,26 @@ void BRepExtrema_TriangleSet::Clear()
 //function : Init
 //purpose  : Initializes triangle set
 //=======================================================================
-Standard_Boolean BRepExtrema_TriangleSet::Init (const BRepExtrema_ShapeList& theFaces)
+Standard_Boolean BRepExtrema_TriangleSet::Init (const BRepExtrema_ShapeList& theShapes)
 {
   Clear();
 
-  for (Standard_Integer aFaceIdx = 0; aFaceIdx < theFaces.Size(); ++aFaceIdx)
+  Standard_Boolean isOK = Standard_True;
+  for (Standard_Integer aShapeIdx = 0; aShapeIdx < theShapes.Size() && isOK; ++aShapeIdx)
   {
-    TopLoc_Location aLocation;
-
-    Handle(Poly_Triangulation) aTriangulation =
-      BRep_Tool::Triangulation (theFaces (aFaceIdx), aLocation);
-
-    if (aTriangulation.IsNull())
-    {
-      return Standard_False;
+    if (theShapes (aShapeIdx).ShapeType() == TopAbs_FACE)
+      isOK = initFace (TopoDS::Face (theShapes(aShapeIdx)), aShapeIdx);
+    else if (theShapes (aShapeIdx).ShapeType() == TopAbs_EDGE)
+      isOK = initEdge (TopoDS::Edge (theShapes(aShapeIdx)), aShapeIdx);
   }
 
-    const Standard_Integer aVertOffset =
-      static_cast<Standard_Integer> (myVertexArray.size()) - 1;
+  Standard_Integer aNumTrg = static_cast<Standard_Integer> (myTriangles.size());
+  myTrgIdxMap.Clear();
+  myTrgIdxMap.ReSize (aNumTrg);
 
-    for (Standard_Integer aVertIdx = 1; aVertIdx <= aTriangulation->NbNodes(); ++aVertIdx)
+  for (Standard_Integer aTrgIdx = 0; aTrgIdx < aNumTrg; ++aTrgIdx)
   {
-      gp_Pnt aVertex = aTriangulation->Node (aVertIdx);
-      aVertex.Transform (aLocation.Transformation());
-      myVertexArray.push_back (BVH_Vec3d (aVertex.X(), aVertex.Y(), aVertex.Z()));
-    }
-
-    for (Standard_Integer aTriIdx = 1; aTriIdx <= aTriangulation->NbTriangles(); ++aTriIdx)
-    {
-      Standard_Integer aVertex1, aVertex2, aVertex3;
-      aTriangulation->Triangle (aTriIdx).Get (aVertex1, aVertex2, aVertex3);
-      myTriangles.push_back (BVH_Vec4i (aVertex1 + aVertOffset,
-                                        aVertex2 + aVertOffset,
-                                        aVertex3 + aVertOffset,
-                                        aFaceIdx));
-    }
+    myTrgIdxMap.Bind (aTrgIdx, aTrgIdx);
   }
 
   MarkDirty(); // needs BVH rebuilding
@@ -203,3 +252,95 @@ Standard_Boolean BRepExtrema_TriangleSet::Init (const BRepExtrema_ShapeList& the
   return Standard_True;
 }
 
+//=======================================================================
+//function : initFace
+//purpose  : Initializes triangle set
+//=======================================================================
+Standard_Boolean BRepExtrema_TriangleSet::initFace (const TopoDS_Face& theFace, const Standard_Integer theIndex)
+{
+  TopLoc_Location aLocation;
+
+  Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (theFace, aLocation);
+  if (aTriangulation.IsNull())
+  {
+    return Standard_False;
+  }
+
+  const Standard_Integer aVertOffset =
+    static_cast<Standard_Integer> (myVertexArray.size()) - 1;
+
+  initNodes (aTriangulation->MapNodeArray()->ChangeArray1(), aLocation.Transformation(), theIndex);
+
+  for (Standard_Integer aTriIdx = 1; aTriIdx <= aTriangulation->NbTriangles(); ++aTriIdx)
+  {
+    Standard_Integer aVertex1;
+    Standard_Integer aVertex2;
+    Standard_Integer aVertex3;
+
+    aTriangulation->Triangle (aTriIdx).Get (aVertex1,
+                                            aVertex2,
+                                            aVertex3);
+
+    myTriangles.push_back (BVH_Vec4i (aVertex1 + aVertOffset,
+                                      aVertex2 + aVertOffset,
+                                      aVertex3 + aVertOffset,
+                                      theIndex));
+  }
+
+  myNumTrgInShapeVec.SetValue (theIndex, aTriangulation->NbTriangles());
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : initEdge
+//purpose  : Initializes triangle set
+//=======================================================================
+Standard_Boolean BRepExtrema_TriangleSet::initEdge (const TopoDS_Edge& theEdge, const Standard_Integer theIndex)
+{
+  TopLoc_Location aLocation;
+
+  Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (theEdge, aLocation);
+  if (aPolygon.IsNull())
+  {
+    return Standard_False;
+  }
+
+  const Standard_Integer aVertOffset =
+    static_cast<Standard_Integer> (myVertexArray.size()) - 1;
+
+  initNodes (aPolygon->Nodes(), aLocation.Transformation(), theIndex);
+
+  for (Standard_Integer aVertIdx = 1; aVertIdx < aPolygon->NbNodes(); ++aVertIdx)
+  {
+    // segment as degenerate triangle
+    myTriangles.push_back (BVH_Vec4i (aVertIdx + aVertOffset,
+                                      aVertIdx + aVertOffset + 1,
+                                      aVertIdx + aVertOffset + 1,
+                                      theIndex));
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : initNodes
+//purpose  : Initializes nodes
+//=======================================================================
+void BRepExtrema_TriangleSet::initNodes (const TColgp_Array1OfPnt& theNodes,
+                                         const gp_Trsf& theTrsf,
+                                         const Standard_Integer theIndex)
+{
+  for (Standard_Integer aVertIdx = 1; aVertIdx <= theNodes.Size(); ++aVertIdx)
+  {
+    gp_Pnt aVertex = theNodes.Value (aVertIdx);
+
+    aVertex.Transform (theTrsf);
+
+    myVertexArray.push_back (BVH_Vec3d (aVertex.X(),
+                                        aVertex.Y(),
+                                        aVertex.Z()));
+    myShapeIdxOfVtxVec.Append (theIndex);
+  }
+
+  myNumVtxInShapeVec.SetValue (theIndex, theNodes.Size());
+}

src/BRepExtrema/BRepExtrema_TriangleSet.hxx

@@ -16,11 +16,14 @@
 #ifndef _BRepExtrema_TriangleSet_HeaderFile
 #define _BRepExtrema_TriangleSet_HeaderFile
 
-#include <TopoDS_Face.hxx>
 #include <BVH_PrimitiveSet3d.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColStd_DataMapOfIntegerInteger.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
 
 //! List of shapes and their IDs for collision detection.
-typedef NCollection_Vector<TopoDS_Face> BRepExtrema_ShapeList;
+typedef NCollection_Vector<TopoDS_Shape> BRepExtrema_ShapeList;
 
 //! Triangle set corresponding to specific face.
 class BRepExtrema_TriangleSet : public BVH_PrimitiveSet3d
@@ -59,7 +62,10 @@ public:
   Standard_EXPORT void Clear();
 
   //! Initializes triangle set.
-  Standard_EXPORT Standard_Boolean Init (const BRepExtrema_ShapeList& theFaces);
+  Standard_EXPORT Standard_Boolean Init (const BRepExtrema_ShapeList& theShapes);
+
+  //! Returns all vertices.
+  Standard_EXPORT const BVH_Array3d& GetVertices() const { return myVertexArray; }
 
   //! Returns vertices of the given triangle.
   Standard_EXPORT void GetVertices (const Standard_Integer theIndex,
@@ -67,9 +73,37 @@ public:
                                     BVH_Vec3d&             theVertex2,
                                     BVH_Vec3d&             theVertex3) const;
 
+  //! Returns vertex indices of the given triangle.
+  Standard_EXPORT void GetVtxIndices (const Standard_Integer theIndex,
+                                      NCollection_Array1<Standard_Integer>& theVtxIndices) const;
+
   //! Returns face ID of the given triangle.
   Standard_EXPORT Standard_Integer GetFaceID (const Standard_Integer theIndex) const;
 
+  //! Returns shape ID of the given vertex index.
+  Standard_EXPORT Standard_Integer GetShapeIDOfVtx (const Standard_Integer theIndex) const;
+
+  //! Returns vertex index in tringulation of the shape, which vertex belongs,
+  //! with the given vtx ID in whole set.
+  Standard_EXPORT Standard_Integer GetVtxIdxInShape (const Standard_Integer theIndex) const;
+
+  //! Returns triangle index (before swapping) in tringulation of the shape, which triangle belongs,
+  //! with the given trg ID in whole set (after swapping).
+  Standard_EXPORT Standard_Integer GetTrgIdxInShape (const Standard_Integer theIndex) const;
+
+private:
+
+  //! Initializes triangle set from the face
+  Standard_Boolean initFace (const TopoDS_Face& theFace, const Standard_Integer theIndex);
+
+  //! Initializes polygon from the edge
+  Standard_Boolean initEdge (const TopoDS_Edge& theEdge, const Standard_Integer theIndex);
+
+  //! Initializes nodes
+  void initNodes (const TColgp_Array1OfPnt& theNodes,
+                  const gp_Trsf& theTrsf,
+                  const Standard_Integer theIndex);
+
 protected:
 
   //! Array of vertex indices.
@@ -78,6 +112,19 @@ protected:
   //! Array of vertex coordinates.
   BVH_Array3d myVertexArray;
 
+  //! Vector of shapes' indices where index of item corresponds to index of vertex,
+  //! belonging to this shape.
+  NCollection_Vector<Standard_Integer> myShapeIdxOfVtxVec;
+
+  //! Vector of vertexes' number belonging to shape which index corresponds item's index.
+  NCollection_Vector<Standard_Integer> myNumVtxInShapeVec;
+
+  //! Vector of triangles' number belonging to shape which index corresponds item's index.
+  NCollection_Vector<Standard_Integer> myNumTrgInShapeVec;
+
+  //! Map of triangles' indices after (key) and before (value) swapping.
+  TColStd_DataMapOfIntegerInteger myTrgIdxMap;
+
 public:
 
   DEFINE_STANDARD_RTTIEXT(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)

src/BRepExtrema/FILES

@@ -18,6 +18,10 @@ BRepExtrema_OverlapTool.cxx
 BRepExtrema_OverlapTool.hxx
 BRepExtrema_Poly.cxx
 BRepExtrema_Poly.hxx
+BRepExtrema_ProximityValueTool.cxx
+BRepExtrema_ProximityValueTool.hxx
+BRepExtrema_ProximityDistTool.cxx
+BRepExtrema_ProximityDistTool.hxx
 BRepExtrema_SelfIntersection.cxx
 BRepExtrema_SelfIntersection.hxx
 BRepExtrema_SeqOfSolution.hxx

src/BRepFill/BRepFill_CompatibleWires.cxx

@@ -1585,7 +1585,7 @@ void BRepFill_CompatibleWires::ComputeOrigin(const  Standard_Boolean /*polar*/ )
     NbSamples = 4;
   gp_Pln FirstPlane;
   PlaneOfWire(TopoDS::Wire(myWork(ideb)), FirstPlane);
-  gp_Pnt FirstBary = FirstPlane.Location();
+  gp_Pnt PrevBary = FirstPlane.Location();
   gp_Vec NormalOfFirstPlane = FirstPlane.Axis().Direction();
   for (i = ideb+1; i <= ifin; i++)
     {
@@ -1596,10 +1596,10 @@ void BRepFill_CompatibleWires::ComputeOrigin(const  Standard_Boolean /*polar*/ )
       gp_Pln CurPlane;
       PlaneOfWire(aWire, CurPlane);
       gp_Pnt CurBary = CurPlane.Location();
-      gp_Vec aVec(FirstBary, CurBary);
+      gp_Vec aVec(PrevBary, CurBary);
       gp_Vec anOffsetProj = (aVec * NormalOfFirstPlane) * NormalOfFirstPlane;
       CurBary.Translate(-anOffsetProj); //projected current bary center
-      gp_Vec Offset(CurBary, FirstBary);
+      gp_Vec Offset(CurBary, PrevBary);
       
       TopoDS_Wire newwire;
       BRep_Builder BB;
@@ -1804,6 +1804,8 @@ void BRepFill_CompatibleWires::ComputeOrigin(const  Standard_Boolean /*polar*/ )
       newwire.Closed( Standard_True );
       newwire.Orientation( TopAbs_FORWARD );
       myWork(i) = newwire;
+
+      PrevBary = CurBary;
     }
 #ifdef OCCT_DEBUG_EFV
 

src/BRepFill/BRepFill_Sweep.cxx

@@ -3002,7 +3002,7 @@ void BRepFill_Sweep::Build(TopTools_MapOfShape& ReversedEdges,
         }
       }
 
-    if (aNbFaces == 0)
+    if ((NbTrous > 0) ? (aNbFaces < NbLaw) : (aNbFaces == 0))
     {
       isDone = Standard_False;
       return;

src/BRepLib/BRepLib_FindSurface.cxx

@@ -506,7 +506,14 @@ void BRepLib_FindSurface::Init(const TopoDS_Shape&    S,
 
   if (!isSolved)
     return;
-
+  //Removing very small values
+  Standard_Real aMaxV = Max(Abs(aVec(1)), Max(Abs(aVec(2)), Abs(aVec(3))));
+  Standard_Real eps = Epsilon(aMaxV);
+  for (i = 1; i <= 3; ++i)
+  {
+    if (Abs(aVec(i)) <= eps)
+      aVec(i) = 0.;
+  }
   gp_Vec aN (aVec (1), aVec (2), aVec (3));
   Handle(Geom_Plane) aPlane = new Geom_Plane (aBaryCenter, aN);
   myTolReached = Controle (aPoints, aPlane);

src/BRepMesh/BRepMesh_ConeRangeSplitter.cxx

@@ -41,10 +41,13 @@ std::pair<Standard_Real, Standard_Real> BRepMesh_ConeRangeSplitter::GetSplitStep
 
   const Standard_Real aDiffU = aRangeU.second - aRangeU.first;
   const Standard_Real aDiffV = aRangeV.second - aRangeV.first;
-  Standard_Integer nbU = (Standard_Integer) (aDiffU / Du);
-  Standard_Integer nbV = (Standard_Integer) (nbU * (aDiffV) / (aDiffU * aRadius));
+  const Standard_Real aScale = (Du * aRadius);
+  const Standard_Real aRatio = Max(1., Log(aDiffV / aScale));
+  const Standard_Integer nbU = (Standard_Integer)(aDiffU / Du);
+  const Standard_Integer nbV = (Standard_Integer)(aDiffV / aScale / aRatio);
+
   Du = aDiffU / (nbU + 1);
-  Dv = aDiffV / (nbV + 1);
+  Dv = aDiffV / (nbV + static_cast<Standard_Integer>(aRatio));
 
   theStepsNb.first  = nbU;
   theStepsNb.second = nbV;

src/BRepMesh/BRepMesh_CurveTessellator.cxx

@@ -35,11 +35,13 @@ IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_CurveTessellator, IMeshTools_CurveTessellato
 //=======================================================================
 BRepMesh_CurveTessellator::BRepMesh_CurveTessellator(
   const IMeshData::IEdgeHandle& theEdge,
-  const IMeshTools_Parameters&  theParameters)
+  const IMeshTools_Parameters&  theParameters,
+  const Standard_Integer        theMinPointsNb)
   : myDEdge(theEdge),
     myParameters(theParameters),
     myEdge(theEdge->GetEdge()),
-    myCurve(myEdge)
+    myCurve(myEdge),
+    myMinPointsNb (theMinPointsNb)
 {
   init();
 }
@@ -52,11 +54,13 @@ BRepMesh_CurveTessellator::BRepMesh_CurveTessellator (
   const IMeshData::IEdgeHandle& theEdge,
   const TopAbs_Orientation      theOrientation,
   const IMeshData::IFaceHandle& theFace,
-  const IMeshTools_Parameters&  theParameters)
+  const IMeshTools_Parameters&  theParameters,
+  const Standard_Integer        theMinPointsNb)
   : myDEdge(theEdge),
     myParameters(theParameters),
     myEdge(TopoDS::Edge(theEdge->GetEdge().Oriented(theOrientation))),
-    myCurve(myEdge, theFace->GetFace())
+    myCurve(myEdge, theFace->GetFace()),
+    myMinPointsNb (theMinPointsNb)
 {
   init();
 }
@@ -97,7 +101,8 @@ void BRepMesh_CurveTessellator::init()
   myEdgeSqTol  = BRep_Tool::Tolerance (myEdge);
   myEdgeSqTol *= myEdgeSqTol;
 
-  const Standard_Integer aMinPntNb = (myCurve.GetType() == GeomAbs_Circle) ? 4 : 2; //OCC287
+  const Standard_Integer aMinPntNb = Max(myMinPointsNb,
+    (myCurve.GetType() == GeomAbs_Circle) ? 4 : 2); //OCC287
 
   myDiscretTool.Initialize (myCurve,
                             myCurve.FirstParameter(), myCurve.LastParameter(),

src/BRepMesh/BRepMesh_CurveTessellator.hxx

@@ -34,14 +34,16 @@ public:
   //! Constructor.
   Standard_EXPORT BRepMesh_CurveTessellator(
     const IMeshData::IEdgeHandle& theEdge,
-    const IMeshTools_Parameters&  theParameters);
+    const IMeshTools_Parameters&  theParameters,
+    const Standard_Integer        theMinPointsNb = 2);
 
   //! Constructor.
   Standard_EXPORT BRepMesh_CurveTessellator (
     const IMeshData::IEdgeHandle& theEdge,
     const TopAbs_Orientation      theOrientation,
     const IMeshData::IFaceHandle& theFace,
-    const IMeshTools_Parameters&  theParameters);
+    const IMeshTools_Parameters&  theParameters,
+    const Standard_Integer        theMinPointsNb = 2);
 
   //! Destructor.
   Standard_EXPORT virtual ~BRepMesh_CurveTessellator ();
@@ -96,6 +98,7 @@ private:
   const IMeshTools_Parameters&  myParameters;
   TopoDS_Edge                   myEdge;
   BRepAdaptor_Curve             myCurve;
+  Standard_Integer              myMinPointsNb;
   GCPnts_TangentialDeflection   myDiscretTool;
   TopoDS_Vertex                 myFirstVertex;
   TopoDS_Vertex                 myLastVertex;

src/BRepMesh/BRepMesh_DefaultRangeSplitter.cxx

@@ -124,10 +124,12 @@ void BRepMesh_DefaultRangeSplitter::computeTolerance(
   const Standard_Real aDiffU = myRangeU.second - myRangeU.first;
   const Standard_Real aDiffV = myRangeV.second - myRangeV.first;
 
+  // Slightly increase exact resolution so to cover links with approximate 
+  // length equal to resolution itself on sub-resolution differences.
   const Standard_Real      aTolerance = BRep_Tool::Tolerance (myDFace->GetFace());
   const Adaptor3d_Surface& aSurface   = GetSurface()->Surface();
-  const Standard_Real      aResU      = aSurface.UResolution (aTolerance);
-  const Standard_Real      aResV      = aSurface.VResolution (aTolerance);
+  const Standard_Real      aResU      = aSurface.UResolution (aTolerance) * 1.1;
+  const Standard_Real      aResV      = aSurface.VResolution (aTolerance) * 1.1;
 
   const Standard_Real aDeflectionUV = 1.e-05;
   myTolerance.first  = Max(Min(aDeflectionUV, aResU), 1e-7 * aDiffU);

src/BRepMesh/BRepMesh_EdgeDiscret.cxx

@@ -49,9 +49,10 @@ BRepMesh_EdgeDiscret::~BRepMesh_EdgeDiscret ()
 //=======================================================================
 Handle(IMeshTools_CurveTessellator) BRepMesh_EdgeDiscret::CreateEdgeTessellator(
   const IMeshData::IEdgeHandle& theDEdge,
-  const IMeshTools_Parameters&  theParameters)
+  const IMeshTools_Parameters&  theParameters,
+  const Standard_Integer        theMinPointsNb)
 {
-  return new BRepMesh_CurveTessellator(theDEdge, theParameters);
+  return new BRepMesh_CurveTessellator(theDEdge, theParameters, theMinPointsNb);
 }
 
 //=======================================================================
@@ -62,11 +63,12 @@ Handle(IMeshTools_CurveTessellator) BRepMesh_EdgeDiscret::CreateEdgeTessellator(
   const IMeshData::IEdgeHandle& theDEdge,
   const TopAbs_Orientation      theOrientation,
   const IMeshData::IFaceHandle& theDFace,
-  const IMeshTools_Parameters&  theParameters)
+  const IMeshTools_Parameters&  theParameters,
+  const Standard_Integer        theMinPointsNb)
 {
   return theDEdge->GetSameParam() ? 
-    new BRepMesh_CurveTessellator(theDEdge, theParameters) :
-    new BRepMesh_CurveTessellator(theDEdge, theOrientation, theDFace, theParameters);
+    new BRepMesh_CurveTessellator(theDEdge, theParameters, theMinPointsNb) :
+    new BRepMesh_CurveTessellator(theDEdge, theOrientation, theDFace, theParameters, theMinPointsNb);
 }
 
 //=======================================================================

src/BRepMesh/BRepMesh_EdgeDiscret.hxx

@@ -38,14 +38,16 @@ public:
   //! Creates instance of free edge tessellator.
   Standard_EXPORT static Handle(IMeshTools_CurveTessellator) CreateEdgeTessellator(
     const IMeshData::IEdgeHandle& theDEdge,
-    const IMeshTools_Parameters&  theParameters);
+    const IMeshTools_Parameters&  theParameters,
+    const Standard_Integer        theMinPointsNb = 2);
 
   //! Creates instance of edge tessellator.
   Standard_EXPORT static Handle(IMeshTools_CurveTessellator) CreateEdgeTessellator(
     const IMeshData::IEdgeHandle& theDEdge,
     const TopAbs_Orientation      theOrientation,
     const IMeshData::IFaceHandle& theDFace,
-    const IMeshTools_Parameters&  theParameters);
+    const IMeshTools_Parameters&  theParameters,
+    const Standard_Integer        theMinPointsNb = 2);
 
   //! Creates instance of tessellation extractor.
   Standard_EXPORT static Handle(IMeshTools_CurveTessellator) CreateEdgeTessellationExtractor(

src/BRepMesh/BRepMesh_ExtrusionRangeSplitter.cxx

@@ -0,0 +1,45 @@
+// Created on: 2022-09-07
+// Copyright (c) 2022 OPEN CASCADE SAS
+// Created by: Oleg AGASHIN
+//
+// 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 <BRepMesh_ExtrusionRangeSplitter.hxx>
+
+//=======================================================================
+// Function: getUndefinedIntervalNb
+// Purpose : 
+//=======================================================================
+Standard_Integer BRepMesh_ExtrusionRangeSplitter::getUndefinedIntervalNb(
+  const Handle(Adaptor3d_Surface)& theSurface,
+  const Standard_Boolean           /*isU*/,
+  const GeomAbs_Shape              theContinuity) const
+{
+  // Here we need just a regular grid along dimension with no 
+  // geometrical data regarding intervals like extrusion surface.
+  const Handle(Adaptor3d_Curve) aCurve = theSurface->BasisCurve();
+  Standard_Integer aIntervalsNb = aCurve->NbIntervals(theContinuity);
+  if (aIntervalsNb == 1)
+  {
+    const GeomAbs_CurveType aCurveType = aCurve->GetType();
+    const Standard_Boolean isBSplineCurve =
+      aCurveType == GeomAbs_BezierCurve ||
+      aCurveType == GeomAbs_BSplineCurve;
+
+    if (isBSplineCurve)
+    {
+      aIntervalsNb = aCurve->NbPoles() - 1;
+    }
+  }
+
+  return aIntervalsNb;
+}

src/BRepMesh/BRepMesh_ExtrusionRangeSplitter.hxx

@@ -0,0 +1,45 @@
+// Created on: 2022-09-07
+// Copyright (c) 2022 OPEN CASCADE SAS
+// Created by: Oleg AGASHIN
+//
+// 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 _BRepMesh_ExtrusionRangeSplitter_HeaderFile
+#define _BRepMesh_ExtrusionRangeSplitter_HeaderFile
+
+#include <BRepMesh_NURBSRangeSplitter.hxx>
+
+//! Auxiliary class analysing extrusion surface in order to generate internal nodes.
+class BRepMesh_ExtrusionRangeSplitter : public BRepMesh_NURBSRangeSplitter
+{
+public:
+
+  //! Constructor.
+  BRepMesh_ExtrusionRangeSplitter()
+  {
+  }
+
+  //! Destructor.
+  virtual ~BRepMesh_ExtrusionRangeSplitter()
+  {
+  }
+
+protected:
+
+  //! Returns number of intervals computed using available geometrical parameters.
+  Standard_EXPORT virtual Standard_Integer getUndefinedIntervalNb(
+    const Handle(Adaptor3d_Surface)& theSurface,
+    const Standard_Boolean           isU,
+    const GeomAbs_Shape              theContinuity) const Standard_OVERRIDE;
+};
+
+#endif

src/BRepMesh/BRepMesh_MeshAlgoFactory.cxx

@@ -21,6 +21,8 @@
 #include <BRepMesh_DelaunayBaseMeshAlgo.hxx>
 #include <BRepMesh_DelaunayDeflectionControlMeshAlgo.hxx>
 #include <BRepMesh_BoundaryParamsRangeSplitter.hxx>
+#include <BRepMesh_ExtrusionRangeSplitter.hxx>
+#include <BRepMesh_UndefinedRangeSplitter.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_MeshAlgoFactory, IMeshTools_MeshAlgoFactory)
 
@@ -71,34 +73,55 @@ Handle(IMeshTools_MeshAlgo) BRepMesh_MeshAlgoFactory::GetAlgo(
   switch (theSurfaceType)
   {
   case GeomAbs_Plane:
-    return theParameters.InternalVerticesMode ?
+    return theParameters.EnableControlSurfaceDeflectionAllSurfaces ?
+      new DeflectionControlMeshAlgo<BRepMesh_DefaultRangeSplitter>::Type :
+        (theParameters.InternalVerticesMode ?
          new NodeInsertionMeshAlgo<BRepMesh_DefaultRangeSplitter>::Type :
-      new BaseMeshAlgo::Type;
+         new BaseMeshAlgo::Type);
     break;
 
   case GeomAbs_Sphere:
-    return new NodeInsertionMeshAlgo<BRepMesh_SphereRangeSplitter>::Type;
+    return theParameters.EnableControlSurfaceDeflectionAllSurfaces ?
+      new DeflectionControlMeshAlgo<BRepMesh_SphereRangeSplitter>::Type :
+      new NodeInsertionMeshAlgo<BRepMesh_SphereRangeSplitter>::Type;
     break;
 
   case GeomAbs_Cylinder:
-    return theParameters.InternalVerticesMode ?
+    return theParameters.EnableControlSurfaceDeflectionAllSurfaces ?
+      new DeflectionControlMeshAlgo<BRepMesh_CylinderRangeSplitter>::Type :
+        (theParameters.InternalVerticesMode ?
         new NodeInsertionMeshAlgo<BRepMesh_CylinderRangeSplitter>::Type :
-      new BaseMeshAlgo::Type;
+        new BaseMeshAlgo::Type);
     break;
 
   case GeomAbs_Cone:
-    return new NodeInsertionMeshAlgo<BRepMesh_ConeRangeSplitter>::Type;
+    return theParameters.EnableControlSurfaceDeflectionAllSurfaces ? 
+      new DeflectionControlMeshAlgo<BRepMesh_ConeRangeSplitter>::Type :
+      new NodeInsertionMeshAlgo<BRepMesh_ConeRangeSplitter>::Type;
     break;
 
   case GeomAbs_Torus:
-    return new NodeInsertionMeshAlgo<BRepMesh_TorusRangeSplitter>::Type;
+    return theParameters.EnableControlSurfaceDeflectionAllSurfaces ?
+      new DeflectionControlMeshAlgo<BRepMesh_TorusRangeSplitter>::Type :
+      new NodeInsertionMeshAlgo<BRepMesh_TorusRangeSplitter>::Type;
     break;
 
   case GeomAbs_SurfaceOfRevolution:
     return new DeflectionControlMeshAlgo<BRepMesh_BoundaryParamsRangeSplitter>::Type;
     break;
 
-  default:
+  case GeomAbs_SurfaceOfExtrusion:
+    return new DeflectionControlMeshAlgo<BRepMesh_ExtrusionRangeSplitter>::Type;
+    break;
+
+  case GeomAbs_BezierSurface:
+  case GeomAbs_BSplineSurface:
     return new DeflectionControlMeshAlgo<BRepMesh_NURBSRangeSplitter>::Type;
+    break;
+
+  case GeomAbs_OffsetSurface:
+  case GeomAbs_OtherSurface:
+  default:
+    return new DeflectionControlMeshAlgo<BRepMesh_UndefinedRangeSplitter>::Type;
   }
 }

src/BRepMesh/BRepMesh_ModelHealer.cxx

@@ -50,14 +50,32 @@ namespace
     void operator()(const IMeshData::IEdgePtr& theDEdge) const
     {
       const IMeshData::IEdgeHandle aDEdge = theDEdge;
+
+      Standard_Integer aPointsNb = aDEdge->GetCurve()->ParametersNb();
+
       aDEdge->Clear(Standard_True);
       aDEdge->SetDeflection(Max(aDEdge->GetDeflection() / 3., Precision::Confusion()));
 
+      for (Standard_Integer aPCurveIt = 0; aPCurveIt < aDEdge->PCurvesNb(); ++aPCurveIt)
+      {
+        const IMeshData::IPCurveHandle& aPCurve = aDEdge->GetPCurve(aPCurveIt);
+        const IMeshData::IFaceHandle    aDFace  = aPCurve->GetFace();
+
+        // Check that outer wire contains 2 edges or less and add an additional point.
+        const IMeshData::IWireHandle&   aDWire  = aDFace->GetWire(0);
+        if (aDWire->EdgesNb() <= 2)
+        {
+          ++aPointsNb;
+          break;
+        }
+      }
+
       const IMeshData::IPCurveHandle& aPCurve = aDEdge->GetPCurve(0);
       const IMeshData::IFaceHandle    aDFace = aPCurve->GetFace();
       Handle(IMeshTools_CurveTessellator) aTessellator =
         BRepMesh_EdgeDiscret::CreateEdgeTessellator(
-          aDEdge, aPCurve->GetOrientation(), aDFace, myParameters);
+          aDEdge, aPCurve->GetOrientation(), aDFace,
+          myParameters, aPointsNb);
 
       BRepMesh_EdgeDiscret::Tessellate3d(aDEdge, aTessellator, Standard_False);
       BRepMesh_EdgeDiscret::Tessellate2d(aDEdge, Standard_False);

src/BRepMesh/BRepMesh_ModelPreProcessor.cxx

@@ -46,7 +46,8 @@ namespace
     void operator()(const Standard_Integer theFaceIndex) const
     {
       const IMeshData::IFaceHandle& aDFace = myModel->GetFace(theFaceIndex);
-      if (aDFace->IsSet(IMeshData_Outdated))
+      if (aDFace->IsSet(IMeshData_Outdated) ||
+          aDFace->GetFace().IsNull())
       {
         return;
       }
@@ -119,7 +120,7 @@ namespace
     void operator()(const Standard_Integer theFaceIndex) const
     {
       const IMeshData::IFaceHandle& aDFace = myModel->GetFace(theFaceIndex);
-      if (aDFace->GetSurface()->GetType() != GeomAbs_Cone)
+      if (aDFace->GetSurface()->GetType() != GeomAbs_Cone || aDFace->IsSet(IMeshData_Failure))
       {
         return;
       }

src/BRepMesh/BRepMesh_NURBSRangeSplitter.cxx

@@ -392,27 +392,73 @@ Handle(IMeshData::ListOfPnt2d) BRepMesh_NURBSRangeSplitter::GenerateSurfaceNodes
   return aNodes;
 }
 
+//=======================================================================
+// Function: getUndefinedIntervalNb
+// Purpose : 
+//=======================================================================
+Standard_Integer BRepMesh_NURBSRangeSplitter::getUndefinedIntervalNb(
+  const Handle(Adaptor3d_Surface)& theSurface,
+  const Standard_Boolean           isU,
+  const GeomAbs_Shape              /*theContinuity*/) const
+{
+  return (isU ? theSurface->NbUPoles() : theSurface->NbVPoles()) - 1;
+}
+
+//=======================================================================
+// Function: getUndefinedInterval
+// Purpose : 
+//=======================================================================
+void BRepMesh_NURBSRangeSplitter::getUndefinedInterval(
+  const Handle(Adaptor3d_Surface)&               theSurface,
+  const Standard_Boolean                         isU,
+  const GeomAbs_Shape                            theContinuity,
+  const std::pair<Standard_Real, Standard_Real>& theRange,
+  TColStd_Array1OfReal&                          theIntervals) const
+{
+  Standard_Integer aIntervalsNb = isU ? 
+    theSurface->NbUIntervals(theContinuity) :
+    theSurface->NbVIntervals(theContinuity);
+
+  if (aIntervalsNb == 1)
+  {
+    aIntervalsNb = getUndefinedIntervalNb(theSurface, isU, theContinuity);
+    if (aIntervalsNb > 1)
+    {
+      theIntervals = TColStd_Array1OfReal(1, aIntervalsNb - 1);
+      const Standard_Real aDiff = (theRange.second - theRange.first) / aIntervalsNb;
+      for (Standard_Integer i = theIntervals.Lower(); i <= theIntervals.Upper(); ++i)
+      {
+        theIntervals.SetValue(i, theRange.first + i * aDiff);
+      }
+    }
+  }
+
+  if (theIntervals.IsEmpty())
+  {
+    theIntervals = TColStd_Array1OfReal(1, aIntervalsNb + 1);
+    if (isU)
+    {
+      theSurface->UIntervals(theIntervals, theContinuity);
+    }
+    else
+    {
+      theSurface->VIntervals(theIntervals, theContinuity);
+    }
+  }
+}
+
 //=======================================================================
 // Function: initParameters
 // Purpose : 
 //=======================================================================
 Standard_Boolean BRepMesh_NURBSRangeSplitter::initParameters() const
 {
+  const GeomAbs_Shape aContinuity = GeomAbs_CN;
   const Handle(BRepAdaptor_Surface)& aSurface = GetSurface();
 
-  const GeomAbs_Shape aContinuity = GeomAbs_CN;
-  const std::pair<Standard_Integer, Standard_Integer> aIntervalsNb(
-    aSurface->NbUIntervals(aContinuity),
-    aSurface->NbVIntervals(aContinuity)
-  );
-
-  TColStd_Array1OfReal aIntervals[2] = {
-    TColStd_Array1OfReal(1, aIntervalsNb.first  + 1),
-    TColStd_Array1OfReal(1, aIntervalsNb.second + 1)
-  };
-
-  aSurface->UIntervals(aIntervals[0], aContinuity);
-  aSurface->VIntervals(aIntervals[1], aContinuity);
+  TColStd_Array1OfReal aIntervals[2];
+  getUndefinedInterval(aSurface, Standard_True,  aContinuity, GetRangeU(), aIntervals[0]);
+  getUndefinedInterval(aSurface, Standard_False, aContinuity, GetRangeV(), aIntervals[1]);
 
   const Standard_Boolean isSplitIntervals = toSplitIntervals (aSurface->Surface().Surface(), aIntervals);
 
@@ -507,12 +553,17 @@ Handle(IMeshData::SequenceOfReal) BRepMesh_NURBSRangeSplitter::computeGrainAndFi
     aMinDiff /= theDelta;
   }
 
-  aMinDiff = Max(theParameters.MinSize, aMinDiff);
+  const Handle(BRepAdaptor_Surface)& aSurface = GetSurface();
+  const Standard_Real aMinSize2d = Max(
+    aSurface->UResolution(theParameters.MinSize),
+    aSurface->VResolution(theParameters.MinSize));
+
+  aMinDiff = Max(aMinSize2d, aMinDiff);
 
   const Standard_Real aDiffMaxLim = 0.1 * theRangeDiff;
   const Standard_Real aDiffMinLim = Max(0.005 * theRangeDiff,
                                         2. * theTol2d);
-  const Standard_Real aDiff = Max(theParameters.MinSize,
+  const Standard_Real aDiff = Max(aMinSize2d,
                                   Min(aDiffMaxLim, aDiffMinLim));
   return filterParameters(theSourceParams, aMinDiff, aDiff, theAllocator);
 }

src/BRepMesh/BRepMesh_NURBSRangeSplitter.hxx

@@ -49,7 +49,21 @@ protected:
   //! Initializes U and V parameters lists using CN continuity intervals.
   Standard_EXPORT virtual Standard_Boolean initParameters() const;
 
+  //! Returns number of intervals computed using available geometrical parameters.
+  Standard_EXPORT virtual Standard_Integer getUndefinedIntervalNb(
+    const Handle(Adaptor3d_Surface)& theSurface,
+    const Standard_Boolean           isU,
+    const GeomAbs_Shape              theContinuity) const;
+
 private:
+  //! Tries to compute intervals even for cases with no intervals 
+  //! at all using available geometrical parameters.
+  void getUndefinedInterval(
+    const Handle(Adaptor3d_Surface)&               theSurface,
+    const Standard_Boolean                         isU,
+    const GeomAbs_Shape                            theContinuity,
+    const std::pair<Standard_Real, Standard_Real>& theRange,
+    TColStd_Array1OfReal&                          theIntervals) const;
 
   //! Computes parameters of filter and applies it to the source parameters.
   Handle(IMeshData::SequenceOfReal) computeGrainAndFilterParameters(

src/BRepMesh/BRepMesh_UndefinedRangeSplitter.cxx

@@ -0,0 +1,28 @@
+// Created on: 2022-09-07
+// Copyright (c) 2022 OPEN CASCADE SAS
+// Created by: Oleg AGASHIN
+//
+// 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 <BRepMesh_UndefinedRangeSplitter.hxx>
+
+//=======================================================================
+// Function: getUndefinedIntervalNb
+// Purpose : 
+//=======================================================================
+Standard_Integer BRepMesh_UndefinedRangeSplitter::getUndefinedIntervalNb(
+  const Handle(Adaptor3d_Surface)& /*theSurface*/,
+  const Standard_Boolean           /*isU*/,
+  const GeomAbs_Shape              /*theContinuity*/) const
+{
+  return 1;
+}

src/BRepMesh/BRepMesh_UndefinedRangeSplitter.hxx

@@ -0,0 +1,46 @@
+// Created on: 2022-09-07
+// Copyright (c) 2022 OPEN CASCADE SAS
+// Created by: Oleg AGASHIN
+//
+// 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 _BRepMesh_UndefinedRangeSplitter_HeaderFile
+#define _BRepMesh_UndefinedRangeSplitter_HeaderFile
+
+#include <BRepMesh_NURBSRangeSplitter.hxx>
+
+//! Auxiliary class provides safe value for surfaces that looks like NURBS 
+//! but has no poles or other characteristics.
+class BRepMesh_UndefinedRangeSplitter : public BRepMesh_NURBSRangeSplitter
+{
+public:
+
+  //! Constructor.
+  BRepMesh_UndefinedRangeSplitter()
+  {
+  }
+
+  //! Destructor.
+  virtual ~BRepMesh_UndefinedRangeSplitter()
+  {
+  }
+
+protected:
+
+  //! Returns number of intervals computed using available geometrical parameters.
+  Standard_EXPORT virtual Standard_Integer getUndefinedIntervalNb(
+    const Handle(Adaptor3d_Surface)& theSurface,
+    const Standard_Boolean           isU,
+    const GeomAbs_Shape              theContinuity) const Standard_OVERRIDE;
+};
+
+#endif

src/BRepMesh/FILES

@@ -40,6 +40,8 @@ BRepMesh_EdgeDiscret.hxx
 BRepMesh_EdgeParameterProvider.hxx
 BRepMesh_EdgeTessellationExtractor.cxx
 BRepMesh_EdgeTessellationExtractor.hxx
+BRepMesh_ExtrusionRangeSplitter.cxx
+BRepMesh_ExtrusionRangeSplitter.hxx
 BRepMesh_FaceChecker.cxx
 BRepMesh_FaceChecker.hxx
 BRepMesh_FaceDiscret.cxx
@@ -80,6 +82,8 @@ BRepMesh_SphereRangeSplitter.hxx
 BRepMesh_TorusRangeSplitter.cxx
 BRepMesh_TorusRangeSplitter.hxx
 BRepMesh_Triangle.hxx
+BRepMesh_UndefinedRangeSplitter.cxx
+BRepMesh_UndefinedRangeSplitter.hxx
 BRepMesh_UVParamRangeSplitter.hxx
 BRepMesh_Vertex.hxx
 BRepMesh_VertexInspector.hxx

src/BRepOffsetAPI/BRepOffsetAPI_MakeOffset.cxx

@@ -17,9 +17,12 @@
 
 #include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
+#include <BRepAdaptor_Curve.hxx>
 #include <BRepAdaptor_Surface.hxx>
+#include <BRepAlgo.hxx>
 #include <BRepAlgo_FaceRestrictor.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepLib.hxx>
 #include <BRepOffsetAPI_MakeOffset.hxx>
 #include <BRepTopAdaptor_FClass2d.hxx>
 #include <Extrema_ExtPS.hxx>
@@ -41,6 +44,50 @@
 static Standard_Boolean AffichSpine = Standard_False;
 #endif
 
+static Standard_Boolean NeedsConvertion (const TopoDS_Wire& theWire)
+{
+  TopoDS_Iterator anIter (theWire);
+  for (; anIter.More(); anIter.Next())
+  {
+    const TopoDS_Edge& anEdge = TopoDS::Edge (anIter.Value());
+    BRepAdaptor_Curve aBAcurve (anEdge);
+    GeomAbs_CurveType aType = aBAcurve.GetType();
+    if (aType != GeomAbs_Line &&
+        aType != GeomAbs_Circle)
+      return Standard_True;
+  }
+
+  return Standard_False;
+}
+
+TopoDS_Face BRepOffsetAPI_MakeOffset::ConvertFace (const TopoDS_Face&  theFace,
+                                                   const Standard_Real theAngleTolerance)
+{
+  TopAbs_Orientation anOr = theFace.Orientation();
+  TopoDS_Face aFace = theFace;
+  aFace.Orientation (TopAbs_FORWARD);
+
+  TopoDS_Face aNewFace = TopoDS::Face (aFace.EmptyCopied());
+  BRep_Builder aBB;
+  TopoDS_Iterator anIter (aFace);
+  for (; anIter.More(); anIter.Next())
+  {
+    TopoDS_Wire aWire = TopoDS::Wire (anIter.Value());
+    if (NeedsConvertion (aWire))
+    {
+      TopAbs_Orientation anOrOfWire = aWire.Orientation();
+      aWire.Orientation (TopAbs_FORWARD);
+      aWire = BRepAlgo::ConvertWire (aWire, theAngleTolerance, aFace);
+      BRepLib::BuildCurves3d (aWire);
+      aWire.Orientation (anOrOfWire);
+    }
+    aBB.Add (aNewFace, aWire);
+  }
+  aNewFace.Orientation (anOr);
+
+  return aNewFace;
+}
+
 //=======================================================================
 //function : BRepOffsetAPI_MakeOffset
 //purpose  : 
@@ -49,7 +96,8 @@ static Standard_Boolean AffichSpine = Standard_False;
 BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset()
   : myIsInitialized( Standard_False),
     myJoin(GeomAbs_Arc),
-    myIsOpenResult(Standard_False)
+    myIsOpenResult(Standard_False),
+    myIsToApprox(Standard_False)
 {
 }
 
@@ -80,6 +128,7 @@ void BRepOffsetAPI_MakeOffset::Init(const TopoDS_Face&     Spine,
   myIsInitialized = Standard_True;
   myJoin          = Join;
   myIsOpenResult  = IsOpenResult;
+  myIsToApprox = Standard_False;
   TopExp_Explorer exp;
   for (exp.Init(myFace,TopAbs_WIRE); exp.More();exp.Next()) {
     myWires.Append(exp.Current());
@@ -99,6 +148,7 @@ BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset(const TopoDS_Wire& Spine,
   myIsInitialized = Standard_True;
   myJoin = Join;
   myIsOpenResult  = IsOpenResult;
+  myIsToApprox = Standard_False;
 }
 
 //=======================================================================
@@ -113,6 +163,18 @@ void BRepOffsetAPI_MakeOffset::Init(const GeomAbs_JoinType Join,
   myIsOpenResult  = IsOpenResult;
 }
 
+//=======================================================================
+//function : SetApprox
+//purpose  : Set approximation flag
+//           for convertion input contours into ones consisting of
+//           2D circular arcs and 2D linear segments only
+//=======================================================================
+
+void BRepOffsetAPI_MakeOffset::SetApprox(const Standard_Boolean ToApprox)
+{
+  myIsToApprox = ToApprox;
+}
+
 //=======================================================================
 //function : BRepOffsetAPI_MakeOffset
 //purpose  : 
@@ -289,6 +351,46 @@ void BRepOffsetAPI_MakeOffset::Perform(const Standard_Real Offset,
 
   try
   {
+    if (myIsToApprox)
+    {
+      Standard_Real aTol = 0.1;
+      if (myFace.IsNull())
+      {
+        TopoDS_Face aFace;
+        Standard_Boolean OnlyPlane = Standard_True;
+        TopTools_ListIteratorOfListOfShape anItl (myWires);
+        for (; anItl.More(); anItl.Next())
+        {
+          BRepBuilderAPI_MakeFace aFaceMaker (TopoDS::Wire(anItl.Value()), OnlyPlane);
+          if (aFaceMaker.Error() == BRepBuilderAPI_FaceDone)
+          {
+            aFace = aFaceMaker.Face();
+            break;
+          }
+        }
+        for (anItl.Initialize(myWires); anItl.More(); anItl.Next())
+        {
+          const TopoDS_Wire& aWire = TopoDS::Wire(anItl.Value());
+          if (NeedsConvertion (aWire))
+          {
+            TopoDS_Wire aNewWire = BRepAlgo::ConvertWire (aWire, aTol, aFace);
+            BRepLib::BuildCurves3d (aNewWire);
+            aNewWire.Orientation (aWire.Orientation());
+            anItl.ChangeValue() = aNewWire;
+          }
+        }
+      }
+      else
+      {
+        myFace = ConvertFace (myFace, aTol);
+        BRepLib::BuildCurves3d (myFace);
+        myWires.Clear();
+        TopoDS_Iterator anIter (myFace);
+        for (; anIter.More(); anIter.Next())
+          myWires.Append (anIter.Value());
+      }
+    }
+    
     Standard_Integer i = 1;
     BRepFill_ListIteratorOfListOfOffsetWire itOW;
     TopoDS_Compound Res;

src/BRepOffsetAPI/BRepOffsetAPI_MakeOffset.hxx

@@ -63,6 +63,11 @@ public:
   //! Initialize the evaluation of Offsetting.
   Standard_EXPORT void Init (const GeomAbs_JoinType Join = GeomAbs_Arc, const Standard_Boolean IsOpenResult = Standard_False);
   
+  //! Set approximation flag
+  //! for convertion input contours into ones consisting of
+  //! 2D circular arcs and 2D linear segments only.
+  Standard_EXPORT void SetApprox (const Standard_Boolean ToApprox);
+  
   //! Initializes the algorithm to construct parallels to the wire Spine.
   Standard_EXPORT void AddWire (const TopoDS_Wire& Spine);
   
@@ -79,7 +84,10 @@ public:
   //! from the shape <S>.
   Standard_EXPORT virtual const TopTools_ListOfShape& Generated (const TopoDS_Shape& S) Standard_OVERRIDE;
 
-
+  //! Converts each wire of the face into contour consisting only of
+  //! arcs and segments. New 3D curves are built too.
+  Standard_EXPORT static TopoDS_Face ConvertFace (const TopoDS_Face& theFace,
+                                                  const Standard_Real theAngleTolerance);
 
 
 protected:
@@ -96,6 +104,7 @@ private:
   Standard_Boolean myLastIsLeft;
   GeomAbs_JoinType myJoin;
   Standard_Boolean myIsOpenResult;
+  Standard_Boolean myIsToApprox;
   TopoDS_Face myFace;
   TopTools_ListOfShape myWires;
   BRepFill_ListOfOffsetWire myLeft;

src/BRepTest/BRepTest_BasicCommands.cxx

@@ -124,7 +124,14 @@ static Standard_Integer transform(Draw_Interpretor&,Standard_Integer n,const cha
   Standard_Boolean isBasic = Standard_False;
   Standard_Boolean isForced = Standard_False;
   Standard_Boolean isCopy = Standard_False;
+  Standard_Boolean isCopyMesh = Standard_False;
 
+  // Check "copymesh" flag.
+  if (!strcmp(a[n - 1], "-copymesh"))
+  {
+    isCopyMesh = Standard_True;
+    last = --n;
+  }
   // Check "copy" flag.
   if (!strcmp(a[n-1], "-copy")) {
     isCopy = Standard_True;
@@ -218,7 +225,7 @@ static Standard_Integer transform(Draw_Interpretor&,Standard_Integer n,const cha
         return 1;
       }
       else {
-        trf.Perform(S, isCopy);
+        trf.Perform(S, isCopy, isCopyMesh);
         if (!trf.IsDone())
           return 1;
         DBRep::Set(a[i],trf.Shape());
@@ -1487,27 +1494,27 @@ void  BRepTest::BasicCommands(Draw_Interpretor& theCommands)
 		  transform,g);
 
   theCommands.Add("tmove",
-		  "tmove name1 name2 ... name, set location from name [-copy]",
+		  "tmove name1 name2 ... name, set location from name [-copy] [-copymesh]",
 		  __FILE__,
 		  transform,g);
 
   theCommands.Add("ttranslate",
-		  "ttranslate name1 name2 ... dx dy dz [-copy]",
+		  "ttranslate name1 name2 ... dx dy dz [-copy [-copymesh]]",
 		  __FILE__,
 		  transform,g);
 
   theCommands.Add("trotate",
-		  "trotate name1 name2 ... x y z dx dy dz angle [-copy]",
+		  "trotate name1 name2 ... x y z dx dy dz angle [-copy [-copymesh]]",
 		  __FILE__,
 		  transform,g);
 
   theCommands.Add("tmirror",
-		  "tmirror name x y z dx dy dz [-copy]",
+		  "tmirror name x y z dx dy dz [-copy] [-copymesh]",
 		  __FILE__,
 		  transform,g);
 
   theCommands.Add("tscale",
-		  "tscale name x y z scale [-copy]",
+		  "tscale name x y z scale [-copy] [-copymesh]",
 		  __FILE__,
 		  transform,g);
 

src/BRepTest/BRepTest_CurveCommands.cxx

@@ -1530,10 +1530,23 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
   char name[100];
 
   BRepOffsetAPI_MakeOffset Paral;
+
+  Standard_Boolean ToApprox = Standard_False;
   GeomAbs_JoinType theJoinType = GeomAbs_Arc;
-  if (n >= 6 && strcmp(a[5], "i") == 0)
+  
+  Standard_Integer anIndArg = 6;
+  if (n >= 6)
+  {
+    if (strcmp(a[5], "-approx") == 0)
+    {
+      ToApprox = Standard_True;
+      anIndArg++;
+    }
+  
+    if (n >= anIndArg && strcmp(a[anIndArg-1], "i") == 0)
       theJoinType = GeomAbs_Intersection;
-  Paral.Init(theJoinType);
+  }
+  
   TopoDS_Shape Base = DBRep::Get(a[2],TopAbs_FACE);
 
   if ( Base.IsNull())
@@ -1553,6 +1566,7 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
     Base.Orientation(TopAbs_FORWARD);
     Paral.Init(TopoDS::Face(Base), theJoinType);
   }
+  Paral.SetApprox (ToApprox);
 
   Standard_Real U, dU;
   Standard_Integer Nb;
@@ -1560,8 +1574,8 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
   Nb = Draw::Atoi(a[3]);
 
   Standard_Real Alt = 0.;
-  if ( n == 7)
-    Alt = Draw::Atof(a[6]);
+  if (n > anIndArg)
+    Alt = Draw::Atof(a[anIndArg]);
 
   Standard_Integer Compt = 1;
 
@@ -1598,16 +1612,30 @@ Standard_Integer openoffset(Draw_Interpretor& di,
   char name[100];
 
   BRepOffsetAPI_MakeOffset Paral;
+  
+  Standard_Boolean ToApprox = Standard_False;
   GeomAbs_JoinType theJoinType = GeomAbs_Arc;
-  if (n == 6 && strcmp(a[5], "i") == 0)
+  
+  Standard_Integer anIndArg = 6;
+  if (n >= 6)
+  {
+    if (strcmp(a[5], "-approx") == 0)
+    {
+      ToApprox = Standard_True;
+      anIndArg++;
+    }
+  
+    if (n >= anIndArg && strcmp(a[anIndArg-1], "i") == 0)
       theJoinType = GeomAbs_Intersection;
-  Paral.Init(theJoinType, Standard_True);
+  }
+  
   TopoDS_Shape Base = DBRep::Get(a[2] ,TopAbs_FACE);
 
   if ( Base.IsNull())
   {
     Base = DBRep::Get(a[2], TopAbs_WIRE);
     if (Base.IsNull()) return 1;
+    Paral.Init(theJoinType, Standard_True);
     Paral.AddWire(TopoDS::Wire(Base));
   }
   else
@@ -1615,6 +1643,7 @@ Standard_Integer openoffset(Draw_Interpretor& di,
     Base.Orientation(TopAbs_FORWARD);
     Paral.Init(TopoDS::Face(Base), theJoinType, Standard_True);
   }
+  Paral.SetApprox (ToApprox);
 
   Standard_Real U, dU;
   Standard_Integer Nb;
@@ -1755,6 +1784,72 @@ Standard_Integer edgeintersector(Draw_Interpretor& di,
 
 }
 
+//=================================================================================
+//function : arclinconvert
+//purpose  : Convert a single face to a face with contour made of arcs and segments
+//=================================================================================
+
+static Standard_Integer arclinconvert (Draw_Interpretor& /*dout*/, Standard_Integer n, const char** a)
+{
+  // Check the command arguments
+  if (n < 3) {
+    std::cout<<"Error: "<<a[0]<<" - invalid number of arguments"<<std::endl;
+    std::cout<<"Usage: type help "<<a[0]<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  //read shape
+  const TopoDS_Shape aShape = DBRep::Get(a[2]);
+  if (aShape.IsNull()) {
+    std::cout<<"Error: "<<a[2]<<" is null"<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  TopAbs_ShapeEnum aType = aShape.ShapeType();
+  if (aType != TopAbs_WIRE &&
+      aType != TopAbs_FACE)
+  {
+    std::cout<<"Error: "<<a[2]<<" is neither wire no face"<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  //read tolerance
+  Standard_Real aTol = 0.01;
+  if (n > 3)
+    aTol = Draw::Atof(a[3]);
+  std::cout<<"Info: tolerance is set to "<<aTol<<std::endl;
+
+  TopoDS_Shape aResult;
+  
+  if (aType == TopAbs_WIRE)
+  {
+    Standard_Boolean OnlyPlane = Standard_False;
+    BRepBuilderAPI_MakeFace aFaceMaker (TopoDS::Wire(aShape), OnlyPlane);
+    if (aFaceMaker.Error() != BRepBuilderAPI_FaceDone)
+    {
+      std::cout<<"Error: failed to find a face for the wire "<<a[2]<<std::endl;
+      return 1; //TCL_ERROR
+    }
+    TopoDS_Face aFace = aFaceMaker.Face();
+    TopoDS_Iterator anIter (aFace);
+    TopoDS_Wire aWire = TopoDS::Wire (anIter.Value());
+    aResult = BRepAlgo::ConvertWire (aWire, aTol, aFace);
+  }
+  else if (aType == TopAbs_FACE)
+  {
+    TopoDS_Face aFace = TopoDS::Face(aShape);
+    aResult = BRepAlgo::ConvertFace (aFace, aTol);
+  }
+
+  if (aResult.IsNull()) {
+    std::cout<<"Error: could not convert "<<a[2]<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  DBRep::Set(a[1], aResult);
+  return 0; //TCL_OK
+}
+
 //=======================================================================
 //function : concatC0wire
 //purpose  : 
@@ -1908,11 +2003,11 @@ void  BRepTest::CurveCommands(Draw_Interpretor& theCommands)
     profile2d,g);
 
   theCommands.Add("mkoffset",
-    "mkoffset result face/compound of wires  nboffset stepoffset [jointype(a/i) [alt]]",__FILE__,
+    "mkoffset result face/compound of wires  nboffset stepoffset [-approx] [jointype(a/i) [alt]]",__FILE__,
     mkoffset,g);
 
   theCommands.Add("openoffset",
-    "openoffset result face/wire nboffset stepoffset [jointype(a/i)]",__FILE__,
+    "openoffset result face/wire nboffset stepoffset [-approx] [jointype(a/i)]",__FILE__,
     openoffset,g);
 
   theCommands.Add("mkedge",
@@ -1968,6 +2063,12 @@ void  BRepTest::CurveCommands(Draw_Interpretor& theCommands)
     "reducepcurves shape1 shape2 ...",__FILE__,
     reducepcurves, g);
 
+  theCommands.Add("arclinconvert",
+    "arclinconvert result wire/face [tol]",
+    __FILE__,
+    arclinconvert,
+    g);
+
   theCommands.Add("concatC0wire",
     "concatC0wire result wire",
     __FILE__,

src/BRepTest/BRepTest_ExtremaCommands.cxx

@@ -173,7 +173,7 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
 {
   if (theNbArgs < 3 || theNbArgs > 6)
   {
-    Message::SendFail() << "Usage: " << theArgs[0] << " Shape1 Shape2 [-tol <value>] [-profile]";
+    Message::SendFail() << "Usage: " << theArgs[0] << " Shape1 Shape2 [-tol <value> | -value] [-profile]";
     return 1;
   }
 
@@ -186,9 +186,11 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
     return 1;
   }
 
-  BRepExtrema_ShapeProximity aTool;
+  BRepExtrema_ShapeProximity aTool(0.0);
 
   Standard_Boolean aProfile = Standard_False;
+  Standard_Boolean isTolerance = Standard_False;
+  Standard_Boolean isValue = Standard_False;
 
   for (Standard_Integer anArgIdx = 3; anArgIdx < theNbArgs; ++anArgIdx)
   {
@@ -197,6 +199,7 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
 
     if (aFlag == "-tol")
     {
+      isTolerance = Standard_True;
       if (++anArgIdx >= theNbArgs)
       {
         Message::SendFail() << "Error: wrong syntax at argument '" << aFlag;
@@ -214,13 +217,23 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
         aTool.SetTolerance (aTolerance);
       }
     }
-
-    if (aFlag == "-profile")
+    else if (aFlag == "-value")
+    {
+      isValue = Standard_True;
+      aTool.SetTolerance(Precision::Infinite());
+    }
+    else if (aFlag == "-profile")
     {
       aProfile = Standard_True;
     }
   }
 
+  if (isTolerance && isValue)
+  {
+    Message::SendFail() << "Error: Proximity value could not be computed if the tolerance is set";
+    return 1;
+  }
+
   Standard_Real aInitTime = 0.0;
   Standard_Real aWorkTime = 0.0;
 
@@ -264,6 +277,40 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
     theDI << "Executing proximity test: " << aWorkTime << "\n";
   }
 
+  if (isValue)
+  {
+    theDI << "Proximity value: " << aTool.Proximity() << "\n";
+
+    // proximity points
+    TopoDS_Vertex aProxVtx1 = BRepLib_MakeVertex (aTool.ProximityPoint1());
+    TopoDS_Vertex aProxVtx2 = BRepLib_MakeVertex (aTool.ProximityPoint2());
+
+    DBRep::Set ("ProxPnt1", aProxVtx1);
+    DBRep::Set ("ProxPnt2", aProxVtx2);
+
+    // proximity points' status
+    TCollection_AsciiString ProxPntStatus1;
+    TCollection_AsciiString ProxPntStatus2;
+
+    switch (aTool.ProxPntStatus1()) 
+    {
+      case 0: ProxPntStatus1 = "Border"; break;
+      case 1: ProxPntStatus1 = "Middle"; break;
+      default: ProxPntStatus1 = "Unknown";
+    }
+
+    switch (aTool.ProxPntStatus2())
+    {
+    case 0: ProxPntStatus2 = "Border"; break;
+    case 1: ProxPntStatus2 = "Middle"; break;
+    default: ProxPntStatus2 = "Unknown";
+    }
+
+    theDI << " Status of ProxPnt1 on " << theArgs[1] << " : " << ProxPntStatus1 << "\n";
+    theDI << " Status of ProxPnt2 on " << theArgs[2] << " : " << ProxPntStatus2 << "\n";
+  }
+  else
+  {
     TopoDS_Builder aCompBuilder;
 
     TopoDS_Compound aFaceCompound1;
@@ -273,9 +320,9 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
     {
       TCollection_AsciiString aStr = TCollection_AsciiString(theArgs[1]) + "_" + (anIt1.Key() + 1);
 
-    const TopoDS_Face& aFace = aTool.GetSubShape1 (anIt1.Key());
-    aCompBuilder.Add (aFaceCompound1, aFace);
-    DBRep::Set (aStr.ToCString(), aFace);
+      const TopoDS_Shape& aShape = aTool.GetSubShape1(anIt1.Key());
+      aCompBuilder.Add(aFaceCompound1, aShape);
+      DBRep::Set(aStr.ToCString(), aShape);
 
       theDI << aStr << " \n";
     }
@@ -287,15 +334,16 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
     {
       TCollection_AsciiString aStr = TCollection_AsciiString(theArgs[2]) + "_" + (anIt2.Key() + 1);
 
-    const TopoDS_Face& aFace = aTool.GetSubShape2 (anIt2.Key());
-    aCompBuilder.Add (aFaceCompound2, aFace);
-    DBRep::Set (aStr.ToCString(), aFace);
+      const TopoDS_Shape& aShape = aTool.GetSubShape2(anIt2.Key());
+      aCompBuilder.Add(aFaceCompound2, aShape);
+      DBRep::Set(aStr.ToCString(), aShape);
 
       theDI << aStr << " \n";
     }
 
     DBRep::Set((TCollection_AsciiString(theArgs[1]) + "_" + "overlapped").ToCString(), aFaceCompound1);
     DBRep::Set((TCollection_AsciiString(theArgs[2]) + "_" + "overlapped").ToCString(), aFaceCompound2);
+  }
 
   return 0;
 }
@@ -445,12 +493,14 @@ void BRepTest::ExtremaCommands (Draw_Interpretor& theCommands)
                    aGroup);
 
   theCommands.Add ("proximity",
-                   "proximity Shape1 Shape2 [-tol <value>] [-profile]"
+                   "proximity Shape1 Shape2 [-tol <value> | -value] [-profile]"
                    "\n\t\t: Searches for pairs of overlapping faces of the given shapes."
                    "\n\t\t: The options are:"
                    "\n\t\t:   -tol     : non-negative tolerance value used for overlapping"
                    "\n\t\t:              test (for zero tolerance, the strict intersection"
                    "\n\t\t:              test will be performed)"
+                   "\n\t\t:   -value   : compute the proximity value (minimal value which"
+                   "\n\t\t:              shows both shapes fully overlapped)"
                    "\n\t\t:   -profile : outputs execution time for main algorithm stages",
                    __FILE__,
                    ShapeProximity,

src/BRepTest/BRepTest_MatCommands.cxx

@@ -35,6 +35,7 @@
 #include <Bisector_BisecAna.hxx>
 #include <Precision.hxx>
 
+#include <BRepOffsetAPI_MakeOffset.hxx>
 #include <BRepMAT2d_Explorer.hxx>
 #include <BRepMAT2d_BisectingLocus.hxx>
 #include <BRepMAT2d_LinkTopoBilo.hxx>
@@ -44,6 +45,7 @@
 
 #include <DBRep.hxx>
 #include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
 
 #ifdef _WIN32
 Standard_IMPORT Draw_Viewer dout;
@@ -70,7 +72,16 @@ static Standard_Integer topoload (Draw_Interpretor& , Standard_Integer argc, con
 
   if (C1.IsNull()) return 1;
 
-  anExplo.Perform (TopoDS::Face(C1));
+  TopoDS_Face aFace = TopoDS::Face(C1);
+  
+  if (argc >= 3 &&
+      (strcmp(argv[2], "-approx") == 0))
+  {
+    Standard_Real aTol = 0.1;
+    aFace = BRepOffsetAPI_MakeOffset::ConvertFace (aFace, aTol);
+  }
+
+  anExplo.Perform (aFace);
   return 0;
 }
 
@@ -267,7 +278,7 @@ void DrawCurve(const Handle(Geom2d_Curve)& aCurve,
 
 void BRepTest::MatCommands (Draw_Interpretor& theCommands)
 {
-  theCommands.Add("topoload","load face",__FILE__,topoload);
+  theCommands.Add("topoload","load face: topoload face [-approx]",__FILE__,topoload);
   theCommands.Add("drawcont","display current contour",__FILE__,drawcont);
   theCommands.Add("mat","computes the mat: mat [a/i [o]]",__FILE__,mat);
   theCommands.Add("side","side left/right",__FILE__,side);

src/BRepTools/BRepTools.cxx

@@ -893,6 +893,8 @@ void BRepTools::CleanGeometry(const TopoDS_Shape& theShape)
     aBuilder.UpdateEdge(anEdge, Handle(Geom_Curve)(),
       TopLoc_Location(), BRep_Tool::Tolerance(anEdge));
   }
+
+  RemoveUnusedPCurves(theShape);
 }
 
 

src/BRepTools/BRepTools_CopyModification.cxx

@@ -0,0 +1,215 @@
+// Copyright (c) 1999-2022 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 <BRepTools_CopyModification.hxx>
+
+#include <BRep_Tool.hxx>
+#include <TopLoc_Location.hxx>
+#include <TopoDS_Vertex.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(BRepTools_CopyModification, BRepTools_Modification)
+
+//=======================================================================
+//function : BRepTools_CopyModification
+//purpose  : 
+//=======================================================================
+BRepTools_CopyModification::BRepTools_CopyModification(const Standard_Boolean copyGeom,
+                                                       const Standard_Boolean copyMesh)
+  : myCopyGeom(copyGeom),
+    myCopyMesh(copyMesh)
+{
+}
+
+//=======================================================================
+//function : NewSurface
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewSurface(const TopoDS_Face&    theFace,
+                                                        Handle(Geom_Surface)& theSurf,
+                                                        TopLoc_Location&      theLoc,
+                                                        Standard_Real&        theTol,
+                                                        Standard_Boolean&     theRevWires,
+                                                        Standard_Boolean&     theRevFace)
+{
+  theSurf = BRep_Tool::Surface(theFace, theLoc);
+  theTol = BRep_Tool::Tolerance(theFace);
+  theRevWires = theRevFace = Standard_False;
+
+  if (!theSurf.IsNull() && myCopyGeom)
+    theSurf = Handle(Geom_Surface)::DownCast(theSurf->Copy());
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewTriangulation
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewTriangulation(const TopoDS_Face&          theFace,
+                                                              Handle(Poly_Triangulation)& theTri)
+{
+  if (!myCopyMesh && BRep_Tool::IsGeometric(theFace))
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc;
+  theTri = BRep_Tool::Triangulation(theFace, aLoc);
+
+  if (theTri.IsNull())
+    return Standard_False;
+
+  // mesh is copied if and only if the geometry need to be copied too
+  if (myCopyGeom)
+    theTri = theTri->Copy();
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewCurve
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewCurve(const TopoDS_Edge&  theEdge,
+                                                      Handle(Geom_Curve)& theCurve,
+                                                      TopLoc_Location&    theLoc,
+                                                      Standard_Real&      theTol)
+{
+  Standard_Real aFirst, aLast;
+  theCurve = BRep_Tool::Curve(theEdge, theLoc, aFirst, aLast);
+  theTol = BRep_Tool::Tolerance(theEdge);
+
+  if (!theCurve.IsNull() && myCopyGeom)
+    theCurve = Handle(Geom_Curve)::DownCast(theCurve->Copy());
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPolygon
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewPolygon(const TopoDS_Edge&      theEdge,
+                                                        Handle(Poly_Polygon3D)& thePoly)
+{
+  if (!myCopyMesh && BRep_Tool::IsGeometric(theEdge))
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc;
+  thePoly = BRep_Tool::Polygon3D(theEdge, aLoc);
+
+  if (thePoly.IsNull())
+    return Standard_False;
+
+  // polygon is copied if and only if the geometry need to be copied too
+  if (myCopyGeom)
+    thePoly = thePoly->Copy();
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPolygonOnTriangulation
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewPolygonOnTriangulation(
+  const TopoDS_Edge&                   theEdge,
+  const TopoDS_Face&                   theFace,
+  Handle(Poly_PolygonOnTriangulation)& thePoly)
+{
+  if (!myCopyMesh && BRep_Tool::IsGeometric(theEdge))
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc;
+  Handle(Poly_Triangulation) aTria = BRep_Tool::Triangulation(theFace, aLoc);
+  thePoly = BRep_Tool::PolygonOnTriangulation(theEdge, aTria, aLoc);
+
+  if (thePoly.IsNull())
+    return Standard_False;
+
+  // polygon is copied if and only if the geometry need to be copied too
+  if (myCopyGeom)
+    thePoly = thePoly->Copy();
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPoint
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewPoint(const TopoDS_Vertex& theVertex, 
+                                                      gp_Pnt&              thePnt,
+                                                      Standard_Real&       theTol)
+{
+  thePnt = BRep_Tool::Pnt(theVertex);
+  theTol = BRep_Tool::Tolerance(theVertex);
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewCurve2d
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewCurve2d(const TopoDS_Edge&    theEdge,
+                                                        const TopoDS_Face&    theFace,
+                                                        const TopoDS_Edge&,
+                                                        const TopoDS_Face&,
+                                                        Handle(Geom2d_Curve)& theCurve,
+                                                        Standard_Real&        theTol)
+{
+  theTol = BRep_Tool::Tolerance(theEdge);
+  Standard_Real aFirst, aLast;
+  theCurve = BRep_Tool::CurveOnSurface(theEdge, theFace, aFirst, aLast);
+
+  if (!theCurve.IsNull() && myCopyGeom)
+    theCurve = Handle(Geom2d_Curve)::DownCast(theCurve->Copy());
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewParameter
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_CopyModification::NewParameter(const TopoDS_Vertex& theVertex,
+                                                          const TopoDS_Edge&   theEdge,
+                                                          Standard_Real&       thePnt,
+                                                          Standard_Real&       theTol)
+{
+  if (theVertex.IsNull())
+    return Standard_False; // infinite edge may have Null vertex
+
+  theTol = BRep_Tool::Tolerance(theVertex);
+  thePnt = BRep_Tool::Parameter(theVertex, theEdge);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Continuity
+//purpose  : 
+//=======================================================================
+GeomAbs_Shape BRepTools_CopyModification::Continuity(const TopoDS_Edge& theEdge,
+                                                     const TopoDS_Face& theFace1,
+                                                     const TopoDS_Face& theFace2,
+                                                     const TopoDS_Edge&,
+                                                     const TopoDS_Face&,
+                                                     const TopoDS_Face&)
+{
+  return BRep_Tool::Continuity(theEdge, theFace1, theFace2);
+}
+
+

src/BRepTools/BRepTools_CopyModification.hxx

@@ -0,0 +1,124 @@
+// Copyright (c) 1999-2022 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 _BRepTools_CopyModification_HeaderFile
+#define _BRepTools_CopyModification_HeaderFile
+
+#include <BRepTools_Modification.hxx>
+
+class BRepTools_CopyModification;
+DEFINE_STANDARD_HANDLE(BRepTools_CopyModification, BRepTools_Modification)
+
+//! Tool class implementing necessary functionality for copying geometry and triangulation.
+class BRepTools_CopyModification : public BRepTools_Modification
+{
+public:
+  //! Constructor.
+  //! \param[in] theCopyGeom  indicates that the geomtery (surfaces and curves) should be copied
+  //! \param[in] theCopyMesh  indicates that the triangulation should be copied
+  Standard_EXPORT explicit BRepTools_CopyModification(const Standard_Boolean theCopyGeom = Standard_True,
+                                                      const Standard_Boolean theCopyMesh = Standard_True);
+  
+  //! Returns true if theFace has been modified.
+  //! If the face has been modified:
+  //! - theSurf is the new geometry of the face,
+  //! - theLoc is its new location, and
+  //! - theTol is the new tolerance.
+  //! theRevWires, theRevFace are always set to false, because the orientaion is not changed.
+  Standard_EXPORT Standard_Boolean NewSurface(const TopoDS_Face&    theFace,
+                                              Handle(Geom_Surface)& theSurf,
+                                              TopLoc_Location&      theLoc,
+                                              Standard_Real&        theTol,
+                                              Standard_Boolean&     theRevWires,
+                                              Standard_Boolean&     theRevFace) Standard_OVERRIDE;
+
+  //! Returns true if theEdge has been modified.
+  //! If the edge has been modified:
+  //! - theCurve is the new geometric support of the edge,
+  //! - theLoc is the new location, and
+  //! - theTol is the new tolerance.
+  //! If the edge has not been modified, this function
+  //! returns false, and the values of theCurve, theLoc and theTol are not significant.
+  Standard_EXPORT Standard_Boolean NewCurve(const TopoDS_Edge&  theEdge,
+                                            Handle(Geom_Curve)& theCurve,
+                                            TopLoc_Location&    theLoc,
+                                            Standard_Real&      theTol) Standard_OVERRIDE;
+  
+  //! Returns true if theVertex has been modified.
+  //! If the vertex has been modified:
+  //! - thePnt is the new geometry of the vertex, and
+  //! - theTol is the new tolerance.
+  //! If the vertex has not been modified this function
+  //! returns false, and the values of thePnt and theTol are not significant.
+  Standard_EXPORT Standard_Boolean NewPoint(const TopoDS_Vertex& theVertex, gp_Pnt& thePnt, Standard_Real& theTol) Standard_OVERRIDE;
+  
+  //! Returns true if theEdge has a new curve on surface on theFace.
+  //! If a new curve exists:
+  //! - theCurve is the new geometric support of the edge,
+  //! - theTol the new tolerance.
+  //! If no new curve exists, this function returns false, and
+  //! the values of theCurve and theTol are not significant.
+  Standard_EXPORT Standard_Boolean NewCurve2d(const TopoDS_Edge&    theEdge,
+                                              const TopoDS_Face&    theFace,
+                                              const TopoDS_Edge&    theNewEdge,
+                                              const TopoDS_Face&    theNewFace,
+                                              Handle(Geom2d_Curve)& theCurve,
+                                              Standard_Real&        theTol) Standard_OVERRIDE;
+  
+  //! Returns true if theVertex has a new parameter on theEdge.
+  //! If a new parameter exists:
+  //! - thePnt is the parameter, and
+  //! - theTol is the new tolerance.
+  //! If no new parameter exists, this function returns false,
+  //! and the values of thePnt and theTol are not significant.
+  Standard_EXPORT Standard_Boolean NewParameter(const TopoDS_Vertex& theVertex,
+                                                const TopoDS_Edge&   theEdge,
+                                                Standard_Real&       thePnt,
+                                                Standard_Real&       theTol) Standard_OVERRIDE;
+  
+  //! Returns the continuity of theNewEdge between theNewFace1 and theNewFace2.
+  //!
+  //! theNewEdge is the new edge created from theEdge.  theNewFace1
+  //! (resp. theNewFace2) is the new face created from theFace1 (resp. theFace2).
+  Standard_EXPORT GeomAbs_Shape Continuity(const TopoDS_Edge& theEdge,
+                                           const TopoDS_Face& theFace1,
+                                           const TopoDS_Face& theFace2,
+                                           const TopoDS_Edge& theNewEdge,
+                                           const TopoDS_Face& theNewFace1,
+                                           const TopoDS_Face& theNewFace2) Standard_OVERRIDE;
+
+  //! Returns true if the face has been modified according to changed triangulation.
+  //! If the face has been modified:
+  //! - theTri is a new triangulation on the face
+  Standard_EXPORT Standard_Boolean NewTriangulation(const TopoDS_Face& theFace, Handle(Poly_Triangulation)& theTri) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon.
+  //! If the edge has been modified:
+  //! - thePoly is a new polygon
+  Standard_EXPORT Standard_Boolean NewPolygon(const TopoDS_Edge& theEdge, Handle(Poly_Polygon3D)& thePoly) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon on triangulation.
+  //! If the edge has been modified:
+  //! - thePoly is a new polygon on triangulation
+  Standard_EXPORT Standard_Boolean NewPolygonOnTriangulation(const TopoDS_Edge&                   theEdge,
+                                                             const TopoDS_Face&                   theFace,
+                                                             Handle(Poly_PolygonOnTriangulation)& thePoly) Standard_OVERRIDE;
+
+  DEFINE_STANDARD_RTTIEXT(BRepTools_CopyModification, BRepTools_Modification)
+
+private:
+  Standard_Boolean myCopyGeom;
+  Standard_Boolean myCopyMesh;
+};
+
+#endif // _BRepTools_CopyModification_HeaderFile

src/BRepTools/BRepTools_GTrsfModification.cxx

@@ -29,6 +29,7 @@
 #include <GeomLib.hxx>
 #include <gp_GTrsf.hxx>
 #include <gp_Pnt.hxx>
+#include <gp_Quaternion.hxx>
 #include <gp_XYZ.hxx>
 #include <Standard_NoSuchObject.hxx>
 #include <Standard_Type.hxx>
@@ -88,7 +89,13 @@ Standard_Boolean BRepTools_GTrsfModification::NewSurface
   gp_GTrsf gtrsf;
   gtrsf.SetVectorialPart(myGTrsf.VectorialPart());
   gtrsf.SetTranslationPart(myGTrsf.TranslationPart());
-  S = Handle(Geom_Surface)::DownCast(BRep_Tool::Surface(F,L)->Copy());
+  S = BRep_Tool::Surface(F, L);
+  if (S.IsNull())
+  {
+    //processing the case when there is no geometry
+    return Standard_False;
+  }
+  S = Handle(Geom_Surface)::DownCast(S->Copy());
 
   Tol = BRep_Tool::Tolerance(F);
   Tol *= myGScale;
@@ -173,7 +180,7 @@ Standard_Boolean BRepTools_GTrsfModification::NewCurve
     C = new Geom_TrimmedCurve(C, f, l);
   }
   L.Identity() ;  
-  return Standard_True;
+  return !C.IsNull();
 }
 
 //=======================================================================
@@ -214,6 +221,11 @@ Standard_Boolean BRepTools_GTrsfModification::NewCurve2d
   Tol *= myGScale;
   Standard_Real f,l;
   C = BRep_Tool::CurveOnSurface(E,F,f,l);
+  if (C.IsNull())
+  {
+    //processing the case when there is no geometry
+    return Standard_False;
+  }
   C = new Geom2d_TrimmedCurve(C, f, l);
   return Standard_True;
 }
@@ -251,4 +263,113 @@ GeomAbs_Shape BRepTools_GTrsfModification::Continuity
   return BRep_Tool::Continuity(E,F1,F2);
 }
 
+//=======================================================================
+//function : NewTriangulation
+//purpose  : 
+//=======================================================================
 
+Standard_Boolean BRepTools_GTrsfModification::NewTriangulation(const TopoDS_Face&          theFace,
+                                                               Handle(Poly_Triangulation)& theTriangulation)
+{
+  TopLoc_Location aLoc;
+  theTriangulation = BRep_Tool::Triangulation(theFace, aLoc);
+  if (theTriangulation.IsNull())
+  {
+    return Standard_False;
+  }
+
+  gp_GTrsf aGTrsf;
+  aGTrsf.SetVectorialPart(myGTrsf.VectorialPart());
+  aGTrsf.SetTranslationPart(myGTrsf.TranslationPart());
+  aGTrsf.Multiply(aLoc.Transformation());
+
+  theTriangulation = theTriangulation->Copy();
+  theTriangulation->SetCachedMinMax(Bnd_Box()); // clear bounding box
+  theTriangulation->Deflection(theTriangulation->Deflection() * Abs(myGScale));
+  // apply transformation to 3D nodes
+  for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbNodes(); ++anInd)
+  {
+    gp_Pnt aP = theTriangulation->Node(anInd);
+    aGTrsf.Transforms(aP.ChangeCoord());
+    theTriangulation->SetNode(anInd, aP);
+  }
+  // modify triangles orientation in case of mirror transformation
+  if (myGScale < 0.0)
+  {
+    for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbTriangles(); ++anInd)
+    {
+      Poly_Triangle aTria = theTriangulation->Triangle(anInd);
+      Standard_Integer aN1, aN2, aN3;
+      aTria.Get(aN1, aN2, aN3);
+      aTria.Set(aN1, aN3, aN2);
+      theTriangulation->SetTriangle(anInd, aTria);
+    }
+  }
+  // modify normals
+  if (theTriangulation->HasNormals())
+  {
+    for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbTriangles(); ++anInd)
+    {
+      gp_Dir aNormal = theTriangulation->Normal(anInd);
+      aNormal.Transform(aGTrsf.Trsf());
+      theTriangulation->SetNormal(anInd, aNormal);
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPolygon
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_GTrsfModification::NewPolygon(const TopoDS_Edge&      theEdge,
+                                                         Handle(Poly_Polygon3D)& thePoly)
+{
+  TopLoc_Location aLoc;
+  thePoly = BRep_Tool::Polygon3D(theEdge, aLoc);
+  if (thePoly.IsNull())
+  {
+    return Standard_False;
+  }
+
+  gp_GTrsf aGTrsf;
+  aGTrsf.SetVectorialPart(myGTrsf.VectorialPart());
+  aGTrsf.SetTranslationPart(myGTrsf.TranslationPart());
+  aGTrsf.Multiply(aLoc.Transformation());
+
+  thePoly = thePoly->Copy();
+  thePoly->Deflection(thePoly->Deflection() * Abs(myGScale));
+  // transform nodes
+  TColgp_Array1OfPnt& aNodesArray = thePoly->ChangeNodes();
+  for (Standard_Integer anId = aNodesArray.Lower(); anId <= aNodesArray.Upper(); ++anId)
+  {
+    gp_Pnt& aP = aNodesArray.ChangeValue(anId);
+    aGTrsf.Transforms(aP.ChangeCoord());
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPolygonOnTriangulation
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_GTrsfModification::NewPolygonOnTriangulation
+ (const TopoDS_Edge& theEdge,
+  const TopoDS_Face& theFace,
+  Handle(Poly_PolygonOnTriangulation)& thePoly)
+{
+  TopLoc_Location aLoc;
+  Handle(Poly_Triangulation) aT = BRep_Tool::Triangulation(theFace, aLoc);
+  if (aT.IsNull())
+  {
+    return Standard_False;
+  }
+
+  thePoly = BRep_Tool::PolygonOnTriangulation(theEdge, aT, aLoc);
+  if (!thePoly.IsNull())
+    thePoly = thePoly->Copy();
+  return Standard_True;
+}

src/BRepTools/BRepTools_GTrsfModification.hxx

@@ -101,6 +101,25 @@ public:
   //! (resp. <F2>).
   Standard_EXPORT GeomAbs_Shape Continuity (const TopoDS_Edge& E, const TopoDS_Face& F1, const TopoDS_Face& F2, const TopoDS_Edge& NewE, const TopoDS_Face& NewF1, const TopoDS_Face& NewF2) Standard_OVERRIDE;
 
+  //! Returns true if the face has been modified according to changed triangulation.
+  //! If the face has been modified:
+  //! - theTri is a new triangulation on the face
+  Standard_EXPORT Standard_Boolean NewTriangulation(const TopoDS_Face&          theFace,
+                                                    Handle(Poly_Triangulation)& theTri) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon.
+  //! If the edge has been modified:
+  //! - thePoly is a new polygon
+  Standard_EXPORT Standard_Boolean NewPolygon(const TopoDS_Edge&      theEdge,
+                                              Handle(Poly_Polygon3D)& thePoly) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon on triangulation.
+  //! If the edge has been modified:
+  //! - thePoly is a new polygon on triangulation
+  Standard_EXPORT Standard_Boolean NewPolygonOnTriangulation(const TopoDS_Edge&                   theEdge,
+                                                             const TopoDS_Face&                   theFace,
+                                                             Handle(Poly_PolygonOnTriangulation)& thePoly) Standard_OVERRIDE;
+
 
 
 

src/BRepTools/BRepTools_NurbsConvertModification.cxx

@@ -20,7 +20,10 @@
 #include <BRep_TEdge.hxx>
 #include <BRepTools.hxx>
 #include <ElSLib.hxx>
+#include <Extrema_ExtPC2d.hxx>
+#include <Extrema_GenLocateExtPS.hxx>
 #include <Extrema_LocateExtPC.hxx>
+#include <Extrema_LocateExtPC2d.hxx>
 #include <Geom2d_BezierCurve.hxx>
 #include <Geom2d_Curve.hxx>
 #include <Geom2d_TrimmedCurve.hxx>
@@ -47,32 +50,165 @@
 #include <TopLoc_Location.hxx>
 #include <TopoDS_Edge.hxx>
 #include <BRep_Builder.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepTools_NurbsConvertModification,BRepTools_Modification)
+
+IMPLEMENT_STANDARD_RTTIEXT(BRepTools_NurbsConvertModification,BRepTools_CopyModification)
 
 //
+namespace
+{
   static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface,
                                     const Standard_Real newU1,
                                     const Standard_Real newU2)
   {
     TColStd_Array1OfReal  knots(1, aSurface->NbUKnots());
     aSurface->UKnots(knots);
-  BSplCLib::Reparametrize(newU1,
-              newU2,
-              knots) ;
+    BSplCLib::Reparametrize(newU1, newU2, knots);
     aSurface->SetUKnots(knots);
   }
+
   static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface,
                                     const Standard_Real newV1,
                                     const Standard_Real newV2)
   {
     TColStd_Array1OfReal  knots(1, aSurface->NbVKnots());
     aSurface->VKnots(knots);
-  BSplCLib::Reparametrize(newV1,
-              newV2,
-              knots) ;
+    BSplCLib::Reparametrize(newV1, newV2, knots);
     aSurface->SetVKnots(knots);
   }
 
+  // find 3D curve from theEdge in theMap, and return the transformed curve or NULL
+  static Handle(Geom_Curve) newCurve(const TColStd_IndexedDataMapOfTransientTransient& theMap,
+                                     const TopoDS_Edge& theEdge,
+                                     Standard_Real& theFirst,
+                                     Standard_Real& theLast)
+  {
+    Handle(Geom_Curve) aNewCurve;
+
+    TopLoc_Location aLoc;
+    Handle(Geom_Curve) aCurve = BRep_Tool::Curve(theEdge, aLoc, theFirst, theLast);
+    if (!aCurve.IsNull() && theMap.Contains(aCurve))
+    {
+      aNewCurve = Handle(Geom_Curve)::DownCast(theMap.FindFromKey(aCurve));
+      aNewCurve = Handle(Geom_Curve)::DownCast(aNewCurve->Transformed(aLoc.Transformation()));
+    }
+    return aNewCurve;
+  }
+
+  // find 2D curve from theEdge on theFace in theMap, and return the transformed curve or NULL
+  static Handle(Geom2d_Curve) newCurve(const TColStd_IndexedDataMapOfTransientTransient& theMap,
+                                       const TopoDS_Edge& theEdge,
+                                       const TopoDS_Face& theFace,
+                                       Standard_Real& theFirst,
+                                       Standard_Real& theLast)
+  {
+    Handle(Geom2d_Curve) aC2d = BRep_Tool::CurveOnSurface(theEdge, theFace, theFirst, theLast);
+    return (!aC2d.IsNull() && theMap.Contains(aC2d)) ? Handle(Geom2d_Curve)::DownCast(theMap.FindFromKey(aC2d))
+                                                     : Handle(Geom2d_Curve)();
+  }
+
+  // find surface from theFace in theMap, and return the transformed surface or NULL
+  static Handle(Geom_Surface) newSurface(const TColStd_IndexedDataMapOfTransientTransient& theMap,
+                                         const TopoDS_Face& theFace)
+  {
+    Handle(Geom_Surface) aNewSurf;
+
+    TopLoc_Location aLoc;
+    Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace, aLoc);
+    if (!aSurf.IsNull() && theMap.Contains(aSurf))
+    {
+      aNewSurf = Handle(Geom_Surface)::DownCast(theMap.FindFromKey(aSurf));
+      aNewSurf = Handle(Geom_Surface)::DownCast(aNewSurf->Transformed(aLoc.Transformation()));
+    }
+    return aNewSurf;
+  }
+
+  static Standard_Boolean newParameter(const gp_Pnt& thePoint,
+                                       const Handle(Geom_Curve)& theCurve,
+                                       const Standard_Real theFirst,
+                                       const Standard_Real theLast,
+                                       const Standard_Real theTol,
+                                       Standard_Real& theParam)
+  {
+    GeomAdaptor_Curve anAdaptor(theCurve);
+    Extrema_LocateExtPC proj(thePoint, anAdaptor, theParam, theFirst, theLast, Precision::PConfusion());
+    if (proj.IsDone())
+    {
+      Standard_Real aDist2Min = proj.SquareDistance();
+      if (aDist2Min < theTol * theTol)
+      {
+        theParam = proj.Point().Parameter();
+        return Standard_True;
+      }
+    }
+    return Standard_False;
+  }
+
+  static Standard_Boolean newParameter(const gp_Pnt2d& theUV,
+                                       const Handle(Geom2d_Curve)& theCurve2d,
+                                       const Standard_Real theFirst,
+                                       const Standard_Real theLast,
+                                       const Standard_Real theTol,
+                                       Standard_Real& theParam)
+  {
+    Geom2dAdaptor_Curve anAdaptor(theCurve2d);
+    Extrema_LocateExtPC2d aProj(theUV, anAdaptor, theParam, Precision::PConfusion());
+    if (aProj.IsDone())
+    {
+      Standard_Real aDist2Min = aProj.SquareDistance();
+      if (aDist2Min < theTol * theTol)
+      {
+        theParam = aProj.Point().Parameter();
+        return Standard_True;
+      }
+    }
+    else
+    {
+      // Try to use general extrema to find the parameter, because Extrema_LocateExtPC2d
+      // sometimes could not find a solution if the parameter's first approach is several
+      // spans away from the expected solution (test bugs/modalg_7/bug28722).
+      Extrema_ExtPC2d anExt(theUV, anAdaptor, theFirst, theLast);
+      if (anExt.IsDone())
+      {
+        Standard_Integer aMinInd = 0;
+        Standard_Real aMinSqDist = Precision::Infinite();
+        for (Standard_Integer anIndex = 1; anIndex <= anExt.NbExt(); ++anIndex)
+          if (anExt.SquareDistance(anIndex) < aMinSqDist)
+          {
+            aMinSqDist = anExt.SquareDistance(anIndex);
+            aMinInd = anIndex;
+          }
+        if (aMinSqDist < theTol * theTol)
+        {
+          theParam = anExt.Point(aMinInd).Parameter();
+          return Standard_True;
+        }
+      }
+    }
+    return Standard_False;
+  }
+
+  static Standard_Boolean newUV(const gp_Pnt& thePoint,
+                                const Handle(Geom_Surface)& theSurf,
+                                const Standard_Real theTol,
+                                gp_Pnt2d& theUV)
+  {
+    GeomAdaptor_Surface anAdaptor(theSurf);
+    Extrema_GenLocateExtPS aProj(anAdaptor);
+    aProj.Perform(thePoint, theUV.X(), theUV.Y());
+    if (aProj.IsDone())
+    {
+      Standard_Real aDist2Min = aProj.SquareDistance();
+      if (aDist2Min < theTol * theTol)
+      {
+        gp_XY& aUV = theUV.ChangeCoord();
+        aProj.Point().Parameter(aUV.ChangeCoord(1), aUV.ChangeCoord(2));
+        return Standard_True;
+      }
+    }
+    return Standard_False;
+  }
+}
+
 //=======================================================================
 //function : BRepTools_NurbsConvertModification
 //purpose  : 
@@ -102,6 +238,12 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
   RevWires = Standard_False;
   RevFace = Standard_False;
   Handle(Geom_Surface) SS = BRep_Tool::Surface(F,L);
+  if (SS.IsNull())
+  {
+    //processing the case when there is no geometry
+    return Standard_False;
+  }
+
   Handle(Standard_Type) TheTypeSS = SS->DynamicType();
   if ((TheTypeSS == STANDARD_TYPE(Geom_BSplineSurface)) ||
       (TheTypeSS == STANDARD_TYPE(Geom_BezierSurface))) {
@@ -115,7 +257,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
   //OCC466(apo)->
   U1 = curvU1;  U2 = curvU2;  
   V1 = curvV1;  V2 = curvV2;
-  SS->Bounds(surfU1,surfU2,surfV1,surfV2);
+  S->Bounds(surfU1,surfU2,surfV1,surfV2);
 
   if (Abs(U1 - surfU1) <= TolPar)
     U1 = surfU1;
@@ -192,10 +334,10 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
 
   if (Abs(surfU1-U1) > Tol || Abs(surfU2-U2) > Tol ||
       Abs(surfV1-V1) > Tol || Abs(surfV2-V2) > Tol)
-    SS = new Geom_RectangularTrimmedSurface(S, U1, U2, V1, V2);
-  SS->Bounds(surfU1,surfU2,surfV1,surfV2); 
+    S = new Geom_RectangularTrimmedSurface(S, U1, U2, V1, V2);
+  S->Bounds(surfU1,surfU2,surfV1,surfV2); 
 
-  S = GeomConvert::SurfaceToBSplineSurface(SS);
+  S = GeomConvert::SurfaceToBSplineSurface(S);
   Handle(Geom_BSplineSurface) BS = Handle(Geom_BSplineSurface)::DownCast(S) ;
   BS->Resolution(Tol, UTol, VTol) ;
   
@@ -210,6 +352,9 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
     GeomLib_ChangeVBounds(BS, V1, V2) ;
   }
 
+  if (!myMap.Contains(SS)) {
+    myMap.Add(SS, S);
+  }
   return Standard_True;
 }
 
@@ -234,6 +379,41 @@ static Standard_Boolean IsConvert(const TopoDS_Edge& E)
   
 }
 
+//=======================================================================
+//function : NewTriangulation
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_NurbsConvertModification::NewTriangulation(const TopoDS_Face&          theFace,
+                                                                      Handle(Poly_Triangulation)& theTri)
+{
+  if (!BRepTools_CopyModification::NewTriangulation(theFace, theTri))
+  {
+    return Standard_False;
+  }
+
+  // convert UV nodes of the mesh
+  if (theTri->HasUVNodes())
+  {
+    TopLoc_Location aLoc;
+    Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace, aLoc);
+    Handle(Geom_Surface) aNewSurf = newSurface(myMap, theFace);
+    if (!aSurf.IsNull() && !aNewSurf.IsNull())
+    {
+      Standard_Real aTol = BRep_Tool::Tolerance(theFace);
+      for (Standard_Integer anInd = 1; anInd <= theTri->NbNodes(); ++anInd)
+      {
+        gp_Pnt2d aUV = theTri->UVNode(anInd);
+        gp_Pnt aPoint = aSurf->Value(aUV.X(), aUV.Y());
+        if (newUV(aPoint, aNewSurf, aTol, aUV))
+          theTri->SetUVNode(anInd, aUV);
+      }
+    }
+  }
+
+  return Standard_True;
+}
+
 //=======================================================================
 //function : NewCurve
 //purpose  : 
@@ -312,6 +492,40 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve
   return Standard_True ;
 }
 
+//=======================================================================
+//function : NewPolygon
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_NurbsConvertModification::NewPolygon(const TopoDS_Edge&      theEdge,
+                                                                Handle(Poly_Polygon3D)& thePoly)
+{
+  if (!BRepTools_CopyModification::NewPolygon(theEdge, thePoly))
+  {
+    return Standard_False;
+  }
+
+  // update parameters of polygon
+  if (thePoly->HasParameters())
+  {
+    Standard_Real aTol = BRep_Tool::Tolerance(theEdge);
+    Standard_Real aFirst, aLast;
+    Handle(Geom_Curve) aCurve = BRep_Tool::Curve(theEdge, aFirst, aLast);
+    Handle(Geom_Curve) aNewCurve = newCurve(myMap, theEdge, aFirst, aLast);
+    if (!aCurve.IsNull() && !aNewCurve.IsNull()) // skip processing degenerated edges
+    {
+      TColStd_Array1OfReal& aParams = thePoly->ChangeParameters();
+      for (Standard_Integer anInd = aParams.Lower(); anInd <= aParams.Upper(); ++anInd)
+      {
+        Standard_Real& aParam = aParams(anInd);
+        gp_Pnt aPoint = aCurve->Value(aParam);
+        newParameter(aPoint, aNewCurve, aFirst, aLast, aTol, aParam);
+      }
+    }
+  }
+  return Standard_True;
+}
+
 //=======================================================================
 //function : NewPoint
 //purpose  : 
@@ -340,7 +554,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
 
   Tol = BRep_Tool::Tolerance(E);
   Standard_Real f2d,l2d;
-  Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E,F,f2d,l2d);
+  Handle(Geom2d_Curve) aBaseC2d = BRep_Tool::CurveOnSurface(E,F,f2d,l2d);
   Standard_Real f3d,l3d;
   TopLoc_Location Loc;
   Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, Loc, f3d,l3d);
@@ -348,6 +562,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
     !C3d->IsKind(STANDARD_TYPE(Geom_BezierCurve))) ||
     IsConvert(E));
 
+  Handle(Geom2d_Curve) C2d = aBaseC2d;
   if(BRep_Tool::Degenerated(E)) {
     //Curve2d = C2d;
     if(!C2d->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve)))
@@ -356,6 +571,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
       C2d = aTrimC;
     }
     Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
+    myMap.Add(aBaseC2d, Curve2d);
     return Standard_True;
   }
   if(!BRepTools::IsReallyClosed(E,F)) {
@@ -381,9 +597,11 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
     if(!newE.IsNull()) {
       C3d = BRep_Tool::Curve(newE, f3d, l3d);
     }
-    else {
+    if (C3d.IsNull()) {
       C3d = BRep_Tool::Curve(E,f3d,l3d);
     }
+    if (C3d.IsNull())
+      return Standard_False;
     GeomAdaptor_Curve   G3dAC(C3d, f3d, l3d);
     Handle(GeomAdaptor_Curve) G3dAHC = new GeomAdaptor_Curve(G3dAC);
     
@@ -403,13 +621,16 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
               Tol = newTol;
               myUpdatedEdges.Append(newE);
             }
+            myMap.Add(aBaseC2d, Curve2d);
             return Standard_True;
           }
           return Standard_False;
         }
       }
       else {
-        S = BRep_Tool::Surface(newF);
+        Handle(Geom_Surface) aNewS = BRep_Tool::Surface(newF);
+        if (!aNewS.IsNull())
+          S = aNewS;
       }
       S->Bounds(Uinf, Usup, Vinf, Vsup);
       //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
@@ -451,6 +672,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
           Tol = newTol;
           myUpdatedEdges.Append(newE);
         }
+        myMap.Add(aBaseC2d, Curve2d);
         return Standard_True;
       }
       Curve2d = ProjOnCurve.BSpline();
@@ -460,6 +682,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
         Tol = newTol;
         myUpdatedEdges.Append(newE);
       }
+      myMap.Add(aBaseC2d, Curve2d);
       return Standard_True;
     }
 
@@ -502,6 +725,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
         Tol = newTol;
         myUpdatedEdges.Append(newE);
       }
+      myMap.Add(aBaseC2d, Curve2d);
       return Standard_True;
     }
     else {
@@ -512,6 +736,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
         Tol = newTol;
         myUpdatedEdges.Append(newE);
       }
+      myMap.Add(aBaseC2d, Curve2d);
       return Standard_True;
     }
   }
@@ -557,6 +782,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
              Tol = newTol;
              myUpdatedEdges.Append(newE);
            }
+           myMap.Add(aBaseC2d, Curve2d);
            return Standard_True;
          }
         return Standard_False;
@@ -582,6 +808,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
               Tol = newTol;
               myUpdatedEdges.Append(newE);
             }
+            myMap.Add(aBaseC2d, Curve2d);
             return Standard_True;
           }
           return Standard_False;
@@ -629,6 +856,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
           Tol = newTol;
           myUpdatedEdges.Append(newE);
         }
+        myMap.Add(aBaseC2d, Curve2d);
         return Standard_True;
       }
       else {
@@ -640,6 +868,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
           myUpdatedEdges.Append(newE);
         }
         mylcu.Append(C2dBis);
+        myMap.Add(aBaseC2d, Curve2d);
         return Standard_True;
       }
     }
@@ -651,11 +880,58 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
         return Standard_False;
       }
       Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
+      myMap.Add(aBaseC2d, Curve2d);
       return Standard_True;
     }
   }
 }
 
+//=======================================================================
+//function : NewPolygonOnTriangulation
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepTools_NurbsConvertModification::NewPolygonOnTriangulation(
+  const TopoDS_Edge&                   theEdge,
+  const TopoDS_Face&                   theFace,
+  Handle(Poly_PolygonOnTriangulation)& thePoly)
+{
+  if (!BRepTools_CopyModification::NewPolygonOnTriangulation(theEdge, theFace, thePoly))
+  {
+    return Standard_False;
+  }
+
+  // update parameters of 2D polygon
+  if (thePoly->HasParameters())
+  {
+    Standard_Real aTol = Max(BRep_Tool::Tolerance(theEdge), thePoly->Deflection());
+    TopLoc_Location aLoc;
+    Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace, aLoc);
+    Handle(Geom_Surface) aNewSurf = newSurface(myMap, theFace);
+    Standard_Real aFirst, aLast;
+    Handle(Geom2d_Curve) aC2d = BRep_Tool::CurveOnSurface(theEdge, theFace, aFirst, aLast);
+    Handle(Geom2d_Curve) aNewC2d = newCurve(myMap, theEdge, theFace, aFirst, aLast);
+    if (!aSurf.IsNull() && !aC2d.IsNull() && !aNewSurf.IsNull() && !aNewC2d.IsNull())
+    {
+      // compute 2D tolerance
+      GeomAdaptor_Surface aSurfAdapt(aSurf);
+      Standard_Real aTol2D = Max(aSurfAdapt.UResolution(aTol), aSurfAdapt.VResolution(aTol));
+
+      for (Standard_Integer anInd = 1; anInd <= thePoly->NbNodes(); ++anInd)
+      {
+        Standard_Real aParam = thePoly->Parameter(anInd);
+        gp_Pnt2d aUV = aC2d->Value(aParam);
+        gp_Pnt aPoint = aSurf->Value(aUV.X(), aUV.Y());
+        if (newUV(aPoint, aNewSurf, aTol, aUV) &&
+            newParameter(aUV, aNewC2d, aFirst, aLast, aTol2D, aParam))
+        {
+          thePoly->SetParameter(anInd, aParam);
+        }
+      }
+    }
+  }
+  return Standard_True;
+}
+
 //=======================================================================
 //function : NewParameter
 //purpose  : 
@@ -670,30 +946,12 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewParameter
   Tol =  BRep_Tool::Tolerance(V);
   if(BRep_Tool::Degenerated(E))
     return Standard_False;
-  Standard_Real f, l, param = BRep_Tool::Parameter(V,E);
-  TopLoc_Location L;
 
-  Handle(Geom_Curve) gc = BRep_Tool::Curve(E, L, f, l);
-  if(!myMap.Contains(gc))
-    return Standard_False;
-
-  Handle(Geom_BSplineCurve) gcc = 
-    Handle(Geom_BSplineCurve)::DownCast(myMap.FindFromKey(gc));
-
-  gcc = Handle(Geom_BSplineCurve)::DownCast(gcc->Transformed(L.Transformation()));
-
-  GeomAdaptor_Curve ac(gcc);
   gp_Pnt pnt = BRep_Tool::Pnt(V);
-
-  Extrema_LocateExtPC proj(pnt, ac, param, f, l, Tol);
-  if(proj.IsDone()) {
-    Standard_Real Dist2Min = proj.SquareDistance();
-    if (Dist2Min < Tol*Tol) {
-      P = proj.Point().Parameter();
-      return Standard_True;
-    }
-  }
-  return Standard_False;
+  P = BRep_Tool::Parameter(V,E);
+  Standard_Real aFirst, aLast;
+  Handle(Geom_Curve) aNewCurve = newCurve(myMap, E, aFirst, aLast);
+  return !aNewCurve.IsNull() && newParameter(pnt, aNewCurve, aFirst, aLast, Tol, P);
 }
 
 //=======================================================================

src/BRepTools/BRepTools_NurbsConvertModification.hxx

@@ -22,7 +22,7 @@
 #include <TopTools_ListOfShape.hxx>
 #include <TColStd_ListOfTransient.hxx>
 #include <TColStd_IndexedDataMapOfTransientTransient.hxx>
-#include <BRepTools_Modification.hxx>
+#include <BRepTools_CopyModification.hxx>
 #include <Standard_Real.hxx>
 #include <GeomAbs_Shape.hxx>
 class TopoDS_Face;
@@ -36,12 +36,12 @@ class Geom2d_Curve;
 
 
 class BRepTools_NurbsConvertModification;
-DEFINE_STANDARD_HANDLE(BRepTools_NurbsConvertModification, BRepTools_Modification)
+DEFINE_STANDARD_HANDLE(BRepTools_NurbsConvertModification, BRepTools_CopyModification)
 
 //! Defines a modification of the  geometry by a  Trsf
 //! from gp. All methods return True and transform the
 //! geometry.
-class BRepTools_NurbsConvertModification : public BRepTools_Modification
+class BRepTools_NurbsConvertModification : public BRepTools_CopyModification
 {
 
 public:
@@ -100,11 +100,27 @@ public:
   //! (resp. <F2>).
   Standard_EXPORT GeomAbs_Shape Continuity (const TopoDS_Edge& E, const TopoDS_Face& F1, const TopoDS_Face& F2, const TopoDS_Edge& NewE, const TopoDS_Face& NewF1, const TopoDS_Face& NewF2) Standard_OVERRIDE;
 
+  //! Returns true if the face has been modified according to changed triangulation.
+  //! If the face has been modified:
+  //! - theTri is a new triangulation on the face
+  Standard_EXPORT Standard_Boolean NewTriangulation(const TopoDS_Face& theFace, Handle(Poly_Triangulation)& theTri) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon.
+  //! If the edge has been modified:
+  //! - thePoly is a new polygon
+  Standard_EXPORT Standard_Boolean NewPolygon(const TopoDS_Edge& theEdge, Handle(Poly_Polygon3D)& thePoly) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon on triangulation.
+  //! If the edge has been modified:
+  //! - thePoly is a new polygon on triangulation
+  Standard_EXPORT Standard_Boolean NewPolygonOnTriangulation(const TopoDS_Edge&                   theEdge,
+                                                             const TopoDS_Face&                   theFace,
+                                                             Handle(Poly_PolygonOnTriangulation)& thePoly) Standard_OVERRIDE;
+
   Standard_EXPORT const TopTools_ListOfShape& GetUpdatedEdges() const;
 
 
-
-  DEFINE_STANDARD_RTTIEXT(BRepTools_NurbsConvertModification,BRepTools_Modification)
+  DEFINE_STANDARD_RTTIEXT(BRepTools_NurbsConvertModification,BRepTools_CopyModification)
 
 protected:
 

src/BRepTools/BRepTools_TrsfModification.cxx

@@ -23,6 +23,7 @@
 #include <Geom_Surface.hxx>
 #include <GeomAdaptor_Surface.hxx>
 #include <GeomLib.hxx>
+#include <GeomLib_Tool.hxx>
 #include <gp_GTrsf2d.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
@@ -43,7 +44,8 @@ IMPLEMENT_STANDARD_RTTIEXT(BRepTools_TrsfModification,BRepTools_Modification)
 //purpose  : 
 //=======================================================================
 BRepTools_TrsfModification::BRepTools_TrsfModification(const gp_Trsf& T) :
-myTrsf(T)
+myTrsf(T),
+myCopyMesh(Standard_False)
 {
 }
 
@@ -58,6 +60,16 @@ gp_Trsf& BRepTools_TrsfModification::Trsf ()
   return myTrsf;
 }
 
+//=======================================================================
+//function : IsCopyMesh
+//purpose  :
+//=======================================================================
+
+Standard_Boolean& BRepTools_TrsfModification::IsCopyMesh()
+{
+  return myCopyMesh;
+}
+
 //=======================================================================
 //function : NewSurface
 //purpose  : 
@@ -72,6 +84,12 @@ Standard_Boolean BRepTools_TrsfModification::NewSurface
        Standard_Boolean& RevFace)
 {
   S = BRep_Tool::Surface(F,L);
+  if (S.IsNull())
+  {
+    //processing cases when there is no geometry
+    return Standard_False;
+  }
+
   Tol = BRep_Tool::Tolerance(F);
   Tol *= Abs(myTrsf.ScaleFactor());
   RevWires = Standard_False;
@@ -87,6 +105,194 @@ Standard_Boolean BRepTools_TrsfModification::NewSurface
   return Standard_True;
 }
 
+//=======================================================================
+//function : NewTriangulation
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_TrsfModification::NewTriangulation
+(const TopoDS_Face& theFace,
+  Handle(Poly_Triangulation)& theTriangulation)
+{
+  if (!myCopyMesh)
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc;
+  theTriangulation = BRep_Tool::Triangulation(theFace, aLoc);
+
+  if (theTriangulation.IsNull())
+  {
+    return Standard_False;
+  }
+
+  gp_Trsf aTrsf = myTrsf;
+  if (!aLoc.IsIdentity())
+  {
+    aTrsf = aLoc.Transformation().Inverted() * aTrsf * aLoc.Transformation();
+  }
+
+  theTriangulation = theTriangulation->Copy();
+  theTriangulation->SetCachedMinMax(Bnd_Box()); // clear bounding box
+  theTriangulation->Deflection(theTriangulation->Deflection() * Abs(myTrsf.ScaleFactor()));
+  // apply transformation to 3D nodes
+  for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbNodes(); ++anInd)
+  {
+    gp_Pnt aP = theTriangulation->Node(anInd);
+    aP.Transform(aTrsf);
+    theTriangulation->SetNode(anInd, aP);
+  }
+  // modify 2D nodes
+  Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace, aLoc);
+  if (theTriangulation->HasUVNodes() && !aSurf.IsNull())
+  {
+    for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbNodes(); ++anInd)
+    {
+      gp_Pnt2d aP2d = theTriangulation->UVNode(anInd);
+      aSurf->TransformParameters(aP2d.ChangeCoord().ChangeCoord(1),
+                                 aP2d.ChangeCoord().ChangeCoord(2),
+                                 myTrsf);
+      theTriangulation->SetUVNode(anInd, aP2d);
+    }
+  }
+  // modify triangles orientation in case of mirror transformation
+  if (myTrsf.ScaleFactor() < 0.0)
+  {
+    for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbTriangles(); ++anInd)
+    {
+      Poly_Triangle aTria = theTriangulation->Triangle(anInd);
+      Standard_Integer aN1, aN2, aN3;
+      aTria.Get(aN1, aN2, aN3);
+      aTria.Set(aN1, aN3, aN2);
+      theTriangulation->SetTriangle(anInd, aTria);
+    }
+  }
+  // modify normals
+  if (theTriangulation->HasNormals())
+  {
+    for (Standard_Integer anInd = 1; anInd <= theTriangulation->NbTriangles(); ++anInd)
+    {
+      gp_Dir aNormal = theTriangulation->Normal(anInd);
+      aNormal.Transform(aTrsf);
+      theTriangulation->SetNormal(anInd, aNormal);
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPolygon
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_TrsfModification::NewPolygon
+(const TopoDS_Edge& theE,
+  Handle(Poly_Polygon3D)& theP)
+{
+  if (!myCopyMesh)
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc;
+  theP = BRep_Tool::Polygon3D(theE, aLoc);
+  if (theP.IsNull())
+  {
+    return Standard_False;
+  }
+
+  gp_Trsf aTrsf = myTrsf;
+  if (!aLoc.IsIdentity())
+  {
+    aTrsf = aLoc.Transformation().Inverted() * aTrsf * aLoc.Transformation();
+  }
+
+  theP = theP->Copy();
+  theP->Deflection(theP->Deflection() * Abs(myTrsf.ScaleFactor()));
+  TColgp_Array1OfPnt& aNodesArray = theP->ChangeNodes();
+  for (Standard_Integer anId = aNodesArray.Lower(); anId <= aNodesArray.Upper(); ++anId)
+  {
+    //Applying the transformation to each node of polygon
+    aNodesArray.ChangeValue(anId).Transform(aTrsf);
+  }
+  // transform the parametrization
+  if (theP->HasParameters())
+  {
+    TopLoc_Location aCurveLoc;
+    Standard_Real aFirst, aLast;
+    Handle(Geom_Curve) aCurve = BRep_Tool::Curve(theE, aCurveLoc, aFirst, aLast);
+    if (!aCurve.IsNull())
+    {
+      Standard_Real aReparametrization = aCurve->ParametricTransformation(aTrsf);
+      if (Abs(aReparametrization - 1.0) > Precision::PConfusion())
+      {
+        TColStd_Array1OfReal& aParams = theP->ChangeParameters();
+        for (Standard_Integer anInd = aParams.Lower(); anInd <= aParams.Upper(); ++anInd)
+        {
+          aParams(anInd) *= aReparametrization;
+        }
+      }
+    }
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : NewPolygonOnTriangulation
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean BRepTools_TrsfModification::NewPolygonOnTriangulation
+(const TopoDS_Edge& theE,
+  const TopoDS_Face& theF,
+  Handle(Poly_PolygonOnTriangulation)& theP)
+{
+  if (!myCopyMesh)
+  {
+    return Standard_False;
+  }
+
+  TopLoc_Location aLoc;
+  Handle(Poly_Triangulation) aT = BRep_Tool::Triangulation(theF, aLoc);
+  if (aT.IsNull())
+  {
+    theP = Handle(Poly_PolygonOnTriangulation) ();
+    return Standard_False;
+  }
+
+  theP = BRep_Tool::PolygonOnTriangulation(theE, aT, aLoc);
+  if (theP.IsNull())
+  {
+    return Standard_False;
+  }
+  theP = theP->Copy();
+  theP->Deflection(theP->Deflection() * Abs(myTrsf.ScaleFactor()));
+
+  // transform the parametrization
+  Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theF, aLoc);
+  Standard_Real aFirst, aLast;
+  Handle(Geom2d_Curve) aC2d = BRep_Tool::CurveOnSurface(theE, theF, aFirst, aLast);
+  if (!aSurf.IsNull() && !aC2d.IsNull() && Abs(Abs(myTrsf.ScaleFactor()) - 1.0) > TopLoc_Location::ScalePrec())
+  {
+    gp_GTrsf2d aGTrsf = aSurf->ParametricTransformation(myTrsf);
+    if (aGTrsf.Form() != gp_Identity)
+    {
+      Handle(Geom2d_Curve) aNewC2d = GeomLib::GTransform(aC2d, aGTrsf);
+      for (Standard_Integer anInd = 1; anInd <= theP->NbNodes(); ++anInd)
+      {
+        Standard_Real aParam = theP->Parameter(anInd);
+        gp_Pnt2d aP2d = aC2d->Value(aParam);
+        aGTrsf.Transforms(aP2d.ChangeCoord());
+        GeomLib_Tool::Parameter(aNewC2d, aP2d, theP->Deflection(), aParam);
+        theP->SetParameter(anInd, aParam);
+      }
+    }
+  }
+
+  return Standard_True;
+}
 
 //=======================================================================
 //function : NewCurve
@@ -101,6 +307,10 @@ Standard_Boolean BRepTools_TrsfModification::NewCurve
 {
   Standard_Real f,l;
   C = BRep_Tool::Curve(E,L,f,l);
+  if (C.IsNull())
+  {
+    return Standard_False;
+  }
 
   Tol = BRep_Tool::Tolerance(E);
   Tol *= Abs(myTrsf.ScaleFactor());
@@ -153,6 +363,12 @@ Standard_Boolean BRepTools_TrsfModification::NewCurve2d
   Standard_Real scale = myTrsf.ScaleFactor();
   Tol *= Abs(scale);
   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,loc);
+
+  if (S.IsNull())
+  {
+    // processing the case when the surface (geometry) is deleted
+    return Standard_False;
+  }
   GeomAdaptor_Surface GAsurf(S);
   if (GAsurf.GetType() == GeomAbs_Plane)
     return Standard_False;

src/BRepTools/BRepTools_TrsfModification.hxx

@@ -51,6 +51,9 @@ public:
   //! modification. The transformation can be changed.
   Standard_EXPORT gp_Trsf& Trsf();
 
+  //! Sets a flag to indicate the need to copy mesh.
+  Standard_EXPORT Standard_Boolean& IsCopyMesh();
+  
   //! Returns true if the face F has been modified.
   //! If the face has been modified:
   //! - S is the new geometry of the face,
@@ -64,6 +67,21 @@ public:
   //! associated with this modification is negative.
   Standard_EXPORT Standard_Boolean NewSurface (const TopoDS_Face& F, Handle(Geom_Surface)& S, TopLoc_Location& L, Standard_Real& Tol, Standard_Boolean& RevWires, Standard_Boolean& RevFace) Standard_OVERRIDE;
   
+  //! Returns true if the face has been modified according to changed triangulation.
+  //! If the face has been modified:
+  //! - T is a new triangulation on the face
+  Standard_EXPORT Standard_Boolean NewTriangulation(const TopoDS_Face& F, Handle(Poly_Triangulation)& T) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon.
+  //! If the edge has been modified:
+  //! - P is a new polygon
+  Standard_EXPORT Standard_Boolean NewPolygon(const TopoDS_Edge& E, Handle(Poly_Polygon3D)& P) Standard_OVERRIDE;
+
+  //! Returns true if the edge has been modified according to changed polygon on triangulation.
+  //! If the edge has been modified:
+  //! - P is a new polygon on triangulation
+  Standard_EXPORT Standard_Boolean NewPolygonOnTriangulation(const TopoDS_Edge& E, const TopoDS_Face& F, Handle(Poly_PolygonOnTriangulation)& P) Standard_OVERRIDE;
+
   //! Returns true if the edge E has been modified.
   //! If the edge has been modified:
   //! - C is the new geometric support of the edge,
@@ -120,6 +138,7 @@ private:
 
 
   gp_Trsf myTrsf;
+  Standard_Boolean myCopyMesh;
 
 
 };

src/BRepTools/FILES

@@ -1,5 +1,7 @@
 BRepTools.cxx
 BRepTools.hxx
+BRepTools_CopyModification.cxx
+BRepTools_CopyModification.hxx
 BRepTools_DataMapIteratorOfMapOfVertexPnt2d.hxx
 BRepTools_Debug.cxx
 BRepTools_GTrsfModification.cxx

src/BVH/BVH_Box.hxx

@@ -64,19 +64,18 @@ public:
   //! given transformation to this box.
   BVH_Box<T, 3> Transformed (const NCollection_Mat4<T>& theTransform) const
   {
-    BVH_Box<T, 3> aResultBox;
-
+    const BVH_Box<T, 3> *aThis = static_cast<const BVH_Box<T, 3>*>(this);
     if (theTransform.IsIdentity())
     {
-      return aResultBox;
+      return *aThis;
     }
 
-    const BVH_Box<T, 3> *aThis = static_cast<const BVH_Box<T, 3>*>(this);
     if (!aThis->IsValid())
     {
-      return aResultBox;
+      return *aThis;
     }
 
+    BVH_Box<T, 3> aResultBox;
     for (size_t aX = 0; aX <= 1; ++aX)
     {
       for (size_t aY = 0; aY <= 1; ++aY)

src/BVH/BVH_Tools.hxx

@@ -30,6 +30,15 @@ public: //! @name public types
 
   typedef typename BVH::VectorType<T, N>::Type BVH_VecNt;
 
+public:
+
+  enum BVH_PrjStateInTriangle
+  {
+    BVH_PrjStateInTriangle_VERTEX,
+    BVH_PrjStateInTriangle_EDGE,
+    BVH_PrjStateInTriangle_INNER
+  };
+
 public: //! @name Box-Box Square distance
 
   //! Computes Square distance between Axis aligned bounding boxes
@@ -113,11 +122,14 @@ public: //! @name Point-Box projection
 
 public: //! @name Point-Triangle Square distance
 
-  //! Computes square distance between point and triangle
-  static T PointTriangleSquareDistance (const BVH_VecNt& thePoint,
+  //! Find nearest point on a triangle for the given point
+  static BVH_VecNt PointTriangleProjection (const BVH_VecNt& thePoint,
                                             const BVH_VecNt& theNode0,
                                             const BVH_VecNt& theNode1,
-                                        const BVH_VecNt& theNode2)
+                                            const BVH_VecNt& theNode2,
+                                            BVH_PrjStateInTriangle* thePrjState = nullptr,
+                                            Standard_Integer* theNumberOfFirstNode = nullptr,
+                                            Standard_Integer* theNumberOfLastNode = nullptr)
   {
     const BVH_VecNt aAB = theNode1 - theNode0;
     const BVH_VecNt aAC = theNode2 - theNode0;
@@ -128,7 +140,13 @@ public: //! @name Point-Triangle Square distance
   
     if (aABdotAP <= 0. && aACdotAP <= 0.)
     {
-      return aAP.Dot(aAP);
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_VERTEX;
+        *theNumberOfFirstNode = 0;
+        *theNumberOfLastNode = 0;
+      }
+      return theNode0;
     }
 
     const BVH_VecNt aBC = theNode2 - theNode1;
@@ -139,7 +157,13 @@ public: //! @name Point-Triangle Square distance
 
     if (aBAdotBP <= 0. && aBCdotBP <= 0.)
     {
-      return (aBP.Dot(aBP));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_VERTEX;
+        *theNumberOfFirstNode = 1;
+        *theNumberOfLastNode = 1;
+      }
+      return theNode1;
     }
 
     const BVH_VecNt aCP = thePoint - theNode2;
@@ -149,7 +173,13 @@ public: //! @name Point-Triangle Square distance
 
     if (aCAdotCP <= 0. && aCBdotCP <= 0.)
     {
-      return (aCP.Dot(aCP));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_VERTEX;
+        *theNumberOfFirstNode = 2;
+        *theNumberOfLastNode = 2;
+      }
+      return theNode2;
     }
 
     T aACdotBP = (aAC.Dot (aBP));
@@ -158,9 +188,13 @@ public: //! @name Point-Triangle Square distance
 
     if (aVC <= 0. && aABdotAP > 0. && aBAdotBP > 0.)
     {
-      const BVH_VecNt aDirect = aAP - aAB * (aABdotAP / (aABdotAP + aBAdotBP));
-  
-      return (aDirect.Dot(aDirect));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_EDGE;
+        *theNumberOfFirstNode = 0;
+        *theNumberOfLastNode = 1;
+      }
+      return theNode0 + aAB * (aABdotAP / (aABdotAP + aBAdotBP));
     }
 
     T aABdotCP = (aAB.Dot (aCP));
@@ -169,27 +203,47 @@ public: //! @name Point-Triangle Square distance
 
     if (aVA <= 0. && aBCdotBP > 0. && aCBdotCP > 0.)
     {
-      const BVH_VecNt aDirect = aBP - aBC * (aBCdotBP / (aBCdotBP + aCBdotCP));
-  
-      return (aDirect.Dot(aDirect));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_EDGE;
+        *theNumberOfFirstNode = 1;
+        *theNumberOfLastNode = 2;
+      }
+      return theNode1 + aBC * (aBCdotBP / (aBCdotBP + aCBdotCP));
     }
 
     T aVB = aABdotCP * aACdotAP + aABdotAP * aCAdotCP;
 
     if (aVB <= 0. && aACdotAP > 0. && aCAdotCP > 0.)
     {
-      const BVH_VecNt aDirect = aAP - aAC * (aACdotAP / (aACdotAP + aCAdotCP));
-  
-      return (aDirect.Dot(aDirect));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_EDGE;
+        *theNumberOfFirstNode = 2;
+        *theNumberOfLastNode = 0;
+      }
+      return theNode0 + aAC * (aACdotAP / (aACdotAP + aCAdotCP));
     }
 
     T aNorm = aVA + aVB + aVC;
 
-    const BVH_VecNt& aDirect = thePoint - (theNode0 * aVA +
-                                           theNode1 * aVB +
-                                           theNode2 * aVC) / aNorm;
+    if (thePrjState != nullptr)
+    {
+      *thePrjState = BVH_PrjStateInTriangle_INNER;
+    }
 
-    return (aDirect.Dot(aDirect));
+    return (theNode0 * aVA + theNode1 * aVB + theNode2 * aVC) / aNorm;
+  }
+
+  //! Computes square distance between point and triangle
+  static T PointTriangleSquareDistance (const BVH_VecNt& thePoint,
+                                        const BVH_VecNt& theNode0,
+                                        const BVH_VecNt& theNode1,
+                                        const BVH_VecNt& theNode2)
+  {
+    const BVH_VecNt aProj = PointTriangleProjection(thePoint, theNode0, theNode1, theNode2);
+    const BVH_VecNt aPP = aProj - thePoint;
+    return aPP.Dot(aPP);
   }
 
 public: //! @name Ray-Box Intersection

src/BinMXCAFDoc/BinMXCAFDoc_VisMaterialDriver.cxx

@@ -54,6 +54,7 @@ static Standard_Byte faceCullToChar (Graphic3d_TypeOfBackfacingModel theMode)
   {
     case Graphic3d_TypeOfBackfacingModel_Auto:        return '0';
     case Graphic3d_TypeOfBackfacingModel_BackCulled:  return 'B';
+    case Graphic3d_TypeOfBackfacingModel_FrontCulled: return 'F';
     case Graphic3d_TypeOfBackfacingModel_DoubleSided: return '1';
   }
   return '0';
@@ -66,6 +67,7 @@ static Graphic3d_TypeOfBackfacingModel faceCullFromChar (Standard_Byte theMode)
   {
     case '0': return Graphic3d_TypeOfBackfacingModel_Auto;
     case 'B': return Graphic3d_TypeOfBackfacingModel_BackCulled;
+    case 'F': return Graphic3d_TypeOfBackfacingModel_FrontCulled;
     case '1': return Graphic3d_TypeOfBackfacingModel_DoubleSided;
   }
   return Graphic3d_TypeOfBackfacingModel_Auto;