From 4e93dcde5c19eb5a127072496eabdfd4fbe10d6e Mon Sep 17 00:00:00 2001
From: asozinov <alexey.sozinov@opencascade.com>
Date: Mon, 28 Nov 2022 11:28:09 +0300
Subject: [PATCH] bos 32359 - Adaptation of SHAPER model

---
 CMakeLists.txt                                |   2 +
 src/CTestTestfileInstall.cmake                |   1 +
 src/Config/plugins.xml.in                     |   2 +
 src/SAMConverter/CMakeLists.txt               |  48 ++++
 src/SAMConverter/SAMConverter.py              |  51 ++++
 .../SAMConverter_ConvertConstraints.py        |  70 +++++
 .../SAMConverter_ConvertPrimitives.py         |  93 +++++++
 .../SAMConverter_ConvertSketch.py             |  68 +++++
 src/SAMConverter/SAMConverter_Logger.py       |   4 +
 .../SAMConverter_SuggestConstraintsFeature.py | 171 ++++++++++++
 src/SAMConverter/SAMConverter_msg_fr.ts       |  15 ++
 src/SAMConverter/Test/CMakeLists.txt          |  45 ++++
 .../Test/CTestTestfileInstall.cmake           |  31 +++
 .../Test/TestSAMConverter_Angle.py            |  43 +++
 src/SAMConverter/Test/TestSAMConverter_Arc.py |  94 +++++++
 .../Test/TestSAMConverter_Circle.py           |  63 +++++
 .../Test/TestSAMConverter_Constraints.py      |  46 ++++
 .../Test/TestSAMConverter_Distance.py         |  73 +++++
 .../Test/TestSAMConverter_Geometrical.py      | 253 ++++++++++++++++++
 .../TestSAMConverter_HorisontalDistance.py    | 101 +++++++
 .../Test/TestSAMConverter_Length.py           |  48 ++++
 .../Test/TestSAMConverter_Line.py             |  69 +++++
 .../Test/TestSAMConverter_Point.py            |  59 ++++
 .../Test/TestSAMConverter_Primitives.py       |  16 ++
 .../Test/TestSAMConverter_Radius.py           |  46 ++++
 .../Test/TestSAMConverter_Sketch.py           |   1 +
 .../Test/TestSAMConverter_VerticalDistance.py | 100 +++++++
 src/SAMConverter/Test/tests.set               |  35 +++
 src/SAMConverter/doc/SAMConverter.rst         |  15 ++
 .../doc/images/suggest_dialog.png             | Bin 0 -> 68563 bytes
 .../doc/suggestConstraintsFeature.rst         |  15 ++
 .../icons/suggest_constraints.png             | Bin 0 -> 477 bytes
 src/SAMConverter/plugin-SAM.xml               |  12 +
 src/SAMConverterAPI/CMakeLists.txt            |  91 +++++++
 src/SAMConverterAPI/SAMConverterAPI.h         |  37 +++
 src/SAMConverterAPI/SAMConverterAPI.i         |  41 +++
 .../SAMConverterAPI_SAMConverter.cpp          |  29 ++
 .../SAMConverterAPI_SAMConverter.h            |  38 +++
 src/SAMConverterAPI/SAMConverterAPI_swig.h    |  27 ++
 src/SketchPlugin/plugin-Sketch.xml            |   2 +-
 40 files changed, 1954 insertions(+), 1 deletion(-)
 create mode 100644 src/SAMConverter/CMakeLists.txt
 create mode 100644 src/SAMConverter/SAMConverter.py
 create mode 100644 src/SAMConverter/SAMConverter_ConvertConstraints.py
 create mode 100644 src/SAMConverter/SAMConverter_ConvertPrimitives.py
 create mode 100644 src/SAMConverter/SAMConverter_ConvertSketch.py
 create mode 100644 src/SAMConverter/SAMConverter_Logger.py
 create mode 100644 src/SAMConverter/SAMConverter_SuggestConstraintsFeature.py
 create mode 100644 src/SAMConverter/SAMConverter_msg_fr.ts
 create mode 100644 src/SAMConverter/Test/CMakeLists.txt
 create mode 100644 src/SAMConverter/Test/CTestTestfileInstall.cmake
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Angle.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Arc.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Circle.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Constraints.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Distance.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Geometrical.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_HorisontalDistance.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Length.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Line.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Point.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Primitives.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Radius.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_Sketch.py
 create mode 100644 src/SAMConverter/Test/TestSAMConverter_VerticalDistance.py
 create mode 100644 src/SAMConverter/Test/tests.set
 create mode 100644 src/SAMConverter/doc/SAMConverter.rst
 create mode 100644 src/SAMConverter/doc/images/suggest_dialog.png
 create mode 100644 src/SAMConverter/doc/suggestConstraintsFeature.rst
 create mode 100644 src/SAMConverter/icons/suggest_constraints.png
 create mode 100644 src/SAMConverter/plugin-SAM.xml
 create mode 100644 src/SAMConverterAPI/CMakeLists.txt
 create mode 100644 src/SAMConverterAPI/SAMConverterAPI.h
 create mode 100644 src/SAMConverterAPI/SAMConverterAPI.i
 create mode 100644 src/SAMConverterAPI/SAMConverterAPI_SAMConverter.cpp
 create mode 100644 src/SAMConverterAPI/SAMConverterAPI_SAMConverter.h
 create mode 100644 src/SAMConverterAPI/SAMConverterAPI_swig.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b28b840f7..6d5592ff9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -197,6 +197,7 @@ ADD_SUBDIRECTORY (src/GeomValidators)
 ADD_SUBDIRECTORY (src/FiltersPlugin)
 ADD_SUBDIRECTORY (src/InitializationPlugin)
 ADD_SUBDIRECTORY (src/ParametersPlugin)
+ADD_SUBDIRECTORY (src/SAMConverter)
 ADD_SUBDIRECTORY (src/PythonAddons)
 ADD_SUBDIRECTORY (src/PythonAPI)
 # High Level C++/Python API
@@ -213,6 +214,7 @@ ADD_SUBDIRECTORY (src/SketchAPI)
 ADD_SUBDIRECTORY (src/GDMLAPI)
 ADD_SUBDIRECTORY (src/ConnectorAPI)
 ADD_SUBDIRECTORY (src/FiltersAPI)
+ADD_SUBDIRECTORY (src/SAMConverterAPI)
 # Tests
 ADD_SUBDIRECTORY (test.API/SHAPER)
 
diff --git a/src/CTestTestfileInstall.cmake b/src/CTestTestfileInstall.cmake
index b9e1c1ebf..591d5ca18 100644
--- a/src/CTestTestfileInstall.cmake
+++ b/src/CTestTestfileInstall.cmake
@@ -44,6 +44,7 @@ SUBDIRS(ConnectorAPI
         Config
         ExchangeAPI
         ModelGeomAlgo
+        SAMConverter
         Locale
         test_API
 )
diff --git a/src/Config/plugins.xml.in b/src/Config/plugins.xml.in
index 7c23b377e..c3452b99a 100644
--- a/src/Config/plugins.xml.in
+++ b/src/Config/plugins.xml.in
@@ -15,6 +15,8 @@
   <plugin library="SketchPlugin" configuration="plugin-SketchCopy.xml"/>
   <plugin script="ConnectorPlugin" configuration="plugin-Connector.xml" dependency="GEOM"/>
   <plugin library="ParametersPlugin" configuration="plugin-Parameters.xml"/>
+  <plugin script="SAMConverter" configuration="plugin-SAM.xml"/>
+  <!--<plugin script="SAMConverter" configuration="plugin-SAM.xml" dependency="SAM"/>-->
 @DEFAULT_SOLVER@
 <!--
 @ALL_SOLVERS@
