DtGeocentricGridLinesDrawer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <makArchives/DtGridLinesSettingsRecord.h>
#include <vrvOsg/DtGridLinesDrawer.h>
#include <vrvUtil/DtUnicode.h>

#include <matrix/vlVector.h>
#include <matrix/coordTransform.h>
#include <matrix/referenceEllipsoid.h>

#include <boost/shared_ptr.hpp>
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>

#include <osg/Vec3>

namespace makVrv
{

   class DtDe;
   class DtOsgChannel;
   class DtLineSegment;
   class DtTextProxy;
   class DtBoundingBox;
   enum class DtGarsPrecision;

   class DT_DLL_VRVOSG DtGeocentricGridLinesDrawer
      : public DtGridLinesDrawer
   {
   public:

      DtGeocentricGridLinesDrawer( DtDe& de );

      virtual ~DtGeocentricGridLinesDrawer();

      virtual void drawGridLines();

      virtual void drawPolarGridLines();

      virtual void drawMidLatitudeGridLines();


      virtual void setScale( double scale );

      virtual void setObserverPosition( const DtVector& position );

      virtual void setChannelDimensions( int startChannelX, int startChannelY,
         int endChannelX, int endChannelY );

      virtual void setLatLonLabelsCenteringCutoff(double alt);

      virtual void setGarsPolarLatitudeCutoff(double lat);

   protected:

      virtual void reloadTextFonts();

      virtual void reloadLabelFonts(std::vector<DtTextProxy*>& labels);

      virtual void setupReferenceEllipsoid();

      virtual void setupTopoGeocTransforms();

      virtual bool pointVisible( const DtVector& point ) const;

      virtual void findPolarSpacing();

      virtual void drawPolarLongitudeLines();

      virtual void drawPolarLatitudeLines();

      virtual void findLatLonWindowDimensions();

      virtual void findSpacing();

      virtual void anchorAndOffsetLines();

      virtual void drawLongitudeLines();

      virtual void drawLatitudeLines();

      virtual void createLabel( DtTextProxy*& label, double radians, bool isLongitude, double* endpoints);

      virtual void destroyGridLines();

      virtual bool clip3D( const DtVector& pointA, const DtVector& pointB,
         DtVector& clippedA, DtVector& clippedB ) const;

      // A Grid line is a vector of line segments that form the (notionally)
      // curved line

      // A Grid Line is an array of line segments
      typedef std::vector<DtLineSegment*> GridLine;

      // A Grid Line Vector is an array or Grid Lines
      typedef std::vector<GridLine> GridLineVector;
      typedef std::vector<DtTextProxy*> LabelArray;

      virtual void clearUnusedLinesAndLabels(int index, GridLineVector& lines,
         LabelArray& labels);

      virtual void clearUnusedSegments( int index, GridLine& line );

      virtual void destroyLinesAndLabels( GridLineVector& lines,
         LabelArray& labels );

      virtual void resizeLinesAndLabels( GridLineVector& lines, LabelArray& labels,
          int numLines );
 
      virtual bool drawLineSegment( DtLineSegment*& segment, const DtVector& start,
         const DtVector& end, float* colorArray, double* endpoints=0, bool* pass3D = 0);

      virtual GridLine& getSegmentedLine( GridLineVector& lines, int index, int numSegments );



      virtual bool drawStandardLongitudeLine(GridLine& lonLine, double resolution, int numSegs, double curLon, int& curSeg, double*endpoints);

      virtual bool drawNorwayMgrsLongitudeLine(GridLine& lonLine, double resolution, int numSegs, int& curSeg);

      virtual bool drawSvalbardMgrsLongitudeLines(GridLine& lonLine, double resolution, int numSegs, double curLon, int& curSeg);


      virtual void drawMapSheetLines();

      virtual void findMapSheetSpacing();

      virtual bool anchorMapSheetLines();

      virtual void clearUnusedLines(int index, GridLineVector& lines);

      virtual void clearUnusedLabels(int index, LabelArray& labels);

      struct MgrsSegStart
      {
         double lat;
         double lon;
      };
      typedef std::vector<MgrsSegStart> SegmentStarts;
      typedef std::vector<SegmentStarts> SegmentLocator;

      virtual SegmentStarts& getSegmentedLocator(SegmentLocator& lines, int index, int numSegments);

      virtual void resizeLocators(SegmentLocator& locator, int numLines);

      virtual void clearUnusedLocators(int index, SegmentLocator& locator);

      virtual bool drawUtmLineSegment(GridLine& line, SegmentStarts& lineLocator, int segIndex, int zone, char hemisphere, 
         double startEasting, double startNorthing, double endEasting, double endNorthing, bool constrainEasting=false);

      virtual void findEastingLimits(double lat, double& minEasting, double& maxEasting);


      virtual void drawEastWestMapSheetLines();

      // \brief Draw the portion of an northing (east-west) line that lies in the specified utm zone
      virtual int drawEastWestMapSheetLineForUtmZone(GridLine& eastWestLine, SegmentStarts& lineLocator, int startSeg, int zone, 
         char hemisphere, double northingLine, int zoneMapSheets, int numSegs, int numPartialSegs, double partialExtra);

      // \brief Draw the interior portion of a northing line that lies in a specified utm zone
      virtual int drawEastWestZoneInterior(GridLine& eastWestLine, SegmentStarts& lineLocator, int startSeg, int utmZone, 
         char hemisphere, double northingLine, int numSegs, int startEasting, int endEasting);


      virtual void drawNorthSouthMapSheetLines();

      virtual int drawNorthSouthMapSheetLinesForUtmZone(int zone, double maxZoneWidth, int iLine);

      virtual bool drawNorthSouthMapSheetLine(int utmZone, double eastingLine, int iLine);


      virtual bool getGzdAndMapSheet(const DtVector& geocLoc, DtUnicode& gzd, DtUnicode& gzdAndMapSheet);

      virtual void labelGridZones();

      virtual bool labelGarsGrid(double lonValue, double latValue, DtGarsPrecision precision, int labelIndex);
      
      virtual void labelGarsGrids();

      virtual bool labelGridZoneDesignator(double lonValue, double latValue, int labelIndex);

      virtual bool includeMgrsDesignator(double lonValue, double latValue, osg::Vec3& screenPos,  DtVector& geocResult);

      virtual bool includeMgrsDesignator(double lonValue, double latValue, float screenPosX,
         float screenPosY, DtVector& geocResult);

      virtual void createGridLineLabel(DtTextProxy*& label, double lat, double lon, float screenPosX, float screenPosY,
         bool isEasting);

      virtual void labelMapSheetLines();

      virtual bool createMapSheetLabel(DtTextProxy*& label, double lat, double lon, float screenPosX, float screenPosY);

      virtual DtFont::TextAlignment offsetGridBoxLabel(double xSrc, double ySrc, double& xOffset, double& yOffset, 
         DtBoundingBox& bbox) const;


   private:

      DtGeocentricGridLinesDrawer(const DtGeocentricGridLinesDrawer& orig);

      DtGeocentricGridLinesDrawer& operator=(const DtGeocentricGridLinesDrawer& rhs);

   protected:

      GridLineVector myLongitudeLines;
      GridLineVector myLatitudeLines;

      LabelArray myLongitudeLabels;
      LabelArray myLatitudeLabels;

      double myLatSpacing; // In Radians
      double myLonSpacing;
      double myScale;
      unsigned int myMinChannelDimension; // the smaller of the actual channel width and channel height
      unsigned int myChannelSize;
      DtVector myObserverPosition;
      double myObserverLatitude;
      double myObserverLongitude;
      double myObserverAltitude;
      int myChannelExpansionX;
      int myChannelExpansionY;

      // This is the normal of the plane facing the observer through the
      // center of the earth.  Used for all 3D clipping.
      DtVector myClipNormal;

      double myStartLat;
      double myEndLat;
      double myStartLon;
      double myEndLon;
      DtCoordTransform myGeocToTopoTransform;
      DtCoordTransform myTopoToGeocTransform;
      DtReferenceEllipsoid myReferenceEllipsoid;
      double myAnchoredStartLat;
      double myAnchoredEndLat;
      double myAnchoredStartLon;
      double myAnchoredEndLon;
      bool myLatCrossesPole;

      // MGRS implementation-specific members
      typedef boost::unordered_set<DtUnicode> UsedGridLabels;
      UsedGridLabels myUsedGzdLabels;
      UsedGridLabels myUsedMapSheetLabels;

      LabelArray myGzdLabels;
      LabelArray myMapSheetLabels;
      LabelArray myGarsGridLabels;

      // The locator vectors mirror the GridLine Vectors, providing the lat/lon
      // for the start of each segment (used for labeling)
      GridLineVector myNorthSouthLines;
      SegmentLocator myNorthSouthSegmentLocator;

      GridLineVector myEastWestLines;
      SegmentLocator myEastWestSegmentLocator;
      LabelArray myNorthSouthLabels;  
      LabelArray myEastWestLabels;

      int myMapSheetSpacing; // 100,000, 10,000, 1,000, 100, 10, or 1m (or 0 for none)

      double myAnchoredStartEasting;
      double myAnchoredStartNorthing;
      double myAnchoredEndEasting;
      double myAnchoredEndNorthing; 
      double myAnchoredStartUtmZone;
      double myAnchoredEndUtmZone;
      char myAnchoredStartNorthingHemisphere; // 'S' or 'N'
      char myAnchoredEndNorthingHemisphere; // 'S' or 'N'
      bool myGarsCanDraw;
   };
}