ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 18:20:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Porting on Mandriva 64

Browse Source
This commit is contained in:
apo 2006-04-06 08:36:23 +00:00
parent d922b42d34
commit 3d9cb959df
27 changed files with 597 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
adm_local/unix/make_commence.in
View File

@ -244,17 +244,31 @@ $(top_srcdir)/configure.in: $(top_srcdir)/configure.in.base
ACLOCAL_SRC = \ ACLOCAL_SRC = \
ac_cxx_bool.m4 check_corba.m4 \ ac_cxx_bool.m4 \
ac_cxx_depend_flag.m4 check_hdf5.m4 enable_pthreads.m4 \ check_corba.m4 \
ac_cxx_mutable.m4 check_mico.m4 libtool.m4 \ ac_cxx_depend_flag.m4 \
ac_cxx_namespaces.m4 check_omniorb.m4 pyembed.m4 \ check_hdf5.m4 \
ac_cxx_partial_specialization.m4 python.m4 \ enable_pthreads.m4 \
ac_cxx_typename.m4 check_pthreads.m4 check_cas.m4 \ ac_cxx_mutable.m4 \
ac_cc_warnings.m4 check_boost.m4 check_swig.m4 check_mico.m4 \
ac_cxx_namespaces.m4 \
check_omniorb.m4 \
pyembed.m4 \
ac_cxx_partial_specialization.m4 \
python.m4 \
ac_cxx_typename.m4 \
check_pthreads.m4 \
check_cas.m4 \
ac_cc_warnings.m4 \
check_boost.m4 \
check_swig.m4
ACLOCAL_GUI = \ ACLOCAL_GUI = \
check_vtk.m4 check_opengl.m4 check_qt.m4 \ check_vtk.m4 \
check_GUI.m4 check_corba_in_GUI.m4 check_opengl.m4 \
check_qt.m4 \
check_GUI.m4 \
check_corba_in_GUI.m4
ACLOCAL_MED = check_Med.m4 ACLOCAL_MED = check_Med.m4
ACLOCAL_GEOM = check_GEOM.m4 ACLOCAL_GEOM = check_GEOM.m4

107
adm_local/unix/make_conclude.in
View File

@ -35,39 +35,21 @@ LIB_OBJ_F = $(patsubst %.f, %.lo, $(filter %.f, $(LIB_SRC)))
# all libtool obj file in library # all libtool obj file in library
LIB_OBJ = $(LIB_OBJ_CXX) $(LIB_OBJ_CC) $(LIB_OBJ_C) $(LIB_CLIENT_OBJ:%.o=%.lo) $(LIB_SERVER_OBJ:%.o=%.lo) $(LIB_SWIG_OBJ) $(LIB_OBJ_F) LIB_OBJ = $(LIB_OBJ_CXX) $(LIB_OBJ_CC) $(LIB_OBJ_C) $(LIB_CLIENT_OBJ:%.o=%.lo) $(LIB_SERVER_OBJ:%.o=%.lo) $(LIB_SWIG_OBJ) $(LIB_OBJ_F)
# LIB_BUILD = $(LIB:%.la=$(top_builddir)/lib/salome/%.la)
LIB_BUILD = $(patsubst %.la, $(top_builddir)/lib/salome/%.la, $(filter %.la, $(LIB)))
LIB_BUILD_A = $(patsubst %.a, $(top_builddir)/lib/salome/%.a, $(filter %.a, $(LIB)))
ifneq ($(findstring cmodule.la,$(filter %.la, $(LIB))),) ifneq ($(findstring cmodule.la,$(filter %.la, $(LIB))),)
LIB_SWIG = $(patsubst %cmodule.la,%.so, $(filter %.la, $(LIB))) LIB_SWIG = $(patsubst %cmodule.la,%.so, $(filter %.la, $(LIB)))
else else
LIB_SWIG = LIB_SWIG =
endif endif
lib: $(LIB_BUILD) $(LIB_CLIENT_PY) lib: $(LIB) $(LIB_CLIENT_PY)
# we don't build static library ! # we don't build static library !
$(LIB_BUILD): $(top_builddir)/lib/salome/%.la: %.la LIB_BUILDDIR=$(shell cd $(CURDIR)/$(top_builddir); pwd)/lib/salome
-$(RM) $@
-$(RM) $(patsubst %.la, %.so, $@)
-$(RM) $(patsubst %.la, %.a, $@)
ln -sf $(CURDIR)/$< $@ || true
ln -sf $(patsubst %.la, %.so, $(CURDIR)/.libs/$<) \
$(patsubst %.la, %.so, $@) || true
ln -sf $(patsubst %.la, %.so, $(CURDIR)/.libs/$<).0 \
$(patsubst %.la, %.so, $@).0 || true
if ! test -z $(LIB_SWIG) ; then \
ln -sf $(patsubst %.la,%.so, $(CURDIR)/.libs/$<) $(top_builddir)/lib/salome/_$(LIB_SWIG) || true;\
fi;
$(LIB_BUILD_A): $(top_builddir)/lib/salome/%.a: %.a
-$(RM) $@
ln -sf $(CURDIR)/$< $@ || true
$(LIB): $(LIB_OBJ) $(LIB): $(LIB_OBJ)
@$(LT) --mode=link $(CXX) -rpath $(libdir) -o $@ $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) $(LT) --mode=uninstall $(RM) $(LIB_BUILDDIR)/$@
$(LT) --mode=link $(CXX) -shared -rpath $(LIB_BUILDDIR) -o $@ $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS)
$(LT_INSTALL_LIB) $@ $(LIB_BUILDDIR)/$@
# transform idl reference in appropriate obj file # transform idl reference in appropriate obj file
BIN_CLIENT_SRC = $(BIN_CLIENT_IDL:%.idl=%$(IDL_CLN_CXX)) BIN_CLIENT_SRC = $(BIN_CLIENT_IDL:%.idl=%$(IDL_CLN_CXX))
@ -79,23 +61,23 @@ BIN_DEP=$(BIN:%=%.cxx) $(BIN_SRC) $(BIN_CLIENT_SRC) $(BIN_SERVER_SRC)
BIN_CLIENT_OBJ = $(BIN_CLIENT_IDL:%.idl=%$(IDL_CLN_OBJ)) BIN_CLIENT_OBJ = $(BIN_CLIENT_IDL:%.idl=%$(IDL_CLN_OBJ))
BIN_SERVER_OBJ = $(BIN_SERVER_IDL:%.idl=%$(IDL_SRV_OBJ)) BIN_SERVER_OBJ = $(BIN_SERVER_IDL:%.idl=%$(IDL_SRV_OBJ))
# transform c file in appropriate libtool obj file (.c) # transform c file in appropriate libtool obj file (.c)
BIN_OBJ_C = $(patsubst %.c, %.o, $(filter %.c, $(BIN_SRC))) BIN_OBJ_C = $(patsubst %.c, %.lo, $(filter %.c, $(BIN_SRC)))
# transform c++ file in appropriate libtool obj file (.cc and .cxx) # transform c++ file in appropriate libtool obj file (.cc and .cxx)
BIN_OBJ_CC = $(patsubst %.cc, %.o, $(filter %.cc, $(BIN_SRC))) BIN_OBJ_CC = $(patsubst %.cc, %.lo, $(filter %.cc, $(BIN_SRC)))
BIN_OBJ_CXX = $(patsubst %.cxx, %.o, $(filter %.cxx, $(BIN_SRC))) BIN_OBJ_CXX = $(patsubst %.cxx, %.lo, $(filter %.cxx, $(BIN_SRC)))
# all obj file in bin target # all obj file in bin target
BIN_OBJ = $(BIN_OBJ_CC) $(BIN_OBJ_CXX) $(BIN_OBJ_C) $(BIN_CLIENT_OBJ) $(BIN_SERVER_OBJ) BIN_OBJ = $(BIN_OBJ_CC) $(BIN_OBJ_CXX) $(BIN_OBJ_C) $(BIN_CLIENT_OBJ) $(BIN_SERVER_OBJ)
bin: $(BIN:%=$(top_builddir)/bin/salome/%) $(BIN) $(LIB) pyscripts sharedpyscripts bin: $(BIN) pyscripts sharedpyscripts
BIN_LIB=$(LIB:lib%.la=-l%) BIN_LIB=$(LIB:lib%.la=-l%)
$(BIN:%=$(top_builddir)/bin/salome/%) $(TEST_PROGS:%=$(top_builddir)/bin/salome/%): $(top_builddir)/bin/salome/%: % BIN_BUILDDIR=$(shell cd $(CURDIR)/$(top_builddir); pwd)/bin/salome
-$(RM) $@
ln -sf $(CURDIR)/$< $@
$(BIN) $(TEST_PROGS): %: %.lo $(BIN_OBJ) $(BIN) $(TEST_PROGS): %: %.lo $(BIN_OBJ) $(LIB)
$(CXX) $(CXXFLAGS) -o $@ $^ $(BIN_LIB) $(LDFLAGSFORBIN) $(LIBSFORBIN) $(LT) --mode=uninstall $(RM) $(BIN_BUILDDIR)/$@
$(LT) --mode=link $(CXX) -rpath $(BIN_BUILDDIR) -o $@ $^ $(CXXFLAGS) $(CPPFLAGS) $(BIN_LIB) $(LDFLAGSFORBIN) $(LIBSFORBIN)
$(LT_INSTALL_PROG) $@ $(BIN_BUILDDIR)/$@
# copy python scripts in $(top_builddir)/bin/salome # copy python scripts in $(top_builddir)/bin/salome
# #
@ -139,30 +121,39 @@ $(libdir) $(includedir) $(bindir) $(datadir) $(idldir) $(sharedpydir):
# Install the library, the public header files, and programs. # Install the library, the public header files, and programs.
install: $(LIB) $(BIN) $(TEST_PROGS) $(libdir) $(includedir) $(bindir) $(datadir) $(idldir) install-python install-sharedpyqt install-qm install: $(LIB) $(BIN) $(TEST_PROGS) $(libdir) $(includedir) $(bindir) $(datadir) $(idldir) install-python install-sharedpyqt install-qm
@for f in X $(LIB); do \ @for f in X $(LIB); do \
if test $$f != X; then \ if test $$f != X; then \
($(LT_INSTALL_LIB) $$f $(libdir)/. || exit 1); \ echo "($(LT) --mode=link $(CXX) -shared -rpath '$(libdir)' -o '$$f' $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) || exit 1)"; \
fi; \ ($(LT) --mode=link $(CXX) -shared -rpath "$(libdir)" -o "$$f" $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) || exit 1); \
echo "($(LT_INSTALL_LIB) '$$f' '$(libdir)/$$f' || exit 1)"; \
($(LT_INSTALL_LIB) "$$f" "$(libdir)/$$f" || exit 1); \
fi; \
done done
@if ! test -z $(LIB_SWIG) ; then \ @if ! test -z $(LIB_SWIG) ; then \
(cd $(libdir); ln -sf $(patsubst %.so, %cmodule.so, $(LIB_SWIG)) _$(LIB_SWIG) || true); \ (cd $(libdir); ln -sf $(patsubst %.so, %cmodule.so, $(LIB_SWIG)) _$(LIB_SWIG) || true); \
fi; fi;
@for f in X $(BIN); do \ @for f in X $(BIN); do \
if test $$f != X; then \ if test $$f != X; then \
($(LT_INSTALL_PROG) $$f $(bindir)/. || exit 1); \ echo "($(LT) --mode=link $(CXX) -shared -rpath '$(bindir)' -o '$$f' $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) || exit 1)"; \
fi; \ ($(LT) --mode=link $(CXX) -shared -rpath "$(bindir)" -o "$$f" $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) || exit 1); \
echo "($(LT_INSTALL_PROG) '$$f' '$(bindir)/$$f' || exit 1)"; \
($(LT_INSTALL_PROG) "$$f" "$(bindir)/$$f" || exit 1); \
fi; \
done done
# Install tests programmes in bindir # Install tests programmes in bindir
@for f in X $(TEST_PROGS); do \ @for f in X $(TEST_PROGS); do \
if test $$f != X; then \ if test $$f != X; then \
($(LT_INSTALL_PROG) $$f $(bindir)/. || exit 1); \ echo "($(LT) --mode=link $(CXX) -shared -rpath '$(bindir)' -o '$$f' $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) || exit 1)"; \
fi; \ ($(LT) --mode=link $(CXX) -shared -rpath "$(bindir)" -o "$$f" $(CXXFLAGS) $(LIB_OBJ) $(LDFLAGS) $(LIBS) || exit 1); \
echo "($(LT_INSTALL_PROG) '$$f' '$(bindir)/$$f' || exit 1)"; \
($(LT_INSTALL_PROG) "$$f" "$(bindir)/$$f" || exit 1); \
fi; \
done done
# Install exported includes in includedir # Install exported includes in includedir
@for f in X $(EXPORT_HEADERS:%=$(srcdir)/%); do \ @for f in X $(EXPORT_HEADERS:%=$(srcdir)/%); do \
if test $$f != X; then \ if test $$f != X; then \
(cp -p -f $$f $(includedir) || exit 1); \ (cp -p -f $$f $(includedir) || exit 1); \
fi; \ fi; \
done done
# Install python script in $(bindir) # Install python script in $(bindir)
@ -293,25 +284,31 @@ distclean: clean
$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
.cc.lo: .cc.lo:
$(LT) --mode=compile $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< $(LT) --mode=compile --tag=CXX $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
.cxx.o: .cxx.o:
$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
.cxx.lo: .cxx.lo:
$(LT) --mode=compile $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< $(LT) --mode=compile --tag=CXX $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
.c.o: .c.o:
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< $(CC) $(CFLAGS) $(CPPFLAGS) -c $<
.c.lo: .c.lo:
$(LT_COMPILE) $(CFLAGS) $(CPPFLAGS) -c $< $(LT) --mode=compile --tag=CC $(CFLAGS) $(CPPFLAGS) -c $<
.f.o: .f.o:
$(FC) $(FFLAGS) -c $< -o $@ $(FC) $(FFLAGS) -c $< -o $@
.f.lo: .f.lo:
$(LT) --mode=compile $(FC) $(FFLAGS) -c $< $(LT) --mode=compile --tag=F77 $(FC) $(FFLAGS) -c $<
.f90.o:
$(FC) $(FFLAGS) -c $< -o $@
.f90.lo:
$(LT) --mode=compile --tag=F90 $(FC) $(FFLAGS) -c $<
.ui.h: .ui.h:
$(UIC) -o $@ $< $(UIC) -o $@ $<

