kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Remove Salomemesh from LibPack and compile with source. Changes for LibPack 8.1

Browse Source 
Had to overwrite the salomemesh in 3rdParty with the original 5.1.2.2 from sf.net since through layout changes imposible to merge or even see changes in the code. Linux tweaking has to be done..
This commit is contained in:
jriegel
2013-03-31 00:16:04 +01:00
parent 82e07c46c9
commit 7bedde5b4f
188 changed files with 4030 additions and 11788 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
cMake/UseLibPack8x.cmake
View File

@@ -56,32 +56,32 @@ set(ZLIB_LIBRARIES zdll.lib)
set(ZLIB_FOUND TRUE)
# SMESH
set(SMESH_INCLUDE_DIR ${FREECAD_LIBPACK_DIR}/include/smesh)
set(SMESH_LIBRARIES
optimized StdMeshers.lib
optimized MEFISTO2.lib
optimized SMESH.lib
optimized DriverUNV.lib
optimized SMESHDS.lib
optimized NETGENPlugin.lib
optimized DriverSTL.lib
optimized DriverDAT.lib
optimized Driver.lib
optimized SMDS.lib
)
set(SMESH_DEBUG_LIBRARIES
debug StdMeshersd.lib
debug MEFISTO2d.lib
debug SMESHd.lib
debug DriverUNVd.lib
debug SMESHDSd.lib
debug NETGENPlugind.lib
debug DriverSTLd.lib
debug DriverDATd.lib
debug Driverd.lib
debug SMDSd.lib
)
set(SMESH_FOUND TRUE)
#set(SMESH_INCLUDE_DIR ${FREECAD_LIBPACK_DIR}/include/smesh)
#set(SMESH_LIBRARIES
# optimized StdMeshers.lib
# optimized MEFISTO2.lib
# optimized SMESH.lib
# optimized DriverUNV.lib
# optimized SMESHDS.lib
# optimized NETGENPlugin.lib
# optimized DriverSTL.lib
# optimized DriverDAT.lib
# optimized Driver.lib
# optimized SMDS.lib
#)
#set(SMESH_DEBUG_LIBRARIES
# debug StdMeshersd.lib
# debug MEFISTO2d.lib
# debug SMESHd.lib
# debug DriverUNVd.lib
# debug SMESHDSd.lib
# debug NETGENPlugind.lib
# debug DriverSTLd.lib
# debug DriverDATd.lib
# debug Driverd.lib
# debug SMDSd.lib
#)
#set(SMESH_FOUND TRUE)
# Coin3D
set(COIN3D_INCLUDE_DIR ${FREECAD_LIBPACK_DIR}/include/coin)
@@ -293,6 +293,21 @@ set(OPENCV_INCLUDE_DIR ${FREECAD_LIBPACK_DIR}/include/opencv)
set(OPENCV_LIBRARIES cv.lib cvaux.lib cxcore.lib cxts.lib highgui.lib)
set(OPENCV_FOUND TRUE)
# NGLIB (NetGen)
set(NGLIB_INCLUDE_DIR ${FREECAD_LIBPACK_DIR}/include/nglib/Include)
set(NGLIB_LIBRARY_DIR
${FREECAD_LIBPACK_DIR}/lib
)
set(NGLIB_LIBRARIES
optimized nglib
)
set(NGLIB_DEBUG_LIBRARIES
debug nglibd
)
# OCC
set(OCC_INCLUDE_DIR ${FREECAD_LIBPACK_DIR}/include/OpenCascade)
set(OCC_LIBRARY_DIR

6
src/3rdParty/CMakeLists.txt vendored
View File

@@ -34,8 +34,6 @@ elseif(FREECAD_BUILD_GUI)
endif (NOT FREECAD_USE_EXTERNAL_PIVY)
endif(FREECAD_BUILD_GUI AND FREECAD_LIBPACK_CHECKFILE6X)
# For Windows we have all stuff in the LibPack
if(CMAKE_COMPILER_IS_GNUCXX)
add_subdirectory(salomesmesh)
endif(CMAKE_COMPILER_IS_GNUCXX)
# Build SalomeMesh for all Platforms since heavily patched
add_subdirectory(salomesmesh)

460
src/3rdParty/salomesmesh/CMakeLists.txt vendored
View File

@@ -8,19 +8,61 @@ SET(SMESH_VERSION_TWEAK 2)
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
SET(CMAKE_BUILD_TYPE "Release") # By default, build in release mode
SET(BUILD_SHARED_LIBS ON)
include_directories(
${CMAKE_BINARY_DIR}/src
${CMAKE_SOURCE_DIR}/src
${CMAKE_CURRENT_BINARY_DIR}
${Boost_INCLUDE_DIRS}
${OCC_INCLUDE_DIR}
${NGLIB_INCLUDE_DIR}
src/SMDS
src/Driver
src/DriverUNV
src/DriverDAT
src/DriverSTL
src/StdMeshers
inc
)
if(MSVC)
set(SMESH_LIBS
debug MSVCRTD.LIB
debug MSVCPRTD.LIB
optimized MSVCRT.LIB
optimized MSVCPRT.LIB
Rpcrt4.lib
${NGLIB_LIBRARIES}
${NGLIB_DEBUG_LIBRARIES}
${OCC_LIBRARIES}
${OCC_DEBUG_LIBRARIES}
${OCC_OCAF_DEBUG_LIBRARIES}
${OCC_OCAF_LIBRARIES}
optimized TKMeshVS.lib
debug TKMeshVSd.lib
optimized TKAdvTools.lib
debug TKAdvToolsd.lib
)
else(MSVC)
set(SMESH_LIBS
${OCC_LIBRARIES}
${OCC_DEBUG_LIBRARIES}
)
endif(MSVC)
#SET(CMAKE_BUILD_TYPE "Release") # By default, build in release mode
#SET(BUILD_SHARED_LIBS ON)
#SET(LIBRARY_OUTPUT_PATH cmake-build)
SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
INCLUDE_DIRECTORIES(inc)
#INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
#INCLUDE_DIRECTORIES(inc)
#############
# FindBoost #
#############
FIND_PACKAGE(Boost REQUIRED)
MESSAGE("-- Boost found: ${Boost_FOUND}")
INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
#FIND_PACKAGE(Boost REQUIRED)
#MESSAGE("-- Boost found: ${Boost_FOUND}")
#INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
#MESSAGE("Popo: ${Boost_INCLUDE_DIR}")
################
@@ -32,12 +74,12 @@ INCLUDE(CMakeDetermineFortranCompiler)
# OpenCASCADE include and lib location #
########################################
# Find OpenCASCADE library, set include and lib path
SET(OCC_INCLUDE_PATH ${OCC_INCLUDE_DIR})
SET(OCC_LIB_PATH ${OCC_LIBRARY_DIR})
#SET(OCC_INCLUDE_PATH ${OCC_INCLUDE_DIR})
#SET(OCC_LIB_PATH ${OCC_LIBRARY_DIR})
# Tells CMake where are the required headers
INCLUDE_DIRECTORIES(${OCC_INCLUDE_PATH})
LINK_DIRECTORIES(${OCC_LIB_PATH})
#INCLUDE_DIRECTORIES(${OCC_INCLUDE_PATH})
#LINK_DIRECTORIES(${OCC_LIB_PATH})
############################
@@ -45,9 +87,9 @@ LINK_DIRECTORIES(${OCC_LIB_PATH})
############################
IF (${CMAKE_SIZEOF_VOID_P} MATCHES "8") # It is 64bit, 32 bit systems returns 4
ADD_DEFINITIONS(-D_OCC64)
MESSAGE("-- Build 64bit")
#MESSAGE("-- Build 64bit")
ELSE (${CMAKE_SIZEOF_VOID_P} MATCHES "8")
MESSAGE("-- Build 32bit")
#MESSAGE("-- Build 32bit")
ENDIF(${CMAKE_SIZEOF_VOID_P} MATCHES "8")
######################################################
@@ -59,7 +101,7 @@ IF(UNIX)
ELSE(UNIX)
IF(WIN32)
######### Windows ###########
MESSAGE("-- Windows system detected")
#MESSAGE("-- Windows system detected")
IF(MSVC)
ADD_DEFINITIONS(-DWNT -DWIN32 -D_WINDOWS -DCSFDB /wd4290 /wd4251 /wd4018 /wd4800 /wd4996 /wd4244 /wd4806 /wd4275)
ELSE(MSVC)
@@ -73,141 +115,333 @@ ENDIF(UNIX)
#########
# SMDS #
#########
FILE(GLOB SMDS_source_files src/SMDS/*.cpp)
INCLUDE_DIRECTORIES(src/SMDS)
FILE(GLOB SMDS_source_files src/SMDS/*.cpp inc/SMDS*.hxx)
ADD_LIBRARY(SMDS SHARED ${SMDS_source_files})
TARGET_LINK_LIBRARIES(SMDS TKernel)
IF(WIN32)
SET_TARGET_PROPERTIES(SMDS PROPERTIES COMPILE_FLAGS "-DSMDS_EXPORTS")
ENDIF(WIN32)
IF(MINGW)
SET_TARGET_PROPERTIES(SMDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(SMDS ${SMESH_LIBS})
if(MSVC)
set_target_properties(SMDS PROPERTIES COMPILE_FLAGS "-DSMDS_EXPORTS")
set_target_properties(SMDS PROPERTIES DEBUG_OUTPUT_NAME "SMDSd")
set_target_properties(SMDS PROPERTIES OUTPUT_NAME "SMDS")
set_target_properties(SMDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMDS PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(SMDS PROPERTIES DEBUG_OUTPUT_NAME "SMDSd")
set_target_properties(SMDS PROPERTIES OUTPUT_NAME "SMDS")
set_target_properties(SMDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMDS PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(SMDS PROPERTIES OUTPUT_NAME "SMDS")
set_target_properties(SMDS PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMDS PROPERTIES PREFIX "")
set_target_properties(SMDS PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
##########
# Driver #
##########
FILE(GLOB Driver_source_files src/Driver/*.cpp)
INCLUDE_DIRECTORIES(src/Driver)
FILE(GLOB Driver_source_files src/Driver/*.cpp inc/Driver_*.hxx)
ADD_LIBRARY(Driver SHARED ${Driver_source_files})
IF(WIN32)
SET_TARGET_PROPERTIES(Driver PROPERTIES COMPILE_FLAGS "-DMESHDRIVER_EXPORTS")
ENDIF(WIN32)
IF(MINGW)
SET_TARGET_PROPERTIES(Driver PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(Driver ${SMESH_LIBS})
if(MSVC)
set_target_properties(Driver PROPERTIES COMPILE_FLAGS "-DMESHDRIVER_EXPORTS")
set_target_properties(Driver PROPERTIES DEBUG_OUTPUT_NAME "Driverd")
set_target_properties(Driver PROPERTIES OUTPUT_NAME "Driver")
set_target_properties(Driver PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(Driver PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(Driver PROPERTIES DEBUG_OUTPUT_NAME "Driverd")
set_target_properties(Driver PROPERTIES OUTPUT_NAME "Driver")
set_target_properties(Driver PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(Driver PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(Driver PROPERTIES OUTPUT_NAME "Driver")
set_target_properties(Driver PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(Driver PROPERTIES PREFIX "")
set_target_properties(Driver PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#IF(WIN32)
# SET_TARGET_PROPERTIES(Driver PROPERTIES COMPILE_FLAGS "-DMESHDRIVER_EXPORTS")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(Driver PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
#############
# DriverSTL #
#############
FILE(GLOB DriverSTL_source_files src/DriverSTL/*.cpp)
INCLUDE_DIRECTORIES(src/DriverSTL)
FILE(GLOB DriverSTL_source_files src/DriverSTL/*.cpp inc/DriverSTL*.h*)
ADD_LIBRARY(DriverSTL SHARED ${DriverSTL_source_files})
TARGET_LINK_LIBRARIES(DriverSTL TKernel TKMath Driver SMDS)
IF(WIN32)
SET_TARGET_PROPERTIES(DriverSTL PROPERTIES COMPILE_FLAGS "-DMESHDRIVERSTL_EXPORTS")
ENDIF(WIN32)
IF(MINGW)
SET_TARGET_PROPERTIES(DriverSTL PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(DriverSTL ${SMESH_LIBS} Driver SMDS)
if(MSVC)
set_target_properties(DriverSTL PROPERTIES COMPILE_FLAGS "-DMESHDRIVERSTL_EXPORTS")
set_target_properties(DriverSTL PROPERTIES DEBUG_OUTPUT_NAME "DriverSTLd")
set_target_properties(DriverSTL PROPERTIES OUTPUT_NAME "DriverSTL")
set_target_properties(DriverSTL PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverSTL PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(DriverSTL PROPERTIES DEBUG_OUTPUT_NAME "Driverd")
set_target_properties(DriverSTL PROPERTIES OUTPUT_NAME "DriverSTL")
set_target_properties(DriverSTL PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverSTL PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(DriverSTL PROPERTIES OUTPUT_NAME "DriverSTL")
set_target_properties(DriverSTL PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverSTL PROPERTIES PREFIX "")
set_target_properties(DriverSTL PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#TARGET_LINK_LIBRARIES(DriverSTL TKernel TKMath Driver SMDS)
#IF(WIN32)
# SET_TARGET_PROPERTIES(DriverSTL PROPERTIES COMPILE_FLAGS "-DMESHDRIVERSTL_EXPORTS")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(DriverSTL PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
#############
# DriverDAT #
#############
FILE(GLOB DriverDAT_source_files src/DriverDAT/*.cpp)
INCLUDE_DIRECTORIES(src/DriverDAT)
FILE(GLOB DriverDAT_source_files src/DriverDAT/*.cpp inc/DriverDAT*.h*)
ADD_LIBRARY(DriverDAT SHARED ${DriverDAT_source_files})
TARGET_LINK_LIBRARIES(DriverDAT SMDS Driver)
IF(WIN32)
SET_TARGET_PROPERTIES(DriverDAT PROPERTIES COMPILE_FLAGS "-DMESHDRIVERDAT_EXPORTS")
ENDIF(WIN32)
IF(MINGW)
SET_TARGET_PROPERTIES(DriverDAT PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(DriverDAT ${SMESH_LIBS} SMDS Driver)
if(MSVC)
set_target_properties(DriverDAT PROPERTIES COMPILE_FLAGS "-DMESHDRIVERDAT_EXPORTS")
set_target_properties(DriverDAT PROPERTIES DEBUG_OUTPUT_NAME "DriverDATd")
set_target_properties(DriverDAT PROPERTIES OUTPUT_NAME "DriverDAT")
set_target_properties(DriverDAT PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverDAT PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(DriverDAT PROPERTIES DEBUG_OUTPUT_NAME "DriverDATd")
set_target_properties(DriverDAT PROPERTIES OUTPUT_NAME "DriverDAT")
set_target_properties(DriverDAT PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverDAT PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(DriverDAT PROPERTIES OUTPUT_NAME "DriverDAT")
set_target_properties(DriverDAT PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverDAT PROPERTIES PREFIX "")
set_target_properties(DriverDAT PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#IF(WIN32)
# SET_TARGET_PROPERTIES(DriverDAT PROPERTIES COMPILE_FLAGS "-DMESHDRIVERDAT_EXPORTS")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(DriverDAT PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
#############
# DriverUNV #
#############
FILE(GLOB DriverUNV_source_files src/DriverUNV/*.cpp)
INCLUDE_DIRECTORIES(src/DriverUNV)
FILE(GLOB DriverUNV_source_files src/DriverUNV/*.cpp inc/DriverUNV*.h*)
ADD_LIBRARY(DriverUNV SHARED ${DriverUNV_source_files})
TARGET_LINK_LIBRARIES(DriverUNV SMDS Driver)
IF(WIN32)
SET_TARGET_PROPERTIES(DriverUNV PROPERTIES COMPILE_FLAGS "-DMESHDRIVERUNV_EXPORTS")
ENDIF(WIN32)
IF(MINGW)
SET_TARGET_PROPERTIES(DriverUNV PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(DriverUNV ${SMESH_LIBS} SMESHDS SMDS Driver)
if(MSVC)
set_target_properties(DriverUNV PROPERTIES COMPILE_FLAGS "-DMESHDRIVERUNV_EXPORTS")
set_target_properties(DriverUNV PROPERTIES DEBUG_OUTPUT_NAME "DriverUNVd")
set_target_properties(DriverUNV PROPERTIES OUTPUT_NAME "DriverUNV")
set_target_properties(DriverUNV PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverUNV PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(DriverUNV PROPERTIES DEBUG_OUTPUT_NAME "DriverUNVd")
set_target_properties(DriverUNV PROPERTIES OUTPUT_NAME "DriverUNV")
set_target_properties(DriverUNV PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverUNV PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(DriverUNV PROPERTIES OUTPUT_NAME "DriverUNV")
set_target_properties(DriverUNV PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(DriverUNV PROPERTIES PREFIX "")
set_target_properties(DriverUNV PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#IF(WIN32)
# SET_TARGET_PROPERTIES(DriverUNV PROPERTIES COMPILE_FLAGS "-DMESHDRIVERUNV_EXPORTS")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(DriverUNV PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
###########
# SMESHDS #
###########
FILE(GLOB SMESHDS_source_files src/SMESHDS/*.cpp)
INCLUDE_DIRECTORIES(src/SMESHDS)
FILE(GLOB SMESHDS_source_files src/SMESHDS/*.cpp inc/SMESHDS_*.h*)
ADD_LIBRARY(SMESHDS SHARED ${SMESHDS_source_files})
TARGET_LINK_LIBRARIES(SMESHDS SMDS TKernel TKMath TKBRep)
IF(MINGW)
SET_TARGET_PROPERTIES(SMESHDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(SMESHDS ${SMESH_LIBS} SMDS )
if(MSVC)
set_target_properties(SMESHDS PROPERTIES DEBUG_OUTPUT_NAME "SMESHDSd")
set_target_properties(SMESHDS PROPERTIES OUTPUT_NAME "SMESHDS")
set_target_properties(SMESHDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMESHDS PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(SMESHDS PROPERTIES DEBUG_OUTPUT_NAME "SMESHDSd")
set_target_properties(SMESHDS PROPERTIES OUTPUT_NAME "SMESHDS")
set_target_properties(SMESHDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMESHDS PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(SMESHDS PROPERTIES OUTPUT_NAME "SMESHDS")
set_target_properties(SMESHDS PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMESHDS PROPERTIES PREFIX "")
set_target_properties(SMESHDS PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#IF(MINGW)
# SET_TARGET_PROPERTIES(SMESHDS PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
#########
# SMESH #
#########
FILE(GLOB SMESH_source_files src/SMESH/*.cpp src/Controls/*.cpp)
INCLUDE_DIRECTORIES(src/SMESH)
FILE(GLOB SMESH_source_files src/SMESH/*.cpp src/Controls/*.cpp inc/SMESH_*.h*)
ADD_LIBRARY(SMESH SHARED ${SMESH_source_files})
TARGET_LINK_LIBRARIES(SMESH SMDS SMESHDS TKernel TKMath TKG2d TKG3d TKMeshVS
TKPrim TKGeomBase TKGeomAlgo TKBRep TKTopAlgo TKShHealing
Driver DriverSTL DriverDAT DriverUNV)
IF(WIN32)
SET_TARGET_PROPERTIES(SMESH PROPERTIES COMPILE_FLAGS "-DSMESHimpl_EXPORTS -DSMESHCONTROLS_EXPORTS")
ENDIF(WIN32)
IF(MINGW)
SET_TARGET_PROPERTIES(SMESH PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
TARGET_LINK_LIBRARIES(SMESH SMDS SMESHDS Driver DriverSTL DriverDAT DriverUNV ${SMESH_LIBS})
if(MSVC)
set_target_properties(SMESH PROPERTIES COMPILE_FLAGS "-DSMESH_EXPORTS -DSMESHCONTROLS_EXPORTS -DSMESHimpl_EXPORTS")
set_target_properties(SMESH PROPERTIES DEBUG_OUTPUT_NAME "SMESHd")
set_target_properties(SMESH PROPERTIES OUTPUT_NAME "SMESH")
set_target_properties(SMESH PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMESH PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(SMESH PROPERTIES DEBUG_OUTPUT_NAME "SMESHd")
set_target_properties(SMESH PROPERTIES OUTPUT_NAME "SMESH")
set_target_properties(SMESH PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(SMESH PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(SMESH PROPERTIES OUTPUT_NAME "SMESH")
set_target_properties(SMESH PROPERTIES PREFIX "")
set_target_properties(SMESH PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#IF(WIN32)
# SET_TARGET_PROPERTIES(SMESH PROPERTIES COMPILE_FLAGS "-DSMESHimpl_EXPORTS -DSMESHCONTROLS_EXPORTS")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(SMESH PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
##############
# MEFISTO2 #
##############
FILE(GLOB MEFISTO2_source_files
src/MEFISTO2/*.cpp
src/MEFISTO2/MEFISTO2F.def
inc/Rn.h
inc/aptrte.h
)
ADD_LIBRARY(MEFISTO2 SHARED ${MEFISTO2_source_files})
if(MSVC)
TARGET_LINK_LIBRARIES(MEFISTO2 ${SMESH_LIBS} MEFISTO2f.lib) # in case of Windows link the prebuild Fortran lib
set_target_properties(MEFISTO2 PROPERTIES COMPILE_FLAGS "-DMEFISTO2D_EXPORTS -D__WATCOM__")
set_target_properties(MEFISTO2 PROPERTIES DEBUG_OUTPUT_NAME "MEFISTO2d")
set_target_properties(MEFISTO2 PROPERTIES OUTPUT_NAME "MEFISTO2")
set_target_properties(MEFISTO2 PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(MEFISTO2 PROPERTIES PREFIX "../")
elseif(MINGW)
TARGET_LINK_LIBRARIES(MEFISTO2 ${SMESH_LIBS})
set_target_properties(MEFISTO2 PROPERTIES DEBUG_OUTPUT_NAME "MEFISTO2d")
set_target_properties(MEFISTO2 PROPERTIES OUTPUT_NAME "MEFISTO2")
set_target_properties(MEFISTO2 PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(MEFISTO2 PROPERTIES PREFIX "")
else(MSVC)
TARGET_LINK_LIBRARIES(MEFISTO2 ${SMESH_LIBS} gfortran)
set_target_properties(MEFISTO2 PROPERTIES COMPILE_FLAGS "${MEFISTO2_CFLAGS}")
set_target_properties(MEFISTO2 PROPERTIES OUTPUT_NAME "MEFISTO2")
set_target_properties(MEFISTO2 PROPERTIES PREFIX "")
set_target_properties(MEFISTO2 PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
##############
# StdMeshers #
##############
FILE(GLOB StdMeshers_source_files src/StdMeshers/*.cpp src/MEFISTO2/*.cpp src/MEFISTO2/trte.f)
INCLUDE_DIRECTORIES(src/StdMeshers)
FILE(GLOB StdMeshers_source_files src/StdMeshers/*.cpp inc/StdMeshers_*.h*)
ADD_LIBRARY(StdMeshers SHARED ${StdMeshers_source_files})
TARGET_LINK_LIBRARIES(StdMeshers SMESH TKernel TKMath TKAdvTools gfortran)
SET(StdMeshers_CFLAGS "")
IF(WIN32)
SET(StdMeshers_CFLAGS "-DSTDMESHERS_EXPORTS -DMEFISTO2D_EXPORTS")
ENDIF(WIN32)
# special compiler flag for g++ 64-bit
IF (${CMAKE_SIZEOF_VOID_P} MATCHES "8")
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(StdMeshers_CFLAGS "${StdMeshers_CFLAGS} -DPCLINUX64")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(${CMAKE_SIZEOF_VOID_P} MATCHES "8")
SET_TARGET_PROPERTIES(StdMeshers PROPERTIES COMPILE_FLAGS "${StdMeshers_CFLAGS}")
IF(MINGW)
SET_TARGET_PROPERTIES(StdMeshers PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
ENDIF(MINGW)
###########
# INSTALL #
###########
if(MSVC)
TARGET_LINK_LIBRARIES(StdMeshers SMESH ${SMESH_LIBS} MEFISTO2)
set_target_properties(StdMeshers PROPERTIES COMPILE_FLAGS "-DSTDMESHERS_EXPORTS")
set_target_properties(StdMeshers PROPERTIES DEBUG_OUTPUT_NAME "StdMeshersd")
set_target_properties(StdMeshers PROPERTIES OUTPUT_NAME "StdMeshers")
set_target_properties(StdMeshers PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(StdMeshers PROPERTIES PREFIX "../")
elseif(MINGW)
TARGET_LINK_LIBRARIES(StdMeshers SMESH ${SMESH_LIBS})
set_target_properties(StdMeshers PROPERTIES DEBUG_OUTPUT_NAME "StdMeshersd")
set_target_properties(StdMeshers PROPERTIES OUTPUT_NAME "StdMeshers")
set_target_properties(StdMeshers PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(StdMeshers PROPERTIES PREFIX "")
else(MSVC)
TARGET_LINK_LIBRARIES(StdMeshers SMESH ${SMESH_LIBS} gfortran)
# special compiler flag for g++ 64-bit
IF (${CMAKE_SIZEOF_VOID_P} MATCHES "8")
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(StdMeshers_CFLAGS "${StdMeshers_CFLAGS} -DPCLINUX64")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(${CMAKE_SIZEOF_VOID_P} MATCHES "8")
set_target_properties(StdMeshers PROPERTIES COMPILE_FLAGS "${StdMeshers_CFLAGS}")
set_target_properties(StdMeshers PROPERTIES OUTPUT_NAME "StdMeshers")
set_target_properties(StdMeshers PROPERTIES PREFIX "")
set_target_properties(StdMeshers PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#SET(StdMeshers_CFLAGS "")
#IF(WIN32)
# SET(StdMeshers_CFLAGS "-DSTDMESHERS_EXPORTS -DMEFISTO2D_EXPORTS")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(StdMeshers PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
################
# NETGENPlugin #
################
FILE(GLOB NETGENPlugin_source_files src/NETGENPlugin/*.cpp inc/NETGENPlugin_*.h* )
ADD_LIBRARY(NETGENPlugin SHARED ${NETGENPlugin_source_files})
TARGET_LINK_LIBRARIES(NETGENPlugin SMDS SMESHD SMESH StdMeshers ${SMESH_LIBS} )
if(MSVC)
set_target_properties(NETGENPlugin PROPERTIES COMPILE_FLAGS "-DNETGENPLUGIN_EXPORTS -DNO_PARALLEL_THREADS -DOCCGEOMETRY")
set_target_properties(NETGENPlugin PROPERTIES DEBUG_OUTPUT_NAME "NETGENPlugind")
set_target_properties(NETGENPlugin PROPERTIES OUTPUT_NAME "NETGENPlugin")
set_target_properties(NETGENPlugin PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(NETGENPlugin PROPERTIES PREFIX "../")
elseif(MINGW)
set_target_properties(NETGENPlugin PROPERTIES DEBUG_OUTPUT_NAME "NETGENPlugind")
set_target_properties(NETGENPlugin PROPERTIES OUTPUT_NAME "NETGENPlugin")
set_target_properties(NETGENPlugin PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set_target_properties(NETGENPlugin PROPERTIES PREFIX "")
else(MSVC)
set_target_properties(NETGENPlugin PROPERTIES OUTPUT_NAME "NETGENPlugin")
set_target_properties(NETGENPlugin PROPERTIES PREFIX "")
set_target_properties(NETGENPlugin PROPERTIES INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/bin)
endif(MSVC)
#IF(WIN32)
# SET_TARGET_PROPERTIES(SMESH PROPERTIES COMPILE_FLAGS "-DNETGENPluginimpl_EXPORTS ")
#ENDIF(WIN32)
#IF(MINGW)
# SET_TARGET_PROPERTIES(SMESH PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#ENDIF(MINGW)
# Path name install: for instance, SMESH-5.1.2.7
SET(INSTALL_PATH_NAME SMESH-${SMESH_VERSION_MAJOR}.${SMESH_VERSION_MINOR}.${SMESH_VERSION_PATCH}.${SMESH_VERSION_TWEAK})
IF(UNIX)
SET_TARGET_PROPERTIES(SMDS Driver DriverSTL DriverDAT DriverUNV
SMESHDS SMESH StdMeshers
PROPERTIES INSTALL_RPATH ${INSTALL_RPATH})
# Libraries are installed by default in /usr/local/lib/SMESH-5.1.2.7
INSTALL(TARGETS SMDS Driver DriverSTL DriverDAT DriverUNV
SMESHDS SMESH StdMeshers
DESTINATION lib
)
# Headers are installed by default in /usr/local/include/SMESH-5.1.2.7
INSTALL(DIRECTORY inc/
DESTINATION include
FILES_MATCHING PATTERN "*.h*"
)
ENDIF(UNIX)

2
src/3rdParty/salomesmesh/inc/Driver_Mesh.h vendored
View File

@@ -29,7 +29,7 @@
#include <string>
#ifdef WNT
#if defined MESHDRIVER_EXPORTS || defined MeshDriver_EXPORTS
#if defined MESHDRIVER_EXPORTS
#define MESHDRIVER_EXPORT __declspec( dllexport )
#else
#define MESHDRIVER_EXPORT __declspec( dllimport )

4
src/3rdParty/salomesmesh/inc/OpUtil.hxx vendored
View File

@@ -1,4 +0,0 @@
#ifndef _OpUtil_HXX_
#define _OpUtil_HXX_
#endif

79
src/3rdParty/salomesmesh/inc/SMDSAbs_ElementType.hxx vendored
View File

@@ -22,7 +22,7 @@
// SMESH SMDS : implementaion of Salome mesh data structure
// File : SMDSAbs_ElementType.hxx
// Module : SMESH
//
#ifndef _SMDSAbs_ElementType_HeaderFile
#define _SMDSAbs_ElementType_HeaderFile
@@ -30,34 +30,33 @@
/// Type (node, edge, face or volume) of elements
///////////////////////////////////////////////////////////////////////////////
enum SMDSAbs_ElementType
{
SMDSAbs_All,
SMDSAbs_Node,
SMDSAbs_Edge,
SMDSAbs_Face,
SMDSAbs_Volume,
SMDSAbs_0DElement,
SMDSAbs_NbElementTypes
};
{
SMDSAbs_All,
SMDSAbs_Node,
SMDSAbs_Edge,
SMDSAbs_Face,
SMDSAbs_Volume,
SMDSAbs_NbElementTypes
};
/*! enumeration for element geometry type */
enum SMDSAbs_GeometryType
{
// 0D element
SMDSGeom_POINT,
// 1D element
SMDSGeom_EDGE,
// 2D element
SMDSGeom_TRIANGLE,
SMDSGeom_QUADRANGLE,
SMDSGeom_POLYGON,
// 3D element
SMDSGeom_TETRA,
SMDSGeom_PYRAMID,
SMDSGeom_HEXA,
SMDSGeom_PENTA,
SMDSGeom_POLYHEDRA,
};
{
// 0D element
SMDSGeom_POINT,
// 1D element
SMDSGeom_EDGE,
// 2D element
SMDSGeom_TRIANGLE,
SMDSGeom_QUADRANGLE,
SMDSGeom_POLYGON,
// 3D element
SMDSGeom_TETRA,
SMDSGeom_PYRAMID,
SMDSGeom_HEXA,
SMDSGeom_PENTA,
SMDSGeom_POLYHEDRA,
};
enum SMDSAbs_ElementOrder {
@@ -66,32 +65,4 @@ enum SMDSAbs_ElementOrder {
ORDER_QUADRATIC /*! entities of 2nd order */
};
/*!
* Enumeration of entity type uses in mesh info array,
* and should be synchronised with enum in SMDS
*/
enum SMDSAbs_EntityType {
SMDSEntity_Node,
SMDSEntity_0D,
SMDSEntity_Edge,
SMDSEntity_Quad_Edge,
SMDSEntity_Triangle,
SMDSEntity_Quad_Triangle,
SMDSEntity_Quadrangle,
SMDSEntity_Quad_Quadrangle,
SMDSEntity_Polygon,
SMDSEntity_Quad_Polygon,
SMDSEntity_Tetra,
SMDSEntity_Quad_Tetra,
SMDSEntity_Pyramid,
SMDSEntity_Quad_Pyramid,
SMDSEntity_Hexa,
SMDSEntity_Quad_Hexa,
SMDSEntity_Penta,
SMDSEntity_Quad_Penta,
SMDSEntity_Polyhedra,
SMDSEntity_Quad_Polyhedra,
SMDSEntity_Last
};
#endif

10
src/3rdParty/salomesmesh/inc/SMDS_ElemIterator.hxx vendored
View File

@@ -22,9 +22,9 @@
// SMESH SMDS : implementaion of Salome mesh data structure
// File : SMDS_MeshElement.hxx
// Module : SMESH
// Created: 12.01.05 18:02:52
// Author: Michael Sazonov
// Created: 12.01.05 18:02:52
// Author: Michael Sazonov
//
#ifndef SMDS_ElemIterator_HeaderFile
#define SMDS_ElemIterator_HeaderFile
@@ -33,7 +33,6 @@
class SMDS_MeshElement;
class SMDS_MeshNode;
class SMDS_Mesh0DElement;
class SMDS_MeshEdge;
class SMDS_MeshFace;
class SMDS_MeshVolume;
@@ -44,9 +43,6 @@ typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshElement *> > SMDS_ElemIte
typedef SMDS_Iterator<const SMDS_MeshNode *> SMDS_NodeIterator;
typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshNode *> > SMDS_NodeIteratorPtr;
typedef SMDS_Iterator<const SMDS_Mesh0DElement *> SMDS_0DElementIterator;
typedef boost::shared_ptr<SMDS_Iterator<const SMDS_Mesh0DElement *> > SMDS_0DElementIteratorPtr;
typedef SMDS_Iterator<const SMDS_MeshEdge *> SMDS_EdgeIterator;
typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshEdge *> > SMDS_EdgeIteratorPtr;

1
src/3rdParty/salomesmesh/inc/SMDS_FaceOfEdges.hxx vendored
View File

@@ -46,7 +46,6 @@ class SMDS_EXPORT SMDS_FaceOfEdges:public SMDS_MeshFace
const SMDS_MeshEdge* edge4);
SMDSAbs_ElementType GetType() const;
virtual SMDSAbs_EntityType GetEntityType() const;
int NbNodes() const;
int NbEdges() const;
int NbFaces() const;

2
src/3rdParty/salomesmesh/inc/SMDS_FaceOfNodes.hxx vendored
View File

@@ -56,8 +56,6 @@ class SMDS_EXPORT SMDS_FaceOfNodes:public SMDS_MeshFace
*/
virtual const SMDS_MeshNode* GetNode(const int ind) const;
virtual SMDSAbs_EntityType GetEntityType() const;
protected:
SMDS_ElemIteratorPtr
elementsIterator(SMDSAbs_ElementType type) const;

410
src/3rdParty/salomesmesh/inc/SMDS_Mesh.hxx vendored
View File

@@ -22,14 +22,13 @@
// SMESH SMDS : implementaion of Salome mesh data structure
// File : SMDS_Mesh.hxx
// Module : SMESH
//
#ifndef _SMDS_Mesh_HeaderFile
#define _SMDS_Mesh_HeaderFile
#include "SMESH_SMDS.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_Mesh0DElement.hxx"
#include "SMDS_MeshEdge.hxx"
#include "SMDS_MeshFace.hxx"
#include "SMDS_MeshVolume.hxx"
@@ -44,64 +43,59 @@
class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
public:
SMDS_Mesh();
SMDS_NodeIteratorPtr nodesIterator() const;
SMDS_0DElementIteratorPtr elements0dIterator() const;
SMDS_EdgeIteratorPtr edgesIterator() const;
SMDS_FaceIteratorPtr facesIterator() const;
SMDS_VolumeIteratorPtr volumesIterator() const;
SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
SMDS_ElemIteratorPtr elementsIterator() const;
SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
SMDS_Mesh *AddSubMesh();
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
virtual SMDS_MeshNode* AddNode(double x, double y, double z);
virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * n);
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
int ID);
const SMDS_MeshNode * n2,
int ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
const SMDS_MeshNode * n2);
// 2d order edge with 3 nodes: n12 - node between n1 and n2
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
const SMDS_MeshEdge * e2,
const SMDS_MeshEdge * e3, int ID);
@@ -122,100 +116,100 @@ public:
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31);
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31);
// 2d order quadrangle
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41);
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f2,
@@ -255,24 +249,24 @@ public:
int n12,int n23,int n31,
int n14,int n24,int n34, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34);
@@ -282,28 +276,28 @@ public:
int n15,int n25,int n35,int n45,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
@@ -317,33 +311,33 @@ public:
int n14,int n25,int n36,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36);
@@ -356,42 +350,42 @@ public:
int n15,int n26,int n37,int n48,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n67,
const SMDS_MeshNode * n78,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n67,
const SMDS_MeshNode * n78,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n67,
const SMDS_MeshNode * n78,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
@@ -422,10 +416,9 @@ public:
virtual void RemoveElement(const SMDS_MeshElement * elem,
std::list<const SMDS_MeshElement *>& removedElems,
std::list<const SMDS_MeshElement *>& removedNodes,
bool removenodes = false);
bool removenodes = false);
virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);
virtual void RemoveNode(const SMDS_MeshNode * node);
virtual void Remove0DElement(const SMDS_Mesh0DElement * elem0d);
virtual void RemoveEdge(const SMDS_MeshEdge * edge);
virtual void RemoveFace(const SMDS_MeshFace * face);
virtual void RemoveVolume(const SMDS_MeshVolume * volume);
@@ -437,7 +430,7 @@ public:
virtual void RemoveFreeElement(const SMDS_MeshElement * elem);
virtual void Clear();
virtual bool RemoveFromParent();
virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
@@ -452,7 +445,6 @@ public:
// Renumber all nodes or elements.
const SMDS_MeshNode *FindNode(int idnode) const;
const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
@@ -462,7 +454,6 @@ public:
const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
int idnode5, int idnode6, int idnode7, int idnode8) const;
const SMDS_MeshElement *FindElement(int IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
@@ -508,13 +499,11 @@ public:
const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
int NbNodes() const;
int Nb0DElements() const;
int NbEdges() const;
int NbFaces() const;
int NbVolumes() const;
int NbSubMesh() const;
void DumpNodes() const;
void Dump0DElements() const;
void DumpEdges() const;
void DumpFaces() const;
void DumpVolumes() const;
@@ -538,7 +527,6 @@ public:
bool Contains (const SMDS_MeshElement* elem) const;
typedef NCollection_Map<SMDS_MeshNode *> SetOfNodes;
typedef NCollection_Map<SMDS_Mesh0DElement *> SetOf0DElements;
typedef NCollection_Map<SMDS_MeshEdge *> SetOfEdges;
typedef NCollection_Map<SMDS_MeshFace *> SetOfFaces;
typedef NCollection_Map<SMDS_MeshVolume *> SetOfVolumes;
@@ -546,34 +534,32 @@ public:
private:
SMDS_Mesh(SMDS_Mesh * parent);
SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
const SMDS_MeshNode * node2,
const SMDS_MeshNode * node3);
SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
const SMDS_MeshNode * node2,
const SMDS_MeshNode * node3);
SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
const SMDS_MeshNode * node2,
const SMDS_MeshNode * node3,
const SMDS_MeshNode * node4);
SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
const SMDS_MeshNode * node2,
const SMDS_MeshNode * node3,
const SMDS_MeshNode * node4);
SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
const SMDS_MeshNode * n2);
SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
const SMDS_MeshNode *n2,
const SMDS_MeshNode *n3);
const SMDS_MeshNode *n2,
const SMDS_MeshNode *n3);
SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
const SMDS_MeshNode *n2,
const SMDS_MeshNode *n3,
const SMDS_MeshNode *n4);
const SMDS_MeshNode *n2,
const SMDS_MeshNode *n3,
const SMDS_MeshNode *n4);
bool registerElement(int ID, SMDS_MeshElement * element);
void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
const SMDS_MeshElement * element,
std::set<const SMDS_MeshElement*>& nodes);
void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
const SMDS_MeshElement * element,
std::set<const SMDS_MeshElement*>& nodes);
// Fields PRIVATE
SetOfNodes myNodes;
SetOf0DElements my0DElements;
SetOfEdges myEdges;
SetOfFaces myFaces;
SetOfVolumes myVolumes;

