GlobeCore

Supported with:
Library dependencies: System, SystemUI, Geometry, Display, Server, Output, Geodatabase, GISClient, DataSourcesFile, DataSourcesGDB, DataSourcesOleDB, DataSourcesRaster, DataSourcesNetCDF, GeoDatabaseDistributed, GeoDatabaseExtensions, Carto, NetworkAnalysis, Location, GeoAnalyst, Animation, Maplex, Geoprocessing, NetworkAnalyst, Schematic, SpatialAnalyst, 3DAnalyst

Additional library information: Contents, Object Model Diagram

The GlobeCore library is the major library for working with the ArcGlobe application (an addition to ArcGIS 3D Analyst at ArcGIS 9.0 for 3D visualization of multiple resolution global data). The GlobeCore library contains objects for working with 2D and 3D data displayed on the surface of a globe; similar to the Carto library, which contains objects for working with 2D maps.

See the following sections for more information about this namespace:

About the GlobeCore library
The Globe object is one of the main objects of the GlobeCore library since it is the container for data layers, similar to the Map object. The GlobeDisplay object, analogous to the SceneGraph coclass of the 3DAnalyst library, is a container for data caching and for events that occur in the globe. These events include those that occur when there is a change in the active view to events that trigger to notify data caching state. The GlobeDisplay object also manages, specifies, and controls different optimization schemes of the application.
The GlobeCore library is also host for the GlobeCamera object that specifies the perspective of a 3D globe display rendering, to define the positioning of the globe relative to the observer. In ArcGlobe, the 3D display window is represented by the GlobeViewer object. It is similar in its function and properties to the SceneViewer object in the 3DAnalyst library. The 3DAnalyst library overview discusses the GlobeViewer, SceneViewer, and 3DViewer (a class that has common properties and methods of the two viewers). The globe can have one or more layers that specify the data on the globe and how the data is drawn.
The GlobeLayerProperties class is one of the more important globe specific layer extension classes that specifies layer drawing priorities on the surface of the globe, controls cache data removal behavior, suggests symbology scaling factor, estimates visibility distance thresholds, determines data caching mode (on-demand versus full data cache), controls cache data compression options and quality, image resampling modes, feature level of detail (LOD), and feature data drawing mode (rasterized versus vector).
The GlobeHeightProperties class provides access to members that manipulate the height properties of a globe layer including those specific to feature layers (as vectors), such as extrusion, z-factor applied to elevation layers, and offset that can be applied to any layer. GlobeAdvancedOptions is a class that allows the developer to set advanced globe properties, such as whether to use disk cache, control near and far clipping planes, control application level of LOD that gets applied only at draw time, the target frame rate for automatic control of display LOD, and various attributes stored in the registry.
In addition, like the Scene object, it contains AnimatonTrack objects, the Globe class contains the same object to make real-time animation or video output by manipulating globe display and layer properties. There can be zero or more AnimatonTrack objects in the globe, which further contains one or more GlobeKeyframe objects. The AnimationTrack further contains AnimationType objects. Through these objects, you can control the behavior and type of animations. For more information, see the 3DAnalyst library overview regarding animation framework discussions in the ArcScene and ArcGlobe application of ArcGIS 3D Analyst extension. See the following illustration:
A GlobeControl and a set of globe commands exists in the Controls library with a ToolbarControl, TOCControl, and helper objects for creating custom commands.

Globe
The functionality of the Globe class is analogous to the Map and Scene classes, where the former is a container for 2D data and the latter is a container for 3D and 2D data in the 3D Analyst's ArcScene application.
The Globe object is a container of 2D and 3D layers. There are many similarities that can be drawn between the Scene and Globe classes. The Globe object has properties that operate on all layers in the globe; spatial reference, scale, and so on, along with methods that manipulate the globe's layers. One major difference between the Globe, Scene, and Map object is that as a prerequisite, any layer intended to be used in the application must have a spatial reference defined. There are many different types of layers that can be added to the globe. Different data sources often have an associated layer responsible for displaying the data on the globe; vector features are handled by the FeatureLayer object, Raster data (both image and surface data) by the RasterLayer, and so on.
If required, layers can handle all the drawing operations for its associated data, but it is more common for layers to have an associated renderer object. The properties of the renderer object control how the data is displayed in the globe. Renderers commonly use symbols from the Display library for the actual drawing; the renderer matches a particular symbol with the properties of the entity that is to be drawn. Similar to the Carto library, the GlobeCore library also contains support for annotation and globe tips. Similarly, the Globe class is a container for display and manipulation of data on the surface of the globe.
The Globe object contains one major interface, IGlobe, along with many other important inherited interfaces required for manipulation and access of data. These include IBasicMap, IBasicScene, IScene, ISceneBookmarks, and IAnimationTracks.
See the following illustration:
The IGlobe interface allows the developer to have access to basic globe ingredients, such as GlobeLayers, and to properties and methods of the globe. It is through this interface the developer can access adding layer types, according to their categories (floating, draped, or elevation), get access to globe background options, including sky and space colors, fading transition values, as well as globe tips properties and the linear units used in the globe.

