Undemanding\Difference\ConnectedDifferences

Complexity

Total Complexity

32

Size/Duplication

Total Lines	219
Duplicated Lines	5.48 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
F	findBoundaries()	0	86	18
C	withJoinedBoundaries()	12	32	8
A	cloneWith()	0	7	1
A	adjacent()	0	14	1
A	intersect()	0	4	2
A	boundaries()	0	4	1

<?php

namespace Undemanding\Difference;

class ConnectedDifferences
{
    /**
     * @var array
     */
    private $bitmap;

    /**
     * @var int
     */
    private $width;

    /**
     * @var int
     */
    private $height;

    /**
     * @var array
     */
    private $boundaries = [];

    /**
     * @param Difference $difference
     */
    public function __construct(Difference $difference)
    {
        $this->bitmap = $difference->getBitmap();
        $this->width = $difference->getWidth();
        $this->height = $difference->getHeight();

        $this->boundaries = $this->findBoundaries();
    }

    /**
     * Find separate boundaries.
     *
     * @return array
     */
    private function findBoundaries()
    {
        $pixels = [];

        for ($y = 0; $y < $this->height; $y++) {
            for ($x = 0; $x < $this->width; $x++) {
                if ($this->bitmap[$y][$x] > 0) {
                    $pixels["{$x}:{$y}"] = [
                        "group" => null,
                        "x" => $x,
                        "y" => $y,
                    ];
                }
            }
        }

        $group = 1;
        $boundaries = [];

        foreach ($pixels as $i => $pixel) {
            $adjacent = $this->adjacent($pixel);

            if (!$pixel["group"]) {
                foreach ($adjacent as $key) {
                    if (isset($pixels[$key]) and $pixels[$key]["group"]) {

Using logical operators such as and instead of && is generally not recommended.

                        $pixel["group"] = $pixels[$key]["group"];
                    }
                }
            }

            if (!$pixel["group"]) {
                $pixel["group"] = $group++;
            }

            foreach ($adjacent as $key) {
                if (isset($pixels[$key])) {
                    $pixels[$key]["group"] = $pixel["group"];
                }
            }
        }

        $groups = array_values(array_unique(array_map(function($pixel) {
            return $pixel["group"];
        }, $pixels)));

        foreach ($groups as $group) {
            $filtered = array_filter($pixels, function($pixel) use ($group) {
                return $pixel["group"] === $group;
            });

            $ax = $this->width;
            $bx = 0;
            $ay = $this->height;
            $by = 0;

            foreach ($filtered as $pixel) {
                $x = $pixel["x"];
                $y = $pixel["y"];

                if ($x > $bx) {
                    $bx = $x;
                }

                if ($x < $ax) {
                    $ax = $x;
                }

                if ($y > $by) {
                    $by = $y;
                }

                if ($y < $ay) {
                    $ay = $y;
                }
            }

            array_push($boundaries, [
                "top" => $ay,
                "right" => $bx,
                "bottom" => $by,
                "left" => $ax,
            ]);
        }

        return $boundaries;
    }

    /**
     * @return ConnectedDifferences
     */
    public function withJoinedBoundaries()
    {
        $keep = [];

        foreach ($this->boundaries as $boundary) {
            foreach ($keep as $i => $kept) {
                if ($this->intersect($boundary, $kept)) {
                    if ($boundary["top"] < $kept["top"]) {

This code seems to be duplicated across your project.

                        $keep[$i]["top"] = $boundary["top"];
                    }

                    if ($boundary["right"] > $kept["right"]) {

This code seems to be duplicated across your project.

                        $keep[$i]["right"] = $boundary["right"];
                    }

                    if ($boundary["bottom"] > $kept["bottom"]) {

This code seems to be duplicated across your project.

                        $keep[$i]["bottom"] = $boundary["bottom"];
                    }

                    if ($boundary["left"] < $kept["left"]) {

This code seems to be duplicated across your project.

                        $keep[$i]["left"] = $boundary["left"];
                    }

                    continue 2;
                }
            }

            array_push($keep, $boundary);
        }

        return $this->cloneWith("boundaries", $keep);
    }

    /**
     * @param string $property
     * @param mixed $value
     *
     * @return ConnectedDifferences
     */
    private function cloneWith($property, $value)
    {
        $clone = clone $this;
        $clone->$property = $value;

        return $clone;
    }

    /**
     * Labels for adjacent pixels.
     *
     * @param array $pixel
     *
     * @return array
     */
    private function adjacent($pixel)
    {
        $adjacent = [
            ($pixel["x"] - 1) . ":" . ($pixel["y"] - 1),
            ($pixel["x"] - 1) . ":" . $pixel["y"],
            ($pixel["x"] - 1) . ":" . ($pixel["y"] + 1),
            $pixel["x"] . ":" . ($pixel["y"] - 1),
            $pixel["x"] . ":" . ($pixel["y"] + 1),
            ($pixel["x"] + 1) . ":" . ($pixel["y"] - 1),
            ($pixel["x"] + 1) . ":" . $pixel["y"],
            ($pixel["x"] + 1) . ":" . ($pixel["y"] + 1),
        ];
        return $adjacent;
    }

    /**
     * Tell if two boundaries overlap.
     *
     * @param array $p
     * @param array $q
     *
     * @return bool
     */
    private function intersect(array $p, array $q)
    {
        return max($p["left"], $q["left"]) <= min($p["right"], $q["right"]) and max($p["top"], $q["top"]) <= min($p["bottom"], $q["bottom"]);

Using logical operators such as and instead of && is generally not recommended.

    }

    /**
     * @return array
     */
    public function boundaries()
    {
        return $this->boundaries;
    }
}