public abstract class CIMTinRenderer : CIMObject, System.ComponentModel.INotifyPropertyChanged, System.Xml.Serialization.IXmlSerializable  

{
  // Note: Needs QueuedTask to run
  {
    // get the list of renderers
    IReadOnlyList<CIMTinRenderer> renderers = surfaceLayer.GetRenderers();

    // get the renderers as a dictionary
    Dictionary<SurfaceRendererTarget, CIMTinRenderer> dict = surfaceLayer.GetRenderersAsDictionary();
  }
}

{
  // 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);
    }
  }
}

{
  // 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);
    }
  }
}

{
  // 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);
    }
  }
}

{
  // 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);
    }
  }
}

{
  // 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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}

{
  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);
    }
  }
}