International Journal of Computer Vision 45(1), 39–54, 2001c© 2001 Kluwer Academic Publishers. Manufactured in The Netherlands.

A General Method for Geometric Feature Matching and Model Extraction

CLARK F. OLSONUniversity of Washington, Bothell, Department of Computing and Software Systems, 18115 Campus Way NE,

Box 358534, Bothell, WA 98011-8246, USAcfolson@u.washington.edu

Received March 3, 2000; Accepted June 15, 2001

Abstract. Popular algorithms for feature matching and model extraction fall into two broad categories: generate-and-test and Hough transform variations. However, both methods suffer from problems in practical implementations.Generate-and-test methods are sensitive to noise in the data. They often fail when the generated model fit is poordue to error in the data used to generate the model position. Hough transform variations are less sensitive to noise,but implementations for complex problems suffer from large time and space requirements and from the detection offalse positives. This paper describes a general method for solving problems where a model is extracted from, or fitto, data that draws benefits from both generate-and-test methods and those based on the Hough transform, yieldinga method superior to both. An important component of the method is the subdivision of the problem into manysubproblems. This allows efficient generate-and-test techniques to be used, including the use of randomization tolimit the number of subproblems that must be examined. Each subproblem is solved using pose space analysistechniques similar to the Hough transform, which lowers the sensitivity of the method to noise. This strategy iseasy to implement and results in practical algorithms that are efficient and robust. We describe case studies ofthe application of this method to object recognition, geometric primitive extraction, robust regression, and motionsegmentation.

Keywords: divide-and-conquer, feature matching, generate-and-test, geometric primitive extraction, Hough trans-form, model extraction, motion segmentation, object recognition, randomized algorithm, robust regression

1. Introduction

The generate-and-test paradigm is a popular strategyfor solving model matching problems such as recog-nition, detection, and fitting. The basic idea of thismethod is to generate (or predict) many hypotheticalmodel positions using the minimal amount of data nec-essary to identify unique solutions. A sequence of suchpositions is tested, and the positions that meet somecriterion are retained. Examples of this technique in-clude RANSAC (Fischler and Bolles, 1981) and thealignment method (Huttenlocher and Ullman, 1990).

The primary drawback to the generate-and-testparadigm is its sensitivity to noise. Let us call the datapoints (or other features, in general) that are used inpredicting the model position for some test the distin-

guished features, since they play a more important rolein whether the test is successful. The other features areundistinguished features. Errors in the locations of thedistinguished features cause the predicted model po-sition(s) to be in error. As the error grows, the testingstep becomes more likely to fail.

To deal with this problem, methods have been de-veloped to propagate errors in the locations of the dis-tinguished features (Alter and Jacobs, 1998; Grimsonet al., 1994). Under the assumption of a bounded er-ror region for each of the distinguished features, thesemethods can place bounds on the locations in whichvarious model features can be located in an image. Ifwe count the number of image features that can bealigned with the model (with the constraint that thedistinguished features must always be in alignment up

40 Olson

to the error bounds) these techniques can guarantee thatwe never undercount the number of alignable features.The techniques will thus never report that the model isnot present according to some counting criterion when,in fact, the model does meet the criterion.

On the other hand, this method is likely to overcountthe number of alignable features, even if the boundson the location of each individual feature are tight.The reason for this is that, while the method checkswhether there are model positions that brings eachof the undistinguished image features into alignmentwith the model (along with all of the distinguished fea-tures) up to the error bounds, it does not check whetherthere is a single position that brings all of the countedundistinguished features into alignment up to the errorbounds.

A competing technique for feature matching andmodel extraction is based on the Hough transform.This method also generates hypothetical model posi-tions solutions using minimal information, but ratherthan testing each solution separately, the testing is per-formed by analyzing the locations of the solutions inthe space of possible model positions (or poses). Thisis often, but not always, accomplished through a his-togramming or clustering procedure. The large clustersin the pose space indicate good model fits. We call tech-niques that examine the pose space for sets of consistentmatches among all hypothetical matches Hough-basedmethods, since they derive from the Hough transform(Illingworth and Kittler, 1988; Leavers, 1993). Whilethese techniques are less sensitive to noise in the fea-tures, they are prone to large computational and mem-ory requirements, as well as the detection of falsepositive instances (Grimson and Huttenlocher, 1990)if the pose space analysis is not precise.

In this paper, we describe a technique that com-bines the generate-and-test and Hough-based meth-ods in a way that draws ideas and advantages fromeach, yielding a method that improves upon both.Like the generate-and-test method, (partial) solutionsbased on distinguished features are generated for fur-ther examination. However, each such solution isunder-constrained and Hough-based methods are usedto determine and evaluate the remainder of the solu-tion. This allows both randomization to be used toreduce the computational complexity of the methodand error propagation techniques to be used in orderto better extract the model(s). We call this techniqueRUDR (pronounced “rudder”), for Recognition UsingDecomposition and Randomization.

We will show that the problem can be treated asmany subproblems, each of which is much simplerthan the original problem. We then discuss variousmethods by which the subproblems can be solved. Theapplication of randomization to reduce the number ofsubproblems that must be examined is next described.These techniques yield efficiency gains over conven-tional generate-and-test and Hough-based methods. Inaddition, the subdivision of the problem allows us toexamine a much smaller parameter space in each of thesubproblems than in the original problem and this al-lows the error inherent in localization procedures to bepropagated accurately and efficiently in the matchingprocess.

This method has a large number of applications.It can be applied to essentially any problem wherea model is fit to cluttered data (that is, with outliersor multiple models present). We describe case stud-ies of the application of this method to object recog-nition, curve detection, robust regression, and motionsegmentation.

The methodology described here is a generalizationof previous work on feature matching and model ex-traction (Olson, 1997a, 1997b, 1999). Similar ideashave been used by other researchers. A simple variationof this method has been applied to curve detection byMurakami et al. (1986) and Leavers (1992). In both ofthese papers, the problem decomposition was achievedthrough the use of a single distinguished feature in theimage for each of the subproblems. We argue that theoptimal performance is achieved when the number ofdistinguished features is one less than the number nec-essary to fully define the model position in the errorlesscase. This has two beneficial effects. First, it reducesthe amount of the pose space that must be consideredin each problem (and the combinatorial explosion inthe sets of undistinguished features that are examined).Second, it allows a more effective use of randomiza-tion in reducing the computational complexity of themethod. A closely related decomposition and random-ization method has been described by Cass (1997) inthe context of pose equivalence analysis. He uses a“base match” to develop an approximation algorithmfor feature matching with uncertain data.

2. Related Research

In this section, we review research on generate-and-testand Hough-based algorithms for model matching.

Geometric Feature Matching and Model Extraction 41

2.1. Generate-and-Test Methods

