/**
* Loads the stretch pairs from the pvl file into the Stretch
* object. The pvl should look similar to this:
* @code
* Group = Pairs
* Input = (0,100,255)
* Output = (255,100,0)
* EndGroup
* @endcode
*
* @param pvl - The pvl containing the stretch pairs
* @param grpName - The group name to get the input and output
* keywords from
*/
void Stretch::Load(Isis::Pvl &pvl, QString &grpName) {
PvlGroup grp = pvl.findGroup(grpName, Isis::PvlObject::Traverse);
PvlKeyword inputs = grp.findKeyword("Input");
PvlKeyword outputs = grp.findKeyword("Output");
if(inputs.size() != outputs.size()) {
QString msg = "Invalid Pvl file: The number of Input values must equal the number of Output values";
throw IException(IException::User, msg, _FILEINFO_);
}
for(int i = 0; i < inputs.size(); i++) {
AddPair(toDouble(inputs[i]), toDouble(outputs[i]));
}
}
/**
* With the Channel, CCD in the isis label, find the coefficient values
* for this image
*
* @author Sharmila Prasad (11/24/2010)
*
* @param pCubeLabel
*/
void GetCCD_Channel_Coefficients(Pvl & pCubeLabel)
{
int iChannel=-1, iSumming=-1;
QString sCcd="";
PvlGroup instrGrp = pCubeLabel.findObject("IsisCube").findGroup("Instrument");
// Summing keyword
if (!instrGrp.hasKeyword("Summing")) {
QString sMsg = "Summing keyword not found";
throw IException(IException::User, sMsg, _FILEINFO_);
}
else {
PvlKeyword binKey = instrGrp.findKeyword("Summing");
iSumming = toInt(binKey[0]);
if (iSumming != 1 && iSumming != 2 && iSumming != 4) {
QString sMsg = "Invalid Summing value in input file, must be 1,2,or 4";
throw IException(IException::User, sMsg, _FILEINFO_);
}
}
// CCD Keyword
if (!instrGrp.hasKeyword("CcdId")) {
QString sMsg = "CcdId keyword not found";
throw IException(IException::User, sMsg, _FILEINFO_);
}
else {
PvlKeyword ccdKey = instrGrp.findKeyword("CcdId");
sCcd = ccdKey[0];
}
// Channel Keyword
if (!instrGrp.hasKeyword("ChannelNumber")) {
QString sMsg = "ChannelNumber keyword not found";
throw IException(IException::User, sMsg, _FILEINFO_);
}
else {
PvlKeyword channelKey = instrGrp.findKeyword("ChannelNumber");
iChannel = toInt(channelKey[0]);
}
// Get the coefficient file name
QString dCoeffFile = "$mro/calibration/HiRISE_Gain_Drift_Correction_Bin" + toString(iSumming) + ".0001.csv";
//QString dCoeffFile = "/home/sprasad/isis3/isis/src/mro/apps/hicalproc/HiRISE_Gain_Drift_Correction_Bin" + toString(iSumming) + ".0001.csv";
#ifdef _DEBUG_
cout << dCoeffFile << endl;
#endif
// Get the coefficients
ReadCoefficientFile(FileName(dCoeffFile).expanded(), sCcd, iChannel);
}
void IsisMain() {
// Create a process so we can output the noproj'd labels without overwriting
Process p;
// Open the user interface and get the input file and the ideal specs file
UserInterface &ui = Application::GetUserInterface();
Cube *mcube, *icube;
// If a MATCH cube is entered, make sure to SetInputCube it first to get the SPICE blobs
// from it propagated to the TO labels
// Until polygon blobs are detached without "/" don't propagate them
p.PropagatePolygons(false);
if((ui.WasEntered("MATCH"))) {
mcube = p.SetInputCube("MATCH");
icube = p.SetInputCube("FROM");
}
else {
mcube = icube = p.SetInputCube("FROM");
}
Camera *incam = mcube->camera();
// Extract Instrument groups from input labels for the output match and noproj'd cubes
PvlGroup inst = mcube->group("Instrument");
PvlGroup fromInst = icube->group("Instrument");
QString groupName = (QString) inst["SpacecraftName"] + "/";
groupName += (QString) inst.findKeyword("InstrumentId");
// Get Ideal camera specifications
FileName specs;
if((ui.WasEntered("SPECS"))) {
specs = ui.GetFileName("SPECS");
}
else {
specs = "$base/applications/noprojInstruments???.pvl";
specs = specs.highestVersion();
}
Pvl idealSpecs(specs.expanded());
PvlObject obSpecs = idealSpecs.findObject("IdealInstrumentsSpecifications");
PvlGroup idealGp = obSpecs.findGroup(groupName);
double transx, transy, transl, transs;
transx = transy = transl = transs = 0.;
if(idealGp.hasKeyword("TransX")) transx = idealGp["TransX"];
if(idealGp.hasKeyword("TransY")) transy = idealGp["TransY"];
if(idealGp.hasKeyword("ItransL")) transl = idealGp["ItransL"];
if(idealGp.hasKeyword("ItransS")) transs = idealGp["ItransS"];
int detectorSamples = mcube->sampleCount();
if(idealGp.hasKeyword("DetectorSamples")) detectorSamples = idealGp["DetectorSamples"];
int numberLines = mcube->lineCount();
int numberBands = mcube->bandCount();
if(idealGp.hasKeyword("DetectorLines")) numberLines = idealGp["DetectorLines"];
int xDepend = incam->FocalPlaneMap()->FocalPlaneXDependency();
// Get output summing mode
if(ui.GetString("SOURCE") == "FROMMATCH") {
LoadMatchSummingMode();
}
else if(ui.GetString("SOURCE") == "FROMINPUT") {
LoadInputSummingMode();
}
double pixPitch = incam->PixelPitch() * ui.GetDouble("SUMMINGMODE");
detectorSamples /= (int)(ui.GetDouble("SUMMINGMODE"));
// Get the user options
int sampleExpansion = int((ui.GetDouble("SAMPEXP") / 100.) * detectorSamples + .5);
int lineExpansion = int((ui.GetDouble("LINEEXP") / 100.) * numberLines + .5);
QString instType;
// Adjust translations for summing mode
transl /= ui.GetDouble("SUMMINGMODE");
transs /= ui.GetDouble("SUMMINGMODE");
detectorSamples += sampleExpansion;
numberLines += lineExpansion;
// Determine whether this ideal camera is a line scan or framing camera and
// set the instrument id and exposure
int detectorLines;
int expandFlag;
if(incam->DetectorMap()->LineRate() != 0.0) {
instType = "LINESCAN";
// Isis3 line rate is always in seconds so convert to milliseconds for the
// Ideal instrument
detectorLines = 1;
expandFlag = 1;
}
else {
instType = "FRAMING";
detectorLines = numberLines;
expandFlag = 0;
// Framing cameras don't need exposure time
}
// Adjust focal plane translations with line expansion for scanners since
// the CCD is only 1 line
if(expandFlag) {
transl += lineExpansion / 2;
if(xDepend == CameraFocalPlaneMap::Line) {
transx -= lineExpansion / 2.*pixPitch * expandFlag;
}
else {
transy -= lineExpansion / 2.*pixPitch * expandFlag;
}
}
// Get the start time for parent line 1
AlphaCube alpha(*icube);
double sample = alpha.BetaSample(.5);
double line = alpha.BetaLine(.5);
incam->SetImage(sample, line);
double et = incam->time().Et();
// Get the output file name and set its attributes
CubeAttributeOutput cao;
// Can we do a regular label? Didn't work on 12-15-2006
cao.setLabelAttachment(Isis::DetachedLabel);
// Determine the output image size from
// 1) the idealInstrument pvl if there or
// 2) the input size expanded by user specified percentage
Cube *ocube = p.SetOutputCube("match.cub", cao, 1, 1, 1);
// Extract the times and the target from the instrument group
QString startTime = inst["StartTime"];
QString stopTime;
if(inst.hasKeyword("StopTime")) stopTime = (QString) inst["StopTime"];
QString target = inst["TargetName"];
// rename the instrument groups
inst.setName("OriginalInstrument");
fromInst.setName("OriginalInstrument");
// add it back to the IsisCube object under a new group name
ocube->putGroup(inst);
// and remove the version from the IsisCube Object
ocube->deleteGroup("Instrument");
// Now rename the group back to the Instrument group and clear out old keywords
inst.setName("Instrument");
inst.clear();
// Add keywords for the "Ideal" instrument
Isis::PvlKeyword key("SpacecraftName", "IdealSpacecraft");
inst.addKeyword(key);
key.setName("InstrumentId");
key.setValue("IdealCamera");
inst.addKeyword(key);
key.setName("TargetName");
key.setValue(target);
inst.addKeyword(key);
key.setName("SampleDetectors");
key.setValue(Isis::toString(detectorSamples));
inst.addKeyword(key);
key.setName("LineDetectors");
key.setValue(Isis::toString(detectorLines));
inst.addKeyword(key);
key.setName("InstrumentType");
key.setValue(instType);
inst.addKeyword(key);
Pvl &ocubeLabel = *ocube->label();
PvlObject *naifKeywordsObject = NULL;
if (ocubeLabel.hasObject("NaifKeywords")) {
naifKeywordsObject = &ocubeLabel.findObject("NaifKeywords");
// Clean up the naif keywords object... delete everything that isn't a radii
for (int keyIndex = naifKeywordsObject->keywords() - 1; keyIndex >= 0; keyIndex--) {
QString keyName = (*naifKeywordsObject)[keyIndex].name();
if (!keyName.contains("RADII")) {
naifKeywordsObject->deleteKeyword(keyIndex);
}
}
// Clean up the kernels group... delete everything that isn't internalized or the orig frame
// code
PvlGroup &kernelsGroup = ocube->group("Kernels");
for (int keyIndex = kernelsGroup.keywords() - 1; keyIndex >= 0; keyIndex--) {
PvlKeyword &kernelsKeyword = kernelsGroup[keyIndex];
bool isTable = false;
bool isFrameCode = kernelsKeyword.isNamed("NaifFrameCode") ||
kernelsKeyword.isNamed("NaifIkCode");
bool isShapeModel = kernelsKeyword.isNamed("ShapeModel");
for (int keyValueIndex = 0; keyValueIndex < kernelsKeyword.size(); keyValueIndex++) {
if (kernelsKeyword[keyValueIndex] == "Table") {
isTable = true;
}
}
if (!isTable && !isFrameCode && !isShapeModel) {
kernelsGroup.deleteKeyword(keyIndex);
}
}
}
if (naifKeywordsObject) {
naifKeywordsObject->addKeyword(PvlKeyword("IDEAL_FOCAL_LENGTH", toString(incam->FocalLength())),
Pvl::Replace);
}
else {
inst.addKeyword(PvlKeyword("FocalLength", toString(incam->FocalLength()), "millimeters"));
}
double newPixelPitch = incam->PixelPitch() * ui.GetDouble("SUMMINGMODE");
if (naifKeywordsObject) {
naifKeywordsObject->addKeyword(PvlKeyword("IDEAL_PIXEL_PITCH", toString(newPixelPitch)),
Pvl::Replace);
}
else {
inst.addKeyword(PvlKeyword("PixelPitch", toString(newPixelPitch), "millimeters"));
}
key.setName("EphemerisTime");
key.setValue(Isis::toString(et), "seconds");
inst.addKeyword(key);
key.setName("StartTime");
key.setValue(startTime);
inst.addKeyword(key);
if(stopTime != "") {
key.setName("StopTime");
key.setValue(stopTime);
inst.addKeyword(key);
}
key.setName("FocalPlaneXDependency");
key.setValue(toString((int)incam->FocalPlaneMap()->FocalPlaneXDependency()));
inst.addKeyword(key);
int xDependency = incam->FocalPlaneMap()->FocalPlaneXDependency();
double newInstrumentTransX = incam->FocalPlaneMap()->SignMostSigX();
inst.addKeyword(PvlKeyword("TransX", toString(newInstrumentTransX)));
double newInstrumentTransY = incam->FocalPlaneMap()->SignMostSigY();
inst.addKeyword(PvlKeyword("TransY", toString(newInstrumentTransY)));
storeSpice(&inst, naifKeywordsObject, "TransX0", "IDEAL_TRANSX", transx,
newPixelPitch * newInstrumentTransX, (xDependency == CameraFocalPlaneMap::Sample));
storeSpice(&inst, naifKeywordsObject, "TransY0", "IDEAL_TRANSY", transy,
newPixelPitch * newInstrumentTransY, (xDependency == CameraFocalPlaneMap::Line));
double transSXCoefficient = 1.0 / newPixelPitch * newInstrumentTransX;
double transLXCoefficient = 1.0 / newPixelPitch * newInstrumentTransY;
if (xDependency == CameraFocalPlaneMap::Line) {
swap(transSXCoefficient, transLXCoefficient);
}
storeSpice(&inst, naifKeywordsObject, "TransS0", "IDEAL_TRANSS",
transs, transSXCoefficient, (xDependency == CameraFocalPlaneMap::Sample));
storeSpice(&inst, naifKeywordsObject, "TransL0", "IDEAL_TRANSL",
transl, transLXCoefficient, (xDependency == CameraFocalPlaneMap::Line));
if(instType == "LINESCAN") {
key.setName("ExposureDuration");
key.setValue(Isis::toString(incam->DetectorMap()->LineRate() * 1000.), "milliseconds");
inst.addKeyword(key);
}
key.setName("MatchedCube");
key.setValue(mcube->fileName());
inst.addKeyword(key);
ocube->putGroup(inst);
p.EndProcess();
// Now adjust the label to fake the true size of the image to match without
// taking all the space it would require for the image data
Pvl label;
label.read("match.lbl");
PvlGroup &dims = label.findGroup("Dimensions", Pvl::Traverse);
dims["Lines"] = toString(numberLines);
dims["Samples"] = toString(detectorSamples);
dims["Bands"] = toString(numberBands);
label.write("match.lbl");
// And run cam2cam to apply the transformation
QString parameters;
parameters += " FROM= " + ui.GetFileName("FROM");
parameters += " MATCH= " + QString("match.cub");
parameters += " TO= " + ui.GetFileName("TO");
parameters += " INTERP=" + ui.GetString("INTERP");
ProgramLauncher::RunIsisProgram("cam2cam", parameters);
// Cleanup by deleting the match files
remove("match.History.IsisCube");
remove("match.lbl");
remove("match.cub");
remove("match.OriginalLabel.IsisCube");
remove("match.Table.BodyRotation");
remove("match.Table.HiRISE Ancillary");
remove("match.Table.HiRISE Calibration Ancillary");
remove("match.Table.HiRISE Calibration Image");
remove("match.Table.InstrumentPointing");
remove("match.Table.InstrumentPosition");
remove("match.Table.SunPosition");
// Finally finish by adding the OriginalInstrument group to the TO cube
Cube toCube;
toCube.open(ui.GetFileName("TO"), "rw");
// Extract label and create cube object
Pvl *toLabel = toCube.label();
PvlObject &o = toLabel->findObject("IsisCube");
o.deleteGroup("OriginalInstrument");
o.addGroup(fromInst);
toCube.close();
}
void TranslateLabels(FileName in, Cube *ocube) {
// Get the directory where the Clementine translation tables are.
PvlGroup &dataDir = Preference::Preferences().findGroup("DataDirectory");
// Transfer the instrument group to the output cube
QString transDir = (QString) dataDir["clementine1"];
FileName transFile(transDir + "/translations/clementine.trn");
Pvl pdsLab(in.expanded());
PvlTranslationManager labelXlater(pdsLab, transFile.expanded());
// Pvl outputLabels;
Pvl *outputLabel = ocube->label();
labelXlater.Auto(*(outputLabel));
//Instrument group
PvlGroup inst = outputLabel->findGroup("Instrument", Pvl::Traverse);
PvlKeyword &startTime = inst.findKeyword("StartTime");
startTime.setValue(startTime[0].mid(0, startTime[0].size() - 1));
// Old PDS labels used keyword INSTRUMENT_COMPRESSION_TYPE & PDS Labels now use ENCODING_TYPE
if(pdsLab.findObject("Image").hasKeyword("InstrumentCompressionType")) {
inst += PvlKeyword("EncodingFormat", (QString) pdsLab.findObject("Image")["InstrumentCompressionType"]);
}
else {
inst += PvlKeyword("EncodingFormat", (QString) pdsLab.findObject("Image")["EncodingType"]);
}
if(((QString)inst["InstrumentId"]) == "HIRES") {
inst += PvlKeyword("MCPGainModeID", (QString)pdsLab["MCP_Gain_Mode_ID"], "");
}
ocube->putGroup(inst);
PvlGroup bBin = outputLabel->findGroup("BandBin", Pvl::Traverse);
QString filter = pdsLab["FilterName"];
if(filter != "F") {
//Band Bin group
double center = pdsLab["CenterFilterWavelength"];
center /= 1000.0;
bBin.findKeyword("Center").setValue(toString(center), "micrometers");
}
double width = pdsLab["Bandwidth"];
width /= 1000.0;
bBin.findKeyword("Width").setValue(toString(width), "micrometers");
ocube->putGroup(bBin);
//Kernel group
PvlGroup kern("Kernels");
if(((QString)inst["InstrumentId"]) == "HIRES") {
kern += PvlKeyword("NaifFrameCode", "-40001");
}
if(((QString)inst["InstrumentId"]) == "UVVIS") {
kern += PvlKeyword("NaifFrameCode", "-40002");
}
if(((QString)inst["InstrumentId"]) == "NIR") {
kern += PvlKeyword("NaifFrameCode", "-40003");
}
if(((QString)inst["InstrumentId"]) == "LWIR") {
kern += PvlKeyword("NaifFrameCode", "-40004");
}
ocube->putGroup(kern);
OriginalLabel org(pdsLab);
ocube->write(org);
}
// Populate cube label using filname and film code
// Code decrypted as specified in film decoder document (July 23, 1971 Revision)
// available at ASU Apollo Resources archive
void TranslateApolloLabels (IString filename, Cube *opack) {
//Instrument group
PvlGroup inst("Instrument");
PvlGroup kern("Kernels");
PvlGroup codeGroup("Code");
inst += PvlKeyword("SpacecraftName", apollo->SpacecraftName());
inst += PvlKeyword("InstrumentId", apollo->InstrumentId());
inst += PvlKeyword("TargetName", apollo->TargetName());
if ( !IsValidCode() ){
PvlGroup error("ERROR");
error.addComment("The decrypted code is invalid.");
for (int i=0; i<4; i++) {
PvlKeyword keyword("Column"+toString(i+1));
for (int j=0; j<32; j++) {
keyword += toString((int)code[i][j]);
}
error.addKeyword(keyword);
codeGroup += keyword;
}
Application::Log(error);
}
else {
codeGroup += PvlKeyword("StartTime", FrameTime());
codeGroup += PvlKeyword("SpacecraftAltitude", toString(Altitude()),"meters");
if (apollo->IsMetric()){
codeGroup += PvlKeyword("ExposureDuration", toString(ShutterInterval()), "milliseconds");
codeGroup += PvlKeyword("ForwardMotionCompensation", FMC());
}
for (int i=0; i<4; i++) {
PvlKeyword keyword("Column"+toString(i+1));
for (int j=0; j<32; j++) {
keyword += toString((int)code[i][j]);
}
codeGroup += keyword;
}
}
PvlGroup bandBin("BandBin");
// There are no filters on the camera, so the default is clear with id # of 1
// the BandBin group is only included to work with the spiceinit application
bandBin += PvlKeyword("FilterName", "CLEAR");
bandBin += PvlKeyword("FilterId", "1");
kern += PvlKeyword("NaifFrameCode", apollo->NaifFrameCode());
// Set up the nominal reseaus group
Isis::PvlGroup &dataDir = Isis::Preference::Preferences().findGroup("DataDirectory");
Process p;
PvlTranslationTable tTable(
(QString)p.MissionData("base", "translations/MissionName2DataDir.trn"));
QString missionDir = dataDir[tTable.Translate("MissionName", apollo->SpacecraftName())][0];
Pvl resTemplate(missionDir + "/reseaus/" + apollo->InstrumentId() + "_NOMINAL.pvl");
PvlGroup *reseaus = &resTemplate.findGroup("Reseaus");
// Update reseau locations based on refined code location
for (int i=0; i<(reseaus->findKeyword("Type")).size(); i++) {
double x = toDouble(reseaus->findKeyword("Sample")[i]) + sampleTranslation + 2278,
y = toDouble(reseaus->findKeyword("Line")[i]) + lineTranslation - 20231;
if (apollo->IsApollo17()) {
x += 50;
y += 20;
}
reseaus->findKeyword("Sample")[i] = toString(
cos(rotation)*(x-sampleTranslation) - sin(rotation)*(y-lineTranslation) + sampleTranslation);
reseaus->findKeyword("Line")[i] = toString(
sin(rotation)*(x-sampleTranslation) + cos(rotation)*(y-lineTranslation) + lineTranslation);
}
inst += PvlKeyword("StartTime", utcTime);
opack->putGroup(inst);
opack->putGroup(bandBin);
opack->putGroup(kern);
opack->putGroup(*reseaus);
opack->putGroup(codeGroup);
}
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;
}
}
/**
* GetPointInfo builds the PvlGroup containing all the important
* information derived from the Camera.
*
* @return PvlGroup* Data taken directly from the Camera and
* drived from Camera information. Ownership passed.
*/
PvlGroup *CameraPointInfo::GetPointInfo(bool passed, bool allowOutside, bool allowErrors) {
PvlGroup *gp = new PvlGroup("GroundPoint");
{
gp->addKeyword(PvlKeyword("Filename"));
gp->addKeyword(PvlKeyword("Sample"));
gp->addKeyword(PvlKeyword("Line"));
gp->addKeyword(PvlKeyword("PixelValue"));
gp->addKeyword(PvlKeyword("RightAscension"));
gp->addKeyword(PvlKeyword("Declination"));
gp->addKeyword(PvlKeyword("PlanetocentricLatitude"));
gp->addKeyword(PvlKeyword("PlanetographicLatitude"));
gp->addKeyword(PvlKeyword("PositiveEast360Longitude"));
gp->addKeyword(PvlKeyword("PositiveEast180Longitude"));
gp->addKeyword(PvlKeyword("PositiveWest360Longitude"));
gp->addKeyword(PvlKeyword("PositiveWest180Longitude"));
gp->addKeyword(PvlKeyword("BodyFixedCoordinate"));
gp->addKeyword(PvlKeyword("LocalRadius"));
gp->addKeyword(PvlKeyword("SampleResolution"));
gp->addKeyword(PvlKeyword("LineResolution"));
gp->addKeyword(PvlKeyword("SpacecraftPosition"));
gp->addKeyword(PvlKeyword("SpacecraftAzimuth"));
gp->addKeyword(PvlKeyword("SlantDistance"));
gp->addKeyword(PvlKeyword("TargetCenterDistance"));
gp->addKeyword(PvlKeyword("SubSpacecraftLatitude"));
gp->addKeyword(PvlKeyword("SubSpacecraftLongitude"));
gp->addKeyword(PvlKeyword("SpacecraftAltitude"));
gp->addKeyword(PvlKeyword("OffNadirAngle"));
gp->addKeyword(PvlKeyword("SubSpacecraftGroundAzimuth"));
gp->addKeyword(PvlKeyword("SunPosition"));
gp->addKeyword(PvlKeyword("SubSolarAzimuth"));
gp->addKeyword(PvlKeyword("SolarDistance"));
gp->addKeyword(PvlKeyword("SubSolarLatitude"));
gp->addKeyword(PvlKeyword("SubSolarLongitude"));
gp->addKeyword(PvlKeyword("SubSolarGroundAzimuth"));
gp->addKeyword(PvlKeyword("Phase"));
gp->addKeyword(PvlKeyword("Incidence"));
gp->addKeyword(PvlKeyword("Emission"));
gp->addKeyword(PvlKeyword("NorthAzimuth"));
gp->addKeyword(PvlKeyword("EphemerisTime"));
gp->addKeyword(PvlKeyword("UTC"));
gp->addKeyword(PvlKeyword("LocalSolarTime"));
gp->addKeyword(PvlKeyword("SolarLongitude"));
if (allowErrors) gp->addKeyword(PvlKeyword("Error"));
}
bool noErrors = passed;
QString error = "";
if (!m_camera->HasSurfaceIntersection()) {
error = "Requested position does not project in camera model; no surface intersection";
noErrors = false;
if (!allowErrors) throw IException(IException::Unknown, error, _FILEINFO_);
}
if (!m_camera->InCube() && !allowOutside) {
error = "Requested position does not project in camera model; not inside cube";
noErrors = false;
if (!allowErrors) throw IException(IException::Unknown, error, _FILEINFO_);
}
if (!noErrors) {
for (int i = 0; i < gp->keywords(); i++) {
QString name = (*gp)[i].name();
// These three keywords have 3 values, so they must have 3 N/As
if (name == "BodyFixedCoordinate" || name == "SpacecraftPosition" ||
name == "SunPosition") {
(*gp)[i].addValue("N/A");
(*gp)[i].addValue("N/A");
(*gp)[i].addValue("N/A");
}
else {
(*gp)[i].setValue("N/A");
}
}
// Set all keywords that still have valid information
gp->findKeyword("Error").setValue(error);
gp->findKeyword("FileName").setValue(m_currentCube->fileName());
gp->findKeyword("Sample").setValue(toString(m_camera->Sample()));
gp->findKeyword("Line").setValue(toString(m_camera->Line()));
gp->findKeyword("EphemerisTime").setValue(
toString(m_camera->time().Et()), "seconds");
gp->findKeyword("EphemerisTime").addComment("Time");
QString utc = m_camera->time().UTC();
gp->findKeyword("UTC").setValue(utc);
gp->findKeyword("SpacecraftPosition").addComment("Spacecraft Information");
gp->findKeyword("SunPosition").addComment("Sun Information");
gp->findKeyword("Phase").addComment("Illumination and Other");
}
else {
Brick b(3, 3, 1, m_currentCube->pixelType());
int intSamp = (int)(m_camera->Sample() + 0.5);
int intLine = (int)(m_camera->Line() + 0.5);
b.SetBasePosition(intSamp, intLine, 1);
m_currentCube->read(b);
double pB[3], spB[3], sB[3];
QString utc;
double ssplat, ssplon, sslat, sslon, pwlon, oglat;
{
gp->findKeyword("FileName").setValue(m_currentCube->fileName());
gp->findKeyword("Sample").setValue(toString(m_camera->Sample()));
gp->findKeyword("Line").setValue(toString(m_camera->Line()));
gp->findKeyword("PixelValue").setValue(PixelToString(b[0]));
gp->findKeyword("RightAscension").setValue(toString(
m_camera->RightAscension()));
gp->findKeyword("Declination").setValue(toString(
m_camera->Declination()));
gp->findKeyword("PlanetocentricLatitude").setValue(toString(
m_camera->UniversalLatitude()));
// Convert lat to planetographic
Distance radii[3];
m_camera->radii(radii);
oglat = TProjection::ToPlanetographic(m_camera->UniversalLatitude(),
radii[0].kilometers(),
radii[2].kilometers());
gp->findKeyword("PlanetographicLatitude").setValue(toString(oglat));
gp->findKeyword("PositiveEast360Longitude").setValue(toString(
m_camera->UniversalLongitude()));
//Convert lon to -180 - 180 range
gp->findKeyword("PositiveEast180Longitude").setValue(toString(
TProjection::To180Domain(m_camera->UniversalLongitude())));
//Convert lon to positive west
pwlon = TProjection::ToPositiveWest(
m_camera->UniversalLongitude(), 360);
gp->findKeyword("PositiveWest360Longitude").setValue(toString(pwlon));
//Convert pwlon to -180 - 180 range
gp->findKeyword("PositiveWest180Longitude").setValue(toString(
TProjection::To180Domain(pwlon)));
m_camera->Coordinate(pB);
gp->findKeyword("BodyFixedCoordinate").addValue(toString(pB[0]), "km");
gp->findKeyword("BodyFixedCoordinate").addValue(toString(pB[1]), "km");
gp->findKeyword("BodyFixedCoordinate").addValue(toString(pB[2]), "km");
gp->findKeyword("LocalRadius").setValue(toString(
m_camera->LocalRadius().meters()), "meters");
gp->findKeyword("SampleResolution").setValue(toString(
m_camera->SampleResolution()), "meters/pixel");
gp->findKeyword("LineResolution").setValue(toString(
m_camera->LineResolution()), "meters/pixel");
//body fixed
m_camera->instrumentPosition(spB);
gp->findKeyword("SpacecraftPosition").addValue(toString(spB[0]), "km");
gp->findKeyword("SpacecraftPosition").addValue(toString(spB[1]), "km");
gp->findKeyword("SpacecraftPosition").addValue(toString(spB[2]), "km");
gp->findKeyword("SpacecraftPosition").addComment("Spacecraft Information");
gp->findKeyword("SpacecraftAzimuth").setValue(toString(
m_camera->SpacecraftAzimuth()));
gp->findKeyword("SlantDistance").setValue(toString(
m_camera->SlantDistance()), "km");
gp->findKeyword("TargetCenterDistance").setValue(toString(
m_camera->targetCenterDistance()), "km");
m_camera->subSpacecraftPoint(ssplat, ssplon);
gp->findKeyword("SubSpacecraftLatitude").setValue(toString(ssplat));
gp->findKeyword("SubSpacecraftLongitude").setValue(toString(ssplon));
gp->findKeyword("SpacecraftAltitude").setValue(toString(
m_camera->SpacecraftAltitude()), "km");
gp->findKeyword("OffNadirAngle").setValue(toString(
m_camera->OffNadirAngle()));
double subspcgrdaz;
subspcgrdaz = m_camera->GroundAzimuth(m_camera->UniversalLatitude(),
m_camera->UniversalLongitude(),
ssplat, ssplon);
gp->findKeyword("SubSpacecraftGroundAzimuth").setValue(toString(subspcgrdaz));
m_camera->sunPosition(sB);
gp->findKeyword("SunPosition").addValue(toString(sB[0]), "km");
gp->findKeyword("SunPosition").addValue(toString(sB[1]), "km");
gp->findKeyword("SunPosition").addValue(toString(sB[2]), "km");
gp->findKeyword("SunPosition").addComment("Sun Information");
gp->findKeyword("SubSolarAzimuth").setValue(toString(m_camera->SunAzimuth()));
gp->findKeyword("SolarDistance").setValue(toString(
m_camera->SolarDistance()), "AU");
m_camera->subSolarPoint(sslat, sslon);
gp->findKeyword("SubSolarLatitude").setValue(toString(sslat));
gp->findKeyword("SubSolarLongitude").setValue(toString(sslon));
double subsolgrdaz;
subsolgrdaz = m_camera->GroundAzimuth(m_camera->UniversalLatitude(),
m_camera->UniversalLongitude(),
sslat, sslon);
gp->findKeyword("SubSolarGroundAzimuth").setValue(toString(subsolgrdaz));
gp->findKeyword("Phase").setValue(toString(m_camera->PhaseAngle()));
gp->findKeyword("Phase").addComment("Illumination and Other");
gp->findKeyword("Incidence").setValue(toString(
m_camera->IncidenceAngle()));
gp->findKeyword("Emission").setValue(toString(
m_camera->EmissionAngle()));
gp->findKeyword("NorthAzimuth").setValue(toString(
m_camera->NorthAzimuth()));
gp->findKeyword("EphemerisTime").setValue(toString(
m_camera->time().Et()), "seconds");
gp->findKeyword("EphemerisTime").addComment("Time");
utc = m_camera->time().UTC();
gp->findKeyword("UTC").setValue(utc);
gp->findKeyword("LocalSolarTime").setValue(toString(
m_camera->LocalSolarTime()), "hour");
gp->findKeyword("SolarLongitude").setValue(toString(
m_camera->solarLongitude().degrees()));
if (allowErrors) gp->findKeyword("Error").setValue("N/A");
}
}
return gp;
}