98
src/OBJECT/SMESH_Actor.cxx
View File

@ -122,15 +122,15 @@ SMESH_ActorDef::SMESH_ActorDef()
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) ) if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = (long)SMESH::GetFloat( "SMESH", "controls_precision", -1 ); myControlsPrecision = (long)SMESH::GetFloat( "SMESH", "controls_precision", -1 );
float aPointSize = SMESH::GetFloat("SMESH:node_size",3); vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3);
float aLineWidth = SMESH::GetFloat("SMESH:element_width",1); vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
VTKViewer_ExtractUnstructuredGrid* aFilter = NULL; VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
//Definition 2D and 3D divices of the actor //Definition 2D and 3D divices of the actor
//----------------------------------------- //-----------------------------------------
float anRGB[3] = {1,1,1}; vtkFloatingPointType anRGB[3] = {1,1,1};
mySurfaceProp = vtkProperty::New(); mySurfaceProp = vtkProperty::New();
SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
mySurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); mySurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
@ -748,7 +748,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
my2DActor->GetMapper()->SetLookupTable(myLookupTable); my2DActor->GetMapper()->SetLookupTable(myLookupTable);
my3DActor->GetMapper()->SetLookupTable(myLookupTable); my3DActor->GetMapper()->SetLookupTable(myLookupTable);
float aFactor, aUnits; vtkFloatingPointType aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
@ -782,7 +782,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
} }
float* SMESH_ActorDef::GetBounds(){ vtkFloatingPointType* SMESH_ActorDef::GetBounds(){
return myNodeActor->GetBounds(); return myNodeActor->GetBounds();
} }
@ -847,11 +847,11 @@ void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
Modified(); Modified();
} }
float SMESH_ActorDef::GetShrinkFactor(){ vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){
return myBaseActor->GetShrinkFactor(); return myBaseActor->GetShrinkFactor();
} }
void SMESH_ActorDef::SetShrinkFactor(float theValue){ void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){
myBaseActor->SetShrinkFactor(theValue); myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue); my1DActor->SetShrinkFactor(theValue);
@ -898,7 +898,7 @@ int SMESH_ActorDef::GetNodeObjId(int theVtkID){
return myPickableActor->GetNodeObjId(theVtkID); return myPickableActor->GetNodeObjId(theVtkID);
} }
float* SMESH_ActorDef::GetNodeCoord(int theObjID){ vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){
return myPickableActor->GetNodeCoord(theObjID); return myPickableActor->GetNodeCoord(theObjID);
} }
@ -1269,15 +1269,15 @@ void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){
} }
static void GetColor(vtkProperty *theProperty, float& r,float& g,float& b){ static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
float* aColor = theProperty->GetColor(); vtkFloatingPointType* aColor = theProperty->GetColor();
r = aColor[0]; r = aColor[0];
g = aColor[1]; g = aColor[1];
b = aColor[2]; b = aColor[2];
} }
void SMESH_ActorDef::SetOpacity(float theValue){ void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
mySurfaceProp->SetOpacity(theValue); mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue); myBackSurfaceProp->SetOpacity(theValue);
myEdgeProp->SetOpacity(theValue); myEdgeProp->SetOpacity(theValue);
@ -1287,74 +1287,74 @@ void SMESH_ActorDef::SetOpacity(float theValue){
} }
float SMESH_ActorDef::GetOpacity(){ vtkFloatingPointType SMESH_ActorDef::GetOpacity(){
return mySurfaceProp->GetOpacity(); return mySurfaceProp->GetOpacity();
} }
void SMESH_ActorDef::SetSufaceColor(float r,float g,float b){ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
mySurfaceProp->SetColor(r,g,b); mySurfaceProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetSufaceColor(float& r,float& g,float& b){ void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
::GetColor(mySurfaceProp,r,g,b); ::GetColor(mySurfaceProp,r,g,b);
} }
void SMESH_ActorDef::SetBackSufaceColor(float r,float g,float b){ void SMESH_ActorDef::SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myBackSurfaceProp->SetColor(r,g,b); myBackSurfaceProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetBackSufaceColor(float& r,float& g,float& b){ void SMESH_ActorDef::GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
::GetColor(myBackSurfaceProp,r,g,b); ::GetColor(myBackSurfaceProp,r,g,b);
} }
void SMESH_ActorDef::SetEdgeColor(float r,float g,float b){ void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myEdgeProp->SetColor(r,g,b); myEdgeProp->SetColor(r,g,b);
my1DProp->SetColor(r,g,b); my1DProp->SetColor(r,g,b);
my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b); my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetEdgeColor(float& r,float& g,float& b){ void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
::GetColor(myEdgeProp,r,g,b); ::GetColor(myEdgeProp,r,g,b);
} }
void SMESH_ActorDef::SetNodeColor(float r,float g,float b){ void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myNodeProp->SetColor(r,g,b); myNodeProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetNodeColor(float& r,float& g,float& b){ void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
::GetColor(myNodeProp,r,g,b); ::GetColor(myNodeProp,r,g,b);
} }
void SMESH_ActorDef::SetHighlightColor(float r,float g,float b){ void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myHighlightProp->SetColor(r,g,b); myHighlightProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetHighlightColor(float& r,float& g,float& b){ void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
::GetColor(myHighlightProp,r,g,b); ::GetColor(myHighlightProp,r,g,b);
} }
void SMESH_ActorDef::SetPreHighlightColor(float r,float g,float b){ void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myPreselectProp->SetColor(r,g,b); myPreselectProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetPreHighlightColor(float& r,float& g,float& b){ void SMESH_ActorDef::GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
::GetColor(myPreselectProp,r,g,b); ::GetColor(myPreselectProp,r,g,b);
} }
float SMESH_ActorDef::GetLineWidth(){ vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){
return myEdgeProp->GetLineWidth(); return myEdgeProp->GetLineWidth();
} }
void SMESH_ActorDef::SetLineWidth(float theVal){ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
myEdgeProp->SetLineWidth(theVal); myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc); my1DProp->SetLineWidth(theVal + aLineWidthInc);
@ -1364,7 +1364,7 @@ void SMESH_ActorDef::SetLineWidth(float theVal){
} }
void SMESH_ActorDef::SetNodeSize(float theVal){ void SMESH_ActorDef::SetNodeSize(vtkFloatingPointType theVal){
myNodeProp->SetPointSize(theVal); myNodeProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal); myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal); myPreselectProp->SetPointSize(theVal);
@ -1375,7 +1375,7 @@ void SMESH_ActorDef::SetNodeSize(float theVal){
Modified(); Modified();
} }
float SMESH_ActorDef::GetNodeSize(){ vtkFloatingPointType SMESH_ActorDef::GetNodeSize(){
return myNodeProp->GetPointSize(); return myNodeProp->GetPointSize();
} }
@ -1448,21 +1448,21 @@ GetClippingPlane(vtkIdType theID)
static void ComputeBoundsParam(vtkDataSet* theDataSet, static void ComputeBoundsParam(vtkDataSet* theDataSet,
float theDirection[3], float theMinPnt[3], vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3],
float& theMaxBoundPrj, float& theMinBoundPrj) vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj)
{ {
float aBounds[6]; vtkFloatingPointType aBounds[6];
theDataSet->GetBounds(aBounds); theDataSet->GetBounds(aBounds);
//Enlarge bounds in order to avoid conflicts of precision //Enlarge bounds in order to avoid conflicts of precision
for(int i = 0; i < 6; i += 2){ for(int i = 0; i < 6; i += 2){
static double EPS = 1.0E-3; static double EPS = 1.0E-3;
float aDelta = (aBounds[i+1] - aBounds[i])*EPS; vtkFloatingPointType aDelta = (aBounds[i+1] - aBounds[i])*EPS;
aBounds[i] -= aDelta; aBounds[i] -= aDelta;
aBounds[i+1] += aDelta; aBounds[i+1] += aDelta;
} }
float aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]}, vtkFloatingPointType aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]},
{aBounds[1],aBounds[2],aBounds[4]}, {aBounds[1],aBounds[2],aBounds[4]},
{aBounds[0],aBounds[3],aBounds[4]}, {aBounds[0],aBounds[3],aBounds[4]},
{aBounds[1],aBounds[3],aBounds[4]}, {aBounds[1],aBounds[3],aBounds[4]},
@ -1475,7 +1475,7 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet,
theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]); theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
theMinBoundPrj = theMaxBoundPrj; theMinBoundPrj = theMaxBoundPrj;
for(int i = 1; i < 8; i++){ for(int i = 1; i < 8; i++){
float aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]); vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
if(theMaxBoundPrj < aTmp){ if(theMaxBoundPrj < aTmp){
theMaxBoundPrj = aTmp; theMaxBoundPrj = aTmp;
aMaxId = i; aMaxId = i;
@ -1485,7 +1485,7 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet,
aMinId = i; aMinId = i;
} }
} }
float *aMinPnt = aBoundPoints[aMaxId]; vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId];
theMinPnt[0] = aMinPnt[0]; theMinPnt[0] = aMinPnt[0];
theMinPnt[1] = aMinPnt[1]; theMinPnt[1] = aMinPnt[1];
theMinPnt[2] = aMinPnt[2]; theMinPnt[2] = aMinPnt[2];
@ -1493,11 +1493,11 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet,
static void DistanceToPosition(vtkDataSet* theDataSet, static void DistanceToPosition(vtkDataSet* theDataSet,
float theDirection[3], float theDist, float thePos[3]) vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3])
{ {
float aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
float aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist; vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
thePos[0] = aMinPnt[0]-theDirection[0]*aLength; thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
thePos[1] = aMinPnt[1]-theDirection[1]*aLength; thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
thePos[2] = aMinPnt[2]-theDirection[2]*aLength; thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
@ -1505,29 +1505,29 @@ static void DistanceToPosition(vtkDataSet* theDataSet,
static void PositionToDistance(vtkDataSet* theDataSet, static void PositionToDistance(vtkDataSet* theDataSet,
float theDirection[3], float thePos[3], float& theDist) vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist)
{ {
float aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
float aPrj = vtkMath::Dot(theDirection,thePos); vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos);
theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj); theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
} }
void SMESH_ActorDef::SetPlaneParam(float theDir[3], float theDist, vtkPlane* thePlane) void SMESH_ActorDef::SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane)
{ {
thePlane->SetNormal(theDir); thePlane->SetNormal(theDir);
float anOrigin[3]; vtkFloatingPointType anOrigin[3];
::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin); ::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin);
thePlane->SetOrigin(anOrigin); thePlane->SetOrigin(anOrigin);
} }
void SMESH_ActorDef::GetPlaneParam(float theDir[3], float& theDist, vtkPlane* thePlane) void SMESH_ActorDef::GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane)
{ {
thePlane->GetNormal(theDir); thePlane->GetNormal(theDir);
float anOrigin[3]; vtkFloatingPointType anOrigin[3];
thePlane->GetOrigin(anOrigin); thePlane->GetOrigin(anOrigin);
::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist); ::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist);
} }
@ -1617,21 +1617,21 @@ void SMESH_ActorDef::UpdateScalarBar()
myScalarBarActor->SetOrientationToVertical(); myScalarBarActor->SetOrientationToVertical();
float aXVal = horiz ? 0.20 : 0.01; vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01;
if( mgr->hasValue( "SMESH", name + "x" ) ) if( mgr->hasValue( "SMESH", name + "x" ) )
aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal ); aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal );
float aYVal = horiz ? 0.01 : 0.1; vtkFloatingPointType aYVal = horiz ? 0.01 : 0.1;
if( mgr->hasValue( "SMESH", name + "y" ) ) if( mgr->hasValue( "SMESH", name + "y" ) )
aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal ); aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal );
myScalarBarActor->SetPosition( aXVal, aYVal ); myScalarBarActor->SetPosition( aXVal, aYVal );
float aWVal = horiz ? 0.60 : 0.10; vtkFloatingPointType aWVal = horiz ? 0.60 : 0.10;
if( mgr->hasValue( "SMESH", name + "width" ) ) if( mgr->hasValue( "SMESH", name + "width" ) )
aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal ); aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal );
myScalarBarActor->SetWidth( aWVal ); myScalarBarActor->SetWidth( aWVal );
float aHVal = horiz ? 0.12 : 0.80; vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80;
if( mgr->hasValue( "SMESH", name + "height" ) ) if( mgr->hasValue( "SMESH", name + "height" ) )
aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal ); aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal );
myScalarBarActor->SetHeight( aHVal ); myScalarBarActor->SetHeight( aHVal );

