Search

The title of this three-volume set on graphics from Romania, ‘Graphics without Computers’, makes a strong statement. It attracts attention, but, in its ambiguity, is misleading for two reasons. Fir...

Graphics are additional elements of vehicle design where even their absence is also an important part of their design. This chapter deals with the arts, science, and mathematics of graphics and their impact on vehicle character.

This paper describes the implementation of high performance process simulator clusters based on modern graphical processing unit architectures. Graphics rendering is basically just an intensive session of complex mathematical calculations, reading and writing memory buffers and computing bitmap matrixes. This is extremely similar to what system simulation software actually does: some mathematics - less complex than the usual graphics rendering in a typical 3D game, updating some algorithm state variables held in memory, and computing an output for the system. The first part of this article will focus on comparing hardware architectures between the central processing unit and graphics processing unit, and the second part will focus on implementing a PID controller on both. A case study will be presented in the last part, presenting a highly efficient mobile application which will employ the on-board graphics processing unit to provide system simulations while also saving energy.

This document demonstrates an efficient stroke algorithm to be used for drawing maps. Map data is stored in vector graphics format and before the actual draw operation items are scaled, cap and joint types defined in map style are added. Proposed stroke algorithm is benchmarked against Anti-Grain Geometry graphics library using both basic vector shapes and real OpenStreet Map (OSM) map data. It is demonstrated that proposed stroke algorithm can create data, ready to be fed to modern graphic acceleration hardware faster without significant quality loss.

AMD's first Fusion Accelerated Processor Unit (APU) codenamed “Zacate” (Fig. 15.4.1) combines a pair of x86 CPUs cores codenamed “Bobcat”, 1MB L2 Cache, Client Northbridge (CNB), with a DirectX® 11 Radeon™ HD5000 graphics/multimedia controller on a single die. The CNB provides an interface to a single 64b DDR3 memory channel, which can operate at up to DDR3–1066. The Fusion architecture implements an efficient form of unified memory architecture (UMA) where a portion of system memory is reserved as graphics frame buffer memory. The graphics memory controller (GMC) arbitrates between graphics, video and display memory accesses and presents a well-ordered stream of system memory requests through the CNB over dedicated 256b wide read and write busses. These GMC requests bypass all of the CNB coherency mechanisms allowing for fast direct access to memory and exposing most of the available memory bandwidth (8.53GB/s). Compared to two chip solutions, use of the on-die integrated GPU significantly reduces memory latency, improves request ordering, and reduces power. The APU supports display formats including VGA, LVDS, Display Port, DVI or HDMI™. A ×4 Gen2 PCIe® Unified Media Interface (UMI) to an external Fusion Controller Hub (FCH) is supported for system I/O. An additional 4× PCIe Gen2 link supports I/O to external Discrete Graphics chip.

We present a new, unified approach to debugging graphics software. We propose a representation of all graphics state over the course of program execution as a relational database, and produce a query-based framework for extracting, manipulating, and visualizing data from all stages of the graphics pipeline. Using an SQL-based query language, the programmer can establish functional relationships among all the data, linking OpenGL state to primitives to vertices to fragments to pixels. Based on the Chromium library, our approach requires no modification to or recompilation of the program to be debugged, and forms a superset of many existing techniques for debugging graphics software.

The earliest Web browsers focussed on the display of textual information. When graphics were added, essentially only image graphics and image file formats were supported. For a significant range of applications, image graphics has severe limitations, for example in terms of file size, download time and inability to interact with and modify the graphics client-side. Vector graphics may be more appropriate in these cases, and this has become possible through the introduction of the WebCGM and Scalable Vector Graphics (SVG) formats, both of which are open standards, the former from ISO/IEC and W3C and the latter from W3C. This paper reviews the background to Web graphics, presents the WebCGM file format, and gives a more detailed exposition of the most recent format, SVG. The paper concludes with reflections on the current state of this area and future prospects.

