gps_pvt 0.6.3 → 0.7.1

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/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;
     }
   };
@@ -474,12 +474,7 @@ struct GPS_Solver_Base {
       using super_t::reset;
       void reset(const int &prn) {set(prn, false);}
       std::vector<int> excluded() const {
-        std::vector<int> res(super_t::indices_one());
-        for(std::vector<int>::iterator it(res.begin()), it_end(res.end());
-            it != it_end; ++it){
-          *it += prn_begin;
-        }
-        return res;
+        return super_t::indices_one(prn_begin);
       }
     };
   };

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

@@ -60,6 +60,12 @@ struct GPS_PVT_RAIM_LSR : public PVT_BaseT {
   } FDE_min, FDE_2nd; ///< Fault exclusion
 };
 
+template <class FloatT>
+struct GPS_Solver_RAIM_LSR_Options {
+  bool skip_exclusion;
+  GPS_Solver_RAIM_LSR_Options() : skip_exclusion(false) {}
+};
+
 /*
  * Comment on implementation of protection level (PL) calculation
  *
@@ -96,6 +102,27 @@ struct GPS_Solver_RAIM_LSR : public SolverBaseT {
   inheritate_type(measurement2_t);
 #undef inheritate_type
 
+  typedef typename GPS_Solver_Base<float_t>::options_t::template merge_t<
+      GPS_Solver_RAIM_LSR_Options<float_t>, super_t> options_t;
+
+protected:
+  GPS_Solver_RAIM_LSR_Options<float_t> _options;
+
+public:
+  options_t available_options() const {
+    return options_t(super_t::available_options(), _options);
+  }
+
+  options_t available_options(const options_t &opt_wish) const {
+    GPS_Solver_RAIM_LSR_Options<float_t> opt(opt_wish);
+    return options_t(super_t::available_options(opt_wish), opt);
+  }
+
+  options_t update_options(const options_t &opt_wish){
+    _options = opt_wish;
+    return options_t(super_t::update_options(opt_wish), _options);
+  }
+
   typedef GPS_PVT_RAIM_LSR<float_t, typename super_t::user_pvt_t> user_pvt_t;
 
   typename super_t::template solver_interface_t<self_t> solve() const {
@@ -155,7 +182,8 @@ protected:
         user_position_init, receiver_error_init,
         opt);
 
-    if(!pvt.position_solved()
+    if(_options.skip_exclusion
+        || !pvt.position_solved()
         || (!pvt.FD.valid)
         || (pvt.used_satellites < 6)){return;}
 

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;