gps_pvt 0.6.2 → 0.7.0

data/ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx

@@ -3002,7 +3002,6 @@ struct MatrixUtil {
       }
       static VALUE read(
           const VALUE &v, const unsigned int &row = 0, const unsigned int &column = 0) {
-        int state;
         VALUE values[3] = {v, UINT2NUM(row), UINT2NUM(column)};
         return funcall_throw_if_error(run, reinterpret_cast<VALUE>(values));
       }
@@ -3355,7 +3354,7 @@ SWIGINTERN std::string Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc
         static const ID with_index[] = {
             rb_intern("map_with_index"), rb_intern("map_with_index!"), 
             rb_intern("collect_with_index"), rb_intern("collect_with_index!")};
-        for(int i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
+        for(std::size_t i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
           if(id_callee == with_index[i]){
             return matrix_yield_get_with_index;
           }
@@ -3829,7 +3828,7 @@ SWIGINTERN std::string Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_S
         static const ID with_index[] = {
             rb_intern("map_with_index"), rb_intern("map_with_index!"), 
             rb_intern("collect_with_index"), rb_intern("collect_with_index!")};
-        for(int i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
+        for(std::size_t i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
           if(id_callee == with_index[i]){
             return matrix_yield_get_with_index;
           }

data/ext/ninja-scan-light/tool/algorithm/interpolate.h

@@ -34,6 +34,9 @@
 
 #include <cstddef>
 #include <vector>
+#include <map>
+#include <algorithm>
+#include <stdexcept>
 
 /*
  * perform Neville's interpolation (with derivative)
@@ -118,4 +121,107 @@ Ty interpolate_Neville(
   return interpolate_Neville(x_given, y_given, x, y_buf, n)[0];
 }
 
+template <class Tx, class Ty, class Tx_delta = Tx>
+struct InterpolatableSet {
+  struct condition_t {
+    std::size_t max_x_size; ///< maximum number of data used for interpolation
+    Tx_delta max_dx_range; ///< maximum acceptable absolute difference between x and x0
+  };
+
+  typedef typename std::vector<std::pair<Tx, Ty> > buffer_t;
+  buffer_t buf;
+  Tx x0, x_lower, x_upper;
+  std::vector<Tx_delta> dx;
+  bool ready;
+
+  InterpolatableSet() : x0(), dx(), ready(false) {}
+
+  /**
+   * update interpolation source
+   * @param force_update If true, update is forcibly performed irrespective of current state
+   * @param cnd condition for source data selection
+   */
+  InterpolatableSet &update(
+      const Tx &x, const std::map<Tx, Ty> &xy_table,
+      const condition_t &cnd,
+      const bool &force_update = false){
+
+    do{
+      if(force_update){break;}
+      if(dx.size() <= 2){break;}
+      if(x < x_lower){break;}
+      if(x > x_upper){break;}
+      return *this;
+    }while(false);
+
+    // If the 1st and 2nd nearest items are changed, then recalculate interpolation targets.
+    struct {
+      const Tx &x_base;
+      bool operator()(
+          const typename std::map<Tx, Ty>::value_type &rhs,
+          const typename std::map<Tx, Ty>::value_type &lhs) const {
+        return std::abs(rhs.first - x_base) < std::abs(lhs.first - x_base);
+      }
+    } cmp = {(x0 = x)};
+
+    buf.resize(cnd.max_x_size);
+    dx.clear();
+    // extract x where x0-dx_range <= x <= x0+dx_range, then sort by ascending order of |x-x0|
+    for(typename buffer_t::const_iterator
+          it(buf.begin()),
+          it_end(std::partial_sort_copy(
+            xy_table.lower_bound(x - cnd.max_dx_range),
+            xy_table.upper_bound(x + cnd.max_dx_range),
+            buf.begin(), buf.end(), cmp));
+        it != it_end; ++it){
+      dx.push_back(it->first - x0);
+    }
+    if(dx.size() >= 2){ // calculate a necessary condition to update samples for new x
+      // According to Nth nearest points, x range in which the order of extracted samples
+      // is retained can be calculated.
+      bool ascending(buf[0].first <= buf[1].first);
+      Tx &xa(ascending ? x_lower : x_upper), &xb(ascending ? x_upper : x_lower);
+      xa = x0;
+      for(std::size_t i(2); i < buf.size(); ++i){
+        if(ascending ? (dx[1] <= dx[i]) : (dx[1] >= dx[i])){continue;}
+        xa = x0 + (dx[1] + dx[i]) / 2;
+        break;
+      }
+      xb = x0 + (dx[0] + dx[1]) / 2;
+    }
+    ready = (dx.size() >= cnd.max_x_size);
+
+    return *this;
+  }
+
+  template <class Ty2, class Ty2_Iterator>
+  Ty2 interpolate2(
+      const Tx &x, const Ty2_Iterator &y,
+      Ty2 *derivative = NULL) const {
+    int order(dx.size() - 1);
+    do{
+      if(order > 0){break;}
+      if((order == 0) && (!derivative)){return y[0];}
+      throw std::range_error("Insufficient records for interpolation");
+    }while(false);
+    std::vector<Ty2> y_buf(order), dy_buf(order);
+    interpolate_Neville(
+        dx, y, x - x0, y_buf, order,
+        &dy_buf, derivative ? 1 : 0);
+    if(derivative){*derivative = dy_buf[0];}
+    return y_buf[0];
+  }
+
+  Ty interpolate(const Tx &x, Ty *derivative = NULL) const {
+    struct second_iterator : public buffer_t::const_iterator {
+      second_iterator(const typename buffer_t::const_iterator &it)
+          : buffer_t::const_iterator(it) {}
+      const Ty &operator[](const int &n) const {
+        return buffer_t::const_iterator::operator[](n).second;
+      }
+    } y_it(buf.begin());
+    return interpolate2(x, y_it, derivative);
+  }
+};
+
 #endif /* __INTERPOLATE_H__ */

data/ext/ninja-scan-light/tool/navigation/ANTEX.h

@@ -604,7 +604,7 @@ class ANTEX_Reader {
       typedef typename ANTEX_Product<FloatT>::antenna_t antenna_t;
       antenna_t *antenna;
       typedef typename ANTEX_Product<FloatT>::per_freq_t per_freq_t;
-      per_freq_t *per_freq;
+      per_freq_t *per_freq(NULL); // NULL fot suppression of GCC uninitialized variable warning
 
       while(src.has_next()){
         parsed_t parsed(src.parse_line());

data/ext/ninja-scan-light/tool/navigation/GLONASS_Solver.h

@@ -133,7 +133,7 @@ class GLONASS_SinglePositioning : public SolverBaseT {
           }
         };
         satellite_t res = {
-            &(it_sat->second),
+            &(it_sat->second), &(it_sat->second),
             impl_t::position, impl_t::velocity,
             impl_t::clock_error, impl_t::clock_error_dot};
         return res;

data/ext/ninja-scan-light/tool/navigation/GPS_Solver.h

@@ -157,7 +157,7 @@ class GPS_SinglePositioning : public SolverBaseT {
           }
         };
         satellite_t res = {
-            &(it_sat->second),
+            &(it_sat->second), &(it_sat->second),
             impl_t::position, impl_t::velocity,
             impl_t::clock_error, impl_t::clock_error_dot};
         return res;

data/ext/ninja-scan-light/tool/navigation/GPS_Solver_Base.h

@@ -227,13 +227,13 @@ struct GPS_Solver_Base {
   }
 
   struct satellite_t {
-    const void *impl;
+    const void *impl_xyz, *impl_t; ///< pointer to actual implementation to return position and clock error
     xyz_t (*impl_position)(const void *, const gps_time_t &, const float_t &);
     xyz_t (*impl_velocity)(const void *, const gps_time_t &, const float_t &);
     float_t (*impl_clock_error)(const void *, const gps_time_t &);
     float_t (*impl_clock_error_dot)(const void *, const gps_time_t &);
     inline bool is_available() const {
-      return impl != NULL;
+      return (impl_xyz != NULL) && (impl_t != NULL);
     }
     /**
      * Return satellite position at the transmission time in EFEC.
@@ -244,28 +244,28 @@ struct GPS_Solver_Base {
      * that is, the transmission time added by the transit time.
      */
     inline xyz_t position(const gps_time_t &t_tx, const float_t &dt_transit = 0) const {
-      return impl_position(impl, t_tx, dt_transit);
+      return impl_position(impl_xyz, t_tx, dt_transit);
     }
     /**
      * Return satellite velocity at the transmission time in EFEC.
      * @see position
      */
     inline xyz_t velocity(const gps_time_t &t_tx, const float_t &dt_transit = 0) const {
-      return impl_velocity(impl, t_tx, dt_transit);
+      return impl_velocity(impl_xyz, t_tx, dt_transit);
     }
     /**
      * Return satellite clock error [s] at the transmission time.
      * @param t_tx transmission time
      */
     inline float_t clock_error(const gps_time_t &t_tx) const {
-      return impl_clock_error(impl, t_tx);
+      return impl_clock_error(impl_t, t_tx);
     }
     /**
      * Return satellite clock error derivative [s/s] at the transmission time.
      * @param t_tx transmission time
      */
     inline float_t clock_error_dot(const gps_time_t &t_tx) const {
-      return impl_clock_error_dot(impl, t_tx);
+      return impl_clock_error_dot(impl_t, t_tx);
     }
     static const satellite_t &unavailable() {
       struct impl_t {
@@ -276,7 +276,7 @@ struct GPS_Solver_Base {
           return float_t(0);
         }
       };
-      static const satellite_t res = {NULL, impl_t::v3, impl_t::v3, impl_t::v, impl_t::v};
+      static const satellite_t res = {NULL, NULL, impl_t::v3, impl_t::v3, impl_t::v, impl_t::v};
       return res;
     }
   };

data/ext/ninja-scan-light/tool/navigation/MagneticField.h

@@ -143,16 +143,17 @@ class MagneticFieldGeneric {
       field_components_res_t res;
       
       // @see http://mooring.ucsd.edu/software/matlab/mfiles/toolbox/geo/IGRF/geomag60.c
+      // @see https://web.archive.org/web/20171008182325/http://mooring.ucsd.edu/software/matlab/mfiles/toolbox/geo/IGRF/geomag60.c
 
-      const FloatT slat(sin_geocentric_latitude);
-      const FloatT clat(cos_geocentric_latitude);
+      const FloatT &slat(sin_geocentric_latitude);
+      const FloatT &clat(cos_geocentric_latitude);
 
       FloatT sl[13] = {sin(longitude_rad)};
       FloatT cl[13] = {cos(longitude_rad)};
       
       res.north = res.east = res.down = 0;
       
-      FloatT aa, bb, cc, rr;
+      FloatT aa, bb, cc, rr(0); // rr(0) for suppression of warning of use of uninitialized variable
       
       aa = sqrt(3.0);
       FloatT p[118] = {

data/ext/ninja-scan-light/tool/navigation/NTCM.h

@@ -66,7 +66,7 @@ class NTCM_GL_Generic {
       return cos_Chi_star3
           + (C[0] * std::cos(v_D)
             + C[1] * std::cos(v_SD) + C[2] * std::sin(v_SD)
-            + C[3] * std::cos(v_TD) + C[4] * std::sin(v_TD)) * cos_Chi_star;
+            + C[3] * std::cos(v_TD) + C[4] * std::sin(v_TD)) * cos_Chi_star2;
     }
 
     static const float_t doy_A, doy_SA;

data/ext/ninja-scan-light/tool/navigation/RINEX.h

@@ -76,6 +76,7 @@ class RINEX_Reader {
         FTYPE_OBSERVATION,
         FTYPE_NAVIGATION,
         FTYPE_METEOROLOGICAL,
+        FTYPE_CLOCK,
       } file_type;
       enum sat_system_t {
         SYS_UNKNOWN = 0,
@@ -89,6 +90,19 @@ class RINEX_Reader {
         SYS_TRANSIT,
         SYS_MIXED,
       } sat_system;
+      static sat_system_t char2sys_v3(const char &c){
+        switch(c){
+          case 'G': return SYS_GPS;
+          case 'R': return SYS_GLONASS;
+          case 'E': return SYS_GALILEO;
+          case 'J': return SYS_QZSS;
+          case 'C': return SYS_BDS;
+          case 'I': return SYS_IRNSS;
+          case 'S': return SYS_SBAS;
+          case 'M': return SYS_MIXED;
+        }
+        return SYS_UNKNOWN;
+      }
       version_type_t(
           const int &ver = 0, const file_type_t &ftype = FTYPE_UNKNOWN, const sat_system_t &sys = SYS_UNKNOWN)
           : version(ver), file_type(ftype), sat_system(sys) {}
@@ -105,7 +119,7 @@ class RINEX_Reader {
         : src(in), _has_next(false),
         version_type() {
       if(src.fail()){return;}
-      
+
       char buf[256];
       
       // Read header
@@ -135,7 +149,13 @@ class RINEX_Reader {
         version_type.parse(it->second.front());
         break;
       }
-
+    }
+    RINEX_Reader(
+        std::istream &in,
+        void (RINEX_Reader::*read_header)())
+        : src(in), _has_next(false),
+        version_type() {
+      (this->*read_header)();
     }
     virtual ~RINEX_Reader(){_header.clear();}
     header_t &header() {return _header;}
@@ -235,6 +255,7 @@ void RINEX_Reader<U>::version_type_t::parse(const std::string &buf){
         case 'H': file_type = FTYPE_NAVIGATION;
           sat_system = SYS_SBAS; // TODO: Is geostational as SBAS?
           break;
+        case 'C': file_type = FTYPE_CLOCK; break;
       }
       break;
     case 3:
@@ -242,18 +263,12 @@ void RINEX_Reader<U>::version_type_t::parse(const std::string &buf){
         case 'O': file_type = FTYPE_OBSERVATION;    break;
         case 'N': file_type = FTYPE_NAVIGATION;     break;
         case 'M': file_type = FTYPE_METEOROLOGICAL; break;
+        case 'C': file_type = FTYPE_CLOCK;          break;
       }
-      if((file_type == FTYPE_OBSERVATION) || (file_type == FTYPE_NAVIGATION)){
-        switch(buf[40]){
-          case 'G': sat_system = SYS_GPS;     break;
-          case 'R': sat_system = SYS_GLONASS; break;
-          case 'E': sat_system = SYS_GALILEO; break;
-          case 'J': sat_system = SYS_QZSS;    break;
-          case 'C': sat_system = SYS_BDS;     break;
-          case 'I': sat_system = SYS_IRNSS;   break;
-          case 'S': sat_system = SYS_SBAS;    break;
-          case 'M': sat_system = SYS_MIXED;   break;
-        }
+      if((file_type == FTYPE_OBSERVATION)
+          || (file_type == FTYPE_NAVIGATION)
+          || (file_type == FTYPE_CLOCK)){
+        sat_system = char2sys_v3(buf[40]);
       }
       break;
   }
@@ -306,7 +321,7 @@ void RINEX_Reader<U>::version_type_t::dump(std::string &buf) const {
       switch(sat_system){
         case SYS_GPS:     sys_str = "G: GPS";     break;
         case SYS_GLONASS: sys_str = "R: GLONASS"; break;
-        case SYS_GALILEO: sys_str = "G: GALILEO"; break;
+        case SYS_GALILEO: sys_str = "E: GALILEO"; break;
         case SYS_QZSS:    sys_str = "Q: QZSS";    break;
         case SYS_BDS:     sys_str = "B: BDS";     break;
         case SYS_IRNSS:   sys_str = "I: IRNSS";   break;