The basic idea in generate-and-test methods is to se-quentially generate hypothetical model positions in thedata and test the positions. The hypothetical modelpositions are generated by conjecturing matches be-tween the model and a set of features in the data andthen determining the model position(s) such that themodel is aligned with the data features. These posi-tions are tested by comparing the position of the modelagainst the remainder of the data. One common mea-sure of the quality of the position is the number ofdata features that agree well with the model at thisposition.

Fischler and Bolles (1981) described the RANSAC(for RANdom SAmple Consensus) technique. Theysuggested that, when solving for the model position,it is best to use the minimum number of data fea-tures necessary to yield a finite set of solutions (as-suming no error). This reduces the likelihood that oneof the data features does not belong to the model, sincethere may be outliers or multiple models present. Theyalso used a randomization technique, where sets ofdata features were sampled randomly until the prob-ability of at least one sample being correct is suf-ficiently large, assuming that the model is actuallypresent in the image. In addition to applying thesetechniques to pose determination from point features(Fischler and Bolles, 1981), these techniques wereapplied to curve and surface detection (Bolles andFischler, 1981).

One problem that generate-and-test methods canhave is that error in the data features causes error inthe model position estimate that can result in failureto detect the model correctly. An alternative to simplytesting the model position corresponding to some hy-pothesized data set is to iteratively refine the modelposition as additional data features are conjecturedto belong to the model (Ayache and Faugeras, 1986;Faugeras and Hebert, 1986; Lowe, 1987). This can sig-nificantly improve the overall match, particularly whenthe initial data set is noisy, although it will not help ifthe initial matching contains an outlier. Another tech-nique, which can be used if the localization error canbe modeled, is to carefully propagate the effects of lo-calization error in the testing step (Alter and Jacobs,1998; Grimson et al., 1994). While this technique willnot miss instances of a model that satisfy some errorcriterion, it will find instances that do not satisfy thecriterion.

2.2. Hough-Based Methods

Parameter space analysis techniques can be traced backto the patent of the Hough transform (Hough, 1962).The Hough transform was initially used to track particlecurves in bubble-chamber imagery. Subsequent workby Rosenfeld (1969) and Duda and Hart (1972) playeda substantial role in popularizing the Hough transformand it has since become an established technique forthe detection of curves and surfaces, as well as manyother applications. The basic idea of the Hough trans-form is that each data feature can be mapped into amanifold in the parameter space of possible curves (ormodel positions, in general). Typical implementationsconsider a quantized parameter space and count thenumber of data features that map to a manifold inter-secting each cell in the quantized space. Cells with highcounts correspond to curves in the image. Surveys ofthe Hough transform and applications have been pub-lished by Illingworth and Kittler (1988) and Leavers(1993).

Ballard (1981) demonstrated that the Hough trans-form can be generalized to detect arbitrary shapes(composed of discrete points) in images. This methoddetermines a mapping between image features and anaccumulator for a parameter space describing the pos-sible positions of the object. When each image featurehas been mapped into the parameter space, instancesof the shape yield local maxima in the accumulator.Ballard used pixel orientation information to speed upthe algorithm and improve accuracy. It was also sug-gested that pairs of features could be mapped into theparameter space to reduce the effort in mapping fea-tures into the parameter space, but this was consideredinfeasible for most cases.

More recent work has incorporated the idea of map-ping sets of features into the parameter space (Bergenand Shvaytser, 1991; Leavers, 1992; Xu et al., 1990).The primary benefit that is gained from this is that onlythose feature sets that are large enough to map to a sin-gle point (or a finite set of points) in the parameter spaceare examined. A drawback is that there are many suchsets of features. An additional technique that has provenuseful for improving the efficiency of the Hough trans-form is randomization (Bergen and Shvaytser, 1991;Kiryati et al., 1991; Leavers, 1992; Xu et al., 1990).

Generalized Hough transform techniques have beenapplied to many object recognition problems (andthese techniques are sometimes called pose clusteringin this context) (Linnainmaa et al., 1988; Silberberg

42 Olson

et al., 1984; Stockman, 1987; Thompson and Mundy,1987). Most of these applications consider feature setsthat map to single points in the space of possiblemodel transformations and then perform some cluster-ing method to detect objects (often multi-dimensionalhistogramming).

3. General Problem Formalization

The class of problems that we solve using RUDR arethose that require a model to be fit to a set of observeddata features, where a significant portion of the ob-served data may be outliers (in fact, the model maycontain outliers as well) or there may be multiple mod-els present in the data. These problems can, in general,be formalized as follows.

Given

• D—the data to match. The data is a set of a set of fea-tures or measurements, {δ1, . . . , δd}, that have beenextracted, for example, from an image. For simplic-ity, we assume that all of the data features are of asingle geometric class, such as points or segments,but this restriction can be removed.

• M—the model to be fit. This model may be a set ofdistinct features as is typical in object recognition, orit may be a parameterized manifold such as a curve orsurface, as in curve detection and robust regression.The only constraint on the model is that we must beable to determine hypothetical model positions bymatching the model with sets of data features.

• T —the set of possible positions or transformationsof the model. We use τ to denote individual trans-formations in this space.

• A(M,D, T , τ, D)—the acceptance criterion. Abinary-valued criterion that specifies whether a trans-formation τ satisfactorily brings the model intoagreement with a set of data features, D ∈D. Weallow this criterion to be a function of the full set ofdata features and the set of transformations to allowthe criterion to select the single best subset of datafeatures according to some criterion or to take intoaccount global matching information.

Determine and Report

• All maximal sets of data features, D ∈D, for whichthere is a transformation, τ ∈ T , such that the ac-ceptance criterion, A(M,D, T , τ, D), is satisfied.

(Only the maximal sets are reported so that the sub-sets of each maximal set need not be reported.)

This formalization is very general. Many problemscan be formalized in this manner, including objectrecognition, geometric primitive extraction, motionsegmentation, and robust regression.

A useful acceptance criterion is based on bound-ing the fitting error between the model and the data.Let C(M, δ, τ ) be a function that determines whetherthe specified position of the model fits the data fea-ture δ (for example, up to a bounded error). Welet C(M, δ, τ ) = 1, if the criterion is satisfied, andC(M, δ, τ ) = 0, otherwise. The model is said to bebrought into alignment with a set of data features,D = {δ1, . . . , δx } up to the error criterion, if all of theindividual features are brought into alignment:

x∏i=1

C(M, δi , τ ) = 1 (1)

The bounded-error acceptance criterion specifies thata set of data features, D = {δ1, . . . , δx }, should be re-ported if the cardinality of the set meets some threshold(x ≥ c), there is a position of the model that satisfies(1), and the set is not a subset of some larger set that isreported.

