ImgWriterGdal Class Reference

#include <ImgWriterGdal.h>

Inheritance diagram for ImgWriterGdal:

Collaboration diagram for ImgWriterGdal:

Public Member Functions
	ImgWriterGdal (void)
	default constructor. Image needs to be opened later with one of the open methods.
	ImgWriterGdal (const std::string &filename, const ImgReaderGdal &imgSrc, const std::vector< std::string > &options=std::vector< std::string >())
	constructor opening an image for writing, copying image attributes from a source image. Image is directly writen to file.
	ImgWriterGdal (const std::string &filename, int ncol, int nrow, int nband, const GDALDataType &dataType, const std::string &imageType, const std::vector< std::string > &options=std::vector< std::string >())
	constructor opening an image for writing, defining all image attributes. Image is directly written to file.
	~ImgWriterGdal (void)
	destructor
void	open (const std::string &filename, const ImgReaderGdal &imgSrc, const std::vector< std::string > &options=std::vector< std::string >())
	Open an image for writing, copying image attributes from a source image. Image is directly written to file. More...
void	open (const std::string &filename, int ncol, int nrow, int nband, const GDALDataType &dataType, const std::string &imageType, const std::vector< std::string > &options=std::vector< std::string >())
	Open an image for writing, defining all image attributes. Image is directly written to file. More...
void	close (void)
	Close the image.
void	setImageDescription (const std::string &imageDescription)
	Set the image description (only for GeoTiff format: TIFFTAG_IMAGEDESCRIPTION)
template<typename T >
bool	writeData (T &value, int col, int row, int band=0)
	Write 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 >
bool	writeData (std::vector< T > &buffer, int minCol, int maxCol, int row, int band=0)
	Write pixel cell values for a range of columns for a specific row and band (all indices start counting from 0) More...
template<typename T >
bool	writeData (std::vector< T > &buffer, int row, int band=0)
	Write pixel cell values for an entire row for a specific band (all indices start counting from 0) More...
template<typename T >
bool	writeDataBlock (Vector2d< T > &buffer2d, int minCol, int maxCol, int minRow, int maxRow, int band=0)
	Write 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...
void	setColorTable (const std::string &filename, int band=0)
	Set the color table using an (ASCII) file with 5 columns (value R G B alpha) More...
void	setColorTable (GDALColorTable *colorTable, int band=0)
	Set the color table using the GDAL class GDALColorTable. More...
void	setMetadata (char **metadata)
	Set specific metadata (driver specific) More...
void	rasterizeOgr (ImgReaderOgr &ogrReader, const std::vector< double > &burnValues, const std::vector< std::string > &controlOptions=std::vector< std::string >(), const std::vector< std::string > &layernames=std::vector< std::string >())
	Rasterize an OGR vector dataset using the gdal algorithm "GDALRasterizeLayers". More...
void	rasterizeBuf (ImgReaderOgr &ogrReader, const std::vector< double > &burnValues, const std::vector< std::string > &controlOptions=std::vector< std::string >(), const std::vector< std::string > &layernames=std::vector< std::string >())
	Rasterize an OGR vector dataset in memory using the gdal algorithm "GDALRasterizeLayersBuf".
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
virtual void	setCodec (const std::string &imageType)
	Register GDAL driver, setting the datatype, imagetype and some metadata. More...
virtual void	setCodec (const ImgReaderGdal &ImgSrc)
	Register GDAL driver, setting the datatype, imagetype and some metadata. More...

Protected Attributes
std::vector< std::string >	m_options
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 write a raster dataset in a format supported by GDAL. Currently only those formats where the drivers support the Create method can be written.

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 37 of file ImgWriterGdal.h.

Member Function Documentation

open() [1/2]

void ImgWriterGdal::open	(	const std::string &	filename,
		const ImgReaderGdal &	imgSrc,
		const std::vector< std::string > &	options = std::vector<std::string>()
	)

Open an image for writing, copying image attributes from a source image. Image is directly written to file.

Parameters

