TrackPoint::with() - Code Metrics - dragosprotung/stc-core - Measure and Improve Code Quality continuously with Scrutinizer

TrackPoint::with() A
last analyzed 2016-12-14 13:27 UTC

↳ Parent: TrackPoint

Complexity

Conditions	1
Paths	1

Size

Total Lines	15
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	15
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	13
nc	1
nop	5

<?php

declare(strict_types = 1);

namespace SportTrackerConnector\Core\Workout;

use Assert\Assertion;
use SportTrackerConnector\Core\Workout\Extension\ExtensionInterface;

/**
 * A point in a track.
 */
final class TrackPoint
{
    /**
     * Latitude of the point.
     *
     * @var float
     */
    private $latitude;

    /**
     * Longitude of the point.
     *
     * @var float
     */
    private $longitude;

    /**
     * Elevation of the point.
     *
     * @var float
     */
    private $elevation;

    /**
     * The time for the point.
     *
     * @var \DateTimeImmutable
     */
    private $dateTime;

    /**
     * Array of extensions.
     *
     * @var ExtensionInterface[]
     */
    private $extensions = array();

    /**
     * @param float $latitude The latitude.
     * @param float $longitude The longitude.
     * @param \DateTimeImmutable $dateTime The date and time of the point.
     * @param float|null $elevation
     * @param array $extensions
     */
    private function __construct(
        ?float $latitude,
        ?float $longitude,
        \DateTimeImmutable $dateTime,
        ?float $elevation,
        array $extensions = []
    ) {
        $this->latitude = $latitude;
        $this->longitude = $longitude;
        $this->dateTime = $dateTime;
        $this->elevation = $elevation;

        foreach ($extensions as $extension) {
            $this->addExtension($extension);
        }
    }

    /**
     * Add an extension to the workout.
     *
     * @param ExtensionInterface $extension The extension to add.
     */
    private function addExtension(ExtensionInterface $extension)
    {
        $this->extensions[$extension::ID()] = $extension;
    }

    /**
     * @param float|null $latitude
     * @param float|null $longitude
     * @param \DateTimeImmutable $dateTime
     * @param float|null $elevation
     * @param array $extensions
     * @return TrackPoint
     */
    public static function with(
        ?float $latitude,
        ?float $longitude,
        \DateTimeImmutable $dateTime,
        ?float $elevation = null,
        array $extensions = []
    ): TrackPoint {
        Assertion::greaterOrEqualThan($latitude, -180);
        Assertion::greaterOrEqualThan($longitude, -180);
        Assertion::lessOrEqualThan($latitude, 180);
        Assertion::lessOrEqualThan($longitude, 180);
        Assertion::allIsInstanceOf($extensions, ExtensionInterface::class);

        return new static($latitude, $longitude, $dateTime, $elevation, $extensions);
    }

    /**
     * Get the elevation.
     *
     * @return float
     */
    public function elevation(): float
    {
        return $this->elevation;
    }

    /**
     * Get the extensions.
     *
     * @return ExtensionInterface[]
     */
    public function extensions(): array
    {
        return array_values($this->extensions);
    }


    /**
     * Check if an extension is present.
     *
     * @param string $idExtension The ID of the extension.
     * @return boolean
     */
    public function hasExtension(string $idExtension): bool
    {
        return array_key_exists($idExtension, $this->extensions);
    }

    /**
     * Get an extension by ID.
     *
     * @param string $idExtension The ID of the extension.
     * @return ExtensionInterface
     * @throws \OutOfBoundsException If the extension is not found.
     */
    public function extension($idExtension): ExtensionInterface
    {
        if ($this->hasExtension($idExtension) !== true) {
            throw new \OutOfBoundsException(sprintf('Extension "%s" not found.', $idExtension));
        }

        return $this->extensions[$idExtension];
    }

    /**
     * Get the latitude.
     *
     * @return float
     */
    public function latitude(): ?float
    {
        return $this->latitude;
    }

    /**
     * Get the longitude.
     *
     * @return float
     */
    public function longitude(): ?float
    {
        return $this->longitude;
    }

