gps_pvt 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83dff6013480dd4df4faacde170a901d712a605093fa006d0d4542c58f43ac45
-  data.tar.gz: 33728f6f9c4969f04ed528831e14977f3f90846b0f740ce0644f06de18ac7322
+  metadata.gz: 6b4f5df780c4ff0977b025fab381c327b04a3e8fae742cc6ff672e08839d9c51
+  data.tar.gz: cbbb233acbe548944d9b317449160465ec04d2041e56f54decc286a900503723
 SHA512:
-  metadata.gz: fd13f81c590a85ffeed54fe62dfb45858373cf687b08e5dc37bf45805f54398c50ad71f03e512a28015d214239e189c0581317d703cb4af99f4f9d258d162d12
-  data.tar.gz: 64df6a70a7b02f94e6f94c878ada85bc293871e5478698a5fdc285f77418fd2d27ecf9aece5b42ca197d6a3dc79ab9294f81b06411b83ca008f3428011245b83
+  metadata.gz: a724b51f5fe55fe9c0d74d02176c26dbad63bcc1fc1fbd477c7a0707e06f832df5110f4a80c5c2807ac5e1ae2d0717846858a30365eec874847c96fb11e12b5e
+  data.tar.gz: 97b3670fd401bc860d9f16ab473fe4c6c33ee87fcf6855757490ec724d8405a6aeb7df22aabaf7e37f559d80ce9b4ce1c764c550acccf591bb940805b3c660a6

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -2671,10 +2671,9 @@ struct GPS_Solver
       const typename base_t::gps_time_t &time_arrival,
       const typename base_t::pos_t &usr_pos,
       const typename base_t::xyz_t &usr_vel) const;
-  virtual typename base_t::xyz_t *satellite_position(
+  virtual typename base_t::satellite_t select_satellite(
       const typename base_t::prn_t &prn,
-      const typename base_t::gps_time_t &time,
-      typename base_t::xyz_t &res) const;
+      const typename base_t::gps_time_t &time) const;
   virtual bool update_position_solution(
       const typename base_t::geometric_matrices_t &geomat,
       typename base_t::user_pvt_t &res) const;
@@ -3867,47 +3866,17 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
       return super_t::update_position_solution(geomat, res);
     }
     template <>
-    GPS_Solver<double>::base_t::xyz_t *GPS_Solver<double>::satellite_position(
+    GPS_Solver<double>::base_t::satellite_t GPS_Solver<double>::select_satellite(
         const GPS_Solver<double>::base_t::prn_t &prn,
-        const GPS_Solver<double>::base_t::gps_time_t &time,
-        GPS_Solver<double>::base_t::xyz_t &buf) const {
-      GPS_Solver<double>::base_t::xyz_t *res(
-          select_solver(prn).satellite_position(prn, time, buf));
+        const GPS_Solver<double>::base_t::gps_time_t &time) const {
+      GPS_Solver<double>::base_t::satellite_t res(
+          select_solver(prn).select_satellite(prn, time));
 
-      do{
-        static const VALUE key(ID2SYM(rb_intern("satellite_position")));
+      if(!res.is_available()){
+        static const VALUE key(ID2SYM(rb_intern("relative_property")));
         VALUE hook(rb_hash_lookup(hooks, key));
-        if(NIL_P(hook)){break;}
-        VALUE values[] = {
-            SWIG_From_int  (prn), // prn
-            SWIG_NewPointerObj( // time
-              new base_t::gps_time_t(time), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN),
-            (res // position (internally calculated)
-              ? SWIG_NewPointerObj(res, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0) 
-              : Qnil)};
-        VALUE res_hook(proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values));
-        if(NIL_P(res_hook)){ // unknown position
-          res = NULL;
-          break;
-        }else if(RB_TYPE_P(res_hook, T_ARRAY) && (RARRAY_LEN(res_hook) == 3)){
-          int i(0);
-          for(; i < 3; ++i){
-            VALUE v(RARRAY_AREF(res_hook, i));
-            if(!SWIG_IsOK(swig::asval(v, &buf[i]))){break;}
-          }
-          if(i == 3){
-            res = &buf;
-            break;
-          }
-        }else if(SWIG_IsOK(SWIG_ConvertPtr(
-            res_hook, (void **)&res, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0))){
-          res = &(buf = *res);
-          break;
-        }
-        throw std::runtime_error(
-            std::string("System_XYZ or [d * 3] is expected (d: " "double" "), however ")
-              .append(inspect_str(res_hook)));
-      }while(false);
+        if(!NIL_P(hook)){res.impl = this;}
+      }
 
       return res;
     }

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