filename	Open a raster dataset with this filename
imgSrc	Use this source image as a template to copy image attributes
options	Creation options

Definition at line 43 of file ImgWriterGdal.cc.

{
  m_ncol=imgSrc.nrOfCol();
  m_nrow=imgSrc.nrOfRow();
  m_nband=imgSrc.nrOfBand();
  m_dataType=imgSrc.getDataType();
  m_filename=filename;
  m_options=options;
  setCodec(imgSrc);
}

open() [2/2]

void ImgWriterGdal::open	(	const std::string &	filename,
		int	ncol,
		int	nrow,
		int	nband,
		const GDALDataType &	dataType,
		const std::string &	imageType,
		const std::vector< std::string > &	options = std::vector<std::string>()
	)

Open an image for writing, defining all image attributes. Image is directly written to file.

Parameters

filename	Open a raster dataset with this filename
ncol	Number of columns in image
nrow	Number of rows in image
nband	Number of bands in image
dataType	The data type of the image (one of the GDAL supported datatypes: GDT_Byte, GDT_[U]Int[16|32], GDT_Float[32|64])
imageType	Image type. Currently only those formats where the drivers support the Create method can be written
options	Creation options

Definition at line 63 of file ImgWriterGdal.cc.

{
  m_ncol = ncol;
  m_nrow = nrow;
  m_nband = nband;
  m_dataType = dataType;
  m_filename = filename;
  m_options=options;
  setCodec(imageType);
}

rasterizeOgr()

void ImgWriterGdal::rasterizeOgr	(	ImgReaderOgr &	ogrReader,
		const std::vector< double > &	burnValues,
		const std::vector< std::string > &	controlOptions = std::vector<std::string>(),
		const std::vector< std::string > &	layernames = std::vector<std::string>()
	)

Rasterize an OGR vector dataset using the gdal algorithm "GDALRasterizeLayers".

Parameters

ogrReader	Vector dataset as an instance of the ImgReaderOgr that must be rasterized
burnValues	Values to burn into raster cells (one value for each band)
controlOptions	special options controlling rasterization (ATTRIBUTE|CHUNKYSIZE|ALL_TOUCHED|BURN_VALUE_FROM|MERGE_ALG) "ATTRIBUTE": Identifies an attribute field on the features to be used for a burn in value. The value will be burned into all output bands. If specified, padfLayerBurnValues will not be used and can be a NULL pointer. "CHUNKYSIZE": The height in lines of the chunk to operate on. The larger the chunk size the less times we need to make a pass through all the shapes. If it is not set or set to zero the default chunk size will be used. Default size will be estimated based on the GDAL cache buffer size using formula: cache_size_bytes/scanline_size_bytes, so the chunk will not exceed the cache. "ALL_TOUCHED": May be set to TRUE to set all pixels touched by the line or polygons, not just those whose center is within the polygon or that are selected by brezenhams line algorithm. Defaults to FALSE. "BURN_VALUE_ May be set to "Z" to use the Z values of the geometries. The value from padfLayerBurnValues or the attribute field value is added to this before burning. In default case dfBurnValue is burned as it is. This is implemented properly only for points and lines for now. Polygons will be burned using the Z value from the first point. The M value may be supported in the future. "MERGE_ALG": May be REPLACE (the default) or ADD. REPLACE results in overwriting of value, while ADD adds the new value to the existing raster, suitable for heatmaps for instance.
layernames	Names of the vector dataset layers to process. Leave empty to process all layers

