void IsisMain() {
UserInterface &ui = Application::GetUserInterface();
Cube cube;
cube.open(ui.GetFileName("FROM"), "rw");
// Make sure cube has been run through spiceinit
try {
cube.camera();
}
catch(IException &e) {
string msg = "Spiceinit must be run before initializing the polygon";
throw IException(e, IException::User, msg, _FILEINFO_);
}
Progress prog;
prog.SetMaximumSteps(1);
prog.CheckStatus();
QString sn = SerialNumber::Compose(cube);
ImagePolygon poly;
if(ui.WasEntered("MAXEMISSION")) {
poly.Emission(ui.GetDouble("MAXEMISSION"));
}
if(ui.WasEntered("MAXINCIDENCE")) {
poly.Incidence(ui.GetDouble("MAXINCIDENCE"));
}
if(ui.GetString("LIMBTEST") == "ELLIPSOID") {
poly.EllipsoidLimb(true);
}
int sinc = 1;
int linc = 1;
IString incType = ui.GetString("INCTYPE");
if(incType.UpCase() == "VERTICES") {
poly.initCube(cube);
sinc = linc = (int)(0.5 + (((poly.validSampleDim() * 2) +
(poly.validLineDim() * 2) - 3.0) /
ui.GetInteger("NUMVERTICES")));
if (sinc < 1.0 || linc < 1.0)
sinc = linc = 1.0;
}
else if (incType.UpCase() == "LINCSINC"){
sinc = ui.GetInteger("SINC");
linc = ui.GetInteger("LINC");
}
else {
string msg = "Invalid INCTYPE option[" + incType + "]";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
bool precision = ui.GetBoolean("INCREASEPRECISION");
try {
poly.Create(cube, sinc, linc, 1, 1, 0, 0, 1, precision);
}
catch (IException &e) {
QString msg = "Cannot generate polygon for [" + ui.GetFileName("FROM") + "]";
throw IException(e, IException::User, msg, _FILEINFO_);
}
if(ui.GetBoolean("TESTXY")) {
Pvl cubeLab(ui.GetFileName("FROM"));
PvlGroup inst = cubeLab.findGroup("Instrument", Pvl::Traverse);
QString target = inst["TargetName"];
PvlGroup radii = Projection::TargetRadii(target);
Pvl map(ui.GetFileName("MAP"));
PvlGroup &mapping = map.findGroup("MAPPING");
if(!mapping.hasKeyword("TargetName"))
mapping += Isis::PvlKeyword("TargetName", target);
if(!mapping.hasKeyword("EquatorialRadius"))
mapping += Isis::PvlKeyword("EquatorialRadius", (QString)radii["EquatorialRadius"]);
if(!mapping.hasKeyword("PolarRadius"))
mapping += Isis::PvlKeyword("PolarRadius", (QString)radii["PolarRadius"]);
if(!mapping.hasKeyword("LatitudeType"))
mapping += Isis::PvlKeyword("LatitudeType", "Planetocentric");
if(!mapping.hasKeyword("LongitudeDirection"))
mapping += Isis::PvlKeyword("LongitudeDirection", "PositiveEast");
if(!mapping.hasKeyword("LongitudeDomain"))
mapping += Isis::PvlKeyword("LongitudeDomain", "360");
if(!mapping.hasKeyword("CenterLatitude"))
mapping += Isis::PvlKeyword("CenterLatitude", "0");
if(!mapping.hasKeyword("CenterLongitude"))
mapping += Isis::PvlKeyword("CenterLongitude", "0");
sinc = poly.getSinc();
linc = poly.getLinc();
bool polygonGenerated = false;
while (!polygonGenerated) {
Projection *proj = NULL;
geos::geom::MultiPolygon *xyPoly = NULL;
try {
proj = ProjectionFactory::Create(map, true);
xyPoly = PolygonTools::LatLonToXY(*poly.Polys(), proj);
polygonGenerated = true;
}
catch (IException &e) {
if (precision && sinc > 1 && linc > 1) {
sinc = sinc * 2 / 3;
linc = linc * 2 / 3;
poly.Create(cube, sinc, linc);
}
else {
delete proj;
delete xyPoly;
e.print(); // This should be a NAIF error
QString msg = "Cannot calculate XY for [";
msg += ui.GetFileName("FROM") + "]";
throw IException(e, IException::User, msg, _FILEINFO_);
}
}
delete proj;
delete xyPoly;
}
}
cube.deleteBlob("Polygon", sn);
cube.write(poly);
if(precision) {
PvlGroup results("Results");
results.addKeyword(PvlKeyword("SINC", toString(sinc)));
results.addKeyword(PvlKeyword("LINC", toString(linc)));
Application::Log(results);
}
Process p;
p.SetInputCube("FROM");
p.WriteHistory(cube);
cube.close();
prog.CheckStatus();
}
void IsisMain() {
const QString caminfo_program = "caminfo";
UserInterface &ui = Application::GetUserInterface();
QList< QPair<QString, QString> > *general = NULL, *camstats = NULL, *statistics = NULL;
BandGeometry *bandGeom = NULL;
// Get input filename
FileName in = ui.GetFileName("FROM");
// Get the format
QString sFormat = ui.GetAsString("FORMAT");
// if true then run spiceinit, xml default is FALSE
// spiceinit will use system kernels
if(ui.GetBoolean("SPICE")) {
QString parameters = "FROM=" + in.expanded();
ProgramLauncher::RunIsisProgram("spiceinit", parameters);
}
Process p;
Cube *incube = p.SetInputCube("FROM");
// General data gathering
general = new QList< QPair<QString, QString> >;
general->append(MakePair("Program", caminfo_program));
general->append(MakePair("IsisVersion", Application::Version()));
general->append(MakePair("RunDate", iTime::CurrentGMT()));
general->append(MakePair("IsisId", SerialNumber::Compose(*incube)));
general->append(MakePair("From", in.baseName() + ".cub"));
general->append(MakePair("Lines", toString(incube->lineCount())));
general->append(MakePair("Samples", toString(incube->sampleCount())));
general->append(MakePair("Bands", toString(incube->bandCount())));
// Run camstats on the entire image (all bands)
// another camstats will be run for each band and output
// for each band.
if(ui.GetBoolean("CAMSTATS")) {
camstats = new QList< QPair<QString, QString> >;
QString filename = ui.GetAsString("FROM");
int sinc = ui.GetInteger("SINC");
int linc = ui.GetInteger("LINC");
CameraStatistics stats(filename, sinc, linc);
Pvl camPvl = stats.toPvl();
PvlGroup cg = camPvl.findGroup("Latitude", Pvl::Traverse);
camstats->append(MakePair("MinimumLatitude", cg["latitudeminimum"][0]));
camstats->append(MakePair("MaximumLatitude", cg["latitudemaximum"][0]));
cg = camPvl.findGroup("Longitude", Pvl::Traverse);
camstats->append(MakePair("MinimumLongitude", cg["longitudeminimum"][0]));
camstats->append(MakePair("MaximumLongitude", cg["longitudemaximum"][0]));
cg = camPvl.findGroup("Resolution", Pvl::Traverse);
camstats->append(MakePair("MinimumResolution", cg["resolutionminimum"][0]));
camstats->append(MakePair("MaximumResolution", cg["resolutionmaximum"][0]));
cg = camPvl.findGroup("PhaseAngle", Pvl::Traverse);
camstats->append(MakePair("MinimumPhase", cg["phaseminimum"][0]));
camstats->append(MakePair("MaximumPhase", cg["phasemaximum"][0]));
cg = camPvl.findGroup("EmissionAngle", Pvl::Traverse);
camstats->append(MakePair("MinimumEmission", cg["emissionminimum"][0]));
camstats->append(MakePair("MaximumEmission", cg["emissionmaximum"][0]));
cg = camPvl.findGroup("IncidenceAngle", Pvl::Traverse);
camstats->append(MakePair("MinimumIncidence", cg["incidenceminimum"][0]));
camstats->append(MakePair("MaximumIncidence", cg["incidencemaximum"][0]));
cg = camPvl.findGroup("LocalSolarTime", Pvl::Traverse);
camstats->append(MakePair("LocalTimeMinimum", cg["localsolartimeMinimum"][0]));
camstats->append(MakePair("LocalTimeMaximum", cg["localsolartimeMaximum"][0]));
}
// Compute statistics for entire cube
if(ui.GetBoolean("STATISTICS")) {
statistics = new QList< QPair<QString, QString> >;
LineManager iline(*incube);
Statistics stats;
Progress progress;
progress.SetText("Statistics...");
progress.SetMaximumSteps(incube->lineCount()*incube->bandCount());
progress.CheckStatus();
iline.SetLine(1);
for(; !iline.end() ; iline.next()) {
incube->read(iline);
stats.AddData(iline.DoubleBuffer(), iline.size());
progress.CheckStatus();
}
// Compute stats of entire cube
double nPixels = stats.TotalPixels();
double nullpercent = (stats.NullPixels() / (nPixels)) * 100;
double hispercent = (stats.HisPixels() / (nPixels)) * 100;
double hrspercent = (stats.HrsPixels() / (nPixels)) * 100;
double lispercent = (stats.LisPixels() / (nPixels)) * 100;
double lrspercent = (stats.LrsPixels() / (nPixels)) * 100;
// Statitics output for band
statistics->append(MakePair("MeanValue", toString(stats.Average())));
statistics->append(MakePair("StandardDeviation", toString(stats.StandardDeviation())));
statistics->append(MakePair("MinimumValue", toString(stats.Minimum())));
statistics->append(MakePair("MaximumValue", toString(stats.Maximum())));
statistics->append(MakePair("PercentHIS", toString(hispercent)));
statistics->append(MakePair("PercentHRS", toString(hrspercent)));
statistics->append(MakePair("PercentLIS", toString(lispercent)));
statistics->append(MakePair("PercentLRS", toString(lrspercent)));
statistics->append(MakePair("PercentNull", toString(nullpercent)));
statistics->append(MakePair("TotalPixels", toString(stats.TotalPixels())));
}
bool getFootBlob = ui.GetBoolean("USELABEL");
bool doGeometry = ui.GetBoolean("GEOMETRY");
bool doPolygon = ui.GetBoolean("POLYGON");
if(doGeometry || doPolygon || getFootBlob) {
Camera *cam = incube->camera();
QString incType = ui.GetString("INCTYPE");
int polySinc, polyLinc;
if(doPolygon && incType.toUpper() == "VERTICES") {
ImagePolygon poly;
poly.initCube(*incube);
polySinc = polyLinc = (int)(0.5 + (((poly.validSampleDim() * 2) +
(poly.validLineDim() * 2) - 3.0) /
ui.GetInteger("NUMVERTICES")));
}
else if (incType.toUpper() == "LINCSINC"){
if(ui.WasEntered("POLYSINC")) {
polySinc = ui.GetInteger("POLYSINC");
}
else {
polySinc = (int)(0.5 + 0.10 * incube->sampleCount());
if(polySinc == 0) polySinc = 1;
}
if(ui.WasEntered("POLYLINC")) {
polyLinc = ui.GetInteger("POLYLINC");
}
else {
polyLinc = (int)(0.5 + 0.10 * incube->lineCount());
if(polyLinc == 0) polyLinc = 1;
}
}
else {
QString msg = "Invalid INCTYPE option[" + incType + "]";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
bandGeom = new BandGeometry();
bandGeom->setSampleInc(polySinc);
bandGeom->setLineInc(polyLinc);
bandGeom->setMaxIncidence(ui.GetDouble("MAXINCIDENCE"));
bandGeom->setMaxEmission(ui.GetDouble("MAXEMISSION"));
bool precision = ui.GetBoolean("INCREASEPRECISION");
if (getFootBlob) {
// Need to read history to obtain parameters that were used to
// create the footprint
History hist("IsisCube", in.expanded());
Pvl pvl = hist.ReturnHist();
PvlObject::PvlObjectIterator objIter;
bool found = false;
PvlGroup fpgrp;
for (objIter=pvl.endObject()-1; objIter>=pvl.beginObject(); objIter--) {
if (objIter->name().toUpper() == "FOOTPRINTINIT") {
found = true;
fpgrp = objIter->findGroup("UserParameters");
break;
}
}
if (!found) {
QString msg = "Footprint blob was not found in input image history";
throw IException(IException::User, msg, _FILEINFO_);
}
QString prec = (QString)fpgrp.findKeyword("INCREASEPRECISION");
prec = prec.toUpper();
if (prec == "TRUE") {
precision = true;
}
else {
precision = false;
}
QString inctype = (QString)fpgrp.findKeyword("INCTYPE");
inctype = inctype.toUpper();
if (inctype == "LINCSINC") {
int linc = fpgrp.findKeyword("LINC");
int sinc = fpgrp.findKeyword("SINC");
bandGeom->setSampleInc(sinc);
bandGeom->setLineInc(linc);
}
else {
int vertices = fpgrp.findKeyword("NUMVERTICES");
int lincsinc = (int)(0.5 + (((incube->sampleCount() * 2) +
(incube->lineCount() * 2) - 3.0) /
vertices));
bandGeom->setSampleInc(lincsinc);
bandGeom->setLineInc(lincsinc);
}
if (fpgrp.hasKeyword("MAXINCIDENCE")) {
double maxinc = fpgrp.findKeyword("MAXINCIDENCE");
bandGeom->setMaxIncidence(maxinc);
}
if (fpgrp.hasKeyword("MAXEMISSION")) {
double maxema = fpgrp.findKeyword("MAXEMISSION");
bandGeom->setMaxEmission(maxema);
}
}
bandGeom->collect(*cam, *incube, doGeometry, doPolygon, getFootBlob, precision);
// Check if the user requires valid image center geometry
if(ui.GetBoolean("VCAMERA") && (!bandGeom->hasCenterGeometry())) {
QString msg = "Image center does not project in camera model";
throw IException(IException::Unknown, msg, _FILEINFO_);
}
}
if(sFormat.toUpper() == "PVL")
GeneratePVLOutput(incube, general, camstats, statistics, bandGeom);
else
GenerateCSVOutput(incube, general, camstats, statistics, bandGeom);
// Clean the data
delete general;
general = NULL;
if(camstats) {
delete camstats;
camstats = NULL;
}
if(statistics) {
delete statistics;
statistics = NULL;
}
if(bandGeom) {
delete bandGeom;
bandGeom = NULL;
}
}