Eye-Sys

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Eye-Sys
Eye-Sys Logo.jpg
Developer(s) Interactive Data Visualization, Inc. (IDV)
Stable release
1.0 / November 13, 2007
Operating system Windows
Type Visualization (graphic)
License Proprietary
Website www.eye-sys.com

Eye-Sys (pronounced like “Isis”) is a general-purpose commercial visualization application. It was developed by Interactive Data Visualization, Inc. (IDV), developers of the SpeedTree video game middleware. Eye-Sys development was partially funded[1] by the U.S. Navy's Small Business Innovation Research (SBIR) program, and guided and administered by the Joint Warfare Analysis Center (JWAC).[2]

Prior to commercial release, Lockheed Martin selected[3][4] Eye-Sys for use in their performance of DARPA's Integrated Crisis Early Warning System (ICEWS)[5] project. Other pre-release uses included visualizations for MIT[6] and the Naval Surface Warfare Center (NSWC).[7]

Eye-Sys was released commercially in November 2007.

Overview[edit]

A screenshot of Eye-Sys, running a real-time aircraft carrier visualization

Eye-Sys is a Windows-based software application designed to gather data from disparate sources, manipulate that data in real-time as necessary, and use that data to drive interactive, real-time visualizations on consumer-level personal computers.

Using an extensible open architecture, Eye-Sys allows users to create interactive visualizations with data from a combination of sources such as text files, spreadsheets, databases, geographic data, real-time data from a network, and custom modeling and simulation output via a COM interface.

Other Eye-Sys features include:

  • Visual programming support (visualizations are built by a series of interlinked, configurable objects)
  • C++/.NET SDK for writing new objects.
  • JScript support at a global and object level.
  • Real-time interaction with visualizations.
  • Interoperability with other applications (e.g. Simulink).

Sandbox[edit]

Visualization systems in Eye-Sys are defined primarily through a visual programming area called the sandbox. The systems are driven by data imported from user-specified sources (like text files or databases) which can be manipulated by script objects and fed into display objects that render the data graphically.

Visualizations are defined through a visual program created in the sandbox by linking together nodes of various types. The four basic types of Eye-Sys nodes are:

  • Input Objects: Input objects are responsible for gathering data. In most cases that means pulling data in from external sources such as text files and databases.
  • Manipulators: Manipulators modify data that has already been imported or generated. They range from simple arithmetic expressions to complex scripts.
  • Display Objects: These render data-driven visualization components (e.g., 3D models, geometric primitives, ESRI shapefiles, etc.) arranged in a scene graph.
  • Display Systems: Display system objects manage the rendering of data and/or display objects and process user interaction.

Visualization Display & Output[edit]

Eye-Sys visualizations are displayed through its display system objects. Display systems facilitate both display and user interaction with a particular visualization, be it a 3D scene, plotter, control panel or other. There is no limit to the number of display systems that can be instantiated in Eye-Sys.

Eye-Sys can also export images and movies from its display systems.

Scripting[edit]

Eye-Sys supports scripting using JScript. Most of the functionality available to the user is available in functions exposed to the scripting engine. Scripts also have access to numerous SDK functions that help with object creation, modification, and connectivity.

Scripting functionality is available as both global scripts and script objects. Global scripts can be used to modify the overall visualization system or any object or objects in it. Script objects (implemented as manipulator objects) are used to affect data flow between objects (e.g. one might write a script to filter incoming data).

Plug-Ins & SDK[edit]

Each of the objects in Eye-Sys is loaded and instantiated through a plugin system (a series of Windows DLLs, each one representing a different object). The Eye-Sys SDK allows users to write their own plug-ins that can interoperate with the other objects in the library. Objects can be written in C++ or a .NET language. The SDK has an AppWizard for C++-based plug-ins and works only with Visual Studio 2005.

External Control[edit]

Eye-Sys provides a set of built-in COM interfaces which can be used to access the internal functionality of the application. These interfaces are utilized by the different scripting options Eye-Sys provides as well as any external applications (e.g. Simulink) that can communicate with Eye-Sys.

Using this interface, Eye-Sys can be used to visualize data from another application in real-time. Because it can be a two-way interface, Eye-Sys can be used to feed data back into the linked application (e.g. using a control panel in Eye-Sys to affect the live simulation feeding Eye-Sys data).

References[edit]

External links[edit]