boofcv.alg.segmentation.ms.ClusterLabeledImage Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of feature Show documentation
Show all versions of feature Show documentation
BoofCV is an open source Java library for real-time computer vision and robotics applications.
/*
* Copyright (c) 2011-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of BoofCV (http://boofcv.org).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package boofcv.alg.segmentation.ms;
import boofcv.alg.misc.ImageMiscOps;
import boofcv.struct.ConnectRule;
import boofcv.struct.image.ImageSInt32;
import georegression.struct.point.Point2D_I32;
import org.ddogleg.struct.GrowQueue_I32;
/**
*
* Given a labeled image in which pixels that contains the same label may or may not be connected to each other,
* create a new labeled image in which only connected pixels have the same label.
* A two pass algorithm is used. In the first pass pixels are examined from top to bottom, left to right. For
* each pixel (the target), the input image and output image labels of its adjacent pixels are examined. If an adjacent
* pixel has the same input label as the target then it is either assigned the same output label or marked for being
* merged. Depending if it is not labeled or has an output label already, respectively. After all the pixels are process
* the merge requests are examined and a new set of output labels is created. A pass across the output image is
* done to relabel the inputs.
*
*
*
* Clustering can be done using 4 or 8 connect, which defines what an adjacent pixel is. 4-connect just considers
* pixels which are (+1,0) (0,1) (-1,0) (0,-1). 8-connect considers (+1,0) (0,1) (-1,0) (0,-1) and
* (1,1) (-1,1) (-1,-1) (1,-1).
*
*
* @author Peter Abeles
*/
public class ClusterLabeledImage extends RegionMergeTree {
// which connectivity rule is used. 4 or 8.
protected ConnectRule connectRule;
// offset in pixel indices for adjacent pixels
protected int edgesIn[];
protected int edgesOut[];
// relative coordinates of adjacent pixels
protected Point2D_I32 edges[];
// contains the number of pixels in each output label
protected GrowQueue_I32 regionMemberCount;
/**
* Configures labeling
*
* @param connectRule Which connectivity rule to use. 4 or 8
*/
public ClusterLabeledImage(ConnectRule connectRule) {
this.connectRule = connectRule;
if( connectRule == ConnectRule.EIGHT ) {
edgesIn = new int[4];
edgesOut = new int[4];
edges = new Point2D_I32[4];
} else if( connectRule == ConnectRule.FOUR ) {
edgesIn = new int[2];
edgesOut = new int[2];
edges = new Point2D_I32[2];
} else {
throw new IllegalArgumentException("connectRule must be 4 or 8");
}
for( int i = 0; i < edges.length; i++ )
edges[i] = new Point2D_I32();
}
/**
* Declares lookup tables for neighbors
*/
protected void setUpEdges( ImageSInt32 input , ImageSInt32 output ) {
if( connectRule == ConnectRule.EIGHT ) {
setUpEdges8(input,edgesIn);
setUpEdges8(output,edgesOut);
edges[0].set( 1, 0);
edges[1].set( 1, 1);
edges[2].set( 0, 1);
edges[3].set(-1, 0);
} else {
setUpEdges4(input,edgesIn);
setUpEdges4(output,edgesOut);
edges[0].set( 1,0);
edges[1].set( 0, 1);
}
}
protected void setUpEdges8( ImageSInt32 image , int edges[] ) {
edges[0] = 1;
edges[1] = 1 + image.stride;
edges[2] = + image.stride;
edges[3] = -1 + image.stride;
}
protected void setUpEdges4( ImageSInt32 image , int edges[] ) {
edges[0] = 1;
edges[1] = + image.stride;
}
/**
* Relabels the image such that all pixels with the same label are a member of the same graph.
*
* @param input Labeled input image.
* @param output Labeled output image.
* @param regionMemberCount (Input/Output) Number of pixels which belong to each group.
*/
public void process( ImageSInt32 input , ImageSInt32 output , GrowQueue_I32 regionMemberCount ) {
// initialize data structures
this.regionMemberCount = regionMemberCount;
regionMemberCount.reset();
setUpEdges(input,output);
ImageMiscOps.fill(output,-1);
// this is a bit of a hack here. Normally you call the parent's init function.
// since the number of regions is not initially known this will grow
mergeList.reset();
connectInner(input, output);
connectLeftRight(input, output);
connectBottom(input, output);
// Merge together all the regions that are connected in the output image
performMerge(output, regionMemberCount);
}
/**
* Examines pixels inside the image without the need for bounds checking
*/
protected void connectInner(ImageSInt32 input, ImageSInt32 output) {
int startX = connectRule == ConnectRule.EIGHT ? 1 : 0;
for( int y = 0; y < input.height-1; y++ ) {
int indexIn = input.startIndex + y*input.stride + startX;
int indexOut = output.startIndex + y*output.stride + startX;
for( int x = startX; x < input.width-1; x++ , indexIn++, indexOut++) {
int inputLabel = input.data[indexIn];
int outputLabel = output.data[indexOut];
if( outputLabel == -1 ) { // see if it needs to create a new output segment
output.data[indexOut] = outputLabel = regionMemberCount.size;
regionMemberCount.add(1);
mergeList.add(outputLabel);
}
for( int i = 0; i < edgesIn.length; i++ ) {
if( inputLabel == input.data[indexIn+edgesIn[i]] ) {
int outputAdj = output.data[indexOut+edgesOut[i]];
if( outputAdj == -1 ) { // see if not assigned
regionMemberCount.data[outputLabel]++;
output.data[indexOut+edgesOut[i]] = outputLabel;
} else if( outputLabel != outputAdj ) { // see if assigned to different regions
markMerge(outputLabel,outputAdj);
} // do nothing, same input and output labels
}
}
}
}
}
/**
* Examines pixels along the left and right border
*/
protected void connectLeftRight(ImageSInt32 input, ImageSInt32 output) {
for( int y = 0; y < input.height; y++ ) {
int x = input.width-1;
int inputLabel = input.unsafe_get(x, y);
int outputLabel = output.unsafe_get(x, y);
if( outputLabel == -1 ) { // see if it needs to create a new output segment
outputLabel = regionMemberCount.size;
output.unsafe_set(x,y,outputLabel);
regionMemberCount.add(1);
mergeList.add(outputLabel);
}
// check right first
for( int i = 0; i < edges.length; i++ ) {
Point2D_I32 offset = edges[i];
// make sure it is inside the image
if( !input.isInBounds(x+offset.x,y+offset.y))
continue;
if( inputLabel == input.unsafe_get(x+offset.x,y+offset.y) ) {
int outputAdj = output.unsafe_get(x+offset.x,y+offset.y);
if( outputAdj == -1 ) { // see if not assigned
regionMemberCount.data[outputLabel]++;
output.unsafe_set(x+offset.x,y+offset.y, outputLabel);
} else if( outputLabel != outputAdj ) { // see if assigned to different regions
markMerge(outputLabel,outputAdj);
} // do nothing, same input and output labels
}
}
// skip check of left of 4-connect
if( connectRule != ConnectRule.EIGHT )
continue;
x = 0;
inputLabel = input.unsafe_get(x, y);
outputLabel = output.unsafe_get(x, y);
if( outputLabel == -1 ) { // see if it needs to create a new output segment
outputLabel = regionMemberCount.size;
output.unsafe_set(x,y,outputLabel);
regionMemberCount.add(1);
mergeList.add(outputLabel);
}
for( int i = 0; i < edges.length; i++ ) {
Point2D_I32 offset = edges[i];
// make sure it is inside the image
if( !input.isInBounds(x+offset.x,y+offset.y))
continue;
if( inputLabel == input.unsafe_get(x+offset.x,y+offset.y) ) {
int outputAdj = output.unsafe_get(x+offset.x,y+offset.y);
if( outputAdj == -1 ) { // see if not assigned
regionMemberCount.data[outputLabel]++;
output.unsafe_set(x+offset.x,y+offset.y, outputLabel);
} else if( outputLabel != outputAdj ) { // see if assigned to different regions
markMerge(outputLabel,outputAdj);
} // do nothing, same input and output labels
}
}
}
}
/**
* Examines pixels along the bottom border
*/
protected void connectBottom(ImageSInt32 input, ImageSInt32 output) {
for( int x = 0; x < input.width-1; x++ ) {
int y = input.height-1;
int inputLabel = input.unsafe_get(x,y);
int outputLabel = output.unsafe_get(x,y);
if( outputLabel == -1 ) { // see if it needs to create a new output segment
outputLabel = regionMemberCount.size;
output.unsafe_set(x,y,outputLabel);
regionMemberCount.add(1);
mergeList.add(outputLabel);
}
// for 4 and 8 connect the check is only +1 x and 0 y
if( inputLabel == input.unsafe_get(x+1,y) ) {
int outputAdj = output.unsafe_get(x+1,y);
if( outputAdj == -1 ) { // see if not assigned
regionMemberCount.data[outputLabel]++;
output.unsafe_set(x+1,y, outputLabel);
} else if( outputLabel != outputAdj ) { // see if assigned to different regions
markMerge(outputLabel,outputAdj);
} // do nothing, same input and output labels
}
}
}
}