diff --git a/src/SAMConverter/CMakeLists.txt b/src/SAMConverter/CMakeLists.txt
new file mode 100644
index 000000000..e4988d8e4
--- /dev/null
+++ b/src/SAMConverter/CMakeLists.txt
@@ -0,0 +1,48 @@
+# Copyright (C) 2014-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+INCLUDE(Common)
+INCLUDE(UnitTest)
+
+SET(PYTHON_FILES
+    SAMConverter.py
+    SAMConverter_SuggestConstraintsFeature.py
+    SAMConverter_ConvertSketch.py
+    SAMConverter_ConvertPrimitives.py
+    SAMConverter_ConvertConstraints.py
+    SAMConverter_Logger.py
+)
+
+SET(XML_RESOURCES
+  plugin-SAM.xml
+)
+
+SET(TEXT_RESOURCES
+    SAMConverter_msg_fr.ts
+)
+
+SOURCE_GROUP ("Resource Files" FILES ${TEXT_RESOURCES})
+
+ADD_CUSTOM_TARGET(SAMConverter SOURCES ${PYTHON_FILES} ${XML_RESOURCES} ${TEXT_RESOURCES})
+
+INSTALL(FILES ${PYTHON_FILES} DESTINATION ${SHAPER_INSTALL_PYTHON_FILES})
+INSTALL(FILES ${XML_RESOURCES} ${TEXT_RESOURCES} DESTINATION ${SHAPER_INSTALL_XML_RESOURCES})
+INSTALL(DIRECTORY icons/ DESTINATION ${SHAPER_INSTALL_XML_RESOURCES}/icons/SAMConverter)
+
+ADD_SUBDIRECTORY(Test)
\ No newline at end of file
diff --git a/src/SAMConverter/SAMConverter.py b/src/SAMConverter/SAMConverter.py
new file mode 100644
index 000000000..4c57c3b47
--- /dev/null
+++ b/src/SAMConverter/SAMConverter.py
@@ -0,0 +1,51 @@
+# Copyright (C) 2014-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+## @package Plugins
+#  Python plugin for working with SAM format
+
+import ModelAPI
+
+from SAMConverter_SuggestConstraintsFeature import SuggestConstraintsFeature
+
+## @ingroup Plugins
+#  The main class for management the construction features as plugin.
+class SAMConverter(ModelAPI.ModelAPI_Plugin):
+
+    ## The constructor.
+    def __init__(self):
+        ModelAPI.ModelAPI_Plugin.__init__(self)
+        pass
+
+    ## Creates the feature objects of this plugin by the feature string ID.
+    def createFeature(self, theFeatureID):
+        if theFeatureID == SuggestConstraintsFeature.ID():
+            return SuggestConstraintsFeature().__disown__()
+        else:
+            print("SAMConverter: No such feature %s" % theFeatureID)
+
+## The plugin created on module importing (from c++)
+isSHAPER_SUGGESTION_GENERATOR = True
+#TODO
+if isSHAPER_SUGGESTION_GENERATOR:
+    plugin = SAMConverter()
+    ## Main session of the application
+    aSession = ModelAPI.ModelAPI_Session.get()
+    aSession.registerPlugin(plugin)
+    pass
diff --git a/src/SAMConverter/SAMConverter_ConvertConstraints.py b/src/SAMConverter/SAMConverter_ConvertConstraints.py
new file mode 100644
index 000000000..f6bbec7c3
--- /dev/null
+++ b/src/SAMConverter/SAMConverter_ConvertConstraints.py
@@ -0,0 +1,70 @@
+from sam.catalog_constraint import *
+
+import math
+
+from SketchAPI import *
+from SAMConverter_Logger import logger
+
+
+def get_params_value(entity):
+    try :
+        value_attr = entity.feature().real("ConstraintValue")
+        if value_attr is not None:
+            # Constraint value is negative in following cases:
+            # For horizontal distance: if first primitive is to the right of the second
+            # For vertical distance: if first primitive is to the above of the second
+            # For angle: if the angle is counted counterclockwise
+            if "Distance" in entity.getKind() or "Angle" in entity.getKind():
+                return abs(value_attr.value())
+            return value_attr.value()
+    except Exception as e :
+        logger.info(f'Problem with constraint parameters: {e}')
+    return None
+
+class ShapertoSAMConstraints:
+
+    def convert(entity, refs):
+        entity_type = entity.getKind()
+        if entity_type == 'SketchConstraintAngle':
+            return Angle(references = refs, angle = get_params_value(entity))
+
+        if entity_type == 'SketchConstraintCoincidence':
+            return Coincident(references = refs)
+
+        if entity_type == 'SketchConstraintDistance':
+            return Distance(references = refs, distance_min = get_params_value(entity))
+
+        if entity_type == 'SketchConstraintDistanceHorizontal':
+            return HorizontalDistance(references = refs, distance_min = get_params_value(entity))
+
+        if entity_type == 'SketchConstraintDistanceVertical':
+            return VerticalDistance(references = refs, distance_min = get_params_value(entity))
+
+        if entity_type == 'SketchConstraintEqual':
+            return Equal(references = refs)
+
+        if entity_type == 'SketchConstraintHorizontal':
+            return Horizontal(references = refs)
+
+        if entity_type == 'SketchConstraintMiddle' :
+            return Midpoint(references = refs)
+
+        if entity_type == 'SketchConstraintParallel' :
+            return Parallel(references = refs)
+
+        if entity_type == 'SketchConstraintPerpendicular' :
+            return Perpendicular(references = refs)
+
+        if entity_type == 'SketchConstraintTangent' :
+            return Tangent(references = refs)
+
+        if entity_type == 'SketchConstraintVertical':
+            return Vertical(references = refs)
+
+        if entity_type == 'SketchConstraintRadius':
+            return Radius(references = refs, radius = get_params_value(entity))
+
+        if entity_type == 'SketchConstraintLength':
+            return Length(references = refs, length = get_params_value(entity))
+
+        return None
diff --git a/src/SAMConverter/SAMConverter_ConvertPrimitives.py b/src/SAMConverter/SAMConverter_ConvertPrimitives.py
new file mode 100644
index 000000000..4abb0e6ca
--- /dev/null
+++ b/src/SAMConverter/SAMConverter_ConvertPrimitives.py
@@ -0,0 +1,93 @@
+from sam.catalog_primitive import Arc, Line, Circle, Point
+
+import math
+
+from ModelAPI import *
+from SketchAPI import *
+from GeomAPI import *
+from SAMConverter_Logger import logger
+
+def convert_angle(angle):
+    a =  int(angle / 360)
+    if math.fabs(angle)  >= 360. :
+        return angle - a * 360
+    else :
+        return angle
+
+class ShapertoSAMPrimitive:
+
+    def convert(entity):
+        entity_type = entity.getKind()
+        if entity_type == 'SketchPoint':
+            return ShapertoSAMPrimitive.convert_point(entity)
+        if entity_type == 'SketchArc':
+            return ShapertoSAMPrimitive.convert_arc(entity)
+        if entity_type == 'SketchCircle':
+            return ShapertoSAMPrimitive.convert_circle(entity)
+        if entity_type == 'SketchLine':
+            return ShapertoSAMPrimitive.convert_line(entity)
+        if entity_type == 'SketchProjection':
+            return ShapertoSAMPrimitive.convert_projection(entity)
+        if entity_type == 'SketchIntersection':
+            return ShapertoSAMPrimitive.convert_intersection(entity)
+        return None, {}
+
+    def check_construction(entity):
+        auxAttr = entity.auxiliary()
+        return auxAttr is not None and auxAttr.value()
+
+    def convert_point(entity):
+        feat = SketchAPI_Point(entity)
+        p1 = feat.coordinates()
+        return Point(status_construction= ShapertoSAMPrimitive.check_construction(entity), point = [p1.x(), p1.y()]), {}
+
+    def convert_line(entity):
+        feat = SketchAPI_Line(entity)
+
+        p1 = feat.startPoint()
+        p2 = feat.endPoint()
+        line = Line(status_construction=ShapertoSAMPrimitive.check_construction(entity), pnt1= [p1.x(), p1.y()], pnt2= [p2.x(), p2.y()])
+        return line, {(p1.x(), p1.y(), feat.name()) : line.pnt1, (p2.x(), p2.y(), feat.name()) : line.pnt2}
+
+    def convert_circle(entity):
+        feat = SketchAPI_Circle(entity)
+        c = feat.center()
+        radius = feat.radius()
+
+        circle =  Circle(status_construction=ShapertoSAMPrimitive.check_construction(entity),
+                        center = [c.x(), c.y()],
+                        radius= radius.value())#feat.radius().value())
+        return circle, {(c.x(), c.y(), feat.name()) : circle.center}
+
+    def convert_arc(entity):
+        status = ShapertoSAMPrimitive.check_construction(entity)
+        feat = SketchAPI_Arc(entity)
+        c = feat.center()
+        s = entity.defaultResult()
+        edge = GeomAPI_Edge(s.shape())
+        a0,a1 = edge.getRange()
+        start_angle = convert_angle(math.degrees(a0))
+        end_angle = convert_angle(math.degrees(a1))
+
+        arc = Arc(status_construction=status,
+                        center = [c.x(), c.y()],
+                        radius= feat.radius().value(),
+                        angles= [start_angle, end_angle])
+        arc.add_points_startend()
+        return arc, {(c.x(), c.y(), feat.name()) : arc.center}
+
+    # Not need convert to SAM
+    def convert_intersection(entity):
+        return None, {}
+
+    # Not need convert to SAM
+    def convert_projection(entity):
+        feature_feat = entity.feature()
+        feat =  ModelAPI.objectToFeature(feature_feat)
+        attr = feat.refattr("ProjectedFeature")
+
+        proj_feat = ModelAPI_Feature.feature(attr.object())
+        proj_entity = SketchAPI_SketchEntity(proj_feat)
+        entity_type = proj_entity.getKind()
+
+        return None, {}
diff --git a/src/SAMConverter/SAMConverter_ConvertSketch.py b/src/SAMConverter/SAMConverter_ConvertSketch.py
new file mode 100644
index 000000000..f59889b57
--- /dev/null
+++ b/src/SAMConverter/SAMConverter_ConvertSketch.py
@@ -0,0 +1,68 @@
+from SAMConverter_Logger import logger
+
+from SAMConverter_ConvertPrimitives import ShapertoSAMPrimitive
+from SAMConverter_ConvertConstraints import ShapertoSAMConstraints
+from sam.sketch import Sketch
+
+from ModelAPI import *
+from SketchAPI import *
+from GeomDataAPI import *
+
+def convert_sketch(sketch: object): # a shaper sketch
+
+	dictionary = {}
+	exchange_sketch = Sketch()
+
+	mapping = {}
+	# Add the primitives
+	for sub in sketch.features().list():
+		feat =  ModelAPI.objectToFeature(sub)
+
+		if feat is not None :
+			entity = SketchAPI_SketchEntity(feat)
+			entity_type = entity.getKind()
+
+			convert, update_mapping = ShapertoSAMPrimitive.convert(entity)
+			if convert is not None:
+				mapping[entity.name()] = convert
+
+			mapping.update(update_mapping)
+
+			if convert is not None:
+				exchange_sketch.add(convert)
+				dictionary[convert] = entity
+
+	logger.debug(f'Mapping; {mapping}')
+
+	# Add the constraints
+	sketchFeature = featureToCompositeFeature(sketch.feature())
+	n = sketchFeature.numberOfSubs()
+	for i in range(n):
+		entity = sketchFeature.subFeature(i)
+		entity_type = entity.getKind()
+		print(entity_type)
+
+		if 'Constraint' in entity_type :
+			if entity_type == 'SuggestConstraints':
+				continue
+			refs = []
+			print(entity_type)
+			l_attributs = [entity.refattr("ConstraintEntityA"), entity.refattr("ConstraintEntityB"),
+						entity.refattr("ConstraintEntityC"), entity.refattr("ConstraintEntityD")]
+			for ref in l_attributs:
+				if ref is None: continue
+				if ref.isObject():
+					attr = ModelAPI_Feature.feature(ref.object())
+					refs.append(mapping[attr.name()])
+
+				else :
+					attr = ref.attr()
+					owner = objectToFeature(attr.owner())
+					elt = geomDataAPI_Point2D(attr).pnt()
+					refs.append(mapping.get((elt.x(), elt.y(), owner.name()), owner.name()))
+
+			convert = ShapertoSAMConstraints.convert(entity, refs)
+			exchange_sketch.add(convert)
+			dictionary[convert] = entity
+
+	return exchange_sketch, dictionary
diff --git a/src/SAMConverter/SAMConverter_Logger.py b/src/SAMConverter/SAMConverter_Logger.py
new file mode 100644
index 000000000..2a3f3b144
--- /dev/null
+++ b/src/SAMConverter/SAMConverter_Logger.py
@@ -0,0 +1,4 @@
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger()
diff --git a/src/SAMConverter/SAMConverter_SuggestConstraintsFeature.py b/src/SAMConverter/SAMConverter_SuggestConstraintsFeature.py
new file mode 100644
index 000000000..f8cb0fb42
--- /dev/null
+++ b/src/SAMConverter/SAMConverter_SuggestConstraintsFeature.py
@@ -0,0 +1,171 @@
+# Copyright (C) 2014-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+## @package Plugins
+#  SuggestConstraintsFeature class definition
+
+from SAMConverter_ConvertSketch import *
+from SAMConverter_ConvertPrimitives import *
+from SAMConverter_ConvertConstraints import *
+
+import ModelAPI
+import EventsAPI
+
+from SketchAPI import *
+import salome
+
+from salome.shaper import model
+
+import os
+
+def createErrorMessage(nonConvertablePrimitive, nonConvertableConstraint):
+    devMessage = f'Primitives and constraints are incompatible with the SAM format. The sequence therefore cannot be translated.\n'
+    if len(nonConvertablePrimitive) > 0:
+        devMessage = devMessage + f'List of primitives not compatible with SAM: {nonConvertablePrimitive}'
+    if len(nonConvertableConstraint) > 0:
+         devMessage = devMessage + f'List of constraints not compatible with SAM: {nonConvertableConstraint}'
+    ### For users
+    userMessage = f'Impossible to apply the suggested constraints.'
+    if len(nonConvertablePrimitive) == 0:
+        userMessage = userMessage + f'The constraints {nonConvertableConstraint} are not currently taken into account by the model.'
+    elif len(nonConvertableConstraint) == 0:
+        userMessage = userMessage + f'The primitives: {nonConvertablePrimitive} are not currently taken into account by the model.'
+    else:
+        userMessage = userMessage + "SuggestConstraints", f'The primitives: {nonConvertablePrimitive} and constraints {nonConvertableConstraint} are not currently taken into account by the model.'
+
+    return userMessage, devMessage
+
+## @ingroup Plugins
+#  Feature to suggest constraints using a Machine Learning model
+class SuggestConstraintsFeature(ModelAPI.ModelAPI_Feature):
+
+    ## The constructor.
+    def __init__(self):
+        ModelAPI.ModelAPI_Feature.__init__(self)
+        pass
+
+    @staticmethod
+    ## Export kind. Static.
+    def ID():
+        return "SuggestConstraints"
+
+    ## Returns the kind of a feature.
+    def getKind(self):
+        return SuggestConstraintsFeature.ID()
+
+    ## True: This feature is action: has no property panel and executes immediately.
+    ## False: Otherwise.
+    def isAction(self):
+        return False
+        #TODO
+        #return True
+
+    def isMacro(self):
+        """
+        Override Feature.isMacro().
+        Suggest constraint feature is macro: removes itself on the creation transaction finish.
+        """
+        return True
+
+    ## Init attributes
+    def initAttributes(self):
+        pass
+
+    ## Check that sketch can convert in SAM format
+    def isConvertedSketch(self):
+        # this elements is compability with SAM format
+        avaliable_elements = [ # Constraints
+                              'SketchConstraintAngle',
+                              'SketchConstraintCoincidence',
+                              'SketchConstraintDistance',
+                              'SketchConstraintDistanceHorizontal',
+                              'SketchConstraintDistanceVertical',
+                              'SketchConstraintEqual',
+                              'SketchConstraintHorizontal',
+                              'SketchConstraintMiddle',
+                              'SketchConstraintParallel',
+                              'SketchConstraintPerpendicular',
+                              'SketchConstraintTangent',
+                              'SketchConstraintVertical',
+                              'SketchConstraintRadius',
+                              'SketchConstraintLength',
+                              # Primitives
+                              'SketchPoint',
+                              'SketchArc',
+                              'SketchCircle',
+                              'SketchLine']
+
+        additional_elements = [# Next entities not compability with SAM, but it's avaliable elements
+                              'SketchProjection',
+                              'SketchIntersectionPoint',
+                              # skip this elements (not primitive/constraint)
+                              'SketchMultiRotation',
+                              'SketchMultiTranslation']
+
+        nonConvertablePrimitive = []
+        nonConvertableConstraint = []
+
+        # Iterate by all features from Sketch
+        for sub in self.Sketch.features().list():
+            feat =  ModelAPI.objectToFeature(sub)
+            if feat is None :
+                continue
+
+            entity = SketchAPI_SketchEntity(feat)
+            entity_type = entity.getKind()
+            if entity_type == 'SuggestConstraints':
+                continue
+            if not entity_type in avaliable_elements and not entity_type in additional_elements:
+                if 'Constraint' in entity_type :
+                    nonConvertableConstraint.append(entity_type)
+                else:
+                    nonConvertablePrimitive.append(entity_type)
+        return nonConvertablePrimitive, nonConvertableConstraint
+
+    ## convert result in SAM format
+    def convertToSAM(self):
+        ## Check that all primitives and constraints is compability with SAM
+        nonConvertablePrimitive, nonConvertableConstraint = self.isConvertedSketch()
+        if len(nonConvertablePrimitive) > 0 or len(nonConvertableConstraint) > 0 :
+            userMessage, devMessage = createErrorMessage(nonConvertablePrimitive, nonConvertableConstraint)
+            logger.debug(self.getKind(), devMessage)
+            EventsAPI.Events_InfoMessage(self.getKind(), userMessage, self).send()
+            return None
+
+        self.exchange_elements, self.dictionary = convert_sketch(self.Sketch)
+        print(self.dictionary)
+        print("-------------\n\n")
+        print(self.exchange_elements)
+        pass
+
+    ## Exports all shapes and groups into the GEOM module.
+    def execute(self):
+        ## Find skecth
+        aSession = ModelAPI.ModelAPI_Session.get()
+        aPartSet = aSession.moduleDocument()
+        self.Part = model.activeDocument()
+        for feat in self.Part.allFeatures():
+            if feat.getKind() == "Sketch":
+                self.Sketch = SketchAPI_Sketch(feat)
+                break
+
+        self.convertToSAM()
+        # TODO: Lot3 and Lot4
+
+        pass
diff --git a/src/SAMConverter/SAMConverter_msg_fr.ts b/src/SAMConverter/SAMConverter_msg_fr.ts
new file mode 100644
index 000000000..0a0273ba9
--- /dev/null
+++ b/src/SAMConverter/SAMConverter_msg_fr.ts
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.0" language="fr_FR">
+  <context>
+    <name>SketchToSAMConverter</name>
+    <message>
+      <source>Primitives and constraints are incompatible with the SAM format. The sequence therefore cannot be translated. List of primitives not compatible with SAM: % 1. List of constraints not compatible with SAM: %2 </source>
+      <translation>Les primitives et les contraintes sont incompatibles avec le format SAM. La séquence ne peut donc pas être traduite. Liste des primitives non compatibles avec SAM: %1. Liste des contraintes non compatibles avec SAM: %2 </translation>
+    </message>
+    <message>
+      <source>Impossible to apply the suggested constraints. The primitives: %1 and constraints %2 are not currently taken into account by the model.</source>
+      <translation>Impossible d'appliquer les contraintes proposées. Les primitives : %1 et les contraintes %2 ne sont actuellement pas prises en compte par le modèle</translation>
+    </message>
+  </context>
+</TS>
diff --git a/src/SAMConverter/Test/CMakeLists.txt b/src/SAMConverter/Test/CMakeLists.txt
new file mode 100644
index 000000000..6860ac008
--- /dev/null
+++ b/src/SAMConverter/Test/CMakeLists.txt
@@ -0,0 +1,45 @@
+# Copyright (C) 2014-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+INCLUDE(tests.set)
+
+SET(TEST_INSTALL_DIRECTORY "${SALOME_SHAPER_INSTALL_TESTS}/SAMConverter")
+
+SALOME_GENERATE_TESTS_ENVIRONMENT(tests_env)
+
+
+FOREACH(tfile ${TEST_NAMES})
+  SET(TEST_NAME ${COMPONENT_NAME}_${tfile})
+  ADD_TEST(NAME ${TEST_NAME}
+           COMMAND ${PYTHON_EXECUTABLE} -B ${CMAKE_CURRENT_SOURCE_DIR}/testme.py ${CMAKE_CURRENT_SOURCE_DIR}/${tfile}.py)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES ENVIRONMENT "${tests_env};SHAPER_UNIT_TEST_IN_PROGRESS=1")
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+ENDFOREACH()
+
+# salome test
+FOREACH(tfile ${TEST_NAMES})
+  INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${tfile}.py
+          DESTINATION ${TEST_INSTALL_DIRECTORY})
+ENDFOREACH()
+
+INSTALL(FILES CTestTestfileInstall.cmake
+  DESTINATION ${TEST_INSTALL_DIRECTORY}
+  RENAME CTestTestfile.cmake)
+
+INSTALL(FILES tests.set DESTINATION ${TEST_INSTALL_DIRECTORY})
diff --git a/src/SAMConverter/Test/CTestTestfileInstall.cmake b/src/SAMConverter/Test/CTestTestfileInstall.cmake
new file mode 100644
index 000000000..798d8a908
--- /dev/null
+++ b/src/SAMConverter/Test/CTestTestfileInstall.cmake
@@ -0,0 +1,31 @@
+# Copyright (C) 2016-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+INCLUDE(tests.set)
+
+SET(COMPONENT_NAME SHAPER)
+SET(PYTHON_TEST_DRIVER "$ENV{KERNEL_ROOT_DIR}/bin/salome/appliskel/python_test_driver.py")
+SET(TIMEOUT        300)
+
+
+FOREACH(tfile ${TEST_NAMES})
+  SET(TEST_NAME ${COMPONENT_NAME}_${tfile})
+  ADD_TEST(${TEST_NAME} python ${PYTHON_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+ENDFOREACH()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Angle.py b/src/SAMConverter/Test/TestSAMConverter_Angle.py
new file mode 100644
index 000000000..bd4e3969d
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Angle.py
@@ -0,0 +1,43 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConvertAngle(unittest.TestCase):
+
+    def test_convert_angle_Line_Line(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Add primitives
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLine_2 = Sketch_1.addLine(-3.9, 1., 8, 0.5)
+        SketchCoincident = Sketch_1.setAngle(SketchLine_1.result(), SketchLine_2.result(), 40)
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_line2, _ = ShapertoSAMPrimitive.convert(SketchLine_2)
+        sam_constraint = ShapertoSAMConstraints.convert(SketchCoincident, refs = [sam_line1, sam_line2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'ANGLE')
+
+        # Check Angle value
+        self.assertEqual(sam_constraint.angle, 40)
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_line2)
diff --git a/src/SAMConverter/Test/TestSAMConverter_Arc.py b/src/SAMConverter/Test/TestSAMConverter_Arc.py
new file mode 100644
index 000000000..69e61baca
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Arc.py
@@ -0,0 +1,94 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertPrimitives import *
+
+
+from salome.shaper import model
+from sam.catalog_primitive import Arc, Line, Circle, Point
+from math import sqrt, acos, degrees, fabs
+
+
+
+
+def compute_parameter(center_x, center_y, start_x, start_y, end_x, end_y):
+    center  = (center_x, center_y)
+
+    # First step, translate the arc such that center became the origin
+    start_2_x = start_x - center_x
+    start_2_y = start_y - center_y
+    end_2_x = end_x - center_x
+    end_2_y = end_y - center_y
+
+    # Compute radius
+    radius_s = sqrt(start_2_x*start_2_x + start_2_y*start_2_y)
+    radius_e = sqrt(end_2_x*end_2_x + end_2_y*end_2_y)
+
+    # Compute start angle start and end
+    angle_s = convert_angle(degrees(acos(start_2_x/radius_s)))
+    angle_e = convert_angle(degrees(acos(end_2_x/radius_e)))
+
+    return center, (radius_s, radius_e), (angle_s, angle_e)
+
+class TestConvertArc(unittest.TestCase):
+
+    def test_convert_arc(self):
+
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchArc
+        SketchArc_1 = Sketch_1.addArc(0, 0, 0, 10, 10, 0, False) # center x, center y, start x, start y, endx, endy
+        SketchArc_2 = Sketch_1.addArc(5., 1, 5.5, 1, 5, 1.5, False)
+        SketchArc_2.setAuxiliary(True)
+        model.do()
+        model.end()
+
+        # Test 1 : SketchArc_1
+        sam_arc, mapping_info = ShapertoSAMPrimitive.convert(SketchArc_1)
+
+        # - Verify the circle information
+        center, (radius_s, radius_e), (angle_s, angle_e) = compute_parameter(0, 0, 0, 10, 10, 0) # compute expected parms
+        self.assertAlmostEqual(radius_e, radius_s, delta = 10e-5)
+        self.assertEqual(sam_arc.radius, radius_e)
+        self.assertEqual(sam_arc.center.x, center[0])
+        self.assertEqual(sam_arc.center.y, center[1])
+        self.assertEqual(sam_arc.angle_start, angle_s)
+        self.assertEqual(sam_arc.angle_end, angle_e)
+        self.assertEqual(sam_arc.radian, False)
+        self.assertEqual(sam_arc.is_construction(), False)
+
+        # - Verify the mapping information
+        self.assertIn((0.0, 0.0, 'SketchArc_1'), mapping_info)
+        self.assertEqual(str(mapping_info[(0.0, 0.0, 'SketchArc_1')]), 'Point P(0.0, 0.0)')
+
+        # Test 2 : SketchArc_2
+        sam_arc, mapping_info = ShapertoSAMPrimitive.convert(SketchArc_2)
+
+        # - Verify the circle information
+        center, (radius_s, radius_e), (angle_s, angle_e) = compute_parameter(5., 1, 5.5, 1, 5, 1.5) # compute expected parms
+        self.assertAlmostEqual(radius_e, radius_s, delta = 10e-5)
+        self.assertAlmostEqual(sam_arc.radius, radius_e, delta = 10e-2)
+        self.assertEqual(sam_arc.center.x, center[0])
+        self.assertEqual(sam_arc.center.y, center[1])
+        self.assertEqual(convert_angle(sam_arc.angle_start), angle_s)
+        self.assertEqual(convert_angle(sam_arc.angle_end), angle_e)
+        self.assertEqual(sam_arc.radian, False)
+        self.assertEqual(sam_arc.is_construction(), True)
+
+
+        # - Verify the mapping information
+        self.assertIn((5.0, 1.0, 'SketchArc_2'), mapping_info)
+        self.assertEqual(str(mapping_info[(5.0, 1.0, 'SketchArc_2')]), 'Point P(5.0, 1.0)')
+
+        if salome.sg.hasDesktop():
+            salome.sg.updateObjBrowser()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Circle.py b/src/SAMConverter/Test/TestSAMConverter_Circle.py
new file mode 100644
index 000000000..6aed96aa4
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Circle.py
@@ -0,0 +1,63 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertPrimitives import *
+
+
+from salome.shaper import model
+from sam.catalog_primitive import Arc, Line, Circle, Point
+
+
+class TestConvertCircle(unittest.TestCase):
+
+    def test_convert_circle(self):
+
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchCircle_1 = Sketch_1.addCircle(1., 0, 30)
+        SketchCircle_2 = Sketch_1.addCircle(10., 4, 50)
+        SketchCircle_2.setAuxiliary(True)
+        model.do()
+        model.end()
+
+        # Test 1 : SketchCircle_1
+        sam_circle, mapping_info = ShapertoSAMPrimitive.convert(SketchCircle_1)
+
+        # - Verify the circle information
+        self.assertEqual(sam_circle.radius, 30.0)
+        self.assertEqual(sam_circle.center.x, 1.)
+        self.assertEqual(sam_circle.center.y, 0.)
+        self.assertEqual(sam_circle.is_construction(), False)
+
+        # Verify the mapping information
+        self.assertIn((1.0, 0.0, 'SketchCircle_1'), mapping_info)
+        self.assertEqual(str(mapping_info[(1.0, 0.0, 'SketchCircle_1')]), 'Point P(1.0, 0.0)')
+
+        # Test 2 : SketchCircle_2
+        sam_circle, mapping_info = ShapertoSAMPrimitive.convert(SketchCircle_2)
+
+        # - Verify the circle information
+        self.assertEqual(sam_circle.radius, 50.0)
+        self.assertEqual(sam_circle.center.x, 10.)
+        self.assertEqual(sam_circle.center.y, 4.)
+        self.assertEqual(sam_circle.is_construction(), True)
+
+        # Verify the mapping information
+        self.assertIn((10.0, 4.0, 'SketchCircle_2'), mapping_info)
+        self.assertEqual(str(mapping_info[(10.0, 4.0, 'SketchCircle_2')]), 'Point P(10.0, 4.0)')
+
+
+        self.assertTrue(True)
+        if salome.sg.hasDesktop():
+            salome.sg.updateObjBrowser()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Constraints.py b/src/SAMConverter/Test/TestSAMConverter_Constraints.py
new file mode 100644
index 000000000..0782f8b7e
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Constraints.py
@@ -0,0 +1,46 @@
+from TestSAMConverter_Angle import TestConvertAngle
+from TestSAMConverter_Distance import TestConvertDistance
+from TestSAMConverter_Geometrical import TestConvertGeometrical
+from TestSAMConverter_HorisontalDistance import TestConverHorizontalDistance
+from TestSAMConverter_Length import TestConvertLength
+from TestSAMConverter_Radius import TestConvertRadius
+from TestSAMConverter_VerticalDistance import TestConvertVerticalDistance
+
+### convert angle test
+angle_test = TestConvertAngle()
+#angle_test.test_convert_angle()
+angle_test.test_convert_angle_Line_Line()
+
+### convert distance test
+dist_test = TestConvertDistance()
+dist_test.test_convert_distance_Point_Line()
+dist_test.test_convert_distance_Point_Point()
+
+### convert horizontal distance
+hDist_test = TestConverHorizontalDistance()
+hDist_test.test_convert_distance_Point_Circle()
+hDist_test.test_convert_distance_Point_Line()
+hDist_test.test_convert_distance_Point_Point()
+
+### convert vertical distance
+vDist_test = TestConvertVerticalDistance()
+vDist_test.test_convert_distance_Point_Circle()
+vDist_test.test_convert_distance_Point_Line()
+vDist_test.test_convert_distance_Point_Point()
+
+### convert geometrical constraints test
+geom_test = TestConvertGeometrical()
+geom_test.test_convert_coincidence()
+geom_test.test_convert_equal()
+geom_test.test_convert_horizontal()
+geom_test.test_convert_midpoint()
+geom_test.test_convert_parallel()
+geom_test.test_convert_perpendicular()
+geom_test.test_convert_tangent()
+geom_test.test_convert_vertical()
+
+len_test = TestConvertLength()
+len_test.test_convert_length()
+
+rad_test = TestConvertRadius()
+rad_test.test_convert_radius()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Distance.py b/src/SAMConverter/Test/TestSAMConverter_Distance.py
new file mode 100644
index 000000000..1d7b3a7c2
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Distance.py
@@ -0,0 +1,73 @@
+import unittest
+
+import salome
+salome.standalone()
+from SketchAPI import *
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConvertDistance(unittest.TestCase):
+
+    def test_convert_distance_Point_Point(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchPoint
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchPoint_2 = Sketch_1.addPoint(4., 0)
+        constraint = Sketch_1.setDistance(SketchAPI_Point(SketchPoint_1).coordinates(), SketchAPI_Point(SketchPoint_2).coordinates(), 2, True)
+        model.do()
+        model.end()
+
+        sam_point1, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_point2, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_2)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point1, sam_point2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point1)
+        self.assertEqual(sam_constraint.references[1], sam_point2)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 2)
+
+
+    def test_convert_distance_Point_Line(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchPoint and SketchLine
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        constraint = Sketch_1.setDistance(SketchAPI_Point(SketchPoint_1).coordinates(), SketchLine_1.result(), 2, True)
+        model.do()
+        model.end()
+
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point, sam_line])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point)
+        self.assertEqual(sam_constraint.references[1], sam_line)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 2)
diff --git a/src/SAMConverter/Test/TestSAMConverter_Geometrical.py b/src/SAMConverter/Test/TestSAMConverter_Geometrical.py
new file mode 100644
index 000000000..57621716e
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Geometrical.py
@@ -0,0 +1,253 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConvertGeometrical(unittest.TestCase):
+
+    def test_convert_coincidence(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchLine
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLine_2 = Sketch_1.addLine(-3.9, 1., 8, 0.5)
+        SketchCoincident = Sketch_1.setCoincident(SketchLine_1.endPoint(), SketchLine_2.startPoint())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_line2, _ = ShapertoSAMPrimitive.convert(SketchLine_2)
+        sam_constraint = ShapertoSAMConstraints.convert(SketchCoincident, refs = [sam_line1, sam_line2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'COINCIDENT')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_line2)
+
+        # Check references
+        # - Verify the line 1 information
+        self.assertEqual(sam_line1.pnt1.x, 3.9)
+        self.assertEqual(sam_line1.pnt1.y, 0.)
+        self.assertEqual(sam_line1.pnt2.x, 8)
+        self.assertEqual(sam_line1.pnt2.y, 0.)
+        self.assertEqual(sam_line1.is_construction(), False)
+
+        # - Verify the line 2 information
+        self.assertEqual(sam_line2.pnt1.x, 8.0)
+        self.assertEqual(sam_line2.pnt1.y, 0.)
+        self.assertEqual(sam_line2.pnt2.x, 8)
+        self.assertEqual(sam_line2.pnt2.y, 0.5)
+        self.assertEqual(sam_line2.is_construction(), False)
+
+    def test_convert_equal(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchLine
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLine_2 = Sketch_1.addLine(-3.9, 1., 8, 0.5)
+        constraint = Sketch_1.setEqual(SketchLine_1.result(), SketchLine_2.result())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_line2, _ = ShapertoSAMPrimitive.convert(SketchLine_2)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_line1, sam_line2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'EQUAL')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_line2)
+
+
+        # Check references
+        # - Verify the line 1 information
+        #TODO: The coordinates may differ from expected, but length of line is equal
+        #self.assertAlmostEqual(sam_line1.pnt1.x, 3.678, delta = 10e-3)
+        #self.assertEqual(sam_line1.pnt1.y, 0.)
+        #self.assertAlmostEqual(sam_line1.pnt2.x, 10.846, delta=10e-3)
+        #self.assertEqual(sam_line1.pnt2.y, 0.)
+        self.assertEqual(sam_line1.is_construction(), False)
+
+        # - Verify the line 2 information
+        #self.assertAlmostEqual(sam_line2.pnt1.x, -1.531, delta=10e-3)
+        #self.assertAlmostEqual(sam_line2.pnt1.y, 0.900, delta=10e-3)
+        #self.assertAlmostEqual(sam_line2.pnt2.x, 5.631, delta=10e-3)
+        #self.assertAlmostEqual(sam_line2.pnt2.y, 0.599, delta = 10e-3)
+        self.assertEqual(sam_line2.is_construction(), False)
+
+
+    def test_convert_horizontal(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchLine
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 1)
+        constraint = Sketch_1.setHorizontal(SketchLine_1.result())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_line1])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'HORIZONTAL')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+
+        # Check references
+        # - Verify the line 1 information
+        self.assertEqual(sam_line1.pnt1.x, 3.9)
+        self.assertEqual(sam_line1.pnt1.y, 0.)
+        self.assertEqual(sam_line1.pnt2.x, 8)
+        self.assertEqual(sam_line1.pnt2.y, 0.)
+        self.assertEqual(sam_line1.is_construction(), False)
+
+
+    def test_convert_midpoint(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchLine and SketchCircle
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchCircle_1 = Sketch_1.addCircle(-17.41591725155751, 16.35177358773851, 29.02191596082682)
+        constraint = Sketch_1.setMiddlePoint(SketchLine_1.result(), SketchCircle_1.center())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_circle, _ = ShapertoSAMPrimitive.convert(SketchCircle_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_line1, sam_circle])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'MIDPOINT')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_circle)
+
+    def test_convert_parallel(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLine_2 = Sketch_1.addLine(-3.9, 1., 8, 0.5)
+        SketchCoincident = Sketch_1.setParallel(SketchLine_1.endPoint(), SketchLine_2.startPoint())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_line2, _ = ShapertoSAMPrimitive.convert(SketchLine_2)
+        sam_constraint = ShapertoSAMConstraints.convert(SketchCoincident, refs = [sam_line1, sam_line2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'PARALLEL')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_line2)
+
+    def test_convert_perpendicular(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLine_2 = Sketch_1.addLine(-3.9, 1., 8, 0.5)
+        SketchCoincident = Sketch_1.setPerpendicular(SketchLine_1.endPoint(), SketchLine_2.startPoint())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_line2, _ = ShapertoSAMPrimitive.convert(SketchLine_2)
+        sam_constraint = ShapertoSAMConstraints.convert(SketchCoincident, refs = [sam_line1, sam_line2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'PERPENDICULAR')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_line2)
+
+
+    def test_convert_tangent(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchCircle_1 = Sketch_1.addCircle(-17.41591725155751, 16.35177358773851, 29.02191596082682)
+        constraint = Sketch_1.setTangent(SketchLine_1.result(), SketchCircle_1.center())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_circle, _ = ShapertoSAMPrimitive.convert(SketchCircle_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_line1, sam_circle])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'TANGENT')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
+        self.assertEqual(sam_constraint.references[1], sam_circle)
+
+
+    def test_convert_vertical(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        constraint = Sketch_1.setVertical(SketchLine_1.result())
+        model.do()
+        model.end()
+
+        sam_line1, _ = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_line1])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'VERTICAL')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_line1)
diff --git a/src/SAMConverter/Test/TestSAMConverter_HorisontalDistance.py b/src/SAMConverter/Test/TestSAMConverter_HorisontalDistance.py
new file mode 100644
index 000000000..c1f075469
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_HorisontalDistance.py
@@ -0,0 +1,101 @@
+import unittest
+
+import salome
+salome.standalone()
+from SketchAPI import *
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConverHorizontalDistance(unittest.TestCase):
+
+    def test_convert_distance_Point_Point(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchPoint_2 = Sketch_1.addPoint(4., 0)
+        constraint = Sketch_1.setHorizontalDistance(SketchPoint_1.coordinates(), SketchPoint_2.coordinates(), 10)
+        model.do()
+        model.end()
+
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_2)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point, sam_line])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'HORIZONTAL_DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point)
+        self.assertEqual(sam_constraint.references[1], sam_line)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 10.0)
+
+
+    def test_convert_distance_Point_Line(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        constraint = Sketch_1.setHorizontalDistance(SketchPoint_1.coordinates(), SketchLine_1.startPoint(), 2)
+        model.do()
+        model.end()
+
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point, sam_line])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'HORIZONTAL_DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point)
+        self.assertEqual(sam_constraint.references[1], sam_line)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 2)
+
+    def test_convert_distance_Point_Circle(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchCircle_1 = Sketch_1.addCircle(-17.41591725155751, 16.35177358773851, 29.02191596082682)
+        constraint = Sketch_1.setHorizontalDistance( SketchPoint_1.coordinates(), SketchCircle_1.center(), 6)
+        model.do()
+        model.end()
+
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_circle, mapping_info = ShapertoSAMPrimitive.convert(SketchCircle_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point, sam_circle])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'HORIZONTAL_DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point)
+        self.assertEqual(sam_constraint.references[1], sam_circle)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 6)
diff --git a/src/SAMConverter/Test/TestSAMConverter_Length.py b/src/SAMConverter/Test/TestSAMConverter_Length.py
new file mode 100644
index 000000000..6f1e7549f
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Length.py
@@ -0,0 +1,48 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConvertLength(unittest.TestCase):
+
+    def test_convert_length(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLength_1 = Sketch_1.setLength(SketchLine_1.result(), 10)
+        model.do()
+        model.end()
+
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_length = ShapertoSAMConstraints.convert(SketchLength_1, refs = [sam_line])
+
+        # Check type
+        self.assertEqual(sam_length.get_name(), 'LENGTH')
+
+        # Check Length value
+        self.assertEqual(sam_length.length, 10)
+
+        # Check references
+        # - Verify the line information
+        ref_sam_line = sam_length.references[0] # Check that it is the same instance object
+        self.assertEqual(sam_line, ref_sam_line)
+        #TODO: X coordinate may differ from expected, but length is correct
+        #self.assertAlmostEqual(ref_sam_line.pnt1.x, 0.828, delta=10e-4) # - temporarily commented line
+        self.assertEqual(ref_sam_line.pnt1.y, 0.)
+        #self.assertAlmostEqual(ref_sam_line.pnt2.x, 10.828, delta=10e-4) # - temporarily commented line
+        self.assertEqual(ref_sam_line.pnt2.y, 0.)
+        self.assertEqual(ref_sam_line.is_construction(), False)
diff --git a/src/SAMConverter/Test/TestSAMConverter_Line.py b/src/SAMConverter/Test/TestSAMConverter_Line.py
new file mode 100644
index 000000000..2355c3955
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Line.py
@@ -0,0 +1,69 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertPrimitives import *
+
+
+from salome.shaper import model
+from sam.catalog_primitive import Arc, Line, Circle, Point
+
+
+class TestConvertLine(unittest.TestCase):
+
+    def test_convert_line(self):
+
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchLine
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        SketchLine_2 = Sketch_1.addLine(0., 0, 1., 1)
+        SketchLine_2.setAuxiliary(True)
+        model.do()
+        model.end()
+
+        # Test 1 : SketchLine_1
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchLine_1)
+
+        # - Verify the line information
+        self.assertEqual(sam_line.pnt1.x, 3.9)
+        self.assertEqual(sam_line.pnt1.y, 0.)
+        self.assertEqual(sam_line.pnt2.x, 8)
+        self.assertEqual(sam_line.pnt2.y, 0.)
+        self.assertEqual(sam_line.is_construction(), False)
+
+        # - Verify the mapping information
+        self.assertIn((3.9, 0.0, 'SketchLine_1'), mapping_info)
+        self.assertIn((8.0, 0.0, 'SketchLine_1'), mapping_info)
+        self.assertEqual(str(mapping_info[(3.9, 0.0, 'SketchLine_1')]), 'Point P(3.9, 0.0)')
+        self.assertEqual(str(mapping_info[(8.0, 0.0, 'SketchLine_1')]), 'Point P(8.0, 0.0)')
+
+        # Test 1 : SketchLine_2
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchLine_2)
+
+        # - Verify the line information
+        self.assertEqual(sam_line.pnt1.x, 0.)
+        self.assertEqual(sam_line.pnt1.y, 0.)
+        self.assertEqual(sam_line.pnt2.x, 1.)
+        self.assertEqual(sam_line.pnt2.y, 1.)
+        self.assertEqual(sam_line.is_construction(), True)
+
+        # - Verify the mapping information
+        self.assertIn((0., 0.0, 'SketchLine_2'), mapping_info)
+        self.assertIn((1., 1., 'SketchLine_2'), mapping_info)
+        self.assertEqual(str(mapping_info[(0., 0.0, 'SketchLine_2')]), 'Point P(0.0, 0.0)')
+        self.assertEqual(str(mapping_info[(1., 1., 'SketchLine_2')]), 'Point P(1.0, 1.0)')
+
+
+        self.assertTrue(True)
+        if salome.sg.hasDesktop():
+            salome.sg.updateObjBrowser()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Point.py b/src/SAMConverter/Test/TestSAMConverter_Point.py
new file mode 100644
index 000000000..ad551b0f1
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Point.py
@@ -0,0 +1,59 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertPrimitives import *
+
+
+from salome.shaper import model
+from sam.catalog_primitive import Arc, Line, Circle, Point
+
+
+class TestConvertPoint(unittest.TestCase):
+
+    def test_convert_point(self):
+
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchPoint
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchPoint_2 = Sketch_1.addPoint(10., 4)
+        SketchPoint_2.setAuxiliary(True)
+        model.do()
+        model.end()
+
+        # Test 1 : SketchPoint_1
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+
+        # - Verify the point information
+        self.assertEqual(sam_point.x, 1.)
+        self.assertEqual(sam_point.y, 0.)
+        self.assertEqual(sam_point.is_construction(), False)
+
+        # Verify the mapping information
+        self.assertDictEqual(mapping_info, {})
+
+        # Test 2 : SketchPoint_2
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_2)
+
+        # - Verify the point information
+        self.assertEqual(sam_point.x, 10.)
+        self.assertEqual(sam_point.y, 4.)
+        self.assertEqual(sam_point.is_construction(), True)
+
+        # Verify the mapping information
+        self.assertDictEqual(mapping_info, {})
+
+
+        self.assertTrue(True)
+        if salome.sg.hasDesktop():
+            salome.sg.updateObjBrowser()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Primitives.py b/src/SAMConverter/Test/TestSAMConverter_Primitives.py
new file mode 100644
index 000000000..f8010871d
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Primitives.py
@@ -0,0 +1,16 @@
+from TestSAMConverter_Arc import TestConvertArc
+from TestSAMConverter_Circle import TestConvertCircle
+from TestSAMConverter_Line import TestConvertLine
+from TestSAMConverter_Point import TestConvertPoint
+
+line = TestConvertLine()
+line.test_convert_line()
+
+point = TestConvertPoint()
+point.test_convert_point()
+
+arc = TestConvertArc()
+arc.test_convert_arc()
+
+cir = TestConvertCircle()
+cir.test_convert_circle()
diff --git a/src/SAMConverter/Test/TestSAMConverter_Radius.py b/src/SAMConverter/Test/TestSAMConverter_Radius.py
new file mode 100644
index 000000000..1deb20421
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Radius.py
@@ -0,0 +1,46 @@
+import unittest
+
+import salome
+salome.standalone()
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConvertRadius(unittest.TestCase):
+
+    def test_convert_radius(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchCircle
+        SketchCircle_1 = Sketch_1.addCircle(0, 0, 30)
+        SketchRadius_1 = Sketch_1.setRadius(SketchCircle_1.results()[1], 40)
+        model.do()
+        model.end()
+
+        sam_circle, mapping_info = ShapertoSAMPrimitive.convert(SketchCircle_1)
+        sam_radius = ShapertoSAMConstraints.convert(SketchRadius_1, refs = [sam_circle])
+
+        # Check type
+        self.assertEqual(sam_radius.get_name(), 'RADIUS')
+
+        # Check Radius value
+        self.assertEqual(sam_radius.radius, 40)
+
+        # Check references
+        # - Verify the circle information
+        ref_sam_circle = sam_radius.references[0] # Check that it is the same instance object
+        self.assertEqual(sam_circle, ref_sam_circle)
+        self.assertEqual(ref_sam_circle.radius, 40.0)
+        self.assertEqual(ref_sam_circle.center.x, 0.)
+        self.assertEqual(ref_sam_circle.center.y, 0.)
+        self.assertEqual(ref_sam_circle.is_construction(), False)
diff --git a/src/SAMConverter/Test/TestSAMConverter_Sketch.py b/src/SAMConverter/Test/TestSAMConverter_Sketch.py
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_Sketch.py
@@ -0,0 +1 @@
+
diff --git a/src/SAMConverter/Test/TestSAMConverter_VerticalDistance.py b/src/SAMConverter/Test/TestSAMConverter_VerticalDistance.py
new file mode 100644
index 000000000..97e2388ad
--- /dev/null
+++ b/src/SAMConverter/Test/TestSAMConverter_VerticalDistance.py
@@ -0,0 +1,100 @@
+import unittest
+
+import salome
+salome.standalone()
+from SketchAPI import *
+
+import sys
+sys.path.append('sam')
+
+from SAMConverter_Logger import logger
+from SAMConverter_ConvertConstraints import *
+from SAMConverter_ConvertPrimitives import *
+
+from salome.shaper import model
+
+class TestConvertVerticalDistance(unittest.TestCase):
+
+    def test_convert_distance_Point_Point(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchPoint
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchPoint_2 = Sketch_1.addPoint(4., 0)
+        constraint = Sketch_1.setVerticalDistance(SketchPoint_1.coordinates(), SketchPoint_2.coordinates(), 10)
+        model.do()
+        model.end()
+
+        sam_point1, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_point2, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_2)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point1, sam_point2])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'VERTICAL_DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point1)
+        self.assertEqual(sam_constraint.references[1], sam_point2)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 10.0)
+
+
+    def test_convert_distance_Point_Line(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchPoint and SketchLine
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchLine_1 = Sketch_1.addLine(3.9, 0, 8, 0)
+        constraint = Sketch_1.setVerticalDistance(SketchPoint_1.coordinates(), SketchLine_1.startPoint(), 2)
+        model.do()
+        model.end()
+
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_line, mapping_info = ShapertoSAMPrimitive.convert(SketchLine_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point, sam_line])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'VERTICAL_DISTANCE')
+
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point)
+        self.assertEqual(sam_constraint.references[1], sam_line)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 2)
+
+    def test_convert_distance_Point_Circle(self):
+        model.begin()
+        partSet = model.moduleDocument()
+
+        ### Create Sketch
+        Sketch_1 = model.addSketch(partSet, model.defaultPlane("XOY"))
+
+        ### Create SketchPoint and SketchCircle
+        SketchPoint_1 = Sketch_1.addPoint(1., 0)
+        SketchCircle_1 = Sketch_1.addCircle(-17.41591725155751, 16.35177358773851, 29.02191596082682)
+        constraint = Sketch_1.setVerticalDistance( SketchPoint_1.coordinates(), SketchCircle_1.center(), 6)
+        model.do()
+        model.end()
+
+        sam_point, mapping_info = ShapertoSAMPrimitive.convert(SketchPoint_1)
+        sam_circle, mapping_info = ShapertoSAMPrimitive.convert(SketchCircle_1)
+        sam_constraint = ShapertoSAMConstraints.convert(constraint, refs = [sam_point, sam_circle])
+
+        # Check type
+        self.assertEqual(sam_constraint.get_name(), 'VERTICAL_DISTANCE')
+        # Check references
+        self.assertEqual(sam_constraint.references[0], sam_point)
+        self.assertEqual(sam_constraint.references[1], sam_circle)
+
+        # Check value
+        self.assertEqual(sam_constraint.distance_min, 6)
diff --git a/src/SAMConverter/Test/tests.set b/src/SAMConverter/Test/tests.set
new file mode 100644
index 000000000..86799645c
--- /dev/null
+++ b/src/SAMConverter/Test/tests.set
@@ -0,0 +1,35 @@
+# Copyright (C) 2021-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+SET(TEST_NAMES
+           TestSAMConverter_Angle
+           TestSAMConverter_Arc
+           TestSAMConverter_Circle
+           TestSAMConverter_Constraints
+           TestSAMConverter_Distance
+           TestSAMConverter_Geometrical
+           TestSAMConverter_HorisontalDistance
+           TestSAMConverter_Length
+           TestSAMConverter_Line
+           TestSAMConverter_Point
+           TestSAMConverter_Primitives
+           TestSAMConverter_Radius
+           TestSAMConverter_Sketch
+           TestSAMConverter_VerticalDistance
+)
diff --git a/src/SAMConverter/doc/SAMConverter.rst b/src/SAMConverter/doc/SAMConverter.rst
new file mode 100644
index 000000000..abe01e341
--- /dev/null
+++ b/src/SAMConverter/doc/SAMConverter.rst
@@ -0,0 +1,15 @@
+
+.. _sAMPlugin:
+
+SAM plug-in
+================
+
+SAM plug-in implements features for Sketch conversion to SAM format and to call Suggest Constraints macro.
+
+It provides the following features:
+
+.. toctree::
+   :titlesonly:
+   :maxdepth: 1
+
+   suggestConstraintsFeature.rst
diff --git a/src/SAMConverter/doc/images/suggest_dialog.png b/src/SAMConverter/doc/images/suggest_dialog.png
new file mode 100644
index 0000000000000000000000000000000000000000..02c810b12ccbb4a85d0e6719c4b3b3e033e78619
GIT binary patch
literal 68563
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
S#kYHZ{*snZ5U&t54E!H=m6;g;

