Unverified Commit 424ec8e2 authored by Kristin's avatar Kristin Committed by GitHub
Browse files

Added more logging (#297) 

* Added more logging

* re-enable logging in Plugin

* Update based on feedback
parent acca16fa

include/usgscsm/UsgsAstroPlugin.h

+1 −0
Original line number Diff line number Diff line
@@ -59,6 +59,7 @@ private: 


    typedef csm::Model* (*sensorConstructor)(void);

    static std::map<std::string, sensorConstructor> MODELS;

    std::shared_ptr<spdlog::logger> m_logger;

};



#endif

include/usgscsm/UsgsAstroSarSensorModel.h

+6 −2
Original line number Diff line number Diff line
@@ -5,6 +5,8 @@ 
#include <SettableEllipsoid.h>

#include <CorrelationModel.h>



#include "spdlog/spdlog.h"



class UsgsAstroSarSensorModel : public csm::RasterGM, virtual public csm::SettableEllipsoid

{
@@ -23,9 +25,9 @@ class UsgsAstroSarSensorModel : public csm::RasterGM, virtual public csm::Settab 


    virtual std::string getModelState() const;



    static std::string constructStateFromIsd(const std::string imageSupportData, csm::WarningList *list);

    std::string constructStateFromIsd(const std::string imageSupportData, csm::WarningList *list);



    static std::string getModelNameFromModelState(const std::string& model_state);

    std::string getModelNameFromModelState(const std::string& model_state);