38
src/OBJECT/SMESH_Actor.h
View File

@ -50,29 +50,29 @@ class SMESH_Actor: public SALOME_Actor
const char* theName, const char* theName,
int theIsClear); int theIsClear);
virtual void SetSufaceColor(float r,float g,float b) = 0; virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetSufaceColor(float& r,float& g,float& b) = 0; virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetBackSufaceColor(float r,float g,float b) = 0; virtual void SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetBackSufaceColor(float& r,float& g,float& b) = 0; virtual void GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetEdgeColor(float r,float g,float b) = 0; virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetEdgeColor(float& r,float& g,float& b) = 0; virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetNodeColor(float r,float g,float b) = 0; virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetNodeColor(float& r,float& g,float& b) = 0; virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetHighlightColor(float r,float g,float b) = 0; virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetHighlightColor(float& r,float& g,float& b) = 0; virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetPreHighlightColor(float r,float g,float b) = 0; virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetPreHighlightColor(float& r,float& g,float& b) = 0; virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual float GetLineWidth() = 0; virtual vtkFloatingPointType GetLineWidth() = 0;
virtual void SetLineWidth(float theVal) = 0; virtual void SetLineWidth(vtkFloatingPointType theVal) = 0;
virtual void SetNodeSize(float size) = 0; virtual void SetNodeSize(vtkFloatingPointType size) = 0;
virtual float GetNodeSize() = 0; virtual vtkFloatingPointType GetNodeSize() = 0;
enum EReperesent { ePoint, eEdge, eSurface}; enum EReperesent { ePoint, eEdge, eSurface};
@ -85,7 +85,7 @@ class SMESH_Actor: public SALOME_Actor
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0; virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
virtual void SetShrinkFactor(float theValue) = 0; virtual void SetShrinkFactor(vtkFloatingPointType theValue) = 0;
virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0; virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0;
virtual bool GetPointsLabeled() = 0; virtual bool GetPointsLabeled() = 0;
@ -101,8 +101,8 @@ class SMESH_Actor: public SALOME_Actor
virtual vtkScalarBarActor* GetScalarBarActor() = 0; virtual vtkScalarBarActor* GetScalarBarActor() = 0;
virtual void SetPlaneParam(float theDir[3], float theDist, vtkPlane* thePlane) = 0; virtual void SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane) = 0;
virtual void GetPlaneParam(float theDir[3], float& theDist, vtkPlane* thePlane) = 0; virtual void GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane) = 0;
virtual void RemoveAllClippingPlanes() = 0; virtual void RemoveAllClippingPlanes() = 0;
virtual vtkIdType GetNumberOfClippingPlanes() = 0; virtual vtkIdType GetNumberOfClippingPlanes() = 0;

51
src/OBJECT/SMESH_ActorDef.h
View File