literal 0
HcmV?d00001

diff --git a/src/SAMConverter/doc/suggestConstraintsFeature.rst b/src/SAMConverter/doc/suggestConstraintsFeature.rst
new file mode 100644
index 000000000..e1457ce25
--- /dev/null
+++ b/src/SAMConverter/doc/suggestConstraintsFeature.rst
@@ -0,0 +1,15 @@
+
+.. _suggestConstraints:
+
+Suggest constraint
+================
+
+This feature provide TODO!!!!!
+Activate only in edit mode.
+
+The following property panel appears:
+
+Result
+""""""
+
+Created new constraints, suggested using ML
\ No newline at end of file
diff --git a/src/SAMConverter/icons/suggest_constraints.png b/src/SAMConverter/icons/suggest_constraints.png
new file mode 100644
index 0000000000000000000000000000000000000000..196cf55dd7d16dc640550bd94c308c14235f767e
GIT binary patch
literal 477
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`EX7WqAsj$Z!;#Vf<TDlrxjQke
zJ16rJB$@8$>&U>cv7h@-A}f&3S>O>_3^eRI2s1iq%&q_mN|v}rlmzFem6RtIr81P4
zm+NKbWfvzW7NqLs7p2dBXCnnP)z;I+F~q|E=;V!lhYbYU-cQn4G<VkoJ_R)vY5xOE
zLeeD<TxV!6*>phJV6%JEq?{!RY!Nde1h{n+0;RU;1uUHO_}pGD9zG|XnoIis%cuRf
zC~I<I(OWe2t1F9DlJu`u^V_yJ_e-C>QDIegn4PO)#U>^$ZWCYjrHuQZ{%2m}JSWR!
z)nW1fbJp&uZZ*}db=bjrh*93<&TE-BGv+0|eW2(&-!iZ1txa~D>SsBDGmICQ&hIVC
zeRy^H^;c^=vK^NAZjFD*Hud4Ustcu)Ke6n*FMT=n)0+)v4<B9etD$*&N_!O7rgx_*
zJLE)tw<fRq9JOQly+e{8D(1}jq!7Q5abrf1%>K;GhdcrtXY`(QovVtRG;3M&rH18x
zMJKOsKkF!ct0+iH;YsA~)TTOy#Y?X?{;HnFa;jfh>vQteh`;9<>luE%Um6*6&3i|l
RE-<tiJYD@<);T3K0RT=X!VCZa

