US20040004612A1

US20040004612A1 - Method and system for processing graphics simulation data

Info

Publication number: US20040004612A1
Application number: US10/191,354
Authority: US
Inventors: Stephen Guest; Jeffrey Minor
Original assignee: Lockheed Martin Corp
Current assignee: Lockheed Martin Corp
Priority date: 2002-07-08
Filing date: 2002-07-08
Publication date: 2004-01-08
Also published as: US20060038816A1; WO2004006141A1; US7190363B2; AU2003243747A1

Abstract

A method and system for processing graphics simulation data is disclosed. Initially, a group of three-dimensional visual models to be rendered in a graphics simulation are constructed. Data that are utilized to move and control elements of the graphics simulation are acquired. The acquired data are subsequently converted to an object oriented format having tables and functions by automatically resolving dependencies between inputs and outputs of each of internal objects with external inputs and external outputs, respectively. Next, a link is established between the data in the object oriented format using the independent and dependent variables and the elements of the graphics simulation. Finally, the data in the object oriented format are processed via a graphics simulation.

Description

BACKGROUND OF THE INVENTION

1. Technical Field

The present invention relates to data processing in general, and in particular to graphics processing within a data processing system. Still more particularly, the present invention relates to a method and system for processing graphics simulation data within a data processing system.

2. Description of the Related Art

Advancements in computer-aided design technology enable engineers to run graphics simulations on a computer system to assist in the testing of physical properties of parts or systems. The ability to run graphics simulations of the physical properties of the parts or systems enables engineers to identify potential design flaws or deficiencies prior to their actual manufacture and/or implementation. But even after the manufacture and/or implementation, graphics simulations allow engineers to visualize certain failure modes based on the data collected from the actual parts or systems. For example, graphics simulations can be utilized to determine when and where a mechanical part will fail under load conditions, thereby enabling engineers to strengthen or modify the mechanical part to improve its performance.

Prior art graphics simulation methodologies typically fall under one of the following two categories. The first category requires graphics simulation software to be custom written specifically to control known elements of the graphics simulation. As a result, the graphics simulation software has to be recompiled for each unique element within a system. The second category allows simulation software to be a little more generic in the sense that the simulation software may not have to be recompiled for every unique graphics simulation, but each controllable element in a simulation is required to be defined by a rigid format and naming convention.

Consequently, it is desirable to provide an improved method for processing graphics simulation data within a data processing system.

SUMMARY OF THE INVENTION

In accordance with a preferred embodiment of the present invention, a group of three-dimensional visual models to be rendered in a graphics simulation are constructed. Data that are utilized to move and control elements of the graphics simulation are acquired. The acquired data are subsequently converted to an object oriented format having tables and functions by automatically resolving dependencies between inputs and outputs of each of internal objects with external inputs and external outputs, respectively. Next, a link is established between the data in the object oriented format using the independent and dependent variables and the elements of the graphics simulation. Finally, the data in the object oriented format are processed via a graphics simulation.

All objects, features, and advantages of the present invention will become apparent in the following detailed written description.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention itself, as well as a preferred mode of use, further objects, and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein: [0009]
FIG. 1 is a block diagram of a data processing system in which a preferred embodiment of the present invention is applicable; and [0010]
FIG. 2 is a high-level logic flow diagram of a method for processing graphics simulation data, in accordance with a preferred embodiment of the present invention. [0011]

DETAILED DESCRIPTION OF A PREFERRED EMBODIMENT

The present invention may be executed in a variety of computers under a number of different operating systems. The computer may be, for example, a personal computer, a midrange computer or a mainframe computer. In addition, the computer may be a stand-alone system or part of a network such as a local-area network (LAN) or a wide-area network (WAN). [0012]
Referring now to the drawings and in particular to FIG. 1, there is illustrated a block diagram of a data processing system in which a preferred embodiment of the present invention is applicable. As shown, a [0013] data processing system 10 includes a processor 11, an input device 12, an output device 13, a memory 14, and an information source 15. Information, such as variable value data, may be received from a user via input device 12 such as a keyboard. Output values or results may be output to the user via output device 13 such as a display.
By way of example, [0014] information source 15 may comprise a model library 25 having one or more models 26 that may be selected by the user via input device 12. Each of models 26 include one or more cooperative collections of objects 27 to provide a simulation or analysis of selected information. However, models 26 may be otherwise configured to provide analysis, simulation or other user defined information processing parameters. Objects 27 generally include data sets, data tables, or functions for processing information according to a selected one of models 26. Each object 27 represents an instance of some class, and whose classes are all members of a hierarchy of classes united via inheritance relationships. Each object 27 includes an input variable and an output variable. Each object 27 is an identifiable, encapsulated piece of code and data that provide one or more services when requested by the user. Thus, based on an input variable value, object 27 provides an output variable value corresponding to the table, data set or function of object 27.
[0015] Information source 15 may also include a variable identifier database 20 having a unique identifier associated with each input variable and output variable of objects 27. For example, the unique identifier may include terminology, alphanumeric designations, phrases or other suitable identifiers to identify particular input variables and output variables of objects 27.
Software programs, such as a [0016] loading engine 21, an update engine 22, a reporting engine 23, and an interface application 24, are illustrated as being stored in memory 14 where they can be executed by processor 11. Loading engine 21, update engine 22, reporting engine 23, and interface application 24 may also be stored on a variety of other types of storage media.
Loading [0017] engine 21 processes information from information source 15 in preparation for evaluation of the information using update engine 22. Loading engine 21 automatically creates object links between each of the input variables and output variables of objects 27 of a selected one of models 26. Loading engine 21 may access variable identifier database 20 for each object 27 included within a particular one of models 26 to automatically determine the input and output variable of objects 27 and automatically link corresponding input and output variables of the objects 27.
Update [0018] engine 22 processes models 26 and automatically updates each object within a model sequentially to obtain output variable values of the user-selected model based on user-defined input variable values. For example, update engine 22 sequentially updates each object of a model to obtain output variable values for each of objects 27 without performing redundant calculations. Thus, a particular one of objects 27 may be updated when an output variable value of the updated object is required to support the update of another one of objects 27.
[0019] Reporting engine 23 may be used to display output variable values of a particular one of models 26 to the user via output device 13. For example, reporting engine 23 may provide output variable values in a particular format or structure as defined by the user via input device 12. However, reporting engine 23 may be otherwise used to display or provide output variable values to the user.
[0020] Interface application 24 may be used to receive input variable values from the user via input device 12 and automatically associate the data or input variable values received from the user to corresponding input variables of objects 27. However, input variable values may be otherwise received and associated with the corresponding input variables of objects 27.
With reference now to FIG. 2, there is depicted a high-level logic flow diagram of a method for processing graphics simulation data, in accordance with a preferred embodiment of the present invention. Initially, requirements for visual simulation are defined, as shown in [0021] block 51. For example, the basic layout of the desired visual simulation, the desired three dimensional (3D) visual models, the simulation data, the user interaction (i.e., how to control the simulation playback and observer viewpoint), and the display requirements (i.e., update rates, output format and size, etc.) are defined. Then, various 3D visual models to be rendered in visual simulation are built, as depicted in block 52. The 3D visual models to be rendered in the visual simulation may include objects such as airplanes, terrain, people, etc. Next, data that are utilized to move and control elements of the visual simulation are built, as shown in block 53. Instead of building, such data can also be acquired from various sources such as engineering analysis, recorded flight test or flight simulation, etc. The built or acquired data are then converted to an object oriented format, such as a GEMD format, as depicted in block 54. The built or acquired data has to be converted to the object oriented format in order to remove the burden of writing custom code for each unique visual simulation, as it is done in the prior art. A linkage between the object oriented data, such as GEMD data, and the elements of the visual simulation is then established, as shown in block 55. The remaining visual simulation attributes are then defined, as depicted in block 56. The remaining visual simulation attributes define the rest of the details such as clouds, fogs, initial viewpoint, etc., for the visual simulation. Finally, the visual simulation software is executed, as shown in block 57.
For use in data processing system [0022] 10 (from FIG. 1), an object oriented GEMD file preferably includes three object types, namely, a dataset object, a table object, and a function object. A sample object oriented GEMD file is depicted as follows.