@ -79,7 +79,8 @@ class vtkTimeStamp;
class SMESH_DeviceActor; class SMESH_DeviceActor;
class SMESH_ActorDef : public SMESH_Actor{ class SMESH_ActorDef : public SMESH_Actor
{
friend class SMESH_VisualObj; friend class SMESH_VisualObj;
friend class SMESH_Actor; friend class SMESH_Actor;
@ -100,35 +101,35 @@ class SMESH_ActorDef : public SMESH_Actor{
virtual bool IsInfinitive(); virtual bool IsInfinitive();
virtual void SetOpacity(float theValue); virtual void SetOpacity(vtkFloatingPointType theValue);
virtual float GetOpacity(); virtual vtkFloatingPointType GetOpacity();
virtual void SetSufaceColor(float r,float g,float b); virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetSufaceColor(float& r,float& g,float& b); virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetBackSufaceColor(float r,float g,float b); virtual void SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetBackSufaceColor(float& r,float& g,float& b); virtual void GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetEdgeColor(float r,float g,float b); virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetEdgeColor(float& r,float& g,float& b); virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetNodeColor(float r,float g,float b); virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetNodeColor(float& r,float& g,float& b); virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetHighlightColor(float r,float g,float b); virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetHighlightColor(float& r,float& g,float& b); virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetPreHighlightColor(float r,float g,float b); virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetPreHighlightColor(float& r,float& g,float& b); virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual float GetLineWidth(); virtual vtkFloatingPointType GetLineWidth();
virtual void SetLineWidth(float theVal); virtual void SetLineWidth(vtkFloatingPointType theVal);
virtual void SetNodeSize(float size) ; virtual void SetNodeSize(vtkFloatingPointType size) ;
virtual float GetNodeSize() ; virtual vtkFloatingPointType GetNodeSize() ;
virtual int GetNodeObjId(int theVtkID); virtual int GetNodeObjId(int theVtkID);
virtual float* GetNodeCoord(int theObjID); virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID); virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID); virtual vtkCell* GetElemCell(int theObjID);
@ -146,15 +147,15 @@ class SMESH_ActorDef : public SMESH_Actor{
virtual void SetPointRepresentation(bool theIsPointsVisible); virtual void SetPointRepresentation(bool theIsPointsVisible);
virtual bool GetPointRepresentation(); virtual bool GetPointRepresentation();
virtual float* GetBounds(); virtual vtkFloatingPointType* GetBounds();
virtual void SetTransform(VTKViewer_Transform* theTransform); virtual void SetTransform(VTKViewer_Transform* theTransform);
virtual vtkUnstructuredGrid* GetUnstructuredGrid(); virtual vtkUnstructuredGrid* GetUnstructuredGrid();
virtual vtkDataSet* GetInput(); virtual vtkDataSet* GetInput();
virtual vtkMapper* GetMapper(); virtual vtkMapper* GetMapper();
virtual float GetShrinkFactor(); virtual vtkFloatingPointType GetShrinkFactor();
virtual void SetShrinkFactor(float theValue); virtual void SetShrinkFactor(vtkFloatingPointType theValue);
virtual bool IsShrunkable() { return myIsShrinkable;} virtual bool IsShrunkable() { return myIsShrinkable;}
virtual bool IsShrunk() { return myIsShrunk;} virtual bool IsShrunk() { return myIsShrunk;}
@ -172,8 +173,8 @@ class SMESH_ActorDef : public SMESH_Actor{
virtual vtkScalarBarActor* GetScalarBarActor(){ return myScalarBarActor;} virtual vtkScalarBarActor* GetScalarBarActor(){ return myScalarBarActor;}
virtual void SetPlaneParam(float theDir[3], float theDist, vtkPlane* thePlane); virtual void SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane);
virtual void GetPlaneParam(float theDir[3], float& theDist, vtkPlane* thePlane); virtual void GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane);
virtual void RemoveAllClippingPlanes(); virtual void RemoveAllClippingPlanes();
virtual vtkIdType GetNumberOfClippingPlanes(); virtual vtkIdType GetNumberOfClippingPlanes();

12
src/OBJECT/SMESH_ActorUtils.cxx
View File

@ -37,10 +37,10 @@ static int MYDEBUG = 0;
namespace SMESH{ namespace SMESH{
float GetFloat( const QString& theValue, float theDefault ) vtkFloatingPointType GetFloat( const QString& theValue, vtkFloatingPointType theDefault )
{ {
int pos = theValue.find( ":" ); int pos = theValue.find( ":" );
float val = theDefault; vtkFloatingPointType val = theDefault;
if( pos>=0 ) if( pos>=0 )
{ {
QString name = theValue.right( theValue.length()-pos-1 ), QString name = theValue.right( theValue.length()-pos-1 ),
@ -51,12 +51,12 @@ namespace SMESH{
return val; return val;
} }
float GetFloat( const QString& theValue, const QString& theSection, float theDefault ) vtkFloatingPointType GetFloat( const QString& theValue, const QString& theSection, vtkFloatingPointType theDefault )
{ {
float val = theDefault; vtkFloatingPointType val = theDefault;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( mgr ) if( mgr )
val = (float) mgr->doubleValue( theValue, theSection, theDefault ); val = (vtkFloatingPointType) mgr->doubleValue( theValue, theSection, theDefault );
return val; return val;
} }
@ -90,7 +90,7 @@ namespace SMESH{
SUIT_Tools::rgbSet( SUIT_Tools::rgbSet( c ), r, g, b ); SUIT_Tools::rgbSet( SUIT_Tools::rgbSet( c ), r, g, b );
} }
void GetColor( const QString& theSect, const QString& theName, float& r, float& g, float& b, const QColor& def ) void GetColor( const QString& theSect, const QString& theName, vtkFloatingPointType& r, vtkFloatingPointType& g, vtkFloatingPointType& b, const QColor& def )
{ {
int ir( 0 ), ig( 0 ), ib( 0 ); int ir( 0 ), ig( 0 ), ib( 0 );
GetColor( theSect, theName, ir, ig, ib, def ); GetColor( theSect, theName, ir, ig, ib, def );

8
src/OBJECT/SMESH_ActorUtils.h
View File

@ -20,6 +20,8 @@
#ifndef SMESH_ACTORUTILS_H #ifndef SMESH_ACTORUTILS_H
#define SMESH_ACTORUTILS_H #define SMESH_ACTORUTILS_H
#include "VTKViewer.h"
#include <qcolor.h> #include <qcolor.h>
#include <qstring.h> #include <qstring.h>
@ -27,12 +29,12 @@ class vtkUnstructuredGrid;
namespace SMESH{ namespace SMESH{
float GetFloat( const QString& theValue, float theDefault = 0 ); vtkFloatingPointType GetFloat( const QString& theValue, vtkFloatingPointType theDefault = 0 );
float GetFloat( const QString& theName, const QString& theSection, float theDefault = 0 ); vtkFloatingPointType GetFloat( const QString& theName, const QString& theSection, vtkFloatingPointType theDefault = 0 );
QColor GetColor( const QString& theSect, const QString& theName, const QColor&t = QColor() ); QColor GetColor( const QString& theSect, const QString& theName, const QColor&t = QColor() );
void GetColor( const QString& theSect, const QString& theName, int&, int&, int&, const QColor&t = QColor() ); void GetColor( const QString& theSect, const QString& theName, int&, int&, int&, const QColor&t = QColor() );
void GetColor( const QString& theSect, const QString& theName, float&, float&, float&, const QColor&t = QColor() ); void GetColor( const QString& theSect, const QString& theName, vtkFloatingPointType&, vtkFloatingPointType&, vtkFloatingPointType&, const QColor&t = QColor() );
void WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, const char* theFileName); void WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, const char* theFileName);

161
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -55,7 +55,7 @@
#include <vtkCell.h> #include <vtkCell.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkIntArray.h> #include <vtkIdTypeArray.h>
#include <vtkCellArray.h> #include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h> #include <vtkUnsignedCharArray.h>
@ -75,7 +75,8 @@ using namespace std;
vtkStandardNewMacro(SMESH_DeviceActor); vtkStandardNewMacro(SMESH_DeviceActor);
SMESH_DeviceActor::SMESH_DeviceActor() SMESH_DeviceActor
::SMESH_DeviceActor()
{ {
if(MYDEBUG) MESSAGE("SMESH_DeviceActor - "<<this); if(MYDEBUG) MESSAGE("SMESH_DeviceActor - "<<this);
@ -113,7 +114,9 @@ SMESH_DeviceActor::SMESH_DeviceActor()
} }
SMESH_DeviceActor::~SMESH_DeviceActor(){ SMESH_DeviceActor
::~SMESH_DeviceActor()
{
if(MYDEBUG) MESSAGE("~SMESH_DeviceActor - "<<this); if(MYDEBUG) MESSAGE("~SMESH_DeviceActor - "<<this);
myProperty->Delete(); myProperty->Delete();
@ -139,8 +142,8 @@ SMESH_DeviceActor::~SMESH_DeviceActor(){
void void
SMESH_DeviceActor:: SMESH_DeviceActor
SetStoreGemetryMapping(bool theStoreMapping) ::SetStoreGemetryMapping(bool theStoreMapping)
{ {
myGeomFilter->SetStoreMapping(theStoreMapping); myGeomFilter->SetStoreMapping(theStoreMapping);
SetStoreClippingMapping(theStoreMapping); SetStoreClippingMapping(theStoreMapping);
@ -148,8 +151,8 @@ SetStoreGemetryMapping(bool theStoreMapping)
void void
SMESH_DeviceActor:: SMESH_DeviceActor
SetStoreClippingMapping(bool theStoreMapping) ::SetStoreClippingMapping(bool theStoreMapping)
{ {
myStoreClippingMapping = theStoreMapping; myStoreClippingMapping = theStoreMapping;
myExtractGeometry->SetStoreMapping(theStoreMapping && myIsImplicitFunctionUsed); myExtractGeometry->SetStoreMapping(theStoreMapping && myIsImplicitFunctionUsed);
@ -158,15 +161,17 @@ SetStoreClippingMapping(bool theStoreMapping)
void void
SMESH_DeviceActor:: SMESH_DeviceActor
SetStoreIDMapping(bool theStoreMapping) ::SetStoreIDMapping(bool theStoreMapping)
{ {
myExtractUnstructuredGrid->SetStoreMapping(theStoreMapping); myExtractUnstructuredGrid->SetStoreMapping(theStoreMapping);
} }
void SMESH_DeviceActor::Init(TVisualObjPtr theVisualObj, void
vtkImplicitBoolean* theImplicitBoolean) SMESH_DeviceActor
::Init(TVisualObjPtr theVisualObj,
vtkImplicitBoolean* theImplicitBoolean)
{ {
myVisualObj = theVisualObj; myVisualObj = theVisualObj;
myExtractGeometry->SetImplicitFunction(theImplicitBoolean); myExtractGeometry->SetImplicitFunction(theImplicitBoolean);
@ -175,8 +180,8 @@ void SMESH_DeviceActor::Init(TVisualObjPtr theVisualObj,
void void
SMESH_DeviceActor:: SMESH_DeviceActor
SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed) ::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
{ {
int anId = 0; int anId = 0;
if(theIsImplicitFunctionUsed) if(theIsImplicitFunctionUsed)
@ -189,7 +194,10 @@ SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
} }
void SMESH_DeviceActor::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid){ void
SMESH_DeviceActor
::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid)
{
if(theGrid){ if(theGrid){
//myIsShrinkable = theGrid->GetNumberOfCells() > 10; //myIsShrinkable = theGrid->GetNumberOfCells() > 10;
myIsShrinkable = true; myIsShrinkable = true;
@ -231,20 +239,28 @@ void SMESH_DeviceActor::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid){
} }
VTKViewer_ExtractUnstructuredGrid* SMESH_DeviceActor::GetExtractUnstructuredGrid(){ VTKViewer_ExtractUnstructuredGrid*
SMESH_DeviceActor
::GetExtractUnstructuredGrid()
{
return myExtractUnstructuredGrid; return myExtractUnstructuredGrid;
} }
vtkUnstructuredGrid* SMESH_DeviceActor::GetUnstructuredGrid(){ vtkUnstructuredGrid*
SMESH_DeviceActor
::GetUnstructuredGrid()
{
myExtractUnstructuredGrid->Update(); myExtractUnstructuredGrid->Update();
return myExtractUnstructuredGrid->GetOutput(); return myExtractUnstructuredGrid->GetOutput();
} }
void SMESH_DeviceActor::SetControlMode(SMESH::Controls::FunctorPtr theFunctor, void
vtkScalarBarActor* theScalarBarActor, SMESH_DeviceActor
vtkLookupTable* theLookupTable) ::SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
vtkScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable)
{ {
bool anIsInitialized = theFunctor; bool anIsInitialized = theFunctor;
if(anIsInitialized){ if(anIsInitialized){
@ -293,9 +309,11 @@ void SMESH_DeviceActor::SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
theScalarBarActor->SetVisibility(anIsInitialized); theScalarBarActor->SetVisibility(anIsInitialized);
} }
void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor, void
vtkScalarBarActor* theScalarBarActor, SMESH_DeviceActor
vtkLookupTable* theLookupTable) ::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor,
vtkScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable)
{ {
bool anIsInitialized = theFunctor; bool anIsInitialized = theFunctor;
myExtractUnstructuredGrid->ClearRegisteredCells(); myExtractUnstructuredGrid->ClearRegisteredCells();
@ -347,7 +365,7 @@ void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor
} }
} }
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 ); aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells ); aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -407,7 +425,7 @@ void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor
} }
} }
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 ); aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells ); aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -432,7 +450,9 @@ void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor
theScalarBarActor->SetVisibility(anIsInitialized); theScalarBarActor->SetVisibility(anIsInitialized);
} }
void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor) void
SMESH_DeviceActor
::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor)
{ {
myExtractUnstructuredGrid->ClearRegisteredCells(); myExtractUnstructuredGrid->ClearRegisteredCells();
myExtractUnstructuredGrid->ClearRegisteredCellsWithType(); myExtractUnstructuredGrid->ClearRegisteredCellsWithType();
@ -487,7 +507,7 @@ void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor
} }
} }
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 ); aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells ); aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -505,7 +525,10 @@ void SMESH_DeviceActor::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor
unsigned long int SMESH_DeviceActor::GetMTime(){ unsigned long int
SMESH_DeviceActor
::GetMTime()
{
unsigned long mTime = this->Superclass::GetMTime(); unsigned long mTime = this->Superclass::GetMTime();
mTime = max(mTime,myExtractGeometry->GetMTime()); mTime = max(mTime,myExtractGeometry->GetMTime());
mTime = max(mTime,myExtractUnstructuredGrid->GetMTime()); mTime = max(mTime,myExtractUnstructuredGrid->GetMTime());
@ -516,12 +539,18 @@ unsigned long int SMESH_DeviceActor::GetMTime(){
} }
void SMESH_DeviceActor::SetTransform(VTKViewer_Transform* theTransform){ void
SMESH_DeviceActor
::SetTransform(VTKViewer_Transform* theTransform)
{
myTransformFilter->SetTransform(theTransform); myTransformFilter->SetTransform(theTransform);
} }
void SMESH_DeviceActor::SetShrink() { void
SMESH_DeviceActor
::SetShrink()
{
if ( !myIsShrinkable ) return; if ( !myIsShrinkable ) return;
if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() ) if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
{ {
@ -531,7 +560,10 @@ void SMESH_DeviceActor::SetShrink() {
} }
} }
void SMESH_DeviceActor::UnShrink() { void
SMESH_DeviceActor
::UnShrink()
{
if ( !myIsShrunk ) return; if ( !myIsShrunk ) return;
if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() ) if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
{ {
@ -543,7 +575,10 @@ void SMESH_DeviceActor::UnShrink() {
} }
void SMESH_DeviceActor::SetRepresentation(EReperesent theMode){ void
SMESH_DeviceActor
::SetRepresentation(EReperesent theMode)
{
switch(theMode){ switch(theMode){
case ePoint: case ePoint:
myGeomFilter->SetInside(true); myGeomFilter->SetInside(true);
@ -572,7 +607,10 @@ void SMESH_DeviceActor::SetRepresentation(EReperesent theMode){
} }
void SMESH_DeviceActor::SetVisibility(int theMode){ void
SMESH_DeviceActor
::SetVisibility(int theMode)
{
if(!myExtractUnstructuredGrid->GetInput() || if(!myExtractUnstructuredGrid->GetInput() ||
GetUnstructuredGrid()->GetNumberOfCells()) GetUnstructuredGrid()->GetNumberOfCells())
{ {
@ -583,7 +621,10 @@ void SMESH_DeviceActor::SetVisibility(int theMode){
} }
int SMESH_DeviceActor::GetVisibility(){ int
SMESH_DeviceActor
::GetVisibility()
{
if(!GetUnstructuredGrid()->GetNumberOfCells()){ if(!GetUnstructuredGrid()->GetNumberOfCells()){
vtkLODActor::SetVisibility(false); vtkLODActor::SetVisibility(false);
} }
@ -591,7 +632,10 @@ int SMESH_DeviceActor::GetVisibility(){
} }
int SMESH_DeviceActor::GetNodeObjId(int theVtkID){ int
SMESH_DeviceActor
::GetNodeObjId(int theVtkID)
{
vtkIdType anID = theVtkID; vtkIdType anID = theVtkID;
if(IsImplicitFunctionUsed()) if(IsImplicitFunctionUsed())
@ -602,16 +646,22 @@ int SMESH_DeviceActor::GetNodeObjId(int theVtkID){
return aRetID; return aRetID;
} }
float* SMESH_DeviceActor::GetNodeCoord(int theObjID){ vtkFloatingPointType*
SMESH_DeviceActor
::GetNodeCoord(int theObjID)
{
vtkDataSet* aDataSet = myMergeFilter->GetOutput(); vtkDataSet* aDataSet = myMergeFilter->GetOutput();
vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID); vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
float* aCoord = aDataSet->GetPoint(anID); vtkFloatingPointType* aCoord = aDataSet->GetPoint(anID);
if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID); if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
return aCoord; return aCoord;
} }
int SMESH_DeviceActor::GetElemObjId(int theVtkID){ int
SMESH_DeviceActor
::GetElemObjId(int theVtkID)
{
vtkIdType anId = myGeomFilter->GetElemObjId(theVtkID); vtkIdType anId = myGeomFilter->GetElemObjId(theVtkID);
if(anId < 0) if(anId < 0)
return -1; return -1;
@ -632,7 +682,10 @@ int SMESH_DeviceActor::GetElemObjId(int theVtkID){
return aRetID; return aRetID;
} }
vtkCell* SMESH_DeviceActor::GetElemCell(int theObjID){ vtkCell*
SMESH_DeviceActor
::GetElemCell(int theObjID)
{
vtkDataSet* aDataSet = myVisualObj->GetUnstructuredGrid(); vtkDataSet* aDataSet = myVisualObj->GetUnstructuredGrid();
vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID); vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID);
vtkCell* aCell = aDataSet->GetCell(aGridID); vtkCell* aCell = aDataSet->GetCell(aGridID);
@ -642,33 +695,45 @@ vtkCell* SMESH_DeviceActor::GetElemCell(int theObjID){
} }
float SMESH_DeviceActor::GetShrinkFactor(){ vtkFloatingPointType
SMESH_DeviceActor
::GetShrinkFactor()
{
return myShrinkFilter->GetShrinkFactor(); return myShrinkFilter->GetShrinkFactor();
} }
void SMESH_DeviceActor::SetShrinkFactor(float theValue){ void
SMESH_DeviceActor
::SetShrinkFactor(vtkFloatingPointType theValue)
{
theValue = theValue > 0.1? theValue: 0.8; theValue = theValue > 0.1? theValue: 0.8;
myShrinkFilter->SetShrinkFactor(theValue); myShrinkFilter->SetShrinkFactor(theValue);
Modified(); Modified();
} }
void SMESH_DeviceActor::SetHighlited(bool theIsHighlited){ void
SMESH_DeviceActor
::SetHighlited(bool theIsHighlited)
{
if ( myIsHighlited == theIsHighlited ) if ( myIsHighlited == theIsHighlited )
return; return;
myIsHighlited = theIsHighlited; myIsHighlited = theIsHighlited;
Modified(); Modified();
} }
void SMESH_DeviceActor::Render(vtkRenderer *ren, vtkMapper* m){ void
SMESH_DeviceActor
::Render(vtkRenderer *ren, vtkMapper* m)
{
int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology(); int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
float aStoredFactor, aStoredUnit; vtkFloatingPointType aStoredFactor, aStoredUnit;
vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit); vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
vtkMapper::SetResolveCoincidentTopologyToPolygonOffset(); vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
float aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits; vtkFloatingPointType aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
if(myIsHighlited){ if(myIsHighlited){
static float EPS = .01; static vtkFloatingPointType EPS = .01;
aUnits *= (1.0-EPS); aUnits *= (1.0-EPS);
} }
vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits); vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits);
@ -679,7 +744,11 @@ void SMESH_DeviceActor::Render(vtkRenderer *ren, vtkMapper* m){
} }
void SMESH_DeviceActor::SetPolygonOffsetParameters(float factor, float units){ void
SMESH_DeviceActor
::SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units)
{
myPolygonOffsetFactor = factor; myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units; myPolygonOffsetUnits = units;
} }

20
src/OBJECT/SMESH_DeviceActor.h
View File

@ -66,7 +66,7 @@ class SMESH_DeviceActor: public vtkLODActor{
void SetStoreIDMapping(bool theStoreMapping); void SetStoreIDMapping(bool theStoreMapping);
virtual int GetNodeObjId(int theVtkID); virtual int GetNodeObjId(int theVtkID);
virtual float* GetNodeCoord(int theObjID); virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID); virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID); virtual vtkCell* GetElemCell(int theObjID);
@ -74,8 +74,8 @@ class SMESH_DeviceActor: public vtkLODActor{
virtual void SetTransform(VTKViewer_Transform* theTransform); virtual void SetTransform(VTKViewer_Transform* theTransform);
virtual unsigned long int GetMTime(); virtual unsigned long int GetMTime();
float GetShrinkFactor(); vtkFloatingPointType GetShrinkFactor();
void SetShrinkFactor(float value); void SetShrinkFactor(vtkFloatingPointType value);
bool IsShrunkable() { return myIsShrinkable;} bool IsShrunkable() { return myIsShrinkable;}
bool IsShrunk() { return myIsShrunk;} bool IsShrunk() { return myIsShrunk;}
@ -135,11 +135,17 @@ class SMESH_DeviceActor: public vtkLODActor{
bool myIsHighlited; bool myIsHighlited;
float myPolygonOffsetFactor; vtkFloatingPointType myPolygonOffsetFactor;
float myPolygonOffsetUnits; vtkFloatingPointType myPolygonOffsetUnits;
void SetPolygonOffsetParameters(float factor, float units); void
void GetPolygonOffsetParameters(float& factor, float& units){ SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units);
void
GetPolygonOffsetParameters(vtkFloatingPointType& factor,
vtkFloatingPointType& units)
{
factor = myPolygonOffsetFactor; factor = myPolygonOffsetFactor;
units = myPolygonOffsetUnits; units = myPolygonOffsetUnits;
} }

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -80,8 +80,8 @@ void SMESH_ExtractGeometry::Execute()
vtkIdList *cellPts; vtkIdList *cellPts;
vtkCell *cell; vtkCell *cell;
int numCellPts; int numCellPts;
float *x; vtkFloatingPointType *x;
float multiplier; vtkFloatingPointType multiplier;
vtkPoints *newPts; vtkPoints *newPts;
vtkIdList *newCellPts; vtkIdList *newCellPts;
vtkDataSet *input = this->GetInput(); vtkDataSet *input = this->GetInput();
@ -156,7 +156,7 @@ void SMESH_ExtractGeometry::Execute()
// To extract boundary cells, we have to create supplemental information // To extract boundary cells, we have to create supplemental information
if ( this->ExtractBoundaryCells ) if ( this->ExtractBoundaryCells )
{ {
float val; vtkFloatingPointType val;
newScalars = vtkFloatArray::New(); newScalars = vtkFloatArray::New();
newScalars->SetNumberOfValues(numPts); newScalars->SetNumberOfValues(numPts);

4
src/OBJECT/SMESH_Object.cxx
View File

@ -39,7 +39,7 @@
#include <vtkCell.h> #include <vtkCell.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkIntArray.h> #include <vtkIdTypeArray.h>
#include <vtkCellArray.h> #include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h> #include <vtkUnsignedCharArray.h>
@ -418,7 +418,7 @@ void SMESH_VisualObjDef::buildElemPrs()
// Insert cells in grid // Insert cells in grid
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 ); aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells ); aCellLocationsArray->SetNumberOfTuples( aNbCells );

34
src/SMESHGUI/SMESHGUI.cxx
View File

@ -457,28 +457,28 @@ namespace{
anActor->SetRepresentation(SMESH_Actor::ePoint); anActor->SetRepresentation(SMESH_Actor::ePoint);
break; break;
case 1132:{ case 1132:{
float color[3]; vtkFloatingPointType color[3];
anActor->GetSufaceColor(color[0], color[1], color[2]); anActor->GetSufaceColor(color[0], color[1], color[2]);
int c0 = int (color[0] * 255); int c0 = int (color[0] * 255);
int c1 = int (color[1] * 255); int c1 = int (color[1] * 255);
int c2 = int (color[2] * 255); int c2 = int (color[2] * 255);
QColor c(c0, c1, c2); QColor c(c0, c1, c2);
float edgecolor[3]; vtkFloatingPointType edgecolor[3];
anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]); anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
c0 = int (edgecolor[0] * 255); c0 = int (edgecolor[0] * 255);
c1 = int (edgecolor[1] * 255); c1 = int (edgecolor[1] * 255);
c2 = int (edgecolor[2] * 255); c2 = int (edgecolor[2] * 255);
QColor e(c0, c1, c2); QColor e(c0, c1, c2);
float backfacecolor[3]; vtkFloatingPointType backfacecolor[3];
anActor->GetBackSufaceColor(backfacecolor[0], backfacecolor[1], backfacecolor[2]); anActor->GetBackSufaceColor(backfacecolor[0], backfacecolor[1], backfacecolor[2]);
c0 = int (backfacecolor[0] * 255); c0 = int (backfacecolor[0] * 255);
c1 = int (backfacecolor[1] * 255); c1 = int (backfacecolor[1] * 255);
c2 = int (backfacecolor[2] * 255); c2 = int (backfacecolor[2] * 255);
QColor b(c0, c1, c2); QColor b(c0, c1, c2);
float nodecolor[3]; vtkFloatingPointType nodecolor[3];
anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]); anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
c0 = int (nodecolor[0] * 255); c0 = int (nodecolor[0] * 255);
c1 = int (nodecolor[1] * 255); c1 = int (nodecolor[1] * 255);
@ -489,7 +489,7 @@ namespace{
if(Edgewidth == 0) if(Edgewidth == 0)
Edgewidth = 1; Edgewidth = 1;
int intValue = int(anActor->GetNodeSize()); int intValue = int(anActor->GetNodeSize());
float Shrink = anActor->GetShrinkFactor(); vtkFloatingPointType Shrink = anActor->GetShrinkFactor();
SMESHGUI_Preferences_ColorDlg *aDlg = SMESHGUI_Preferences_ColorDlg *aDlg =
new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI(), "" ); new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI(), "" );
@ -506,26 +506,26 @@ namespace{
QColor nodecolor = aDlg->GetColor(3); QColor nodecolor = aDlg->GetColor(3);
QColor backfacecolor = aDlg->GetColor(4); QColor backfacecolor = aDlg->GetColor(4);
/* actor color and backface color */ /* actor color and backface color */
anActor->SetSufaceColor(float (color.red()) / 255., anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
float (color.green()) / 255., vtkFloatingPointType (color.green()) / 255.,
float (color.blue()) / 255.); vtkFloatingPointType (color.blue()) / 255.);
anActor->SetBackSufaceColor(float (backfacecolor.red()) / 255., anActor->SetBackSufaceColor(vtkFloatingPointType (backfacecolor.red()) / 255.,
float (backfacecolor.green()) / 255., vtkFloatingPointType (backfacecolor.green()) / 255.,
float (backfacecolor.blue()) / 255.); vtkFloatingPointType (backfacecolor.blue()) / 255.);
/* edge color */ /* edge color */
anActor->SetEdgeColor(float (edgecolor.red()) / 255., anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
float (edgecolor.green()) / 255., vtkFloatingPointType (edgecolor.green()) / 255.,
float (edgecolor.blue()) / 255.); vtkFloatingPointType (edgecolor.blue()) / 255.);
/* Shrink factor and size edges */ /* Shrink factor and size edges */
anActor->SetShrinkFactor(aDlg->GetIntValue(3) / 100.); anActor->SetShrinkFactor(aDlg->GetIntValue(3) / 100.);
anActor->SetLineWidth(aDlg->GetIntValue(1)); anActor->SetLineWidth(aDlg->GetIntValue(1));
/* Nodes color and size */ /* Nodes color and size */
anActor->SetNodeColor(float (nodecolor.red()) / 255., anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255.,
float (nodecolor.green()) / 255., vtkFloatingPointType (nodecolor.green()) / 255.,
float (nodecolor.blue()) / 255.); vtkFloatingPointType (nodecolor.blue()) / 255.);
anActor->SetNodeSize(aDlg->GetIntValue(2)); anActor->SetNodeSize(aDlg->GetIntValue(2));
delete aDlg; delete aDlg;

2
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

@ -121,7 +121,7 @@ namespace SMESH {
myPreviewActor->VisibilityOff(); myPreviewActor->VisibilityOff();
myPreviewActor->SetMapper(myMapper); myPreviewActor->SetMapper(myMapper);
float anRGB[3]; vtkFloatingPointType anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );

14
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -120,7 +120,7 @@ namespace SMESH {
vtkUnstructuredGrid* myGrid; vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp; //vtkProperty* myBackProp, *myProp;
float anRGB[3], aBackRGB[3]; vtkFloatingPointType myRGB[3], myBackRGB[3];
public: public:
TElementSimulation (SalomeApp_Application* theApplication) TElementSimulation (SalomeApp_Application* theApplication)
@ -143,14 +143,14 @@ namespace SMESH {
myPreviewActor->SetMapper(myMapper); myPreviewActor->SetMapper(myMapper);
vtkProperty* myProp = vtkProperty::New(); vtkProperty* myProp = vtkProperty::New();
GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "fill_color", myRGB[0], myRGB[1], myRGB[2], QColor( 0, 170, 255 ) );
myProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); myProp->SetColor( myRGB[0], myRGB[1], myRGB[2] );
myPreviewActor->SetProperty( myProp ); myPreviewActor->SetProperty( myProp );
myProp->Delete(); myProp->Delete();
vtkProperty* myBackProp = vtkProperty::New(); vtkProperty* myBackProp = vtkProperty::New();
GetColor( "SMESH", "backface_color", aBackRGB[0], aBackRGB[1], aBackRGB[2], QColor( 0, 0, 255 ) ); GetColor( "SMESH", "backface_color", myBackRGB[0], myBackRGB[1], myBackRGB[2], QColor( 0, 0, 255 ) );
myBackProp->SetColor( aBackRGB[0], aBackRGB[1], aBackRGB[2] ); myBackProp->SetColor( myBackRGB[0], myBackRGB[1], myBackRGB[2] );
myPreviewActor->SetBackfaceProperty( myBackProp ); myPreviewActor->SetBackfaceProperty( myBackProp );
myBackProp->Delete(); myBackProp->Delete();
@ -200,7 +200,7 @@ namespace SMESH {
// take care of orientation // take care of orientation
if ( aType == VTK_CONVEX_POINT_SET ) { if ( aType == VTK_CONVEX_POINT_SET ) {
if ( theReverse && theMode == VTK_SURFACE ) { if ( theReverse && theMode == VTK_SURFACE ) {
//myPreviewActor->GetProperty()->SetColor( aBackRGB[0], aBackRGB[1], aBackRGB[2] ); //myPreviewActor->GetProperty()->SetColor( myBackRGB[0], myBackRGB[1], myBackRGB[2] );
} }
} }
else { else {
@ -230,7 +230,7 @@ namespace SMESH {
// restore normal orientation // restore normal orientation
if ( aType == VTK_CONVEX_POINT_SET ) { if ( aType == VTK_CONVEX_POINT_SET ) {
if ( theReverse && theMode == VTK_SURFACE ) { if ( theReverse && theMode == VTK_SURFACE ) {
//myPreviewActor->GetProperty()->SetColor( anRGB[0], anRGB[1], anRGB[2] ); //myPreviewActor->GetProperty()->SetColor( myRGB[0], myRGB[1], myRGB[2] );
} }
} }
} }

60
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View File

@ -159,7 +159,7 @@ protected:
myActor->SetInfinitive(true); myActor->SetInfinitive(true);
myActor->SetMapper(myMapper); myActor->SetMapper(myMapper);
float anRGB[3]; vtkFloatingPointType anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
@ -656,18 +656,18 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
OrientedPlane* aPlane = myPlanes[aCurPlaneIndex].GetPointer(); OrientedPlane* aPlane = myPlanes[aCurPlaneIndex].GetPointer();
float aNormal[3]; vtkFloatingPointType aNormal[3];
SMESH::Orientation anOrientation; SMESH::Orientation anOrientation;
float aDir[3][3] = {{0, 0, 0}, {0, 0, 0}}; vtkFloatingPointType aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
{ {
static double aCoeff = vtkMath::Pi()/180.0; static double aCoeff = vtkMath::Pi()/180.0;
float aRot[2] = {getRotation1(), getRotation2()}; vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()};
aPlane->myAngle[0] = aRot[0]; aPlane->myAngle[0] = aRot[0];
aPlane->myAngle[1] = aRot[1]; aPlane->myAngle[1] = aRot[1];
float anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])}; vtkFloatingPointType anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
float aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])}; vtkFloatingPointType aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
aV[0] = aRot[0] > 0? aV[0]: -aV[0]; aV[0] = aRot[0] > 0? aV[0]: -aV[0];
aV[1] = aRot[1] > 0? aV[1]: -aV[1]; aV[1] = aRot[1] > 0? aV[1]: -aV[1];
@ -715,37 +715,37 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
myActor->SetPlaneParam(aNormal, getDistance(), aPlane); myActor->SetPlaneParam(aNormal, getDistance(), aPlane);
vtkDataSet* aDataSet = myActor->GetInput(); vtkDataSet* aDataSet = myActor->GetInput();
float *aPnt = aDataSet->GetCenter(); vtkFloatingPointType *aPnt = aDataSet->GetCenter();
float* anOrigin = aPlane->GetOrigin(); vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
float aDel = aDataSet->GetLength()/2.0; vtkFloatingPointType aDel = aDataSet->GetLength()/2.0;
float aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel}, vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
{aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}}; {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
float aParam, aPnt0[3], aPnt1[3], aPnt2[3]; vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
float aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0], vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
aPnt[1] - aDelta[0][1] - aDelta[1][1], aPnt[1] - aDelta[0][1] - aDelta[1][1],
aPnt[2] - aDelta[0][2] - aDelta[1][2]}; aPnt[2] - aDelta[0][2] - aDelta[1][2]};
float aPnt02[3] = {aPnt01[0] + aNormal[0], vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
aPnt01[1] + aNormal[1], aPnt01[1] + aNormal[1],
aPnt01[2] + aNormal[2]}; aPnt01[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0); vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
float aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0], vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
aPnt[1] - aDelta[0][1] + aDelta[1][1], aPnt[1] - aDelta[0][1] + aDelta[1][1],
aPnt[2] - aDelta[0][2] + aDelta[1][2]}; aPnt[2] - aDelta[0][2] + aDelta[1][2]};
float aPnt12[3] = {aPnt11[0] + aNormal[0], vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
aPnt11[1] + aNormal[1], aPnt11[1] + aNormal[1],
aPnt11[2] + aNormal[2]}; aPnt11[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1); vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
float aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0], vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
aPnt[1] + aDelta[0][1] - aDelta[1][1], aPnt[1] + aDelta[0][1] - aDelta[1][1],
aPnt[2] + aDelta[0][2] - aDelta[1][2]}; aPnt[2] + aDelta[0][2] - aDelta[1][2]};
float aPnt22[3] = {aPnt21[0] + aNormal[0], vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
aPnt21[1] + aNormal[1], aPnt21[1] + aNormal[1],
aPnt21[2] + aNormal[2]}; aPnt21[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2); vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
vtkPlaneSource* aPlaneSource = aPlane->myPlaneSource; vtkPlaneSource* aPlaneSource = aPlane->myPlaneSource;

