Implementing custom globe layers with dynamic feed

In this topic

• About implementing globe layers
• Drawing simple 3D graphics
  • Manipulating feature layers
  • Drawing 3D objects using GlobeGraphicsLayer
  • Using GlobeGraphics API for custom drawings
• Advanced drawing
  • Implementation methods
  • Drawing from tools and commands
• Implementing custom globe layers
  • Issues for implementing a globe custom layer
• Preparing applications to draw 3D graphics on a globe
• Broadcasting activities through IGlobeDisplayEvents
• Communicating with the GlobeDisplay
• Implementing a 3D custom layer
  • Setup for drawing OpenGL
  • Loading 3D models from file
  • Creating display lists from 3D symbols
  • Coordinate systems for drawing 3D graphics
  • Globe coordinate system
  • Local object’s coordinate system
  • Coordinate transformation
  • Aligning the object's up direction
• Drawing sequence
  • Optimizing the drawing sequence
  • Minimizing the computation load inside DrawImmediate
  • Scaling and aggregating symbols
  • Screening out objects outside the display viewport
  • Using a single timer to redraw the display
• Managing dynamic objects
• Connecting to real-time feeds
• Serializing the custom layer
• Labeling objects
  • Creating fonts for fast 3D display
  • Creating billboard text
  • Implementing a HitTest method
• Identifying objects
  • Selecting objects
  • Flashing objects in the globe display
  • Implementing prediction mode

About implementing globe layers

Drawing simple 3D graphics

Manipulating feature layers

Drawing 3D objects using GlobeGraphicsLayer

Using GlobeGraphics API for custom drawings

• The following code example shows how to create a graphic layer and add it to the globe:

//Declaration of a graphic layer.
private IGlobeGraphicsLayer m_globeGraphicsLayer=null;

//Create the graphic layer.
m_globeGraphicsLayer=new GlobeGraphicsLayerClass();
((ILayer)m_globeGraphicsLayer).Name="DynamicObjects";

IScene scene=(IScene)m_globeDisplay.Globe;

//Add the new graphic layer to the globe.
scene.AddLayer((ILayer)m_globeGraphicsLayer, false);

//Activate the graphic layer.
scene.ActiveGraphicsLayer=(ILayer)m_globeGraphicsLayer;

• The following code example shows how to create a graphic element and add it to the graphic layer:

//Create the element's geometry.
IPoint point=new PointClass();
(IZAware(point)).ZAware=true;
point.PutCoords(position.longitude, position.latitude);
point.Z=position.altitude;

//Create the element's color (red).
IRgbColor color=new RgbColorClass();
color.Red=255;
color.Green=0;
color.Blue=0;

//Create the element's symbol.
IMarkerSymbol markerSymbol=new SimpleMarker3DSymbolClass();
//Set the marker symbol's style and resolution.
((ISimpleMarker3DSymbol)markerSymbol).Style =
    esriSimple3DMarkerStyle.esriS3DMSSphere;
((ISimpleMarker3DSymbol)markerSymbol).ResolutionQuality=1.0;
markerSymbol.Size=700;
markerSymbol.Color=color as IColor;

//Create the new marker symbol's element.
IElement trackElement=new MarkerElementClass();

//Set the element's symbol and geometry (location and shape).
((IMarkerElement)trackElement).Symbol=markerSymbol;
trackElement.Geometry=point as IPoint;

//Add the element to the graphic layer.
((IGraphicsContainer)globeGraphicsLayer).AddElement(trackElement, 0);

• The following code example shows how to update a graphic element inside a graphic layer:

//Get the element by its index.
IElement elem=((IGraphicsContainer3D)m_globeGraphicsLayer).get_Element
    (m_trackObjectIndex);

//Get the geometry of the element.
IPoint point=elem.Geometry as IPoint;

//Update the element's position.
point.PutCorrds(position.longitude, position.latitude);
point.Z=position.altitude;
elem.Geometry=(IGeometry)point;

//Update the element in the graphic layer.
m_globeGraphicsLayer.UpdateElementByIndex(m_trackObjectIndex)

Advanced drawing

Implementation methods

• Drawing within the content of a command item
• Custom drawing as part of a custom layer implementation

Drawing from tools and commands

Implementing custom globe layers

• Rasterized (esriGlobeCustomDrawRasterize)—Layer type rasterized by the layer's Draw method and usually serves custom raster layers.
• Rasterized by tile (esriGlobeCustomDrawByTile)—Layer for the custom data that is rasterized and rendered directly into the tile. Globe calls the GetTile() method to obtain the rasterized data for displaying on the globe's display.
• Custom OpenGL layer (esriGlobeCustomDrawOpenGL)—Layer type draws 3D objects using the direct OpenGL plug-in. This is the layer type discussed in this topic and is suitable for custom graphics drawing.

