CanSetRenderer Method (SurfaceLayer)

In This Topic

Determines whether a renderer is valid and can be applied for the surface layer and target, This method must be called on the MCT. Use QueuedTask.Run.

Syntax

Visual Basic (Declaration)
C#

Public Function CanSetRenderer( _
   ByVal renderer As CIMTinRenderer, _
   ByVal surfaceRendererTarget As SurfaceRendererTarget _
) As Boolean

public bool CanSetRenderer( 
   CIMTinRenderer renderer,
   SurfaceRendererTarget surfaceRendererTarget
)

Parameters

renderer: A custom renderer that will be used to draw the surface layer.
surfaceRendererTarget: A SurfaceRendererTarget indicating the intended usage of the renderer.

Return Value

A boolean indicates that the renderer can be applied to the layer.

Exceptions

Exception	Description
ArcGIS.Core.CalledOnWrongThreadException	This method or property must be called within the lambda passed to QueuedTask.Run.

Remarks

It is important to call this method prior to SetRenderer as some renderers are only appropriate for certain layer types and can only be applied for a specified SurfaceRendererTarget. For example a ArcGIS.Core.CIM.CIMTinNodeRenderer applies only to a TIN layer and can only be set to a target of SurfaceRendererTarget.Points.

Example

Simple Node Renderer

{
  // applies to TIN layers only
  var nodeRendererDef = new TinNodeRendererDefinition();
  nodeRendererDef.Description = "Nodes";
  nodeRendererDef.Label = "Nodes";
  nodeRendererDef.SymbolTemplate = nodeSymbol.MakeSymbolReference();

  // Note: Needs QueuedTask to run
  {
    if (tinLayer.CanCreateRenderer(nodeRendererDef))
    {
      CIMTinRenderer renderer = tinLayer.CreateRenderer(nodeRendererDef);
      if (tinLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
        tinLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
    }
  }
}

Elevation Node Renderer - Equal Breaks

{
  // applies to TIN layers only
  var equalBreaksNodeRendererDef = new TinNodeClassBreaksRendererDefinition();
  equalBreaksNodeRendererDef.BreakCount = 7;
  // Note: Needs QueuedTask to run
  {
    if (tinLayer.CanCreateRenderer(equalBreaksNodeRendererDef))
    {
      CIMTinRenderer renderer = tinLayer.CreateRenderer(equalBreaksNodeRendererDef);
      if (tinLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Edges))
        tinLayer.SetRenderer(renderer, SurfaceRendererTarget.Edges);
    }
  }
}

Elevation Node Renderer - Defined Interval

{
  // applies to TIN layers only
  var defiendIntervalNodeRendererDef = new TinNodeClassBreaksRendererDefinition();
  defiendIntervalNodeRendererDef.ClassificationMethod = ClassificationMethod.DefinedInterval;
  defiendIntervalNodeRendererDef.IntervalSize = 4;
  defiendIntervalNodeRendererDef.SymbolTemplate = nodeSymbol.MakeSymbolReference();
  // Note: Needs QueuedTask to run
  {
    if (tinLayer.CanCreateRenderer(defiendIntervalNodeRendererDef))
    {
      CIMTinRenderer renderer = tinLayer.CreateRenderer(defiendIntervalNodeRendererDef);
      if (tinLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Edges))
        tinLayer.SetRenderer(renderer, SurfaceRendererTarget.Edges);
    }
  }
}

Elevation Node Renderer - Standard Deviation

{
  // applies to TIN layers only
  var stdDevNodeRendererDef = new TinNodeClassBreaksRendererDefinition();
  stdDevNodeRendererDef.ClassificationMethod = ClassificationMethod.StandardDeviation;
  stdDevNodeRendererDef.DeviationInterval = StandardDeviationInterval.OneHalf;
  stdDevNodeRendererDef.ColorRamp = ColorFactory.Instance.GetColorRamp("Cyan to Purple");
  // Note: Needs QueuedTask to run
  {
    if (tinLayer.CanCreateRenderer(stdDevNodeRendererDef))
    {
      CIMTinRenderer renderer = tinLayer.CreateRenderer(stdDevNodeRendererDef);
      if (tinLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Edges))
        tinLayer.SetRenderer(renderer, SurfaceRendererTarget.Edges);
    }
  }
}

Simple Edge Renderer