62
src/3rdParty/salomesmesh/inc/SMDS_Mesh0DElement.hxx vendored
View File

@@ -1,62 +0,0 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// File : SMDS_Mesh0DElement.hxx
// Module : SMESH
#ifndef _SMDS_Mesh0DElement_HeaderFile
#define _SMDS_Mesh0DElement_HeaderFile
#include "SMESH_SMDS.hxx"
#include "SMDS_MeshElement.hxx"
#include <iostream>
class SMDS_EXPORT SMDS_Mesh0DElement: public SMDS_MeshElement
{
public:
SMDS_Mesh0DElement (const SMDS_MeshNode * node);
bool ChangeNode (const SMDS_MeshNode * node);
void Print (std::ostream & OS) const;
SMDSAbs_ElementType GetType() const;
SMDSAbs_EntityType GetEntityType() const {return SMDSEntity_0D;}
int NbNodes() const;
int NbEdges() const;
friend bool operator< (const SMDS_Mesh0DElement& e1, const SMDS_Mesh0DElement& e2);
/*!
* \brief Return node by its index
* \param ind - node index
* \retval const SMDS_MeshNode* - the node
*/
virtual const SMDS_MeshNode* GetNode (const int ind) const;
protected:
SMDS_ElemIteratorPtr elementsIterator (SMDSAbs_ElementType type) const;
protected:
const SMDS_MeshNode* myNode;
};
#endif