Everybody has their own favorite bunch of programming tricks. A few years ago, I started the Graphics Gems series of books to bring together lots of these handy techniques. The Journal of Graphics Tools (http://www.acm.org/jgt) has continued that tradition. In this column, I thought I would describe some little tricks of mine that are too small even for JGT. Small can be beautiful. Most of these techniques are so useful that I have bundled them up into little libraries. They include: the amazing expando-square, blob functions and multipoint weighting.

PCs with substantial 3D graphics are arriving on desktops everywhere. It was only a few years ago that people sniggered at PC graphics and laughed out loud at the notion of PCs with robust and versatile operating systems. Now, however, PC operating systems-especially Windows NT-have software development, networking, multiprocessing, and other tools to rival Unix environments. A user or developer can add a 3D graphics accelerator offering pipelined rendering, full texture mapping, and a complete set of graphics tools with performance that competes with mid-range graphics workstations. And no one is going to beat the price point. On top of all this, it's clear that Intel and Microsoft take this market seriously.

On various consumer electronics devices including smart phones and table PC's, the 3D graphics architectures are rapidly changing from fixed function pipelines to programmable pipelines. To execute the traditional graphics applications on the modern programmable pipelines, shader programs are used for their emulations. In this paper, we present an efficient way of the most suitable shader program generation for the given configurations. Comparing to the previously used shader programs, our just-in-time approach shows remarkable speed-ups, to give much more convenience for their consumers.

• High performance, but power efficient, and very low power modes • AV in and out media hub • Specialized audio, graphics, and video processors offload CPU and graphics core • CPU, GPU, specialized processors, and 10 share memory via host-guest MMUs with synchronized page tables • High bandwidth CPU cache coherency • 200+ GB/second power efficient memory system balanced to CPU, GPU, specialized processors, and 10 requirements • DX11.1+ graphics core with custom graphics and compute command processors to offload CPU and improve GPGPU

This paper presents a tactile hard-copy system which help an "active tactile graphics" for the blind. Here the word "active" means that the blind can make graphics programs and deal with computer graphics by his own efforts. It translates the color graphics on the screen into an embossed dots image on paper. To get a precise embossed dots hard-copy close to the real graphics screen, we adopted a Braille printer plotter. The program stays resident in computer's memory, and a push of COPY key at any time starts to make an embossed hard-copy of the current graphic screen. By this system and computer language like C, the blind can try to make graphics programs and examine the colors and the graphic figures constructing the screen graphics. The system can extract several combinations of colors from the whole graphics selectively and make the hard-copys. This color selective hard-copys help the blind understand the whole graphics as a result, because each hard-copy reduces the complexity of the graphics and tends to be easier to examine by touch.

Increasingly, 3D graphics is becoming the rule rather than the exception in applications such as games, CAD/CAM, and video production. Some LSIs provide rendering capabilities, but require an additional CPU to perform essential geometry transformations. Fujitsu's chip set solves that problem using two processors to render 300,000 polygons per second (for flat-shaded triangles with texture)-performance comparable to that of advanced game machines.

The Siggraph/Eurographics Graphics Hardware 2003 workshop, held in San Diego, will likely be remembered as a turning point in modern computing. In one of those rare moments when a new paradigm visibly begins changing general-purpose computing's course, what has traditionally been a graphics-centric workshop shifted its attention to the nongraphics applications of the graphics processing unit. GPUs, made by Nvidia (www.nvidia.com) and ATI (www.ati.com), function as components in graphics subsystems that power everything from Microsoft's Xbox to high-end visualization systems from Hewlett-Packard and SGI. The GPUs act as coprocessors to CPUs such as Intel's Pentium, using a fast bus such as Intel's Advanced Graphics Port. AGP8x has a peak bandwidth of 2.1 gigabytes per second - speed it needs to avoid inflicting bus starvation on data-hungry GPU coprocessors.

To resolve the difficulty of reading and identifying the CAD graphics file about automatic distinguishing and judging of CAD graphics file, this paper propses a CAD graphics identification method based on the graphics primitive. In this method, the CAD graphics is exploded to graphics primitive and read the graphics attribute. According to the comparison results of the identified graphics and standard graphics, the graphics primitives are differentiated with their graphics attributs. The graphics identification is finished by reading different sorts of graphics primitives.

This paper attempts to introduce a model for three-dimensional computer graphics in personal computers (PC). It introduces a design based on the Programmers Hierarchical Interactive Graphics System (PHIGS) and suggests some methods for achieving this design on PCs.

Recent applications of computer software to water resources and environmental master-planning studies include use of graphical displays in order to disseminate information. In this paper, a simple-to-use graphics display program is presented which enables a user to display graphical slides, stored on disk, to the CRT. Such a program enables a user to link graphics slides to next data by use of a read-only text display routine. Application of the provided program in a Graphics Data Base Management System is considered as a case study. Computer code is provided for the graphics slide display.

As we discussed in Chap. 14, “Graphics Overview,” the ggplot2 package is an implementation of Wilkinson’s grammar of graphics (hence the “gg” in its name). The last chapter focused on R’s traditional graphics functions. Many plots were easy, but other plots were a lot of work compared to SAS or SPSS. In particular, adding things like legends and confidence intervals was complicated.

International audience; In this paper we present an implementation of a 3D graphics player showing for a first time worldwide a successful integration between COLLADA, a standard for representing 3D graphics assets, and MPEG-4, a standard for compression and delivery of the assets

HAGI is an object-oriented graphics system developed on top of the X window system. In addition to providing facilities that structured graphics systems such as GKS usually have, HAGI supports a high- level graphics paradigm with the following features: + In addition to graphical objects, the system provides a class of application objects with a higher level of abstraction than graphical objects. + Graphics manipulation operations can be issued simplyfrom application objects without explicitly referring to specific graphical objects. Thus graphics manipulation appears to be transparent to application programmers. + Graphical objects are designed to encompass more semantics, thus are at a level close to the application. For example, they useflexible visual objects to determine their visual appearance. HAGI provides such a high-level application/graphics interface by maintaining a dependency relationship between graphical objects and application objects.

The author describes how he extracted the desirable aspects of window-to-viewpoint transformation while discarding the disquieting ones. He examines the classic window-to-viewport transform, and discusses how it relates to the graphics pipeline he has discussed in the past. He then considers clipping and off-screen viewports. >

This paper first presents how the 2-Dimension (2-D) Scalable Vector Graphics (SVG) based display format can be enhanced to display 2-D scene in 3-Dimension (3-D) perspective view while utilizing the standard 2-D SVG graphics library. This is then further extended to include 3-D objects that, when added on top of the 2-D scene, enable a full 3-D projection of the scene. The 3-D objects are encoded based on SVG derived syntax in order to maintain compatibility with the 2-D SVG graphics library for the final perspective display on 2-D screen. With the compact vector format used in SVG, this approach enables high quality dynamic 3-D graphics display for applications like digital map to be generated on embedded platforms where memory resources is of severe constraint.

This paper describes the global architecture and behavior of an ESSL compiler, based on the ES Shading Language for OpenGL ES 2.0 defined by the Khronos specification. This compiler is running at driver level, and processes shader code destined to run over a proprietary programmable 3D graphics pipeline functional model.

Graphics and vision are approximate inverses of each other: ordinarily graphics processing units (GPUs) are used to convert ldquonumbers into picturesrdquo (i.e. computer graphics). In this paper, we discuss the use of GPUs in approximately the reverse way: to assist in ldquoconverting pictures into numbersrdquo (i.e. computer vision). For graphical operations, GPUs currently provide many hundreds of gigaflops of processing power. This paper discusses how this processing power is being harnessed for image processing and computer vision, thereby providing dramatic speedups on commodity, readily available graphics hardware. A brief review of algorithms mapped to the GPU by using the graphics API for vision is presented. The NVIDIA CUDA programming model is then introduced as a way of expressing program parallelism without the need for graphics expertise.

In this paper, we introduce a graphics to Scalable Vector Graphics (SVG) adaptation framework with a mechanism of vector graphics transmission to overcome the shortcoming of real-time representation and interaction experiences of 3D graphics application running on mobile devices. We therefore develop an interactive 3D visualization system based on the proposed framework for rapidly representing a 3D scene on mobile devices without having to download it from the server. Our system scenario is composed of a client viewer and a graphic to SVG adaptation server. The client viewer offers the user to access to the same 3D contents with different devices according to consumer interactions.© (2007) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.

With the emergence of 3D graphics/arts assets commerce on the Internet, to protect their intellectual property and to restrict their usage have become a new design challenge. This paper presents a novel protection model for commercial graphics data by integrating digital rights management into the graphics processing unit and creating a digital rights enabled graphics processing system to defend against piracy of entertainment software and copyrighted graphics arts. In accordance with the presented model, graphics content providers distribute encrypted 3D graphics data along with their certified licenses. During rendering, when encrypted graphics data, e.g. geometry or textures, are fetched by a digital rights enabled graphics processing system, it will be decrypted. The graphics processing system also ensures that graphics data such as geometry, textures or shaders are bound only in accordance with the binding constraints designated in the licenses. Special API extensions for media/software developers are also proposed to enable our protection model. We evaluated the proposed hardware system based on cycle-based GPU simulator with configuration in line with realistic implementation and open source video game Quake 3D.

Graphics and vision are approximate inverses of each other: ordinarily Graphics Processing Units (GPUs) are used to convert "numbers into pictures" (i.e. computer graphics). In this paper, we propose using GPUs in approximately the reverse way: to assist in "converting pictures into numbers" (i.e. computer vision). The OpenVIDIA project uses single or multiple graphics cards to accelerate image analysis and computer vision. It is a library and API aimed at providing a graphics hardware accelerated processing framework for image processing and computer vision. OpenVIDIA explores the creation of a parallel computer architecture consisting of multiple Graphics Processing Units (GPUs) built entirely from commodity hardware. OpenVIDIA uses multiple Graphic.Processing Units in parallel to operate as a general-purpose parallel computer architecture. It provides a simple API which implements some common computer vision algorithms. Many components can be used immediately and because the project is Open Source, the code is intended to serve as templates and examples for how similar algorithms are mapped onto graphics hardware. Implemented are image processing techniques (Canny edge detection, filtering), image feature handling (identifying and matching features) and image registration, to name a few.

The design principles that were applied in the design of the integer-RISC machine, are applied to the design of the Reduced Instruction Set Graphics Processor. The processor instruction is defined after critical evaluation of the common graphics operations. Single cycle operations (in a pure RISC style) are performed through instructions for primitive graphics as well as general purpose computations. This processor is envisioned to become the CPU of choice for the ergonomic applications that rely heavily on graphics capabilities for user interface bandwidth improvement. The motivation for integrating graphics with general-purpose computations sterns from the performance enhancement acheived due to increased integration levels, and the program portability offered by a single processor based systems.

Author(s): Kniss, Joe M.; Lefohn, Aaron; Strzodka, Robert; Sengupta, Shubhabrata; Owens, John D. | Abstract: We implement an interactive 3D painting application that stores paint in an octree-like GPU-based adaptive data structure. Interactive painting of complex or unparameterized surfaces is an important problem in the digital film community. Many models used in production environments are either difficult to parameterize or are unparameterized implicit surfaces. We address this problem with a system that allows interactive 3D painting of complex, unparameterized models. The included movie demonstrates interactive painting of a 817k polygon model with effective paint resolutions varying between 64^3 to 2048^3. Our implementation differs from previous work in two important ways: first, it uses an adaptive data structure implemented entirely on the GPU, and second, it enables interactive performance with high quality by supporting quadlinear (mipmapped) filtering and fast, constant-time data accesses.

In comparison with the six chapters of the Programming volume [767] of the GuideBooks, this chapter is very long—almost one and a half times longer than the average chapter text, without the plots. The reason for this is threefold: The reader is now familiar with the structure of Mathematica expressions, and we can make full use of this knowledge to write larger programs. Often, one of the simplest ways to check whether a calculation produces the desired result is to look at it graphically for special values of parameters or/and limiting cases. Originally, it was not my intention to discuss a lot of graphical methods and examples. However, because of numerous requests by the students who listened to the original lectures that resulted in this book, I have now included, in my opinion, a sufficient amount of graphics. Apparently many students and colleagues wanted to use Mathematica not only for symbolic calculations, but also (sometimes, unfortunately, only) to produce plots of measured data or sets of data produced by other programs. Visualization of mathematical knowledge is very important for teaching and “understanding” mathematics [94], [835], [597], [228], [364], [438], [649], [361], [45], [446], [428], [269], [226].

In this chapter, we again discuss some of the commands presented in the last chapter on two-dimensional (2D) graphics. We do this for two reasons: first, it enables us to give a comprehensive and detailed treatment of three-dimensional (3D) graphics, and second, there are, in fact, several differences between the 2D and 3D graphics primitives, directives, and options.

Custom graphics processors or GPUs have been available for a few years now. Currently these graphics processors are slowing evolving to generalized stream processors. These custom vector processors [1] have special support for vector and matrix data types supported through "packed arrays". Recently, Microsoft and 3D Labs (Open GL ARB) have independently developed virtual execution environments to abstract these underlying graphics processors [2]. Additionally new languages including Cg [3], HLSL [4], and GLSlang [5] have been developed to target these graphics virtual machines. This paper explores the technical issues involved with building compilers that target DirectX 9.0 compatible programmable graphics processors.

With the innovation and integration of media objects in multimedia applications, the importance of architectural support for different types of media objects, e.g., image, video and graphics, in one platform has significantly increased. While several approaches based on vector or VLIW (very long instruction word) architectures, e.g., Vector-IRAM and Imagine, have been pursued, they are not as effective as dedicated graphics pipelines for high-performance 3D graphics. We have explored a new programmable computing architecture based on a 3D graphics pipeline, which utilizes dedicated hardware resources in the 3D graphics pipeline for other types of multimedia computing. Adding programmable flexibility to a graphics pipeline for texture mapping has proven to be effective, e.g., pixel shader. However, due to the diversity of imaging and video processing applications, there are several challenges associated with converting a fixed graphics pipeline to a flexible multimedia computing engine. In this paper, we identify the additional architectural requirements, introduce the proposed architecture with extension details, and present the results of the performance evaluation. With cycle-accurate simulation of several benchmark functions, we have verified that the proposed architecture outperforms a modem powerful media processor in imaging and video processing by a factor of 1.3 to 7.5. The 3D graphics performance would not change much because the additional pipeline stages for the extension result in longer pipeline latency but similar throughout.

Presents DGPSL (distributed graphics processing support library) which is one of major components of the authors' distributed graphics processing support environment. It is a facility for implementing graphics applications which require expensive computing power that is not available on single workstation. The paper describes in detail the techniques in designing and implementing DGPSL. >

This x86 compatible CPU with multimedia functionality includes DRAM controller, accelerated graphics controller, and PCI bus interface. The integer pipeline and L1 cache of the CPU are enhanced to accelerate graphics and multimedia applications, and take advantage of the on-chip peripherals. Modules integrated onto the die are chosen because they are high-value functions with compelling performance or reduced complexity when integrated with the CPU. Graphics and video functions benefit from a tight integration with the CPU since partitioning of functions between hardware and software can differ from a traditional architecture without hurting performance.

The geometry stage which performs the transformation and lighting operations of vertices, has become the critical part in the 3D graphics pipeline. We have designed the FGA (FLOVA Geometry Accelerator) that is the 3D geometry graphics system and it almost removes the time required for the process geometry stage. The 3D graphics library, FGA-GL, supports the FGA system. The deferred primitive rendering algorithm of FGA-GL enables the geometry processing of the primitive data to be done concurrently with the host job such as primitive data management or game AI. FGA improves the average performance of the 3D graphics system by 2.5-3.0 times.

In this paper a technique is presented that combines interactive hardware accelerated bump mapping with shift-variant anisotropic reflectance models. An evolutionary path is shown how some simpler reflectance models can be rendered at interactive rates on current low-end graphics hardware, and how features from future graphics hardware can be exploited for more complex models.We show how our method can be applied to some well known reflectance models, namely the Banks model, Ward's model, and an anisotropic version of the Blinn-Phong model, but it is not limited to these models.Furthermore, we take a close look at the necessary capabilities of the graphics hardware, identifiy problems with current hardware, and discuss possible enhancements.

The author predicts that computer graphics will move toward intellect support through better visualization tools based on a 30% per year improvement in hardware. He discusses graphics languages, visualization, processors, workstations, application-specific integrated circuits graphics (ASICs), memory and image files, and medical uses. >

The last chapter showed how the graphics facilities provided by Windows 98 can be applied to generate 2D bitmap graphics — this chapter continues the exploration of new graphical algorithms by creating wire-frame images of 3D objects. Indeed this is the first step in producing a graphical representation of an entire virtual world — the remaining chapters in the book continue to develop this idea. The key topics covered here include: polygon representation of 3D objects the OBJECT and POLYGON classes capturing a 3D image with a SCENE object line-drawing and line-clipping algorithms managing a virtual world with a WORLD object

It has become increasingly difficult to drive a modern highperformance graphics accelerator at full speed with a serial immediate-mode graphics interface. To resolve this problem, retainedmode constructs have been integrated into graphics interfaces. While retained-mode constructs provide a good solution in many cases, at times they provide an undesirable interface model for the application programmer, and in some cases they do not solve the performance problem. In order to resolve some of these cases, we present a parallel graphics interface that may be used in conjunction with the existing API as a new paradigm for highperformance graphics applications. The parallel API extends existing ideas found in OpenGL and X11 that allow multiple graphics contexts to simultaneously draw into the same image. Through the introduction of synchronization primitives, the parallel API allows parallel traversal of an explicitly ordered scene. We give code examples which demonstrate how the API can be used to expose parallelism while retaining many of the desirable features of serial immediate-mode programming. The viability of the API is demonstrated by the performance of our implementation which achieves scalable performance on a 24 processor system. CR