Definition at line 314 of file ImgWriterGdal.cc.

                                                                                                                                                                                 {
  std::vector<int> bands;
  if(burnValues.empty()&&controlOptions.empty()){
    std::string errorString="Error: either burn values or control options must be provided";
    throw(errorString);
  }
  for(int iband=0;iband<nrOfBand();++iband)
    bands.push_back(iband+1);
  std::vector<OGRLayerH> layers;
  int nlayer=0;

  std::vector<double> burnBands;//burn values for all bands in a single layer
  std::vector<double> burnLayers;//burn values for all bands and all layers
  if(burnValues.size()){
    burnBands=burnValues;
    while(burnBands.size()<nrOfBand())
      burnBands.push_back(burnValues[0]);
  }
  for(int ilayer=0;ilayer<ogrReader.getLayerCount();++ilayer){
    std::string currentLayername=ogrReader.getLayer(ilayer)->GetName();
    if(layernames.size())
      if(find(layernames.begin(),layernames.end(),currentLayername)==layernames.end())
    continue;
    std::cout << "processing layer " << currentLayername << std::endl;
    layers.push_back((OGRLayerH)ogrReader.getLayer(ilayer));
    ++nlayer;
    if(burnValues.size()){
      for(int iband=0;iband<nrOfBand();++iband)
        burnLayers.insert(burnLayers.end(),burnBands.begin(),burnBands.end());
    }
  }
  void* pTransformArg;
  GDALProgressFunc pfnProgress=NULL;
  void* pProgressArg=NULL;

  char **coptions=NULL;
  for(std::vector<std::string>::const_iterator optionIt=controlOptions.begin();optionIt!=controlOptions.end();++optionIt)
    coptions=CSLAddString(coptions,optionIt->c_str());

  if(controlOptions.size()){
    if(GDALRasterizeLayers( (GDALDatasetH)m_gds,nrOfBand(),&(bands[0]),layers.size(),&(layers[0]),NULL,pTransformArg,NULL,coptions,pfnProgress,pProgressArg)!=CE_None){
      std::string errorString(CPLGetLastErrorMsg());
      throw(errorString);
    }
  }
  else if(burnValues.size()){
    if(GDALRasterizeLayers( (GDALDatasetH)m_gds,nrOfBand(),&(bands[0]),layers.size(),&(layers[0]),NULL,pTransformArg,&(burnLayers[0]),NULL,pfnProgress,pProgressArg)!=CE_None){
      std::string errorString(CPLGetLastErrorMsg());
      throw(errorString);
    }
  }
  else{
    std::string errorString="Error: either attribute fieldname or burn values must be set to rasterize vector dataset";
    throw(errorString);
  }
}

setCodec() [1/2]

void ImgWriterGdal::setCodec ( const std::string &  imageType )

protectedvirtual

Register GDAL driver, setting the datatype, imagetype and some metadata.

Parameters

dataType	The data type of the image (one of the GDAL supported datatypes: GDT_Byte, GDT_[U]Int[16|32], GDT_Float[32|64])
imageType	Image type. Currently only those formats where the drivers support the Create method can be written

Definition at line 161 of file ImgWriterGdal.cc.

{
  GDALAllRegister();
  GDALDriver *poDriver;
  poDriver = GetGDALDriverManager()->GetDriverByName(imageType.c_str());
  if( poDriver == NULL ){
    std::ostringstream s;
    s << "FileOpenError (" << imageType << ")";
    throw(s.str());
  }
  char **papszMetadata;
  papszMetadata = poDriver->GetMetadata();
  //todo: try and catch if CREATE is not supported (as in PNG)
  assert( CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ));
  char **papszOptions=NULL;
  for(std::vector<std::string>::const_iterator optionIt=m_options.begin();optionIt!=m_options.end();++optionIt)
    papszOptions=CSLAddString(papszOptions,optionIt->c_str());
  m_gds=poDriver->Create(m_filename.c_str(),m_ncol,m_nrow,m_nband,m_dataType,papszOptions);
  double gt[6];
  getGeoTransform(gt);
  if(setGeoTransform(gt)!=CE_None)
    std::cerr << "Warning: could not write geotransform information in " << m_filename << std::endl;
  if(setProjection(m_projection)!=CE_None)
    std::cerr << "Warning: could not write projection information in " << m_filename << std::endl;
  m_gds->SetMetadataItem( "TIFFTAG_DOCUMENTNAME", m_filename.c_str());
  std::string versionString="pktools ";
  versionString+=VERSION;
  versionString+=" by Pieter Kempeneers";
  m_gds->SetMetadataItem( "TIFFTAG_SOFTWARE", versionString.c_str());
  time_t rawtime;
  time ( &rawtime );

  time_t tim=time(NULL);
  tm *now=localtime(&tim);
  std::ostringstream datestream;
  //date std::string must be 20 characters long...
  datestream << now->tm_year+1900;
  if(now->tm_mon+1<10)
    datestream << ":0" << now->tm_mon+1;
  else
    datestream << ":" << now->tm_mon+1;
  if(now->tm_mday<10)
    datestream << ":0" << now->tm_mday;
  else
    datestream << ":" << now->tm_mday;
  if(now->tm_hour<10)
    datestream << " 0" << now->tm_hour;
  else
    datestream << " " << now->tm_hour;
  if(now->tm_min<10)
    datestream << ":0" << now->tm_min;
  else
    datestream << ":" << now->tm_min;
  if(now->tm_sec<10)
    datestream << ":0" << now->tm_sec;
  else
    datestream << ":" << now->tm_sec;
  m_gds->SetMetadataItem( "TIFFTAG_DATETIME", datestream.str().c_str());
}

