# doc-cache created by Octave 4.0.0
# name: cache
# type: cell
# rows: 3
# columns: 5
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
delaunayGraph


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 839
 -- Function File: [POINTS EDGES]=  delaunayGraph (POINTS)
     Graph associated to Delaunay triangulation of input points

     Compute the Delaunay triangulation of the set of input points, and
     convert to a set of edges. The output NODES is the same as the
     input POINTS.

     WARNING: 3d pltottig works correctly in Octave >= 3.6

     Example

          # Draw a planar graph correpspionding to Delaunay triangulation
          points = rand(30, 2) * 100;
          [nodes edges] = delaunayGraph(points);
          figure;
          drawGraph(nodes, edges);

          # Draw a 3Dgraph corresponding to Delaunay tetrahedrisation
          points = rand(20, 3) * 100;
          [nodes edges] = delaunayGraph(points);
          figure;
          drawGraph(nodes, edges);
          view(3);

     See also: delaunay, delaunayn.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Graph associated to Delaunay triangulation of input points



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
drawGraph


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1733
 -- Function File: drawGraph (NODES, EDGES)
 -- Function File: drawGraph (NODES, EDGES, FACES)
 -- Function File: drawGraph (GRAPH)
 -- Function File: drawGraph (..., SNODES)
 -- Function File: drawGraph (..., SNODES, SEDGES)
 -- Function File: drawGraph (..., SNODES, SEDGES, SFACES)
 -- Function File: H =  drawGraph (...)
 -- Function File: [H HE] =  drawGraph (...)
 -- Function File: [H HE HF] =  drawGraph (...)
     Draw a graph, given as a set of vertices and edges

     DRAWGRAPH(NODES, EDGES)   draw a graph specified by a set of nodes
     (array N*2 or N*3,   corresponding to coordinate of each node),
     and a set of edges (an array   Ne*2, containing for each edge the
     first and the second node).    Default drawing is a red circle for
     nodes and a blue line for edges.

     DRAWGRAPH(NODES, EDGES, FACES)   also draw faces of the graph as
     patches.

     DRAWGRAPH(GRAPH)   passes argument in a srtucture with at least 2
     fields named 'nodes' and   'edges', and possibly one field
     'faces', corresponding to previously   described parameters.
     GRAPH can also be a cell array, whose first element is node array,
      second element is edges array, and third element, if present, is
     faces   array.

     DRAWGRAPH(..., SNODES)   DRAWGRAPH(..., SNODES, SEDGES)
     DRAWGRAPH(..., SNODES, SEDGES, SFACES)   specify the draw mode for
     each element, as in the classical 'plot'   function. To not
     display some elements, uses 'none'.

     H = DRAWGRAPH(...)    return handle to the set of edges.

     [HN, HE] = DRAWGRAPH(...)    return handle to the set of nodes and
     to the set of edges.

     [HN, HE, HF] = DRAWGRAPH(...)    Also return handle to the set of
     faces.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Draw a graph, given as a set of vertices and edges



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
graphs_Contents


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5805
 -- Function File: graphs_Contents ()
     GRAPHS Simple Toolbox for manipulating Geometric Graphs Version
     0.5 11-Apr-2010 .

     The aim of this package is to provides functions to easily create,
      modify and display geometric graphs (geometric in a sense position
      of vertices is kept in memory).

     Graph structure is represented by at least two arrays:   * NODES,
     which contains coordinates of each vertex   * EDGES, which
     contains indices of start and end vertex.

     Others arrays may sometimes be used:   * FACES, which contains
     indices of vertices of each face (either a       double array, or
     a cell array)   * CELLS, which contains indices of faces of each
     cell.

     An alternative representation is to use a structure, with fields:
     * edges   * faces   * cells   corresponding to the data described
     above.

     Note that topological description of 2D graph is entirely
     contained in   EDGES array, and that NODES array is used only to
     display graph

     Caution: this type of data structure is easy to create and to
     manage,   but may be very inefficient for some algorithms.

     Graphs are usually considered as non-oriented in this package.

     Graph creation   knnGraph                - Create the k-nearest
     neighbors graph of a set of points   delaunayGraph           -
     Graph associated to Delaunay triangulation of input points
     euclideanMST            - Build euclidean minimal spanning tree of
     a set of points   prim_mst                - Minimal spanning tree
     by Prim's algorithm

     Create graph from images   imageGraph              - Create
     equivalent graph of a binary image   boundaryGraph           - Get
     boundary of image as a graph   gcontour2d              - Creates
     contour graph of a 2D binary image.    gcontour3d              -
     Create contour graph of a 3D binary image.    vectorize
       - Transform a binary skeleton into a graph (nodes and edges)

     Graph information   grNodeDegree            - Degree of a node in
     a (undirected) graph   grNodeInnerDegree       - Inner degree of a
     node in a graph   grNodeOuterDegree       - Outer degree of a node
     in a graph   grNeighborNodes         - Find adjacent nodes of a
     given node   grNeighborEdges         - Find adjacent edges of a
     given node   grOppositeNode          - Return opposite node in an
     edge   grLabel                 - Associate a label to each
     connected component of the graph

     Graph management (low level operations)   grRemoveNode
     - Remove a node in a graph   grRemoveNodes           - Remove
     several nodes in a graph   grRemoveEdge            - Remove an
     edge in a graph.    grRemoveEdges           - Remove several edges
     from a graph

     Graph processing (general applications)   mergeGraphs
     - Merge two graphs, by adding nodes, edges and faces lists.
     grMergeNodes            - Merge two (or more) nodes in a graph.
     grMergeMultipleNodes    - Simplify a graph by merging multiple
     nodes   grMergeMultipleEdges    - Remove all edges sharing the
     same extremities   grSimplifyBranches      - Replace branches of a
     graph by single edges

     Filtering operations on Graph   grMean                  - Compute
     mean from neihgbours   grMedian                - Compute median
     from neihgbours   grDilate                - Morphological dilation
     on graph   grErode                 - Morphological erosion on graph
      grClose                 - Morphological closing on graph   grOpen
                     - Morphological opening on graph

     Geodesic operations   grPropagateDistance     - Propagates
     distances from a vertex to other vertices   grVertexEccentricity
     - Eccentricity of vertices in the graph   graphDiameter
     - Diameter of a graph   graphPeripheralVertices - Peripheral
     vertices of a graph   graphCenter             - Center of a graph
     graphRadius             - Radius of a graph   grFindGeodesicPath
       - Find a geodesic path between two nodes in the graph
     grFindMaximalLengthPath - Find a path that maximizes sum of edge
     weights

     Operations for geometric graphs   grMergeNodeClusters     - Merge
     cluster of connected nodes in a graph   grMergeNodesMedian      -
     Replace several nodes by their median coordinate   clipGraph
            - Clip a graph with a rectangular area   addSquareFace
         - Add a (square) face defined from its vertices to a graph
     grFaceToPolygon         - Compute the polygon corresponding to a
     graph face   graph2Contours          - Convert a graph to a set of
     contour curves

     Voronoi Graphs   voronoi2d               - Compute a voronoi
     diagram as a graph structure   boundedVoronoi2d        - Return a
     bounded voronoi diagram as a graph structure   centroidalVoronoi2d
        - Create a 2D Centroidal Voronoi Tesselation   cvtUpdate
           - Update germs of a CVT with given points   cvtIterate
           - Update germs of a CVT using random points with given
     density

     Graph display   drawGraph               - Draw a graph, given as a
     set of vertices and edges   drawGraphEdges          - Draw edges
     of a graph   drawGraphFaces          - Draw faces of a graph
     drawDigraph             - Draw a directed graph, given as a set of
     vertices and edges   drawDirectedEdges       - Draw edges with
     arrow indicating direction   drawEdgeLabels          - Draw values
     associated to graph edges   drawNodeLabels          - Draw values
     associated to graph nodes   drawSquareMesh          - Draw a 3D
     square mesh given as a graph   patchGraph              - Transform
     3D graph (mesh) into a patch handle



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GRAPHS Simple Toolbox for manipulating Geometric Graphs Version 0.5
11-Apr-2010 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
knnGraph


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 252
 -- Function File: EDGES =  knnGrpah (NODES)
     Create the k-nearest neighbors graph of a set of points

     EDGES = knnGraph(NODES)

     Example

          nodes = rand(10, 2);
          edges = knnGraph(nodes);
          drawGraph(nodes, edges);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Create the k-nearest neighbors graph of a set of points



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
voronoi2d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 369
 -- Function File: [NODES EDGES FACES] =  voronoi2d (GERMS)
     Compute a voronoi diagram as a graph structure

     [NODES EDGES FACES] = voronoi2d(GERMS) GERMS an array of points
     with dimension 2 NODES, EDGES, FACES: usual graph representation,
     FACES as cell array

     Example

          [n e f] = voronoi2d(rand(100, 2)*100);
          drawGraph(n, e);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Compute a voronoi diagram as a graph structure