4
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
View File

@ -115,12 +115,12 @@ class TPolySimulation{
myPreviewActor->SetMapper( myMapper ); myPreviewActor->SetMapper( myMapper );
myPreviewActor->SetRepresentation( 3 ); myPreviewActor->SetRepresentation( 3 );
float anRGB[3]; vtkFloatingPointType anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myPreviewActor->SetProperty( aProp ); myPreviewActor->SetProperty( aProp );
float aFactor,aUnits; vtkFloatingPointType aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true); myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits); myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits); myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits);

4
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
View File

@ -89,7 +89,7 @@
// VTK Includes // VTK Includes
#include <vtkCell.h> #include <vtkCell.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkIntArray.h> #include <vtkIdTypeArray.h>
#include <vtkCellArray.h> #include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h> #include <vtkUnsignedCharArray.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
@ -1226,7 +1226,7 @@ vtkUnstructuredGrid* SMESHGUI_MeshPatternDlg::getGrid()
else aCellTypesArray->InsertNextValue(VTK_EMPTY_CELL); else aCellTypesArray->InsertNextValue(VTK_EMPTY_CELL);
} }
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents(1); aCellLocationsArray->SetNumberOfComponents(1);
aCellLocationsArray->SetNumberOfTuples(aNbCells); aCellLocationsArray->SetNumberOfTuples(aNbCells);

