Map service GetLayerTile method

Gets the image tile from a layer cache for a specific location.

GetLayerTile(string MapName, int LayerID, int Level, int Row, int Column, string Format)

Parameter

Description

MapName

The name of the map (data frame) that contains a layer cache.

LayerID

The layer id of the layer on which a cache is available.

Level

The level of detail (scale) of the layer cache from which a tile will be retrieved.

Row

The row in which a tile is located. Row values start at 0 from top of each cache level.

Column

The column in which a tile is located. Column values start at 0 from the left of each cache level.

Format

The image format to retrieve from a cache. This defines the file extension to be used when retrieving the cached tile. A cache can be generated in multiple image formats.

Return Value

A byte array (byte[ ]) containing the raw image content. The image format for the layer cache can be discovered using the TileImageInfo object returned from a call to GetTileImageInfo on the map service proxy. If the image tile is not available, a SOAP exception will be thrown. A tile may not be generated in situations where no layer data was present in the tile extent.

Remarks

In general, this method is used to retrieve image tiles that have been pre-generated (cached) for a single layer. The cache properties such as the number and scale of levels and the physical size of image tiles in pixels can be defined by the map service administrator, thus the values can be arbitrary.

Examples

C#

MapService_MapServer mapservice = new MapService_MapServer();

mapservice.Url = "http://localhost:6080/arcgis/services/MapLayerCache/MapServer";

string mapname = mapservice.GetDefaultMapName();

MapServerInfo mapinfo = mapservice.GetServerInfo(mapname);

MapDescription mapdesc = mapinfo.DefaultMapDescription;

LayerDescription[] layerdescriptions = mapdesc.LayerDescriptions;

// Pixel height and width of map display on the client. In this case, a Windows Form

// PictureBox control.

int picturewidth = pictureBox1.Width;

int pictureheight = pictureBox1.Height;

EnvelopeN mapextent = (EnvelopeN)mapdesc.MapArea.Extent;

// Use map scale resolution (map units per pixel) to determine tile level

double mapresolution = Math.Abs(mapextent.XMax - mapextent.XMin) / picturewidth;

System.Drawing.Bitmap imgbitmap = new System.Drawing.Bitmap(picturewidth, pictureheight);

System.Drawing.Graphics imggraphics = System.Drawing.Graphics.FromImage(imgbitmap);

imggraphics.FillRectangle(new System.Drawing.SolidBrush(System.Drawing.Color.LightGray),

0, 0, picturewidth, pictureheight);

int layerdesc_maxindex = layerdescriptions.Length - 1;

// Iterate through layers bottom up. Polygons on bottom, then lines, then points.

for (int d = layerdesc_maxindex; d >= 0; d--)