Issues for implementing a globe custom layer

• Type of input feed and database for the layer.
• Amount of objects managed by the layer.
• Geographic distribution of the data. Are the objects distributed homogeneously?
• Is the extent of the layer large or limited to a local area?
• What is the rate at which objects get added, updated, and deleted from the layer?
• What type of geometry is used by the layer?
• What functionality does your layer have to support (dynamic selection, editing capabilities, and so on)?

Preparing applications to draw 3D graphics on a globe

Broadcasting activities through IGlobeDisplayEvents

• The following code example shows how the AfterDraw event is wired:

//Start listening to globe display events.
((IGlobeDisplayEvents_Event)m_globeDisplay).AfterDraw += new
    IGlobeDisplayEvents_AfterDrawEventHandler(OnAfterDraw);

• The following code example shows how to draw mouse feedback in IglobeDisplayEvents.AfterDraw:

private void OnAfterDraw(ISceneViewer pViewer)
{
    //Test whether in drawing mode. 
    if (false == m_bDrawPoint)
        return ;

    //Convert the mouse coordinate into a geocentric (OpenGL) coordinate system.
    double glX, glY, glZ;
    m_globeViewUtil.WindowToGeocentric(m_globeDisplay, m_sceneViewer, m_srcX, m_srcY,
        true, out glX, out glY, out glZ);

    //Draw the converted point on the surface of the globe.
    GL.glPointSize(15.0f);
    GL.glColor3ub(255, 0, 0);
    GL.glBegin(GL.GL_POINTS);
    GL.glVertex3f((float)glX, (float)glY, (float)glZ);
    GL.glEnd();

Communicating with the GlobeDisplay

Implementing a 3D custom layer

• The following code example shows wiring AfterDraw inside the ICommand.Onclick event handler using GlobeHookHelper:

public override void OnClick()
{
    m_globeDisplay=(IGlobeDisplay3)m_globeHookHelper.GlobeDisplay;
    //Start listening to globe display events.
    ((IGlobeDisplayEvents_Event)m_globeDisplay).AfterDraw += new
        IGlobeDisplayEvents_AfterDrawEventHandler(OnAfterDraw);
}

/// <summary>
/// GlobeDisplay's AfterDraw event handler.
/// </summary>
/// <param name="pViewer"></param>
private void OnAfterDraw(ISceneViewer pViewer)
{
    //AfterDraw event handler logic goes here.
}

• ILayer
• IGeoDataset
• ILayerExtensions
• ILegendInfo
• ILayerDrawingProperties
• ILayerInfo
• IPersistStream

Setup for drawing OpenGL

Loading 3D models from file

• The following code example shows loading a 3D model from file:

//Loading 3D model from file.
IMarker3DSymbol marker3DSymbol=new Marker3DSymbolClass();
marker3DSymbol.CreateFromFile(path);

//Create a 3D marker symbol.
IMarkerSymbol markerSymbol=new SimpleMarker3DSymbolClass();

//Set the marker symbol's style and resolution.
((ISimpleMarker3DSymbol)markerSymbol).Style =
    esriSimple3DMarkerStyle.esriS3DMSSphere;
((ISimpleMarker3DSymbol)markerSymbol).ResolutionQuality=1.0;

//Set the symbol's size and color.
markerSymbol.Size=700;
markerSymbol.Color=color as IColor;

Creating display lists from 3D symbols

• See the following code example that shows how to calculate the symbol scale:

private uint CreateDisplayList(IMarker3DSymbol marker3DSymbol)
{
    m_globeDisplay.DirectOpenGLDraw=true;
    GL.glMatrixMode(GL.GL_MODELVIEW);

    IDisplay display=(IDisplay)m_globeDisplay;
    IGlobeDisplayRendering globeDisplayRendering=(IGlobeDisplayRendering)
        m_globeDisplay;
    double globeRadiusMeters=globeDisplayRendering.GlobeRadius;

    //Calculate the symbol scale.
    double scale=1.0 / globeRadiusMeters; //Normalized by the globe radius.

    uint intSymbolDisplayList=GL.glGenLists(1);
    GL.glNewList(intSymbolDisplayList, GL.GL_COMPILE);
    {
        GL.glDisable(GL.GL_COLOR_MATERIAL);
        GL.glPushMatrix();
        {
            GL.glScaled(scale, scale, scale);
            display.SetSymbol((ISymbol)marker3DSymbol);
        }
        GL.glPopMatrix();
        GL.glEnable(GL.GL_COLOR_MATERIAL);
    }
    GL.glEndList();

    m_globeDisplay.DirectOpenGLDraw=false;

    return intSymbolDisplayList;
}

• After caching your symbol inside a display list, the drawing becomes a sequence of translating, rotating, scaling, and calling your display lists.

Coordinate systems for drawing 3D graphics

Globe coordinate system

• See the following code example that shows how to calculate the scale for a globe coordinate system:

IGlobeDisplayRendering globeDisplayRendering=(IGlobeDisplayRendering)
    m_globeDisplay;
double globeRadiusMeters=globeDisplayRendering.GlobeRadius;
double scale=1.0 / globeRadiusMeters; //Normalized by the globe radius.

 

• The following code example shows how to convert coordinates for each coordinate system using globe:

//Declaring the GlobeViewUtil.
private IGlobeViewUtil m_globeViewUtil=null;

//Cast GlobeViewUtil from the globe camera.
m_globeViewUtil=sceneViewer.Camera as IGlobeViewUtil;

//Convert a geographic coordinate to geocentric.
m_ipGlobeViewUtil.GeographicToGeocentric(longitude, latitude, altitudeMeters, out X,
    out Y, out Z);

//Convert geocentric to geographic.
m_ipGlobeViewUtil.GeocentricToGeographic(X, Y, Z, out longitude, out latitude, out
    altitudeMeters);

//Convert geocentric to window.
int winX, winY;
m_globeViewUtil.GeocentricToWindow(x, y, z, out winX, out winY);

//Convert window to geographic.
m_globeViewUtil.WindowToGeographic(m_globeDisplay, m_sceneViewer, X, Y, true, out
    lon, out lat, out alt);

Local object's coordinate system

Coordinate transformation

Aligning the object's up direction

private void CalculateSymbolOrientation(ISceneViewer sceneViewer, double glX, double
    glY, double glZ, out WKSPointZ orientation)
{
    m_vector3D.SetComponents(glX, glY, glZ);
    double inclination=m_vector3D.Inclination;
    double azimuth=m_vector3D.Azimuth;

    orientation.X=( - 1.0 * inclination * (180.0 / Math.PI)) + 180.0;
    orientation.Y=0.0;
    orientation.Z=180.0 - azimuth * (180.0 / Math.PI);
}

void TranslateAndRotate(double glX, double glY, double glZ, WKSPointZ
    symbolOrientation, double udfAzimuth)
{
    GL.glTranslated(glX, glY, glZ);
    GL.glRotated(symbolOrientation.Z, 0.0, 0.0, 1.0);
    GL.glRotated(symbolOrientation.X, 1.0, 0.0, 0.0);
    GL.glRotated(symbolOrientation.Y, 0.0, 1.0, 0.0);
    GL.glRotated(udfAzimuth, 0.0, 1.0, 0.0);
}

Drawing sequence

1. Call glPushMatrix to push the current matrix stack. This needs to be done since you are about to manipulate the transformation stack to put the object in place.
2. Normally, you have to convert your object’s coordinates from real-world geographic coordinates into a geocentric coordinate system. For this reason, you have to reproject (if required) your object’s coordinate into a World Geodetic System 1984 (WGS84) geographical coordinate system.
3. Once you have your object’s coordinate in a WGS84 geographical coordinate system, convert it into a geocentric coordinate system by using the IGlobeViewUtil interface.
4. Calculate the object’s orientation so that it will be parallel to the globe and aligned with the object’s heading direction. This means aligning the z-axis to the globe’s radius vector.
5. Translate the object into place and if necessary, orient the object.
6. Scale the object to display in its real size or if necessary, aggregate the object’s size.
7. Call the display list of the relevant symbol in which to draw.
8. Call glPopMatrix to pop back the current matrix stack.

• The following code example shows a simple implementation of the DrawImmediate call:

public override void DrawImmediate(IGlobeViewer pGlobeViewer)
{
    //Ensure the layer is visible and valid.
    if (!m_bVisible || !m_bValid)
        return ;

    //Only once, create display lists and do other initializations.
    if (!m_bDisplayListCreated)
    {
        CreateDisplayLists();
    }

    //Get the GlobeDisplay.
    IGlobeDisplay globeDisplay=pGlobeViewer.GlobeDisplay;

    //Get the active viewer. 
    SceneViewer sceneViewer=globeDisplay.ActiveViewer;

    //Calculate the scale.
    IGlobeDisplayRendering globeDisplayRendering=IGlobeDisplayRendering)
        m_globeDisplay; double globeRadiusMeters =
        globeDisplayRendering.GlobeRadius; double scale=1.0 / globeRadiusMeters; 

    IGlobeDisplayRenderingPtr ipGlobeDisplayRend(pGlobeDisplay); 

    double glX, glY, glZ; WKSPointZ wksSymbolOrientation; 

    . . . 

    //Translate the object into place.
    GL.glPushMatrix(); 
    {
        //Get the object’s OpenGL coordinate. 
        m_ipGlobeViewUtil.GeographicToGeocentric(obj.dLongitude, obj.dLatitude,
            obj.dAltitudeMeters, out glX, out glY, out glZ); 
        //Calculate the object’s orientation.
        CalculateSymbolOrientation(ipSceneViewer, glX, glY, glZ,
            wksSymbolOrientation); 

        //Translate the object into place and orient it.
        TranslateAndRotate(glX, glY, glZ, wksSymbolOrientation, dblSymbolAngle); 

        //Set the object’s scale.
        GL.glScaled(dScale, dScale, dScale); 

        //Draw the object.
        GL.glCallList(m_intMainSymbolDisplayList); 
    }
    GL.glPopMatrix(); 
}

