ProConcepts Raster - Esri/arcgis-pro-sdk GitHub Wiki

// Get the RasterDatasetDefinition from the raster dataset.
RasterDatasetDefinition rasterDatasetDefinition = rasterDataset.GetDefinition();
// Get the number of bands from the raster band definition.
int bandCount = rasterDatasetDefinition.GetBandCount();

// Get a RasterBand from the raster dataset.
RasterBand rasterBand = rasterDataset.GetBand(0);
// Get the RasterBandDefinition from the raster band.
RasterBandDefinition rasterBandDefinition = rasterBand.GetDefinition();
// Get the name of the raster band from the raster band.
string bandName = rasterBandDefinition.GetName();

// Create a FileSystemConnectionPath using the folder path.
FileSystemConnectionPath connectionPath = 
  new FileSystemConnectionPath(new System.Uri(@"C:\Temp"), FileSystemDatastoreType.Raster);
// Create a new FileSystemDatastore using the FileSystemConnectionPath.
FileSystemDatastore dataStore = new FileSystemDatastore(connectionPath);
// Open the raster dataset.
RasterDataset fileRasterDataset = dataStore.OpenDataset<RasterDataset>("Sample.tif");

// Create a FileGeodatabaseConnectionPath using the path to the gdb. Note: This can be a path to a .sde file.
FileGeodatabaseConnectionPath geodatabaseConnectionPath = 
  new FileGeodatabaseConnectionPath(new Uri(@"C:\Temp\rasters.gdb"));
// Create a new Geodatabase object using the FileGeodatabaseConnectionPath.
Geodatabase geodatabase = new Geodatabase(geodatabaseConnectionPath);
// Open the raster dataset.
RasterDataset gdbRasterDataset = geodatabase.OpenDataset<RasterDataset>("sample");

// Create a FileGeodatabaseConnectionPath using the path to the gdb.
FileGeodatabaseConnectionPath connectionPath = new FileGeodatabaseConnectionPath(new System.Uri(dataStorePath));
// Create a new Geodatabase object using the FileGeodatabaseConnectionPath.
Geodatabase gdb = new Geodatabase(connectionPath);
// Open the Mosaic dataset.
MosaicDataset mosaicDatasetToOpen = gdb.OpenDataset<MosaicDataset>(name);

// Create a FileSystemConnectionPath using the path to the folder.
FileSystemConnectionPath connectionPath = 
    new FileSystemConnectionPath(new System.Uri(@"c:\test"), FileSystemDatastoreType.Raster);
// Create a new FileSystemDatastore using the FileSystemConnectionPath.
FileSystemDatastore dataStore = new FileSystemDatastore(connectionPath);
// Open the Mosaic dataset.
MosaicDataset mosaicDatasetToOpen = dataStore.OpenDataset<MosaicDataset>("testmosaicdataset.amd");

// Get the catalog table from the mosaic dataset
FeatureClass mdCatalog = mosaicDataset.GetCatalog();
// Use the row cursor to get rows from the catalog.
RowCursor catalogCursor = mdCatalog.Search();
while (catalogCursor.MoveNext())
{
    // Get the feature from the current row.
    Feature currFeature = catalogCursor.Current as Feature;
    // Get the value for the Raster field.
    var rasterFieldVal = currFeature["RASTER"];
    RasterValue rasterVal = rasterFieldVal as RasterValue;
    // Use the RasterValue class to get the raster dataset.
    RasterDataset rasterValrasterDataset = rasterVal.GetRasterDataset();
}

// Create a full raster from the raster dataset.
ArcGIS.Core.Data.Raster.Raster raster = rasterDataset.CreateFullRaster();

// Calculate size of pixel block to create. Use 128 or height/width of the raster, whichever is smaller.
int pixelBlockHeight = raster.GetHeight() > 128 ? 128 : raster.GetHeight();
int pixelBlockWidth = raster.GetWidth() > 128 ? 128 : raster.GetWidth();

// Create a new (blank) pixel block.
PixelBlock currentPixelBlock = raster.CreatePixelBlock(pixelBlockWidth, pixelBlockHeight);

// Read pixel values from the raster dataset into the pixel block starting from the given top left corner.
raster.Read(0, 0, currentPixelBlock);

// Do something with the pixel block...

// Write the pixel block to the raster dataset starting from the given top left corner.
raster.Write(0, 0, currentPixelBlock);