@@ -75,7 +75,6 @@ class GLONASS_SinglePositioning : public SolverBaseT {
 
     typedef GLONASS_SpaceNode<float_t> space_node_t;
     inheritate_type(gps_time_t);
-    typedef typename space_node_t::Satellite satellite_t;
 
     inheritate_type(xyz_t);
     inheritate_type(enu_t);
@@ -83,9 +82,10 @@ class GLONASS_SinglePositioning : public SolverBaseT {
     inheritate_type(pos_t);
 
     typedef typename base_t::measurement_t measurement_t;
-    inheritate_type(range_error_t);
-    inheritate_type(range_corrector_t);
-    inheritate_type(range_correction_t);
+    typedef typename base_t::satellite_t satellite_t;
+    typedef typename base_t::range_error_t range_error_t;
+    typedef typename base_t::range_corrector_t range_corrector_t;
+    typedef typename base_t::range_correction_t range_correction_t;
 
     inheritate_type(relative_property_t);
     typedef typename super_t::measurement_items_t measurement_items_t;
@@ -97,11 +97,51 @@ class GLONASS_SinglePositioning : public SolverBaseT {
         GLONASS_SinglePositioning_Options<float_t>, base_t> options_t;
 
   protected:
-    const space_node_t &_space_node;
     GLONASS_SinglePositioning_Options<float_t> _options;
 
   public:
-    const space_node_t &space_node() const {return _space_node;}
+    struct satellites_t {
+      const void *impl;
+      satellite_t (*impl_select)(const void *, const prn_t &, const gps_time_t &);
+      inline satellite_t select(const prn_t &prn, const gps_time_t &receiver_time) const {
+        return impl_select(impl, prn, receiver_time);
+      }
+      static satellite_t select_broadcast(
+          const void *ptr, const prn_t &prn, const gps_time_t &receiver_time){
+        const typename space_node_t::satellites_t &sats(
+            reinterpret_cast<const space_node_t *>(ptr)->satellites());
+        const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
+        if((it_sat == sats.end()) // has ephemeris?
+            || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
+          return satellite_t::unavailable();
+        }
+        struct impl_t {
+          static inline const typename space_node_t::Satellite &sat(const void *ptr) {
+            return *reinterpret_cast<const typename space_node_t::Satellite *>(ptr);
+          }
+          static xyz_t position(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).constellation(t, pseudo_range).position;
+          }
+          static xyz_t velocity(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).constellation(t, pseudo_range).velocity;
+          }
+          static float_t clock_error(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).clock_error(t, pseudo_range);
+          }
+          static float_t clock_error_dot(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            // Clock rate error is already taken into account in constellation()
+            return 0;
+          }
+        };
+        satellite_t res = {
+            &(it_sat->second),
+            impl_t::position, impl_t::velocity,
+            impl_t::clock_error, impl_t::clock_error_dot};
+        return res;
+      }
+      satellites_t(const space_node_t &sn)
+          : impl(&sn), impl_select(select_broadcast) {}
+    } satellites;
 
     range_correction_t ionospheric_correction, tropospheric_correction;
 
@@ -120,7 +160,8 @@ class GLONASS_SinglePositioning : public SolverBaseT {
     }
 
     GLONASS_SinglePositioning(const space_node_t &sn, const options_t &opt_wish = options_t())
