From db09f96ca8438dbbfe598a79507a7104c0223803 Mon Sep 17 00:00:00 2001
From: nge <nge>
Date: Fri, 29 May 2009 14:34:14 +0000
Subject: [PATCH] Size Map feature integration. Dev doc added.

---
 Makefile.am                                   |  13 +-
 clean_configure                               |   3 +-
 configure.ac                                  |   7 +
 doc/Makefile.am                               |  34 +
 doc/salome/Makefile.am                        |  40 +
 doc/salome/gui/Makefile.am                    |  44 ++
 doc/salome/gui/doxyfile.in                    |  65 ++
 doc/salome/gui/input/empty                    |   0
 doc/salome/gui/static/footer.html             |  10 +
 doc/salome/gui/static/header.html             |  12 +
 doc/salome/tui/Makefile.am                    |  44 ++
 doc/salome/tui/doxyfile.in                    | 263 +++++++
 doc/salome/tui/images/Application-About.png   | Bin 0 -> 19226 bytes
 doc/salome/tui/images/application.gif         | Bin 0 -> 2602 bytes
 doc/salome/tui/images/html_comments.gif       | Bin 0 -> 156 bytes
 doc/salome/tui/images/logocorp.gif            | Bin 0 -> 1792 bytes
 doc/salome/tui/static/doxygen.css             | 152 ++++
 doc/salome/tui/static/footer.html             |   5 +
 doc/salome/tui/static/myheader.html           |  13 +
 idl/BLSURFPlugin_Algorithm.idl                |  45 +-
 src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx      | 527 ++++++++++++-
 src/BLSURFPlugin/BLSURFPlugin_BLSURF.hxx      |   9 +-
 src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx  | 193 ++++-
 src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx  |  28 +
 .../BLSURFPlugin_Hypothesis_i.cxx             | 269 +++++++
 .../BLSURFPlugin_Hypothesis_i.hxx             |  42 +
 src/BLSURFPlugin/Makefile.am                  |  22 +-
 src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx | 737 +++++++++++++++++-
 src/GUI/BLSURFPluginGUI_HypothesisCreator.h   |  75 +-
 src/GUI/BLSURFPlugin_msg_en.ts                |  52 ++
 src/GUI/Makefile.am                           |  10 +-
 src/Makefile.am                               |   4 +-
 src/PluginUtils/GeomSelectionTools.cxx        | 273 +++++++
 src/PluginUtils/GeomSelectionTools.h          |  67 ++
 src/PluginUtils/Makefile.am                   |  66 ++
 src/PluginUtils/PluginUtils.h                 |  28 +
 src/PluginUtils/SizeMapPython.cxx             |   0
 src/PluginUtils/SizeMapPython.h               |   1 +
 38 files changed, 3077 insertions(+), 76 deletions(-)
 create mode 100644 doc/Makefile.am
 create mode 100644 doc/salome/Makefile.am
 create mode 100644 doc/salome/gui/Makefile.am
 create mode 100755 doc/salome/gui/doxyfile.in
 create mode 100644 doc/salome/gui/input/empty
 create mode 100755 doc/salome/gui/static/footer.html
 create mode 100755 doc/salome/gui/static/header.html
 create mode 100644 doc/salome/tui/Makefile.am
 create mode 100755 doc/salome/tui/doxyfile.in
 create mode 100755 doc/salome/tui/images/Application-About.png
 create mode 100755 doc/salome/tui/images/application.gif
 create mode 100755 doc/salome/tui/images/html_comments.gif
 create mode 100755 doc/salome/tui/images/logocorp.gif
 create mode 100755 doc/salome/tui/static/doxygen.css
 create mode 100755 doc/salome/tui/static/footer.html
 create mode 100755 doc/salome/tui/static/myheader.html
 create mode 100644 src/PluginUtils/GeomSelectionTools.cxx
 create mode 100644 src/PluginUtils/GeomSelectionTools.h
 create mode 100644 src/PluginUtils/Makefile.am
 create mode 100644 src/PluginUtils/PluginUtils.h
 create mode 100644 src/PluginUtils/SizeMapPython.cxx
 create mode 100644 src/PluginUtils/SizeMapPython.h

diff --git a/Makefile.am b/Makefile.am
index d5c2257..d3ca9b6 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -38,9 +38,9 @@ else !BLSURFPLUGIN_ENABLE_GUI
                     -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files
 endif
 
-SUBDIRS = idl adm_local resources src bin
+SUBDIRS = idl adm_local resources src bin doc
 
-DIST_SUBDIRS = idl adm_local resources src bin 
+DIST_SUBDIRS = idl adm_local resources src bin doc 
 
 DISTCLEANFILES = a.out aclocal.m4 configure
 
@@ -52,3 +52,12 @@ EXTRA_DIST += \
 
 dist-hook:
 	rm -rf `find $(distdir) -name CVS`
+
+usr_docs:
+	(cd doc && $(MAKE) $(AM_MAKEFLAGS) usr_docs)
+
+docs: usr_docs
+
+dev_docs:
+	(cd doc && $(MAKE) $(AM_MAKEFLAGS) dev_docs)
+
diff --git a/clean_configure b/clean_configure
index 8f00366..0d23d94 100755
--- a/clean_configure
+++ b/clean_configure
@@ -32,6 +32,7 @@ find bin -name Makefile.in | xargs rm -f
 find doc -name Makefile.in | xargs rm -f
 find idl -name Makefile.in | xargs rm -f
 find resources -name Makefile.in | xargs rm -f
-find salome_adm -name Makefile.in | xargs rm -f
+find adm_local -name Makefile.in | xargs rm -f
 find src -name Makefile.in | xargs rm -f
 rm -f Makefile.in