3
src/3rdParty/salomesmesh/inc/SMDS_MeshEdge.hxx vendored
View File

@@ -41,8 +41,7 @@ class SMDS_EXPORT SMDS_MeshEdge:public SMDS_MeshElement
const SMDS_MeshNode * node2);
void Print(std::ostream & OS) const;
virtual SMDSAbs_ElementType GetType() const;
virtual SMDSAbs_EntityType GetEntityType() const { return SMDSEntity_Edge; }
SMDSAbs_ElementType GetType() const;
int NbNodes() const;
int NbEdges() const;
friend bool operator<(const SMDS_MeshEdge& e1, const SMDS_MeshEdge& e2);

2
src/3rdParty/salomesmesh/inc/SMDS_MeshElement.hxx vendored
View File

@@ -64,8 +64,6 @@ public:
virtual SMDSAbs_ElementType GetType() const = 0;
virtual bool IsPoly() const { return false; };
virtual bool IsQuadratic() const;
//! Return type of entity
virtual SMDSAbs_EntityType GetEntityType() const = 0;
virtual bool IsMediumNode(const SMDS_MeshNode* node) const;

171
src/3rdParty/salomesmesh/inc/SMDS_MeshInfo.hxx vendored
View File

@@ -26,11 +26,6 @@
#ifndef SMDS_MeshInfo_HeaderFile
#define SMDS_MeshInfo_HeaderFile
#ifdef __BORLANDC__
#pragma warn -8066
#pragma warn -8012
#endif
using namespace std;
#include "SMESH_SMDS.hxx"
@@ -45,10 +40,7 @@ public:
inline void Clear();
int NbNodes() const { return myNbNodes; }
inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
inline int NbEntities(SMDSAbs_EntityType type) const;
int Nb0DElements() const { return myNb0DElements; }
inline int NbEdges (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline int NbFaces (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline int NbTriangles (SMDSAbs_ElementOrder order = ORDER_ANY) const;
@@ -68,7 +60,7 @@ private:
// methods to count NOT POLY elements
inline void remove(const SMDS_MeshElement* el);
inline void add (const SMDS_MeshElement* el);
inline int index(SMDSAbs_ElementType type, int nbNodes) const;
inline int index(SMDSAbs_ElementType type, int nbNodes);
// methods to remove elements of ANY kind
inline void RemoveEdge(const SMDS_MeshElement* el);
inline void RemoveFace(const SMDS_MeshElement* el);
@@ -76,7 +68,6 @@ private:
int myNbNodes;
int myNb0DElements;
int myNbEdges , myNbQuadEdges ;
int myNbTriangles , myNbQuadTriangles ;
int myNbQuadrangles, myNbQuadQuadrangles;
@@ -94,7 +85,6 @@ private:
inline SMDS_MeshInfo::SMDS_MeshInfo():
myNbNodes(0),
myNb0DElements(0),
myNbEdges (0), myNbQuadEdges (0),
myNbTriangles (0), myNbQuadTriangles (0),
myNbQuadrangles(0), myNbQuadQuadrangles(0),
@@ -106,47 +96,40 @@ inline SMDS_MeshInfo::SMDS_MeshInfo():
myNbPolyhedrons(0)
{
// Number of nodes in standard element types
// n v f e 0 n
// o o a d d o
// d l c g d
// e e e e
// s
// -----------------
// 0 *
// 1 . *
// n v f e
// o o a d
// d l c g
// e e e
// -----------
// 1
// 2 *
// 3 . *
// 4 * . .
// 5 *
// 6 * .
// 7
// 8 * .
// 9
// 10 *
// 11 *
// 12 *
// 13 *
// 14 *
// 15 *
// 16 *
// 17
// 18
// 19
// 3 *
// 4 * * *
// 5 *
// 6 * *
// 7
// 8 * *
// 9
// 10 *
// 11
// 12
// 13 *
// 14
// 15 *
// 16
// 17
// 18
// 19
// 20 *
//
// So to have a unique index for each type basing on nb of nodes, we use a shift:
myShift.resize(SMDSAbs_NbElementTypes, 0);
myShift[ SMDSAbs_Face ] = +8; // 3->11, 4->12, 6->14, 8->16
myShift[ SMDSAbs_Edge ] = -2; // 2->0, 4->2
myShift[ SMDSAbs_0DElement ] = +2; // 1->3
myShift.resize(SMDSAbs_Volume + 1, 0);
myShift[ SMDSAbs_Face ] = +8; // 3->11, 4->12, 6->14, 8->16
myShift[ SMDSAbs_Edge ] = -2; // 2->0, 4->2
myNb.resize( index( SMDSAbs_Volume,20 ) + 1, NULL);
myNb[ index( SMDSAbs_Node,1 )] = & myNbNodes;
myNb[ index( SMDSAbs_0DElement,1 )] = & myNb0DElements;
myNb[ index( SMDSAbs_Edge,2 )] = & myNbEdges;
myNb[ index( SMDSAbs_Edge,4 )] = & myNbQuadEdges;
@@ -164,15 +147,13 @@ inline SMDS_MeshInfo::SMDS_MeshInfo():
myNb[ index( SMDSAbs_Volume, 15)] = & myNbQuadPrisms;
myNb[ index( SMDSAbs_Volume, 20)] = & myNbQuadHexas;
}
inline void // Clear
SMDS_MeshInfo::Clear()
{ for ( int i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
myNbPolygons=myNbPolyhedrons=0;
}
inline int // index
SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes) const
SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes)
{ return nbNodes + myShift[ type ]; }
inline void // remove
@@ -231,100 +212,4 @@ inline int // NbPrisms
SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
inline int // NbElements
SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
{
int nb = 0;
switch (type) {
case SMDSAbs_All:
for ( int i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
nb += myNbPolygons + myNbPolyhedrons;
break;
case SMDSAbs_Volume:
nb = myNbTetras+ myNbPyramids+ myNbPrisms+ myNbHexas+
myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbQuadHexas+myNbPolyhedrons;
break;
case SMDSAbs_Face:
nb = myNbTriangles+ myNbQuadrangles+ myNbQuadTriangles+ myNbQuadQuadrangles + myNbPolygons;
break;
case SMDSAbs_Edge:
nb = myNbEdges + myNbQuadEdges;
break;
case SMDSAbs_0DElement:
nb = myNb0DElements;
break;
case SMDSAbs_Node:
nb = myNbNodes;
break;
default:;
}
return nb;
}
int // NbEntities
SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
{
switch (type) {
case SMDSEntity_Node:
return myNbNodes;
break;
case SMDSEntity_0D:
return myNb0DElements;
break;
case SMDSEntity_Edge:
return myNbEdges;
break;
case SMDSEntity_Quad_Edge:
return myNbQuadEdges;
break;
case SMDSEntity_Triangle:
return myNbTriangles;
break;
case SMDSEntity_Quad_Triangle:
return myNbQuadTriangles;
break;
case SMDSEntity_Quadrangle:
return myNbQuadrangles;
break;
case SMDSEntity_Quad_Quadrangle:
return myNbQuadQuadrangles;
break;
case SMDSEntity_Polygon:
return myNbPolygons;
break;
case SMDSEntity_Tetra:
return myNbTetras;
break;
case SMDSEntity_Quad_Tetra:
return myNbQuadTetras;
break;
case SMDSEntity_Pyramid:
return myNbPyramids;
break;
case SMDSEntity_Quad_Pyramid:
return myNbQuadPyramids;
break;
case SMDSEntity_Hexa:
return myNbHexas;
break;
case SMDSEntity_Quad_Hexa:
return myNbQuadHexas;
break;
case SMDSEntity_Penta:
return myNbPrisms;
break;
case SMDSEntity_Quad_Penta:
return myNbQuadPrisms;
break;
case SMDSEntity_Polyhedra:
return myNbPolyhedrons;
break;
case SMDSEntity_Quad_Polygon:
case SMDSEntity_Quad_Polyhedra:
default:
break;
}
return 0;
}
#endif

55
src/3rdParty/salomesmesh/inc/SMDS_MeshNode.hxx vendored
View File

@@ -35,41 +35,40 @@
class SMDS_EXPORT SMDS_MeshNode:public SMDS_MeshElement
{
public:
SMDS_MeshNode(double x, double y, double z);
void Print(std::ostream & OS) const;
double X() const;
double Y() const;
double Z() const;
void AddInverseElement(const SMDS_MeshElement * ME);
void RemoveInverseElement(const SMDS_MeshElement * parent);
void ClearInverseElements();
bool emptyInverseElements();
SMDS_ElemIteratorPtr GetInverseElementIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
int NbInverseElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
void SetPosition(const SMDS_PositionPtr& aPos);
const SMDS_PositionPtr& GetPosition() const;
SMDSAbs_ElementType GetType() const;
SMDSAbs_EntityType GetEntityType() const {return SMDSEntity_Node;}
int NbNodes() const;
void setXYZ(double x, double y, double z);
friend bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2);
public:
SMDS_MeshNode(double x, double y, double z);
void Print(std::ostream & OS) const;
double X() const;
double Y() const;
double Z() const;
void AddInverseElement(const SMDS_MeshElement * ME);
void RemoveInverseElement(const SMDS_MeshElement * parent);
void ClearInverseElements();
bool emptyInverseElements();
SMDS_ElemIteratorPtr GetInverseElementIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
int NbInverseElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
void SetPosition(const SMDS_PositionPtr& aPos);
const SMDS_PositionPtr& GetPosition() const;
SMDSAbs_ElementType GetType() const;
int NbNodes() const;
void setXYZ(double x, double y, double z);
friend bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2);
/*!
* \brief Return node by its index
* \param ind - node index
* \retval const SMDS_MeshNode* - the node
* \param ind - node index
* \retval const SMDS_MeshNode* - the node
*/
virtual const SMDS_MeshNode* GetNode(const int) const { return this; }
protected:
SMDS_ElemIteratorPtr
elementsIterator(SMDSAbs_ElementType type) const;
protected:
SMDS_ElemIteratorPtr
elementsIterator(SMDSAbs_ElementType type) const;
private:
double myX, myY, myZ;
SMDS_PositionPtr myPosition;
NCollection_List<const SMDS_MeshElement*> myInverseElements;
private:
double myX, myY, myZ;
SMDS_PositionPtr myPosition;
NCollection_List<const SMDS_MeshElement*> myInverseElements;
};
#endif

1
src/3rdParty/salomesmesh/inc/SMDS_PolygonalFaceOfNodes.hxx vendored
View File

@@ -40,7 +40,6 @@ class SMDS_EXPORT SMDS_PolygonalFaceOfNodes:public SMDS_MeshFace
SMDS_PolygonalFaceOfNodes (std::vector<const SMDS_MeshNode *> nodes);
virtual SMDSAbs_ElementType GetType() const;
virtual SMDSAbs_EntityType GetEntityType() const { return SMDSEntity_Polygon; }
virtual bool IsPoly() const { return true; };
bool ChangeNodes (std::vector<const SMDS_MeshNode *> nodes);

1
src/3rdParty/salomesmesh/inc/SMDS_PolyhedralVolumeOfNodes.hxx vendored
View File

@@ -39,7 +39,6 @@ class SMDS_EXPORT SMDS_PolyhedralVolumeOfNodes:public SMDS_VolumeOfNodes
//virtual ~SMDS_PolyhedralVolumeOfNodes();
virtual SMDSAbs_ElementType GetType() const;
virtual SMDSAbs_EntityType GetEntityType() const { return SMDSEntity_Polyhedra; }
virtual bool IsPoly() const { return true; };
bool ChangeNodes (const std::vector<const SMDS_MeshNode *> & nodes,

2
src/3rdParty/salomesmesh/inc/SMDS_QuadraticEdge.hxx vendored
View File

@@ -47,8 +47,6 @@ public:
int NbNodes() const;
virtual SMDSAbs_EntityType GetEntityType() const { return SMDSEntity_Quad_Edge; }
virtual bool IsQuadratic() const { return true; }
virtual bool IsMediumNode(const SMDS_MeshNode* node) const;

1
src/3rdParty/salomesmesh/inc/SMDS_QuadraticFaceOfNodes.hxx vendored
View File

@@ -49,7 +49,6 @@ public:
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41);
virtual SMDSAbs_EntityType GetEntityType() const;
virtual bool IsQuadratic() const { return true; }
virtual bool IsMediumNode(const SMDS_MeshNode* node) const;

