terrainUtil.h

Go to the documentation of this file.

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



#pragma once

#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>

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

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


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);

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())
   {
   }
};