+rm -Rf salome_adm 
diff --git a/configure.ac b/configure.ac
index 2bdc7c3..6df09ba 100644
--- a/configure.ac
+++ b/configure.ac
@@ -405,11 +405,18 @@ AC_OUTPUT([ \
   adm_local/Makefile \
   adm_local/unix/Makefile \
   adm_local/unix/config_files/Makefile \
+  doc/Makefile \
+  doc/salome/Makefile \
+  doc/salome/gui/Makefile \
+  doc/salome/gui/doxyfile \
+  doc/salome/tui/Makefile \
+  doc/salome/tui/doxyfile \
   bin/VERSION \
   bin/Makefile \
   idl/Makefile \
   resources/Makefile \
   src/Makefile \
+  src/PluginUtils/Makefile \
   src/BLSURFPlugin/Makefile \
   src/GUI/Makefile \
   BLSURFPLUGIN_version.h \
diff --git a/doc/Makefile.am b/doc/Makefile.am
new file mode 100644
index 0000000..bf2a8e0
--- /dev/null
+++ b/doc/Makefile.am
@@ -0,0 +1,34 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# -* Makefile *- 
+# Author : Patrick GOLDBRONN (CEA)
+# Date : 30/11/2001
+#
+SUBDIRS = salome
+
+usr_docs:
+	(cd salome && $(MAKE) $(AM_MAKEFLAGS) usr_docs)
+
+docs: usr_docs
+
+dev_docs:
+	(cd salome && $(MAKE) $(AM_MAKEFLAGS) dev_docs)
diff --git a/doc/salome/Makefile.am b/doc/salome/Makefile.am
new file mode 100644
index 0000000..b17b95b
--- /dev/null
+++ b/doc/salome/Makefile.am
@@ -0,0 +1,40 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# -* Makefile *- 
+# Author : Patrick GOLDBRONN (CEA)
+# Date : 30/11/2001
+#
+SUBDIRS = tui gui
+SUBDIRSTUI = tui
+SUBDIRSGUI = gui
+
+usr_docs:
+	@@SETX@; for d in $(SUBDIRSGUI); do 	\
+	   (cd $$d && $(MAKE) $@) || exit 1; 	\
+	done;
+
+docs: usr_docs
+
+dev_docs:
+	@@SETX@; for d in $(SUBDIRSTUI); do 	\
+	   (cd $$d && $(MAKE) $@) || exit 1; 	\
+	done;
diff --git a/doc/salome/gui/Makefile.am b/doc/salome/gui/Makefile.am
new file mode 100644
index 0000000..e5e5b54
--- /dev/null
+++ b/doc/salome/gui/Makefile.am
@@ -0,0 +1,44 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+#  File   : Makefile.in
+#  Author : Vasily Rusyaev (Open Cascade NN)
+#  Module : doc
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+EXTRA_DIST += images input static
+
+usr_docs: doxyfile
+	echo "Running doxygen in directory: "`pwd`; \
+	$(DOXYGEN) $<
+
+docs: usr_docs
+
+clean-local:
+	-rm -fr BLSURFPLUGIN doxygen.bak
+
+install-data-local: usr_docs
+	$(INSTALL) -d $(DESTDIR)$(docdir)/gui
+	cp -rp BLSURFPLUGIN $(DESTDIR)$(docdir)/gui
+
+uninstall-local:
+	rm -rf $(DESTDIR)$(docdir)/gui/BLSURFPLUGIN
diff --git a/doc/salome/gui/doxyfile.in b/doc/salome/gui/doxyfile.in
new file mode 100755
index 0000000..2c4daef
--- /dev/null
+++ b/doc/salome/gui/doxyfile.in
@@ -0,0 +1,65 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME      = "BLSURFPLUGIN Module Reference Manual v.@VERSION@"
+OUTPUT_DIRECTORY  = BLSURFPLUGIN
+CREATE_SUBDIRS	  = NO
+OUTPUT_LANGUAGE   = English
+TAB_SIZE          = 5
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET             = NO
+WARNINGS          = YES
+
+#---------------------------------------------------------------------------
+#Input related options
+#---------------------------------------------------------------------------
+INPUT             = @srcdir@/input		  
+FILE_PATTERNS     = *.doc
+IMAGE_PATH        = @srcdir@/images
+
+#---------------------------------------------------------------------------
+#HTML related options
+#---------------------------------------------------------------------------
+GENERATE_HTML     = YES
+HTML_OUTPUT       = .
+HTML_HEADER       = @srcdir@/static/header.html
+HTML_FOOTER       = @srcdir@/static/footer.html
+#HTML_STYLESHEET  = @srcdir@/static/doxygen.css
+TOC_EXPAND        = YES
+DISABLE_INDEX     = NO
+GENERATE_TREEVIEW = YES
+TREEVIEW_WIDTH    = 300
+
+#---------------------------------------------------------------------------
+#LaTeX related option
+#---------------------------------------------------------------------------
+GENERATE_LATEX    = NO
+
+#---------------------------------------------------------------------------
+#RTF related options
+#---------------------------------------------------------------------------
+GENERATE_RTF      = NO
diff --git a/doc/salome/gui/input/empty b/doc/salome/gui/input/empty
new file mode 100644
index 0000000..e69de29
diff --git a/doc/salome/gui/static/footer.html b/doc/salome/gui/static/footer.html
new file mode 100755
index 0000000..56d52a6
--- /dev/null
+++ b/doc/salome/gui/static/footer.html
@@ -0,0 +1,10 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+</head>
+<body>
+<hr style="width: 100%; height: 2px;">
+<div style="text-align: center;">Copyright &copy; 2003-2007 CEA, EDF<br>
+</div>
+</body>
+</html>
diff --git a/doc/salome/gui/static/header.html b/doc/salome/gui/static/header.html
new file mode 100755
index 0000000..a70a95e
--- /dev/null
+++ b/doc/salome/gui/static/header.html
@@ -0,0 +1,12 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
+<html>
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+   <title>$title</title>
+   <link href="doxygen.css" rel="stylesheet" type="text/css">
+</head>
+<hr>
+<center>
+SALOME documentation central
+</center>
+<hr>
diff --git a/doc/salome/tui/Makefile.am b/doc/salome/tui/Makefile.am
new file mode 100644
index 0000000..4b05cbf
--- /dev/null
+++ b/doc/salome/tui/Makefile.am
@@ -0,0 +1,44 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+#  File   : Makefile.in
+#  Author : Vasily Rusyaev (Open Cascade NN)
+#  Module : doc
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+EXTRA_DIST += images static
+
+dev_docs: doxyfile
+	echo "Running doxygen in directory: "`pwd`; \
+	$(DOXYGEN) $<;
+
+clean-local:
+	-rm -fr BLSURFPLUGIN doxygen.bak
+
+install-data-local:
+	if test -d BLSURFPLUGIN; then \
+	  $(INSTALL) -d $(DESTDIR)$(docdir)/tui ; \
+	  cp -rp BLSURFPLUGIN $(DESTDIR)$(docdir)/tui ; \
+	fi;
+
+uninstall-local:
+	rm -rf $(DESTDIR)$(docdir)/tui/BLSURFPLUGIN
diff --git a/doc/salome/tui/doxyfile.in b/doc/salome/tui/doxyfile.in
new file mode 100755
index 0000000..3baf75b
--- /dev/null
+++ b/doc/salome/tui/doxyfile.in
@@ -0,0 +1,263 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Doxyfile 1.4.6
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = "BLSURFPLUGIN Module Programming Guide v.@VERSION@"
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = BLSURFPLUGIN
+CREATE_SUBDIRS         = NO
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = NO
+ABBREVIATE_BRIEF       = 
+ALWAYS_DETAILED_SEC    = YES
+INLINE_INHERITED_MEMB  = YES
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = @top_srcdir@ @top_builddir@
+STRIP_FROM_INC_PATH    = 
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = NO
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 5
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = YES
+BUILTIN_STL_SUPPORT    = @DOXYGEN_SUPPORT_STL@
+DISTRIBUTE_GROUP_DOC   = NO
+SUBGROUPING            = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+HIDE_UNDOC_MEMBERS     = YES
+HIDE_UNDOC_CLASSES     = YES
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = YES
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = NO
+SORT_BRIEF_DOCS        = NO
+SORT_BY_SCOPE_NAME     = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 25
+SHOW_USED_FILES        = NO
+SHOW_DIRECTORIES       = NO
+FILE_VERSION_FILTER    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = @top_srcdir@/src \
+			 @top_srcdir@/bin \
+			 @top_srcdir@/idl \
+			 @top_builddir@/bin
+FILE_PATTERNS          = *.idl *.hxx *.cxx *.h *.c *.hh *.cc @DOXYGEN_PYTHON_EXTENSION@
+RECURSIVE              = YES
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = YES
+IMAGE_PATH             = @srcdir@/images
+INPUT_FILTER           = 
+FILTER_PATTERNS        = 
+FILTER_SOURCE_FILES    = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 3
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = .
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = @srcdir@/static/myheader.html
+HTML_FOOTER            = @srcdir@/static/footer.html
+HTML_STYLESHEET        = @srcdir@/static/doxygen.css
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = YES
+TOC_EXPAND             = YES
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = NO
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = NO
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = NO
+GROUP_GRAPHS           = NO
+UML_LOOK               = NO
+TEMPLATE_RELATIONS     = YES
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = NO
+CALL_GRAPH             = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = jpg
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1200
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = NO
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
diff --git a/doc/salome/tui/images/Application-About.png b/doc/salome/tui/images/Application-About.png
new file mode 100755
index 0000000000000000000000000000000000000000..7b58330d50856e28562e8f9ed80dae72d6e6dda3
GIT binary patch
literal 19226
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

literal 0
HcmV?d00001

diff --git a/doc/salome/tui/images/application.gif b/doc/salome/tui/images/application.gif
new file mode 100755
index 0000000000000000000000000000000000000000..0b05d5c18ee88779d283508781836e2b151f606f
GIT binary patch
literal 2602
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
H2G;!_1w6Z(

literal 0
HcmV?d00001

diff --git a/doc/salome/tui/images/html_comments.gif b/doc/salome/tui/images/html_comments.gif
new file mode 100755
index 0000000000000000000000000000000000000000..f0c0f0b47100447f7d3a8104b0b4930c548f5437
GIT binary patch
literal 156
zcmV;N0Av40Nk%w1VQT;h0Du4hv>+h=|NkNW6+?1mVRU6=Aa`kWXdqN*WgtgMO;7+K
z`2+z90096j00000YXAuV00LT!kEzS;4#1l<$#<*OH8amG5(oyRc7{m0hHSLOstHBc
z2p=%3&u96YxeS>bktgh7J}aBf$+6{%G-U^B!de@_Bt+>MZM~unISNh_&rFnzZP`Jm
KJ9x`c0029x$~vY1

literal 0
HcmV?d00001

diff --git a/doc/salome/tui/images/logocorp.gif b/doc/salome/tui/images/logocorp.gif
new file mode 100755
index 0000000000000000000000000000000000000000..7697e0837777ed6aa775741b68962a9533f62caa
GIT binary patch
literal 1792
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

literal 0
HcmV?d00001

diff --git a/doc/salome/tui/static/doxygen.css b/doc/salome/tui/static/doxygen.css
new file mode 100755
index 0000000..4893b5e
--- /dev/null
+++ b/doc/salome/tui/static/doxygen.css
@@ -0,0 +1,152 @@
+H1 { 
+   text-align: center; 
+}
+
+CAPTION { 
+   font-weight: bold 
+}
+
+/* Link in the top navbar */
+A.qindex {}
+
+A.qindexRef {}
+
+/* Link to any cross-referenced Doxygen element */
+A.el { 
+   text-decoration: none; 
+   font-weight: bold 
+}
+
+A.elRef { 
+   font-weight: bold 
+}
+
+/* Link to any cross-referenced Doxygen element inside a code section 
+   (ex: header)
+*/
+A.code { 
+   text-decoration: none; 
+   font-weight: normal; 
+   color: #4444ee 
+}
+
+A.codeRef { 
+   font-weight: normal; 
+   color: #4444ee 
+}
+
+A:hover { 
+   text-decoration: none; 
+   background-color: lightblue 
+}
+
+DL.el { 
+   margin-left: -1cm 
+}
+
+/* A code fragment (ex: header) */
+DIV.fragment { 
+   width: 100%; 
+   border: none; 
+   background-color: #CCCCCC 
+}
+
+/* In the alpha list (coumpound index), style of an alphabetical index letter */
+DIV.ah { 
+   background-color: #CCCCCC; 
+   font-weight: bold; 
+   color: #ffffff; 
+   margin-bottom: 3px; 
+   margin-top: 3px 
+}
+
+/* Method name (+ type) */
+TD.md { 
+   background-color: lightblue; 
+   font-weight: bold; 
+}
+
+/* Method parameter (some of them) */
+TD.mdname1 { 
+   background-color: lightblue; 
+   font-weight: bold; color: #602020; 
+}
+
+/* Method parameter (some of them) */
+TD.mdname { 
+   background-color: lightblue; 
+   font-weight: bold; 
+   color: #602020; 
+   width: 600px; 
+}
+
+/* Separator between methods group (usually empty, seems not supported by IE) */
+DIV.groupHeader { 
+   margin-left: 16px; 
+   margin-top: 12px; 
+   margin-bottom: 6px; 
+   font-weight: bold 
+}
+
+DIV.groupText { 
+   margin-left: 16px; 
+   font-style: italic; 
+   font-size: smaller 
+}
+
+BODY { background: #FFFFFF
+}
+
+/* BODY { 
+   background: url(sources/bg_salome.gif) 
+} */
+
+div.tabs { 
+  text-align: justify; 
+  font-weight: bold;
+  color: #FFFFFF;
+}
+
+DIV.div-footer { 
+  margin-left: 1em;
+  margin-right: 1em;
+  margin-bottom: 0.2em;
+  text-align: right;
+  font-size: 9pt; 
+}
+
+/* In File List, Coumpound List, etc, 1st column of the index */
+TD.indexkey { 
+   background-color: #CCCCCC; 
+   font-weight: bold; 
+   padding-right  : 10px; 
+   padding-top    : 2px; 
+   padding-left   : 10px; 
+   padding-bottom : 2px; 
+   margin-left    : 0px; 
+   margin-right   : 0px; 
+   margin-top     : 2px; 
+   margin-bottom  : 2px  
+}
+
+/* In File List, Coumpound List, etc, 2nd column of the index */
+TD.indexvalue { 
+   background-color: #CCCCCC; 
+   font-style: italic; 
+   padding-right  : 10px; 
+   padding-top    : 2px; 
+   padding-left   : 10px; 
+   padding-bottom : 2px; 
+   margin-left    : 0px; 
+   margin-right   : 0px; 
+   margin-top     : 2px; 
+   margin-bottom  : 2px  
+}
+
+span.keyword       { color: #008000 }
+span.keywordtype   { color: #604020 }
+span.keywordflow   { color: #e08000 }
+span.comment       { color: #800000 }
+span.preprocessor  { color: #806020 }
+span.stringliteral { color: #002080 }
+span.charliteral   { color: #008080 }
diff --git a/doc/salome/tui/static/footer.html b/doc/salome/tui/static/footer.html
new file mode 100755
index 0000000..cb55f39
--- /dev/null
+++ b/doc/salome/tui/static/footer.html
@@ -0,0 +1,5 @@
+</DIV>
+<DIV class="div-footer">
+Generated on $datetime for $projectname by&nbsp;<A href="http://www.doxygen.org/index.html"><img src="doxygen.png" alt="doxygen" align="middle" border="0"></A> $doxygenversion</DIV>
+</BODY>
+</HTML>
diff --git a/doc/salome/tui/static/myheader.html b/doc/salome/tui/static/myheader.html
new file mode 100755
index 0000000..d2efb75
--- /dev/null
+++ b/doc/salome/tui/static/myheader.html
@@ -0,0 +1,13 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
+<html>
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+   <meta name="GENERATOR" content="Mozilla/4.73 [en] (WinNT; I) [Netscape]">
+   <title>Main Page</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+<body>
+&nbsp;
+</body>
+</html>
diff --git a/idl/BLSURFPlugin_Algorithm.idl b/idl/BLSURFPlugin_Algorithm.idl
index 026602a..470dffc 100644
--- a/idl/BLSURFPlugin_Algorithm.idl
+++ b/idl/BLSURFPlugin_Algorithm.idl
@@ -19,12 +19,14 @@
 // ---
 // File    : BLSURFPlugin_Algorithm.idl
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #ifndef _SMESH_BLSURFALGORITHM_IDL_
 #define _SMESH_BLSURFALGORITHM_IDL_
 
 #include "SMESH_Hypothesis.idl"
+#include "GEOM_Gen.idl"
 #include "SALOME_Exception.idl"
 
 /*!
@@ -160,8 +162,49 @@ module BLSURFPlugin
      * Note: the method is mostly for interaction with GUI.
      */
     void SetOptionValues(in string_array options);
-  };
 
+    /*!
+     * SizeMap
+     */
+    void SetSizeMapEntries(in string_array sizeMaps);
+    void ClearSizeMaps();
+
+    void UnsetEntry(in string entry);
+
+    /*!
+     * Set a SizeMap on geom object
+     */
+    void         SetSizeMap(in GEOM::GEOM_Object GeomObj, in string sizeMap);
+    void         UnsetSizeMap(in GEOM::GEOM_Object GeomObj);
+    
+    /*!
+     * Set a SizeMap on geom object given by entry
+     */
+    void         SetSizeMapEntry(in string entry, in string sizeMap);
+    string       GetSizeMapEntry(in string entry);
+    string_array GetSizeMapEntries();
+
+    /*!
+     * Set an attractor on geom object
+     */
+    void         SetAttractor(in GEOM::GEOM_Object GeomObj, in string attractor);
+    void         UnsetAttractor(in GEOM::GEOM_Object GeomObj);
+    
+    /*!
+     * Set an attractor on geom object given by entry
+     */
+    void         SetAttractorEntry(in string entry, in string attractor);
+    string       GetAttractorEntry(in string entry);
+    string_array GetAttractorEntries();
+
+/*
+    void         SetCustomSizeMapEntry(in string entry, in string sizeMap);
+    string       GetCustomSizeMapEntry(in string entry);
+    void         SetCustomSizeMap(in GEOM::GEOM_Object GeomObj, in string sizeMap);
+    void         UnsetCustomSizeMap(in GEOM::GEOM_Object GeomObj);
+    string_array GetCustomSizeMapEntries();
+*/
+  };
 };
 
 #endif
diff --git a/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx b/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx
index 39e7d49..ad1dd02 100644
--- a/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx
@@ -20,14 +20,19 @@
 // File    : BLSURFPlugin_BLSURF.cxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
 //           & Aurelien ALLEAUME (DISTENE)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #include "BLSURFPlugin_BLSURF.hxx"
 #include "BLSURFPlugin_Hypothesis.hxx"
 
+#include <structmember.h>
+
+
 #include <SMESH_Gen.hxx>
 #include <SMESH_Mesh.hxx>
 #include <SMESH_ControlsDef.hxx>
+#include <SMESHGUI_Utils.h>
 
 #include <SMESHDS_Mesh.hxx>
 #include <SMDS_MeshElement.hxx>
@@ -35,8 +40,10 @@
 
 #include <utilities.h>
 
+#include <limits>
 #include <list>
 #include <vector>
+#include <cstdlib>
 
 #include <BRep_Tool.hxx>
 #include <TopExp.hxx>
@@ -68,6 +75,131 @@ extern "C"{
 #include <fenv.h>
 #endif
 
+#include  <GeomSelectionTools.h>
+
+#include <GeomAPI_ProjectPointOnCurve.hxx>
+#include <GeomAPI_ProjectPointOnSurf.hxx>
+#include <gp_XY.hxx>
+#include <gp_XYZ.hxx>
+
+/* ==================================
+ * ===========  PYTHON ==============
+ * ==================================*/
+
+typedef struct {
+  PyObject_HEAD
+  int softspace;
+  std::string *out;
+  } PyStdOut;
+
+static void
+PyStdOut_dealloc(PyStdOut *self)
+{
+  PyObject_Del(self);
+}
+
+static PyObject *
+PyStdOut_write(PyStdOut *self, PyObject *args)
+{
+  char *c;
+  int l;
+  if (!PyArg_ParseTuple(args, "t#:write",&c, &l))
+    return NULL;
+
+  //std::cerr << c ;
+  *(self->out)=*(self->out)+c;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyMethodDef PyStdOut_methods[] = {
+  {"write",  (PyCFunction)PyStdOut_write,  METH_VARARGS,
+    PyDoc_STR("write(string) -> None")},
+  {NULL,    NULL}   /* sentinel */
+};
+
+static PyMemberDef PyStdOut_memberlist[] = {
+  {"softspace", T_INT,  offsetof(PyStdOut, softspace), 0,
+   "flag indicating that a space needs to be printed; used by print"},
+  {NULL} /* Sentinel */
+};
+
+static PyTypeObject PyStdOut_Type = {
+  /* The ob_type field must be initialized in the module init function
+   * to be portable to Windows without using C++. */
+  PyObject_HEAD_INIT(NULL)
+  0,      /*ob_size*/
+  "PyOut",   /*tp_name*/
+  sizeof(PyStdOut),  /*tp_basicsize*/
+  0,      /*tp_itemsize*/
+  /* methods */
+  (destructor)PyStdOut_dealloc, /*tp_dealloc*/
+  0,      /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  0,      /*tp_compare*/
+  0,      /*tp_repr*/
+  0,      /*tp_as_number*/
+  0,      /*tp_as_sequence*/
+  0,      /*tp_as_mapping*/
+  0,      /*tp_hash*/
+        0,                      /*tp_call*/
+        0,                      /*tp_str*/
+        PyObject_GenericGetAttr,                      /*tp_getattro*/
+        /* softspace is writable:  we must supply tp_setattro */
+        PyObject_GenericSetAttr,    /* tp_setattro */
+        0,                      /*tp_as_buffer*/
+        Py_TPFLAGS_DEFAULT,     /*tp_flags*/
+        0,                      /*tp_doc*/
+        0,                      /*tp_traverse*/
+        0,                      /*tp_clear*/
+        0,                      /*tp_richcompare*/
+        0,                      /*tp_weaklistoffset*/
+        0,                      /*tp_iter*/
+        0,                      /*tp_iternext*/
+        PyStdOut_methods,                      /*tp_methods*/
+        PyStdOut_memberlist,                      /*tp_members*/
+        0,                      /*tp_getset*/
+        0,                      /*tp_base*/
+        0,                      /*tp_dict*/
+        0,                      /*tp_descr_get*/
+        0,                      /*tp_descr_set*/
+        0,                      /*tp_dictoffset*/
+        0,                      /*tp_init*/
+        0,                      /*tp_alloc*/
+        0,                      /*tp_new*/
+        0,                      /*tp_free*/
+        0,                      /*tp_is_gc*/
+};
+
+PyObject * newPyStdOut( std::string& out )
+{
+  PyStdOut *self;
+  self = PyObject_New(PyStdOut, &PyStdOut_Type);
+  if (self == NULL)
+    return NULL;
+  self->softspace = 0;
+  self->out=&out;
+  return (PyObject*)self;
+}
+
+
+////////////////////////END PYTHON///////////////////////////
+
+//////////////////MY MAPS////////////////////////////////////////
+std::map<int,string> FaceId2SizeMap;
+std::map<int,string> EdgeId2SizeMap;
+std::map<int,string> VertexId2SizeMap;
+std::map<int,PyObject*> FaceId2PythonSmp;
+std::map<int,PyObject*> EdgeId2PythonSmp;
+std::map<int,PyObject*> VertexId2PythonSmp;
+
+
+bool HasSizeMapOnFace=false;
+bool HasSizeMapOnEdge=false;
+bool HasSizeMapOnVertex=false;
+
 //=============================================================================
 /*!
  *  
@@ -86,6 +218,28 @@ BLSURFPlugin_BLSURF::BLSURFPlugin_BLSURF(int hypId, int studyId,
   _requireDescretBoundary = false;
   _onlyUnaryInput = false;
   _hypothesis = NULL;
+
+
+  /* Initialize the Python interpreter */
+  assert(Py_IsInitialized());
+  PyGILState_STATE gstate;
+  gstate = PyGILState_Ensure();
+
+  main_mod = NULL;
+  main_mod = PyImport_AddModule("__main__");
+
+  main_dict = NULL;
+  main_dict = PyModule_GetDict(main_mod);
+
+  PyRun_SimpleString("from math import *");
+  PyGILState_Release(gstate);
+  
+  FaceId2SizeMap.clear();
+  EdgeId2SizeMap.clear();
+  VertexId2SizeMap.clear();
+  FaceId2PythonSmp.clear();
+  EdgeId2PythonSmp.clear();
+  VertexId2PythonSmp.clear();
 }
 
 //=============================================================================
@@ -99,6 +253,7 @@ BLSURFPlugin_BLSURF::~BLSURFPlugin_BLSURF()
   MESSAGE("BLSURFPlugin_BLSURF::~BLSURFPlugin_BLSURF");
 }
 
+
 //=============================================================================
 /*!
  *  
@@ -165,6 +320,39 @@ inline std::string to_string(int i)
    return o.str();
 }
 
+double _smp_phy_size;
+status_t size_on_surface(integer face_id, real *uv, real *size, void *user_data);
+status_t size_on_edge(integer edge_id, real t, real *size, void *user_data); 
+status_t size_on_vertex(integer vertex_id, real *size, void *user_data);
+
+double my_u_min=1e6,my_v_min=1e6,my_u_max=-1e6,my_v_max=-1e6;
+
+/////////////////////////////////////////////////////////
+gp_XY getUV(const TopoDS_Face& face, const gp_XYZ& point)
+{
+  Handle(Geom_Surface) surface = BRep_Tool::Surface(face);
+  GeomAPI_ProjectPointOnSurf projector( point, surface );
+  if ( !projector.IsDone() || projector.NbPoints()==0 )
+    throw "Can't project";
+
+  Quantity_Parameter u,v;
+  projector.LowerDistanceParameters(u,v);
+  return gp_XY(u,v);
+}
+/////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////
+double getT(const TopoDS_Edge& edge, const gp_XYZ& point)
+{
+  Standard_Real f,l;
+  Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, f,l);
+  GeomAPI_ProjectPointOnCurve projector( point, curve);
+  if ( projector.NbPoints() == 0 )
+    throw;
+  return projector.LowerDistanceParameter();
+}
+/////////////////////////////////////////////////////////
+
 void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp, blsurf_session_t *bls)
 {
   int    _topology      = BLSURFPlugin_Hypothesis::GetDefaultTopology();
@@ -177,7 +365,7 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp, blsu
   bool   _quadAllowed   = BLSURFPlugin_Hypothesis::GetDefaultQuadAllowed();
   bool   _decimesh      = BLSURFPlugin_Hypothesis::GetDefaultDecimesh();
   int    _verb          = BLSURFPlugin_Hypothesis::GetDefaultVerbosity();
-
+   
   if (hyp) {
     MESSAGE("BLSURFPlugin_BLSURF::SetParameters");
     _topology      = (int) hyp->GetTopology();
@@ -204,22 +392,142 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp, blsu
     BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt;
     for ( opIt = opts.begin(); opIt != opts.end(); ++opIt )
       if ( !opIt->second.empty() ) {
-#ifdef _DEBUG_
-        cout << "blsurf_set_param(): " << opIt->first << " = " << opIt->second << endl;
-#endif
+        MESSAGE("blsurf_set_param(): " << opIt->first << " = " << opIt->second);
         blsurf_set_param(bls, opIt->first.c_str(), opIt->second.c_str());
       }
 
   } else {
     MESSAGE("BLSURFPlugin_BLSURF::SetParameters using defaults");
   }
-  
+  _smp_phy_size = _phySize;
   blsurf_set_param(bls, "topo_points",       _topology > 0 ? "1" : "0");
   blsurf_set_param(bls, "topo_curves",       _topology > 0 ? "1" : "0");
   blsurf_set_param(bls, "topo_project",      _topology > 0 ? "1" : "0");
   blsurf_set_param(bls, "clean_boundary",    _topology > 1 ? "1" : "0");
   blsurf_set_param(bls, "close_boundary",    _topology > 1 ? "1" : "0");
   blsurf_set_param(bls, "hphy_flag",         to_string(_physicalMesh).c_str());
+//  blsurf_set_param(bls, "hphy_flag",         "2");
+  if ((to_string(_physicalMesh))=="2"){
+    GeomSelectionTools* GeomST = new GeomSelectionTools::GeomSelectionTools( SMESH::GetActiveStudyDocument());
+
+    TopoDS_Shape GeomShape;
+    TopAbs_ShapeEnum GeomType;
+    //
+    // Standard Size Maps
+    //
+    MESSAGE("Setting a Size Map");
+    const BLSURFPlugin_Hypothesis::TSizeMap & sizeMaps = hyp->GetSizeMapEntries();
+    BLSURFPlugin_Hypothesis::TSizeMap::const_iterator smIt;
+    int i=0;
+    for ( smIt = sizeMaps.begin(); smIt != sizeMaps.end(); ++smIt ) {
+      if ( !smIt->second.empty() ) {
+        MESSAGE("blsurf_set_sizeMap(): " << smIt->first << " = " << smIt->second);
+        GeomShape = GeomST->entryToShape(smIt->first);
+        GeomType  = GeomShape.ShapeType();
+        if (GeomType == TopAbs_FACE){
+          HasSizeMapOnFace = true;
+          FaceId2SizeMap[TopoDS::Face(GeomShape).HashCode(471662)] = smIt->second;
+        }
+        if (GeomType == TopAbs_EDGE){
+          HasSizeMapOnEdge = true;
+          HasSizeMapOnFace = true;
+          EdgeId2SizeMap[TopoDS::Edge(GeomShape).HashCode(471662)] = smIt->second;
+        }
+        if (GeomType == TopAbs_VERTEX){
+          HasSizeMapOnVertex = true;
+          HasSizeMapOnEdge   = true;
+          HasSizeMapOnFace   = true;
+          VertexId2SizeMap[TopoDS::Vertex(GeomShape).HashCode(471662)] = smIt->second;
+        }
+      }
+    }
+
+    //
+    // Attractors
+    //
+    MESSAGE("Setting Attractors");
+    const BLSURFPlugin_Hypothesis::TSizeMap & attractors = hyp->GetAttractorEntries();
+    BLSURFPlugin_Hypothesis::TSizeMap::const_iterator atIt;
+    for ( atIt = attractors.begin(); atIt != attractors.end(); ++atIt ) {
+      if ( !atIt->second.empty() ) {
+        MESSAGE("blsurf_set_attractor(): " << atIt->first << " = " << atIt->second);
+        GeomShape = GeomST->entryToShape(atIt->first);
+        GeomType  = GeomShape.ShapeType();
+
+        if (GeomType == TopAbs_FACE){
+          HasSizeMapOnFace = true;
+
+          double xa, ya, za; // Coordinates of attractor point
+          double a, b;       // Attractor parameter
+          int pos1, pos2;
+          // atIt->second has the following pattern:
+          // ATTRACTOR(xa;ya;za;a;b)
+          // where:
+          // xa;ya;za : coordinates of  attractor
+          // a        : desired size on attractor
+          // b        : distance of influence of attractor
+          //
+          // We search the parameters in the string
+          pos1 = atIt->second.find(";");
+          xa = atof(atIt->second.substr(10, pos1-10).c_str());
+          pos2 = atIt->second.find(";", pos1+1);
+          ya = atof(atIt->second.substr(pos1+1, pos2-pos1-1).c_str());
+          pos1 = pos2;
+          pos2 = atIt->second.find(";", pos1+1);
+          za = atof(atIt->second.substr(pos1+1, pos2-pos1-1).c_str());
+          pos1 = pos2;
+          pos2 = atIt->second.find(";", pos1+1);
+          a = atof(atIt->second.substr(pos1+1, pos2-pos1-1).c_str());
+          pos1 = pos2;
+          pos2 = atIt->second.find(")");
+          b = atof(atIt->second.substr(pos1+1, pos2-pos1-1).c_str());
+          
+          // Get the (u,v) values of the attractor on the face
+          gp_XY uvPoint = getUV(TopoDS::Face(GeomShape),gp_XYZ(xa,ya,za));
+          Standard_Real u0 = uvPoint.X();
+          Standard_Real v0 = uvPoint.Y();
+          // We construct the python function
+          ostringstream attractorFunction;
+          attractorFunction << "def f(u,v): return ";
+          attractorFunction << _smp_phy_size << "-(" << _smp_phy_size <<"-" << a << ")";
+          attractorFunction << "*exp(-((u-("<<u0<<"))*(u-("<<u0<<"))+(v-("<<v0<<"))*(v-("<<v0<<")))/(" << b << "*" << b <<"))";  
+
+          MESSAGE("Python function for attractor:" << std::endl << attractorFunction.str());
+
+          FaceId2SizeMap[TopoDS::Face(GeomShape).HashCode(471662)] =attractorFunction.str();
+        }
+/*
+        if (GeomType == TopAbs_EDGE){
+          HasSizeMapOnEdge = true;
+          HasSizeMapOnFace = true;
+        EdgeId2SizeMap[TopoDS::Edge(GeomShape).HashCode(471662)] = atIt->second;
+        }
+        if (GeomType == TopAbs_VERTEX){
+          HasSizeMapOnVertex = true;
+          HasSizeMapOnEdge   = true;
+          HasSizeMapOnFace   = true;
+        VertexId2SizeMap[TopoDS::Vertex(GeomShape).HashCode(471662)] = atIt->second;
+        }
+*/
+      }
+    }    
+
+
+//    if (HasSizeMapOnFace){
+    // In all size map cases (hphy_flag = 2), at least map on face must be defined
+    MESSAGE("Setting Size Map on FACES ");
+    blsurf_data_set_sizemap_iso_cad_face(bls, size_on_surface, &_smp_phy_size);
+//    }
+
+    if (HasSizeMapOnEdge){
+      MESSAGE("Setting Size Map on EDGES ");
+      blsurf_data_set_sizemap_iso_cad_edge(bls, size_on_edge, &_smp_phy_size);
+    }
+    if (HasSizeMapOnVertex){
+      MESSAGE("Setting Size Map on VERTICES ");
+      blsurf_data_set_sizemap_iso_cad_point(bls, size_on_vertex, &_smp_phy_size);
+    }
+  }
   blsurf_set_param(bls, "hphydef",           to_string(_phySize).c_str());
   blsurf_set_param(bls, "hgeo_flag",         to_string(_geometricMesh).c_str());
   blsurf_set_param(bls, "angle_meshs",       to_string(_angleMeshS).c_str());
@@ -246,10 +554,10 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
   MESSAGE("BLSURFPlugin_BLSURF::Compute");
 
   if (aShape.ShapeType() == TopAbs_COMPOUND) {
-    cout << "  the shape is a COMPOUND" << endl;
+    MESSAGE("  the shape is a COMPOUND");
   }
   else {
-    cout << "  the shape is UNKNOWN" << endl;
+    MESSAGE("  the shape is UNKNOWN");
   };
 
   context_t *ctx =  context_new();
@@ -257,19 +565,39 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
 
   cad_t *c = cad_new(ctx);
  
+  blsurf_session_t *bls = blsurf_session_new(ctx);
+  
+
+  SetParameters(_hypothesis, bls);
+
   TopTools_IndexedMapOfShape fmap;
   TopTools_IndexedMapOfShape emap;
   TopTools_IndexedMapOfShape pmap;
   vector<Handle(Geom2d_Curve)> curves;
   vector<Handle(Geom_Surface)> surfaces;
 
+
+
   fmap.Clear();
+  FaceId2PythonSmp.clear();
   emap.Clear();
+  EdgeId2PythonSmp.clear();
   pmap.Clear();
+  VertexId2PythonSmp.clear();
   surfaces.resize(0);
   curves.resize(0);
 
+  assert(Py_IsInitialized());
+  PyGILState_STATE gstate;
+  gstate = PyGILState_Ensure();
+/*
+  Standard_Real u_min;
+  Standard_Real v_min;
+  Standard_Real u_max;
+  Standard_Real v_max;
+*/
   int iface = 0;
+  string bad_end = "return"; 
   for (TopExp_Explorer face_iter(aShape,TopAbs_FACE);face_iter.More();face_iter.Next()) {
     TopoDS_Face f=TopoDS::Face(face_iter.Current());
     if (fmap.FindIndex(f) > 0)
@@ -278,6 +606,26 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
     fmap.Add(f);
     iface++;
     surfaces.push_back(BRep_Tool::Surface(f));
+    // Get bound values of uv surface
+    //BRep_Tool::Surface(f)->Bounds(u_min,u_max,v_min,v_max);
+    //MESSAGE("BRep_Tool::Surface(f)->Bounds(u_min,u_max,v_min,v_max): " << u_min << ", " << u_max << ", " << v_min << ", " << v_max);
+    
+    if ((HasSizeMapOnFace) && FaceId2SizeMap.find(f.HashCode(471662))!=FaceId2SizeMap.end()){
+        MESSAGE("FaceId2SizeMap[f.HashCode(471662)].find(bad_end): " << FaceId2SizeMap[f.HashCode(471662)].find(bad_end));
+        MESSAGE("FaceId2SizeMap[f.HashCode(471662)].size(): " << FaceId2SizeMap[f.HashCode(471662)].size());
+        MESSAGE("bad_end.size(): " << bad_end.size());
+      // check if function ends with "return"
+        if (FaceId2SizeMap[f.HashCode(471662)].find(bad_end) == (FaceId2SizeMap[f.HashCode(471662)].size()-bad_end.size()-1))
+        continue;
+      // Expr To Python function, verification is performed at validation in GUI
+      PyObject * obj = NULL;
+      obj= PyRun_String(FaceId2SizeMap[f.HashCode(471662)].c_str(), Py_file_input, main_dict, NULL);
+      Py_DECREF(obj);
+      PyObject * func = NULL;
+      func = PyObject_GetAttrString(main_mod, "f");
+      FaceId2PythonSmp[iface]=func;
+      FaceId2SizeMap.erase(f.HashCode(471662));
+    }
     cad_face_t *fce = cad_face_new(c, iface, surf_fun, surfaces.back());  
     cad_face_set_tag(fce, iface);
     if(f.Orientation() != TopAbs_FORWARD){
@@ -294,6 +642,18 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
       
       double tmin,tmax;
       curves.push_back(BRep_Tool::CurveOnSurface(e, f, tmin, tmax));
+      if ((HasSizeMapOnEdge) && EdgeId2SizeMap.find(e.HashCode(471662))!=EdgeId2SizeMap.end()){
+          if (EdgeId2SizeMap[e.HashCode(471662)].find(bad_end) == (EdgeId2SizeMap[e.HashCode(471662)].size()-bad_end.size()-1))
+          continue;
+        // Expr To Python function, verification is performed at validation in GUI
+        PyObject * obj = NULL;
+        obj= PyRun_String(EdgeId2SizeMap[e.HashCode(471662)].c_str(), Py_file_input, main_dict, NULL);
+        Py_DECREF(obj);
+        PyObject * func = NULL;
+        func = PyObject_GetAttrString(main_mod, "f");
+        EdgeId2PythonSmp[ic]=func;
+        EdgeId2SizeMap.erase(e.HashCode(471662));
+      }
       cad_edge_t *edg = cad_edge_new(fce, ic, tmin, tmax, curv_fun, curves.back());
       cad_edge_set_tag(edg, ic);
       cad_edge_set_property(edg, EDGE_PROPERTY_SOFT_REQUIRED);
@@ -307,7 +667,6 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
       Standard_Real d1=0,d2=0;
       for (TopExp_Explorer ex_edge(e ,TopAbs_VERTEX); ex_edge.More(); ex_edge.Next()) {
 	TopoDS_Vertex v = TopoDS::Vertex(ex_edge.Current());
-
 	++npts;
 	if (npts == 1){
 	  ip = &ip1;
@@ -319,10 +678,22 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
 	*ip = pmap.FindIndex(v);
 	if(*ip <= 0)
 	  *ip = pmap.Add(v);
+    if ((HasSizeMapOnVertex) && VertexId2SizeMap.find(v.HashCode(471662))!=VertexId2SizeMap.end()){
+        if (VertexId2SizeMap[v.HashCode(471662)].find(bad_end) == (VertexId2SizeMap[v.HashCode(471662)].size()-bad_end.size()-1))
+            continue;
+          // Expr To Python function, verification is performed at validation in GUI
+          PyObject * obj = NULL;
+          obj= PyRun_String(VertexId2SizeMap[v.HashCode(471662)].c_str(), Py_file_input, main_dict, NULL);
+          Py_DECREF(obj);
+          PyObject * func = NULL;
+          func = PyObject_GetAttrString(main_mod, "f");
+          VertexId2PythonSmp[*ip]=func;
+          VertexId2SizeMap.erase(v.HashCode(471662));
+        }
       }
       if (npts != 2) {
 	// should not happen 
-	cout << "An edge does not have 2 extremities." << endl;
+	MESSAGE("An edge does not have 2 extremities.");
       } else {
 	if (d1 < d2)
 	  cad_edge_set_extremities(edg, ip1, ip2);
@@ -333,16 +704,13 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
   } //for face
 
 
+  PyGILState_Release(gstate);
 
-
-  blsurf_session_t *bls = blsurf_session_new(ctx);
   blsurf_data_set_cad(bls, c);
 
-  SetParameters(_hypothesis, bls);
-
-  cout << endl;
-  cout << "Beginning of Surface Mesh generation" << endl;
-  cout << endl;
+  std::cout << std::endl;
+  std::cout << "Beginning of Surface Mesh generation" << std::endl;
+  std::cout << std::endl;
 
   // Issue 0019864. On DebianSarge, FE signals do not obey to OSD::SetSignal(false)
 #ifndef WNT
@@ -380,9 +748,9 @@ bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
     return error(_comment);
   }
 
-  cout << endl;
-  cout << "End of Surface Mesh generation" << endl;
-  cout << endl;
+  std::cout << std::endl;
+  std::cout << "End of Surface Mesh generation" << std::endl;
+  std::cout << std::endl;
 
   mesh_t *msh;
   blsurf_data_get_mesh(bls, &msh);
@@ -604,6 +972,125 @@ status_t surf_fun(real *uv, real *xyz, real*du, real *dv,
   return 0;
 }
 
+
+status_t size_on_surface(integer face_id, real *uv, real *size, void *user_data)
+{
+  if (face_id == 1) {
+    if (my_u_min > uv[0]) {
+      my_u_min = uv[0];
+    }
+    if (my_v_min > uv[1]) {
+      my_v_min = uv[1];
+    }
+    if (my_u_max < uv[0]) {
+      my_u_max = uv[0];
+    }
+    if (my_v_max < uv[1]) {
+      my_v_max = uv[1];
+    }
+  }
+
+  if (FaceId2PythonSmp.count(face_id) != 0){
+    PyObject * pyresult = NULL;
+    PyObject* new_stderr = NULL;
+    assert(Py_IsInitialized());
+    PyGILState_STATE gstate;
+    gstate = PyGILState_Ensure();
+    pyresult = PyObject_CallFunction(FaceId2PythonSmp[face_id],"(f,f)",uv[0],uv[1]);
+    double result;
+    if ( pyresult == NULL){
+      fflush(stderr);
+      string err_description="";
+      new_stderr = newPyStdOut(err_description);
+      PySys_SetObject("stderr", new_stderr);
+      PyErr_Print();
+      PySys_SetObject("stderr", PySys_GetObject("__stderr__"));
+      Py_DECREF(new_stderr);
+      MESSAGE("Can't evaluate f(" << uv[0] << "," << uv[1] << ")" << " error is " << err_description);
+      result = *((double*)user_data);
+      }
+    else {
+      result = PyFloat_AsDouble(pyresult);
+      Py_DECREF(pyresult);
+    }
+    *size = result;
+    //MESSAGE("f(" << uv[0] << "," << uv[1] << ")" << " = " << result);
+    PyGILState_Release(gstate);
+  }
+  else {
+    *size = *((double*)user_data);
+  }
+  return STATUS_OK;
+}
+
+status_t size_on_edge(integer edge_id, real t, real *size, void *user_data)
+{
+  if (EdgeId2PythonSmp.count(edge_id) != 0){
+    PyObject * pyresult = NULL;
+    PyObject* new_stderr = NULL;
+    assert(Py_IsInitialized());
+    PyGILState_STATE gstate;
+    gstate = PyGILState_Ensure();
+    pyresult = PyObject_CallFunction(EdgeId2PythonSmp[edge_id],"(f)",t);
+    double result;
+    if ( pyresult == NULL){
+      fflush(stderr);
+      string err_description="";
+      new_stderr = newPyStdOut(err_description);
+      PySys_SetObject("stderr", new_stderr);
+      PyErr_Print();
+      PySys_SetObject("stderr", PySys_GetObject("__stderr__"));
+      Py_DECREF(new_stderr);
+      MESSAGE("Can't evaluate f(" << t << ")" << " error is " << err_description);
+      result = *((double*)user_data);
+      }
+    else {
+      result = PyFloat_AsDouble(pyresult);
+      Py_DECREF(pyresult);
+    }
+    *size = result;
+    PyGILState_Release(gstate);
+  }
+  else {
+    *size = *((double*)user_data);
+  }
+  return STATUS_OK;
+}
+
+status_t size_on_vertex(integer point_id, real *size, void *user_data)
+{
+  if (VertexId2PythonSmp.count(point_id) != 0){
+    PyObject * pyresult = NULL;
+    PyObject* new_stderr = NULL;
+    assert(Py_IsInitialized());
+    PyGILState_STATE gstate;
+    gstate = PyGILState_Ensure();
+    pyresult = PyObject_CallFunction(VertexId2PythonSmp[point_id],"");
+    double result;
+    if ( pyresult == NULL){
+      fflush(stderr);
+      string err_description="";
+      new_stderr = newPyStdOut(err_description);
+      PySys_SetObject("stderr", new_stderr);
+      PyErr_Print();
+      PySys_SetObject("stderr", PySys_GetObject("__stderr__"));
+      Py_DECREF(new_stderr);
+      MESSAGE("Can't evaluate f()" << " error is " << err_description);
+      result = *((double*)user_data);
+      }
+    else {
+      result = PyFloat_AsDouble(pyresult);
+      Py_DECREF(pyresult);
+    }
+    *size = result;
+    PyGILState_Release(gstate);
+  }
+  else {
+    *size = *((double*)user_data);
+  }
+ return STATUS_OK;
+}
+
 status_t message_callback(message_t *msg, void *user_data)
 {
   integer errnumber = 0;
@@ -621,7 +1108,7 @@ status_t message_callback(message_t *msg, void *user_data)
     error->append( desc, len );
   }
   else {
-    cout << desc;
+      std::cout << desc << std::endl;
   }
   return STATUS_OK;
 }
diff --git a/src/BLSURFPlugin/BLSURFPlugin_BLSURF.hxx b/src/BLSURFPlugin/BLSURFPlugin_BLSURF.hxx
index 8dd022f..8f442fb 100644
--- a/src/BLSURFPlugin/BLSURFPlugin_BLSURF.hxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_BLSURF.hxx
@@ -20,11 +20,13 @@
 // File    : BLSURFPlugin_BLSURF.hxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
 //           & Aurelien ALLEAUME (DISTENE)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #ifndef _BLSURFPlugin_BLSURF_HXX_
 #define _BLSURFPlugin_BLSURF_HXX_
 
+#include <Python.h>
 #include "SMESH_2D_Algo.hxx"
 #include "SMESH_Mesh.hxx"
 #include "Utils_SALOME_Exception.hxx"
@@ -52,9 +54,14 @@ class BLSURFPlugin_BLSURF: public SMESH_2D_Algo {
     istream & LoadFrom(istream & load);
     friend ostream & operator << (ostream & save, BLSURFPlugin_BLSURF & hyp);
     friend istream & operator >> (istream & load, BLSURFPlugin_BLSURF & hyp);
-
+ 
   protected:
     const BLSURFPlugin_Hypothesis* _hypothesis;
+
+  private:
+      PyObject *          main_mod;
+      PyObject *          main_dict;
+      
 };
 
 #endif
diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
index d5967a8..ae1d60e 100644
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
@@ -20,6 +20,7 @@
 // File    : BLSURFPlugin_Hypothesis.cxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
 //           & Aurelien ALLEAUME (DISTENE)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #include "BLSURFPlugin_Hypothesis.hxx"
@@ -121,6 +122,8 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis (int hypId, int studyId,
     _charOptions.insert( charOptionNames[i] );
     _option2value[ charOptionNames[i++] ].clear();
   }
+  
+  _sizeMap.clear();
 }
 
 //=============================================================================
@@ -334,6 +337,69 @@ void BLSURFPlugin_Hypothesis::ClearOption(const std::string& optionName)
     op_val->second.clear();
 }
 
+
+void  BLSURFPlugin_Hypothesis::SetSizeMapEntry(const std::string& entry,const std::string& sizeMap)
+{
+  if (_sizeMap[entry].compare(sizeMap) != 0) {
+    _sizeMap[entry]=sizeMap;
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+std::string  BLSURFPlugin_Hypothesis::GetSizeMapEntry(const std::string& entry)
+{
+ TSizeMap::iterator it  = _sizeMap.find( entry );
+ if ( it != _sizeMap.end() )
+   return it->second;
+ else
+   return "No_Such_Entry";
+}
+
+void  BLSURFPlugin_Hypothesis::SetAttractorEntry(const std::string& entry,const std::string& attractor)
+{
+  if (_attractors[entry].compare(attractor) != 0) {
+    _attractors[entry]=attractor;
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
+std::string  BLSURFPlugin_Hypothesis::GetAttractorEntry(const std::string& entry)
+{
+ TSizeMap::iterator it  = _attractors.find( entry );
+ if ( it != _attractors.end() )
+   return it->second;
+ else
+   return "No_Such_Entry";
+}
+
+
+void BLSURFPlugin_Hypothesis::ClearEntry(const std::string& entry)
+{
+ TSizeMap::iterator it  = _sizeMap.find( entry );
+ if ( it != _sizeMap.end() ) {
+   _sizeMap.erase(it);
+   NotifySubMeshesHypothesisModification();
+ }
+ else {
+   TSizeMap::iterator itAt  = _attractors.find( entry );
+   if ( itAt != _attractors.end() ) {
+     _attractors.erase(itAt);
+     NotifySubMeshesHypothesisModification();
+   }
+   else
+     std::cout<<"No_Such_Entry"<<std::endl;
+ }
+}
+
+
+void BLSURFPlugin_Hypothesis::ClearSizeMaps()
+{
+  _sizeMap.clear();
+  _attractors.clear();
+}
+
+
+
 //=============================================================================
 std::ostream & BLSURFPlugin_Hypothesis::SaveTo(std::ostream & save)
 {
@@ -353,12 +419,37 @@ std::ostream & BLSURFPlugin_Hypothesis::SaveTo(std::ostream & save)
        << " " << _verb;
 
   TOptionValues::iterator op_val = _option2value.begin();
-  for ( ; op_val != _option2value.end(); ++op_val ) {
-    if ( !op_val->second.empty() )
-      save << " " << op_val->first
-           << " " << op_val->second << "%#"; // "%#" is a mark of value end
+  if (op_val != _option2value.end()) {
+    save << " " << "__OPTIONS_BEGIN__";
+    for ( ; op_val != _option2value.end(); ++op_val ) {
+      if ( !op_val->second.empty() )
+        save << " " << op_val->first
+             << " " << op_val->second << "%#"; // "%#" is a mark of value end
+    }
+    save << " " << "__OPTIONS_END__";
   }
 
+  TSizeMap::iterator it_sm  = _sizeMap.begin();
+  if (it_sm != _sizeMap.end()) {
+    save << " " << "__SIZEMAP_BEGIN__";
+    for ( ; it_sm != _sizeMap.end(); ++it_sm ) {
+        save << " " << it_sm->first
+             << " " << it_sm->second << "%#"; // "%#" is a mark of value end
+    }
+    save << " " << "__SIZEMAP_END__";
+  }
+
+  TSizeMap::iterator it_at  = _attractors.begin();
+  if (it_at != _attractors.end()) {
+    save << " " << "__ATTRACTORS_BEGIN__";
+    for ( ; it_at != _attractors.end(); ++it_at ) {
+        save << " " << it_at->first
+             << " " << it_at->second << "%#"; // "%#" is a mark of value end
+    }
+    save << " " << "__ATTRACTORS_END__";
+  }
+  
+  
   return save;
 }
 
@@ -453,11 +544,28 @@ std::istream & BLSURFPlugin_Hypothesis::LoadFrom(std::istream & load)
   else
     load.clear(std::ios::badbit | load.rdstate());
 
+  std::string option_or_sm;
+  bool hasOptions = false;
+  bool hasSizeMap = false;
+  bool hasAttractor = false;
+
+  isOK = (load >> option_or_sm);
+  if (isOK)
+    if (option_or_sm == "__OPTIONS_BEGIN__")
+      hasOptions = true;
+    else if (option_or_sm == "__SIZEMAP_BEGIN__")
+      hasSizeMap = true;
+    else if (option_or_sm == "__ATTRACTORS_BEGIN__")
+      hasAttractor = true;
+
   std::string optName, optValue;
-  while (isOK) {
+  while (isOK && hasOptions) {
     isOK = (load >> optName);
-    if (isOK)
+    if (isOK) {
+      if (optName == "__OPTIONS_END__")
+        break;
       isOK = (load >> optValue);
+    }
     if (isOK) {
       std::string & value = _option2value[ optName ];
       value = optValue;
@@ -479,6 +587,79 @@ std::istream & BLSURFPlugin_Hypothesis::LoadFrom(std::istream & load)
     }
   }
 
+  if (hasOptions) {
+    isOK = (load >> option_or_sm);
+    if (isOK)
+      if (option_or_sm == "__SIZEMAP_BEGIN__")
+        hasSizeMap = true;
+      else if (option_or_sm == "__ATTRACTORS_BEGIN__")
+        hasAttractor = true;
+  }
+
+  std::string smEntry, smValue;
+  while (isOK && hasSizeMap) {
+    isOK = (load >> smEntry);
+    if (isOK) {
+      if (smEntry == "__SIZEMAP_END__")
+        break;
+      isOK = (load >> smValue);
+    }
+    if (isOK) {
+      std::string & value2 = _sizeMap[ smEntry ];
+      value2 = smValue;
+      int len2= value2.size();
+      // continue reading until "%#" encountered
+      while ( value2[len2-1] != '#' || value2[len2-2] != '%' )
+      {
+        isOK = (load >> smValue);
+        if (isOK) {
+          value2 += " ";
+          value2 += smValue;
+          len2 = value2.size();
+        }
+        else {
+          break;
+        }
+      }
+      value2[ len2-2 ] = '\0'; //cut off "%#"
+    }
+  }
+
+  if (hasSizeMap) {
+    isOK = (load >> option_or_sm);
+    if (isOK && option_or_sm == "__ATTRACTORS_BEGIN__")
+      hasAttractor = true;
+  }
+
+  std::string atEntry, atValue;
+  while (isOK && hasAttractor) {
+    isOK = (load >> atEntry);
+    if (isOK) {
+      if (atEntry == "__ATTRACTORS_END__")
+        break;
+      isOK = (load >> atValue);
+    }
+    if (isOK) {
+      std::string & value3 = _attractors[ atEntry ];
+      value3 = atValue;
+      int len3= value3.size();
+      // continue reading until "%#" encountered
+      while ( value3[len3-1] != '#' || value3[len3-2] != '%' )
+      {
+        isOK = (load >> atValue);
+        if (isOK) {
+          value3 += " ";
+          value3 += atValue;
+          len3 = value3.size();
+        }
+        else {
+          break;
+        }
+      }
+      value3[ len3-2 ] = '\0'; //cut off "%#"
+    }
+  }
+
   return load;
 }
 
diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
index a8fb7d2..de5af16 100644
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
@@ -20,6 +20,7 @@
 // File    : BLSURFPlugin_Hypothesis.hxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
 //           & Aurelien ALLEAUME (DISTENE)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #ifndef _BLSURFPlugin_Hypothesis_HXX_
@@ -95,6 +96,28 @@ public:
 
   void SetVerbosity(int theVal);
   int GetVerbosity() const { return _verb; }
+  
+  void ClearEntry(const std::string& entry);
+  void ClearSizeMaps();  
+
+  typedef std::map<std::string,std::string> TSizeMap;
+
+  void SetSizeMapEntry(const std::string& entry,const std::string& sizeMap );
+  std::string  GetSizeMapEntry(const std::string& entry);
+  const TSizeMap& GetSizeMapEntries() const { return _sizeMap; }  
+
+
+  void SetAttractorEntry(const std::string& entry,const std::string& attractor );
+  std::string GetAttractorEntry(const std::string& entry);
+  const TSizeMap& GetAttractorEntries() const { return _attractors; };
+
+
+/*
+  void SetCustomSizeMapEntry(const std::string& entry,const std::string& sizeMap );
+  std::string  GetCustomSizeMapEntry(const std::string& entry);
+  void UnsetCustomSizeMap(const std::string& entry);
+  const TSizeMap& GetCustomSizeMapEntries() const { return _customSizeMap; }
+ */
 
   static Topology      GetDefaultTopology();
   static PhysicalMesh  GetDefaultPhysicalMesh();
@@ -152,6 +175,11 @@ private:
   int           _verb;
   TOptionValues _option2value;
   TOptionNames  _doubleOptions, _charOptions;
+  TSizeMap      _sizeMap;
+  TSizeMap      _attractors;
+/*
+  TSizeMap      _customSizeMap;
+*/
 };
 
 #endif
diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
index 55ca0d8..815ea9d 100644
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
@@ -19,11 +19,13 @@
 // ---
 // File    : BLSURFPlugin_Hypothesis.cxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #include "BLSURFPlugin_Hypothesis_i.hxx"
 #include "SMESH_Gen.hxx"
 #include "SMESH_PythonDump.hxx"
+#include "GEOM_Object.hxx"
 
 #include "Utils_CorbaException.hxx"
 #include "utilities.h"
@@ -507,6 +509,273 @@ void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array
   }
 }
 
+//=============================================================================
+
+void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry,const char* sizeMap)
+  throw (SALOME::SALOME_Exception)
+{
+  ASSERT(myBaseImpl);
+  MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry); 
+  bool valueChanged = false;
+  try {
+    valueChanged = ( this->GetImpl()->GetSizeMapEntry(entry) != sizeMap );
+    if ( valueChanged )
+      this->GetImpl()->SetSizeMapEntry(entry, sizeMap);
+  }
+  catch (const std::invalid_argument& ex) {
+    SALOME::ExceptionStruct ExDescription;
+    ExDescription.text = ex.what();
+    ExDescription.type = SALOME::BAD_PARAM;
+    ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetSizeMapEntry(entry,sizemap)";
+    ExDescription.lineNumber = 0;
+    throw SALOME::SALOME_Exception(ExDescription);
+  }
+  catch (SALOME_Exception& ex) {
+    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+  }
+  MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry);
+  if ( valueChanged )
+    SMESH::TPythonDump() << _this() << ".SetSizeMap("
+                         << entry << ", '" << sizeMap << "' )";
+}
+
+//=============================================================================
+
+void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry,const char* attractor )
+  throw (SALOME::SALOME_Exception)
+{
+  ASSERT(myBaseImpl);
+  MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry);
+  bool valueChanged = false;
+  try {
+    valueChanged = ( this->GetImpl()->GetAttractorEntry(entry) != attractor );
+    if ( valueChanged )
+      this->GetImpl()->SetAttractorEntry(entry, attractor);
+  }
+  catch (const std::invalid_argument& ex) {
+    SALOME::ExceptionStruct ExDescription;
+    ExDescription.text = ex.what();
+    ExDescription.type = SALOME::BAD_PARAM;
+    ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetAttractorEntry(entry,attractor)";
+    ExDescription.lineNumber = 0;
+    throw SALOME::SALOME_Exception(ExDescription);
+  }
+  catch (SALOME_Exception& ex) {
+    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+  }
+  MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry);
+  if ( valueChanged )
+    SMESH::TPythonDump() << _this() << ".SetAttractor("
+                         << entry << ", '" << attractor << "' )";
+}
+
+
+//=============================================================================
+                                                             
+char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry) 
+  throw (SALOME::SALOME_Exception)
+{
+  ASSERT(myBaseImpl);
+  try {
+    return CORBA::string_dup( this->GetImpl()->GetSizeMapEntry(entry).c_str());
+  }
+  catch (const std::invalid_argument& ex) {
+    SALOME::ExceptionStruct ExDescription;
+    ExDescription.text = ex.what();
+    ExDescription.type = SALOME::BAD_PARAM;
+    ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetSizeMapEntry(name)";
+    ExDescription.lineNumber = 0;
+    throw SALOME::SALOME_Exception(ExDescription);
+  }
+  catch (SALOME_Exception& ex) {
+    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+  }
+  return 0;
+}
+
+//=============================================================================
+
+char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry)
+  throw (SALOME::SALOME_Exception)
+{
+  ASSERT(myBaseImpl);
+  try {
+    return CORBA::string_dup( this->GetImpl()->GetAttractorEntry(entry).c_str());
+  }
+  catch (const std::invalid_argument& ex) {
+    SALOME::ExceptionStruct ExDescription;
+    ExDescription.text = ex.what();
+    ExDescription.type = SALOME::BAD_PARAM;
+    ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetAttractorEntry(name)";
+    ExDescription.lineNumber = 0;
+    throw SALOME::SALOME_Exception(ExDescription);
+  }
+  catch (SALOME_Exception& ex) {
+    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+  }
+  return 0;
+}
+
+//=============================================================================
+
+void BLSURFPlugin_Hypothesis_i::UnsetEntry(const char* entry)
+{
+  ASSERT(myBaseImpl); 
+  this->GetImpl()->ClearEntry(entry);
+//  SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry << " )";
+}
+
+//=============================================================================
+
+BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetSizeMapEntries()
+{
+  ASSERT(myBaseImpl);
+  BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
+
+  const ::BLSURFPlugin_Hypothesis::TSizeMap & sizeMaps= this->GetImpl()->GetSizeMapEntries();
+  result->length( sizeMaps.size() );
+
+  ::BLSURFPlugin_Hypothesis::TSizeMap::const_iterator smIt = sizeMaps.begin();
+  for ( int i = 0 ; smIt != sizeMaps.end(); ++smIt, ++i ) {
+    string entry_sizemap = smIt->first;
+    if ( !smIt->second.empty() ) {
+      entry_sizemap += "|";
+      entry_sizemap += smIt->second;
+    }
+    result[i] = CORBA::string_dup(entry_sizemap.c_str());
+  }
+  return result._retn();
+}
+
+//=============================================================================                   
+
+BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAttractorEntries()
+{
+  ASSERT(myBaseImpl);
+  BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
+
+  const ::BLSURFPlugin_Hypothesis::TSizeMap & attractors= this->GetImpl()->GetAttractorEntries();
+  result->length( attractors.size() );
+
+  ::BLSURFPlugin_Hypothesis::TSizeMap::const_iterator atIt = attractors.begin();
+  for ( int i = 0 ; atIt != attractors.end(); ++atIt, ++i ) {
+    string entry_attractor = atIt->first;
+    if ( !atIt->second.empty() ) {
+      entry_attractor += "|";
+      entry_attractor += atIt->second;
+    }
+    result[i] = CORBA::string_dup(entry_attractor.c_str());
+  }
+  return result._retn();
+}
+
+//=============================================================================                   
+                                                                                                  
+void BLSURFPlugin_Hypothesis_i::SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps)        
+  throw (SALOME::SALOME_Exception)                                                                
+{                                                                                                 
+  ASSERT(myBaseImpl);                                                                             
+  for (int i = 0; i < sizeMaps.length(); ++i)                                                      
+  {                                                                                               
+    string entry_sizemap = sizeMaps[i].in();                                                          
+    int colonPos = entry_sizemap.find( '|' );                                                        
+    string entry, sizemap;                                                                           
+    if ( colonPos == string::npos ) // '|' separator not found                                              
+      entry = entry_sizemap;                                                                          
+    else {                                                                                        
+      entry = entry_sizemap.substr( 0, colonPos);                                                     
+      if ( colonPos < entry_sizemap.size()-1 && entry_sizemap[colonPos] != ' ')                         
+        sizemap = entry_sizemap.substr( colonPos+1 );                                                  
+    }                                                                                             
+    this->GetImpl()->SetSizeMapEntry( entry.c_str(), sizemap.c_str() );                                                
+  }                                                                                               
+}                                                                                                 
+
+//=============================================================================
+
+void BLSURFPlugin_Hypothesis_i::ClearSizeMaps()
+{
+  ASSERT(myBaseImpl);
+  this->GetImpl()->ClearSizeMaps();
+}
+
+
+//=============================================================================
+
+void BLSURFPlugin_Hypothesis_i::SetSizeMap(const GEOM::GEOM_Object_ptr GeomObj,const char* sizeMap)
+{
+  ASSERT(myBaseImpl);
+  string entry;
+  entry=GeomObj->GetStudyEntry();
+  MESSAGE("IDL : GetName : " << GeomObj->GetName());
+  MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")"); 
+  SetSizeMapEntry( entry.c_str(),sizeMap);
+}
+  
+//=============================================================================
+void BLSURFPlugin_Hypothesis_i::UnsetSizeMap(const GEOM::GEOM_Object_ptr GeomObj)
+{
+  ASSERT(myBaseImpl);
+  string entry;
+  entry=GeomObj->GetStudyEntry();
+  MESSAGE("IDL : GetName : " << GeomObj->GetName());
+  MESSAGE("IDL : UNSETSIZEMAP ( "<< entry << ")");
+  UnsetEntry( entry.c_str());
+  SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry.c_str() << " )";
+}
+
+
+void BLSURFPlugin_Hypothesis_i::SetAttractor(GEOM::GEOM_Object_ptr GeomObj, const char* attractor)
+{
+  ASSERT(myBaseImpl);
+  string entry;
+  entry=GeomObj->GetStudyEntry();
+  MESSAGE("IDL : GetName : " << GeomObj->GetName());
+  MESSAGE("IDL : SETATTRACTOR ( "<< entry << " , " << attractor << ")");
+  SetAttractorEntry( entry.c_str(),attractor);
+}
+
+void BLSURFPlugin_Hypothesis_i::UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj)
+{
+  ASSERT(myBaseImpl);
+  string entry;
+  entry=GeomObj->GetStudyEntry();
+  MESSAGE("IDL : GetName : " << GeomObj->GetName());
+  MESSAGE("IDL : UNSETATTRACTOR ( "<< entry << ")");
+  UnsetEntry( entry.c_str());
+  SMESH::TPythonDump() << _this() << ".UnsetAttractor( " << entry.c_str() << " )";
+}
+
+
+
+
+/*
+void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
+{}
+
+void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
+{}
+
+void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception)
+{}
+
+char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception)
+{}
+
+void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
+{
+  ASSERT(myBaseImpl);
+  this->GetImpl()->UnsetCustomSizeMap(entry);
+  SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
+}
+
+
+BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
+{}
+
+*/
+
+     
 //=============================================================================
 /*!
  *  BLSURFPlugin_Hypothesis_i::GetImpl
diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
index 76b826f..eef9617 100644
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
@@ -19,6 +19,7 @@
 // ---
 // File    : BLSURFPlugin_Hypothesis.hxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #ifndef _BLSURFPlugin_Hypothesis_i_HXX_
@@ -31,6 +32,7 @@
 #include "BLSURFPlugin_Hypothesis.hxx"
 
 class SMESH_Gen;
+class GEOM_Object;
 
 // BLSURFPlugin parameters hypothesis
 
@@ -98,6 +100,46 @@ class BLSURFPlugin_Hypothesis_i:
 
   void SetOptionValues(const BLSURFPlugin::string_array& options) throw (SALOME::SALOME_Exception);
 
+  void SetSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception);
+  
+  char* GetSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception);
+
+  void UnsetEntry(const char* entry);
+
+  BLSURFPlugin::string_array* GetSizeMapEntries();
+
+  void SetSizeMapEntries(const BLSURFPlugin::string_array& options) throw (SALOME::SALOME_Exception);
+
+  void SetSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap);
+
+  void UnsetSizeMap(GEOM::GEOM_Object_ptr GeomObj);
+
+  void ClearSizeMaps();
+
+
+  void SetAttractor(GEOM::GEOM_Object_ptr GeomObj, const char* attractor);
+
+  void UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj);
+
+  void SetAttractorEntry(const char* entry,const char* attractor )  throw (SALOME::SALOME_Exception);
+
+  char* GetAttractorEntry(const char* entry)  throw (SALOME::SALOME_Exception);
+
+  BLSURFPlugin::string_array* GetAttractorEntries();
+
+
+/*
+  void SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap);
+
+  void UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj);
+
+  void SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception);
+
+  char* GetCustomSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception);
+
+  BLSURFPlugin::string_array* GetCustomSizeMapEntries();
+*/
+
   // Get implementation
   ::BLSURFPlugin_Hypothesis* GetImpl();
   
