gps_pvt 0.8.1 → 0.8.3

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

@@ -57,13 +57,15 @@ struct GLONASS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<Floa
 
 template <class FloatT, class SolverBaseT = GPS_Solver_Base<FloatT> >
 class GLONASS_SinglePositioning : public SolverBaseT {
-  private:
-    GLONASS_SinglePositioning<FloatT> &operator=(const GLONASS_SinglePositioning<FloatT> &);
   public:
-    typedef GLONASS_SinglePositioning<FloatT> self_t;
+    typedef GLONASS_SinglePositioning<FloatT, SolverBaseT> self_t;
     typedef SolverBaseT base_t;
     typedef SolverBaseT super_t;
+  private:
+    self_t &operator=(const self_t &);
+    GLONASS_SinglePositioning(const self_t &);
 
+  public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename base_t::x x;
 #else

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

@@ -77,12 +77,14 @@ struct GPS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<FloatT>
 
 template <class FloatT, class SolverBaseT = GPS_Solver_Base<FloatT> >
 class GPS_SinglePositioning : public SolverBaseT {
-  private:
-    GPS_SinglePositioning<FloatT> &operator=(const GPS_SinglePositioning<FloatT> &);
   public:
-    typedef GPS_SinglePositioning<FloatT> self_t;
+    typedef GPS_SinglePositioning<FloatT, SolverBaseT> self_t;
     typedef SolverBaseT base_t;
+  private:
+    self_t &operator=(const self_t &);
+    GPS_SinglePositioning(const self_t &);
 
+  public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename base_t::x x;
 #else

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

@@ -52,6 +52,7 @@ class GPS_Solver_MultiFrequency : public BaseSolver {
     typedef BaseSolver super_t;
   private:
     self_t &operator=(const self_t &);
+    GPS_Solver_MultiFrequency(const self_t &);
   public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename super_t::x x;

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

@@ -56,12 +56,14 @@ struct SBAS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<FloatT>
 
 template <class FloatT, class SolverBaseT = GPS_Solver_Base<FloatT> >
 class SBAS_SinglePositioning : public SolverBaseT {
-  private:
-    SBAS_SinglePositioning<FloatT> &operator=(const SBAS_SinglePositioning<FloatT> &);
   public:
-    typedef SBAS_SinglePositioning<FloatT> self_t;
+    typedef SBAS_SinglePositioning<FloatT, SolverBaseT> self_t;
     typedef SolverBaseT base_t;
+  private:
+    self_t &operator=(const self_t &);
+    SBAS_SinglePositioning(const self_t &);
 
+  public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename base_t::x x;
 #else

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"
 
@@ -157,6 +158,16 @@ static std::string inspect_str(const VALUE &v){
   %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) const std::tm & {
     $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
   }
+  %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){
+      rb_ary_push($result,
+          rb_ary_new3(3,
+            SWIG_From(int)($1[i].corrected.week),
+            swig::from($1[i].corrected.seconds),
+            SWIG_From(int)($1[i].leap_seconds)));
+    }
+  }
 #endif
   %ignore canonicalize();
   %ignore GPS_Time(const int &_week, const float_t &_seconds);
@@ -1119,6 +1130,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){
@@ -1142,7 +1163,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>
@@ -1156,17 +1177,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;}
 };
