/*
* LookupTableOperation
*
* Copyright (c) 2001, 2002, 2003, 2004, 2005 Marco Schmidt
* All rights reserved.
*/
package net.sourceforge.jiu.ops;
import net.sourceforge.jiu.data.PixelImage;
import net.sourceforge.jiu.data.IntegerImage;
import net.sourceforge.jiu.ops.ImageToImageOperation;
import net.sourceforge.jiu.ops.MissingParameterException;
import net.sourceforge.jiu.ops.WrongParameterException;
/**
* An operation that replaces samples with values taken from a lookup table.
* Operations where each pixel is treated independently from its neighbors
* and where a pixel value is always mapped to the same new pixel value
* can be implemented this way.
*
* @author Marco Schmidt
* @since 0.6.0
*/
public abstract class LookupTableOperation extends ImageToImageOperation
{
private int[][] intTables;
private int numTables;
/**
* Creates a LookupTableOperation for one lookup table.
*/
public LookupTableOperation()
{
this(1);
}
/**
* Creates an object of this class, calling the super constructor with two <code>null</code>
* arguments and allocates space for the argument number of lookup tables.
* @param numTables number of tables to be used in this operation
*/
public LookupTableOperation(int numTables)
{
super(null, null);
if (numTables < 1)
{
throw new IllegalArgumentException("The number of tables must be at least 1; got " + numTables);
}
intTables = new int[numTables][];
this.numTables = numTables;
}
/**
* Returns the number of tables in this operation.
* @return number of tables
*/
public int getNumTables()
{
return numTables;
}
/**
* Returns one of the internal <code>int</code> lookup tables.
* @param channelIndex the zero-based index of the table to be returned;
* from 0 to getNumTables() - 1
* @return the channelIndex'th table
*/
public int[] getTable(int channelIndex)
{
return intTables[channelIndex];
}
public void prepareImages() throws
MissingParameterException,
WrongParameterException
{
ensureInputImageIsAvailable();
PixelImage in = getInputImage();
if (!(in instanceof IntegerImage))
{
throw new WrongParameterException("Input image must be of type IntegerImage.");
}
PixelImage out = getOutputImage();
if (out == null)
{
out = in.createCompatibleImage(in.getWidth(), in.getHeight());
setOutputImage(out);
}
else
{
if (in.getNumChannels() != out.getNumChannels())
{
throw new WrongParameterException("Output image must have same number of channels as input image.");
}
ensureImagesHaveSameResolution();
}
}
public void process() throws
MissingParameterException,
WrongParameterException
{
prepareImages();
process((IntegerImage)getInputImage(), (IntegerImage)getOutputImage());
}
private void process(IntegerImage in, IntegerImage out)
{
boolean useFirstTableOnly = getNumTables() < in.getNumChannels();
final int TOTAL_ITEMS = in.getHeight() * in.getNumChannels();
int processedItems = 0;
for (int channelIndex = 0; channelIndex < in.getNumChannels(); channelIndex++)
{
int tableIndex;
if (useFirstTableOnly)
{
tableIndex = 0;
}
else
{
tableIndex = channelIndex;
}
process(in, out, channelIndex, tableIndex, processedItems, TOTAL_ITEMS);
processedItems += in.getHeight();
}
}
private void process(IntegerImage in, IntegerImage out, final int CHANNEL_INDEX,
int tableIndex, int processedItems, final int TOTAL_ITEMS)
{
final int[] TABLE = getTable(tableIndex);
final int WIDTH = in.getWidth();
final int HEIGHT = in.getHeight();
for (int y = 0; y < HEIGHT; y++)
{
for (int x = 0; x < WIDTH; x++)
{
out.putSample(CHANNEL_INDEX, x, y, TABLE[in.getSample(CHANNEL_INDEX, x, y)]);
}
setProgress(processedItems++, TOTAL_ITEMS);
}
}
/**
* Resets the number of tables to be used in this operation to the
* argument and drops all actual table data initialized so far.
* After a call to this method, {@link #getTable} will return
* <code>null</code> as long as no new table data is provided
* via {@link #setTable} or {@link #setTables}.
* @param numberOfTables the new number of tables for this operation, must be <code>1</code> or larger
* @throws IllegalArgumentException if the number is zero or smaller
*/
public void setNumTables(int numberOfTables)
{
if (numberOfTables < 1)
{
throw new IllegalArgumentException("Number of tables argument must be larger than zero.");
}
numTables = numberOfTables;
intTables = new int[numTables][];
}
/**
* Provides a new lookup table for one of the channels.
* @param channelIndex the index of the channel for which a table is provided; must be at least <code>0</code> and smaller than {@link #getNumTables}
* @param tableData the actual table to be used for lookup
* @throws IllegalArgumentException if the channel index is not in the valid interval (see above)
*/
public void setTable(int channelIndex, int[] tableData)
{
if (channelIndex < 0)
{
throw new IllegalArgumentException("The channelIndex argument must be at least 0; got " + channelIndex);
}
if (channelIndex >= getNumTables())
{
throw new IllegalArgumentException("The channelIndex argument must be smaller than the number of tables " +
getNumTables() + "; got " + channelIndex);
}
intTables[channelIndex] = tableData;
}
/**
* Sets the tables for all channels to the argument table.
* Useful when the same table can be used for all channels.
* @param tableData the data that will be used as lookup table for all channels
*/
public void setTables(int[] tableData)
{
for (int i = 0; i < getNumTables(); i++)
{
setTable(i, tableData);
}
}
}