{
  // applies to TIN or LAS dataset layers only
  var edgeRendererDef = new TinEdgeRendererDefintion();
  edgeRendererDef.Description = "Edges";
  edgeRendererDef.Label = "Edges";
  edgeRendererDef.SymbolTemplate = lineSymbol.MakeSymbolReference();
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(edgeRendererDef))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(edgeRendererDef);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Edges))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Edges);
    }
  }
}

Edge Type Renderer

{
  var breaklineRendererDef = new TinBreaklineRendererDefinition();
  // use default symbol for regular edge but specific symbols for hard,soft,outside
  breaklineRendererDef.HardEdgeSymbol = hardEdgeSymbol.MakeSymbolReference();
  breaklineRendererDef.SoftEdgeSymbol = softEdgeSymbol.MakeSymbolReference();
  breaklineRendererDef.OutsideEdgeSymbol = outsideEdgeSymbol.MakeSymbolReference();
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(breaklineRendererDef))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(breaklineRendererDef);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Edges))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Edges);
    }
  }
}

Contour Renderer

{
  var contourDef = new TinContourRendererDefinition();

  // now customize with a symbol
  contourDef.Label = "Contours";
  contourDef.SymbolTemplate = contourLineSymbol.MakeSymbolReference();
  contourDef.ContourInterval = 6;

  contourDef.IndexLabel = "Index Contours";
  contourDef.IndexSymbolTemplate = indexLineSymbol.MakeSymbolReference();
  contourDef.ContourFactor = 4;
  contourDef.ReferenceHeight = 7;
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(contourDef))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(contourDef);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Contours))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Contours);
    }
  }
}

Simple Face Renderer

{
  var simpleFaceRendererDef = new TinFaceRendererDefinition();
  simpleFaceRendererDef.SymbolTemplate = polySymbol.MakeSymbolReference();
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(simpleFaceRendererDef))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(simpleFaceRendererDef);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Surface))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Surface);
    }
  }
}

Aspect Face Renderer

{
  var aspectFaceRendererDef = new TinFaceClassBreaksAspectRendererDefinition();
  aspectFaceRendererDef.SymbolTemplate = polySymbol.MakeSymbolReference();
  // accept default color ramp

  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(aspectFaceRendererDef))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(aspectFaceRendererDef);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Surface))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Surface);
    }
  }
}

Slope Face Renderer - Equal Interval

{
  var slopeFaceClassBreaksEqual = new TinFaceClassBreaksRendererDefinition(TerrainDrawCursorType.FaceSlope);
  // accept default breakCount, symbolTemplate, color ramp
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(slopeFaceClassBreaksEqual))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(slopeFaceClassBreaksEqual);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Surface))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Surface);
    }
  }
}

Slope Face Renderer - Quantile

{
  var slopeFaceClassBreaksQuantile = new TinFaceClassBreaksRendererDefinition(TerrainDrawCursorType.FaceSlope);
  slopeFaceClassBreaksQuantile.ClassificationMethod = ClassificationMethod.Quantile;
  // accept default breakCount, symbolTemplate, color ramp
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(slopeFaceClassBreaksQuantile))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(slopeFaceClassBreaksQuantile);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Surface))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Surface);
    }
  }
}

Elevation Face Renderer - Equal Interval

{
  var elevFaceClassBreaksEqual = new TinFaceClassBreaksRendererDefinition();
  // accept default breakCount, symbolTemplate, color ramp
  // Note: Needs QueuedTask to run
  {
    if (surfaceLayer.CanCreateRenderer(elevFaceClassBreaksEqual))
    {
      CIMTinRenderer renderer = surfaceLayer.CreateRenderer(elevFaceClassBreaksEqual);
      if (surfaceLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Surface))
        surfaceLayer.SetRenderer(renderer, SurfaceRendererTarget.Surface);
    }
  }
}

Dirty Area Renderer

{
  var dirtyAreaRendererDef = new TerrainDirtyAreaRendererDefinition();
  // accept default labels, symbolTemplate

  if (terrainLayer == null)
    return;
  // Note: Needs QueuedTask to run
  {
    if (terrainLayer.CanCreateRenderer(dirtyAreaRendererDef))
    {
      CIMTinRenderer renderer = terrainLayer.CreateRenderer(dirtyAreaRendererDef);
      if (terrainLayer.CanSetRenderer(renderer, SurfaceRendererTarget.DirtyArea))
        terrainLayer.SetRenderer(renderer, SurfaceRendererTarget.DirtyArea);
    }
  }
}

