CanCreateRenderer Method (SurfaceLayer)

In This Topic

Determines whether a renderer can be created and is valid for the surface layer using the specified TinRendererDefinition. This method must be called on the MCT. Use QueuedTask.Run.

Syntax

Visual Basic (Declaration)
C#

Public Function CanCreateRenderer( _
   ByVal rendererDefinition As TinRendererDefinition _
) As Boolean

public bool CanCreateRenderer( 
   TinRendererDefinition rendererDefinition
)

Parameters

rendererDefinition: A renderer definition object.

Return Value

A boolean indicates that a renderer can be created for 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 CreateRenderer as some renderers are only appropriate for certain layer types or for displaying features of a certain geometry type. For example a TinNodeRendererDefinition can only be applied to a TIN layer. It cannot be applied to a Terrain layer or a LAS dataset layer.

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