gps_pvt 0.2.0 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +33 -6
- data/Rakefile +0 -0
- data/exe/gps_pvt +28 -19
- data/ext/gps_pvt/GPS/GPS_wrap.cxx +596 -467
- data/ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx +277 -14
- data/ext/ninja-scan-light/tool/navigation/GPS.h +8 -43
- data/ext/ninja-scan-light/tool/navigation/GPS_Solver.h +61 -147
- data/ext/ninja-scan-light/tool/navigation/GPS_Solver_Base.h +83 -22
- data/ext/ninja-scan-light/tool/navigation/RINEX.h +15 -5
- data/ext/ninja-scan-light/tool/navigation/SBAS.h +2 -2
- data/ext/ninja-scan-light/tool/navigation/SBAS_Solver.h +55 -78
- data/ext/ninja-scan-light/tool/param/bit_array.h +4 -3
- data/ext/ninja-scan-light/tool/swig/GPS.i +342 -103
- data/ext/ninja-scan-light/tool/swig/SylphideMath.i +53 -6
- data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb +42 -6
- data/ext/ninja-scan-light/tool/swig/spec/SylphideMath_spec.rb +38 -4
- data/gps_pvt.gemspec +63 -0
- data/lib/gps_pvt/receiver.rb +86 -41
- data/lib/gps_pvt/version.rb +1 -1
- metadata +7 -6
@@ -1889,12 +1889,12 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
|
|
1889
1889
|
#define SWIGTYPE_p_llh_t swig_types[39]
|
1890
1890
|
#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t swig_types[40]
|
1891
1891
|
#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t swig_types[41]
|
1892
|
-
#define
|
1893
|
-
#define
|
1894
|
-
#define
|
1895
|
-
#define
|
1896
|
-
#define
|
1897
|
-
#define
|
1892
|
+
#define SWIGTYPE_p_range_correction_list_t swig_types[42]
|
1893
|
+
#define SWIGTYPE_p_s16_t swig_types[43]
|
1894
|
+
#define SWIGTYPE_p_s32_t swig_types[44]
|
1895
|
+
#define SWIGTYPE_p_s8_t swig_types[45]
|
1896
|
+
#define SWIGTYPE_p_satellites_t swig_types[46]
|
1897
|
+
#define SWIGTYPE_p_self_t swig_types[47]
|
1898
1898
|
#define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[48]
|
1899
1899
|
#define SWIGTYPE_p_swig__GC_VALUE swig_types[49]
|
1900
1900
|
#define SWIGTYPE_p_u16_t swig_types[50]
|
@@ -2465,6 +2465,7 @@ struct GPS_Measurement {
|
|
2465
2465
|
L1_RANGE_RATE_SIGMA,
|
2466
2466
|
L1_SIGNAL_STRENGTH_dBHz,
|
2467
2467
|
L1_LOCK_SEC,
|
2468
|
+
L1_FREQUENCY,
|
2468
2469
|
ITEMS_PREDEFINED,
|
2469
2470
|
};
|
2470
2471
|
void add(const int &prn, const int &key, const FloatT &value){
|
@@ -2475,43 +2476,8 @@ struct GPS_Measurement {
|
|
2475
2476
|
|
2476
2477
|
template <class FloatT>
|
2477
2478
|
struct GPS_SolverOptions_Common {
|
2478
|
-
enum {
|
2479
|
-
IONOSPHERIC_KLOBUCHAR,
|
2480
|
-
IONOSPHERIC_SBAS,
|
2481
|
-
IONOSPHERIC_NTCM_GL,
|
2482
|
-
IONOSPHERIC_NONE, // which allows no correction
|
2483
|
-
IONOSPHERIC_MODELS,
|
2484
|
-
IONOSPHERIC_SKIP = IONOSPHERIC_MODELS, // which means delegating the next slot
|
2485
|
-
};
|
2486
2479
|
virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
|
2487
2480
|
virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
|
2488
|
-
std::vector<int> get_ionospheric_models() const {
|
2489
|
-
typedef GPS_Solver_GeneralOptions<FloatT> general_t;
|
2490
|
-
const general_t *general(this->cast_general());
|
2491
|
-
std::vector<int> res;
|
2492
|
-
for(int i(0); i < general_t::IONOSPHERIC_MODELS; ++i){
|
2493
|
-
int v((int)(general->ionospheric_models[i]));
|
2494
|
-
if(v == general_t::IONOSPHERIC_SKIP){break;}
|
2495
|
-
res.push_back(v);
|
2496
|
-
}
|
2497
|
-
return res;
|
2498
|
-
}
|
2499
|
-
std::vector<int> set_ionospheric_models(const std::vector<int> &models){
|
2500
|
-
typedef GPS_Solver_GeneralOptions<FloatT> general_t;
|
2501
|
-
general_t *general(this->cast_general());
|
2502
|
-
typedef typename general_t::ionospheric_model_t model_t;
|
2503
|
-
for(int i(0), j(0), j_max(models.size()); i < general_t::IONOSPHERIC_MODELS; ++i){
|
2504
|
-
model_t v(general_t::IONOSPHERIC_SKIP);
|
2505
|
-
if(j < j_max){
|
2506
|
-
if((models[j] >= 0) && (models[j] < general_t::IONOSPHERIC_SKIP)){
|
2507
|
-
v = (model_t)models[j];
|
2508
|
-
}
|
2509
|
-
++j;
|
2510
|
-
}
|
2511
|
-
general->ionospheric_models[i] = v;
|
2512
|
-
}
|
2513
|
-
return get_ionospheric_models();
|
2514
|
-
}
|
2515
2481
|
};
|
2516
2482
|
|
2517
2483
|
|
@@ -2541,6 +2507,26 @@ struct SBAS_SolverOptions
|
|
2541
2507
|
};
|
2542
2508
|
|
2543
2509
|
|
2510
|
+
template <class FloatT>
|
2511
|
+
struct GPS_RangeCorrector
|
2512
|
+
: public GPS_Solver_Base<FloatT>::range_corrector_t {
|
2513
|
+
VALUE callback;
|
2514
|
+
GPS_RangeCorrector(const VALUE &callback_)
|
2515
|
+
: GPS_Solver_Base<FloatT>::range_corrector_t(),
|
2516
|
+
callback(callback_) {}
|
2517
|
+
bool is_available(const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
|
2518
|
+
return false;
|
2519
|
+
}
|
2520
|
+
FloatT *calculate(
|
2521
|
+
const typename GPS_Solver_Base<FloatT>::gps_time_t &t,
|
2522
|
+
const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos,
|
2523
|
+
const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
|
2524
|
+
FloatT &buf) const {
|
2525
|
+
return NULL;
|
2526
|
+
}
|
2527
|
+
};
|
2528
|
+
|
2529
|
+
|
2544
2530
|
template <class FloatT>
|
2545
2531
|
struct GPS_Solver
|
2546
2532
|
: public GPS_Solver_RAIM_LSR<FloatT,
|
@@ -2561,19 +2547,36 @@ struct GPS_Solver
|
|
2561
2547
|
sbas_t() : space_node(), options(), solver(space_node) {}
|
2562
2548
|
} sbas;
|
2563
2549
|
VALUE hooks;
|
2550
|
+
typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
|
2551
|
+
user_correctors_t user_correctors;
|
2564
2552
|
|
2565
2553
|
static void mark(void *ptr){
|
2566
2554
|
GPS_Solver<FloatT> *solver = (GPS_Solver<FloatT> *)ptr;
|
2567
|
-
if(solver->hooks == Qnil){return;}
|
2568
2555
|
rb_gc_mark(solver->hooks);
|
2556
|
+
for(typename user_correctors_t::const_iterator
|
2557
|
+
it(solver->user_correctors.begin()), it_end(solver->user_correctors.end());
|
2558
|
+
it != it_end; ++it){
|
2559
|
+
rb_gc_mark(it->callback);
|
2560
|
+
}
|
2569
2561
|
}
|
2570
2562
|
|
2571
|
-
GPS_Solver() : super_t(),
|
2572
|
-
|
2573
|
-
|
2563
|
+
GPS_Solver() : super_t(),
|
2564
|
+
gps(), sbas(),
|
2565
|
+
hooks(), user_correctors() {
|
2574
2566
|
|
2575
2567
|
hooks = rb_hash_new();
|
2576
2568
|
|
2569
|
+
typename base_t::range_correction_t ionospheric, tropospheric;
|
2570
|
+
ionospheric.push_back(&sbas.solver.ionospheric_sbas);
|
2571
|
+
ionospheric.push_back(&gps.solver.ionospheric_klobuchar);
|
2572
|
+
tropospheric.push_back(&sbas.solver.tropospheric_sbas);
|
2573
|
+
tropospheric.push_back(&gps.solver.tropospheric_simplified);
|
2574
|
+
gps.solver.ionospheric_correction
|
2575
|
+
= sbas.solver.ionospheric_correction
|
2576
|
+
= ionospheric;
|
2577
|
+
gps.solver.tropospheric_correction
|
2578
|
+
= sbas.solver.tropospheric_correction
|
2579
|
+
= tropospheric;
|
2577
2580
|
}
|
2578
2581
|
GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
|
2579
2582
|
GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
|
@@ -2584,7 +2587,11 @@ struct GPS_Solver
|
|
2584
2587
|
if(prn > 0 && prn <= 32){return gps.solver;}
|
2585
2588
|
if(prn >= 120 && prn <= 158){return sbas.solver;}
|
2586
2589
|
if(prn > 192 && prn <= 202){return gps.solver;}
|
2587
|
-
|
2590
|
+
// call order: base_t::solve => this returned by select()
|
2591
|
+
// => relative_property() => select_solver()
|
2592
|
+
// For not supported satellite, call loop prevention is required.
|
2593
|
+
static const base_t dummy;
|
2594
|
+
return dummy;
|
2588
2595
|
}
|
2589
2596
|
virtual typename base_t::relative_property_t relative_property(
|
2590
2597
|
const typename base_t::prn_t &prn,
|
@@ -2596,9 +2603,7 @@ struct GPS_Solver
|
|
2596
2603
|
virtual typename base_t::xyz_t *satellite_position(
|
2597
2604
|
const typename base_t::prn_t &prn,
|
2598
2605
|
const typename base_t::gps_time_t &time,
|
2599
|
-
typename base_t::xyz_t &res) const
|
2600
|
-
return select_solver(prn).satellite_position(prn, time, res);
|
2601
|
-
}
|
2606
|
+
typename base_t::xyz_t &res) const;
|
2602
2607
|
virtual bool update_position_solution(
|
2603
2608
|
const typename base_t::geometric_matrices_t &geomat,
|
2604
2609
|
typename base_t::user_pvt_t &res) const;
|
@@ -2611,6 +2616,53 @@ struct GPS_Solver
|
|
2611
2616
|
const_cast<sbas_t &>(sbas).solver.update_options(sbas.options);
|
2612
2617
|
return super_t::solve().user_pvt(measurement.items, receiver_time);
|
2613
2618
|
}
|
2619
|
+
typedef
|
2620
|
+
std::map<int, std::vector<const typename base_t::range_corrector_t *> >
|
2621
|
+
range_correction_list_t;
|
2622
|
+
range_correction_list_t update_correction(
|
2623
|
+
const bool &update,
|
2624
|
+
const range_correction_list_t &list = range_correction_list_t()){
|
2625
|
+
range_correction_list_t res;
|
2626
|
+
typename base_t::range_correction_t *root[] = {
|
2627
|
+
&gps.solver.ionospheric_correction,
|
2628
|
+
&gps.solver.tropospheric_correction,
|
2629
|
+
&sbas.solver.ionospheric_correction,
|
2630
|
+
&sbas.solver.tropospheric_correction,
|
2631
|
+
};
|
2632
|
+
for(std::size_t i(0); i < sizeof(root) / sizeof(root[0]); ++i){
|
2633
|
+
do{
|
2634
|
+
if(!update){break;}
|
2635
|
+
typename range_correction_list_t::const_iterator it(list.find(i));
|
2636
|
+
if(it == list.end()){break;}
|
2637
|
+
|
2638
|
+
// Remove user defined unused correctors
|
2639
|
+
for(typename base_t::range_correction_t::const_iterator
|
2640
|
+
it2(root[i]->begin()), it2_end(root[i]->end());
|
2641
|
+
it2 != it2_end; ++it2){
|
2642
|
+
for(typename user_correctors_t::const_iterator
|
2643
|
+
it3(user_correctors.begin()), it3_end(user_correctors.end());
|
2644
|
+
it3 != it3_end; ++it3){
|
2645
|
+
if(*it2 != &(*it3)){continue;}
|
2646
|
+
user_correctors.erase(it3);
|
2647
|
+
}
|
2648
|
+
}
|
2649
|
+
|
2650
|
+
root[i]->clear();
|
2651
|
+
for(typename range_correction_list_t::mapped_type::const_iterator
|
2652
|
+
it2(it->second.begin()), it2_end(it->second.end());
|
2653
|
+
it2 != it2_end; ++it2){
|
2654
|
+
root[i]->push_back(*it2);
|
2655
|
+
}
|
2656
|
+
}while(false);
|
2657
|
+
for(typename base_t::range_correction_t::const_iterator
|
2658
|
+
it(root[i]->begin()), it_end(root[i]->end());
|
2659
|
+
it != it_end; ++it){
|
2660
|
+
res[i].push_back(*it);
|
2661
|
+
}
|
2662
|
+
}
|
2663
|
+
return res;
|
2664
|
+
}
|
2665
|
+
VALUE update_correction(const bool &update, const VALUE &hash);
|
2614
2666
|
};
|
2615
2667
|
|
2616
2668
|
|
@@ -2848,6 +2900,12 @@ SWIGINTERN void GPS_Time_Sl_double_Sg__to_a(GPS_Time< double > const *self,int *
|
|
2848
2900
|
*week = self->week;
|
2849
2901
|
*seconds = self->seconds;
|
2850
2902
|
}
|
2903
|
+
SWIGINTERN int GPS_Time_Sl_double_Sg____cmp__(GPS_Time< double > const *self,GPS_Time< double > const &t){
|
2904
|
+
return ((self->week < t.week) ? -1
|
2905
|
+
: ((self->week > t.week) ? 1
|
2906
|
+
: (self->seconds < t.seconds ? -1
|
2907
|
+
: (self->seconds > t.seconds ? 1 : 0))));
|
2908
|
+
}
|
2851
2909
|
|
2852
2910
|
namespace swig {
|
2853
2911
|
template <class Type>
|
@@ -3200,11 +3258,8 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
|
|
3200
3258
|
|
3201
3259
|
SWIGINTERN int GPS_SpaceNode_Sl_double_Sg__read(GPS_SpaceNode< double > *self,char const *fname){
|
3202
3260
|
std::fstream fin(fname, std::ios::in | std::ios::binary);
|
3203
|
-
typename RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {
|
3204
|
-
|
3205
|
-
NULL, // SBAS
|
3206
|
-
self, // QZSS
|
3207
|
-
};
|
3261
|
+
typename RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {self};
|
3262
|
+
space_nodes.qzss = self;
|
3208
3263
|
return RINEX_NAV_Reader<double>::read_all(fin, space_nodes);
|
3209
3264
|
}
|
3210
3265
|
SWIGINTERN void GPS_Ionospheric_UTC_Parameters_Sl_double_Sg__set_alpha(GPS_Ionospheric_UTC_Parameters< double > *self,double const values[4]){
|
@@ -3593,6 +3648,18 @@ SWIGINTERN void GPS_Ephemeris_Sl_double_Sg__constellation__SWIG_0(GPS_Ephemeris<
|
|
3593
3648
|
|
3594
3649
|
return SWIG_ERROR;
|
3595
3650
|
}
|
3651
|
+
|
3652
|
+
template <>
|
3653
|
+
VALUE from(const GPS_Measurement<double>::items_t::mapped_type &val) {
|
3654
|
+
VALUE per_sat(rb_hash_new());
|
3655
|
+
for(typename GPS_Measurement<double>::items_t::mapped_type::const_iterator
|
3656
|
+
it(val.begin()), it_end(val.end());
|
3657
|
+
it != it_end; ++it){
|
3658
|
+
rb_hash_aset(per_sat, SWIG_From_int (it->first), swig::from(it->second));
|
3659
|
+
}
|
3660
|
+
return per_sat;
|
3661
|
+
}
|
3662
|
+
|
3596
3663
|
}
|
3597
3664
|
|
3598
3665
|
SWIGINTERN void GPS_Measurement_Sl_double_Sg__each(GPS_Measurement< double > const *self){
|
@@ -3618,13 +3685,7 @@ SWIGINTERN VALUE GPS_Measurement_Sl_double_Sg__to_hash(GPS_Measurement< double >
|
|
3618
3685
|
for(typename GPS_Measurement<double>::items_t::const_iterator
|
3619
3686
|
it(self->items.begin()), it_end(self->items.end());
|
3620
3687
|
it != it_end; ++it){
|
3621
|
-
|
3622
|
-
rb_hash_aset(res, SWIG_From_int (it->first), per_sat);
|
3623
|
-
for(typename GPS_Measurement<double>::items_t::mapped_type::const_iterator
|
3624
|
-
it2(it->second.begin()), it2_end(it->second.end());
|
3625
|
-
it2 != it2_end; ++it2){
|
3626
|
-
rb_hash_aset(per_sat, SWIG_From_int (it2->first), swig::from(it2->second));
|
3627
|
-
}
|
3688
|
+
rb_hash_aset(res, SWIG_From_int (it->first), swig::from(it->second));
|
3628
3689
|
}
|
3629
3690
|
return res;
|
3630
3691
|
}
|
@@ -3640,24 +3701,18 @@ SWIGINTERN double GPS_SolverOptions_Common_Sl_double_Sg__set_residual_mask(GPS_S
|
|
3640
3701
|
SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mask(GPS_SolverOptions_Common< double > const *self){
|
3641
3702
|
return self->cast_general()->residual_mask;
|
3642
3703
|
}
|
3643
|
-
SWIGINTERN double GPS_SolverOptions_Common_Sl_double_Sg__set_f_10_7(GPS_SolverOptions_Common< double > *self,double const &v){
|
3644
|
-
return self->cast_general()->f_10_7 = v;
|
3645
|
-
}
|
3646
|
-
SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_SolverOptions_Common< double > const *self){
|
3647
|
-
return self->cast_general()->f_10_7;
|
3648
|
-
}
|
3649
3704
|
|
3650
3705
|
template <>
|
3651
|
-
|
3706
|
+
GPS_Solver<double>::base_t::relative_property_t
|
3652
3707
|
GPS_Solver<double>::relative_property(
|
3653
|
-
const
|
3654
|
-
const
|
3655
|
-
const
|
3656
|
-
const
|
3657
|
-
const
|
3658
|
-
const
|
3708
|
+
const GPS_Solver<double>::base_t::prn_t &prn,
|
3709
|
+
const GPS_Solver<double>::base_t::measurement_t::mapped_type &measurement,
|
3710
|
+
const GPS_Solver<double>::base_t::float_t &receiver_error,
|
3711
|
+
const GPS_Solver<double>::base_t::gps_time_t &time_arrival,
|
3712
|
+
const GPS_Solver<double>::base_t::pos_t &usr_pos,
|
3713
|
+
const GPS_Solver<double>::base_t::xyz_t &usr_vel) const {
|
3659
3714
|
union {
|
3660
|
-
|
3715
|
+
base_t::relative_property_t prop;
|
3661
3716
|
double values[7];
|
3662
3717
|
} res = {
|
3663
3718
|
select_solver(prn).relative_property(
|
@@ -3679,6 +3734,7 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
|
|
3679
3734
|
swig::from(res.prop.los_neg[0]),
|
3680
3735
|
swig::from(res.prop.los_neg[1]),
|
3681
3736
|
swig::from(res.prop.los_neg[2])),
|
3737
|
+
swig::from(measurement), // measurement => Hash
|
3682
3738
|
swig::from(receiver_error), // receiver_error
|
3683
3739
|
SWIG_NewPointerObj( // time_arrival
|
3684
3740
|
new base_t::gps_time_t(time_arrival), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN),
|
@@ -3709,28 +3765,213 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7(GPS_S
|
|
3709
3765
|
}
|
3710
3766
|
template <>
|
3711
3767
|
bool GPS_Solver<double>::update_position_solution(
|
3712
|
-
const
|
3713
|
-
|
3768
|
+
const GPS_Solver<double>::base_t::geometric_matrices_t &geomat,
|
3769
|
+
GPS_Solver<double>::base_t::user_pvt_t &res) const {
|
3714
3770
|
|
3715
3771
|
do{
|
3716
3772
|
static const VALUE key(ID2SYM(rb_intern("update_position_solution")));
|
3717
3773
|
VALUE hook(rb_hash_lookup(hooks, key));
|
3718
3774
|
if(NIL_P(hook)){break;}
|
3719
|
-
|
3720
|
-
const_cast<
|
3775
|
+
base_t::geometric_matrices_t &geomat_(
|
3776
|
+
const_cast< base_t::geometric_matrices_t & >(geomat));
|
3721
3777
|
VALUE values[] = {
|
3722
3778
|
SWIG_NewPointerObj(&geomat_.G,
|
3723
3779
|
SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
|
3724
3780
|
SWIG_NewPointerObj(&geomat_.W,
|
3725
3781
|
SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
|
3726
3782
|
SWIG_NewPointerObj(&geomat_.delta_r,
|
3727
|
-
SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0)
|
3783
|
+
SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0),
|
3784
|
+
SWIG_NewPointerObj(&res,
|
3785
|
+
SWIGTYPE_p_GPS_User_PVTT_double_t, 0)};
|
3728
3786
|
proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values);
|
3729
3787
|
}while(false);
|
3730
3788
|
|
3731
3789
|
return super_t::update_position_solution(geomat, res);
|
3732
3790
|
}
|
3791
|
+
template <>
|
3792
|
+
GPS_Solver<double>::base_t::xyz_t *GPS_Solver<double>::satellite_position(
|
3793
|
+
const GPS_Solver<double>::base_t::prn_t &prn,
|
3794
|
+
const GPS_Solver<double>::base_t::gps_time_t &time,
|
3795
|
+
GPS_Solver<double>::base_t::xyz_t &buf) const {
|
3796
|
+
GPS_Solver<double>::base_t::xyz_t *res(
|
3797
|
+
select_solver(prn).satellite_position(prn, time, buf));
|
3798
|
+
|
3799
|
+
do{
|
3800
|
+
static const VALUE key(ID2SYM(rb_intern("satellite_position")));
|
3801
|
+
VALUE hook(rb_hash_lookup(hooks, key));
|
3802
|
+
if(NIL_P(hook)){break;}
|
3803
|
+
VALUE values[] = {
|
3804
|
+
SWIG_From_int (prn), // prn
|
3805
|
+
SWIG_NewPointerObj( // time
|
3806
|
+
new base_t::gps_time_t(time), SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_OWN),
|
3807
|
+
(res // position (internally calculated)
|
3808
|
+
? SWIG_NewPointerObj(res, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0)
|
3809
|
+
: Qnil)};
|
3810
|
+
VALUE res_hook(proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values));
|
3811
|
+
if(NIL_P(res_hook)){ // unknown position
|
3812
|
+
res = NULL;
|
3813
|
+
break;
|
3814
|
+
}else if(RB_TYPE_P(res_hook, T_ARRAY) && (RARRAY_LEN(res_hook) == 3)){
|
3815
|
+
int i(0);
|
3816
|
+
for(; i < 3; ++i){
|
3817
|
+
VALUE v(RARRAY_AREF(res_hook, i));
|
3818
|
+
if(!SWIG_IsOK(swig::asval(v, &buf[i]))){break;}
|
3819
|
+
}
|
3820
|
+
if(i == 3){
|
3821
|
+
res = &buf;
|
3822
|
+
break;
|
3823
|
+
}
|
3824
|
+
}else if(SWIG_IsOK(SWIG_ConvertPtr(
|
3825
|
+
res_hook, (void **)&res, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0))){
|
3826
|
+
res = &(buf = *res);
|
3827
|
+
break;
|
3828
|
+
}
|
3829
|
+
throw std::runtime_error(
|
3830
|
+
std::string("System_XYZ or [d * 3] is expected (d: " "double" "), however ")
|
3831
|
+
.append(inspect_str(res_hook)));
|
3832
|
+
}while(false);
|
3833
|
+
|
3834
|
+
return res;
|
3835
|
+
}
|
3836
|
+
|
3837
|
+
|
3838
|
+
template <>
|
3839
|
+
bool GPS_RangeCorrector<double>::is_available(
|
3840
|
+
const typename GPS_Solver_Base<double>::gps_time_t &t) const {
|
3841
|
+
VALUE values[] = {
|
3842
|
+
SWIG_NewPointerObj(
|
3843
|
+
const_cast< GPS_Time<double> * >(&t), SWIGTYPE_p_GPS_TimeT_double_t, 0),
|
3844
|
+
};
|
3845
|
+
VALUE res(proc_call_throw_if_error(
|
3846
|
+
callback, sizeof(values) / sizeof(values[0]), values));
|
3847
|
+
return RTEST(res) ? true : false;
|
3848
|
+
}
|
3849
|
+
template <>
|
3850
|
+
double *GPS_RangeCorrector<double>::calculate(
|
3851
|
+
const typename GPS_Solver_Base<double>::gps_time_t &t,
|
3852
|
+
const typename GPS_Solver_Base<double>::pos_t &usr_pos,
|
3853
|
+
const typename GPS_Solver_Base<double>::enu_t &sat_rel_pos,
|
3854
|
+
double &buf) const {
|
3855
|
+
VALUE values[] = {
|
3856
|
+
SWIG_NewPointerObj(
|
3857
|
+
const_cast< GPS_Time<double> * >(&t),
|
3858
|
+
SWIGTYPE_p_GPS_TimeT_double_t, 0),
|
3859
|
+
SWIG_NewPointerObj(
|
3860
|
+
(const_cast< System_XYZ<double,WGS84> * >(&usr_pos.xyz)),
|
3861
|
+
SWIGTYPE_p_System_XYZT_double_WGS84_t, 0),
|
3862
|
+
SWIG_NewPointerObj(
|
3863
|
+
(const_cast< System_ENU<double,WGS84> * >(&sat_rel_pos)),
|
3864
|
+
SWIGTYPE_p_System_ENUT_double_WGS84_t, 0),
|
3865
|
+
};
|
3866
|
+
VALUE res(proc_call_throw_if_error(
|
3867
|
+
callback, sizeof(values) / sizeof(values[0]), values));
|
3868
|
+
return SWIG_IsOK(swig::asval(res, &buf)) ? &buf : NULL;
|
3869
|
+
}
|
3870
|
+
template<>
|
3871
|
+
VALUE GPS_Solver<double>::update_correction(
|
3872
|
+
const bool &update, const VALUE &hash){
|
3873
|
+
typedef range_correction_list_t list_t;
|
3874
|
+
static const VALUE k_root[] = {
|
3875
|
+
ID2SYM(rb_intern("gps_ionospheric")),
|
3876
|
+
ID2SYM(rb_intern("gps_tropospheric")),
|
3877
|
+
ID2SYM(rb_intern("sbas_ionospheric")),
|
3878
|
+
ID2SYM(rb_intern("sbas_tropospheric")),
|
3879
|
+
};
|
3880
|
+
static const VALUE k_opt(ID2SYM(rb_intern("options")));
|
3881
|
+
static const VALUE k_f_10_7(ID2SYM(rb_intern("f_10_7")));
|
3882
|
+
static const VALUE k_known(ID2SYM(rb_intern("known")));
|
3883
|
+
struct {
|
3884
|
+
VALUE sym;
|
3885
|
+
list_t::mapped_type::value_type obj;
|
3886
|
+
} item[] = {
|
3887
|
+
{ID2SYM(rb_intern("no_correction")), &base_t::no_correction},
|
3888
|
+
{ID2SYM(rb_intern("klobuchar")), &this->gps.solver.ionospheric_klobuchar},
|
3889
|
+
{ID2SYM(rb_intern("ntcm_gl")), &this->gps.solver.ionospheric_ntcm_gl},
|
3890
|
+
{ID2SYM(rb_intern("hopfield")), &this->gps.solver.tropospheric_simplified},
|
3891
|
+
{ID2SYM(rb_intern("sbas_igp")), &this->sbas.solver.ionospheric_sbas},
|
3892
|
+
{ID2SYM(rb_intern("sbas_tropo")), &this->sbas.solver.tropospheric_sbas},
|
3893
|
+
};
|
3894
|
+
list_t input;
|
3895
|
+
if(update){
|
3896
|
+
if(!RB_TYPE_P(hash, T_HASH)){
|
3897
|
+
throw std::runtime_error(
|
3898
|
+
std::string("Hash is expected, however ").append(inspect_str(hash)));
|
3899
|
+
}
|
3900
|
+
for(std::size_t i(0); i < sizeof(k_root) / sizeof(k_root[0]); ++i){
|
3901
|
+
VALUE ary = rb_hash_lookup(hash, k_root[i]);
|
3902
|
+
if(NIL_P(ary)){continue;}
|
3903
|
+
if(!RB_TYPE_P(ary, T_ARRAY)){
|
3904
|
+
ary = rb_ary_new_from_values(1, &ary);
|
3905
|
+
}
|
3906
|
+
for(int j(0); j < RARRAY_LEN(ary); ++j){
|
3907
|
+
std::size_t k(0);
|
3908
|
+
VALUE v(rb_ary_entry(ary, j));
|
3909
|
+
for(; k < sizeof(item) / sizeof(item[0]); ++k){
|
3910
|
+
if(v == item[k].sym){break;}
|
3911
|
+
}
|
3912
|
+
if(k >= sizeof(item) / sizeof(item[0])){ // other than symbol
|
3913
|
+
user_correctors.push_back(GPS_RangeCorrector<double>(v));
|
3914
|
+
input[i].push_back(&user_correctors.back());
|
3915
|
+
}else{
|
3916
|
+
input[i].push_back(item[k].obj);
|
3917
|
+
}
|
3918
|
+
}
|
3919
|
+
}
|
3920
|
+
VALUE opt(rb_hash_lookup(hash, k_opt));
|
3921
|
+
if(RB_TYPE_P(opt, T_HASH)){
|
3922
|
+
swig::asval(rb_hash_lookup(opt, k_f_10_7), // ntcm_gl
|
3923
|
+
&this->gps.solver.ionospheric_ntcm_gl.f_10_7);
|
3924
|
+
}
|
3925
|
+
}
|
3926
|
+
list_t output(update_correction(update, input));
|
3927
|
+
VALUE res = rb_hash_new();
|
3928
|
+
for(list_t::const_iterator it(output.begin()), it_end(output.end());
|
3929
|
+
it != it_end; ++it){
|
3930
|
+
VALUE k;
|
3931
|
+
if((it->first < 0) || (it->first >= (int)(sizeof(k_root) / sizeof(k_root[0])))){
|
3932
|
+
k = SWIG_From_int (it->first);
|
3933
|
+
}else{
|
3934
|
+
k = k_root[it->first];
|
3935
|
+
}
|
3936
|
+
VALUE v = rb_ary_new();
|
3937
|
+
for(list_t::mapped_type::const_iterator
|
3938
|
+
it2(it->second.begin()), it2_end(it->second.end());
|
3939
|
+
it2 != it2_end; ++it2){
|
3940
|
+
std::size_t i(0);
|
3941
|
+
for(; i < sizeof(item) / sizeof(item[0]); ++i){
|
3942
|
+
if(*it2 == item[i].obj){break;}
|
3943
|
+
}
|
3944
|
+
if(i >= sizeof(item) / sizeof(item[0])){ // other than built-in corrector
|
3945
|
+
rb_ary_push(v,
|
3946
|
+
reinterpret_cast<const GPS_RangeCorrector<double> *>(*it2)->callback);
|
3947
|
+
}else{
|
3948
|
+
rb_ary_push(v, item[i].sym);
|
3949
|
+
}
|
3950
|
+
}
|
3951
|
+
rb_hash_aset(res, k, v);
|
3952
|
+
}
|
3953
|
+
{ // common options
|
3954
|
+
VALUE opt = rb_hash_new();
|
3955
|
+
rb_hash_aset(res, k_opt, opt);
|
3956
|
+
rb_hash_aset(opt, k_f_10_7, // ntcm_gl
|
3957
|
+
swig::from(this->gps.solver.ionospheric_ntcm_gl.f_10_7));
|
3958
|
+
}
|
3959
|
+
{ // known models
|
3960
|
+
VALUE ary = rb_ary_new_capa((int)(sizeof(item) / sizeof(item[0])));
|
3961
|
+
for(std::size_t i(0); i < sizeof(item) / sizeof(item[0]); ++i){
|
3962
|
+
rb_ary_push(ary, item[i].sym);
|
3963
|
+
}
|
3964
|
+
rb_hash_aset(res, k_known, ary);
|
3965
|
+
}
|
3966
|
+
return res;
|
3967
|
+
}
|
3733
3968
|
|
3969
|
+
SWIGINTERN VALUE GPS_Solver_Sl_double_Sg__get_correction(GPS_Solver< double > const *self){
|
3970
|
+
return const_cast<GPS_Solver<double> *>(self)->update_correction(false, Qnil);
|
3971
|
+
}
|
3972
|
+
SWIGINTERN VALUE GPS_Solver_Sl_double_Sg__set_correction(GPS_Solver< double > *self,VALUE hash){
|
3973
|
+
return self->update_correction(true, hash);
|
3974
|
+
}
|
3734
3975
|
SWIGINTERN unsigned int SBAS_Ephemeris_Sl_double_Sg__set_svid(SBAS_Ephemeris< double > *self,unsigned int const &v){
|
3735
3976
|
return self->svid = v;
|
3736
3977
|
}
|
@@ -3836,7 +4077,8 @@ SWIGINTERN SBAS_Ephemeris< double > SBAS_SpaceNode_Sl_double_Sg__ephemeris(SBAS_
|
|
3836
4077
|
}
|
3837
4078
|
SWIGINTERN int SBAS_SpaceNode_Sl_double_Sg__read(SBAS_SpaceNode< double > *self,char const *fname){
|
3838
4079
|
std::fstream fin(fname, std::ios::in | std::ios::binary);
|
3839
|
-
RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {NULL
|
4080
|
+
RINEX_NAV_Reader<double>::space_node_list_t space_nodes = {NULL};
|
4081
|
+
space_nodes.sbas = self;
|
3840
4082
|
return RINEX_NAV_Reader<double>::read_all(fin, space_nodes);
|
3841
4083
|
}
|
3842
4084
|
SWIGINTERN int SBAS_SpaceNode_Sl_double_Sg__decode_message__SWIG_2(SBAS_SpaceNode< double > *self,unsigned int const buf[8],int const &prn,GPS_Time< double > const &t_reception,bool const &LNAV_VNAV_LP_LPV_approach=false){
|
@@ -6052,6 +6294,58 @@ fail:
|
|
6052
6294
|
}
|
6053
6295
|
|
6054
6296
|
|
6297
|
+
/*
|
6298
|
+
Document-method: GPS_PVT::GPS::Time.<=>
|
6299
|
+
|
6300
|
+
call-seq:
|
6301
|
+
<=>(t) -> int
|
6302
|
+
|
6303
|
+
Comparison operator. Returns < 0 for less than, 0 for equal or > 1 for higher than..
|
6304
|
+
*/
|
6305
|
+
SWIGINTERN VALUE
|
6306
|
+
_wrap_Time___cmp__(int argc, VALUE *argv, VALUE self) {
|
6307
|
+
GPS_Time< double > *arg1 = (GPS_Time< double > *) 0 ;
|
6308
|
+
GPS_Time< double > *arg2 = 0 ;
|
6309
|
+
void *argp1 = 0 ;
|
6310
|
+
int res1 = 0 ;
|
6311
|
+
void *argp2 ;
|
6312
|
+
int res2 = 0 ;
|
6313
|
+
int result;
|
6314
|
+
VALUE vresult = Qnil;
|
6315
|
+
|
6316
|
+
if ((argc < 1) || (argc > 1)) {
|
6317
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
6318
|
+
}
|
6319
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_TimeT_double_t, 0 | 0 );
|
6320
|
+
if (!SWIG_IsOK(res1)) {
|
6321
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Time< double > const *","__cmp__", 1, self ));
|
6322
|
+
}
|
6323
|
+
arg1 = reinterpret_cast< GPS_Time< double > * >(argp1);
|
6324
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t, 0 );
|
6325
|
+
if (!SWIG_IsOK(res2)) {
|
6326
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","__cmp__", 2, argv[0] ));
|
6327
|
+
}
|
6328
|
+
if (!argp2) {
|
6329
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","__cmp__", 2, argv[0]));
|
6330
|
+
}
|
6331
|
+
arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
|
6332
|
+
{
|
6333
|
+
try {
|
6334
|
+
result = (int)GPS_Time_Sl_double_Sg____cmp__((GPS_Time< double > const *)arg1,(GPS_Time< double > const &)*arg2);
|
6335
|
+
} catch (const native_exception &e) {
|
6336
|
+
e.regenerate();
|
6337
|
+
SWIG_fail;
|
6338
|
+
} catch (const std::exception& e) {
|
6339
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
6340
|
+
}
|
6341
|
+
}
|
6342
|
+
vresult = SWIG_From_int(static_cast< int >(result));
|
6343
|
+
return vresult;
|
6344
|
+
fail:
|
6345
|
+
return Qnil;
|
6346
|
+
}
|
6347
|
+
|
6348
|
+
|
6055
6349
|
SWIGINTERN void
|
6056
6350
|
free_GPS_Time_Sl_double_Sg_(void *self) {
|
6057
6351
|
GPS_Time< double > *arg1 = (GPS_Time< double > *)self;
|
@@ -6270,6 +6564,50 @@ _wrap_SpaceNode_gamma_L1_L2_get(VALUE self) {
|
|
6270
6564
|
}
|
6271
6565
|
|
6272
6566
|
|
6567
|
+
/*
|
6568
|
+
Document-method: GPS_PVT::GPS::SpaceNode.gamma_per_L1
|
6569
|
+
|
6570
|
+
call-seq:
|
6571
|
+
gamma_per_L1(GPS_SpaceNode< double >::float_t const & freq) -> GPS_SpaceNode< double >::float_t const
|
6572
|
+
|
6573
|
+
A class method.
|
6574
|
+
|
6575
|
+
*/
|
6576
|
+
SWIGINTERN VALUE
|
6577
|
+
_wrap_SpaceNode_gamma_per_L1(int argc, VALUE *argv, VALUE self) {
|
6578
|
+
GPS_SpaceNode< double >::float_t *arg1 = 0 ;
|
6579
|
+
GPS_SpaceNode< double >::float_t temp1 ;
|
6580
|
+
double val1 ;
|
6581
|
+
int ecode1 = 0 ;
|
6582
|
+
GPS_SpaceNode< double >::float_t result;
|
6583
|
+
VALUE vresult = Qnil;
|
6584
|
+
|
6585
|
+
if ((argc < 1) || (argc > 1)) {
|
6586
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
6587
|
+
}
|
6588
|
+
ecode1 = SWIG_AsVal_double(argv[0], &val1);
|
6589
|
+
if (!SWIG_IsOK(ecode1)) {
|
6590
|
+
SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::float_t","GPS_SpaceNode<(double)>::gamma_per_L1", 1, argv[0] ));
|
6591
|
+
}
|
6592
|
+
temp1 = static_cast< GPS_SpaceNode< double >::float_t >(val1);
|
6593
|
+
arg1 = &temp1;
|
6594
|
+
{
|
6595
|
+
try {
|
6596
|
+
result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR gamma_per_L1((double const &)*arg1);
|
6597
|
+
} catch (const native_exception &e) {
|
6598
|
+
e.regenerate();
|
6599
|
+
SWIG_fail;
|
6600
|
+
} catch (const std::exception& e) {
|
6601
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
6602
|
+
}
|
6603
|
+
}
|
6604
|
+
vresult = SWIG_From_double(static_cast< double >(result));
|
6605
|
+
return vresult;
|
6606
|
+
fail:
|
6607
|
+
return Qnil;
|
6608
|
+
}
|
6609
|
+
|
6610
|
+
|
6273
6611
|
SWIGINTERN VALUE
|
6274
6612
|
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
|
6275
6613
|
_wrap_SpaceNode_allocate(VALUE self)
|
@@ -7695,50 +8033,42 @@ fail:
|
|
7695
8033
|
tropo_correction(ENU relative_pos, LLH usrllh) -> GPS_SpaceNode< double >::float_t
|
7696
8034
|
tropo_correction(XYZ sat, XYZ usr) -> GPS_SpaceNode< double >::float_t
|
7697
8035
|
|
7698
|
-
|
8036
|
+
A class method.
|
7699
8037
|
|
7700
8038
|
*/
|
7701
8039
|
SWIGINTERN VALUE
|
7702
8040
|
_wrap_SpaceNode_tropo_correction__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
7703
|
-
GPS_SpaceNode< double
|
7704
|
-
GPS_SpaceNode< double >::
|
7705
|
-
|
7706
|
-
void *argp1 = 0 ;
|
8041
|
+
GPS_SpaceNode< double >::enu_t *arg1 = 0 ;
|
8042
|
+
GPS_SpaceNode< double >::llh_t *arg2 = 0 ;
|
8043
|
+
void *argp1 ;
|
7707
8044
|
int res1 = 0 ;
|
7708
8045
|
void *argp2 ;
|
7709
8046
|
int res2 = 0 ;
|
7710
|
-
void *argp3 ;
|
7711
|
-
int res3 = 0 ;
|
7712
8047
|
GPS_SpaceNode< double >::float_t result;
|
7713
8048
|
VALUE vresult = Qnil;
|
7714
8049
|
|
7715
8050
|
if ((argc < 2) || (argc > 2)) {
|
7716
8051
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
7717
8052
|
}
|
7718
|
-
res1 = SWIG_ConvertPtr(
|
8053
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 );
|
7719
8054
|
if (!SWIG_IsOK(res1)) {
|
7720
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double
|
8055
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::enu_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
|
7721
8056
|
}
|
7722
|
-
|
7723
|
-
|
8057
|
+
if (!argp1) {
|
8058
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::enu_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0]));
|
8059
|
+
}
|
8060
|
+
arg1 = reinterpret_cast< GPS_SpaceNode< double >::enu_t * >(argp1);
|
8061
|
+
res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
|
7724
8062
|
if (!SWIG_IsOK(res2)) {
|
7725
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::
|
8063
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::llh_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1] ));
|
7726
8064
|
}
|
7727
8065
|
if (!argp2) {
|
7728
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::
|
7729
|
-
}
|
7730
|
-
arg2 = reinterpret_cast< GPS_SpaceNode< double >::enu_t * >(argp2);
|
7731
|
-
res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
|
7732
|
-
if (!SWIG_IsOK(res3)) {
|
7733
|
-
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::llh_t const &","tropo_correction", 3, argv[1] ));
|
7734
|
-
}
|
7735
|
-
if (!argp3) {
|
7736
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::llh_t const &","tropo_correction", 3, argv[1]));
|
8066
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::llh_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1]));
|
7737
8067
|
}
|
7738
|
-
|
8068
|
+
arg2 = reinterpret_cast< GPS_SpaceNode< double >::llh_t * >(argp2);
|
7739
8069
|
{
|
7740
8070
|
try {
|
7741
|
-
result = (GPS_SpaceNode< double >::float_t)
|
8071
|
+
result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((System_ENU< double,WGS84 > const &)*arg1,(System_LLH< double,WGS84 > const &)*arg2);
|
7742
8072
|
} catch (const native_exception &e) {
|
7743
8073
|
e.regenerate();
|
7744
8074
|
SWIG_fail;
|
@@ -7825,50 +8155,42 @@ fail:
|
|
7825
8155
|
tropo_correction(ENU relative_pos, LLH usrllh) -> GPS_SpaceNode< double >::float_t
|
7826
8156
|
tropo_correction(XYZ sat, XYZ usr) -> GPS_SpaceNode< double >::float_t
|
7827
8157
|
|
7828
|
-
|
8158
|
+
A class method.
|
7829
8159
|
|
7830
8160
|
*/
|
7831
8161
|
SWIGINTERN VALUE
|
7832
8162
|
_wrap_SpaceNode_tropo_correction__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
7833
|
-
GPS_SpaceNode< double
|
8163
|
+
GPS_SpaceNode< double >::xyz_t *arg1 = 0 ;
|
7834
8164
|
GPS_SpaceNode< double >::xyz_t *arg2 = 0 ;
|
7835
|
-
|
7836
|
-
void *argp1 = 0 ;
|
8165
|
+
void *argp1 ;
|
7837
8166
|
int res1 = 0 ;
|
7838
8167
|
void *argp2 ;
|
7839
8168
|
int res2 = 0 ;
|
7840
|
-
void *argp3 ;
|
7841
|
-
int res3 = 0 ;
|
7842
8169
|
GPS_SpaceNode< double >::float_t result;
|
7843
8170
|
VALUE vresult = Qnil;
|
7844
8171
|
|
7845
8172
|
if ((argc < 2) || (argc > 2)) {
|
7846
8173
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
7847
8174
|
}
|
7848
|
-
res1 = SWIG_ConvertPtr(
|
8175
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
|
7849
8176
|
if (!SWIG_IsOK(res1)) {
|
7850
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double
|
8177
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
|
7851
8178
|
}
|
7852
|
-
|
7853
|
-
|
8179
|
+
if (!argp1) {
|
8180
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 1, argv[0]));
|
8181
|
+
}
|
8182
|
+
arg1 = reinterpret_cast< GPS_SpaceNode< double >::xyz_t * >(argp1);
|
8183
|
+
res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
|
7854
8184
|
if (!SWIG_IsOK(res2)) {
|
7855
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 2, argv[
|
8185
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1] ));
|
7856
8186
|
}
|
7857
8187
|
if (!argp2) {
|
7858
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 2, argv[
|
8188
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","GPS_SpaceNode<(double)>::tropo_correction", 2, argv[1]));
|
7859
8189
|
}
|
7860
8190
|
arg2 = reinterpret_cast< GPS_SpaceNode< double >::xyz_t * >(argp2);
|
7861
|
-
res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_System_XYZT_double_WGS84_t, 0 );
|
7862
|
-
if (!SWIG_IsOK(res3)) {
|
7863
|
-
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 3, argv[1] ));
|
7864
|
-
}
|
7865
|
-
if (!argp3) {
|
7866
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_SpaceNode< double >::xyz_t const &","tropo_correction", 3, argv[1]));
|
7867
|
-
}
|
7868
|
-
arg3 = reinterpret_cast< GPS_SpaceNode< double >::xyz_t * >(argp3);
|
7869
8191
|
{
|
7870
8192
|
try {
|
7871
|
-
result = (GPS_SpaceNode< double >::float_t)
|
8193
|
+
result = (GPS_SpaceNode< double >::float_t)GPS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((System_XYZ< double,WGS84 > const &)*arg1,(System_XYZ< double,WGS84 > const &)*arg2);
|
7872
8194
|
} catch (const native_exception &e) {
|
7873
8195
|
e.regenerate();
|
7874
8196
|
SWIG_fail;
|
@@ -7885,56 +8207,45 @@ fail:
|
|
7885
8207
|
|
7886
8208
|
SWIGINTERN VALUE _wrap_SpaceNode_tropo_correction(int nargs, VALUE *args, VALUE self) {
|
7887
8209
|
int argc;
|
7888
|
-
VALUE argv[
|
8210
|
+
VALUE argv[2];
|
7889
8211
|
int ii;
|
7890
8212
|
|
7891
|
-
argc = nargs
|
7892
|
-
|
7893
|
-
|
7894
|
-
|
7895
|
-
argv[ii] = args[ii-1];
|
8213
|
+
argc = nargs;
|
8214
|
+
if (argc > 2) SWIG_fail;
|
8215
|
+
for (ii = 0; (ii < argc); ++ii) {
|
8216
|
+
argv[ii] = args[ii];
|
7896
8217
|
}
|
7897
|
-
if (argc ==
|
8218
|
+
if (argc == 2) {
|
7898
8219
|
int _v;
|
7899
8220
|
void *vptr = 0;
|
7900
|
-
int res = SWIG_ConvertPtr(argv[0], &vptr,
|
8221
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_ENUT_double_WGS84_t, SWIG_POINTER_NO_NULL);
|
7901
8222
|
_v = SWIG_CheckState(res);
|
7902
8223
|
if (_v) {
|
7903
8224
|
void *vptr = 0;
|
7904
|
-
int res = SWIG_ConvertPtr(argv[1], &vptr,
|
8225
|
+
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
|
7905
8226
|
_v = SWIG_CheckState(res);
|
7906
8227
|
if (_v) {
|
7907
|
-
|
7908
|
-
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
|
7909
|
-
_v = SWIG_CheckState(res);
|
7910
|
-
if (_v) {
|
7911
|
-
return _wrap_SpaceNode_tropo_correction__SWIG_0(nargs, args, self);
|
7912
|
-
}
|
8228
|
+
return _wrap_SpaceNode_tropo_correction__SWIG_0(nargs, args, self);
|
7913
8229
|
}
|
7914
8230
|
}
|
7915
8231
|
}
|
7916
|
-
if (argc ==
|
8232
|
+
if (argc == 2) {
|
7917
8233
|
int _v;
|
7918
8234
|
void *vptr = 0;
|
7919
|
-
int res = SWIG_ConvertPtr(argv[0], &vptr,
|
8235
|
+
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
|
7920
8236
|
_v = SWIG_CheckState(res);
|
7921
8237
|
if (_v) {
|
7922
8238
|
void *vptr = 0;
|
7923
8239
|
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
|
7924
8240
|
_v = SWIG_CheckState(res);
|
7925
8241
|
if (_v) {
|
7926
|
-
|
7927
|
-
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_NO_NULL);
|
7928
|
-
_v = SWIG_CheckState(res);
|
7929
|
-
if (_v) {
|
7930
|
-
return _wrap_SpaceNode_tropo_correction__SWIG_1(nargs, args, self);
|
7931
|
-
}
|
8242
|
+
return _wrap_SpaceNode_tropo_correction__SWIG_1(nargs, args, self);
|
7932
8243
|
}
|
7933
8244
|
}
|
7934
8245
|
}
|
7935
8246
|
|
7936
8247
|
fail:
|
7937
|
-
Ruby_Format_OverloadedError( argc,
|
8248
|
+
Ruby_Format_OverloadedError( argc, 2, "SpaceNode.tropo_correction",
|
7938
8249
|
" GPS_SpaceNode< double >::float_t SpaceNode.tropo_correction(GPS_SpaceNode< double >::enu_t const &relative_pos, GPS_SpaceNode< double >::llh_t const &usrllh)\n"
|
7939
8250
|
" GPS_SpaceNode< double >::float_t SpaceNode.tropo_correction(GPS_SpaceNode< double >::xyz_t const &sat, GPS_SpaceNode< double >::xyz_t const &usr)\n");
|
7940
8251
|
|
@@ -14171,6 +14482,15 @@ A class method.
|
|
14171
14482
|
|
14172
14483
|
A class method.
|
14173
14484
|
|
14485
|
+
*/
|
14486
|
+
/*
|
14487
|
+
Document-method: GPS_PVT::GPS.L1_FREQUENCY
|
14488
|
+
|
14489
|
+
call-seq:
|
14490
|
+
L1_FREQUENCY -> int
|
14491
|
+
|
14492
|
+
A class method.
|
14493
|
+
|
14174
14494
|
*/
|
14175
14495
|
/*
|
14176
14496
|
Document-method: GPS_PVT::GPS.ITEMS_PREDEFINED
|
@@ -14464,65 +14784,11 @@ free_GPS_Measurement_Sl_double_Sg_(void *self) {
|
|
14464
14784
|
static swig_class SwigClassSolverOptionsCommon;
|
14465
14785
|
|
14466
14786
|
/*
|
14467
|
-
Document-method: GPS_PVT::GPS.
|
14787
|
+
Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
|
14468
14788
|
|
14469
14789
|
call-seq:
|
14470
|
-
|
14471
|
-
|
14472
|
-
A class method.
|
14473
|
-
|
14474
|
-
*/
|
14475
|
-
/*
|
14476
|
-
Document-method: GPS_PVT::GPS.IONOSPHERIC_SBAS
|
14477
|
-
|
14478
|
-
call-seq:
|
14479
|
-
IONOSPHERIC_SBAS -> int
|
14480
|
-
|
14481
|
-
A class method.
|
14482
|
-
|
14483
|
-
*/
|
14484
|
-
/*
|
14485
|
-
Document-method: GPS_PVT::GPS.IONOSPHERIC_NTCM_GL
|
14486
|
-
|
14487
|
-
call-seq:
|
14488
|
-
IONOSPHERIC_NTCM_GL -> int
|
14489
|
-
|
14490
|
-
A class method.
|
14491
|
-
|
14492
|
-
*/
|
14493
|
-
/*
|
14494
|
-
Document-method: GPS_PVT::GPS.IONOSPHERIC_NONE
|
14495
|
-
|
14496
|
-
call-seq:
|
14497
|
-
IONOSPHERIC_NONE -> int
|
14498
|
-
|
14499
|
-
A class method.
|
14500
|
-
|
14501
|
-
*/
|
14502
|
-
/*
|
14503
|
-
Document-method: GPS_PVT::GPS.IONOSPHERIC_MODELS
|
14504
|
-
|
14505
|
-
call-seq:
|
14506
|
-
IONOSPHERIC_MODELS -> int
|
14507
|
-
|
14508
|
-
A class method.
|
14509
|
-
|
14510
|
-
*/
|
14511
|
-
/*
|
14512
|
-
Document-method: GPS_PVT::GPS.IONOSPHERIC_SKIP
|
14513
|
-
|
14514
|
-
call-seq:
|
14515
|
-
IONOSPHERIC_SKIP -> int
|
14516
|
-
|
14517
|
-
A class method.
|
14518
|
-
|
14519
|
-
*/
|
14520
|
-
/*
|
14521
|
-
Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
|
14522
|
-
|
14523
|
-
call-seq:
|
14524
|
-
cast_general -> GPS_Solver_GeneralOptions< double > *
|
14525
|
-
cast_general -> GPS_Solver_GeneralOptions< double > const
|
14790
|
+
cast_general -> GPS_Solver_GeneralOptions< double > *
|
14791
|
+
cast_general -> GPS_Solver_GeneralOptions< double > const
|
14526
14792
|
|
14527
14793
|
An instance method.
|
14528
14794
|
|
@@ -14632,122 +14898,6 @@ fail:
|
|
14632
14898
|
}
|
14633
14899
|
|
14634
14900
|
|
14635
|
-
/*
|
14636
|
-
Document-method: GPS_PVT::GPS::SolverOptionsCommon.ionospheric_models
|
14637
|
-
|
14638
|
-
call-seq:
|
14639
|
-
ionospheric_models -> std::vector< int >
|
14640
|
-
|
14641
|
-
An instance method.
|
14642
|
-
|
14643
|
-
*/
|
14644
|
-
SWIGINTERN VALUE
|
14645
|
-
_wrap_SolverOptionsCommon_ionospheric_models(int argc, VALUE *argv, VALUE self) {
|
14646
|
-
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
|
14647
|
-
void *argp1 = 0 ;
|
14648
|
-
int res1 = 0 ;
|
14649
|
-
std::vector< int > result;
|
14650
|
-
VALUE vresult = Qnil;
|
14651
|
-
|
14652
|
-
if ((argc < 0) || (argc > 0)) {
|
14653
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
14654
|
-
}
|
14655
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
|
14656
|
-
if (!SWIG_IsOK(res1)) {
|
14657
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","get_ionospheric_models", 1, self ));
|
14658
|
-
}
|
14659
|
-
arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
|
14660
|
-
{
|
14661
|
-
try {
|
14662
|
-
result = ((GPS_SolverOptions_Common< double > const *)arg1)->get_ionospheric_models();
|
14663
|
-
} catch (const native_exception &e) {
|
14664
|
-
e.regenerate();
|
14665
|
-
SWIG_fail;
|
14666
|
-
} catch (const std::exception& e) {
|
14667
|
-
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14668
|
-
}
|
14669
|
-
}
|
14670
|
-
{
|
14671
|
-
vresult = rb_ary_new();
|
14672
|
-
|
14673
|
-
for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
|
14674
|
-
it != it_end; ++it){
|
14675
|
-
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (*it));
|
14676
|
-
}
|
14677
|
-
}
|
14678
|
-
return vresult;
|
14679
|
-
fail:
|
14680
|
-
return Qnil;
|
14681
|
-
}
|
14682
|
-
|
14683
|
-
|
14684
|
-
/*
|
14685
|
-
Document-method: GPS_PVT::GPS::SolverOptionsCommon.ionospheric_models=
|
14686
|
-
|
14687
|
-
call-seq:
|
14688
|
-
ionospheric_models=(std::vector< int > const & models) -> std::vector< int >
|
14689
|
-
|
14690
|
-
An instance method.
|
14691
|
-
|
14692
|
-
*/
|
14693
|
-
SWIGINTERN VALUE
|
14694
|
-
_wrap_SolverOptionsCommon_ionospheric_modelse___(int argc, VALUE *argv, VALUE self) {
|
14695
|
-
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
|
14696
|
-
std::vector< int > *arg2 = 0 ;
|
14697
|
-
void *argp1 = 0 ;
|
14698
|
-
int res1 = 0 ;
|
14699
|
-
std::vector< int > temp2 ;
|
14700
|
-
std::vector< int > result;
|
14701
|
-
VALUE vresult = Qnil;
|
14702
|
-
|
14703
|
-
if ((argc < 1) || (argc > 1)) {
|
14704
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
14705
|
-
}
|
14706
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
|
14707
|
-
if (!SWIG_IsOK(res1)) {
|
14708
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","set_ionospheric_models", 1, self ));
|
14709
|
-
}
|
14710
|
-
arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
|
14711
|
-
{
|
14712
|
-
arg2 = &temp2;
|
14713
|
-
|
14714
|
-
if(RB_TYPE_P(argv[0], T_ARRAY)){
|
14715
|
-
for(int i(0), i_max(RARRAY_LEN(argv[0])); i < i_max; ++i){
|
14716
|
-
VALUE obj(RARRAY_AREF(argv[0], i));
|
14717
|
-
int v;
|
14718
|
-
if(SWIG_IsOK(SWIG_AsVal_int (obj, &v))){
|
14719
|
-
temp2.push_back(v);
|
14720
|
-
}else{
|
14721
|
-
SWIG_exception(SWIG_TypeError, "std::vector< int > is expected");
|
14722
|
-
}
|
14723
|
-
}
|
14724
|
-
}
|
14725
|
-
|
14726
|
-
}
|
14727
|
-
{
|
14728
|
-
try {
|
14729
|
-
result = (arg1)->set_ionospheric_models((std::vector< int > const &)*arg2);
|
14730
|
-
} catch (const native_exception &e) {
|
14731
|
-
e.regenerate();
|
14732
|
-
SWIG_fail;
|
14733
|
-
} catch (const std::exception& e) {
|
14734
|
-
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14735
|
-
}
|
14736
|
-
}
|
14737
|
-
{
|
14738
|
-
vresult = rb_ary_new();
|
14739
|
-
|
14740
|
-
for(std::vector< int >::const_iterator it((&result)->begin()), it_end((&result)->end());
|
14741
|
-
it != it_end; ++it){
|
14742
|
-
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int (*it));
|
14743
|
-
}
|
14744
|
-
}
|
14745
|
-
return vresult;
|
14746
|
-
fail:
|
14747
|
-
return Qnil;
|
14748
|
-
}
|
14749
|
-
|
14750
|
-
|
14751
14901
|
/*
|
14752
14902
|
Document-method: GPS_PVT::GPS::SolverOptionsCommon.elevation_mask=
|
14753
14903
|
|
@@ -14936,100 +15086,6 @@ fail:
|
|
14936
15086
|
}
|
14937
15087
|
|
14938
15088
|
|
14939
|
-
/*
|
14940
|
-
Document-method: GPS_PVT::GPS::SolverOptionsCommon.f_10_7=
|
14941
|
-
|
14942
|
-
call-seq:
|
14943
|
-
f_10_7=(double const & v) -> double
|
14944
|
-
|
14945
|
-
An instance method.
|
14946
|
-
|
14947
|
-
*/
|
14948
|
-
SWIGINTERN VALUE
|
14949
|
-
_wrap_SolverOptionsCommon_f_10_7e___(int argc, VALUE *argv, VALUE self) {
|
14950
|
-
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
|
14951
|
-
double *arg2 = 0 ;
|
14952
|
-
void *argp1 = 0 ;
|
14953
|
-
int res1 = 0 ;
|
14954
|
-
double temp2 ;
|
14955
|
-
double val2 ;
|
14956
|
-
int ecode2 = 0 ;
|
14957
|
-
double result;
|
14958
|
-
VALUE vresult = Qnil;
|
14959
|
-
|
14960
|
-
if ((argc < 1) || (argc > 1)) {
|
14961
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
14962
|
-
}
|
14963
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
|
14964
|
-
if (!SWIG_IsOK(res1)) {
|
14965
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","set_f_10_7", 1, self ));
|
14966
|
-
}
|
14967
|
-
arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
|
14968
|
-
ecode2 = SWIG_AsVal_double(argv[0], &val2);
|
14969
|
-
if (!SWIG_IsOK(ecode2)) {
|
14970
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_f_10_7", 2, argv[0] ));
|
14971
|
-
}
|
14972
|
-
temp2 = static_cast< double >(val2);
|
14973
|
-
arg2 = &temp2;
|
14974
|
-
{
|
14975
|
-
try {
|
14976
|
-
result = (double)GPS_SolverOptions_Common_Sl_double_Sg__set_f_10_7(arg1,(double const &)*arg2);
|
14977
|
-
} catch (const native_exception &e) {
|
14978
|
-
e.regenerate();
|
14979
|
-
SWIG_fail;
|
14980
|
-
} catch (const std::exception& e) {
|
14981
|
-
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
14982
|
-
}
|
14983
|
-
}
|
14984
|
-
vresult = SWIG_From_double(static_cast< double >(result));
|
14985
|
-
return vresult;
|
14986
|
-
fail:
|
14987
|
-
return Qnil;
|
14988
|
-
}
|
14989
|
-
|
14990
|
-
|
14991
|
-
/*
|
14992
|
-
Document-method: GPS_PVT::GPS::SolverOptionsCommon.f_10_7
|
14993
|
-
|
14994
|
-
call-seq:
|
14995
|
-
f_10_7 -> double const &
|
14996
|
-
|
14997
|
-
An instance method.
|
14998
|
-
|
14999
|
-
*/
|
15000
|
-
SWIGINTERN VALUE
|
15001
|
-
_wrap_SolverOptionsCommon_f_10_7(int argc, VALUE *argv, VALUE self) {
|
15002
|
-
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
|
15003
|
-
void *argp1 = 0 ;
|
15004
|
-
int res1 = 0 ;
|
15005
|
-
double *result = 0 ;
|
15006
|
-
VALUE vresult = Qnil;
|
15007
|
-
|
15008
|
-
if ((argc < 0) || (argc > 0)) {
|
15009
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
15010
|
-
}
|
15011
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 | 0 );
|
15012
|
-
if (!SWIG_IsOK(res1)) {
|
15013
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","get_f_10_7", 1, self ));
|
15014
|
-
}
|
15015
|
-
arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
|
15016
|
-
{
|
15017
|
-
try {
|
15018
|
-
result = (double *) &GPS_SolverOptions_Common_Sl_double_Sg__get_f_10_7((GPS_SolverOptions_Common< double > const *)arg1);
|
15019
|
-
} catch (const native_exception &e) {
|
15020
|
-
e.regenerate();
|
15021
|
-
SWIG_fail;
|
15022
|
-
} catch (const std::exception& e) {
|
15023
|
-
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
15024
|
-
}
|
15025
|
-
}
|
15026
|
-
vresult = SWIG_From_double(static_cast< double >(*result));
|
15027
|
-
return vresult;
|
15028
|
-
fail:
|
15029
|
-
return Qnil;
|
15030
|
-
}
|
15031
|
-
|
15032
|
-
|
15033
15089
|
SWIGINTERN void
|
15034
15090
|
free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
|
15035
15091
|
GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *)self;
|
@@ -15565,6 +15621,92 @@ fail:
|
|
15565
15621
|
}
|
15566
15622
|
|
15567
15623
|
|
15624
|
+
/*
|
15625
|
+
Document-method: GPS_PVT::GPS::Solver.correction
|
15626
|
+
|
15627
|
+
call-seq:
|
15628
|
+
correction -> VALUE
|
15629
|
+
|
15630
|
+
An instance method.
|
15631
|
+
|
15632
|
+
*/
|
15633
|
+
SWIGINTERN VALUE
|
15634
|
+
_wrap_Solver_correction(int argc, VALUE *argv, VALUE self) {
|
15635
|
+
GPS_Solver< double > *arg1 = (GPS_Solver< double > *) 0 ;
|
15636
|
+
void *argp1 = 0 ;
|
15637
|
+
int res1 = 0 ;
|
15638
|
+
VALUE result;
|
15639
|
+
VALUE vresult = Qnil;
|
15640
|
+
|
15641
|
+
if ((argc < 0) || (argc > 0)) {
|
15642
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
15643
|
+
}
|
15644
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverT_double_t, 0 | 0 );
|
15645
|
+
if (!SWIG_IsOK(res1)) {
|
15646
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Solver< double > const *","get_correction", 1, self ));
|
15647
|
+
}
|
15648
|
+
arg1 = reinterpret_cast< GPS_Solver< double > * >(argp1);
|
15649
|
+
{
|
15650
|
+
try {
|
15651
|
+
result = (VALUE)GPS_Solver_Sl_double_Sg__get_correction((GPS_Solver< double > const *)arg1);
|
15652
|
+
} catch (const native_exception &e) {
|
15653
|
+
e.regenerate();
|
15654
|
+
SWIG_fail;
|
15655
|
+
} catch (const std::exception& e) {
|
15656
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
15657
|
+
}
|
15658
|
+
}
|
15659
|
+
vresult = result;
|
15660
|
+
return vresult;
|
15661
|
+
fail:
|
15662
|
+
return Qnil;
|
15663
|
+
}
|
15664
|
+
|
15665
|
+
|
15666
|
+
/*
|
15667
|
+
Document-method: GPS_PVT::GPS::Solver.correction=
|
15668
|
+
|
15669
|
+
call-seq:
|
15670
|
+
correction=(VALUE hash) -> VALUE
|
15671
|
+
|
15672
|
+
An instance method.
|
15673
|
+
|
15674
|
+
*/
|
15675
|
+
SWIGINTERN VALUE
|
15676
|
+
_wrap_Solver_correctione___(int argc, VALUE *argv, VALUE self) {
|
15677
|
+
GPS_Solver< double > *arg1 = (GPS_Solver< double > *) 0 ;
|
15678
|
+
VALUE arg2 = (VALUE) 0 ;
|
15679
|
+
void *argp1 = 0 ;
|
15680
|
+
int res1 = 0 ;
|
15681
|
+
VALUE result;
|
15682
|
+
VALUE vresult = Qnil;
|
15683
|
+
|
15684
|
+
if ((argc < 1) || (argc > 1)) {
|
15685
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
15686
|
+
}
|
15687
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverT_double_t, 0 | 0 );
|
15688
|
+
if (!SWIG_IsOK(res1)) {
|
15689
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_Solver< double > *","set_correction", 1, self ));
|
15690
|
+
}
|
15691
|
+
arg1 = reinterpret_cast< GPS_Solver< double > * >(argp1);
|
15692
|
+
arg2 = argv[0];
|
15693
|
+
{
|
15694
|
+
try {
|
15695
|
+
result = (VALUE)GPS_Solver_Sl_double_Sg__set_correction(arg1,arg2);
|
15696
|
+
} catch (const native_exception &e) {
|
15697
|
+
e.regenerate();
|
15698
|
+
SWIG_fail;
|
15699
|
+
} catch (const std::exception& e) {
|
15700
|
+
SWIG_exception_fail(SWIG_RuntimeError, e.what());
|
15701
|
+
}
|
15702
|
+
}
|
15703
|
+
vresult = result;
|
15704
|
+
return vresult;
|
15705
|
+
fail:
|
15706
|
+
return Qnil;
|
15707
|
+
}
|
15708
|
+
|
15709
|
+
|
15568
15710
|
SWIGINTERN void
|
15569
15711
|
free_GPS_Solver_Sl_double_Sg_(void *self) {
|
15570
15712
|
GPS_Solver< double > *arg1 = (GPS_Solver< double > *)self;
|
@@ -17678,60 +17820,52 @@ fail:
|
|
17678
17820
|
call-seq:
|
17679
17821
|
tropo_correction(SBAS_SpaceNode< double >::float_t const & year_utc, ENU relative_pos, LLH usrllh) -> SBAS_SpaceNode< double >::float_t
|
17680
17822
|
|
17681
|
-
|
17823
|
+
A class method.
|
17682
17824
|
|
17683
17825
|
*/
|
17684
17826
|
SWIGINTERN VALUE
|
17685
17827
|
_wrap_SpaceNode_SBAS_tropo_correction(int argc, VALUE *argv, VALUE self) {
|
17686
|
-
SBAS_SpaceNode< double
|
17687
|
-
SBAS_SpaceNode< double >::
|
17688
|
-
SBAS_SpaceNode< double >::
|
17689
|
-
SBAS_SpaceNode< double >::
|
17690
|
-
|
17691
|
-
int
|
17692
|
-
|
17693
|
-
|
17694
|
-
int ecode2 = 0 ;
|
17828
|
+
SBAS_SpaceNode< double >::float_t *arg1 = 0 ;
|
17829
|
+
SBAS_SpaceNode< double >::enu_t *arg2 = 0 ;
|
17830
|
+
SBAS_SpaceNode< double >::llh_t *arg3 = 0 ;
|
17831
|
+
SBAS_SpaceNode< double >::float_t temp1 ;
|
17832
|
+
double val1 ;
|
17833
|
+
int ecode1 = 0 ;
|
17834
|
+
void *argp2 ;
|
17835
|
+
int res2 = 0 ;
|
17695
17836
|
void *argp3 ;
|
17696
17837
|
int res3 = 0 ;
|
17697
|
-
void *argp4 ;
|
17698
|
-
int res4 = 0 ;
|
17699
17838
|
SBAS_SpaceNode< double >::float_t result;
|
17700
17839
|
VALUE vresult = Qnil;
|
17701
17840
|
|
17702
17841
|
if ((argc < 3) || (argc > 3)) {
|
17703
17842
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
17704
17843
|
}
|
17705
|
-
|
17706
|
-
if (!SWIG_IsOK(
|
17707
|
-
SWIG_exception_fail(SWIG_ArgError(
|
17708
|
-
}
|
17709
|
-
arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
|
17710
|
-
ecode2 = SWIG_AsVal_double(argv[0], &val2);
|
17711
|
-
if (!SWIG_IsOK(ecode2)) {
|
17712
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::float_t","tropo_correction", 2, argv[0] ));
|
17844
|
+
ecode1 = SWIG_AsVal_double(argv[0], &val1);
|
17845
|
+
if (!SWIG_IsOK(ecode1)) {
|
17846
|
+
SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::float_t","SBAS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
|
17713
17847
|
}
|
17714
|
-
|
17715
|
-
|
17716
|
-
|
17717
|
-
if (!SWIG_IsOK(
|
17718
|
-
SWIG_exception_fail(SWIG_ArgError(
|
17848
|
+
temp1 = static_cast< SBAS_SpaceNode< double >::float_t >(val1);
|
17849
|
+
arg1 = &temp1;
|
17850
|
+
res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_ENUT_double_WGS84_t, 0 );
|
17851
|
+
if (!SWIG_IsOK(res2)) {
|
17852
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::enu_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 2, argv[1] ));
|
17719
17853
|
}
|
17720
|
-
if (!
|
17721
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::enu_t const &","tropo_correction",
|
17854
|
+
if (!argp2) {
|
17855
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::enu_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 2, argv[1]));
|
17722
17856
|
}
|
17723
|
-
|
17724
|
-
|
17725
|
-
if (!SWIG_IsOK(
|
17726
|
-
SWIG_exception_fail(SWIG_ArgError(
|
17857
|
+
arg2 = reinterpret_cast< SBAS_SpaceNode< double >::enu_t * >(argp2);
|
17858
|
+
res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 );
|
17859
|
+
if (!SWIG_IsOK(res3)) {
|
17860
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::llh_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 3, argv[2] ));
|
17727
17861
|
}
|
17728
|
-
if (!
|
17729
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::llh_t const &","tropo_correction",
|
17862
|
+
if (!argp3) {
|
17863
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::llh_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 3, argv[2]));
|
17730
17864
|
}
|
17731
|
-
|
17865
|
+
arg3 = reinterpret_cast< SBAS_SpaceNode< double >::llh_t * >(argp3);
|
17732
17866
|
{
|
17733
17867
|
try {
|
17734
|
-
result = (SBAS_SpaceNode< double >::float_t)
|
17868
|
+
result = (SBAS_SpaceNode< double >::float_t)SBAS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((double const &)*arg1,(System_ENU< double,WGS84 > const &)*arg2,(System_LLH< double,WGS84 > const &)*arg3);
|
17735
17869
|
} catch (const native_exception &e) {
|
17736
17870
|
e.regenerate();
|
17737
17871
|
SWIG_fail;
|
@@ -18914,12 +19048,12 @@ static swig_type_info _swigt__p_int_t = {"_p_int_t", "int_t *", 0, 0, (void*)0,
|
|
18914
19048
|
static swig_type_info _swigt__p_llh_t = {"_p_llh_t", "llh_t *", 0, 0, (void*)0, 0};
|
18915
19049
|
static swig_type_info _swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t = {"_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t", "GPS_User_PVT< double >::base_t::detection_t **|GPS_Solver_RAIM_LSR< double,GPS_Solver_Base_Debug< double,GPS_Solver_Base< double > > >::user_pvt_t::detection_t **", 0, 0, (void*)0, 0};
|
18916
19050
|
static swig_type_info _swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t = {"_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t", "GPS_User_PVT< double >::base_t::exclusion_t **|GPS_Solver_RAIM_LSR< double,GPS_Solver_Base_Debug< double,GPS_Solver_Base< double > > >::user_pvt_t::exclusion_t **", 0, 0, (void*)0, 0};
|
19051
|
+
static swig_type_info _swigt__p_range_correction_list_t = {"_p_range_correction_list_t", "range_correction_list_t *", 0, 0, (void*)0, 0};
|
18917
19052
|
static swig_type_info _swigt__p_s16_t = {"_p_s16_t", "s16_t *", 0, 0, (void*)0, 0};
|
18918
19053
|
static swig_type_info _swigt__p_s32_t = {"_p_s32_t", "s32_t *", 0, 0, (void*)0, 0};
|
18919
19054
|
static swig_type_info _swigt__p_s8_t = {"_p_s8_t", "s8_t *", 0, 0, (void*)0, 0};
|
18920
19055
|
static swig_type_info _swigt__p_satellites_t = {"_p_satellites_t", "satellites_t *", 0, 0, (void*)0, 0};
|
18921
19056
|
static swig_type_info _swigt__p_self_t = {"_p_self_t", "self_t *", 0, 0, (void*)0, 0};
|
18922
|
-
static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)0, 0};
|
18923
19057
|
static swig_type_info _swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t = {"_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t", "SBAS_SpaceNode< double >::available_satellites_t *|std::vector< std::pair< int,SBAS_SpaceNode< double >::Satellite const * > > *", 0, 0, (void*)0, 0};
|
18924
19058
|
static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
|
18925
19059
|
static swig_type_info _swigt__p_u16_t = {"_p_u16_t", "u16_t *", 0, 0, (void*)0, 0};
|
@@ -18971,12 +19105,12 @@ static swig_type_info *swig_type_initial[] = {
|
|
18971
19105
|
&_swigt__p_llh_t,
|
18972
19106
|
&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t,
|
18973
19107
|
&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t,
|
19108
|
+
&_swigt__p_range_correction_list_t,
|
18974
19109
|
&_swigt__p_s16_t,
|
18975
19110
|
&_swigt__p_s32_t,
|
18976
19111
|
&_swigt__p_s8_t,
|
18977
19112
|
&_swigt__p_satellites_t,
|
18978
19113
|
&_swigt__p_self_t,
|
18979
|
-
&_swigt__p_std__vectorT_int_t,
|
18980
19114
|
&_swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t,
|
18981
19115
|
&_swigt__p_swig__GC_VALUE,
|
18982
19116
|
&_swigt__p_u16_t,
|
@@ -19028,12 +19162,12 @@ static swig_cast_info _swigc__p_int_t[] = { {&_swigt__p_int_t, 0, 0, 0},{0, 0,
|
|
19028
19162
|
static swig_cast_info _swigc__p_llh_t[] = { {&_swigt__p_llh_t, 0, 0, 0},{0, 0, 0, 0}};
|
19029
19163
|
static swig_cast_info _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t[] = { {&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t, 0, 0, 0},{0, 0, 0, 0}};
|
19030
19164
|
static swig_cast_info _swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t[] = { {&_swigt__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t, 0, 0, 0},{0, 0, 0, 0}};
|
19165
|
+
static swig_cast_info _swigc__p_range_correction_list_t[] = { {&_swigt__p_range_correction_list_t, 0, 0, 0},{0, 0, 0, 0}};
|
19031
19166
|
static swig_cast_info _swigc__p_s16_t[] = { {&_swigt__p_s16_t, 0, 0, 0},{0, 0, 0, 0}};
|
19032
19167
|
static swig_cast_info _swigc__p_s32_t[] = { {&_swigt__p_s32_t, 0, 0, 0},{0, 0, 0, 0}};
|
19033
19168
|
static swig_cast_info _swigc__p_s8_t[] = { {&_swigt__p_s8_t, 0, 0, 0},{0, 0, 0, 0}};
|
19034
19169
|
static swig_cast_info _swigc__p_satellites_t[] = { {&_swigt__p_satellites_t, 0, 0, 0},{0, 0, 0, 0}};
|
19035
19170
|
static swig_cast_info _swigc__p_self_t[] = { {&_swigt__p_self_t, 0, 0, 0},{0, 0, 0, 0}};
|
19036
|
-
static swig_cast_info _swigc__p_std__vectorT_int_t[] = { {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
|
19037
19171
|
static swig_cast_info _swigc__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t[] = { {&_swigt__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
19038
19172
|
static swig_cast_info _swigc__p_swig__GC_VALUE[] = { {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
|
19039
19173
|
static swig_cast_info _swigc__p_u16_t[] = { {&_swigt__p_u16_t, 0, 0, 0},{0, 0, 0, 0}};
|
@@ -19085,12 +19219,12 @@ static swig_cast_info *swig_cast_initial[] = {
|
|
19085
19219
|
_swigc__p_llh_t,
|
19086
19220
|
_swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t,
|
19087
19221
|
_swigc__p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t,
|
19222
|
+
_swigc__p_range_correction_list_t,
|
19088
19223
|
_swigc__p_s16_t,
|
19089
19224
|
_swigc__p_s32_t,
|
19090
19225
|
_swigc__p_s8_t,
|
19091
19226
|
_swigc__p_satellites_t,
|
19092
19227
|
_swigc__p_self_t,
|
19093
|
-
_swigc__p_std__vectorT_int_t,
|
19094
19228
|
_swigc__p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t,
|
19095
19229
|
_swigc__p_swig__GC_VALUE,
|
19096
19230
|
_swigc__p_u16_t,
|
@@ -19397,6 +19531,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19397
19531
|
rb_define_singleton_method(SwigClassTime.klass, "leap_second_events", VALUEFUNC(_wrap_Time_leap_second_events_get), 0);
|
19398
19532
|
rb_define_singleton_method(SwigClassTime.klass, "guess_leap_seconds", VALUEFUNC(_wrap_Time_guess_leap_seconds), -1);
|
19399
19533
|
rb_define_method(SwigClassTime.klass, "to_a", VALUEFUNC(_wrap_Time_to_a), -1);
|
19534
|
+
rb_define_method(SwigClassTime.klass, "<=>", VALUEFUNC(_wrap_Time___cmp__), -1);
|
19400
19535
|
SwigClassTime.mark = 0;
|
19401
19536
|
SwigClassTime.destroy = (void (*)(void *)) free_GPS_Time_Sl_double_Sg_;
|
19402
19537
|
SwigClassTime.trackObjects = 0;
|
@@ -19412,6 +19547,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19412
19547
|
rb_define_singleton_method(SwigClassSpaceNode.klass, "L2_Frequency", VALUEFUNC(_wrap_SpaceNode_L2_Frequency_get), 0);
|
19413
19548
|
rb_define_singleton_method(SwigClassSpaceNode.klass, "L2_WaveLength", VALUEFUNC(_wrap_SpaceNode_L2_WaveLength), -1);
|
19414
19549
|
rb_define_singleton_method(SwigClassSpaceNode.klass, "gamma_L1_L2", VALUEFUNC(_wrap_SpaceNode_gamma_L1_L2_get), 0);
|
19550
|
+
rb_define_singleton_method(SwigClassSpaceNode.klass, "gamma_per_L1", VALUEFUNC(_wrap_SpaceNode_gamma_per_L1), -1);
|
19415
19551
|
rb_define_method(SwigClassSpaceNode.klass, "iono_utc", VALUEFUNC(_wrap_SpaceNode_iono_utc), -1);
|
19416
19552
|
rb_define_method(SwigClassSpaceNode.klass, "is_valid_iono", VALUEFUNC(_wrap_SpaceNode_is_valid_iono), -1);
|
19417
19553
|
rb_define_method(SwigClassSpaceNode.klass, "is_valid_utc", VALUEFUNC(_wrap_SpaceNode_is_valid_utc), -1);
|
@@ -19425,7 +19561,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19425
19561
|
rb_define_singleton_method(SwigClassSpaceNode.klass, "tec2delay", VALUEFUNC(_wrap_SpaceNode_tec2delay), -1);
|
19426
19562
|
rb_define_method(SwigClassSpaceNode.klass, "iono_correction", VALUEFUNC(_wrap_SpaceNode_iono_correction), -1);
|
19427
19563
|
rb_define_singleton_method(SwigClassSpaceNode.klass, "tropo_correction_zenith_hydrostatic_Saastamoinen", VALUEFUNC(_wrap_SpaceNode_tropo_correction_zenith_hydrostatic_Saastamoinen), -1);
|
19428
|
-
|
19564
|
+
rb_define_singleton_method(SwigClassSpaceNode.klass, "tropo_correction", VALUEFUNC(_wrap_SpaceNode_tropo_correction), -1);
|
19429
19565
|
rb_define_method(SwigClassSpaceNode.klass, "register_ephemeris", VALUEFUNC(_wrap_SpaceNode_register_ephemeris), -1);
|
19430
19566
|
rb_define_method(SwigClassSpaceNode.klass, "ephemeris", VALUEFUNC(_wrap_SpaceNode_ephemeris), -1);
|
19431
19567
|
rb_define_method(SwigClassSpaceNode.klass, "read", VALUEFUNC(_wrap_SpaceNode_read), -1);
|
@@ -19594,6 +19730,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19594
19730
|
rb_define_const(SwigClassMeasurement.klass, "L1_RANGE_RATE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_RANGE_RATE_SIGMA)));
|
19595
19731
|
rb_define_const(SwigClassMeasurement.klass, "L1_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_SIGNAL_STRENGTH_dBHz)));
|
19596
19732
|
rb_define_const(SwigClassMeasurement.klass, "L1_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_LOCK_SEC)));
|
19733
|
+
rb_define_const(SwigClassMeasurement.klass, "L1_FREQUENCY", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_FREQUENCY)));
|
19597
19734
|
rb_define_const(SwigClassMeasurement.klass, "ITEMS_PREDEFINED", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::ITEMS_PREDEFINED)));
|
19598
19735
|
rb_define_method(SwigClassMeasurement.klass, "add", VALUEFUNC(_wrap_Measurement_add), -1);
|
19599
19736
|
rb_define_method(SwigClassMeasurement.klass, "each", VALUEFUNC(_wrap_Measurement_each), -1);
|
@@ -19605,21 +19742,11 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19605
19742
|
SwigClassSolverOptionsCommon.klass = rb_define_class_under(mGPS, "SolverOptionsCommon", rb_cObject);
|
19606
19743
|
SWIG_TypeClientData(SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, (void *) &SwigClassSolverOptionsCommon);
|
19607
19744
|
rb_undef_alloc_func(SwigClassSolverOptionsCommon.klass);
|
19608
|
-
rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_KLOBUCHAR", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_KLOBUCHAR)));
|
19609
|
-
rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_SBAS", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_SBAS)));
|
19610
|
-
rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_NTCM_GL", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_NTCM_GL)));
|
19611
|
-
rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_NONE", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_NONE)));
|
19612
|
-
rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_MODELS", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_MODELS)));
|
19613
|
-
rb_define_const(SwigClassSolverOptionsCommon.klass, "IONOSPHERIC_SKIP", SWIG_From_int(static_cast< int >(GPS_SolverOptions_Common< double >::IONOSPHERIC_SKIP)));
|
19614
19745
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "cast_general", VALUEFUNC(_wrap_SolverOptionsCommon_cast_general), -1);
|
19615
|
-
rb_define_method(SwigClassSolverOptionsCommon.klass, "ionospheric_models", VALUEFUNC(_wrap_SolverOptionsCommon_ionospheric_models), -1);
|
19616
|
-
rb_define_method(SwigClassSolverOptionsCommon.klass, "ionospheric_models=", VALUEFUNC(_wrap_SolverOptionsCommon_ionospheric_modelse___), -1);
|
19617
19746
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_maske___), -1);
|
19618
19747
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_mask), -1);
|
19619
19748
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_residual_maske___), -1);
|
19620
19749
|
rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask", VALUEFUNC(_wrap_SolverOptionsCommon_residual_mask), -1);
|
19621
|
-
rb_define_method(SwigClassSolverOptionsCommon.klass, "f_10_7=", VALUEFUNC(_wrap_SolverOptionsCommon_f_10_7e___), -1);
|
19622
|
-
rb_define_method(SwigClassSolverOptionsCommon.klass, "f_10_7", VALUEFUNC(_wrap_SolverOptionsCommon_f_10_7), -1);
|
19623
19750
|
SwigClassSolverOptionsCommon.mark = 0;
|
19624
19751
|
SwigClassSolverOptionsCommon.destroy = (void (*)(void *)) free_GPS_SolverOptions_Common_Sl_double_Sg_;
|
19625
19752
|
SwigClassSolverOptionsCommon.trackObjects = 0;
|
@@ -19645,6 +19772,8 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19645
19772
|
rb_define_method(SwigClassSolver.klass, "sbas_space_node", VALUEFUNC(_wrap_Solver_sbas_space_node), -1);
|
19646
19773
|
rb_define_method(SwigClassSolver.klass, "sbas_options", VALUEFUNC(_wrap_Solver_sbas_options), -1);
|
19647
19774
|
rb_define_method(SwigClassSolver.klass, "solve", VALUEFUNC(_wrap_Solver_solve), -1);
|
19775
|
+
rb_define_method(SwigClassSolver.klass, "correction", VALUEFUNC(_wrap_Solver_correction), -1);
|
19776
|
+
rb_define_method(SwigClassSolver.klass, "correction=", VALUEFUNC(_wrap_Solver_correctione___), -1);
|
19648
19777
|
SwigClassSolver.mark = (void (*)(void *)) GPS_Solver<double>::mark;
|
19649
19778
|
SwigClassSolver.destroy = (void (*)(void *)) free_GPS_Solver_Sl_double_Sg_;
|
19650
19779
|
SwigClassSolver.trackObjects = 0;
|
@@ -19714,7 +19843,7 @@ SWIGEXPORT void Init_GPS(void) {
|
|
19714
19843
|
rb_define_const(SwigClassSpaceNode_SBAS.klass, "NULL_MESSAGES", SWIG_From_int(static_cast< int >(SBAS_SpaceNode< double >::NULL_MESSAGES)));
|
19715
19844
|
rb_define_const(SwigClassSpaceNode_SBAS.klass, "UNSUPPORTED_MESSAGE", SWIG_From_int(static_cast< int >(SBAS_SpaceNode< double >::UNSUPPORTED_MESSAGE)));
|
19716
19845
|
rb_define_singleton_method(SwigClassSpaceNode_SBAS.klass, "sagnac_correction", VALUEFUNC(_wrap_SpaceNode_SBAS_sagnac_correction), -1);
|
19717
|
-
|
19846
|
+
rb_define_singleton_method(SwigClassSpaceNode_SBAS.klass, "tropo_correction", VALUEFUNC(_wrap_SpaceNode_SBAS_tropo_correction), -1);
|
19718
19847
|
rb_define_method(SwigClassSpaceNode_SBAS.klass, "has_satellite", VALUEFUNC(_wrap_SpaceNode_SBAS_has_satellite), -1);
|
19719
19848
|
rb_define_method(SwigClassSpaceNode_SBAS.klass, "update_all_ephemeris", VALUEFUNC(_wrap_SpaceNode_SBAS_update_all_ephemeris), -1);
|
19720
19849
|
rb_define_method(SwigClassSpaceNode_SBAS.klass, "available_satellites", VALUEFUNC(_wrap_SpaceNode_SBAS_available_satellites), -1);
|