GetFunctionalLookupTable Method

Updates a range of entries in the lookup table, based on the specified mathematical function.

public static void GetFunctionalLookupTable(  
   int[] lookupTable, 
   int start, 
   int end, 
   int factor, 
   Leadtools.Imageprocessing.Effects.FunctionalLookupTableFlags flags 
) 

Public Shared Sub GetFunctionalLookupTable( _ 
   ByVal lookupTable() As Integer, _ 
   ByVal start As Integer, _ 
   ByVal end As Integer, _ 
   ByVal factor As Integer, _ 
   ByVal flags As Leadtools.Imageprocessing.Effects.FunctionalLookupTableFlags _ 
) 

public static void GetFunctionalLookupTable(  
   int[] lookupTable, 
   int start, 
   int end, 
   int factor, 
   Leadtools.Imageprocessing.Effects.FunctionalLookupTableFlags flags 
) 

+ (void)getFunctionalLookupTable:(int *)lookupTable 
               lookupTableLength:(NSUInteger)lookupTableLength 
                           start:(NSInteger)start 
                             end:(NSInteger)end 
                          factor:(NSInteger)factor 
                           flags:(LTFunctionalLookupTableFlags)flags 
                           error:(NSError **)error 

public static void getFunctionalLookupTable( 
   int[] lookupTable,  
   int start,  
   int end,  
   int factor,  
   FunctionalLookupTableFlags flags 
) 

function Leadtools.ImageProcessing.Effects.EffectsUtilities.GetFunctionalLookupTable(  
   lookupTable , 
   start , 
   end , 
   factor , 
   flags  
) 

public: 
static void GetFunctionalLookupTable(  
   array<int>^ lookupTable, 
   int start, 
   int end, 
   int factor, 
   Leadtools.Imageprocessing.Effects.FunctionalLookupTableFlags flags 
) 

Parameters

• This method will update the lookup table array using the predefined function specified in the flags parameter. In most cases, this method is used with RemapIntensityCommand.
• The factor parameter is used for logarithm, exponential and sigmoid functions only. If factor = 0, the method performs a linear interpolation between the two points start and end and stores the results in the lookup table, regardless of the value set in flags.
• If flags parameter is set to FunctionalLookupTableFlags.Exponential, the value of factor modifies the lookup table values (see figure below) according to the following equations:

• If the flags parameter is set to FunctionalLookupTableFlags.Logarithm, the value of factor modifies the lookup table values (see figure below) according to the following equations:

• If the flags parameter is set to FunctionalLookupTableFlags.Sigmoid, the value of factor modifies the lookup table values (see figure below) according to the following equations:

• If the flags parameter is set to FunctionalLookupTableFlags.Linear, factor is ignored. The method performs a linear interpolation between the two points (start, YStart) and (end, YEnd) and stores the results in the lookup table.

  where:

  YStart = The lookupTable value at start.

  YEnd = The lookupTable value at end.

• If the value of (end - start) exceed the lookupTable length, the method will throw an exception.

• As an example, suppose a user wants to select a point, change the intensity value of that point (x), and then perform two linear interpolations:
  • from 0 to the intensity value x
  • from intensity value x to the end of the range

• To accomplish this, the user would proceed by doing the following:

  • Select the point and get its intensity value (x).
  • Change the intensity value of the selected point to some new value (newIntensity).

  • Store the new intensity value in the Lookup table by assignment: lookupTable[0] = 0; lookupTable[x] = newIntensity;

  • Call GetFunctionalLookupTable with start set to 0, end set to x, and flags set to FunctionalLookupTableFlags.Linear.

  • Call GetFunctionalLookupTable with start set to x, end set to 255, and flags set to FunctionalLookupTableFlags.Linear. (For the example, assume the image is 8-bits per pixel.)
  • For another example, please refer to the example for RemapIntensityCommand.

This example will darken the loaded image by using a lookup table created by using an exponential function.

Imports Leadtools 
Imports Leadtools.Codecs 
Imports Leadtools.ImageProcessing 
Imports Leadtools.ImageProcessing.Color 
Imports Leadtools.ImageProcessing.Effects 
 
    
Public Sub GetFunctionalLookupTableExample() 
   Dim codecs As New RasterCodecs() 
   codecs.ThrowExceptionsOnInvalidImages = True 
   Dim leadImage As RasterImage = codecs.Load(Path.Combine(LEAD_VARS.ImagesDir, "Master.jpg")) 
 
   ' Prepare the command 
   Dim LookupTable() As Integer 
   ReDim LookupTable(255) 
   LookupTable(0) = 0 
   LookupTable(255) = 255 
   EffectsUtilities.GetFunctionalLookupTable(LookupTable, 0, 255, 5, FunctionalLookupTableFlags.Exponential) 
 
   Dim command As RemapIntensityCommand = New RemapIntensityCommand 
   command.Flags = RemapIntensityCommandFlags.Master 
   command.LookupTable = LookupTable 
   command.Run(leadImage) 
   codecs.Save(leadImage, Path.Combine(LEAD_VARS.ImagesDir, "Result.jpg"), RasterImageFormat.Jpeg, 24) 
 
End Sub 
 
Public NotInheritable Class LEAD_VARS 
Public Const ImagesDir As String = "C:\Users\Public\Documents\LEADTOOLS Images" 
End Class 

