gps_pvt 0.2.0 → 0.3.0

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

@@ -159,6 +159,14 @@ static std::string inspect_str(const VALUE &v){
     *week = self->week;
     *seconds = self->seconds;
   }
+#if defined(SWIG)  
+  int __cmp__(const GPS_Time<FloatT> &t) const {
+    return ((self->week < t.week) ? -1 
+        : ((self->week > t.week) ? 1 
+          : (self->seconds < t.seconds ? -1 
+            : (self->seconds > t.seconds ? 1 : 0))));
+  }
+#endif
 }
 
 %define MAKE_ACCESSOR(name, type)
@@ -413,15 +421,10 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
     %append_output(swig::from($1.latitude));
     %append_output(swig::from($1.longitude));
   }
-  %ignore iono_correction() const;
-  %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 +479,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 +666,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 +749,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);
@@ -796,6 +806,7 @@ struct GPS_Measurement {
     L1_RANGE_RATE_SIGMA,
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
+    L1_FREQUENCY,
     ITEMS_PREDEFINED,
   };
   void add(const int &prn, const int &key, const FloatT &value){
@@ -817,71 +828,15 @@ const type &get_ ## name () const {
 %enddef
   MAKE_ACCESSOR2(elevation_mask, FloatT);
   MAKE_ACCESSOR2(residual_mask, FloatT);
-  MAKE_ACCESSOR2(f_10_7, FloatT);
 #undef MAKE_ACCESSOR2
   MAKE_VECTOR2ARRAY(int);
   %ignore cast_base;
-#ifdef SWIGRUBY
-  %rename("ionospheric_models=") set_ionospheric_models;
-  %rename("ionospheric_models") get_ionospheric_models;
-#endif
-  %typemap(in) const std::vector<int> &models (std::vector<int> temp) {
-    $1 = &temp;
-#ifdef SWIGRUBY
-    if(RB_TYPE_P($input, T_ARRAY)){
-      for(int i(0), i_max(RARRAY_LEN($input)); i < i_max; ++i){
-        SWIG_Object obj(RARRAY_AREF($input, i));
-        int v;
-        if(SWIG_IsOK(SWIG_AsVal(int)(obj, &v))){
-          temp.push_back(v);
-        }else{
-          SWIG_exception(SWIG_TypeError, "$*1_ltype is expected");
-        }
-      }
-    }
-#endif
-  }
 }
 %inline %{
 template <class FloatT>
 struct GPS_SolverOptions_Common {
-  enum {
-    IONOSPHERIC_KLOBUCHAR,
-    IONOSPHERIC_SBAS,
-    IONOSPHERIC_NTCM_GL,
-    IONOSPHERIC_NONE, // which allows no correction
-    IONOSPHERIC_MODELS,
-    IONOSPHERIC_SKIP = IONOSPHERIC_MODELS, // which means delegating the next slot
-  };
   virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
   virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
-  std::vector<int> get_ionospheric_models() const {
-    typedef GPS_Solver_GeneralOptions<FloatT> general_t;
-    const general_t *general(this->cast_general());
-    std::vector<int> res;
-    for(int i(0); i < general_t::IONOSPHERIC_MODELS; ++i){
-      int v((int)(general->ionospheric_models[i]));
-      if(v == general_t::IONOSPHERIC_SKIP){break;}
-      res.push_back(v);
-    }
-    return res;
-  }
-  std::vector<int> set_ionospheric_models(const std::vector<int> &models){
-    typedef GPS_Solver_GeneralOptions<FloatT> general_t;
-    general_t *general(this->cast_general());
-    typedef typename general_t::ionospheric_model_t model_t;
-    for(int i(0), j(0), j_max(models.size()); i < general_t::IONOSPHERIC_MODELS; ++i){
-      model_t v(general_t::IONOSPHERIC_SKIP);
-      if(j < j_max){
-        if((models[j] >= 0) && (models[j] < general_t::IONOSPHERIC_SKIP)){
-          v = (model_t)models[j];
-        }
-        ++j;
-      }
-      general->ionospheric_models[i] = v;
-    }
-    return get_ionospheric_models();
-  }
 };
 %}
 
@@ -923,6 +878,27 @@ struct SBAS_SolverOptions
 };
 %}
 
+%header {
+template <class FloatT>
+struct GPS_RangeCorrector
+    : public GPS_Solver_Base<FloatT>::range_corrector_t {
+  SWIG_Object callback;
+  GPS_RangeCorrector(const SWIG_Object &callback_)
+      : GPS_Solver_Base<FloatT>::range_corrector_t(),
+      callback(callback_) {}
+  bool is_available(const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
+    return false;
+  }
+  FloatT *calculate(
+      const typename GPS_Solver_Base<FloatT>::gps_time_t &t, 
+      const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos, 
+      const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
+      FloatT &buf) const {
+    return NULL;
+  }
+};
+}
+
 %extend GPS_Solver {
   %ignore super_t;
   %ignore base_t;
@@ -934,22 +910,25 @@ struct SBAS_SolverOptions
   %ignore relative_property;
   %ignore satellite_position;
   %ignore update_position_solution;
+  %ignore user_correctors_t;
+  %ignore user_correctors;
   %immutable hooks;
   %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 +950,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,29 +981,222 @@ 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),
             SWIG_NewPointerObj(&geomat_.W,
               $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0),
             SWIG_NewPointerObj(&geomat_.delta_r,
-              $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0)};
+              $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0),
+            SWIG_NewPointerObj(&res,
+              $descriptor(GPS_User_PVT<FloatT> *), 0)};
         proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values);
       }while(false);
 #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>});