GlobeDisplay
GlobeDisplay is a central object in ArcGlobe. It provides access to basic properties of the globe and layers to more advanced aspects of the application, including management of viewers, rendering and data caching. The GlobeDisplay class has the following major interfaces:
See the following illustration:
ArcGlobe is an application that has a highly optimized data tiling, LOD management, and data caching architecture. Managed by the GlobeDisplay object and common to all data sets, there is a division of data in quadrilateral areas of the globe (tiles). At the lowest level, the globe is divided into six major areas (face tiles), which consist of four around the equator and two at the poles. See the following illustration:
Part of the application's notion of LOD stems from the fact that these tiles are recursively subdivisible. At any LOD, the area covered by any tile is equal to four levels at the next level to a maximum resolution of the data set. Each of the six major faces is divided into multiple tiles at different levels of detail (referred to as data tiling). See the following illustration:
The GlobeDisplay object manages and controls tile generation and subsequent storing of data tiles for future use (referred to as data caching). Data tiles are always stored in a memory cache and optionally, in a disk cache. The main advantage of data caching is to improve the visualization performance and reduce repetitive data requests from data sources. Each data tile will be stored into memory and optionally into disk for future use.
The tile generator, IGlobeDisplayLayers.GenerateTiles, preprocesses data in offline mode (full caching) and in an interactive on-demand mode (on-demand data caching). See the following illustration:
General globe properties are accessed via the IGlobeDisplayRendering interface. See the following illustration:
Commonly used globe properties include vertical exaggeration, background colors, and sun position. The IGlobeDisplayLayers interface provides access to globe specific layer properties and general purpose functions. GlobeDisplay gives you access to one or more GlobeViewers being used by the application (3D display windows). You can change the perspective displayed in a GlobeViewer through its camera. GlobeDisplay can be acquired from an ArcGlobe document's Globe object via IGlobe.GlobeDisplay.
Most of the members from IGlobeDisplayLayers are used for internal purposes. Developers should not directly use members from this interface but instead, use methods and properties from IGlobeLayerProperties.
IGlobeDisplayLayers.IViewers3D provides access to members that control the ActiveViewer, indicate the 3D display navigation mode, control redrawing into all viewers, and registers and unregisters any additional viewers.

GlobeViewer
Similar to the SceneViewer, the GlobeViewer is a 3D display window in ArcGlobe. See the SceneViewer and GlobeViewer discussion in the 3DAnalyst library overview.

