edges
Structured Edge Detection Toolbox
view repo
Edge detection is a critical component of many vision systems, including object detectors and image segmentation algorithms. Patches of edges exhibit wellknown forms of local structure, such as straight lines or Tjunctions. In this paper we take advantage of the structure present in local image patches to learn both an accurate and computationally efficient edge detector. We formulate the problem of predicting local edge masks in a structured learning framework applied to random decision forests. Our novel approach to learning decision trees robustly maps the structured labels to a discrete space on which standard information gain measures may be evaluated. The result is an approach that obtains realtime performance that is orders of magnitude faster than many competing stateoftheart approaches, while also achieving stateoftheart edge detection results on the BSDS500 Segmentation dataset and NYU Depth dataset. Finally, we show the potential of our approach as a general purpose edge detector by showing our learned edge models generalize well across datasets.
READ FULL TEXT VIEW PDF
Local structures of shadow boundaries as well as complex interactions of...
read it
We propose a new approach to image segmentation, which exploits the
adva...
read it
Superpixel segmentation is becoming ubiquitous in computer vision. In
pr...
read it
Edge detection is among the most fundamental vision problems for its rol...
read it
This paper proposes a Deep Learning based edge detector, which is inspir...
read it
Recent advances in the area of plane segmentation from single RGB images...
read it
A fundamental question for edge detection in noisy images is how faint c...
read it
Structured Edge Detection Toolbox
The testing code for deep contour detector
Structured Edge Detection Toolbox
Structured Edge Detection Toolbox
None
Edge detection has remained a fundamental task in computer vision since the early 1970’s
[Fram1975IEEE, Duda1973BOOK, Robinson1977OE]. The detection of edges is a critical preprocessing step for a variety of tasks, including object recognition [UllmanPAMI91, Ferrari2008PAMI], segmentation [Malik2001IJCV, Arbelaez2011PAMI], and active contours [Kass1988IJCV]. Traditional approaches to edge detection use a variety of methods for computing color gradients followed by nonmaximal suppression [Canny1986PAMI, Freeman91PAMI, Ziou1998PR]. Unfortunately, many visually salient edges do not correspond to color gradients, such as texture edges [Martin2004PAMI] and illusory contours [Ren2005ICCV]. Stateoftheart edge detectors [Arbelaez2011PAMI, Ren2012NIPS, Lim2013CVPR, Gupta2013CVPR] use multiple features as input, including brightness, color, texture and depth gradients computed over multiple scales.Since visually salient edges correspond to a variety of visual phenomena, finding a unified approach to edge detection is difficult. Motivated by this observation several recent papers have explored the use of learning techniques for edge detection [Dollar2006CVPR, Zheng07CVPR, Lim2013CVPR, Kivinen2014AISTATS]. These approaches take an image patch and compute the likelihood that the center pixel contains an edge. Optionally, the independent edge predictions may then be combined using global reasoning [Arbelaez2011PAMI, Ren2012NIPS, Zheng07CVPR, Arbelaez2014CVPR].
Edges in a local patch are highly interdependent [Lim2013CVPR]. They often contain wellknown patterns, such as straight lines, parallel lines, Tjunctions or Yjunctions [Ren2006ECCV, Lim2013CVPR]. Recently, a family of learning approaches called structured learning [Nowozin2011foundations] has been applied to problems exhibiting similar characteristics. For instance, [Kontschieder2011ICCV] applies structured learning to the problem of semantic image labeling for which local image labels are also highly interdependent.
In this paper we propose a generalized structured learning approach that we apply to edge detection. This approach allows us to take advantage of the inherent structure in edge patches, while being surprisingly computationally efficient. We can compute edge maps in realtime, which is orders of magnitude faster than competing stateoftheart approaches. A random forest framework is used to capture the structured information
[Kontschieder2011ICCV]. We formulate the problem of edge detection as predicting local segmentation masks given input image patches. Our novel approach to learning decision trees uses structured labels to determine the splitting function at each branch in the tree. The structured labels are robustly mapped to a discrete space on which standard information gain measures may be evaluated. Each forest predicts a patch of edge pixel labels that are aggregated across the image to compute our final edge map, see Figure 1. Since the aggregated edge maps may be diffuse, the edge maps may optionally be sharpened using local color and depth cues. We show stateoftheart results on both the BSDS500 [Arbelaez2011PAMI] and the NYU Depth dataset [Silberman2012ECCV]. We demonstrate the potential of our approach as a general purpose edge detector by showing the strong cross dataset generalization of our learned edge models.We now discuss related work in edge detection and structured learning. An earlier version of this work appeared in [Dollar2013ICCV].
Edge detection: Numerous papers have been written on edge detection over the past 50 years. Early work [Fram1975IEEE, Duda1973BOOK, Canny1986PAMI, Perona1990PAMI, Freeman91PAMI] focused on the detection of intensity or color gradients. The popular Canny detector [Canny1986PAMI] finds the peak gradient orthogonal to edge direction. An evaluation of various lowlevel edge detectors can be found in [Bowyer2001CVIU] and an overview in [Ziou1998PR]. More recent work [Martin2004PAMI, Mairal2008ECCV, Kokkinos2010ECCV, Arbelaez2011PAMI, Widynski2012ECCV, Leordeanu2014PAMI] explores edge detection under more challenging conditions.
Several techniques have explored the use of learning for edge detection [Dollar2006CVPR, Zheng07CVPR, Mairal2008ECCV, Ren2012NIPS, Lim2013CVPR, Kivinen2014AISTATS]. Dollár et al. [Dollar2006CVPR]
used a boosted classifier to independently label each pixel using its surrounding image patch as input. Zheng et al.
[Zheng07CVPR] combine low, mid, and highlevel cues and show improved results for objectspecific edge detection. Ren and Bo [Ren2012NIPS] improved the result of [Arbelaez2011PAMI] by computing gradients across learned sparse codes of patch gradients. While [Ren2012NIPS] achieved good results, their approach further increased the high computational cost of [Arbelaez2011PAMI]. Catanzaro et al. [Catanzaro2009ICCV] improve the runtime of [Arbelaez2011PAMI] using parallel algorithms. Recently, Kivinen et al. [Kivinen2014AISTATS] applied deep networks to edge detection achieving competitive results.Finally, Lim et al. [Lim2013CVPR] propose an edge detection approach that classifies edge patches into sketch tokens using random forest classifiers, that, like in our work, attempt to capture local edge structure. Sketch tokens bear resemblance to earlier work on shapemes [Ren2006ECCV] but are computed directly from color image patches rather than from precomputed edge maps. The result is an efficient approach for detecting edges that also shows promising results for object detection. In contrast to previous work, we do not require the use of predefined classes of edge patches. This allows us to learn more subtle variations in edge structure and leads to a more accurate and efficient algorithm.
Structured learning: Structured learning addresses the problem of learning a mapping where the input or output space may be arbitrarily complex representing strings, sequences, graphs, object pose, bounding boxes etc. [Tsochantaridis2004ICML, Taskar2005ICML, Blaschko2008ECCV]. We refer readers to [Nowozin2011foundations] for a comprehensive survey.
Our structured random forests differ from these works in several respects. First, we assume that the output space is structured but operate on a standard input space. Second, by default our model can only output examples observed during training, which implicitly assumes the existence of a set of representative samples (this shortcoming can be ameliorated with custom ensemble models). On the other hand, typical structured predictors learn parameters to a scoring function and at inference perform an optimization to obtain predictions [Tsochantaridis2004ICML, Nowozin2011foundations]. This requires defining a scoring function and an efficient (possibly approximate) inference procedure. In contrast, inference using our structured random forest is straightforward, general and fast (same as for standard random forests).
Finally, our work was inspired by recent work from Kontschieder et al. [Kontschieder2011ICCV] on learning random forests for structured class labels for the specific case where the output labels represent a semantic image labeling for an image patch. The key observation made by Kontschieder et al. is that given a color image patch, the leaf node reached in a tree is independent of the structured semantic labels, and any type of output can be stored at each leaf. Building on this, we propose a general learning framework for structured output forests that can be used with a broad class of output spaces. We apply our framework to learning an accurate and fast edge detector.
We begin with a review of random decision forests [Breiman1984BOOK, Breiman01ML, Geurts2006ML]. Throughout our presentation we adopt the notation and terminology of the extensive recent survey by Criminisi et al. [Criminisi12FT], somewhat simplified for ease of presentation. The notation in [Criminisi12FT] is sufficiently general to support our extension to random forests with structured outputs.
A decision tree classifies a sample by recursively branching left or right down the tree until a leaf node is reached. Specifically, each node in the tree is associated with a binary split function:
(1) 
with parameters . If node sends left, otherwise right, with the process terminating at a leaf node. The output of the tree on an input is the prediction stored at the leaf reached by , which may be a target label or a distribution over the labels .
While the split function may be arbitrarily complex, a common choice is a ‘stump’ where a single feature dimension of is compared to a threshold. Specifically, and , where denotes the indicator function. Another popular choice is and . Both are computationally efficient and effective in practice [Criminisi12FT].
A decision forest is an ensemble of independent trees . Given a sample , the predictions from the set of trees are combined using an ensemble model into a single output. Choice of ensemble model is problem specific and depends on , common choices include majority voting for classification and averaging for regression, although more sophisticated ensemble models may be employed [Criminisi12FT].
Observe that arbitrary information may be stored at the leaves of a decision tree. The leaf node reached by the tree depends only on the input , and while predictions of multiple trees must be merged in some useful way (the ensemble model), any type of output can be stored at each leaf. This allows use of complex output spaces , including structured outputs as observed by Kontschieder et al. [Kontschieder2011ICCV].
While prediction is straightforward, training random decision forests with structured is more challenging. We review the standard learning procedure next and describe our generalization to learning with structured outputs in §3.
Each tree is trained independently in a recursive manner. For a given node and training set , the goal is to find parameters of the split function that result in a ‘good’ split of the data. This requires defining an information gain criterion of the form:
(2) 
where , . Splitting parameters are chosen to maximize the information gain ; training then proceeds recursively on the left node with data and similarly for the right node. Training stops when a maximum depth is reached or if information gain or training set size fall below fixed thresholds.
For multiclass classification () the standard definition of information gain can be used:
(3) 
where denotes the Shannon entropy and is the fraction of elements in with label . Alternatively the Gini impurity has also been used in conjunction with Eqn. (3) [Breiman1984BOOK].
For regression, entropy and information gain can be extended to continuous variables [Criminisi12FT]. Alternatively, a common approach for singlevariate regression (
) is to minimize the variance of labels at the leaves
[Breiman1984BOOK]. If we write the variance as where , then substituting for entropy in Eqn. (3) leads to the standard criterion for singlevariate regression.Can we define a more general information gain criterion for Eqn. (2) that generalizes well for arbitrary output spaces ? Surprisingly yes, given mild additional assumptions about . Before going into detail in §3, we discuss the key role that randomness plays in the training of decision forests next.
Individual decision trees exhibit high variance and tend to overfit [Ho1998PAMI, Breiman1984BOOK, Breiman01ML, Geurts2006ML]. Decision forests ameliorate this by training multiple decorrelated trees and combining their output. A crucial component of the training procedure is therefore to achieve a sufficient diversity of trees.
Diversity of trees can be obtained either by randomly subsampling the data used to train each tree [Breiman1984BOOK] or randomly subsampling the features and splits used to train each node [Ho1998PAMI]. Injecting randomness at the level of nodes tends to produce higher accuracy models [Geurts2006ML] and has proven more popular [Criminisi12FT]. Specifically, when optimizing Eqn. (2), only a small set of possible are sampled and tested when choosing the optimal split. E.g., for stumps where and , [Geurts2006ML] advocates sampling features where and a single threshold per feature.
In effect, accuracy of individual trees is sacrificed in favor of a high diversity ensemble [Geurts2006ML]. Leveraging similar intuition allows us to introduce an approximate information gain criterion for structured labels, described next, and leads to our generalized structured forest formulation.
In this section we extend random decision forests to general structured output spaces . Of particular interest for computer vision is the case where represents an image patch and encodes the corresponding local image annotation (e.g., a segmentation mask or set of semantic image labels). However, we keep our derivation general.
Training random forests with structured labels poses two main challenges. First, structured output spaces are often high dimensional and complex. Thus scoring numerous candidate splits directly over structured labels may be prohibitively expensive. Second, and more critically, information gain over structured labels may not be well defined.
We use the observation that even approximate measures of information gain suffice to train effective random forest classifiers [Geurts2006ML, Kontschieder2011ICCV]. ‘Optimal’ splits are not necessary or even desired, see §2.2. Our core idea is to map all the structured labels at a given node into a discrete set of labels , where , such that similar structured labels are assigned to the same discrete label .
Given the discrete labels , information gain calculated directly and efficiently over can serve as a proxy for the information gain over the structured labels . As a result at each node we can leverage existing random forest training procedures to learn structured random forests effectively.
Our approach to calculating information gain relies on measuring similarity over . However, for many structured output spaces, including those used for edge detection, computing similarity over is not well defined. Instead, we define a mapping of to an intermediate space in which distance is easily measured. We therefore utilize a broadly applicable twostage approach of first mapping followed by a straightforward mapping of .
We describe the proposed approach in more detail next and return to its application to edge detection in §4.
Our key assumption is that for many structured output spaces, including for structured learning of edge detection, we can define a mapping of the form:
(4) 
such that we can approximate dissimilarity of by computing Euclidean distance in . For example, as we describe in detail in §4, for edge detection the labels are segmentation masks and we define
to be a long binary vector that encodes whether every pair of pixels in
belong to the same or different segments. Distance is easily measured in the resulting space .may be high dimensional which presents a challenge computationally. For example, for edge detection there are unique pixel pairs in a segmentation mask, so computing for every would be expensive. However, as only an approximate distance measure is necessary, the dimensionality of can be reduced.
In order to reduce dimensionality, we sample dimensions of , resulting in a reduced mapping parametrized by . During training, a distinct mapping is randomly generated and applied to training labels at each node . This serves two purposes. First, can be considerably faster to compute than . Second, sampling injects additional randomness into the learning process and helps ensure a sufficient diversity of trees, see §2.2.
Finally, Principal Component Analysis (PCA)
[Joliffe1986BOOK] can be used to further reduce the dimensionality of . PCA denoises while approximately preserving Euclidean distance. In practice, we use with dimensions followed by a PCA projection to at most 5 dimensions.Given the mapping , a number of choices for the information gain criterion are possible. For discrete multivariate joint entropy could be computed directly. Kontschieder et al. [Kontschieder2011ICCV] proposed such an approach, but due to its complexity of , were limited to using . Our experiments indicate is necessary to accurately capture similarities between elements in . Alternatively, given continuous , variance or a continuous formulation of entropy [Criminisi12FT] can be used to define information gain. In this work we propose a simpler, extremely efficient approach.
We map a set of structured labels into a discrete set of labels , where , such that labels with similar are assigned to the same discrete label , see Figure 2. The discrete labels may be binary () or multiclass (). This allows us to use standard information gain criteria based on Shannon entropy or Gini impurity as defined in Eqn. (3). Critically, discretization is performed independently when training each node and depends on the distribution of labels at a given node (contrast with [Lim2013CVPR]).
We consider two straightforward approaches to obtaining the discrete label set given . Our first approach is to cluster into
clusters using Kmeans (projecting
onto 5 dimensions prior to clustering). Alternatively, we can quantize based on the top PCA dimensions, assigning a discrete label according to the orthant (generalization of quadrant) into which falls. Both approaches perform similarly but the latter is slightly faster. We use PCA quantization to obtain labels unless otherwise specified.Finally, we define how to combine a set of labels into a single prediction for both training (to set leaf labels) and testing (to merge predictions). As before, we sample an dimensional mapping and compute for each . We select the label whose is the medoid, i.e. the that minimizes the sum of distances to all other ^{1}^{1}1The medoid minimizes . This is equivalent to and can be computed efficiently in time .. Note that typically we only need to compute the medoid for small (either for training a leaf node or merging the output of multiple trees), hence using a coarse distance metric suffices.
The biggest limitation is that any prediction must have been observed during training; the ensemble model is unable to synthesize novel labels. Indeed, this is impossible without additional information about . In practice, domain specific ensemble models are preferable. For example, in edge detection we apply structured prediction to obtain edge maps for each image patch independently and merge overlapping predictions by averaging (note that in this case structured prediction operates at the patch level and not the image level).
We now describe how to apply our structured forests to edge detection. As input our method takes an image that may contain multiple channels, such as an RGB or RGBD image. The task is to label each pixel with a binary variable indicating whether the pixel contains an edge or not. Similar to the task of semantic image labeling
[Kontschieder2011ICCV], the labels within a small image patch are highly interdependent, providing a promising candidate problem for our structured forest approach.We assume we are given a set of segmented training images, in which the boundaries between the segments correspond to contours [Arbelaez2011PAMI, Silberman2012ECCV]. Given an image patch, its annotation can be specified either as a segmentation mask indicating segment membership for each pixel (defined up to a permutation) or a binary edge map. We use to denote the former and for the latter, where indicates patch width. An edge map can always be trivially derived from segmentation mask , but not vice versa. We utilize both representations in our approach.
Next, we describe how we compute the input features , the mapping functions used to determine splits, and the ensemble model used to combine multiple predictions.
Input features: Our learning approach predicts a structured segmentation mask from a larger image patch. We begin by augmenting each image patch with multiple additional channels of information, resulting in a feature vector where is the number of channels. We use features of two types: pixel lookups and pairwise differences , see §2.
Inspired by Lim et al. [Lim2013CVPR], we use a similar set of color and gradient channels (originally developed for fast pedestrian detection [Dollar2010BMVC]). We compute 3 color channels in CIELUV color space along with normalized gradient magnitude at 2 scales (original and half resolution). Additionally, we split each gradient magnitude channel into 4 channels based on orientation. The result is 3 color, 2 magnitude and 8 orientation channels, for a total of channels.
We blur the channels with a radius 2 triangle filter and downsample by a factor of 2, resulting in candidate features . Motivated by [Lim2013CVPR], we also compute pairwise difference features. We apply a large triangle blur to each channel (8 pixel radius), and downsample to a resolution of . Sampling all candidate pairs and computing their differences yields an additional candidate features per channel, resulting in 7228 total candidate features.
Mapping function: To train decision trees, we need to define a mapping as described in §3. Recall that our structured labels are segmentation masks. One option is to use , where represents the binary edge map corresponding to . Unfortunately Euclidean distance over yields a brittle distance measure.
We therefore define an alternate mapping . Let for denote the segment index of the pixel of . Individually a single value yields no information about , since is defined only up to a permutation. Instead we can sample a pair of locations and check if they belong to the same segment, . This allows us to define as a large binary vector that encodes for every unique pair of indices . While has dimensions, in practice we only compute a subset of dimensions as discussed in §3.2. We found a setting of and gives good results, effectively capturing the similarity of segmentation masks.
Ensemble model: Random forests achieve robust results by combining the output of multiple trees. While merging segmentation masks for overlapping patches is difficult, multiple overlapping edge maps can be averaged to yield a soft edge response. Thus in addition to the learned mask , we also store the corresponding edge map at each leaf node, thus allowing predictions to be combined quickly and simply through averaging during inference.
Efficiency: The surprising efficiency of our approach derives from the use of structured labels that predict information for an entire image neighborhood. This greatly reduces the number of trees
that need to be evaluated. We compute our structured output densely on the image with a stride of 2 pixels, thus with
output patches, each pixel receives predictions. In practice we use and thus the score of each pixel in the output edge map is averaged over 256 votes.A critical assumption is that predictions are uncorrelated. Since both the inputs and outputs of each tree overlap, we train total trees and evaluate an alternating set of trees at each adjacent location. Use of such a ‘checkerboard pattern’ improves results somewhat, introducing larger separation between the trees did not improve results further.
We now describe the first of two enhancements to our base algorithm. Inspired by the work of Ren [Ren2008ICCV], we implement a multiscale version of our edge detector. Given an input image , we run our structured edge detector on the original, half, and double resolution version of and average the result of the three edge maps after resizing to the original image dimensions. Although somewhat inefficient, the approach noticeably improves edge quality. We refer to the multiscale version of our structured edge detector as SE+MS.
We observed that predicted edge maps from our structured edge detector are somewhat diffuse. For strong, isolated edges nonmaximal suppression can be used to effectively detect edge peaks. However, given fine image structures edge responses can ‘bleed’ together resulting in missed detections; likewise, for weak edges that receive few votes no clear peak may emerge. The underlying cause for the diffuse edge responses is that the individually predicted edge maps are noisy and are not perfectly aligned to each other or the underlying image data. Specifically, each overlapping prediction may be shifted by a few pixels from the true edge location.
To address this phenomenon, we introduce a new sharpening procedure that aligns edge responses from overlapping predictions. Our core observation is that local image color and depth values can be used to more precisely localize predicted responses. Intuitively, given a predicted segmentation mask, the mask can be morphed slightly so that it better matches the underlying image patch. Aligning overlapping masks to the underlying image data implicitly aligns the masks with each other, resulting in sharper, better localized edge responses.
Sharpening takes a predicted segmentation mask and the corresponding image patch and produces a new mask that better aligns to . As before, let denote the segment index of the pixel of mask . First, for each segment , we compute its mean color using all pixels in . Next, we iteratively update the assigned segment for each pixel by assigning it to the segment which minimizes . For each pixel we restrict the set of assignable segments to the segments that are immediately adjacent to it (4connected neighborhood). Given the new sharpened segmentation masks, we compute and average their corresponding edge maps as before. However, since the edge maps are better aligned to the image data the resulting aggregated edge map is sharper.
Sharpening can be repeated multiple times prior to averaging the corresponding edge maps. Experiments reveal that the first sharpening step produces the largest gains, and in practice two steps suffice. Taking advantage of the sparsity of edges, the sharpening procedure can be implemented efficiently. For details we direct readers to source code. Note that sharpening is not guaranteed to improve results but we find it is quite effective in practice. We refer to the sharpened versions of our structured edge detector as SE+SH and SE+MS+SH.



