Novel Image Super pixel Segmentation Approach Using LRW

ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
Novel Image Super pixel Segmentation Approach Using LRW
Algorithm
R.Prabha1,C.Kohila 2
1
PG Scholar,[email protected] college of Engineering,Karur, India
Assistant Professor,[email protected],M.Kumarasamy college of engineering,Karur , India
2
Abstract
Super pixels are becoming increasingly popular for use in computer vision applications. Image
segmentation is the process of partitioning a digital image into multiple segments (known as super
pixels). The superpixel segmentation process is employed by identifying similar regions in the images and
grouping the pixels into regions. The lazy random walk approach identifies the similarities between the
neighbouring regions and grouping the similar regions. The similar pixels were identified based on the
intensity of the image pixels. The initial seed region is given. The initial seed region denoted the intensity
of the required object in the image. The regions that are having similar properties as the initial seed
region is selected. The probabilities for each pixels to belong to a region is identified and the pixels that
are having highest probability were assigned into the region. The super pixel segmentation process
identifies the similar pixels and groups them into a region. The centre position of each region is
identified. The neighbouring regions were selected and the pixels belonging to the regions were
identified. If the similarity between the pixels were high means then the regions were grouped. This is
based on the optimization techniques. Finally the object regions and the other regions were separately
identified. The performance of the process is measured. The measured performance of the process
denotes that the segmentation accuracy obtained is high compared to the normal superpixel segmentation
which is due to the addition of the optimization technique.
Keywords: Lazy Random Walk, Seed position, Commute time, Optimization, Superpixel.
1. Introduction
Superpixel are defined as contracting and grouping uniform pixels in the image, which have been widely used
in many computer vision applications such as image segmentation and object recognition. Compared to the
traditional pixel representation of the image, the superpixel representation greatly reduces the number of image
primitives and improves the representative efficiency. Furthermore, it is more convenient and effective to compute
the region based visual features by superpixels, which will provide the important benefits for the vision tasks such as
object recognition.
The properties of superpixel segmentation should not only adhere well to object boundaries of image, but also
maintain the compact constrains in the complicated texture regions. it is still challenging to develop a high quality
superpixel which avoids the under- segmentation and locals groups the pixels respecting the intensity boundaries.
Our LRW algorithm with self-loops effectively solves the segmentation problem in weak boundary and
complex texture regions. On the other hand, the LRW based superpixel algorithm may suffer from the sensitiveness
of the initial seed positions. In order to overcome these limitations and improve the performance, we further develop
a new superpixel optimization approach by introducing an energy optimization framework. Our superpixel
optimization strategy is essentially a compactness constraint, which ensures the resulting superpixel to distribute
uniformly with the homogeneous size by relocation and splitting mechanism.
Our energy function is composed of two items, the first data item adaptively optimizes the positions of seed
points to make the superpixel boundaries adhere to the object boundaries well, and the second smooth item
adaptively divides the large superpixel into small ones to make the superpixel more homogeneous. According to
these relocated seed positions and newly created seeds by the splitting scheme, our LRW algorithm is executed
again to optimize the initial superpixel, which makes the boundaries of final superpixel adhere to object boundaries
364
ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
very well.
The existing superpixel approaches can be roughly classified into two categories. The first category is the
algorithms that do not consider the compactness constrains during the superpixel generation procedure, such as
meanshift [4], and graph based [7] algorithms. The second category of superpixel algorithms considers the
compactness constrains, such as normalized cuts, lattice cut, TurboPixels, and graph cut approaches. Ren and Malik
[11] proposed an image superpixel approach to segment the image into a large number of small compact and
homogeneous regions by the normalized cuts.
Fig. 1: The workflow of our LRW based super pixel method.
(a) Input image; (b) initial super pixels by LRW and seed points (red “o”); (c) seeds relocation by super pixels
optimization (yellow “+” is the relocated seeds from the original positions in (b), and yellow arrow “→” denotes the
motion of some seed); (d) super pixel refinement by our LRW method with updated center positions (red “+”); (e)
seeds relocation and newly created super pixels with their center positions (green “+”) by super pixels optimization;
(f) super pixel refinement by LRW; (g) final super pixels. Note that steps (c) to (f) (rectangle with dash lines) are
performed iteratively until the final super pixels are obtained.
2. Lazy Random Walk Algorithm
Random walk algorithm has been used to separate the foreground and background of images with quality of
segmentation. Even RW produce a weak boundaries and complex texture region In order to overcome the
difficulties LRW (Lazy Random Walk) algorithm used. These algorithms are extensively for interactive image
segmentation and computer vision application.
Random walk algorithm first calculate probability for each pixel then find the maximum probability of each
label that is consider as a seed position of each label.RW starts from a pixel must arrive at the position of prelabeled
seed and thus it only considers the local relationship between the current pixel and other seed points.To get a quality
of segmentation global relationships used in LRW because of the local relationship it may produce weak boundary
to solve this self loops are introduced in LRW due to the self loops in LRW to make RW process lazy this is mainly
used in mining and website data classifying application.
Lazy Random Walk is a two-fold algorithm that is shown in bellow figure 2.first one self-loop is added to the
vertex to ensure the boundary constrains. Since a vertex with a heavy self-loop is more likely to absorb its
neighboring pixels than the one with light self-loop, which makes the vertex to absorb and capture both the weak
boundary and texture information with self-loops.
On the other hand, instead of starting from the pixels to the seed points as the original RW algorithm does, our
LRW algorithm computes the commute time from the seed points to other pixels. The probability maps by our LRW
approach give more confident separation than the ones by RW method. Therefore, our LRW algorithm significantly
outperforms the original RW algorithm on the test images with the same background and foreground seed scribbles.
365
ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
Fig. 2. Illustration the structure of RW and LRW algorithms with their comparison results.
(a) Traditional RW method without self-loops; (b) our LRW algorithm with self-loops; (c) input images
with user seeds (scribbles); (d) and (e) are the probability maps by RW and LRW algorithms; (f) and (g) are the
segmentation results by RW and our LRW method. Image segmentation result by our LRW algorithm has the better
performance than the one by classic RW method with the same user scribbles (green for foreground and blue for
background), especially in the leg regions of wolf and the flower parts.
3. LRW Based Superpixel Initialization
Our aim is to make super pixel spread over the input image as much as possible. LRW methods begin with
initial super pixel seeds on the input image. We first place K circular seeds in a lattice formation, and the distance
between lattice neighbors is equal to √N/K where N is the total number of pixels in the image. This strategy ensures
that the super pixels will be evenly distributed on the whole image.
However, this placement strategy may cause some seeds too occasionally close to a strong edge because these
images are not completely uniform distribution. Thus, the initial seed position is perturbed by moving it along its
gradient direction according to the seed density.
After we have finished the seed initialization stage, we then use the LRW algorithm to compute the boundaries
of super pixels. At each step, the LRW algorithm transmits to its neighborhood with the probability which is
proportional to the aforementioned edge-weight wij. The LRW algorithm will converge at a pixel xi with the
boundary likelihood probabilities flk (xi) of super pixels. Finally, we obtain the labeled boundaries of super pixels
from the commute time as follows:
R(xi) = arglkminCT(clk,xi) = arglkmax flk(xi) (1)
Where clk denotes the center of the I-th super pixel, and the label lk is assigned to each pixel xi to obtain the
boundaries of super pixels. Algorithm 1 gives the main steps of our LRW based super pixel initialization algorithm.
Algorithm 1: LRW Based superixel Initialization Algorithm
Input: Input image I(xi) and an integer of initial seeds K
Step 1: Define an adjacency matrix W= [wij]M×N
Step 2: Construct the matrix S =D-1/2WD-1/2
Step 3: compute flk = (I-αS)-1ylk
Step 4: compute R(xi) = arglkminCT(clk,xi) to obtain the labels by assigning label R(xi) to each pixel xi
Step 5: Obtain Superpixels by Slk= { xi | R(xi) = lk} where {i=1,…,N} and {k=1,…,K}
Output: the initial superpixel results slk
4. Superpixel Optimization
4.1. Optimization
This optimization should contain that the super pixel boundaries adhere well to image intensity boundaries and
also make with regular uniform size in complicated texture regions the optimization new energy function .
366
ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
E = ∑(Area(Sl)-Area(ŝ))2 +∑ŵxCT(cln,x)2
(2)
Where the first term is the data item and the second term is the smooth item. The data item makes the
texture information of image to be distributed uniformly in the super pixels, which produces more homogeneous
super pixels. The smooth item makes the boundaries of super pixels to be more consistent with the object boundaries
in the image. Area(Sl) is the area of super pixel and Area( ¯S) defines the average area of super pixels.
Algorithm 2: Superpixel Optimization Algorithm
Input: Initial Superpixels Sl and an integer Nsp
Step 1: Apply Equation (1) to obtain the new Cln
Step 2: Apply equation (2) to get the new Clnew,1 and Clnew,2
Step 3: Refine Sl,Cln, Clnew,1 and Clnew,2
Step 4: Run steps 1 to 3 iteratively until convergence
Output: The final optimized superpixel results
4.2. System Architecture
Pre Processing
Initially the input images are preprocessed, in order to improve the quality of the images we normally employ
some filtering operations. Median filter is used for filtering. The median filter considers each pixel in the image in
turn and looks at its nearby neighbors to decide whether or not it is representative of its surroundings. Instead of
simply replacing the pixel value with the median of neighboring pixel values, The median is calculated by first
sorting all the pixel values from the surrounding neighborhood into numerical order and then replacing the pixel
being considered with the middle pixel value.
Input
image
Pre-Processing
Superpixel
Segmentation
Analysis
LRW
Optimization
Seed Point
selection
Fig 3: Modules of LRW Algorithm
Seed Selection
It is computationally efficient: it reduces the complexity of images from hundreds of thousands of pixels to
only a few hundred superpixels. It is also representationally efficient: pairwise constraints between units, while only
for adjacent pixels on the pixel-grid, can now model much longer-range interactions between superpixels. The
superpixels are percetually meaningful: each superpixel is a perceptually consistent unit, i.e. all pixels in a
superpixel are most likely uniform in, say, color and texture. It is near-complete: because superpixels are results of
an oversegmentation, most structures in the image are conserved. There is very little loss in moving from the pixelgrid to the superpixel map.
Superpixel Segmentation
Superpixel segmentation is an important module for many computer vision applications such as object
recognition, image segmentation and single view 3D reconstruction. A superpixel is commonly defined as a
perceptually uniform region in the image. A superpixel representation greatly reduces the number of image
primitives compared to the pixel representation. The desired properties of superpixel segmentation depends on the
application of interest. Here we list some general properties required by various vision applications: Every
superpixel should overlap with only one object. The set of superpixel boundaries should be a superset of object
boundaries. The mapping from pixels to superpixels should not reduce the achievable performance of the intended
application. The above properties should be obtained with as few superpixels as possible.
367
ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
LRW Optimization
It will be sometime convenient to consider a slight variation of random walk, in which in each step, with
probability 1= 2, Staying at the current vertex and only with probability 1 = 2. Its make the usual step of random
walk. This variation is called lazy random walk and it can be viewed as a vanilla version of random walk in a graph
in which we added d (u) self-loops to every vertex u. Our LRW algorithm with self loops effectively solves the
segmentation problem in weak boundary and complex texture regions. On the other hand, the LRW based superpixel
algorithm may suffer from the sensitiveness of the initial seed positions.
Performance analysis
Accuracy is measured and analyzed performance with the previous process. Accuracy and Error rate are the
best in proposed approach compared with prior work. The simplicity, efficiency and the performance of the
algorithm make it faster and more practical for real-time systems than other existing superpixel segmentation
methods. Segmentation performance that context-aware approach of motivated us to pursue a training method for a
superpixel classifier with even some of examples while retaining the accuracy of that learned on complete
groundtruth.
4.3.Quantitative Comparision With Other Algorithms
There are three commonly used evaluation measures to evaluate the performance of superpixel algorithms. These
measures include the under segmentation error (UE), the boundary recall (BR), and the achievable segmentation
accuracy (ASA), In order to quantitatively compare our superpixel algorithm to the existing algorithms, we adopt
these three metric measures to evaluate our algorithm.