{

      LayerDescription layerdesc = layerdescriptions[d];

      if (mapservice.HasLayerCache(mapname, layerdesc.LayerID))

      {

            TileCacheInfo tci = mapservice.GetTileCacheInfo(mapservice.GetDefaultMapName());

            LODInfo[] tcis = tci.LODInfos;

            // Map units per pixel

            double tileresolution = 0;

            //Scale level

            int tilelevel = 0;

            foreach (LODInfo ldi in tcis)

            {

                  tileresolution = ldi_resolution;
      
                  tilelevel = ldi.LevelID;

                  if (mapresolution >= ldi_resolution)

                  {

                        break;

                  }

            }

            // Measured from the origin

            double minx = mapextent.XMin;

            double miny = mapextent.YMin;

            double maxx = mapextent.XMax;

            double maxy = mapextent.YMax;

            >// Origin of the cache (upper left corner)

            double xorigin = ((PointN)tci.TileOrigin).X;

            double yorigin = ((PointN)tci.TileOrigin).Y;

            // Get minimum tile column

            double minxtile = (minx - xorigin) / (tci.TileCols * tileresolution);

            // Get minimum tile row

            // From the origin, maxy is minimum y

            double minytile = (yorigin - maxy) / (tci.TileRows * tileresolution);

            // Get maximum tile column

            double maxxtile = (maxx - xorigin) / (tci.TileCols * tileresolution);

            // Get maximum tile row

            // From the origin, miny is maximum y

            double maxytile = (yorigin - miny) / (tci.TileRows * tileresolution);

            // Return integer value for min and max, row and column

            int mintilecolumn = (int)Math.Floor(minxtile);

            int mintilerow = (int)Math.Floor(minytile);

            int maxtilecolumn = (int)Math.Floor(maxxtile);

            int maxtilerow = (int)Math.Floor(maxytile);

            // Origin of the min tile

            double xmintileorigin = xorigin + (mintilecolumn * (tci.TileCols * tileresolution));

            double ymintileorigin = yorigin - (mintilerow * (tci.TileRows * tileresolution));

            // Since the origin of the extent and origin of the min tile are different

            // get the difference and use to place consolidated image graphic in correct location

            double xadjust = Math.Abs(minx - xmintileorigin);

            double yadjust = Math.Abs(maxy - ymintileorigin);

            int xpixadjust = (int)(xadjust / tileresolution);

            int ypixadjust = (int)(yadjust / tileresolution);

            TileImageInfo tii = mapservice.GetTileImageInfo(mapservice.GetDefaultMapName());

            int rowindex = 0;

            // for each row in the map extent

            for (int row = mintilerow; row <= maxtilerow;row++)

            {

                  int colindex = 0;

                  // for each column in the row, in the map extent

                  for (int col = mintilecolumn; col <= maxtilecolumn; col++)

                  {

                        byte[] myByteArray = null;

                        try

                        {

                              // Return the byte array of the tile image

                              myByteArray = mapservice.GetLayerTile(mapservice.GetDefaultMapName(), layerdesc.LayerID,

                              tilelevel, row, col, tii.CacheTileFormat);

                        catch

                        {

                              // Tile may not be available because no data was present when creating the cache

                        }

                        // If Tile was found, add it to the consolidated image graphic

                        if (myByteArray != null)

                        {

                              System.Drawing.Image newImage;

                              using (System.IO.MemoryStream ms = new System.IO.MemoryStream(myByteArray, 0, myByteArray.Length))

                              {

                                    ms.Write(myByteArray, 0, myByteArray.Length);

                                    newImage = Image.FromStream(ms, true);

                                    imggraphics.DrawImage(newImage, (tci.TileCols * colindex) - xpixadjust, (tci.TileRows * rowindex) - ypixadjust,

                                    tci.TileCols, tci.TileRows);

                              }

                        }

                        colindex++;

                  }

                  rowindex++;

            }

      }

}

// Post-processing, if necessary... otherwise just use imgbitmap with PictureBox

System.Drawing.Bitmap picturebitmap = new System.Drawing.Bitmap(picturewidth, pictureheight);

System.Drawing.Graphics graphicsimage = System.Drawing.Graphics.FromImage(picturebitmap);

graphicsimage.FillRectangle(new System.Drawing.SolidBrush(System.Drawing.Color.LightGray),0, 0, picturewidth, pictureheight);

graphicsimage.DrawImage(imgbitmap, 0, 0, picturewidth, pictureheight);

pictureBox1.Image = picturebitmap;

VB.NET

Dim mapservice As MapService_MapServer = New MapService_MapServer()

mapservice.Url = "http://localhost:6080/arcgis/services/MapLayerCache/MapServer"

 

Dim mapname As String = mapservice.GetDefaultMapName()

Dim mapinfo As MapServerInfo = mapservice.GetServerInfo(mapname)

 

Dim mapdesc As MapDescription = mapinfo.DefaultMapDescription

Dim layerdescriptions() As LayerDescription = mapdesc.LayerDescriptions

 

' Pixel height and width of map display on the client. In this case, a Windows Form

' PictureBox control.

Dim picturewidth As Integer = pictureBox1.Width

Dim pictureheight As Integer = pictureBox1.Height

 

Dim mapextent As EnvelopeN = CType(mapdesc.MapArea.Extent, EnvelopeN)

' Use map scale resolution (map units per pixel) to determine tile level

Dim mapresolution As Double = Math.Abs(mapextent.XMax - mapextent.XMin) / picturewidth

Dim imgbitmap As System.Drawing.Bitmap = New System.Drawing.Bitmap(picturewidth, pictureheight)

Dim imggraphics As System.Drawing.Graphics = System.Drawing.Graphics.FromImage(imgbitmap)

imggraphics.FillRectangle(New System.Drawing.SolidBrush(System.Drawing.Color.LightGray), 0, 0, _

picturewidth, pictureheight)

 

Dim layerdesc_maxindex As Integer = layerdescriptions.Length - 1

' Iterate through layers bottom up. Polygons on bottom, then lines, then points.

Dim d As Integer

For d = layerdesc_maxindex To 0 Step d - 1

      Dim layerdesc As LayerDescription = layerdescriptions(d)

      If mapservice.HasLayerCache(mapname, layerdesc.LayerID) Then

            Dim tci As TileCacheInfo = mapservice.GetTileCacheInfo(mapservice.GetDefaultMapName())

            Dim tcis() As LODInfo = tci.LODInfos

 

            ' Map units per pixel

            Dim tileresolution As Double = 0

 

            ' Scale level

                  Dim tilelevel As Integer = 0

            Dim ldi As LODInfo

            For Each ldi In tcis

                  Dim ldi_resolution As Double = ldi.Resolution

                  tileresolution = ldi_resolution

                  tilelevel = ldi.LevelID

                        If mapresolution >= ldi_resolution Then

                              Exit For

                        End If

            Next

 

            ' Measured from the origin

            Dim minx As Double = mapextent.XMin

            Dim miny As Double = mapextent.YMin

            Dim maxx As Double = mapextent.XMax

            Dim maxy As Double = mapextent.YMax

 

            ' Origin of the cache (upper left corner)

            Dim xorigin As Double = (CType(tci.TileOrigin, PointN)).X

            Dim yorigin As Double = (CType(tci.TileOrigin, PointN)).Y

 

            ' Get minimum tile column

            Dim minxtile As Double = (minx - xorigin) / (tci.TileCols * tileresolution)

 

            ' Get minimum tile row

            ' From the origin, maxy is minimum y

            Dim minytile As Double = (yorigin - maxy) / (tci.TileRows * tileresolution)

 

            ' Get maximum tile column

            Dim maxxtile As Double = (maxx - xorigin) / (tci.TileCols * tileresolution)

 

            ' Get maximum tile row

            ' From the origin, miny is maximum y

            Dim maxytile As Double = (yorigin - miny) / (tci.TileRows * tileresolution)

 

            ' Return integer value for min and max, row and column

            Dim mintilecolumn As Integer = CType(Math.Floor(minxtile), Integer)

            Dim mintilerow As Integer = CType(Math.Floor(minytile), Integer)

            Dim maxtilecolumn As Integer = CType(Math.Floor(maxxtile), Integer)

            Dim maxtilerow As Integer = CType(Math.Floor(maxytile), Integer)

 

            ' Origin of the min tile

            Dim xmintileorigin As Double = xorigin + (mintilecolumn * (tci.TileCols * tileresolution))

            Dim ymintileorigin As Double = yorigin - (mintilerow * (tci.TileRows * tileresolution))

 

            ' Since the origin of the extent and origin of the min tile are different

            ' get the difference and use to place consolidated image graphic in correct location

            Dim xadjust As Double = Math.Abs(minx - xmintileorigin)

            Dim yadjust As Double = Math.Abs(maxy - ymintileorigin)

            Dim xpixadjust As Integer = CType((xadjust / tileresolution), Integer)

            Dim ypixadjust As Integer = CType((yadjust / tileresolution), Integer)

            Dim tii As TileImageInfo = mapservice.GetTileImageInfo(mapservice.GetDefaultMapName())

            Dim rowindex As Integer = 0

 

            ' for each row in the map extent

            Dim row As Integer

            For row = mintilerow To maxtilerow Step row + 1

                  Dim colindex As Integer = 0

 

                  ' for each column in the row, in the map extent

                  Dim col As Integer

                  For col = mintilecolumn To maxtilecolumn Step col + 1

                        Dim myByteArray() As Byte = Nothing

                              Try

                              ' Return the byte array of the tile image

                              myByteArray = mapservice.GetLayerTile(mapservice.GetDefaultMapName(), _ layerdesc.LayerID, tilelevel, row, col, tii.CacheTileFormat)

                        Catch

                        ' Tile may not be available because no data was present when creating the cache

                        End Try

 

                        ' If Tile was found, add it to the consolidated image graphic

                        If Not myByteArray Is Nothing Then

                              Dim NewImage As System.Drawing.Image

                              Dim ms As System.IO.MemoryStream = New System.IO.MemoryStream(myByteArray, 0, _ myByteArray.Length)

 

                              Try

                                    ms.Write(myByteArray, 0, myByteArray.Length)

                                    NewImage = Image.FromStream(ms, True)

                                    imggraphics.DrawImage(NewImage, (tci.TileCols * colindex) - xpixadjust, _ (tci.TileRows * rowindex) - ypixadjust, tci.TileCols, tci.TileRows)

                              Finally

                                    ms.Dispose()

                              End Try

 

                        End If

 

                        colindex = colindex + 1

                  Next

 

                  rowindex = rowindex + 1

            Next

      End If

Next

 

' Post-processing, if necessary... otherwise just use imgbitmap with PictureBox

Dim picturebitmap As System.Drawing.Bitmap = New System.Drawing.Bitmap(picturewidth, pictureheight)

Dim graphicsimage As System.Drawing.Graphics = System.Drawing.Graphics.FromImage(picturebitmap)

graphicsimage.FillRectangle(New System.Drawing.SolidBrush(System.Drawing.Color.LightGray), _

0, 0, picturewidth, pictureheight)

graphicsimage.DrawImage(imgbitmap, 0, 0, picturewidth, pictureheight)

pictureBox1.Image = picturebitmap

Java

String serviceURL = "http://localhost:6080/arcgis/services/MapService/MapServer";

MapServerBindingStub mapService = new MapServerBindingStub(serviceURL);

  

String mapName = mapService.getDefaultMapName();

MapServerInfo mapInfo = mapService.getServerInfo(mapName);

MapDescription mapDesc = mapInfo.getDefaultMapDescription();

 

LayerDescription[] layerDescriptions = mapDesc.getLayerDescriptions();

 

int layerdescMaxindex = layerDescriptions.length - 1;

 

EnvelopeN mapExtent = (EnvelopeN)mapDesc.getMapArea().getExtent();

 

//Use map scale resolution (map units per pixel) to determine tile level

double mapResolution = Math.abs(mapExtent.getXMax() - mapExtent.getXMin()) / width;

 

//Iterate through layers bottom up.  Polygons on bottom, then lines, then points.

for (int d = layerdescMaxindex; d >= 0; d--)

{

      LayerDescription layerDesc = layerDescriptions[d];

      if (mapService.hasLayerCache(mapName, layerDesc.getLayerID()))

      {

            TileCacheInfo tci = mapService.getTileCacheInfo(mapName);

            LODInfo[] tcis = tci.getLODInfos();

 

            //Map units per pixel

            double tileResolution = 0;

 

            //Scale level

            int tileLevel = 0;

            for (LODInfo ldi : tcis)

            {

                  double ldiResolution = ldi.getResolution();

                  tileResolution = ldiResolution;

                  tileLevel = ldi.getLevelID();

                  if (mapResolution >= ldiResolution)

                  {

                        break;

                  }

            }

            //Measured from the origin

            double minX = mapExtent.getXMin();

            double minY = mapExtent.getYMin();

            double maxX = mapExtent.getXMax();

            double maxY = mapExtent.getYMax();

 

            //Origin of the cache (upper left corner)

            double xOrigin = ((PointN)tci.getTileOrigin()).getX();

            double yOrigin = ((PointN)tci.getTileOrigin()).getY();

 

            //Get minimum tile column

            double minXTile = (minX - xOrigin) / (tci.getTileCols() * tileResolution);

 

            //Get minimum tile row

            //From the origin, maxY is minimum y

            double minYTile = (yOrigin - maxY) / (tci.getTileRows() * tileResolution);

 

            //Get maximum tile column

            double maxXTile = (maxX - xOrigin) / (tci.getTileCols() * tileResolution);

 

            //Get maximum tile row

            //From the origin, minY is maximum y

            double maxYTile = (yOrigin - minY) / (tci.getTileRows() * tileResolution);

 

            //Return integer value for min and max, row and column

            int minTileColumn = (int)Math.floor(minXTile);

            int minTileRow = (int)Math.floor(minYTile);

            int maxTileColumn = (int)Math.floor(maxXTile);

            int maxTileRow = (int)Math.floor(maxYTile);

            TileImageInfo tii = mapService.getTileImageInfo(mapName);

 

            //for each row in the map extent

            for (int row = minTileRow; row <= maxTileRow; row++)

                  {

                  //for each column in the row, in the map extent

                  for (int col = minTileColumn; col <= maxTileColumn; col++)

                  {

                        //Return the byte array of the tile image

                        byte[] tileByteArray = mapService.getLayerTile(mapName, layerDesc.getLayerID(), tileLevel, row, col, tii.getCacheTileFormat());

                        System.out.println("Tile Byte Array Length: " + tileByteArray.length);

                  }

            }

      }

}

11/8/2016