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