Class: GPS_PVT::Coordinate::LLH

Inherits:
((swig_class *) SWIGTYPE_p_System_3DT_double_t->clientdata)->klass
  • Object
show all
Defined in:
ext/gps_pvt/Coordinate/Coordinate_wrap.cxx,
ext/gps_pvt/Coordinate/Coordinate_wrap.cxx

Overview

Proxy of C++ GPS_PVT::Coordinate::LLH class

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



4170
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191
4192
4193
4194
4195
4196
4197
4198
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4170

SWIGINTERN VALUE _wrap_new_LLH(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LLH__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LLH__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LLH__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LLH.new", 
    "    LLH.new()\n"
    "    LLH.new(double const &latitude, double const &longitude, double const &height)\n"
    "    LLH.new(System_LLH< double,WGS84 >::self_t const &llh)\n");
  
  return Qnil;
}

Instance Method Details

#height(*args, self) ⇒ Object Also known as: h, alt

call-seq:

height -> double const &
height -> double

An instance method.



4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4519

SWIGINTERN VALUE _wrap_LLH_height(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_height__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_height__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "LLH.height", 
    "    double const LLH.height()\n"
    "    double & LLH.height()\n");
  
  return Qnil;
}

#height=(*args) ⇒ Object Also known as: h=, alt=

call-seq:

height=(double const & v) -> double

An instance method.



5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078
5079
5080
5081
5082
5083
5084
5085
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 5054

SWIGINTERN VALUE
_wrap_LLH_heighte___(int argc, VALUE *argv, VALUE self) {
  System_LLH< double,WGS84 > *arg1 = (System_LLH< double,WGS84 > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "System_LLH< double,WGS84 > *","set_height", 1, self )); 
  }
  arg1 = reinterpret_cast< System_LLH< double,WGS84 > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_height", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (double)System_LLH_Sl_double_Sc_WGS84_Sg__set_height(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#latitude(*args, self) ⇒ Object Also known as: lat

call-seq:

latitude -> double const &
latitude -> double

An instance method.



4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4369

SWIGINTERN VALUE _wrap_LLH_latitude(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_latitude__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_latitude__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "LLH.latitude", 
    "    double const LLH.latitude()\n"
    "    double & LLH.latitude()\n");
  
  return Qnil;
}

#latitude=(*args) ⇒ Object Also known as: lat=

call-seq:

latitude=(double const & v) -> double

An instance method.



4968
4969
4970
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986
4987
4988
4989
4990
4991
4992
4993
4994
4995
4996
4997
4998
4999
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4968

SWIGINTERN VALUE
_wrap_LLH_latitudee___(int argc, VALUE *argv, VALUE self) {
  System_LLH< double,WGS84 > *arg1 = (System_LLH< double,WGS84 > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "System_LLH< double,WGS84 > *","set_latitude", 1, self )); 
  }
  arg1 = reinterpret_cast< System_LLH< double,WGS84 > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_latitude", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (double)System_LLH_Sl_double_Sc_WGS84_Sg__set_latitude(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#longitude(*args, self) ⇒ Object Also known as: lng

call-seq:

longitude -> double const &
longitude -> double

An instance method.



4444
4445
4446
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478
4479
4480
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4444

SWIGINTERN VALUE _wrap_LLH_longitude(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_longitude__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_longitude__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "LLH.longitude", 
    "    double const LLH.longitude()\n"
    "    double & LLH.longitude()\n");
  
  return Qnil;
}

#longitude=(*args) ⇒ Object Also known as: lng=

call-seq:

longitude=(double const & v) -> double

An instance method.



5011
5012
5013
5014
5015
5016
5017
5018
5019
5020
5021
5022
5023
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036
5037
5038
5039
5040
5041
5042
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 5011

SWIGINTERN VALUE
_wrap_LLH_longitudee___(int argc, VALUE *argv, VALUE self) {
  System_LLH< double,WGS84 > *arg1 = (System_LLH< double,WGS84 > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "System_LLH< double,WGS84 > *","set_longitude", 1, self )); 
  }
  arg1 = reinterpret_cast< System_LLH< double,WGS84 > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_longitude", 2, argv[0] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (double)System_LLH_Sl_double_Sc_WGS84_Sg__set_longitude(arg1,(double const &)*arg2);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#rotation_ecef2enu(*args, self) ⇒ Object

call-seq:

rotation_ecef2enu(double const & clat, double const & clng, double const & slat, double const & slng)
rotation_ecef2enu

A class method.



4684
4685
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705
4706
4707
4708
4709
4710
4711
4712
4713
4714
4715
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725
4726
4727
4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4684

SWIGINTERN VALUE _wrap_LLH_rotation_ecef2enu(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_rotation_ecef2enu__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LLH_rotation_ecef2enu__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "LLH.rotation_ecef2enu", 
    "    void LLH.rotation_ecef2enu(double const &clng, double const &slat, double const &slng, double (&res)[3][3])\n"
    "    void LLH.rotation_ecef2enu(double (&res)[3][3])\n");
  
  return Qnil;
}

#rotation_ecef2ned(*args, self) ⇒ Object

call-seq:

rotation_ecef2ned(double const & clat, double const & clng, double const & slat, double const & slng)
rotation_ecef2ned

A class method.



4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919
4920
4921
4922
4923
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4868

SWIGINTERN VALUE _wrap_LLH_rotation_ecef2ned(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_System_LLHT_double_WGS84_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LLH_rotation_ecef2ned__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LLH_rotation_ecef2ned__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "LLH.rotation_ecef2ned", 
    "    void LLH.rotation_ecef2ned(double const &clng, double const &slat, double const &slng, double (&res)[3][3])\n"
    "    void LLH.rotation_ecef2ned(double (&res)[3][3])\n");
  
  return Qnil;
}

#xyz(*args) ⇒ Object

call-seq:

xyz -> XYZ

An instance method.



4935
4936
4937
4938
4939
4940
4941
4942
4943
4944
4945
4946
4947
4948
4949
4950
4951
4952
4953
4954
4955
4956
 
# File 'ext/gps_pvt/Coordinate/Coordinate_wrap.cxx', line 4935

SWIGINTERN VALUE
_wrap_LLH_xyz(int argc, VALUE *argv, VALUE self) {
  System_LLH< double,WGS84 > *arg1 = (System_LLH< double,WGS84 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  System_LLH< double,WGS84 >::xyz_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_System_LLHT_double_WGS84_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "System_LLH< double,WGS84 > const *","xyz", 1, self )); 
  }
  arg1 = reinterpret_cast< System_LLH< double,WGS84 > * >(argp1);
  result = ((System_LLH< double,WGS84 > const *)arg1)->xyz();
  vresult = SWIG_NewPointerObj((new System_LLH< double,WGS84 >::xyz_t(static_cast< const System_LLH< double,WGS84 >::xyz_t& >(result))), SWIGTYPE_p_System_XYZT_double_WGS84_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}