Strategy.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Strategy.h"
 
// Qt library
#include <QScopedPointer>
#include <QString>
#include <QStringList>
 
// boost library
#include <boost/foreach.hpp>
 
// other ISIS
#include "IException.h"
#include "GisGeometry.h"
#include "Progress.h"
#include "PvlFlatMap.h"
#include "PvlObject.h"
#include "Resource.h"
 
using namespace std;
 
namespace Isis {
  
  Strategy::Strategy() : m_globals(), m_definition(new PvlObject("Strategy")),
                         m_name("Strategy"), m_type("Counter"),
                         m_total(0), m_applyDiscarded(false), m_debug(false),
                         m_progress() { 
  }
  
  
  Strategy::Strategy(const QString &name, const QString &type) : 
                     m_globals(),
                     m_definition(new PvlObject(name)),
                     m_name(name), m_type(type), m_total(0), 
                     m_applyDiscarded(false), m_debug(false), m_progress() { 
  }
  
  
  Strategy::Strategy(const PvlObject &definition, const ResourceList &globals) : 
                    m_globals(globals), m_definition(new PvlObject(definition)),
                    m_name("Strategy"), m_type("Unknown"), 
                    m_total(0), m_applyDiscarded(false), m_debug(false), m_progress() {
    PvlFlatMap parms(getDefinitionMap());
    m_name = parms.get("Name");
    m_type = parms.get("Type");
    m_applyDiscarded = toBool(parms.get("ApplyToDiscarded", "false"));
    m_debug = toBool(parms.get("Debug", "false"));
    initProgress();
  }
  
  
  Strategy::~Strategy() {
  }
 
 
  QString Strategy::name() const {
    return (m_name);
  }
  
  
  QString Strategy::type() const {
    return (m_type);
  }
 
 
  void Strategy::setName(const QString &name) {
    m_name = name;
    return;
  }
 
 
  void Strategy::setType(const QString &type) {
    m_type = type;
    return;
  }
 
 
   ResourceList Strategy::getGlobalDefaults() const {
     return (m_globals);
   }
 
 
   ResourceList Strategy::getGlobals(SharedResource &myGlobals, 
                                     const ResourceList &globals) const {
 
#if 0
     ResourceList v_globals(globals);
     v_globals.append(myGlobals);
#else
     ResourceList v_globals;
     v_globals.push_back(myGlobals);
     v_globals.append(globals);
#endif
     return ( v_globals );
   }
 
 
   const PvlObject &Strategy::getDefinition() const {
     return (*m_definition);
   }
 
 
   PvlFlatMap Strategy::getDefinitionMap() const {
   return ( PvlFlatMap(*m_definition, PvlConstraints::withExcludes(getObjectList(*m_definition))) );
   }
 
 
  QString Strategy::description() const {
    if ( m_definition->hasKeyword("Description") ) {
      return (m_definition->findKeyword("Description")[0]);
    }
    else {
      QString descr = "Strategy::" + name() + " is running a " + type() +
                      " algorithm.";
      return (descr);
    }
  }
 
  
  int Strategy::apply(ResourceList &resources) {
    return ( apply(resources, getGlobalDefaults()) );
  }
 
  
  int Strategy::apply(SharedResource &resource) {
    return ( apply( resource, getGlobalDefaults()) );
  }
 
  
  int Strategy::apply(ResourceList &resources, const ResourceList &globals) { 
    return ( applyToResources(resources, globals) );
  }
  
  
  int Strategy::apply(SharedResource &resource, const ResourceList &globals) {
    if ( isDebug() ) {
      cout << "Empty apply is called...\n";
    }
    return (1); 
  }
  
    
  unsigned int Strategy::totalProcessed() const {
    return (m_total);
  }
  
  
  void Strategy::setApplyToDiscarded() {
    m_applyDiscarded = true;
    return;
  }
  
  
  bool Strategy::isApplyToDiscarded() const {
    return (m_applyDiscarded);
  }
  
  
  void Strategy::setDoNotApplyToDiscarded() {
    m_applyDiscarded = false;
    return;
  }
  
  
  int Strategy::applyToResources(ResourceList &resources, const ResourceList &globals) { 
   
    initProgress( ( isApplyToDiscarded() ) ? resources.size() : countActive(resources) );
 
    int result = 0;
    BOOST_FOREACH ( SharedResource resource, resources ) {
      if ( resource->isDiscarded() ) {
        if (true == isApplyToDiscarded() ) {
          result += apply(resource, globals);
          processed();
        }
      }
      else {
        result += apply(resource, globals);
        processed();
      }
    }
    return (result);
  }
  
  
  unsigned int Strategy::processed() {
    m_total++;
    if ( doShowProgress() && !m_progress.isNull() ) { 
      m_progress->CheckStatus(); 
    }
 
    return (m_total);
  }
  
  
  void Strategy::resetProcessed() {
    m_total = 0;
    return;
  }
  
  
  int Strategy::countActive(const ResourceList &resources) const {
    return ( resources.size() - countDiscarded(resources) );
  }
  
  
  int Strategy::countDiscarded(const ResourceList &resources) const {
    int n = 0;
    BOOST_FOREACH ( SharedResource resource, resources ) {
      if ( resource->isDiscarded() ) { n++; }
    }
    return (n);
  }
  
  
  ResourceList Strategy::assetResourceList(const SharedResource &resource, 
                                           const QString &name) const {
    ResourceList alist;
    if ( resource->hasAsset(name) ) {
      QVariant v_asset = resource->asset(name);
      if ( v_asset.canConvert<ResourceList>() ) {
         alist = v_asset.value<ResourceList>();
      }
    }
  
    return (alist);
  }
 
  
   QString Strategy::findReplacement(const QString &target,
                                     const ResourceList &globals, 
                                     const int &index,
                                     const QString &defValue) const {
     BOOST_FOREACH ( const SharedResource keystore, globals ) {
       if ( keystore->exists(target) ) {
         if ( keystore->count(target) > index ) {
           return (keystore->value(target, index)); 
         }
       }
     }
 
     return ( defValue );
   }
 
  
  QStringList Strategy::qualifiers(const QString &keyspec,
                                   const QString &delimiter) const {
    QStringList parts = keyspec.split(delimiter);
    return (parts);
  }
 
  
  QString Strategy::scanAndReplace(const QString &input, const QString &target, 
                                   const QString &replacement) const {
    QString str(input);
    str.replace(target, replacement, Qt::CaseInsensitive);
    return (str);
  }
  
  
  QString Strategy::translateKeywordArgs(const QString &keyBase,
                                         const ResourceList &globals,
                                         const QString &defValue) const {
  
    // Get keyword configuration from definition 
    PvlFlatMap keys( getDefinitionMap() );
  
    QStringList idArgs;  // Argument replacement list
    QString value;
    
    QString keyword = keyBase + "Keyword";
    if ( keys.exists(keyword) ) {
      idArgs.push_back(keys.get(keyword));
      value = keys.get(keyBase, "%1");
    }
    else {
      if ( keys.exists(keyBase + "Args") ) {
        idArgs = keys.allValues(keyBase + "Args");
      }
      value = keys.get(keyBase, defValue);
    }
  
    return (processArgs(value, idArgs, globals, defValue));
  }
  
  
  QString Strategy::processArgs(const QString &value, const QStringList &argKeys,
                                const ResourceList &globals,
                                const QString &defValue) const {
  
    QString result = value;
    int i = argKeys.size();
    BOOST_REVERSE_FOREACH ( QString arg, argKeys ) {
      QString target("%"+QString::number(i));
      result = scanAndReplace(result, target, findReplacement(arg,globals,0,defValue));
      i--;
    } 
    return (result);
  }
  
  
  void Strategy::propagateKeys(SharedResource &source, SharedResource &target) 
                               const {
    PvlFlatMap keys( getDefinitionMap() );
    QStringList keySources = keys.allValues("PropagateKeywords");
    BOOST_FOREACH ( QString key, keySources ) {
      if ( source->exists(key) ) {
        target->add(source->keyword(key));
      }
    }
    return;
  }
 
  
  SharedResource Strategy::composite(SharedResource &resourceA, 
                                     SharedResource &resourceB,
                                     const QPair<QString, QString> &keySuffix) 
                                     const {
 
    // Create the new resource
    QString id = resourceA->name() + "_" + resourceB->name();
    SharedResource composite(new Resource(id));
    
    // See if user wants to restrict keyword propagation to a list 
    QStringList keySources = PvlFlatMap( getDefinitionMap() ).allValues("PropagateKeywords");
    if ( !keySources.isEmpty() ) {
      // Propogate only specified keywords from each Resource
      BOOST_FOREACH ( QString key, keySources ) {
        if ( resourceA->exists(key) ) {
          PvlKeyword keyword(resourceA->keyword(key));
          keyword.setName(keyword.name().append(keySuffix.first));
          composite->add(keyword);
        }
 
        if ( resourceB->exists(key) ) {
          PvlKeyword keyword(resourceB->keyword(key));
          keyword.setName(keyword.name().append(keySuffix.second));
          composite->add(keyword);
        }
      }
    }
    else {
      // Propagate all keys from each source to the composite Resource
      const PvlFlatMap &rkeysA = resourceA->keys();
      PvlFlatMap::ConstPvlFlatMapIterator pkeys = rkeysA.begin();
      while ( rkeysA.constEnd() != pkeys) {
        PvlKeyword keyword(pkeys.value());
        keyword.setName(keyword.name().append(keySuffix.first));
        composite->add(keyword);
        ++pkeys;
      }
 
      const PvlFlatMap &rkeysB = resourceB->keys();
      pkeys = rkeysB.begin();
      while ( rkeysB.constEnd() != pkeys) {
        PvlKeyword keyword(pkeys.value());
        keyword.setName(keyword.name().append(keySuffix.second));
        composite->add(keyword);
        ++pkeys;
      }
    }
    return (composite);
  }
  
  
  bool Strategy::importGeometry(SharedResource &resource, 
                                const ResourceList &globals) const {
    PvlFlatMap keys( getDefinitionMap() );
  
    //  Assume a specific geometry is present
    QString geom(keys.get("GisGeometry", ""));
 
    QString giskey;
    if ( keys.exists("GisGeometryRef") ) { giskey = keys.get("GisGeometryRef"); }
    if ( keys.exists("GisGeometryKey") ) { giskey = keys.get("GisGeometryKey"); }
  
    if ( !giskey.isEmpty() ) {
      if ( !resource->isNull(giskey) ) {
        geom = resource->value(giskey);
        
        // Erase key if requested
        if ( toBool(keys.get("RemoveGisKeywordAfterImport", "false")) ) { 
          resource->erase(giskey); 
        }
      }
    }
  
    // Got a geometry.
    if ( !geom.isEmpty() ) {
  
      //  Process arguments  Allows creation specialized geometry as well
      if ( keys.exists("GisGeometryArgs") ) {
        QStringList args = keys.allValues("GisGeometryArgs");
        geom = processArgs(geom, args, getGlobals(resource, globals));
      }
  
      // Get the type
      QString gisType = keys.get("GisType");
      int npoints(0);
      int npointsOrg(0);
      double tolerance(0.0);
  
      //  Check for Geometry.  May want to remove it after parsing/conversion.  
      //  These text geometries tend to be huge and consume lots of memory.
      if ( !geom.isEmpty() ) {
        
        QScopedPointer<GisGeometry> geosgeom(new GisGeometry(geom, GisGeometry::type(gisType)));
        if ( geosgeom.isNull() || !geosgeom->isValid() ) return (false);
 
        npointsOrg =  npoints = geosgeom->points();
        QString gisTolerance  = translateKeywordArgs("GisSimplifyTolerance", 
                                                     getGlobals(resource, globals), ""); 
 
        if ( !gisTolerance.isEmpty() ) {
          tolerance = toDouble(gisTolerance);
          GisGeometry *simple = geosgeom->simplify(tolerance);
          if ( 0 != simple ) geosgeom.reset(simple);
          npoints = geosgeom->points();
        }
 
        resource->add(geosgeom.take());
 
        // Add the geometry point count to the resource if requested
        QString pointsKey = translateKeywordArgs("GisGeometryPointsKey", 
                                                 getGlobals(resource, globals), 
                                                 ""); 
        if ( !pointsKey.isEmpty() ) {
          resource->add(pointsKey, toString(npoints));
          resource->add(pointsKey+"Original", toString(npointsOrg));
          resource->add(pointsKey+"Tolerance", toString(tolerance));
        }
 
        //  Status if requested
        if ( isDebug() ) {
          cout << "  " << type() << ":" << name() << " has a geometry with "
               << npoints << " points!\n";
          if ( npoints != npointsOrg ) {
            cout << "  Geometry has been simplified/reduced from original " 
                 << npointsOrg << " points.\n";
          }
        }
        return (true);
      }
    }
  
    // Report geometry status
    if ( isDebug() ) {
      cout << "  " << type() << ":" << name() << " does not have a geometry!\n";
    }
  
    return (false);
  }
  
  
  ResourceList Strategy::activeList(ResourceList &resources) const {
    //  Create a list of active resources
    ResourceList v_active;
    BOOST_FOREACH ( SharedResource resource, resources ) {
      if ( !resource->isDiscarded() ) { v_active.append(resource); }
    }
   return (v_active);
  }
  
  
  void Strategy::activateList(ResourceList &resources) const {
    BOOST_FOREACH ( SharedResource resource, resources ) {
      resource->activate();
    }
  }
  
  
  void Strategy::deactivateList(ResourceList &resources) const {
    BOOST_FOREACH ( SharedResource resource, resources ) {
      resource->discard();
    }
  }
 
  
  ResourceList Strategy::copyList(const ResourceList &resources) const {
    ResourceList v_copy;
    BOOST_FOREACH ( SharedResource resource, resources ) {
      v_copy.append(SharedResource(resource->copy()));
    }
    return ( v_copy);
  }
 
 
  ResourceList Strategy::cloneList(const ResourceList &resources,
                                   const bool &withAssets) const {
    ResourceList v_clone;
    BOOST_FOREACH ( SharedResource resource, resources ) {
      v_clone.append(SharedResource(resource->clone(resource->name(), withAssets))); 
    }
    return ( v_clone );
  }
 
 
  int Strategy::applyToIntersectedGeometry(ResourceList &resources, 
                                           GisGeometry &geom,
                                           const ResourceList &globals) {
  
    QString method = getDefinitionMap().get("GisMethod", "direct").toLower();  
 
    // The programmer is required to ensure a valid geometry provides the
    // source of the intersection operation.
    if ( !geom.isValid() ) {
      QString mess = type() + ":" + name() + 
                     "Cannot apply RTree search to bad geometry."; 
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
  
    //  Create a list of active resources only
    ResourceList v_active = activeList(resources);
 
    // Use direct computation method 
    ResourceList overlaps;
    if ( "direct" == method ) {
      if ( isDebug() ) {
        cout << "Using direct Geom intersects for " << v_active.size() << " geometries...\n";
      }
 
      // Direct intersect computations of overlaps has about the same overhead 
      // of constructing an RTree index and running queries.
      initProgress(v_active.size());
      BOOST_FOREACH ( SharedResource resource, v_active ) {
        if ( resource->hasValidGeometry() ) {
          if ( geom.intersects( *resource->geometry()) ) {
            overlaps.append(resource);
          }
        }
        processed();
      }
    }
    else {
 
      //  Use RTree method to get potenital overlappers...
      if ( isDebug() ) {
        cout << "Allocating " << v_active.size() << " RTree geometries.\n";
      }
      GEOSSTRtree *rtree = GEOSSTRtree_create(v_active.size());
      if ( !rtree ) {
        QString mess = "GEOS RTree allocation failed for " +
                        toString(v_active.size()) + " geometries.";
          throw IException(IException::Programmer, mess, _FILEINFO_);
        }
 
      if ( isDebug() ) {
        cout << "GEOS RTree allocated " << v_active.size() << " geometry entries.\n";
      }
  
      // Create and query the RTree geometries calling once for each 
      // strategy::appy(SharedResource &) geometry that intersect the envelope.
      initProgress(v_active.size());
      int nvalid = 0;
      for ( int i = 0 ; i < v_active.size() ; i++ ) {
        if ( v_active[i]->hasValidGeometry() ) {
          GEOSSTRtree_insert(rtree, v_active[i]->geometry()->geometry(),
                             &v_active[i]); 
          nvalid++;
        }
        processed();
      }
 
      // Report number found...
      if ( isDebug() ) {
        cout << "Valid Geometries found: " << nvalid << " - running query...\n";
      }
  
      // Run the query
      GEOSSTRtree_query(rtree, geom.geometry(), &queryCallback, &overlaps);
      GEOSSTRtree_destroy(rtree);
    }
 
    if ( isDebug() ) {
      cout << "Potential Intersections Found: " << overlaps.size() << "\n";
    }
 
 
    // Now apply all intersected geometries to calling strategy. Note to 
    // properly reflect the intersected list, we must deactivate the entire
    // active list after the query search and activate each one prior to
    // applying it in the strategy method, which has the responsibility to
    // determine validity, and return the proper Resource list status to the
    // next strategy.
    deactivateList(v_active);
 
    initProgress(overlaps.size());
    int n = 0;  // Result count
    BOOST_FOREACH ( SharedResource resource, overlaps ) {
      resource->activate();
      n += apply(resource, globals);
      processed();
    }
 
 
    if ( isDebug() ) {
      cout << "Total valid Intersections Found: " << n << "\n"; 
    }
  
    return (n);
  }
  
  
  void Strategy::queryCallback(void *item, void *userdata) {
    SharedResource *resource = (SharedResource *) item;  // Maybe fancy casts?
    ResourceList *rlist = (ResourceList *) userdata;
    rlist->append(*resource);
    return;
  }
  
  
  bool Strategy::isDebug() const {
    return ( m_debug );
  }
 
 
  bool Strategy::doShowProgress() const {
    return ( !m_progress.isNull() );
  }
 
 
 
  bool Strategy::initProgress(const int &nsteps, const QString &text) {
    
    QString p_text = text;
    resetProcessed();
    bool status = false;
 
    //  Check for initialization 
    if ( !doShowProgress()  ) {
      PvlFlatMap p_var( getDefinitionMap() );
      if ( toBool(p_var.get("ShowProgress", "false")) ) {
        m_progress.reset( new Progress() );
        if ( p_text.isEmpty() ) { 
           p_text = type() + "::" + name();
        }
      }
    }
 
 
    // No check if progress is requested
    if ( doShowProgress() ) {
      if ( !p_text.isEmpty() ) m_progress->SetText(p_text);
      m_progress->SetMaximumSteps(nsteps);
      if ( nsteps > 0 ) m_progress->CheckStatus();
      status = true;
    }
 
    // Set up for systematic processing
    return (status);
  }
 
 
  QStringList Strategy::getObjectList(const PvlObject &source) const {
    QStringList objList;
    PvlObject::ConstPvlObjectIterator object = source.beginObject();
    while ( object != source.endObject() ) {
      objList << object->name();
      ++object;
    }
    return (objList);
  }
 
 
}  //namespace Isis