LatLongFormatter::formatCoordinate() - Code Metrics - Inspection of "Merge pull request #23 from DataValues/killGeo" - DataValues/Geo - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4564ad...000d15 )

by Bekh-Ivanov

created 2017-05-08 11:14 UTC

LatLongFormatter::formatCoordinate() C

↳ Parent: LatLongFormatter

Complexity

Conditions	12
Paths	17

Size

Total Lines	29
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	5.1612
c	0
b	0
f	0
cc	12
eloc	17
nc	17
nop	2

How to fix Complexity

<?php

namespace DataValues\Geo\Formatters;

use DataValues\Geo\Values\LatLongValue;
use InvalidArgumentException;
use ValueFormatters\FormatterOptions;
use ValueFormatters\ValueFormatterBase;

/**
 * Geographical coordinates formatter.
 * Formats LatLongValue objects.
 *
 * Supports the following notations:
 * - Degree minute second
 * - Decimal degrees
 * - Decimal minutes
 * - Float
 *
 * Some code in this class has been borrowed from the
 * MapsCoordinateParser class of the Maps extension for MediaWiki.
 *
 * @since 0.1
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < [email protected] >
 * @author Addshore
 * @author Thiemo Mättig
 */
class LatLongFormatter extends ValueFormatterBase {

	/**
	 * Output formats for use with the self::OPT_FORMAT option.
	 */
	const TYPE_FLOAT = 'float';
	const TYPE_DMS = 'dms';
	const TYPE_DM = 'dm';
	const TYPE_DD = 'dd';

	/**
	 * The symbols representing the different directions for usage in directional notation.
	 * @since 0.1
	 */
	const OPT_NORTH_SYMBOL = 'north';
	const OPT_EAST_SYMBOL = 'east';
	const OPT_SOUTH_SYMBOL = 'south';
	const OPT_WEST_SYMBOL = 'west';

	/**
	 * The symbols representing degrees, minutes and seconds.
	 * @since 0.1
	 */
	const OPT_DEGREE_SYMBOL = 'degree';
	const OPT_MINUTE_SYMBOL = 'minute';
	const OPT_SECOND_SYMBOL = 'second';

	/**
	 * Flags for use with the self::OPT_SPACING_LEVEL option.
	 */
	const OPT_SPACE_LATLONG = 'latlong';
	const OPT_SPACE_DIRECTION = 'direction';
	const OPT_SPACE_COORDPARTS = 'coordparts';

	/**
	 * Option specifying the output format (also referred to as output type). Must be one of the
	 * self::TYPE_… constants.
	 */
	const OPT_FORMAT = 'geoformat';

	/**
	 * Boolean option specifying if negative coordinates should have minus signs, e.g. "-1°, -2°"
	 * (false) or cardinal directions, e.g. "1° S, 2° W" (true). Default is false.
	 */
	const OPT_DIRECTIONAL = 'directional';

	/**
	 * Option for the separator character between latitude and longitude. Defaults to a comma.
	 */
	const OPT_SEPARATOR_SYMBOL = 'separator';

	/**
	 * Option specifying the amount and position of space characters in the output. Must be an array
	 * containing zero or more of the self::OPT_SPACE_… flags.
	 */
	const OPT_SPACING_LEVEL = 'spacing';

	/**
	 * Option specifying the precision in fractional degrees. Must be a number or numeric string.
	 */
	const OPT_PRECISION = 'precision';

	/**
	 * @since 0.1
	 *
	 * @param FormatterOptions|null $options
	 */
	public function __construct( FormatterOptions $options = null ) {
		parent::__construct( $options );

		$this->defaultOption( self::OPT_NORTH_SYMBOL, 'N' );
		$this->defaultOption( self::OPT_EAST_SYMBOL, 'E' );
		$this->defaultOption( self::OPT_SOUTH_SYMBOL, 'S' );
		$this->defaultOption( self::OPT_WEST_SYMBOL, 'W' );

		$this->defaultOption( self::OPT_DEGREE_SYMBOL, '°' );
		$this->defaultOption( self::OPT_MINUTE_SYMBOL, "'" );
		$this->defaultOption( self::OPT_SECOND_SYMBOL, '"' );

		$this->defaultOption( self::OPT_FORMAT, self::TYPE_FLOAT );
		$this->defaultOption( self::OPT_DIRECTIONAL, false );

		$this->defaultOption( self::OPT_SEPARATOR_SYMBOL, ',' );
		$this->defaultOption( self::OPT_SPACING_LEVEL, array(
			self::OPT_SPACE_LATLONG,
			self::OPT_SPACE_DIRECTION,
			self::OPT_SPACE_COORDPARTS,
		) );
		$this->defaultOption( self::OPT_PRECISION, 0 );
	}