await QueuedTask.Run(() =>
{
  // Read pixel values from the raster dataset into the pixel block starting from the given top left corner.
  raster.Read(0, 0, currentPixelBlock);

  // For each plane (band) in the pixel block
  for (int plane = 0; plane < currentPixelBlock.GetPlaneCount(); plane++)
  {
    // Get a copy of the array of pixels from the pixel block corresponding to the current plane.
    Array sourcePixels = currentPixelBlock.GetPixelData(plane, true);
    // Get the height and width of the pixel block.
    int pBHeight = currentPixelBlock.GetHeight();
    int pBWidth = currentPixelBlock.GetWidth();

    // Iterate through the pixels in the array.
    for (int i = 0; i < pBHeight; i++)
    {
      for (int j = 0; j < pBWidth; j++)
      {
        // Get the NoData mask value to see if the pixel is a valid pixel.
        if (Convert.ToByte(currentPixelBlock.GetNoDataMaskValue(plane, j, i)) == 1)
        {
          // Get the pixel value from the array and process it (add 5 to the value).
          // Note: This is assuming the pixel type is Unisigned 8bit.
          int pixelValue = Convert.ToInt16(sourcePixels.GetValue(j, i)) + 5;
          // Make sure the pixel value does not go above the range of the pixel type.
          pixelValue = pixelValue > 254 ? 254 : pixelValue;
          // Set the new pixel value to the array.
          // Note: This is assuming the pixel type is Unisigned 8bit.
          sourcePixels.SetValue(Convert.ToByte(pixelValue), j, i);
        }
      }
    }
    // Set the modified array of pixels back to the pixel block.
    currentPixelBlock.SetPixelData(plane, sourcePixels);
  }
  // Write the pixel block to the raster dataset starting from the given top left corner.
  raster.Write(0, 0, currentPixelBlock);
});

