gps_pvt 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ba5a3a5c8364753e1f6384519a015f29459e51e17bd82eb81e398c89e80619f
-  data.tar.gz: 565bd717bb178be9784b9b249860270b9d45e33e8af456ab1042db5d75b34c04
+  metadata.gz: 6b4f5df780c4ff0977b025fab381c327b04a3e8fae742cc6ff672e08839d9c51
+  data.tar.gz: cbbb233acbe548944d9b317449160465ec04d2041e56f54decc286a900503723
 SHA512:
-  metadata.gz: 1fef4a8e70a4872f17219f3f97a2ac21d0b5feb44a611d747291d842dd6939cd297426c53cbd16875ece618b610d557542f98c720177a05e95db63f9dcd788c9
-  data.tar.gz: 60450ca6f661f0eaeb0c194caa97f4246dd723edbf2f566c5775fa91dffb621357aca7732b54fb7d27b636cb0864b2f26c40efa661fb3afde029b6a4bc985d63
+  metadata.gz: a724b51f5fe55fe9c0d74d02176c26dbad63bcc1fc1fbd477c7a0707e06f832df5110f4a80c5c2807ac5e1ae2d0717846858a30365eec874847c96fb11e12b5e
+  data.tar.gz: 97b3670fd401bc860d9f16ab473fe4c6c33ee87fcf6855757490ec724d8405a6aeb7df22aabaf7e37f559d80ce9b4ce1c764c550acccf591bb940805b3c660a6

data/README.md

@@ -32,7 +32,7 @@ An attached executable is useful. After installation, type
 
     $ gps_pvt RINEX_or_UBX_file(s)
 
-The format of RINEX_or_UBX_file is automatically determined with its extention, such as .ubx will be treated as UBX format. If you want to specify the file format, instead of RINEX_or_UBX_file(s), use the following arguments:
+The format of RINEX_or_UBX_file is automatically determined with its extension, such as .ubx will be treated as UBX format. A gz compressed file can be specified directly, and URI such as https://... is also acceptable since version 0.5.0. If you want to specify the file format, instead of RINEX_or_UBX_file(s), use the following arguments:
 
     --rinex_nav=filename
     --rinex_obs=filename
@@ -50,6 +50,7 @@ Additionally, the following command options *--key=value* are available.
 | elevation_mask_deg | numeric | satellite elevation mask specified in degrees. *ex) --elevation_mask_deg=10* | v0.3.0 |
 | start_time | time string | start time to perform solution. GPS, UTC and other formats are supported. *ex1) --start_time=1234:5678* represents 5678 seconds in 1234 GPS week, *ex2) --start_time="2000-01-01 00:00:00 UTC"* is in UTC format. | v0.3.3 |
 | end_time | time string | end time to perform solution. Its format is the same as start_time. | v0.3.3 |
+| online_ephemeris | | automatically load ephemeris published online based on observation | v0.5.0 |
 
 ### For developer
 

data/exe/gps_pvt

@@ -1,16 +1,19 @@
 #!/usr/bin/env ruby
 
 require 'gps_pvt'
+require 'uri'
 
 # runnable quick example to solve PVT by using RINEX NAV/OBS or u-blox ubx
 
 $stderr.puts <<__STRING__
 Usage: #{__FILE__} GPS_file1 GPS_file2 ...
 As GPS_file, rinex_nav(*.YYn, *.YYh, *.YYq, *.YYg), rinex_obs(*.YYo), and ubx(*.ubx) format are currently supported.
+(YY = last two digit of year)
 File format is automatically determined based on its extention described in above parentheses.
 If you want to specify its format manually, --rinex_(nav|obs)=file_name or --ubx=file_name are available.
 Supported RINEX versions are 2 and 3.
-Note: YY = last two digit of year.
+A file having additional ".gz" extension is recognized as a file compressed by zlib.
+Major URL such as http(s)://... is acceptable as an input file name. 
 __STRING__
 
 options = []
