New FalconView Web Site

In preperation for the upcoming FalconView open source release, Georgia Tech has launched a new web site for the FalconView project.  The new web site pulls together the main web site at falconview.org, as well as the developer wiki.  Check it out here.

Installing FalconView Client Editors

As discussed in the FalconView SDK, in order to install FalconView client editors, it is necessary to add an entry to the client editors registry key (under "HKLM\Software\PFPS\FalconView\Client Editors").  The trick with installing a client editor key is that the installer must determine which client editor number to use for the key.  I recently wrote a new FalconView overlay in C# .NET and thought I'd share some steps that other developers may find useful for installing FalconView overlays.  (I'm working in Visual Studio 2005, so the steps below are for that version.  These steps are somewhat broad as I assume that the developer is experienced enough to fill in some of the details.  I also assume that the overlay is being written in .NET as this example uses all .NET classes and assemblies.)

1.  Create a new Setup Project Using Visual Studio and Add Your Binaries to the Setup

I'll leave most of this work to the reader as this post is not meant to address this part of the setup.  Suffice it to say that you add your project outputs to a new setup project in a conventional fashion so that they get installed to the desired location on the user's PC.

2.  Add an Installer Class to Your Output Assembly

An installer class derives from System.Configuration.Install.Installer.  Installer classes have a number of methods that you can override in order to execute steps at certain points during an install.

3.  Add Code to Your Installer Class to Register Your Assembly for COM

FalconView uses COM to communicate with all its client editors.  This function is a short sample that shows how you can add a method to your installer class that will register your assembly for COM so that FalconView can find your overlay class.

private void RegisterAssembly(string assemblyFile)

{

  Assembly assembly = Assembly.LoadFrom(assemblyFile);

  new RegistrationServices().RegisterAssembly(assembly,

     AssemblyRegistrationFlags.SetCodeBase);

}

4. Add Code to Your Installer Class to Set the Client Editor Key

Here's the meat of this post.  The following method sets the client editor key so that your overlay becomes visible to FalconView.

private void InstallClientEditorKey(

   string classIdString, int interfaceVersion, bool isStaticOverlay)

{

   // get the FalconView client editors key

   RegistryKey clientEditorsKey = 

      Registry.LocalMachine.OpenSubKey(

      @"SOFTWARE\PFPS\FalconView\Client Editors", true);

   // create a list of taken client editor numbers

   List listTakenNumbers = new List();

   string[] subKeys = clientEditorsKey.GetSubKeyNames();

   foreach (string subKeyName in subKeys)

   {

      try

      {

         listTakenNumbers.Add(Int32.Parse(subKeyName));

      }

      catch (Exception) { } // probably just a key that isn't an integer

   }

   // find the first available client editor number

   int iFirstAvailable = 0;

   while (listTakenNumbers.Contains(iFirstAvailable))

      iFirstAvailable++;

   // create the client editor key

   RegistryKey overlayKey = 

      clientEditorsKey.CreateSubKey(iFirstAvailable.ToString());

   // create the values

   overlayKey.SetValue("classIdString", classIdString,

      RegistryValueKind.String);

   overlayKey.SetValue("interfaceVersion", interfaceVersion,

      RegistryValueKind.DWord);

   overlayKey.SetValue("isStaticOverlay",

      isStaticOverlay ? 1 : 0, RegistryValueKind.DWord);

   // clean up

   overlayKey.Close();

   clientEditorsKey.Close();

}

5. Call Your Methods From an Overridden Method in Your Installer Class

I choose to override the Install method on the installer class.  (For more documentiontation on Installer classes, consult MSDN.)

public override void Install(IDictionary stateSaver)

{

   try

   {

      base.Install(stateSaver);

      // register the assembly for COM

      RegisterAssembly(Context.Parameters["assemblypath"]);

      // install the FalconView client editor key

      InstallClientEditorKey("Server.Overlay", 3, true);

   }

   catch (Exception ex)

   {

      MessageBox.Show(ex.Message,

         "Install Failed", MessageBoxButtons.OK,

         MessageBoxIcon.Error);

   }

}

Note the use of Context.Parameters above.  This dictionary is how all of the install parameters are passed into an Installer class by the installer.

6. Add the Custom Action to Your Setup Project

When you add the custom action, you will need to specify the entry point for the action.

This screen capture shows where to set the EntryPoint property on the custom action.  When your install reaches the custom action, it will call into your Installer class and execute the actions there.

You could add additional logic to your install, such as checking to make sure the overlay isn't already installed and adding uninstall steps, but I'll leave that as an exercise for the reader.

Compiling libkml on Windows

Just a quick hint here for anyone searching for information on compiling libkml under Visual Studio. Version 0.4, which I just downloaded, won't compile the libkmlbase project unless you make a small modification to time_util.cc. Just change the order of the includes so that the winsock2.h include comes before the windows.h include. If you don't, you will get compiler errors such as, "error C2011: 'fd_set' : 'struct' type redefinition."

