Add raster data

You can add raster data stored on your device or raster data from an image service by performing one of the following tasks:

Adding a raster to a map or scene using a raster layer if you want to display the raster
Adding a raster to a map or scene for use with a raster function

Raster data provides a unique way to analyze and visualize geographic phenomena. Rasters consist of a matrix of cells, with each cell containing a value. Rasters can have multiple dimensions or bands, for example, the red, green, and blue channels in an aerial photo. Rasters are different from vectors, which use points, lines, and polygons to represent features. For more information on raster data, including advantages and disadvantages of using it, see What is raster data? and Imagery and raster in ArcGIS Pro in the ArcGIS Desktop help.

Raster data is represented by the Raster class. Your app can work with many sources of raster data including raster files, mosaic datasets, raster data shared through image services, or the results of raster functions. A raster function can take any of these rasters as input for analysis.

The Raster object implements the loadable pattern described in Loading resources asynchronously and asynchronously accesses raster data from remote services or datasets.

Raster data supports the identify operation to obtain RasterCell values when a user clicks on a pixel in a RasterLayer in a MapView or SceneView.

Create a raster from a raster file

To add raster files stored on your desktop or device to your app, create a Raster object using the path of the raster file.

Use dark colors for code blocksCopy
    // Create a new raster based on the path provided.
    Raster* raster = new Raster(m_localRasterFilePath, this);

Load a raster from a GeoPackage

A GeoPackage is an open, standards-based, platform-independent, portable, self-describing, compact format for transferring geospatial information. It is a platform-independent SQLite database file that contains data and metadata tables. For details, refer to the OGC GeoPackage specification. You can read a local GeoPackage and load the feature tables and rasters that it contains.

Open a GeoPackage using the path to the .gpkg file. The GeoPackageRasters property returns a collection of all rasters in the package. You can work with a GeoPackageRaster as you would any other Raster, including adding it as a RasterLayer to your app's map.

Use dark colors for code blocksCopy
    // Create a bew geo package (.gpkg) based on the path provided.
    GeoPackage* gpkg = new GeoPackage(gpkgFilePath, this);

    // Signal/slot that loads a geo package.
    connect(gpkg, &GeoPackage::doneLoading, this, [gpkg, this](const Error& loadError)
    {
        // Check for load errors and display a message if needed.
        if (!loadError.isEmpty())
        {
            qDebug() << "Error loading GeoPackage" << loadError.message() << loadError.additionalMessage();
            return;
        }

        // Get the collection of rasters in the package.
        const QList<GeoPackageRaster*> packageRasters = gpkg->geoPackageRasters();

        // Get the first raster in the collection.
        GeoPackageRaster* gpkgRaster = packageRasters.first();

        // Create a RasterLayer using the GeoPackageRaster (which inherits from Raster).
        RasterLayer* rasterLayer = new RasterLayer(gpkgRaster, this);

        // Add the layer to the map.
        m_map->operationalLayers()->append(rasterLayer);
    });

    // Call the load function which uses the connect signal/slot above.
    gpkg->load();

Create a raster from a mobile mosaic dataset

Raster data stored in a mobile mosaic dataset should be read through the MosaicDatasetRaster, which inherits from Raster. The MosaicDatasetRaster object is instantiated with a path of the mobile geodatabase and a name of the dataset.

Use dark colors for code blocksCopy
    // Create a mosaic raster data using the supplied path and table name.
    MosaicDatasetRaster* mosaicDatasetRaster = new MosaicDatasetRaster(localMdsSqliteFilePath, localMdsTableName, this);

Create a mobile mosaic dataset and add raster files

MosaicDatasetRaster can also be used to create a mobile mosaic dataset in a new mobile geodatabase and save it to the device. After the mobile mosaic dataset is created, individual raster files can be asynchronously added to it. The mobile geodatabase is created when the MosaicDatasetRaster is loaded successfully.

