Raster.h

#pragma once

#include "forward.h"

#include <gdal_priv.h>
#include <string>

#include "Dataset.h"
#include "detail/MemoryMap.h"

namespace isce3 { namespace io { namespace gdal {

class Raster {
public:

    static
    std::string defaultDriver() { return Dataset::defaultDriver(); }

    Raster(const std::string & path, GDALAccess access = GA_ReadOnly);

    Raster(const isce3::io::IDataSet & dataset, GDALAccess access = GA_ReadOnly);

    Raster(const std::string & path, int band, GDALAccess access = GA_ReadOnly);

    Raster(const isce3::io::IDataSet & dataset, int band, GDALAccess access = GA_ReadOnly);

    Raster(const std::string & path,
           int width,
           int length,
           GDALDataType datatype,
           const std::string & driver = defaultDriver());

    template<typename T>
    Raster(const T * data, int width, int length);

    template<typename T>
    Raster(T * data, int width, int length, GDALAccess access = GA_Update);

    template<typename T>
    Raster(const T * data,
           int width,
           int length,
           std::size_t colstride,
           std::size_t rowstride);

    template<typename T>
    Raster(T * data,
           int width,
           int length,
           std::size_t colstride,
           std::size_t rowstride,
           GDALAccess access = GA_Update);

    const Dataset & dataset() const { return _dataset; }

    Dataset & dataset() { return _dataset; }

    int band() const { return _band; }

    GDALDataType datatype() const;

    GDALAccess access() const { return _dataset.access(); }

    int width() const { return _dataset.width(); }

    int length() const { return _dataset.length(); }

    std::string driver() const { return _dataset.driver(); }

    GeoTransform getGeoTransform() const { return _dataset.getGeoTransform(); }

    void setGeoTransform(const GeoTransform & transform) { _dataset.setGeoTransform(transform); }

    isce3::core::ProjectionBase * getProjection() const { return _dataset.getProjection(); }

    void setProjection(const isce3::core::ProjectionBase * proj) { _dataset.setProjection(proj); }

    double x0() const { return _dataset.x0(); }

    double y0() const { return _dataset.y0(); }

    double dx() const { return _dataset.dx(); }

    double dy() const { return _dataset.dy(); }

    template<typename T>
    void readPixel(T * dst, int col, int row) const;

    template<typename T>
    void writePixel(const T * src, int col, int row);

    template<typename T>
    void readLine(T * dst, int row) const;

    template<typename T>
    void writeLine(const T * src, int row);

    template<typename T>
    void readLines(T * dst, int first_row, int num_rows) const;

    template<typename T>
    void writeLines(const T * src, int first_row, int num_rows);

    template<typename T>
    void readBlock(T * dst, int first_col, int first_row, int num_cols, int num_rows) const;

    template<typename T>
    void writeBlock(const T * src, int first_col, int first_row, int num_cols, int num_rows);

    template<typename T>
    void readAll(T * dst) const;

    template<typename T>
    void writeAll(const T * src);

    GDALRasterBand * get() { return _dataset._dataset->GetRasterBand(_band); }

    const GDALRasterBand * get() const { return _dataset._dataset->GetRasterBand(_band); }

    Buffer memmap();

    template<typename T>
    TypedBuffer<T> memmap();

    friend class Dataset;

private:

    Raster(const Dataset & dataset, int band);

    template<typename T>
    GDALDataType getIODataType() const;

    template<typename T>
    CPLErr readwriteBlock(T * buf,
                          int first_col,
                          int first_row,
                          int num_cols,
                          int num_rows,
                          GDALRWFlag rwflag) const;

    Dataset _dataset;
    int _band = 1;

    // _mmap must be constructed after _dataset and destructed before _dataset
    detail::MemoryMap _mmap;
};

}}}

#define ISCE_IO_GDAL_RASTER_ICC
#include "Raster.icc"
#undef ISCE_IO_GDAL_RASTER_ICC