gps_pvt 0.9.2 → 0.9.4

data/ext/ninja-scan-light/tool/param/matrix_fixed.h

@@ -380,6 +380,32 @@ struct MatrixBuilder_Dependency<
             (MatrixViewProperty<ViewType_R>::transposed ? nR_R : nC_R)>,
           ViewType> > {};
 
+template <
+    class T, class T_op,
+    class T2, class T3, class T4, class T5,
+    class ViewType,
+    int nR_L, int nC_L, class ViewType_L,
+    int nR_R, int nC_R, class ViewType_R,
+    bool horizontal_R>
+struct MatrixBuilder_Dependency<
+    Matrix_Frozen<
+        T,
+        Array2D_Operator<T_op, Array2D_Operator_Stack<
+          Matrix_Frozen<T2, Array2D_Fixed<T3, nR_L, nC_L>, ViewType_L>,
+          Matrix_Frozen<T4, Array2D_Fixed<T5, nR_R, nC_R>, ViewType_R>,
+          horizontal_R> >,
+        ViewType> >
+    : public MatrixBuilder_Dependency<
+        Matrix_Frozen<
+          T,
+          Array2D_Fixed<
+            T,
+            (MatrixViewProperty<ViewType_L>::transposed ? nC_L : nR_L)
+              + (horizontal_R ? 0 : (MatrixViewProperty<ViewType_R>::transposed ? nC_R : nR_R)),
+            (MatrixViewProperty<ViewType_L>::transposed ? nR_L : nC_L)
+              + (horizontal_R ? (MatrixViewProperty<ViewType_R>::transposed ? nR_R : nC_R) : 0)>,
+          ViewType> > {};
+
 // For optimization of local temporary matrix
 template <
     template <class, class, class> class MatrixT,

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

@@ -16,6 +16,7 @@
 %include std_common.i
 %include std_string.i
 %include exception.i
+%include std_except.i
 
 //%import "SylphideMath.i"
 
@@ -29,7 +30,13 @@ type set_ ## name (const type &v) {
 %enddef
 
 #if !defined(SWIGIMPORTED)
