ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Desktop.Mapping Namespace / VoxelLayer Class / SetVisualization Method
The visualization mode to set
Example

In This Topic
    SetVisualization Method
    In This Topic
    Sets the visualization mode. This method must be called on the MCT. Use QueuedTask.Run.
    Syntax
    public void SetVisualization( 
       VoxelVisualization visualization
    )
    Public Sub SetVisualization( _
       ByVal visualization As VoxelVisualization _
    ) 

    Parameters

    visualization
    The visualization mode to set
    Exceptions
    ExceptionDescription
    This method or property must be called within the lambda passed to QueuedTask.Run
    Example
    Change the Voxel Visualization
    {
      await QueuedTask.Run(() =>
      {
        //Change the visualization to Volume
        //e.g. for creating slices
        voxelLayer.SetVisualization(VoxelVisualization.Volume);
    
        //Change the visualization to Surface
        //e.g. to create isosurfaces and sections
        voxelLayer.SetVisualization(VoxelVisualization.Surface);
      });
    }
    Check CanCreateIsoSurface
    {
      //Visualization must be surface or CanCreateIsosurface will return
      //false
      if (voxelLayer.Visualization != VoxelVisualization.Surface)
      {
        voxelLayer.SetVisualization(VoxelVisualization.Surface);
      }
    
      //Get the variable profile on which to create the iso surface
      var variable = voxelLayer.SelectedVariableProfile;
      //or use ...voxelLayer.GetVariableProfiles().First(....
    
      // o Visualization must be Surface
      // o Variable profile must be continuous
      // o Variable MaxNumberofIsoSurfaces must not have been reached...
      if (variable.CanCreateIsosurface)
      {
        //Do the create
      }
    }
    Create Isosurface
    {
      await QueuedTask.Run(() =>
      {
        //Visualization must be surface
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        //Get the variable profile on which to create the iso surface
        var variable = voxelLayer.SelectedVariableProfile;
    
        // o Visualization must be Surface
        // o Variable profile must be continuous
        // o Variable MaxNumberofIsoSurfaces must not have been reached...
        if (variable.CanCreateIsosurface)
        {
          //Note: calling create if variable.CanCreateIsosurface == false
          //will trigger an InvalidOperationException
    
          //Specify a voxel value for the iso surface
    
          var min = variable.Statistics.MinimumValue;
          var max = variable.Statistics.MaximumValue;
          var mid = (max + min) / 2;
    
          //color range (i.e. values that are being rendered)
          var renderer = variable.Renderer as CIMVoxelStretchRenderer;
          var color_min = renderer.ColorRangeMin;
          var color_max = renderer.ColorRangeMax;
    
          //keep the surface within the current color range (or it
          //won't render)
          if (mid < color_min)
          {
            mid = renderer.ColorRangeMin;
          }
          else if (mid > color_max)
          {
            mid = renderer.ColorRangeMax;
          }
    
          //Create the iso surface
          var suffix = Math.Truncate(mid * 100) / 100;
          variable.CreateIsosurface(new IsosurfaceDefinition()
          {
            Name = $"Surface {suffix}",
            Value = mid,
            IsVisible = true
          });
        }
      });
    }
    How to Change Value and Color on an Isosurface
    {
      await QueuedTask.Run(() =>
      {
        var variable = voxelLayer.SelectedVariableProfile;
    
        //Change the color of the first surface for the given profile
        var surface = variable.GetIsosurfaces().FirstOrDefault();
        if (surface != null)
        {
          if (voxelLayer.Visualization != VoxelVisualization.Surface)
          {
            voxelLayer.SetVisualization(VoxelVisualization.Surface);
          }
    
          //Change the iso surface voxel value
          surface.Value = surface.Value * 0.9;
    
          //get a random color
          var count = new Random().Next(0, 100);
          var colors = ColorFactory.Instance.GenerateColorsFromColorRamp(
            ((CIMVoxelStretchRenderer)variable.Renderer).ColorRamp, count);
    
          var idx = new Random().Next(0, count - 1);
          surface.Color = colors[idx];
          //set the custom color flag true to lock the color
          //locking the color prevents it from being changed if the
          //renderer color range or color theme is updated
          surface.IsCustomColor = true;
    
          //update the surface
          variable.UpdateIsosurface(surface);
        }
      });
    }
    Delete Isosurfaces
    {
      await QueuedTask.Run(() =>
      {
        var variable = voxelLayer.SelectedVariableProfile;
    
        //delete the last surface
        var last_surface = variable.GetIsosurfaces().LastOrDefault();
    
        if (last_surface != null)
        {
          variable.DeleteIsosurface(last_surface);
        }
    
        //delete all the surfaces
        foreach (var surface in variable.GetIsosurfaces())
        {
          variable.DeleteIsosurface(surface);
        }
    
        //Optional - set visualization back to Volume
        if (variable.GetIsosurfaces().Count() == 0)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Volume);
        }
      });
    }
    Create a Slice
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Volume)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Volume);
        }
    
        voxelLayer.SetSliceContainerExpanded(true);
        voxelLayer.SetSliceContainerVisibility(true);
    
        //To stop the Voxel Exploration Dockpane activating use:
        voxelLayer.AutoShowExploreDockPane = false;
        //This is useful if u have your own dockpane currently activated...
    
        //Use the SelectedVariableProfile to get the slices currently in the TOC
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var volumeSize = volume.GetVolumeSize();
    
        //Orientation 90 degrees (West), Tilt 0.0 (vertical)
        //Convert to a normal
        var normal = voxelLayer.GetNormal(90, 0.0);
    
        //Create the slice at the voxel mid-point. VoxelPosition
        //is specified in voxel-space coordinates
    
        //Create the slice on the respective volume
        volume.CreateSlice(new SliceDefinition()
        {
          Name = "Middle Slice",
          VoxelPosition = new Coordinate3D(volumeSize.X / 2, volumeSize.Y / 2, volumeSize.Z / 2),
          Normal = normal,
          IsVisible = true
        });
    
        //reset if needed...
        voxelLayer.AutoShowExploreDockPane = true;
      });
    }
    Change Tilt on a Slice
    {
      await QueuedTask.Run(() =>
      {
        //To stop the Voxel Exploration Dockpane activating use:
        voxelLayer.AutoShowExploreDockPane = false;
        //This is useful if u have your own dockpane currently activated...
        //Normally, it would be set in your dockpane
    
        if (voxelLayer.Visualization != VoxelVisualization.Volume)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Volume);
        }
    
        voxelLayer.SetSliceContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the slices currently in the TOC
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var slice = volume.GetSlices().First(s => s.Name == "Change Tilt Slice");
    
        (double orientation, double tilt) = voxelLayer.GetOrientationAndTilt(slice.Normal);
    
        //Convert orientation and tilt to a normal
        slice.Normal = voxelLayer.GetNormal(orientation, 45.0);
        volume.UpdateSlice(slice);
    
        //reset if needed...Normally this might be when your dockpane
        //was de-activated (ie "closed")
        voxelLayer.AutoShowExploreDockPane = true;
      });
    }
    Get the Current Collection of Sections
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections currently in the TOC
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var sections = volume.GetSections();
      });
    }
    Create a Section at the Voxel MidPoint
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //To stop the Voxel Exploration Dockpane activating use:
        voxelLayer.AutoShowExploreDockPane = false;
        //This is useful if u have your own dockpane currently activated...
        //Normally, it would be set in your dockpane
    
        //Create a section that cuts the volume in two on the vertical plane
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var volumeSize = volume.GetVolumeSize();
    
        //Orientation 90 degrees (due West), Tilt 0 degrees
        var normal = voxelLayer.GetNormal(90, 0.0);
    
        //Position must be specified in voxel space
    
        volume.CreateSection(new SectionDefinition()
        {
          Name = "Middle Section",
          VoxelPosition = new Coordinate3D(volumeSize.X / 2, volumeSize.Y / 2, volumeSize.Z / 2),
          Normal = normal,
          IsVisible = true
        });
    
        //reset if needed...Normally this might be when your dockpane
        //was de-activated (ie "closed")
        voxelLayer.AutoShowExploreDockPane = true;
      });
    }
    Create a Horizontal Section
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Create a section that cuts the volume in two on the horizontal plane
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var volumeSize = volume.GetVolumeSize();
    
        //Or use normal (0, 0, 1) or (0, 0, -1)...
        var horz_section = SectionDefinition.CreateHorizontalSectionDefinition();
    
        horz_section.Name = "Horizontal Section";
        horz_section.IsVisible = true;
        horz_section.VoxelPosition = new Coordinate3D(volumeSize.X / 2, volumeSize.Y / 2, volumeSize.Z / 2);
    
        volume.CreateSection(horz_section);
      });
    }
    Create Sections in a Circle Pattern
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var volumeSize = volume.GetVolumeSize();
    
        //180 degrees orientation is due South. 90 degrees orientation is due west.
        var south = 180.0;
        var num_sections = 12;
        var spacing = 1 / (double)num_sections;
    
        //Create a section every nth degree of orientation. Each section
        //bisects the middle of the voxel
        for (int s = 0; s < num_sections; s++)
        {
          var orientation = south * (s * spacing);
          volume.CreateSection(new SectionDefinition()
          {
            Name = $"Circle {s + 1}",
            VoxelPosition = new Coordinate3D(volumeSize.X / 2, volumeSize.Y / 2, volumeSize.Z / 2),
            Normal = voxelLayer.GetNormal(orientation, 0.0),
            IsVisible = true
          });
        }
      });
    }
    Create Sections that Bisect the Voxel
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var volumeSize = volume.GetVolumeSize();
    
        //Make three Normals - each is a Unit Vector (x, y, z)
        var north_south = new Coordinate3D(1, 0, 0);
        var east_west = new Coordinate3D(0, 1, 0);
        var horizontal = new Coordinate3D(0, 0, 1);
    
        int n = 0;
        //The two verticals bisect the x,y plane. The horizontal normal bisects
        //the Z plane.
        foreach (var normal in new List<Coordinate3D> { north_south, east_west, horizontal })
        {
          volume.CreateSection(new SectionDefinition()
          {
            Name = $"Cross {++n}",
            VoxelPosition = new Coordinate3D(volumeSize.X / 2, volumeSize.Y / 2, volumeSize.Z / 2),
            Normal = normal,
            IsVisible = true
          });
        }
      });
    }
    Create Sections Diagonally across the Voxel
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var volumeSize = volume.GetVolumeSize();
    
        //make a diagonal across the voxel
        var voxel_pos = new Coordinate3D(0, 0, volumeSize.Z);
        var voxel_pos_ur = new Coordinate3D(volumeSize.X, volumeSize.Y, volumeSize.Z);
    
        var lineBuilder = new LineBuilderEx(voxel_pos, voxel_pos_ur, null);
        var diagonal = PolylineBuilderEx.CreatePolyline(lineBuilder.ToSegment());
    
        var num_sections = 12;
        var spacing = 1 / (double)num_sections;
    
        //change as needed
        var orientation = 20.0; //(approx NNW)
        var tilt = -15.0;
    
        var normal = voxelLayer.GetNormal(orientation, tilt);
    
        for (int s = 0; s < num_sections; s++)
        {
          Coordinate2D end_pt = new Coordinate2D(0, 0);
          if (s > 0)
          {
            //position each section evenly spaced along the diagonal
            var segments = new List<Segment>() as ICollection<Segment>;
            var part = GeometryEngine.Instance.GetSubCurve3D(
                diagonal, 0.0, s * spacing, AsRatioOrLength.AsRatio);
            part.GetAllSegments(ref segments);
            end_pt = segments.First().EndCoordinate;
          }
    
          volume.CreateSection(new SectionDefinition()
          {
            Name = $"Diagonal {s + 1}",
            VoxelPosition = new Coordinate3D(end_pt.X, end_pt.Y, volumeSize.Z),
            Normal = normal,
            IsVisible = true
          });
        }
      });
    }
    Update Section Orientation and Tilt
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
    
        foreach (var section in volume.GetSections())
        {
          //set each normal to 45.0 orientation and tilt
          section.Normal = voxelLayer.GetNormal(45.0, 45.0);
          //apply the change
          volume.UpdateSection(section);
        }
      });
    }
    Update Section Visibility
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
        var sections = volume.GetSections().Where(s => !s.IsVisible);
    
        //Make them all visible
        foreach (var section in sections)
        {
          section.IsVisible = true;
          //apply the change
          volume.UpdateSection(section);
        }
      });
    }
    Delete Sections
    {
      await QueuedTask.Run(() =>
      {
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
    
        foreach (var section in volume.GetSections())
        {
          volume.DeleteSection(section);
        }
    
        //optional...
        if (voxelLayer.Visualization != VoxelVisualization.Volume)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Volume);
        }
      });
    }
    Get the Current Collection of Locked Sections
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetLockedSectionContainerExpanded(true);
        voxelLayer.SetLockedSectionContainerVisibility(true);
    
        var locked_sections = voxelLayer.GetLockedSections();
      });
    }
    Lock a Section/Create a Locked Section
    {
      var mapView = MapView.Active;
    
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetLockedSectionContainerExpanded(true);
        voxelLayer.SetLockedSectionContainerVisibility(true);
    
        //Use the SelectedVariableProfile to get the sections
        //via its associated volume
        var volume = voxelLayer.SelectedVariableProfile.Volume;
    
        //get the selected section
        var section = mapView.GetSelectedSections().FirstOrDefault();
        if (section == null)
        {
          section = volume.GetSections().FirstOrDefault();
        }
    
        if (section == null)
        {
          return;
        }
    
        //Lock the section (Creates a locked section, deletes
        //the section)
        //if (voxelLayer.CanLockSection(section))
        //	voxelLayer.LockSection(section);
        if (volume.CanLockSection(section))
        {
          volume.LockSection(section);
        }
      });
    }
    Update Locked Section Visibility
    {
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetLockedSectionContainerExpanded(true);
        voxelLayer.SetLockedSectionContainerVisibility(true);
    
        var locked_sections = voxelLayer.GetLockedSections().Where(ls => !ls.IsVisible);
    
        //Make them visible
        foreach (var locked_section in locked_sections)
        {
          locked_section.IsVisible = true;
          //apply change
          voxelLayer.UpdateSection(locked_section);
        }
      });
    }
    Unlock a Locked Section
    {
      var mapView = MapView.Active;
    
      await QueuedTask.Run(() =>
      {
        if (voxelLayer.Visualization != VoxelVisualization.Surface)
        {
          voxelLayer.SetVisualization(VoxelVisualization.Surface);
        }
    
        voxelLayer.SetSectionContainerExpanded(true);
        voxelLayer.SetSectionContainerVisibility(true);
        voxelLayer.SetLockedSectionContainerExpanded(true);
    
        //get the selected locked section
        var locked_section = mapView.GetSelectedLockedSections().FirstOrDefault();
        if (locked_section == null)
        {
          locked_section = voxelLayer.GetLockedSections().FirstOrDefault();
        }
    
        if (locked_section == null)
        {
          return;
        }
    
        //Unlock the locked section (Deletes the locked section, creates
        //a section)
        if (voxelLayer.CanUnlockSection(locked_section))
        {
          voxelLayer.UnlockSection(locked_section);
        }
      });
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also