+  %ignore update_correction;
+#ifdef SWIGRUBY
+  %fragment("correction"{GPS_Solver<FloatT>}, "header",
+      fragment=SWIG_From_frag(int),
+      fragment=SWIG_Traits_frag(FloatT)){
+    template <>
+    bool GPS_RangeCorrector<FloatT>::is_available(
+        const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
+      VALUE values[] = {
+        SWIG_NewPointerObj(
+            %const_cast(&t, GPS_Time<FloatT> *), $descriptor(GPS_Time<FloatT> *), 0),
+      };
+      VALUE res(proc_call_throw_if_error(
+          callback, sizeof(values) / sizeof(values[0]), values));
+      return RTEST(res) ? true : false;
+    }
+    template <>
+    FloatT *GPS_RangeCorrector<FloatT>::calculate(
+        const typename GPS_Solver_Base<FloatT>::gps_time_t &t,
+        const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos, 
+        const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
+        FloatT &buf) const {
+      VALUE values[] = {
+        SWIG_NewPointerObj(
+            %const_cast(&t, GPS_Time<FloatT> *),
+            $descriptor(GPS_Time<FloatT> *), 0),
+        SWIG_NewPointerObj(
+            (%const_cast(&usr_pos.xyz, System_XYZ<FloatT, WGS84> *)),
+            $descriptor(System_XYZ<FloatT, WGS84> *), 0),
+        SWIG_NewPointerObj(
+            (%const_cast(&sat_rel_pos, System_ENU<FloatT, WGS84> *)),
+            $descriptor(System_ENU<FloatT, WGS84> *), 0),
+      };
+      VALUE res(proc_call_throw_if_error(
+          callback, sizeof(values) / sizeof(values[0]), values));
+      return SWIG_IsOK(swig::asval(res, &buf)) ? &buf : NULL;
+    }
+    template<>
+    VALUE GPS_Solver<FloatT>::update_correction(
+        const bool &update, const VALUE &hash){
+      typedef range_correction_list_t list_t;
+      static const VALUE k_root[] = {
+        ID2SYM(rb_intern("gps_ionospheric")),
+        ID2SYM(rb_intern("gps_tropospheric")),
+        ID2SYM(rb_intern("sbas_ionospheric")),
+        ID2SYM(rb_intern("sbas_tropospheric")),
+      };
+      static const VALUE k_opt(ID2SYM(rb_intern("options")));
+      static const VALUE k_f_10_7(ID2SYM(rb_intern("f_10_7")));
+      static const VALUE k_known(ID2SYM(rb_intern("known")));
+      struct {
+        VALUE sym;
+        list_t::mapped_type::value_type obj;
+      } item[] = {
+        {ID2SYM(rb_intern("no_correction")), &base_t::no_correction},
+        {ID2SYM(rb_intern("klobuchar")), &this->gps.solver.ionospheric_klobuchar},
+        {ID2SYM(rb_intern("ntcm_gl")), &this->gps.solver.ionospheric_ntcm_gl},
+        {ID2SYM(rb_intern("hopfield")), &this->gps.solver.tropospheric_simplified},
+        {ID2SYM(rb_intern("sbas_igp")), &this->sbas.solver.ionospheric_sbas},
+        {ID2SYM(rb_intern("sbas_tropo")), &this->sbas.solver.tropospheric_sbas},
+      };
+      list_t input;
+      if(update){
+        if(!RB_TYPE_P(hash, T_HASH)){
+          throw std::runtime_error(
+              std::string("Hash is expected, however ").append(inspect_str(hash)));
+        }
+        for(std::size_t i(0); i < sizeof(k_root) / sizeof(k_root[0]); ++i){
+          VALUE ary = rb_hash_lookup(hash, k_root[i]);
+          if(NIL_P(ary)){continue;}
+          if(!RB_TYPE_P(ary, T_ARRAY)){
+            ary = rb_ary_new_from_values(1, &ary);
+          }
+          for(int j(0); j < RARRAY_LEN(ary); ++j){
+            std::size_t k(0);
+            VALUE v(rb_ary_entry(ary, j));
+            for(; k < sizeof(item) / sizeof(item[0]); ++k){
+              if(v == item[k].sym){break;}
+            }
+            if(k >= sizeof(item) / sizeof(item[0])){ // other than symbol
+              user_correctors.push_back(GPS_RangeCorrector<FloatT>(v));
+              input[i].push_back(&user_correctors.back());
+            }else{
+              input[i].push_back(item[k].obj);
+            }
+          }
+        }
+        VALUE opt(rb_hash_lookup(hash, k_opt));
+        if(RB_TYPE_P(opt, T_HASH)){
+          swig::asval(rb_hash_lookup(opt, k_f_10_7), // ntcm_gl
+              &this->gps.solver.ionospheric_ntcm_gl.f_10_7);
+        }
+      }
+      list_t output(update_correction(update, input));
+      VALUE res = rb_hash_new();
+      for(list_t::const_iterator it(output.begin()), it_end(output.end());
+          it != it_end; ++it){
+        VALUE k;
+        if((it->first < 0) || (it->first >= (int)(sizeof(k_root) / sizeof(k_root[0])))){
+          k = SWIG_From(int)(it->first);
+        }else{
+          k = k_root[it->first];
+        }
+        VALUE v = rb_ary_new();
+        for(list_t::mapped_type::const_iterator
+              it2(it->second.begin()), it2_end(it->second.end());
+            it2 != it2_end; ++it2){
+          std::size_t i(0);
+          for(; i < sizeof(item) / sizeof(item[0]); ++i){
+            if(*it2 == item[i].obj){break;}
+          }
+          if(i >= sizeof(item) / sizeof(item[0])){ // other than built-in corrector
+            rb_ary_push(v, 
+                reinterpret_cast<const GPS_RangeCorrector<FloatT> *>(*it2)->callback);
+          }else{
+            rb_ary_push(v, item[i].sym);
+          }
+        }
+        rb_hash_aset(res, k, v);
+      }
+      { // common options
+        VALUE opt = rb_hash_new();
+        rb_hash_aset(res, k_opt, opt);
+        rb_hash_aset(opt, k_f_10_7, // ntcm_gl 
+            swig::from(this->gps.solver.ionospheric_ntcm_gl.f_10_7));
+      }
+      { // known models
+        VALUE ary = rb_ary_new_capa((int)(sizeof(item) / sizeof(item[0])));
+        for(std::size_t i(0); i < sizeof(item) / sizeof(item[0]); ++i){
+          rb_ary_push(ary, item[i].sym);
+        }
+        rb_hash_aset(res, k_known, ary);
+      }
+      return res;
+    }
+  }
+  %fragment("correction"{GPS_Solver<FloatT>});
+  %rename("correction") get_correction;
+  %rename("correction=") set_correction;
+  VALUE get_correction() const {
+    return const_cast<GPS_Solver<FloatT> *>(self)->update_correction(false, Qnil);
+  }
+  VALUE set_correction(VALUE hash){
+    return self->update_correction(true, hash);
+  }
+#endif
 }
 %inline {
 template <class FloatT>
@@ -1046,19 +1219,36 @@ struct GPS_Solver
     sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
   SWIG_Object hooks;
+  typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
+  user_correctors_t user_correctors;
 #ifdef SWIGRUBY
   static void mark(void *ptr){
     GPS_Solver<FloatT> *solver = (GPS_Solver<FloatT> *)ptr;
-    if(solver->hooks == Qnil){return;}
     rb_gc_mark(solver->hooks);
+    for(typename user_correctors_t::const_iterator 
+          it(solver->user_correctors.begin()), it_end(solver->user_correctors.end());
+        it != it_end; ++it){
+      rb_gc_mark(it->callback);
+    }
   }
 #endif
-  GPS_Solver() : super_t(), gps(), sbas(), hooks() {
-    gps.solver.space_node_sbas = &sbas.space_node;
-    sbas.solver.space_node_gps = &gps.space_node;
+  GPS_Solver() : super_t(),
+      gps(), sbas(),
+      hooks(), user_correctors() {
 #ifdef SWIGRUBY
     hooks = rb_hash_new();
 #endif
+    typename base_t::range_correction_t ionospheric, tropospheric;
+    ionospheric.push_back(&sbas.solver.ionospheric_sbas);
+    ionospheric.push_back(&gps.solver.ionospheric_klobuchar);
+    tropospheric.push_back(&sbas.solver.tropospheric_sbas);
+    tropospheric.push_back(&gps.solver.tropospheric_simplified);
+    gps.solver.ionospheric_correction
+        = sbas.solver.ionospheric_correction
+        = ionospheric;
+    gps.solver.tropospheric_correction
+        = sbas.solver.tropospheric_correction
+        = tropospheric;
   }
   GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
   GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
@@ -1069,7 +1259,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 +1275,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;
@@ -1096,6 +1288,53 @@ struct GPS_Solver
     const_cast<sbas_t &>(sbas).solver.update_options(sbas.options);
     return super_t::solve().user_pvt(measurement.items, receiver_time);
   }
+  typedef 
+      std::map<int, std::vector<const typename base_t::range_corrector_t *> >
+      range_correction_list_t;
+  range_correction_list_t update_correction(
+      const bool &update,
+      const range_correction_list_t &list = range_correction_list_t()){
+    range_correction_list_t res;
+    typename base_t::range_correction_t *root[] = {
+      &gps.solver.ionospheric_correction,
+      &gps.solver.tropospheric_correction,
+      &sbas.solver.ionospheric_correction,
+      &sbas.solver.tropospheric_correction,
+    };
+    for(std::size_t i(0); i < sizeof(root) / sizeof(root[0]); ++i){
+      do{
+        if(!update){break;}
+        typename range_correction_list_t::const_iterator it(list.find(i));
+        if(it == list.end()){break;}
+
+        // Remove user defined unused correctors
+        for(typename base_t::range_correction_t::const_iterator
+              it2(root[i]->begin()), it2_end(root[i]->end());
+            it2 != it2_end; ++it2){
+          for(typename user_correctors_t::const_iterator
+                it3(user_correctors.begin()), it3_end(user_correctors.end());
+              it3 != it3_end; ++it3){
+            if(*it2 != &(*it3)){continue;}
+            user_correctors.erase(it3);
+          }
+        }
+
+        root[i]->clear();
+        for(typename range_correction_list_t::mapped_type::const_iterator
+              it2(it->second.begin()), it2_end(it->second.end());
+            it2 != it2_end; ++it2){
+          root[i]->push_back(*it2);
+        }
+      }while(false);
+      for(typename base_t::range_correction_t::const_iterator
+            it(root[i]->begin()), it_end(root[i]->end());
+          it != it_end; ++it){
+        res[i].push_back(*it);
+      }
+    }
+    return res;
+  }
+  SWIG_Object update_correction(const bool &update, const SWIG_Object &hash);
 };
 }
 

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