While this criterion does not incorporate global in-formation, such as mean-square-error or least-median-of-squares, RUDR is not restricted to using thisbounded-error criterion. This method has been appliedto least-median-of-squares regression with excellentresults (Olson, 1997a).

Example. As a running example, we will considerdetecting circles in two-dimensional image data. Forthis case, our model M is simply the parameteriza-tion of a circle, (x − xc)

2 + (y − yc)2 = r2, and our

data D is a set of image points. The space of possibletransformations is the space of circles,T = [xc, yc, r ]T .We use a bounded-error acceptance criterion suchthat a point is considered to be on the circle if|√

(x − xc)2 + (y − yc)2 − r | < ε. We will report thecircles that have

∑di=1 Cε(M, δi , τ ) > πr . In other

words, we search for the circles that have approxi-mately half of their perimeter present in the image,although any other threshold could be used.

4. RUDR Approach

The main components of the approach that we take areas follows. First, we subdivide the problem into many

Geometric Feature Matching and Model Extraction 43

smaller subproblems, as in generate-and-test methods.However, our subproblems do not fully constrain thepose of the model. Each subproblem is solved usinga Hough transform-based method to search a partiallyconstrained pose space in which with model may lie.Randomization techniques are used to limit the numberof subproblems that are examined with a low probabil-ity of failure.

Let us call the hypothetical correspondence betweena set of data features and the model a matching. Thegenerate-and-test paradigm and many Hough-basedstrategies solve for hypothetical model positions us-ing matchings of the minimum cardinality to constrainthe model position up to a finite ambiguity (assumingerrorless features). We call the matchings that containthis minimal amount of information minimal match-ings and denote their cardinality k. We consider twotypes of models. One type of model consists of a setof discrete features similar to the data features. Theother is a parameterized model such as a curve or sur-face. When the model is a set of discrete features,the minimal matchings specify the model features thatmatch each of the data features in the minimal match-ing and we call these explicit matchings. Otherwise,the data features are matched implicitly to positions inparameterized model and we, thus, call these implicitmatchings.

In the generate-and-test paradigm, the model posi-tions generated using the minimal matchings are testedby determining how well the undistinguished featuresare fit according to the predicted model position. InHough-based methods, it is typical to determine thepositions of the model that align each of the minimalmatchings and detect clusters of these positions in theparameter space that describes the set of possible modelpositions,1 but other pose space analysis techniquescan be used (Breuel, 1992; Cass, 1997).

The approach that we take draws upon both generate-and-test techniques and Hough-based techniques. Theunderlying matching method may be any one of sev-eral pose space analysis techniques in the Hough-basedapproach (see Section 5), but unlike previous Hough-based methods, the problem is subdivided into manysmaller problems, in which only a subset of the min-imal matchings is examined. When randomization isapplied to selecting which subproblems to solve, a lowcomputational complexity can be achieved with a lowprobability of failure.

The key to this method is the subdivision of theproblem into many small subproblems, in which a

distinguished matching of some cardinality g < k be-tween data features and the model is considered. Onlythose minimal matchings that contain the distinguishedmatching are examined in each subproblem and thisconstrains the portion of the pose space that the sub-problem considers. We could consider each possibledistinguished matching of the appropriate cardinal-ity as a subproblem, but we shall see that this is notnecessary in practice.

In the remainder of this section, we show that thesubdivision of the problem into many smaller subprob-lems does not inherently change the solutions that aredetected by the algorithm. We then discuss the op-timal cardinality for the distinguished matching thatconstrains each subproblem and the application of thismethodology using approximation algorithms. Follow-ing sections describe algorithms that can be used tosolve the individual subproblems and the use of ran-domization to limit the complexity of the algorithms.

4.1. Problem Equivalence

Let’s consider the effect of the decomposition of theproblem on the matchings that are detected by a sys-tem using a bounded-error criterion, C(M, d, t), asdescribed above. For now, we assume that we havesome method of determining precisely those sets ofdata features that should be reported according to thebounded-error acceptance criterion. The implicationsof performing matching only approximately and theuse of an acceptance criterion other than the bounded-error criterion are discussed subsequently.

Proposition 1. For any transformation, τ ∈ T , thefollowing statements are equivalent:

1. Transformation τ brings at least x data features intoalignment with the model up to the error criterion.

2. Transformation τ brings at least (xk ) sets of data

features with cardinality k into alignment with themodel up to the error criterion.

3. For any distinguished matching with cardinality gthat is brought into alignment with the model upto the error criterion by τ , there are (

x−gk−g ) mini-

mal matchings that contain the distinguished match-ing that are brought into alignment up to the errorcriterion by τ .

Proof: The proof follows from combinatorics. Wesketch the proof that (a) Statement 1 implies

44 Olson

Statement 2, (b) Statement 2 implies Statement 3, and(c) Statement 3 implies Statement 1. The statementsare thus equivalent.

(a) From Statement 1, there are at least x data featureswith C(M, δi , τ ) = 1. We can thus form at least( x

k ) distinct sets of these data features with cardi-nality k. Each such set has

∏ki=1 C(M, δi , τ ) = 1.

These matchings thus contribute at least ( xk ) to the

sum.(b) To form the ( x

k ) sets of data features that are broughtinto alignment with the model, we must have x in-dividual data features satisfying C(M, δi , τ ) =1. (If there were y < x such features then wecould only form ( y

k ) minimal matchings satis-fying Eq. (1).) Choose any subset G of thesematches with cardinality g. Form the ( x − g

k − g ) sub-sets with cardinality k − g that do not includeany feature in G. Each of these subsets whencombined with G forms a minimal matching thatis brought into alignment up to the error crite-rion since each of the individual features satisfiesC(M, δi , τ ) = 1.

(c) From Statement 3, the g data features in the distin-guished matching are brought into alignment up tothe error criterion by τ . In addition there must ex-ist x − g additional data features that are broughtinto alignment up to the error criterion by τ toform the ( x−g

k−g ) subsets of cardinality k − g that arebrought into alignment up to the error criterion byτ . Thus, in total, there must be g + x − g = x datafeatures that are brought into alignment up to theerror criterion by τ . ✷

Statement 3 indicates that as long as we examineone distinguished matching that belongs to each ofthe matchings that should be reported, the strategyof subdividing the problem into subproblems yieldsequivalent results to examining the original problem aslong as the threshold on the number of matches is setappropriately.

This decomposition of the problem allows ourmethod to be viewed as a class of generate-and-testmethods, where distinguished matchings (rather thanminimal matchings) are generated and the testing stepis performed using a pose space analysis method (suchas clustering or pose space equivalence analysis) ratherthan comparing a particular model position againstthe data. Methods for solving the subproblems arediscussed further in Section 5.

4.2. Optimal Cardinality