@@ -54,6 +57,9 @@ options.reject!{|opt|
     end
     misc_options[opt[0]] = t
     true
+  when :online_ephemeris
+    misc_options[opt[0]] = opt[1]
+    true
   else
     false
   end
@@ -61,19 +67,45 @@ options.reject!{|opt|
 
 # Check file existence and extension
 files.collect!{|fname, ftype|
-  raise "File not found: #{fname}" unless File::exist?(fname)
   ftype ||= case fname
-  when /\.\d{2}[nhqg]$/; :rinex_nav
-  when /\.\d{2}o$/; :rinex_obs
+  when /\.\d{2}[nhqg](?:\.gz)?$/; :rinex_nav
+  when /\.\d{2}o(?:\.gz)?$/; :rinex_obs
   when /\.ubx$/; :ubx
   else
     raise "Format cannot be guessed, use --(format, ex. rinex_nav)=#{fname}"
   end
+  fname = proc{
+    next fname if File::exist?(fname)
+    if uri = URI::parse(fname) and !uri.instance_of?(URI::Generic) then
+      next uri
+    end
+    raise "File not found: #{fname}"
+  }.call
   [fname, ftype]
 }
 
 rcv = GPS_PVT::Receiver::new(options)
 
+proc{|src|
+  next unless src
+  loader = proc{|t_meas|
+    utc = Time::utc(*t_meas.c_tm)
+    y, yday = [:year, :yday].collect{|f| utc.send(f)}
+    uri = URI::parse(
+        "ftp://gssc.esa.int/gnss/data/daily/" + 
+          "%04d/brdc/BRDC00IGS_R_%04d%03d0000_01D_MN.rnx.gz"%[y, y, yday])
+    rcv.parse_rinex_nav(uri)
+    uri
+  }
+  run_orig = rcv.method(:run)
+  eph_list = {}
+  rcv.define_singleton_method(:run){|meas, t_meas, *args|
+    w_d = [t_meas.week, (t_meas.seconds.to_i / 86400)]
+    eph_list[w_d] ||= loader.call(t_meas)
+    run_orig.call(meas, t_meas, *args)
+  }
+}.call(misc_options[:online_ephemeris])
+
 proc{
   run_orig = rcv.method(:run)
   t_start, t_end = [nil, nil]

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.h

@@ -952,6 +952,8 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET]){break;}
           float_t sidereal_t_b_rad;
           typename Ephemeris::differential_t eq_of_motion;
 
+          static const float_t time_step_max_per_one_integration;
+
           void calculate_additional() {
             sidereal_t_b_rad = TimeProperties::date_t::Greenwich_sidereal_time_deg(
                 TimeProperties::date.c_tm(),
@@ -1009,36 +1011,52 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET]){break;}
             return calculate_clock_error(t_arrival_onboard - Ephemeris::t_b, pseudo_range);
           }
           /**
-           * Calculate constellation(t) based on constellation(t_0).
+           * Calculate absolute constellation(t) based on constellation(t_0).
            * t_0 is a time around t_b, and is used to calculate
-           * an intermediate result specified with the 3rd argument.
-           * This method is useful to calculate constellation effectively
-           * by using a cache.
-           * @param delta_t time interval from t_0 to t
-           * @param pseudo_range measured pusedo_range to correct delta_t
+           * @param t_step time interval from t_0 to t
+           * @param times number of integration steps (assume times >=0)
            * @param xa_t_0 constellation(t_0)
-           * @param t_0_from_t_b time interval from t_b to t_0
+           * @param t_0_from_t_b time interval from t_b to t_0 (= t_0 - t_b)
            */