Use dark colors for code blocksCopy
    // Define the path for the gdb file.
    const QString gdbFilePath = QDir::toNativeSeparators(QDir::homePath() + m_geodatabase);

    // Create a mosaic dataset raster using the gdb file path, table name, and spatial reference.
    m_mosaicDatasetRaster = MosaicDatasetRaster::create(gdbFilePath, m_tableName, SpatialReference::webMercator());

    // Signal/slot that loads a mosaic dataset raster.
    connect(m_mosaicDatasetRaster, &MosaicDatasetRaster::loadStatusChanged, this, [this](LoadStatus loadStatus)
    {
        // Proceed if the load status is loaded.
        if (loadStatus == LoadStatus::Loaded)
        {
            // Define the add raster parementers.
            AddRastersParameters addRastersParameters;

            // Set the raster parameters input directory to the path supplied.
            addRastersParameters.setInputDirectory(QDir::toNativeSeparators(QDir::homePath() + m_inputDirectoryUrl));

            // Set the raster parameters filter to the string supplied.
            addRastersParameters.setFilter("tif$"); // Regex filter

            // Asynchronously call the add rasters async method on the mosaic dataset raster using the parameters defined.
            m_mosaicDatasetRaster->addRastersAsync(addRastersParameters).then(this, [this]()
            {
                // Create a new raster layer using the mosaic dataset raster.
                m_rasterLayer = new RasterLayer(m_mosaicDatasetRaster, this);

                // Add the raster layer to the maps operational layer list model collection.
                m_map->operationalLayers()->append(m_rasterLayer);
            });
        }
    });

    // Call the load function which uses the connect signal/slot above.
    m_mosaicDatasetRaster->load();

Use the AddRastersParameters class to perform tasks, such as the following:

Set the input directory containing the raster files to be added
Control other properties of the mosaic, such as minimum and maximum pixel sizes

Create a raster from an image service

Raster and image data can be shared as an image service using ArcGIS Server. An image service provides access to raster data through a web service. A single raster dataset or a mosaic dataset that contains a collection of raster datasets can be served as one image service. The mosaic dataset can dynamically process and mosaic the images on the fly. An image service supports accessing both the mosaicked image and its catalog, as well as individual rasters in the catalog. For more information on image services, see Key concepts for image services in the ArcGIS help.

Use the ImageServiceRaster class to work with image services in your app. You can create an ImageServiceRaster with the URL of an image service. And if you want to display the raster data on a map, create a raster layer for it.

For mosaicked images, a mosaic rule defines how the individual rasters are combined. You can use the default rule defined with the service or, starting with 100.9.0, define rule settings to control how overlapping areas in the mosaic are handled. In addition to how it's displayed, the mosaic rule may effect values returned when identifying, computing a histogram, or exporting the image.

ImageServiceRaster is a subclass of Raster, so any operation that can be applied to the Raster class, such as raster functions, can also be applied to ImageServiceRaster. Besides the common properties inherited from the Raster class, ImageServiceRaster has additional properties and capabilities, such as the image service metadata and rendering rules. After the image service raster has been loaded, the metadata of the image service can be retrieved through the service info property, which is represented by ArcGISImageServiceInfo. However, only a subset of the metadata, including attribution text and a list of information on predefined service rendering rules, is exposed by this API. For more information on the metadata of an image service, see Image Service in the ArcGIS services reference.

Use dark colors for code blocksCopy
    // Create a new image service raster using the Url provided.
    ImageServiceRaster* imageServiceRaster = new ImageServiceRaster(imageServiceUrl, this);

    // Proceed if we created a valid image service raster.
    if (imageServiceRaster)
    {
        // Signal/slot that loads an image service raster.
        connect(imageServiceRaster, &ImageServiceRaster::doneLoading, this, [this, imageServiceRaster]()
        {
            // Create a new raster layer based on the image service raster.
            RasterLayer* rasterLayer = new RasterLayer(imageServiceRaster, this);

            // Proceed if we have a valid raster layer.
            if (rasterLayer)
            {
                // Signal/slot that loads a raster layer.
                connect(rasterLayer, &RasterLayer::doneLoading, this, [this, rasterLayer]()
                {
                    // Clear out an existing layers in the map.
                    m_map->operationalLayers()->clear();

                    // Add the raster layer to the maps operational layer list model collection.
                    m_map->operationalLayers()->append(rasterLayer);
                });

                // Call the load function which uses the connect signal/slot above.
                rasterLayer->load();
            }
        });

        // Call the load function which uses the connect signal/slot above.
        imageServiceRaster->load();
    }

Create a raster from a raster function

