ImgReaderGdal Class Reference

#include <ImgReaderGdal.h>

Inheritance diagram for ImgReaderGdal:

Collaboration diagram for ImgReaderGdal:

Public Member Functions
	ImgReaderGdal (void)
	default constructor. Image needs to be opened later with one of the open methods.
	ImgReaderGdal (const std::string &filename, const GDALAccess &readMode=GA_ReadOnly)
	constructor opening an image. Set memory (in MB) to cache a number of rows in memory
	~ImgReaderGdal (void)
	destructor
void	open (const std::string &filename, const GDALAccess &readMode=GA_ReadOnly)
	Open an image. More...
void	close (void)
	Set the memory (in MB) to cache a number of rows in memory. More...
template<typename T >
void	readData (T &value, int col, int row, int band=0)
	Read a single pixel cell value at a specific column and row for a specific band (all indices start counting from 0) More...
template<typename T >
void	readData (std::vector< T > &buffer, int minCol, int maxCol, int row, int band=0)
	Read pixel cell values for a range of columns for a specific row and band (all indices start counting from 0) More...
template<typename T >
void	readData (std::vector< T > &buffer, int minCol, int maxCol, double row, int band=0, RESAMPLE resample=NEAR)
	Read pixel cell values for a range of columns for a specific row and band (all indices start counting from 0). The row counter can be floating, in which case a resampling is applied at the row level. You still must apply the resampling at column level. This function will be deprecated, as the GDAL API now supports rasterIO resampling (see http://www.gdal.org/structGDALRasterIOExtraArg.html) More...
template<typename T >
void	readDataBlock (Vector2d< T > &buffer2d, int minCol, int maxCol, int minRow, int maxRow, int band=0)
	Read pixel cell values for a range of columns and rows for a specific band (all indices start counting from 0). The buffer is a two dimensional vector (stl vector of stl vector) representing [row][col]. More...
template<typename T >
void	readDataBlock (std::vector< T > &buffer, int minCol, int maxCol, int minRow, int maxRow, int band=0)
	Read pixel cell values for a range of columns and rows for a specific band (all indices start counting from 0). The buffer is a one dimensional stl vector representing all pixel values read starting from upper left to lower right. More...
template<typename T >
void	readData (std::vector< T > &buffer, int row, int band=0)
	Read pixel cell values for an entire row for a specific band (all indices start counting from 0) More...
template<typename T >
void	readData (std::vector< T > &buffer, double row, int band=0, RESAMPLE resample=NEAR)
	Read pixel cell values for an entire row for a specific band (all indices start counting from 0). The row counter can be floating, in which case a resampling is applied at the row level. You still must apply the resampling at column level. This function will be deprecated, as the GDAL API now supports rasterIO resampling (see http://www.gdal.org/structGDALRasterIOExtraArg.html) More...
void	getMinMax (int startCol, int endCol, int startRow, int endRow, int band, double &minValue, double &maxValue)
	Get the minimum and maximum cell values for a specific band in a region of interest defined by startCol, endCol, startRow and endRow (all indices start counting from 0). More...
void	getMinMax (double &minValue, double &maxValue, int band=0)
	Get the minimum and maximum cell values for a specific band (all indices start counting from 0). More...
double	getMin (int &col, int &row, int band=0)
	Get the minimum cell values for a specific band and report the column and row in which the minimum value was found (all indices start counting from 0). More...
double	getMax (int &col, int &row, int band=0)
	Get the maximum cell values for a specific band and report the column and row in which the maximum value was found (all indices start counting from 0). More...
double	getHistogram (std::vector< double > &histvector, double &min, double &max, unsigned int &nbin, int theBand=0, bool kde=false)
	Calculate the image histogram for a specific band using a defined number of bins and constrained by a minimum and maximum value. A kernel density function can also be applied (default is false). More...
void	getRefPix (double &refX, double &refY, int band=0)
	Calculate the reference pixel as the centre of gravity pixel (weighted average of all values not taking into account no data values) for a specific band (start counting from 0). More...
void	getRange (std::vector< short > &range, int Band=0)
	Calculate the range of cell values in the image for a specific band (start counting from 0). More...
unsigned long int	getNvalid (int band)
	Calculate the number of valid pixels (with a value not defined as no data). More...
Public Member Functions inherited from ImgRasterGdal
	ImgRasterGdal (void)
	default constructor
virtual	~ImgRasterGdal (void)
	destructor
void	setScale (double theScale, int band=0)
	Set scale for a specific band when writing the raster data values. The scaling and offset are applied on a per band basis. You need to set the scale for each band.
void	setOffset (double theOffset, int band=0)
	Set offset for a specific band when writing the raster data values. The scaling and offset are applied on a per band basis. You need to set the offset for each band.
std::string	getFileName () const
	Get the filename of this dataset.
int	nrOfCol (void) const
	Get the number of columns of this dataset.
int	nrOfRow (void) const
	Get the number of rows of this dataset.
int	nrOfBand (void) const
	Get the number of bands of this dataset.
bool	isGeoRef () const
	Is this dataset georeferenced (pixel size in y must be negative) ?
std::string	getProjection (void) const
	Get the projection string (deprecated, use getProjectionRef instead) More...
std::string	getProjectionRef (void) const
	Get the projection reference. More...
std::string	getGeoTransform () const
	Get the geotransform data for this dataset as a string. More...
void	getGeoTransform (double *gt) const
	Get the geotransform data for this dataset. More...
CPLErr	setGeoTransform (double *gt)
	Set the geotransform data for this dataset. More...
void	copyGeoTransform (const ImgRasterGdal &imgSrc)
	Copy geotransform information from another georeferenced image. More...
CPLErr	setProjection (const std::string &projection)
	Set the projection for this dataset in well known text (wkt) format. More...
CPLErr	setProjectionProj4 (const std::string &projection)
	Set the projection for this dataset from user input (supports epsg:<number> format) More...
bool	getBoundingBox (double &ulx, double &uly, double &lrx, double &lry) const
	Get the bounding box of this dataset in georeferenced coordinates. More...
bool	getCenterPos (double &x, double &y) const
	Get the center position of this dataset in georeferenced coordinates. More...
double	getUlx () const
	Get the upper left corner x (georeferenced) coordinate of this dataset.
double	getUly () const
	Get the upper left corner y (georeferenced) coordinate of this dataset.
double	getLrx () const
	Get the lower right corner x (georeferenced) coordinate of this dataset.
double	getLry () const
	Get the lower right corner y (georeferenced) coordinate of this dataset.
int	getNoDataValues (std::vector< double > &noDataValues) const
	Get the no data values of this dataset as a standard template library (stl) vector. More...
bool	isNoData (double value) const
	Check if value is nodata in this dataset.
int	pushNoDataValue (double noDataValue)
	Push a no data value for this dataset. More...
int	setNoData (const std::vector< double > nodata)
	Set the no data values of this dataset using a standard template library (stl) vector as input.
CPLErr	GDALSetNoDataValue (double noDataValue, int band=0)
	Set the GDAL (internal) no data value for this data set. Only a single no data value per band is supported.
bool	covers (double x, double y) const
	Check if a geolocation is covered by this dataset. Only the bounding box is checked, irrespective of no data values. More...
bool	covers (double ulx, double uly, double lrx, double lry) const
	Check if a region of interest is (partially) covered by this dataset. Only the bounding box is checked, irrespective of no data values. More...
bool	geo2image (double x, double y, double &i, double &j) const
	Convert georeferenced coordinates (x and y) to image coordinates (column and row) More...
bool	image2geo (double i, double j, double &x, double &y) const
	Convert image coordinates (column and row) to georeferenced coordinates (x and y) More...
double	getDeltaX (void) const
	Get the pixel cell spacing in x.
double	getDeltaY (void) const
	Get the pixel cell spacing in y.
GDALDataType	getDataType (int band=0) const
	Get the GDAL datatype for this dataset. More...
GDALRasterBand *	getRasterBand (int band=0) const
	Get the GDAL rasterband for this dataset. More...
GDALColorTable *	getColorTable (int band=0) const
	Get the GDAL color table for this dataset as an instance of the GDALColorTable class. More...
std::string	getDriverDescription () const
	Get the GDAL driver description of this dataset. More...
std::string	getImageType () const
	Get the image type (implemented as the driver description)
std::string	getInterleave () const
	Get the band coding (interleave) More...
std::string	getCompression () const
	Get the compression from the metadata of this dataset. More...
GDALDataset *	getDataset ()
char **	getMetadata ()
	Get the metadata of this dataset. More...
char **	getMetadata () const
	Get the metadata of this dataset (const version) More...
void	getMetadata (std::list< std::string > &metadata) const
	Get the metadata of this dataset in the form of a list of strings (const version) More...
std::string	getDescription () const
	Get the image description from the driver of this dataset. More...
std::string	getMetadataItem () const
	Get metadata item of this dataset. More...
std::string	getImageDescription () const
	Get the image description from the metadata of this dataset. More...
int	nrOfBlockX (int band=0)
int	nrOfBlockY (int band=0)

Protected Member Functions
void	setCodec (const GDALAccess &readMode=GA_ReadOnly)
	Set GDAL dataset number of columns, rows, bands and geotransform. More...

Additional Inherited Members
Protected Attributes inherited from ImgRasterGdal
std::string	m_filename
	filename of this dataset
GDALDataset *	m_gds
	instance of the GDAL dataset of this dataset
int	m_ncol
	number of columns in this dataset
int	m_nrow
	number of rows in this dataset
int	m_nband
	number of bands in this dataset
GDALDataType	m_dataType
	GDAL data type for this dataset.
double	m_gt [6]
	geotransform information of this dataset
std::string	m_projection
std::vector< double >	m_noDataValues
	no data values for this dataset
std::vector< double >	m_scale
	Vector containing the scale factor to be applied (one scale value for each band)
std::vector< double >	m_offset
	Vector containing the offset factor to be applied (one offset value for each band)

Detailed Description

Class to read a raster dataset in a format supported by GDAL. Data are cached in memory for a number of rows (if memory>0) before read from file.

This class inherits from ImgRasterGdal, a general raster class to store e.g., filename, number of columns, rows and bands of the dataset.

Definition at line 36 of file ImgReaderGdal.h.

Member Function Documentation

close()

void ImgReaderGdal::close ( void  )

virtual

Set the memory (in MB) to cache a number of rows in memory.

Close the image.

Reimplemented from ImgRasterGdal.

Reimplemented in ImgUpdaterGdal.

Definition at line 42 of file ImgReaderGdal.cc.

{
  ImgRasterGdal::close();
}

getHistogram()

double ImgReaderGdal::getHistogram	(	std::vector< double > &	histvector,
		double &	min,
		double &	max,
		unsigned int &	nbin,
		int	theBand = 0,
		bool	kde = false
	)

Calculate the image histogram for a specific band using a defined number of bins and constrained by a minimum and maximum value. A kernel density function can also be applied (default is false).

Parameters

histvector	The reported histogram with counts per bin
min,max	Only calculate histogram for values between min and max. If min>=max, calculate min and max from the image
nbin	Number of bins used for calculating the histogram. If nbin is 0, the number of bins is automatically calculated from min and max
theBand	The band for which to calculate the histogram (start counting from 0)
kde	Apply kernel density function for a Gaussian basis function

Returns

number of valid pixels in this dataset for the the selected band

Definition at line 257 of file ImgReaderGdal.cc.

                                                                                                                                    {
  double minValue=0;
  double maxValue=0;
      
  if(min>=max)
    getMinMax(minValue,maxValue,theBand);
  else{
    minValue=min;
    maxValue=max;
  }
  if(min<max&&min>minValue)
    minValue=min;
  if(min<max&&max<maxValue)
    maxValue=max;
  min=minValue;
  max=maxValue;

  double sigma=0;
  if(kde){
    double meanValue=0;
    double stdDev=0;
    GDALProgressFunc pfnProgress;
    void* pProgressData;
    GDALRasterBand* rasterBand;
    rasterBand=getRasterBand(theBand);
    rasterBand->ComputeStatistics(0,&minValue,&maxValue,&meanValue,&stdDev,pfnProgress,pProgressData);
    //rest minvalue and MaxValue as ComputeStatistics does not account for nodata, scale and offset
    minValue=min;
    maxValue=max;

    if(m_scale.size()>theBand){
      stdDev*=m_scale[theBand];
    }
    sigma=1.06*stdDev*pow(getNvalid(theBand),-0.2);
  }

  double scale=0;
  if(maxValue>minValue){
    if(nbin==0)
      nbin=maxValue-minValue+1;
    scale=static_cast<double>(nbin-1)/(maxValue-minValue);
  }
  else
    nbin=1;
  assert(nbin>0);
  if(histvector.size()!=nbin){
    histvector.resize(nbin);
    for(int i=0;i<nbin;histvector[i++]=0);
  }
  double nvalid=0;
  unsigned long int nsample=0;
  unsigned long int ninvalid=0;
  std::vector<double> lineBuffer(nrOfCol());
  for(int irow=0;irow<nrOfRow();++irow){
    readData(lineBuffer,irow,theBand);
    for(int icol=0;icol<nrOfCol();++icol){
      if(isNoData(lineBuffer[icol]))
        ++ninvalid;
      else if(lineBuffer[icol]>maxValue)
        ++ninvalid;
      else if(lineBuffer[icol]<minValue)
        ++ninvalid;
      else if(nbin==1)
    ++histvector[0];
      else{//scale to [0:nbin]
    if(sigma>0){
      //create kde for Gaussian basis function
      //todo: speed up by calculating first and last bin with non-zero contriubtion...
      //todo: calculate real surface below pdf by using gsl_cdf_gaussian_P(x-mean+binsize,sigma)-gsl_cdf_gaussian_P(x-mean,sigma)
      for(int ibin=0;ibin<nbin;++ibin){
        double icenter=minValue+static_cast<double>(maxValue-minValue)*(ibin+0.5)/nbin;
        double thePdf=gsl_ran_gaussian_pdf(lineBuffer[icol]-icenter, sigma);
        histvector[ibin]+=thePdf;
        nvalid+=thePdf;
      }
    }
    else{
      int theBin=static_cast<unsigned long int>(scale*(lineBuffer[icol]-minValue));
      assert(theBin>=0);
      assert(theBin<nbin);
      ++histvector[theBin];
      ++nvalid;
    }
      // else if(lineBuffer[icol]==maxValue)
      //   ++histvector[nbin-1];
      // else
      //   ++histvector[static_cast<int>(static_cast<double>(lineBuffer[icol]-minValue)/(maxValue-minValue)*(nbin-1))];
      }
    }
  }
  // unsigned long int nvalid=nrOfCol()*nrOfRow()-ninvalid;
  return nvalid;
}

getMax()

double ImgReaderGdal::getMax	(	int &	x,
		int &	y,
		int	band = 0
	)

Get the maximum cell values for a specific band and report the column and row in which the maximum value was found (all indices start counting from 0).

Parameters

x	Reported column where maximum value in image was found (start counting from 0)
y	Reported row where maximum value in image was found (start counting from 0)
band	Search mininum value in image for this band

Returns

maximum value in image for the selected band

Definition at line 125 of file ImgReaderGdal.cc.

                                                    {
  double maxValue=0;
  std::vector<double> lineBuffer(nrOfCol());
  bool isValid=false;
  for(int irow=0;irow<nrOfRow();++irow){
    readData(lineBuffer,irow,band);
    for(int icol=0;icol<nrOfCol();++icol){
      if(isNoData(lineBuffer[icol]))
    continue;
      if(isValid){
    if(lineBuffer[icol]>maxValue){
          y=irow;
          x=icol;
          maxValue=lineBuffer[icol];
        }
      }
      else{
    y=irow;
    x=icol;
    maxValue=lineBuffer[icol];
    isValid=true;
      }
    }
  }
  if(isValid)
    return maxValue;
  else
    throw(static_cast<std::string>("Warning: not initialized"));
}

getMin()

double ImgReaderGdal::getMin	(	int &	x,
		int &	y,
		int	band = 0
	)

Get the minimum cell values for a specific band and report the column and row in which the minimum value was found (all indices start counting from 0).

Parameters

x	Reported column where minimum value in image was found (start counting from 0)
y	Reported row where minimum value in image was found (start counting from 0)
band	Search mininum value in image for this band

Returns

minimum value in image for the selected band

Definition at line 89 of file ImgReaderGdal.cc.

                                                    {
  double minValue=0;
  std::vector<double> lineBuffer(nrOfCol());
  bool isValid=false;
  for(int irow=0;irow<nrOfRow();++irow){
    readData(lineBuffer,irow,band);
    for(int icol=0;icol<nrOfCol();++icol){
      if(isNoData(lineBuffer[icol]))
    continue;
      if(isValid){
    if(lineBuffer[icol]<minValue){
          y=irow;
          x=icol;
          minValue=lineBuffer[icol];
        }
      }
      else{
    y=irow;
    x=icol;
    minValue=lineBuffer[icol];
    isValid=true;
      }
    }
  }
  if(isValid)
    return minValue;
  else
    throw(static_cast<std::string>("Warning: not initialized"));
}

getMinMax() [1/2]

void ImgReaderGdal::getMinMax	(	int	startCol,
		int	endCol,
		int	startRow,
		int	endRow,
		int	band,
		double &	minValue,
		double &	maxValue
	)

Get the minimum and maximum cell values for a specific band in a region of interest defined by startCol, endCol, startRow and endRow (all indices start counting from 0).

Parameters

startCol,endCol,startRow,endRow	Search extreme value in this region of interest (all indices start counting from 0)
band	Search extreme value in image for this band
minValue	Reported minimum value within searched region
maxValue	Reported maximum value within searched region

Definition at line 161 of file ImgReaderGdal.cc.

{
  bool isConstraint=(maxValue>minValue);
  double minConstraint=minValue;
  double maxConstraint=maxValue;
  std::vector<double> lineBuffer(endCol-startCol+1);
  bool isValid=false;
  assert(endRow<nrOfRow());
  for(int irow=startCol;irow<endRow+1;++irow){
    readData(lineBuffer,startCol,endCol,irow,band);
    for(int icol=0;icol<lineBuffer.size();++icol){
      if(isNoData(lineBuffer[icol]))
    continue;
      if(isValid){
    if(isConstraint){
      if(lineBuffer[icol]<minConstraint)
        continue;
      if(lineBuffer[icol]>maxConstraint)
        continue;
    }
    if(lineBuffer[icol]<minValue)
      minValue=lineBuffer[icol];
    if(lineBuffer[icol]>maxValue)
      maxValue=lineBuffer[icol];
      }
      else{
    if(isConstraint){
      if(lineBuffer[icol]<minConstraint)
        continue;
      if(lineBuffer[icol]>maxConstraint)
        continue;
    }
    minValue=lineBuffer[icol];
    maxValue=lineBuffer[icol];
    isValid=true;
      }
    }
  }
  if(!isValid)
    throw(static_cast<std::string>("Warning: not initialized"));
}

getMinMax() [2/2]

void ImgReaderGdal::getMinMax	(	double &	minValue,
		double &	maxValue,
		int	band = 0
	)

Get the minimum and maximum cell values for a specific band (all indices start counting from 0).

Parameters

minValue	Reported minimum value in image
maxValue	Reported maximum value in image
band	Search extreme value in image for this band

Definition at line 208 of file ImgReaderGdal.cc.

{
  bool isConstraint=(maxValue>minValue);
  double minConstraint=minValue;
  double maxConstraint=maxValue;
  std::vector<double> lineBuffer(nrOfCol());
  bool isValid=false;
  for(int irow=0;irow<nrOfRow();++irow){
    readData(lineBuffer,irow,band);
    for(int icol=0;icol<nrOfCol();++icol){
      if(isNoData(lineBuffer[icol]))
    continue;
      if(isValid){
    if(isConstraint){
      if(lineBuffer[icol]<minConstraint)
        continue;
      if(lineBuffer[icol]>maxConstraint)
        continue;
    }
    if(lineBuffer[icol]<minValue)
      minValue=lineBuffer[icol];
    if(lineBuffer[icol]>maxValue)
      maxValue=lineBuffer[icol];
      }
      else{
    if(isConstraint){
      if(lineBuffer[icol]<minConstraint)
        continue;
      if(lineBuffer[icol]>maxConstraint)
        continue;
    }
    minValue=lineBuffer[icol];
    maxValue=lineBuffer[icol];
    isValid=true;
      }
    }
  }
  if(!isValid)
    throw(static_cast<std::string>("Warning: not initialized"));
}

getNvalid()

unsigned long int ImgReaderGdal::getNvalid

(

int

band

)

Calculate the number of valid pixels (with a value not defined as no data).

Parameters

band	The band for which to calculate the number of valid pixels

Returns

number of valid pixels in this dataset for the the selected band

Definition at line 373 of file ImgReaderGdal.cc.

{
  unsigned long int nvalid=0;
  if(m_noDataValues.size()){
    std::vector<double> lineBuffer(nrOfCol());
    for(int irow=0;irow<nrOfRow();++irow){
      readData(lineBuffer,irow,band);
      for(int icol=0;icol<nrOfCol();++icol){
    if(isNoData(lineBuffer[icol]))
      continue;
    else
      ++nvalid;
      }
    }
    return nvalid;
  }
  else
    return(nrOfCol()*nrOfRow());
}

getRange()

void ImgReaderGdal::getRange	(	std::vector< short > &	range,
		int	band = 0
	)

Calculate the range of cell values in the image for a specific band (start counting from 0).

Parameters

range	Sorted vector containing the range of image values
band	The band for which to calculate the range

Definition at line 355 of file ImgReaderGdal.cc.

{
  std::vector<short> lineBuffer(nrOfCol());
  range.clear();
  for(int irow=0;irow<nrOfRow();++irow){
    readData(lineBuffer,irow,band);
    for(int icol=0;icol<nrOfCol();++icol){
      if(find(range.begin(),range.end(),lineBuffer[icol])==range.end())
        range.push_back(lineBuffer[icol]);
    }
  }
  sort(range.begin(),range.end());
}

getRefPix()

void ImgReaderGdal::getRefPix	(	double &	refX,
		double &	refY,
		int	band = 0
	)

Calculate the reference pixel as the centre of gravity pixel (weighted average of all values not taking into account no data values) for a specific band (start counting from 0).

Parameters

refX,refY	Calculated reference pixel position in geo-refererenced coordinates
band	The band for which to calculate the number of valid pixels

Definition at line 398 of file ImgReaderGdal.cc.

{
  std::vector<double> lineBuffer(nrOfCol());
  double validCol=0;
  double validRow=0;
  int nvalidCol=0;
  int nvalidRow=0;
  for(int irow=0;irow<nrOfRow();++irow){
    readData(lineBuffer,irow,band);
    for(int icol=0;icol<nrOfCol();++icol){
      // bool valid=(find(m_noDataValues.begin(),m_noDataValues.end(),lineBuffer[icol])==m_noDataValues.end());
      // if(valid){
      if(!isNoData(lineBuffer[icol])){
        validCol+=icol+1;
        ++nvalidCol;
        validRow+=irow+1;
        ++nvalidRow;
      }
    }
  }
  if(isGeoRef()){
    //reference coordinate is lower left corner of pixel in center of gravity
    //we need geo coordinates for exactly this location: validCol(Row)/nvalidCol(Row)-0.5
    double cgravi=validCol/nvalidCol-0.5;
    double cgravj=validRow/nvalidRow-0.5;
    double refpixeli=floor(cgravi);
    double refpixelj=ceil(cgravj-1);
    //but image2geo provides location at center of pixel (shifted half pixel right down)
    image2geo(refpixeli,refpixelj,refX,refY);
    //refX and refY now refer to center of gravity pixel
    refX-=0.5*getDeltaX();//shift to left corner
    refY-=0.5*getDeltaY();//shift to lower left corner
  }
  else{
    refX=floor(validCol/nvalidCol-0.5);//left corner
    refY=floor(validRow/nvalidRow-0.5);//upper corner
    //shift to lower left corner of pixel
    refY+=1;
  }
}

open()

void ImgReaderGdal::open	(	const std::string &	filename,
		const GDALAccess &	readMode = GA_ReadOnly
	)

Open an image.

Parameters

filename	Open a raster dataset with this filename
readMode	Open dataset in ReadOnly or Update mode
memory	Available memory to cache image raster data (in MB)

Definition at line 36 of file ImgReaderGdal.cc.

{
  m_filename = filename;
  setCodec(readMode);
}

readData() [1/5]

template<typename T >

void ImgReaderGdal::readData	(	T &	value,
		int	col,
		int	row,
		int	band = 0
	)

Read a single pixel cell value at a specific column and row for a specific band (all indices start counting from 0)

Parameters

[out]	value	The cell value that was read
[in]	col	The column number to read (counting starts from 0)
[in]	row	The row number to read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)

Definition at line 95 of file ImgReaderGdal.h.

{
  assert(band<nrOfBand()+1);
  assert(col<nrOfCol());
  assert(col>=0);
  assert(row<nrOfRow());
  assert(row>=0);
  double dvalue=0;
  double theScale=1;
  double theOffset=0;
  if(m_scale.size()>band||m_offset.size()>band){
    if(m_scale.size()>band)
      theScale=m_scale[band];
    if(m_offset.size()>band)
      theOffset=m_offset[band];
  }
  //fetch raster band
  GDALRasterBand  *poBand;
  poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
  poBand->RasterIO(GF_Read,col,row,1,1,&value,1,1,getGDALDataType<T>(),0,0);
  dvalue=theScale*value+theOffset;
  value=static_cast<T>(dvalue);
}

readData() [2/5]

template<typename T >

void ImgReaderGdal::readData	(	std::vector< T > &	buffer,
		int	minCol,
		int	maxCol,
		int	row,
		int	band = 0
	)

Read pixel cell values for a range of columns for a specific row and band (all indices start counting from 0)

Parameters

[out]	buffer	The vector with all cell values that were read
[in]	minCol	First column from where to start reading (counting starts from 0)
[in]	maxCol	Last column that must be read (counting starts from 0)
[in]	row	The row number to read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)

