Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
U
Usgscsm
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Package registry
Container registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
GitLab community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
aflab
astrogeology
Usgscsm
Commits
4a874334
Commit
4a874334
authored
2 years ago
by
acpaquette
Browse files
Options
Downloads
Patches
Plain Diff
Removed a bunch of child class redundent functions
parent
dd83af45
No related branches found
No related tags found
No related merge requests found
Changes
2
Show whitespace changes
Inline
Side-by-side
Showing
2 changed files
include/usgscsm/UsgsAstroProjectedLsSensorModel.h
+2
-408
2 additions, 408 deletions
include/usgscsm/UsgsAstroProjectedLsSensorModel.h
src/UsgsAstroProjectedLsSensorModel.cpp
+5
-404
5 additions, 404 deletions
src/UsgsAstroProjectedLsSensorModel.cpp
with
7 additions
and
812 deletions
include/usgscsm/UsgsAstroProjectedLsSensorModel.h
+
2
−
408
View file @
4a874334
...
@@ -25,23 +25,21 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
...
@@ -25,23 +25,21 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDE_USGSCSM_USGSASTROPROJECTEDLSSENSORMODEL_H_
#ifndef INCLUDE_USGSCSM_USGSASTROPROJECTEDLSSENSORMODEL_H_
#define INCLUDE_USGSCSM_USGSASTROPROJECTEDLSSENSORMODEL_H_
#define INCLUDE_USGSCSM_USGSASTROPROJECTEDLSSENSORMODEL_H_
#include
<CorrelationModel.h>
#include
<RasterGM.h>
#include
<RasterGM.h>
#include
<SettableEllipsoid.h>
#include
<SettableEllipsoid.h>
#include
"Distortion.h"
#include
"UsgsAstroLsSensorModel.h"
#include
<utility>
#include
<utility>
#include
<memory>
#include
<memory>
#include
<string>
#include
<string>
#include
<vector>
#include
<vector>
#include
"ale/Distortion.h"
#include
"ale/Orientations.h"
#include
"ale/Orientations.h"
#include
"ale/States.h"
#include
"ale/States.h"
#include
"spdlog/spdlog.h"
#include
"spdlog/spdlog.h"
#include
"UsgsAstroLsSensorModel.h"
class
UsgsAstroProjectedLsSensorModel
:
public
UsgsAstroLsSensorModel
{
class
UsgsAstroProjectedLsSensorModel
:
public
UsgsAstroLsSensorModel
{
public:
public:
// Initializes the class from state data as formatted
// Initializes the class from state data as formatted
...
@@ -80,11 +78,6 @@ class UsgsAstroProjectedLsSensorModel : public UsgsAstroLsSensorModel {
...
@@ -80,11 +78,6 @@ class UsgsAstroProjectedLsSensorModel : public UsgsAstroLsSensorModel {
static
const
std
::
string
_SENSOR_MODEL_NAME
;
// state date element 0
static
const
std
::
string
_SENSOR_MODEL_NAME
;
// state date element 0
static
const
std
::
string
_STATE_KEYWORD
[];
static
const
std
::
string
_STATE_KEYWORD
[];
static
const
int
NUM_PARAM_TYPES
;
static
const
std
::
string
PARAM_STRING_ALL
[];
static
const
csm
::
param
::
Type
PARAM_CHAR_ALL
[];
static
const
int
NUM_PARAMETERS
;
static
const
std
::
string
PARAMETER_NAME
[];
// Set to default values
// Set to default values
void
reset
();
void
reset
();
...
@@ -247,272 +240,9 @@ class UsgsAstroProjectedLsSensorModel : public UsgsAstroLsSensorModel {
...
@@ -247,272 +240,9 @@ class UsgsAstroProjectedLsSensorModel : public UsgsAstroLsSensorModel {
// possible.
// possible.
//<
//<
//---
// Monoscopic Mensuration
//---
virtual
csm
::
ImageCoord
getImageStart
()
const
;
//> This method returns the starting coordinate (line, sample in full
// image space pixels) for the imaging operation. Typically (0,0).
//<
virtual
csm
::
ImageVector
getImageSize
()
const
;
//> This method returns the number of lines and samples in full image
// space pixels for the imaging operation.
//
// Note that the model might not be valid over the entire imaging
// operation. Use getValidImageRange() to get the valid range of image
// coordinates.
//<
virtual
std
::
pair
<
csm
::
ImageCoord
,
csm
::
ImageCoord
>
getValidImageRange
()
const
;
//> This method returns the minimum and maximum image coordinates
// (line, sample in full image space pixels), respectively, over which
// the current model is valid. The image coordinates define opposite
// corners of a rectangle whose sides are parallel to the line and
// sample axes.
//
// The valid image range does not always match the full image
// coverage as returned by the getImageStart and getImageSize methods.
//
// Used in conjunction with the getValidHeightRange method, it is
// possible to determine the full range of ground coordinates over which
// the model is valid.
//<
virtual
std
::
pair
<
double
,
double
>
getValidHeightRange
()
const
;
//> This method returns the minimum and maximum heights (in meters
// relative to WGS-84 ellipsoid), respectively, over which the model is
// valid. For example, a model for an airborne platform might not be
// designed to return valid coordinates for heights above the aircraft.
//
// If there are no limits defined for the model, (-99999.0,99999.0)
// will be returned.
//<
//---
// Time and Trajectory
//---
virtual
const
csm
::
CorrelationModel
&
getCorrelationModel
()
const
;
//> This method returns a reference to a CorrelationModel.
// The CorrelationModel is used to determine the correlation between
// the model parameters of different models of the same type.
// These correlations are used to establish the "a priori" cross-covariance
// between images. While some applications (such as generation of a
// replacement sensor model) may wish to call this method directly,
// it is reccommended that the inherited method
// GeometricModel::getCrossCovarianceMatrix() be called instead.
//<
virtual
std
::
vector
<
double
>
getUnmodeledCrossCovariance
(
const
csm
::
ImageCoord
&
pt1
,
const
csm
::
ImageCoord
&
pt2
)
const
;
//> This method returns the 2x2 line and sample cross covariance
// (in pixels squared) between the given imagePt1 and imagePt2 for any
// model error not accounted for by the model parameters. The error is
// reported as the four terms of a 2x2 matrix, returned as a 4 element
// vector.
//<
virtual
csm
::
EcefCoord
getReferencePoint
()
const
;
//> This method returns the ground point indicating the general
// location of the image.
//<
virtual
void
setReferencePoint
(
const
csm
::
EcefCoord
&
groundPt
);
//> This method sets the ground point indicating the general location
// of the image.
//<
//---
// Sensor Model Parameters
//---
virtual
int
getNumParameters
()
const
;
//> This method returns the number of adjustable parameters.
//<
virtual
std
::
string
getParameterName
(
int
index
)
const
;
//> This method returns the name for the adjustable parameter
// indicated by the given index.
//
// If the index is out of range, a csm::Error may be thrown.
//<
virtual
std
::
string
getParameterUnits
(
int
index
)
const
;
//> This method returns the units for the adjustable parameter
// indicated by the given index. This string is intended for human
// consumption, not automated analysis. Preferred unit names are:
//
//- meters "m"
//- centimeters "cm"
//- millimeters "mm"
//- micrometers "um"
//- nanometers "nm"
//- kilometers "km"
//- inches-US "inch"
//- feet-US "ft"
//- statute miles "mi"
//- nautical miles "nmi"
//-
//- radians "rad"
//- microradians "urad"
//- decimal degrees "deg"
//- arc seconds "arcsec"
//- arc minutes "arcmin"
//-
//- seconds "sec"
//- minutes "min"
//- hours "hr"
//-
//- steradian "sterad"
//-
//- none "unitless"
//-
//- lines per second "lines/sec"
//- samples per second "samples/sec"
//- frames per second "frames/sec"
//-
//- watts "watt"
//-
//- degrees Kelvin "K"
//-
//- gram "g"
//- kilogram "kg"
//- pound - US "lb"
//-
//- hertz "hz"
//- megahertz "mhz"
//- gigahertz "ghz"
//
// Units may be combined with "/" or "." to indicate division or
// multiplication. The caret symbol "^" can be used to indicate
// exponentiation. Thus "m.m" and "m^2" are the same and indicate
// square meters. The return "m/sec^2" indicates an acceleration in
// meters per second per second.
//
// Derived classes may choose to return additional unit names, as
// required.
//<
virtual
bool
hasShareableParameters
()
const
;
//> This method returns true if there exists at least one adjustable
// parameter on the model that is shareable. See the
// isParameterShareable() method. This method should return false if
// all calls to isParameterShareable() return false.
//<
virtual
bool
isParameterShareable
(
int
index
)
const
;
//> This method returns a flag to indicate whether or not the adjustable
// parameter referenced by index is shareable across models.
//<
virtual
csm
::
SharingCriteria
getParameterSharingCriteria
(
int
index
)
const
;
//> This method returns characteristics to indicate how the adjustable
// parameter referenced by index is shareable across models.
//<
virtual
double
getParameterValue
(
int
index
)
const
;
//> This method returns the value of the adjustable parameter
// referenced by the given index.
//<
virtual
void
setParameterValue
(
int
index
,
double
value
);
//> This method sets the value for the adjustable parameter referenced by
// the given index.
//<
virtual
csm
::
param
::
Type
getParameterType
(
int
index
)
const
;
//> This method returns the type of the adjustable parameter
// referenced by the given index.
//<
virtual
void
setParameterType
(
int
index
,
csm
::
param
::
Type
pType
);
//> This method sets the type of the adjustable parameter
// reference by the given index.
//<
virtual
std
::
shared_ptr
<
spdlog
::
logger
>
getLogger
();
virtual
void
setLogger
(
std
::
string
logName
);
//---
// Uncertainty Propagation
//---
virtual
double
getParameterCovariance
(
int
index1
,
int
index2
)
const
;
//> This method returns the covariance between the parameters
// referenced by index1 and index2. Variance of a single parameter
// is indicated by specifying the samve value for index1 and index2.
//<
virtual
void
setParameterCovariance
(
int
index1
,
int
index2
,
double
covariance
);
//> This method is used to set the covariance between the parameters
// referenced by index1 and index2. Variance of a single parameter
// is indicated by specifying the samve value for index1 and index2.
//<
//---
//---
// Error Correction
// Error Correction
//---
//---
virtual
int
getNumGeometricCorrectionSwitches
()
const
;
//> This method returns the number of geometric correction switches
// implemented for the current model.
//<
virtual
std
::
string
getGeometricCorrectionName
(
int
index
)
const
;
//> This method returns the name for the geometric correction switch
// referenced by the given index.
//<
virtual
void
setGeometricCorrectionSwitch
(
int
index
,
bool
value
,
csm
::
param
::
Type
pType
);
//> This method is used to enable/disable the geometric correction switch
// referenced by the given index.
//<
virtual
bool
getGeometricCorrectionSwitch
(
int
index
)
const
;
//> This method returns the value of the geometric correction switch
// referenced by the given index.
//<
virtual
std
::
vector
<
double
>
getCrossCovarianceMatrix
(
const
csm
::
GeometricModel
&
comparisonModel
,
csm
::
param
::
Set
pSet
=
csm
::
param
::
VALID
,
const
csm
::
GeometricModel
::
GeometricModelList
&
otherModels
=
csm
::
GeometricModel
::
GeometricModelList
())
const
;
//> This method returns a matrix containing the elements of the error
// cross covariance between this model and a given second model
// (comparisonModel). The set of cross covariance elements returned is
// indicated by pSet, which, by default, is all VALID parameters.
//
// If comparisonModel is the same as this model, the covariance for
// this model will be returned. It is equivalent to calling
// getParameterCovariance() for the same set of elements. Note that
// even if the cross covariance for a particular model type is always
// zero, the covariance for this model must still be supported.
//
// The otherModels list contains all of the models in the current
// photogrammetric process; some cross-covariance implementations are
// influenced by other models. It can be omitted if it is not needed
// by any models being used.
//
// The returned vector will logically be a two-dimensional matrix of
// covariances, though for simplicity it is stored in a one-dimensional
// vector (STL has no two-dimensional structure). The height (number of
// rows) of this matrix is the number of parameters on the current model,
// and the width (number of columns) is the number of parameters on
// the comparison model. Thus, the covariance between p1 on this model
// and p2 on the comparison model is found in index (N*p1 + p2)
// in the returned vector. N is the size of the vector returned by
// getParameterSetIndices() on the comparison model for the given pSet).
//
// Note that cross covariance is often zero. Non-zero cross covariance
// can occur for models created from the same sensor (or different
// sensors on the same platform). While cross covariances can result
// from a bundle adjustment involving multiple models, no mechanism
// currently exists within csm to "set" the cross covariance between
// models. It should thus be assumed that the returned cross covariance
// reflects the "un-adjusted" state of the models.
//<
virtual
csm
::
Version
getVersion
()
const
;
virtual
csm
::
Version
getVersion
()
const
;
//> This method returns the version of the model code. The Version
//> This method returns the version of the model code. The Version
...
@@ -531,142 +261,6 @@ class UsgsAstroProjectedLsSensorModel : public UsgsAstroLsSensorModel {
...
@@ -531,142 +261,6 @@ class UsgsAstroProjectedLsSensorModel : public UsgsAstroLsSensorModel {
// model created from the same sensor's support data would produce
// model created from the same sensor's support data would produce
// different pedigrees for each case.
// different pedigrees for each case.
//<
//<
//---
// Basic collection information
//---
virtual
std
::
string
getImageIdentifier
()
const
;
//> This method returns an identifier to uniquely indicate the imaging
// operation associated with this model.
// This is the primary identifier of the model.
//
// This method may return an empty string if the ID is unknown.
//<
virtual
void
setImageIdentifier
(
const
std
::
string
&
imageId
,
csm
::
WarningList
*
warnings
=
NULL
);
//> This method sets an identifier to uniquely indicate the imaging
// operation associated with this model. Typically used for models
// whose initialization does not produce an adequate identifier.
//
// If a non-NULL warnings argument is received, it will be populated
// as applicable.
//<
virtual
std
::
string
getSensorIdentifier
()
const
;
//> This method returns an identifier to indicate the specific sensor
// that was used to acquire the image. This ID must be unique among
// sensors for a given model name. It is used to determine parameter
// correlation and sharing. Equivalent to camera or mission ID.
//
// This method may return an empty string if the sensor ID is unknown.
//<
virtual
std
::
string
getPlatformIdentifier
()
const
;
//> This method returns an identifier to indicate the specific platform
// that was used to acquire the image. This ID must unique among
// platforms for a given model name. It is used to determine parameter
// correlation sharing. Equivalent to vehicle or aircraft tail number.
//
// This method may return an empty string if the platform ID is unknown.
//<
virtual
std
::
string
getCollectionIdentifier
()
const
;
//> This method returns an identifer to indicate a collection activity
// common to a set of images. This ID must be unique among collection
// activities for a given model name. It is used to determine parameter
// correlation and sharing.
//<
virtual
std
::
string
getTrajectoryIdentifier
()
const
;
//> This method returns an identifier to indicate a trajectory common
// to a set of images. This ID must be unique among trajectories
// for a given model name. It is used to determine parameter
// correlation and sharing.
//<
virtual
std
::
string
getSensorType
()
const
;
//> This method returns a description of the sensor type (EO, IR, SAR,
// etc). See csm.h for a list of common types. Should return
// CSM_SENSOR_TYPE_UNKNOWN if the sensor type is unknown.
//<
virtual
std
::
string
getSensorMode
()
const
;
//> This method returns a description of the sensor mode (FRAME,
// PUSHBROOM, SPOT, SCAN, etc). See csm.h for a list of common modes.
// Should return CSM_SENSOR_MODE_UNKNOWN if the sensor mode is unknown.
//<
virtual
std
::
string
getReferenceDateAndTime
()
const
;
//> This method returns an approximate date and time at which the
// image was taken. The returned string follows the ISO 8601 standard.
//
//- Precision Format Example
//- year yyyy "1961"
//- month yyyymm "196104"
//- day yyyymmdd "19610420"
//- hour yyyymmddThh "19610420T20"
//- minute yyyymmddThhmm "19610420T2000"
//- second yyyymmddThhmmss "19610420T200000"
//<
//---
// Sensor Model State
//---
// virtual std::string setModelState(std::string stateString) const;
//> This method returns a string containing the data to exactly recreate
// the current model. It can be used to restore this model to a
// previous state with the replaceModelState method or create a new
// model object that is identical to this model.
// The string could potentially be saved to a file for later use.
// An empty string is returned if it is not possible to save the
// current state.
//<
private:
// Some state data values not found in the support data require a
// sensor model in order to be set.
void
updateState
();
// This method returns the value of the specified adjustable parameter
// with the associated adjustment added in.
double
getValue
(
int
index
,
const
std
::
vector
<
double
>&
adjustments
)
const
;
void
reconstructSensorDistortion
(
double
&
focalX
,
double
&
focalY
,
const
double
&
desiredPrecision
)
const
;
// Computes the LOS correction due to light aberration
void
lightAberrationCorr
(
const
double
&
vx
,
const
double
&
vy
,
const
double
&
vz
,
const
double
&
xl
,
const
double
&
yl
,
const
double
&
zl
,
double
&
dxl
,
double
&
dyl
,
double
&
dzl
)
const
;
// Intersects a LOS at a specified height above the ellipsoid.
void
losEllipsoidIntersect
(
const
double
&
height
,
const
double
&
xc
,
const
double
&
yc
,
const
double
&
zc
,
const
double
&
xl
,
const
double
&
yl
,
const
double
&
zl
,
double
&
x
,
double
&
y
,
double
&
z
,
double
&
achieved_precision
,
const
double
&
desired_precision
,
csm
::
WarningList
*
warnings
=
NULL
)
const
;
// Computes the imaging locus that would view a ground point at a specific
// time. Computationally, this is the opposite of losToEcf.
std
::
vector
<
double
>
computeDetectorView
(
const
double
&
time
,
// The time to use the EO at
const
csm
::
EcefCoord
&
groundPoint
,
// The ground coordinate
const
std
::
vector
<
double
>&
adj
)
// Parameter Adjustments for partials
const
;
csm
::
NoCorrelationModel
_no_corr_model
;
// A way to report no correlation
// between images is supported
std
::
vector
<
double
>
_no_adjustment
;
// A vector of zeros indicating no internal adjustment
// Store here the projective approximation of the sensor model
std
::
vector
<
double
>
m_projTransCoeffs
;
// Flag indicating if an initial approximation is used
bool
m_useApproxInitTrans
;
};
};
#endif // INCLUDE_USGSCSM_USGSASTROPROJECTEDLSSENSORMODEL_H_
#endif // INCLUDE_USGSCSM_USGSASTROPROJECTEDLSSENSORMODEL_H_
This diff is collapsed.
Click to expand it.
src/UsgsAstroProjectedLsSensorModel.cpp
+
5
−
404
View file @
4a874334
...
@@ -23,15 +23,7 @@ IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISI
...
@@ -23,15 +23,7 @@ IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISI
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. **/
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. **/
#include
"UsgsAstroProjectedLsSensorModel.h"
#include
"UsgsAstroProjectedLsSensorModel.h"
#include
"Distortion.h"
#include
"Utilities.h"
#include
"Utilities.h"
#include
"EigenUtilities.h"
#include
<float.h>
#include
<math.h>
#include
<algorithm>
#include
<iostream>
#include
<sstream>
#include
<proj.h>
#include
<proj.h>
...
@@ -49,25 +41,6 @@ using json = nlohmann::json;
...
@@ -49,25 +41,6 @@ using json = nlohmann::json;
const
std
::
string
UsgsAstroProjectedLsSensorModel
::
_SENSOR_MODEL_NAME
=
const
std
::
string
UsgsAstroProjectedLsSensorModel
::
_SENSOR_MODEL_NAME
=
"USGS_ASTRO_PROJECTED_LINE_SCANNER_SENSOR_MODEL"
;
"USGS_ASTRO_PROJECTED_LINE_SCANNER_SENSOR_MODEL"
;
const
int
UsgsAstroProjectedLsSensorModel
::
NUM_PARAMETERS
=
16
;
const
std
::
string
UsgsAstroProjectedLsSensorModel
::
PARAMETER_NAME
[]
=
{
"IT Pos. Bias "
,
// 0
"CT Pos. Bias "
,
// 1
"Rad Pos. Bias "
,
// 2
"IT Vel. Bias "
,
// 3
"CT Vel. Bias "
,
// 4
"Rad Vel. Bias "
,
// 5
"Omega Bias "
,
// 6
"Phi Bias "
,
// 7
"Kappa Bias "
,
// 8
"Omega Rate "
,
// 9
"Phi Rate "
,
// 10
"Kappa Rate "
,
// 11
"Omega Accl "
,
// 12
"Phi Accl "
,
// 13
"Kappa Accl "
,
// 14
"Focal Bias "
// 15
};
const
std
::
string
UsgsAstroProjectedLsSensorModel
::
_STATE_KEYWORD
[]
=
{
const
std
::
string
UsgsAstroProjectedLsSensorModel
::
_STATE_KEYWORD
[]
=
{
"m_modelName"
,
"m_modelName"
,
...
@@ -123,13 +96,6 @@ const std::string UsgsAstroProjectedLsSensorModel::_STATE_KEYWORD[] = {
...
@@ -123,13 +96,6 @@ const std::string UsgsAstroProjectedLsSensorModel::_STATE_KEYWORD[] = {
"m_projString"
,
"m_projString"
,
};
};
const
int
UsgsAstroProjectedLsSensorModel
::
NUM_PARAM_TYPES
=
4
;
const
std
::
string
UsgsAstroProjectedLsSensorModel
::
PARAM_STRING_ALL
[]
=
{
"NONE"
,
"FICTITIOUS"
,
"REAL"
,
"FIXED"
};
const
csm
::
param
::
Type
UsgsAstroProjectedLsSensorModel
::
PARAM_CHAR_ALL
[]
=
{
csm
::
param
::
NONE
,
csm
::
param
::
FICTITIOUS
,
csm
::
param
::
REAL
,
csm
::
param
::
FIXED
};
//***************************************************************************
//***************************************************************************
// UsgsAstroLineScannerSensorModel::replaceModelState
// UsgsAstroLineScannerSensorModel::replaceModelState
//***************************************************************************
//***************************************************************************
...
@@ -212,18 +178,12 @@ void UsgsAstroProjectedLsSensorModel::reset() {
...
@@ -212,18 +178,12 @@ void UsgsAstroProjectedLsSensorModel::reset() {
//*****************************************************************************
//*****************************************************************************
// UsgsAstroProjectedLsSensorModel Constructor
// UsgsAstroProjectedLsSensorModel Constructor
//*****************************************************************************
//*****************************************************************************
UsgsAstroProjectedLsSensorModel
::
UsgsAstroProjectedLsSensorModel
()
{
UsgsAstroProjectedLsSensorModel
::
UsgsAstroProjectedLsSensorModel
()
:
UsgsAstroLsSensorModel
()
{}
_no_adjustment
.
assign
(
UsgsAstroProjectedLsSensorModel
::
NUM_PARAMETERS
,
0.0
);
}
//*****************************************************************************
//*****************************************************************************
// UsgsAstroProjectedLsSensorModel Destructor
// UsgsAstroProjectedLsSensorModel Destructor
//*****************************************************************************
//*****************************************************************************
UsgsAstroProjectedLsSensorModel
::~
UsgsAstroProjectedLsSensorModel
()
{
UsgsAstroProjectedLsSensorModel
::~
UsgsAstroProjectedLsSensorModel
()
{}
if
(
m_logger
)
{
m_logger
->
flush
();
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Core Photogrammetry
// Core Photogrammetry
...
@@ -393,118 +353,6 @@ csm::EcefLocus UsgsAstroProjectedLsSensorModel::imageToRemoteImagingLocus(
...
@@ -393,118 +353,6 @@ csm::EcefLocus UsgsAstroProjectedLsSensorModel::imageToRemoteImagingLocus(
return
UsgsAstroLsSensorModel
::
imageToRemoteImagingLocus
(
cameraImagePt
,
desired_precision
,
achieved_precision
,
warnings
);
return
UsgsAstroLsSensorModel
::
imageToRemoteImagingLocus
(
cameraImagePt
,
desired_precision
,
achieved_precision
,
warnings
);
}
}
//---------------------------------------------------------------------------
// Uncertainty Propagation
//---------------------------------------------------------------------------
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getParameterCovariance
//***************************************************************************
double
UsgsAstroProjectedLsSensorModel
::
getParameterCovariance
(
int
index1
,
int
index2
)
const
{
int
index
=
UsgsAstroProjectedLsSensorModel
::
NUM_PARAMETERS
*
index1
+
index2
;
MESSAGE_LOG
(
spdlog
::
level
::
debug
,
"getParameterCovariance for {} {} is {}"
,
index1
,
index2
,
m_covariance
[
index
])
return
m_covariance
[
index
];
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::setParameterCovariance
//***************************************************************************
void
UsgsAstroProjectedLsSensorModel
::
setParameterCovariance
(
int
index1
,
int
index2
,
double
covariance
)
{
int
index
=
UsgsAstroProjectedLsSensorModel
::
NUM_PARAMETERS
*
index1
+
index2
;
MESSAGE_LOG
(
spdlog
::
level
::
debug
,
"setParameterCovariance for {} {} is {}"
,
index1
,
index2
,
m_covariance
[
index
])
m_covariance
[
index
]
=
covariance
;
}
//---------------------------------------------------------------------------
// Time and Trajectory
//---------------------------------------------------------------------------
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getTrajectoryIdentifier
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getTrajectoryIdentifier
()
const
{
return
"UNKNOWN"
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getReferenceDateAndTime
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getReferenceDateAndTime
()
const
{
csm
::
EcefCoord
referencePointGround
=
UsgsAstroProjectedLsSensorModel
::
getReferencePoint
();
csm
::
ImageCoord
referencePointImage
=
UsgsAstroProjectedLsSensorModel
::
groundToImage
(
referencePointGround
);
double
relativeTime
=
UsgsAstroProjectedLsSensorModel
::
getImageTime
(
referencePointImage
);
time_t
ephemTime
=
m_centerEphemerisTime
+
relativeTime
;
return
ephemTimeToCalendarTime
(
ephemTime
);
}
//---------------------------------------------------------------------------
// Sensor Model Parameters
//---------------------------------------------------------------------------
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::setParameterValue
//***************************************************************************
void
UsgsAstroProjectedLsSensorModel
::
setParameterValue
(
int
index
,
double
value
)
{
m_currentParameterValue
[
index
]
=
value
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getParameterValue
//***************************************************************************
double
UsgsAstroProjectedLsSensorModel
::
getParameterValue
(
int
index
)
const
{
return
m_currentParameterValue
[
index
];
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getParameterName
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getParameterName
(
int
index
)
const
{
return
PARAMETER_NAME
[
index
];
}
std
::
string
UsgsAstroProjectedLsSensorModel
::
getParameterUnits
(
int
index
)
const
{
// All parameters are meters or scaled to meters
return
"m"
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getNumParameters
//***************************************************************************
int
UsgsAstroProjectedLsSensorModel
::
getNumParameters
()
const
{
return
UsgsAstroProjectedLsSensorModel
::
NUM_PARAMETERS
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getParameterType
//***************************************************************************
csm
::
param
::
Type
UsgsAstroProjectedLsSensorModel
::
getParameterType
(
int
index
)
const
{
return
m_parameterType
[
index
];
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::setParameterType
//***************************************************************************
void
UsgsAstroProjectedLsSensorModel
::
setParameterType
(
int
index
,
csm
::
param
::
Type
pType
)
{
m_parameterType
[
index
]
=
pType
;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Sensor Model Information
// Sensor Model Information
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
...
@@ -513,53 +361,7 @@ void UsgsAstroProjectedLsSensorModel::setParameterType(int index,
...
@@ -513,53 +361,7 @@ void UsgsAstroProjectedLsSensorModel::setParameterType(int index,
// UsgsAstroProjectedLsSensorModel::getPedigree
// UsgsAstroProjectedLsSensorModel::getPedigree
//***************************************************************************
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getPedigree
()
const
{
std
::
string
UsgsAstroProjectedLsSensorModel
::
getPedigree
()
const
{
return
"USGS_LINE_SCANNER"
;
return
"USGS_PROJECTED_LINE_SCANNER"
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getImageIdentifier
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getImageIdentifier
()
const
{
return
m_imageIdentifier
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::setImageIdentifier
//***************************************************************************
void
UsgsAstroProjectedLsSensorModel
::
setImageIdentifier
(
const
std
::
string
&
imageId
,
csm
::
WarningList
*
warnings
)
{
// Image id should include the suffix without the path name
m_imageIdentifier
=
imageId
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getSensorIdentifier
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getSensorIdentifier
()
const
{
return
m_sensorIdentifier
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getPlatformIdentifier
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getPlatformIdentifier
()
const
{
return
m_platformIdentifier
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::setReferencePoint
//***************************************************************************
void
UsgsAstroProjectedLsSensorModel
::
setReferencePoint
(
const
csm
::
EcefCoord
&
ground_pt
)
{
m_referencePointXyz
=
ground_pt
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getReferencePoint
//***************************************************************************
csm
::
EcefCoord
UsgsAstroProjectedLsSensorModel
::
getReferencePoint
()
const
{
// Return ground point at image center
return
m_referencePointXyz
;
}
}
//***************************************************************************
//***************************************************************************
...
@@ -569,196 +371,6 @@ std::string UsgsAstroProjectedLsSensorModel::getModelName() const {
...
@@ -569,196 +371,6 @@ std::string UsgsAstroProjectedLsSensorModel::getModelName() const {
return
UsgsAstroProjectedLsSensorModel
::
_SENSOR_MODEL_NAME
;
return
UsgsAstroProjectedLsSensorModel
::
_SENSOR_MODEL_NAME
;
}
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getImageStart
//***************************************************************************
csm
::
ImageCoord
UsgsAstroProjectedLsSensorModel
::
getImageStart
()
const
{
return
csm
::
ImageCoord
(
0.0
,
0.0
);
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getImageSize
//***************************************************************************
csm
::
ImageVector
UsgsAstroProjectedLsSensorModel
::
getImageSize
()
const
{
return
csm
::
ImageVector
(
m_nLines
,
m_nSamples
);
}
//---------------------------------------------------------------------------
// Monoscopic Mensuration
//---------------------------------------------------------------------------
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getValidHeightRange
//***************************************************************************
std
::
pair
<
double
,
double
>
UsgsAstroProjectedLsSensorModel
::
getValidHeightRange
()
const
{
return
std
::
pair
<
double
,
double
>
(
m_minElevation
,
m_maxElevation
);
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getValidImageRange
//***************************************************************************
std
::
pair
<
csm
::
ImageCoord
,
csm
::
ImageCoord
>
UsgsAstroProjectedLsSensorModel
::
getValidImageRange
()
const
{
return
std
::
pair
<
csm
::
ImageCoord
,
csm
::
ImageCoord
>
(
csm
::
ImageCoord
(
0.0
,
0.0
),
csm
::
ImageCoord
(
m_nLines
,
m_nSamples
));
// Technically nl and ns are outside the
// image in a zero based system.
}
//---------------------------------------------------------------------------
// Error Correction
//---------------------------------------------------------------------------
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getNumGeometricCorrectionSwitches
//***************************************************************************
int
UsgsAstroProjectedLsSensorModel
::
getNumGeometricCorrectionSwitches
()
const
{
return
0
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getGeometricCorrectionName
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getGeometricCorrectionName
(
int
index
)
const
{
MESSAGE_LOG
(
spdlog
::
level
::
debug
,
"Accessing name of geometric correction switch {}. "
"Geometric correction switches are not supported, throwing exception"
,
index
);
// Since there are no geometric corrections, all indices are out of range
throw
csm
::
Error
(
csm
::
Error
::
INDEX_OUT_OF_RANGE
,
"Index is out of range."
,
"UsgsAstroProjectedLsSensorModel::getGeometricCorrectionName"
);
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::setGeometricCorrectionSwitch
//***************************************************************************
void
UsgsAstroProjectedLsSensorModel
::
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"
,
index
,
value
,
pType
);
// Since there are no geometric corrections, all indices are out of range
throw
csm
::
Error
(
csm
::
Error
::
INDEX_OUT_OF_RANGE
,
"Index is out of range."
,
"UsgsAstroProjectedLsSensorModel::setGeometricCorrectionSwitch"
);
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getGeometricCorrectionSwitch
//***************************************************************************
bool
UsgsAstroProjectedLsSensorModel
::
getGeometricCorrectionSwitch
(
int
index
)
const
{
MESSAGE_LOG
(
spdlog
::
level
::
debug
,
"Accessing value of geometric correction switch {}. "
"Geometric correction switches are not supported, throwing exception"
,
index
);
// Since there are no geometric corrections, all indices are out of range
throw
csm
::
Error
(
csm
::
Error
::
INDEX_OUT_OF_RANGE
,
"Index is out of range."
,
"UsgsAstroProjectedLsSensorModel::getGeometricCorrectionSwitch"
);
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getCrossCovarianceMatrix
//***************************************************************************
std
::
vector
<
double
>
UsgsAstroProjectedLsSensorModel
::
getCrossCovarianceMatrix
(
const
csm
::
GeometricModel
&
comparisonModel
,
csm
::
param
::
Set
pSet
,
const
csm
::
GeometricModel
::
GeometricModelList
&
otherModels
)
const
{
// Return covariance matrix
if
(
&
comparisonModel
==
this
)
{
std
::
vector
<
int
>
paramIndices
=
getParameterSetIndices
(
pSet
);
int
numParams
=
paramIndices
.
size
();
std
::
vector
<
double
>
covariances
(
numParams
*
numParams
,
0.0
);
for
(
int
i
=
0
;
i
<
numParams
;
i
++
)
{
for
(
int
j
=
0
;
j
<
numParams
;
j
++
)
{
covariances
[
i
*
numParams
+
j
]
=
getParameterCovariance
(
paramIndices
[
i
],
paramIndices
[
j
]);
}
}
return
covariances
;
}
// No correlation between models.
const
std
::
vector
<
int
>&
indices
=
getParameterSetIndices
(
pSet
);
size_t
num_rows
=
indices
.
size
();
const
std
::
vector
<
int
>&
indices2
=
comparisonModel
.
getParameterSetIndices
(
pSet
);
size_t
num_cols
=
indices
.
size
();
return
std
::
vector
<
double
>
(
num_rows
*
num_cols
,
0.0
);
}
//***************************************************************************
// UsgsAstroLineScannerSensorModel::getCorrelationModel
//***************************************************************************
const
csm
::
CorrelationModel
&
UsgsAstroProjectedLsSensorModel
::
getCorrelationModel
()
const
{
// All Line Scanner images are assumed uncorrelated
return
_no_corr_model
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getUnmodeledCrossCovariance
//***************************************************************************
std
::
vector
<
double
>
UsgsAstroProjectedLsSensorModel
::
getUnmodeledCrossCovariance
(
const
csm
::
ImageCoord
&
pt1
,
const
csm
::
ImageCoord
&
pt2
)
const
{
// No unmodeled error
return
std
::
vector
<
double
>
(
4
,
0.0
);
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getCollectionIdentifier
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getCollectionIdentifier
()
const
{
return
"UNKNOWN"
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::hasShareableParameters
//***************************************************************************
bool
UsgsAstroProjectedLsSensorModel
::
hasShareableParameters
()
const
{
// Parameter sharing is not supported for this sensor
return
false
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::isParameterShareable
//***************************************************************************
bool
UsgsAstroProjectedLsSensorModel
::
isParameterShareable
(
int
index
)
const
{
// Parameter sharing is not supported for this sensor
return
false
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getParameterSharingCriteria
//***************************************************************************
csm
::
SharingCriteria
UsgsAstroProjectedLsSensorModel
::
getParameterSharingCriteria
(
int
index
)
const
{
MESSAGE_LOG
(
spdlog
::
level
::
debug
,
"Checking sharing criteria for parameter {}. "
"Sharing is not supported."
,
index
);
return
csm
::
SharingCriteria
();
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getSensorType
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getSensorType
()
const
{
return
CSM_SENSOR_TYPE_EO
;
}
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getSensorMode
//***************************************************************************
std
::
string
UsgsAstroProjectedLsSensorModel
::
getSensorMode
()
const
{
return
CSM_SENSOR_MODE_PB
;
}
//***************************************************************************
//***************************************************************************
// UsgsAstroProjectedLsSensorModel::getVersion
// UsgsAstroProjectedLsSensorModel::getVersion
//***************************************************************************
//***************************************************************************
...
@@ -786,14 +398,3 @@ std::string UsgsAstroProjectedLsSensorModel::constructStateFromIsd(
...
@@ -786,14 +398,3 @@ std::string UsgsAstroProjectedLsSensorModel::constructStateFromIsd(
// some state data is not in the ISD and requires a SM to compute them.
// some state data is not in the ISD and requires a SM to compute them.
return
lsState
.
dump
();
return
lsState
.
dump
();
}
}
//***************************************************************************
// UsgsAstroLineScannerSensorModel::getLogger
//***************************************************************************
std
::
shared_ptr
<
spdlog
::
logger
>
UsgsAstroProjectedLsSensorModel
::
getLogger
()
{
return
m_logger
;
}
void
UsgsAstroProjectedLsSensorModel
::
setLogger
(
std
::
string
logName
)
{
m_logger
=
spdlog
::
get
(
logName
);
}
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment