26 #include <gsl/gsl_sort.h>
27 #include <gsl/gsl_wavelet.h>
29 #include "StatFactory.h"
30 #include "imageclasses/ImgReaderGdal.h"
31 #include "imageclasses/ImgWriterGdal.h"
36 enum FILTER_TYPE { median=0, var=1 , min=2, max=3, sum=4, mean=5, minmax=6, dilate=7, erode=8, close=9, open=10, homog=11, sobelx=12, sobely=13, sobelxy=14, sobelyx=-14, smooth=15, density=16, majority=17, mixed=18, smoothnodata=19, threshold=20, ismin=21, ismax=22, heterog=23, order=24, stdev=25, dwt=26, dwti=27, dwt_cut=28, dwt_cut_from=29};
38 enum PADDING { symmetric=0, replicate=1, circular=2, constant=3};
44 Filter(
const std::vector<double> &taps);
46 static PADDING getPadding(
const std::string& padString){
47 std::map<std::string, PADDING> padMap;
48 padMap[
"constant"]=filter::constant;
49 padMap[
"symmetric"]=filter::symmetric;
50 padMap[
"replicate"]=filter::replicate;
51 padMap[
"circular"]=filter::circular;
52 return(padMap[padString]);
55 static const gsl_wavelet_type* getWaveletType(
const std::string waveletType){
56 if(waveletType==
"daubechies")
return(gsl_wavelet_daubechies);
57 if(waveletType==
"daubechies_centered")
return(gsl_wavelet_daubechies_centered);
58 if(waveletType==
"haar")
return(gsl_wavelet_haar);
59 if(waveletType==
"haar_centered")
return(gsl_wavelet_haar_centered);
60 if(waveletType==
"bspline")
return(gsl_wavelet_bspline);
61 if(waveletType==
"bspline_centered")
return(gsl_wavelet_bspline_centered);
63 static FILTER_TYPE getFilterType(
const std::string filterType){
64 std::map<std::string, FILTER_TYPE> m_filterMap;
65 initFilterMap(m_filterMap);
66 return m_filterMap[filterType];
68 void setTaps(
const std::vector<double> &taps,
bool normalize=
true);
69 void pushClass(
short theClass=1){m_class.push_back(theClass);};
70 void pushMask(
short theMask=0){m_mask.push_back(theMask);};
71 template<
class T>
void filter(
const std::vector<T>& input, std::vector<T>& output);
72 template<
class T>
void filter(
const std::vector<T>& input, std::vector<T>& output,
const std::string& method,
int dim);
73 template<
class T>
void smooth(
const std::vector<T>& input, std::vector<T>& output,
short dim);
74 template<
class T>
void filter(T* input,
int inputSize, std::vector<T>& output);
75 template<
class T>
void smooth(T* input,
int inputSize, std::vector<T>& output,
short dim);
76 template<
class T>
void morphology(
const std::vector<T>& input, std::vector<T>& output,
const std::string& method,
int dim,
bool verbose=
false);
82 double getCentreWavelength(
const std::vector<double> &wavelengthIn,
const Vector2d<double>& srf,
const std::string& interpolationType,
double delta=1.0,
bool verbose=
false);
83 template<
class T>
double applySrf(
const std::vector<double> &wavelengthIn,
const std::vector<T>& input,
const Vector2d<double>& srf,
const std::string& interpolationType, T& output,
double delta=1.0,
bool normalize=
false,
bool verbose=
false);
84 template<
class T>
double applySrf(
const std::vector<double> &wavelengthIn,
const Vector2d<T>& input,
const Vector2d<double>& srf,
const std::string& interpolationType, std::vector<T>& output,
double delta=1.0,
bool normalize=
false,
int down=1,
bool transposeInput=
false,
bool verbose=
false);
86 template<
class T>
void applyFwhm(
const std::vector<double> &wavelengthIn,
const std::vector<T>& input,
const std::vector<double> &wavelengthOut,
const std::vector<double> &fwhm,
const std::string& interpolationType, std::vector<T>& output,
bool verbose=
false);
87 template<
class T>
void applyFwhm(
const std::vector<double> &wavelengthIn,
const Vector2d<T>& input,
const std::vector<double> &wavelengthOut,
const std::vector<double> &fwhm,
const std::string& interpolationType,
Vector2d<T>& output,
int down=1,
bool verbose=
false);
91 void dwtForward(std::vector<double>& data,
const std::string& wavelet_type,
int family);
92 void dwtInverse(std::vector<double>& data,
const std::string& wavelet_type,
int family);
93 void dwtCut(std::vector<double>& data,
const std::string& wavelet_type,
int family,
double cut);
98 static void initFilterMap(std::map<std::string, FILTER_TYPE>& m_filterMap){
100 m_filterMap[
"dwt"]=filter::dwt;
101 m_filterMap[
"dwti"]=filter::dwti;
102 m_filterMap[
"dwt_cut"]=filter::dwt_cut;
103 m_filterMap[
"dwt_cut_from"]=filter::dwt_cut_from;
104 m_filterMap[
"stdev"]=filter::stdev;
105 m_filterMap[
"var"]=filter::var;
106 m_filterMap[
"min"]=filter::min;
107 m_filterMap[
"max"]=filter::max;
108 m_filterMap[
"sum"]=filter::sum;
109 m_filterMap[
"mean"]=filter::mean;
110 m_filterMap[
"minmax"]=filter::minmax;
111 m_filterMap[
"dilate"]=filter::dilate;
112 m_filterMap[
"erode"]=filter::erode;
113 m_filterMap[
"close"]=filter::close;
114 m_filterMap[
"open"]=filter::open;
115 m_filterMap[
"homog"]=filter::homog;
116 m_filterMap[
"sobelx"]=filter::sobelx;
117 m_filterMap[
"sobely"]=filter::sobely;
118 m_filterMap[
"sobelxy"]=filter::sobelxy;
119 m_filterMap[
"sobelyx"]=filter::sobelyx;
120 m_filterMap[
"smooth"]=filter::smooth;
121 m_filterMap[
"density"]=filter::density;
122 m_filterMap[
"majority"]=filter::majority;
123 m_filterMap[
"mixed"]=filter::mixed;
124 m_filterMap[
"smoothnodata"]=filter::smoothnodata;
125 m_filterMap[
"threshold"]=filter::threshold;
126 m_filterMap[
"ismin"]=filter::ismin;
127 m_filterMap[
"ismax"]=filter::ismax;
128 m_filterMap[
"heterog"]=filter::heterog;
129 m_filterMap[
"order"]=filter::order;
130 m_filterMap[
"median"]=filter::median;
133 std::vector<double> m_taps;
134 std::vector<short> m_class;
135 std::vector<short> m_mask;
136 std::string m_padding;
141 template<
class T>
double Filter::applySrf(
const std::vector<double> &wavelengthIn,
const std::vector<T>& input,
const Vector2d<double>& srf,
const std::string& interpolationType, T& output,
double delta,
bool normalize,
bool verbose)
143 assert(srf.size()==2);
144 int nband=srf[0].size();
145 double start=floor(wavelengthIn[0]);
146 double end=ceil(wavelengthIn.back());
148 std::cout <<
"wavelengths in [" << start <<
"," << end <<
"]" << std::endl << std::flush;
152 gsl_interp_accel *acc;
155 stat.getSpline(interpolationType,nband,spline);
156 stat.initSpline(spline,&(srf[0][0]),&(srf[1][0]),nband);
158 std::cout <<
"calculating norm of srf" << std::endl << std::flush;
160 norm=gsl_spline_eval_integ(spline,srf[0].front(),srf[0].back(),acc);
162 std::cout <<
"norm of srf: " << norm << std::endl << std::flush;
163 gsl_spline_free(spline);
164 gsl_interp_accel_free(acc);
167 std::vector<double> wavelength_fine;
168 for(
double win=floor(wavelengthIn[0]);win<=ceil(wavelengthIn.back());win+=delta)
169 wavelength_fine.push_back(win);
172 std::cout <<
"interpolate wavelengths to " << wavelength_fine.size() <<
" entries " << std::endl;
173 std::vector<double> srf_fine;
175 stat.interpolateUp(srf[0],srf[1],wavelength_fine,interpolationType,srf_fine,verbose);
176 assert(srf_fine.size()==wavelength_fine.size());
178 gsl_interp_accel *accOut;
179 stat.allocAcc(accOut);
180 gsl_spline *splineOut;
181 stat.getSpline(interpolationType,wavelength_fine.size(),splineOut);
184 assert(wavelengthIn.size()==input.size());
185 std::vector<double> input_fine;
186 std::vector<double> product(wavelength_fine.size());
187 std::vector<double> wavelengthOut(wavelength_fine.size());
188 stat.interpolateUp(wavelengthIn,input,wavelength_fine,interpolationType,input_fine,verbose);
191 std::cout <<
"input_fine.size(): " << input_fine.size() << std::endl;
192 for(
int iband=0;iband<input_fine.size();++iband){
193 product[iband]=input_fine[iband]*srf_fine[iband];
194 wavelengthOut[iband]=wavelength_fine[iband]*srf_fine[iband];
197 assert(input_fine.size()==srf_fine.size());
198 assert(input_fine.size()==wavelength_fine.size());
199 stat.initSpline(splineOut,&(wavelength_fine[0]),&(product[0]),wavelength_fine.size());
201 output=gsl_spline_eval_integ(splineOut,start,end,accOut)/norm;
203 output=gsl_spline_eval_integ(splineOut,start,end,accOut);
205 stat.initSpline(splineOut,&(wavelength_fine[0]),&(wavelengthOut[0]),wavelength_fine.size());
206 double centreWavelength=gsl_spline_eval_integ(splineOut,start,end,accOut)/norm;
208 gsl_spline_free(splineOut);
209 gsl_interp_accel_free(accOut);
220 return(centreWavelength);
225 template<
class T>
double Filter::applySrf(
const std::vector<double> &wavelengthIn,
const Vector2d<T>& input,
const Vector2d<double>& srf,
const std::string& interpolationType, std::vector<T>& output,
double delta,
bool normalize,
int down,
bool transposeInput,
bool verbose)
227 assert(srf.size()==2);
228 int nband=srf[0].size();
229 unsigned int nsample=(transposeInput)? input.size():input[0].size();
230 output.resize((nsample+down-1)/down);
231 double start=floor(wavelengthIn[0]);
232 double end=ceil(wavelengthIn.back());
234 std::cout <<
"wavelengths in [" << start <<
"," << end <<
"]" << std::endl << std::flush;
238 gsl_interp_accel *acc;
241 stat.getSpline(interpolationType,nband,spline);
242 stat.initSpline(spline,&(srf[0][0]),&(srf[1][0]),nband);
244 std::cout <<
"calculating norm of srf" << std::endl << std::flush;
246 norm=gsl_spline_eval_integ(spline,srf[0].front(),srf[0].back(),acc);
248 std::cout <<
"norm of srf: " << norm << std::endl << std::flush;
249 gsl_spline_free(spline);
250 gsl_interp_accel_free(acc);
253 std::vector<double> wavelength_fine;
254 for(
double win=floor(wavelengthIn[0]);win<=ceil(wavelengthIn.back());win+=delta)
255 wavelength_fine.push_back(win);
258 std::cout <<
"interpolate wavelengths to " << wavelength_fine.size() <<
" entries " << std::endl;
259 std::vector<double> srf_fine;
261 stat.interpolateUp(srf[0],srf[1],wavelength_fine,interpolationType,srf_fine,verbose);
262 assert(srf_fine.size()==wavelength_fine.size());
264 gsl_interp_accel *accOut;
265 stat.allocAcc(accOut);
266 gsl_spline *splineOut;
267 stat.getSpline(interpolationType,wavelength_fine.size(),splineOut);
270 std::vector<double> wavelengthOut;
271 double centreWavelength=0;
272 for(
int isample=0;isample<nsample;++isample){
273 if((isample+1+down/2)%down)
275 std::vector<T> inputValues;
277 inputValues=input[isample];
279 input.selectCol(isample,inputValues);
280 assert(wavelengthIn.size()==inputValues.size());
281 std::vector<double> input_fine;
282 std::vector<double> product(wavelength_fine.size());
283 stat.interpolateUp(wavelengthIn,inputValues,wavelength_fine,interpolationType,input_fine,verbose);
285 for(
int iband=0;iband<input_fine.size();++iband){
286 product[iband]=input_fine[iband]*srf_fine[iband];
287 if(wavelengthOut.size()<input_fine.size())
288 wavelengthOut.push_back(wavelength_fine[iband]*srf_fine[iband]);
291 assert(input_fine.size()==srf_fine.size());
292 assert(input_fine.size()==wavelength_fine.size());
293 stat.initSpline(splineOut,&(wavelength_fine[0]),&(product[0]),wavelength_fine.size());
295 output[isample/down]=gsl_spline_eval_integ(splineOut,start,end,accOut)/norm;
297 output[isample/down]=gsl_spline_eval_integ(splineOut,start,end,accOut);
299 stat.initSpline(splineOut,&(wavelength_fine[0]),&(wavelengthOut[0]),wavelength_fine.size());
300 if(centreWavelength>0);
302 centreWavelength=gsl_spline_eval_integ(splineOut,start,end,accOut)/norm;
304 gsl_spline_free(splineOut);
305 gsl_interp_accel_free(accOut);
316 return(centreWavelength);
319 template<
class T>
void Filter::applyFwhm(
const std::vector<double> &wavelengthIn,
const std::vector<T>& input,
const std::vector<double> &wavelengthOut,
const std::vector<double> &fwhm,
const std::string& interpolationType, std::vector<T>& output,
bool verbose){
321 std::vector<double> stddev(fwhm.size());
322 for(
int index=0;index<fwhm.size();++index)
323 stddev[index]=fwhm[index]/2.0/sqrt(2*log(2.0));
324 assert(wavelengthOut.size()==fwhm.size());
325 assert(wavelengthIn.size()==input.size());
326 assert(wavelengthIn[0]<=wavelengthOut[0]);
327 assert(wavelengthIn.back()>=wavelengthOut.back());
329 std::vector<double> input_fine;
330 std::vector<double> wavelength_fine;
331 for(
double win=floor(wavelengthIn[0]);win<=ceil(wavelengthIn.back());win+=delta)
332 wavelength_fine.push_back(win);
334 for(
int index=0;index<wavelength_fine.size();++index)
335 std::cout <<
" " << wavelength_fine[index];
336 std::cout << std::endl;
337 std::cout <<
"interpolate input wavelength to " << delta <<
" nm resolution (size=" << wavelength_fine.size() <<
")" << std::endl;
339 stat.interpolateUp(wavelengthIn,input,wavelength_fine,interpolationType,input_fine,verbose);
340 int nbandIn=wavelength_fine.size();
342 int nbandOut=wavelengthOut.size();
343 output.resize(nbandOut);
345 for(
int indexOut=0;indexOut<nbandOut;++indexOut){
347 for(
int indexIn=0;indexIn<nbandIn;++indexIn){
349 tf[indexIn][indexOut]=
350 exp((wavelengthOut[indexOut]-wavelength_fine[indexIn])
351 *(wavelength_fine[indexIn]-wavelengthOut[indexOut])
352 /2.0/stddev[indexOut]
354 tf[indexIn][indexOut]/=sqrt(2.0*M_PI);
355 tf[indexIn][indexOut]/=stddev[indexOut];
356 norm+=tf[indexIn][indexOut];
359 for(
int indexIn=0;indexIn<nbandIn;++indexIn)
360 output[indexOut]+=input_fine[indexIn]*tf[indexIn][indexOut]/norm;
366 template<
class T>
void Filter::applyFwhm(
const std::vector<double> &wavelengthIn,
const Vector2d<T>& input,
const std::vector<double> &wavelengthOut,
const std::vector<double> &fwhm,
const std::string& interpolationType,
Vector2d<T>& output,
int down,
bool verbose){
368 std::vector<double> stddev(fwhm.size());
369 for(
int index=0;index<fwhm.size();++index)
370 stddev[index]=fwhm[index]/2.0/sqrt(2*log(2.0));
372 std::vector<double> wavelength_fine;
373 for(
double win=floor(wavelengthIn[0]);win<=ceil(wavelengthIn.back());win+=delta)
374 wavelength_fine.push_back(win);
375 assert(wavelengthOut.size()==fwhm.size());
376 assert(wavelengthIn[0]<=wavelengthOut[0]);
377 assert(wavelengthIn.back()>=wavelengthOut.back());
379 for(
int index=0;index<wavelength_fine.size();++index)
380 std::cout <<
" " << wavelength_fine[index];
381 std::cout << std::endl;
382 std::cout <<
"interpolate input wavelength to " << delta <<
" nm resolution (size=" << wavelength_fine.size() <<
")" << std::endl;
384 int nbandIn=wavelength_fine.size();
385 int nbandOut=wavelengthOut.size();
386 output.resize(nbandOut,(input[0].size()+down-1)/down);
389 std::vector<double> norm(nbandOut);
390 for(
int indexOut=0;indexOut<nbandOut;++indexOut){
392 for(
int indexIn=0;indexIn<nbandIn;++indexIn){
393 tf[indexIn][indexOut]=
394 exp((wavelengthOut[indexOut]-wavelength_fine[indexIn])
395 *(wavelength_fine[indexIn]-wavelengthOut[indexOut])
396 /2.0/stddev[indexOut]
398 tf[indexIn][indexOut]/=sqrt(2.0*M_PI);
399 tf[indexIn][indexOut]/=stddev[indexOut];
400 norm[indexOut]+=tf[indexIn][indexOut];
404 for(
int isample=0;isample<input[0].size();++isample){
405 if((isample+1+down/2)%down)
407 std::vector<T> inputValues;
408 input.selectCol(isample,inputValues);
409 assert(wavelengthIn.size()==inputValues.size());
410 for(
int indexOut=0;indexOut<nbandOut;++indexOut){
411 std::vector<double> input_fine;
412 stat.interpolateUp(wavelengthIn,inputValues,wavelength_fine,interpolationType,input_fine,verbose);
413 output[indexOut][(isample+down-1)/down]=0;
414 for(
int indexIn=0;indexIn<nbandIn;++indexIn){
415 output[indexOut][(isample+down-1)/down]+=input_fine[indexIn]*tf[indexIn][indexOut]/norm[indexOut];
421 template<
class T>
void Filter::smooth(
const std::vector<T>& input, std::vector<T>& output,
short dim)
425 for(
int itap=0;itap<dim;++itap)
426 m_taps[itap]=1.0/dim;
427 filter(input,output);
430 template<
class T>
void Filter::filter(
const std::vector<T>& input, std::vector<T>& output)
432 assert(input.size()>m_taps.size());
433 output.resize(input.size());
436 for(i=0;i<m_taps.size()/2;++i){
438 output[i]=m_taps[m_taps.size()/2]*input[i];
439 for(
int t=1;t<=m_taps.size()/2;++t){
440 output[i]+=m_taps[m_taps.size()/2+t]*input[i+t];
442 output[i]+=m_taps[m_taps.size()/2-t]*input[i-t];
444 switch(getPadding(m_padding)){
446 output[i]+=m_taps[m_taps.size()/2-t]*input[0];
449 output[i]+=m_taps[m_taps.size()/2-t]*input[input.size()+i-t];
452 output[i]+=m_taps[m_taps.size()/2-t]*0;
456 output[i]+=m_taps[m_taps.size()/2-t]*input[t-i];
464 for(i=m_taps.size()/2;i<input.size()-m_taps.size()/2;++i){
466 T leaveOut=(*(m_taps.begin()))*input[i-m_taps.size()/2];
467 T include=(m_taps.back())*input[i+m_taps.size()/2];
469 for(
int t=0;t<m_taps.size();++t)
470 output[i]+=input[i-m_taps.size()/2+t]*m_taps[t];
473 for(i=input.size()-m_taps.size()/2;i<input.size();++i){
475 output[i]=m_taps[m_taps.size()/2]*input[i];
477 for(
int t=1;t<=m_taps.size()/2;++t){
478 output[i]+=m_taps[m_taps.size()/2-t]*input[i-t];
480 output[i]+=m_taps[m_taps.size()/2+t]*input[i+t];
482 switch(getPadding(m_padding)){
484 output[i]+=m_taps[m_taps.size()/2+t]*input.back();
487 output[i]+=m_taps[m_taps.size()/2+t]*input[t-1];
490 output[i]+=m_taps[m_taps.size()/2+t]*0;
494 output[i]+=m_taps[m_taps.size()/2+t]*input[i-t];
503 template<
class T>
void Filter::filter(
const std::vector<T>& input, std::vector<T>& output,
const std::string& method,
int dim)
507 output.resize(input.size());
510 std::vector<T> statBuffer;
513 for(i=0;i<dim/2;++i){
515 for(
int iclass=0;iclass<m_class.size();++iclass){
516 if(input[i]==m_class[iclass]){
522 statBuffer.push_back(binValue);
524 statBuffer.push_back(input[i]);
526 for(
int t=1;t<=dim/2;++t){
527 T theValue=input[i+t];
528 for(
int iclass=0;iclass<m_class.size();++iclass){
529 if(theValue==m_class[iclass]){
535 statBuffer.push_back(binValue);
537 statBuffer.push_back(theValue);
543 switch(getPadding(m_padding)){
548 theValue=input[input.size()+i-t];
559 for(
int iclass=0;iclass<m_class.size();++iclass){
560 if(theValue==m_class[iclass]){
566 statBuffer.push_back(binValue);
568 statBuffer.push_back(theValue);
571 switch(getFilterType(method)){
572 case(filter::median):
573 output[i]=stat.median(statBuffer);
576 output[i]=stat.mymin(statBuffer);
579 output[i]=stat.mymax(statBuffer);
582 output[i]=sqrt(stat.sum(statBuffer));
585 output[i]=stat.var(statBuffer);
588 output[i]=stat.mean(statBuffer);
591 std::string errorString=
"method not supported";
598 for(i=dim/2;i<input.size()-dim/2;++i){
600 for(
int t=0;t<dim;++t){
601 for(
int iclass=0;iclass<m_class.size();++iclass){
602 if(input[i-dim/2+t]==m_class[iclass]){
608 statBuffer.push_back(binValue);
610 statBuffer.push_back(input[i-dim/2+t]);
612 switch(getFilterType(method)){
613 case(filter::median):
614 output[i]=stat.median(statBuffer);
617 output[i]=stat.mymin(statBuffer);
620 output[i]=stat.mymax(statBuffer);
623 output[i]=sqrt(stat.sum(statBuffer));
626 output[i]=stat.var(statBuffer);
629 output[i]=stat.mean(statBuffer);
632 std::string errorString=
"method not supported";
639 for(i=input.size()-dim/2;i<input.size();++i){
641 for(
int iclass=0;iclass<m_class.size();++iclass){
642 if(input[i]==m_class[iclass]){
648 statBuffer.push_back(binValue);
650 statBuffer.push_back(input[i]);
652 for(
int t=1;t<=dim/2;++t){
653 T theValue=input[i-t];
654 for(
int iclass=0;iclass<m_class.size();++iclass){
655 if(theValue==m_class[iclass]){
661 statBuffer.push_back(binValue);
663 statBuffer.push_back(theValue);
667 switch(getPadding(m_padding)){
669 theValue=input.back();
683 for(
int iclass=0;iclass<m_class.size();++iclass){
684 if(theValue==m_class[iclass]){
690 statBuffer.push_back(binValue);
692 statBuffer.push_back(theValue);
694 switch(getFilterType(method)){
695 case(filter::median):
696 output[i]=stat.median(statBuffer);
699 output[i]=stat.mymin(statBuffer);
702 output[i]=stat.mymax(statBuffer);
705 output[i]=sqrt(stat.sum(statBuffer));
708 output[i]=stat.var(statBuffer);
711 output[i]=stat.mean(statBuffer);
714 std::string errorString=
"method not supported";
723 template<
class T>
void Filter::morphology(
const std::vector<T>& input, std::vector<T>& output,
const std::string& method,
int dim,
bool verbose)
726 output.resize((input.size());
729 std::vector<T> statBuffer;
732 for(i=0;i<dim/2;++i){
734 for(
int iclass=0;iclass<m_class.size();++iclass){
735 if(input[i]==m_class[iclass]){
741 statBuffer.push_back(binValue);
743 statBuffer.push_back(input[i]);
744 for(
int t=1;t<=dim/2;++t){
746 for(
int iclass=0;iclass<m_class.size();++iclass){
747 if(input[i+t]==m_class[iclass]){
753 statBuffer.push_back(binValue);
754 statBuffer.push_back(binValue);
757 statBuffer.push_back(input[i+t]);
758 statBuffer.push_back(input[i+t]);
762 switch(getFilterType(method)){
763 case(filter::dilate):
764 output[i]=stat.mymax(statBuffer);
767 output[i]=stat.mymin(statBuffer);
770 std::string errorString=
"method not supported";
775 std::cout <<
"buffer: ";
776 for(
int ibuf=0;ibuf<statBuffer.size();++ibuf)
777 std::cout << statBuffer[ibuf] <<
" ";
778 std::cout <<
"->" << output[i] << std::endl;
783 for(i=dim/2;i<input.size()-dim/2;++i){
785 for(
int t=0;t<dim;++t){
786 for(
int iclass=0;iclass<m_class.size();++iclass){
787 if(input[i-dim/2+t]==m_class[iclass]){
793 statBuffer.push_back(binValue);
795 statBuffer.push_back(input[i-dim/2+t]);
798 switch(getFilterType(method)){
799 case(filter::dilate):
800 output[i]=stat.mymax(statBuffer);
803 output[i]=stat.mymin(statBuffer);
806 std::string errorString=
"method not supported";
811 std::cout <<
"buffer: ";
812 for(
int ibuf=0;ibuf<statBuffer.size();++ibuf)
813 std::cout << statBuffer[ibuf] <<
" ";
814 std::cout <<
"->" << output[i] << std::endl;
819 for(i=input.size()-dim/2;i<input.size();++i){
821 for(
int iclass=0;iclass<m_class.size();++iclass){
822 if(input[i]==m_class[iclass]){
828 statBuffer.push_back(binValue);
830 statBuffer.push_back(input[i]);
831 for(
int t=1;t<=dim/2;++t){
833 for(
int iclass=0;iclass<m_class.size();++iclass){
834 if(input[i-t]==m_class[iclass]){
840 statBuffer.push_back(binValue);
841 statBuffer.push_back(binValue);
844 statBuffer.push_back(input[i-t]);
845 statBuffer.push_back(input[i-t]);
849 switch(getFilterType(method)){
850 case(filter::dilate):
851 output[i]=stat.mymax(statBuffer);
854 output[i]=stat.mymin(statBuffer);
857 std::string errorString=
"method not supported";
862 std::cout <<
"buffer: ";
863 for(
int ibuf=0;ibuf<statBuffer.size();++ibuf)
864 std::cout << statBuffer[ibuf] <<
" ";
865 std::cout <<
"->" << output[i] << std::endl;
870 template<
class T>
void Filter::smooth(T* input,
int inputSize, std::vector<T>& output,
short dim)
874 for(
int itap=0;itap<dim;++itap)
875 m_taps[itap]=1.0/dim;
876 filter(input,output);
879 template<
class T>
void Filter::filter(T* input,
int inputSize, std::vector<T>& output)
881 output.resize((inputSize);
884 for(i=0;i<m_taps.size()/2;++i){
885 output[i]=m_taps[m_taps.size()/2]*input[i];
886 for(
int t=1;t<=m_taps.size()/2;++t)
887 output[i]+=(m_taps[m_taps.size()/2+t]+m_taps[m_taps.size()/2-t])*input[i+t];
890 for(i=m_taps.size()/2;i<inputSize-m_taps.size()/2;++i){
891 T leaveOut=(*(m_taps.begin()))*input[i-m_taps.size()/2];
892 T include=(m_taps.back())*input[i+m_taps.size()/2];
894 for(
int t=0;t<m_taps.size();++t)
895 output[i]+=input[i-m_taps.size()/2+t]*m_taps[t];
898 for(i=inputSize-m_taps.size()/2;i<inputSize;++i){
899 output[i]=m_taps[m_taps.size()/2]*input[i];
900 for(
int t=1;t<=m_taps.size()/2;++t)
901 output[i]+=(m_taps[m_taps.size()/2+t]+m_taps[m_taps.size()/2-t])*input[i-t];