Under-Segmentation Error: A good superpixel algorithm should try to avoid the under-segmentation areas
in the segmentation results. In other words, we need to make sure that a superpixel only overlaps one
object. This evaluation measurement checks the deducting area by the superpixel that overlaps the given
ground-truth segmentation.
Fig 4:Comparision Results of Error Rate

Boundary Recall: Precise boundary is an important metric for measuring the performance of superpixel
algorithms by considering the boundary adherence. A superpixel algorithm with good ability to adhere well
to the object boundaries would improve the segmentation performance. Boundary recall measurement
computes the ratio of the ground truth boundaries that fall within the nearest superpixel boundaries.
368
ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
Fig 5:Comparision results of Boundary Recall

Achievable Segmentation Accuracy: These metric measures whether the objects in the image are correctly
recognized. In other words, ASA computes the highest achievable accuracy by labeling each superpixel
with the label of ground truth segmentation that has the biggest overlap area.
Fig 6:Comparision results of Accuracy Rate
5. Conclusion
We have presented a novel image super pixel approach using the LRW and energy optimization algorithm in
this paper. Our method first runs the LRW algorithm to obtain the initial super pixel results by placing the seed
positions on input image. Then we further optimize the labels of super pixels to improve the regularity and boundary
adherence performance by relocating the center positions of super pixels and dividing the large super pixels into
small uniform ones in an energy optimization framework. The experimental results have demonstrated that our super
pixel algorithm achieves better performance than the previous well-known super pixel approaches. Our algorithm is
capable of obtaining the good boundary adherence in the complicated texture and weak boundary regions, and also
this LRW method increase the iteration. Further, the iteration is reduced by using fuzzy k-means clustering with
ACO.
369
ISSN: 2393-994X
KARPAGAM JOURNAL OF ENGINEERING RESEARCH (KJER)
Volume No.: II, Special Issue on IEEE Sponsored International Conference on Intelligent Systems and Control (ISCO’15)
Acknowledgment
I would like to thank authors, mentioned in the references which are citied below for their valuable research
works which helped me to gain knowledge. And also I thank my guide for her precious guidance .
Reference
1.IEEE Transcation
[1].A. Moore, S. Prince, and J. Warrel, “Lattice cut—Constructing superpixels using layer constraints,”.(2010).
2.IEEE Transcation
[2].A. Moore, S. Prince, J. Warrell, U. Mohammed, and G. Jones, “Superpixel lattices,”(2008).
3.IEEE Transcation
[3].A. Levinshtein, A. Stere, K. Kutulakos, D. Fleet, S. Dickinson, and K. Siddiqi, “Turbopixels: Fast superpixels
using geometric flows,”(2009).
4.IEEE Transcation
[4].D. Comaniciu and P. Meer, “Mean shift: A robustapproach toward feature space analysis,”(2002).
5.IEEE Transcation
[5].L. Grady, “Random walks for image segmentation,”(2006).
6.IEEE Transcation
.T. Pätz and T. Preusser, “Segmentation of stochastic images with astochastic random walker method,” (2012).
7.IEEE Transcation
[7].V. Gopalakrishnan, Y. Hu, and D. Rajan, “Random walks on graphs forsalient object detection in images,”
(2010).
8.IEEE ICCV
[8].X. Bai and G. Sapiro, “A geodesic framework for fast interactive image and video segmentation and
matting,”(2007).
9.IEEE ICCV
[9].X. Ren and J. Malik, “Learning a classification model for segmentation,”(2003).
10.IEEE CVPR
[10].Z. Li, X. M. Wu, and S. F. Chang, “Segmentation using superpixels:A bipartite graph partitioning
approach,”(2012).
370