//! Constructs a HiLab Object
HiLab::HiLab(Cube *cube){
PvlGroup group = cube->GetGroup("Instrument");
p_cpmmNumber = group["CpmmNumber"];
p_channel = group["ChannelNumber"];
if (group.HasKeyword("Summing")) {
p_bin = group["Summing"];
}
else {
std::string msg = "Cannot find required Summing keyword in label";
throw Isis::iException::Message(Isis::iException::Io,msg,_FILEINFO_);
}
if (group.HasKeyword("Tdi")) {
p_tdi = group["Tdi"];
}
else {
std::string msg = "Cannot find required Tdi keyword in label";
throw Isis::iException::Message(Isis::iException::Io,msg,_FILEINFO_);
}
}
void IsisMain() {
// We will be processing by brick
ProcessByBrick p;
Isis::Cube *amatrixCube=NULL;
Isis::Cube *bmatrixCube=NULL;
// Setup the user input for the input/output files and the option
UserInterface &ui = Application::GetUserInterface();
// Setup the input HiRise cube
Isis::Cube *icube = p.SetInputCube("FROM");
if (icube->Bands() != 1) {
std::string msg = "Only single-band HiRise cubes can be calibrated";
throw Isis::iException::Message(Isis::iException::Io,msg,_FILEINFO_);
}
//Get pertinent label information to determine which band of matrix cube to use
HiLab hilab(icube);
int ccd = hilab.getCcd();
int channel = hilab.getChannel();
if (channel != 0 && channel != 1) {
std::string msg = "Only unstitched cubes can be calibrated";
throw Isis::iException::Message(Isis::iException::Io,msg,_FILEINFO_);
}
int band = 1 + ccd*2 + channel;
string option = ui.GetString("OPTION");
// Set attributes (input band number) for the matrix cube(s);
CubeAttributeInput att("+" + iString(band));
// Determine the file specification to the matrix file(s) if defaulted
// and open
if (ui.WasEntered ("MATRIX") ) {
if (option == "GAIN") {
string matrixFile = ui.GetFilename("MATRIX");
amatrixCube = p.SetInputCube(matrixFile, att);
}
else if (option == "OFFSET") {
string matrixFile = ui.GetFilename("MATRIX");
bmatrixCube = p.SetInputCube(matrixFile, att);
}
else { //(option == "BOTH")
std::string
msg = "The BOTH option cannot be used if a MATRIX is entered";
throw Isis::iException::Message(Isis::iException::Io,msg,_FILEINFO_);
}
}
else {
int tdi = hilab.getTdi();
int bin = hilab.getBin();
if (option == "OFFSET" || option == "BOTH") {
std::string bmatrixFile = "$mro/calibration";
bmatrixFile += "/B_matrix_tdi";
bmatrixFile += iString(tdi) + "_bin" + iString(bin);
bmatrixCube = p.SetInputCube(bmatrixFile, att);
}
if (option == "GAIN" || option == "BOTH") {
std::string amatrixFile = "$mro/calibration";
amatrixFile += "/A_matrix_tdi";
amatrixFile += iString(tdi) + "_bin" + iString(bin);
amatrixCube = p.SetInputCube(amatrixFile, att);
}
}
// Open the output file and set processing parameters
Cube *ocube = p.SetOutputCube ("TO");
p.SetWrap (true);
p.SetBrickSize ( icube->Samples(), 1, 1);
// Add the radiometry group if it is not there yet. Otherwise
// read the current value of the keyword CalibrationParameters.
// Then delete the keyword and rewrite it after appending the
// new value to it. Do it this way to avoid multiple Calibration
// Parameter keywords.
PvlGroup calgrp;
PvlKeyword calKey;
if (ocube->HasGroup("Radiometry")) {
calgrp = ocube->GetGroup ("Radiometry");
if (calgrp.HasKeyword("CalibrationParameters")) {
calKey = calgrp.FindKeyword("CalibrationParameters");
calgrp.DeleteKeyword( "CalibrationParameters" );
}
else {
calKey.SetName ("CalibrationParameters");
}
}
else {
calgrp.SetName("Radiometry");
calKey.SetName ("CalibrationParameters");
}
string keyValue = option;
if (option == "GAIN") {
keyValue += ":" + amatrixCube->Filename();
}
else if (option == "OFFSET") {
keyValue += ":" + bmatrixCube->Filename();
}
else { // "BOTH"
keyValue += ":"+bmatrixCube->Filename()+":"+amatrixCube->Filename();
}
calKey += keyValue;
calgrp += calKey;
ocube->PutGroup(calgrp);
// Start the processing based on the option
if (option == "GAIN") {
p.StartProcess(mult);
}
else if (option == "OFFSET") {
p.StartProcess(sub);
}
else { //(option == "BOTH")
p.StartProcess(multSub);
}
// Cleanup
p.EndProcess();
}
// Main program
void IsisMain(){
// Create an object for exporting Isis data
ProcessExport p;
// Open the input cube
Cube *icube = p.SetInputCube("FROM");
// Conform to the Big-Endian format for FITS
if(IsLsb()) p.SetOutputEndian(Isis::Msb);
// Generate the name of the fits file and open it
UserInterface &ui = Application::GetUserInterface();
// specify the bits per pixel
string bitpix;
if (ui.GetString ("BITTYPE") == "8BIT") bitpix = "8";
else if (ui.GetString ("BITTYPE") == "16BIT") bitpix = "16";
else if (ui.GetString ("BITTYPE") == "32BIT") bitpix = "-32";
else {
string msg = "Pixel type of [" + ui.GetString("BITTYPE") + "] is unsupported";
throw iException::Message(iException::User, msg, _FILEINFO_);
}
// Determine bit size and calculate number of bytes to write
// for each line.
if (bitpix == "8") p.SetOutputType(Isis::UnsignedByte);
if (bitpix == "16") p.SetOutputType(Isis::SignedWord);
if (bitpix == "-32") p.SetOutputType(Isis::Real);
// determine core base and multiplier, set up the stretch
PvlGroup pix = icube->Label()->FindObject("IsisCube").FindObject("Core").FindGroup("Pixels");
double scale = pix["Multiplier"][0].ToDouble();
double base = pix["Base"][0].ToDouble();
if (ui.GetString("STRETCH") != "NONE" && bitpix != "-32") {
if (ui.GetString("STRETCH") == "LINEAR") {
p.SetInputRange();
}
else if (ui.GetString("STRETCH") == "MANUAL") {
p.SetInputRange(ui.GetDouble("MINIMUM"), ui.GetDouble("MAXIMUM"));
}
// create a proper scale so pixels look like 32bit data.
scale = ((p.GetInputMaximum() - p.GetInputMinimum()) *
(p.GetOutputMaximum() - p.GetOutputMinimum()));
// round off after 14 decimals to avoid system architecture differences
scale = ((floor(scale * 1e14)) / 1e14);
// create a proper zero point so pixels look like 32bit data.
base = -1.0 * (scale * p.GetOutputMinimum()) + p.GetInputMinimum();
// round off after 14 decimals to avoid system architecture differences
base = ((floor(base * 1e14)) / 1e14);
}
//////////////////////////////////////////
// Write the minimal fits header //
//////////////////////////////////////////
string header;
// specify that this file conforms to simple fits standard
header += FitsKeyword("SIMPLE", true, "T");
// specify the bits per pixel
header += FitsKeyword("BITPIX", true, bitpix);
// specify the number of data axes (2: samples by lines)
int axes = 2;
if (icube->Bands() > 1) {
axes = 3;
}
header += FitsKeyword("NAXIS", true, iString(axes));
// specify the limit on data axis 1 (number of samples)
header += FitsKeyword("NAXIS1", true, iString(icube->Samples()));
// specify the limit on data axis 2 (number of lines)
header += FitsKeyword("NAXIS2", true, iString(icube->Lines()));
if (axes == 3){
header += FitsKeyword("NAXIS3", true, iString(icube->Bands()));
}
header += FitsKeyword("BZERO", true, base);
header += FitsKeyword("BSCALE", true, scale);
// Sky and All cases
if (ui.GetString("INFO") == "SKY" || ui.GetString("INFO") == "ALL") {
iString msg = "cube has not been skymapped";
PvlGroup map;
if (icube->HasGroup("mapping")) {
map = icube->GetGroup("mapping");
msg = (string)map["targetname"];
}
// If we have sky we want it
if (msg == "Sky") {
double midRa = 0, midDec = 0;
midRa = ((double)map["MaximumLongitude"] +
(double)map["MinimumLongitude"])/2;
midDec = ((double)map["MaximumLatitude"] +
(double)map["MinimumLatitude"])/2;
header += FitsKeyword("OBJCTRA", true, iString(midRa));
// Specify the Declination
header += FitsKeyword("OBJCTDEC", true, iString(midDec));
}
if (ui.GetString("INFO") == "ALL") {
header += WritePvl("INSTRUME","Instrument","InstrumentId", icube, true);
header += WritePvl("OBSERVER","Instrument","SpacecraftName", icube, true);
header += WritePvl("OBJECT ","Instrument","TargetName", icube, true);
// StartTime is sometimes middle of the exposure and somtimes beginning,
// so StopTime can't be calculated off of exposure reliably.
header += WritePvl("DATE-OBS","Instrument","StartTime", icube, true);
// Some cameras don't have StopTime
if (icube->HasGroup("Instrument")) {
PvlGroup inst = icube->GetGroup("Instrument");
if (inst.HasKeyword("StopTime")) {
header += WritePvl("TIME_END","Instrument","StopTime", icube, true);
}
if (inst.HasKeyword("ExposureDuration")) {
header += WritePvl("EXPTIME","Instrument","ExposureDuration", icube, false);
}
}
}
// If we were set on SKY and Sky doesn't exist
else if (msg != "Sky") {
throw iException::Message(iException::User,msg,_FILEINFO_);
}
}
// signal the end of the header
header += FitsKeyword("END", false, "");
// fill the rest of the fits header with space so to conform with the fits header
// size of 2880 bytes
for (int i = header.length() % 2880 ; i < 2880 ; i++) header += " ";
// open the cube for writing
string to = ui.GetFilename("TO","fits");
ofstream fout;
fout.open (to.c_str (), ios::out|ios::binary);
if (!fout.is_open ()) {
string msg = "Cannot open fits output file";
throw iException::Message(iException::Programmer,msg,_FILEINFO_);
}
fout.seekp(0);
fout.write(header.c_str(),header.length());
// write the raw cube data
p.StartProcess (fout);
// Finish off data area to a number n % 2880 == 0 is true
// 2880 is the size of the data blocks
int count = 2880 - (fout.tellp() % 2880);
for (int i = 0; i < count; i++) {
// Write nul characters as needed. ascii 0, hex 00...
fout.write("\0", 1);
}
fout.close();
p.EndProcess();
}
bool TryKernels(Cube *icube, Process &p,
Kernel lk, Kernel pck,
Kernel targetSpk, Kernel ck,
Kernel fk, Kernel ik, Kernel sclk,
Kernel spk, Kernel iak,
Kernel dem, Kernel exk) {
Pvl lab = *icube->Label();
// Add the new kernel files to the existing kernels group
PvlKeyword lkKeyword("LeapSecond");
PvlKeyword pckKeyword("TargetAttitudeShape");
PvlKeyword targetSpkKeyword("TargetPosition");
PvlKeyword ckKeyword("InstrumentPointing");
PvlKeyword ikKeyword("Instrument");
PvlKeyword sclkKeyword("SpacecraftClock");
PvlKeyword spkKeyword("InstrumentPosition");
PvlKeyword iakKeyword("InstrumentAddendum");
PvlKeyword demKeyword("ShapeModel");
PvlKeyword exkKeyword("Extra");
for (int i=0; i<lk.size(); i++) {
lkKeyword.AddValue(lk[i]);
}
for (int i=0; i<pck.size(); i++) {
pckKeyword.AddValue(pck[i]);
}
for (int i=0; i<targetSpk.size(); i++) {
targetSpkKeyword.AddValue(targetSpk[i]);
}
for (int i=0; i<ck.size(); i++) {
ckKeyword.AddValue(ck[i]);
}
for (int i=0; i<ik.size(); i++) {
ikKeyword.AddValue(ik[i]);
}
for (int i=0; i<sclk.size(); i++) {
sclkKeyword.AddValue(sclk[i]);
}
for (int i=0; i<spk.size(); i++) {
spkKeyword.AddValue(spk[i]);
}
for (int i=0; i<iak.size(); i++) {
iakKeyword.AddValue(iak[i]);
}
for (int i=0; i<dem.size(); i++) {
demKeyword.AddValue(dem[i]);
}
for (int i=0; i<exk.size(); i++) {
exkKeyword.AddValue(exk[i]);
}
PvlGroup originalKernels = icube->GetGroup("Kernels");
PvlGroup currentKernels = originalKernels;
currentKernels.AddKeyword(lkKeyword, Pvl::Replace);
currentKernels.AddKeyword(pckKeyword, Pvl::Replace);
currentKernels.AddKeyword(targetSpkKeyword, Pvl::Replace);
currentKernels.AddKeyword(ckKeyword, Pvl::Replace);
currentKernels.AddKeyword(ikKeyword, Pvl::Replace);
currentKernels.AddKeyword(sclkKeyword, Pvl::Replace);
currentKernels.AddKeyword(spkKeyword, Pvl::Replace);
currentKernels.AddKeyword(iakKeyword, Pvl::Replace);
currentKernels.AddKeyword(demKeyword, Pvl::Replace);
// report qualities
PvlKeyword spkQuality("InstrumentPositionQuality");
spkQuality.AddValue(spiceInit::kernelTypeEnum(spk.kernelType));
currentKernels.AddKeyword(spkQuality, Pvl::Replace);
PvlKeyword ckQuality("InstrumentPointingQuality");
ckQuality.AddValue(spiceInit::kernelTypeEnum(ck.kernelType));
currentKernels.AddKeyword(ckQuality, Pvl::Replace);
if (!exkKeyword.IsNull()) {
currentKernels.AddKeyword(exkKeyword, Pvl::Replace);
}
else if( currentKernels.HasKeyword("EXTRA") ) {
currentKernels.DeleteKeyword( "EXTRA" );
}
// Get rid of old keywords from previously inited cubes
if (currentKernels.HasKeyword("SpacecraftPointing")) {
currentKernels.DeleteKeyword("SpacecraftPointing");
}
if (currentKernels.HasKeyword("SpacecraftPosition")) {
currentKernels.DeleteKeyword("SpacecraftPosition");
}
if (currentKernels.HasKeyword("ElevationModel")) {
currentKernels.DeleteKeyword("ElevationModel");
}
if (currentKernels.HasKeyword("Frame")) {
currentKernels.DeleteKeyword("Frame");
}
if (currentKernels.HasKeyword("StartPadding")) {
currentKernels.DeleteKeyword("StartPadding");
}
if (currentKernels.HasKeyword("EndPadding")) {
currentKernels.DeleteKeyword("EndPadding");
}
UserInterface &ui = Application::GetUserInterface();
// Add any time padding the user specified to the spice group
if(ui.GetDouble("STARTPAD") > DBL_EPSILON) {
currentKernels.AddKeyword(PvlKeyword("StartPadding", ui.GetDouble("STARTPAD"), "seconds"));
}
if(ui.GetDouble("ENDPAD") > DBL_EPSILON) {
currentKernels.AddKeyword(PvlKeyword("EndPadding", ui.GetDouble("ENDPAD"), "seconds"));
}
currentKernels.AddKeyword(PvlKeyword("CameraVersion",CameraFactory::CameraVersion(lab)), Pvl::Replace);
// Add the modified Kernels group to the input cube labels
icube->PutGroup(currentKernels);
// Create the camera so we can get blobs if necessary
try {
Camera *cam;
try {
cam = icube->Camera();
Application::Log(currentKernels);
} catch (iException &e) {
Pvl errPvl = e.PvlErrors();
if(errPvl.Groups() > 0) {
currentKernels += PvlKeyword("Error", errPvl.Group(errPvl.Groups()-1)["Message"][0]);
}
Application::Log(currentKernels);
icube->PutGroup(originalKernels);
throw e;
}
if (ui.GetBoolean("ATTACH")) {
Table ckTable = cam->InstrumentRotation()->Cache("InstrumentPointing");
ckTable.Label() += PvlKeyword("Description", "Created by spiceinit");
ckTable.Label() += PvlKeyword("Kernels");
for (int i=0; i<ckKeyword.Size(); i++) {
ckTable.Label()["Kernels"].AddValue(ckKeyword[i]);
}
icube->Write(ckTable);
Table spkTable = cam->InstrumentPosition()->Cache("InstrumentPosition");
spkTable.Label() += PvlKeyword("Description", "Created by spiceinit");
spkTable.Label() += PvlKeyword("Kernels");
for (int i=0; i<spkKeyword.Size(); i++) {
spkTable.Label()["Kernels"].AddValue(spkKeyword[i]);
}
icube->Write(spkTable);
Table bodyTable = cam->BodyRotation()->Cache("BodyRotation");
bodyTable.Label() += PvlKeyword("Description", "Created by spiceinit");
bodyTable.Label() += PvlKeyword("Kernels");
for (int i=0; i<targetSpkKeyword.Size(); i++) {
bodyTable.Label()["Kernels"].AddValue(targetSpkKeyword[i]);
}
for (int i=0; i<pckKeyword.Size(); i++) {
bodyTable.Label()["Kernels"].AddValue(pckKeyword[i]);
}
bodyTable.Label() += PvlKeyword("SolarLongitude", cam->SolarLongitude());
icube->Write(bodyTable);
Table sunTable = cam->SunPosition()->Cache("SunPosition");
sunTable.Label() += PvlKeyword("Description", "Created by spiceinit");
sunTable.Label() += PvlKeyword("Kernels");
for (int i=0; i<targetSpkKeyword.Size(); i++) {
sunTable.Label()["Kernels"].AddValue(targetSpkKeyword[i]);
}
icube->Write(sunTable);
// Save original kernels in keyword before changing to Table
PvlKeyword origCk = currentKernels["InstrumentPointing"];
PvlKeyword origSpk = currentKernels["InstrumentPosition"];
PvlKeyword origTargPos = currentKernels["TargetPosition"];
currentKernels["InstrumentPointing"] = "Table";
for (int i=0; i<origCk.Size(); i++) {
currentKernels["InstrumentPointing"].AddValue(origCk[i]);
}
currentKernels["InstrumentPosition"] = "Table";
for (int i=0; i<origSpk.Size(); i++) {
currentKernels["InstrumentPosition"].AddValue(origSpk[i]);
}
currentKernels["TargetPosition"] = "Table";
for (int i=0; i<origTargPos.Size(); i++) {
currentKernels["TargetPosition"].AddValue(origTargPos[i]);
}
icube->PutGroup(currentKernels);
}
//modify Kernels group only
else {
Pvl *label = icube->Label();
int i=0;
while (i < label->Objects()) {
PvlObject currObj = label->Object(i);
if (currObj.IsNamed("Table")) {
if (currObj["Name"][0] == iString("InstrumentPointing")) {
label->DeleteObject(i);
} else if (currObj["Name"][0] == iString("InstrumentPosition")) {
label->DeleteObject(i);
} else if (currObj["Name"][0] == iString("BodyRotation")) {
label->DeleteObject(i);
} else if (currObj["Name"][0] == iString("SunPosition")) {
label->DeleteObject(i);
} else {
i++;
}
} else {
i++;
}
}
}
p.WriteHistory(*icube);
} catch (iException &e) {
e.Clear();
icube->PutGroup(originalKernels);
return false;
}
return true;
}
void IsisMain() {
// We will be warping a cube
ProcessRubberSheet p;
// Get the map projection file provided by the user
UserInterface &ui = Application::GetUserInterface();
Pvl userPvl(ui.GetFilename("MAP"));
PvlGroup &userMappingGrp = userPvl.FindGroup("Mapping",Pvl::Traverse);
// Open the input cube and get the projection
Cube *icube = p.SetInputCube ("FROM");
// Get the mapping group
PvlGroup fromMappingGrp = icube->GetGroup("Mapping");
Projection *inproj = icube->Projection();
PvlGroup outMappingGrp = fromMappingGrp;
// If the default range is FROM, then wipe out any range data in user mapping file
if(ui.GetString("DEFAULTRANGE").compare("FROM") == 0 && !ui.GetBoolean("MATCHMAP")) {
if(userMappingGrp.HasKeyword("MinimumLatitude")) {
userMappingGrp.DeleteKeyword("MinimumLatitude");
}
if(userMappingGrp.HasKeyword("MaximumLatitude")) {
userMappingGrp.DeleteKeyword("MaximumLatitude");
}
if(userMappingGrp.HasKeyword("MinimumLongitude")) {
userMappingGrp.DeleteKeyword("MinimumLongitude");
}
if(userMappingGrp.HasKeyword("MaximumLongitude")) {
userMappingGrp.DeleteKeyword("MaximumLongitude");
}
}
// Deal with user overrides entered in the GUI. Do this by changing the user's mapping group, which
// will then overlay anything in the output mapping group.
if(ui.WasEntered("MINLAT") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.AddKeyword( PvlKeyword("MinimumLatitude", ui.GetDouble("MINLAT")), Pvl::Replace );
}
if(ui.WasEntered("MAXLAT") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.AddKeyword( PvlKeyword("MaximumLatitude", ui.GetDouble("MAXLAT")), Pvl::Replace );
}
if(ui.WasEntered("MINLON") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.AddKeyword( PvlKeyword("MinimumLongitude", ui.GetDouble("MINLON")), Pvl::Replace );
}
if(ui.WasEntered("MAXLON") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.AddKeyword( PvlKeyword("MaximumLongitude", ui.GetDouble("MAXLON")), Pvl::Replace );
}
/**
* If the user is changing from positive east to positive west, or vice-versa, the output minimum is really
* the input maximum. However, the user mapping group must be left unaffected (an input minimum must be the
* output minimum). To accomplish this, we swap the minimums/maximums in the output group ahead of time. This
* causes the minimums and maximums to correlate to the output minimums and maximums. That way when we copy
* the user mapping group into the output group a mimimum overrides a minimum and a maximum overrides a maximum.
*/
bool sameDirection = true;
if(userMappingGrp.HasKeyword("LongitudeDirection")) {
if(((string)userMappingGrp["LongitudeDirection"]).compare(fromMappingGrp["LongitudeDirection"]) != 0) {
sameDirection = false;
}
}
// Since the out mapping group came from the from mapping group, which came from a valid cube,
// we can assume both min/max lon exists if min longitude exists.
if(!sameDirection && outMappingGrp.HasKeyword("MinimumLongitude")) {
double minLon = outMappingGrp["MinimumLongitude"];
double maxLon = outMappingGrp["MaximumLongitude"];
outMappingGrp["MaximumLongitude"] = minLon;
outMappingGrp["MinimumLongitude"] = maxLon;
}
if(ui.GetString("PIXRES").compare("FROM") == 0 && !ui.GetBoolean("MATCHMAP")) {
// Resolution will be in fromMappingGrp and outMappingGrp at this time
// delete from user mapping grp
if(userMappingGrp.HasKeyword("Scale")) {
userMappingGrp.DeleteKeyword("Scale");
}
if(userMappingGrp.HasKeyword("PixelResolution")) {
userMappingGrp.DeleteKeyword("PixelResolution");
}
}
else if(ui.GetString("PIXRES").compare("MAP") == 0 || ui.GetBoolean("MATCHMAP")) {
// Resolution will be in userMappingGrp - delete all others
if(outMappingGrp.HasKeyword("Scale")) {
outMappingGrp.DeleteKeyword("Scale");
}
if(outMappingGrp.HasKeyword("PixelResolution")) {
outMappingGrp.DeleteKeyword("PixelResolution");
}
if(fromMappingGrp.HasKeyword("Scale")); {
fromMappingGrp.DeleteKeyword("Scale");
}
if(fromMappingGrp.HasKeyword("PixelResolution")) {
fromMappingGrp.DeleteKeyword("PixelResolution");
}
}
else if(ui.GetString("PIXRES").compare("MPP") == 0) {
// Resolution specified - delete all and add to outMappingGrp
if(outMappingGrp.HasKeyword("Scale")) {
outMappingGrp.DeleteKeyword("Scale");
}
if(outMappingGrp.HasKeyword("PixelResolution")) {
outMappingGrp.DeleteKeyword("PixelResolution");
}
if(fromMappingGrp.HasKeyword("Scale")) {
fromMappingGrp.DeleteKeyword("Scale");
}
if(fromMappingGrp.HasKeyword("PixelResolution")) {
fromMappingGrp.DeleteKeyword("PixelResolution");
}
if(userMappingGrp.HasKeyword("Scale")) {
userMappingGrp.DeleteKeyword("Scale");
}
if(userMappingGrp.HasKeyword("PixelResolution")) {
userMappingGrp.DeleteKeyword("PixelResolution");
}
outMappingGrp.AddKeyword(PvlKeyword("PixelResolution", ui.GetDouble("RESOLUTION"), "meters/pixel"), Pvl::Replace);
}
else if(ui.GetString("PIXRES").compare("PPD") == 0) {
// Resolution specified - delete all and add to outMappingGrp
if(outMappingGrp.HasKeyword("Scale")) {
outMappingGrp.DeleteKeyword("Scale");
}
if(outMappingGrp.HasKeyword("PixelResolution")) {
outMappingGrp.DeleteKeyword("PixelResolution");
}
if(fromMappingGrp.HasKeyword("Scale")) {
fromMappingGrp.DeleteKeyword("Scale");
}
if(fromMappingGrp.HasKeyword("PixelResolution")) {
fromMappingGrp.DeleteKeyword("PixelResolution");
}
if(userMappingGrp.HasKeyword("Scale")) {
userMappingGrp.DeleteKeyword("Scale");
}
if(userMappingGrp.HasKeyword("PixelResolution")) {
userMappingGrp.DeleteKeyword("PixelResolution");
}
outMappingGrp.AddKeyword(PvlKeyword("Scale", ui.GetDouble("RESOLUTION"), "pixels/degree"), Pvl::Replace);
}
// Rotation will NOT Propagate
if(outMappingGrp.HasKeyword("Rotation")) {
outMappingGrp.DeleteKeyword("Rotation");
}
/**
* The user specified map template file overrides what ever is in the
* cube's mapping group.
*/
for(int keyword = 0; keyword < userMappingGrp.Keywords(); keyword ++) {
outMappingGrp.AddKeyword(userMappingGrp[keyword], Pvl::Replace);
}
/**
* Now, we have to deal with unit conversions. We convert only if the following are true:
* 1) We used values from the input cube
* 2) The values are longitudes or latitudes
* 3) The map file or user-specified information uses a different measurement system than
* the input cube for said values.
*
* The data is corrected for:
* 1) Positive east/positive west
* 2) Longitude domain
* 3) planetographic/planetocentric.
*/
// First, the longitude direction
if(!sameDirection) {
PvlGroup longitudes = inproj->MappingLongitudes();
for(int index = 0; index < longitudes.Keywords(); index ++) {
if(!userMappingGrp.HasKeyword(longitudes[index].Name())) {
// use the from domain because that's where our values are coming from
if(((string)userMappingGrp["LongitudeDirection"]).compare("PositiveEast") == 0) {
outMappingGrp[longitudes[index].Name()] =
Projection::ToPositiveEast(outMappingGrp[longitudes[index].Name()], outMappingGrp["LongitudeDomain"]);
}
else {
outMappingGrp[longitudes[index].Name()] =
Projection::ToPositiveWest(outMappingGrp[longitudes[index].Name()], outMappingGrp["LongitudeDomain"]);
}
}
}
}
// The minimum/maximum longitudes should be in order now. However, if the user entered a
// maximum that was lower than the minimum, or a minimum that was higher than the maximum this
// may still fail. Let it throw an error when we instantiate the projection.
// Second, longitude domain
if(userMappingGrp.HasKeyword("LongitudeDomain")) { // user set a new domain?
if((int)userMappingGrp["LongitudeDomain"] != (int)fromMappingGrp["LongitudeDomain"]) { // new domain different?
PvlGroup longitudes = inproj->MappingLongitudes();
for(int index = 0; index < longitudes.Keywords(); index ++) {
if(!userMappingGrp.HasKeyword(longitudes[index].Name())) {
if((int)userMappingGrp["LongitudeDomain"] == 180) {
outMappingGrp[longitudes[index].Name()] = Projection::To180Domain(outMappingGrp[longitudes[index].Name()]);
}
else {
outMappingGrp[longitudes[index].Name()] = Projection::To360Domain(outMappingGrp[longitudes[index].Name()]);
}
}
}
}
}
// Third, planetographic/planetocentric
if(userMappingGrp.HasKeyword("LatitudeType")) { // user set a new domain?
if(((string)userMappingGrp["LatitudeType"]).compare(fromMappingGrp["LatitudeType"]) != 0) { // new lat type different?
PvlGroup latitudes = inproj->MappingLatitudes();
for(int index = 0; index < latitudes.Keywords(); index ++) {
if(!userMappingGrp.HasKeyword(latitudes[index].Name())) {
if(((string)userMappingGrp["LatitudeType"]).compare("Planetographic") == 0) {
outMappingGrp[latitudes[index].Name()] = Projection::ToPlanetographic(
(double)fromMappingGrp[latitudes[index].Name()],
(double)fromMappingGrp["EquatorialRadius"],
(double)fromMappingGrp["PolarRadius"]);
}
else {
outMappingGrp[latitudes[index].Name()] = Projection::ToPlanetocentric(
(double)fromMappingGrp[latitudes[index].Name()],
(double)fromMappingGrp["EquatorialRadius"],
(double)fromMappingGrp["PolarRadius"]);
}
}
}
}
}
// If MinLon/MaxLon out of order, we weren't able to calculate the correct values
if((double)outMappingGrp["MinimumLongitude"] >= (double)outMappingGrp["MaximumLongitude"]) {
if(!ui.WasEntered("MINLON") || !ui.WasEntered("MAXLON")) {
string msg = "Unable to determine the correct [MinimumLongitude,MaximumLongitude].";
msg += " Please specify these values in the [MINLON,MAXLON] parameters";
throw iException::Message(iException::Pvl,msg,_FILEINFO_);
}
}
int samples,lines;
Pvl mapData;
// Copy to preserve cube labels so we can match cube size
if (userPvl.HasObject("IsisCube")) {
mapData = userPvl;
mapData.FindObject("IsisCube").DeleteGroup("Mapping");
mapData.FindObject("IsisCube").AddGroup(outMappingGrp);
}
else {
mapData.AddGroup(outMappingGrp);
}
// *NOTE: The UpperLeftX,UpperLeftY keywords will not be used in the CreateForCube
// method, and they will instead be recalculated. This is correct.
Projection *outproj = ProjectionFactory::CreateForCube(mapData,samples,lines,
ui.GetBoolean("MATCHMAP"));
// Set up the transform object which will simply map
// output line/samps -> output lat/lons -> input line/samps
Transform *transform = new map2map (icube->Samples(),
icube->Lines(),
icube->Projection(),
samples,
lines,
outproj,
ui.GetBoolean("TRIM"));
// Allocate the output cube and add the mapping labels
Cube *ocube = p.SetOutputCube ("TO", transform->OutputSamples(),
transform->OutputLines(),
icube->Bands());
PvlGroup cleanOutGrp = outproj->Mapping();
// ProjectionFactory::CreateForCube updated mapData to have the correct
// upperleftcornerx, upperleftcornery, scale and resolution. Use these
// updated numbers.
cleanOutGrp.AddKeyword(mapData.FindGroup("Mapping",Pvl::Traverse)["UpperLeftCornerX"], Pvl::Replace);
cleanOutGrp.AddKeyword(mapData.FindGroup("Mapping",Pvl::Traverse)["UpperLeftCornerY"], Pvl::Replace);
cleanOutGrp.AddKeyword(mapData.FindGroup("Mapping",Pvl::Traverse)["Scale"], Pvl::Replace);
cleanOutGrp.AddKeyword(mapData.FindGroup("Mapping",Pvl::Traverse)["PixelResolution"], Pvl::Replace);
ocube->PutGroup(cleanOutGrp);
// Set up the interpolator
Interpolator *interp;
if (ui.GetString("INTERP") == "NEARESTNEIGHBOR") {
interp = new Interpolator(Interpolator::NearestNeighborType);
}
else if (ui.GetString("INTERP") == "BILINEAR") {
interp = new Interpolator(Interpolator::BiLinearType);
}
else if (ui.GetString("INTERP") == "CUBICCONVOLUTION") {
interp = new Interpolator(Interpolator::CubicConvolutionType);
}
else {
string msg = "Unknow value for INTERP [" + ui.GetString("INTERP") + "]";
throw iException::Message(iException::Programmer,msg,_FILEINFO_);
}
// Warp the cube
p.StartProcess(*transform, *interp);
p.EndProcess();
Application::Log(cleanOutGrp);
// Cleanup
delete transform;
delete interp;
}
void IsisMain() {
// Get the list of cubes to mosaic
UserInterface &ui = Application::GetUserInterface();
FileList flist(ui.GetFilename("FROMLIST"));
vector<Cube *> clist;
try {
if (flist.size() < 1) {
string msg = "the list file [" +ui.GetFilename("FROMLIST") +
"does not contain any data";
throw iException::Message(iException::User,msg,_FILEINFO_);
}
// open all the cube and place in vector clist
for (int i=0; i<(int)flist.size(); i++) {
Cube *c = new Cube();
clist.push_back(c);
c->Open(flist[i]);
}
// run the compair function here. This will conpair the
// labels of the first cube to the labels of each following cube.
PvlKeyword sourceProductId("SourceProductId");
string ProdId;
for (int i=0; i<(int)clist.size(); i++) {
Pvl *pmatch = clist[0]->Label();
Pvl *pcomp = clist[i]->Label();
CompareLabels(*pmatch, *pcomp);
PvlGroup g = pcomp->FindGroup("Instrument",Pvl::Traverse);
if (g.HasKeyword("StitchedProductIds")) {
PvlKeyword k = g["StitchedProductIds"];
for (int j=0; j<(int)k.Size(); j++) {
sourceProductId += g["stitchedProductIds"][j];
}
}
ProdId = (string)pmatch->FindGroup("Archive",Pvl::Traverse)["ObservationId"];
iString bandname = (string)pmatch->FindGroup("BandBin",Pvl::Traverse)["Name"];
bandname = bandname.UpCase();
ProdId = ProdId + "_" + bandname;
}
bool runXY=true;
//calculate the min and max lon
double minLat = DBL_MAX;
double maxLat = -DBL_MAX;
double minLon = DBL_MAX;
double maxLon = -DBL_MAX;
double avgLat;
double avgLon;
for (int i=0; i<(int)clist.size(); i++) {
Projection *proj = clist[i]->Projection();
if (proj->MinimumLatitude() < minLat) minLat = proj->MinimumLatitude();
if (proj->MaximumLatitude() > maxLat) maxLat = proj->MaximumLatitude();
if (proj->MinimumLongitude() < minLon) minLon = proj->MinimumLongitude();
if (proj->MaximumLongitude() > maxLon) maxLon = proj->MaximumLongitude();
}
avgLat = (minLat + maxLat) / 2;
avgLon = (minLon + maxLon) / 2;
Projection *proj = clist[0]->Projection();
proj->SetGround(avgLat,avgLon);
avgLat = proj->UniversalLatitude();
avgLon = proj->UniversalLongitude();
// Use camera class to get Inc., emi., phase, and other values
double Cemiss;
double Cphase;
double Cincid;
double ClocalSolTime;
double CsolarLong;
double CsunAzimuth;
double CnorthAzimuth;
for (int i=0; i<(int)clist.size(); i++) {
Camera *cam = clist[i]->Camera();
if (cam->SetUniversalGround(avgLat,avgLon)) {
Cemiss = cam->EmissionAngle();
Cphase = cam->PhaseAngle();
Cincid = cam->IncidenceAngle();
ClocalSolTime = cam->LocalSolarTime();
CsolarLong = cam->SolarLongitude();
CsunAzimuth = cam->SunAzimuth();
CnorthAzimuth = cam->NorthAzimuth();
runXY = false;
break;
}
}
//The code within the if runXY was added in 10/07 to find an intersect with
//pole images that would fail when using projection set universal ground.
// This is run if no intersect is found when using lat and lon in
// projection space.
if (runXY) {
double startX = DBL_MAX;
double endX = DBL_MIN;
double startY = DBL_MAX;
double endY = DBL_MIN;
for (int i=0; i<(int)clist.size(); i++) {
Projection *proj = clist[i]->Projection();
proj->SetWorld(0.5,0.5);
if (i==0) {
startX = proj->XCoord();
endY = proj->YCoord();
}
else {
if (proj->XCoord() < startX) startX = proj->XCoord();
if (proj->YCoord() > endY) endY = proj->YCoord();
}
Pvl *p = clist[i]->Label();
double nlines = p->FindGroup("Dimensions",Pvl::Traverse)["Lines"];
double nsamps = p->FindGroup("Dimensions",Pvl::Traverse)["Samples"];
proj->SetWorld((nsamps+0.5),(nlines+0.5));
if (i==0) {
endX = proj->XCoord();
startY = proj->YCoord();
}
else {
if (proj->XCoord() > endX) endX = proj->XCoord();
if (proj->YCoord() < startY) startY = proj->YCoord();
}
}
double avgX = (startX + endX) / 2;
double avgY = (startY + endY) / 2;
double sample = proj->ToWorldX(avgX);
double line = proj->ToWorldY(avgY);
for (int i=0; i<(int)clist.size(); i++) {
Camera *cam = clist[i]->Camera();
if (cam->SetImage(sample,line)) {
Cemiss = cam->EmissionAngle();
Cphase = cam->PhaseAngle();
Cincid = cam->IncidenceAngle();
ClocalSolTime = cam->LocalSolarTime();
CsolarLong = cam->SolarLongitude();
CsunAzimuth = cam->SunAzimuth();
CnorthAzimuth = cam->NorthAzimuth();
runXY = false;
break;
}
}
}
if (runXY) {
string msg = "Camera did not intersect images to gather stats";
throw iException::Message(iException::User,msg,_FILEINFO_);
}
// get the min and max SCLK values ( do this with string comp.)
// get the value from the original label blob
string startClock;
string stopClock;
string startTime;
string stopTime;
for (int i=0; i<(int)clist.size(); i++) {
OriginalLabel origLab;
clist[i]->Read(origLab);
PvlGroup timegrp = origLab.ReturnLabels().FindGroup("TIME_PARAMETERS",Pvl::Traverse);
if (i==0) {
startClock = (string)timegrp["SpacecraftClockStartCount"];
stopClock = (string)timegrp["SpacecraftClockStopCount"];
startTime = (string)timegrp["StartTime"];
stopTime = (string)timegrp["StopTime"];
}
else {
string testStartTime = (string)timegrp["StartTime"];
string testStopTime = (string)timegrp["StopTime"];
if (testStartTime < startTime) {
startTime = testStartTime;
startClock = (string)timegrp["SpacecraftClockStartCount"];
}
if (testStopTime > stopTime) {
stopTime = testStopTime;
stopClock = (string)timegrp["spacecraftClockStopCount"];
}
}
}
// Concatenate all TDI's and summing and specialProcessingFlat into one keyword
PvlKeyword cpmmTdiFlag("cpmmTdiFlag");
PvlKeyword cpmmSummingFlag("cpmmSummingFlag");
PvlKeyword specialProcessingFlag("SpecialProcessingFlag");
for (int i=0; i<14; i++) {
cpmmTdiFlag +=(string)"";
cpmmSummingFlag +=(string)"";
specialProcessingFlag +=(string)"";
}
for (int i=0; i<(int)clist.size(); i++) {
Pvl *clab = clist[i]->Label();
PvlGroup cInst = clab->FindGroup("Instrument",Pvl::Traverse);
OriginalLabel cOrgLab;
clist[i]->Read(cOrgLab);
PvlGroup cGrp = cOrgLab.ReturnLabels().FindGroup("INSTRUMENT_SETTING_PARAMETERS",Pvl::Traverse);
cpmmTdiFlag[(int)cInst["CpmmNumber"]] = (string) cGrp["MRO:TDI"];
cpmmSummingFlag[(int)cInst["CpmmNumber"]] = (string) cGrp["MRO:BINNING"];
if (cInst.HasKeyword("Special_Processing_Flag")) {
specialProcessingFlag[cInst["CpmmNumber"]] = (string) cInst["Special_Processing_Flag"];
}
else {
// there may not be the keyword Special_Processing_Flag if no
//keyword then set the output to NOMINAL
specialProcessingFlag[cInst["CpmmNumber"]] = "NOMINAL";
}
}
// Get the blob of original labels from first image in list
OriginalLabel org;
clist[0]->Read(org);
//close all cubes
for (int i=0; i<(int)clist.size(); i++) {
clist[i]->Close();
delete clist[i];
}
clist.clear();
// automos step
string list = ui.GetFilename("FROMLIST");
string toMosaic = ui.GetFilename("TO");
string MosaicPriority = ui.GetString("PRIORITY");
string parameters = "FROMLIST=" + list + " MOSAIC=" + toMosaic + " PRIORITY=" + MosaicPriority;
Isis::iApp ->Exec("automos",parameters);
// write out new information to new group mosaic
PvlGroup mos("Mosaic");
mos += PvlKeyword("ProductId ", ProdId);
mos += PvlKeyword(sourceProductId);
mos += PvlKeyword("StartTime ", startTime);
mos += PvlKeyword("SpacecraftClockStartCount ", startClock);
mos += PvlKeyword("StopTime ", stopTime);
mos += PvlKeyword("SpacecraftClockStopCount ", stopClock);
mos += PvlKeyword("IncidenceAngle ", Cincid, "DEG");
mos += PvlKeyword("EmissionAngle ", Cemiss, "DEG");
mos += PvlKeyword("PhaseAngle ", Cphase, "DEG");
mos += PvlKeyword("LocalTime ", ClocalSolTime, "LOCALDAY/24");
mos += PvlKeyword("SolarLongitude ", CsolarLong, "DEG");
mos += PvlKeyword("SubSolarAzimuth ", CsunAzimuth, "DEG");
mos += PvlKeyword("NorthAzimuth ", CnorthAzimuth, "DEG");
mos += cpmmTdiFlag;
mos += cpmmSummingFlag;
mos += specialProcessingFlag;
Cube mosCube;
mosCube.Open(ui.GetFilename("TO"), "rw");
PvlObject &lab=mosCube.Label()->FindObject("IsisCube");
lab.AddGroup(mos);
//add orginal label blob to the output cube
mosCube.Write(org);
mosCube.Close();
}
catch (iException &e) {
for (int i=0; i<(int)clist.size(); i++) {
clist[i]->Close();
delete clist[i];
}
string msg = "The mosaic [" + ui.GetFilename("TO") + "] was NOT created";
throw iException::Message(iException::User,msg,_FILEINFO_);
}
} // end of isis main
