Computer-Aided Design 44 (2012) 709–720

Contents lists available at SciVerse ScienceDirect

Computer-Aided Design

journal homepage: www.elsevier.com/locate/cad

Computing parameter ranges in constructive geometric constraint solving:Implementation and correctness proofMarta Hidalgo, Robert Joan-Arinyo ∗

Grup d’Informàtica a l’Enginyeria, Universitat Politècnica de Catalunya, Diagonal 649, 8è, Barcelona 08028, Catalonia

a r t i c l e i n f o

Article history:Received 8 November 2011Accepted 29 February 2012

Keywords:Parametric-based CADGeometric constraint solvingParameter range computationConfiguration space

a b s t r a c t

In parametric design, changing values of parameters to get different solution instances to the problemat hand is a paramount operation. One of the main issues when generating the solution instance for theactual set of parameters is that the user does not know in general which is the set of parameter valuesfor which the parametric solution is feasible. Similarly, in constraint-based dynamic geometry, knowingthe set of critical points where construction feasibility changes would allow to avoid unexpected andunwanted behaviors.

We consider parametric models in the Euclidean space with one internal degree of freedom. In thisscenario, in general, the set of values of the variant parameter forwhich the parametricmodel is realizableand defines a valid shape is a set of intervals on the real line.

In this work we report on our experiments implementing the van der Meiden Approach to computethe set of parameter values that bound intervals for which the parametric object is realizable. Theimplementation is developed on top of a constructive, ruler-and-compass geometric constraint solver.We formalize the underlying concepts and prove that our implementation is correct, that is, the approachexactly computes all the feasible interval bounds.

© 2012 Elsevier Ltd. All rights reserved.

1. Introduction

Many applications in computer-aided design, computer-aidedmanufacturing, kinematics, robotics or dynamic geometry are con-veniently modeled by geometric problems defined by geometricconstraints with parameters, some of them representing dimen-sions. These generic models allow the user to easily generate spe-cific instances for various parameter and constraint values.

When parametric models are used in real applications, it isoften found that instantiation may fail for some parameter values.Assuming that failures are not due to bugs in the system, theyshould be attributed to a more basic problem, that is, a certaincombination of constraints in the model and values of parametersdo not define a valid shape. We consider parametric models ofgeometric objects in the Euclidean plane with one degree offreedom corresponding to a variant parameter, after discountingrotations and translations of the entire object.

In general, the set of values of the variant parameter for whichthe parametric model is realizable and defines a valid shape is a setof intervals on the real line. The goal of this work is to implementthe van der Meiden et al. approach [1,2], to figure out the set

∗ Corresponding author. Tel.: +34 93 401 66 69; fax: +34 93 401 60 50.E-mail addresses:mhidalgo@lsi.upc.edu (M. Hidalgo), robert@lsi.upc.edu

(R. Joan-Arinyo).

0010-4485/$ – see front matter© 2012 Elsevier Ltd. All rights reserved.doi:10.1016/j.cad.2012.02.012

of values of the variant parameter that bound these intervals.The approach is built on top of a constructive ruler-and-compasssolver. We prove that the algorithm is correct in the sense that ityields all and only bounds of the interval feasible values.

Computing the set of parameter values for which a parametricobject is realizable is a long standing problem. However, theliterature published concerning this problem is scarce. Shapiroand Vossler, [3], and Raghothama and Shapiro, [4–6], developeda theory on validity of parametric family of solids by investigatingthe relationship between Brep and CSG schemas in systems withdual representations for solidmodeling. The formulation is built onformalisms of algebraic topology. Unfortunately, it seems a ratherdifficult problem transforming these formalisms into effectivealgorithms.

Joan-Arinyo and Mata [7] reported on a method to computefeasible ranges for parameters in geometric constraint solvingunder the assumption that values assigned to parameters are non-trivial-width intervals. The method applies to complex systems ofgeometric constraints in both 2D and 3D and has been successfullyapplied in the dynamic geometry field, [8]. It is a general method,the main drawback, however, is that it is based on numericalsampling.

Hoffmann and Kim [9] developed a constructive approach tocalculate parameter ranges for systems of geometric constraintsthat include sets of isothetic line segments anddistance constraintsbetween them.Model instantiation for distance parameterswithin

710 M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720

the ranges output by the method preserve the topology of the setof isothetic lines.

In an illuminatingwork, van derMeiden [1], and vanderMeidenand Bronsvoort, [2], reported on a constructivemethod to calculateparameter ranges for systems of geometric constraints. Constraintsystems are restricted to systems of distance and angle constraintson points and straight lines in 2D or 3D spaces that are wellconstrained and decomposable respectively into triangular andtetrahedral subproblems. The method automatically determinesthe allowable range for a single parameter of the system, calledvariant parameter, that an actual solution exists for any value in therange. Themethod consists of two steps. First a set of values for thevariant parameter, called critical points, [10], for which some welldefined subproblem feasibility changes is computed. Once sorted,critical points define a sequence of intervals and their feasibilityis established by checking feasibility at some point within eachinterval.

Gao and Sitharam, in [11,12], described a general resultconcerning the computation of critical points for 2D problemswithone degree of freedom which include just points and distanceconstraints that can be abstracted as one degree of freedomHenneberg graphs. Here we consider problems including distanceand angle constraints that can be abstracted as tree decomposablegraphs, a superset of Henneberg graphs.

The van der Meiden et al. method is the subject of our study.In Section 2 we recall basic concepts on constructive geometricconstraint solving. Section 3 formalizes the geometric constraintproblem with one variant parameter. The van der Meiden methodand our implementation are described in Sections 4 and 5respectively. Section 6 is devoted to prove that the method iscorrect. Section 7 describes a case study to illustrate how theapproach works. Finally, in Section 8 we offer a short discussion.

2. Preliminaries

First we recall some basic concepts related to geometricconstraint solving in general. Then we focus on the constructivetechnique. For an in depth discussion on this topic see, forexample, [13–23].

2.1. Geometric constraint problems

In this paper we focus on the basic constraint problem definedas follows. Given a set of geometric elements G and a set ofconstraints between them C , place each geometric element in sucha way that the constraints are fulfilled. We consider 2D geometricconstraint problems defined by a set of geometric elements likepoints, lines, line segments, circles and circular arcs with fixedradius, alongwith a set of constraints like distance, angle, incidenceand tangency between any two geometric elements.