@@ -1236,7 +1263,8 @@ template <class BaseT, class HookT>
 struct HookableSolver : public BaseT {
   typedef BaseT base_t;
   HookT *hook;
-  HookableSolver(const BaseT &base) : BaseT(base), hook(NULL) {}
+  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,
@@ -1289,6 +1317,20 @@ struct HookableSolver : public BaseT {
       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(
@@ -1581,7 +1623,9 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    HookableSolver<GPS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    HookableSolver<
+        GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+        GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -1603,19 +1647,21 @@ struct GPS_Solver
         solver.satellites.impl_select = forward;
       }
     } ephemeris_proxy;
-    gps_t() : space_node(), options(), solver(GPS_SinglePositioning<FloatT>(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;
     HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
-    sbas_t() : space_node(), options(), solver(SBAS_SinglePositioning<FloatT>(space_node)) {}
+    sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
   struct glonass_t {
     GLONASS_SpaceNode<FloatT> space_node;
     GLONASS_SolverOptions<FloatT> options;
     HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
-    glonass_t() : space_node(), options(), solver(GLONASS_SinglePositioning<FloatT>(space_node)) {}
+    glonass_t() : space_node(), options(), solver(space_node) {}
   } glonass;
   SWIG_Object hooks;
   typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;

data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb

@@ -759,6 +759,10 @@ __RINEX_CLK_TEXT__
       puts "Measurement time: #{t_meas.to_a} (a.k.a #{"%d/%d/%d %02d:%02d:%02d UTC"%[*t_meas.c_tm]})"
       expect(t_meas.c_tm).to eq([2015, 6, 15, 23, 53, 33])
       expect(GPS::Time::new(0, t_meas.serialize)).to eq(t_meas)
+      expect(t_meas.leap_seconds).to eq(sn.iono_utc.delta_t_LS)
+      expect(GPS::Time::leap_second_events.select{|wn, sec, leap|
+        t_meas >= GPS::Time::new(wn, sec)
+      }[0][2]).to eq(sn.iono_utc.delta_t_LS)
       
       sn.update_all_ephemeris(t_meas)
       
@@ -924,6 +928,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/lib/gps_pvt/receiver/extension.rb

@@ -29,15 +29,24 @@ class Receiver
     return (eph.valid?(t) ? eph : nil)
   end
 
-  def attach_online_ephemeris(uri_template = nil)
-    if (!uri_template) || (uri_template =~ /^\s*$/) then
-      uri_template = "ftp://gssc.esa.int/gnss/data/daily/%Y/brdc/BRDC00IGS_R_%Y%j0000_01D_MN.rnx.gz"
-    end
+  def attach_online_ephemeris(uri_template = [nil])
+    uri_template = uri_template.collect{|v|
+      if (!v) || (v =~ /^\s*$/) then
+        "ftp://gssc.esa.int/gnss/data/daily/%Y/brdc/BRDC00IGS_R_%Y%j0000_01D_MN.rnx.gz"
+      else
+        v
+      end
+    }.uniq
     loader = proc{|t_meas|
       utc = Time::utc(*t_meas.c_tm)
-      uri = URI::parse(utc.strftime(uri_template))
-      self.parse_rinex_nav(uri)
-      uri
+      uri_template.each{|v|
+        uri = URI::parse(utc.strftime(v))
+        begin
+          self.parse_rinex_nav(uri)
+        rescue Net::FTPError, Net::HTTPExceptions => e
+          $stderr.puts "Skip to read due to %s (%s)"%[e.inspect.gsub(/[\r\n]/, ' '), uri]
+        end
+      }
     }
     run_orig = self.method(:run)
     eph_list = {}

data/lib/gps_pvt/receiver.rb

@@ -290,6 +290,11 @@ class Receiver
       when :fault_exclusion
         @solver.options = {:skip_exclusion => !(output_options[:FDE] = v.to_b)}
         next true
+      when :use_signal
+        {
+          :GPS_L2C => proc{@solver.gps_options.exclude_L2C = false},
+        }[v.to_sym].call rescue next false
+        next true
       end
       false
     }
@@ -334,9 +339,9 @@ class Receiver
         }.flatten(1))]
       }
     }.call
-    alias_method(:add_orig, :add)
+    add_orig = instance_method(:add)
     define_method(:add){|prn, key, value|
-      add_orig(prn, key.kind_of?(Symbol) ? GPS::Measurement.const_get(key) : key, value)
+      add_orig.bind(self).call(prn, key.kind_of?(Symbol) ? GPS::Measurement.const_get(key) : key, value)
     }
   }
 
@@ -523,33 +528,39 @@ class Receiver
             v
           }
           sys, svid = gnss_serial.call(*loader.call(36, 2).reverse)
-          # sigID check to restrict signal to L1 if version(>0); @see UBX-18010854
-          next if (packet[6 + 13] != 0) && (loader.call(38, 1, "C") != 0)
+          sigid = (packet[6 + 13] != 0) ? loader.call(38, 1, "C") : 0 # sigID if version(>0); @see UBX-18010854 
           case sys
