PHPCoord\CoordinateOperation\AutoConversion

Complexity

Total Complexity

63

Size/Duplication

Total Lines	301
Duplicated Lines	0 %

Test Coverage

Coverage

93.29%

Importance

Changes	8
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
C	validatePath()	0	52	13
A	getPointForBoundaryCheck()	0	33	6
A	buildSupportedTransformationsByCRSPair()	0	11	6
B	findOperationPath()	0	33	8
A	buildIndirectTransformationPathsToCRS()	0	24	4
A	buildSupportedTransformationsByCRS()	0	9	6
A	buildDirectTransformationPathsToCRS()	0	18	3
A	convert()	0	19	6
A	DFS()	0	18	5
A	expandSimplePaths()	0	27	6

<?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 class_exists;
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\GeocentricPoint;
use PHPCoord\GeographicPoint;
use PHPCoord\Geometry\BoundingArea;
use PHPCoord\Point;
use PHPCoord\ProjectedPoint;
use PHPCoord\UnitOfMeasure\Time\Year;
use function strpos;
use function usort;

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

    private static array $directTransformationPathCache = [];

    private static array $indirectTransformationPathCache = [];

    private static array $transformationsByCRS = [];

    private static array $transformationsByCRSPair = [];

    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($this->getCRS(), $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 $source, CoordinateReferenceSystem $target, bool $ignoreBoundaryRestrictions): array
    {
        self::buildSupportedTransformationsByCRS();
        self::buildSupportedTransformationsByCRSPair();
        $boundaryCheckPoint = $ignoreBoundaryRestrictions ? null : $this->getPointForBoundaryCheck();

        // Try simple direct match before doing anything more complex!
        $candidatePaths = $this->buildDirectTransformationPathsToCRS($source, $target);

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

        foreach ($candidatePaths as $candidatePath) {
            if ($this->validatePath($candidatePath['path'], $boundaryCheckPoint)) {
                return $candidatePath['path'];
            }
        }

        // Otherwise, recursively calculate permutations of intermediate CRSs
        $candidatePaths = $this->buildIndirectTransformationPathsToCRS($source, $target);

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

        foreach ($candidatePaths as $candidatePath) {
            if ($this->validatePath($candidatePath['path'], $boundaryCheckPoint)) {
                return $candidatePath['path'];
            }
        }

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

    protected function validatePath(array $candidatePath, ?GeographicValue $boundaryCheckPoint): bool
    {
        foreach ($candidatePath as $pathStep) {
            $operation = CoordinateOperations::getOperationData($pathStep['operation']);
            if ($boundaryCheckPoint) {
                //filter out operations that only operate outside this point
                $polygon = BoundingArea::createFromExtentCodes($operation['extent_code']);
                if (!$polygon->containsPoint($boundaryCheckPoint)) {
                    return false;
                }
            }

            $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)) {
                    return false;
                }

                $params = CoordinateOperationParams::getParamData($pathStep['operation']);

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

                //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)) {
                    $pointEpoch = Year::fromDateTime($this->getCoordinateEpoch());
                    if (!(abs($pointEpoch->getValue() - $params['Transformation reference epoch']['value']) <= 0.001)) {
                        return false;
                    }
                }

                //filter out operations that require a grid file that we don't have
                foreach ($params as $param) {
                    if (isset($param['fileProvider']) && !class_exists($param['fileProvider'])) {
                        return false;
                    }
                }
            }
        }

        return true;
    }

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

            // Expand each CRS->CRS permutation with the various ways of achieving that (can be lots :/)
            $fullPaths = $this->expandSimplePaths($simplePaths, $source->getSRID(), $target->getSRID());

            $paths = [];
            foreach ($fullPaths as $fullPath) {
                $paths[] = ['path' => $fullPath, 'accuracy' => array_sum(array_column($fullPath, 'accuracy'))];
            }

            self::$directTransformationPathCache[$cacheKey] = $paths;
        }

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

    /**
     * Build the set of possible indirect paths that lead from the current CRS to the target CRS.
     */
    protected function buildIndirectTransformationPathsToCRS(CoordinateReferenceSystem $source, CoordinateReferenceSystem $target): array
    {
        $cacheKey = $source->getSRID() . '|' . $target->getSRID();
        if (!isset(self::$indirectTransformationPathCache[$cacheKey])) {
            $simplePaths = [];
            $visited = [];
            foreach (CoordinateReferenceSystem::getSupportedSRIDs() as $crs => $name) {
                $visited[$crs] = false;
            }
            $currentPath = [];
            $this->DFS($source->getSRID(), $target->getSRID(), $visited, $currentPath, $simplePaths);

            // Then expand each CRS->CRS permutation with the various ways of achieving that (can be lots :/)
            $fullPaths = $this->expandSimplePaths($simplePaths, $source->getSRID(), $target->getSRID());

            $paths = [];
            foreach ($fullPaths as $fullPath) {
                $paths[] = ['path' => $fullPath, 'accuracy' => array_sum(array_column($fullPath, 'accuracy'))];
            }

            self::$indirectTransformationPathCache[$cacheKey] = $paths;
        }

        return self::$indirectTransformationPathCache[$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 (static::$transformationsByCRS[$u] as $nextU) {

Since $transformationsByCRS is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $transformationsByCRS to at least protected.

                    if (!$visited[$nextU]) {
                        $this->DFS($nextU, $v, $visited, $currentPath, $simplePaths);
                    }
                }
            }
        }

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

    protected function expandSimplePaths(array $simplePaths, string $fromSRID, string $toSRID): array
    {
        $fullPaths = [];
        foreach ($simplePaths as $simplePath) {
            $transformationsToMakePath = [[]];
            $from = array_shift($simplePath);
            assert($from === $fromSRID);
            do {
                $to = array_shift($simplePath);
                $wipTransformationsInPath = [];
                foreach (static::$transformationsByCRSPair[$from . '|' . $to] ?? [] as $transformation) {

Since $transformationsByCRSPair is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $transformationsByCRSPair to at least protected.

                    foreach ($transformationsToMakePath as $transformationToMakePath) {
                        $wipTransformationsInPath[] = array_merge($transformationToMakePath, [$transformation]);
                    }
                }

                $transformationsToMakePath = $wipTransformationsInPath;
                $from = $to;
            } while (count($simplePath) > 0);
            assert($to === $toSRID);

            foreach ($transformationsToMakePath as $transformationToMakePath) {
                $fullPaths[] = $transformationToMakePath;
            }
        }

        return $fullPaths;
    }

    /**
     * Boundary polygons are defined as WGS84, so theoretically all that needs to happen is
     * to conversion to WGS84 by calling ->convert(). However, that leads quickly to either circularity
     * when a conversion is possible, or an exception because not every CRS has a WGS84 transformation
     * available to it even when chaining.
     */
    protected function getPointForBoundaryCheck(): ?GeographicValue
    {
        if ($this instanceof CompoundPoint) {
            $point = $this->getHorizontalPoint();
        } else {
            $point = $this;
        }

        try {
            // try converting to WGS84 if possible...
            return $point->convert(Geographic2D::fromSRID(Geographic2D::EPSG_WGS_84), true)->asGeographicValue();

The method asGeographicValue() does not exist on PHPCoord\Point. It seems like you code against a sub-type of PHPCoord\Point such as PHPCoord\GeographicPoint or PHPCoord\GeocentricPoint.

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?

        } catch (UnknownConversionException $e) {
            /*
             * If Projected then either the point is inside the boundary by definition
             * or the user is deliberately exceeding the safe zone so safe to make a no-op either way.
             */
            if ($point instanceof ProjectedPoint) {
                return null;
            }

            /*
             * Otherwise, compensate for non-Greenwich Prime Meridian, but otherwise assume that coordinates
             * are interchangeable between the actual CRS and WGS84. Boundaries are only defined to the nearest
             * ≈1km so the error bound should be acceptable within the area of interest
             */
            if ($point instanceof GeographicPoint) {
                return new GeographicValue($point->getLatitude(), $point->getLongitude()->subtract($point->getCRS()->getDatum()->getPrimeMeridian()->getGreenwichLongitude()), null, $point->getCRS()->getDatum());
            }

            if ($point instanceof GeocentricPoint) {
                $asGeographic = $point->asGeographicValue();

                return new GeographicValue($asGeographic->getLatitude(), $asGeographic->getLongitude()->subtract($asGeographic->getDatum()->getPrimeMeridian()->getGreenwichLongitude()), null, $asGeographic->getDatum());
            }
        }
    }

    protected static function buildSupportedTransformationsByCRS(): void
    {
        if (!static::$transformationsByCRS) {

The expression static::transformationsByCRS of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $transformationsByCRS is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $transformationsByCRS to at least protected.

            foreach (CRSTransformations::getSupportedTransformations() as $transformation) {

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

                if (!isset(static::$transformationsByCRS[$transformation['source_crs']][$transformation['target_crs']])) {
                    static::$transformationsByCRS[$transformation['source_crs']][$transformation['target_crs']] = $transformation['target_crs'];
                }
                if ($transformation['reversible'] && !isset(static::$transformationsByCRS[$transformation['target_crs']][$transformation['source_crs']])) {
                    static::$transformationsByCRS[$transformation['target_crs']][$transformation['source_crs']] = $transformation['source_crs'];
                }
            }
        }
    }

    protected static function buildSupportedTransformationsByCRSPair(): void
    {
        if (!static::$transformationsByCRSPair) {

The expression static::transformationsByCRSPair of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $transformationsByCRSPair is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $transformationsByCRSPair to at least protected.

            foreach (CRSTransformations::getSupportedTransformations() as $key => $transformation) {
                if (!isset(static::$transformationsByCRSPair[$transformation['source_crs'] . '|' . $transformation['target_crs']][$key])) {
                    static::$transformationsByCRSPair[$transformation['source_crs'] . '|' . $transformation['target_crs']][$key] = $transformation;
                    static::$transformationsByCRSPair[$transformation['source_crs'] . '|' . $transformation['target_crs']][$key]['in_reverse'] = false;
                }
                if ($transformation['reversible'] && !isset(static::$transformationsByCRSPair[$transformation['target_crs'] . '|' . $transformation['source_crs']][$key])) {
                    static::$transformationsByCRSPair[$transformation['target_crs'] . '|' . $transformation['source_crs']][$key] = $transformation;
                    static::$transformationsByCRSPair[$transformation['target_crs'] . '|' . $transformation['source_crs']][$key]['in_reverse'] = true;
                }
            }
        }
    }

    abstract public function getCRS(): CoordinateReferenceSystem;

    abstract public function getCoordinateEpoch(): ?DateTimeImmutable;

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