PHPCoord\CoordinateOperation\AutoConversion

Complexity

Total Complexity

36

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Test Coverage

Coverage

98.8%

Importance

Changes	4
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	findOperationPath()	0	56	14
B	buildTransformationPathsToCRS()	0	49	9
A	convert()	0	19	6
A	asWGS84()	0	9	2
A	DFS()	0	18	5

<?php
/**
 * PHPCoord.
 *
 * @author Doug Wright
 */
declare(strict_types=1);

namespace PHPCoord\CoordinateOperation;

use function abs;
use function array_column;
use function array_merge;
use function array_pop;
use function array_shift;
use function array_sum;
use function assert;
use function count;
use DateTimeImmutable;
use function in_array;
use PHPCoord\CompoundPoint;
use PHPCoord\CoordinateReferenceSystem\CoordinateReferenceSystem;
use PHPCoord\CoordinateReferenceSystem\Geographic2D;
use PHPCoord\Exception\UnknownConversionException;
use PHPCoord\GeographicPoint;
use PHPCoord\Geometry\GeographicPolygon;
use PHPCoord\Point;
use PHPCoord\UnitOfMeasure\Time\Year;
use function strpos;
use function usort;

trait AutoConversion
{
    private int $maxChainDepth = 4; // if traits could have constants...

    private static array $pathCache = [];

    public function convert(CoordinateReferenceSystem $to, bool $ignoreBoundaryRestrictions = false): Point
    {
        if ($this->getCRS() == $to) {
            return $this;
        }

        if (strpos($this->getCRS()->getSRID(), CoordinateReferenceSystem::CRS_SRID_PREFIX_EPSG) !== 0 || strpos($to->getSRID(), CoordinateReferenceSystem::CRS_SRID_PREFIX_EPSG) !== 0) {
            throw new UnknownConversionException('Automatic conversions are only supported for EPSG CRSs');
        }

        $point = $this;
        $path = $this->findOperationPath($to, $ignoreBoundaryRestrictions);

        foreach ($path as $step) {
            $target = CoordinateReferenceSystem::fromSRID($step['in_reverse'] ? $step['source_crs'] : $step['target_crs']);
            $point = $point->performOperation($step['operation'], $target, $step['in_reverse']);
        }

        return $point;
    }

    protected function findOperationPath(CoordinateReferenceSystem $to, bool $ignoreBoundaryRestrictions): array
    {
        $candidatePaths = $this->buildTransformationPathsToCRS($to);

        usort($candidatePaths, static function (array $a, array $b) {
            return count($a['path']) <=> count($b['path']) ?: $a['accuracy'] <=> $b['accuracy'];
        });

        $asWGS84Value = $ignoreBoundaryRestrictions ? null : $this->asWGS84()->asGeographicValue();

        foreach ($candidatePaths as $candidatePath) {
            $ok = true;

            foreach ($candidatePath['path'] as $pathStep) {
                $operation = CoordinateOperations::getOperationData($pathStep['operation']);

The type PHPCoord\CoordinateOperation\CoordinateOperations was not found. Maybe you did not declare it correctly or list all dependencies?

                if (!$ignoreBoundaryRestrictions) {
                    //filter out operations that only operate outside this point
                    $polygon = GeographicPolygon::createFromArray($operation['bounding_box'], $operation['bounding_box_crosses_antimeridian']);
                    $ok = $ok && $polygon->containsPoint($asWGS84Value);

It seems like $asWGS84Value can also be of type null; however, parameter $point of PHPCoord\Geometry\GeographicPolygon::containsPoint() does only seem to accept PHPCoord\CoordinateOperation\GeographicValue, maybe add an additional type check?

                }

                $operations = static::resolveConcatenatedOperations($pathStep['operation'], false);

                foreach ($operations as $operation) {
                    //filter out operations that require an epoch if we don't have one
                    if (!$this->getCoordinateEpoch() && in_array($operation['method'], [
                            CoordinateOperationMethods::EPSG_TIME_DEPENDENT_COORDINATE_FRAME_ROTATION_GEOCEN,
                            CoordinateOperationMethods::EPSG_TIME_DEPENDENT_COORDINATE_FRAME_ROTATION_GEOG2D,
                            CoordinateOperationMethods::EPSG_TIME_DEPENDENT_COORDINATE_FRAME_ROTATION_GEOG3D,
                            CoordinateOperationMethods::EPSG_TIME_DEPENDENT_POSITION_VECTOR_TFM_GEOCENTRIC,
                            CoordinateOperationMethods::EPSG_TIME_DEPENDENT_POSITION_VECTOR_TFM_GEOG2D,
                            CoordinateOperationMethods::EPSG_TIME_DEPENDENT_POSITION_VECTOR_TFM_GEOG3D,
                            CoordinateOperationMethods::EPSG_TIME_SPECIFIC_COORDINATE_FRAME_ROTATION_GEOCEN,
                            CoordinateOperationMethods::EPSG_TIME_SPECIFIC_POSITION_VECTOR_TRANSFORM_GEOCEN,
                        ], true)) {
                        $ok = false;
                    }

                    //filter out operations that require a specific epoch
                    if ($this->getCoordinateEpoch() && in_array($operation['method'], [
                            CoordinateOperationMethods::EPSG_TIME_SPECIFIC_COORDINATE_FRAME_ROTATION_GEOCEN,
                            CoordinateOperationMethods::EPSG_TIME_SPECIFIC_POSITION_VECTOR_TRANSFORM_GEOCEN,
                        ], true)) {
                        $params = CoordinateOperationParams::getParamData($pathStep['operation']);

The type PHPCoord\CoordinateOperation\CoordinateOperationParams was not found. Maybe you did not declare it correctly or list all dependencies?

                        $pointEpoch = Year::fromDateTime($this->getCoordinateEpoch());
                        $ok = $ok && (abs($pointEpoch->getValue() - $params['Transformation reference epoch']['value']) <= 0.001);
                    }
                }
            }

            if ($ok) {
                return $candidatePath['path'];
            }
        }

        throw new UnknownConversionException('Unable to perform conversion, please file a bug if you think this is incorrect');
    }

