void ossimPpjFrameSensor::updateModel()
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimPpjFrameSensor::updateModel DEBUG:" << std::endl;
}
double deltap = computeParameterOffset(PARAM_ADJ_LAT_OFFSET)/
m_cameraPositionEllipsoid.metersPerDegree().y;
double deltal = computeParameterOffset(PARAM_ADJ_LON_OFFSET)/
m_cameraPositionEllipsoid.metersPerDegree().x;
m_adjustedCameraPosition = ossimGpt(m_cameraPositionEllipsoid.latd() + deltap,
m_cameraPositionEllipsoid.lond() + deltal,
m_cameraPositionEllipsoid.height() + computeParameterOffset(PARAM_ADJ_ALTITUDE_OFFSET));
// TODO Need to add correction matrix to accommodate orientation offsets. It
// shouldn't be done in ECF frame.
// double r = ossim::degreesToRadians(m_roll + computeParameterOffset(PARAM_ADJ_ROLL_OFFSET));
// double p = ossim::degreesToRadians(m_pitch + computeParameterOffset(PARAM_ADJ_PITCH_OFFSET) );
// double y = ossim::degreesToRadians(m_yaw + computeParameterOffset(PARAM_ADJ_YAW_OFFSET));
// NEWMAT::Matrix rollM = ossimMatrix3x3::create(1, 0, 0,
// 0, cos(r), sin(r),
// 0, -sin(r), cos(r));
// NEWMAT::Matrix pitchM = ossimMatrix3x3::create(cos(p), 0, -sin(p),
// 0, 1, 0,
// sin(p), 0, cos(p));
// NEWMAT::Matrix yawM = ossimMatrix3x3::create(cos(y), sin(y), 0,
// -sin(y), cos(y), 0,
// 0,0,1);
m_adjustedFocalLength = m_focalLength + computeParameterOffset(PARAM_ADJ_FOCAL_LENGTH_OFFSET);
try
{
computeGsd();
}
catch(...)
{
}
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimPpjFrameSensor::updateModel complete..." << std::endl;
}
/*
ossimGpt gpt;
lineSampleToWorld(theImageClipRect.ul(),gpt);//+ossimDpt(-w, -h), gpt);
theBoundGndPolygon[0] = gpt;
lineSampleToWorld(theImageClipRect.ur(),gpt);//+ossimDpt(w, -h), gpt);
theBoundGndPolygon[1] = gpt;
lineSampleToWorld(theImageClipRect.lr(),gpt);//+ossimDpt(w, h), gpt);
theBoundGndPolygon[2] = gpt;
lineSampleToWorld(theImageClipRect.ll(),gpt);//+ossimDpt(-w, h), gpt);
theBoundGndPolygon[3] = gpt;
*/
}
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
}
}
//*************************************************************************************************
//! Collects common code among all parsers
//*************************************************************************************************
void rspfQuickbirdRpcModel::finishConstruction()
{
theImageSize.line = theImageClipRect.height();
theImageSize.samp = theImageClipRect.width();
theRefImgPt.line = theImageClipRect.midPoint().y;
theRefImgPt.samp = theImageClipRect.midPoint().x;
theRefGndPt.lat = theLatOffset;
theRefGndPt.lon = theLonOffset;
theRefGndPt.hgt = theHgtOffset;
//---
// NOTE: We must call "updateModel()" to set parameter used by base
// rspfRpcModel prior to calling lineSampleHeightToWorld or all
// the world points will be same.
//---
updateModel();
rspfGpt v0, v1, v2, v3;
lineSampleHeightToWorld(theImageClipRect.ul(), theHgtOffset, v0);
lineSampleHeightToWorld(theImageClipRect.ur(), theHgtOffset, v1);
lineSampleHeightToWorld(theImageClipRect.lr(), theHgtOffset, v2);
lineSampleHeightToWorld(theImageClipRect.ll(), theHgtOffset, v3);
theBoundGndPolygon = rspfPolygon (rspfDpt(v0), rspfDpt(v1), rspfDpt(v2), rspfDpt(v3));
// Set the ground reference point using the model.
lineSampleHeightToWorld(theRefImgPt, theHgtOffset, theRefGndPt);
if( theGSD.hasNans() )
{
try
{
// This will set theGSD and theMeanGSD. Method throws rspfException.
computeGsd();
}
catch (const rspfException& e)
{
rspfNotify(rspfNotifyLevel_WARN)
<< "rspfQuickbirdRpcModel::finishConstruction -- caught exception:\n"
<< e.what() << std::endl;
}
}
}
void ossimAlphaSensorHSI::updateModel()
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimAlphaSensorHSI::updateModel DEBUG:" << std::endl;
}
ossimAlphaSensor::updateModel();
try
{
computeGsd();
}
catch(...)
{
}
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimAlphaSensorHSI::updateModel complete..." << std::endl;
}
// Ref point
lineSampleToWorld(theRefImgPt, theRefGndPt);
// Bounding rectangle
ossimGpt gpt;
theBoundGndPolygon.clear();
lineSampleToWorld(theImageClipRect.ul(),gpt); //+ossimDpt(-w, -h), gpt);
theBoundGndPolygon.addPoint(gpt.lond(), gpt.latd());
lineSampleToWorld(theImageClipRect.ur(),gpt); //+ossimDpt(w, -h), gpt);
theBoundGndPolygon.addPoint(gpt.lond(), gpt.latd());
lineSampleToWorld(theImageClipRect.lr(),gpt); //+ossimDpt(w, h), gpt);
theBoundGndPolygon.addPoint(gpt.lond(), gpt.latd());
lineSampleToWorld(theImageClipRect.ll(),gpt); //+ossimDpt(-w, h), gpt);
theBoundGndPolygon.addPoint(gpt.lond(), gpt.latd());
}
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;
}
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;
}
void ossimRpcModel::setAttributes(ossim_float64 sampleOffset,
ossim_float64 lineOffset,
ossim_float64 sampleScale,
ossim_float64 lineScale,
ossim_float64 latOffset,
ossim_float64 lonOffset,
ossim_float64 heightOffset,
ossim_float64 latScale,
ossim_float64 lonScale,
ossim_float64 heightScale,
const std::vector<double>& xNumeratorCoeffs,
const std::vector<double>& xDenominatorCoeffs,
const std::vector<double>& yNumeratorCoeffs,
const std::vector<double>& yDenominatorCoeffs,
PolynomialType polyType,
bool computeGsdFlag)
{
thePolyType = polyType;
theLineScale = lineScale;
theSampScale = sampleScale;
theLatScale = latScale;
theLonScale = lonScale;
theHgtScale = heightScale;
theLineOffset = lineOffset;
theSampOffset = sampleOffset;
theLatOffset = latOffset;
theLonOffset = lonOffset;
theHgtOffset = heightOffset;
if(xNumeratorCoeffs.size() == 20)
{
std::copy(xNumeratorCoeffs.begin(),
xNumeratorCoeffs.end(),
theSampNumCoef);
}
if(xDenominatorCoeffs.size() == 20)
{
std::copy(xDenominatorCoeffs.begin(),
xDenominatorCoeffs.end(),
theSampDenCoef);
}
if(yNumeratorCoeffs.size() == 20)
{
std::copy(yNumeratorCoeffs.begin(),
yNumeratorCoeffs.end(),
theLineNumCoef);
}
if(yDenominatorCoeffs.size() == 20)
{
std::copy(yDenominatorCoeffs.begin(),
yDenominatorCoeffs.end(),
theLineDenCoef);
}
if(computeGsdFlag)
{
try
{
// This will set theGSD and theMeanGSD. Method throws ossimException.
computeGsd();
}
catch (const ossimException& e)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimRpcModel::setAttributes Caught Exception:\n"
<< e.what() << std::endl;
}
}
}
}
bool rspfNitfRpcModel::parseImageHeader(const rspfNitfImageHeader* ih)
{
if (getRpcData(ih) == false)
{
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfNitfRpcModel::parseFile DEBUG:"
<< "\nError parsing rpc tags. Aborting with error."
<< std::endl;
}
setErrorStatus();
return false;
}
rspfString os = ih->getImageMagnification();
if ( os.contains("/") )
{
os = os.after("/");
rspf_float64 d = os.toFloat64();
if (d)
{
theDecimation = 1.0 / d;
}
}
theImageID = ih->getImageId();
rspfIrect imageRect = ih->getImageRect();
theImageSize.line =
static_cast<rspf_int32>(imageRect.height() / theDecimation);
theImageSize.samp =
static_cast<rspf_int32>(imageRect.width() / theDecimation);
getSensorID(ih);
theRefImgPt.line = theImageSize.line/2.0;
theRefImgPt.samp = theImageSize.samp/2.0;
theRefGndPt.lat = theLatOffset;
theRefGndPt.lon = theLonOffset;
theRefGndPt.hgt = theHgtOffset;
theImageClipRect = rspfDrect(0.0, 0.0,
theImageSize.samp-1, theImageSize.line-1);
rspfGpt v0, v1, v2, v3;
rspfDpt ip0 (0.0, 0.0);
rspfRpcModel::lineSampleHeightToWorld(ip0, theHgtOffset, v0);
rspfDpt ip1 (theImageSize.samp-1.0, 0.0);
rspfRpcModel::lineSampleHeightToWorld(ip1, theHgtOffset, v1);
rspfDpt ip2 (theImageSize.samp-1.0, theImageSize.line-1.0);
rspfRpcModel::lineSampleHeightToWorld(ip2, theHgtOffset, v2);
rspfDpt ip3 (0.0, theImageSize.line-1.0);
rspfRpcModel::lineSampleHeightToWorld(ip3, theHgtOffset, v3);
theBoundGndPolygon
= rspfPolygon (rspfDpt(v0), rspfDpt(v1), rspfDpt(v2), rspfDpt(v3));
updateModel();
rspfRpcModel::lineSampleHeightToWorld(theRefImgPt,
theHgtOffset,
theRefGndPt);
if ( theRefGndPt.isLatNan() || theRefGndPt.isLonNan() )
{
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfNitfRpcModel::rspfNitfRpcModel DEBUG:"
<< "\nGround Reference Point not valid."
<< " Aborting with error..."
<< std::endl;
}
setErrorStatus();
return false;
}
try
{
computeGsd();
}
catch (const rspfException& e)
{
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfNitfRpcModel::rspfNitfRpcModel DEBUG:\n"
<< e.what() << std::endl;
}
}
if (traceExec())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "DEBUG rspfNitfRpcModel::parseFile: returning..."
<< std::endl;
}
return true;
}
bool ossimCsmSensorModel::setSensorModel(const ossimFilename& imageFile,
const ossimFilename& pluginDir,
const ossimString& pluginName,
const ossimString& sensorName)
{
if(m_model)
{
delete m_model; m_model = 0;
}
ossimString error;
m_pluginDir = pluginDir;
m_pluginName = pluginName;
m_sensorName = sensorName;
m_imageFile = imageFile;
if(!m_pluginDir.exists()||!m_imageFile.exists()) return false;
if(!m_sensorName.empty()&&!m_pluginName.empty())
{
m_model = CSMSensorModelLoader::newSensorModel(m_pluginDir.c_str(),
m_pluginName,
m_sensorName.c_str(),
m_imageFile.c_str(), error, false);
if(!error.empty()&&m_model)
{
delete m_model;
m_model = 0;
}
}
else
{
std::vector<string> pluginNames = CSMSensorModelLoader::getAvailablePluginNames(m_pluginDir, error );
ossim_uint32 idx = 0;
for(idx = 0; ((idx < pluginNames.size())&&(!m_model)); ++idx)
{
std::vector<string> sensorModelNames = CSMSensorModelLoader::getAvailableSensorModelNames( pluginDir,
pluginNames[idx].c_str(), error );
ossim_uint32 idx2=0;
for(idx2 = 0; ((idx2 < sensorModelNames.size())&&(!m_model)); ++idx2)
{
error = "";
TSMSensorModel* model = CSMSensorModelLoader::newSensorModel(pluginDir,
pluginNames[idx].c_str(),
sensorModelNames[idx2].c_str(),
m_imageFile.c_str(), error, false);
if(model&&error.empty())
{
m_sensorName = sensorModelNames[idx2].c_str();
m_pluginName = pluginNames[idx];
m_model = model;
}
else if(model)
{
delete model;
model = 0;
}
}
}
}
if(m_model)
{
int nLines, nSamples;
m_model->getImageSize(nLines, nSamples);
theImageClipRect = ossimIrect(-nLines, -nSamples, 2*nLines, 2*nSamples);
theRefImgPt = theImageClipRect.midPoint();
int nParams = 0;
m_model->getNumParameters(nParams);
int idx = 0;
ossimString name;
resizeAdjustableParameterArray(nParams);
double paramValue = 0.0;
TSMMisc::Param_CharType paramType;
for(idx = 0; idx < nParams; ++idx)
{
m_model->getParameterName(idx, name);
m_model->getCurrentParameterValue(idx, paramValue);
setParameterCenter(idx, paramValue);
setAdjustableParameter(idx, 0.0, 1.0);
setParameterDescription(idx, name.c_str());
m_model->getParameterType(idx, paramType);
setParameterUnit(idx, "");
}
try
{
computeGsd();
}
catch (...)
{
}
}
return (m_model != 0);
}
bool ossimNitfRsmModel::parseImageHeader(const ossimNitfImageHeader* ih)
{
static const char MODULE[] = "ossimNitfRsmModel::getRsmData";
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering..." << std::endl;
}
bool status = false;
if ( getRsmData(ih) )
{
theImageID = m_iid.trim();
ossimIrect imageRect = ih->getImageRect();
// Fetch Image Size:
theImageSize.line = static_cast<ossim_int32>(imageRect.height());
theImageSize.samp = static_cast<ossim_int32>(imageRect.width());
// Assign other data members:
theRefImgPt.line = theImageSize.line/2.0;
theRefImgPt.samp = theImageSize.samp/2.0;
// Assign the bounding image space rectangle:
theImageClipRect = ossimDrect(0.0, 0.0, theImageSize.samp-1, theImageSize.line-1);
ossimGpt v0, v1, v2, v3;
ossimDpt ip0 (0.0, 0.0);
lineSampleHeightToWorld(ip0, m_znrmo, v0);
ossimDpt ip1 (theImageSize.samp-1.0, 0.0);
lineSampleHeightToWorld(ip1, m_znrmo, v1);
ossimDpt ip2 (theImageSize.samp-1.0, theImageSize.line-1.0);
lineSampleHeightToWorld(ip2, m_znrmo, v2);
ossimDpt ip3 (0.0, theImageSize.line-1.0);
lineSampleHeightToWorld(ip3, m_znrmo, v3);
theBoundGndPolygon = ossimPolygon (ossimDpt(v0), ossimDpt(v1), ossimDpt(v2), ossimDpt(v3));
updateModel();
// Set the ground reference point.
lineSampleHeightToWorld(theRefImgPt, m_znrmo, theRefGndPt);
// Height could have nan if elevation is not set so check lat, lon individually.
if ( ( theRefGndPt.isLatNan() == false ) && ( theRefGndPt.isLonNan() == false ) )
{
//---
// This will set theGSD and theMeanGSD. This model doesn't need these but
// others do.
//---
try
{
computeGsd();
// Set return status.
status = true;
}
catch (const ossimException& e)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimNitfRpcModel::ossimNitfRpcModel DEBUG:\n"
<< e.what() << std::endl;
}
setErrorStatus();
}
}
else
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimNitfRpcModel::ossimNitfRpcModel DEBUG:"
<< "\nGround Reference Point not valid(has nans)."
<< " Aborting with error..."
<< std::endl;
}
setErrorStatus();
}
}
else
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimNitfRpcModel::parseFile DEBUG:"
<< "\nError parsing rsm tags. Aborting with error."
<< std::endl;
}
setErrorStatus();
}
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< MODULE << " exit status: " << ( status ? "true" : "false" ) << "\n";
}
return status;
} // End: ossimNitfRsmModel::parseImageHeader(const ossimNitfImageHeader* ih)
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 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 ossimNitfRpcModel::parseImageHeader(const ossimNitfImageHeader* ih)
{
// Do this first so we don't waste time if not rpc image.
if (getRpcData(ih) == false)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimNitfRpcModel::parseFile DEBUG:"
<< "\nError parsing rpc tags. Aborting with error."
<< std::endl;
}
setErrorStatus();
return false;
}
//---
// Get the decimation if any from the header "IMAG" field.
//
// Look for string like:
// "/2" = 1/2
// "/4 = 1/4
// ...
// "/16 = 1/16
// If it is full resolution it should be "1.0"
//---
ossimString os = ih->getImageMagnification();
if ( os.contains("/") )
{
os = os.after("/");
ossim_float64 d = os.toFloat64();
if (d)
{
theDecimation = 1.0 / d;
}
}
//***
// Fetch Image ID:
//***
theImageID = ih->getImageId();
ossimIrect imageRect = ih->getImageRect();
//---
// Fetch Image Size:
//---
theImageSize.line =
static_cast<ossim_int32>(imageRect.height() / theDecimation);
theImageSize.samp =
static_cast<ossim_int32>(imageRect.width() / theDecimation);
// Search for the STDID Tag to fetch mission (satellite) name:
getSensorID(ih);
//***
// Assign other data members:
//***
theRefImgPt.line = theImageSize.line/2.0;
theRefImgPt.samp = theImageSize.samp/2.0;
theRefGndPt.lat = theLatOffset;
theRefGndPt.lon = theLonOffset;
theRefGndPt.hgt = theHgtOffset;
//***
// Assign the bounding image space rectangle:
//***
theImageClipRect = ossimDrect(0.0, 0.0,
theImageSize.samp-1, theImageSize.line-1);
//---
// Assign the bounding ground polygon:
//
// NOTE: We will use the base ossimRpcModel for transformation since all
// of our calls are in full image space (not decimated).
//---
ossimGpt v0, v1, v2, v3;
ossimDpt ip0 (0.0, 0.0);
ossimRpcModel::lineSampleHeightToWorld(ip0, theHgtOffset, v0);
ossimDpt ip1 (theImageSize.samp-1.0, 0.0);
ossimRpcModel::lineSampleHeightToWorld(ip1, theHgtOffset, v1);
ossimDpt ip2 (theImageSize.samp-1.0, theImageSize.line-1.0);
ossimRpcModel::lineSampleHeightToWorld(ip2, theHgtOffset, v2);
ossimDpt ip3 (0.0, theImageSize.line-1.0);
ossimRpcModel::lineSampleHeightToWorld(ip3, theHgtOffset, v3);
theBoundGndPolygon
= ossimPolygon (ossimDpt(v0), ossimDpt(v1), ossimDpt(v2), ossimDpt(v3));
updateModel();
// Set the ground reference point.
ossimRpcModel::lineSampleHeightToWorld(theRefImgPt,
theHgtOffset,
theRefGndPt);
if ( theRefGndPt.isLatNan() || theRefGndPt.isLonNan() )
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimNitfRpcModel::ossimNitfRpcModel DEBUG:"
<< "\nGround Reference Point not valid."
<< " Aborting with error..."
<< std::endl;
}
setErrorStatus();
return false;
}
//---
// This will set theGSD and theMeanGSD. This model doesn't need these but
// others do.
//---
try
{
computeGsd();
}
catch (const ossimException& e)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimNitfRpcModel::ossimNitfRpcModel DEBUG:\n"
<< e.what() << std::endl;
}
}
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimNitfRpcModel::parseFile: returning..."
<< std::endl;
}
return true;
}
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: ossimIkonosRpcModel::finishConstruction()
//
//*****************************************************************************
void ossimIkonosRpcModel::finishConstruction()
{
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimIkonosRpcModel finishConstruction(): entering..."
<< std::endl;
}
//***
// Assign other data members:
//***
thePolyType = B; // This may not be true for early RPC imagery
theRefImgPt.line = theLineOffset;
theRefImgPt.samp = theSampOffset;
theRefGndPt.lat = theLatOffset;
theRefGndPt.lon = theLonOffset;
theRefGndPt.hgt = theHgtOffset;
//***
// Assign the bounding image space rectangle:
//***
theImageClipRect = ossimDrect(0.0, 0.0,
theImageSize.samp-1, theImageSize.line-1);
//---
// NOTE: We must call "updateModel()" to set parameter used by base
// ossimRpcModel prior to calling lineSampleHeightToWorld or all
// the world points will be same.
//---
updateModel();
//***
// Assign the bounding ground polygon:
//***
ossimGpt v0, v1, v2, v3;
ossimDpt ip0 (0.0, 0.0);
lineSampleHeightToWorld(ip0, 0.0, v0);
ossimDpt ip1 (theImageSize.samp-1.0, 0.0);
lineSampleHeightToWorld(ip1, 0.0, v1);
ossimDpt ip2 (theImageSize.samp-1.0, theImageSize.line-1.0);
lineSampleHeightToWorld(ip2, 0.0, v2);
ossimDpt ip3 (0.0, theImageSize.line-1.0);
lineSampleHeightToWorld(ip3, 0.0, v3);
theBoundGndPolygon
= ossimPolygon (ossimDpt(v0), ossimDpt(v1), ossimDpt(v2), ossimDpt(v3));
//---
// Call compute gsd:
//
// This will set theGSD and theMeanGSD using lineSampleHeightToWorld on
// three image points. Previously this was pulled from metadata. Some of
// which was in US Survey feet and not converted to meters. This method
// is more accurate as it uses the sensor model to compute.
//---
try
{
// Method throws ossimException.
computeGsd();
}
catch (const ossimException& e)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimIkonosRpcModel finishConstruction Caught Exception:\n"
<< e.what() << std::endl;
}
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimIkonosRpcModel finishConstruction(): returning..."
<< std::endl;
}
}
