Here's a few screen shots:

Point in Polygon Test:

Drawing Shapes on the Globe:

You can check out a few of our videos presented at the Dailies on YouTube:

The Fate of the Apollo 13 Crew
Might Have Been Much Different Than Originally Thought

US Airways Flight 1549:
Hudson River Crash Animation With Flight Data

Satellite Collision Visualization:
Technically Accurate Depictions of Debris Breakup and Evolution

Also, I updated the page on our poster, GPU Ray Casting of Virtual Globes, to include the actual poster (2200x2200) in addition to the abstract, video, etc.

• SIGGRAPH Dailies! - Kel Elkins and Branden Coker, members of our production team, are presenting some great AGI videos:
  • The Fate of the Apollo 13 Crew Might Have Been Much Different Than Originally Thought
  • US Airways Flight 1549: Hudson River Crash Animation With Flight Data
  • Satellite Collision Visualization: Technically Accurate Depictions of Debris Breakup and Evolution
  • MADCAT: Graphical All-on-all Conjunction Assessment for Objects in Outer Space

  SIGGRAPH Dallies! is new to SIGGRAPH this year. It is an hour and a half of 60-90 second videos with live commentary from the presenter - a format similar to the popular Technical Papers Fast Forward session. If my numbers are correct, AGI is presenting 4 of the 38 videos, second to only Pixar and Disney, and tied with Texas A&M University. I'm happy to see that the SIGGRAPH community is so interested in our videos.

• Birds of a Feather - Deron is giving a talk on Insight3D at the Computer Graphics for Simulation BOF. If you're interested in how AGI products can be used in simulations, don't miss it!
• Posters - I am presenting our poster: GPU Ray Casting of Virtual Globes. This is a next generation rendering technique for ellipsoids - check it out if you like the details behind 3D rendering.

I'm sure the burning question in your mind is when and where is all this good stuff? After all, you need to put together your conference schedule well ahead of time (you should see mine - I am double booked, sometimes even triple booked, the entire time. There is that much to see).

• SIGGRAPH Dallies! - Tuesday and Wednesday, 6 - 7:30 pm. Room 408 AB
• Computer Graphics for Simulation BOF - Wednesday, 2:30-3:30 pm. Room 301 A
• Posters - Tuesday and Wednesday, 12:15-1:15 pm. West Lobby (our poster will be at location 80B)

My suggestion is to make Wednesday "AGI day" and check out all three in one day! See you at SIGGRAPH.

Deron and I realized that not much has been written about this type of 3D engine, at least not all in the same place, so we decided to start writing a book on the topic: Virtual Globe and Terrain Rendering. This isn't a book on Insight3D or STK specifically but rather a best practices guide for designing and implementing 3D engines for virtual globes, GIS, simulations, etc - all things we've learned by working on Insight3D and STK. If you're interested in this kind of stuff, check out the book's blog as we continue to work on the manuscript and example code.

I should mention that our book is not directly affiliated with AGI. Although, since AGI is such an awesome employer, they are very encouraging about our book project and allowed us to mention it on this blog.

Download r4 from ADN.

This was a collaborative effort between the aerospace guys on the DGL team and our 3D team.  We hope these types of next generation rendering algorithms make their way into Insight3D.

Short Abstract: Our work presents a GPU ray casting approach to rendering the ellipsoidal surface of virtual globes that provides an infinite level of geometric detail at frame rates competitive with traditional tessellation and rasterization approaches. This work has application in areas including globe rendering for geographic information systems and video games.

Downloads

• One Page Abstract (preprint)
• Three Page Supplement
• Poster (2200x2200)
• Five minute video
• Source Code - Compiles with Visual C# 2008.  Requires OpenGL 3.2 drivers to run.
• ACM Portal page

A shaded, ray casted globe correctly interacting with rasterized billboards.  Upper Right: Viewport-aligned ellipsoid bounding polygon.  Ray hits are cyan and misses are gray.  Raster data from Natural Earth and icons from Yusuke Kamiyamane.

Not only is this entirely possible with C++/CLI, but Insight3D is capable of being easily integrated into many common user interface frameworks in that environment, including MFC, Windows Forms, and Qt.

As an example, I've posted a simple C++/CLI example using Insight3D and AGI Components in the context of a Windows Forms application to help you get started.

You should note that the above example references assemblies in the default install location for AGI Components for .NET 2010 r2. You may need to update the references in the project to point to your particular install location. From the project properties, navigate to Common Properties->Framework and References, remove the references to AGI.Foundation.*, then add references to the same assemblies from your particular AGI Components installation. Similarly, if you get an error in relation to licenses, you may have to remove licenses.licx from the project and add the licenses.licx file from the Assemblies directory in your AGI Components installation.

After the webinar, you can follow this tutorial on getting started building an Insight3D web application and download the sample code here.

Update: The recorded webinar and materials are now available on AGI's website.

A new overview, available in our online help, explains how to use the solid primitive, including using visual cues such as the white silhouette edge and removal of back facing lines shown above.  The polyline and point batch primitive now have an optional outline with a unique size, color, and translucency.  This small feature adds a nice visual cue:

Download AGI Components 2010 r1 from ADN and give these new features a try.

All surface images in Insight3D are placed on the Earth where the edges of the image align with latitudinal and longitudinal lines and the top edge is north.  Several customers have asked if they could map an image where that is not the case, where they have the latitude and longitude coordinates of each corner.

Fig. 1 shows an image captured from the viewpoint of a simulated UAV camera.  While the image itself is exactly as it was, the image is not correctly positioned on the terrain.  As mentioned, the image edges align with latitudinal and longitudinal lines. 

Fig. 1

In fig. 2, the image’s corners have been mapped from their original coordinates to their actual coordinates. One can tell that the camera took this image from the southwest.

Fig. 2

This capability has been added to Insight3D’s  Surface Mesh Primitive for our upcoming r8 release.  I’ll wait until r8 is out to discuss the new interfaces and how this method differs from projecting an image onto the terrain.

In this post, I’ll discuss how we use OpenGL to remap the image of fig. 1 to that of fig. 2.

Perspective Texture Projection

The goal is to remap the texture coordinates from one trapezoid to another.  Let’s begin with an example.  Fig 3a shows an image, a blue square with a red border, mapped to a square, while the other figures show a remapping of that square to a trapezoid with an outline of the original square shown as reference.

a. Original                      b. Orthographic                   c. Perspective

Fig. 3

One obvious way to map to the trapezoid would be to just move the vertices.  In fig 3b, the vertex positions have been moved while the texture coordinates remain that same as in fig 3a.  This results in an orthographic projection where the texture coordinates are linearly interpolated across the trapezoid.  Given that we want a perspective projection, this is incorrect.

In fig 3c, the vertex positions have been moved, and the texture coordinates have been altered.  This trapezoid appears to be a rectangle closer to the viewer on the left side and farther away on the right; however,  the trapezoid is actually in a plane perpendicular to the viewer, i.e. flat to your display.  A perspective transform has been applied to the texture coordinates.  This is how the UAV image should be placed onto the terrain.  How is this transform computed?

The Texture Matrix

A texture coordinate is defined by the vector (s, t, r,  q).  Most graphics developers are familiar with using s and t to map a 2D texture to a triangle; in this case, r and q default to 0 and 1 respectively.  The value r is used for 3D textures and so is ignored here.  I’ll get to q in a moment.

In the OpenGL fixed function pipeline, each texture coordinate (s, t, r,  q) is multiplied by a 4x4 texture matrix as shown in eq. 1.

Eq. 1

Since OpenGL interprets (s’, t’, r’, q’) as a homogeneous coordinate, s’, t’,  and r’ are next divided by q’ as shown in eqs. 2, 3 and 4.  This is the perspective divide, and is necessary to produce fig 3c.

Eqs. 2, 3, 4

Coordinate (s’’, t’’, r’’) is used to sample the texture.  For a 2D texture, only s’’ and t’’ are used.

Computing the Texture Matrix

Remapping requires a texture matrix that maps (s, t) in fig 3c to (s’’, t’’) in fig. 3a.

Since only a 2D texture is being considered, the 3D components of the matrix and vectors are zeroed out; m₄₄ is set to 1 as this is a homogenous matrix; m₃₃ is inconsequential as that value is multiplied by 0 in the matrix multiplication.

Eq. 5

After multiplication,

Eqs. 6, 7 , 8

After multiplying both sides of eqs. 2 and 3 by q’, and then plugging in eqs. 6, 7, and 8,

Eqs. 9, 10

Eqs. 9 and 10 are rearranged to form two linear equations.

Eqs. 11, 12

There are eight unknown matrix components to solve.   The mapping for the corners to go from figs. 3c to 3a are:

Fig 4.

This yields eight equations with eight unknowns. Using a linear equation solver, the texture matrix can be computed.

Applying the Texture Matrix

If you are using the OpenGL fixed function pipeline, after loading this matrix to the OpenGL matrix stack, there are two basic ways to render the texture and geometry.

You can move the vertex positions and use the (s, t) texture coordinates.

Alternatively, you could keep the original vertex positions and (s’’, t’’) texture coordinates.  You will have to specify a border color for the texture.

float borderColor[4] = {126.0f, 126.0f, 126.0f, 0.0f};
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

When rendering, you must enable the alpha test.

glAlphaFunc(GL_GREATER, 0.0f);
glEnable(GL_ALPHA_TEST);

If you do not, the texture will bleed beyond its border as shown in fig. 5.

Fig. 5

Of course if you are using shaders instead of the fixed function pipeline, you can still easily do either way.  There are various other combinations that will work too.

Our unique method for rendering the surface mesh primitive requires that we use the second method.

Footnoticed

Benjamin Supnik’s blog posts on this topic here and here were very helpful.  He explains much of what I have and more.  Hopefully though, I have added to understanding this topic.