GlobeLayerProperties
GlobeLayerProperties class is the layer extension that contains globe specific layer properties. These include layer drawing priority on the surface of the globe, exposed as IGlobeLayerProperties.BaseImageDrawingPriority. This value relates to the position of the layers that are part of the base globe (that is, draped layers and elevation layers) in the drawing order. To get an ordered list of layers in the base globe, use IGlobeDrawingOrder.GetOrderedLayers.
Elevation layers are always on top of the ordered list followed by draped layers.
The GlobeLayerProperties object also controls the layers cache data removal behavior via IGlobeLayerProperties.SetCacheRemovalOption. The default setting is to remove the cache when exiting the application or removing the layer.
The IGlobeLayerProperties.IsDynamicallyRasterized property (set only) indicates if the feature data is to be rasterized. Feature layers will be treated as rasterized if this property is set to true. By default, all 2D feature data is rasterized and 3D data (including multipatch feature classes) will be treated as vectors.
You will get advanced symbology support (any symbology supported in ArcMap will be honored when a feature layer is treated as rasterized) and better draping of feature data onto the surface of the globe, especially if elevation data is present. Symbol sizes that are usually expressed as points need to have a scaling factor when used in an application that uses real-world units.
The IGlobeLayerProperties.SymbologyScalingFactor property (get/set) is the scaling factor of meters-per-point to apply to symbol sizes during rasterization, which indicates that a symbol with a size of eight points is converted to real-world units multiplied by the factor as suggested by IGlobeLayerProperties.SetSymbologyScalingFactor.
Visibility distance thresholds, IGlobeLayerProperties.MaximumDistance and IGlobeLayerProperties.MinimumDistance (get/set) govern the distance where a layer becomes visible or not. These values are automatically set for feature data when IGlobeLayerProperties.MaxFeatureLevelOfDetail is set.
The user is prompted to set this value when adding feature data to the application, especially if the data is to be treated as vector. Similarly, the developer needs to explicitly set this property when adding feature data to the application. See the following code example:
[Java] 
// Get the globe layers for a GlobeDisplay object, sorted by drawing priority.
IEnumLayer globeLayers = globeDisplay.getGlobe().getGlobeLayers(null, false, true,
    true);
// For each globe layer, set its maximum LOD to 2 if it hasn't already been set. 
for (ILayer globeLayer = globeLayers.next(); globeLayer != null; globeLayer =
    globeLayers.next()){
    IGlobeLayerProperties globeLayerProperties = globeDisplay.findGlobeProperties
        (globeLayer);
    if (globeLayerProperties.getMaxLOD() ==  - 1){
        globeLayerProperties.setMaxLOD(2);
    }
    globeDisplay.refreshLayer(globeLayer);
}

GlobeCamera
GlobeCamera defines the global and perspective viewing of data on the globe. Developers should use the GlobeCamera object to obtain Observer and Target positions via the GlobeCamera object instead of Camera because GlobeCamera works with latitude and longitude values instead of local coordinate system. IGlobeCamera is the major interface that has properties and methods to control navigation orientation, IGlobeCamera.setOrientationMode, which can be used to set to surface or global modes, the offset for the roll angle in degrees via IGlobeCamera.setRollOffset, and methods to get/set Observer and Target positions via IGlobeCamera.setObserverLatLonAlt(latDD, lonDD, altKMs) and IGlobeCamera.setTargetLatLonAlt(latDD, lonDD, altKMs) as a combination of latitude and longitude in decimal degrees plus altitude in kilometers. IGlobeCamera.getLocalOrientation(localAzi, LocalIncl, LocalRoll) gets the azimuth, inclination and roll angles relative to the current target on surface.

See the following illustration: 

GlobeServer
The GlobeServer coclass gives you access to an ArcGIS Globe layer bound to a GlobeServer object. It also allows globe server layers to be queried and identified (via the Find and Identify methods). GlobeServer can be used in desktop or Internet development environments. In a desktop environment, GlobeServer objects can be created in-process within your application. GlobeServer objects are run within ArcGIS for Server.
ArcGIS for Desktop and ArcGIS Engine developers can also consume server objects via the Server API. If you want to work with the fine-grained ArcObjects, use the Server API. You can use the GISServerConnection to connect to the GIS server, or you can obtain a reference to the ServerObjectManager through GISClient (TCP/IP connection only).
The GlobeServer class contains several important interfaces with basic functions for starting and stoping an ArcGIS for Server (IObjectActivate), for initializing a globeserver object from an ArcGlobe document (*.3dd file), and methods for defining the physical and virtual directories of a webservice (IGlobeServerSetup ), as well as an interface (IGlobeServerObject) for getting an ArcGIS Globe layer. The IGlobeServer interface contains methods for performing query and find on an ArcGIS Globe Server layer. In addition, IGlobeServer also contains methods for getting components of a globe server layer, such as animation files, tiles and associated textures as a uniform resource locator (URL) or binary data.
The GlobeServer class also uses IRequestHandler and IRequestHandler2, which provides access to members that control handling of request messages (binary or SOAP). See the following illustration:

