We at GISi have been very happy with our client successes using GISi HealthCheck and GISi ArcGIS 4 Local Government (AG4LG)  jumpstart toolkit.  Most recently, the GISi & the City of Southfield, MI GIS group has been working diligently to implement Esri’s AG4LG information model into the City’s existing Enterprise GIS infrastructure.  The City has adopted the newly released common information model, core GIS tools, templates, and applications to help the City improve operations and communicate more effectively with the public while saving both time and money.

We are very excited that Southfield has joined our client, Effingham County, GA, to become one of the first communities in the country to truly embrace the new information model, applications and services being provided by GISi & Esri. The work GISi and the City have been doing in the AG4LG space has already generated a wealth of positive word of mouth throughout the region.

The City of Southfield GIS group has deployed the apps and maps gallery template: Destination Southfield and three applications; “GISi Silverlight Template Viewer”, “Polling Places”, “Parks & Rec Finder” and the City plans to have many more apps added in the coming months.

The GISi Silverlight Template Viewer application provides a wealth of geospatial information to its residential and business community, supporting public service delivery 24/7.  The City and GISi migrated its current WebADF application to the ArcGIS Server 10 platform using Microsoft Silverlight™ version 4.  Resources like the City’s Internet Mapping Portal reflect the type of investments Southfield is making to ensure a vibrant business climate exists.  This site helps promote the growth of existing business and attract new investments into the city while providing vital information to its citizens. Residents and nonresidents alike are able to view property ownership, zoning, voting districts, refuse and recycling information and many more commonly used data layers.

The Election Polling Places application helps citizens locate their election polling place and obtain information about current elected officials. This application is typically used by citizens during an election season, but can be used throughout the year to determine which elected official represents the precinct they reside in. To locate a polling place, simply click on the map or enter an address in the search box. The polling place and respective voting precinct will then be highlighted on the map and relevant information about the polling place and elected officials will be presented in two tabs at the bottom of the application. The application will also provide directions from the searched address to the associated polling place location.

The Park and Recreation Finder application helps residents locate a park and obtain information about recreation activities in their community. This application is typically used by residents in a community, but can be used by visitors to locate a park or recreation area near them, or one that offers the activity they are interested in. To locate a park, simply enter an address or activity in the search box. The park(s) or recreation area(s) will then be highlighted on the map and relevant information about available recreation activities are presented to the user.

The City now plans to release new applications on a consistent basis over the upcoming months. Sally Price feels the release of these applications will offer significant value to both City of Southfield staff as well as its citizens.  The City is using the GISi HealthCheck prescription to guide these future apps.

I would like to thank everyone at Esri who made this implementation possible through education and commitment to the success of our clients, to the GISi staff (Steve Gogola, Sean Savage & Christopher Fricke) and Sally Price sprice@cityofsouthfield.com.

GISi will soon be deploying AG4LG apps to ArcGIS online, visit: http://www.arcgis.com/home/item.html?id=881d4967817241db818795135a12ab09

For more information on the GIS HealthCheck, visit http://www.GISHealthCheck.com

For more information on AG4LG, visit: http://resources.arcgis.com/content/local-government/about

For a link to Destination Southfield, visit: http://maps.cityofsouthfield.com/destinationsouthfield/

For more information on the GISi Silverlight Template Viewer, contact sales@gisinc.com and try it live: http://maps.cityofsouthfield.com/GISViewer/

For more information on Elections Polling Place Template, visit: http://www.arcgis.com/home/item.html?id=14290c7441b34ea984ad9310f4cf6435 and try it live: http://maps.cityofsouthfield.com/Apps/Elections/PollingPlaces/

For more information on the Park and Recreation Finder Template, visit: http://www.arcgis.com/home/item.html?id=734512384d3b4b849aba2db0e33a80f2 and try it live: http://maps.cityofsouthfield.com/Apps/Recreation/ParkFinder/

In the beginning, there were scientists. Remember we are talking GIS, okay? The scientists were trying to figure out how do analyses with these cool computer things and apply that to maps and spatial questions. Those smart scientists started developing computer applications to help them do their day jobs. GIS was an applied science. One guy could do it all. The GIS guy.

