PolygonSeeder.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "PolygonSeeder.h"
 
#include "IException.h"
#include "LeastSquares.h"
#include "Plugin.h"
#include "PolygonTools.h"
#include "PolynomialBivariate.h"
#include "LeastSquares.h"
#include "FileName.h"
#include "ProjectionFactory.h"
#include "Pvl.h"
#include "PvlGroup.h"
 
 
namespace Isis {
  PolygonSeeder::PolygonSeeder(Pvl &pvl) {
    invalidInput = NULL;
    invalidInput = new Pvl(pvl);
 
    p_algorithmName = "Unknown";
 
    Parse(pvl);
  }
 
 
  PolygonSeeder::PolygonSeeder(const PolygonSeeder &other) {
    p_algorithmName = other.p_algorithmName;
    p_minimumThickness = other.p_minimumThickness;
    p_minimumArea = other.p_minimumArea;
  }
 
 
  PolygonSeeder::~PolygonSeeder() {
    if(invalidInput) {
      delete invalidInput;
      invalidInput = NULL;
    }
  }
 
 
  void PolygonSeeder::Parse(Pvl &pvl) {
 
    QString errorSpot;
 
    try {
      // Get info from Algorithm group
      errorSpot = "Algorithm";
      PvlGroup &algo = pvl.findGroup("PolygonSeederAlgorithm", Pvl::Traverse);
 
      // algo is such a cool name for a PvlGroup that it begs to be out done
      PvlGroup &invalgo = invalidInput->findGroup("PolygonSeederAlgorithm",
                          Pvl::Traverse);
 
      // Set the algorithm name
      errorSpot = "Name";
      p_algorithmName = (QString) algo["Name"];
 
      if(invalgo.hasKeyword("Name"))
        invalgo.deleteKeyword("Name");
 
      // Set the minimum thickness (Area / max(extent X, extent Y)**2
      errorSpot = "MinimumThickness";
      p_minimumThickness = 0.0;
      if(algo.hasKeyword("MinimumThickness")) {
        p_minimumThickness = (double) algo["MinimumThickness"];
      }
 
      if(invalgo.hasKeyword("MinimumThickness"))
        invalgo.deleteKeyword("MinimumThickness");
 
      // Set the minimum area
      errorSpot = "MinimumArea";
      p_minimumArea = 0.0;
      if(algo.hasKeyword("MinimumArea")) {
        p_minimumArea = (double) algo["MinimumArea"];
      }
 
      if(invalgo.hasKeyword("MinimumArea"))
        invalgo.deleteKeyword("MinimumArea");
    }
    catch(IException &e) {
      QString msg = "Improper format for PolygonSeeder PVL [";
      msg +=  pvl.fileName() + "]. Location [" + errorSpot + "]";
      throw IException(IException::User, msg, _FILEINFO_);
    }
 
    return;
  }
 
 
  QString PolygonSeeder::StandardTests(const geos::geom::MultiPolygon *xymp,
      const geos::geom::Envelope *xyBoundBox) {
    if(xymp->getArea() < MinimumArea()) {
      QString msg = "Polygon did not meet the minimum area of [";
      msg += toString(MinimumArea()) + "]";
      return msg;
    }
 
    double thickness =
      xymp->getArea() /
      pow(std::max(xyBoundBox->getWidth(), xyBoundBox->getHeight()), 2.0);
    if(thickness < MinimumThickness()) {
      QString msg = "Polygon did not meet the minimum thickness ratio of [";
      msg += toString(MinimumThickness()) + "]";
      return msg;
    }
 
    return "";
  }
 
  QString PolygonSeeder::Algorithm() const {
    return p_algorithmName;
  }
 
  double PolygonSeeder::MinimumThickness() {
    return p_minimumThickness;
  }
 
 
  double PolygonSeeder::MinimumArea() {
    return p_minimumArea;
  }
 
  PvlGroup PolygonSeeder::PluginParameters(QString grpName) {
    PvlGroup pluginInfo(grpName);
 
    PvlKeyword name("Name", p_algorithmName);
    PvlKeyword minThickness("MinimumThickness", toString(p_minimumThickness));
    PvlKeyword minArea("MinimumArea", toString(p_minimumArea));
 
    pluginInfo.addKeyword(name);
    pluginInfo.addKeyword(minThickness);
    pluginInfo.addKeyword(minArea);
 
    return pluginInfo;
  }
 
 
  Pvl PolygonSeeder::InvalidInput() {
    return *invalidInput;
  }
 
  const PolygonSeeder &PolygonSeeder::operator=(const PolygonSeeder &other) {
    p_algorithmName = other.p_algorithmName;
    p_minimumThickness = other.p_minimumThickness;
    p_minimumArea = other.p_minimumArea;
 
    return *this;
  }
 
}