terrainUtil.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <osg/BoundingSphere>
#include <terrainInterface/terrainPagingGeometry.h>
#include <terrainInterface/terrainPagingChord.h>
#include <terrainInterface/terrainPagingSphere.h>
#include <terrainInterface/terrainPagingShape.h>

#include <terrainCS/geodeticCS.h>

#include <vector>
#include <osg/BoundingBox>
#include <osgEarth/Config>
#include <osgEarth/URI>
#include <osgEarth/GeoData>

class DtSphere;
class Coordinate_System;
class DtVrfChordIntersectionRecord;
class DtVrfChordIntersectRecordList;

DtSphere boundingSphere2DtSphere(const osg::BoundingSphere& boundingSphere);

DtExtent boundingBox2DtExtent(const osg::BoundingBoxd& boundingBox);


void convertGeometry(
   const DtTerrainPagingGeometryPtr& geometry, const Coordinate_System* CS, 
   const double worldWidth, std::vector<DtTerrainPagingGeometryPtr>& output);

void convertToOsgEarthCoordSys(DtPoint& p, CS_Type cstype);

void convertFromOsgEarthCoordSys(DtPoint& p, CS_Type cstype);

void convertFromOsgEarthCoordSys(DtVector& p, CS_Type cstype);

void convertFromOsgEarthCoordSys(DtVrfChordIntersectionRecord& record, CS_Type cstype);

void unwrap(double width, DtLocalVertexList& list, std::vector<DtTerrainPagingGeometryPtr>& output);


bool extentIntersectsAABB(
   const DtVector& min1 /*rhs sw*/, const DtVector& max1 /*rhs ne*/,
   const DtVector& min2 /*mysw*/, const DtVector& max2 /*myne*/);

bool boundariesOverlap(double min1, double max1, double min2, double max2);

DtExtent sphereExtent(const DtSphere& sphere);

bool shapeIntersectsAABB(
   const DtLocalVertexList& shape,
   const DtVector& lower, const DtVector& upper);

bool pointIntersectsAABB(
   const DtVector& p,
   const DtVector& lower, const DtVector& upper);

bool doubleEqual(double d1, double d2);

DtVrfChordIntersectionRecord* insertRecordAlongChord(
   const DtVrfChordIntersectionRecord& record,
   DtVrfChordIntersectRecordList& intList);

class DT_DLL_vantageTerrainImplementation IndexInputInterface
{
public:
   static std::unique_ptr<IndexInputInterface> Create(const DtFilename&);

   virtual ~IndexInputInterface();

   virtual bool read(unsigned& lod, unsigned& x, unsigned& y, double& min, double& max, bool& valid) = 0;
};

template <class T>
struct DT_DLL_vantageTerrainImplementation IndexConfig
{
   std::string name;
   osgEarth::URI file;
   bool isDefault;
   double minTolerance, maxTolerance;
   unsigned minlod, maxlod;
   osgEarth::GeoExtent extent;

   IndexConfig(
      const T& tracker,
      const osgEarth::Config& cfg)
      : name(cfg.value<std::string>("name", ""))
      , isDefault(false)
      , minTolerance(cfg.value<double>("min_tolerance", 0))
      , maxTolerance(cfg.value<double>("max_tolerance", 0))
      , minlod(cfg.value<unsigned>("min_lod", 0))
      , maxlod(cfg.value<unsigned>("max_lod", tracker.maxLOD()))
      , extent(tracker.profile()->getExtent())
   {
      double xmin = extent.xMin();
      double ymin = extent.yMin();
      double xmax = extent.xMax();
      double ymax = extent.yMax();

      if (tracker.localCS()->getCS_Type() == CS_DIS)
      {
         xmin = cfg.value<double>("min_lon", xmin);
         ymin = cfg.value<double>("min_lat", ymin);
         xmax = cfg.value<double>("max_lon", xmax);
         ymax = cfg.value<double>("max_lat", ymax);
      }
      else
      {
         xmin = cfg.value<double>("min_x", xmin);
         ymin = cfg.value<double>("min_y", ymin);
         xmax = cfg.value<double>("max_x", xmax);
         ymax = cfg.value<double>("max_y", ymax);
      }

      extent.set(xmin, ymin, xmax, ymax);
   }

   IndexConfig(
      const T& tracker)
      : isDefault(true)
      , minTolerance(0)
      , maxTolerance(0)
      , minlod(0)
      , maxlod(tracker.maxLOD())
      , extent(tracker.mapNode()->getMap()->getProfile()->getExtent())
   {
   }
};

struct MinMaxInfo
{
   double min, max;

   void update(const DtPoint& p)
   {
      double value = p.x();

      if (value > max)
      {
         max = value;
      }

      if (value < min)
      {
         min = value;
      }
   }

   bool wrapsAround(double width) const
   {
      return max - min > width / 2;
   }

   MinMaxInfo()
      : min(std::numeric_limits<double>::infinity())
      , max(-std::numeric_limits<double>::infinity())
   {
   }
};