    /**
     * Get the date time of the point.
     *
     * @return \DateTimeImmutable
     */
    public function dateTime(): \DateTimeImmutable
    {
        return $this->dateTime;
    }

    /**
     * Get the distance between this point and another point in meters.
     *
     * @param TrackPoint $trackPoint The other point.
     * @return float The distance in meters.
     */
    public function distanceFromPoint(TrackPoint $trackPoint): float
    {
        $earthRadius = 6371000;

        $latFrom = deg2rad($this->latitude());
        $lonFrom = deg2rad($this->longitude());
        $latTo = deg2rad($trackPoint->latitude());
        $lonTo = deg2rad($trackPoint->longitude());

        $latDelta = $latTo - $latFrom;
        $lonDelta = $lonTo - $lonFrom;

        $angle = 2 * asin(
                sqrt(
                    pow(sin($latDelta / 2), 2) +
                    cos($latFrom) * cos($latTo) * pow(sin($lonDelta / 2), 2)
                )
            );

        return $angle * $earthRadius;
    }

    /**
     * Get the speed between this point and another point in km/h.
     *
     * @param TrackPoint $trackPoint The other point.
     * @return float
     */
    public function speed(TrackPoint $trackPoint): float
    {
        $start = $this->dateTime();
        $end = $trackPoint->dateTime();
        $dateDiff = $start->diff($end);
        $secondsDifference = ($dateDiff->days * 86400) + ($dateDiff->h * 3600) + ($dateDiff->i * 60) + $dateDiff->s;

        if ($secondsDifference === 0) {
            return 0.0;
        }

        $distance = $this->distanceFromPoint($trackPoint);

        return ($distance / $secondsDifference) * 3.6;
    }
}