Definition at line 126 of file ImgReaderGdal.h.

{
  assert(band<nrOfBand()+1);
  assert(minCol<nrOfCol());
  assert(minCol>=0);
  assert(maxCol<nrOfCol());
  assert(minCol<=maxCol);
  assert(row<nrOfRow());
  assert(row>=0);
  double theScale=1;
  double theOffset=0;
  if(m_scale.size()>band||m_offset.size()>band){
    if(m_scale.size()>band)
      theScale=m_scale[band];
    if(m_offset.size()>band)
      theOffset=m_offset[band];
  }
  //fetch raster band
  GDALRasterBand  *poBand;
  poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
  if(buffer.size()!=maxCol-minCol+1)
    buffer.resize(maxCol-minCol+1);
  poBand->RasterIO(GF_Read,minCol,row,buffer.size(),1,&(buffer[0]),buffer.size(),1,getGDALDataType<T>(),0,0);
  if(m_scale.size()>band||m_offset.size()>band){
    for(int index=0;index<buffer.size();++index)
      buffer[index]=theScale*static_cast<double>(buffer[index])+theOffset;
  }
}

readData() [3/5]

template<typename T >

void ImgReaderGdal::readData	(	std::vector< T > &	buffer,
		int	minCol,
		int	maxCol,
		double	row,
		int	band = 0,
		RESAMPLE	resample = NEAR
	)