GlobeServerLayer
The GlobeServerLayer class allows users to access an ArcGIS Globe Server layer, which is the basic component of an ArcGIS Globe service.
The GlobeServerLayer class contains several interfaces, which includes IGlobeServerLayer, (encapsulates methods for connecting to an ArcGIS for Server application and properties for querying layer properties), ILayerEffects (with propeties to manuiplate layer transparency), and ICompositeLayer (with a count property [get only] returning the exact layer count in the GlobeServerLayer).
Unlike a MapServer layer, calls to get the layer count or layer transparency will be honored and applied. Since the working components of a GlobeServer are layers, the developer has the ability to access each individual layer property. Furthermore, a GlobeServerLayer is different from a MapServer layer in that it supports being expanded via  the expanded property of ICompositeLayer2. This in effect, enables GlobeServer layers to be accessed per the layer level. This is an integral property of GlobeServerLayer in that it allows you to mix and match layers from different globe services and consume them as separate entities.
 
Other notable interfaces implemented by the class include, ILayerExtensions (with methods and properties to add layer extensions), ILayerPosition (with a property to get or set a layer's drawing position in the globe), and IPublishLayer (enabling GlobeServerLayers to support publishing). See the following illustration:

GlobeLayerInfo
The GlobeLayerInfo class can be considered as the class that provides detailed information about a GlobeServer layer. This class can be considered as the globe server layer equivalent of the GlobeLayerProperties class, which is an important layer extension object that contains globe specific layer properties. The bulk of the properties of GlobeLayerInfo are members of IGlobeLayerInfo. Some of these members include layer drawing priority on the surface of the globe, exposed as IGlobeLayerInfo.BaseImageDrawingPriority, and IGlobeLayerInfo.DataType, that describes the type of layer (whether it is a raster, elevation, or feature data). See the following illustration:

GlobeLayerInfos
GlobeLayerInfos is a container class for a GlobeLayerInfo, which provides detailed information about a globe server layer. See the following illustration:

GlobeServerIdentifyResult
The GlobeServerFindResult class provides information about a find result. See the following illustration:

GlobeServerIdentifyResults
This is a container class for GlobeServerFindResult, which provides information about a find result.

GlobeServerFindResult
The GlobeServerFindResult class provides information about a find result. See the following information:

GlobeServerFindResults
The GlobeServerFindResults is a container class for GlobeServerFindResult, which provides information about a find result. See the following illustration:

GlobeServerLayerFactory
The GlobeServerLayerFactory class provides access to the available properties of a layer factory for globe server layers. See the following illustration:

GlobeHeightProperties
The GlobeHeightProperties object is contained in the GlobeLayerProperties class. There is only one GlobeHeightProperties object at a time. Access to a layer's elevation property is obtained through the GlobeHeightProperties class. This class is important because a layer gets its height property and accordingly, where to display on the Table of Contents Type tab of the application. See the following screen shot:
The following are the categories in ArcGlobe in which a layer can belong:
The IGlobeHeightProperties Offset property represents a constant value that can be applied to any layer in the draped or floating layer categories. Both feature layers and raster images cannot have an offset if they are in the Draped layer category (needs to be part of the Floating layer cataloger to use this property).
Only feature layers treated as vectors honor the IGlobeHeightProperties offset property while still part of the Draped layers category. Similarly, the IGlobeHeightProperties ElevationExpressionString and ElevationExpression properties represent a constant or an expression value to define any feature layer's elevation applied to feature layers as vectors.
The HasElevationValues of the IGlobeHeightProperties is a Boolean that indicates whether the feature layer has z-values and is one of the properties that can be used to define a layer's z-placement.
Feature layers (as vectors) can have extrusion factors to convert any 2D feature layer into a 3D object (multipatch) by applying a conversion factor via the IGlobeHeightProperties ExtrusionExpression or ExtrusionExpressionString properties. See the following illustration:

GlobeAdvancedOptions
GlobeAdvancedOptions is used to manipulate ArcGlobe's advanced visualization and cache data management options. Use the IGlobeAdvancedOptions interface to access properties, such as CachePath (where cache data resides on the local machine), DefaultUse16ElevBits and DefaultUse16ColorBits (default values for elevation and image color compression), ClipNear and ClipFarFactor (near and far clipping planes that aid in performance optimization by clipping areas that do not fall within the application's view), LevelOfDetail (the LOD of image and elevation layers that gets applied during display), ManualLOD (a Boolean that indicates if the manual LOD control is on), and TargetFrameRate (the target frame rate when using automatic control of  LOD).