Raster functions can be applied to a raster to process that data. This processing is not permanently applied to the data; instead, it is applied on the fly as the rasters are accessed.

A subset of raster functions is supported.

Use dark colors for code blocksCopy
    // Create a new raster function using the provided path to the .json file.
    RasterFunction* rasterFunction = new RasterFunction(dataPath + "/hillshade_simplified.json", this);

    // Get the raster function argumemtns from the raster function.
    RasterFunctionArguments* arguments = rasterFunction->arguments();

    // Set the raster using the supplied name and image service raster object in the raster function arguments.
    arguments->setRaster("raster", imageServiceRaster);

    // Create a new raster using the the raster function.
    Raster* raster = new Raster(rasterFunction, this);

    // Create a new raster layer using the raster.
    RasterLayer* rasterLayer = new RasterLayer(raster, this);

Supported raster functions

The supported raster functions are detailed in this section, along with the syntax for using them. Note that the syntax is similar to the ArcGIS REST syntax for the same functions but is not exactly the same.

The general syntax for raster functions is the following:

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"<Raster Function Name>"},
  "raster_function_arguments":
  {
    "argument1":"<JSON Value Object>",
    "argument2":"<JSON Value Object>",
    "argumentN":"<JSON Value Object>",
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Clip

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Clip_function"},
  "raster_function_arguments":
  {
    "minx":{"double":value,"type":"Raster_function_variable"},
    "miny":{"double":value,"type":"Raster_function_variable"},
    "maxx":{"double":value,"type":"Raster_function_variable"},
    "maxy":{"double":value,"type":"Raster_function_variable"},
    "dx":{"double":cell_size_x,"type":"Raster_function_variable"},
    "dy":{"double":cell_size_y,"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Colormap

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Colormap_function"},
  "raster_function_arguments":
  {
    "raster_colormap":{"colors":[color1,color2,...,colorN],"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Colormap_to_RGB

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Colormap_to_RGB_function"},
  "raster_function_arguments":
  {
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Color_ramp

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Color_ramp_function"},
  "raster_function_arguments":
  {
    "resizable":{"bool":false,"type":"Raster_function_variable"},
    "color_ramp":
    {
      "color_ramp":
      {
        "ramps":
        [
         {"to_color":[0,255,0],"from_color":[0,191,191],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[255,255,0],"from_color":[0,255,0],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[255,127,0],"from_color":[255,255,0],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[191,127,63],"from_color":[255,127,0],"num_colors":3932,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"},
         {"to_color":[20,20,20],"from_color":[191,127,63],"num_colors":3935,"type":"Algorithmic_color_ramp","algorithmic_type":"hsv"}
        ],
        "type":"Multipart_color_ramp"
      },
      "type":"Raster_function_variable"
    },
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Composite_band

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Composite_band_function"},
  "raster_function_arguments":
  {
    "raster_names":{"name":"raster_names","string_array":["r1","r2","r3","r4"],"type":"Raster_function_variable"},
    "r1":{"name":"r1","is_raster":true,"type":"Raster_function_variable"},
    "r2":{"name":"r2","is_raster":true,"type":"Raster_function_variable"},
    "r3":{"name":"r3","is_raster":true,"type":"Raster_function_variable"},
    "r4":{"name":"r4","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Extract_band

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Extract_band_function"},
  "raster_function_arguments":
  {
    "exact_match":{"bool":false,"type":"Raster_function_variable"},
    "band_indexes":{"int_array":[2,1,0],"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Geometric

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Geometric_function"},
  "raster_function_arguments":
  {
    "raster_transform":{"raster_transform":"Raster Transform JSON object","type":"Raster_function_variable"},
    "z_offset":{"double":0,"type":"Raster_function_variable"},
    "z_factor":{"double":1,"type":"Raster_function_variable"},
    "raster":{"is_raster":true,"name":"raster","type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Hillshade

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Hillshade_function"},
  "raster_function_arguments":
  {
    "z_factor":{"double":0.0002,"type":"Raster_function_variable"},
    "slope_type":{"raster_slope_type":"none","type":"Raster_function_variable"},
    "azimuth":{"double":315,"type":"Raster_function_variable"},
    "altitude":{"double":45,"type":"Raster_function_variable"},
    "nbits":{"int":8,"type":"Raster_function_variable"}, // Number of bits per pixel for output raster
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Mask

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Mask_function"},
  "raster_function_arguments":
  {
    "nodata_values":{"double_array":[value1, value2, ..., valueN],"type":"Raster_function_variable"},
    "nodata_interpretation":{"nodata_interpretation":"all","type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Pansharpen

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Pansharpen_function"},
  "raster_function_arguments":
  {
    "weights":{"double_array":[0.10000000000000001,0.5,0.40000000000000002,0.29999999999999999],"type":"Raster_function_variable"},
    "pansharpen_type":{"pansharpen_type":"gram_schmidt","type":"Raster_function_variable"},
    "pan_raster":{"name":"pan_raster","is_raster":true,"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Raster_calculator

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Raster_calculator_function"},
  "raster_function_arguments":
  {
    "expression":{"string":"r1 + r2","name":"expression","type":"Raster_function_variable"},
    "raster_names":{"name":"raster_names","type":"Raster_function_variable"},
    "raster_names":{"name":"raster_names","string_array":["r1","r2"],"type":"Raster_function_variable"},
    "r1":{"name":"r1","is_raster":true,"type":"Raster_function_variable"},
    "r2":{"name":"r2","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Stretch

Use dark colors for code blocksCopy
{
  "raster_function":{"type":"Stretch_function"},
  "raster_function_arguments":
  {
    "stretch_type":{"raster_stretch_type":"minimum_maximum","type":"Raster_function_variable"},
    "min_values":{"double_array":[-10977],"type":"Raster_function_variable"},
    "max_values":{"double_array":[8685],"type":"Raster_function_variable"},
    "estimate_stats":{"bool":false,"type":"Raster_function_variable"},
    "raster":{"name":"raster","is_raster":true,"type":"Raster_function_variable"},
    "type":"Raster_function_arguments"
  },
  "type":"Raster_function_template"
}

Add a raster using a raster layer

It's not necessary to display the raster data you work with in your app. However, if you want your users to view raster data on a map, add the raster using the RasterLayer class. RasterLayer can render raster data from any type of raster. See Layers for more information about creating and working with raster layers.

Use dark colors for code blocksCopy
    // Create a new raster using the supplied path to a .tif file.
    Raster* raster = new Raster(dataPath + "/Shasta.tif", this);

    // Create a new raster layer using the supplied raster.
    RasterLayer* rasterLayer = new RasterLayer(raster, this);

    // Create a new basemap using the raster layer.
    Basemap* basemap = new Basemap(rasterLayer, this);

    // Set the member m_map variable to the newly created new map using the base map.
    m_map = new Map(basemap, this);

    // Set the map views map to the member m_map variable.
    m_mapView->setMap(m_map);

You can add a raster layer to a map as either a basemap or an operational layer. When adding a raster layer as an operational layer to a map with different spatial reference, the layer will be reprojected on the fly and added to the map.

Use dark colors for code blocksCopy
    // Create a new raster layer using the supplied raster.
    RasterLayer* rasterLayer = new RasterLayer(raster, this);

    // Signal/slot that loads a raster layer.
    connect(rasterLayer, &RasterLayer::doneLoading, this, [this, rasterLayer](Error loadError)
    {
        // Proceed if we do not have an error.
        if (!loadError.isEmpty())
            return;

        // Center the map view to the center of thefull extent of the  raster layer at the scale provided.
        m_mapView->setViewpointCenterAsync(rasterLayer->fullExtent().center(), 80000);

        // Add the raster layer to the maps operational layer list model collection.
        m_map->operationalLayers()->append(rasterLayer);
    });

    // Call the load function which uses the connect signal/slot above.
    rasterLayer->load();

You can also change the renderer to control how the data is visualized on the map.

See Layers for more information about creating and working with raster layers.

Supported raster formats

This API supportes a subset of raster file formats that ArcGIS Desktop supports. The supported raster file formats include:

ASRP/USRP
CRF
DTED0, 1, 2
GeoTIFF
HFA
HRE
IMG
JPEG
JPEG 2000
MrSID, generations 2, 3, and 4
NITF
PNG
RPF (CIB)
RPF (CADRG)
SRTM1, 2
Mobile mosaic datasets