diff --git a/src/BLSURFPlugin/Makefile.am b/src/BLSURFPlugin/Makefile.am
index e78b060..5e7b1b3 100644
--- a/src/BLSURFPlugin/Makefile.am
+++ b/src/BLSURFPlugin/Makefile.am
@@ -24,25 +24,27 @@
 include $(top_srcdir)/adm_local/unix/make_common_starter.am
 
 # header files 
-salomeinclude_HEADERS =
+salomeinclude_HEADERS =	\
+	BLSURFPlugin_BLSURF.hxx	\
+	BLSURFPlugin_BLSURF_i.hxx	\
+	BLSURFPlugin_Hypothesis.hxx	\
+	BLSURFPlugin_Hypothesis_i.hxx
 
 # Libraries targets
 lib_LTLIBRARIES = libBLSURFEngine.la
 
 dist_libBLSURFEngine_la_SOURCES =	\
-	BLSURFPlugin_BLSURF.hxx		\
 	BLSURFPlugin_BLSURF.cxx		\
-	BLSURFPlugin_BLSURF_i.hxx	\
 	BLSURFPlugin_BLSURF_i.cxx	\
-	BLSURFPlugin_Hypothesis.hxx	\
 	BLSURFPlugin_Hypothesis.cxx	\
-	BLSURFPlugin_Hypothesis_i.hxx	\
 	BLSURFPlugin_Hypothesis_i.cxx	\
 	BLSURFPlugin_i.cxx
 
 libBLSURFEngine_la_CPPFLAGS =	\