setCodec() [2/2]

void ImgWriterGdal::setCodec ( const ImgReaderGdal &  imgSrc )

protectedvirtual

Register GDAL driver, setting the datatype, imagetype and some metadata.

Parameters

imgSrc

Use this source image as a template to copy image attributes

Definition at line 88 of file ImgWriterGdal.cc.

                                                       {
  GDALAllRegister();
  GDALDriver *poDriver;
  poDriver = GetGDALDriverManager()->GetDriverByName(imgSrc.getDriverDescription().c_str());
  if( poDriver == NULL ){
    std::string errorString="FileOpenError";
    throw(errorString);
  }
  char **papszMetadata;
  papszMetadata = poDriver->GetMetadata();
  //todo: try and catch if CREATE is not supported (as in PNG)
  assert( CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ));
  char **papszOptions=NULL;
  for(std::vector<std::string>::const_iterator optionIt=m_options.begin();optionIt!=m_options.end();++optionIt)
    papszOptions=CSLAddString(papszOptions,optionIt->c_str());

  m_gds=poDriver->Create(m_filename.c_str(),m_ncol,m_nrow,m_nband,imgSrc.getDataType(),papszOptions);
  double gt[6];
  imgSrc.getGeoTransform(gt);
  if(setGeoTransform(gt)!=CE_None)
    std::cerr << "Warning: could not write geotransform information in " << m_filename << std::endl;
  setProjection(imgSrc.getProjection());
  if(setProjection(imgSrc.getProjection())!=CE_None)
    std::cerr << "Warning: could not write projection information in " << m_filename << std::endl;

  if(m_noDataValues.size()){
    for(int iband=0;iband<nrOfBand();++iband)
      GDALSetNoDataValue(m_noDataValues[0],iband);
  }

  m_gds->SetMetadata(imgSrc.getMetadata() ); 
  m_gds->SetMetadataItem( "TIFFTAG_DOCUMENTNAME", m_filename.c_str());
  std::string versionString="pktools ";
  versionString+=VERSION;
  versionString+=" by Pieter Kempeneers";
  m_gds->SetMetadataItem( "TIFFTAG_SOFTWARE", versionString.c_str());
  time_t rawtime;
  time ( &rawtime );

  time_t tim=time(NULL);
  tm *now=localtime(&tim);
  std::ostringstream datestream;
  //date std::string must be 20 characters long...
  datestream << now->tm_year+1900;
  if(now->tm_mon+1<10)
    datestream << ":0" << now->tm_mon+1;
  else
    datestream << ":" << now->tm_mon+1;
  if(now->tm_mday<10)
    datestream << ":0" << now->tm_mday;
  else
    datestream << ":" << now->tm_mday;
  if(now->tm_hour<10)
    datestream << " 0" << now->tm_hour;
  else
    datestream << " " << now->tm_hour;
  if(now->tm_min<10)
    datestream << ":0" << now->tm_min;
  else
    datestream << ":" << now->tm_min;
  if(now->tm_sec<10)
    datestream << ":0" << now->tm_sec;
  else
    datestream << ":" << now->tm_sec;
  m_gds->SetMetadataItem( "TIFFTAG_DATETIME", datestream.str().c_str());
  if(imgSrc.getColorTable()!=NULL)
    setColorTable(imgSrc.getColorTable());
}

