MorphoGraphX  2.0-1-227
StackProcessFilters.hpp
Go to the documentation of this file.
1 //
2 // This file is part of MorphoGraphX - http://www.MorphoGraphX.org
3 // Copyright (C) 2012-2016 Richard S. Smith and collaborators.
4 //
5 // If you use MorphoGraphX in your work, please cite:
6 // http://dx.doi.org/10.7554/eLife.05864
7 //
8 // MorphoGraphX is free software, and is licensed under under the terms of the
9 // GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
10 //
11 #ifndef STACKPROCESSFILTERS_HPP
12 #define STACKPROCESSFILTERS_HPP
13 
14 #include <Process.hpp>
15 
16 namespace mgx
17 {
20 
28  class mgxBase_EXPORT AverageStack : public Process
29  {
30  public:
31  AverageStack(const Process& process) : Process(process)
32  {
33  setName("Stack/Filters/Average");
34  setDesc("Average stack data with a square filter.");
35  setIcon(QIcon(":/images/AvgPix.png"));
36 
37  addParm("X Radius","X Radius","1");
38  addParm("Y Radius","Y Radius","1");
39  addParm("Z Radius","Z Radius","1");
40  addParm("Steps","Steps","1");
41  }
42 
43  bool run()
44  {
45  if(!checkState().store(STORE_NON_EMPTY))
46  return false;
47  Store* input = currentStack()->currentStore();
48  Store* output = currentStack()->work();
49  Point3i r(parm("X Radius").toInt(), parm("Y Radius").toInt(), parm("Z Radius").toInt());
50  bool res = run(input, output, r, parm("Steps").toUInt());
51  if(res) {
52  input->hide();
53  output->show();
54  }
55  return res;
56  }
57 
58  bool run(const Store* input, Store* output, Point3i radius, uint steps);
59  };
60 
64  class mgxBase_EXPORT MedianStack : public Process
65  {
66  public:
67  MedianStack(const Process& process) : Process(process)
68  {
69  setName("Stack/Filters/Median");
70  setDesc("Median of stack data.");
71  setIcon(QIcon(":/images/AvgPix.png"));
72 
73  addParm("X Radius","X Radius","1");
74  addParm("Y Radius","Y Radius","1");
75  addParm("Z Radius","Z Radius","1");
76  }
77 
78  bool run()
79  {
80  if(!checkState().store(STORE_NON_EMPTY))
81  return false;
82  Store* input = currentStack()->currentStore();
83  Store* output = currentStack()->work();
84  Point3i r(parm("X Radius").toInt(), parm("Y Radius").toInt(), parm("Z Radius").toInt());
85  bool res = run(input, output, r);
86  if(res) {
87  input->hide();
88  output->show();
89  }
90  return res;
91  }
92 
93  bool run(const Store* input, Store* output, Point3i radius);
94  };
95 
99  class mgxBase_EXPORT MedianOfMediansStack : public Process
100  {
101  public:
102  MedianOfMediansStack(const Process& process) : Process(process)
103  {
104 
105  setName("Stack/Filters/Median of Medians");
106  setDesc("Median of medians of stack data.");
107  setIcon(QIcon(":/images/AvgPix.png"));
108 
109  addParm("X Radius","X Radius","1");
110  addParm("Y Radius","Y Radius","1");
111  addParm("Z Radius","Z Radius","1");
112  }
113 
114  bool run()
115  {
116  if(!checkState().store(STORE_NON_EMPTY))
117  return false;
118  Store* input = currentStack()->currentStore();
119  Store* output = currentStack()->work();
120  Point3i r(parm("X Radius").toInt(), parm("Y Radius").toInt(), parm("Z Radius").toInt());
121  bool res = run(input, output, r);
122  if(res) {
123  input->hide();
124  output->show();
125  }
126  return res;
127  }
128 
129  bool run(const Store* input, Store* output, Point3i radius);
130 
131  };
132 
144  class mgxBase_EXPORT BrightenStack : public Process {
145  public:
146  BrightenStack(const Process& process) : Process(process)
147  {
148  setName("Stack/Filters/Brighten Darken");
149  setDesc("Brighten or Darken stack.\n"
150  "A value > 1 will brighten the stack, < 1 will darken it.\n"
151  "To convert from a 12bit to a 16bit stack, use 16.\n"
152  "To convert from a 8bit to a 16bit stack, use 256.");
153  setIcon(QIcon(":/images/Brightness.png"));
154 
155  addParm("Amount","Amount to multiply voxels. Use 16 for 12bit images and 256 for 8bit images","16.0");
156  }
157 
158  bool run()
159  {
160  if(!checkState().store(STORE_NON_EMPTY))
161  return false;
162  Stack* s = currentStack();
163  Store* input = s->currentStore();
164  Store* output = s->work();
165  bool res = run(input, output, parm("Amount").toFloat());
166  if(res) {
167  input->hide();
168  output->show();
169  }
170  return res;
171  }
172 
173  bool run(const Store* input, Store* output, float brightness);
174 
175  };
176 
183  class mgxBase_EXPORT BinarizeStack : public Process
184  {
185  public:
186  BinarizeStack(const Process& process) : Process(process)
187  {
188  setName("Stack/Filters/Binarize");
189  setDesc("Transform the stack to binary (65535 or 0).\n"
190  "All voxels with an intensity greater than the threshold to 65535, while to others are set to 0.");
191  setIcon(QIcon(":/images/Brightness.png"));
192 
193  addParm("Threshold","Voxels above this threshold will be assigned 1.","5000");
194  }
195 
196  bool run()
197  {
198  if(!checkState().store(STORE_NON_EMPTY))
199  return false;
200  Stack* s = currentStack();
201  Store* input = s->currentStore();
202  Store* output = s->work();
203  bool res = run(input, output, parm("Threshold").toUShort());
204  if(res) {
205  input->hide();
206  output->show();
207  }
208  return res;
209  }
210 
211  bool run(const Store* input, Store* output, ushort threshold);
212 
213  };
214 
220  class mgxBase_EXPORT ColorGradient : public Process
221  {
222  public:
223  ColorGradient(const Process& process) : Process(process)
224  {
225  setName("Stack/Filters/Color Gradient");
226  setDesc("Compute color gradient in Z direction");
227  setIcon(QIcon(":/images/ColorGrad.png"));
228 
229  addParm("Z Divisor","Factor by which the gradient is divided by.","5.0");
230  }
231 
232  bool run()
233  {
234  if(!checkState().store(STORE_NON_EMPTY))
235  return false;
236  Stack* s = currentStack();
237  Store* input = s->currentStore();
238  Store* output = s->work();
239  bool res = run(input, output, parm("Z Divisor").toFloat());
240  if(res) {
241  input->hide();
242  output->show();
243  }
244  return res;
245  }
246 
247  bool run(const Store* input, Store* output, float colorGradDiv);
248  };
249 
255  class mgxBase_EXPORT InvertStack : public Process
256  {
257  public:
258  InvertStack(const Process& process) : Process(process)
259  {
260  setName("Stack/Filters/Invert");
261  setDesc("Invert the stack");
262  setIcon(QIcon(":/images/Invert.png"));
263  }
264 
265  bool run()
266  {
267  if(!checkState().store(STORE_NON_EMPTY))
268  return false;
269  Stack* s = currentStack();
270  Store* input = s->currentStore();
271  Store* output = s->work();
272  bool res = run(input, output);
273  if(res) {
274  input->hide();
275  output->show();
276  }
277  return res;
278  }
279 
280  bool run(const Store* input, Store* output);
281 
282  };
283 
289  class mgxBase_EXPORT FilterStack : public Process
290  {
291  public:
292  FilterStack(const Process& process) : Process(process)
293  {
294  setName("Stack/Filters/Trim High Low Values");
295  setDesc("Clip the voxel intensities to the interval [Low Threshold, High Threshold].");
296  setIcon(QIcon(":/images/Filter.png"));
297 
298  addParm("Low Threshold","Lower bound","1000");
299  addParm("High Threshold","Upper bound","0");
300  }
301 
302  bool run()
303  {
304  if(!checkState().store(STORE_NON_EMPTY))
305  return false;
306  Stack* s = currentStack();
307  Store* input = s->currentStore();
308  Store* output = s->work();
309  bool res = run(input, output, parm("Low Threshold").toUInt(), parm("High Threshold").toUInt());
310  if(res) {
311  input->hide();
312  output->show();
313  }
314  return res;
315  }
316 
317  bool run(const Store* input, Store* output, uint lowFilter, uint highFilter);
318 
319  };
320 
329  class mgxBase_EXPORT GaussianBlurStack : public Process
330  {
331  public:
332  GaussianBlurStack(const Process& process) : Process(process)
333  {
334  setName("Stack/Filters/Gaussian Blur Stack");
335  setDesc("Blur the stack, radius = 3 x Sigma");
336  setIcon(QIcon(":/images/Gaussian.png"));
337 
338  addParm("X Sigma (µm)","X Sigma (µm)","0.3");
339  addParm("Y Sigma (µm)","Y Sigma (µm)","0.3");
340  addParm("Z Sigma (µm)","Z Sigma (µm)","0.3");
341  }
342 
343  bool run()
344  {
345  if(!checkState().store(STORE_NON_EMPTY))
346  return false;
347  Stack* s = currentStack();
348  Store* input = s->currentStore();
349  Store* output = s->work();
350  Point3f sigma(parm("X Sigma (µm)").toFloat(), parm("Y Sigma (µm)").toFloat(), parm("Z Sigma (µm)").toFloat());
351  bool res = run(input, output, sigma);
352  if(res) {
353  input->hide();
354  output->show();
355  }
356  return res;
357  }
358 
359  bool run(const Store* input, Store* output, Point3f sigma);
360  };
361 
370  class mgxBase_EXPORT DiffGaussians : public Process
371  {
372  public:
373  DiffGaussians(const Process& process) : Process(process)
374  {
375  setName("Stack/Filters/Diff Gaussians");
376  setDesc("Difference of Gaussians, first - second");
377  setIcon(QIcon(":/images/DiffGaussians.png"));
378 
379  addParm("X1 Sigma (µm)","X1 Sigma (µm)","0.3");
380  addParm("Y1 Sigma (µm)","Y1 Sigma (µm)","0.3");
381  addParm("Z1 Sigma (µm)","Z1 Sigma (µm)","0.3");
382  addParm("X2 Sigma (µm)","X2 Sigma (µm)","10.0");
383  addParm("Y2 Sigma (µm)","Y2 Sigma (µm)","10.0");
384  addParm("Z2 Sigma (µm)","Z2 Sigma (µm)","10.0");
385  }
386 
387  bool run()
388  {
389  if(!checkState().store(STORE_NON_EMPTY))
390  return false;
391  Stack* s = currentStack();
392  Store* input = s->currentStore();
393  Store* output = s->work();
394  Point3f sigma1(parm("X1 Sigma (µm)").toFloat(), parm("Y1 Sigma (µm)").toFloat(), parm("Z1 Sigma (µm)").toFloat());
395  Point3f sigma2(parm("X2 Sigma (µm)").toFloat(), parm("Y2 Sigma (µm)").toFloat(), parm("Z2 Sigma (µm)").toFloat());
396  bool res = run(input, output, sigma1, sigma2);
397  if(res) {
398  input->hide();
399  output->show();
400  }
401  return res;
402  }
403 
404  bool run(const Store* input, Store* output, Point3f sigma1, Point3f sigma2);
405 
406  };
407 
417  class mgxBase_EXPORT SharpenStack : public Process
418  {
419  public:
420  SharpenStack(const Process& process) : Process(process)
421  {
422  setName("Stack/Filters/Sharpen Stack");
423  setDesc("Sharpen the stack, radius = 3 x Sigma");
424  setIcon(QIcon(":/images/Sharpen.png"));
425 
426  addParm("X Sigma (µm)","X Sigma (µm)","0.2");
427  addParm("Y Sigma (µm)","Y Sigma (µm)","0.2");
428  addParm("Z Sigma (µm)","Z Sigma (µm)","1.0");
429  addParm("Amount","Amount","1.0");
430  addParm("Passes","Passes","1");
431  }
432 
433  bool run()
434  {
435  if(!checkState().store(STORE_NON_EMPTY))
436  return false;
437  Stack* s = currentStack();
438  Store* input = s->currentStore();
439  Store* output = s->work();
440  Point3f sigma(parm("X Sigma (µm)").toFloat(), parm("Y Sigma (µm)").toFloat(), parm("Z Sigma (µm)").toFloat());
441  bool res = run(input, output, sigma, parm("Amount").toFloat(), parm("Passes").toInt());
442  if(res) {
443  input->hide();
444  output->show();
445  }
446  return res;
447  }
448 
449  bool run(const Store* input, Store* output,
450  const Point3f &sigma, float amount, int passes);
451  };
452 
461  //class mgxBase_EXPORT ApplyKernelStack : public Process {
462  //public:
463  //ApplyKernelStack(const Process& process) : Process(process)
464  //{
465  //setName("Stack/Filters/Apply Separable Kernel");
466  //setDesc("Kernel must have odd number of values");
467  //setIcon(QIcon(":/images/Kernel.png"));
468 
469  //addParm("X Kernel","X Kernel","-.1 1.2 -.1");
470  //addParm("Y Kernel","Y Kernel","-.1 1.2 -.1");
471  //addParm("Z Kernel","Z Kernel","-.1 1.2 -.1");
472  //}
473 
474  //bool run()
475  //{
476  //if(!checkState().store(STORE_NON_EMPTY))
477  //return false;
478  //Stack* s = currentStack();
479  //Store* input = s->currentStore();
480  //Store* output = s->work();
481  //HVecF kernels[3];
482  //bool ok;
483  //QString fields[3] = { "x", "y", "z" };
484  //for(int i = 0; i < 3; i++) {
485  //QString str = QString(parms[i]).trimmed();
486  //QStringList field_values = str.split(" ", QString::SkipEmptyParts);
487  //kernels[i].resize(field_values.size());
488  //for(size_t j = 0; j < (size_t)field_values.size(); ++j) {
489  //kernels[i][j] = field_values[j].toFloat(&ok);
490  //if(not ok)
491  //return setErrorMessage(
492  //QString("Value %1 of field %2 if not a valid number.").arg(j).arg(fields[i]));
493  //}
494  //}
495 
496  //bool res = run(input, output, kernels[0], kernels[1], kernels[2]);
497  //if(res) {
498  //input->hide();
499  //output->show();
500  //}
501  //return res;
502  //}
503  //bool run(const Store* input, Store* output, const HVecF& kernelX, const HVecF& kernelY,
504  //const HVecF& kernelZ);
505  //};
506 
516  class mgxBase_EXPORT NormalizeStack : public Process
517  {
518  public:
519  NormalizeStack(const Process& process) : Process(process)
520  {
521  setName("Stack/Filters/Normalize Stack");
522  setDesc("Normalize the stack");
523  setIcon(QIcon(":/images/Normalize.png"));
524 
525  addParm("X Radius (µm)","X Radius (µm) for the locality of normalization","5.0");
526  addParm("Y Radius (µm)","Y Radius (µm) for the locality of normalization","5.0");
527  addParm("Z Radius (µm)","Z Radius (µm) for the locality of normalization","5.0");
528  addParm("X Sigma (µm)","X Sigma (µm) for pre-blur","0.5");
529  addParm("Y Sigma (µm)","Y Sigma (µm) for pre-blur","0.5");
530  addParm("Z Sigma (µm)","Z Sigma (µm) for pre-blur","0.5");
531  addParm("Threshold","Threshold under which pixels are cleared considered as background","10000");
532  addParm("Blur factor","Relative contribution of blurred vs unblurred dilation","0.7");
533  }
534 
535  bool run()
536  {
537  if(!checkState().store(STORE_NON_EMPTY))
538  return false;
539  Stack* s = currentStack();
540  Store* input = s->currentStore();
541  Store* output = s->work();
542  Point3f radius(parm("X Radius (µm)").toFloat(), parm("Y Radius (µm)").toFloat(), parm("Z Radius (µm)").toFloat());
543  Point3f sigma(parm("X Sigma (µm)").toFloat(), parm("Y Sigma (µm)").toFloat(), parm("Z Sigma (µm)").toFloat());
544  bool res = run(input, output, radius, sigma, parm("Threshold").toUInt(), parm("Blur factor").toFloat());
545  if(res) {
546  input->hide();
547  output->show();
548  }
549  return res;
550  }
551 
552  bool run(const Store* input, Store* output, Point3f radius, Point3f sigma,
553  uint threshold, float blurFactor);
554  };
555 
561  class mgxBase_EXPORT CImgGaussianBlurStack : public Process
562  {
563  public:
564  CImgGaussianBlurStack(const Process& process) : Process(process)
565  {
566  setName("Stack/CImage/Gaussian Blur");
567  setDesc("CImage Gaussian Blur");
568  setIcon(QIcon(":/images/Blur.png"));
569 
570  addParm("Radius","Radius","5");
571  }
572 
573  bool run()
574  {
575  if(!checkState().store(STORE_NON_EMPTY))
576  return false;
577  Stack* s = currentStack();
578  Store* input = s->currentStore();
579  Store* output = s->work();
580  bool res = run(input, output, parm("Radius").toUInt());
581  if(res) {
582  input->hide();
583  output->show();
584  }
585  return res;
586  }
587 
588  bool run(const Store* input, Store* output, uint radius);
589  };
590 
596  class mgxBase_EXPORT CImgMedianBlurStack : public Process
597  {
598  public:
599  CImgMedianBlurStack(const Process& process) : Process(process)
600  {
601  setName("Stack/CImage/Median Blur");
602  setDesc("CImage Median Blur");
603  setIcon(QIcon(":/images/Blur.png"));
604 
605  addParm("Radius (voxels)","Size of the median filter.","3");
606  }
607 
608  bool run()
609  {
610  if(!checkState().store(STORE_NON_EMPTY))
611  return false;
612  Stack* s = currentStack();
613  Store* input = s->currentStore();
614  Store* output = s->work();
615  bool res = run(input, output, parm("Radius (voxels)").toUInt());
616  if(res) {
617  input->hide();
618  output->show();
619  }
620  return res;
621  }
622 
623  bool run(const Store* input, Store* output, uint radius);
624  };
625 
631  class mgxBase_EXPORT CImgLaplaceStack : public Process
632  {
633  public:
634  CImgLaplaceStack(const Process& process) : Process(process)
635  {
636  setName("Stack/CImage/Laplace Transform");
637  setIcon(QIcon(":/images/Laplace.png"));
638  }
639 
640  bool run()
641  {
642  if(!checkState().store(STORE_NON_EMPTY))
643  return false;
644  Stack* s = currentStack();
645  Store* input = s->currentStore();
646  Store* output = s->work();
647  bool res = run(input, output);
648  if(res) {
649  input->hide();
650  output->show();
651  }
652  return res;
653  }
654 
655  bool run(const Store* input, Store* output);
656  };
657 
665  class mgxBase_EXPORT TopHatStack : public Process
666  {
667  public:
668  TopHatStack(const Process& process) : Process(process)
669  {
670  setName("Stack/Filters/Top Hat");
671  setDesc("Perform Top Hat transformation on stack, used for background subtraction");
672  setIcon(QIcon(":/images/TopHat.png"));
673 
674  addParm("X Radius","X Radius","10");
675  addParm("Y Radius","Y Radius","10");
676  addParm("Z Radius","Z Radius","10");
677  addParm("Round Nhbd","Use a round (Ellipsoidal) neighborhood","No",booleanChoice());
678  }
679 
680  bool run()
681  {
682  if(!checkState().store(STORE_NON_EMPTY))
683  return false;
684  Stack* s = currentStack();
685  Store* input = s->currentStore();
686  Store* output = s->work();
687  bool res = run(s, input, output,
688  parm("X Radius").toUInt(), parm("Y Radius").toUInt(), parm("Z Radius").toUInt(), stringToBool(parm("Round Nhbd")));
689  if(res) {
690  input->hide();
691  output->show();
692  }
693  return res;
694  }
695 
696  bool run(Stack* stack, const Store* input, Store* output,
697  uint xradius, uint yradius, uint zradius, bool roundNhbd);
698  };
699 
705  class mgxBase_EXPORT AddNoiseStack : public Process
706  {
707  public:
708  AddNoiseStack(const Process& process) : Process(process)
709  {
710  setName("Stack/Filters/Add Noise");
711  setDesc("Perform Top Hat transformation on stack, used for background subtraction");
712  setIcon(QIcon(":/images/TopHat.png"));
713 
714  addParm("Amount","Amount of noise to add","1000");
715  }
716 
717  bool run()
718  {
719  if(!checkState().store(STORE_NON_EMPTY))
720  return false;
721  Stack* s = currentStack();
722  Store* input = s->currentStore();
723  Store* output = s->work();
724  bool res = run(s, input, output, parm("Amount").toUInt());
725  if(res) {
726  input->hide();
727  output->show();
728  }
729  return res;
730  }
731 
732  bool run(Stack* stack, const Store* input, Store* output, uint amount);
733  };
734 
736 }
737 
738 #endif
mgx::CImgGaussianBlurStack
Definition: StackProcessFilters.hpp:561
mgx::MedianStack
Uses quickselect to compute the local median of each voxel of the stack.
Definition: StackProcessFilters.hpp:64
mgx::uint
unsigned int uint
Definition: Geometry.hpp:41
Process.hpp
mgx::CImgLaplaceStack::CImgLaplaceStack
CImgLaplaceStack(const Process &process)
Definition: StackProcessFilters.hpp:634
mgx::CImgLaplaceStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:640
mgx::NormalizeStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:535
mgx::BinarizeStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:196
mgx::Stack::work
const Store * work() const
Access the work store.
Definition: Stack.hpp:101
mgx::ColorGradient::ColorGradient
ColorGradient(const Process &process)
Definition: StackProcessFilters.hpp:223
mgx::AddNoiseStack
Definition: StackProcessFilters.hpp:705
mgx::GaussianBlurStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:343
mgx::Stack::currentStore
const Store * currentStore() const
Returns the current store.
Definition: Stack.hpp:120
mgx::CImgGaussianBlurStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:573
mgx::ColorGradient
Definition: StackProcessFilters.hpp:220
mgx::CImgMedianBlurStack::CImgMedianBlurStack
CImgMedianBlurStack(const Process &process)
Definition: StackProcessFilters.hpp:599
mgx::MedianOfMediansStack::MedianOfMediansStack
MedianOfMediansStack(const Process &process)
Definition: StackProcessFilters.hpp:102
mgx::NormalizeStack
Definition: StackProcessFilters.hpp:516
mgx::ushort
unsigned short ushort
Simpler names for the various containers and iterators.
Definition: Geometry.hpp:42
mgx::BinarizeStack::BinarizeStack
BinarizeStack(const Process &process)
Definition: StackProcessFilters.hpp:186
mgx::SharpenStack
Definition: StackProcessFilters.hpp:417
mgx::Stack
Definition: Stack.hpp:33
mgx::MedianStack::MedianStack
MedianStack(const Process &process)
Definition: StackProcessFilters.hpp:67
mgx::AverageStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:43
mgx
Distributed matrix library.
Definition: Assert.hpp:26
mgx::DiffGaussians::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:387
mgx::Store::hide
void hide()
Ask the user interface to hide this store.
Definition: Store.hpp:167
mgx::CImgLaplaceStack
Definition: StackProcessFilters.hpp:631
mgx::SharpenStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:433
mgx::GaussianBlurStack
Definition: StackProcessFilters.hpp:329
mgx::MedianOfMediansStack
Sepearable median-of-medians approximation to median filter.
Definition: StackProcessFilters.hpp:99
mgx::Process
Definition: Process.hpp:219
mgx::BinarizeStack
Definition: StackProcessFilters.hpp:183
mgx::stringToBool
mgx_EXPORT bool stringToBool(const QString &string)
Helper function converting a string into a boolean.
mgx::AverageStack::AverageStack
AverageStack(const Process &process)
Definition: StackProcessFilters.hpp:31
mgx::InvertStack::InvertStack
InvertStack(const Process &process)
Definition: StackProcessFilters.hpp:258
mgx::DiffGaussians
Definition: StackProcessFilters.hpp:370
mgx::CImgMedianBlurStack
Definition: StackProcessFilters.hpp:596
mgx::FilterStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:302
mgx::SharpenStack::SharpenStack
SharpenStack(const Process &process)
Definition: StackProcessFilters.hpp:420
mgx::BrightenStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:158
mgx::DiffGaussians::DiffGaussians
DiffGaussians(const Process &process)
Definition: StackProcessFilters.hpp:373
mgx::GaussianBlurStack::GaussianBlurStack
GaussianBlurStack(const Process &process)
Definition: StackProcessFilters.hpp:332
mgx::Store::show
void show()
Ask the user interface to show this store.
Definition: Store.hpp:162
mgx::TopHatStack::TopHatStack
TopHatStack(const Process &process)
Definition: StackProcessFilters.hpp:668
mgx::MedianOfMediansStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:114
mgx::Vector< 3, int >
mgx::FilterStack
Definition: StackProcessFilters.hpp:289
mgx::AverageStack
Definition: StackProcessFilters.hpp:28
mgx::FilterStack::FilterStack
FilterStack(const Process &process)
Definition: StackProcessFilters.hpp:292
mgx::NormalizeStack::NormalizeStack
NormalizeStack(const Process &process)
Definition: StackProcessFilters.hpp:519
mgx::CImgGaussianBlurStack::CImgGaussianBlurStack
CImgGaussianBlurStack(const Process &process)
Definition: StackProcessFilters.hpp:564
mgx::InvertStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:265
mgx::BrightenStack::BrightenStack
BrightenStack(const Process &process)
Definition: StackProcessFilters.hpp:146
mgx::ColorGradient::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:232
mgx::InvertStack
Definition: StackProcessFilters.hpp:255
mgx::TopHatStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:680
mgx::TopHatStack
Definition: StackProcessFilters.hpp:665
mgx::BrightenStack
Definition: StackProcessFilters.hpp:144
mgx::MedianStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:78
mgx::AddNoiseStack::AddNoiseStack
AddNoiseStack(const Process &process)
Definition: StackProcessFilters.hpp:708
mgx::AddNoiseStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:717
mgx::CImgMedianBlurStack::run
bool run()
Runs the process.
Definition: StackProcessFilters.hpp:608
mgx::Store
Definition: Store.hpp:33
Generated on Fri Jul 9 2021 18:34:54 for MorphoGraphX by   doxygen 1.8.17