Optimizing the drawing sequence

• Minimizing the computation load inside DrawImmediate
• Scaling and aggregating the drawn symbology
• Screening out objects outside of the display viewport
• Using a global timer to redraw the display

Minimizing the computation load inside DrawImmediate

• The following code example shows how to minimize the computation load:

public bool AddItem(long zipCode, double lat, double lon)
{
    double X=0.0, Y=0.0, Z=0.0;
    . . . DataRow r=m_table.Rows.Find(zipCode);
    if (null != r)
    //If the record with this ZIP Code already exists.
    {
        //Cache the item’s geocentric coordinate to save the calculation inside method 
        DrawImmediate(). globeViewUtil.GeographicToGeocentric(lon, lat, 1000.0, out
            X, out Y, out Z);

        //Update the record.
        r[3]=lat;
        r[4]=lon;
        r[5]=X;
        r[6]=Y;
        r[7]=Z;

        lock(m_table)
        {
            r.AcceptChanges();
        }
    }
    . . .
}

Scaling and aggregating symbols

• The following code example shows calculating the scale (magnitude) according to the distance from the camera to the object using geocentric units, taking into consideration the elevation exaggeration:

double dblObsX, dblObsY, dblObsZ, dMagnitude;
ICamera camera=pGlobeViewer.GlobeDisplay.ActiveViewer.Camera;