setColorTable() [1/2]

void ImgWriterGdal::setColorTable	(	const std::string &	filename,
		int	band = 0
	)

Set the color table using an (ASCII) file with 5 columns (value R G B alpha)

Parameters

filename	ASCII file containing 5 columns: index R G B ALFA (0:transparent, 255:solid)
band	band number to set color table (starting counting from 0)

Definition at line 254 of file ImgWriterGdal.cc.

{
  //todo: fool proof table in file (no checking currently done...)
  std::ifstream ftable(filename.c_str(),std::ios::in);
  std::string line;
//   poCT=new GDALColorTable();
  GDALColorTable colorTable;
  short nline=0;
  while(getline(ftable,line)){
    ++nline;
    std::istringstream ist(line);
    GDALColorEntry sEntry;
    short id;
    ist >> id >> sEntry.c1 >> sEntry.c2 >> sEntry.c3 >> sEntry.c4;
    colorTable.SetColorEntry(id,&sEntry);
  }
  if(m_gds)
    (m_gds->GetRasterBand(band+1))->SetColorTable(&colorTable);
}

setColorTable() [2/2]

void ImgWriterGdal::setColorTable	(	GDALColorTable *	colorTable,
		int	band = 0
	)

Set the color table using the GDAL class GDALColorTable.

Parameters

colorTable	Instance of the GDAL class GDALColorTable
band	band number to set color table (starting counting from 0)

Definition at line 278 of file ImgWriterGdal.cc.

{
  if(m_gds)
    (m_gds->GetRasterBand(band+1))->SetColorTable(colorTable);
}

setMetadata()

void ImgWriterGdal::setMetadata

(

char **

metadata

)

Set specific metadata (driver specific)

Parameters

metadata

Set this metadata when writing the image (if supported byt the driver)

Definition at line 224 of file ImgWriterGdal.cc.

{
  if(m_gds)
    m_gds->SetMetadata(metadata); 
}

writeData() [1/3]

template<typename T >

bool ImgWriterGdal::writeData	(	T &	value,
		int	col,
		int	row,
		int	band = 0
	)

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

Parameters

[in]	value	The cell value to write
[in]	col	The column number to write (counting starts from 0)
[in]	row	The row number to write (counting starts from 0)
[in]	band	The band number to write (counting starts from 0)

Returns

true if write successful

Definition at line 96 of file ImgWriterGdal.h.

{
  if(band>=nrOfBand()+1){
    std::ostringstream s;
    s << "Error: band (" << band << ") exceeds nrOfBand (" << nrOfBand() << ")";
    throw(s.str());
  }
  if(col>=nrOfCol()){
    std::ostringstream s;
    s << "Error: col (" << col << ") exceeds nrOfCol (" << nrOfCol() << ")";
    throw(s.str());
  }
  if(col<0){
    std::ostringstream s;
    s << "Error: col (" << col << ") is negative";
    throw(s.str());
  }
  if(row>=nrOfRow()){
    std::ostringstream s;
    s << "Error: row (" << row << ") exceeds nrOfRow (" << nrOfRow() << ")";
    throw(s.str());
  }
  if(row<0){
    std::ostringstream s;
    s << "Error: row (" << row << ") is negative";
    throw(s.str());
  }
  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;
  T dvalue=theScale*value+theOffset;
  poBand->RasterIO(GF_Write,col,row,1,1,&dvalue,1,1,getGDALDataType<T>(),0,0);
  return true;
}

writeData() [2/3]

template<typename T >

bool ImgWriterGdal::writeData	(	std::vector< T > &	buffer,
		int	minCol,
		int	maxCol,
		int	row,
		int	band = 0
	)

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

