gps_pvt 0.2.0 → 0.3.0
Sign up to get free protection for your applications and to get access to all the features.
- 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);
|