USGS

Isis 3.0 Object Programmers' Reference

 Home
ControlNetValidMeasure.cpp
1 #include "ControlNetValidMeasure.h"
2 #include "Cube.h"
3 #include "Camera.h"
4 #include "ControlMeasure.h"
5 #include "CubeManager.h"
6 #include "MeasureValidationResults.h"
7 #include "SerialNumberList.h"
8 #include "SpecialPixel.h"
9 #include "UniversalGroundMap.h"
10 
11 using namespace std;
12 
13 namespace Isis {
14 
23  ControlNetValidMeasure::ControlNetValidMeasure(Pvl *pPvl) {
24  InitStdOptions();
25 
26  if(pPvl != NULL && pPvl->hasGroup("ValidMeasure")) {
27  Parse(*pPvl);
28  }
29  else {
30  InitStdOptionsGroup();
31  }
32  mStatisticsGrp = PvlGroup("Statistics");
33  }
34 
43  ControlNetValidMeasure::ControlNetValidMeasure(Pvl &pPvl) {
44  InitStdOptions();
45 
46  if(pPvl.hasGroup("ValidMeasure")) {
47  Parse(pPvl);
48  }
49  else {
50  InitStdOptionsGroup();
51  }
52  mStatisticsGrp = PvlGroup("Statistics");
53  }
54 
60  void ControlNetValidMeasure::InitStdOptions(void) {
61  mdMinEmissionAngle = 0;
62  mdMaxEmissionAngle = 135;
63  mdMinIncidenceAngle = 0;
64  mdMaxIncidenceAngle = 135;;
65  miPixelsFromEdge = 0;
66  mdMinResolution = 0;
67  mdMaxResolution = DBL_MAX;
68  mdMinDN = Isis::ValidMinimum;
69  mdMaxDN = Isis::ValidMaximum;
70  miPixelsFromEdge = 0;
71  mdMetersFromEdge = 0;
72  mdSampleResTolerance = DBL_MAX;
73  mdLineResTolerance = DBL_MAX;
74  mdResidualTolerance = DBL_MAX;
75  m_sampleShiftTolerance = DBL_MAX;
76  m_lineShiftTolerance = DBL_MAX;
77  m_pixelShiftTolerance = DBL_MAX;
78 
79  mbCameraRequired = false;
80  mbValidateDN = false;
81  mbValidateFromEdge = false;
82  }
83 
89  void ControlNetValidMeasure::InitStdOptionsGroup(void) {
90  mStdOptionsGrp = PvlGroup("StandardOptions");
91 
92  mStdOptionsGrp += Isis::PvlKeyword("MinDN", (mdMinDN == Isis::ValidMinimum ? "NA" : toString(mdMinDN)));
93  mStdOptionsGrp += Isis::PvlKeyword("MaxDN", (mdMaxDN == Isis::ValidMaximum ? "NA" : toString(mdMaxDN)));
94 
95  mStdOptionsGrp += Isis::PvlKeyword("MinEmission", toString(mdMinEmissionAngle));
96  mStdOptionsGrp += Isis::PvlKeyword("MaxEmission", toString(mdMaxEmissionAngle));
97  mStdOptionsGrp += Isis::PvlKeyword("MinIncidence", toString(mdMinIncidenceAngle));
98  mStdOptionsGrp += Isis::PvlKeyword("MaxIncidence", toString(mdMaxIncidenceAngle));
99  mStdOptionsGrp += Isis::PvlKeyword("MinResolution", toString(mdMinResolution));
100  mStdOptionsGrp += Isis::PvlKeyword("MaxResolution", (mdMaxResolution == DBL_MAX ? "NA" : toString(mdSampleResTolerance)));
101  mStdOptionsGrp += Isis::PvlKeyword("PixelsFromEdge", toString(miPixelsFromEdge));
102  mStdOptionsGrp += Isis::PvlKeyword("MetersFromEdge", toString(mdMetersFromEdge));
103 
104  mStdOptionsGrp += Isis::PvlKeyword("SampleResidual", (mdSampleResTolerance == DBL_MAX ? "NA" : toString(mdSampleResTolerance)));
105  mStdOptionsGrp += Isis::PvlKeyword("LineResidual", (mdLineResTolerance == DBL_MAX ? "NA" : toString(mdLineResTolerance)));
106  mStdOptionsGrp += Isis::PvlKeyword("ResidualMagnitude", (mdResidualTolerance == DBL_MAX ? "NA" : toString(mdResidualTolerance)));
107 
108  mStdOptionsGrp += Isis::PvlKeyword("SampleShift", (m_sampleShiftTolerance == DBL_MAX ? "NA" : toString(m_sampleShiftTolerance)));
109  mStdOptionsGrp += Isis::PvlKeyword("LineShift", (m_lineShiftTolerance == DBL_MAX ? "NA" : toString(m_lineShiftTolerance)));
110  mStdOptionsGrp += Isis::PvlKeyword("PixelShift", (m_pixelShiftTolerance == DBL_MAX ? "NA" : toString(m_pixelShiftTolerance)));
111  }
112 
118  ControlNetValidMeasure::~ControlNetValidMeasure() {
119  mCubeMgr.CleanCubes();
120  }
121 
130  void ControlNetValidMeasure::ReadSerialNumbers(QString psSerialNumfile) {
131  mSerialNumbers = SerialNumberList(psSerialNumfile, true, &mStatus);
132 
133  mCubeMgr.SetNumOpenCubes(50);
134  }
135 
144  void ControlNetValidMeasure::Parse(Pvl &pvlDef) {
145  mPvlOpGrp = pvlDef.findGroup("ValidMeasure", Pvl::Traverse);
146 
147  mStdOptionsGrp = PvlGroup("StandardOptions");
148 
149  ValidatePvlDN();
150  ValidatePvlEmissionAngle();
151  ValidatePvlIncidenceAngle();
152  ValidatePvlResolution();
153  ValidatePvlFromEdge();
154  ValidatePvlResidualTolerances();
155  ValidatePvlShiftTolerances();
156 
157  mPvlLog += mStdOptionsGrp;
158  }
159 
173  MeasureValidationResults ControlNetValidMeasure::ValidStandardOptions(
174  double pSample, double pLine, const ControlMeasure *pMeasure, Cube *pCube,
175  PvlGroup *pMeasureGrp) {
176 
177  // Get the Camera
178  Camera *measureCamera = NULL;
179  if(mbCameraRequired) {
180  try {
181  measureCamera = pCube->camera();
182  }
183  catch(IException &e) {
184  QString msg = "Cannot Create Camera for Image:" + pCube->fileName();
185  throw IException(IException::User, msg, _FILEINFO_);
186  }
187  }
188 
189  return ValidStandardOptions(pSample, pLine, pMeasure,
190  pCube, measureCamera, pMeasureGrp);
191  }
192 
193 
194  MeasureValidationResults ControlNetValidMeasure::ValidStandardOptions(
195  double pSample, double pLine, const ControlMeasure *pMeasure, Cube *pCube,
196  Camera *measureCamera, PvlGroup *pMeasureGrp) {
197 
198  mdEmissionAngle = 0;
199  mdIncidenceAngle = 0;
200  mdDnValue = 0;
201  mdResolution = 0;
202  mdSampleResidual = 0;
203  mdLineResidual = 0;
204  mdResidualMagnitude=0;
205  m_sampleShift = 0;
206  m_lineShift = 0;
207  m_pixelShift = 0;
208 
209  if (measureCamera != NULL) {
210  measureCamera->SetImage(pSample, pLine);
211 
212  mdEmissionAngle = measureCamera->EmissionAngle();
213  mdIncidenceAngle = measureCamera->IncidenceAngle();
214  mdResolution = measureCamera->PixelResolution();
215  }
216 
217  if (pMeasure != NULL) {
218  double temp = pMeasure->GetSampleResidual();
219  if (temp != Null) {
220  mdSampleResidual = fabs(temp);
221  }
222 
223  temp = pMeasure->GetLineResidual();
224  if (temp != Null) {
225  mdLineResidual = fabs(temp);
226  }
227 
228  temp = pMeasure->GetResidualMagnitude();
229  if (temp != Null) {
230  mdResidualMagnitude = fabs(temp);
231  }
232 
233  temp = pMeasure->GetSampleShift();
234  if (temp != Null) {
235  m_sampleShift = fabs(temp);
236  }
237 
238  temp = pMeasure->GetLineShift();
239  if (temp != Null) {
240  m_lineShift = fabs(temp);
241  }
242 
243  temp = pMeasure->GetPixelShift();
244  if (temp != Null) {
245  m_pixelShift = fabs(temp);
246  }
247  }
248 
249  if(mbValidateDN) {
250  Isis::Portal inPortal(1, 1, pCube->pixelType());
251  inPortal.SetPosition(pSample, pLine, 1);
252  pCube->read(inPortal);
253  mdDnValue = inPortal[0];
254  }
255 
256  if(pMeasureGrp != NULL) {
257  if(mbCameraRequired) {
258  *pMeasureGrp += Isis::PvlKeyword("EmissionAngle", toString(mdEmissionAngle));
259  *pMeasureGrp += Isis::PvlKeyword("IncidenceAngle", toString(mdIncidenceAngle));
260  *pMeasureGrp += Isis::PvlKeyword("Resolution", toString(mdResolution));
261  }
262  if(mbValidateDN) {
263  *pMeasureGrp += Isis::PvlKeyword("DNValue", toString(mdDnValue));
264  }
265  *pMeasureGrp += Isis::PvlKeyword("SampleResidual", toString(mdSampleResidual));
266  *pMeasureGrp += Isis::PvlKeyword("LineResidual", toString(mdLineResidual));
267  *pMeasureGrp += Isis::PvlKeyword("ResidualMagnitude", toString(mdResidualMagnitude));
268 
269  *pMeasureGrp += Isis::PvlKeyword("SampleShift", toString(m_sampleShift));
270  *pMeasureGrp += Isis::PvlKeyword("LineShift", toString(m_lineShift));
271  *pMeasureGrp += Isis::PvlKeyword("PixelShift", toString(m_pixelShift));
272  }
273 
274  MeasureValidationResults results;
275 
276  if(mbCameraRequired) {
277  if(!ValidEmissionAngle(mdEmissionAngle)) {
278  results.addFailure(MeasureValidationResults::EmissionAngle,
279  mdEmissionAngle, mdMinEmissionAngle, mdMaxEmissionAngle);
280  }
281 
282  if(!ValidIncidenceAngle(mdIncidenceAngle)) {
283  results.addFailure(MeasureValidationResults::IncidenceAngle,
284  mdIncidenceAngle, mdMinIncidenceAngle, mdMaxEmissionAngle);
285  }
286 
287  if(!ValidResolution(mdResolution)) {
288  results.addFailure(MeasureValidationResults::Resolution,
289  mdResolution, mdMinResolution, mdMaxResolution);
290  }
291  }
292 
293  if(mbValidateDN) {
294  if(!ValidDnValue(mdDnValue)) {
295  results.addFailure(MeasureValidationResults::DNValue,
296  mdDnValue, mdMinDN, mdMaxDN);
297  }
298  }
299 
300  if(mbValidateFromEdge) {
301  if(!PixelsFromEdge((int)pSample, (int)pLine, pCube)) {
302  results.addFailure(MeasureValidationResults::PixelsFromEdge, miPixelsFromEdge);
303  }
304 
305  if(!MetersFromEdge((int)pSample, (int)pLine, pCube)) {
306  results.addFailure(MeasureValidationResults::MetersFromEdge,
307  mdMetersFromEdge);
308  }
309  }
310 
311  if(pMeasure != NULL) {
312  ValidResidualTolerances(mdSampleResidual, mdLineResidual,
313  mdResidualMagnitude, results);
314  ValidShiftTolerances(m_sampleShift, m_lineShift,
315  m_pixelShift, results);
316  }
317 
318  return results;
319  }
320 
333  MeasureValidationResults ControlNetValidMeasure::ValidStandardOptions(
334  double pSample, double pLine, Cube *pCube, PvlGroup *pMeasureGrp) {
335 
336  return ValidStandardOptions(pSample, pLine, NULL, pCube, pMeasureGrp);
337 
338  }
339 
340 
353  MeasureValidationResults ControlNetValidMeasure::ValidStandardOptions(
354  const ControlMeasure * pMeasure, Cube *pCube, PvlGroup *pMeasureGrp) {
355 
356  double dSample, dLine;
357  dSample = pMeasure->GetSample();
358  dLine = pMeasure->GetLine();
359 
360  return (ValidStandardOptions(dSample, dLine, pMeasure, pCube, pMeasureGrp));
361  }
362 
363 
364  MeasureValidationResults ControlNetValidMeasure::ValidStandardOptions(
365  const ControlMeasure * pMeasure, Cube *pCube, Camera *camera,
366  PvlGroup *pMeasureGrp) {
367 
368  double dSample, dLine;
369  dSample = pMeasure->GetSample();
370  dLine = pMeasure->GetLine();
371 
372  return ValidStandardOptions(dSample, dLine, pMeasure,
373  pCube, camera, pMeasureGrp);
374  }
375 
382  void ControlNetValidMeasure::ValidatePvlFromEdge(void) {
383  // Parse the Pixels from edge
384  if(mPvlOpGrp.hasKeyword("PixelsFromEdge")) {
385  miPixelsFromEdge = mPvlOpGrp["PixelsFromEdge"];
386  if(miPixelsFromEdge < 0) {
387  miPixelsFromEdge = 0;
388  }
389  else {
390  mbValidateFromEdge = true;
391  }
392  mStdOptionsGrp += Isis::PvlKeyword("PixelsFromEdge", toString(miPixelsFromEdge));
393  }
394  // Parse the Meters from edge
395  if(mPvlOpGrp.hasKeyword("MetersFromEdge")) {
396  mdMetersFromEdge = mPvlOpGrp["MetersFromEdge"];
397  if(mdMetersFromEdge < 0) {
398  mdMetersFromEdge = 0;
399  }
400  else {
401  mbValidateFromEdge = true;
402  }
403  mStdOptionsGrp += Isis::PvlKeyword("MetersFromEdge", toString(mdMetersFromEdge));
404  }
405  }
406 
414  void ControlNetValidMeasure::ValidatePvlResolution(void) {
415  if(mPvlOpGrp.hasKeyword("MinResolution")){
416  mdMinResolution = mPvlOpGrp["MinResolution"];
417  mbCameraRequired = true;
418  }
419  else {
420  mdMinResolution = 0;
421  }
422  mStdOptionsGrp += Isis::PvlKeyword("MinResolution", toString(mdMinResolution));
423 
424  if(mPvlOpGrp.hasKeyword("MaxResolution")){
425  mdMaxResolution = mPvlOpGrp["MaxResolution"];
426  mbCameraRequired = true;
427  }
428  else {
429  mdMaxResolution = DBL_MAX;
430  }
431  mStdOptionsGrp += Isis::PvlKeyword("MaxResolution", (mdMaxResolution == DBL_MAX ? "NA" : toString(mdMaxResolution)));
432 
433  if(mdMinResolution < 0 || mdMaxResolution < 0) {
434  QString msg = "Invalid Resolution value(s), Resolution must be greater than zero";
435  throw IException(IException::User, msg, _FILEINFO_);
436  }
437 
438  if(mdMaxResolution < mdMinResolution) {
439  QString msg = "MinResolution must be less than MaxResolution";
440  throw IException(IException::User, msg, _FILEINFO_);
441  }
442  }
443 
452  void ControlNetValidMeasure::ValidatePvlDN(void) {
453  if(mPvlOpGrp.hasKeyword("MinDN")) {
454  mdMinDN = mPvlOpGrp["MinDN"];
455  mbValidateDN = true;
456  }
457  else {
458  mdMinDN = Isis::ValidMinimum;
459  }
460  mStdOptionsGrp += Isis::PvlKeyword("MinDN", (mdMinDN == Isis::ValidMinimum ? "NA" : toString(mdMinDN)));
461 
462  if(mPvlOpGrp.hasKeyword("MaxDN")) {
463  mdMaxDN = mPvlOpGrp["MaxDN"];
464  mbValidateDN = true;
465  }
466  else {
467  mdMaxDN = Isis::ValidMaximum;
468  }
469  mStdOptionsGrp += Isis::PvlKeyword("MaxDN", (mdMaxDN == Isis::ValidMaximum ? "NA" : toString(mdMaxDN)));
470 
471  if(mdMaxDN < mdMinDN) {
472  QString msg = "MinDN must be less than MaxDN";
473  throw IException(IException::User, msg, _FILEINFO_);
474  }
475  }
476 
485  void ControlNetValidMeasure::ValidatePvlEmissionAngle(void) {
486  if(mPvlOpGrp.hasKeyword("MinEmission")) {
487  mdMinEmissionAngle = mPvlOpGrp["MinEmission"];
488  mbCameraRequired = true;
489  if(mdMinEmissionAngle < 0 || mdMinEmissionAngle > 135) {
490  QString msg = "Invalid Min Emission Angle, Valid Range is [0-135]";
491  throw IException(IException::User, msg, _FILEINFO_);
492  }
493  }
494  mStdOptionsGrp += Isis::PvlKeyword("MinEmission", toString(mdMinEmissionAngle));
495 
496  if(mPvlOpGrp.hasKeyword("MaxEmission")) {
497  mdMaxEmissionAngle = mPvlOpGrp["MaxEmission"];
498  mbCameraRequired = true;
499  if(mdMaxEmissionAngle < 0 || mdMaxEmissionAngle > 135) {
500  QString msg = "Invalid Max Emission Angle, Valid Range is [0-135]";
501  throw IException(IException::User, msg, _FILEINFO_);
502  }
503  }
504  mStdOptionsGrp += Isis::PvlKeyword("MaxEmission", toString(mdMaxEmissionAngle));
505 
506  if(mdMaxEmissionAngle < mdMinEmissionAngle) {
507  QString msg = "Min EmissionAngle must be less than Max EmissionAngle";
508  throw IException(IException::User, msg, _FILEINFO_);
509  }
510 
511  }
512 
521  void ControlNetValidMeasure::ValidatePvlIncidenceAngle(void) {
522  if(mPvlOpGrp.hasKeyword("MinIncidence")) {
523  mdMinIncidenceAngle = mPvlOpGrp["MinIncidence"];
524  mbCameraRequired = true;
525  if(mdMinIncidenceAngle < 0 || mdMinIncidenceAngle > 135) {
526  QString msg = "Invalid Min Incidence Angle, Valid Range is [0-135]";
527  throw IException(IException::User, msg, _FILEINFO_);
528  }
529  }
530  mStdOptionsGrp += Isis::PvlKeyword("MinIncidence", toString(mdMinIncidenceAngle));
531 
532  if(mPvlOpGrp.hasKeyword("MaxIncidence")) {
533  mdMaxIncidenceAngle = mPvlOpGrp["MaxIncidence"];
534  mbCameraRequired = true;
535  if(mdMaxIncidenceAngle < 0 || mdMaxIncidenceAngle > 135) {
536  QString msg = "Invalid Max Incidence Angle, Valid Range is [0-135]";
537  throw IException(IException::User, msg, _FILEINFO_);
538  }
539  }
540  mStdOptionsGrp += Isis::PvlKeyword("MaxIncidence", toString(mdMaxIncidenceAngle));
541 
542  if(mdMaxIncidenceAngle < mdMinIncidenceAngle) {
543  QString msg = "Min IncidenceAngle must be less than Max IncidenceAngle";
544  throw IException(IException::User, msg, _FILEINFO_);
545  }
546  }
547 
553  void ControlNetValidMeasure::ValidatePvlResidualTolerances(void){
554  bool bRes=false;
555  bool bResMag = false;
556  if(mPvlOpGrp.hasKeyword("SampleResidual")) {
557  mdSampleResTolerance = mPvlOpGrp["SampleResidual"];
558  if(mdSampleResTolerance < 0) {
559  QString msg = "Invalid Sample Residual, must be greater than zero";
560  throw IException(IException::User, msg, _FILEINFO_);
561  }
562  bRes = true;
563  }
564  mStdOptionsGrp += Isis::PvlKeyword("SampleResidual", (mdSampleResTolerance == DBL_MAX ? "NA" : toString(mdSampleResTolerance)));
565 
566  if(mPvlOpGrp.hasKeyword("LineResidual")) {
567  mdLineResTolerance = mPvlOpGrp["LineResidual"];
568  if(mdLineResTolerance < 0) {
569  QString msg = "Invalid Line Residual, must be greater than zero";
570  throw IException(IException::User, msg, _FILEINFO_);
571  }
572  bRes = true;
573  }
574  mStdOptionsGrp += Isis::PvlKeyword("LineResidual", (mdLineResTolerance == DBL_MAX ? "NA" : toString(mdLineResTolerance)));
575 
576  if(mPvlOpGrp.hasKeyword("ResidualMagnitude")) {
577  mdResidualTolerance = mPvlOpGrp["ResidualMagnitude"];
578  if(mdResidualTolerance < 0) {
579  QString msg = "Invalid Residual Magnitude Tolerance, must be greater than zero";
580  throw IException(IException::User, msg, _FILEINFO_);
581  }
582  bResMag = true;
583  }
584  mStdOptionsGrp += Isis::PvlKeyword("ResidualMagnitude", (mdResidualTolerance == DBL_MAX ? "NA" : toString(mdResidualTolerance)));
585 
586  if(bRes && bResMag) {
587  QString msg = "Cannot have both Sample/Line Residuals and Residual Magnitude.";
588  msg += "\nChoose either Sample/Line Residual or Residual Magnitude";
589  throw IException(IException::User, msg, _FILEINFO_);
590  }
591  }
592 
593 
598  void ControlNetValidMeasure::ValidatePvlShiftTolerances() {
599  bool hasSampleLineShift = false;
600  if (mPvlOpGrp.hasKeyword("SampleShift")) {
601  m_sampleShiftTolerance = mPvlOpGrp["SampleShift"];
602  if (m_sampleShiftTolerance < 0) {
603  QString msg = "Invalid Sample Shift tolerance:"
604  " must be greater than or equal to zero";
605  throw IException(IException::User, msg, _FILEINFO_);
606  }
607  hasSampleLineShift = true;
608  }
609  mStdOptionsGrp += Isis::PvlKeyword("SampleShift", (m_sampleShiftTolerance == DBL_MAX ? "NA" : toString(m_sampleShiftTolerance)));
610 
611  if (mPvlOpGrp.hasKeyword("LineShift")) {
612  m_lineShiftTolerance = mPvlOpGrp["LineShift"];
613  if (m_lineShiftTolerance < 0) {
614  QString msg = "Invalid Line Shift tolerance:"
615  " must be greater than or equal to zero";
616  throw IException(IException::User, msg, _FILEINFO_);
617  }
618  hasSampleLineShift = true;
619  }
620  mStdOptionsGrp += Isis::PvlKeyword("LineShift", (m_lineShiftTolerance == DBL_MAX ? "NA" : toString(m_lineShiftTolerance)));
621 
622  bool hasPixelShift = false;
623  if (mPvlOpGrp.hasKeyword("PixelShift")) {
624  m_pixelShiftTolerance = mPvlOpGrp["PixelShift"];
625  if (m_pixelShiftTolerance < 0) {
626  QString msg = "Invalid Pixel Shift tolerance:"
627  " must be greater than or equal to zero";
628  throw IException(IException::User, msg, _FILEINFO_);
629  }
630  hasPixelShift = true;
631  }
632  mStdOptionsGrp += Isis::PvlKeyword("PixelShift", (m_pixelShiftTolerance == DBL_MAX ? "NA" : toString(m_pixelShiftTolerance)));
633 
634  if (hasSampleLineShift && hasPixelShift) {
635  QString msg = "Cannot have both Sample/Line Shift and Pixel Shift";
636  msg += " tolerances.\n";
637  msg += "Choose either Sample/Line Shift or Pixel Shift to validate on";
638  throw IException(IException::User, msg, _FILEINFO_);
639  }
640  }
641 
642 
654  bool ControlNetValidMeasure::ValidEmissionAngle(double pdEmissionAngle) {
655  if(pdEmissionAngle < mdMinEmissionAngle || pdEmissionAngle > mdMaxEmissionAngle) {
656  return false;
657  }
658  return true;
659  }
660 
672  bool ControlNetValidMeasure::ValidIncidenceAngle(double pdIncidenceAngle) {
673  if(pdIncidenceAngle < mdMinIncidenceAngle || pdIncidenceAngle > mdMaxIncidenceAngle) {
674  return false;
675  }
676  return true;
677  }
678 
689  bool ControlNetValidMeasure::ValidDnValue(double pdDnValue) {
690  if(Isis::IsSpecial(pdDnValue) || pdDnValue < mdMinDN || pdDnValue > mdMaxDN) {
691  return false;
692  }
693  return true;
694  }
695 
706  bool ControlNetValidMeasure::ValidResolution(double pdResolution) {
707  if(pdResolution < mdMinResolution || pdResolution > mdMaxResolution) {
708  return false;
709  }
710  return true;
711  }
712 
713 
727  bool ControlNetValidMeasure::ValidResidualTolerances(double pdSampleResidual,
728  double pdLineResidual, double pdResidualMagnitude,
729  MeasureValidationResults & pResults){
730  bool bFlag = true;
731 
732  if(pdSampleResidual > mdSampleResTolerance) {
733  bFlag = false;
734  pResults.addFailure(MeasureValidationResults::SampleResidual, mdSampleResTolerance, "greater");
735  }
736  if(pdLineResidual > mdLineResTolerance) {
737  bFlag = false;
738  pResults.addFailure(MeasureValidationResults::LineResidual, mdLineResTolerance, "greater");
739  }
740  if(pdResidualMagnitude > mdResidualTolerance) {
741  bFlag = false;
742  pResults.addFailure(MeasureValidationResults::ResidualMagnitude, mdResidualTolerance, "greater");
743  }
744 
745  return bFlag;
746  }
747 
748 
760  bool ControlNetValidMeasure::ValidShiftTolerances(
761  double sampleShift, double lineShift, double pixelShift,
762  MeasureValidationResults &results) {
763 
764  bool valid = true;
765 
766  if (sampleShift > m_sampleShiftTolerance) {
767  valid = false;
768  results.addFailure(MeasureValidationResults::SampleShift,
769  m_sampleShiftTolerance, "greater");
770  }
771  if (lineShift > m_lineShiftTolerance) {
772  valid = false;
773  results.addFailure(MeasureValidationResults::LineShift,
774  m_lineShiftTolerance, "greater");
775  }
776  if (pixelShift > m_pixelShiftTolerance) {
777  valid = false;
778  results.addFailure(MeasureValidationResults::PixelShift,
779  m_pixelShiftTolerance, "greater");
780  }
781 
782  return valid;
783  }
784 
785 
797  bool ControlNetValidMeasure::ValidLatLon(Camera *pCamera, int piSample, int piLine) {
798  return true;
799  }
800 
812  bool ControlNetValidMeasure::PixelsFromEdge(int piSample, int piLine, Cube *pCube) {
813  if(miPixelsFromEdge <= 0) {
814  return true;
815  }
816 
817  int iNumSamples = pCube->sampleCount();
818  int iNumLines = pCube->lineCount();
819 
820  // test right
821  if((iNumSamples - piSample) < miPixelsFromEdge) {
822  return false;
823  }
824 
825  // test left
826  if((piSample - miPixelsFromEdge) <= 0) {
827  return false;
828  }
829 
830  // test down
831  if((iNumLines - piLine) < miPixelsFromEdge) {
832  return false;
833  }
834 
835  // test up
836  if((piLine - miPixelsFromEdge) <= 0) {
837  return false;
838  }
839 
840  return true;
841  }
842 
854  bool ControlNetValidMeasure::MetersFromEdge(int piSample, int piLine, Cube *pCube) {
855  if(mdMetersFromEdge <= 0) {
856  return true;
857  }
858 
859  int iNumSamples = pCube->sampleCount();
860  int iNumLines = pCube->lineCount();
861 
862  try {
863  // Get the image's camera to get pixel resolution
864  Camera *camera = pCube->camera();
865  double resMetersTotal = 0;
866  bool bMinDistance = false;
867 
868  // test top
869  for(int line = piLine - 1; line > 0; line--) {
870  camera->SetImage(piSample, line);
871  double resolution = camera->PixelResolution();
872  resMetersTotal += resolution;
873  if(resMetersTotal >= mdMetersFromEdge) {
874  bMinDistance = true;
875  break;
876  }
877  }
878  if(!bMinDistance) {
879  return false;
880  }
881 
882  // test bottom
883  bMinDistance = false;
884  resMetersTotal = 0;
885  for(int line = piLine + 1; line <= iNumLines; line++) {
886  camera->SetImage(piSample, line);
887  double resolution = camera->PixelResolution();
888  resMetersTotal += resolution;
889  if(resMetersTotal >= mdMetersFromEdge) {
890  bMinDistance = true;
891  break;
892  }
893  }
894  if(!bMinDistance) {
895  return false;
896  }
897 
898  // test left
899  resMetersTotal = 0;
900  bMinDistance = false;
901  for(int sample = piSample - 1; sample > 0; sample--) {
902  camera->SetImage(sample, piLine);
903  double resolution = camera->PixelResolution();
904  resMetersTotal += resolution;
905  if(resMetersTotal >= mdMetersFromEdge) {
906  bMinDistance = true;
907  break;
908  }
909  }
910  if(!bMinDistance) {
911  return false;
912  }
913 
914  // test right
915  resMetersTotal = 0;
916  bMinDistance = false;
917  for(int sample = piSample + 1; sample <= iNumSamples; sample++) {
918  camera->SetImage(sample, piLine);
919  double resolution = camera->PixelResolution();
920  resMetersTotal += resolution;
921  if(resMetersTotal >= mdMetersFromEdge) {
922  return true;
923  }
924  }
925  return false;
926  }
927  catch(IException &e) {
928  QString msg = "Cannot Create Camera for Image [" +
929  pCube->fileName() + "]";
930  throw IException(IException::User, msg, _FILEINFO_);
931  }
932  }
933 };
934