KDTree\ValueObject\Partition

Complexity

Total Complexity

26

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getDMax()	0	7	2
A	equals()	0	16	5
A	distanceToPoint()	0	14	4
A	getDimensions()	0	3	1
A	getDMin()	0	7	2
A	__construct()	0	20	4
A	contains()	0	9	4
A	intersects()	0	12	4

<?php

namespace KDTree\ValueObject;

use KDTree\Exceptions\{InvalidPointsCount, UnknownDimension};
use KDTree\Interfaces\{PartitionInterface, PointInterface, PointsListInterface};

/**
 * Class Partition
 *
 * @package KDTree\ValueObject
 */
final class Partition implements PartitionInterface
{
    /**
     * @var PointsListInterface<PointInterface>
     */
    private $pointsList;

    /**
     * @var float[]
     */
    private $dMax;

    /**
     * @var float[]
     */
    private $dMin;

    /**
     * @param PointsListInterface<PointInterface> $pointsList
     *
     * @throws InvalidPointsCount
     */
    public function __construct(PointsListInterface $pointsList)
    {
        $pointCount = count($pointsList);
        if ($pointCount !== 2 ** $pointsList->getDimensions()) {
            throw new InvalidPointsCount();
        }

        $this->pointsList = $pointsList;

        $dMax = array_fill(0, $pointsList->getDimensions(), PHP_INT_MIN);
        $dMin = array_fill(0, $pointsList->getDimensions(), PHP_INT_MAX);
        foreach ($pointsList as $point) {
            foreach ($point->getAxises() as $d => $axis) {
                $dMax[$d] = max($dMax[$d], $axis);
                $dMin[$d] = min($dMin[$d], $axis);
            }
        }

        $this->dMax = $dMax;
        $this->dMin = $dMin;
    }

    /**
     * @param PointInterface $point
     *
     * @return bool
     * @throws UnknownDimension
     */
    public function contains(PointInterface $point): bool
    {
        foreach ($point->getAxises() as $dimension => $axis) {
            if ($axis < $this->getDMin($dimension) || $axis > $this->getDMax($dimension)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param int $dimension
     *
     * @return float
     * @throws UnknownDimension
     */
    public function getDMin(int $dimension): float
    {
        if (isset($this->dMin[$dimension])) {
            return $this->dMin[$dimension];
        }

        throw new UnknownDimension();
    }

    /**
     * @param int $dimension
     *
     * @return float
     * @throws UnknownDimension
     */
    public function getDMax(int $dimension): float
    {
        if (isset($this->dMax[$dimension])) {
            return $this->dMax[$dimension];
        }

        throw new UnknownDimension();
    }

    /**
     * @param PartitionInterface $partition
     *
     * @return bool
     * @throws UnknownDimension
     */
    public function intersects(PartitionInterface $partition): bool
    {
        foreach (range(0, $this->getDimensions() - 1) as $dimension) {
            $isIntersects = $this->getDMax($dimension) >= $partition->getDMin($dimension)
                && $partition->getDMax($dimension) >= $this->getDMin($dimension);

            if (false === $isIntersects) {
                return false;
            }
        }

        return true;
    }

    /**
     * @inheritDoc
     */
    public function getDimensions(): int
    {
        return $this->pointsList->getDimensions();
    }

    /**
     * @param PointInterface $point
     *
     * @return float
     * @throws UnknownDimension
     */
    public function distanceToPoint(PointInterface $point): float
    {
        $result = 0.0;
        foreach ($point->getAxises() as $dimension => $axis) {
            $len = 0.0;
            if ($axis < $this->getDMin($dimension)) {
                $len = $axis - $this->getDMin($dimension);
            } elseif ($axis > $this->getDMax($dimension)) {
                $len = $axis - $this->getDMax($dimension);
            }
            $result += $len ** 2;
        }

        return sqrt($result);
    }

    /**
     * @param PartitionInterface $partition
     *
     * @return bool
     * @throws UnknownDimension
     */
    public function equals(PartitionInterface $partition): bool
    {
        if ($partition->getDimensions() !== $this->getDimensions()) {
            return false;
        }

        foreach (range(0, $this->getDimensions() - 1) as $dimension) {
            if (
                $this->getDMin($dimension) !== $partition->getDMin($dimension)
                || $this->getDMax($dimension) !== $partition->getDMax($dimension)
            ) {
                return false;
            }
        }

        return true;
    }
}