//Get the camera location in a geocentric coordinate (OpenGL coordsystem).
camera.Observer.QueryCoords(out dblObsX, out dblObsY);
dblObsZ=camera.Observer.Z;

IGlobeDisplayRendering globeDisplayRendering=IGlobeDisplayRendering)
    m_globeDisplay; double baseExaggeration =
    globeDisplayRendering.BaseExaggeration; 

double X=0.0, Y=0.0, Z=0.0; X=Convert.ToDouble(rec[5]); Y=Convert.ToDouble
    (rec[6]); Z=Convert.ToDouble(rec[7]); 

m_ipVector3D.SetComponents(dblObsX - X, dblObsY - Y, dblObsZ - Z); 

dMagnitude=m_ipVector3D.Magnitude; 

double scale=dblMagnitude * baseExagFactor;

• The following code example shows how to set the scale threshold:

//If far away from the object, draw it as a simple OpenGL point.
if (scale > 2.5)
{
    GL.glPointSize(5.0f);
    GL.glColor3ub(0, 255, 0);
    GL.glBegin(GL.GL_POINTS);
    GL.glVertex3f(Convert.ToSingle(X), Convert.ToSingle(Y), Convert.ToSingle(Z));
    GL.glEnd();

}

else
//When close enough, draw the full symbol.
{
    GL.glPushMatrix();
    {
        //Translate and orient the object into place.
        TranslateAndRotate(X, Y, Z, wksSymbolOrientation, dSymbolAngle);

        //Scale the object.
        GL.glScaled(dObjScale, dObjScale, dObjScale);

        //Draw the object.       
        GL.glCallList(m_intMainSymbolDisplayList);
    }
    GL.glPopMatrix();
}

Screening out objects outside the display viewport

• The following code example shows testing an object inside the viewport:

private bool InsideViewport(double x, double y, double z, double clipNear, uint mode)
{

    bool inside=true;

    //In selection mode, the projection matrix is changed.
    //Therefore, use the GlobeViewUtil because calling gluProject gives unexpected results.
    if (GL.GL_SELECT == mode)
    {
        int winX, winY;
        m_globeViewUtil.GeocentricToWindow(x, y, z, out winX, out winY);

        inside=(winX >= m_viewport[0] && winX <= m_viewport[2]) && (winY >=
            m_viewport[1] && winY <= m_viewport[3]);

    }
    else
    {

        //Use gluProject to convert into the window’s coordinate.

        unsafe
        {
            double winx, winy, winz;
            GLU.gluProject(x, y, z, m_modelViewMatrix, m_projMatrix, m_viewport,  &
                winx, &winy, &winz);

            inside=(winx >= m_viewport[0] && winx <= m_viewport[2]) && (winy >=
                m_viewport[1] && winy <= m_viewport[3] && (winz >= clipNear && winz
                <= 1.0));
        }
    }

    return inside;
}

//Get the OpenGL matrices.
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, m_modelViewMatrix);
GL.glGetIntegerv(GL.GL_VIEWPORT, m_viewport);
GL.glGetDoublev(GL.GL_PROJECTION_MATRIX, m_projMatrix);

//Get the OpenGL rendering mode.
uint mode;
unsafe
{
    int m;
    GL.glGetIntegerv(GL.GL_RENDER_MODE, &m);
    mode=(uint)m;
}

//Get the globe’s near clipping plane. The ClipNear value is required for the viewport filtering 
//(since you do not want to draw an item beyond the clipping planes).
IGlobeAdvancedOptions advOpt=m_globeDisplay.AdvancedOptions;

double clipNear=advOpt.ClipNear;

//Ensure the object is within the viewport.
if (!InsideViewport(X, Y, Z, clipNear, mode))
    continue;
//Continue with the drawings here.
. . .

Using a single timer to redraw the display

• The following code example shows a class inheriting the System.Windows.Forms.Control interface:

//Class definition.
public abstract class GlobeCustomLayerBase: Control, ILayer, IGeoDataset, . . . 
//Class constructor.
public GlobeCustomLayerBase()
{
    //Call CreateControl to create the handle.
    this.CreateControl();
}

. . .

//Redraw delegate invokes the timer's event handler on the main thread.
private delegate void RedrawEventHandler();

//Set the layer’s redraw timer.
private System.Timers.Timer m_redrawTimer=null;

//Initialize the redraw timer.
m_redrawTimer=new System.Timers.Timer(200);
m_redrawTimer.Enabled=false;
//Wire the timer’s elapsed event handler.
m_redrawTimer.Elapsed += new ElapsedEventHandler(OnRedrawUpdateTimer);

//Redraw the timer’s elapsed event handler.
private void OnRedrawUpdateTimer(object sender, ElapsedEventArgs e)
{
    //Since this is the timer’s event handler, it gets executed on a different thread 
    //than the main one; therefore, the Invoke call is required to force the call on 
    //the main thread and prevent cross apartment calls.
    if (m_bTimerIsRunning)
        base.Invoke(new RedrawEventHandler(OnRedrawEvent));
}

//This method invoked by the timer’s elapsed event handler and gets executed on the 
//main thread.
void OnRedrawEvent()
{
    m_globeDisplay.RefreshViewers();
}

//Declare the global timer.
private IGlobalTimer m_globalTimer=null;

