Detailed Description

Class Raster is used for managing raster data.

A raster consists of the meta data like number of columns and rows, the lower left point, the size of a raster pixel and a value for invalid data pixels. Additional the object needs the raster data itself. The raster data will be copied from the constructor. The destructor will release the memory.

Definition at line 48 of file Raster.h.

#include <Raster.h>

Collaboration diagram for GeoLib::Raster:

[legend]

Public Member Functions
template<typename InputIterator >
	Raster (RasterHeader header, InputIterator begin, InputIterator end)
	Constructor for an object of class Raster. The raster data have to be handed over via input iterators. Deploying iterators has the advantage that the use of the class is independent from the input container.

	Raster (Raster const &)=default

	Raster (Raster &&)=default

Raster &	operator= (Raster const &)=default

Raster &	operator= (Raster &&)=default

	~Raster ()=default

RasterHeader const &	getHeader () const
	Returns the complete header information.

void	refineRaster (std::size_t scaling)

std::vector< double >::const_iterator	begin () const

std::vector< double >::const_iterator	end () const

double const *	data () const

double const &	operator() (std::size_t const row, std::size_t const col) const

double &	operator() (std::size_t const row, std::size_t const col)

double	getValueAtPoint (const MathLib::Point3d &pnt) const

double	interpolateValueAtPoint (const MathLib::Point3d &pnt) const

bool	isPntOnRaster (MathLib::Point3d const &pnt) const

bool	operator== (Raster const &) const =default

Private Member Functions
void	setCellSize (double cell_size)

void	setNoDataVal (double no_data_val)

Private Attributes
GeoLib::RasterHeader	_header

std::vector< double >	_raster_data

Constructor & Destructor Documentation

◆ Raster() [1/3]

template<typename InputIterator >

GeoLib::Raster::Raster	(	RasterHeader	header,
		InputIterator	begin,
		InputIterator	end )

inline

Constructor for an object of class Raster. The raster data have to be handed over via input iterators. Deploying iterators has the advantage that the use of the class is independent from the input container.

Parameters

header	meta-information about the raster (height, width, etc.)
begin	input iterator pointing to the first element of the data
end	input iterator pointing to the last element of the data, end have to be reachable from begin

Definition at line 62 of file Raster.h.

        : _header(std::move(header)),
          _raster_data(_header.n_cols * _header.n_rows)
    {
        unsigned long const number_of_input_values =
            static_cast<unsigned long>(std::distance(begin, end));
        if (number_of_input_values != _header.n_cols * _header.n_rows)
        {
            throw std::out_of_range(
                "Number of raster data mismatch, need " +
                std::to_string(_header.n_cols * _header.n_rows) +
                " values, but got " + std::to_string(number_of_input_values));
        }
        std::copy(begin, end, _raster_data.begin());
    }

References _header, _raster_data, begin(), end(), GeoLib::RasterHeader::n_cols, and GeoLib::RasterHeader::n_rows.

◆ Raster() [2/3]

GeoLib::Raster::Raster ( Raster const & )

default

◆ Raster() [3/3]

GeoLib::Raster::Raster ( Raster && )

default

◆ ~Raster()

GeoLib::Raster::~Raster ( )

default

Member Function Documentation

◆ begin()

std::vector< double >::const_iterator GeoLib::Raster::begin ( ) const

inline

Constant iterator that is pointing to the first raster pixel value.

Returns: constant iterator

Definition at line 96 of file Raster.h.

    {
        return _raster_data.begin();
    }

References _raster_data.

Referenced by Raster(), and LayeredMeshGenerator::calcEpsilon().

◆ data()

double const * GeoLib::Raster::data ( ) const

inline

Definition at line 111 of file Raster.h.

111{ return _raster_data.data(); }

References _raster_data.

Referenced by MeshToolsLib::RasterToMesh::convert(), and FileIO::AsciiRasterInterface::writeRasterAsASC().

◆ end()

std::vector< double >::const_iterator GeoLib::Raster::end ( ) const

inline

Iterator to the element following the last pixel element of the raster

Returns: constant iterator

Definition at line 106 of file Raster.h.

    {
        return _raster_data.end();
    }

References _raster_data.

Referenced by Raster(), and LayeredMeshGenerator::calcEpsilon().

◆ getHeader()

RasterHeader const & GeoLib::Raster::getHeader ( ) const

inline

Returns the complete header information.

Definition at line 85 of file Raster.h.

85{ return _header; }

References _header.

Referenced by MeshToolsLib::RasterToMesh::convert(), DirectConditionGenerator::directToSurfaceNodes(), LayeredMeshGenerator::getNewLayerNode(), MeshToolsLib::MeshLayerMapper::layerMapping(), MeshToolsLib::RasterDataToMesh::projectToElements(), MeshToolsLib::RasterDataToMesh::projectToNodes(), and FileIO::AsciiRasterInterface::writeRasterAsASC().

◆ getValueAtPoint()

double GeoLib::Raster::getValueAtPoint ( const MathLib::Point3d & pnt ) const

Returns the raster value at the position of the given point.

Definition at line 56 of file Raster.cpp.

{
    if (pnt[0] >= _header.origin[0] &&
        pnt[0] < (_header.origin[0] + (_header.cell_size * _header.n_cols)) &&
        pnt[1] >= _header.origin[1] &&
        pnt[1] < (_header.origin[1] + (_header.cell_size * _header.n_rows)))
    {
        auto cell_x = static_cast<int>(
            std::floor((pnt[0] - _header.origin[0]) / _header.cell_size));
        auto cell_y = static_cast<int>(
            std::floor((pnt[1] - _header.origin[1]) / _header.cell_size));
 
        // use raster boundary values if node is outside raster due to rounding
        // errors or floating point arithmetic
        cell_x = (cell_x < 0) ? 0
                              : ((cell_x > static_cast<int>(_header.n_cols))
                                     ? static_cast<int>(_header.n_cols - 1)
                                     : cell_x);
        cell_y = (cell_y < 0) ? 0
                              : ((cell_y > static_cast<int>(_header.n_rows))
                                     ? static_cast<int>(_header.n_rows - 1)
                                     : cell_y);
 
        const std::size_t index = cell_y * _header.n_cols + cell_x;
        return _raster_data[index];
    }
    return _header.no_data;
}

References _header, _raster_data, GeoLib::RasterHeader::cell_size, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_rows, GeoLib::RasterHeader::no_data, and GeoLib::RasterHeader::origin.

Referenced by DirectConditionGenerator::directToSurfaceNodes(), and MeshToolsLib::MeshLayerMapper::layerMapping().

◆ interpolateValueAtPoint()

double GeoLib::Raster::interpolateValueAtPoint ( const MathLib::Point3d & pnt ) const

Interpolates the elevation of the given point based on the 8-neighbourhood of the raster cell it is located on

Definition at line 85 of file Raster.cpp.

{
    // position in raster
    double const xPos((pnt[0] - _header.origin[0]) / _header.cell_size);
    double const yPos((pnt[1] - _header.origin[1]) / _header.cell_size);
    // raster cell index
    double const xIdx(std::floor(xPos));  // carry out computions in double
    double const yIdx(std::floor(yPos));  //  so not to over- or underflow.
 
    // weights for bilinear interpolation
    double const xShift = std::abs((xPos - xIdx) - 0.5);
    double const yShift = std::abs((yPos - yIdx) - 0.5);
    Eigen::Vector4d weight = {(1 - xShift) * (1 - yShift),
                              xShift * (1 - yShift), xShift * yShift,
                              (1 - xShift) * yShift};
 
    // neighbors to include in interpolation
    int const xShiftIdx = (xPos - xIdx >= 0.5) ? 1 : -1;
    int const yShiftIdx = (yPos - yIdx >= 0.5) ? 1 : -1;
    std::array<int, 4> const x_nb = {{0, xShiftIdx, xShiftIdx, 0}};
    std::array<int, 4> const y_nb = {{0, 0, yShiftIdx, yShiftIdx}};
 
    // get pixel values
    Eigen::Vector4d pix_val{};
    unsigned no_data_count(0);
    for (unsigned j = 0; j < 4; ++j)
    {
        // check if neighbour pixel is still on the raster, otherwise substitute
        // a no data value. This also allows the cast to unsigned type.
        if ((xIdx + x_nb[j]) < 0 || (yIdx + y_nb[j]) < 0 ||
            (xIdx + x_nb[j]) > (_header.n_cols - 1) ||
            (yIdx + y_nb[j]) > (_header.n_rows - 1))
        {
            pix_val[j] = _header.no_data;
        }
        else
        {
            pix_val[j] = _raster_data[static_cast<std::size_t>(yIdx + y_nb[j]) *
                                          _header.n_cols +
                                      static_cast<std::size_t>(xIdx + x_nb[j])];
        }
 
        // remove no data values
        if (std::abs(pix_val[j] - _header.no_data) <
            std::numeric_limits<double>::epsilon())
        {
            weight[j] = 0;
            no_data_count++;
        }
    }
 
    // adjust weights if necessary
    if (no_data_count > 0)
    {
        if (no_data_count == 4)
        {  // if there is absolutely no data just use the default value
            return _header.no_data;
        }
 
        weight /= weight.sum();
    }
 
    // new value
    return weight.dot(pix_val);
}

References _header, _raster_data, GeoLib::RasterHeader::cell_size, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_rows, GeoLib::RasterHeader::no_data, and GeoLib::RasterHeader::origin.

Referenced by VtkImageDataToSurfacePointsFilter::createPointSurface(), LayeredMeshGenerator::getNewLayerNode(), and MeshToolsLib::MeshLayerMapper::layerMapping().

◆ isPntOnRaster()

bool GeoLib::Raster::isPntOnRaster ( MathLib::Point3d const & pnt ) const

Checks if the given point is located within the (x,y)-extension of the raster.

Definition at line 151 of file Raster.cpp.

{
    return !(
        (pnt[0] < _header.origin[0]) ||
        (pnt[0] > _header.origin[0] + (_header.n_cols * _header.cell_size)) ||
        (pnt[1] < _header.origin[1]) ||
        (pnt[1] > _header.origin[1] + (_header.n_rows * _header.cell_size)));
}

References _header, GeoLib::RasterHeader::cell_size, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_rows, and GeoLib::RasterHeader::origin.

Referenced by MeshToolsLib::MeshLayerMapper::layerMapping().

◆ operator()() [1/2]

double & GeoLib::Raster::operator()	(	std::size_t const	row,
		std::size_t const	col )

inline

Definition at line 126 of file Raster.h.

    {
        return const_cast<double&>(std::as_const(*this)(row, col));
    }

◆ operator()() [2/2]

double const & GeoLib::Raster::operator()	(	std::size_t const	row,
		std::size_t const	col ) const

inline

Access the pixel specified by row, col.

Definition at line 116 of file Raster.h.

    {
        if (row >= _header.n_rows || col >= _header.n_cols)
        {
            OGS_FATAL(
                "Raster pixel ({}, {}) doesn't exist. Raster size is {} x {}.",
                row, col, _header.n_rows, _header.n_cols);
        }
        return _raster_data[(_header.n_rows - 1 - row) * _header.n_cols + col];
    }

References _header, _raster_data, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_rows, and OGS_FATAL.

◆ operator=() [1/2]

Raster & GeoLib::Raster::operator= ( Raster && )

default

◆ operator=() [2/2]

Raster & GeoLib::Raster::operator= ( Raster const & )

default

◆ operator==()

bool GeoLib::Raster::operator== ( Raster const & ) const

default

◆ refineRaster()

void GeoLib::Raster::refineRaster ( std::size_t scaling )

Refine the raster using scaling as a refinement parameter.

Definition at line 25 of file Raster.cpp.

{
    std::vector<double> new_raster_data(_header.n_rows * _header.n_cols *
                                        scaling * scaling);
 
    for (std::size_t row(0); row < _header.n_rows; row++)
    {
        for (std::size_t col(0); col < _header.n_cols; col++)
        {
            const std::size_t idx(row * _header.n_cols + col);
            for (std::size_t new_row(row * scaling);
                 new_row < (row + 1) * scaling;
                 new_row++)
            {
                const std::size_t idx0(new_row * _header.n_cols * scaling);
                for (std::size_t new_col(col * scaling);
                     new_col < (col + 1) * scaling;
                     new_col++)
                {
                    new_raster_data[idx0 + new_col] = _raster_data[idx];
                }
            }
        }
    }
 
    std::swap(_raster_data, new_raster_data);
    _header.cell_size /= scaling;
    _header.n_cols *= scaling;
    _header.n_rows *= scaling;
}

References _header, _raster_data, GeoLib::RasterHeader::cell_size, GeoLib::RasterHeader::n_cols, and GeoLib::RasterHeader::n_rows.

◆ setCellSize()

void GeoLib::Raster::setCellSize ( double cell_size )

private

◆ setNoDataVal()

void GeoLib::Raster::setNoDataVal ( double no_data_val )

private

Member Data Documentation

◆ _header

GeoLib::RasterHeader GeoLib::Raster::_header

private

Definition at line 150 of file Raster.h.

Referenced by Raster(), getHeader(), getValueAtPoint(), interpolateValueAtPoint(), isPntOnRaster(), operator()(), and refineRaster().

◆ _raster_data

std::vector<double> GeoLib::Raster::_raster_data

private

Definition at line 151 of file Raster.h.

Referenced by Raster(), begin(), data(), end(), getValueAtPoint(), interpolateValueAtPoint(), operator()(), and refineRaster().

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

GeoLib/Raster.h
GeoLib/Raster.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ Raster() [1/3]

◆ Raster() [2/3]

◆ Raster() [3/3]

◆ ~Raster()

Member Function Documentation

◆ begin()

◆ data()

◆ end()

◆ getHeader()

◆ getValueAtPoint()

◆ interpolateValueAtPoint()

◆ isPntOnRaster()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ refineRaster()

◆ setCellSize()

◆ setNoDataVal()

Member Data Documentation

◆ _header

◆ _raster_data