src/Selector/Selector_Modify.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 <Selector_Modify.h>
  22
  23 #include <Selector_NameGenerator.h>
  24 #include <Selector_NExplode.h>
  25
  26 #include <TNaming_NamedShape.hxx>
  27 #include <TNaming_Iterator.hxx>
  28 #include <TNaming_SameShapeIterator.hxx>
  29 #include <TNaming_NewShapeIterator.hxx>
  30 #include <TNaming_Tool.hxx>
  31 #include <TDataStd_Name.hxx>
  32 #include <TDataStd_Integer.hxx>
  33 #include <TDF_ChildIterator.hxx>
  34 #include <TopTools_MapOfShape.hxx>
  35 #include <TopExp_Explorer.hxx>
  36 #include <BRep_Tool.hxx>
  37 #include <TopoDS.hxx>
  38 #include <TopoDS_Builder.hxx>
  39 #include <TopoDS_Compound.hxx>
  40
  41 Selector_Modify::Selector_Modify() : Selector_Algo()
  42 {
  43   myWeakIndex = -1; // no index by default
  44 }
  45
  46 // adds to theResult all labels that contain initial shapes for theValue located in theFinal
  47 static void findBases(TDF_Label theAccess, Handle(TNaming_NamedShape) theFinal,
  48   const TopoDS_Shape& theValue,
  49   bool aMustBeAtFinal, const TDF_Label& theAdditionalDocument, TDF_LabelList& theResult)
  50 {
  51   bool aFoundAnyShape = false;
  52   TNaming_SameShapeIterator aLabIter(theValue, theAccess);
  53   for(; aLabIter.More(); aLabIter.Next()) {
  54     Handle(TNaming_NamedShape) aNS;
  55     if (aLabIter.Label().FindAttribute(TNaming_NamedShape::GetID(), aNS)) {
  56       if (aMustBeAtFinal && aNS != theFinal)
  57         continue; // looking for old at the same final label only
  58       TNaming_Evolution anEvolution = aNS->Evolution();
  59       if (anEvolution == TNaming_PRIMITIVE) {
  60         // check that this is not in the results already
  61         const TDF_Label aResult = aNS->Label();
  62         TDF_LabelList::Iterator aResIter(theResult);
  63         for(; aResIter.More(); aResIter.Next()) {
  64           if (aResIter.Value().IsEqual(aResult))
  65             break;
  66         }
  67         if (!aResIter.More()) // not found, so add this new
  68           theResult.Append(aResult);
  69         aFoundAnyShape = true;
  70       }
  71       if (anEvolution == TNaming_GENERATED || anEvolution == TNaming_MODIFY) {
  72         for(TNaming_Iterator aThisIter(aNS); aThisIter.More(); aThisIter.Next()) {
  73           if (aThisIter.NewShape().IsSame(theValue)) {
  74             // continue recursively, null NS means that any NS are ok
  75             findBases(theAccess, theFinal, aThisIter.OldShape(),
  76               false, theAdditionalDocument, theResult);
  77             aFoundAnyShape = true;
  78           }
  79         }
  80       }
  81     }
  82   }
  83   if (!aFoundAnyShape && !theAdditionalDocument.IsNull()) { // try to find in additional document
  84     static TDF_Label anEmpty;
  85     if (TNaming_Tool::HasLabel(theAdditionalDocument, theValue))
  86       findBases(theAdditionalDocument, Handle(TNaming_NamedShape)(), theValue,
  87         false, anEmpty, theResult);
  88   }
  89 }
  90
  91 /// Returns in theResults all shapes with history started in theBase and ended in theFinal
  92 static void findFinals(const TDF_Label& anAccess, const TopoDS_Shape& theBase,
  93   const TDF_Label& theFinal,
  94   const TDF_Label& theAdditionalDoc, TopTools_MapOfShape& theResults)
  95 {
  96   if (TNaming_Tool::HasLabel(anAccess, theBase)) {
  97     for(TNaming_NewShapeIterator aBaseIter(theBase, anAccess); aBaseIter.More(); aBaseIter.Next())
  98     {
  99       TNaming_Evolution anEvolution = aBaseIter.NamedShape()->Evolution();
 100       if (anEvolution == TNaming_GENERATED || anEvolution == TNaming_MODIFY) {
 101         if (aBaseIter.NamedShape()->Label().IsEqual(theFinal)) {
 102           theResults.Add(aBaseIter.Shape());
 103         } else {
 104           findFinals(anAccess, aBaseIter.Shape(), theFinal, theAdditionalDoc, theResults);
 105         }
 106       }
 107     }
 108   }
 109   if (!theAdditionalDoc.IsNull()) { // search additionally by the additional access label
 110     static TDF_Label anEmpty;
 111     findFinals(theAdditionalDoc, theBase, theFinal, anEmpty, theResults);
 112   }
 113 }
 114
 115 void Selector_Modify::findModificationResult(TopoDS_ListOfShape& theCommon) {
 116   for(TDF_LabelList::Iterator aBase(myBases); aBase.More(); aBase.Next()) {
 117     TDF_Label anAdditionalDoc; // this document if base is started in extra document
 118     if (aBase.Value().Root() != label().Root()) {
 119       anAdditionalDoc = label();
 120     }
 121     TopTools_MapOfShape aFinals;
 122     for(TNaming_Iterator aBaseShape(aBase.Value()); aBaseShape.More(); aBaseShape.Next()) {
 123       findFinals(aBase.Value(), aBaseShape.NewShape(), myFinal, anAdditionalDoc, aFinals);
 124     }
 125     if (!aFinals.IsEmpty()) {
 126       if (theCommon.IsEmpty()) { // just copy all to common
 127         for(TopTools_MapOfShape::Iterator aFinal(aFinals); aFinal.More(); aFinal.Next()) {
 128           theCommon.Append(aFinal.Key());
 129         }
 130       } else { // keep only shapes presented in both lists
 131         for(TopoDS_ListOfShape::Iterator aCommon(theCommon); aCommon.More(); ) {
 132           if (aFinals.Contains(aCommon.Value())) {
 133             aCommon.Next();
 134           } else { // common is not found, remove it
 135             theCommon.Remove(aCommon);
 136           }
 137         }
 138       }
 139     }
 140   }
 141 }
 142
 143 bool Selector_Modify::select(NCollection_List<Handle(TNaming_NamedShape)>& theModifList,
 144   const TopoDS_Shape theContext, const TopoDS_Shape theValue)
 145 {
 146   if (theModifList.Extent() > 1) { // searching for the best modification result: by context
 147     Handle(TNaming_NamedShape) aCandidate;
 148     NCollection_List<Handle(TNaming_NamedShape)>::Iterator aModIter(theModifList);
 149     for (; !theModifList.IsEmpty() && aModIter.More(); aModIter.Next()) {
 150       aCandidate = aModIter.Value();
 151       TDF_Label aFatherLab = aCandidate->Label().Father();
 152       Handle(TNaming_NamedShape) aFatherNS;
 153       if (aFatherLab.FindAttribute(TNaming_NamedShape::GetID(), aFatherNS)) {
 154         for (TNaming_Iterator anIter(aFatherNS); anIter.More(); anIter.Next()) {
 155           if (theContext.IsSame(anIter.NewShape())) { // found the best modification
 156             theModifList.Clear();
 157             break;
 158           }
 159         }
 160       }
 161     }
 162     // take the best candidate, or the last in the iteration
 163     theModifList.Clear();
 164     theModifList.Append(aCandidate);
 165   }
 166
 167   if (!theModifList.IsEmpty()) {
 168     // searching for all the base shapes of this modification
 169     findBases(label(), theModifList.First(), theValue, true, baseDocument(), myBases);
 170     if (!myBases.IsEmpty()) {
 171       myFinal = theModifList.First()->Label();
 172       TopoDS_ListOfShape aCommon;
 173       findModificationResult(aCommon);
 174       // trying to search by neighbors
 175       if (aCommon.Extent() > 1) { // more complicated selection
 176         if (alwaysGeometricalNaming()) {
 177           TopoDS_ListOfShape::Iterator aCommonIter(aCommon);
 178           TopoDS_Shape aFirst = aCommonIter.Value();
 179           for (aCommonIter.Next(); aCommonIter.More(); aCommonIter.Next()) {
 180             if (!sameGeometry(aFirst, aCommonIter.Value()))
 181               break;
 182           }
 183           if (!aCommonIter.More()) { // all geometry is same, result is a compound
 184             return true;
 185           }
 186         }
 187       } else if (aCommon.Extent() == 1) {
 188         return true; // simple modification
 189       }
 190       // weak naming between the common results
 191       Selector_NExplode aNexp(aCommon);
 192       myWeakIndex = aNexp.index(theValue);
 193       return myWeakIndex != -1;
 194     }
 195     // weak naming case
 196     TopoDS_ListOfShape aCommon;
 197     myFinal = theModifList.First()->Label();
 198     Handle(TNaming_NamedShape) aNS;
 199     if (myFinal.FindAttribute(TNaming_NamedShape::GetID(), aNS)) {
 200       for(TNaming_Iterator aFinalIter(aNS); aFinalIter.More(); aFinalIter.Next()) {
 201         const TopoDS_Shape& aNewShape = aFinalIter.NewShape();
 202         if (!aNewShape.IsNull())
 203           aCommon.Append(aNewShape);
 204       }
 205     }
 206     Selector_NExplode aNexp(aCommon);
 207     myWeakIndex = aNexp.index(theValue);
 208     return myWeakIndex != -1;
 209   }
 210   return false;
 211 }
 212
 213 void Selector_Modify::store()
 214 {
 215   storeType(Selector_Algo::SELTYPE_MODIFICATION);
 216   storeBaseArray(myBases, myFinal);
 217   if (myWeakIndex != -1) {
 218     TDataStd_Integer::Set(label(), weakID(), myWeakIndex);
 219   }
 220 }
 221
 222 bool Selector_Modify::restore()
 223 {
 224   if (restoreBaseArray(myBases, myFinal)) {
 225     Handle(TDataStd_Integer) aWeakInt;
 226     if (label().FindAttribute(weakID(), aWeakInt)) {
 227       myWeakIndex = aWeakInt->Get();
 228     }
 229     return true;
 230   }
 231   return false;
 232 }
 233
 234 TDF_Label Selector_Modify::restoreByName(std::string theName,
 235   const TopAbs_ShapeEnum theShapeType, Selector_NameGenerator* theNameGenerator)
 236 {
 237   TDF_Label aContext;
 238   for(size_t anEnd, aStart = 0; aStart != std::string::npos; aStart = anEnd) {
 239     if (aStart != 0)
 240       aStart++;
 241     anEnd = theName.find('&', aStart);
 242     std::string aSubStr =
 243       theName.substr(aStart, anEnd == std::string::npos ? anEnd : anEnd - aStart);
 244     if (aSubStr.find(weakNameID()) == 0) { // weak name identifier
 245       std::string aWeakIndex = aSubStr.substr(weakNameID().size());
 246       myWeakIndex = atoi(aWeakIndex.c_str());
 247       continue;
 248     }
 249     TDF_Label aSubContext, aValue;
 250     if (!theNameGenerator->restoreContext(aSubStr, aSubContext, aValue))
 251       return TDF_Label(); // can not restore
 252     if(aSubContext.IsNull() || aValue.IsNull())
 253       return TDF_Label(); // can not restore
 254     if (myFinal.IsNull()) {
 255       myFinal = aValue;
 256       aContext = aSubContext;
 257     } else
 258       myBases.Append(aValue);
 259   }
 260   return aContext;
 261 }
 262
 263 bool Selector_Modify::solve(const TopoDS_Shape& theContext)
 264 {
 265   TopoDS_Shape aResult;
 266   if (myBases.IsEmpty() && myWeakIndex > 0) { // weak name by the final shapes index
 267     TopoDS_ListOfShape aCommon;
 268     Handle(TNaming_NamedShape) aNS;
 269     if (myFinal.FindAttribute(TNaming_NamedShape::GetID(), aNS)) {
 270       for(TNaming_Iterator aFinalIter(aNS); aFinalIter.More(); aFinalIter.Next()) {
 271         const TopoDS_Shape& aNewShape = aFinalIter.NewShape();
 272         if (!aNewShape.IsNull())
 273           aCommon.Append(aNewShape);
 274       }
 275     }
 276     Selector_NExplode aNexp(aCommon);
 277     aResult = aNexp.shape(myWeakIndex);
 278   } else { // standard case
 279     TopoDS_ListOfShape aFinalsCommon; // final shapes presented in all results from bases
 280     findModificationResult(aFinalsCommon);
 281     if (aFinalsCommon.Extent() == 1) { // result is valid: found only one shape
 282       aResult = aFinalsCommon.First();
 283       findNewVersion(theContext, aResult);
 284     } else if (aFinalsCommon.Extent() > 1 && myWeakIndex > 0) {
 285       Selector_NExplode aNExp(aFinalsCommon);
 286       aResult = aNExp.shape(myWeakIndex);
 287       findNewVersion(theContext, aResult);
 288     } else if (aFinalsCommon.Extent() > 1 && geometricalNaming()) {// if same geometry - compound
 289       TopoDS_ListOfShape::Iterator aCommonIter(aFinalsCommon);
 290       TopoDS_Shape aFirst = aCommonIter.Value();
 291       for(aCommonIter.Next(); aCommonIter.More(); aCommonIter.Next()) {
 292         if (!sameGeometry(aFirst, aCommonIter.Value()))
 293           break;
 294       }
 295       if (!aCommonIter.More()) { // all geometry is same, create a result compound
 296         TopoDS_Builder aBuilder;
 297         TopoDS_Compound aCompound;
 298         aBuilder.MakeCompound(aCompound);
 299         for(aCommonIter.Initialize(aFinalsCommon); aCommonIter.More(); aCommonIter.Next()) {
 300           TopoDS_Shape aSub = aCommonIter.Value();
 301           findNewVersion(theContext, aSub);
 302           aBuilder.Add(aCompound, aSub);
 303         }
 304         aResult = aCompound;
 305       }
 306
 307     }
 308   }
 309
 310   if (!aResult.IsNull()) {
 311     Selector_Algo::store(aResult);
 312     return true;
 313   }
 314   return false;
 315 }
 316
 317 std::string Selector_Modify::name(Selector_NameGenerator* theNameGenerator)
 318 {
 319   // final&base1&base2 +optionally: [weak_name_1]
 320   std::string aResult;
 321   Handle(TDataStd_Name) aName;
 322   if (!myFinal.FindAttribute(TDataStd_Name::GetID(), aName))
 323     return "";
 324   aResult += theNameGenerator->contextName(myFinal) + "/" +
 325     std::string(TCollection_AsciiString(aName->Get()).ToCString());
 326   for(TDF_LabelList::iterator aBase = myBases.begin(); aBase != myBases.end(); aBase++) {
 327     if (!aBase->FindAttribute(TDataStd_Name::GetID(), aName))
 328       return "";
 329     aResult += "&";
 330     aResult += theNameGenerator->contextName(*aBase) + "/" +
 331       std::string(TCollection_AsciiString(aName->Get()).ToCString());
 332   }
 333   if (myWeakIndex != -1) {
 334     std::ostringstream aWeakStr;
 335     aWeakStr<<"&"<<weakNameID()<<myWeakIndex;
 336     aResult += aWeakStr.str();
 337   }
 338   return aResult;
 339 }