Fast forward a few years and those GIS guys began migrating away from their scientific day jobs, because, well, GIS was just so cool! They began to see how GIS could be applied to a wide variety of problems, not only scientific, but economic, demographic and sociological avenues. It could be used as a real differentiator in understanding and solving business problems.

We started seeing the GIS guy get stretched thin on his ability to know it all, but most of them could still do it, and most of them still started somewhere else before they came to be the GIS professional.

Then, something happened. In conjunction with the rapid development in desktop computing power, application of GIS in scientific and demographic communities, the GIS guy became a specialist who actually went to school to become a GIS guy. We needed it to be that way, and so the paradigm of the GIS professional shifted. It is analogous to what happened in the broader computer science industry 2 decades earlier. The mathematicians and engineers who adopted computers and were the early programmers were replaced by the computer science graduates who specialized in all sorts of areas in the “computer science” industry.

The thing that fascinates me about the paradigm shift is how quickly it seemed to happen. Can we look to the broader computer science landscape and see what is possible with GIS? Are we already there? Have we simply been absorbed into computer science as a niche market or are we something altogether different? The old scientist in me says the latter, but I could be convinced otherwise.

ArcObjects is thread-safe, but some of ArcObject’s operations lock out concurrent processing to ensure thread safety.

I discovered this fact while working on an algorithm that performs several calls to ISurface::GetLineOfSight.  After profiling the algorithm, I discovered that the line of sight operation was the algorithm’s bottleneck.  To get more speed, I multi-threaded the algorithm.  The result was unexpected: The algorithm took twice as long to process and required twice as much processing power.

I came to the conclusion that I needed to write my own line of sight algorithm.

After a bit of research, I decided to use a Triangle-Ray Intersection technique (used by some ray tracing methods).  The method requires converting the surface to a collection of 3D triangles.  To determine the intersection point, search through the triangle collection for an intersection with the ray.

