Coverage for astrocalc/coords/unit

Hot-keys on this page

r m x p toggle line displays

j k next/prev highlighted chunk

0 (zero) top of page

1 (one) first highlighted chunk

1#!/usr/local/bin/python

2# encoding: utf-8

3"""

4*Convert coordinates from decimal to sexagesimal units and vice-versa*

6:Author:

7 David Young

8"""

9from __future__ import division

10from builtins import str

11from builtins import object

12from past.utils import old_div

13import sys

14import os

15import math

16os.environ['TERM'] = 'vt100'

17from fundamentals import tools

19class unit_conversion(object):

20 """

21 *The worker class for the unit_conversion module*

23 **Key Arguments**

25 - ``log`` -- logger

26 - ``settings`` -- the settings dictionary (prob not required)

29 **Usage**

31 .. todo::

33 - add usage info

34 - create a sublime snippet for usage

35 - add ra_sexegesimal_to_decimal

37 ```python

38 usage code

39 ```

42 .. todo::

44 - @review: when complete, clean unit_conversion class

45 - @review: when complete add logging

46 - @review: when complete, decide whether to abstract class to another module

47 """

48 # Initialisation

49 # 1. @flagged: what are the unique attrributes for each object? Add them

50 # to __init__

52 def __init__(

53 self,

54 log,

55 settings=False

56 ):

57 self.log = log

58 log.debug("instansiating a new 'unit_conversion' object")

59 self.settings = settings

60 # xt-self-arg-tmpx

62 # 2. @flagged: what are the default attrributes each object could have? Add them to variable attribute set here

63 # Variable Data Atrributes

65 # 3. @flagged: what variable attrributes need overriden in any baseclass(es) used

66 # Override Variable Data Atrributes

68 # Initial Actions

70 return None

72 # 4. @flagged: what actions does each object have to be able to perform? Add them here

73 # Method Attributes

74 def get(self):

75 """

76 *get the unit_conversion object*

78 **Return**

80 - ``unit_conversion``

83 .. todo::

85 - @review: when complete, clean get method

86 - @review: when complete add logging

87 """

88 self.log.debug('starting the ``get`` method')

90 unit_conversion = None

92 self.log.debug('completed the ``get`` method')

93 return unit_conversion

95 def dec_sexegesimal_to_decimal(

96 self,

97 dec):

98 """

99 *Convert a declination from sexegesimal format to decimal degrees.*

100

101 Precision should be respected. If a float is passed to this method, the same float will be returned (useful if unclear which format coordinates are in).

102

103 The code will attempt to read the sexegesimal value in whatever form it is passed. Any of the following should be handled correctly:

104

105 - ``+1:58:05.45341``

106 - ``01:5:05``

107 - ``+1 58 05.45341``

108 - ``-23h53m05s``

109

110 **Key Arguments**

111

112 - ``dec`` - DEC in sexegesimal format.

113

114

115 **Return**

116

117 - ``decDeg`` -- declination converted to decimal degrees

120 **Usage**

122 .. todo::

124 - replace dryxPython declination_sexegesimal_to_decimal with this version in all my code

125 - replace coords_sex_to_dec in all code

126

127 ```python

128 from astrocalc.coords import unit_conversion

129 converter = unit_conversion(

130 log=log

131 )

132 dec = converter.dec_sexegesimal_to_decimal(

133 dec="-23:45:21.23232"

134 )

135 print(dec)

136

137 # OUTPUT: -23.7558978667

138 ```

139

140 """

141 self.log.debug(

142 'completed the ````dec_sexegesimal_to_decimal`` method')

143

144 import re

145

146 # TEST TO SEE IF DECIMAL DEGREES PASSED

147 try:

148 dec = float(dec)

149 if dec > -90. and dec < 90.:

150 self.log.debug(

151 'declination seems to already be in decimal degrees, returning original value' % locals())

152 return float(dec)

153 except:

154 pass

155

156 # REMOVE SURROUNDING WHITESPACE

157 dec = str(dec).strip()

158

159 # LOOK FOR A MINUS SIGN. NOTE THAT -00 IS THE SAME AS 00.

160 regex = re.compile(

161 r'^([\+\-]?(\d|[0-8]\d))\D+([0-5]\d)\D+([0-6]?\d(\.\d+)?)$')

162 decMatch = regex.match(dec)

163

164 if decMatch:

165 degrees = decMatch.group(1)

166 minutes = decMatch.group(3)

167 seconds = decMatch.group(4)

168

169 if degrees[0] == '-':

170 sgn = -1

171 else:

172 sgn = 1

173

174 degrees = abs(float(degrees))

175 minutes = float(minutes)

176 seconds = float(seconds)

177

178 # PRECISION TEST

179 # 1s = .000277778 DEGREE

180 # THEREFORE REPORT SECONDS TO A PRECISION = INPUT PRECISION + 4

181 decimalLen = len(repr(seconds).split(".")[-1])

182 precision = decimalLen + 4

183

184 decDeg = (degrees + (minutes / 60.0)

185 + (seconds / 3600.0)) * sgn

186

187 decDeg = "%0.*f" % (precision, decDeg)

188

189 else:

190 raise IOError(

191 "could not convert dec to decimal degrees, could not parse sexegesimal input. Original value was `%(dec)s`" % locals())

192

193 decDeg = float(decDeg)

194 self.log.debug('decDeg: %(decDeg)s' % locals())

195 self.log.debug(

196 'completed the ``dec_sexegesimal_to_decimal`` method')

197

198 return float(decDeg)

199

200 def ra_sexegesimal_to_decimal(

201 self,

202 ra

203 ):

204 """

205 *Convert a right-ascension from sexegesimal format to decimal degrees.*

206

207 Precision should be respected. If a float is passed to this method, the same float will be returned (useful if unclear which format coordinates are in).

208

209 The code will attempt to read the sexegesimal value in whatever form it is passed. Any of the following should be handled correctly

210

211 - ``23:45:21.23232``

212 - ``23h45m21.23232s``

213 - ``23 45 21.23232``

214 - ``2 04 21.23232``

215 - ``04:45 21``

216

217 **Key Arguments**

218

219 - ``ra`` -- ra in sexegesimal units