-        : base_t(), _space_node(sn), _options(available_options(opt_wish)),
+        : base_t(), _options(available_options(opt_wish)),
+        satellites(sn),
         ionospheric_correction(), tropospheric_correction() {
 
       // default ionospheric correction: no correction
@@ -163,25 +204,18 @@ class GLONASS_SinglePositioning : public SolverBaseT {
     }
 
     /**
-     * Check availability of a satellite with which observation is associated
+     * Select satellite by using PRN and time
      *
      * @param prn satellite number
      * @param receiver_time receiver time
-     * @return (const satellite_t *) If available, const pointer to satellite is returned,
-     * otherwise NULL.
+     * @return (satellite_t) If available, satellite.is_available() returning true is returned.
      */
-    const satellite_t *is_available(
-        const typename space_node_t::satellites_t::key_type &prn,
+    satellite_t select_satellite(
+        const prn_t &prn,
         const gps_time_t &receiver_time) const {
-
-      const typename space_node_t::satellites_t &sats(_space_node.satellites());
-      const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn & 0xFF));
-      if((it_sat == sats.end()) // has ephemeris?
-          || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
-        return NULL;
-      }
-
-      return &(it_sat->second);
+      prn_t prn_(prn & 0xFF);
+      if(_options.exclude_prn[prn_]){return satellite_t::unavailable();}
+      return satellites.select(prn_, receiver_time);
     }
 
     /**
@@ -205,32 +239,27 @@ class GLONASS_SinglePositioning : public SolverBaseT {
 
       relative_property_t res = {0};
 
-      if(_options.exclude_prn[prn & 0xFF]){return res;}
-
       float_t range;
       range_error_t range_error;
       if(!this->range(measurement, range, &range_error)){
         return res; // If no range entry, return with weight = 0
       }
 
-      const satellite_t *sat(is_available(prn, time_arrival));
-      if(!sat){return res;} // If satellite is unavailable, return with weight = 0
+      satellite_t sat(select_satellite(prn, time_arrival));
+      if(!sat.is_available()){return res;} // If satellite is unavailable, return with weight = 0
 
       range -= receiver_error;
 
       // Clock correction, which will be considered in the next constellation()
       // as extra transmission time by using extra psuedo range.
       if(range_error.unknown_flag & range_error_t::SATELLITE_CLOCK){
-        range += (sat->clock_error(time_arrival, range) * space_node_t::light_speed);
+        range += (sat.clock_error(time_arrival, range) * space_node_t::light_speed);
       }else{
         range += range_error.value[range_error_t::SATELLITE_CLOCK];
       }
 
-      // Calculate satellite position and velocity
-      typename GPS_SpaceNode<float_t>::SatelliteProperties::constellation_t sat_pos_vel(
-          sat->constellation(time_arrival, range));
-
-      const xyz_t &sat_pos(sat_pos_vel.position);
+      // Calculate satellite position
+      xyz_t sat_pos(sat.position(time_arrival, range));
       float_t geometric_range(usr_pos.xyz.dist(sat_pos));
 
       // Calculate residual
@@ -278,24 +307,15 @@ class GLONASS_SinglePositioning : public SolverBaseT {
 
       res.range_corrected = range;
 
-      xyz_t rel_vel(sat_pos_vel.velocity - usr_vel); // Calculate velocity
+      xyz_t rel_vel(sat.velocity(time_arrival, range) - usr_vel); // Calculate velocity
 
-      // Note: clock rate error is already accounted for in constellation()
       res.rate_relative_neg = res.los_neg[0] * rel_vel.x()
           + res.los_neg[1] * rel_vel.y()
-          + res.los_neg[2] * rel_vel.z();
+          + res.los_neg[2] * rel_vel.z()
+          + sat.clock_error_dot(time_arrival, range) * space_node_t::light_speed;
 
       return res;
     }
-
-    xyz_t *satellite_position(
-        const prn_t &prn,
-        const gps_time_t &time,
-        xyz_t &res) const {
-
-      const satellite_t *sat(is_available(prn, time));
-      return sat ? &(res = sat->position(time)) : NULL;
-    }
 };
 
 template <class FloatT, class SolverBaseT>

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

@@ -95,7 +95,6 @@ class GPS_SinglePositioning : public SolverBaseT {
 
     typedef typename base_t::space_node_t space_node_t;
     inheritate_type(gps_time_t);
-    typedef typename space_node_t::Satellite satellite_t;
 
     inheritate_type(xyz_t);
     inheritate_type(llh_t);
@@ -106,6 +105,7 @@ class GPS_SinglePositioning : public SolverBaseT {
     inheritate_type(prn_obs_t);
     typedef typename base_t::measurement_t measurement_t;
     inheritate_type(measurement_items_t);
+    typedef typename base_t::satellite_t satellite_t;
     typedef typename base_t::range_error_t range_error_t;
     typedef typename base_t::range_corrector_t range_corrector_t;
     typedef typename base_t::range_correction_t range_correction_t;
@@ -119,11 +119,52 @@ class GPS_SinglePositioning : public SolverBaseT {
         GPS_SinglePositioning_Options<float_t>, base_t> options_t;
 
   protected:
-    const space_node_t &_space_node;
     GPS_SinglePositioning_Options<float_t> _options;
 
   public:
-    const space_node_t &space_node() const {return _space_node;}
+    struct satellites_t {
+      const void *impl;
+      satellite_t (*impl_select)(const void *, const prn_t &, const gps_time_t &);
+      inline satellite_t select(const prn_t &prn, const gps_time_t &receiver_time) const {
+        return impl_select(impl, prn, receiver_time);
+      }
+      static satellite_t select_broadcast(
+          const void *ptr, const prn_t &prn, const gps_time_t &receiver_time){
+        // If this static function is defined in inner struct,
+        // C2440 error raises with VC2010
+        const typename space_node_t::satellites_t &sats(
+            reinterpret_cast<const space_node_t *>(ptr)->satellites());
+        const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
+        if((it_sat == sats.end()) // has ephemeris?
+            || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
+          return satellite_t::unavailable();
+        }
+        struct impl_t {
+          static inline const typename space_node_t::Satellite &sat(const void *ptr) {
+            return *reinterpret_cast<const typename space_node_t::Satellite *>(ptr);
+          }
+          static xyz_t position(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).position(t, pseudo_range);
+          }
+          static xyz_t velocity(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).velocity(t, pseudo_range);
+          }
+          static float_t clock_error(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).clock_error(t, pseudo_range);
+          }
+          static float_t clock_error_dot(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).clock_error_dot(t, pseudo_range);
+          }
+        };
+        satellite_t res = {
+            &(it_sat->second),
+            impl_t::position, impl_t::velocity,
+            impl_t::clock_error, impl_t::clock_error_dot};
+        return res;
+      }
+      satellites_t(const space_node_t &sn)
+          : impl(&sn), impl_select(select_broadcast) {}
+    } satellites;
 
     struct klobuchar_t : public range_corrector_t {
       const space_node_t &space_node;
@@ -134,6 +175,7 @@ class GPS_SinglePositioning : public SolverBaseT {
       float_t *calculate(
           const gps_time_t &t, const pos_t &usr_pos, const enu_t &sat_rel_pos,
           float_t &buf) const {
+        if(!is_available(t)){return NULL;}
         return &(buf = space_node.iono_correction(sat_rel_pos, usr_pos.llh, t));
       }
     } ionospheric_klobuchar;
@@ -185,7 +227,8 @@ class GPS_SinglePositioning : public SolverBaseT {
     }
 
     GPS_SinglePositioning(const space_node_t &sn)
-        : base_t(), _space_node(sn), _options(available_options(options_t())),
+        : base_t(), _options(available_options(options_t())),
+        satellites(sn),
         ionospheric_klobuchar(sn), ionospheric_ntcm_gl(),
         tropospheric_simplified(),
         ionospheric_correction(), tropospheric_correction() {
@@ -309,27 +352,17 @@ class GPS_SinglePositioning : public SolverBaseT {
     }
 
     /**
-     * Check availability of a satellite with which observation is associated
+     * Select satellite by using PRN and time
      *
      * @param prn satellite number
      * @param receiver_time receiver time
-     * @return (const satellite_t *) If available, const pointer to satellite is returned,
-     * otherwise NULL.
+     * @return (satellite_t) If available, satellite.is_available() returning true is returned.
      */