ground truth


gPb+owt+ucm


SketchTokens


SCG


SE


SE+MS


SE+SH


SE+MS+SH




ground truth


high precision


optimal thresh


high recall

In this section we analyze the performance of our structured edge (SE) detector in detail. First we analyze the influence of parameters in §5.1 and test SE variants in §5.2. Next, we compare results on the BSDS [Arbelaez2011PAMI] and NYUD [Silberman2012ECCV] datasets to the stateoftheart in §5.3 and §5.4, respectively, reporting both accuracy and runtime. We conclude by demonstrating the cross dataset generalization of our approach in §5.5.
The majority of our experiments are performed on the Berkeley Segmentation Dataset and Benchmark (BSDS500) [Martin2001ICCV, Arbelaez2011PAMI]. The dataset contains 200 training, 100 validation, and 200 testing images. Each image has hand labeled ground truth contours. Edge detection accuracy is evaluated using three standard measures: fixed contour threshold (ODS), perimage best threshold (OIS), and average precision (AP) [Arbelaez2011PAMI]. To evaluate accuracy in the high recall regime, we additionally introduce a new measure, recall at 50% precision (R50), in §5.2. Prior to evaluation, we apply a standard nonmaximal suppression technique to our edge maps to obtain thinned edges [Canny1986PAMI]. Example detections on BSDS are shown in Figure 3 and visualizations of edge accuracy are shown in Figure 4.
We set all parameters with the help of the BSDS validation set which is fully independent of the test set. Parameters include: structured forest splitting parameters (e.g., and ), feature parameters (e.g., image and channel blurring), and model and tree parameters (e.g. number of trees and data quantity). Training takes 20 minute per tree using one million patches and is parallelized over trees. Evaluation of trees is parallelized as well, we use a quadcore machine for all reported runtimes.
In Figures 57 we explore the effect of choices of splitting, model and feature parameters. For each experiment we train on the 200 image training set and measure edge detection accuracy on the 100 image validation set (using the standard ODS performance metric). All results are averaged over 5 trials. First, we set all parameters to their default values indicated by orange markers in the plots. Then, keeping all but one parameter fixed, we explore the effect on edge detection accuracy as a single parameter is varied.
Since we explore a large number of parameters settings, we perform our experiments using a slightly reduced accuracy model that is faster to train. Specifically we train using fewer patches ( versus ) and utilize sharpening (SH) but not multiscale detection (MS). Also, the validation set is more challenging than the test set and we evaluate using 25 thresholds instead of 99, further reducing accuracy (.71 ODS). Finally, we note that sweep details have changed slightly from the our previous work [Dollar2013ICCV]; most notably, the sweeps now utilize sharpening but not multiscale detection.
Splitting Parameters: In Figure 5 we explore how best to measure information gain over structured labels. Recall we utilize a twostage approach of mapping followed by . Plots (a) and (b) demonstrate that should be large and small. Results are robust to both the discretization method and the discrete measure of information gain as shown in plots (c) and (d).
(a) (size of )  (b) (size of ) 
(c) discretization type  (d) information gain 
(a) # grid cells  (b) # gradient orients 
(c) normalization radius  (d) channel downsample 
(e) channel blur  (f) selfsimilarity blur 
(a) patch size for  (b) patch size for 
(c) # train patches  (d) # train images 
(e) fraction ‘positives’  (f) fraction features 
(g) # decision trees  (h) max tree depth 
(i) min samples per node  (j) # sharpening steps 
Feature Parameters: Figure 6 shows how varying the channel features affects accuracy. We refer readers to §4 and source code for details, here we only note that performance is relatively insensitive to a broad range of parameter settings.
Model Parameters: In Figure 7 we plot the influence of parameters governing the model and training data. (a) and (b) show the effect of image and label patch sizes on accuracy, image patches and label patches are best. (c) and (d) show that increasing the number of patches and training images improves accuracy. (e) shows that about half the sampled patches should be ‘positive’ (have more than one ground truth segment) and (f) shows that training each tree with a fraction of total features has negligible impact on accuracy (but results in proportionally lower memory usage). In (g)(i) we see that many, deep, unpruned trees give best performance (nevertheless, we prune trees so every node has at least 8 training samples to decrease model size). Finally (j) shows that two sharpening steps give best results. Impact of sharpening is explored in more detail next in §5.2.
Given our trained detector, sharpening (SH) and multiscale detection (MS) can be used to enhance results. In this section we analyze the performance of the four resulting combinations. We emphasize that the same trained model can be used with sharpening and multiscale detection enabled at runtime.
In Figure 8 we plot precision/recall curves for the four variants of our approach: SE, SE+MS, SE+SH, and SE+MS+SH. Summary statistics are reported in the bottom rows of Table I. SE has an ODS score of .73 and SE+MS and SE+SH both achieve an ODS of .74. SE+MS+SH, which combines multiscale detection and sharpening^{2}^{2}2We trained the topperforming SE+MS+SH model with patches compared to for the other SE models, further increasing ODS by ., yields an ODS of .75. In all cases OIS, which is measured using a separate optimal threshold per image, is about 2 points higher than ODS.
As these results indicate, both sharpening and multiscale detection improve accuracy. To further analyze these enhancements, we introduce a new evaluation metric: recall at 50% precision (R50), which measures accuracy in the high recall regime. SE achieves R50 of .90 and SE+MS does not improve this. In contrast, SE+SH boosts R50 considerably to .93. This increase in recall for the SE variants can clearly be seen in Figure
8. The MS variants, on the other hand, improve precision in the lowrecall regime. Overall, both SH and MS improve AP^{3}^{3}3We discovered an error in the BSDS evaluation which overestimates AP by 1%. For consistency with past results, however, we used the code as is., with SE+SH+MS achieving an AP of .80.The runtime of the four variants is reported in the last column of Table I. SE runs at a frame rate of 30hz, enabling real time processing. Both SH and MS slow the detector, with MS incurring a higher cost. Nevertheless, SE+SH runs at over 12hz while achieving excellent accuracy. Indeed, in the high recall regime, which is necessary for many common scenarios, SE+SH achieves top results. Given its speed and high recall, we expect SE+SH to be the default variant used in practice.
ODS  OIS  AP  R50  FPS  
Human  .80  .80       
Canny  .60  .63  .58  .75  15 
FelzHutt [Felzenszwalb2004IJCV]  .61  .64  .56  .78  10 
Normalized Cuts [Cour2005CVPR]  .64  .68  .45  .81   
Mean Shift [Comaniciu2002PAMI]  .64  .68  .56  .79   
HidayatGreen [Hidayat2009BMVC]  .62        20 
BEL [Dollar2006CVPR]  .66        1/10 
Gb [Leordeanu2014PAMI]  .69  .72  .72  .85  1/6 
gPb + GPU [Catanzaro2009ICCV]  .70        1/2 
ISCRA [Ren2013CVPR]  .72  .75  .46  .89  1/30 
gPbowtucm [Arbelaez2011PAMI]  .73  .76  .73  .89  1/240 
Sketch Tokens [Lim2013CVPR]  .73  .75  .78  .91  1 
DeepNet [Kivinen2014AISTATS]  .74  .76  .76    1/5 
SCG [Ren2012NIPS]  .74  .76  .77  .91  1/280 
SE+multiucm [Arbelaez2014CVPR]  .75  .78  .76  .91  1/15 
SE  .73  .75  .77  .90  30 
SE+SH  .74  .76  .79  .93  12.5 
SE+MS  .74  .76  .78  .90  6 
SE+MS+SH  .75  .77  .80  .93  2.5 
We compare our edge detector against competing methods, reporting both accuracy and runtime. Precision/recall curves are shown in Figure 9 and summary statistics are in Table I.
Our full approach, SE+MS+SH, outperforms all stateoftheart approaches [Ren2012NIPS, Kivinen2014AISTATS, Lim2013CVPR, Arbelaez2011PAMI, Ren2013CVPR]. We improve ODS/OIS by 1 point over competing methods and AP/R50 by 2 points. Our edge detector is particularly effective in the high recall regime. The only method with comparable accuracy is SE+multiucm [Arbelaez2014CVPR] which couples our SE+MS detector with a hierarchical multiscale segmentation approach.
SE+MS+SH is orders of magnitude faster than nearly all edge detectors with comparable accuracy, see last column of Table I. All runtimes are reported on images. Our approach scales linearly with image size and and is parallelized across four cores. While many competing methods are likewise linear, they have a much higher cost per pixel. The single scale variant of our detector, SE+SH, further improves speed by with only minor loss in accuracy and no loss in recall. Finally, SE runs at hz while still achieving competitive accuracy.
In comparison to other learningbased approaches to edge detection, we considerably outperform BEL [Dollar2006CVPR] which computes edges independently at each pixel given its surrounding image patch. We also outperform Sketch Tokens [Lim2013CVPR] in both accuracy and runtime performance. This may be the result of Sketch Tokens using a fixed set of classes for selecting split criterion at each node, whereas our structured forests can capture finer patch edge structure. Moreover, our structured output leads to significantly smoother edge maps, see Figure 3. Finally, Kivinen et al. [Kivinen2014AISTATS] recently trained deep networks for edge detection; unfortunately, we were unable to obtain results from the authors to perform detailed comparisons.
ODS  OIS  AP  R50  FPS  

gPbowtucm [Arbelaez2011PAMI]  .63  .66  .56  .79  1/360 
Silberman [Silberman2012ECCV]  .65  .66  .29  .84  1/360+ 
gPb+NG [Gupta2013CVPR]  .68  .71  .63  .86  1/375 
SE+NG+ [Gupta2014ECCV]  .71  .72  .74  .90  1/15 
SED  .64  .65  .66  .80  7.5 
SERGB  .65  .67  .65  .84  7.5 
SERGBD  .69  .71  .72  .89  5 
The NYU Depth (NYUD) dataset [Silberman2012ECCV] is composed of pairs of RGB and depth images with corresponding semantic segmentations. The dataset was adopted independently for edge detection by Ren and Bo [Ren2012NIPS] and by Gupta et al. [Gupta2013CVPR]. In practice, the two dataset variants have significant differences. Specifically, [Ren2012NIPS] proposed a different train/test split and used half resolution images. Instead, [Gupta2013CVPR] use the train/test split originally proposed by Silberman et al. [Silberman2012ECCV] and full resolution images. In our previous work we used the version from [Ren2012NIPS] in our experiments; in the present work we switch to the version from Gupta et al. [Gupta2013CVPR] as more methods have been evaluated on this variant and it utilizes the full resolution images.
Gupta et al. [Gupta2013CVPR] split the NYUD dataset into 381 training, 414 validation, and 654 testing images and generated ground truth edges from the semantic segmentations provided by [Silberman2012ECCV]. The original images are cropped to discard boundary regions with missing ground truth. Finally the maximum slop allowed for correct matches of edges to ground truth during evaluation is increased from .0075 of the image diagonal to .011. This is necessary to compensate for the relatively inexact localization of the ground truth.
Example SE results are shown in Figure 12. We treat the depth channel in the same manner as the other color channels. Specifically, we recompute the gradient channels over the depth channel (with identical parameters) resulting in 11 additional channels. Precision/recall curves for SE+SH with different image modalities are shown in Figure 10. Use of depth information only (SED) gives good precision as strong depth discontinuities nearly always correspond to edges. Use of intensity information only (SERGB) gives better recall as nearly all edges have intensity discontinuities but not all edges have depth discontinuities. As expected, simultaneous use of intensity and depth (SERGBD) substantially improves results.
Summary statistics are given in Table II. Runtime is slower than on BSDS as NYUD images are higher resolution and features must be computed over both intensity and depth. For these results we utilized the SE+SH variant which slightly outperformed SE+MS+SH on this dataset.
In Table II and Figure 11 we compare our approach, SE+SH, to a number of stateoftheart approaches, including gPbowtucm (color only), Silberman et al.’s RGBD segmentation algorithm [Silberman2012ECCV], and detectors from Gupta et al. [Gupta2013CVPR, Gupta2014ECCV]
that explicitly estimate depth normal gradient (NG). While our approach naively utilizes depth (treating the depth image identically to the intensity image), we outperform nearly all competing methods, including gPb+NG
[Gupta2013CVPR]. Gupta et al. [Gupta2014ECCV] obtain top results by coupling our structured edges detector with depth normal gradients and additional cues (SE+NG+). Finally, for a comparison of SE to Ren and Bo’s SCG [Ren2012NIPS] on the alternate version of NYUD we refer readers to our previous work [Dollar2013ICCV] (in the alternate setup SE likewise outperforms SCG across all modalities while retaining its speed advantage).