-        $(KERNEL_CXXFLAGS)	\
-        $(GUI_CXXFLAGS)		\
+   $(QT_INCLUDES)          \
+   $(PYTHON_INCLUDES)      \
+   $(KERNEL_CXXFLAGS)	\
+   $(GUI_CXXFLAGS)		\
 	$(MED_CXXFLAGS)		\
 	$(GEOM_CXXFLAGS)	\
 	$(CAS_CPPFLAGS)		\
@@ -51,11 +53,15 @@ libBLSURFEngine_la_CPPFLAGS =	\
 	$(CORBA_CXXFLAGS)	\
 	$(CORBA_INCLUDES)	\
 	$(BOOST_CPPFLAGS)	\
+   -I$(srcdir)/../PluginUtils  \
 	-I$(top_builddir)/idl	\
-	-I$(top_builddir)/salome_adm/unix
+	-I$(top_builddir)/salome_adm/unix 
+
+#Qt uniquement necessaire pour le getActiveStudyDocument de SMeshGuiUtils.h
 
 libBLSURFEngine_la_LDFLAGS  =			\
 	../../idl/libSalomeIDLBLSURFPLUGIN.la	\
+   ../PluginUtils/libGeomSelectionTools.la \
 	$(BLSURF_LIBS)				\
 	$(SMESH_LDFLAGS) -lSMESHimpl -lSMESHEngine -lStdMeshersEngine	\
 	$(KERNEL_LDFLAGS) -lSalomeGenericObj
