GRASS logo


i.segment.gsoc - Outputs a single segmented map (raster) based on input values in an image group.


imagery, segmentation


i.segment.gsoc --help
i.segment.gsoc [-tdwfl] group=name output=name threshold=float method=string similarity=string minsize=integer radioweight=float smoothweight=float [seeds=name] [bounds=name] [endt=integer] [final_mean=name] [--overwrite] [--help] [--verbose] [--quiet] [--ui]


Estimate a threshold based on input image group and exit.
Use 8 neighbors (3x3 neighborhood) instead of the default 4 neighbors for each pixel.
Weighted input, don't perform the default scaling of input maps.
Final forced merge only (skip the growing portion of the algorithm.
segments are limited to be included in only one merge per pass
Allow output files to overwrite existing files
Print usage summary
Verbose module output
Quiet module output
Force launching GUI dialog


group=name [required]
Name of input imagery group
output=name [required]
Name for output raster map
threshold=float [required]
Similarity threshold.
method=string [required]
Segmentation method.
Options: region_growing
Default: region_growing
similarity=string [required]
Similarity calculation method.
Options: euclidean, manhattan
Default: euclidean
minsize=integer [required]
Minimum number of cells in a segment.
The final iteration will ignore the threshold for any segments with fewer pixels.
Options: 1-100000
Default: 1
radioweight=float [required]
Importance of radiometric (input raseters) values relative to shape
Options: 0-1
Default: 0.9
smoothweight=float [required]
Importance of smoothness relative to compactness
Options: 0-1
Default: 0.5
Optional raster map with starting seeds.
Pixel values with positive integers are used as starting seeds.
Optional bounding/constraining raster map
Pixels with the same integer value will be segmented independent of the others.
Maximum number of passes (time steps) to complete.
Default: 1000
Save the final mean values for the first band in the imagery group.

Table of contents


Image segmentation is the process of grouping similar pixels into unique segments. Boundary and region based algorithms are described in the literature, currently a region growing and merging algorithm is implemented. Each grouping (usually refered to as objects or segments) found during the segmentation process is given a unique ID and is a collection of contiguous pixels meeting some criteria. (Note the contrast with image classification, where continuity and spatial characteristics are not important, but rather only the spectral similarity.) The results can be useful on their own, or used as a preprocessing step for image classification. The segmentation preprocessing step can reduce noise and speed up the classification.


Region Growing and Merging

This segmentation algorithm sequentially examines all current segments in the map. The similarity between the current segment and each of its neighbors is calculated according to the given distance formula. Segments will be merged if they meet a number of criteria, including: 1. The pair is mutually most similar to each other (the similarity distance will be smaller then all other neighbors), and 2. The similarity must be lower then the input threshold. All segments are checked once per pass. The process is repeated until no merges are made during a complete pass.

Similarity and Threshold

The similarity between segments and unmerged pixels is used to determine which are merged. The Euclidean version uses the radiometric distance between the two segments and also the shape characteristics. The Manhatten calculations currently only uses only the radiometric distance between the two segments, but eventually shape characteristics will be included as well. NOTE: Closer/smaller distances mean a lower value for the similarity indicates a closer match, with a similarity score of zero for identical pixels.

During normal processing, merges are only allowed when the similarity between two segments is lower then the calculated threshold value. During the final pass, however, if a minimum segment size of 2 or larger is given with the minsize parameter, segments with a smaller pixel count will be merged with their most similar neighbor even if the similarity is greater then the threshold.

Unless the -w flag for weighted data is used, the threshold should be set by the user between 0 and 1.0. A threshold of 0 would allow only identical valued pixels to be merged, while a threshold of 1 would allow everything to be merged.

The threshold will be multiplied by the number of rasters included in the image group. This will allow the same threshold to achieve similar segmentation results when the number of rasters in the image group varies.

The -t flag will estimate the threshold, it is calculated at 3% of the range of data in the imagery group. Initial empirical tests indicate threshold values of 1% to 5% are reasonable places to start.

Calculation Formulas

Both Euclidean and Manhattan distances use the normal definition, considering each raster in the image group as a dimension. Furthermore, the Euclidean calculation also takes into account the shape characteristics of the segments. The normal distances are multiplied by the input radiometric weight. Next an additional contribution is added: (1-radioweight) * {smoothness * smoothness weight + compactness * (1-smoothness weight)}, where compactness = the Perimeter Length / sqrt( Area ) and smoothness = Perimeter Length / the Bounding Box. The perimeter length is estimated as the number of pixel sides the segment has.


The seeds map can be used to provide either seed pixels (random or selected points from which to start the segmentation process) or seed segments (results of previous segmentations or classifications). The different approaches are automatically detected by the program: any pixels that have identical seed values and are contiguous will be lumped into a single segment ID.

It is expected that the minsize will be set to 1 if a seed map is used, but the program will allow other values to be used. If both options are used, the final iteration that ignores the threshold also will ignore the seed map and force merges for all pixels (not just segments that have grown/merged from the seeds).

Maximum number of starting segments

For the region growing algorithm without starting seeds, each pixel is sequentially numbered. The current limit with CELL storage is 2 billion starting segment ID's. If the initial map has a larger number of non-null pixels, there are two workarounds:

1. Use starting seed pixels. (Maximum 2 billion pixels can be labeled with positive integers.)

2. Use starting seed segments. (By initial classification or other methods.)

Boundary Constraints

Boundary constraints limit the adjacency of pixels and segments. Each unique value present in the bounds raster are considered as a MASK. Thus no segments in the final segmentated map will cross a boundary, even if their spectral data is very similar.

Minimum Segment Size

To reduce the salt and pepper affect, a minsize greater than 1 will add one additional pass to the processing. During the final pass, the threshold is ignored for any segments smaller then the set size, thus forcing very small segments to merge with their most similar neighbor.


This example uses the ortho photograph included in the NC Sample Dataset. Set up an imagery group: group=ortho_group input=ortho_2001_t792_1m@PERMANENT

Because the segmentation process is computationally expensive, start with a small processing area to confirm if the segmentation results meet your requirements. Some manual adjustment of the threshold may be required.

g.region raster=ortho_2001_t792_1m@PERMANENT n=220400 s=220200 e=639000 w=638800
Try out a first threshold and check the results.
i.segment -w -l group=ortho_group output=ortho_segs threshold=4 \

From a visual inspection, it seems this results in oversegmentation. Increasing the threshold:
i.segment -w -l --overwrite group=ortho_group output=ortho_segs \
          threshold=10 method=region_growing

This looks better. There is some noise in the image, lets next force all segments smaller then 5 pixels to be merged into their most similar neighbor (even if they are less similar then required by our threshold):
i.segment -w -l --overwrite group=ortho_group output=ortho_segs \
          threshold=10 method=region_growing minsize=5

Each of these segmentation steps took less then 1 minute on a decent machine. Now that we are satisfied with the settings, we'll process the entire image:
g.region raster=ortho_2001_t792_1m@PERMANENT
i.segment -w -l --overwrite group=ortho_group output=ortho_segs \ threshold=10 method=region_growing minsize=5 endt=5000

Processing the entire ortho image (over 9 million pixels) took about a day.



Use of Segmentation Results




If the seeds map is used to give starting seed segments, the segments are renumbered starting from 1. There is a chance a segment could be renumbered to a seed value that has not yet been processed. If they happen to be adjacent, they would be merged. (Possible fixes: a. use a processing flag to make sure the pixels hasn't been previously used, or b. use negative segment ID's as a placeholder and negate all values after the seed map has been processed.)


This project was first developed during GSoC 2012. Project documentation, Image Segmentation references, and other information is at the project wiki.

Information about classification in GRASS GIS is also available on the wiki.

SEE ALSO, i.maxlik, r.fuzzy, i.smap, r.seg (Addon)


Eric Momsen - North Dakota State University

GSoC mentor: Markus Metz


Available at: i.segment.gsoc source code (history)

Latest change: Monday Jun 24 13:07:24 2024 in commit: 71dbc88614ccda943c73db28f3531855610f6146

Main index | Imagery index | Topics index | Keywords index | Graphical index | Full index

© 2003-2024 GRASS Development Team, GRASS GIS 8.3.3dev Reference Manual