gps_pvt 0.8.0 → 0.8.2

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

@@ -29,6 +29,7 @@
 #include "navigation/GPS_Solver_Base.h"
 #include "navigation/GPS_Solver.h"
 #include "navigation/GPS_Solver_RAIM.h"
+#include "navigation/GPS_Solver_MultiFrequency.h"
 #include "navigation/SBAS_Solver.h"
 #include "navigation/GLONASS_Solver.h"
 
@@ -273,6 +274,25 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
     (typename GPS_SpaceNode<FloatT>::Ionospheric_UTC_Parameters &)res = raw;
     return res;
   }
+  %typemap(in,numinputs=0) unsigned int buf_brdc[ANY] (unsigned int temp[$1_dim0] = {0}) "$1 = temp;"
+  %typemap(argout) unsigned int buf_brdc[ANY] {
+    for(int i(0); i < $1_dim0; ++i){
+      %append_output(SWIG_From(unsigned int)(($1)[i]));
+    }
+  }
+  /**
+   * Return broadcasted raw data related to ionospheric and UTC parameters.
+   * @param buf_brdc pointer to store raw data of subframe 4 page 18.
+   * Each 30bit length word (MSB 2 bits are padding) is stored in each successive address of the pointer.
+   * @param t GPS time at broadcasting
+   */
+  void dump(unsigned int buf_brdc[10], const GPS_Time<FloatT> &t){
+    typedef typename GPS_SpaceNode<FloatT>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    dump_t::how_set(buf_brdc, t);
+    GPS_SpaceNode<FloatT>::Ionospheric_UTC_Parameters::raw_t raw;
+    (raw = *self).dump<2, 0>(buf_brdc);
+  }
 }
 
 %inline %{
@@ -287,6 +307,11 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
         || (this->iode != this->iode_subframe3)
         || ((this->iodc & 0xFF) != this->iode));
   }
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return is_consistent() && GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
+  }
+  GPS_Time<FloatT> t_clock() const {return GPS_Time<FloatT>(this->WN, this->t_oc);}
+  GPS_Time<FloatT> t_ephemeris() const {return GPS_Time<FloatT>(this->WN, this->t_oe);}
   GPS_Ephemeris() : GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {
     invalidate();
   }
@@ -303,7 +328,7 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
   MAKE_ACCESSOR(svid, unsigned int);
           
   MAKE_ACCESSOR(WN, unsigned int);
-  MAKE_ACCESSOR(URA, int);
+  MAKE_ACCESSOR(URA, FloatT);
   MAKE_ACCESSOR(SV_health, unsigned int);
   MAKE_ACCESSOR(iodc, int);
   MAKE_ACCESSOR(t_GD, FloatT);
@@ -384,6 +409,83 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
         break;
     }
   }
+  %apply unsigned int buf_brdc[ANY] {
+      unsigned int buf_sf1[10], unsigned int buf_sf2[10], unsigned int buf_sf3[10]};
+  /**
+   * Return broadcasted raw data of ephemeris data.
+   * @param buf_sf1 pointer to store raw data of subframe 1.
+   * Each 30bit length word (MSB 2 bits are padding) is stored in each successive address of the pointer.
+   * @param buf_sf2 pointer to store raw data of subframe 2. Its structue is same as sf1.
+   * @param buf_sf3 pointer to store raw data of subframe 3. Its structue is same as sf1.
+   * @param t GPS time at broadcasting
+   */
+  void dump(
+      unsigned int buf_sf1[10], unsigned int buf_sf2[10], unsigned int buf_sf3[10],
+      const GPS_Time<FloatT> &t){
+    typedef typename GPS_SpaceNode<FloatT>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::raw_t raw;
+    raw = *self;
+    unsigned int *buf[10] = {buf_sf1, buf_sf2, buf_sf3};
+    for(int i(0); i < 3; ++i){
+      dump_t::how_set(buf[i], t);
+      raw.dump<2, 0>(buf[i], i + 1);
+    }
+  }
+  int parse_almanac(const unsigned int buf[10]){
+    typedef GPS_SpaceNode<FloatT>::BroadcastedMessage<unsigned int, 30> parse_t;
+    switch(parse_t::subframe_id(buf)){
+      case 4:
+      case 5:
+        break;
+      default: return -1;
+    }
+    typedef GPS_SpaceNode<FloatT>::SatelliteProperties::Almanac almanac_t;
+    almanac_t::raw_t raw;
+    switch(parse_t::data_id(buf)){
+      case 1: // GPS
+        raw.update<2, 0>(buf);
+        if((raw.svid < 1) || (raw.svid > 32)){return -1;}
+        break;
+      case 3: // QZSS
+        reinterpret_cast<QZSS_SpaceNode<FloatT>::SatelliteProperties::Almanac::raw_t &>(raw)
+            .update<2, 0>(buf);
+        if((raw.svid < 193) || (raw.svid > 202)){return -1;}
+        break;
+      default:
+        return -1;
+    }
+    almanac_t almanac;
+    *self = (GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris)(almanac = raw);
+    return self->svid;
+  }
+  /**
+   * Return broadcasted raw data of almanac data.
+   * @param buf_brdc pointer to store raw data of subframe 4 or 5.
+   * Each 30bit (MSB 2 bits are padding) length word is stored in each successive address of the pointer.
+   * @param t GPS time at broadcasting
+   * @param qzss_subframe if 4 or 5, this ephemeris is treated as QZSS, otherwise GPS (default).
+   */
+  void dump_almanac(
+      unsigned int buf_brdc[10], const GPS_Time<FloatT> &t,
+      const unsigned int &qzss_subframe = 0){
+    typedef typename GPS_SpaceNode<FloatT>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    dump_t::how_set(buf_brdc, t);
+    typedef GPS_SpaceNode<FloatT>::SatelliteProperties::Almanac almanac_t;
+    almanac_t almanac;
+    almanac_t::raw_t raw;
+    raw = (almanac = *self);
+    switch(qzss_subframe){
+      case 4:
+      case 5:
+        reinterpret_cast<QZSS_SpaceNode<FloatT>::SatelliteProperties::Almanac::raw_t &>(raw)
+            .dump<2, 0>(buf_brdc, qzss_subframe);
+        break;
+      default:
+        raw.dump<2, 0>(buf_brdc);
+    }
+  }
   %typemap(out) constellation_res_t {
     %append_output(SWIG_NewPointerObj((new System_XYZ<FloatT, WGS84>($1.position)), 
         $descriptor(System_XYZ<FloatT, WGS84> *), SWIG_POINTER_OWN));
@@ -402,6 +504,7 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
   }
 #if defined(SWIGRUBY)
   %rename("consistent?") is_consistent;
+  %rename("valid?") is_valid;
 #endif
 }
 
@@ -444,6 +547,10 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
   SBAS_Ephemeris() : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {}
   SBAS_Ephemeris(const typename SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris &eph) 
       : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris(eph) {}
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
+  }
+  GPS_Time<FloatT> t_applicable() const {return GPS_Time<FloatT>(this->WN, this->t_0);}
 };
 %}
 %extend SBAS_Ephemeris {
@@ -457,6 +564,18 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
   MAKE_ACCESSOR(ddx, FloatT); MAKE_ACCESSOR(ddy, FloatT); MAKE_ACCESSOR(ddz, FloatT);
   MAKE_ACCESSOR(a_Gf0, FloatT);
   MAKE_ACCESSOR(a_Gf1, FloatT);
+  /**
+   * Return broadcasted raw data of SBAS ephemeris
+   * @param buf_brdc pointer to store raw data of Type 9 message.
+   * 250 of 256 bits are effective, LSB 6 bits of last word are padding.
+   * @param preamble_idx index of preamble, 0(0x53), 1(0x9A), or 2(0xC6)
+   */
+  void dump(unsigned int buf_brdc[8], const unsigned int &preamble_idx = 0){
+    SBAS_SpaceNode<FloatT>::DataBlock::preamble_set2(buf_brdc, preamble_idx);
+    SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::raw_t raw;
+    (raw = *self).dump(buf_brdc);
+    SBAS_SpaceNode<FloatT>::DataBlock::parity_set(buf_brdc);
+  }
   typename GPS_Ephemeris<FloatT>::constellation_res_t constellation(
       const GPS_Time<FloatT> &t_tx, const FloatT &dt_transit = 0,
       const bool &with_velocity = true) const {
@@ -466,6 +585,9 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
         pv.position, pv.velocity, self->clock_error(t_tx), self->clock_error_dot(t_tx)};
     return res;
   }
+#if defined(SWIGRUBY)
+  %rename("valid?") is_valid;
+#endif
 }
 
 %extend SBAS_SpaceNode {
@@ -519,6 +641,9 @@ struct GLONASS_Ephemeris
   bool is_consistent() const {
     return has_string == 0x1F;
   }
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return is_consistent() && eph_t::is_valid(t);
+  }
   GLONASS_Ephemeris() : eph_t() {
     invalidate();
   }
@@ -607,6 +732,31 @@ struct GLONASS_Ephemeris
     self->has_string = has_string;
     return updated;
   }
+  %apply unsigned int buf_brdc[ANY] {
+      unsigned int buf_str1[3], unsigned int buf_str2[3], unsigned int buf_str3[3],
+      unsigned int buf_str4[3], unsigned int buf_str5[3]};
+  /**
+   * Return broadcasted raw data of GLONASS ephemeris data.
+   * @param buf_str1 pointer to store raw data of string 1.
+   * 85bit length data (LSB 11 bits are padding) is stored in successive address of the pointer.
+   * @param buf_str2 pointer to store raw data of string 2. Its structue is same as str1.
+   * @param buf_str3 pointer to store raw data of string 3. Its structue is same as str1.
+   * @param buf_str4 pointer to store raw data of string 4. Its structue is same as str1.
+   * @param buf_str5 pointer to store raw data of string 5. Its structue is same as str1.
+   * @param t GPS time at broadcasting
+   */
+  void dump(
+      unsigned int buf_str1[3], unsigned int buf_str2[3], unsigned int buf_str3[3],
+      unsigned int buf_str4[3], unsigned int buf_str5[3],
+      const GPS_Time<FloatT> &t){
+    typename GLONASS_Ephemeris<FloatT>::eph_t::raw_t raw;
+    raw = *self;
+    unsigned int *buf[4] = {buf_str1, buf_str2, buf_str3, buf_str4};
+    for(int i(0); i < 4; ++i){
+      raw.GLONASS_Ephemeris<FloatT>::Ephemeris::raw_t::dump<0, 0>(buf[i], i + 1);
+    }
+    raw.GLONASS_Ephemeris<FloatT>::TimeProperties::raw_t::dump<0, 0>(buf_str5);
+  }
   typename GPS_Ephemeris<FloatT>::constellation_res_t constellation(
       const GPS_Time<FloatT> &t_tx, const FloatT &dt_transit = 0) const {
     typename GPS_SpaceNode<FloatT>::SatelliteProperties::constellation_t pv(
@@ -617,6 +767,7 @@ struct GLONASS_Ephemeris
   }
 #if defined(SWIGRUBY)
   %rename("consistent?") is_consistent;
+  %rename("valid?") is_valid;
   %rename("in_range?") is_in_range;
 #endif
   bool is_in_range(const GPS_Time<FloatT> &t) const {
@@ -969,6 +1120,16 @@ struct GPS_Measurement {
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
     L1_FREQUENCY,
+#define make_entry(key) L2CM_ ## key, L2CL_ ## key
+#define make_entry2(key) make_entry(key), make_entry(key ## _SIGMA)
+    make_entry2(PSEUDORANGE),
+    make_entry2(CARRIER_PHASE),
+    make_entry2(DOPPLER),
+    make_entry2(RANGE_RATE),
+    make_entry(SIGNAL_STRENGTH_dBHz),
+    make_entry(LOCK_SEC),
+#undef make_entry2
+#undef make_entry
     ITEMS_PREDEFINED,
   };
   void add(const int &prn, const int &key, const FloatT &value){
@@ -992,7 +1153,7 @@ const type &get_ ## name () const {
   MAKE_ACCESSOR2(residual_mask, FloatT);
 #undef MAKE_ACCESSOR2
   MAKE_VECTOR2ARRAY(int);
-  %ignore cast_base;
+  %ignore cast_general;
 }
 %inline %{
 template <class FloatT>
@@ -1006,17 +1167,23 @@ struct GPS_SolverOptions_Common {
 %extend GPS_SolverOptions {
   %ignore base_t;
   %ignore cast_general;
+#ifdef SWIGRUBY
+  %rename("exclude_L2C?") get_exclude_L2C;
+  %rename("exclude_L2C=") set_exclude_L2C;
+#endif
   MAKE_VECTOR2ARRAY(int);
 }
 %inline %{
 template <class FloatT>
 struct GPS_SolverOptions 
-    : public GPS_SinglePositioning<FloatT>::options_t, 
+    : public GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t, 
     GPS_SolverOptions_Common<FloatT> {
-  typedef typename GPS_SinglePositioning<FloatT>::options_t base_t;
+  typedef typename GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t base_t;
   void exclude(const int &prn){base_t::exclude_prn.set(prn);}
   void include(const int &prn){base_t::exclude_prn.reset(prn);}
   std::vector<int> excluded() const {return base_t::exclude_prn.excluded();}
+  bool get_exclude_L2C() {return base_t::exclude_L2C;}
+  bool set_exclude_L2C(const bool &b) {return base_t::exclude_L2C = b;}
   GPS_Solver_GeneralOptions<FloatT> *cast_general(){return this;}
   const GPS_Solver_GeneralOptions<FloatT> *cast_general() const {return this;}
 };
@@ -1081,6 +1248,44 @@ struct GPS_RangeCorrector
 };
 }
 
+%{
+template <class BaseT, class HookT>
+struct HookableSolver : public BaseT {
+  typedef BaseT base_t;
+  HookT *hook;
+  template <class ArgT>
+  HookableSolver(const ArgT &);
+  virtual typename base_t::relative_property_t relative_property(
+      const typename base_t::prn_t &prn,
+      const typename base_t::measurement_t::mapped_type &measurement,
+      const typename base_t::float_t &receiver_error,
+      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 {
+    typename base_t::relative_property_t res(
+        base_t::relative_property(
+          prn, measurement, receiver_error, time_arrival,
+          usr_pos, usr_vel));
+    if(hook){
+      res = hook->relative_property(
+          prn, measurement, receiver_error, time_arrival,
+          usr_pos, usr_vel,
+          res);
+    }
+    return res;
+  }
+  virtual typename base_t::satellite_t select_satellite(
+      const typename base_t::prn_t &prn,
+      const typename base_t::gps_time_t &time) const {
+    typename base_t::satellite_t res(base_t::select_satellite(prn, time));
+    if(hook){
+      res = hook->select_satellite(prn, time, res);
+    }
+    return res;
+  }
+};
+%}
+
 %extend GPS_Solver {
   %ignore super_t;
   %ignore base_t;
@@ -1090,7 +1295,7 @@ struct GPS_RangeCorrector
   %ignore sbas;
   %ignore glonass_t;
   %ignore glonass;
-  %ignore select_solver;
+  %ignore select;
   %ignore relative_property;
   %ignore select_satellite;
   %ignore update_position_solution;
@@ -1102,6 +1307,20 @@ struct GPS_RangeCorrector
       fragment=SWIG_From_frag(int),
       fragment=SWIG_Traits_frag(FloatT),
       fragment=SWIG_Traits_frag(GPS_Measurement<FloatT>)){
+    template <> template <>
+    HookableSolver<
+          GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+          GPS_Solver<FloatT> >
+        ::HookableSolver<GPS_SpaceNode<FloatT> >(const GPS_SpaceNode<FloatT> &sn)
+          : GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> >
+        ::HookableSolver<SBAS_SpaceNode<FloatT> >(const SBAS_SpaceNode<FloatT> &sn)
+          : SBAS_SinglePositioning<FloatT>(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> >
+        ::HookableSolver<GLONASS_SpaceNode<FloatT> >(const GLONASS_SpaceNode<FloatT> &sn)
+          : GLONASS_SinglePositioning<FloatT>(sn), hook(NULL) {}
     template <>
     GPS_Solver<FloatT>::base_t::relative_property_t
         GPS_Solver<FloatT>::relative_property(
@@ -1110,14 +1329,12 @@ struct GPS_RangeCorrector
           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 {
+          const GPS_Solver<FloatT>::base_t::xyz_t &usr_vel,
+          const GPS_Solver<FloatT>::base_t::relative_property_t &res_orig) const {
       union {
         base_t::relative_property_t prop;
         FloatT values[7];
-      } res = {
-          select_solver(prn).relative_property(
-            prn, measurement, receiver_error, time_arrival,
-            usr_pos, usr_vel)};
+      } res = {res_orig};
 #ifdef SWIGRUBY
       do{
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
@@ -1197,9 +1414,9 @@ struct GPS_RangeCorrector
     template <>
     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) const {
-      GPS_Solver<FloatT>::base_t::satellite_t res(
-          select_solver(prn).select_satellite(prn, time));
+        const GPS_Solver<FloatT>::base_t::gps_time_t &time,
+        const GPS_Solver<FloatT>::base_t::satellite_t &res_orig) const {
+      GPS_Solver<FloatT>::base_t::satellite_t res(res_orig);
 #ifdef SWIGRUBY
       if(!res.is_available()){
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
@@ -1396,7 +1613,9 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    GPS_SinglePositioning<FloatT> solver;
+    HookableSolver<
+        GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+        GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -1418,18 +1637,20 @@ struct GPS_Solver
         solver.satellites.impl_select = forward;
       }
     } ephemeris_proxy;
-    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {}
+    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {
+      options.exclude_L2C = true;
+    }
   } gps;
   struct sbas_t {
     SBAS_SpaceNode<FloatT> space_node;
     SBAS_SolverOptions<FloatT> options;
-    SBAS_SinglePositioning<FloatT> solver;
+    HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
     sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
   struct glonass_t {
     GLONASS_SpaceNode<FloatT> space_node;
     GLONASS_SolverOptions<FloatT> options;
-    GLONASS_SinglePositioning<FloatT> solver;
+    HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
     glonass_t() : space_node(), options(), solver(space_node) {}
   } glonass;
   SWIG_Object hooks;
@@ -1465,6 +1686,9 @@ struct GPS_Solver
         = sbas.solver.tropospheric_correction
         = glonass.solver.tropospheric_correction
         = tropospheric;
+    gps.solver.hook = this;
+    sbas.solver.hook = this;
+    glonass.solver.hook = this;
   }
   GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
   GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
@@ -1472,28 +1696,44 @@ struct GPS_Solver
   SBAS_SolverOptions<FloatT> &sbas_options() {return sbas.options;}
   GLONASS_SpaceNode<FloatT> &glonass_space_node() {return glonass.space_node;}
   GLONASS_SolverOptions<FloatT> &glonass_options() {return glonass.options;}
-  const base_t &select_solver(
+  const base_t &select(
       const typename base_t::prn_t &prn) const {
     if(prn > 0 && prn <= 32){return gps.solver;}
     if(prn >= 120 && prn <= 158){return sbas.solver;}
     if(prn > 192 && prn <= 202){return gps.solver;}
     if(prn > 0x100 && prn <= (0x100 + 24)){return glonass.solver;}
-    // 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;
+    return *this;
   }
+  // proxy of virtual functions
+  typename base_t::relative_property_t relative_property(
+      const typename base_t::prn_t &prn,
+      const typename base_t::measurement_t::mapped_type &measurement,
+      const typename base_t::float_t &receiver_error,
+      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 typename base_t::relative_property_t &orig) const;
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
       const typename base_t::measurement_t::mapped_type &measurement,
       const typename base_t::float_t &receiver_error,
       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;
+      const typename base_t::xyz_t &usr_vel) const {
+    return relative_property(
+        prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel,
+        super_t::relative_property(
+          prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel));
+  }
+  typename base_t::satellite_t select_satellite(
+      const typename base_t::prn_t &prn,
+      const typename base_t::gps_time_t &time,
+      const typename base_t::satellite_t &orig) const;
   virtual typename base_t::satellite_t select_satellite(
       const typename base_t::prn_t &prn,
-      const typename base_t::gps_time_t &time) const;
+      const typename base_t::gps_time_t &time) const {
+    return select_satellite(prn, time, super_t::select_satellite(prn, time));
+  }
   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

@@ -765,9 +765,70 @@ __RINEX_CLK_TEXT__
       [:alpha, :beta].each{|k|
         puts "Iono #{k}: #{sn.iono_utc.send(k)}"
       }
+      proc{|raw|
+        expect(raw.size).to eq(10)
+        puts "Raw(IONO): #{raw.collect{|v| "0x%08X" % [v]}.join(', ')}"
+        iono2 = GPS::Ionospheric_UTC_Parameters::parse(raw)
+        [:alpha, :beta].collect{|f|
+          sn.iono_utc.send(f).zip(iono2.send(f))
+        }.flatten(1).zip([-30, -27, -24, -24, 11, 14, 16, 16]).each{|(a, b), sf|
+          expect(a).to be_within((2 ** sf) * 2).of(b)
+        }
+        [
+          [:A1, 2 ** -50], [:A0, 2 ** -30],
+        ].each{|k, sf|
+          #p [k, sf.to_f, sn.iono_utc.send(k) - iono2.send(k), sn.iono_utc.send(k), iono2.send(k)]
+          expect(sn.iono_utc.send(k)).to be_within((sf || 1).to_f * 2).of(iono2.send(k))
+        }
+      }.call(sn.iono_utc.dump(t_meas))
       
       meas.each{|prn, k, v|
         eph = sn.ephemeris(prn)
+        expect(eph.valid?(t_meas)).to eq(true)
+        sc2rad = 3.1415926535898
+        proc{|raw|
+          expect(raw.size).to eq(30)
+          eph2 = GPS::Ephemeris::new
+          raw.each_slice(10).with_index{|subframe, i|
+            puts "Raw(PRN:#{prn},SF:#{i+1}): #{subframe.collect{|v| "0x%08X" % [v]}.join(', ')}"
+            eph2.parse(subframe)
+          }
+          expect(eph.WN % 1024).to be(eph2.WN % 1024)
+          [
+            #:URA,
+            :SV_health, :iodc,
+            [:t_GD, 2 ** -31], [:t_oc, 2 ** 4], # SF1
+            [:a_f0, 2 ** -31], [:a_f1, 2 ** -43], [:a_f2, 2 ** -55], # SF1
+            :iode, # SF2
+            [:c_rs, 2 ** -5], [:delta_n, sc2rad * 2 ** -43], # SF2
+            [:M0, sc2rad * 2 ** -31], [:c_uc, 2 ** -29], [:e, 2 ** -33], # SF2
+            [:c_us, 2 ** -29], [:sqrt_A, 2 ** -19], [:t_oe, 2 ** 4], # SF2
+            :fit_interval, # SF2
+            [:c_ic, 2 ** -29], [:Omega0, sc2rad * 2 ** -31], [:c_is, 2 ** -29], # SF3
+            [:i0, sc2rad * 2 ** -31], [:c_rc, 2 ** -5], [:omega, sc2rad * 2 ** -31], # SF3
+            [:dot_Omega0, sc2rad * 2 ** -43], [:dot_i0, sc2rad * 2 ** -43], # SF3
+          ].each{|k, sf|
+            #p [k, sf.to_f, eph.send(k) - eph2.send(k), eph.send(k), eph2.send(k)]
+            expect(eph.send(k)).to be_within((sf || 1).to_f * 2).of(eph2.send(k))
+          }
+        }.call(eph.dump(t_meas))
+        proc{|raw| # Almanac -> Ephemeris
+          expect(raw.size).to eq(10)
+          puts "Raw(PRN:#{prn},Almanac): #{raw.collect{|v| "0x%08X" % [v]}.join(', ')}"
+          eph2 = GPS::Ephemeris::new
+          eph2.parse_almanac(raw)
+          [
+            :SV_health,
+            [:t_oc, 2 ** 12], [:a_f0, 2 ** -20], [:a_f1, 2 ** -38], 
+            [:M0, sc2rad * 2 ** -23], [:e, 2 ** -21],
+            [:sqrt_A, 2 ** -11], [:t_oe, 2 ** 12],
+            [:Omega0, sc2rad * 2 ** -23], [:i0, sc2rad * 2 ** -19],
+            [:omega, sc2rad * 2 ** -23], [:dot_Omega0, sc2rad * 2 ** -38],
+          ].each{|k, sf|
+            #p [k, sf.to_f, eph.send(k) - eph2.send(k), eph.send(k), eph2.send(k)]
+            expect(eph.send(k)).to be_within((sf || 1).to_f * 2).of(eph2.send(k))
+          }
+        }.call(eph.dump_almanac(t_meas))
         puts "XYZ(PRN:#{prn}): #{eph.constellation(t_meas)[0].to_a} (iodc: #{eph.iodc}, iode: #{eph.iode})"
       }
       
@@ -863,6 +924,9 @@ __RINEX_CLK_TEXT__
       }}.not_to raise_error
       expect(solver.correction[:gps_ionospheric]).to include(:no_correction)
       expect(solver.correction[:options][:f_10_7]).to eq(10)
+      expect(solver.gps_options.exclude_L2C?).to eq(true) #default
+      solver.gps_options.exclude_L2C = false
+      expect(solver.gps_options.exclude_L2C?).to eq(false)
       sn.read(input[:rinex_nav])
       t_meas = GPS::Time::new(1849, 172413)
       sn.update_all_ephemeris(t_meas)

data/ext/ninja-scan-light/tool/util/bit_counter.h

@@ -0,0 +1,84 @@
+#ifndef __BIT_COUNTER__
+#define __BIT_COUNTER__
+
+#include <climits>
+
+using namespace std;
+
+/**
+ * Counting bits utility
+ */
+template <class T>
+struct BitCounter {
+
+  static const int num_of_bits = CHAR_BIT * sizeof(T);
+
+  private:
+    template <int Interval>
+    static T make_mask(){
+      /*
+       * @see http://www.nminoru.jp/~nminoru/programming/bitcount.html
+       * 
+       * 01010101010101010101010101010101  1 32
+       * 00110011001100110011001100110011  2 32
+       * 00001111000011110000111100001111  4 32
+       * 00000000111111110000000011111111  8 32
+       * 00000000000000001111111111111111 16 32 
+       */
+
+      T mask(1);
+      for(int i(1); i < Interval; i++){
+        mask <<= 1;
+        mask |= 0x01;
+      }
+      /*
+      // Equivalent to the following if T is built-in type
+      mask <<= Interval;
+      mask = (mask & (-mask)) - 1;
+      */ 
+
+      T res(mask);
+      for(unsigned int i(1); i < num_of_bits / Interval / 2; i++){
+        res <<= Interval;
+        res <<= Interval;
+        res |= mask;
+      }
+      return res;
+    }
+
+    template <int Interval, class U = void>
+    struct count_loop {
+      static T run(T bits){
+        bits = count_loop<(Interval >> 1)>::run(bits);
+        static const T mask(make_mask<Interval>());
+        // bit shift and add operators are required at least
+        return (bits & mask) + ((bits >> Interval) & mask);
+      }
+    };
+    template <class U>
+    struct count_loop<1, U> {
+      static T run(T bits){
+        static const T mask(make_mask<1>());
+        return (bits & mask) + ((bits >> 1) & mask);
+      }
+    };
+
+  public:
+    /**
+     * Count bits in a value
+     * @param results
+     */
+    static T count(const T &v) {
+      return count_loop<(num_of_bits >> 1)>::run(v);
+    }
+
+    /**
+     * Count rightmost zeros before the first one (Number of trailing zeros)
+     * @param bits results
+     */
+    static T ntz(const T &v) {
+      return count((T)((~v) & (v - 1)));
+    }
+};
+
+#endif /* __BIT_COUNTER__ */