@@ -238,6 +238,23 @@ INSTANTIATE_COMPLEX(double, D);
 
 #undef INSTANTIATE_COMPLEX
 
+#if defined(SWIGRUBY)
+/* Work around of miss detection of negative value on Windows Ruby (devkit). 
+ * This results from SWIG_AsVal(unsigned int) depends on SWIG_AsVal(unsigned long), 
+ * and sizeof(long) == sizeof(int).
+ */
+%fragment("check_value"{unsigned int}, "header"){
+  inline bool is_lt_zero_after_asval(const unsigned int &i){
+    return ((sizeof(unsigned int) == sizeof(unsigned long)) && ((UINT_MAX >> 1) <= i));
+  }
+  void raise_if_lt_zero_after_asval(const unsigned int &i){
+    if(is_lt_zero_after_asval(i)){
+      SWIG_exception(SWIG_ValueError, "Expected positive value.");
+    }
+  } 
+}
+#endif
+
 #define DO_NOT_INSTANTIATE_SCALAR_MATRIX
 #define USE_MATRIX_VIEW_FILTER
 
@@ -949,6 +966,7 @@ MAKE_TO_S(Matrix_Frozen)
   }
 #if defined(SWIGRUBY)
   %fragment(SWIG_AsVal_frag(unsigned int));