4
src/SMESHGUI/SMESHGUI_MoveNodesDlg.cxx
View File

@ -61,7 +61,7 @@
// VTK includes // VTK includes
#include <vtkCell.h> #include <vtkCell.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkIntArray.h> #include <vtkIdTypeArray.h>
#include <vtkCellArray.h> #include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h> #include <vtkUnsignedCharArray.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
@ -547,7 +547,7 @@ void SMESHGUI_MoveNodesDlg::redisplayPreview()
aCellTypesArray->InsertNextValue(VTK_VERTEX); aCellTypesArray->InsertNextValue(VTK_VERTEX);
anIdList->Delete(); anIdList->Delete();
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents(1); aCellLocationsArray->SetNumberOfComponents(1);
aCellLocationsArray->SetNumberOfTuples(1); aCellLocationsArray->SetNumberOfTuples(1);

4
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -68,7 +68,7 @@
#include <vtkPolygon.h> #include <vtkPolygon.h>
#include <vtkConvexPointSet.h> #include <vtkConvexPointSet.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkIntArray.h> #include <vtkIdTypeArray.h>
#include <vtkCellArray.h> #include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h> #include <vtkUnsignedCharArray.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
@ -1320,7 +1320,7 @@ void SMESHGUI_CuttingOfQuadsDlg::displayPreview()
} }
} }
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents(1); aCellLocationsArray->SetNumberOfComponents(1);
aCellLocationsArray->SetNumberOfTuples(aNbCells); aCellLocationsArray->SetNumberOfTuples(aNbCells);