-    const satellite_t *is_available(
-        const typename space_node_t::satellites_t::key_type &prn,
+    satellite_t select_satellite(
+        const prn_t &prn,
         const gps_time_t &receiver_time) const {
-
-      if(_options.exclude_prn[prn]){return NULL;}
-
-      const typename space_node_t::satellites_t &sats(_space_node.satellites());
-      const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
-      if((it_sat == sats.end()) // has ephemeris?
-          || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
-        return NULL;
-      }
-
-      return &(it_sat->second);
+      if(_options.exclude_prn[prn]){return satellite_t::unavailable();}
+      return satellites.select(prn, receiver_time);
     }
 
     /**
@@ -359,8 +392,8 @@ class GPS_SinglePositioning : public SolverBaseT {
         return res; // If no range entry, return with weight = 0
       }
 
-      const satellite_t *sat(is_available(prn, time_arrival));
-      if(!sat){return res;} // If satellite is unavailable, return with weight = 0
+      satellite_t sat(select_satellite(prn, time_arrival));
+      if(!sat.is_available()){return res;} // If satellite is unavailable, return with weight = 0
 
       residual_t residual = {
         res.range_residual,
@@ -369,9 +402,9 @@ class GPS_SinglePositioning : public SolverBaseT {
       };
 
       res.range_corrected = range_corrected(
-          *sat, range - receiver_error, time_arrival,
+          sat, range - receiver_error, time_arrival,
           usr_pos, residual, range_error);
-      res.rate_relative_neg = rate_relative_neg(*sat, res.range_corrected, time_arrival, usr_vel,
+      res.rate_relative_neg = rate_relative_neg(sat, res.range_corrected, time_arrival, usr_vel,
           res.los_neg[0], res.los_neg[1], res.los_neg[2]);
 
       return res;
@@ -415,7 +448,7 @@ class GPS_SinglePositioning : public SolverBaseT {
         float_t range;
         if(!this->range(it->second, range)){continue;} // No range entry
 
-        if(!is_available(it->first, receiver_time)){continue;} // No satellite
+        if(!(select_satellite(it->first, receiver_time).is_available())){continue;} // No satellite
 
         typename base_t::measurement2_t::value_type v = {
             it->first, &(it->second), this}; // prn, measurement, solver
@@ -426,15 +459,6 @@ class GPS_SinglePositioning : public SolverBaseT {
           measurement2, receiver_time, user_position_init, receiver_error_init,
           typename base_t::user_pvt_opt_t(good_init, with_velocity));
     }
-
-    xyz_t *satellite_position(
-        const prn_t &prn,
-        const gps_time_t &time,
-        xyz_t &res) const {
-
-      const satellite_t *sat(is_available(prn, time));
-      return sat ? &(res = sat->position(time)) : NULL;
-    }
 };
 
 #endif /* __GPS_SOLVER_H__ */

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

@@ -226,6 +226,47 @@ struct GPS_Solver_Base {
     return res;
   }
 
+  struct satellite_t {
+    const void *impl;
+    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 &, const float_t &);
+    float_t (*impl_clock_error_dot)(const void *, const gps_time_t &, const float_t &);
+    inline bool is_available() const {
+      return impl != NULL;
+    }
+    inline xyz_t position(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_position(impl, t, pseudo_range);
+    }
+    inline xyz_t velocity(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_velocity(impl, t, pseudo_range);
+    }
+    inline float_t clock_error(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_clock_error(impl, t, pseudo_range);
+    }
+    inline float_t clock_error_dot(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_clock_error_dot(impl, t, pseudo_range);
+    }
+    static const satellite_t &unavailable() {
+      static const satellite_t res = {NULL};
+      return res;
+    }
+  };
+
+  /**
+   * Select satellite by using PRN and time
+   * This function should be overridden.
+   *
+   * @param prn satellite number
+   * @param receiver_time receiver time
+   * @return (satellite_t) If available, satellite.is_available() returning true is returned.
+   */
+  virtual satellite_t select_satellite(
+      const prn_t &prn,
+      const gps_time_t &receiver_time) const {
+    return satellite_t::unavailable();
+  }
+
   struct range_corrector_t {
     virtual ~range_corrector_t() {}
     virtual bool is_available(const gps_time_t &t) const {
@@ -838,21 +879,6 @@ protected:
   }
 
 public:
-  /**
-   * Calculate satellite position
-   *
-   * @param prn satellite number
-   * @param time GPS time
-   * @param res object to which results are stored
-   * @return If position is available, &res will be returned, otherwise NULL.
-   */
-  virtual xyz_t *satellite_position(
-      const prn_t &prn,
-      const gps_time_t &time,
-      xyz_t &res) const {
-    return NULL;
-  }
-
   /**
    * Calculate User position/velocity with hint
    * This is multi-constellation version,
@@ -882,8 +908,7 @@ public:
         it != it_end; ++it){
       typename measurement2_t::value_type v = {
           it->first, &(it->second), &select(it->first)}; // prn, measurement, solver
-      xyz_t sat;
-      if(!v.solver->satellite_position(v.prn, receiver_time, sat)){
+      if(!v.solver->select_satellite(v.prn, receiver_time).is_available()){
         // pre-check satellite availability; remove it when its position is unknown
         continue;
       }

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

@@ -62,8 +62,6 @@ class RINEX_Reader {
     typedef RINEX_Reader<U> self_t;
     typedef std::map<std::string, std::vector<std::string> > header_t;
     
-  protected:
-    header_t _header;
     struct src_stream_t : public std::istream {
       src_stream_t(std::istream &is) : std::istream(is.rdbuf()) {}
       /**
@@ -106,7 +104,11 @@ class RINEX_Reader {
         }
         return *this;
       }
-    } src;
+    };
+
+  protected:
+    header_t _header;
+    src_stream_t src;
     bool _has_next;
     
   public:
@@ -198,7 +200,7 @@ class RINEX_Reader {
           return true;
         }
       }
-      static bool f(
+      static bool f_pure(
           std::string &buf, const int &offset, const int &length, void *value, const int &precision = 0, const bool &str2val = true){
         if(str2val){
           std::stringstream ss(buf.substr(offset, length));
@@ -209,22 +211,30 @@ class RINEX_Reader {
           ss << std::setfill(' ') << std::right << std::setw(length)
               << std::setprecision(precision) << std::fixed
               << *(T *)value;
-          std::string s(ss.str());
+          buf.replace(offset, length, ss.str());
+          return true;
+        }
+      }
+      static bool f(
+          std::string &buf, const int &offset, const int &length, void *value, const int &precision = 0, const bool &str2val = true){
+        bool res(f_pure(buf, offset, length, value, precision, str2val));
+        if((!str2val) && res){
           if((*(T *)value) >= 0){
             if((*(T *)value) < 1){
               int i(length - precision - 2);
-              if(i >= 0){s[i] = ' ';}
+              // 0.12345 => .12345
+              if(i >= 0){buf[i + offset] = ' ';}
             }
           }else{
             if((*(T *)value) > -1){
               int i(length - precision - 2);
-              if(i >= 0){s[i] = '-';}
-              if(--i >= 0){s[i] = ' ';}
+              // -0.12345 => -.12345
+              if(i >= 0){buf[i + offset] = '-';}
+              if(--i >= 0){buf[i + offset] = ' ';}
             }
           }
-          buf.replace(offset, length, s);
-          return true;
         }
+        return res;
       }
       static bool e(
           std::string &buf, const int &offset, const int &length, void *value, const int &precision = 0, const bool &str2val = true){
@@ -268,6 +278,14 @@ class RINEX_Reader {
           std::string &buf, const int &offset, const int &length, void *value, const int &opt = 0, const bool &str2val = true){
         return conv_t<T, false>::d(buf, offset, length, value, opt, str2val);
       }
+      static bool f_pure(
+          std::string &buf, const int &offset, const int &length, void *value, const int &precision = 0, const bool &str2val = true){
+        double v(*(T *)value);
+        bool res(
+            conv_t<double, false>::f_pure(buf, offset, length, &v, precision, str2val));
+        *(T *)value = static_cast<T>(v);
+        return res;
+      }
       static bool f(
           std::string &buf, const int &offset, const int &length, void *value, const int &precision = 0, const bool &str2val = true){
         double v(*(T *)value);

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

@@ -2183,10 +2183,11 @@ template <typename T>
 typename SBAS_SpaceNode<FloatT>::KnownSatellites::list_t
     SBAS_SpaceNode<FloatT>::KnownSatellites::sort(T sorter){
   static const typename SBAS_SpaceNode<FloatT>::RangingCode codes[] = {
+    {120,  145, 01106,    5,   "ASECNA (A-SBAS)"},
     {121,  175, 01241,    5,   "EGNOS (Eutelsat 5WB)"},
     {122,   52, 00267,  143.5, "SPAN (INMARSAT 4F1)"},
     {123,   21, 00232,   31.5, "EGNOS (ASTRA 5B)"},
-    {124,  237, 01617,    0,   "EGNOS (Reserved)"},
+    //{124,  237, 01617,    0,   "(Reserved)"},
     {125,  235, 01076,  -16,   "SDCM (Luch-5A)"},
     {126,  886, 01764,   63.9, "EGNOS (INMARSAT 4F2)"},
     {127,  657, 00717,   55,   "GAGAN (GSAT-8)"},
@@ -2198,16 +2199,30 @@ typename SBAS_SpaceNode<FloatT>::KnownSatellites::list_t
     {133,  603, 01731, -129,   "WAAS (SES-15)"},
     {134,  130, 00706,   91.5, "KASS (MEASAT-3D)"},
     {135,  359, 01216, -125,   "WAAS (Intelsat Galaxy 30)"},
-    {136,  595, 00740,    5,   "EGNOS (SES-5)"},
+    {136,  595, 00740,    5,   "EGNOS (HOTBIRD 13G)"},
     {137,   68, 01007,  127,   "MSAS (QZS-3)"},
     {138,  386, 00450,  107.3, "WAAS (ANIK F1R)"},
+    //{139,  797, 00305,    0,   "MSAS (QZS-7)"},
     {140,  456, 01653,   95,   "SDCM (Luch-5V)"},
     {141,  499, 01411,  167,   "SDCM (Luch-5A)"},
+    //{142,  883, 01644,    0,   "(Unallocated)"},
     {143,  307, 01312,  110.5, "BDSBAS (G3)"},
     {144,  127, 01060,   80,   "BDSBAS (G2)"},
-    {147,  118, 00355,   42.5, "NSAS (NIGCOMSAT-1R)"},
+    //{145,  211, 01560,    0,   "(Unallocated)"},
+    //{146,  121, 00035,    0,   "(Unallocated)"},
+    {147,  118, 00355,    5,   "ASECNA (A-SBAS)"},
     {148,  163, 00335,  -24.8, "ASAL (ALCOMSAT-1)"},
-  }; ///< @see https://www.gps.gov/technical/prn-codes/L1-CA-PRN-code-assignments-2020-Apr.pdf
+    //{149,  628, 01254,    0,   "(Unallocated)"},
+    //{150,  853, 01041,    0,   "EGNOS"},
+    //{151,  484, 00142,    0,   "(Unallocated)"},
+    //{152,  289, 01641,    0,   "(Unallocated)"},
+    //{153,  811, 01504,    0,   "(Unallocated)"},
+    //{154,  202, 00751,    0,   "(Unallocated)"},
+    //{155, 1021, 01774,    0,   "(Unallocated)"},
+    //{156,  463, 00107,    0,   "(Unallocated)"},
+    //{157,  568, 01153,    0,   "(Unallocated)"},
+    //{158,  904, 01542,    0,   "(Unallocated)"},
+  }; ///< @see https://www.gps.gov/technical/prn-codes/L1-CA-PRN-code-assignments-2021-Jun.pdf
   list_t res;
   res.reserve(sizeof(codes) / sizeof(codes[0]));
   for(unsigned int i(0); i < sizeof(codes) / sizeof(codes[0]); ++i){

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

@@ -73,7 +73,6 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
     typedef SBAS_SpaceNode<float_t> space_node_t;
     inheritate_type(gps_time_t);
-    typedef typename space_node_t::Satellite satellite_t;
 
     inheritate_type(xyz_t);
     inheritate_type(enu_t);
@@ -81,6 +80,7 @@ class SBAS_SinglePositioning : public SolverBaseT {
     inheritate_type(pos_t);
 
     typedef typename base_t::measurement_t measurement_t;
+    typedef typename base_t::satellite_t satellite_t;
     typedef typename base_t::range_error_t range_error_t;
     typedef typename base_t::range_corrector_t range_corrector_t;
     typedef typename base_t::range_correction_t range_correction_t;
@@ -92,11 +92,52 @@ class SBAS_SinglePositioning : public SolverBaseT {
         SBAS_SinglePositioning_Options<float_t>, base_t> options_t;
 
   protected:
-    const space_node_t &_space_node;
     SBAS_SinglePositioning_Options<float_t> _options;
 
   public:
-    const space_node_t &space_node() const {return _space_node;}
+    struct satellites_t {
+      const void *impl;
+      satellite_t (*impl_select)(const void *, const prn_t &, const gps_time_t &);
+      inline satellite_t select(const prn_t &prn, const gps_time_t &receiver_time) const {
+        return impl_select(impl, prn, receiver_time);
+      }
+      static satellite_t select_broadcast(
+          const void *ptr, const prn_t &prn, const gps_time_t &receiver_time){
+        const typename space_node_t::satellites_t &sats(
+            reinterpret_cast<const space_node_t *>(ptr)->satellites());
+        const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
+        if((it_sat == sats.end()) // has ephemeris?
+            || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
+          return satellite_t::unavailable();
+        }
+        struct impl_t {
+          static inline const typename space_node_t::Satellite &sat(const void *ptr) {
+            return *reinterpret_cast<const typename space_node_t::Satellite *>(ptr);
+          }
+          static xyz_t position(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).ephemeris().constellation(t, pseudo_range, false).position;
+          }
+          static xyz_t velocity(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).ephemeris().constellation(t, pseudo_range, true).velocity;
+          }
+          static float_t clock_error(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            // Clock correction is taken into account in position()
+            return 0;
+          }
+          static float_t clock_error_dot(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            // Clock rate error is taken in account in velocity()
+            return 0;
+          }
+        };
+        satellite_t res = {
+            &(it_sat->second),
+            impl_t::position, impl_t::velocity,
+            impl_t::clock_error, impl_t::clock_error_dot};
+        return res;
+      }
+      satellites_t(const space_node_t &sn)
+          : impl(&sn), impl_select(select_broadcast) {}
+    } satellites;
 
     struct ionospheric_sbas_t : public range_corrector_t {
       const space_node_t &space_node;
@@ -155,7 +196,8 @@ class SBAS_SinglePositioning : public SolverBaseT {
     }
 
     SBAS_SinglePositioning(const space_node_t &sn)
-        : base_t(), _space_node(sn), _options(available_options(options_t())),
+        : base_t(), _options(available_options(options_t())),
+        satellites(sn),
         ionospheric_sbas(sn), tropospheric_sbas() {
 
       // default ionospheric correction: Broadcasted IGP.
@@ -168,25 +210,17 @@ class SBAS_SinglePositioning : public SolverBaseT {
     ~SBAS_SinglePositioning(){}
 
     /**
-     * Check availability of a satellite with which observation is associated
+     * Select satellite by using PRN and time
      *
      * @param prn satellite number
      * @param receiver_time receiver time
-     * @return (const satellite_t *) If available, const pointer to satellite is returned,
-     * otherwise NULL.
+     * @return (satellite_t) If available, satellite.is_available() returning true is returned.
      */
-    const satellite_t *is_available(
-        const typename space_node_t::satellites_t::key_type &prn,
+    satellite_t select_satellite(
+        const prn_t &prn,
         const gps_time_t &receiver_time) const {
-
-      const typename space_node_t::satellites_t &sats(_space_node.satellites());
-      const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
-      if((it_sat == sats.end()) // has ephemeris?
-          || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
-        return NULL;
-      }
-
-      return &(it_sat->second);
+      if(_options.exclude_prn[prn]){return satellite_t::unavailable();}
+      return satellites.select(prn, receiver_time);
     }
 
     /**
@@ -210,33 +244,28 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
       relative_property_t res = {0};
 
-      if(_options.exclude_prn[prn]){return res;}
-
       float_t range;
       range_error_t range_error;
       if(!this->range(measurement, range, &range_error)){
         return res; // If no range entry, return with weight = 0
       }
 
-      const satellite_t *sat(is_available(prn, time_arrival));
-      if(!sat){return res;} // If satellite is unavailable, return with weight = 0
+      satellite_t sat(select_satellite(prn, time_arrival));
+      if(!sat.is_available()){return res;} // If satellite is unavailable, return with weight = 0
 
       ///< The following procedure is based on Appendix.S with modification
 
       range -= receiver_error;
 
-      // Clock correction will be performed in the following constellation()
-      if(!(range_error.unknown_flag & range_error_t::SATELLITE_CLOCK)){
-        range += range_error.value[range_error_t::SATELLITE_CLOCK];
-      }
+      // Clock error correction
+      range += ((range_error.unknown_flag & range_error_t::SATELLITE_CLOCK)
+          ? (sat.clock_error(time_arrival, range) * GPS_SpaceNode<float_t>::light_speed)
+          : range_error.value[range_error_t::SATELLITE_CLOCK]);
 
       // TODO WAAS long term clock correction (2.1.1.4.11)
 
-      // Calculate satellite position and velocity
-      typename space_node_t::SatelliteProperties::constellation_t sat_pos_vel(
-          sat->ephemeris().constellation(time_arrival, range));
-
-      const xyz_t &sat_pos(sat_pos_vel.position);
+      // Calculate satellite position
+      xyz_t sat_pos(sat.position(time_arrival, range));
       float_t geometric_range(usr_pos.xyz.dist(sat_pos));
 
       // Calculate residual with Sagnac correction (A.4.4.11)
@@ -283,24 +312,15 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
       res.range_corrected = range;
 
-      xyz_t rel_vel(sat_pos_vel.velocity - usr_vel); // Calculate velocity
+      xyz_t rel_vel(sat.velocity(time_arrival, range) - usr_vel); // Calculate velocity
 
-      // Note: clock rate error is already accounted for in constellation()
       res.rate_relative_neg = res.los_neg[0] * rel_vel.x()
           + res.los_neg[1] * rel_vel.y()
-          + res.los_neg[2] * rel_vel.z();
+          + res.los_neg[2] * rel_vel.z()
+          + sat.clock_error_dot(time_arrival, range) * GPS_SpaceNode<float_t>::light_speed;
 
       return res;
     }
-
-    xyz_t *satellite_position(
-        const prn_t &prn,
-        const gps_time_t &time,
-        xyz_t &res) const {
-
-      const satellite_t *sat(is_available(prn, time));
-      return sat ? &(res = sat->ephemeris().constellation(time).position) : NULL;
-    }
 };
 
 #endif /* __SBAS_SOLVER_H__ */

data/ext/ninja-scan-light/tool/swig/GPS.i

@@ -1104,7 +1104,7 @@ struct GPS_RangeCorrector
   %ignore glonass;
   %ignore select_solver;
   %ignore relative_property;
-  %ignore satellite_position;
+  %ignore select_satellite;
   %ignore update_position_solution;
   %ignore user_correctors_t;
   %ignore user_correctors;
@@ -1201,47 +1201,17 @@ struct GPS_RangeCorrector
       return super_t::update_position_solution(geomat, res);
     }
     template <>
-    GPS_Solver<FloatT>::base_t::xyz_t *GPS_Solver<FloatT>::satellite_position(
+    GPS_Solver<FloatT>::base_t::satellite_t GPS_Solver<FloatT>::select_satellite(
         const GPS_Solver<FloatT>::base_t::prn_t &prn,
-        const GPS_Solver<FloatT>::base_t::gps_time_t &time,
-        GPS_Solver<FloatT>::base_t::xyz_t &buf) const {
-      GPS_Solver<FloatT>::base_t::xyz_t *res(
-          select_solver(prn).satellite_position(prn, time, buf));
+        const GPS_Solver<FloatT>::base_t::gps_time_t &time) const {
+      GPS_Solver<FloatT>::base_t::satellite_t res(
+          select_solver(prn).select_satellite(prn, time));
 #ifdef SWIGRUBY
-      do{
-        static const VALUE key(ID2SYM(rb_intern("satellite_position")));
+      if(!res.is_available()){
+        static const VALUE key(ID2SYM(rb_intern("relative_property")));
         VALUE hook(rb_hash_lookup(hooks, key));
-        if(NIL_P(hook)){break;}
-        VALUE values[] = {
-            SWIG_From(int)(prn), // prn
-            SWIG_NewPointerObj( // time
-              new base_t::gps_time_t(time), $descriptor(GPS_Time<FloatT> *), SWIG_POINTER_OWN),
-            (res // position (internally calculated)
-              ? SWIG_NewPointerObj(res, $descriptor(System_XYZ<FloatT, WGS84> *), 0) 
-              : Qnil)};
-        VALUE res_hook(proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values));
-        if(NIL_P(res_hook)){ // unknown position
-          res = NULL;
-          break;
-        }else if(RB_TYPE_P(res_hook, T_ARRAY) && (RARRAY_LEN(res_hook) == 3)){
-          int i(0);
-          for(; i < 3; ++i){
-            VALUE v(RARRAY_AREF(res_hook, i));
-            if(!SWIG_IsOK(swig::asval(v, &buf[i]))){break;}
-          }
-          if(i == 3){
-            res = &buf;
-            break;
-          }
-        }else if(SWIG_IsOK(SWIG_ConvertPtr(
-            res_hook, (void **)&res, $descriptor(System_XYZ<FloatT, WGS84> *), 0))){
-          res = &(buf = *res);
-          break;
-        }
-        throw std::runtime_error(
-            std::string("System_XYZ or [d * 3] is expected (d: " %str(FloatT) "), however ")
-              .append(inspect_str(res_hook)));
-      }while(false);
+        if(!NIL_P(hook)){res.impl = this;}
+      }
 #endif
       return res;
     }
@@ -1481,10 +1451,9 @@ struct GPS_Solver
       const typename base_t::gps_time_t &time_arrival,
       const typename base_t::pos_t &usr_pos,
       const typename base_t::xyz_t &usr_vel) const;
