Flight.cc

Go to the documentation of this file.

/*
 * Flight.cpp
 *
 *  Created on: Apr 24, 2015
 *      Author: leven
 */

#include "Flight.h"
#include "Interpolator3D.h"
#include "Ads_bEvent.h"
#include "Airplane.h"
#include "AirplaneUtil.h"
#include "Ads_bDataBase.h"

#include "utl/UTCDateTime.h"
//uncomment for debugging
//#include "utl/ErrorLogger.h"

#include "boost/lexical_cast.hpp"

using namespace RdAirplane;
using namespace std;
using namespace utl;
using namespace RdAirplane::Util;

const TimeInterval& Flight::MaxAllowedTimeBetweenADS_BEventsForInterpolation() {
  static TimeInterval interval(15*s);
  return interval;
}

Flight::Flight(Airplane* pAirplane) :
   _id_(""),
  _airplane_(pAirplane),
  _earliestEvent_(NULL),
  _latestEvent_(NULL),
  _offset_(NULL) {}

void Flight::Init() {
  _earliestEvent_ = getEarliestAds_bEvent();
  _latestEvent_ = getLatestAds_bEvent();
  _setId();
  _interpolateAds_bEvents(Ads_bEvent::eManuallyCorrectedPressureAltitude);
  _interpolateAds_bEvents(Ads_bEvent::ePressureAltitude);
  _interpolateAds_bEvents(Ads_bEvent::eGDASCorrectedPressureAltitude);
  _interpolateAds_bEvents(Ads_bEvent::eGPSAltitude);
}

const Ads_bEvent* Flight::getEarliestAds_bEvent() const {
  if(_ads_bEventsAll_.empty())
    return NULL;
  return *_ads_bEventsAll_.begin();
}

const Ads_bEvent* Flight::getLatestAds_bEvent() const {
  if(_ads_bEventsAll_.empty())
    return NULL;
  return *_ads_bEventsAll_.rbegin();
}

void Flight::_interpolateAds_bEvents(Ads_bEvent::AltitudeType pAltitudeType) {
  CoordinateSystemPtr coordinateSystem = getAirplane().getAdsBDataBase().getCoordinateSystem();
  Ads_bEventSet& ads_bEvents = _getAdsbEvents(pAltitudeType);
  vector<const TimeStamp*> timesForInterpolation;
  vector<const UTMPoint*> coordForInterpolation;
  for(Ads_bEventSet::iterator iter = ads_bEvents.begin(); iter != ads_bEvents.end(); ++iter) {
    Ads_bEvent* event = *iter;
    const UTMPoint& eventCoordinates = event->getCoordinates(pAltitudeType);
    const TimeStamp& time = event->getCaptureTime();
    if(!timesForInterpolation.empty() &&
       (time-*timesForInterpolation.back()>MaxAllowedTimeBetweenADS_BEventsForInterpolation() ||
        iter == --ads_bEvents.end())) {
      if(timesForInterpolation.size()>3) {
        // at least three points to make a second order polynomial fit and account for the curvature of the earth in a later version
        _getInterpolators(pAltitudeType).push_back(new Interpolator3D(timesForInterpolation, coordForInterpolation, this));
      }
      timesForInterpolation.clear();
      coordForInterpolation.clear();
    }
    timesForInterpolation.push_back(&time);
    coordForInterpolation.push_back(&eventCoordinates);
  }
}



Flight::Ads_bEventSet& Flight::_getAdsbEvents(Ads_bEvent::AltitudeType pAltitudeType) const {
  // object does not change, so this is okay
  Flight* this_noConst = const_cast<Flight*>(this);
  switch(pAltitudeType) {
    case Ads_bEvent::ePressureAltitude:
    case Ads_bEvent::eManuallyCorrectedPressureAltitude:
      return this_noConst->_ads_bEventsPressureAltitude_;
    case Ads_bEvent::eGDASCorrectedPressureAltitude:
      return this_noConst->_ads_bEventsCorrectedPressureAltitude_;
    case Ads_bEvent::eGPSAltitude:
      return this_noConst->_ads_bEventsGPSAltitude_;
    default:
      throw runtime_error("Encountered an unknown altitude type.");
  };
  return this_noConst->_ads_bEventsPressureAltitude_;
}