	/**
	 * @see ValueFormatter::format
	 *
	 * Calls formatLatLongValue() using OPT_PRECISION for the $precision parameter.
	 *
	 * @param LatLongValue $value
	 *
	 * @return string Plain text
	 * @throws InvalidArgumentException
	 */
	public function format( $value ) {
		if ( !( $value instanceof LatLongValue ) ) {
			throw new InvalidArgumentException( 'Data value type mismatch. Expected a LatLongValue.' );
		}

		$precision = $this->options->getOption( self::OPT_PRECISION );

		return $this->formatLatLongValue( $value, $precision );
	}

	/**
	 * Formats a LatLongValue with the desired precision.
	 *
	 * @since 0.5
	 *
	 * @param LatLongValue $value
	 * @param float|int $precision The desired precision, given as fractional degrees.
	 *
	 * @return string Plain text
	 * @throws InvalidArgumentException
	 */
	public function formatLatLongValue( LatLongValue $value, $precision ) {
		if ( $precision <= 0 || !is_finite( $precision ) ) {
			$precision = 1 / 3600;
		}

		$formatted = implode(
			$this->getOption( self::OPT_SEPARATOR_SYMBOL ) . $this->getSpacing( self::OPT_SPACE_LATLONG ),
			array(
				$this->formatLatitude( $value->getLatitude(), $precision ),
				$this->formatLongitude( $value->getLongitude(), $precision )
			)
		);

		return $formatted;
	}

	/**
	 * @param string $spacingLevel One of the self::OPT_SPACE_… constants
	 *
	 * @return string
	 */
	private function getSpacing( $spacingLevel ) {
		if ( in_array( $spacingLevel, $this->getOption( self::OPT_SPACING_LEVEL ) ) ) {
			return ' ';
		}
		return '';
	}

	/**
	 * @param float $latitude
	 * @param float|int $precision
	 *
	 * @return string
	 */
	private function formatLatitude( $latitude, $precision ) {
		return $this->makeDirectionalIfNeeded(
			$this->formatCoordinate( $latitude, $precision ),
			$this->options->getOption( self::OPT_NORTH_SYMBOL ),
			$this->options->getOption( self::OPT_SOUTH_SYMBOL )
		);
	}

	/**
	 * @param float $longitude
	 * @param float|int $precision
	 *
	 * @return string
	 */
	private function formatLongitude( $longitude, $precision ) {
		return $this->makeDirectionalIfNeeded(
			$this->formatCoordinate( $longitude, $precision ),
			$this->options->getOption( self::OPT_EAST_SYMBOL ),
			$this->options->getOption( self::OPT_WEST_SYMBOL )
		);
	}

	/**
	 * @param string $coordinate
	 * @param string $positiveSymbol
	 * @param string $negativeSymbol
	 *
	 * @return string
	 */
	private function makeDirectionalIfNeeded( $coordinate, $positiveSymbol, $negativeSymbol ) {
		if ( $this->options->getOption( self::OPT_DIRECTIONAL ) ) {
			return $this->makeDirectional( $coordinate, $positiveSymbol, $negativeSymbol );
		}

		return $coordinate;
	}

	/**
	 * @param string $coordinate
	 * @param string $positiveSymbol
	 * @param string $negativeSymbol
	 *
	 * @return string
	 */
	private function makeDirectional( $coordinate, $positiveSymbol, $negativeSymbol ) {
		$isNegative = substr( $coordinate, 0, 1 ) === '-';

		if ( $isNegative ) {
			$coordinate = substr( $coordinate, 1 );
		}

		$symbol = $isNegative ? $negativeSymbol : $positiveSymbol;

		return $coordinate . $this->getSpacing( self::OPT_SPACE_DIRECTION ) . $symbol;
	}

