Center for Computational Science and Advanced Distributed Simulation (C2SDS)
September 29, 2000 - January 15, 2002
September 29, 2000 - January 15, 2002
Several undergraduate students are involved in activities related to this research. All are working in the area of spoken language understanding. Their projects are designed to help them gain familiarity with the field of spoken language understanding and to give them experience in using the tools available for spoken language systems. The student projects are described below.
Taja Weatherspoon, Kevin Bartholomew
Project: User responses in a Spoken Dialogue System with Implicit confirmation.
Description: This work investigates how users correct a spoken language system that uses implicit confirmation. Implicit confirmation is used when a speech system verifies a user?s response by including the user?s response in a subsequent question.
Project: A Speech-based Appointment Scheduler with Variable Initiative Dialogue
Description: This project involves developing a speech-based calendar. With this system, the user adds appointments to the calendar by speaking. The system supports variable-initiative dialogue: the user or the system may direct the conversation
JSBB can be used to develop a multiple user speech application that requires synchronous interaction. This means multiple users interact with the speech application, but speak at different times. Our approach to multiple user speech applications views the application as an agent, and the developer specifies the behavior of the agent (by using a special dialogue state from the toolbar). The developer determines when and where the agent moves in the distributed computing environment and how it interacts with the users in that environment.
Compression of Large Datasets
D. Williams, H. Williams, and R. Johnson (student)
Research Objective and Significance:
An objective of this project is to research different compression algorithms. Enormous number of bits are used to represent data in various computer transactions. Managing these extremely large datasets pose problems in storage space and processing time requirements. Compression addresses the issues of manageability and storagability of large amounts of data. The primary focus of this past year has been the development of a compression testbed.
Large amounts of data have to be transmitted and/or stored in Distributed Interactive Simulation (DIS). A sizeable portion of this data is in some image format. Thus, many times the data can tolerate some ?lost? bits without losing its ?identity?. This tolerance lowers the data space and time requirements and thereby leading to better real-time simulations.
Initial research revealed the existence of several basic compression algorithms, such as Discrete Cosine Transform (DCT) and Lempel-Ziv-Welch (LZW), for images. It was also learned that there are several image formats and that these formats determine the algorithm(s) which may be utilized to compress the image. The LZW, which is used for Graphic Interchange Format (GIF) images, has been patented and is not available for analysis and testing. However, many compression routines have been developed that uses and/or extends the DCT, which is used for Joint Photographic Experts Group (JPEG) format. It was determined that a testbed of different algorithms for the image formats would provide an effective means to continue this research effort.
Source or executable code for several algorithms has been stored. Some of these algorithms have been used to compress tank, airplane, and human images at various ratios. Others are being debugged so that they may be executed. In the future, we plan to develop parameters to compare the effectiveness of the different algorithms and enhance/modify those that show promise for DIS.
Reference-Based Metamorphosis For Polyhedral Objects
R. Guha and P. Sompagdee(UCF)
Research Objectives and Significance:
Morphing techniques have long been used in the entertainment industry. However, the visualization of one thing changing into another can benefit other applications as well, for example, the study of the development of human beings. The objectives of this method are: (1) to find a general transformation function or method that is applicable to 3D polygonally-based representation of objects by solving three major problems of namely, morphing; control, correspondence and interpolation and (2) to propose the analysis methodologies to determine the behaviors of intermediate objects; distortion, surface self-intersection, fold-over problem.
This method is a general solution for the transformation of any 3D polygonally-based representation of objects. It is applicable to any visualization systems for displaying the changes of objects that have been developed or transformed into some other objects.
We developed a reference-based 3D morphing technique by using Open Inventor, the graphics libraries with the C++ interface, to implement and test our algorithms. The models used are 3D polygonally-based representation of objects. Each object is composed of the coordinates of each vertex, the edge connections, the color of each polygon or/and its texture file. These models are commonly used and can be obtained easily. Our method provides general solution to solve three major problems of morphing: control, establishing correspondence, and interpolation for a class of polyhedral models. A pair of reference lines and a pair of lines perpendicular to the reference lines embedded inside the source and target models are utilized in solving these three problems. For control, they define how objects are oriented. For establishing correspondence, they are used for projecting all vertices from the inside out. Applying the inside-out clipping algorithm merges the topologies of two objects. Finally, we apply linear interpolation to the length and angle of each vertex in the form of a polar coordinate system representation. The reference line and line center are chosen for measuring the length, and angle of the edge from that vertex to the center. Reference lines help avoid distortion in vertex-path interpolation and reduce surface self-intersection considerably. The polyhedral models are restricted to the case that all vertices are visible from either end or the center of the reference line.
The following tasks have been accomplished:
- (1) Development of the C++ programs and the supporting graphics routines of OpenInventor for embedding the reference axes.
- (2) The routines for creating the correspondence and the merging of object topologies are accomplished and have been tested for more than 20 pairs of 3D polygonally-based representation of objects.
- (3) Devised some approaches to improve the interpolation techniques. These include the simple linear interpolation techniques and other high order interpolants. The results showed that the linear interpolation can give good results but it has to be applied to the polar coordinate representation of vertices combined with the information on object orientations.
- (4) We have published a paper in the proceedings of the International Conference on Information Technology 2001.
Two-Dimensional Simulation of Fire Using the Ising Model and Monte Carlo Simulation - The Implementation
Henry Williams (FAMU)
Research Objectives and Significance:
The objective of this research focuses on developing a model to simulate fire in a virtual environment using a distributed parallel computing environment. The approach involves developing a two-dimensional (2-D) simulation of fire that improves on current 2-D fire simulations and uses Monte Carlo simulation techniques and stochastic models like the Ising Model as templates. A 2D simulation, FireSim2, was developed to test the theoretical background that could lead to a 3-D fire simulation in a virtual environment.
The effects of fire and smoke it produces can have a significant impact on the strategic and tactical goals of a battle unit. Military personnel training in virtual world simulations and using training simulators may experience a realistic representation of these phenomenological elements that occur in real world theaters of war. As such, the effectiveness of combat simulators may improve as simulated fires and smoke mimic their real counterparts. Consequently, the cost of effectively training soldiers may be reduced.
FireSim2 is currently being expanded from 2-D to 3-D. Additional work is being done on changing the output display method. Currently, the output window is an array of 3600 panels that simulate pixels. With each iteration of the simulation, each of the panels is updated regardless of whether its color value changes. The modifications being done involve getting the array to update only those panels that register a color change. Furthermore, algorithms for simulating fire spread, fuel consumption, smoke generation and reactions to wind are being developed. Cross-platform functionality is being tested to ensure that the fire simulation operates on a variety of computer platforms. A distributed parallel processing technique was investigated to increase the speed of the computation and to expand the capacity of the program to process large arrays.
The ADSRC group at FAMU has developed and improved on the computation and visualization of a two-dimensional fire simulation in its endeavor to create a three-dimensional 3-D fire simulation for virtual environment training simulations. Two main goals have been met in producing this simulation:
- a) The simulation system, called FireSim2, uses temperature difference equations, Monte Carlo simulation techniques and the Ising Model (as a template) to produce a visually accurate 2-D simulation of fire with random, erratic behavior.
- b) FireSim2 is an improvement over current 2-D fire simulations, since it generates simulated images of fire that are recognizable to individuals viewing the graphical display. This improvement has been accomplished by using arrays of several thousand elements, each element representing a single pixel, and using probability values that allow the simulation to mimic fire in two dimensions.
Computer Representation and Control of Images in ADS Environments
H. L. Williams, Girish Kota, Girish Patil (FAMU)
Research Objectives and Significance:
Much work has already been done so far in the design, development and implementation of efficient physics-based mathematical models for the computer simulation of fire, smoke, and other phenomenological elements in distributed simulation environments. Our main efforts have been focused on the expansion of the well-known and simple Ising model to represent these phenomenological elements as systems of tightly coupled particles. Smoke and fire have been successfully represented graphically in our ADSRC computer environment. In this sub-project, our current research emphasis has now shifted from the problem of creating graphical representations of elements like fire and smoke to the problem of inserting those graphical images into a dynamic virtual environment. This is a new direction in the ADSRC project. This summer we initially limited our concentration on the exploration and development of ways to reduce the large volume of image data streams which is created when smoke is simulated in our Ising simulation model. This is a crucial step in the implementation of scenarios involving smoke interactions with other entities in virtual environments. This capability allows for realistic simulations of battlefield operations and is of wider relevance to government and industry.
The incorporation of real-time obscurants into computer simulations makes the virtual battlefield much more realistic. The reduction in size of the large image data sets also improves the overall network performance of scaled simulations. This allows for military training at higher levels of complexity thereby enhancing readiness for battle.
It was supposed that the two-dimensional Ising model was used to represent smoke as a system of tightly coupled particles. Consequently, the effects of temperature, magnetization, and force-field on the particles as a result of the spinning effect of the particles were assumed to be incorporated into the computer image representation of the smoke. We limited our initial analysis to smoke simulations only. (Other phenomenological elements such as fire and aerosol sprays will be considered at a later time.) We concentrated our efforts on the design, development, testing and implementation of a Graphical Control Engine, (GCE) which would allow for the representation and control of visual objects in a virtual battlefield simulation. Ways to devise methods for building and implementing the GCE were heavily investigated using digital signal processing and image processing techniques, concepts, and tools such as the discrete Fourier transform and wavelets. OpenGL was the main software tool used in the development of the GCE to represent and control smoke images. The C programming language was also used as needed. Various standard image formats such as MPEG and JPEG were targeted for investigation as useful data formats.
The development of the Graphical Control Engine proved to be quite dependent upon the development of more basic items. We employed two electrical engineering graduate students to assist us with the digital and image processing aspects of the project. However, their learning curve was steep for the ADSRC application environment. In particular, they spent considerable time learning OpenGL and other software tools in our environment so that most of our work was done in the areas of the design of the GCE and the development of a tutorial on wavelets and other useful DSP and image processing information. The representation of smoke particles in OpenGL was also completely designed.
Using the Message Passing Interface (MPI) for Computational Speed-up, Color Mapping and Visualization
H. L. Williams, S. Roper, R. Giroux, C. Birmingham II, M. Arradondo (FAMU)
Research Objectives and Significance:
Use of the MPI environment was expected to increase the speed of the computations required of the 2-D Ising calculations. (This component of the algorithm complements the sub-project on using heat transfer equations and other models for modeling fire behavior.) It was assumed that the Message Passing Interface system would reduce the time necessary to process large lattices both mathematically and graphically. A parallel version of the Ising algorithm was implemented and currently runs in the MPI environment on a cluster of SGI workstations. Currently, the Java/OpenGL API environment is being used to render and visualize the simulation to understand the inherent phenomenology. In the heat transfer subtask, fire behavior was modeled according to the Ising lattice function, which was decomposed into sub-lattices.
Analysts studying fire and smoke often employ computer simulations, which model the behavior of these statistical mechanical systems using physics and mathematical theory. Computer programs like CFAST and FAST create zone models of fire and smoke that predict the effect of temperatures, various gas combinations, and the height of smoke-layer in multi-compartment structures. Distributed simulation environments have played a significant role in an ever-increasing number of critical military and commercial applications. Applications ranging from fire safety training to virtual warfare benefit tremendously from this emerging technology. These synthetic virtual environments necessitate the inclusion of real-time obscurants such as fire and smoke into the computer simulation in complex ways.
Real-time simulations of large systems with two-dimensional or three-dimensional lattices require significant processing power. Using a distributed computing environment with an MPI system reduced the time required to process large lattices mathematically and graphically. In particular, an increase in computational speed was observed when the sub-lattice sizes were increased. The Monte Carlo simulation was performed in a five-node distributed MPI environment. This environment used four client nodes and the host node - which were hard-coded into the simulation program. Therefore, the configuration required N+1 nodes (the host and N clients) such that each sub-lattice size was a 5x5 matrix/grid. Four MPI 'daemon' processes were spawned on the nodes. Each 5x5 sub-lattice was mapped onto one SGI O2 node. Using the MPI and Ising calculations, it was possible to represent a cluster of particles as a 2-D grid. Working from this architecture, visualization of some of the most random physical phenomena became relatively easy.
Results from the numerical calculations in the simulation provided sets of input data for an OpenGL backend graphics program to render the graphical output. The OpenGL subsystem mapped the computed data values into graphic elements by assigning different colors to the temperature values. For example, each particle might have an initial ambient temperature value that corresponds to a transparent color to simulate the presence of air. With the introduction of a flame element, the particles that actually comprised the flame were varied in color from bright yellow in the hottest areas to dark red in the cooler areas. Those particles near the edges of the fire were given a gray color to indicate the presence of smoke. Incorporating heat transfer principles into the program allowed for the calculation of subsequent temperatures for each particle in the array. A recursive calculation of the basic heat transfer algorithm coupled with graphical color assignment and mapping techniques, was used to generate a simple animated fire effect.
Page maintained by CST Web Support Technician
Last updated or reviewed on 10/19/10