    /**
     * Build the set of *all* possible paths that lead from the current CRS to the target CRS.
     */
    protected function buildTransformationPathsToCRS(CoordinateReferenceSystem $target): array
    {
        $cacheKey = $this->getCRS()->getSRID() . '|' . $target->getSRID();
        if (!isset(self::$pathCache[$cacheKey])) {
            $simplePaths = [];

            // Try a simple direct match before doing anything more complex!
            if (CRSTransformations::getSupportedTransformationsForCRSPair($this->getCRS()->getSRID(), $target->getSRID())) {
                $simplePaths[] = [$this->getCRS()->getSRID(), $target->getSRID()];
            } else { // Otherwise, recursively calculate permutations of intermediate CRSs
                $visited = [];
                foreach (CoordinateReferenceSystem::getSupportedSRIDs() as $crs => $name) {
                    $visited[$crs] = false;
                }
                $currentPath = [];
                $this->DFS($this->getCRS()->getSRID(), $target->getSRID(), $visited, $currentPath, $simplePaths);
            }

            // Then expand each CRS->CRS permutation with the various ways of achieving that (can be lots :/)
            $candidatePaths = [];
            foreach ($simplePaths as $simplePath) {
                $transformationsToMakePath = [[]];
                $from = array_shift($simplePath);
                assert($from === $this->getCRS()->getSRID());
                do {
                    $to = array_shift($simplePath);
                    $wipTransformationsInPath = [];
                    foreach (CRSTransformations::getSupportedTransformationsForCRSPair($from, $to) as $transformation) {
                        foreach ($transformationsToMakePath as $transformationToMakePath) {
                            $wipTransformationsInPath[] = array_merge($transformationToMakePath, [$transformation]);
                        }
                    }

                    $transformationsToMakePath = $wipTransformationsInPath;
                    $from = $to;
                } while (count($simplePath) > 0);
                assert($to === $target->getSRID());
                $candidatePaths = array_merge($candidatePaths, $transformationsToMakePath);
            }

            $candidates = [];
            foreach ($candidatePaths as $candidatePath) {
                $candidates[] = ['path' => $candidatePath, 'accuracy' => array_sum(array_column($candidatePath, 'accuracy'))];
            }

            self::$pathCache[$cacheKey] = $candidates;
        }

        return self::$pathCache[$cacheKey];
    }

    protected function DFS(string $u, string $v, array &$visited, array &$currentPath, array &$simplePaths): void
    {
        $currentPath[] = $u;
        if ($u === $v) {
            $simplePaths[] = $currentPath;
        } else {
            $visited[$u] = true;
            if (count($currentPath) <= $this->maxChainDepth) {
                foreach (CRSTransformations::getSupportedTransformationsForCRS($u) as $nextU) {
                    if (!$visited[$nextU]) {
                        $this->DFS($nextU, $v, $visited, $currentPath, $simplePaths);
                    }
                }
            }
        }

        array_pop($currentPath);
        $visited[$u] = false;
    }

    protected function asWGS84(): GeographicPoint
    {
        if ($this instanceof CompoundPoint) {
            $point = $this->getHorizontalPoint();
        } else {
            $point = $this;
        }

        return $point->convert(Geographic2D::fromSRID(Geographic2D::EPSG_WGS_84), true);

The method convert() does not exist on PHPCoord\Point. It seems like you code against a sub-type of said class. However, the method does not exist in PHPCoord\VerticalPoint. Are you sure you never get one of those?

    }

    abstract public function getCRS(): CoordinateReferenceSystem;

    abstract public function getCoordinateEpoch(): ?DateTimeImmutable;

    abstract protected function performOperation(string $srid, CoordinateReferenceSystem $to, bool $inReverse): Point;
}