-          constellation_t calculate_constellation(
-              float_t delta_t, const float_t &pseudo_range,
+          constellation_t constellation_abs(
+              const float_t &t_step,
+              int times,
               const constellation_t &xa_t_0, const float_t &t_0_from_t_b) const {
 
             constellation_t res(xa_t_0);
-            { // time integration from t_b to t_transmit
-              float_t delta_t_to_transmit(delta_t - pseudo_range / light_speed);
-              float_t t_step_max(delta_t_to_transmit >= 0 ? 60 : -60);
-              int i(std::floor(delta_t_to_transmit / t_step_max));
-              float_t t_step_remain(delta_t_to_transmit - t_step_max * i);
-              float_t delta_t_itg(0); // accumulative time of integration
-              for(; i > 0; --i, delta_t_itg += t_step_max){
-                res = nextByRK4(eq_of_motion, delta_t_itg, res, t_step_max);
-              }
-              res = nextByRK4(eq_of_motion, delta_t_itg, res, t_step_remain);
+            float_t delta_t_itg(t_0_from_t_b); // accumulative time of integration
+            for(; times > 0; --times, delta_t_itg += t_step){
+              res = nextByRK4(eq_of_motion, delta_t_itg, res, t_step);
             }
+            return res;
+          }
+          /**
+           * Calculate absolute constellation(t) based on constellation(t_0).
+           * t_0 is a time around t_b, and is used to calculate
+           * an intermediate result specified with the 2nd argument.
+           * This method is useful to calculate constellation effectively
+           * by using a cache.
+           * @param delta_t time interval from t_0 to t
+           * @param xa_t_0 constellation(t_0)
+           * @param t_0_from_t_b time interval from t_b to t_0 (= t_0 - t_b)
+           */
+          constellation_t constellation_abs(
+              const float_t &delta_t,
+              const constellation_t &xa_t_0, const float_t &t_0_from_t_b) const {
 
-            static const float_t omega_E(0.7292115E-4); // Earth's rotation rate, TODO move to PZ-90.02
-            return res.rel_corrdinate(
-                sidereal_t_b_rad + (omega_E * (delta_t + t_0_from_t_b))); // transform from abs to PZ-90.02
+            float_t t_step_max(delta_t >= 0
+                ? time_step_max_per_one_integration
+                : -time_step_max_per_one_integration);
+            int n(std::floor(delta_t / t_step_max));
+            float_t delta_t_steps(t_step_max * n), delta_t_remain(delta_t - delta_t_steps);
+
+            // To perform time integration from t_0 to (t_0 + delta_t),
+            // n-times integration with t_step_max,
+            // then, one-time integration with delta_t_remain are conducted.
+            return constellation_abs(
+                delta_t_remain, 1,
+                constellation_abs(t_step_max, n, xa_t_0, t_0_from_t_b),
+                t_0_from_t_b + delta_t_steps);
           }
           /**
            * Calculate constellation(t) based on constellation(t_b).
@@ -1046,8 +1064,14 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET]){break;}
            * @param pseudo_range measured pusedo_range to correct delta_t, default is 0.
            */
           constellation_t calculate_constellation(
-              float_t delta_t, const float_t &pseudo_range = 0) const {
-            return calculate_constellation(delta_t, pseudo_range, xa_t_b, float_t(0));
+              const float_t &delta_t, const float_t &pseudo_range = 0) const {
+
+            float_t delta_t_to_transmit(delta_t - pseudo_range / light_speed);
+            constellation_t res(
+                constellation_abs(delta_t_to_transmit, xa_t_b, float_t(0)));
+
+            return res.rel_corrdinate(
+                sidereal_t_b_rad + (constellation_t::omega_E * delta_t)); // transform from abs to PZ-90.02
           }
           /**
            * @param t_arrival_glonass signal arrival time in glonass time scale,
@@ -1098,7 +1122,37 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET]){break;}
     struct Satellite : public SatelliteProperties {
       public:
         typedef typename SatelliteProperties::Ephemeris_with_GPS_Time eph_t;
-        typedef typename GPS_SpaceNode<float_t>::template PropertyHistory<eph_t> eph_list_t;
+
+        struct eph_cached_t : public eph_t {
+          mutable typename eph_t::constellation_t xa_t_0;
+          mutable float_t t_0_from_t_b;
+          eph_cached_t() : eph_t(), xa_t_0(eph_t::xa_t_b), t_0_from_t_b(0) {}
+          eph_cached_t(const eph_t &eph) : eph_t(eph), xa_t_0(eph.xa_t_b), t_0_from_t_b(0) {}
+          using eph_t::constellation;
+          typename eph_t::constellation_t constellation(
+              const GPS_Time<float_t> &t_arrival_gps, const float_t &pseudo_range = 0) const {
+            float_t delta_t(t_arrival_gps - eph_t::t_b_gps);
+            float_t delta_t_transmit_from_t_0(delta_t - pseudo_range / light_speed - t_0_from_t_b);
+
+            float_t t_step_max(delta_t_transmit_from_t_0 >= 0
+                ? eph_t::time_step_max_per_one_integration
+                : -eph_t::time_step_max_per_one_integration);
+
+            int big_steps(std::floor(delta_t_transmit_from_t_0 / t_step_max));
+            if(big_steps > 0){ // perform integration and update cache
+              xa_t_0 = eph_t::constellation_abs(t_step_max, big_steps, xa_t_0, t_0_from_t_b);
+              float_t delta_t_updated(t_step_max * big_steps);
+              t_0_from_t_b += delta_t_updated;
+              delta_t_transmit_from_t_0 -= delta_t_updated;
+            }
+
+            return eph_t::constellation_abs(delta_t_transmit_from_t_0, 1, xa_t_0, t_0_from_t_b)
+                .rel_corrdinate(
+                  eph_t::sidereal_t_b_rad + (eph_t::constellation_t::omega_E * delta_t)); // transform from abs to PZ-90.02
+          }
+        };
+
+        typedef typename GPS_SpaceNode<float_t>::template PropertyHistory<eph_cached_t> eph_list_t;
       protected:
         eph_list_t eph_history;
       public:
@@ -1115,7 +1169,7 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET]){break;}
         }
 
         void register_ephemeris(const eph_t &eph, const int &priority_delta = 1){
-          eph_history.add(eph, priority_delta);
+          eph_history.add(eph_cached_t(eph), priority_delta);
         }
 
         void merge(const Satellite &another, const bool &keep_original = true){
@@ -1143,7 +1197,7 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET]){break;}
         typename GPS_SpaceNode<float_t>::SatelliteProperties::constellation_t constellation(
             const GPS_Time<float_t> &t, const float_t &pseudo_range = 0) const {
           return (typename GPS_SpaceNode<float_t>::SatelliteProperties::constellation_t)(
-              ephemeris().constellation(t, pseudo_range));
+              eph_history.current().constellation(t, pseudo_range));
         }
 
         typename GPS_SpaceNode<float_t>::xyz_t position(const GPS_Time<float_t> &t, const float_t &pseudo_range = 0) const {
@@ -1267,4 +1321,9 @@ typename GLONASS_SpaceNode<FloatT>::u8_t GLONASS_SpaceNode<FloatT>::SatellitePro
   return res;
 }
 
+template <class FloatT>
+const typename GLONASS_SpaceNode<FloatT>::float_t
+    GLONASS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris_with_Time
+      ::time_step_max_per_one_integration = 60;
+
 #endif /* __GLONASS_H__ */

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/receiver.rb

@@ -4,6 +4,7 @@ Receiver class to be an top level interface to a user
 =end
 
 require_relative 'GPS'
+require_relative 'util'
 
 module GPS_PVT
 class Receiver
@@ -547,22 +548,24 @@ class Receiver
     $stderr.puts ", found packets are %s"%[ubx_kind.inspect]
   end
   
-  def parse_rinex_nav(fname)
+  def parse_rinex_nav(src)
+    fname = Util::get_txt(src)
     items = [
       @solver.gps_space_node,
       @solver.sbas_space_node,
       @solver.glonass_space_node,
     ].inject(0){|res, sn|
       loaded_items = sn.send(:read, fname)
-      raise "Format error! (Not RINEX) #{fname}" if loaded_items < 0
+      raise "Format error! (Not RINEX) #{src}" if loaded_items < 0
       res + loaded_items
     }
-    $stderr.puts "Read RINEX NAV file (%s): %d items."%[fname, items]
+    $stderr.puts "Read RINEX NAV file (%s): %d items."%[src, items]
   end
   
-  def parse_rinex_obs(fname, &b)
+  def parse_rinex_obs(src, &b)
+    fname = Util::get_txt(src)
     after_run = b || proc{|pvt| puts pvt.to_s if pvt}
-    $stderr.print "Reading RINEX observation file (%s)"%[fname]
+    $stderr.print "Reading RINEX observation file (%s)"%[src]
     types = nil
     glonass_freq = nil
     count = 0

data/lib/gps_pvt/util.rb

@@ -0,0 +1,32 @@
+require 'open-uri'
+require 'tempfile'
+require 'uri'
+require 'zlib'
+
+module GPS_PVT
+module Util
+  class << self
+    def inflate(src)
+      Zlib::GzipReader.send(*(src.kind_of?(IO) ? [:new, src] : [:open, src]))
+    end
+    def get_txt(fname_or_uri)
+      is_uri = fname_or_uri.kind_of?(URI)
+      ((is_uri && (RUBY_VERSION >= "2.5.0")) ? URI : Kernel) \
+          .send(:open, fname_or_uri){|src|
+        is_gz = (src.content_type =~ /gzip/) if is_uri
+        is_gz ||= (fname_or_uri.to_s =~ /\.gz$/)
+        is_file = src.kind_of?(File) || src.kind_of?(Tempfile)
+
+        return src.path if ((!is_gz) and is_file)
+
+        Tempfile::open(File::basename($0, '.*')){|dst|
+          dst.binmode
+          dst.write((is_gz ? inflate(is_file ? src.path : src) : src).read)
+          dst.rewind
+          dst.path
+        }
+      }
+    end
+  end
+end
+end

data/lib/gps_pvt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.4.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.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-17 00:00:00.000000000 Z
+date: 2022-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -93,11 +93,12 @@ files:
 - ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb
 - ext/ninja-scan-light/tool/swig/spec/SylphideMath_spec.rb
 - gps_pvt.gemspec
+- gps_pvt.rbs
 - lib/gps_pvt.rb
 - lib/gps_pvt/receiver.rb
 - lib/gps_pvt/ubx.rb
+- lib/gps_pvt/util.rb
 - lib/gps_pvt/version.rb
-- sig/gps_pvt.rbs
 homepage: https://github.com/fenrir-naru/gps_pvt
 licenses: []
 metadata: