PHP Graph::getVertices方法代码示例

 /**
  *
  */
 public function createGraph()
 {
     $graph = new Graph();
     $file = $this->getLines();
     $graph->createVertices($this->readInt($file[0]));
     unset($file[0]);
     // set the value of the vertices
     $zeile = 1;
     foreach ($graph->getVertices() as $vertex) {
         $vertex->setBalance($this->readFloat($file[$zeile]));
         unset($file[$zeile]);
         ++$zeile;
     }
     foreach ($file as $zeile) {
         $parts = $this->readLine($zeile, array('vertex', 'vertex', 'float', 'float'), $graph);
         if ($this->directedEdges) {
             $edge = $parts[0]->createEdgeTo($parts[1]);
         } else {
             $edge = $parts[0]->createEdge($parts[1]);
         }
         $edge->setWeight($parts[2]);
         $edge->setCapacity($parts[3]);
     }
     return $graph;
 }

 /**
  * @expectedException InvalidArgumentException
  */
 public function testGetVertexOrderInvalidSortBy()
 {
     $graph = new Graph();
     $graph->createVertex(1);
     $vertices = $graph->getVertices();
     $vertices->getVertexOrder('not a valid callback');
 }

 public function getOutput(Graph $graph)
 {
     $output = '';
     // build an array to map vertex IDs (which may contain complex strings) to temporary numeric IDs for output
     $tid = 1;
     $tids = array();
     foreach ($graph->getVertices()->getMap() as $vid => $vertex) {
         $output .= $tid . ' ' . $this->getVertexLabel($vertex) . self::EOL;
         $tids[$vid] = $tid++;
     }
     // end of vertex list, start of edge list
     $output .= '#' . self::EOL;
     foreach ($graph->getEdges() as $edge) {
         /* @var $edge Edge */
         $ids = $edge->getVertices()->getIds();
         $a = $tids[$ids[0]];
         $b = $tids[$ids[1]];
         $label = $this->getEdgeLabel($edge);
         if ($label !== '') {
             $label = ' ' . $label;
         }
         $output .= $a . ' ' . $b . $label . self::EOL;
         // this is not a directed edge => also add back-edge with same label
         if (!$edge instanceof Directed) {
             $output .= $b . ' ' . $a . $label . self::EOL;
         }
     }
     return $output;
 }

 /**
  * get resulting (first) best circle of edges connecting all vertices
  *
  * @throws Exception on error
  * @return Edges
  */
 public function getEdges()
 {
     $this->numEdges = count($this->graph->getVertices());
     if ($this->numEdges < 3) {
         throw new UnderflowException('Needs at least 3 vertices');
     }
     // numEdges 3-12 should work
     $this->bestWeight = $this->upperLimit;
     $this->startVertex = $this->getVertexStart();
     $result = $this->step($this->startVertex, 0, array(), array());
     if ($result === NULL) {
         throw new UnexpectedValueException('No resulting solution for TSP found');
     }
     return new Edges($result);
 }

 public function getOutput(Graph $graph)
 {
     $root = new SimpleXMLElement(self::SKEL);
     $graphElem = $root->addChild('graph');
     $graphElem['edgeDefault'] = 'undirected';
     foreach ($graph->getVertices()->getMap() as $id => $vertex) {
         /* @var $vertex Vertex */
         $vertexElem = $graphElem->addChild('node');
         $vertexElem['id'] = $id;
     }
     foreach ($graph->getEdges() as $edge) {
         /* @var $edge Edge */
         $edgeElem = $graphElem->addChild('edge');
         $edgeElem['source'] = $edge->getVertices()->getVertexFirst()->getId();
         $edgeElem['target'] = $edge->getVertices()->getVertexLast()->getId();
         if ($edge instanceof Directed) {
             $edgeElem['directed'] = 'true';
         }
     }
     return $root->asXML();
 }

 /**
  *
  *
  * @param  Graph     $graph
  * @throws Exception if there is no left source vertex
  *
  * @return Vertex a source vertex in the given graph
  */
 private function getVertexSource(Graph $graph)
 {
     foreach ($graph->getVertices()->getMap() as $vid => $vertex) {
         if ($this->graph->getVertex($vid)->getBalance() - $vertex->getBalance() > 0) {
             return $vertex;
         }
     }
     throw new UnderflowException('No source vertex found in graph');
 }

 protected function getVertexStart()
 {
     return $this->graph->getVertices()->getVertexFirst();
 }

 /**
  *
  * @return Edges
  */
 public function getEdges()
 {
     // Sortiere Kanten im Graphen
     $sortedEdges = new SplPriorityQueue();
     // For all edges
     $this->addEdgesSorted($this->graph->getEdges(), $sortedEdges);
     $returnEdges = array();
     // next color to assign
     $colorNext = 0;
     // array(color1 => array(vid1, vid2, ...), color2=>...)
     $colorVertices = array();
     // array(vid1 => color1, vid2 => color1, ...)
     $colorOfVertices = array();
     // Füge billigste Kanten zu neuen Graphen hinzu und verschmelze teilgragen wenn es nötig ist (keine Kreise)
     // solange ich mehr als einen Graphen habe mit weniger als n-1 kanten (bei n knoten im original)
     foreach ($sortedEdges as $edge) {
         /* @var $edge EdgeDirected */
         // Gucke Kante an:
         $vertices = $edge->getVertices()->getIds();
         $aId = $vertices[0];
         $bId = $vertices[1];
         $aColor = isset($colorOfVertices[$aId]) ? $colorOfVertices[$aId] : NULL;
         $bColor = isset($colorOfVertices[$bId]) ? $colorOfVertices[$bId] : NULL;
         // 1. weder start noch end gehört zu einem graphen
         // => neuer Graph mit kanten
         if ($aColor === NULL && $bColor === NULL) {
             $colorOfVertices[$aId] = $colorNext;
             $colorOfVertices[$bId] = $colorNext;
             $colorVertices[$colorNext] = array($aId, $bId);
             ++$colorNext;
             // connect both vertices
             $returnEdges[] = $edge;
         } else {
             if ($aColor === NULL && $bColor !== NULL) {
                 // paint a in b's color
                 $colorOfVertices[$aId] = $bColor;
                 $colorVertices[$bColor][] = $aId;
                 $returnEdges[] = $edge;
                 // Only a has color
             } elseif ($aColor !== NULL && $bColor === NULL) {
                 // paint b in a's color
                 $colorOfVertices[$bId] = $aColor;
                 $colorVertices[$aColor][] = $bId;
                 $returnEdges[] = $edge;
             } else {
                 if ($aColor !== $bColor) {
                     $betterColor = $aColor;
                     $worseColor = $bColor;
                     // more vertices with color a => paint all in b in a's color
                     if (count($colorVertices[$bColor]) > count($colorVertices[$aColor])) {
                         $betterColor = $bColor;
                         $worseColor = $aColor;
                     }
                     // search all vertices with color b
                     foreach ($colorVertices[$worseColor] as $vid) {
                         $colorOfVertices[$vid] = $betterColor;
                         // repaint in a's color
                         $colorVertices[$betterColor][] = $vid;
                     }
                     // delete old color
                     unset($colorVertices[$worseColor]);
                     $returnEdges[] = $edge;
                 }
             }
         }
         // 2. start und end gehören zum gleichen graphen => zirkel
         // => nichts machen
     }
     // definition of spanning tree: number of edges = number of vertices - 1
     // above algorithm does not check isolated edges or may otherwise return multiple connected components => force check
     if (count($returnEdges) !== count($this->graph->getVertices()) - 1) {
         throw new UnexpectedValueException('Graph is not connected');
     }
     return new Edges($returnEdges);
 }

 public function testRemoveVertex()
 {
     $graph = new Graph();
     $vertex = $graph->createVertex(1);
     $this->assertEquals(array(1 => $vertex), $graph->getVertices()->getMap());
     $vertex->destroy();
     $this->assertEquals(array(), $graph->getVertices()->getVector());
 }

 /**
  * create graphviz script representing this graph
  *
  * @return string
  * @uses Directed::hasDirected()
  * @uses Graph::getVertices()
  * @uses Graph::getEdges()
  */
 public function createScript()
 {
     $alg = new Directed($this->graph);
     $directed = $alg->hasDirected();
     $script = ($directed ? 'di' : '') . 'graph G {' . self::EOL;
     // add global attributes
     $layout = $this->graph->getLayout();
     if ($layout) {
         $script .= $this->formatIndent . 'graph ' . $this->escapeAttributes($layout) . self::EOL;
     }
     if ($this->layoutVertex) {
         $script .= $this->formatIndent . 'node ' . $this->escapeAttributes($this->layoutVertex) . self::EOL;
     }
     if ($this->layoutEdge) {
         $script .= $this->formatIndent . 'edge ' . $this->escapeAttributes($this->layoutEdge) . self::EOL;
     }
     $alg = new Groups($this->graph);
     // only append group number to vertex label if there are at least 2 different groups
     $showGroups = $alg->getNumberOfGroups() > 1;
     if ($showGroups) {
         $gid = 0;
         $indent = str_repeat($this->formatIndent, 2);
         // put each group of vertices in a separate subgraph cluster
         foreach ($alg->getGroups() as $group) {
             $script .= $this->formatIndent . 'subgraph cluster_' . $gid++ . ' {' . self::EOL . $indent . 'label = ' . $this->escape($group) . self::EOL;
             foreach ($alg->getVerticesGroup($group)->getMap() as $vid => $vertex) {
                 $layout = $this->getLayoutVertex($vertex);
                 $script .= $indent . $this->escapeId($vid);
                 if ($layout) {
                     $script .= ' ' . $this->escapeAttributes($layout);
                 }
                 $script .= self::EOL;
             }
             $script .= '  }' . self::EOL;
         }
     } else {
         $alg = new Degree($this->graph);
         // explicitly add all isolated vertices (vertices with no edges) and vertices with special layout set
         // other vertices wil be added automatically due to below edge definitions
         foreach ($this->graph->getVertices()->getMap() as $vid => $vertex) {
             $layout = $this->getLayoutVertex($vertex);
             if ($layout || $alg->isVertexIsolated($vertex)) {
                 $script .= $this->formatIndent . $this->escapeId($vid);
                 if ($layout) {
                     $script .= ' ' . $this->escapeAttributes($layout);
                 }
                 $script .= self::EOL;
             }
         }
     }
     $edgeop = $directed ? ' -> ' : ' -- ';
     // add all edges as directed edges
     foreach ($this->graph->getEdges() as $currentEdge) {
         $both = $currentEdge->getVertices()->getVector();
         $currentStartVertex = $both[0];
         $currentTargetVertex = $both[1];
         $script .= $this->formatIndent . $this->escapeId($currentStartVertex->getId()) . $edgeop . $this->escapeId($currentTargetVertex->getId());
         $layout = $this->getLayoutEdge($currentEdge);
         // this edge also points to the opposite direction => this is actually an undirected edge
         if ($directed && $currentEdge->isConnection($currentTargetVertex, $currentStartVertex)) {
             $layout['dir'] = 'none';
         }
         if ($layout) {
             $script .= ' ' . $this->escapeAttributes($layout);
         }
         $script .= self::EOL;
     }
     $script .= '}' . self::EOL;
     return $script;
 }

 public function testOrderByGroup()
 {
     $graph = new Graph();
     $graph->createVertex()->setGroup(1);
     $graph->createVertex()->setGroup(100);
     $graph->createVertex()->setGroup(5);
     $graph->createVertex()->setGroup(100);
     $graph->createVertex()->setGroup(100);
     $graph->createVertex()->setGroup(2);
     $biggest = $graph->createVertex()->setGroup(200);
     $vertices = $graph->getVertices();
     $verticesOrdered = $vertices->getVerticesOrder(Vertices::ORDER_GROUP);
     $this->assertInstanceOf('Fhaculty\\Graph\\Set\\Vertices', $verticesOrdered);
     $this->assertEquals(1, $verticesOrdered->getVertexFirst()->getGroup());
     $this->assertEquals(200, $verticesOrdered->getVertexLast()->getGroup());
     $this->assertSame($biggest, $verticesOrdered->getVertexLast());
     $this->assertSame($biggest, $vertices->getVertexOrder(Vertices::ORDER_GROUP, true));
     $sumgroups = function (Vertex $vertex) {
         return $vertex->getGroup();
     };
     $this->assertSame(508, $vertices->getSumCallback($sumgroups));
     $this->assertSame(508, $verticesOrdered->getSumCallback($sumgroups));
 }