gps_pvt 0.2.0 → 0.3.0

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

@@ -221,7 +221,11 @@ __RINEX_OBS_TEXT__
       f.path
     },
   }}
-  let(:solver){GPS::Solver::new}
+  let(:solver){
+    res = GPS::Solver::new
+    res.correction = {:gps_ionospheric => :klobuchar, :gps_tropospheric => :hopfield}
+    res
+  }
   
   describe 'demo' do
     it 'calculates position without any error' do
@@ -255,7 +259,6 @@ __RINEX_OBS_TEXT__
       [:alpha, :beta].each{|k|
         puts "Iono #{k}: #{sn.iono_utc.send(k)}"
       }
-      puts solver.gps_options.ionospheric_models
       
       meas.each{|prn, k, v|
         eph = sn.ephemeris(prn)
@@ -336,11 +339,26 @@ __RINEX_OBS_TEXT__
     
     it 'can be modified through hooks' do
       sn = solver.gps_space_node
+      expect(solver.correction[:gps_ionospheric]).to include(:klobuchar)
+      expect(solver.correction[:gps_tropospheric]).to include(:hopfield)
+      expect{solver.correction = nil}.to raise_error(RuntimeError)
+      expect{solver.correction = {
+        :gps_ionospheric => [proc{|t, usr_pos, sat_pos|
+              expect(t).to be_a_kind_of(GPS::Time)
+              expect(usr_pos).to be_a_kind_of(Coordinate::XYZ) unless usr_pos
+              expect(sat_pos).to be_a_kind_of(Coordinate::ENU) unless sat_pos
+              false
+            }, :klobuchar, :no_correction],
+        :options => {:f_10_7 => 10},
+      }}.not_to raise_error
+      expect(solver.correction[:gps_ionospheric]).to include(:no_correction)
+      expect(solver.correction[:options][:f_10_7]).to eq(10)
       sn.read(input[:rinex_nav])
       t_meas = GPS::Time::new(1849, 172413)
       sn.update_all_ephemeris(t_meas)
-      solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+      solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
         expect(input[:measurement]).to include(prn)
+        expect(meas).to be_a_kind_of(Hash)
         expect(t_arv).to be_a_kind_of(GPS::Time)
         expect(usr_pos).to be_a_kind_of(Coordinate::XYZ)
         expect(usr_vel).to be_a_kind_of(Coordinate::XYZ)
@@ -348,12 +366,30 @@ __RINEX_OBS_TEXT__
         weight = 1
         [weight, range_c, range_r, rate_rel_neg] + los_neg
       }
