23 #include "base/Optionpk.h"
24 #include "algorithms/StatFactory.h"
25 #include "algorithms/ImgRegression.h"
28 int main(
int argc,
char *argv[])
32 Optionpk<bool> filename_opt(
"f",
"filename",
"Shows image filename ",
false);
33 Optionpk<bool> stat_opt(
"stats",
"statistics",
"Shows basic statistics (min,max, mean and stdDev of the raster datasets)",
false);
39 Optionpk<short> down_opt(
"down",
"down",
"Down sampling factor (for raster sample datasets only). Can be used to create grid points", 1);
41 Optionpk<double> scale_opt(
"scale",
"scale",
"Scale(s) for reading input image(s)");
42 Optionpk<double> offset_opt(
"offset",
"offset",
"Offset(s) for reading input image(s)");
49 Optionpk<bool> median_opt(
"median",
"median",
"calculate median",
false);
51 Optionpk<bool> skewness_opt(
"skew",
"skewness",
"calculate skewness",
false);
52 Optionpk<bool> kurtosis_opt(
"kurt",
"kurtosis",
"calculate kurtosis",
false);
53 Optionpk<bool> stdev_opt(
"stdev",
"stdev",
"calculate standard deviation",
false);
54 Optionpk<bool> sum_opt(
"sum",
"sum",
"calculate sum of column",
false);
55 Optionpk<bool> minmax_opt(
"mm",
"minmax",
"calculate minimum and maximum value",
false);
56 Optionpk<bool> min_opt(
"min",
"min",
"calculate minimum value",
false);
57 Optionpk<bool> max_opt(
"max",
"max",
"calculate maximum value",
false);
58 Optionpk<double> src_min_opt(
"src_min",
"src_min",
"start reading source from this minimum value");
59 Optionpk<double> src_max_opt(
"src_max",
"src_max",
"stop reading source from this maximum value");
60 Optionpk<bool> histogram_opt(
"hist",
"hist",
"calculate histogram",
false);
61 Optionpk<bool> histogram2d_opt(
"hist2d",
"hist2d",
"calculate 2-dimensional histogram based on two images",
false);
62 Optionpk<short> nbin_opt(
"nbin",
"nbin",
"number of bins to calculate histogram");
63 Optionpk<bool> relative_opt(
"rel",
"relative",
"use percentiles for histogram to calculate histogram",
false);
64 Optionpk<bool> kde_opt(
"kde",
"kde",
"Use Kernel density estimation when producing histogram. The standard deviation is estimated based on Silverman's rule of thumb",
false);
65 Optionpk<bool> correlation_opt(
"cor",
"correlation",
"calculate Pearson produc-moment correlation coefficient between two raster datasets (defined by -c <col1> -c <col2>)",
false);
66 Optionpk<bool> rmse_opt(
"rmse",
"rmse",
"calculate root mean square error between two raster datasets",
false);
67 Optionpk<bool> reg_opt(
"reg",
"regression",
"calculate linear regression between two raster datasets and get correlation coefficient",
false);
68 Optionpk<bool> regerr_opt(
"regerr",
"regerr",
"calculate linear regression between two raster datasets and get root mean square error",
false);
69 Optionpk<bool> preg_opt(
"preg",
"preg",
"calculate perpendicular regression between two raster datasets and get correlation coefficient",
false);
70 Optionpk<short> verbose_opt(
"v",
"verbose",
"verbose mode when positive", 0,2);
76 random_opt.setHide(1);
78 offset_opt.setHide(1);
79 src_min_opt.setHide(1);
80 src_max_opt.setHide(1);
89 doProcess=input_opt.retrieveOption(argc,argv);
91 band_opt.retrieveOption(argc,argv);
92 filename_opt.retrieveOption(argc,argv);
93 stat_opt.retrieveOption(argc,argv);
94 nodata_opt.retrieveOption(argc,argv);
95 mean_opt.retrieveOption(argc,argv);
96 median_opt.retrieveOption(argc,argv);
97 var_opt.retrieveOption(argc,argv);
98 stdev_opt.retrieveOption(argc,argv);
99 minmax_opt.retrieveOption(argc,argv);
100 min_opt.retrieveOption(argc,argv);
101 max_opt.retrieveOption(argc,argv);
102 histogram_opt.retrieveOption(argc,argv);
103 nbin_opt.retrieveOption(argc,argv);
104 relative_opt.retrieveOption(argc,argv);
105 histogram2d_opt.retrieveOption(argc,argv);
106 correlation_opt.retrieveOption(argc,argv);
107 rmse_opt.retrieveOption(argc,argv);
108 reg_opt.retrieveOption(argc,argv);
109 regerr_opt.retrieveOption(argc,argv);
110 preg_opt.retrieveOption(argc,argv);
112 ulx_opt.retrieveOption(argc,argv);
113 uly_opt.retrieveOption(argc,argv);
114 lrx_opt.retrieveOption(argc,argv);
115 lry_opt.retrieveOption(argc,argv);
116 down_opt.retrieveOption(argc,argv);
117 random_opt.retrieveOption(argc,argv);
118 scale_opt.retrieveOption(argc,argv);
119 offset_opt.retrieveOption(argc,argv);
120 src_min_opt.retrieveOption(argc,argv);
121 src_max_opt.retrieveOption(argc,argv);
122 kde_opt.retrieveOption(argc,argv);
123 verbose_opt.retrieveOption(argc,argv);
125 catch(
string predefinedString){
126 std::cout << predefinedString << std::endl;
131 cout <<
"Usage: pkstat -i input" << endl;
133 std::cout <<
"short option -h shows basic options only, use long option --help to show all options" << std::endl;
137 if(src_min_opt.size()){
138 while(src_min_opt.size()<band_opt.size())
139 src_min_opt.push_back(src_min_opt[0]);
141 if(src_max_opt.size()){
142 while(src_max_opt.size()<band_opt.size())
143 src_max_opt.push_back(src_max_opt[0]);
156 const char* pszMessage;
157 void* pProgressArg=NULL;
158 GDALProgressFunc pfnProgress=GDALTermProgress;
164 std::vector<double> histogramOutput;
169 if(scale_opt.size()){
170 while(scale_opt.size()<input_opt.size())
171 scale_opt.push_back(scale_opt[0]);
173 if(offset_opt.size()){
174 while(offset_opt.size()<input_opt.size())
175 offset_opt.push_back(offset_opt[0]);
177 if(input_opt.empty()){
178 std::cerr <<
"No image dataset provided (use option -i). Use --help for help information";
181 for(
int ifile=0;ifile<input_opt.size();++ifile){
183 imgReader.open(input_opt[ifile]);
185 catch(std::string errorstring){
186 std::cout << errorstring << std::endl;
191 std::cout <<
" --input " << input_opt[ifile] <<
" ";
193 for(
int inodata=0;inodata<nodata_opt.size();++inodata)
194 imgReader.pushNoDataValue(nodata_opt[inodata]);
196 int nband=band_opt.size();
197 for(
int iband=0;iband<nband;++iband){
199 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
201 imgReader.GDALSetNoDataValue(nodata_opt[0],iband);
204 if(offset_opt.size()>ifile)
205 imgReader.setOffset(offset_opt[ifile],band_opt[iband]);
206 if(scale_opt.size()>ifile)
207 imgReader.setScale(scale_opt[ifile],band_opt[iband]);
227 if(minmax_opt[0]||min_opt[0]||max_opt[0]){
228 assert(band_opt[iband]<imgReader.nrOfBand());
230 if((ulx_opt.size()||uly_opt.size()||lrx_opt.size()||lry_opt.size())&&(imgReader.covers(ulx_opt[0],uly_opt[0],lrx_opt[0],lry_opt[0]))){
231 double uli,ulj,lri,lrj;
232 imgReader.geo2image(ulx_opt[0],uly_opt[0],uli,ulj);
233 imgReader.geo2image(lrx_opt[0],lry_opt[0],lri,lrj);
234 imgReader.getMinMax(static_cast<int>(uli),static_cast<int>(lri),static_cast<int>(ulj),static_cast<int>(lrj),band_opt[iband],minValue,maxValue);
237 imgReader.getMinMax(minValue,maxValue,band_opt[iband],
true);
240 std::cout <<
"-min " << minValue <<
" -max " << maxValue <<
" ";
243 std::cout <<
"-min " << minValue <<
" ";
245 std::cout <<
"-max " << maxValue <<
" ";
249 if(histogram_opt[0]){
250 assert(band_opt[0]<imgReader.nrOfBand());
251 nbin=(nbin_opt.size())? nbin_opt[0]:0;
253 imgReader.getMinMax(minValue,maxValue,band_opt[0]);
254 if(src_min_opt.size())
255 minValue=src_min_opt[0];
256 if(src_max_opt.size())
257 maxValue=src_max_opt[0];
258 if(minValue>=maxValue)
259 imgReader.getMinMax(minValue,maxValue,band_opt[0]);
262 cout <<
"number of valid pixels in image: " << imgReader.getNvalid(band_opt[0]) << endl;
264 nsample+=imgReader.getHistogram(histogramOutput,minValue,maxValue,nbin,band_opt[0],kde_opt[0]);
267 if(ifile==input_opt.size()-1){
268 std::cout.precision(10);
269 for(
int bin=0;bin<nbin;++bin){
271 if(nbin==maxValue-minValue+1)
272 binValue=minValue+bin;
274 binValue=minValue+
static_cast<double>(maxValue-minValue)*(bin+0.5)/nbin;
275 std::cout << binValue <<
" ";
276 if(relative_opt[0]||kde_opt[0])
277 std::cout << 100.0*
static_cast<double>(histogramOutput[bin])/static_cast<double>(nsample) << std::endl;
279 std::cout << static_cast<double>(histogramOutput[bin]) << std::endl;
283 if(histogram2d_opt[0]&&input_opt.size()<2){
284 assert(band_opt.size()>1);
285 imgReader.getMinMax(minX,maxX,band_opt[0]);
286 imgReader.getMinMax(minY,maxY,band_opt[1]);
287 if(src_min_opt.size()){
291 if(src_max_opt.size()){
295 nbin=(nbin_opt.size())? nbin_opt[0]:0;
297 std::cerr <<
"Warning: number of bins not defined, calculating bins from min and max value" << std::endl;
299 imgReader.getMinMax(minX,maxX,band_opt[0]);
301 imgReader.getMinMax(minY,maxY,band_opt[1]);
303 minValue=(minX<minY)? minX:minY;
304 maxValue=(maxX>maxY)? maxX:maxY;
306 std::cout <<
"min and max values: " << minValue <<
", " << maxValue << std::endl;
307 nbin=maxValue-minValue+1;
313 assert(band_opt[0]<imgReader.nrOfBand());
314 assert(band_opt[1]<imgReader.nrOfBand());
315 GDALProgressFunc pfnProgress;
317 GDALRasterBand* rasterBand;
320 rasterBand=imgReader.getRasterBand(band_opt[0]);
321 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev1,pfnProgress,pProgressData);
322 rasterBand=imgReader.getRasterBand(band_opt[1]);
323 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev2,pfnProgress,pProgressData);
325 double estimatedSize=1.0*imgReader.getNvalid(band_opt[0])/down_opt[0]/down_opt[0];
327 estimatedSize*=random_opt[0]/100.0;
328 sigma=1.06*sqrt(stdDev1*stdDev2)*pow(estimatedSize,-0.2);
333 std::cout <<
"calculating 2d kernel density estimate with sigma " << sigma <<
" for bands " << band_opt[0] <<
" and " << band_opt[1] << std::endl;
335 std::cout <<
"calculating 2d histogram for bands " << band_opt[0] <<
" and " << band_opt[1] << std::endl;
336 std::cout <<
"nbin: " << nbin << std::endl;
340 vector< vector<double> > output;
343 imgReader.getMinMax(minX,maxX,band_opt[0]);
345 imgReader.getMinMax(minY,maxY,band_opt[1]);
348 std::ostringstream s;
349 s<<
"Error: could not calculate distribution (minX>=maxX)";
353 std::ostringstream s;
354 s<<
"Error: could not calculate distribution (minY>=maxY)";
358 for(
int i=0;i<nbin;++i){
359 output[i].resize(nbin);
360 for(
int j=0;j<nbin;++j)
365 vector<double> inputX(imgReader.nrOfCol());
366 vector<double> inputY(imgReader.nrOfCol());
367 unsigned long int nvalid=0;
368 for(
int irow=0;irow<imgReader.nrOfRow();++irow){
371 imgReader.readData(inputX,GDT_Float64,irow,band_opt[0]);
372 imgReader.readData(inputY,GDT_Float64,irow,band_opt[1]);
373 for(
int icol=0;icol<imgReader.nrOfCol();++icol){
377 double p=
static_cast<double>(rand())/(RAND_MAX);
382 if(imgReader.isNoData(inputX[icol]))
384 if(imgReader.isNoData(inputY[icol]))
387 if(inputX[icol]>=maxX)
389 else if(inputX[icol]<=minX)
392 binX=
static_cast<int>(
static_cast<double>(inputX[icol]-minX)/(maxX-minX)*nbin);
393 if(inputY[icol]>=maxY)
395 else if(inputY[icol]<=minX)
398 binY=
static_cast<int>(
static_cast<double>(inputY[icol]-minY)/(maxY-minY)*nbin);
400 assert(binX<output.size());
402 assert(binY<output[binX].size());
406 for(
int ibinX=0;ibinX<nbin;++ibinX){
407 double centerX=minX+
static_cast<double>(maxX-minX)*ibinX/nbin;
408 double pdfX=gsl_ran_gaussian_pdf(inputX[icol]-centerX, sigma);
409 for(
int ibinY=0;ibinY<nbin;++ibinY){
411 double centerY=minY+
static_cast<double>(maxY-minY)*ibinY/nbin;
412 double pdfY=gsl_ran_gaussian_pdf(inputY[icol]-centerY, sigma);
413 output[ibinX][binY]+=pdfX*pdfY;
418 ++output[binX][binY];
422 cout <<
"number of valid pixels: " << nvalid << endl;
424 for(
int binX=0;binX<nbin;++binX){
426 for(
int binY=0;binY<nbin;++binY){
428 if(nbin==maxX-minX+1)
431 binValueX=minX+
static_cast<double>(maxX-minX)*(binX+0.5)/nbin;
433 if(nbin==maxY-minY+1)
436 binValueY=minY+
static_cast<double>(maxY-minY)*(binY+0.5)/nbin;
438 double value=
static_cast<double>(output[binX][binY]);
443 cout << binValueX <<
" " << binValueY <<
" " << value << std::endl;
449 if(reg_opt[0]&&input_opt.size()<2){
450 if(band_opt.size()<2)
452 imgreg.setDown(down_opt[0]);
453 imgreg.setThreshold(random_opt[0]);
456 double r2=imgreg.getR2(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
457 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
459 if(regerr_opt[0]&&input_opt.size()<2){
460 if(band_opt.size()<2)
462 imgreg.setDown(down_opt[0]);
463 imgreg.setThreshold(random_opt[0]);
466 double err=imgreg.getRMSE(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
467 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -rmse " << err << std::endl;
469 if(rmse_opt[0]&&input_opt.size()<2){
470 if(band_opt.size()<2)
472 imgreg.setDown(down_opt[0]);
473 imgreg.setThreshold(random_opt[0]);
476 double err=imgreg.getRMSE(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
477 std::cout <<
" -rmse " << err << std::endl;
479 if(preg_opt[0]&&input_opt.size()<2){
480 if(band_opt.size()<2)
482 imgreg.setDown(down_opt[0]);
483 imgreg.setThreshold(random_opt[0]);
486 double r2=imgreg.pgetR2(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
487 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
491 if(reg_opt[0]&&(input_opt.size()>1)){
492 imgreg.setDown(down_opt[0]);
493 imgreg.setThreshold(random_opt[0]);
496 while(band_opt.size()<input_opt.size())
497 band_opt.push_back(band_opt[0]);
498 if(src_min_opt.size()){
499 while(src_min_opt.size()<input_opt.size())
500 src_min_opt.push_back(src_min_opt[0]);
502 if(src_max_opt.size()){
503 while(src_max_opt.size()<input_opt.size())
504 src_max_opt.push_back(src_max_opt[0]);
509 if(offset_opt.size())
510 imgReader1.setOffset(offset_opt[0],band_opt[0]);
512 imgReader1.setScale(scale_opt[0],band_opt[0]);
513 if(offset_opt.size()>1)
514 imgReader2.setOffset(offset_opt[1],band_opt[1]);
515 if(scale_opt.size()>1)
516 imgReader2.setScale(scale_opt[1],band_opt[1]);
518 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
520 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
521 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
523 imgReader1.pushNoDataValue(nodata_opt[inodata]);
524 imgReader2.pushNoDataValue(nodata_opt[inodata]);
527 double r2=imgreg.getR2(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
528 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
532 if(preg_opt[0]&&(input_opt.size()>1)){
533 imgreg.setDown(down_opt[0]);
534 imgreg.setThreshold(random_opt[0]);
537 while(band_opt.size()<input_opt.size())
538 band_opt.push_back(band_opt[0]);
539 if(src_min_opt.size()){
540 while(src_min_opt.size()<input_opt.size())
541 src_min_opt.push_back(src_min_opt[0]);
543 if(src_max_opt.size()){
544 while(src_max_opt.size()<input_opt.size())
545 src_max_opt.push_back(src_max_opt[0]);
550 if(offset_opt.size())
551 imgReader1.setOffset(offset_opt[0],band_opt[0]);
553 imgReader1.setScale(scale_opt[0],band_opt[0]);
554 if(offset_opt.size()>1)
555 imgReader2.setOffset(offset_opt[1],band_opt[1]);
556 if(scale_opt.size()>1)
557 imgReader2.setScale(scale_opt[1],band_opt[1]);
559 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
561 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
562 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
564 imgReader1.pushNoDataValue(nodata_opt[inodata]);
565 imgReader2.pushNoDataValue(nodata_opt[inodata]);
568 double r2=imgreg.pgetR2(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
569 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
573 if(regerr_opt[0]&&(input_opt.size()>1)){
574 imgreg.setDown(down_opt[0]);
575 imgreg.setThreshold(random_opt[0]);
578 while(band_opt.size()<input_opt.size())
579 band_opt.push_back(band_opt[0]);
580 if(src_min_opt.size()){
581 while(src_min_opt.size()<input_opt.size())
582 src_min_opt.push_back(src_min_opt[0]);
584 if(src_max_opt.size()){
585 while(src_max_opt.size()<input_opt.size())
586 src_max_opt.push_back(src_max_opt[0]);
591 if(offset_opt.size())
592 imgReader1.setOffset(offset_opt[0],band_opt[0]);
594 imgReader1.setScale(scale_opt[0],band_opt[0]);
595 if(offset_opt.size()>1)
596 imgReader2.setOffset(offset_opt[1],band_opt[1]);
597 if(scale_opt.size()>1)
598 imgReader2.setScale(scale_opt[1],band_opt[1]);
600 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
602 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
603 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
605 imgReader1.pushNoDataValue(nodata_opt[inodata]);
606 imgReader2.pushNoDataValue(nodata_opt[inodata]);
609 double err=imgreg.getRMSE(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
610 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -rmse " << err << std::endl;
614 if(rmse_opt[0]&&(input_opt.size()>1)){
615 imgreg.setDown(down_opt[0]);
616 imgreg.setThreshold(random_opt[0]);
619 while(band_opt.size()<input_opt.size())
620 band_opt.push_back(band_opt[0]);
621 if(src_min_opt.size()){
622 while(src_min_opt.size()<input_opt.size())
623 src_min_opt.push_back(src_min_opt[0]);
625 if(src_max_opt.size()){
626 while(src_max_opt.size()<input_opt.size())
627 src_max_opt.push_back(src_max_opt[0]);
632 if(offset_opt.size())
633 imgReader1.setOffset(offset_opt[0],band_opt[0]);
635 imgReader1.setScale(scale_opt[0],band_opt[0]);
636 if(offset_opt.size()>1)
637 imgReader2.setOffset(offset_opt[1],band_opt[1]);
638 if(scale_opt.size()>1)
639 imgReader2.setScale(scale_opt[1],band_opt[1]);
641 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
643 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
644 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
646 imgReader1.pushNoDataValue(nodata_opt[inodata]);
647 imgReader2.pushNoDataValue(nodata_opt[inodata]);
650 double err=imgreg.getRMSE(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
651 std::cout <<
"-rmse " << err << std::endl;
655 if(histogram2d_opt[0]&&(input_opt.size()>1)){
656 while(band_opt.size()<input_opt.size())
657 band_opt.push_back(band_opt[0]);
658 if(src_min_opt.size()){
659 while(src_min_opt.size()<input_opt.size())
660 src_min_opt.push_back(src_min_opt[0]);
662 if(src_max_opt.size()){
663 while(src_max_opt.size()<input_opt.size())
664 src_max_opt.push_back(src_max_opt[0]);
669 if(offset_opt.size())
670 imgReader1.setOffset(offset_opt[0],band_opt[0]);
672 imgReader1.setScale(scale_opt[0],band_opt[0]);
673 if(offset_opt.size()>1)
674 imgReader2.setOffset(offset_opt[1],band_opt[1]);
675 if(scale_opt.size()>1)
676 imgReader2.setScale(scale_opt[1],band_opt[1]);
678 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
680 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
681 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
683 imgReader1.pushNoDataValue(nodata_opt[inodata]);
684 imgReader2.pushNoDataValue(nodata_opt[inodata]);
687 imgReader1.getMinMax(minX,maxX,band_opt[0]);
688 imgReader2.getMinMax(minY,maxY,band_opt[1]);
691 cout <<
"minX: " << minX << endl;
692 cout <<
"maxX: " << maxX << endl;
693 cout <<
"minY: " << minY << endl;
694 cout <<
"maxY: " << maxY << endl;
697 if(src_min_opt.size()){
701 if(src_max_opt.size()){
706 nbin=(nbin_opt.size())? nbin_opt[0]:0;
708 std::cerr <<
"Warning: number of bins not defined, calculating bins from min and max value" << std::endl;
712 imgReader1.getMinMax(minX,maxX,band_opt[0]);
714 imgReader2.getMinMax(minY,maxY,band_opt[1]);
716 minValue=(minX<minY)? minX:minY;
717 maxValue=(maxX>maxY)? maxX:maxY;
719 std::cout <<
"min and max values: " << minValue <<
", " << maxValue << std::endl;
720 nbin=maxValue-minValue+1;
726 GDALProgressFunc pfnProgress;
728 GDALRasterBand* rasterBand;
731 rasterBand=imgReader1.getRasterBand(band_opt[0]);
732 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev1,pfnProgress,pProgressData);
733 rasterBand=imgReader2.getRasterBand(band_opt[0]);
734 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev2,pfnProgress,pProgressData);
737 double estimatedSize=1.0*imgReader.getNvalid(band_opt[0])/down_opt[0]/down_opt[0];
739 estimatedSize*=random_opt[0]/100.0;
740 sigma=1.06*sqrt(stdDev1*stdDev2)*pow(estimatedSize,-0.2);
745 std::cout <<
"calculating 2d kernel density estimate with sigma " << sigma <<
" for datasets " << input_opt[0] <<
" and " << input_opt[1] << std::endl;
747 std::cout <<
"calculating 2d histogram for datasets " << input_opt[0] <<
" and " << input_opt[1] << std::endl;
748 std::cout <<
"nbin: " << nbin << std::endl;
751 vector< vector<double> > output;
754 imgReader1.getMinMax(minX,maxX,band_opt[0]);
756 imgReader2.getMinMax(minY,maxY,band_opt[1]);
759 std::ostringstream s;
760 s<<
"Error: could not calculate distribution (minX>=maxX)";
764 std::ostringstream s;
765 s<<
"Error: could not calculate distribution (minY>=maxY)";
769 cout <<
"minX: " << minX << endl;
770 cout <<
"maxX: " << maxX << endl;
771 cout <<
"minY: " << minY << endl;
772 cout <<
"maxY: " << maxY << endl;
775 for(
int i=0;i<nbin;++i){
776 output[i].resize(nbin);
777 for(
int j=0;j<nbin;++j)
782 vector<double> inputX(imgReader1.nrOfCol());
783 vector<double> inputY(imgReader2.nrOfCol());
791 for(
int irow=0;irow<imgReader1.nrOfRow();++irow){
795 imgReader1.image2geo(icol1,irow1,geoX,geoY);
796 imgReader2.geo2image(geoX,geoY,icol2,irow2);
797 irow2=
static_cast<int>(irow2);
798 imgReader1.readData(inputX,GDT_Float64,irow1,band_opt[0]);
799 imgReader2.readData(inputY,GDT_Float64,irow2,band_opt[1]);
800 for(
int icol=0;icol<imgReader.nrOfCol();++icol){
805 double p=
static_cast<double>(rand())/(RAND_MAX);
810 if(imgReader1.isNoData(inputX[icol]))
812 imgReader1.image2geo(icol1,irow1,geoX,geoY);
813 imgReader2.geo2image(geoX,geoY,icol2,irow2);
814 icol2=
static_cast<int>(icol2);
815 if(imgReader2.isNoData(inputY[icol2]))
818 if(inputX[icol1]>=maxX)
820 else if(inputX[icol]<=minX)
823 binX=
static_cast<int>(
static_cast<double>(inputX[icol1]-minX)/(maxX-minX)*nbin);
824 if(inputY[icol2]>=maxY)
826 else if(inputY[icol2]<=minY)
829 binY=
static_cast<int>(
static_cast<double>(inputY[icol2]-minY)/(maxY-minY)*nbin);
831 assert(binX<output.size());
833 assert(binY<output[binX].size());
837 for(
int ibinX=0;ibinX<nbin;++ibinX){
838 double centerX=minX+
static_cast<double>(maxX-minX)*ibinX/nbin;
839 double pdfX=gsl_ran_gaussian_pdf(inputX[icol1]-centerX, sigma);
840 for(
int ibinY=0;ibinY<nbin;++ibinY){
842 double centerY=minY+
static_cast<double>(maxY-minY)*ibinY/nbin;
843 double pdfY=gsl_ran_gaussian_pdf(inputY[icol2]-centerY, sigma);
844 output[ibinX][binY]+=pdfX*pdfY;
850 ++output[binX][binY];
856 cout <<
"number of valid pixels: " << nvalid << endl;
857 for(
int binX=0;binX<nbin;++binX){
859 for(
int binY=0;binY<nbin;++binY){
861 if(nbin==maxX-minX+1)
864 binValueX=minX+
static_cast<double>(maxX-minX)*(binX+0.5)/nbin;
866 if(nbin==maxY-minY+1)
869 binValueY=minY+
static_cast<double>(maxY-minY)*(binY+0.5)/nbin;
870 double value=
static_cast<double>(output[binX][binY]);
872 if(relative_opt[0]||kde_opt[0])
875 cout << binValueX <<
" " << binValueY <<
" " << value << std::endl;
884 if(!histogram_opt[0]||histogram2d_opt[0])
885 std::cout << std::endl;