height_manager.cpp

Go to the documentation of this file.

#include "height_management/height_manager.h"
 
#include <gdal.h>
#include <gdal_priv.h>
 
namespace HeightManagement
{
 
    HeightManager::HeightManager() {}
 
    void
    HeightManager::LoadTif(const char* filePath, double x, double y)
    {
        m_CachedTifName = filePath;
        Core::UTMCoordinate UTMCoord{ x, y };
        UpdateOrigin(UTMCoord, m_Size);
        return;
    }
 
    void
    HeightManager::UpdateOrigin(Core::UTMCoordinate UTMCoord, int size)
    {
        m_Origo = { UTMCoord.Easting, UTMCoord.Northing, 0 };
        m_Size = size;
        m_Vertices = new heightdata[m_Size * m_Size];
 
        UpdateCornerCoords();
 
        if (!OrigoWithinBounds(UTMCoord.Easting, UTMCoord.Northing)) {
            // If I get the WCS request to work, that will be initialized here!
            std::cerr
                << "Selected origin not within bounds! Please ensure x is "
                   "within the range "
                << m_UpperLeftX << " - " << m_LowerRightX
                << " and Y is within the range " << long(m_LowerRightY) << " - "
                << long(m_UpperLeftY) << " (" << m_CoordinateSystem << ")"
                << "." << std::endl;
            return;
        }
 
        PopulateVertices();
        m_Origo.z = GetHeightAbsolute(UTMCoord.Easting, UTMCoord.Northing);
    }
 
    void
    HeightManager::PopulateVertices()
    {
        // Opening the dataset
        GDALAllRegister();
 
        GDALDataset* dataset =
            (GDALDataset*)GDALOpen(m_CachedTifName, GA_ReadOnly);
        if (dataset == NULL) {
            std::cerr << "Failed to open file" << std::endl;
        }
 
        // Extracting raster band data. Elevation data is located on band 1 as a
        // rule for GeoTiff files.
        GDALRasterBand* band = dataset->GetRasterBand(1);
        if (band == NULL) {
            std::cerr << "Failed to get raster band" << std::endl;
        }
 
        // Converting and extracting data from pixels/lines to coordinates
        double geoTransform[6];
        dataset->GetGeoTransform(geoTransform);
 
        // The corners for the entire dataset can be found on [0] and [3] of the
        // geotransformed array.
        double upperLeftX = geoTransform[0];
        double upperLeftY = geoTransform[3];
 
        // Defining the upper right corner of our selection. Because the origin
        // point is in the center of the dataset, the distance from the origin
        // x, y to each corner is half of the total size of the subset.
        double selectionCornerX = (m_Origo.x - m_Size / 2);
        double selectionCornerY = (m_Origo.y + m_Size / 2);
 
        // Updating the member variable for the selected subset's top left
        // corner coordinate for use in other methods.
        m_SelectionCorner = { selectionCornerX, selectionCornerY, 0 };
 
        // Extracting height values from the band containing height data
        // (elevationData). This is placed in a one-dimensional array
        // elevationData.
        int xOffset = (selectionCornerX - upperLeftX);
        int yOffset = (upperLeftY - selectionCornerY);
 
        float* elevationData = new float[m_Size * m_Size];
 
        CPLErr result =
            band->RasterIO(GF_Read, xOffset, yOffset, m_Size, m_Size,
                           elevationData, m_Size, m_Size, GDT_Float32, 0, 0);
 
        // Placing height data into member variable for use in other methods.
        // The method to find any given point in a coordinate system with 0, 0
        // in the top left corner is (y coordinate * size of one dimension of
        // the imagined two-dimensional array) + x coordinate. If the array is
        // 500*500 in size and you want the height for the (5, 10) coordinate,
        // the calculation will be (10 * 500) + 5.
        for (int yDex = 0; yDex < m_Size; yDex++) {
            for (int xDex = 0; xDex < m_Size; xDex++) {
                m_Vertices[yDex * m_Size + xDex].x = selectionCornerX + xDex;
                m_Vertices[yDex * m_Size + xDex].y = selectionCornerY - yDex;
                m_Vertices[yDex * m_Size + xDex].z =
                    elevationData[yDex * m_Size + xDex];
            }
        }
 
        // Cleaning up and closing dataset.
        delete[] elevationData;
        GDALClose(dataset);
    }
 
    bool
    HeightManager::GetVertex(int inputRelativeX, int inputRelativeY,
                             HeightManager::heightdata& vertex)
    {
        if (ValidInput(inputRelativeX, inputRelativeY)) {
            vertex.z = m_Vertices[inputRelativeY * m_Size + inputRelativeX].z;
            return true;
        }
 
        else {
            std::cerr << "Request out of bounds" << std::endl;
            return false;
        }
    }
 
    bool
    HeightManager::GetVertexAbsolute(double inputX, double inputY,
                                     HeightManager::heightdata& vertex)
    {
        if (ValidInput(inputX, inputY)) {
            double inputOffsetX = inputX - m_SelectionCorner.x;
            double inputOffsetY = m_SelectionCorner.y - inputY;
            vertex.z = m_Vertices[int(inputOffsetY * m_Size + inputOffsetX)].z;
            return true;
        }
 
        else {
            std::cerr << "Request out of bounds" << std::endl;
            return false;
        }
    }
 
    float
    HeightManager::GetHeightAbsolute(double inputX, double inputY)
    {
        if (ValidInput(inputX, inputY)) {
            double inputOffsetX = inputX - m_SelectionCorner.x;
            double inputOffsetY = m_SelectionCorner.y - inputY;
            return m_Vertices[int(inputOffsetY * m_Size + inputOffsetX)].z;
        }
 
        else {
            std::cerr << "Request out of bounds" << std::endl;
            return 0;
        }
    }
 
    bool
    HeightManager::GetHeight(int inputRelativeX, int inputRelativeY,
                             float& height)
    {
        if (ValidInput(inputRelativeX, inputRelativeY)) {
            height = m_Vertices[inputRelativeY * m_Size + inputRelativeX].z;
            return true;
        }
 
        else {
            std::cerr << "Request out of bounds" << std::endl;
            return false;
        }
    }
 
    bool
    HeightManager::ValidInput(int x, int y)
    {
        bool validInput = (0 <= y) && (y < m_Size) && (0 <= x) && (x < m_Size);
        return validInput;
    }
 
    bool
    HeightManager::ValidInput(double x, double y)
    {
        bool validInput = (m_SelectionCorner.x <= x) &&
                          (x <= (m_SelectionCorner.x + m_Size)) &&
                          (m_SelectionCorner.y >= y) &&
                          (y >= m_SelectionCorner.y - m_Size);
        return validInput;
    }
 
    bool
    HeightManager::OrigoWithinBounds(double x, double y)
    {
        double min_x = m_UpperLeftX + m_Size / 2;
        double max_x = m_LowerRightX - m_Size / 2;
        double min_y = m_LowerRightY + m_Size / 2;
        double max_y = m_UpperLeftY - m_Size / 2;
 
        return ((x <= max_x) && (x >= min_x) && (y <= max_y) && (y >= min_y));
    }
 
    void
    HeightManager::UpdateCornerCoords()
    {
        GDALAllRegister();
 
        GDALDataset* dataset =
            (GDALDataset*)GDALOpen(m_CachedTifName, GA_ReadOnly);
        if (dataset == NULL) {
            std::cerr << "Failed to open file" << std::endl;
        }
 
        GDALRasterBand* band = dataset->GetRasterBand(1);
        if (band == NULL) {
            std::cerr << "Failed to get raster band" << std::endl;
        }
 
        double geoTransform[6];
        dataset->GetGeoTransform(geoTransform);
 
        m_UpperLeftX = geoTransform[0];
        m_UpperLeftY = geoTransform[3];
        m_LowerRightX =
            m_UpperLeftX + geoTransform[1] * dataset->GetRasterXSize();
        m_LowerRightY =
            m_UpperLeftY + geoTransform[5] * dataset->GetRasterXSize();
 
        GDALClose(dataset);
    }
 
} // namespace HeightManagement