diff --git a/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx b/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx
index ba14fc8..ab94476 100644
--- a/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx
+++ b/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx
@@ -1,4 +1,4 @@
-//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D
+	//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D
 //
 //  This library is free software; you can redistribute it and/or
 //  modify it under the terms of the GNU Lesser General Public
@@ -20,12 +20,14 @@
 // File    : BLSURFPluginGUI_HypothesisCreator.cxx
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
 //           & Aurelien ALLEAUME (DISTENE)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #include "BLSURFPluginGUI_HypothesisCreator.h"
 
 #include <SMESHGUI_Utils.h>
 #include <SMESHGUI_HypothesesUtils.h>
+#include <SMESHGUI_Dialog.h>
 
 #include <SUIT_Session.h>
 #include <SUIT_MessageBox.h>
@@ -48,19 +50,33 @@
 #include <QTableWidget>
 #include <QHeaderView>
 #include <QApplication>
+#include <QRadioButton>
 
+#include <LightApp_SelectionMgr.h>
+#include <SalomeApp_Application.h> 
+#include <SALOME_ListIO.hxx>
+#include <SALOME_ListIteratorOfListIO.hxx>
+
+#include <GEOM_Client.hxx>
+#include <TopoDS_Shape.hxx>
+#include <SMESH_Gen_i.hxx>
+#include <boost/shared_ptr.hpp> 
+#include <structmember.h>
+
+// #include <GeomSelectionTools.h>
 #define WITH_SIZE_BOUNDARIES
 
 enum Topology {
     FromCAD,
     Process,
     Process2
-  };
+  } ;
 
 enum PhysicalMesh
   {
     DefaultSize = 0,
-    PhysicalUserDefined
+    PhysicalUserDefined,
+    SizeMap
   };
 
 enum GeometricMesh
@@ -72,21 +88,188 @@ enum GeometricMesh
 enum {
   STD_TAB = 0,
   ADV_TAB,
+  SMP_TAB,
   OPTION_ID_COLUMN = 0,
   OPTION_NAME_COLUMN,
   OPTION_VALUE_COLUMN,
-  NB_COLUMNS
+  NB_COLUMNS,
+  SMP_ENTRY_COLUMN = 0,
+  SMP_NAME_COLUMN,
+  SMP_SIZEMAP_COLUMN,
+  SMP_NB_COLUMNS
+};
+
+enum {
+  SMP_BTNS = 0,
+//   SMP_ATTRACTOR_BTN,
+//   SMP_SEPARATOR1,
+  SMP_POINT_BTN,
+  SMP_EDGE_BTN,
+  SMP_SURFACE_BTN,
+  SMP_SEPARATOR2,
+  SMP_REMOVE_BTN,
+};
+
+/**************************************************
+ Begin initialization Python structures and objects 
+***************************************************/
+
+typedef struct {
+  PyObject_HEAD
+  int softspace;
+  std::string *out;
+  } PyStdOut;
+
+static void
+PyStdOut_dealloc(PyStdOut *self)
+{
+  PyObject_Del(self);
+}
+
+static PyObject *
+PyStdOut_write(PyStdOut *self, PyObject *args)
+{
+  char *c;
+  int l;
+  if (!PyArg_ParseTuple(args, "t#:write",&c, &l))
+    return NULL;
+
+  //std::cerr << c ;
+  *(self->out)=*(self->out)+c;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyMethodDef PyStdOut_methods[] = {
+  {"write",  (PyCFunction)PyStdOut_write,  METH_VARARGS,
+    PyDoc_STR("write(string) -> None")},
+  {NULL,    NULL}   /* sentinel */
+};
+
+static PyMemberDef PyStdOut_memberlist[] = {
+  {"softspace", T_INT,  offsetof(PyStdOut, softspace), 0,
+   "flag indicating that a space needs to be printed; used by print"},
+  {NULL} /* Sentinel */
+};
+
+static PyTypeObject PyStdOut_Type = {
+  /* The ob_type field must be initialized in the module init function
+   * to be portable to Windows without using C++. */
+  PyObject_HEAD_INIT(NULL)
+  0,                            /*ob_size*/
+  "PyOut",                      /*tp_name*/
+  sizeof(PyStdOut),             /*tp_basicsize*/
+  0,                            /*tp_itemsize*/
+  /* methods */
+  (destructor)PyStdOut_dealloc, /*tp_dealloc*/
+  0,                            /*tp_print*/
+  0,                            /*tp_getattr*/
+  0,                            /*tp_setattr*/
+  0,                            /*tp_compare*/
+  0,                            /*tp_repr*/
+  0,                            /*tp_as_number*/
+  0,                            /*tp_as_sequence*/
+  0,                            /*tp_as_mapping*/
+  0,                            /*tp_hash*/
+  0,                            /*tp_call*/
+  0,                            /*tp_str*/
+  PyObject_GenericGetAttr,      /*tp_getattro*/
+  /* softspace is writable:  we must supply tp_setattro */
+  PyObject_GenericSetAttr,      /* tp_setattro */
+  0,                            /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT,           /*tp_flags*/
+  0,                            /*tp_doc*/
+  0,                            /*tp_traverse*/
+  0,                            /*tp_clear*/
+  0,                            /*tp_richcompare*/
+  0,                            /*tp_weaklistoffset*/
+  0,                            /*tp_iter*/
+  0,                            /*tp_iternext*/
+  PyStdOut_methods,             /*tp_methods*/
+  PyStdOut_memberlist,          /*tp_members*/
+  0,                            /*tp_getset*/
+  0,                            /*tp_base*/
+  0,                            /*tp_dict*/
+  0,                            /*tp_descr_get*/
+  0,                            /*tp_descr_set*/
+  0,                            /*tp_dictoffset*/
+  0,                            /*tp_init*/
+  0,                            /*tp_alloc*/
+  0,                            /*tp_new*/
+  0,                            /*tp_free*/
+  0,                            /*tp_is_gc*/
 };
 
+PyObject * newPyStdOut( std::string& out )
+{
+  PyStdOut *self;
+  self = PyObject_New(PyStdOut, &PyStdOut_Type);
+  if (self == NULL)
+    return NULL;
+  self->softspace = 0;
+  self->out=&out;
+  return (PyObject*)self;
+}
+
+/*************************************************
+End initialization Python structures and objects 
+**************************************************/
+
+/**
+ * \brief {BLSURFPluginGUI_HypothesisCreator constructor}
+ * @param theHypType Name of the hypothesis type (here BLSURF_Parameters)
+ * 
+ * */
 BLSURFPluginGUI_HypothesisCreator::BLSURFPluginGUI_HypothesisCreator( const QString& theHypType )
   : SMESHGUI_GenericHypothesisCreator( theHypType )
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::BLSURFPluginGUI_HypothesisCreator"); 
+  this->mySMPMap.clear();
+
+  GeomToolSelected = NULL;
+  GeomToolSelected = getGeomSelectionTool();
+
+  aSel = GeomToolSelected->selectionMgr();
+
+  /* Initialize the Python interpreter */
+  if (not Py_IsInitialized())
+    throw ("Error: Python interpreter is not initialized");
+  PyGILState_STATE gstate;
+  gstate = PyGILState_Ensure();
+  
+  main_mod = NULL;
+  main_mod = PyImport_AddModule("__main__");
+  
+  main_dict = NULL;
+  main_dict = PyModule_GetDict(main_mod);
+  
+  PyRun_SimpleString("from math import *");
+  PyGILState_Release(gstate);
+
 }
 
 BLSURFPluginGUI_HypothesisCreator::~BLSURFPluginGUI_HypothesisCreator()
 {
 }
 
+/**
+ * \brief {Get or create the geom selection tool for active study}
+ * */
+GeomSelectionTools* BLSURFPluginGUI_HypothesisCreator::getGeomSelectionTool()
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::getGeomSelectionTool"); 
+  BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+  _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+  if (that->GeomToolSelected == NULL or that->GeomToolSelected->getMyStudy() != aStudy) {
+    MESSAGE("GeomToolSelected is created");
+    that->GeomToolSelected = new GeomSelectionTools(aStudy);
+  }
+  else
+    MESSAGE("GeomToolSelected already exists");
+  return that->GeomToolSelected;
+}
+
 namespace {
   inline bool isDouble( const QString& theText, const bool emptyOK=false ) {
     QString str = theText.trimmed();
@@ -99,8 +282,10 @@ namespace {
   }
 }
 
+
 bool BLSURFPluginGUI_HypothesisCreator::checkParams() const
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::checkParams"); 
   bool ok = true;
   if ( !isDouble( myPhySize->text(), false )) {
     if ( myPhySize->text().isEmpty() )
@@ -153,11 +338,49 @@ bool BLSURFPluginGUI_HypothesisCreator::checkParams() const
     h->SetOptionValues( myOptions ); // restore values
   }
 
+  // SizeMap
+  if ( ok )
+  {
+    mySizeMapTable->setFocus();
+    QApplication::instance()->processEvents();
+
+    BLSURFPlugin::BLSURFPlugin_Hypothesis_var h = BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis() );
+    BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+
+    int row = 0, nbRows = mySizeMapTable->rowCount();
+    for ( ; row < nbRows; ++row )
+    {
+      QString entry   = mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->text();
+      QString sizeMap = mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN )->text().trimmed();
+      if ( !sizeMap.isEmpty() ) {
+        if (that->sizeMapValidationFromRow(row))
+        {
+          try {
+            const char* e = entry.toLatin1().constData();
+            const char* s = that->mySMPMap[entry].toLatin1().constData();
+            h->SetSizeMapEntry( e, s );
+          }
+          catch ( const SALOME::SALOME_Exception& ex )
+          {
+            SUIT_MessageBox::critical( dlg(),
+                                       tr("SMESH_ERROR"),
+                                       ex.details.text.in() );
+            ok = false;
+          }
+        }
+        else {
+          ok = false;
+        }
+      }
+    }
+  }
+
   return ok;
 }
 
 QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::buildFrame");
   QFrame* fr = new QFrame( 0 );
   QVBoxLayout* lay = new QVBoxLayout( fr );
   lay->setMargin( 5 );
@@ -187,7 +410,7 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
   myPhysicalMesh = new QComboBox( myStdGroup );
   aStdLayout->addWidget( myPhysicalMesh, row++, 1, 1, 1 );
   QStringList physicalTypes;
-  physicalTypes << tr( "BLSURF_DEFAULT_USER" ) << tr( "BLSURF_CUSTOM_USER" );
+  physicalTypes << tr( "BLSURF_DEFAULT_USER" ) << tr( "BLSURF_CUSTOM_USER" ) << tr( "BLSURF_SIZE_MAP");
   myPhysicalMesh->addItems( physicalTypes );
 
   aStdLayout->addWidget( new QLabel( tr( "BLSURF_HPHYDEF" ), myStdGroup), row, 0, 1, 1 );
@@ -289,9 +512,54 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
   anAdvLayout->setRowStretch( 4, 5 );
   anAdvLayout->setColumnStretch( 1, 5 );
 
