| pktools 2.6.7 Processing Kernel for geospatial data

ImgWriterGdal.h
1/**********************************************************************
2 ImgWriterGdal.h: class to write raster files using GDAL API library
3 Copyright (C) 2008-2016 Pieter Kempeneers
4
5 This file is part of pktools
6
7 pktools is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10(at your option) any later version.
11
12 pktools is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with pktools. If not, see <http://www.gnu.org/licenses/>.
19***********************************************************************/
20#ifndef _IMGWRITERGDAL_H_
21#define _IMGWRITERGDAL_H_
22
23#include <assert.h>
24#include <fstream>
25#include <string>
26#include <sstream>
27#include "gdal_priv.h"
28#include "ImgRasterGdal.h"
29#include "ImgReaderGdal.h"
30#include "ImgReaderOgr.h"
31
37 class ImgWriterGdal : public virtual ImgRasterGdal
38{
39 public:
41 ImgWriterGdal(void);
43 ImgWriterGdal(const std::string& filename, const ImgReaderGdal& imgSrc, const std::vector<std::string>& options=std::vector<std::string>()){open(filename, imgSrc, options);};
45 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>()){open(filename, ncol, nrow, nband, dataType, imageType, options);};
47 ~ImgWriterGdal(void);
48
50 void open(const std::string& filename, const ImgReaderGdal& imgSrc, const std::vector<std::string>& options=std::vector<std::string>());
52 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>());
53 void close(void);//definition in ImgWritergdal.cc
55 void setImageDescription(const std::string& imageDescription){m_gds->SetMetadataItem( "TIFFTAG_IMAGEDESCRIPTION",imageDescription.c_str());};
56
58 template<typename T> bool writeData(T& value, int col, int row, int band=0);
60 template<typename T> bool writeData(std::vector<T>& buffer, int minCol, int maxCol, int row, int band=0);
62 template<typename T> bool writeData(std::vector<T>& buffer, int row, int band=0);
63 // deprecated? Write an entire image from memory to file
64 // bool writeData(void* pdata, const GDALDataType& dataType, int band=0);
66 template<typename T> bool writeDataBlock(Vector2d<T>& buffer2d, int minCol, int maxCol, int minRow, int maxRow, int band=0);
67
69 void setColorTable(const std::string& filename, int band=0);
71 void setColorTable(GDALColorTable* colorTable, int band=0);
73 void setMetadata(char** metadata);
75 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>());
77 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>());
78
79 protected:
81 virtual void setCodec(const std::string& imageType);
83 virtual void setCodec(const ImgReaderGdal& ImgSrc);
84 std::vector<std::string> m_options;
85
86 private:
87};
88
96 template<typename T> bool ImgWriterGdal::writeData(T& value, int col, int row, int band)
97{
98 if(band>=nrOfBand()+1){
99 std::ostringstream s;
100 s << "Error: band (" << band << ") exceeds nrOfBand (" << nrOfBand() << ")";
101 throw(s.str());
102 }
103 if(col>=nrOfCol()){
104 std::ostringstream s;
105 s << "Error: col (" << col << ") exceeds nrOfCol (" << nrOfCol() << ")";
106 throw(s.str());
107 }
108 if(col<0){
109 std::ostringstream s;
110 s << "Error: col (" << col << ") is negative";
111 throw(s.str());
112 }
113 if(row>=nrOfRow()){
114 std::ostringstream s;
115 s << "Error: row (" << row << ") exceeds nrOfRow (" << nrOfRow() << ")";
116 throw(s.str());
117 }
118 if(row<0){
119 std::ostringstream s;
120 s << "Error: row (" << row << ") is negative";
121 throw(s.str());
122 }
123 double theScale=1;
124 double theOffset=0;
125 if(m_scale.size()>band||m_offset.size()>band){
126 if(m_scale.size()>band)
127 theScale=m_scale[band];
128 if(m_offset.size()>band)
129 theOffset=m_offset[band];
130 }
131 //fetch raster band
132 GDALRasterBand *poBand;
133 T dvalue=theScale*value+theOffset;
134 poBand->RasterIO(GF_Write,col,row,1,1,&dvalue,1,1,getGDALDataType<T>(),0,0);
135 return true;
136}
137
146 template<typename T> bool ImgWriterGdal::writeData(std::vector<T>& buffer, int minCol, int maxCol, int row, int band)
147{
148 if(buffer.size()!=maxCol-minCol+1){
149 std::string errorstring="invalid size of buffer";
150 throw(errorstring);
151 }
152 if(minCol>=nrOfCol()){
153 std::ostringstream s;
154 s << "minCol (" << minCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
155 throw(s.str());
156 }
157 if(minCol<0){
158 std::ostringstream s;
159 s << "mincol (" << minCol << ") is negative";
160 throw(s.str());
161 }
162 if(maxCol>=nrOfCol()){
163 std::ostringstream s;
164 s << "maxCol (" << maxCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
165 throw(s.str());
166 }
167 if(maxCol<minCol){
168 std::ostringstream s;
169 s << "maxCol (" << maxCol << ") is less than minCol (" << minCol << ")";
170 throw(s.str());
171 }
172 if(row>=nrOfRow()){
173 std::ostringstream s;
174 s << "row (" << row << ") exceeds nrOfRow (" << nrOfRow() << ")";
175 throw(s.str());
176 }
177 if(row<0){
178 std::ostringstream s;
179 s << "row (" << row << ") is negative";
180 throw(s.str());
181 }
182 //todo: scaling and offset!
183 //fetch raster band
184 GDALRasterBand *poBand;
185 if(band>=nrOfBand()+1){
186 std::ostringstream s;
187 s << "band (" << band << ") exceeds nrOfBand (" << nrOfBand() << ")";
188 throw(s.str());
189 }
190 poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
191 poBand->RasterIO(GF_Write,minCol,row,buffer.size(),1,&(buffer[0]),buffer.size(),1,getGDALDataType<T>(),0,0);
192 return true;
193}
194
201 template<typename T> bool ImgWriterGdal::writeData(std::vector<T>& buffer, int row, int band)
202{
203 return writeData(buffer,0,nrOfCol()-1,row,band);
204}
205
214 template<typename T> bool ImgWriterGdal::writeDataBlock(Vector2d<T>& buffer2d, int minCol, int maxCol, int minRow, int maxRow, int band)
215{
216 double theScale=1;
217 double theOffset=0;
218 if(m_scale.size()>band)
219 theScale=m_scale[band];
220 if(m_offset.size()>band)
221 theOffset=m_offset[band];
222 if(buffer2d.size()!=maxRow-minRow+1){
223 std::string errorstring="invalid buffer size";
224 throw(errorstring);
225 }
226 if(band>=nrOfBand()+1){
227 std::ostringstream s;
228 s << "band (" << band << ") exceeds nrOfBand (" << nrOfBand() << ")";
229 throw(s.str());
230 }
231 if(minCol>=nrOfCol()){
232 std::ostringstream s;
233 s << "minCol (" << minCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
234 throw(s.str());
235 }
236 if(minCol<0){
237 std::ostringstream s;
238 s << "mincol (" << minCol << ") is negative";
239 throw(s.str());
240 }
241 if(maxCol>=nrOfCol()){
242 std::ostringstream s;
243 s << "maxCol (" << maxCol << ") exceeds nrOfCol (" << nrOfCol() << ")";
244 throw(s.str());
245 }
246 if(maxCol<minCol){
247 std::ostringstream s;
248 s << "maxCol (" << maxCol << ") is less than minCol (" << minCol << ")";
249 throw(s.str());
250 }
251 //todo: apply scaling and offset!
252 typename std::vector<T> buffer((maxRow-minRow+1)*(maxCol-minCol+1));
253 //fetch raster band
254 GDALRasterBand *poBand;
255 // typename std::vector<T>::iterator startit=buffer.begin();
256 for(int irow=minRow;irow<=maxRow;++irow){
257 buffer.insert(buffer.begin()+(maxCol-minCol+1)*(irow-minRow),buffer2d[irow-minRow].begin(),buffer2d[irow-minRow].end());
258 }
259 poBand = m_gds->GetRasterBand(band+1);//GDAL uses 1 based index
260 poBand->RasterIO(GF_Write,minCol,minRow,maxCol-minCol+1,maxRow-minRow+1,&(buffer[0]),(maxCol-minCol+1),(maxRow-minRow+1),getGDALDataType<T>(),0,0);
261 return true;
262}
263
264#endif // _IMGWRITERGDAL_H_
265
266
267// adfGeoTransform[0] /* top left x */
268// adfGeoTransform[1] /* w-e pixel resolution */
269// adfGeoTransform[2] /* rotation, 0 if image is "north up" */
270// adfGeoTransform[3] /* top left y */
271// adfGeoTransform[4] /* rotation, 0 if image is "north up" */
272// adfGeoTransform[5] /* n-s pixel resolution */
ImgRasterGdal
Definition: ImgRasterGdal.h:68
ImgRasterGdal::nrOfRow
int nrOfRow(void) const
Get the number of rows of this dataset.
Definition: ImgRasterGdal.h:100
ImgRasterGdal::m_gds
GDALDataset * m_gds
instance of the GDAL dataset of this dataset
Definition: ImgRasterGdal.h:205
ImgRasterGdal::nrOfBand
int nrOfBand(void) const
Get the number of bands of this dataset.
Definition: ImgRasterGdal.h:102
ImgRasterGdal::m_offset
std::vector< double > m_offset
Vector containing the offset factor to be applied (one offset value for each band)
Definition: ImgRasterGdal.h:223
ImgRasterGdal::nrOfCol
int nrOfCol(void) const
Get the number of columns of this dataset.
Definition: ImgRasterGdal.h:98
ImgRasterGdal::m_scale
std::vector< double > m_scale
Vector containing the scale factor to be applied (one scale value for each band)
Definition: ImgRasterGdal.h:221
ImgReaderGdal
Definition: ImgReaderGdal.h:37
ImgReaderOgr
Definition: ImgReaderOgr.h:36
ImgWriterGdal
Definition: ImgWriterGdal.h:38
ImgWriterGdal::close
void close(void)
Close the image.
Definition: ImgWriterGdal.cc:74
ImgWriterGdal::setMetadata
void setMetadata(char **metadata)
Set specific metadata (driver specific)
Definition: ImgWriterGdal.cc:224
ImgWriterGdal::setCodec
virtual void setCodec(const std::string &imageType)
Register GDAL driver, setting the datatype, imagetype and some metadata.
Definition: ImgWriterGdal.cc:161
ImgWriterGdal::ImgWriterGdal
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....
Definition: ImgWriterGdal.h:43
ImgWriterGdal::open
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...
Definition: ImgWriterGdal.cc:43
ImgWriterGdal::ImgWriterGdal
ImgWriterGdal(void)
default constructor. Image needs to be opened later with one of the open methods.
Definition: ImgWriterGdal.cc:33
ImgWriterGdal::writeDataBlock
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 counti...
Definition: ImgWriterGdal.h:214
ImgWriterGdal::rasterizeOgr
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".
Definition: ImgWriterGdal.cc:314
ImgWriterGdal::setColorTable
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)
Definition: ImgWriterGdal.cc:254
ImgWriterGdal::setImageDescription
void setImageDescription(const std::string &imageDescription)
Set the image description (only for GeoTiff format: TIFFTAG_IMAGEDESCRIPTION)
Definition: ImgWriterGdal.h:55
ImgWriterGdal::rasterizeBuf
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".
ImgWriterGdal::~ImgWriterGdal
~ImgWriterGdal(void)
destructor
Definition: ImgWriterGdal.cc:35
ImgWriterGdal::ImgWriterGdal
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...
Definition: ImgWriterGdal.h:45
ImgWriterGdal::writeData
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 c...
Definition: ImgWriterGdal.h:96
Vector2d
Definition: Vector2d.h:32