depth


ground truth


SED




SERGB




SERGBD



To study the ability of our approach to generalize across datasets we ran a final set of experiments. In Table III we show results on NYUD using structured forests trained on BSDS and also results on BSDS using structured forests trained on NYUD. For these experiments we use intensity images only. Note that images in the BSDS and NYUD datasets are qualitatively quite different, see Figure 3 and 12, respectively.
Table III, top, compares results on NYUD of the NYUD and BSDS trained models. Across all performance measure, scores degrade by about 1 point when using the BSDS dataset for training. Precision/recall curves on NYUD for the NYUD model (SERGB) and the BSDS model (SEBSDS) are shown in Figure 10. The resulting curves align closely. The minor performance change is surprising given the different statistics of the datasets. Results on BSDS of the BSDS and NYUD models, shown in Table III, bottom, are likewise similar.
These experiments provide strong evidence that our approach could serve as a general purpose edge detector without the necessity of retraining. We expect this to be a critical aspect of our detector allowing for its widespread applicability.
ODS  OIS  AP  R50  FPS  

NYUD / NYUD  .65  .67  .65  .84  7.5 
BSDS / NYUD  .64  .66  .63  .83  7.5 
BSDS / BSDS  .75  .77  .80  .93  2.5 
NYUD / BSDS  .73  .74  .77  .91  2.5 
Our approach is capable of realtime frame rates while achieving stateoftheart accuracy. This may enable new applications that require highquality edge detection and efficiency. For instance, our approach may be well suited for video segmentation or for time sensitive object recognition tasks such as pedestrian detection.
Our approach to learning structured decision trees may be applied to a variety of problems. The fast and direct inference procedure is ideal for applications requiring computational efficiency. Given that many vision applications contain structured data, there is significant potential for structured forests in other applications.
In conclusion, we propose a structured learning approach to edge detection. We describe a general purpose method for learning structured random decision forest that robustly uses structured labels to select splits in the trees. We demonstrate stateoftheart accuracies on two edge detection datasets, while being orders of magnitude faster than most competing stateoftheart methods.
Source code is available online.
Comments
There are no comments yet.