gps_pvt 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b49839b2da332d30293697783114af90a441fe477dfb85e17ac166c381970836
-  data.tar.gz: 4227cc97c2bdd1c5994a598ab1723c9bad86331478f0cc60aaa8435302bc9838
+  metadata.gz: cd084c2ca722a761b9dbae3ea2fde546531f403ebff8e87b5d7b9632986c3aa8
+  data.tar.gz: 92943ca82b4ab13794dc39c51e71a23d178baf483fd1dd782a7305fc7a121de5
 SHA512:
-  metadata.gz: a81577f725c28dfe949342076d10826eb14238ec791bc58bc8b7797715b5bc6d6b014fd10454e8f2c56a66ac6b6d03965c79f9e94f39ac65b193fa815cd83924
-  data.tar.gz: f7eb1d3c1eb4e4ef61d8ada6b12efe1a0d4a9c167d87fc6d2ee7f829dcddb0f3b3c50c6a47a58b08cce57ca220283e2f73af24fafed27da3bb112e4af71a5efd
+  metadata.gz: 48597633d7d70da6f7458f00482873d8c2f695dfb352ce0d5a1c6529b495eb0f3c26e07df89249d5a5dd34a82b13bcfd964fcac330e775f9b2f1cf90bd3274ab
+  data.tar.gz: 31baba44c7d446334ed3fc9c73c73dd69500f7548ba417a1da92d20c991fc33c799a3a38e0f4651ff873e3caf4d7a3123b4e0e9514d50523cb9003f02f2affd2

data/README.md

@@ -31,6 +31,16 @@ For user who just generate PVT solution, an attached executable is useful. After
 
     $ 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:
