From a01988bf04f133bb20d953bab60187914b5a63f7 Mon Sep 17 00:00:00 2001
From: Jesse Mapel <jmapel@usgs.gov>
Date: Wed, 10 Aug 2022 13:08:50 -0700
Subject: [PATCH] Added log levels (#414)
* Added log levels to line scan
* Fixed bold in readme
* Added flush on exit to ls
* Added plugin logging
* frame logging
* Added output to info logs
---
README.md | 25 +-
src/UsgsAstroFrameSensorModel.cpp | 258 +++++++++++++--------
src/UsgsAstroLsSensorModel.cpp | 364 ++++++++++++++++++++++--------
src/UsgsAstroPlugin.cpp | 98 ++++----
tests/Fixtures.h | 1 +
5 files changed, 514 insertions(+), 232 deletions(-)
diff --git a/README.md b/README.md
index c22e4e4..672781c 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
<p align="center">
- <img src="docs/USGSCSM_Logo.svg" alt="USGSCSM" width=200>
+ <img src="docs/USGSCSM_Logo.svg" alt="USGSCSM" width=200>
</p>
# USGSCSM
-This library provides *Community Sensor Model (CSM)*-compliant sensor models
+This library provides *Community Sensor Model (CSM)*-compliant sensor models
created by the USGS Astrogeology Science Center.
USGSCSM contains three different sensor models. The first is a
@@ -71,7 +71,26 @@ camera operations, as described in its
Logging of the internal operations in the sensor models can be enabled by setting
the `USGSCSM_LOG_FILE` environment variable to the file the log should be written to.
To have the logging information printed to the standard output or standard error, set
-this to `stdout` or `stderr`. Note that these logs can become several GB in size.
+this to `stdout` or `stderr`.
+
+You can adjust how much information is logged by setting the `USGSCSM_LOG_LEVEL`
+environment variable. The log level is not case sensitive.
+The log levels are:
+
+| Level | Description |
+| ----- | ----------- |
+| trace | Intermediate calculation values |
+| debug | All function calls and returns |
+| **info** | Only core photogrammetry calls and returns - Default log level |
+| warn | CSM warnings |
+| err | CSM exceptions |
+| critical | Critical errors |
+| off | No log messages |
+
+All log messages of level `USGSCSM_LOG_LEVEL` and below will be logged. For example,
+setting the log level to *info* will log all messages of types *info*, *warn*, *err*,
+*critical*, and *off*. Note that these logs can become several GB in size when the
+log level is set to *debug* or *trace*.
---
diff --git a/src/UsgsAstroFrameSensorModel.cpp b/src/UsgsAstroFrameSensorModel.cpp
index 363b79a..2b928ab 100644
--- a/src/UsgsAstroFrameSensorModel.cpp
+++ b/src/UsgsAstroFrameSensorModel.cpp
@@ -13,7 +13,7 @@
#define MESSAGE_LOG(...) \
if (m_logger) { \
- m_logger->info(__VA_ARGS__); \
+ m_logger->log(__VA_ARGS__); \
}
using json = nlohmann::json;
@@ -33,12 +33,12 @@ const std::string UsgsAstroFrameSensorModel::m_parameterName[] = {
};
UsgsAstroFrameSensorModel::UsgsAstroFrameSensorModel() {
- MESSAGE_LOG("Creating UsgsAstroFrameSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Creating UsgsAstroFrameSensorModel");
reset();
}
void UsgsAstroFrameSensorModel::reset() {
- MESSAGE_LOG("Resetting UsgsAstroFrameSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Resetting UsgsAstroFrameSensorModel");
m_modelName = _SENSOR_MODEL_NAME;
m_platformName = "";
m_sensorName = "";
@@ -106,12 +106,18 @@ csm::ImageCoord UsgsAstroFrameSensorModel::groundToImage(
const csm::EcefCoord &groundPt, double desiredPrecision,
double *achievedPrecision, csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing groundToImage(No adjustments) for {}, {}, {}, with desired "
"precision {}",
groundPt.x, groundPt.y, groundPt.z, desiredPrecision);
- return groundToImage(groundPt, m_noAdjustments, desiredPrecision,
- achievedPrecision, warnings);
+ csm::ImageCoord imagePt = groundToImage(
+ groundPt, m_noAdjustments, desiredPrecision, achievedPrecision, warnings);
+ MESSAGE_LOG(
+ spdlog::level::info,
+ "groundToImage result of ({}, {})",
+ imagePt.line, imagePt.samp);
+ return imagePt;
}
/**
@@ -129,6 +135,7 @@ csm::ImageCoord UsgsAstroFrameSensorModel::groundToImage(
double desired_precision, double *achieved_precision,
csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing groundToImage for {}, {}, {}, with desired precision {}",
groundPt.x, groundPt.y, groundPt.z, desired_precision);
@@ -178,8 +185,10 @@ csm::ImageCoord UsgsAstroFrameSensorModel::groundToImage(
sample = jitteredSample;
}
- MESSAGE_LOG("Computed groundToImage for {}, {}, {} as line, sample: {}, {}",
- groundPt.x, groundPt.y, groundPt.z, line, sample);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Computed groundToImage for {}, {}, {} as line, sample: {}, {}",
+ groundPt.x, groundPt.y, groundPt.z, line, sample);
return csm::ImageCoord(line, sample);
}
@@ -188,6 +197,7 @@ csm::ImageCoordCovar UsgsAstroFrameSensorModel::groundToImage(
const csm::EcefCoordCovar &groundPt, double desiredPrecision,
double *achievedPrecision, csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing groundToImage(Covar) for {}, {}, {}, with desired precision "
"{}",
groundPt.x, groundPt.y, groundPt.z, desiredPrecision);
@@ -203,6 +213,7 @@ csm::ImageCoordCovar UsgsAstroFrameSensorModel::groundToImage(
// This is a partial, incorrect implementation to test if SocetGXP needs
// this method implemented in order to load the sensor.
MESSAGE_LOG(
+ spdlog::level::debug,
"Computed groundToImage(Covar) for {}, {}, {}, as line, sample: {}, {}",
groundPt.x, groundPt.y, groundPt.z, ip.line, ip.samp);
return result;
@@ -212,6 +223,7 @@ csm::EcefCoord UsgsAstroFrameSensorModel::imageToGround(
const csm::ImageCoord &imagePt, double height, double desiredPrecision,
double *achievedPrecision, csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing imageToGround for {}, {}, {}, with desired precision {}",
imagePt.line, imagePt.samp, height, desiredPrecision);
@@ -222,6 +234,7 @@ csm::EcefCoord UsgsAstroFrameSensorModel::imageToGround(
double m[3][3];
calcRotationMatrix(m);
MESSAGE_LOG(
+ spdlog::level::trace,
"Calculated rotation matrix [{}, {}, {}], [{}, {}, {}], [{}, {}, {}]",
m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1],
m[2][2]);
@@ -245,8 +258,10 @@ csm::EcefCoord UsgsAstroFrameSensorModel::imageToGround(
double undistortedX, undistortedY;
removeDistortion(x_camera, y_camera, undistortedX, undistortedY,
m_opticalDistCoeffs, m_distortionType);
- MESSAGE_LOG("Found undistortedX: {}, and undistortedY: {}", undistortedX,
- undistortedY);
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "Found undistortedX: {}, and undistortedY: {}",
+ undistortedX, undistortedY);
// Now back from distorted mm to pixels
double xl, yl, zl;
@@ -256,20 +271,25 @@ csm::EcefCoord UsgsAstroFrameSensorModel::imageToGround(
m[1][2] * -m_focalLength;
zl = m[2][0] * undistortedX + m[2][1] * undistortedY -
m[2][2] * -m_focalLength;
- MESSAGE_LOG("Compute xl, yl, zl as {}, {}, {}", xl, yl, zl);
+ MESSAGE_LOG(spdlog::level::trace, "Compute xl, yl, zl as {}, {}, {}", xl, yl, zl);
double xc, yc, zc;
xc = m_currentParameterValue[0];
yc = m_currentParameterValue[1];
zc = m_currentParameterValue[2];
- MESSAGE_LOG("Set xc, yc, zc to {}, {}, {}", m_currentParameterValue[0],
- m_currentParameterValue[1], m_currentParameterValue[2]);
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "Set xc, yc, zc to {}, {}, {}", m_currentParameterValue[0],
+ m_currentParameterValue[1], m_currentParameterValue[2]);
// Intersect with some height about the ellipsoid.
double x, y, z;
losEllipsoidIntersect(height, xc, yc, zc, xl, yl, zl, x, y, z, warnings);
- MESSAGE_LOG("Resulting EcefCoordinate: {}, {}, {}", x, y, z);
+ MESSAGE_LOG(
+ spdlog::level::info,
+ "Resulting EcefCoordinate: {}, {}, {}",
+ x, y, z);
return csm::EcefCoord(x, y, z);
}
@@ -279,6 +299,7 @@ csm::EcefCoordCovar UsgsAstroFrameSensorModel::imageToGround(
double desiredPrecision, double *achievedPrecision,
csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing imageToGround(Covar) for {}, {}, {}, with desired precision "
"{}",
imagePt.line, imagePt.samp, height, desiredPrecision);
@@ -286,6 +307,7 @@ csm::EcefCoordCovar UsgsAstroFrameSensorModel::imageToGround(
// implemented.
MESSAGE_LOG(
+ spdlog::level::trace,
"This is an incomplete implementation to see if SocetGXP needs this "
"method implemented");
@@ -298,6 +320,7 @@ csm::EcefLocus UsgsAstroFrameSensorModel::imageToProximateImagingLocus(
double desiredPrecision, double *achievedPrecision,
csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing imageToProximateImagingLocus(No ground) for point {}, {}, {}, "
"with desired precision {}",
imagePt.line, imagePt.samp, desiredPrecision);
@@ -316,19 +339,29 @@ csm::EcefLocus UsgsAstroFrameSensorModel::imageToProximateImagingLocus(
csm::EcefVector positionToClosest =
dot(remoteLocus.direction, positionToGround) * remoteLocus.direction;
- return csm::EcefLocus(
+ csm::EcefLocus locus(
remoteLocus.point.x + positionToClosest.x,
remoteLocus.point.y + positionToClosest.y,
remoteLocus.point.z + positionToClosest.z,
remoteLocus.direction.x,
remoteLocus.direction.y,
remoteLocus.direction.z);
+
+ MESSAGE_LOG(
+ spdlog::level::info,
+ "imageToProximateImagingLocus result of point ({}, {}, {}) "
+ "direction ({}, {}, {}).",
+ locus.point.x, locus.point.y, locus.point.z,
+ locus.direction.x, locus.direction.y, locus.direction.z);
+
+ return locus;
}
csm::EcefLocus UsgsAstroFrameSensorModel::imageToRemoteImagingLocus(
const csm::ImageCoord &imagePt, double desiredPrecision,
double *achievedPrecision, csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing imageToProximateImagingLocus for {}, {}, {}, with desired "
"precision {}",
imagePt.line, imagePt.samp, desiredPrecision);
@@ -371,8 +404,10 @@ csm::EcefLocus UsgsAstroFrameSensorModel::imageToRemoteImagingLocus(
}
csm::ImageCoord UsgsAstroFrameSensorModel::getImageStart() const {
- MESSAGE_LOG("Accessing Image Start line: {}, sample: {}",
- m_startingDetectorLine, m_startingDetectorSample);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing Image Start line: {}, sample: {}",
+ m_startingDetectorLine, m_startingDetectorSample);
csm::ImageCoord start;
start.samp = m_startingDetectorSample;
start.line = m_startingDetectorLine;
@@ -380,8 +415,10 @@ csm::ImageCoord UsgsAstroFrameSensorModel::getImageStart() const {
}
csm::ImageVector UsgsAstroFrameSensorModel::getImageSize() const {
- MESSAGE_LOG("Accessing Image Size line: {}, sample: {}", m_nLines,
- m_nSamples);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing Image Size line: {}, sample: {}",
+ m_nLines, m_nSamples);
csm::ImageVector size;
size.line = m_nLines;
size.samp = m_nSamples;
@@ -390,26 +427,30 @@ csm::ImageVector UsgsAstroFrameSensorModel::getImageSize() const {
std::pair<csm::ImageCoord, csm::ImageCoord>
UsgsAstroFrameSensorModel::getValidImageRange() const {
- MESSAGE_LOG("Accessing Image Range");
+ MESSAGE_LOG(spdlog::level::debug, "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,
+ MESSAGE_LOG(spdlog::level::debug, "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);
}
std::pair<double, double> UsgsAstroFrameSensorModel::getValidHeightRange()
const {
- MESSAGE_LOG("Accessing Image Height min: {}, max: {}", m_minElevation,
- m_maxElevation);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing Image Height min: {}, max: {}",
+ m_minElevation, m_maxElevation);
return std::pair<double, double>(m_minElevation, m_maxElevation);
}
csm::EcefVector UsgsAstroFrameSensorModel::getIlluminationDirection(
const csm::EcefCoord &groundPt) const {
// ground (body-fixed) - sun (body-fixed) gives us the illumination direction.
- MESSAGE_LOG("Accessing illumination direction for ground point {}, {}, {}",
- groundPt.x, groundPt.y, groundPt.z);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing illumination direction for ground point {}, {}, {}",
+ groundPt.x, groundPt.y, groundPt.z);
return csm::EcefVector{groundPt.x - m_sunPosition[0],
groundPt.y - m_sunPosition[1],
groundPt.z - m_sunPosition[2]};
@@ -417,8 +458,10 @@ csm::EcefVector UsgsAstroFrameSensorModel::getIlluminationDirection(
double UsgsAstroFrameSensorModel::getImageTime(
const csm::ImageCoord &imagePt) const {
- MESSAGE_LOG("Accessing image time for image point {}, {}", imagePt.line,
- imagePt.samp);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing image time for image point {}, {}",
+ imagePt.line, imagePt.samp);
// The entire image is aquired at once so image time for all pixels is the
// reference time
return 0.0;
@@ -426,8 +469,10 @@ double UsgsAstroFrameSensorModel::getImageTime(
csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(
const csm::ImageCoord &imagePt) const {
- MESSAGE_LOG("Accessing sensor position for image point {}, {}", imagePt.line,
- imagePt.samp);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing sensor position for image point {}, {}",
+ imagePt.line, imagePt.samp);
// check if the image point is in range
if (imagePt.samp >= m_startingDetectorSample &&
imagePt.samp <= (m_startingDetectorSample + m_nSamples) &&
@@ -441,6 +486,7 @@ csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(
return sensorPosition;
} else {
MESSAGE_LOG(
+ spdlog::level::err,
"ERROR: UsgsAstroFrameSensorModel::getSensorPosition: "
"Image Coordinate {},{} out of Bounds",
imagePt.line, imagePt.samp);
@@ -450,7 +496,7 @@ csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(
}
csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(double time) const {
- MESSAGE_LOG("Accessing sensor position for time {}", time);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing sensor position for time {}", time);
if (time == 0.0) {
csm::EcefCoord sensorPosition;
sensorPosition.x = m_currentParameterValue[0];
@@ -460,6 +506,7 @@ csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(double time) const {
return sensorPosition;
} else {
MESSAGE_LOG(
+ spdlog::level::err,
"ERROR: UsgsAstroFrameSensorModel::getSensorPosition: Valid image time "
"is 0.0");
std::string aMessage = "Valid image time is 0.0";
@@ -470,12 +517,14 @@ csm::EcefCoord UsgsAstroFrameSensorModel::getSensorPosition(double time) const {
csm::EcefVector UsgsAstroFrameSensorModel::getSensorVelocity(
const csm::ImageCoord &imagePt) const {
- MESSAGE_LOG("Accessing sensor velocity for image point {}, {}", imagePt.line,
- imagePt.samp);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing sensor velocity for image point {}, {}",
+ imagePt.line, imagePt.samp);
// 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.")
+ MESSAGE_LOG(spdlog::level::err, "ERROR: Image coordinate out of bounds.")
throw csm::Error(csm::Error::BOUNDS, "Image coordinate out of bounds.",
"UsgsAstroFrameSensorModel::getSensorVelocity");
}
@@ -487,7 +536,7 @@ csm::EcefVector UsgsAstroFrameSensorModel::getSensorVelocity(
csm::EcefVector UsgsAstroFrameSensorModel::getSensorVelocity(
double time) const {
- MESSAGE_LOG("Accessing sensor position for time {}", time);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing sensor position for time {}", time);
if (time == 0.0) {
return csm::EcefVector{m_spacecraftVelocity[0], m_spacecraftVelocity[1],
m_spacecraftVelocity[2]};
@@ -502,6 +551,7 @@ csm::RasterGM::SensorPartials UsgsAstroFrameSensorModel::computeSensorPartials(
int index, const csm::EcefCoord &groundPt, double desiredPrecision,
double *achievedPrecision, csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing sensor partials image point from ground point {}, {}, {} \
and desiredPrecision: {}",
groundPt.x, groundPt.y, groundPt.z, desiredPrecision);
@@ -533,6 +583,7 @@ csm::RasterGM::SensorPartials UsgsAstroFrameSensorModel::computeSensorPartials(
double desiredPrecision, double *achievedPrecision,
csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing sensor partials for ground point {}, {}, {}\
with point: {}, {}, index: {}, and desiredPrecision: {}",
groundPt.x, groundPt.y, groundPt.z, imagePt.line, imagePt.samp, index,
@@ -565,6 +616,7 @@ UsgsAstroFrameSensorModel::computeAllSensorPartials(
csm::param::Set pset, double desiredPrecision, double *achievedPrecision,
csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing all sensor partials for ground point {}, {}, {}\
with point: {}, {}, pset: {}, and desiredPrecision: {}",
groundPt.x, groundPt.y, groundPt.z, imagePt.line, imagePt.samp, pset,
@@ -580,6 +632,7 @@ UsgsAstroFrameSensorModel::computeAllSensorPartials(
double desiredPrecision, double *achievedPrecision,
csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing all sensor partials image point from ground point {}, {}, {} \
and desiredPrecision: {}",
groundPt.x, groundPt.y, groundPt.z, desiredPrecision);
@@ -591,8 +644,10 @@ UsgsAstroFrameSensorModel::computeAllSensorPartials(
std::vector<double> UsgsAstroFrameSensorModel::computeGroundPartials(
const csm::EcefCoord &groundPt) const {
- MESSAGE_LOG("Computing ground partials for ground point {}, {}, {}",
- groundPt.x, groundPt.y, groundPt.z);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Computing ground partials for ground point {}, {}, {}",
+ groundPt.x, groundPt.y, groundPt.z);
// Partial of line, sample wrt X, Y, Z
double x = groundPt.x;
double y = groundPt.y;
@@ -631,6 +686,7 @@ std::vector<double> UsgsAstroFrameSensorModel::computeGroundPartials(
partials[5] = (ipZ.samp - ipB.samp) / pixelGroundSize;
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing ground partials results:\nLine: {}, {}, {}\nSample: {}, {}, "
"{}",
partials[0], partials[1], partials[2], partials[3], partials[4],
@@ -641,7 +697,7 @@ std::vector<double> UsgsAstroFrameSensorModel::computeGroundPartials(
const csm::CorrelationModel &UsgsAstroFrameSensorModel::getCorrelationModel()
const {
- MESSAGE_LOG("Accessing correlation model");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing correlation model");
return _no_corr_model;
}
@@ -649,6 +705,7 @@ std::vector<double> UsgsAstroFrameSensorModel::getUnmodeledCrossCovariance(
const csm::ImageCoord &pt1, const csm::ImageCoord &pt2) const {
// No unmodeled error
MESSAGE_LOG(
+ spdlog::level::debug,
"Accessing unmodeled cross covar with \
point1: {}, {} and point2: {}, {}",
pt1.line, pt1.samp, pt2.line, pt2.samp);
@@ -656,63 +713,63 @@ std::vector<double> UsgsAstroFrameSensorModel::getUnmodeledCrossCovariance(
}
csm::Version UsgsAstroFrameSensorModel::getVersion() const {
- MESSAGE_LOG("Accessing CSM version");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing CSM version");
return csm::Version(0, 1, 0);
}
std::string UsgsAstroFrameSensorModel::getModelName() const {
- MESSAGE_LOG("Accessing CSM name {}", _SENSOR_MODEL_NAME);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing CSM name {}", _SENSOR_MODEL_NAME);
return _SENSOR_MODEL_NAME;
}
std::string UsgsAstroFrameSensorModel::getPedigree() const {
- MESSAGE_LOG("Accessing CSM pedigree");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing CSM pedigree");
return "USGS_FRAMER";
}
std::string UsgsAstroFrameSensorModel::getImageIdentifier() const {
- MESSAGE_LOG("Accessing image ID {}", m_imageIdentifier);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing image ID {}", m_imageIdentifier);
return m_imageIdentifier;
}
void UsgsAstroFrameSensorModel::setImageIdentifier(const std::string &imageId,
csm::WarningList *warnings) {
- MESSAGE_LOG("Setting image ID to {}", imageId);
+ MESSAGE_LOG(spdlog::level::debug, "Setting image ID to {}", imageId);
m_imageIdentifier = imageId;
}
std::string UsgsAstroFrameSensorModel::getSensorIdentifier() const {
- MESSAGE_LOG("Accessing sensor ID: {}", m_sensorName);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing sensor ID: {}", m_sensorName);
return m_sensorName;
}
std::string UsgsAstroFrameSensorModel::getPlatformIdentifier() const {
- MESSAGE_LOG("Accessing platform ID: {}", m_platformName);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing platform ID: {}", m_platformName);
return m_platformName;
}
std::string UsgsAstroFrameSensorModel::getCollectionIdentifier() const {
- MESSAGE_LOG("Accessing collection ID: {}", m_collectionIdentifier);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing collection ID: {}", m_collectionIdentifier);
return m_collectionIdentifier;
}
std::string UsgsAstroFrameSensorModel::getTrajectoryIdentifier() const {
- MESSAGE_LOG("Accessing trajectory ID");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing trajectory ID");
return "";
}
std::string UsgsAstroFrameSensorModel::getSensorType() const {
- MESSAGE_LOG("Accessing sensor type");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing sensor type");
return CSM_SENSOR_TYPE_EO;
}
std::string UsgsAstroFrameSensorModel::getSensorMode() const {
- MESSAGE_LOG("Accessing sensor mode");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing sensor mode");
return CSM_SENSOR_MODE_FRAME;
}
std::string UsgsAstroFrameSensorModel::getReferenceDateAndTime() const {
- MESSAGE_LOG("Accessing reference data and time");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing reference data and time");
time_t ephemTime = m_ephemerisTime;
return ephemTimeToCalendarTime(ephemTime);
@@ -745,7 +802,7 @@ std::string UsgsAstroFrameSensorModel::getModelNameFromModelState(
}
std::string UsgsAstroFrameSensorModel::getModelState() const {
- MESSAGE_LOG("Dumping model state");
+ MESSAGE_LOG(spdlog::level::debug, "Dumping model state");
json state = {
{"m_modelName", _SENSOR_MODEL_NAME},
{"m_sensorName", m_sensorName},
@@ -851,7 +908,7 @@ void UsgsAstroFrameSensorModel::applyTransformToState(ale::Rotation const& r, al
bool UsgsAstroFrameSensorModel::isValidModelState(
const std::string &stringState, csm::WarningList *warnings) {
- MESSAGE_LOG("Checking if model has valid state");
+ MESSAGE_LOG(spdlog::level::debug, "Checking if model has valid state");
std::vector<std::string> requiredKeywords = {"m_modelName",
"m_majorAxis",
"m_minorAxis",
@@ -888,7 +945,7 @@ bool UsgsAstroFrameSensorModel::isValidModelState(
std::copy(missingKeywords.begin(), missingKeywords.end(),
std::ostream_iterator<std::string>(oss, " "));
- MESSAGE_LOG("State has missing keywords: {} ", oss.str());
+ MESSAGE_LOG(spdlog::level::warn, "State has missing keywords: {} ", oss.str());
warnings->push_back(
csm::Warning(csm::Warning::DATA_NOT_AVAILABLE,
@@ -899,7 +956,7 @@ bool UsgsAstroFrameSensorModel::isValidModelState(
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 {}",
+ MESSAGE_LOG(spdlog::level::warn, "Incorrect model name in state, expected {} but got {}",
_SENSOR_MODEL_NAME, modelName);
warnings->push_back(
@@ -918,7 +975,7 @@ bool UsgsAstroFrameSensorModel::isValidIsd(const std::string &Isd,
// or rather, it would be a pain to maintain, so just check if
// we can get a valid state from ISD. Once ISD schema is 100% clear
// we can change this.
- MESSAGE_LOG("Building isd to check model state");
+ MESSAGE_LOG(spdlog::level::debug, "Building isd to check model state");
try {
std::string state = constructStateFromIsd(Isd, warnings);
return isValidModelState(state, warnings);
@@ -932,7 +989,7 @@ void UsgsAstroFrameSensorModel::replaceModelState(
json state = stateAsJson(stringState);
- MESSAGE_LOG("Replacing model state");
+ MESSAGE_LOG(spdlog::level::debug, "Replacing model state");
// The json library's .at() will except if key is missing
try {
m_modelName = state.at("m_modelName").get<std::string>();
@@ -991,9 +1048,11 @@ void UsgsAstroFrameSensorModel::replaceModelState(
m_lineTimes = state.at("m_lineTimes").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");
+ MESSAGE_LOG(
+ spdlog::level::err,
+ "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: " +
@@ -1004,12 +1063,10 @@ void UsgsAstroFrameSensorModel::replaceModelState(
std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
const std::string &jsonIsd, csm::WarningList *warnings) {
- MESSAGE_LOG("Constructing state from isd");
+ MESSAGE_LOG(spdlog::level::debug, "Constructing state from isd");
json parsedIsd = json::parse(jsonIsd);
json state = {};
- MESSAGE_LOG("Constructing state from isd");
-
std::shared_ptr<csm::WarningList> parsingWarnings(new csm::WarningList);
state["m_modelName"] = ale::getSensorModelName(parsedIsd);
@@ -1053,6 +1110,7 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
if (!positions.empty() && positions.size() != 3) {
MESSAGE_LOG(
+ spdlog::level::warn,
"Sensor position does not have 3 values, "
"UsgsAstroFrameSensorModel::constructStateFromIsd()");
parsingWarnings->push_back(
@@ -1069,6 +1127,7 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
// get sensor_velocity
if (!velocities.empty() && velocities.size() != 3) {
MESSAGE_LOG(
+ spdlog::level::warn,
"Sensor velocity does not have 3 values, "
"UsgsAstroFrameSensorModel::constructStateFromIsd()");
parsingWarnings->push_back(
@@ -1142,6 +1201,7 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
if (quaternions.size() != 4) {
MESSAGE_LOG(
+ spdlog::level::warn,
"Sensor quaternion does not have 4 values, "
"UsgsAstroFrameSensorModel::constructStateFromIsd()");
parsingWarnings->push_back(
@@ -1210,6 +1270,7 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
state["m_iTransS"][0].get<double>());
} catch (...) {
MESSAGE_LOG(
+ spdlog::level::warn,
"Could not compute detector pixel to focal plane coordinate "
"transformation.");
parsingWarnings->push_back(
@@ -1233,7 +1294,7 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
warnings->insert(warnings->end(), parsingWarnings->begin(),
parsingWarnings->end());
}
- MESSAGE_LOG("ISD is invalid for creating the sensor model.");
+ MESSAGE_LOG(spdlog::level::err, "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.",
@@ -1244,31 +1305,35 @@ std::string UsgsAstroFrameSensorModel::constructStateFromIsd(
}
csm::EcefCoord UsgsAstroFrameSensorModel::getReferencePoint() const {
- MESSAGE_LOG("Accessing reference point x: {}, y: {}, z: {}",
- m_referencePointXyz.x, m_referencePointXyz.y,
- m_referencePointXyz.z);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing reference point x: {}, y: {}, z: {}",
+ m_referencePointXyz.x, m_referencePointXyz.y,
+ m_referencePointXyz.z);
return m_referencePointXyz;
}
void UsgsAstroFrameSensorModel::setReferencePoint(
const csm::EcefCoord &groundPt) {
- MESSAGE_LOG("Setting reference point to {}, {}, {}", groundPt.x, groundPt.y,
- groundPt.z);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Setting reference point to {}, {}, {}",
+ groundPt.x, groundPt.y, groundPt.z);
m_referencePointXyz = groundPt;
}
int UsgsAstroFrameSensorModel::getNumParameters() const {
- MESSAGE_LOG("Accessing num parameters: {}", NUM_PARAMETERS);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing num parameters: {}", NUM_PARAMETERS);
return NUM_PARAMETERS;
}
std::string UsgsAstroFrameSensorModel::getParameterName(int index) const {
- MESSAGE_LOG("Setting parameter name to {}", index);
+ MESSAGE_LOG(spdlog::level::debug, "Setting parameter name to {}", index);
return m_parameterName[index];
}
std::string UsgsAstroFrameSensorModel::getParameterUnits(int index) const {
- MESSAGE_LOG("Accessing parameter units for {}", index);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing parameter units for {}", index);
if (index < 3) {
return "m";
} else {
@@ -1277,18 +1342,19 @@ std::string UsgsAstroFrameSensorModel::getParameterUnits(int index) const {
}
bool UsgsAstroFrameSensorModel::hasShareableParameters() const {
- MESSAGE_LOG("Checking for shareable parameters");
+ MESSAGE_LOG(spdlog::level::debug, "Checking for shareable parameters");
return false;
}
bool UsgsAstroFrameSensorModel::isParameterShareable(int index) const {
- MESSAGE_LOG("Checking is parameter: {} is shareable", index);
+ MESSAGE_LOG(spdlog::level::debug, "Checking is parameter: {} is shareable", index);
return false;
}
csm::SharingCriteria UsgsAstroFrameSensorModel::getParameterSharingCriteria(
int index) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Checking sharing criteria for parameter {}. "
"Sharing is not supported.",
index);
@@ -1296,52 +1362,59 @@ csm::SharingCriteria UsgsAstroFrameSensorModel::getParameterSharingCriteria(
}
double UsgsAstroFrameSensorModel::getParameterValue(int index) const {
- MESSAGE_LOG("Accessing parameter value {} at index: {}",
- m_currentParameterValue[index], index);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing parameter value {} at index: {}",
+ m_currentParameterValue[index], index);
return m_currentParameterValue[index];
}
void UsgsAstroFrameSensorModel::setParameterValue(int index, double value) {
- MESSAGE_LOG("Setting parameter value: {} at index: {}", value, index);
+ MESSAGE_LOG(spdlog::level::debug, "Setting parameter value: {} at index: {}", value, index);
m_currentParameterValue[index] = value;
}
csm::param::Type UsgsAstroFrameSensorModel::getParameterType(int index) const {
- MESSAGE_LOG("Accessing parameter type: {} at index: {}",
+ MESSAGE_LOG(spdlog::level::debug, "Accessing parameter type: {} at index: {}",
m_parameterType[index], index);
return m_parameterType[index];
}
void UsgsAstroFrameSensorModel::setParameterType(int index,
csm::param::Type pType) {
- MESSAGE_LOG("Setting parameter type: {} at index: {}", pType, index);
+ MESSAGE_LOG(spdlog::level::debug, "Setting parameter type: {} at index: {}", pType, index);
m_parameterType[index] = pType;
}
double UsgsAstroFrameSensorModel::getParameterCovariance(int index1,
int index2) const {
int index = UsgsAstroFrameSensorModel::NUM_PARAMETERS * index1 + index2;
- MESSAGE_LOG("Accessing parameter covar: {} between index1: {} and index2: {}",
- m_currentParameterCovariance[index], index1, index2);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Accessing parameter covar: {} between index1: {} and index2: {}",
+ m_currentParameterCovariance[index], index1, index2);
return m_currentParameterCovariance[index];
}
void UsgsAstroFrameSensorModel::setParameterCovariance(int index1, int index2,
double covariance) {
- MESSAGE_LOG("Setting parameter covar: {} between index1: {} and index2: {}",
- covariance, index1, index2);
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Setting parameter covar: {} between index1: {} and index2: {}",
+ covariance, index1, index2);
int index = UsgsAstroFrameSensorModel::NUM_PARAMETERS * index1 + index2;
m_currentParameterCovariance[index] = covariance;
}
int UsgsAstroFrameSensorModel::getNumGeometricCorrectionSwitches() const {
- MESSAGE_LOG("Accessing num geom correction switches");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing num geom correction switches");
return 0;
}
std::string UsgsAstroFrameSensorModel::getGeometricCorrectionName(
int index) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Accessing name of geometric correction switch {}. "
"Geometric correction switches are not supported, throwing exception",
index);
@@ -1353,6 +1426,7 @@ std::string UsgsAstroFrameSensorModel::getGeometricCorrectionName(
void UsgsAstroFrameSensorModel::setGeometricCorrectionSwitch(
int index, bool value, csm::param::Type pType) {
MESSAGE_LOG(
+ spdlog::level::debug,
"Setting geometric correction switch {} to {} "
"with parameter type {}. "
"Geometric correction switches are not supported, throwing exception",
@@ -1364,6 +1438,7 @@ void UsgsAstroFrameSensorModel::setGeometricCorrectionSwitch(
bool UsgsAstroFrameSensorModel::getGeometricCorrectionSwitch(int index) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Accessing value of geometric correction switch {}. "
"Geometric correction switches are not supported, throwing exception",
index);
@@ -1375,7 +1450,7 @@ bool UsgsAstroFrameSensorModel::getGeometricCorrectionSwitch(int index) const {
std::vector<double> UsgsAstroFrameSensorModel::getCrossCovarianceMatrix(
const GeometricModel &comparisonModel, csm::param::Set pSet,
const GeometricModelList &otherModels) const {
- MESSAGE_LOG("Accessing cross covariance matrix");
+ MESSAGE_LOG(spdlog::level::debug, "Accessing cross covariance matrix");
// No correlation between models.
const std::vector<int> &indices = getParameterSetIndices(pSet);
@@ -1388,19 +1463,19 @@ std::vector<double> UsgsAstroFrameSensorModel::getCrossCovarianceMatrix(
}
csm::Ellipsoid UsgsAstroFrameSensorModel::getEllipsoid() const {
- MESSAGE_LOG("Accessing ellipsoid radii {} {}", m_majorAxis, m_minorAxis);
+ MESSAGE_LOG(spdlog::level::debug, "Accessing ellipsoid radii {} {}", m_majorAxis, m_minorAxis);
return csm::Ellipsoid(m_majorAxis, m_minorAxis);
}
void UsgsAstroFrameSensorModel::setEllipsoid(const csm::Ellipsoid &ellipsoid) {
- MESSAGE_LOG("Setting ellipsoid radii {} {}", ellipsoid.getSemiMajorRadius(),
+ MESSAGE_LOG(spdlog::level::debug, "Setting ellipsoid radii {} {}", ellipsoid.getSemiMajorRadius(),
ellipsoid.getSemiMinorRadius());
m_majorAxis = ellipsoid.getSemiMajorRadius();
m_minorAxis = ellipsoid.getSemiMinorRadius();
}
void UsgsAstroFrameSensorModel::calcRotationMatrix(double m[3][3]) const {
- MESSAGE_LOG("Calculating rotation matrix");
+ MESSAGE_LOG(spdlog::level::trace, "Calculating rotation matrix");
// Trigonometric functions for rotation matrix
double x = m_currentParameterValue[3];
double y = m_currentParameterValue[4];
@@ -1426,7 +1501,7 @@ void UsgsAstroFrameSensorModel::calcRotationMatrix(double m[3][3]) const {
void UsgsAstroFrameSensorModel::calcRotationMatrix(
double m[3][3], const std::vector<double> &adjustments) const {
- MESSAGE_LOG("Calculating rotation matrix with adjustments");
+ MESSAGE_LOG(spdlog::level::trace, "Calculating rotation matrix with adjustments");
// Trigonometric functions for rotation matrix
double x = getValue(3, adjustments);
double y = getValue(4, adjustments);
@@ -1449,6 +1524,7 @@ void UsgsAstroFrameSensorModel::losEllipsoidIntersect(
const double xl, const double yl, const double zl, double &x, double &y,
double &z, csm::WarningList *warnings) const {
MESSAGE_LOG(
+ spdlog::level::trace,
"Calculating losEllipsoidIntersect with height: {},\n\
xc: {}, yc: {}, zc: {}\n\
xl: {}, yl: {}, zl: {}",
@@ -1484,7 +1560,7 @@ void UsgsAstroFrameSensorModel::losEllipsoidIntersect(
csm::Warning(csm::Warning::NO_INTERSECTION, message,
"UsgsAstroFrameSensorModel::losEllipsoidIntersect"));
}
- MESSAGE_LOG(message);
+ MESSAGE_LOG(spdlog::level::warn, message);
}
double scale;
@@ -1495,15 +1571,17 @@ void UsgsAstroFrameSensorModel::losEllipsoidIntersect(
y = yc + scale * yl;
z = zc + scale * zl;
- MESSAGE_LOG("Calculated losEllipsoidIntersect at: {}, {}, {}", x, y, z);
+ MESSAGE_LOG(spdlog::level::trace, "Calculated losEllipsoidIntersect at: {}, {}, {}", x, y, z);
}
/***** Helper Functions *****/
double UsgsAstroFrameSensorModel::getValue(
int index, const std::vector<double> &adjustments) const {
- MESSAGE_LOG("Accessing value: {} at index: {}, with adjustments",
- m_currentParameterValue[index] + adjustments[index], index);
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "Accessing value: {} at index: {}, with adjustments",
+ m_currentParameterValue[index] + adjustments[index], index);
return m_currentParameterValue[index] + adjustments[index];
}
diff --git a/src/UsgsAstroLsSensorModel.cpp b/src/UsgsAstroLsSensorModel.cpp
index 0d0a756..48dd7dd 100644
--- a/src/UsgsAstroLsSensorModel.cpp
+++ b/src/UsgsAstroLsSensorModel.cpp
@@ -40,7 +40,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define MESSAGE_LOG(...) \
if (m_logger) { \
- m_logger->info(__VA_ARGS__); \
+ m_logger->log(__VA_ARGS__); \
}
using json = nlohmann::json;
@@ -130,7 +130,7 @@ const csm::param::Type UsgsAstroLsSensorModel::PARAM_CHAR_ALL[] = {
// UsgsAstroLineScannerSensorModel::replaceModelState
//***************************************************************************
void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
- MESSAGE_LOG("Replacing model state")
+ MESSAGE_LOG(spdlog::level::info, "Replacing model state")
reset();
auto j = stateAsJson(stateString);
@@ -142,6 +142,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_nSamples = j["m_nSamples"];
m_platformFlag = j["m_platformFlag"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_imageIdentifier: {} "
"m_sensorName: {} "
"m_nLines: {} "
@@ -162,6 +163,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_startingDetectorLine = j["m_startingDetectorLine"];
m_ikCode = j["m_ikCode"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_startingEphemerisTime: {} "
"m_centerEphemerisTime: {} "
"m_detectorSampleSumming: {} "
@@ -177,6 +179,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_distortionType = (DistortionType)j["m_distortionType"].get<int>();
m_opticalDistCoeffs = j["m_opticalDistCoeffs"].get<std::vector<double>>();
MESSAGE_LOG(
+ spdlog::level::trace,
"m_focalLength: {} "
"m_zDirection: {} "
"m_distortionType: {} ",
@@ -193,6 +196,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_majorAxis = j["m_majorAxis"];
m_minorAxis = j["m_minorAxis"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_detectorSampleOrigin: {} "
"m_detectorLineOrigin: {} "
"m_majorAxis: {} "
@@ -203,6 +207,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_platformIdentifier = j["m_platformIdentifier"];
m_sensorIdentifier = j["m_sensorIdentifier"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_platformIdentifier: {} "
"m_sensorIdentifier: {} ",
j["m_platformIdentifier"].dump(), j["m_sensorIdentifier"].dump())
@@ -210,6 +215,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_minElevation = j["m_minElevation"];
m_maxElevation = j["m_maxElevation"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_minElevation: {} "
"m_maxElevation: {} ",
j["m_minElevation"].dump(), j["m_maxElevation"].dump())
@@ -220,6 +226,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_t0Quat = j["m_t0Quat"];
m_numPositions = j["m_numPositions"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_dtEphem: {} "
"m_t0Ephem: {} "
"m_dtQuat: {} "
@@ -232,6 +239,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_referencePointXyz.y = j["m_referencePointXyz"][1];
m_referencePointXyz.z = j["m_referencePointXyz"][2];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_numQuaternions: {} "
"m_referencePointX: {} "
"m_referencePointY: {} "
@@ -244,6 +252,7 @@ void UsgsAstroLsSensorModel::replaceModelState(const std::string& stateString) {
m_halfSwath = j["m_halfSwath"];
m_halfTime = j["m_halfTime"];
MESSAGE_LOG(
+ spdlog::level::trace,
"m_gsd: {} "
"m_flyingHeight: {} "
"m_halfSwath: {} "
@@ -316,7 +325,7 @@ std::string UsgsAstroLsSensorModel::getModelNameFromModelState(
// UsgsAstroLineScannerSensorModel::getModelState
//***************************************************************************
std::string UsgsAstroLsSensorModel::getModelState() const {
- MESSAGE_LOG("Running getModelState")
+ MESSAGE_LOG(spdlog::level::info, "Running getModelState")
json state;
state["m_modelName"] = _SENSOR_MODEL_NAME;
@@ -328,6 +337,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_nSamples"] = m_nSamples;
state["m_platformFlag"] = m_platformFlag;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_imageIdentifier: {} "
"m_sensorName: {} "
"m_nLines: {} "
@@ -341,6 +351,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_startingEphemerisTime"] = m_startingEphemerisTime;
state["m_centerEphemerisTime"] = m_centerEphemerisTime;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_startingEphemerisTime: {} "
"m_centerEphemerisTime: {} ",
m_startingEphemerisTime, m_centerEphemerisTime)
@@ -350,6 +361,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_startingDetectorSample"] = m_startingDetectorSample;
state["m_ikCode"] = m_ikCode;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_detectorSampleSumming: {} "
"m_detectorLineSumming: {} "
"m_startingDetectorSample: {} "
@@ -362,6 +374,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_distortionType"] = m_distortionType;
state["m_opticalDistCoeffs"] = m_opticalDistCoeffs;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_focalLength: {} "
"m_zDirection: {} "
"m_distortionType (0-Radial, 1-Transverse): {} ",
@@ -375,6 +388,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_majorAxis"] = m_majorAxis;
state["m_minorAxis"] = m_minorAxis;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_detectorSampleOrigin: {} "
"m_detectorLineOrigin: {} "
"m_majorAxis: {} "
@@ -386,6 +400,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_minElevation"] = m_minElevation;
state["m_maxElevation"] = m_maxElevation;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_platformIdentifier: {} "
"m_sensorIdentifier: {} "
"m_minElevation: {} "
@@ -397,6 +412,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_dtQuat"] = m_dtQuat;
state["m_t0Quat"] = m_t0Quat;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_dtEphem: {} "
"m_t0Ephem: {} "
"m_dtQuat: {} "
@@ -409,6 +425,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_velocities"] = m_velocities;
state["m_quaternions"] = m_quaternions;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_numPositions: {} "
"m_numQuaternions: {} ",
m_numPositions, m_numQuaternions)
@@ -422,6 +439,7 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_halfTime"] = m_halfTime;
state["m_covariance"] = m_covariance;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_gsd: {} "
"m_flyingHeight: {} "
"m_halfSwath: {} "
@@ -433,16 +451,17 @@ std::string UsgsAstroLsSensorModel::getModelState() const {
state["m_referencePointXyz"][1] = m_referencePointXyz.y;
state["m_referencePointXyz"][2] = m_referencePointXyz.z;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_referencePointXyz: {} "
"m_referencePointXyz: {} "
"m_referencePointXyz: {} ",
m_referencePointXyz.x, m_referencePointXyz.y, m_referencePointXyz.z)
state["m_sunPosition"] = m_sunPosition;
- MESSAGE_LOG("num sun positions: {} ", m_sunPosition.size())
+ MESSAGE_LOG(spdlog::level::trace, "num sun positions: {} ", m_sunPosition.size())
state["m_sunVelocity"] = m_sunVelocity;
- MESSAGE_LOG("num sun velocities: {} ", m_sunVelocity.size());
+ MESSAGE_LOG(spdlog::level::trace, "num sun velocities: {} ", m_sunVelocity.size());
// Use dump(2) to avoid creating the model string as a single long line
std::string stateString = getModelName() + "\n" + state.dump(2);
@@ -490,7 +509,7 @@ void UsgsAstroLsSensorModel::applyTransformToState(ale::Rotation const& r, ale::
// UsgsAstroLineScannerSensorModel::reset
//***************************************************************************
void UsgsAstroLsSensorModel::reset() {
- MESSAGE_LOG("Running reset()")
+ MESSAGE_LOG(spdlog::level::debug, "Running reset()")
m_useApproxInitTrans = false; // default until an initial approximation is found
_no_adjustment.assign(UsgsAstroLsSensorModel::NUM_PARAMETERS, 0.0);
@@ -566,7 +585,11 @@ UsgsAstroLsSensorModel::UsgsAstroLsSensorModel() {
//*****************************************************************************
// UsgsAstroLsSensorModel Destructor
//*****************************************************************************
-UsgsAstroLsSensorModel::~UsgsAstroLsSensorModel() {}
+UsgsAstroLsSensorModel::~UsgsAstroLsSensorModel() {
+ if (m_logger) {
+ m_logger->flush();
+ }
+}
//*****************************************************************************
// UsgsAstroLsSensorModel updateState
@@ -574,19 +597,22 @@ UsgsAstroLsSensorModel::~UsgsAstroLsSensorModel() {}
void UsgsAstroLsSensorModel::updateState() {
// If sensor model is being created for the first time
// This routine will set some parameters not found in the ISD.
- MESSAGE_LOG("Updating State")
+ MESSAGE_LOG(spdlog::level::debug, "Updating State")
// Reference point (image center)
double lineCtr = m_nLines / 2.0;
double sampCtr = m_nSamples / 2.0;
csm::ImageCoord ip(lineCtr, sampCtr);
- MESSAGE_LOG("updateState: center image coordinate set to {} {}", lineCtr,
- sampCtr)
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "updateState: center image coordinate set to {} {}",
+ lineCtr, sampCtr)
double refHeight = 0;
m_referencePointXyz = imageToGround(ip, refHeight);
- MESSAGE_LOG("updateState: reference point (x, y, z) {} {} {}",
- m_referencePointXyz.x, m_referencePointXyz.y,
- m_referencePointXyz.z)
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "updateState: reference point (x, y, z) {} {} {}",
+ m_referencePointXyz.x, m_referencePointXyz.y, m_referencePointXyz.z)
// Compute ground sample distance
ip.line += 1;
@@ -597,6 +623,7 @@ void UsgsAstroLsSensorModel::updateState() {
double dz = delta.z - m_referencePointXyz.z;
m_gsd = sqrt((dx * dx + dy * dy + dz * dz) / 2.0);
MESSAGE_LOG(
+ spdlog::level::trace,
"updateState: ground sample distance set to {} "
"based on dx {} dy {} dz {}",
m_gsd, dx, dy, dz)
@@ -608,20 +635,21 @@ void UsgsAstroLsSensorModel::updateState() {
dz = sensorPos.z - m_referencePointXyz.z;
m_flyingHeight = sqrt(dx * dx + dy * dy + dz * dz);
MESSAGE_LOG(
+ spdlog::level::trace,
"updateState: flight height set to {}"
"based on dx {} dy {} dz {}",
m_flyingHeight, dx, dy, dz)
// Compute half swath
m_halfSwath = m_gsd * m_nSamples / 2.0;
- MESSAGE_LOG("updateState: half swath set to {}", m_halfSwath)
+ MESSAGE_LOG(spdlog::level::trace, "updateState: half swath set to {}", m_halfSwath)
// Compute half time duration
double fullImageTime = m_intTimeStartTimes.back() -
m_intTimeStartTimes.front() +
m_intTimes.back() * (m_nLines - m_intTimeLines.back());
m_halfTime = fullImageTime / 2.0;
- MESSAGE_LOG("updateState: half time duration set to {}", m_halfTime)
+ MESSAGE_LOG(spdlog::level::trace, "updateState: half time duration set to {}", m_halfTime)
// Parameter covariance, hardcoded accuracy values
// hardcoded ~1 pixel accuracy values
@@ -667,13 +695,19 @@ csm::ImageCoord UsgsAstroLsSensorModel::groundToImage(
const csm::EcefCoord& ground_pt, double desired_precision,
double* achieved_precision, csm::WarningList* warnings) const {
MESSAGE_LOG(
- "Computing groundToImage(No adjustments) for {}, {}, {}, with desired "
+ spdlog::level::info,
+ "Computing groundToImage(No adjustments) for ({}, {}, {}), with desired "
"precision {}",
ground_pt.x, ground_pt.y, ground_pt.z, desired_precision);
// The public interface invokes the private interface with no adjustments.
- return groundToImage(ground_pt, _no_adjustment, desired_precision,
- achieved_precision, warnings);
+ csm::ImageCoord imagePt = groundToImage(
+ ground_pt, _no_adjustment, desired_precision, achieved_precision, warnings);
+ MESSAGE_LOG(
+ spdlog::level::info,
+ "groundToImage result of ({}, {})",
+ imagePt.line, imagePt.samp);
+ return imagePt;
}
//***************************************************************************
@@ -740,8 +774,10 @@ csm::ImageCoord UsgsAstroLsSensorModel::groundToImage(
*achievedPrecision = finalUpdate;
}
- MESSAGE_LOG("groundToImage: image line sample {} {}", approxPt.line,
- approxPt.samp)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "groundToImage result image line sample {} {}",
+ approxPt.line, approxPt.samp)
if (warnings && (desiredPrecision > 0.0) &&
(std::abs(finalUpdate) > desiredPrecision)) {
@@ -760,6 +796,7 @@ csm::ImageCoordCovar UsgsAstroLsSensorModel::groundToImage(
const csm::EcefCoordCovar& groundPt, double desired_precision,
double* achieved_precision, csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing groundToImage(Covar) for {}, {}, {}, with desired precision "
"{}",
groundPt.x, groundPt.y, groundPt.z, desired_precision);
@@ -819,6 +856,7 @@ csm::EcefCoord UsgsAstroLsSensorModel::imageToGround(
const csm::ImageCoord& image_pt, double height, double desired_precision,
double* achieved_precision, csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing imageToGround for {}, {}, {}, with desired precision {}",
image_pt.line, image_pt.samp, height, desired_precision);
double xc, yc, zc;
@@ -840,7 +878,10 @@ csm::EcefCoord UsgsAstroLsSensorModel::imageToGround(
csm::Warning::PRECISION_NOT_MET, "Desired precision not achieved.",
"UsgsAstroLsSensorModel::imageToGround()"));
}
- MESSAGE_LOG("imageToGround for {} {} {}", image_pt.line, image_pt.samp, height);
+ MESSAGE_LOG(
+ spdlog::level::info,
+ "imageToGround result {} {} {}",
+ x, y, z);
return csm::EcefCoord(x, y, z);
}
@@ -849,8 +890,10 @@ csm::EcefCoord UsgsAstroLsSensorModel::imageToGround(
//***************************************************************************
void UsgsAstroLsSensorModel::determineSensorCovarianceInImageSpace(
csm::EcefCoord& gp, double sensor_cov[4]) const {
- MESSAGE_LOG("Calculating determineSensorCovarianceInImageSpace for {} {} {}",
- gp.x, gp.y, gp.z)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Calculating determineSensorCovarianceInImageSpace for {} {} {}",
+ gp.x, gp.y, gp.z)
int i, j, totalAdjParams;
totalAdjParams = getNumParameters();
@@ -885,7 +928,8 @@ csm::EcefCoordCovar UsgsAstroLsSensorModel::imageToGround(
double desired_precision, double* achieved_precision,
csm::WarningList* warnings) const {
MESSAGE_LOG(
- "Calculating imageToGround (with error propagation) for {}, {}, {} with "
+ spdlog::level::debug,
+ "Calculating imageToGround (covar) for {}, {}, {} with "
"height varinace {} and desired precision {}",
image_pt.line, image_pt.samp, height, heightVariance, desired_precision)
// Image to ground with error propagation
@@ -914,7 +958,7 @@ csm::EcefCoordCovar UsgsAstroLsSensorModel::imageToGround(
double zps = (gps.z - gp.z) / DELTA_IMAGE;
ip.line = image_pt.line;
- ip.samp = image_pt.samp; // +DELTA_IMAGE;
+ ip.samp = image_pt.samp;
csm::EcefCoord gph =
imageToGround(ip, height + DELTA_GROUND, desired_precision);
double xph = (gph.x - gp.x) / DELTA_GROUND;
@@ -972,8 +1016,9 @@ csm::EcefLocus UsgsAstroLsSensorModel::imageToProximateImagingLocus(
double desired_precision, double* achieved_precision,
csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing imageToProximateImagingLocus (ground {}, {}, {}) for image "
- "point {}, {} with desired precision {}",
+ "point ({}, {}) with desired precision {}",
ground_pt.x, ground_pt.y, ground_pt.z, image_pt.line, image_pt.samp,
desired_precision);
@@ -1036,6 +1081,7 @@ csm::EcefLocus UsgsAstroLsSensorModel::imageToRemoteImagingLocus(
const csm::ImageCoord& image_pt, double desired_precision,
double* achieved_precision, csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Calculating imageToRemoteImagingLocus for point {}, {} with desired "
"precision {}",
image_pt.line, image_pt.samp, desired_precision)
@@ -1053,6 +1099,13 @@ csm::EcefLocus UsgsAstroLsSensorModel::imageToRemoteImagingLocus(
if (achieved_precision) {
*achieved_precision = 0.0;
}
+
+ MESSAGE_LOG(
+ spdlog::level::info,
+ "imageToProximateImagingLocus result of point ({}, {}, {}) "
+ "direction ({}, {}, {}).",
+ locus.point.x, locus.point.y, locus.point.z,
+ locus.direction.x, locus.direction.y, locus.direction.z);
return locus;
}
@@ -1065,8 +1118,10 @@ csm::EcefLocus UsgsAstroLsSensorModel::imageToRemoteImagingLocus(
//***************************************************************************
std::vector<double> UsgsAstroLsSensorModel::computeGroundPartials(
const csm::EcefCoord& ground_pt) const {
- MESSAGE_LOG("Computing computeGroundPartials for point {}, {}, {}",
- ground_pt.x, ground_pt.y, ground_pt.z)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Computing computeGroundPartials for point {}, {}, {}",
+ ground_pt.x, ground_pt.y, ground_pt.z)
double GND_DELTA = m_gsd;
// Partial of line, sample wrt X, Y, Z
@@ -1097,6 +1152,7 @@ csm::RasterGM::SensorPartials UsgsAstroLsSensorModel::computeSensorPartials(
int index, const csm::EcefCoord& ground_pt, double desired_precision,
double* achieved_precision, csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Calculating computeSensorPartials for ground point {}, {}, {} with "
"desired precision {}",
ground_pt.x, ground_pt.y, ground_pt.z, desired_precision)
@@ -1118,6 +1174,7 @@ csm::RasterGM::SensorPartials UsgsAstroLsSensorModel::computeSensorPartials(
double desired_precision, double* achieved_precision,
csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Calculating computeSensorPartials (with image points {}, {}) for ground "
"point {}, {}, {} with desired precision {}",
image_pt.line, image_pt.samp, ground_pt.x, ground_pt.y, ground_pt.z,
@@ -1147,6 +1204,7 @@ UsgsAstroLsSensorModel::computeAllSensorPartials(
double desired_precision, double* achieved_precision,
csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::info,
"Computing computeAllSensorPartials for ground point {}, {}, {} with "
"desired precision {}",
ground_pt.x, ground_pt.y, ground_pt.z, desired_precision)
@@ -1166,6 +1224,7 @@ UsgsAstroLsSensorModel::computeAllSensorPartials(
csm::param::Set pSet, double desired_precision, double* achieved_precision,
csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing computeAllSensorPartials for image {} {} and ground {}, {}, "
"{} with desired precision {}",
image_pt.line, image_pt.samp, ground_pt.x, ground_pt.y, ground_pt.z,
@@ -1182,8 +1241,10 @@ double UsgsAstroLsSensorModel::getParameterCovariance(int index1,
int index2) const {
int index = UsgsAstroLsSensorModel::NUM_PARAMETERS * index1 + index2;
- MESSAGE_LOG("getParameterCovariance for {} {} is {}", index1, index2,
- m_covariance[index])
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getParameterCovariance for {} {} is {}",
+ index1, index2, m_covariance[index])
return m_covariance[index];
}
@@ -1195,8 +1256,10 @@ void UsgsAstroLsSensorModel::setParameterCovariance(int index1, int index2,
double covariance) {
int index = UsgsAstroLsSensorModel::NUM_PARAMETERS * index1 + index2;
- MESSAGE_LOG("setParameterCovariance for {} {} is {}", index1, index2,
- m_covariance[index])
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "setParameterCovariance for {} {} is {}",
+ index1, index2, m_covariance[index])
m_covariance[index] = covariance;
}
@@ -1232,6 +1295,10 @@ std::string UsgsAstroLsSensorModel::getReferenceDateAndTime() const {
//***************************************************************************
double UsgsAstroLsSensorModel::getImageTime(
const csm::ImageCoord& image_pt) const {
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getImageTime for image line {}",
+ image_pt.line)
double lineFull = image_pt.line;
auto referenceLineIt =
@@ -1247,7 +1314,10 @@ double UsgsAstroLsSensorModel::getImageTime(
m_intTimes[referenceIndex] *
(lineFull - m_intTimeLines[referenceIndex] + 0.5);
- MESSAGE_LOG("getImageTime for image line {} is {}", image_pt.line, time)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getImageTime is {}",
+ time)
return time;
}
@@ -1257,7 +1327,10 @@ double UsgsAstroLsSensorModel::getImageTime(
//***************************************************************************
csm::EcefCoord UsgsAstroLsSensorModel::getSensorPosition(
const csm::ImageCoord& imagePt) const {
- MESSAGE_LOG("getSensorPosition at line {}", imagePt.line)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getSensorPosition at image coord ({}, {})",
+ imagePt.line, imagePt.samp)
return getSensorPosition(getImageTime(imagePt));
}
@@ -1266,12 +1339,18 @@ csm::EcefCoord UsgsAstroLsSensorModel::getSensorPosition(
// UsgsAstroLsSensorModel::getSensorPosition
//***************************************************************************
csm::EcefCoord UsgsAstroLsSensorModel::getSensorPosition(double time) const {
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getSensorPosition at {}",
+ time)
double x, y, z, vx, vy, vz;
bool calc_vel = false;
getAdjSensorPosVel(time, _no_adjustment, x, y, z, vx, vy, vz, calc_vel);
- MESSAGE_LOG("getSensorPosition at {}", time)
-
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getSensorPosition is ({}, {}, {})",
+ x, y, z);
return csm::EcefCoord(x, y, z);
}
@@ -1280,7 +1359,10 @@ csm::EcefCoord UsgsAstroLsSensorModel::getSensorPosition(double time) const {
//***************************************************************************
csm::EcefVector UsgsAstroLsSensorModel::getSensorVelocity(
const csm::ImageCoord& imagePt) const {
- MESSAGE_LOG("getSensorVelocity at {}", imagePt.line)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getSensorVelocity at image coord ({}, {})",
+ imagePt.line, imagePt.samp);
return getSensorVelocity(getImageTime(imagePt));
}
@@ -1288,11 +1370,18 @@ csm::EcefVector UsgsAstroLsSensorModel::getSensorVelocity(
// UsgsAstroLsSensorModel::getSensorVelocity
//***************************************************************************
csm::EcefVector UsgsAstroLsSensorModel::getSensorVelocity(double time) const {
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getSensorVelocity at {}",
+ time);
double x, y, z, vx, vy, vz;
getAdjSensorPosVel(time, _no_adjustment, x, y, z, vx, vy, vz);
- MESSAGE_LOG("getSensorVelocity at {}", time)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getSensorVelocity is ({}, {}, {})",
+ vx, vy, vz)
return csm::EcefVector(vx, vy, vz);
}
@@ -1455,6 +1544,7 @@ UsgsAstroLsSensorModel::getValidImageRange() const {
csm::EcefVector UsgsAstroLsSensorModel::getIlluminationDirection(
const csm::EcefCoord& groundPt) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Accessing illumination direction of ground point"
"{} {} {}.",
groundPt.x, groundPt.y, groundPt.z);
@@ -1492,6 +1582,7 @@ int UsgsAstroLsSensorModel::getNumGeometricCorrectionSwitches() const {
std::string UsgsAstroLsSensorModel::getGeometricCorrectionName(
int index) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Accessing name of geometric correction switch {}. "
"Geometric correction switches are not supported, throwing exception",
index);
@@ -1506,6 +1597,7 @@ std::string UsgsAstroLsSensorModel::getGeometricCorrectionName(
void UsgsAstroLsSensorModel::setGeometricCorrectionSwitch(
int index, bool value, csm::param::Type pType) {
MESSAGE_LOG(
+ spdlog::level::debug,
"Setting geometric correction switch {} to {} "
"with parameter type {}. "
"Geometric correction switches are not supported, throwing exception",
@@ -1520,6 +1612,7 @@ void UsgsAstroLsSensorModel::setGeometricCorrectionSwitch(
//***************************************************************************
bool UsgsAstroLsSensorModel::getGeometricCorrectionSwitch(int index) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Accessing value of geometric correction switch {}. "
"Geometric correction switches are not supported, throwing exception",
index);
@@ -1604,6 +1697,7 @@ bool UsgsAstroLsSensorModel::isParameterShareable(int index) const {
csm::SharingCriteria UsgsAstroLsSensorModel::getParameterSharingCriteria(
int index) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Checking sharing criteria for parameter {}. "
"Sharing is not supported.",
index);
@@ -1662,6 +1756,7 @@ void UsgsAstroLsSensorModel::getQuaternions(const double& time,
if (m_numQuaternions < 6 && nOrder == 8) nOrderQuat = 4;
MESSAGE_LOG(
+ spdlog::level::debug,
"Calculating getQuaternions for time {} with {}"
"order lagrange",
time, nOrder)
@@ -1676,6 +1771,7 @@ void UsgsAstroLsSensorModel::calculateAttitudeCorrection(
const double& time, const std::vector<double>& adj,
double attCorr[9]) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing calculateAttitudeCorrection (with adjustment)"
"for time {}",
time)
@@ -1692,8 +1788,10 @@ void UsgsAstroLsSensorModel::calculateAttitudeCorrection(
euler[2] = (getValue(8, adj) + getValue(11, adj) * nTime +
getValue(14, adj) * nTime2) /
m_halfSwath;
- MESSAGE_LOG("calculateAttitudeCorrection: euler {} {} {}", euler[0], euler[1],
- euler[2])
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "calculateAttitudeCorrection: euler {} {} {}",
+ euler[0], euler[1], euler[2])
calculateRotationMatrixFromEuler(euler, attCorr);
}
@@ -1719,6 +1817,7 @@ void UsgsAstroLsSensorModel::losToEcf(
// Computes image ray (look vector) in ecf coordinate system.
// Compute adjusted sensor position and velocity
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing losToEcf (with adjustments) for"
"line {} sample {}",
line, sample);
@@ -1739,24 +1838,30 @@ void UsgsAstroLsSensorModel::losToEcf(
m_detectorSampleSumming, m_detectorLineSumming, m_startingDetectorSample,
m_startingDetectorLine, m_iTransS, m_iTransL, distortedFocalPlaneX,
distortedFocalPlaneY);
- MESSAGE_LOG("losToEcf: distorted focal plane coordinate {} {}",
- distortedFocalPlaneX, distortedFocalPlaneY)
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "losToEcf: distorted focal plane coordinate {} {}",
+ distortedFocalPlaneX, distortedFocalPlaneY)
// Remove lens
double undistortedFocalPlaneX, undistortedFocalPlaneY;
removeDistortion(distortedFocalPlaneX, distortedFocalPlaneY,
undistortedFocalPlaneX, undistortedFocalPlaneY,
m_opticalDistCoeffs, m_distortionType);
- MESSAGE_LOG("losToEcf: undistorted focal plane coordinate {} {}",
- undistortedFocalPlaneX, undistortedFocalPlaneY)
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "losToEcf: undistorted focal plane coordinate {} {}",
+ undistortedFocalPlaneX, undistortedFocalPlaneY)
// Define imaging ray (look vector) in camera space
double cameraLook[3];
createCameraLookVector(
undistortedFocalPlaneX, undistortedFocalPlaneY, m_zDirection,
m_focalLength * (1 - getValue(15, adj) / m_halfSwath), cameraLook);
- MESSAGE_LOG("losToEcf: uncorrected camera look vector {} {} {}",
- cameraLook[0], cameraLook[1], cameraLook[2])
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "losToEcf: uncorrected camera look vector {} {} {}",
+ cameraLook[0], cameraLook[1], cameraLook[2])
// Apply attitude correction
double attCorr[9];
@@ -1772,9 +1877,10 @@ void UsgsAstroLsSensorModel::losToEcf(
correctedCameraLook[2] = attCorr[6] * cameraLook[0] +
attCorr[7] * cameraLook[1] +
attCorr[8] * cameraLook[2];
- MESSAGE_LOG("losToEcf: corrected camera look vector {} {} {}",
- correctedCameraLook[0], correctedCameraLook[1],
- correctedCameraLook[2])
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "losToEcf: corrected camera look vector {} {} {}",
+ correctedCameraLook[0], correctedCameraLook[1], correctedCameraLook[2])
// Rotate the look vector into the body fixed frame from the camera reference
// frame by applying the rotation matrix from the sensor quaternions
double quaternions[4];
@@ -1791,8 +1897,10 @@ void UsgsAstroLsSensorModel::losToEcf(
bodyLookZ = cameraToBody[6] * correctedCameraLook[0] +
cameraToBody[7] * correctedCameraLook[1] +
cameraToBody[8] * correctedCameraLook[2];
- MESSAGE_LOG("losToEcf: body look vector {} {} {}", bodyLookX, bodyLookY,
- bodyLookZ)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "losToEcf: body look vector {} {} {}",
+ bodyLookX, bodyLookY, bodyLookZ)
}
//***************************************************************************
@@ -1803,6 +1911,7 @@ void UsgsAstroLsSensorModel::lightAberrationCorr(
const double& yl, const double& zl, double& dxl, double& dyl,
double& dzl) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing lightAberrationCorr for camera velocity"
"{} {} {} and image ray {} {} {}",
vx, vy, vz, xl, yl, zl)
@@ -1824,6 +1933,7 @@ void UsgsAstroLsSensorModel::lightAberrationCorr(
dyl = 0.0;
dzl = 0.0;
MESSAGE_LOG(
+ spdlog::level::warn,
"lightAberrationCorr: image ray is parallel"
"to velocity vector")
}
@@ -1844,6 +1954,7 @@ void UsgsAstroLsSensorModel::lightAberrationCorr(
dyl = cfac * vy;
dzl = cfac * vz;
MESSAGE_LOG(
+ spdlog::level::debug,
"lightAberrationCorr: light of sight correction"
"{} {} {}",
dxl, dyl, dzl)
@@ -1858,6 +1969,7 @@ void UsgsAstroLsSensorModel::losEllipsoidIntersect(
double& z, double& achieved_precision,
const double& desired_precision, csm::WarningList* warnings) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing losEllipsoidIntersect for camera position "
"{} {} {} looking {} {} {} with desired precision {}",
xc, yc, zc, xl, yl, zl, desired_precision)
@@ -1894,7 +2006,7 @@ void UsgsAstroLsSensorModel::losEllipsoidIntersect(
warnings->push_back(csm::Warning(
csm::Warning::NO_INTERSECTION, message, "UsgsAstroLsSensorModel::losElliposidIntersect"));
}
- MESSAGE_LOG(message)
+ MESSAGE_LOG(spdlog::level::warn, message)
}
double scale, scale1, h;
double sprev, hprev;
@@ -1916,6 +2028,7 @@ void UsgsAstroLsSensorModel::losEllipsoidIntersect(
achieved_precision = fabs(height - h);
MESSAGE_LOG(
+ spdlog::level::debug,
"losEllipsoidIntersect: found intersect at {} {} {}"
"with achieved precision of {}",
x, y, z, achieved_precision)
@@ -1930,7 +2043,10 @@ void UsgsAstroLsSensorModel::getAdjSensorPosVel(const double& time,
double& zc, double& vx,
double& vy, double& vz,
bool calc_vel) const {
- MESSAGE_LOG("Calculating getAdjSensorPosVel at time {}", time)
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Calculating getAdjSensorPosVel at time {}",
+ time)
// Sensor position and velocity (4th or 8th order Lagrange).
int nOrder = 8;
@@ -1956,10 +2072,11 @@ void UsgsAstroLsSensorModel::getAdjSensorPosVel(const double& time,
vy = 0.0;
vz = 0.0;
- MESSAGE_LOG("getAdjSensorPosVel: postition {} {} {}"
- "and velocity {} {} {}",
- xc, yc, zc, vx, vy, vz)
- return;
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "getAdjSensorPosVel: no velocity, postition ({}, {}, {})",
+ xc, yc, zc)
+ return;
}
}
@@ -1967,8 +2084,6 @@ void UsgsAstroLsSensorModel::getAdjSensorPosVel(const double& time,
lagrangeInterp(m_numPositions / 3, &m_velocities[0], m_t0Ephem, m_dtEphem,
time, 3, nOrder, sensVelNom);
- MESSAGE_LOG("getAdjSensorPosVel: using {} order Lagrange", nOrder)
-
// Compute rotation matrix from ICR to ECF
double radialUnitVec[3];
double radMag =
@@ -2026,8 +2141,9 @@ void UsgsAstroLsSensorModel::getAdjSensorPosVel(const double& time,
ecfFromIcr[8] * dr;
MESSAGE_LOG(
- "getAdjSensorPosVel: postition {} {} {}"
- "and velocity {} {} {}",
+ spdlog::level::debug,
+ "getAdjSensorPosVel: postition ({}, {}, {}) "
+ "and velocity ({}, {}, {})",
xc, yc, zc, vx, vy, vz)
}
@@ -2038,6 +2154,7 @@ std::vector<double> UsgsAstroLsSensorModel::computeDetectorView(
const double& time, const csm::EcefCoord& groundPoint,
const std::vector<double>& adj) const {
MESSAGE_LOG(
+ spdlog::level::debug,
"Computing computeDetectorView (with adjusments)"
"for ground point {} {} {} at time {} ",
groundPoint.x, groundPoint.y, groundPoint.z, time);
@@ -2054,8 +2171,10 @@ std::vector<double> UsgsAstroLsSensorModel::computeDetectorView(
double bodyLookX = groundPoint.x - xc;
double bodyLookY = groundPoint.y - yc;
double bodyLookZ = groundPoint.z - zc;
- MESSAGE_LOG("computeDetectorView: look vector {} {} {}", bodyLookX, bodyLookY,
- bodyLookZ)
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "computeDetectorView: look vector {} {} {}",
+ bodyLookX, bodyLookY, bodyLookZ)
// Rotate the look vector into the camera reference frame
double quaternions[4];
@@ -2074,6 +2193,7 @@ std::vector<double> UsgsAstroLsSensorModel::computeDetectorView(
bodyToCamera[5] * bodyLookY +
bodyToCamera[8] * bodyLookZ;
MESSAGE_LOG(
+ spdlog::level::trace,
"computeDetectorView: look vector (camera ref frame)"
"{} {} {}",
cameraLookX, cameraLookY, cameraLookZ)
@@ -2090,6 +2210,7 @@ std::vector<double> UsgsAstroLsSensorModel::computeDetectorView(
double adjustedLookZ = attCorr[2] * cameraLookX + attCorr[5] * cameraLookY +
attCorr[8] * cameraLookZ;
MESSAGE_LOG(
+ spdlog::level::trace,
"computeDetectorView: adjusted look vector"
"{} {} {}",
adjustedLookX, adjustedLookY, adjustedLookZ)
@@ -2100,6 +2221,7 @@ std::vector<double> UsgsAstroLsSensorModel::computeDetectorView(
double focalY = adjustedLookY * lookScale;
MESSAGE_LOG(
+ spdlog::level::debug,
"computeDetectorView: focal plane coordinates"
"x:{} y:{} scale:{}",
focalX, focalY, lookScale)
@@ -2112,6 +2234,10 @@ std::vector<double> UsgsAstroLsSensorModel::computeDetectorView(
//***************************************************************************
void UsgsAstroLsSensorModel::computeProjectiveApproximation(const csm::EcefCoord& gp,
csm::ImageCoord& ip) const {
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Computing projective approximation for ground point ({}, {}, {})",
+ gp.x, gp.y, gp.z);
if (m_useApproxInitTrans) {
std::vector<double> const& u = m_projTransCoeffs; // alias, to save on typing
@@ -2125,7 +2251,9 @@ void UsgsAstroLsSensorModel::computeProjectiveApproximation(const csm::EcefCoord
ip.line = m_nLines / 2.0;
ip.samp = m_nSamples / 2.0;
- MESSAGE_LOG("Computing initial guess with constant approx line/2 and sample/2");
+ MESSAGE_LOG(
+ spdlog::level::warn,
+ "Computing initial guess with constant approx line/2 and sample/2");
return;
}
@@ -2143,20 +2271,23 @@ void UsgsAstroLsSensorModel::computeProjectiveApproximation(const csm::EcefCoord
if (ip.samp < 0.0) ip.samp = 0.0;
if (ip.samp > numCols) ip.samp = numCols;
-
- MESSAGE_LOG("Computing initial guess with projective approximation");
} else {
ip.line = m_nLines / 2.0;
ip.samp = m_nSamples / 2.0;
- MESSAGE_LOG("Computing initial guess with constant approx line/2 and sample/2");
}
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Projective approximation ({}, {})",
+ ip.line, ip.samp);
}
//***************************************************************************
// UsgsAstroLineScannerSensorModel::createProjectiveApproximation
//***************************************************************************
void UsgsAstroLsSensorModel::createProjectiveApproximation() {
- MESSAGE_LOG("Calculating createProjectiveApproximation");
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Calculating createProjectiveApproximation");
// Use 9 points (9*4 eventual matrix rows) as we need to fit 14 variables.
const int numPts = 9;
@@ -2169,17 +2300,21 @@ void UsgsAstroLsSensorModel::createProjectiveApproximation() {
double height = computeEllipsoidElevation(
refPt.x, refPt.y, refPt.z, m_majorAxis, m_minorAxis, desired_precision);
if (std::isnan(height)) {
- MESSAGE_LOG("createProjectiveApproximation: computeElevation of"
- "reference point {} {} {} with desired precision"
- "{} returned nan height; nonprojective",
- refPt.x, refPt.y, refPt.z, desired_precision);
+ MESSAGE_LOG(
+ spdlog::level::warn,
+ "createProjectiveApproximation: computeElevation of"
+ "reference point {} {} {} with desired precision"
+ "{} returned nan height; nonprojective",
+ refPt.x, refPt.y, refPt.z, desired_precision);
m_useApproxInitTrans = false;
return;
}
- MESSAGE_LOG("createProjectiveApproximation: computeElevation of"
- "reference point {} {} {} with desired precision"
- "{} returned {} height",
- refPt.x, refPt.y, refPt.z, desired_precision, height);
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "createProjectiveApproximation: computeElevation of"
+ "reference point {} {} {} with desired precision"
+ "{} returned {} height",
+ refPt.x, refPt.y, refPt.z, desired_precision, height);
double numImageRows = m_nLines;
double numImageCols = m_nSamples;
@@ -2208,7 +2343,9 @@ void UsgsAstroLsSensorModel::createProjectiveApproximation() {
usgscsm::computeBestFitProjectiveTransform(ip, gp, m_projTransCoeffs);
m_useApproxInitTrans = true;
- MESSAGE_LOG("Completed createProjectiveApproximation");
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Completed createProjectiveApproximation");
}
//***************************************************************************
@@ -2217,7 +2354,9 @@ void UsgsAstroLsSensorModel::createProjectiveApproximation() {
std::string UsgsAstroLsSensorModel::constructStateFromIsd(
const std::string imageSupportData, csm::WarningList* warnings) {
json state = {};
- MESSAGE_LOG("Constructing state from Isd")
+ MESSAGE_LOG(
+ spdlog::level::debug,
+ "Constructing state from Isd")
// Instantiate UsgsAstroLineScanner sensor model
json jsonIsd = json::parse(imageSupportData);
std::shared_ptr<csm::WarningList> parsingWarnings(new csm::WarningList);
@@ -2227,6 +2366,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_sensorName"] = ale::getSensorName(jsonIsd);
state["m_platformName"] = ale::getPlatformName(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_modelName: {} "
"m_imageIdentifier: {} "
"m_sensorName: {} "
@@ -2235,11 +2375,15 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_sensorName"].dump(), state["m_platformName"].dump())
state["m_focalLength"] = ale::getFocalLength(jsonIsd);
- MESSAGE_LOG("m_focalLength: {} ", state["m_focalLength"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "m_focalLength: {} ",
+ state["m_focalLength"].dump())
state["m_nLines"] = ale::getTotalLines(jsonIsd);
state["m_nSamples"] = ale::getTotalSamples(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_nLines: {} "
"m_nSamples: {} ",
state["m_nLines"].dump(), state["m_nSamples"].dump())
@@ -2247,6 +2391,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_iTransS"] = ale::getFocal2PixelSamples(jsonIsd);
state["m_iTransL"] = ale::getFocal2PixelLines(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_iTransS: {} "
"m_iTransL: {} ",
state["m_iTransS"].dump(), state["m_iTransL"].dump())
@@ -2255,6 +2400,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_ikCode"] = 0;
state["m_zDirection"] = 1;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_platformFlag: {} "
"m_ikCode: {} "
"m_zDirection: {} ",
@@ -2265,13 +2411,17 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
getDistortionModel(ale::getDistortionModel(jsonIsd));
state["m_opticalDistCoeffs"] = ale::getDistortionCoeffs(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_distortionType: {} "
"m_opticalDistCoeffs: {} ",
state["m_distortionType"].dump(), state["m_opticalDistCoeffs"].dump())
// Zero computed state values
state["m_referencePointXyz"] = std::vector<double>(3, 0.0);
- MESSAGE_LOG("m_referencePointXyz: {} ", state["m_referencePointXyz"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "m_referencePointXyz: {} ",
+ state["m_referencePointXyz"].dump())
// Sun position and sensor position use the same times so compute that now
ale::States inst_state = ale::getInstrumentPosition(jsonIsd);
@@ -2290,22 +2440,28 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
try {
state["m_dtEphem"] = timeStep;
- MESSAGE_LOG("m_dtEphem: {} ", state["m_dtEphem"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "m_dtEphem: {} ",
+ state["m_dtEphem"].dump())
} catch (...) {
parsingWarnings->push_back(csm::Warning(
csm::Warning::DATA_NOT_AVAILABLE, "dt_ephemeris not in ISD",
"UsgsAstroFrameSensorModel::constructStateFromIsd()"));
- MESSAGE_LOG("m_dtEphem not in ISD")
+ MESSAGE_LOG(spdlog::level::warn, "m_dtEphem not in ISD")
}
try {
state["m_t0Ephem"] = startTime - ale::getCenterTime(jsonIsd);
- MESSAGE_LOG("t0_ephemeris: {}", state["m_t0Ephem"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "t0_ephemeris: {}",
+ state["m_t0Ephem"].dump())
} catch (...) {
parsingWarnings->push_back(csm::Warning(
csm::Warning::DATA_NOT_AVAILABLE, "t0_ephemeris not in ISD",
"UsgsAstroFrameSensorModel::constructStateFromIsd()"));
- MESSAGE_LOG("t0_ephemeris not in ISD")
+ MESSAGE_LOG(spdlog::level::warn, "t0_ephemeris not in ISD")
}
ale::States sunState = ale::getSunPosition(jsonIsd);
@@ -2335,6 +2491,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_halfSwath"] = 1000.0;
state["m_halfTime"] = 10.0;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_gsd: {} "
"m_flyingHeight: {} "
"m_halfSwath: {} "
@@ -2345,6 +2502,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_centerEphemerisTime"] = ale::getCenterTime(jsonIsd);
state["m_startingEphemerisTime"] = ale::getStartingTime(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_centerEphemerisTime: {} "
"m_startingEphemerisTime: {} ",
state["m_centerEphemerisTime"].dump(),
@@ -2357,6 +2515,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
getIntegrationStartTimes(lineScanRate, parsingWarnings.get());
state["m_intTimes"] = getIntegrationTimes(lineScanRate, parsingWarnings.get());
MESSAGE_LOG(
+ spdlog::level::trace,
"m_intTimeLines: {} "
"m_intTimeStartTimes: {} "
"m_intTimes: {} ",
@@ -2370,6 +2529,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_detectorSampleOrigin"] = ale::getDetectorCenterSample(jsonIsd);
state["m_detectorLineOrigin"] = ale::getDetectorCenterLine(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_detectorSampleSumming: {} "
"m_detectorLineSumming: {}"
"m_startingDetectorSample: {} "
@@ -2404,12 +2564,16 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_positions"] = positions;
state["m_numPositions"] = positions.size();
MESSAGE_LOG(
+ spdlog::level::trace,
"m_positions: {}"
"m_numPositions: {}",
state["m_positions"].dump(), state["m_numPositions"].dump())
state["m_velocities"] = velocities;
- MESSAGE_LOG("m_velocities: {}", state["m_velocities"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "m_velocities: {}",
+ state["m_velocities"].dump())
// Work-around for issues in ALE <=0.8.5 where Orientations without angular
// velocities seg fault when you multiply them. This will make the angular
@@ -2441,22 +2605,32 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
(ephemTime.back() - ephemTime.front()) / (ephemTime.size() - 1);
try {
state["m_dtQuat"] = quatStep;
- MESSAGE_LOG("dt_quaternion: {}", state["m_dtQuat"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "dt_quaternion: {}",
+ state["m_dtQuat"].dump())
} catch (...) {
parsingWarnings->push_back(csm::Warning(
csm::Warning::DATA_NOT_AVAILABLE, "dt_quaternion not in ISD",
"UsgsAstroFrameSensorModel::constructStateFromIsd()"));
- MESSAGE_LOG("dt_quaternion not in ISD")
+ MESSAGE_LOG(
+ spdlog::level::warn,
+ "dt_quaternion not in ISD")
}
try {
state["m_t0Quat"] = ephemTime[0] - ale::getCenterTime(jsonIsd);
- MESSAGE_LOG("m_t0Quat: {}", state["m_t0Quat"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "m_t0Quat: {}",
+ state["m_t0Quat"].dump())
} catch (...) {
parsingWarnings->push_back(csm::Warning(
csm::Warning::DATA_NOT_AVAILABLE, "t0_quaternion not in ISD",
"UsgsAstroFrameSensorModel::constructStateFromIsd()"));
- MESSAGE_LOG("t0_quaternion not in ISD")
+ MESSAGE_LOG(
+ spdlog::level::warn,
+ "t0_quaternion not in ISD")
}
std::vector<double> quaternion;
std::vector<double> quaternions;
@@ -2474,19 +2648,23 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_quaternions"] = quaternions;
state["m_numQuaternions"] = quaternions.size();
MESSAGE_LOG(
+ spdlog::level::trace,
"m_quaternions: {}"
"m_numQuaternions: {}",
state["m_quaternions"].dump(), state["m_numQuaternions"].dump())
state["m_currentParameterValue"] = std::vector<double>(NUM_PARAMETERS, 0.0);
- MESSAGE_LOG("m_currentParameterValue: {}",
- state["m_currentParameterValue"].dump())
+ MESSAGE_LOG(
+ spdlog::level::trace,
+ "m_currentParameterValue: {}",
+ state["m_currentParameterValue"].dump())
// Get radii
// ALE operates in km and we want m
state["m_minorAxis"] = ale::getSemiMinorRadius(jsonIsd) * 1000;
state["m_majorAxis"] = ale::getSemiMajorRadius(jsonIsd) * 1000;
MESSAGE_LOG(
+ spdlog::level::trace,
"m_minorAxis: {}"
"m_majorAxis: {}",
state["m_minorAxis"].dump(), state["m_majorAxis"].dump())
@@ -2495,6 +2673,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_platformIdentifier"] = ale::getPlatformName(jsonIsd);
state["m_sensorIdentifier"] = ale::getSensorName(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_platformIdentifier: {}"
"m_sensorIdentifier: {}",
state["m_platformIdentifier"].dump(), state["m_sensorIdentifier"].dump())
@@ -2503,6 +2682,7 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
state["m_minElevation"] = ale::getMinHeight(jsonIsd);
state["m_maxElevation"] = ale::getMaxHeight(jsonIsd);
MESSAGE_LOG(
+ spdlog::level::trace,
"m_minElevation: {}"
"m_maxElevation: {}",
state["m_minElevation"].dump(), state["m_maxElevation"].dump())
@@ -2533,8 +2713,6 @@ std::string UsgsAstroLsSensorModel::constructStateFromIsd(
// UsgsAstroLineScannerSensorModel::getLogger
//***************************************************************************
std::shared_ptr<spdlog::logger> UsgsAstroLsSensorModel::getLogger() {
- // MESSAGE_LOG("Getting log pointer, logger is {}",
- // m_logger)
return m_logger;
}
diff --git a/src/UsgsAstroPlugin.cpp b/src/UsgsAstroPlugin.cpp
index b073a46..d90ea7c 100644
--- a/src/UsgsAstroPlugin.cpp
+++ b/src/UsgsAstroPlugin.cpp
@@ -55,7 +55,7 @@ using json = nlohmann::json;
#define MESSAGE_LOG(...) \
if (m_logger) { \
- m_logger->info(__VA_ARGS__); \
+ m_logger->log(__VA_ARGS__); \
}
// Declaration of static variables
@@ -75,21 +75,27 @@ UsgsAstroPlugin::UsgsAstroPlugin() {
std::string logFile(logFilePtr);
if (logFile != "") {
- std::shared_ptr<spdlog::logger> m_logger = spdlog::get("usgscsm_logger");
+ m_logger = spdlog::get("usgscsm_logger");
if (!m_logger) {
if (logFile == "stdout") {
- std::shared_ptr<spdlog::logger> m_logger =
- spdlog::stdout_color_mt("usgscsm_logger");
+ m_logger = spdlog::stdout_color_mt("usgscsm_logger");
}
else if (logFile == "stderr") {
- std::shared_ptr<spdlog::logger> m_logger =
- spdlog::stderr_color_mt("usgscsm_logger");
+ m_logger = spdlog::stderr_color_mt("usgscsm_logger");
}
else {
- std::shared_ptr<spdlog::logger> m_logger =
- spdlog::basic_logger_mt("usgscsm_logger", logFile);
+ m_logger = spdlog::basic_logger_mt("usgscsm_logger", logFile);
}
+
+ char *logLevlPtr = getenv("USGSCSM_LOG_LEVEL");
+ if (logLevlPtr != NULL) {
+ std::string logLevelStr(logLevlPtr);
+ std::transform(logLevelStr.begin(), logLevelStr.end(), logLevelStr.begin(),
+ [](unsigned char c){ return std::tolower(c); });
+ m_logger->set_level(spdlog::level::from_str(logLevelStr));
+ }
+
}
}
}
@@ -98,27 +104,27 @@ UsgsAstroPlugin::UsgsAstroPlugin() {
UsgsAstroPlugin::~UsgsAstroPlugin() {}
std::string UsgsAstroPlugin::getPluginName() const {
- MESSAGE_LOG("Get Plugin Name: {}", _PLUGIN_NAME);
+ MESSAGE_LOG(spdlog::level::debug, "Get Plugin Name: {}", _PLUGIN_NAME);
return _PLUGIN_NAME;
}
std::string UsgsAstroPlugin::getManufacturer() const {
- MESSAGE_LOG("Get Manufacturer Name: {}", _MANUFACTURER_NAME);
+ MESSAGE_LOG(spdlog::level::debug, "Get Manufacturer Name: {}", _MANUFACTURER_NAME);
return _MANUFACTURER_NAME;
}
std::string UsgsAstroPlugin::getReleaseDate() const {
- MESSAGE_LOG("Get Release Date: {}", _RELEASE_DATE);
+ MESSAGE_LOG(spdlog::level::debug, "Get Release Date: {}", _RELEASE_DATE);
return _RELEASE_DATE;
}
csm::Version UsgsAstroPlugin::getCsmVersion() const {
- MESSAGE_LOG("Get Current CSM Version");
+ MESSAGE_LOG(spdlog::level::debug, "Get Current CSM Version");
return CURRENT_CSM_VERSION;
}
size_t UsgsAstroPlugin::getNumModels() const {
- MESSAGE_LOG("Get Number of Sensor Models: {}", _N_SENSOR_MODELS);
+ MESSAGE_LOG(spdlog::level::debug, "Get Number of Sensor Models: {}", _N_SENSOR_MODELS);
return _N_SENSOR_MODELS;
}
@@ -128,19 +134,19 @@ std::string UsgsAstroPlugin::getModelName(size_t modelIndex) const {
UsgsAstroLsSensorModel::_SENSOR_MODEL_NAME,
UsgsAstroSarSensorModel::_SENSOR_MODEL_NAME,
UsgsAstroPushFrameSensorModel::_SENSOR_MODEL_NAME};
- MESSAGE_LOG("Get Model Name: {}. Used index: {}",
+ MESSAGE_LOG(spdlog::level::debug, "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);
+ MESSAGE_LOG(spdlog::level::debug, "Get Model Familey: {}", CSM_RASTER_FAMILY);
return CSM_RASTER_FAMILY;
}
csm::Version UsgsAstroPlugin::getModelVersion(
const std::string &modelName) const {
- MESSAGE_LOG("Get Model Version");
+ MESSAGE_LOG(spdlog::level::debug, "Get Model Version");
return csm::Version(1, 0, 0);
}
@@ -175,7 +181,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromState(
fullMsg += err_msg;
fullMsg += "]";
- MESSAGE_LOG(fullMsg);
+ MESSAGE_LOG(spdlog::level::err, fullMsg);
if (warnings) {
warnings->push_back(csm::Warning
(csm::Warning::UNKNOWN_WARNING, fullMsg,
@@ -200,7 +206,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromISD(
msg += "] with error [";
msg += e.what();
msg += "]";
- MESSAGE_LOG(msg);
+ MESSAGE_LOG(spdlog::level::warn, msg);
warnings->push_back(csm::Warning(
csm::Warning::UNKNOWN_WARNING, msg,
"UsgsAstroFrameSensorModel::canModelBeConstructedFromISD()"));
@@ -210,7 +216,7 @@ bool UsgsAstroPlugin::canModelBeConstructedFromISD(
std::string msg = "Could not create model [";
msg += modelName;
msg += "] with an unknown error.";
- MESSAGE_LOG(msg);
+ MESSAGE_LOG(spdlog::level::warn, msg);
warnings->push_back(csm::Warning(
csm::Warning::UNKNOWN_WARNING, msg,
"UsgsAstroFrameSensorModel::canModelBeConstructedFromISD()"));
@@ -231,7 +237,7 @@ std::string UsgsAstroPlugin::loadImageSupportData(
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: {}, {}, {}, {}, {}",
+ MESSAGE_LOG(spdlog::level::info, "Load Image Support Data using: {}, {}, {}, {}, {}",
imageFilename, lastIndex, baseName, filename, isdFilename);
try {
std::ifstream isd_sidecar(isdFilename);
@@ -246,7 +252,7 @@ std::string UsgsAstroPlugin::loadImageSupportData(
errorMessage += "] with error [";
errorMessage += e.what();
errorMessage += "]";
- MESSAGE_LOG(errorMessage);
+ MESSAGE_LOG(spdlog::level::err, errorMessage);
throw csm::Error(csm::Error::FILE_READ, errorMessage,
"UsgsAstroPlugin::loadImageSupportData");
}
@@ -257,13 +263,13 @@ std::string UsgsAstroPlugin::getModelNameFromModelState(
auto state = stateAsJson(modelState);
std::string name = state.value<std::string>("name_model", "");
- MESSAGE_LOG("Get model name from model state. State: {}, Name: {}",
+ MESSAGE_LOG(spdlog::level::debug, "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);
+ MESSAGE_LOG(spdlog::level::err, aMessage);
csm::Error csmErr(aErrorType, aMessage, aFunction);
throw(csmErr);
}
@@ -274,7 +280,7 @@ std::string UsgsAstroPlugin::getModelNameFromModelState(
bool UsgsAstroPlugin::canISDBeConvertedToModelState(
const csm::Isd &imageSupportData, const std::string &modelName,
csm::WarningList *warnings) const {
- MESSAGE_LOG("Running canISDBeConvertedToModelState");
+ MESSAGE_LOG(spdlog::level::debug, "Running canISDBeConvertedToModelState");
try {
convertISDToModelState(imageSupportData, modelName, warnings);
} catch (std::exception &e) {
@@ -284,7 +290,7 @@ bool UsgsAstroPlugin::canISDBeConvertedToModelState(
msg += "] state with error [";
msg += e.what();
msg += "]";
- MESSAGE_LOG(msg);
+ MESSAGE_LOG(spdlog::level::warn, msg);
warnings->push_back(csm::Warning(
csm::Warning::UNKNOWN_WARNING, msg,
"UsgsAstroFrameSensorModel::canISDBeConvertedToModelState()"));
@@ -295,9 +301,9 @@ bool UsgsAstroPlugin::canISDBeConvertedToModelState(
}
std::string UsgsAstroPlugin::getStateFromISD(csm::Isd imageSupportData) const {
- MESSAGE_LOG("Running getStateFromISD");
+ MESSAGE_LOG(spdlog::level::debug, "Running getStateFromISD");
std::string stringIsd = loadImageSupportData(imageSupportData);
- MESSAGE_LOG("ISD string: {}", stringIsd);
+ MESSAGE_LOG(spdlog::level::trace, "ISD string: {}", stringIsd);
json jsonIsd = json::parse(stringIsd);
return convertISDToModelState(imageSupportData, jsonIsd.at("name_model"));
}
@@ -305,7 +311,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");
+ MESSAGE_LOG(spdlog::level::info, "Running convertISDToModelState");
std::shared_ptr<csm::Model> sensor_model
(constructModelFromISD(imageSupportData, modelName, warnings));
std::string stateString = sensor_model->getModelState();
@@ -315,17 +321,17 @@ std::string UsgsAstroPlugin::convertISDToModelState(
csm::Model *UsgsAstroPlugin::constructModelFromISD(
const csm::Isd &imageSupportDataOriginal, const std::string &modelName,
csm::WarningList *warnings) const {
- MESSAGE_LOG("Running constructModelFromISD");
+ MESSAGE_LOG(spdlog::level::info, "Running constructModelFromISD");
std::string stringIsd = loadImageSupportData(imageSupportDataOriginal);
- MESSAGE_LOG("ISD String: {}", stringIsd);
+ MESSAGE_LOG(spdlog::level::trace, "ISD String: {}", stringIsd);
if (modelName == UsgsAstroFrameSensorModel::_SENSOR_MODEL_NAME) {
UsgsAstroFrameSensorModel *model = new UsgsAstroFrameSensorModel();
try {
- MESSAGE_LOG("Trying to construct a UsgsAstroFrameSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Trying to construct a UsgsAstroFrameSensorModel");
model->replaceModelState(
model->constructStateFromIsd(stringIsd, warnings));
- MESSAGE_LOG("Constructed model: {}", modelName);
+ MESSAGE_LOG(spdlog::level::debug, "Constructed model: {}", modelName);
} catch (std::exception &e) {
delete model;
csm::Error::ErrorType aErrorType =
@@ -335,7 +341,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(
aMessage += "] with error [";
aMessage += e.what();
aMessage += "]";
- MESSAGE_LOG(aMessage);
+ MESSAGE_LOG(spdlog::level::err, aMessage);
std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";
throw csm::Error(aErrorType, aMessage, aFunction);
}
@@ -343,7 +349,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(
} else if (modelName == UsgsAstroLsSensorModel::_SENSOR_MODEL_NAME) {
UsgsAstroLsSensorModel *model = new UsgsAstroLsSensorModel();
try {
- MESSAGE_LOG("Trying to construct a UsgsAstroLsSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Trying to construct a UsgsAstroLsSensorModel");
model->replaceModelState(
model->constructStateFromIsd(stringIsd, warnings));
} catch (std::exception &e) {
@@ -356,13 +362,13 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(
aMessage += e.what();
aMessage += "]";
std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";
- MESSAGE_LOG(aMessage);
+ MESSAGE_LOG(spdlog::level::err, 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");
+ MESSAGE_LOG(spdlog::level::debug, "Trying to construct a UsgsAstroSarSensorModel");
try {
model->replaceModelState(
model->constructStateFromIsd(stringIsd, warnings));
@@ -376,13 +382,13 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(
aMessage += e.what();
aMessage += "]";
std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";
- MESSAGE_LOG(aMessage);
+ MESSAGE_LOG(spdlog::level::err, aMessage);
throw csm::Error(aErrorType, aMessage, aFunction);
}
return model;
} else if (modelName == UsgsAstroPushFrameSensorModel::_SENSOR_MODEL_NAME) {
UsgsAstroPushFrameSensorModel *model = new UsgsAstroPushFrameSensorModel();
- MESSAGE_LOG("Trying to construct a UsgsAstroPushFrameSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Trying to construct a UsgsAstroPushFrameSensorModel");
try {
model->replaceModelState(
model->constructStateFromIsd(stringIsd, warnings));
@@ -396,7 +402,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(
aMessage += e.what();
aMessage += "]";
std::string aFunction = "UsgsAstroPlugin::constructModelFromISD()";
- MESSAGE_LOG(aMessage);
+ MESSAGE_LOG(spdlog::level::err, aMessage);
throw csm::Error(aErrorType, aMessage, aFunction);
}
return model;
@@ -404,30 +410,30 @@ csm::Model *UsgsAstroPlugin::constructModelFromISD(
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);
+ MESSAGE_LOG(spdlog::level::err, aMessage);
throw csm::Error(aErrorType, aMessage, aFunction);
}
}
csm::Model *UsgsAstroPlugin::constructModelFromState(
const std::string &modelState, csm::WarningList *warnings) const {
- MESSAGE_LOG("Runing constructModelFromState with modelState: {}", modelState);
+ MESSAGE_LOG(spdlog::level::info, "Runing constructModelFromState with modelState: {}", modelState);
json state = stateAsJson(modelState);
std::string modelName = state["m_modelName"];
- MESSAGE_LOG("Using model name: {}", modelName);
+ MESSAGE_LOG(spdlog::level::debug, "Using model name: {}", modelName);
if (modelName == UsgsAstroFrameSensorModel::_SENSOR_MODEL_NAME) {
- MESSAGE_LOG("Constructing a UsgsAstroFrameSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Constructing a UsgsAstroFrameSensorModel");
UsgsAstroFrameSensorModel *model = new UsgsAstroFrameSensorModel();
model->replaceModelState(modelState);
return model;
} else if (modelName == UsgsAstroLsSensorModel::_SENSOR_MODEL_NAME) {
- MESSAGE_LOG("Constructing a UsgsAstroLsSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Constructing a UsgsAstroLsSensorModel");
UsgsAstroLsSensorModel *model = new UsgsAstroLsSensorModel();
model->replaceModelState(modelState);
return model;
} else if (modelName == UsgsAstroSarSensorModel::_SENSOR_MODEL_NAME) {
- MESSAGE_LOG("Constructing a UsgsAstroSarSensorModel");
+ MESSAGE_LOG(spdlog::level::debug, "Constructing a UsgsAstroSarSensorModel");
UsgsAstroSarSensorModel *model = new UsgsAstroSarSensorModel();
model->replaceModelState(modelState);
return model;
@@ -435,7 +441,7 @@ csm::Model *UsgsAstroPlugin::constructModelFromState(
csm::Error::ErrorType aErrorType = csm::Error::ISD_NOT_SUPPORTED;
std::string aMessage = "Model" + modelName + " not supported: ";
std::string aFunction = "UsgsAstroPlugin::constructModelFromState()";
- MESSAGE_LOG(aMessage);
+ MESSAGE_LOG(spdlog::level::err, aMessage);
throw csm::Error(aErrorType, aMessage, aFunction);
}
}
diff --git a/tests/Fixtures.h b/tests/Fixtures.h
index 350bf8f..cf5a2ee 100644
--- a/tests/Fixtures.h
+++ b/tests/Fixtures.h
@@ -87,6 +87,7 @@ class FrameSensorModelLogging : public ::testing::Test {
std::uintptr_t sensorId = reinterpret_cast<std::uintptr_t>(sensorModel);
auto logger = std::make_shared<spdlog::logger>(std::to_string(sensorId),
ostream_sink);
+ logger->set_level(spdlog::level::trace);
spdlog::register_logger(logger);
sensorModel->setLogger(std::to_string(sensorId));
--
GitLab