using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.ImageProcessing; 
using Leadtools.ImageProcessing.Effects; 
using Leadtools.ImageProcessing.Color; 
 
       
public void GetFunctionalLookupTableExample() 
{ 
   // Load an image 
   RasterCodecs codecs = new RasterCodecs(); 
   codecs.ThrowExceptionsOnInvalidImages = true; 
   RasterImage image = codecs.Load(Path.Combine(LEAD_VARS.ImagesDir, "Master.jpg")); 
 
   // Prepare the command 
   int[] LookupTable = new int[256]; 
   LookupTable[0] = 0; 
   LookupTable[255] = 255; 
   EffectsUtilities.GetFunctionalLookupTable(LookupTable, 0, 255, 5, FunctionalLookupTableFlags.Exponential); 
 
   RemapIntensityCommand command = new RemapIntensityCommand(); 
   command.Flags = RemapIntensityCommandFlags.Master; 
   command.LookupTable = LookupTable; 
   command.Run(image); 
   codecs.Save(image, Path.Combine(LEAD_VARS.ImagesDir, "Result.jpg"), RasterImageFormat.Jpeg, 24); 
 
} 
 
static class LEAD_VARS 
{ 
public const string ImagesDir = @"C:\Users\Public\Documents\LEADTOOLS Images"; 
} 

using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.ImageProcessing.Effects; 
using Leadtools.ImageProcessing; 
using Leadtools.ImageProcessing.Color; 
 
       
public async Task GetFunctionalLookupTableExample() 
{ 
   // Load an image 
   RasterCodecs codecs = new RasterCodecs(); 
   codecs.ThrowExceptionsOnInvalidImages = true; 
   // Load the image 
   string srcFileName = @"Assets\Image1.cmp"; 
   StorageFile loadFile = await Tools.AppInstallFolder.GetFileAsync(srcFileName); 
   RasterImage image = await codecs.LoadAsync(LeadStreamFactory.Create(loadFile)); 
 
   // Prepare the command 
   int[] LookupTable = new int[256]; 
   LookupTable[0] = 0; 
   LookupTable[255] = 255; 
   int[] retLookupTable = EffectsUtilities.GetFunctionalLookupTable(LookupTable, 0, 255, 5, FunctionalLookupTableFlags.Exponential); 
 
   RemapIntensityCommand command = new RemapIntensityCommand(); 
   command.Flags = RemapIntensityCommandFlags.Master; 
   command.LookupTable = retLookupTable; 
   command.Run(image); 
   //Save as BMP 
   string destFileName = @"result.bmp"; 
   StorageFile saveFile = await Tools.AppLocalFolder.CreateFileAsync(destFileName); 
   await codecs.SaveAsync(image, LeadStreamFactory.Create(saveFile), RasterImageFormat.Bmp, 24); 
 
} 

using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.ImageProcessing; 
using Leadtools.ImageProcessing.Effects; 
using Leadtools.ImageProcessing.Color; 
using Leadtools.Examples; 
 
public void GetFunctionalLookupTableExample(RasterImage image, Stream outStream) 
{ 
   // Prepare the command 
   int[] LookupTable = new int[256]; 
   LookupTable[0] = 0; 
   LookupTable[255] = 255; 
   EffectsUtilities.GetFunctionalLookupTable(LookupTable, 0, 255, 5, FunctionalLookupTableFlags.Exponential); 
   RemapIntensityCommand command = new RemapIntensityCommand(); 
   command.Flags = RemapIntensityCommandFlags.Master; 
   command.LookupTable = LookupTable; 
   command.Run(image); 
   // Save result image 
   RasterCodecs codecs = new RasterCodecs(); 
   codecs.Save(image, outStream, RasterImageFormat.Jpeg, 24); 
   image.Dispose(); 
} 

Imports Leadtools 
Imports Leadtools.Codecs 
Imports Leadtools.ImageProcessing 
Imports Leadtools.ImageProcessing.Effects 
Imports Leadtools.ImageProcessing.Color 
 
Public Sub GetFunctionalLookupTableExample(ByVal image As RasterImage, ByVal outStream As Stream) 
   ' Prepare the command 
   Dim LookupTable As Integer() = New Integer(255){} 
   LookupTable(0) = 0 
   LookupTable(255) = 255 
   EffectsUtilities.GetFunctionalLookupTable(LookupTable, 0, 255, 5, FunctionalLookupTableFlags.Exponential) 
   Dim command As RemapIntensityCommand = New RemapIntensityCommand() 
   command.Flags = RemapIntensityCommandFlags.Master 
   command.LookupTable = LookupTable 
   command.Run(image) 
   ' Save result image 
   Dim codecs As RasterCodecs = New RasterCodecs() 
   codecs.Save(image, outStream, RasterImageFormat.Jpeg, 24) 
   image.Dispose() 
End Sub 

Target Platforms

Reference

EffectsUtilities Class

EffectsUtilities Members

Leadtools.ImageProcessing.Color.RemapIntensityCommand

Leadtools.ImageProcessing.Core.ApplyVoiLookupTableCommand

Leadtools.ImageProcessing.Color.AdjustTintCommand

Leadtools.ImageProcessing.Color.GammaCorrectExtendedCommand