Fig. 1(a) shows an example of geometric constraint problemconsisting of six points {a, b, c, d, e, f }, nine point–point distanceconstraints {di, 1 ≤ i ≤ 9}. Fig. 1(b) shows the geometricconstraint problem abstracted as a graph where one noderepresents one geometric element and one labeled edge representsa geometric constraint defined on the two geometric elementsthe edge connects. In what follows we will represent geometricconstraint problems as graphs.

In what follows a geometric constraint problemwill be denotedby a tuple Π = ⟨G, C, P⟩ where G is the set of geometric objects, Cthe set of constraints defined on G and P is the set of parameters ofconstraints in C .

The constraint solving community is mainly interested inobjects which are invariant under rigid transformations oftranslation and rotation. This property is known as rigidity. Theintuitive concept of rigidity, the one that will be used here, is

a

b

Fig. 1. Geometric constraint problemexample. (a) Geometric sketch. (b) Geometricconstraint problem abstracted as a graph.

defined from the number of solutions of the considered problem.In this context, geometric constraint problems are categorized inthree different families:

1. Well constrained problems are geometric constraint problemswith a non-empty and finite set of solutions.

2. Over-constrained problems are those problems with no actualsolution. Generally, the elimination of one or more constraintsresults in a well constraint problem.

3. Under-constrained problems are geometric constraint prob-lems for which an infinite set of solutions exists. In these cases,not enough constraints are given.

In this work we only consider well constrained problems.

2.2. Constructive geometric constraint problem solving

Geometric constraint solving is arguably a core technology ofcomputer aided design and, by extension, geometric constraintsolving is also applicable in virtual reality and is closely relatedin a technical sense to geometric theorem proving. For solutiontechniques, geometric constraint solving also borrows heavilyfrom symbolic algebraic computation and matroid theory.

Many techniques have been reported in the literature thatprovide powerful and efficient methods for solving systems ofgeometric constraints. For a review, see [24]. Among all thegeometric constraint solving techniques, our interest here focuseson the one known as constructive.

Constructive geometric constraint solving is a techniquewidelyused in the geometric constraint solving field. We briefly recallhere the main features underlying this technique. An architecturefor constructive solvers is illustrated in Fig. 2 where squareboxes are functional units and rounded boxes are data entities.The functional units are the analyzer, the index selector andthe constructor. The data entities are the geometric constraintproblem, the construction plan, the parameters assignment andthe index assignment.

In this technology, the user defines a geometric constraintproblemby sketching some geometric elements taken froma givenrepertoire (points, lines, circles, etc.) and annotates the sketchwitha set of geometric relationships, called constraints, (point–pointdistance, point–line distance, angle between two lines and so on),that must be fulfilled.

Given the geometric constraint problem, Π = ⟨G, C, P⟩, theanalyzer is responsible for figuring out whether the solver isable to solve the problem. If the answer is positive, the analyzeroutputs the solution as a sequence of construction steps, knownas construction plan, that will place the geometric elements inpositions for which the constraints hold.

Fig. 3 shows a construction plan for the constraint problemgiven in Fig. 1. The meaning of each construction step is theusual. For example, origin() stands for the origin of an arbitrary

M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720 711

Fig. 2. An architecture for the constructive solving technique.

Fig. 3. Construction plan for the example problem in Fig. 1.

framework, b = distD(a, d3) places point b at distance d3 frompoint a, c2 = circleCR(a, d1) defines the circle c2 with center a andradius d1 and intCC(c1, c2) defines a point as the intersection ofcircles c1 and c2. Notice that symbols ci do not represent entities inthe problem. They are intermediate results introduced to increasereadability.

Solving a geometric constraint problem can be seen as solvinga set of, in general, nonlinear equations. Therefore, each equationcan have as many roots as the equation degree. Obviously, eachspecific root will result in a different placement for the geometricelements in the problem. Selecting the desired root, known asthe Root Identification Problem, [14], is the goal of the indexselector that associates each equation with several roots an indexthat unambiguously identifies the desired root. The index in theconstruction plan in Fig. 3 is I = {s1, s2, s3, s4}. For an in depthstudy of the index and the role it plays in a geometric constraintsolving see [8]. A number of techniques have been developedto deal with the Root identification problem. See, for example,[14,25–27].

The specific solution to the constraint problem Π identified byan assignment of values to the index I is called the intended solution.In what follows we consider that the intended solution has beenfixed and that equations degree is at most 2, that is, signs si in theindex take values in, say {−1, 1}.

Fig. 4. Construction plan as a tree decomposition.

Fig. 5. Sibling clusters pairwise share one geometric element.

Once values have been assigned to the indices, a more conve-nient way to represent the construction plan is the decomposi-tion tree [21], a way to represent decomposition–recombinationalgorithms (DR-algorithms) that solve geometric constraint prob-lems, [18]. Fig. 4 shows a decomposition tree for the constructionplan in Fig. 3. Each node in the tree stands for a rigid object, calledcluster, built on the geometric objects included in the curly brack-ets list and whose position relative to each other has already beendetermined. Leaf nodes represent elemental placement problemscorresponding to two geometric elements and the constraint de-fined on them. For example: two points at a given distance, a pointand a straight segment at a given distance, two straight segmentsat a given angle and so on. Edges in the decomposition tree repre-sent the merging of three solved clusters into a larger rigid clusterby application of a specific solving rule. The root node includes allthe geometric elements in the problem and represents a solutioninstance.

Notice that sibling clusters pairwise share one geometricelement, for example clusters {a, b, c, d}, {c, e} and {e, d} in thetree in Fig. 4 pairwise share c, e and d respectively. Fig. 5 illustratesthe situation. Shared geometric elements c, e and d are calledhinges. For a more formal rational on this topic see [16,20].

Finally, once a set of actual values have been assigned to theconstraint parameters and the intended solution has been selectedby assigning values to the index signs, the constructor buildsan instance of a placement for the geometric objects, a solutioninstance, provided that no numerical incompatibility arises due togeometric degeneracy.

This architecture, known generically as DR-planner, [18], showssome nice properties. First, the nature of the computations in eachstep is quite different. The analyzer requires symbolic computationwhile the constructor only performs numerical computations.Second, determining whether the problem is solvable by thesolver at hand or not is performed in the analysis step andit does not depend neither on the actual parameter values

712 M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720

d

a b e

c f

Fig. 6. Geometric constraint problem with one variant parameter λ.

Fig. 7. Objects belonging to the family defined by the problem in Fig. 6.

nor on the geometric computations. Next, with the proposeddecoupling, when computing instances for different parametervalues, only the construction step needs to be carried out. Thisallows to skip the analysis step, which is computationally themost expensive, as well as the index selection. Finally, givena symbolically solvable geometric constraint problem and aparameters assignment, the object can be instantiated if there arenot numerical impossibilities, for example trying to intersect twodisjoint circles that entails computing the square root of a negativevalue. These impossibilities are detected while carrying out thegeometric computations, and we say that the construction plan isunfeasible.

Construction plans expressed as decomposition trees will bedenoted by T.

3. Problems with one variant parameter

In this section we present basic concepts concerning geometricconstraint problems for which the value of a given constraintparameter is not fixed.

3.1. The construction plan as a function

Let Π = ⟨G, C, P⟩ be a well constrained geometric constraintproblem where all parameters in P have been assigned a givenvalue except for one, say λ, which can take arbitrary values in R.We will say that the resulting problem has one variant parameter.Fig. 6 shows a problem with one variant parameter.

Let T be a construction plan for the constraint problem Π =

⟨G, C, P⟩. The construction plan of a constraint problem dependson the set of constraint parameters and on the index and it isvalid for any problem derived from Π by considering one of itsparameters as variant. Therefore, for a given index, Tλ defines afamily of objects whose members are built as the value assignedto λ changes. Fig. 7 shows from left to right objects in the familydefined by the problem in Fig. 6 for index value s1 = +, s2 = +,s3 = +, s4 = +, distance constraint values d1 = 3, d2 = 3,d4 = 3.5, d5 = 3.5, d6 = 4, d7 = 4.5, d8 = 4, d9 = 3.5 andvalues of the variant parameter λ in {2.5, 4.5, 5.9}.

For some values of the variant parameter λ, however, itmay not be possible to satisfy the set of constraints in C ,

Table 1Feasibility conditions for some basic construction steps. λ is the variant parameter.

Basic construction Feasibility

abs(|d1| − |d2|) ≤ |λ| ≤ |d1| + |d2|

−d2/d1 ≤ tan(λ) ≤ d2/d1

0 ≤ λ ≤ 2π

− sin(λ) ≤ d2/d1 ≤ sin(λ) d1 ≥ d20 ≤ λ ≤ 2π d1 < d2

d1 sin(α) ≤ λ ≤ ∞

that is the construction plan Tλ is unfeasible for such variantparameter values. To formalize concepts related to constructionplan feasibility, we need some definitions.

Definition 3.1. Let Π = ⟨G, C, P⟩ be a geometric constraintproblem and T a construction plan that solves Π . Let x =

(x1, . . . , λ, . . . , xn) be the set of parameters in P with λ the variantparameter. Let xc = (x1c, . . . , λc, . . . , xnc) be the set of parametervalues where feasibility of Tλ changes. We say that xc is a criticalpoint of Tλ and λc is a critical variant parameter value.

To illustrate this concept, consider the construction shown inFig. 8 where a triangle is defined by giving the constraints b =

distD(a, d1), c = distD(b, d2), and λ = angle(ab, ac). If weassume that d1 ≥ d2 and consider λ as the variant parameter, theconstruction plan shown on the left of Fig. 8 is feasible for values ofλ in the range [0, sin−1(d2/d1)]. The bounds of this range are thecritical values of λ for this construction.

The situation described can be found for each basic constructionin a constructive solver and the corresponding feasibility rangescan be collected in a dictionary. Table 1 shows examples for somebasic constructions.

Definition 3.2. Let Π = ⟨G, C, P⟩ be a geometric constraintproblem with one variant parameter λ in P and let T be aconstruction plan that solvesΠ . The domain ofλ is the set of valuesfor which T is feasible.

In general the domain of a variant parameter is a set of disjointintervals bounded by critical variant parameter values. In thiscontext, a construction plan can be considered a function of thevariant parameter, Tλ. Since construction plan feasibility changesonly at critical points, as the value of λ changes continuously in itsdomain, the solution instance generated by Tλ traces a path in thespace of solutions to problem Π .

M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720 713

Fig. 8. Critical points for a triangle defined by two sides and the angle supported by one of them. Construction plan and actual construction.

a b c

Fig. 9. Dependency of a construction step. (a) Independent. (b) Directly dependent. (c) Indirectly dependent.

3.2. Dependency on the variant parameter

Dependency of a construction step on the variant parameter isa central concept in this work. Fig. 9(a) illustrates the definition ofindependent construction step.

Definition 3.3. Let Π = ⟨G, C, P⟩ be a constraint problem and Ta construction plan that solves Π . Let C1, C2 and C3 be the clustersinvolved in a construction step of Twhere u, v andw are the hingesthat u, v ∈ C1, v, w ∈ C2 and w, u ∈ C3. Assume that the variantparameter λ is defined on geometric elements u′, v′

∈ C1. We saythat the construction step does not depend on λ if there is a clusterC ′

1 ⊂ C1 that defines a rigid object which does not include both u′

and v′.

Notice that in independent construction steps the constructioncan be actually carried out without taking into account the valueof the variant parameter.

Next we define the concept of directly dependent constructionstep. See Fig. 9(b).

Definition 3.4. Let Π = ⟨G, C, P⟩ be a constraint problem and Ta construction plan that solves Π . Let C1, C2 and C3 be the clustersinvolved in a construction step of T with u, v and w hinges thatu, v ∈ C1, v, w ∈ C2 and w, u ∈ C3. Let λ be the variantcorresponding to the constraint defined upon hinges u, v in C1. Wesay that the construction step depends directly on λ.

Computing critical values of the variant parameter in directlydependent construction steps is straightforward because a feasibil-ity rule can be determined for each such cluster. See the dictionaryin Table 1.

Finally, the definition of indirectly dependent construction stepis illustrated in Fig. 9(b).

Definition 3.5. Let Π = ⟨G, C, P⟩ be a constraint problem and Ta construction plan that solves Π . Let C1, C2 and C3 be the clustersinvolved in a construction step of T where u, v and w hinges arehinges that u, v ∈ C1, v, w ∈ C2 and w, u ∈ C3. Let λ be definedon geometric elements of cluster C1. We say that the constructionstep depends indirectly on λ if it is not independent nor directlydependent.

By extension, we will say that a construction plan directlyor indirectly depends on the variant parameter when the planincludes a construction step with the corresponding dependency.

3.3. The variant parameter and construction subplans

Here we define the concepts of construction subplan thatfixes the value of the variant parameter λ and the set of signssignificative to λ.

Definition 3.6. Let Πλ = ⟨G, C, P⟩ be a geometric constraintproblemwith variant parameter λ ∈ P whose constraint is definedover geometric objects u, v ∈ G. Let Tλ be a construction plan thatsolves Πλ. Let Cλ be the cluster in Tλ with the smallest numberof geometric objects which places geometric elements u, v withrespect to a given framework. We define the construction subplanthat fixes the value of λ as the subplan of Tλ whose subtree rootis Cλ.

The set of signs occurring in the subplan that fixes the value of λwill play a central role in solving problems that depend indirectlyon the variant parameter. We define this set as follows.

Definition 3.7. Let Πλ = ⟨G, C, P⟩ be a geometric constraintproblem with variant parameter λ and index I . Let Tλ be aconstruction plan that solvesΠλ and let T′

λ be the subplan that fixesthe value of λ in Tλ. The significative index associated with λ is theset of signs Iλ ⊆ I occurring in the subplan T′

λ.

Since given a value assignment for the parameters in P , eachsign in the index entails a possible different placement for thegeometric elements, the significative index associated with thevariant parameter, Iλ, fixes the maximum number of differentactual constructions for cluster Cλ, the root of the subplan thatfixes λ.

4. The van der Meiden method

The van der Meiden et al. method to compute the domainof the variant parameter has two steps, [1,2]. In the first stepthe critical values for the variant parameter, that is, variant

714 M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720

Fig. 10. Computing critical points. Subproblems {a, b, d} and {a, b, c, d} directly depend on the variant parameter λ. Subproblem {a, b, c, d, e, f } indirectly depends on λ.

parameter values for which the construction plan feasibility mightchange, are computed. Then, in each interval defined by twosubsequent critical values, pick a value for the variant parameterand determine whether the construction plan is feasible. Sinceintervals may be open or closed at each bound, feasibility is alsochecked at these points. The variant parameter’s domain is theunion of the intervals where the construction plan is feasible.

The approach relies on the fact that, under the assumption thatthe variant parameter continuously changes within the intervalbounded by two subsequent critical points, construction planfeasibility does not change. Therefore, checking for feasibility inone point within the interval is sufficient to establish feasibilityover the whole interval. Besides, feasibility on the critical pointsmust also be checked in order to elucidate whether feasibleintervals are open or closed.

Because only one variant parameter is considered, degeneratesituations appear only on those subproblems that depend on thevariant parameter. For a subproblem that depends directly onthe variant parameter, critical values are computed applying adictionary that collects for each degenerate subproblem case aspecific solution method. For example, for a triangular problemconsisting on three points pairwise constrainedwith a point–pointdistance, the triangular inequality is applied. Fig. 10 illustrates thecase for the subproblems {a, b, c, d} (clusters in the middle) and{a, b, c, d, e, f } (clusters in the middle plus clusters on the right)with variant parameter λ.

If distance constraints take values d1 = 3, d2 = 3, d4 = 3.5,d5 = 3.5, d6 = 4, d7 = 4.5, d8 = 4, d9 = 3.5, the criticalvalues for the variant parameter λ = d3 in direct dependentproblems {a, b, d} and {a, b, c, d} are computed applying the rulesin the dictionary. Resulting critical values are respectively {0, 7}and {0, 6}.

When a subproblem depends indirectly on the variant param-eter, computing the relation between the critical variant param-eter values and the solutions of the degenerate problem is morecomplex and they are computed indirectly. First the indirect de-pendency is transformed into a direct one by removing the con-straint corresponding to the variant parameter and adding a newconstraint that captures the degeneracy in the current subproblem.Then themodified problem is solved and critical values for the orig-inal variant parameter are measured in the solution built for thecritical values of the modified problem.

If the variant parameter is λ as illustrated in Fig. 10 and thesubproblem currently under construction is {a, b, c, d, e, f }, themodified problem is the one shown in Fig. 11. Notice that now thesubproblem depends directly on the new variant parameter µ andit can be solved by applying the dictionary. Critical values for λare obtained by measuring the parameter λ in the solution to themodified problem for critical values of µ. Fig. 12(a) shows valuesmeasured for λ as the variant parameterµ changes in themodifiedproblem for the example at hand. For the actual parameters values

and according to the rules in the dictionary, critical values of µ are{0.5, 6.5, 8.5}. Corresponding values measured for λ are 0 if µ iseither 0.5 or 6.5. Forµ = 8.5 the construction plan for themodifiedproblem is not feasible thus λ cannot be measured and does notlead to any critical point.

Carrying over the critical values figured out for directlydependent subproblems, the resulting set of critical values are then{0, 6, 7}. Checking now construction plan feasibility for values of λat the critical values and for a value in each interval between twoconsecutive critical values, for example, at 3, 6.5 and 7.5, results inthe feasible domain ]0, 6] depicted in thick line in Fig. 12(b).

The main drawback of the method is that, since constructivesolvers in general are not complete, the problem resulting from thetransformation of the indirectly dependent problem does not needto be solvable by the solver at hand. In this case, either a differentsolving approach is applied or the method fails.

5. Our implementation

Algorithms have been implemented in Java(TM) SE 1.6.0_24,running on a personal computer featuring an Intel(R) Xeon(R)E5530 CPU running at 2.40 GHz and 3 GB RAM. For the sake ofmaking it easier to read, we report them here in pseudo-code.

Let T be the decomposition tree that solves the constraintproblem at hand. In our implementation, each node in T stores:1. T.built: A Boolean flag that takes value true whenever

the coordinates of the geometric object have been actuallycomputed with respect to a local framework,

