Encircle
Encircle
Description
Encircle is a cross-platform imaging toolkit that affords a natural user interface for 3D image visualization, 3D reconstruction, arbitrary slicing, and much more. Encircle is a novel technological foundation that allows for the generation of state-of-the-art 3D imaging applications.
Encircle is the harmonious integration between a high-performance 3D imaging toolkit and a user interface widget library. Patented technologies form this union by aligning design paradigms between the two. This saves the software developer substantial time and allows them to focus on scientific problems at hand when developing complex high-performance applications. This saves time, money, and makes our software developers more efficient at solving difficult real-world software problems.
Stratovan Encircle™ is a cross-platform foundation tailored to imaging applications. The complexity of imaging software demands harmonious integration of numerous technologies. Encircle incorporates patent-pending user interface technology that permits natural user interface evolution while minimizing internal changes to data structures, algorithms, and connective logic. Encircle minimizes the complexity in creating multi-target commercial quality applications that look and act like native software. On a Mac it looks like a Mac application and on Windows it looks like a Windows application.
Encircle reduces the complexity of connecting user interface (UI) elements to complex data structures and algorithms.
Measuring the complexity of a user interface is challenging. Tangible metrics such as lines of code and required level of understanding are both reduced using the Encircle platform. However, it is the intangible issues that contribute to complexity in difficult to measure ways. Consider these questions in regard to your current platform of choice and how they contribute to your everyday workload:
- How do you position widgets in a UI layout?
- How is the UI context (i.e., a list box selection state) accessed by application data structures and algorithms?
- How do widgets get their data?
- What percentage of your time is spent on (re-)wiring UI elements to data structures compared to high-value time spent on data structure and algorithm development?
Furthermore, consider how each of these issues affect late-stage UI design changes. Typically, these issues result in several hours/days of work for minor UI changes, such as moving a button or changing the window hierarchy.
- Cross-platform development: Windows and OSX.
- Integrated multi-processor threading support.
- OpenGL integration and substantial support for hardware accelerated graphics.
- Integrated software licensing.
- Common mathematical methods and linear algebra tools.
- Medical imaging data structures, tools, visualization, 3D reconstruction, slicing, and more.
- Includes Stratovan Relay&trade, a patent pending resolution independent user interface design technology.
- Hundreds of miscellaneous data structures, algorithms, and tools for image processing and 3D manipulation.
- Integrated landmark editing system.
- Easy to use user interface widget layer.
- Patent pending centralized selection context for handling selection state throughout a software application.
- and more...
Encircle Layout Technology | ||||||||||||||
Stratovan Relay™ is a patent-pending resolution independent layout technology that bases runtime widget resizing and positioning on two source layout designs. The UI designer specifies a small and large layout so that the widgets are positioned correctly for each size. During runtime, Relay automatically determines the size and position of each UI element based upon the runtime width and height of the layout. The following images show an actual UI designed using Relay technology and the corresponding runtime layouts (click on each image to enlarge): | ||||||||||||||
| ||||||||||||||
Conventional Layout Technologies | ||||||||||||||
Consider these questions for your current widget platform:
Conventional layout technologies:
|
Centralized Selection Context |
Stratovan Encircle™ integrates a patent-pending centralized selection context for widgets. The technology pulls the selection state for each widget out of the widget itself and places it in a centralized storage that can then be queried, updated, or listened-to from any portion of the application. Centralizing the runtime UI selection context has a profound effect on reducing the complexity of data binding between the UI widgets and your data structures and algorithms. The following image shows a diagram of the conventional selection context in relation to data binding:
Under this paradigm, the application developer must mediate between the widgets and data structures and algorithms (data storage). The mediator must query widgets for selection state, retrieve the appropriate data, and then provide that data directly to each widget. This results in several direct connections to widget objects. These direct connections are the main source of complexity that prevent late-stage UI changes. Some widget toolkit vendors recognized the difficulty with providing data to widgets and added direct data binding to alleviate the issue:
While direct data binding alleviates the issue of getting data into a widget, the application developer must still query widgets directly to obtain their selection state in order to determine which data the widget displays. Thus, direct connections to widgets are still commonplace under this modified paradigm. Encircle combines direct data binding with a centralized selection context in the following manner:
This paradigm eliminates all direct connections between widgets to internal data structures and algorithms. Flexibility is obtained by connecting through generic direct data binding interfaces in addition to connecting to the central selection context. This results in a less complex mediator and minimizes the maintenance of the "wiring" between widgets and data. Since the UI connections are simplified, late-stage UI changes (i.e., moving widgets around based on user studies and requests) are now easily incorporated. |
Conventional Selection Management |
Consider these questions for your current widget platform:
Conventional paradigms are widget-centric in that widgets "own" their selection state. This requires the application developer to query each widget when the selection state is needed. Consider how a list box maintains selection state and how it must be queried to obtain it within an application. A widget-centric paradigm results in:
|
Conventional Data Binding |
Consider these questions for your current widget platform:
|
Stratovan Encircle™ utilizes a class-centric notification mechanism. It is class-centric in the sense that the specific notifications (messages, connection points, etc.) are defined relative to a specific class. This is counter to conventional paradigms that tend to use a numeric counter or ID, which can easily lose integrity in large software projects.
Encircle differentiates between the following notification types:
- Command - i.e., when a button is clicked
- Selection set - i.e., denotes which list box item is selected
- Datum - i.e., a specific class member variable
- Class ID - i.e., a class ID useful for serialization
- String - i.e., accessing application strings from anywhere in the implementatio
To add a new notification, you declare the notification in the class in which it is associated using one of the following mechanisms:
- COMMAND_DECLARATION( classname, commandname )
- SELECTIONSET_DECLARATION( classname, selectionsetname )
- DATUM_DECLARATION( classname, datumname )
- CLASSID_DECLARATION( classname )
- STRING_DECLARATION( classname, stringname
The above declarations are placed within the enclosing backets of the classname (in a public section) and can be referred to in any part of the application using the following:
- TYPE_COMMAND( classname, commandname )
- TYPE_SELECTIONSET( classname, selectionsetname )
- TYPE_DATUM( classname, datumname )
- TYPE_CLASSID( classname )
- TYPE_STRING( classname, stringname )
Conventional Notifications
Consider these questions for your current widget platform:
- How are command notifications handled?
- How do you notify the UI when data changes?
- Does the widget/window hierarchy play a role in command routing?
- Is there a delineation between "commands" and selection state changes?