IGlobeAdvancedOptions also has the GetUseCache and SetUseCache methods to get/set the disk caching option and the amount of disk size to allocate, and a method to get the default lossy compression option for a data type and its quality from 1 to 100; GetDefaultCompression.
IGlobeAdvancedOptions.RestoreClipPlaneDefaults and IGlobeAdvancedOptions.RestoreLODDefaults methods set the default clipping planes and LOD settings to their default values, respectively. Most of these advanced options will not be used until IGlobeAdvancedOptions.WriteToRegistry is used to commit the changes to the system registry. See the following illustration:
 

GlobeLegendInfo
This class provides information about a globe layer. The legend information provided by a layer is usually provided by the renderer. See the following illustration:

GlobeLegendInfos
GlobeLegendInfos is a container class for a GlobeLegendInfo class, which provides information about a globe layer. See the following illustration:

GlobeLayer
The GlobeLayer class is used internally and developers should not use it (will be deprecated in future releases). Use classes that implement ILayer and add layer extensions, such as GlobeLayerProperties and GlobeLayerHeight objects to a layer to access globe specific properties. The following are the methods to achieve this:
See the following code example:
[Java] 
void addRasterLayerToGlobe(RasterLayer rasterLayer, Globe globe)throws
    AutomationException, IOException{
    globe.addLayerType(rasterLayer, esriGlobeLayerType.esriGlobeLayerTypeElevation,
        false);
}
The following code example shows how to add the layer extension (GlobeLayerProperties) and the GlobeLayerHeight object to set some of the globe specific properties of a layer before adding it to ArcGlobe:
[Java] 
void addLyrExtension(RasterLayer rasterLayer, Globe globe)throws AutomationException,
    IOException{
    //
    // Create a GlobeLayerProperties object to add as an extension to the raster layer.
    //
    GlobeLayerProperties globeLayerProperties = new GlobeLayerProperties();
    globeLayerProperties.setType(esriGlobeDataType.esriGlobeDataElevation);
    globeLayerProperties.putLossyCompressionOption(true, (short)70);
    globeLayerProperties.setUse16ElevationBits(false);
    //
    // Create a GlobeHeightProperties object to add to the GlobeLayerProperties.
    //
    GlobeHeightProperties globeHeightProperties = new GlobeHeightProperties();
    globeHeightProperties.setZFactor(0.348); 
        // Apply factor to convert from feet to meters.
    globeLayerProperties.setHeightPropertiesByRef(globeHeightProperties);
    //
    // Add the properties as an extension.
    //
    rasterLayer.addExtension(globeLayerProperties);
    //
    // Verify if an extension is added.
    //
    int extensionCount = rasterLayer.getExtensionCount();
    System.out.println("Number of extensions: " + rasterLayer.getExtensionCount());
    for (int j = 0; j < extensionCount; j++){
        if (rasterLayer.getExtension(j)instanceof IGlobeLayerProperties){
            globeLayerProperties = (GlobeLayerProperties)rasterLayer.getExtension(j);
            System.out.println("Layer " + j + " has ZFactor of " +
                globeLayerProperties.getHeightProperties().getZFactor());
        }
    }
    //
    // Verify the previously set Globelayer property is honored.
    // By default, when a raster layer is added, it will be treated as an image texture(?).
    // However, since the globe layer property type is set to esriGlobeDataElevation, 
    // it should have been added as an elevation layer.
    //
    GlobeDisplay globeDisplay = (GlobeDisplay)globe.getGlobeDisplay();
    System.out.print("Layer property type: ");
    switch (globeDisplay.findGlobeProperties(rasterLayer).getType()){
        case esriGlobeDataType.esriGlobeDataElevation:
            System.out.println("Elevation");
            break;
        case esriGlobeDataType.esriGlobeDataInvalid:
            System.out.println("Invalid");
            break;
        case esriGlobeDataType.esriGlobeDataObject:
            System.out.println("Object");
            break;
        case esriGlobeDataType.esriGlobeDataPoint:
            System.out.println("Point");
            break;
        case esriGlobeDataType.esriGlobeDataText:
            System.out.println("Text");
            break;
        case esriGlobeDataType.esriGlobeDataTexture:
            System.out.println("Texture");
            break;
        case esriGlobeDataType.esriGlobeDataVector:
            System.out.println("Vector");
            break;
        default:
            System.out.println("?");
            break;
    }
}