(Source: http://www.cs.cornell.edu/courses/cs465/2003fa/homeworks/raytri.pdf)

The reason to use triangles is that the math becomes much simpler (and faster).  In fact, there are no computationally complex (and slow) mathematical operations.  Take a look at the code:

Granted, the math is complex, but the math isn’t computationally complex.  The above method, “flattens” the surface and then determines the intersection of the triangle’s plane with the ray.  The PointInTriangle method then determines if the intersection point is inside the triangle.

The way the PointInTriangle method works is by checking which “side” of each of the triangle’s lines the point is on.  If the point is outside of the triangle, the point will be on the left side of 2 of the lines, and on the right of the other (1: Left, 2: Left, 3: Right).  If the point is inside of the triangle, the point will be on the same side of each line.

So far, my implemented version is 10x slower, but just as accurate as the ArcObjects line of sight operation (the trick is to use the same points to build the triangle collection).  But not to worry, there is plenty of room for improvement.

Currently, the triangles are stored in a 2D array.  A more efficient data structure will greatly improve performance.  Another positive note is that this implementation is thread-safe and doesn’t lock out concurrent processing.

This implementation can be modified for GPU processing.  Using a GPU technique, every triangle can be checked for intersection at the same time.

In conclusion, there is a lot of potential using GPUs to perform line of sight operations.  Transferring the surface’s data to the GPU is a relatively considerable investment (about 2-3 ms).  Luckily, when performing thousands of line of sight operations, the data transfer happens only once at the beginning.  Compared to ArcObjects running on a single thread, we can expect to see at least a 14 times speed up.  This means an algorithm that previously took an hour to run could potentially run in 4 minutes.

It took a bit of research to determine a good method of implementation.  Luckily there were several sources out there to read and use:

http://www.cs.cornell.edu/courses/cs465/2003fa/homeworks/raytri.pdf

http://en.wikipedia.org/wiki/Ray_tracing

http://en.wikipedia.org/wiki/Line-plane_intersection

http://www.codeproject.com/KB/graphics/Simple_Ray_Tracing_in_C_2.aspx

http://t-ray.googlecode.com/svn/trunk/ORayTracer/RayTracer/tTriangle.cs

Like Christopher mentioned, integration was certainly a buzz word tossed around a fair amount.  Demos given during the main session talks showed how a user could fairly easily push maps and data from ArcGIS Desktop to ArcGIS Server and ArcGIS online.  As Clint Brown, Director of Software Products at Esri, was casting vision for the future of ArcGIS, he liked to refer to ArcGIS as a system.  To paraphrase, “What is ArcGIS?  It is a system that enables people to work with your online maps and associated geographic info.”  It would seem that Esri’s heavy investment in cloud technology (in the form of ArcGIS Online) is the key to the advancement of this vision.

In line with this vision is the idea that maps are windows into our data.  Maps are way more than a way to find directions from A to B.  Thanks to Google, the general public is familiar with the idea of using a map to explore data from the world around them.  Esri wants to harness this general population spatial awareness.  Again, Clint Brown: “Everyone knows how to use a map.  The map is the window into everything else GIS related.  It is one of the most universally recognized ways to present information.”  He encouraged us to think of new ways to use the map as a window into our respective organization’s business data.

Like Christopher mentioned in his previous post, the Esri MUG was a very inspirational event.  In addition to the array of fine user presentations, I was particularly inspired by the recipient of the First MUG Community Service Award, Dr. Jay Morgan of Towson University.  This man has used his career to increase the public’s awareness of GIS and how it can be used to create a better world.  He inspired us to find ways to volunteer in the community and transfer our passion for GIS to the next generation.

If I could choose one buzz word to describe the future of GIS it would be Integration. With Esri’s upcoming 10.1 release and increasing push into cloud infrastructures, it is becoming easier to push data developed in ArcGIS Desktop to map services hosted by ArcGIS online, that feed applications hosted on a webserver to clients anywhere in the world.  It is a different concept than what I am used to.  I think Clint Brown said it best when he proclaimed ArcGIS Online the Flickr of GIS.

In addition to integrating a number of their software products, it sounds like Esri has invested a lot of time simplifying the everyday maintenance of their ArcGIS Server and ArcSDE products.  ArcGIS Server is getting a total make over, dropping support for DCOM connections and trimming down the number of installed users from three to one.  Also, I really like the incorporation of more Database Administration tools into ArcCatalog.  Hopefully gone are the days of cracking open SQL management studio to manage users.

I was left really inspired by this year’s MUG.  There were a bunch of presentations that showed the increasing role that GIS plays in disseminating information to typically non-GIS users.  The Flex Site the Baltimore City Fire Department set up for emergency responders working the Grand Prix showcased how GIS can be used to help dispatchers make decisions on the fly in a rapidly changing environment.   I also thought the model the National Capital Region Geospatial Data Exchange utilized to distribute data between local governments, private industry and non-profits was really innovative.  Silos of data are nice and all, but real information comes when multiple data is shared throughout the community.

Let’s try to demystify things a little.

Mobile Hardware and Software

There are two basic types of mobile hardware: smartphones and tablets. There are big variations in each category, one of the most critical is size. Size as it relates to portability, and more importantly screen. Smartphone screens vary from 2.1″ to just over 4″; in contrast tablets have a range of 7″ to 10.1″. Why is screen size so critical? Try interacting with an ArcGIS map on a 2.1″ screen!

Users can interact with mobile applications in one of two ways. They can use their Web browser to access a Web site, or they can download and install an application from one of the Mobile App stores. Most Web pages have been built for the PC. This means mouse interaction. Increasingly, Web sites are being optimized for mobile viewing and interaction. This means built for use on smaller screens, and allowing for finger interaction. This usually requires multiple Web sites; one for PC’s and one or more for mobiles. Now suppose your company has taken advantage of the excellent Flex Viewer for ArcGIS to give access to your spatial data. You share with your users the news of a new widget you have added, one perfect for use on mobiles. The deluge of angry iPhone and iPad users, complaining they cannot access the Web site, makes you regret your announcement. It’s an unfortunate reality that both Flash and Silverlight will not run on the browser of any Apple device.

Visiting Apple’s App store or Google’s Android Market, users can access an array of mobile apps. These are installed mobile apps; both free and fee based. A simple search on GIS or maps in an App Store produces a nice list of mobile apps. Let’s imagine you have a unique idea for a mobile application; one you’d like to push into one of these stores. Where do you begin? In the old days, we are talking here about months not years, you would first choose the platform to target for the app. That was usually Apples iOS, for running on the iPad or iPhone. Next hire an Objective C programmer. And build a so-called native mobile application. Once done, launch it into the Apple marketplace and watch it jump off the shelves, figuratively. Android from Google has seen increasing popularity. Suppose you wanted to take your app and push it into the Android market. Stop. Rewind. Hire a Java programmer. Have him rebuild the application. Push it to the Android Market. You get the idea; a single mobile app running on different platforms requires multiple rewrites. When you add in bug fixing and updates, this has the potential to be expensive.

Cross Platform Mobile Apps

In a perfect world we should be able to write an application once and run it across all mobile devices. Whether it be a Web or installed application respectively. Thanks to HTML5 and Adobe Air this is now possible. HTML5 is an augmentation of the current HTML 4.01 specification, which adds new features that designers and developers will be able to use. Important new additions include multimedia elements and dynamic graphics, allowing for improvements in data visualization, image manipulation, and video. In combination with Javascript, HTML5 presents some new and exciting possibilities for Web development. Apple iOS, Android, BlackBerry 6, and HP/Palm WebOS devices all support HTML5 features. HTML5 can be a compelling Web solution for multi-device and multi-screen applications.

Adobe AIR is a sister technology to Adobe Flex. AIR does not run in a browser like Flex; it is used to create an installed application, which has access to more local resources than are available to Flex. Mobile AIR is a new flavor of AIR, designed specifically for mobile devices. Adobe has made some important changes to their existing development tools. Now a project built in mobile Adobe AIR can be cross compiled to run on Apple iOS, Android and Blackberry. That is one code base for multiple platforms!

So now an application built in HTML5 will run on ALL mobile web browsers. An application built in mobile AIR, and distributed in the App stores, can be installed on all major mobile devices. That is huge. One more thing. If you build your HTML5 app for the mobile Web and at some time in the future decide you want this to be an installed app. Step forward PhoneGap; an open source tool to convert an HTML5 app to a cross platform installable app. So there is one code base for both Web and installed apps!

We live in exciting times. It could well be that we are seeing the end of the PC. Applications which are location-focused are a huge part of the new mobile revolution. The cross platform development tools, described in this article, available to designers and developers, will simplify the building of state of the art mobile solutions.

First you need to define the coordinates of the vector shape you want to create.

<fx:Declarations>

<fx:String id="arrowPath">

M 0 0

L 20 0

L 100 0

L 120 20

L 100 40

L 0 40

L 20 20

L 0 0

</fx:String>

</fx:Declarations>

Then, you’ll need to create a Graphic object. You can use a scale9Grid to fit the width of the label text without distortion.

<s:Graphic includeIn="up"

height="100%" width="100%"

scaleGridTop="1" scaleGridBottom="39"

scaleGridLeft="20" scaleGridRight="100">

<s:Path data="{arrowPath}">

<s:fill>

<s:LinearGradient id="gradientUp" rotation="90">

<s:GradientEntry color="0x4e77b3"/>

<s:GradientEntry color="0x345c98"/>

</s:LinearGradient>

</s:fill>

<s:stroke>

<s:LinearGradientStroke rotation="90">

<s:GradientEntry color="0x7399CF"/>

<s:GradientEntry color="0xd3d3d3"/>

<s:GradientEntry color="0x23467B"/>

</s:LinearGradientStroke>

</s:stroke>

</s:Path>

</s:Graphic>

You’re on a roll now, so you toss a few buttons into a button bar, back ‘em up so they saddle up next to each other, and you’ve got something like this:

Bada bing.  Bada boom.

The GIS HealthCheck SWAT team objective is much like a medical health check that includes diagnostics (tests), a lifestyle assessment, and prescriptions or recommendations for improvement.  The GIS HealthCheck has similar components: a technical diagnostic of the GIS, an assessment of the business utilization of the GIS, and finally a prescription, or suggestions for the future.

Most of our GIS HealthCheck clients have been able to obtain budget for a GIS project after a prescription has been presented.  We pride our GIS HealthCheck on its ability to make our clients more relevant within their organization and uncover hidden revenue that can be generated from their existing GIS investments.

For more information on the GIS HealthCheck, visit http://www.GISHealthCheck.com

The GISi HealthCheck SWAT team is looking forward to working with our clients.

1)      Simplified deployment