Read pixel cell values for a range of columns for a specific row and band (all indices start counting from 0). The row counter can be floating, in which case a resampling is applied at the row level. You still must apply the resampling at column level. This function will be deprecated, as the GDAL API now supports rasterIO resampling (see http://www.gdal.org/structGDALRasterIOExtraArg.html)

Parameters

[out]	buffer	The vector with all cell values that were read
[in]	minCol	First column from where to start reading (counting starts from 0)
[in]	maxCol	Last column that must be read (counting starts from 0)
[in]	row	The row number to read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)
[in]	resample	The resampling method (currently only BILINEAR and NEAR are supported)

Definition at line 163 of file ImgReaderGdal.h.

{
  double eps=0.00001;
  std::vector<T> readBuffer_upper;
  std::vector<T> readBuffer_lower;
  double upperRow, lowerRow;
  if(buffer.size()!=maxCol-minCol+1)
    buffer.resize(maxCol-minCol+1);
  /* double upperRow=row-0.5; */
  /* upperRow=static_cast<int>(upperRow); */
  /* double lowerRow=row+0.5; */
  /* lowerRow=static_cast<int>(lowerRow); */
  switch(resample){
  case(BILINEAR):
    /* if(lowerRow>=nrOfRow()) */
    /*   lowerRow=nrOfRow()-1; */
    upperRow=static_cast<int>(row-0.5+eps);
    if(upperRow<0)
      upperRow=0;
    if(upperRow>=nrOfRow())
      upperRow=nrOfRow()-1;
    lowerRow=upperRow+1.0;
    if(lowerRow>=nrOfRow())
      lowerRow=nrOfRow()-1;

    readData(readBuffer_upper,minCol,maxCol,static_cast<int>(upperRow),band);
    readData(readBuffer_lower,minCol,maxCol,static_cast<int>(lowerRow),band);
    //do interpolation in y
    for(int icol=0;icol<maxCol-minCol+1;++icol){
      /* buffer[icol]=(lowerRow-row+0.5)*readBuffer_upper[icol]+(1-lowerRow+row-0.5)*readBuffer_lower[icol]; */
      if(!isNoData(readBuffer_upper[icol])){
        if(!isNoData(readBuffer_lower[icol])){
          buffer[icol]=(lowerRow-row+0.5)*readBuffer_upper[icol]+(1-lowerRow+row-0.5)*readBuffer_lower[icol];
        }
        else{
          buffer[icol]=readBuffer_upper[icol];
        }
      }
      else{
        buffer[icol]=readBuffer_lower[icol];
      }
    }
    break;
  default:
    readData(buffer,minCol,maxCol,static_cast<int>(row),band);
    break;
  }
}