2. T.coordinates: An array of coordinates that places everygeometric object with respect to a local framework,

3. T.rule: An identifier for the solving rule. If the node is a leaf,the rule is a basic placement. Otherwise the rule identifies themerging of three clusters,

4. T.hinges.u, T.hinges.v, T.hinges.w: Pointers to the hinges in theset of geometric objects on which the merging was carried out,and

5. T.left and T.right point to the left and right tree childrespectively.Without loss of generality and for the sake of simplicity and

convenience, we assume that the variant parameter is alwaysdefined upon geometric elements within the leftmost cluster ineach set of sibling nodes of T. Since we consider problems withjust one variant parameter and the order in which siblings aredepicted in the decomposition tree ismeaningless, this assumptionjust implies that the tree has been conveniently rewritten.

We assume that the set of geometric elements, G, the set ofconstraints, C , the vector of parameters in C, P , the index in Pof the variant parameter, i, and, the decomposition tree of theproblem being solved, T are stored as static variables. Moreover,T.built value is true for the leaf nodes and false otherwise. Ourimplementation is based on the algorithms listed in Algorithm 1through Algorithm 4.

M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720 715

Fig. 11. Modified problem. Subproblem {a, b, c, d, e, f } now directly depends on the variant parameter µ.

a

b

Fig. 12. (a) Measured values for λ as µ changes. (b) Critical points. The domain of variant parameter λ for which the construction plan is feasible shown as a thick line.

Algorithm 1 Computing the DomainK : Empty set of critical valuesD: Empty set of intervals of feasible values

function VariantParameterDomain()K := ComputeCriticalPoints(T)for each subsequent interval [c1, c2] in K do

pi := (c1 + c2)/2if ConstructionPlanFeasible(T) then

D := D + [c1, c2]Check for feasibility at interval bounds c1 and c2

end ifend forreturn Dendfunction

6. Algorithm correctness

In this section we show the correctness of our algorithm tocompute the domain of the variant parameter of a geometricconstraint solving problem with one variant parameter. A generalresult concerning the computation of critical points of 2Dconstraint systems including only points and point–point distanceconstraints with one degree of freedom that can be abstracted asone degree of freedom Henneberg graphs can be found in [11,12].Problems considered here include points, straight lines and circlesas geometric elements. The geometric constraints available includepoint–point distance, point–line perpendicular distance, line–lineangle, point on line, point on circle and line–circle tangency. Theconstraint graph that abstract the problems we consider are treedecomposable, a superset of Henneberg graphs.

6.1. The transformation

We start by showing that the transformation defined inSection 4 is always possible if the problem is well constrained.

Algorithm 2 Computing Critical PointsInput: The subtree T whose root is the current construction step

Output: The set of critical points K

function ComputeCriticalPoints()if not T.left.built then

ComputeCriticalPoints(T.left)end ifdependency = ComputeDependency(T.left.u, T.left.v)if dependency == DIRECT then

K := K+CriticalPointsFromDictionary(T.rule, pi)else if dependency == INDIRECT then

d := DummyParameter(T.hinges.u, T.hinges.v)T′

:= SubtreeThatFixesTheVariantParameter(T , d)G′

:= GeomsInT(T′)C ′

:= ConstraintsInT(T′)P ′

:= ParametersIn(T′)C ′

:= {C ′− ci} ∪ {cd}

P ′:= {P ′

− pi} ∪ {d}T′

:= SolveProblem(G′, C ′, P ′)I := Significative index associatedwith the dummyparameterdQ := CriticalPointsFromDictionary(T′.rule, d)for each q in Q do

for each possible assignment to signs in I doR := BuildRealization(T′, q, I)K := K+MeasureInRealization(R, pi)

end forend for

end ifT.built := truereturn K

Theorem 6.1. Let Π = ⟨G, C, P⟩ be a geometric constraint problemand T a construction plan that solves Π . Let C1, C2 and C3 be the

716 M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720

Algorithm 3 Compute the type of dependencyInput: hinges u, v in cluster C1Output: dependency on the variant parameter λ of a construc-tion step

function ComputeDependency(u, v)if λ is defined over hinges u and v then

return DIRECTelse if A constraint is defined over hinges u and v then

return INDEPENDENTelse if There is a cluster C ′

1 ⊂ C1 with |C ′

1(V )| ≥ 3, u, v ∈ C ′

1 andλ /∈ C ′

1 thenreturn INDEPENDENT

elsereturn INDIRECT

end if

Algorithm 4 Compute Dummy ParametersInput: hinges u, v in cluster C1Output: Type of needed dummy constraint

function DummyParameters(u, v)if IsApoint(u) and isApoint(v) then

return point-point-distanceelse if (IsApoint(u) and isAline(v)) or (IsApoint(v) andisAline(u)) then

return point-line-distanceelse if IsAline(u) and isAline(v) then

return line-line-angleend if

a b

Fig. 13. In well constrained problems, no constraint is defined on the hinges ofcluster C1 in construction steps that indirectly depend on the variant parameter λ.

three clusters in a construction step in T with hinges u, v and w thatu, v ∈ C1, v, w ∈ C2 andw, u ∈ C3. Let C1 be the cluster that dependson the variant parameter λ. If the construction step depends indirectlyon λ then no constraint is defined between hinges u and v in C1.

Proof. For a contradiction assume that there is a constraint in C1defined between hinges u and v. On the one hand, this constraintdoes not correspond to λ otherwise the construction step woulddepend directly on it. On the other hand, since the problem iswell constrained, clusters C ′

1 = {u, v}, C2 and C3 would define arigid object. Therefore merging C1, C2 and C3 would not dependon λ. �

Fig. 13 illustrates the situation. In a well constrained problemeither the variant parameter is defined on geometric elementswhich are not hinges, Fig. 13(a), or it is incident at most on onehinge, Fig. 13(b).

6.2. The set of solution instances

Now we show that the given problem and the transformedproblem have the same set of solution instances.

In Section 4, we have seen that, when a problem depends in-directly on the variant parameter, the van der Meiden methodcomputes ranges for feasible values of variant parameters trans-forming the problem by removing the variant parameter in thegiven problem and adding a convenient, new variant parameter.Thus, we need to prove that the sets of solution instances for thegiven problem and the modified problem are the same set.

The proof is guided by the idea illustrated in Fig. 14. Theconstruction step that indirectly depends on the variant parameterλ shown in Fig. 14(a) is transformed into a directly dependentstep on the new variant parameter µ, as shown in Fig. 14(b). Oncethe transformed problem is solved, Fig. 14(c), measures can betaken that give valid values to the variant parameter in the givenproblem.

Let Π = ⟨G, C, P⟩ be a well constrained geometric constraintproblem and T a construction plan that solves Π . We shall denoteby T(P, I) the instance of T resulting from evaluating T for thespecific values in P of the parameters in the constraints C and indexsigns fixed in I . We start the proof by stating a trivial lemma.

Lemma 6.1. Let Π = ⟨G, C, P⟩ be a well constrained geometricconstraint problem. Let T be a construction plan that solves Π andlet T(P, I) be a realization of the solution instance. Then for any pairof geometric objects gi, gj ∈ G any relationship between them can bemeasured in T(P, I).

Proof. Since the problem is well constrained, any realizationT(P, I) places all the geometric elements in G with respect to acommon reference. �

Nextwe state and prove a lemma that relates solution instancesfor different geometric constraint problems defined on the sameset of geometric elements for which tree decompositions areknown.

Lemma 6.2. Let Π1 = ⟨G, C1, P1⟩ and Π2 = ⟨G, C2, P2⟩ be twowell constrained geometric constraint problems defined on the sameset of geometric elements G. Let T1 and T2 be construction plans thatrespectively solve problemsΠ1 andΠ2 and let T1(P1, I1) be a solutioninstance for the problem Π1. If parameters in P2 and indices in I2are assigned values measured in the actual solution T1(P1, I1), thenT2(P2, I2) is a solution instance for Π2.

Proof. By Lemma 6.1, we can measure a value for any constraintparameter in C2 and derive any sign in I2 in the actual solutioninstance T1(P1, I1). The construction plan T2(P2, I2) represents allpossible solution instances to problem Π2 and in particular thesolution instance corresponding to values of P2 and I2 measuredfrom the actual construction T1(P1, I1). �

Finally, we have

Theorem 6.2. Let Πλ = ⟨G, Cλ, Pλ⟩ and Πµ = ⟨G, Cµ, Pµ⟩ betwo well constrained geometric constraint problems, defined on thesame set of geometric elements G with variant parameters λ and µrespectively, that fulfill Cλ − {λ} = Cµ − {µ}. Moreover, let Tλ andTµ be construction plans that respectively solve Πλ and Πµ. Thenthe sets of solution instances Tλ(Pλ, Iλ) and Tµ(Pµ, Iµ) generated byarbitrarily varying λ and µ are the same set.

Proof. For each value assigned to the variant parameter of one ofthe problems, apply Lemma 6.2. �

M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720 717

a b c

Fig. 14. (a) Construction step that depends indirectly on λ. (b) Construction for the transformed problem that depends directly on µ. (c) Construction where values for thevariant parameter λ are measured.

on

on

on

a b c

Fig. 15. (a) Piston and connecting rod crankshaft. (b) Geometric abstraction. (c) Construction plan.

6.3. Correctness

First we see that values of the variant parameter measured atcritical points of the transformed problem are critical values of theinitial problem.

Lemma 6.3. Let Πλ = ⟨G, Cλ, Pλ⟩ be a problem that indirectlydepends on λ. Let Πµ = ⟨G, Cµ, Pµ⟩ be the problem that directlydepends on parameter µ, resulting from transforming Πλ. LetTµ be a solution tree to Πµ for some index Iµ, and let xc =

{x1, . . . , µ∗, . . . , xn} be a critical point of Tµ. If λ∗ is the value ofparameter λ measured in Tµ(µ∗), then constructibility of Tλ changesat xc = {x1, . . . , λ∗, . . . , xn}. That is, xc is a critical point for theproblem Πλ.

Proof. Let xc = {x1, . . . , µ∗, . . . , xn} be a critical point forΠµ and λ∗ be the measure in Tµ for parameter λ. Assume thatC1, C2 and C3 are the three clusters involved in the indirectlydependent problem with C1 being the cluster that undergoes theproblem transformation. Since the problem is well constrained,and according to Theorem 6.2, continuously changing λ in clusterC1 of Tλ, will result in λ reaching the value λ∗. Then, µ will takethe value µ∗ and constructibility of Tλ will change accordinglyto the constructibility of the problem defined over C1, C2 and C3.Therefore xc = {x1, . . . , λ∗, . . . , xn} is a critical point for Πλ. �

Then we show that the algorithm figures out all the criticalpoints and only critical points.

Theorem 6.3. The algorithm given in Section 5 computes exactly theset of critical points of a given problem Πλ = ⟨G, C, Pλ⟩ if Tλ is aconstruction plan that solves the problem.

Proof. Since the algorithm visits once and only once each node inTλ that is directly or indirectly dependent on λ, each directly orindirectly dependent construction step is considered once and onlyonce. �

7. Case study

To further illustrate how our algorithm works, we develop acase study, depicted in Fig. 15. From left to right, the figure shows apiston and connecting rod crankshaft, an abstraction of the pistonrepresented as a geometric constraint problem, and an actualconstruction plan. The set of geometric elements includes fourpoints {p0, p1, p2, p3} and a straight line l. The set of constraintsincludes four point–point distances, d(p1, p0) = d0, d(p1, p2) =

d1, d(p2, p3) = d2, and d(p0, p3) = d3; and three point-on-lineconstraints onPL(p0, l), onPL(p2, l) and onPL(p3, l). We consider asvariant parameter λ the distance d2.

Fig. 16(a) shows the graph of the geometric constraint problemΠλ = ⟨G, C, P⟩, and Fig. 16(b) is the tree decomposition Tλ of aconstruction plan that solves the problem. Since we consider thatan intended solution for the problem has been selected, signs inthe index I = {s1, s2} have been fixed.

Clusters in the decomposition tree Tλ, the construction ofwhichdepends on λ, are {p0, p2, p3, l}, and {p0, p1, p2, p3, l}. Cluster

718 M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720

on

on

on

a b

Fig. 16. Piston and connecting rod crankshaft. (a) Problem graph. (b) Construction plan that solves the problem.

on

on

on

a b