-  virtual typename base_t::xyz_t *satellite_position(
+  virtual typename base_t::satellite_t select_satellite(
       const typename base_t::prn_t &prn,
-      const typename base_t::gps_time_t &time,
-      typename base_t::xyz_t &res) const;
+      const typename base_t::gps_time_t &time) const;
   virtual bool update_position_solution(
       const typename base_t::geometric_matrices_t &geomat,
       typename base_t::user_pvt_t &res) const;

data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb

@@ -375,22 +375,6 @@ __RINEX_OBS_TEXT__
           expect(mat).to respond_to(:resize!)
         }
       }
-      solver.hooks[:satellite_position] = proc{
-        i = 0
-        proc{|prn, time, pos|
-          expect(input[:measurement]).to include(prn)
-          expect(pos).to be_a_kind_of(Coordinate::XYZ).or eq(nil)
-          # System_XYZ or [x,y,z] or nil(= unknown position) are acceptable
-          case (i += 1) % 5
-          when 0
-            nil
-          when 1
-            pos.to_a
-          else
-            pos
-          end
-        }
-      }.call
       pvt = solver.solve(
           input[:measurement].collect{|prn, items|
             items.collect{|k, v| [prn, k, v]}

data/lib/gps_pvt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-11 00:00:00.000000000 Z
+date: 2022-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake