ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Desktop.Mapping Namespace / VoxelLayer Class / Visualization Property
Example

In This Topic
    Visualization Property (VoxelLayer)
    In This Topic
    Gets the voxel visualization mode.
    Syntax
    public VoxelVisualization Visualization {get;}
    Public ReadOnly Property Visualization As VoxelVisualization
    Example
    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);
        }
      });
    }
    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