Pyvoronoi

https://pypi.org/project/pyvoronoi/
Admin
Pyvoronoi is a Python wrapper for the Boost Voronoi library, providing robust tools for generating...
Tokens:12,500
Snippets:131
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Build Documentation with Sphinx

Source: https://pypi.org/project/pyvoronoi

Commands to build the project documentation using Sphinx. Ensure you have Sphinx and the RTD theme installed.

```bash
python.exe setup.py build_ext --inplace
D:\arcgis-pro-envs\pyvoronoi\Scripts\sphinx-build -M html docs/source/ docs/build/ -E -a

```

```bash
(sudo)pipinstallsphinx (sudo) pip install sphinx-rtd-theme D:\arcgis-pro-envs\pyvoronoi\Scripts\sphinx-build -M html docs/source/ docs/build/ -E -a

```

--------------------------------

### Add Segments and Construct Voronoi Diagram

Source: https://pypi.org/project/pyvoronoi

Adds multiple segments to define the boundaries for the Voronoi diagram construction. This example demonstrates adding segments and then retrieving and printing cell information.

```python
pv = pyvoronoi.Pyvoronoi(100)
pv.AddSegment([[0.1,0.8],[0.3,0.6]])
pv.AddSegment([[0.3,0.6],[0.4,0.6]])
pv.AddSegment([[0.4,0.6],[0.4,0.5]])
pv.AddSegment([[0.4,0.6],[0.4,0.7]])
pv.AddSegment([[0.4,0.7],[0.5,0.8]])
pv.AddSegment([[0.4,0.7],[0.5,0.6]])
pv.AddSegment([[0.5,0.6],[0.7,0.7]])

pv.Construct()
edges = pv.GetEdges()
vertices = pv.GetVertices()
cells = pv.GetCells()
print("Cell Count: {0}".format(len(cells)))
for c in cells:
    print("Cell contains point: {0}. Contains segment: {1}. Is open: {2}, Site Index: {3}".format(c.contains_point, c.contains_segment, c.is_open, c.site))
    print(",".join(map(str,c.vertices)))
    for sIndex in c.edges:
        print("Start Index: {0}, End Index = {1}".format(edges[sIndex].start, edges[sIndex].end))
```

--------------------------------

### Initialize and Construct Voronoi Diagram

Source: https://pypi.org/project/pyvoronoi

Initializes the Pyvoronoi object, adds input points and segments, and constructs the Voronoi diagram. Use this to set up the geometric structure.

```python
import pyvoronoi
pv = pyvoronoi.Pyvoronoi(1)
pv.AddPoint([5,5])
pv.AddSegment([[0,0],[0,10]])
pv.AddSegment([[0,0],[10,0]])
pv.AddSegment([[0,10],[10,10]])
pv.AddSegment([[10,0],[10,10]])
pv.Construct()
```

--------------------------------

### Initialize Pyvoronoi Instance

Source: https://pypi.org/project/pyvoronoi

Create a new instance of Pyvoronoi, passing a scaling factor to the constructor. This factor is crucial for maintaining precision when converting coordinates to integers.

```python
import pyvoronoi
pv = pyvoronoi.Pyvoronoi(10)
```

--------------------------------

### Retrieve and Count Input Geometries with Pyvoronoi

Source: https://pypi.org/project/pyvoronoi

Demonstrates how to retrieve individual points and segments by index, count the total number of input points and segments, and iterate through all input points and segments using generators. This is useful for inspecting geometries after processing.

```python
def test_retrieve_input(self):
    pv = pyvoronoi.Pyvoronoi(1)

    p1 = [5, 5]
    p2 = [0, 0]
    s1 = [[10, 10], [20, 20]]
    s2 = [[10, 10], [20, 20]]
    s3 = [[-10, -10], [-20, -20]]

    pv.AddPoint(p1)
    pv.AddPoint(p2)
    pv.AddSegment(s1)
    pv.AddSegment(s2)
    pv.AddSegment(s3)


    pv.Construct()

    self.assertTrue(2 == len(list(pv.GetPoints())))
    self.assertEqual(2, pv.CountPoints())
    self.assertTrue(3 == len(list(pv.GetSegments())))
    self.assertEqual(3, pv.CountSegments())
    self.assertEqual(p1, pv.GetPoint(0))
    self.assertEqual(p2, pv.GetPoint(1))
    self.assertEqual(s1, pv.GetSegment(0))
    self.assertEqual(s2, pv.GetSegment(1))
```

--------------------------------

### Construct Voronoi Diagram and Retrieve Data

Source: https://pypi.org/project/pyvoronoi

Construct the Voronoi diagram after adding points and segments. Retrieve the computed edges, vertices, and cells of the diagram.

```python
pv.Construct()
edges = pv.GetEdges()
vertices = pv.GetVertices()
cells = pv.GetCells()
```

--------------------------------

### Retrieve All Edges (Convenience Wrapper)

Source: https://pypi.org/project/pyvoronoi

