rspfApplanixEcefModel::rspfApplanixEcefModel()
{
theCompositeMatrix = rspfMatrix4x4::createIdentity();
theCompositeMatrixInverse = rspfMatrix4x4::createIdentity();
theRoll = 0.0;
thePitch = 0.0;
theHeading = 0.0;
theFocalLength = 55.0;
thePixelSize = rspfDpt(.009, .009);
theEcefPlatformPosition = rspfGpt(0.0,0.0, 1000.0);
theAdjEcefPlatformPosition = rspfGpt(0.0,0.0, 1000.0);
theGSD.x = 0.1524;
theGSD.y = 0.1524;
theMeanGSD = 0.1524;
theLensDistortion = new rspfMeanRadialLensDistortion;
initAdjustableParameters();
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfApplanixEcefModel::rspfApplanixEcefModel DEBUG:" << endl;
#ifdef RSPF_ID_ENABLED
rspfNotify(rspfNotifyLevel_DEBUG)<< "RSPF_ID: " << RSPF_ID << endl;
#endif
}
}
void ossimAdjustableParameterInterface::resetAdjustableParameters(bool notify)
{
if(!theAdjustmentList.size())
{
return;
}
ossim_uint32 saveCurrent = theCurrentAdjustment;
copyAdjustment();
initAdjustableParameters();
ossim_uint32 numberOfAdjustables = getNumberOfAdjustableParameters();
ossim_uint32 idx = 0;
for(idx = 0; idx < numberOfAdjustables; ++idx)
{
theAdjustmentList[saveCurrent].getParameterList()[idx].setParameter(theAdjustmentList[theAdjustmentList.size()-1].getParameterList()[idx].getParameter());
}
setCurrentAdjustment(saveCurrent);
eraseAdjustment((ossim_uint32)theAdjustmentList.size()-1, false);
if(notify)
{
adjustableParametersChanged();
}
}
//*****************************************************************************
// DEFAULT CONSTRUCTOR: ossimRpcModel()
//
//*****************************************************************************
ossimRpcModel::ossimRpcModel()
: ossimSensorModel(),
thePolyType (A),
theLineScale (0.0),
theSampScale (0.0),
theLatScale (0.0),
theLonScale (0.0),
theHgtScale (0.0),
theLineOffset (0.0),
theSampOffset (0.0),
theLatOffset (0.0),
theLonOffset (0.0),
theHgtOffset (0.0),
theIntrackOffset(0.0),
theCrtrackOffset(0.0),
theIntrackScale (0.0),
theCrtrackScale (0.0),
theCosMapRot (0.0),
theSinMapRot (0.0),
theBiasError (0.0),
theRandError (0.0)
{
initAdjustableParameters();
}
ossimApplanixUtmModel::ossimApplanixUtmModel()
:theOmega(0.0),
thePhi(0.0),
theKappa(0.0),
theBoreSightTx(0.0),
theBoreSightTy(0.0),
theBoreSightTz(0.0)
{
theCompositeMatrix = ossimMatrix4x4::createIdentity();
theCompositeMatrixInverse = ossimMatrix4x4::createIdentity();
theFocalLength = 55.0;
thePixelSize = ossimDpt(.009, .009);
theEcefPlatformPosition = ossimGpt(0.0,0.0, 1000.0);
theGSD.x = 0.1524;
theGSD.y = 0.1524;
theMeanGSD = 0.1524;
theLensDistortion = new ossimMeanRadialLensDistortion;
initAdjustableParameters();
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimApplanixUtmModel::ossimApplanixUtmModel DEBUG:" << endl;
#ifdef OSSIM_ID_ENABLED
ossimNotify(ossimNotifyLevel_DEBUG)<< "OSSIM_ID: " << OSSIM_ID << endl;
#endif
}
}
ossimSpectraboticsRedEdgeModel::ossimSpectraboticsRedEdgeModel()
{
m_compositeMatrix = ossimMatrix4x4::createIdentity();
m_compositeMatrixInverse = ossimMatrix4x4::createIdentity();
m_roll = 0.0;
m_pitch = 0.0;
m_heading = 0.0;
m_focalLength = 5.5;
m_pixelSize = ossimDpt(0.003, 0.003);
m_ecefPlatformPosition = ossimGpt(0.0,0.0, 1000.0);
m_adjEcefPlatformPosition = ossimGpt(0.0,0.0, 1000.0);
theGSD.x = 0.076;
theGSD.y = 0.076;
theMeanGSD = 0.076;
m_fov = 48.8; // degrees
m_lensDistortion = new ossimTangentialRadialLensDistortion();
initAdjustableParameters();
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimSpectraboticsRedEdgeModel::ossimSpectrabotics DEBUG:" << endl;
#ifdef OSSIM_ID_ENABLED
ossimNotify(ossimNotifyLevel_DEBUG)<< "OSSIM_ID: " << OSSIM_ID << endl;
#endif
}
}
ossimAlphaSensorHSI::ossimAlphaSensorHSI()
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimAlphaSensorHSI::ossimAlphaSensorHSI DEBUG:" << std::endl;
}
initAdjustableParameters();
theSensorID = "AlphaHSI";
}
rspfSFIMFusion::rspfSFIMFusion()
:theLowPassKernelWidth(1.5),
theHighPassKernelWidth(3)
{
theAutoAdjustScales = true;
theLowPassFilter = new rspfImageGaussianFilter;
theHighPassFilter = new rspfConvolutionSource;
setFilters();
initAdjustableParameters();
}
rspfApplanixEcefModel::rspfApplanixEcefModel(const rspfApplanixEcefModel& src)
:rspfSensorModel(src)
{
initAdjustableParameters();
if(src.theLensDistortion.valid())
{
theLensDistortion = new rspfMeanRadialLensDistortion(*(src.theLensDistortion.get()));
}
else
{
theLensDistortion = new rspfMeanRadialLensDistortion();
}
}
ossimSpectraboticsRedEdgeModel::ossimSpectraboticsRedEdgeModel(const ossimSpectraboticsRedEdgeModel& src)
:ossimSensorModel(src)
{
initAdjustableParameters();
if(src.m_lensDistortion.valid())
{
m_lensDistortion = new ossimTangentialRadialLensDistortion(*(src.m_lensDistortion.get()));
}
else
{
m_lensDistortion = new ossimTangentialRadialLensDistortion();
}
}
rspfLandSatModel::rspfLandSatModel()
:
rspfSensorModel(),
theIntrackOffset (0.0),
theCrtrackOffset (0.0),
theLineGsdCorr (0.0),
theSampGsdCorr (0.0),
theRollOffset (0.0),
theYawOffset (0.0),
theYawRate (0.0),
theMapRotation (0.0)
{
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::rspfLandSatModel: entering..." << std::endl;
initAdjustableParameters();
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::rspfLandSatModel: returning..." << std::endl;
}
//*****************************************************************************
// DEFAULT CONSTRUCTOR: ossimRpcModel()
//
//*****************************************************************************
ossimRpcProjection::ossimRpcProjection()
: ossimOptimizableProjection(),
theIntrackOffset(0),
theCrtrackOffset(0),
theIntrackScale(0.0),
theCrtrackScale(0.0),
theYawSkew (0.0),
theCosMapRot (1.0),
theSinMapRot (0.0)
{
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection Default Constructor: entering..." << std::endl;
initAdjustableParameters();
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection Default Constructor: returning..." << std::endl;
}
rspfLandSatModel::rspfLandSatModel(const rspfKeywordlist& geom_kwl)
:
rspfSensorModel(),
theIntrackOffset (0.0),
theCrtrackOffset (0.0),
theLineGsdCorr (0.0),
theSampGsdCorr (0.0),
theRollOffset (0.0),
theYawOffset (0.0),
theYawRate (0.0),
theMapRotation (0.0)
{
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::rspfLandSatModel(geom_kwl): entering..." << std::endl;
initAdjustableParameters();
loadState(geom_kwl);
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::rspfLandSatModel(geom_kwl): Exited..." << std::endl;
}
rspfApplanixEcefModel::rspfApplanixEcefModel(const rspfDrect& imageRect,
const rspfGpt& platformPosition,
double roll,
double pitch,
double heading,
const rspfDpt& /* principalPoint */, // in millimeters
double focalLength, // in millimeters
const rspfDpt& pixelSize) // in millimeters
{
theImageClipRect = imageRect;
theRefImgPt = theImageClipRect.midPoint();
theCompositeMatrix = rspfMatrix4x4::createIdentity();
theCompositeMatrixInverse = rspfMatrix4x4::createIdentity();
theRoll = roll;
thePitch = pitch;
theHeading = heading;
theFocalLength = focalLength;
thePixelSize = pixelSize;
theEcefPlatformPosition = platformPosition;
theAdjEcefPlatformPosition = platformPosition;
theLensDistortion = new rspfMeanRadialLensDistortion;
initAdjustableParameters();
updateModel();
try
{
// Method throws rspfException.
computeGsd();
}
catch (const rspfException& e)
{
rspfNotify(rspfNotifyLevel_WARN)
<< "rspfApplanixEcefModel Constructor caught Exception:\n"
<< e.what() << std::endl;
}
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfApplanixEcefModel::rspfApplanixEcefModel DEBUG:" << endl;
#ifdef RSPF_ID_ENABLED
rspfNotify(rspfNotifyLevel_DEBUG)<< "RSPF_ID: " << RSPF_ID << endl;
#endif
}
}
ossimSpectraboticsRedEdgeModel::ossimSpectraboticsRedEdgeModel(const ossimDrect& imageRect,
const ossimGpt& platformPosition,
double roll,
double pitch,
double heading,
const ossimDpt& /* principalPoint */, // in millimeters
double focalLength, // in millimeters
const ossimDpt& pixelSize) // in millimeters
{
theImageClipRect = imageRect;
theRefImgPt = theImageClipRect.midPoint();
m_compositeMatrix = ossimMatrix4x4::createIdentity();
m_compositeMatrixInverse = ossimMatrix4x4::createIdentity();
m_roll = roll;
m_pitch = pitch;
m_heading = heading;
m_focalLength = focalLength;
m_pixelSize = pixelSize;
m_ecefPlatformPosition = platformPosition;
m_adjEcefPlatformPosition = platformPosition;
m_lensDistortion = new ossimTangentialRadialLensDistortion();
initAdjustableParameters();
updateModel();
try
{
// Method throws ossimException.
// computeGsd();
}
catch (const ossimException& e)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimSpectrabotics Constructor caught Exception:\n"
<< e.what() << std::endl;
}
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimSpectraboticsRedEdgeModel::ossimSpectrabotics DEBUG:" << endl;
#ifdef OSSIM_ID_ENABLED
ossimNotify(ossimNotifyLevel_DEBUG)<< "OSSIM_ID: " << OSSIM_ID << endl;
#endif
}
}
ossimBuckeyeSensor::ossimBuckeyeSensor(const ossimBuckeyeSensor& src)
:ossimSensorModel(src)
{
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::ossimBuckeyeSensor(src): entering..." << std::endl;
initAdjustableParameters();
if(src.theLensDistortion.valid())
{
theLensDistortion = new ossimSmacCallibrationSystem(*(src.theLensDistortion.get()));
}
else
{
theLensDistortion = new ossimSmacCallibrationSystem();
}
theGSD.makeNan();
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::ossimBuckeyeSensor(src): returning..." << std::endl;
}
ossimBuckeyeSensor::ossimBuckeyeSensor(const ossimDrect& imageRect,
const ossimGpt& platformPosition,
double roll,
double pitch,
double heading,
const ossimDpt& /* principalPoint */, // in millimeters
double focalLength, // in millimeters
const ossimDpt& pixelSize) // in millimeters
{
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::ossimBuckeyeSensor(imageRect,platformPosition,roll,pitch,heading,ossimDpt,focalLength,pixelSize): entering..." << std::endl;
theImageClipRect = imageRect;
theRefImgPt = theImageClipRect.midPoint();
theCompositeMatrix = ossimMatrix4x4::createIdentity();
theCompositeMatrixInverse = ossimMatrix4x4::createIdentity();
theRoll = roll;
thePitch = pitch;
theHeading = heading;
theFocalLength = focalLength;
thePixelSize = pixelSize;
theEcefPlatformPosition = platformPosition;
theAdjEcefPlatformPosition = platformPosition;
theLensDistortion = new ossimSmacCallibrationSystem();
theGSD.makeNan();
initAdjustableParameters();
updateModel();
try
{
// Method throws ossimException.
computeGsd();
}
catch (const ossimException& e)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimBuckeyeSensor Constructor caught Exception:\n"
<< e.what() << std::endl;
}
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::ossimBuckeyeSensor(imageRect,platformPosition,roll,pitch,heading,ossimDpt,focalLength,pixelSize): returning..." << std::endl;
}
ossimBuckeyeSensor::ossimBuckeyeSensor()
{
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::ossimBuckeyeSensor(): entering..." << std::endl;
theCompositeMatrix = ossimMatrix4x4::createIdentity();
theCompositeMatrixInverse = ossimMatrix4x4::createIdentity();
theRoll = 0.0;
thePitch = 0.0;
theHeading = 0.0;
theFocalLength = 195.1000;
thePixelSize = ossimDpt(.006, .006);
thePrincipalPoint = ossimDpt(0, 0);
theEcefPlatformPosition = ossimGpt(0.0,0.0, 1000.0);
theAdjEcefPlatformPosition = ossimGpt(0.0,0.0, 1000.0);
theLensDistortion = new ossimSmacCallibrationSystem();
theGSD.makeNan();
initAdjustableParameters();
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::ossimBuckeyeSensor(): returning..." << std::endl;
}
rspfLandSatModel::rspfLandSatModel(const rspfLandSatModel& rhs)
:
rspfSensorModel (rhs),
theIllumAzimuth (rhs.theIllumAzimuth),
theIllumElevation (rhs.theIllumElevation),
theOrbitAltitude (rhs.theOrbitAltitude),
theOrbitInclination(rhs.theOrbitInclination),
theMapZone (rhs.theMapZone),
theMapOffset (rhs.theMapOffset),
theWrsPathNumber (rhs.theWrsPathNumber),
theWrsRowNumber (rhs.theWrsRowNumber),
theMeridianalAngle (rhs.theMeridianalAngle),
thePositionError (rhs.thePositionError),
theProjectionType (rhs.theProjectionType),
theMapProjection (rhs.theMapProjection.valid()?
(rspfMapProjection*)rhs.theMapProjection->dup():
(rspfMapProjection*)0),
theMapAzimAngle (rhs.theMapAzimAngle),
theMapAzimCos (rhs.theMapAzimCos),
theMapAzimSin (rhs.theMapAzimSin),
theMap2IcRotAngle (rhs.theMap2IcRotAngle),
theMap2IcRotCos (rhs.theMap2IcRotCos),
theMap2IcRotSin (rhs.theMap2IcRotSin),
theIntrackOffset (rhs.theIntrackOffset),
theCrtrackOffset (rhs.theCrtrackOffset),
theLineGsdCorr (rhs.theLineGsdCorr),
theSampGsdCorr (rhs.theSampGsdCorr),
theRollOffset (rhs.theRollOffset),
theYawOffset (rhs.theYawOffset),
theYawRate (rhs.theYawRate),
theMapRotation (rhs.theMapRotation),
theRollRotMat (rhs.theRollRotMat)
{
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::rspfLandSatModel(rhs): entering..." << std::endl;
initAdjustableParameters();
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::rspfLandSatModel(rhs): returning..." << std::endl;
}
ossimPpjFrameSensor::ossimPpjFrameSensor()
:
m_ecef2Cam(),
m_ecef2CamInverse(),
m_principalPoint(0.0, 0.0),
m_focalLengthX(0.0),
m_focalLengthY(0.0),
m_focalLength(0.0),
m_ecefCameraPosition(),
m_cameraPositionEllipsoid(),
m_radialK1(0.0),
m_radialK2(0.0),
m_radialP1(0.0),
m_radialP2(0.0),
m_adjustedCameraPosition(),
m_adjustedFocalLength(0.0),
m_averageProjectedHeight(0.0)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimPpjFrameSensor::ossimPpjFrameSensor DEBUG:" << std::endl;
}
initAdjustableParameters();
theSensorID = "PpjFrame";
m_ecef2Cam.ReSize(3,3);
m_ecef2CamInverse.ReSize(3,3);
std::fill(m_ecef2Cam.Store(), m_ecef2Cam.Store()+9, 0.0);
std::fill(m_ecef2CamInverse.Store(), m_ecef2CamInverse.Store()+9, 0.0);
m_ecef2Cam[0][0] = 1.0;
m_ecef2Cam[1][1] = 1.0;
m_ecef2Cam[2][2] = 1.0;
m_ecef2CamInverse[0][0] = 1.0;
m_ecef2CamInverse[1][1] = 1.0;
m_ecef2CamInverse[2][2] = 1.0;
}
bool ossimAlphaSensorHSI::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimAlphaSensorHSI::loadState DEBUG:" << std::endl;
}
ossimAlphaSensor::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
updateModel();
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimAlphaSensorHSI::loadState complete..." << std::endl;
}
return true;
}
rspfBuckeyeSensor::rspfBuckeyeSensor()
{
m_lensDistortion = new rspfSmacCallibrationSystem;
initAdjustableParameters();
}
void rspfLandSatModel::initFromHeader(const rspfFfL7& head)
{
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::initFromHeader: entering..." << std::endl;
theRefGndPt = head.theCenterGP;
theRefImgPt = head.theCenterImagePoint;
theImageSize.x = head.thePixelsPerLine;
theImageSize.y = head.theLinesPerBand;
theImageID = head.theRequestNumber;
theSensorID = head.theSatName;
theSensorDATE = head.theAcquisitionDate;
theImageClipRect = rspfDrect(0, 0, theImageSize.x-1, theImageSize.y-1);
theGSD.samp = head.theGsd;
theGSD.line = head.theGsd;
theIllumAzimuth = head.theSunAzimuth;
theIllumElevation = head.theSunElevation;
theMapZone = head.theUsgsMapZone;
theWrsPathNumber = head.thePathNumber;
theWrsRowNumber = head.theRowNumber;
theRollOffset = head.theOffNadirAngle;
theMeanGSD = head.theGsd;
m_scale=head.theProjectionParams[2];
m_centerLongitude=(int)(head.theProjectionParams[4]+0.01)*1.0;
m_theMapoffsetX=head.theProjectionParams[6];
m_theMapoffsetY=head.theProjectionParams[5];
semi_major=head.theProjectionParams[0];
semi_minor=head.theProjectionParams[1];
//int longcenter=(int)(head.theProjectionParams[4]+0.5);
//theProjectionParams[4]=(double)longcenter;
rspfString satname(head.theSatName);
if (satname.contains("7"))
{
theOrbitAltitude = L7_ORBIT_ALTITUDE;
theOrbitInclination = L7_ORBIT_INCLINATION;
theNominalPosError = L7_NOMINAL_POS_ERROR;
} else if (satname.contains("5"))
{
theOrbitAltitude = L5_ORBIT_ALTITUDE;
theOrbitInclination = L5_ORBIT_INCLINATION;
theNominalPosError = L5_NOMINAL_POS_ERROR;
} else {
theErrorStatus = 1; //MODEL_ERROR
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_WARN) << "WARNING rspfLandSatModel::initFromHeader: " << "Unknown satellite name : " << satname << std::endl;
}
}
double phi_c = rspf::atand(rspf::tand(theRefGndPt.lat)/
GEODETIC_2_GEOCENTRIC_FACTOR);
double cos_phi_c = rspf::cosd(phi_c);
theMeridianalAngle = -rspf::asind(rspf::cosd(theOrbitInclination) / cos_phi_c);
theMapAzimAngle = head.theOrientationAngle;
rspfDpt v[4]; // temporarily holds vertices for ground polygon
v[0] = head.theUL_Corner;
v[1] = head.theUR_Corner;
v[2] = head.theLR_Corner;
v[3] = head.theLL_Corner;
theBoundGndPolygon = rspfPolygon(4, v);
rspfString orient_type = head.theProductType;
rspfString proj_type = head.theMapProjectionName;
proj_type.trim();
if (proj_type.contains("SOM"))
{
if (orient_type.contains("ORBIT"))
theProjectionType = SOM_ORBIT;
else
theProjectionType = SOM_MAP;
theMapAzimAngle -= 90.0;
}
else if (proj_type.contains("UTM"))
{
if (orient_type.contains("ORBIT"))
theProjectionType = UTM_ORBIT;
else
theProjectionType = UTM_MAP;
}
else if (proj_type.contains("TM"))
{
if (orient_type.contains("ORBIT"))
theProjectionType = TM_ORBIT;
else
theProjectionType = TM_MAP;
}
else
{
theErrorStatus = 1; //MODEL_ERROR
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_WARN) << "WARNING rspfLandSatModel::initFromHeader: "
<< "Unknown projection/orientation type." << std::endl;
}
return;
}
initMapProjection();
theMapOffset = theMapProjection->forward(head.theUL_Corner);
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "DEBUG rspfLandSatModel::initFromHeader:"
<< "\ntheMapProjection:\n";
theMapProjection->print(rspfNotify(rspfNotifyLevel_DEBUG));
rspfNotify(rspfNotifyLevel_DEBUG)
<< "\nHeader upper left ground point: " << head.theUL_Corner
<< std::endl;
}
initAdjustableParameters();
updateModel();
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::initFromHeader: returning..." << std::endl;
}
bool ossimSpectraboticsRedEdgeModel::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
if(traceDebug())
{
std::cout << "ossimSpectraboticsRedEdgeModel::loadState: ......... entered" << std::endl;
}
//ossimSensorModel::loadState(kwl,prefix);
ossimSensorModel::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
m_ecefPlatformPosition = ossimGpt(0.0,0.0,1000.0);
m_adjEcefPlatformPosition = ossimGpt(0.0,0.0,1000.0);
m_roll = 0.0;
m_pitch = 0.0;
m_heading = 0.0;
// bool computeGsdFlag = false;
const char* roll = kwl.find(prefix, "Roll");
const char* pitch = kwl.find(prefix, "Pitch");
const char* heading = kwl.find(prefix, "Yaw");
const char* focalLength = kwl.find(prefix, "Focal Length");
const char* imageWidth = kwl.find(prefix, "Image Width");
const char* imageHeight = kwl.find(prefix, "Image Height");
const char* fov = kwl.find(prefix, "Field Of View");
const char* gpsPos = kwl.find(prefix, "GPS Position");
const char* gpsAlt = kwl.find(prefix, "GPS Altitude");
const char* imageCenter = kwl.find(prefix, "Image Center");
const char* fx = kwl.find(prefix, "fx");
const char* fy = kwl.find(prefix, "fy");
const char* cx = kwl.find(prefix, "cx");
const char* cy = kwl.find(prefix, "cy");
const char* k = kwl.find(prefix, "k");
const char* p = kwl.find(prefix, "p");
bool result = true;
#if 0
std::cout << "roll: " << roll << "\n";
std::cout << "pitch: " << pitch << "\n";
std::cout << "heading: " << heading << "\n";
std::cout << "focalLength: " << focalLength << "\n";
std::cout << "imageWidth: " << imageWidth << "\n";
std::cout << "imageHeight: " << imageHeight << "\n";
// std::cout << "fov: " << fov << "\n";
std::cout << "gpsPos: " << gpsPos << "\n";
std::cout << "gpsAlt: " << gpsAlt << "\n";
#endif
//
if(k&&p)
{
m_lensDistortion = new ossimTangentialRadialLensDistortion();
m_lensDistortion->loadState(kwl, prefix);
}
if(roll&&
pitch&&
heading&&
focalLength&&
imageWidth&&
imageHeight&&
gpsPos&&
gpsAlt)
{
theSensorID = "MicaSense RedEdge";
m_roll = ossimString(roll).toDouble();
m_pitch = ossimString(pitch).toDouble();
m_heading = ossimString(heading).toDouble();
m_focalLength = ossimString(focalLength).toDouble();
m_fov = fov?ossimString(fov).toDouble():48.8;
theImageSize.x = ossimString(imageWidth).toDouble();
theImageSize.y = ossimString(imageHeight).toDouble();
theImageClipRect = ossimDrect(0,0,theImageSize.x-1,theImageSize.y-1);
theRefImgPt = ossimDpt(theImageSize.x/2.0, theImageSize.y/2.0);
m_calibratedCenter = theImageClipRect.midPoint();
// now lets use the field of view and the focal length to
// calculate the pixel size on the ccd in millimeters
double d = tan((m_fov*0.5)*M_PI/180.0)*m_focalLength;
d*=2.0;
double tempRadiusPixel = theImageSize.length();
m_pixelSize.x = (d)/tempRadiusPixel;
m_pixelSize.y = m_pixelSize.x;
if(imageCenter)
{
std::vector<ossimString> splitString;
ossimString tempString(imageCenter);
tempString.split(splitString, ossimString(" "));
if(splitString.size() == 2)
{
theRefImgPt = ossimDpt(splitString[0].toDouble(), splitString[1].toDouble());
}
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No Image Center found" << std::endl;
// result = false;
}
}
// now extract the GPS position and shift it to the ellipsoidal height.
std::vector<ossimString> splitArray;
ossimString(gpsPos).split(splitArray, ",");
splitArray[0] = splitArray[0].replaceAllThatMatch("deg", " ");
splitArray[1] = splitArray[1].replaceAllThatMatch("deg", " ");
ossimDms dmsLat;
ossimDms dmsLon;
double h = ossimString(gpsAlt).toDouble();
dmsLat.setDegrees(splitArray[0]);
dmsLon.setDegrees(splitArray[1]);
double lat = dmsLat.getDegrees();
double lon = dmsLon.getDegrees();
h = h+ossimGeoidManager::instance()->offsetFromEllipsoid(ossimGpt(lat,lon));
m_ecefPlatformPosition = ossimGpt(lat,lon,h);
// double height1 = ossimElevManager::instance()->getHeightAboveEllipsoid(ossimGpt(lat, lon));
//std::cout << "PLATFORM HEIGHT: " << h << "\n"
// << "ELEVATION: " << height1 << "\n";
// std::cout << m_ecefPlatformPosition << std::endl;
// std::cout << "POINT: " << ossimGpt(lat,lon,h) << std::endl;
// std::cout << "MSL: " << height1 << "\n";
theRefGndPt = m_ecefPlatformPosition;
theRefGndPt.height(0.0);
m_norm = ossim::nan();
// lens parameters
if(m_lensDistortion.valid()&&cx&&cy&&fx&&fy)
{
m_focalX = ossimString(fx).toDouble();
m_focalY = ossimString(fy).toDouble();
// our lens distorion assume center point. So
// lets shift to center and then set calibrated relative to
// image center. We will then normalize.
//
ossimDpt focal(m_focalX,m_focalY);
m_norm = focal.length()*0.5; // convert from diameter to radial
m_calibratedCenter = ossimDpt(ossimString(cx).toDouble(), ossimString(cy).toDouble());
m_principalPoint = m_calibratedCenter-theImageClipRect.midPoint();
m_principalPoint.x /= m_norm;
m_principalPoint.y /= m_norm;
// lets initialize the root to be about one pixel norm along the diagonal
// and the convergence will be approximately 100th of a pixel.
//
double temp = m_norm;
if(temp < FLT_EPSILON) temp = 1.0;
else temp = 1.0/temp;
m_lensDistortion->setCenter(m_principalPoint);
m_lensDistortion->setDxDy(ossimDpt(temp,temp));
m_lensDistortion->setConvergenceThreshold(temp*0.001);
}
else
{
m_lensDistortion = 0;
m_calibratedCenter = theImageClipRect.midPoint();
m_norm = theImageSize.length()*0.5;
m_principalPoint = ossimDpt(0,0);
}
updateModel();
}
else // load from regular save state
{
const char* principal_point = kwl.find(prefix, "principal_point");
const char* pixel_size = kwl.find(prefix, "pixel_size");
const char* ecef_platform_position = kwl.find(prefix, "ecef_platform_position");
const char* latlonh_platform_position = kwl.find(prefix, "latlonh_platform_position");
// const char* compute_gsd_flag = kwl.find(prefix, "compute_gsd_flag");
roll = kwl.find(prefix, "roll");
pitch = kwl.find(prefix, "pitch");
heading = kwl.find(prefix, "heading");
fov = kwl.find(prefix, "field_of_view");
focalLength = kwl.find(prefix, "focal_length");
if(roll)
{
m_roll = ossimString(roll).toDouble();
}
if(pitch)
{
m_pitch = ossimString(pitch).toDouble();
}
if(heading)
{
m_heading = ossimString(heading).toDouble();
}
if(cx&&cy)
{
m_calibratedCenter = ossimDpt(ossimString(cx).toDouble(), ossimString(cy).toDouble());
}
if(principal_point)
{
std::vector<ossimString> splitString;
ossimString tempString(principal_point);
tempString.split(splitString, ossimString(" "));
if(splitString.size() == 2)
{
m_principalPoint.x = splitString[0].toDouble();
m_principalPoint.y = splitString[1].toDouble();
}
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No principal_point found" << std::endl;
// result = false;
}
}
if(pixel_size)
{
std::vector<ossimString> splitString;
ossimString tempString(pixel_size);
tempString.split(splitString, ossimString(" "));
if(splitString.size() == 1)
{
m_pixelSize.x = splitString[0].toDouble();
m_pixelSize.y = m_pixelSize.x;
}
else if(splitString.size() == 2)
{
m_pixelSize.x = splitString[0].toDouble();
m_pixelSize.y = splitString[1].toDouble();
}
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No pixel size found" << std::endl;
// result = false;
}
}
if(ecef_platform_position)
{
std::vector<ossimString> splitString;
ossimString tempString(ecef_platform_position);
tempString.split(splitString, ossimString(" "));
if(splitString.size() > 2)
{
m_ecefPlatformPosition = ossimEcefPoint(splitString[0].toDouble(),
splitString[1].toDouble(),
splitString[2].toDouble());
}
}
else if(latlonh_platform_position)
{
std::vector<ossimString> splitString;
ossimString tempString(latlonh_platform_position);
tempString.split(splitString, ossimString(" "));
std::string datumString;
double lat=0.0, lon=0.0, h=0.0;
if(splitString.size() > 2)
{
lat = splitString[0].toDouble();
lon = splitString[1].toDouble();
h = splitString[2].toDouble();
}
m_ecefPlatformPosition = ossimGpt(lat,lon,h);
}
if(focalLength)
{
m_focalLength = ossimString(focalLength).toDouble();
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No focal length found" << std::endl;
result = false;
}
}
if(fov)
{
m_fov = ossimString(fov).toDouble();
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No field of view found" << std::endl;
result = false;
}
}
theRefGndPt = m_ecefPlatformPosition;
if(m_lensDistortion.valid()&&cx&&cy&&fx&&fy)
{
m_focalX = ossimString(fx).toDouble();
m_focalY = ossimString(fy).toDouble();
// our lens distorion assume center point. So
// lets shift to center and then set calibrated relative to
// image center. We will then normalize.
//
ossimDpt focal(m_focalX,m_focalY);
m_norm = focal.length()*0.5;
m_calibratedCenter = ossimDpt(ossimString(cx).toDouble(), ossimString(cy).toDouble());
// m_principalPoint = m_calibratedCenter-theImageClipRect.midPoint();
// m_principalPoint.x /= m_norm;
// m_principalPoint.y /= m_norm;
// lets initialize the root to be about one pixel norm along the diagonal
// and the convergence will be approximately 100th of a pixel.
//
double temp = m_norm;
if(temp < FLT_EPSILON) temp = 1.0;
else temp = 1.0/temp;
m_lensDistortion->setCenter(m_principalPoint);
m_lensDistortion->setDxDy(ossimDpt(temp,temp));
m_lensDistortion->setConvergenceThreshold(temp*0.001);
}
else
{
m_lensDistortion = 0;
}
updateModel();
}
try
{
//---
// This will set theGSD and theMeanGSD. Method throws
// ossimException.
//---
computeGsd();
}
catch (const ossimException& e)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimSpectraboticsRedEdgeModel::loadState Caught Exception:\n"
<< e.what() << std::endl;
}
// std::cout << "METERS PER PIXEL : " << getMetersPerPixel() << std::endl;
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << std::setprecision(15) << std::endl;
ossimNotify(ossimNotifyLevel_DEBUG) << "roll: " << m_roll << std::endl
<< "pitch: " << m_pitch << std::endl
<< "heading: " << m_heading << std::endl
<< "platform: " << m_ecefPlatformPosition << std::endl
<< "latlon Platform: " << ossimGpt(m_ecefPlatformPosition) << std::endl
<< "focal len: " << m_focalLength << std::endl
<< "FOV : " << m_fov << std::endl
<< "principal: " << m_principalPoint << std::endl
<< "Ground: " << ossimGpt(m_ecefPlatformPosition) << std::endl;
}
// ossimGpt wpt;
// ossimDpt dpt(100,100);
// lineSampleToWorld(dpt, wpt);
// std::cout << "dpt: " << dpt << "\n"
// << "wpt: " << wpt << "\n";
// worldToLineSample(wpt,dpt);
// std::cout << "dpt: " << dpt << "\n"
// << "wpt: " << wpt << "\n";
return result;
}
bool ossimBuckeyeSensor::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::loadState: entering..." << std::endl;
theImageClipRect = ossimDrect(0,0,8984,6732);
theRefImgPt = ossimDpt(4492, 3366);
ossimSensorModel::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
theEcefPlatformPosition = ossimGpt(0.0,0.0,1000.0);
theAdjEcefPlatformPosition = ossimGpt(0.0,0.0,1000.0);
theRoll = 0.0;
thePitch = 0.0;
theHeading = 0.0;
ossimString framemeta_gsti = kwl.find(prefix, "framemeta_gsti");
ossimString framemeta = kwl.find(prefix,"framemeta");
ossimString frame_number = kwl.find(prefix, "frame_number");
ossimString pixel_size = kwl.find(prefix, "pixel_size");
ossimString principal_point = kwl.find(prefix, "principal_point");
ossimString focal_length = kwl.find(prefix, "focal_length");
ossimString smac_radial = kwl.find(prefix, "smac_radial");
ossimString smac_decent = kwl.find(prefix, "smac_decent");
ossimString roll;
ossimString pitch;
ossimString yaw;
ossimString platform_position;
ossimFilename file_to_load;
ossimString FRAME_STRING = "Frame#";
ossimString ROLL_STRING = "Roll(deg)";
ossimString PITCH_STRING = "Pitch(deg)";
ossimString YAW_STRING = "Yaw(deg)";
ossimString LAT_STRING = "Lat(deg)";
ossimString LON_STRING = "Lon(deg)";
ossimString HAE_STRING = "HAE(m)";
// Deal with the fact that there are 3 different types of 'FrameMeta' file
if (framemeta_gsti.empty() && !framemeta.empty() && !frame_number.empty())
{
file_to_load.setFile(framemeta);
YAW_STRING = "Azimuth(deg)";
}
else if (!framemeta_gsti.empty() && framemeta.empty() && !frame_number.empty())
{
file_to_load.setFile(framemeta_gsti);
}
if (file_to_load.exists() && !frame_number.empty())
{
ossimCsvFile csv(" \t"); // we will use tab or spaces as seaparator
if(csv.open(file_to_load))
{
if(csv.readHeader())
{
ossimCsvFile::StringListType heads = csv.fieldHeaderList();
// Try to see if you can find the first header item, if not, then you either have a file that doesn't work in this case, or it's uppercase
if (std::find(heads.begin(), heads.end(), FRAME_STRING) == heads.end())
{
FRAME_STRING = FRAME_STRING.upcase();
ROLL_STRING = ROLL_STRING.upcase();
PITCH_STRING = PITCH_STRING.upcase();
YAW_STRING = YAW_STRING.upcase();
LAT_STRING = LAT_STRING.upcase();
LON_STRING = LON_STRING.upcase();
HAE_STRING = HAE_STRING.upcase();
}
ossimRefPtr<ossimCsvFile::Record> record;
bool foundFrameNumber = false;
while( ((record = csv.nextRecord()).valid()) && !foundFrameNumber)
{
if( (*record)[FRAME_STRING] == frame_number)
{
foundFrameNumber = true;
roll = (*record)[ROLL_STRING];
pitch = (*record)[PITCH_STRING];
yaw = (*record)[YAW_STRING];
platform_position = (*record)[LAT_STRING] + " "
+ (*record)[LON_STRING]+ " "
+ (*record)[HAE_STRING] + " WGE";
}
}
}
}
csv.close();
}
else
{
roll = kwl.find(prefix, "roll");
pitch = kwl.find(prefix, "pitch");
yaw = kwl.find(prefix, "heading");
platform_position = kwl.find(prefix, "ecef_platform_position");
}
bool result = (!pixel_size.empty()&&
!principal_point.empty()&&
!focal_length.empty()&&
!platform_position.empty());
if(!focal_length.empty())
{
theFocalLength = focal_length.toDouble();
}
if(!pixel_size.empty())
{
thePixelSize.toPoint(pixel_size);
}
if(!roll.empty())
{
theRoll = roll.toDouble();
}
if(!pitch.empty())
{
thePitch = pitch.toDouble();
}
if(!yaw.empty())
{
theHeading = yaw.toDouble();
}
if(!principal_point.empty())
{
thePrincipalPoint.toPoint(principal_point);
}
if(platform_position.contains("WGE"))
{
std::vector<ossimString> splitString;
ossimString tempString(platform_position);
tempString.split(splitString, ossimString(" "));
std::string datumString;
double lat=0.0, lon=0.0, h=0.0;
if(splitString.size() > 2)
{
lat = splitString[0].toDouble();
lon = splitString[1].toDouble();
h = splitString[2].toDouble();
}
theEcefPlatformPosition = ossimGpt(lat,lon,h);
} else {
std::vector<ossimString> splitString;
ossimString tempString(platform_position);
tempString.split(splitString, ossimString(" "));
std::string datumString;
double x=0.0, y=0.0, z=0.0;
if(splitString.size() > 2)
{
x = splitString[0].toDouble();
y = splitString[1].toDouble();
z = splitString[2].toDouble();
}
theEcefPlatformPosition = ossimEcefPoint(x, y, z);
}
theLensDistortion = 0;
if(!smac_radial.empty()&&
!smac_decent.empty())
{
std::vector<ossimString> radial;
std::vector<ossimString> decent;
smac_radial.split(radial, " ");
smac_decent.split(decent, " ");
if((radial.size() == 5)&&
(decent.size() == 4))
{
// Just for debugging really.. optomization will make this sleeker
double k0 = radial[0].toDouble();
double k1 = radial[1].toDouble();
double k2 = radial[2].toDouble();
double k3 = radial[3].toDouble();
double k4 = radial[4].toDouble();
double p0 = decent[0].toDouble();
double p1 = decent[1].toDouble();
double p2 = decent[2].toDouble();
double p3 = decent[3].toDouble();
//theLensDistortion = new ossimSmacCallibrationSystem(radial[0].toDouble(),
// radial[1].toDouble(),
// radial[2].toDouble(),
// radial[3].toDouble(),
// radial[4].toDouble(),
// decent[0].toDouble(),
// decent[1].toDouble(),
// decent[2].toDouble(),
// decent[3].toDouble());
theLensDistortion = new ossimSmacCallibrationSystem(k0,k1,k2,k3,k4,p0,p1,p2,p3);
}
}
theImageSize = ossimDpt(theImageClipRect.width(),
theImageClipRect.height());
updateModel();
if(theGSD.isNan())
{
try
{
// This will set theGSD and theMeanGSD. Method throws ossimException.
computeGsd();
}
catch (const ossimException& e)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimBuckeyeSensor::loadState Caught Exception:\n"
<< e.what() << std::endl;
}
}
}
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::loadState: returning..." << std::endl;
return result;
}
bool rspfLandSatModel::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::loadState: entering..." << std::endl;
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::loadState:"
<< "\nInput kwl: " << kwl
<< std::endl;
}
const char* value = NULL;
const char* keyword =NULL;
bool success;
value = kwl.find(prefix, rspfKeywordNames::TYPE_KW);
if (!value || (strcmp(value, TYPE_NAME(this))))
{
theErrorStatus = 1;
return false;
}
if(getNumberOfAdjustableParameters() != NUM_ADJUSTABLE_PARAMS)
{
initAdjustableParameters();
}
success = rspfSensorModel::loadState(kwl, prefix);
if (!success)
{
theErrorStatus++;
return false;
}
keyword = PROJECTION_TYPE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theProjectionType = (ProjectionType) atoi(value);
keyword = MAP_ZONE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theMapZone = atoi(value);
if(theMapZone==0) {
/* static const char* MAP_SCALE_KW = "theMapScale";
static const char* MAP_CENTER_LONGITUDE_KW = "theMapCenterLongitude";
static const char* MAP_OFFSET_LONGITUDE_KW = "theMapoffsetX";
static const char* MAP_OFFSET_LATITUDE_KW = "theMapoffsetY";
double m_scale;
double m_centerLongitude;
double m_theMapoffsetX;
double m_theMapoffsetY;*/
keyword = MAP_SCALE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
m_scale = atof(value);
keyword = MAP_CENTER_LONGITUDE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
m_centerLongitude = atof(value);
keyword = MAP_OFFSET_LONGITUDE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
m_theMapoffsetX = atof(value);
keyword = MAP_OFFSET_LATITUDE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
m_theMapoffsetY = atof(value);
keyword = MAP_SEMI_MAJOR_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
semi_major = atof(value);
keyword = MAP_SEMI_MINOR_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
semi_minor= atof(value);
}
keyword = MAP_OFFSET_X_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theMapOffset.x = atof(value);
keyword = MAP_OFFSET_Y_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theMapOffset.y = atof(value);
keyword = WRS_PATH_NUMBER_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theWrsPathNumber = atoi(value);
keyword = ROW_NUMBER_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theWrsRowNumber = atoi(value);
keyword = ILLUM_AZIMUTH_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theIllumAzimuth = atof(value);
keyword = ILLUM_ELEVATION_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theIllumElevation = atof(value);
keyword = MERIDIANAL_ANGLE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theMeridianalAngle = atof(value);
keyword = ORBIT_ALTITUDE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theOrbitAltitude = atof(value);
keyword = ORBIT_INCLINATION_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theOrbitInclination = atof(value);
keyword = MAP_AZIM_ANGLE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theMapAzimAngle = atof(value);
keyword = MAP_2Ic_ROT_ANGLE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
theErrorStatus++;
return false;
}
theMap2IcRotAngle = atof(value);
theIntrackOffset = 0.0;
theCrtrackOffset = 0.0;
theLineGsdCorr = 0.0;
theSampGsdCorr = 0.0;
theRollOffset = 0.0;
theYawOffset = 0.0;
theYawRate = 0.0;
theMapRotation = 0.0;
initMapProjection();
updateModel();
if (traceExec()) rspfNotify(rspfNotifyLevel_DEBUG) << "DEBUG rspfLandSatModel::loadState: returning..." << std::endl;
return true;
}
bool ossimApplanixUtmModel::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
if(traceDebug())
{
std::cout << "ossimApplanixUtmModel::loadState: ......... entered" << std::endl;
}
theImageClipRect = ossimDrect(0,0,4076,4091);
theRefImgPt = ossimDpt(2046.0, 2038.5);
ossimSensorModel::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
const char* eo_file = kwl.find(prefix, "eo_file");
const char* eo_id = kwl.find(prefix, "eo_id");
const char* omega = kwl.find(prefix, "omega");
const char* phi = kwl.find(prefix, "phi");
const char* kappa = kwl.find(prefix, "kappa");
const char* bore_sight_tx = kwl.find(prefix, "bore_sight_tx");
const char* bore_sight_ty = kwl.find(prefix, "bore_sight_ty");
const char* bore_sight_tz = kwl.find(prefix, "bore_sight_tz");
const char* principal_point = kwl.find(prefix, "principal_point");
const char* pixel_size = kwl.find(prefix, "pixel_size");
const char* focal_length = kwl.find(prefix, "focal_length");
const char* latlonh_platform_position = kwl.find(prefix, "latlonh_platform_position");
const char* utm_platform_position = kwl.find(prefix, "utm_platform_position");
const char* compute_gsd_flag = kwl.find(prefix, "compute_gsd_flag");
const char* utm_zone = kwl.find(prefix, "utm_zone");
const char* utm_hemisphere = kwl.find(prefix, "utm_hemisphere");
const char* camera_file = kwl.find(prefix, "camera_file");
const char* shift_values = kwl.find(prefix, "shift_values");
theCompositeMatrix = ossimMatrix3x3::createIdentity();
theCompositeMatrixInverse = ossimMatrix3x3::createIdentity();
theOmega = 0.0;
thePhi = 0.0;
theKappa = 0.0;
theBoreSightTx = 0.0;
theBoreSightTy = 0.0;
theBoreSightTz = 0.0;
theFocalLength = 55.0;
thePixelSize = ossimDpt(.009, .009);
theEcefPlatformPosition = ossimGpt(0.0,0.0, 1000.0);
bool loadedFromEoFile = false;
if(eo_id)
{
theImageID = eo_id;
}
// loading from standard eo file with given record id
//
if(eo_file)
{
ossimApplanixEOFile eoFile;
if(eoFile.parseFile(ossimFilename(eo_file)))
{
ossimRefPtr<ossimApplanixEORecord> record = eoFile.getRecordGivenId(theImageID);
if(record.valid())
{
loadedFromEoFile = true;
theBoreSightTx = eoFile.getBoreSightTx()/60.0;
theBoreSightTy = eoFile.getBoreSightTy()/60.0;
theBoreSightTz = eoFile.getBoreSightTz()/60.0;
theShiftValues = ossimEcefVector(eoFile.getShiftValuesX(),
eoFile.getShiftValuesY(),
eoFile.getShiftValuesZ());
ossim_int32 easting = eoFile.getFieldIdxLike("EASTING");
ossim_int32 northing = eoFile.getFieldIdxLike("NORTHING");
ossim_int32 height = eoFile.getFieldIdxLike("HEIGHT");
ossim_int32 omega = eoFile.getFieldIdxLike("OMEGA");
ossim_int32 phi = eoFile.getFieldIdxLike("PHI");
ossim_int32 kappa = eoFile.getFieldIdxLike("KAPPA");
if((omega>=0)&&
(phi>=0)&&
(kappa>=0)&&
(height>=0)&&
(easting>=0)&&
(northing>=0))
{
theOmega = (*record)[omega].toDouble();
thePhi = (*record)[phi].toDouble();
theKappa = (*record)[kappa].toDouble();
double h = (*record)[height].toDouble();
ossimString heightType = kwl.find(prefix, "height_type");
if(eoFile.isUtmFrame())
{
theUtmZone = eoFile.getUtmZone();
theUtmHemisphere = eoFile.getUtmHemisphere()=="North"?'N':'S';
ossimUtmProjection utmProj;
utmProj.setZone(theUtmZone);
utmProj.setHemisphere((char)theUtmHemisphere);
theUtmPlatformPosition.x = (*record)[easting].toDouble();
theUtmPlatformPosition.y = (*record)[northing].toDouble();
theUtmPlatformPosition.z = h;
thePlatformPosition = utmProj.inverse(ossimDpt(theUtmPlatformPosition.x,
theUtmPlatformPosition.y));
thePlatformPosition.height(h);
if(eoFile.isHeightAboveMSL())
{
double offset = ossimGeoidManager::instance()->offsetFromEllipsoid(thePlatformPosition);
if(!ossim::isnan(offset))
{
thePlatformPosition.height(h + offset);
theUtmPlatformPosition.z = h + offset;
}
}
}
else
{
return false;
}
}
theEcefPlatformPosition = thePlatformPosition;
}
else
{
return false;
}
}
}
if(!loadedFromEoFile)
{
if(shift_values)
{
std::vector<ossimString> splitString;
ossimString tempString(shift_values);
tempString = tempString.trim();
tempString.split(splitString, " " );
if(splitString.size() == 3)
{
theShiftValues = ossimEcefVector(splitString[0].toDouble(),
splitString[1].toDouble(),
splitString[2].toDouble());
}
}
if(omega&&phi&&kappa)
{
theOmega = ossimString(omega).toDouble();
thePhi = ossimString(phi).toDouble();
theKappa = ossimString(kappa).toDouble();
}
if(bore_sight_tx&&bore_sight_ty&&bore_sight_tz)
{
theBoreSightTx = ossimString(bore_sight_tx).toDouble()/60.0;
theBoreSightTy = ossimString(bore_sight_ty).toDouble()/60.0;
theBoreSightTz = ossimString(bore_sight_tz).toDouble()/60.0;
}
double lat=0.0, lon=0.0, h=0.0;
if(utm_zone)
{
theUtmZone = ossimString(utm_zone).toInt32();
}
if(utm_hemisphere)
{
ossimString hem = utm_hemisphere;
hem = hem.trim();
hem = hem.upcase();
theUtmHemisphere = *(hem.begin());
}
if(utm_platform_position)
{
ossimUtmProjection utmProj;
std::vector<ossimString> splitString;
ossimString tempString(utm_platform_position);
tempString = tempString.trim();
ossimString datumString;
utmProj.setZone(theUtmZone);
utmProj.setHemisphere((char)theUtmHemisphere);
tempString.split(splitString, " ");
if(splitString.size() > 2)
{
theUtmPlatformPosition.x = splitString[0].toDouble();
theUtmPlatformPosition.y = splitString[1].toDouble();
theUtmPlatformPosition.z = splitString[2].toDouble();
}
if(splitString.size() > 3)
{
datumString = splitString[3];
}
const ossimDatum* datum = ossimDatumFactory::instance()->create(datumString);
if(datum)
{
utmProj.setDatum(datum);
}
thePlatformPosition = utmProj.inverse(ossimDpt(theUtmPlatformPosition.x,
theUtmPlatformPosition.y));
thePlatformPosition.height(theUtmPlatformPosition.z);
ossimString heightType = kwl.find(prefix, "height_type");
if(heightType == "msl")
{
double offset = ossimGeoidManager::instance()->offsetFromEllipsoid(thePlatformPosition);
if(ossim::isnan(offset) == false)
{
thePlatformPosition.height(thePlatformPosition.height() + offset);
theUtmPlatformPosition.z = thePlatformPosition.height();
}
}
theEcefPlatformPosition = thePlatformPosition;
}
else if(latlonh_platform_position)
{
std::vector<ossimString> splitString;
ossimString tempString(latlonh_platform_position);
std::string datumString;
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() > 2)
{
lat = splitString[0].toDouble();
lon = splitString[1].toDouble();
h = splitString[2].toDouble();
}
if(splitString.size() > 3)
{
datumString = splitString[3];
}
thePlatformPosition.latd(lat);
thePlatformPosition.lond(lon);
thePlatformPosition.height(h);
const ossimDatum* datum = ossimDatumFactory::instance()->create(datumString);
if(datum)
{
thePlatformPosition.datum(datum);
}
ossimString heightType = kwl.find(prefix, "height_type");
if(heightType == "msl")
{
double offset = ossimGeoidManager::instance()->offsetFromEllipsoid(thePlatformPosition);
if(ossim::isnan(offset) == false)
{
thePlatformPosition.height(thePlatformPosition.height() + offset);
}
}
theEcefPlatformPosition = thePlatformPosition;
}
}
if(principal_point)
{
std::vector<ossimString> splitString;
ossimString tempString(principal_point);
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 2)
{
thePrincipalPoint.x = splitString[0].toDouble();
thePrincipalPoint.y = splitString[1].toDouble();
}
}
if(pixel_size)
{
std::vector<ossimString> splitString;
ossimString tempString(principal_point);
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 2)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = splitString[1].toDouble();
}
}
if(focal_length)
{
theFocalLength = ossimString(focal_length).toDouble();
}
if(camera_file)
{
ossimKeywordlist cameraKwl;
ossimKeywordlist lensKwl;
cameraKwl.add(camera_file);
const char* sensor = cameraKwl.find("sensor");
const char* image_size = cameraKwl.find(prefix, "image_size");
principal_point = cameraKwl.find("principal_point");
focal_length = cameraKwl.find("focal_length");
pixel_size = cameraKwl.find(prefix, "pixel_size");
focal_length = cameraKwl.find(prefix, "focal_length");
const char* distortion_units = cameraKwl.find(prefix, "distortion_units");
ossimUnitConversionTool tool;
ossimUnitType unitType = OSSIM_MILLIMETERS;
if(distortion_units)
{
unitType = (ossimUnitType)ossimUnitTypeLut::instance()->getEntryNumber(distortion_units);
if(unitType == OSSIM_UNIT_UNKNOWN)
{
unitType = OSSIM_MILLIMETERS;
}
}
if(image_size)
{
std::vector<ossimString> splitString;
ossimString tempString(image_size);
tempString = tempString.trim();
tempString.split(splitString, " ");
double w=1, h=1;
if(splitString.size() == 2)
{
w = splitString[0].toDouble();
h = splitString[1].toDouble();
}
theImageClipRect = ossimDrect(0,0,w-1,h-1);
theRefImgPt = ossimDpt(w/2.0, h/2.0);
}
if(sensor)
{
theSensorID = sensor;
}
if(principal_point)
{
std::vector<ossimString> splitString;
ossimString tempString(principal_point);
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 2)
{
thePrincipalPoint.x = splitString[0].toDouble();
thePrincipalPoint.y = splitString[1].toDouble();
}
}
if(pixel_size)
{
std::vector<ossimString> splitString;
ossimString tempString(pixel_size);
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 1)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = thePixelSize.x;
}
else if(splitString.size() == 2)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = splitString[1].toDouble();
}
}
if(focal_length)
{
theFocalLength = ossimString(focal_length).toDouble();
}
ossim_uint32 idx = 0;
for(idx = 0; idx < 26; ++idx)
{
const char* value = cameraKwl.find(ossimString("d")+ossimString::toString(idx));
if(value)
{
std::vector<ossimString> splitString;
ossimString tempString(value);
double distance=0.0, distortion=0.0;
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 2)
{
distance = splitString[0].toDouble();
distortion = splitString[1].toDouble();
}
tool.setValue(distortion, unitType);
lensKwl.add(ossimString("distance") + ossimString::toString(idx),
distance,
true);
lensKwl.add(ossimString("distortion") + ossimString::toString(idx),
tool.getMillimeters(),
true);
}
lensKwl.add("convergence_threshold",
.00001,
true);
if(pixel_size)
{
lensKwl.add("dxdy",
ossimString(pixel_size) + " " + ossimString(pixel_size),
true);
}
else
{
lensKwl.add("dxdy",
".009 .009",
true);
}
}
if(theLensDistortion.valid())
{
theLensDistortion->loadState(lensKwl,"");
}
}
else
{
if(principal_point)
{
std::vector<ossimString> splitString;
ossimString tempString(principal_point);
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 2)
{
thePrincipalPoint.x = splitString[0].toDouble();
thePrincipalPoint.y = splitString[1].toDouble();
}
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No principal_point found" << std::endl;
return false;
}
}
if(pixel_size)
{
std::vector<ossimString> splitString;
ossimString tempString(pixel_size);
tempString = tempString.trim();
tempString.split(splitString, " ");
if(splitString.size() == 1)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = thePixelSize.x;
}
else if(splitString.size() == 2)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = splitString[1].toDouble();
}
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No pixel size found" << std::endl;
return false;
}
}
if(focal_length)
{
theFocalLength = ossimString(focal_length).toDouble();
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "No focal length found" << std::endl;
return false;
}
}
if(theLensDistortion.valid())
{
ossimString lensPrefix = ossimString(prefix)+"distortion.";
theLensDistortion->loadState(kwl,
lensPrefix.c_str());
}
}
theRefGndPt = thePlatformPosition;
updateModel();
lineSampleToWorld(theRefImgPt, theRefGndPt);
if(compute_gsd_flag)
{
if(ossimString(compute_gsd_flag).toBool())
{
ossimGpt right;
ossimGpt top;
lineSampleToWorld(theRefImgPt + ossimDpt(1.0, 0.0),
right);
lineSampleToWorld(theRefImgPt + ossimDpt(1.0, 0.0),
top);
ossimEcefVector horizontal = ossimEcefPoint(theRefGndPt)-ossimEcefPoint(right);
ossimEcefVector vertical = ossimEcefPoint(theRefGndPt)-ossimEcefPoint(top);
theGSD.x = horizontal.length();
theGSD.y = vertical.length();
theMeanGSD = (theGSD.x+theGSD.y)*.5;
}
}
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << "theOmega: " << theOmega << std::endl
<< "thePhi: " << thePhi << std::endl
<< "theKappa: " << theKappa << std::endl;
std::cout << "platform position: " << thePlatformPosition << std::endl;
std::cout << "platform position ECF: " << theEcefPlatformPosition << std::endl;
std::cout << "ossimApplanixModel::loadState: ......... leaving" << std::endl;
}
return true;
}
bool ossimPpjFrameSensor::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimPpjFrameSensor::loadState DEBUG:" << std::endl;
}
theGSD.makeNan();
theRefImgPt.makeNan();
ossimSensorModel::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
ossimString principal_point = kwl.find(prefix, "principal_point");
ossimString focal_length_x = kwl.find(prefix, "focal_length_x");
ossimString focal_length_y = kwl.find(prefix, "focal_length_y");
ossimString number_samples = kwl.find(prefix, "number_samples");
ossimString number_lines = kwl.find(prefix, "number_lines");
ossimString ecf_to_cam_row1 = kwl.find(prefix, "ecf_to_cam_row1");
ossimString ecf_to_cam_row2 = kwl.find(prefix, "ecf_to_cam_row2");
ossimString ecf_to_cam_row3 = kwl.find(prefix, "ecf_to_cam_row3");
ossimString platform_position = kwl.find(prefix, "ecef_camera_position");
ossimString averageProjectedHeight = kwl.find(prefix, "average_projected_height");
// ossimString roll;
// ossimString pitch;
// ossimString yaw;
// m_roll = 0;
// m_pitch = 0;
// m_yaw = 0;
// roll = kwl.find(prefix, "roll");
// pitch = kwl.find(prefix, "pitch");
// yaw = kwl.find(prefix, "yaw");
bool result = (!principal_point.empty()&&
!focal_length_x.empty()&&
!platform_position.empty()&&
!ecf_to_cam_row1.empty()&&
!ecf_to_cam_row2.empty()&&
!ecf_to_cam_row3.empty());
if(!averageProjectedHeight.empty())
{
m_averageProjectedHeight = averageProjectedHeight.toDouble();
}
if(!number_samples.empty())
{
theImageSize = ossimIpt(number_samples.toDouble(), number_lines.toDouble());
theRefImgPt = ossimDpt(theImageSize.x*.5, theImageSize.y*.5);
theImageClipRect = ossimDrect(0,0,theImageSize.x-1, theImageSize.y-1);
}
if(theImageClipRect.hasNans())
{
theImageClipRect = ossimDrect(0,0,theImageSize.x-1,theImageSize.y-1);
}
if(theRefImgPt.hasNans())
{
theRefImgPt = theImageClipRect.midPoint();
}
if(!focal_length_x.empty())
{
m_focalLengthX = focal_length_x.toDouble();
m_focalLength = m_focalLengthX;
}
if(!focal_length_y.empty())
{
m_focalLengthY = focal_length_y.toDouble();
}
std::vector<ossimString> row;
if(!ecf_to_cam_row1.empty())
{
row = ecf_to_cam_row1.explode(" ");
for (int i=0; i<3; ++i)
m_ecef2Cam[0][i] = row[i].toDouble();
row = ecf_to_cam_row2.explode(" ");
for (int i=0; i<3; ++i)
m_ecef2Cam[1][i] = row[i].toDouble();
row = ecf_to_cam_row3.explode(" ");
for (int i=0; i<3; ++i)
m_ecef2Cam[2][i] = row[i].toDouble();
m_ecef2CamInverse = m_ecef2Cam.t();
}
// if(!roll.empty())
// {
// m_roll = roll.toDouble();
// }
// if(!pitch.empty())
// {
// m_pitch = pitch.toDouble();
// }
// if(!yaw.empty())
// {
// m_yaw = yaw.toDouble();
// }
if(!principal_point.empty())
{
m_principalPoint.toPoint(principal_point);
}
if(!platform_position.empty())
{
m_ecefCameraPosition.toPoint(platform_position);
m_cameraPositionEllipsoid = ossimGpt(m_ecefCameraPosition);
}
updateModel();
if(theGSD.isNan())
{
try
{
computeGsd();
}
catch (const ossimException& e)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimPpjFrameSensor::loadState Caught Exception:\n"
<< e.what() << std::endl;
}
}
}
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimPpjFrameSensor::loadState complete..." << std::endl;
}
return result;
}
bool rspfBuckeyeSensor::loadState(const rspfKeywordlist& kwl, const char* prefix)
{
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
theGSD.makeNan();
theRefImgPt.makeNan();
rspfSensorModel::loadState(kwl, prefix);
if(theRefImgPt.hasNans())
{
theRefImgPt = theImageClipRect.midPoint();
}
rspfString framemeta_gsti = kwl.find(prefix, "framemeta_gsti");
rspfString frame_number = kwl.find(prefix, "frame_number");
rspfString pixel_size = kwl.find(prefix, "pixel_size");
rspfString principal_point = kwl.find(prefix, "principal_point");
rspfString focal_length = kwl.find(prefix, "focal_length");
rspfString smac_radial = kwl.find(prefix, "smac_radial");
rspfString smac_decent = kwl.find(prefix, "smac_decent");
rspfString roll;
rspfString pitch;
rspfString yaw;
rspfString platform_position;
m_roll = 0;
m_pitch = 0;
m_yaw = 0;
if(!framemeta_gsti.empty()&&
!frame_number.empty())
{
rspfCsvFile csv(" \t"); // we will use tab or spaces as seaparator
if(csv.open(framemeta_gsti))
{
if(csv.readHeader())
{
rspfRefPtr<rspfCsvFile::Record> record;
bool foundFrameNumber = false;
while( ((record = csv.nextRecord()).valid()) && !foundFrameNumber)
{
if( (*record)["Frame#"] == frame_number)
{
foundFrameNumber = true;
roll = (*record)["Roll(deg)"];
pitch = (*record)["Pitch(deg)"];
yaw = (*record)["Yaw(deg)"];
platform_position = "(" + (*record)["Lat(deg)"] + ","
+ (*record)["Lon(deg)"]+ ","
+ (*record)["HAE(m)"] + ",WGE)";
}
}
}
}
}
else
{
roll = kwl.find(prefix, "roll");
pitch = kwl.find(prefix, "pitch");
yaw = kwl.find(prefix, "yaw");
platform_position = kwl.find(prefix, "platform_position");
}
bool result = (!pixel_size.empty()&&
!principal_point.empty()&&
!focal_length.empty()&&
!platform_position.empty());
if(!focal_length.empty())
{
m_focalLength = focal_length.toDouble();
}
if(!pixel_size.empty())
{
m_pixelSize.toPoint(pixel_size);
}
if(!roll.empty())
{
m_roll = roll.toDouble();
}
if(!pitch.empty())
{
m_pitch = pitch.toDouble();
}
if(!yaw.empty())
{
m_yaw = yaw.toDouble();
}
if(!principal_point.empty())
{
m_principalPoint.toPoint(principal_point);
}
if(!platform_position.empty())
{
m_platformPosition.toPoint(platform_position);
}
m_lensDistortion = 0;
if(!smac_radial.empty()&&
!smac_decent.empty())
{
std::vector<rspfString> radial;
std::vector<rspfString> decent;
smac_radial.split(radial, " ");
smac_decent.split(decent, " ");
if((radial.size() == 5)&&
(decent.size() == 4))
{
m_lensDistortion = new rspfSmacCallibrationSystem(radial[0].toDouble(),
radial[1].toDouble(),
radial[2].toDouble(),
radial[3].toDouble(),
radial[4].toDouble(),
decent[0].toDouble(),
decent[1].toDouble(),
decent[2].toDouble(),
decent[3].toDouble());
}
}
theImageSize = rspfDpt(theImageClipRect.width(),
theImageClipRect.height());
updateModel();
if(theGSD.isNan())
{
try
{
computeGsd();
}
catch (const rspfException& e)
{
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfBuckeyeSensor::loadState Caught Exception:\n"
<< e.what() << std::endl;
}
}
}
return result;
}
//*****************************************************************************
// METHOD: ossimRpcProjection::loadState()
//
// Restores the model's state from the KWL. This KWL also serves as a
// geometry file.
//
//*****************************************************************************
bool ossimRpcProjection::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection::loadState(): entering..." << std::endl;
const char* value;
const char* keyword;
//***
// Pass on to the base-class for parsing first:
//***
bool success = ossimProjection::loadState(kwl, prefix);
if (!success)
{
theErrorStatus++;
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection::loadState(): returning with error..." << std::endl;
return false;
}
//***
// Continue parsing for local members:
//***
keyword = POLY_TYPE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
thePolyType = (PolynomialType) value[0];
keyword = LINE_SCALE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLineScale = ossimString(value).toDouble();
keyword = SAMP_SCALE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theSampScale = ossimString(value).toDouble();
keyword = LAT_SCALE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLatScale = ossimString(value).toDouble();
keyword = LON_SCALE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLonScale = ossimString(value).toDouble();
keyword = HGT_SCALE_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theHgtScale = ossimString(value).toDouble();
keyword = LINE_OFFSET_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLineOffset = ossimString(value).toDouble();
keyword = SAMP_OFFSET_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theSampOffset = ossimString(value).toDouble();
keyword = LAT_OFFSET_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLatOffset = ossimString(value).toDouble();
keyword = LON_OFFSET_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLonOffset = ossimString(value).toDouble();
keyword = HGT_OFFSET_KW;
value = kwl.find(prefix, keyword);
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theHgtOffset = ossimString(value).toDouble();
for (int i=0; i<NUM_COEFFS; i++)
{
value = kwl.find(prefix, (LINE_NUM_COEF_KW+ossimString::toString(i)).c_str());
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLineNumCoef[i] = ossimString(value).toDouble();
value = kwl.find(prefix, (LINE_DEN_COEF_KW+ossimString::toString(i)).c_str());
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theLineDenCoef[i] = ossimString(value).toDouble();
value = kwl.find(prefix, (SAMP_NUM_COEF_KW+ossimString::toString(i)).c_str());
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theSampNumCoef[i] = ossimString(value).toDouble();
value = kwl.find(prefix, (SAMP_DEN_COEF_KW+ossimString::toString(i)).c_str());
if (!value)
{
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimRpcProjection::loadState(): Error encountered parsing the following required keyword: "
<< "<" << keyword << ">. Check the keywordlist for proper syntax."
<< std::endl;
return false;
}
theSampDenCoef[i] = ossimString(value).toDouble();
}
loadAdjustments(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection::loadState(): returning..." << std::endl;
return true;
}
bool rspfApplanixEcefModel::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
if(traceDebug())
{
std::cout << "rspfApplanixEcefModel::loadState: ......... entered" << std::endl;
}
theImageClipRect = rspfDrect(0,0,4076,4091);
theRefImgPt = rspfDpt(2046.0, 2038.5);
rspfSensorModel::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
theEcefPlatformPosition = rspfGpt(0.0,0.0,1000.0);
theAdjEcefPlatformPosition = rspfGpt(0.0,0.0,1000.0);
theRoll = 0.0;
thePitch = 0.0;
theHeading = 0.0;
// bool computeGsdFlag = false;
const char* roll = kwl.find(prefix, "roll");
const char* pitch = kwl.find(prefix, "pitch");
const char* heading = kwl.find(prefix, "heading");
const char* principal_point = kwl.find(prefix, "principal_point");
const char* pixel_size = kwl.find(prefix, "pixel_size");
const char* focal_length = kwl.find(prefix, "focal_length");
const char* ecef_platform_position = kwl.find(prefix, "ecef_platform_position");
const char* latlonh_platform_position = kwl.find(prefix, "latlonh_platform_position");
const char* compute_gsd_flag = kwl.find(prefix, "compute_gsd_flag");
const char* eo_file = kwl.find(prefix, "eo_file");
const char* camera_file = kwl.find(prefix, "camera_file");
const char* eo_id = kwl.find(prefix, "eo_id");
bool result = true;
if(eo_id)
{
theImageID = eo_id;
}
if(eo_file)
{
rspfApplanixEOFile eoFile;
if(eoFile.parseFile(rspfFilename(eo_file)))
{
rspfRefPtr<rspfApplanixEORecord> record = eoFile.getRecordGivenId(theImageID);
if(record.valid())
{
rspf_int32 rollIdx = eoFile.getFieldIdx("ROLL");
rspf_int32 pitchIdx = eoFile.getFieldIdx("PITCH");
rspf_int32 headingIdx = eoFile.getFieldIdx("HEADING");
rspf_int32 xIdx = eoFile.getFieldIdx("X");
rspf_int32 yIdx = eoFile.getFieldIdx("Y");
rspf_int32 zIdx = eoFile.getFieldIdx("Z");
if((rollIdx >= 0)&&
(pitchIdx >= 0)&&
(headingIdx >= 0)&&
(xIdx >= 0)&&
(yIdx >= 0)&&
(zIdx >= 0))
{
theRoll = (*record)[rollIdx].toDouble();
thePitch = (*record)[pitchIdx].toDouble();
theHeading = (*record)[headingIdx].toDouble();
theEcefPlatformPosition = rspfEcefPoint((*record)[xIdx].toDouble(),
(*record)[yIdx].toDouble(),
(*record)[zIdx].toDouble());
theAdjEcefPlatformPosition = theEcefPlatformPosition;
}
else
{
return false;
}
}
else
{
rspfNotify(rspfNotifyLevel_WARN) << "rspfApplanixEcefModel::loadState() Image id " << theImageID << " not found in eo file " << eo_file << std::endl;
return false;
}
}
else
{
return false;
}
// computeGsdFlag = true;
}
else
{
if(roll)
{
theRoll = rspfString(roll).toDouble();
}
if(pitch)
{
thePitch = rspfString(pitch).toDouble();
}
if(heading)
{
theHeading = rspfString(heading).toDouble();
}
if(ecef_platform_position)
{
std::vector<rspfString> splitString;
rspfString tempString(ecef_platform_position);
tempString.split(splitString, rspfString(" "));
if(splitString.size() > 2)
{
theEcefPlatformPosition = rspfEcefPoint(splitString[0].toDouble(),
splitString[1].toDouble(),
splitString[2].toDouble());
}
}
else if(latlonh_platform_position)
{
std::vector<rspfString> splitString;
rspfString tempString(latlonh_platform_position);
tempString.split(splitString, rspfString(" "));
std::string datumString;
double lat=0.0, lon=0.0, h=0.0;
if(splitString.size() > 2)
{
lat = splitString[0].toDouble();
lon = splitString[1].toDouble();
h = splitString[2].toDouble();
}
theEcefPlatformPosition = rspfGpt(lat,lon,h);
}
}
if(camera_file)
{
rspfKeywordlist cameraKwl;
rspfKeywordlist lensKwl;
cameraKwl.add(camera_file);
const char* sensor = cameraKwl.find("sensor");
const char* image_size = cameraKwl.find(prefix, "image_size");
principal_point = cameraKwl.find("principal_point");
focal_length = cameraKwl.find("focal_length");
pixel_size = cameraKwl.find(prefix, "pixel_size");
focal_length = cameraKwl.find(prefix, "focal_length");
const char* distortion_units = cameraKwl.find(prefix, "distortion_units");
rspfUnitConversionTool tool;
rspfUnitType unitType = RSPF_MILLIMETERS;
if(distortion_units)
{
unitType = (rspfUnitType)rspfUnitTypeLut::instance()->getEntryNumber(distortion_units);
if(unitType == RSPF_UNIT_UNKNOWN)
{
unitType = RSPF_MILLIMETERS;
}
}
if(image_size)
{
std::vector<rspfString> splitString;
rspfString tempString(image_size);
tempString.split(splitString, rspfString(" "));
double w=1, h=1;
if(splitString.size() == 2)
{
w = splitString[0].toDouble();
h = splitString[1].toDouble();
}
theImageClipRect = rspfDrect(0,0,w-1,h-1);
theRefImgPt = rspfDpt(w/2.0, h/2.0);
}
if(sensor)
{
theSensorID = sensor;
}
if(principal_point)
{
std::vector<rspfString> splitString;
rspfString tempString(principal_point);
tempString.split(splitString, rspfString(" "));
if(splitString.size() == 2)
{
thePrincipalPoint.x = splitString[0].toDouble();
thePrincipalPoint.y = splitString[1].toDouble();
}
}
if(pixel_size)
{
std::vector<rspfString> splitString;
rspfString tempString(pixel_size);
tempString.split(splitString, rspfString(" "));
if(splitString.size() == 1)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = thePixelSize.x;
}
else if(splitString.size() == 2)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = splitString[1].toDouble();
}
}
if(focal_length)
{
theFocalLength = rspfString(focal_length).toDouble();
}
cameraKwl.trimAllValues();
rspfString regExpression = rspfString("^(") + "d[0-9]+)";
vector<rspfString> keys;
cameraKwl.getSubstringKeyList( keys, regExpression );
long numberOfDistortions = (long)keys.size();
int offset = (int)rspfString("d").size();
rspf_uint32 idx = 0;
std::vector<int> numberList(numberOfDistortions);
for(idx = 0; idx < (int)numberList.size();++idx)
{
rspfString numberStr(keys[idx].begin() + offset,
keys[idx].end());
numberList[idx] = numberStr.toInt();
}
std::sort(numberList.begin(), numberList.end());
double distance=0.0, distortion=0.0;
for(idx = 0; idx < numberList.size(); ++idx)
{
rspfString value = cameraKwl.find(rspfString("d")+rspfString::toString(numberList[idx]));
if(!value.empty())
{
std::istringstream inStr(value.c_str());
inStr >> distance;
rspf::skipws(inStr);
inStr >> distortion;
#if 0
std::vector<rspfString> splitString;
rspfString tempString(value);
tempString = tempString.trim();
tempString.split(splitString, " ");
std::cout << splitString.size() << std::endl;
if(splitString.size() >= 2)
{
distance = splitString[0].toDouble();
distortion = splitString[1].toDouble();
}
#endif
tool.setValue(distortion, unitType);
lensKwl.add(rspfString("distance") + rspfString::toString(idx),
distance,
true);
lensKwl.add(rspfString("distortion") + rspfString::toString(idx),
tool.getMillimeters(),
true);
}
lensKwl.add("convergence_threshold",
.00001,
true);
if(pixel_size)
{
lensKwl.add("dxdy",
rspfString(pixel_size) + " " + rspfString(pixel_size),
true);
}
else
{
lensKwl.add("dxdy",
".009 .009",
true);
}
}
if(theLensDistortion.valid())
{
theLensDistortion->loadState(lensKwl,"");
}
}