Terrain Point Class Breaks Renderer

{
  var terrainPointClassBreaks = new TerrainPointClassBreaksRendererDefinition();
  // accept defaults
  // Note: Needs QueuedTask to run
  {
    if (terrainLayer.CanCreateRenderer(terrainPointClassBreaks))
    {
      CIMTinRenderer renderer = terrainLayer.CreateRenderer(terrainPointClassBreaks);
      if (terrainLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
        terrainLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
    }
  }
}

LAS Points Classification Unique Value Renderer

{
  var lasPointsClassificationRendererDef = new LasUniqueValueRendererDefinition(LasAttributeType.Classification);
  // accept the defaults for color ramp, symbolTemplate, symbol scale factor

  if (lasDatasetLayer == null)
    return;
  // Note: Needs QueuedTask to run
  {
    if (lasDatasetLayer.CanCreateRenderer(lasPointsClassificationRendererDef))
    {
      CIMTinRenderer renderer = lasDatasetLayer.CreateRenderer(lasPointsClassificationRendererDef);
      if (lasDatasetLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
        lasDatasetLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
    }
  }
}

LAS Points Returns Unique Value Renderer

{
  var lasPointsReturnsRendererDef = new LasUniqueValueRendererDefinition(LasAttributeType.ReturnNumber);
  lasPointsReturnsRendererDef.ModulateUsingIntensity = true;
  lasPointsReturnsRendererDef.SymbolScaleFactor = 1.0;
  // accept the defaults for color ramp, symbolTemplate
  // Note: Needs QueuedTask to run
  {
    if (lasDatasetLayer.CanCreateRenderer(lasPointsReturnsRendererDef))
    {
      CIMTinRenderer renderer = lasDatasetLayer.CreateRenderer(lasPointsReturnsRendererDef);
      if (lasDatasetLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
        lasDatasetLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
    }
  }
}

LAS Points Elevation Stretch Renderer

{
  var elevLasStretchRendererDef = new LasStretchRendererDefinition(ArcGIS.Core.CIM.LASStretchAttribute.Elevation);
  // accept the defaults for color ramp, etc

  if (lasDatasetLayer.CanCreateRenderer(elevLasStretchRendererDef))
  {
    CIMTinRenderer renderer = lasDatasetLayer.CreateRenderer(elevLasStretchRendererDef);
    if (lasDatasetLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
      lasDatasetLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
  }
  // OR use a stretch renderer with stretchType standard Deviations
  var elevLasStretchStdDevRendererDef = new LasStretchRendererDefinition(ArcGIS.Core.CIM.LASStretchAttribute.Elevation);
  elevLasStretchStdDevRendererDef.StretchType = LASStretchType.StandardDeviations;
  elevLasStretchStdDevRendererDef.NumberOfStandardDeviations = 2;
  // accept the defaults for color ramp,  etc
  // Note: Needs QueuedTask to run
  {
    if (lasDatasetLayer.CanCreateRenderer(elevLasStretchStdDevRendererDef))
    {
      CIMTinRenderer renderer = lasDatasetLayer.CreateRenderer(elevLasStretchStdDevRendererDef);
      if (lasDatasetLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
        lasDatasetLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
    }
  }
}

LAS Points Classified Elevation Renderer

{
  var lasPointsClassBreaksRendererDef = new LasPointClassBreaksRendererDefinition();
  lasPointsClassBreaksRendererDef.ClassificationMethod = ClassificationMethod.NaturalBreaks;
  lasPointsClassBreaksRendererDef.ModulateUsingIntensity = true;
  // increase the symbol size by a factor
  lasPointsClassBreaksRendererDef.SymbolScaleFactor = 1.0;
  // Note: Needs QueuedTask to run
  {
    if (lasDatasetLayer.CanCreateRenderer(lasPointsClassBreaksRendererDef))
    {
      CIMTinRenderer renderer = lasDatasetLayer.CreateRenderer(lasPointsClassBreaksRendererDef);
      if (lasDatasetLayer.CanSetRenderer(renderer, SurfaceRendererTarget.Points))
        lasDatasetLayer.SetRenderer(renderer, SurfaceRendererTarget.Points);
    }
  }
}

Requirements

Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

ArcGIS Pro version: 3.2 or higher.

Reference

SurfaceLayer Class
SurfaceLayer Members

Send feedback