From: nri Date: Fri, 16 May 2003 14:22:04 +0000 (+0000) Subject: NRI : First integration. X-Git-Tag: Start-v1_1a~10 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=11b47d48aa238206c0a6493749a1ac8a9fd93c69;p=modules%2Fvisu.git NRI : First integration. --- diff --git a/Makefile.in b/Makefile.in new file mode 100644 index 00000000..8e496240 --- /dev/null +++ b/Makefile.in @@ -0,0 +1,112 @@ +# -* Makefile *- +# +# Author : Patrick GOLDBRONN (CEA) +# Date : 28/06/2001 +# $Header$ +# + +# source path +top_srcdir=@top_srcdir@ +top_builddir=. +srcdir=@srcdir@ +VPATH=.:@srcdir@:@top_srcdir@/bin:@top_srcdir@/resources:./bin:@top_srcdir@/idl:${KERNEL_ROOT_DIR}/idl/salome + + +@COMMENCE@ + +SUBDIRS = idl src + +RESOURCES_FILES = \ +ModuleVisu.png \ +Visu_anim.png \ +Visu_cutplane.png \ +Visu_deformed.png \ +Visu_deformed_anim.png \ +Visu_eraseall.png \ +Visu_isosurfaces.png \ +Visu_plot2d.png \ +Visu_plot3d.png \ +Visu_points.png \ +Visu_sameas.png \ +Visu_scalars.png \ +Visu_scalars_anim.png \ +Visu_selectall.png \ +Visu_selectionactor.png \ +Visu_selectioncell.png \ +Visu_selectionedge.png \ +Visu_selectionpoint.png \ +Visu_selectonly.png \ +Visu_surface.png \ +Visu_vectors.png \ +Visu_wireframe.png \ +Visu_scaling.png \ +VISU_en.xml \ +VISU_fr.xml \ +Visu_tree_visu.png \ +Visu_streamlines.png + +BIN_SCRIPT= + + +# copy header files in common directory +ifeq ($(HAVE_SSTREAM),yes) + include_list=include/salome/SALOMEconfig.h +else + include_list=include/salome/SALOMEconfig.h include/salome/sstream +endif + +inc: idl $(include_list) + +include/salome/SALOMEconfig.h: salome_adm/unix/SALOMEconfig.h + -$(RM) $@ + $(LN_S) ../../$< $@ + +include/salome/sstream: salome_adm/unix/sstream + -$(RM) $@ + $(LN_S) ../../$< $@ + +depend: depend_idl + +depend_idl: + (cd idl ; $(MAKE) $@) || exit 1 + +# doc is already build : if you want to had documents, go manually to doc and run 'make doc' +#doc: +# (cd doc && $(MAKE) $@) || exit 1 + +install-end: +# finish libtool install +# @$(LT) --mode=finish $(libdir) + +install-include: $(include_list) + $(INSTALL) -d $(includedir) + @for f in X $(include_list); do \ + if test $$f != X; then \ + ($(INSTALL_DATA) $$f $(includedir)/. || exit 1); \ + fi; \ + done + +# install script in $(bindir) : +install-bin: $(BIN_SCRIPT) + $(INSTALL) -d $(bindir) + if test $(BIN_SCRIPT)X != X; then \ + $(INSTALL_PROGRAM) $^ $(bindir); \ + fi + +uninstall: uninstall-idl + +uninstall-idl: + $(RM) $(idldir)/*.idl + +distclean: distclean-other + +distclean-other: + -$(RM) salome_adm/unix/*~ salome_adm/unix/*% salome_adm/unix/*.bak salome_adm/unix/*.new salome_adm/unix/*.old + -$(RM) salome_adm/unix/make_* + -$(RM) salome_adm/unix/depend salome_adm/unix/SALOMEconfig.h + -$(RM) config.cache config.log config.status + +@MODULE@ + +install: install-bin install-include install-end + diff --git a/build_configure b/build_configure new file mode 100755 index 00000000..4edf6f44 --- /dev/null +++ b/build_configure @@ -0,0 +1,206 @@ +#!/bin/bash + +# +# Tool for updating list of .in file for the SALOME project +# and regenerating configure script +# +# Author : Marc Tajchman - CEA +# Date : 10/10/2002 +# $Header$ +# + +ORIG_DIR=`pwd` +CONF_DIR=`echo $0 | sed -e "s,[^/]*$,,;s,/$,,;s,^$,.,"` + +######################################################################## +# Test if the KERNEL_ROOT_DIR is set correctly + +if test ! -d "${KERNEL_ROOT_DIR}"; then + echo "failed : KERNEL_ROOT_DIR variable is not correct !" + exit +fi + +# Test if the KERNEL_SRC is set correctly + +#if test ! -d "${KERNEL_SRC}"; then +# echo "failed : KERNEL_SRC variable is not correct !" +# exit +#fi +######################################################################## +# find_in - utility function +# +# usage : +# find_in directory filename +# +# Finds files following the *.in pattern, recursively in the +# directory (first argument). +# Results are appended into the file (second argument) +# +# Difference from the standard unix find is that files are tested +# before directories +# + +find_in() +{ + local i + local f=$2 + +# if the first argument is not a directory, returns + + if [ ! -d "$1" ] ; then + return + fi + +# dont look in the CVS directories + + case $1 in + */CVS) return ;; + *) ;; + esac + +# for each regular file contained in the directory +# test if it's a .in file + + for i in "$1"/* + do + if [ -f "$i" ] ; then + case $i in + *.in) echo " "$i" \\" >> $f;; + *) ;; + esac + fi + done + +# for each subdirectory of the first argument, proceeds recursively + + for i in "$1"/* + do + if [ -d "$i" ] ; then + find_in "$i" "$f" + fi + done +} + + +####################################################################### +# Generate list of .in files (Makefile.in, config.h.in, etc) +# appending it in file configure.in + +cd ${CONF_DIR} +ABS_CONF_DIR=`pwd` + +# +# Common part of the configure.in file +# +chmod u+w configure.in.base +if ! \cp -f configure.in.base configure.in_tmp1 +then + echo + echo "error : can't create files in" ${CONF_DIR} + echo "aborting ..." + chmod u-w configure.in.base + exit +fi +chmod u-w configure.in.base + +# make a link allowing AC_OUTPUT to find the salome_adm/.../*.in files +echo "" >> configure.in_tmp1 +echo 'ln -fs ${KERNEL_ROOT_DIR}/salome_adm ${ROOT_SRCDIR}/salome_adm' >> configure.in_tmp1 + +echo "" >> configure.in_tmp1 +echo "AC_OUTPUT([ \\" >> configure.in_tmp1 + +# +# List of .in files in the adm/unix directory +# These files MUST be on top of AC_OUTPUT list so we +# put them "manually" +# + +echo " ./salome_adm/unix/SALOMEconfig.h \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/F77config.h \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/sstream \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/depend \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/make_omniorb \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/envScript \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/make_commence \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/make_conclude \\" >> configure.in_tmp1 +echo " ./salome_adm/unix/make_module \\" >> configure.in_tmp1 + +\rm -f configure.in_tmp2 configure.in_tmp3 +touch configure.in_tmp2 +find_in . configure.in_tmp2 +sed '/^.*salome_adm/d' configure.in_tmp2 > configure.in_tmp3 +sed '/configure.in/d' configure.in_tmp3 > configure.in_tmp2 +sed 's/.in / /' configure.in_tmp2 >> configure.in_tmp1 + +echo "])" >> configure.in_tmp1 + +# delete the link created for AC_OUTPUT +#echo "" >> configure.in_tmp1 +#echo 'rm -f ${ROOT_SRCDIR}/salome_adm' >> configure.in_tmp1 +\mv configure.in_tmp1 configure.in_new +\rm -f configure.in_tmp2 configure.in_tmp3 + + +######################################################################## +# Create new (or replace old) configure.in file +# Print a message if the file is write protected +# + +echo +if test ! -f configure.in +then + echo -n "Creating new file 'configure.in' ... " + if \mv configure.in_new configure.in >& /dev/null + then + echo "done" + else + echo "error, check your file permissions" + fi +else + echo -n "Updating 'configure.in' file ... " + if ! \cp configure.in configure.in_old >& /dev/null + then + echo + echo + echo "Can't backup previous configure.in" + echo -n "Continue (you will not be able to revert) - (Y/N) ? " + read R + case "x$R" in + xn*) exit;; + xN*) exit;; + esac + echo + echo -n " " + fi + if \cp configure.in_new configure.in >& /dev/null + then + echo "done" + else + echo + echo "error, can't update previous configure.in" + fi +fi + +######################################################################## +# Use autoconf to rebuild the configure script +# + +if test -f configure +then + echo -n "Updating 'configure' script ... " +else + echo -n "Creating 'configure' script ... " +fi + +aclocal --acdir=${KERNEL_ROOT_DIR}/salome_adm/unix/config_files +if autoconf +then + echo "done" +else + echo "failed (check file permissions and/or user quotas ...)" +fi + +cd ${ORIG_DIR} + +echo diff --git a/configure.in.base b/configure.in.base new file mode 100644 index 00000000..b363a0b3 --- /dev/null +++ b/configure.in.base @@ -0,0 +1,366 @@ +# +# PLEASE DO NOT MODIFY configure.in FILE +# +# ALL CHANGES WILL BE DISCARDED BY THE NEXT +# build_configure COMMAND +# +# CHANGES MUST BE MADE IN configure.in.base FILE +# +# +# Author : Marc Tajchman (CEA) +# Date : 28/06/2001 +# Modified by : Patrick GOLDBRONN (CEA) +# Modified by : Marc Tajchman (CEA) +# +# Created from configure.in.base +# + +AC_INIT(src) +AC_CONFIG_AUX_DIR(${KERNEL_ROOT_DIR}/salome_adm/unix/config_files) +AC_CANONICAL_HOST + +PACKAGE=salome +AC_SUBST(PACKAGE) + +VERSION=0.0.1 +AC_SUBST(VERSION) + +dnl +dnl Initialize source and build root directories +dnl + +ROOT_BUILDDIR=`pwd` +ROOT_SRCDIR=`echo $0 | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"` +cd $ROOT_SRCDIR +ROOT_SRCDIR=`pwd` +cd $ROOT_BUILDDIR + +AC_SUBST(ROOT_SRCDIR) +AC_SUBST(ROOT_BUILDDIR) + +echo +echo Source root directory : $ROOT_SRCDIR +echo Build root directory : $ROOT_BUILDDIR +echo +echo + +if test -z "$AR"; then + AC_CHECK_PROGS(AR,ar xar,:,$PATH) +fi +AC_SUBST(AR) + +dnl Export the AR macro so that it will be placed in the libtool file +dnl correctly. +export AR + +echo +echo --------------------------------------------- +echo testing make +echo --------------------------------------------- +echo + +AC_PROG_MAKE_SET +AC_PROG_INSTALL +dnl +dnl libtool macro check for CC, LD, NM, LN_S, RANLIB, STRIP + pour les librairies dynamiques ! + +AC_ENABLE_DEBUG(yes) +AC_DISABLE_PRODUCTION + +echo --------------------------------------------- +echo testing libtool +echo --------------------------------------------- + +dnl first, we set static to no! +dnl if we want it, use --enable-static +AC_ENABLE_STATIC(no) + +AC_LIBTOOL_DLOPEN +AC_PROG_LIBTOOL + +dnl Fix up the INSTALL macro if it s a relative path. We want the +dnl full-path to the binary instead. +case "$INSTALL" in + *install-sh*) + INSTALL='\${KERNEL_ROOT_DIR}'/salome_adm/unix/config_files/install-sh + ;; +esac + +echo +echo --------------------------------------------- +echo testing C/C++ +echo --------------------------------------------- +echo + +cc_ok=no +dnl inutil car libtool +dnl AC_PROG_CC +AC_PROG_CXX +AC_DEPEND_FLAG +# AC_CC_WARNINGS([ansi]) +cc_ok=yes + +dnl Library libdl : +AC_CHECK_LIB(dl,dlopen) + +dnl add library libm : +AC_CHECK_LIB(m,ceil) + +dnl +dnl Well we use sstream which is not in gcc pre-2.95.3 +dnl We must test if it exists. If not, add it in include ! +dnl + +AC_CXX_HAVE_SSTREAM + +dnl +dnl --------------------------------------------- +dnl testing MPICH +dnl --------------------------------------------- +dnl + +CHECK_MPICH + +echo +echo --------------------------------------------- +echo testing LEX \& YACC +echo --------------------------------------------- +echo + +lex_yacc_ok=no +AC_PROG_YACC +AC_PROG_LEX +lex_yacc_ok=yes + +echo +echo --------------------------------------------- +echo testing python +echo --------------------------------------------- +echo + +CHECK_PYTHON + +echo +echo --------------------------------------------- +echo testing java +echo --------------------------------------------- +echo + +CHECK_JAVA + +echo +echo --------------------------------------------- +echo testing swig +echo --------------------------------------------- +echo + +CHECK_SWIG + +echo +echo --------------------------------------------- +echo testing threads +echo --------------------------------------------- +echo + +ENABLE_PTHREADS + +echo +echo --------------------------------------------- +echo testing omniORB +echo --------------------------------------------- +echo + +CHECK_OMNIORB + +echo +echo --------------------------------------------- +echo testing mico +echo --------------------------------------------- +echo + +CHECK_MICO + +echo +echo --------------------------------------------- +echo default ORB : omniORB +echo --------------------------------------------- +echo + +DEFAULT_ORB=omniORB +CHECK_CORBA + +AC_SUBST_FILE(CORBA) +corba=make_$ORB +CORBA=salome_adm/unix/$corba + +echo +echo --------------------------------------------- +echo testing openGL +echo --------------------------------------------- +echo + +CHECK_OPENGL + +echo +echo --------------------------------------------- +echo testing QT +echo --------------------------------------------- +echo + +CHECK_QT + +echo +echo --------------------------------------------- +echo testing VTK +echo --------------------------------------------- +echo + +CHECK_VTK + +echo +echo --------------------------------------------- +echo testing HDF5 +echo --------------------------------------------- +echo + +CHECK_HDF5 + +echo +echo --------------------------------------------- +echo testing MED2 +echo --------------------------------------------- +echo + +CHECK_MED2 + +echo +echo --------------------------------------------- +echo Testing OpenCascade +echo --------------------------------------------- +echo + +CHECK_CAS + +echo +echo --------------------------------------------- +echo Testing qwt +echo --------------------------------------------- +echo + +CHECK_QWT + +echo +echo --------------------------------------------- +echo Testing Kernel +echo --------------------------------------------- +echo + +CHECK_KERNEL + +echo +echo --------------------------------------------- +echo Summary +echo --------------------------------------------- +echo + +echo Configure +variables="cc_ok lex_yacc_ok python_ok java_ok swig_ok threads_ok OpenGL_ok qt_ok vtk_ok hdf5_ok med2_ok omniORB_ok mico_ok occ_ok qwt_ok Kernel_ok" + +for var in $variables +do + printf " %10s : " `echo \$var | sed -e "s,_ok,,"` + eval echo \$$var +done + +echo +echo "Default ORB : $DEFAULT_ORB" +echo + +dnl generals files which could be included in every makefile + +AC_SUBST_FILE(COMMENCE) COMMENCE=salome_adm/unix/make_commence +AC_SUBST_FILE(CONCLUDE) CONCLUDE=salome_adm/unix/make_conclude +AC_SUBST_FILE(MODULE) MODULE=salome_adm/unix/make_module + +dnl les dependences +AC_SUBST_FILE(DEPEND) DEPEND=salome_adm/unix/depend + +dnl We don t need to say when we re entering directories if we re using +dnl GNU make becuase make does it for us. +if test "X$GMAKE" = "Xyes"; then + AC_SUBST(SETX) SETX=":" +else + AC_SUBST(SETX) SETX="set -x" +fi + +# make other build directories +for rep in salome_adm adm_local doc bin/salome include/salome lib/salome share/salome/resources share/salome/doc idl +do +# if test ! -d $rep ; then +# eval mkdir $rep +# fi + $INSTALL -d $rep +done + +echo +echo --------------------------------------------- +echo copying resource files, shell scripts, and +echo xml files +echo --------------------------------------------- +echo + + +dnl copy resources directories + +#for i in `find $ROOT_SRCDIR -name 'resources' -print` +#do +# local_res=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"` +# local_res_dir=`echo $local_res | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"` +# mkdir -p $local_res_dir +# cd $local_res_dir +# ln -fs $i +# echo $local_res +# cd $ROOT_BUILDDIR +#done + +dnl copy shells and utilities contained in the bin directory +dnl excluding .in files (treated in AC-OUTPUT below) and CVS +dnl directory + +cd bin +for i in $ROOT_SRCDIR/bin/* +do + local_bin=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"` + case "$local_bin" in + *.in | *~) ;; + ./bin/CVS) ;; + *) ln -fs $i; echo $local_bin ;; + esac +done +cd $ROOT_BUILDDIR + +AC_SUBST_FILE(ENVSCRIPT) ENVSCRIPT=salome_adm/unix/envScript + +dnl copy xml files to the build tree (lib directory) +dnl pourquoi ???? + +#cd lib +#for i in `find $ROOT_SRCDIR -name "*.xml" -print` +#do +# ln -fs $i +# echo `echo $i | sed -e "s,$ROOT_SRCDIR,.,"` +#done +#cd $ROOT_BUILDDIR + + +echo +echo --------------------------------------------- +echo generating Makefiles and configure files +echo --------------------------------------------- +echo + +AC_OUTPUT_COMMANDS([ \ + chmod +x ./bin/* \ +]) + +## do not delete this line diff --git a/idl/Makefile.in b/idl/Makefile.in new file mode 100644 index 00000000..98f8e070 --- /dev/null +++ b/idl/Makefile.in @@ -0,0 +1,74 @@ +# +# generate dependencies for idl file : +# + +# source path +top_srcdir=@top_srcdir@ +top_builddir=.. +srcdir=@srcdir@ +VPATH=.:$(srcdir):${KERNEL_ROOT_DIR}/idl/salome:${MED_ROOT_DIR}/idl/salome + +@COMMENCE@ + +IDL_FILES = \ + SALOME_Component.idl \ + SALOMEDS.idl \ + SALOMEDS_Attributes.idl \ + SALOME_Exception.idl \ + Logger.idl \ + SALOME_ModuleCatalog.idl \ + SALOME_Session.idl \ + VISU_Gen.idl \ + MED.idl \ + Med_Gen.idl + +PY_CLIENT_IDL = $(IDL_FILES) + +# we copy all idl file in $(top_builddir)/idl +inc: $(IDL_FILES:%=$(top_builddir)/idl/%) + +$(IDL_FILES:%=$(top_builddir)/idl/%):$(top_builddir)/idl/%:% +# $(CP) $< $@ + cp -f $< $@ + + +lib: pyidl + +PYTHON_BUILD_SITE=$(top_builddir)/lib/python$(PYTHON_VERSION)/site-packages/@PACKAGE@ + +pyidl: $(PYTHON_BUILD_SITE) $(IDL_FILES:%.idl=$(PYTHON_BUILD_SITE)/%_idl.py) + +$(PYTHON_BUILD_SITE): + $(INSTALL) -d $@ + +$(PYTHON_BUILD_SITE)/%_idl.py: %.idl + $(OMNIORB_IDL) $(OMNIORB_IDLPYFLAGS) -C$(PYTHON_BUILD_SITE) $< + + +# install python client (generated from idl file +install: install-pyidl install-idl + +# create directory $(idldir) and copy idl files into it +install-idl: $(IDL_FILES) + $(INSTALL) -d $(idldir) + $(INSTALL_DATA) $^ $(idldir) + + +install-pyidl: $(IDL_FILES) + $(INSTALL) -d $(PYTHON_SITE_INSTALL) + @for file in $^ dummy; do \ + if [ $$file != "dummy" ]; then \ + $(OMNIORB_IDL) $(OMNIORB_IDLPYFLAGS) -C$(PYTHON_SITE_INSTALL) $$file ; \ + fi ; \ + done ; + +#@ CONCLUDE @ + +cleandep: + -$(RM) .dep* + +distclean: + -$(RM) *.py + -$(RM) $(IDL_FILES:%=$(top_builddir)/idl/%) + -$(RM) Makefile + diff --git a/idl/VISU_Gen.idl b/idl/VISU_Gen.idl new file mode 100644 index 00000000..fa970874 --- /dev/null +++ b/idl/VISU_Gen.idl @@ -0,0 +1,939 @@ +// File : VISU_Gen.idl +// Created : +// Author : Alexey Petrov +// Project : SALOME +// Copyright : OPEN CASCADE +// $HEADERS: + +/*! \file VISU_Gen.idl This file conatins a set of interfaces of %VISU module. + This module will provide various forms of data visualization in %SALOME application. + These forms include data tables, XY plots, 3d representations + and combination of these forms. +*/ +/*! + \defgroup Visu SALOME VISU module +*/ + +#ifndef __VISU_GEN__ +#define __VISU_GEN__ + +#include "SALOME_Exception.idl" +#include "SALOME_Component.idl" +#include "SALOMEDS.idl" +#include "SALOMEDS_Attributes.idl" +#include "MED.idl" + +/*! \ingroup Visu + The main package of interfaces of the module %VISU. +*/ +module VISU { + //------------------------------------------------------- + const string VISU__doc__ = "Module VISU provides various forms of data visualization in SALOME application.\nThese forms include data tables, XY plots,\n3d representations and combination of these forms."; + typedef string IdType; + enum Scaling{ LINEAR, LOGARITHMIC}; + enum Entity{ NODE, EDGE, FACE, CELL}; + //enum Entity{ CELL, FACE, EDGE, NODE}; +/*! + This enumeration contains a set of elements defining the type of the module. +*/ + enum VISUType{ TNONE, + TCURVE, TTABLE, TCONTAINER, TMESH, TSCALARMAP, + TISOSURFACE, TDEFORMEDSHAPE, TCUTPLANES, TVECTORS, TSTREAMLINES, + TVISUGEN, TVIEWMANAGER, TRESULT, + TXYPLOT, TTABLEVIEW, TVIEW3D, + TENTITY, TFAMILY, TGROUP, TFIELD, TTIMESTAMP, + TALL}; + interface Base { +/*! + Returns ID of the object. +*/ + IdType GetID(); + const string GetID__doc__ = "Returns ID of the object."; +/*! +Returns the type of the presentable object +*/ + VISUType GetType(); + const string GetType__doc__ = "Returns the type of the module interface"; + }; +/*! \brief Presentable object interface + + It is the root class of all presentable objects. +*/ + interface PrsObject : Base{ + }; + const string PrsObject__doc__ = "It is the root class of all presentable objects."; + //------------------------------------------------------- +/*! \brief %Table representation interface + +Presentation parameters of the %Table view. +*/ + interface Table : PrsObject { +/*! +Sets the title of the table. +*/ + void SetTitle(in string theTitle); + const string SetTitle__doc__ = "Sets the title of the table."; +/*! +Gets the title of the table. +*/ + string GetTitle(); + const string GetTitle__doc__ = "Gets the title of the table."; +/*! + This enumeration contains a set of elements defining the orientation of the table. +*/ + enum Orientation{ HORIZONTAL, /*!Returns nil if there are no views currently opened. +*/ + + View GetCurrentView(); + const string GetCurrentView__doc__ = "Getting an active View Frame.\nReturns an object reference to the active view frame."; +/*! \brief Creation of a 3d %View. + + Returns an object reference to the newly created 3d %View. +*/ + View3D Create3DView(); + const string Create3DView__doc__ = "Creation of a 3d view.\nReturns an object reference to the newly created 3d view."; + + TableView CreateTableView(in Table theTable); + + const string CreateTableView__doc__ = "Creation of a table view.\nReturns an object reference to the newly created table view."; + XYPlot CreateXYPlot(); + + const string CreateXYPlot__doc__ = "Creation of a 2d view.\nReturns an object reference to the newly created XYPlot view."; + void Destroy(in View theView); + + const string Destroy__doc__ = "Destroying of the view"; + + + }; + const string ViewManager__doc__ = "The ViewManager interface is necessary for work\nwith view windows (creation and deletion)."; +}; +#endif + + diff --git a/resources/ModuleVisu.png b/resources/ModuleVisu.png new file mode 100644 index 00000000..7990d934 Binary files /dev/null and b/resources/ModuleVisu.png differ diff --git a/resources/VISU_en.xml b/resources/VISU_en.xml new file mode 100644 index 00000000..121d7122 --- /dev/null +++ b/resources/VISU_en.xml @@ -0,0 +1,107 @@ + + + + + + + + title="Visu component" + date="24/07/2001" + author="Laurent CORNABE" + appId="Visu for Salome" > + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/VISU_fr.xml b/resources/VISU_fr.xml new file mode 100644 index 00000000..7ff81e22 --- /dev/null +++ b/resources/VISU_fr.xml @@ -0,0 +1,103 @@ + + + + + + + + title="Visu component" + date="24/07/2001" + author="Laurent CORNABE" + appId="Visu for Salome" > + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/Visu_anim.png b/resources/Visu_anim.png new file mode 100644 index 00000000..86a5ffb9 Binary files /dev/null and b/resources/Visu_anim.png differ diff --git a/resources/Visu_cutplane.png b/resources/Visu_cutplane.png new file mode 100644 index 00000000..5e92cf65 Binary files /dev/null and b/resources/Visu_cutplane.png differ diff --git a/resources/Visu_deformed.png b/resources/Visu_deformed.png new file mode 100644 index 00000000..def8c330 Binary files /dev/null and b/resources/Visu_deformed.png differ diff --git a/resources/Visu_deformed_anim.png b/resources/Visu_deformed_anim.png new file mode 100644 index 00000000..4cee8007 Binary files /dev/null and b/resources/Visu_deformed_anim.png differ diff --git a/resources/Visu_eraseall.png b/resources/Visu_eraseall.png new file mode 100644 index 00000000..9cf15188 Binary files /dev/null and b/resources/Visu_eraseall.png differ diff --git a/resources/Visu_isosurfaces.png b/resources/Visu_isosurfaces.png new file mode 100644 index 00000000..2946029d Binary files /dev/null and b/resources/Visu_isosurfaces.png differ diff --git a/resources/Visu_plot2d.png b/resources/Visu_plot2d.png new file mode 100644 index 00000000..e6d2089f Binary files /dev/null and b/resources/Visu_plot2d.png differ diff --git a/resources/Visu_plot3d.png b/resources/Visu_plot3d.png new file mode 100644 index 00000000..ea7b5745 Binary files /dev/null and b/resources/Visu_plot3d.png differ diff --git a/resources/Visu_points.png b/resources/Visu_points.png new file mode 100644 index 00000000..92d535ba Binary files /dev/null and b/resources/Visu_points.png differ diff --git a/resources/Visu_sameas.png b/resources/Visu_sameas.png new file mode 100644 index 00000000..3611ef44 Binary files /dev/null and b/resources/Visu_sameas.png differ diff --git a/resources/Visu_scalars.png b/resources/Visu_scalars.png new file mode 100644 index 00000000..f048e920 Binary files /dev/null and b/resources/Visu_scalars.png differ diff --git a/resources/Visu_scalars_anim.png b/resources/Visu_scalars_anim.png new file mode 100644 index 00000000..e6188160 Binary files /dev/null and b/resources/Visu_scalars_anim.png differ diff --git a/resources/Visu_scaling.png b/resources/Visu_scaling.png new file mode 100644 index 00000000..5d344363 Binary files /dev/null and b/resources/Visu_scaling.png differ diff --git a/resources/Visu_selectall.png b/resources/Visu_selectall.png new file mode 100644 index 00000000..ec589031 Binary files /dev/null and b/resources/Visu_selectall.png differ diff --git a/resources/Visu_selectionactor.png b/resources/Visu_selectionactor.png new file mode 100644 index 00000000..6d6cdfbd Binary files /dev/null and b/resources/Visu_selectionactor.png differ diff --git a/resources/Visu_selectioncell.png b/resources/Visu_selectioncell.png new file mode 100644 index 00000000..f83268fe Binary files /dev/null and b/resources/Visu_selectioncell.png differ diff --git a/resources/Visu_selectionedge.png b/resources/Visu_selectionedge.png new file mode 100644 index 00000000..bd6d9df9 Binary files /dev/null and b/resources/Visu_selectionedge.png differ diff --git a/resources/Visu_selectionpoint.png b/resources/Visu_selectionpoint.png new file mode 100644 index 00000000..0ac7cd43 Binary files /dev/null and b/resources/Visu_selectionpoint.png differ diff --git a/resources/Visu_selectonly.png b/resources/Visu_selectonly.png new file mode 100644 index 00000000..3d7b24ea Binary files /dev/null and b/resources/Visu_selectonly.png differ diff --git a/resources/Visu_streamlines.png b/resources/Visu_streamlines.png new file mode 100644 index 00000000..344ca199 Binary files /dev/null and b/resources/Visu_streamlines.png differ diff --git a/resources/Visu_surface.png b/resources/Visu_surface.png new file mode 100644 index 00000000..98de1fdb Binary files /dev/null and b/resources/Visu_surface.png differ diff --git a/resources/Visu_tree_visu.png b/resources/Visu_tree_visu.png new file mode 100644 index 00000000..56ce446c Binary files /dev/null and b/resources/Visu_tree_visu.png differ diff --git a/resources/Visu_vectors.png b/resources/Visu_vectors.png new file mode 100644 index 00000000..caac1595 Binary files /dev/null and b/resources/Visu_vectors.png differ diff --git a/resources/Visu_wireframe.png b/resources/Visu_wireframe.png new file mode 100644 index 00000000..8406b9b9 Binary files /dev/null and b/resources/Visu_wireframe.png differ diff --git a/src/Makefile.in b/src/Makefile.in new file mode 100644 index 00000000..d01b6f40 --- /dev/null +++ b/src/Makefile.in @@ -0,0 +1,20 @@ +#============================================================================== +# File : Makefile.in +# Created : ven déc 7 13:32:20 CET 2001 +# Author : Paul RASCLE, EDF +# Project : SALOME +# Copyright : EDF 2001 +# $Header$ +#============================================================================== + +# source path +top_srcdir=@top_srcdir@ +top_builddir=.. +srcdir=@srcdir@ +VPATH=.:@srcdir@ + +@COMMENCE@ + +SUBDIRS = OBJECT VISU_I VISUGUI VISU_SWIG + +@MODULE@ diff --git a/src/OBJECT/Makefile.in b/src/OBJECT/Makefile.in new file mode 100644 index 00000000..54a6cbcf --- /dev/null +++ b/src/OBJECT/Makefile.in @@ -0,0 +1,33 @@ +# source path +top_srcdir=@top_srcdir@ +top_builddir=../.. +srcdir=@srcdir@ +VPATH=.:$(srcdir):$(top_srcdir)/idl:$(top_builddir)/idl + + +@COMMENCE@ + +EXPORT_HEADERS = VISU_Actor.h + + +# Libraries targets + +LIB = libVisuObject.la +LIB_SRC = VISU_Actor.cxx + +LIB_CLIENT_IDL = + +# Executables targets +BIN = +BIN_SRC = + +CPPFLAGS+=$(QT_INCLUDES) $(PYTHON_INCLUDES) $(OCC_INCLUDES) $(VTK_INCLUDES) \ + $(OGL_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome +LDFLAGS+=$(QT_MT_LIBS) $(OCC_LIBS) $(VTK_LIBS) $(OGL_LIBS) $(PYTHON_LIBS) \ + -lSalomeObject -L${KERNEL_ROOT_DIR}/lib/salome + +%_moc.cxx: %.h + $(MOC) $< -o $@ + + +@CONCLUDE@ diff --git a/src/OBJECT/VISU_Actor.cxx b/src/OBJECT/VISU_Actor.cxx new file mode 100644 index 00000000..a94fb9df --- /dev/null +++ b/src/OBJECT/VISU_Actor.cxx @@ -0,0 +1,118 @@ +using namespace std; +// File : VISU_Actor.cxx +// Created : Wed Feb 20 18:04:42 CET 2002 +// Author : Laurent CORNABE with help of Nicolas REJNERI +// Project : SALOME +// Module : VISU +// Copyright : PRINCIPIA RD +// $Header$ + +#include "VISU_Actor.h" +#include "utilities.h" + +// VTK Includes +#include + +VISU_Actor* VISU_Actor::New(){ + vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_Actor"); + if(ret) return (VISU_Actor*)ret; + return new VISU_Actor; +} +VISU_Actor::VISU_Actor(){ + this->Device = vtkActor::New(); + + this->EdgeDevice = NULL; + //this->EdgeDevice = SALOME_Actor::New(); + //EdgeDevice->VisibilityOff(); + //EdgeDevice->PickableOff(); + + this->DataSource = NULL; + myScalarBar = NULL; + this->myIO = NULL; + this->myName = ""; + this->IsDefined = false; + this->IsShrunk = false; + this->IsShrinkable = false; + this->VisuActorType = 0; + this->Presentation = NULL; + myHasScalarBar = false; + this->HighlightProperty = NULL; + this->ishighlighted = false; + this->IsHighlighting = true; + this->ResultAtNode = false; + this->VectorComponent = -1; + for (int i=0; i<6; i++) + this->VABounds[i] = 0.; + strcpy(this->FieldName,""); +} + + +VISU_Actor::~VISU_Actor() +{ + if (EdgeDevice != NULL) + this->EdgeDevice->Delete(); +} + + +void VISU_Actor::setScalarBar(VISU_ScalarBarActor* theBar) { + if (theBar) { + myScalarBar = theBar; + myHasScalarBar = true; + } else { + myScalarBar = NULL; + myHasScalarBar = false; + } +} + + +void VISU_Actor::setActor(vtkActor *Actor){ + this->Device=Actor; +} + +void VISU_Actor::ShallowCopy(vtkProp *prop){ + VISU_Actor *f = VISU_Actor::SafeDownCast(prop); + if ( f != NULL ) + { + setName( f->getName() ); + if ( f->hasIO() ) + setIO( f->getIO() ); + } + SALOME_Actor::ShallowCopy(prop); +} + +void VISU_Actor::highlight(Standard_Boolean highlight) { + if (this->IsHighlighting) { + if(highlight && !ishighlighted) { + ishighlighted=true; + // build highlight property is necessary + if(HighlightProperty==NULL) { + HighlightProperty = vtkProperty::New(); + HighlightProperty->SetAmbient(0.5); + HighlightProperty->SetDiffuse(0.3); + HighlightProperty->SetSpecular(0.2); + HighlightProperty->SetRepresentationToSurface(); + HighlightProperty->SetAmbientColor(1, 1, 1); + HighlightProperty->SetDiffuseColor(1, 1, 1); + HighlightProperty->SetSpecularColor(0.5, 0.5, 0.5); + } + this->Property = HighlightProperty; + }else if (!highlight) { + if(ishighlighted) { + ishighlighted=false; + } + } + } +} + + +void VISU_Actor::setVABounds(const float bounds[6]){ + for (int i=0; i<6; i++) + VABounds[i] = bounds[i]; +} + + +void VISU_Actor::getVABounds(float bounds[6]){ + for (int i=0; i<6; i++) + bounds[i] = VABounds[i]; +} + diff --git a/src/OBJECT/VISU_Actor.h b/src/OBJECT/VISU_Actor.h new file mode 100644 index 00000000..298f25cb --- /dev/null +++ b/src/OBJECT/VISU_Actor.h @@ -0,0 +1,110 @@ +// File : VISU_Actor.h +// Created : Wed Feb 20 18:04:42 CET 2002 +// Author : Laurent CORNABE with the help of Nicolas REJNERI +// Project : SALOME +// Module : VISU +// Copyright : PRINCIPIA RD +// $Header$ + + +#ifndef VISU_ACTOR_H +#define VISU_ACTOR_H + +#include "SALOME_Actor.h" + +#include +// VTK Includes +#include +#include +#include +#include +#include + +#ifdef _WIN_32 +#define VTKOCC_EXPORT __declspec (dllexport) +#else +#define VTKOCC_EXPORT +#endif + +#define VisuActorType_Mesh 1 +#define VisuActorType_BoundingBox 2 +#define VisuActorType_DeformedShape 3 +#define VisuActorType_Vectors 4 +#define VisuActorType_ScalarMap 5 +#define VisuActorType_IsoSurfaces 6 +#define VisuActorType_CutPlanes 7 +#define VisuActorType_Plot2D 8 +#define VisuActorType_StreamLines 9 + + + +namespace VISU { + class Prs3d_i; +} + +class VISU_ScalarBarActor; + +class VTKOCC_EXPORT VISU_Actor : public SALOME_Actor { + friend class VISU::Prs3d_i; + public: + vtkTypeMacro(VISU_Actor,SALOME_Actor); + + Standard_Boolean IsHighlighting; + + static VISU_Actor* New(); + + void setActor(vtkActor *Actor); + + void ShallowCopy(vtkProp *prop); + + void highlight(Standard_Boolean highlight); + Standard_Boolean isHighlighted() { return true; }; + + void SetOpacity(float opa) {}; + float GetOpacity() + { return 0;}; + + Standard_Boolean HasScalarBar() + { return myHasScalarBar; } + + void setScalarBar(VISU_ScalarBarActor* theBar); + VISU_ScalarBarActor* getScalarBar() + { return myScalarBar; } + + + void setIO(const Handle(SALOME_InteractiveObject)& io) + { SALOME_Actor::setIO(io); myName = io->getName(); } + + + VISU::Prs3d_i* getPrs3d() { return Presentation; } + void setPrs3d(VISU::Prs3d_i* thePrs) { Presentation = thePrs; } + + vtkDataSet *DataSource; + VISU_Actor* EdgeDevice; + + Standard_Boolean IsShrinkable; + Standard_Boolean IsShrunk; + int VisuActorType; + Standard_Boolean ResultAtNode; + int VectorComponent; + char FieldName[40]; + + Standard_Boolean IsDefined; + + float VABounds[6]; + void setVABounds(const float bounds[6]); + void getVABounds(float bounds[6]); + + ~VISU_Actor(); + protected: + VISU_Actor(); + + Standard_Boolean myHasScalarBar; + VISU_ScalarBarActor* myScalarBar; + VISU::Prs3d_i* Presentation; + + private: + vtkProperty* HighlightProperty; + +}; +#endif //VISU_ACTOR_H diff --git a/src/VISU_I/Makefile.in b/src/VISU_I/Makefile.in new file mode 100644 index 00000000..f1180d0e --- /dev/null +++ b/src/VISU_I/Makefile.in @@ -0,0 +1,65 @@ +# -* Makefile *- +# +# Author : Alexey Petrov +# Date : +# $Header: +# + +# source path +top_srcdir=@top_srcdir@ +top_builddir=../.. +srcdir=@srcdir@ +VPATH=.:$(srcdir):$(top_srcdir)/idl:$(top_builddir)/idl + + +@COMMENCE@ + +# Libraries targets +LIB = libVISUEngine.la +LIB_SRC = VISU_Gen_i.cc VISU_Result_i.cc \ + VISU_PrsObject_i.cc VISU_ViewManager_i.cc VISU_Table_i.cc \ + VISU_Extractor.cxx VISU_FieldTransform.cxx \ + VISU_Convertor.cxx VISU_MedConvertor.cxx VISU_DatConvertor.cxx \ + VISU_Convertor_impl.cxx VISU_CorbaMedConvertor.cxx \ + VISU_LookupTable.cxx VISU_ScalarBarActor.cxx \ + VISU_TimeAnimation.cxx + +LIB_MOC = VISU_TimeAnimation.h + +LIB_SERVER_IDL = VISU_Gen.idl SALOME_Component.idl SALOME_Exception.idl SALOME_Session.idl MED.idl +LIB_CLIENT_IDL = SALOMEDS.idl SALOMEDS_Attributes.idl + +# Executables targets +BIN = VISU_Convertor +BIN_SRC = VISU_Convertor_impl.cxx VISU_MedConvertor.cxx +#BIN_SRC = VISU_Convertor_impl.cxx VISU_MedConvertor.cxx VISU_DatConvertor.cxx +#BIN = VISU_Convertor +#BIN_SRC = VISU_Convertor_impl.cxx VISU_MedConvertor.cxx VISU_DatConvertor.cxx \ +# VISU_LookupTable.cxx VISU_ScalarBarActor.cxx + +BIN_CLIENT_IDL = +BIN_SERVER_IDL = + +EXPORT_HEADERS = VISUConfig.hh VISU_Gen_i.hh VISU_Result_i.hh \ + VISU_PrsObject_i.hh VISU_ViewManager_i.hh VISU_Table_i.hh \ + VISU_Extractor.hxx VISU_FieldTransform.hxx VISU_Convertor.hxx \ + VISU_LookupTable.hxx VISU_ScalarBarActor.hxx \ + VISU_TimeAnimation.h +# additionnal information to compil and link file +CPPFLAGS += -ftemplate-depth-32 $(QT_INCLUDES) $(PYTHON_INCLUDES) $(OCC_INCLUDES) $(VTK_INCLUDES) \ + $(MED2_INCLUDES) $(HDF5_INCLUDES) $(QWT_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome +LDFLAGS += $(QT_MT_LIBS) $(OCC_LIBS) $(VTK_LIBS) $(QWT_LIBS) -lSalomeNS -lSalomeDS \ + -lSalomeContainer -lOpUtil -lSalomeGUI -lVTKViewer -lVisuObject \ + -L${KERNEL_ROOT_DIR}/lib/salome + +LIBS+= $(PYTHON_LIBS) $(MED2_LIBS) $(HDF5_LIBS) -lPlot2d -lSalomeHDFPersist -lSalomeLoggerServer -lRegistry -lqsplitterP -lSalomeLifeCycleCORBA -lSalomeObject -lSalomeNotification -L${KERNEL_ROOT_DIR}/lib/salome + +# additional file to be cleaned +MOSTLYCLEAN = +CLEAN = +DISTCLEAN = + +@CONCLUDE@ + + + diff --git a/src/VISU_I/VISUConfig.hh b/src/VISU_I/VISUConfig.hh new file mode 100644 index 00000000..9b73f059 --- /dev/null +++ b/src/VISU_I/VISUConfig.hh @@ -0,0 +1,105 @@ +// File: VISU_Common.hh +// Created: Tue Dec 24 17:13:35 2002 +// Author: Alexey PETROV +// + +#ifndef __VISU_CONFIG_H__ +#define __VISU_CONFIG_H__ + +// standard C++ headers +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +// IDL headers +#include +#include CORBA_SERVER_HEADER(VISU_Gen) +#include CORBA_SERVER_HEADER(MED) +#include CORBA_SERVER_HEADER(SALOMEDS) +#include CORBA_SERVER_HEADER(SALOMEDS_Attributes) +#include "SALOME_NamingService.hxx" +#include "SALOME_LifeCycleCORBA.hxx" +#include "Utils_CorbaException.hxx" +#include "utilities.h" + +#include +#include + +namespace VISU{ + //=========================================================================== + class VISU_Gen_i; + class Base_i : public virtual POA_VISU::Base, + public virtual PortableServer::RefCountServantBase + { + public: + virtual ~Base_i(); + virtual char* GetID(); + virtual VISU::VISUType GetType()=0; + protected: + static QMutex* myMutex; + static CORBA::ORB_var myOrb; + static PortableServer::POA_var myPOA; + static SALOME_NamingService* myNamingService; + static VISU_Gen_i* myVisuGenImpl; + static SALOME_LifeCycleCORBA* myEnginesLifeCycle; + public: + static CORBA::ORB_ptr GetORB() { return myOrb;} + static PortableServer::POA_ptr GetPOA() { return myPOA;} + static SALOME_NamingService* GetNS() { return myNamingService;} + static SALOME_LifeCycleCORBA* GetLCC() { return myEnginesLifeCycle;} + static VISU_Gen_i* GetVisuGenImpl() { return myVisuGenImpl;} + static VISU_Gen_var GetVisuGenInter(); + }; + //=========================================================================== + class Mutex{ + QMutex* myMutex; + QApplication* myQApp; + int isQAppLocked, isSessionLocked; + public: + Mutex(QMutex* theMutex, QApplication* theQApp); + ~Mutex(); + }; + //=========================================================================== + class Storable : public virtual Base_i { + protected: + virtual void ToStream(ostrstream& theStr) = 0; + public: + string ToString(); + virtual const char* GetComment() const = 0; + typedef map TRestoringMap; + typedef Storable* (*TStorableEngine)(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const TRestoringMap& theMap); + typedef map TCallbackMap; + static void Registry(const char* theComment, TStorableEngine theEngine) + throw(std::logic_error&); + static Storable* Create(SALOMEDS::SObject_ptr, const string& thePrefix, const string& theString) + throw(std::runtime_error&); + static const QString& FindValue(const TRestoringMap& theMap, const string& theArg, bool* isFind = NULL) + throw(std::logic_error&); + static void StrToMap(const QString& theStr, VISU::Storable::TRestoringMap& theMap); + static SALOMEDS::SObject_ptr GetResultSO(SALOMEDS::SObject_ptr theSObject); + static void DataToStream(ostrstream& theStr, const QString& theName, const QString& theVal); + static void DataToStream(ostrstream& theStr, const QString& theName, const int theVal); + static void DataToStream(ostrstream& theStr, const QString& theName, const double theVal); + }; + //=========================================================================== + const CORBA::Boolean IsMultifile(); + PortableServer::Servant GetServant(CORBA::Object_ptr theObject); + CORBA::Object_var SObjectToObject(SALOMEDS::SObject_ptr theSObject); + SALOMEDS::SComponent_var FindOrCreateVisuComponent(SALOMEDS::Study_ptr theStudyDocument); + string CreateAttributes(SALOMEDS::Study_ptr theStudyDocument, + const char* theFatherEntry, const char* theRefFatherEntry, + const char* theIOR, const char* theName, + const char* thePersistentRef, const char* theComment, + CORBA::Boolean theCreateNew = true); + string FindEntryWithComment(SALOMEDS::Study_ptr theStudyDocument, const char* theStartEntry, + const char* theComment, int IsAllLevels = true); +} + +#endif diff --git a/src/VISU_I/VISU_Convertor.cxx b/src/VISU_I/VISU_Convertor.cxx new file mode 100644 index 00000000..46a36f9c --- /dev/null +++ b/src/VISU_I/VISU_Convertor.cxx @@ -0,0 +1,483 @@ +using namespace std; + +// File: VISU_Convertor.cxx +// Created: Wed Jan 15 17:43:32 2003 +// Author: Alexey PETROV +// + + +#include "VISU_Convertor.hxx" +#include +#include +#include +#include +#include +#include +#include +using namespace std; + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 1; +#endif + +namespace VISU{ + TVtkCellInfoMap aVtkCellInfoMap; + static int INIT = ( + aVtkCellInfoMap[VTK_VERTEX] = TVtkCellInfo("VTK_VERTEX",1), + aVtkCellInfoMap[VTK_LINE] = TVtkCellInfo("VTK_LINE",2), + aVtkCellInfoMap[VTK_TRIANGLE] = TVtkCellInfo("VTK_TRIANGLE",3), + aVtkCellInfoMap[VTK_QUAD] = TVtkCellInfo("VTK_QUAD",4), + aVtkCellInfoMap[VTK_TETRA] = TVtkCellInfo("VTK_TETRA",4), + aVtkCellInfoMap[VTK_HEXAHEDRON] = TVtkCellInfo("VTK_HEXAHEDRON",8), + aVtkCellInfoMap[VTK_WEDGE] = TVtkCellInfo("VTK_WEDGE",6), + aVtkCellInfoMap[VTK_PYRAMID] = TVtkCellInfo("VTK_PYRAMID",5), + 1); + + pair TMeshOnEntity::GetCellsDims(const string& theFamilyName) const + throw(std::runtime_error&) + { + bool isFamilyPresent = (theFamilyName != ""); + int aNbCells = 0, aCellsSize = 0; + if(!isFamilyPresent){ + TCellsConn::const_iterator aCellsConnIter = myCellsConn.begin(); + for(; aCellsConnIter != myCellsConn.end(); aCellsConnIter++){ + const TConnForCellType& aConnForCellType = aCellsConnIter->second; + if(!aConnForCellType.empty()){ + aNbCells += aConnForCellType.size(); + aCellsSize += aConnForCellType.size()*(aConnForCellType[0].size()+1); + } + } + }else{ + TFamilyMap::const_iterator aFamilyMapIter = myFamilyMap.find(theFamilyName); + if(aFamilyMapIter == myFamilyMap.end()) + throw std::runtime_error("GetCellsDims >> There is no family on the mesh with entity !!!"); + const TFamily& aFamily = aFamilyMapIter->second; + const TFamily::TSubMesh& aSubMesh = aFamily.mySubMesh; + TFamily::TSubMesh::const_iterator aSubMeshIter = aSubMesh.begin(); + for(; aSubMeshIter != aSubMesh.end(); aSubMeshIter++){ + const TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aSubMeshIter->second; + if(!aSubMeshOnCellType.empty()){ + int tmp = aSubMeshOnCellType.size(); + aNbCells += tmp; + int aVtkType = aSubMeshIter->first; + int aVtkSize = aVtkCellInfoMap[aVtkType].mySize; + aCellsSize += tmp*(aVtkSize+1); + } + } + } + return make_pair(aNbCells,aCellsSize); + } + + void TMesh::CreateMeshOnNodes(){ + TMeshOnEntity& aMeshOnEntity = myMeshOnEntityMap[NODE_ENTITY]; + TMeshOnEntity::TConnForCellType& aConnForCellType = aMeshOnEntity.myCellsConn[VTK_VERTEX]; + int jEnd = myPointsCoord.size()/myDim; + aConnForCellType.resize(jEnd); + for (int j = 0; j < jEnd; j++) aConnForCellType[j] = TMeshOnEntity::TConnect(1,j); + } + + const TField* TMesh::GetField(const string& theFieldName) const { + TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter = myMeshOnEntityMap.begin(); + for(; aMeshOnEntityMapIter != myMeshOnEntityMap.end(); aMeshOnEntityMapIter++){ + const TFieldMap& aFieldMap = (aMeshOnEntityMapIter->second).myFieldMap; + TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin(); + for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++) + if(theFieldName == aFieldMapIter->first) return &(aFieldMapIter->second); + } + return NULL; + } + + const TFamily* GetFamily(const VISU::TMeshOnEntity& theMeshOnEntity, const string& theFamilyName) + throw(std::runtime_error&) + { + if(theFamilyName == "") return NULL; + const VISU::TFamilyMap& aFamilyMap = theMeshOnEntity.myFamilyMap; + VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.find(theFamilyName); + if(aFamilyMapIter == aFamilyMap.end()) + throw std::runtime_error("GetFamily >> There is no family on the mesh with entity !!!"); + const VISU::TFamily& aFamily = aFamilyMapIter->second; + return &aFamily; + } + + TFamily* GetFamily(VISU::TMeshOnEntity& theMeshOnEntity, const string& theFamilyName) + throw(std::runtime_error&) + { + if(theFamilyName == "") return NULL; + VISU::TFamilyMap& aFamilyMap = theMeshOnEntity.myFamilyMap; + VISU::TFamilyMap::iterator aFamilyMapIter = aFamilyMap.find(theFamilyName); + if(aFamilyMapIter == aFamilyMap.end()) + throw std::runtime_error("GetFamily >> There is no family on the mesh with entity !!!"); + VISU::TFamily& aFamily = aFamilyMapIter->second; + return &aFamily; + } + + void TField::ShallowCopy(const TField& aField){ + myEntity = aField.myEntity; + myMeshName = aField.myMeshName; + myNbComp = aField.myNbComp; + VISU::TField::TValField::const_iterator iter = aField.myValField.begin(); + for(; iter != aField.myValField.end(); iter++) + myValField[iter->first]; + } +} + +const VISU::TMeshMap& VISU_Convertor::GetMeshMap() throw(std::runtime_error&){ + if(!myIsDone) { myIsDone = true; Build();} + return myMeshMap; +} + +const VISU::TField& VISU_Convertor::GetField(const string& theMeshName, + VISU::TEntity theEntity, + const string& theFieldName) + throw (std::runtime_error&) +{ + if(!myIsDone) { myIsDone = true; Build();} + VISU::TMeshMap::const_iterator aMeshMapIter = myMeshMap.find(theMeshName); + if(aMeshMapIter == myMeshMap.end()) + throw std::runtime_error("GetField >> There is no mesh with the name !!!"); + const VISU::TMesh& aMesh = aMeshMapIter->second; + VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter = aMesh.myMeshOnEntityMap.find(theEntity); + if(aMeshOnEntityMapIter == aMesh.myMeshOnEntityMap.end()) + throw std::runtime_error("GetField >> There is no mesh with the entity !!!"); + const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second; + const VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap; + VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.find(theFieldName); + if(aFieldMapIter == aFieldMap.end()) + throw std::runtime_error("GetField >> There is no field with the name !!!"); + return aFieldMapIter->second; +} + +string VISU_Convertor::GenerateName(const VISU::TField::TTime& aTime){ + static QString aName; + const string aUnits = aTime.second, tmp(aUnits.size(),' '); + if(aUnits == "" || aUnits == tmp) + aName.sprintf("%g, ---",aTime.first); + else + aName.sprintf("%g, %s",aTime.first,aTime.second.c_str()); + aName = aName.simplifyWhiteSpace(); + return aName.latin1(); +} + +string VISU_Convertor::GenerateName(const string& theName, unsigned int theTimeId) { + static QString aName; + aName = QString(theName.c_str()).simplifyWhiteSpace(); + int iEnd = strlen(aName); + static int VtkHighLevelLength = 12; //25 + if(iEnd > VtkHighLevelLength) iEnd = VtkHighLevelLength; + char aNewName[iEnd+1]; + aNewName[iEnd] = '\0'; + strncpy(aNewName,aName,iEnd); + replace(aNewName,aNewName+iEnd,' ','_'); + if(true || theTimeId == 0) + aName = aNewName; + else + aName.sprintf("%s_%d",aNewName,theTimeId); + return aName.latin1(); +} + +void parseFile(const char* theFileName) throw(std::runtime_error&){ + try{ + auto_ptr aCon(CreateConvertor(theFileName)); + const VISU::TMeshMap& aMeshMap = aCon->GetMeshMap(); + VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin(); + for(; aMeshMapIter != aMeshMap.end(); aMeshMapIter++){ + const string& aMeshName = aMeshMapIter->first; + const VISU::TMesh& aMesh = aMeshMapIter->second; + const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap; + VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter; + //Import fields + aMeshOnEntityMapIter = aMeshOnEntityMap.begin(); + for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){ + const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first; + const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second; + const VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap; + VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin(); + for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){ + const string& aFieldName = aFieldMapIter->first; + const VISU::TField& aField = aFieldMapIter->second; + const VISU::TField::TValField& aValField = aField.myValField; + VISU::TField::TValField::const_iterator aValFieldIter = aValField.begin(); + for(; aValFieldIter != aValField.end(); aValFieldIter++){ + int aTimeStamp = aValFieldIter->first; + aCon->GetFieldOnMesh(aMeshName,anEntity,aFieldName,aTimeStamp); + } + } + } + //Importing groups + const VISU::TGroupMap& aGroupMap = aMesh.myGroupMap; + VISU::TGroupMap::const_iterator aGroupMapIter = aGroupMap.begin(); + for(; aGroupMapIter != aGroupMap.end(); aGroupMapIter++){ + const string& aGroupName = aGroupMapIter->first; + aCon->GetMeshOnGroup(aMeshName,aGroupName); + } + //Import families + aMeshOnEntityMapIter = aMeshOnEntityMap.begin(); + for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){ + const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first; + const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second; + //aCon->GetMeshOnEntity(aMeshName,anEntity); + const VISU::TFamilyMap& aFamilyMap = aMeshOnEntity.myFamilyMap; + VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.begin(); + for(; aFamilyMapIter != aFamilyMap.end(); aFamilyMapIter++){ + const string& aFamilyName = aFamilyMapIter->first; + aCon->GetMeshOnEntity(aMeshName,anEntity,aFamilyName); + } + } + //Import mesh on entity + aMeshOnEntityMapIter = aMeshOnEntityMap.begin(); + for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){ + const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first; + aCon->GetMeshOnEntity(aMeshName,anEntity); + } + } + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured in file:"< myValues; +}; + +struct TTable2D{ + string myTitle; + vector myColumnUnits; + vector myColumnTitles; + vector myRows; +}; + +vector aTables; + +int GetLine(ifstream& theStmIn, QString& theString){ + char tmp; + ostrstream aStrOut; + while(theStmIn.get(tmp)){ + aStrOut< aRet(aStrOut.str()); + theString = aRet.get(); + return !theStmIn.eof(); +} + +int main(int argc, char** argv){ + try{ + if(argc > 1){ + ifstream aStmIn; + aStmIn.open(argv[1]); + QString aTmp; + while(!aStmIn.eof()){ + //Find beginning of Table + while(GetLine(aStmIn,aTmp) && aTmp.find("#TITLE:") != 0); + if(aStmIn.eof()) return 0; + cout<<"\n There is new Table2D with Title = "; + TTable2D aTable2D; + while(!aStmIn.eof() && aTmp != "\n"){ + if(aTmp.find("#TITLE:") == 0){ + int aLen = aTmp.find(":") + 1; + aTmp.remove(0,aLen); + QString aTitle = aTmp.stripWhiteSpace(); + aTable2D.myTitle = aTitle; + cout< 0){ + QStringList aStrList = QStringList::split("#TITLE:",aTmp); + QString aTitle = aStrList[1].stripWhiteSpace(); + TRow aRow; + aRow.myTitle = aTitle; + cout< +#include +#include +#include + +#include +#include +#include +#include +#include + +int main(int argc, char** argv){ + vtkRenderWindow *renWin = vtkRenderWindow::New(); + vtkRenderer *ren = vtkRenderer::New(); + renWin->AddRenderer(ren); + ren->GetActiveCamera()->ParallelProjectionOn(); + vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); + iren->SetRenderWindow(renWin); + VISU_Convertor* aConvertor = CreateConvertor(argv[1]); + float aScalarRange[2]; + int aFieldIndex = 1, aNumberOfColors = 64, aNumberOfLabels = 5; + FieldInfo aFieldInfo = *(aConvertor->GetFieldInfo(aFieldIndex)); + VISU_Extractor *anExtractor = VISU_Extractor::New(); + anExtractor->Extract(aConvertor->GetOutput(),aFieldInfo.myName.c_str(),0, + aFieldInfo.myNumComponent,aFieldInfo.myType); + vtkUnstructuredGrid *aDataSet = anExtractor->GetUnstructuredGridOutput(); + VISU_FieldTransform* aFieldTransform = VISU_FieldTransform::New(); + aFieldTransform->SetInput(aDataSet); + if(argc > 2) + aFieldTransform->SetTransformFunction(&log10); + vtkDataSetMapper *aMapper = vtkDataSetMapper::New(); + aMapper->SetInput(aFieldTransform->GetUnstructuredGridOutput()); + aMapper->ScalarVisibilityOn(); + anExtractor->GetUnstructuredGridOutput()->GetScalarRange(aScalarRange); + + VISU_LookupTable* aActorLookupTbl = VISU_LookupTable::New(); + cout<<"aActorLookupTbl = "< 2) + aActorLookupTbl->SetLog(true); + aActorLookupTbl->SetHueRange(0.667,0.0); + aActorLookupTbl->SetNumberOfColors(aNumberOfColors); + aActorLookupTbl->SetTableRange(aScalarRange[0],aScalarRange[1]); // + aActorLookupTbl->SetMapScale(1.); + aActorLookupTbl->Build(); + aMapper->SetLookupTable(aActorLookupTbl); + aMapper->SetScalarRange(aScalarRange); + aActorLookupTbl->Delete(); + + vtkActor* aActor = vtkActor::New(); + aActor->SetMapper(aMapper); + + VISU_ScalarBarActor* aBar = VISU_ScalarBarActor::New(); + VISU_LookupTable* aBarLookupTbl = VISU_LookupTable::New(); + cout<<"aBarLookupTbl = "< 2) + aBarLookupTbl->SetLog(true); + aBarLookupTbl->SetHueRange(0.667,0.0); + aBarLookupTbl->SetNumberOfColors(aNumberOfColors); + aBarLookupTbl->SetTableRange(aScalarRange[0],aScalarRange[1]); // + aBarLookupTbl->Build(); + aBar->SetLookupTable(aBarLookupTbl); + aBarLookupTbl->Delete(); + + aBar->SetTitle((aFieldInfo.myName).c_str()); + aBar->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport(); + aBar->SetNumberOfLabels(aNumberOfLabels); + + vtkProperty* aProperty = aActor->GetProperty(); + aProperty->SetSpecularColor( 1, 1, 1); + aProperty->SetSpecular( 0.3 ); + aProperty->SetSpecularPower( 20 ); + aProperty->SetAmbient( 0.2); + aProperty->SetDiffuse( 0.8 ); + aProperty->EdgeVisibilityOn(); + + ren->AddActor(aActor); + ren->AddActor2D(aBar); + + renWin->Render(); + iren->Start(); + return 0; +} +*/ + +/* +#include +#include + +int main(int argc, char** argv){ + try{ + if(argc > 1){ + int iEnd = 1; + if(argc > 2) iEnd = atoi(argv[2]); + string aFileName("/tmp/AAA"); + ofstream stmOut(aFileName.c_str(),ios::out); + for(int i = 0; i < iEnd; i++){ + MESSAGE("\n--------------------------- "<ToString(); + } + } + return 0; + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured :\n"< + +#ifndef VISU_Convertor_HeaderFile +#define VISU_Convertor_HeaderFile + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "utilities.h" +#ifndef MESSAGE +#define MESSAGE(msg) cout< TVtkCellInfoMap; + extern TVtkCellInfoMap aVtkCellInfoMap; + + enum TEntity {NODE_ENTITY, EDGE_ENTITY, FACE_ENTITY, CELL_ENTITY}; + //enum TEntity {CELL_ENTITY, FACE_ENTITY, EDGE_ENTITY, NODE_ENTITY}; + template class vtk_ptr { + private: + _Tp* _M_ptr; + public: + typedef _Tp element_type; + explicit vtk_ptr(_Tp* __p = 0) : _M_ptr(__p) {} + vtk_ptr(const vtk_ptr& __a) : _M_ptr(0) {} + vtk_ptr(vtk_ptr& __a) : _M_ptr(__a.release()) {} + vtk_ptr& operator=(const vtk_ptr& __a) { return *this;} + vtk_ptr& operator=(vtk_ptr& __a) { + if (&__a != this) { + if(_M_ptr) _M_ptr->Delete(); + _M_ptr = __a.release(); + } + return *this; + } + ~vtk_ptr() { + if(_M_ptr) _M_ptr->Delete(); + _M_ptr = 0; + } + _Tp& operator*() const { return *_M_ptr;} + _Tp* operator->() const { return _M_ptr;} + _Tp* get() const { return _M_ptr;} + _Tp* release() { + _Tp* __tmp = _M_ptr; + _M_ptr = 0; + return __tmp; + } + void reset(_Tp* __p = 0) { + if(_M_ptr) _M_ptr->Delete(); + _M_ptr = __p; + } + }; + typedef vtk_ptr TVTKReader; + + typedef std::set TBindGroups; + + struct TFamily{ + TVTKReader myStorage; + int myId; + string myName; + TEntity myEntity; + TBindGroups myGroups; + typedef std::set TSubMeshOnCellType; + typedef std::map TSubMesh; + TSubMesh mySubMesh; + }; + typedef std::map TFamilyMap; + + struct TField{ + int myId; + string myName; + TEntity myEntity; + string myMeshName; + int myNbComp; + typedef std::vector TValForCellsWithType; + typedef std::map TValForCells; + typedef std::pair TTime; + struct TValForTime{ + TVTKReader myStorage; + int myId; + TTime myTime; + TValForCells myValForCells; + }; + typedef std::map TValField; + TValField myValField; + void ShallowCopy(const TField& aField); + }; + typedef map TFieldMap; + + struct TMeshOnEntity{ + TVTKReader myStorage; + string myMeshName; + TEntity myEntity; + typedef vector TConnect; + typedef vector TConnForCellType; + typedef map TCellsConn; + TCellsConn myCellsConn; + TFamilyMap myFamilyMap; + TFieldMap myFieldMap; + pair GetCellsDims(const string& theFamilyName = "") const + throw(std::runtime_error&); + }; + typedef std::map TMeshOnEntityMap; + const TFamily* GetFamily(const VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName) + throw(std::runtime_error&); + TFamily* GetFamily(VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName) + throw(std::runtime_error&); + + typedef std::pair TFamilyAndEntity; + typedef std::set TFamilyAndEntitySet; + struct TGroup{ + TVTKReader myStorage; + string myName; + string myMeshName; + TFamilyAndEntitySet myFamilyAndEntitySet; + }; + typedef std::map TGroupMap; + + struct TMesh{ + int myDim; + string myName; + typedef vector TPointsCoord; + TPointsCoord myPointsCoord; + TMeshOnEntityMap myMeshOnEntityMap; + TGroupMap myGroupMap; + void CreateMeshOnNodes(); + const TField* GetField(const string& theFieldName) const; + }; + typedef std::map TMeshMap; +}; + +class VISU_Convertor{ +protected: + std::string myName; + VISU::TMeshMap myMeshMap; + int myIsDone; +public: + virtual ~VISU_Convertor(){}; + virtual const string& GetName() { return myName;} + virtual int IsDone() const { return myIsDone;} + typedef vtkUnstructuredGridReader OutputType; + virtual VISU_Convertor* Build() throw (std::runtime_error&) = 0; + virtual OutputType* GetMeshOnEntity(const string& theMeshName, + const VISU::TEntity& theEntity, + const string& theFamilyName = "") + throw(std::runtime_error&) = 0; + virtual OutputType* GetMeshOnGroup(const string& theMeshName, + const string& theGroupName) + throw(std::runtime_error&) = 0; + virtual OutputType* GetFieldOnMesh(const string& theMeshName, + const VISU::TEntity& theEntity, + const string& theFieldName, + int theStampsNum) + throw(std::runtime_error&) = 0; + virtual const VISU::TMeshMap& GetMeshMap() throw(std::runtime_error&); + virtual const VISU::TField& GetField(const string& theMeshName, VISU::TEntity theEntity, + const string& theFieldName) + throw(std::runtime_error&); + static string GenerateName(const VISU::TField::TTime& aTime); + static string GenerateName(const string& theName, unsigned int theTimeId); +}; + +template std::string dtos(const string& fmt, T val){ + static QString aString; + aString.sprintf(fmt.c_str(),val); + return aString.latin1(); +} +extern "C"{ + VISU_Convertor* CreateMedConvertor(const std::string& theFileName) throw(std::runtime_error&); + VISU_Convertor* CreateDatConvertor(const std::string& theFileName) throw(std::runtime_error&); + VISU_Convertor* CreateConvertor(const std::string& theFileName) throw(std::runtime_error&); +}; + +#endif diff --git a/src/VISU_I/VISU_Convertor_impl.cxx b/src/VISU_I/VISU_Convertor_impl.cxx new file mode 100644 index 00000000..a8f0dcb1 --- /dev/null +++ b/src/VISU_I/VISU_Convertor_impl.cxx @@ -0,0 +1,427 @@ +using namespace std; + +// File: VISU_Convertor_impl.cxx +// Created: Fri Jan 10 11:44:54 2003 +// Author: Alexey PETROV +// + + +#include "VISU_Convertor_impl.hxx" + +#include +#include +#include +#include +#include +#include +using namespace std; + +#ifdef DEBUG +static int MYDEBUG = 1; +static int MYDEBUGWITHFILES = 0; +#else +static int MYDEBUG = 0; +static int MYDEBUGWITHFILES = 0; +#endif +static int PRECISION = 7; + +#define MED2VTK(MEDTYPE,VTKTYPE,VTKNBNODES) \ + {MEDTYPE,#MEDTYPE,getNbMedNodes(MEDTYPE),VTKTYPE,#VTKTYPE,VTKNBNODES} +Med2vtk med2vtk[MED_NBR_GEOMETRIE_MAILLE] = { + MED2VTK(MED_POINT1,VTK_VERTEX,1), + MED2VTK(MED_SEG2,VTK_LINE,2), + MED2VTK(MED_SEG3,VTK_LINE,2), + MED2VTK(MED_TRIA3,VTK_TRIANGLE,3), + MED2VTK(MED_TRIA6,VTK_TRIANGLE,3), + MED2VTK(MED_QUAD4,VTK_QUAD,4), + MED2VTK(MED_QUAD8,VTK_QUAD,4), + MED2VTK(MED_TETRA4,VTK_TETRA,4), + MED2VTK(MED_TETRA10,VTK_TETRA,4), + MED2VTK(MED_HEXA8,VTK_HEXAHEDRON,8), + MED2VTK(MED_HEXA20,VTK_HEXAHEDRON,8), + MED2VTK(MED_PENTA6,VTK_WEDGE,6), + MED2VTK(MED_PENTA15,VTK_WEDGE,6), + MED2VTK(MED_PYRA5,VTK_PYRAMID,5), + MED2VTK(MED_PYRA13,VTK_PYRAMID,5) +}; +#undef MED2VTK + +extern "C" { + VISU_Convertor* CreateConvertor(const string& theFileName) throw(std::runtime_error&){ + if(QFileInfo(theFileName.c_str()).extension(false) == "med") + return CreateMedConvertor(theFileName); + else + return CreateDatConvertor(theFileName); + } + + int getNbMedConnect(int theMedType, int theMedEntity, int theMeshDim){ + int anElemDim = theMedType / 100, nsup = 0; + if(theMedEntity == VISU::CELL_ENTITY && anElemDim < theMeshDim) nsup = 1; + return nsup + theMedType % 100; + } + + int getNbMedNodes(int geom){ + return geom % 100; + } + + int getIdMedType(int medType){ + for(int i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++) + if(med2vtk[i].medType == medType) return i; + return -1; + } +} + +VISU_Convertor_impl::VISU_Convertor_impl() { + myIsDone = false; +} + +VISU_Convertor_impl::~VISU_Convertor_impl() {} + +VISU_Convertor::OutputType* VISU_Convertor_impl::GetMeshOnEntity(const string& theMeshName, + const VISU::TEntity& theEntity, + const string& theFamilyName) + throw (std::runtime_error&) +{ + if(!myIsDone) { myIsDone = true; Build();} + if(MYDEBUG) + MESSAGE("GetMeshOnEntity - theMeshName = '"<> There is no mesh with the name!!!"); + VISU::TMesh& aMesh = myMeshMap[theMeshName]; + VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap; + if(aMeshOnEntityMap.find(theEntity) == aMeshOnEntityMap.end()) + throw std::runtime_error("MeshOnEntityToString >> There is no mesh on the entity!!!"); + VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMap[theEntity]; + VISU::TFamily* pFamily = VISU::GetFamily(aMeshOnEntity,theFamilyName); + VISU::TVTKReader* pReader; + if(pFamily != NULL) + pReader = &(pFamily->myStorage); + else + pReader = &(aMeshOnEntity.myStorage); + VISU::TVTKReader& aReader = *pReader; + //Main part of code + if(aReader.get() == NULL){ + LoadMeshOnEntity(aMeshOnEntity,theFamilyName); + ostrstream strOut; + strOut< aCellsDim = aMeshOnEntity.GetCellsDims(theFamilyName); + int aNbCells = aCellsDim.first, aCellsSize = aCellsDim.second; + ostrstream strCellsOut, strTypesOut; + GetCells(strCellsOut,strTypesOut,aMeshOnEntity,theFamilyName); + strCellsOut< aRet(strCellsOut.str()); + strOut<DebugOn(); + aReader->ReadFromInputStringOn(); + aRet.reset(strOut.str()); + aReader->SetInputString(aRet.get()); + //aReader->Update(); + //aReader->Print(cout); + if(MYDEBUGWITHFILES){ + string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1(); + string aFamilyName = QString(theFamilyName.c_str()).simplifyWhiteSpace().latin1(); + string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-"; + aFileName += aMeshName + dtos("-%d-",theEntity) + aFamilyName + "-Conv.vtk"; + ofstream stmOut(aFileName.c_str(),ios::out); + stmOut<> There is no mesh with the name!!!"); + VISU::TMesh& aMesh = myMeshMap[theMeshName]; + VISU::TGroupMap& aGroupMap = aMesh.myGroupMap; + VISU::TGroupMap::iterator aGroupMapIter = aGroupMap.find(theGroupName); + if(aGroupMapIter == aGroupMap.end()) + throw std::runtime_error("GetMeshOnGroup >> There is no the group in the mesh!!!"); + VISU::TGroup& aGroup = aGroupMapIter->second; + const VISU::TFamilyAndEntitySet& aFamilyAndEntitySet = aGroup.myFamilyAndEntitySet; + VISU::TVTKReader& aReader = aGroup.myStorage; + if(aReader.get() == NULL){ + LoadMeshOnGroup(aMesh,aFamilyAndEntitySet); + ostrstream strOut; + strOut< aCellsDim = aMeshOnEntity.GetCellsDims(aFamilyName); + aNbCells += aCellsDim.first; + aCellsSize += aCellsDim.second; + GetCells(strCellsOut,strTypesOut,aMeshOnEntity,aFamilyName); + } + strCellsOut< aRet(strCellsOut.str()); + strOut<ReadFromInputStringOn(); + aRet.reset(strOut.str()); + aReader->SetInputString(aRet.get()); + if(MYDEBUGWITHFILES){ + string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1(); + string aGroupName = QString(theGroupName.c_str()).simplifyWhiteSpace().latin1(); + string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-"; + aFileName += aMeshName + "-" + aGroupName + "-Conv.vtk"; + ofstream stmOut(aFileName.c_str(),ios::out); + stmOut<> There is no mesh with the name!!!"); + VISU::TMesh& aMesh = myMeshMap[theMeshName]; + VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap; + if(aMeshOnEntityMap.find(theEntity) == aMeshOnEntityMap.end()) + throw std::runtime_error("GetFieldOnMesh >> There is no mesh on the entity!!!"); + VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMap[theEntity]; + VISU::TMeshOnEntity* pVtkMeshOnEntity = &aMeshOnEntity; + if(theEntity == VISU::NODE_ENTITY){ + if(aMeshOnEntityMap.find(VISU::CELL_ENTITY) == aMeshOnEntityMap.end()) + throw std::runtime_error("GetFieldOnMesh >> There is no mesh on CELL_ENTITY!!!"); + pVtkMeshOnEntity = &aMeshOnEntityMap[VISU::CELL_ENTITY]; + } + VISU::TMeshOnEntity& aVtkMeshOnEntity = *pVtkMeshOnEntity; + VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap; + if(aFieldMap.find(theFieldName) == aFieldMap.end()) + throw std::runtime_error("GetFieldOnMesh >> There is no field on the mesh!!!"); + VISU::TField& aField = aFieldMap[theFieldName]; + VISU::TField::TValField& aValField = aField.myValField; + if(aValField.find(theStampsNum) == aValField.end()) + throw std::runtime_error("GetFieldOnMesh >> There is no field with the timestamp!!!"); + VISU::TField::TValForTime& aValForTime = aValField[theStampsNum]; + VISU::TVTKReader& aReader = aValForTime.myStorage; + //Main part of code + if(aReader.get() == NULL){ + LoadMeshOnEntity(aVtkMeshOnEntity); + LoadFieldOnMesh(aMesh,aMeshOnEntity,aField,aValForTime); + ostrstream strOut; + strOut< aCellsDim = aVtkMeshOnEntity.GetCellsDims(); + int aNbCells = aCellsDim.first, aCellsSize = aCellsDim.second; + ostrstream strCellsOut, strTypesOut; + GetCells(strCellsOut,strTypesOut,aVtkMeshOnEntity); + strCellsOut< aRet(strCellsOut.str()); + strOut<ReadFromInputStringOn(); + aRet.reset(strOut.str()); + aReader->SetInputString(aRet.get()); + if(MYDEBUGWITHFILES){ + string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1(); + string aFieldName = QString(theFieldName.c_str()).simplifyWhiteSpace().latin1(); + string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-"; + aFileName += aMeshName + dtos("-%d-",theEntity) + aFieldName + dtos("-%d",theStampsNum) + "-Conv.vtk"; + ofstream stmOut(aFileName.c_str(),ios::out); + stmOut<> There is no elements on the family !!!"); + VISU::TFamily::TSubMesh::const_iterator aSubMeshIter = aSubMesh.find(aVtkType); + if(aSubMeshIter == aSubMesh.end()) continue; + const VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aSubMeshIter->second; + if(MYDEBUG) MESSAGE("GetCells - aSubMeshOnCellType.size() = "< aRet(strOut.str()); + return aRet.get(); +} + +string VISU_Convertor_impl::GetPoints(const VISU::TMesh& theMesh) const + throw (std::runtime_error&) +{ + ostrstream strOut; + strOut.setf(ios::scientific,ios::floatfield); strOut.precision(PRECISION); + const VISU::TMesh::TPointsCoord& anArray = theMesh.myPointsCoord; + int iEnd = theMesh.myPointsCoord.size(); + int aNbPoints = iEnd/theMesh.myDim; + strOut<<"POINTS "< aRet(strOut.str()); + return aRet.get(); +} + +string VISU_Convertor_impl::GetField(const VISU::TField& theField, + const VISU::TField::TValForTime& theValForTime, + int theDim, int theNbPoints, int theNbCells) const + throw (std::runtime_error&) +{ + ostrstream strOut; + strOut.setf(ios::scientific,ios::floatfield); strOut.precision(PRECISION); + string aName = GenerateName(theField.myName,theValForTime.myId); + if(MYDEBUG) MESSAGE("GetField - aTime = "<second; + int iEnd = anArray.size()/theField.myNbComp; + int aVtkType = aValForCellsIter->first; + if(MYDEBUG) MESSAGE("GetField - iEnd = "< aRet(strOut.str()); + return aRet.get(); +} diff --git a/src/VISU_I/VISU_Convertor_impl.hxx b/src/VISU_I/VISU_Convertor_impl.hxx new file mode 100644 index 00000000..68b69e1b --- /dev/null +++ b/src/VISU_I/VISU_Convertor_impl.hxx @@ -0,0 +1,82 @@ +// File: VISU_Convertor_impl.hxx +// Created: Fri Jan 10 11:36:46 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_Convertor_impl_HeaderFile +#define VISU_Convertor_impl_HeaderFile + +#include "VISU_Convertor.hxx" + +extern "C"{ +#include +} + +#include +#include + +#include +#include +using namespace std; + +class VISU_Convertor_impl: public VISU_Convertor{ + private: + string GetHead(const string& theMeshName) const throw (std::runtime_error&); + string GetPoints(const VISU::TMesh& theMesh) const throw (std::runtime_error&); + int GetCells(ostrstream& strCellsOut, ostrstream& strTypesOut, + const VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName = "") const throw (std::runtime_error&); + string GetField(const VISU::TField& theField, + const VISU::TField::TValForTime& theValForTime, + int theDim, int theNbPoints, int theNbCells) const + throw (std::runtime_error&); + public: + VISU_Convertor_impl(); + virtual ~VISU_Convertor_impl(); + virtual VISU_Convertor* Build() throw (std::runtime_error&) { return this;}; + virtual OutputType* GetMeshOnEntity(const string& theMeshName, + const VISU::TEntity& theEntity, + const string& theFamilyName = "") + throw(std::runtime_error&); + virtual OutputType* GetMeshOnGroup(const string& theMeshName, + const string& theGroupName) + throw(std::runtime_error&); + virtual OutputType* GetFieldOnMesh(const string& theMeshName, + const VISU::TEntity& theEntity, + const string& theFieldName, + int theStampsNum) + throw(std::runtime_error&); + + protected: + virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName = "") + throw (std::runtime_error&) = 0; + virtual int LoadMeshOnGroup(VISU::TMesh& theMesh, + const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet) + throw (std::runtime_error&) = 0; + virtual int LoadFieldOnMesh(VISU::TMesh& theMesh, + VISU::TMeshOnEntity& theMeshOnEntity, + VISU::TField& theField, + VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&) = 0; +}; + +extern "C"{ + int getNbMedConnect(int theMedType, int theMedEntity, int theMeshDim); + int getNbMedNodes(int theMedType); + int med2vtkCellType(int theMedType); + int vtk2medCellType(int theVtkType); + int getIdMedType(int medType); +} + +struct Med2vtk { + med_geometrie_element medType; + const char *medName; + int medNbNodes; + int vtkType; + const char *vtkName; + int vtkNbNodes; +}; +extern Med2vtk med2vtk[MED_NBR_GEOMETRIE_MAILLE]; +#endif diff --git a/src/VISU_I/VISU_CorbaMedConvertor.cxx b/src/VISU_I/VISU_CorbaMedConvertor.cxx new file mode 100644 index 00000000..46ccae6c --- /dev/null +++ b/src/VISU_I/VISU_CorbaMedConvertor.cxx @@ -0,0 +1,635 @@ +using namespace std; +// File: VISU_CorbaMedConvertor.cxx +// Created: Fri Jan 10 12:04:54 2003 +// Author: Alexey PETROV +// + + +#include "VISU_CorbaMedConvertor.hxx" +using namespace VISU; +#include +#include + +#define USER_INTERLACE MED_FULL_INTERLACE + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 0; +#endif +static med_err ret = 0; + +extern "C" + VISU_Convertor* CreateMEDConvertor(SALOMEDS::SObject_ptr theMedSObject) throw(std::runtime_error&){ + return new VISU_MEDConvertor(theMedSObject); + } + +typedef map TVisu2MedEntity; +static TVisu2MedEntity aVisu2MedEntity; +typedef map TMed2VisuEntity; +static TMed2VisuEntity aMed2VisuEntity; +static int INIT = ( + aVisu2MedEntity[VISU::CELL_ENTITY] = SALOME_MED::MED_CELL, + aVisu2MedEntity[VISU::FACE_ENTITY] = SALOME_MED::MED_FACE, + aVisu2MedEntity[VISU::EDGE_ENTITY] = SALOME_MED::MED_EDGE, + aVisu2MedEntity[VISU::NODE_ENTITY] = SALOME_MED::MED_NODE, + + aMed2VisuEntity[SALOME_MED::MED_CELL] = VISU::CELL_ENTITY, + aMed2VisuEntity[SALOME_MED::MED_FACE] = VISU::FACE_ENTITY, + aMed2VisuEntity[SALOME_MED::MED_EDGE] = VISU::EDGE_ENTITY, + aMed2VisuEntity[SALOME_MED::MED_NODE] = VISU::NODE_ENTITY, + + 1); + +static int CELLGEOM[MED_NBR_GEOMETRIE_MAILLE] = { + SALOME_MED::MED_POINT1, + SALOME_MED::MED_SEG2, + SALOME_MED::MED_SEG3, + SALOME_MED::MED_TRIA3, + SALOME_MED::MED_QUAD4, + SALOME_MED::MED_TRIA6, + SALOME_MED::MED_QUAD8, + SALOME_MED::MED_TETRA4, + SALOME_MED::MED_PYRA5, + SALOME_MED::MED_PENTA6, + SALOME_MED::MED_TETRA10, + SALOME_MED::MED_HEXA8, + SALOME_MED::MED_PYRA13, + SALOME_MED::MED_PENTA15, + SALOME_MED::MED_HEXA20 +}; + +static const int VTKCELLGEOMEND = 8; +static int VTKCELLGEOM[VTKCELLGEOMEND] = { + SALOME_MED::MED_POINT1, + SALOME_MED::MED_SEG2, + SALOME_MED::MED_TRIA3, + SALOME_MED::MED_QUAD4, + SALOME_MED::MED_TETRA4, + SALOME_MED::MED_PYRA5, + SALOME_MED::MED_PENTA6, + SALOME_MED::MED_HEXA8 +}; + +static int FACEGEOM[MED_NBR_GEOMETRIE_FACE] = { + SALOME_MED::MED_TRIA3, + SALOME_MED::MED_QUAD4, + SALOME_MED::MED_TRIA6, + SALOME_MED::MED_QUAD8 +}; + +static int EDGEGEOM[MED_NBR_GEOMETRIE_ARETE] = { + SALOME_MED::MED_SEG2, + SALOME_MED::MED_SEG3 +}; + +static int NODEGEOM[1] = { + SALOME_MED::MED_POINT1, +}; + +void GetEntity2Geom(const VISU::TEntity& theEntity, int*& theVector, int* theEnd) + throw (std::runtime_error&) +{ + switch(theEntity){ + case VISU::CELL_ENTITY: theVector = CELLGEOM; *theEnd = MED_NBR_GEOMETRIE_MAILLE; break; + case VISU::FACE_ENTITY: theVector = FACEGEOM; *theEnd = MED_NBR_GEOMETRIE_FACE; break; + case VISU::EDGE_ENTITY: theVector = EDGEGEOM; *theEnd = MED_NBR_GEOMETRIE_ARETE; break; + case VISU::NODE_ENTITY: theVector = NODEGEOM; *theEnd = 1; break; + default: + throw std::runtime_error("GetEntity2Geom >> theEntity is uncorrect !!!"); + } +} + +struct SalomeMed2vtk { + SALOME_MED::medGeometryElement medType; + char *medName; + int medNbNodes; + int vtkType; + char *vtkName; + int vtkNbNodes; +}; + +#define CORBAMED2VTK(MEDTYPE,VTKTYPE,VTKNBNODES) \ + {SALOME_MED::MEDTYPE,#MEDTYPE,getNbMedNodes(MEDTYPE),VTKTYPE,#VTKTYPE,VTKNBNODES} +static SalomeMed2vtk salome_med2vtk[SALOME_MED::MED_ALL_ELEMENTS] = { + {SALOME_MED::MED_NONE,"MED_NONE",0,VTK_EMPTY_CELL,"VTK_EMPTY_CELL",0}, + CORBAMED2VTK(MED_POINT1,VTK_VERTEX,1), + CORBAMED2VTK(MED_SEG2,VTK_LINE,2), + CORBAMED2VTK(MED_SEG3,VTK_LINE,2), + CORBAMED2VTK(MED_TRIA3,VTK_TRIANGLE,3), + CORBAMED2VTK(MED_QUAD4,VTK_QUAD,4), + CORBAMED2VTK(MED_TRIA6,VTK_TRIANGLE,3), + CORBAMED2VTK(MED_QUAD8,VTK_QUAD,4), + CORBAMED2VTK(MED_TETRA4,VTK_TETRA,4), + CORBAMED2VTK(MED_PYRA5,VTK_PYRAMID,5), + CORBAMED2VTK(MED_PENTA6,VTK_WEDGE,6), + CORBAMED2VTK(MED_TETRA10,VTK_TETRA,4), + CORBAMED2VTK(MED_HEXA8,VTK_HEXAHEDRON,8), + CORBAMED2VTK(MED_PYRA13,VTK_PYRAMID,5), + CORBAMED2VTK(MED_PENTA15,VTK_WEDGE,6), + CORBAMED2VTK(MED_HEXA20,VTK_HEXAHEDRON,8) +}; +#undef CORBAMED2VTK + +int GetIdMEDType(int medType){ + for(int i = 0; i < SALOME_MED::MED_ALL_ELEMENTS; i++) + if(salome_med2vtk[i].medType == medType) return i; + return -1; +} + +string GetName(SALOMEDS::SObject_ptr aSObject){ + SALOMEDS::GenericAttribute_var anAttr; + if (aSObject->FindAttribute(anAttr,"AttributeName")) { + SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr); + CORBA::String_var aString = aName->Value(); + return aString.in(); + } + return ""; +} + +VISU_Convertor* VISU_MEDConvertor::Build() throw (std::runtime_error&){ + if(mySObject->_is_nil()) + throw std::runtime_error("VISU_MEDConvertor::Build >> mySObject->_is_nil() !!!"); + myStudy = mySObject->GetStudy(); + CORBA::Short aTag = mySObject->Tag(); + SALOMEDS::SObject_var aMedCompSObj = mySObject->GetFather(); + SALOMEDS::SObject_var aMeshSObj; + CORBA::Boolean aBool = aMedCompSObj->FindSubObject(aTag+1,aMeshSObj); + if(!aBool) throw std::runtime_error("VISU_MEDConvertor::Build >> Cann't find MEDMESH label !!!"); + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - MEDMESH found."); + SALOMEDS::ChildIterator_var aMeshIterator = myStudy->NewChildIterator(aMeshSObj); + for(; aMeshIterator->More(); aMeshIterator->Next()){ + aMeshSObj = aMeshIterator->Value(); + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aMeshSObj = '"<<::GetName(aMeshSObj)<<"'"); + CORBA::Object_var aMedMesh = SObjectToObject(aMeshSObj); + if(CORBA::is_nil(aMedMesh)) continue; + SALOME_MED::MESH_var aMEDMesh = SALOME_MED::MESH::_narrow(aMedMesh); + if(aMEDMesh->_is_nil()) continue; + CORBA::String_var aMeshName = aMEDMesh->getName(); + VISU::TMesh &aMesh = myMeshMap[aMeshName.in()]; + aMesh.myDim = aMEDMesh->getSpaceDimension(); + aMesh.myName = aMeshName.in(); + VISUMED::TMesh &aMesh2 = myMeshMap2[aMeshName.in()]; + aMesh2.myMesh = aMEDMesh; + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aMeshName = "<NewChildIterator(aFieldSObj); + for(int iField = 0; aFieldIterator->More(); aFieldIterator->Next(), iField++){ + aFieldSObj = aFieldIterator->Value(); + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aFieldName = '"<<::GetName(aFieldSObj)<<"'"); + SALOMEDS::ChildIterator_var aTimeStampIterator = myStudy->NewChildIterator(aFieldSObj); + for(; aTimeStampIterator->More(); aTimeStampIterator->Next()){ + SALOMEDS::SObject_var aTimeStampSObj = aTimeStampIterator->Value(); + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aTimeStampSObj = '"<<::GetName(aTimeStampSObj)<<"'"); + CORBA::Object_var aMedField = SObjectToObject(aTimeStampSObj); + if(CORBA::is_nil(aMedField)) continue; + SALOME_MED::FIELD_var aMEDField = SALOME_MED::FIELD::_narrow(aMedField); + if(aMEDField->_is_nil()) continue; + SALOME_MED::SUPPORT_var aMEDSupport = aMEDField->getSupport(); + if(aMEDSupport->_is_nil()) continue; + SALOME_MED::medEntityMesh aMEDEntity = aMEDSupport->getEntity(); + VISU::TEntity anEntity = aMed2VisuEntity[aMEDEntity]; + SALOME_MED::MESH_var aMEDMesh = aMEDSupport->getMesh(); + if(aMEDMesh->_is_nil()) continue; + CORBA::String_var aMeshName = aMEDMesh->getName(); + CORBA::String_var aFieldName = aMEDField->getName(); + VISU::TMesh &aMesh = myMeshMap[aMeshName.in()]; + VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity]; + VISU::TField& aField = aMeshOnEntity.myFieldMap[aFieldName.in()]; + aField.myId = iField; + aField.myName = aFieldName.in(); + aField.myEntity = anEntity; + aField.myMeshName = aMeshName.in(); + aField.myNbComp = aMEDField->getNumberOfComponents(); + //int iTimeStamp = aMEDField->getOrderNumber(); + int iTimeStamp = aMEDField->getIterationNumber(); + VISU::TField::TValForTime& aValForTime = aField.myValField[iTimeStamp]; + aValForTime.myId = iTimeStamp; + double dt = aMEDField->getTime(); + aValForTime.myTime = VISU::TField::TTime(dt,""); + VISUMED::TMesh &aMesh2 = myMeshMap2[aMeshName.in()]; + VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity]; + VISUMED::TField& aField2 = aMeshOnEntity2.myFieldMap[aFieldName.in()]; + VISUMED::TField::TValForTime& aValForTime2 = aField2.myValField[iTimeStamp]; + aValForTime2.myField = aMEDField; + if(MYDEBUG) + MESSAGE("VISU_MEDConvertor::Build - aMeshName = '"<getSpaceDimension(); + int iNumElemEnd = aMedMesh->getNumberOfNodes(); + VISU::TMesh::TPointsCoord& aPointsCoord = theMesh.myPointsCoord; + if(MYDEBUG) MESSAGE("LoadPoints - iNumElemEnd = "<> There is no points in the mesh !!!"); + aPointsCoord.resize(theMesh.myDim*iNumElemEnd,0.0); + Engines::double_array_var coord = aMedMesh->getCoordinates(SALOME_MED::MED_FULL_INTERLACE); + if(!isPointsLoaded){ + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) + for(int iDim = 0, iNumElem2Dim = iNumElem*theMesh.myDim; iDim < theMesh.myDim; iDim++, iNumElem2Dim++) + aPointsCoord[iNumElem2Dim] = coord[iNumElem2Dim]; + if(MYDEBUG) MESSAGE("LoadPoints - Filling aMeshOnEntity with type NODE_ENTITY"); + VISU::TMeshOnEntity::TConnForCellType& aConnForCellType = aMeshOnEntity.myCellsConn[VTK_VERTEX]; + aConnForCellType.resize(iNumElemEnd); + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) + aConnForCellType[iNumElem] = VISU::TMeshOnEntity::TConnect(1,iNumElem); + } + if(isFamilyPresent){ + if(MYDEBUG) MESSAGE("LoadPoints - Filling aFamily SubMesh"); + VISUMED::TFamily aFamily2 = aMeshOnEntity2.myFamilyMap[aFamily.myName]; + SALOME_MED::FAMILY_var aMedFamily = aFamily2.myFamily; + VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aFamily.mySubMesh[VTK_VERTEX]; + SALOME_MED::medGeometryElement_array_var aGeom = aMedFamily->getTypes(); + Engines::long_array_var aCellNumForType = aMedFamily->getNumber(aGeom[0]); + int iNumElemEndTmp = iNumElemEnd; + iNumElemEnd = aCellNumForType->length(); + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) { + int tmp = aCellNumForType[iNumElem]-1; + if(0 > tmp || tmp >= iNumElemEndTmp) { + static QString aString; + aString.sprintf("LoadPoints >> iNumElemEndTmp(%d) <= aCellNumForType[%d]=%d < 0 !!!",iNumElemEnd,iNumElem,tmp); + throw std::runtime_error(aString.latin1()); + } + aSubMeshOnCellType.insert(tmp); + } + } + return 1; +} + +int VISU_MEDConvertor::LoadCellsOnEntity(VISU::TMeshOnEntity& theMeshOnEntity, const string& theFamilyName) + throw (std::runtime_error&) +{ + //Check on existing family + VISU::TFamily* pFamily = VISU::GetFamily(theMeshOnEntity,theFamilyName); + bool isFamilyPresent = (pFamily != NULL); + VISU::TFamily& aFamily = *pFamily; + //Check on loading already done + bool isCellsLoaded = !theMeshOnEntity.myCellsConn.empty(); + if(isCellsLoaded) + if(!isFamilyPresent) return 0; + else if(!aFamily.mySubMesh.empty()) return 0; + VISUMED::TMesh& aMesh2 = myMeshMap2[theMeshOnEntity.myMeshName]; + VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[theMeshOnEntity.myEntity]; + SALOME_MED::SUPPORT_var& aMedSupport = aMeshOnEntity2.mySupport; + SALOME_MED::MESH_var aMedMesh = aMedSupport->getMesh(); + if(MYDEBUG) { + MESSAGE("LoadCellsOnEntity - theFamilyName = '"<> aNbPoints(%d) <= anArray[%d][%d]=%d < 0 !!!",aNbPoints,iNumElem,k,anArray[k]); + throw std::runtime_error(aString.latin1()); + } + aConnForCellType.push_back(anArray); + } + //Workaround for MED Component data structure + int aSize = aConnForCellType.size(); + aMeshOnEntity2.myCellsFirstIndex[aMedType] = VISUMED::TMeshOnEntity::TIndexAndSize(aCounter,aSize); + aCounter += aSize; + } + } + } + //Filling aFamily SubMesh + if(isFamilyPresent){ + VISUMED::TFamily aFamily2 = aMeshOnEntity2.myFamilyMap[aFamily.myName]; + SALOME_MED::FAMILY_var aMedFamily = aFamily2.myFamily; + SALOME_MED::medGeometryElement_array_var aGeom = aMedFamily->getTypes(); + iGeomElemEnd = aGeom->length(); + if(MYDEBUG) MESSAGE("LoadCellsOnEntity - iGeomElemEnd = "<getNumber(aGeomType); + int medId = GetIdMEDType(aGeomType); + int aVtkType = salome_med2vtk[medId].vtkType; + SALOME_MED::medGeometryElement aMedType = salome_med2vtk[medId].medType; + VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aFamily.mySubMesh[aVtkType]; + med_int iNumElemEndTmp = theMeshOnEntity.myCellsConn[aVtkType].size(); + med_int iNumElemEnd = aCellNumForType->length(); + int aCounter = aMeshOnEntity2.myCellsFirstIndex[aMedType].first; + if(MYDEBUG) + MESSAGE("LoadCellsOnEntity - medName = "<> iNumElemEndTmp(%d) <= aCellNumForType[%d]=%d < 0 !!!",iNumElemEndTmp,iNumElem,tmp); + throw std::runtime_error(aString.latin1()); + } + aSubMeshOnCellType.insert(tmp); + } + } + } + return 1; +} + +template int ImportField(TArray& theArray, + const VISU::TMesh& theMesh, + const VISU::TField& theField, + VISU::TField::TValForTime& theValForTime, + const VISU::TMeshOnEntity& theMeshOnEntity, + const VISUMED::TMeshOnEntity& theMeshOnEntity2) +{ + if(theField.myEntity == VISU::NODE_ENTITY){ + VISU::TField::TValForCellsWithType& aValForCellsWithType = theValForTime.myValForCells[VTK_VERTEX]; + int iNumElemEnd = theMesh.myPointsCoord.size()/theMesh.myDim*theField.myNbComp; + if(MYDEBUG) MESSAGE("ImportField - iNumElemEnd = "<second; + const VISUMED::TMeshOnEntity::TIndexAndSize& aIndexAndSize = aCellsFirstIndexIter->second; + int iNumElemEnd = aIndexAndSize.second; + if(MYDEBUG) + MESSAGE("ImportField - medName = "<_is_nil()){ + Engines::double_array_var anArray = aFieldDouble->getValue(SALOME_MED::MED_FULL_INTERLACE); + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::LoadField - There is FIELDDOUBLE = "<length()); + ::ImportField(anArray,aMesh,theField,theValForTime,theMeshOnEntity,aMeshOnEntity2); + } + SALOME_MED::FIELDINT_ptr aFieldInt = SALOME_MED::FIELDINT::_narrow(aMEDField); + if(!aFieldInt->_is_nil()){ + Engines::long_array_var anArray = aFieldInt->getValue(SALOME_MED::MED_FULL_INTERLACE); + if(MYDEBUG) MESSAGE("VISU_MEDConvertor::LoadField - There is FIELDINT = "<length()); + ::ImportField(anArray,aMesh,theField,theValForTime,theMeshOnEntity,aMeshOnEntity2); + } + return 1; +} diff --git a/src/VISU_I/VISU_CorbaMedConvertor.hxx b/src/VISU_I/VISU_CorbaMedConvertor.hxx new file mode 100644 index 00000000..4fb887ff --- /dev/null +++ b/src/VISU_I/VISU_CorbaMedConvertor.hxx @@ -0,0 +1,88 @@ +// File: VISU_CorbaMedConvertor.hxx +// Created: Fri Jan 10 12:02:49 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_CorbaMedConvertor_HeaderFile +#define VISU_CorbaMedConvertor_HeaderFile + +#include "VISUConfig.hh" +#include "VISU_Convertor_impl.hxx" + +extern "C"{ +#include +} + +namespace VISUMED{ + struct TFamily{ + SALOME_MED::FAMILY_var myFamily; + }; + typedef std::map TFamilyMap; + + struct TField{ + struct TValForTime{ + SALOME_MED::FIELD_var myField; + }; + typedef std::map TValField; + TValField myValField; + }; + typedef map TFieldMap; + + struct TMeshOnEntity{ + SALOME_MED::SUPPORT_var mySupport; + typedef pair TIndexAndSize; + typedef map TCellsFirstIndex; + TCellsFirstIndex myCellsFirstIndex; + TFamilyMap myFamilyMap; + TFieldMap myFieldMap; + }; + typedef std::map TMeshOnEntityMap; + + struct TGroup{ + SALOME_MED::GROUP_var myGroup; + }; + typedef std::map TGroupMap; + + struct TMesh{ + SALOME_MED::MESH_var myMesh; + TMeshOnEntityMap myMeshOnEntityMap; + TGroupMap myGroupMap; + }; + typedef std::map TMeshMap; +} + + +class VISU_MEDConvertor: public VISU_Convertor_impl{ + protected: + VISUMED::TMeshMap myMeshMap2; + SALOMEDS::SObject_var mySObject; + SALOMEDS::Study_var myStudy; + public: + VISU_MEDConvertor(SALOMEDS::SObject_ptr theMedSObject) : mySObject(SALOMEDS::SObject::_duplicate(theMedSObject)) {} + virtual VISU_Convertor* Build() throw (std::runtime_error&); + protected: + virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName = "") + throw (std::runtime_error&); + virtual int LoadMeshOnGroup(VISU::TMesh& theMesh, + const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet) + throw (std::runtime_error&); + virtual int LoadFieldOnMesh(VISU::TMesh& theMesh, + VISU::TMeshOnEntity& theMeshOnEntity, + VISU::TField& theField, + VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&); + int LoadPoints(VISU::TMesh& theMesh, const string& theFamilyName = "") + throw (std::runtime_error&); + int LoadCellsOnEntity(VISU::TMeshOnEntity& theMeshOnEntity, const string& theFamilyName = "") + throw (std::runtime_error&); + int LoadField(const VISU::TMeshOnEntity& theMeshOnEntity, + const VISU::TField& theField, VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&); +}; + +extern "C" + VISU_Convertor* CreateMEDConvertor(SALOMEDS::SObject_ptr theMedSObject) throw(std::runtime_error&); +#endif + diff --git a/src/VISU_I/VISU_DatConvertor.cxx b/src/VISU_I/VISU_DatConvertor.cxx new file mode 100644 index 00000000..2fb3b149 --- /dev/null +++ b/src/VISU_I/VISU_DatConvertor.cxx @@ -0,0 +1,252 @@ +using namespace std; + +// File: VISU_DatConvertor.cxx +// Created: Fri Jan 10 12:15:57 2003 +// Author: Alexey PETROV +// + + +#include "VISU_DatConvertor.hxx" +using namespace std; + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 0; +#endif +static int PRECISION = 7; + +extern "C" +VISU_Convertor* CreateDatConvertor(const string& theFileName) throw(std::runtime_error&){ + VISU_DatConvertor* aConvertor = new VISU_DatConvertor(theFileName); + aConvertor->Build(); + return aConvertor; +} +VISU_DatConvertor::VISU_DatConvertor(const string& theFileName) throw(std::runtime_error&){ + myFileInfo.setFile(QString(theFileName.c_str())); + myName = myFileInfo.baseName(); +} + +VISU_Convertor* VISU_DatConvertor::Build() throw (std::runtime_error&){ + /* + ifstream stmIn(myFileInfo.absFilePath()); + if(!stmIn.good()) + throw std::runtime_error(string("VISU_DatConvertor::CreateResult() >> can't open file - ") + + (const char*)myFileInfo.absFilePath()); + int aNbPoints, aNbCells, aNbFields; + ImportHead(&stmIn,&aNbPoints,&aNbCells,&aNbFields); + ImportPoints(&stmIn,aNbPoints); + vector aCellsType(aNbCells); + ImportCells(&stmIn,&aCellsType); + for(int i = 0; i < aNbFields; i++) + ImportField(&stmIn,aNbPoints,&aCellsType); + myIsDone = true; + */ + return this; +} + +int VISU_DatConvertor::ImportField(ifstream* pStmIn, int theNbPoints, vector* pCellsType) + throw (std::runtime_error&) +{ + /* + ifstream &stmIn = *pStmIn; + vector& aCellsType = *pCellsType; + int aNbCells = aCellsType.size(); + string aName; stmIn>>aName; stmIn>>aName; + VISU::TMesh& aMesh = myMeshMap[myName]; + VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY]; + VISU::TField& aField = aMeshOnEntity.myFieldMap[aName]; + aField.myMeshName = myName; + stmIn>>(aField.myNbComp); + aField.myNbComp %= 100; + int iEnd; stmIn>>iEnd; + if(iEnd == theNbPoints) + aField.myEntity = VISU::NODE_ENTITY; + else if(iEnd == aNbCells) + aField.myEntity = VISU::CELL_ENTITY; + else + throw std::runtime_error("ImportChamp >> elements doesn't connected to points or cells"); + if(MYDEBUG) + MESSAGE("FieldInfo - myMeshName = "<>tmp; + anArray.push_back(tmp); + } + } + */ + return 0; +} + +int VISU_DatConvertor::ImportHead(ifstream* pStmIn, int* theNbPoints, + int* theNbCells, int* theNbFields) + throw (std::runtime_error&) +{ + /* + ifstream &stmIn = *pStmIn; + const int BUFSIZE = 256; + char buf[BUFSIZE]; + stmIn.getline(buf,BUFSIZE); + istrstream strIn(buf); + VISU::TMesh& aMesh = myMeshMap[myName]; + *theNbFields = 0; + strIn>>(*theNbPoints); strIn>>(*theNbCells); strIn>>(*theNbFields); + if(MYDEBUG) + MESSAGE("ImportHead - theNbPoints = "<<(*theNbPoints)<< + "; theNbCells = "<<(*theNbCells)<< + "; theNbFields = "<<(*theNbFields)); + */ + return 0; +} + +int VISU_DatConvertor::ImportPoints(ifstream* pStmIn, int theNbPoints) + throw (std::runtime_error&) +{ + /* + ifstream &stmIn = *pStmIn; + VISU::TMesh& aMesh = myMeshMap[myName]; + aMesh.myName = myName; + aMesh.myDim = 3; + int iEnd = aMesh.myDim*theNbPoints; + if(MYDEBUG) MESSAGE("ImportPoints - iEnd = "< &aPointsCoord = aMesh.myPointsCoord; + aPointsCoord.resize(iEnd); + for(int i = 0, tmp; i < iEnd;){ + stmIn>>tmp; + stmIn>>aPointsCoord[i++]; stmIn>>aPointsCoord[i++]; stmIn>>aPointsCoord[i++]; + } + */ + return 0; +} + +int VISU_DatConvertor::ImportCells(ifstream* pStmIn, vector* pCellsType) + throw (std::runtime_error&) +{ + /* + ifstream &stmIn = *pStmIn; + vector& aCellsType = *pCellsType; + int aNbCells = aCellsType.size(); + if(MYDEBUG) MESSAGE("ImportCells - theNbCells - Beginning"); + VISU::TMesh& aMesh = myMeshMap[myName]; + VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY]; + aMeshOnEntity.myEntity = VISU::CELL_ENTITY; + aMeshOnEntity.myMeshName = myName; + for(int i = 0, aMedType, aVtkType; i < aNbCells; i++){ + stmIn>>aMedType; stmIn>>aMedType; + aCellsType[i] = aVtkType = med2vtkCellType(aMedType); + VISU::TMeshOnEntity::TConnForCellType& anArray = aMeshOnEntity.myCellsConn[aVtkType]; + anArray.push_back(VISU::TMeshOnEntity::TConnect()); + VISU::TMeshOnEntity::TConnect& aVector = anArray.back(); + int jEnd = getNbMedNodes(aMedType); + aVector.resize(jEnd); + for(int j = 0, tmp; j < jEnd; j++){ + stmIn>>tmp; + aVector[j] = tmp - 1; + } + } + if(MYDEBUG) MESSAGE("ImportCells - theNbCells - End"); + */ + return 0; +} + +/* +int VISU_Convertor_impl::ToDatFile(const string& theFileName) throw(std::runtime_error&){ + if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - "<second; + if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - aMeshName = "<first); + VISU::TFieldMap aFieldMap = GetFieldMapForMesh(aMeshIter->first); + const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap; + VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter = aMeshOnEntityMap.find(VISU::CELL_ENTITY); + if(aMeshOnEntityMapIter != aMeshOnEntityMap.end()){ + const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second; + int aNbPoints = aMesh.myPointsCoord.size()/aMesh.myDim; + int aNbCells = aMeshOnEntity.GetCellsDims().first; + stmOut<first)<<"\t"; + const vector& aVector = anArray[j]; + int kEnd = aVector.size(); + for(int k = 0; k < kEnd; k++) + stmOut<second; + const VISU::TField::TValField &aValField = aField.myValField; + VISU::TField::TValField::const_reverse_iterator iter = aField.myValField.rbegin(); + for(int i = 0; iter != aValField.rend(); iter++, i++) { + if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - aTime = "<second; + VISU::TField::TValForTime::const_iterator jter = aValForTime.begin(); + stmOut<<(++i)<first).c_str(),i); + stmOut< + + +#ifndef VISU_DatConvertor_HeaderFile +#define VISU_DatConvertor_HeaderFile + +#include "VISU_Convertor_impl.hxx" +#include + +class VISU_DatConvertor: public VISU_Convertor_impl{ + VISU_DatConvertor(); + VISU_DatConvertor(const VISU_DatConvertor&); +public: + VISU_DatConvertor(const string& theFileName) throw (std::runtime_error&); + virtual VISU_Convertor* Build() throw (std::runtime_error&); +protected: + QFileInfo myFileInfo; + int ImportHead(ifstream* pStmIn, int* theNbPoints, int* theNbCells, int* theNbFields) + throw (std::runtime_error&); + int ImportPoints(ifstream*, int theNbPoints) + throw (std::runtime_error&); + int ImportCells(ifstream*, vector* aCellsType) + throw (std::runtime_error&); + int ImportField(ifstream*, int theNbPoints, vector* aCellsType) + throw (std::runtime_error&); + protected: + virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName = "") + throw (std::runtime_error&) {return 1;} + virtual int LoadMeshOnGroup(VISU::TMesh& theMesh, + const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet) + throw (std::runtime_error&) {return 1;} + virtual int LoadFieldOnMesh(VISU::TMesh& theMesh, + VISU::TMeshOnEntity& theMeshOnEntity, + VISU::TField& theField, + VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&) {return 1;} +}; + +#endif diff --git a/src/VISU_I/VISU_Extractor.cxx b/src/VISU_I/VISU_Extractor.cxx new file mode 100644 index 00000000..4ca6929d --- /dev/null +++ b/src/VISU_I/VISU_Extractor.cxx @@ -0,0 +1,84 @@ +using namespace std; +#include "VISU_Extractor.hxx" + +#include +#include +#include +#include + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 0; +#endif + +VISU_Extractor::VISU_Extractor(){ + myNbComp = 0; + myScalarMode = 0; +} +VISU_Extractor::~VISU_Extractor() {} +VISU_Extractor* VISU_Extractor::New(){ + vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_Extractor"); + if(ret) return (VISU_Extractor*)ret; + return new VISU_Extractor; +} +void VISU_Extractor::Extract(vtkUnstructuredGridReader* theReader, + const string& theFieldName, int theScalarMode, + int theNbComp, const VISU::TEntity& theEntity) +{ + myScalarMode = theScalarMode; + myNbComp = theNbComp; + myEntity = theEntity; + if(myNbComp == 1) + theReader->SetScalarsName(theFieldName.c_str()); + else + theReader->SetVectorsName(theFieldName.c_str()); + SetInput(theReader->GetOutput()); + Update(); +} +template void +execute(int theNbComp, int theScalarMode, TypeData* theInputData, TypeData* theOutputData){ + vtkVectors *inVectors = theInputData->GetVectors(); + if ( !inVectors || theNbComp < 1 ) + return; + vtkScalars *newScalars = vtkScalars::New(); + newScalars->SetNumberOfScalars(theNbComp); + for (int ptId = 0; ptId < theNbComp; ptId++) { + float v[3], s; + inVectors->GetVector(ptId,v); + if ( theScalarMode < 1 || theScalarMode > 3) + s = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); + else + s = v[theScalarMode - 1]; + newScalars->SetScalar(ptId, s); + } + theOutputData->SetScalars(newScalars); + newScalars->Delete(); +} +void VISU_Extractor::Execute(){ + vtkDataSet *input = this->GetInput(), *output = this->GetOutput(); + output->CopyStructure(input); + output->GetPointData()->CopyAllOff(); + output->GetCellData()->CopyAllOff(); + if(myEntity == VISU::NODE_ENTITY){ + output->GetPointData()->CopyVectorsOn(); + int nbComp = input->GetNumberOfPoints(); + vtkPointData *inData = input->GetPointData(), *outData = output->GetPointData(); + if(myNbComp > 1) + execute(nbComp,myScalarMode,inData,outData); + else + output->GetPointData()->CopyScalarsOn(); + outData->PassData(inData); + }else{ + output->GetCellData()->CopyVectorsOn(); + int nbComp = input->GetNumberOfCells(); + vtkCellData *inData = input->GetCellData(), *outData = output->GetCellData(); + if(myNbComp > 1) + execute(nbComp,myScalarMode,inData,outData); + else + output->GetCellData()->CopyScalarsOn(); + outData->PassData(inData); + } +} + + diff --git a/src/VISU_I/VISU_Extractor.hxx b/src/VISU_I/VISU_Extractor.hxx new file mode 100644 index 00000000..ab6eaafb --- /dev/null +++ b/src/VISU_I/VISU_Extractor.hxx @@ -0,0 +1,34 @@ +// File: VISU_Extractor.hxx +// Created: Fri Jan 10 16:37:54 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_Extractor_HeaderFile +#define VISU_Extractor_HeaderFile + +#include +#include +#include "VISU_Convertor.hxx" +class vtkUnstructuredGridReader; + +class VTK_EXPORT VISU_Extractor : public vtkDataSetToDataSetFilter{ +public: + vtkTypeMacro(VISU_Extractor,vtkDataSetToDataSetFilter); + static VISU_Extractor *New(); + void Extract(vtkUnstructuredGridReader* theReader, + const string& theFieldName, int theScalarMode, + int theNbComp, const VISU::TEntity& theEntity); +protected: + VISU_Extractor(); + virtual ~VISU_Extractor(); + VISU_Extractor(const VISU_Extractor&) {}; + void operator=(const VISU_Extractor&) {}; + void Execute(); + + int myNbComp; + int myScalarMode; + VISU::TEntity myEntity; +}; + +#endif diff --git a/src/VISU_I/VISU_FieldTransform.cxx b/src/VISU_I/VISU_FieldTransform.cxx new file mode 100644 index 00000000..58626521 --- /dev/null +++ b/src/VISU_I/VISU_FieldTransform.cxx @@ -0,0 +1,110 @@ +using namespace std; +#include "VISU_FieldTransform.hxx" +#include "utilities.h" + +#include +#include +#include +#include + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 1; +#endif + +extern "C" { +double Identical(double theArg) { + return theArg; +} + +double Logarithmic10(double theArg) { + if(theArg == 0.0) return 0.0; + double aResult; + if(theArg < 0.0) return -log10(-theArg); + return log10(theArg); +} + +} + +VISU_FieldTransform::VISU_FieldTransform(){ + myFunction = &Identical; +} + +VISU_FieldTransform::~VISU_FieldTransform() {} + +VISU_FieldTransform* VISU_FieldTransform::New(){ + vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_FieldTransform"); + if(ret) return (VISU_FieldTransform*)ret; + return new VISU_FieldTransform; +} + +void VISU_FieldTransform::SetTransformFunction(TTransformFun theFunction) { + //if(MYDEBUG) MESSAGE("VISU_FieldTransform::SetTransformFunction"); + myFunction = theFunction; + if(myFunction == NULL) myFunction = &Identical; + Modified(); +} + +template void +ExecVectors(VISU_FieldTransform::TTransformFun theFunction, int theNbComponent, + TypeData* theInputData, TypeData* theOutputData) +{ + vtkVectors *inVectors = theInputData->GetVectors(); + if ( !inVectors || theNbComponent < 1 ) + return; + vtkVectors *newVectors = vtkVectors::New(); + newVectors->SetNumberOfVectors(theNbComponent); + for (int ptId = 0; ptId < theNbComponent; ptId++) { + float v[3], val, res; + inVectors->GetVector(ptId,v); +// v[0] = (*theFunction)(v[0]); +// v[1] = (*theFunction)(v[1]); +// v[2] = (*theFunction)(v[2]); + val = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); + res = (*theFunction)(val); + if(val > 1.0) res /= val; else res *= val; + v[0] *= res; + v[1] *= res; + v[2] *= res; + newVectors->SetVector(ptId, v); + } + theOutputData->SetVectors(newVectors); + newVectors->Delete(); +} + +template void +ExecScalars(VISU_FieldTransform::TTransformFun theFunction, int theNbComponent, + TypeData* theInputData, TypeData* theOutputData) +{ + vtkScalars *inScalars = theInputData->GetScalars(); + if ( !inScalars || theNbComponent < 1 ) + return; + vtkScalars *newScalars = vtkScalars::New(); + newScalars->SetNumberOfScalars(theNbComponent); + for (int ptId = 0; ptId < theNbComponent; ptId++) { + float s = inScalars->GetScalar(ptId ); + s = (*theFunction)(s); + newScalars->SetScalar(ptId, s); + } + theOutputData->SetScalars(newScalars); + newScalars->Delete(); +} + +void VISU_FieldTransform::Execute(){ + //if(MYDEBUG) MESSAGE("VISU_FieldTransform::Execute"); + vtkDataSet *input = this->GetInput(), *output = this->GetOutput(); + output->CopyStructure(input); + output->GetPointData()->CopyAllOff(); + output->GetCellData()->CopyAllOff(); + + ExecScalars(myFunction,input->GetNumberOfPoints(),input->GetPointData(),output->GetPointData()); + ExecVectors(myFunction,input->GetNumberOfPoints(),input->GetPointData(),output->GetPointData()); + //output->GetPointData()->PassData(input->GetPointData()); + + ExecScalars(myFunction,input->GetNumberOfCells(),input->GetCellData(),output->GetCellData()); + ExecVectors(myFunction,input->GetNumberOfCells(),input->GetCellData(),output->GetCellData()); + //output->GetCellData()->PassData(input->GetCellData()); +} + + diff --git a/src/VISU_I/VISU_FieldTransform.hxx b/src/VISU_I/VISU_FieldTransform.hxx new file mode 100644 index 00000000..71e9cfc2 --- /dev/null +++ b/src/VISU_I/VISU_FieldTransform.hxx @@ -0,0 +1,33 @@ +// File: VISU_Extractor.hxx +// Created: Fri Jan 10 16:37:54 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_FieldTransform_HeaderFile +#define VISU_FieldTransform_HeaderFile + +#include +#include + +class VTK_EXPORT VISU_FieldTransform : public vtkDataSetToDataSetFilter{ +public: + vtkTypeMacro(VISU_FieldTransform,vtkDataSetToDataSetFilter); + static VISU_FieldTransform *New(); + typedef double (*TTransformFun)(double); + void SetTransformFunction(TTransformFun theFunction); +protected: + VISU_FieldTransform(); + virtual ~VISU_FieldTransform(); + VISU_FieldTransform(const VISU_FieldTransform&) {}; + void operator=(const VISU_FieldTransform&) {}; + void Execute(); + + TTransformFun myFunction; +}; +extern "C" { + double Identical(double theArg); + double Logarithmic10(double theArg); +} + +#endif diff --git a/src/VISU_I/VISU_Gen_i.cc b/src/VISU_I/VISU_Gen_i.cc new file mode 100644 index 00000000..037e0d51 --- /dev/null +++ b/src/VISU_I/VISU_Gen_i.cc @@ -0,0 +1,947 @@ +using namespace std; +// File : VISU_Gen_i.cc file +// Created : +// Author : Alexey Petrov +// Project : SALOME +// Copyright : OPEN CASCADE +// $Header: + +#include "VISU_Gen_i.hh" +#include "VISU_Result_i.hh" +#include "VISU_Convertor.hxx" +#include "VISU_PrsObject_i.hh" +#include "VISU_ViewManager_i.hh" +#include "VISU_Table_i.hh" + +#include "QAD_Application.h" +#include "QAD_Desktop.h" +#include "QAD_Study.h" +#include "SALOMEDS_Tool.hxx" + +#include +#include +#include +#include +#include + +#include +#include CORBA_SERVER_HEADER(SALOME_Session) + +#include +#include +static QFileInfo aFileInfo; + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 0; +#endif + +#include + +//static int IS_LOADED = (cout<<"\n----------------- VisuEngine_factory is loaded -----------------\n", 1); +extern "C" { + PortableServer::ObjectId * + VisuEngine_factory(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, PortableServer::ObjectId * contId, + const char *instanceName, const char *interfaceName) + { + if(MYDEBUG) MESSAGE("VisuEngine_factory : "<getId() ; + } + Engines::Component_ptr + GetVisuGen(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA, + SALOME_NamingService* theNamingService, QMutex* theMutex) + { + if(MYDEBUG) MESSAGE("extern \"C\" GetVisuGen"); + VISU::VISU_Gen_i *aVISU_Gen = new VISU::VISU_Gen_i(theORB,thePOA,theNamingService,theMutex); + return Engines::Component::_narrow( VISU::VISU_Gen::_duplicate(aVISU_Gen->_this())); + //return aVISU_Gen->_this(); + } +} + +namespace VISU{ + //=========================================================================== + QMutex* Base_i::myMutex = NULL; + CORBA::ORB_var Base_i::myOrb; + PortableServer::POA_var Base_i::myPOA; + SALOME_NamingService* Base_i::myNamingService; + SALOME_LifeCycleCORBA* Base_i::myEnginesLifeCycle; + VISU_Gen_i* Base_i::myVisuGenImpl; + VISU_Gen_var Base_i::GetVisuGenInter() { return myVisuGenImpl->_this();} + Base_i::~Base_i() {} + char* Base_i::GetID(){ + //CORBA::Object_var anObject = _this(); + //return CORBA::string_dup(myOrb->object_to_string(anObject)); + return CORBA::string_dup(myOrb->object_to_string(_this())); + } + //=========================================================================== + static int mySCnt = 0; + static int myQCnt = 0; + Mutex::Mutex(QMutex* theMutex, QApplication* theQApp) : + myQApp(theQApp), isQAppLocked(theQApp->locked()), + myMutex(theMutex), isSessionLocked(theMutex->locked()) + { + if(MYDEBUG) MESSAGE("Mutex::Mutex : "<lock(); mySCnt++; } + if(!isQAppLocked) { myQApp->lock(); myQCnt++; } + //myQApp->syncX(); + //if(MYDEBUG) MESSAGE("Mutex::Mutex - "<syncX(); + if(!isQAppLocked) { myQApp->unlock(); myQCnt--; } + if(!isSessionLocked) { myMutex->unlock(); mySCnt--; } + //if(MYDEBUG) MESSAGE("Mutex::~Mutex - "<processEvents(); myQApp->processEvents(); myQApp->processEvents(); + } + //=========================================================================== + static Storable::TCallbackMap VisuStoreMap; + string Storable::ToString(){ + ostrstream strOut; + Storable::DataToStream( strOut, "myComment", GetComment() ); + ToStream(strOut); + strOut< aRet(strOut.str()); + return aRet.get(); + } + + void Storable::Registry(const char* theComment, TStorableEngine theEngine) + throw(std::logic_error&) + { + if(!VisuStoreMap.insert(TCallbackMap::value_type(theComment,theEngine)).second){ + if(MYDEBUG) MESSAGE("Storable::Registry >> dupliacte registring !!!"); + throw std::logic_error("Storable::Registry >> dupliacte registring !!!"); + } + } + + void RegistryStorable() throw(std::logic_error&) { + //Storable::Registry(View3D_i::myComment.c_str(),&View3DRestore); + Storable::Registry(Result_i::myComment.c_str(),&ResultRestore); + Storable::Registry(Mesh_i::myComment.c_str(),&MeshRestore); + Storable::Registry(ScalarMap_i::myComment.c_str(),&ScalarMapRestore); + Storable::Registry(DeformedShape_i::myComment.c_str(),&DeformedShapeRestore); + Storable::Registry(CutPlanes_i::myComment.c_str(),&CutPlanesRestore); + Storable::Registry(IsoSurfaces_i::myComment.c_str(),&IsoSurfacesRestore); + Storable::Registry(StreamLines_i::myComment.c_str(),&StreamLinesRestore); + Storable::Registry(Vectors_i::myComment.c_str(),&VectorsRestore); + Storable::Registry(Table_i::myComment.c_str(),&TableRestore); + Storable::Registry(Curve_i::myComment.c_str(),&CurveRestore); + Storable::Registry(Container_i::myComment.c_str(),&ContainerRestore); + } + + void Storable::StrToMap(const QString& theStr, VISU::Storable::TRestoringMap& theMap){ + if(0 && MYDEBUG) MESSAGE("Storable::StrToMap : string="<GetID()); + //aMap.insert(TRestoringMap::value_type("ResultID", strdup(aResultID))); + bool isExist; + QString aComment = VISU::Storable::FindValue(aMap,"myComment",&isExist); + if ( isExist ) { + TCallbackMap::const_iterator i = VisuStoreMap.find(aComment.latin1()); + if(MYDEBUG) MESSAGE("Storable::Create - "<second)(theSObject,thePrefix,aMap); + } + }catch(std::logic_error& exc){ + MESSAGE("Follow exception was accured :\n"<> there is no value for "<> there is no value for ") + theArg); + static QString BAD_VALUE("NULL"); + return BAD_VALUE; + } + if(isFind != NULL) *isFind = true; + return i->second; + } + + //=========================================================================== + PortableServer::Servant GetServant(CORBA::Object_ptr theObject){ + PortableServer::POA_ptr aPOA = Base_i::GetPOA(); + if(CORBA::is_nil(theObject)) + if(MYDEBUG) MESSAGE("GetServant - CORBA::is_nil(theObject)"); + return aPOA->reference_to_servant(theObject); + } + //=========================================================================== + CORBA::Object_var SObjectToObject(SALOMEDS::SObject_ptr theSObject){ + SALOMEDS::GenericAttribute_var anAttr; + CORBA::Object_var anObj; + try{ + if(theSObject->FindAttribute(anAttr, "AttributeIOR")){ + SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); + CORBA::String_var aValue = anIOR->Value(); + CORBA::ORB_ptr anORB = Base_i::GetORB(); + if(strcmp(aValue,"") != 0) + anObj = anORB->string_to_object(aValue); + } + }catch(...){ + MESSAGE("SObjectToObject - Unknown exception was accured!"); + } + return anObj; + } + //=========================================================================== + SALOMEDS::SComponent_var FindOrCreateVisuComponent(SALOMEDS::Study_ptr theStudyDocument){ + SALOMEDS::SComponent_var aSComponent = theStudyDocument->FindComponent("VISU"); + if (aSComponent->_is_nil()) { + SALOMEDS::StudyBuilder_var aStudyBuilder = theStudyDocument->NewBuilder(); + aStudyBuilder->NewCommand(); + int aLocked = theStudyDocument->GetProperties()->IsLocked(); + if (aLocked) theStudyDocument->GetProperties()->SetLocked(false); + aSComponent = aStudyBuilder->NewComponent("VISU"); + SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName"); + SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr); + aName->SetValue("Visu"); + + anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributePixMap"); + SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr); + aPixmap->SetPixMap( "ICON_OBJBROWSER_Visu" ); + + VISU_Gen_var aVisuGen = Base_i::GetVisuGenInter(); + aStudyBuilder->DefineComponentInstance(aSComponent,aVisuGen); + if (aLocked) theStudyDocument->GetProperties()->SetLocked(true); + aStudyBuilder->CommitCommand(); + } + return aSComponent; + } + //=========================================================================== + string FindEntryWithComment(SALOMEDS::Study_ptr theStudyDocument, const char* theStartEntry, + const char* theComment, int IsAllLevels) + { + if(0 && MYDEBUG) MESSAGE("FindEntryWithComment - '"<NewChildIterator(theStudyDocument->FindObjectID(theStartEntry)); + anIter->InitEx(IsAllLevels); + SALOMEDS::SObject_var aFieldSO; + for(;anIter->More();anIter->Next()) { + SALOMEDS::GenericAttribute_var anAttr; + if (anIter->Value()->FindAttribute(anAttr,"AttributeComment")) { + SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr); + CORBA::String_var aString = aCmnt->Value(); + string aValue(aString); + if (aValue == theComment) { + aFieldSO = anIter->Value(); + aString = aFieldSO->GetID(); + aValue = aString; + return aValue; + } + } + } + return ""; + } + //=========================================================================== + string CreateAttributes(SALOMEDS::Study_ptr theStudyDocument, + const char* theFatherEntry, const char* theRefFatherEntry, + const char* theIOR, const char* theName, + const char* thePersistentRef, const char* theComment, + CORBA::Boolean theCreateNew) + { + if(0 && MYDEBUG) + MESSAGE("CreateAttributes - theName = "<SetValue(theIOR); + anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeName"); + SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr); + aName->SetValue(theName); + anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributePersistentRef"); + SALOMEDS::AttributePersistentRef_var aPRef = SALOMEDS::AttributePersistentRef::_narrow(anAttr); + aPRef->SetValue(thePersistentRef); + anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeComment"); + SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr); + aCmnt->SetValue(theComment); + if(strcmp(theRefFatherEntry,"") != 0){ + SALOMEDS::SObject_var aRefFather = theStudyDocument->FindObjectID(theRefFatherEntry); + SALOMEDS::SObject_var anObj = aStudyBuilder->NewObject(aRefFather); + aStudyBuilder->Addreference(anObj,newObj); + } + CORBA::String_var anEntry = newObj->GetID(); + string aRet(anEntry); + if(0 && MYDEBUG) MESSAGE("CreateAttributes - anEntry = "<activate_object(_thisObj); + SALOME_NamingService aNamingService(orb); + CORBA::Object_ptr anObject = aNamingService.Resolve("/Kernel/Session"); + SALOME::Session_var aSession = SALOME::Session::_narrow(anObject); + //aSession->GetInterface(); + myVisuGen = VISU::VISU_Gen::_narrow( aSession->GetVisuComponent() ); + } + + VISU_Gen_i::VISU_Gen_i(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA, + SALOME_NamingService* theNamingService, QMutex* theMutex) : + Engines_Component_i() + { + if(MYDEBUG) MESSAGE("VISU_Gen_i::VISU_Gen_i : "<getActiveStudy()) + QAD_Application::getDesktop()->createStudy(); + myStudyDocument = + QAD_Application::getDesktop()->getActiveStudy()->getStudyDocument(); + Base_i::myPOA->activate_object(this); + } + + VISU_Gen_i::~VISU_Gen_i(){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::~VISU_Gen_i"); + } + //=========================================================================== + bool VISU_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent, + const SALOMEDS::TMPFile & theStream, + const char* theURL, + bool isMultiFile) + { + if(MYDEBUG) MESSAGE("VISU_Gen_i::Load - myMutex = "<GetStudy(); + SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); + TCollection_AsciiString aTmpDir = + isMultiFile?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir(); + VisuSComponent = SALOMEDS::SComponent::_duplicate(theComponent); + VisuTmpDir = aTmpDir.ToCString(); + SALOMEDS::ListOfFileNames_var aSeq = + SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.ToCString(),isMultiFile); + myIsMultiFile = isMultiFile; + return true; + } + return myVisuGen->Load(theComponent,theStream,theURL,isMultiFile); + } + + char* VISU_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject, + const char* aLocalPersistentID, + CORBA::Boolean isMultiFile) { + if(myMutex){ + CORBA::String_var aString(""); + if(strcmp(aLocalPersistentID,"") != 0) { + Mutex mt(myMutex,qApp); + Storable* aStorable = + Storable::Create(theSObject,VisuTmpDir.c_str(),aLocalPersistentID); + if(aStorable != NULL) aString = aStorable->GetID(); + } + return aString._retn(); + } + return myVisuGen->LocalPersistentIDToIOR(theSObject, aLocalPersistentID, isMultiFile); + } + //=========================================================================== + SALOMEDS::TMPFile* VISU_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent, + const char* theURL, + bool isMultiFile) + { + if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - myMutex = "<GetStudy(); + SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent); + for (; itBig->More(); itBig->Next()) { + SALOMEDS::SObject_var gotBranch = itBig->Value(); + CORBA::Object_var anObj = SObjectToObject(gotBranch); + if(CORBA::is_nil(anObj)) continue; + Result_i* pResult = dynamic_cast(GetServant(anObj)); + if(pResult && abs(pResult->GetSourceId()) == Result_i::eFile){ + const QFileInfo& aFileInfo = pResult->GetFileInfo(); + QString aPrefix = SALOMEDS_Tool::GetNameFromPath(aStudy->URL()); + QString aFileName = aPrefix + "_" + (pResult->GetName()).c_str(); + static QString aCommand; + aCommand.sprintf("cp %s %s%s",aFileInfo.filePath().latin1(),aTmpDir.ToCString(),aFileName.latin1()); + if(system(aCommand) == -1){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - Cann't execute the command :"< 0){ + SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames; + aSeq->length(aFileNames.Length()); + for(aCounter = aFileNames.Length(); aCounter > 0; aCounter--) + aSeq[aCounter-1] = CORBA::string_dup(aFileNames.Value(aCounter).ToCString()); + aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile); + if(!isMultiFile) + SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true); + } + return aStreamFile._retn(); + } + return myVisuGen->Save(theComponent,theURL,isMultiFile); + } + + char* VISU_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject, + const char* IORString, + CORBA::Boolean isMultiFile) { + if(MYDEBUG) MESSAGE("VISU_Gen_i::IORToLocalPersistentID - myMutex = "<string_to_object(aString); + if(!CORBA::is_nil(anObj)){ + Storable* pStorable = dynamic_cast(GetServant(anObj)); + if(pStorable != NULL){ + Mutex mt(myMutex,qApp); + aString = pStorable->ToString().c_str(); + return aString._retn(); + } + } + } + return aString._retn(); + } + return myVisuGen->IORToLocalPersistentID(theSObject, IORString, isMultiFile); + } + + void VISU_Gen_i::SetCurrentStudy(SALOMEDS::Study_ptr theStudy){ + //if(MYDEBUG) MESSAGE("VISU_Gen_i::SetCurrentStudy : "<<(!theStudy->_is_nil())); + if(myMutex) + myStudyDocument = SALOMEDS::Study::_duplicate(theStudy); + else + myVisuGen->SetCurrentStudy(theStudy); + } + SALOMEDS::Study_ptr VISU_Gen_i::GetCurrentStudy(){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::GetCurrentStudy : "<GetCurrentStudy(); + } + ViewManager_ptr VISU_Gen_i::GetViewManager(){ + //omni_mutex aMutex; + //omni_mutex_lock aMutexLock(aMutex); + if(MYDEBUG) MESSAGE("VISU_Gen_i::GetViewManager : "<_this()); + } + return myVisuGen->GetViewManager(); + } + + SALOMEDS::SObject_ptr VISU_Gen_i::ImportTables(const char* theFileName){ + if(myMutex){ + if(myStudyDocument->GetProperties()->IsLocked()) return SALOMEDS::SObject::_nil(); + Mutex mt(myMutex,qApp); + SALOMEDS::SObject_var aRes = VISU::ImportTables(theFileName,myStudyDocument); + return aRes._retn(); + } + return myVisuGen->ImportTables(theFileName); + } + + Result_ptr VISU_Gen_i::ImportFile(const char* theFileName){ + if(myMutex){ + if(myStudyDocument->GetProperties()->IsLocked()) return Result::_nil(); + Mutex mt(myMutex,qApp); + aFileInfo.setFile(theFileName); + Result_i* pResult = new Result_i(myStudyDocument); + if(pResult->Create(theFileName) != NULL) + return Result::_duplicate(pResult->_this()); + return Result::_nil(); + } + return myVisuGen->ImportFile(theFileName); + } + + Result_ptr VISU_Gen_i::ImportMed(SALOMEDS::SObject_ptr theMedSObject){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ImportMed : "<GetProperties()->IsLocked()) return Result::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = new Result_i(myStudyDocument); + if(pResult->Create(theMedSObject) != NULL) + return Result::_duplicate(pResult->_this()); + return Result::_nil(); + } + return myVisuGen->ImportMed(theMedSObject); + } + + Mesh_ptr VISU_Gen_i::MeshOnEntity(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::MeshOnEntity : "<GetProperties()->IsLocked()) return Mesh::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + Mesh_i* aPresent = new Mesh_i(pResult); + if(aPresent->Create(theMeshName,theEntity) != NULL) + return Mesh::_duplicate(aPresent->_this()); + return Mesh::_nil(); + } + return myVisuGen->MeshOnEntity(theResult,theMeshName,theEntity); + } + + Mesh_ptr VISU_Gen_i::FamilyMeshOnEntity(Result_ptr theResult, const char* theMeshName, + VISU::Entity theEntity, + const char* theFamilyName){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::FamilyMeshOnEntity : "<GetProperties()->IsLocked()) return Mesh::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + Mesh_i* aPresent = new Mesh_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFamilyName) != NULL) + return Mesh::_duplicate(aPresent->_this()); + return Mesh::_nil(); + } + return myVisuGen->FamilyMeshOnEntity(theResult,theMeshName,theEntity,theFamilyName); + } + + Mesh_ptr VISU_Gen_i::GroupMesh(Result_ptr theResult, const char* theMeshName, + const char* theGroupName){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::GroupMesh : "<GetProperties()->IsLocked()) return Mesh::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + Mesh_i* aPresent = new Mesh_i(pResult); + if(aPresent->Create(theMeshName,theGroupName) != NULL) + return Mesh::_duplicate(aPresent->_this()); + return Mesh::_nil(); + } + return myVisuGen->GroupMesh(theResult,theMeshName,theGroupName); + } + + ScalarMap_ptr VISU_Gen_i::ScalarMapOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<GetProperties()->IsLocked()) return ScalarMap::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + if(ScalarMap_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){ + ScalarMap_i* aPresent = new ScalarMap_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL) + return ScalarMap::_duplicate(aPresent->_this()); + } + return ScalarMap::_nil(); + } + return myVisuGen->ScalarMapOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); + } + + DeformedShape_ptr VISU_Gen_i::DeformedShapeOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<GetProperties()->IsLocked()) return DeformedShape::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + if(DeformedShape_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){ + DeformedShape_i* aPresent = new DeformedShape_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL) + return DeformedShape::_duplicate(aPresent->_this()); + } + return DeformedShape::_nil(); + } + return myVisuGen->DeformedShapeOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); + } + + Vectors_ptr VISU_Gen_i::VectorsOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<GetProperties()->IsLocked()) return Vectors::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + if(Vectors_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){ + Vectors_i* aPresent = new Vectors_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL) + return Vectors::_duplicate(aPresent->_this()); + } + return Vectors::_nil(); + } + return myVisuGen->VectorsOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); + } + + IsoSurfaces_ptr VISU_Gen_i::IsoSurfacesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<GetProperties()->IsLocked()) return IsoSurfaces::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + if(IsoSurfaces_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){ + IsoSurfaces_i* aPresent = new IsoSurfaces_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL) + return IsoSurfaces::_duplicate(aPresent->_this()); + } + return IsoSurfaces::_nil(); + } + return myVisuGen->IsoSurfacesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); + } + + StreamLines_ptr VISU_Gen_i::StreamLinesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<GetProperties()->IsLocked()) return StreamLines::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + if(StreamLines_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){ + StreamLines_i* aPresent = new StreamLines_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL) + return StreamLines::_duplicate(aPresent->_this()); + } + return StreamLines::_nil(); + } + return myVisuGen->StreamLinesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); + } + + CutPlanes_ptr VISU_Gen_i::CutPlanesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<GetProperties()->IsLocked()) return CutPlanes::_nil(); + Mutex mt(myMutex,qApp); + Result_i* pResult = dynamic_cast(GetServant(theResult)); + if(CutPlanes_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){ + CutPlanes_i* aPresent = new CutPlanes_i(pResult); + if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL) + return CutPlanes::_duplicate(aPresent->_this()); + } + return CutPlanes::_nil(); + } + return myVisuGen->CutPlanesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); + } + + Table_ptr VISU_Gen_i::CreateTable(const char* theTableEntry){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateTable : "<GetProperties()->IsLocked()) return Table::_nil(); + Mutex mt(myMutex,qApp); + Table_i* aPresent = new Table_i(myStudyDocument,theTableEntry); + if(aPresent->Create() != NULL) + return Table::_duplicate(aPresent->_this()); + return Table::_nil(); + } + return myVisuGen->CreateTable(theTableEntry); + } + + Curve_ptr VISU_Gen_i::CreateCurve(Table_ptr theTable, CORBA::Long theHRow, CORBA::Long theVRow){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateCurve : "<GetProperties()->IsLocked()) return Curve::_nil(); + Mutex mt(myMutex,qApp); + PortableServer::POA_ptr aPOA = GetPOA(); + Table_i* pTable = dynamic_cast(aPOA->reference_to_servant(theTable)); + Curve_i* aPresent = new Curve_i(myStudyDocument,pTable,theHRow,theVRow); + if(aPresent->Create() != NULL) { + return Curve::_duplicate(aPresent->_this()); + } + return Curve::_nil(); + } + return myVisuGen->CreateCurve(theTable,theHRow,theVRow); + } + Container_ptr VISU_Gen_i::CreateContainer(){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateContainer : "<GetProperties()->IsLocked()) return Container::_nil(); + Mutex mt(myMutex,qApp); + Container_i* aPresent = new Container_i(myStudyDocument); + if(aPresent->Create() != NULL) { + return Container::_duplicate(aPresent->_this()); + } + return Container::_nil(); + } + return myVisuGen->CreateContainer(); + } + + void VISU_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent){ + if(MYDEBUG) MESSAGE("VISU_Gen_i::Close : "<GetStudy(); + if(!aStudy->_is_nil()){ + SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent); + for (int i = 0; itBig->More(); itBig->Next(),i++) { + SALOMEDS::SObject_var gotBranch = itBig->Value(); + if(MYDEBUG) MESSAGE("VISU_Gen_i::Close : itBig->Next() = "<(GetServant(anObj)); + if(pResult->GetSourceId() == Result_i::eRestoredFile){ //Try remove its file and directory + const QFileInfo& aFileInfo = pResult->GetFileInfo(); + static QString aCommand; + aCommand.sprintf("rm %s",aFileInfo.filePath().latin1()); + if(system(aCommand) != -1 && MYDEBUG) MESSAGE("VISU_Gen_i::Close - "<Close(theComponent); + } + + char* VISU_Gen_i::ComponentDataType(){ + return CORBA::string_dup("VISU"); + } + + bool VISU_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR) { + Result_var aResultObj = Result::_narrow(theIOR); + return !(aResultObj->_is_nil()); + } + + SALOMEDS::SObject_ptr VISU_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy, + SALOMEDS::SObject_ptr theSObject, + CORBA::Object_ptr theObject, + const char* theName) + throw (SALOME::SALOME_Exception) + { + if(MYDEBUG) MESSAGE("VISU_Gen_i::PublishInStudy : "<(GetServant(theObject)); + if (!aResultObj) return aResultSO._retn(); + const QFileInfo& aFileInfo = aResultObj->GetFileInfo(); + CORBA::String_var anEntry = aResultObj->Create(aFileInfo.filePath().latin1())->GetID(); + aResultSO = theStudy->FindObjectID(anEntry); + return aResultSO._retn(); + } + return myVisuGen->PublishInStudy(theStudy, theSObject, theObject, theName); + } + + CORBA::Boolean VISU_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) { + if(0 && MYDEBUG) MESSAGE("VISU_Gen_i::CanCopy : "<FindAttribute(anAttr, "AttributeIOR")) return false; + try { + SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); + CORBA::String_var aValue = anIOR->Value(); + if(strcmp(aValue,"") != 0){ + CORBA::Object_ptr anObj = GetORB()->string_to_object(aValue); + if (!CORBA::is_nil(anObj)){ + Result_var aResultObj = Result::_narrow(anObj); + if(!aResultObj->_is_nil()){ + Result_i* pResult = dynamic_cast(GetServant(aResultObj)); + if(pResult != NULL){ + if(abs(pResult->GetSourceId()) > Result_i::eFile) + if((pResult->GetFileInfo()).filePath() == "Med") return false; + return true; + } + } + } + } + } catch (...) { + MESSAGE("Unknown exception was accured!"); + } + return false; + } + return myVisuGen->CanCopy(theObject); + } + + SALOMEDS::TMPFile* VISU_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID) { + if(MYDEBUG) MESSAGE("VISU_Gen_i::CopyFrom : "<FindAttribute(anAttr,"AttributeIOR")) return NULL; + SALOMEDS::AttributeIOR_var anIORAttr = SALOMEDS::AttributeIOR::_narrow(anAttr); + CORBA::Object_var aCorbaObj; + try { + aCorbaObj = GetORB()->string_to_object(anIORAttr->Value()); + } catch(...) { + aStreamFile->length(1); + aStreamFile[0] = strdup("E")[0]; + return aStreamFile._retn(); + } + if (CORBA::is_nil(aCorbaObj)) { + return NULL; + } + + Storable* pStorable = dynamic_cast(GetServant(aCorbaObj)); + if (!pStorable) { + return NULL; + } + CORBA::String_var aTmpDir = SALOMEDS_Tool::GetTmpDir(); + + string aStr = pStorable->ToString().c_str(); + ofstream stmOut2((string(aTmpDir) + string("copy_persistent")).c_str(),ios::out); + stmOut2<(aPOA->reference_to_servant(aCorbaObj)); + if (aResultObj) { + string aFileName = string(SALOMEDS_Tool::GetNameFromPath(theObject->GetStudy()->URL())) + "_"; + const QFileInfo& aFileInfo = aResultObj->GetFileInfo(); + aFileName += aFileInfo.fileName().latin1(); + static QString aCommand; + aCommand.sprintf("cp %s %s", + aFileInfo.filePath().latin1(), + (string(aTmpDir) + aFileName).c_str()); + if(system(aCommand) == -1) { + if(MYDEBUG) MESSAGE("VISU_Gen_i::Copy - Cann't execute the command :"<length(2); + aSeq[0] = "copy_persistent"; + aSeq[1] = aFileName.c_str(); + } else { + aSeq->length(1); + aSeq[0] = "copy_persistent"; + } + aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir, aSeq.in(), false); + SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeq.in(), true); + + // Assign an ID = 1 the the type VISU::Result + theObjectID = 1; + return aStreamFile._retn(); + } + return myVisuGen->CopyFrom(theObject, theObjectID); + } + + CORBA::Boolean VISU_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) { + // The VISU component can paste only objects copied by VISU component + // and with the object type = 1 + if(0 && MYDEBUG) MESSAGE("VISU_Gen_i::CanPaste : "<length() > 1) aFileName += aSeq[1].in(); + Storable* aStorable = Storable::Create(theObject,aFileName,aString); + + SALOMEDS::ListOfFileNames_var aSeqToRm = new SALOMEDS::ListOfFileNames; + aSeqToRm->length(1); + aSeqToRm[0] = "copy_persistent"; + SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeqToRm.in(), true); + + SALOMEDS::SComponent_var aComponent = theObject->GetFatherComponent(); + SALOMEDS::Study_var aStudy = theObject->GetStudy(); + SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); + CORBA::String_var aComponentID(aComponent->GetID()), aSObjID(theObject->GetID()); + if (strcmp(aComponentID, aSObjID) == 0) //create the new result SObject + aResultSO = aStudyBuilder->NewObject(aComponent); + else + aResultSO = SALOMEDS::SObject::_duplicate(theObject); + SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR"); + SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); + CORBA::String_var anIORValue(aStorable->GetID()); + anIOR->SetValue(anIORValue); + return aResultSO._retn(); + } + return myVisuGen->PasteInto(theStream,theObjectID,theObject); + } + +}; diff --git a/src/VISU_I/VISU_Gen_i.hh b/src/VISU_I/VISU_Gen_i.hh new file mode 100644 index 00000000..3b5e2386 --- /dev/null +++ b/src/VISU_I/VISU_Gen_i.hh @@ -0,0 +1,105 @@ +// File : VISU_GEN_i.h file +// Created : +// Author : Alexey Petrov +// Project : SALOME +// Copyright : OPEN CASCADE +// $Header: + + +#ifndef __VISU_GEN_I_H__ +#define __VISU_GEN_I_H__ + +#include "VISUConfig.hh" + +#include "SALOME_Component_i.hxx" +#include "SALOME_NamingService.hxx" + +namespace VISU{ + class VISU_Gen_i : public virtual POA_VISU::VISU_Gen, + public virtual ::Engines_Component_i, + public virtual Base_i + { + VISU_Gen_var myVisuGen; + SALOMEDS::Study_var myStudyDocument; + VISU_Gen_i(); + VISU_Gen_i(const VISU::VISU_Gen_i &); + public: + VISU_Gen_i(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA, + SALOME_NamingService* theNamingService, QMutex* theMutex); + VISU_Gen_i(CORBA::ORB_ptr orb, + PortableServer::POA_ptr poa, + PortableServer::ObjectId * contId, + const char *instanceName, + const char *interfaceName); + virtual ~VISU_Gen_i(); + virtual VISU::VISUType GetType() { return VISU::TVISUGEN;}; + + virtual void SetCurrentStudy(SALOMEDS::Study_ptr theStudy); + virtual SALOMEDS::Study_ptr GetCurrentStudy(); + virtual ViewManager_ptr GetViewManager(); + + virtual SALOMEDS::SObject_ptr ImportTables(const char* theFileName); + + //Create Result + virtual Result_ptr ImportFile(const char* theFileName); + virtual Result_ptr ImportMed(SALOMEDS::SObject_ptr theMedSObject); + + //Create Presentation Of Submeshes + virtual Mesh_ptr MeshOnEntity(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity); + virtual Mesh_ptr FamilyMeshOnEntity(Result_ptr theResult, const char* theMeshName, + VISU::Entity theEntity, const char* theFamilyName); + virtual Mesh_ptr GroupMesh(Result_ptr theResult, const char* theMeshName, const char* theGroupName); + + //Create 3D collored Presentation Of Different Types + virtual ScalarMap_ptr ScalarMapOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration); + virtual DeformedShape_ptr DeformedShapeOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration); + virtual Vectors_ptr VectorsOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration); + virtual IsoSurfaces_ptr IsoSurfacesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration); + virtual CutPlanes_ptr CutPlanesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration); + virtual StreamLines_ptr StreamLinesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration); + //Create Digital Presentation + virtual Table_ptr CreateTable(const char* theTableEntry); + virtual Curve_ptr CreateCurve(Table_ptr theTable, CORBA::Long theHRow, CORBA::Long theVRow); + virtual Container_ptr CreateContainer(); + + // inherited methods from SALOMEDS::Driver + virtual SALOMEDS::TMPFile* Save(SALOMEDS::SComponent_ptr theComponent, + const char* theURL, + bool isMultiFile); + virtual bool Load(SALOMEDS::SComponent_ptr, + const SALOMEDS::TMPFile &, + const char* theURL, + bool isMultiFile); + + virtual void Close(SALOMEDS::SComponent_ptr IORSComponent); + + virtual char* ComponentDataType(); + + virtual char* IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject, + const char* IORString, + CORBA::Boolean isMultiFile); + virtual char* LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject, + const char* aLocalPersistentID, + CORBA::Boolean isMultiFile); + + virtual bool CanPublishInStudy(CORBA::Object_ptr theIOR); + virtual SALOMEDS::SObject_ptr PublishInStudy(SALOMEDS::Study_ptr theStudy, + SALOMEDS::SObject_ptr theSObject, + CORBA::Object_ptr theObject, + const char* theName) throw (SALOME::SALOME_Exception); + + CORBA::Boolean CanCopy(SALOMEDS::SObject_ptr theObject); + SALOMEDS::TMPFile* CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID); + CORBA::Boolean CanPaste(const char* theComponentName, CORBA::Long theObjectID); + SALOMEDS::SObject_ptr PasteInto(const SALOMEDS::TMPFile& theStream, + CORBA::Long theObjectID, + SALOMEDS::SObject_ptr theObject); + }; +} +#endif diff --git a/src/VISU_I/VISU_LookupTable.cxx b/src/VISU_I/VISU_LookupTable.cxx new file mode 100644 index 00000000..af543757 --- /dev/null +++ b/src/VISU_I/VISU_LookupTable.cxx @@ -0,0 +1,79 @@ +using namespace std; +// File : VISU_LookupTable.cxx +// Created : UI team, 18.02.03 +// Descr : Scaling values of vtkLookupTable +// Author : Vitaliy Smetannikov +// Project : SALOME +// Module : OBJECT +// Copyright : Open CASCADE 2003 + + +#include "VISU_LookupTable.hxx" +#include "vtkObjectFactory.h" + + +VISU_LookupTable *VISU_LookupTable::New() { + vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_LookupTable"); + if(ret) { + return (VISU_LookupTable*)ret; + } + // If the factory was unable to create the object, then create it here. + return new VISU_LookupTable; +} + +VISU_LookupTable::VISU_LookupTable(int sze, int ext) + : vtkLogLookupTable(sze, ext), myScale(1.), myIsLog(0) +{} + +int VISU_LookupTable::ComputeLogRange(float inRange[2], float outRange[2]){ + if(inRange[0] >= inRange[1]){ + //vtkErrorMacro (<<"Minimum value must be less than maximum value"); + return -1; + } + if(0.0 <= inRange[0] && 0.0 < inRange[1]){ + if (inRange[0] == 0.0) inRange[0] = 1.0e-06 * (inRange[1] - inRange[0]); + outRange[0] = log10((double)inRange[0]); + outRange[1] = log10((double)inRange[1]); + return 0; + }else if(inRange[0] < 0.0 && inRange[1] <= 0.0){ + outRange[0] = log10((double)-inRange[0]); + outRange[1] = log10((double)-inRange[1]); + return 1; + }else{ + //vtkErrorMacro(<<"Can't use logarithmic table on mixed negative/positive values"); + return -1; + } +} + +void VISU_LookupTable::SetTableRange(float min, float max){ + this->TableRange[0] = min; + this->TableRange[1] = max; + this->UseAbsoluteValue = ComputeLogRange(this->TableRange,this->myLogRange); + if(this->UseAbsoluteValue < 0) return; + this->LogMinRange = this->myLogRange[0]; + this->LogMaxRange = this->myLogRange[1]; +} + +unsigned char* VISU_LookupTable::MapValue(float v) { + v = this->TableRange[0] + (v - this->TableRange[0])*myScale; + if(myIsLog) { + v = pow((float)10.0,v)*myScale; + //v = pow(10.0, (this->LogMinRange + (v - this->LogMinRange)))*myScale; + return vtkLogLookupTable::MapValue(v); + }else{ + //v *= myScale; + return vtkLookupTable::MapValue(v); + } +} + + + + + + + + + + + + diff --git a/src/VISU_I/VISU_LookupTable.hxx b/src/VISU_I/VISU_LookupTable.hxx new file mode 100644 index 00000000..a690fb63 --- /dev/null +++ b/src/VISU_I/VISU_LookupTable.hxx @@ -0,0 +1,41 @@ +// File : VISU_LookupTable.h +// Created : UI team, 18.02.03 +// Descr : Scaling values of vtkLookupTable +// Author : Vitaliy Smetannikov +// Project : SALOME +// Module : OBJECT +// Copyright : Open CASCADE 2003 + + +#ifndef VISU_LookupTable_H +#define VISU_LookupTable_H + +//#include +#include + +class VISU_LookupTable: public vtkLogLookupTable { + public: + vtkTypeMacro(VISU_LookupTable,vtkLogLookupTable); + + static VISU_LookupTable *New(); + + void SetTableRange(float min, float max); + static int ComputeLogRange(float inRange[2], float outRange[2]); + float* GetLogRange() { return myLogRange;} + unsigned char *MapValue(float v); + + float GetMapScale() { return myScale; } + void SetMapScale(float theScale) { myScale = theScale; Modified(); } + + int IsLog() { return myIsLog; } + void SetLog(int theLog) { myIsLog = theLog; Modified(); } + + protected: + VISU_LookupTable(int sze=256, int ext=256); + ~VISU_LookupTable() {}; + + float myScale; + int myIsLog; + float myLogRange[2]; +}; +#endif // VISU_LookupTable_H diff --git a/src/VISU_I/VISU_MedConvertor.cxx b/src/VISU_I/VISU_MedConvertor.cxx new file mode 100644 index 00000000..2ae5ff24 --- /dev/null +++ b/src/VISU_I/VISU_MedConvertor.cxx @@ -0,0 +1,625 @@ +using namespace std; + +// File: VISU_MedConvertor.cxx +// Created: Fri Jan 10 12:04:54 2003 +// Author: Alexey PETROV +// + + +#include "VISU_MedConvertor.hxx" +#include +#include +#define USER_INTERLACE MED_FULL_INTERLACE +using namespace std; + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 1; +#endif +static med_err ret = 0; + +typedef map TVisu2MedEntity; +static TVisu2MedEntity aVisu2MedEntity; +static int INIT = ( + aVisu2MedEntity[VISU::NODE_ENTITY] = MED_NOEUD, + aVisu2MedEntity[VISU::EDGE_ENTITY] = MED_ARETE, + aVisu2MedEntity[VISU::FACE_ENTITY] = MED_FACE, + aVisu2MedEntity[VISU::CELL_ENTITY] = MED_MAILLE, + 1); + +static med_geometrie_element NODEGEOM[1] = {MED_POINT1}; +static med_geometrie_element EDGEGEOM[MED_NBR_GEOMETRIE_ARETE] = { + MED_SEG2, MED_SEG3 + }; +static med_geometrie_element FACEGEOM[MED_NBR_GEOMETRIE_FACE] = { + MED_TRIA3, MED_QUAD4, MED_TRIA6, MED_QUAD8 + }; +static med_geometrie_element CELLGEOM[MED_NBR_GEOMETRIE_MAILLE] = { + MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3, + MED_QUAD4, MED_TRIA6, MED_QUAD8, MED_TETRA4, + MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10, + MED_PYRA13, MED_PENTA15, MED_HEXA20 + }; +void GetEntity2Geom(const VISU::TEntity& theEntity, med_geometrie_element*& theVector, int* theEnd) + throw (std::runtime_error&) +{ + switch(theEntity){ + case VISU::CELL_ENTITY: theVector = CELLGEOM; *theEnd = MED_NBR_GEOMETRIE_MAILLE; break; + case VISU::FACE_ENTITY: theVector = FACEGEOM; *theEnd = MED_NBR_GEOMETRIE_FACE; break; + case VISU::EDGE_ENTITY: theVector = EDGEGEOM; *theEnd = MED_NBR_GEOMETRIE_ARETE; break; + case VISU::NODE_ENTITY: theVector = NODEGEOM; *theEnd = 1; break; + default: + throw std::runtime_error("GetEntity2Geom >> theEntity is uncorrect"); + } +} + +extern "C" +VISU_Convertor* CreateMedConvertor(const string& theFileName) throw(std::runtime_error&){ + return new VISU_MedConvertor(theFileName); +} + +int med2vtkCellType(int medType){ + for(int i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++) + if(med2vtk[i].medType == medType) return med2vtk[i].vtkType; + return -1; +} + +int vtk2medCellType(int vtkType){ + for(int i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++) + if(med2vtk[i].vtkType == vtkType) return med2vtk[i].medType; + return -1; +} + +class MedFile{ + char* myFileName; + med_idt myFid; + MedFile(); + MedFile(const MedFile&); +public: + MedFile(const char* theFileName) throw(std::runtime_error&) : + myFileName(strdup(theFileName)) + { + myFid = MEDouvrir(myFileName,MED_LECT); + if(myFid < 0){ + free(myFileName); + throw std::runtime_error(string("MedFile::MedFile >> MEDouvrir(...) - ") + theFileName); + } + } + ~MedFile(){ + free(myFileName); + if(myFid >= 0) + MEDfermer(myFid); + } + const med_idt& GetFid() const { return myFid;}; +}; + +VISU_MedConvertor::VISU_MedConvertor(const string& theFileName) throw (std::runtime_error&) { + myFileInfo.setFile(QString(theFileName.c_str())); + myName = myFileInfo.baseName(); +} + +VISU_Convertor* VISU_MedConvertor::Build() throw (std::runtime_error&) { + MedFile aMedFile(myFileInfo.absFilePath()); + med_idt fid = aMedFile.GetFid(); + med_int iMeshEnd = MEDnMaa(fid); //Get number of meshes + if(MYDEBUG) MESSAGE("ImportInfo - MEDnMaa = "<> MEDnoeudsLire(...)"); + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) + if(num_fam_elem[iNumElem] != 0) + aFamily2EntityMap[num_fam_elem[iNumElem]] = anEntity; + } + } + //Get number of connectivities + med_int iNumElemEnd = MEDnEntMaa(fid,aMeshName,MED_CONN,aMedEntity,aMedType,MED_NOD); + if (iNumElemEnd > 0) { + VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity]; + aMeshOnEntity.myEntity = anEntity; + aMeshOnEntity.myMeshName = aMeshName; + med_booleen iname_elem, inum_elem; + valarray num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd); + valarray name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1); + med_int aNbConnForElem = getNbMedConnect(aMedType,anEntity,aMesh.myDim); + if(MYDEBUG) + MESSAGE("ImportInfo -\t anEntity = "<> MEDelementsLire(...)"); + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) + if(num_fam_elem[iNumElem] != 0) + aFamily2EntityMap[num_fam_elem[iNumElem]] = anEntity; + } + } + } + med_int aNbFamily = MEDnFam(fid,aMeshName,0,MED_FAMILLE); + if(MYDEBUG) MESSAGE("ImportInfo - aNbFamily = "< anAttId(aNbAttrib), anAttVal(aNbAttrib); + valarray anAttDesc('\0',aNbAttrib*MED_TAILLE_DESC+1); + med_int aNbGroup = MEDnFam(fid,aMeshName,aFamInd,MED_GROUPE); + if(0 && MYDEBUG) + MESSAGE("ImportInfo - aFamInd = "<> MEDfamInfo"); + if(0 && MYDEBUG) + MESSAGE("ImportInfo - aFamilyNum = "<second; + const VISU::TFamilyMap& aFamilyMap = aMeshOnEntity.myFamilyMap; + if(aFamilyMap.empty()) continue; + VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.begin(); + for(; aFamilyMapIter != aFamilyMap.end(); aFamilyMapIter++){ + const VISU::TFamily& aFamily = aFamilyMapIter->second; + const VISU::TBindGroups& aBindGroups = aFamily.myGroups; + if(aBindGroups.empty()) continue; + VISU::TBindGroups::const_iterator aBindGroupsIter = aBindGroups.begin(); + for(; aBindGroupsIter != aBindGroups.end(); aBindGroupsIter++){ + const string& aGroupName = *aBindGroupsIter; + VISU::TGroup& aGroup = aGroupMap[aGroupName]; + aGroup.myName = aGroupName; + aGroup.myMeshName = aMesh.myName; + VISU::TFamilyAndEntity aFamilyAndEntity(aFamily.myName,aFamily.myEntity); + aGroup.myFamilyAndEntitySet.insert(aFamilyAndEntity); + } + } + } + //Displaing information for the TMesh.TGroupMap + VISU::TGroupMap::const_iterator aGroupMapIter = aGroupMap.begin(); + if(MYDEBUG) MESSAGE("ImportInfo - aGroupMap.size() = "<first; + if(MYDEBUG) MESSAGE("ImportInfo - aGroupName = '"<second; + const VISU::TFamilyAndEntitySet& aFamilyAndEntitySet = aGroup.myFamilyAndEntitySet; + VISU::TFamilyAndEntitySet::const_iterator aFamilyAndEntitySetIter = aFamilyAndEntitySet.begin(); + for(; aFamilyAndEntitySetIter != aFamilyAndEntitySet.end(); aFamilyAndEntitySetIter++){ + const string& aFamilyName = aFamilyAndEntitySetIter->first; + if(MYDEBUG) MESSAGE("ImportInfo - \t aFamilyName = '"<> MEDnChamp(fid,0)"); + if(MYDEBUG) MESSAGE("ImportInfo - iFieldEnd = "<> MEDnChamp(fid,i)"); + valarray comp('\0',ncomp*MED_TAILLE_PNOM + 1); + valarray unit('\0',ncomp*MED_TAILLE_PNOM + 1); + char name_field[MED_TAILLE_NOM + 1] = ""; + med_type_champ type_field; + if(MEDchampInfo(fid,iField,name_field,&type_field,&comp[0],&unit[0],ncomp) < 0) + throw std::runtime_error(string("ImportInfo >> MEDchampInfo(...)")); + //if(type_field != MED_REEL64) continue; //There is some problem in reading INTXX values + TVisu2MedEntity::const_iterator aVisu2MedEntityIter = aVisu2MedEntity.begin(); + for(; aVisu2MedEntityIter != aVisu2MedEntity.end(); aVisu2MedEntityIter++) { + VISU::TEntity anEntity = aVisu2MedEntityIter->first; + int iGeomElemEnd; + med_geometrie_element* aGeomElemVector; + GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd); + med_entite_maillage& aMedEntity = aVisu2MedEntity[anEntity]; + for (int iGeomElem = 0; iGeomElem < iGeomElemEnd; iGeomElem++) { + med_geometrie_element& aGeom = aGeomElemVector[iGeomElem]; + med_int iTimeStampEnd = MEDnPasdetemps(fid,name_field,aMedEntity,aGeom); + if(iTimeStampEnd < 0) throw std::runtime_error("ImportInfo >> MEDnPasdetemps(...)"); + if(iTimeStampEnd > 0) { + for(med_int iTimeStamp = 1; iTimeStamp <= iTimeStampEnd; iTimeStamp++) { + char aMeshName[MED_TAILLE_NOM+1] = ""; + med_int ngauss = 0, numdt = 0, numo = 0; + char dt_unit[MED_TAILLE_PNOM+1] = ""; + med_float dt = 0; + ret = MEDpasdetempsInfo(fid,name_field,aMedEntity,aGeom,iTimeStamp, + aMeshName,&ngauss,&numdt,dt_unit,&dt,&numo); + if(ret < 0) throw std::runtime_error("ImportInfo >> MEDpasdetempsInfo(...) < 0"); + if(myMeshMap.find(aMeshName) == myMeshMap.end()) + throw std::runtime_error("ImportInfo >> MEDpasdetempsInfo(...)"); + VISU::TMesh &aMesh = myMeshMap[aMeshName]; + VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity]; + VISU::TFieldMap::iterator aFieldMapIter = aMeshOnEntity.myFieldMap.find(name_field); + //if(MYDEBUG && aFieldMapIter == aMeshOnEntity.myFieldMap.end()){ + VISU::TField& aField = aMeshOnEntity.myFieldMap[name_field]; + if(iTimeStamp == 1){ + if(MYDEBUG){ + MESSAGE("ImportInfo - aField.myName = '"<first; + const VISU::TEntity& anEntity = aFamilyAndEntitySetIter->second; + VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap[anEntity]; + if(anEntity == VISU::NODE_ENTITY){ + isPointsUpdated += LoadPoints(fid,theMesh,aFamilyName); + isCellsOnEntityUpdated += LoadCellsOnEntity(fid,aMeshOnEntity); + }else{ + isPointsUpdated += LoadPoints(fid,theMesh); + isCellsOnEntityUpdated += LoadCellsOnEntity(fid,aMeshOnEntity,aFamilyName); + } + } + + return (isPointsUpdated || isCellsOnEntityUpdated); +} + +int VISU_MedConvertor::LoadFieldOnMesh(VISU::TMesh& theMesh, + VISU::TMeshOnEntity& theMeshOnEntity, + VISU::TField& theField, + VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&) +{ + //Open the med file (it will be closed by call of destructor) + MedFile aMedFile(myFileInfo.absFilePath()); + med_idt fid = aMedFile.GetFid(); + //Main part of code + int isPointsUpdated = LoadPoints(fid,theMesh); + int isCellsOnEntityUpdated = LoadCellsOnEntity(fid,theMeshOnEntity); + int isFieldUpdated = LoadField(fid,theMeshOnEntity,theField,theValForTime); + + return (isPointsUpdated || isCellsOnEntityUpdated || isFieldUpdated); +} + +int VISU_MedConvertor::LoadPoints(const med_idt& fid, VISU::TMesh& theMesh, const string& theFamilyName) + throw (std::runtime_error&) +{ + //Check on existing family + VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap[VISU::NODE_ENTITY]; + aMeshOnEntity.myEntity = VISU::NODE_ENTITY; + aMeshOnEntity.myMeshName = theMesh.myName; + VISU::TFamily* pFamily = VISU::GetFamily(aMeshOnEntity,theFamilyName); + bool isFamilyPresent = (pFamily != NULL); + VISU::TFamily& aFamily = *pFamily; + //Check on loading already done + bool isPointsLoaded = !theMesh.myPointsCoord.empty(); + if(isPointsLoaded) + if(!isFamilyPresent) return 0; + else if(!aFamily.mySubMesh.empty()) return 0; + if(MYDEBUG) + MESSAGE("LoadPoints - isPointsLoaded = "<> MEDnEntMaa(...)"); + if(MYDEBUG) MESSAGE("LoadPoints - iNumElemEnd = "< num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd); + valarray name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1); + valarray name_coord('\0',theMesh.myDim*MED_TAILLE_PNOM+1); + valarray unit_coord('\0',theMesh.myDim*MED_TAILLE_PNOM+1); + valarray coord(theMesh.myDim*iNumElemEnd); + ret = MEDnoeudsLire(fid,aMeshName,theMesh.myDim,&coord[0],MED_FULL_INTERLACE,&rep, + &name_coord[0],&unit_coord[0],&name_elem[0],&iname_elem, + &num_elem[0],&inum_elem,&num_fam_elem[0],iNumElemEnd); + if(ret < 0) throw std::runtime_error("LoadPoints >> MEDnoeudsLire(...)"); + if(!isPointsLoaded){ + VISU::TMesh::TPointsCoord& aPointsCoord = theMesh.myPointsCoord; + aPointsCoord.resize(iNumElemEnd*theMesh.myDim); + if(MYDEBUG) MESSAGE("LoadPoints - Filling coordinates of the mesh - inum_elem = "< 0){ + if(MYDEBUG) MESSAGE("LoadPoints - Filling aFamily SubMesh"); + VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aFamily.mySubMesh[VTK_VERTEX]; + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) + if(num_fam_elem[iNumElem] == aFamily.myId) + aSubMeshOnCellType.insert(iNumElem); + } + return 1; +} + +int VISU_MedConvertor::LoadCellsOnEntity(const med_idt& fid, VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName) + throw (std::runtime_error&) +{ + //Check on existing family + VISU::TFamily* pFamily = VISU::GetFamily(theMeshOnEntity,theFamilyName); + bool isFamilyPresent = (pFamily != NULL); + VISU::TFamily& aFamily = *pFamily; + //Check on loading already done + bool isCellsLoaded = !theMeshOnEntity.myCellsConn.empty(); + if(isCellsLoaded) + if(!isFamilyPresent) return 0; + else if(!aFamily.mySubMesh.empty()) return 0; + if(MYDEBUG) { + MESSAGE("LoadCellsOnEntity - theFamilyName = '"< 0) { + med_booleen iname_elem, inum_elem; + valarray num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd); + valarray name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1); + med_int aNbConnForElem = getNbMedConnect(aMedType,anEntity,aMesh.myDim); + if(MYDEBUG) MESSAGE("LoadCellsOnEntity - medName = "<> MEDelementsLire(...)"); + if(!isCellsLoaded){ + VISU::TMeshOnEntity::TConnForCellType& aConnForCellType = theMeshOnEntity.myCellsConn[aVtkType]; + aConnForCellType.resize(iNumElemEnd); + valarray aConnect(nbMedNodes); + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) { + VISU::TMeshOnEntity::TConnect& anArray = aConnForCellType[iNumElem]; + anArray.resize(nbVtkNodes); + for (int k = 0, kj = iNumElem*aNbConnForElem; k < nbMedNodes; k++) { + aConnect[k] = conn[kj+k] - 1; + } + switch(aMedType){ + case MED_TETRA4 : + case MED_TETRA10 : + anArray[0] = aConnect[0]; + anArray[1] = aConnect[1]; + anArray[2] = aConnect[3]; + anArray[3] = aConnect[2]; + break; + case MED_PYRA5 : + case MED_PYRA13 : + anArray[0] = aConnect[0]; + anArray[1] = aConnect[3]; + anArray[2] = aConnect[2]; + anArray[3] = aConnect[1]; + anArray[4] = aConnect[4]; + break; + default: + for (int k = 0; k < nbVtkNodes; k++) + anArray[k] = aConnect[k]; + } + for (int k = 0; k < nbVtkNodes; k++) + if(anArray[k] < 0 || aNbPoints <= anArray[k]){ + static QString aString; + aString.sprintf("ImportCells >> aNbPoints(%d) <= anArray[%d][%d](%d) < 0",aNbPoints,iNumElem,k,anArray[k]); + throw std::runtime_error(aString.latin1()); + } + } + } + //Filling aFamily SubMesh + if(isFamilyPresent){ + VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aFamily.mySubMesh[aVtkType]; + for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) + if(num_fam_elem[iNumElem] == aFamily.myId) + aSubMeshOnCellType.insert(iNumElem); + } + } + } + return 1; +} + +int VISU_MedConvertor::LoadField(const med_idt& fid, const VISU::TMeshOnEntity& theMeshOnEntity, + const VISU::TField& theField, VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&) +{ + //Check on loading already done + if(!theValForTime.myValForCells.empty()) return 0; + //Main part of code + med_int ncomp = MEDnChamp(fid,theField.myId); + if(ncomp < 0) throw std::runtime_error("LoadField >> MEDnChamp(fid,i)"); + valarray comp('\0',ncomp*MED_TAILLE_PNOM + 1); + valarray unit('\0',ncomp*MED_TAILLE_PNOM + 1); + char aFieldName[MED_TAILLE_NOM + 1] = ""; + med_type_champ type_field; + if(MEDchampInfo(fid,theField.myId,aFieldName,&type_field,&comp[0],&unit[0],ncomp) < 0) + throw std::runtime_error(string("LoadField >> MEDchampInfo(...)")); + int iGeomElemEnd; + med_geometrie_element* aGeomElemVector; + const VISU::TEntity& anEntity = theField.myEntity; + GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd); + med_entite_maillage& aMedEntity = aVisu2MedEntity[anEntity]; + if(MYDEBUG) { + MESSAGE("LoadField - aFieldName = '"<> MEDpasdetempsInfo(...)"); + med_int nval = MEDnVal(fid,aFieldName,aMedEntity,aGeom,numdt,numo); + if (nval <= 0) throw std::runtime_error("LoadField >> MEDnVal(...) - nval <= 0"); + else{ + //Checking for accordance between the mesh and the field on number of geomterical elements + int aVtkType = med2vtkCellType(aGeom); + const VISU::TMeshOnEntity::TCellsConn& aCellsConn = theMeshOnEntity.myCellsConn; + VISU::TMeshOnEntity::TCellsConn::const_iterator aCellsConnIter = aCellsConn.find(aVtkType); + if(aCellsConnIter == aCellsConn.end()) throw std::runtime_error("LoadField - There is no the geom. elem. on the mesh !!!"); + const VISU::TMeshOnEntity::TConnForCellType aConnForCellType = aCellsConnIter->second; + if(aConnForCellType.size() != nval) throw std::runtime_error("LoadField - Size of values and size of mesh not equal !!!"); + if(MYDEBUG) MESSAGE("LoadField - aGeom = "< valr(jEnd); + ret = MEDchampLire(fid,aMeshName,aFieldName,(unsigned char*)&valr[0],MED_FULL_INTERLACE,MED_ALL, + pflname,aMedEntity,aGeom,numdt,numo); + for (med_int j = 0; j < jEnd; j++) anArray[j] = valr[j]; + break; + } + //case MED_INT64 : //valarray valr(jEnd); + case MED_INT32 : //valarray valr(jEnd); + case MED_INT : { + valarray valr(jEnd); + ret = MEDchampLire(fid,aMeshName,aFieldName,(unsigned char*)&valr[0],MED_FULL_INTERLACE,MED_ALL, + pflname,aMedEntity,aGeom,numdt,numo); + for (med_int j = 0; j < jEnd; j++) anArray[j] = valr[j]; + break; + } + default : + throw std::runtime_error("LoadField >> Value of med_type_champ for the field is wrong !!!"); + } + if(ret < 0) throw std::runtime_error("ChampLire >> MEDchampLire(...)"); + } + } + } + return 1; +} diff --git a/src/VISU_I/VISU_MedConvertor.hxx b/src/VISU_I/VISU_MedConvertor.hxx new file mode 100644 index 00000000..94ddd8fe --- /dev/null +++ b/src/VISU_I/VISU_MedConvertor.hxx @@ -0,0 +1,48 @@ +// File: VISU_MedConvertor.hxx +// Created: Fri Jan 10 12:02:49 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_MedConvertor_HeaderFile +#define VISU_MedConvertor_HeaderFile + +#include "VISU_Convertor_impl.hxx" + +extern "C"{ +#include +} + +class VISU_MedConvertor: public VISU_Convertor_impl{ + VISU_MedConvertor(); + VISU_MedConvertor(const VISU_MedConvertor&); +public: + VISU_MedConvertor(const string& theFileName) throw (std::runtime_error&); + virtual VISU_Convertor* Build() throw (std::runtime_error&); +protected: + QFileInfo myFileInfo; + + virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName = "") + throw (std::runtime_error&); + virtual int LoadMeshOnGroup(VISU::TMesh& theMesh, + const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet) + throw (std::runtime_error&); + virtual int LoadFieldOnMesh(VISU::TMesh& theMesh, + VISU::TMeshOnEntity& theMeshOnEntity, + VISU::TField& theField, + VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&); + + int LoadPoints(const med_idt& fid, VISU::TMesh& theMesh, + const string& theFamilyName = "") + throw (std::runtime_error&); + int LoadCellsOnEntity(const med_idt& fid, VISU::TMeshOnEntity& theMeshOnEntity, + const string& theFamilyName = "") + throw (std::runtime_error&); + int LoadField(const med_idt& fid, const VISU::TMeshOnEntity& theMeshOnEntity, + const VISU::TField& theField, VISU::TField::TValForTime& theValForTime) + throw (std::runtime_error&); +}; + +#endif diff --git a/src/VISU_I/VISU_PrsObject_i.cc b/src/VISU_I/VISU_PrsObject_i.cc new file mode 100644 index 00000000..5faaa071 --- /dev/null +++ b/src/VISU_I/VISU_PrsObject_i.cc @@ -0,0 +1,1684 @@ +using namespace std; +// File: VISU_PrsObject_i.cxx +// Created: Fri Jan 17 09:27:59 2003 +// Author: Alexey PETROV +// + + +#include "VISU_PrsObject_i.hh" +#include "VISU_Extractor.hxx" +#include "VISU_FieldTransform.hxx" +#include "VISU_LookupTable.hxx" +#include "VISU_ScalarBarActor.hxx" +#include "VISU_Actor.h" +using namespace VISU; + +//#include "QAD_Study.h" +#include "QAD_Config.h" + +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +//#define CHECKTIME +#ifdef CHECKTIME +#include +#endif + +#ifdef DEBUG +static int MYDEBUG = 1; +static int MYDEBUGWITHFILES = 0; +#else +static int MYDEBUG = 0; +static int MYDEBUGWITHFILES = 0; +#endif +static float EPS = 1.0E-3; +const float PI2 = 2.0*PI; + +//============================================================================== +void SetIOR(SALOMEDS::SObject_var& theSObject, const char* theIOR){ + SALOMEDS::GenericAttribute_var anAttr; + theSObject->FindAttribute(anAttr, "AttributeIOR"); + SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); + CORBA::String_var aValue(theIOR); + anIOR->SetValue(aValue); +} + +float CalcScaleFactor(float theBound[6], int theNbElem){ + float aVolume = 1, vol, idim = 0; + for(int i = 0; i < 6; i += 2){ + vol = fabs(theBound[i+1] - theBound[i]); + if(vol > 0) { + idim++; + aVolume *= vol; + } + } + aVolume /= theNbElem; + float aFactor = pow(aVolume,(float)1./idim); + return aFactor; +} + +VISU::Result_i* GetResult(SALOMEDS::SObject_ptr theSObject){ + VISU::Result_var aResult = FindResult(theSObject); + if(!aResult->_is_nil()) + return dynamic_cast(VISU::GetServant(aResult.in())); + return NULL; +} + + +//============================================================================== +QString VISU::PrsObject_i::GetEntry() { + CORBA::String_var anIOR = GetID(); + SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(anIOR); + CORBA::String_var anEntry = aSObject->GetID(); + return anEntry.in(); +} + + +//---------------------------------------------------------------- +// Prs3d Object +//---------------------------------------------------------------- +VISU::Prs3d_i::Prs3d_i(Result_i* theResult) : + PrsObject_i(theResult->GetStudyDocument()), + myResult(theResult) +{ + myMapper = MapperType::New(); + myColor.R = myColorRGB[0] = 0.5; + myColor.G = myColorRGB[1] = 0.5; + myColor.B = myColorRGB[2] = 0.5; + myAddToStudy = true; +} + +void VISU::Prs3d_i::SameAs(const Prs3d_i* theOrigin) +{ + SetColor(theOrigin->GetColor()); + myMapper = MapperType::New(); + myMapper->ShallowCopy(theOrigin->GetMapper()); +} + +VISU::Prs3d_i::~Prs3d_i() { + myMapper->Delete(); +} + + +/** + * Create Actor referred on existing IO + */ +VISU_Actor* VISU::Prs3d_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO){ + Update(); + float bounds[6]; + static float eps = VTK_LARGE_FLOAT * 0.1 ; + myMapper->GetBounds(bounds); + for (int i = 0; i < 6; ++i) { + if (fabs (bounds[i] - myBounds[i]) > eps ) { + MESSAGE("Prs3d_i::CreateActor >> Boundaries of actor do not coincide with boundaries of initial shape !!!"); + return NULL; + } + } + VISU_Actor* aActor = VISU_Actor::New(); + if(myMapper->GetInput()->GetNumberOfCells() < 10) + aActor->IsShrinkable = false; //Bug SAL2011 Crash on shrink view + else + aActor->IsShrinkable = true; + aActor->SetMapper(myMapper); + if (myAddToStudy) { + if (theIO.IsNull()){ + //Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(GetEntry(),"VISU",GetName()); + //There is a bug in gcc compiler - const Standard_CString is mapping as char * const not as const char * + //(where Standard_CString is defined as typedef char* Standard_CString) + Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(strdup(GetEntry()),"VISU", + (const Standard_CString)GetName()); + aActor->setIO(anIO); + }else + aActor->setIO(theIO); + } + aActor->DataSource = myMapper->GetInput(); + aActor->Presentation = this; + vtkProperty* aProperty = aActor->GetProperty(); + aProperty->SetColor(myColorRGB); + return aActor; +} + +VISU::Storable* VISU::Prs3d_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + if(MYDEBUG) MESSAGE(GetComment()); + myName = VISU::Storable::FindValue(theMap,"myName"); + myColorRGB[0] = myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble(); + myColorRGB[1] = myColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble(); + myColorRGB[2] = myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble(); + return this; +} + +void VISU::Prs3d_i::ToStream(ostrstream& theStr){ + Storable::DataToStream( theStr, "myName", myName.c_str() ); + Storable::DataToStream( theStr, "myColor.R", myColor.R ); + Storable::DataToStream( theStr, "myColor.G", myColor.G ); + Storable::DataToStream( theStr, "myColor.B", myColor.B ); +} + +void VISU::Prs3d_i::Update() +{ + myMapper->Update(); +} + + +//---------------------------------------------------------------- +// Mesh Object +//---------------------------------------------------------------- +int VISU::Mesh_i::myNbPresent = 0; + +QString VISU::Mesh_i::GenerateName() { return VISU::GenerateName("Mesh",myNbPresent++);} + +const string VISU::Mesh_i::myComment = "MESH"; + +const char* VISU::Mesh_i::GetComment() const { return myComment.c_str();} + + +VISU::Mesh_i::Mesh_i(Result_i* theResult) : + PrsObject_i(theResult->GetStudyDocument()), + Prs3d_i(theResult) +{ + myInput = NULL; + SALOMEDS::Color aColor = {0,1,1}; + SetCellColor(aColor); + SetNodeColor(aColor); + SALOMEDS::Color aLinkColor = {83/255.,83/255.,83/255.}; + SetLinkColor(aLinkColor); +} + +void VISU::Mesh_i::SameAs(const Mesh_i* theOrigin) +{ + VISU::Prs3d_i::SameAs(theOrigin); + Mesh_i* aMesh = (Mesh_i*) theOrigin; + SetCellColor(aMesh->GetCellColor()); + SetNodeColor(aMesh->GetNodeColor()); + SetLinkColor(aMesh->GetLinkColor()); + SetPresentationType(aMesh->GetPresentationType()); + //myName = string("Copy of ") + theOrigin->GetName(); + Build(false); +} + +VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, int theEntity){ + myMeshName = theMeshName; + myEntity = theEntity; + mySubMeshName = ""; + return Build(false); +} + +VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, int theEntity, const char* theFamilyName){ + myMeshName = theMeshName; + myEntity = theEntity; + mySubMeshName = theFamilyName; + return Build(false); +} +VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, const char* theGroupName){ + myMeshName = theMeshName; + myEntity = -1; + mySubMeshName = theGroupName; + return Build(false); +} + +VISU::Storable* VISU::Mesh_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + Prs3d_i::Restore(theMap,false); + + myMeshName = VISU::Storable::FindValue(theMap,"myMeshName").latin1(); + myEntity = VISU::Storable::FindValue(theMap,"myEntity").toInt(); + mySubMeshName = VISU::Storable::FindValue(theMap,"mySubMeshName").latin1(); + + myCellColor.R = VISU::Storable::FindValue(theMap,"myCellColor.R").toDouble(); + myCellColor.G = VISU::Storable::FindValue(theMap,"myCellColor.G").toDouble(); + myCellColor.B = VISU::Storable::FindValue(theMap,"myCellColor.B").toDouble(); + + myNodeColor.R = VISU::Storable::FindValue(theMap,"myNodeColor.R").toDouble(); + myNodeColor.G = VISU::Storable::FindValue(theMap,"myNodeColor.G").toDouble(); + myNodeColor.B = VISU::Storable::FindValue(theMap,"myNodeColor.B").toDouble(); + + myLinkColor.R = VISU::Storable::FindValue(theMap,"myLinkColor.R").toDouble(); + myLinkColor.G = VISU::Storable::FindValue(theMap,"myLinkColor.G").toDouble(); + myLinkColor.B = VISU::Storable::FindValue(theMap,"myLinkColor.B").toDouble(); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::Mesh_i::ToStream(ostrstream& theStr){ + Prs3d_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() ); + Storable::DataToStream( theStr, "myEntity", myEntity ); + Storable::DataToStream( theStr, "mySubMeshName", mySubMeshName.c_str() ); + + Storable::DataToStream( theStr, "myCellColor.R", myCellColor.R ); + Storable::DataToStream( theStr, "myCellColor.G", myCellColor.G ); + Storable::DataToStream( theStr, "myCellColor.B", myCellColor.B ); + + Storable::DataToStream( theStr, "myNodeColor.R", myNodeColor.R ); + Storable::DataToStream( theStr, "myNodeColor.G", myNodeColor.G ); + Storable::DataToStream( theStr, "myNodeColor.B", myNodeColor.B ); + + Storable::DataToStream( theStr, "myLinkColor.R", myLinkColor.R ); + Storable::DataToStream( theStr, "myLinkColor.G", myLinkColor.G ); + Storable::DataToStream( theStr, "myLinkColor.B", myLinkColor.B ); +} + +VISU::Storable* VISU::MeshRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&) +{ + VISU::Result_i* pResult = GetResult(theSObject); + if(pResult != NULL){ + VISU::Mesh_i* pResent = new VISU::Mesh_i(pResult); + return pResent->Restore(theMap); + } + return NULL; +} + + +VISU::Mesh_i::~Mesh_i(){ + if(MYDEBUG) MESSAGE("Mesh_i::~Mesh_i()"); +} + + +VISU::Storable* VISU::Mesh_i::Build(int theRestoring){ + try{ +#ifdef CHECKTIME + OSD_Timer timer; + timer.Start(); +#endif + if(myResult->GetInput() == NULL) + throw std::runtime_error("Mesh_i::Build - myResult->GetInput() == NULL !!!"); + if(!theRestoring) myName = GenerateName(); + if(myEntity >= 0) + if(mySubMeshName == "") + myType = VISU::TENTITY; + else + myType = VISU::TFAMILY; + else + myType = VISU::TGROUP; + if(MYDEBUG) MESSAGE("Mesh_i::Build - myType = "<GetInput()->GetMeshOnEntity(myMeshName,(VISU::TEntity)myEntity); + aComment.sprintf("myComment=ENTITY;myType=%d;myMeshName=%s;myId=%d", + VISU::TENTITY,myMeshName.c_str(),myEntity); + break; + case VISU::TFAMILY : + myInput = myResult->GetInput()->GetMeshOnEntity(myMeshName,(VISU::TEntity)myEntity,mySubMeshName); + aComment.sprintf("myComment=FAMILY;myType=%d;myMeshName=%s;myEntityId=%d;myName=%s", + VISU::TFAMILY,myMeshName.c_str(),myEntity,mySubMeshName.c_str()); + break; + case VISU::TGROUP : + myInput = myResult->GetInput()->GetMeshOnGroup(myMeshName,mySubMeshName); + aComment.sprintf("myComment=GROUP;myType=%d;myMeshName=%s;myName=%s", + VISU::TGROUP,myMeshName.c_str(),mySubMeshName.c_str()); + break; + } + if(myInput == NULL) throw std::runtime_error("Mesh_i::Build - myInput == NULL !!!"); + //Binding pipeline + vtkUnstructuredGrid *aDataSet = myInput->GetOutput(); + //Avoid selection points that don't belong any of cells + vtkGeometryFilter *aGeomFilter = vtkGeometryFilter::New(); + aGeomFilter->SetInput(aDataSet); + vtkTriangleFilter *aTriangleFilter = vtkTriangleFilter::New(); + aTriangleFilter->SetInput(aGeomFilter->GetOutput()); + myMapper->SetInput(aTriangleFilter->GetOutput()); + // myMapper->SetInput(aDataSet); + myMapper->ScalarVisibilityOff(); + //Setting IOR on the label + if(!theRestoring) { + string aResultEntry = myResult->GetEntry(); + string anEntry = FindEntryWithComment(myStudy,aResultEntry.c_str(),aComment.latin1()); + if(anEntry == "") throw std::runtime_error("Mesh_i::Build - anEntry was not found !!!"); + SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(anEntry.c_str()); + SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aSObj,"AttributeIOR"); + SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); + CORBA::String_var aString = GetID(); + anIOR->SetValue(aString); + } +#ifdef CHECKTIME + timer.Stop(); + timer.Show(); +#endif + aDataSet->GetBounds(myBounds); + return this; + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured :\n"<VisuActorType = VisuActorType_Mesh; + + vtkProperty* aProperty = aActor->GetProperty(); + //aProperty->SetRepresentation(TypeRepresentation); + aProperty->BackfaceCullingOff(); + aProperty->EdgeVisibilityOn(); + + vtkGeometryFilter *gf = vtkGeometryFilter::New(); + gf->SetInput(aActor->DataSource); + vtkFeatureEdges *edges = vtkFeatureEdges::New(); + edges->SetInput(gf->GetOutput()); + edges->BoundaryEdgesOn(); + edges->ManifoldEdgesOn(); + + vtkPolyDataMapper *edgeMapper = vtkPolyDataMapper::New(); + edgeMapper->SetInput(edges->GetOutput()); + edgeMapper->ScalarVisibilityOff(); + + aActor->GetMapper()->SetResolveCoincidentTopologyToShiftZBuffer(); + aActor->GetMapper()->SetResolveCoincidentTopologyZShift(0.02); + + aActor->EdgeDevice = VISU_Actor::New(); + aActor->EdgeDevice->PickableOff(); + + aActor->EdgeDevice->SetMapper(edgeMapper); + edgeMapper->Update(); + + aActor->EdgeDevice->GetProperty()->SetColor(myLinkColor.R, myLinkColor.G, myLinkColor.B); + + aActor->EdgeDevice->VisibilityOn(); + + return aActor; +} + + + +//============================================================================== +int VISU::ScalarMap_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + try{ + const VISU::TField& aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName); + const VISU::TField::TValField& aValField = aField.myValField; + return aValField.find((int)theIteration) != aValField.end(); + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured :\n"<GetStudyDocument()), + Prs3d_i(theResult) +{ + myAddToStudy = theAddToStudy; + myInput = VISU_Extractor::New(); + myFieldTransform = VISU_FieldTransform::New(); +} + +void VISU::ScalarMap_i::SameAs(const ScalarMap_i* theOrigin) +{ + ScalarMap_i* aScalarMap = (ScalarMap_i*) theOrigin; + VISU::Prs3d_i::SameAs(aScalarMap); + myField = aScalarMap->GetField(); + myMeshName = myField->myMeshName; + myEntity = myField->myEntity; + myIteration = aScalarMap->GetIteration(); + myFieldName = aScalarMap->GetFieldName(); + + SetScalarMode(aScalarMap->GetScalarMode()); + Build(false); + SetScaling(aScalarMap->GetScaling()); + SetOrientation(aScalarMap->GetOrientation()); + SetPosition(aScalarMap->GetPosX(), aScalarMap->GetPosY()); + SetSize(aScalarMap->GetWidth(), aScalarMap->GetHeight()); + SetNbColors(aScalarMap->GetNbColors()); + SetLabels(aScalarMap->GetLabels()); + SetTitle(aScalarMap->GetTitle()); + //if (aScalarMap->isRangeFixed()) + SetRange(aScalarMap->GetMin(), aScalarMap->GetMax()); + //else + //CalculateRange(); + //myScalarMode = aScalarMap->GetScalarMode(); + //myName = string("Copy of ") + theOrigin->GetName(); +} + + +/** + * Creates Scalar Map and initialises it from resources + */ +VISU::Storable* VISU::ScalarMap_i::Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, CORBA::Double theIteration){ + myIsFixedRange = false; + + // Orientation + QString aOrient = QAD_CONFIG->getSetting("Visu:SBOrientation"); + if ( !aOrient.isEmpty() ) + myOrientation = (VISU::ScalarMap::Orientation) aOrient.toInt(); + else + myOrientation = VISU::ScalarMap::VERTICAL; + + // Scalar Bar origin + QString aXorigin = QAD_CONFIG->getSetting("Visu:SBXorigin"); + if ( !aXorigin.isEmpty() ) + myPosition[0] = aXorigin.toFloat(); + else { + if(myOrientation == VISU::ScalarMap::VERTICAL) { + myPosition[0] = 0.03; + } else { + myPosition[0] = 0.2; + } + } + + QString aYorigin = QAD_CONFIG->getSetting("Visu:SBYorigin"); + if ( !aYorigin.isEmpty() ) + myPosition[1] = aYorigin.toFloat(); + else { + if(myOrientation == VISU::ScalarMap::VERTICAL) { + myPosition[1] = 0.1; + } else { + myPosition[1] = 0.012; + } + } + + // Scalar Bar size + QString aWidth = QAD_CONFIG->getSetting("Visu:SBWidth"); + if ( !aWidth.isEmpty() ) + myWidth = aWidth.toFloat(); + else { + myWidth =(myOrientation == VISU::ScalarMap::VERTICAL)? 0.17:0.6; + } + QString aHeight = QAD_CONFIG->getSetting("Visu:SBHeight"); + if ( !aHeight.isEmpty() ) + myHeight = aHeight.toFloat(); + else { + myHeight =(myOrientation == VISU::ScalarMap::VERTICAL)? 0.8:0.12; + } + + // Nb of Colors + QString aColors = QAD_CONFIG->getSetting("Visu:SBNumberOfColors"); + myNumberOfColors = (aColors.isEmpty())? 64 : aColors.toInt(); + if (myNumberOfColors > 64) + myNumberOfColors = 64; + + // Nb of Labels + QString aLabels = QAD_CONFIG->getSetting("Visu:SBNumberOfLabels"); + myNumberOfLabels = (aLabels.isEmpty())? 5 : aLabels.toInt(); + if (myNumberOfLabels > 65) + myNumberOfLabels = 65; + + // Scalar Range + QString aFixRange = QAD_CONFIG->getSetting("Visu:SBImposeRange"); + myIsFixedRange = (aFixRange.compare("true") == 0); + + QString aRangeMin = QAD_CONFIG->getSetting("Visu:SBMinimumValue"); + myScalarRange[0] = (aRangeMin.isEmpty())? 0 : aRangeMin.toFloat(); + + QString aRangeMax = QAD_CONFIG->getSetting("Visu:SBMaximumValue"); + myScalarRange[1] = (aRangeMax.isEmpty())? 0 : aRangeMax.toFloat(); + + QString aScaling = QAD_CONFIG->getSetting("Visu:SBScaling"); + if(aScaling.compare("LOGARITHMIC") == 0) + myScaling = VISU::LOGARITHMIC; + else + myScaling = VISU::LINEAR; + +// myName = GenerateName(); + myMeshName = theMeshName; + myEntity = theEntity; + myFieldName =theFieldName; + myScalarMode = 0; + myIteration = theIteration; + return Build(false); +} + + + +VISU::Storable* VISU::ScalarMap_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + Prs3d_i::Restore(theMap,false); + + myMeshName = VISU::Storable::FindValue(theMap,"myMeshName"); + myEntity = VISU::Storable::FindValue(theMap,"myEntity").toInt(); + myFieldName = VISU::Storable::FindValue(theMap,"myFieldName"); + myIteration = VISU::Storable::FindValue(theMap,"myIteration").toInt(); + + myScalarMode = VISU::Storable::FindValue(theMap,"myScalarMode").toInt(); + myScalarRange[0] = VISU::Storable::FindValue(theMap,"myScalarRange[0]").toDouble(); + myScalarRange[1] = VISU::Storable::FindValue(theMap,"myScalarRange[1]").toDouble(); + myIsFixedRange = VISU::Storable::FindValue(theMap,"myIsFixedRange").toInt(); + myScaling = (VISU::Scaling)VISU::Storable::FindValue(theMap,"myScaling").toInt(); + + myTitle = VISU::Storable::FindValue(theMap,"myTitle"); + myOrientation = (VISU::ScalarMap::Orientation)VISU::Storable::FindValue(theMap,"myOrientation").toInt(); + myNumberOfColors = VISU::Storable::FindValue(theMap,"myNumberOfColors").toInt(); + myNumberOfLabels = VISU::Storable::FindValue(theMap,"myNumberOfLabels").toInt(); + myPosition[0] = VISU::Storable::FindValue(theMap,"myPosition[0]").toDouble(); + myPosition[1] = VISU::Storable::FindValue(theMap,"myPosition[1]").toDouble(); + myWidth = VISU::Storable::FindValue(theMap,"myWidth").toDouble(); + myHeight = VISU::Storable::FindValue(theMap,"myHeight").toDouble(); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::ScalarMap_i::ToStream(ostrstream& theStr){ + Prs3d_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() ); + Storable::DataToStream( theStr, "myEntity", myEntity ); + Storable::DataToStream( theStr, "myFieldName", myFieldName.c_str() ); + Storable::DataToStream( theStr, "myIteration", myIteration ); + + Storable::DataToStream( theStr, "myScalarMode", myScalarMode ); + Storable::DataToStream( theStr, "myScalarRange[0]", myScalarRange[0] ); + Storable::DataToStream( theStr, "myScalarRange[1]", myScalarRange[1] ); + Storable::DataToStream( theStr, "myIsFixedRange", myIsFixedRange ); + Storable::DataToStream( theStr, "myScaling", myScaling ); + + Storable::DataToStream( theStr, "myTitle", myTitle.c_str() ); + Storable::DataToStream( theStr, "myOrientation", myOrientation ); + Storable::DataToStream( theStr, "myNumberOfColors", myNumberOfColors ); + Storable::DataToStream( theStr, "myNumberOfLabels", myNumberOfLabels ); + Storable::DataToStream( theStr, "myPosition[0]", myPosition[0] ); + Storable::DataToStream( theStr, "myPosition[1]", myPosition[1] ); + Storable::DataToStream( theStr, "myWidth", myWidth ); + Storable::DataToStream( theStr, "myHeight", myHeight ); +} + +void VISU::ScalarMap_i::SetScaling(VISU::Scaling theScaling){ + VISU_FieldTransform::TTransformFun aFun; + if(MYDEBUG) MESSAGE("ScalarMap_i::SetScaling - theScaling = "<SetTransformFunction(aFun); + if(MYDEBUGWITHFILES) + WriteToFile(myFieldTransform->GetUnstructuredGridOutput(),(string("/tmp/")+getenv("USER")+"-PrsScaling").c_str()); +} + +VISU::Scaling VISU::ScalarMap_i::GetScaling(){ + return myScaling; +} + + +void VISU::ScalarMap_i::SetRange(CORBA::Double theMin, CORBA::Double theMax) { + myScalarRange[0] = theMin; + myScalarRange[1] = theMax; + myIsFixedRange = true; + if(MYDEBUG) + MESSAGE("ScalarMap_i::SetRange - myScalarRange[0] = "<Delete(); + myFieldTransform->Delete(); +} + + +void VISU::ScalarMap_i::Update() { + VISU::Prs3d_i::Update(); + if (!myIsFixedRange) CalculateRange(); +} + + +VISU::Storable* VISU::ScalarMap_i::Build(int theRestoring){ + if(MYDEBUG) + MESSAGE("ScalarMap_i::Build - "<GetInput() == NULL !!!"); + myField = &(myResult->GetInput()->GetField(myMeshName,(VISU::TEntity)myEntity,myFieldName)); + if(myField == NULL) throw std::runtime_error("There is no Field with the parameters !!!"); + SetScalarMode(myScalarMode); + if(myInput->GetInput() == NULL) throw std::runtime_error("Can't build build vtk representation !!!"); + vtkUnstructuredGrid *aDataSet = myInput->GetUnstructuredGridOutput(); + myFieldTransform->SetInput(aDataSet); + SetScaling(myScaling); + aDataSet->GetBounds(myBounds); + if(!theRestoring){ + if (!myIsFixedRange) aDataSet->GetScalarRange(myScalarRange); + myName = "NoName"; + CORBA::String_var anIOR = GetID(); + const VISU::TField::TValField& aValField = myField->myValField; + const VISU::TField::TValForTime& aValForTime = aValField.find((int)myIteration)->second; + const VISU::TField::TTime& aTime = aValForTime.myTime; + QString aComment; + aComment.sprintf("%s, %g",myFieldName.c_str(),aTime.first); + myTitle = aComment.simplifyWhiteSpace(); + if (myAddToStudy) { + myName = GenerateName(); + aComment.sprintf("myComment=TIMESTAMP;myType=%d;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d", + VISU::TTIMESTAMP,myMeshName.c_str(),myEntity,myFieldName.c_str(),(int)myIteration,myField->myNbComp); + string aResultEntry = myResult->GetEntry(); + string aRefFatherEntry = myResult->GetRefFatherEntry(); + string anEntry = FindEntryWithComment(myStudy,aResultEntry.c_str(),aComment.latin1()); + if(anEntry == "") throw std::runtime_error("There is no Entry for binding the presentation !!!"); + aComment.sprintf("myComment=%s;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d;myComponentId=%d", + GetComment(),myMeshName.c_str(),myEntity,myFieldName.c_str(),(int)myIteration,myField->myNbComp,myScalarMode); + CreateAttributes(myStudy,anEntry.c_str(),aRefFatherEntry.c_str(), + anIOR,myName.c_str(),"",aComment.latin1(),true); + } + } + if(MYDEBUG) + MESSAGE("ScalarMap_i::Build - myFieldName = "<ScalarVisibilityOn(); + return myFieldTransform->GetUnstructuredGridOutput(); +} + + + +VISU_Actor* VISU::ScalarMap_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) { + //Update(); + VISU_Actor* aActor = VISU::Prs3d_i::CreateActor(theIO); + if ( !aActor ) return NULL; + + VISU_LookupTable* aActorLookupTbl = VISU_LookupTable::New(); + if(GetScaling() == VISU::LOGARITHMIC) + aActorLookupTbl->SetLog(true); + aActorLookupTbl->SetHueRange(0.667,0.0); + aActorLookupTbl->SetNumberOfColors(myNumberOfColors); + aActorLookupTbl->SetRange(myScalarRange); + aActorLookupTbl->SetMapScale(1.); + aActorLookupTbl->Build(); + myMapper->SetLookupTable(aActorLookupTbl); +// if(GetScaling() == VISU::ScalarMap::LOGARITHMIC){ +// float* aLogScalarRange = aActorLookupTbl->GetLogRange(); +// myMapper->SetScalarRange(aLogScalarRange); +// }else + myMapper->SetScalarRange(myScalarRange); + aActorLookupTbl->Delete(); + + + VISU_ScalarBarActor* aBar = VISU_ScalarBarActor::New(); + VISU_LookupTable* aBarLookupTbl = VISU_LookupTable::New(); + if(GetScaling() == VISU::LOGARITHMIC) + aBarLookupTbl->SetLog(true); + aBarLookupTbl->SetHueRange(0.667,0.0); + aBarLookupTbl->SetNumberOfColors(myNumberOfColors); + aBarLookupTbl->SetRange(myScalarRange); + aBarLookupTbl->Build(); + aBar->SetLookupTable(aBarLookupTbl); + aBarLookupTbl->Delete(); + + aBar->SetTitle(myTitle.c_str()); + aBar->SetOrientation(myOrientation); + aBar->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport(); + aBar->GetPositionCoordinate()->SetValue(myPosition[0], + myPosition[1]); + aBar->SetWidth(myWidth); + aBar->SetHeight(myHeight); + aBar->SetNumberOfLabels(myNumberOfLabels); + aActor->setScalarBar(aBar); + + aActor->VisuActorType = VisuActorType_ScalarMap; + strncpy(aActor->FieldName, myFieldName.c_str(), 40); + aActor->FieldName[39] = '\0'; + + vtkProperty* aProperty = aActor->GetProperty(); +// aProperty->SetSpecularColor( 1, 1, 1); +// aProperty->SetSpecular( 0.3 ); +// aProperty->SetSpecularPower( 20 ); +// aProperty->SetAmbient( 0.2); +// aProperty->SetDiffuse( 0.8 ); + aProperty->EdgeVisibilityOn(); + return aActor; +} + +//============================================================================== +int VISU::DeformedShape_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + try{ + if(!VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration)) return 0; + const VISU::TField& aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName); + return aField.myNbComp > 1; + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured :\n"<GetStudyDocument()), + Prs3d_i(theResult), + ScalarMap_i(theResult, theAddToStudy) +{ + if(MYDEBUG) MESSAGE("DeformedShape_i::DeformedShape_i"); + myWarpVector = vtkWarpVector::New(); +} + + +void VISU::DeformedShape_i::SameAs(const DeformedShape_i* theOrigin) +{ + DeformedShape_i* aDefShape = (DeformedShape_i*) theOrigin; + setColored(aDefShape->isColored()); + VISU::ScalarMap_i::SameAs(theOrigin); + SetScale(aDefShape->GetScale()); +} + + +VISU::Storable* VISU::DeformedShape_i::Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + myIsColored = false; + return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration); +} + +VISU::Storable* VISU::DeformedShape_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + ScalarMap_i::Restore(theMap,false); + + myFactor = VISU::Storable::FindValue(theMap,"myFactor").toDouble(); + myIsColored = VISU::Storable::FindValue(theMap,"myIsColored").toInt(); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::DeformedShape_i::ToStream(ostrstream& theStr){ + ScalarMap_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myFactor", myFactor ); + Storable::DataToStream( theStr, "myIsColored", myIsColored ); +} + +VISU::Storable* VISU::DeformedShapeRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&) +{ + VISU::Result_i* pResult = GetResult(theSObject); + if(pResult != NULL){ + VISU::DeformedShape_i* pResent = new VISU::DeformedShape_i(pResult); + return pResent->Restore(theMap); + } + return NULL; +} + + +VISU::DeformedShape_i::~DeformedShape_i(){ + if(MYDEBUG) MESSAGE("DeformedShape_i::~DeformedShape_i()"); + myWarpVector->Delete(); +} + + +VISU::ScalarMap_i::DataType* VISU::DeformedShape_i::DoHook(int theRestoring){ + if(!theRestoring) + myFactor = ScaleFactor(); + if(MYDEBUG) + MESSAGE("DeformedShape_i::DoHook() - myFactor = "<myNbComp > 1){ + if(myField->myEntity == VISU::CELL_ENTITY){ + vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New(); + aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + aFilter->PassCellDataOn(); + myWarpVector->SetInput(aFilter->GetUnstructuredGridOutput()); + aFilter->Delete(); + }else + myWarpVector->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + + if(GetScaling() == VISU::LOGARITHMIC) + myWarpVector->SetScaleFactor(log10(myFactor)); + else + myWarpVector->SetScaleFactor(myFactor); + if(myIsColored) + myMapper->ScalarVisibilityOn(); + } + return myWarpVector->GetOutput(); +} + + +float VISU::DeformedShape_i::ScaleFactor() { + vtkUnstructuredGrid *aDataSet = myInput->GetUnstructuredGridOutput(); + int nbCells = aDataSet->GetNumberOfCells(), nbPoints = aDataSet->GetNumberOfPoints(); + return ::CalcScaleFactor(myBounds, nbCells? nbCells: nbPoints); +} + +void VISU::DeformedShape_i::Update(){ + myWarpVector->SetScaleFactor(myFactor); + myMapper->Update(); +} + +VISU_Actor* VISU::DeformedShape_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) { + VISU_Actor* aActor = VISU::ScalarMap_i::CreateActor(theIO); + if ( ! aActor ) return NULL; + if (myIsColored) { + myMapper->ScalarVisibilityOn(); + } else { + myMapper->ScalarVisibilityOff(); + aActor->setScalarBar(NULL); + } + aActor->VisuActorType = VisuActorType_DeformedShape; + aActor->GetProperty()->SetRepresentation(1); + return aActor; +} + + +//============================================================================== +int VISU::CutPlanes_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration); +} + +int VISU::CutPlanes_i::myNbPresent = 0; +QString VISU::CutPlanes_i::GenerateName() { return VISU::GenerateName("CutPlanes",myNbPresent++);} + +const string VISU::CutPlanes_i::myComment = "CUTPLANES"; +const char* VISU::CutPlanes_i::GetComment() const { return myComment.c_str();} + +VISU::CutPlanes_i::CutPlanes_i(Result_i* theResult, bool theAddToStudy) : + PrsObject_i(theResult->GetStudyDocument()), + Prs3d_i(theResult), + ScalarMap_i(theResult, theAddToStudy) +{ + if(MYDEBUG) MESSAGE("CutPlanes_i::CutPlanes_i"); + myAppendPolyData = vtkAppendPolyData::New(); +} + +void VISU::CutPlanes_i::SameAs(const CutPlanes_i* theOrigin) +{ + CutPlanes_i* aCutPlanes = (CutPlanes_i*) theOrigin; + SetNbPlanes(aCutPlanes->GetNbPlanes()); + SetOrientationType(aCutPlanes->GetOrientationType()); + SetRotateX(aCutPlanes->GetRotateX()); + SetRotateY(aCutPlanes->GetRotateY()); + Update(); + VISU::ScalarMap_i::SameAs(theOrigin); +} + +VISU::Storable* VISU::CutPlanes_i::Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration); +} + +VISU::Storable* VISU::CutPlanes_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + ScalarMap_i::Restore(theMap,false); + + myNbPlanes = VISU::Storable::FindValue(theMap,"myNbPlanes").toInt(); + myBasePlane = (VISU::CutPlanes::Orientation)VISU::Storable::FindValue(theMap,"myBasePlane").toInt(); + SetOrientationType(myBasePlane); + float aRot[2]; + aRot[0] = VISU::Storable::FindValue(theMap,"aRot[0]").toDouble(); + SetRotateX(aRot[0]); + aRot[1] = VISU::Storable::FindValue(theMap,"aRot[1]").toDouble(); + SetRotateY(aRot[1]); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::CutPlanes_i::ToStream(ostrstream& theStr){ + ScalarMap_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myNbPlanes", myNbPlanes ); + Storable::DataToStream( theStr, "myBasePlane", myBasePlane ); + Storable::DataToStream( theStr, "aRot[0]", GetRotateX() ); + Storable::DataToStream( theStr, "aRot[1]", GetRotateY() ); +} + +VISU::Storable* VISU::CutPlanesRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&) +{ + VISU::Result_i* pResult = GetResult(theSObject); + if(pResult != NULL){ + VISU::CutPlanes_i* pResent = new VISU::CutPlanes_i(pResult); + return pResent->Restore(theMap); + } + return NULL; +} + + +VISU::CutPlanes_i::~CutPlanes_i(){ + if(MYDEBUG) MESSAGE("CutPlanes_i::~CutPlanes_i()"); + myAppendPolyData->Delete(); +} + +VISU_Actor* VISU::CutPlanes_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) { + VISU_Actor* aActor = VISU::ScalarMap_i::CreateActor(theIO); + if (! aActor ) return NULL; + aActor->VisuActorType = VisuActorType_CutPlanes; + return aActor; +} + + + +float* GetIdent(float theR[3][3]){ + for(int i = 0; i < 3; i++) + for(int j = 0; j < 3; j++) + theR[i][j] = (i==j? 1.0: 0.0); + return theR[0]; +} + + +float* GetRx(float theRx[3][3], float thaAng){ + theRx[0][0] = 1.0; theRx[0][1] = 0.0; theRx[0][2] = 0.0; + theRx[1][0] = 0.0; theRx[1][1] = cos(thaAng); theRx[1][2] = -sin(thaAng); + theRx[2][0] = 0.0; theRx[2][1] = sin(thaAng); theRx[2][2] = cos(thaAng); + return theRx[0]; +} + + +float* GetRy(float theRy[3][3], float thaAng){ + theRy[0][0] = cos(thaAng); theRy[0][1] = 0.0; theRy[0][2] = sin(thaAng); + theRy[1][0] = 0.0; theRy[1][1] = 1.0; theRy[1][2] = 0.0; + theRy[2][0] = -sin(thaAng); theRy[2][1] = 0.0; theRy[2][2] = cos(thaAng); + return theRy[0]; +} + + +float* GetRz(float theRz[3][3], float thaAng){ + theRz[0][0] = cos(thaAng); theRz[0][1] = -sin(thaAng); theRz[0][2] = 0.0; + theRz[1][0] = sin(thaAng); theRz[1][1] = cos(thaAng); theRz[1][2] = 0.0; + theRz[2][0] = 0.0; theRz[2][1] = 0.0; theRz[2][2] = 1.0; + return theRz[0]; +} + + +void MulMatrix(float C[3][3], const float A[3][3], const float B[3][3]){ // C = A*B; + for(int i = 0; i < 3; i++) + for(int j = 0; j < 3; j++){ + C[i][j] = 0.0; + for(int k = 0; k < 3; k++) + C[i][j] += A[i][k]*B[k][j]; + } +} + + +float DotMul(const float A[3], const float B[3]){ // A*B; + float C = 0.0; + for(int i = 0; i < 3; i++) C += A[i]*B[i]; + return C; +} + + +void Mul(float C[3], const float A[3], float B){ // A*B; + for(int i = 0; i < 3; i++) C[i] = A[i]*B; +} + + +void GetBoundProject(float BoundPrj[3], const float BoundBox[6], const float Dir[3]){ + float BoundPoints[8][3] = { {BoundBox[0],BoundBox[2],BoundBox[4]}, + {BoundBox[1],BoundBox[2],BoundBox[4]}, + {BoundBox[0],BoundBox[3],BoundBox[4]}, + {BoundBox[1],BoundBox[3],BoundBox[4]}, + {BoundBox[0],BoundBox[2],BoundBox[5]}, + {BoundBox[1],BoundBox[2],BoundBox[5]}, + {BoundBox[0],BoundBox[3],BoundBox[5]}, + {BoundBox[1],BoundBox[3],BoundBox[5]}}; + BoundPrj[0] = DotMul(Dir,BoundPoints[0]), BoundPrj[1] = BoundPrj[0]; + float tmp; + for(int i = 1; i < 8; i++){ + tmp = DotMul(Dir,BoundPoints[i]); + if(BoundPrj[1] < tmp) BoundPrj[1] = tmp; + if(BoundPrj[0] > tmp) BoundPrj[0] = tmp; + } + BoundPrj[2] = BoundPrj[1] - BoundPrj[0]; + BoundPrj[1] = BoundPrj[0] + (1.0 - EPS)*BoundPrj[2]; + BoundPrj[0] = BoundPrj[0] + EPS*BoundPrj[2]; + BoundPrj[2] = BoundPrj[1] - BoundPrj[0]; +} + +void VISU::CutPlanes_i::SetRotateX(CORBA::Double theAng){ + if(myBasePlane == VISU::CutPlanes::XY) + myAng[0] = theAng; + else if(myBasePlane == VISU::CutPlanes::YZ) + myAng[1] = theAng; + else if(myBasePlane == VISU::CutPlanes::ZX) + myAng[2] = theAng; +} + +CORBA::Double VISU::CutPlanes_i::GetRotateX(){ + if(myBasePlane == VISU::CutPlanes::XY) + return myAng[0]; + else if(myBasePlane == VISU::CutPlanes::YZ) + return myAng[1]; + else if(myBasePlane == VISU::CutPlanes::ZX) + return myAng[2]; +} + +void VISU::CutPlanes_i::SetRotateY(CORBA::Double theAng){ + if(myBasePlane == VISU::CutPlanes::XY) + myAng[1] = theAng; + else if(myBasePlane == VISU::CutPlanes::YZ) + myAng[2] = theAng; + else if(myBasePlane == VISU::CutPlanes::ZX) + myAng[0] = theAng; +} + +CORBA::Double VISU::CutPlanes_i::GetRotateY(){ + if(myBasePlane == VISU::CutPlanes::XY) + return myAng[1]; + else if(myBasePlane == VISU::CutPlanes::YZ) + return myAng[2]; + else if(myBasePlane == VISU::CutPlanes::ZX) + return myAng[0]; +} + +VISU::ScalarMap_i::DataType* VISU::CutPlanes_i::DoHook(int theRestoring){ + if(!theRestoring){ + myAng[0] = myAng[1] = myAng[2] = 0.0; + myNbPlanes = 10; + myBasePlane = VISU::CutPlanes::XY; + } + if(MYDEBUG) + MESSAGE("CutPlanes_i::DoHook() - myNbPlanes = "<SetOrigin(aOrig); + if(theId == 0) aPlane->SetNormal(myInvDir); + else aPlane->SetNormal(myDir); + aCutPlane->SetCutFunction(aPlane); + aPlane->Delete(); + myAppendPolyData->AddInput(aCutPlane->GetOutput()); + aCutPlane->Delete(); +} + + +void VISU::CutPlanes_i::Update(){ + int iEnd = myAppendPolyData->GetNumberOfInputs(); + if(MYDEBUG) MESSAGE("CutPlanes_i::Update - iEnd = "<= 0; i--) + myAppendPolyData->RemoveInput(myAppendPolyData->GetInput(i)); + + float aRx[3][3], aRy[3][3], aRz[3][3]; + int iPlane = 0; + if(myBasePlane == VISU::CutPlanes::XY){ // X-Y + if(fabs(myAng[0]) > EPS) ::GetRx(aRx,myAng[0]); else ::GetIdent(aRx); + if(fabs(myAng[1]) > EPS) ::GetRy(aRy,myAng[1]); else ::GetIdent(aRy); + ::MulMatrix(myRotation,aRx,aRy); + iPlane = 2; + }else if(myBasePlane == VISU::CutPlanes::YZ){ // Y-Z + if(fabs(myAng[1]) > EPS) ::GetRy(aRy,myAng[1]); else ::GetIdent(aRy); + if(fabs(myAng[2]) > EPS) ::GetRz(aRz,myAng[2]); else ::GetIdent(aRz); + ::MulMatrix(myRotation,aRy,aRz); + iPlane = 0; + }else if(myBasePlane == VISU::CutPlanes::ZX){ // Z-X + if(fabs(myAng[2]) > EPS) ::GetRz(aRz,myAng[2]); else ::GetIdent(aRz); + if(fabs(myAng[0]) > EPS) ::GetRx(aRx,myAng[0]); else ::GetIdent(aRx); + ::MulMatrix(myRotation,aRz,aRx); + iPlane = 1; + } + for(int i = 0; i < 3; i++) myDir[i] = myRotation[i][iPlane]; + ::Mul(myInvDir,myDir,-1.0); + ::GetBoundProject(myBoundPrj, myBounds, myDir); + if(MYDEBUG) MESSAGE("myDir "< 1 ) { + myDBPrj = myBoundPrj[2]/(aNbPlanes - 1); + for (int i = 0; i < aNbPlanes; i++){ + SetPlane(i); + } + } + else { + myDBPrj = 0.5*myBoundPrj[2]; + SetPlane(1); + } +} + + +//============================================================================== +int VISU::IsoSurfaces_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration); +} + +int VISU::IsoSurfaces_i::myNbPresent = 0; +QString VISU::IsoSurfaces_i::GenerateName() { return VISU::GenerateName("IsoSurfaces",myNbPresent++);} + +const string VISU::IsoSurfaces_i::myComment = "ISOSURFACES"; +const char* VISU::IsoSurfaces_i::GetComment() const { return myComment.c_str();} + +VISU::IsoSurfaces_i::IsoSurfaces_i(Result_i* theResult, bool theAddToStudy) : + PrsObject_i(theResult->GetStudyDocument()), + Prs3d_i(theResult), + ScalarMap_i(theResult, theAddToStudy) +{ + if(MYDEBUG) MESSAGE("IsoSurfaces_i::IsoSurfaces_i"); + myContourFilter = vtkContourFilter::New(); +} + +void VISU::IsoSurfaces_i::SameAs(const IsoSurfaces_i* theOrigin) { + IsoSurfaces_i* aIsoSurfaces = (IsoSurfaces_i*) theOrigin; + SetNbSurfaces(aIsoSurfaces->GetNbSurfaces()); + SetRange(aIsoSurfaces->GetRangeMin(), aIsoSurfaces->GetRangeMax()); + VISU::ScalarMap_i::SameAs(theOrigin); +} + +VISU::Storable* VISU::IsoSurfaces_i::Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + myNbSurface = 10; + myRange[0] = 0; + myRange[1] = 0; + return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration); +} + +VISU::Storable* VISU::IsoSurfaces_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + ScalarMap_i::Restore(theMap,false); + + myNbSurface = VISU::Storable::FindValue(theMap,"myNbSurface").toInt(); + myRange[0] = VISU::Storable::FindValue(theMap,"myRange[0]").toDouble(); + myRange[1] = VISU::Storable::FindValue(theMap,"myRange[1]").toDouble(); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::IsoSurfaces_i::ToStream(ostrstream& theStr){ + ScalarMap_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myNbSurface", myNbSurface ); + Storable::DataToStream( theStr, "myRange[0]", myRange[0] ); + Storable::DataToStream( theStr, "myRange[1]", myRange[1] ); +} + +VISU::Storable* VISU::IsoSurfacesRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&) +{ + VISU::Result_i* pResult = GetResult(theSObject); + if(pResult != NULL){ + VISU::IsoSurfaces_i* pResent = new VISU::IsoSurfaces_i(pResult); + return pResent->Restore(theMap); + } + return NULL; +} + + +VISU::IsoSurfaces_i::~IsoSurfaces_i(){ + if(MYDEBUG) MESSAGE("IsoSurfaces_i::~IsoSurfaces_i()"); + myContourFilter->Delete(); +} + + +VISU::ScalarMap_i::DataType* VISU::IsoSurfaces_i::DoHook(int theRestoring){ + if(MYDEBUG) + MESSAGE("IsoSurfaces_i::DoHook() - myNbSurface = "<myEntity == VISU::CELL_ENTITY){ + vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New(); + aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + aFilter->PassCellDataOn(); + myContourFilter->SetInput(aFilter->GetOutput()); + aFilter->Delete(); + } else + myContourFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + + if ((myRange[0]==0) && (myRange[1]==0)) { + myRange[0] = myScalarRange[0]; + myRange[1] = myScalarRange[1]; + } + if(GetScaling() == VISU::LOGARITHMIC){ + float aLogRange[2]; + VISU_LookupTable::ComputeLogRange(myRange,aLogRange); + if(MYDEBUG) + MESSAGE("IsoSurfaces_i::DoHook() - aLogRange = {"<GenerateValues(myNbSurface, aLogRange); + }else + myContourFilter->GenerateValues(myNbSurface, myRange); + myMapper->ScalarVisibilityOn(); + return myContourFilter->GetOutput(); +} + + +void VISU::IsoSurfaces_i::Update(){ + if ((myRange[0]==0) && (myRange[1]==0)) { + myRange[0] = myScalarRange[0]; + myRange[1] = myScalarRange[1]; + } + if(GetScaling() == VISU::LOGARITHMIC){ + float aLogRange[2]; + VISU_LookupTable::ComputeLogRange(myRange,aLogRange); + if(MYDEBUG) + MESSAGE("IsoSurfaces_i::Update() - aLogRange = {"<GenerateValues(myNbSurface, aLogRange); + }else + myContourFilter->GenerateValues(myNbSurface, myRange); + myMapper->Update(); +} + + +VISU_Actor* VISU::IsoSurfaces_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) { + VISU_Actor* aActor = VISU::ScalarMap_i::CreateActor(theIO); + if ( ! aActor ) return NULL; + aActor->VisuActorType = VisuActorType_IsoSurfaces; + return aActor; +} + +//============================================================================== +int VISU::StreamLines_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + return DeformedShape_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration); +} + +int VISU::StreamLines_i::myNbPresent = 0; +QString VISU::StreamLines_i::GenerateName() { return VISU::GenerateName("StreamLines",myNbPresent++);} + +const string VISU::StreamLines_i::myComment = "STREAMLINES"; +const char* VISU::StreamLines_i::GetComment() const { return myComment.c_str();} + +VISU::StreamLines_i::StreamLines_i(Result_i* theResult, bool theAddToStudy) : + PrsObject_i(theResult->GetStudyDocument()), + Prs3d_i(theResult), + ScalarMap_i(theResult, theAddToStudy), + DeformedShape_i(theResult, theAddToStudy) +{ + if(MYDEBUG) MESSAGE("StreamLines_i::StreamLines_i"); + myStream = vtkStreamLine::New(); +} + +VISU::Storable* VISU::StreamLines_i::Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + myDirection = VISU::StreamLines::FORWARD; + myStepLength = 0.1; + myIntegrationStep = 0.1; + myPropagationTime = 100; + return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration); +} + +void VISU::StreamLines_i::SameAs(const StreamLines_i* theOrigin) { + StreamLines_i* aIsoLines = (StreamLines_i*) theOrigin; + SetDirection(aIsoLines->GetDirection()); + SetStepLength(aIsoLines->GetStepLength()); + SetIntegrationStep(aIsoLines->GetIntegrationStep()); + SetPropagationTime(aIsoLines->GetPropagationTime()); + VISU::DeformedShape_i::SameAs(theOrigin); +} + +VISU::Storable* VISU::StreamLines_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + DeformedShape_i::Restore(theMap,false); + + myStepLength = VISU::Storable::FindValue(theMap,"myStepLength").toDouble(); + myIntegrationStep = VISU::Storable::FindValue(theMap,"myIntegrationStep").toDouble(); + myPropagationTime = VISU::Storable::FindValue(theMap,"myPropagationTime").toDouble(); + myDirection = (VISU::StreamLines::Direction) VISU::Storable::FindValue(theMap,"myDirection").toInt(); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::StreamLines_i::ToStream(ostrstream& theStr){ + DeformedShape_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myStepLength", myStepLength ); + Storable::DataToStream( theStr, "myIntegrationStep", myIntegrationStep ); + Storable::DataToStream( theStr, "myPropagationTime", myPropagationTime ); + Storable::DataToStream( theStr, "myDirection", (int)myDirection ); + +} + +VISU::Storable* VISU::StreamLinesRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&) +{ + VISU::Result_i* pResult = GetResult(theSObject); + if(pResult != NULL){ + VISU::StreamLines_i* pResent = new VISU::StreamLines_i(pResult); + return pResent->Restore(theMap); + } + return NULL; +} + + +VISU::StreamLines_i::~StreamLines_i(){ + if(MYDEBUG) MESSAGE("StreamLines_i::~StreamLines_i()"); + myStream->Delete(); +} + + +VISU::ScalarMap_i::DataType* VISU::StreamLines_i::DoHook(int theRestoring){ + return myStream->GetOutput(); +} + + +void VISU::StreamLines_i::Update(){ + if(myField->myNbComp > 1){ + if(myField->myEntity == VISU::CELL_ENTITY){ + //myStream->DebugOn(); + vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New(); + aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + aFilter->PassCellDataOn(); + myStream->SetInput(aFilter->GetOutput()); + aFilter->Delete(); + + vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells + centers->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + centers->VertexCellsOn(); + myStream->SetSource(centers->GetOutput()); + centers->Delete(); + }else{ + myStream->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + myStream->SetSource(myFieldTransform->GetUnstructuredGridOutput()); + } + myStream->SetStepLength(myStepLength); + myStream->SetIntegrationStepLength(myIntegrationStep); + myStream->SetMaximumPropagationTime(myPropagationTime); + switch (myDirection) { + case VISU::StreamLines::FORWARD: + myStream->SetIntegrationDirectionToForward(); + break; + case VISU::StreamLines::BACKWARD: + myStream->SetIntegrationDirectionToBackward(); + break; + case VISU::StreamLines::BOTH: + myStream->SetIntegrationDirectionToIntegrateBothDirections(); + } + myStream->Update(); + myMapper->Update(); + } +} + + +VISU_Actor* VISU::StreamLines_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) { + VISU_Actor* aActor = VISU::DeformedShape_i::CreateActor(theIO); + if ( ! aActor ) return NULL; + aActor->VisuActorType = VisuActorType_StreamLines; + return aActor; +} + +//============================================================================== +int VISU::Vectors_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + return DeformedShape_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration); +} + +int VISU::Vectors_i::myNbPresent = 0; +QString VISU::Vectors_i::GenerateName() { return VISU::GenerateName("Vectors",myNbPresent++);} + +const string VISU::Vectors_i::myComment = "VECTORS"; +const char* VISU::Vectors_i::GetComment() const { return myComment.c_str();} + +VISU::Vectors_i::Vectors_i(Result_i* theResult, bool theAddToStudy) : + PrsObject_i(theResult->GetStudyDocument()), + Prs3d_i(theResult), + ScalarMap_i(theResult, theAddToStudy), + DeformedShape_i(theResult, theAddToStudy) +{ + if(MYDEBUG) MESSAGE("Vectors_i::Vectors_i"); + myGlyph = vtkGlyph3D::New(); + myHog = vtkHedgeHog::New(); +} + +void VISU::Vectors_i::SameAs(const VISU::Vectors_i* theOrigin) { + Vectors_i* aVectors = (Vectors_i*) theOrigin; + SetLineWidth(aVectors->GetLineWidth()); + SetGlyphType(aVectors->GetGlyphType()); + SetGlyphPos(aVectors->GetGlyphPos()); + VISU::DeformedShape_i::SameAs(theOrigin); +} + +VISU::Storable* VISU::Vectors_i::Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration){ + myLineWidth = 1.0; + myTypeGlyph = VISU::Vectors::ARROW; + myPosGlyph = VISU::Vectors::CENTER; + return DeformedShape_i::Create(theMeshName,theEntity,theFieldName,theIteration); +} + +VISU::Storable* VISU::Vectors_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding) + throw(std::logic_error&) +{ + DeformedShape_i::Restore(theMap,false); + + myTypeGlyph = (VISU::Vectors::GlyphType)VISU::Storable::FindValue(theMap,"myTypeGlyph").toInt(); + myLineWidth = VISU::Storable::FindValue(theMap,"myLineWidth").toDouble(); + myPosGlyph = (VISU::Vectors::GlyphPos)VISU::Storable::FindValue(theMap,"myPosGlyph").toInt(); + + if(theBuilding) + return Build(true); + return NULL; +} + +void VISU::Vectors_i::ToStream(ostrstream& theStr){ + DeformedShape_i::ToStream(theStr); + + Storable::DataToStream( theStr, "myTypeGlyph", myTypeGlyph ); + Storable::DataToStream( theStr, "myLineWidth", myLineWidth ); + Storable::DataToStream( theStr, "myPosGlyph", myPosGlyph ); +} + +VISU::Storable* VISU::VectorsRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&) +{ + VISU::Result_i* pResult = GetResult(theSObject); + if(pResult != NULL){ + VISU::Vectors_i* pResent = new VISU::Vectors_i(pResult); + return pResent->Restore(theMap); + } + return NULL; +} + + +VISU::ScalarMap_i::DataType* VISU::Vectors_i::DoHook(int theRestoring){ + if(!theRestoring){ + myFactor = ScaleFactor(); + } + if(MYDEBUG) + MESSAGE("Vectors_i::DoHook() - myFactor = "<Delete(); + myHog->Delete(); +} + +VISU_Actor* VISU::Vectors_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) { + VISU_Actor* aActor = VISU::DeformedShape_i::CreateActor(theIO); + if ( ! aActor ) return NULL; + aActor->VisuActorType = VisuActorType_Vectors; + aActor->IsShrinkable = false; + vtkProperty* aProperty = aActor->GetProperty(); + aProperty->SetRepresentation(2); + aProperty->SetLineWidth(myLineWidth); + return aActor; +} + +void VISU::Vectors_i::Update() { + switch (myTypeGlyph) { + case VISU::Vectors::ARROW: + { + vtkGlyphSource2D *aGlyphSource = vtkGlyphSource2D::New(); + aGlyphSource->SetGlyphTypeToArrow(); + aGlyphSource->SetFilled(0); + if(myPosGlyph == VISU::Vectors::TAIL) + aGlyphSource->SetCenter(0.5, 0.0, 0.0); + else if(myPosGlyph == VISU::Vectors::HEAD) + aGlyphSource->SetCenter(-0.5, 0.0, 0.0); + myGlyph->SetSource(aGlyphSource->GetOutput()); + aGlyphSource->Delete(); + } + break; + + case VISU::Vectors::CONE2: + case VISU::Vectors::CONE6: + { + vtkConeSource *aGlyphSource = vtkConeSource::New(); //by default + if (myTypeGlyph == VISU::Vectors::CONE6) + aGlyphSource->SetResolution(7); + else + aGlyphSource->SetResolution(3); + aGlyphSource->SetHeight(.7); + aGlyphSource->SetRadius(.1); + vtkTransform *aTransform = vtkTransform::New(); + if(myPosGlyph == VISU::Vectors::TAIL) + aTransform->Translate(0.5*aGlyphSource->GetHeight(),0.0,0.0); + else if(myPosGlyph == VISU::Vectors::HEAD) + aTransform->Translate(-0.5*aGlyphSource->GetHeight(),0.0,0.0); + + vtkTransformPolyDataFilter *aFilter = vtkTransformPolyDataFilter::New(); + aFilter->SetInput(aGlyphSource->GetOutput()); + aGlyphSource->Delete(); + aFilter->SetTransform(aTransform); + aTransform->Delete(); + myGlyph->SetSource(aGlyphSource->GetOutput()); + aFilter->Delete(); + } + break; + case VISU::Vectors::NONE: + { + if(myField->myEntity == VISU::CELL_ENTITY){ + vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells + centers->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + centers->VertexCellsOn(); + myHog->SetInput(centers->GetOutput()); + centers->Delete(); + }else + myHog->SetInput(myFieldTransform->GetInput()); + + myHog->SetScaleFactor(myFactor); + myHog->Update(); + myMapper->SetInput(myHog->GetOutput()); + myMapper->Update(); + return; + } + } + if(myField->myNbComp > 1){ + if(myField->myEntity == VISU::CELL_ENTITY){ + vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells + centers->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + centers->VertexCellsOn(); + myGlyph->SetInput(centers->GetOutput()); + centers->Delete(); + }else + myGlyph->SetInput(myFieldTransform->GetUnstructuredGridOutput()); + myGlyph->SetVectorModeToUseVector(); + myGlyph->SetScaleFactor(2*myFactor); + } + myGlyph->Update(); + myMapper->SetInput(myGlyph->GetOutput()); + myMapper->Update(); +} +//============================================================================== + diff --git a/src/VISU_I/VISU_PrsObject_i.hh b/src/VISU_I/VISU_PrsObject_i.hh new file mode 100644 index 00000000..842ec89e --- /dev/null +++ b/src/VISU_I/VISU_PrsObject_i.hh @@ -0,0 +1,535 @@ +// File: VISU_PrsObject_i.hxx +// Created: Fri Jan 17 09:26:33 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_PrsObject_i_HeaderFile +#define VISU_PrsObject_i_HeaderFile + +#include "VISU_Result_i.hh" +//#include "VISU_Convertor.hxx" +#include "Handle_SALOME_InteractiveObject.hxx" + +class VISU_Extractor; +class VISU_FieldTransform; +class VISU_Actor; + +class vtkDataSetMapper; +class vtkDataSet; +class vtkProperty; + +class vtkWarpVector; +class vtkContourFilter; +class vtkAppendPolyData; + +class vtkGlyph3D; +class vtkHedgeHog; +class vtkPolyDataSource; +class vtkStreamLine; + + +namespace VISU{ + struct TField; + //============================================================================== + class PrsObject_i : public virtual POA_VISU::PrsObject, + public virtual Storable + { + PrsObject_i(const PrsObject_i&); + + public: + PrsObject_i(SALOMEDS::Study_ptr theStudy) : + myStudy(SALOMEDS::Study::_duplicate(theStudy)) {}; + virtual ~PrsObject_i() {} + + protected: + string myName; + SALOMEDS::Study_var myStudy; + + public: + virtual const char* GetName() const { return myName.c_str();} + const SALOMEDS::Study_var& GetStudyDocument() const { return myStudy;} + QString GetEntry(); + }; + + + //============================================================================== + class Prs3d_i : public virtual PrsObject_i + { + Prs3d_i(); + Prs3d_i(const Prs3d_i&); + public: + Prs3d_i(Result_i* theResult); + virtual void SameAs(const Prs3d_i* theOrigin); + virtual ~Prs3d_i(); + + typedef vtkDataSetMapper MapperType; + typedef vtkDataSet DataType; + + virtual const float* GetColor() const { return myColorRGB;} + virtual void SetColor(const float* theRGB){ + myColor.R = myColorRGB[0] = theRGB[0]; + myColor.G = myColorRGB[1] = theRGB[1]; + myColor.B = myColorRGB[2] = theRGB[2]; + } + + + protected: + Result_i* myResult; + MapperType *myMapper; + float myBounds[6]; + float myColorRGB[3]; + struct SALOMEDS::Color myColor; + + bool myAddToStudy; + + public: + virtual void Update(); + virtual const char* GetComment() const = 0; + virtual QString GenerateName() = 0; + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + virtual void ToStream(ostrstream& theStr); + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + MapperType* GetMapper() const { return myMapper;} + Result_i* GetResult() const { return myResult; } + }; + + + //============================================================================== + class Mesh_i : public virtual POA_VISU::Mesh, + public virtual Prs3d_i + { + static int myNbPresent; + Mesh_i(); + Mesh_i(const Mesh_i&); + public: + Mesh_i(Result_i* theResult); + virtual void SameAs(const Mesh_i* theOrigin); + virtual ~Mesh_i(); + virtual VISU::VISUType GetType() { return VISU::TMESH;}; + + virtual void SetCellColor(const SALOMEDS::Color& theColor) { myCellColor = theColor;} + virtual SALOMEDS::Color GetCellColor() { return myCellColor;} + + virtual void SetNodeColor(const SALOMEDS::Color& theColor) { myNodeColor = theColor;} + virtual SALOMEDS::Color GetNodeColor() { return myNodeColor;} + + virtual void SetLinkColor(const SALOMEDS::Color& theColor) { myLinkColor = theColor;} + virtual SALOMEDS::Color GetLinkColor() { return myLinkColor;} + + virtual void SetPresentationType(VISU::PresentationType theType) { myPresentType = theType;} + virtual PresentationType GetPresentationType() { return myPresentType;} + + typedef VISU::Mesh InterfaceType; + typedef vtkUnstructuredGridReader InputType; + + protected: + Storable* Build(int theRestoring); + + InputType *myInput; + VISU::VISUType myType; + string myMeshName; + int myEntity; + string mySubMeshName; + struct SALOMEDS::Color myCellColor, myNodeColor, myLinkColor; + VISU::PresentationType myPresentType; + + public: + virtual Storable* Create(const char* theMeshName, int theEntity); + virtual Storable* Create(const char* theMeshName, int theEntity, const char* theFamilyName); + virtual Storable* Create(const char* theMeshName, const char* theGroupName); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + virtual void ToStream(ostrstream& theStr); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + virtual InputType* GetInput() const { return myInput;} + }; + Storable* MeshRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + + + //============================================================================== + class ScalarMap_i : public virtual POA_VISU::ScalarMap, + public virtual Prs3d_i + { + static int myNbPresent; + ScalarMap_i(); + ScalarMap_i(const ScalarMap_i&); + + public: + ScalarMap_i(Result_i* theResult, bool theAddToStudy = true); + virtual void SameAs(const ScalarMap_i* theOrigin); + virtual ~ScalarMap_i(); + + virtual VISU::VISUType GetType() { return VISU::TSCALARMAP;}; + + virtual void SetScalarMode(CORBA::Long theScalarMode); + virtual CORBA::Long GetScalarMode() { return myScalarMode;} + + virtual void SetScaling(VISU::Scaling theScaling); + virtual VISU::Scaling GetScaling(); + + virtual void SetRange(CORBA::Double theMin, CORBA::Double theMax); + virtual CORBA::Double GetMin() { return myScalarRange[0];} + virtual CORBA::Double GetMax() { return myScalarRange[1];} + + virtual void SetOrientation(VISU::ScalarMap::Orientation theOrientation) { + myOrientation = theOrientation; + } + virtual VISU::ScalarMap::Orientation GetOrientation() { return myOrientation;} + + virtual void SetPosition(CORBA::Double X, CORBA::Double Y) { myPosition[0] = X; myPosition[1] = Y;} + virtual CORBA::Double GetPosX() { return myPosition[0];} + virtual CORBA::Double GetPosY() { return myPosition[1];} + + virtual void SetSize(CORBA::Double theWidth, CORBA::Double theHeight) { + myWidth = theWidth; myHeight = theHeight; + } + virtual CORBA::Double GetWidth() { return myWidth;} + virtual CORBA::Double GetHeight() { return myHeight;} + + virtual void SetNbColors(CORBA::Long theNbColors) { myNumberOfColors = theNbColors;} + virtual CORBA::Long GetNbColors() { return myNumberOfColors;} + + virtual void SetLabels(CORBA::Long theNbLabels) { myNumberOfLabels = theNbLabels;} + virtual CORBA::Long GetLabels() { return myNumberOfLabels;} + + virtual void SetTitle(const char* theName) { myTitle = theName;} + virtual char* GetTitle() { return CORBA::string_dup(myTitle.c_str());} + + virtual void CalculateRange(); + virtual bool isRangeFixed() { return myIsFixedRange; } + + virtual double GetIteration() { return myIteration; } + + typedef VISU::ScalarMap InterfaceType; + typedef VISU_Extractor InputType; + + protected: + Storable* Build(int theRestoring); + virtual DataType* DoHook(int theRestoring); + + InputType *myInput; + + string myMeshName; + int myEntity; + string myFieldName; + int myScalarMode; + double myIteration; + VISU_FieldTransform *myFieldTransform; + const TField* myField; + + float myScalarRange[2]; + bool myIsFixedRange; + VISU::Scaling myScaling; + + string myTitle; + VISU::ScalarMap::Orientation myOrientation; + int myNumberOfColors, myNumberOfLabels; + float myPosition[2], myWidth, myHeight; + + public: + virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual void ToStream(ostrstream& theStr); + static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + InputType* GetInput() { return myInput;} + + virtual void Update(); + const VISU::TField* GetField() const { return myField;} + const string& GetFieldName() const { return myFieldName;} + int GetScalarMode() const { return myScalarMode;} + + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + }; + Storable* ScalarMapRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + + + //============================================================================== + class DeformedShape_i : public virtual POA_VISU::DeformedShape, + public virtual ScalarMap_i + { + static int myNbPresent; + DeformedShape_i(); + DeformedShape_i(const DeformedShape_i&); + public: + DeformedShape_i(Result_i* theResult, bool theAddToStudy = true); + virtual void SameAs(const DeformedShape_i* theOrigin); + virtual ~DeformedShape_i(); + + virtual VISU::VISUType GetType() { return VISU::TDEFORMEDSHAPE;}; + + virtual void SetScale(CORBA::Double theScale) { myFactor = theScale;} + virtual CORBA::Double GetScale() { return myFactor;} + + typedef VISU::DeformedShape InterfaceType; + + virtual bool isColored() { return myIsColored; } + virtual void setColored(bool theColor) + { myIsColored = theColor; } + + protected: + virtual DataType* DoHook(int theRestoring); + float myFactor; + bool myIsColored; + vtkWarpVector *myWarpVector; + + public: + virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual void Update(); + virtual void ToStream(ostrstream& theStr); + static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + float ScaleFactor(); + + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + }; + Storable* DeformedShapeRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + + + + + //============================================================================== + class CutPlanes_i : public virtual POA_VISU::CutPlanes, + public virtual ScalarMap_i + { + static int myNbPresent; + CutPlanes_i(); + CutPlanes_i(const CutPlanes_i&); + public: + CutPlanes_i(Result_i* theResult, bool theAddToStudy = true); + virtual void SameAs(const CutPlanes_i* theOrigin); + virtual ~CutPlanes_i(); + virtual VISU::VISUType GetType() { return VISU::TCUTPLANES;}; + + virtual void SetOrientationType(VISU::CutPlanes::Orientation theOrient) { + myBasePlane = theOrient; + } + virtual VISU::CutPlanes::Orientation GetOrientationType() { return myBasePlane;} + + virtual void SetNbPlanes(CORBA::Long theNb) { myNbPlanes = theNb;} + virtual CORBA::Long GetNbPlanes() { return myNbPlanes;} + + virtual void SetRotateX(CORBA::Double theAngle); + virtual CORBA::Double GetRotateX(); + virtual void SetRotateY(CORBA::Double theAngle); + virtual CORBA::Double GetRotateY(); + + typedef VISU::CutPlanes InterfaceType; + + protected: + virtual DataType* DoHook(int theRestoring); + + float myRotation[3][3]; + float myAng[3], myDir[3], myInvDir[3], myBoundPrj[3], myDBPrj; + vtkAppendPolyData *myAppendPolyData; + VISU::CutPlanes::Orientation myBasePlane; + int myNbPlanes; + + public: + virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual void Update(); + virtual void ToStream(ostrstream& theStr); + static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + void SetPlane(int theId); + + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + }; + Storable* CutPlanesRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + + + + //============================================================================== + class IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces, + public virtual ScalarMap_i + { + static int myNbPresent; + IsoSurfaces_i(); + IsoSurfaces_i(const IsoSurfaces_i&); + public: + IsoSurfaces_i(Result_i* theResult, bool theAddToStudy = true); + virtual void SameAs(const IsoSurfaces_i* theOrigin); + virtual ~IsoSurfaces_i(); + virtual VISU::VISUType GetType() { return VISU::TISOSURFACE;}; + + virtual void SetNbSurfaces(CORBA::Long theNb) { myNbSurface = theNb;} + virtual CORBA::Long GetNbSurfaces() { return myNbSurface;} + + virtual void SetRange(float theMin, float theMax) + { myRange[0] = theMin; myRange[1] = theMax; } + + virtual float GetRangeMin() { return myRange[0]; } + virtual float GetRangeMax() { return myRange[1]; } + + typedef VISU::IsoSurfaces InterfaceType; + + protected: + virtual DataType* DoHook(int theRestoring); + + vtkContourFilter *myContourFilter; + int myNbSurface; + float myRange[2]; + + public: + virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual void Update(); + virtual void ToStream(ostrstream& theStr); + static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + vtkContourFilter* GetFilter() { return myContourFilter;} + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + }; + Storable* IsoSurfacesRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + + + + //============================================================================== + class StreamLines_i : public virtual POA_VISU::StreamLines, + public virtual DeformedShape_i + { + static int myNbPresent; + StreamLines_i(); + StreamLines_i(const StreamLines_i&); + public: + StreamLines_i(Result_i* theResult, bool theAddToStudy = true); + virtual void SameAs(const StreamLines_i* theOriginal); + virtual ~StreamLines_i(); + + virtual VISU::VISUType GetType() { return VISU::TSTREAMLINES;} + + typedef VISU::StreamLines InterfaceType; + + virtual void SetDirection(VISU::StreamLines::Direction theDirection) + { myDirection = theDirection; } + virtual VISU::StreamLines::Direction GetDirection() { return myDirection;} + + virtual void SetStepLength(float theStep) { myStepLength = theStep; } + virtual float GetStepLength() { return myStepLength; } + + virtual void SetPropagationTime(float theTime) { myPropagationTime = theTime; } + virtual float GetPropagationTime() { return myPropagationTime; } + + virtual void SetIntegrationStep(float theStep) { myIntegrationStep = theStep; } + virtual float GetIntegrationStep() { return myIntegrationStep; } + + protected: + virtual DataType* DoHook(int theRestoring); + vtkStreamLine* myStream; + + VISU::StreamLines::Direction myDirection; + float myStepLength; + float myIntegrationStep; + float myPropagationTime; + + public: + virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual void Update(); + virtual void ToStream(ostrstream& theStr); + static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + }; + Storable* StreamLinesRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + + + //============================================================================== + class Vectors_i : public virtual POA_VISU::Vectors, + public virtual DeformedShape_i + { + static int myNbPresent; + Vectors_i(); + Vectors_i(const Vectors_i&); + public: + Vectors_i(Result_i* theResult, bool theAddToStudy = true); + virtual void SameAs(const Vectors_i* theOrigin); + virtual ~Vectors_i(); + virtual VISU::VISUType GetType() { return VISU::TVECTORS;}; + + virtual void SetLineWidth(CORBA::Double theWidth) { myLineWidth = theWidth;} + virtual CORBA::Double GetLineWidth() { return myLineWidth;} + + virtual void SetGlyphType(VISU::Vectors::GlyphType theType) { myTypeGlyph = theType;} + virtual VISU::Vectors::GlyphType GetGlyphType() { return myTypeGlyph;} + + virtual void SetGlyphPos(VISU::Vectors::GlyphPos thePos) { myPosGlyph = thePos;} + virtual VISU::Vectors::GlyphPos GetGlyphPos() { return myPosGlyph;} + + typedef VISU::Vectors InterfaceType; + + protected: + virtual DataType* DoHook(int theRestoring); + + float myLineWidth; + VISU::Vectors::GlyphType myTypeGlyph; + VISU::Vectors::GlyphPos myPosGlyph; + vtkGlyph3D *myGlyph; + vtkHedgeHog *myHog; + + public: + virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true) + throw(std::logic_error&); + static const string myComment; + virtual const char* GetComment() const; + virtual QString GenerateName(); + virtual void Update(); + virtual void ToStream(ostrstream& theStr); + static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity, + const char* theFieldName, double theIteration); + virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL); + }; + Storable* VectorsRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + //============================================================================== +} +#endif + + diff --git a/src/VISU_I/VISU_Result_i.cc b/src/VISU_I/VISU_Result_i.cc new file mode 100644 index 00000000..dc9f2505 --- /dev/null +++ b/src/VISU_I/VISU_Result_i.cc @@ -0,0 +1,375 @@ +using namespace std; +// File: VISU_Result_i.cc +// Created: Fri Jan 10 13:56:05 2003 +// Author: Alexey PETROV +// + +#include "VISU_Result_i.hh" +#include "VISU_Convertor_impl.hxx" +#include "VISU_CorbaMedConvertor.hxx" +#include "VISU_Extractor.hxx" +using namespace VISU; + +#include "SALOMEDS_Tool.hxx" + +#include +#include + +#include + +#include +#include + +using namespace std; + +#ifdef DEBUG +static int MYDEBUG = 1; +static int MYDEBUGWITHFILES = 0; +#else +static int MYDEBUG = 0; +static int MYDEBUGWITHFILES = 0; +#endif + +VISU::Result_var VISU::FindResult(SALOMEDS::SObject_ptr theSObject){ + SALOMEDS::SComponent_var aSComponent = theSObject->GetFatherComponent(); + SALOMEDS::SObject_var aFather = theSObject->GetFather(); + CORBA::String_var aComponentID(aSComponent->GetID()); + CORBA::String_var aFatherID(aFather->GetID()); + VISU::Result_var aResult; + while(strcmp(aComponentID,aFatherID) != 0){ + CORBA::Object_var anObject = VISU::SObjectToObject(aFather); + if(!CORBA::is_nil(anObject)){ + aResult = VISU::Result::_narrow(anObject); + if(!aResult->_is_nil()) return aResult; + } + aFather = aFather->GetFather(); + } + return aResult; +} + +QString VISU::GenerateName(const string& theFmt, int theId){ + static QString aName; + if(theId > 0) + aName.sprintf("%s:%d",theFmt.c_str(),theId); + else + aName.sprintf("%s",theFmt.c_str()); + return aName; +} + +void VISU::WriteToFile(vtkUnstructuredGrid* theDataSet, const string& theFileName){ + vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); + aWriter->SetFileName(theFileName.c_str()); + aWriter->SetInput(theDataSet); + aWriter->Write(); + aWriter->Delete(); +} + +QString GenerateName(const char* theName){ + typedef map TNameMap; + static TNameMap aMap; + TNameMap::const_iterator i = aMap.find(theName); + QString tmp; + if(i == aMap.end()) { + aMap[theName] = 0; + tmp = theName; + }else{ + tmp = VISU::GenerateName(theName,++aMap[theName]); + } + if(MYDEBUG) MESSAGE("GenerateName - "<NewBuilder(); + SALOMEDS::SObject_var aFather = theStudyDocument->FindObjectID(theFatherEntry.c_str()); + SALOMEDS::SObject_var newObj = aStudyBuilder->NewObject(aFather); + SALOMEDS::SObject_var aRefSObj = theStudyDocument->FindObjectID(theRefEntry.c_str()); + aStudyBuilder->Addreference(newObj,aRefSObj); +} + +string GetComponentDataType(SALOMEDS::SObject_ptr theSObject){ + SALOMEDS::SComponent_var aCompRefSObj = theSObject->GetFatherComponent(); + CORBA::String_var aDataType = aCompRefSObj->ComponentDataType(); + return aDataType.in(); +} + +//============================================================================== + +const string VISU::Result_i::myComment = "RESULT"; +const char* VISU::Result_i::GetComment() const { return myComment.c_str();} + +VISU::Result_i::Result_i(SALOMEDS::Study_ptr theStudy) { + myStudyDocument = SALOMEDS::Study::_duplicate(theStudy); + myInput = NULL; +} + +VISU::Storable* VISU::Result_i::Build(SALOMEDS::SObject_ptr theSObject) + throw (std::runtime_error&) +{ + if(MYDEBUG) MESSAGE("Result_i::Build"); + mySComponent = FindOrCreateVisuComponent(myStudyDocument); + CORBA::String_var aSComponentEntry = mySComponent->GetID(), anIOR(GetID()); + string aRefFatherEntry = GetRefFatherEntry(); + QString aComment; + aComment.sprintf("myComment=%s;myType=%d;myFileName=%s", + GetComment(),VISU::TRESULT,myFileInfo.filePath().latin1()); + string aResultEntry = CreateAttributes(myStudyDocument,aSComponentEntry,aRefFatherEntry.c_str(), + anIOR,myName.c_str(),"",aComment.latin1(),true); + mySObject = myStudyDocument->FindObjectID(aResultEntry.c_str()); + if(mySObject->_is_nil()) throw std::runtime_error("Build - There is no SObject for the Result !!!"); + if(theSObject != NULL){ + CORBA::String_var aString = theSObject->GetID(); + CreateReference(myStudyDocument,aResultEntry,aString.in()); + } + const TMeshMap& aMeshMap = myInput->GetMeshMap(); + if(!aMeshMap.empty()) {//apo + TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin(); + for(; aMeshMapIter != aMeshMap.end(); aMeshMapIter++){ + const string& aMeshName = aMeshMapIter->first; + const VISU::TMesh& aMesh = aMeshMapIter->second; + const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap; + VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter; + aComment.sprintf("myComment=MESH;myName=%s;myDim=%d", + aMeshName.c_str(),aMesh.myDim); + string aMeshEntry = CreateAttributes(myStudyDocument,aResultEntry.c_str(),aRefFatherEntry.c_str(), + "",aMeshName.c_str(),"",aComment.latin1(),true); + if(aMeshOnEntityMap.empty()) continue; + aComment.sprintf("myComment=FAMILIES;myMeshName=%s",aMeshName.c_str()); + string aSubMeshesEntry = CreateAttributes(myStudyDocument,aMeshEntry.c_str(),aRefFatherEntry.c_str(), + "","Families","",aComment.latin1(),true); + //Import entities and according families + aMeshOnEntityMapIter = aMeshOnEntityMap.begin(); + typedef map TEntity2Entry; + TEntity2Entry aEntity2Entry; + for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){ + const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first; + aComment.sprintf("myComment=ENTITY;myType=%d;myMeshName=%s;myId=%d", + VISU::TENTITY,aMeshName.c_str(),anEntity); + string anEntityName; + switch(anEntity){ + case VISU::NODE_ENTITY : anEntityName = "onNodes"; break; + case VISU::EDGE_ENTITY : anEntityName = "onEdges"; break; + case VISU::FACE_ENTITY : anEntityName = "onFaces"; break; + case VISU::CELL_ENTITY : anEntityName = "onCells"; break; + default: + throw std::runtime_error("Build >> Value of entity is incorrect!"); + } + aEntity2Entry[anEntity] = CreateAttributes(myStudyDocument,aSubMeshesEntry.c_str(),aRefFatherEntry.c_str(), + "",anEntityName.c_str(),"",aComment.latin1(),true); + const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second; + const VISU::TFamilyMap& aFamilyMap = aMeshOnEntity.myFamilyMap; + VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.begin(); + for(; aFamilyMapIter != aFamilyMap.end(); aFamilyMapIter++){ + const string& aFamilyName = aFamilyMapIter->first; + aComment.sprintf("myComment=FAMILY;myType=%d;myMeshName=%s;myEntityId=%d;myName=%s", + VISU::TFAMILY,aMeshName.c_str(),anEntity,aFamilyName.c_str()); + CreateAttributes(myStudyDocument,aEntity2Entry[anEntity].c_str(),aRefFatherEntry.c_str(), + "",aFamilyName.c_str(),"",aComment.latin1(),true); + } + } + //Importing groups + const VISU::TGroupMap& aGroupMap = aMesh.myGroupMap; + if(aGroupMap.size() > 0){ + aComment.sprintf("myComment=GROUPS;myMeshName=%s",aMeshName.c_str()); + string aGroupsEntry = CreateAttributes(myStudyDocument,aMeshEntry.c_str(),aRefFatherEntry.c_str(), + "","Groups","",aComment.latin1(),true); + VISU::TGroupMap::const_iterator aGroupMapIter = aGroupMap.begin(); + for(; aGroupMapIter != aGroupMap.end(); aGroupMapIter++){ + const string& aGroupName = aGroupMapIter->first; + aComment.sprintf("myComment=GROUP;myType=%d;myMeshName=%s;myName=%s", + VISU::TGROUP,aMeshName.c_str(),aGroupName.c_str()); + string aGroupEntry = CreateAttributes(myStudyDocument,aGroupsEntry.c_str(),aRefFatherEntry.c_str(), + "",aGroupName.c_str(),"",aComment.latin1(),true); + const VISU::TGroup& aGroup = aGroupMapIter->second; + const VISU::TFamilyAndEntitySet& aFamilyAndEntitySet = aGroup.myFamilyAndEntitySet; + VISU::TFamilyAndEntitySet::const_iterator aFamilyAndEntitySetIter = aFamilyAndEntitySet.begin(); + for(; aFamilyAndEntitySetIter != aFamilyAndEntitySet.end(); aFamilyAndEntitySetIter++){ + const VISU::TFamilyAndEntity& aFamilyAndEntity = *aFamilyAndEntitySetIter; + const string& aFamilyName = aFamilyAndEntity.first; + const VISU::TEntity& anEntity = aFamilyAndEntity.second; + aComment.sprintf("myComment=FAMILY;myType=%d;myMeshName=%s;myEntityId=%d;myName=%s", + VISU::TFAMILY,aMeshName.c_str(),anEntity,aFamilyName.c_str()); + string anEntry = FindEntryWithComment(myStudyDocument,aEntity2Entry[anEntity].c_str(),aComment); + CreateReference(myStudyDocument,aGroupEntry,anEntry); + } + } + } + //Import fields + string aFieldsEntry; + bool isFieldEntryCreated = 0; + aMeshOnEntityMapIter = aMeshOnEntityMap.begin(); + for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){ + const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first; + const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second; + const VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap; + VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin(); + for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){ + if(!isFieldEntryCreated){ + aComment.sprintf("myComment=FIELDS;myMeshName=%s",aMeshName.c_str()); + aFieldsEntry = CreateAttributes(myStudyDocument,aMeshEntry.c_str(),aRefFatherEntry.c_str(), + "","Fields","",aComment.latin1(),true); + isFieldEntryCreated = true; + } + const string& aFieldName = aFieldMapIter->first; + const VISU::TField& aField = aFieldMapIter->second; + const VISU::TField::TValField& aValField = aField.myValField; + aComment.sprintf("myComment=FIELD;myType=%d;myMeshName=%s;myEntityId=%d;myName=%s;myNbTimeStamps=%d;myNumComponent=%d", + VISU::TFIELD,aMeshName.c_str(),anEntity,aFieldName.c_str(),aValField.size(),aField.myNbComp); + string aFieldEntry = CreateAttributes(myStudyDocument,aFieldsEntry.c_str(),aRefFatherEntry.c_str(), + "",aFieldName.c_str(),"",aComment.latin1(),true); + CreateReference(myStudyDocument,aFieldEntry,aEntity2Entry[anEntity]); + VISU::TField::TValField::const_iterator aValFieldIter = aValField.begin(); + for(; aValFieldIter != aValField.end(); aValFieldIter++){ + int aTimeStamp = aValFieldIter->first; + const VISU::TField::TValForTime& aValForTime = aValFieldIter->second; + aComment.sprintf("myComment=TIMESTAMP;myType=%d;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d", + VISU::TTIMESTAMP,aMeshName.c_str(),anEntity,aFieldName.c_str(),aTimeStamp,aField.myNbComp); + string aTimeStampId = VISU_Convertor::GenerateName(aValForTime.myTime); + CreateAttributes(myStudyDocument,aFieldEntry.c_str(),aRefFatherEntry.c_str(), + "",aTimeStampId.c_str(),"",aComment.latin1(),true); + } + } + } + } + } + return this; +} + +VISU::Storable* VISU::Result_i::Create(const char* theFileName){ + try{ + mySourceId = eFile; + myInput = CreateConvertor(theFileName); + if(myInput == NULL) return NULL; + myFileInfo.setFile(theFileName); + myName = ::GenerateName(myFileInfo.fileName().latin1()); + return Build(); + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured :\n"<GetStudy(); + mySComponent = mySObject->GetFatherComponent(); + myName = VISU::Storable::FindValue(theMap,"myName"); + SALOMEDS::SObject_var aRefSObj, aTargetRefSObj; + if(mySObject->FindSubObject(1,aRefSObj) && aRefSObj->ReferencedObject(aTargetRefSObj)){ + mySourceId = eRestoredComponent; + if(MYDEBUG) MESSAGE("Result_i::GetInput - There is some reference."); + SALOMEDS::SComponent_var aCompRefSObj = aTargetRefSObj->GetFatherComponent(); + CORBA::String_var aDataType = aCompRefSObj->ComponentDataType(); + myFileInfo.setFile(aDataType.in()); + if(MYDEBUG) MESSAGE("Result_i::GetInput - aDataType = "<FindOrLoad_Component("FactoryServer", aDataType.in()); + if (CORBA::is_nil(aEngComp)) + throw std::runtime_error("Restore - There is no aEngComp for the aDataType !!!"); + SALOMEDS::StudyBuilder_var aStudyBuilder = myStudyDocument->NewBuilder(); + SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(aEngComp); + aStudyBuilder->LoadWith(aCompRefSObj,aDriver); + if(strcmp(aDataType,"Med") == 0){ + myInput = CreateMEDConvertor(aTargetRefSObj); + }else + throw std::runtime_error("GetInput - There is no convertor for the aDataType !!!"); + }else{ + mySourceId = eRestoredFile; + myFileInfo.setFile(thePrefix.c_str()); + string aStudyPrefix(SALOMEDS_Tool::GetNameFromPath(myStudyDocument->URL())); + string aTmpDir(SALOMEDS_Tool::GetDirFromPath(myStudyDocument->URL())); + if(!myFileInfo.isFile()){ + string aFileName = thePrefix + aStudyPrefix + "_" + myName; + myFileInfo.setFile(aFileName.c_str()); + } + if(MYDEBUG) + MESSAGE("Result_i::Restore - aFileName = "<FindAttribute(anAttr, "AttributeComment")) + throw std::runtime_error("Build - There is no AttributeComment for the SObject !!!"); + SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr); + aCmnt->SetValue(aComment.latin1()); + // remove temporary file, if it's not multifile mode + if (false || !IsMultifile()) { + SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames; + aSeq->length(1); + aSeq[0]=(aStudyPrefix + myName).c_str(); + SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true); + } + } + return this; + }catch(std::runtime_error& exc){ + MESSAGE("Follow exception was accured :\n"<GetStudy(); + VISU::Result_i* pResult = new VISU::Result_i(aStudy); + if(pResult == NULL) return NULL; + return pResult->Restore(theSObject,thePrefix,theMap); +} + +string VISU::Result_i::GetRefFatherEntry() { + //return QAD_Application::getDesktop()->getActiveStudy()->getActiveStudyFrame()->entry(); + return ""; +} + +string VISU::Result_i::GetEntry(){ + CORBA::String_var anEntry = mySObject->GetID(); + return string(anEntry); +} + +const SALOMEDS::SObject_var& VISU::Result_i::GetSObject() const { return mySObject;} +const SALOMEDS::Study_var& VISU::Result_i::GetStudyDocument() const { return myStudyDocument;} +const SALOMEDS::SComponent_var& VISU::Result_i::GetSComponent() const { return mySComponent;} + +VISU::Result_i::~Result_i() { + if(MYDEBUG) MESSAGE("Result_i::~Result_i()"); + if(myInput) delete myInput; +} diff --git a/src/VISU_I/VISU_Result_i.hh b/src/VISU_I/VISU_Result_i.hh new file mode 100644 index 00000000..441e8260 --- /dev/null +++ b/src/VISU_I/VISU_Result_i.hh @@ -0,0 +1,71 @@ +// File: VISU_Result_i.hh +// Created: Fri Jan 10 12:36:38 2003 +// Author: Alexey PETROV +// + +#ifndef __VISU_RESULT_I_H__ +#define __VISU_RESULT_I_H__ + +#include "VISUConfig.hh" + +class vtkUnstructuredGridReader; +class vtkUnstructuredGrid; +class VISU_Convertor; +class FieldInfo; +class QAD_Study; + +namespace VISU{ + class Result_i : public virtual POA_VISU::Result, + public virtual Storable + { + Result_i(); + Result_i(const Result_i &); + public: + Result_i(SALOMEDS::Study_ptr theStudy); + virtual ~Result_i(); + + virtual VISU::VISUType GetType() { return VISU::TRESULT;}; + + typedef VISU_Convertor InputType; + typedef vtkUnstructuredGridReader OutputType; + enum TSourceId {eRestoredComponent = -2, eRestoredFile = -1, eFile = 1, eComponent = 2}; + private: + TSourceId mySourceId; + InputType *myInput; + string myName; + QFileInfo myFileInfo; + protected: + virtual Storable* Build(SALOMEDS::SObject_ptr theSObject = NULL) + throw (std::runtime_error&); + public: + virtual Storable* Create(const char* theFileName); + virtual Storable* Create(SALOMEDS::SObject_ptr theMedSObject); + virtual Storable* Restore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + virtual void ToStream(ostrstream& theStr); + virtual const char* GetComment() const; + static const string myComment; + InputType* GetInput(); + const string& GetName() const { return myName;} + const QFileInfo& GetFileInfo() const { return myFileInfo;} + Result_i::TSourceId GetSourceId() const { return mySourceId;} + private: + SALOMEDS::SObject_var mySObject; + SALOMEDS::Study_var myStudyDocument; + SALOMEDS::SComponent_var mySComponent; + public: + string GetRefFatherEntry(); + string GetEntry(); + const SALOMEDS::SObject_var& GetSObject() const; + const SALOMEDS::Study_var& GetStudyDocument() const; + const SALOMEDS::SComponent_var& GetSComponent() const; + }; + Storable* ResultRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) + throw(std::logic_error&); + Result_var FindResult(SALOMEDS::SObject_ptr theSObject); + QString GenerateName(const string& theFmt, int theId); + void WriteToFile(vtkUnstructuredGrid* theDataSet, const string& theFileName); +} +#endif diff --git a/src/VISU_I/VISU_ScalarBarActor.cxx b/src/VISU_I/VISU_ScalarBarActor.cxx new file mode 100644 index 00000000..754779ca --- /dev/null +++ b/src/VISU_I/VISU_ScalarBarActor.cxx @@ -0,0 +1,600 @@ +using namespace std; +// File: VISU_ScalarBarActor.cxx +// Created: Wed Feb 26 10:34:56 2003 +// Author: Alexey PETROV +// + + +#include "VISU_ScalarBarActor.hxx" +#include "VISU_LookupTable.hxx" +#include + +//------------------------------------------------------------------------------ +VISU_ScalarBarActor* VISU_ScalarBarActor::New(){ + vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_ScalarBarActor"); + if(ret) + return (VISU_ScalarBarActor*)ret; + return new VISU_ScalarBarActor; +} + +VISU_ScalarBarActor::VISU_ScalarBarActor() +{ + this->myLookupTable = NULL; + this->Position2Coordinate->SetValue(0.17, 0.8); + + this->PositionCoordinate->SetCoordinateSystemToNormalizedViewport(); + this->PositionCoordinate->SetValue(0.82,0.1); + + this->MaximumNumberOfColors = 64; + this->NumberOfLabels = 5; + this->NumberOfLabelsBuilt = 0; + this->Orientation = VTK_ORIENT_VERTICAL; + this->Title = NULL; + + this->Bold = 1; + this->Italic = 1; + this->Shadow = 1; + this->FontFamily = VTK_ARIAL; + this->LabelFormat = new char[8]; + sprintf(this->LabelFormat,"%s","%-#6.3g"); + + this->TitleMapper = vtkTextMapper::New(); + this->TitleMapper->SetJustificationToCentered(); + this->TitleActor = vtkActor2D::New(); + this->TitleActor->SetMapper(this->TitleMapper); + this->TitleActor->GetPositionCoordinate()-> + SetReferenceCoordinate(this->PositionCoordinate); + + this->TextMappers = NULL; + this->TextActors = NULL; + + this->ScalarBar = vtkPolyData::New(); + this->ScalarBarMapper = vtkPolyDataMapper2D::New(); + this->ScalarBarMapper->SetInput(this->ScalarBar); + this->ScalarBarActor = vtkActor2D::New(); + this->ScalarBarActor->SetMapper(this->ScalarBarMapper); + this->ScalarBarActor->GetPositionCoordinate()-> + SetReferenceCoordinate(this->PositionCoordinate); + this->LastOrigin[0] = 0; + this->LastOrigin[1] = 0; + this->LastSize[0] = 0; + this->LastSize[1] = 0; +} + +void VISU_ScalarBarActor::ReleaseGraphicsResources(vtkWindow *win) +{ + this->TitleActor->ReleaseGraphicsResources(win); + if (this->TextMappers != NULL ) + { + for (int i=0; i < this->NumberOfLabelsBuilt; i++) + { + this->TextActors[i]->ReleaseGraphicsResources(win); + } + } + this->ScalarBarActor->ReleaseGraphicsResources(win); +} + +VISU_ScalarBarActor::~VISU_ScalarBarActor() +{ + if (this->LabelFormat) + { + delete [] this->LabelFormat; + this->LabelFormat = NULL; + } + + this->TitleMapper->Delete(); + this->TitleActor->Delete(); + + if (this->TextMappers != NULL ) + { + for (int i=0; i < this->NumberOfLabelsBuilt; i++) + { + this->TextMappers[i]->Delete(); + this->TextActors[i]->Delete(); + } + delete [] this->TextMappers; + delete [] this->TextActors; + } + + this->ScalarBar->Delete(); + this->ScalarBarMapper->Delete(); + this->ScalarBarActor->Delete(); + + if (this->Title) + { + delete [] this->Title; + this->Title = NULL; + } + + this->SetLookupTable(NULL); +} + +void VISU_ScalarBarActor::SetLookupTable(vtkScalarsToColors* theLookupTable){ + //this->myLookupTable = dynamic_cast(theLookupTable); + if(this->myLookupTable != NULL) this->myLookupTable->UnRegister(this); + this->myLookupTable = VISU_LookupTable::SafeDownCast(theLookupTable); + this->myLookupTable->Register(this); +} + +vtkScalarsToColors* VISU_ScalarBarActor::GetLookupTable(){ + cout<<"VISU_ScalarBarActor::GetLookupTable = "<myLookupTable; + return this->myLookupTable; +} + +int VISU_ScalarBarActor::RenderOverlay(vtkViewport *viewport) +{ + int renderedSomething = 0; + int i; + + // Everything is built, just have to render + if (this->Title != NULL) + { + renderedSomething += this->TitleActor->RenderOverlay(viewport); + } + this->ScalarBarActor->RenderOverlay(viewport); + if( this->TextActors == NULL) + { + vtkWarningMacro(<<"Need a mapper to render a scalar bar"); + return renderedSomething; + } + + for (i=0; iNumberOfLabels; i++) + { + renderedSomething += this->TextActors[i]->RenderOverlay(viewport); + } + + renderedSomething = (renderedSomething > 0)?(1):(0); + + return renderedSomething; +} + +int VISU_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport) +{ + int renderedSomething = 0; + int i; + int size[2]; + + if ( ! this->myLookupTable ) + { + vtkWarningMacro(<<"Need a mapper to render a scalar bar"); + return 0; + } + + // Check to see whether we have to rebuild everything + if ( viewport->GetMTime() > this->BuildTime || + ( viewport->GetVTKWindow() && + viewport->GetVTKWindow()->GetMTime() > this->BuildTime ) ) + { + // if the viewport has changed we may - or may not need + // to rebuild, it depends on if the projected coords chage + int *barOrigin; + barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport); + size[0] = + this->Position2Coordinate->GetComputedViewportValue(viewport)[0] - + barOrigin[0]; + size[1] = + this->Position2Coordinate->GetComputedViewportValue(viewport)[1] - + barOrigin[1]; + if (this->LastSize[0] != size[0] || this->LastSize[1] != size[1] || + this->LastOrigin[0] != barOrigin[0] || + this->LastOrigin[1] != barOrigin[1]) + { + this->Modified(); + } + } + + // Check to see whether we have to rebuild everything + if ( this->GetMTime() > this->BuildTime || + this->myLookupTable->GetMTime() > this->BuildTime ) + { + vtkDebugMacro(<<"Rebuilding subobjects"); + + // Delete previously constructed objects + // + if (this->TextMappers != NULL ) + { + for (i=0; i < this->NumberOfLabelsBuilt; i++) + { + this->TextMappers[i]->Delete(); + this->TextActors[i]->Delete(); + } + delete [] this->TextMappers; + delete [] this->TextActors; + } + + // Build scalar bar object + // + VISU_LookupTable *lut = this->myLookupTable; //VISU specific + // we hard code how many steps to display + int numColors = this->MaximumNumberOfColors; + float *range = lut->GetRange(); + + int numPts = 2*(numColors + 1); + vtkPoints *pts = vtkPoints::New(); + pts->SetNumberOfPoints(numPts); + vtkCellArray *polys = vtkCellArray::New(); + polys->Allocate(polys->EstimateSize(numColors,4)); + vtkScalars *colors = vtkScalars::New(VTK_UNSIGNED_CHAR,3); + colors->SetNumberOfScalars(numColors); + vtkUnsignedCharArray *colorData = (vtkUnsignedCharArray *)colors->GetData(); + + this->ScalarBarActor->SetProperty(this->GetProperty()); + this->ScalarBar->Initialize(); + this->ScalarBar->SetPoints(pts); + this->ScalarBar->SetPolys(polys); + this->ScalarBar->GetCellData()->SetScalars(colors); + pts->Delete(); polys->Delete(); colors->Delete(); + + // get the viewport size in display coordinates + int *barOrigin, barWidth, barHeight; + barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport); + size[0] = + this->Position2Coordinate->GetComputedViewportValue(viewport)[0] - + barOrigin[0]; + size[1] = + this->Position2Coordinate->GetComputedViewportValue(viewport)[1] - + barOrigin[1]; + this->LastOrigin[0] = barOrigin[0]; + this->LastOrigin[1] = barOrigin[1]; + this->LastSize[0] = size[0]; + this->LastSize[1] = size[1]; + + // Update all the composing objects + // + if (this->Title == NULL ) + { + this->TitleActor->VisibilityOff(); + } + this->TitleActor->VisibilityOn(); + this->TitleActor->SetProperty(this->GetProperty()); + this->TitleMapper->SetInput(this->Title); + this->TitleMapper->SetBold(this->Bold); + this->TitleMapper->SetItalic(this->Italic); + this->TitleMapper->SetShadow(this->Shadow); + this->TitleMapper->SetFontFamily(this->FontFamily); + + + // find the best size for the title font + int titleSize[2]; + this->SizeTitle(titleSize, size, viewport); + + // find the best size for the ticks + int labelSize[2]; + this->AllocateAndSizeLabels(labelSize, size, viewport,range); + this->NumberOfLabelsBuilt = this->NumberOfLabels; + + // generate points + float x[3]; x[2] = 0.0; + float delta; + if ( this->Orientation == VTK_ORIENT_VERTICAL ) + { + barWidth = size[0] - 4 - labelSize[0]; + barHeight = (int)(0.86*size[1]); + delta=(float)barHeight/numColors; + for (i=0; iSetPoint(2*i,x); + x[0] = barWidth; + pts->SetPoint(2*i+1,x); + } + } + else + { + barWidth = size[0]; + barHeight = (int)(0.4*size[1]); + delta=(float)barWidth/numColors; + for (i=0; iSetPoint(2*i,x); + x[1] = 0; + pts->SetPoint(2*i+1,x); + } + } + + //polygons & cell colors + unsigned char *rgba, *rgb; + int ptIds[4]; + float val, *aLogRange = this->myLookupTable->GetLogRange(); + for (i=0; iInsertNextCell(4,ptIds); + rgba = lut->MapValue(range[0] + (range[1] - range[0])*((float)i /(numColors-1.0))); + if(this->myLookupTable->IsLog()){ // SALOME specific + val = aLogRange[0] + (float)i/(numColors-1.0) * (aLogRange[1]-aLogRange[0]); + rgba = lut->MapValue(val); + } + rgb = colorData->GetPointer(3*i); //write into array directly + rgb[0] = rgba[0]; + rgb[1] = rgba[1]; + rgb[2] = rgba[2]; + } + + // Now position everything properly + // + if (this->Orientation == VTK_ORIENT_VERTICAL) + { + int sizeTextData[2]; + + // center the title + this->TitleActor->SetPosition(size[0]/2, 0.9*size[1]); + + for (i=0; i < this->NumberOfLabels; i++) + { + val = (float)i/(this->NumberOfLabels-1) *barHeight; + this->TextMappers[i]->SetJustificationToLeft(); + this->TextMappers[i]->GetSize(viewport,sizeTextData); + this->TextActors[i]->SetPosition(barWidth+3, + val - sizeTextData[1]/2); + } + } + else + { + this->TitleActor->SetPosition(size[0]/2, + barHeight + labelSize[1] + 0.1*size[1]); + for (i=0; i < this->NumberOfLabels; i++) + { + val = (float)i/(this->NumberOfLabels-1) * barWidth; + this->TextMappers[i]->SetJustificationToCentered(); + this->TextActors[i]->SetPosition(val, barHeight + 0.05*size[1]); + } + } + + this->BuildTime.Modified(); + } + + // Everything is built, just have to render + if (this->Title != NULL) + { + renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport); + } + this->ScalarBarActor->RenderOpaqueGeometry(viewport); + for (i=0; iNumberOfLabels; i++) + { + renderedSomething += this->TextActors[i]->RenderOpaqueGeometry(viewport); + } + + renderedSomething = (renderedSomething > 0)?(1):(0); + + return renderedSomething; +} + +void VISU_ScalarBarActor::PrintSelf(ostream& os, vtkIndent indent) +{ + vtkActor2D::PrintSelf(os,indent); + + if ( this->myLookupTable ) + { + os << indent << "Lookup Table:\n"; + this->myLookupTable->PrintSelf(os,indent.GetNextIndent()); + } + else + { + os << indent << "Lookup Table: (none)\n"; + } + + os << indent << "Title: " << (this->Title ? this->Title : "(none)") << "\n"; + os << indent << "Maximum Number Of Colors: " + << this->MaximumNumberOfColors << "\n"; + os << indent << "Number Of Labels: " << this->NumberOfLabels << "\n"; + os << indent << "Number Of Labels Built: " << this->NumberOfLabelsBuilt << "\n"; + + os << indent << "Orientation: "; + if ( this->Orientation == VTK_ORIENT_HORIZONTAL ) + { + os << "Horizontal\n"; + } + else + { + os << "Vertical\n"; + } + + os << indent << "Font Family: "; + if ( this->FontFamily == VTK_ARIAL ) + { + os << "Arial\n"; + } + else if ( this->FontFamily == VTK_COURIER ) + { + os << "Courier\n"; + } + else + { + os << "Times\n"; + } + + os << indent << "Bold: " << (this->Bold ? "On\n" : "Off\n"); + os << indent << "Italic: " << (this->Italic ? "On\n" : "Off\n"); + os << indent << "Shadow: " << (this->Shadow ? "On\n" : "Off\n"); + os << indent << "Label Format: " << this->LabelFormat << "\n"; +} + +void VISU_ScalarBarActor::ShallowCopy(vtkProp *prop) +{ + VISU_ScalarBarActor *a = VISU_ScalarBarActor::SafeDownCast(prop); + if ( a != NULL ) + { + this->SetPosition2(a->GetPosition2()); + this->SetLookupTable(a->GetLookupTable()); + this->SetMaximumNumberOfColors(a->GetMaximumNumberOfColors()); + this->SetOrientation(a->GetOrientation()); + this->SetBold(a->GetBold()); + this->SetItalic(a->GetItalic()); + this->SetShadow(a->GetShadow()); + this->SetFontFamily(a->GetFontFamily()); + this->SetLabelFormat(a->GetLabelFormat()); + this->SetTitle(a->GetTitle()); + + this->GetPositionCoordinate()->SetCoordinateSystem( + a->GetPositionCoordinate()->GetCoordinateSystem()); + this->GetPositionCoordinate()->SetValue( + a->GetPositionCoordinate()->GetValue()); + this->GetPosition2Coordinate()->SetCoordinateSystem( + a->GetPosition2Coordinate()->GetCoordinateSystem()); + this->GetPosition2Coordinate()->SetValue( + a->GetPosition2Coordinate()->GetValue()); + } + + // Now do superclass + this->vtkActor2D::ShallowCopy(prop); +} + +void VISU_ScalarBarActor::AllocateAndSizeLabels(int *labelSize, int *size, + vtkViewport *viewport, + float *range) +{ + labelSize[0] = 0; + labelSize[1] = 0; + int fontSize; + int tempi[2]; + + this->TextMappers = new vtkTextMapper * [this->NumberOfLabels]; + this->TextActors = new vtkActor2D * [this->NumberOfLabels]; + char string[512]; + float val, *aLogRange = this->myLookupTable->GetLogRange(); + int targetWidth, targetHeight; + int i; + + for (i=0; i < this->NumberOfLabels; i++) + { + this->TextMappers[i] = vtkTextMapper::New(); + val = range[0] + (float)i/(this->NumberOfLabels-1) * (range[1]-range[0]); + if(0 < i && i < this->NumberOfLabels - 1) // SALOME specific + if(this->myLookupTable->IsLog()){ + val = aLogRange[0] + (float)i/(this->NumberOfLabels-1) * (aLogRange[1]-aLogRange[0]); + val = pow((float)10.0,val); + } + sprintf(string, this->LabelFormat, val); + this->TextMappers[i]->SetInput(string); + this->TextMappers[i]->SetBold(this->Bold); + this->TextMappers[i]->SetItalic(this->Italic); + this->TextMappers[i]->SetShadow(this->Shadow); + this->TextMappers[i]->SetFontFamily(this->FontFamily); + this->TextActors[i] = vtkActor2D::New(); + this->TextActors[i]->SetMapper(this->TextMappers[i]); + this->TextActors[i]->SetProperty(this->GetProperty()); + this->TextActors[i]->GetPositionCoordinate()-> + SetReferenceCoordinate(this->PositionCoordinate); + } + if (this->NumberOfLabels) + { + if ( this->Orientation == VTK_ORIENT_VERTICAL ) + { + targetWidth = (int)(0.6*size[0]); + targetHeight = (int)(0.86*size[1]/this->NumberOfLabels); + } + else + { + targetWidth = (int)(size[0]*0.8/this->NumberOfLabels); + targetHeight = (int)(0.25*size[1]); + } + fontSize = targetWidth; + for (i=0; i < this->NumberOfLabels; i++) + { + this->TextMappers[i]->SetFontSize(fontSize); + this->TextMappers[i]->GetSize(viewport,tempi); + if (labelSize[0] < tempi[0]) + { + labelSize[0] = tempi[0]; + } + if (labelSize[1] < tempi[1]) + { + labelSize[1] = tempi[1]; + } + } + + while (labelSize[0] < targetWidth && labelSize[1] < targetHeight && + fontSize < 100 ) + { + fontSize++; + labelSize[0] = 0; + labelSize[1] = 0; + for (i=0; i < this->NumberOfLabels; i++) + { + this->TextMappers[i]->SetFontSize(fontSize); + this->TextMappers[i]->GetSize(viewport,tempi); + if (labelSize[0] < tempi[0]) + { + labelSize[0] = tempi[0]; + } + if (labelSize[1] < tempi[1]) + { + labelSize[1] = tempi[1]; + } + } + } + + while ((labelSize[0] > targetWidth || + labelSize[1] > targetHeight) && fontSize > 0 ) + { + fontSize--; + labelSize[0] = 0; + labelSize[1] = 0; + for (i=0; i < this->NumberOfLabels; i++) + { + this->TextMappers[i]->SetFontSize(fontSize); + this->TextMappers[i]->GetSize(viewport,tempi); + if (labelSize[0] < tempi[0]) + { + labelSize[0] = tempi[0]; + } + if (labelSize[1] < tempi[1]) + { + labelSize[1] = tempi[1]; + } + } + } + } +} + +void VISU_ScalarBarActor::SizeTitle(int *titleSize, int *size, + vtkViewport *viewport) +{ + int targetWidth, targetHeight; + titleSize[0] = 0; + titleSize[1] = 0; + int fontSize; + int tempi[2]; + + if (this->Title != NULL && (strlen(this->Title) != 0)) + { + if ( this->Orientation == VTK_ORIENT_VERTICAL ) + { + targetWidth = size[0]; + targetHeight = (int)(0.1*size[1]); + } + else + { + targetWidth = size[0]; + targetHeight = (int)(0.25*size[1]); + } + fontSize = targetWidth; + this->TitleMapper->SetFontSize(fontSize); + this->TitleMapper->GetSize(viewport,tempi); + + while (tempi[1] < targetHeight && tempi[0] < targetWidth + && fontSize < 100 ) + { + fontSize++; + this->TitleMapper->SetFontSize(fontSize); + this->TitleMapper->GetSize(viewport,tempi); + } + + while ((tempi[1] > targetHeight || tempi[0] > targetWidth ) + && fontSize > 0 ) + { + fontSize--; + this->TitleMapper->SetFontSize(fontSize); + this->TitleMapper->GetSize(viewport,tempi); + } + titleSize[0] = tempi[0]; + titleSize[1] = tempi[1]; + } +} diff --git a/src/VISU_I/VISU_ScalarBarActor.hxx b/src/VISU_I/VISU_ScalarBarActor.hxx new file mode 100644 index 00000000..9e4ed8bc --- /dev/null +++ b/src/VISU_I/VISU_ScalarBarActor.hxx @@ -0,0 +1,116 @@ +// File: VISU_ScalarBarActor.hxx +// Created: Wed Feb 26 10:13:15 2003 +// Author: Alexey PETROV +// + + +#ifndef VISU_ScalarBarActor_HeaderFile +#define VISU_ScalarBarActor_HeaderFile + +#include +#include +#include +#include +#include + +class VISU_LookupTable; + +#define VTK_ORIENT_HORIZONTAL 0 +#define VTK_ORIENT_VERTICAL 1 + +class VTK_EXPORT VISU_ScalarBarActor : public vtkActor2D +{ +public: + vtkTypeMacro(VISU_ScalarBarActor,vtkActor2D); + void PrintSelf(ostream& os, vtkIndent indent); + + static VISU_ScalarBarActor *New(); + + int RenderOpaqueGeometry(vtkViewport* viewport); + int RenderTranslucentGeometry(vtkViewport*) { return 0; }; + int RenderOverlay(vtkViewport* viewport); + + virtual void ReleaseGraphicsResources(vtkWindow *); + + void SetLookupTable(vtkScalarsToColors*); + vtkScalarsToColors* GetLookupTable(); + + vtkSetClampMacro(MaximumNumberOfColors, int, 2, VTK_LARGE_INTEGER); + vtkGetMacro(MaximumNumberOfColors, int); + + vtkSetClampMacro(NumberOfLabels, int, 0, 64); + vtkGetMacro(NumberOfLabels, int); + + vtkSetClampMacro(Orientation,int,VTK_ORIENT_HORIZONTAL, VTK_ORIENT_VERTICAL); + vtkGetMacro(Orientation, int); + void SetOrientationToHorizontal() + {this->SetOrientation(VTK_ORIENT_HORIZONTAL);}; + void SetOrientationToVertical() {this->SetOrientation(VTK_ORIENT_VERTICAL);}; + + vtkSetMacro(Bold, int); + vtkGetMacro(Bold, int); + vtkBooleanMacro(Bold, int); + + vtkSetMacro(Italic, int); + vtkGetMacro(Italic, int); + vtkBooleanMacro(Italic, int); + + vtkSetMacro(Shadow, int); + vtkGetMacro(Shadow, int); + vtkBooleanMacro(Shadow, int); + + vtkSetMacro(FontFamily, int); + vtkGetMacro(FontFamily, int); + void SetFontFamilyToArial() {this->SetFontFamily(VTK_ARIAL);}; + void SetFontFamilyToCourier() {this->SetFontFamily(VTK_COURIER);}; + void SetFontFamilyToTimes() {this->SetFontFamily(VTK_TIMES);}; + + vtkSetStringMacro(LabelFormat); + vtkGetStringMacro(LabelFormat); + + vtkSetStringMacro(Title); + vtkGetStringMacro(Title); + + void ShallowCopy(vtkProp *prop); + +protected: + VISU_ScalarBarActor(); + ~VISU_ScalarBarActor(); + VISU_ScalarBarActor(const VISU_ScalarBarActor&); + void operator=(const VISU_ScalarBarActor&); + + VISU_LookupTable* myLookupTable; +private: + int MaximumNumberOfColors; + int NumberOfLabels; + int NumberOfLabelsBuilt; + int Orientation; + char *Title; + + int Bold; + int Italic; + int Shadow; + int FontFamily; + char *LabelFormat; + +private: + vtkTextMapper *TitleMapper; + vtkActor2D *TitleActor; + + vtkTextMapper **TextMappers; + vtkActor2D **TextActors; + + vtkPolyData *ScalarBar; + vtkPolyDataMapper2D *ScalarBarMapper; + vtkActor2D *ScalarBarActor; + + vtkTimeStamp BuildTime; + int LastSize[2]; + int LastOrigin[2]; + + void SizeTitle(int *titleSize, int *size, vtkViewport *viewport); + void AllocateAndSizeLabels(int *labelSize, int *size, + vtkViewport *viewport, float *range); +}; + +#endif diff --git a/src/VISU_I/VISU_Table_i.cc b/src/VISU_I/VISU_Table_i.cc new file mode 100644 index 00000000..ba5dda37 --- /dev/null +++ b/src/VISU_I/VISU_Table_i.cc @@ -0,0 +1,1053 @@ +using namespace std; +// File: VISU_Table_i.cc +// Created: Thu Feb 13 17:57:39 2003 +// Author: Vadim SANDLER +// + +#include "VISU_Table_i.hh" + +#include "QAD_Application.h" +#include "QAD_Desktop.h" +#include "QAD_Study.h" +#include +#include +#include +#include +#include + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 0; +#endif + +//---------------------------------------------------------------- +// Table Object +//---------------------------------------------------------------- +int VISU::Table_i::myNbPresent = 0; +const string VISU::Table_i::myComment = "TABLE"; +/*! + Generate unique name +*/ +const char* VISU::Table_i::GenerateName() +{ + return VISU::GenerateName( "Table", ++myNbPresent ); +} +/*! + Gets comment string +*/ +const char* VISU::Table_i::GetComment() const +{ + return myComment.c_str(); +} +/*! + Constructor +*/ +VISU::Table_i::Table_i( SALOMEDS::Study_ptr theStudy, const char* theObjectEntry ) + : PrsObject_i(theStudy) +{ + myObjectEntry = theObjectEntry; + myOrientation = VISU::Table::HORIZONTAL; +} +/*! + Destructor +*/ +VISU::Table_i::~Table_i() +{ +} +/*! + Gets number of rows in table +*/ +CORBA::Long VISU::Table_i::GetNbRows() +{ + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myObjectEntry.c_str() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + if ( !SO->_is_nil() ) { + SALOMEDS::GenericAttribute_var anAttr; + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + SALOMEDS::AttributeTableOfInteger_var anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + return anInt->GetNbRows(); + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + SALOMEDS::AttributeTableOfReal_var aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + return aReal->GetNbRows(); + } + } + return 0; +} +/*! + Gets number of columns in table +*/ +CORBA::Long VISU::Table_i::GetNbColumns() +{ + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myObjectEntry.c_str() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + if ( !SO->_is_nil() ) { + SALOMEDS::GenericAttribute_var anAttr; + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + SALOMEDS::AttributeTableOfInteger_var anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + return anInt->GetNbColumns(); + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + SALOMEDS::AttributeTableOfReal_var aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + return aReal->GetNbColumns(); + } + } + return 0; +} +/*! + Creates table object +*/ +VISU::Storable* VISU::Table_i::Create() +{ + // generate name ... + myName = GenerateName(); + // ... and build the object + return Build( false ); +} +/*! + Builds presentation of table +*/ +VISU::Storable* VISU::Table_i::Build( int theRestoring ) +{ + // look for reference SObject with table attribute + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myObjectEntry.c_str() ); + if ( !SO->_is_nil() ) { + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) || + Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + // look for component + if ( !theRestoring ) { + SALOMEDS::SComponent_var SComponent = VISU::FindOrCreateVisuComponent( myStudy ); + // create SObject and set attributes + QString aComment; + aComment.sprintf("myComment=%s;myType=%d",GetComment(),VISU::TTABLE); + string anEntry = CreateAttributes( myStudy, + SComponent->GetID(), + "", + GetID(), + GetName(), + "", + aComment.latin1(), + true ); + // create SObject referenced to real table object + SALOMEDS::SObject_var newSO = myStudy->FindObjectID( anEntry.c_str() ); + SALOMEDS::SObject_var refSO = Builder->NewObject( newSO ); + Builder->Addreference( refSO, SO ); + } + return this; + } + } + return NULL; +} +/*! + Restores table object from stream +*/ +VISU::Storable* VISU::Table_i::Restore( const Storable::TRestoringMap& theMap ) + throw( std::logic_error& ) +{ + if(MYDEBUG) MESSAGE(GetComment()); + myName = VISU::Storable::FindValue(theMap,"myName"); + myObjectEntry = VISU::Storable::FindValue(theMap,"myObjectEntry"); + myTitle = VISU::Storable::FindValue(theMap,"myTitle"); + myOrientation = ( VISU::Table::Orientation )( VISU::Storable::FindValue(theMap,"myOrientation").toInt() ); + return Build( true ); +} +/*! + Flushes table data into stream +*/ +void VISU::Table_i::ToStream( ostrstream& theStr ) +{ + Storable::DataToStream( theStr, "myName", myName.c_str() ); + Storable::DataToStream( theStr, "myObjectEntry", myObjectEntry.c_str() ); + Storable::DataToStream( theStr, "myTitle", myTitle.c_str() ); + Storable::DataToStream( theStr, "myOrientation", myOrientation ); + +// theStr<<"\n myName ="<GetStudy(); + VISU::Table_i* pResent = new VISU::Table_i( aStudy, "" ); + return pResent->Restore( theMap ); +} + +//---------------------------------------------------------------- +// Curve Object +//---------------------------------------------------------------- +/*! + Restores table object from the stream [ static ] +*/ +static VISU::Table_i* GetTable( SALOMEDS::Study_var& theStudy, const VISU::Storable::TRestoringMap& theMap ) { + string anEntry = VISU::Storable::FindValue( theMap, "TableID" ).latin1(); + SALOMEDS::SObject_var aSObject = theStudy->FindObjectID( anEntry.c_str() ); + CORBA::Object_var anObject = VISU::SObjectToObject( aSObject ); + if( !CORBA::is_nil( anObject ) ) { + CORBA::Object_ptr aTable = VISU::Table::_narrow( anObject ); + if( !CORBA::is_nil( aTable ) ) + return dynamic_cast( VISU::GetServant( aTable ) ); + } + return NULL; +} + +int VISU::Curve_i::myNbPresent = 0; +const string VISU::Curve_i::myComment = "CURVE"; +/*! + Generate unique name +*/ +const char* VISU::Curve_i::GenerateName() +{ + return VISU::GenerateName( "Curve", ++myNbPresent ); +} +/*! + Gets comment string +*/ +const char* VISU::Curve_i::GetComment() const +{ + return myComment.c_str(); +} +/*! + Constructor + NB : theHRow, theVRow are the indexes of rows in the Table object and numbered from the 1 to GetNbRows() +*/ +VISU::Curve_i::Curve_i(SALOMEDS::Study_ptr theStudy, Table_i* theTable, CORBA::Long theHRow, CORBA::Long theVRow ) + : PrsObject_i(theStudy), myTable( theTable ), myHRow( theHRow ), myVRow( theVRow ) +{ + myAuto = true; + myLine = VISU::Curve::SOLIDLINE; + myLineWidth = 0; + myMarker = VISU::Curve::CIRCLE; + myColor.R = 0.0; myColor.G = 0.0; myColor.B = 0.0; +} +/*! + Destructor +*/ +VISU::Curve_i::~Curve_i() +{ +} +/*! + Creates curve object +*/ +VISU::Storable* VISU::Curve_i::Create() +{ + // generate name ... + myName = GenerateName(); + // ... and build the object + return Build( false ); +} +/*! + Builds presentation of curve +*/ +VISU::Storable* VISU::Curve_i::Build( int theRestoring ) +{ + if ( myTable != NULL ) { + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetEntry() ); + int nbRows = myTable->GetNbRows(); + if ( !SO->_is_nil() && myHRow > 0 && myHRow <= nbRows && myVRow > 0 && myVRow <= nbRows ) { + if ( !theRestoring ) { + // look for component + SALOMEDS::SComponent_var SComponent = VISU::FindOrCreateVisuComponent( myStudy ); + // create SObject and set attributes + QString aComment; + aComment.sprintf("myComment=%s;myType=%d",GetComment(),VISU::TCURVE); + string anEntry = CreateAttributes( myStudy, + myTable->GetEntry(), + "", + GetID(), + GetName(), + "", + aComment.latin1(), + true ); + } + return this; + } + } + return NULL; +} + +/*! + Returns CORBA::True if curve refers to valid table data +*/ +CORBA::Boolean VISU::Curve_i::IsValid() +{ + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::AttributeTableOfInteger_var anInt; + SALOMEDS::AttributeTableOfReal_var aReal; + if ( !SO->_is_nil() ) { + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + if ( myHRow > 0 && myHRow <= anInt->GetNbRows() && myVRow > 0 && myVRow <= anInt->GetNbRows() ) { + return true; + } + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + if ( myHRow > 0 && myHRow <= aReal->GetNbRows() && myVRow > 0 && myVRow <= aReal->GetNbRows() ) { + return true; + } + } + } + return false; +} +/*! + Returns hor.axis title +*/ +string VISU::Curve_i::GetHorTitle() +{ + string title; + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::AttributeTableOfInteger_var anInt; + SALOMEDS::AttributeTableOfReal_var aReal; + if ( !SO->_is_nil() ) { + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowTitles = anInt->GetRowTitles(); + if ( rowTitles->length() > 0 && myHRow > 0 && myHRow <= anInt->GetNbRows() ) { + title = strdup( rowTitles[ myHRow-1 ] ); + } + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowTitles = aReal->GetRowTitles(); + if ( rowTitles->length() > 0 && myHRow > 0 && myHRow <= aReal->GetNbRows() ) { + title = strdup( rowTitles[ myHRow-1 ] ); + } + } + } + return title; +} +/*! + Returns ver.axis title +*/ +string VISU::Curve_i::GetVerTitle() +{ + string title; + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::AttributeTableOfInteger_var anInt; + SALOMEDS::AttributeTableOfReal_var aReal; + if ( !SO->_is_nil() ) { + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowTitles = anInt->GetRowTitles(); + if ( rowTitles->length() > 0 && myVRow > 0 && myVRow <= anInt->GetNbRows() ) + title = strdup( rowTitles[ myVRow-1 ] ); + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowTitles = aReal->GetRowTitles(); + if ( rowTitles->length() > 0 && myVRow > 0 && myVRow <= aReal->GetNbRows() ) + title = strdup( rowTitles[ myVRow-1 ] ); + } + } + return title; +} +/*! + Returns hor.axis units +*/ +string VISU::Curve_i::GetHorUnits() +{ + string units; + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::AttributeTableOfInteger_var anInt; + SALOMEDS::AttributeTableOfReal_var aReal; + if ( !SO->_is_nil() ) { + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowUnits = anInt->GetRowUnits(); + if ( rowUnits->length() > 0 && myHRow > 0 && myHRow <= anInt->GetNbRows() ) + units = strdup( rowUnits[ myHRow-1 ] ); + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowUnits = aReal->GetRowUnits(); + if ( rowUnits->length() > 0 && myHRow > 0 && myHRow <= aReal->GetNbRows() ) + units = strdup( rowUnits[ myHRow-1 ] ); + } + } + return units; +} +/*! + Returns ver.axis units +*/ +string VISU::Curve_i::GetVerUnits() +{ + string units; + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::AttributeTableOfInteger_var anInt; + SALOMEDS::AttributeTableOfReal_var aReal; + if ( !SO->_is_nil() ) { + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowUnits = anInt->GetRowUnits(); + if ( rowUnits->length() > 0 && myVRow > 0 && myVRow <= anInt->GetNbRows() ) + units = strdup( rowUnits[ myVRow-1] ); + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + SALOMEDS::StringSeq_var rowUnits = aReal->GetRowUnits(); + if ( rowUnits->length() > 0 && myVRow > 0 && myVRow <= aReal->GetNbRows() ) + units = strdup( rowUnits[ myVRow-1 ] ); + } + } + return units; +} +/*! + Gets curve data +*/ +int VISU::Curve_i::GetData( double*& theHorList, double*& theVerList ) +{ + theHorList = 0; theVerList = 0; + // getting table SObject by it's entry + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myTable->GetObjectEntry() ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::AttributeTableOfInteger_var anInt; + SALOMEDS::AttributeTableOfReal_var aReal; + if ( !SO->_is_nil() ) { + if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfInteger" ) ) { + anInt = SALOMEDS::AttributeTableOfInteger::_narrow( anAttr ); + int nbCols = anInt->GetNbColumns() ; + if ( nbCols > 0 && myHRow > 0 && myHRow <= anInt->GetNbRows() && myVRow > 0 && myVRow <= anInt->GetNbRows() ) { + int nbPoints = 0; + for ( int j = 1; j <= nbCols; j++ ) { + if ( anInt->HasValue( myHRow, j ) && anInt->HasValue( myVRow, j ) ) + nbPoints++; + } + if ( nbPoints > 0 ) { + theHorList = new double[ nbPoints ]; + theVerList = new double[ nbPoints ]; + for ( int j = 1; j <= nbCols; j++ ) { + if ( anInt->HasValue( myHRow, j ) && anInt->HasValue( myVRow, j ) ) { + theHorList[j-1] = anInt->GetValue( myHRow, j ); + theVerList[j-1] = anInt->GetValue( myVRow, j ); + } + } + } + return nbPoints; + } + } + else if ( Builder->FindAttribute( SO, anAttr, "AttributeTableOfReal" ) ) { + aReal = SALOMEDS::AttributeTableOfReal::_narrow( anAttr ); + int nbCols = aReal->GetNbColumns() ; + if ( nbCols > 0 && myHRow > 0 && myHRow <= aReal->GetNbRows() && myVRow > 0 && myVRow <= aReal->GetNbRows() ) { + int nbPoints = 0; + for ( int j = 1; j <= nbCols; j++ ) { + if ( aReal->HasValue( myHRow, j ) && aReal->HasValue( myVRow, j ) ) + nbPoints++; + } + if ( nbPoints > 0 ) { + theHorList = new double[ nbPoints ]; + theVerList = new double[ nbPoints ]; + for ( int j = 1; j <= nbCols; j++ ) { + if ( aReal->HasValue( myHRow, j ) && aReal->HasValue( myVRow, j ) ) { + theHorList[j-1] = aReal->GetValue( myHRow, j ); + theVerList[j-1] = aReal->GetValue( myVRow, j ); + } + } + } + return nbPoints; + } + } + } + return 0; +} +/*! + Creates curve Plot2d presentation object +*/ +Plot2d_Curve* VISU::Curve_i::CreatePresentation() +{ + Plot2d_Curve* crv = new Plot2d_Curve(); + crv->setHorTitle( strdup( GetHorTitle().c_str() ) ); + //crv->setVerTitle( strdup( GetVerTitle().c_str() ) ); + crv->setVerTitle( strdup( GetName() ) ); + crv->setHorUnits( strdup( GetHorUnits().c_str() ) ); + crv->setVerUnits( strdup( GetVerUnits().c_str() ) ); + double* xList = 0; + double* yList = 0; + int nbPoints = GetData( xList, yList ); + if ( nbPoints > 0 && xList && yList ) { + crv->setData( xList, yList, nbPoints ); + } + crv->setLine( (Plot2d_Curve::LineType)GetLine(), GetLineWidth() ); + crv->setMarker( (Plot2d_Curve::MarkerType)GetMarker() ); + SALOMEDS::Color color = GetColor(); + crv->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) ); + crv->setAutoAssign( IsAuto() ); + crv->setIO(new SALOME_InteractiveObject(strdup(GetEntry()),"VISU",strdup(GetName()))); + return crv; +} +/*! + Restores curve object from stream +*/ +VISU::Storable* VISU::Curve_i::Restore( const Storable::TRestoringMap& theMap ) + throw( std::logic_error& ) +{ + if(MYDEBUG) MESSAGE(GetComment()); + myName = VISU::Storable::FindValue(theMap,"myName"); + myHRow = VISU::Storable::FindValue(theMap,"myHRow").toInt(); + myVRow = VISU::Storable::FindValue(theMap,"myVRow").toInt(); + myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble(); + myColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble(); + myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble(); + myMarker = ( VISU::Curve::MarkerType )( VISU::Storable::FindValue(theMap,"myMarker").toInt() ); + myLine = ( VISU::Curve::LineType )( VISU::Storable::FindValue(theMap,"myLine").toInt() ); + return Build( true ); +} +/*! + Flushes curve data into stream +*/ +void VISU::Curve_i::ToStream( ostrstream& theStr ) +{ + Storable::DataToStream( theStr, "TableID", GetTableID() ); + Storable::DataToStream( theStr, "myName", myName.c_str() ); + Storable::DataToStream( theStr, "myHRow", myHRow ); + Storable::DataToStream( theStr, "myVRow", myVRow ); + Storable::DataToStream( theStr, "myColor.R", myColor.R ); + Storable::DataToStream( theStr, "myColor.G", myColor.G ); + Storable::DataToStream( theStr, "myColor.B", myColor.B ); + Storable::DataToStream( theStr, "myMarker", myMarker ); + Storable::DataToStream( theStr, "myLine", myLine ); +} +/*! + Gets reference table's entry +*/ +const char* VISU::Curve_i::GetTableID() { + return myTable->GetEntry(); +} +/*! + Called from engine to restore curve from the file +*/ +VISU::Storable* VISU::CurveRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap) +{ + SALOMEDS::Study_var aStudy = theSObject->GetStudy(); + VISU::Table_i* pTable = GetTable( aStudy, theMap ); + if( pTable != NULL ) { + VISU::Curve_i* pResent = new VISU::Curve_i( aStudy, pTable, 0, 0 ); + return pResent->Restore( theMap ); + } + return NULL; +} + +//---------------------------------------------------------------- +// Container Object +//---------------------------------------------------------------- +int VISU::Container_i::myNbPresent = 0; +const string VISU::Container_i::myComment = "CONTAINER"; +/*! + Generate unique name +*/ +const char* VISU::Container_i::GenerateName() +{ + return VISU::GenerateName( "Container", ++myNbPresent ); +} +/*! + Gets comment string +*/ +const char* VISU::Container_i::GetComment() const +{ + return myComment.c_str(); +} +/*! + Constructor +*/ +VISU::Container_i::Container_i( SALOMEDS::Study_ptr theStudy ) + : PrsObject_i( theStudy ) +{ +} +/*! + Destructor +*/ +VISU::Container_i::~Container_i() +{ + myCurves.clear(); +} +/*! + Inserts curve into the container +*/ +void VISU::Container_i::AddCurve( Curve_ptr theCurve ) +{ + if ( myStudy->_is_nil() ) + return; + SALOMEDS::SObject_var mySO = myStudy->FindObjectID( GetEntry() ); + if ( mySO->_is_nil() ) + return; + PortableServer::POA_var aPOA = GetPOA(); + Curve_i* pCurve = dynamic_cast( aPOA->reference_to_servant( theCurve ) ); + if( pCurve ) { + QString entry = pCurve->GetEntry(); + SALOMEDS::SObject_var SO = myStudy->FindObjectID( entry.latin1() ); + if ( !SO->_is_nil() && myCurves.find( entry ) == myCurves.end() ) { + myCurves.append( entry ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::SObject_var newSO = Builder->NewObject( mySO ); + Builder->Addreference( newSO, SO ); + } + } +} +/*! + Removes curve from the container +*/ +void VISU::Container_i::RemoveCurve( Curve_ptr theCurve ) +{ + if ( myStudy->_is_nil() ) + return; + SALOMEDS::SObject_var mySO = myStudy->FindObjectID( GetEntry() ); + if ( mySO->_is_nil() ) + return; + PortableServer::POA_var aPOA = GetPOA(); + Curve_i* pCurve = dynamic_cast( aPOA->reference_to_servant( theCurve ) ); + if( pCurve ) { + QString entry = pCurve->GetEntry(); + if ( myCurves.find( entry ) != myCurves.end() ) { + // found !!! + myCurves.remove( entry ); + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::ChildIterator_var CI = myStudy->NewChildIterator( mySO ); + for ( ; CI->More(); CI->Next() ) { + SALOMEDS::SObject_var childSO = CI->Value(); + SALOMEDS::SObject_var refSO; + if ( childSO->ReferencedObject( refSO ) && !refSO->_is_nil() && entry == QString( refSO->GetID() ) ) { + Builder->RemoveObject( childSO ); + } + } + } + } +} +/*! + Gets number of curves in the container +*/ +CORBA::Long VISU::Container_i::GetNbCurves() +{ + return myCurves.count(); +} +/*! + Clears container +*/ +void VISU::Container_i::Clear() +{ + if ( myStudy->_is_nil() ) + return; + SALOMEDS::SObject_var mySO = myStudy->FindObjectID( GetEntry() ); + if ( mySO->_is_nil() ) + return; + QStringList toDelete; + SALOMEDS::ChildIterator_var CI = myStudy->NewChildIterator( mySO ); + for ( ; CI->More(); CI->Next() ) { + toDelete.append( CI->Value()->GetID() ); + } + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + for ( int i = 0; i < toDelete.count(); i++ ) { + SALOMEDS::SObject_var SO = myStudy->FindObjectID( toDelete[i].latin1() ); + Builder->RemoveObject( SO ); + } + myCurves.clear(); +} +/*! + Creates container object +*/ +VISU::Storable* VISU::Container_i::Create() +{ + // generate name ... + myName = GenerateName(); + // ... and build the object + return Build( false ); +} +/*! + Builds presentation of container +*/ +VISU::Storable* VISU::Container_i::Build( int theRestoring ) +{ + if ( !theRestoring ) { + // looking for component + SALOMEDS::SComponent_var SComponent = VISU::FindOrCreateVisuComponent( myStudy ); + // create SObject and set attributes + QString aComment; + aComment.sprintf("myComment=%s;myType=%d",GetComment(),VISU::TCONTAINER); + string anEntry = CreateAttributes( myStudy, + SComponent->GetID(), + "", + GetID(), + GetName(), + "", + aComment.latin1(), + true ); + } + return this; +} +/*! + Updates presentation of container +*/ +void VISU::Container_i::Update() +{ + if ( myStudy->_is_nil() ) + return; + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::SObject_var mySO = myStudy->FindObjectID( GetEntry() ); + SALOMEDS::GenericAttribute_var anAttr; + if ( !mySO->_is_nil() ) { + QStringList toDelete; + int i; + for ( i = 0; i < myCurves.count(); i++ ) { + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myCurves[i].latin1() ); + if ( !SO->_is_nil() && Builder->FindAttribute( SO, anAttr, "AttributeIOR" ) ) { + // if real Curve Object still exists + SALOMEDS::ChildIterator_var CI = myStudy->NewChildIterator( mySO ); + bool bFound = false; + for ( ; CI->More(); CI->Next() ) { + SALOMEDS::SObject_var childSO = CI->Value(); + SALOMEDS::SObject_var refSO; + if ( childSO->ReferencedObject( refSO ) && !refSO->_is_nil() && myCurves[i] == QString( refSO->GetID() ) ) { + bFound = true; break; + } + } + if (! bFound ) { + // create SObject referenced to real curve object if is not yet added + SALOMEDS::SObject_var newSO = Builder->NewObject( mySO ); + Builder->Addreference( newSO, SO ); + } + } + else { + // real Curve Object doesn't exist (might be removed) + toDelete.append( myCurves[i] ); + } + } + for ( i = 0; i < toDelete.count(); i++ ) { + myCurves.remove( toDelete[i] ); + } + toDelete.clear(); + SALOMEDS::ChildIterator_var CI = myStudy->NewChildIterator( mySO ); + for ( ; CI->More(); CI->Next() ) { + SALOMEDS::SObject_var childSO = CI->Value(); + SALOMEDS::SObject_var refSO; + if ( childSO->ReferencedObject( refSO ) && ( refSO->_is_nil() || !Builder->FindAttribute( refSO, anAttr, "AttributeIOR" ) || + myCurves.find( refSO->GetID() ) == myCurves.end() ) ) { + toDelete.append( childSO->GetID() ); + } + } + for ( i = 0; i < toDelete.count(); i++ ) { + SALOMEDS::ChildIterator_var CI = myStudy->NewChildIterator( mySO ); + for ( ; CI->More(); CI->Next() ) { + SALOMEDS::SObject_var childSO = CI->Value(); + if ( toDelete[i] == CI->Value()->GetID() ) { + Builder->RemoveObject( childSO ); + } + } + } + } +} +/*! + Gets curve from container by index + NB : curves are numbered from 1 +*/ +VISU::Curve_i* VISU::Container_i::GetCurve( CORBA::Long theIndex ) +{ + if ( theIndex > 0 && theIndex <= myCurves.count() ) { + SALOMEDS::StudyBuilder_var Builder = myStudy->NewBuilder(); + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::SObject_var SO = myStudy->FindObjectID( myCurves[ theIndex-1 ].latin1() ); + CORBA::Object_var anObject = VISU::SObjectToObject( SO ); + if( !CORBA::is_nil( anObject ) ) { + // if real Curve Object exists + CORBA::Object_ptr aCurve = VISU::Curve::_narrow( anObject ); + if( !CORBA::is_nil( aCurve ) ) + return dynamic_cast(VISU::GetServant( aCurve ) ); + } + } + return NULL; +} +/*! + Restores container data from the stream +*/ +VISU::Storable* VISU::Container_i::Restore( const Storable::TRestoringMap& theMap ) + throw( std::logic_error& ) +{ + if(MYDEBUG) MESSAGE(GetComment()); + myName = VISU::Storable::FindValue( theMap, "myName" ); + QString val = VISU::Storable::FindValue( theMap, "myCurves" ); + myCurves = QStringList::split( QString( "*" ), val, false ); + return Build( true ); +} +/*! + Flushes container data into the stream +*/ +void VISU::Container_i::ToStream( ostrstream& theStr ) +{ + Storable::DataToStream( theStr, "myName", myName.c_str() ); + Storable::DataToStream( theStr, "myCurves", myCurves.join( QString( "*" ) ) ); +// theStr<<" myName "<GetStudy(); + VISU::Container_i* pResent = new VISU::Container_i( aStudy ); + return pResent->Restore( theMap ); +} + +//------------------------------------------------------------- +// Implementation of reading from file +//------------------------------------------------------------- +typedef vector TValues; + +struct TRow{ + string myTitle; + string myUnit; + TValues myValues; +}; + +typedef vector TRows; + +struct TTable2D{ + string myTitle; + vector myColumnUnits; + vector myColumnTitles; + TRows myRows; + int Check(){ + if(myRows.empty()) return 0; + int iEnd = myRows[0].myValues.size(); + if(iEnd == 0) return 0; + if(myColumnTitles.size() != iEnd) myColumnTitles.resize(iEnd); + if(myColumnUnits.size() != iEnd) myColumnUnits.resize(iEnd); + int jEnd = myRows.size(); + for(int j = 0; j < jEnd; j++) + if(myRows[j].myValues.size() != iEnd) return 0; + return 1; + } + void getColumns(TTable2D& theTable2D) const { + TRows& aRows = theTable2D.myRows; + aRows.clear(); + if(myRows.empty()) return; + int jEnd = myRows.size(); + //Define Titles & Units + theTable2D.myColumnTitles.resize(jEnd); + theTable2D.myColumnUnits.resize(jEnd); + for(int j = 0; j < jEnd; j++){ + theTable2D.myColumnTitles[j] = myRows[j].myTitle; + theTable2D.myColumnUnits[j] = myRows[j].myUnit; + } + //Define Rows + int iEnd = myRows[0].myValues.size(); + for(int i = 0; i < iEnd; i++){ + TRow aNewRow; + aNewRow.myTitle = myColumnTitles[i]; + aNewRow.myUnit = myColumnUnits[i]; + aNewRow.myValues.resize(jEnd); + for(int j = 0; j < jEnd; j++){ + aNewRow.myValues[j] = myRows[j].myValues[i]; + } + aRows.push_back(aNewRow); + } + } +}; + +typedef vector TTableCont; + +int getLine(ifstream& theStmIn, QString& theString){ + char tmp; + ostrstream aStrOut; + while(theStmIn.get(tmp)){ + aStrOut< aRet(aStrOut.str()); + theString = aRet.get(); + return !theStmIn.eof(); +} + +void ImportTables(const char* theFileName, TTableCont& theTableCont){ + ifstream aStmIn; + QFileInfo aFileInfo(theFileName); + if(!aFileInfo.isFile() || !aFileInfo.isReadable() || !aFileInfo.size()) return; + aStmIn.open(theFileName); + QString aTmp; + do{ + //Find beginning of Table + while(getLine(aStmIn,aTmp) && aTmp == "\n"); + cout<<"\n There is new Table2D with Title = "; + TTable2D aTable2D; + while(!aStmIn.eof() && aTmp != "\n"){ + if(aTmp.find("#TITLE:") == 0){ + int aLen = aTmp.find(":") + 1; + aTmp.remove(0,aLen); + QString aTitle = aTmp.stripWhiteSpace(); + aTable2D.myTitle = aTitle; + cout< 0){ + QStringList aStrList = QStringList::split("#TITLE:",aTmp); + QString aTitle = aStrList[1].stripWhiteSpace(); + TRow aRow; + aRow.myTitle = aTitle; + cout<NewBuilder(); + SALOMEDS::SComponent_var theSComponent = VISU::FindOrCreateVisuComponent(theStudy); + SALOMEDS::SObject_var aFileObject = aStudyBuilder->NewObject(theSComponent); + SALOMEDS::GenericAttribute_var anAttr = + aStudyBuilder->FindOrCreateAttribute(aFileObject, "AttributeName"); + SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr); + QFileInfo aFileInfo(theFileName); + aName->SetValue(aFileInfo.fileName().latin1()); + int iEnd = aTableCont.size(); + /* + for(int i = 0, iEnd = aTableCont.size(); i < iEnd; i++){ + const TTable2D& aTable2D = aTableCont[i]; + SALOMEDS::SObject_var aRealObject = aStudyBuilder->NewObject(aFileObject); + anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeName"); + aName = SALOMEDS::AttributeName::_narrow(anAttr); + cout<<"aTable2D.myTitle = "<SetValue(aTable2D.myTitle.c_str()); + else{ + QString aNewName; + aNewName.sprintf("Table:%d",i); + aName->SetValue(aNewName.latin1()); + } + anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeTableOfReal"); + SALOMEDS::AttributeTableOfReal_var aTableOfReal = SALOMEDS::AttributeTableOfReal::_narrow(anAttr); + aTableOfReal->SetTitle(aTable2D.myTitle.c_str()); + const TRows& aRows = aTable2D.myRows; + //aTable2D.getColumns(aRows); + int kEnd = aRows[0].myValues.size(); + aTableOfReal->SetNbColumns(kEnd); + for(int j = 0, jEnd = aRows.size(); j < jEnd; j++){ + cout<<"j = "<length(kEnd); + cout<<"kEnd = "<AddRow(aDoubleSeq.in()); + aTableOfReal->SetRowTitle(j+1,aRow.myTitle.c_str()); + aTableOfReal->SetRowUnit(j+1,aRow.myUnit.c_str()); + } + for(int k = 0; k < kEnd; k++){ + aTableOfReal->SetColumnTitle(k+1,aTable2D.myColumnTitles[k].c_str()); + //aTableOfReal->SetColumnUnit(k+1,aTable2D.myColumnUnits[k].c_str()); + } + } + */ + for(int i = 0, iEnd = aTableCont.size(); i < iEnd; i++){ + const TTable2D& aTable2D = aTableCont[i]; + SALOMEDS::SObject_var aRealObject = aStudyBuilder->NewObject(aFileObject); + anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeName"); + aName = SALOMEDS::AttributeName::_narrow(anAttr); + cout<<"aTable2D.myTitle = "<SetValue(aTable2D.myTitle.c_str()); + else{ + QString aNewName; + aNewName.sprintf("Table:%d",i); + aName->SetValue(aNewName.latin1()); + } + anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeTableOfReal"); + SALOMEDS::AttributeTableOfReal_var aTableOfReal = SALOMEDS::AttributeTableOfReal::_narrow(anAttr); + aTableOfReal->SetTitle(aTable2D.myTitle.c_str()); + TTable2D aNewTable2D; + aTable2D.getColumns(aNewTable2D); + int kEnd = aNewTable2D.myRows[0].myValues.size(); + aTableOfReal->SetNbColumns(kEnd); + for(int j = 0, jEnd = aNewTable2D.myRows.size(); j < jEnd; j++){ + cout<<"j = "<length(kEnd); + cout<<"kEnd = "<AddRow(aDoubleSeq.in()); + aTableOfReal->SetRowTitle(j+1,aNewTable2D.myRows[j].myTitle.c_str()); + aTableOfReal->SetRowUnit(j+1,aNewTable2D.myRows[j].myUnit.c_str()); + } + for(int k = 0; k < kEnd; k++){ + aTableOfReal->SetColumnTitle(k+1,aNewTable2D.myColumnTitles[k].c_str()); + //aTableOfReal->SetColumnUnit(k+1,aTable2D.myColumnUnits[k].c_str()); + } + } + return aFileObject; +} diff --git a/src/VISU_I/VISU_Table_i.hh b/src/VISU_I/VISU_Table_i.hh new file mode 100644 index 00000000..d92547a7 --- /dev/null +++ b/src/VISU_I/VISU_Table_i.hh @@ -0,0 +1,163 @@ +// File: VISU_Table_i.hh +// Created: Thu Feb 13 17:24:49 2003 +// Author: Vadim SANDLER +// + +#ifndef VISU_Table_i_HeaderFile +#define VISU_Table_i_HeaderFile + +#include "VISU_PrsObject_i.hh" +#include +#include "Plot2d_Curve.h" + +namespace VISU{ + //============================================================================== + class Table_i : public virtual POA_VISU::Table, + public virtual PrsObject_i + { + static int myNbPresent; + Table_i(); + Table_i( const Table_i& ); + public: + Table_i( SALOMEDS::Study_ptr theStudy, const char* theObject ); + virtual ~Table_i(); + virtual VISU::VISUType GetType() { return VISU::TTABLE;}; + + virtual void SetTitle( const char* theName ) { myTitle = theName; } + virtual char* GetTitle() { return CORBA::string_dup( myTitle.c_str() ); } + + virtual void SetOrientation( VISU::Table::Orientation theOrientation ) { myOrientation = theOrientation; } + virtual VISU::Table::Orientation GetOrientation() { return myOrientation; } + + virtual CORBA::Long GetNbRows(); + virtual CORBA::Long GetNbColumns(); + + protected: + Storable* Build(int theRestoring); + + protected: + VISU::Table::Orientation myOrientation; + string myTitle; + string myObjectEntry; + + public: + virtual Storable* Create(); + virtual Storable* Restore( const Storable::TRestoringMap& theMap ) + throw(std::logic_error&); + virtual void ToStream( ostrstream& theStr ); + static const string myComment; + virtual const char* GetComment() const; + virtual const char* GenerateName(); + + virtual char* GetObjectEntry() { return CORBA::string_dup( myObjectEntry.c_str() ); } + }; + Storable* TableRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap); + SALOMEDS::SObject_var ImportTables(const char* theFileName, SALOMEDS::Study_ptr theStudy); + + //============================================================================== + class Curve_i : public virtual POA_VISU::Curve, + public virtual PrsObject_i + { + static int myNbPresent; + Curve_i(); + Curve_i( const Curve_i& ); + public: + Curve_i( SALOMEDS::Study_ptr theStudy, Table_i* theTable, CORBA::Long theHRow, CORBA::Long theVRow ); + virtual ~Curve_i(); + virtual VISU::VISUType GetType() { return VISU::TCURVE;}; + + virtual void SetTitle( const char* theName ) { myTitle = theName; myAuto = false; } + virtual char* GetTitle() { return CORBA::string_dup( myTitle.c_str() ); } + + virtual void SetColor( const SALOMEDS::Color& theColor ) { myColor = theColor; myAuto = false; } + virtual SALOMEDS::Color GetColor() { return myColor; } + + virtual void SetMarker( VISU::Curve::MarkerType theType ) { myMarker = theType; myAuto = false; } + virtual VISU::Curve::MarkerType GetMarker() { return myMarker; } + + virtual void SetLine( VISU::Curve::LineType theType, CORBA::Long theWidth ) + { myLine = theType; myLineWidth = theWidth; myAuto = false; } + virtual VISU::Curve::LineType GetLine() { return myLine; } + virtual CORBA::Long GetLineWidth() { return myLineWidth; } + + protected: + Storable* Build(int theRestoring); + + protected: + Table_i* myTable; + int myHRow; + int myVRow; + struct SALOMEDS::Color myColor; + VISU::Curve::MarkerType myMarker; + VISU::Curve::LineType myLine; + int myLineWidth; + string myTitle; + bool myAuto; + + public: + virtual Storable* Create(); + virtual Storable* Restore( const Storable::TRestoringMap& theMap ) + throw(std::logic_error&); + virtual void ToStream( ostrstream& theStr ); + static const string myComment; + virtual const char* GetComment() const; + virtual const char* GenerateName(); + virtual const char* GetTableID(); + + virtual CORBA::Boolean IsAuto() { return myAuto; } + virtual CORBA::Boolean IsValid(); + virtual string GetHorTitle(); + virtual string GetVerTitle(); + virtual string GetHorUnits(); + virtual string GetVerUnits(); + virtual int GetData( double*& theHorList, double*& theVerList ); + + virtual Plot2d_Curve* CreatePresentation(); + }; + Storable* CurveRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap); + + //============================================================================== + class Container_i : public virtual POA_VISU::Container, + public virtual PrsObject_i + { + static int myNbPresent; + Container_i(); + Container_i( const Container_i& ); + public: + Container_i(SALOMEDS::Study_ptr theStudy); + virtual ~Container_i(); + virtual VISU::VISUType GetType() { return VISU::TCONTAINER;}; + + virtual void AddCurve( Curve_ptr theCurve ); + virtual void RemoveCurve( Curve_ptr theCurve ); + + virtual CORBA::Long GetNbCurves(); + virtual void Clear(); + + protected: + Storable* Build(int theRestoring); + + protected: + QStringList myCurves; + + public: + virtual Storable* Create(); + virtual Storable* Restore( const Storable::TRestoringMap& theMap ) + throw(std::logic_error&); + virtual void ToStream( ostrstream& theStr ); + static const string myComment; + virtual const char* GetComment() const; + virtual const char* GenerateName(); + + void Update(); + VISU::Curve_i* GetCurve( CORBA::Long theIndex ); + + }; + Storable* ContainerRestore(SALOMEDS::SObject_ptr theSObject, + const string& thePrefix, const Storable::TRestoringMap& theMap); +} +#endif // (#ifndef VISU_Table_i_HeaderFile) + + diff --git a/src/VISU_I/VISU_TimeAnimation.cxx b/src/VISU_I/VISU_TimeAnimation.cxx new file mode 100644 index 00000000..f475f1a5 --- /dev/null +++ b/src/VISU_I/VISU_TimeAnimation.cxx @@ -0,0 +1,460 @@ +// File : VISU_TimeAnimation.cxx +// Created : 10 / 04 / 2003 +// Author : Vitaly SMETANNIKOV +// Project : SALOME +// Module : VISU_I +// Copyright : Open CASCADE + + +#include "VISU_TimeAnimation.h" +#include "VISU_ScalarBarActor.hxx" + + +//************************************************************************ +VISU_TimeAnimation::VISU_TimeAnimation(SALOMEDS::Study_var theStudy) { + myStudy = theStudy; + myIsActive = false; + myFrame = 0; + mySpeed = 1; + myProportional = false; + myView = 0; + myMaxVal = 0; + myMinVal = 0; +} + + +//************************************************************************ +VISU_TimeAnimation::~VISU_TimeAnimation() { + for (int i = 0; i < getNbFields(); i++) + clearData(myFieldsLst[i]); +} + + +//************************************************************************ +void VISU_TimeAnimation::addField(SALOMEDS::SObject_var theField) { + FieldData aNewData; + aNewData.myField = theField; + aNewData.myNbTimes = 0; + aNewData.myPrs = 0; + aNewData.myActors = 0; + aNewData.myTiming = 0; + aNewData.myPrsType = VISU::TSCALARMAP; + myFieldsLst.append(aNewData); +} + + +//************************************************************************ +void VISU_TimeAnimation::clearData(FieldData& theData) { + if (theData.myTiming) { + free(theData.myTiming); + theData.myTiming = 0; + } + vtkRenderer* aRen = myView->getRenderer(); + if (theData.myActors) { + for (int i = 0; i < theData.myNbTimes; i++) { + if (theData.myActors[i]->HasScalarBar() && (i==0)) + aRen->RemoveActor2D(theData.myActors[i]->getScalarBar()); + aRen->RemoveActor(theData.myActors[i]); + theData.myActors[i]->Delete(); + } + free(theData.myActors); + theData.myActors = 0; + } + if (theData.myPrs) { + for (int i = 0; i < theData.myNbTimes; i++) + theData.myPrs[i]->_remove_ref(); + free(theData.myPrs); + theData.myPrs = 0; + } + theData.myNbTimes = 0; +} + + +//************************************************************************ +void VISU_TimeAnimation::generatePresentations(int theFieldNum) { + FieldData& aData = myFieldsLst[theFieldNum]; + + // Delete previous presentations + clearData(aData); + + VISU::Result_i* pResult = createPresent(aData.myField); + VISU::Storable::TRestoringMap aMap = getMapOfValue(aData.myField); + aData.myNbTimes = VISU::Storable::FindValue(aMap,"myNbTimeStamps").toLong(); + + aData.myPrs = (VISU::ScalarMap_i**) malloc(aData.myNbTimes * sizeof(VISU::ScalarMap_i*)); + aData.myTiming = (double*) malloc(aData.myNbTimes * sizeof(double)); + + SALOMEDS::ChildIterator_var anIter = myStudy->NewChildIterator(aData.myField); + SALOMEDS::SObject_var aTimeStamp; + anIter->Next(); // First is reference on support + long i = 0; + double aMin = 0, aMax = 0; + for(;anIter->More();anIter->Next()) { + if (i == aData.myNbTimes) { + MESSAGE("Found extra timestamps in field"); + return; + } + aTimeStamp = anIter->Value(); + if (aTimeStamp->_is_nil()) continue; + + aData.myTiming[i] = getTimeValue(aTimeStamp); + if (isRangeDefined()) { + if (aData.myTiming[i] < myMinVal) continue; + if (aData.myTiming[i] > myMaxVal) break; + } + + VISU::Storable::TRestoringMap aTimeMap = getMapOfValue(aTimeStamp); + QString aMeshName = VISU::Storable::FindValue(aTimeMap,"myMeshName"); + VISU::Entity anEntity = (VISU::Entity) VISU::Storable::FindValue(aTimeMap,"myEntityId").toInt(); + QString aFieldName = VISU::Storable::FindValue(aTimeMap,"myFieldName"); + double aTimeStampId = VISU::Storable::FindValue(aTimeMap,"myTimeStampId").toDouble(); + + switch (aData.myPrsType) { + case VISU::TSCALARMAP: // ScalarMap + { + VISU::ScalarMap_i* aPresent = new VISU::ScalarMap_i(pResult, false); + aPresent->Create(aMeshName.latin1(), anEntity, + aFieldName.latin1(), aTimeStampId); + //VISU::ScalarMap_var aTmp = aPresent->_this(); + //aPresent->_remove_ref(); + aData.myPrs[i] = aPresent; + } + break; + + case VISU::TISOSURFACE: // Iso Surfaces + { + VISU::IsoSurfaces_i* aPresent = new VISU::IsoSurfaces_i(pResult, false); + aPresent->Create(aMeshName.latin1(), anEntity, + aFieldName.latin1(), aTimeStampId); + //VISU::IsoSurfaces_var aTmp = aPresent->_this(); + //aPresent->_remove_ref(); + aData.myPrs[i] = aPresent; + } + break; + + case VISU::TCUTPLANES: // Cut Planes + { + VISU::CutPlanes_i* aPresent = new VISU::CutPlanes_i(pResult, false); + aPresent->Create(aMeshName.latin1(), anEntity, + aFieldName.latin1(), aTimeStampId); + //VISU::CutPlanes_var aTmp = aPresent->_this(); + //aPresent->_remove_ref(); + aData.myPrs[i] = aPresent; + } + break; + + case VISU::TDEFORMEDSHAPE: // Deformed Shape + { + VISU::DeformedShape_i* aPresent = new VISU::DeformedShape_i(pResult, false); + aPresent->Create(aMeshName.latin1(), anEntity, + aFieldName.latin1(), aTimeStampId); + //VISU::DeformedShape_var aTmp = aPresent->_this(); + //aPresent->_remove_ref(); + aData.myPrs[i] = aPresent; + } + break; + + case VISU::TVECTORS: // Vectors + { + VISU::Vectors_i* aPresent = new VISU::Vectors_i(pResult, false); + aPresent->Create(aMeshName.latin1(), anEntity, + aFieldName.latin1(), aTimeStampId); + //VISU::Vectors_var aTmp = aPresent->_this(); + //aPresent->_remove_ref(); + aData.myPrs[i] = aPresent; + } + break; + + case VISU::TSTREAMLINES: // Stream Lines + { + VISU::StreamLines_i* aPresent = new VISU::StreamLines_i(pResult, false); + aPresent->Create(aMeshName.latin1(), anEntity, + aFieldName.latin1(), aTimeStampId); + //VISU::StreamLines_var aTmp = aPresent->_this(); + //aPresent->_remove_ref(); + aData.myPrs[i] = aPresent; + } + break; + } + if (aData.myPrs[i]->GetMin() < aMin) aMin = aData.myPrs[i]->GetMin(); + if (aData.myPrs[i]->GetMax() > aMax) aMax = aData.myPrs[i]->GetMax(); + i++; + } + aData.myNbTimes = i; + for (i = 0; i < aData.myNbTimes; i++) + aData.myPrs[i]->SetRange(aMin, aMax); +} + + +//************************************************************************ +bool VISU_TimeAnimation::generateFrames() { + if (!myView) { + MESSAGE("Viewer is nod defined for animation"); + return false; + } + clearView(); + vtkRenderer* aRen = myView->getRenderer(); + for (int i = 0; i < getNbFields(); i++) { + FieldData& aData = myFieldsLst[i]; + aData.myActors = (VISU_Actor**) malloc(aData.myNbTimes * sizeof(VISU_Actor*)); + for (long j = 0; j < aData.myNbTimes; j++) { + VISU_Actor* aActor = aData.myPrs[j]->CreateActor(); + if (aActor == NULL) { + for (int k = 0; k < j; k++) { + aData.myActors[k]->Delete(); + } + free(aData.myActors); + aData.myActors = 0; + return false; + } + aRen->AddActor(aActor); + if (j == 0) { + aActor->VisibilityOn(); + if (aActor->HasScalarBar()) { + aRen->AddActor2D(aActor->getScalarBar()); + } + } else + aActor->VisibilityOff(); + aData.myActors[j] = aActor; + } + } + myFrame = 0; + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + myView->Repaint(); + return true; +} + +//************************************************************************ +void VISU_TimeAnimation::clearView() { + if (!myView) { + MESSAGE("Viewer is nod defined for animation"); + return; + } + vtkRenderer* aRen = myView->getRenderer(); + for (int i = 0; i < getNbFields(); i++) { + FieldData& aData = myFieldsLst[i]; + if (aData.myActors) { + for (int i = 0; i < aData.myNbTimes; i++) { + if (aData.myActors[i]->HasScalarBar() && (i==0)) + aRen->RemoveActor2D(aData.myActors[i]->getScalarBar()); + aRen->RemoveActor(aData.myActors[i]); + aData.myActors[i]->Delete(); + } + free(aData.myActors); + aData.myActors = 0; + } + } +} + +//************************************************************************ +void VISU_TimeAnimation::stopAnimation() { + myIsActive = false; +} + +//************************************************************************ +void VISU_TimeAnimation::startAnimation() { + if (!myIsActive) { + myIsActive = true; + QThread::start(); + } +} + +//************************************************************************ +void VISU_TimeAnimation::nextFrame() { + stopAnimation(); + if (myFrame < (myFieldsLst[0].myNbTimes-1)) { + int i; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOff(); + myFrame++; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOn(); + + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + myView->Repaint(); + } +} + +//************************************************************************ +void VISU_TimeAnimation::prevFrame() { + stopAnimation(); + if (myFrame > 0) { + int i; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOff(); + myFrame--; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOn(); + + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + myView->Repaint(); + } +} + +//************************************************************************ +void VISU_TimeAnimation::firstFrame() { + stopAnimation(); + int i; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOff(); + myFrame = 0; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOn(); + + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + myView->Repaint(); +} + +//************************************************************************ +void VISU_TimeAnimation::lastFrame() { + stopAnimation(); + int i; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOff(); + myFrame = myFieldsLst[0].myNbTimes-1; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOn(); + + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + myView->Repaint(); +} + + +//************************************************************************ +void VISU_TimeAnimation::gotoFrame(long theFrame) { + if ((theFrame < 0) || (theFrame > (getNbFrames()-1))) + return; + stopAnimation(); + int i; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOff(); + myFrame = theFrame; + for (i = 0; i < getNbFields(); i++) + myFieldsLst[i].myActors[myFrame]->VisibilityOn(); + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + myView->Repaint(); +} + + +//************************************************************************ +VISU::ScalarMap_i* VISU_TimeAnimation::getPresentation(int theField, long theFrame) { + if ((theField > getNbFields()) || (theField < 0)) + return NULL; + if ((theFrame < 0) || (theFrame > (myFieldsLst[theField].myNbTimes - 1))) + return NULL; + return myFieldsLst[theField].myPrs[theFrame]; +} + + +//************************************************************************ +long VISU_TimeAnimation::getNbFrames() { + return (getNbFields() > 0)? myFieldsLst[0].myNbTimes : 0; +} + + +//************************************************************************ +void VISU_TimeAnimation::run() { + if (!myView) { + MESSAGE("Viewer is nod defined for animation"); + return; + } + + double k=1; + double aOneVal; + bool isDumping = !myDumpPath.isEmpty(); + aOneVal = (myFieldsLst[0].myNbTimes > 2) ? + myFieldsLst[0].myTiming[1] - myFieldsLst[0].myTiming[0] : 1; + + while (true) { + qApp->lock(); + emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]); + for (int i = 0; i < getNbFields(); i++) { + FieldData& aData = myFieldsLst[i]; + if (myFrame > 0) aData.myActors[myFrame-1]->VisibilityOff(); + else aData.myActors[aData.myNbTimes-1]->VisibilityOff(); + + aData.myActors[myFrame]->VisibilityOn(); + } + myView->Repaint(); + if (isDumping) { + QPixmap px = QPixmap::grabWindow(myView->getViewWidget()->winId()); + QString aFile(myDumpPath); + QString aName = QString("%1").arg(myFieldsLst[0].myTiming[myFrame]); + int aPos = -1; + while ((aPos = aName.find(".")) > -1 ) + aName.replace(aPos, 1, "_"); + aFile += aName; + aFile += ".jpeg"; + px.save(aFile, "JPEG"); + } + qApp->unlock(); + + if (!isDumping) { + if (myProportional) { + switch (myFrame) { + case 0: + k=1; + break; + case 1: + if (myFieldsLst[0].myNbTimes > 2) + k = (myFieldsLst[0].myTiming[myFrame+1] - myFieldsLst[0].myTiming[myFrame])/aOneVal; + else + k = 1; + break; + default: + k = (myFrame < (myFieldsLst[0].myNbTimes-1))? + (myFieldsLst[0].myTiming[myFrame+1] - myFieldsLst[0].myTiming[myFrame])/aOneVal : 1; + } + } else + k = 1; + + msleep((int) 1000.*k/mySpeed); + } + if (!myIsActive) QThread::exit(); + + myFrame++; + if (myFrame == myFieldsLst[0].myNbTimes) + myFrame = 0; + } +} + +//************************************************************************ +VISU::Result_i* VISU_TimeAnimation::createPresent(SALOMEDS::SObject_var theField) { + SALOMEDS::SObject_var aSObj = theField->GetFather(); + aSObj = aSObj->GetFather(); + aSObj = aSObj->GetFather(); + CORBA::Object_var anObject = VISU::SObjectToObject(aSObj); + if(CORBA::is_nil(anObject)) return NULL; + return dynamic_cast(VISU::GetServant(anObject)); +} + + +//************************************************************************ +VISU::Storable::TRestoringMap VISU_TimeAnimation::getMapOfValue(SALOMEDS::SObject_var theSObject) { + VISU::Storable::TRestoringMap aMap; + if(!theSObject->_is_nil()){ + SALOMEDS::GenericAttribute_var anAttr; + if (theSObject->FindAttribute(anAttr, "AttributeComment")) { + SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr); + CORBA::String_var aString = aComment->Value(); + QString strIn(aString.in()); + VISU::Storable::StrToMap(strIn,aMap); + } + } + return aMap; +} + +//************************************************************************ +double VISU_TimeAnimation::getTimeValue(SALOMEDS::SObject_var theTimeStamp) { + SALOMEDS::GenericAttribute_var anAttr; + if(theTimeStamp->FindAttribute(anAttr, "AttributeName")) { + SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr); + QString aNameString(aName->Value()); + return aNameString.toDouble(); + } +} + +//************************************************************************ +void VISU_TimeAnimation::setSpeed(int theSpeed) { + mySpeed = (theSpeed<1)? 1 : theSpeed; +} diff --git a/src/VISU_I/VISU_TimeAnimation.h b/src/VISU_I/VISU_TimeAnimation.h new file mode 100644 index 00000000..87f08e6e --- /dev/null +++ b/src/VISU_I/VISU_TimeAnimation.h @@ -0,0 +1,106 @@ +// File : VISU_TimeAnimation.h +// Created : 10 / 04 / 2003 +// Author : Vitaly SMETANNIKOV +// Project : SALOME +// Module : VISU_I +// Copyright : Open CASCADE + +#ifndef VISU_TIMEANIMATION_H +#define VISU_TIMEANIMATION_H + +#include +#include +#include +#include "VISU_Actor.h" +#include "VISU_PrsObject_i.hh" +#include "VTKViewer_ViewFrame.h" + + +struct FieldData +{ + VISU::VISUType myPrsType; + SALOMEDS::SObject_var myField; // field label + long myNbTimes; // number of Timestamps + VISU::ScalarMap_i** myPrs; // Presentations + VISU_Actor** myActors; // Actors + double* myTiming; // time values +}; + + +class VISU_TimeAnimation: public QObject, public QThread +{ + Q_OBJECT + public: + static VISU::Result_i* createPresent(SALOMEDS::SObject_var theField); + static VISU::Storable::TRestoringMap getMapOfValue(SALOMEDS::SObject_var theSObject); + static double getTimeValue(SALOMEDS::SObject_var theTimestamp); + + VISU_TimeAnimation(SALOMEDS::Study_var theStudy); + ~VISU_TimeAnimation(); + + void addField(SALOMEDS::SObject_var theField); + FieldData& getFieldData(int theNum) { return myFieldsLst[theNum]; } + + bool generateFrames(); + void generatePresentations(int theFieldNum); + void setViewer(VTKViewer_ViewFrame* theView) { myView = theView; } + VTKViewer_ViewFrame* getViewer() { return myView; } + void clearView(); + void clearData(FieldData& theData); + + void stopAnimation(); + void startAnimation(); + void nextFrame(); + void prevFrame(); + void firstFrame(); + void lastFrame(); + void gotoFrame(long theFrame); + + int getNbFields() { return myFieldsLst.size(); } + long getNbFrames(); + bool isRunning() { return myIsActive; } + long getCurrentFrame() { return myFrame; } + + VISU::ScalarMap_i* getPresentation(int theField, long theFrame); + + void setPresentationType(int theFieldNum, VISU::VISUType theType) { myFieldsLst[theFieldNum].myPrsType = theType; } + VISU::VISUType getPresentationType(int theFieldNum) { return myFieldsLst[theFieldNum].myPrsType; } + + void setSpeed(int theSpeed); + int getSpeed() { return mySpeed; } + + bool isProportional() { return myProportional; } + + void setAnimationRange(double theMin, double theMax) + { myMaxVal = theMax; myMinVal = theMin; } + + double getMinRange() { return myMinVal; } + double getMaxRange() { return myMaxVal; } + bool isRangeDefined() { return ((myMaxVal!=0) && (myMinVal != 0)); } + + void dumpTo(QString thePath) { myDumpPath = thePath; } + + public slots: + void setProportional(bool theProp) { myProportional = theProp; } + + signals: + void frameChanged(long theNewFrame, double theTime); + + protected: + void run(); + + private: + + QValueList myFieldsLst; + bool myIsActive; + long myFrame; + int mySpeed; + bool myProportional; + SALOMEDS::Study_var myStudy; + + double myMaxVal, myMinVal; + QString myDumpPath; + VTKViewer_ViewFrame* myView; +}; + +#endif //VISU_TIMEANIMATION_H diff --git a/src/VISU_I/VISU_ViewManager_i.cc b/src/VISU_I/VISU_ViewManager_i.cc new file mode 100644 index 00000000..f7d2de23 --- /dev/null +++ b/src/VISU_I/VISU_ViewManager_i.cc @@ -0,0 +1,1147 @@ +using namespace std; +// File: VISU_ViewManager_i.cxx +// Created: Wed Jan 22 17:53:23 2003 +// Author: Alexey PETROV +// + +#include "VISU_ViewManager_i.hh" +#include "VISU_PrsObject_i.hh" +#include "VISU_Table_i.hh" +#include "VISU_ScalarBarActor.hxx" +#include "VISU_Actor.h" + +#include "QAD_Application.h" +#include "QAD_Desktop.h" +#include "QAD_Tools.h" +#include "QAD_Study.h" +#include "QAD_RightFrame.h" +#include "QAD_StudyFrame.h" + +#include "VTKViewer_ViewFrame.h" +#include "SALOMEGUI_TableDlg.h" +#include "Plot2d_CurveContainer.h" +#include "Plot2d_ViewFrame.h" +//#include "SALOMEGUI_SetupCurveDlg.h" +//#include "SALOMEGUI_SetupPlot2dDlg.h" + +#include +#include +#include +#include + +#include +#include + +#ifdef DEBUG +static int MYDEBUG = 1; +#else +static int MYDEBUG = 0; +#endif + +namespace VISU{ + //=========================================================================== + VTKViewer_ViewFrame* GetViewFrame(QAD_StudyFrame* theStudyFrame){ + return dynamic_cast(theStudyFrame->getRightFrame()->getViewFrame()); + } + vtkRenderer* GetRenderer(QAD_StudyFrame* theStudyFrame){ + return GetViewFrame(theStudyFrame)->getRenderer(); + } + vtkCamera* GetCamera(QAD_StudyFrame* theStudyFrame){ + return GetRenderer(theStudyFrame)->GetActiveCamera(); + } + void RepaintView(QAD_StudyFrame* theStudyFrame){ + GetRenderer(theStudyFrame)->ResetCameraClippingRange(); + GetViewFrame(theStudyFrame)->Repaint(); + } + VISU_Actor* UpdateViewer(QAD_StudyFrame* theStudyFrame, int theDisplaing, Prs3d_i* thePrs){ + VTKViewer_ViewFrame* vf = GetViewFrame(theStudyFrame); + if (!vf) return NULL; + if(MYDEBUG) MESSAGE("UpdateViewer - theDisplaing = "<GetMapper(); + if(MYDEBUG) MESSAGE("UpdateViewer - aCurrAddr = "<VisibilityOn(); + if (aResActor->HasScalarBar()) aResActor->getScalarBar()->VisibilityOn(); + }else{ + aResActor->VisibilityOff(); + if (aResActor->HasScalarBar()) aResActor->getScalarBar()->VisibilityOff(); + } + } else { + if(theDisplaing > eDisplay){ + anVISUActor->VisibilityOff(); + if (anVISUActor->HasScalarBar()) anVISUActor->getScalarBar()->VisibilityOff(); + }else{ + anVISUActor->VisibilityOn(); + if (anVISUActor->HasScalarBar()) anVISUActor->getScalarBar()->VisibilityOn(); + } + } + } + } + if (aResActor) { + RepaintView(theStudyFrame); + return aResActor; + } + if(thePrs != NULL && theDisplaing < eErase){ + anVISUActor = thePrs->CreateActor(); + if (anVISUActor ) { + if(MYDEBUG) MESSAGE("UpdateViewer - thePrs->CreateActor() = "<GetMapper()); + vf->AddActor(anVISUActor); + if(anVISUActor->HasScalarBar()){ + if(MYDEBUG) MESSAGE("UpdateViewer - anVISUActor->getScalarBar()"); + aRen->AddActor2D(anVISUActor->getScalarBar()); + } + } else { + MESSAGE ("Null actor is created"); + return NULL; + } + } + RepaintView(theStudyFrame); + return anVISUActor; + } + void UpdatePlot2d(Plot2d_ViewFrame *theView,int theDisplaying, Curve_i* theCurve) { + if(MYDEBUG) MESSAGE("UpdatePlot2d - theDisplaying = "< clist; + theView->getCurves( clist ); + if ( theDisplaying == eEraseAll ) { + for ( int i = 0; i < clist.count(); i++ ) { + if(MYDEBUG) MESSAGE("UpdatePlot2d - erasing all : curve - "<eraseCurve( clist.at( i ) ); + } + } + else if ( theDisplaying == eErase ) { + for ( int i = 0; i < clist.count(); i++ ) { + if ( theCurve && clist.at( i )->hasIO() && !strcmp( clist.at( i )->getIO()->getEntry(), theCurve->GetEntry() ) ) { + if(MYDEBUG) MESSAGE("UpdatePlot2d - erasing : curve - "<eraseCurve( clist.at( i ) ); + } + } + } + else if ( theDisplaying == eDisplay ) { + bool bFound = false; + for ( int i = 0; i < clist.count(); i++ ) { + if ( theCurve && clist.at( i )->hasIO() && !strcmp( clist.at( i )->getIO()->getEntry(), theCurve->GetEntry() ) ) { + if(MYDEBUG) MESSAGE("UpdatePlot2d - displaying : curve - "<setHorTitle( strdup( theCurve->GetHorTitle().c_str() ) ); + clist.at( i )->setVerTitle( strdup( theCurve->GetVerTitle().c_str() ) ); + clist.at( i )->setHorUnits( strdup( theCurve->GetHorUnits().c_str() ) ); + clist.at( i )->setVerUnits( strdup( theCurve->GetVerUnits().c_str() ) ); + /* - DATA NOT UPDATED */ + if ( !clist.at( i )->isAutoAssign() ) { + clist.at( i )->setLine( (Plot2d_Curve::LineType)theCurve->GetLine(), theCurve->GetLineWidth() ); + clist.at( i )->setMarker( (Plot2d_Curve::MarkerType)theCurve->GetMarker() ); + SALOMEDS::Color color = theCurve->GetColor(); + clist.at( i )->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) ); + clist.at( i )->setAutoAssign( theCurve->IsAuto() ); + } + theView->displayCurve( clist.at( i ) ); + bFound = true; + } + } + if ( !bFound ) { + Plot2d_Curve* crv = theCurve->CreatePresentation(); + if(MYDEBUG) MESSAGE("UpdatePlot2d - displaying : curve (new) - "<displayCurve( crv ); + } + } + else if ( theDisplaying == eDisplayOnly ) { + bool bFound = false; + for ( int i = 0; i < clist.count(); i++ ) { + if ( theCurve && clist.at( i )->hasIO() && !strcmp( clist.at( i )->getIO()->getEntry(), theCurve->GetEntry() ) ) { + if(MYDEBUG) MESSAGE("UpdatePlot2d - displaying only : curve - "<setHorTitle( strdup( theCurve->GetHorTitle().c_str() ) ); + clist.at( i )->setVerTitle( strdup( theCurve->GetVerTitle().c_str() ) ); + clist.at( i )->setHorUnits( strdup( theCurve->GetHorUnits().c_str() ) ); + clist.at( i )->setVerUnits( strdup( theCurve->GetVerUnits().c_str() ) ); + /* - DATA NOT UPDATED */ + if ( !clist.at( i )->isAutoAssign() ) { + clist.at( i )->setLine( (Plot2d_Curve::LineType)theCurve->GetLine(), theCurve->GetLineWidth() ); + clist.at( i )->setMarker( (Plot2d_Curve::MarkerType)theCurve->GetMarker() ); + SALOMEDS::Color color = theCurve->GetColor(); + clist.at( i )->setColor( QColor( (int)(color.R*255.), (int)(color.G*255.), (int)(color.B*255.) ) ); + clist.at( i )->setAutoAssign( theCurve->IsAuto() ); + } + theView->displayCurve( clist.at( i ) ); + bFound = true; + } + else { + theView->eraseCurve( clist.at( i ) ); + } + } + if ( !bFound ) { + Plot2d_Curve* crv = theCurve->CreatePresentation(); + if(MYDEBUG) MESSAGE("UpdatePlot2d - displaying only : curve (new) - "<displayCurve( crv ); + } + } + } + //=========================================================================== + ViewManager_i::ViewManager_i(SALOMEDS::Study_ptr theStudy) { + if(MYDEBUG) MESSAGE("ViewManager_i::ViewManager_i"); + Mutex mt(myMutex,qApp); + myStudyDocument = SALOMEDS::Study::_duplicate(theStudy); + /* + CORBA::String_var aName = myStudyDocument->Name(); + if(QAD_Application::getDesktop()->getActiveApp()->isStudyOpened(aName.in())) + QAD_Application::getDesktop()->getActiveApp()->loadStudy(aName.in()); + */ + } + VISU::View3D_ptr ViewManager_i::Create3DView(){ + if(MYDEBUG) MESSAGE("ViewManager_i::Create3DView"); + VISU::View3D_i* pView = new View3D_i(myStudyDocument); + if(pView->Create(1) != NULL) + return VISU::View3D::_duplicate(pView->_this()); + return VISU::View3D::_nil(); + } + VISU::View_ptr ViewManager_i::GetCurrentView(){ + if(MYDEBUG) MESSAGE("ViewManager_i::GetCurrent3DView"); + QAD_Study* Study = QAD_Application::getDesktop()->findStudy( myStudyDocument ); + QAD_StudyFrame* StudyFrame; + if ( Study && ( StudyFrame = Study->getActiveStudyFrame() ) ) { + if ( StudyFrame->getTypeView() == VIEW_VTK ) { + VISU::View3D_i* pView = new View3D_i(myStudyDocument); + if(pView->Create(0) != NULL) + return VISU::View3D::_duplicate(pView->_this()); + } + else if ( StudyFrame->getTypeView() == VIEW_PLOT2D ) { + VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument); + if(pView->Create(0) != NULL) + return VISU::XYPlot::_duplicate(pView->_this()); + } + } + return VISU::View::_nil(); + } + VISU::XYPlot_ptr ViewManager_i::CreateXYPlot(){ + if(MYDEBUG) MESSAGE("ViewManager_i::CreateXYPlot"); + VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument); + if(pView->Create(1) != NULL) + return VISU::XYPlot::_duplicate(pView->_this()); + return VISU::XYPlot::_nil(); + } + VISU::TableView_ptr ViewManager_i::CreateTableView(VISU::Table_ptr theTable){ + if(MYDEBUG) MESSAGE("ViewManager_i::CreateTableView"); + VISU::TableView_i* pView = new TableView_i(myStudyDocument); + if(pView->Create(VISU::Table::_duplicate(theTable)) != NULL) + return VISU::TableView::_duplicate(pView->_this()); + return VISU::TableView::_nil(); + } + void ViewManager_i::Destroy(View_ptr theView){ + if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - "<_is_nil()); + if(theView->_is_nil()) return; + CORBA::Object_var aView = VISU::View::_narrow(theView); + if(!CORBA::is_nil(aView)){ + if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - VISU::View"<<(!CORBA::is_nil(aView))); + VISU::View_i* pView = dynamic_cast(VISU::GetServant(aView)); + if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - dynamic_cast"<Close(); + pView->_remove_ref(); + } + //if(pView) delete pView; + return; + } + } + //=========================================================================== + View_i::View_i(SALOMEDS::Study_ptr theStudy) { + if(MYDEBUG) MESSAGE("View_i::View_i"); + Mutex mt(myMutex,qApp); + CORBA::String_var aName = theStudy->Name(); + myStudy = QAD_Application::getDesktop()->findStudy( theStudy ); + if(MYDEBUG) MESSAGE("View_i::View_i - isStudyOpened = "<getActiveApp()->loadStudy(aName.in()); + } + View_i::~View_i(){ + if(MYDEBUG) MESSAGE("View_i::~View_i"); + } + + void View_i::SetBackground(const SALOMEDS::Color& theColor) {} + SALOMEDS::Color View_i::GetBackground() { return SALOMEDS::Color();} + void View_i::Minimize() {} + void View_i::Restore() {} + void View_i::Maximize() {} + void View_i::EraseAll() {} + void View_i::DisplayAll() {} + void View_i::Erase(PrsObject_ptr thePrsObj) {} + void View_i::Display(PrsObject_ptr thePrsObj) {} + void View_i::DisplayOnly(PrsObject_ptr thePrsObj) {} + void View_i::Update() {} + + CORBA::Boolean View_i::SavePicture(const char* theFileName) { return false; } + + const char* View_i::GetComment() const { return "";} + void View_i::ToStream(ostrstream& theStr) {} + + const char* View_i::GetEntry(){ + SALOMEDS::SObject_var aSObject = myStudy->getStudyDocument()->FindObjectIOR(GetID()); + CORBA::String_var anEntry = aSObject->GetID(); + string aString(anEntry); + if(MYDEBUG) MESSAGE("Result_i::GetEntry - "<newWindow3d("",VIEW_PLOT2D); + else + myStudyFrame = myStudy->getActiveStudyFrame(); + myView = dynamic_cast(myStudyFrame->getRightFrame()->getViewFrame()); + Update(); + return this; + } + void XYPlot_i::Update() { + if(MYDEBUG) MESSAGE("XYPlot_i::Update"); + Mutex mt(myMutex,qApp); + myName = myStudyFrame->title(); + myView->Repaint(); + } + void XYPlot_i::Close(){ + if(MYDEBUG) MESSAGE("XYPlot_i::Close"); + Mutex mt(myMutex,qApp); + myStudyFrame->close(); + } + XYPlot_i::~XYPlot_i() { + if(MYDEBUG) MESSAGE("XYPlot_i::~XYPlot_i"); + Mutex mt(myMutex,qApp); + myStudyFrame->close(); + } + void XYPlot_i::SetTitle(const char* theTitle){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetTitle"); + Mutex mt(myMutex,qApp); + myName = theTitle; + myStudyFrame->setCaption(myName.c_str()); + } + char* XYPlot_i::GetTitle() { + if(MYDEBUG) MESSAGE("XYPlot_i::GetTitle"); + Mutex mt(myMutex,qApp); + myName = myStudyFrame->title(); + return CORBA::string_dup(myName.c_str()); + } + + void XYPlot_i::SetSubTitle(const char* theTitle){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetSubTitle"); + Mutex mt(myMutex,qApp); + myView->setTitle(theTitle); + } + char* XYPlot_i::GetSubTitle() { + if(MYDEBUG) MESSAGE("XYPlot_i::GetSubTitle"); + Mutex mt(myMutex,qApp); + return CORBA::string_dup(myView->getTitle()); + } + + void XYPlot_i::SetCurveType(VISU::XYPlot::CurveType theType){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetCurveType"); + Mutex mt(myMutex,qApp); + myView->setCurveType(theType); + } + VISU::XYPlot::CurveType XYPlot_i::GetCurveType(){ + if(MYDEBUG) MESSAGE("XYPlot_i::GetCurveType"); + Mutex mt(myMutex,qApp); + return (VISU::XYPlot::CurveType)myView->getCurveType(); + } + + void XYPlot_i::SetMarkerSize(CORBA::Long theSize){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetMarkerSize"); + Mutex mt(myMutex,qApp); + myView->setMarkerSize(theSize); + } + CORBA::Long XYPlot_i::GetMarkerSize(){ + if(MYDEBUG) MESSAGE("XYPlot_i::GetMarkerSize"); + Mutex mt(myMutex,qApp); + return myView->getMarkerSize(); + } + + void XYPlot_i::EnableXGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor, + CORBA::Boolean theMinor, CORBA::Long theNumMinor){ + if(MYDEBUG) MESSAGE("XYPlot_i::EnableXGrid"); + Mutex mt(myMutex,qApp); + myView->setXGrid(theMajor,theNumMajor,theMinor,theNumMinor); + } + void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor, + CORBA::Boolean theMinor, CORBA::Long theNumMinor){ + if(MYDEBUG) MESSAGE("XYPlot_i::EnableYGrid"); + Mutex mt(myMutex,qApp); + myView->setYGrid(theMajor,theNumMajor,theMinor,theNumMinor); + } + + void XYPlot_i::SetHorScaling(VISU::Scaling theScaling){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetHorScaling"); + Mutex mt(myMutex,qApp); + if(theScaling == VISU::LOGARITHMIC) + myView->setHorScaleMode(1); + else + myView->setHorScaleMode(0); + } + VISU::Scaling XYPlot_i::GetHorScaling(){ + if(MYDEBUG) MESSAGE("XYPlot_i::GetHorScaling"); + Mutex mt(myMutex,qApp); + return (VISU::Scaling)myView->getHorScaleMode(); + } + + void XYPlot_i::SetVerScaling(VISU::Scaling theScaling){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetVerScaling"); + Mutex mt(myMutex,qApp); + if(theScaling == VISU::LOGARITHMIC) + myView->setVerScaleMode(1); + else + myView->setVerScaleMode(0); + } + VISU::Scaling XYPlot_i::GetVerScaling(){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetVerScaling"); + Mutex mt(myMutex,qApp); + return (VISU::Scaling)myView->getVerScaleMode(); + } + + void XYPlot_i::SetXTitle(const char* theTitle){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetXTitle"); + Mutex mt(myMutex,qApp); + myView->setXTitle(true,theTitle); + } + char* XYPlot_i::GetXTitle() { + if(MYDEBUG) MESSAGE("XYPlot_i::GetXTitle"); + Mutex mt(myMutex,qApp); + return CORBA::string_dup(myView->getXTitle()); + } + + void XYPlot_i::SetYTitle(const char* theTitle){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetYTitle"); + Mutex mt(myMutex,qApp); + myView->setYTitle(true,theTitle); + } + char* XYPlot_i::GetYTitle() { + if(MYDEBUG) MESSAGE("XYPlot_i::GetYTitle"); + Mutex mt(myMutex,qApp); + return CORBA::string_dup(myView->getYTitle()); + } + + void XYPlot_i::ShowLegend(CORBA::Boolean theShowing){ + if(MYDEBUG) MESSAGE("XYPlot_i::ShowLegend"); + Mutex mt(myMutex,qApp); + myView->showLegend(theShowing); + } + + void XYPlot_i::SetBackground(const SALOMEDS::Color& theColor){ + if(MYDEBUG) MESSAGE("XYPlot_i::SetBackground"); + Mutex mt(myMutex,qApp); + QColor aColor(255.0*theColor.R,255.0*theColor.G,255.0*theColor.B); + myView->setBackgroundColor(aColor); + } + SALOMEDS::Color XYPlot_i::GetBackground() { + if(MYDEBUG) MESSAGE("XYPlot_i::GetBackground"); + Mutex mt(myMutex,qApp); + SALOMEDS::Color aColor; + aColor.R = myView->backgroundColor().red()/255.0; + aColor.G = myView->backgroundColor().green()/255.0; + aColor.B = myView->backgroundColor().blue()/255.0; + return aColor; + } + void XYPlot_i::Minimize() { + if(MYDEBUG) MESSAGE("XYPlot_i::Minimize"); + Mutex mt(myMutex,qApp); + myStudyFrame->showMinimized(); + } + void XYPlot_i::Restore() { + if(MYDEBUG) MESSAGE("XYPlot_i::Restore"); + Mutex mt(myMutex,qApp); + myStudyFrame->showNormal(); + } + void XYPlot_i::Maximize() { + if(MYDEBUG) MESSAGE("XYPlot_i::Maximize"); + Mutex mt(myMutex,qApp); + myStudyFrame->showMaximized(); + } + void XYPlot_i::Display(PrsObject_ptr thePrsObj) { + if(MYDEBUG) MESSAGE("View3D_i::Display"); + Mutex mt(myMutex,qApp); + CORBA::Object_var anObj = thePrsObj; + // is it Curve ? + if(Curve_i* aCurve = dynamic_cast(VISU::GetServant(anObj))) { + UpdatePlot2d(myView,eDisplay,aCurve); + } + // is it Container ? + if(Container_i* aContainer = dynamic_cast(VISU::GetServant(anObj))) { + int nbCurves = aContainer->GetNbCurves(); + for ( int i = 1; i <= nbCurves; i++ ) { + VISU::Curve_i* aCurve = aContainer->GetCurve( i ); + if ( aCurve && aCurve->IsValid() ) { + UpdatePlot2d(myView,eDisplay,aCurve); + } + } + myView->Repaint(); + } + // is it Table ? + if(Table_i* aTable = dynamic_cast(VISU::GetServant(anObj))) { + SALOMEDS::SObject_var TableSO = myStudy->getStudyDocument()->FindObjectID( aTable->GetEntry() ); + if ( !TableSO->_is_nil() ) { + SALOMEDS::ChildIterator_var Iter = myStudy->getStudyDocument()->NewChildIterator( TableSO ); + for ( ; Iter->More(); Iter->Next() ) { + CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() ); + if( !CORBA::is_nil( childObject ) ) { + CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject ); + if( !CORBA::is_nil( aCurve ) ) + UpdatePlot2d(myView,eDisplay,dynamic_cast( VISU::GetServant( aCurve ) )); + } + } + myView->Repaint(); + } + } + } + void XYPlot_i::Erase(PrsObject_ptr thePrsObj) { + if(MYDEBUG) MESSAGE("View3D_i::Display"); + Mutex mt(myMutex,qApp); + CORBA::Object_var anObj = thePrsObj; + // is it Curve ? + if(Curve_i* aCurve = dynamic_cast(VISU::GetServant(anObj))) { + UpdatePlot2d(myView,eErase,aCurve); + } + // is it Container ? + if(Container_i* aContainer = dynamic_cast(VISU::GetServant(anObj))) { + int nbCurves = aContainer->GetNbCurves(); + for ( int i = 1; i <= nbCurves; i++ ) { + VISU::Curve_i* aCurve = aContainer->GetCurve( i ); + if ( aCurve && aCurve->IsValid() ) { + UpdatePlot2d(myView,eErase,aCurve); + } + } + myView->Repaint(); + } + // is it Table ? + if(Table_i* aTable = dynamic_cast(VISU::GetServant(anObj))) { + SALOMEDS::SObject_var TableSO = myStudy->getStudyDocument()->FindObjectID( aTable->GetEntry() ); + if ( !TableSO->_is_nil() ) { + SALOMEDS::ChildIterator_var Iter = myStudy->getStudyDocument()->NewChildIterator( TableSO ); + for ( ; Iter->More(); Iter->Next() ) { + CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() ); + if( !CORBA::is_nil( childObject ) ) { + CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject ); + if( !CORBA::is_nil( aCurve ) ) + UpdatePlot2d(myView,eErase,dynamic_cast( VISU::GetServant( aCurve ) )); + } + } + myView->Repaint(); + } + } + } + void XYPlot_i::EraseAll() { + if(MYDEBUG) MESSAGE("XYPlot_i::EraseAll"); + Mutex mt(myMutex,qApp); + myView->EraseAll(); + } + void XYPlot_i::DisplayOnly(PrsObject_ptr thePrsObj) { + if(MYDEBUG) MESSAGE("View3D_i::Display"); + Mutex mt(myMutex,qApp); + CORBA::Object_var anObj = thePrsObj; + // is it Curve ? + if(Curve_i* aCurve = dynamic_cast(VISU::GetServant(anObj))) { + UpdatePlot2d(myView,eDisplayOnly,aCurve); + } + // is it Container ? + if(Container_i* aContainer = dynamic_cast(VISU::GetServant(anObj))) { + int nbCurves = aContainer->GetNbCurves(); + for ( int i = 1; i <= nbCurves; i++ ) { + VISU::Curve_i* aCurve = aContainer->GetCurve( i ); + if ( aCurve && aCurve->IsValid() ) { + UpdatePlot2d(myView,eDisplayOnly,aCurve); + } + } + myView->Repaint(); + } + // is it Table ? + if(Table_i* aTable = dynamic_cast(VISU::GetServant(anObj))) { + SALOMEDS::SObject_var TableSO = myStudy->getStudyDocument()->FindObjectID( aTable->GetEntry() ); + if ( !TableSO->_is_nil() ) { + SALOMEDS::ChildIterator_var Iter = myStudy->getStudyDocument()->NewChildIterator( TableSO ); + for ( ; Iter->More(); Iter->Next() ) { + CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() ); + if( !CORBA::is_nil( childObject ) ) { + CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject ); + if( !CORBA::is_nil( aCurve ) ) + UpdatePlot2d(myView,eDisplayOnly,dynamic_cast( VISU::GetServant( aCurve ) )); + } + } + myView->Repaint(); + } + } + } + void XYPlot_i::FitAll() { + if(MYDEBUG) MESSAGE("XYPlot_i::FitAll"); + Mutex mt(myMutex,qApp); + myView->fitAll(); + } + CORBA::Boolean XYPlot_i::SavePicture(const char* theFileName) { + if(MYDEBUG) MESSAGE("XYPlot_i::SavePicture"); + Mutex mt(myMutex,qApp); + if (!myView->getViewWidget()) + return false; + + QApplication::setOverrideCursor( Qt::waitCursor ); + QPixmap px = QPixmap::grabWindow(myView->getViewWidget()->winId()); + QApplication::restoreOverrideCursor(); + + if (!QString(theFileName).isNull()) { + QApplication::setOverrideCursor( Qt::waitCursor ); + QString fmt = QAD_Tools::getFileExtensionFromPath(theFileName).upper(); + if (fmt.isEmpty()) + fmt = QString("BMP"); // default format + if (fmt == "JPG") + fmt = "JPEG"; + bool bOk = px.save(theFileName, fmt.latin1()); + QApplication::restoreOverrideCursor(); + return bOk; + } + return false; + } + + //=========================================================================== + TableView_i::TableView_i(SALOMEDS::Study_ptr theStudy) : View_i(theStudy) {} + Storable* TableView_i::Create(VISU::Table_var theTable){ + if(MYDEBUG) MESSAGE("TableView_i::Create - "<<(!theTable->_is_nil())); + Mutex mt(myMutex,qApp); + if(!theTable->_is_nil()){ + VISU::Table_i* table = dynamic_cast(VISU::GetServant(theTable.in())); + if(MYDEBUG) MESSAGE("TableView_i::Create - dynamic_cast = "<getStudyDocument()->FindObjectID(table->GetObjectEntry()); + if(!aSObject->_is_nil()) { + myView = new SALOMEGUI_TableDlg(QAD_Application::getDesktop(),aSObject); + myView->show(); + myName = (myView->caption()).latin1(); + return this; + } + } + } + return NULL; + } + void TableView_i::SetTitle(const char* theTitle){ + if(MYDEBUG) MESSAGE("TableView_i::SetTitle"); + Mutex mt(myMutex,qApp); + myName = theTitle; + myView->setCaption(myName.c_str()); + } + char* TableView_i::GetTitle() { + if(MYDEBUG) MESSAGE("TableView_i::GetTitle"); + Mutex mt(myMutex,qApp); + myName = (myView->caption()).latin1(); + return CORBA::string_dup(myName.c_str()); + } + void TableView_i::Close(){ + if(MYDEBUG) MESSAGE("TableView_i::Close"); + Mutex mt(myMutex,qApp); + myView->close(); + } + TableView_i::~TableView_i() { + if(MYDEBUG) MESSAGE("TableView_i::~TableView_i"); + Mutex mt(myMutex,qApp); + Close(); + delete myView; + } + //=========================================================================== + int View3D_i::myNbViewParams = 0; + const string View3D_i::myComment = "VIEW3D"; + const char* View3D_i::GetComment() const { return myComment.c_str();} + const char* View3D_i::GenerateViewParamsName() { + return VISU::GenerateName( "ViewParams", ++myNbViewParams ); + } + + View3D_i::View3D_i(SALOMEDS::Study_ptr theStudy) : View_i(theStudy) { + if(MYDEBUG) MESSAGE("View3D_i::View3D_i"); + } + + Storable* View3D_i::Create(int theNew){ + if(MYDEBUG) MESSAGE("View3D_i::Create"); + Mutex mt(myMutex,qApp); + if(theNew) + myStudyFrame = myStudy->newWindow3d("",VIEW_VTK); + else + myStudyFrame = myStudy->getActiveStudyFrame(); + + VTKViewer_NonIsometricTransform *NITr = GetViewFrame(myStudyFrame)->getNonIsometricTransform(); + myScaleFactor[0] = NITr->GetCoeff(AxisFunction::XAxis); + myScaleFactor[1] = NITr->GetCoeff(AxisFunction::YAxis); + myScaleFactor[2] = NITr->GetCoeff(AxisFunction::ZAxis); + + return Build(false); + } + + Storable* View3D_i::Build(int theRestoring){ + if(MYDEBUG) MESSAGE("View3D_i::Build"); + if(theRestoring){ + myStudyFrame->setTitle(myName.c_str()); + SetBackground(myColor); + SetPointOfView(myPosition); + SetViewUp(myViewUp); + SetFocalPoint(myFocalPnt); + SetParallelScale(myParallelScale); + ScaleView(VISU::View3D::XAxis,myScaleFactor[0]); + ScaleView(VISU::View3D::YAxis,myScaleFactor[1]); + ScaleView(VISU::View3D::ZAxis,myScaleFactor[2]); + RepaintView(myStudyFrame); + }else{ + Update(); + /* + SALOMEDS::SComponent_var aSComponent = FindOrCreateVisuComponent(myStudyDocument); + CORBA::String_var aSComponentEntry = aSComponent->GetID(), anIOR(GetID()); + string anEntry = CreateAttributes(myStudyDocument,aSComponentEntry,"",anIOR,myName.c_str(),"",GetComment()); + */ + } + return this; + } + + void View3D_i::Update(){ + if(MYDEBUG) MESSAGE("View3D_i::Update"); + Mutex mt(myMutex,qApp); + myName = myStudyFrame->title(); + myColor = GetBackground(); + GetCamera(myStudyFrame)->GetPosition(myPosition); + GetCamera(myStudyFrame)->GetViewUp(myViewUp); + GetCamera(myStudyFrame)->GetFocalPoint(myFocalPnt); + myParallelScale = GetCamera(myStudyFrame)->GetParallelScale(); + RepaintView(myStudyFrame); + + VTKViewer_NonIsometricTransform *NITr = GetViewFrame(myStudyFrame)->getNonIsometricTransform(); + myScaleFactor[0] = NITr->GetCoeff(AxisFunction::XAxis); + myScaleFactor[1] = NITr->GetCoeff(AxisFunction::YAxis); + myScaleFactor[2] = NITr->GetCoeff(AxisFunction::ZAxis); + } + + CORBA::Boolean View3D_i::SavePicture(const char* theFileName) { + if(MYDEBUG) MESSAGE("View3D_i::SavePicture"); + Mutex mt(myMutex,qApp); + if (!myStudyFrame->getRightFrame()->getViewFrame()->getViewWidget()) + return false; + + QApplication::setOverrideCursor( Qt::waitCursor ); + QPixmap px = QPixmap::grabWindow(myStudyFrame->getRightFrame()->getViewFrame()->getViewWidget()->winId()); + QApplication::restoreOverrideCursor(); + + if (!QString(theFileName).isNull()) { + QApplication::setOverrideCursor( Qt::waitCursor ); + QString fmt = QAD_Tools::getFileExtensionFromPath(theFileName).upper(); + if (fmt.isEmpty()) + fmt = QString("BMP"); // default format + if (fmt == "JPG") + fmt = "JPEG"; + bool bOk = px.save(theFileName, fmt.latin1()); + QApplication::restoreOverrideCursor(); + return bOk; + } + return false; + } + + CORBA::Boolean View3D_i::SaveViewParams(const char* theName){ + if(MYDEBUG) MESSAGE("View3D_i::SaveViewPoint"); + Mutex mt(myMutex,qApp); + if ( theName ) { + SALOMEDS::Study::ListOfSObject_var aList = + myStudy->getStudyDocument()->FindObjectByName(theName,"VISU"); + SALOMEDS::GenericAttribute_var anAttr; + int iEnd = aList->length(); + for(int i = 0; i < iEnd; i++){ + SALOMEDS::SObject_var anObj = aList[i]; + CORBA::String_var aString = anObj->GetID(); + string anEntry(aString); + if(MYDEBUG) MESSAGE("View3D_i::SaveViewPoint - anEntry = "<FindAttribute(anAttr, "AttributeComment")){ + SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr); + aString = aCmnt->Value(); + string aComm(aString); + if(MYDEBUG) MESSAGE("View3D_i::SaveViewPoint - aComm = "<= 0){ + aCmnt->SetValue(ToString().c_str()); + return 1; + } + } + } + } + QString newName; + if ( theName ) + newName = QString( theName ); + else + newName = QString( GenerateViewParamsName() ); + SALOMEDS::SComponent_var aSComponent = + FindOrCreateVisuComponent(myStudy->getStudyDocument()); + CORBA::String_var aSComponentEntry = aSComponent->GetID(), anIOR(GetID()); + string anEntry = CreateAttributes(myStudy->getStudyDocument(),aSComponentEntry,"","",newName.latin1(),"",ToString().c_str()); + return 1; + } + + CORBA::Boolean View3D_i::RestoreViewParams(const char* theName){ + if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - "<getStudyDocument()->FindObjectByName(theName,"VISU"); + SALOMEDS::GenericAttribute_var anAttr; + int iEnd = aList->length(); + if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - iEnd = "<GetID(); + string anEntry(aString); + if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - anEntry = "<FindAttribute(anAttr, "AttributeComment")){ + SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr); + aString = aCmnt->Value(); + QString strIn(aString); + Storable::TRestoringMap aMap; + Storable::StrToMap(strIn,aMap); + if ( Storable::FindValue( aMap,"myComment").compare( View3D_i::myComment.c_str() ) >= 0 ) { + if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - aComm = "<Restore(theMap); + }catch(std::logic_error& exc){ + MESSAGE("Follow exception was accured :\n"<close(); + } + + View3D_i::~View3D_i() { + if(MYDEBUG) MESSAGE("View3D_i::~View3D_i"); + Mutex mt(myMutex,qApp); + myStudyFrame->close(); + } + + //-------------------- View interface -------------------- + void View3D_i::SetTitle(const char* theTitle){ + if(MYDEBUG) MESSAGE("View3D_i::SetTitle"); + Mutex mt(myMutex,qApp); + myName = theTitle; + /* + SALOMEDS::SObject_var aSObject = + myStudy->getStudyDocument()->FindObjectID(GetEntry()); + SALOMEDS::GenericAttribute_var anAttr; + if(aSObject->FindAttribute(anAttr,"AttributeName")){ + SALOMEDS::AttributeName_ptr aName = SALOMEDS::AttributeName::_narrow(anAttr); + aName->SetValue(myName.c_str()); + } + */ + myStudyFrame->setTitle(myName.c_str()); + } + char* View3D_i::GetTitle() { + if(MYDEBUG) MESSAGE("View3D_i::GetTitle"); + Mutex mt(myMutex,qApp); + myName = myStudyFrame->title(); + return CORBA::string_dup(myName.c_str()); + } + void View3D_i::SetBackground(const SALOMEDS::Color& theColor) { + if(MYDEBUG) MESSAGE("View3D_i::SetBackground"); + Mutex mt(myMutex,qApp); + myColor.R = theColor.R; + myColor.G = theColor.G; + myColor.B = theColor.B; + QColor aColor(255.0*myColor.R,255.0*myColor.G,255.0*myColor.B); + GetViewFrame(myStudyFrame)->setBackgroundColor(aColor); + } + SALOMEDS::Color View3D_i::GetBackground() { + if(MYDEBUG) MESSAGE("View3D_i::GetBackground"); + Mutex mt(myMutex,qApp); + float backint[3]; + GetRenderer(myStudyFrame)->GetBackground(backint); + myColor.R = backint[0]; + myColor.G = backint[1]; + myColor.B = backint[2]; + return myColor; + } + void View3D_i::Minimize() { + if(MYDEBUG) MESSAGE("View3D_i::Minimize"); + Mutex mt(myMutex,qApp); + myStudyFrame->showMinimized(); + } + void View3D_i::Restore() { + if(MYDEBUG) MESSAGE("View3D_i::Restore"); + Mutex mt(myMutex,qApp); + myStudyFrame->showNormal(); + } + void View3D_i::Maximize() { + if(MYDEBUG) MESSAGE("View3D_i::Maximize"); + Mutex mt(myMutex,qApp); + myStudyFrame->showMaximized(); + } + //=========================================================================== + void View3D_i::EraseAll() { + if(MYDEBUG) MESSAGE("View3D_i::EraseAll"); + Mutex mt(myMutex,qApp); + UpdateViewer(myStudyFrame,eEraseAll); + } + void View3D_i::DisplayAll() { + if(MYDEBUG) MESSAGE("View3D_i::DisplayAll"); + Mutex mt(myMutex,qApp); + UpdateViewer(myStudyFrame,eDisplayAll); + } + void View3D_i::Erase(PrsObject_ptr thePrsObj) { + if(MYDEBUG) MESSAGE("View3D_i::Erase"); + Mutex mt(myMutex,qApp); + CORBA::Object_var anObj = thePrsObj; + if(Prs3d_i* aPrs = dynamic_cast(VISU::GetServant(anObj))) + UpdateViewer(myStudyFrame,eErase,aPrs); + } + void View3D_i::Display(PrsObject_ptr thePrsObj) { + if(MYDEBUG) MESSAGE("View3D_i::Display"); + Mutex mt(myMutex,qApp); + CORBA::Object_var anObj = thePrsObj; + if(Prs3d_i* aPrs = dynamic_cast(VISU::GetServant(anObj))) + UpdateViewer(myStudyFrame,eDisplay,aPrs); + } + void View3D_i::DisplayOnly(PrsObject_ptr thePrsObj) { + if(MYDEBUG) MESSAGE("View3D_i::DisplayOnly"); + Mutex mt(myMutex,qApp); + CORBA::Object_var anObj = thePrsObj; + if(Prs3d_i* aPrs = dynamic_cast(VISU::GetServant(anObj))) + UpdateViewer(myStudyFrame,eDisplayOnly,aPrs); + } + + //-------------------- View3D interface -------------------- + void View3D_i::FitAll() { + if(MYDEBUG) MESSAGE("View3D_i::FitAll"); + Mutex mt(myMutex,qApp); + GetViewFrame(myStudyFrame)->onViewFitAll(); + Update(); + } + void View3D_i::SetView(VISU::View3D::ViewType theType) { + if(MYDEBUG) MESSAGE("View3D_i::SetView"); + Mutex mt(myMutex,qApp); + switch(theType){ + case VISU::View3D::FRONT : GetViewFrame(myStudyFrame)->onViewFront(); break; + case VISU::View3D::BACK : GetViewFrame(myStudyFrame)->onViewBack(); break; + case VISU::View3D::LEFT : GetViewFrame(myStudyFrame)->onViewLeft(); break; + case VISU::View3D::RIGHT : GetViewFrame(myStudyFrame)->onViewRight(); break; + case VISU::View3D::TOP : GetViewFrame(myStudyFrame)->onViewTop(); break; + case VISU::View3D::BOTTOM : GetViewFrame(myStudyFrame)->onViewBottom(); break; + } + Update(); + } + + void View3D_i::SetPointOfView(const VISU::View3D::XYZ theCoord) { + if(MYDEBUG) MESSAGE("View3D_i::SetPointOfView"); + Mutex mt(myMutex,qApp); + VISU::View3D::XYZ_copy(myPosition,theCoord); + GetCamera(myStudyFrame)->SetPosition(myPosition); + } + VISU::View3D::XYZ_slice* View3D_i::GetPointOfView() { + if(MYDEBUG) MESSAGE("View3D_i::GetPointOfView"); + Mutex mt(myMutex,qApp); + GetCamera(myStudyFrame)->GetPosition(myPosition); + return VISU::View3D::XYZ_dup(myPosition); + } + + void View3D_i::SetViewUp(const VISU::View3D::XYZ theDir) { + if(MYDEBUG) MESSAGE("View3D_i::SetViewUp"); + Mutex mt(myMutex,qApp); + VISU::View3D::XYZ_copy(myViewUp,theDir); + GetCamera(myStudyFrame)->SetViewUp(myViewUp); + } + VISU::View3D::XYZ_slice* View3D_i::GetViewUp() { + if(MYDEBUG) MESSAGE("View3D_i::GetViewUp"); + Mutex mt(myMutex,qApp); + GetCamera(myStudyFrame)->GetViewUp(myViewUp); + return VISU::View3D::XYZ_dup(myViewUp); + } + + void View3D_i::SetFocalPoint(const VISU::View3D::XYZ theCoord) { + if(MYDEBUG) MESSAGE("View3D_i::SetFocalPoint"); + Mutex mt(myMutex,qApp); + VISU::View3D::XYZ_copy(myFocalPnt,theCoord); + GetCamera(myStudyFrame)->SetFocalPoint(myFocalPnt); + } + VISU::View3D::XYZ_slice* View3D_i::GetFocalPoint() { + if(MYDEBUG) MESSAGE("View3D_i::GetFocalPoint"); + Mutex mt(myMutex,qApp); + GetCamera(myStudyFrame)->GetFocalPoint(myFocalPnt); + return VISU::View3D::XYZ_dup(myFocalPnt); + } + + void View3D_i::SetParallelScale(CORBA::Double theScale) { + if(MYDEBUG) MESSAGE("View3D_i::SetParallelScale"); + Mutex mt(myMutex,qApp); + myParallelScale = theScale; + GetCamera(myStudyFrame)->SetParallelScale(myParallelScale); + } + CORBA::Double View3D_i::GetParallelScale() { + if(MYDEBUG) MESSAGE("View3D_i::GetParallelScale"); + Mutex mt(myMutex,qApp); + return myParallelScale = GetCamera(myStudyFrame)->GetParallelScale(); + } + + void View3D_i::ScaleView(VISU::View3D::Axis theAxis, CORBA::Double theParam) { + Mutex mt(myMutex,qApp); + bool changed = false; + VTKViewer_ViewFrame* vf = GetViewFrame(myStudyFrame); + VTKViewer_NonIsometricTransform *aTransform = vf->getNonIsometricTransform(); + static double EPS =1.0E-3; + VTKViewer_NonIsometricTransform::Function + aFunction = (fabs(theParam - 1.0) < EPS? + VTKViewer_NonIsometricTransform::Identical: + VTKViewer_NonIsometricTransform::Linear); + AxisFunction::Axis anAxis; + if(theAxis == VISU::View3D::XAxis){ + myScaleFactor[0] = theParam; + anAxis = AxisFunction::XAxis; + }else if(theAxis == VISU::View3D::YAxis){ + myScaleFactor[1] = theParam; + anAxis = AxisFunction::YAxis; + }else{ + myScaleFactor[2] = theParam; + anAxis = AxisFunction::ZAxis; + } + if(MYDEBUG) + MESSAGE("View3D_i::ScaleView - theParam = "<GetPolyDataMapper (); + else + mapper = vtkPolyDataMapper::SafeDownCast( initialMapper ); + if(mapper){ + //create transformation + if(MYDEBUG) MESSAGE("View3D_i::ScaleView - theActors->GetNextActor()"); + aTransform->SetFunction(anAxis,aFunction,theParam); + //create Filter + vtkTransformPolyDataFilter *aTransformFilter = vtkTransformPolyDataFilter::New(); + aTransformFilter->SetInput ( mapper->GetInput() ); + aTransformFilter->SetTransform (aTransform); + + //create new mapper + vtkMapper* aIMapper = pSA->GetInitialMapper(); + if ((aIMapper != NULL) && aIMapper->IsA("vtkDataSetMapper")) { + vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); + aMapper->SetInput (aTransformFilter->GetOutput()); + aMapper->ShallowCopy ( actor->GetMapper()); + actor->SetMapper (aMapper); + aMapper->Delete(); + } else { + vtkPolyDataMapper *aMapper = vtkPolyDataMapper::New(); + aMapper->SetInput (aTransformFilter->GetOutput()); + aMapper->ShallowCopy ( actor->GetMapper()); + actor->SetMapper (aMapper); + aMapper->Delete(); + } + aTransformFilter->Delete(); + changed = true; + } + } + actor = theActors->GetNextActor(); + } + if(MYDEBUG) + MESSAGE("View3D_i::ScaleView - myScaleFactor = "<< + myScaleFactor[0]<<"; "< + + +#ifndef VISU_ViewManager_i_HeaderFile +#define VISU_ViewManager_i_HeaderFile + +#include "VISUConfig.hh" +class QAD_Study; +class QAD_StudyFrame; +class VTKViewer_ViewFrame; +class Plot2d_ViewFrame; +class SALOMEGUI_TableDlg; +class VISU_Actor; +class vtkRenderer; +class vtkCamera; + +namespace VISU{ + class Prs3d_i; + class ViewManager_i : public virtual POA_VISU::ViewManager, + public virtual Base_i + { + public: + ViewManager_i(SALOMEDS::Study_ptr theStudy); + virtual ~ViewManager_i() {}; + virtual VISU::VISUType GetType() { return VISU::TVIEWMANAGER;}; + + virtual View3D_ptr Create3DView(); + virtual View_ptr GetCurrentView(); + virtual TableView_ptr CreateTableView(VISU::Table_ptr theTable); + virtual XYPlot_ptr CreateXYPlot(); + virtual void Destroy(View_ptr theView); + + protected: + SALOMEDS::Study_var myStudyDocument; + }; + + //=========================================================================== + class View_i : public virtual POA_VISU::View, + public virtual Storable + { + protected: + QAD_Study* myStudy; + string myName; + public: + View_i(SALOMEDS::Study_ptr theStudy); + virtual ~View_i(); + virtual void SetBackground(const SALOMEDS::Color& theColor); + virtual SALOMEDS::Color GetBackground(); + virtual void Minimize(); + virtual void Restore(); + virtual void Maximize(); + virtual void EraseAll(); + virtual void DisplayAll(); + virtual void Erase(PrsObject_ptr thePrsObj); + virtual void Display(PrsObject_ptr thePrsObj); + virtual void DisplayOnly(PrsObject_ptr thePrsObj); + virtual void Update(); + + virtual CORBA::Boolean SavePicture(const char* theFileName); + + virtual void Close() = 0; + virtual void ToStream(ostrstream& theStr); + virtual const char* GetComment() const; + public: + virtual const char* View_i::GetEntry(); + }; + + //=========================================================================== + class XYPlot_i : public virtual POA_VISU::XYPlot, + public virtual View_i + { + public: + XYPlot_i(SALOMEDS::Study_ptr theStudy); + virtual ~XYPlot_i(); + virtual VISU::VISUType GetType() { return VISU::TXYPLOT;}; + + virtual void SetTitle(const char* theTitle); + virtual char* GetTitle(); + + virtual void SetSubTitle(const char* theTitle); + virtual char* GetSubTitle(); + + virtual void SetCurveType(VISU::XYPlot::CurveType theType); + virtual VISU::XYPlot::CurveType GetCurveType(); + + virtual void SetMarkerSize(CORBA::Long theSize); + virtual CORBA::Long GetMarkerSize(); + + virtual void EnableXGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor, + CORBA::Boolean theMinor, CORBA::Long theNumMinor); + virtual void EnableYGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor, + CORBA::Boolean theMinor, CORBA::Long theNumMinor); + + virtual void SetHorScaling(VISU::Scaling theScaling); + virtual VISU::Scaling GetHorScaling(); + virtual void SetVerScaling(VISU::Scaling theScaling); + virtual VISU::Scaling GetVerScaling(); + + virtual void SetXTitle(const char* theTitle); + virtual char* GetXTitle(); + + virtual void SetYTitle(const char* theTitle); + virtual char* GetYTitle(); + + virtual void ShowLegend(CORBA::Boolean theShowing); + + virtual void SetBackground(const SALOMEDS::Color& theColor); + virtual SALOMEDS::Color GetBackground(); + virtual void Minimize(); + virtual void Restore(); + virtual void Maximize(); + virtual void EraseAll(); + virtual void Erase(PrsObject_ptr thePrsObj); + virtual void Display(PrsObject_ptr thePrsObj); + virtual void DisplayOnly(PrsObject_ptr thePrsObj); + virtual void Update(); + + virtual CORBA::Boolean SavePicture(const char* theFileName); + + virtual void FitAll(); + + virtual void Close(); + protected: + QAD_StudyFrame* myStudyFrame; + Plot2d_ViewFrame* myView; + public: + virtual Storable* Create(int theNew); + }; + + //=========================================================================== + class TableView_i : public virtual POA_VISU::TableView, + public virtual View_i + { + public: + TableView_i(SALOMEDS::Study_ptr theStudy); + virtual ~TableView_i(); + virtual VISU::VISUType GetType() { return VISU::TTABLEVIEW;}; + + virtual void SetTitle(const char* theTitle); + virtual char* GetTitle(); + + virtual void Close(); + protected: + SALOMEGUI_TableDlg* myView; + public: + virtual Storable* Create(VISU::Table_var theTable); + }; + + //=========================================================================== + class View3D_i : public virtual POA_VISU::View3D, + public virtual View_i + { + public: + View3D_i(SALOMEDS::Study_ptr theStudy); + virtual ~View3D_i(); + virtual VISU::VISUType GetType() { return VISU::TVIEW3D;}; + + //View interface + virtual void SetTitle(const char* theTitle); + virtual char* GetTitle(); + virtual void SetBackground(const SALOMEDS::Color& theColor); + virtual SALOMEDS::Color GetBackground(); + virtual void Minimize(); + virtual void Restore(); + virtual void Maximize(); + virtual void EraseAll(); + virtual void DisplayAll(); + virtual void Erase(PrsObject_ptr thePrsObj); + virtual void Display(PrsObject_ptr thePrsObj); + virtual void DisplayOnly(PrsObject_ptr thePrsObj); + virtual void Update(); + + virtual CORBA::Boolean SavePicture(const char* theFileName); + + //View3D interface + virtual void FitAll(); + virtual void SetView(VISU::View3D::ViewType theType); + + virtual void SetPointOfView(const VISU::View3D::XYZ theCoord); + virtual VISU::View3D::XYZ_slice* GetPointOfView(); + + virtual void SetViewUp(const VISU::View3D::XYZ theDir); + virtual VISU::View3D::XYZ_slice* GetViewUp(); + + virtual void SetFocalPoint(const VISU::View3D::XYZ theCoord); + virtual VISU::View3D::XYZ_slice* GetFocalPoint(); + + virtual void SetParallelScale(CORBA::Double theScale); + virtual CORBA::Double GetParallelScale(); + + virtual void ScaleView(VISU::View3D::Axis theAxis, CORBA::Double theParam); + virtual void RemoveScale(); + + virtual const char* GenerateViewParamsName(); + virtual CORBA::Boolean SaveViewParams(const char* theName); + virtual CORBA::Boolean RestoreViewParams(const char* theName); + + virtual void Close(); + protected: + QAD_StudyFrame* myStudyFrame; + SALOMEDS::Color myColor; + CORBA::Double myPosition[3], myFocalPnt[3], myViewUp[3], myParallelScale, myScaleFactor[3]; + + Storable* Build(int theRestoring); + static int myNbViewParams; + + public: + virtual Storable* Create(int theNew); + virtual Storable* Restore(const Storable::TRestoringMap& theMap) throw(std::logic_error&); + virtual void ToStream(ostrstream& theStr); + virtual const char* GetComment() const; + static const string myComment; + }; + Storable* View3DRestore(SALOMEDS::SComponent_var& theSComponent, SALOMEDS::Study_var& theStudy, + const char* thePrefix, const Storable::TRestoringMap& theMap); + + VTKViewer_ViewFrame* GetViewFrame(QAD_StudyFrame* theStudyFrame); + vtkRenderer* GetRenderer(QAD_StudyFrame* theStudyFrame); + vtkCamera* GetCamera(QAD_StudyFrame* theStudyFrame); + void RepaintView(QAD_StudyFrame* theStudyFrame); + + enum Displaing {eDisplayAll, eDisplay, eDisplayOnly, eErase, eEraseAll}; + VISU_Actor* UpdateViewer(QAD_StudyFrame* theStudyFrame, int theDisplaing, Prs3d_i* thePrs = NULL); +} + +#endif