AutoConversion::buildIndirectTransformationPathsToCRS() - Code Metrics - Inspection of "Rewrite path computation to not use recursion, Xde..." - dvdoug/PHPCoord - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( fc1d9d...4229b1 )

by Doug
created 2021-08-08 19:35 UTC
buildIndirectTransformationPathsToCRS() B

↳ Parent: AutoConversion
Complexity

Conditions	11
Paths	3
Size

Total Lines	51
Code Lines	29
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	31
CRAP Score	11
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	11
eloc	29
c	2
b	0
f	0
nc	3
nop	2
dl	0
loc	51
ccs	31
cts	31
cp	1
crap	11
rs	7.3166
How to fix Long Method Complexity

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

namespace PHPCoord\CoordinateOperation;

use function abs;
use function array_column;
use function array_filter;
use function array_merge;
use function array_shift;
use function array_sum;
use function assert;
use function class_exists;
use function count;
use DateTimeImmutable;
use function end;
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 $operationId => $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($operationId);
filter:
    dependency_paths: ["lib/*"]

                //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
    {
        $sourceSRID = $source->getSRID();
        $targetSRID = $target->getSRID();
        if (!isset(static::$transformationsByCRS[$sourceSRID])) {

            return [];
        }

        $cacheKey = $sourceSRID . '|' . $targetSRID;
        if (!isset(self::$indirectTransformationPathCache[$cacheKey])) {
            $visited = [];
            foreach (CoordinateReferenceSystem::getSupportedSRIDs() as $crs => $name) {
                $visited[$crs] = false;
            }

            $simplePaths = [[$sourceSRID]];

            $iterations = 0;
            while ($iterations < $this->maxChainDepth) {
                foreach ($simplePaths as $key => $simplePath) {
                    $current = end($simplePath);
                    $visited[$current] = true;
                    if ($current !== $targetSRID && isset(static::$transformationsByCRS[$current])) {
                        foreach (static::$transformationsByCRS[$current] as $next) {
                            if (!$visited[$next]) {
                                $simplePaths[] = array_merge($simplePath, [$next]);
                            }
                        }
                        unset($simplePaths[$key]);
                    }
                }
                ++$iterations;
            }

            // Filter out any incomplete chains didn't make it to the target
            $simplePaths = array_filter($simplePaths, static function (array $simplePath) use ($targetSRID) {
                return end($simplePath) === $targetSRID;
            });

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

            $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 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) {

                    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();
            return $point->convert(Geographic2D::fromSRID(Geographic2D::EPSG_WGS_84), true)->/** @scrutinizer ignore-call */ asGeographicValue();
        } 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) {

            foreach (CRSTransformations::getSupportedTransformations() as $transformation) {
filter:
    dependency_paths: ["lib/*"]
                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) {

            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;
}

dvdoug / PHPCoord

Push — master ( fc1d9d...4229b1 )

buildIndirectTransformationPathsToCRS() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
