GetFunctionalLookupTable Method - Leadtools.ImageProcessing.Effects Namespace

Summary

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

Syntax

C#

VB

Java

Objective-C

WinRT C#

C++

public static void GetFunctionalLookupTable( 
   int[] lookupTable, 
   int start, 
   int end, 
   int factor, 
   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

lookupTable
Lookup table array to be filled by this method. The user must set the first and the last element of the lookup table manually (i.e. lookupTable[0] = firstValue; lookupTable[tableSize - 1] = lastValue;), if you set the first element to last value and the last element to the first value then the lookup table will become inverted.

start
Index of the first entry in the lookup table to update. The indices of the table correspond to the intensity values. If this parameter has a negative value the corresponding index to lookupTable is equal to its value + its length. The range of its possible value is between (- lookupTable length/2) and ( lookupTable length/2 - 1).

end
Index of the last entry in the lookup table to update. The indices of the table correspond to the intensity values. If this parameter has a negative value the corresponding index to lookupTable is equal to its value + its length. The range of its possible value is between (- lookupTable length/2) and ( lookupTable length/2 - 1).

factor
Value that indicates the factor to be applied in the function operation specified in the flags parameter. This parameter is used only if flags is set to FunctionalLookupTableFlags.Exponential, FunctionalLookupTableFlags.Sigmoid or FunctionalLookupTableFlags.Logarithm. If FunctionalLookupTableFlags.Exponential or FunctionalLookupTableFlags.Sigmoid is set, the value of this parameter can be any integer (+/-). If FunctionalLookupTableFlags.Logarithm is set, its value should be >= 0. However, if factor = 0, the lookup table will be filled linearly from start to end, regardless of the value set in flags.

flags
Flags that indicate the function used to update the lookup table and whether or not the lookupTable should contain signed or unsigned data.

Remarks

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:

Y	=	YStart	+	(YEnd - YStart) * (Exp ((factor/10.0 * (x-start))/(end-start)) - firstValue)
				(lastValue - firstValue)

YStart = The value at start. YEnd = The value at end. firstValue = Exp(0). lastValue = Exp(factor) x = the intensity value of the selected point

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:

Y	=	YStart	+	(YEnd - YStart) * (Log (1 + (factor/10.0 * (x-start))/(end- start)) - firstValue)
				(lastValue - firstValue)

YStart = The value at start. YEnd = The value at end. firstValue = 0. lastValue = Log(1 + nFactor). x = the intensity value of the selected point

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:

Y	=	YStart	+	(YEnd - YStart) * (1.0/ (1 + Exp(2factor/10.0 (x-center))/(end- start)) - firstValue)
				(lastValue - firstValue)

YStart = The value at start. YEnd = The value at end. firstValue = 1.0/(1 + Exp(2.0 \* factor/10.0 \*(start - center)/ (end- start))). lastValue = Log(1 + factor). x = the intensity value of the selected point

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.

Example

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

C#

VB

Silverlight C#

Silverlight VB

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"; 
}

Imports Leadtools 
Imports Leadtools.Codecs 
Imports Leadtools.ImageProcessing 
Imports Leadtools.ImageProcessing.Color 
Imports Leadtools.ImageProcessing.Effects 
      Leadtools.Examples.Support.SetLicense() 
 
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; 
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

Requirements

Target Platforms

Reference

EffectsUtilities Class

EffectsUtilities Members

Leadtools.ImageProcessing.Color.RemapIntensityCommand

Leadtools.ImageProcessing.Core.ApplyVoiLookupTableCommand

Leadtools.ImageProcessing.Color.AdjustTintCommand

Leadtools.ImageProcessing.Color.GammaCorrectExtendedCommand