You may have already seen the now almost legendary demo where an Esri dev drags his Runtime project on to a thumb drive, walks it to another machine and fires it up without an install. It never fails to gets gasps from the crowd, and for good reason. How many times have you had to sheepishly tell your client “hmm, it works on my machine”? The ArcGIS Runtime eliminates complicated deployments by packaging everything required by the application into a (relatively) small deployment package. A simple tracking application I built with a pre-beta version of the runtime weighed in at about 175 megs. Since the Runtime is split into several “functionality sets”, you can keep your deployment lean by eliminating functionality your application doesn’t require. As a bonus, a Runtime application doesn’t care about other versions of ArcGIS you might have installed, and will happily run side-by-side with its progenitors.

2)      Performance

The ArcGIS Runtime has been architected to take advantage of available CPU resources, including multiple processors and cores. It provides true multithreading and native 32 and 64-bit support. It also supports an asynchronous programming pattern (made possible by its multithreaded architecture) that contributes to an improved user experience. The ArcGIS Runtime display architecture has also been optimized for speed.

3)     Connected and disconnected modes

Both local and Web data sources for the Runtime use the same programming model, which means it’s easy to build connected and disconnected modes into your application. Since your application’s data source can be based on map (or tile, locator, geoprocessing, etc.) packages, these data can be downloaded from ArcGIS.com on the initial load and then used locally thereafter. A common and effective approach is to use online data for your base map, while deploying a map package with your application to contain operational data. Editing can also be performed in a disconnected manner, using the geodatabase check-in/check-out replication model.

