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