diff --git a/isis/src/base/objs/CameraStatistics/CameraStatistics.cpp b/isis/src/base/objs/CameraStatistics/CameraStatistics.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8d9252ed3f80d059bc37486734c186aa3db90b3f --- /dev/null +++ b/isis/src/base/objs/CameraStatistics/CameraStatistics.cpp @@ -0,0 +1,300 @@ +#include "IsisDebug.h" +#include "CameraStatistics.h" + +#include "Camera.h" +#include "Cube.h" +#include "Distance.h" +#include "Progress.h" +#include "Statistics.h" + +namespace Isis { + CameraStatistics::CameraStatistics(std::string filename, int sinc, int linc) { + Cube cube; + cube.Open(filename); + Camera *cam = cube.Camera(); + init(cam, sinc, linc, filename); + } + + + CameraStatistics::CameraStatistics(Camera *cam, int sinc, int linc) { + init(cam, sinc, linc, ""); + } + + + CameraStatistics::CameraStatistics(Camera *cam, int sinc, int linc, + std::string filename) { + init(cam, sinc, linc, filename); + } + + + void CameraStatistics::init(Camera *cam, int sinc, int linc, + std::string filename) { + + m_filename = filename; + m_sinc = sinc; + m_linc = linc; + + m_latStat = new Statistics(); + m_lonStat = new Statistics(); + m_resStat = new Statistics(); + m_sampleResStat = new Statistics(); + m_lineResStat = new Statistics(); + m_aspectRatioStat = new Statistics(); + m_phaseStat = new Statistics(); + m_emissionStat = new Statistics(); + m_incidenceStat = new Statistics(); + m_localSolarTimeStat = new Statistics(); + m_localRaduisStat = new Statistics(); + m_northAzimuthStat = new Statistics(); + + int eband = cam->Bands(); + + // If the camera is band independent then only run one band + if(cam->IsBandIndependent()) eband = 1; + + int pTotal = eband * ((cam->Lines() - 2) / linc + 2); + Progress progress; + progress.SetMaximumSteps(pTotal); + progress.CheckStatus(); + + for(int band = 1; band <= eband; band++) { + cam->SetBand(band); + for(int line = 1; line < (int)cam->Lines(); line = line + linc) { + for(int sample = 1; sample < cam->Samples(); sample = sample + sinc) { + addStats(cam, sample, line); + } + //set the sample value to the last sample and run buildstats + int sample = cam->Samples(); + addStats(cam, sample, line); + progress.CheckStatus(); + } + //set the line value to the last line and run on all samples(sample + sinc) + int line = cam->Lines(); + for(int sample = 1; sample < cam->Samples(); sample = sample + sinc) { + addStats(cam, sample, line); + } + //set last sample and run with last line + int sample = cam->Samples(); + addStats(cam, sample, line); + progress.CheckStatus(); + } + } + + + CameraStatistics::~CameraStatistics() { + if (m_latStat != NULL) { + delete m_latStat; + m_latStat = NULL; + } + if (m_lonStat != NULL) { + delete m_lonStat; + m_lonStat = NULL; + } + if (m_resStat != NULL) { + delete m_resStat; + m_resStat = NULL; + } + if (m_sampleResStat != NULL) { + delete m_sampleResStat; + m_sampleResStat = NULL; + } + if (m_lineResStat != NULL) { + delete m_lineResStat; + m_lineResStat = NULL; + } + if (m_aspectRatioStat != NULL) { + delete m_aspectRatioStat; + m_aspectRatioStat = NULL; + } + if (m_phaseStat != NULL) { + delete m_phaseStat; + m_phaseStat = NULL; + } + if (m_emissionStat != NULL) { + delete m_emissionStat; + m_emissionStat = NULL; + } + if (m_incidenceStat != NULL) { + delete m_incidenceStat; + m_incidenceStat = NULL; + } + if (m_localSolarTimeStat != NULL) { + delete m_localSolarTimeStat; + m_localSolarTimeStat = NULL; + } + if (m_localRaduisStat != NULL) { + delete m_localRaduisStat; + m_localRaduisStat = NULL; + } + if (m_northAzimuthStat != NULL) { + delete m_northAzimuthStat; + m_northAzimuthStat = NULL; + } + } + + + //function to add stats data to the stats object. + //also tests if the line and samp are valid + void CameraStatistics::addStats(Camera *cam, int &sample, int &line) { + cam->SetImage(sample, line); + if(cam->HasSurfaceIntersection()) { + m_latStat->AddData(cam->UniversalLatitude()); + m_lonStat->AddData(cam->UniversalLongitude()); + m_resStat->AddData(cam->PixelResolution()); + m_sampleResStat->AddData(cam->SampleResolution()); + m_lineResStat->AddData(cam->LineResolution()); + m_phaseStat->AddData(cam->PhaseAngle()); + m_emissionStat->AddData(cam->EmissionAngle()); + m_incidenceStat->AddData(cam->IncidenceAngle()); + m_localSolarTimeStat->AddData(cam->LocalSolarTime()); + m_localRaduisStat->AddData(cam->LocalRadius().GetMeters()); + m_northAzimuthStat->AddData(cam->NorthAzimuth()); + + double aspectRatio = cam->LineResolution() / cam->SampleResolution(); + m_aspectRatioStat->AddData(aspectRatio); + } + } + + + /** Produces NULL values for special pixels + * + * @param keyname Name of keyword to generate + * @param value Value to write to keyword + * @param unit Optional units for keywords + * + * @return PvlKeyword Newly created keyword + */ + PvlKeyword CameraStatistics::constructKeyword(std::string keyname, + double value, std::string unit="") const { + + if(IsSpecial(value)) { + return (PvlKeyword(keyname, "NULL")); + } + else { + return (PvlKeyword(keyname, value, unit)); + } + } + + + Pvl CameraStatistics::toPvl() const { + // Set up the Pvl groups and get min, max, avg, and sd for each statstics + // object + PvlGroup pUser("User Parameters"); + if (m_filename != "") pUser += PvlKeyword("Filename", m_filename); + pUser += PvlKeyword("Linc", m_linc); + pUser += PvlKeyword("Sinc", m_sinc); + + PvlGroup pLat("Latitude"); + pLat += constructKeyword("LatitudeMinimum", m_latStat->Minimum()); + pLat += constructKeyword("LatitudeMaximum", m_latStat->Maximum()); + pLat += constructKeyword("LatitudeAverage", m_latStat->Average()); + pLat += constructKeyword("LatitudeStandardDeviation", m_latStat->StandardDeviation()); + + PvlGroup pLon("Longitude"); + pLon += constructKeyword("LongitudeMinimum", m_lonStat->Minimum()); + pLon += constructKeyword("LongitudeMaximum", m_lonStat->Maximum()); + pLon += constructKeyword("LongitudeAverage", m_lonStat->Average()); + pLon += constructKeyword("LongitudeStandardDeviation", m_lonStat->StandardDeviation()); + + PvlGroup pSampleRes("SampleResolution"); + pSampleRes += constructKeyword("SampleResolutionMinimum", m_sampleResStat->Minimum(), + "meters/pixel"); + pSampleRes += constructKeyword("SampleResolutionMaximum", m_sampleResStat->Maximum(), + "meters/pixel"); + pSampleRes += constructKeyword("SampleResolutionAverage", m_sampleResStat->Average(), + "meters/pixel"); + pSampleRes += constructKeyword("SampleResolutionStandardDeviation", + m_sampleResStat->StandardDeviation(), "meters/pixel"); + + PvlGroup pLineRes("LineResolution"); + pLineRes += constructKeyword("LineResolutionMinimum", m_lineResStat->Minimum(), + "meters/pixel"); + pLineRes += constructKeyword("LineResolutionMaximum", m_lineResStat->Maximum(), + "meters/pixel"); + pLineRes += constructKeyword("LineResolutionAverage", m_lineResStat->Average(), + "meters/pixel"); + pLineRes += constructKeyword("LineResolutionStandardDeviation", + m_lineResStat->StandardDeviation(), "meters/pixel"); + + PvlGroup pResolution("Resolution"); + pResolution += constructKeyword("ResolutionMinimum", m_resStat->Minimum(), + "meters/pixel"); + pResolution += constructKeyword("ResolutionMaximum", m_resStat->Maximum(), + "meters/pixel"); + pResolution += constructKeyword("ResolutionAverage", m_resStat->Average(), + "meters/pixel"); + pResolution += constructKeyword("ResolutionStandardDeviation", + m_resStat->StandardDeviation(), "meters/pixel"); + + PvlGroup pAspectRatio("AspectRatio"); + pAspectRatio += constructKeyword("AspectRatioMinimum", m_aspectRatioStat->Minimum()); + pAspectRatio += constructKeyword("AspectRatioMaximun", m_aspectRatioStat->Maximum()); + pAspectRatio += constructKeyword("AspectRatioAverage", m_aspectRatioStat->Average()); + pAspectRatio += constructKeyword("AspectRatioStandardDeviation", + m_aspectRatioStat->StandardDeviation()); + + PvlGroup pPhase("PhaseAngle"); + pPhase += constructKeyword("PhaseMinimum", m_phaseStat->Minimum()); + pPhase += constructKeyword("PhaseMaximum", m_phaseStat->Maximum()); + pPhase += constructKeyword("PhaseAverage", m_phaseStat->Average()); + pPhase += constructKeyword("PhaseStandardDeviation", m_phaseStat->StandardDeviation()); + + PvlGroup pEmission("EmissionAngle"); + pEmission += constructKeyword("EmissionMinimum", m_emissionStat->Minimum()); + pEmission += constructKeyword("EmissionMaximum", m_emissionStat->Maximum()); + pEmission += constructKeyword("EmissionAverage", m_emissionStat->Average()); + pEmission += constructKeyword("EmissionStandardDeviation", + m_emissionStat->StandardDeviation()); + + PvlGroup pIncidence("IncidenceAngle"); + pIncidence += constructKeyword("IncidenceMinimum", m_incidenceStat->Minimum()); + pIncidence += constructKeyword("IncidenceMaximum", m_incidenceStat->Maximum()); + pIncidence += constructKeyword("IncidenceAverage", m_incidenceStat->Average()); + pIncidence += constructKeyword("IncidenceStandardDeviation", + m_incidenceStat->StandardDeviation()); + + PvlGroup pTime("LocalSolarTime"); + pTime += constructKeyword("LocalSolarTimeMinimum", m_localSolarTimeStat->Minimum(), + "hours"); + pTime += constructKeyword("LocalSolarTimeMaximum", m_localSolarTimeStat->Maximum(), + "hours"); + pTime += constructKeyword("LocalSolarTimeAverage", m_localSolarTimeStat->Average(), + "hours"); + pTime += constructKeyword("LocalSolarTimeStandardDeviation", + m_localSolarTimeStat->StandardDeviation(), "hours"); + + PvlGroup pLocalRadius("LocalRadius"); + pLocalRadius += constructKeyword("LocalRadiusMinimum", m_localRaduisStat->Minimum()); + pLocalRadius += constructKeyword("LocalRadiusMaximum", m_localRaduisStat->Maximum()); + pLocalRadius += constructKeyword("LocalRadiusAverage", m_localRaduisStat->Average()); + pLocalRadius += constructKeyword("LocalRadiusStandardDeviation", + m_localRaduisStat->StandardDeviation()); + + PvlGroup pNorthAzimuth("NorthAzimuth"); + pNorthAzimuth += constructKeyword("NorthAzimuthMinimum", m_northAzimuthStat->Minimum()); + pNorthAzimuth += constructKeyword("NorthAzimuthMaximum", m_northAzimuthStat->Maximum()); + pNorthAzimuth += constructKeyword("NorthAzimuthAverage", m_northAzimuthStat->Average()); + pNorthAzimuth += constructKeyword("NorthAzimuthStandardDeviation", + m_northAzimuthStat->StandardDeviation()); + + Pvl returnPvl; + returnPvl.SetTerminator(""); + returnPvl.AddGroup(pUser); + returnPvl.AddGroup(pLat); + returnPvl.AddGroup(pLon); + returnPvl.AddGroup(pSampleRes); + returnPvl.AddGroup(pLineRes); + returnPvl.AddGroup(pResolution); + returnPvl.AddGroup(pAspectRatio); + returnPvl.AddGroup(pPhase); + returnPvl.AddGroup(pEmission); + returnPvl.AddGroup(pIncidence); + returnPvl.AddGroup(pTime); + returnPvl.AddGroup(pLocalRadius); + returnPvl.AddGroup(pNorthAzimuth); + return returnPvl; + } + + +} // End namespace Isis + diff --git a/isis/src/base/objs/CameraStatistics/CameraStatistics.h b/isis/src/base/objs/CameraStatistics/CameraStatistics.h new file mode 100644 index 0000000000000000000000000000000000000000..04776b0e79a01de24f4cb5fe8ebaeada8730570d --- /dev/null +++ b/isis/src/base/objs/CameraStatistics/CameraStatistics.h @@ -0,0 +1,117 @@ +/** + * @file + * $Revision: 1.16 $ + * $Date: 2010/06/15 18:27:43 $ + * + * Unless noted otherwise, the portions of Isis written by the USGS are + * public domain. See individual third-party library and package descriptions + * for intellectual property information, user agreements, and related + * information. + * + * Although Isis has been used by the USGS, no warranty, expressed or + * implied, is made by the USGS as to the accuracy and functioning of such + * software and related material nor shall the fact of distribution + * constitute any such warranty, and no responsibility is assumed by the + * USGS in connection therewith. + * + * For additional information, launch + * $ISISROOT/doc//documents/Disclaimers/Disclaimers.html + * in a browser or see the Privacy & Disclaimers page on the Isis website, + * http://isis.astrogeology.usgs.gov, and the USGS privacy and disclaimers on + * http://www.usgs.gov/privacy.html. + */ + +#ifndef CameraStatistics_h +#define CameraStatistics_h + +#include + +namespace Isis { + class Camera; + class Pvl; + class PvlKeyword; + class Statistics; + + class CameraStatistics { + public: + CameraStatistics(std::string filename, int sinc, int linc); + CameraStatistics(Camera *cam, int sinc, int linc); + CameraStatistics(Camera *cam, int sinc, int linc, std::string filename); + virtual ~CameraStatistics(); + + void addStats(Camera *cam, int &sample, int &line); + PvlKeyword constructKeyword(std::string keyname, double value, + std::string unit) const; + Pvl toPvl() const; + + const Statistics * getLatStat() const { + return m_latStat; + }; + + const Statistics * getLonStat() const { + return m_lonStat; + }; + + const Statistics * getResStat() const { + return m_resStat; + }; + + const Statistics * getSampleResStat() const { + return m_sampleResStat; + }; + + const Statistics * getLineResStat() const { + return m_lineResStat; + }; + + const Statistics * getAspectRatioStat() const { + return m_aspectRatioStat; + }; + + const Statistics * getPhaseStat() const { + return m_phaseStat; + }; + + const Statistics * getEmissionStat() const { + return m_emissionStat; + }; + + const Statistics * getIncidenceStat() const { + return m_incidenceStat; + }; + + const Statistics * getLocalSolarTimeStat() const { + return m_localSolarTimeStat; + }; + + const Statistics * getLocalRaduisStat() const { + return m_localRaduisStat; + }; + + const Statistics * getNorthAzimuthStat() const { + return m_northAzimuthStat; + }; + + private: + void init(Camera *cam, int sinc, int linc, std::string filename); + + std::string m_filename; + int m_sinc; + int m_linc; + + Statistics *m_latStat; + Statistics *m_lonStat; + Statistics *m_resStat; + Statistics *m_sampleResStat; + Statistics *m_lineResStat; + Statistics *m_aspectRatioStat; + Statistics *m_phaseStat; + Statistics *m_emissionStat; + Statistics *m_incidenceStat; + Statistics *m_localSolarTimeStat; + Statistics *m_localRaduisStat; + Statistics *m_northAzimuthStat; + }; +}; + +#endif diff --git a/isis/src/base/objs/CameraStatistics/CameraStatistics.truth b/isis/src/base/objs/CameraStatistics/CameraStatistics.truth new file mode 100644 index 0000000000000000000000000000000000000000..8715c91349f021b6efb257abaa8a5f6d9d9b674d --- /dev/null +++ b/isis/src/base/objs/CameraStatistics/CameraStatistics.truth @@ -0,0 +1,92 @@ +UnitTest for Camera Statistics +Working +0% Processed 10% Processed 20% Processed 30% Processed 40% Processed 50% Processed 60% Processed 70% Processed 80% Processed 90% Processed 100% Processed +Group = "User Parameters" + Linc = 1 + Sinc = 1 +End_Group + +Group = Latitude + LatitudeMinimum = -20.743419955997 + LatitudeMaximum = -18.686072173289 + LatitudeAverage = -19.71681386966 + LatitudeStandardDeviation = 0.58835134290867 +End_Group + +Group = Longitude + LongitudeMinimum = 59.57478574391 + LongitudeMaximum = 61.760679042474 + LongitudeAverage = 60.674084136199 + LongitudeStandardDeviation = 0.62505397316487 +End_Group + +Group = SampleResolution + SampleResolutionMinimum = 244.73491531858 + SampleResolutionMaximum = 245.67634691522 + SampleResolutionAverage = 245.01463448871 + SampleResolutionStandardDeviation = 0.18103889280198 +End_Group + +Group = LineResolution + LineResolutionMinimum = 244.73491531858 + LineResolutionMaximum = 245.67634691522 + LineResolutionAverage = 245.01463448871 + LineResolutionStandardDeviation = 0.18103889280198 +End_Group + +Group = Resolution + ResolutionMinimum = 244.73491531858 + ResolutionMaximum = 245.67634691522 + ResolutionAverage = 245.01463448871 + ResolutionStandardDeviation = 0.18103889280198 +End_Group + +Group = AspectRatio + AspectRatioMinimum = 1.0 + AspectRatioMaximun = 1.0 + AspectRatioAverage = 1.0 + AspectRatioStandardDeviation = 0.0 +End_Group + +Group = PhaseAngle + PhaseMinimum = 26.054237241148 + PhaseMaximum = 33.901113868904 + PhaseAverage = 30.017793870509 + PhaseStandardDeviation = 1.6368195261582 +End_Group + +Group = EmissionAngle + EmissionMinimum = 0.011134531995214 + EmissionMaximum = 5.8513054958698 + EmissionAverage = 2.9866724541674 + EmissionStandardDeviation = 1.1256764927357 +End_Group + +Group = IncidenceAngle + IncidenceMinimum = 28.746959414683 + IncidenceMaximum = 31.56881410666 + IncidenceAverage = 30.162744173036 + IncidenceStandardDeviation = 0.58835691504548 +End_Group + +Group = LocalSolarTime + LocalSolarTimeMinimum = 10.419188834715 + LocalSolarTimeMaximum = 10.56491505462 + LocalSolarTimeAverage = 10.492475394201 + LocalSolarTimeStandardDeviation = 0.041670264876096 +End_Group + +Group = LocalRadius + LocalRadiusMinimum = 1737400.0 + LocalRadiusMaximum = 1737400.0 + LocalRadiusAverage = 1737400.0 + LocalRadiusStandardDeviation = 0.0 +End_Group + +Group = NorthAzimuth + NorthAzimuthMinimum = 7.65717912202035e-04 + NorthAzimuthMaximum = 359.999865858 + NorthAzimuthAverage = 356.02518387129 + NorthAzimuthStandardDeviation = 28.450666885516 +End_Group + diff --git a/isis/src/base/objs/CameraStatistics/Makefile b/isis/src/base/objs/CameraStatistics/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..f122bc88227c5c7ebd108dea5d339d1d2e074d82 --- /dev/null +++ b/isis/src/base/objs/CameraStatistics/Makefile @@ -0,0 +1,7 @@ +ifeq ($(ISISROOT), $(BLANK)) +.SILENT: +error: + echo "Please set ISISROOT"; +else + include $(ISISROOT)/make/isismake.objs +endif \ No newline at end of file diff --git a/isis/src/base/objs/CameraStatistics/unitTest.cpp b/isis/src/base/objs/CameraStatistics/unitTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..52d153ba2158e94148969158173fdea59e473261 --- /dev/null +++ b/isis/src/base/objs/CameraStatistics/unitTest.cpp @@ -0,0 +1,30 @@ +#include + +#include "Camera.h" +#include "CameraStatistics.h" +#include "Cube.h" +#include "iException.h" +#include "Pvl.h" +#include "Preference.h" +#include "Statistics.h" + +using namespace std; + +int main(int argc, char *argv[]) { + Isis::Preference::Preferences(true); + + try { + cout << "UnitTest for Camera Statistics" << endl; + Isis::Cube cube; + cube.Open("$Clementine1/testData/lna1391h.cub"); + Isis::Camera *cam = cube.Camera(); + cout << setprecision(9); + + Isis::CameraStatistics camStats(cam, 1, 1); + Isis::Pvl test = camStats.toPvl(); + cout << test << endl; + } + catch(Isis::iException &e) { + e.Report(); + } +}