+  %fragment("check_value"{unsigned int});
   Matrix(const void *replacer){
     const SWIG_Object *value(static_cast<const SWIG_Object *>(replacer));
     static const ID id_r(rb_intern("row_size")), id_c(rb_intern("column_size"));
@@ -959,13 +977,10 @@ MAKE_TO_S(Matrix_Frozen)
       MatrixUtil::replace(res, replacer);
       return new Matrix<T, Array2D_Type, ViewType>(res);
     }else if(value && rb_respond_to(*value, id_r) && rb_respond_to(*value, id_c)){
-      /* "unsigned" is remove because SWIG_AsVal(unsigned int)
-       * can not detect less than zero in Windows Ruby devkit.
-       */
-      int r, c; 
+      unsigned int r, c; 
       VALUE v_r(rb_funcall(*value, id_r, 0, 0)), v_c(rb_funcall(*value, id_c, 0, 0));
-      if(!SWIG_IsOK(SWIG_AsVal(int)(v_r, &r)) || (r < 0)
-          || !SWIG_IsOK(SWIG_AsVal(int)(v_c, &c)) || (c < 0)){
+      if(!SWIG_IsOK(SWIG_AsVal(unsigned int)(v_r, &r)) || is_lt_zero_after_asval(r)
+          || !SWIG_IsOK(SWIG_AsVal(unsigned int)(v_c, &c)) || is_lt_zero_after_asval(c)){
         throw std::runtime_error(
             std::string("Unexpected length [")
               .append(inspect_str(v_r)).append(", ")
@@ -1147,6 +1162,8 @@ INSTANTIATE_MATRIX_EIGEN2(type, ctype, Array2D_Dense<type >, MatView_pt);
 #endif
 
 %define INSTANTIATE_MATRIX(type, suffix)
+%typemap(check, fragment="check_value"{unsigned int})
+    const unsigned int & "raise_if_lt_zero_after_asval(*$1);"
 #if !defined(DO_NOT_INSTANTIATE_SCALAR_MATRIX)
 %extend Matrix_Frozen<type, Array2D_ScaledUnit<type >, MatViewBase> {
   const Matrix_Frozen<type, Array2D_ScaledUnit<type >, MatViewBase> &transpose() const {
@@ -1200,6 +1217,35 @@ INSTANTIATE_MATRIX_PARTIAL(type, Array2D_Dense<type >, MatView_pt, MatView_pt);
 %template(Matrix_Frozen ## suffix ## _pt) Matrix_Frozen<type, Array2D_Dense<type >, MatView_pt>;
 #endif
 
+%extend Matrix<type, Array2D_Dense<type > > {
+#if defined(SWIGRUBY)
+  %bang resize;
+#endif
+  %typemap(in, fragment="check_value"{unsigned int}) 
+      unsigned int *r_p (unsigned int temp), unsigned int *c_p (unsigned int temp) {
+    if(SWIG_IsOK(SWIG_AsVal(unsigned int)($input, &temp))){
+#if defined(SWIGRUBY)
+      raise_if_lt_zero_after_asval(temp);
+#endif
+      $1 = &temp;
+    }
+#if defined(SWIGRUBY)
+    else if(NIL_P($input)){$1 = NULL;}
+#endif
+    else{SWIG_exception(SWIG_TypeError, "$*1_ltype is expected");}
+  }
+  Matrix<type, Array2D_Dense<type > > &resize(
+      const unsigned int *r_p, const unsigned int *c_p){
+    unsigned int r(r_p ? *r_p : $self->rows()), c(c_p ? *c_p : self->columns());
+    Matrix<type, Array2D_Dense<type > > mat_new(r, c);
+    unsigned int r_min(r), c_min(c);
+    if(r_min > $self->rows()){r_min = $self->rows();}
+    if(c_min > $self->columns()){c_min = $self->columns();}
+    mat_new.partial(r_min, c_min).replace($self->partial(r_min, c_min), false);
+    return (*($self) = mat_new);
+  }
+};
+
 %template(Matrix ## suffix) Matrix<type, Array2D_Dense<type > >;
 #if defined(SWIGRUBY)
 %fragment("init"{Matrix<type, Array2D_Dense<type > >}, "init") {
@@ -1212,6 +1258,7 @@ INSTANTIATE_MATRIX_PARTIAL(type, Array2D_Dense<type >, MatView_pt, MatView_pt);
 }
 %fragment("init"{Matrix<type, Array2D_Dense<type > >});
 #endif
+%typemap(check) const unsigned int &;
 %enddef
 
 INSTANTIATE_MATRIX(double, D);