1
src/3rdParty/salomesmesh/inc/SMDS_QuadraticVolumeOfNodes.hxx vendored
View File

@@ -99,7 +99,6 @@ public:
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48);
virtual SMDSAbs_EntityType GetEntityType() const;
virtual bool IsQuadratic() const { return true; }
virtual bool IsMediumNode(const SMDS_MeshNode* node) const;

1
src/3rdParty/salomesmesh/inc/SMDS_VolumeOfFaces.hxx vendored
View File

@@ -54,7 +54,6 @@ class SMDS_EXPORT SMDS_VolumeOfFaces:public SMDS_MeshVolume
const SMDS_MeshFace * face5,
const SMDS_MeshFace * face6);
virtual SMDSAbs_EntityType GetEntityType() const;
void Print(std::ostream & OS) const;
int NbFaces() const;

3
src/3rdParty/salomesmesh/inc/SMDS_VolumeOfNodes.hxx vendored
View File

@@ -69,8 +69,7 @@ class SMDS_EXPORT SMDS_VolumeOfNodes:public SMDS_MeshVolume
int NbFaces() const;
int NbNodes() const;
int NbEdges() const;
virtual SMDSAbs_ElementType GetType() const;
virtual SMDSAbs_EntityType GetEntityType() const;
SMDSAbs_ElementType GetType() const;
/*!
* \brief Return node by its index

2
src/3rdParty/salomesmesh/inc/SMDS_VolumeTool.hxx vendored
View File

@@ -93,8 +93,6 @@ class SMDS_EXPORT SMDS_VolumeTool
bool GetBaryCenter (double & X, double & Y, double & Z) const;
bool IsOut(double X, double Y, double Z, double tol);
// Classify a point
// -----------------------
// info on node connection

1
src/3rdParty/salomesmesh/inc/SMESHDS_Command.hxx vendored
View File

@@ -38,7 +38,6 @@ class SMESHDS_EXPORT SMESHDS_Command
public:
SMESHDS_Command(const SMESHDS_CommandType aType);
void AddNode(int NewNodeID, double x, double y, double z);
void Add0DElement(int New0DElementID, int idnode);
void AddEdge(int NewEdgeID, int idnode1, int idnode2);
void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3);
void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3,

4
src/3rdParty/salomesmesh/inc/SMESHDS_CommandType.hxx vendored
View File

@@ -53,9 +53,7 @@ enum SMESHDS_CommandType {
SMESHDS_AddQuadTetrahedron,
SMESHDS_AddQuadPyramid,
SMESHDS_AddQuadPentahedron,
SMESHDS_AddQuadHexahedron,
// special type for 0D elements
SMESHDS_Add0DElement
SMESHDS_AddQuadHexahedron
};

2
src/3rdParty/salomesmesh/inc/SMESHDS_Group.hxx vendored
View File

@@ -22,7 +22,7 @@
// SMESH SMESHDS : management of mesh data and SMESH document
// File : SMESHDS_Group.hxx
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESHDS/SMESHDS_Group.hxx,v 1.7.2.1 2008/11/27 12:31:37 abd Exp $
//
#ifndef _SMESHDS_Group_HeaderFile
#define _SMESHDS_Group_HeaderFile

2
src/3rdParty/salomesmesh/inc/SMESHDS_GroupBase.hxx vendored
View File

@@ -22,7 +22,7 @@
// SMESH SMESHDS : management of mesh data and SMESH document
// File : SMESHDS_Group.hxx
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESHDS/SMESHDS_GroupBase.hxx,v 1.8.2.1 2008/11/27 12:31:37 abd Exp $
//
#ifndef _SMESHDS_GroupBase_HeaderFile
#define _SMESHDS_GroupBase_HeaderFile

2
src/3rdParty/salomesmesh/inc/SMESHDS_Hypothesis.hxx vendored
View File

@@ -23,7 +23,7 @@
// File : SMESHDS_Hypothesis.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESHDS/SMESHDS_Hypothesis.hxx,v 1.10.2.1 2008/11/27 12:31:37 abd Exp $
//
#ifndef _SMESHDS_HYPOTHESIS_HXX_
#define _SMESHDS_HYPOTHESIS_HXX_

333
src/3rdParty/salomesmesh/inc/SMESHDS_Mesh.hxx vendored
View File

@@ -30,7 +30,6 @@
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_Mesh0DElement.hxx"
#include "SMDS_MeshEdge.hxx"
#include "SMDS_MeshFace.hxx"
#include "SMDS_MeshVolume.hxx"
@@ -67,164 +66,160 @@ public:
bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
virtual SMDS_MeshNode* AddNode(double x, double y, double z);
virtual SMDS_Mesh0DElement* Add0DElementWithID(int nodeID, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, int ID);
virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * node);
virtual SMDS_MeshNode * AddNode(double x, double y, double z);
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
int ID);
const SMDS_MeshNode * n2,
int ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
const SMDS_MeshNode * n2);
// 2d order edge with 3 nodes: n12 - node between n1 and n2
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
// 2d order triangle of 6 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31);
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31);
// 2d order quadrangle
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41);
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8);
// 2d order tetrahedron of 10 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n31,
int n14,int n24,int n34, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
@@ -238,24 +233,24 @@ public:
int n15,int n25,int n35,int n45,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
@@ -273,27 +268,27 @@ public:
int n14,int n25,int n36,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
@@ -312,34 +307,34 @@ public:
int n15,int n26,int n37,int n48,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n67,
const SMDS_MeshNode * n78,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID);
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n67,
const SMDS_MeshNode * n78,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
@@ -405,9 +400,9 @@ public:
void SetNodeOnVertex(SMDS_MeshNode * aNode, const TopoDS_Vertex & S);
void UnSetNodeOnShape(const SMDS_MeshNode * aNode);
void SetMeshElementOnShape(const SMDS_MeshElement * anElt,
const TopoDS_Shape & S);
const TopoDS_Shape & S);
void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt,
const TopoDS_Shape & S);
const TopoDS_Shape & S);
bool HasMeshElements(const TopoDS_Shape & S);
SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
SMESHDS_SubMesh * MeshElements(const int Index);

1
src/3rdParty/salomesmesh/inc/SMESHDS_Script.hxx vendored
View File

@@ -44,7 +44,6 @@ class SMESHDS_EXPORT SMESHDS_Script
bool IsModified();
void AddNode(int NewNodeID, double x, double y, double z);
void Add0DElement(int New0DElementID, int idnode);
void AddEdge(int NewEdgeID, int idnode1, int idnode2);
void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3);
void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3,

2
src/3rdParty/salomesmesh/inc/SMESH_0D_Algo.hxx vendored
View File

@@ -22,7 +22,7 @@
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : SMESH_0D_Algo.hxx
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_0D_Algo.hxx,v 1.2.2.1 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_0D_ALGO_HXX_
#define _SMESH_0D_ALGO_HXX_

2
src/3rdParty/salomesmesh/inc/SMESH_1D_Algo.hxx vendored
View File

@@ -23,7 +23,7 @@
// File : SMESH_1D_Algo.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_1D_Algo.hxx,v 1.8.2.1 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_1D_ALGO_HXX_
#define _SMESH_1D_ALGO_HXX_

2
src/3rdParty/salomesmesh/inc/SMESH_2D_Algo.hxx vendored
View File

@@ -23,7 +23,7 @@
// File : SMESH_2D_Algo.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_2D_Algo.hxx,v 1.9.2.1 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_2D_ALGO_HXX_
#define _SMESH_2D_ALGO_HXX_

2
src/3rdParty/salomesmesh/inc/SMESH_3D_Algo.hxx vendored
View File

@@ -23,7 +23,7 @@
// File : SMESH_3D_Algo.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_3D_Algo.hxx,v 1.9.2.1 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_3D_ALGO_HXX_
#define _SMESH_3D_ALGO_HXX_

26
src/3rdParty/salomesmesh/inc/SMESH_Algo.hxx vendored
View File

@@ -23,8 +23,8 @@
// File : SMESH_Algo.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_Algo.hxx,v 1.12.2.4 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_ALGO_HXX_
#define _SMESH_ALGO_HXX_
@@ -54,9 +54,6 @@ class SMDS_MeshNode;
class SMESH_subMesh;
class SMESH_MesherHelper;
typedef std::map< SMESH_subMesh*, std::vector<int> > MapShapeNbElems;
// vector must have size corresponding to EntityType_Last from SMDSAbs:
typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsItr;
class SMESH_EXPORT SMESH_Algo:public SMESH_Hypothesis
{
@@ -125,16 +122,6 @@ public:
*/
virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper);
/*!
* \brief evaluates size of prospective mesh on a shape
* \param aMesh - the mesh
* \param aShape - the shape
* \param aNbElems - prospective number of elements by types
* \retval bool - is a success
*/
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap) = 0;
/*!
* \brief Returns a list of compatible hypotheses used to mesh a shape
* \param aMesh - the mesh
@@ -176,10 +163,13 @@ public:
bool InitCompatibleHypoFilter( SMESH_HypoFilter & theFilter,
const bool ignoreAuxiliary) const;
/*!
* \brief Just return false as the algorithm does not hold parameters values
* \brief Initialize my parameter values by the mesh built on the geometry
*
* Just return false as the algorithm does not hold parameters values
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
/*!
* \brief return compute error
*/
@@ -253,7 +243,8 @@ public:
static bool GetNodeParamOnEdge(const SMESHDS_Mesh* theMesh,
const TopoDS_Edge& theEdge,
std::vector< double > & theParams);
/*!
/*!
* \brief Fill map of node parameter on geometrical edge to node it-self
* \param theMesh - The mesh containing nodes
* \param theEdge - The geometrical edge of interest
@@ -265,6 +256,7 @@ public:
const TopoDS_Edge& theEdge,
const bool ignoreMediumNodes,
std::map< double, const SMDS_MeshNode* > & theNodes);
/*!
* \brief Find out elements orientation on a geometrical face
* \param theFace - The face correctly oriented in the shape being meshed
@@ -303,7 +295,7 @@ public:
* \retval const SMDS_MeshNode* - found node or NULL
*/
static const SMDS_MeshNode* VertexNode(const TopoDS_Vertex& V,
const SMESHDS_Mesh* meshDS);
const SMESHDS_Mesh* meshDS);
protected:

5
src/3rdParty/salomesmesh/inc/SMESH_Block.hxx vendored
View File

@@ -276,14 +276,11 @@ public:
static int GetOrderedEdges (const TopoDS_Face& theFace,
TopoDS_Vertex theFirstVertex,
std::list< TopoDS_Edge >& theEdges,
std::list< int > & theNbVertexInWires,
const bool theShapeAnalysisAlgo=false);
std::list< int > & theNbVertexInWires);
// Return nb wires and a list of oredered edges.
// It is used to assign indices to subshapes.
// theFirstVertex may be NULL.
// Always try to set a seam edge first
// if (theShapeAnalysisAlgo) then ShapeAnalysis::OuterWire() is used to find the outer
// wire else BRepTools::OuterWire() is used
public:
// -----------------------------------------------------------

56
src/3rdParty/salomesmesh/inc/SMESH_ControlsDef.hxx vendored
View File

@@ -68,40 +68,30 @@ class gp_Pnt;
namespace SMESH{
namespace Controls{
class SMESHCONTROLS_EXPORT TSequenceOfXYZ
class SMESHCONTROLS_EXPORT TSequenceOfXYZ: public std::vector<gp_XYZ>
{
typedef std::vector<gp_XYZ>::size_type size_type;
public:
TSequenceOfXYZ();
TSequenceOfXYZ(size_type n);
TSequenceOfXYZ(size_type n, const gp_XYZ& t);
TSequenceOfXYZ(size_type n, const value_type& t);
TSequenceOfXYZ(const TSequenceOfXYZ& theSequenceOfXYZ);
template <class InputIterator>
TSequenceOfXYZ(InputIterator theBegin, InputIterator theEnd);
~TSequenceOfXYZ();
TSequenceOfXYZ& operator=(const TSequenceOfXYZ& theSequenceOfXYZ);
gp_XYZ& operator()(size_type n);
reference operator()(size_type n);
const gp_XYZ& operator()(size_type n) const;
void clear();
void reserve(size_type n);
void push_back(const gp_XYZ& v);
size_type size() const;
const_reference operator()(size_type n) const;
private:
std::vector<gp_XYZ> myArray;
reference operator[](size_type n);
const_reference operator[](size_type n) const;
};
/*
@@ -132,9 +122,9 @@ namespace SMESH{
void SetPrecision( const long thePrecision );
bool GetPoints(const int theId,
TSequenceOfXYZ& theRes) const;
TSequenceOfXYZ& theRes) const;
static bool GetPoints(const SMDS_MeshElement* theElem,
TSequenceOfXYZ& theRes);
TSequenceOfXYZ& theRes);
protected:
const SMDS_Mesh* myMesh;
const SMDS_MeshElement* myCurrElement;
@@ -263,10 +253,10 @@ namespace SMESH{
virtual double GetBadRate( double Value, int nbNodes ) const;
virtual SMDSAbs_ElementType GetType() const;
struct Value{
double myLength;
long myPntId[2];
Value(double theLength, long thePntId1, long thePntId2);
bool operator<(const Value& x) const;
double myLength;
long myPntId[2];
Value(double theLength, long thePntId1, long thePntId2);
bool operator<(const Value& x) const;
};
typedef std::set<Value> TValues;
void GetValues(TValues& theValues);
@@ -296,9 +286,9 @@ namespace SMESH{
virtual double GetBadRate( double Value, int nbNodes ) const;
virtual SMDSAbs_ElementType GetType() const;
struct Value{
long myPntId[2];
Value(long thePntId1, long thePntId2);
bool operator<(const Value& x) const;
long myPntId[2];
Value(long thePntId1, long thePntId2);
bool operator<(const Value& x) const;
};
typedef std::map<Value,int> MValues;
@@ -364,10 +354,10 @@ namespace SMESH{
static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId );
typedef long TElemId;
struct Border{
TElemId myElemId;
TElemId myPntId[2];
Border(long theElemId, long thePntId1, long thePntId2);
bool operator<(const Border& x) const;
TElemId myElemId;
TElemId myPntId[2];
Border(long theElemId, long thePntId1, long thePntId2);
bool operator<(const Border& x) const;
};
typedef std::set<Border> TBorders;
void GetBoreders(TBorders& theBorders);
@@ -797,13 +787,13 @@ namespace SMESH{
virtual
void
GetElementsId( const SMDS_Mesh* theMesh,
TIdSequence& theSequence );
TIdSequence& theSequence );
static
void
GetElementsId( const SMDS_Mesh* theMesh,
PredicatePtr thePredicate,
TIdSequence& theSequence );
PredicatePtr thePredicate,
TIdSequence& theSequence );
protected:
PredicatePtr myPredicate;

2
src/3rdParty/salomesmesh/inc/SMESH_DriverDAT.hxx vendored
View File

@@ -27,7 +27,7 @@
#define _SMESH_DriverDAT_HXX_
#ifdef WNT
#if defined MESHDRIVERDAT_EXPORTS || defined MeshDriverDAT_EXPORTS
#if defined MESHDRIVERDAT_EXPORTS
#define MESHDRIVERDAT_EXPORT __declspec( dllexport )
#else
#define MESHDRIVERDAT_EXPORT __declspec( dllimport )

2
src/3rdParty/salomesmesh/inc/SMESH_DriverSTL.hxx vendored
View File

@@ -27,7 +27,7 @@
#define _SMESH_DriverSTL_HXX_
#ifdef WNT
#if defined MESHDRIVERSTL_EXPORTS || defined MeshDriverSTL_EXPORTS
#if defined MESHDRIVERSTL_EXPORTS
#define MESHDRIVERSTL_EXPORT __declspec( dllexport )
#else
#define MESHDRIVERSTL_EXPORT __declspec( dllimport )

2
src/3rdParty/salomesmesh/inc/SMESH_DriverUNV.hxx vendored
View File

@@ -27,7 +27,7 @@
#define _SMESH_DriverUNV_HXX_
#ifdef WNT
#if defined MESHDRIVERUNV_EXPORTS || defined MeshDriverUNV_EXPORTS
#if defined MESHDRIVERUNV_EXPORTS
#define MESHDRIVERUNV_EXPORT __declspec( dllexport )
#else
#define MESHDRIVERUNV_EXPORT __declspec( dllimport )

14
src/3rdParty/salomesmesh/inc/SMESH_ExceptHandlers.hxx vendored
View File

@@ -31,7 +31,19 @@
#include <stdexcept>
#include <SMESH_SMESH.hxx>
#if defined SMESH_EXPORTS
#if defined WIN32
#define SMESH_EXPORT __declspec( dllexport )
#else
#define SMESH_EXPORT
#endif
#else
#if defined WNT
#define SMESH_EXPORT __declspec( dllimport )
#else
#define SMESH_EXPORT
#endif
#endif
typedef void (*PVF)();

14
src/3rdParty/salomesmesh/inc/SMESH_Exception.hxx vendored
View File

@@ -31,7 +31,19 @@
# define LOCALIZED(message) #message
#endif
#include <SMESH_SMESH.hxx>
#if defined SMESH_EXPORTS
#if defined WIN32
#define SMESH_EXPORT __declspec( dllexport )
#else
#define SMESH_EXPORT
#endif
#else
#if defined WNT
#define SMESH_EXPORT __declspec( dllimport )
#else
#define SMESH_EXPORT
#endif
#endif
class SMESH_EXPORT SMESH_Exception : public std::exception
{

39
src/3rdParty/salomesmesh/inc/SMESH_Gen.hxx vendored
View File

@@ -30,7 +30,7 @@
#include "SMESH_SMESH.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include "SMESH_Hypothesis.hxx"
#include "SMESH_ComputeError.hxx"
@@ -61,12 +61,12 @@ typedef std::set<int> TSetOfInt;
class SMESH_EXPORT SMESH_Gen
{
public:
public:
SMESH_Gen();
~SMESH_Gen();
SMESH_Mesh* CreateMesh(int theStudyId, bool theIsEmbeddedMode)
throw(SALOME_Exception);
throw(SMESH_Exception);
/*!
* \brief Computes aMesh on aShape
@@ -78,21 +78,8 @@ public:
bool Compute(::SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape,
const bool anUpward=false,
const ::MeshDimension aDim=::MeshDim_3D,
TSetOfInt* aShapesId=0);
/*!
* \brief evaluates size of prospective mesh on a shape
* \param aMesh - the mesh
* \param aShape - the shape
* \param aResMap - map for prospective numbers of elements
* \retval bool - is a success
*/
bool Evaluate(::SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap,
const bool anUpward=false,
TSetOfInt* aShapesId=0);
const ::MeshDimension aDim=::MeshDim_3D,
TSetOfInt* aShapesId=0);
bool CheckAlgoState(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
// notify on bad state of attached algos, return false
@@ -109,7 +96,7 @@ public:
*/
void SetDefaultNbSegments(int nb) { _nbSegments = nb; }
int GetDefaultNbSegments() const { return _nbSegments; }
struct TAlgoStateError
{
TAlgoStateErrorName _name;
@@ -138,6 +125,16 @@ public:
SMESH_Algo* GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, TopoDS_Shape* assignedTo=0);
static bool IsGlobalHypothesis(const SMESH_Hypothesis* theHyp, SMESH_Mesh& aMesh);
// inherited methods from SALOMEDS::Driver
// void Save(int studyId, const char *aUrlOfFile);
// void Load(int studyId, const char *aUrlOfFile);
// void Close(int studyId);
// const char *ComponentDataType();
// const char *IORToLocalPersistentID(const char *IORString, bool & IsAFile);
// const char *LocalPersistentIDToIOR(const char *aLocalPersistentID);
int GetANewId();
std::map < int, SMESH_Algo * >_mapAlgo;
@@ -146,9 +143,9 @@ public:
std::map < int, SMESH_2D_Algo * >_map2D_Algo;
std::map < int, SMESH_3D_Algo * >_map3D_Algo;
private:
private:
int _localId; // unique Id of created objects, within SMESH_Gen entity
int _localId; // unique Id of created objects, within SMESH_Gen entity
std::map < int, StudyContextStruct * >_mapStudyContext;
// hypotheses managing

2
src/3rdParty/salomesmesh/inc/SMESH_Group.hxx vendored
View File

@@ -23,7 +23,7 @@
// File : SMESH_Group.hxx
// Author : Michael Sazonov (OCC)
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_Group.hxx,v 1.8.2.1 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_Group_HeaderFile
#define _SMESH_Group_HeaderFile

6
src/3rdParty/salomesmesh/inc/SMESH_HypoFilter.hxx vendored
View File

@@ -22,7 +22,7 @@
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : SMESH_HypoFilter.hxx
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_HypoFilter.hxx,v 1.6.2.2 2008/11/27 12:25:15 abd Exp $
//
#ifndef SMESH_HypoFilter_HeaderFile
#define SMESH_HypoFilter_HeaderFile
@@ -96,14 +96,10 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
std::list<SMESH_HypoPredicate*> myPredicates;
// private methods
#ifdef __BORLANDC__
public:
#endif
enum Logical { AND, AND_NOT, OR, OR_NOT };
enum Comparison { EQUAL, NOT_EQUAL, MORE, LESS };
#ifdef __BORLANDC__
protected:
#endif
SMESH_HypoFilter(const SMESH_HypoFilter& other){}
void add( Logical bool_op, SMESH_HypoPredicate* pred )

2
src/3rdParty/salomesmesh/inc/SMESH_IndexedDataMapOfShapeIndexedMapOfShape.hxx vendored
View File

@@ -48,6 +48,8 @@ DEFINE_INDEXEDMAP (SMESH_IndexedMapOfShape, SMESH_BaseCollectionShape, TopoDS_Sh
SMESH_DEFINE_INDEXEDMAP (SMESH_IndexedMapOfShape, SMESH_BaseCollectionShape, TopoDS_Shape)
#endif
#endif
#ifndef SMESH_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile

89
src/3rdParty/salomesmesh/inc/SMESH_Mesh.hxx vendored
View File

@@ -23,6 +23,7 @@
// File : SMESH_Mesh.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_Mesh.hxx,v 1.18.2.3 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_MESH_HXX_
#define _SMESH_MESH_HXX_
@@ -35,7 +36,7 @@
#include "SMESHDS_Command.hxx"
#include "SMDSAbs_ElementType.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <TopoDS_Shape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
@@ -55,10 +56,10 @@ class SMESH_EXPORT SMESH_Mesh
{
public:
SMESH_Mesh(int theLocalId,
int theStudyId,
SMESH_Gen* theGen,
bool theIsEmbeddedMode,
SMESHDS_Document* theDocument);
int theStudyId,
SMESH_Gen* theGen,
bool theIsEmbeddedMode,
SMESHDS_Document* theDocument);
virtual ~SMESH_Mesh();
@@ -74,7 +75,7 @@ public:
* \brief Return true if there is a geometry to be meshed, not PseudoShape()
*/
bool HasShapeToMesh() const { return _isShapeToMesh; }
/*!
/*!
* \brief Return diagonal size of bounding box of shape to mesh.
*/
double GetShapeDiagonalSize() const;
@@ -93,7 +94,7 @@ public:
*/
void Clear();
/*!
/*!
* \brief Remove all nodes and elements of indicated shape
*/
void ClearSubMesh(const int theShapeId);
@@ -110,15 +111,15 @@ public:
SMESH_Hypothesis::Hypothesis_Status
AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
throw(SALOME_Exception);
throw(SMESH_Exception);
SMESH_Hypothesis::Hypothesis_Status
RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
throw(SALOME_Exception);
throw(SMESH_Exception);
const std::list <const SMESHDS_Hypothesis * >&
GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception);
throw(SMESH_Exception);
const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape,
const SMESH_HypoFilter& aFilter,
@@ -130,9 +131,9 @@ public:
std::list <const SMESHDS_Hypothesis * >& aHypList,
const bool andAncestors) const;
const std::list<SMESHDS_Command*> & GetLog() throw(SALOME_Exception);
const std::list<SMESHDS_Command*> & GetLog() throw(SMESH_Exception);
void ClearLog() throw(SALOME_Exception);
void ClearLog() throw(SMESH_Exception);
int GetId() { return _id; }
@@ -141,30 +142,30 @@ public:
SMESH_Gen *GetGen() { return _gen; }
SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
throw(SALOME_Exception);
throw(SMESH_Exception);
SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception);
throw(SMESH_Exception);
SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
throw(SALOME_Exception);
throw(SMESH_Exception);
/*!
* \brief Return submeshes of groups containing the given subshape
*/
std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
throw(SALOME_Exception);
throw(SMESH_Exception);
/*!
* \brief Say all submeshes that theChangedHyp has been modified
*/
void NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* theChangedHyp);
const std::list < SMESH_subMesh * >&
GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) throw(SALOME_Exception);
GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) throw(SMESH_Exception);
/*!
* \brief Return True if anHyp is used to mesh aSubShape
*/
bool IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
const SMESH_subMesh * aSubMesh);
const SMESH_subMesh * aSubMesh);
/*!
* \brief check if a hypothesis alowing notconform mesh is present
*/
@@ -177,9 +178,9 @@ public:
*/
const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
void SetAutoColor(bool theAutoColor) throw(SALOME_Exception);
void SetAutoColor(bool theAutoColor) throw(SMESH_Exception);
bool GetAutoColor() throw(SALOME_Exception);
bool GetAutoColor() throw(SMESH_Exception);
/*!
* \brief Return data map of descendant to ancestor shapes
@@ -193,48 +194,46 @@ public:
bool HasDuplicatedGroupNamesMED();
void ExportMED(const char *file,
const char* theMeshName = NULL,
bool theAutoGroups = true,
int theVersion = 0)
throw(SALOME_Exception);
const char* theMeshName = NULL,
bool theAutoGroups = true,
int theVersion = 0)
throw(SMESH_Exception);
void ExportDAT(const char *file) throw(SALOME_Exception);
void ExportUNV(const char *file) throw(SALOME_Exception);
void ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception);
void ExportDAT(const char *file) throw(SMESH_Exception);
void ExportUNV(const char *file) throw(SMESH_Exception);
void ExportSTL(const char *file, const bool isascii) throw(SMESH_Exception);
int NbNodes() throw(SALOME_Exception);
int NbNodes() throw(SMESH_Exception);
int Nb0DElements() throw(SALOME_Exception);
int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbPolygons() throw(SALOME_Exception);
int NbPolygons() throw(SMESH_Exception);
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SMESH_Exception);
int NbPolyhedrons() throw(SALOME_Exception);
int NbPolyhedrons() throw(SMESH_Exception);
int NbSubMesh() throw(SALOME_Exception);
int NbSubMesh() throw(SMESH_Exception);
int NbGroup() const { return _mapGroup.size(); }
SMESH_Group* AddGroup (const SMDSAbs_ElementType theType,
const char* theName,
int& theId,
const char* theName,
int& theId,
const TopoDS_Shape& theShape=TopoDS_Shape());
typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
@@ -273,7 +272,7 @@ protected:
bool _isAutoColor;
double _shapeDiagonal; //!< diagonal size of bounding box of shape to mesh
TopTools_IndexedDataMapOfShapeListOfShape _mapAncestors;
protected:

144
src/3rdParty/salomesmesh/inc/SMESH_MeshEditor.hxx vendored
View File

@@ -41,7 +41,6 @@
#include <list>
#include <map>
#include <set>
class SMDS_MeshFace;
class SMDS_MeshNode;
@@ -55,38 +54,12 @@ typedef std::map<const SMDS_MeshElement*,
std::list<const SMDS_MeshElement*> > TElemOfElemListMap;
typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
//!< Set of elements sorted by ID, to be used to assure predictability of edition
//!< Set of elements sorted by ID, to be used to assure predictability of edition
typedef std::set< const SMDS_MeshElement*, TIDCompare > TIDSortedElemSet;
typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* > NLink;
//=======================================================================
/*!
* \brief Searcher for the node closest to point
*/
//=======================================================================
struct SMESH_NodeSearcher
{
virtual const SMDS_MeshNode* FindClosestTo( const gp_Pnt& pnt ) = 0;
virtual void MoveNode( const SMDS_MeshNode* node, const gp_Pnt& toPnt ) = 0;
};
//=======================================================================
/*!
* \brief Return elements of given type where the given point is IN or ON.
*
* 'ALL' type means elements of any type excluding nodes and 0D elements
*/
//=======================================================================
struct SMESH_ElementSearcher
{
virtual void FindElementsByPoint(const gp_Pnt& point,
SMDSAbs_ElementType type,
std::vector< const SMDS_MeshElement* >& foundElems)=0;
};
//=======================================================================
/*!
* \brief A sorted pair of nodes
@@ -99,56 +72,19 @@ struct SMESH_TLink: public NLink
{ if ( n1->GetID() < n2->GetID() ) std::swap( first, second ); }
SMESH_TLink(const NLink& link ):NLink( link )
{ if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
const SMDS_MeshNode* node1() const { return first; }
const SMDS_MeshNode* node2() const { return second; }
};
//=======================================================================
// ============================================================
/*!
* auxiliary class
* \brief Searcher for the node closest to point
*/
//=======================================================================
class SMESH_MeshEditor_PathPoint {
public:
SMESH_MeshEditor_PathPoint() {
myPnt.SetCoord(99., 99., 99.);
myTgt.SetCoord(1.,0.,0.);
myAngle=0.;
myPrm=0.;
}
void SetPnt(const gp_Pnt& aP3D){
myPnt=aP3D;
}
void SetTangent(const gp_Dir& aTgt){
myTgt=aTgt;
}
void SetAngle(const double& aBeta){
myAngle=aBeta;
}
void SetParameter(const double& aPrm){
myPrm=aPrm;
}
const gp_Pnt& Pnt()const{
return myPnt;
}
const gp_Dir& Tangent()const{
return myTgt;
}
double Angle()const{
return myAngle;
}
double Parameter()const{
return myPrm;
}
// ============================================================
protected:
gp_Pnt myPnt;
gp_Dir myTgt;
double myAngle;
double myPrm;
struct SMESH_NodeSearcher
{
virtual const SMDS_MeshNode* FindClosestTo( const gp_Pnt& pnt ) = 0;
};
// ============================================================
/*!
* \brief Editor of a mesh
@@ -356,16 +292,6 @@ public:
const SMDS_MeshNode* theNodeStart,
const bool theHasAngles,
std::list<double>& theAngles,
const bool theLinearVariation,
const bool theHasRefPoint,
const gp_Pnt& theRefPoint,
const bool theMakeGroups);
Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet & theElements,
SMESH_Mesh* theTrackPattern,
const SMDS_MeshNode* theNodeStart,
const bool theHasAngles,
std::list<double>& theAngles,
const bool theLinearVariation,
const bool theHasRefPoint,
const gp_Pnt& theRefPoint,
const bool theMakeGroups);
@@ -379,7 +305,6 @@ public:
SMESH_Mesh* theTargetMesh=0);
// Move or copy theElements applying theTrsf to their nodes
typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes;
void FindCoincidentNodes (std::set<const SMDS_MeshNode*> & theNodes,
@@ -393,16 +318,6 @@ public:
*/
SMESH_NodeSearcher* GetNodeSearcher();
/*!
* \brief Return SMESH_ElementSearcher
*/
SMESH_ElementSearcher* GetElementSearcher();
/*!
* \brief Return true if the point is IN or ON of the element
*/
static bool isOut( const SMDS_MeshElement* element, const gp_Pnt& point, double tol );
int SimplifyFace (const std::vector<const SMDS_MeshNode *> faceNodes,
std::vector<const SMDS_MeshNode *>& poly_nodes,
std::vector<int>& quantities) const;
@@ -416,7 +331,7 @@ public:
typedef std::list< std::list< int > > TListOfListOfElementsID;
void FindEqualElements(std::set<const SMDS_MeshElement*> & theElements,
TListOfListOfElementsID & theGroupsOfElementsID);
TListOfListOfElementsID & theGroupsOfElementsID);
// Return list of group of elements build on the same nodes.
// Search among theElements or in the whole mesh if theElements is empty.
@@ -601,25 +516,10 @@ public:
const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; }
const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
bool DoubleNodes( const std::list< int >& theListOfNodes,
const std::list< int >& theListOfModifiedElems );
bool DoubleNodes( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
const TIDSortedElemSet& theAffectedElems );
bool DoubleNodesInRegion( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
const TopoDS_Shape& theShape );
/*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh
* The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise
*/
bool Make2DMeshFrom3D();
private:
/*!
@@ -683,32 +583,6 @@ private:
TIDSortedElemSet& elemSet,
const int nbSteps,
SMESH_SequenceOfElemPtr& srcElements);
/*!
* auxilary for ExtrusionAlongTrack
*/
Extrusion_Error MakeEdgePathPoints(std::list<double>& aPrms,
const TopoDS_Edge& aTrackEdge,
bool FirstIsStart,
list<SMESH_MeshEditor_PathPoint>& LPP);
Extrusion_Error MakeExtrElements(TIDSortedElemSet& theElements,
list<SMESH_MeshEditor_PathPoint>& fullList,
const bool theHasAngles,
list<double>& theAngles,
const bool theLinearVariation,
const bool theHasRefPoint,
const gp_Pnt& theRefPoint,
const bool theMakeGroups);
void LinearAngleVariation(const int NbSteps,
list<double>& theAngles);
bool doubleNodes( SMESHDS_Mesh* theMeshDS,
const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
std::map< const SMDS_MeshNode*,
const SMDS_MeshNode* >& theNodeNodeMap,
const bool theIsDoubleElem );
private:
SMESH_Mesh * myMesh;

70
src/3rdParty/salomesmesh/inc/SMESH_MesherHelper.hxx vendored
View File

@@ -32,15 +32,15 @@
#include <SMDS_MeshNode.hxx>
#include <SMDS_QuadraticEdge.hxx>
#include <Geom_Surface.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <gp_Pnt2d.hxx>
#include <map>
typedef std::map<SMESH_TLink, const SMDS_MeshNode*> TLinkNodeMap;
typedef std::map<SMESH_TLink, const SMDS_MeshNode*>::iterator ItTLinkNode;
typedef std::pair<const SMDS_MeshNode*, const SMDS_MeshNode*> NLink;
typedef std::map<NLink, const SMDS_MeshNode*> NLinkNodeMap;
typedef std::map<NLink, const SMDS_MeshNode*>::iterator ItNLinkNode;
/*!
* \brief It helps meshers to add elements
@@ -91,8 +91,9 @@ public:
* \param meshDS - mesh DS
* \retval TopoDS_Shape - found support shape
*/
static TopoDS_Shape GetSubShapeByNode(const SMDS_MeshNode* node,
SMESHDS_Mesh* meshDS);
static const TopoDS_Shape& GetSubShapeByNode(const SMDS_MeshNode* node,
SMESHDS_Mesh* meshDS)
{ return meshDS->IndexToShape( node->GetPosition()->GetShapeId() ); }
/*!
* \brief Return a valid node index, fixing the given one if necessary
@@ -125,7 +126,7 @@ public:
/*!
* Check submesh for given shape: if all elements on this shape are quadratic,
* quadratic elements will be created. Also fill myTLinkNodeMap
* quadratic elements will be created. Also fill myNLinkNodeMap
*/
bool IsQuadraticSubMesh(const TopoDS_Shape& theShape);
/*!
@@ -138,12 +139,6 @@ public:
*/
bool GetIsQuadratic() const { return myCreateQuadratic; }
/*!
* \brief Move medium nodes of faces and volumes to fix distorted elements
* \param volumeOnly - fix nodes on geom faces or not if the shape is solid
*/
void FixQuadraticElements(bool volumeOnly=true);
/*!
* \brief To set created elements on the shape set by IsQuadraticSubMesh()
* or the next methods. By defaul elements are set on the shape if
@@ -184,7 +179,7 @@ public:
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const int id=0,
const bool force3d = false);
const bool force3d = false);
/*!
* Creates quadratic or linear quadrangle
*/
@@ -193,7 +188,7 @@ public:
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id = 0,
const bool force3d = false);
const bool force3d = false);
/*!
* Creates quadratic or linear tetraahedron
*/
@@ -202,7 +197,7 @@ public:
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id = 0,
const bool force3d = true);
const bool force3d = true);
/*!
* Creates quadratic or linear pyramid
*/
@@ -212,7 +207,7 @@ public:
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const int id = 0,
const bool force3d = true);
const bool force3d = true);
/*!
* Creates quadratic or linear pentahedron
*/
@@ -223,7 +218,7 @@ public:
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const int id = 0,
const bool force3d = true);
const bool force3d = true);
/*!
* Creates quadratic or linear hexahedron
*/
@@ -236,35 +231,19 @@ public:
const SMDS_MeshNode* n7,
const SMDS_MeshNode* n8,
const int id = 0,
bool force3d = true);
bool force3d = true);
/*!
* \brief Return U of the given node on the edge
*/
double GetNodeU(const TopoDS_Edge& theEdge,
const SMDS_MeshNode* theNode,
bool* check=0);
const SMDS_MeshNode* theNode);
/*!
* \brief Return node UV on face
* \param inFaceNode - a node of element being created located inside a face
* \param inFaceNode - a node of element being created located inside a face
*/
gp_XY GetNodeUV(const TopoDS_Face& F,
const SMDS_MeshNode* n,
const SMDS_MeshNode* inFaceNode=0,
bool* check=0) const;
/*!
* \brief Check and fix node UV on a face
* \retval bool - false if UV is bad and could not be fixed
*/
bool CheckNodeUV(const TopoDS_Face& F,
const SMDS_MeshNode* n,
gp_XY& uv,
const double tol) const;
/*!
* \brief Return middle UV taking in account surface period
*/
static gp_XY GetMiddleUV(const Handle(Geom_Surface)& surface,
const gp_XY& uv1,
const gp_XY& uv2);
const SMDS_MeshNode* inFaceNode=0) const;
/*!
* \brief Check if inFaceNode argument is necessary for call GetNodeUV(F,..)
* \retval bool - return true if the face is periodic
@@ -338,21 +317,21 @@ public:
const SMDS_MeshNode* n2,
const bool force3d);
/*!
* Auxilary function for filling myTLinkNodeMap
* Auxilary function for filling myNLinkNodeMap
*/
void AddTLinkNode(const SMDS_MeshNode* n1,
void AddNLinkNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n12);
/**
* Auxilary function for filling myTLinkNodeMap
* Auxilary function for filling myNLinkNodeMap
*/
void AddTLinkNodeMap(const TLinkNodeMap& aMap)
{ myTLinkNodeMap.insert(aMap.begin(), aMap.end()); }
void AddNLinkNodeMap(const NLinkNodeMap& aMap)
{ myNLinkNodeMap.insert(aMap.begin(), aMap.end()); }
/**
* Returns myTLinkNodeMap
* Returns myNLinkNodeMap
*/
const TLinkNodeMap& GetTLinkNodeMap() const { return myTLinkNodeMap; }
const NLinkNodeMap& GetNLinkNodeMap() const { return myNLinkNodeMap; }
/**
* Check mesh without geometry for: if all elements on this shape are quadratic,
@@ -378,7 +357,7 @@ protected:
SMESH_MesherHelper (const SMESH_MesherHelper& theOther) {};
// special map for using during creation of quadratic elements
TLinkNodeMap myTLinkNodeMap;
NLinkNodeMap myNLinkNodeMap;
std::set< int > myDegenShapeIds;
std::set< int > mySeamShapeIds;
@@ -392,7 +371,6 @@ protected:
// to create quadratic elements
bool myCreateQuadratic;
bool mySetElemOnShape;
std::set< int > myOkNodePosShapes;
};

108
src/3rdParty/salomesmesh/inc/SMESH_Octree.hxx vendored
View File

@@ -20,12 +20,11 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH_Octree : global Octree implementation
// File : SMESH_Octree.hxx
// Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurélien Motteux (OCC)
// Module : SMESH
//
// File : SMESH_Octree.hxx
// Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurélien Motteux (OCC)
// Module : SMESH
#ifndef _SMESH_OCTREE_HXX_
#define _SMESH_OCTREE_HXX_
@@ -34,90 +33,67 @@
class SMESH_Octree {
public:
// Data limiting the tree height
struct Limit {
// MaxLevel of the Octree
int myMaxLevel;
// Minimal size of the Box
double myMinBoxSize;
// Default:
// maxLevel-> 8^8 = 16777216 terminal trees
// minSize -> box size not checked
Limit(int maxLevel=8, double minSize=0.):myMaxLevel(maxLevel),myMinBoxSize(minSize) {}
virtual ~Limit() {} // it can be inherited
};
// Constructor. limit must be provided at tree root construction.
// limit will be deleted by SMESH_Octree
SMESH_Octree (Limit* limit=0);
// Constructor
SMESH_Octree (const int maxLevel = -1, const double minBoxSize = 0.);
// Destructor
virtual ~SMESH_Octree ();
// Compute the Octree. Must be called by constructor of inheriting class
void compute();
// Tell if Octree is a leaf or not (has to be implemented in inherited classes)
virtual const bool isLeaf() = 0;
// Tell if Octree is a leaf or not.
// An inheriting class can influence it via myIsLeaf protected field
bool isLeaf() const;
// Compute the Octree
void Compute();
// Set the maximal level of the Octree
void setMaxLevel(const int maxLevel);
// Set the minimal size of the Box
void setMinBoxSize(const double minBoxSize){myMinBoxSize = minBoxSize;};
// Set the bounding box of the Octree
void setBox(const Bnd_B3d* box);
// Set box to the 3d Bounding Box of the Octree
void getBox(Bnd_B3d & box);
// Compute the bigger dimension of the box
static double maxSize(const Bnd_B3d* box);
// Return its level
int level() const { return myLevel; }
// Get box to the 3d Bounding Box of the Octree
const Bnd_B3d& getBox() const { return *myBox; }
// Compute the bigger dimension of my box
double maxSize() const;
// Return index of a child the given point is in
inline int getChildIndex(double x, double y, double z, const gp_XYZ& boxMiddle)const;
protected:
// Return box of the whole tree
virtual Bnd_B3d* buildRootBox() = 0;
// Constructor for children (has to be implemented in inherited classes)
virtual SMESH_Octree* allocateOctreeChild() = 0;
// Constructor for children
virtual SMESH_Octree* allocateOctreeChild() const = 0;
// Build the 8 children boxes
void buildChildren();
// Build the data in the 8 children
virtual void buildChildrenData() = 0;
// Build the data in the 8 children (has to be implemented in inherited classes)
virtual void buildChildrenData() = 0;
// members
// Box of the Octree
Bnd_B3d* myBox;
// Array of 8 Octree children
SMESH_Octree** myChildren;
// Point the father, set to NULL for the level 0
SMESH_Octree* myFather;
// Tell us if the Octree is a leaf or not
bool myIsLeaf;
// Tree limit
const Limit* myLimit;
private:
// Build the 8 children boxes recursively
void buildChildren();
// Level of the Octree
int myLevel;
Bnd_B3d* myBox;
// MaxLevel of the Octree
int myMaxLevel;
// Minimal size of the Box
double myMinBoxSize;
// Tell us if the Octree is a leaf or not (-1 if not initialized)
int myIsLeaf;
};
//================================================================================
/*!
* \brief Return index of a child the given point is in
*/
//================================================================================
inline int SMESH_Octree::getChildIndex(double x, double y, double z, const gp_XYZ& mid) const
{
return (x > mid.X()) + ( y > mid.Y())*2 + (z > mid.Z())*4;
}
#endif

41
src/3rdParty/salomesmesh/inc/SMESH_OctreeNode.hxx vendored
View File

@@ -34,7 +34,6 @@
#include <list>
#include <set>
#include <map>
#include "SMDS_ElemIterator.hxx"
@@ -45,7 +44,7 @@ class SMESH_OctreeNode;
typedef SMDS_Iterator<SMESH_OctreeNode*> SMESH_OctreeNodeIterator;
typedef boost::shared_ptr<SMESH_OctreeNodeIterator> SMESH_OctreeNodeIteratorPtr;
class SMESH_OctreeNode : public SMESH_Octree {
class SMESH_OctreeNode : public SMESH_Octree{
public:
@@ -60,6 +59,9 @@ public:
//=============================
virtual ~SMESH_OctreeNode () {};
// Tells us if SMESH_OctreeNode is a leaf or not (-1 = not initialiazed)
virtual const bool isLeaf();
// Tells us if Node is inside the current box with the precision "precision"
virtual const bool isInside(const SMDS_MeshNode * Node, const double precision = 0.);
@@ -68,11 +70,6 @@ public:
std::list<const SMDS_MeshNode*>* Result,
const double precision = 0.);
// Return in dist2Nodes nodes mapped to their square distance from Node
bool NodesAround(const SMDS_MeshNode * Node,
std::map<double, const SMDS_MeshNode*>& dist2Nodes,
double precision);
// Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance
// Search for all the nodes in nodes
void FindCoincidentNodes ( std::set<const SMDS_MeshNode*>* nodes,
@@ -81,15 +78,10 @@ public:
// Static method that return in theGroupsOfNodes a list of group of nodes close to each other within
// theTolerance search for all the nodes in nodes
static void FindCoincidentNodes ( std::set<const SMDS_MeshNode*>& nodes,
static void FindCoincidentNodes ( std::set<const SMDS_MeshNode*> nodes,
std::list< std::list< const SMDS_MeshNode*> >* theGroupsOfNodes,
const double theTolerance = 0.00001,
const int maxLevel = -1,
const double theTolerance = 0.00001, const int maxLevel = -1,
const int maxNbNodes = 5);
/*!
* \brief Update data according to node movement
*/
void UpdateByMoveNode( const SMDS_MeshNode* node, const gp_Pnt& toPnt );
/*!
* \brief Return iterator over children
*/
@@ -101,20 +93,25 @@ public:
/*!
* \brief Return nb nodes in a tree
*/
int NbNodes() const { return myNodes.size(); }
int NbNodes() const { return myNbNodes; }
protected:
SMESH_OctreeNode (int maxNbNodes );
// Compute the bounding box of the whole set of nodes myNodes
virtual Bnd_B3d* buildRootBox();
//=============================
/*!
* \brief Empty constructor
*/
//=============================
SMESH_OctreeNode (){};
// Shares the father's data with each of his child
virtual void buildChildrenData();
// Compute the bounding box of the whole set of nodes myNodes (only used for OctreeNode level 0)
void computeBoxForFather();
// Construct an empty SMESH_OctreeNode used by SMESH_Octree::buildChildren()
virtual SMESH_Octree* allocateOctreeChild() const;
virtual SMESH_Octree* allocateOctreeChild();
// Return in result a list of nodes closed to Node and remove it from SetOfNodes
void FindCoincidentNodes( const SMDS_MeshNode * Node,
@@ -123,11 +120,13 @@ protected:
const double precision);
// The max number of nodes a leaf box can contain
int myMaxNbNodes;
int myMaxNbNodes;
// The set of nodes inside the box of the Octree (Empty if Octree is not a leaf)
std::set<const SMDS_MeshNode*> myNodes;
// The number of nodes I have inside the box
int myNbNodes;
};
#endif

2
src/3rdParty/salomesmesh/inc/SMESH_Pattern.hxx vendored
View File

@@ -299,7 +299,7 @@ private:
const TListOfEdgesList::iterator& theFromWire,
const TListOfEdgesList::iterator& theToWire,
const int theFirstEdgeID,
std::list< std::list< TPoint* > >& theEdgesPointsList );
std::list< std::list< TPoint* > >& theEdgesPointsList );
// sort wires in theWireList from theFromWire until theToWire,
// the wires are set in the order to correspond to the order
// of boundaries; after sorting, edges in the wires are put

2
src/3rdParty/salomesmesh/inc/SMESH_SMESH.hxx vendored
View File

@@ -27,7 +27,7 @@
#define _SMESH_SMESH_HXX_
#ifdef WNT
#if defined SMESHimpl_EXPORTS
#if defined SMESH_EXPORTS
#define SMESH_EXPORT __declspec( dllexport )
#else
#define SMESH_EXPORT __declspec( dllimport )

2
src/3rdParty/salomesmesh/inc/SMESH_StdMeshers.hxx vendored
View File

@@ -28,7 +28,7 @@
#define _SMESH_StdMeshers_HXX_
#ifdef WNT
#if defined STDMESHERS_EXPORTS || defined StdMeshers_EXPORTS
#if defined STDMESHERS_EXPORTS
#define STDMESHERS_EXPORT __declspec( dllexport )
#else
#define STDMESHERS_EXPORT __declspec( dllimport )

13
src/3rdParty/salomesmesh/inc/SMESH_subMesh.hxx vendored
View File

@@ -23,6 +23,7 @@
// File : SMESH_subMesh.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/SMESH/SMESH_subMesh.hxx,v 1.12.2.3 2008/11/27 12:25:15 abd Exp $
//
#ifndef _SMESH_SUBMESH_HXX_
#define _SMESH_SUBMESH_HXX_
@@ -33,9 +34,8 @@
#include "SMESHDS_SubMesh.hxx"
#include "SMESH_Hypothesis.hxx"
#include "SMESH_ComputeError.hxx"
#include "SMESH_Algo.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <TopoDS_Shape.hxx>
@@ -47,7 +47,7 @@ class SMESH_Hypothesis;
class SMESH_Algo;
class SMESH_Gen;
class SMESH_subMeshEventListener;
struct SMESH_subMeshEventListenerData;
class SMESH_subMeshEventListenerData;
class SMESH_subMesh;
typedef SMESH_subMeshEventListener EventListener;
@@ -60,7 +60,7 @@ class SMESH_EXPORT SMESH_subMesh
{
public:
SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
const TopoDS_Shape & aSubShape);
const TopoDS_Shape & aSubShape);
virtual ~ SMESH_subMesh();
int GetId() const;
@@ -192,8 +192,6 @@ public:
bool ComputeStateEngine(int event);
bool Evaluate(MapShapeNbElems& aResMap);
bool IsConform(const SMESH_Algo* theAlgo);
// check if a conform mesh will be produced by the Algo
@@ -225,9 +223,10 @@ public:
* none mesh entity is bound to it
*/
void SetIsAlwaysComputed(bool isAlCo);
bool IsAlwaysComputed() { return _alwaysComputed; }
protected:
// ==================================================================
void InsertDependence(const TopoDS_Shape aSubShape);

21
src/3rdParty/salomesmesh/inc/StdMeshers_Arithmetic1D.hxx vendored
View File

@@ -23,18 +23,15 @@
// File : StdMeshers_Arithmetic1D.hxx
// Author : Damien COQUERET, OCC
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_Arithmetic1D.hxx,v 1.7.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_ARITHMETIC1D_HXX_
#define _SMESH_ARITHMETIC1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_Arithmetic1D:
public SMESH_Hypothesis
@@ -43,18 +40,10 @@ public:
StdMeshers_Arithmetic1D(int hypId, int studyId, SMESH_Gen* gen);
virtual ~StdMeshers_Arithmetic1D();
void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
void SetLength(double length, bool isStartLength) throw(SMESH_Exception);
double GetLength(bool isStartLength) const;
void SetReversedEdges( std::vector<int>& ids);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream& operator << (std::ostream & save, StdMeshers_Arithmetic1D & hyp);
@@ -68,7 +57,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
@@ -76,8 +65,6 @@ public:
protected:
double _begLength, _endLength;
std::vector<int> _edgeIDs;
std::string _objEntry;
};
#endif

11
src/3rdParty/salomesmesh/inc/StdMeshers_AutomaticLength.hxx vendored
View File