public void DrawImmediate(IGlobeViewer pGlobeViewer)
{
    if (!m_bVisible || !m_bValid)
        return ;
    . . . 

    if (null == m_globalTimer)
    {
        m_globalTimer=new GlobalTimerClass();
        m_globalTimer.GlobeDisplay=pGlobeViewer.GlobeDisplay;
        if (m_globalTimer.RedrawInterval > 200)
            m_globalTimer.RedrawInterval=200;
        m_globalTimer.Start();
    }
    . . .

Managing dynamic objects

• The following code example shows a user-defined data structure that is storing real-time data using ADO.NET DataTable:

private DataTable m_table=null;

public GlobeCustomLayerBase()
{
    m_table=new DataTable("RECORDS");

    //Add columns to the table.
    m_table.Columns.Add("ID", typeof(long));
    m_table.Columns.Add("ZIPCODE", typeof(long));
    m_table.Columns.Add("CITYNAME", typeof(string));
    m_table.Columns.Add("LAT", typeof(double));
    m_table.Columns.Add("LON", typeof(double));
    m_table.Columns.Add("X", typeof(double));
    m_table.Columns.Add("Y", typeof(double));
    m_table.Columns.Add("Z", typeof(double));
    . . . 

    //Set the columns’ properties.
    m_table.Columns[0].AutoIncrement=true;
    m_table.Columns[0].ReadOnly=true;

    //Set the ZIP Code primary key for the table.
    m_table.PrimaryKey=new DataColumn[]
    {
        m_table.Columns["ZIPCODE"]
    };
    . . .

• The following code example shows accessing the data stored in the DataTable:

//Sequential access.
foreach (DataRow rec in m_table.Rows)
{
    lat=Convert.ToDouble(rec[3]);
    lon=Convert.ToDouble(rec[4]);
    X=Convert.ToDouble(rec[5]);
    Y=Convert.ToDouble(rec[6]);
    Z=Convert.ToDouble(rec[7]);
    . . .
}

//Random access, first make sure the item exists. 
//To call the Find()method, set columns as a primary key. 
DataRow r=m_locations.Rows.Find(zip);
if (null == r)

. . .

//Add the current location to the location table.
DataRow r=m_locations.Rows.Find(zip);
if (null == r)
{
    r=m_locations.NewRow();
    r[1]=zip;
    r[2]=cityName;

    //Lock the location table to prevent access from other
    //threads while adding the new record to the table. 
    lock(m_locations)
    {
        m_locations.Rows.Add(r);
    }
}

Connecting to real-time feeds

• Push mode—Means the layer listens to events sent by the server resulting in a synchronized connection.
• Pull mode—Means the layer queries the server periodically for updates, normally by using a timer.

• The following code example shows pulling messages from an ArcGIS Tracking Server feed:

private System.Timers.Timer m_timer=null;

//Declare the invoke delegate.
private delegate void MessageHandler(IMessage msg);

//Set the update timer interval to 10MS.
m_timer=new System.Timers.Timer(10);
m_timer.Enabled=false;

//Wire the timer’s elapsed event.
m_timer.Elapsed += new ElapsedEventHandler(OnTimer);

//Pull the messages from the server.
private void OnTimer(object sender, ElapsedEventArgs e)
{
    try
    {
        IMessage msg=m_internetServerConnection.getMessage(0);
        if (msg == null)
            break;

        //Process the incoming message.
        this.Invoke(new MessageHandler(HandleMessage), new object[]
        {
            msg
        }
        );
    }
    catch (Exception ex)
    {
        System.Diagnostics.Trace.WriteLine(ex.Message);
    }
}


//Handle the incoming message.
private void HandleMessage(IMessage msg)
{
    IDataMessage dataMessage=(IDataMessage)msg;
    int flightId=Convert.ToInt32(dataMessage.getColumn(1));
    . . .
}

Serializing the custom layer

• The following code example shows implementing IPersistStream Save and Load to serialize a layer:

void ESRI.ArcGIS.esriSystem.IPersistVariant.Save(IVariantStream Stream)
{
    Stream.Write(m_name);
    Stream.Write(m_bValid);
    Stream.Write(m_bCached);
    Stream.Write(m_dblMinScale);
    Stream.Write(m_dblMaxScale);
    Stream.Write(m_bDrawDirty);
    Stream.Write(m_bShowIcon);

    Stream.Write(m_spRef);
    Stream.Write(m_extent);

    Stream.Write(m_extensions);
}

void ESRI.ArcGIS.esriSystem.IPersistVariant.Load(IVariantStream Stream)
{
    m_name=(string)Stream.Read();
    m_bValid=(bool)Stream.Read();
    m_bCached=(bool)Stream.Read();
    m_dblMinScale=(double)Stream.Read();
    m_dblMaxScale=(double)Stream.Read();
    m_bDrawDirty=(bool)Stream.Read();
    m_bShowIcon=(bool)Stream.Read();

    m_spRef=(ISpatialReference)Stream.Read();
    m_extent=(IEnvelope)Stream.Read();

    m_extensions=(ArrayList)Stream.WiringRead();

    //Allocate a new vector 3D, do not worry about writing and reading...
    m_vector3D=new Vector3DClass();
}

/// <summary>
/// The main update thread of the layer.
/// </summary>
private void ThreadProc()
{
    . . . 

    //Serialize the tables onto the local machine.
    DataSet ds=new DataSet();
    //Add the in-memory tables to the dataset.
    ds.Tables.Add(m_table);
    ds.Tables.Add(clonedTextureMap);
    //Write the dataset to the local machine.
    ds.WriteXml(m_weatherXmlFile);

    ds.Tables.Remove(m_table);
    ds.Tables.Remove(clonedTextureMap);
    clonedTextureMap.Dispose();
    ds.Dispose();
    GC.Collect();
}

Labeling objects

Creating fonts for fast 3D display

Creating billboard text

Implementing a HitTest method

. . . 
//Load the name to implement the HitTest method.
GL.glLoadName((uint)lZipCode);
//Draw the item.
GL.glCallList(m_billboardRectList);

• As shown in the following code example, ensure the hit object belongs to the current layer:

//Get the owner.
object owner=pHit3D.Owner;

//Ensure the owner is a weather layer.
if (!(owner is RSSWeatherLayer3DClass))
    return ;

//Get the record by the ZIP Code received from the selection buffer. 
DataRow[] rows=m_table.Select("ZIPCODE=" + hitObjectID.ToString());
if (rows.Length == 0)
    return ;

//Get the hit point from the Hit3D.
IPoint hitPoint=pHit3D.Point;

//Ensure the hit point is initialized.
if (null == hitPoint)
{
    double lat, lon, alt;
    lat=Convert.ToDouble(r[3]);
    lon=Convert.ToDouble(r[4]);
    alt=1000.0;

    IPoint point=new PointClass();
    ((IZAware)point).ZAware=true;
    point.PutCoords(lon, lat);
    point.Z=alt;

    pHit3D.Point=point;
}

• For that reason, you must pass all the information that is relevant on the object as shown in the following code example:

//Create a PropertySet instance.
IPropertySet propSet=new PropertySetClass();

//Add the object’s information to the PropertySet.
propSet.SetProperty("ZIPCODE", r[1]);
propSet.SetProperty("CITYNAME", r[2]);
propSet.SetProperty("LATITUDE", r[3]);
propSet.SetProperty("LONGITUDE", r[4]);
propSet.SetProperty("TEMPERATURE", r[8]);
propSet.SetProperty("DESCRIPTION", r[9]);
propSet.SetProperty("DAY", r[11]);
propSet.SetProperty("DATE", r[12]);
propSet.SetProperty("LOW", r[13]);
propSet.SetProperty("HIGH", r[14]);
propSet.SetProperty("UPDATED", r[16]);

//Pass the PropertySet to the caller.
pHit3D.Object=propSet;

Identifying objects

public IArray Identify(IGeometry pGeom)
{
    . . . 

}

IEnvelope inEnv;
IArray array=new ArrayClass();

//Get the envelope from the geometry.
if (pGeom.GeometryType == esriGeometryType.esriGeometryEnvelope)
    inEnv=pGeom.Envelope;
else
    inEnv=pGeom as IEnvelope;

if (inEnv.IsEmpty)
    return array;

//Get the envelope’s center coordinate.
double xMin, xMax, yMin, yMax, zMin, zMax;
inEnv.QueryCoords(out xMin, out yMin, out xMax, out yMax);
zMin=inEnv.ZMin;
zMax=inEnv.ZMax;

double xC, yC, zC;
xC=(xMin + xMax) * 0.5;
yC=(yMin + yMax) * 0.5;
zC=(zMin + zMax) * 0.5;

ISceneViewer sceneViewer=m_globeDisplay.ActiveViewer;
ICamera camera=sceneViewer, Camera;

//Convert the coordinate into the window’s coordinate.
ISceneViewer sceneViewer=m_globeDisplay.ActiveViewer;
IGlobeViewUtil globeViewUtil=(IGlobeViewUtil)sceneViewer.Camera;

int winX, winY;
globeViewUtil.GeographicToWindow(xC, yC, zC * 1000.0, out winX, out winY);

IHit3DSet hits;
//Locate all items that fall within the given location.
m_globeDisplay.LocateMultiple(sceneViewer, winX, winY, true, false, false, false,
    out hits);

if (null == hits)
    return array;

• For each of these objects, create an instance of IdentifyObject, pass it the PropertySet, and add it to the output array of identified results. See the following code example:

IHit3D hit3D=null;
IPropertySet propSet=null;
IIdentifyObj idObj=null;
IIdentifyObject idObject=null;
bool bIdentify=false;

//Get all the hits from the Hit3Dset.
IArray objArray=hits.Hits;
int nCount=objArray.Count;

//Iterate through the hit items and create identify objects.
for (int i=0; i < nCount; i++)
{
    hit3D=objArray.get_Element(i)as IHit3D;

    //Make sure that the hit object type is a PropertySet.
    propSet=hit3D.Object as IPropertySet;
    if (null != propSet)
    {
        //Instantiate the identify object and add it to the array.
        idObj=new GlobeWeatherIdentifyObject();

        //Test whether the layer can be identified.
        bIdentify=idObj.CanIdentify((ILayer)this);
        if (bIdentify)
        {
            idObject=idObj as IIdentifyObject;
            idObject.PropertySet=propSet;
            array.Add(idObj);
        }
    }
}

//Return the array with the identify objects.
return array;

Selecting objects

• See the following code example:

GL.glPushMatrix();
//Translate to the item’s location.
GL.glTranslatef(Convert.ToSingle(X), Convert.ToSingle(Y), Convert.ToSingle(Z));

//Orient the icon so that it faces the camera.
OrientBillboard();

//Scale the item (original size is 1 unit).
double useScale=0.04 * dMagnitude;
GL.glScaled(useScale, useScale, 1.0);

GL.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//Loads the ZIP Code onto the name stack.

GL.glLoadName((uint)lZipCode);
//Draw the item.
GL.glCallList(m_billboardRectList);

//If the object is selected, draw a box around it.
if (bIsSelected)
{
    GL.glColor4ub(255, 255, 128, 255);
    GL.glCallList(m_selectionDisplayList);
}

. . . GL.glPopMatrix();

• The following code example shows selecting objects according to an object’s ZIP Code (unique):

public void Select(long zipCode, bool newSelection)
{
    //If it is a new selection, unselect any selected items.
    if (newSelection)
    {
        //Unselect all the currently selected items.
        lock(m_table)
        {
            foreach (DataRow r in m_table.Rows)
            {
                r["SELECTED"]=false;
            }
            m_table.AcceptChanges();
        }
    }

    //Get the record from the table.
    DataRow[] rows=m_table.Select("ZIPCODE=" + zipCode.ToString());

    //Make sure the record exists.
    if (rows.Length == 0)
        return ;

    DataRow rec=rows[0];
    //Set the selection flag to true.
    lock(m_table)
    {
        rec["SELECTED"]=true;
        rec.AcceptChanges();
    }
}

• The following code example shows selection by area:

public override void OnMouseDown(int Button, int Shift, int X, int Y)
{
    if (null == m_weatherLayer)
        return ;

    object owner;
    object obj;

    IPoint hitPoint;
    //Get the globe display.
    IGlobeDisplay globedisplay=((IGlobe)m_scene).GlobeDisplay;

    ISceneViewer sceneViewer=globedisplay.ActiveViewer;

    //Call locate to HitTest the element in the current window coordinate.
    globedisplay.Locate(sceneViewer, X, Y, false, false, out hitPoint, out owner,
        out obj);

    if (obj != null)
    {
        //Make sure the returned object is indeed a PropertySet.
        if (!(obj is IPropertySet))
        {
            return ;
        }
        //Cast the object into a PropertySet.
        IPropertySet propset=obj as IPropertySet;
        if (propset == null)
            return ;

        //Make sure the owner is the right layer.
        if (!(owner is RSSWeatherLayer3DClass))
            return ;

        //Get the ZIP Code.
        object o=propset.GetProperty("ZIPCODE");
        long zipcode=Convert.ToInt64(o);

        //Select the object.
        m_weatherLayer.Select(zipcode, Shift != 1);
    }
}

Flashing objects in the globe display

• The following code example shows using static counters to flash an item using a dedicated display list:

private long m_lItemToFlash= - 1L;
private static int m_flashCount=0;
private static bool m_flashDraw=true;

//Flash the required object.
if (lZipCode == m_lItemToFlash)
{
    if (m_flashCount > 10)
    //Quit flashing after 10 draw cycles.
    {
        m_lItemToFlash= - 1;
        m_flashDraw=true;
        m_flashCount=0;
    }
    else
    //Draw the flash symbol.
    {
        //Draw only on even cycles.
        if (m_flashDraw == true)
        {
            GL.glCallList(m_intFlashSymbolList);
        }

        //Set the counter. 
        m_flashCount++;

        //Alternate the flash drawing.
        m_flashDraw=!m_flashDraw;
    }
}

Implementing prediction mode

• The following code example shows calculation of the distance to the next object’s position according to the object’s speed and the elapsed time:

//Get the system time.
long ticks=DateTime.Now.Ticks;

//Get the cached last update time.
long ticksSinceUpdate=r["UPDATETIME"];

//Get the object’s speed.
double speed=ref["SPEED"];

//Calculate the distance to the next object position; time is in seconds. 
dDist=speed * ((double)(ticks - ticksSinceUpdate) / 1000.0);

r["UPDATETIME"]=ticks;
. . .

• The following code example shows conversion from kilometers per hour into decimal degrees:

//Get the globe radius.
IGlobeDisplayRendering globeDisplayRendering=(IGlobeDisplayRendering)
    m_globeDisplay;
double globeRadiusMeters=globeDisplayRendering.GlobeRadius;

//Calculate the angular distance in radians. 
double dblDistDD=(dblDistMeters / (globeRadius + dblAltMeters));

//Convert the distance from radians to decimal degrees.
dblDistDD *= (180.0 / Math.PI);

See Also: