AGI STK Engine (4DX) Blog

May 16, 2010

Vector Geometry API (Beta) – Part Uno

Vector Geometry Tool API is now out and available as beta with STK 9.2. With the Vector Geometry Tool API developers and engineers can programmatically manipulate existing or create custom geometric constructs in order to perform analysis and/or visualization. (more...)

May 13, 2010

STK 9.2 is out!

Filed under: STK Object Model, stk — Tags: , , — Sylvain @ 4:11 pm

STK is 9.2 is out! You can download the new release from ADN here. The release notes are also available online here. Besides the STK enhancements, this release also adds (beta) support for the Vector Geometry Tool to the STK Object Model. This is a brand new library! More details to come on this blog in the next days. Stay tuned!

January 29, 2010

Update on mono

Filed under: .Net, Linux, mono — Tags: , , , — Sylvain @ 12:23 pm

Previously in this blog I wrote an article about using STK Engine with mono (see here). At that time, mono supported running a purely analytical STK Engine application, but with some limitations. One of the limitations found was the lack of proper support for passing arrays as parameters to the STK Engine methods (i.e. marshalling of COM safearrays between managed and unmanaged code). Since then, I have contributed two patches (r136836 and r149817) to the mono code base that address these issues. (more...)

June 3, 2009

Using the Object Model with C++Builder 2009

Filed under: Uncategorized — Tags: , , , , — Logan @ 4:19 pm

We recently had a question about how to use the STK Engine within C++Builder (previously known as Borland C++ and now produced by CodeGear). In this article I will walk you through the steps required to enable the STK Engine in your C++ Builder environment. A full example is provided and attached to this article. It is a C++Builder port of the STKProTutorial tutorial available in a regular STK 8 install. (more...)

May 13, 2009

STK 9 Astrogator Object Model

Filed under: .Net, C#, Java — Tags: , , , , , — Matthew @ 5:15 pm

With STK 9 just about wrapped up, I have time to talk about some of the new features added to the STK Object Model. I'll be focusing today on one of the major pieces that was added, Astrogator. For those who aren't too familiar with Astrogator, it is a specialized analysis module for interactive orbit maneuver and spacecraft trajectory design. Astrogator acts as one of the propagators available for a satellite object. This module calculates the satellite's ephemeris by executing a Mission Control Sequence, or MCS, that you define according to the requirements of your mission. By exposing it through the STK Object Model you now have more options for automating repetitive tasks, integrating with other applications or even developing your own custom application. (more...)

March 16, 2009

What’s cooking in STK Engine 9.0…

Filed under: .Net, C#, Java — Tags: , , , , — Sylvain @ 9:04 am

Hi everybody! Sorry for not posting more articles on this blog for the last couple of months. We have been busy working on STK 9.0! We have lots of exciting Engine features currently in the final stages of development (this is in addition of many, many new features in the STK Desktop application as well, both on the user interface usability and the computational capabilities). The STK 9 Seminar Series will be held tomorrow and (more...)

November 3, 2008


Filed under: .Net, C#, Linux, mono — Tags: , , , — Sylvain @ 11:50 am

Update to this post available here

In the past few months a couple of requests for information have been posted on ADN forums regarding using STK Engine (4DX) with mono on Linux (see here and here). This question also comes up from time to time directly from customers. In the past the missing piece has been COM interop (STK Engine is written in C++ with the API exposed to .Net using COM Interop). Therefore when mono 2.0 came out at the beginning of October the mention of better COM interop support sparked my interest. From Miguel de Icaza's blog announcing mono 2.0: «COM interop is now complete (works on Windows with "real COM" and can be used on Unix with Mainsoft's COM or Mozilla's XPCOM)». However I could not find anywhere a list of what is or is not supported at this point. The documentation is somehow sparse, or outdated and still referring to mono 1.1 in most places. So I decided to take a look and evaluate what is possible (more...)

October 1, 2008

Installing STK Engine on Ubuntu Linux

Filed under: Java, Linux — Tags: , , , , — Sylvain @ 5:11 pm

In my last post I promised to give directions about how to install STK Engine 8.02 on Ubuntu 8.04. So here it is, in a few easy steps. I used a VMware virtual machine to generate this procedure. I configured the virtual machine for 1GB of memory and an 8GB hard disk. I started from a clean install of Ubuntu using the default install settings (more...)

May 7, 2008

STK Object Model Contexts

Filed under: Uncategorized — Tags: , — Peter @ 12:22 pm

A context within the STK Object Model is an object holding the unit preferences, the Object Identify Cache (OIC) as well as access restrictions. Contexts are not directly accessible to the users, yet users can influence their behavior to a certain degree (see the following article "Root Object Isolation"). Any object created or accessible through the Object Model is associated with a context through which the object accesses the unit preferences to perform the unit conversion. The diagram below shows the two root objects sharing the same context.

STK Object Model: Root Object Isolation

In the version 8.1 we have introduced a new feature called ‘Root Object Isolation’. In a nutshell, the isolation is designed to provide a way for the 4DX developers to make multiple copies of the unit preferences. Here is a short example how to use the isolation to configure two distinct, non-overlapping unit preference sets. The code creates two independent root objects and configure each with its own set of unit preferences. This process is referred to as "isolation".

AgStkObjectRootClass rootA = new AgStkObjectRootClass();           
root.UnitPreferences.SetCurrentUnit("DistanceUnit", "km");
AgStkObjectRootClass rootB = new AgStkObjectRootClass();
// rootA and rootB  are now using non-overlapping unit preferences, i.e. the changes to the unit preferences via object “rootA” do not interfere with the unit preferences of the object “rootB”.

Note: The isolation must be done right after a new root object is instantiated. Once the root object becomes “tainted”, i.e. changed, any attempts to isolate it will not succeed and will throw an exception.

The benefits of having multiple roots isolated from each other becomes more obvious when building enterprise applications where it is necessary to make individual components as independent and isolated from each other as possible. Another example where Isolation becomes a must-have is in a type of application that is constructed out of many components, for example the Application Framework. Each add-in, to prevent interfering with other add-ins, must isolate itself from the rest of the add-ins so that each one manipulates with its own private set of unit preferences. The following diagram shows two root objects isolated from each other:

Note: the references to the STK objects are local to the context so use the “Path” property of the IAgStkObject interface to compare two instances to find whether they represent the same object within STK engine.

STK Object Model: Restricted Contexts and STK Plug-ins

Contexts are also useful for the STK engine plug-ins. A while ago, while in the process of exposing the Object Model to the Constraint Plug-ins, we realized that simply giving a full read/write access is not an option and here is why. When computing the access constraints, the engine expects its state to stay the same before and after the access computation is completed. Now imagine a custom access constraint plugin which changes a position of a facility, re-propagates a satellite or does something else that changes the state of the application. So what, one may ask? Well, changes to the object’s position will trigger the access computations and the access plug-in will be called again, and again, and again… To address this, we have introduced a "restricted" context which purpose is to provide a safe mechanism for accessing the STK object state via the Object Model while protecting its state. How does this work?
When accessing the STK Object Model configured using a restricted context, the users are given read-only access to the STK Object Model objects and their methods and properties. Any attempt to change the application state by calling a method or changing a property value will result in an exception. The diagram below shows the restricted STK Object Model Root object accessed by the access constraint plug-in. Any action via the Object Model will first consult the associated context and throw an exception in case if the action is marked unsafe. So, if you are writing an access constraint plug-in and intent to use the Object Model, beware of the restricted contexts.


Powered by WordPress