-      solver.hooks[:update_position_solution] = proc{|*mats|
-        mats.each{|mat|
+      solver.hooks[:update_position_solution] = proc{|mat_G, mat_W, mat_delta_r, temp_pvt|
+        expect(temp_pvt).to be_a_kind_of(GPS::PVT)
+        [mat_G, mat_W, mat_delta_r].each{|mat|
           expect(mat).to be_a_kind_of(SylphideMath::MatrixD)
+          expect(mat.rows).to be >= temp_pvt.used_satellites
+          expect(mat).to respond_to(:resize!)
         }
-        mat_G, mat_W, mat_delta_r = mats
       }
+      solver.hooks[:satellite_position] = proc{
+        i = 0
+        proc{|prn, time, pos|
+          expect(input[:measurement]).to include(prn)
+          expect(pos).to be_a_kind_of(Coordinate::XYZ).or eq(nil)
+          # System_XYZ or [x,y,z] or nil(= unknown position) are acceptable
+          case (i += 1) % 5
+          when 0
+            nil
+          when 1
+            pos.to_a
+          else
+            pos
+          end
+        }
+      }.call
       pvt = solver.solve(
           input[:measurement].collect{|prn, items|
             items.collect{|k, v| [prn, k, v]}

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

@@ -19,6 +19,12 @@ shared_examples 'Matrix' do
       expect( mat_type::new(*params[:rc]).rows ).to equal(params[:rc][0])
       expect( mat_type::new(*params[:rc]).columns ).to equal(params[:rc][1])
     end
+    it 'declines negative number argument' do
+      [[-1, 1], [1, -1]].each{|sf|
+        r, c = params[:rc].zip(sf).collect{|v1, v2| v1 * v2}
+        expect{ mat_type::new(r, c) }.to raise_error(ArgumentError)
+      }
+    end
     it 'accepts ([[]])' do
       expect{ mat_type::new(compare_with) }.not_to raise_error
       expect( mat_type::new(compare_with).rows ).to equal(params[:rc][0])
@@ -44,9 +50,11 @@ shared_examples 'Matrix' do
       a.define_singleton_method(:[]){|i, j| raise(IndexError) if i != j; 0}
       expect{ mat_type::new(a) }.to raise_error(IndexError)
 
-      a = a_gen.call
-      a.define_singleton_method(:row_size){-1}
-      expect{ mat_type::new(a) }.to raise_error(RuntimeError)
+      [:row_size, :column_size].each{|f|
+        a = a_gen.call
+        a.define_singleton_method(f){-1}
+        expect{ mat_type::new(a) }.to raise_error(RuntimeError)
+      }
     end
     it 'is invoked with I, identity, unit' do
       [:I, :identity, :unit].each{|f|
@@ -132,7 +140,7 @@ shared_examples 'Matrix' do
         expect(mat[:square].sum).to eq(Matrix[*mat[:square].to_a].sum)
         expect(mat[:not_square].sum).to eq(Matrix[*mat[:not_square].to_a].sum)
       end
-      it 'determinat, det' do
+      it 'determinant, det' do
         [:determinant, :det].each{|f|
           #expect(mat[:square].send(f)).to eq(Matrix[*mat[:square].to_a].det)
           expect{mat[:not_square].send(f)}.to raise_error(RuntimeError)
@@ -163,6 +171,15 @@ shared_examples 'Matrix' do
         }
       }
     end
+    it 'is inaccessible and unchangeable with negative number arguments' do
+      [[-1, 0], [0, -1]].each{|i, j|
+        [[:[], i, j], [:[]=, i, j, 0]].each{|args|
+          expect{ mat[0].send(*args) }.to raise_error{|err|
+            expect(err).to be_a(RangeError).or be_a(ArgumentError)
+          }
+        }
+      }
+    end
   end
   
   describe 'elements' do
@@ -394,6 +411,23 @@ shared_examples 'Matrix' do
       }
       expect{mat[2] / mat[3]}.to raise_error(RuntimeError)
     end
+    it 'have resize!' do
+      [-1, :sym].each{|arg|
+        [[arg, nil], [nil, arg]].each{|args|
+          expect{mat[0].resize!(*args)}.to raise_error{|err|
+            expect(err).to be_a(TypeError).or be_a(ArgumentError)
+          }
+        }
+      }
+      mat_orig = mat[0].to_a
+      r, c = [:rows, :columns].collect{|f| mat[0].send(f)}
+      expect(mat[0].resize!(r, c).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(r, nil).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(nil, c).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(nil, nil).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(r * 2, c * 2).to_a).to \
+          eq(Matrix::build(r * 2, c * 2){|i, j| (i < r && j < c) ? mat_orig[i][j] : 0}.to_a)
+    end
   end
   
   describe 'decomposition' do

data/gps_pvt.gemspec

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "lib/gps_pvt/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "gps_pvt"
+  spec.version = GPS_PVT::VERSION
+  spec.authors = ["fenrir(M.Naruoka)"]
+  spec.email = ["fenrir.naru@gmail.com"]
+
+  spec.summary = "GPS position, velocity, and time (PVT) solver"
+  spec.description = "This module calculate PVT by using raw observation obtained from a GPS receiver"
+  spec.homepage = "https://github.com/fenrir-naru/gps_pvt"
+  spec.required_ruby_version = ">= 2.3.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+    
+  spec.extensions = ["ext/gps_pvt/extconf.rb"]
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.files += proc{
+    require 'pathname'
+    base_dir = Pathname::new(File::absolute_path(File.dirname(__FILE__)))
+    # get an array of submodule dirs by executing 'pwd' inside each submodule
+    `git submodule --quiet foreach pwd`.split($/).collect{|dir|
+      # issue git ls-files in submodule's directory
+      `git -C #{dir} ls-files -v`.split($/).collect{|f|
+        next nil unless f =~ /^H */ # consider git sparse checkout
+        # get relative path
+        f = Pathname::new(File::join(dir, $'))
+        begin
+          (f.relative? ? f : f.relative_path_from(base_dir)).to_s
+        rescue
+          # Patch for Windows drive letter problem
+          base_dir = Pathname::new(base_dir.to_s.sub(/^([^\/])+:\//){"/#{$1}/"})
+          f.relative_path_from(base_dir).to_s
+        end
+      }.compact
+    }.flatten
+  }.call
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/gps_pvt/receiver.rb

@@ -47,23 +47,31 @@ class Receiver
     ]] + [
       [:used_satellites, proc{|pvt| pvt.used_satellites}],
     ] + opt[:system].collect{|sys, range|
-      bit_flip = if range.kind_of?(Array) then
-        proc{|res, i|
+      range = range.kind_of?(Array) ? proc{
+        # check whether inputs can be converted to Range
+        next nil if range.empty?
+        a, b = range.minmax
+        ((b - a) == (range.length - 1)) ? (a..b) : range
+      }.call : range
+      next nil unless range
+      bit_flip, label = case range
+      when Array
+        [proc{|res, i|
           res[i] = "1" if i = range.index(i)
           res
-        }
-      else # expect Range
+        }, range.collect{|pen| pen & 0xFF}.reverse.join('+')]
+      when Range
         base_prn = range.min
-        proc{|res, i|
+        [proc{|res, i|
           res[i - base_prn] = "1" if range.include?(i)
           res
-        }
+        }, [:max, :min].collect{|f| range.send(f) & 0xFF}.join('..')]
       end
-      ["#{sys}_PRN", proc{|pvt|
+      ["#{sys}_PRN(#{label})", proc{|pvt|
         pvt.used_satellite_list.inject("0" * range.size, &bit_flip) \
             .scan(/.{1,8}/).join('_').reverse
       }]
-    } + [[
+    }.compact + [[
       opt[:satellites].collect{|prn, label|
         [:range_residual, :weight, :azimuth, :elevation, :slopeH, :slopeV].collect{|str|
           "#{str}(#{label || prn})"
@@ -73,12 +81,12 @@ class Receiver
         next ([nil] * 6 * opt[:satellites].size) unless pvt.position_solved?
         sats = pvt.used_satellite_list
         r, w = [:delta_r, :W].collect{|f| pvt.send(f)}
-        opt[:satellites].collect{|i|
-          next ([nil] * 6) unless i2 = sats.index(i)
+        opt[:satellites].collect{|prn, label|
+          next ([nil] * 6) unless i2 = sats.index(prn)
           [r[i2, 0], w[i2, i2]] +
               [:azimuth, :elevation].collect{|f|
-                pvt.send(f)[i] / Math::PI * 180
-              } + [pvt.slopeH[i], pvt.slopeV[i]]
+                pvt.send(f)[prn] / Math::PI * 180
+              } + [pvt.slopeH[prn], pvt.slopeV[prn]]
         }.flatten
       },
     ]] + [[
@@ -106,16 +114,19 @@ class Receiver
     opt = {
       :satellites => (1..32).to_a,
     }.merge(opt)
+    keys = [:PSEUDORANGE, :RANGE_RATE, :DOPPLER, :FREQUENCY].collect{|k|
+      GPS::Measurement.const_get("L1_#{k}".to_sym)
+    }
     [[
       opt[:satellites].collect{|prn, label|
         [:L1_range, :L1_rate].collect{|str| "#{str}(#{label || prn})"}
       }.flatten,
       proc{|meas|
-        meas_hash = Hash[*(meas.collect{|prn, k, v| [[prn, k], v]}.flatten(1))]
-        opt[:satellites].collect{|prn|
-          [:L1_PSEUDORANGE, [:L1_DOPPLER, GPS::SpaceNode.L1_WaveLength]].collect{|k, sf|
-            meas_hash[[prn, GPS::Measurement.const_get(k)]] * (sf || 1) rescue nil
-          }
+        meas_hash = meas.to_hash
+        opt[:satellites].collect{|prn, label|
+          pr, rate, doppler, freq = keys.collect{|k| meas_hash[prn][k] rescue nil}
+          freq ||= GPS::SpaceNode.L1_Frequency
+          [pr, rate || ((doppler * GPS::SpaceNode::light_speed / freq) rescue nil)]
         }
       }
     ]]
@@ -130,11 +141,19 @@ class Receiver
 
   def initialize(options = {})
     @solver = GPS::Solver::new
-    @solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+    @solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
       rel_prop[0] = 1 if rel_prop[0] > 0 # weight = 1
       rel_prop
     }
     @debug = {}
+    solver_opts = [:gps_options, :sbas_options].collect{|target|
+      @solver.send(target)
+    }
+    solver_opts.each{|opt|
+      # default solver options
+      opt.elevation_mask = 0.0 / 180 * Math::PI # 0 deg (use satellite over horizon)
+      opt.residual_mask = 1E4 # 10 km (without residual filter, practically)
+    }
     output_options = {
       :system => [[:GPS, 1..32], [:QZSS, 193..202]],
       :satellites => (1..32).to_a + (193..202).to_a, # [idx, ...] or [[idx, label], ...] is acceptable
@@ -148,7 +167,7 @@ class Receiver
       when :weight
         case v.to_sym
         when :elevation # (same as underneath C++ library)
-          @solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+          @solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
             if rel_prop[0] > 0 then
               elv = Coordinate::ENU::relative_rel(
                   Coordinate::XYZ::new(*rel_prop[4..6]), usr_pos).elevation
@@ -160,6 +179,13 @@ class Receiver
         when :identical # same as default
           next true
         end
+      when :elevation_mask_deg
+        raise "Unknown elevation mask angle: #{v}" unless elv_deg = (Float(v) rescue nil)
+        $stderr.puts "Elevation mask: #{elv_deg} deg"
+        solver_opts.each{|opt|
+          opt.elevation_mask = elv_deg / 180 * Math::PI # 0 deg (use satellite over horizon)
+        }
+        next true
       when :base_station
         crd, sys = v.split(/ *, */).collect.with_index{|item, i|
           case item
@@ -193,9 +219,9 @@ class Receiver
           sys, svid = case spec
           when Integer
             [nil, spec]
-          when /([a-zA-Z]+)(?::(-?\d+))?/
-            [$1.upcase.to_sym, (Integre($2) rescue nil)]
-          when /-?\d+/
+          when /^([a-zA-Z]+)(?::(-?\d+))?$/
+            [$1.upcase.to_sym, (Integer($2) rescue nil)]
+          when /^-?\d+$/
             [nil, $&.to_i]
           else
             next false
@@ -206,27 +232,37 @@ class Receiver
           else
             (k == :with) ? :include : :exclude
           end
-          if (sys == :GPS) || (sys == :QZSS) \
-              || (svid && ((1..32).include?(svid) || (193..202).include?(svid))) then
-            [svid || ((1..32).to_a + (193..202).to_a)].flatten.each{
-              @solver.gps_options.send(mode, svid)
-            }
-          elsif (sys == :SBAS) || (svid && (120..158).include?(svid)) then
-            prns = [svid || (120..158).to_a].flatten
-            unless (i = output_options[:system].index{|sys, range| sys == :SBAS}) then
+          update_output = proc{|sys_target, prns, labels|
+            unless (i = output_options[:system].index{|sys, range| sys == sys_target}) then
               i = -1
-              output_options[:system] << [:SBAS, []]
+              output_options[:system] << [sys_target, []]
             else
-              output_options[:system][i].reject!{|prn| prns.include?(prn)}
+              output_options[:system][i][1].reject!{|prn| prns.include?(prn)}
             end
             output_options[:satellites].reject!{|prn, label| prns.include?(prn)}
             if mode == :include then
               output_options[:system][i][1] += prns
-              output_options[:satellites] += prns
+              output_options[:system][i][1].sort!
+              output_options[:satellites] += (labels ? prns.zip(labels) : prns)
+              output_options[:satellites].sort!{|a, b| [a].flatten[0] <=> [b].flatten[0]}
             end
+          }
+          check_sys_svid = proc{|sys_target, range_in_sys, offset|
+            next range_in_sys.include?(svid - (offset || 0)) unless sys # svid is specified without system
+            next false unless sys == sys_target
+            next true unless svid # All satellites in a target system (svid == nil)
+            range_in_sys.include?(svid)
+          }
+          if check_sys_svid.call(:GPS, 1..32) then
+            [svid || (1..32).to_a].flatten.each{|prn| @solver.gps_options.send(mode, prn)}
+          elsif check_sys_svid.call(:SBAS, 120..158) then
+            prns = [svid || (120..158).to_a].flatten
+            update_output.call(:SBAS, prns)
             prns.each{|prn| @solver.sbas_options.send(mode, prn)}
+          elsif check_sys_svid.call(:QZSS, 193..202) then
+            [svid || (193..202).to_a].flatten.each{|prn| @solver.gps_options.send(mode, prn)}
           else
-            next false  
+            raise "Unknown satellite: #{spec}"
           end
           $stderr.puts "#{mode.capitalize} satellite: #{[sys, svid].compact.join(':')}"
         }
@@ -235,10 +271,6 @@ class Receiver
       false
     }
     raise "Unknown receiver options: #{options.inspect}" unless options.empty?
-    proc{|opt|
-      opt.elevation_mask = 0.0 / 180 * Math::PI # 0 deg
-      opt.residual_mask = 1E4 # 10 km
-    }.call(@solver.gps_options)
     @output = {
       :pvt => Receiver::pvt_items(output_options),
       :meas => Receiver::meas_items(output_options),
@@ -316,6 +348,11 @@ class Receiver
     [:azimuth, :elevation, :slopeH, :slopeV].each{|k|
       eval("define_method(:#{k}){@#{k} || self.post_solution(:@#{k})}")
     }
+    define_method(:other_state){
+      # If a design matrix G has columns larger than 4, 
+      # other states excluding position and time are estimated.
+      (self.G.rows <= 4) ? [] : (self.S * self.delta_r).transpose.to_a[0][4..-1]
+    }
   }
   
   proc{
@@ -477,8 +514,15 @@ class Receiver
   end
   
   def parse_rinex_nav(fname)
-    $stderr.puts "Read RINEX NAV file (%s): %d items."%[
-        fname, @solver.gps_space_node.read(fname)]
+    items = [
+      @solver.gps_space_node,
+      @solver.sbas_space_node,
+    ].inject(0){|res, sn|
+      loaded_items = sn.send(:read, fname)
+      raise "Format error! (Not RINEX) #{fname}" if loaded_items < 0
+      res + loaded_items
+    }
+    $stderr.puts "Read RINEX NAV file (%s): %d items."%[fname, items]
   end
   
   def parse_rinex_obs(fname, &b)
@@ -515,7 +559,8 @@ class Receiver
         when 'J'; prn += 192
         else; next
         end
-        (types[sys] || []).each{|i, type_|
+        types[sys] = (types[' '] || []) unless types[sys]
+        types[sys].each{|i, type_|
           meas.add(prn, type_, v[i][0]) if v[i]
         }
       }

data/lib/gps_pvt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-26 00:00:00.000000000 Z
+date: 2022-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -89,6 +89,7 @@ files:
 - ext/ninja-scan-light/tool/swig/makefile
 - ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb
 - ext/ninja-scan-light/tool/swig/spec/SylphideMath_spec.rb
+- gps_pvt.gemspec
 - lib/gps_pvt.rb
 - lib/gps_pvt/receiver.rb
 - lib/gps_pvt/ubx.rb
@@ -99,7 +100,7 @@ licenses: []
 metadata:
   homepage_uri: https://github.com/fenrir-naru/gps_pvt
   source_code_uri: https://github.com/fenrir-naru/gps_pvt
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -114,8 +115,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: GPS position, velocity, and time (PVT) solver
 test_files: []