8
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

@ -63,7 +63,7 @@
// VTK Includes // VTK Includes
#include <vtkCell.h> #include <vtkCell.h>
#include <vtkIdList.h> #include <vtkIdList.h>
#include <vtkIntArray.h> #include <vtkIdTypeArray.h>
#include <vtkCellArray.h> #include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h> #include <vtkUnsignedCharArray.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
@ -148,7 +148,7 @@ namespace SMESH {
aCells->InsertNextCell(anIdList); aCells->InsertNextCell(anIdList);
aCellTypesArray->InsertNextValue(VTK_VERTEX); aCellTypesArray->InsertNextValue(VTK_VERTEX);
vtkIntArray* aCellLocationsArray = vtkIntArray::New(); vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents(1); aCellLocationsArray->SetNumberOfComponents(1);
aCellLocationsArray->SetNumberOfTuples(1); aCellLocationsArray->SetNumberOfTuples(1);
@ -179,11 +179,11 @@ namespace SMESH {
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
aProp->SetRepresentationToPoints(); aProp->SetRepresentationToPoints();
float anRGB[3]; vtkFloatingPointType anRGB[3];
GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) ); GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
float aPointSize = GetFloat( "SMESH:node_size", 3 ); vtkFloatingPointType aPointSize = GetFloat( "SMESH:node_size", 3 );
aProp->SetPointSize( aPointSize ); aProp->SetPointSize( aPointSize );
myPreviewActor->SetProperty( aProp ); myPreviewActor->SetProperty( aProp );

6
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
View File

@ -636,13 +636,13 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
vtkScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor(); vtkScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
if ( myScalarBarActor->GetLookupTable() ) { if ( myScalarBarActor->GetLookupTable() ) {
float *range = myScalarBarActor->GetLookupTable()->GetRange(); vtkFloatingPointType *range = myScalarBarActor->GetLookupTable()->GetRange();
myMinEdit->setText( QString::number( range[0],'g',12 ) ); myMinEdit->setText( QString::number( range[0],'g',12 ) );
myMaxEdit->setText( QString::number( range[1],'g',12 ) ); myMaxEdit->setText( QString::number( range[1],'g',12 ) );
} }
vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty(); vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty();
float aTColor[3]; vtkFloatingPointType aTColor[3];
aTitleTextPrp->GetColor( aTColor ); aTitleTextPrp->GetColor( aTColor );
myTitleColorBtn->setPaletteBackgroundColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) ); myTitleColorBtn->setPaletteBackgroundColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) );
myTitleFontCombo->setCurrentItem( aTitleTextPrp->GetFontFamily() ); myTitleFontCombo->setCurrentItem( aTitleTextPrp->GetFontFamily() );
@ -651,7 +651,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() ); myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() );
vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty(); vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty();
float aLColor[3]; vtkFloatingPointType aLColor[3];
aLabelsTextPrp->GetColor( aLColor ); aLabelsTextPrp->GetColor( aLColor );
myLabelsColorBtn->setPaletteBackgroundColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) ); myLabelsColorBtn->setPaletteBackgroundColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) );
myLabelsFontCombo->setCurrentItem( aLabelsTextPrp->GetFontFamily() ); myLabelsFontCombo->setCurrentItem( aLabelsTextPrp->GetFontFamily() );

2
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -174,7 +174,7 @@ namespace SMESH
myStream << aSObject->GetID(); myStream << aSObject->GetID();
} else if ( !CORBA::is_nil(theArg)) { } else if ( !CORBA::is_nil(theArg)) {
if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object
myStream << "smeshObj_" << (int) theArg; myStream << "smeshObj_" << size_t(theArg);
else else
myStream << NotPublishedObjectName(); myStream << NotPublishedObjectName();
} }

11
src/SMESH_I/SMESH_Filter_i.cxx
View File

@ -2511,11 +2511,12 @@ static LDOM_Element createFilterItem( const char* theName,
{ {
LDOM_Element aCriterionItem = theDoc.createElement( "criterion" ); LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type ) ); typedef long int TLongParam;
aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) ); aCriterionItem.setAttribute( ATTR_TYPE , toString( TLongParam( aCriteria[ i ].Type) ) );
aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) ); aCriterionItem.setAttribute( ATTR_COMPARE , toString( TLongParam( aCriteria[ i ].Compare ) ) );
aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) ); aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( TLongParam( aCriteria[ i ].Threshold ) ) );
aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) ); aCriterionItem.setAttribute( ATTR_UNARY , toString( TLongParam( aCriteria[ i ].UnaryOp ) ) );
aCriterionItem.setAttribute( ATTR_BINARY , toString( TLongParam( aCriteria[ i ].BinaryOp ) ) );
aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr ); aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
aCriterionItem.setAttribute( ATTR_TOLERANCE , toString( aCriteria[ i ].Tolerance ) ); aCriterionItem.setAttribute( ATTR_TOLERANCE , toString( aCriteria[ i ].Tolerance ) );

2
src/SMESH_I/SMESH_MEDFamily_i.hxx
View File

@ -61,7 +61,7 @@ public :
// IDL Methods // IDL Methods
void setProtocol(SALOME::TypeOfCommunication typ) {} void setProtocol(SALOME::TypeOfCommunication typ) {}
void release() {} void release() {}
SALOME::SenderInt_ptr getSenderForNumber(long int) {return SALOME::SenderInt::_nil();} SALOME::SenderInt_ptr getSenderForNumber(SALOME_MED::medGeometryElement) {return SALOME::SenderInt::_nil();}
SALOME::SenderInt_ptr getSenderForNumberIndex() {return SALOME::SenderInt::_nil();} SALOME::SenderInt_ptr getSenderForNumberIndex() {return SALOME::SenderInt::_nil();}
CORBA::Long getIdentifier() CORBA::Long getIdentifier()

293
src/SMESH_I/SMESH_MEDMesh_i.hxx
View File

@ -45,195 +45,206 @@
class SMESH_Mesh_i; class SMESH_Mesh_i;
class SMESH_MEDMesh_i: class SMESH_MEDMesh_i:
public virtual POA_SALOME_MED::MESH, public virtual SALOME::GenericObj_i public virtual POA_SALOME_MED::MESH,
public virtual SALOME::GenericObj_i
{ {
public: private: protected: protected:
// C++ object containing values // C++ object containing values
::SMESH_Mesh_i * _mesh_i; ::SMESH_Mesh_i * _mesh_i;
SMESHDS_Mesh *_meshDS; SMESHDS_Mesh *_meshDS;
string _meshId; string _meshId;
bool _compte; bool _compte;
bool _creeFamily; bool _creeFamily;
int _indexElts; int _indexElts;
int _indexEnts; int _indexEnts;
int _famIdent; int _famIdent;
map < SALOME_MED::medGeometryElement, int >_mapIndToSeqElts; map < SALOME_MED::medGeometryElement, int >_mapIndToSeqElts;
SALOME_MED::long_array_var _seq_elemId[MED_NBR_GEOMETRIE_MAILLE]; SALOME_MED::long_array_var _seq_elemId[MED_NBR_GEOMETRIE_MAILLE];
map < SALOME_MED::medEntityMesh, int >_mapNbTypes; map < SALOME_MED::medEntityMesh, int >_mapNbTypes;
map < SALOME_MED::medEntityMesh, int >_mapIndToVectTypes; map < SALOME_MED::medEntityMesh, int >_mapIndToVectTypes;
vector < SALOME_MED::medGeometryElement > vector < SALOME_MED::medGeometryElement >
_TypesId[MED_NBR_GEOMETRIE_MAILLE]; _TypesId[MED_NBR_GEOMETRIE_MAILLE];
vector < SALOME_MED::FAMILY_ptr > _families; vector < SALOME_MED::FAMILY_ptr > _families;
public: public:
// Constructors and associated internal methods // Constructors and associated internal methods
SMESH_MEDMesh_i(); SMESH_MEDMesh_i();
SMESH_MEDMesh_i(SMESH_Mesh_i * m); SMESH_MEDMesh_i(SMESH_Mesh_i * m);
~SMESH_MEDMesh_i(); ~SMESH_MEDMesh_i();
// IDL Methods // IDL Methods
void setProtocol(SALOME::TypeOfCommunication typ) {} void setProtocol(SALOME::TypeOfCommunication typ) {}
void release() {} void release() {}
SALOME::SenderDouble_ptr getSenderForCoordinates(long int) {return SALOME::SenderDouble::_nil();} SALOME::SenderDouble_ptr getSenderForCoordinates(SALOME_MED::medModeSwitch) {return SALOME::SenderDouble::_nil();}
SALOME::SenderInt_ptr getSenderForConnectivity(long int, long int, long int, long int) {return SALOME::SenderInt::_nil();} SALOME::SenderInt_ptr getSenderForConnectivity(SALOME_MED::medModeSwitch,
SALOME::SenderInt_ptr getSenderForPolygonsConnectivity(SALOME_MED::medConnectivity, SALOME_MED::medEntityMesh) {return SALOME::SenderInt::_nil();} SALOME_MED::medConnectivity,
SALOME::SenderInt_ptr getSenderForPolygonsConnectivityIndex(SALOME_MED::medConnectivity, SALOME_MED::medEntityMesh) {return SALOME::SenderInt::_nil();} SALOME_MED::medEntityMesh,
SALOME::SenderInt_ptr getSenderForPolyhedronConnectivity(SALOME_MED::medConnectivity) {return SALOME::SenderInt::_nil();} SALOME_MED::medGeometryElement)
SALOME::SenderInt_ptr getSenderForPolyhedronIndex(SALOME_MED::medConnectivity) {return SALOME::SenderInt::_nil();} {
SALOME::SenderInt_ptr getSenderForPolyhedronFacesIndex() {return SALOME::SenderInt::_nil();} return SALOME::SenderInt::_nil();
}
SALOME::SenderInt_ptr getSenderForPolygonsConnectivity(SALOME_MED::medConnectivity, SALOME_MED::medEntityMesh) {return SALOME::SenderInt::_nil();}
SALOME::SenderInt_ptr getSenderForPolygonsConnectivityIndex(SALOME_MED::medConnectivity, SALOME_MED::medEntityMesh) {return SALOME::SenderInt::_nil();}
SALOME::SenderInt_ptr getSenderForPolyhedronConnectivity(SALOME_MED::medConnectivity) {return SALOME::SenderInt::_nil();}
SALOME::SenderInt_ptr getSenderForPolyhedronIndex(SALOME_MED::medConnectivity) {return SALOME::SenderInt::_nil();}
SALOME::SenderInt_ptr getSenderForPolyhedronFacesIndex() {return SALOME::SenderInt::_nil();}
char *getName() throw(SALOME::SALOME_Exception); char *getName() throw(SALOME::SALOME_Exception);
CORBA::Long getSpaceDimension() throw(SALOME::SALOME_Exception); CORBA::Long getSpaceDimension() throw(SALOME::SALOME_Exception);
CORBA::Long getMeshDimension() throw(SALOME::SALOME_Exception); CORBA::Long getMeshDimension() throw(SALOME::SALOME_Exception);
CORBA::Boolean getIsAGrid() throw (SALOME::SALOME_Exception); CORBA::Boolean getIsAGrid() throw (SALOME::SALOME_Exception);
CORBA::Boolean CORBA::Boolean
existConnectivity(SALOME_MED::medConnectivity connectivityType, existConnectivity(SALOME_MED::medConnectivity connectivityType,
SALOME_MED::medEntityMesh entity) SALOME_MED::medEntityMesh entity)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
char *getCoordinatesSystem() throw(SALOME::SALOME_Exception); char *getCoordinatesSystem() throw(SALOME::SALOME_Exception);
CORBA::Double getCoordinate(CORBA::Long Number, CORBA::Long Axis) CORBA::Double getCoordinate(CORBA::Long Number, CORBA::Long Axis)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
SALOME_MED::double_array * getCoordinates(SALOME_MED::medModeSwitch typeSwitch) SALOME_MED::double_array * getCoordinates(SALOME_MED::medModeSwitch typeSwitch)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::string_array * getCoordinatesNames() SALOME_MED::string_array * getCoordinatesNames()
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::string_array * getCoordinatesUnits() SALOME_MED::string_array * getCoordinatesUnits()
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
CORBA::Long getNumberOfNodes() throw(SALOME::SALOME_Exception); CORBA::Long getNumberOfNodes() throw(SALOME::SALOME_Exception);
CORBA::Long getNumberOfTypes(SALOME_MED::medEntityMesh entity) CORBA::Long getNumberOfTypes(SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::medGeometryElement_array * SALOME_MED::medGeometryElement_array *
getTypes(SALOME_MED::medEntityMesh entity) throw(SALOME:: getTypes(SALOME_MED::medEntityMesh entity) throw(SALOME::
SALOME_Exception); SALOME_Exception);
SALOME_MED::medGeometryElement SALOME_MED::medGeometryElement
getElementType(SALOME_MED::medEntityMesh entity, getElementType(SALOME_MED::medEntityMesh entity,
CORBA::Long number) CORBA::Long number)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
CORBA::Long getNumberOfElements(SALOME_MED::medEntityMesh entity, CORBA::Long getNumberOfElements(SALOME_MED::medEntityMesh entity,
SALOME_MED::medGeometryElement geomElement) SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getConnectivity(SALOME_MED::medModeSwitch typeSwitch, getConnectivity(SALOME_MED::medModeSwitch typeSwitch,
SALOME_MED::medConnectivity mode, SALOME_MED::medConnectivity mode,
SALOME_MED::medEntityMesh entity, SALOME_MED::medEntityMesh entity,
SALOME_MED::medGeometryElement geomElement) SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getConnectivityIndex(SALOME_MED::medConnectivity mode, getConnectivityIndex(SALOME_MED::medConnectivity mode,
SALOME_MED::medEntityMesh entity) SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array* SALOME_MED::long_array*
getGlobalNumberingIndex(SALOME_MED::medEntityMesh entity) getGlobalNumberingIndex(SALOME_MED::medEntityMesh entity)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
CORBA::Long getElementNumber(SALOME_MED::medConnectivity mode, CORBA::Long getElementNumber(SALOME_MED::medConnectivity mode,
SALOME_MED::medEntityMesh entity, SALOME_MED::medEntityMesh entity,
SALOME_MED::medGeometryElement type, SALOME_MED::medGeometryElement type,
const SALOME_MED::long_array & connectivity) const SALOME_MED::long_array & connectivity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getReverseConnectivity(SALOME_MED::medConnectivity mode) getReverseConnectivity(SALOME_MED::medConnectivity mode)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getReverseConnectivityIndex(SALOME_MED:: getReverseConnectivityIndex(SALOME_MED::medConnectivity mode)
medConnectivity mode) throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
// Family and Group // Family and Group
CORBA::Long getNumberOfFamilies(SALOME_MED::medEntityMesh entity) CORBA::Long getNumberOfFamilies(SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
CORBA::Long getNumberOfGroups(SALOME_MED::medEntityMesh entity) CORBA::Long getNumberOfGroups(SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::Family_array * SALOME_MED::Family_array *
getFamilies(SALOME_MED::medEntityMesh entity) getFamilies(SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FAMILY_ptr getFamily(SALOME_MED::medEntityMesh entity, SALOME_MED::FAMILY_ptr getFamily(SALOME_MED::medEntityMesh entity,
CORBA::Long i) throw(SALOME::SALOME_Exception); CORBA::Long i)
throw(SALOME::SALOME_Exception);
SALOME_MED::Group_array * getGroups(SALOME_MED::medEntityMesh entity) SALOME_MED::Group_array * getGroups(SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::GROUP_ptr getGroup(SALOME_MED::medEntityMesh entity, SALOME_MED::GROUP_ptr getGroup(SALOME_MED::medEntityMesh entity,
CORBA::Long i) throw(SALOME::SALOME_Exception); CORBA::Long i)
throw(SALOME::SALOME_Exception);
SALOME_MED::SUPPORT_ptr SALOME_MED::SUPPORT_ptr
getBoundaryElements(SALOME_MED::medEntityMesh entity) getBoundaryElements(SALOME_MED::medEntityMesh entity)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
SALOME_MED::SUPPORT_ptr getSkin(SALOME_MED::SUPPORT_ptr mySupport3D) SALOME_MED::SUPPORT_ptr getSkin(SALOME_MED::SUPPORT_ptr mySupport3D)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
SALOME_MED::FIELD_ptr getVolume(SALOME_MED::SUPPORT_ptr mySupport) SALOME_MED::FIELD_ptr getVolume(SALOME_MED::SUPPORT_ptr mySupport)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FIELD_ptr getArea(SALOME_MED::SUPPORT_ptr mySupport) SALOME_MED::FIELD_ptr getArea(SALOME_MED::SUPPORT_ptr mySupport)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FIELD_ptr getLength(SALOME_MED::SUPPORT_ptr mySupport) SALOME_MED::FIELD_ptr getLength(SALOME_MED::SUPPORT_ptr mySupport)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FIELD_ptr getNormal(SALOME_MED::SUPPORT_ptr mySupport) SALOME_MED::FIELD_ptr getNormal(SALOME_MED::SUPPORT_ptr mySupport)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FIELD_ptr getBarycenter(SALOME_MED::SUPPORT_ptr mySupport) SALOME_MED::FIELD_ptr getBarycenter(SALOME_MED::SUPPORT_ptr mySupport)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FIELD_ptr getNeighbourhood(SALOME_MED::SUPPORT_ptr mySupport) SALOME_MED::FIELD_ptr getNeighbourhood(SALOME_MED::SUPPORT_ptr mySupport)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
// Others // Others
void addInStudy(SALOMEDS::Study_ptr myStudy, void addInStudy(SALOMEDS::Study_ptr myStudy,
SALOME_MED::MESH_ptr myIor) throw(SALOME::SALOME_Exception); SALOME_MED::MESH_ptr myIor)
CORBA::Long addDriver(SALOME_MED::medDriverTypes driverType, throw(SALOME::SALOME_Exception);
const char *fileName, const char *meshName) CORBA::Long addDriver(SALOME_MED::medDriverTypes driverType,
throw(SALOME::SALOME_Exception); const char *fileName, const char *meshName)
void rmDriver(CORBA::Long i) throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
void read(CORBA::Long i) throw(SALOME::SALOME_Exception); void rmDriver(CORBA::Long i) throw(SALOME::SALOME_Exception);
void write(CORBA::Long i, const char *driverMeshName) void read(CORBA::Long i) throw(SALOME::SALOME_Exception);
throw(SALOME::SALOME_Exception); void write(CORBA::Long i, const char *driverMeshName)
throw(SALOME::SALOME_Exception);
// Cuisine interne // Cuisine interne
CORBA::Long getCorbaIndex() throw(SALOME::SALOME_Exception); CORBA::Long getCorbaIndex()
throw(SALOME::SALOME_Exception);
SALOME_MED::MESH::meshInfos * getMeshGlobal() SALOME_MED::MESH::meshInfos * getMeshGlobal()
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
bool areEquals(SALOME_MED::MESH_ptr other) { return false;}; bool areEquals(SALOME_MED::MESH_ptr other) { return false;};
SALOME_MED::MESH::coordinateInfos * getCoordGlobal() SALOME_MED::MESH::coordinateInfos * getCoordGlobal()
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
SALOME_MED::MESH::connectivityInfos * SALOME_MED::MESH::connectivityInfos *
getConnectGlobal(SALOME_MED::medEntityMesh entity) getConnectGlobal(SALOME_MED::medEntityMesh entity)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
// //
void calculeNbElts() throw(SALOME::SALOME_Exception); void calculeNbElts() throw(SALOME::SALOME_Exception);
void createFamilies() throw(SALOME::SALOME_Exception); void createFamilies() throw(SALOME::SALOME_Exception);
}; };
#endif /* _MED_MESH_I_HXX_ */ #endif /* _MED_MESH_I_HXX_ */

2
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -1639,7 +1639,7 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo
CORBA::Long SMESH_Mesh_i::GetMeshPtr() CORBA::Long SMESH_Mesh_i::GetMeshPtr()
{ {
return (CORBA::Long)_impl; return CORBA::Long(size_t(_impl));
} }

11
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
View File

@ -78,8 +78,10 @@ StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i()
* Builds point distribution according to passed function * Builds point distribution according to passed function
*/ */
//============================================================================= //=============================================================================
SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func, long nbSeg, long conv ) SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func,
throw ( SALOME::SALOME_Exception ) CORBA::Long nbSeg,
CORBA::Long conv )
throw ( SALOME::SALOME_Exception )
{ {
MESSAGE( "StdMeshers_NumberOfSegments_i::BuildDistribution" ); MESSAGE( "StdMeshers_NumberOfSegments_i::BuildDistribution" );
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
@ -99,8 +101,9 @@ throw ( SALOME::SALOME_Exception )
} }
SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func, SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
long nbSeg, long conv ) CORBA::Long nbSeg,
throw ( SALOME::SALOME_Exception ) CORBA::Long conv )
throw ( SALOME::SALOME_Exception )
{ {
MESSAGE( "StdMeshers_NumberOfSegments_i::BuildDistribution" ); MESSAGE( "StdMeshers_NumberOfSegments_i::BuildDistribution" );
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );