Intelligent Dragging Eric Allan Bier Dept. of EECS UC Berkeley Berkeley, CA 94720 Maureen C. Stone Xerox PARC 3333 Coyote Hill Rd. Palo Alto, CA 94304 Abstract We are interested in the problem of making precise line drawings, line drawings where specific relationships are expected to hold between points and lines, using interactive computer systems. In published computer graphics systems, precise relationships have been achieved by using rectangular grids, or by solving simultaneous equations (constraints). The availability of fast display hardware and plentiful computational power suggest that we should take another look at the ruler and compass techniques traditionally used by draftsmen. Intelligent dragging uses the ruler and compass metaphor to help the user place his next point with precision, and uses heuristics to automatically place those guiding lines and circles that are most likely to help the user construct each shape. Intelligent dragging also provides a simple mechanism for translation, rotation, and scaling transformations. We show that intelligent dragging compares favorably to grid techniques and constraint techniques in power and ease of use. CR Category: I.3.6 [Methodology and Techniques, Interactive techniques] Additional Keywords: Interactive design, geometric construction, constraint systems 1. Introduction Artists drawing technical illustrations often require that precise relationships hold among picture elements. For example, certain line segments should be horizontal, parallel, or congruent. Interactive illustration systems in the past have provided techniques such as grids and constraints to facilitate precise positioning. Both of these techniques have significant limitations. Grids provide only a small fraction of the desired types of precision. Constraints, while very powerful, require the user to specify and add extra structure that is often difficult to understand and time consuming to manipulate. We introduce an interactive technique, intelligent dragging, as a compromise between the convenience of grids and the power of constraints. Intelligent dragging is based on the familiar idea of snapping the display cursor to points and curves using a gravity function. The new idea is that a set of gravity active points, lines and circles called alignment objects are automatically constructed from hints given by the user plus heuristics about typical editing behavior. The result is a system with as much power as a ruler, compass, protractor, and T-square drafting set, but little time is spent moving the tools and setting up the constructions. The name "intelligent dragging" is meant to suggest that the program is making intelligent guesses about which gravity active objects to compute, but the user is performing all scene modifications individually by dragging scene objects until they snap onto gravity active objects. Intelligent dragging can be seen as an extension to the idea of gravity active grids (used in illustrators such as Griffin, Gremlin, MacDrawr, and Starr Graphics [Stone80] [Opperman84] [MacDraw84] [Lipkie82]) or as a diluted form of constraint-based system (such as Sketchpad, ThingLab, and Juno [Sutherland84] [Borning79] [Nelson85]. As in a grid system, the cursor may snap to gravity active objects provided by the system. However, the set of gravity active objects is richer and varies with the current scene and with the operation being performed. As in a constraint-based system, points can be placed to satisfy angle constraints, slope constraints, and distance constraints. However, with intelligent dragging, constraints are solved two at a time, with the user explicitly controlling the placement of each point, and the constraints are forgotten as soon as they are used rather than becoming part of the data structure. Intelligent dragging is currently implemented as part of the Gargoyle two dimensional illustrator, running in the Cedar programming environment [Swinehart80], on the Xerox Dorado high-performance personal workstation [Pier83]. All the figures in this paper except figure 7 were created with Gargoyle. In Section 2 we will present intelligent dragging in more detail. Section 3 is an analysis of design issues for geometric precision techniques, comparing grids, constraints and intelligent dragging. Section 4 presents more detail on the implementation of intelligent dragging. Section 5 summarizes our results. 2. Intelligent Dragging This section describes how intelligent dragging is used to construct shapes and perform transformations. In Gargoyle, a special point called the the caret can be placed with precision using gravity. The caret is distinct from the cursor in that the cursor always moves with the mouse, while the caret can stray from the cursor if a gravity active object attracts it. In construction operations a new point is always placed at the position of the caret. Positioning operations use the position of the caret as a parameter. When adding or moving a point to an object, affected line segments are adjusted in realtime using the technique called rubber-banding [Newman79]. Transformed objects are smoothly dragged into position. The user specifies via a menu or by typing any special points of interest and what kinds of precision are currently of interest. How many alignment objects to generate and where to place them is determined automatically. Alignment objects are visible only when the user is in the process of moving a point or object and are drawn in gray so they may be easily distinguished. Figure 1 shows how a user would adjust a point in an existing triangle to make the base horizontal. Figure 1 (a) The user has activated horizontal alignment lines, and picked up a vertex with the caret. Figure 1 (b) And drags the vertex until it snaps onto one of the alignment lines. When the operation is done, the alignment lines will disappear. Figure 2 demonstrates construction of an equilateral triangle 0.75 inch on a side with its base at 30 degrees to horizontal. Constructing the triangle takes six steps: 1) Activate lines of slope 30 degrees (click on a menu). 2) Activate 0.75 inch circles (click on a menu). 3) Place the lower left vertex. A 0.75 inch alignment circle appears centered on the new vertex, and an alignment line sloping at 30 degrees appears passing through the new vertex. 4) Place the second vertex at one of the intersections of the circle and the 30 degree line. Figure 2 (a). A second alignment circle appears, centered on the second vertex. 5) Place the last vertex at the intersection of the two circles. Figure 2 (b). 6) Invoke a close polygon command, or place a fourth vertex on top of the first. Since the operation is finished, the alignment objects disappear to allow the artist to inspect the shape. Figure 2 (c). Figure 2 (a) The user places the first two points of an equilateral triangle with side of length 0.75 inch and with its base at 30 degrees. A 0.75 inch circle and a 30 degree line appear. Figure 2 (b) Another circle appears. The last vertex is placed at the intersection of the two circles. Figure 2 (c) The triangle is closed and all alignment lines disappear. The whole process takes six keystrokes and all but two of these would be needed to draw any triangle. Note that it is impossible to construct an equilateral triangle using only a square grid and in most constraint systems, only a triangle with a horizontal base would be easy. Interactive transformations based on the current position of the cursor are already present in commercial illustrators. However, the ability to take advantage of alignment objects makes it easy to perform these operations with precision. Each transformation is performed in three steps. First, the objects to be transformed are selected. Second, the caret is placed at an initial position in the scene. Gravity and alignment objects can be used to choose this position with precision. Third, the selected objects are smoothly transformed (translated, rotated, or scaled) using the displacement between the original position of the caret and the new (constantly updated) position of the caret to determine the current transformation. Like the original caret position, the new caret position can be snapped to alignment objects. We will discuss the operations translate, rotate, and scale in more detail here. 2.1 Translation When performing translation, we simply add a displacement vector (old caret - new caret) to the original position of each selected object to get its new position. We move one polygon to touch another by selecting a point on the selected polygon in the first step, and a point on the target polygon at the end. Figure 3 shows how point-parameterized translation can be used to align two rectangles; the caret is snapped onto a 90 degree slope line in this example. Figure 3 An example of translation parameterized by two points (A and B). (a) the caret snaps onto Point A on the object which (b) the user then drags and snaps onto a vertical alignment line at point B. 2.2 Rotation The center of rotation, called the anchor, is placed by positioning the caret and invoking the Drop Anchor command. During rotation, the angle of rotation is kept equal to the angle through which the caret displacement vector has moved from its initial position. Consider the example in figure 4. We place the anchor point at the base of an arrow, make the initial selection at its tip (Point A), and make the final selection on the object we would like the arrow to point to (Point B). Figure 4 (a) Rotation is parameterized by 3 points (Anchor, A, and Caret). The anchor is the center of rotation, A is a point on the rotating object. The object is rotated to keep Anchor, A, and Caret collinear. Figure 4 (b) By placing the caret on a point of interest (point B), the arrow is made to point at it; Anchor, A, and B are collinear. 2.3 Scaling The anchor point is also used as the center of scaling. The magnitude of scaling is the ratio of the new caret displacement vector to the original caret displacement vector. This transformation can be used to scale one object until one of its dimensions matches a dimension of another object. In figure 5 the square is enlarged to fit onto an edge of the hexagon. Figure 5 (a) The anchor is fixed on one corner of the square and the caret is positioned on the adjacent corner. (b) The square is scaled as the caret is dragged to the vertex of the polygon. 3. Design Issues for Geometric Precision Tools The ideal tool is powerful but easy to use. Good tool design, therefore, requires a compromise between functionality and complexity of user interface. We measure the functionality of a geometric precision tool by examining which of a set of geometric relationships can be expressed directly. This set of relationships must be weighed against the total number of commands the user must learn and the time taken to specify all the arguments and invoke each command. Ease of use involves more than reduction of commands and keystrokes. A system that is easy to use will be predictable, require user input in proportion to the difficulty of the task, and be free from catastrophic failures which destroy hours of work. We will show that intelligent dragging makes it easy to reach these goals. In this section we will describe the sets of relationships we use to define the power of a geometric tool, and describe some important factors in making a system easy to use. In the process, we will compare intelligent dragging to grids and constraints. Geometric Power Our approach to the problem of making precise line drawings has been to assume that the designer will define shapes by carefully placing points rather than by sketching and aligning afterwards as described by Pavlidis and VanWyk [Pavlidis85]. This design philosophy focuses the design issues on methods for positioning points, and especially on the issue of positioning a new point with respect to the other points in a scene or with respect to the boundaries of the drawing space. Whether or not a picture is actually produced by placing one point at a time, we can measure the power of a geometric design system, particularly a polygon-based one, on the point-to-point relationships which its user can express. We describe one possible taxonomy of such relationships and use it to compare grid, constraint, and intelligent dragging systems. Geometric constructions can be organized into groups by the number of points in the construction. We have chosen this organization because it has a direct bearing on the user interface; constructions involving more points will take more work to specify, or will require more guesswork on the part of the tool. It is not possible to enumerate all possible interesting relationships between n points; we list constructions common in plane geometry, which are reflected in the tools of a typical drafting system. Each construction constrains only one degree of freedom of the new point; constructions that constrain both degrees of freedom can be built from these. Group 1: Place a point with respect to one other point in the scene. This group includes the operations: placing a point at a known x coordinate or a known y coordinate (relative to an existing point or the origin), placing a point at a specified distance from another point and placing a point such that the line segment between the points has a specified slope. Group 2: Place a point with respect to two other points in the scene. This group includes placing a point such that all three points define a specified angle, placing a point such that it is a specified distance from a line defined by two other points, and placing a point such that the distances between it and two other points are in a specified ratio (e.g. midpoint). Group 3: Place a point with respect to three other points in the scene. This group includes placing a point D relative to points A, B, and C so that segment CD is congruent to (or parallel to) AB. Figure 6 Group 1 operations allow a new point P to be placed at known x, y, r, and q positions relative to a global coordinate frame. Group 2 operations allow P to be placed at known x, y, r, and q positions relative to a coordinate frame determined by two points, A and B, already in the scene. The operations in Groups 1 and 2 represent all of the relationships between points that we could squeeze out of the language of cartesian coordinates and polar coordinates (see figure 6). In particular, Group 1 includes four relationshipsthe x and y of cartesian coordinates and the r and q of polar coordinates (or distance and slope). Group 2 adds those relationships which take advantage of the fact that two points, A and B, can be used to define a new coordinate system. All four relationships of Group 1 are re-expressed in terms of this new coordinate system. The y coordinate (the direction perpendicular to AB) is now the distance from a point to a line (line AB). The x coordinate (parallel to AB) can be used to place points whose perpendicular projection onto AB is known. The r coordinate has the same function as in Group 1, adding nothing new. The q coordinate becomes an angle relative to line AB. The listed Group 3 operations are just Group 1 operations where the slope between two points or the distance between two points is used in place of a globally specified slope and distance respectively. Our taxonomy of relationships highlights the limitations of grid systems. A grid is the computer graphics equivalent of graph paper. When the grid is turned on, all points placed by the user will be forced to land on the intersection points of the rules of the graph paper (figure 7). This gives us only some of the Group 1 relationships. Furthermore, precise positioning is inherently quantized to the spacing of the grid, so only a subset of the possible positions, distances and angles defined in Group 1 are available to the user. The operations in Group 2, which are not inherently aligned with the grid axes, are nearly impossible to achieve. Figure 7 The grid in this example is shown as an array of tick marks. Constraint-based systems can potentially provide all of the relationships mentioned above and more. For instance, the Juno constraint-based illustrator [Nelson85] provides some Group 1 relationships (horizontal and vertical), and some Group 3 relationships (parallel and congruent). The user selects as many as four points at a time and then specifies the new relationship between them that the system should enforce. An example is shown in figure 8. Not only are a larger set of relationships possible than with the other two approaches, but many constraints can be solved simultaneously. Constraint-based illustrators are typically very powerful by our metric. Figure 8 A Juno user touches two points with a T-square shaped cursor to add a horizontal constraint. After the constraint solver is invoked, a new triangle is drawn. Intelligent dragging as implemented in Gargoyle provides exactly the relationships described in Groups 1 and 2. We felt this was an interesting point in the power scale when balanced with the ease of use issues. Providing more complex relationships would stretch the capabilities of intelligent dragging since the technique relies on being able to guess what relationships will be useful and there are simply too many groups of three (or more) points to make guessing possible. Intelligent dragging is, therefore, less powerful than constraints and more powerful than grids. Ease of use A system is predictable if the designer can confidently predict the results that each action will have on the state of his illustration. A system uses user input appropriately if a small change to the picture always requires a short period of designer time. A system is free from catastrophic failures if no sequence of actions are likely to require the user to redo significant parts of the design. In this section we focus on how the properties of geometric precision schemes affect these aspects of system design. Predictability and User Confidence A system that is easy to use will be predictable, require user input in proportion to the difficulty of the task, and be free from catastrophic failures which destroy hours of work. A predictable system will provide commands at the right semantic level to help the user concisely express his intent, and good feedback that the intent has been captured. Too low a level will require the user to perform tasks that take too many steps, which is tedious and unreliable. Superficially, grid systems are quite predictable. The grid itself is a visible reminder of the active constraints. The mechanism of a grid, however, provides no straightforward way to express relationships even as simple as a specific distance or angle. For example, a user trying to construct a 45 degree line has to translate his idea (45 degree line) into a more primitive one (move 5 points over and 5 points up). To be sure the angle is correct he may need to count grid points several times. So while a grid is easy to use, it may not inspire confidence that a particular relationship is satisfied because it provides control at too low a level. Constraint-based systems tend to be difficult to control. A set of simultaneous non-linear equations almost always has multiple solutions. Many points may be moved at once to arrive at a solution, drastically altering the scene. Presenting and controlling all the constraints and possible solutions is a formidable user interface problem. Some constraint-based systems do not attempt to describe the constraints graphically, relying on a textual description and letting the user correlate the text with the geometry. In either case, getting the constraints correct can be more like debugging code than graphical editing. With intelligent dragging, one line is moved at a time, and all constraints are represented as visible lines and circles so the constraints are simple and visible. We believe it presents commands at the correct semantic level, providing the same operations that a designer would use to describe the construction. Appropriate User Input The amount of work required to produce a design must be measured not only in terms of keystrokes but in the amount of effort it takes to make use of the design tools. Most systems do well at providing local optimization of keystrokes by taking advantage of coherence in the editing session, providing ways to free the user from repeatedly indicating that the same relationship and/or values are needed in a sequence of editing steps. However, in systems that are optimized for specific directions, such as horizontal and vertical, or that limit precise editing to discrete points, a significant amount of planning and extra construction may be needed so that precise editing can proceed at all stages of the design. Grid systems are both quantized and optimized for constructions that align with the axis. To maintain precise control throughout the editing session, the designer must plan ahead to make sure that all his vertices can be placed on grid points. For instance, if an arrowhead is to be attached to the middle of the edge of a rectangle, the rectangle must be an even number of grid units long. If this planning is not done, the designer will have to change the size of the rectangle which may, in turn, require other changes in the picture. Constraint-based systems often include direction specific constraints such as horizontal and vertical. A shape defined using these constraints cannot be rotated without either changing the constraints, or violating the constraints. Editing the constraints to make them consistent with the new rotation requires the user to change the constraint network everywhere the horizontal and vertical constraints are used, which can be time consuming. It is possible to design a shape with only a single mention of absolute orientation so that we can rotate the object by altering just that one constraint. However, designing the shape may be more complicated and the designer needs to plan in advance which shapes may be rotated. The most important feature of an alignment paradigm based on points and geometric constructions is that it is isotropic, or independent of orientation. It is just as easy in a system like Gargoyle to align the base of the triangle in figure 2 with a 30 degree line as it would be to make the base horizontal. We believe that this feature of intelligent dragging is the most significant advantage it has over grids and constraints in reducing the work needed to make an illustration. Preventing Catastrophic Failures Catastrophic failure occurs when a short sequence of actions can destroy large amounts of work. This includes accidental deletions, transformations or solutions to constraint systems that collapse several lines or points together as well as system crashes and other facts of computer life. We also consider it a catastrophic failure when late in the design process a problem is uncovered that requires significant rework of pieces of the design. Such problems include shapes moved prematurely off a grid, designs that are incorrectly quantized, subsections of a design which don't fit together, constraints that can't be rotated and other failures of planning. We feel intelligent dragging is a good methodology for preventing both types of catastrophic failures. Most of the first kind of problems can be prevented by good feedback and by the ability to undo an action. Intelligent dragging provides visible feedback for transformations as they occur. Each operation is incremental and leaves the objects in the scene in a well defined state, making it easier to implement both undo and incremental backup systems. The second type of problems can never be completely eliminated but a tool that is isotropic is clearly more adaptable than one that provides its full power only in specific directions. Errors can be corrected in place, independent of orientation. Designs can be combined and adjusted independent of the original orientation or quantization. Similarly, any system that allows arbitrary points to be selected for alignment eliminates the problems caused by failing to place or keep alignment points on a grid. Overall, we feel that intelligent dragging offers a significantly better compromise between power and ease of use than grids or constraints. 4. Intelligent Dragging Details In this section we will provide more detail about three important aspects of intelligent dragging: How we select and position alignment objects, how a set of lines of known slope and circles of known radius can be used to provide all of the constraints mentioned in Section 3 and how we get intelligent dragging to work in real time. 4.1 Choosing Alignment Objects The utility of intelligent dragging depends on good strategies for presenting the user with only the alignment objects of interest. We base our heuristics on typical editing behavior. The key observations are: Observation 1: The new point A is often placed relative to an existing point B so that one of these constraints is satisfied: the distance from A to B or the slope of segment AB, or some combination of these is known. Observation 2: The new point A is often placed relative to an existing segment BC so that one of these constraints is satisfied: the distance from A to BC is known, or the angle ABC is known, or the ratio BA/AC is known, or some combination of these. Observation 3: The same distance, slope, or angle is often used over and over. These observations suggest that we should construct alignment lines and circles based on the points and curves in the scene, once the user has specified some distances, slopes, angles, and ratios of interest. By providing appropriate gravity functions, the user will be able to easily point precisely to any of the alignment lines, circles, and intersection points. If our heuristics are correct, the next point to be placed will typically be a member of this set. Our strategies take advantage of additional information about what the user is trying to do. We know what type of operation the user is trying to perform, such as placing the first point of a polygon, adding a point to a polygon, reshaping a polygon or transforming a polygon, as soon as the user initiates that command. Furthermore, we often know some of the objects that are involved. We can use both types of information to guess a small number of vertices and segments that the user is most likely to try to align with the changing shape. We call these vertices and segments triggers because we will use them to trigger the construction of alignment lines and circles. We define a heuristic: Heuristic 1: When the user moves one point of a polygon, he will often want to align it with other parts of that same polygon. For all operations that modify a polygon, we use as triggers the set of vertices and segments of that polygon. Additional vertices and segments are used as triggers only if the user asks for them explicitly. We allow the user to specify that certain objects are "hot" (they should be used as triggers at all times) or "cold" (they should be used as triggers only if Heuristic 1 recommends it). When polygons are being repositioned rather than modified we cannot use Heuristic 1. Instead, we have decided that all stationary objects in the scene will be gravity active but will not trigger any alignment lines. This approach relies on a second heuristic: Heuristic 2: When a polygon is translated, rotated, or scaled in entirety, the resulting operation is often performed to make that polygon touch an existing polygon. Hence, we make all of them objects in the scene gravity active except for the polygon or polygons being moved. If the user wants some of the stationary objects to trigger alignment objects, he must explicitly make the appropriate vertices hot. Figure 9 Flow chart showing how the set of alignment objects is computed. Figure 9 shows how the final set of alignment objects is computed. The operation determines which triggers to guess. These triggers are combined with those made hot by the user to make up the set of active triggers. Next the menus are consulted to see which slopes, distances, and angles are currently of interest. This information alone is used to determine which lines and circles to construct around the triggering vertices and segments. In addition to being triggers, the vertices and line segments in the scene can themselves be gravity active (as used above to implement Heuristic 2). We have found it helpful to treat this as a special case (the lower pathway in figure 9), since we often want to choose which scene objects are to be gravity active independent of which alignment objects are to appear. 4.2 Measuring It is clear how to use our alignment objects to construct line segments of known slope or known length. However, it is less clear how to perform operations involving relative values such as making line B parallel to line A, where the slope of line A is unknown. One technique that is easy for the programmer to implement and easy for the user to understand, is to allow the user to measure scene quantities. To make two segments parallel, for example, it suffices to measure the slope of one segment and then adjust the other segment to have the same slope. It is interesting that solving the problem in this way takes about the same number of keystrokes as it would take to set up and solve the constraint in a constraint-based system where the user would point at both segments, choose the parallel constraint, and invoke the constraint solver. Figure 10 shows the use of measuring to make one segment parallel to another. Figure 10 (a) Measure the slope of line A, which is 53.1 degrees and add it to the menu. Activate alignment lines of this slope. Figure 10 (b) Snap one end of segment B onto the new 53.1 degree alignment line to make B parallel to A. In Gargoyle, the distance between a pair of points, and the slope between a pair of points and the angle made by three points can be measured and added to the appropriate menu by pointing with the mouse. 4.3 Performance Intelligent dragging requires significant rendering and computing resources. Each time the user begins a new operation all alignment objects must be displayed in less than a second. During transformations, affected objects must move smoothly as they are dragged into position. An additional realtime computational burden is the calculation of points of intersection among all alignment objects whenever the set of alignment objects changes. How can these computations be performed in a reasonable amount of time? The set of triggers depends on the operation being performed so we don't know until the last minute which triggers will be active. However, we do know in advance what the slope of the lines will be and what the radius of the circles will be. These lines and circles can be scan-converted in advance and then sent to the screen as a block of pixels when they are needed. This is already a practical solution for bi-level displays and will become so for color displays. The problem of smooth motion during dragging is addressed in many commercial systems. Common solutions include reducing detail during dragging (show only a bounding box), or rendering the moving objects into a bitmap which is repeatedly repositioned. These same tricks can be used for intelligent dragging. Calculating points of intersection of the alignment lines and circles is not particularly time consuming. However, finding the intersections of alignment objects with scene objects can be. This cost can be reduced by using spatial sorting techniques (bounding boxes or grids) and by computing only on demand; the intersection calculation is performed only when both the scene object and the alignment line are within the gravity field of the caret. This same trick can be used to compute the intersections of scene objects with themselves. 5. Conclusion There are three construction techniques used in computer illustration systems. Grid systems have been commercial successes because they are easy to learn and implement. Constraint-based systems are constantly discussed in the literature because of their great power. We have shown that ruler and compass type construction systems are a viable compromise. Most of the advantages that we claim for intelligent dragging are advantages of the ruler and compass approach. In particular, it handles a wide range of alignment types, works at any rotation, and provides constraints which are easy to add, delete, and modify. For example, Qubix Graphics Systems has begun to demonstrate a technical illustration workstation which employs the ruler, compass and protractor paradigm. The obvious drawback of a construction approach is that setting up the construction may take quite a bit of time. Intelligent dragging tries to reduce construction time by taking advantage of the repetition which is present in many constructions; often the same slope or distance is needed repeatedly; often a polygon's vertex is aligned with other vertices of that same polygon. We believe the result is almost as easy to learn to use as grids, while providing most of the power of constraint systems. While ruler and compass construction is not inherently computationally expensive, intelligent dragging is; many alignment objects must be drawn and many intersection points must be computed. However, the computational requirements are bounded, because the user will turn off alignment objects when the screen becomes too cluttered. Improvements in graphics hardware will make the technique feasible in low-cost workstations in the near future. Future work Work is in progress to extend intelligent dragging to the editing of free-form curves and to three dimensional objects. We can introduce curves in a straightforward manner if the curves are controlled by points. In addition, we would like to extend our system to make alignments based on the local tangent to a curve to provide a simple way to position objects on curves. One of the motivations for this work is to develop better ways to edit objects quickly in three dimensions. In three dimensions, the grid approach is impractical because drawing a full three dimensional grid puts so many lines on the screen that the user has trouble identifying the proper grid point, and notifying the system of the point chosen. Constraint-based approaches are also difficult to use. Some progress has been made by Lin et al. towards using constraints in three dimensions to alter dimensions in mechanical assemblies [Lin81]. It is more difficult to use constraints to provide a quick-sketch capability because, in three dimensions, there is an explosion of degrees of freedom which need to be constrained requiring the production of a large number of constraints. A modified version of intelligent dragging might be successful in providing a precise three dimensional quick-sketch capability. References [Borning79] Alan Borning. Thinglab -- A Constraint-Oriented Simulation Laboratory. Revised PhD thesis, Report SSL-79-3, Xerox PARC, Palo Alto, CA 94304, July 1979. Also available as Stanford CS Dept. Report STAN-CS-79-746. [Pier83] Kenneth A. Pier. A retrospective on the Dorado, a high-performance personal computer. Proceedings of the 10th Symposium on Computer Architecture, SigArch/IEEE, Stockholm, pages 252-269, June 1983. [Lin81] V. C. Lin, D. C. Gossard, and R. A. Light. Variational geometry in computer-aided design. Computer Graphics 15(3):171-177, August 1981. SIGGRAPH '81 Proceedings. [Lipkie82] Daniel E. Lipkie, Steven R. Evans, John K. Newlin, Robert L. Weissman. StarGraphics: an object-oriented implementation. Computer Graphics 16(3):115-124, July 1982. SIGGRAPH '82 Proceedings. [MacDraw84] MacDraw Manual. Apple Computer, Inc. 20525 Mariani Ave. Cupertino, CA 95014. 1984. [Nelson85] Greg Nelson. Juno, a constraint-based graphics system. Computer Graphics 19(3):235-243, July 1985. SIGGRAPH '85 Proceedings. [Newman79] William M. Newman and Robert F. Sproull. Principles of Interactive Computer Graphics, chapter 12. McGraw Hill, second edition 1979. [Opperman84] A Gremlin Tutorial for the SUN Workstation. Internal document, EECS Department, UC Berkeley, Berkeley CA 94720. [Pavlidis85] Theo Pavlidis and Christopher J. VanWyk, An automatic beautifier for drawings and illustrations. Computer Graphics 19(3):225-234. SIGGRAPH '85 Proceedings. [Swinehart80] Daniel C. Swinehart, Polle T. Zellweger, and Robert B. Hagmann. The structure of Cedar, SIGPLAN Notices 20(7):230-244, July 1985. Proceedings of the ACM SIGPLAN 85 Symposium on Language Issues in Programming Environments held in June 1985. [Stone80] Maureen Stone, How to use Griffin, Internal Memo, Xerox PARC, 3333 Coyote Hill Rd, Palo Alto CA 94304. 1980. [Sutherland84] Ivan E. Sutherland. Sketchpad, a man-machine graphical communication system. In Herbert Freeman, editor, Tutorial and Selected Readings in Interactive Computer Graphics, pages 2-19, IEEE Computer Society, Silver Spring, MD, 1984. Reprinted from AFIPS 1963.  [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool] [Artwork node; type 'ArtworkInterpress on' to command tool]  "cedar" style61.0 in leftMargin 1.0 in rightMargin 7.0 in lineLengthItitleIauthors<transformations. In Gargoyle, a special point called the the Xerox PressFontsTimesRoman-mir#Pcaret can be placed with precision ;P}Pq/using gravity. The caret is distinct from the cursor1 in that the cursor always moves with the mouse, ;PI $)dwhile the caret can stray from the cursor if a gravity-active object attracts it. In construction ;P:bdoperations the new point is always placed at the position of the caret. Positioning operations use ;P3Zethe position of the caret as a parameter. When adding or moving a point to an object, affected line ;Py![Wsegments are adjusted in realtime using the technique called rubber-banding [Newman]. ;PC ]Transformed objects are smoothly dragged into position. The user specifies via a menu or by ;PAIbtyping any special points of interest and what kinds of precision are currently of interest. How ;PQ& Ymany lines and circles to generate and where to place them is determined automatically. ;Pw ReAlignment objects are visible only when the user is in the process of moving a point or object. "P׊i,XFigure 1 shows how a user would adjust a point in an existing triangle to make the base ;PE horizontal.bz xjWBrjWB]A/'WBrjWBaOqlq}qcYq}+!}q}rjmKkrjN AkIlSN AhbmKrjIlSN AkrjhbmKkrjIlSN AkaOqlq}qcYq}+!}q}IlSN AhbmKhbmKIlSN ArjkkkkA Xerox PressFonts Laurel-mrr#P_Fig. 1 (a) The user has activated horizontal alignment lines, and picked up a vertex with the Ey"5caret.hz5YxjWBrjWBE WBrjWBrjmKkrjN AkIlSN AhbmKrjIlSN AkrjhbmKkrjIlSN AkIlSN AhbmKhbmKN AN AIlSN ArjN AkGkkkkkgArtwork InterpressBounds:0.0 mm xmin 0.0 mm ymin 68.79166 mm xmax 43.12708 mm ymax G45.94931 mm topLeading 45.94931 mm topIndent 1.411111 mm bottomLeading n==Icaptiong)Interpress/Xerox/3.0 fjkjWBXI%qWBrjWB;PXerox PressFontsTimesRoman-mrr#P%`d[Nelson85]. As in a grid system, the user snaps a cursor to gravity active objects provided by the ;PƊ dsystem. However, the set of gravity active objects is richer and varies with the current scene and ;P ^with the operation being performed. As in a constraint-based system, points can be placed to ;PPNwcsatisfy angle constraints, slope constraints, and distance constraints. However, with intelligent ;Pfdragging, constraints are solved two at a time, with the user explicitly controlling the placement of ;Prndeach point, and the constraints are forgotten as soon as they are used rather than becoming part of ;PMڊthe data structure."P2VIntelligent dragging is currently implemented as part of the Gargoyle two dimensional ;PP2!Willustrator, running in the Cedar programming environment [Cedar], on the Xerox Dorado ;P!dxbhigh-performance personal workstation [Lampson]. All the figures in this paper were created with ;P( Gargoyle."P~Z l_In Section 2 we will present intelligent dragging in more detail. Section 3 is an analysis of ;P!PG_design issues for geometric precision techniques, comparing grids, constraints and intelligent ;PTŊuddragging. Section 4 presents more detail on the implementation of intelligent dragging. Section 5 ;P 1summarizes our results.;PWXerox PressFontsTimesRoman-brr iȠ2. Intelligent Dragging"P=7XThis section describes how intelligent dragging is used to construct shapes and perform ;P @;>transformations. In Gargoyle, a special point called the the Xerox PressFontsTimesRoman-mir#Pcaret can be placed with precision ;P}Pq/using gravity. The caret is distinct from the cursor1 in that the cursor always moves with the mouse, ;PI $)dwhile the caret can stray from the cursor if a gravity-active object attracts it. In construction ;P:bdoperations the new point is always placed at the position of the caret. Positioning operations use ;P3Zethe position of the caret as a parameter. When adding or moving a point to an object, affected line ;Py![Wsegments are adjusted in realtime using the technique called rubber-banding [Newman]. ;PC ]Transformed objects are smoothly dragged into position. The user specifies via a menu or by ;PAIbtyping any special points of interest and what kinds of precision are currently of interest. How ;PQ& Ymany lines and circles to generate and where to place them is determined automatically. ;Pw ReAlignment objects are visible only when the user is in the process of moving a point or object. "P׊i,XFigure 1 shows how a user would adjust a point in an existing triangle to make the base ;PE horizontal.bz xjWBrjWB]A/'WBrjWBaOqlq}qcYq}+!}q}rjmKkrjN AkIlSN AhbmKrjIlSN AkrjhbmKkrjIlSN AkaOqlq}qcYq}+!}q}IlSN AhbmKhbmKIlSN ArjkkkkA Xerox PressFonts Laurel-mrr#P_Fig. 1 (a) The user has activated horizontal alignment lines, and picked up a vertex with the Ey"5caret.hz5YxjWBrjWBE WBrjWBrjmKkrjN AkIlSN AhbmKrjIlSN AkrjhbmKkrjIlSN AkIlSN AhbmKhbmKN AN AIlSN ArjN AkGkkkkkg Interpress:0.0 mm xmin 0.0 mm ymin 64.91112 mm xmax 36.33611 mm ymax G39.15833 mm topLeading 39.15833 mm topIndent 1.411111 mm bottomLeading ==QOIitem99R11RRRPPRInterpress/Xerox/3.0 fjkjWB`C WBrjWBXerox PressFonts Helvetica-mrrǷ0p؊30/0 945M;Ƿ60h}RQ90D 0Ƿ120J0p؊135Q0Ƿ150tNtXtXXXNNtNQSlopes:GP-Circles:(052inO#P-OtherQ/QXQXsXsXs/s/Q/W5.75inrj:;RkrjXQ䊠ktNtXtXXXNNtNQ/QXQXsXsXs/s/Q/rjGQiQGQ䡓krjXQrjkkkkg Interpress:0.0 mm xmin 0.0 mm ymin 131.9389 mm xmax 67.73333 mm ymax G70.55555 mm topLeading 70.55555 mm topIndent 1.411111 mm bottomLeading ==QQG54.68056 mm topLeading 54.68056 mm topIndent 1.411111 mm bottomLeading 80.0 mm xmin 0.0 mm ymin 73.025 mm xmax 51.85833 mm ymax  InterpressInterpress/Xerox/3.0 fjkjWBo3 WBrjWBrj/G;Rk[Qrjيkrj[Q􊠪krjJQlQJQkrj]ٙ]١krjrj(_*k[Q[Q(_*UM*kkkg==QhQG27.16389 mm topLeading 27.16389 mm topIndent 1.411111 mm bottomLeading :0.0 mm xmin 0.0 mm ymin 34.57222 mm xmax 24.34167 mm ymax  InterpressInterpress/Xerox/3.0 fjkjWB塣n WBrjWBٙ[Q(_*ٗ[Q[Q(_*(_*١kkg==QGOO MOInterpress/Xerox/3.0 fjkjWB" f ̠:WBrjrjWBXeroxResearch RGBLinearcCFkcCcCFFkFkFkcCkcCcCC%T@yT@yT@QkyT@Q-jXerox PressFonts Helvetica-mrrf4)AZ EŠBcCFkcCcCFFkFkFkcCkcCcCT@T@' T@T@T@*QT@L95hrjϡkcCFFkFkFkcCkcCcCC%T@yT@yT@QkyT@Q-jcCFFkFkFkcCkcCcCT@T@' T@T@T@*QT@L95hrjrj-񊠩k@kg@kHo@kHoHoHogg@kgrj@kgkrj@kHokrjHokrjgkrj@kgkkkrjWBXeroxResearch RGBLinearnCC)̎nCnCC)nCC)nCC)C)Xerox PressFonts Helvetica-mrrq;BnCC)̎nCnCC)nCC)nCC)C)  ˡu  ˡ u ˡk$rjϡknCnCC)nCC)nCC)C)nCnCC)nCC)nCC)C)  ˡu  ˡ u ˡk$rjrj ˊk k#Kk#K>G*k#K>G*k#K>G* ˡ>G*  ˡrj ˊkrjk#Kkrj>G*k#Kkrj>G* ˊkrj ˊkkkkkg Interpress:0.0 mm xmin 0.0 mm ymin 136.1722 mm xmax 45.15556 mm ymax G47.97778 mm topLeading 47.97778 mm topIndent 1.411111 mm bottomLeading ==QQM O#1Interpress/Xerox/3.0 fjkjWB8WBrjWBA2Xerox PressFonts Laurel-mrr#PeFig. 5 The set of gravity active objects in Gargoyle is computed in two stages. First, the current E(1operation determines a set of vertex and segment Xerox PressFontsTimesRoman-mir#Ptriggers&. Second, the menus are consulted to Ed_see what alignment objects to draw at each trigger. Which scene objects are gravity active is E!Ȋ/determined by the operation alone (lower path).;P'=IxjWBrjWBJ#^۠WBrjWBXeroxResearch RGBLinearV A VV VAVAAA  V eԡeƙ]eƙ7]Xerox PressFonts Helvetica-mrrۊAڊBV A VV VAVAAA  V VVԡ3]JVԡV5JԡVZGJVWJ 4C0(a)rjVϡkV VAVAAA  V eԡeƙ]eƙ7]V VAVAAA  V VVԡ3]JVԡV5JԡVZGJVWJrjՊkӡӡrjӊkrjkrjkrjӊkrjӊkkkkAEQSzCxjWBrjWBC!vWBrjWBXeroxResearch RGBLinearV A VV VAVAAA  V Xerox PressFonts Helvetica-mrrڊBV A VV VAVAAA  V ,(b)rjVϡkV VAVAAA  V V VAVAAA  V rjV׊kR   ԡ ԡrjԊkrjkrj krj ԊkrjԊkkkkAʬ\Fig. 6 An example of translation parameterized by two points (A and B). (a) Point A on the E64k_object snaps onto the caret which (b) the user snaps onto a vertical alignment line at point B.L7;MxjWBrjWBPF0WBrjWB[M[[13 PZq13 a'塹13 a'13 gIpa'qa'塹Xerox PressFonts Helvetica-mrr.mrAnchor42rA'WBCaretF:+D?g3HH3g?¡[M[[13 PZq13 a'塹13 a'13 gIpa'qa'塹rjk ,' ᠢEn#YFYFNRݡNRB6CB;rB6CB;r0*70*7nmnmġj<z֡j<zEn#rjEn#krjYFkrjNR݊krjB6CB;rkrj0*7krjnmkrjĊkrjj<z֊krjEn#kkkkA~ ]Fig. 7 (a) Rotation is parameterized by 3 points (Anchor, A, and Caret). The anchor is the Eacenter of rotation. A is a point on the rotating object. The object is rotated to keep Anchor, E#A, and Caret collinear.=Y2xjWBrjWB+VWWBrjWB[M[[13 PZq13 M 13 M 13 gIpM qM Xerox PressFonts Helvetica-mrr.mE)Anchor92AA'WBF:+D?g3HH3g?¡[M[[13 PZq13 M 13 M 13 gIpM qM rj13 M kt%ϠEn#kk(L)(L)UUl'b l'b pyf-pyf-# %Hm# %HmLM|n]LM|n]En#rjEn#krjk򊠩krj(L)krjUkrjl'b krjpyf-krj# %HmkrjLM|n]krjEn#kkkkkkg Interpress:0.0 mm xmin 0.0 mm ymin 118.8861 mm xmax 53.62222 mm ymax G56.44445 mm topLeading 56.44445 mm topIndent 1.411111 mm bottomLeading ==Q Interpress/Xerox/3.0 fjkjWB+VWWBrjWB[M[[13 PZq13 M 13 M 13 gŧM qM Xerox PressFonts Helvetica-mrr.mE)Anchor92AA'WBF:+D?g3HH3g?¡[M[[13 PZq13 M 13 M 13 gŧM qM rj13 M kt%ϠEn#kk(L)(L)UUl'b l'b pyf-pyf-# %Hm# %HmLM|n]LM|n]En#rjEn#krjk򊠩krj(L)krjUkrjl'b krjpyf-krj# %HmkrjLM|n]krjEn#kkkg Interpress:0.0 mm xmin 0.0 mm ymin 131.2333 mm xmax 49.03611 mm ymax G51.85833 mm topLeading 51.85833 mm topIndent 1.411111 mm bottomLeading ==QM OInterpress/Xerox/3.0 fjkjWBEFWBrjrjWBXeroxResearch RGBLinear]}@V}`N4mSJ>]}@V}]}@V}``N4mN4mSJ>SJ>]}@V}rj]}@V}krj`krjN4mkrjSJ>k;<`]}@V}`َH?V};<;<`;<`;<]}@V}]}@V}``H?V}H?V};<rj`kFǠD?g3HH3g?¡]}@V}``N4mN4mSJ>SJ>]}@V}rj]}@V}krj`krjN4mkrjSJ>k;<`;<`;<]}@V}]}@V}``H?V}H?V};<rjGckkrjWBXeroxResearch RGBLinearO3;<VU_~V}9UzoO3QEV}O3;<O3;<VU;<VU;<_~V}_~V}9Uzo9UzoO3zoO3zoQEV}QEV}O3;<_~V}\TMΐBVh&!_~V}_~V}\TM\TMΐBΐBVh&!Vh&!_~V}rj_~V}krj\TMkrjΐBkrjVh&!krj\TMkFZǠD?g3HH3g?¡O3;<VU;<VU;<_~V}_~V}9Uzo9UzoO3zoO3zoQEV}QEV}O3;<_~V}\TM\TMΐBΐBVh&!Vh&!_~V}rj_~V}krj\TMkrjΐBkrjVh&!krjGckkkkg Interpress:0.0 mm xmin 0.0 mm ymin 115.3583 mm xmax 35.63055 mm ymax G38.45278 mm topLeading 38.45278 mm topIndent 1.411111 mm bottomLeading ==Q//OOOOOIindent OfS.|SSG52.21111 mm topLeading 52.21111 mm topIndent 1.411111 mm bottomLeading :0.0 mm xmin 0.0 mm ymin 125.2361 mm xmax 49.38889 mm ymax  Interpress Interpress/Xerox/3.0 fjkjWB,sKWBrjWB[qH\q@]qq@q@]8sPI4[[g]Xerox PressFonts Helvetica-mrr%2xGa[yXeroxResearch RGBLinearD]v>R*G>D]vD]v>D]vRD]vR*GR*GR*G>*G>D]v>b.]0reMP:2AA+ BQ5rITO85Q5rIQ5rIuM]=M2xy;V_k7V;Vَ;V__k7V_k7V_k7V;Vk7V;V;VlP_8rOga)em\,O#JO#J&$E-Xerox PressFonts Hippo-mrrqqkkg==QTgqbOOInterpress/Xerox/3.0 fjkjWBm&W`F                                                                                                             `kg Interpress:0.0 mm xmin 0.0 mm ymin 72.31944 mm xmax 47.27222 mm ymax G50.09444 mm topLeading 50.09444 mm topIndent 1.411111 mm bottomLeading ==QFOG59.61944 mm topLeading 59.61944 mm topIndent 1.411111 mm bottomLeading :0.0 mm xmin 0.0 mm ymin 123.4722 mm xmax 56.79722 mm ymax  Interpress9Interpress/Xerox/3.0 fjkjWBA%iWBrjWBA2Xerox PressFonts Laurel-mrr#PWFig. 5 An example of scaling. The original square (shaded gray) and the final square E((unshaded) are superimposed.;POȊXerox PressFontsTimesRoman-brr iȠ.3. Design Issues for Geometric Precision Tools"P}ȊXerox PressFontsTimesRoman-mrr#P`The ideal tool is powerful but easy to use. Good tool design, therefore, requires a compromise ;P2 [between functionality and complexity of user interface. We measure the functionality of a ;P#ageometric precision tool by examining which of a set of geometric relationships can be expressed ;P!d M[cdirectly. This set of relationships must be weighed against the total number of commands the user ;P(Smust learn and the time taken to specify all the arguments and invoke each command."P~ZQ\Ease of use involves more than reduction of commands and keystrokes. A system that is easy ;P!Pehto use will be predictable, require user input in proportion to the difficulty of the task, and be free ;PTŊ Z`from catastrophic failures which destroy hours of work. We will show that intelligent dragging ;P 1#makes it easy to reach these goals."P[ [In this section we will describe the sets of relationships we use to define the power of a ;P}d egeometric tool, and describe some important factors in making a system easy to use. In the process, ;P'Ȋ>we will compare intelligent dragging to grids and constraints.;PXerox PressFontsTimesRoman-brr#PGeometric Power"P]M}XOur approach to the problem of making precise line drawings has been to assume that the ;P!2 H3^designer will define shapes by carefully placing points rather than by sketching and aligning ;P;?dafterwords [Pavlidis]. This design philosophy focuses the design issues on methods for positioning ;Pgpoints, and especially on the issue of positioning a new point with respect to the other points in the ;PQ 2`scene. With intelligent dragging a point can be snapped to the alignment objects using gravity ;P\ b(figures 1 and 2). A grid is the computer graphics equivalent of graph paper. When the grid is ;Pc.e$hturned on, all points placed by the user will be forced to land on the intersection points of the rules ;P{9SPof the graph paper. A polygon drawn on such a grid is shown in figure grid. _%zxjWBrjWBm&W`F                                                                                                             `kkApADFig. 6 The grid in this example is shown as an array of tick marks."P (VIn the Juno constraint-based illustrator [Nelson], a shape is drawn freehand and then ;P2 #_constraints are added to it. The process of adding constraints involves selecting the type of ;P;pSdconstraint desired and pointing at the scene vertices which are to be constrained. This process is ;PTGshown in Fig. 7.6PxjWBrjWBInZ֠wWBrjWB}KX}}KXKXv4Bvv4B4BXerox PressFonts Helvetica-mrr=rY>SOLVE  `>7  `>%}}}};{KR{9;{9R{K qqG3?pmCursorkkkkkg==QO OM"OOOOMO OOOn M OO OOSSSOOOOmSOOSIblock3Interpress/Xerox/3.0 fjkjWBWBrjWBZYVxjWBrjWBD塣:]WBrjWBXeroxResearch RGBLinear9+H+99+9H9HHH++9+9HeH99H9e9eeeHH9H9ee99e99ee9eHePHHeePePePHPHH+HP++HHPHPHP+P++ePeePPPePeemmmqmmqm\+\,+,6-w,,+Kwšu5)\\c5)Xerox PressFonts Helvetica-mrr Drag1NRotate."Scale.?Slopes$K1N DistancesH2 Anglesvvv\\v\vvmm%vvvmmUmqmmmc"I80@T5@T5c"I6W%}jN+hMVN+hMV%svv6ӡ|w%%w3333UUUUmmmqmmqm333333UUUUUvvv݊ComputeDTriggers%Triggers62$GActive[? Computet}P AlignmenttPObjectscP80Objects]2m Alignment: 5N[Gravityo Sensitivekkk0 CXerox PressFonts Laurel-mrr#PHFig. 8 Flow chart showing how the set of alignment objects is computed.H%/Xerox PressFontsTimesRoman-mrr#P bFig. 8 shows how the final set of alignment objects is computed. The operation determines which ;dwULmtriggers to guess. These triggers are combined with those made hot by the user to make up the set of active ;d ) }otriggers. Next the menus are consulted to see which slopes, distances, and angles are currently of interest. ;dγ wgThis information alone is used to determine which lines and circles to construct around the triggering ;d bvertices and segments.H%jR eIn addition to being triggers, the vertices and line segments in the scene can themselves be gravity ;d{6G 4pactive (as used above to implement Heuristic 2). We have found it helpful to treat this as a special case (the ;d^Kelower pathway in Fig. 8), since we often want to choose which scene objects are to be gravity active ;d-!5independent of which alignment objects are to appear.;d! Xerox PressFontsTimesRoman-brr#P 4.2 MeasuringH%h 2iIt is clear how to use our alignment objects to construct line segments of known slope or known length. ;dVMNmHowever, it is less clear how to perform operations involving relative values such as making line B parallel ;dh/ Fcto line A, where the slope of line A is unknown. One technique that is easy for the programmer to ;d7baimplement and easy for the user to understand, is to allow the user to measure scene quantities. H%/X  @eTo make two segments parallel, for example, it suffices to measure the slope of one segment and then ;dj> F1ladjust the other segment to have the same slope. It is interesting that solving the constraint in this way ;d %ctakes about the same number of keystrokes as it would take to set up and solve the constraint in a ;d{65Wiconstraint-based system where the user would point at both segments, choose the parallel constraint, and ;d7"iinvoke the constraint solver. Fig. 9 shows the use of measuring to make one segment parallel to another.ZY_xjWBrjWBD+QdWBrjWBZ)rjZ񊠪krj)kXerox PressFonts Helvetica-mrrǷ0p؊30/0 945M;Ƿ60h}RQ90D 0Ƿ120J0p؊135Q0Ƿ150pNpXpXXXNNpNQSlopes:cp؊53.1SABZ)rjZ񊠪krj)kpNpXpXXXNNpNrjZ񊠪krj)krj)k mdZkkkkkg Interpress:0.0 mm xmin 0.0 mm ymin 111.8306 mm xmax 84.66667 mm ymax G87.48889 mm topLeading 87.48889 mm topIndent 1.411111 mm bottomLeading ==QJJOO OOInterpress/Xerox/3.0 fjkjWBD+QdWBrjWBZ)rjZ񊠪krj)kXerox PressFonts Helvetica-mrrǷ0p؊30/0 945M;Ƿ60h}RQ90D 0Ƿ120J0p؊135Q0Ƿ150pNpXpXXXNNpNQSlopes:cp؊53.1SABZ)rjZ񊠪krj)kpNpXpXXXNNpNrjZ񊠪krj)krj)k mdZkkg Interpress:0.0 mm xmin 0.0 mm ymin 148.1667 mm xmax 49.03611 mm ymax G51.85833 mm topLeading 51.85833 mm topIndent 1.411111 mm bottomLeading ==QG50.09444 mm topLeading 50.09444 mm topIndent 1.411111 mm bottomLeading :0.0 mm xmin 0.0 mm ymin 80.43333 mm xmax 47.27222 mm ymax  InterpressInterpress/Xerox/3.0 fjkjWB&RWBrjWBZ)Xerox PressFonts Helvetica-mrrSABrjn3ϡkZ)K8rjK8k ikkg==QiOOOOOOOOM OwOO I reference7U_snUUUccUU5+0U}}UUUwwUz?YW