[[ UPDATE: Apparently there are other problems with using libkml in Windows. I just came across a linker issue where the symbol IsIconParent was undefined. To solve this problem, I had to add get_link_parents.cc and get_link_parents.h to the libkmlengine project and recompile. ]]

[[ UPDATE 5 Nov. 08: Both of these issues have been corrected as of version 0.5. ]]

FalconView Open Source

Beginning with FalconView 4.3, FalconView will become an open source product.  Georgia Tech will distribute the code to FalconView to the general public, and installable binaries will be available.  The open source effort will include the main FalconView application and most of the overlays that come packaged with FalconView.

In order to accomplish this effort, we are reworking major parts of the FalconView architucture.  Historically, FalconView has included a standard set of overlays that built-in to the executible software and a set of "plug-in" overlays that may or may not be installed with FalconView.  Because some of the overlays are export-sensitive, all of the overlays for FalconView 4.3 will be pulled out and made into plug-in overlays.  This architecture will allow us to distribute a version of FalconView for the general public and a version of FalconView for the government.  The versions will be identical, except that the government version will include the threat overlay, the tactical graphics overlay, and some other components not available to the general public.

The FalconView team is excited about this effort.  We feel a great sense of ownership in our work and will be very glad to make the product available to a wider user base.  I'd expect that public betas of FalconView 4.3 will start hitting the internet sometime in the first half of 2009.  Stay tuned as for more news as events unfold.  Feel free to contact me for more details.

Geoprocessing in FalconView Using ArcGIS

I recently presented this paper at the 2008 ESRI User's Conference in San Diego. It's about much of what I've discussed on this blog recently, with some added technical details. Here are the slides from the presentation, in case you missed it.

[[ Note that the slides were originally generated in PowerPoint. I've uploaded them to Google for publication on the web. Some of the formating is a bit off, but they should get the point across. ]]

FalconView / ArcGIS 9.3 Compatibility Testing

I've just finished testing the FalconView GIS Overlay with ArcGIS 9.3 and I'm pleased to say that the testing went off without so much as a bump.

When we moved from ArcGIS 9.1 to 9.2, I found several incompatibilities in the FalconView 4.1 GIS Overlay that prevented FalconView 4.1 from working with ArcGIS 9.2. ESRI had changed the behavior of some of their objects so that we had to rewrite parts of our software to make it work with their new version. In my opinion, this loss of backwards compatibility moving between minor versions was a failure on the part of ESRI software engineering. This time, though, they seem to have gotten everything exactly right. Way to go, ESRI.

I'm very pleased that Georgia Tech will be releasing a version of FalconView 4.1 that is compatible with ArcGIS 9.1, 9.2 and 9.3. FalconView 4.2 will include compatibility with ArcGIS 9.2 and 9.3. For more information on these FalconView enhancements, e-mail me directly.

Using FalconView Geoprocessing to Find Communications Sites

This upcoming weekend is a special weekend for the amateur radio community. Field day (which would better be called Field Days) is a time when ham radio operators go outdoors to set up temporary communications stations to practice emergency communications preparedness and to have a fun educational and relational experience doing it.

I'm going to dust off my radio license (W4LL) this field day and hit the air with a friend in Colorado. We talked about several possible sites around the Boulder area where we could set up. One near the top of our list was Rocky Mountain National Park. Since there is a plethora of GIS data available for national parks, I decided to load some into FalconView and see if I could use it to help pick a site for us.

Here are some of the things we wanted in a site:

1. Within the park.
2. At a moderate altitude (not too high, not in a valley).
3. Near a road so we wouldn't have to hike too far with our gear.
4. On an area with level slope.
5. An area with a good view of the sky (for radio propagation).
6. Near a river or stream, if possible.

I loaded Colorado terrain data, RMNP road, stream, trail and border data and went to work. The simple way to do this kind of analysis is to make a group of raster data sets and score them based on a weighting of the criteria above. Adding all the scores together gives you an overall raster that scores the various terrains.

I won't go into too much detail here, but the ArcGIS analysis tools integrated into FalconView performed well for the task. The reclassify tool was used to score the terrain raster for altitude, the slope tool was used to get slopes from the terrain raster, the Euclidean distance tool was used for road and stream proximity data. Once some camp sites were picked out, the view shed tool was used to determine the sky visibility from the raster.

The first picture below shows some of the outputs from the aforementioned tools drawn in FalconView. The colors are so ugly because they represent a mosaic of different outputs which a human must interpret through careful visual analysis. (Honestly, without the table of contents, which shows up on the GIS Editor, the colors aren't very meaningful.)

The next picture shows just a camp site of interest, view shed, and terrain data, all drawn in the FalconView ArcGIS Editor.