Distributed 3D rendering system in a multi-agent platform
David MouldProceedings of the Fourth Mexican International Conference on Computer Science, 2003. ENC 2003.
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
In this work, we propose a 3D rendering system that distributes rendering tasks across a multi-agent platform. The new approach is based on a multi-agent platform, where the goal is to create a virtual 3D environment. The main task is the rendering of individual objects. Each 3D object must be rendered in a remote unit; the resulting rendering is sent through the network to a 3D visualization process which generates the visualization of the whole 3D environment. The object movement and remote communication requirements have been implemented using a multi-agent system platform. The distributed system is implemented in Windows O.S., using DirectX graphical libraries and JAVA programming. The multi-agent platform used is JADE. The computer connection is a LAN at 100 MBS in a star topology.
Related papers
Distributed Rendering Engine
Lecture Notes in Computer Science, 2002
This paper present aspects of architecture of a cluster of workstations developed using ATM and FastEthernet technology and some of the basic principles of distributed memory programming, based on message-passing. The team used an application called Parallel POV-Ray rendering engine to show the viability of the "PoliCluster". This paper will describe the performance improvement that the Cluster architecture brought to this particular application. A significant role in choosing this particular application as an example was the natural parallelism of the rendering engine.
Distributed Information Processing and Rendering for 3D Simulation Applications
International Journal of Computer Theory and Engineering, 2014
The growing demand for 3D simulation techniques in various application domains leads to more and more specialized tools and complex frameworks. Between homogeneous or inhomogeneous clients, data has to be distributed and synchronized in centralized or decentralized setups. Hardware/Software-in-the-Loop and Co-Simulation are common tasks in virtual prototyping. Load balancing and parallelization is necessary for computationally intensive simulations. Spatially distributed developers and designers collaborate in networked virtual environments. All these different applications impose different requirements on the data distribution and synchronization mechanism. In this paper, we categorize distribution scenarios, their requirements and according synchronization techniques. Four different approaches with different key aspects are presented and compared by means of a reference implementation and several application examples. This overview shall enable the reader to choose the approach best suited for his particular distribution problem.
Distributed open inventor: A practical approach to distributed 3D graphics
1999
Distributed Open Inventor is an extension to the popular Open Inventor toolkit for interactive 3D graphics. The toolkit is extended with the concept of a distributed shared scene graph, similar to distributed shared memory. From the application programmer's perspective, multiple workstations share a common scene graph. The proposed system introduces a convenient mechanism for writing distributed graphical applications based on a popular tool in an almost transparent manner. Local variations in the scene graph allow for a wide range of possible applications, and local low latency interaction mechanisms called input streams enable high performance while saving the programmer from network peculiarities.
Creating distributed rendering applications
2017
This article discusses the aspect of visualization appliance by the usage of distributed computing systems. It describes possible practical scope for several visualization technologies on the basis of an example for the construction such an application exploiting modern technologies and ready-made solutions. An extra attention is paid to the selection of software packages and to the provisioning of a final result to the end user taking in mind the issue of unusual computer graphics output approaches. In the light of these questions this study is carrying out an analysis of implementation’s hardware and software features.
3D distributed rendering and optimization using free software
Resumen The media industry is demanding high fidelity images for their 3D synthesis projects. Rendering is the process by means of which a 2D image can be obtained from the abstract definition of a 3D scene. Despite the development of new techniques and algorithms, this process is computationally intensive and requires a lot of time to be done, specially when the source scene is complex or when photo-realistic images are required. This paper describes Yafrid (standing for Yeah! A Free Render grID) and MagArRO (Multi Agent AppRoach to Rendering Optimization) architectures developed in the University of Castilla-La Mancha for distributed rendering optimization.
A Multiagent Architecture for 3D Rendering Optimization
Applied Artificial Intelligence, 2010
Rendering is the process of generating a 2D image from the abstract description of a 3D scene. In spite of the development of new techniques and algorithms, the computational requirements of photorealistic rendering are huge so that it is not possible to render them in real time. In addition, the adequate configuration of rendering quality parameters is very difficult to be done by inexpert users, and they are usually set higher than in fact are needed. This article presents an architecture called MAgArRO to optimize the rendering process in a distributed, noncentralized way through a multiagent solution, by making use of expert knowledge or previous jobs to reduce the final rendering. Experimental results prove that this novel approach offers a promising research line to optimize the rendering of photorealistic images.
Distributed Rendering and Collaborative User Navigation- and Scene Manipulation
Abstract: The broad availability of large datasets for decision-making, as well as current technological trends in large-area projection systems and intelligent interaction devices pose new challenges for designing Virtual Environments (VEs) for decision-making processes. This paper addresses three main challenges for modern VEs in the context of decision-making: the render organisation for large-scale projection systems, the scene navigation by a group of concurrent users, and the in-place modification of rendered datasets by concurrent users. Distributed Rendering, Collaborative User Navigation and Collaborative Scene Manipulation are my proposed approaches for extending VEs to work in modern decision-making setups.
Communication Platform for Synchronous Collaborative Virtual Environment
This paper describes our communication platform over which a 3D CVE (Collaborative Virtual Environment) called SPIN-3D is built. With our 3D interface, a small group of people operates simultaneously on 3D objects described with the VRML format. Multi-user is supported through a VRML extension. We propose to share some data of the scene tree as well as an easy way to implement this solution: each shared data communicates with its remote copies through a multicast CORBA technology for discrete actions and through multicast real-time streams for animations.
Portable 3D Graphics in a Heterogeneous Distributed Environment
1991
Computer Aided Geometric Design is a young and rapidly growing field that deals with the construction and manipulation of geometric objects. By its very nature it relies heavily on high-perfonnance computer graphics. The SHASlRA environment aims to provide distributed, collaborative geometric design across a heterogeneous workstation environment. It was therefore necessary to achieve truly portable computer graphics without suffering the usual loss in perfonnance. The XS suite was designed and built as a solution to this problem, and is now used by all SHASlRA applications. We describe our experience with it.
Towards peer-assisted rendering in networked virtual environments
Proceedings of the 19th ACM international conference on Multimedia - MM '11, 2011
This paper introduces a new technique, called peer-assisted rendering, that aims to enable interactive navigation in a 3D networked virtual environment using a resource-constrained device, by speeding up the rendering. A resource-constrained client requests part of the rendered scenes from other peers with similar viewpoints within the virtual environment, and merges the rendered parts into its own view. This approach is more scalable than previous solutions based on server-based pre-rendering. The goal of this paper is to make a strong case for the feasibility of peer-assisted rendering through the following two messages. First, by analyzing a large number of user traces from a popular virtual world called Second Life, we show that there are surprisingly many users with similar viewpoints and encompass large number of common objects in their viewing areas, indicating that a client can potentially find multiple other peers that can assist in rendering. Second, by combining three different rendering methods, each contributing to rendering of different classes of objects in the scene, we show that it is possible for a client to render the scene efficiently with little visual artifacts.
Related papers
A Java-Based Multi-Participant 3D Graphics Application Interface Using JAVAGL1 and JAVANL2
This paper proposes a Java-based multi-participant 3D graphics application interface to provide 3D graphics and interactive capabilities over network. Two libraries support this interface, one is a 3D graphics library, called JavaGL, and the other is a network library, called JavaNL. The 3D graphics library is almost identical to OpenGL application interface but is written in Java to satisfy the 3D graphics requirement of the application model. The network library follows the concepts of Distributed Interactive Simulation (DIS), and is also written in Java. With these two libraries, we are able to provide an interactive application written in Java, gains the flexibility in cross-platform capability, while maintaining reasonable performance over Local Area Network (LAN).
A Java-Based Multi-Participant 3D Graphics Application Interface Using Javagl and Javanl 2
1998
This paper proposes a Java-based multi-participant 3D graphics application interface to provide 3D graphics and interactive capabilities over network. Two libraries support this interface, one is a 3D graphics library, called JavaGL, and the other is a network library, called JavaNL. The 3D graphics library is almost identical to OpenGL application interface but is written in Java to satisfy the 3D graphics requirement of the application model. The network library follows the concepts of Distributed Interactive Simulation (DIS), and is also written in Java. With these two libraries, we are able to provide an interactive application written in Java, gains the flexibility in cross-platform capability, while maintaining reasonable performance over Local Area Network (LAN).
URay: A Flexible Framework for Distributed Rendering and Display
2008
The available rendering performance increases constantly, primarily by new hardware in the form of faster GPUs. Additionally, we also see increasingly more powerful many-core processors that have enabled more flexible and continuously faster software-based graphics-such as real-time ray tracing. Despite this tremendous hardware progress in rendering power, there are and will always be applications that require distributed configurations for rendering and display. In this paper we present URay, consisting of an X3D-based scene graph system that supports different rendering modules (e.g., rasterization, and ray tracing) and combine it with NMM, a system for distributed multimedia processing and streaming. Together, URay supports all of the above scenarios. URay is highly modular and flexible, and can easily be reconfigured-even at runtime-to meet the changing demands of the application. Even better, we demonstrate that this great flexibility of URay even comes at a negligible cost over specialized and highly-optimized implementations. URay will be made available as Open Source.
DRONE: A Flexible Framework for Distributed Rendering and Display
Lecture Notes in Computer Science, 2009
The available rendering performance on current computers increases constantly, primarily by employing parallel algorithms using the newest many-core hardware, as for example multi-core CPUs or GPUs. This development enables faster rasterization, as well as conspicuously faster software-based real-time ray tracing. Despite the tremendous progress in rendering power, there are and always will be applications in classical computer graphics and Virtual Reality, which require distributed configurations employing multiple machines for both rendering and display. In this paper we address this problem and use NMM, a distributed multimedia middleware, to build a powerful and flexible rendering framework. Our framework is highly modular, and can be easily reconfigured-even at runtime-to meet the changing demands of applications built on top of it. We show that the flexibility of our approach comes at a negligible cost in comparison to a specialized and highly-optimized implementation of distributed rendering.
Distributed applications for collaborative three-dimensional workspaces
2003
This paper focuses on the distributed architecture of the collaborative three-dimensional user interface management system Studierstube. The system allows multiple users to experience a shared 3D workspace populated by multiple applications using see-through head mounted displays or other presentation media such as projection systems. The system design is based on a distributed shared scene graph that alleviates the application programmer from explicitly considering distribution, and avoids a separation of graphical and application data. The idea of unifying all system data in the scene graph is taken to its logical consequence by implementing application instances as nodes in the scene graph. Through the distributed shared scene graph mechanism, consistency of scene graph replicas and the contained application nodes is assured. Multi-user 3D widgets allow concurrent interaction with minimal coordination effort from the application. Special interest is paid to migration of application nodes from host to host allowing dynamic workgroup management, load balancing, ad-hoc collaboration, and ubiquitous computing.
An architecture for java-based real-time distributed visualization
IEEE Transactions on Visualization and Computer Graphics, 2003
In this paper, we present a Java-based software architecture for real-time visualization that utilizes a cluster of conventional PCs to generate high-quality interactive graphics. Normally, a large multiprocessor computer would be needed for interactive visualization tasks requiring more processing power than a single PC can provide. By using clusters of PCs, enormous cost savings can be realized, and proprietary "high-end" hardware is no longer necessary for these tasks. Our architecture minimizes the amount of synchronization needed between PCs, resulting in excellent scalability. It provides a modular framework that can accommodate a wide variety of rendering algorithms and data formats, provided that the rendering algorithms can generate pixels individually and the data is duplicated on each PC. Demonstration modules that implement ray tracing, fractal rendering, and volume rendering algorithms were developed to evaluate the architecture. Results are encouraging-using 15 PCs connected to a standard 100 Megabit/s Ethernet network, the system can interactively render simple to moderately complex data sets at modest resolution. Excellent scalability is achieved; however, our tests were limited to a cluster of 15 PCs. Results also demonstrate that Java is a viable platform for real-time distributed visualization.
Distributed Applications for Collaborative Three-Dimensional Workspaces"; Presence, 12 (2003), 1; S. 53-68
This paper focuses on the distributed architecture of the collaborative three-dimensional user interface management system Studierstube. The system allows multiple users to experience a shared 3D workspace populated by multiple applications using see-through head mounted displays or other presentation media such as projection systems. The system design is based on a distributed shared scene graph that alleviates the application programmer from explicitly considering distribution, and avoids a separation of graphical and application data. The idea of unifying all system data in the scene graph is taken to its logical consequence by implementing application instances as nodes in the scene graph. Through the distributed shared scene graph mechanism, consistency of scene graph replicas and the contained application nodes is assured. Multi-user 3D widgets allow concurrent interaction with minimal coordination effort from the application. Special interest is paid to migration of application nodes from host to host allowing dynamic workgroup management, load balancing, ad-hoc collaboration, and ubiquitous computing.
The JavaGL 3D Graphics Library & JavaNL Network Library
1997
This thesis presents a three dimensional (3D) graphics library, JavaGL, and a multiparticipant network library, JavaNL, both of them are written in pure Java programming language. Therefore people can use the applications developed with these two libraries on Internet through a Java enabled browser or on a Java enabled machine.
An open and scalable architecture for delivering 3D shared visualization services to heterogeneous devices
Concurrency and Computation: Practice and Experience, 2011
Shared visualization environments represent an effective means to enhance collaborative work in engineering and scientific design tasks. The availability of high-speed networks allows researchers to work together from geographically distributed locations, and mobile devices are able to carry out ubiquitous 3D visualization tasks through wireless network connections. This paper presents a scalable architecture for the delivery of shared 3D visualization services to heterogeneous terminals ranging from powerful workstations to mobile devices such as PDAs and smart-phones. The framework design allows both desktop and mobile clients to simultaneously visualize the same model by sharing a common view. Remote-rendering servers support effective visualization on thin clients, and a load balancing mechanism provides efficient resource usage.
Distributed Visualization with OpenGL Vizserver
2001
The increasing demand for distributed solutions in computing technology does not stop when it comes to visualization techniques. However, the capabilities of todays applications to perform remote rendering are limited by historical designs legacys. Especially the popular X11 protocol, that has been proven to be extremely flexible and useful for remote 2D graphics applications, collapses in case of remotely rendering complex 3D scenes. In this paper, we give a short overview of generic remote rendering technologies available today, and we compare their performances and usabilities to the recently released OpenGL Vizserver by Silicon Graphics, Inc. (SGI): a network extension to the SGI OpenGL rendering engines. In this report we limit ourselves to remote techniques compatible to the OpenGL standard.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.