While distinguished matchings of any cardinality couldbe considered, we must balance the complexity ofthe subproblems with the number of subproblems thatare examined. Increasing the cardinality of the distin-guished matching is beneficial up to a point. As the sizeof the distinguished matching is increased, the numberof minimal matchings that is examined in each sub-problem is decreased and we have more constraint onthe position of the model. The subproblems are thussimpler to solve.

By itself, this does not necessarily improve matters,since there are more subproblems to examine. How-ever, since we use randomization to limit the numberof subproblems that are examined, a lower computa-tional complexity is achieved by having more sim-ple subproblems than fewer difficult ones. Section 6shows why this is true. On the other hand, when wereach g = k, the method becomes no better than a stan-dard generate-and-test technique and we lose both thebenefits gained through the Hough-based analysis ofthe pose space and the property that the subproblemsbecome simpler with larger distinguished matchings.We, thus, use distinguished matchings with cardinalityg = k − 1. For each subproblem, this means that weexamine a set of minimal matchings that share k − 1data features and that vary in only one feature.

4.3. Approximation Algorithms

For practical reasons, we may not wish to use an al-gorithm that reports exactly those matchings that sat-isfy the error criterion, since such algorithms are of-ten time consuming. In this case, we cannot guaranteethat examining a distinguished matching that belongsto a solution that should be reported will result in de-tecting that solution. However, empirical evidence sug-gests that the examination of these subproblems yieldssuperior results when an approximation algorithm isused (Olson, 1997b), owing to failures that occur in theexamination of full problem.

We can also use these techniques with acceptancecriteria other than the bounded-error criterion. Withother criteria, the proposition is not always true,but if an approximation algorithm is used to detectgood matchings, examination of the subproblems of-ten yields good results. For example, an application ofthese ideas to least-median-of-squares regression hasyielded an approximation algorithm that is provably

Geometric Feature Matching and Model Extraction 45

accurate with high probability, while previous approx-imation algorithms do not have this property (Olson,1997a).

Example. For our circle detection example, k = 3,since three points are sufficient to define a circle in theerrorless case. The above analysis implies that, ratherthan examining individual image features, or all triplesof features, we should examine trials (or subproblems)consisting of only the triples that share some distin-guished pair of features in common. Multiple trials areexamined to prevent missing a circle.

5. Solving the Subproblems

Now, we must use some method to solve each of thesubproblems that are examined. We can use any methodthat determines the number of matchings with a givencardinality can be brought approximately into align-ment with the model at a particular position. We dis-cuss histogramming first, which is the simplest method,but is prone to errors. Pose constraint methods, whichare precise methods for locating good pose subject tobounded error constraints, are discussed next. Finally,we describe a middle ground, where errors are prop-agated into a small subspace and then clustering isperformed.

5.1. Histogramming

The simplest method for solving the subproblems isto use a multi-dimensional histogramming step in or-der to locate large clusters in the pose space. In thismethod, the parameter space is quantized and a counteris maintained for each cell in the quantized space. Eachmatching is mapped into a manifold in the parameterspace and the counter associated with each parameterspace cell that intersects that manifold is incremented.Clusters in the parameter space are found by locatingcells with high counts. The primary reason this methodis popular is that it requires linear time in the number ofmatchings that are considered, while most other meth-ods are more complex. While this method is fast if theparameter space is not too large and yields good resultsfor many applications, it does not propagate the effectsof error accurately, it introduces quantization effects,and it is time consuming for large parameter spaces.

To reduce the problem of a large parameter space, hi-erarchical decompositions of the parameter space have

often been used. This is usually performed through acoarse-to-fine search of the parameter space or by de-composing the parameter space along the orthogonalaxes. Such decompositions of the parameter space al-low the initial steps to be performed using only a fewcells in the transformation space. Those that cannotlead to a large cluster are eliminated and the rest areexamined in finer detail.

The problem of error propagation is more difficult tohandle with this technique. For complex problems, itcan become problematic to detect the clusters withoutalso detecting a significant number of false positives(Grimson and Huttenlocher, 1990). One possibility is todiscretize the pose space finely and then increment thecounter for each cell that is consistent with each mini-mal matching (Shapiro, 1978). However, this requiresmuch computation.

5.2. Pose Constraint Methods

Alternatively, pose equivalence analysis techniquesthat have been developed by Breuel (1992) and Cass(1997) can be applied that allow localization error tobe propagated accurately. The basic idea of these meth-ods is that each match between a model feature and adata feature yields some constraints on the model po-sition that must be satisfied in order for the features tobe aligned up to the error boundary. These constraintsdivide the pose space into equivalence classes, withinwhich the same sets of features are brought into corre-spondence. A search of the pose space is performed tolocate the positions that satisfy the maximum numberof constraints.

Cass (1997) searches the pose space by examiningthe arrangement of the constraints using computationalgeometry techniques. A significant speedup is achievedthrough the use of an approximation algorithm. Breuel(1992) uses a method that adaptively divides the posespace, pruning cells that are not consistent with a suffi-cient number of the constraints. Unpruned cells are di-vided recursively until they are small enough to acceptas valid model positions. Breuel’s experiments suggestthat his techniques can operate in approximately linearexpected time in the number of matchings, so this stepcan be performed efficiently in many cases.

Both of these techniques can be used in conjunctionwith our approach to subdividing the problem. In themethod of Cass, much less of the pose space is exam-ined in each trial, since only a few of the pose equiv-alence classes are consistent with each distinguished

46 Olson

matching. In Breuel’s method, k-tuples are used to formclosed constraint regions in the pose space, so our ap-proach would examine only the k-tuples that containthe distinguished matching in each trial.

5.3. Subspace Error Propagation

In our method, only a small portion of the parameterspace is examined in each subproblem. If it is assumedthat there is no error in the data features in the dis-tinguished matching, then each subproblem considersonly a sub-manifold of the parameter space. In gen-eral, if there are p transformation parameters and eachfeature match yields c constraints on the transforma-tion, then a subproblem where the distinguished match-ings have cardinality g considers only a ( p − gc)-dimensional manifold of the transformation space inthe errorless case.2 This allows us to parameterize thesub-manifold (using p − gc parameters) and performanalysis in this lower dimensional space. A particularlyuseful case is when the resulting manifold has only onedimension (i.e. it is a curve). In this case, the subprob-lem can be solved very simply by parameterizing thecurve and finding positions on the curve that are con-sistent with many minimal matchings.

When localization error in the data features is con-sidered, the subproblems must (at least implicity) con-sider a larger space than the manifold described above.The subproblems are still much easier to solve. A tech-nique that is useful in this case is to project the set oftransformations that are consistent with each minimalmatching up to the error criterion onto the manifoldthat results in the errorless case and then perform clus-tering only in the parameterization of this manifold asdiscussed above (Olson, 1999).