	/**
	 * @param float $degrees
	 * @param float|int $precision
	 *
	 * @return string
	 */
	private function formatCoordinate( $degrees, $precision ) {
		// Remove insignificant detail
		$degrees = $this->roundDegrees( $degrees, $precision );
		$format = $this->getOption( self::OPT_FORMAT );

		if ( $format === self::TYPE_FLOAT ) {
			return $this->getInFloatFormat( $degrees );
		}

		if ( $format !== self::TYPE_DD ) {
			if ( $precision >= 1 - 1 / 60 && $precision < 1 ) {
				$precision = 1;
			} elseif ( $precision >= 1 / 60 - 1 / 3600 && $precision < 1 / 60 ) {
				$precision = 1 / 60;
			}
		}

		if ( $format === self::TYPE_DD || $precision >= 1 ) {
			return $this->getInDecimalDegreeFormat( $degrees, $precision );
		}
		if ( $format === self::TYPE_DM || $precision >= 1 / 60 ) {
			return $this->getInDecimalMinuteFormat( $degrees, $precision );
		}
		if ( $format === self::TYPE_DMS ) {
			return $this->getInDegreeMinuteSecondFormat( $degrees, $precision );
		}

		throw new InvalidArgumentException( 'Invalid coordinate format specified in the options' );
	}

	/**
	 * Round degrees according to OPT_PRECISION
	 *
	 * @param float $degrees
	 * @param float|int $precision
	 *
	 * @return float
	 */
	private function roundDegrees( $degrees, $precision ) {
		$sign = $degrees > 0 ? 1 : -1;
		$reduced = round( abs( $degrees ) / $precision );
		$expanded = $reduced * $precision;

		return $sign * $expanded;
	}

	/**
	 * @param float $floatDegrees
	 *
	 * @return string
	 */
	private function getInFloatFormat( $floatDegrees ) {
		$stringDegrees = (string)$floatDegrees;

		// Floats are fun...
		if ( $stringDegrees === '-0' ) {
			$stringDegrees = '0';
		}

		return $stringDegrees;
	}

	/**
	 * @param float $floatDegrees
	 * @param float|int $precision
	 *
	 * @return string
	 */
	private function getInDecimalDegreeFormat( $floatDegrees, $precision ) {
		$degreeDigits = $this->getSignificantDigits( 1, $precision );
		$stringDegrees = $this->formatNumber( $floatDegrees, $degreeDigits );

		return $stringDegrees . $this->options->getOption( self::OPT_DEGREE_SYMBOL );
	}

	/**
	 * @param float $floatDegrees
	 * @param float|int $precision
	 *
	 * @return string
	 */
	private function getInDegreeMinuteSecondFormat( $floatDegrees, $precision ) {
		$isNegative = $floatDegrees < 0;
		$secondDigits = $this->getSignificantDigits( 3600, $precision );

		$seconds = round( abs( $floatDegrees ) * 3600, max( 0, $secondDigits ) );
		$minutes = (int)( $seconds / 60 );
		$degrees = (int)( $minutes / 60 );

		$seconds -= $minutes * 60;
		$minutes -= $degrees * 60;

		$space = $this->getSpacing( self::OPT_SPACE_COORDPARTS );
		$result = $this->formatNumber( $degrees )
			. $this->options->getOption( self::OPT_DEGREE_SYMBOL )
			. $space
			. $this->formatNumber( $minutes )
			. $this->options->getOption( self::OPT_MINUTE_SYMBOL )
			. $space
			. $this->formatNumber( $seconds, $secondDigits )
			. $this->options->getOption( self::OPT_SECOND_SYMBOL );

		if ( $isNegative && ( $degrees + $minutes + $seconds ) > 0 ) {
			$result = '-' . $result;
		}

		return $result;
	}

