ossimDpt ossimRpcProjection::getMetersPerPixel() const
{
ossimDpt result;
// ossimDpt left = ossimDpt(theSampOffset-1,
// theLineOffset);
// ossimDpt right = ossimDpt(theSampOffset+1,
// theLineOffset);
ossimDpt top = ossimDpt(theSampOffset,
theLineOffset-1);
ossimDpt bottom = ossimDpt(theSampOffset,
theLineOffset+1);
// ossimGpt leftG;
// ossimGpt rightG;
ossimGpt topG;
ossimGpt bottomG;
// lineSampleToWorld(left, leftG);
// lineSampleToWorld(right, rightG);
lineSampleToWorld(top, topG);
lineSampleToWorld(bottom, bottomG);
// result.x = (ossimEcefPoint(leftG) - ossimEcefPoint(rightG)).magnitude()/2.0;
result.y = (ossimEcefPoint(topG) - ossimEcefPoint(bottomG)).magnitude()/2.0;
result.x = result.y;
return result;
}
//*****************************************************************************
// METHOD: ossimRpcModel::imagingRay()
//
// Constructs an RPC ray by intersecting 2 ellipsoid heights above and
// below the RPC height offset, and then forming a vector between the two.
//
//*****************************************************************************
void ossimRpcModel::imagingRay(const ossimDpt& imagePoint,
ossimEcefRay& imageRay) const
{
//---
// For "from point", "to point" we want the image ray to be from above the
// ellipsoid down to Earth.
//
// It appears the ray "from point" must be above the ellipsiod for the
// ossimElevSource::intersectRay method; ultimately, the
// ossimEllipsoid::nearestIntersection method, else it goes off in the
// weeds...
//---
// this one is messed up so keep as #if 0 untill tested more
#if 0
ossimGpt gpt;
lineSampleHeightToWorld(imagePoint, theHgtOffset, gpt);
//lineSampleHeightToWorld(imagePoint, ossim::nan(), gpt);
ossimEcefVector v;
if(gpt.datum())
{
if(gpt.datum()->ellipsoid())
{
gpt.datum()->ellipsoid()->gradient(ossimEcefPoint(gpt), v);
v = v.unitVector();
ossimEcefPoint intECFto(gpt);
ossimEcefPoint intECFfrom = (intECFto + v*100000);
ossimEcefRay ray(intECFfrom, intECFto);
imageRay = ray;
}
}
#else
double vectorLength = theHgtScale ? (theHgtScale * 2.0) : 1000.0;
ossimGpt gpt;
// "from" point
double intHgt = theHgtOffset + vectorLength;
lineSampleHeightToWorld(imagePoint, intHgt, gpt);
ossimEcefPoint intECFfrom(gpt);
// "to" point
lineSampleHeightToWorld(imagePoint, theHgtOffset, gpt);
ossimEcefPoint intECFto(gpt);
// Construct ray
ossimEcefRay ray(intECFfrom, intECFto);
imageRay = ray;
#endif
}
ossimGpt ossimThreeParamDatum::shiftToWgs84(const ossimGpt &aPt)const
{
if(ossim::almostEqual(param1(), 0.0)&&
ossim::almostEqual(param2(), 0.0)&&
ossim::almostEqual(param3(), 0.0))
{
return ossimGpt(aPt.latd(),
aPt.lond(),
aPt.latd(),
ossimGpt().datum());
}
ossimEcefPoint p1 = aPt;
ossimEcefPoint p2;
if(withinMolodenskyRange(aPt.latd()))
{
ossimWgs84Datum wgs84;
double latin, lonin, hgtin;
double latout, lonout, hgtout;
double da = wgs84.ellipsoid()->getA() - ellipsoid()->getA();
double df = wgs84.ellipsoid()->getFlattening() - ellipsoid()->getFlattening();
latin = aPt.latr();
lonin = aPt.lonr();
hgtin = aPt.height();
if(aPt.isHgtNan())
{
hgtin = 0.0;
}
molodenskyShift(ellipsoid()->getA(), da, ellipsoid()->getFlattening(), df, param1(), param2(), param3(),
latin, lonin, hgtin,
latout, lonout, hgtout);
ossimGpt g;
g.latr(latout);
g.lonr(lonout);
g.height(hgtout);
g.datum(this);
return g;
}
else
{
p2 = ossimEcefPoint(p1.x() + theParam1,
p1.y() + theParam2,
p1.z() + theParam3);
}
return ossimGpt(p2); // defaults to WGS84
}
void ossimAlphaSensorHSI::worldToLineSample(const ossimGpt& world_point,
ossimDpt& image_point) const
{
// Initialize at middle
ossim_float64 refL = theImageSize.y/2;
ossim_float64 drefL = 5;
int nIter = 0;
ossimColumnVector3d camLOS;
ossimColumnVector3d camLOS1;
// Iterate using Newton's method
while (nIter<3)
{
ossim_float64 Fx[2];
ossim_float64 refl[2];
refl[0] = refL;
refl[1] = refL + drefL;
for (int ll=0; ll<2; ++ll)
{
// Compute camera position & orientation matrix
ossimEcefPoint platPos;
NEWMAT::Matrix cam2EcfRot;
getPositionOrientation(refl[ll], platPos, cam2EcfRot);
// Compute ECF vector
ossimEcefPoint worldPointECF = ossimEcefPoint(world_point);
ossimColumnVector3d ecfLOS = worldPointECF.data() - platPos.data();
// Rotate to camera frame
camLOS = cam2EcfRot.t() * ecfLOS;
if (ll==0)
camLOS1 = camLOS;
// Set function value
ossim_float64 cScanAngle = atan(camLOS[1]/camLOS[2]);
ossim_float64 scanAngle = getScanAngle(refl[ll]);
Fx[ll] = cScanAngle - scanAngle;
}
// Compute numeric 1st derivative & new estimate for reference line (refL)
ossim_float64 dFx = (Fx[1]-Fx[0]) / drefL;
refL -= Fx[0]/dFx;
nIter++;
}
ossim_float64 samp = m_adjustedFocalLength*camLOS1[0]/camLOS1[2] + theImageSize.x/2;
ossimDpt p(samp, refL);
image_point = p;
}
//*****************************************************************************
// CONSTRUCTORS: ossimLsrSpace(ossimGpt, y_azimuth)
//
// This constructor sets up a local coordinate system centered at the
// specified groundpoint, with the Z-axis normal to the ellipsoid and the
// Y-axis rotated clockwise from north by the y_azimuth. This angle defaults
// to 0, producing an East-North-Up system.
//
//*****************************************************************************
ossimLsrSpace::ossimLsrSpace(const ossimGpt& origin,
const double& y_azimuth)
{
//***
// Convert ground point origin to ECEF coordinates:
//***
theOrigin = ossimEcefPoint(origin);
//***
// Establish the component vectors for ENU system::
//***
double sin_lat = ossim::sind(origin.lat);
double cos_lat = ossim::cosd(origin.lat);
double sin_lon = ossim::sind(origin.lon);
double cos_lon = ossim::cosd(origin.lon);
ossimColumnVector3d E (-sin_lon,
cos_lon,
0.0);
ossimColumnVector3d N (-sin_lat*cos_lon,
-sin_lat*sin_lon,
cos_lat);
ossimColumnVector3d U (E.cross(N));
//
// Fill rotation matrix with these components, rotated about the Z axis
// by the azimuth indicated:
//
if (std::abs(y_azimuth) > FLT_EPSILON)
{
double cos_azim = ossim::cosd(y_azimuth);
double sin_azim = ossim::sind(y_azimuth);
ossimColumnVector3d X (cos_azim*E - sin_azim*N);
ossimColumnVector3d Y (sin_azim*E + cos_azim*N);
ossimColumnVector3d Z (X.cross(Y));
theLsrToEcefRotMatrix
= ossimMatrix3x3::create(X[0], Y[0], Z[0],
X[1], Y[1], Z[1],
X[2], Y[2], Z[2]);
}
else
{
//***
// No azimuth rotation, so simplify:
//***
theLsrToEcefRotMatrix = ossimMatrix3x3::create(E[0], N[0], U[0],
E[1], N[1], U[1],
E[2], N[2], U[2]);
}
}
void ossimCsmSensorModel::imagingRay(const ossimDpt& image_point,
ossimEcefRay& image_ray) const
{
if(m_model)
{
double locus[6] = {0.0, 0.0, 0.0,
0.0, 0.0, 0.0};
double AP = 0.0;
m_model->imageToRemoteImagingLocus(image_point.y, image_point.x, locus, AP);
ossimEcefVector v(locus[3], locus[4], locus[5]);
image_ray.setOrigin(ossimEcefPoint(locus[0], locus[1], locus[2]));
image_ray.setDirection(v);
}
}
/*!
* removeOutliers(): use RANdom SAmple Consensus method (RANSAC)
* but stops at the first good fit, without looking for better fits
*/
bool
ossimOutlierRejection::removeOutliers(ossim_float64* result_var_pix2,
ossim_float64* target_var_pix2)
{
//init optional variance to error
if (result_var_pix2!=NULL) *result_var_pix2 = -1.0;
if(!theModel.valid()) return false;
static const double SUCCESS = 0.97; //required chance of success for RANSAC
static const double NSTD = 2.2; //deviations allowed around mean
//check args
if ((theInlierRatio<=0.0) || (theInlierRatio>1.0))
{
ossimNotify(ossimNotifyLevel_WARN) <<
"WARNING: ossimOutlierRejection::removeOutliers() bad theInlierRatio\n";
return false;
}
ossimOptimizableProjection* optProj = PTR_CAST(ossimOptimizableProjection, theModel.get());
if(!optProj) return false;
//direction of transform (cached)
bool useForward = optProj->useForward();
//keep a copy of projection if it needs initialization
ossimKeywordlist initialState;
bool nis=optProj->needsInitialState(); //cached
if (nis)
{
//save state //TBD: make the copy/restore faster
if (!theModel->saveState(initialState))
{
ossimNotify(ossimNotifyLevel_WARN) <<
"WARNING: ossimOutlierRejection::removeOutliers() can't save projection initial state\n";
}
}
// convert error to ground if necessary
double imageToGroundRatio;
if (useForward)
{
imageToGroundRatio = 1.0;
} else {
//convert image error to ground error (meters)
imageToGroundRatio = theModel->getMetersPerPixel().length()/std::sqrt(2.0);
}
double maxFitError = imageToGroundRatio * theInlierImageAccuracy; //either pixels or meters
unsigned long dof = optProj->degreesOfFreedom();
unsigned long dofPerPoint = 2L; //use 2 because only 2 uncorelated equations (height is correlated)
unsigned long miniPts = (dof+ dofPerPoint-1) / dofPerPoint; //TBD: shouldn't be lower than nbsamples
unsigned long miniInliers = (unsigned long)ceil(theTieSet.size()*theInlierRatio);
//calculate maximum number of iterations (average and std)
double probaAllGood = std::pow(theInlierRatio, (int)miniPts);
double avg_iter_max = std::log(SUCCESS) / std::log(1.0-probaAllGood);
double std_iter_max = std::sqrt(1.0-probaAllGood) / probaAllGood;
long iter_max = (long)ceil(avg_iter_max + NSTD * std_iter_max);
ossimNotify(ossimNotifyLevel_WARN) <<
"INFO: max number of RANSAC iterations = "<<iter_max<<"\n"; //TBR
unsigned long nbsamples = theTieSet.size();
ossimNotify(ossimNotifyLevel_WARN) <<
"INFO: samples before RANSAC = "<<nbsamples<<"\n"; //TBR
//array for random draws : init on identity permutation
//high memory cost?
vector<unsigned long> vshuf(nbsamples);
//init random / inliers tie point set from current tie set, but with no ties
ossimTieGptSet randSelection;
randSelection.setMasterPath(theTieSet.getMasterPath());
randSelection.setSlavePath(theTieSet.getSlavePath());
randSelection.setImageCov(theTieSet.getImageCov());
randSelection.setGroundCov(theTieSet.getGroundCov());
double bestfit;
long iterations = 0;
unsigned long npos=0;
while(iterations < iter_max)
{
//TBD: find out why we need to reset that index table at every iteration
for(unsigned long c=0; c<nbsamples; ++c) vshuf[c]=c;
//randomly select miniPts indices
for(unsigned long s=0;s<miniPts;++s)
{
unsigned long rpick = s+(unsigned long)(((double)std::rand())/(1.0+RAND_MAX)*(nbsamples-s)); //between 0 and nbsamples-1 inc.
vshuf[s] = rpick;
vshuf[rpick] = s;
}
//use miniPts random tie points for selection
randSelection.clearTiePoints();
for(unsigned long c=0;c<miniPts;++c) randSelection.addTiePoint( theTieSet.getTiePoints()[vshuf[c]] );
//optimize model with random selection
double fitvar = optProj->optimizeFit(randSelection, NULL); //best possible fit, do not use target variance here
//if optimization goes fine, then test it further
if ((fitvar>=0) && (fitvar <= maxFitError*maxFitError)) //RMS must be below max distance
{
//find other compatible points (and enqueue them)
npos = miniPts;
double perr;
for(unsigned long c=miniPts; c<nbsamples; ++c)
{
ossimRefPtr< ossimTieGpt > rt = theTieSet.getTiePoints()[vshuf[c]];
if (useForward)
{
perr = (theModel->forward(*rt) - rt->tie).length(); //image error, unit pixels
} else {
perr = (ossimEcefPoint(theModel->inverse(rt->tie)) - ossimEcefPoint(*rt)).magnitude(); //ground error, unit meters
}
if (perr <= maxFitError)
{
//keep the indices after the miniPts first elts
vshuf[npos] = c;
vshuf[c] = npos;
++npos;
}
}
//DEBUG TBR
ossimNotify(ossimNotifyLevel_WARN) <<
"INFO: model finds "<<100.0*npos/((double)nbsamples)<<"% inliers\n"; //TBR
if (npos >= miniInliers )
{
//re-optimize model with the new possible inliers :
//-add new inliers to sleection
for(unsigned long c=miniPts;c<npos;++c) randSelection.addTiePoint( theTieSet.getTiePoints()[vshuf[c]] );
//use target variance
if (target_var_pix2!=NULL)
{
ossim_float64 target_var = (*target_var_pix2) * imageToGroundRatio * imageToGroundRatio;
bestfit = optProj->optimizeFit(randSelection, &target_var); //best possible fit with target variance
} else {
bestfit = optProj->optimizeFit(randSelection); //best possible fit
}
//assume fit to be OK (which might NOT be the case...)
//TBD iterate over minimal number of times
break;
}
}
if (nis)
{
//restore initial state //TBD: make the copy/restore faster
if (!theModel->loadState(initialState))
{
ossimNotify(ossimNotifyLevel_WARN) <<
"WARNING: ossimOutlierRejection::removeOutliers() can't reload projection initial state at iteration "<<iterations<<"\n";
}
}
iterations++;
}
if (iterations >= iter_max)
{
ossimNotify(ossimNotifyLevel_WARN) <<
"WARNING: RANSAC didn't find a solution after "<<iterations<<" iterations"<<endl;
return false;
}
//keep inliers
theTieSet = randSelection;
//display results, with RMS always in pixels
ossimNotify(ossimNotifyLevel_WARN) <<
"INFO: RANSAC solution found after "<<iterations<<" iterations, nbinliers="<<npos<<endl;
//convert to pixel2 variance
ossim_float64 variance_pix2 = bestfit / (imageToGroundRatio * imageToGroundRatio);
//normal exit : return optional variance
if (result_var_pix2!=NULL) *result_var_pix2 = variance_pix2;
return true;
}
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 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 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;
}