This method slightly overestimates the total numberof consistent matches, since matches that are consistentin the projections may not be in the full pose space.However, significant errors are unlikely, because theregions of the pose space consistent with each minimalmatching do not deviate far from the manifold corre-sponding the errorless case, except in extreme circum-stances (cases that are nearly degenerate).

Example. For circle detection, we saw previously thatwe should use two distinguished points. The circle po-sitions that share a pair of points lie on a curve in thepose space. (The center of the circle is always on theperpendicular bisector of the two distinguished points.)For triples of points that contain the two distinguished

points, we parameterize the positions using the signeddistance d from the center of the circle to the midpointbetween the distinguished points (positive if above,negative if below). This yields a unique descriptor forevery circle passing through the distinguished points.For each triple that is considered, we can project thepose space consistent with the triple onto the parameter-ization by considering which centers are possible givensome error bounds on the point locations (Olson, 1999).We determine if a circle is present in each trial by finelydiscretizing d and performing a simple Hough trans-form variation in this one-dimensional space, where thecounter for each bin is incremented for each triple thatis consistent with the span represented by the counter.Peaks in the accumulator are accepted if they surpasssome predetermined threshold. This process is repeatedfor several pairs of distinguished points to ensure a lowprobability of failure, as described in the next section.

6. Randomization and Complexity

A deterministic implementation of these ideas shouldexamine each possible distinguished matching withthe appropriate cardinality. This requires O(nk) time,where n is the number of possible matches betweena data feature and the model. When explicit match-ings are considered, n = md, where m is the numberof model features and d is the number of data features.When implicit matchings are considered, n = d. Sucha deterministic implementation performs much redun-dant work. There are many distinguished matchingsthat are part of each of the large consistent matchingsthat we are seeking. We thus find each matching thatmeets the acceptance criterion many times (once foreach distinguished matching that is contained in themaximal matching). We can take advantage of this re-dundancy through the use of a common randomizationtechnique to limit the number of subproblems that wemust consider while maintaining a low probability offailure.

Assume that some minimum number of the imagefeatures belong to the model. Denote this number b.Since our usual acceptance criterion is based on count-ing the number of image features that belong to themodel, we can allow the procedure to fail when toofew image features belong to the model. Otherwise,the probability that some set of image features withcardinality g = k − 1 completely belongs to the modelis bounded by ( b

k−1 )/(d

k−1 ) ≈ ( bd )k−1. If we take t tri-

als that select sets of k − 1 image features randomly,

Geometric Feature Matching and Model Extraction 47

then the probability that none of them will completelybelong to the model is:

pt ≈(

1 −(

b

d

)k−1)t

. (2)

Setting this probability below some arbitrarily smallthreshold (pt < γ ) yields:

t ≈ ln γ

ln(1 − (

bd

)k−1) ≈(

d

b

)k−1

ln1

γ. (3)

Now, for explicit matches, we assume that some min-imum fraction fe of the model features appear in theimage. In this case, the number of trials necessary isapproximately ( d

fem )k−1 ln 1γ

. For each trial, we mustconsider matching the set of image features againsteach possible matching set of model features, so thetotal number of distinguished matchings that are con-sidered is approximately ( d

fe)k−1(k − 1)! ln 1

γ. Each ex-

plicit distinguished matching requires O(md) time toprocess, so the overall time required is O(mdk). Notethat if we use g < k − 1 (that is, a smaller set of distin-guished points than we have been discussing,) we willexamine O(mk−gnk−g) minimal matchings for eachdistinguished matching and the overall complexity in-creases to O(mk−gdk). For this reason, the use of fewerthan g = k − 1 distinguished points is suboptimal.

For implicit matches, we assume that each signif-icant model in the image comprises some minimumfraction fi of the image features. The number of trialsnecessary to achieve a probability of failure below γ

is approximately f 1−ki ln 1

γ, which is a constant inde-

pendent of the number of image features. Since eachtrial can be performed in O(d) time, the overall time re-quired is O(d). If a smaller distinguished matching wasused, the trials would require O(dk−g) time, since weconsider all minimal matchings that contain the distin-guished matching. Again we see that the use of a smalldistinguished matching yields an increased computa-tional complexity.

Note that the complexity can be reduced further insome cases by performing subsampling among the min-imal matchings considered in each trial. Indeed, O(1)

complexity is possible with some assumptions aboutthe number of features present and the rate of errorsallowable (Bergen and Shvaytser, 1991). We have notfound this further complexity reduction to be necessaryin our experiments. In fact, in most cases the number ofsamples necessary with this technique is large. How-ever, this technique may be useful when the number ofimage features is very large.

Grouping techniques can also be used to improvethe computational complexity of the algorithm. If wehave some method that can determine feature sets thatare more likely to belong to the same model, we canuse these as sets of distinguished features in the image.Such methods can be used to reduce the likelihood ofa false positive match in addition to reducing the com-putational complexity (Olson, 1998).

Example. Our circle detection case uses implicitmatchings. If we assume that each circle that we wishto detect comprises at least fi = 5% of the image dataand require that the probability of failure is belowγ = 0.1%, then the number of trials necessary is 2764.Each trial considers the remaining d − 2 image fea-tures. Note that techniques considering all triples willsurpass the number of triples considered here whend > 53.

7. Comparison with Previous Techniques

This section gives a comparison of the RUDR ap-proach with previous generate-and-test and Hough-based techniques.

Deterministic generate-and-test techniques requireO(nk+1) time to perform model extraction in general,since there are O(nk) minimal matchings and thetesting stage can be implemented O(n) time. Thiscan often be reduced slightly through the use of effi-cient geometric searching techniques during the testingstage. RUDR yields a superior computational com-plexity requirement. When randomization is applied togenerate-and-test techniques, the computational com-plexity becomes O(mdk+1) (or slightly better using ef-ficient geometric search) for explicit matches and O(d)

for implicit matches. RUDR yields a superior compu-tational complexity for the case of explicit matchesand, while the generate-and-test approach matches thecomplexity for the case of implicit matches, RUDRexamines less subproblems by a constant factor (ap-proximately 1

fi) and is, thus, faster in practice.

In addition, previous generate-and-test techniquesare inherently less precise in the propagation of local-ization error. The basic generate-and-test algorithm in-troduces false positives unless care is taken to propagatethe errors correctly (Alter and Jacobs, 1998; Grimsonet al., 1994), since error in the data features leads to er-ror in the hypothetical model pose and this error causessome of the models to be missed as a result of a poorfit. On the other hand, when error propagation is used,

48 Olson

false positives are introduced. The error propagationtechniques ensure that each of the undistinguished fea-tures can be separately brought into alignment (alongwith the distinguished set) up to some error bounds bya single model position, this position may be differentfor each such feature match. It does not guarantee thatall of the features can be brought into alignment up tothe error bounds by a single position and thus causesfalse positives to be found.