readData() [4/5]

template<typename T >

void ImgReaderGdal::readData	(	std::vector< T > &	buffer,
		int	row,
		int	band = 0
	)

Read pixel cell values for an entire row for a specific band (all indices start counting from 0)

Parameters

[out]	buffer	The vector with all cell values that were read
[in]	row	The row number to read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)

Definition at line 280 of file ImgReaderGdal.h.

{
  readData(buffer,0,nrOfCol()-1,row,band);
}

readData() [5/5]

template<typename T >

void ImgReaderGdal::readData	(	std::vector< T > &	buffer,
		double	row,
		int	band = 0,
		RESAMPLE	resample = NEAR
	)

Read pixel cell values for an entire row for a specific band (all indices start counting from 0). The row counter can be floating, in which case a resampling is applied at the row level. You still must apply the resampling at column level. This function will be deprecated, as the GDAL API now supports rasterIO resampling (see http://www.gdal.org/structGDALRasterIOExtraArg.html)

Parameters

[out]	buffer	The vector with all cell values that were read
[in]	row	The row number to read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)
[in]	resample	The resampling method (currently only BILINEAR and NEAR are supported).

Definition at line 291 of file ImgReaderGdal.h.

{
  readData(buffer,0,nrOfCol()-1,row,band,resample);
}