4)     Intuitive object model

While functionally more powerful than MapObjects, the ArcGIS Runtime SDK is considerably more coarse grained than ArcGIS Engine. In other words, it delivers all the functionality that most GIS applications need without an overly complex object model. Under the hood, the Runtime uses REST for communication with both Web and local data sources. Developers who are familiar with any of the ArcGIS Web APIs should find the Runtime API very intuitive to work with right out of the gate.

5)     Multi-platform support

The ArcGIS Runtime supports applications for 32-bit Windows, 64-bit Windows, and for 64-bit Linux. Windows applications can be built using the WPF, Java, or QT SDKs. Linux applications can be built using Java or QT.

While your applications still won’t be writing themselves anytime soon, the ArcGIS Runtime SDK should make GIS development a little more enjoyable. The time you may have had to spend smoothing out your deployment or pouring over a couple dozen object model diagrams can now be spent doing something fun (or at least productive), like fine-tuning your cartography or making tweaks to your application’s UI.

• Previous flash players supported 4-8 thousand polygons
• Molehill has been stress-testing supporting millions of polygons

Talk about holy poly-count Batman!

But diving into the guts of the API isn’t for the faint hearted.  Coming from the development world, we’re all familiar with the ‘Hello World’ examples… so how about a ‘Hello Triangle’ example?  The following code snippet was authored by Ryan Speets.  This is an incomplete example of a simple triangle and square on the screen.

public function myContext3DHandler ( event : Event ) : void {

var stage3D:Stage3D;

var vertexShaderAssembler:AGALMiniAssembler;

var fragmentShaderAssembler:AGALMiniAssembler;

stage3D = event.target as Stage3D;

context = stage3D.context3D;

context.configureBackBuffer(640, 480, 4, true);

// Set up triangle's buffers

trianglevertexbuffer = context.createVertexBuffer(3, 6);

trianglevertexbuffer.uploadFromVector ( Vector.<Number>([

0, 1, 0,  1,0,0,

-1,-1, 0,  0,1,0,

1,-1, 0,  0,0,1

]),0, 3 );

triangleindexbuffer = context.createIndexBuffer(3);

triangleindexbuffer.uploadFromVector(Vector.<uint>([0, 1, 2]), 0, 3);

// Set up square's buffers

squarevertexbuffer = context.createVertexBuffer(4, 6);

squarevertexbuffer.uploadFromVector ( Vector.<Number>([

-1, 1, 0,  0.5,0.5,1.0,

1, 1, 0,  0.5,0.5,1.0,

1,-1, 0,  0.5,0.5,1.0,

-1,-1, 0,  0.5,0.5,1.0

]),0, 4 );

squareindexbuffer = context.createIndexBuffer(6);

squareindexbuffer.uploadFromVector(Vector.<uint>([0, 1, 2, 0, 2, 3]), 0, 6);

// Assemble shaders

vertexShaderAssembler = new AGALMiniAssembler();

vertexShaderAssembler.assemble( Context3DProgramType.VERTEX,

"m44 vt0, va0, vc0 \n" +

"m44 op, vt0, vc4 \n" +

"mov v0, va1"

);

fragmentShaderAssembler = new AGALMiniAssembler();

fragmentShaderAssembler.assemble( Context3DProgramType.FRAGMENT,

"mov oc, v0\n"

);

// Upload and set active the shaders

program = context.createProgram();

program.upload(vertexShaderAssembler.agalcode, fragmentShaderAssembler.agalcode);

context.setProgram(program);

this.addEventListener(Event.ENTER_FRAME, enterFrame)

}

Whatever happened to var triangle:Triangle = new Triangle()?  As mentioned earlier, Molehill is a low-level API (and they mean really low).  Fortunately there are a number of robust frameworks freely available that are compatible with Molehill and abstract much of the complexity of the Stage3D away from us so we can focus on doing “funner” stuff.  What are some of these frameworks?