	/**
	 * @param float $floatDegrees
	 * @param float|int $precision
	 *
	 * @return string
	 */
	private function getInDecimalMinuteFormat( $floatDegrees, $precision ) {
		$isNegative = $floatDegrees < 0;
		$minuteDigits = $this->getSignificantDigits( 60, $precision );

		$minutes = round( abs( $floatDegrees ) * 60, max( 0, $minuteDigits ) );
		$degrees = (int)( $minutes / 60 );

		$minutes -= $degrees * 60;

		$space = $this->getSpacing( self::OPT_SPACE_COORDPARTS );
		$result = $this->formatNumber( $degrees )
			. $this->options->getOption( self::OPT_DEGREE_SYMBOL )
			. $space
			. $this->formatNumber( $minutes, $minuteDigits )
			. $this->options->getOption( self::OPT_MINUTE_SYMBOL );

		if ( $isNegative && ( $degrees + $minutes ) > 0 ) {
			$result = '-' . $result;
		}

		return $result;
	}

	/**
	 * @param float|int $unitsPerDegree The number of target units per degree
	 * (60 for minutes, 3600 for seconds)
	 * @param float|int $degreePrecision
	 *
	 * @return int The number of digits to show after the decimal point
	 * (resp. before, if the result is negative).
	 */
	private function getSignificantDigits( $unitsPerDegree, $degreePrecision ) {
		return (int)ceil( -log10( $unitsPerDegree * $degreePrecision ) );
	}

	/**
	 * @param float $number
	 * @param int $digits The number of digits after the decimal point.
	 *
	 * @return string
	 */
	private function formatNumber( $number, $digits = 0 ) {
		// TODO: use NumberLocalizer
		return sprintf( '%.' . ( $digits > 0 ? $digits : 0 ) . 'F', $number );
	}

}