readDataBlock() [1/2]

template<typename T >

void ImgReaderGdal::readDataBlock	(	Vector2d< T > &	buffer2d,
		int	minCol,
		int	maxCol,
		int	minRow,
		int	maxRow,
		int	band = 0
	)

Read pixel cell values for a range of columns and rows for a specific band (all indices start counting from 0). The buffer is a two dimensional vector (stl vector of stl vector) representing [row][col].

Parameters

[out]	buffer2d	Two dimensional vector of type Vector2d (stl vector of stl vector) representing [row][col]. This vector contains all cell values that were read
[in]	minCol	First column from where to start reading (counting starts from 0)
[in]	maxCol	Last column that must be read (counting starts from 0)
[in]	minRow	First row from where to start reading (counting starts from 0)
[in]	maxRow	Last row that must be read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)

Definition at line 220 of file ImgReaderGdal.h.

{
  buffer2d.resize(maxRow-minRow+1);
  typename std::vector<T> buffer;
  readDataBlock(buffer,minCol,maxCol,minRow,maxRow,band);
  typename std::vector<T>::const_iterator startit=buffer.begin();
  typename std::vector<T>::const_iterator endit=startit;
  for(int irow=minRow;irow<=maxRow;++irow){
    buffer2d[irow-minRow].resize(maxCol-minCol+1);
    endit+=maxCol-minCol+1;
    buffer2d[irow-minRow].assign(startit,endit);
    startit+=maxCol-minCol+1;
  }
}

