gps_pvt 0.3.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ceeb392e9d4a3df9a3b6af1ed6b19a92fec4fae110c9c89118602f3213d6905
-  data.tar.gz: c91c94043d2e39dde8ea0909dbd862f0194b15a4f2baa3030b48d760f933a147
+  metadata.gz: b91245b6a851b08ef5ec4b23e6be27cdd1150eaf6f7036249bf971c105bd920d
+  data.tar.gz: 75e5a367d8e1cc0d0e8cc48dae63b3b9b6a72fc86eeeea76bc6d1562ba171f02
 SHA512:
-  metadata.gz: bcf702f83fd0df488470b385df370c3639e953b064a6acd9cdc4418a98b03ffab9c15dc9af0ad79185177bc3feb03e74b0ee0c9dba667bf73af1e1afabdca7be
-  data.tar.gz: eac046233bfd52db17a3fb94d2c74fcf01c8cd3200d0d5dce2546a669bb9313cccda4bdb74e2b991f1397d27325ec87d79d8c0e87be36b05fa6856daf0342ad0
+  metadata.gz: 3763faded2f4a5ace56f3a5cfde25311792ea06bda6ce5eb987fa10e1add08d9eb505bdb697fefb84b95a212072a824c3c134d298f4adea13d4ea31edfbeb831
+  data.tar.gz: 76b55b2da8d816a4bd2be024191ac0b706e40624035f979411f9192d78e030f2ee10ab4ce186160e8de2006b175728db593b11c25020f734ed9ac22544f0d2fb

data/README.md

@@ -27,7 +27,8 @@ For Windows users, this gem requires Devkit because of native compilation.
 
 ## Usage
 
-For user who just generate PVT solution, an attached executable is useful. After installation, type
+### For user who just generate PVT solution
+An attached executable is useful. After installation, type
 
     $ gps_pvt RINEX_or_UBX_file(s)
 
@@ -41,7 +42,18 @@ From version 0.2.0, SBAS and QZSS are supported in addition to GPS. QZSS ranging
 
     $ gps_pvt --with=137 RINEX_or_UBX_file(s)
 
