void ProcessIr() {
UserInterface &ui = Application::GetUserInterface();
Pipeline p;
p.SetInputFile("FROM", "BANDS");
p.SetOutputFile("TO");
p.KeepTemporaryFiles(!ui.GetBoolean("REMOVE"));
p.AddToPipeline("thm2isis");
p.Application("thm2isis").SetInputParameter("FROM", false);
p.Application("thm2isis").SetOutputParameter("TO", "raw");
p.AddToPipeline("spiceinit");
p.Application("spiceinit").SetInputParameter("FROM", false);
p.Application("spiceinit").AddParameter("PCK", "PCK");
p.Application("spiceinit").AddParameter("CK", "CK");
p.Application("spiceinit").AddParameter("SPK", "SPK");
p.Application("spiceinit").AddParameter("SHAPE", "SHAPE");
p.Application("spiceinit").AddParameter("MODEL", "MODEL");
p.Application("spiceinit").AddParameter("CKNADIR", "CKNADIR");
p.AddToPipeline("cam2map");
p.Application("cam2map").SetInputParameter("FROM", true);
p.Application("cam2map").SetOutputParameter("TO", "lev2");
p.Application("cam2map").AddParameter("MAP", "MAP");
p.Application("cam2map").AddParameter("PIXRES", "RESOLUTION");
if(ui.WasEntered("PIXRES")) {
p.Application("cam2map").AddConstParameter("PIXRES", "MPP");
}
if(ui.GetBoolean("INGESTION")) {
p.SetFirstApplication("thm2isis");
}
else{
p.SetFirstApplication("spiceinit");
}
if(ui.GetBoolean("MAPPING")) {
p.SetLastApplication("cam2map");
}
else {
p.SetLastApplication("spiceinit");
}
p.Run();
}
void IsisMain() {
vector<QString> sTempFiles;
QString inFile, outFile;
try {
// Get user interface
UserInterface &ui = Application::GetUserInterface();
bool bRemoveTempFiles = ui.GetBoolean("REMOVE");
bool bMapping = ui.GetBoolean("MAPPING");
bool bIngestion = ui.GetBoolean("INGESTION");
bool bHideStripe = ui.GetBoolean("DESTRIPE");
bool bNoiseFilter = ui.GetBoolean("NOISE_FILTER");
bool bRemoveFurrows = ui.GetBoolean("FURROWS");
// Get the cube info
inFile = ui.GetFileName("FROM");
outFile = ui.GetFileName("TO");
Pvl cubeLabel;
if (bIngestion) {
int sDotPos = outFile.indexOf('.');
QString sIngestedFile = outFile.mid(0, sDotPos);
cubeLabel = Pvl(sIngestedFile + ".lev2.cub");
}
else {
cubeLabel = Pvl(inFile);
}
// Get the Summing from the label
int iSumming = toInt(cubeLabel.findObject("IsisCube").findGroup("Instrument").findKeyword("Summing")[0]);
Pipeline p1("hicalproc1");
p1.SetInputFile("FROM");
p1.SetOutputFile(FileName("$TEMPORARY/p1_out.cub"));
sTempFiles.push_back(FileName("$TEMPORARY/p1_out.cub").expanded());
p1.KeepTemporaryFiles(!bRemoveTempFiles);
// If Raw image convert to Isis format
p1.AddToPipeline("hi2isis");
p1.Application("hi2isis").SetInputParameter ("FROM", false);
p1.Application("hi2isis").SetOutputParameter("TO", "lev2");
if (!bIngestion) {
p1.Application("hi2isis").Disable();
}
// Run spiceinit
p1.AddToPipeline("spiceinit");
p1.Application("spiceinit").SetInputParameter("FROM", false);
p1.Application("spiceinit").AddConstParameter("ATTACH", "NO");
p1.Application("spiceinit").AddParameter ("PCK", "PCK");
p1.Application("spiceinit").AddParameter ("CK", "CK");
p1.Application("spiceinit").AddParameter ("SPK", "SPK");
p1.Application("spiceinit").AddParameter ("SHAPE", "SHAPE");
p1.Application("spiceinit").AddParameter ("MODEL", "MODEL");
p1.Application("spiceinit").AddParameter ("CKNADIR", "CKNADIR");
if (!bMapping) {
p1.Application("spiceinit").Disable();
}
p1.AddToPipeline("hifurrows");
p1.Application("hifurrows").SetInputParameter ("FROM", false);
p1.Application("hifurrows").SetOutputParameter("TO", "rmfrw");
p1.Application("hifurrows").AddConstParameter ("NEW_VERSION", "true");
p1.Application("hifurrows").AddConstParameter ("LOWPASS", "true");
if (!bRemoveFurrows) {
p1.Application("hifurrows").Disable();
}
// MASK if NoiseFilter==true
p1.AddToPipeline("mask");
// if nothing to mask, continue even if app generates an exception
p1.Application("mask").SetContinue(true);
p1.Application("mask").SetInputParameter ("FROM", false);
p1.Application("mask").SetOutputParameter("TO", "mask1");
p1.Application("mask").AddConstParameter ("MINIMUM", "1200");
p1.Application("mask").AddConstParameter ("MAXIMUM", "16383");
p1.Application("mask").AddConstParameter ("PRESERVE", "INSIDE");
p1.Application("mask").AddConstParameter ("SPIXELS", "NONE");
if (!bNoiseFilter) {
p1.Application("mask").Disable();
}
// There is no ouput created as the Furrows and Noise Filter apps are disabled
// Hence just copy the input to the output
if (!bIngestion && !bMapping && !bRemoveFurrows && !bNoiseFilter) {
p1.AddToPipeline("crop");
p1.Application("crop").SetInputParameter ("FROM", false);
p1.Application("crop").SetOutputParameter("TO", "copy");
}
#ifdef _DEBUG_
cout << p1 << endl;
cout << "*****************************************************************\n";
#endif
p1.Run();
Pipeline pStats;
pStats.SetInputFile(FileName("$TEMPORARY/p1_out.cub"));
pStats.SetOutputFile(FileName("$TEMPORARY/statsMask"));
sTempFiles.push_back(FileName("$TEMPORARY/statsMask").expanded());
pStats.KeepTemporaryFiles(!bRemoveTempFiles);
pStats.AddToPipeline("cubenorm");
pStats.Application("cubenorm").SetInputParameter("FROM", false);
pStats.Application("cubenorm").SetOutputParameter("STATS", "statsMask");
if (!bNoiseFilter) {
pStats.Application("cubenorm").Disable();
}
else {
#ifdef _DEBUG_
cout << pStats << endl;
cout << "*****************************************************************\n";
#endif
pStats.Run();
}
double dMinDN=0, dMaxDN=0;
if (bNoiseFilter) {
AnalyzeCubenormStats(FileName("$TEMPORARY/statsMask").expanded(), iSumming, dMinDN, dMaxDN);
}
Pipeline p2("hicalproc2");
p2.SetInputFile(FileName("$TEMPORARY/p1_out.cub"));
if (bNoiseFilter || bHideStripe || bMapping ) {
p2.SetOutputFile(FileName("$TEMPORARY/p2_out.cub"));
sTempFiles.push_back(FileName("$TEMPORARY/p2_out.cub").expanded());
}
else {
p2.SetOutputFile("TO");
}
p2.KeepTemporaryFiles(!bRemoveTempFiles);
p2.AddToPipeline("mask");
p2.Application("mask").SetContinue(true);
p2.Application("mask").SetInputParameter("FROM", false);
p2.Application("mask").SetOutputParameter("TO", "mask2");
p2.Application("mask").AddConstParameter("MINIMUM", toString(dMinDN));
p2.Application("mask").AddConstParameter("MAXIMUM", toString(dMaxDN));
p2.Application("mask").AddConstParameter("PRESERVE", "INSIDE");
p2.Application("mask").AddConstParameter("SPIXELS", "NONE");
if (!bNoiseFilter) {
p2.Application("mask").Disable();
}
// Caliberation
p2.AddToPipeline("hical");
p2.Application("hical").SetInputParameter("FROM", false);
p2.Application("hical").SetOutputParameter("TO", "hical");
// Gaindrift Corrections
GetCCD_Channel_Coefficients(cubeLabel);
p2.AddToPipeline("fx");
p2.Application("fx").SetInputParameter("F1", false);
p2.Application("fx").SetOutputParameter("TO", "gnfx");
p2.Application("fx").AddConstParameter("MODE", "CUBES");
QString sEquation = "\\((F1/(" + csvArr[R0]+ "+( " + csvArr[R1] + "*line)+(" + csvArr[R2];
sEquation += "*line*line))) *(line<" + csvArr[MAX_LINE]+ ") + (F1*(line>=" + csvArr[MAX_LINE] + ")))";
sEquation = sEquation.simplified();
p2.Application("fx").AddConstParameter("EQUATION", sEquation);
#ifdef _DEBUG_
cerr << "FX Equation=" << sEquation << endl;
cout << p2<<endl;
cout << "*****************************************************************\n";
#endif
p2.Run();
// ********************************************************************************************
// CubeNorm Corrections
// ********************************************************************************************
if (bNoiseFilter || bHideStripe) {
Pipeline p3("hicalproc3");
p3.SetInputFile(FileName("$TEMPORARY/p2_out.cub"));
p3.SetOutputFile(FileName("$TEMPORARY/StatsCubeNorm1"));
sTempFiles.push_back(FileName("$TEMPORARY/StatsCubeNorm1").expanded());
p3.KeepTemporaryFiles(!bRemoveTempFiles);
// Crop if skip top and bottom lines are defined in the Configuration file
/*p3.AddToPipeline("crop");
p3.Application("crop").SetInputParameter ("FROM", false);
p3.Application("crop").SetOutputParameter("TO", "crop");
p3.Application("crop").AddConstParameter ("line", "1");
//p3.Application("crop").AddConstParameter ("nlines", "156");
p3.Application("crop").AddConstParameter ("nlines", "209");*/
p3.AddToPipeline("cubenorm");
p3.Application("cubenorm").SetInputParameter ("FROM", false);
p3.Application("cubenorm").SetOutputParameter("stats", "stats");
p3.Application("cubenorm").AddConstParameter ("format", "table");
p3.Run();
#ifdef _DEBUG_
cout << p3 << endl;
cout << "*****************************************************************\n";
#endif
Pipeline p4("hicalproc4");
p4.SetInputFile(FileName("$TEMPORARY/p2_out.cub"));
p4.SetOutputFile(FileName("$TEMPORARY/StatsCubeNorm2"));
sTempFiles.push_back(FileName("$TEMPORARY/StatsCubeNorm2").expanded());
p4.KeepTemporaryFiles(!bRemoveTempFiles);
p4.AddToPipeline("hicubenorm");
p4.Application("hicubenorm").SetInputParameter ("FROM", false);
p4.Application("hicubenorm").SetOutputParameter("STATS", "hicbnrm");
p4.Application("hicubenorm").AddConstParameter ("FORMAT", "TABLE");
p4.Application("hicubenorm").AddConstParameter ("FILTER", "5");
p4.Application("hicubenorm").AddConstParameter ("STATSOURCE", "TABLE");
p4.Application("hicubenorm").AddConstParameter ("FROMSTATS",
FileName("$TEMPORARY/StatsCubeNorm1").expanded());
p4.Application("hicubenorm").AddConstParameter ("NEW_VERSION", "TRUE");
p4.Application("hicubenorm").AddConstParameter ("HIGHPASS_MODE", "HIGHPASS_DIVIDE");
p4.Application("hicubenorm").AddConstParameter ("PAUSECROP", "TRUE");
p4.Run();
#ifdef _DEBUG_
cout << p4 << endl;
cout << "*****************************************************************\n";
#endif
Pipeline p5("hicalproc5");
p5.SetInputFile(FileName("$TEMPORARY/p2_out.cub"));
if (bHideStripe || bMapping) {
p5.SetOutputFile(FileName("$TEMPORARY/p5_out.cub"));
sTempFiles.push_back(FileName("$TEMPORARY/p5_out.cub").expanded());
}
else {
p5.SetOutputFile("TO");
}
p5.KeepTemporaryFiles(!bRemoveTempFiles);
p5.SetContinue(true);
p5.AddToPipeline("cubenorm");
p5.Application("cubenorm").SetInputParameter ("FROM", false);
p5.Application("cubenorm").SetOutputParameter("TO", "cbnorm");
p5.Application("cubenorm").AddConstParameter ("format", "TABLE");
p5.Application("cubenorm").AddConstParameter ("STATSOURCE", "TABLE");
p5.Application("cubenorm").AddConstParameter ("FROMSTATS", FileName("$TEMPORARY/StatsCubeNorm2").expanded());
p5.Application("cubenorm").AddConstParameter ("DIRECTION", "COLUMN");
p5.Application("cubenorm").AddConstParameter ("NORMALIZER", "AVERAGE");
p5.Application("cubenorm").AddConstParameter ("PRESERVE", "FALSE");
p5.Application("cubenorm").AddConstParameter ("MODE", "DIVIDE");
// **********************************************************************************
// Noise Filter
if (bNoiseFilter) {
p5.AddToPipeline("hinoise");
p5.Application("hinoise").SetInputParameter ("FROM", false);
p5.Application("hinoise").SetOutputParameter("TO", "hinoise");
p5.Application("hinoise").AddConstParameter ("REMOVE", QString(bRemoveTempFiles));
// Values got from HiCal configuration file
// Lowpass options
p5.Application("hinoise").AddConstParameter ("LPF_LINES", "251");
p5.Application("hinoise").AddConstParameter ("LPF_SAMPLES", "3");
p5.Application("hinoise").AddConstParameter ("LPF_MINPER", "5");
// Highpass Options
p5.Application("hinoise").AddConstParameter ("HPF_LINES", "251");
p5.Application("hinoise").AddConstParameter ("HPF_SAMPLES", "1");
p5.Application("hinoise").AddConstParameter ("HPF_MINPER", "5");
// Noise Filter options
p5.Application("hinoise").AddConstParameter ("NULL_COLUMNS", "FALSE");
p5.Application("hinoise").AddConstParameter ("TOLMIN", "3.5");
p5.Application("hinoise").AddConstParameter ("TOLMAX", "3.5");
p5.Application("hinoise").AddConstParameter ("FLATTOL", "1.0");
p5.Application("hinoise").AddConstParameter ("MIN_VALUE", "0.0");
p5.Application("hinoise").AddConstParameter ("HARD_TOLMIN", "3.5");
p5.Application("hinoise").AddConstParameter ("HARD_TOLMAX", "3.5");
p5.Application("hinoise").AddConstParameter ("LPFZ_LINES", "5");
p5.Application("hinoise").AddConstParameter ("LPFZ_SAMPLES", "5");
p5.Application("hinoise").AddConstParameter ("NOISE_LINES", "7");
p5.Application("hinoise").AddConstParameter ("NOISE_SAMPLES", "7");
p5.Application("hinoise").AddConstParameter ("CLEAR_FRACTION", "0.8");
p5.Application("hinoise").AddConstParameter ("NONVALID_FRACTION", "0.9");
p5.Application("hinoise").AddConstParameter ("HARD_FILTERING", "0.1");
p5.Application("hinoise").AddConstParameter ("HIGHEND_PERCENT", "99.999");
p5.Application("hinoise").AddConstParameter ("HARD_HIGHEND_PERCENT", "99.99");
p5.Application("hinoise").Disable();
}
p5.Run();
#ifdef _DEBUG_
cout << p5 << endl;
cout << "*****************************************************************\n";
#endif
}
// **********************************************************************************
// HideStripe Filter
if (bHideStripe) {
Pipeline p6("hicalproc6");
p6.SetInputFile(FileName("$TEMPORARY/p5_out.cub"));
if (!bMapping) {
p6.SetOutputFile("TO");
}
else {
p6.SetOutputFile(FileName("$TEMPORARY/p6_out.cub"));
sTempFiles.push_back(FileName("$TEMPORARY/p6_out.cub").expanded());
}
p6.KeepTemporaryFiles(!bRemoveTempFiles);
if (iSumming == 1 || iSumming == 2) {
p6.AddToPipeline("hidestripe", "hidestripe1");
p6.Application("hidestripe1").SetInputParameter ("FROM", false);
p6.Application("hidestripe1").SetOutputParameter("TO", "hdstrp1");
p6.Application("hidestripe1").AddConstParameter ("PARITY", "EVEN");
p6.Application("hidestripe1").AddConstParameter ("CORRECTION", "ADD");
p6.AddToPipeline("hidestripe", "hidestripe2");
p6.Application("hidestripe2").SetInputParameter ("FROM", false);
p6.Application("hidestripe2").SetOutputParameter("TO", "hdstrp2");
p6.Application("hidestripe2").AddConstParameter ("PARITY", "ODD");
p6.Application("hidestripe2").AddConstParameter ("CORRECTION", "ADD");
}
else {
p6.AddToPipeline("hidestripe");
p6.Application("hidestripe").SetInputParameter ("FROM", false);
p6.Application("hidestripe").SetOutputParameter("TO", "hdstrp");
p6.Application("hidestripe").AddConstParameter ("PARITY", "AUTO");
p6.Application("hidestripe").AddConstParameter ("CORRECTION", "ADD");
}
p6.Run();
#ifdef _DEBUG_
cout << p6 << endl;
cout << "*****************************************************************\n";
#endif
}
// **********************************************************************************
// Projection
if (bMapping) {
Pipeline p7("hicalproc7");
if (bHideStripe) {
p7.SetInputFile(FileName("$TEMPORARY/p6_out.cub"));
}
else {
p7.SetInputFile(FileName("$TEMPORARY/p2_out.cub"));
}
p7.SetOutputFile("TO");
p7.KeepTemporaryFiles(!bRemoveTempFiles);
p7.AddToPipeline("cam2map");
p7.Application("cam2map").SetInputParameter ("FROM", false);
p7.Application("cam2map").SetOutputParameter("TO", "map");
p7.Application("cam2map").AddParameter ("MAP", "MAP");
p7.Application("cam2map").AddParameter ("PIXRES", "RESOLUTION");
if(ui.WasEntered("PIXRES")) {
p7.Application("cam2map").AddConstParameter("PIXRES", "MPP");
}
#ifdef _DEBUG_
cout << p7 << endl;
cout << "*****************************************************************\n";
#endif
p7.Run();
}
CleanUp(sTempFiles, inFile);
}
catch(IException &) {
CleanUp(sTempFiles, inFile);
throw;
}
catch(std::exception const &se) {
CleanUp(sTempFiles, inFile);
QString message = "std::exception: " + (QString)se.what();
throw IException(IException::User, message, _FILEINFO_);
}
catch(...) {
CleanUp(sTempFiles, inFile);
QString message = "Other Error";
throw IException(IException::User, message, _FILEINFO_);
}
}