-          when :GPS, :SBAS, :QZSS;
+          when :GPS
+            sigid = {0 => :L1, 3 => :L2CL, 4 => :L2CM}[sigid]
+          when :SBAS
+            sigid = :L1
+          when :QZSS
+            sigid = {0 => :L1, 5 => :L2CL, 4 => :L2CM}[sigid]
           when :GLONASS
             svid += 0x100
+            sigid = {0 => :L1}[sigid] # TODO: to support {2 -> :L2}
             meas.add(svid, :L1_FREQUENCY, 
                 GPS::SpaceNode_GLONASS::L1_frequency(loader.call(39, 1, "C") - 7))
           else; next
           end
+          next unless sigid
           trk_stat = loader.call(46, 1)[0]
           {
-            :L1_PSEUDORANGE => [16, 8, "E", proc{|v| (trk_stat & 0x1 == 0x1) ? v : nil}],
-            :L1_PSEUDORANGE_SIGMA => [43, 1, nil, proc{|v|
+            :PSEUDORANGE => [16, 8, "E", proc{|v| (trk_stat & 0x1 == 0x1) ? v : nil}],
+            :PSEUDORANGE_SIGMA => [43, 1, nil, proc{|v|
               (trk_stat & 0x1 == 0x1) ? (1E-2 * (1 << (v[0] & 0xF))) : nil
             }],
-            :L1_DOPPLER => [32, 4, "e"],
-            :L1_DOPPLER_SIGMA => [45, 1, nil, proc{|v| 2E-3 * (1 << (v[0] & 0xF))}],
-            :L1_CARRIER_PHASE => [24, 8, "E", proc{|v| (trk_stat & 0x2 == 0x2) ? v : nil}],
-            :L1_CARRIER_PHASE_SIGMA => [44, 1, nil, proc{|v|
+            :DOPPLER => [32, 4, "e"],
+            :DOPPLER_SIGMA => [45, 1, nil, proc{|v| 2E-3 * (1 << (v[0] & 0xF))}],
+            :CARRIER_PHASE => [24, 8, "E", proc{|v| (trk_stat & 0x2 == 0x2) ? v : nil}],
+            :CARRIER_PHASE_SIGMA => [44, 1, nil, proc{|v|
               (trk_stat & 0x2 == 0x2) ? (0.004 * (v[0] & 0xF)) : nil
             }],
-            :L1_SIGNAL_STRENGTH_dBHz => [42, 1, "C"],
-            :L1_LOCK_SEC => [40, 2, "v", proc{|v| 1E-3 * v}],
+            :SIGNAL_STRENGTH_dBHz => [42, 1, "C"],
+            :LOCK_SEC => [40, 2, "v", proc{|v| 1E-3 * v}],
           }.each{|k, prop|
             next unless v = loader.call(*prop)
-            meas.add(svid, k, v)
+            meas.add(svid, "#{sigid}_#{k}".to_sym, v) rescue nil # unsupported signal
           }
         }
         after_run.call(run(meas, t_meas), [meas, t_meas])
@@ -605,18 +616,19 @@ class Receiver
 
       types ||= Hash[*(item[:meas_types].collect{|sys, values|
         [sys, values.collect.with_index{|type_, i|
-          case type_
-          when "C1", "C1C"
-            [i, :L1_PSEUDORANGE]
-          when "L1", "L1C"
-            [i, :L1_CARRIER_PHASE]
-          when "D1", "D1C"
-            [i, :L1_DOPPLER]
-          when "S1", "S1C"
-            [i, :L1_SIGNAL_STRENGTH_dBHz]
-          else
-            nil 
-          end
+          sig_obs_type = [case type_[1..-1]
+            when /^1C?$/; :L1
+            when /^2[XL]$/; :L2CL
+            when /^2S$/; :L2CM
+            else; nil
+          end, {
+            'C' => :PSEUDORANGE,
+            'L' => :CARRIER_PHASE,
+            'D' => :DOPPLER,
+            'S' => :SIGNAL_STRENGTH_dBHz,
+          }[type_[0]]]
+          next nil unless sig_obs_type.all?
+          [i, sig_obs_type.join('_').to_sym]
         }.compact]
       }.flatten(1))]
 

data/lib/gps_pvt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-17 00:00:00.000000000 Z
+date: 2022-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial