SourceXtractorPlusPlus  0.15
Please provide a description of the project.
SE2BackgroundModeller.cpp
Go to the documentation of this file.
1 
17 /*
18  * Created on Jan 05, 2015
19  * @author: mkuemmel@usm.lmu.de
20  * Date: $Date$
21  * Revision: $Revision$
22  * Author: $Author$
23  */
24 #include <iostream>
25 #include <cstdlib>
26 
27 #include "fitsio.h"
28 
37 #define SIZETSUB(X, Y) ((X) > (Y) ? (X-Y) : (Y-X))
38 using namespace std;
39 
40 namespace SourceXtractor {
41 
42 SE2BackgroundModeller::SE2BackgroundModeller(std::shared_ptr<DetectionImage> image, std::shared_ptr<WeightImage> variance_map, std::shared_ptr<Image<unsigned char>> mask, const unsigned char mask_type_flag)
43 {
44  itsImage = image;
45  itsVariance = variance_map;
46  itsMask = mask;
47  itsMaskType = mask_type_flag;
48  //itsWeightTypeFlag = weight_type_flag;
49 
50  //check for variance
51  if (variance_map!=nullptr)
52  itsHasVariance=true;
53  else
54  itsHasVariance=false;
55 
56  //check for mask
57  if (mask!=nullptr)
58  itsHasMask=true;
59  else
60  itsHasMask=false;
61 
62  // store the image size
63  itsNaxes[0] = (size_t)image->getWidth();
64  itsNaxes[1] = (size_t)image->getHeight();
65 }
66 
67 SE2BackgroundModeller::~SE2BackgroundModeller() {
68  if (itsWhtMeanVals)
69  delete[] itsWhtMeanVals;
70 }
71 
72 void SE2BackgroundModeller::createSE2Models(std::shared_ptr<TypedSplineModelWrapper<SeFloat>> &bckPtr, std::shared_ptr<TypedSplineModelWrapper<SeFloat>> &varPtr, PIXTYPE &sigFac, const size_t *bckCellSize, const WeightImage::PixelType varianceThreshold, const size_t *filterBoxSize, const float &filterThreshold)
73 {
74  using DetectionAccessor = ImageAccessor<DetectionImage::PixelType>;
75  using MaskAccessor = ImageAccessor<unsigned char>;
76 
77  DetectionAccessor detectionAccessor(itsImage);
78  MaskAccessor maskAccessor(itsMask);
79 
80  size_t gridSize[2] = {0,0};
81  size_t nGridPoints=0;
82 
83  long increment[2]={1,1};
84  long fpixel[2];
85  long lpixel[2];
86 
87  size_t nElements=0;
88  size_t nData=0;
89  size_t subImgNaxes[2] = {0,0};
90 
91  PIXTYPE* gridData=NULL;
92  PIXTYPE* weightData=NULL;
93 
94  //PIXTYPE undefNumber=-BIG;
95 
96  BackgroundCell* oneCell=NULL;
97 
98  PIXTYPE* bckMeanVals=NULL;
99  PIXTYPE* bckSigVals=NULL;
100  PIXTYPE* whtSigVals=NULL;
101 
102  size_t gridIndex=0;
103 
104  ldiv_t divResult;
105 
106  PIXTYPE weightVarThreshold=(PIXTYPE)varianceThreshold;
107 
108  // not necessary, since all is in variance
109  // re-scale the weight threshold
110  //if (itsHasVariance){
111  // rescaleThreshold(weightVarThreshold, weightThreshold);
112  //}
113 
114  // get the number of grid cells in x
115  divResult = std::div(long(itsNaxes[0]), long(bckCellSize[0]));
116  gridSize[0] = size_t(divResult.quot);
117  if (divResult.rem)
118  gridSize[0] += 1;
119 
120  // get the number of grid cells in y
121  divResult = std::div(long(itsNaxes[1]), long(bckCellSize[1]));
122  gridSize[1] = size_t(divResult.quot);
123  if (divResult.rem)
124  gridSize[1] += 1;
125 
126  // compute the number of grid points
127  nGridPoints = gridSize[0]*gridSize[1];
128 
129  // create the arrays
130  bckMeanVals = new PIXTYPE[nGridPoints];
131  bckSigVals = new PIXTYPE[nGridPoints];
132  if (itsHasVariance){
133  itsWhtMeanVals = new PIXTYPE[nGridPoints];
134  whtSigVals = new PIXTYPE[nGridPoints];
135  }
136 
137  // give some feedback on the parameters
138  bck_model_logger.debug() << "\tBackground cell size=("<<bckCellSize[0]<<"," << bckCellSize[1]<< ")";
139  bck_model_logger.debug() << "\tFilter box size=("<<filterBoxSize[0]<<"," << filterBoxSize[1]<< ")";
140  bck_model_logger.debug() << "\tThe bad pixel threshold is: "<< weightVarThreshold;
141 
142  // iterate over cells in y
143  gridIndex=0;
144  for (size_t yIndex=0; yIndex<gridSize[1]; yIndex++){
145 
146  // set the boundaries in y
147  fpixel[1] = (long)yIndex*bckCellSize[1];
148  lpixel[1] = yIndex < gridSize[1]-1 ? (long)(yIndex+1)*bckCellSize[1] : (long)itsNaxes[1];
149 
150  // iterate over cells in x
151  for (size_t xIndex=0; xIndex<gridSize[0]; xIndex++){
152 
153  // set the boundaries in x
154  fpixel[0] = (long)xIndex*bckCellSize[0];
155  lpixel[0] = xIndex < gridSize[0]-1 ? (long)(xIndex+1)*bckCellSize[0] : (long)itsNaxes[0];
156 
157  // compute the length of the cell sub-image
158  subImgNaxes[0] =(size_t)(lpixel[0]-fpixel[0]);
159  subImgNaxes[1] =(size_t)(lpixel[1]-fpixel[1]);
160 
161  // some feedback on the corners of the image to be treated
162  bck_model_logger.debug() << "Background cell from fpixel=(" << fpixel[0] << "," << fpixel[1] << ") to lpixel=("<< lpixel[0] << "," << lpixel[1] << ")";
163 
164  // compute the increments to perhaps limit the number
165  // of pixels read in, the total number of elements
166  // and the numbers read in x and y
167  getMinIncr(nElements, increment, subImgNaxes);
168 
169  // define or re-define the buffers
170  if (nElements!=nData) {
171  delete [] gridData;
172  gridData = new PIXTYPE[nElements];
173  //if (itsInputWeight){
174  if (itsHasVariance){
175  delete [] weightData;
176  weightData = new PIXTYPE[nElements];
177  }
178  nData=nElements;
179  }
180 
181  // load in the image data
182  long pixIndex=0;
183  for (auto yIndex=fpixel[1]; yIndex<lpixel[1]; yIndex+=increment[1])
184  for (auto xIndex=fpixel[0]; xIndex<lpixel[0]; xIndex+=increment[0]){
185  gridData[pixIndex++] = (PIXTYPE)detectionAccessor.getValue(int(xIndex), int(yIndex));
186  }
187  if (itsHasVariance){
188  long pixIndex=0;
189  for (auto yIndex=fpixel[1]; yIndex<lpixel[1]; yIndex+=increment[1])
190  for (auto xIndex=fpixel[0]; xIndex<lpixel[0]; xIndex+=increment[0])
191  weightData[pixIndex++] = (PIXTYPE)detectionAccessor.getValue(int(xIndex), int(yIndex));
192  }
193  if (itsHasMask){
194  // load in the image data
195  long pixIndex=0;
196  for (auto yIndex=fpixel[1]; yIndex<lpixel[1]; yIndex+=increment[1])
197  for (auto xIndex=fpixel[0]; xIndex<lpixel[0]; xIndex+=increment[0], pixIndex++)
198  //if (!itsMask->getValue(int(xIndex), int(yIndex)))
199  if (maskAccessor.getValue(int(xIndex), int(yIndex)) & itsMaskType){
200  gridData[pixIndex] = -BIG;
201  bck_model_logger.debug() << "\tReplacing data value";
202  }
203  }
204 
205  // create a background cell compute and store the values
206  // and then delete the cell again
207  oneCell = new BackgroundCell(gridData, nElements, weightData, weightVarThreshold);
208  if (itsHasVariance)
209  oneCell->getBackgroundValues(bckMeanVals[gridIndex], bckSigVals[gridIndex], itsWhtMeanVals[gridIndex], whtSigVals[gridIndex]);
210  else
211  oneCell->getBackgroundValues(bckMeanVals[gridIndex], bckSigVals[gridIndex]);
212  delete oneCell;
213 
214  // enhance the grid index
215  gridIndex++;
216  }
217  }
218 
219  // do some filtering on the data
220  filter(bckMeanVals, bckSigVals, gridSize, filterBoxSize, filterThreshold);
221  if (itsHasVariance){
222  filter(itsWhtMeanVals, whtSigVals, gridSize, filterBoxSize, filterThreshold);
223  }
224 
225  if (itsHasVariance){
226  //if (itsHasVariance && (itsWeightTypeFlag & (VAR_FIELD|WEIGHT_FIELD))){
227  // compute the scaling factor
228  computeScalingFactor(itsWhtMeanVals, bckSigVals, sigFac, nGridPoints);
229  }
230  else{
231  sigFac=0.0;
232  }
233 
234  // convert the grid of rms values to variance
235  for (size_t index=0; index<nGridPoints; index++)
236  bckSigVals[index] *= bckSigVals[index];
237 
238  // create the splined interpolation images for background and variance
239  bckPtr = TypedSplineModelWrapper<SeFloat>::create(itsNaxes, bckCellSize, gridSize, bckMeanVals);
240  varPtr = TypedSplineModelWrapper<SeFloat>::create(itsNaxes, bckCellSize, gridSize, bckSigVals);
241 
242  // release memory
243  delete [] whtSigVals;
244  delete [] gridData;
245  delete [] weightData;
246 }
247 
248 void SE2BackgroundModeller::getMinIncr(size_t &nElements, long* incr, const size_t * subImgNaxes)
249 {
250  float axisRatio;
251  ldiv_t divResult;
252 
253  // copy the original dimensions
254  size_t tmpImgNaxes[2] = {subImgNaxes[0], subImgNaxes[1]};
255 
256  // set the default increment
257  incr[0] = 1;
258  incr[1] = 1;
259 
260  // compute the number of elements;
261  // check if something needs to be done at all
262  nElements = tmpImgNaxes[0]*tmpImgNaxes[1];
263  if (nElements <= BACK_BUFSIZE)
264  return;
265 
266  // compute the axis ratio
267  axisRatio = float(tmpImgNaxes[0]) / float(tmpImgNaxes[1]);
268 
269  // iterate until the number is small enough
270  while (nElements > BACK_BUFSIZE)
271  {
272  // change the increments such
273  // that pixels sampled in x and y
274  // are about equal
275  if (axisRatio >= 1.0)
276  incr[0] += 1;
277  else
278  incr[1] += 1;
279 
280  // get the number of pixels sampled in x
281  divResult = std::div(long(subImgNaxes[0]), long(incr[0]));
282  tmpImgNaxes[0] = size_t(divResult.quot);
283  if (divResult.rem)
284  tmpImgNaxes[0] += 1;
285 
286  // get the number of pixels sampled in y
287  divResult = std::div(long(subImgNaxes[1]), long(incr[1]));
288  tmpImgNaxes[1] = size_t(divResult.quot);
289  if (divResult.rem)
290  tmpImgNaxes[1] += 1;
291 
292  // re-compute the number of elements and the
293  // axis ratio
294  nElements = tmpImgNaxes[0]*tmpImgNaxes[1];
295  axisRatio = float(tmpImgNaxes[0]) / float(tmpImgNaxes[1]);
296  }
297 
298  // some feedback for the new increments and sizes
299  bck_model_logger.debug() << "New increment=(" << incr[0] << "," << incr[1] << ") sampledPixels=("<< tmpImgNaxes[0] << "," << tmpImgNaxes[1] << ") nElements=" << nElements;
300 
301  return;
302 }
303 
304 void SE2BackgroundModeller::filter(PIXTYPE* bckVals, PIXTYPE* sigmaVals,const size_t* gridSize, const size_t* filterSize, const float &filterThreshold)
305 {
306  // replace undefined values
307  replaceUNDEF(bckVals, sigmaVals, gridSize);
308 
309  // do a median filtering of the values
310  filterMedian(bckVals, sigmaVals, gridSize, filterSize, filterThreshold);
311 
312  return;
313 }
314 
315 void SE2BackgroundModeller::replaceUNDEF(PIXTYPE* bckVals, PIXTYPE* sigmaVals,const size_t* gridSize)
316 {
317  PIXTYPE *back=NULL;
318  PIXTYPE *sigma=NULL;
319  PIXTYPE *backMod=NULL;
320  PIXTYPE val;
321  PIXTYPE sval;
322  float dist=0.;
323  float distMin=0;
324  size_t iAct,jAct, nx,ny, nmin;
325  size_t np;
326  bool hasHoles=false;
327 
328  // take the sizing information
329  nx = gridSize[0];
330  ny = gridSize[1];
331  np = gridSize[0]*gridSize[1];
332 
333  // check whether something needs to be done
334  for (size_t index=0; index< np; index++)
335  {
336  if (bckVals[index]<=-BIG)
337  {
338  hasHoles=true;
339  break;
340  }
341  }
342 
343  // nothing to do,
344  // just go back
345  if (!hasHoles)
346  return;
347 
348  // give some feedback that undefined data is replaced
349  bck_model_logger.debug() << "\tReplacing undefined data";
350 
351  // vector for the final
352  // background values
353  backMod = new PIXTYPE[np];
354 
355  // go to the array start
356  back = bckVals;
357  sigma = sigmaVals;
358 
359  // look for `bad' meshes and interpolate them if necessary
360  val = 0.0;
361  sval = 0.0;
362  iAct=0;
363  for (size_t py=0; py<ny; py++)
364  {
365  for (size_t px=0; px<nx; px++)
366  {
367  // compute the current index
368  iAct = py*nx+px;
369 
370  // transfer the value
371  backMod[iAct]=back[iAct];
372 
373  // check for undefined data
374  if (back[iAct]<=-BIG)
375  {
376 
377  // seek the closest data points,
378  // search over the entire array
379  distMin = BIG;
380  nmin = 0;
381  for (size_t y=0; y<ny; y++)
382  {
383  for (size_t x=0; x<nx; x++)
384  {
385  // compute the current index
386  jAct = y*nx+x;
387 
388  if (back[jAct]>-BIG)
389  {
390  // compute the pixel distance
391  dist = (float)SIZETSUB(x,px)*SIZETSUB(x,px)+SIZETSUB(y,py)*SIZETSUB(y,py);
392 
393  // check for a new minimum distance
394  if (dist<distMin)
395  {
396  // start new average values
397  val = back[jAct];
398  sval = sigma[jAct];
399  nmin = 1;
400  distMin = dist;
401  }
402  else if (fabs(dist-distMin)<1e-05)
403  {
404  // add equal distance pixel for averaging
405  val += back[jAct];
406  sval += sigma[jAct];
407  nmin++;
408  }
409  }
410  }
411  }
412  // take the mean of the closest
413  // defined data points
414  backMod[iAct] = nmin ? val/nmin: 0.0;
415  sigma[iAct] = nmin ? sval/nmin: 1.0;
416  }
417  }
418  }
419 
420  // push the modified values back
421  for (size_t index=0; index< np; index++)
422  {
423  bckVals[index] =backMod[index];
424  }
425 
426  // release the memory
427  if (backMod)
428  delete [] backMod;
429 
430  return;
431 }
432 
433 void SE2BackgroundModeller::filterMedian(PIXTYPE* bckVals, PIXTYPE* sigmaVals, const size_t* gridSize, const size_t* filterSize, const float filterThresh)
434 {
435  PIXTYPE *back, *sigma, *sigmat;
436  PIXTYPE* backFilt=NULL;
437  PIXTYPE* sigmaFilt=NULL;
438  PIXTYPE* bmask=NULL;
439  PIXTYPE* smask=NULL;
440  PIXTYPE allSigmaMed, median; //allBckMed
441  int i,nx,ny,npx,npx2,npy,npy2,x,y;
442  int np;
443 
444  // check whether something needs to be done at all
445  // note that the code would run nevertheless
446  if (filterSize[0]<2 && filterSize[1]<2)
447  return;
448 
449  // Note: I am converting the "size_t" to int's since
450  // there are computations done down.
451 
452  // take the sizing information
453  nx = (int)gridSize[0];
454  ny = (int)gridSize[1];
455  np = nx*ny;
456 
457  // store the filter size
458  npx = (int)filterSize[0]/2;
459  npy = (int)filterSize[1]/2;
460  npy *= nx;
461 
462  // allocate space for the work area
463  bmask = new PIXTYPE[(2*npx+1)*(2*npy+1)];
464  smask = new PIXTYPE[(2*npx+1)*(2*npy+1)];
465 
466  // allocate space for filtered arrays
467  backFilt = new PIXTYPE[np];
468  sigmaFilt = new PIXTYPE[np];
469 
470  // store the arrays locally
471  back = bckVals;
472  sigma = sigmaVals;
473 
474  // go over all y
475  for (int py=0; py<np; py+=nx)
476  {
477  // limit the filter box in y
478  npy2 = np - py - nx;
479  if (npy2>npy)
480  npy2 = npy;
481  if (npy2>py)
482  npy2 = py;
483 
484  // go over all x
485  for (int px=0; px<nx; px++)
486  {
487  // limit the filter box in x
488  npx2 = nx - px - 1;
489  if (npx2>npx)
490  npx2 = npx;
491  if (npx2>px)
492  npx2 = px;
493 
494  // store all values in the box
495  // in an array
496  i=0;
497  for (int dpy = -npy2; dpy<=npy2; dpy+=nx)
498  {
499  y = py+dpy;
500  for (int dpx = -npx2; dpx <= npx2; dpx++)
501  {
502  x = px+dpx;
503  bmask[i] = back[x+y];
504  smask[i++] = sigma[x+y];
505  }
506  }
507 
508  // compute the median, check
509  // whether the median is above the threshold
510  median = SE2BackgroundUtils::fqMedian(bmask, i);
511  if (fabs((median-back[px+py]))>=(PIXTYPE)filterThresh)
512  {
513  // use the median values
514  backFilt[px+py] = median;
515  sigmaFilt[px+py] = SE2BackgroundUtils::fqMedian(smask, i);
516  }
517  else
518  {
519  // use the original value
520  backFilt[px+py] = back[px+py];
521  sigmaFilt[px+py] = sigma[px+py];
522  }
523  }
524  }
525 
526  // transfer the filtered background values back
527  for (int index=0; index<np; index++)
528  back[index] = backFilt[index];
529 
530  // transfer the filtered sigma values back
531  for (int index=0; index<np; index++)
532  sigma[index] = sigmaFilt[index];
533 
534  // compute the median values for the background
535  // and the sigma
536  //allBckMed = SE2BackgroundUtils::fqMedian(backFilt, np);
537  allSigmaMed = SE2BackgroundUtils::fqMedian(sigmaFilt, np);
538 
539  // NOTE: I don't understand what that does.
540  // Why should the median sigma be <.0?
541  if (allSigmaMed<=0.0)
542  {
543  sigmat = sigmaFilt+np;
544  for (i=np; i-- && *(--sigmat)>0.0;);
545  if (i>=0 && i<(np-1))
546  allSigmaMed = SE2BackgroundUtils::fqMedian(sigmat+1, np-1-i);
547  else
548  {
549  //if (field->flags&(DETECT_FIELD|MEASURE_FIELD))
550  // warning("Image contains mainly constant data; ",
551  // "I'll try to cope with that...");
552  //field->backsig = 1.0;
553  allSigmaMed = 1.0;
554  }
555  }
556 
557  // release memory
558  delete [] sigmaFilt;
559  delete [] backFilt;
560  delete [] bmask;
561  delete [] smask;
562 
563  return;
564 }
565 
566 void SE2BackgroundModeller::computeScalingFactor(PIXTYPE* whtMeanVals, PIXTYPE* bckSigVals, PIXTYPE& sigFac, const size_t nGridPoints)
567 {
568 
569  size_t nr = 0;
570  size_t lowIndex=0;
571  PIXTYPE* ratio=NULL;
572 
573  PIXTYPE actRatio;
574  //PIXTYPE tmp;
575 
576  // allocate memory
577  ratio = new PIXTYPE[nGridPoints];
578 
579  // form the list of ratios between measured sigma values
580  // and the sigma's properly derived from the weights
581 
582  for (size_t index=0; index<nGridPoints; index++){
583  if (whtMeanVals[index]>0.0){
584  //actRatio = bckSigVals[index] / sqrt(whtMeanVals[index]);
585  actRatio = bckSigVals[index] * bckSigVals[index] / whtMeanVals[index]; // scaling factor for the variance image
586  if (actRatio>0.0){
587  ratio[nr]=actRatio;
588  nr++;
589  }
590  }
591  }
592 
593  // use the median ratio as scaling factor
594  sigFac = SE2BackgroundUtils::fqMedian(ratio, nr);
595 
596  // count leading 0.0 values in the list
597  for (lowIndex=0; lowIndex<nr && ratio[lowIndex]<=0.0; lowIndex++);
598 
599  // re-calculated the median, omitting
600  // the leading 0.0 values; I can't see
601  // how there should be leading zeros
602  // TODO: check whether this make sense
603  if (lowIndex>0){
604  if (lowIndex<nr){
605  // make a log message
606  bck_model_logger.debug() << "\tRe-calculating the scaling due to leading zeros";
607  sigFac = SE2BackgroundUtils::fqMedian(ratio+lowIndex, nr-lowIndex);
608  }
609  else {
610  //warning("Null or negative global weighting factor:","defaulted to 1");
611  bck_model_logger.debug() << "\tNull or negative global weighting factor: " << " | " << lowIndex << "defaulted to 1 " << nr;
612  sigFac = 1.0;
613  }
614  }
615 
616  delete [] ratio;
617  return;
618 }
619 
620 void SE2BackgroundModeller::rescaleThreshold(PIXTYPE &weightVarThreshold, const PIXTYPE &weightThreshold)
621 {
622  // the threshold needs to be larger than zero
623  if (weightThreshold<0.0){
624  throw Elements::Exception() << "The weight threshold is: " << weightThreshold << " but can not be smaller than 0.0";
625  }
626 
627  // check the type flag
628  switch (itsWeightTypeFlag){
629 
630  case VAR_FIELD:
631  // just copy for variance
632  weightVarThreshold = weightThreshold;
633  break;
634 
635  case RMS_FIELD:
636  // square for rms
637  weightVarThreshold = weightThreshold*weightThreshold;
638  break;
639 
640  case WEIGHT_FIELD:
641  // give default or invert for weight
642  if (weightThreshold>0.0){
643  weightVarThreshold = 1.0/weightThreshold;
644  }
645  else {
646  weightVarThreshold = BIG;
647  }
648  break;
649 
650  default:
651  // this is the default
652  weightVarThreshold = BIG;
653  break;
654  }
655  return;
656 }
657 
658 PIXTYPE *SE2BackgroundModeller::getWhtMeanVals()
659 {
660  return itsWhtMeanVals;
661 }
662 } // end of namespace SourceXtractor
WEIGHT_FIELD
#define WEIGHT_FIELD
Definition: BackgroundDefine.h:41
SourceXtractor::PIXTYPE
float PIXTYPE
Definition: BackgroundDefine.h:30
SourceXtractor::ImageAccessor
Definition: ImageAccessor.h:41
std::shared_ptr
STL class.
std::fabs
T fabs(T... args)
RMS_FIELD
#define RMS_FIELD
Definition: BackgroundDefine.h:39
SIZETSUB
#define SIZETSUB(X, Y)
Definition: SE2BackgroundModeller.cpp:37
std::div
T div(T... args)
SourceXtractor::Image< unsigned char >
BackgroundDefine.h
BACK_BUFSIZE
#define BACK_BUFSIZE
Definition: BackgroundDefine.h:50
Utils.h
SourceXtractor
Definition: Aperture.h:30
std::ratio
Exception.h
Elements::Exception
VAR_FIELD
#define VAR_FIELD
Definition: BackgroundDefine.h:40
Elements::Logging::debug
void debug(const std::string &logMessage)
SourceXtractor::BackgroundCell
Definition: BackgroundCell.h:32
e
constexpr double e
SourceXtractor::BackgroundCell::getBackgroundValues
void getBackgroundValues(PIXTYPE &meanVal, PIXTYPE &sigmaVal)
Definition: BackgroundCell.cpp:64
BIG
#define BIG
Definition: BackgroundDefine.h:32
SourceXtractor::bck_model_logger
static Elements::Logging bck_model_logger
Definition: Utils.h:25
BackgroundCell.h
x
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > x
Definition: MoffatModelFittingTask.cpp:94
std
STL namespace.
SE2BackgroundUtils.h
SE2BackgroundModeller.h
std::size_t
TypedSplineModelWrapper.h
y
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > y
Definition: MoffatModelFittingTask.cpp:94
ImageAccessor.h
SourceXtractor::TypedSplineModelWrapper
Definition: TypedSplineModelWrapper.h:35