readDataBlock() [2/2]

template<typename T >

void ImgReaderGdal::readDataBlock	(	std::vector< T > &	buffer,
		int	minCol,
		int	maxCol,
		int	minRow,
		int	maxRow,
		int	band = 0
	)

Read pixel cell values for a range of columns and rows for a specific band (all indices start counting from 0). The buffer is a one dimensional stl vector representing all pixel values read starting from upper left to lower right.

Parameters

[out]	buffer	One dimensional vector representing all pixel values read starting from upper left to lower right.
[in]	minCol	First column from where to start reading (counting starts from 0)
[in]	maxCol	Last column that must be read (counting starts from 0)
[in]	minRow	First row from where to start reading (counting starts from 0)
[in]	maxRow	Last row that must be read (counting starts from 0)
[in]	band	The band number to read (counting starts from 0)

Definition at line 243 of file ImgReaderGdal.h.

{
  double theScale=1;
  double theOffset=0;
  if(m_scale.size()>band)
    theScale=m_scale[band];
  if(m_offset.size()>band)
    theOffset=m_offset[band];
  if(minCol>=nrOfCol() ||
     (minCol<0) ||
     (maxCol>=nrOfCol()) ||
     (minCol>maxCol) ||
     (minRow>=nrOfRow()) ||
     (minRow<0) ||
     (maxRow>=nrOfRow()) ||
     (minRow>maxRow)){
    std::string errorString="block not within image boundaries";
    throw(errorString);
  }
  if(buffer.size()!=(maxRow-minRow+1)*(maxCol-minCol+1))
    buffer.resize((maxRow-minRow+1)*(maxCol-minCol+1));
  //fetch raster band
  GDALRasterBand  *poBand;
  assert(band<nrOfBand()+1);
  poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
  poBand->RasterIO(GF_Read,minCol,minRow,maxCol-minCol+1,maxRow-minRow+1,&(buffer[0]),(maxCol-minCol+1),(maxRow-minRow+1),getGDALDataType<T>(),0,0);
  if(m_scale.size()>band||m_offset.size()>band){
    for(int index=0;index<buffer.size();++index)
      buffer[index]=theScale*buffer[index]+theOffset;
  }
}