+  // Size Maps parameters
+  
+  mySmpGroup = new QWidget();
+  QGridLayout* anSmpLayout = new QGridLayout(mySmpGroup);
+
+  mySizeMapTable = new QTableWidget( 0, SMP_NB_COLUMNS, mySmpGroup );
+  anSmpLayout->addWidget(mySizeMapTable, 1, 0, 8, 1);
+  QStringList sizeMapHeaders;
+  sizeMapHeaders << tr( "SMP_ENTRY_COLUMN" )<< tr( "SMP_NAME_COLUMN" ) << tr( "SMP_SIZEMAP_COLUMN" ); 
+  mySizeMapTable->setHorizontalHeaderLabels(sizeMapHeaders);
+  mySizeMapTable->horizontalHeader()->hideSection( SMP_ENTRY_COLUMN );
+  mySizeMapTable->resizeColumnToContents(SMP_NAME_COLUMN);
+  mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
+  mySizeMapTable->setAlternatingRowColors(true);
+  mySizeMapTable->verticalHeader()->hide();
+
+/*
+  addAttractorButton = new QPushButton(tr("BLSURF_SM_ATTRACTOR"),mySmpGroup);
+  anSmpLayout->addWidget(addAttractorButton, SMP_ATTRACTOR_BTN, 1, 1, 1);
+
+  QFrame *line = new QFrame(mySmpGroup);
+  line->setFrameShape(QFrame::HLine);
+  line->setFrameShadow(QFrame::Sunken);
+  anSmpLayout->addWidget(line, SMP_SEPARATOR1, 1, 1, 1);
+*/
+  addSurfaceButton = new QPushButton(tr("BLSURF_SM_SURFACE"),mySmpGroup);
+  anSmpLayout->addWidget(addSurfaceButton, SMP_SURFACE_BTN, 1, 1, 1);
+
+  addEdgeButton = new QPushButton(tr("BLSURF_SM_EDGE"),mySmpGroup);
+  anSmpLayout->addWidget(addEdgeButton, SMP_EDGE_BTN, 1, 1, 1);
+
+  addPointButton = new QPushButton(tr("BLSURF_SM_POINT"),mySmpGroup);
+  anSmpLayout->addWidget(addPointButton, SMP_POINT_BTN, 1, 1, 1);
+
+  QFrame *line2 = new QFrame(mySmpGroup);
+  line2->setFrameShape(QFrame::HLine);
+  line2->setFrameShadow(QFrame::Sunken);
+  anSmpLayout->addWidget(line2, SMP_SEPARATOR2, 1, 1, 1);
+
+  removeButton = new QPushButton(tr("BLSURF_SM_REMOVE"),mySmpGroup);
+  anSmpLayout->addWidget(removeButton, SMP_REMOVE_BTN, 1, 1, 1);
+  
+
   // ---
   tab->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
-  tab->insertTab( ADV_TAB, myAdvGroup, tr( "GHS3D_ADV_ARGS" ) );
+  tab->insertTab( ADV_TAB, myAdvGroup, tr( "BLSURF_ADV_ARGS" ) );
+  tab->insertTab( SMP_TAB, mySmpGroup, tr( "BLSURF_SIZE_MAP" ) );
+
   tab->setCurrentIndex( STD_TAB );
 
   // ---
@@ -300,12 +568,19 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
   connect( addBtn->menu(),  SIGNAL( aboutToShow() ),    this, SLOT( onAddOption() ) );
   connect( addBtn->menu(),  SIGNAL( triggered( QAction* ) ), this, SLOT( onOptionChosenInPopup( QAction* ) ) );
   connect( rmBtn,           SIGNAL( clicked()),         this, SLOT( onDeleteOption() ) );
+  
+  connect(addSurfaceButton, SIGNAL(clicked()), this, SLOT(onAddMapOnSurface()));
+  connect(addEdgeButton, SIGNAL(clicked()), this, SLOT(onAddMapOnEdge()));
+  connect(addPointButton, SIGNAL(clicked()), this, SLOT(onAddMapOnPoint()));
+  connect(removeButton, SIGNAL(clicked()), this, SLOT(onRemoveMap()));
+  connect(mySizeMapTable, SIGNAL(cellChanged ( int, int  )),this,SLOT (onSetSizeMap(int,int )));
 
   return fr;
 }
 
 void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::retrieveParams");
   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
 
   BlsurfHypothesisData data;
@@ -332,7 +607,7 @@ void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const
   myAllowQuadrangles->setChecked( data.myAllowQuadrangles );
   myDecimesh->setChecked( data.myDecimesh );
   myVerbosity->setValue( data.myVerbosity );
-
+  
   if ( myOptions.operator->() ) {
     printf("retrieveParams():myOptions->length()=%d\n",myOptions->length());
     for ( int i = 0, nb = myOptions->length(); i < nb; ++i ) {
@@ -355,6 +630,29 @@ void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const
   }
   myOptionTable->resizeColumnToContents( OPTION_NAME_COLUMN );
 
+  printf("retrieveParams():that->mySMPMap.size()=%d\n",that->mySMPMap.size());
+  QMapIterator<QString, QString> i(that->mySMPMap);
+  GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
+  while (i.hasNext()) {
+    i.next();
+    const QString entry = i.key();
+    string shapeName = myGeomToolSelected->getNameFromEntry(entry.toStdString());
+    const QString sizeMap = i.value();
+    int row = mySizeMapTable->rowCount();
+    mySizeMapTable->setRowCount( row+1 );
+    mySizeMapTable->setItem( row, SMP_ENTRY_COLUMN, new QTableWidgetItem( entry ) );
+    mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->setFlags( 0 );
+    mySizeMapTable->setItem( row, SMP_NAME_COLUMN, new QTableWidgetItem( QString::fromStdString(shapeName) ) );
+    mySizeMapTable->item( row, SMP_NAME_COLUMN )->setFlags( 0 );
+    mySizeMapTable->setItem( row, SMP_SIZEMAP_COLUMN, new QTableWidgetItem( sizeMap ) );
+    mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN )->setFlags( Qt::ItemIsSelectable |
+                                                               Qt::ItemIsEditable   |
+                                                               Qt::ItemIsEnabled );
+    }
+  
+  mySizeMapTable->resizeColumnToContents( SMP_NAME_COLUMN );
+  mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
+
   // update widgets
   that->onPhysicalMeshChanged();
   that->onGeometricMeshChanged();
@@ -373,6 +671,7 @@ QString BLSURFPluginGUI_HypothesisCreator::storeParams() const
 
 bool BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo( BlsurfHypothesisData& h_data ) const
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo");
   BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
     BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis() );
 
@@ -405,11 +704,66 @@ bool BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo( BlsurfHypothesisData
   BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
   that->myOptions = h->GetOptionValues();
 
+  that->mySMPMap.clear();
+
+  // classic size maps
+  BLSURFPlugin::string_array_var mySizeMaps = h->GetSizeMapEntries();
+  MESSAGE("mySizeMaps->length() = " << mySizeMaps->length());
+  QString fullSizeMaps;
+  QStringList fullSizeMapList;
+  GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
+  for ( int i = 0;i<mySizeMaps->length(); ++i ) {
+    fullSizeMaps =  mySizeMaps[i].in();
+    MESSAGE("fullSizeMaps: " << fullSizeMaps.toStdString());
+    fullSizeMapList = fullSizeMaps.split( "|", QString::KeepEmptyParts );
+    if ( fullSizeMapList.count() > 1 ) {
+      string fullSizeMap = fullSizeMapList[1].toStdString();
+      int pos = fullSizeMap.find("return")+7;
+      QString sizeMap = QString::fromStdString(fullSizeMap.substr(pos, fullSizeMap.size()-pos));
+      that->mySMPMap[fullSizeMapList[0]] = sizeMap;
+      MESSAGE("mySMPMap[" << fullSizeMapList[0].toStdString() << "] = " << sizeMap.toStdString());
+      that->mySMPShapeTypeMap[fullSizeMapList[0]] = myGeomToolSelected->entryToShape(fullSizeMapList[0].toStdString()).ShapeType();
+      MESSAGE("mySMPShapeTypeMap[" << fullSizeMapList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[fullSizeMapList[0]]);
+    }
+  }
+
+  // custom size maps
+/*
+  BLSURFPlugin::string_array_var myCustomSizeMaps = h->GetCustomSizeMapEntries();
+  MESSAGE("myCustomSizeMaps->length() = " << myCustomSizeMaps->length());
+
+  for ( int i = 0;i<myCustomSizeMaps->length(); ++i ) {
+    QString fullCustomSizeMaps =  myCustomSizeMaps[i].in();
+    QStringList fullCustomSizeMapList = fullCustomSizeMaps.split( "|", QString::KeepEmptyParts );
+    if ( fullCustomSizeMapList.count() > 1 ) {
+      that->mySMPMap[fullCustomSizeMapList[0]] = fullCustomSizeMapList[1];
+      that->mySMPShapeTypeMap[fullCustomSizeMapList[0]] = GeomToolSelected->entryToShape(fullCustomSizeMapList[0].toStdString()).ShapeType();
+      MESSAGE("mySMPMap[" << fullCustomSizeMapList[0].toStdString() << "] = " << fullCustomSizeMapList[1].toStdString());
+      MESSAGE("mySMPShapeTypeMap[" << fullCustomSizeMapList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[fullCustomSizeMapList[0]]);
+    }
+  }
+*/
+  // attractor
+  BLSURFPlugin::string_array_var allMyAttractors = h->GetAttractorEntries();
+  MESSAGE("myAttractors->length() = " << allMyAttractors->length());
+
+  for ( int i = 0;i<allMyAttractors->length(); ++i ) {
+    QString myAttractors =  allMyAttractors[i].in();
+    QStringList myAttractorList = myAttractors.split( "|", QString::KeepEmptyParts );
+    if ( myAttractorList.count() > 1 ) {
+      that->mySMPMap[myAttractorList[0]] = myAttractorList[1];
+      that->mySMPShapeTypeMap[myAttractorList[0]] = myGeomToolSelected->entryToShape(myAttractorList[0].toStdString()).ShapeType();
+      MESSAGE("mySMPMap[" << myAttractorList[0].toStdString() << "] = " << myAttractorList[1].toStdString());
+      MESSAGE("mySMPShapeTypeMap[" << myAttractorList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[myAttractorList[0]]);
+    }
+  }
+
   return true;
 }
 
 bool BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo( const BlsurfHypothesisData& h_data ) const
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo");
   BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
     BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( hypothesis() );
 