dataset d_gemd_sample

indvar time

depvar x y z h p r

{

function f_to_vega

indvar time xloc yloc alt psi theta phi

depvar x y z h p r

{

x = yloc / 3.281;

y = −xloc / 3.281;

z = −alt / 3.281;

h = psi * 180 / 3.14159;

p = theta * 180 / 3.14159;

r = phi * 180 / 3.14159;

}

table t_data

indvar time

depvar xloc yloc alt psi theta phi

{

time xloc yloc alt psi theta phi

0 0 0 5000 5 3 45

0.1 99 14 5060 4 2 34

1 212 135 5030 3 3 4

...

100 980 432 3500 9 −3 −55

}

}
For the linkages (in block [0023] 55 of FIG. 2) to work, the top level object in the object oriented GEMD file has to be a dataset and has to have a unique dataset name. The above-shown sample object oriented GEMD file provides a dataset with the name of d_gemd_sample. Independent variables are the variables that receive the time from the simulation. The top level dependent variables are those that are used by the simulation to control a simulation element. An object oriented GEMD dataset, by definition, includes other datasets, tables, or functions. In this example, a function is needed to convert the source data into units used by the visual simulation. Therefore, the above-shown object oriented GEMD sample file uses a function called f_to_vega to take the source data and make the necessary conversions. Again, the independent variables have to be identified and in this example, it is not only time, but the source data variables that will need to be converted. The dependent variables are those that will be returned out of the function with the converted values. In the above-shown object oriented GEMD sample, the x and y values are swapped, and converted from feet to meters. For the heading, pitch and roll variables (such as h,p, and r) are included with radian converted to degree.
An object oriented GEMD table is defined with the name of t_data with the independent variable of time and the dependent variables being the original source data. Often the table is kept in a separate file and uses a GEMD convention of “# include” to point to that file so that it does not have to be edited with the header information. In the end, it is the definition of independent and dependent variables that define the way GEMD automatically determines dependencies and order of operations in order to generate the top level dependent variables based on the top level independent variable. [0024]
The steps for converting raw source data into GEMD format (as depicted in block [0025] 54 of FIG. 2) are as follows:
(A) If the data is in a tabular format, then [0026]
1. create new file; [0027]
2. add a GEMD table header and name; [0028]
3. add an indvar declaration to identify time variable in the GEMD table; [0029]
4. add a depvar declaration to identify dependent variables in the GEMD table; [0030]
5. add an open brace “{”; [0031]
6. add a list of table variables; [0032]
7. include tab or space delimited table of numbers; and [0033]
8. add a close brace “}”. [0034]
The resulting file is then either be directly added to the GEMD file that contains the data source definition, or it can be referenced by using the GEMD “# include” directive. [0035]
(B) If the data is in the form of an equation or set of equations, then [0036]
1. create a new file; [0037]
2. add a GEMD function header and name; [0038]
3. add an indvar declaration to identify time variable in the GEMD table; [0039]
4. add a depvar declaration to identify dependent variables in the GEMD table; [0040]
5. add an open brace “{”; [0041]
6. add equations using C/C++ like GEMD syntax; and [0042]
7. add an close brace “}”. [0043]
As with the GEMD table in (A) above, the function can be directly added to the parent dataset or referenced via “# include” directive. [0044]
The steps for establishing linkage between the GEMD data and the visual simulation elements (as depicted in block [0045] 55 of FIG. 2) are as follows. The “DataSource” must be identified first and it defines the GEMD file and the associated top level dataset variables that will be utilized to control the visual simulation elements by
1. identify the GEMD file to be used; [0046]
2. identify the independent time variable; and [0047]
3. identify the list of dependent variables. [0048]
Next, the visual simulation elements that are to be controlled by the GEMD variables must be linked by identifying the required parameters. This linkage is known as the “DataPipe,” as follows: [0049]
1. identify GEMD DataSource; [0050]
2. identify type of visual simulation element to control (e.g., player position, control surface deflection, enabling/disabling symbology, etc.); [0051]
3. identify specific element in simulation to control (e.g., which player, which control surface, etc.); and [0052]
4. identify the GEMD variables necessary to enable the manipulation of the visual simulation element (some require only one variable, others might use nine or more). [0053]
After the linkage has been defined by the user, [0054] data processing system 10 automatically creates and associates specific controlling functions with the identified GEMD variables and visual simulation elements. This step occurs at the initiation of the visual simulation application. Then, at run-time, before each frame is rendered, the controlling function is invoked that calculates the necessary information based on the associated GEMD variables. Once this is done for each DataPipe, a single frame is rendered. The steps associated with this activity are as follows. At initialization, for each DataPipe:
1. gather DataPipe parameters defined for controlling visual simulation element; [0055]
2. establish controlling function appropriate for specified visual simulation element; [0056]
3. link defined GEMD variables into controlling function; and [0057]
4. register controlling function to execute prior to the rendering of each frame. [0058]
At run-time, prior to rendering each frame, each registered controlling function for all DataPipes is executed prior to rendering frame and the frames are rendered. [0059]
As has been described, the present invention provides a method and system for processing graphics simulation data within a data processing system. The present invention provides the capability of using a graphical user interface to define specific GEMD data (variables) and how they control individual elements of the visual simulation. Specifically, GEMD data can control an object's position, a DOF head position (allows articulation of individual pieces of an object), dynamic text displays, turning on and off specific elements, turning on and off sounds, etc. Using such capability, a wide variety of data and simulation elements can be controlled without having to rewrite and recompile any software, nor do simulation elements require a rigid construction format or naming convention. [0060]
While the invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention. [0061]

