workspace sdk map extensions

Extending maps

The Workspace SDK provides components for extending Security Center maps with custom objects, layers, and visualizations. Map extensions integrate with both geo-referenced and non-geo-referenced maps.

Map extension components

Note

The map components documented on this page do not require an SDK certificate. The MapDesignerTool and MapDesignerWidget components listed on the components page do require certificates.

Map functionality is extended through several component types:

Component	Purpose
MapObjectProvider	Supplies custom objects to display on maps
MapObjectViewBuilder	Creates visual representations of map objects
MapLayerBuilder	Adds custom overlay layers to maps
MapSearcher	Provides search results for map locations
MapImporter	Imports external map data

MapObjectProvider

A MapObjectProvider supplies custom objects for display on maps. Objects are queried based on the current map context.

Creating a provider

Inherit from MapObjectProvider and implement the Query method:

public sealed class VehicleProvider : MapObjectProvider
{
    public override string Name => "Vehicle Provider";
    public override Guid UniqueId => new Guid("...");

    public override IList<MapObject> Query(MapObjectProviderContext context)
    {
        var map = Workspace.Sdk.GetEntity(context.MapId) as Map;
        if (map?.IsGeoReferenced != true)
            return null;

        return GetVehicleObjects();
    }
}

MapObjectProviderContext

The context provides information about the map being queried:

Property	Description
MapId	The map entity GUID

Registering the provider

public class SampleModule : Module
{
    private VehicleProvider m_provider;

    public override void Load()
    {
        m_provider = new VehicleProvider();
        m_provider.Initialize(Workspace);
        Workspace.Components.Register(m_provider);
    }
}

MapLayerBuilder

A MapLayerBuilder creates custom overlay layers for maps, such as heat maps or data visualizations.

Creating a layer builder

Inherit from MapLayerBuilder:

public sealed class HeatMapLayerBuilder : MapLayerBuilder
{
    public override string Name => "Heat Map Layer";
    public override Guid UniqueId => new Guid("...");

    public override bool IsSupported(MapContext context)
    {
        var map = Workspace.Sdk.GetEntity(context.MapId) as Map;
        return map?.IsGeoReferenced == true;
    }

    public override IList<MapLayer> CreateLayers(MapContext context)
    {
        return new List<MapLayer> { new MyHeatMapLayer(Workspace) };
    }
}

IsSupported method

Override IsSupported to control when the layer is available. Check map properties to determine compatibility:

public override bool IsSupported(MapContext context)
{
    var map = Workspace.Sdk.GetEntity(context.MapId) as Map;
    return map != null && map.IsGeoReferenced;
}

MapContext

The context provides map information:

Property	Description
MapId	The map entity GUID

Combining providers and layers

Map extensions often combine multiple components. A provider supplies data while a layer visualizes it:

public class SampleModule : Module
{
    private VehicleProvider m_provider;
    private VehicleHeatMapBuilder m_layerBuilder;

    public override void Load()
    {
        // Register the data provider
        m_provider = new VehicleProvider();
        m_provider.Initialize(Workspace);
        Workspace.Components.Register(m_provider);

        // Register the layer builder with provider reference
        m_layerBuilder = new VehicleHeatMapBuilder();
        m_layerBuilder.Initialize(Workspace, m_provider);
        Workspace.Components.Register(m_layerBuilder);
    }

    public override void Unload()
    {
        if (m_provider != null)
        {
            Workspace.Components.Unregister(m_provider);
            m_provider.Dispose();
            m_provider = null;
        }

        if (m_layerBuilder != null)
        {
            Workspace.Components.Unregister(m_layerBuilder);
            m_layerBuilder = null;
        }
    }
}

Custom map objects

Create custom map objects by inheriting from MapObject. The base class provides Latitude and Longitude properties that you can override:

public class VehicleMapObject : MapObject
{
    public string VehicleId { get; set; }

    // Latitude and Longitude are inherited from MapObject
    // Override them if you need custom behavior
}

Animating map objects

Update object positions dynamically to create animations:

public void UpdatePosition(GeoCoordinate newPosition)
{
    m_vehicle.Latitude = newPosition.Latitude;
    m_vehicle.Longitude = newPosition.Longitude;
    OnPositionChanged?.Invoke(this, newPosition);
}

MapObjectViewBuilder

Creates visual representations for custom map objects. Register view builders to control how objects appear on maps.

MapSearcher

Implements map search functionality. When users search on maps, your searcher can return matching locations.

Creating a searcher

public class LocationSearcher : MapSearcher
{
    public override string Name => "Location Searcher";
    public override Guid UniqueId => new Guid("...");

    public override IList<MapSearcherResult> Search(MapSearcherContext context)
    {
        // context.Text contains the search query
        // context.MapId is the current map
        // context.ViewArea is the visible map bounds
        return FindMatchingLocations(context.Text);
    }
}

MapImporter

Imports external map data into Security Center. Implement for integrations with external mapping systems.

Geo-referenced maps

Many map extensions only support geo-referenced maps. Check the IsGeoReferenced property:

var map = Workspace.Sdk.GetEntity(mapId) as Map;
if (map?.IsGeoReferenced == true)
{
    // Map supports geographic coordinates
}

For related examples, see the MapControl sample in ControlsSample and the MapObjectsSample on GitHub.