-For developer, this library will be used like:
+Additionally, the following command options *--key=value* are available.
+
+| key | value | comment | version |
+----|----|----|----
+| base_station | 3 \* (numeric+coordinate) | base position used for relative ENU position calculation. XYZ, NEU formats are acceptable. *ex1) --base_station=0X,0Y,0Z*, *ex2) --base_station=12.34N,56.789E,0U* | v0.1.7 |
+| elevation_mask_deg | numeric | satellite elevation mask specified in degrees. *ex) --elevation_mask_deg=10* | v0.3.0 |
+| start_time | time string | start time to perform solution. GPS, UTC and other formats are supported. *ex1) --start_time=1234:5678* represents 5678 seconds in 1234 GPS week, *ex2) --start_time="2000-01-01 00:00:00 UTC"* is in UTC format. | v0.3.3 |
+| end_time | time string | end time to perform solution. Its format is the same as start_time. | v0.3.3 |
+
+### For developer
+
+This library will be used like:
 
 ```ruby
 require 'gps_pvt'

data/exe/gps_pvt

@@ -14,6 +14,7 @@ Note: YY = last two digit of year.
 __STRING__
 
 options = []
+misc_options = {}
 
 # check options and file format
 files = ARGV.collect{|arg|
@@ -24,6 +25,40 @@ files = ARGV.collect{|arg|
   nil
 }.compact
 
+options.reject!{|opt|
+  case opt[0]
+  when :start_time, :end_time
+    require 'time'
+    gpst_type = GPS_PVT::GPS::Time
+    t = nil
+    if opt[1] =~ /^(?:(\d+):)??(\d+(?:\.\d*)?)$/ then
+      t = [$1 && $1.to_i, $2.to_f]
+      t = gpst_type::new(*t) if t[0]
+    elsif t = (Time::parse(opt[1]) rescue nil) then
+      # leap second handling in Ruby Time is system dependent, thus 
+      #t = gpst_type::new(0, t - Time::parse("1980-01-06 00:00:00 +0000"))
+      # is inappropriate.
+      subsec = t.subsec.to_f
+      t = gpst_type::new(t.to_a[0..5].reverse)
+      t += (subsec + gpst_type::guess_leap_seconds(t))
+    else
+      raise "Unknown time format: #{opt[1]}"
+    end
+    case t
+    when gpst_type
+      $stderr.puts(
+          "#{opt[0]}: %d week %f (a.k.a %04d/%02d/%02d %02d:%02d:%02.1f)" \
+            %(t.to_a + t.utc))
+    when Array
+      $stderr.puts("#{opt[0]}: #{t[0] || '(current)'} week #{t[1]}")
+    end
+    misc_options[opt[0]] = t
+    true
+  else
+    false
+  end
+}
+
 # Check file existence and extension
 files.collect!{|fname, ftype|
   raise "File not found: #{fname}" unless File::exist?(fname)
@@ -39,6 +74,34 @@ files.collect!{|fname, ftype|
 
 rcv = GPS_PVT::Receiver::new(options)
 
+proc{
+  run_orig = rcv.method(:run)
+  t_start, t_end = [nil, nil]
+  tasks = []
+  task = proc{|meas, t_meas, *args|
+    t_start, t_end = [:start_time, :end_time].collect{|k|
+      res = misc_options[k]
+      res.kind_of?(Array) \
+          ? GPS_PVT::GPS::Time::new(t_meas.week, res[1]) \
+          : res
+    }
+    task = tasks.shift
+    task.call(*([meas, t_meas] + args))
+  }
+  tasks << proc{|meas, t_meas, *args|
+    next nil if t_start && (t_start > t_meas)
+    task = tasks.shift
+    task.call(*([meas, t_meas] + args))
+  }
+  tasks << proc{|meas, t_meas, *args|
+    next nil if t_end && (t_end < t_meas)
+    run_orig.call(*([meas, t_meas] + args))
+  }
+  rcv.define_singleton_method(:run){|*args|
+    task.call(*args)
+  }
+}.call if [:start_time, :end_time].any?{|k| misc_options[k]}
+
 puts rcv.header
 
 # parse RINEX NAV

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -2896,6 +2896,9 @@ SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
   return res;
 }
 
+SWIGINTERN GPS_Time< double > *new_GPS_Time_Sl_double_Sg___SWIG_4(int const &week_,GPS_Time< double >::float_t const &seconds_,void *dummy){
+    return &((new GPS_Time<double>(week_, seconds_))->canonicalize());
+  }
 SWIGINTERN void GPS_Time_Sl_double_Sg__to_a(GPS_Time< double > const *self,int *week,double *seconds){
     *week = self->week;
     *seconds = self->seconds;
@@ -4642,9 +4645,9 @@ fail:
   call-seq:
     Time.new
     Time.new(Time t)
-    Time.new(int const & _week, GPS_Time< double >::float_t const & _seconds)
     Time.new(std::tm const & t, GPS_Time< double >::float_t const & leap_seconds=0)
     Time.new(std::tm const & t)
+    Time.new(int const & week_, GPS_Time< double >::float_t const & seconds_)
 
 Class constructor.
 
@@ -4710,105 +4713,6 @@ fail:
 
 SWIGINTERN VALUE
 _wrap_new_Time__SWIG_2(int argc, VALUE *argv, VALUE self) {
-  int *arg1 = 0 ;
-  GPS_Time< double >::float_t *arg2 = 0 ;
-  int temp1 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  GPS_Time< double >::float_t temp2 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  GPS_Time< double > *result = 0 ;
-  
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","GPS_Time<(double)>", 1, argv[0] ));
-  } 
-  temp1 = static_cast< int >(val1);
-  arg1 = &temp1;
-  ecode2 = SWIG_AsVal_double(argv[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "GPS_Time< double >::float_t","GPS_Time<(double)>", 2, argv[1] ));
-  } 
-  temp2 = static_cast< GPS_Time< double >::float_t >(val2);
-  arg2 = &temp2;
-  {
-    try {
-      result = (GPS_Time< double > *)new GPS_Time< double >((int const &)*arg1,(GPS_Time< double >::float_t const &)*arg2);
-      DATA_PTR(self) = result;
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  return self;
-fail:
-  return Qnil;
-}
-
-
-/*
-  Document-method: GPS_PVT::GPS::Time.canonicalize
-
-  call-seq:
-    canonicalize -> Time
-
-An instance method.
-
-*/
-SWIGINTERN VALUE
-_wrap_Time_canonicalize(int argc, VALUE *argv, VALUE self) {
-  GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GPS_Time< double > *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_TimeT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > *","canonicalize", 1, self )); 
-  }
-  arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
-  {
-    try {
-      result = (GPS_Time< double > *) &(arg1)->canonicalize();
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPS_TimeT_double_t, 0 |  0 );
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-/*
-  Document-method: GPS_PVT::GPS::Time.new
-
-  call-seq:
-    Time.new
-    Time.new(Time t)
-    Time.new(int const & _week, GPS_Time< double >::float_t const & _seconds)
-    Time.new(std::tm const & t, GPS_Time< double >::float_t const & leap_seconds=0)
-    Time.new(std::tm const & t)
-
-Class constructor.
-
-*/
-SWIGINTERN VALUE
-_wrap_new_Time__SWIG_3(int argc, VALUE *argv, VALUE self) {
   std::tm *arg1 = 0 ;
   GPS_Time< double >::float_t *arg2 = 0 ;
   std::tm temp1 = {
@@ -4876,22 +4780,7 @@ fail:
 
 
 SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_Time_allocate(VALUE self)
-#else
-_wrap_Time_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GPS_TimeT_double_t);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
-  return vresult;
-}
-
-
-SWIGINTERN VALUE
-_wrap_new_Time__SWIG_4(int argc, VALUE *argv, VALUE self) {
+_wrap_new_Time__SWIG_3(int argc, VALUE *argv, VALUE self) {
   std::tm *arg1 = 0 ;
   std::tm temp1 = {
     0
@@ -4948,81 +4837,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_new_Time(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[2];
-  int ii;
-  
-  argc = nargs;
-  if (argc > 2) SWIG_fail;
-  for (ii = 0; (ii < argc); ++ii) {
-    argv[ii] = args[ii];
-  }
-  if (argc == 0) {
-    return _wrap_new_Time__SWIG_0(nargs, args, self);
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_Time__SWIG_1(nargs, args, self);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_new_Time__SWIG_4(nargs, args, self);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_double(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_new_Time__SWIG_3(nargs, args, self);
-      }
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      int res = SWIG_AsVal_int(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_double(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_new_Time__SWIG_2(nargs, args, self);
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 2, "Time.new", 
-    "    Time.new()\n"
-    "    Time.new(GPS_Time< double > const &t)\n"
-    "    Time.new(int const &_week, GPS_Time< double >::float_t const &_seconds)\n"
-    "    Time.new(std::tm const &t, GPS_Time< double >::float_t const &leap_seconds)\n"
-    "    Time.new(std::tm const &t)\n");
-  
-  return Qnil;
-}
-
-
 /*
   Document-method: GPS_PVT::GPS::Time.now
 
@@ -6234,6 +6048,155 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_Time_allocate(VALUE self)
+#else
+_wrap_Time_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GPS_TimeT_double_t);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+/*
+  Document-method: GPS_PVT::GPS::Time.new
+
+  call-seq:
+    Time.new
+    Time.new(Time t)
+    Time.new(std::tm const & t, GPS_Time< double >::float_t const & leap_seconds=0)
+    Time.new(std::tm const & t)
+    Time.new(int const & week_, GPS_Time< double >::float_t const & seconds_)
+
+Class constructor.
+
+*/
+SWIGINTERN VALUE
+_wrap_new_Time__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  int *arg1 = 0 ;
+  GPS_Time< double >::float_t *arg2 = 0 ;
+  void *arg3 = (void *) 0 ;
+  int temp1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  GPS_Time< double >::float_t temp2 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  GPS_Time< double > *result = 0 ;
+  
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","GPS_Time<(double)>", 1, argv[0] ));
+  } 
+  temp1 = static_cast< int >(val1);
+  arg1 = &temp1;
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "GPS_Time< double >::float_t","GPS_Time<(double)>", 2, argv[1] ));
+  } 
+  temp2 = static_cast< GPS_Time< double >::float_t >(val2);
+  arg2 = &temp2;
+  {
+    try {
+      result = (GPS_Time< double > *)new_GPS_Time_Sl_double_Sg___SWIG_4((int const &)*arg1,(double const &)*arg2,arg3);
+      DATA_PTR(self) = result;
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_Time(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_Time__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Time__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_new_Time__SWIG_3(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Time__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Time__SWIG_4(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "Time.new", 
+    "    Time.new()\n"
+    "    Time.new(GPS_Time< double > const &t)\n"
+    "    Time.new(std::tm const &t, GPS_Time< double >::float_t const &leap_seconds)\n"
+    "    Time.new(std::tm const &t)\n"
+    "    Time.new(int const &week_, GPS_Time< double >::float_t const &seconds_, void *dummy)\n");
+  
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::GPS::Time.to_a
 
@@ -19515,7 +19478,6 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassTime.klass, "week", VALUEFUNC(_wrap_Time_week_get), -1);
   rb_define_method(SwigClassTime.klass, "seconds=", VALUEFUNC(_wrap_Time_seconds_set), -1);
   rb_define_method(SwigClassTime.klass, "seconds", VALUEFUNC(_wrap_Time_seconds_get), -1);
-  rb_define_method(SwigClassTime.klass, "canonicalize", VALUEFUNC(_wrap_Time_canonicalize), -1);
   rb_define_singleton_method(SwigClassTime.klass, "now", VALUEFUNC(_wrap_Time_now), -1);
   rb_define_method(SwigClassTime.klass, "serialize", VALUEFUNC(_wrap_Time_serialize), -1);
   rb_define_method(SwigClassTime.klass, "+", VALUEFUNC(_wrap_Time___add__), -1);