    virtual csm::ImageCoord groundToImage(

        const csm::EcefCoord& groundPt,
@@ -264,6 +266,8 @@ class UsgsAstroSarSensorModel : public csm::RasterGM, virtual public csm::Settab 
    std::vector<double> m_sunVelocity;

    double m_wavelength;

    LookDirection m_lookDirection;

    

    std::shared_ptr<spdlog::logger> m_logger = spdlog::get("usgscsm_logger");

};



#endif

src/UsgsAstroFrameSensorModel.cpp

+47 −11
Original line number Diff line number Diff line
@@ -31,10 +31,12 @@ const std::string UsgsAstroFrameSensorModel::m_parameterName[] = { 
};



UsgsAstroFrameSensorModel::UsgsAstroFrameSensorModel() {

  MESSAGE_LOG("Creating UsgsAstroFrameSensorModel");

  reset();

}



void UsgsAstroFrameSensorModel::reset() {

  MESSAGE_LOG("Resetting UsgsAstroFrameSensorModel");

    m_modelName = _SENSOR_MODEL_NAME;

    m_platformName = "";

    m_sensorName = "";
@@ -161,6 +163,10 @@ csm::ImageCoord UsgsAstroFrameSensorModel::groundToImage( 
    &m_iTransS[0], &m_iTransL[0],

    line, sample);





  MESSAGE_LOG("Computed groundToImage for {}, {}, {} as line, sample: {}, {}",

              groundPt.x, groundPt.y, groundPt.z, line, sample);



  return csm::ImageCoord(line, sample);

}
@@ -169,7 +175,7 @@ csm::ImageCoordCovar UsgsAstroFrameSensorModel::groundToImage(const csm::EcefCoo 
                                   double desiredPrecision,

                                   double *achievedPrecision,

                                   csm::WarningList *warnings) const {

    MESSAGE_LOG("Computeing groundToImage(Covar) for {}, {}, {}, with desired precision {}",

    MESSAGE_LOG("Computing groundToImage(Covar) for {}, {}, {}, with desired precision {}",

                groundPt.x, groundPt.y, groundPt.z, desiredPrecision);



    csm::EcefCoord gp;
@@ -182,6 +188,8 @@ csm::ImageCoordCovar UsgsAstroFrameSensorModel::groundToImage(const csm::EcefCoo 
   csm::ImageCoordCovar result(ip.line, ip.samp);

   // This is a partial, incorrect implementation to test if SocetGXP needs

   // this method implemented in order to load the sensor.

    MESSAGE_LOG("Computed groundToImage(Covar) for {}, {}, {}, as line, sample: {}, {}",

                groundPt.x, groundPt.y, groundPt.z, ip.line, ip.samp);

   return result;

}
@@ -242,6 +250,8 @@ csm::EcefCoord UsgsAstroFrameSensorModel::imageToGround(const csm::ImageCoord &i 
  double x, y, z;

  losEllipsoidIntersect(height, xc, yc, zc, xl, yl, zl, x, y, z);



  MESSAGE_LOG("Resulting EcefCoordinate: {}, {}, {}", x, y, z);



  return csm::EcefCoord(x, y, z);

}
@@ -251,9 +261,12 @@ csm::EcefCoordCovar UsgsAstroFrameSensorModel::imageToGround(const csm::ImageCoo 
                                  double *achievedPrecision,

                                  csm::WarningList *warnings) const {



    MESSAGE_LOG("Computeing imageToGround(Covar) for {}, {}, {}, with desired precision {}",

    MESSAGE_LOG("Computing imageToGround(Covar) for {}, {}, {}, with desired precision {}",

                imagePt.line, imagePt.samp, height, desiredPrecision);

    // This is an incomplete implementation to see if SocetGXP needs this method implemented.



    MESSAGE_LOG("This is an incomplete implementation to see if SocetGXP needs this method implemented"); 



    csm::EcefCoordCovar result;

    return result;

}
@@ -265,7 +278,7 @@ csm::EcefLocus UsgsAstroFrameSensorModel::imageToProximateImagingLocus(const csm 
                                                                double *achievedPrecision,

                                                                csm::WarningList *warnings) const {

  // Ignore the ground point?

  MESSAGE_LOG("Computeing imageToProximateImagingLocus(No ground) for point {}, {}, {}, with desired precision {}",

  MESSAGE_LOG("Computing imageToProximateImagingLocus(No ground) for point {}, {}, {}, with desired precision {}",

                               imagePt.line, imagePt.samp, desiredPrecision);

  return imageToRemoteImagingLocus(imagePt);

}
@@ -275,7 +288,7 @@ csm::EcefLocus UsgsAstroFrameSensorModel::imageToRemoteImagingLocus(const csm::I 
                                                             double desiredPrecision,

                                                             double *achievedPrecision,

                                                             csm::WarningList *warnings) const {

  MESSAGE_LOG("Computeing imageToProximateImagingLocus for {}, {}, {}, with desired precision {}",

  MESSAGE_LOG("Computing imageToProximateImagingLocus for {}, {}, {}, with desired precision {}",

                               imagePt.line, imagePt.samp, desiredPrecision);

  // Find the line,sample on the focal plane (mm)

  double focalPlaneX, focalPlaneY;
@@ -343,6 +356,8 @@ std::pair<csm::ImageCoord, csm::ImageCoord> UsgsAstroFrameSensorModel::getValidI 
    MESSAGE_LOG("Accessing Image Range");

    csm::ImageCoord min_pt(m_startingDetectorLine, m_startingDetectorSample);

    csm::ImageCoord max_pt(m_nLines, m_nSamples);

    MESSAGE_LOG("Valid image range: min {}, {} max: {}, {}", min_pt.samp, min_pt.line, 

                max_pt.samp, max_pt.line)

    return std::pair<csm::ImageCoord, csm::ImageCoord>(min_pt, max_pt);

}
@@ -391,6 +406,9 @@ csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(const csm::ImageCoor 
    return sensorPosition;

  }

  else {

    MESSAGE_LOG("ERROR: UsgsAstroFrameSensorModel::getSensorPosition: "

                "Image Coordinate {},{} out of Bounds",

                imagePt.line, imagePt.samp);

    throw csm::Error(csm::Error::BOUNDS,

                     "Image Coordinate out of Bounds",

                     "UsgsAstroFrameSensorModel::getSensorPosition");
@@ -408,6 +426,7 @@ csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(double time) const { 


        return sensorPosition;

    } else {

      MESSAGE_LOG("ERROR: UsgsAstroFrameSensorModel::getSensorPosition: Valid image time is 0.0");

        std::string aMessage = "Valid image time is 0.0";

        throw csm::Error(csm::Error::BOUNDS,

                         aMessage,
@@ -422,6 +441,7 @@ csm::EcefVector UsgsAstroFrameSensorModel::getSensorVelocity(const csm::ImageCoo 
  // Make sure the passed coordinate is with the image dimensions.

  if (imagePt.samp < 0.0 || imagePt.samp > m_nSamples ||

      imagePt.line < 0.0 || imagePt.line > m_nLines) {

    MESSAGE_LOG("ERROR: Image coordinate out of bounds.")

    throw csm::Error(csm::Error::BOUNDS, "Image coordinate out of bounds.",

                     "UsgsAstroFrameSensorModel::getSensorVelocity");

  }
@@ -643,19 +663,19 @@ void UsgsAstroFrameSensorModel::setImageIdentifier(const std::string& imageId, 




std::string UsgsAstroFrameSensorModel::getSensorIdentifier() const {

  MESSAGE_LOG("Accessing sensor ID");

  MESSAGE_LOG("Accessing sensor ID: {}", m_sensorName);

  return m_sensorName;

}





std::string UsgsAstroFrameSensorModel::getPlatformIdentifier() const {

  MESSAGE_LOG("Accessing platform ID");

  MESSAGE_LOG("Accessing platform ID: {}", m_platformName);

  return m_platformName;

}





std::string UsgsAstroFrameSensorModel::getCollectionIdentifier() const {

  MESSAGE_LOG("Accessing collection ID");

  MESSAGE_LOG("Accessing collection ID: {}", m_collectionIdentifier);

  return m_collectionIdentifier;

}
@@ -782,9 +802,12 @@ bool UsgsAstroFrameSensorModel::isValidModelState(const std::string& stringState 
  if (!missingKeywords.empty() && warnings) {

    std::ostringstream oss;

    std::copy(missingKeywords.begin(), missingKeywords.end(), std::ostream_iterator<std::string>(oss, " "));



    MESSAGE_LOG("State has missing keywords: {} ", oss.str()); 



    warnings->push_back(csm::Warning(

      csm::Warning::DATA_NOT_AVAILABLE,

      "State has missing keywrods: " + oss.str(),

      "State has missing keywords: " + oss.str(),

      "UsgsAstroFrameSensorModel::isValidModelState"

    ));

  }
@@ -792,6 +815,9 @@ bool UsgsAstroFrameSensorModel::isValidModelState(const std::string& stringState 
  std::string modelName = jsonState.value<std::string>("m_modelName", "");



  if (modelName != _SENSOR_MODEL_NAME && warnings) {

    MESSAGE_LOG("Incorrect model name in state, expected {} but got {}",

                _SENSOR_MODEL_NAME, modelName);

 

    warnings->push_back(csm::Warning(

      csm::Warning::DATA_NOT_AVAILABLE,

      "Incorrect model name in state, expected " + _SENSOR_MODEL_NAME + " but got " + modelName,
@@ -822,7 +848,7 @@ bool UsgsAstroFrameSensorModel::isValidIsd(const std::string& Isd, csm::WarningL 
void UsgsAstroFrameSensorModel::replaceModelState(const std::string& stringState) {



    json state = json::parse(stringState);

    MESSAGE_LOG("Replaceing model state");

    MESSAGE_LOG("Replacing model state");

    // The json library's .at() will except if key is missing

    try {

        m_modelName = state.at("m_modelName").get<std::string>();
@@ -856,6 +882,7 @@ void UsgsAstroFrameSensorModel::replaceModelState(const std::string& stringState 
        m_currentParameterCovariance = state.at("m_currentParameterCovariance").get<std::vector<double>>();

    }

    catch(std::out_of_range& e) {

      MESSAGE_LOG("State keywords required to generate sensor model missing: " + std::string(e.what()) + "\nUsing model string: " + stringState + "UsgsAstroFrameSensorModel::replaceModelState");

      throw csm::Error(csm::Error::SENSOR_MODEL_NOT_CONSTRUCTIBLE,

                       "State keywords required to generate sensor model missing: " + std::string(e.what()) + "\nUsing model string: " + stringState,

                       "UsgsAstroFrameSensorModel::replaceModelState");
@@ -913,6 +940,8 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(const std::string& 
    }



    if (!positions.empty() && positions.size() != 3) {

      MESSAGE_LOG("Sensor position does not have 3 values, "

                  "UsgsAstroFrameSensorModel::constructStateFromIsd()");

      parsingWarnings->push_back(

        csm::Warning(

          csm::Warning::DATA_NOT_AVAILABLE,
@@ -928,6 +957,8 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(const std::string& 


    // get sensor_velocity

    if (!velocities.empty() && velocities.size() != 3) {

      MESSAGE_LOG("Sensor velocity does not have 3 values, "

                  "UsgsAstroFrameSensorModel::constructStateFromIsd()");

      parsingWarnings->push_back(

        csm::Warning(

          csm::Warning::DATA_NOT_AVAILABLE,
@@ -975,6 +1006,8 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(const std::string& 
    }



    if (quaternions.size() != 4) {

      MESSAGE_LOG("Sensor quaternion does not have 4 values, "

                  "UsgsAstroFrameSensorModel::constructStateFromIsd()");

      parsingWarnings->push_back(

        csm::Warning(

          csm::Warning::DATA_NOT_AVAILABLE,
@@ -1032,6 +1065,7 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(const std::string& 
                               state["m_transY"][2].get<double>() * state["m_iTransS"][0].get<double>());

    }

    catch (...) {

      MESSAGE_LOG("Could not compute detector pixel to focal plane coordinate transformation.");

      parsingWarnings->push_back(

        csm::Warning(

          csm::Warning::DATA_NOT_AVAILABLE,
@@ -1053,6 +1087,8 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(const std::string& 
      }

      delete parsingWarnings;

      parsingWarnings = nullptr;

      MESSAGE_LOG("ISD is invalid for creating the sensor model.");

                  

      throw csm::Error(csm::Error::SENSOR_MODEL_NOT_CONSTRUCTIBLE,

                       "ISD is invalid for creating the sensor model.",

                       "UsgsAstroFrameSensorModel::constructStateFromIsd");

src/UsgsAstroPlugin.cpp

+123 −92
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ using json = nlohmann::json; 
# define DIR_DELIMITER_STR  "/"

#endif



#define MESSAGE_LOG(...) if (m_logger) { m_logger->info(__VA_ARGS__); }



// Declaration of static variables

const std::string UsgsAstroPlugin::_PLUGIN_NAME = "UsgsAstroPluginCSM";
@@ -37,17 +38,17 @@ const UsgsAstroPlugin UsgsAstroPlugin::m_registeredPlugin; 


UsgsAstroPlugin::UsgsAstroPlugin() {



  // Build and register the USGSCSM logger on pluggin creation

  // Build and register the USGSCSM logger on plugin creation

  char * logFilePtr = getenv("ALE_LOG_FILE");



  if (logFilePtr != NULL) {

    std::string logFile(logFilePtr);



    if (logFile != "") {

      std::shared_ptr<spdlog::logger> logger = spdlog::get("usgscsm_logger");

      std::shared_ptr<spdlog::logger> m_logger = spdlog::get("usgscsm_logger");



      if (!logger) {

        std::shared_ptr<spdlog::logger> new_logger = spdlog::basic_logger_mt("usgscsm_logger", logFile);

      if (!m_logger) {

        std::shared_ptr<spdlog::logger> m_logger = spdlog::basic_logger_mt("usgscsm_logger", logFile);

      }

    }

  }
@@ -59,26 +60,31 @@ UsgsAstroPlugin::~UsgsAstroPlugin() { 




std::string UsgsAstroPlugin::getPluginName() const {

  MESSAGE_LOG("Get Plugin Name: {}", _PLUGIN_NAME);

  return _PLUGIN_NAME;

}





std::string UsgsAstroPlugin::getManufacturer() const {

  MESSAGE_LOG("Get Manufacturer Name: {}", _MANUFACTURER_NAME);

  return _MANUFACTURER_NAME;

}





std::string UsgsAstroPlugin::getReleaseDate() const {

  MESSAGE_LOG("Get Release Date: {}", _RELEASE_DATE);

  return _RELEASE_DATE;

}





csm::Version UsgsAstroPlugin::getCsmVersion() const {

  MESSAGE_LOG("Get Current CSM Version");

  return CURRENT_CSM_VERSION;

}





size_t UsgsAstroPlugin::getNumModels() const {

  MESSAGE_LOG("Get Number of Sensor Models: {}", _N_SENSOR_MODELS);

  return _N_SENSOR_MODELS;

}
@@ -89,16 +95,19 @@ std::string UsgsAstroPlugin::getModelName(size_t modelIndex) const { 
    UsgsAstroLsSensorModel::_SENSOR_MODEL_NAME,

    UsgsAstroSarSensorModel::_SENSOR_MODEL_NAME

  };

  MESSAGE_LOG("Get Model Name: {}. Used index: {}", supportedModelNames[modelIndex], modelIndex);

  return supportedModelNames[modelIndex];

}





std::string UsgsAstroPlugin::getModelFamily(size_t modelIndex) const {

  MESSAGE_LOG("Get Model Familey: {}", CSM_RASTER_FAMILY); 

  return CSM_RASTER_FAMILY;

}





csm::Version UsgsAstroPlugin::getModelVersion(const std::string &modelName) const {

  MESSAGE_LOG("Get Model Version");

  return csm::Version(1, 0, 0);

}
@@ -116,6 +125,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromState(const std::string &modelNam 
    msg += "] with error [";

    msg += e.what();

    msg += "]";

    MESSAGE_LOG(msg);

    if(warnings) {

      warnings->push_back(

        csm::Warning(
@@ -129,6 +139,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromState(const std::string &modelNam 
    std::string msg = "Could not create model [";

    msg += modelName;

    msg += "] with an unknown error.";

    MESSAGE_LOG(msg);

    if(warnings) {

      warnings->push_back(

        csm::Warning(
@@ -155,6 +166,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromISD(const csm::Isd &imageSupportD 
      msg += "] with error [";

      msg += e.what();

      msg += "]";

      MESSAGE_LOG(msg);

      warnings->push_back(

        csm::Warning(

          csm::Warning::UNKNOWN_WARNING,
@@ -167,6 +179,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromISD(const csm::Isd &imageSupportD 
      std::string msg = "Could not create model [";

      msg += modelName;

      msg += "] with an unknown error.";

      MESSAGE_LOG(msg);

      warnings->push_back(

        csm::Warning(

          csm::Warning::UNKNOWN_WARNING,
@@ -190,7 +203,8 @@ std::string UsgsAstroPlugin::loadImageSupportData(const csm::Isd &imageSupportDa 
  lastIndex = baseName.find_last_of(DIR_DELIMITER_STR);

  std::string filename = baseName.substr(lastIndex + 1);

  std::string isdFilename = baseName.append(".json");



  MESSAGE_LOG("Load Image Support Data using: {}, {}, {}, {}, {}", 

              imageFilename, lastIndex, baseName, filename, isdFilename);

  try {

    std::ifstream isd_sidecar(isdFilename);

    json jsonisd;
@@ -205,6 +219,7 @@ std::string UsgsAstroPlugin::loadImageSupportData(const csm::Isd &imageSupportDa 
    errorMessage += "] with error [";

    errorMessage += e.what();

    errorMessage += "]";

    MESSAGE_LOG(errorMessage);

    throw csm::Error(csm::Error::FILE_READ, errorMessage,

                     "UsgsAstroPlugin::loadImageSupportData");

  }
@@ -216,11 +231,12 @@ std::string UsgsAstroPlugin::getModelNameFromModelState(const std::string &model 
  auto state = json::parse(modelState);



  std::string name = state.value<std::string>("name_model", "");



  MESSAGE_LOG("Get model name from model state. State: {}, Name: {}", modelState, name);

  if (name == "") {

      csm::Error::ErrorType aErrorType = csm::Error::INVALID_SENSOR_MODEL_STATE;

      std::string aMessage = "No 'name_model' key in the model state object.";

      std::string aFunction = "UsgsAstroPlugin::getModelNameFromModelState";

      MESSAGE_LOG(aMessage);

      csm::Error csmErr(aErrorType, aMessage, aFunction);

      throw(csmErr);

  }
@@ -232,6 +248,7 @@ std::string UsgsAstroPlugin::getModelNameFromModelState(const std::string &model 
bool UsgsAstroPlugin::canISDBeConvertedToModelState(const csm::Isd &imageSupportData,

                                               const std::string &modelName,

                                               csm::WarningList *warnings) const {

  MESSAGE_LOG("Running canISDBeConvertedToModelState");

  try {

       convertISDToModelState(imageSupportData, modelName, warnings);

  }
@@ -242,6 +259,7 @@ bool UsgsAstroPlugin::canISDBeConvertedToModelState(const csm::Isd &imageSupport 
      msg += "] state with error [";

      msg += e.what();

      msg += "]";

      MESSAGE_LOG(msg);

      warnings->push_back(

        csm::Warning(

          csm::Warning::UNKNOWN_WARNING,
@@ -255,7 +273,9 @@ bool UsgsAstroPlugin::canISDBeConvertedToModelState(const csm::Isd &imageSupport 




std::string UsgsAstroPlugin::getStateFromISD(csm::Isd imageSupportData) const {

  MESSAGE_LOG("Running getStateFromISD");

  std::string stringIsd = loadImageSupportData(imageSupportData);

  MESSAGE_LOG("ISD string: {}", stringIsd);

  json jsonIsd = json::parse(stringIsd);

  return convertISDToModelState(imageSupportData, jsonIsd.at("name_model"));

}
@@ -264,7 +284,7 @@ std::string UsgsAstroPlugin::getStateFromISD(csm::Isd imageSupportData) const { 
std::string UsgsAstroPlugin::convertISDToModelState(const csm::Isd &imageSupportData,

                                               const std::string &modelName,

                                               csm::WarningList *warnings) const {



  MESSAGE_LOG("Running convertISDToModelState");

  csm::Model* sensor_model = constructModelFromISD(imageSupportData, modelName, warnings);

  return sensor_model->getModelState();

}
@@ -273,16 +293,16 @@ std::string UsgsAstroPlugin::convertISDToModelState(const csm::Isd &imageSupport 
csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportDataOriginal,

                                              const std::string &modelName,

                                              csm::WarningList *warnings) const {

  MESSAGE_LOG("Running constructModelFromISD");

  std::string stringIsd = loadImageSupportData(imageSupportDataOriginal);

  

  MESSAGE_LOG("ISD String: {}", stringIsd);

  if (modelName == UsgsAstroFrameSensorModel::_SENSOR_MODEL_NAME) {

    UsgsAstroFrameSensorModel *model =  new UsgsAstroFrameSensorModel();

    try {

      MESSAGE_LOG("Trying to construct a UsgsAstroFrameSensorModel");

      model->replaceModelState(model->constructStateFromIsd(stringIsd, warnings));

        std::shared_ptr<spdlog::logger> logger = model->getLogger();

        if (logger) {

          logger->info("Constructed model: {}", modelName);

        }

      MESSAGE_LOG("Constructed model: {}", modelName);

    }

    catch (std::exception& e) {

      csm::Error::ErrorType aErrorType = csm::Error::SENSOR_MODEL_NOT_CONSTRUCTIBLE;
@@ -291,6 +311,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportD 
      aMessage += "] with error [";

      aMessage += e.what();

      aMessage += "]";

      MESSAGE_LOG(aMessage);

      std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";

      throw csm::Error(aErrorType, aMessage, aFunction);

    }
@@ -299,6 +320,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportD 
  else if (modelName == UsgsAstroLsSensorModel::_SENSOR_MODEL_NAME) {

    UsgsAstroLsSensorModel *model =  new UsgsAstroLsSensorModel();

    try {

      MESSAGE_LOG("Trying to construct a UsgsAstroLsSensorModel");

      model->replaceModelState(model->constructStateFromIsd(stringIsd, warnings));

    }

    catch (std::exception& e) {
@@ -309,12 +331,14 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportD 
      aMessage += e.what();

      aMessage += "]";

      std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";

      MESSAGE_LOG(aMessage);

      throw csm::Error(aErrorType, aMessage, aFunction);

    }

    return model;

  }

  else if (modelName == UsgsAstroSarSensorModel::_SENSOR_MODEL_NAME) {

    UsgsAstroSarSensorModel *model =  new UsgsAstroSarSensorModel();

    MESSAGE_LOG("Trying to construct a UsgsAstroSarSensorModel");

    try {

      model->replaceModelState(model->constructStateFromIsd(stringIsd, warnings));

    }
@@ -326,6 +350,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportD 
      aMessage += e.what();

      aMessage += "]";

      std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";

      MESSAGE_LOG(aMessage);

      throw csm::Error(aErrorType, aMessage, aFunction);

    }

    return model;
@@ -334,6 +359,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportD 
    csm::Error::ErrorType aErrorType = csm::Error::SENSOR_MODEL_NOT_SUPPORTED;

    std::string aMessage = "Model [" + modelName + "] not supported: ";

    std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";

    MESSAGE_LOG(aMessage);

    throw csm::Error(aErrorType, aMessage, aFunction);

  }

}
@@ -341,21 +367,25 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(const csm::Isd &imageSupportD 


csm::Model *UsgsAstroPlugin::constructModelFromState(const std::string& modelState,

                                                csm::WarningList *warnings) const {



  MESSAGE_LOG("Runing constructModelFromState with modelState: {}", modelState);

  json state = json::parse(modelState);

  std::string modelName = state["m_modelName"];

  MESSAGE_LOG("Using model name: {}", modelName);



  if (modelName == UsgsAstroFrameSensorModel::_SENSOR_MODEL_NAME) {

    MESSAGE_LOG("Constructing a UsgsAstroFrameSensorModel");

    UsgsAstroFrameSensorModel* model = new UsgsAstroFrameSensorModel();

    model->replaceModelState(modelState);

    return model;

  }

  else if (modelName == UsgsAstroLsSensorModel::_SENSOR_MODEL_NAME) {

    MESSAGE_LOG("Constructing a UsgsAstroLsSensorModel");

    UsgsAstroLsSensorModel* model = new UsgsAstroLsSensorModel();

    model->replaceModelState(modelState);

    return model;

  }

  else if (modelName == UsgsAstroSarSensorModel::_SENSOR_MODEL_NAME) {

    MESSAGE_LOG("Constructing a UsgsAstroSarSensorModel");

    UsgsAstroSarSensorModel* model = new UsgsAstroSarSensorModel();

    model->replaceModelState(modelState);

    return model;
@@ -364,6 +394,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromState(const std::string& modelSta 
    csm::Error::ErrorType aErrorType = csm::Error::ISD_NOT_SUPPORTED;

    std::string aMessage = "Model" + modelName + " not supported: ";

    std::string aFunction = "UsgsAstroPlugin::constructModelFromState()";

    MESSAGE_LOG(aMessage);

    throw csm::Error(aErrorType, aMessage, aFunction);

  }

}

src/UsgsAstroSarSensorModel.cpp

+84 −70

File changed.

Preview size limit exceeded, changes collapsed.