Isis 3.0
Home
Equalization.h
Go to the documentation of this file.
1 #ifndef Equalization_h
2 #define Equalization_h
3 
26 #include <vector>
27 
28 #include <QString>
29 #include <QStringList>
30 
31 #include "FileList.h"
32 #include "LeastSquares.h"
33 #include "OverlapNormalization.h"
34 
35 using namespace std;
36 
37 namespace Isis {
38  class Buffer;
39  class OverlapStatistics;
40  class Pvl;
41  class PvlGroup;
42  class PvlObject;
43  class Statistics;
134  class Equalization {
135  public:
136  Equalization(OverlapNormalization::SolutionType sType, QString fromListName);
137  virtual ~Equalization();
138 
139  void addHolds(QString holdListName);
140 
141  void calculateStatistics(double samplingPercent,
142  int mincnt,
143  bool wtopt,
144  LeastSquares::SolveMethod methodType);
145  void recalculateStatistics(QString inStatsFileName);
146  void importStatistics(QString instatsFileName);
147  void applyCorrection(QString toListName);
148 
149  PvlGroup getResults();
150  void write(QString outstatsFileName);
151 
152  double evaluate(double dn, int imageIndex, int bandIndex) const;
153 
154  protected:
163  public:
166 
167  void addGain(double gain) {
168  gains.push_back(gain);
169  }
170 
171  void addOffset(double offset) {
172  offsets.push_back(offset);
173  }
174 
175  void addAverage(double average) {
176  avgs.push_back(average);
177  }
178 
179  double getGain(int index) const {
180  return gains[index];
181  }
182 
183  double getOffset(int index) const {
184  return offsets[index];
185  }
186 
187  double getAverage(int index) const {
188  return avgs[index];
189  }
190 
191  double evaluate(double dn, int index) const {
192  double result = Null;
193 
194  double gain = gains[index];
195  if (m_sType != OverlapNormalization::GainsWithoutNormalization) {
196  double offset = offsets[index];
197  double avg = avgs[index];
198  result = (dn - avg) * gain + offset + avg;
199  }
200  else {
201  result = dn * gain;
202  }
203 
204  return result;
205  }
206 
207  private:
208  vector<double> gains;
209  vector<double> offsets;
210  vector<double> avgs;
211 
213  };
214 
223  public:
231  CalculateFunctor(Statistics *stats, double percent) {
232  m_stats = stats;
233  m_linc = (int) (100.0 / percent + 0.5);
234  }
235 
236  virtual ~CalculateFunctor() {}
237 
238  void operator()(Buffer &in) const;
239 
240  protected:
241  virtual void addStats(Buffer &in) const;
242 
243  private:
244  Statistics *m_stats;
245  int m_linc;
246  };
247 
255  class ApplyFunctor {
256  public:
257  ApplyFunctor(const ImageAdjustment *adjustment) {
258  m_adjustment = adjustment;
259  }
260 
261  void operator()(Buffer &in, Buffer &out) const;
262 
263  private:
264  const ImageAdjustment *m_adjustment;
265  };
266 
267  protected:
268  Equalization();
269  void loadInputs(QString fromListName);
270  void setInput(int index, QString value);
271  const FileList &getInputs() const;
272 
273  // Should these be protected or private? (Recall children, i.e. HiEqual... can't
274  // access Equalization's private vars directly)
275  void calculateBandStatistics();
276  void calculateOverlapStatistics();
277 
278  virtual void fillOutList(FileList &outList, QString toListName);
279  virtual void errorCheck(QString fromListName);
280 
281  void generateOutputs(FileList &outList);
282  void loadOutputs(FileList &outList, QString toListName);
283  void loadHolds(OverlapNormalization *oNorm);
284 
285  void setResults();
286 
287  void clearAdjustments();
288  void addAdjustment(ImageAdjustment *adjustment);
289 
290  void clearNormalizations();
291  void clearOverlapStatistics();
292 
293  void addValid(int count);
294  void addInvalid(int count);
295 
296  void fromPvl(const PvlObject &inStats);
297  void setSolved(bool solved);
298  bool isSolved() const;
299 
300  private:
301  void init();
302  QVector<int> validateInputStatistics(QString instatsFileName);
303 
304  bool m_normsSolved;
305  bool m_recalculating;
306  bool m_wtopt;
307 
308  FileList m_imageList; //<! List of input image filenames
309 
310  double m_samplingPercent;
313  int m_validCnt;
314  int m_invalidCnt;
315  int m_mincnt;
316 
317  int m_maxCube;
318  int m_maxBand;
319 
320  QStringList m_badFiles;
321 
322  vector<ImageAdjustment *> m_adjustments; //<! Corrective factors for equalization
323  vector<int> m_holdIndices;
324  vector<bool> m_doesOverlapList;
325  vector<bool> m_alreadyCalculated;
326  vector<OverlapNormalization *> m_overlapNorms;
327  vector<OverlapStatistics *> m_overlapStats;
328 
332  LeastSquares::SolveMethod m_lsqMethod;
333 
334  Pvl *m_results;
335  };
336 };
337 
338 #endif
Buffer for reading and writing cube data.
Definition: Buffer.h:68
ImageAdjustment(OverlapNormalization::SolutionType sType)
Definition: Equalization.h:164
const double Null
Value for an Isis Null pixel.
Definition: SpecialPixel.h:109
This class is used as a functor calculate image statistics.
Definition: Equalization.h:222
void addOffset(double offset)
Definition: Equalization.h:171
Internalizes a list of files.
Definition: FileList.h:67
SolutionType
Enumeration for whether user/programmer wants to calculate new gains, offsets, or both when solving...
Definition: OverlapNormalization.h:125
double getGain(int index) const
Definition: Equalization.h:179
This class is used as a functor to apply adjustments (equalize) to an image.
Definition: Equalization.h:255
double getOffset(int index) const
Definition: Equalization.h:183
SolveMethod
Definition: LeastSquares.h:130
This class is used to accumulate statistics on double arrays.
Definition: Statistics.h:109
void addAverage(double average)
Definition: Equalization.h:175
CalculateFunctor(Statistics *stats, double percent)
Constructs a CalculateFunctor.
Definition: Equalization.h:231
virtual ~CalculateFunctor()
Definition: Equalization.h:236
Calculate the bases and multipliers for normalizing overlapping &quot;data sets&quot; (e.g., cubes).
Definition: OverlapNormalization.h:75
Definition: Equalization.h:162
This class can be used to calculate, read in, and/or apply equalization statistics for a list of file...
Definition: Equalization.h:134
ApplyFunctor(const ImageAdjustment *adjustment)
Definition: Equalization.h:257
Contains multiple PvlContainers.
Definition: PvlGroup.h:57
double evaluate(double dn, int index) const
Definition: Equalization.h:191
~ImageAdjustment()
Definition: Equalization.h:165
Container for cube-like labels.
Definition: Pvl.h:135
void addGain(double gain)
Definition: Equalization.h:167
double getAverage(int index) const
Definition: Equalization.h:187
Contains Pvl Groups and Pvl Objects.
Definition: PvlObject.h:74