Flight::InterpolatorList& Flight::_getInterpolators(Ads_bEvent::AltitudeType pAltitudeType) const {
  // object does not change, so this is okay
  Flight* this_noConst = const_cast<Flight*>(this);
  switch(pAltitudeType) {
    case Ads_bEvent::ePressureAltitude:
      return this_noConst->_interpolatorsPressureAltitude_;
    case Ads_bEvent::eGDASCorrectedPressureAltitude:
      return this_noConst->_interpolatorsGDASCorrectedPressureAltitude_;
    case Ads_bEvent::eManuallyCorrectedPressureAltitude:
          return this_noConst->_interpolatorsManuallyCorrectedPressureAltitude_;
    case Ads_bEvent::eGPSAltitude:
      return this_noConst->_interpolatorsGPSAltitude_;
    default:
      throw runtime_error("Encountered an unknown altitude type.");
  };
  return this_noConst->_interpolatorsPressureAltitude_;
}

const Flight::Ads_bEventSet& Flight::getAdsbEvents(Ads_bEvent::AltitudeType pAltitudeType) const {
  return _getAdsbEvents(pAltitudeType);
}

const Flight::Ads_bEventSet& Flight::getAdsbEvents() const {
  return _ads_bEventsAll_;
}

void Flight::_setId() {
  UTCDateTime time(_earliestEvent_->getCaptureTime());
  string year = boost::lexical_cast<string>(time.GetYear());
  char month_c[3];
  sprintf(month_c, "%02d", time.GetMonth());
  char day_c[3];
  sprintf(day_c, "%02d", time.GetDay());
  char hour_c[3];
  sprintf(hour_c, "%02d", time.GetHour());
  char minute_c[3];
  sprintf(minute_c, "%02d", time.GetMinute());
  string timeIdendifier = year+month_c+day_c+hour_c+minute_c;
  _id_=_airplane_->getId()+"_"+timeIdendifier;
}

Ads_bEvent* Flight::addAds_bEvent(const TimeStamp& pCaptureTime, const UTMPoint& pCoordinates, const string& pAds_bMessageAsHex) {
  cout.flush();
  if(_ads_bEventsAll_.empty()) {
    _offset_=getAirplane().getAdsBDataBase().getAirplaneOffset(getAirplane(), pCaptureTime);
  }
   cout.flush();
  Ads_bEvent* event = new Ads_bEvent(pCaptureTime, pCoordinates, pAds_bMessageAsHex, this);
  if(event->ShouldBeFilteredOut()) {
    delete event;
    return NULL;
  }
  _ads_bEventsAll_.insert(event);
  switch(event->getAltitudeType()) {
    case Ads_bEvent::eGPSAltitude:
      _getAdsbEvents(Ads_bEvent::eGPSAltitude).insert(event);
      break;
    case Ads_bEvent::eGDASCorrectedPressureAltitude:
        _getAdsbEvents(Ads_bEvent::eGDASCorrectedPressureAltitude).insert(event);
        _getAdsbEvents(Ads_bEvent::ePressureAltitude).insert(event);
        break;
    case Ads_bEvent::ePressureAltitude:
        _getAdsbEvents(Ads_bEvent::ePressureAltitude).insert(event);
        break;
    default:
      throw runtime_error("Encountered an unknown altitude type.");
      break;
  }
  return event;
}

Flight::~Flight() {
  deleteAllPointersInContainer(_ads_bEventsAll_);
  deleteAllPointersInContainer(_interpolatorsPressureAltitude_);
  deleteAllPointersInContainer(_interpolatorsManuallyCorrectedPressureAltitude_);
  deleteAllPointersInContainer(_interpolatorsGDASCorrectedPressureAltitude_);
  deleteAllPointersInContainer(_interpolatorsGPSAltitude_);
}

