-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-// Name : ModelHighAPI_Tools.cpp
-// Purpose:
+// Copyright (C) 2014-2023 CEA, EDF
+//
+// 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
//
-// History:
-// 07/06/16 - Sergey POKHODENKO - Creation of the file
-//--------------------------------------------------------------------------------------
#include "ModelHighAPI_Tools.h"
#include <ModelHighAPI_FeatureStore.h>
//--------------------------------------------------------------------------------------
#include <GeomDataAPI_Dir.h>
#include <GeomDataAPI_Point.h>
#include <GeomDataAPI_Point2D.h>
+#include <GeomDataAPI_Point2DArray.h>
+//--------------------------------------------------------------------------------------
+#include <GeomAlgoAPI_Tools.h>
+//--------------------------------------------------------------------------------------
+#include <Locale_Convert.h>
//--------------------------------------------------------------------------------------
#include <ModelAPI_AttributeBoolean.h>
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_AttributeDouble.h>
+#include <ModelAPI_AttributeDoubleArray.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeInteger.h>
#include <ModelAPI_AttributeRefAttr.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Tools.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Events.h>
//--------------------------------------------------------------------------------------
#include <Config_ModuleReader.h>
//--------------------------------------------------------------------------------------
void fillAttribute(const std::list<std::shared_ptr<ModelAPI_Object> > & theValue,
const std::shared_ptr<ModelAPI_AttributeRefList> & theAttribute)
{
- theAttribute->clear();
- for (auto it = theValue.begin(); it != theValue.end(); ++it)
+ int aSize = theAttribute->size();
+ // keep objects at the beginning of the list if they the same
+ auto it = theValue.begin();
+ for (int anIndex = 0; it != theValue.end() && anIndex < aSize; ++it, ++anIndex)
+ if (theAttribute->object(anIndex) != *it) {
+ // remove the tail of the list
+ while (++anIndex <= aSize)
+ theAttribute->removeLast();
+ break;
+ }
+ // append the rest of elements
+ for (; it != theValue.end(); ++it)
theAttribute->append(*it);
}
const std::shared_ptr<ModelAPI_AttributeRefList> & theAttribute)
{
theAttribute->clear();
- for (auto it = theValue.begin(); it != theValue.end(); ++it)
- theAttribute->append(it->resultSubShapePair().first); // use only context
+ for (auto it = theValue.begin(); it != theValue.end(); ++it) {
+ if (it->resultSubShapePair().first)
+ theAttribute->append(it->resultSubShapePair().first); // use only context
+ }
}
//--------------------------------------------------------------------------------------
{
theAttribute->clear();
- if(!theValue.empty()) {
- std::string aSelectionType;
+ if(!theValue.empty() && theAttribute->selectionType().empty()) {
const ModelHighAPI_Selection& aSelection = theValue.front();
- theAttribute->setSelectionType(aSelection.shapeType());
+ GeomAPI_Shape::ShapeType aSelectionType = getShapeType(aSelection);
+ theAttribute->setSelectionType(strByShapeType(aSelectionType));
}
for (auto it = theValue.begin(); it != theValue.end(); ++it)
theAttribute->setValue(theValue);
}
+//--------------------------------------------------------------------------------------
+void fillAttribute(const std::wstring & theValue,
+ const std::shared_ptr<ModelAPI_AttributeString> & theAttribute)
+{
+ theAttribute->setValue(theValue);
+}
+
//--------------------------------------------------------------------------------------
void fillAttribute(const char * theValue,
const std::shared_ptr<ModelAPI_AttributeString> & theAttribute)
theAttribute->setValue(anIndex, it->intValue()); // use only values, no text support in array
}
+//--------------------------------------------------------------------------------------
+void fillAttribute(const std::list<ModelHighAPI_Double> & theValue,
+ const std::shared_ptr<ModelAPI_AttributeDoubleArray> & theAttribute)
+{
+ theAttribute->setSize(int(theValue.size()));
+
+ int anIndex = 0;
+ for (auto it = theValue.begin(); it != theValue.end(); ++it, ++anIndex)
+ theAttribute->setValue(anIndex, it->value()); // use only values, no text support in array
+}
+
+//--------------------------------------------------------------------------------------
+void fillAttribute(const std::list<std::shared_ptr<GeomAPI_Pnt2d> > & theValue,
+ const std::shared_ptr<GeomDataAPI_Point2DArray> & theAttribute)
+{
+ theAttribute->setSize(int(theValue.size()));
+
+ int anIndex = 0;
+ for (auto it = theValue.begin(); it != theValue.end(); ++it, ++anIndex)
+ theAttribute->setPnt(anIndex, *it);
+}
+
+//--------------------------------------------------------------------------------------
+void fillAttribute(const ModelHighAPI_Double & theX,
+ const ModelHighAPI_Double & theY,
+ const ModelHighAPI_Double & theZ,
+ const std::shared_ptr<GeomDataAPI_Point> & theAttribute)
+{
+ theX.fillAttribute(theAttribute, theX, theY, theZ);
+}
+
//==================================================================================================
GeomAPI_Shape::ShapeType shapeTypeByStr(std::string theShapeTypeStr)
{
GeomAPI_Shape::ShapeType aShapeType = GeomAPI_Shape::SHAPE;
- std::transform(theShapeTypeStr.begin(), theShapeTypeStr.end(),
- theShapeTypeStr.begin(), ::tolower);
+ std::transform(theShapeTypeStr.begin(), theShapeTypeStr.end(), theShapeTypeStr.begin(),
+ [](char c) { return static_cast<char>(::tolower(c)); });
if(theShapeTypeStr == "compound") {
aShapeType = GeomAPI_Shape::COMPOUND;
return aShapeType;
}
+std::string strByShapeType(GeomAPI_Shape::ShapeType theShapeType)
+{
+ std::string aShapeTypeStr;
+ switch (theShapeType) {
+ case GeomAPI_Shape::COMPOUND:
+ aShapeTypeStr = "COMPOUND";
+ break;
+ case GeomAPI_Shape::COMPSOLID:
+ aShapeTypeStr = "COMPSOLID";
+ break;
+ case GeomAPI_Shape::SOLID:
+ aShapeTypeStr = "SOLID";
+ break;
+ case GeomAPI_Shape::SHELL:
+ aShapeTypeStr = "SHELL";
+ break;
+ case GeomAPI_Shape::FACE:
+ aShapeTypeStr = "FACE";
+ break;
+ case GeomAPI_Shape::WIRE:
+ aShapeTypeStr = "WIRE";
+ break;
+ case GeomAPI_Shape::EDGE:
+ aShapeTypeStr = "EDGE";
+ break;
+ case GeomAPI_Shape::VERTEX:
+ aShapeTypeStr = "VERTEX";
+ break;
+ default:
+ aShapeTypeStr = "SHAPE";
+ break;
+ }
+ return aShapeTypeStr;
+}
+
//==================================================================================================
GeomAPI_Shape::ShapeType getShapeType(const ModelHighAPI_Selection& theSelection)
{
case ModelHighAPI_Selection::VT_ResultSubShapePair: {
ResultSubShapePair aPair = theSelection.resultSubShapePair();
GeomShapePtr aShape = aPair.second;
- if(!aShape.get()) {
+ if(!aShape.get() && aPair.first.get()) {
aShape = aPair.first->shape();
}
if(!aShape.get()) {
aShapeType = shapeTypeByStr(aType);
break;
}
+ case ModelHighAPI_Selection::VT_TypeInnerPointPair: {
+ TypeInnerPointPair aPair = theSelection.typeInnerPointPair();
+ std::string aType = aPair.first;
+ aType = aType.substr(0, aType.find_first_of('_'));
+ aShapeType = shapeTypeByStr(aType);
+ break;
+ }
+ case ModelHighAPI_Selection::VT_WeakNamingPair: {
+ TypeWeakNamingPair aPair = theSelection.typeWeakNamingPair();
+ std::string aType = aPair.first;
+ aShapeType = shapeTypeByStr(aType);
+ break;
+ }
+ default:
+ break; // do nothing [to avoid compilation warning]
}
return aShapeType;
ModelAPI_AttributeTables::ValueType valueTypeByStr(const std::string& theValueTypeStr)
{
std::string aType = theValueTypeStr;
- std::transform(aType.begin(), aType.end(), aType.begin(), ::tolower);
+ std::transform(aType.begin(), aType.end(), aType.begin(),
+ [](char c) { return static_cast<char>(::tolower(c)); });
if (aType == "boolean")
return ModelAPI_AttributeTables::BOOLEAN;
else if (aType == "integer")
return ""; // bad case
}
-/// stores the features information, recoursively stores sub-documetns features
-std::string storeFeatures(const std::string& theDocName, DocumentPtr theDoc,
- std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> >& theStore,
+/// stores the features information, recursively stores sub-documents features
+std::string storeFeatures(const std::wstring& theDocName, DocumentPtr theDoc,
+ std::map<std::wstring, std::map<std::wstring, ModelHighAPI_FeatureStore> >& theStore,
const bool theCompare) // if false => store
{
- std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> >::iterator aDocFind;
+ std::map<std::wstring, std::map<std::wstring, ModelHighAPI_FeatureStore> >::iterator aDocFind;
if (theCompare) {
aDocFind = theStore.find(theDocName);
if (aDocFind == theStore.end()) {
- return "Document '" + theDocName + "' not found";
+ return "Document '" + Locale::Convert::toString(theDocName) + "' not found";
}
}
// store the model features information: iterate all features
- int aFeaturesCount = 0; // stores the number of compared features for this document to compate
- std::set<std::string> aProcessed; // processed features names (that are in the current document)
- std::list<FeaturePtr> allFeatures = theDoc->allFeatures();
- std::list<FeaturePtr>::iterator allIter = allFeatures.begin();
- for(; allIter != allFeatures.end(); allIter++) {
- FeaturePtr aFeat = *allIter;
+ size_t anObjectsCount = 0; // stores the number of compared features for this document to compare
+ std::set<std::wstring> aProcessed; // processed features names (that are in the current document)
+
+ // process all objects (features and folders)
+ std::list<ObjectPtr> allObjects = theDoc->allObjects();
+ std::list<ObjectPtr>::iterator allIter = allObjects.begin();
+ for(; allIter != allObjects.end(); allIter++) {
+ ObjectPtr anObject = *allIter;
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
+ //if (aFeature && aFeature->getKind() == "SketchConstraintCoincidenceInternal")
+
+ if (aFeature) {
+ std::string aStr = aFeature->getKind().substr(0, 16);
+ if (aStr == "SketchConstraint")
+ continue; // no need to dump and check constraints
+ }
if (theCompare) {
- std::map<std::string, ModelHighAPI_FeatureStore>::iterator
- aFeatFind = aDocFind->second.find(aFeat->name());
- if (aFeatFind == aDocFind->second.end()) {
- return "Document '" + theDocName + "' feature '" + aFeat->name() + "' not found";
+ std::map<std::wstring, ModelHighAPI_FeatureStore>::iterator
+ anObjFind = aDocFind->second.find(anObject->data()->name());
+ if (anObjFind == aDocFind->second.end()) {
+ return "Document '" + Locale::Convert::toString(theDocName)
+ + "' feature '" + Locale::Convert::toString(anObject->data()->name()) + "' not found";
}
- std::string anError = aFeatFind->second.compare(aFeat);
+ std::string anError = anObjFind->second.compare(anObject);
if (!anError.empty()) {
+ anError = "Document " + Locale::Convert::toString(theDocName) + " " + anError;
return anError;
}
- aFeaturesCount++;
- aProcessed.insert(aFeat->name());
+ anObjectsCount++;
+ aProcessed.insert(anObject->data()->name());
} else {
- theStore[theDocName][aFeat->name()] = ModelHighAPI_FeatureStore(aFeat);
+ theStore[theDocName][anObject->data()->name()] = ModelHighAPI_FeatureStore(anObject);
}
- // iterate all results of this feature
- std::list<ResultPtr> allResults;
- ModelAPI_Tools::allResults(aFeat, allResults);
- std::list<ResultPtr>::iterator aRes = allResults.begin();
- for(; aRes != allResults.end(); aRes++) {
- // recoursively store features of sub-documents
- if ((*aRes)->groupName() == ModelAPI_ResultPart::group()) {
- DocumentPtr aDoc = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aRes)->partDoc();
- if (aDoc.get()) {
- std::string anError = storeFeatures((*aRes)->data()->name(), aDoc, theStore, theCompare);
- if (!anError.empty())
- return anError;
+
+ if (aFeature) {
+ // iterate all results of this feature
+ std::list<ResultPtr> allResults;
+ ModelAPI_Tools::allResults(aFeature, allResults);
+ std::list<ResultPtr>::iterator aRes = allResults.begin();
+ for(; aRes != allResults.end(); aRes++) {
+ // recursively store features of sub-documents
+ if ((*aRes)->groupName() == ModelAPI_ResultPart::group()) {
+ DocumentPtr aDoc = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aRes)->partDoc();
+ if (aDoc.get()) {
+ std::string anError =
+ storeFeatures((*aRes)->data()->name(), aDoc, theStore, theCompare);
+ if (!anError.empty())
+ return anError;
+ }
}
}
}
}
// checks the number of compared features
if (theCompare) {
- if (aDocFind->second.size() != aFeaturesCount) {
+ if (aDocFind->second.size() != anObjectsCount) {
// search for disappeared feature
- std::string aLostName;
- std::map<std::string, ModelHighAPI_FeatureStore>::iterator aLostIter;
+ std::wstring aLostName;
+ std::map<std::wstring, ModelHighAPI_FeatureStore>::iterator aLostIter;
for(aLostIter = aDocFind->second.begin(); aLostIter != aDocFind->second.end(); aLostIter++) {
if (aProcessed.find(aLostIter->first) == aProcessed.end()) {
aLostName = aLostIter->first;
}
}
- return "For document '" + theDocName +
- "' the number of features is decreased, there is no feature '" + aLostName + "'";
+ return "For document '" + Locale::Convert::toString(theDocName) +
+ "' the number of features is decreased, there is no feature '" +
+ Locale::Convert::toString(aLostName) + "'";
}
}
return ""; // ok
}
//==================================================================================================
-bool checkPythonDump()
+typedef std::map<std::wstring, std::map<std::wstring, ModelHighAPI_FeatureStore> > Storage;
+
+static bool dumpToPython(SessionPtr theSession,
+ const std::string& theFilename,
+ const checkDumpType theSelectionType,
+ const std::string& theErrorMsgContext)
{
- SessionPtr aSession = ModelAPI_Session::get();
+ // 2431: set PartSet as a current document
+ theSession->setActiveDocument(theSession->moduleDocument(), true);
// dump all to the python file
- aSession->startOperation("Check python dump");
- FeaturePtr aDump = aSession->moduleDocument()->addFeature("Dump");
+ theSession->startOperation("Check python dump");
+ FeaturePtr aDump = theSession->moduleDocument()->addFeature("Dump");
if (aDump.get()) {
- aDump->string("file_path")->setValue("check_dump.py"); // to the current folder
- aDump->string("file_format")->setValue("py"); // to the current folder
- aDump->execute();
+ aDump->string("file_path")->setValue(theFilename);
+ aDump->string("file_format")->setValue("py");
+ std::string aTrek = GeomAlgoAPI_Tools::File_Tools::path(theFilename);
+ aDump->string("dump_dir")->setValue(aTrek);
+ aDump->boolean("topological_naming")->setValue((theSelectionType & CHECK_NAMING) != 0);
+ aDump->boolean("geometric_selection")->setValue((theSelectionType & CHECK_GEOMETRICAL) != 0);
+ aDump->boolean("weak_naming")->setValue((theSelectionType & CHECK_WEAK) != 0);
}
bool isProblem = !aDump.get() || !aDump->error().empty(); // after "finish" dump will be removed
- aSession->finishOperation();
- if (isProblem)
- return false; // something is wrong during dump
-
- // map from document name to feature name to feature data
- std::map<std::string, std::map<std::string, ModelHighAPI_FeatureStore> > aStore;
- std::string anError = storeFeatures(
- aSession->moduleDocument()->kind(), aSession->moduleDocument(), aStore, false);
- if (!anError.empty()) {
- Events_InfoMessage anErrorMsg(std::string("checkPythonDump"), anError);
+ if (isProblem && aDump.get()) {
+ std::cout << "Dump feature error " << aDump->error() << std::endl;
+ Events_InfoMessage anErrorMsg(theErrorMsgContext, aDump->error());
anErrorMsg.send();
- return false;
}
+ theSession->finishOperation();
+ return !isProblem;
+}
+
+static bool checkDump(SessionPtr theSession,
+ const char* theFilename,
+ Storage& theStorage,
+ const std::string& theErrorMsgContext)
+{
+
// close all before importation of the script
- aSession->closeAll();
+ theSession->closeAll();
+
// execute the dumped
PyGILState_STATE gstate = PyGILState_Ensure(); /* acquire python thread */
- PyObject* PyFileObject = PyFile_FromString("./check_dump.py", "r");
- PyRun_SimpleFileEx(PyFile_AsFile(PyFileObject), "./check_dump.py", 1);
+ static char aReadMode[] = "r";
+ FILE* PyFileObject = fopen(theFilename, aReadMode);
+ PyRun_SimpleFileEx(PyFileObject, theFilename, 1);
PyGILState_Release(gstate); /* release python thread */
// compare with the stored data
- anError = storeFeatures(
- aSession->moduleDocument()->kind(), aSession->moduleDocument(), aStore, true);
+ std::string anError =
+ storeFeatures(Locale::Convert::toWString(theSession->moduleDocument()->kind()),
+ theSession->moduleDocument(), theStorage, true);
if (!anError.empty()) {
- std::cout<<anError<<std::endl;
- Events_InfoMessage anErrorMsg(std::string("checkPythonDump"), anError);
+ std::cout << anError << std::endl;
+ Events_InfoMessage anErrorMsg(theErrorMsgContext, anError);
anErrorMsg.send();
return false;
}
return true;
}
+bool checkPyDump(
+#ifdef _DEBUG
+ const std::string&, const std::string&, const std::string&,
+#else
+ const std::string& theFilenameNaming,
+ const std::string& theFilenameGeo,
+ const std::string& theFilenameWeak,
+#endif
+ const checkDumpType theCheckType)
+{
+ static const std::string anErrorByNaming("checkPythonDump by naming");
+ static const std::string anErrorByGeometry("checkPythonDump by geometry");
+ static const std::string anErrorByWeak("checkPythonDump by weak naming");
+
+#ifdef _DEBUG
+ std::string aFileForNamingDump("./check_dump.py");
+ std::string aFileForGeometryDump("./check_dump_geo.py");
+ std::string aFileForWeakDump("./check_dump_weak.py");
+#else
+ std::string aFileForNamingDump = theFilenameNaming;
+ std::string aFileForGeometryDump = theFilenameGeo;
+ std::string aFileForWeakDump = theFilenameWeak;
+#endif
+
+ SessionPtr aSession = ModelAPI_Session::get();
+ // dump with the specified types
+ std::string aFileName = theCheckType == CHECK_GEOMETRICAL ? aFileForGeometryDump :
+ (theCheckType == CHECK_WEAK ? aFileForWeakDump : aFileForNamingDump);
+ if (!dumpToPython(aSession, aFileName, theCheckType, anErrorByNaming))
+ return false;
+
+ // map from document name to feature name to feature data
+ std::map<std::wstring, std::map<std::wstring, ModelHighAPI_FeatureStore> > aStore;
+ std::string anError =
+ storeFeatures(Locale::Convert::toWString(aSession->moduleDocument()->kind()),
+ aSession->moduleDocument(), aStore, false);
+ if (!anError.empty()) {
+ Events_InfoMessage anErrorMsg(std::string("checkPythonDump"), anError);
+ anErrorMsg.send();
+ return false;
+ }
+
+ bool isOk = true;
+ if (theCheckType & CHECK_NAMING) {
+ // check dump with the selection by names
+ isOk = checkDump(aSession, aFileForNamingDump.c_str(), aStore, anErrorByNaming);
+ }
+ if (theCheckType & CHECK_GEOMETRICAL) {
+ // check dump with the selection by geometry
+ isOk = isOk && checkDump(aSession, aFileForGeometryDump.c_str(), aStore, anErrorByGeometry);
+ }
+ if (theCheckType & CHECK_WEAK) {
+ isOk = isOk && checkDump(aSession, aFileForWeakDump.c_str(), aStore, anErrorByWeak);
+ }
+
+ return isOk;
+}
+
//--------------------------------------------------------------------------------------