await QueuedTask.Run(() =>
{
  // Create a full raster from the raster dataset.
  ArcGIS.Core.Data.Raster.Raster raster = rasterDataset.CreateFullRaster();

  // Calculate size of pixel blocks to process. Use 1000 or height/width of the raster, whichever is smaller.
  int pixelBlockHeight = raster.GetHeight() > 1000 ? 1000 : raster.GetHeight();
  int pixelBlockWidth = raster.GetWidth() > 1000 ? 1000 : raster.GetWidth();

  // Create the raster cursor using the height and width calculated.
  RasterCursor rasterCursor = raster.CreateCursor(pixelBlockWidth, pixelBlockHeight);

  // Use a do while loop to iterate through the pixel blocks of the raster using the raster cursor.
  do
  {
    // Get the current pixel block from the cursor.
    PixelBlock currentPixelBlock = rasterCursor.Current;
    // Do something with the pixel block...

    // Once you are done, move to the next pixel block.
  }
  while (rasterCursor.MoveNext());
});

  // Gets and sets the application raster and imagery options.
  public class RasterImageryOptions
  {
    // Gets the application default raster NoData color.
    public CIMColor DefaultNoDataColor { get; }
    // Gets the application default raster background color.
    public CIMColor DefaultBackgroundColor { get; }

    // Get the three band composition. This method must be called on the MCT. Use QueuedTask.Run.
    public (int r, int g, int b) Get3BandColor();
    // Gets the raster background color. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public CIMColor GetBackgroundColor();
    // Gets the RGB values used to indicate the background value. This method must be
    // called on the MCT. Use QueuedTask.Run.
    public (double red, double green, double blue) GetBackgroundValue();
    // Gets the color ramp used for the classify symbology type. This method must be
    // called on the MCT. Use QueuedTask.Run.
    public CIMColorRamp GetClassifyColorRamp();
    // Gets the name of the color ramp used for the classify symbology type. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public string GetClassifyColorRampName();
    // Gets the minimum and maximum clip percentages. This method must be called on
    // the MCT. Use QueuedTask.Run.
    public (double minValue, double maxValue) GetClipPercentage();
    // Gets if tiled TIFF files are to be created. This method must be called on the
    // MCT. Use QueuedTask.Run.
    public bool GetCreateTiledTiff();
    // Gets the color ramp used for the discrete symbology type. This method must be
    // called on the MCT. Use QueuedTask.Run.
    public CIMColorRamp GetDiscreteColorRamp();
    // Gets the name of the color ramp used for the discrete symbology type. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public string GetDiscreteColorRampName();
    // Gets if the background value of the raster dataset is to be displayed. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public bool GetDisplayBackground();
    // Gets the setting that allows you to set custom color schemes. This method must
    // be called on the MCT. Use QueuedTask.Run.
    public bool GetEnableCustomColorSchemes();
    // Gets the setting that allows you to set custom rendering defaults. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public bool GetEnableCustomRenderingDefaults();
    // Gets the gamma stretch blue value. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public double GetGammaStretchValueBlue();
    // Gets the gamma stretch green value. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public double GetGammaStretchValueGreen();
    // Gets the gamma stretch red value. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public double GetGammaStretchValueRed();
    // Gets if the boundary of the dataset is to be displayed in the map. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public bool GetIsMosaicBoundaryVisible();
    // Gets if the footprints of each raster within the dataset are to be displayed
    // in the map. This method must be called on the MCT. Use QueuedTask.Run.
    public bool GetIsMosaicFootprintVisible();
    // Gets if a mosaic layer is to be expanded in the TOC. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public bool GetIsMosaicLayerExpanded();
    // Gets if the mosaic layer is to be shown in the map. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public bool GetIsMosaicPreviewVisible();
    // Gets if seamlines are to be displayed in the map. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public bool GetIsMosaicSeamlinesVisible();
    // Gets if a multidimensional dataset is to be tiled for pixel time series access.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public bool GetIsMultidimensionalDatasetTiledForTimeSeries();
    // Gets the maximum number of values to display. This method must be called on the
    // MCT. Use QueuedTask.Run.
    public int GetMaximumUniqueValues();
    // Gets the multispectral data band composition. This method must be called on the
    // MCT. Use QueuedTask.Run.
    public (int r, int g, int b) GetMSColor();
    // Gets the raster NoData color. This method must be called on the MCT. Use QueuedTask.Run.
    public CIMColor GetNoDataColor();
    // Gets the number of standard deviations. This method must be called on the MCT.
    // Use QueuedTask.Run.
    public double GetNumberOfStandardDeviation();
    // Gets the proxy file location. This method must be called on the MCT. Use QueuedTask.Run.
    public string GetProxyFileLocation();
    // Gets the compression type used when building the raster pyramids. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public PyramidCompressionType GetPyramidCompressionMethod();
    // Gets the pyramid compression quality used when pyramids are built with the ArcGIS.Desktop.Core.PyramidCompressionType.JPEG
    // or ArcGIS.Desktop.Core.PyramidCompressionType.JPEG_YCbCr compression methods.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public int GetPyramidCompressionQuality();
    // Gets the build pyramid option; that is how to handle raster dataset that do not
    // have pyramids built. This method must be called on the MCT. Use QueuedTask.Run.
    public BuildPyramidOption GetPyramidOption();
    // Gets the resanmpling method used when building pyramids. This method must be
    // called on the MCT. Use QueuedTask.Run.
    public PyramidResamplingMode GetPyramidResampleMethod();
    // Gets the resampling method. This method must be called on the MCT. Use QueuedTask.Run.
    public RasterResamplingType GetResampleType();
    // Gets the X skip factor. That is the number of horizontal pixels between samples.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public int GetSkipFactorX();
    // Gets the Y skip factor. That is the number of vertical pixels between samples.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public int GetSkipFactorY();
    // Gets the calculate statistics option; that is how to handle raster datasets that
    // do not have statistics calculated. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public CalculateStatisticOption GetStatisticsOption();
    // Gets the color ramp used for the stretched symbology type. This method must be
    // called on the MCT. Use QueuedTask.Run.
    public CIMColorRamp GetStretchedColorRamp();
    // Gets the name of the color ramp used for the stretched symbology type. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public string GetStretchedColorRampName();
    // Gets the stretch type. This method must be called on the MCT. Use QueuedTask.Run.
    public RasterStretchType GetStretchType();
    // Gets the color ramp used for the unique value symbology type. This method must
    // be called on the MCT. Use QueuedTask.Run.
    public CIMColorRamp GetUniqueValueColorRamp();
    // Gets the name of the color ramp used for the unique value symbology type. This
    // method must be called on the MCT. Use QueuedTask.Run.
    public string GetUniqueValueColorRampName();
    // Gets if the application will work in the perspective view when an appropriate
    // layers is added to a map. This method must be called on the MCT. Use QueuedTask.Run.
    public bool GetUseFirstPerspectiveImageryLayer();
    // Gets the value indicating if an image service cache should be displayed rather
    // than the image service (if it has a cache generated). This method must be called
    // on the MCT. Use QueuedTask.Run.
    public bool GetUseImageServiceCache();
    // Gets the use band wavelength information setting. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public bool GetUseWavelengthInformation();
    // Gets if the raster dataset's native georeferencing should be overridden with
    // the world file information. This method must be called on the MCT. Use QueuedTask.Run.
    public bool GetUseWorldFile();
    // Gets the set of color ramp categories that are valid for the raster settings.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public IReadOnlyList<string> GetValidColorRampCategories();
    // Sets the three band composition. This method must be called on the MCT. Use QueuedTask.Run.
    public void Set3BandColor(int r, int g, int b);
    // Sets the raster background color. Use ArcGIS.Desktop.Core.RasterImageryOptions.SetDisplayBackground(System.Boolean)
    // and ArcGIS.Desktop.Core.RasterImageryOptions.SetBackgroundValue(System.Double,System.Double,System.Double)
    // to display the background value. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetBackgroundColor(CIMColor backgroundColor);
    // Sets the RGB values for the background value. Use ArcGIS.Desktop.Core.RasterImageryOptions.SetDisplayBackground(System.Boolean)
    // and ArcGIS.Desktop.Core.RasterImageryOptions.SetBackgroundColor(ArcGIS.Core.CIM.CIMColor)
    // to display the background value. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetBackgroundValue(double red, double green, double blue);
    // Sets the name of the color ramp used for the classify symbology type. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public void SetClassifyColorRampName(string colorRamp);
    // Sets the minimum and maximum clip percentages. This method must be called on
    // the MCT. Use QueuedTask.Run.
    public void SetClipPercentage(double minValue, double maxValue);
    // Sets if tiled TIFF files are to be created. This method must be called on the
    // MCT. Use QueuedTask.Run.
    public void SetCreateTiledTiff(bool tiled);
    // Sets the name of the color ramp used for the discrete symbology type. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public void SetDiscreteColorRampName(string colorRamp);
    // Sets if the background value of the raster dataset is to be displayed. Use 
    // ArcGIS.Desktop.Core.RasterImageryOptions.SetBackgroundValue(System.Double,System.Double,System.Double)
    // and ArcGIS.Desktop.Core.RasterImageryOptions.SetBackgroundColor(ArcGIS.Core.CIM.CIMColor)
    // to define the background value and the color. This method must be called on the
    // MCT. Use QueuedTask.Run.
    public void SetDisplayBackground(bool displayBackground);
    // Sets the custom color scheme setting. This method must be called on the MCT.
    // Use QueuedTask.Run.
    public void SetEnableCustomColorSchemes(bool enableCustomColorSchemes);
    // Sets the custom rendering setting. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public void SetEnableCustomRenderingDefaults(bool enableCustomRendering);
    // Sets the gamma stretch blue value. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public void SetGammaStretchValueBlue(double value);
    // Sets the gamma stretch green value. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public void SetGammaStretchValueGreen(double value);
    // Sets the gamma stretch red value. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public void SetGammaStretchValueRed(double value);
    // Sets if the boundary of the dataset is to be displayed in the map. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public void SetIsMosaicBoundaryVisible(bool isVisible);
    // Sets if the footprints of each raster within the dataset are to be displayed
    // in the map. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetIsMosaicFootprintVisible(bool isVisible);
    // Sets if a mosaic layer is to be expanded in the TOC. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public void SetIsMosaicLayerExpanded(bool isExpanded);
    // Sets if the mosaic layer is to be shown in the map. Set this to false to improve
    // performance if it is not necessary to immediately see your imagery or raster
    // dataset. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetIsMosaicPreviewVisible(bool isVisible);
    // Sets if seamlines are to be displayed in the map. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public void SetIsMosaicSeamlinesVisible(bool isVisible);
    // Sets if a multidimensional dataset is to be tiled for pixel time series access.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public void SetIsMultidimensionalDatasetTiledForTimeSeries(bool isTiled);
    // Sets the maximum number of unique values to display. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public void SetMaximumUniqueValues(int maximum);
    // Sets the multispectral data band composition. This method must be called on the
    // MCT. Use QueuedTask.Run.
    public void SetMSColor(int r, int g, int b);
    // Sets the raster NoData color. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetNoDataColor(CIMColor noDataColor);
    // Sets the number of standard deviations. This method must be called on the MCT.
    // Use QueuedTask.Run.
    public void SetNumberOfStandardDeviation(double value);
    // Sets the proxy file location. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetProxyFileLocation(string path);
    // Sets the compression type used when building the raster pyramids. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public void SetPyramidCompressionMethod(PyramidCompressionType compressionType);
    // Sets the pyramid compression quality. This method must be called on the MCT.
    // Use QueuedTask.Run.
    public void SetPyramidCompressionQuality(int value);
    // Sets the build pyramid option for handling raster datasets that do not have pyramids
    // built. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetPyramidOption(BuildPyramidOption option);
    // Sets the resampling method used when building pyramids. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public void SetPyramidResampleMethod(PyramidResamplingMode resamplingMode);
    // Sets the resampling method. Must be one of ArcGIS.Core.CIM.RasterResamplingType.NearestNeighbor,
    // ArcGIS.Core.CIM.RasterResamplingType.BilinearInterpolation or ArcGIS.Core.CIM.RasterResamplingType.CubicConvolution.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public void SetResampleType(RasterResamplingType resampleType);
    // Sets the X skip factor. That is the number of horizontal pixels between samples.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public void SetSkipFactorX(int skipfactorX);
    // Sets the Y skip factor. That is the number of vertical pixels between samples.
    // This method must be called on the MCT. Use QueuedTask.Run.
    public void SetSkipFactorY(int skipfactorY);
    // Sets the calculate statistics option; that is how to handle raster datasets that
    // do not have statistics calculated. This method must be called on the MCT. Use
    // QueuedTask.Run.
    public void SetStatisticsOption(CalculateStatisticOption option);
    // Sets the name of the color ramp used for the stretched symbology type. This method
    // must be called on the MCT. Use QueuedTask.Run.
    public void SetStretchedColorRampName(string colorRamp);
    // Sets the stretch type. Must be one of ArcGIS.Core.CIM.RasterStretchType.None,
    // ArcGIS.Core.CIM.RasterStretchType.StandardDeviations, ArcGIS.Core.CIM.RasterStretchType.MinimumMaximum
    // or ArcGIS.Core.CIM.RasterStretchType.PercentMinimumMaximum. This method must
    // be called on the MCT. Use QueuedTask.Run.
    public void SetStretchType(RasterStretchType stretchType);
    // Sets the name of the color ramp used for the unique value symbology type. This
    // method must be called on the MCT. Use QueuedTask.Run.
    public void SetUniqueValueColorRampName(string colorRamp);
    // Sets if the application will work in the perspective view when an appropriate
    // layers is added to a map. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetUseFirstPerspectiveImageryLayer(bool usePerspectiveView);
    // Sets the value indicating if an image service cache should be displayed rather
    // than the image service (if it has a cache generated). This method must be called
    // on the MCT. Use QueuedTask.Run.
    public void SetUseImageServiceCache(bool useCache);
    // Sets the use band wavelength information setting. This method must be called
    // on the MCT. Use QueuedTask.Run.
    public void SetUseWavelengthInformation(bool useWaveLengthInformation);
    // Sets if the raster dataset's native georeferencing should be overridden with
    // the world file information. This method must be called on the MCT. Use QueuedTask.Run.
    public void SetUseWorldFile(bool useWorldFile);
  }

      var ro = ApplicationOptions.RasterImageryOptions;

      QueuedTask.Run(() =>
      {
        var validCategories = ro.GetValidColorRampCategories();
        var validCategory = validCategories.FirstOrDefault();

        var colorRamps = ColorFactory.Instance.GetColorRampNames(validCategory);
        var newColorRampName = colorRamps.FirstOrDefault();

        var stretchedColorRamp = ro.GetStretchedColorRamp();
        var colorRampName = ro.GetStretchedColorRampName();
        ro.SetStretchedColorRampName(null);

        var classifyColorRamp = ro.GetClassifyColorRamp();
        colorRampName = ro.GetClassifyColorRampName();
        ro.SetClassifyColorRampName(newColorRampName);

        var discreteColorRamp = ro.GetDiscreteColorRamp();
        colorRampName = ro.GetDiscreteColorRampName();
        ro.SetDiscreteColorRampName(newColorRampName);

        var uniqueValueColorRamp = ro.GetUniqueValueColorRamp();
        colorRampName = ro.GetUniqueValueColorRampName();
        ro.SetUniqueValueColorRampName(newColorRampName);

        var customRendering = ro.GetEnableCustomRenderingDefaults(); 
        ro.SetEnableCustomRenderingDefaults(!customRendering);   

        var sampleType = ro.GetResampleType();   
        ro.SetResampleType(RasterResamplingType.CubicConvolution); 

        var stretchType = ro.GetStretchType();
        ro.SetStretchType(RasterStretchType.PercentMinimumMaximum);   

        var val = ro.GetNumberOfStandardDeviation();
        ro.SetNumberOfStandardDeviation(3);

        var (clipMin, clipMax) = ro.GetClipPercentage();
        ro.SetClipPercentage(12, 23);

        var red = ro.GetGammaStretchValueRed();
        var green = ro.GetGammaStretchValueGreen();
        var blue = ro.GetGammaStretchValueBlue();

        ro.SetGammaStretchValueRed(2);
        ro.SetGammaStretchValueGreen(20);
        ro.SetGammaStretchValueBlue(60);

        var displayBackground = ro.GetDisplayBackground();
        ro.SetDisplayBackground(!displayBackground);

        var (r, g, b) = ro.GetBackgroundValue();
        ro.SetBackgroundValue(4, 21, 61);

        var backColor = ro.GetBackgroundColor();
        ro.SetBackgroundColor(CIMColor.CreateRGBColor(255, 0, 0));

        var noData = ro.GetNoDataColor();
        ro.SetNoDataColor(CIMColor.CreateRGBColor(0, 255, 0));


        // cache
        var useCache = ro.GetUseImageServiceCache();
        ro.SetUseImageServiceCache(!useCache);

        //dataset

        var opt = ro.GetPyramidOption();
        ro.SetPyramidOption(ArcGIS.Desktop.Core.BuildPyramidOption.NeverBuild);
        var sample = ro.GetPyramidResampleMethod();
        ro.SetPyramidResampleMethod(PyramidResamplingMode.Bilinear);
        var compression = ro.GetPyramidCompressionMethod();
        ro.SetPyramidCompressionMethod(PyramidCompressionType.JPEG_YCbCr);

        var quality = ro.GetPyramidCompressionQuality();
        ro.SetPyramidCompressionQuality(32);

        var stats = ro.GetStatisticsOption();
        ro.SetStatisticsOption(CalculateStatisticOption.AlwaysCalculate);
        var x = ro.GetSkipFactorX();
        ro.SetSkipFactorX(3);
        var y = ro.GetSkipFactorY();
        ro.SetSkipFactorY(23);

        var useWorldFile = ro.GetUseWorldFile();
        ro.SetUseWorldFile(!useWorldFile);

        var createTiledTiff = ro.GetCreateTiledTiff();
        ro.SetCreateTiledTiff(!createTiledTiff);

        var maxUniqueValues = ro.GetMaximumUniqueValues();
        ro.SetMaximumUniqueValues(123456);

        var path = ro.GetProxyFileLocation();
        ro.SetProxyFileLocation("c:\\temp");

        var isExpanded = ro.GetIsMosaicLayerExpanded();
        ro.SetIsMosaicLayerExpanded(!isExpanded);
        var isVisible = ro.GetIsMosaicBoundaryVisible();
        ro.SetIsMosaicBoundaryVisible(!isVisible);
        isVisible = ro.GetIsMosaicFootprintVisible();
        ro.SetIsMosaicFootprintVisible(!isVisible);
        isVisible = ro.GetIsMosaicSeamlinesVisible();
        ro.SetIsMosaicSeamlinesVisible(!isVisible);
        isVisible = ro.GetIsMosaicPreviewVisible();
        ro.SetIsMosaicPreviewVisible(!isVisible);


        var (red_3band, green_3band, blue_3band) = ro.Get3BandColor();
        ro.Set3BandColor(2, 2, 2);
        var (ms_red, ms_green, ms_blue) = ro.GetMSColor();
        ro.SetMSColor(23, 24, 25);

        var enableCustomColorSchemes = ro.GetEnableCustomColorSchemes(); 
        ro.SetEnableCustomColorSchemes(!enableCustomColorSchemes);   

        var useWavelengthInfo = ro.GetUseWavelengthInformation();
        ro.SetUseWavelengthInformation(!useWavelengthInfo);
      });