Hot off the presses, AGI Components 2008 r7 is now available from the AGI Developer Network!
In addition to a couple of new features, this release includes some important bug fixes. See What's New for the complete list of changes.
Thank you to everyone that attended the 2008 AGI Users' Conference! For my part, I particularly appreciated everyone that attended my Under the Hood presentations and training sessions on AGI Components and asked some great questions!
The slides for all of the UC presentations should be available before too long from the main UC web site: www.agiuc.com. If you just can't wait, here are the slides for the two presentations I gave on AGI Components:
- Addressing Architectural Issues with AGI Components
- Scalable Servers and Applications using AGI Components
If you have any questions that you didn't have a chance to ask me (or any other member of the AGI Components team) at the UC, please don't hesitate to post them as comments to this blog entry or in the ADN forums.
As part of an effort to promote our "Software in any Form" message, I recently made a video that demonstrates the ease with which one can build web services using AGI Components. In this video, I build a simple web service to calculate intervisibility intervals between an orbiting satellite and a location on the ground during a specified analysis interval. The orbit of the satellite is calculated using the Two Line Element Sets (TLEs) for the satellite, which we propagate using the SGP4 progagator that is part of the Dynamic Geometry Library. The position of the ground location is specified using Latitude and Longitude. Of course, since the whole video is about 10-15 minutes, I use Visual Studio macros to insert the code (I didnt have the heart to make you watch me type). All in all, its about 80-100 lines of code. And its a good demonstration of how cool AGI Components are! BTW, the macros used to generate the code in the video can be downloaded from here - VS2005Macros. Load them up in VS2005. Looking at the still in the video, someone commented that I look like an axe murderer! So yeah, feel free to make fun of me 
I am a computer science major at
You end up working for 3 separate 6 month terms, divided by 6 months of normal classes. You may work for 3 different companies or for the same company 3 times (though that may defeat the purpose of coop).
I chose AGI over the competition because it seemed to offer what no one else did, true programming experience with professional software as well as graphics programming experience. The bountiful amounts of quality free food were not a deterrent either, mind you.
AGI delivered on its promise of being a challenging programming environment as well as being a great learning experience... the food delivered on its promise too.
While at AGI, I worked on the AGI Components team. AGI Components is a software library that enables 3rd party developers to use AGI technology in their own custom applications. This was perfect because it freed me from having to deal with the syntax and pointer issues you run into with C++ and focus solely on design in the C# .NET framework. I gained experience with design patterns and development methodology that I could not have learned in a classroom. These skills will be invaluable to me when I enter the workforce at the end of this year, and will place me a step above any graduate from a normal school who has nothing but good grades to back his experience.
Much of my early work was with bug fixes and small enhancements, which helped me learn the details of AGI Components, and at the same time, become familiar with the AGI development and integration pipeline. Once I had a handle on that, I began receiving larger and more challenging tasks that used my previously gained knowledge to add valuable components to the library.
When no projects existed that were within the scope of my abilities, I was tasked with creating demo applications that combined Point Break and Components. I thoroughly enjoyed writing these applications, they were a way to have fun with a 3D graphics engine in the process of being developed, and create truly impressive looking visualizations with data computed using the newest features of Components.
AGI was my 3rd and final coop. Before going into this cycle I wanted to make sure that my last coop would be my favorite as well as my most challenging. There is no question in my mind that I achieved this goal by choosing AGI.
AGI Components 2008 r6 is available now from the AGI Developer Network. Download it!
Primarily this release includes usability improvements and some important bug fixes. The complete list of changes can be found here: What's New?
As always, a development license for AGI Components is available free of charge and will be emailed to you in seconds. If you haven't tried AGI Components yet, what's your excuse?
If you've been designing software for any length of time, you've probably run into the concept of a "deep copy," usually contrasted with a "shallow copy." Wikipedia has a nice explanation.
Shallow copies are pretty straightforward. Most programming languages have a mechanism to make a shallow copy of an arbitrary object without any help from the implementor of the class. In C#, Object.MemberwiseClone does the trick.
Deep copies are a bit trickier. The usual approach in languages like C++, C#, and Java is for the class implementor to write a public Clone method which calls a protected copy constructor. The protected copy constructor recurses the copy operation on any reference or pointer fields in the class. This approach has two main problems. One of the problems has to do with copying graphs of objects. The problem (and an elegant solution) is described nicely here.
The other problem is it is often difficult for the class implementor to decide whether a referenced object should be copied (deep copy) or if that particular object should be shared between the old instance and the new (shallow copy). Sure, this object is being deep copied, but that doesn't mean that every referenced object should be copied as well. Imagine making a copy of a Satellite object where the satellite has a reference to two other objects: one representing its solar panels and the other representing the central body (or planet) that it is orbiting. When copying the satellite, you probably do want to copy its solar panels, but you don't want to copy Mars.
Worse, the choice of which sub-objects to copy and which to share sometimes depends on the intended use of the copy. In other words, the class implementor has no idea what to do. Only the caller of the Clone method knows just how deep the deep copy should be.
Dynamic Geometry Library (DGL) uses a novel (?) approach to object copying that solves both of the usual deep copying problems. I like to think of the pattern as 'copy ballast' because it allows the depth of a copy to be controlled by the user of the class rather than exclusively by its implementor. Even better, it does so without violating encapsulation.
Read on for more information about how this works.
We are pleased to announce the immediate availability of AGI Components 2008 r5!
This release includes a number of features that have been in development for awhile now, most notably the ability to perform Coverage computations. See the complete list of changes in this release.
This release unfortunately introduces some breaking changes for anyone that has implemented their own custom access constraints. Please contact support@agi.com for assistance updating your constraints to work with this release.
Hello Blogosphere! My name is Zac - this is my second summer interning for the DGL team here at AGI (and taking advantage of the awesome food). While I've come to really appreciate C# and the .Net APIs in my time working on DGL, I started out programming in Java. Lately I've been putting some work into getting DGL to work with Java. One of the easiest ways to do this turned out to be a product called JNBridge. It allows you to call .Net code from Java and vice-versa via automatically generated proxy classes. Feed it a .Net assembly and it'll churn out a .jar file with java classes and methods that have the same names as your .Net originals. Once you reference this .jar and the JNBridge runtime libraries in your Java project, you can instantiate, and call methods on, the proxy classes, as if they were the originals. JNBridge handles all the interop and marshaling for you, either via network sockets or shared memory in the same process.
My experience getting JNBridge up and running wasn't without hiccups - their documentation could have been a little more explicit and I uncovered a bug in their generated proxies - but, after a few support emails, they had a patch for me in under 24 hours (the fix is now included in the normal download on their site). The other gotcha I ran into was that JNBridge requires the Microsoft .Net implementation - no Mono - so shared memory interop is a Windows-only affair.
Now for some code! To try out JNBridge (and make something that would look cool) I made a demo application that leverages DGL's satellite propagating abilities and the Java SDK from NASA's WorldWind 3D globe. The app is a simple Swing JFrame with a 3D globe control and a text box for entering TLEs. Several TLEs can be entered and their ground tracks will be drawn on the globe. Check it out at the Code Exchange on the AGI Developer Network to see the source.
If you need interoperability between DGL (or anything else .Net) and Java code in a desktop application and you are only deploying on Windows, JNBridge provides a pretty painless solution that requires no extra coding on your part. It may also provide a good solution if you want to deploy a Java-based web application that leverages DGL (though I have yet to explore that). After the initial setup steps, you can pretend you're using native Java objects.
One of the great features coming soon in AGI Components is Coverage analysis. I am going to talk a bit here about what Coverage is, what you can do with it, and what sort of features will be coming in the components. Coverage is a term used by James Wertz and Wiley Larson in Space Mission Analysis and Design (or SMAD for short). Here is what SMAD has to say:
"Earth coverage refers to the part of the Earth that a spacecraft instrument or antenna can see at one instant or over an extended period. The coverage available for a particular location or region is frequently a key element in mission design." p 163
So essentially, Coverage is a means by which we can take a set of resources or "assets" and analyze their ability to observe (and possibly interact) with a set of locations (or objects) on the ground. Numerically, this usually entails representing a given area on the surface of the Earth (or other CentralBody) as a set of grid points. What this means is hundreds if not thousands of access calculations happening in parallel between each grid point and any number of time-dynamic 'assets'. The goal is to allow the user to conveniently assemble the problem and run the analysis without having to manually configure each access calculation. SMAD goes on to talk about the use of "Figures of Merit" (p173) which represent scalar fitness values based on statistical analysis of the results of the coverage computation. This allows the user to effectively analyze and design complex missions based on various fitness criteria.
The various libraries that compose AGI Components are great for analyzing the time-dynamic relationships in all sorts of aerospace and defense scenarios, but that's only half the story. Our company is called Analytical Graphics for a reason. We're all about high-precision analysis, but we're also all about letting you see your analysis results in an intuitive and precise manner using 3D graphics.
Sure, AGI Components works great for generating analysis results which can then be pumped out to any number of virtual globes like Google Earth, Microsoft Virtual Earth, or NASA World Wind. But we happen to think that our own virtual globe, available in STK and and 4DX, blows all of these away. This is particularly the case when you need to visualize things that.. well.. move.
On that note, I'm very excited to pass along word that AGI's Point Break team has just completed an Alpha release of the visualization component of the AGI Components family.