Parameters

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

Returns

true if write successful

Definition at line 146 of file ImgWriterGdal.h.

{
  if(buffer.size()!=maxCol-minCol+1){
    std::string errorstring="invalid size of buffer";
    throw(errorstring);
  }
  if(minCol>=nrOfCol()){
    std::ostringstream s;
    s << "minCol (" << minCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
    throw(s.str());
  }
  if(minCol<0){
    std::ostringstream s;
    s << "mincol (" << minCol << ") is negative";
    throw(s.str());
  }
  if(maxCol>=nrOfCol()){
    std::ostringstream s;
    s << "maxCol (" << maxCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
    throw(s.str());
  }
  if(maxCol<minCol){
    std::ostringstream s;
    s << "maxCol (" << maxCol << ") is less than minCol (" << minCol << ")";
    throw(s.str());
  }
  if(row>=nrOfRow()){
    std::ostringstream s;
    s << "row (" << row << ") exceeds nrOfRow (" << nrOfRow() << ")";
    throw(s.str());
  }
  if(row<0){
    std::ostringstream s;
    s << "row (" << row << ") is negative";
    throw(s.str());
  }
  //todo: scaling and offset!
  //fetch raster band
  GDALRasterBand  *poBand;
  if(band>=nrOfBand()+1){
    std::ostringstream s;
    s << "band (" << band << ") exceeds nrOfBand (" << nrOfBand() << ")";
    throw(s.str());
  }
  poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
  poBand->RasterIO(GF_Write,minCol,row,buffer.size(),1,&(buffer[0]),buffer.size(),1,getGDALDataType<T>(),0,0);
  return true;
}

writeData() [3/3]

template<typename T >

bool ImgWriterGdal::writeData	(	std::vector< T > &	buffer,
		int	row,
		int	band = 0
	)

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

Parameters

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

Returns

true if write successful

Definition at line 201 of file ImgWriterGdal.h.

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

writeDataBlock()

template<typename T >

bool ImgWriterGdal::writeDataBlock	(	Vector2d< T > &	buffer2d,
		int	minCol,
		int	maxCol,
		int	minRow,
		int	maxRow,
		int	band = 0
	)

Write 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

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

Returns

true if write successful

Definition at line 214 of file ImgWriterGdal.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(buffer2d.size()!=maxRow-minRow+1){
    std::string errorstring="invalid buffer size";
    throw(errorstring);
  }
  if(band>=nrOfBand()+1){
    std::ostringstream s;
    s << "band (" << band << ") exceeds nrOfBand (" << nrOfBand() << ")";
    throw(s.str());
  }
  if(minCol>=nrOfCol()){
    std::ostringstream s;
    s << "minCol (" << minCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
    throw(s.str());
  }
  if(minCol<0){
    std::ostringstream s;
    s << "mincol (" << minCol << ") is negative";
    throw(s.str());
  }
  if(maxCol>=nrOfCol()){
    std::ostringstream s;
    s << "maxCol (" << maxCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
    throw(s.str());
  }
  if(maxCol<minCol){
    std::ostringstream s;
    s << "maxCol (" << maxCol << ") is less than minCol (" << minCol << ")";
    throw(s.str());
  }
  //todo: apply scaling and offset!
  typename std::vector<T> buffer((maxRow-minRow+1)*(maxCol-minCol+1));
  //fetch raster band
  GDALRasterBand  *poBand;
  // typename std::vector<T>::iterator startit=buffer.begin();
  for(int irow=minRow;irow<=maxRow;++irow){
    buffer.insert(buffer.begin()+(maxCol-minCol+1)*(irow-minRow),buffer2d[irow-minRow].begin(),buffer2d[irow-minRow].end());
  }
  poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
  poBand->RasterIO(GF_Write,minCol,minRow,maxCol-minCol+1,maxRow-minRow+1,&(buffer[0]),(maxCol-minCol+1),(maxRow-minRow+1),getGDALDataType<T>(),0,0);
  return true;
}

---

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

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