literal 0
HcmV?d00001

diff --git a/src/SAMConverter/plugin-SAM.xml b/src/SAMConverter/plugin-SAM.xml
new file mode 100644
index 000000000..d25fdfd7a
--- /dev/null
+++ b/src/SAMConverter/plugin-SAM.xml
@@ -0,0 +1,12 @@
+<plugin>
+  <workbench id="Sketch">
+    <group id="Automatic constraints">
+      <feature
+        id="SuggestConstraints"
+        title="Suggest constraints"
+        tooltip="Suggest constraints using a Machine Learning model"
+        icon="icons/SAM/suggest_constraints.png"
+        helpfile="SAMConverter/SAMPlugin.html"/>
+    </group>
+  </workbench>
+</plugin>
diff --git a/src/SAMConverterAPI/CMakeLists.txt b/src/SAMConverterAPI/CMakeLists.txt
new file mode 100644
index 000000000..009a00efb
--- /dev/null
+++ b/src/SAMConverterAPI/CMakeLists.txt
@@ -0,0 +1,91 @@
+# Copyright (C) 2014-2022  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, or (at your option) any later version.
+#
+# 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
+#
+
+INCLUDE(Common)
+
+SET(PROJECT_HEADERS
+  SAMConverterAPI.h
+  SAMConverterAPI_SAMConverter.h
+)
+
+SET(PROJECT_SOURCES
+  SAMConverterAPI_SAMConverter.cpp
+)
+
+SET(PROJECT_LIBRARIES
+  ModelAPI
+  ModelHighAPI
+)
+
+INCLUDE_DIRECTORIES(
+  ${PROJECT_SOURCE_DIR}/src/Events
+  ${PROJECT_SOURCE_DIR}/src/ModelAPI
+  ${PROJECT_SOURCE_DIR}/src/ModelHighAPI
+)
+
+# Plugin headers dependency
+INCLUDE_DIRECTORIES(
+  # TODO(spo): modify ConnectorPlugin headers to remove dependency on GeomAPI headers
+  ${PROJECT_SOURCE_DIR}/src/GeomAPI
+  # TODO(spo): it is for *_swig.h files. Can we eliminate it?
+  ${PROJECT_SOURCE_DIR}/src/GeomDataAPI
+  ${PROJECT_SOURCE_DIR}/src/SAMConverter
+)
+
+#TODO(spo): is ${OpenCASCADE_DEFINITIONS} necessary?
+ADD_DEFINITIONS(-DSAMCONVERTERAPI_EXPORTS ${OpenCASCADE_DEFINITIONS})
+ADD_LIBRARY(SAMConverterAPI SHARED ${PROJECT_SOURCES} ${PROJECT_HEADERS})
+TARGET_LINK_LIBRARIES(SAMConverterAPI ${PROJECT_LIBRARIES})
+
+# SWIG wrapper
+
+INCLUDE(PythonAPI)
+
+SET_SOURCE_FILES_PROPERTIES(SAMConverterAPI.i PROPERTIES CPLUSPLUS ON)
+SET_SOURCE_FILES_PROPERTIES(SAMConverterAPI.i PROPERTIES SWIG_DEFINITIONS "-shadow")
+
+#TODO(spo): is ModelAPI necessary or it could be received by INTERFACE_ (may require modern CMake)?
+SET(SWIG_LINK_LIBRARIES
+  ModelHighAPI
+  ModelAPI
+  SAMConverterAPI
+  ${PYTHON_LIBRARIES}
+)
+
+SET(SWIG_MODULE_SAMConverterAPI_EXTRA_DEPS ${SWIG_MODULE_SAMConverterAPI_EXTRA_DEPS}
+  ${PROJECT_SOURCE_DIR}/src/ModelHighAPI/ModelHighAPI.i
+  doxyhelp.i
+  ${PROJECT_HEADERS}
+)
+SET(CMAKE_SWIG_FLAGS -threads -w325,321,302,362,322,383,403)
+
+IF(${CMAKE_VERSION} VERSION_GREATER "3.8.0")
+  SWIG_ADD_LIBRARY(SAMConverterAPI LANGUAGE python SOURCES SAMConverterAPI.i ${PROJECT_HEADERS})
+ELSE()
+  SWIG_ADD_MODULE(SAMConverterAPI python SAMConverterAPI.i ${PROJECT_HEADERS})
+ENDIF()
+SWIG_LINK_LIBRARIES(SAMConverterAPI ${SWIG_LINK_LIBRARIES})
+
+IF(WIN32)
+  SET_TARGET_PROPERTIES(_SAMConverterAPI PROPERTIES DEBUG_OUTPUT_NAME _SAMConverterAPI_d)
+ENDIF(WIN32)
+
+INSTALL(TARGETS _SAMConverterAPI DESTINATION ${SHAPER_INSTALL_SWIG})
+INSTALL(TARGETS SAMConverterAPI DESTINATION ${SHAPER_INSTALL_BIN})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/SAMConverterAPI.py DESTINATION ${SHAPER_INSTALL_SWIG})
\ No newline at end of file
diff --git a/src/SAMConverterAPI/SAMConverterAPI.h b/src/SAMConverterAPI/SAMConverterAPI.h
new file mode 100644
index 000000000..84f91fdfc
--- /dev/null
+++ b/src/SAMConverterAPI/SAMConverterAPI.h
@@ -0,0 +1,37 @@
+// Copyright (C) 2014-2022  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, or (at your option) any later version.
+//
+// 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
+//
+
+#ifndef SAMCONVERTERAPI_H
+#define SAMCONVERTERAPI_H
+
+#if defined SAMCONVERTERAPI_EXPORTS
+#if defined WIN32
+#define SAMCONVERTERAPI_EXPORT __declspec( dllexport )
+#else
+#define SAMCONVERTERAPI_EXPORT
+#endif
+#else
+#if defined WIN32
+#define SAMCONVERTERAPI_EXPORT __declspec( dllimport )
+#else
+#define SAMCONVERTERAPI_EXPORT
+#endif
+#endif
+
+#endif
diff --git a/src/SAMConverterAPI/SAMConverterAPI.i b/src/SAMConverterAPI/SAMConverterAPI.i
new file mode 100644
index 000000000..a61cdf6fa
--- /dev/null
+++ b/src/SAMConverterAPI/SAMConverterAPI.i
@@ -0,0 +1,41 @@
+// Copyright (C) 2014-2022  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, or (at your option) any later version.
+//
+// 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
+//
+
+/* SAMConverterAPI.i */
+
+%module SAMConverterAPI
+
+%{
+  #include "SAMConverterAPI_swig.h"
+%}
+
+%include "doxyhelp.i"
+
+// import other modules
+%import "ModelHighAPI.i"
+
+// to avoid error on this
+#define SAMCONVERTERAPI_EXPORT
+
+// standard definitions
+%include "typemaps.i"
+%include "std_shared_ptr.i"
+
+// all supported interfaces
+%include "SAMConverterAPI_SAMConverter.h"
diff --git a/src/SAMConverterAPI/SAMConverterAPI_SAMConverter.cpp b/src/SAMConverterAPI/SAMConverterAPI_SAMConverter.cpp
new file mode 100644
index 000000000..5ea46c768
--- /dev/null
+++ b/src/SAMConverterAPI/SAMConverterAPI_SAMConverter.cpp
@@ -0,0 +1,29 @@
+// Copyright (C) 2014-2022  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, or (at your option) any later version.
+//
+// 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
+//
+
+#include "SAMConverterAPI_SAMConverter.h"
+//--------------------------------------------------------------------------------------
+#include <ModelAPI_Document.h>
+#include <ModelAPI_Feature.h>
+//--------------------------------------------------------------------------------------
+void suggestConstraints(const std::shared_ptr<ModelAPI_Document> & thePart)
+{
+  // TODO(spo): check that thePart is not empty
+  std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature("SuggestConstraints");
+}
diff --git a/src/SAMConverterAPI/SAMConverterAPI_SAMConverter.h b/src/SAMConverterAPI/SAMConverterAPI_SAMConverter.h
new file mode 100644
index 000000000..a4955afe9
--- /dev/null
+++ b/src/SAMConverterAPI/SAMConverterAPI_SAMConverter.h
@@ -0,0 +1,38 @@
+// Copyright (C) 2014-2022  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, or (at your option) any later version.
+//
+// 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
+//
+
+#ifndef SRC_SAMCONVERTERAPI_SAMCONVERTERAPI_PART_H_
+#define SRC_SAMCONVERTERAPI_SAMCONVERTERAPI_PART_H_
+
+//--------------------------------------------------------------------------------------
+#include "SAMConverterAPI.h"
+//--------------------------------------------------------------------------------------
+#include <memory>
+//--------------------------------------------------------------------------------------
+class ModelAPI_Document;
+//--------------------------------------------------------------------------------------
+/**\ingroup CPPHighAPI
+ * \brief Export to GEOM
+ */
+SAMCONVERTERAPI_EXPORT
+void suggestConstraints(const std::shared_ptr<ModelAPI_Document> & thePart);
+
+//--------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------
+#endif /* SRC_SAMCONVERTERAPI_SAMCONVERTERAPI_PART_H_ */
diff --git a/src/SAMConverterAPI/SAMConverterAPI_swig.h b/src/SAMConverterAPI/SAMConverterAPI_swig.h
new file mode 100644
index 000000000..d9c4ee69f
--- /dev/null
+++ b/src/SAMConverterAPI/SAMConverterAPI_swig.h
@@ -0,0 +1,27 @@
+// Copyright (C) 2014-2022  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, or (at your option) any later version.
+//
+// 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
+//
+
+#ifndef SRC_SAMCONVERTERAPI_SAMCONVERTERAPI_SWIG_H_
+#define SRC_SAMCONVERTERAPI_SAMCONVERTERAPI_SWIG_H_
+
+  #include <ModelHighAPI_swig.h>
+
+  #include "SAMConverterAPI_SAMConverter.h"
+
+#endif /* SRC_SAMCONVERTERAPI_SAMCONVERTERAPI_SWIG_H_ */
diff --git a/src/SketchPlugin/plugin-Sketch.xml b/src/SketchPlugin/plugin-Sketch.xml
index 86b234c51..aaecd91f8 100644
--- a/src/SketchPlugin/plugin-Sketch.xml
+++ b/src/SketchPlugin/plugin-Sketch.xml
@@ -19,7 +19,7 @@
                 SketchConstraintMirror SketchConstraintAngle
                 SketchMultiRotation SketchMultiTranslation
                 SketchOffset
-                SketchConstraintCollinear SketchConstraintMiddle"
+                SketchConstraintCollinear SketchConstraintMiddle SuggestConstraints"
         when_nested="accept abort"
         title="Sketch"
         tooltip="Create sketch"
-- 
2.39.2