53235783
Clothing manipulation
This paper presents interaction techniques (and the underlying implementations) for putting clothes on a 3D character and manipulating them. The user paints freeform marks on the clothes and corresponding marks on the 3D character; the system then puts the clothes around the body so that corresponding marks match. Internally, the system grows the clothes on the body surface around the marks while maintaining basic cloth constraints via simple relaxation steps. The entire computation takes a few seconds. After that, the user can adjust the placement of the clothes by an enhanced dragging operation. Unlike standard dragging where the user moves a set of vertices in a single direction in 3D space, our dragging operation moves the cloth along the body surface to make possible more flexible operations. The user can apply pushpins to fix certain cloth points during dragging. The techniques are ideal for specifying an initial cloth configuration before applying a more sophisticated cloth simulation.
795737
Navigating documents with the virtual scroll ring
We present a technique for scrolling through documents that is simple to implement and requires no special hardware. This is accomplished by simulating a hardware scroll ring--a device that maps circular finger motion into vertical scrolling. The technique performs at least as well as a mouse wheel for medium and long distances, and is preferred by users. It can be particularly useful in portable devices where screen-space and space for peripherals is at a premium.
2239491
Voice as sound: using non-verbal voice input for interactive control
We describe the use of non-verbal features in voice for direct control of interactive applications. Traditional speech recognition interfaces are based on an indirect, conversational model. First the user gives a direction and then the system performs certain operation. Our goal is to achieve more direct, immediate interaction like using a button or joystick by using lower-level features of voice such as pitch and volume. We are developing several prototype interaction techniques based on this idea, such as "control by continuous voice", "rate-based parameter control by pitch," and "discrete parameter control by tonguing." We have implemented several prototype systems, and they suggest that voice-as-sound techniques can enhance traditional voice recognition approach.
5447867
Clothing manipulation
This paper presents interaction techniques (and the underlying implementations) for putting clothes on a 3D character and manipulating them. The user paints freeform marks on the clothes and corresponding marks on the 3D character; the system then puts the clothes around the body so that corresponding marks match. Internally, the system grows the clothes on the body surface around the marks while maintaining basic cloth constraints via simple relaxation steps. The entire computation takes a few seconds. After that, the user can adjust the placement of the clothes by an enhanced dragging operation. Unlike standard dragging where the user moves a set of vertices in a single direction in 3D space, our dragging operation moves the cloth along the body surface to make possible more flexible operations. The user can apply pushpins to fix certain cloth points during dragging. The techniques are ideal for specifying an initial cloth configuration before applying a more sophisticated cloth simulation.
7967082
An annotation system for 3D fluid flow visualization
Annotation is a key activity of data analysis. However, current data analysis systems focus almost exclusively on visualization. We propose a system which integrates annotations into a visualization system. Annotations are embedded in 3D data space, using the Post-it metaphor. This embedding allows contextual-based information storage and retrieval, and facilitates information sharing in collaborative environments. We provide a traditional database filter and a Magic Lens filter to create specialized views of the data. The system is customized for fluid flow applications, with features which allow users to store parameters of visualization tools and sketch 3D volumes.<<ETX>>
14187938
Smooth meshes for sketch-based freeform modeling
This paper describes a framework for introducing visually smooth surfaces into sketch-based freeform modeling systems. An existing sketch-based freeform modeling system generates rough polygonal meshes with uneven triangulations after each operation. Our approach generates a dense, visually smooth polygonal mesh by beautifying and refining the original rough mesh. A beautification process generates near-equilateral triangles with a near-uniform distribution of vertices to mask the noise and bad sampling of the uneven mesh. The vertices are distributed on a smoothed surface that approximately interpolates the original mesh. Refinement generates a smooth, dense mesh by subdividing the beautified mesh and moving the vertices to the interpolative surface. The smooth interpolative surface is computed via implicit quadratic surfaces that best fit the mesh locally in a least-squares sense.
40264513
Avoiding Unnecessary Updates
Graph reduction underlies most implementations of lazy functional languages, allowing separate computations to share results when sub­ terms are evaluated. Once a term is evaluated, the node of the graph representing the computation is updated with the value of the term. How­ ever, in many cases, no other computation requires this value, so the up­ date is unnecessary. In this paper we take some steps towards an analysis for determining when these updates may be omitted.
45717332
Fast Abstract Interpretation Using Sequential Algorithms
interpretation in the framework introduced by Cousot and Cousot requires finding fixpoints of continuous functions between abstract lattices [CC77]. Very often these abstract functions are expressed as typed ,~-expressions, even when the language being analysed isn't functional--for example an abstract interpretation derived from a denotational semantics in the style of Nielson [Nie82] will naturally be in this form. So implementing an abstract interpreter often requires an evaluator for ,k-expressions over lattices. Of course, evaluation must always terminate--even when the result is the bottom element of the lattice concerned. In practice this evaluation is intractable. The problem is caused by function types: lattices of functions grow more than exponentially in the size of their type. A-expressions of quite simple types therefore denote functions that are too enormous to manipulate efficiently. Attempts to find clever representations of functions (as frontiers) have really failed to solve the problem [HH92], and in practice the intractability is avoided by avoiding functions--function types may be abstracted as the one point type, discarding all information about function values, or analyses may be constructed from a more intensional semantics in which 'function' values are closures (code-environment pairs), so that true functions do not appear. Such approaches are forced to make more or less ad hoc approximations, at a cost in accuracy, and moreover cannot yield faithful implementations of the many analyses in the literature in which functions are abstracted as functions. In this paper we describe an approach which we hope will make evaluation of )~-expressions over finite lattices tractable in practice. Our basic idea is to save time by computing only part of the value of each ,kexpression. For example, to compute the value of the application el e2 it's not necessary to compute the value of el precisely. We only need to know what value el returns when applied to e2 --one point in the graph of the function, rather than the whole graph. Moreover, if el is a constant function, we may not need to compute the value of e2 at all. Or if e2 is itself a function, el may only apply it to a couple of different arguments, and so we may only need to know its value at a few points rather than its entire graph. Our intention is to lazily compute only as much as is needed of each expression, in the hope that in normal cases this will be only a tiny proportion of the whole. This idea is also at the heart of Young's pending analysis [YH86] and Launchbury's use of minimal function graphs [Lau91] to represent just the part of the graph that is needed, but these approaches are really confined to first-order functions. Our contribution is to extend the same idea smoothly to the higher-order case.
8161135
Binding-Time Analysis for Polymorphic Types
Offline partial evaluators specialise programs with annotations which distinguish specialisation-time (or static) computations from run-time ones. These annotations are generated by a binding-time analyser, via type inference in a suitable type-system. Henglein and Mossin developed a type system which allows polymorphism in binding-times, so that the same code can be specialised with different computations being static at different uses. We extend their work to permit polymorphism in types as well. This is particularly important for separately compiled libraries.Following Henglein and Mossin, binding-times are passed as parameters during specialisation, but types are not. Instead, we pass coercion functions when necessary, which makes specialisation less "interpretive" than it would otherwise be. We keep track of the coercions needed by assigning qualified types to polymorphic functions.We also consider hand-annotations to provide limited user control over the binding-time analysis, which our prototype implementation showed to be necessary.
7653698
Reversing Abstract Interpretations
Program analyses are often presented as one of two brands: forwards or backwards. In this paper we explore the significance of the direction of analysis, and show how arbitrary abstract interpretations may be reversed.
29935552
Optimal design of checksum-based checkers for fault detection in linear analog circuits
Traditionally, built-in self-test (BIST) techniques have assumed access to only the input and output nodes of the circuit under test (CUT). It has been shown earlier, that checksum-based checkers can be designed to perform on-line fault detection in linear analog circuits using access to certain internal nodes of CUT. In this paper, we address the problem of optimizing the checker circuitry to maximize the detectability of faults in CUT. The above optimization problem is solved as a linear programming problem. The resulting checker can be used to perform both BIST of CUT and on-line error detection as well. Faults in the checker hardware are taken into account during the checker optimization process.