@@ -23,14 +23,15 @@
// File : StdMeshers_AutomaticLength.hxx
// Author : Edward AGAPOV, OCC
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_AutomaticLength.hxx,v 1.5.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_AutomaticLength_HXX_
#define _SMESH_AutomaticLength_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <map>
@@ -55,13 +56,13 @@ public:
* \brief Computes segment for a given edge
*/
double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge)
throw(SALOME_Exception);
throw(SMESH_Exception);
/*!
* \brief Computes segment length for an edge of given length
*/
double GetLength(const SMESH_Mesh* aMesh, const double edgeLength)
throw(SALOME_Exception);
throw(SMESH_Exception);
/*!
* \brief Set Fineness
@@ -74,7 +75,7 @@ public:
* is divided by (0.5 + 4.5 x theFineness)
*/
void SetFineness(double theFineness)
throw(SALOME_Exception);
throw(SMESH_Exception);
/*!
* \brief Return mesh Fineness

3
src/3rdParty/salomesmesh/inc/StdMeshers_CompositeHexa_3D.hxx vendored
View File

@@ -50,9 +50,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
Hypothesis_Status& aStatus);

2
src/3rdParty/salomesmesh/inc/StdMeshers_CompositeSegment_1D.hxx vendored
View File

@@ -22,7 +22,7 @@
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : StdMeshers_CompositeSegment_1D.hxx
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_CompositeSegment_1D.hxx,v 1.2.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_CompositeSegment_1D_HXX_
#define _SMESH_CompositeSegment_1D_HXX_

10
src/3rdParty/salomesmesh/inc/StdMeshers_Deflection1D.hxx vendored
View File

@@ -22,15 +22,15 @@
// SMESH StdMeshers : implementaion of SMESH idl descriptions
// File : StdMeshers_Deflection1D.hxx
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_Deflection1D.hxx,v 1.7.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _StdMeshers_Deflection1D_HXX_
#define _StdMeshers_Deflection1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
{
@@ -38,7 +38,7 @@ class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
StdMeshers_Deflection1D(int hypId, int studyId, SMESH_Gen * gen);
virtual ~ StdMeshers_Deflection1D();
void SetDeflection(double value) throw(SALOME_Exception);
void SetDeflection(double value) throw(SMESH_Exception);
double GetDeflection() const;
@@ -55,13 +55,13 @@ class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
protected:
protected:
double _value;
};

2
src/3rdParty/salomesmesh/inc/StdMeshers_Distribution.hxx vendored
View File

@@ -23,7 +23,7 @@
// File : StdMeshers_Distribution.hxx
// Author : Alexandre SOLOVYOV
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_Distribution.hxx,v 1.4.2.2 2008/11/27 13:03:49 abd Exp $
//
#ifndef _STD_MESHERS_DISTRIBUTION_HXX_
#define _STD_MESHERS_DISTRIBUTION_HXX_

8
src/3rdParty/salomesmesh/inc/StdMeshers_FaceSide.hxx vendored
View File

@@ -93,12 +93,7 @@ public:
SMESH_Mesh* theMesh,
const bool theIsForward,
const bool theIgnoreMediumNodes);
/*!
* \brief Wrap for vertex using data from other FaceSide
*/
StdMeshers_FaceSide(const SMDS_MeshNode* theNode,
const gp_Pnt2d thePnt2d,
const StdMeshers_FaceSide* theSide);
/*!
* \brief Return wires of a face as StdMeshers_FaceSide's
*/
@@ -207,7 +202,6 @@ protected:
int myNbPonits, myNbSegments;
SMESH_Mesh* myMesh;
bool myMissingVertexNodes, myIgnoreMediumNodes;
gp_Pnt2d myDefaultPnt2d;
};

90
src/3rdParty/salomesmesh/inc/StdMeshers_FixedPoints1D.hxx vendored
View File

