dvdoug /
PHPCoord
| Total Complexity | 68 |
| Total Lines | 338 |
| Duplicated Lines | 0 % |
| Coverage | 93.94% |
| Changes | 19 | ||
| Bugs | 0 | Features | 0 |
Complex classes like AutoConversion often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use AutoConversion, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 49 | trait AutoConversion |
||
| 50 | { |
||
| 51 | private int $maxChainDepth = 6; // if traits could have constants... |
||
| 52 | |||
| 53 | /** |
||
| 54 | * @var array<string, array<int, array{path: array<int, array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}>, accuracy: float}>> |
||
| 55 | */ |
||
| 56 | private static array $completePathCache = []; |
||
| 57 | |||
| 58 | /** |
||
| 59 | * @return ($to is Compound ? CompoundPoint : ($to is Geocentric ? GeocentricPoint : ($to is Geographic ? GeographicPoint : ($to is Projected ? ProjectedPoint : ($to is Vertical ? VerticalPoint: Point))))) |
||
|
Documentation
Bug
introduced
by
|
|||
| 60 | 553 | */ |
|
| 61 | public function convert(Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $to, bool $ignoreBoundaryRestrictions = false): Point |
||
| 62 | 553 | { |
|
| 63 | 279 | if ($this->getCRS() == $to) { |
|
| 64 | return $this; |
||
| 65 | } |
||
| 66 | 328 | ||
| 67 | 328 | $point = $this; |
|
| 68 | $path = $this->findOperationPath($this->getCRS(), $to, $ignoreBoundaryRestrictions); |
||
| 69 | 292 | ||
| 70 | 292 | foreach ($path as $step) { |
|
| 71 | 292 | $target = CoordinateReferenceSystem::fromSRID($step['in_reverse'] ? $step['source_crs'] : $step['target_crs']); |
|
| 72 | $point = $point->performOperation($step['operation'], $target, $step['in_reverse']); |
||
| 73 | } |
||
| 74 | 292 | ||
| 75 | return $point; |
||
| 76 | } |
||
| 77 | |||
| 78 | /** |
||
| 79 | * Calculates if the point as constructed actually lies within the bounding box of the CRS. |
||
| 80 | 9 | */ |
|
| 81 | public function isWithinCRSBoundingArea(): bool |
||
| 82 | 9 | { |
|
| 83 | $pointAsWGS84 = $this->getPointForBoundaryCheck(); // some obscure CRSs might not be able to convert |
||
| 84 | 9 | ||
| 85 | return !$pointAsWGS84 instanceof GeographicValue || $this->crs->getBoundingArea()->containsPoint($pointAsWGS84); |
||
| 86 | } |
||
| 87 | |||
| 88 | /** |
||
| 89 | * @return array<int, array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}> |
||
| 90 | 328 | */ |
|
| 91 | protected function findOperationPath(Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $source, Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $target, bool $ignoreBoundaryRestrictions): array |
||
| 92 | 328 | { |
|
| 93 | $boundaryCheckPoint = $ignoreBoundaryRestrictions ? null : $this->getPointForBoundaryCheck(); |
||
| 94 | |||
| 95 | 328 | // Iteratively calculate permutations of intermediate CRSs |
|
| 96 | 328 | $candidatePaths = $this->buildTransformationPathsToCRS($source, $target); |
|
| 97 | usort($candidatePaths, static fn (array $a, array $b) => $a['accuracy'] <=> $b['accuracy'] ?: count($a['path']) <=> count($b['path'])); |
||
| 98 | 328 | ||
| 99 | 310 | foreach ($candidatePaths as $candidatePath) { |
|
| 100 | 292 | if ($this->validatePath($candidatePath['path'], $target, $boundaryCheckPoint)) { |
|
| 101 | return $candidatePath['path']; |
||
| 102 | } |
||
| 103 | } |
||
| 104 | 72 | ||
| 105 | throw new UnknownConversionException('Unable to perform conversion, please file a bug if you think this is incorrect'); |
||
| 106 | } |
||
| 107 | |||
| 108 | /** |
||
| 109 | * @param array<int, array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}> $candidatePath |
||
| 110 | 310 | */ |
|
| 111 | protected function validatePath(array $candidatePath, Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $target, ?GeographicValue $boundaryCheckPoint): bool |
||
| 172 | } |
||
| 173 | |||
| 174 | /** |
||
| 175 | * Build the set of possible paths that lead from the current CRS to the target CRS. |
||
| 176 | * @return array<int, array{path: array<int, array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}>, accuracy: float}> |
||
| 177 | 328 | */ |
|
| 178 | protected function buildTransformationPathsToCRS(Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $source, Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $target): array |
||
| 179 | 328 | { |
|
| 180 | 328 | $iterations = 0; |
|
| 181 | 328 | $sourceSRID = $source->getSRID(); |
|
| 182 | 328 | $targetSRID = $target->getSRID(); |
|
| 183 | 328 | $previousSimplePaths = [[$sourceSRID]]; |
|
| 184 | $cacheKey = $sourceSRID . '|' . $targetSRID; |
||
| 185 | 328 | ||
| 186 | 274 | if (!isset(self::$completePathCache[$cacheKey])) { |
|
| 187 | 274 | $transformationsByCRS = self::buildSupportedTransformationsByCRS($source, $target); |
|
| 188 | 274 | $transformationsByCRSPair = self::buildSupportedTransformationsByCRSPair($source, $target); |
|
| 189 | self::$completePathCache[$cacheKey] = []; |
||
| 190 | 274 | ||
| 191 | 274 | while ($iterations <= $this->maxChainDepth) { |
|
| 192 | 274 | $completePaths = []; |
|
| 193 | $simplePaths = []; |
||
| 194 | 274 | ||
| 195 | 274 | foreach ($previousSimplePaths as $simplePath) { |
|
| 196 | 274 | $current = $simplePath[$iterations]; |
|
| 197 | 247 | if ($current === $targetSRID) { |
|
| 198 | 274 | $completePaths[] = $simplePath; |
|
| 199 | 265 | } elseif (isset($transformationsByCRS[$current])) { |
|
| 200 | 265 | foreach ($transformationsByCRS[$current] as $next) { |
|
| 201 | 265 | if (!in_array($next, $simplePath, true)) { |
|
| 202 | $simplePaths[] = [...$simplePath, $next]; |
||
| 203 | } |
||
| 204 | } |
||
| 205 | } |
||
| 206 | } |
||
| 207 | |||
| 208 | 274 | // Then expand each CRS->CRS permutation with the various ways of achieving that (can be lots :/) |
|
| 209 | $fullPaths = $this->expandSimplePaths($transformationsByCRSPair, $completePaths, $sourceSRID, $targetSRID); |
||
| 210 | 274 | ||
| 211 | 274 | $paths = []; |
|
| 212 | 247 | foreach ($fullPaths as $fullPath) { |
|
| 213 | $paths[] = ['path' => $fullPath, 'accuracy' => array_sum(array_column($fullPath, 'accuracy'))]; |
||
| 214 | } |
||
| 215 | 274 | ||
| 216 | 274 | $previousSimplePaths = $simplePaths; |
|
| 217 | 274 | self::$completePathCache[$cacheKey] = [...self::$completePathCache[$cacheKey], ...$paths]; |
|
| 218 | ++$iterations; |
||
| 219 | } |
||
| 220 | } |
||
| 221 | 328 | ||
| 222 | return self::$completePathCache[$cacheKey]; |
||
| 223 | } |
||
| 224 | |||
| 225 | /** |
||
| 226 | * @param array<string, array<int, array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}>> $transformationsByCRSPair |
||
| 227 | * @param array<int, array<int, string>> $simplePaths |
||
| 228 | * @return array<int, array<int, array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}>> |
||
| 229 | 274 | */ |
|
| 230 | protected function expandSimplePaths(array $transformationsByCRSPair, array $simplePaths, string $fromSRID, string $toSRID): array |
||
| 231 | 274 | { |
|
| 232 | 274 | $fullPaths = []; |
|
| 233 | 247 | foreach ($simplePaths as $simplePath) { |
|
| 234 | 247 | $transformationsToMakePath = [[]]; |
|
| 235 | 247 | $from = array_shift($simplePath); |
|
| 236 | assert($from === $fromSRID); |
||
| 237 | 247 | do { |
|
| 238 | 247 | $to = array_shift($simplePath); |
|
| 239 | 247 | $wipTransformationsInPath = []; |
|
| 240 | 247 | foreach ($transformationsByCRSPair[$from . '|' . $to] ?? [] as $transformation) { |
|
| 241 | 247 | foreach ($transformationsToMakePath as $transformationToMakePath) { |
|
| 242 | $wipTransformationsInPath[] = [...$transformationToMakePath, $transformation]; |
||
| 243 | } |
||
| 244 | } |
||
| 245 | 247 | ||
| 246 | 247 | $transformationsToMakePath = $wipTransformationsInPath; |
|
| 247 | 247 | $from = $to; |
|
| 248 | 247 | } while (count($simplePath) > 0); |
|
| 249 | assert($to === $toSRID); |
||
| 250 | 247 | ||
| 251 | 247 | foreach ($transformationsToMakePath as $transformationToMakePath) { |
|
| 252 | $fullPaths[] = $transformationToMakePath; |
||
| 253 | } |
||
| 254 | } |
||
| 255 | 274 | ||
| 256 | return $fullPaths; |
||
| 257 | } |
||
| 258 | |||
| 259 | /** |
||
| 260 | * Boundary polygons are defined as WGS84, so theoretically all that needs to happen is |
||
| 261 | * to conversion to WGS84 by calling ->convert(). However, that leads quickly to either circularity |
||
| 262 | * when a conversion is possible, or an exception because not every CRS has a WGS84 transformation |
||
| 263 | * available to it even when chaining. |
||
| 264 | 310 | */ |
|
| 265 | protected function getPointForBoundaryCheck(): ?GeographicValue |
||
| 301 | } |
||
| 302 | } |
||
| 303 | |||
| 304 | /** |
||
| 305 | * @return array<string, array<string, string>> |
||
| 306 | 274 | */ |
|
| 307 | protected static function buildSupportedTransformationsByCRS(Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $source, Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $target): array |
||
| 308 | 274 | { |
|
| 309 | 274 | $regions = array_unique([$source->getBoundingArea()->getRegion(), $target->getBoundingArea()->getRegion(), RegionMap::REGION_GLOBAL]); |
|
| 310 | 274 | $relevantRegionData = CoordinateOperations::getCustomTransformations(); |
|
| 311 | 274 | foreach ($regions as $region) { |
|
| 312 | 274 | $regionData = match ($region) { |
|
| 313 | 211 | RegionMap::REGION_GLOBAL => CRSTransformationsGlobal::getSupportedTransformations(), |
|
| 314 | 211 | RegionMap::REGION_AFRICA => CRSTransformationsAfrica::getSupportedTransformations(), |
|
| 315 | 211 | RegionMap::REGION_ANTARCTIC => CRSTransformationsAntarctic::getSupportedTransformations(), |
|
| 316 | 211 | RegionMap::REGION_ARCTIC => CRSTransformationsArctic::getSupportedTransformations(), |
|
| 317 | 184 | RegionMap::REGION_ASIA => CRSTransformationsAsia::getSupportedTransformations(), |
|
| 318 | 49 | RegionMap::REGION_EUROPE => CRSTransformationsEurope::getSupportedTransformations(), |
|
| 319 | 10 | RegionMap::REGION_NORTHAMERICA => CRSTransformationsNorthAmerica::getSupportedTransformations(), |
|
| 320 | RegionMap::REGION_OCEANIA => CRSTransformationsOceania::getSupportedTransformations(), |
||
| 321 | RegionMap::REGION_SOUTHAMERICA => CRSTransformationsSouthAmerica::getSupportedTransformations(), |
||
| 322 | 274 | default => throw new UnknownConversionException('Unknown region: ' . $region), |
|
| 323 | 274 | }; |
|
| 324 | $relevantRegionData = [...$relevantRegionData, ...$regionData]; |
||
| 325 | } |
||
| 326 | 274 | ||
| 327 | 274 | $transformationsByCRS = []; |
|
| 328 | 274 | foreach ($relevantRegionData as $transformation) { |
|
| 329 | 274 | $operation = CoordinateOperations::getOperationData($transformation['operation']); |
|
| 330 | $method = CoordinateOperationMethods::getMethodData($operation['method']); |
||
| 331 | 274 | ||
| 332 | 274 | if (!isset($transformationsByCRS[$transformation['source_crs']][$transformation['target_crs']])) { |
|
| 333 | $transformationsByCRS[$transformation['source_crs']][$transformation['target_crs']] = $transformation['target_crs']; |
||
| 334 | 274 | } |
|
| 335 | 274 | if ($method['reversible'] && !isset($transformationsByCRS[$transformation['target_crs']][$transformation['source_crs']])) { |
|
| 336 | $transformationsByCRS[$transformation['target_crs']][$transformation['source_crs']] = $transformation['source_crs']; |
||
| 337 | } |
||
| 338 | } |
||
| 339 | 274 | ||
| 340 | return $transformationsByCRS; |
||
| 341 | } |
||
| 342 | |||
| 343 | /** |
||
| 344 | * @return array<string, array<array{operation: string, name: string, source_crs: string, target_crs: string, accuracy: float, in_reverse: bool}>> |
||
| 345 | 274 | */ |
|
| 346 | protected static function buildSupportedTransformationsByCRSPair(Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $source, Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $target): array |
||
| 380 | } |
||
| 381 | |||
| 382 | abstract public function getCRS(): CoordinateReferenceSystem; |
||
| 383 | |||
| 384 | abstract public function getCoordinateEpoch(): ?DateTimeImmutable; |
||
| 385 | |||
| 386 | abstract protected function performOperation(string $srid, Compound|Geocentric|Geographic2D|Geographic3D|Projected|Vertical $to, bool $inReverse): Point; |
||
| 387 | } |
||
| 388 |
Loading history...