bool Flight::isTimeDuringFlight(const utl::TimeStamp& pTime) const {
  return pTime > _earliestEvent_->getCaptureTime() && pTime <_latestEvent_->getCaptureTime();
}

Point* Flight::getPosition(const TimeStamp& pTime, Ads_bEvent::AltitudeType pAltitudeType) const {
  static Point* point;
  if(!isTimeDuringFlight(pTime))
    return NULL;
  const InterpolatorList& interpolators = _getInterpolators(pAltitudeType);
  for(InterpolatorList::const_iterator iter = interpolators.begin(); iter!=interpolators.end(); ++iter) {
    if((*iter)->isTimeInInterpolatedRange(pTime)) {
      delete point;
      point = new Point((*iter)->getCoordinates(pTime));
      return point;
    }
  }
  return NULL;
}

Point* Flight::getPosition(const TimeStamp& pTime) const {
  Point* res = getPosition(pTime, Ads_bEvent::eGPSAltitude);
  if(res==NULL)
     res = getPosition(pTime, Ads_bEvent::eManuallyCorrectedPressureAltitude);
  if(res==NULL)
    res = getPosition(pTime, Ads_bEvent::eGDASCorrectedPressureAltitude);
  if(res==NULL)
    res = getPosition(pTime, Ads_bEvent::ePressureAltitude);
  return res;
}

Vector* Flight::getSpeed(const TimeStamp& pTime, Ads_bEvent::AltitudeType pAltitudeType) const {
  static Vector* speed;
  if(!isTimeDuringFlight(pTime))
    return NULL;
  const InterpolatorList& interpolators = _getInterpolators(pAltitudeType);
  for(InterpolatorList::const_iterator iter = interpolators.begin(); iter!=interpolators.end(); ++iter) {
    if((*iter)->isTimeInInterpolatedRange(pTime)) {
      delete speed;
      speed = new Vector((*iter)->getDerivative(pTime));
      return speed;
    }
  }
  return NULL;
}

Vector* Flight::getSpeed(const TimeStamp& pTime) const {
  Vector* res = getSpeed(pTime, Ads_bEvent::eGPSAltitude);
  if(res==NULL)
    res = getSpeed(pTime, Ads_bEvent::eManuallyCorrectedPressureAltitude);
  if(res==NULL)
    res = getSpeed(pTime, Ads_bEvent::eGDASCorrectedPressureAltitude);
  if(res==NULL)
    res = getSpeed(pTime, Ads_bEvent::ePressureAltitude);
  return res;
}

string Flight::getInfo() const {
  ostringstream info;
  info << "\t Flight Id: " << getId() << endl
       << "\t\t first seen: " << UTCDateTime(_earliestEvent_->getCaptureTime()).GetInAugerFormat() << endl
       << "\t\t last seen: " << UTCDateTime(_latestEvent_->getCaptureTime()).GetInAugerFormat() << endl;
  info << "\t\t pressure altitude interpolated:" << endl;
  InterpolatorList& interpolators = _getInterpolators(Ads_bEvent::ePressureAltitude);
  for(InterpolatorList::const_iterator iter = interpolators.begin(); iter != interpolators.end(); ++iter) {
    info << "\t\t\t" << (*iter)->getInformation() << endl;
  }
  info << "\t\t corrected pressure altitude interpolated:" << endl;
  interpolators = _getInterpolators(Ads_bEvent::eGDASCorrectedPressureAltitude);
  for(InterpolatorList::const_iterator iter = interpolators.begin(); iter != interpolators.end(); ++iter) {
    info << "\t\t\t" << (*iter)->getInformation() << endl;
  }
  info << "\t\t GPS altitude interpolated:" << endl;
  interpolators = _getInterpolators(Ads_bEvent::eGPSAltitude);
  for(InterpolatorList::const_iterator iter = interpolators.begin(); iter != interpolators.end(); ++iter) {
    info << "\t\t\t" << (*iter)->getInformation() << endl;
  }
  return info.str();
}