@@ -1,90 +0,0 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : StdMeshers_FixedPoints1D.hxx
// Author : Damien COQUERET, OCC
// Module : SMESH
//
#ifndef _SMESH_FIXEDPOINTS1D_HXX_
#define _SMESH_FIXEDPOINTS1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
class STDMESHERS_EXPORT StdMeshers_FixedPoints1D:
public SMESH_Hypothesis
{
public:
StdMeshers_FixedPoints1D(int hypId, int studyId, SMESH_Gen* gen);
virtual ~StdMeshers_FixedPoints1D();
void SetPoints(std::vector<double>& listParams)
throw(SALOME_Exception);
void SetNbSegments(std::vector<int>& listNbSeg)
throw(SALOME_Exception);
const std::vector<double>& GetPoints() const { return _params; }
const std::vector<int>& GetNbSegments() const { return _nbsegs; }
void SetReversedEdges( std::vector<int>& ids);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream& operator << (std::ostream & save, StdMeshers_FixedPoints1D & hyp);
friend std::istream& operator >> (std::istream & load, StdMeshers_FixedPoints1D & hyp);
/*!
* \brief Initialize start and end length by the mesh built on the geometry
* \param theMesh - the built mesh
* \param theShape - the geometry of interest
* \retval bool - true if parameter values have been successfully defined
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
protected:
std::vector<double> _params;
std::vector<int> _nbsegs;
std::vector<int> _edgeIDs;
std::string _objEntry;
};
#endif

7
src/3rdParty/salomesmesh/inc/StdMeshers_Hexa_3D.hxx vendored
View File

@@ -33,7 +33,7 @@
#include "SMESH_3D_Algo.hxx"
#include "SMESH_Mesh.hxx"
#include "StdMeshers_Quadrangle_2D.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include "SMESH_MesherHelper.hxx"
@@ -75,10 +75,7 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape)
/*throw (SALOME_Exception)*/;
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
/*throw (SMESH_Exception)*/;
static TopoDS_Vertex OppositeVertex(const TopoDS_Vertex& aVertex,
const TopTools_IndexedMapOfShape& aQuads0Vertices,

7
src/3rdParty/salomesmesh/inc/StdMeshers_LayerDistribution.hxx vendored
View File

@@ -23,6 +23,7 @@
// File : StdMeshers_LayerDistribution.hxx
// Author : Edward AGAPOV
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_LayerDistribution.hxx,v 1.2.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_LayerDistribution_HXX_
#define _SMESH_LayerDistribution_HXX_
@@ -30,7 +31,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <string>
@@ -59,7 +60,7 @@ public:
* \param hyp1D - 1D hypothesis
*/
void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* \brief Returns 1D hypothesis specifying distribution of layers
@@ -82,7 +83,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

55
src/3rdParty/salomesmesh/inc/StdMeshers_LayerDistribution2D.hxx vendored
View File

@@ -1,55 +0,0 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
// File : StdMeshers_LayerDistribution2D.hxx
// Author : Edward AGAPOV
// Module : SMESH
//
#ifndef _SMESH_LayerDistribution2D_HXX_
#define _SMESH_LayerDistribution2D_HXX_
#include "StdMeshers_LayerDistribution.hxx"
// =========================================================
// =========================================================
/*!
* This hypothesis is used by "Radial quadrangle" algorithm.
* It specifies 1D hypothesis defining distribution of segments
* between the internal and the external surfaces.
*/
// =========================================================
// =========================================================
class STDMESHERS_EXPORT StdMeshers_LayerDistribution2D
:public StdMeshers_LayerDistribution
{
public:
// Constructor
StdMeshers_LayerDistribution2D(int hypId, int studyId, SMESH_Gen* gen);
// Destructor
virtual ~StdMeshers_LayerDistribution2D();
};
#endif

8
src/3rdParty/salomesmesh/inc/StdMeshers_LengthFromEdges.hxx vendored
View File

@@ -24,15 +24,15 @@
// Moved here from SMESH_LengthFromEdges.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_LengthFromEdges.hxx,v 1.8.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_LENGTHFROMEDGES_HXX_
#define _SMESH_LENGTHFROMEDGES_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_LengthFromEdges:
public SMESH_Hypothesis
@@ -42,7 +42,7 @@ public:
virtual ~StdMeshers_LengthFromEdges();
void SetMode(int mode)
throw (SALOME_Exception);
throw (SMESH_Exception);
int GetMode();
@@ -61,7 +61,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

10
src/3rdParty/salomesmesh/inc/StdMeshers_LocalLength.hxx vendored
View File

@@ -24,15 +24,15 @@
// Moved here from SMESH_LocalLength.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_LocalLength.hxx,v 1.8.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_LOCALLENGTH_HXX_
#define _SMESH_LOCALLENGTH_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_LocalLength: public SMESH_Hypothesis
{
@@ -40,8 +40,8 @@ class STDMESHERS_EXPORT StdMeshers_LocalLength: public SMESH_Hypothesis
StdMeshers_LocalLength(int hypId, int studyId, SMESH_Gen * gen);
virtual ~ StdMeshers_LocalLength();
void SetLength(double length) throw(SALOME_Exception);
void SetPrecision(double precision) throw(SALOME_Exception);
void SetLength(double length) throw(SMESH_Exception);
void SetPrecision(double precision) throw(SMESH_Exception);
double GetLength() const;
double GetPrecision() const;
@@ -59,7 +59,7 @@ class STDMESHERS_EXPORT StdMeshers_LocalLength: public SMESH_Hypothesis
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

5
src/3rdParty/salomesmesh/inc/StdMeshers_MEFISTO_2D.hxx vendored
View File

@@ -24,7 +24,7 @@
// Moved here from SMESH_MEFISTO_2D.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_MEFISTO_2D.hxx,v 1.9.2.2 2008/11/27 13:03:49 abd Exp $
//
#ifndef _StdMeshers_MEFISTO_2D_HXX_
#define _StdMeshers_MEFISTO_2D_HXX_
@@ -57,9 +57,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
typedef boost::shared_ptr< StdMeshers_FaceSide> StdMeshers_FaceSidePtr;
typedef std::vector< StdMeshers_FaceSidePtr > TWireVector;

7
src/3rdParty/salomesmesh/inc/StdMeshers_MaxElementArea.hxx vendored
View File

@@ -24,6 +24,7 @@
// Moved here from SMESH_MaxElementArea.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_MaxElementArea.hxx,v 1.8.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_MAXELEMENTAREA_HXX_
#define _SMESH_MAXELEMENTAREA_HXX_
@@ -31,7 +32,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_MaxElementArea:public SMESH_Hypothesis
{
@@ -39,7 +40,7 @@ public:
StdMeshers_MaxElementArea(int hypId, int studyId, SMESH_Gen * gen);
virtual ~ StdMeshers_MaxElementArea();
void SetMaxArea(double maxArea) throw(SALOME_Exception);
void SetMaxArea(double maxArea) throw(SMESH_Exception);
double GetMaxArea() const;
@@ -56,7 +57,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

9
src/3rdParty/salomesmesh/inc/StdMeshers_MaxElementVolume.hxx vendored
View File

@@ -24,14 +24,15 @@
// Moved here from SMESH_MaxElementVolume.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_MaxElementVolume.hxx,v 1.8.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_MAXELEMENTVOLUME_HXX_
#define _SMESH_MAXELEMENTVOLUME_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_MaxElementVolume:
public SMESH_Hypothesis
@@ -41,7 +42,7 @@ public:
virtual ~StdMeshers_MaxElementVolume();
void SetMaxVolume(double maxVolume)
throw (SALOME_Exception);
throw (SMESH_Exception);
double GetMaxVolume() const;
@@ -58,7 +59,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

4
src/3rdParty/salomesmesh/inc/StdMeshers_MaxLength.hxx vendored
View File

@@ -28,7 +28,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_MaxLength: public SMESH_Hypothesis
{
@@ -36,7 +36,7 @@ class STDMESHERS_EXPORT StdMeshers_MaxLength: public SMESH_Hypothesis
StdMeshers_MaxLength(int hypId, int studyId, SMESH_Gen * gen);
virtual ~ StdMeshers_MaxLength();
void SetLength(double length) throw(SALOME_Exception);
void SetLength(double length) throw(SMESH_Exception);
double GetLength() const;
bool HavePreestimatedLength() const { return _preestimated > 0.; }

5
src/3rdParty/salomesmesh/inc/StdMeshers_NotConformAllowed.hxx vendored
View File

@@ -23,6 +23,7 @@
// File : StdMeshers_NotConformAllowed.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_NotConformAllowed.hxx,v 1.8.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _StdMeshers_NotConformAllowed_HXX_
#define _StdMeshers_NotConformAllowed_HXX_
@@ -30,7 +31,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_NotConformAllowed:
public SMESH_Hypothesis
@@ -54,7 +55,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

7
src/3rdParty/salomesmesh/inc/StdMeshers_NumberOfLayers.hxx vendored
View File

@@ -23,6 +23,7 @@
// File : StdMeshers_NumberOfLayers.hxx
// Author : Edward AGAPOV
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_NumberOfLayers.hxx,v 1.2.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_NumberOfLayers_HXX_
#define _SMESH_NumberOfLayers_HXX_
@@ -30,7 +31,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class SMESH_Gen;
@@ -53,7 +54,7 @@ public:
virtual ~StdMeshers_NumberOfLayers();
// Sets <number of segments> parameter value
void SetNumberOfLayers(int numberOfLayers) throw ( SALOME_Exception );
void SetNumberOfLayers(int numberOfLayers) throw ( SMESH_Exception );
// Returns <number of layers> parameter value
int GetNumberOfLayers() const;
@@ -73,7 +74,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

54
src/3rdParty/salomesmesh/inc/StdMeshers_NumberOfLayers2D.hxx vendored
View File

@@ -1,54 +0,0 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : idl implementation based on 'SMESH' unit's calsses
// File : StdMeshers_NumberOfLayers2D.hxx
// Author : Edward AGAPOV
// Module : SMESH
//
#ifndef _SMESH_NumberOfLayers2D_HXX_
#define _SMESH_NumberOfLayers2D_HXX_
#include "StdMeshers_NumberOfLayers.hxx"
// =========================================================
// =========================================================
/*!
* This hypothesis is used by "Radial quadrangle" algorithm.
* It specifies number of segments between the internal
* and the external surfaces.
*/
// =========================================================
// =========================================================
class STDMESHERS_EXPORT StdMeshers_NumberOfLayers2D
: public StdMeshers_NumberOfLayers
{
public:
// Constructor
StdMeshers_NumberOfLayers2D(int hypId, int studyId, SMESH_Gen* gen);
// Destructor
virtual ~StdMeshers_NumberOfLayers2D();
};
#endif

54
src/3rdParty/salomesmesh/inc/StdMeshers_NumberOfSegments.hxx vendored
View File

@@ -24,6 +24,7 @@
// Moved here from SMESH_NumberOfSegments.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_NumberOfSegments.hxx,v 1.12.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_NUMBEROFSEGMENTS_HXX_
#define _SMESH_NUMBEROFSEGMENTS_HXX_
@@ -31,7 +32,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <vector>
/*!
@@ -48,15 +49,15 @@ public:
virtual ~StdMeshers_NumberOfSegments();
// Builds point distribution according to passed function
const std::vector<double>& BuildDistributionExpr( const char*, int, int ) throw ( SALOME_Exception );
const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) throw ( SALOME_Exception );
const std::vector<double>& BuildDistributionExpr( const char*, int, int ) throw ( SMESH_Exception );
const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) throw ( SMESH_Exception );
/*!
* \brief Set the number of segments
* \param segmentsNumber - must be greater than zero
*/
void SetNumberOfSegments(int segmentsNumber)
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Get the number of segments
@@ -78,7 +79,7 @@ public:
* \brief Set distribution type
*/
void SetDistrType(DistrType typ)
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Get distribution type
@@ -89,19 +90,19 @@ public:
* \brief Set scale factor for scale distribution
* \param scaleFactor - positive value different from 1
*
* Throws SALOME_Exception if distribution type is not DT_Scale,
* Throws SMESH_Exception if distribution type is not DT_Scale,
* or scaleFactor is not a positive value different from 1
*/
virtual void SetScaleFactor(double scaleFactor)
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Get scale factor for scale distribution
*
* Throws SALOME_Exception if distribution type is not DT_Scale
* Throws SMESH_Exception if distribution type is not DT_Scale
*/
double GetScaleFactor() const
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Set table function for distribution DT_TabFunc
@@ -110,36 +111,36 @@ public:
* must be even. The parameters must be in range [0,1] and sorted in
* increase order. The values of function must be positive.
*
* Throws SALOME_Exception if distribution type is not DT_TabFunc
* Throws SMESH_Exception if distribution type is not DT_TabFunc
*/
void SetTableFunction(const std::vector<double>& table)
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Get table function for distribution DT_TabFunc
*
* Throws SALOME_Exception if distribution type is not DT_TabFunc
* Throws SMESH_Exception if distribution type is not DT_TabFunc
*/
const std::vector<double>& GetTableFunction() const
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Set expression function for distribution DT_ExprFunc
* \param expr - string containing the expression of the function
* f(t), e.g. "sin(t)"
*
* Throws SALOME_Exception if distribution type is not DT_ExprFunc
* Throws SMESH_Exception if distribution type is not DT_ExprFunc
*/
void SetExpressionFunction( const char* expr)
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Get expression function for distribution DT_ExprFunc
*
* Throws SALOME_Exception if distribution type is not DT_ExprFunc
* Throws SMESH_Exception if distribution type is not DT_ExprFunc
*/
const char* GetExpressionFunction() const
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Set conversion mode. When it is 0, it means "exponent mode":
@@ -148,26 +149,19 @@ public:
* F(t), where F(t0)=f(t0), if f(t0)>=0, otherwise F(t0) = 0.
* This mode is sensible only when function distribution is used (DT_TabFunc or DT_ExprFunc)
*
* Throws SALOME_Exception if distribution type is not functional
* Throws SMESH_Exception if distribution type is not functional
*/
void SetConversionMode( int conv )
throw (SALOME_Exception);
throw (SMESH_Exception);
/*!
* \brief Returns conversion mode
*
* Throws SALOME_Exception if distribution type is not functional
* Throws SMESH_Exception if distribution type is not functional
*/
int ConversionMode() const
throw (SALOME_Exception);
throw (SMESH_Exception);
void SetReversedEdges( std::vector<int>& ids);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
/*!
* \brief Initialize number of segments by the mesh built on the geometry
@@ -177,7 +171,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
@@ -195,8 +189,6 @@ protected:
std::vector<double> _table, _distr; //!< the table for DT_TabFunc, a sequence of pairs of numbers
std::string _func; //!< the expression of the function for DT_ExprFunc
int _convMode; //!< flag of conversion mode: 0=exponent, 1=cut negative
std::vector<int> _edgeIDs; //!< list of reversed edges ids
std::string _objEntry; //!< Entry of the main object to reverse edges
};
#endif

10
src/3rdParty/salomesmesh/inc/StdMeshers_Penta_3D.hxx vendored
View File

@@ -45,7 +45,6 @@
#include "SMESH_Block.hxx"
#include "SMESH_ComputeError.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_3D_Algo.hxx"
typedef std::map< double, std::vector<const SMDS_MeshNode*> > StdMeshers_IJNodeMap;
@@ -205,9 +204,6 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
// The key of theIJNodes map is a normalized parameter of each
// 0-the node on theBaseEdge.
bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
protected: // methods
@@ -217,8 +213,8 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
void MakeNodes();
double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ,
const int aFaceID,
double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ,
const int aFaceID,
std::vector<const SMDS_MeshNode*>*& aCol1,
std::vector<const SMDS_MeshNode*>*& aCol2);
@@ -266,7 +262,7 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
std::map < int, int > myConnectingMap;
//
std::vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
std::vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
std::vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
bool myCreateQuadratic;
SMESH_MesherHelper* myTool; // tool building quadratic elements

3
src/3rdParty/salomesmesh/inc/StdMeshers_Prism_3D.hxx vendored
View File

@@ -379,9 +379,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
/*!
* \brief Enable removal of quadrangles from the bottom face and
* triangles creation there by projection from the top

9
src/3rdParty/salomesmesh/inc/StdMeshers_ProjectionSource1D.hxx vendored
View File

@@ -23,6 +23,7 @@
// File : StdMeshers_ProjectionSource1D.hxx
// Author : Edward AGAPOV
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_ProjectionSource1D.hxx,v 1.2.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_ProjectionSource1D_HXX_
#define _SMESH_ProjectionSource1D_HXX_
@@ -30,7 +31,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <TopoDS_Vertex.hxx>
@@ -56,7 +57,7 @@ public:
* Sets source <edge> to take a mesh pattern from
*/
void SetSourceEdge(const TopoDS_Shape& edge)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* Returns the source edge or a group containing edges
@@ -85,7 +86,7 @@ public:
*/
void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
const TopoDS_Shape& targetVertex)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* Returns the vertex associated with the target vertex.
@@ -136,7 +137,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

13
src/3rdParty/salomesmesh/inc/StdMeshers_ProjectionSource2D.hxx vendored
View File

@@ -23,14 +23,15 @@
// File : StdMeshers_ProjectionSource2D.hxx
// Author : Edward AGAPOV
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_ProjectionSource2D.hxx,v 1.2.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _SMESH_ProjectionSource2D_HXX_
#define _SMESH_ProjectionSource2D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <TopoDS_Vertex.hxx>
@@ -56,7 +57,7 @@ public:
* Sets a source <face> to take a mesh pattern from
*/
void SetSourceFace(const TopoDS_Shape& face)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* Returns the source face or a group containing faces
@@ -88,21 +89,21 @@ public:
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
TopoDS_Vertex GetSourceVertex(int i) const throw ( SMESH_Exception );
/*!
* Returns the <i>-th target vertex associated with the <i>-th source vertex.
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
TopoDS_Vertex GetTargetVertex(int i) const throw ( SMESH_Exception );
/*!
* \brief Test if vertex association defined

15
src/3rdParty/salomesmesh/inc/StdMeshers_ProjectionSource3D.hxx vendored
View File

@@ -23,14 +23,15 @@
// File : StdMeshers_ProjectionSource3D.hxx
// Author : Edward AGAPOV
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_ProjectionSource3D.hxx,v 1.2.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_ProjectionSource3D_HXX_
#define _SMESH_ProjectionSource3D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <TopoDS_Vertex.hxx>
@@ -56,7 +57,7 @@ public:
* Sets a source <shape> to take a mesh pattern from
*/
void SetSource3DShape(const TopoDS_Shape& shape)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* Returns the source shape
@@ -82,19 +83,19 @@ public:
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2)
throw ( SALOME_Exception );
throw ( SMESH_Exception );
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
* Result may be nil if association not set.
*/
TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
TopoDS_Vertex GetSourceVertex(int i) const throw ( SMESH_Exception );
/*!
* Returns the <i>-th target vertex associated with the <i>-th source vertex.
* Result may be nil if association not set.
*/
TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
TopoDS_Vertex GetTargetVertex(int i) const throw ( SMESH_Exception );
/*!
* \brief Test if vertex association defined
@@ -138,7 +139,7 @@ public:
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

8
src/3rdParty/salomesmesh/inc/StdMeshers_ProjectionUtils.hxx vendored
View File

@@ -81,10 +81,10 @@ class StdMeshers_ProjectionUtils
* \param edges2 - out list of edges of face 2
* \retval int - nb of edges in an outer wire in a success case, else zero
*/
static int FindFaceAssociation(const TopoDS_Face& face1,
TopoDS_Vertex VV1[2],
const TopoDS_Face& face2,
TopoDS_Vertex VV2[2],
static int FindFaceAssociation(const TopoDS_Face& face1,
TopoDS_Vertex VV1[2],
const TopoDS_Face& face2,
TopoDS_Vertex VV2[2],
std::list< TopoDS_Edge > & edges1,
std::list< TopoDS_Edge > & edges2);

3
src/3rdParty/salomesmesh/inc/StdMeshers_Projection_1D.hxx vendored
View File

@@ -46,9 +46,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
/*!
* \brief Sets a default event listener to submesh of the source edge
* \param whenSetToSubMesh - submesh where algo is set

5
src/3rdParty/salomesmesh/inc/StdMeshers_Projection_2D.hxx vendored
View File

@@ -44,9 +44,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
/*!
* \brief Sets a default event listener to submesh of the source face
* \param whenSetToSubMesh - submesh where algo is set
@@ -57,7 +54,7 @@ public:
* the whenSetToSubMesh submesh.
*/
virtual void SetEventListener(SMESH_subMesh* whenSetToSubMesh);
protected:
const StdMeshers_ProjectionSource2D* _sourceHypo;

3
src/3rdParty/salomesmesh/inc/StdMeshers_Projection_3D.hxx vendored
View File

@@ -44,9 +44,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
/*!
* \brief Sets a default event listener to submesh of the source shape
* \param whenSetToSubMesh - submesh where algo is set

2
src/3rdParty/salomesmesh/inc/StdMeshers_Propagation.hxx vendored
View File

@@ -30,7 +30,7 @@
#include "SMESH_Hypothesis.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
#include <TopoDS_Edge.hxx>

2
src/3rdParty/salomesmesh/inc/StdMeshers_QuadToTriaAdaptor.hxx vendored
View File

@@ -27,7 +27,7 @@
#define _SMESH_QuadToTriaAdaptor_HXX_
#include <SMESH_Mesh.hxx>
#include "SMESH_StdMeshers.hxx"
#include <SMESH_StdMeshers.hxx>
#include <SMDS_FaceOfNodes.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TColgp_HArray1OfVec.hxx>

80
src/3rdParty/salomesmesh/inc/StdMeshers_QuadrangleParams.hxx vendored
View File

@@ -1,80 +0,0 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : StdMeshers_QuadrangleParams.hxx
// Author : Sergey KUUL, OCC
// Module : SMESH
//
#ifndef _SMESH_QUADRANGLEPARAMS_HXX_
#define _SMESH_QUADRANGLEPARAMS_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_QuadrangleParams:
public SMESH_Hypothesis
{
public:
StdMeshers_QuadrangleParams(int hypId, int studyId, SMESH_Gen* gen);
virtual ~StdMeshers_QuadrangleParams();
void SetTriaVertex(int id);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
int GetTriaVertex() const { return _triaVertexID; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream& operator << (std::ostream & save,
StdMeshers_QuadrangleParams & hyp);
friend std::istream& operator >> (std::istream & load,
StdMeshers_QuadrangleParams & hyp);
/*!
* \brief Initialize start and end length by the mesh built on the geometry
* \param theMesh - the built mesh
* \param theShape - the geometry of interest
* \retval bool - true if parameter values have been successfully defined
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh,
const TopoDS_Shape& theShape);
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
virtual bool SetParametersByDefaults(const TDefaults& dflts,
const SMESH_Mesh* theMesh=0);
protected:
int _triaVertexID;
std::string _objEntry;
};
#endif

7
src/3rdParty/salomesmesh/inc/StdMeshers_QuadranglePreference.hxx vendored
View File

@@ -22,14 +22,15 @@
// SMESH StdMeshers : implementaion of SMESH idl descriptions
// File : StdMeshers_QuadranglePreference.hxx
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_QuadranglePreference.hxx,v 1.4.2.1 2008/11/27 13:03:49 abd Exp $
//
#ifndef _StdMeshers_QuadranglePreference_HXX_
#define _StdMeshers_QuadranglePreference_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
/*!
* \brief Hypothesis for StdMeshers_Quadrangle_2D, forcing construction
@@ -58,7 +59,7 @@ class STDMESHERS_EXPORT StdMeshers_QuadranglePreference:public SMESH_Hypothesis
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

26
src/3rdParty/salomesmesh/inc/StdMeshers_Quadrangle_2D.hxx vendored
View File

@@ -24,7 +24,7 @@
// Moved here from SMESH_Quadrangle_2D.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header$
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_Quadrangle_2D.hxx,v 1.12.2.4 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_QUADRANGLE_2D_HXX_
#define _SMESH_QUADRANGLE_2D_HXX_
@@ -32,7 +32,7 @@
#include "SMESH_StdMeshers.hxx"
#include "SMESH_2D_Algo.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
class SMESH_Mesh;
class SMESH_MesherHelper;
@@ -40,7 +40,6 @@ class StdMeshers_FaceSide;
class SMDS_MeshNode;
struct uvPtStruct;
enum TSideID { BOTTOM_SIDE=0, RIGHT_SIDE, TOP_SIDE, LEFT_SIDE, NB_SIDES };
typedef uvPtStruct UVPtStruct;
@@ -65,9 +64,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
FaceQuadStruct* CheckAnd2Dcompute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
const bool CreateQuadratic);
@@ -77,12 +73,6 @@ protected:
FaceQuadStruct* CheckNbEdges(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape);
bool CheckNbEdgesForEvaluate(SMESH_Mesh& aMesh,
const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap,
std::vector<int>& aNbNodes,
bool& IsQuadratic);
bool SetNormalizedGrid(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
FaceQuadStruct*& quad);
@@ -101,12 +91,6 @@ protected:
const TopoDS_Shape& aShape,
FaceQuadStruct* quad);
bool EvaluateQuadPref(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
std::vector<int>& aNbNodes,
MapShapeNbElems& aResMap,
bool IsQuadratic);
UVPtStruct* LoadEdgePoints2(SMESH_Mesh& aMesh,
const TopoDS_Face& F, const TopoDS_Edge& E,
bool IsReverse);
@@ -121,14 +105,12 @@ protected:
// true if QuadranglePreference hypothesis is assigned that forces
// construction of quadrangles if the number of nodes on opposite edges
// is not the same in the case where the global number of nodes on edges
// is even
// is not the same in the case where the global number of nodes on edges is even
bool myQuadranglePreference;
bool myTrianglePreference;
int myTriaVertexID;
SMESH_MesherHelper* myTool; // tool for working with quadratic elements
};

7
src/3rdParty/salomesmesh/inc/StdMeshers_QuadraticMesh.hxx vendored
View File

@@ -22,14 +22,15 @@
// SMESH StdMeshers : implementaion of SMESH idl descriptions
// File : StdMeshers_QuadraticMesh.hxx
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_QuadraticMesh.hxx,v 1.4.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _StdMeshers_QuadraticMesh_HXX_
#define _StdMeshers_QuadraticMesh_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
/*!
* \brief Hypothesis for StdMeshers_Regular_1D, forcing construction of quadratic edges.
@@ -60,7 +61,7 @@ class STDMESHERS_EXPORT StdMeshers_QuadraticMesh:public SMESH_Hypothesis
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

3
src/3rdParty/salomesmesh/inc/StdMeshers_RadialPrism_3D.hxx vendored
View File

@@ -51,9 +51,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
protected:
typedef std::vector<const SMDS_MeshNode* > TNodeColumn;

76
src/3rdParty/salomesmesh/inc/StdMeshers_RadialQuadrangle_1D2D.hxx vendored
View File

@@ -1,76 +0,0 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : StdMeshers_RadialQuadrangle_1D2D.hxx
// Module : SMESH
//
#ifndef _SMESH_RadialQuadrangle_1D2D_HXX_
#define _SMESH_RadialQuadrangle_1D2D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_2D_Algo.hxx"
//#include "SMDS_MeshNode.hxx"
//#include <vector>
//#include <map>
class StdMeshers_NumberOfLayers;
class StdMeshers_LayerDistribution;
class SMESH_MesherHelper;
class gp_Pnt;
class STDMESHERS_EXPORT StdMeshers_RadialQuadrangle_1D2D: public SMESH_2D_Algo
{
public:
StdMeshers_RadialQuadrangle_1D2D(int hypId, int studyId, SMESH_Gen* gen);
virtual ~StdMeshers_RadialQuadrangle_1D2D();
virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
/*!
* \brief Allow algo to do something after persistent restoration
* \param subMesh - restored submesh
*
* This method is called only if a submesh has HYP_OK algo_state.
*/
virtual void SubmeshRestored(SMESH_subMesh* subMesh);
protected:
bool computeLayerPositions(const gp_Pnt& pIn,
const gp_Pnt& pOut);
const StdMeshers_NumberOfLayers* myNbLayerHypo;
const StdMeshers_LayerDistribution* myDistributionHypo;
SMESH_MesherHelper* myHelper;
std::vector< double > myLayerPositions;
};
#endif

10
src/3rdParty/salomesmesh/inc/StdMeshers_Regular_1D.hxx vendored
View File

@@ -32,8 +32,6 @@
#include "SMESH_1D_Algo.hxx"
#include "StdMeshers_FixedPoints1D.hxx"
class Adaptor3d_Curve;
class TopoDS_Vertex;
class StdMeshers_SegmentLengthAroundVertex;
@@ -51,9 +49,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
virtual const std::list <const SMESHDS_Hypothesis *> &
GetUsedHypothesis(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, const bool=true);
@@ -99,7 +94,7 @@ protected:
StdMeshers_SegmentLengthAroundVertex* getVertexHyp(SMESH_Mesh & theMesh,
const TopoDS_Vertex & theV);
enum HypothesisType { LOCAL_LENGTH, MAX_LENGTH, NB_SEGMENTS, BEG_END_LENGTH, DEFLECTION, ARITHMETIC_1D, FIXED_POINTS_1D, NONE };
enum HypothesisType { LOCAL_LENGTH, MAX_LENGTH, NB_SEGMENTS, BEG_END_LENGTH, DEFLECTION, ARITHMETIC_1D, NONE };
enum ValueIndex {
SCALE_FACTOR_IND = 0,
@@ -125,13 +120,10 @@ protected:
HypothesisType _hypType;
const StdMeshers_FixedPoints1D* _fpHyp;
double _value[2];
int _ivalue[3];
std::vector<double> _vvalue[1];
std::string _svalue[1];
std::vector<int> _revEdgesIDs;
// a source of propagated hypothesis, is set by CheckHypothesis()
// always called before Compute()

2
src/3rdParty/salomesmesh/inc/StdMeshers_SegmentAroundVertex_0D.hxx vendored
View File

@@ -46,8 +46,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
};
#endif

9
src/3rdParty/salomesmesh/inc/StdMeshers_SegmentLengthAroundVertex.hxx vendored
View File

@@ -23,14 +23,15 @@
// File : StdMeshers_SegmentLengthAroundVertex.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_SegmentLengthAroundVertex.hxx,v 1.2.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _SMESH_SegmentLengthAroundVertex_HXX_
#define _SMESH_SegmentLengthAroundVertex_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
/*!
* \brief This hypothesis specifies length of segments adjacent to the vertex the
@@ -42,7 +43,7 @@ class STDMESHERS_EXPORT StdMeshers_SegmentLengthAroundVertex:public SMESH_Hypoth
StdMeshers_SegmentLengthAroundVertex(int hypId, int studyId, SMESH_Gen * gen);
virtual ~ StdMeshers_SegmentLengthAroundVertex();
void SetLength(double length) throw(SALOME_Exception);
void SetLength(double length) throw(SMESH_Exception);
double GetLength() const;
@@ -59,7 +60,7 @@ class STDMESHERS_EXPORT StdMeshers_SegmentLengthAroundVertex:public SMESH_Hypoth
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

21
src/3rdParty/salomesmesh/inc/StdMeshers_StartEndLength.hxx vendored
View File

@@ -22,16 +22,15 @@
// SMESH StdMeshers : implementaion of SMESH idl descriptions
// File : StdMeshers_StartEndLength.hxx
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/StdMeshers_StartEndLength.hxx,v 1.7.2.1 2008/11/27 13:03:50 abd Exp $
//
#ifndef _STDMESHERS_STARTENDLENGTH_HXX_
#define _STDMESHERS_STARTENDLENGTH_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
#include "SMESH_Exception.hxx"
class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
{
@@ -39,17 +38,9 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
StdMeshers_StartEndLength(int hypId, int studyId, SMESH_Gen * gen);
virtual ~ StdMeshers_StartEndLength();
void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
void SetLength(double length, bool isStartLength) throw(SMESH_Exception);
double GetLength(bool isStartLength) const;
void SetReversedEdges( std::vector<int>& ids);
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
@@ -65,7 +56,7 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
@@ -73,8 +64,6 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
protected:
double _begLength, _endLength;
std::vector<int> _edgeIDs;
std::string _objEntry;
};
#endif

7
src/3rdParty/salomesmesh/inc/StdMeshers_TrianglePreference.hxx vendored
View File

@@ -22,14 +22,15 @@
// SMESH StdMeshers : implementaion of SMESH idl descriptions
// File : StdMeshers_TrianglePreference.hxx
// Module : SMESH
// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/StdMeshers/Attic/StdMeshers_TrianglePreference.hxx,v 1.1.4.2 2008/11/27 13:03:50 abd Exp $
//
#ifndef _StdMeshers_TrianglePreference_HXX_
#define _StdMeshers_TrianglePreference_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Exception.hxx"
/*!
* \brief Hypothesis for StdMeshers_Quadrangle_2D, forcing construction
@@ -57,7 +58,7 @@ class STDMESHERS_EXPORT StdMeshers_TrianglePreference:public SMESH_Hypothesis
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
/*!
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/

4
src/3rdParty/salomesmesh/inc/StdMeshers_UseExisting_1D2D.hxx vendored
View File

@@ -46,8 +46,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
};
class STDMESHERS_EXPORT StdMeshers_UseExisting_1D: public SMESH_1D_Algo
@@ -61,8 +59,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
};
#endif

7
src/3rdParty/salomesmesh/inc/Utils_ExceptHandlers.hxx vendored
View File

@@ -1,7 +0,0 @@
#ifndef _Utils_ExceptHandlers_HXX_
#define _Utils_ExceptHandlers_HXX_
#include <SMESH_ExceptHandlers.hxx>
#define SalomeException SmeshException
#endif

Some files were not shown because too many files have changed in this diff Show More