letournel / path-finder

src/Converters/Grid/ASCIISyntax.php

Doc Comments +3 added lines

@@ -96,6 +96,9 @@
         return $syntax;
     }
     
+    /**
+     * @param string $charToFind
+     */
     public function findAndCreateNode($syntax, $charToFind)
     {
         for($x = 0; $x < count($syntax); $x++)

Spacing +24 added lines, -24 removed lines

@@ -20,9 +20,9 @@ 
     {
         $matrix = $this->convertToMatrix($syntax);
         
-        foreach($matrix as $x => $line)
+        foreach ($matrix as $x => $line)
         {
-            foreach($line as $y => $char)
+            foreach ($line as $y => $char)
             {
                 $matrix[$x][$y] = ($char !== self::WALL) ? 1 : 0;
             }
@@ -35,7 +35,7 @@ 
     {
         $matrix = array_filter(explode("\n", $syntax));
         
-        foreach($matrix as $key => $line)
+        foreach ($matrix as $key => $line)
         {
             $matrix[$key] = array_filter(str_split($line));
         }
@@ -48,9 +48,9 @@ 
         $syntax = '';
         
         $nodes = $grid->getNodes();
-        foreach($nodes as $line)
+        foreach ($nodes as $line)
         {
-            foreach($line as $node)
+            foreach ($line as $node)
             {
                 $syntax .= ($node->isWalkable() ? self::FREE : self::WALL);
             }
@@ -65,23 +65,23 @@ 
         $syntax = '';
         
         $nodes = $grid->getNodes();
-        foreach($nodes as $line)
+        foreach ($nodes as $line)
         {
-            foreach($line as $node)
+            foreach ($line as $node)
             {
-                if(! $node->isWalkable())
+                if (!$node->isWalkable())
                 {
                     $syntax .= self::WALL;
                 }
-                elseif($node->toString() == $path->getStartNode()->toString())
+                elseif ($node->toString() == $path->getStartNode()->toString())
                 {
                     $syntax .= self::IN;
                 }
-                elseif($node->toString() == $path->getEndNode()->toString())
+                elseif ($node->toString() == $path->getEndNode()->toString())
                 {
                     $syntax .= self::OUT;
                 }
-                elseif($path->contains($node))
+                elseif ($path->contains($node))
                 {
                     $syntax .= self::STEP;
                 }
@@ -98,11 +98,11 @@ 
     
     public function findAndCreateNode($syntax, $charToFind)
     {
-        for($x = 0; $x < count($syntax); $x++)
+        for ($x = 0; $x < count($syntax); $x++)
         {
-            for($y = 0; $y < count($syntax[$x]); $y++)
+            for ($y = 0; $y < count($syntax[$x]); $y++)
             {
-                if($syntax[$x][$y] === $charToFind)
+                if ($syntax[$x][$y] === $charToFind)
                 {
                     return new Node($x, $y);
                 }
@@ -113,11 +113,11 @@ 
     public function findAndCreateNodes($syntax, $charToFind)
     {
         $nodes = array();
-        for($x = 0; $x < count($syntax); $x++)
+        for ($x = 0; $x < count($syntax); $x++)
         {
-            for($y = 0; $y < count($syntax[$x]); $y++)
+            for ($y = 0; $y < count($syntax[$x]); $y++)
             {
-                if($syntax[$x][$y] === $charToFind)
+                if ($syntax[$x][$y] === $charToFind)
                 {
                     $nodes[] = new Node($x, $y);
                 }
@@ -131,32 +131,32 @@ 
     {
         $deltas = array(
             array(-1, -1), array(-1, +0), array(-1, +1),
-            array(+0, -1),                array(+0, +1),
+            array(+0, -1), array(+0, +1),
             array(+1, -1), array(+1, +0), array(+1, +1),
         );
         
         $node = $this->findAndCreateNode($matrix, self::IN);
         $target = $this->findAndCreateNode($matrix, self::OUT);
         $path = array($node);
-        while($node->getId() !== $target->getId())
+        while ($node->getId() !== $target->getId())
         {
             $newNode = null;
-            foreach($deltas as $delta)
+            foreach ($deltas as $delta)
             {
                 $x = $node->getX() + $delta[0];
                 $y = $node->getY() + $delta[1];
                 
-                if(! array_key_exists($x, $matrix))
+                if (!array_key_exists($x, $matrix))
                 {
                     continue;
                 }
                 
-                if(! array_key_exists($y, $matrix[$x]))
+                if (!array_key_exists($y, $matrix[$x]))
                 {
                     continue;
                 }
                 
-                if($matrix[$x][$y] === self::STEP || $matrix[$x][$y] === self::OUT)
+                if ($matrix[$x][$y] === self::STEP || $matrix[$x][$y] === self::OUT)
                 {
                     $matrix[$x][$y] = self::FREE;
                     $newNode = new Node($x, $y);
@@ -164,7 +164,7 @@ 
                 }
             }
             
-            if(! $newNode instanceof Node)
+            if (!$newNode instanceof Node)
             {
                 throw new \RuntimeException('Path is not continous in the grid');
             }

Braces +4 added lines, -8 removed lines

@@ -72,20 +72,16 @@
                 if(! $node->isWalkable())
                 {
                     $syntax .= self::WALL;
-                }
-                elseif($node->toString() == $path->getStartNode()->toString())
+                } elseif($node->toString() == $path->getStartNode()->toString())
                 {
                     $syntax .= self::IN;
-                }
-                elseif($node->toString() == $path->getEndNode()->toString())
+                } elseif($node->toString() == $path->getEndNode()->toString())
                 {
                     $syntax .= self::OUT;
-                }
-                elseif($path->contains($node))
+                } elseif($path->contains($node))
                 {
                     $syntax .= self::STEP;
-                }
-                else
+                } else
                 {
                     $syntax .= self::FREE;
                 }

src/Core/NodePath.php

Spacing +7 added lines, -7 removed lines

@@ -14,9 +14,9 @@ 
     {
         $this->path = array();
         $this->valid = true;
-        foreach($path as $node)
+        foreach ($path as $node)
         {
-            if($node instanceof Node)
+            if ($node instanceof Node)
             {
                 $this->path[$node->getId()] = $node;
             }
@@ -68,9 +68,9 @@ 
     {
         $length = 0;
         $prevNode = null;
-        foreach($this->path as $node)
+        foreach ($this->path as $node)
         {
-            if($prevNode === null)
+            if ($prevNode === null)
             {
                 $prevNode = $node;
                 continue;
@@ -85,9 +85,9 @@ 
     
     public function contains(Node $needleNode)
     {
-        foreach($this->path as $node)
+        foreach ($this->path as $node)
         {
-            if($node->toString() == $needleNode->toString())
+            if ($node->toString() == $needleNode->toString())
             {
                 return true;
             }
@@ -109,7 +109,7 @@ 
     public function toString()
     {
         $nodesString = array();
-        foreach($this->path as $node)
+        foreach ($this->path as $node)
         {
             $nodesString[] = $node->toString();
         }

src/Core/NodeGrid.php

Spacing +13 added lines, -13 removed lines

@@ -33,7 +33,7 @@ 
     private function computeWidth(array $matrix)
     {
         $width = 0;
-        foreach($matrix as $line)
+        foreach ($matrix as $line)
         {
             $width = max(count($line), $width);
         }
@@ -45,10 +45,10 @@ 
     {
         $nodes = array();
         
-        for($i = 0; $i < $this->height; $i++)
+        for ($i = 0; $i < $this->height; $i++)
         {
             $nodes[$i] = array();
-            for($j = 0; $j < $this->width; $j++)
+            for ($j = 0; $j < $this->width; $j++)
             {
                 $walkable = isset($matrix[$i][$j]) ? $matrix[$i][$j] : false;
                 $nodes[$i][$j] = new Node($i, $j, $walkable);
@@ -66,11 +66,11 @@ 
     public function buildWalkableNodesList()
     {
         $list = array();
-        foreach($this->nodes as $line)
+        foreach ($this->nodes as $line)
         {
-            foreach($line as $node)
+            foreach ($line as $node)
             {
-                if($node->isWalkable())
+                if ($node->isWalkable())
                 {
                     $list[] = $node;
                 }
@@ -105,23 +105,23 @@ 
     
     public function getWalkableNeighbors(Node $node)
     {
-        if(! $node->isWalkable())
+        if (!$node->isWalkable())
         {
             return array();
         }
         
         $deltas = array(
             array(-1, -1), array(-1, +0), array(-1, +1),
-            array(+0, -1),                array(+0, +1),
+            array(+0, -1), array(+0, +1),
             array(+1, -1), array(+1, +0), array(+1, +1),
         );
         
         $neighbors = array();
-        foreach($deltas as $delta)
+        foreach ($deltas as $delta)
         {
             $x = $node->getX() + $delta[0];
             $y = $node->getY() + $delta[1];
-            if($this->isWalkableAt($x, $y))
+            if ($this->isWalkableAt($x, $y))
             {
                 $neighbors[] = $this->getNodeAt($x, $y);
             }
@@ -132,12 +132,12 @@ 
     
     private function getNodeAt($x, $y)
     {
-        if(! array_key_exists($x, $this->nodes))
+        if (!array_key_exists($x, $this->nodes))
         {
             return null;
         }
         
-        if(! array_key_exists($y, $this->nodes[$x]))
+        if (!array_key_exists($y, $this->nodes[$x]))
         {
             return null;
         }
@@ -148,7 +148,7 @@ 
     private function isWalkableAt($x, $y)
     {
         $node = $this->getNodeAt($x, $y);
-        if($node instanceof Node)
+        if ($node instanceof Node)
         {
             return $node->isWalkable();
         }

src/Core/Pairs.php

Spacing +4 added lines, -4 removed lines

@@ -14,7 +14,7 @@ 
     
     public function __construct(array $items)
     {
-        if(count($items) < 2)
+        if (count($items) < 2)
         {
             throw new \RuntimeException('Pairs must be initialized with at least two items');
         }
@@ -25,7 +25,7 @@ 
         
         $this->keys = array();
         $this->values = array();
-        foreach($items as $key => $value)
+        foreach ($items as $key => $value)
         {
             $this->keys[] = $key;
             $this->values[] = $value;
@@ -52,12 +52,12 @@ 
     public function next()
     {
         $this->secondIndex++;
-        if($this->secondIndex >= $this->maxIndex)
+        if ($this->secondIndex >= $this->maxIndex)
         {
             $this->firstIndex++;
             $this->secondIndex = $this->firstIndex + 1;
         }
-        if($this->secondIndex >= $this->maxIndex)
+        if ($this->secondIndex >= $this->maxIndex)
         {
             $this->hasNext = false;
             return null;

src/Core/NodeGraph.php

Spacing +21 added lines, -21 removed lines

@@ -14,9 +14,9 @@ 
         $this->edges = array();
         $this->vertexes = array();
         $this->symetric = true;
-        foreach($nodes as $node)
+        foreach ($nodes as $node)
         {
-            if($node instanceof Node)
+            if ($node instanceof Node)
             {
                 $this->vertexes[$node->getId()] = $node;
             }
@@ -34,16 +34,16 @@ 
     {
         $aId = $a->getId();
         $bId = $b->getId();
-        if(! array_key_exists($aId, $this->vertexes) || ! array_key_exists($bId, $this->vertexes))
+        if (!array_key_exists($aId, $this->vertexes) || !array_key_exists($bId, $this->vertexes))
         {
             return;
         }
-        if($aId === $bId)
+        if ($aId === $bId)
         {
             return;
         }
         
-        if($this->symetric === true)
+        if ($this->symetric === true)
         {
             $this->edges[$bId][$aId] = (float) $value;
         }
@@ -54,19 +54,19 @@ 
     {
         $aId = $a->getId();
         $bId = $b->getId();
-        if(! array_key_exists($aId, $this->vertexes) || ! array_key_exists($bId, $this->vertexes))
+        if (!array_key_exists($aId, $this->vertexes) || !array_key_exists($bId, $this->vertexes))
         {
             return null;
         }
-        if($aId === $bId)
+        if ($aId === $bId)
         {
             return 0;
         }
-        if(! array_key_exists($aId, $this->edges))
+        if (!array_key_exists($aId, $this->edges))
         {
             return INF;
         }
-        if(! array_key_exists($bId, $this->edges[$aId]))
+        if (!array_key_exists($bId, $this->edges[$aId]))
         {
             return INF;
         }
@@ -78,19 +78,19 @@ 
     {
         $aId = $a->getId();
         $bId = $b->getId();
-        if(! array_key_exists($aId, $this->vertexes) || ! array_key_exists($bId, $this->vertexes))
+        if (!array_key_exists($aId, $this->vertexes) || !array_key_exists($bId, $this->vertexes))
         {
             return false;
         }
-        if($aId === $bId)
+        if ($aId === $bId)
         {
             return false;
         }
-        if(! array_key_exists($aId, $this->edges))
+        if (!array_key_exists($aId, $this->edges))
         {
             return false;
         }
-        if(! array_key_exists($bId, $this->edges[$aId]))
+        if (!array_key_exists($bId, $this->edges[$aId]))
         {
             return false;
         }
@@ -110,7 +110,7 @@ 
     {
         $aId = $a->getId();
         $bId = $b->getId();
-        if(! array_key_exists($aId, $this->vertexes) || ! array_key_exists($bId, $this->vertexes))
+        if (!array_key_exists($aId, $this->vertexes) || !array_key_exists($bId, $this->vertexes))
         {
             return;
         }
@@ -126,7 +126,7 @@ 
     
     public function getVertex($id)
     {
-        if(array_key_exists($id, $this->vertexes))
+        if (array_key_exists($id, $this->vertexes))
         {
             return $this->vertexes[$id];
         }
@@ -138,9 +138,9 @@ 
     {
         $edges = array();
         $vertexFromId = $vertexFrom->getId();
-        foreach($this->vertexes as $vertexToId => $vertexTo)
+        foreach ($this->vertexes as $vertexToId => $vertexTo)
         {
-            if(isset($this->edges[$vertexFromId][$vertexToId]))
+            if (isset($this->edges[$vertexFromId][$vertexToId]))
             {
                 $edges[$vertexToId] = $this->edges[$vertexFromId][$vertexToId];
             }
@@ -153,9 +153,9 @@ 
     {
         $edges = array();
         $vertexToId = $vertexTo->getId();
-        foreach($this->vertexes as $vertexFromId => $vertexFrom)
+        foreach ($this->vertexes as $vertexFromId => $vertexFrom)
         {
-            if(isset($this->edges[$vertexFromId][$vertexToId]))
+            if (isset($this->edges[$vertexFromId][$vertexToId]))
             {
                 $edges[$vertexToId] = $this->edges[$vertexFromId][$vertexToId];
             }
@@ -168,9 +168,9 @@ 
     {
         $length = 0;
         $prevNode = null;
-        foreach($route as $node)
+        foreach ($route as $node)
         {
-            if($prevNode === null)
+            if ($prevNode === null)
             {
                 $prevNode = $node;
                 continue;

src/Core/NodeMap.php

Spacing +4 added lines, -4 removed lines

@@ -51,7 +51,7 @@ 
     {
         $id = $node->getId();
         
-        if(array_key_exists($id, $this->map))
+        if (array_key_exists($id, $this->map))
         {
             return $this->map[$id];
         }
@@ -62,12 +62,12 @@ 
     public function lookupFrom(Node $node)
     {
         $path = array();
-        while($node instanceof Node)
+        while ($node instanceof Node)
         {
             array_unshift($path, $node);
             $node = $this->lookup($node);
             
-            if(in_array($node, $path))
+            if (in_array($node, $path))
             {
                 break;
             }
@@ -81,7 +81,7 @@ 
         $id = $node->getId();
         $value = null;
         
-        if(array_key_exists($id, $this->map))
+        if (array_key_exists($id, $this->map))
         {
             $value = $this->map[$id];
             unset($this->map[$id]);

src/Core/NodePriorityQueueMin.php

Spacing +1 added lines, -1 removed lines

@@ -28,7 +28,7 @@
     {
         $id = $node->getId();
         
-        if(array_key_exists($id, $this->queue))
+        if (array_key_exists($id, $this->queue))
         {
             return $this->queue[$id];
         }

src/Algorithms/ShortestDistance/FloydWarshall.php

Spacing +13 added lines, -13 removed lines

@@ -33,17 +33,17 @@ 
     
     public function computeLength(Node $source, Node $target)
     {
-        if(! $this->grid instanceof NodeGrid)
+        if (!$this->grid instanceof NodeGrid)
         {
             throw new \RuntimeException('Invalid Grid');
         }
-        if(! $this->distanceGraph instanceof NodeGraph)
+        if (!$this->distanceGraph instanceof NodeGraph)
         {
             throw new \RuntimeException('Invalid Graph');
         }
         
         $edges = $this->distanceGraph->getEdgesFrom($source);
-        if(empty($edges))
+        if (empty($edges))
         {
             $this->computeDistanceGraph();
         }
@@ -54,43 +54,43 @@ 
     private function computeDistanceGraph()
     {
         $nbNodes = $this->grid->getNodesNb();
-        for($i = 0; $i < $nbNodes; $i++)
+        for ($i = 0; $i < $nbNodes; $i++)
         {
             $iNode = $this->grid->getNodeNumber($i);
             $neighbors = $this->grid->getWalkableNeighbors($iNode);
-            foreach($neighbors as $neighbor)
+            foreach ($neighbors as $neighbor)
             {
                 $alternativeDistance = $this->distance->compute($iNode, $neighbor);
-                if($alternativeDistance < $this->distanceGraph->getEdgeBetween($iNode, $neighbor))
+                if ($alternativeDistance < $this->distanceGraph->getEdgeBetween($iNode, $neighbor))
                 {
                     $this->distanceGraph->createEdgeBetween($iNode, $neighbor, $alternativeDistance);
                 }
             }
         }
         
-        for($k = 0; $k < $nbNodes; $k++)
+        for ($k = 0; $k < $nbNodes; $k++)
         {
             $kNode = $this->grid->getNodeNumber($k);
-            if(! $kNode->isWalkable())
+            if (!$kNode->isWalkable())
             {
                 continue;
             }
-            for($i = 0; $i < $nbNodes; $i++)
+            for ($i = 0; $i < $nbNodes; $i++)
             {
                 $iNode = $this->grid->getNodeNumber($i);
-                if(! $iNode->isWalkable())
+                if (!$iNode->isWalkable())
                 {
                     continue;
                 }
-                for($j = 0; $j < $nbNodes; $j++)
+                for ($j = 0; $j < $nbNodes; $j++)
                 {
                     $jNode = $this->grid->getNodeNumber($j);
-                    if(! $jNode->isWalkable())
+                    if (!$jNode->isWalkable())
                     {
                         continue;
                     }
                     $alternativeDistance = $this->distanceGraph->getEdgeBetween($iNode, $kNode) + $this->distanceGraph->getEdgeBetween($kNode, $jNode);
-                    if($alternativeDistance < $this->distanceGraph->getEdgeBetween($iNode, $jNode))
+                    if ($alternativeDistance < $this->distanceGraph->getEdgeBetween($iNode, $jNode))
                     {
                         $this->distanceGraph->createEdgeBetween($iNode, $jNode, $alternativeDistance);
                     }

src/Algorithms/ShortestDistance/Dijkstra.php

Spacing +7 added lines, -7 removed lines

@@ -35,17 +35,17 @@ 
     
     public function computeLength(Node $source, Node $target)
     {
-        if(! $this->grid instanceof NodeGrid)
+        if (!$this->grid instanceof NodeGrid)
         {
             throw new \RuntimeException('Invalid Grid');
         }
-        if(! $this->distanceGraph instanceof NodeGraph)
+        if (!$this->distanceGraph instanceof NodeGraph)
         {
             throw new \RuntimeException('Invalid Graph');
         }
         
         $edges = $this->distanceGraph->getEdgesFrom($source);
-        if(empty($edges))
+        if (empty($edges))
         {
             $this->computeDistanceGraph(array($source));
         }
@@ -55,20 +55,20 @@ 
     
     private function computeDistanceGraph(array $nodesList)
     {
-        foreach($nodesList as $source)
+        foreach ($nodesList as $source)
         {
             $priorityQueue = new NodePriorityQueueMin();
             $priorityQueue->insert($source, 0);
             
-            while(! $priorityQueue->isEmpty())
+            while (!$priorityQueue->isEmpty())
             {
                 $node = $priorityQueue->extract();
                 
                 $neighbors = $this->grid->getWalkableNeighbors($node);
-                foreach($neighbors as $neighbor)
+                foreach ($neighbors as $neighbor)
                 {
                     $alternativeDistance = $this->distanceGraph->getEdgeBetween($source, $node) + $this->distance->compute($node, $neighbor);
-                    if(! $this->distanceGraph->existsEdgeBetween($source, $neighbor) || $alternativeDistance < $this->distanceGraph->getEdgeBetween($source, $neighbor))
+                    if (!$this->distanceGraph->existsEdgeBetween($source, $neighbor) || $alternativeDistance < $this->distanceGraph->getEdgeBetween($source, $neighbor))
                     {
                         $priorityQueue->insert($neighbor, $alternativeDistance);
                         $this->distanceGraph->createEdgeBetween($source, $neighbor, $alternativeDistance);