HFRadarModelPoint.h

Go to the documentation of this file.

#ifndef HFRADARMODELPOINT_H_
#define HFRADARMODELPOINT_H_

#include "component/Behavior.h"
#include "data/Mtx.h"
#include "utils/FlexArray.h"

class Location;
class LocationNode;
class UniversalDataReader;
class UniversalDataWriter;

class HFRadarModelPoint : public Behavior
{
public:
    HFRadarModelPoint( const Str& prefix, const Module* module );

    virtual ~HFRadarModelPoint();

    void initialize( void );

    bool isSatisfied();

    void run();

    bool runIfUnsatisfied();

    void uninitialize( void );

    static Behavior* CreateBehavior( const Str& prefix, const Module* module );

protected:

    double latitudeSetting_;

    double longitudeSetting_;

    float speedSetting_;

    double intermediateLatitude_;

    double intermediateLongitude_;

    // Intermediate lat/lon points
    FlexArray<Location*> subpoints_;

    // If true, need to calculate subpoints
    bool needSubpoints_;

    // If true, currently calculating subpoints
    bool calculatingSubpoints_;

    // If true, currently refining subpoints
    bool refiningSubpoints_;

    int fineLatSize_;
    float* fineLat_;
    int fineLonSize_;
    float* fineLon_;
    float*** fineU_;
    float*** fineV_;

    float bearing_;

    double finalPerpendicularSlope_;

    bool finalStartOverLine_;

    double intermediatePerpendicularSlope_;

    bool intermediateStartOverLine_;

    bool initialized_;

    double initTime_;

    int timeSize_;

    // Slate input setting variables

    SettingReader *distanceDeltaSettingReader_;

    SettingReader *distanceDeltaBearingSettingReader_;

    SettingReader *eastingsDeltaSettingReader_;

    // Desired waypoint latitude
    SettingReader *latitudeSettingReader_;

    // Desired waypoint latitude delta from the current latitude
    // If specified with latitude, the two are added together
    SettingReader *latitudeDeltaSettingReader_;

    // Desired waypoint longitude
    SettingReader *longitudeSettingReader_;

    // Desired waypoint latitude delta from the current latitude
    // If specified with latitude, the two are added together
    SettingReader *longitudeDeltaSettingReader_;

    SettingReader *northingsDeltaSettingReader_;

    SettingReader *speedSettingReader_;

    SettingReader *gridDivideSettingReader_;

    // Slate input measurements

    UniversalDataReader *latitudeReader_;

    UniversalDataReader *longitudeReader_;

    // Slate output variables

    // Sets the heading mode for HeadingControl
    DataWriter *horizontalModeWriter_;

    // Sets the waypoint latitude for HeadingControl
    DataWriter *latitudeCmdWriter_;

    // Sets the waypoint longitude for HeadingControl
    DataWriter *longitudeCmdWriter_;

    // Sets the bearing to the waypoint
    DataWriter *bearingCmdWriter_;

    // Variables related to path search algorithm

    Timestamp calcCompleteTime_;

    LocationNode* startNode_;

    LocationNode* goalNode_;

    FlexArray<FlexArray<LocationNode*>*> nodeMap_;

    FastMap<const float, LocationNode*> nodeQueue_;

    int minNodeCount_;

    float heuristic( LocationNode* node, const float& maxCurent );

    // Returns 32 pairs of adjoining edge offsets from a grid center
    // Can be subset at the first 8 or 16 offsets
    static const int EDGE_OFFSETS[32][2];

    void getAdjoining( const LocationNode* node, FlexArray<LocationNode*>& adjs,
                       int nLats, int nLons, float* lats, float* lons );

    // Returns the travel time from one node to another
    // Assumes that dScore of node equals arrival time at that node minus initTime_
    float travelTime( LocationNode* fromNode, LocationNode* toNode,
                      const double* time, int timeSize, float*** u, float*** v );

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    HFRadarModelPoint( const HFRadarModelPoint& old ); // disallow copy constructor

    void initCompletion( double startLatitude, double startLongitude );

    void calcCompletion( double startLatitude, double startLongitude,
                         double latitudeSetting, double longitudeSetting,
                         double& perpendicularSlope, bool& startOverLine );

    bool isComplete( double latitude, double longitude, double latitudeGoal,
                     double longitudeGoal, double perpendicularSlope,
                     bool startOverLine );

    void initNodes( const double& latitude, const double& longitude, int latSize,
                    int lonSize, float* lat, float* lon, const float& maxCurrent );

    // Allocates fine-grained data
    void makeFine( int timeSize, int latSize, int lonSize, float* lat,
                   float* lon, float*** u, float*** v );

    void clearFine();

};

#endif /*RATECALCULATOR_H_*/