[Gzz-commits] manuscripts/AGPU fillets.txt irregu.txt

[Tuomas J. Lukka]

CVSROOT:        /cvsroot/gzz
Module name:    manuscripts
Changes by:     Tuomas J. Lukka <address@hidden>        03/04/08 03:52:42

Modified files:
        AGPU           : fillets.txt irregu.txt 

Log message:
        finishing

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/AGPU/fillets.txt.diff?tr1=1.3&tr2=1.4&r1=text&r2=text
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/AGPU/irregu.txt.diff?tr1=1.3&tr2=1.4&r1=text&r2=text

Patches:
Index: manuscripts/AGPU/fillets.txt
diff -u manuscripts/AGPU/fillets.txt:1.3 manuscripts/AGPU/fillets.txt:1.4
--- manuscripts/AGPU/fillets.txt:1.3    Mon Apr  7 09:11:12 2003
+++ manuscripts/AGPU/fillets.txt        Tue Apr  8 03:52:42 2003
@@ -1,15 +1,5 @@
-
-Z-buffer use in drawing 2 1/2 D non-photorealistic shapes.
-
-Line drawings drawn differently for algorithmic ease.
-
-Achieving a specific rendering goal efficiently, several different methods.
-
-All techniques pretty familiar, but the application is novel.
-
--------
-
 Rendering fillets
+=================
 
 Fillets (Lukka, Kujala and Niemelä, Information Visualization'02
 conference, reprint available on request) are graphical technique for
@@ -19,14 +9,17 @@
 "Introduction to Implicit Surfaces", Morgan Kaufmann 1997),
 mean the fillings used for sharp crevices to avoid breaking of the finished
 object at the sharp corners.  Our use of fillets here is analogical: 
-we use fillets to avoid the viewer's perception breaking the object and
+we use 2 1/2 D fillets to avoid the viewer's perception breaking the object and
 the line into separate pieces.
 
-Drawing fillets is difficult
-
-
-
-From the GPU perspective, the techniques presented
+We present two complementary approaches to rendering fillets:
+using pre-rendered textures for the shapes and minimizing the polygon
+use of the algorithm, and rendering the shape in full using polygons,
+giving maximum flexibility to the shapes.
+
+For the polygonized algorithm, we show how edges of constant thickness
+(even textured along the edge dimension) can be rendered for 
+2D shapes which are the union of simpler shapes using the Z-buffer.
 
 None of the techniques presented are particularly novel, but applying
 them to the novel problem (rendering fillets) allows a goal-oriented
@@ -35,4 +28,55 @@
 this proposal covers the area of 2 1/2 D rendering on the GPU fairly
 comprehensively; this proposal is more concerned on vertex processing
 and the other on fragment processing.
+
+If we get our NV3X cards in time, we may also be able to implement
+and demonstrate a filleting algorithm based on fragment programs,
+in somewhat the same way as the torn viewport algorithm.
+
+Our current implementations are OpenGL1.3 with NV extensions but we
+can easily rewrite them using Cg.
+
+--- Figures
+
+Fig.1. The basic premise of fillets in graph visualization.
+a) An inherently ambiguous diagram, which can mean
+either the structure in b) or c).
+In d), the two conditions are shown by the conventional drawing
+method of erasing the edge that goes behind something,
+and in e) fillets are used. Fillets display the structure clearly.
+[ boxline-ambiguity, ink-erase, edgeless ]
+
+Fig.2. The way alpha compositing can be used to render fillets
+from pre-drawn images with minimal polygon budgets.
+[ alphaimgs ]
+
+Fig.3. How vertex programs can be used to bend the connection
+so that it both leaves and enters nodes at a certain location.
+This is important for some of our user interfaces.
+[ screenshot from fillets demo showing both wireframe and normal ]
+
+Fig.4. A more flexible algorithm for creating filleted shapes. 
+This algorithm has to create the shape from polygons instead 
+of prerendered textures.
+
+Fig.5. How edges of constant thickness and even of textures can be drawn
+for the general polygonized shape using the Z buffer.
+In this way, fillets starting from a node can be allowed to overlap.
+This is an adaptation of the old Voronoi diagram hack for GPUs.
+Note that because of the flexibility of GPUs, the actual appearance
+of the polygons drawn need not depend at all on the Z coordinate.
+
+Fig.6. A random, badly laid out graph rendered using the polygonized
+algorithm. To demonstrate the edge-drawing system, we have used a 1D
+texture on the edge, creating two thin lines on the edges. The shapes
+are unbroken.
+
+Fig.7. Of course, since we're bevelling inside, we *can*, if we want to,
+also show the bevels using light. However, the angles of the bevels
+seen in the image need not correspond at all to the actual angles
+in the Z-buffer.
+
+
+
+
 
Index: manuscripts/AGPU/irregu.txt
diff -u manuscripts/AGPU/irregu.txt:1.3 manuscripts/AGPU/irregu.txt:1.4
--- manuscripts/AGPU/irregu.txt:1.3     Mon Apr  7 09:11:12 2003
+++ manuscripts/AGPU/irregu.txt Tue Apr  8 03:52:42 2003
@@ -1,7 +1,3 @@
-- 2 1/2 D !!!
-
-------
-
 Rendering and animating torn 2 1/2 D viewports efficiently
 ==================================================
 
@@ -59,15 +55,17 @@
 
 --- Figures
 
-Fig.1 shows break lines in their conventional context: break lines
+Fig.1. Break lines in their conventional context: break lines
 are the freehand lines implying that the object extends outside the
 depicted region.
 
-Fig.2 shows a screenshot from our BuoyOING user interface.
+Fig.2. A screenshot from our BuoyOING user interface, in which
+torn edges are used.
 
-Fig.3 shows how the shape of a torn frame changes when the frame moves
+Fig.3. How the shape of a torn frame changes when the frame moves
 (the canvas stays still in this figure). The shape of the edge is tied
 to its location, making the movement feel more like "a piece of paper
 that has magically been torn from a slightly different location from
 where it was a moment ago". Obtaining
 
+XXX how to explain the intricate edge-drawing algorithms here?