• Proscenium (Written by Adobe)
• Flare3D (http://www.flare3d.com/)
• Alternativa3D (http://alternativaplatform.com/en/alternativa3d/)
• Sophie3D (http://www.sophie3d.com/website/index_en.php)
• Yogurt3D (http://www.yogurt3d.com/)
• Frima (http://frimastudio.com/)
• Away3D (http://away3d.com/)
• Coppercube (http://www.ambiera.com/coppercube/)
• The list goes on and on…

For the following demonstrations, I leveraged Away3D.  Away3D is an open-sourced framework created by the same folks who put together (the now dead?) Papervision.  Away3D features a great developer community, significant samples, responsive contributors, and open-source accessibility.  Seemed like a good choice.  Alternativa3D was a close second and was the shop responsible for putting together the MAX3D racer demo available from Adobe’s website (http://alternativaplatform.com/en/demos/maxracer/).

But we’re a GIS Technology company and so we started asking ourselves how these new advances in web-based 3D visualization can help the geospatial community.  Really, the possibilities are endless, but here are some of the low hanging fruit:

• Terrain visualization
• Flight simulation
• 3D based COP
• Utility/Pipelines
• Physics simulations
• Development pre-visualization
• Resource geolocation/tracking
• Etc.

The demonstrations range from simple primitive test, elevation and ESRI basemaps, to global geolocation and AVL tracking.

Caption:  Who would have thought that simple polygons would get me so excited?

Once the polygons were in place I thought it might be beneficial if we could interact with the 3D objects.  A simple property change (mouseEnabled = true) and an extra EventListener and voila, we now have interactive 3D objects.

Caption:  Imagine, if you will, something cool!

Then I asked myself what would a 3D scene be without a little mood lighting and textures?  Away3D supports a number of light and material options including DirectionalLight, Point Light, BitmapMaterial, ColorMaterial, VideoMaterial, etc.  Notice the Poly count listed on the statistics in the upper left corner… 19802 polygons.  That sphere has waaay too many divisions, but take my word for it, manipulating the 3D scene is a smooth as butter.

Caption:  Adding a little mood makes everything seem more dramatic.

Next up was the manipulation of 3D objects using embedded audio assets.  We’re all familiar with audio equalizers, but what about representing audio frequencies in real-time 3D?  The flash.media.SoundMixer class offers useful utilities for introspecting audio playback and tying it to 3D objects makes an interesting demonstration.  Not much to see by way of screenshot, but visualize each bar bumping up and down to the rhythm.

Caption:  3D equalizer gives a new meaning to audio visualizations

At this point I was ready to begin delving into more geospatial experimentation.  What’s the first thing that many of us GIS professionals think of when we think of 3D… TINS, DEMS, elevation.  Right?  Unfortunately, the following demonstrations don’t represent true elevevations (rather pixel values are converted into relative extrusion heights), but from a visualization perspective the results are impressive (if not accurate).  Notice the POLY count on this screenshot… 80,000 polygons without a single hiccup in framerate as I spin the map.

Caption:  Pixel colors are converted into relative heights to create the 3D extrusion.

Caption:  A closer look

As developers, we’re always looking for ways to create value for our stakeholders.  Those familiar with the ESRI development APIs are probably familiar with the ESRI basemaps and the manipulation of graphics via GraphicLayers… now if only this could be extruded into 3D…

Caption:  Starting sample application.  User may begin sketching their waypoints.

Caption:  Ready for 3D visualization

Caption:  Elevation and basemap data mashed together to create 3D flight simulation.  Red box could easily be swapped out for camera.

In the above concepts, I use three different map services published with ESRI’s ArcGIS server.  The first map service uses the ESRI street basemap as simple reference while sketching the waypoints.  Once the waypoints are drawn, the application analyzes the extent of the points and exports images from a map service rendering DEM data, as well as ESRI’s topographic basemap.  These are mashed together to create the final scene.  The red box represents an object that could just as well have been a camera to create a “pilots perspective” flight simulation.  Again, the terrain is only a simulation/visualization, and should not be considered representative as true elevation.

Now that I had location on a local level, I started thinking international/global.  Can I use the concepts learned while generating local 3D scenes on a much larger scope?  You bet!  These examples not only demonstrate the ability to load data from external web services dynamically into a 3D scene, but also mapping geographic coordinates to pixel coordinates.  We can also attach event listeners to the markers to provide click or tooltip information.

Caption:  There’s something about don’t click me buttons that drives people crazy

Caption:  Data loaded and converted to pixel-space from external web-service, with tooltip interactivity

The mapping of lat/lon data in real-time 3D reminded me of AVL situations on COP applications.  What if you were managing a wildfire in rough terrain and wanted to visualize on-the-ground resources in context of the terrain?  In the next experiment, I created a simulated web-service that the 3D scene can poll every XX seconds to update the locations of resources on the ground.  The blue resources move over time as their coordinates are updated via a web-service call.  All the while I’m zooming in and out of canyons, panning around, etc within the 3D scene.   How about real-time FAA flight visualizations?

Caption:  Select area to analyze

Caption:  See on the ground resource locations in near realtime (simulated from web-service).

Finally, (and just for the fun of it) I wanted to start testing 3D physics.  Adobe has another great project underway that allows users to compile raw C and C++ code into SWF or SWC files that can be embedded in your applications (codename “Alchemy”).  Someone in the community was kind enough to compile the Bullet physics engine (http://bulletphysics.org) into a consumable SWC file used in the following demonstration.  Not much use for it yet, but it certainly opens the door of possibilities.

Caption:  Shooting balls at a wall of cubes could be packaged into a game

Caption:  Resulting chaos

Hopefully we can post a demo video up soon, but in the meantime enjoy the provided screenshots/discussion to get you thinking about adding 50% more D to your world.