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 (calculate in memory) (min,max, mean and stdDev of the raster datasets)",
false);
86 Optionpk<bool> fstat_opt(
"fstats",
"fstatistics",
"Shows basic statistics using GDAL computeStatistics (min,max, mean and stdDev of the raster datasets)",
false);
92 Optionpk<short> down_opt(
"down",
"down",
"Down sampling factor (for raster sample datasets only). Can be used to create grid points", 1);
94 Optionpk<double> scale_opt(
"scale",
"scale",
"Scale(s) for reading input image(s)");
95 Optionpk<double> offset_opt(
"offset",
"offset",
"Offset(s) for reading input image(s)");
102 Optionpk<bool> median_opt(
"median",
"median",
"calculate median",
false);
104 Optionpk<bool> skewness_opt(
"skew",
"skewness",
"calculate skewness",
false);
105 Optionpk<bool> kurtosis_opt(
"kurt",
"kurtosis",
"calculate kurtosis",
false);
106 Optionpk<bool> stdev_opt(
"stdev",
"stdev",
"calculate standard deviation",
false);
107 Optionpk<bool> sum_opt(
"sum",
"sum",
"calculate sum of column",
false);
108 Optionpk<bool> minmax_opt(
"mm",
"minmax",
"calculate minimum and maximum value",
false);
109 Optionpk<bool> min_opt(
"min",
"min",
"calculate minimum value",
false);
110 Optionpk<bool> max_opt(
"max",
"max",
"calculate maximum value",
false);
111 Optionpk<double> src_min_opt(
"src_min",
"src_min",
"start reading source from this minimum value");
112 Optionpk<double> src_max_opt(
"src_max",
"src_max",
"stop reading source from this maximum value");
113 Optionpk<bool> histogram_opt(
"hist",
"hist",
"calculate histogram",
false);
114 Optionpk<bool> histogram2d_opt(
"hist2d",
"hist2d",
"calculate 2-dimensional histogram based on two images",
false);
115 Optionpk<short> nbin_opt(
"nbin",
"nbin",
"number of bins to calculate histogram");
116 Optionpk<bool> relative_opt(
"rel",
"relative",
"use percentiles for histogram to calculate histogram",
false);
117 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);
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);
123 fstat_opt.setHide(1);
129 random_opt.setHide(1);
130 scale_opt.setHide(1);
131 offset_opt.setHide(1);
132 src_min_opt.setHide(1);
133 src_max_opt.setHide(1);
142 doProcess=input_opt.retrieveOption(argc,argv);
144 band_opt.retrieveOption(argc,argv);
145 filename_opt.retrieveOption(argc,argv);
146 stat_opt.retrieveOption(argc,argv);
147 fstat_opt.retrieveOption(argc,argv);
148 nodata_opt.retrieveOption(argc,argv);
149 mean_opt.retrieveOption(argc,argv);
150 median_opt.retrieveOption(argc,argv);
151 var_opt.retrieveOption(argc,argv);
152 stdev_opt.retrieveOption(argc,argv);
153 minmax_opt.retrieveOption(argc,argv);
154 min_opt.retrieveOption(argc,argv);
155 max_opt.retrieveOption(argc,argv);
156 histogram_opt.retrieveOption(argc,argv);
157 nbin_opt.retrieveOption(argc,argv);
158 relative_opt.retrieveOption(argc,argv);
159 histogram2d_opt.retrieveOption(argc,argv);
160 rmse_opt.retrieveOption(argc,argv);
161 reg_opt.retrieveOption(argc,argv);
162 regerr_opt.retrieveOption(argc,argv);
163 preg_opt.retrieveOption(argc,argv);
165 ulx_opt.retrieveOption(argc,argv);
166 uly_opt.retrieveOption(argc,argv);
167 lrx_opt.retrieveOption(argc,argv);
168 lry_opt.retrieveOption(argc,argv);
169 down_opt.retrieveOption(argc,argv);
170 random_opt.retrieveOption(argc,argv);
171 scale_opt.retrieveOption(argc,argv);
172 offset_opt.retrieveOption(argc,argv);
173 src_min_opt.retrieveOption(argc,argv);
174 src_max_opt.retrieveOption(argc,argv);
175 kde_opt.retrieveOption(argc,argv);
176 verbose_opt.retrieveOption(argc,argv);
178 catch(
string predefinedString){
179 std::cout << predefinedString << std::endl;
184 cout <<
"Usage: pkstat -i input" << endl;
186 std::cout <<
"short option -h shows basic options only, use long option --help to show all options" << std::endl;
190 if(src_min_opt.size()){
191 while(src_min_opt.size()<band_opt.size())
192 src_min_opt.push_back(src_min_opt[0]);
194 if(src_max_opt.size()){
195 while(src_max_opt.size()<band_opt.size())
196 src_max_opt.push_back(src_max_opt[0]);
209 const char* pszMessage;
210 void* pProgressArg=NULL;
211 GDALProgressFunc pfnProgress=GDALTermProgress;
217 std::vector<double> histogramOutput;
222 if(scale_opt.size()){
223 while(scale_opt.size()<input_opt.size())
224 scale_opt.push_back(scale_opt[0]);
226 if(offset_opt.size()){
227 while(offset_opt.size()<input_opt.size())
228 offset_opt.push_back(offset_opt[0]);
230 if(input_opt.empty()){
231 std::cerr <<
"No image dataset provided (use option -i). Use --help for help information";
234 for(
int ifile=0;ifile<input_opt.size();++ifile){
236 imgReader.open(input_opt[ifile]);
238 catch(std::string errorstring){
239 std::cout << errorstring << std::endl;
244 std::cout <<
" --input " << input_opt[ifile] <<
" ";
246 for(
int inodata=0;inodata<nodata_opt.size();++inodata)
247 imgReader.pushNoDataValue(nodata_opt[inodata]);
249 int nband=band_opt.size();
250 for(
int iband=0;iband<nband;++iband){
252 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
254 imgReader.GDALSetNoDataValue(nodata_opt[0],band_opt[iband]);
257 if(offset_opt.size()>ifile)
258 imgReader.setOffset(offset_opt[ifile],band_opt[iband]);
259 if(scale_opt.size()>ifile)
260 imgReader.setScale(scale_opt[ifile],band_opt[iband]);
262 if(stat_opt[0]||mean_opt[0]||var_opt[0]||stdev_opt[0]){
264 vector<double> readBuffer;
266 imgReader.readDataBlock(readBuffer, GDT_Float64, 0, imgReader.nrOfCol()-1, 0, imgReader.nrOfRow()-1, band_opt[0]);
267 stat.setNoDataValues(nodata_opt);
268 stat.meanVar(readBuffer,meanValue,varValue);
269 stat.minmax(readBuffer,readBuffer.begin(),readBuffer.end(),minValue,maxValue);
271 std::cout <<
"--mean " << meanValue <<
" ";
273 std::cout <<
"--stdDev " << sqrt(varValue) <<
" ";
275 std::cout <<
"--var " << varValue <<
" ";
277 std::cout <<
"-min " << minValue <<
" -max " << maxValue <<
" --mean " << meanValue <<
" --stdDev " << sqrt(varValue) <<
" ";
281 assert(band_opt[iband]<imgReader.nrOfBand());
282 GDALProgressFunc pfnProgress;
284 GDALRasterBand* rasterBand;
285 rasterBand=imgReader.getRasterBand(band_opt[iband]);
286 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev,pfnProgress,pProgressData);
288 std::cout <<
"-min " << minValue <<
" -max " << maxValue <<
" --mean " << meanValue <<
" --stdDev " << stdDev <<
" ";
291 if(minmax_opt[0]||min_opt[0]||max_opt[0]){
292 assert(band_opt[iband]<imgReader.nrOfBand());
294 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]))){
295 double uli,ulj,lri,lrj;
296 imgReader.geo2image(ulx_opt[0],uly_opt[0],uli,ulj);
297 imgReader.geo2image(lrx_opt[0],lry_opt[0],lri,lrj);
298 imgReader.getMinMax(static_cast<int>(uli),static_cast<int>(lri),static_cast<int>(ulj),static_cast<int>(lrj),band_opt[iband],minValue,maxValue);
301 imgReader.getMinMax(minValue,maxValue,band_opt[iband],
true);
304 std::cout <<
"-min " << minValue <<
" -max " << maxValue <<
" ";
307 std::cout <<
"-min " << minValue <<
" ";
309 std::cout <<
"-max " << maxValue <<
" ";
313 if(histogram_opt[0]){
314 assert(band_opt[0]<imgReader.nrOfBand());
315 nbin=(nbin_opt.size())? nbin_opt[0]:0;
317 imgReader.getMinMax(minValue,maxValue,band_opt[0]);
318 if(src_min_opt.size())
319 minValue=src_min_opt[0];
320 if(src_max_opt.size())
321 maxValue=src_max_opt[0];
322 if(minValue>=maxValue)
323 imgReader.getMinMax(minValue,maxValue,band_opt[0]);
326 cout <<
"number of valid pixels in image: " << imgReader.getNvalid(band_opt[0]) << endl;
328 nsample+=imgReader.getHistogram(histogramOutput,minValue,maxValue,nbin,band_opt[0],kde_opt[0]);
331 if(ifile==input_opt.size()-1){
332 std::cout.precision(10);
333 for(
int bin=0;bin<nbin;++bin){
335 if(nbin==maxValue-minValue+1)
336 binValue=minValue+bin;
338 binValue=minValue+
static_cast<double>(maxValue-minValue)*(bin+0.5)/nbin;
339 std::cout << binValue <<
" ";
340 if(relative_opt[0]||kde_opt[0])
341 std::cout << 100.0*
static_cast<double>(histogramOutput[bin])/static_cast<double>(nsample) << std::endl;
343 std::cout << static_cast<double>(histogramOutput[bin]) << std::endl;
347 if(histogram2d_opt[0]&&input_opt.size()<2){
348 assert(band_opt.size()>1);
349 imgReader.getMinMax(minX,maxX,band_opt[0]);
350 imgReader.getMinMax(minY,maxY,band_opt[1]);
351 if(src_min_opt.size()){
355 if(src_max_opt.size()){
359 nbin=(nbin_opt.size())? nbin_opt[0]:0;
361 std::cerr <<
"Warning: number of bins not defined, calculating bins from min and max value" << std::endl;
363 imgReader.getMinMax(minX,maxX,band_opt[0]);
365 imgReader.getMinMax(minY,maxY,band_opt[1]);
367 minValue=(minX<minY)? minX:minY;
368 maxValue=(maxX>maxY)? maxX:maxY;
370 std::cout <<
"min and max values: " << minValue <<
", " << maxValue << std::endl;
371 nbin=maxValue-minValue+1;
377 assert(band_opt[0]<imgReader.nrOfBand());
378 assert(band_opt[1]<imgReader.nrOfBand());
379 GDALProgressFunc pfnProgress;
381 GDALRasterBand* rasterBand;
384 rasterBand=imgReader.getRasterBand(band_opt[0]);
385 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev1,pfnProgress,pProgressData);
386 rasterBand=imgReader.getRasterBand(band_opt[1]);
387 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev2,pfnProgress,pProgressData);
389 double estimatedSize=1.0*imgReader.getNvalid(band_opt[0])/down_opt[0]/down_opt[0];
391 estimatedSize*=random_opt[0]/100.0;
392 sigma=1.06*sqrt(stdDev1*stdDev2)*pow(estimatedSize,-0.2);
397 std::cout <<
"calculating 2d kernel density estimate with sigma " << sigma <<
" for bands " << band_opt[0] <<
" and " << band_opt[1] << std::endl;
399 std::cout <<
"calculating 2d histogram for bands " << band_opt[0] <<
" and " << band_opt[1] << std::endl;
400 std::cout <<
"nbin: " << nbin << std::endl;
404 vector< vector<double> > output;
407 imgReader.getMinMax(minX,maxX,band_opt[0]);
409 imgReader.getMinMax(minY,maxY,band_opt[1]);
412 std::ostringstream s;
413 s<<
"Error: could not calculate distribution (minX>=maxX)";
417 std::ostringstream s;
418 s<<
"Error: could not calculate distribution (minY>=maxY)";
422 for(
int i=0;i<nbin;++i){
423 output[i].resize(nbin);
424 for(
int j=0;j<nbin;++j)
429 vector<double> inputX(imgReader.nrOfCol());
430 vector<double> inputY(imgReader.nrOfCol());
431 unsigned long int nvalid=0;
432 for(
int irow=0;irow<imgReader.nrOfRow();++irow){
435 imgReader.readData(inputX,GDT_Float64,irow,band_opt[0]);
436 imgReader.readData(inputY,GDT_Float64,irow,band_opt[1]);
437 for(
int icol=0;icol<imgReader.nrOfCol();++icol){
441 double p=
static_cast<double>(rand())/(RAND_MAX);
446 if(imgReader.isNoData(inputX[icol]))
448 if(imgReader.isNoData(inputY[icol]))
451 if(inputX[icol]>=maxX)
453 else if(inputX[icol]<=minX)
456 binX=
static_cast<int>(
static_cast<double>(inputX[icol]-minX)/(maxX-minX)*nbin);
457 if(inputY[icol]>=maxY)
459 else if(inputY[icol]<=minX)
462 binY=
static_cast<int>(
static_cast<double>(inputY[icol]-minY)/(maxY-minY)*nbin);
464 assert(binX<output.size());
466 assert(binY<output[binX].size());
470 for(
int ibinX=0;ibinX<nbin;++ibinX){
471 double centerX=minX+
static_cast<double>(maxX-minX)*ibinX/nbin;
472 double pdfX=gsl_ran_gaussian_pdf(inputX[icol]-centerX, sigma);
473 for(
int ibinY=0;ibinY<nbin;++ibinY){
475 double centerY=minY+
static_cast<double>(maxY-minY)*ibinY/nbin;
476 double pdfY=gsl_ran_gaussian_pdf(inputY[icol]-centerY, sigma);
477 output[ibinX][binY]+=pdfX*pdfY;
482 ++output[binX][binY];
486 cout <<
"number of valid pixels: " << nvalid << endl;
488 for(
int binX=0;binX<nbin;++binX){
490 for(
int binY=0;binY<nbin;++binY){
492 if(nbin==maxX-minX+1)
495 binValueX=minX+
static_cast<double>(maxX-minX)*(binX+0.5)/nbin;
497 if(nbin==maxY-minY+1)
500 binValueY=minY+
static_cast<double>(maxY-minY)*(binY+0.5)/nbin;
502 double value=
static_cast<double>(output[binX][binY]);
507 cout << binValueX <<
" " << binValueY <<
" " << value << std::endl;
513 if(reg_opt[0]&&input_opt.size()<2){
514 if(band_opt.size()<2)
516 imgreg.setDown(down_opt[0]);
517 imgreg.setThreshold(random_opt[0]);
520 double r2=imgreg.getR2(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
521 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
523 if(regerr_opt[0]&&input_opt.size()<2){
524 if(band_opt.size()<2)
526 imgreg.setDown(down_opt[0]);
527 imgreg.setThreshold(random_opt[0]);
530 double err=imgreg.getRMSE(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
531 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -rmse " << err << std::endl;
533 if(rmse_opt[0]&&input_opt.size()<2){
534 if(band_opt.size()<2)
536 imgreg.setDown(down_opt[0]);
537 imgreg.setThreshold(random_opt[0]);
540 double err=imgreg.getRMSE(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
541 std::cout <<
" -rmse " << err << std::endl;
543 if(preg_opt[0]&&input_opt.size()<2){
544 if(band_opt.size()<2)
546 imgreg.setDown(down_opt[0]);
547 imgreg.setThreshold(random_opt[0]);
550 double r2=imgreg.pgetR2(imgReader,band_opt[0],band_opt[1],c0,c1,verbose_opt[0]);
551 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
555 if(reg_opt[0]&&(input_opt.size()>1)){
556 imgreg.setDown(down_opt[0]);
557 imgreg.setThreshold(random_opt[0]);
560 while(band_opt.size()<input_opt.size())
561 band_opt.push_back(band_opt[0]);
562 if(src_min_opt.size()){
563 while(src_min_opt.size()<input_opt.size())
564 src_min_opt.push_back(src_min_opt[0]);
566 if(src_max_opt.size()){
567 while(src_max_opt.size()<input_opt.size())
568 src_max_opt.push_back(src_max_opt[0]);
573 if(offset_opt.size())
574 imgReader1.setOffset(offset_opt[0],band_opt[0]);
576 imgReader1.setScale(scale_opt[0],band_opt[0]);
577 if(offset_opt.size()>1)
578 imgReader2.setOffset(offset_opt[1],band_opt[1]);
579 if(scale_opt.size()>1)
580 imgReader2.setScale(scale_opt[1],band_opt[1]);
582 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
584 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
585 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
587 imgReader1.pushNoDataValue(nodata_opt[inodata]);
588 imgReader2.pushNoDataValue(nodata_opt[inodata]);
591 double r2=imgreg.getR2(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
592 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
596 if(preg_opt[0]&&(input_opt.size()>1)){
597 imgreg.setDown(down_opt[0]);
598 imgreg.setThreshold(random_opt[0]);
601 while(band_opt.size()<input_opt.size())
602 band_opt.push_back(band_opt[0]);
603 if(src_min_opt.size()){
604 while(src_min_opt.size()<input_opt.size())
605 src_min_opt.push_back(src_min_opt[0]);
607 if(src_max_opt.size()){
608 while(src_max_opt.size()<input_opt.size())
609 src_max_opt.push_back(src_max_opt[0]);
614 if(offset_opt.size())
615 imgReader1.setOffset(offset_opt[0],band_opt[0]);
617 imgReader1.setScale(scale_opt[0],band_opt[0]);
618 if(offset_opt.size()>1)
619 imgReader2.setOffset(offset_opt[1],band_opt[1]);
620 if(scale_opt.size()>1)
621 imgReader2.setScale(scale_opt[1],band_opt[1]);
623 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
625 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
626 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
628 imgReader1.pushNoDataValue(nodata_opt[inodata]);
629 imgReader2.pushNoDataValue(nodata_opt[inodata]);
632 double r2=imgreg.pgetR2(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
633 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -r2 " << r2 << std::endl;
637 if(regerr_opt[0]&&(input_opt.size()>1)){
638 imgreg.setDown(down_opt[0]);
639 imgreg.setThreshold(random_opt[0]);
642 while(band_opt.size()<input_opt.size())
643 band_opt.push_back(band_opt[0]);
644 if(src_min_opt.size()){
645 while(src_min_opt.size()<input_opt.size())
646 src_min_opt.push_back(src_min_opt[0]);
648 if(src_max_opt.size()){
649 while(src_max_opt.size()<input_opt.size())
650 src_max_opt.push_back(src_max_opt[0]);
655 if(offset_opt.size())
656 imgReader1.setOffset(offset_opt[0],band_opt[0]);
658 imgReader1.setScale(scale_opt[0],band_opt[0]);
659 if(offset_opt.size()>1)
660 imgReader2.setOffset(offset_opt[1],band_opt[1]);
661 if(scale_opt.size()>1)
662 imgReader2.setScale(scale_opt[1],band_opt[1]);
664 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
666 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
667 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
669 imgReader1.pushNoDataValue(nodata_opt[inodata]);
670 imgReader2.pushNoDataValue(nodata_opt[inodata]);
673 double err=imgreg.getRMSE(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
674 std::cout <<
"-c0 " << c0 <<
" -c1 " << c1 <<
" -rmse " << err << std::endl;
678 if(rmse_opt[0]&&(input_opt.size()>1)){
679 imgreg.setDown(down_opt[0]);
680 imgreg.setThreshold(random_opt[0]);
683 while(band_opt.size()<input_opt.size())
684 band_opt.push_back(band_opt[0]);
685 if(src_min_opt.size()){
686 while(src_min_opt.size()<input_opt.size())
687 src_min_opt.push_back(src_min_opt[0]);
689 if(src_max_opt.size()){
690 while(src_max_opt.size()<input_opt.size())
691 src_max_opt.push_back(src_max_opt[0]);
696 if(offset_opt.size())
697 imgReader1.setOffset(offset_opt[0],band_opt[0]);
699 imgReader1.setScale(scale_opt[0],band_opt[0]);
700 if(offset_opt.size()>1)
701 imgReader2.setOffset(offset_opt[1],band_opt[1]);
702 if(scale_opt.size()>1)
703 imgReader2.setScale(scale_opt[1],band_opt[1]);
705 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
707 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
708 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
710 imgReader1.pushNoDataValue(nodata_opt[inodata]);
711 imgReader2.pushNoDataValue(nodata_opt[inodata]);
714 double err=imgreg.getRMSE(imgReader1,imgReader2,c0,c1,band_opt[0],band_opt[1],verbose_opt[0]);
715 std::cout <<
"-rmse " << err << std::endl;
719 if(histogram2d_opt[0]&&(input_opt.size()>1)){
720 while(band_opt.size()<input_opt.size())
721 band_opt.push_back(band_opt[0]);
722 if(src_min_opt.size()){
723 while(src_min_opt.size()<input_opt.size())
724 src_min_opt.push_back(src_min_opt[0]);
726 if(src_max_opt.size()){
727 while(src_max_opt.size()<input_opt.size())
728 src_max_opt.push_back(src_max_opt[0]);
733 if(offset_opt.size())
734 imgReader1.setOffset(offset_opt[0],band_opt[0]);
736 imgReader1.setScale(scale_opt[0],band_opt[0]);
737 if(offset_opt.size()>1)
738 imgReader2.setOffset(offset_opt[1],band_opt[1]);
739 if(scale_opt.size()>1)
740 imgReader2.setScale(scale_opt[1],band_opt[1]);
742 for(
int inodata=0;inodata<nodata_opt.size();++inodata){
744 imgReader1.GDALSetNoDataValue(nodata_opt[0],band_opt[0]);
745 imgReader2.GDALSetNoDataValue(nodata_opt[0]),band_opt[1];
747 imgReader1.pushNoDataValue(nodata_opt[inodata]);
748 imgReader2.pushNoDataValue(nodata_opt[inodata]);
751 imgReader1.getMinMax(minX,maxX,band_opt[0]);
752 imgReader2.getMinMax(minY,maxY,band_opt[1]);
755 cout <<
"minX: " << minX << endl;
756 cout <<
"maxX: " << maxX << endl;
757 cout <<
"minY: " << minY << endl;
758 cout <<
"maxY: " << maxY << endl;
761 if(src_min_opt.size()){
765 if(src_max_opt.size()){
770 nbin=(nbin_opt.size())? nbin_opt[0]:0;
772 std::cerr <<
"Warning: number of bins not defined, calculating bins from min and max value" << std::endl;
776 imgReader1.getMinMax(minX,maxX,band_opt[0]);
778 imgReader2.getMinMax(minY,maxY,band_opt[1]);
780 minValue=(minX<minY)? minX:minY;
781 maxValue=(maxX>maxY)? maxX:maxY;
783 std::cout <<
"min and max values: " << minValue <<
", " << maxValue << std::endl;
784 nbin=maxValue-minValue+1;
790 GDALProgressFunc pfnProgress;
792 GDALRasterBand* rasterBand;
795 rasterBand=imgReader1.getRasterBand(band_opt[0]);
796 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev1,pfnProgress,pProgressData);
797 rasterBand=imgReader2.getRasterBand(band_opt[0]);
798 rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev2,pfnProgress,pProgressData);
801 double estimatedSize=1.0*imgReader.getNvalid(band_opt[0])/down_opt[0]/down_opt[0];
803 estimatedSize*=random_opt[0]/100.0;
804 sigma=1.06*sqrt(stdDev1*stdDev2)*pow(estimatedSize,-0.2);
809 std::cout <<
"calculating 2d kernel density estimate with sigma " << sigma <<
" for datasets " << input_opt[0] <<
" and " << input_opt[1] << std::endl;
811 std::cout <<
"calculating 2d histogram for datasets " << input_opt[0] <<
" and " << input_opt[1] << std::endl;
812 std::cout <<
"nbin: " << nbin << std::endl;
815 vector< vector<double> > output;
818 imgReader1.getMinMax(minX,maxX,band_opt[0]);
820 imgReader2.getMinMax(minY,maxY,band_opt[1]);
823 std::ostringstream s;
824 s<<
"Error: could not calculate distribution (minX>=maxX)";
828 std::ostringstream s;
829 s<<
"Error: could not calculate distribution (minY>=maxY)";
833 cout <<
"minX: " << minX << endl;
834 cout <<
"maxX: " << maxX << endl;
835 cout <<
"minY: " << minY << endl;
836 cout <<
"maxY: " << maxY << endl;
839 for(
int i=0;i<nbin;++i){
840 output[i].resize(nbin);
841 for(
int j=0;j<nbin;++j)
846 vector<double> inputX(imgReader1.nrOfCol());
847 vector<double> inputY(imgReader2.nrOfCol());
855 for(
int irow=0;irow<imgReader1.nrOfRow();++irow){
859 imgReader1.image2geo(icol1,irow1,geoX,geoY);
860 imgReader2.geo2image(geoX,geoY,icol2,irow2);
861 irow2=
static_cast<int>(irow2);
862 imgReader1.readData(inputX,GDT_Float64,irow1,band_opt[0]);
863 imgReader2.readData(inputY,GDT_Float64,irow2,band_opt[1]);
864 for(
int icol=0;icol<imgReader.nrOfCol();++icol){
869 double p=
static_cast<double>(rand())/(RAND_MAX);
874 if(imgReader1.isNoData(inputX[icol]))
876 imgReader1.image2geo(icol1,irow1,geoX,geoY);
877 imgReader2.geo2image(geoX,geoY,icol2,irow2);
878 icol2=
static_cast<int>(icol2);
879 if(imgReader2.isNoData(inputY[icol2]))
882 if(inputX[icol1]>=maxX)
884 else if(inputX[icol]<=minX)
887 binX=
static_cast<int>(
static_cast<double>(inputX[icol1]-minX)/(maxX-minX)*nbin);
888 if(inputY[icol2]>=maxY)
890 else if(inputY[icol2]<=minY)
893 binY=
static_cast<int>(
static_cast<double>(inputY[icol2]-minY)/(maxY-minY)*nbin);
895 assert(binX<output.size());
897 assert(binY<output[binX].size());
901 for(
int ibinX=0;ibinX<nbin;++ibinX){
902 double centerX=minX+
static_cast<double>(maxX-minX)*ibinX/nbin;
903 double pdfX=gsl_ran_gaussian_pdf(inputX[icol1]-centerX, sigma);
904 for(
int ibinY=0;ibinY<nbin;++ibinY){
906 double centerY=minY+
static_cast<double>(maxY-minY)*ibinY/nbin;
907 double pdfY=gsl_ran_gaussian_pdf(inputY[icol2]-centerY, sigma);
908 output[ibinX][binY]+=pdfX*pdfY;
914 ++output[binX][binY];
920 cout <<
"number of valid pixels: " << nvalid << endl;
921 for(
int binX=0;binX<nbin;++binX){
923 for(
int binY=0;binY<nbin;++binY){
925 if(nbin==maxX-minX+1)
928 binValueX=minX+
static_cast<double>(maxX-minX)*(binX+0.5)/nbin;
930 if(nbin==maxY-minY+1)
933 binValueY=minY+
static_cast<double>(maxY-minY)*(binY+0.5)/nbin;
934 double value=
static_cast<double>(output[binX][binY]);
936 if(relative_opt[0]||kde_opt[0])
939 cout << binValueX <<
" " << binValueY <<
" " << value << std::endl;
948 if(!histogram_opt[0]||histogram2d_opt[0])
949 std::cout << std::endl;