/**
* Create and initialize a Latitude value using the mapping group's latitude
* units and radii.
*
* @see ErrorChecking
* @see CoordinateType
* @param latitude The latitude value this instance will represent,
* in the mapping group's units
* @param mapping A mapping group
* @param latitudeUnits The angular units of the latitude value (degs, rads)
* @param errors Error checking conditions
*/
Latitude::Latitude(Angle latitude, PvlGroup mapping,
ErrorChecking errors) : Angle(latitude) {
m_equatorialRadius = NULL;
m_polarRadius = NULL;
if (mapping.hasKeyword("EquatorialRadius") && mapping.hasKeyword("PolarRadius")) {
m_equatorialRadius = new Distance(toDouble(mapping["EquatorialRadius"][0]),
Distance::Meters);
m_polarRadius = new Distance(toDouble(mapping["PolarRadius"][0]),
Distance::Meters);
}
else {
PvlGroup radiiGrp = TProjection::TargetRadii(mapping["TargetName"]);
m_equatorialRadius = new Distance(toDouble(radiiGrp["EquatorialRadius"][0]),
Distance::Meters);
m_polarRadius = new Distance(toDouble(radiiGrp["PolarRadius"][0]),
Distance::Meters);
}
m_errors = errors;
if(mapping["LatitudeType"][0] == "Planetographic") {
setPlanetographic(latitude.radians(), Radians);
}
else if(mapping["LatitudeType"][0] == "Planetocentric") {
setPlanetocentric(latitude.radians(), Radians);
}
else {
QString msg = "Latitude type [" + mapping["LatitudeType"][0] +
"] is not recognized";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
}
/**
* Adds an angle to this latitude. The adding method is determined by the
* latitude type.
*
* @param angleToAdd the latitude being added to this one
* @param mapping the mapping group from a projection
* @return The result
*/
Latitude Latitude::add(Angle angleToAdd, PvlGroup mapping) {
CoordinateType latType;
Distance equatorialRadius;
Distance polarRadius;
if (mapping.hasKeyword("EquatorialRadius") && mapping.hasKeyword("PolarRadius")) {
equatorialRadius = Distance(toDouble(mapping["EquatorialRadius"][0]),
Distance::Meters);
polarRadius = Distance(toDouble(mapping["PolarRadius"][0]),
Distance::Meters);
}
else {
PvlGroup radiiGrp = TProjection::TargetRadii(mapping["TargetName"]);
equatorialRadius = Distance(toDouble(radiiGrp["EquatorialRadius"][0]),
Distance::Meters);
polarRadius = Distance(toDouble(radiiGrp["PolarRadius"][0]),
Distance::Meters);
}
if(mapping["LatitudeType"][0] == "Planetocentric")
latType = Planetocentric;
else if (mapping["LatitudeType"][0] == "Planetographic")
latType = Planetographic;
else {
IString msg = "Latitude type [" + IString(mapping["LatitudeType"][0]) +
"] is not recognized";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
return add(angleToAdd, equatorialRadius, polarRadius, latType);
}
/**
* 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);
}
// Updates existing BandBin keywords with additional values to ensure
// label compilancy (which should support Camera models). It checks for the
// existance of the keyword and uses its (assumed) first value to set nvals
// values to a constant. If the keyword doesn't exist, it uses the default
// value.
void UpdateBandKey(const QString &keyname, PvlGroup &bb, const int &nvals,
const QString &default_value) {
QString defVal(default_value);
if ( bb.hasKeyword(keyname) ) {
defVal = bb[keyname][0];
}
bb.addKeyword(makeKey(keyname, nvals, defVal), PvlContainer::Replace);
return;
}
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();
}
/**
* Find the lat/lon range of the image. This will use the image footprint,
* camera, or projection in order to find a good result.
*
* @param Cube* This is required for estimation. You can pass in NULL (it will
* disable estimation).
* @param minLat This is an output: minimum latitude
* @param maxLat This is an output: maximum latitude
* @param minLon This is an output: minimum longitude
* @param maxLon This is an output: maximum longitude
* @param allowEstimation If this is true then extra efforts will be made to
* guess the ground range of the input. This can still fail.
* @return True if a ground range was found, false if no ground range could
* be determined. Some lat/lon results may still be populated; their
* values are undefined.
*/
bool UniversalGroundMap::GroundRange(Cube *cube, Latitude &minLat,
Latitude &maxLat, Longitude &minLon, Longitude &maxLon,
bool allowEstimation) {
// Do we need a RingRange method?
// For now just return false
if (HasCamera())
if (p_camera->target()->shape()->name() == "Plane") return false;
if (HasProjection())
if (p_projection->projectionType() == Projection::RingPlane) return false;
minLat = Latitude();
maxLat = Latitude();
minLon = Longitude();
maxLon = Longitude();
// If we have a footprint, use it
try {
if (cube) {
ImagePolygon poly;
cube->read(poly);
geos::geom::MultiPolygon *footprint = PolygonTools::MakeMultiPolygon(
poly.Polys()->clone());
geos::geom::Geometry *envelope = footprint->getEnvelope();
geos::geom::CoordinateSequence *coords = envelope->getCoordinates();
for (unsigned int i = 0; i < coords->getSize(); i++) {
const geos::geom::Coordinate &coord = coords->getAt(i);
Latitude coordLat(coord.y, Angle::Degrees);
Longitude coordLon(coord.x, Angle::Degrees);
if (!minLat.isValid() || minLat > coordLat)
minLat = coordLat;
if (!maxLat.isValid() || maxLat < coordLat)
maxLat = coordLat;
if (!minLon.isValid() || minLon > coordLon)
minLon = coordLon;
if (!maxLon.isValid() || maxLon < coordLon)
maxLon = coordLon;
}
delete coords;
coords = NULL;
delete envelope;
envelope = NULL;
delete footprint;
footprint = NULL;
}
}
catch (IException &) {
}
if (!minLat.isValid() || !maxLat.isValid() ||
!minLon.isValid() || !maxLon.isValid()) {
if (HasCamera()) {
// Footprint failed, ask the camera
PvlGroup mappingGrp("Mapping");
mappingGrp += PvlKeyword("LatitudeType", "Planetocentric");
mappingGrp += PvlKeyword("LongitudeDomain", "360");
mappingGrp += PvlKeyword("LongitudeDirection", "PositiveEast");
Pvl mappingPvl;
mappingPvl += mappingGrp;
double minLatDouble;
double maxLatDouble;
double minLonDouble;
double maxLonDouble;
p_camera->GroundRange(
minLatDouble, maxLatDouble,
minLonDouble, maxLonDouble, mappingPvl);
minLat = Latitude(minLatDouble, Angle::Degrees);
maxLat = Latitude(maxLatDouble, Angle::Degrees);
minLon = Longitude(minLonDouble, Angle::Degrees);
maxLon = Longitude(maxLonDouble, Angle::Degrees);
}
else if (HasProjection()) {
// Footprint failed, look in the mapping group
PvlGroup mappingGrp = p_projection->Mapping();
if (mappingGrp.hasKeyword("MinimumLatitude") &&
mappingGrp.hasKeyword("MaximumLatitude") &&
mappingGrp.hasKeyword("MinimumLongitude") &&
mappingGrp.hasKeyword("MaximumLongitude")) {
minLat = Latitude(mappingGrp["MinimumLatitude"],
mappingGrp, Angle::Degrees);
maxLat = Latitude(mappingGrp["MaximumLatitude"],
mappingGrp, Angle::Degrees);
minLon = Longitude(mappingGrp["MinimumLongitude"],
mappingGrp, Angle::Degrees);
maxLon = Longitude(mappingGrp["MaximumLongitude"],
mappingGrp, Angle::Degrees);
}
else if (allowEstimation && cube) {
// Footprint and mapping failed... no lat/lon range of any kind is
// available. Let's test points in the image to try to make our own
// extent.
QList<QPointF> imagePoints;
// Reset to TProjection
TProjection *tproj = (TProjection *) p_projection;
/*
* This is where we're testing:
*
* |---------------|
* |***************|
* |** * **|
* |* * * * *|
* |* * * * *|
* |***************|
* |* * * * *|
* |* * * * *|
* |** * **|
* |***************|
* |---------------|
*
* We'll test at the edges, a plus (+) and an (X) to help DEMs work.
*/
int sampleCount = cube->sampleCount();
int lineCount = cube->lineCount();
int stepsPerLength = 20; //number of steps per length
double aspectRatio = (double)lineCount / (double)sampleCount;
double xStepSize = sampleCount / stepsPerLength;
double yStepSize = xStepSize * aspectRatio;
if (lineCount > sampleCount) {
aspectRatio = (double)sampleCount / (double)lineCount;
yStepSize = lineCount / stepsPerLength;
xStepSize = yStepSize * aspectRatio;
}
double yWalked = 0.5;
//3 vertical lines
for (int i = 0; i < 3; i++) {
double xValue = 0.5 + ( i * (sampleCount / 2) );
while (yWalked <= lineCount) {
imagePoints.append( QPointF(xValue, yWalked) );
yWalked += yStepSize;
}
yWalked = 0.5;
}
double xWalked = 0.5;
//3 horizontal lines
for (int i = 0; i < 3; i++) {
double yValue = 0.5 + ( i * (lineCount / 2) );
while (xWalked <= sampleCount) {
imagePoints.append( QPointF(xWalked, yValue) );
xWalked += xStepSize;
}
xWalked = 0.5;
}
double xDiagonalWalked = 0.5;
double yDiagonalWalked = 0.5;
xStepSize = sampleCount / stepsPerLength;
yStepSize = lineCount / stepsPerLength;
//Top-Down Diagonal
while ( (xDiagonalWalked <= sampleCount) && (yDiagonalWalked <= lineCount) ) {
imagePoints.append( QPointF(xDiagonalWalked, yDiagonalWalked) );
xDiagonalWalked += xStepSize;
yDiagonalWalked += yStepSize;
}
xDiagonalWalked = 0.5;
//Bottom-Up Diagonal
while ( (xDiagonalWalked <= sampleCount) && (yDiagonalWalked >= 0) ) {
imagePoints.append( QPointF(xDiagonalWalked, yDiagonalWalked) );
xDiagonalWalked += xStepSize;
yDiagonalWalked -= yStepSize;
}
foreach (QPointF imagePoint, imagePoints) {
if (tproj->SetWorld(imagePoint.x(), imagePoint.y())) {
Latitude latResult(tproj->UniversalLatitude(),
Angle::Degrees);
Longitude lonResult(tproj->UniversalLongitude(),
Angle::Degrees);
if (minLat.isValid())
minLat = qMin(minLat, latResult);
else
minLat = latResult;
if (maxLat.isValid())
maxLat = qMax(maxLat, latResult);
else
maxLat = latResult;
if (minLon.isValid())
minLon = qMin(minLon, lonResult);
else
minLon = lonResult;
if (maxLon.isValid())
maxLon = qMax(maxLon, lonResult);
else
maxLon = lonResult;
}
}
}
}
}
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->group("Mapping");
TProjection *inproj = (TProjection *) 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", toString(ui.GetDouble("MINLAT"))), Pvl::Replace);
}
if(ui.WasEntered("MAXLAT") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.addKeyword(PvlKeyword("MaximumLatitude", toString(ui.GetDouble("MAXLAT"))), Pvl::Replace);
}
if(ui.WasEntered("MINLON") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.addKeyword(PvlKeyword("MinimumLongitude", toString(ui.GetDouble("MINLON"))), Pvl::Replace);
}
if(ui.WasEntered("MAXLON") && !ui.GetBoolean("MATCHMAP")) {
userMappingGrp.addKeyword(PvlKeyword("MaximumLongitude", toString(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(((QString)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"] = toString(minLon);
outMappingGrp["MinimumLongitude"] = toString(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", toString(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", toString(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(((QString)userMappingGrp["LongitudeDirection"]).compare("PositiveEast") == 0) {
outMappingGrp[longitudes[index].name()] = toString(
TProjection::ToPositiveEast(outMappingGrp[longitudes[index].name()],
outMappingGrp["LongitudeDomain"]));
}
else {
outMappingGrp[longitudes[index].name()] = toString(
TProjection::ToPositiveWest(outMappingGrp[longitudes[index].name()],
outMappingGrp["LongitudeDomain"]));
}
}
}
}
// 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()] = toString(
TProjection::To180Domain(outMappingGrp[longitudes[index].name()]));
}
else {
outMappingGrp[longitudes[index].name()] = toString(
TProjection::To360Domain(outMappingGrp[longitudes[index].name()]));
}
}
}
}
}
// Third, planetographic/planetocentric
if(userMappingGrp.hasKeyword("LatitudeType")) { // user set a new domain?
if(((QString)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(((QString)userMappingGrp["LatitudeType"]).compare("Planetographic") == 0) {
outMappingGrp[latitudes[index].name()] = toString(TProjection::ToPlanetographic(
(double)fromMappingGrp[latitudes[index].name()],
(double)fromMappingGrp["EquatorialRadius"],
(double)fromMappingGrp["PolarRadius"]));
}
else {
outMappingGrp[latitudes[index].name()] = toString(TProjection::ToPlanetocentric(
(double)fromMappingGrp[latitudes[index].name()],
(double)fromMappingGrp["EquatorialRadius"],
(double)fromMappingGrp["PolarRadius"]));
}
}
}
}
}
// Try a couple equivalent longitudes to fix the ordering of min,max for border cases
if ((double)outMappingGrp["MinimumLongitude"] >=
(double)outMappingGrp["MaximumLongitude"]) {
if ((QString)outMappingGrp["MinimumLongitude"] == "180.0" &&
(int)userMappingGrp["LongitudeDomain"] == 180)
outMappingGrp["MinimumLongitude"] = "-180";
if ((QString)outMappingGrp["MaximumLongitude"] == "-180.0" &&
(int)userMappingGrp["LongitudeDomain"] == 180)
outMappingGrp["MaximumLongitude"] = "180";
if ((QString)outMappingGrp["MinimumLongitude"] == "360.0" &&
(int)userMappingGrp["LongitudeDomain"] == 360)
outMappingGrp["MinimumLongitude"] = "0";
if ((QString)outMappingGrp["MaximumLongitude"] == "0.0" &&
(int)userMappingGrp["LongitudeDomain"] == 360)
outMappingGrp["MaximumLongitude"] = "360";
}
// 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")) {
QString msg = "Unable to determine the correct [MinimumLongitude,MaximumLongitude].";
msg += " Please specify these values in the [MINLON,MAXLON] parameters";
throw IException(IException::Unknown, 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.
TProjection *outproj = (TProjection *) 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->sampleCount(),
icube->lineCount(),
(TProjection *) 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->bandCount());
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 {
QString msg = "Unknow value for INTERP [" + ui.GetString("INTERP") + "]";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
// Warp the cube
p.StartProcess(*transform, *interp);
p.EndProcess();
Application::Log(cleanOutGrp);
// Cleanup
delete transform;
delete interp;
}
/**
* Set the output cube to specified file name and specified input images
* and output attributes and lat,lons
*/
Isis::Cube *ProcessMapMosaic::SetOutputCube(FileList &propagationCubes,
double slat, double elat, double slon, double elon,
CubeAttributeOutput &oAtt, const QString &mosaicFile) {
if (propagationCubes.size() < 1) {
QString msg = "The list does not contain any data";
throw IException(IException::Programmer, msg, _FILEINFO_);
}
int samples, lines, bands = 0;
Pvl label;
label.read(propagationCubes[0].toString());
PvlGroup mGroup = label.findGroup("Mapping", Pvl::Traverse);
mGroup.addKeyword(PvlKeyword("MinimumLatitude", toString(slat)), Pvl::Replace);
mGroup.addKeyword(PvlKeyword("MaximumLatitude", toString(elat)), Pvl::Replace);
mGroup.addKeyword(PvlKeyword("MinimumLongitude", toString(slon)), Pvl::Replace);
mGroup.addKeyword(PvlKeyword("MaximumLongitude", toString(elon)), Pvl::Replace);
if (mGroup.hasKeyword("UpperLeftCornerX"))
mGroup.deleteKeyword("UpperLeftCornerX");
if (mGroup.hasKeyword("UpperLeftCornerY"))
mGroup.deleteKeyword("UpperLeftCornerY");
Pvl mapPvl;
mapPvl += mGroup;
// Use CreateForCube because our range differs from any of the cubes (manually specified)
Projection *proj = Isis::ProjectionFactory::CreateForCube(mapPvl, samples, lines, false);
double xmin, xmax, ymin, ymax;
proj->XYRange(xmin, xmax, ymin, ymax);
// The xmin/ymax should be rounded for the labels
xmin = mapPvl.findGroup("Mapping")["UpperLeftCornerX"];
ymax = mapPvl.findGroup("Mapping")["UpperLeftCornerY"];
for (int i = 0; i < propagationCubes.size(); i++) {
Cube cube;
cube.open(propagationCubes[i].toString());
bands = max(cube.bandCount(), bands);
// See if the cube has a projection and make sure it matches
// previous input cubes
Projection *projNew =
Isis::ProjectionFactory::CreateFromCube(*(cube.label()));
if (proj == NULL) {
}
else if (*proj != *projNew) {
QString msg = "Mapping groups do not match between cube [" + propagationCubes[i].toString() +
"] and [" + propagationCubes[0].toString() + "]";
throw IException(IException::User, msg, _FILEINFO_);
}
if (proj) delete proj;
proj = projNew;
}
if (proj) delete proj;
return SetOutputCube(propagationCubes[0].toString(), xmin, xmax, ymin, ymax,
slat, elat, slon, elon, bands, oAtt, mosaicFile);
}
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) {
QString msg = "the list file [" + ui.GetFileName("FROMLIST") +
"does not contain any data";
throw IException(IException::User, msg, _FILEINFO_);
}
// open all the cube and place in vector clist
for(int i = 0; i < flist.size(); i++) {
Cube *c = new Cube();
clist.push_back(c);
c->open(flist[i].toString());
}
// run the compair function here. This will conpair the
// labels of the first cube to the labels of each following cube.
PvlKeyword sourceProductId("SourceProductId");
QString 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 = (QString)pmatch->findGroup("Archive", Pvl::Traverse)["ObservationId"];
QString bandname = (QString)pmatch->findGroup("BandBin", Pvl::Traverse)["Name"];
bandname = bandname.toUpper();
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++) {
TProjection *proj = (TProjection *) 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;
TProjection *proj = (TProjection *) 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().degrees();
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++) {
TProjection *proj = (TProjection *) 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().degrees();
CsunAzimuth = cam->SunAzimuth();
CnorthAzimuth = cam->NorthAzimuth();
runXY = false;
break;
}
}
}
if(runXY) {
QString msg = "Camera did not intersect images to gather stats";
throw IException(IException::User, msg, _FILEINFO_);
}
// get the min and max SCLK values ( do this with QString comp.)
// get the value from the original label blob
QString startClock;
QString stopClock;
QString startTime;
QString 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 = (QString)timegrp["SpacecraftClockStartCount"];
stopClock = (QString)timegrp["SpacecraftClockStopCount"];
startTime = (QString)timegrp["StartTime"];
stopTime = (QString)timegrp["StopTime"];
}
else {
QString testStartTime = (QString)timegrp["StartTime"];
QString testStopTime = (QString)timegrp["StopTime"];
if(testStartTime < startTime) {
startTime = testStartTime;
startClock = (QString)timegrp["SpacecraftClockStartCount"];
}
if(testStopTime > stopTime) {
stopTime = testStopTime;
stopClock = (QString)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 += (QString)"";
cpmmSummingFlag += (QString)"";
specialProcessingFlag += (QString)"";
}
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"]] = (QString) cGrp["MRO:TDI"];
cpmmSummingFlag[(int)cInst["CpmmNumber"]] = (QString) cGrp["MRO:BINNING"];
if(cInst.hasKeyword("Special_Processing_Flag")) {
specialProcessingFlag[cInst["CpmmNumber"]] = (QString) 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
QString list = ui.GetFileName("FROMLIST");
QString toMosaic = ui.GetFileName("TO");
QString MosaicPriority = ui.GetString("PRIORITY");
QString parameters = "FROMLIST=" + list + " MOSAIC=" + toMosaic + " PRIORITY=" + MosaicPriority;
ProgramLauncher::RunIsisProgram("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 ", toString(Cincid), "DEG");
mos += PvlKeyword("EmissionAngle ", toString(Cemiss), "DEG");
mos += PvlKeyword("PhaseAngle ", toString(Cphase), "DEG");
mos += PvlKeyword("LocalTime ", toString(ClocalSolTime), "LOCALDAY/24");
mos += PvlKeyword("SolarLongitude ", toString(CsolarLong), "DEG");
mos += PvlKeyword("SubSolarAzimuth ", toString(CsunAzimuth), "DEG");
mos += PvlKeyword("NorthAzimuth ", toString(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];
}
QString msg = "The mosaic [" + ui.GetFileName("TO") + "] was NOT created";
throw IException(IException::User, msg, _FILEINFO_);
}
} // end of isis main
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;
}
}
