]> SALOME platform Git repositories - modules/shaper.git/blob - src/ModelHighAPI/ModelHighAPI_Tools.cpp
Salome HOME
Merge remote-tracking branch 'origin/Custom_Fitter' into CEA_2019
[modules/shaper.git] / src / ModelHighAPI / ModelHighAPI_Tools.cpp
1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "ModelHighAPI_Tools.h"
21 #include <ModelHighAPI_FeatureStore.h>
22 //--------------------------------------------------------------------------------------
23 #include <GeomAPI_Dir.h>
24 #include <GeomAPI_Pnt.h>
25 #include <GeomAPI_Pnt2d.h>
26 //--------------------------------------------------------------------------------------
27 #include <GeomDataAPI_Dir.h>
28 #include <GeomDataAPI_Point.h>
29 #include <GeomDataAPI_Point2D.h>
30 //--------------------------------------------------------------------------------------
31 #include <ModelAPI_AttributeBoolean.h>
32 #include <ModelAPI_AttributeDocRef.h>
33 #include <ModelAPI_AttributeDouble.h>
34 #include <ModelAPI_AttributeIntArray.h>
35 #include <ModelAPI_AttributeInteger.h>
36 #include <ModelAPI_AttributeRefAttr.h>
37 #include <ModelAPI_AttributeRefAttrList.h>
38 #include <ModelAPI_AttributeReference.h>
39 #include <ModelAPI_AttributeRefList.h>
40 #include <ModelAPI_AttributeSelection.h>
41 #include <ModelAPI_AttributeSelectionList.h>
42 #include <ModelAPI_AttributeString.h>
43 #include <ModelAPI_AttributeStringArray.h>
44 #include <ModelAPI_AttributeDoubleArray.h>
45 #include <ModelAPI_Session.h>
46 #include <ModelAPI_Tools.h>
47 #include <ModelAPI_ResultPart.h>
48 #include <ModelAPI_Events.h>
49 //--------------------------------------------------------------------------------------
50 #include <Config_ModuleReader.h>
51 //--------------------------------------------------------------------------------------
52 #include "ModelHighAPI_Double.h"
53 #include "ModelHighAPI_Integer.h"
54 #include "ModelHighAPI_RefAttr.h"
55 #include "ModelHighAPI_Reference.h"
56 #include "ModelHighAPI_Selection.h"
57
58 #include <Events_InfoMessage.h>
59
60 // Have to be included before std headers
61 #include <Python.h>
62
63 #include <algorithm>
64 #include <iostream>
65
66 //--------------------------------------------------------------------------------------
67 void fillAttribute(const std::shared_ptr<GeomAPI_Pnt2d> & theValue,
68                    const std::shared_ptr<GeomDataAPI_Point2D> & theAttribute)
69 {
70   theAttribute->setValue(theValue);
71 }
72
73 void fillAttribute(const std::shared_ptr<GeomDataAPI_Point2D> & theAttribute,
74                    double theX, double theY)
75 {
76   theAttribute->setValue(theX, theY);
77 }
78
79 //--------------------------------------------------------------------------------------
80 void fillAttribute(const std::shared_ptr<GeomAPI_Dir> & theValue,
81                    const std::shared_ptr<GeomDataAPI_Dir> & theAttribute)
82 {
83   theAttribute->setValue(theValue);
84 }
85
86 //--------------------------------------------------------------------------------------
87 void fillAttribute(const std::shared_ptr<GeomAPI_Pnt> & theValue,
88                    const std::shared_ptr<GeomDataAPI_Point> & theAttribute)
89 {
90   theAttribute->setValue(theValue);
91 }
92
93 //--------------------------------------------------------------------------------------
94 void fillAttribute(bool theValue,
95                    const std::shared_ptr<ModelAPI_AttributeBoolean> & theAttribute)
96 {
97   theAttribute->setValue(theValue);
98 }
99
100 //--------------------------------------------------------------------------------------
101 void fillAttribute(const ModelHighAPI_Double & theValue,
102                    const std::shared_ptr<ModelAPI_AttributeDouble> & theAttribute)
103 {
104   theValue.fillAttribute(theAttribute);
105 }
106 void fillAttribute(double theValue,
107                    const std::shared_ptr<ModelAPI_AttributeDouble> & theAttribute)
108 {
109   theAttribute->setValue(theValue);
110 }
111
112 //--------------------------------------------------------------------------------------
113 void fillAttribute(const ModelHighAPI_Integer & theValue,
114                    const std::shared_ptr<ModelAPI_AttributeInteger> & theAttribute)
115 {
116   theValue.fillAttribute(theAttribute);
117 }
118 void fillAttribute(int theValue,
119                    const std::shared_ptr<ModelAPI_AttributeInteger> & theAttribute)
120 {
121   theAttribute->setValue(theValue);
122 }
123
124 //--------------------------------------------------------------------------------------
125 void fillAttribute(const ModelHighAPI_RefAttr & theValue,
126                    const std::shared_ptr<ModelAPI_AttributeRefAttr> & theAttribute)
127 {
128   theValue.fillAttribute(theAttribute);
129 }
130
131 //--------------------------------------------------------------------------------------
132 void fillAttribute(const std::list<ModelHighAPI_RefAttr> & theValue,
133                    const std::shared_ptr<ModelAPI_AttributeRefAttrList> & theAttribute)
134 {
135   theAttribute->clear();
136   for (auto it = theValue.begin(); it != theValue.end(); ++it)
137     it->appendToList(theAttribute);
138 }
139
140 //--------------------------------------------------------------------------------------
141 void fillAttribute(const ModelHighAPI_Reference & theValue,
142                    const std::shared_ptr<ModelAPI_AttributeReference> & theAttribute)
143 {
144   theValue.fillAttribute(theAttribute);
145 }
146
147 //--------------------------------------------------------------------------------------
148 void fillAttribute(const std::list<ModelHighAPI_Reference> & theValue,
149                    const std::shared_ptr<ModelAPI_AttributeRefList> & theAttribute)
150 {
151   theAttribute->clear();
152   for (auto it = theValue.begin(); it != theValue.end(); ++it)
153     it->appendToList(theAttribute);
154 }
155
156 //--------------------------------------------------------------------------------------
157 void fillAttribute(const std::shared_ptr<ModelAPI_Object> & theValue,
158                    const std::shared_ptr<ModelAPI_AttributeReference> & theAttribute)
159 {
160   theAttribute->setValue(theValue);
161 }
162
163 //--------------------------------------------------------------------------------------
164 void fillAttribute(const std::list<std::shared_ptr<ModelAPI_Object> > & theValue,
165                    const std::shared_ptr<ModelAPI_AttributeRefList> & theAttribute)
166 {
167   theAttribute->clear();
168   for (auto it = theValue.begin(); it != theValue.end(); ++it)
169     theAttribute->append(*it);
170 }
171
172 MODELHIGHAPI_EXPORT
173 void fillAttribute(const std::list<ModelHighAPI_Selection> & theValue,
174                    const std::shared_ptr<ModelAPI_AttributeRefList> & theAttribute)
175 {
176   theAttribute->clear();
177   for (auto it = theValue.begin(); it != theValue.end(); ++it) {
178     if (it->resultSubShapePair().first)
179       theAttribute->append(it->resultSubShapePair().first); // use only context
180   }
181 }
182
183 //--------------------------------------------------------------------------------------
184 void fillAttribute(const ModelHighAPI_Selection & theValue,
185                    const std::shared_ptr<ModelAPI_AttributeSelection> & theAttribute)
186 {
187   theValue.fillAttribute(theAttribute);
188 }
189
190 //--------------------------------------------------------------------------------------
191 void fillAttribute(const std::list<ModelHighAPI_Selection> & theValue,
192                    const std::shared_ptr<ModelAPI_AttributeSelectionList> & theAttribute)
193 {
194   theAttribute->clear();
195
196   if(!theValue.empty() && theAttribute->selectionType().empty()) {
197     const ModelHighAPI_Selection& aSelection = theValue.front();
198     GeomAPI_Shape::ShapeType aSelectionType = getShapeType(aSelection);
199     theAttribute->setSelectionType(strByShapeType(aSelectionType));
200   }
201
202   for (auto it = theValue.begin(); it != theValue.end(); ++it)
203     it->appendToList(theAttribute);
204 }
205
206 //--------------------------------------------------------------------------------------
207 void fillAttribute(const std::string & theValue,
208                    const std::shared_ptr<ModelAPI_AttributeString> & theAttribute)
209 {
210   theAttribute->setValue(theValue);
211 }
212
213 //--------------------------------------------------------------------------------------
214 void fillAttribute(const char * theValue,
215                    const std::shared_ptr<ModelAPI_AttributeString> & theAttribute)
216 {
217   theAttribute->setValue(theValue);
218 }
219
220 //--------------------------------------------------------------------------------------
221 void fillAttribute(const std::list<std::string> & theValue,
222                    const std::shared_ptr<ModelAPI_AttributeStringArray> & theAttribute)
223 {
224   theAttribute->setSize(int(theValue.size()));
225
226   int anIndex = 0;
227   for (auto it = theValue.begin(); it != theValue.end(); ++it, ++anIndex)
228     theAttribute->setValue(anIndex, *it);
229 }
230
231 //--------------------------------------------------------------------------------------
232 void fillAttribute(const std::list<ModelHighAPI_Integer> & theValue,
233                    const std::shared_ptr<ModelAPI_AttributeIntArray> & theAttribute)
234 {
235   theAttribute->setSize(int(theValue.size()));
236
237   int anIndex = 0;
238   for (auto it = theValue.begin(); it != theValue.end(); ++it, ++anIndex)
239     theAttribute->setValue(anIndex, it->intValue()); // use only values, no text support in array
240 }
241
242 void fillAttribute(const ModelHighAPI_Double & theX,
243                    const ModelHighAPI_Double & theY,
244                    const ModelHighAPI_Double & theZ,
245                    const std::shared_ptr<GeomDataAPI_Point> & theAttribute)
246 {
247   theX.fillAttribute(theAttribute, theX, theY, theZ);
248 }
249
250
251 //==================================================================================================
252 GeomAPI_Shape::ShapeType shapeTypeByStr(std::string theShapeTypeStr)
253 {
254   GeomAPI_Shape::ShapeType aShapeType = GeomAPI_Shape::SHAPE;
255
256   std::transform(theShapeTypeStr.begin(), theShapeTypeStr.end(),
257                  theShapeTypeStr.begin(), ::tolower);
258
259   if(theShapeTypeStr == "compound") {
260     aShapeType = GeomAPI_Shape::COMPOUND;
261   } else if(theShapeTypeStr == "compsolid") {
262     aShapeType = GeomAPI_Shape::COMPSOLID;
263   } else if(theShapeTypeStr == "solid") {
264     aShapeType = GeomAPI_Shape::SOLID;
265   } else if(theShapeTypeStr == "shell") {
266     aShapeType = GeomAPI_Shape::SHELL;
267   } else if(theShapeTypeStr == "face") {
268     aShapeType = GeomAPI_Shape::FACE;
269   } else if(theShapeTypeStr == "wire") {
270     aShapeType = GeomAPI_Shape::WIRE;
271   } else if(theShapeTypeStr == "edge") {
272     aShapeType = GeomAPI_Shape::EDGE;
273   } else if(theShapeTypeStr == "vertex") {
274     aShapeType = GeomAPI_Shape::VERTEX;
275   } else if(theShapeTypeStr == "shape") {
276     aShapeType = GeomAPI_Shape::SHAPE;
277   }
278
279   return aShapeType;
280 }
281
282 std::string strByShapeType(GeomAPI_Shape::ShapeType theShapeType)
283 {
284   std::string aShapeTypeStr;
285   switch (theShapeType) {
286   case GeomAPI_Shape::COMPOUND:
287     aShapeTypeStr = "COMPOUND";
288     break;
289   case GeomAPI_Shape::COMPSOLID:
290     aShapeTypeStr = "COMPSOLID";
291     break;
292   case GeomAPI_Shape::SOLID:
293     aShapeTypeStr = "SOLID";
294     break;
295   case GeomAPI_Shape::SHELL:
296     aShapeTypeStr = "SHELL";
297     break;
298   case GeomAPI_Shape::FACE:
299     aShapeTypeStr = "FACE";
300     break;
301   case GeomAPI_Shape::WIRE:
302     aShapeTypeStr = "WIRE";
303     break;
304   case GeomAPI_Shape::EDGE:
305     aShapeTypeStr = "EDGE";
306     break;
307   case GeomAPI_Shape::VERTEX:
308     aShapeTypeStr = "VERTEX";
309     break;
310   default:
311     aShapeTypeStr = "SHAPE";
312     break;
313   }
314   return aShapeTypeStr;
315 }
316
317 //==================================================================================================
318 GeomAPI_Shape::ShapeType getShapeType(const ModelHighAPI_Selection& theSelection)
319 {
320   GeomAPI_Shape::ShapeType aShapeType = GeomAPI_Shape::SHAPE;
321
322   switch(theSelection.variantType()) {
323     case ModelHighAPI_Selection::VT_ResultSubShapePair: {
324       ResultSubShapePair aPair = theSelection.resultSubShapePair();
325       GeomShapePtr aShape = aPair.second;
326       if(!aShape.get()) {
327         aShape = aPair.first->shape();
328       }
329       if(!aShape.get()) {
330         return aShapeType;
331       }
332       aShapeType = aShape->shapeType();
333       break;
334     }
335     case ModelHighAPI_Selection::VT_TypeSubShapeNamePair: {
336       TypeSubShapeNamePair aPair = theSelection.typeSubShapeNamePair();
337       std::string aType = aPair.first;
338       aShapeType = shapeTypeByStr(aType);
339       break;
340     }
341     case ModelHighAPI_Selection::VT_TypeInnerPointPair: {
342       TypeInnerPointPair aPair = theSelection.typeInnerPointPair();
343       std::string aType = aPair.first;
344       aType = aType.substr(0, aType.find_first_of('_'));
345       aShapeType = shapeTypeByStr(aType);
346       break;
347     }
348     case ModelHighAPI_Selection::VT_WeakNamingPair: {
349       TypeWeakNamingPair aPair = theSelection.typeWeakNamingPair();
350       std::string aType = aPair.first;
351       aShapeType = shapeTypeByStr(aType);
352       break;
353     }
354   }
355
356   return aShapeType;
357 }
358
359 //--------------------------------------------------------------------------------------
360 ModelAPI_AttributeTables::ValueType valueTypeByStr(const std::string& theValueTypeStr)
361 {
362   std::string aType = theValueTypeStr;
363   std::transform(aType.begin(), aType.end(), aType.begin(), ::tolower);
364   if (aType == "boolean")
365     return ModelAPI_AttributeTables::BOOLEAN;
366   else if (aType == "integer")
367     return ModelAPI_AttributeTables::INTEGER;
368   else if (aType == "string")
369     return ModelAPI_AttributeTables::STRING;
370   return ModelAPI_AttributeTables::DOUBLE; // default
371 }
372
373 //--------------------------------------------------------------------------------------
374 std::string strByValueType(const ModelAPI_AttributeTables::ValueType theType)
375 {
376   switch(theType) {
377   case ModelAPI_AttributeTables::BOOLEAN: return "BOOLEAN";
378   case ModelAPI_AttributeTables::INTEGER: return "INTEGER";
379   case ModelAPI_AttributeTables::DOUBLE: return "DOUBLE";
380   case ModelAPI_AttributeTables::STRING: return "STRING";
381   }
382   return ""; // bad case
383 }
384
385 /// stores the features information, recursively stores sub-documents features
386 std::string storeFeatures(const std::string& theDocName, DocumentPtr theDoc,
387   std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> >& theStore,
388   const bool theCompare) // if false => store
389 {
390   std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> >::iterator aDocFind;
391   if (theCompare) {
392      aDocFind = theStore.find(theDocName);
393      if (aDocFind == theStore.end()) {
394        return "Document '" + theDocName + "' not found";
395      }
396   }
397   // store the model features information: iterate all features
398   int anObjectsCount = 0; // stores the number of compared features for this document to compare
399   std::set<std::string> aProcessed; // processed features names (that are in the current document)
400
401   // process all objects (features and folders)
402   std::list<ObjectPtr> allObjects = theDoc->allObjects();
403   std::list<ObjectPtr>::iterator allIter = allObjects.begin();
404   for(; allIter != allObjects.end(); allIter++) {
405     ObjectPtr anObject = *allIter;
406     if (theCompare) {
407       std::map<std::string, ModelHighAPI_FeatureStore>::iterator
408         anObjFind = aDocFind->second.find(anObject->data()->name());
409       if (anObjFind == aDocFind->second.end()) {
410         return "Document '" + theDocName + "' feature '" + anObject->data()->name() + "' not found";
411       }
412       std::string anError = anObjFind->second.compare(anObject);
413       if (!anError.empty()) {
414         anError = "Document " + theDocName + " " + anError;
415         return anError;
416       }
417       anObjectsCount++;
418       aProcessed.insert(anObject->data()->name());
419     } else {
420       theStore[theDocName][anObject->data()->name()] = ModelHighAPI_FeatureStore(anObject);
421     }
422
423     FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
424     if (aFeature) {
425       // iterate all results of this feature
426       std::list<ResultPtr> allResults;
427       ModelAPI_Tools::allResults(aFeature, allResults);
428       std::list<ResultPtr>::iterator aRes = allResults.begin();
429       for(; aRes != allResults.end(); aRes++) {
430         // recursively store features of sub-documents
431         if ((*aRes)->groupName() == ModelAPI_ResultPart::group()) {
432           DocumentPtr aDoc = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aRes)->partDoc();
433           if (aDoc.get()) {
434             std::string anError =
435                 storeFeatures((*aRes)->data()->name(), aDoc, theStore, theCompare);
436             if (!anError.empty())
437               return anError;
438           }
439         }
440       }
441     }
442   }
443   // checks the number of compared features
444   if (theCompare) {
445     if (aDocFind->second.size() != anObjectsCount) {
446       // search for disappeared feature
447       std::string aLostName;
448       std::map<std::string, ModelHighAPI_FeatureStore>::iterator aLostIter;
449       for(aLostIter = aDocFind->second.begin(); aLostIter != aDocFind->second.end(); aLostIter++) {
450         if (aProcessed.find(aLostIter->first) == aProcessed.end()) {
451           aLostName = aLostIter->first;
452         }
453       }
454       return "For document '" + theDocName +
455         "' the number of features is decreased, there is no feature '" + aLostName + "'";
456     }
457   }
458   return ""; // ok
459 }
460
461 //==================================================================================================
462 typedef std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> > Storage;
463
464 static bool dumpToPython(SessionPtr theSession,
465                          const char* theFilename,
466                          const checkDumpType theSelectionType,
467                          const std::string& theErrorMsgContext)
468 {
469   // 2431: set PartSet as a current document
470   theSession->setActiveDocument(theSession->moduleDocument(), true);
471   // dump all to the python file
472   theSession->startOperation("Check python dump");
473   FeaturePtr aDump = theSession->moduleDocument()->addFeature("Dump");
474   if (aDump.get()) {
475     aDump->string("file_path")->setValue(theFilename);
476     aDump->string("file_format")->setValue("py");
477     aDump->boolean("topological_naming")->setValue((theSelectionType & CHECK_NAMING) != 0);
478     aDump->boolean("geometric_selection")->setValue((theSelectionType & CHECK_GEOMETRICAL) != 0);
479     aDump->boolean("weak_naming")->setValue((theSelectionType & CHECK_WEAK) != 0);
480   }
481   bool isProblem = !aDump.get() || !aDump->error().empty(); // after "finish" dump will be removed
482   if (isProblem && aDump.get()) {
483     std::cout << "Dump feature error " << aDump->error() << std::endl;
484     Events_InfoMessage anErrorMsg(theErrorMsgContext, aDump->error());
485     anErrorMsg.send();
486   }
487   theSession->finishOperation();
488   return !isProblem;
489 }
490
491 static bool checkDump(SessionPtr theSession,
492                       char* theFilename,
493                       Storage& theStorage,
494                       const std::string& theErrorMsgContext)
495 {
496
497   // close all before importation of the script
498   theSession->closeAll();
499
500   // execute the dumped
501   PyGILState_STATE gstate = PyGILState_Ensure(); /* acquire python thread */
502   static char aReadMode[] = "r";
503   FILE* PyFileObject = _Py_fopen(theFilename, aReadMode);
504   PyRun_SimpleFileEx(PyFileObject, theFilename, 1);
505   PyGILState_Release(gstate); /* release python thread */
506
507   // compare with the stored data
508   std::string anError = storeFeatures(
509     theSession->moduleDocument()->kind(), theSession->moduleDocument(), theStorage, true);
510   if (!anError.empty()) {
511     std::cout << anError << std::endl;
512     Events_InfoMessage anErrorMsg(theErrorMsgContext, anError);
513     anErrorMsg.send();
514     return false;
515   }
516
517   return true;
518 }
519
520 bool checkPythonDump(const checkDumpType theCheckType)
521 {
522   static const std::string anErrorByNaming("checkPythonDump by naming");
523   static const std::string anErrorByGeometry("checkPythonDump by geometry");
524   static const std::string anErrorByWeak("checkPythonDump by weak naming");
525
526   static char aFileForNamingDump[] = "./check_dump.py";
527   static char aFileForGeometryDump[] = "./check_dump_geo.py";
528   static char aFileForWeakDump[] = "./check_dump_weak.py";
529
530   SessionPtr aSession = ModelAPI_Session::get();
531   // dump with the specified types
532   char* aFileName = theCheckType == CHECK_GEOMETRICAL ? aFileForGeometryDump :
533                    (theCheckType == CHECK_WEAK ? aFileForWeakDump : aFileForNamingDump);
534   if (!dumpToPython(aSession, aFileName, theCheckType, anErrorByNaming))
535     return false;
536
537    // map from document name to feature name to feature data
538   std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> > aStore;
539   std::string anError = storeFeatures(
540     aSession->moduleDocument()->kind(), aSession->moduleDocument(), aStore, false);
541   if (!anError.empty()) {
542     Events_InfoMessage anErrorMsg(std::string("checkPythonDump"), anError);
543     anErrorMsg.send();
544     return false;
545   }
546
547   bool isOk = true;
548   if (theCheckType & CHECK_NAMING) {
549     // check dump with the selection by names
550     isOk = checkDump(aSession, aFileForNamingDump, aStore, anErrorByNaming);
551   }
552   if (theCheckType & CHECK_GEOMETRICAL) {
553     // check dump with the selection by geometry
554     isOk = isOk && checkDump(aSession, aFileForGeometryDump, aStore, anErrorByGeometry);
555   }
556   if (theCheckType & CHECK_WEAK) {
557     isOk = isOk && checkDump(aSession, aFileForWeakDump, aStore, anErrorByWeak);
558   }
559
560   return isOk;
561 }
562
563 //--------------------------------------------------------------------------------------