23 #include "base/Optionpk.h"
24 #include "algorithms/StatFactory.h"
25 #include "algorithms/ImgRegression.h"
80 int main(
int argc,
char *argv[])
84 Optionpk<bool> filename_opt(
"f",
"filename",
"Shows image filename ",
false);
85 Optionpk<bool> stat_opt(
"stats",
"statistics",
"Shows basic statistics (min,max, mean and stdDev of the raster datasets)",
false);
91 Optionpk<short> down_opt(
"down",
"down",
"Down sampling factor (for raster sample datasets only). Can be used to create grid points", 1);
93 Optionpk<double> scale_opt(
"scale",
"scale",
"Scale(s) for reading input image(s)");
94 Optionpk<double> offset_opt(
"offset",
"offset",
"Offset(s) for reading input image(s)");
101 Optionpk<bool> median_opt(
"median",
"median",
"calculate median",
false);
103 Optionpk<bool> skewness_opt(
"skew",
"skewness",
"calculate skewness",
false);
104 Optionpk<bool> kurtosis_opt(
"kurt",
"kurtosis",
"calculate kurtosis",
false);
105 Optionpk<bool> stdev_opt(
"stdev",
"stdev",
"calculate standard deviation",
false);
106 Optionpk<bool> sum_opt(
"sum",
"sum",
"calculate sum of column",
false);
107 Optionpk<bool> minmax_opt(
"mm",
"minmax",
"calculate minimum and maximum value",
false);
108 Optionpk<bool> min_opt(
"min",
"min",
"calculate minimum value",
false);
109 Optionpk<bool> max_opt(
"max",
"max",
"calculate maximum value",
false);
110 Optionpk<double> src_min_opt(
"src_min",
"src_min",
"start reading source from this minimum value");
111 Optionpk<double> src_max_opt(
"src_max",
"src_max",
"stop reading source from this maximum value");
112 Optionpk<bool> histogram_opt(
"hist",
"hist",
"calculate histogram",
false);
113 Optionpk<bool> histogram2d_opt(
"hist2d",
"hist2d",
"calculate 2-dimensional histogram based on two images",
false);
114 Optionpk<short> nbin_opt(
"nbin",
"nbin",
"number of bins to calculate histogram");
115 Optionpk<bool> relative_opt(
"rel",
"relative",
"use percentiles for histogram to calculate histogram",
false);
116 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);
117 Optionpk<bool> correlation_opt(
"cor",
"correlation",
"calculate Pearson produc-moment correlation coefficient between two raster datasets (defined by -c <col1> -c <col2>)",
false);
118 Optionpk<bool> rmse_opt(
"rmse",
"rmse",
"calculate root mean square error between two raster datasets",
false);
119 Optionpk<bool> reg_opt(
"reg",
"regression",
"calculate linear regression between two raster datasets and get correlation coefficient",
false);
120 Optionpk<bool> regerr_opt(
"regerr",
"regerr",
"calculate linear regression between two raster datasets and get root mean square error",
false);
121 Optionpk<bool> preg_opt(
"preg",
"preg",
"calculate perpendicular regression between two raster datasets and get correlation coefficient",
false);
122 Optionpk<short> verbose_opt(
"v",
"verbose",
"verbose mode when positive", 0,2);
128 random_opt.setHide(1);
129 scale_opt.setHide(1);
130 offset_opt.setHide(1);
131 src_min_opt.setHide(1);
132 src_max_opt.setHide(1);
141 doProcess=input_opt.retrieveOption(argc,argv);
143 band_opt.retrieveOption(argc,argv);
144 filename_opt.retrieveOption(argc,argv);
145 stat_opt.retrieveOption(argc,argv);
146 nodata_opt.retrieveOption(argc,argv);
147 mean_opt.retrieveOption(argc,argv);
148 median_opt.retrieveOption(argc,argv);
149 var_opt.retrieveOption(argc,argv);
150 stdev_opt.retrieveOption(argc,argv);
151 minmax_opt.retrieveOption(argc,argv);
152 min_opt.retrieveOption(argc,argv);
153 max_opt.retrieveOption(argc,argv);
154 histogram_opt.retrieveOption(argc,argv);
155 nbin_opt.retrieveOption(argc,argv);
156 relative_opt.retrieveOption(argc,argv);
157 histogram2d_opt.retrieveOption(argc,argv);
158 correlation_opt.retrieveOption(argc,argv);
159 rmse_opt.retrieveOption(argc,argv);
160 reg_opt.retrieveOption(argc,argv);
161 regerr_opt.retrieveOption(argc,argv);
162 preg_opt.retrieveOption(argc,argv);
164 ulx_opt.retrieveOption(argc,argv);
165 uly_opt.retrieveOption(argc,argv);
166 lrx_opt.retrieveOption(argc,argv);
167 lry_opt.retrieveOption(argc,argv);
168 down_opt.retrieveOption(argc,argv);
169 random_opt.retrieveOption(argc,argv);
170 scale_opt.retrieveOption(argc,argv);
171 offset_opt.retrieveOption(argc,argv);
172 src_min_opt.retrieveOption(argc,argv);
173 src_max_opt.retrieveOption(argc,argv);
174 kde_opt.retrieveOption(argc,argv);
175 verbose_opt.retrieveOption(argc,argv);
177 catch(
string predefinedString){
178 std::cout << predefinedString << std::endl;
183 cout <<
"Usage: pkstat -i input" << endl;
185 std::cout <<
"short option -h shows basic options only, use long option --help to show all options" << std::endl;
189 if(src_min_opt.size()){
190 while(src_min_opt.size()<band_opt.size())
191 src_min_opt.push_back(src_min_opt[0]);
193 if(src_max_opt.size()){
194 while(src_max_opt.size()<band_opt.size())
195 src_max_opt.push_back(src_max_opt[0]);
208 const char* pszMessage;
209 void* pProgressArg=NULL;
210 GDALProgressFunc pfnProgress=GDALTermProgress;
216 std::vector<double> histogramOutput;
221 if(scale_opt.size()){
222 while(scale_opt.size()<input_opt.size())
223 scale_opt.push_back(scale_opt[0]);
225 if(offset_opt.size()){
226 while(offset_opt.size()<input_opt.size())
227 offset_opt.push_back(offset_opt[0]);
229 if(input_opt.empty()){
230 std::cerr <<
"No image dataset provided (use option -i). Use --help for help information";
233 for(
int ifile=0;ifile<input_opt.size();++ifile){
235 imgReader.open(input_opt[ifile]);
237 catch(std::string errorstring){
238 std::cout << errorstring << std::endl;
243 std::cout <<
" --input " << input_opt[ifile] <<
" ";
245 for(
int inodata=0;inodata<nodata_opt.size();++inodata)
246 imgReader.pushNoDataValue(nodata_opt[inodata]);
248 int nband=band_opt.size();
249 for(
int iband=0;iband<nband;++iband){
251 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
253 imgReader.GDALSetNoDataValue(nodata_opt[0],iband);
256 if(offset_opt.size()>ifile)
257 imgReader.setOffset(offset_opt[ifile],band_opt[iband]);
258 if(scale_opt.size()>ifile)
259 imgReader.setScale(scale_opt[ifile],band_opt[iband]);
279 if(minmax_opt[0]||min_opt[0]||max_opt[0]){
280 assert(band_opt[iband]<imgReader.nrOfBand());
282 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]))){
283 double uli,ulj,lri,lrj;
284 imgReader.geo2image(ulx_opt[0],uly_opt[0],uli,ulj);
285 imgReader.geo2image(lrx_opt[0],lry_opt[0],lri,lrj);
286 imgReader.getMinMax(static_cast<int>(uli),static_cast<int>(lri),static_cast<int>(ulj),static_cast<int>(lrj),band_opt[iband],minValue,maxValue);
289 imgReader.getMinMax(minValue,maxValue,band_opt[iband],
true);
292 std::cout <<
"-min " << minValue <<
" -max " << maxValue <<
" ";
295 std::cout <<
"-min " << minValue <<
" ";
297 std::cout <<
"-max " << maxValue <<
" ";
301 if(histogram_opt[0]){
302 assert(band_opt[0]<imgReader.nrOfBand());
303 nbin=(nbin_opt.size())? nbin_opt[0]:0;
305 imgReader.getMinMax(minValue,maxValue,band_opt[0]);
306 if(src_min_opt.size())
307 minValue=src_min_opt[0];
308 if(src_max_opt.size())
309 maxValue=src_max_opt[0];
310 if(minValue>=maxValue)
311 imgReader.getMinMax(minValue,maxValue,band_opt[0]);
314 cout <<
"number of valid pixels in image: " << imgReader.getNvalid(band_opt[0]) << endl;
316 nsample+=imgReader.getHistogram(histogramOutput,minValue,maxValue,nbin,band_opt[0],kde_opt[0]);
319 if(ifile==input_opt.size()-1){
320 std::cout.precision(10);
321 for(
int bin=0;bin<nbin;++bin){
323 if(nbin==maxValue-minValue+1)
324 binValue=minValue+bin;
326 binValue=minValue+
static_cast<double>(maxValue-minValue)*(bin+0.5)/nbin;
327 std::cout << binValue <<
" ";
328 if(relative_opt[0]||kde_opt[0])
329 std::cout << 100.0*
static_cast<double>(histogramOutput[bin])/static_cast<double>(nsample) << std::endl;
331 std::cout << static_cast<double>(histogramOutput[bin]) << std::endl;
335 if(histogram2d_opt[0]&&input_opt.size()<2){
336 assert(band_opt.size()>1);
337 imgReader.getMinMax(minX,maxX,band_opt[0]);
338 imgReader.getMinMax(minY,maxY,band_opt[1]);
339 if(src_min_opt.size()){
343 if(src_max_opt.size()){
347 nbin=(nbin_opt.size())? nbin_opt[0]:0;
349 std::cerr <<
"Warning: number of bins not defined, calculating bins from min and max value" << std::endl;
351 imgReader.getMinMax(minX,maxX,band_opt[0]);
353 imgReader.getMinMax(minY,maxY,band_opt[1]);
355 minValue=(minX<minY)? minX:minY;
356 maxValue=(maxX>maxY)? maxX:maxY;
358 std::cout <<
"min and max values: " << minValue <<
", " << maxValue << std::endl;
359 nbin=maxValue-minValue+1;
365 assert(band_opt[0]<imgReader.nrOfBand());
366 assert(band_opt[1]<imgReader.nrOfBand());
367 GDALProgressFunc pfnProgress;
369 GDALRasterBand* rasterBand;
372 rasterBand=imgReader.getRasterBand(band_opt[0]);
373 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev1,pfnProgress,pProgressData);
374 rasterBand=imgReader.getRasterBand(band_opt[1]);
375 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev2,pfnProgress,pProgressData);
377 double estimatedSize=1.0*imgReader.getNvalid(band_opt[0])/down_opt[0]/down_opt[0];
379 estimatedSize*=random_opt[0]/100.0;
380 sigma=1.06*sqrt(stdDev1*stdDev2)*pow(estimatedSize,-0.2);
385 std::cout <<
"calculating 2d kernel density estimate with sigma " << sigma <<
" for bands " << band_opt[0] <<
" and " << band_opt[1] << std::endl;
387 std::cout <<
"calculating 2d histogram for bands " << band_opt[0] <<
" and " << band_opt[1] << std::endl;
388 std::cout <<
"nbin: " << nbin << std::endl;
392 vector< vector<double> > output;
395 imgReader.getMinMax(minX,maxX,band_opt[0]);
397 imgReader.getMinMax(minY,maxY,band_opt[1]);
400 std::ostringstream s;
401 s<<
"Error: could not calculate distribution (minX>=maxX)";
405 std::ostringstream s;
406 s<<
"Error: could not calculate distribution (minY>=maxY)";
410 for(
int i=0;i<nbin;++i){
411 output[i].resize(nbin);
412 for(
int j=0;j<nbin;++j)
417 vector<double> inputX(imgReader.nrOfCol());
418 vector<double> inputY(imgReader.nrOfCol());
419 unsigned long int nvalid=0;
420 for(
int irow=0;irow<imgReader.nrOfRow();++irow){
423 imgReader.readData(inputX,GDT_Float64,irow,band_opt[0]);
424 imgReader.readData(inputY,GDT_Float64,irow,band_opt[1]);
425 for(
int icol=0;icol<imgReader.nrOfCol();++icol){
429 double p=
static_cast<double>(rand())/(RAND_MAX);
434 if(imgReader.isNoData(inputX[icol]))
436 if(imgReader.isNoData(inputY[icol]))
439 if(inputX[icol]>=maxX)
441 else if(inputX[icol]<=minX)
444 binX=
static_cast<int>(
static_cast<double>(inputX[icol]-minX)/(maxX-minX)*nbin);
445 if(inputY[icol]>=maxY)
447 else if(inputY[icol]<=minX)
450 binY=
static_cast<int>(
static_cast<double>(inputY[icol]-minY)/(maxY-minY)*nbin);
452 assert(binX<output.size());
454 assert(binY<output[binX].size());
458 for(
int ibinX=0;ibinX<nbin;++ibinX){
459 double centerX=minX+
static_cast<double>(maxX-minX)*ibinX/nbin;
460 double pdfX=gsl_ran_gaussian_pdf(inputX[icol]-centerX, sigma);
461 for(
int ibinY=0;ibinY<nbin;++ibinY){
463 double centerY=minY+
static_cast<double>(maxY-minY)*ibinY/nbin;
464 double pdfY=gsl_ran_gaussian_pdf(inputY[icol]-centerY, sigma);
465 output[ibinX][binY]+=pdfX*pdfY;
470 ++output[binX][binY];
474 cout <<
"number of valid pixels: " << nvalid << endl;
476 for(
int binX=0;binX<nbin;++binX){
478 for(
int binY=0;binY<nbin;++binY){
480 if(nbin==maxX-minX+1)
483 binValueX=minX+
static_cast<double>(maxX-minX)*(binX+0.5)/nbin;
485 if(nbin==maxY-minY+1)
488 binValueY=minY+
static_cast<double>(maxY-minY)*(binY+0.5)/nbin;
490 double value=
static_cast<double>(output[binX][binY]);
495 cout << binValueX <<
" " << binValueY <<
" " << value << std::endl;
501 if(reg_opt[0]&&input_opt.size()<2){
502 if(band_opt.size()<2)
504 imgreg.setDown(down_opt[0]);
505 imgreg.setThreshold(random_opt[0]);
508 double r2=imgreg.getR2(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
509 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
511 if(regerr_opt[0]&&input_opt.size()<2){
512 if(band_opt.size()<2)
514 imgreg.setDown(down_opt[0]);
515 imgreg.setThreshold(random_opt[0]);
518 double err=imgreg.getRMSE(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
519 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -rmse " << err << std::endl;
521 if(rmse_opt[0]&&input_opt.size()<2){
522 if(band_opt.size()<2)
524 imgreg.setDown(down_opt[0]);
525 imgreg.setThreshold(random_opt[0]);
528 double err=imgreg.getRMSE(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
529 std::cout <<
" -rmse " << err << std::endl;
531 if(preg_opt[0]&&input_opt.size()<2){
532 if(band_opt.size()<2)
534 imgreg.setDown(down_opt[0]);
535 imgreg.setThreshold(random_opt[0]);
538 double r2=imgreg.pgetR2(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
539 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
543 if(reg_opt[0]&&(input_opt.size()>1)){
544 imgreg.setDown(down_opt[0]);
545 imgreg.setThreshold(random_opt[0]);
548 while(band_opt.size()<input_opt.size())
549 band_opt.push_back(band_opt[0]);
550 if(src_min_opt.size()){
551 while(src_min_opt.size()<input_opt.size())
552 src_min_opt.push_back(src_min_opt[0]);
554 if(src_max_opt.size()){
555 while(src_max_opt.size()<input_opt.size())
556 src_max_opt.push_back(src_max_opt[0]);
561 if(offset_opt.size())
562 imgReader1.setOffset(offset_opt[0],band_opt[0]);
564 imgReader1.setScale(scale_opt[0],band_opt[0]);
565 if(offset_opt.size()>1)
566 imgReader2.setOffset(offset_opt[1],band_opt[1]);
567 if(scale_opt.size()>1)
568 imgReader2.setScale(scale_opt[1],band_opt[1]);
570 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
572 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
573 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
575 imgReader1.pushNoDataValue(nodata_opt[inodata]);
576 imgReader2.pushNoDataValue(nodata_opt[inodata]);
579 double r2=imgreg.getR2(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
580 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
584 if(preg_opt[0]&&(input_opt.size()>1)){
585 imgreg.setDown(down_opt[0]);
586 imgreg.setThreshold(random_opt[0]);
589 while(band_opt.size()<input_opt.size())
590 band_opt.push_back(band_opt[0]);
591 if(src_min_opt.size()){
592 while(src_min_opt.size()<input_opt.size())
593 src_min_opt.push_back(src_min_opt[0]);
595 if(src_max_opt.size()){
596 while(src_max_opt.size()<input_opt.size())
597 src_max_opt.push_back(src_max_opt[0]);
602 if(offset_opt.size())
603 imgReader1.setOffset(offset_opt[0],band_opt[0]);
605 imgReader1.setScale(scale_opt[0],band_opt[0]);
606 if(offset_opt.size()>1)
607 imgReader2.setOffset(offset_opt[1],band_opt[1]);
608 if(scale_opt.size()>1)
609 imgReader2.setScale(scale_opt[1],band_opt[1]);
611 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
613 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
614 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
616 imgReader1.pushNoDataValue(nodata_opt[inodata]);
617 imgReader2.pushNoDataValue(nodata_opt[inodata]);
620 double r2=imgreg.pgetR2(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
621 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
625 if(regerr_opt[0]&&(input_opt.size()>1)){
626 imgreg.setDown(down_opt[0]);
627 imgreg.setThreshold(random_opt[0]);
630 while(band_opt.size()<input_opt.size())
631 band_opt.push_back(band_opt[0]);
632 if(src_min_opt.size()){
633 while(src_min_opt.size()<input_opt.size())
634 src_min_opt.push_back(src_min_opt[0]);
636 if(src_max_opt.size()){
637 while(src_max_opt.size()<input_opt.size())
638 src_max_opt.push_back(src_max_opt[0]);
643 if(offset_opt.size())
644 imgReader1.setOffset(offset_opt[0],band_opt[0]);
646 imgReader1.setScale(scale_opt[0],band_opt[0]);
647 if(offset_opt.size()>1)
648 imgReader2.setOffset(offset_opt[1],band_opt[1]);
649 if(scale_opt.size()>1)
650 imgReader2.setScale(scale_opt[1],band_opt[1]);
652 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
654 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
655 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
657 imgReader1.pushNoDataValue(nodata_opt[inodata]);
658 imgReader2.pushNoDataValue(nodata_opt[inodata]);
661 double err=imgreg.getRMSE(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
662 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -rmse " << err << std::endl;
666 if(rmse_opt[0]&&(input_opt.size()>1)){
667 imgreg.setDown(down_opt[0]);
668 imgreg.setThreshold(random_opt[0]);
671 while(band_opt.size()<input_opt.size())
672 band_opt.push_back(band_opt[0]);
673 if(src_min_opt.size()){
674 while(src_min_opt.size()<input_opt.size())
675 src_min_opt.push_back(src_min_opt[0]);
677 if(src_max_opt.size()){
678 while(src_max_opt.size()<input_opt.size())
679 src_max_opt.push_back(src_max_opt[0]);
684 if(offset_opt.size())
685 imgReader1.setOffset(offset_opt[0],band_opt[0]);
687 imgReader1.setScale(scale_opt[0],band_opt[0]);
688 if(offset_opt.size()>1)
689 imgReader2.setOffset(offset_opt[1],band_opt[1]);
690 if(scale_opt.size()>1)
691 imgReader2.setScale(scale_opt[1],band_opt[1]);
693 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
695 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
696 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
698 imgReader1.pushNoDataValue(nodata_opt[inodata]);
699 imgReader2.pushNoDataValue(nodata_opt[inodata]);
702 double err=imgreg.getRMSE(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
703 std::cout <<
"-rmse " << err << std::endl;
707 if(histogram2d_opt[0]&&(input_opt.size()>1)){
708 while(band_opt.size()<input_opt.size())
709 band_opt.push_back(band_opt[0]);
710 if(src_min_opt.size()){
711 while(src_min_opt.size()<input_opt.size())
712 src_min_opt.push_back(src_min_opt[0]);
714 if(src_max_opt.size()){
715 while(src_max_opt.size()<input_opt.size())
716 src_max_opt.push_back(src_max_opt[0]);
721 if(offset_opt.size())
722 imgReader1.setOffset(offset_opt[0],band_opt[0]);
724 imgReader1.setScale(scale_opt[0],band_opt[0]);
725 if(offset_opt.size()>1)
726 imgReader2.setOffset(offset_opt[1],band_opt[1]);
727 if(scale_opt.size()>1)
728 imgReader2.setScale(scale_opt[1],band_opt[1]);
730 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
732 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
733 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
735 imgReader1.pushNoDataValue(nodata_opt[inodata]);
736 imgReader2.pushNoDataValue(nodata_opt[inodata]);
739 imgReader1.getMinMax(minX,maxX,band_opt[0]);
740 imgReader2.getMinMax(minY,maxY,band_opt[1]);
743 cout <<
"minX: " << minX << endl;
744 cout <<
"maxX: " << maxX << endl;
745 cout <<
"minY: " << minY << endl;
746 cout <<
"maxY: " << maxY << endl;
749 if(src_min_opt.size()){
753 if(src_max_opt.size()){
758 nbin=(nbin_opt.size())? nbin_opt[0]:0;
760 std::cerr <<
"Warning: number of bins not defined, calculating bins from min and max value" << std::endl;
764 imgReader1.getMinMax(minX,maxX,band_opt[0]);
766 imgReader2.getMinMax(minY,maxY,band_opt[1]);
768 minValue=(minX<minY)? minX:minY;
769 maxValue=(maxX>maxY)? maxX:maxY;
771 std::cout <<
"min and max values: " << minValue <<
", " << maxValue << std::endl;
772 nbin=maxValue-minValue+1;
778 GDALProgressFunc pfnProgress;
780 GDALRasterBand* rasterBand;
783 rasterBand=imgReader1.getRasterBand(band_opt[0]);
784 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev1,pfnProgress,pProgressData);
785 rasterBand=imgReader2.getRasterBand(band_opt[0]);
786 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev2,pfnProgress,pProgressData);
789 double estimatedSize=1.0*imgReader.getNvalid(band_opt[0])/down_opt[0]/down_opt[0];
791 estimatedSize*=random_opt[0]/100.0;
792 sigma=1.06*sqrt(stdDev1*stdDev2)*pow(estimatedSize,-0.2);
797 std::cout <<
"calculating 2d kernel density estimate with sigma " << sigma <<
" for datasets " << input_opt[0] <<
" and " << input_opt[1] << std::endl;
799 std::cout <<
"calculating 2d histogram for datasets " << input_opt[0] <<
" and " << input_opt[1] << std::endl;
800 std::cout <<
"nbin: " << nbin << std::endl;
803 vector< vector<double> > output;
806 imgReader1.getMinMax(minX,maxX,band_opt[0]);
808 imgReader2.getMinMax(minY,maxY,band_opt[1]);
811 std::ostringstream s;
812 s<<
"Error: could not calculate distribution (minX>=maxX)";
816 std::ostringstream s;
817 s<<
"Error: could not calculate distribution (minY>=maxY)";
821 cout <<
"minX: " << minX << endl;
822 cout <<
"maxX: " << maxX << endl;
823 cout <<
"minY: " << minY << endl;
824 cout <<
"maxY: " << maxY << endl;
827 for(
int i=0;i<nbin;++i){
828 output[i].resize(nbin);
829 for(
int j=0;j<nbin;++j)
834 vector<double> inputX(imgReader1.nrOfCol());
835 vector<double> inputY(imgReader2.nrOfCol());
843 for(
int irow=0;irow<imgReader1.nrOfRow();++irow){
847 imgReader1.image2geo(icol1,irow1,geoX,geoY);
848 imgReader2.geo2image(geoX,geoY,icol2,irow2);
849 irow2=
static_cast<int>(irow2);
850 imgReader1.readData(inputX,GDT_Float64,irow1,band_opt[0]);
851 imgReader2.readData(inputY,GDT_Float64,irow2,band_opt[1]);
852 for(
int icol=0;icol<imgReader.nrOfCol();++icol){
857 double p=
static_cast<double>(rand())/(RAND_MAX);
862 if(imgReader1.isNoData(inputX[icol]))
864 imgReader1.image2geo(icol1,irow1,geoX,geoY);
865 imgReader2.geo2image(geoX,geoY,icol2,irow2);
866 icol2=
static_cast<int>(icol2);
867 if(imgReader2.isNoData(inputY[icol2]))
870 if(inputX[icol1]>=maxX)
872 else if(inputX[icol]<=minX)
875 binX=
static_cast<int>(
static_cast<double>(inputX[icol1]-minX)/(maxX-minX)*nbin);
876 if(inputY[icol2]>=maxY)
878 else if(inputY[icol2]<=minY)
881 binY=
static_cast<int>(
static_cast<double>(inputY[icol2]-minY)/(maxY-minY)*nbin);
883 assert(binX<output.size());
885 assert(binY<output[binX].size());
889 for(
int ibinX=0;ibinX<nbin;++ibinX){
890 double centerX=minX+
static_cast<double>(maxX-minX)*ibinX/nbin;
891 double pdfX=gsl_ran_gaussian_pdf(inputX[icol1]-centerX, sigma);
892 for(
int ibinY=0;ibinY<nbin;++ibinY){
894 double centerY=minY+
static_cast<double>(maxY-minY)*ibinY/nbin;
895 double pdfY=gsl_ran_gaussian_pdf(inputY[icol2]-centerY, sigma);
896 output[ibinX][binY]+=pdfX*pdfY;
902 ++output[binX][binY];
908 cout <<
"number of valid pixels: " << nvalid << endl;
909 for(
int binX=0;binX<nbin;++binX){
911 for(
int binY=0;binY<nbin;++binY){
913 if(nbin==maxX-minX+1)
916 binValueX=minX+
static_cast<double>(maxX-minX)*(binX+0.5)/nbin;
918 if(nbin==maxY-minY+1)
921 binValueY=minY+
static_cast<double>(maxY-minY)*(binY+0.5)/nbin;
922 double value=
static_cast<double>(output[binX][binY]);
924 if(relative_opt[0]||kde_opt[0])
927 cout << binValueX <<
" " << binValueY <<
" " << value << std::endl;
936 if(!histogram_opt[0]||histogram2d_opt[0])
937 std::cout << std::endl;