A convenience method to retrieve all edges from the Voronoi diagram. This method iterates through all edge indices and fetches each edge.

```python
def GetEdges(self):
    count = self.CountEdges()
    output = []
    for index in range(count):
        output.append(self.GetEdge(index))
    return output
```

--------------------------------

### Retrieve All Vertices (Convenience Wrapper)

Source: https://pypi.org/project/pyvoronoi

A convenience method to retrieve all vertices from the Voronoi diagram. This method iterates through all vertex indices and fetches each vertex.

```python
def GetVertices(self):
    count = self.CountVertices()
    output = []
    for index in  range(count):
        output.append(self.GetVertex(index))
    return output
```

--------------------------------

### Retrieve All Cells (Convenience Wrapper)

Source: https://pypi.org/project/pyvoronoi

A convenience method to retrieve all cells from the Voronoi diagram. This method iterates through all cell indices and fetches each cell.

```python
def GetCells(self):
    count = self.CountCells()
    output = []
    for index in range(count):
        output.append(self.GetCell(index))
    return output
```

--------------------------------

### Find Points on Segments with Pyvoronoi

Source: https://pypi.org/project/pyvoronoi

Use GetPointsOnSegments to identify input points that lie on any segment. This helps in validating input data according to Voronoi diagram constraints. Segments' endpoints are excluded from this check.

```python
pv = pyvoronoi.Pyvoronoi(1)

# Those two segments do not intersect or overlap anything
pv.AddSegment([[-6, -6], [-10, -10]])
pv.AddSegment([[6, 6], [10, 10]])

# The second point is located on the second segment
pv.AddPoint([0, 0])
pv.AddPoint([7, 7])
   
# Will return [1] as the second point is on the second segment
invalid_points = pv.GetPointsOnSegments()
```

--------------------------------

### Find Intersecting Segments with Pyvoronoi

Source: https://pypi.org/project/pyvoronoi

Use GetIntersectingSegments to find segments that intersect with other segments. This validation method is crucial for ensuring valid input for Voronoi diagram construction. Intersections only at endpoints are ignored.

```python
pv = pyvoronoi.Pyvoronoi(1)

# Those two segments overlap on 0,0 --> 5,0
pv.AddSegment([[0, 0], [10, 0]])
pv.AddSegment([[-10, 0], [5, 0]])

# Those two segments not intersect or overlap anything
pv.AddSegment([[-6, -6], [-10, -10]])
pv.AddSegment([[6, 6], [10, 10]])

# Will return [0, 1] since the first two segments overlap
intersecting_segments = pv.GetIntersectingSegments()
```

--------------------------------

### Enumerate Voronoi Diagram Components

Source: https://pypi.org/project/pyvoronoi

Iterates through the vertices, edges, and cells of a constructed Voronoi diagram. Access geometric data for each component.

```python
for index, vertex in pv.EnumerateVertices():
      # ... do things with vertex.X or vertex.Y
   
   for index, edge in pv.EnumerateEdges():
      # ... do things with the current edge
   
   for index, cell in pv.EnumerateCells():
      # ... do things with the current cell
```

--------------------------------

### Add Points and Segments

Source: https://pypi.org/project/pyvoronoi

Add points and line segments to the Voronoi diagram. Points are added as a list of coordinates, and segments are defined by a list of two points.

```python
pv.AddPoint([0, 0])
pv.AddSegment([[1,5],[2,2]])
```

--------------------------------

### Memory-Efficient Data Enumeration

Source: https://pypi.org/project/pyvoronoi

Provides memory-efficient ways to iterate over vertices, edges, and cells using generators. This is preferred for large datasets to avoid loading all data into memory at once.

```python
def EnumerateVertices(self):
    for index in range(self.CountVertices()):
        yield index, self.GetVertex(index)
            
def EnumerateEdges(self):
    for index in range(self.CountEdges()):
        yield index, self.GetEdge(index)

def EnumerateCells(self):
    for index in range(self.CountCells()):
        yield index, self.GetCell(index)
```

--------------------------------

### Discretize Curved Edges in Voronoi Diagram

Source: https://pypi.org/project/pyvoronoi

Processes cells to discretize any curved edges into a series of points. This is useful for rendering or further geometric processing of non-linear edges.

```python
for cIndex in range(len(cells)):
    cell = cells[cIndex]
    if cell.is_open == False:
        for i in range(len(cell.edges)):
            e = edges[cell.edges[i]]
            startVertex = vertices[e.start]
            endVertex = vertices[e.end]

            max_distance  = distance([startVertex.X, startVertex.Y], [endVertex.X, endVertex.Y]) / 10
            if startVertex != -1 and endVertex != -1:
                if(e.is_linear == True):
                    array = [[startVertex.X, startVertex.Y],[endVertex.X, endVertex.Y]]
                else:
                    points = pv.DiscretizeCurvedEdge(i, max_distance)
                    for p in points:
                        print "{0},{1}".format(p[0], p[1])
```
Tokens:
Raw