Hough-based methods are capable of propagatinglocalization error such that neither false positives norfalse negatives occur (in the sense that only matchingsmeeting the acceptance criterion are reported) (Breuel,1992; Cass, 1997). However, previous Hough-basedmethods have had large time and space requirements.Deterministic Hough-based techniques that examineminimal matchings require O(nk) time and consider-able memory (Olson, 1997b).

Randomization has been previously applied toHough transform techniques (Bergen and Shvaytser,1991; Kiryati et al., 1991; Leavers, 1992; Xu et al.,1990). However, in previous methods, randomizationhas been used in a different manner than it is used here.While our approach examines all of the data in eachof the subproblems, previous uses of randomizationin Hough-based methods have subsampled the overalldata examined, causing both false positives and falsenegatives to occur as a result. While false negatives canalso occur due to the use of randomization in our ap-proach, the probability of such an occurrence can beset arbitrarily low, with a logarithmic dependency onthe failure rate.

Our method draws the ability to propagate local-ization error accurately from Hough-based methodsand combines it with the ability to subdivide the prob-lem into many smaller subproblems and thus gain thefull benefit of randomization techniques. The result isa model extraction algorithm with superior computa-tional complexity to previous methods that is also ro-bust with respect to false positives and false negatives.

All of the techniques considered so far have beenmodel-based methods. The primary drawback to suchtechniques is a combinatorial complexity that is poly-nomial in the number of features, but exponential inthe complexity of the pose space (as measured by k).This can be subverted in some cases by assuming thatsome fraction of the data features arises from the model(this shifts the base of the exponent to be the requiredfraction). An alternative that can be useful in reduc-ing this problem is the use of grouping or perceptual

organization methods that use data-driven techniquesto determine features that are likely to belong to thesame model (for example, Jacobs, 1996; Lowe, 1985).In cases where models can be identified by purely data-driven methods, such techniques may be faster than thetechniques described here. However, we have shownthat even imperfect feature grouping methods can im-prove both the complexity and lower the rate of falsepositives in the RUDR method (Olson, 1998).

There are some situations where RUDR can not beapplied effectively. If a single data feature is sufficientto constrain the position of the model, the RUDR prob-lem decomposition will not be useful. In addition, thetechniques we describe will be of less value when thereis a small number of features in the image. In this case,the randomization may not yield an improvement in thespeed of the algorithm. However, the error propagationtechniques will still be beneficial.

8. Case Studies

We have studied the application of these ideas to severalproblems. We review the important aspects of theseapplications here and discuss additional areas whereRUDR can be applied. The problems described hereshow some of the generality of this method. How-ever, there remain a wide variety of additional problemswhere these techniques have not yet been applied.

8.1. Extraction of Geometric Primitives

As previously discussed, the Hough transform is a wellknown technique for geometric primitive extraction(Illingworth and Kittler, 1988; Leavers, 1993). The ap-plication of RUDR to this method improves the effi-ciency of the technique, allows the localization error tobe propagated accurately, and reduces the amount ofmemory that is required (Olson, 1999).

Consider the case of detecting curves from featurepoints in two-dimensional image data. If we wish todetect curves with p parameters, then we use distin-guished matchings consisting of p − 1 feature points,since, in general, p points are required to solve for thecurve parameters. Each distingusihed matching mapsto a one-dimensional manifold (a curve) in the param-eter space, if the points are errorless and in generalposition. Methods have been developed to map mini-mal matchings with bounded error into segments of thecurve for the cases of lines and circles (Olson, 1999).O(d) time and space is required for curve detection

Geometric Feature Matching and Model Extraction 49

Figure 1. Circle detection. (a) Engineering drawing. (b) Circles found comprising 4% of the image. (c) Perceptually salient circles foundcomprising 0.8% of the image. (d) Insalient circles found comprising 0.8% of the image.

with these techniques, where d is the number of datapoints extracted from the image.

The case of circle detection has been discussed insome detail in the running example. Figure 1 showsthe results of using RUDR to detect circles in a binaryimage of an engineering drawing. Note that, when alow threshold is used, small circles are found that arenot perceptually salient. These circles meet the accep-tance criterion specified, so this is not a failure of thealgorithm.

The image in Fig. 1 contains 9299 edge pixels. Inorder to detect circles comprising 4% of the image,RUDR examines 4318 trials and considers 4.01 × 107

triples. Contrast this to the 8.04 × 1011 possible triples.A generate-and-test technique using the same type ofrandomization examines 1.08 × 105 trials (1.00 × 109

triples) to achieve the same probability of examining acorrect trial, but will still miss circles due to the errorin the features.

The robustness of this technique for line detectionhas been compared against other methods in a large

number of synthetic images. The methodology and anexample synthetic image have been previously pub-lished (Olson, 1999). This methodology has been ex-tended to include generate-and-test methods here. Fivemethods have been compared:

1. The RUDR paradigm with propagated localizationerror.

2. The RUDR paradigm without propagated localiza-tion error.

3. A method mapping pairs of points into the parameterspace, but without decomposition into subproblems.

4. The standard Hough transform.5. Generate-and-test line detection. Four times as

many trials were used as in the first and secondmethods.

Figure 2 shows the results. For each method, theprobability of detecting the single correct line segmentpresent in the image is plotted versus the probability offinding a false positive (curved distractors were added

50 Olson

Figure 2. Receiver operating characteristic (ROC) curves for line detection generated using synthetic data.

to the images) for varying levels of the threshold usedto determine which lines are detected.

The best performance is achieved by the RUDRparadigm with propagation of localization error into theparameter space. It is important to note that the RUDRparadigm fares much worse when localization error isnot propagated carefully. This reason for this is thatthe method without propagation only succeeds whenone of the trials that is examined uses a distinguishedmatching that is quite close to the model to be de-tected. However, when a trial with a significant amountof error is examined, the method becomes likely to fail(like generate-and-test methods), due to the poor modelfit. This experiment demonstrates the importance ofpropagating the localization error into the parameterspace when using techniques with a generate-and-testcomponent.

8.2. Robust Regression

RUDR has been applied to the problem of finding theleast-median-of-squares (LMS) regression line. In thiscase, a single distinguished point is examined in eachtrial (since two points are required to define a line). Foreach trial, we determine the line that is optimal withrespect to the median residual, but with the constraintthat the line must pass through the distinguished point.

It can be shown that the solution to this constrainedproblem has a median residual that is no more than the

sum of the optimal median residual and the distance ofthe distinguished point from the optimal LMS regres-sion line (Olson, 1997a). Now, at least half of the datapoints must lie no farther from the optimal regressionline than the optimal median residual (by definition).Thus, each trial has a probability of at least 0.5 of ob-taining a solution with a residual no worse than twicethe optimal median residual. The use of randomizationimplies that we need to perform only a constant numberof trials to achieve a good solution with high probability(approximately − log2 δ trials are necessary to achievean error rate of δ).

Each subproblem (corresponding to a distinguishedpoint) can be solved using a specialized methodbased on parametric search techniques (Olson, 1997a).This allows each subproblem to be solved exactly inO(n log2 n) time or in O(n log n) time for a fixed pre-cision solution using numerical techniques. These tech-niques have also been extended to problems in higherdimensional spaces.

The complexity of our method is superior to the bestknown exact algorithms for this problem (Edelsbrunnerand Souvaine, 1990). The PROGRESS algorithm(Rousseeuw and Leroy, 1987) is a commonly used ap-proximation algorithm for LMS regression that usesthe generate-and-test paradigm. It requires O(n) time.The basic method for line detection is to sample pairsof points from the data and examine the median resid-ual of the line that passes through the points. The line

Geometric Feature Matching and Model Extraction 51

Figure 3. Robust regression examples. The solid lines are the RUDR LMS estimate. The dashed lines are the PROGRESS LMS estimate. Thedotted lines are the least-squares fit.

with the lowest median residual is kept. Unlike our al-gorithm, this algorithm yields no lower bounds (withhigh probability) on the quality of the solution detected.

Figure 3 shows two examples where RUDR,PROGRESS, and least-squares estimation were usedto perform linear regression. In these examples, weused 400 inliers and 100 outliers, both from two-dimensional normal distributions. For these experi-ments, 10 trials of the RUDR algorithm were consid-ered, and 50 trials of the PROGRESS algorithm. Forboth examples, RUDR produces the best fit to the in-liers. The least-squares fit is known to be non-robust, soit is not surprising that it fairs poorly. The PROGRESSalgorithm also results in lower quality fits, since, evenin 50 trials, it failed generate a solution that was closeenough to the optimal solution.

8.3. Object Recognition

The application of RUDR to object recognition yieldsan algorithm with O(mdk) computational complexity,where m is the number of model features, d is the num-ber of data featuers, and k is the minimum number offeature matches necessary to constrain the position ofthe model up to a finite ambiguity in the case of error-less features in general position.

We have examined the recognition of three-dimensional objects using two-dimensional image

data, for which k = 3 (Olson, 1997b). In each subprob-lem, we compute the pose for each minimal match-ing containing the distinguished matching using themethod of Huttenlocher and Ullman (1990). We thenuse a multi-dimensional histogramming technique thatexamines each axis of the pose space separately. Afterfinding the clusters along some axis in the pose space,the clusters of sufficient size are then analyzed recur-sively in the remainder of the pose space. The poses forall sets of points sharing a distinguished matching withcardinality k − 1 lie in a two-dimensional subspace forthis case. Despite this fact, we perform the histogram-ming in the full six-dimensional space, since this re-quires little extra time and space with our histogram-ming method. Feature error has been treated in an adhoc manner in this implementation through the exami-nation of overlapping bins in the pose space. Compleximages may require a more thorough analysis of theerrors.

We can also apply these techniques to images inwhich imperfect grouping techniques have determinedsets of points that are likely to derive from the sameobject (Olson, 1998). This allows a reduction in boththe computational complexity and the rate of falsepositives.

Figure 4 shows an example where this approach hasbeen applied to the recognition of a three-dimensionalobject. Also shown in this figure are poses generatedusing the alignment method (Huttenlocher and Ullman,

52 Olson

Figure 4. Three-dimensional object recognition. (a) Corners detected in the image. (b) Best hypothesis found. (c) Example pose generatedusing alignment. (d) Example pose generated using alignment.

1990). Figure 4(c) shows a case where the distingui-shed points are well distributed across of the object.Even in this case, the pose is significantly in error, withthe upper right corner of the model off by over eightpixels due to corner detection error and perspectivedistortion. When the distinguished points are not welldistributed, the error can be much worse, as is shownin Fig. 4(d). These examples illustrate the sensitivity toerror that generate-and-test methods suffer from.

8.4. Motion Segmentation

In addition to the applications that we have previouslystudied, RUDR can be used to perform motion seg-mentation with any technique for determining struc-ture and motion from corresponding data features inmultiple images. In this problem, we are given sets ofdata features in multiple images. We assume that weknow the feature correspondences between images (forexample, from a tracking mechanism), but not whichsets of features belong to rigid objects.

Say that we have an algorithm to determine struc-ture and motion using k feature correspondences ini images and that there are d features for which weknow the correspondences between the images. (SeeHuang and Netravali, 1994 for a review of such tech-niques.) We examine distinguished matchings of k − 1sets of feature correspondences between the images.Each subproblem is solved by determining the hypo-thetical structure and motion of each minimal matching(sets of k feature correspondences) containing the dis-tinguished matching and then determining how manyof the minimal matchings yield consistent structuresfor the distinguished matching and motions that areconsistent with them belonging to a single object. Thisis repeated for enough distinguished matchings to findall of the rigidly moving objects consisting of someminimum fraction of all image features.

Our analysis for implicit matchings implies that wemust examine approximately ε1−k ln 1

γtrials to find ob-

jects whose fraction of the total number of data featuresis at least ε with a probability of failure for a particularobject no larger than γ .

Geometric Feature Matching and Model Extraction 53

9. Summary

This paper has described a technique for solving modelextraction and fitting problems such as recognition andregression that we have named RUDR. This approachis very general and can be applied to a wide varietyproblems where a model is fit to a set of data featuresand it is tolerant to noisy data features, occlusion, andoutliers.

The RUDR method draws advantages from both thegenerate-and-test paradigm and from parameter spacemethods based on the Hough transform. The key ideasare:

1. Break down the problem into many small subprob-lems in which only the model positions consistentwith some distinguished matching of features areexamined.

2. Use randomization techniques to limit the numberof subproblems that need to be examined to guar-antee a low probability of failure.

3. Use clustering or parameter space analysis tech-niques to determine the matchings that satisfy thecriteria.

The use of this technique yields two primary advan-tages over previous methods. First, RUDR is computa-tionally efficient and has a low memory requirement.Second, we can use methods by which the localizationerror in the data features is propagated precisely, so thatfalse positives and false negatives do not occur.

Acknowledgments

The research described in this paper was carried out inpart at the Jet Propulsion Laboratory, California Insti-tute of Technology, and was sponsored in part by theAir Force Research Laboratory at Tyndall Air ForceBase, Panama City, Florida, through an agreement withthe National Aeronautics and Space Administration.Portions of this research were carried out while theauthor was with Cornell University and with the Uni-versity of California at Berkeley. A condensed versionof this work appeared in the Vision Algorithms: Theoryand Practice Workshop (Olson, 2000).

Notes

1. Early Hough transform strategies mapped single features intomanifolds in the parameter space, but further work in Houghtransforms has improved on these techniques by mapping sets

of data features into points in the parameter space (Bergen andShvaytser, 1991; Leavers, 1992; Xu et al., 1990).

2. This is not always true. For example, consider the case where thedata and the model consist of sets of three-dimensional pointsand the transformation space is the six-dimensional space of rigidmotions. Each individual match between a data point and a modelpoint yields three constraints on the position of the model. How-ever, a pair of such matches yields only five constraints, since therotation around the segment joining the points is unconstrained.In this case, the additional constraint lies in the distance betweenthe points, which must be the same in both the model and the data.

References

Alter, T.D. and Jacobs, D.W. 1998. Uncertainty propagation inmodel-based recognition. International Journal of ComputerVision, 27(2):127–159.

Ayache, N. and Faugeras, O.D. 1986. HYPER: A new approachfor the recognition and positioning of two-dimensional objects.IEEE Transactions on Pattern Analysis and Machine Intelligence,8(1):44–54.

Ballard, D.H. 1981. Generalizing the Hough transform to detect ar-bitrary shapes. Pattern Recognition, 13(2):111–122.

Bergen, J.R. and Shvaytser, H. 1991. A probabilistic algorithm forcomputing Hough transforms. Journal of Algorithms, 12:639–656.

Bolles, R.C. and Fischler, M.S. 1981. A RANSAC-based approach tomodel fitting and its application to finding cylinders in range data.In Proceedings of the International Joint Conference on ArtificialIntelligence, pp. 637–642.

Breuel, T.M. 1992. Fast recognition using adaptive subdivisions oftransformation space. In Proceedings of the IEEE Conference onComputer Vision and Pattern Recognition, pp. 445–451.

Cass, T.A. 1997. Polynomial-time geometric matching for ob-ject recognition. International Journal of Computer Vision,21(1/2):37–61.

Duda, R.O. and Hart, P.E. 1972. Use of the Hough transformation todetect lines and curves in pictures. Communications of the ACM,15:11–15.

Edelsbrunner, H. and Souvaine, D.L. 1990. Computing least medianof squares regression lines and guided topological sweep. Journalof the American Statistical Association, 85(409):115–119.

Faugeras, O.D. and Hebert, M. 1986. The representation, recogni-tion, and locating of 3-d objects. International Journal of RoboticsResearch, 5(3):27–52.

Fischler, M.A. and Bolles, R.C. 1981. Random sample consensus:A paradigm for model fitting with applications to image analysisand automated cartography. Communications of the ACM, 24:381–396.

Grimson, W.E.L. and Huttenlocher, D.P. 1990. On the sensitivity ofthe Hough transform for object recognition. IEEE Transactionson Pattern Analysis and Machine Intelligence, 12(3):255–274.

Grimson, W.E.L., Huttenlocher, D.P., and Jacobs, D.W. 1994. A studyof affine matching with bounded sensor error. International Jour-nal of Computer Vision, 13(1):7–32.

Hough, P.V.C. 1962. Method and means for recognizing complexpatterns. U.S. Patent 3069654.

Huang, T.S. and Netravali, A.N. 1994. Motion and structure fromfeature correspondences: A review. In Proceedings of the IEEE,82(2):252–268.

54 Olson

Huttenlocher, D.P. and Ullman, S. 1990. Recognizing solid objectsby alignment with an image. International Journal of ComputerVision, 5(2):195–212.

Illingworth, J. and Kittler, J. 1988. A survey of the Hough transform.Computer Vision, Graphics, and Image Processing, 44:87–116.

Jacobs, D.W. 1996. Robust and efficient detection of salient con-vex groups. IEEE Transactions on Pattern Analysis and MachineIntelligence, 18(1):23–37.

Kiryati, N., Eldar, Y., and Bruckstein, A.M. 1991. A probabilisticHough transform. Pattern Recognition, 24(4):303–316.

Leavers, V.F. 1992. The dynamic generalized Hough transform: Itsrelationship to the probabilistic Hough transforms and an appli-cation to the concurrent detection of circles and ellipses. CVGIP:Image Understanding, 56(3):381–398.

Leavers, V.F. 1993. Which Hough transform? CVGIP: Image Un-derstanding, 58(2):250–264.

Linnainmaa, S., Harwood, D., and Davis, L.S. 1988. Pose determina-tion of a three-dimensional object using triangle pairs. IEEE Trans-actions on Pattern Analysis and Machine Intelligence, 10(5):634–647.

Lowe, D.G. 1985. Perceptual Organization and Visual Recognition.Kluwer Academic: Dordrecht.

Lowe, D.G. 1987. Three-dimensional object recognition from sin-gle two-dimensional images. Artificial Intelligence, Boston, MA,31:355–395.

Murakami, K., Koshimizu, H., and Hasegawa, K. 1986. On the newHough algorithms without two-dimensional array for parameterspace to detect a set of straight lines. In Proceedings of the IAPRInternational Conference on Pattern Recognition, pp. 831–833.

Olson, C.F. 1997a. An approximation algorithm for least medianof squares regression. Information Processing Letters, 63(5):237–241.

Olson, C.F. 1997b. Efficient pose clustering using a randomizedalgorithm. International Journal of Computer Vision, 23(2):131–147.

Olson, C.F. 1998. Improving the generalized Hough transformthrough imperfect grouping. Image and Vision Computing,16(9/10):627–634.

Olson, C.F. 1999. Constrained Hough transforms for curve detection.Computer Vision and Image Understanding, 73(3):329–345.

Olson, C.F. 2000. A general method for feature matching and modelextraction. Vision Algorithms: Theory and Practice, LNCS 1883,Springer-Verlag: Berlin, pp. 20–36.

Rosenfeld, A. 1969. Picture Processing by Computer. AcademicPress: New York, NY.

Rousseeuw, P.J. and Leroy, A.M. 1987. Robust Regression and Out-lier Detection. John Wiley and Sons: New York.

Shapiro, S.D. 1978. Generalization of the Hough transform forcurve detection in noisy digital images. In Proceedings of the In-ternational Joint Conference on Pattern Recognition, pp. 710–714.

Silberberg, T.M., Davis, L.S., and Harwood, D.A. 1984. An itera-tive Hough procedure for three-dimensional object recognition.Pattern Recognition, 17(6):621–629.

Stockman, G. 1987. Object recognition and localization via poseclustering. Computer Vision, Graphics, and Image Processing,40:361–387.

Thompson, D.W. and Mundy, J.L. 1987. Three-dimensional modelmatching from an unconstrained viewpoint. In Proceedings of theIEEE Conference on Robotics and Automation, Vol. 1, pp. 208–220.

Xu, L., Oja, E., and Kultanen, P. 1990. A new curve detection method:Randomized Hough transform (RHT). Pattern RecognitionLetters, 11:331–338.