-%header {
+%exceptionclass native_exception;
+%typemap(throws,noblock=1) native_exception {
+  $1.regenerate();
+  SWIG_fail;
+}
+%ignore native_exception;
+%inline {
 struct native_exception : public std::exception {
 #if defined(SWIGRUBY)
   int state;
@@ -67,22 +74,15 @@ struct native_exception : public std::exception {
     }
   }
 #endif
-  %exception each {
+  %typemap(in,numinputs=0) const void *check_block {
 #ifdef SWIGRUBY
     if(!rb_block_given_p()){
-      return rb_enumeratorize(self, ID2SYM(rb_intern("each")), argc, argv);
+      return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
     }
 #endif
-    try {
-      $action
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
   }
-  void each() const {
+  %catches(native_exception) each;
+  void each(const void *check_block) const {
     for(int i(0); i < 3; ++i){
 #ifdef SWIGRUBY
       int state;

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

@@ -48,9 +48,16 @@ inline std::string to_string(const T &value){
 %include std_common.i
 %include std_string.i
 %include exception.i
+%include std_except.i
 
 #if !defined(SWIGIMPORTED)
-%header {
+%exceptionclass native_exception;
+%typemap(throws,noblock=1) native_exception {
+  $1.regenerate();
+  SWIG_fail;
+}
+%ignore native_exception;
+%inline {
 struct native_exception : public std::exception {
 #if defined(SWIGRUBY)
   int state;
@@ -61,16 +68,6 @@ struct native_exception : public std::exception {
 #endif
 };
 }
-%exception {
-  try {
-    $action
-  } catch (const native_exception &e) {
-    e.regenerate();
-    SWIG_fail;
-  } catch (const std::exception& e) {
-    SWIG_exception_fail(SWIG_RuntimeError, e.what());
-  }
-}
 #endif
 
 #ifdef SWIGRUBY
@@ -117,47 +114,82 @@ static std::string inspect_str(const VALUE &v){
 %import "SylphideMath.i"
 %import "Coordinate.i"
 
-%extend GPS_Time {
-  %typemap(out) std::tm {
-    %append_output(SWIG_From(int)($1.tm_year + 1900));
-    %append_output(SWIG_From(int)($1.tm_mon + 1));
-    %append_output(SWIG_From(int)($1.tm_mday));
-    %append_output(SWIG_From(int)($1.tm_hour));
-    %append_output(SWIG_From(int)($1.tm_min));
-    %append_output(SWIG_From(int)($1.tm_sec));
+%typemap(in,numinputs=0) const void *check_block {
+#ifdef SWIGRUBY
+  if(!rb_block_given_p()){
+    return rb_enumeratorize(self, ID2SYM(rb_frame_callee()), argc, argv);
   }
-#if defined(SWIGRUBY)
-  %typemap(in) const std::tm & (std::tm temp = {0}) {
-    $1 = &temp;
-    int *dst[] = {
-      &(temp.tm_year),
-      &(temp.tm_mon),
-      &(temp.tm_mday),
-      &(temp.tm_hour),
-      &(temp.tm_min),
-      &(temp.tm_sec),
-    };
-    int i_max(sizeof(dst) / sizeof(dst[0]));
-    if(i_max > RARRAY_LEN($input)){i_max = RARRAY_LEN($input);}
+#endif
+}
+
+%fragment(SWIG_From_frag(std::tm), "header", fragment=SWIG_From_frag(int)) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(std::tm)(const std::tm &value){
+  SWIG_Object res(SWIG_From(int)(value.tm_year + 1900));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_mon + 1));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_mday));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_hour));
+  res = SWIG_AppendOutput(res, SWIG_From(int)(value.tm_min));
+  return SWIG_AppendOutput(res, SWIG_From(int)(value.tm_sec));
+}
+}
+%fragment(SWIG_AsVal_frag(std::tm), "header", fragment=SWIG_AsVal_frag(int)){
+SWIGINTERN int
+SWIG_AsVal_dec(std::tm)(SWIG_Object obj, std::tm *val) {
+#ifdef SWIGRUBY
+  int *dst[] = {
+    &(val->tm_year),
+    &(val->tm_mon),
+    &(val->tm_mday),
+    &(val->tm_hour),
+    &(val->tm_min),
+    &(val->tm_sec),
+  };
+  if(RB_TYPE_P(obj, T_ARRAY)){
+    int i_max(RARRAY_LEN(obj));
+    if(i_max > sizeof(dst) / sizeof(dst[0])){return SWIG_ERROR;}
+    VALUE obj_i;
+    int v;
     for(int i(0); i < i_max; ++i){
-      SWIG_Object obj = rb_ary_entry($input, i);
-      int v;
-      if(SWIG_IsOK(SWIG_AsVal(int)(obj, &v))){
-        if(dst[i] == &(temp.tm_year)){
+      obj_i = RARRAY_AREF(obj, i);
+      if(SWIG_IsOK(SWIG_AsVal(int)(obj_i, &v))){
+        if(dst[i] == &(val->tm_year)){
           *dst[i] = v - 1900;
-        }else if(dst[i] == &(temp.tm_mon)){
+        }else if(dst[i] == &(val->tm_mon)){
           *dst[i] = v - 1;
         }else{
           *dst[i] = v;
         }
       }else{
-        SWIG_exception(SWIG_TypeError, "int is expected");
+        SWIG_exception(SWIG_TypeError, 
+            std::string("Unexpected input [").append(std::to_string(i)).append("]: ")
+              .append(inspect_str(obj_i)).c_str());
       }
     }
+    return SWIG_OK;
   }
-  %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) const std::tm & {
-    $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
+#endif
+  return SWIG_ERROR;
+}
+}
+%typemap(out, fragment=SWIG_From_frag(std::tm)) std::tm {
+  $result = SWIG_From(std::tm)($1);
+}
+%typemap(in, fragment=SWIG_AsVal_frag(std::tm)) const std::tm & (std::tm temp = {0}) {
+  if(SWIG_AsVal(std::tm)($input, $1 = &temp) != SWIG_OK){
+    SWIG_exception(SWIG_TypeError, "int[1..6] is expected");
   }
+}
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) const std::tm & {
+#ifdef SWIGRUBY
+  $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
+#else
+  $1 = 0;
+#endif
+}
+
+%extend GPS_Time {
+#if defined(SWIGRUBY)
   %typemap(varout,fragment="SWIG_Traits_frag(FloatT)") leap_second_event_t [] {
     $result = rb_ary_new2(sizeof($1) / sizeof($1[0]));
     for(std::size_t i(0); i < sizeof($1) / sizeof($1[0]); ++i){
@@ -275,11 +307,12 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
   MAKE_ACCESSOR(WN_LSF, unsigned int);
   MAKE_ACCESSOR(DN, unsigned int);
   MAKE_ACCESSOR(delta_t_LSF, int);
+  %catches(std::invalid_argument) parse;
   static GPS_Ionospheric_UTC_Parameters<FloatT> parse(const unsigned int buf[10]){
     typedef typename GPS_SpaceNode<FloatT>
         ::BroadcastedMessage<unsigned int, 30> parser_t;
     if((parser_t::subframe_id(buf) != 4) || (parser_t::sv_page_id(buf) != 56)){
-      throw std::runtime_error("Not valid data");
+      throw std::invalid_argument("Not valid data");
     }
     typename GPS_SpaceNode<FloatT>::Ionospheric_UTC_Parameters::raw_t raw;
     raw.update<2, 0>(buf);
@@ -894,11 +927,12 @@ struct GPS_User_PVT
     ERROR_VELOCITY_LS,
   };
   int error_code() const {return (int)(base_t::error_code);}
-  const GPS_Time<FloatT> &receiver_time() const {return base_t::receiver_time;}
-  const System_XYZ<FloatT, WGS84> &xyz() const {return base_t::user_position.xyz;}
-  const System_LLH<FloatT, WGS84> &llh() const {return base_t::user_position.llh;}
+  // Returning Type because returning const Type & causes reference problem after GC
+  GPS_Time<FloatT> receiver_time() const {return base_t::receiver_time;}
+  System_XYZ<FloatT, WGS84> xyz() const {return base_t::user_position.xyz;}
+  System_LLH<FloatT, WGS84> llh() const {return base_t::user_position.llh;}
   const FloatT &receiver_error() const {return base_t::receiver_error;}
-  const System_ENU<FloatT, WGS84> &velocity() const {return base_t::user_velocity_enu;}
+  System_ENU<FloatT, WGS84> velocity() const {return base_t::user_velocity_enu;}
   const FloatT &receiver_error_rate() const {return base_t::receiver_error_rate;}
   const FloatT &gdop() const {return base_t::dop.g;}
   const FloatT &pdop() const {return base_t::dop.p;}
@@ -975,23 +1009,9 @@ struct GPS_User_PVT
 %extend GPS_Measurement {
   %ignore items_t;
   %ignore items;
-  %exception each {
-#ifdef SWIGRUBY
-    if(!rb_block_given_p()){
-      return rb_enumeratorize(self, ID2SYM(rb_intern("each")), argc, argv);
-    }
-#endif
-    try {
-      $action
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
   %fragment(SWIG_Traits_frag(FloatT));
-  void each() const {
+  %catches(native_exception) each;
+  void each(const void *check_block) const {
     for(typename GPS_Measurement<FloatT>::items_t::const_iterator
           it(self->items.begin()), it_end(self->items.end());
         it != it_end; ++it){
@@ -1074,18 +1094,18 @@ struct GPS_User_PVT
                       .append(inspect_str(v_key_value)).append("}").c_str());
               }
               rb_hash_foreach(v_key_value,
-#if RUBY_API_VERSION < 20700
+%#if RUBY_API_VERSION_CODE < 20700
                   // @see https://docs.ruby-lang.org/ja/latest/doc/news=2f2_7_0.html
                   (int (*)(ANYARGS))
-#endif
+%#endif
                   arg_t::iter2, v_arg);
               return ST_CONTINUE;
             }
           } arg = {val};
           rb_hash_foreach(obj,
-#if RUBY_API_VERSION < 20700
+%#if RUBY_API_VERSION_CODE < 20700
               (int (*)(ANYARGS))
-#endif
+%#endif
               arg_t::iter1, reinterpret_cast<VALUE>(&arg));
           return SWIG_OK;
         }
@@ -1149,6 +1169,7 @@ struct GPS_Measurement {
     L1_RANGE_RATE_SIGMA,
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
+    L1_CARRIER_PHASE_AMBIGUITY_SCALE,
     L1_FREQUENCY,
 #define make_entry(key) L2CM_ ## key, L2CL_ ## key
 #define make_entry2(key) make_entry(key), make_entry(key ## _SIGMA)
@@ -1158,6 +1179,7 @@ struct GPS_Measurement {
     make_entry2(RANGE_RATE),
     make_entry(SIGNAL_STRENGTH_dBHz),
     make_entry(LOCK_SEC),
+    make_entry(CARRIER_PHASE_AMBIGUITY_SCALE),
 #undef make_entry2
 #undef make_entry
     ITEMS_PREDEFINED,
@@ -1322,6 +1344,7 @@ struct HookableSolver : public BaseT {
   %ignore user_correctors;
   %immutable hooks;
   %ignore mark;
+  %catches(native_exception, std::runtime_error) solve;
   %fragment("hook"{GPS_Solver<FloatT>}, "header",
       fragment=SWIG_From_frag(int),
       fragment=SWIG_Traits_frag(FloatT),
@@ -1385,7 +1408,7 @@ struct HookableSolver : public BaseT {
         if((!RB_TYPE_P(res_hook, T_ARRAY))
             || (RARRAY_LEN(res_hook) != prop_items)){
           throw std::runtime_error(
-              std::string("[d * ").append(std::to_string(prop_items))
+              std::string("relative_property() returning [d * ").append(std::to_string(prop_items))
                 .append("] is expected (d: " %str(FloatT) "), however ")
                 .append(inspect_str(res_hook)));
         }
@@ -1393,7 +1416,7 @@ struct HookableSolver : public BaseT {
           VALUE v(RARRAY_AREF(res_hook, i));
           if(!SWIG_IsOK(swig::asval(v, &res.values[i]))){
             throw std::runtime_error(
-                std::string(%str(FloatT) " is exepcted, however ")
+                std::string("relative_property() returning " %str(FloatT) " is exepcted, however ")
                   .append(inspect_str(v))
                   .append(" @ [").append(std::to_string(i)).append("]"));
           }
@@ -1516,7 +1539,7 @@ struct HookableSolver : public BaseT {
       list_t input;
       if(update){
         if(!RB_TYPE_P(hash, T_HASH)){
-          throw std::runtime_error(
+          throw std::invalid_argument(
               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){
@@ -1594,6 +1617,7 @@ struct HookableSolver : public BaseT {
   VALUE get_correction() const {
     return const_cast<GPS_Solver<FloatT> *>(self)->update_correction(false, Qnil);
   }
+  %catches(std::invalid_argument) set_correction;
   VALUE set_correction(VALUE hash){
     return self->update_correction(true, hash);
   }
@@ -1824,23 +1848,9 @@ struct GPS_Solver
 %fragment(SWIG_From_frag(char));
 
 %extend RINEX_Observation {
-  %exception read {
-#ifdef SWIGRUBY
-    if(!rb_block_given_p()){
-      return rb_enumeratorize(self, ID2SYM(rb_intern("read")), argc, argv);
-    }
-#endif
-    try {
-      $action
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
   %fragment(SWIG_Traits_frag(FloatT));
-  static void read(const char *fname) {
+  %catches(native_exception) read;
+  static void read(const char *fname, const void *check_block) {
     std::fstream fin(fname, std::ios::in | std::ios::binary);
     struct reader_t : public RINEX_OBS_Reader<FloatT> {
       typedef RINEX_OBS_Reader<FloatT> super_t;