@@ -434,7 +788,7 @@ bool BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo( const BlsurfHypothesi
     if ( h->GetVerbosity() != h_data.myVerbosity )
       h->SetVerbosity( h_data.myVerbosity );
 
-    if( (int) h_data.myPhysicalMesh == PhysicalUserDefined ) {
+    if( ((int) h_data.myPhysicalMesh == PhysicalUserDefined)||((int) h_data.myPhysicalMesh == SizeMap) ) {
       if ( h->GetPhySize() != h_data.myPhySize.toDouble() )
         h->SetPhySize( h_data.myPhySize.toDouble() );
     }
@@ -463,8 +817,43 @@ bool BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo( const BlsurfHypothesi
       h->SetGeoMax( h_data.myGeoMax.toDouble() );
 #endif
 
-    printf("storeParamsToHypo():myOptions->length()=%d\n",myOptions->length());
+    //printf("storeParamsToHypo():myOptions->length()=%d\n",myOptions->length());
     h->SetOptionValues( myOptions ); // is set in checkParams()
+
+    BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+    QMapIterator<QString,QString> i(that->mySMPMap);
+    // Iterate over each size map
+    while (i.hasNext()) {
+      i.next();
+      const QString entry = i.key();
+      const QString sizeMap = i.value();
+
+      if (sizeMap == "__TO_DELETE__") {
+        MESSAGE("Delete entry " << entry.toStdString() << " from engine");
+        h->UnsetEntry(entry.toLatin1().constData());
+      }
+      else if (sizeMap.startsWith("ATTRACTOR")) {
+        MESSAGE("SetAttractorEntry(" << entry.toStdString() << ")= " << sizeMap.toStdString());
+        h->SetAttractorEntry( entry.toLatin1().constData(), sizeMap.toLatin1().constData() );
+      }
+      else if (sizeMap.startsWith("def")) {
+        MESSAGE("SetCustomSizeMapEntry(" << entry.toStdString() << ")= " << sizeMap.toStdString());
+//        h->SetCustomSizeMapEntry( entry.toLatin1().constData(), sizeMap.toLatin1().constData() );
+      }
+      else {
+        QString fullSizeMap;
+        fullSizeMap = QString("");
+        if (that->mySMPShapeTypeMap[entry]  == TopAbs_FACE)
+          fullSizeMap = QString("def f(u,v): return ") + sizeMap;
+        else if (that->mySMPShapeTypeMap[entry]  == TopAbs_EDGE)
+          fullSizeMap = QString("def f(t): return ") + sizeMap;
+        else if (that->mySMPShapeTypeMap[entry] == TopAbs_VERTEX)
+          fullSizeMap = QString("def f(): return ") + sizeMap;
+
+        MESSAGE("SetSizeMapEntry("<<entry.toStdString()<<") = " <<fullSizeMap.toStdString());
+        h->SetSizeMapEntry( entry.toLatin1().constData(), fullSizeMap.toLatin1().constData() );
+      }
+    }
   }
   catch(const SALOME::SALOME_Exception& ex)
   {
@@ -476,6 +865,7 @@ bool BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo( const BlsurfHypothesi
 
 QString BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets( BlsurfHypothesisData& h_data ) const
 {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets");
   h_data.myName             = myName ? myName->text() : "";
   h_data.myTopology         = myTopology->currentIndex();
   h_data.myPhysicalMesh     = myPhysicalMesh->currentIndex();
@@ -526,14 +916,24 @@ QString BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets( BlsurfHypothes
         guiHyp += name + " = " + value + "; ";
     }
   }
-
-  cout << "guiHyp : " << guiHyp.toLatin1().data() << endl;
+  
+  // SizeMap
+  row = 0, nbRows = mySizeMapTable->rowCount();
+  for ( ; row < nbRows; ++row )
+  {
+      QString entry   = mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->text();
+      if ( that->mySMPMap.contains(entry) )
+        guiHyp += entry + " = " + that->mySMPMap[entry] + "; ";
+  }
+  
+  MESSAGE("guiHyp : " << guiHyp.toLatin1().data());
 
   return guiHyp;
 }
 
 void BLSURFPluginGUI_HypothesisCreator::onPhysicalMeshChanged() {
-  bool isCustom = (myPhysicalMesh->currentIndex() == PhysicalUserDefined);
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::onPhysicalMeshChanged");
+  bool isCustom = ((myPhysicalMesh->currentIndex() == PhysicalUserDefined) || (myPhysicalMesh->currentIndex() == SizeMap)) ;
   myPhySize->setEnabled(isCustom);
   myPhyMax->setEnabled(isCustom);
   myPhyMin->setEnabled(isCustom);
@@ -559,6 +959,7 @@ void BLSURFPluginGUI_HypothesisCreator::onPhysicalMeshChanged() {
 }
 
 void BLSURFPluginGUI_HypothesisCreator::onGeometricMeshChanged() {
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::onGeometricMeshChanged");
   bool isCustom = (myGeometricMesh->currentIndex() == UserDefined);
   myAngleMeshS->setEnabled(isCustom);
   myAngleMeshC->setEnabled(isCustom);
@@ -661,6 +1062,308 @@ void BLSURFPluginGUI_HypothesisCreator::onDeleteOption()
     myOptionTable->removeRow( it.previous() );
 }
 
+// **********************
+// *** BEGIN SIZE MAP ***
+// **********************
+
+
+void BLSURFPluginGUI_HypothesisCreator::onRemoveMap()
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::onRemoveMap()");
+  QList<int> selectedRows;
+  QList<QTableWidgetItem*> selected = mySizeMapTable->selectedItems();
+  QTableWidgetItem* item;
+  int row;
+  foreach( item, selected ) {
+    row = item->row();
+    if ( !selectedRows.contains( row ) ) 
+      selectedRows.append( row );
+  }
+
+  BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+
+  qSort( selectedRows );
+  QListIterator<int> it( selectedRows );
+  it.toBack();
+  while ( it.hasPrevious() ) {
+      row = it.previous();
+      QString entry = mySizeMapTable->item(row,SMP_ENTRY_COLUMN)->text();
+      if (that->mySMPMap.contains(entry))
+        that->mySMPMap[entry] = "__TO_DELETE__";
+      if (that->mySMPShapeTypeMap.contains(entry))
+        that->mySMPShapeTypeMap.remove(entry);
+      mySizeMapTable->removeRow(row );
+  }
+  mySizeMapTable->resizeColumnToContents(SMP_NAME_COLUMN);
+  mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
+}
+
+void BLSURFPluginGUI_HypothesisCreator::onSetSizeMap(int row,int col)
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::onSetSizeMap("<< row << "," << col << ")");
+  if (col == SMP_SIZEMAP_COLUMN) {
+    BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+    QString entry   = that->mySizeMapTable->item(row, SMP_ENTRY_COLUMN)->text();
+    QString sizeMap = that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->text().trimmed();
+    MESSAGE("entry: " << entry.toStdString() << ", sizeMap: " << sizeMap.toStdString());
+    if (not that->mySMPShapeTypeMap.contains(entry))
+      return;
+    if (that->mySMPMap.contains(entry))
+      if (that->mySMPMap[entry] == sizeMap)
+        return;
+    QColor* bgColor = new QColor("white");
+    QColor* fgColor = new QColor("black");
+    if (not sizeMap.isEmpty()) {
+      that->mySMPMap[entry] = sizeMap;
+      if (not sizeMapValidationFromRow(row)) {
+        bgColor->setRgb(255,0,0);
+        fgColor->setRgb(255,255,255);
+      }
+    }
+    else {
+      MESSAGE("Size map empty: reverse to precedent value" );
+      that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->setText(that->mySMPMap[entry]);
+    }
+    that->mySizeMapTable->item(row, SMP_NAME_COLUMN)->setBackground(QBrush(*bgColor));
+    that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->setBackground(QBrush(*bgColor));
+    that->mySizeMapTable->item(row, SMP_NAME_COLUMN)->setForeground(QBrush(*fgColor));
+    that->mySizeMapTable->item(row, SMP_SIZEMAP_COLUMN)->setForeground(QBrush(*fgColor));
+    mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
+  }
+}
+
+void BLSURFPluginGUI_HypothesisCreator::onAddMapOnSurface()
+{
+ insertElementType(TopAbs_FACE);
+}
+
+void BLSURFPluginGUI_HypothesisCreator::onAddMapOnEdge()
+{
+ insertElementType(TopAbs_EDGE);
+}
+
+void BLSURFPluginGUI_HypothesisCreator::onAddMapOnPoint()
+{
+ insertElementType(TopAbs_VERTEX);
+}
+
+void BLSURFPluginGUI_HypothesisCreator::insertElementType(TopAbs_ShapeEnum typeShapeAsked)
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::insertElementType()");
+
+  BLSURFPlugin::BLSURFPlugin_Hypothesis_var h =
+    BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis());
+
+  BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+
+  TopoDS_Shape S;
+  string entry, shapeName;
+//  LightApp_SelectionMgr* aSel = GeomToolSelected->selectionMgr();
+
+  SALOME_ListIO ListSelectedObjects;
+  aSel->selectedObjects(ListSelectedObjects, NULL, false );
+  if (!ListSelectedObjects.IsEmpty())
+  {
+    SALOME_ListIteratorOfListIO Object_It(ListSelectedObjects);
+    GeomSelectionTools* myGeomToolSelected = getGeomSelectionTool();
+    for (; Object_It.More(); Object_It.Next()) 
+    {
+      Handle(SALOME_InteractiveObject) anObject = Object_It.Value();
+      entry     = myGeomToolSelected->getEntryOfObject(anObject);
+      shapeName = anObject->getName();
+      S         = myGeomToolSelected->entryToShape(entry);
+      if ((! S.IsNull()) && (S.ShapeType() == typeShapeAsked)) 
+      { 
+        mySizeMapTable->setFocus();
+        QString shapeEntry;
+        shapeEntry = QString::fromStdString(entry);
+        double phySize = h->GetPhySize();
+        std::ostringstream oss;
+        oss << phySize;
+        QString sizeMap;
+        sizeMap  = QString::fromStdString(oss.str());
+        if (that->mySMPMap.contains(shapeEntry)) {
+          if (that->mySMPMap[shapeEntry] != "__TO_DELETE__") {
+            MESSAGE("Size map for shape with name(entry): "<< shapeName << "(" << entry << ")");
+            break;
+          }
+        }
+        that->mySMPMap[shapeEntry] = sizeMap;
+        that->mySMPShapeTypeMap[shapeEntry] = typeShapeAsked; 
+        int row = mySizeMapTable->rowCount() ;
+        mySizeMapTable->setRowCount( row+1 );
+        mySizeMapTable->setItem( row, SMP_ENTRY_COLUMN, new QTableWidgetItem( shapeEntry ) );
+        mySizeMapTable->item( row, SMP_ENTRY_COLUMN )->setFlags( 0 );
+        mySizeMapTable->setItem( row, SMP_NAME_COLUMN, new QTableWidgetItem( QString::fromStdString(shapeName) ) );
+        mySizeMapTable->item( row, SMP_NAME_COLUMN )->setFlags( 0 );
+        mySizeMapTable->setItem( row, SMP_SIZEMAP_COLUMN, new QTableWidgetItem( sizeMap ) );
+        mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN )->setFlags( Qt::ItemIsSelectable |Qt::ItemIsEditable   |Qt::ItemIsEnabled );
+        mySizeMapTable->resizeColumnToContents( SMP_NAME_COLUMN );
+        mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
+        mySizeMapTable->clearSelection();
+        mySizeMapTable->scrollToItem( mySizeMapTable->item( row, SMP_SIZEMAP_COLUMN ) );
+
+        if ( myPhysicalMesh->currentIndex() != SizeMap ) {
+          myPhysicalMesh->setCurrentIndex( SizeMap );
+          onPhysicalMeshChanged();
+        }
+      }
+    }
+  }
+}
+
+bool BLSURFPluginGUI_HypothesisCreator::sizeMapsValidation()
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::sizeMapsValidation()");
+  int row = 0, nbRows = mySizeMapTable->rowCount();
+  for ( ; row < nbRows; ++row )
+    if (not sizeMapValidationFromRow(row))
+      return false;
+  return true;
+}
+
+bool BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromRow(int myRow, bool displayError)
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromRow()");
+  QString myEntry   = mySizeMapTable->item( myRow, SMP_ENTRY_COLUMN )->text();
+  bool res = sizeMapValidationFromEntry(myEntry,displayError);
+  mySizeMapTable->setFocus();
+  return res; 
+}
+
+bool BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromEntry(QString myEntry, bool displayError)
+{
+  MESSAGE("BLSURFPluginGUI_HypothesisCreator::sizeMapValidationFromEntry()");
+
+  BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+     
+  if (not that->mySMPMap.contains(myEntry)) {
+    MESSAGE("Geometry with entry "<<myEntry.toStdString()<<" was not found.");
+    return false;
+  }
+  if (not that->mySMPShapeTypeMap.contains(myEntry)) {
+    MESSAGE("Shape type with entry "<<myEntry.toStdString()<<" was not found.");
+    return false;
+  }
+
+  string expr;
+
+  if (that->mySMPMap[myEntry].startsWith("def")) {
+    MESSAGE("custom function" );
+    expr = that->mySMPMap[myEntry].toStdString();
+  }
+  else if (that->mySMPMap[myEntry].startsWith("ATTRACTOR")) {
+    MESSAGE("Attractor" );
+//    if ((that->mySMPMap[myEntry].count(QRegExp("ATTRACTOR([0-9])")) != 1))
+    if ((that->mySMPMap[myEntry].count('(') != 1) or 
+        (that->mySMPMap[myEntry].count(')') != 1) or
+        (that->mySMPMap[myEntry].count(';') != 4) or
+        (that->mySMPMap[myEntry].size() == 15)){
+      if (displayError)
+        SUIT_MessageBox::warning( dlg(),"Definition of attractor : Error" ,"An attractor is defined with the following pattern: ATTRACTOR(xa;ya;za;a;b)" );
+      return false;
+    }
+    return true;
+  }
+  else {
+    // case size map is empty
+    if (that->mySMPMap[myEntry].isEmpty()) {
+      if (displayError)
+        SUIT_MessageBox::warning( dlg(),"Definition of size map : Error" , "Size map can't be empty");
+      return false;
+    }
+
+    if ( that->mySMPShapeTypeMap[myEntry] == TopAbs_FACE)
+      expr = "def f(u,v) : return " + that->mySMPMap[myEntry].toStdString();
+    else if ( that->mySMPShapeTypeMap[myEntry] == TopAbs_EDGE)
+      expr = "def f(t) : return " + that->mySMPMap[myEntry].toStdString();
+    else if ( that->mySMPShapeTypeMap[myEntry] == TopAbs_VERTEX)
+      expr = "def f() : return " + that->mySMPMap[myEntry].toStdString();
+  }
+  //assert(Py_IsInitialized());
+  if (not Py_IsInitialized())
+    throw ("Erreur: Python interpreter is not initialized");
+  PyGILState_STATE gstate;
+  gstate = PyGILState_Ensure();
+ 
+  PyObject * obj = NULL;   
+  PyObject* new_stderr = NULL;   
+  string  err_description="";
+  obj= PyRun_String(expr.c_str(), Py_file_input, main_dict, NULL);
+  if (obj == NULL){
+    fflush(stderr);
+    err_description="";
+    new_stderr=newPyStdOut(err_description);
+    PySys_SetObject("stderr", new_stderr);
+    PyErr_Print();
+    PySys_SetObject("stderr", PySys_GetObject("__stderr__"));
+    Py_DECREF(new_stderr);
+    if (displayError)
+      SUIT_MessageBox::warning( dlg(),"Definition of Python Function : Error" ,err_description.c_str() );
+    PyGILState_Release(gstate);
+    return false;
+  }
+  Py_DECREF(obj);
+   
+  PyObject * func = NULL;
+  func = PyObject_GetAttrString(main_mod, "f");
+  if ( func == NULL){
+    fflush(stderr);                                                                            
+    err_description="";                                                                        
+    new_stderr=newPyStdOut(err_description);                                         
+    PySys_SetObject("stderr", new_stderr);                                                     
+    PyErr_Print();                                                                             
+    PySys_SetObject("stderr", PySys_GetObject("__stderr__"));                                  
+    Py_DECREF(new_stderr);
+    if (displayError)
+      SUIT_MessageBox::warning( dlg(),"Python Error" ,err_description.c_str() );
+    PyGILState_Release(gstate);
+    return false;
+  }
+
+  PyGILState_Release(gstate);
+
+  MESSAGE("SizeMap expression "<<expr<<" is valid");
+
+  return true;
+}
+
+/*
+void BLSURFPluginGUI_HypothesisCreator::OnEditMapFunction(QModelIndex* index) {
+  int myRow = index->row();
+  int myColumn = index->column();
+  
+  if (myColumn == 2){
+     if (!myEditor) {
+         myEditor = new BLSURFPluginGUI_MapFunctionEditor(sizeMapModel->item(myRow,0)->text());
+	 connect(myEditor, SIGNAL(FunctionEntered(QString)), this, SLOT(FunctionLightValidation(QString)));
+     }
+     myEditor->exec();
+//      myEditor->show();
+//      myEditor->raise();
+//      myEditor->activateWindow();
+     
+
+//     BLSURFPluginGUI_MapFunctionEditor* myEditor = new BLSURFPluginGUI_MapFunctionEditor(sizeMapModel->item(myRow,0)->text());
+//     myEditor->exec();
+     QString myFunction = myEditor->GetFunctionText();
+     // FIN RECUPERATION FONCTION
+     
+     if (! myFunction.isEmpty()) {
+     
+     // MAJ DE LA MAP
+     
+     BLSURFPlugin::BLSURFPlugin_Hypothesis_var h = 
+       BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis());
+
+//     h->SetSizeMapEntry(sizeMapModel->item(myRow,1)->text().toLatin1().constData(),
+//                        item->text().toLatin1().constData());
+     h->SetSizeMapEntry(sizeMapModel->item(myRow,1)->text().toLatin1().constData(),
+                        myFunction.toLatin1().constData());
+     // FIN MAJ DE LA MAP
+     }
+  }
+}*/
  
 QString BLSURFPluginGUI_HypothesisCreator::caption() const
 {
@@ -681,3 +1384,13 @@ QString BLSURFPluginGUI_HypothesisCreator::helpPage() const
 {
   return "blsurf_hypo_page.html";
 }
+
+LightApp_SelectionMgr* BLSURFPluginGUI_HypothesisCreator::selectionMgr()
+{
+
+  SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+  if( anApp )
+    return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
+  else
+    return 0;
+}
diff --git a/src/GUI/BLSURFPluginGUI_HypothesisCreator.h b/src/GUI/BLSURFPluginGUI_HypothesisCreator.h
index 15e701e..db48e08 100644
--- a/src/GUI/BLSURFPluginGUI_HypothesisCreator.h
+++ b/src/GUI/BLSURFPluginGUI_HypothesisCreator.h
@@ -20,6 +20,7 @@
 // File    : BLSURFPluginGUI_HypothesisCreator.h
 // Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
 //           & Aurelien ALLEAUME (DISTENE)
+//           Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
 // ---
 //
 #ifndef BLSURFPLUGINGUI_HypothesisCreator_H
@@ -35,8 +36,13 @@
   #define BLSURFPLUGIN_GUI_EXPORT
 #endif
 
+#include <Python.h>
 #include <SMESHGUI_Hypotheses.h>
 #include <SALOMEconfig.h>
+#include <cstring>
+#include <map>
+#include <TopAbs_ShapeEnum.hxx>
+#include <GeomSelectionTools.h>
 #include CORBA_SERVER_HEADER(BLSURFPlugin_Algorithm)
 
 class QGroupBox;
@@ -45,21 +51,24 @@ class QComboBox;
 class QCheckBox;
 class QLineEdit;
 class QTableWidget;
+class QTableView;
+class QModelIndex;
 class QSpinBox;
 class QMenu;
 class QAction;
+class LightApp_SelectionMgr;
 
 typedef struct
 {
   int     myTopology, myVerbosity;
   int     myPhysicalMesh, myGeometricMesh;
   double  myAngleMeshS, myAngleMeshC, myGradation;
-  QString myPhySize, myGeoMin, myGeoMax, myPhyMin, myPhyMax;
-  bool    myAllowQuadrangles, myDecimesh;
+  QString myPhySize, myGeoMin, myGeoMax, myPhyMin,myPhyMax;
+  bool    myAllowQuadrangles, myDecimesh,mySmpsurface,mySmpedge,mySmppoint;
   QString myName;
-
 } BlsurfHypothesisData;
 
+
 /*!
  * \brief Class for creation of BLSURF hypotheses
 */
@@ -71,29 +80,40 @@ public:
   BLSURFPluginGUI_HypothesisCreator( const QString& );
   virtual ~BLSURFPluginGUI_HypothesisCreator();
 
-  virtual bool     checkParams() const;
-  virtual QString  helpPage() const;
+  virtual bool        checkParams() const;
+  virtual QString     helpPage() const;
+  void                insertElementType( TopAbs_ShapeEnum );
+  static LightApp_SelectionMgr* selectionMgr();
 
 protected:
-  virtual QFrame*  buildFrame    ();
-  virtual void     retrieveParams() const;
-  virtual QString  storeParams   () const;
+  virtual QFrame*     buildFrame    ();
+  virtual void        retrieveParams() const;
+  virtual QString     storeParams   () const;
   
-  virtual QString  caption() const;
-  virtual QPixmap  icon() const;
-  virtual QString  type() const;
+  virtual QString     caption() const;
+  virtual QPixmap     icon() const;
+  virtual QString     type() const;
 
 protected slots:
-  void             onPhysicalMeshChanged();
-  void             onGeometricMeshChanged();
-  void             onAddOption();
-  void             onDeleteOption();
-  void             onOptionChosenInPopup( QAction* );
+  void                onPhysicalMeshChanged();
+  void                onGeometricMeshChanged();
+  void                onAddOption();
+  void                onDeleteOption();
+  void                onOptionChosenInPopup( QAction* );
+  void                onAddMapOnSurface();
+  void                onAddMapOnEdge();
+  void                onAddMapOnPoint();
+  void                onRemoveMap();
+  void                onSetSizeMap(int,int);
 
 private:
-  bool             readParamsFromHypo( BlsurfHypothesisData& ) const;
-  QString          readParamsFromWidgets( BlsurfHypothesisData& ) const;
-  bool             storeParamsToHypo( const BlsurfHypothesisData& ) const;
+  bool                readParamsFromHypo( BlsurfHypothesisData& ) const;
+  QString             readParamsFromWidgets( BlsurfHypothesisData& ) const;
+  bool                storeParamsToHypo( const BlsurfHypothesisData& ) const;
+  bool                sizeMapsValidation();
+  bool                sizeMapValidationFromRow(int,bool displayError = true);
+  bool                sizeMapValidationFromEntry(QString,bool displayError = true);
+  GeomSelectionTools* getGeomSelectionTool();
 
 private:
   QWidget*            myStdGroup;
@@ -116,7 +136,24 @@ private:
   QSpinBox*           myVerbosity;
   QTableWidget*       myOptionTable;
 
+  QWidget             *mySmpGroup;  
+  QTableWidget        *mySizeMapTable;
+  QPushButton         *addAttractorButton;
+  QPushButton         *addSurfaceButton;
+  QPushButton         *addEdgeButton;
+  QPushButton         *addPointButton;
+  QPushButton         *removeButton;
+
+  // map =  entry , size map
+  QMap<QString, QString>          mySMPMap;
+  QMap<QString, TopAbs_ShapeEnum> mySMPShapeTypeMap;
+  GeomSelectionTools*             GeomToolSelected;
+  LightApp_SelectionMgr*          aSel;
+
   BLSURFPlugin::string_array_var myOptions;
+
+  PyObject *          main_mod;
+  PyObject *          main_dict;
 };
 
 #endif // BLSURFPLUGINGUI_HypothesisCreator_H
diff --git a/src/GUI/BLSURFPlugin_msg_en.ts b/src/GUI/BLSURFPlugin_msg_en.ts
index 0e4e862..5fb60b8 100644
--- a/src/GUI/BLSURFPlugin_msg_en.ts
+++ b/src/GUI/BLSURFPlugin_msg_en.ts
@@ -94,6 +94,58 @@
             <source>BLSURF_PHY_MESH</source>
             <translation>Physical Mesh</translation>
         </message>
+        <message>
+            <source>BLSURF_SIZE_MAP</source>
+            <translation>Size Map</translation>
+        </message>
+        <message>
+            <source>SMP_ENTRY_COLUMN</source>
+            <translation>Entry</translation>
+        </message>
+        <message>
+            <source>SMP_NAME_COLUMN</source>
+            <translation>Name</translation>
+        </message>
+        <message>
+            <source>SMP_SIZEMAP_COLUMN</source>
+            <translation>Size Map</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_SURFACE</source>
+            <translation>Add Map on Surface</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_EDGE</source>
+            <translation>Add Map on Edge</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_POINT</source>
+            <translation>Add Map on Point</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_ATTRACTOR</source>
+            <translation>Add Attractor</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_REMOVE</source>
+            <translation>Remove Map</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_SURF_VALUE</source>
+            <translation>Size on Surface(s)</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_EDGE_VALUE</source>
+            <translation>Size on Edge(s)</translation>
+        </message>
+        <message>
+            <source>BLSURF_SM_POINT_VALUE</source>
+            <translation>Size on Point(s)</translation>
+        </message>
+        <message>
+            <source>BLSURF_ADV_ARGS</source>
+            <translation>Advanced</translation>
+        </message>
         <message>
             <source>BLSURF_TITLE</source>
             <translation>Hypothesis Construction</translation>
diff --git a/src/GUI/Makefile.am b/src/GUI/Makefile.am
index 20136b4..0539f7e 100644
--- a/src/GUI/Makefile.am
+++ b/src/GUI/Makefile.am
@@ -24,14 +24,14 @@
 include $(top_srcdir)/adm_local/unix/make_common_starter.am
 
 # header files 
-salomeinclude_HEADERS =
+salomeinclude_HEADERS =	\
+	BLSURFPluginGUI_HypothesisCreator.h
 
 # Libraries targets
 lib_LTLIBRARIES = libBLSURFPluginGUI.la
 
-dist_libBLSURFPluginGUI_la_SOURCES =		\
-	BLSURFPluginGUI.cxx			\
-	BLSURFPluginGUI_HypothesisCreator.h	\
+dist_libBLSURFPluginGUI_la_SOURCES = \
+	BLSURFPluginGUI.cxx \
 	BLSURFPluginGUI_HypothesisCreator.cxx
 
 MOC_FILES = \
@@ -56,11 +56,13 @@ libBLSURFPluginGUI_la_CPPFLAGS = 	\
 	$(CORBA_INCLUDES)		\
 	$(BLSURF_INCLUDES)		\
 	-I$(srcdir)/../BLSURFPlugin	\
+	-I$(srcdir)/../PluginUtils  \
 	-I$(top_builddir)/idl		\
 	-I$(top_builddir)/salome_adm/unix
 
 libBLSURFPluginGUI_la_LDFLAGS =			\
 	../BLSURFPlugin/libBLSURFEngine.la	\
+	../PluginUtils/libGeomSelectionTools.la \
 	${SMESH_LDFLAGS} -lSMESH		\
 	$(CAS_KERNEL) $(BLSURF_LIBS)
 
diff --git a/src/Makefile.am b/src/Makefile.am
index 5768f50..2d86256 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -23,10 +23,10 @@
 #
 include $(top_srcdir)/adm_local/unix/make_common_starter.am
 
-SUBDIRS = BLSURFPlugin
+SUBDIRS = PluginUtils BLSURFPlugin
 
 if BLSURFPLUGIN_ENABLE_GUI
   SUBDIRS += GUI
 endif
 
-DIST_SUBDIRS = BLSURFPlugin GUI
\ No newline at end of file
+DIST_SUBDIRS = PluginUtils BLSURFPlugin GUI
diff --git a/src/PluginUtils/GeomSelectionTools.cxx b/src/PluginUtils/GeomSelectionTools.cxx
new file mode 100644
index 0000000..9bdad21
--- /dev/null
+++ b/src/PluginUtils/GeomSelectionTools.cxx
@@ -0,0 +1,273 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// ---
+// File    : GeomSelectionTools.cxx
+// Authors : Nicolas GEIMER (OCC)
+// ---
+//
+
+
+#include "GeomSelectionTools.h"
+#include <sstream>
+
+#include <LightApp_SelectionMgr.h> 
+#include <SalomeApp_Application.h> 
+#include <SUIT_Session.h> 
+
+#include <SALOME_ListIteratorOfListIO.hxx> 
+#include <GEOM_Client.hxx>
+#include <SMESH_Gen_i.hxx> 
+#include <SMESHGUI_Utils.h>
+#include <boost/shared_ptr.hpp> 
+
+#include <TopoDS.hxx>
+#include <BRep_Tool.hxx>
+#include <Handle_Geom_Surface.hxx>
+#include <BRepAdaptor_Surface.hxx>
+
+
+/*!
+ * Constructor 
+ * @param aStudy pointer to the Study
+ *
+ */
+GeomSelectionTools::GeomSelectionTools(_PTR(Study) aStudy)
+{
+  myStudy = aStudy;
+}
+
+/*!
+ * Accessor to the Study used by this GeomSelectionTools object
+ * @return The study used by the GeomSelectionTools class
+ */
+_PTR(Study) GeomSelectionTools::getMyStudy()
+{
+    return myStudy;
+}
+
+/*!
+ * Allows to get the selection manager from LightApp 
+ * @return A LightApp_SelectionMgr Pointer or 0 if it can't get it.
+ */
+LightApp_SelectionMgr*  GeomSelectionTools::selectionMgr()
+{
+  SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+  if (anApp)
+    return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() ); 
+  else  
+    return 0;
+}
+
+/*!
+ * Return the list of the selected Salome Interactive Object (SALOME_ListIO*)
+ * @return the list of the selected Salome Interactive Object
+ */
+SALOME_ListIO* GeomSelectionTools::getSelectedSalomeObjects()
+{
+  SALOME_ListIO* selected;
+  LightApp_SelectionMgr* aSel = selectionMgr();
+  aSel->selectedObjects( *selected, NULL, false );
+  return selected;
+}
+
+/*!
+ * Return the first selected Salome Interactive Object (Handle(Salome_InteractiveObject))
+ * @return the first selected Salome Interactive Object
+ */
+Handle(SALOME_InteractiveObject) GeomSelectionTools::getFirstSelectedSalomeObject()
+{
+  SALOME_ListIO selected;
+  LightApp_SelectionMgr* aSel = selectionMgr();
+  aSel->selectedObjects( selected, NULL, false );
+  if (!selected.IsEmpty()){  
+    SALOME_ListIteratorOfListIO anIt(selected);
+    Handle(SALOME_InteractiveObject) anIO;
+    anIO = anIt.Value();
+    return anIO;
+  }
+  return NULL;
+}
+
+/*!
+ * Return the entry of the first selected Object
+ * @return the entry of the first selected Object
+ */ 
+std::string GeomSelectionTools::getFirstSelectedEntry()
+{
+  Handle(SALOME_InteractiveObject) anIO;
+  std::string entry="";
+  anIO=GeomSelectionTools::getFirstSelectedSalomeObject();
+  return GeomSelectionTools::getEntryOfObject(anIO);
+}
+
+/*!
+ * Return the entry of a Salome Interactive Object
+ * @param anIO the Handle of the Salome Interactive Object
+ * @return the entry of the Salome Interactive Object
+ */
+std::string GeomSelectionTools::getEntryOfObject(Handle(SALOME_InteractiveObject) anIO){
+  std::string entry="";
+  _PTR(SObject) aSO = myStudy->FindObjectID(anIO->getEntry());
+  if (aSO){   
+    _PTR(SObject) aRefSObj;
+    // If selected object is a reference
+    if ( aSO->ReferencedObject( aRefSObj ))
+      entry = aRefSObj->GetID();
+    // If selected object is a reference is not a reference
+    else
+      entry= anIO->getEntry();
+  }
+  return entry;
+}
+  
+/*!
+ * Retrieve the name from the entry of the object
+ * @param entry the entry of the object
+ * @return the name of the object
+ */
+std::string GeomSelectionTools::getNameFromEntry(std::string entry){
+  std::string name = "";
+  _PTR(SObject) aSO = myStudy->FindObjectID(entry);
+  if (aSO){
+    _PTR(SObject) aRefSObj;
+    // If selected object is a reference
+    if ( aSO->ReferencedObject( aRefSObj ))
+      name = aRefSObj->GetName();
+    // If selected object is a reference is not a reference
+    else
+      name = aSO->GetName();
+   }
+  return name;
+}
+
+
+/*!
+ * Retrieve the component type of the first selected object, it manages successfully references.
+ * @return the component type of the first selected object
+ */
+std::string GeomSelectionTools::getFirstSelectedComponentDataType()
+{
+  Handle(SALOME_InteractiveObject) anIO;
+  std::string DataType="";
+  anIO=GeomSelectionTools::getFirstSelectedSalomeObject();
+  _PTR(SObject) aSO = myStudy->FindObjectID(anIO->getEntry()); 
+  if (aSO){
+    _PTR(SObject) aRefSObj;
+    // If selected object is a reference 
+    if ( aSO->ReferencedObject( aRefSObj ))
+      DataType= aRefSObj->GetFatherComponent()->ComponentDataType();
+    // If selected object is a reference is not a reference 
+    else 
+      DataType=anIO->getComponentDataType();
+ }
+ return DataType;
+}
+
+/*!
+ *  Retrieve the TopoDS shape from the first selected object
+ *  @return the TopoDS shape from the first selected object, empty TopoDS Shape if a shape is not selected.
+ */
+TopoDS_Shape GeomSelectionTools::getFirstSelectedTopoDSShape()
+{
+ Handle(SALOME_InteractiveObject) anIO;
+ anIO=GeomSelectionTools::getFirstSelectedSalomeObject();
+ return entryToShape(anIO->getEntry());
+}
+
+/*!
+ * Retrieve the TopoDS shape from the entry
+ * @return the TopoDS shape from the entry, empty TopoDS Shape if the entry does not define a shape.
+ */
+TopoDS_Shape GeomSelectionTools::entryToShape(std::string entry){
+  TopoDS_Shape S = TopoDS_Shape();
+   _PTR(SObject) aSO = myStudy->FindObjectID(entry);
+  if (aSO){ 
+    _PTR(SObject) aRefSObj;
+    GEOM::GEOM_Object_var aShape;
+    // If selected object is a reference 
+    if ( aSO->ReferencedObject( aRefSObj )){
+      if (aRefSObj->GetFatherComponent()->ComponentDataType() == "GEOM")  
+        aShape=SMESH::SObjectToInterface<GEOM::GEOM_Object>(aRefSObj);
+     }
+     // If selected object is a reference is not a reference
+     else {
+       if (  aSO->GetFatherComponent()->ComponentDataType() == "GEOM") 
+         aShape = SMESH::SObjectToInterface<GEOM::GEOM_Object>(aSO);
+     }
+     if ( !aShape->_is_nil() ){
+       if (SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen())
+          S=gen->GeomObjectToShape( aShape.in() );
+    }
+  }
+  return S;
+}
+
+/*!
+ * Gives the ShapeType of the first Selected Object, return TopAbs_SHAPE if the first selected object does not define a shape.
+ * @return the ShapeType of the first Selected Object, return TopAbs_SHAPE if the first selected object does not define a shape.
+ */
+TopAbs_ShapeEnum GeomSelectionTools:: getFirstSelectedShapeType()
+{
+ TopoDS_Shape S=getFirstSelectedTopoDSShape();
+ if (!S.IsNull())
+   return S.ShapeType();
+ else
+   return TopAbs_SHAPE;
+}
+
+/*!
+ *  Print information to std output of the face (if the first selected object is a face)
+ *  and return the OCC type of face: Plane, Cylinder,Cone, Sphere, Torus, BezierSurface,BSplineSurface, SurfaceOfRevolution,SurfaceOfExtrusion, OtherSurface
+ *  @return the OCC type of face: Plane, Cylinder,Cone, Sphere, Torus, BezierSurface,BSplineSurface, SurfaceOfRevolution,SurfaceOfExtrusion, OtherSurface
+ *  return Other_Surface if the selected face is not a face.
+ *  Information printed is :
+ *  U and V degrees
+ *  U and V number of poles
+ *  U and V number of knots
+ *  U or V is Rational ?
+ *  
+ */  
+GeomAbs_SurfaceType GeomSelectionTools::getFaceInformation()
+{
+  TopoDS_Shape S=getFirstSelectedTopoDSShape();
+  GeomAbs_SurfaceType surf_type=GeomAbs_OtherSurface ;
+  if (!S.IsNull() &&  S.ShapeType()==TopAbs_FACE){
+    TopoDS_Face f=TopoDS::Face(S);
+    Handle(Geom_Surface) surf = BRep_Tool::Surface(f);
+    BRepAdaptor_Surface surf_adap=BRepAdaptor_Surface::BRepAdaptor_Surface(f);
+    
+    /* Global Information */
+    cout << "GLOBAL INFORMATION" << endl;
+    cout << "******************" << endl;
+    stringstream buffer;
+    buffer << "Degre U : " <<  surf_adap.UDegree();
+   //conversion nécessaire pour affichage
+    cout << buffer.str() << endl;
+    cout <<  " Degre V : " <<  surf_adap.VDegree() << endl;
+    cout <<  " Nb Poles U : " <<  surf_adap.NbUPoles() << endl;
+    cout <<  " Nb Poles V : " <<  surf_adap.NbVPoles() << endl;    
+    cout <<  " Nb Noeuds U : " <<  surf_adap.NbUKnots() << endl; 
+    cout <<  " Nb Noeuds V : " <<  surf_adap.NbVKnots() << endl;
+    cout <<  " U Rationnel ? " <<  surf_adap.IsURational() << endl;
+    cout <<  " V Rationnel ? " <<  surf_adap.IsVRational() << endl;
+
+    surf_type=surf_adap.GetType();
+  }
+  return surf_type;
+}
diff --git a/src/PluginUtils/GeomSelectionTools.h b/src/PluginUtils/GeomSelectionTools.h
new file mode 100644
index 0000000..7b491fb
--- /dev/null
+++ b/src/PluginUtils/GeomSelectionTools.h
@@ -0,0 +1,67 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+// This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// ---
+// File    : GeomSelectionTools.h
+// Authors : Nicolas GEIMER (OCC)
+// ---
+
+
+
+#include "SALOMEDSClient.hxx"
+#include "SALOME_InteractiveObject.hxx"
+#include <SALOME_ListIO.hxx>
+
+#include <TopoDS_Shape.hxx>
+#include <GeomAbs_SurfaceType.hxx>
+
+class LightApp_SelectionMgr;  
+
+
+/*!
+ * The GeomSelectionTools class gives high level tools to select Geom (and other objects)
+ * A specific attention has been given to analyze selected GEOM objects.
+ *
+ * @param myStudy This class is specific to the study !
+ *
+ */
+
+class GeomSelectionTools
+{
+
+private:
+ 
+  _PTR(Study) myStudy; 
+
+public:
+
+  GeomSelectionTools(_PTR(Study)); 
+  static LightApp_SelectionMgr* selectionMgr();
+  SALOME_ListIO* getSelectedSalomeObjects();
+  Handle(SALOME_InteractiveObject) getFirstSelectedSalomeObject();
+  std::string getFirstSelectedEntry();
+  std::string getEntryOfObject(Handle(SALOME_InteractiveObject));
+  std::string getNameFromEntry(std::string);
+  std::string getFirstSelectedComponentDataType();
+  TopoDS_Shape getFirstSelectedTopoDSShape();
+  TopAbs_ShapeEnum getFirstSelectedShapeType();
+  TopoDS_Shape entryToShape(std::string );
+  GeomAbs_SurfaceType getFaceInformation();
+  _PTR(Study) getMyStudy();
+};
+
+
diff --git a/src/PluginUtils/Makefile.am b/src/PluginUtils/Makefile.am
new file mode 100644
index 0000000..6ba3947
--- /dev/null
+++ b/src/PluginUtils/Makefile.am
@@ -0,0 +1,66 @@
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# ---
+# File   : Makefile.am
+# Author : Nicolas GEIMER (OCC)
+# ---
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# header files 
+salomeinclude_HEADERS =
+
+# Libraries targets
+lib_LTLIBRARIES = libGeomSelectionTools.la
+
+dist_libGeomSelectionTools_la_SOURCES =		\
+	GeomSelectionTools.h            	\
+	GeomSelectionTools.cxx
+
+MOC_FILES = \
+	BLSURFPluginGUI_HypothesisCreator_moc.cxx
+
+nodist_GeomSelectionTools_la_SOURCES = \
+	$(MOC_FILES)
+
+# additionnal information to compil and link file
+
+libGeomSelectionTools_la_CPPFLAGS = 	\
+	$(QT_INCLUDES)			\
+	$(CAS_CPPFLAGS)			\
+	$(PYTHON_INCLUDES)		\
+	$(KERNEL_CXXFLAGS)		\
+	$(GUI_CXXFLAGS)			\
+	$(GEOM_CXXFLAGS)		\
+	$(SMESH_CXXFLAGS)		\
+	$(MED_CXXFLAGS)   		\
+	$(BOOST_CPPFLAGS)		\
+	$(CORBA_CXXFLAGS)		\
+	$(CORBA_INCLUDES)		\
+	-I$(top_builddir)/idl		\
+	-I$(top_builddir)/salome_adm/unix
+
+libGeomSelectionTools_la_LDFLAGS =		\
+	${SMESH_LDFLAGS} -lSMESH		\
+	$(CAS_KERNEL) 
+
+# resources files
+#nodist_salomeres_DATA =		\
+#	BLSURFPlugin_images.qm	\
+#	BLSURFPlugin_msg_en.qm
diff --git a/src/PluginUtils/PluginUtils.h b/src/PluginUtils/PluginUtils.h
new file mode 100644
index 0000000..69c2e86
--- /dev/null
+++ b/src/PluginUtils/PluginUtils.h
@@ -0,0 +1,28 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//  File   : PluginUtils.h
+//  Author : Nicolas GEIMER (OCC)
+//  Module : BLSURFPlugin
+//
+
+
+
diff --git a/src/PluginUtils/SizeMapPython.cxx b/src/PluginUtils/SizeMapPython.cxx
new file mode 100644
index 0000000..e69de29
diff --git a/src/PluginUtils/SizeMapPython.h b/src/PluginUtils/SizeMapPython.h
new file mode 100644
index 0000000..576fc6d
--- /dev/null
+++ b/src/PluginUtils/SizeMapPython.h
@@ -0,0 +1 @@
+#include <Python.h>
-- 
2.39.2