1			<?php
2
3			declare(strict_types = 1);
4
5			namespace SportTrackerConnector\Core\Workout;
6
7			use Assert\Assertion;
8			use SportTrackerConnector\Core\Workout\Extension\ExtensionInterface;
9
10			/**
11			* A point in a track.
12			*/
13			final class TrackPoint
14			{
15			/**
16			* Latitude of the point.
17			*
18			* @var float
19			*/
20			private $latitude;
21
22			/**
23			* Longitude of the point.
24			*
25			* @var float
26			*/
27			private $longitude;
28
29			/**
30			* Elevation of the point.
31			*
32			* @var float
33			*/
34			private $elevation;
35
36			/**
37			* The time for the point.
38			*
39			* @var \DateTimeImmutable
40			*/
41			private $dateTime;
42
43			/**
44			* Array of extensions.
45			*
46			* @var ExtensionInterface[]
47			*/
48			private $extensions = array();
49
50			/**
51			* @param float $latitude The latitude.
52			* @param float $longitude The longitude.
53			* @param \DateTimeImmutable $dateTime The date and time of the point.
54			* @param float\|null $elevation
55			* @param array $extensions
56			*/
57			private function __construct(
58			?float $latitude,
59			?float $longitude,
60			\DateTimeImmutable $dateTime,
61			?float $elevation,
62			array $extensions = []
63			) {
64			$this->latitude = $latitude;
65			$this->longitude = $longitude;
66			$this->dateTime = $dateTime;
67			$this->elevation = $elevation;
68
69			foreach ($extensions as $extension) {
70			$this->addExtension($extension);
71			}
72			}
73
74			/**
75			* Add an extension to the workout.
76			*
77			* @param ExtensionInterface $extension The extension to add.
78			*/
79			private function addExtension(ExtensionInterface $extension)
80			{
81			$this->extensions[$extension::ID()] = $extension;
82			}
83
84			/**
85			* @param float\|null $latitude
86			* @param float\|null $longitude
87			* @param \DateTimeImmutable $dateTime
88			* @param float\|null $elevation
89			* @param array $extensions
90			* @return TrackPoint
91			*/
92			public static function with(
93			?float $latitude,
94			?float $longitude,
95			\DateTimeImmutable $dateTime,
96			?float $elevation = null,
97			array $extensions = []
98			): TrackPoint {
99			Assertion::greaterOrEqualThan($latitude, -180);
100			Assertion::greaterOrEqualThan($longitude, -180);
101			Assertion::lessOrEqualThan($latitude, 180);
102			Assertion::lessOrEqualThan($longitude, 180);
103			Assertion::allIsInstanceOf($extensions, ExtensionInterface::class);
104
105			return new static($latitude, $longitude, $dateTime, $elevation, $extensions);
106			}
107
108			/**
109			* Get the elevation.
110			*
111			* @return float
112			*/
113			public function elevation(): float
114			{
115			return $this->elevation;
116			}
117
118			/**
119			* Get the extensions.
120			*
121			* @return ExtensionInterface[]
122			*/
123			public function extensions(): array
124			{
125			return array_values($this->extensions);
126			}
127
128
129			/**
130			* Check if an extension is present.
131			*
132			* @param string $idExtension The ID of the extension.
133			* @return boolean
134			*/
135			public function hasExtension(string $idExtension): bool
136			{
137			return array_key_exists($idExtension, $this->extensions);
138			}
139
140			/**
141			* Get an extension by ID.
142			*
143			* @param string $idExtension The ID of the extension.
144			* @return ExtensionInterface
145			* @throws \OutOfBoundsException If the extension is not found.
146			*/
147			public function extension($idExtension): ExtensionInterface
148			{
149			if ($this->hasExtension($idExtension) !== true) {
150			throw new \OutOfBoundsException(sprintf('Extension "%s" not found.', $idExtension));
151			}
152
153			return $this->extensions[$idExtension];
154			}
155
156			/**
157			* Get the latitude.
158			*
159			* @return float
160			*/
161			public function latitude(): ?float
162			{
163			return $this->latitude;
164			}
165
166			/**
167			* Get the longitude.
168			*
169			* @return float
170			*/
171			public function longitude(): ?float
172			{
173			return $this->longitude;
174			}
175
176			/**
177			* Get the date time of the point.
178			*
179			* @return \DateTimeImmutable
180			*/
181			public function dateTime(): \DateTimeImmutable
182			{
183			return $this->dateTime;
184			}
185
186			/**
187			* Get the distance between this point and another point in meters.
188			*
189			* @param TrackPoint $trackPoint The other point.
190			* @return float The distance in meters.
191			*/
192			public function distanceFromPoint(TrackPoint $trackPoint): float
193			{
194			$earthRadius = 6371000;
195
196			$latFrom = deg2rad($this->latitude());
197			$lonFrom = deg2rad($this->longitude());
198			$latTo = deg2rad($trackPoint->latitude());
199			$lonTo = deg2rad($trackPoint->longitude());
200
201			$latDelta = $latTo - $latFrom;
202			$lonDelta = $lonTo - $lonFrom;
203
204			$angle = 2 * asin(
205			sqrt(
206			pow(sin($latDelta / 2), 2) +
207			cos($latFrom) * cos($latTo) * pow(sin($lonDelta / 2), 2)
208			)
209			);
210
211			return $angle * $earthRadius;
212			}
213
214			/**
215			* Get the speed between this point and another point in km/h.
216			*
217			* @param TrackPoint $trackPoint The other point.
218			* @return float
219			*/
220			public function speed(TrackPoint $trackPoint): float
221			{
222			$start = $this->dateTime();
223			$end = $trackPoint->dateTime();
224			$dateDiff = $start->diff($end);
225			$secondsDifference = ($dateDiff->days * 86400) + ($dateDiff->h * 3600) + ($dateDiff->i * 60) + $dateDiff->s;
226
227			if ($secondsDifference === 0) {
228			return 0.0;
229			}
230
231			$distance = $this->distanceFromPoint($trackPoint);
232
233			return ($distance / $secondsDifference) * 3.6;
234			}
235			}
236

dragosprotung / stc-core

TrackPoint::with() A last analyzed 2016-12-14 13:27 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TrackPoint::with() A
last analyzed 2016-12-14 13:27 UTC