Claims

What is claimed is:

1. A method for processing graphics simulation data within a data processing system, said method comprising:

constructing a plurality of three-dimensional visual models to be rendered in a graphics simulation;

acquiring data that are utilized to move and control elements of said graphics simulation;

converting said acquired data to an object oriented format having tables and functions by automatically resolving dependencies between inputs and outputs of each of internal objects with external inputs and external outputs, respectively;

establishing a link between said data in said object oriented format using said independent and dependent variables and said elements of said graphics simulation; and

processing said data in said object oriented format via said graphics simulation.

2. The method of claim 1, wherein said method further includes defining requirements for a graphics simulation.

3. The method of claim 1, wherein said functions are objects.

4. The method of claim 1, wherein said object oriented format is GEMD format.

5. The method of claim 1, where said external inputs are independent variables and said external outputs are dependent variables.

6. A computer program product residing on a computer usable medium for processing graphics simulation data, said computer program product comprising:

program code means for constructing a plurality of three-dimensional visual models to be rendered in a graphics simulation;

program code means for acquiring data that are utilized to move and control elements of said graphics simulation;

program code means for converting said acquired data to an object oriented format having tables and functions by automatically resolving dependencies between inputs and outputs of each of internal objects with external inputs and external outputs, respectively;

program code means for establishing a link between said data in said object oriented format using said independent and dependent variables and said elements of said graphics simulation; and

program code means for processing said data in said object oriented format via said graphics simulation.

7. The computer program product of claim 6, wherein said computer program product further includes program code means for defining requirements for a graphics simulation.

8. The computer program product of claim 6, wherein said functions are objects.

9. The computer program product of claim 6, wherein said object oriented format is GEMD format.

10. The computer program product of claim 6, where said external inputs are independent variables and said external outputs are dependent variables.

11. A data processing system for processing graphics simulation data, said data processing system comprising:

means for constructing a plurality of three-dimensional visual models to be rendered in a graphics simulation;

means for acquiring data that are utilized to move and control elements of said graphics simulation;

means for converting said acquired data to an object oriented format having tables and functions by automatically resolving dependencies between inputs and outputs of each of internal objects with external inputs and external outputs, respectively;

means for establishing a link between said data in said object oriented format using said independent and dependent variables and said elements of said graphics simulation; and

means for processing said data in said object oriented format via said graphics simulation.

12. The data processing system of claim 11, wherein said data processing system further includes means for defining requirements for a graphics simulation.

13. The data processing system of claim 11, wherein said functions are objects.

14. The data processing system of claim 11, wherein said object oriented format is GEMD format.

15. The data processing system of claim 11, where said external inputs are independent variables and said external outputs are dependent variables.