Fig. 17. Piston and connecting rod crankshaft. Transformed problem. (a) Problem graph. (b) Construction plan that solves the problem.

a

b

Fig. 18. Piston and connecting rod crankshaft. Transformed problem. (a) Construction plan. (b) Geometric realization.

{p0, p2, p3, l} directly depends on the variant parameter λ, so thedictionary provides the critical values. The construction placespoint p2 on the straight line through points p0 and p3 and at a givendistance λ from p3. Since we do not consider signed distances, theconstruction is clearly feasible for 0 ≤ λ < ∞.

Cluster {p0, p1, p2, p3, l} depends indirectly on the variantparameter λ. Note that the value of λ is fixed by the subtreein the plan rooted at node {p0, p2, p3, l}, s1. Thus the problemis transformed by replacing the constraint λ = d(p2, p3) withµ = d(p2, p0). The graph of the transformed problem Πµ and aconstruction plan that solves it are shown in Fig. 17.

When solving the transformed problem, cluster {p0, p2, l}depends directly on µ. Since the cluster places two points onstraight line at a give distance, it is feasible for 0 ≤ µ < ∞.Then, cluster {p0, p2, p3, l} is also feasible for 0 ≤ λ < ∞.Cluster {p0, p1, p2, p3, l} depends directly on the variant parameterµ. According to the dictionary of critical points, Πµ is feasible if|d1 − d0| ≤ µ ≤ |d1| + |d0|. Considering, for example, specificparameters values d0 = 5, d1 = 8 and d3 = 14, we have that thetransformed problem is feasible if 3 ≤ µ ≤ 13.

Fig. 18 shows on the left a construction plan for the transformedproblem, Πµ, and on the right an actual geometric construction.

M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720 719

Fig. 19. Piston and connecting rod crankshaft. Feasible domain for variantparameter λ = d2 .

Values for signs have been fixed for the original problem but theyare unknown in the transformed problem.

The variant parameter λ in the original problem is definedover points p2 and p3 and the smallest cluster in the transformedproblem that includes these points is {p0, p2, p3, l}, which is built inthe construction step number 5, p2 = iLC(l, c0, s1). See Fig. 18(a).Therefore the significative index associated with µ is Iµ = {s1},and, in general, there will be two different possible placements forpoint p2, corresponding to the two possible intersections of circlec0 with line l. One construction places point p2 on the same side asp3 with respect to point p0. The other places p2 opposite to p3 withrespect to p0. See Fig. 18(b). Thus, there are two different measuresfor the variant parameter λ for each critical value of µ.

In the case we are considering, measures for λ taken in Tµ(3)are 11 and 17. Values measured for λ from Tµ(13) are 1 and 27.Therefore, the set of critical values for the variant parameter λ is{0, 1, 11, 17, 27, ∞}.

Checking feasibility of Tλ at the critical values and at, say, λtaking values in {0.5, 6, 14, 22, 28}, we find that the constructionplan is feasible at critical values {1, 11, 17, 27} and at Tλ(6) andTλ(22). Therefore the domain for the problem Πλ is [1, 11] ∪

[17, 27].The index of the construction plan shown in Fig. 15 that solves

the piston and connecting rod crankshaft problem includes twosigns I = {s1, s2}, hence up to four different intended solutioninstances can be selected. Applying our algorithm to each of themyields the feasibility domain depicted in Fig. 19 where feasibleintervals are filled in black. Notice that for signs assignments s1 =

+1, s2 = −1 and s1 = −1, s2 = −1 there are no feasible values.

8. Discussion

In parametric geometric modeling and its applications in fieldslike computer aided design and dynamic geometry, knowing theset of parameter values for which the model is realizable isparamount. This is a long standing open problem.

Van der Meiden in [2]and van der Meiden in [1] reported anapproach to compute feasible parameter ranges for 2D and 3Dgeometric constraint-based, parametric problems. The problemsconsidered in these works include points and straight lines asgeometric elements and point–point distance and line–line angleas constraints.

In this work we have described a specific implementationof the van der Meiden et al. approach, developed on top of aruler-and-compass geometric constraint solver. It is limited to2D problems but considers problems including points, straightlines and circles as geometric elements and point–point distance,perpendicular–straight line distance, line–line angle, point-on-circle and line–circle tangency. This means that underlyingequations have at most degree two and, therefore, signs in theconstruction plans take values in a binary set, say {+, −}. Clearly,this set up enlarges the class of problems considered by van derMeiden, [2] and by Gao and Sitharam in [11,12].

The implementation can be extended by considering a moregeneral class of solvable problems with more complicated cluster

combinations where underlying equations have degree three orhigher. We need to do two things. First we have to replace the setwhere index signs take values with a numbering as defined in [28].This numbering would allow to uniquely associate each differentsolution with a general equation. Next, for each new constructionrule, we need to include in the dictionary defined in Section 3 thecorresponding feasibility rule.

If circles are excluded, extending our implementation to3D problems would require replacing the underlying geometricconstraint solver with another similar to the one used by vander Meiden in [2]. A more general extension would requireconsidering, for example, planes as basic geometric objects andthe associated geometric constraints. A more difficult questionarises from the fact that constructive geometric constraint solvingin 3D entails hard open problems related to basic constructionsteps. These limitations and the technology available prevent thedevelopment of general constructive 3D solvers. See [29,30].

We have applied our prototype to a large benchmark ofconstraint problems. Running time allowed always real timeinteraction. However, a naive analysis of the worst case runningtime yields that time complexity of the approach is exponentialon the number of signs in the index. Just notice that, for anindirectly dependent problem, the algorithm needs to check all thepossible combinations of signs in the corresponding constructionsubplan. Gao and Sitharam in [11,12] claim that for constraintproblems involving points and point–point distances which canbe abstracted as one degree of freedom Henneberg-I graphs, therange of parameters can be computed in time linearwith respect tothe cardinality of the set of geometric objects. Tree decomposablegraphs considered in thiswork are a superset of Henneberg graphs.Therefore exploring how the tools developed in [11,12] generalizeto tree decomposable constraint graphs is a convenient startingpoint to improve the performance of the approach described here.