+
+    --rinex_nav=filename
+    --rinex_obs=filename
+    --ubx=filename
+
+From version 0.2.0, SBAS and QZSS are supported in addition to GPS. QZSS ranging is activated in default, however, SBAS is just utilized for ionospheric correction. If you want to activate SBAS ranging, "--with=(SBAS PRN number, ex. 137)" option is used with gps_pvt executable like
+
+    $ gps_pvt --with=137 RINEX_or_UBX_file(s)
+
 For developer, this library will be used in the following:
 
 ```ruby
@@ -75,9 +85,10 @@ receiver.parse_rinex_obs(rinex_obs_file){|pvt, meas| # per epoch
 receiver.solver.gps_options.exclude(prn) # Exclude satellite; the default is to use every satellite if visible
 receiver.solver.gps_options.include(prn) # Discard previous setting of exclusion
 receiver.solver.gps_options.elevation_mask = Math::PI / 180 * 10 # example 10 [deg] elevation mask
-receiver.solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+receiver.solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
   # control weight per satellite per iteration
   weight, range_c, range_r, rate_rel_neg, *los_neg = rel_prop # relative property
+  # meas is measurement represented by pseudo range of the selected satellite.
   # rcv_e, t_arv, usr_pos, usr_vel are temporary solution of 
   # receiver clock error [m], time of arrival [s], user position and velocity in ECEF, respectively.
   
@@ -94,7 +105,7 @@ receiver.solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, u
   alias_method(:run_orig, :run)
   define_method(:run){|meas, t_meas, &b|
     meas # observation, same as the 2nd argument of parse_XXX
-    receiver.solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+    receiver.solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
       # Do something based on meas, t_meas.
       rel_prop
     }

data/exe/gps_pvt

@@ -6,23 +6,35 @@ require 'gps_pvt'
 
 $stderr.puts <<__STRING__
 Usage: #{__FILE__} GPS_file1 GPS_file2 ...
-As GPS_file, rinex_nav(*.YYn), rinex_obs(*.YYo), and ubx(*.ubx) format are currently supported.
+As GPS_file, rinex_nav(*.YYn, *.YYh, *.YYq), rinex_obs(*.YYo), and ubx(*.ubx) format are currently supported.
 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.
 __STRING__
 
 options = []
 
-# check options
-ARGV.reject!{|arg|
-  next false unless arg =~ /^--([^=]+)=?/
+# check options and file format
+files = ARGV.collect{|arg|
+  next [arg, nil] unless arg =~ /^--([^=]+)=?/
+  k, v = [$1.downcase.to_sym, $']
+  next [v, k] if [:rinex_nav, :rinex_obs, :ubx].include?(k) # file type
   options << [$1.to_sym, $']
-  true
-}
-
-# Check file existence
-ARGV.each{|arg|
-  raise "File not found: #{arg}" unless File::exist?(arg)
+  nil
+}.compact
+
+# Check file existence and extension
+files.collect!{|fname, ftype|
+  raise "File not found: #{fname}" unless File::exist?(fname)
+  ftype ||= case fname
+  when /\.\d{2}[nhq]$/; :rinex_nav
+  when /\.\d{2}o$/; :rinex_obs
+  when /\.ubx$/; :ubx
+  else
+    raise "Format cannot be guessed, use --(format, ex. rinex_nav)=#{fname}"
+  end
+  [fname, ftype]
 }
 
 rcv = GPS_PVT::Receiver::new(options)
@@ -30,17 +42,14 @@ rcv = GPS_PVT::Receiver::new(options)
 puts rcv.header
 
 # parse RINEX NAV
-ARGV.reject!{|arg|
-  next false unless arg =~ /\.\d{2}[nq]$/
-  rcv.parse_rinex_nav(arg)
+files.each{|fname, ftype|
+  rcv.parse_rinex_nav(fname) if ftype == :rinex_nav
 }
 
 # other files
-ARGV.each{|arg|
-  case arg
-  when /\.ubx$/
-    rcv.parse_ubx(arg)
-  when /\.\d{2}o$/
-    rcv.parse_rinex_obs(arg)
+files.each{|fname, ftype|
+  case ftype
+  when :ubx; rcv.parse_ubx(fname)
+  when :rinex_obs; rcv.parse_rinex_obs(fname)
   end
 }

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -2584,7 +2584,11 @@ struct GPS_Solver
     if(prn > 0 && prn <= 32){return gps.solver;}
     if(prn >= 120 && prn <= 158){return sbas.solver;}
     if(prn > 192 && prn <= 202){return gps.solver;}
-    return *this;
+    // call order: base_t::solve => this returned by select() 
+    //     => relative_property() => select_solver()
+    // For not supported satellite, call loop prevention is required.
+    static const base_t dummy; 
+    return dummy;
   }
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
@@ -2596,9 +2600,7 @@ struct GPS_Solver
   virtual typename base_t::xyz_t *satellite_position(
       const typename base_t::prn_t &prn,
       const typename base_t::gps_time_t &time,
-      typename base_t::xyz_t &res) const {
-    return select_solver(prn).satellite_position(prn, time, res);
-  }
+      typename base_t::xyz_t &res) const;
   virtual bool update_position_solution(
       const typename base_t::geometric_matrices_t &geomat,
       typename base_t::user_pvt_t &res) const;
@@ -3200,11 +3202,8 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
 
 SWIGINTERN int GPS_SpaceNode_Sl_double_Sg__read(GPS_SpaceNode< double > *self,char const *fname){
     std::fstream fin(fname, std::ios::in | std::ios::binary);
-    typename RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {
-      self, // GPS
-      NULL, // SBAS
-      self, // QZSS
-    };
+    typename RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {self};
+    space_nodes.qzss = self;
     return RINEX_NAV_Reader<double>::read_all(fin, space_nodes);
   }
 SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_alpha(GPS_Ionospheric_UTC_Parameters< double > *self,double const values[4]){
@@ -3593,6 +3592,18 @@ SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GPS_Ephemeris<
 
         return SWIG_ERROR;
       }
+
+      template <>
+      VALUE from(const GPS_Measurement<double>::items_t::mapped_type &val) {
+        VALUE per_sat(rb_hash_new());
+        for(typename GPS_Measurement<double>::items_t::mapped_type::const_iterator 
+              it(val.begin()), it_end(val.end());
+            it != it_end; ++it){
+          rb_hash_aset(per_sat, SWIG_From_int  (it->first), swig::from(it->second));
+        }
+        return per_sat;
+      }
+
     }
   
 SWIGINTERN void GPS_Measurement_Sl_double_Sg__each(GPS_Measurement< double > const *self){
@@ -3618,13 +3629,7 @@ SWIGINTERN VALUE GPS_Measurement_Sl_double_Sg__to_hash(GPS_Measurement< double >
     for(typename GPS_Measurement<double>::items_t::const_iterator
           it(self->items.begin()), it_end(self->items.end());
         it != it_end; ++it){
-      VALUE per_sat(rb_hash_new());
-      rb_hash_aset(res, SWIG_From_int  (it->first), per_sat);
-      for(typename GPS_Measurement<double>::items_t::mapped_type::const_iterator 
-            it2(it->second.begin()), it2_end(it->second.end());
-          it2 != it2_end; ++it2){
-        rb_hash_aset(per_sat, SWIG_From_int  (it2->first), swig::from(it2->second));
-      }
+      rb_hash_aset(res, SWIG_From_int  (it->first), swig::from(it->second));
     }
     return res;
   }
@@ -3648,16 +3653,16 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
 }
 
     template <>
-    typename GPS_Solver<double>::base_t::relative_property_t
+    GPS_Solver<double>::base_t::relative_property_t
         GPS_Solver<double>::relative_property(
-          const typename GPS_Solver<double>::base_t::prn_t &prn,
-          const typename GPS_Solver<double>::base_t::measurement_t::mapped_type &measurement,
-          const typename GPS_Solver<double>::base_t::float_t &receiver_error,
-          const typename GPS_Solver<double>::base_t::gps_time_t &time_arrival,
-          const typename GPS_Solver<double>::base_t::pos_t &usr_pos,
-          const typename GPS_Solver<double>::base_t::xyz_t &usr_vel) const {
+          const GPS_Solver<double>::base_t::prn_t &prn,
+          const GPS_Solver<double>::base_t::measurement_t::mapped_type &measurement,
+          const GPS_Solver<double>::base_t::float_t &receiver_error,
+          const GPS_Solver<double>::base_t::gps_time_t &time_arrival,
+          const GPS_Solver<double>::base_t::pos_t &usr_pos,
+          const GPS_Solver<double>::base_t::xyz_t &usr_vel) const {
       union {
-        typename base_t::relative_property_t prop;
+        base_t::relative_property_t prop;
         double values[7];
       } res = {
           select_solver(prn).relative_property(
@@ -3679,6 +3684,7 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
               swig::from(res.prop.los_neg[0]),
               swig::from(res.prop.los_neg[1]),
               swig::from(res.prop.los_neg[2])),
+            swig::from(measurement), // measurement => Hash
             swig::from(receiver_error), // receiver_error
             SWIG_NewPointerObj( // time_arrival
               new base_t::gps_time_t(time_arrival), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN),
@@ -3709,15 +3715,15 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
     }
     template <>
     bool GPS_Solver<double>::update_position_solution(
-        const typename GPS_Solver<double>::base_t::geometric_matrices_t &geomat,
-        typename GPS_Solver<double>::base_t::user_pvt_t &res) const {
+        const GPS_Solver<double>::base_t::geometric_matrices_t &geomat,
+        GPS_Solver<double>::base_t::user_pvt_t &res) const {
 
       do{
         static const VALUE key(ID2SYM(rb_intern("update_position_solution")));
         VALUE hook(rb_hash_lookup(hooks, key));
         if(NIL_P(hook)){break;}
-        typename base_t::geometric_matrices_t &geomat_(
-            const_cast< typename base_t::geometric_matrices_t & >(geomat));
+        base_t::geometric_matrices_t &geomat_(
+            const_cast< base_t::geometric_matrices_t & >(geomat));
         VALUE values[] = {
             SWIG_NewPointerObj(&geomat_.G,
               SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
@@ -3730,6 +3736,51 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
 
       return super_t::update_position_solution(geomat, res);
     }
+    template <>
+    GPS_Solver<double>::base_t::xyz_t *GPS_Solver<double>::satellite_position(
+        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));
+
+      do{
+        static const VALUE key(ID2SYM(rb_intern("satellite_position")));
+        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);
+
+      return res;
+    }
   
 SWIGINTERN unsigned int SBAS_Ephemeris_Sl_double_Sg__set_svid(SBAS_Ephemeris< double > *self,unsigned int const &v){
   return self->svid = v;
@@ -3836,7 +3887,8 @@ SWIGINTERN SBAS_Ephemeris< double > SBAS_SpaceNode_Sl_double_Sg__ephemeris(SBAS_
   }
 SWIGINTERN int SBAS_SpaceNode_Sl_double_Sg__read(SBAS_SpaceNode< double > *self,char const *fname){
     std::fstream fin(fname, std::ios::in | std::ios::binary);
-    RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {NULL, self};
+    RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {NULL};
+    space_nodes.sbas = self;
     return RINEX_NAV_Reader<double>::read_all(fin, space_nodes);
   }
 SWIGINTERN int SBAS_SpaceNode_Sl_double_Sg__decode_message__SWIG_2(SBAS_SpaceNode< double > *self,unsigned int const buf[8],int const &prn,GPS_Time< double > const &t_reception,bool const &LNAV_VNAV_LP_LPV_approach=false){

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

@@ -395,10 +395,11 @@ protected:
      * @return transformed design matrix G'
      */
     static matrix_t rotate_G(const MatrixT &G_, const matrix_t &rotation_matrix){
-      matrix_t res(G_.rows(), 4);
-      res.partial(G_.rows(), 3).replace(
-          G_.partial(G_.rows(), 3) * rotation_matrix.transpose());
-      res.partial(G_.rows(), 1, 0, 3).replace(G_.partial(G_.rows(), 1, 0, 3));
+      unsigned int r(G_.rows()), c(G_.columns()); // Normally c=4
+      matrix_t res(r, c);
+      res.partial(r, 3).replace(
+          G_.partial(r, 3) * rotation_matrix.transpose());
+      res.partial(r, c - 3, 0, 3).replace(G_.partial(r, c - 3, 0, 3));
       return res;
     }
 
@@ -425,14 +426,16 @@ protected:
      * @see rotate_G
      */
     static matrix_t rotate_C(const matrix_t &C, const matrix_t &rotation_matrix){
-      matrix_t res(4, 4);
+      unsigned int n(C.rows()); // Normally n=4
+      matrix_t res(n, n);
       res.partial(3, 3).replace( // upper left
           rotation_matrix * C.partial(3, 3) * rotation_matrix.transpose());
-      res.partial(3, 1, 0, 3).replace( // upper right
-          rotation_matrix * C.partial(3, 1, 0, 3));
-      res.partial(1, 3, 3, 0).replace( // lower left
-          C.partial(1, 3, 3, 0) * rotation_matrix.transpose());
-      res(3, 3) = C(3, 3); // lower right
+      res.partial(3, n - 3, 0, 3).replace( // upper right
+          rotation_matrix * C.partial(3, n - 3, 0, 3));
+      res.partial(n - 3, 3, 3, 0).replace( // lower left
+          C.partial(n - 3, 3, 3, 0) * rotation_matrix.transpose());
+      res.partial(n - 3, n - 3, 3, 3).replace( // lower right
+          C.partial(n - 3, n - 3, 3, 3));
       return res;
     }
     /**
@@ -470,11 +473,10 @@ protected:
      * @see rotate_G
      */
     static matrix_t rotate_S(const matrix_t &S, const matrix_t &rotation_matrix){
-      matrix_t res(4, S.columns());
-      res.partial(3, S.columns()).replace(rotation_matrix * S.partial(3, S.columns()));
-      for(unsigned int j(0), j_end(S.columns()); j < j_end; ++j){
-        res(3, j) = S(3, j);
-      }
+      unsigned int r(S.rows()), c(S.columns()); // Normally r=4
+      matrix_t res(r, c);
+      res.partial(3, c).replace(rotation_matrix * S.partial(3, c));
+      res.partial(r - 3, c, 3, 0).replace(S.partial(r - 3, c, 3, 0));
       return res;
     }
     /**
@@ -537,7 +539,7 @@ protected:
     partial_t partial(unsigned int size) const {
       if(size >= G.rows()){size = G.rows();}
       return partial_t(
-          G.partial(size, 4), W.partial(size, size), delta_r.partial(size, 1));
+          G.partial(size, G.columns()), W.partial(size, size), delta_r.partial(size, 1));
     }
     typedef linear_solver_t<typename MatrixT::circular_t> exclude_t;
     exclude_t exclude(const unsigned int &row) const {
@@ -545,14 +547,16 @@ protected:
       if(size >= 1){size--;}
       // generate matrices having circular view
       return exclude_t(
-          G.circular(offset, 0, size, 4),
+          G.circular(offset, 0, size, G.columns()),
           W.circular(offset, offset, size, size),
           delta_r.circular(offset, 0, size, 1));
     }
     template <class MatrixT2>
     void copy_G_W_row(const linear_solver_t<MatrixT2> &src,
         const unsigned int &i_src, const unsigned int &i_dst){
-      for(unsigned int j(0); j < 4; ++j){
+      unsigned int c_dst(G.columns()), c_src(src.G.columns()),
+          c(c_dst > c_src ? c_src : c_dst); // Normally c=4
+      for(unsigned int j(0); j < c; ++j){
         G(i_dst, j) = src.G(i_src, j);
       }
       W(i_dst, i_dst) = src.W(i_src, i_src);
@@ -561,9 +565,12 @@ protected:
 
   struct geometric_matrices_t : public linear_solver_t<matrix_t> {
     typedef linear_solver_t<matrix_t> super_t;
-    geometric_matrices_t(const unsigned int &capacity)
+    geometric_matrices_t(
+        const unsigned int &capacity,
+        const unsigned int &estimate_system_differences = 0)
         : super_t(
-          matrix_t(capacity, 4), matrix_t(capacity, capacity), matrix_t(capacity, 1)) {
+          matrix_t(capacity, 4 + estimate_system_differences),
+          matrix_t(capacity, capacity), matrix_t(capacity, 1)) {
       for(unsigned int i(0); i < capacity; ++i){
         super_t::G(i, 3) = 1;
       }

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

@@ -846,8 +846,10 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
     };
 
     static int read_all(std::istream &in, space_node_list_t &space_nodes = {0}){
-      int res(-1);
       RINEX_NAV_Reader reader(in);
+      if(reader.version_type.file_type != version_type_t::FTYPE_NAVIGATION){
+        return -1;
+      }
       if(space_nodes.gps){
         (reader.version_type.version >= 300)
             ? reader.extract_iono_utc_v3(*space_nodes.gps)
@@ -857,7 +859,7 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
           && (reader.version_type.version >= 302)){
         reader.extract_iono_utc_v3(*space_nodes.qzss);
       }
-      res++;
+      int res(0);
       for(; reader.has_next(); reader.next()){
         switch(reader.sys_of_msg){
           case super_t::version_type_t::SYS_GPS:
@@ -1140,6 +1142,9 @@ class RINEX_OBS_Reader : public RINEX_Reader<> {
     RINEX_OBS_Reader(std::istream &in)
         : super_t(in, self_t::modify_header),
           obs_types() {
+      if(super_t::version_type.file_type != version_type_t::FTYPE_OBSERVATION){
+        return;
+      }
       typedef super_t::header_t::const_iterator it_t;
       typedef super_t::header_t::mapped_type::const_iterator it2_t;
       it_t it;
@@ -1860,8 +1865,13 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
           version, super_t::version_type_t::FTYPE_NAVIGATION, sys));
     }
 
+    struct space_node_list_t {
+      const space_node_t *gps;
+      const SBAS_SpaceNode<FloatT> *sbas;
+      const space_node_t *qzss;
+    };
     int write_all(
-        const typename reader_t::space_node_list_t &space_nodes,
+        const space_node_list_t &space_nodes,
         const int &version = 304){
       int res(-1);
       int systems(0);
@@ -1966,12 +1976,12 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
     }
     static int write_all(
         std::ostream &out,
-        const typename reader_t::space_node_list_t &space_nodes,
+        const space_node_list_t &space_nodes,
         const int &version = 304){
       return RINEX_NAV_Writer(out).write_all(space_nodes, version);
     }
     int write_all(const space_node_t &space_node, const int &version = 304){
-      const typename reader_t::space_node_list_t list = {&const_cast<space_node_t &>(space_node)};
+      space_node_list_t list = {&space_node};
       return write_all(list, version);
     }
     static int write_all(std::ostream &out, const space_node_t &space_node, const int &version = 304){

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

@@ -417,11 +417,8 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
   %ignore tropo_correction() const;
   int read(const char *fname) {
     std::fstream fin(fname, std::ios::in | std::ios::binary);
-    typename RINEX_NAV_Reader<FloatT>::space_node_list_t space_nodes = {
-      self, // GPS
-      NULL, // SBAS
-      self, // QZSS
-    };
+    typename RINEX_NAV_Reader<FloatT>::space_node_list_t space_nodes = {self};
+    space_nodes.qzss = self;
     return RINEX_NAV_Reader<FloatT>::read_all(fin, space_nodes);
   }
 }
@@ -476,7 +473,8 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
   }
   int read(const char *fname) {
     std::fstream fin(fname, std::ios::in | std::ios::binary);
-    RINEX_NAV_Reader<FloatT>::space_node_list_t space_nodes = {NULL, self};
+    RINEX_NAV_Reader<FloatT>::space_node_list_t space_nodes = {NULL};
+    space_nodes.sbas = self;
     return RINEX_NAV_Reader<FloatT>::read_all(fin, space_nodes);
   }
   MAKE_ARRAY_INPUT(const unsigned int, buf, SWIG_AsVal(unsigned int));
@@ -662,23 +660,6 @@ struct GPS_User_PVT
       }
     }
   }
-#ifdef SWIGRUBY
-  VALUE to_hash() const {
-    VALUE res(rb_hash_new());
-    for(typename GPS_Measurement<FloatT>::items_t::const_iterator
-          it(self->items.begin()), it_end(self->items.end());
-        it != it_end; ++it){
-      VALUE per_sat(rb_hash_new());
-      rb_hash_aset(res, SWIG_From(int)(it->first), per_sat);
-      for(typename GPS_Measurement<FloatT>::items_t::mapped_type::const_iterator 
-            it2(it->second.begin()), it2_end(it->second.end());
-          it2 != it2_end; ++it2){
-        rb_hash_aset(per_sat, SWIG_From(int)(it2->first), swig::from(it2->second));
-      }
-    }
-    return res;
-  }
-#endif
   %fragment(SWIG_Traits_frag(GPS_Measurement<FloatT>), "header",
       fragment=SWIG_Traits_frag(FloatT)){
     namespace swig {
@@ -762,9 +743,32 @@ struct GPS_User_PVT
 #endif
         return SWIG_ERROR;
       }
+#ifdef SWIGRUBY
+      template <>
+      VALUE from(const GPS_Measurement<FloatT>::items_t::mapped_type &val) {
+        VALUE per_sat(rb_hash_new());
+        for(typename GPS_Measurement<FloatT>::items_t::mapped_type::const_iterator 
+              it(val.begin()), it_end(val.end());
+            it != it_end; ++it){
+          rb_hash_aset(per_sat, SWIG_From(int)(it->first), swig::from(it->second));
+        }
+        return per_sat;
+      }
+#endif
     }
   }
   %fragment(SWIG_Traits_frag(GPS_Measurement<FloatT>));
+#ifdef SWIGRUBY
+  VALUE to_hash() const {
+    VALUE res(rb_hash_new());
+    for(typename GPS_Measurement<FloatT>::items_t::const_iterator
+          it(self->items.begin()), it_end(self->items.end());
+        it != it_end; ++it){
+      rb_hash_aset(res, SWIG_From(int)(it->first), swig::from(it->second));
+    }
+    return res;
+  }
+#endif
   %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) const GPS_Measurement<FloatT> & {
     $1 = SWIG_CheckState(SWIG_ConvertPtr($input, (void **)0, $1_descriptor, 0))
         || swig::check<GPS_Measurement<FloatT> >($input);
@@ -938,18 +942,19 @@ struct SBAS_SolverOptions
   %ignore mark;
   %fragment("hook"{GPS_Solver<FloatT>}, "header",
       fragment=SWIG_From_frag(int),
-      fragment=SWIG_Traits_frag(FloatT)){
+      fragment=SWIG_Traits_frag(FloatT),
+      fragment=SWIG_Traits_frag(GPS_Measurement<FloatT>)){
     template <>
-    typename GPS_Solver<FloatT>::base_t::relative_property_t
+    GPS_Solver<FloatT>::base_t::relative_property_t
         GPS_Solver<FloatT>::relative_property(
-          const typename GPS_Solver<FloatT>::base_t::prn_t &prn,
-          const typename GPS_Solver<FloatT>::base_t::measurement_t::mapped_type &measurement,
-          const typename GPS_Solver<FloatT>::base_t::float_t &receiver_error,
-          const typename GPS_Solver<FloatT>::base_t::gps_time_t &time_arrival,
-          const typename GPS_Solver<FloatT>::base_t::pos_t &usr_pos,
-          const typename GPS_Solver<FloatT>::base_t::xyz_t &usr_vel) const {
+          const GPS_Solver<FloatT>::base_t::prn_t &prn,
+          const GPS_Solver<FloatT>::base_t::measurement_t::mapped_type &measurement,
+          const GPS_Solver<FloatT>::base_t::float_t &receiver_error,
+          const GPS_Solver<FloatT>::base_t::gps_time_t &time_arrival,
+          const GPS_Solver<FloatT>::base_t::pos_t &usr_pos,
+          const GPS_Solver<FloatT>::base_t::xyz_t &usr_vel) const {
       union {
-        typename base_t::relative_property_t prop;
+        base_t::relative_property_t prop;
         FloatT values[7];
       } res = {
           select_solver(prn).relative_property(
@@ -971,6 +976,7 @@ struct SBAS_SolverOptions
               swig::from(res.prop.los_neg[0]),
               swig::from(res.prop.los_neg[1]),
               swig::from(res.prop.los_neg[2])),
+            swig::from(measurement), // measurement => Hash
             swig::from(receiver_error), // receiver_error
             SWIG_NewPointerObj( // time_arrival
               new base_t::gps_time_t(time_arrival), $descriptor(GPS_Time<FloatT> *), SWIG_POINTER_OWN),
@@ -1001,15 +1007,15 @@ struct SBAS_SolverOptions
     }
     template <>
     bool GPS_Solver<FloatT>::update_position_solution(
-        const typename GPS_Solver<FloatT>::base_t::geometric_matrices_t &geomat,
-        typename GPS_Solver<FloatT>::base_t::user_pvt_t &res) const {
+        const GPS_Solver<FloatT>::base_t::geometric_matrices_t &geomat,
+        GPS_Solver<FloatT>::base_t::user_pvt_t &res) const {
 #ifdef SWIGRUBY
       do{
         static const VALUE key(ID2SYM(rb_intern("update_position_solution")));
         VALUE hook(rb_hash_lookup(hooks, key));
         if(NIL_P(hook)){break;}
-        typename base_t::geometric_matrices_t &geomat_(
-            %const_cast(geomat, typename base_t::geometric_matrices_t &));
+        base_t::geometric_matrices_t &geomat_(
+            %const_cast(geomat, base_t::geometric_matrices_t &));
         VALUE values[] = {
             SWIG_NewPointerObj(&geomat_.G,
               $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0),
@@ -1022,6 +1028,51 @@ struct SBAS_SolverOptions
 #endif
       return super_t::update_position_solution(geomat, res);
     }
+    template <>
+    GPS_Solver<FloatT>::base_t::xyz_t *GPS_Solver<FloatT>::satellite_position(
+        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));
+#ifdef SWIGRUBY
+      do{
+        static const VALUE key(ID2SYM(rb_intern("satellite_position")));
+        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);
+#endif
+      return res;
+    }
   }
   %fragment("hook"{GPS_Solver<FloatT>});
 }
@@ -1069,7 +1120,11 @@ struct GPS_Solver
     if(prn > 0 && prn <= 32){return gps.solver;}
     if(prn >= 120 && prn <= 158){return sbas.solver;}
     if(prn > 192 && prn <= 202){return gps.solver;}
-    return *this;
+    // call order: base_t::solve => this returned by select() 
+    //     => relative_property() => select_solver()
+    // For not supported satellite, call loop prevention is required.
+    static const base_t dummy; 
+    return dummy;
   }
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
@@ -1081,9 +1136,7 @@ struct GPS_Solver
   virtual typename base_t::xyz_t *satellite_position(
       const typename base_t::prn_t &prn,
       const typename base_t::gps_time_t &time,
-      typename base_t::xyz_t &res) const {
-    return select_solver(prn).satellite_position(prn, time, res);
-  }
+      typename base_t::xyz_t &res) 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

@@ -339,8 +339,9 @@ __RINEX_OBS_TEXT__
       sn.read(input[:rinex_nav])
       t_meas = GPS::Time::new(1849, 172413)
       sn.update_all_ephemeris(t_meas)
-      solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+      solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
         expect(input[:measurement]).to include(prn)
+        expect(meas).to be_a_kind_of(Hash)
         expect(t_arv).to be_a_kind_of(GPS::Time)
         expect(usr_pos).to be_a_kind_of(Coordinate::XYZ)
         expect(usr_vel).to be_a_kind_of(Coordinate::XYZ)
@@ -354,6 +355,22 @@ __RINEX_OBS_TEXT__
         }
         mat_G, mat_W, mat_delta_r = mats
       }
+      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

@@ -130,7 +130,7 @@ class Receiver
 
   def initialize(options = {})
     @solver = GPS::Solver::new
-    @solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+    @solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
       rel_prop[0] = 1 if rel_prop[0] > 0 # weight = 1
       rel_prop
     }
@@ -148,7 +148,7 @@ class Receiver
       when :weight
         case v.to_sym
         when :elevation # (same as underneath C++ library)
-          @solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+          @solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
             if rel_prop[0] > 0 then
               elv = Coordinate::ENU::relative_rel(
                   Coordinate::XYZ::new(*rel_prop[4..6]), usr_pos).elevation
@@ -477,8 +477,15 @@ class Receiver
   end
   
   def parse_rinex_nav(fname)
-    $stderr.puts "Read RINEX NAV file (%s): %d items."%[
-        fname, @solver.gps_space_node.read(fname)]
+    items = [
+      @solver.gps_space_node,
+      @solver.sbas_space_node,
+    ].inject(0){|res, sn|
+      loaded_items = sn.send(:read, fname)
+      raise "Format error! (Not RINEX) #{fname}" if loaded_items < 0
+      res + loaded_items
+    }
+    $stderr.puts "Read RINEX NAV file (%s): %d items."%[fname, items]
   end
   
   def parse_rinex_obs(fname, &b)
@@ -515,7 +522,8 @@ class Receiver
         when 'J'; prn += 192
         else; next
         end
-        (types[sys] || []).each{|i, type_|
+        types[sys] = (types[' '] || []) unless types[sys]
+        types[sys].each{|i, type_|
           meas.add(prn, type_, v[i][0]) if v[i]
         }
       }

data/lib/gps_pvt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-26 00:00:00.000000000 Z
+date: 2022-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake