quantized_mesh_tiler.h

// Copyright (c) 2018 Coronis Computing S.L. (Spain)
// All rights reserved.
//
// This file is part of EMODnet Quantized Mesh Generator for Cesium.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// Author: Ricard Campos (ricardcd@gmail.com)

#ifndef EMODNET_QMGC_QUANTIZED_MESH_TILER_H
#define EMODNET_QMGC_QUANTIZED_MESH_TILER_H

#include "quantized_mesh.h"
#include "quantized_mesh_tile.h"
#include "tin_creation/tin_creation_cgal_types.h"
#include <ctb.hpp>
#include <boost/filesystem.hpp>
#include "ellipsoid.h"
#include "tin_creation/tin_creator.h"
#include <mutex>
#include "borders_data.h"

namespace fs = boost::filesystem ;


class QuantizedMeshTiler : public ctb::TerrainTiler
{
    // --- Private Typedefs ---
    typedef TinCreation::Point_3 Point_3;
    typedef TinCreation::Vector_3 Vector_3;
    typedef TinCreation::Point_2 Point_2;
    typedef TinCreation::Polyhedron Polyhedron;

public:
    // --- Options struct ---
    struct QMTOptions {
        bool IsBathymetry = false ;                     
        Ellipsoid RefEllipsoid = WGS84Ellipsoid() ;     
        int HeighMapSamplingSteps = 256 ;               
        float ClippingHighValue = std::numeric_limits<float>::infinity() ; 
        float ClippingLowValue = -std::numeric_limits<float>::infinity() ; 
        float AboveSeaLevelScaleFactor = -1;    
        float BelowSeaLevelScaleFactor = -1;    
    };

    // --- Methods ---

    QuantizedMeshTiler(GDALDataset *dataset,
                       const ctb::Grid &grid,
                       const ctb::TilerOptions &tilerOptions,
                       const QMTOptions& options,
                       const TinCreation::TinCreator& tinCreator )
            : TerrainTiler(dataset, grid, tilerOptions)
            , m_options(options)
            , m_tinCreator(tinCreator)
            {checkOptions();}

    QuantizedMeshTiler(const QuantizedMeshTiler& tiler )
            : TerrainTiler(tiler.poDataset, tiler.mGrid, tiler.options)
            , m_options(tiler.m_options)
            , m_tinCreator(tiler.m_tinCreator)
    {}

    QuantizedMeshTile createTile(const ctb::TileCoordinate &coord, BordersData& bd) ;

    QMTOptions getOptions() { return m_options; }

    void setTinCreatorParamsForZoom(const unsigned int& zoom) { m_tinCreator.setParamsForZoom(zoom); }

    std::vector<Point_3> getUVHPointsFromRaster(const ctb::TileCoordinate &coord,
                                                BordersData& bd,
                                                float& minHeight, float& maxHeight,
                                                ctb::CRSBounds& tileBounds) const ;

private:
    // --- Attributes ---
    QMTOptions m_options;
    TinCreation::TinCreator m_tinCreator;
    mutable std::mutex m_mutex; // Mark mutex as mutable because it doesn't represent the object's real state
                                // Note that we don't need the mutex if we create multiple instances of tilers, as done in qm_tiler right now. We leave it here in case it is needed for other implementations

    // --- Private Functions ---
    void checkOptions() {
        if ( m_options.HeighMapSamplingSteps < 0 ) {
            std::cerr << "[WARNING] QuantizedMeshTiler::options HeighMapSamplingSteps < 0, defaulting to 256" << std::endl;
            m_options.HeighMapSamplingSteps = 256 ;
        }
        if ( m_options.HeighMapSamplingSteps > 256 ) {
            std::cerr << "[WARNING] QuantizedMeshTiler::options HeighMapSamplingSteps > 256 (maximum), defaulting to 256" << std::endl;
            m_options.HeighMapSamplingSteps = 256 ;
        }
    }

    float clip(const float& n, const float& lower, const float& upper) const {
        return std::max(lower, std::min(n, upper));
    }

    // --- The following private functions split the processing required to generate the tiles for better readability ---



    void computeQuantizedMeshHeader(QuantizedMeshTile& qmTile,
                                    const Polyhedron& surface,
                                    const float& minHeight, float& maxHeight,
                                    const ctb::CRSBounds& tileBounds) const ;


    void computeQuantizedMeshGeometry(QuantizedMeshTile& qmTile,
                                      Polyhedron& surface,
                                      const float& minHeight, const float& maxHeight,
                                      std::vector<Point_3> &tileEastVertices,
                                      std::vector<Point_3> &tileWestVertices,
                                      std::vector<Point_3> &tileNorthVertices,
                                      std::vector<Point_3> &tileSouthVertices ) const ;
};

#endif //EMODNET_QMGC_QUANTIZED_MESH_TILER_H