setCodec()

void ImgReaderGdal::setCodec ( const GDALAccess &  readMode = GA_ReadOnly )

protected

Set GDAL dataset number of columns, rows, bands and geotransform.

Parameters

readMode

Open dataset in ReadOnly or Update mode

Definition at line 50 of file ImgReaderGdal.cc.

{
  GDALAllRegister();
  // m_gds = (GDALDataset *) GDALOpen(m_filename.c_str(), readMode );
#if GDAL_VERSION_MAJOR < 2
  GDALAllRegister();
  m_gds = (GDALDataset *) GDALOpen(m_filename.c_str(), readMode );
#else
  GDALAllRegister();
  if(readMode==GA_ReadOnly)
    m_gds = (GDALDataset*) GDALOpenEx(m_filename.c_str(), GDAL_OF_READONLY|GDAL_OF_RASTER, NULL, NULL, NULL);
  else if(readMode==GA_Update)
    m_gds = (GDALDataset*) GDALOpenEx(m_filename.c_str(), GDAL_OF_UPDATE|GDAL_OF_RASTER, NULL, NULL, NULL);
#endif

  if(m_gds == NULL){
    std::string errorString="FileOpenError";
    throw(errorString);
  }
  m_ncol= m_gds->GetRasterXSize();
  m_nrow= m_gds->GetRasterYSize();
  m_nband= m_gds->GetRasterCount();
  double adfGeoTransform[6];
  m_gds->GetGeoTransform( adfGeoTransform );
  m_gt[0]=adfGeoTransform[0];
  m_gt[1]=adfGeoTransform[1];
  m_gt[2]=adfGeoTransform[2];
  m_gt[3]=adfGeoTransform[3];
  m_gt[4]=adfGeoTransform[4];
  m_gt[5]=adfGeoTransform[5];
  m_projection=m_gds->GetProjectionRef();
}

---

The documentation for this class was generated from the following files:

• /home/kempepi/PKTOOLS-2.6.7.6/src/imageclasses/ImgReaderGdal.h
• /home/kempepi/PKTOOLS-2.6.7.6/src/imageclasses/ImgReaderGdal.cc