The Reachability problem in dynamic geometry refers to theproblem of deciding whether there is a continuous transformationthat brings a given starting geometric shape into an ending shapeby continuously changing one variant parameter. In this context,computing critical points is paramount. See [10]. Preliminary workreported in [31] describes and implements a frameworkwhere theReachability problem is solved using themethod described here tofigure out critical points without the burden of computing Voronoidiagrams as in [10].

Acknowledgments

We thank the editor and four anonymous referees for theirvaluable comments and constructive suggestions which helped toimprove the manuscript.

References

[1] vanderMeidenH. Semantics of families of objects. Ph.D. Thesis. Delft TechnicalUniversity. 2008.

[2] van der Meiden H, Bronsvoort W. A constructive approach to calculateparameter ranges for systems of geometric constraints. Computer-AidedDesign 2006;38:275–83.

[3] Shapiro V, Vossler D. What is a parametric family of solids? In: Proceedings ofthe third symposium on solid modeling and applications. Salt Lake City: ACMPress; 1995. p. 65–75.

[4] Raghothama S, Shapiro V. Necessary conditions for boundary representationsvariance. In: Proceedings of the 13th international annual symposium oncomputational geometry. New York: ACM Press; 1997. p. 77–86.

[5] Raghothama S, Shapiro V. Boundary representation deformation in parametricsolid modeling. ACM Transactions on Graphics 1998;17(4):259–86.

[6] Raghothama S, Shapiro V. Consistent updates in dual representation systems.In: Proceedings of the fifth symposium on solid modeling and applications.New York: ACM Press; 1999. p. 65–75.

[7] Joan-Arinyo R, Mata N. Applying constructive geometric constraint solvers togeometric problemswith interval parameters. Nonlinear Analysis 2001;47(1):213–24.

720 M. Hidalgo, R. Joan-Arinyo / Computer-Aided Design 44 (2012) 709–720

[8] Freixas M, Joan-Arinyo R, Soto-Riera A. A constraint-based dy-namic geometry system. Computer-Aided Design 2010;42:151–61.http://dx.doi.org/10.1016/j.cad.2009.02.016.

[9] Hoffmann C, Kim K. Towards valid parametric CAD models. Computer-AidedDesign 2001;33(1):376–408.

[10] Denner-Broser B. Tracing-problems in dynamic geometry. Ph.D. Thesis.Fachbereich Mathematik und Informatik der Freien Universität Berlin. 2008.

[11] Gao H, Sitharam M. Characterizing 1-Dof Henneberg-I graphs with efficientconfiguration spaces, http://arxiv.org/abs/0810.1997.

[12] Gao H, Sitharam M. Characterizing 1-Dof Henneberg-I graphs with efficientconfiguration spaces. In: SAC’09. 2009. p. 1122–6.

[13] Aldefeld B. Variation of geometric based on a geometric–reasoning method.Computer-Aided Design 1988;20(3):117–26.

[14] Bouma W, Fudos I, Hoffmann C, Cai J, Paige R. Geometric constraint solver.Computer-Aided Design 1995;27(6):487–501.

[15] Brüderlin B. Symbolic computer geometry for computer aided geometricdesign. In: Advances in design and manufacturing systems, proceedings NSFconference. 1990.

[16] Fudos I, Hoffmann C. A graph-constructive approach to solving systems ofgeometric constraints. ACM Transactions on Graphics 1997;16(2):179–216.

[17] Hoffmann C, Lomonosov A, Sitharam M. Decompostion plans for geometricconstraint problems, part II: new algorithms. Journal of Symbolic Computation2001;31:409–27.

[18] Hoffmann C, Lomonosov A, Sitharam M. Decompostion plans for geometricconstraint systems, part I: performance measurements for CAD. Journal ofSymbolic Computation 2001;31:367–408.

[19] Jerman C, Trombettoni G, Neveu B, Mathis P. Decomposition of geometric con-straint systems: a survey. International Journal of Computational Geometryand Applications 2006;16:379–414.

[20] Joan-Arinyo R, Soto A. A correct rule-based geometric constraint solver.Computers & Graphics 1997;21(5):599–609.

[21] Joan-Arinyo R, Soto-Riera A, Vila-Marta S, Vilaplana J. On the domainof constructive geometric constraint solving techniques. In: Duricovic R,

Czanner S, editors. Spring conference on computer graphics. Los Alamitos (CA,Budmerice, Slovakia): IEEE Computer Society; 2001. p. 49–54.

[22] Owen J. Algebraic solution for geometry from dimensional constraints.In: Rossignac R, Turner J, editors. Symposium on solid modeling foundationsand CAD/CAM applications. Austin (TX): ACM Press; 1991. p. 397–407.

[23] Thierry S. Décomposition et paramétrisation de systèmes de contraitesgéométriques sous-constraints. Ph.D. Thesis. Université de Strasbourg. 2010.

[24] Hoffmann C, Joan-Arinyo R. A brief on constraint solving. Computer-AidedDesign and Applications 2005;2(5):655–63.

[25] Joan-Arinyo R, Luzón M, Soto A. Genetic algorithms for root multiselection inconstructive geometric constraint solving. Computers & Graphics 2003;27(1):51–60.

[26] Joan-Arinyo R, Luzón M, Yeguas E. Search space pruning to solve theroot identification problem in geometric constraint solving. Computer-AidedDesign and Applications 2009;6:15–25.

[27] van der Meiden H, Bronsvoort W. An efficient method to determine theintended solution for a system of geometric constraints. International Journalof Computational Geometry 2005;15(3):79–98.

[28] Essert-Villard C, Schreck P, Dufourd J-F. Skecth-based pruning of a solutionspace within a formal geometric constraint solver. Artificial Intelligence 2000;124:139–59.

[29] Hoffmann C, Yuan B. On spatial constrint solving approaches. In: J. Richter-Gebert, D. Wand (Eds.), Proceedings of ADG’2000. 2000.

[30] Gao X-S, Hoffmann C, Yang W-Q. Solving spatial basic geometric constraintconfigurations with locus intersection. In: Proceedings of solid modelingSM’02. Saarbrucken (Germany): ACM Press; 2002.

[31] Hidalgo M, Joan-Arinyo R. The reachability problem in constructive geometricconstraint solving based dynamic geometry. Tech. rep. LSI-11-9-R. Departa-ment Llenguatges i Sistemes Informàtics. Universitat Politècnica de Catalunya.2011.