java.lang.Object
- org.locationtech.jts.dissolve.LineDissolver

```
public class LineDissolver
extends java.lang.Object
```
Dissolves the linear components from a collection of Geometrys into a set of maximal-length Linestrings in which every unique segment appears once only. The output linestrings run between node vertices of the input, which are vertices which have either degree 1, or degree 3 or greater.
Use cases for dissolving linear components include generalization (in particular, simplifying polygonal coverages), and visualization (in particular, avoiding symbology conflicts when depicting shared polygon boundaries).
This class does not node the input lines. If there are line segments crossing in the input, they will still cross in the output.

Field Summary

Fields
Modifier and Type	Field	Description
`private GeometryFactory`	`factory`
`private DissolveEdgeGraph`	`graph`
`private java.util.List`	`lines`
`private java.util.Stack`	`nodeEdgeStack`
`private Geometry`	`result`
`private DissolveHalfEdge`	`ringStartEdge`

Constructor Summary

Constructors
Constructor Description

LineDissolver()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`add(java.util.Collection geometries)`	Adds a collection of Geometries to be processed.
`void`	`add(Geometry geometry)`	Adds a `Geometry` to be dissolved.
`private void`	`add(LineString lineString)`
`private void`	`addLine(CoordinateList line)`
`private void`	`buildLine(HalfEdge eStart)`	Builds a line starting from the given edge.
`private void`	`buildLines()`	For each edge in stack (which must originate at a node) extracts the line it initiates.
`private void`	`buildRing(HalfEdge eStartRing)`
`private void`	`computeResult()`
`static Geometry`	`dissolve(Geometry g)`	Dissolves the linear components in a geometry.
`Geometry`	`getResult()`	Gets the dissolved result as a MultiLineString.
`private void`	`process(HalfEdge e)`
`private void`	`stackEdges(HalfEdge node)`	Adds edges around this node to the stack.
`private void`	`updateRingStartEdge(DissolveHalfEdge e)`	Updates the tracked ringStartEdge if the given edge has a lower origin (using the standard `Coordinate` ordering).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - result
```
private Geometry result
```
  - factory
```
private GeometryFactory factory
```
  - graph
```
private DissolveEdgeGraph graph
```
  - lines
```
private java.util.List lines
```
  - nodeEdgeStack
```
private java.util.Stack nodeEdgeStack
```
  - ringStartEdge
```
private DissolveHalfEdge ringStartEdge
```
- Constructor Detail
  - LineDissolver
```
public LineDissolver()
```
- Method Detail
  - dissolve
```
public static Geometry dissolve(Geometry g)
```
    Dissolves the linear components in a geometry.
    
    Parameters:
    
    g - the geometry to dissolve
    
    Returns:
    
    the dissolved lines
  - add
```
public void add(Geometry geometry)
```
    Adds a Geometry to be dissolved. Any number of geometries may be added by calling this method multiple times. Any type of Geometry may be added. The constituent linework will be extracted to be dissolved.
    
    Parameters:
    
    geometry - geometry to be line-merged
  - add
```
public void add(java.util.Collection geometries)
```
    Adds a collection of Geometries to be processed. May be called multiple times. Any dimension of Geometry may be added; the constituent linework will be extracted.
    
    Parameters:
    
    geometries - the geometries to be line-merged
  - add
```
private void add(LineString lineString)
```
  - getResult
```
public Geometry getResult()
```
    Gets the dissolved result as a MultiLineString.
    
    Returns:
    
    the dissolved lines
  - computeResult
```
private void computeResult()
```
  - process
```
private void process(HalfEdge e)
```
  - buildLines
```
private void buildLines()
```
    For each edge in stack (which must originate at a node) extracts the line it initiates.
  - updateRingStartEdge
```
private void updateRingStartEdge(DissolveHalfEdge e)
```
    Updates the tracked ringStartEdge if the given edge has a lower origin (using the standard Coordinate ordering). Identifying the lowest starting node meets two goals:
    
    It ensures that isolated input rings are created using the original node and orientation
    For isolated rings formed from multiple input linestrings, it provides a canonical node and orientation for the output (rather than essentially random, and thus hard to test).
    Parameters:
    
    e -
  - buildLine
```
private void buildLine(HalfEdge eStart)
```
    Builds a line starting from the given edge. The start edge origin is a node (valence = 1 or >= 3), unless it is part of a pure ring. A pure ring has no other incident lines. In this case the start edge may occur anywhere on the ring. The line is built up to the next node encountered, or until the start edge is re-encountered (which happens if the edges form a ring).
    
    Parameters:
    
    eStart -
  - buildRing
```
private void buildRing(HalfEdge eStartRing)
```
  - addLine
```
private void addLine(CoordinateList line)
```
  - stackEdges
```
private void stackEdges(HalfEdge node)
```
    Adds edges around this node to the stack.
    
    Parameters:
    
    node -

Class LineDissolver

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

result

factory

graph

lines

nodeEdgeStack

ringStartEdge

Constructor Detail

LineDissolver

Method Detail

dissolve

add

add

add

getResult

computeResult

process

buildLines

updateRingStartEdge

buildLine

buildRing

addLine

stackEdges