1			<?php
2
3			namespace DataValues\Geo\Formatters;
4
5			use DataValues\Geo\Values\LatLongValue;
6			use InvalidArgumentException;
7			use ValueFormatters\FormatterOptions;
8			use ValueFormatters\ValueFormatterBase;
9
10			/**
11			* Geographical coordinates formatter.
12			* Formats LatLongValue objects.
13			*
14			* Supports the following notations:
15			* - Degree minute second
16			* - Decimal degrees
17			* - Decimal minutes
18			* - Float
19			*
20			* Some code in this class has been borrowed from the
21			* MapsCoordinateParser class of the Maps extension for MediaWiki.
22			*
23			* @since 0.1
24			*
25			* @license GPL-2.0+
26			* @author Jeroen De Dauw < [email protected] >
27			* @author Addshore
28			* @author Thiemo Mättig
29			*/
30			class LatLongFormatter extends ValueFormatterBase {
31
32			/**
33			* Output formats for use with the self::OPT_FORMAT option.
34			*/
35			const TYPE_FLOAT = 'float';
36			const TYPE_DMS = 'dms';
37			const TYPE_DM = 'dm';
38			const TYPE_DD = 'dd';
39
40			/**
41			* The symbols representing the different directions for usage in directional notation.
42			* @since 0.1
43			*/
44			const OPT_NORTH_SYMBOL = 'north';
45			const OPT_EAST_SYMBOL = 'east';
46			const OPT_SOUTH_SYMBOL = 'south';
47			const OPT_WEST_SYMBOL = 'west';
48
49			/**
50			* The symbols representing degrees, minutes and seconds.
51			* @since 0.1
52			*/
53			const OPT_DEGREE_SYMBOL = 'degree';
54			const OPT_MINUTE_SYMBOL = 'minute';
55			const OPT_SECOND_SYMBOL = 'second';
56
57			/**
58			* Flags for use with the self::OPT_SPACING_LEVEL option.
59			*/
60			const OPT_SPACE_LATLONG = 'latlong';
61			const OPT_SPACE_DIRECTION = 'direction';
62			const OPT_SPACE_COORDPARTS = 'coordparts';
63
64			/**
65			* Option specifying the output format (also referred to as output type). Must be one of the
66			* self::TYPE_… constants.
67			*/
68			const OPT_FORMAT = 'geoformat';
69
70			/**
71			* Boolean option specifying if negative coordinates should have minus signs, e.g. "-1°, -2°"
72			* (false) or cardinal directions, e.g. "1° S, 2° W" (true). Default is false.
73			*/
74			const OPT_DIRECTIONAL = 'directional';
75
76			/**
77			* Option for the separator character between latitude and longitude. Defaults to a comma.
78			*/
79			const OPT_SEPARATOR_SYMBOL = 'separator';
80
81			/**
82			* Option specifying the amount and position of space characters in the output. Must be an array
83			* containing zero or more of the self::OPT_SPACE_… flags.
84			*/
85			const OPT_SPACING_LEVEL = 'spacing';
86
87			/**
88			* Option specifying the precision in fractional degrees. Must be a number or numeric string.
89			*/
90			const OPT_PRECISION = 'precision';
91
92			/**
93			* @since 0.1
94			*
95			* @param FormatterOptions\|null $options
96			*/
97			public function __construct( FormatterOptions $options = null ) {
98			parent::__construct( $options );
99
100			$this->defaultOption( self::OPT_NORTH_SYMBOL, 'N' );
101			$this->defaultOption( self::OPT_EAST_SYMBOL, 'E' );
102			$this->defaultOption( self::OPT_SOUTH_SYMBOL, 'S' );
103			$this->defaultOption( self::OPT_WEST_SYMBOL, 'W' );
104
105			$this->defaultOption( self::OPT_DEGREE_SYMBOL, '°' );
106			$this->defaultOption( self::OPT_MINUTE_SYMBOL, "'" );
107			$this->defaultOption( self::OPT_SECOND_SYMBOL, '"' );
108
109			$this->defaultOption( self::OPT_FORMAT, self::TYPE_FLOAT );
110			$this->defaultOption( self::OPT_DIRECTIONAL, false );
111
112			$this->defaultOption( self::OPT_SEPARATOR_SYMBOL, ',' );
113			$this->defaultOption( self::OPT_SPACING_LEVEL, array(
114			self::OPT_SPACE_LATLONG,
115			self::OPT_SPACE_DIRECTION,
116			self::OPT_SPACE_COORDPARTS,
117			) );
118			$this->defaultOption( self::OPT_PRECISION, 0 );
119			}
120
121			/**
122			* @see ValueFormatter::format
123			*
124			* Calls formatLatLongValue() using OPT_PRECISION for the $precision parameter.
125			*
126			* @param LatLongValue $value
127			*
128			* @return string Plain text
129			* @throws InvalidArgumentException
130			*/
131			public function format( $value ) {
132			if ( !( $value instanceof LatLongValue ) ) {
133			throw new InvalidArgumentException( 'Data value type mismatch. Expected a LatLongValue.' );
134			}
135
136			$precision = $this->options->getOption( self::OPT_PRECISION );
137
138			return $this->formatLatLongValue( $value, $precision );
139			}
140
141			/**
142			* Formats a LatLongValue with the desired precision.
143			*
144			* @since 0.5
145			*
146			* @param LatLongValue $value
147			* @param float\|int $precision The desired precision, given as fractional degrees.
148			*
149			* @return string Plain text
150			* @throws InvalidArgumentException
151			*/
152			public function formatLatLongValue( LatLongValue $value, $precision ) {
153			if ( $precision <= 0 \|\| !is_finite( $precision ) ) {
154			$precision = 1 / 3600;
155			}
156
157			$formatted = implode(
158			$this->getOption( self::OPT_SEPARATOR_SYMBOL ) . $this->getSpacing( self::OPT_SPACE_LATLONG ),
159			array(
160			$this->formatLatitude( $value->getLatitude(), $precision ),
161			$this->formatLongitude( $value->getLongitude(), $precision )
162			)
163			);
164
165			return $formatted;
166			}
167
168			/**
169			* @param string $spacingLevel One of the self::OPT_SPACE_… constants
170			*
171			* @return string
172			*/
173			private function getSpacing( $spacingLevel ) {
174			if ( in_array( $spacingLevel, $this->getOption( self::OPT_SPACING_LEVEL ) ) ) {
175			return ' ';
176			}
177			return '';
178			}
179
180			/**
181			* @param float $latitude
182			* @param float\|int $precision
183			*
184			* @return string
185			*/
186			private function formatLatitude( $latitude, $precision ) {
187			return $this->makeDirectionalIfNeeded(
188			$this->formatCoordinate( $latitude, $precision ),
189			$this->options->getOption( self::OPT_NORTH_SYMBOL ),
190			$this->options->getOption( self::OPT_SOUTH_SYMBOL )
191			);
192			}
193
194			/**
195			* @param float $longitude
196			* @param float\|int $precision
197			*
198			* @return string
199			*/
200			private function formatLongitude( $longitude, $precision ) {
201			return $this->makeDirectionalIfNeeded(
202			$this->formatCoordinate( $longitude, $precision ),
203			$this->options->getOption( self::OPT_EAST_SYMBOL ),
204			$this->options->getOption( self::OPT_WEST_SYMBOL )
205			);
206			}
207
208			/**
209			* @param string $coordinate
210			* @param string $positiveSymbol
211			* @param string $negativeSymbol
212			*
213			* @return string
214			*/
215			private function makeDirectionalIfNeeded( $coordinate, $positiveSymbol, $negativeSymbol ) {
216			if ( $this->options->getOption( self::OPT_DIRECTIONAL ) ) {
217			return $this->makeDirectional( $coordinate, $positiveSymbol, $negativeSymbol );
218			}
219
220			return $coordinate;
221			}
222
223			/**
224			* @param string $coordinate
225			* @param string $positiveSymbol
226			* @param string $negativeSymbol
227			*
228			* @return string
229			*/
230			private function makeDirectional( $coordinate, $positiveSymbol, $negativeSymbol ) {
231			$isNegative = substr( $coordinate, 0, 1 ) === '-';
232
233			if ( $isNegative ) {
234			$coordinate = substr( $coordinate, 1 );
235			}
236
237			$symbol = $isNegative ? $negativeSymbol : $positiveSymbol;
238
239			return $coordinate . $this->getSpacing( self::OPT_SPACE_DIRECTION ) . $symbol;
240			}
241
242			/**
243			* @param float $degrees
244			* @param float\|int $precision
245			*
246			* @return string
247			*/
248			private function formatCoordinate( $degrees, $precision ) {
249			// Remove insignificant detail
250			$degrees = $this->roundDegrees( $degrees, $precision );
251			$format = $this->getOption( self::OPT_FORMAT );
252
253			if ( $format === self::TYPE_FLOAT ) {
254			return $this->getInFloatFormat( $degrees );
255			}
256
257			if ( $format !== self::TYPE_DD ) {
258			if ( $precision >= 1 - 1 / 60 && $precision < 1 ) {
259			$precision = 1;
260			} elseif ( $precision >= 1 / 60 - 1 / 3600 && $precision < 1 / 60 ) {
261			$precision = 1 / 60;
262			}
263			}
264
265			if ( $format === self::TYPE_DD \|\| $precision >= 1 ) {
266			return $this->getInDecimalDegreeFormat( $degrees, $precision );
267			}
268			if ( $format === self::TYPE_DM \|\| $precision >= 1 / 60 ) {
269			return $this->getInDecimalMinuteFormat( $degrees, $precision );
270			}
271			if ( $format === self::TYPE_DMS ) {
272			return $this->getInDegreeMinuteSecondFormat( $degrees, $precision );
273			}
274
275			throw new InvalidArgumentException( 'Invalid coordinate format specified in the options' );
276			}
277
278			/**
279			* Round degrees according to OPT_PRECISION
280			*
281			* @param float $degrees
282			* @param float\|int $precision
283			*
284			* @return float
285			*/
286			private function roundDegrees( $degrees, $precision ) {
287			$sign = $degrees > 0 ? 1 : -1;
288			$reduced = round( abs( $degrees ) / $precision );
289			$expanded = $reduced * $precision;
290
291			return $sign * $expanded;
292			}
293
294			/**
295			* @param float $floatDegrees
296			*
297			* @return string
298			*/
299			private function getInFloatFormat( $floatDegrees ) {
300			$stringDegrees = (string)$floatDegrees;
301
302			// Floats are fun...
303			if ( $stringDegrees === '-0' ) {
304			$stringDegrees = '0';
305			}
306
307			return $stringDegrees;
308			}
309
310			/**
311			* @param float $floatDegrees
312			* @param float\|int $precision
313			*
314			* @return string
315			*/
316			private function getInDecimalDegreeFormat( $floatDegrees, $precision ) {
317			$degreeDigits = $this->getSignificantDigits( 1, $precision );
318			$stringDegrees = $this->formatNumber( $floatDegrees, $degreeDigits );
319
320			return $stringDegrees . $this->options->getOption( self::OPT_DEGREE_SYMBOL );
321			}
322
323			/**
324			* @param float $floatDegrees
325			* @param float\|int $precision
326			*
327			* @return string
328			*/
329			private function getInDegreeMinuteSecondFormat( $floatDegrees, $precision ) {
330			$isNegative = $floatDegrees < 0;
331			$secondDigits = $this->getSignificantDigits( 3600, $precision );
332
333			$seconds = round( abs( $floatDegrees ) * 3600, max( 0, $secondDigits ) );
334			$minutes = (int)( $seconds / 60 );
335			$degrees = (int)( $minutes / 60 );
336
337			$seconds -= $minutes * 60;
338			$minutes -= $degrees * 60;
339
340			$space = $this->getSpacing( self::OPT_SPACE_COORDPARTS );
341			$result = $this->formatNumber( $degrees )
342			. $this->options->getOption( self::OPT_DEGREE_SYMBOL )
343			. $space
344			. $this->formatNumber( $minutes )
345			. $this->options->getOption( self::OPT_MINUTE_SYMBOL )
346			. $space
347			. $this->formatNumber( $seconds, $secondDigits )
348			. $this->options->getOption( self::OPT_SECOND_SYMBOL );
349
350			if ( $isNegative && ( $degrees + $minutes + $seconds ) > 0 ) {
351			$result = '-' . $result;
352			}
353
354			return $result;
355			}
356
357			/**
358			* @param float $floatDegrees
359			* @param float\|int $precision
360			*
361			* @return string
362			*/
363			private function getInDecimalMinuteFormat( $floatDegrees, $precision ) {
364			$isNegative = $floatDegrees < 0;
365			$minuteDigits = $this->getSignificantDigits( 60, $precision );
366
367			$minutes = round( abs( $floatDegrees ) * 60, max( 0, $minuteDigits ) );
368			$degrees = (int)( $minutes / 60 );
369
370			$minutes -= $degrees * 60;
371
372			$space = $this->getSpacing( self::OPT_SPACE_COORDPARTS );
373			$result = $this->formatNumber( $degrees )
374			. $this->options->getOption( self::OPT_DEGREE_SYMBOL )
375			. $space
376			. $this->formatNumber( $minutes, $minuteDigits )
377			. $this->options->getOption( self::OPT_MINUTE_SYMBOL );
378
379			if ( $isNegative && ( $degrees + $minutes ) > 0 ) {
380			$result = '-' . $result;
381			}
382
383			return $result;
384			}
385
386			/**
387			* @param float\|int $unitsPerDegree The number of target units per degree
388			* (60 for minutes, 3600 for seconds)
389			* @param float\|int $degreePrecision
390			*
391			* @return int The number of digits to show after the decimal point
392			* (resp. before, if the result is negative).
393			*/
394			private function getSignificantDigits( $unitsPerDegree, $degreePrecision ) {
395			return (int)ceil( -log10( $unitsPerDegree * $degreePrecision ) );
396			}
397
398			/**
399			* @param float $number
400			* @param int $digits The number of digits after the decimal point.
401			*
402			* @return string
403			*/
404			private function formatNumber( $number, $digits = 0 ) {
405			// TODO: use NumberLocalizer
406			return sprintf( '%.' . ( $digits > 0 ? $digits : 0 ) . 'F', $number );
407			}
408
409			}
410

DataValues / Geo

Push — master ( 4564ad...000d15 )

LatLongFormatter::formatCoordinate() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like