13883306
Implementing Projection-based Strictness Analysis
Projection-based backwards strictness analysis has been understood for some years. Surprisingly, even though the method is fairly simple and quite general, no reports of its implementation have appeared. This paper describes ideas underlying our prototype implementation of the analysis for a simple programming language. The implementation serves as a case study before applying the method in the Glasgow Haskell compiler.
28448708
The Design of a Pretty-printing Library
In this chapter we have considered the design of combinator libraries. We saw how studying the algebraic properties of the combinators desired can both help to suggest natural choices of representation, and guide the implementation of the operators. We saw several examples — lists, monads, and a pretty-printing library. For this kind of program development we need a language with higher-order functions and lazy evaluation, for which equational reasoning is valid; in other words, Haskell is ideally suited.
218895568
How to give a good research talk
Giving a good research talk is not easy. We try to identify some things which we have found helpful, in the hope that they may be useful to you.
14804186
Proving the correctness of reactive systems using sized types
We have designed and implemented a type-based analysis for proving some basic properties of reactive systems. The analysis manipulates rich type expressions that contain information about the sizes of recursively defined data structures. Sized types are useful for detecting deadlocks, nontermination, and other errors in embedded programs. To establish the soundness of the analysis we have developed an appropriate semantic model of sized types.
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.
27745403
Type Specialisation for the lambda-Calculus; or, A New Paradigm for Partial Evaluation Based on Type Inference
7238760
Analyzing bounding boxes for object intersection
Heuristics that exploit bouning boxes are common in algorithms for rendering, modeling, and animation. While experience has shown that bounding boxes improve the performance of these algorithms in practice, the previous theoretical analysis has concluded that bounding boxes perform poorly in the worst case. This paper reconciles this discrepancy by analyzing intersections among <italic>n</italic> geometric objects in terms of two parameters: α an upper bound on the <italic>aspect ratio</italic> or elongatedness of each object; and &sgr; an upper bound on the <italic>scale factor</italic> or size disparity between the largest and smallest  objects. Letting <italic>K<subscrpt>o</subscrpt></italic> and <italic>K<subscrpt>b</subscrpt></italic> be the number of intersecting object       pairs and bounding box pairs, respectively, we analyze a ratio measure of the   bounding boxes'  efficiency, <inline-equation> <f> <g>r</g>=K<inf>b</inf>/<fen lp="par">n+K<inf>o</inf><rp post="par"></fen> </f> </inline-equation>. The analysis proves that <inline-equation> <f> <g>r</g>=O<fen lp="par"><g>a</g><rad><rcd><g>s</g></rcd></rad> <lim align="r"><op><rf>log</rf></op><ul>2</ul></lim><g>s</g><rp post="par"></fen> </f> </inline-equation> and <inline-equation> <f> <g>r</g>=<g>W</g><fen lp="par"><g>a</g><rad><rcd><g>s</g></rcd></rad> <rp post="par"></fen></f> </inline-equation>.
 One important consequence is that if α and &sgr; are small constants (as is often the case in practice), then<italic>K<subscrpt>b</subscrpt></italic>= <italic>O</italic>(<italic>K<subscrpt>o</subscrpt></italic>)+<italic>O</italic>(<italic>n</italic>, so an algorithm that uses bounding boxes has time complexity proportional to the number of actual object intersections. This theoretical result validates the efficiency that bounding boxes have demonstrated in practice. Another consequence of our analysis is a proof of the output-sensitivity of an algorithm for reporting all intersecting pairs in a set of <italic>n</italic> convex polyhedra with constant α and &sgr;. The algorithm takes time <italic>O</italic>(<italic>n</italic>log<supscrpt><italic>d</italic>−1</supscrpt><italic>n</italic>+<italic>K<subscrpt>o</subscrpt></italic>log<supscrpt><italic>d</italic>−1</supscrpt><italic>n</italic>) for dimension <italic>d</italic> = 2, 3. This running time improves on the performance of previous algorithms, which make no assumptions about α and &sgr;.
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.
176582
Hardware-determined feature edges
Algorithms that detect silhouettes, creases, and other edge based features often perform per-edge and per-face mesh computations using global adjacency information. These are unsuitable for hardware-pipeline implementation, where programmability is at the vertex and pixel level and only local information is available. Card and Mitchell and Gooch have suggested that adjacency information could be packed into a vertex data structure; we describe the details of converting global/per-edge computations into local/per-vertex computations on a related 'edge mesh.' Using this trick, we describe a feature-edge detection algorithm that runs entirely in hardware, and show how to use it to create thick screen-space contours with end-caps that join adjacent thick line segments. The end-cap technique favors speed over quality and produces artifacts for some meshes.We present two parameterizations for mapping stroke textures onto these thick lines---a tessellation-independent screen space method that is better suited to still images, and an object space method better suited to animation. As additional applications, we show how to create fins for fur rendering and how to extrude contours in world-space to create the sides of a shadow volume directly on the GPU.The edge mesh is about nine times larger than the original mesh when stored at 16-bit precision and is constructed through a linear time pre-processing step. As long as topology remains fixed, the edge mesh can be animated as if it were a vertex mesh.
13514949
Programming Languages for Compressing Graphics
Images are programs. They are usually simple instructions to a very specialized interpreter that renders them on screen. Image formats therefore correspond to different programming languages, each with distinctive properties of program size and accuracy. Image-processing languages render large images from small pieces of code. We present Evolver, a language and toolkit that perform the reverse transformation.The toolkit accepts images in conventional graphics formats like JPEG and uses genetic algorithms to grow a program in the Evolver language that generates a similar image. Because the program it produces is often significantly smaller than the input image, Evolver can be used as a compression tool.The language balances the tradeoff between having many features, which improves compression, and fewer features, which improves searching. In addition, by being programmatic descriptions, the rendered images scale much better to multiple resolutions than fixed-size images. We have implemented this system and present examples of its use.
5091350
Orientable textures for image-based pen-and-ink illustration
We present an interactive system for creating pen-and-ink-style line drawings from greyscale images in which the strokes of the rendered illustration follow the features of the original image. The user, via new interaction techniques for editing a direction field, specifies an orientation for each region of the image; the computer draws oriented strokes, based on a user-specified set of example strokes, that achieve the same tone as the image via a new algorithm that compares an adaptively-blurred version of the current illustration to the target tone image. By aligning the direction field with surface orientations of the objects in the image, the user can create textures that appear attached to those objects instead of merely conveying their darkness. The result is a more compelling pen-and-ink illustration than was previously possible from 2D reference imagery. CR