public PDIndexed() 
{
        array = new COSArray();
        array.add( COSName.getPDFName( NAME ) );
        array.add( COSName.getPDFName( PDDeviceRGB.NAME ) );
        array.add( COSInteger.get( 255 ) );
        array.add( org.apache.pdfbox.cos.COSNull.NULL );
}

Constructor, default DeviceRGB, hival 255.

 public PDIndexed(COSArray indexedArray) 
{
        array = indexedArray;
}

Constructor.

Parameters:

indexedArray - The array containing the indexed parameters

 public ColorModel createColorModel(int bpc) throws IOException 
{
        int size = getHighValue();
        byte[] index = getLookupData();
        PDColorSpace baseColorSpace = getBaseColorSpace();
        ColorModel cm = null;
        if( baseColorSpace instanceof PDDeviceRGB )
        {
            cm = new IndexColorModel(bpc, size+1, index,0,false);
        }
        else
        {
            ColorModel baseColorModel = baseColorSpace.createColorModel(bpc);
            if( baseColorModel.getTransferType() != DataBuffer.TYPE_BYTE )
            {
                throw new IOException( "Not implemented" );
            }
            byte[] r = new byte[size+1];
            byte[] g = new byte[size+1];
            byte[] b = new byte[size+1];
            byte[] a = baseColorModel.hasAlpha() ? new byte[size+1] : null;
            byte[] inData = new byte[baseColorModel.getNumComponents()];
            for( int i = 0; i < = size; i++ )
            {
                System.arraycopy(index, i * inData.length, inData, 0, inData.length);
                r[i] = (byte)baseColorModel.getRed(inData);
                g[i] = (byte)baseColorModel.getGreen(inData);
                b[i] = (byte)baseColorModel.getBlue(inData);
                if(a != null)
                {
                    a[i] = (byte)baseColorModel.getAlpha(inData);
                }
            }
            cm = a == null ? new IndexColorModel(bpc, size+1, r, g, b) : new IndexColorModel(bpc, size+1, r, g, b, a);
        }
        return cm;
}

Create a Java color model for this colorspace.

 protected ColorSpace createColorSpace() throws IOException 
{
        throw new IOException( "Not implemented" );
}

Create a Java colorspace for this colorspace.

 public PDColorSpace getBaseColorSpace() throws IOException 
{
        COSBase base = array.getObject( 1 );
        return PDColorSpaceFactory.createColorSpace( base );
}

This will get the color space that acts as the index for this color space.

 public int getHighValue() 
{
        return ((COSNumber)array.getObject( 2 )).intValue();
}

Get the highest value for the lookup.

 public String getName() 
{
        return NAME;
}

This will return the name of the color space.

 public int getNumberOfComponents() throws IOException 
{
        return getBaseColorSpace().getNumberOfComponents();
}

This will return the number of color components. This will return the number of color components in the base color.

 public int lookupColor(int lookupIndex,
    int componentNumber) throws IOException 
{
        PDColorSpace baseColor = getBaseColorSpace();
        byte[] data = getLookupData();
        int numberOfComponents = baseColor.getNumberOfComponents();
        return (data[lookupIndex*numberOfComponents + componentNumber]+256)%256;
}

This will perform a lookup into the color lookup table.

 public  void setBaseColorSpace(PDColorSpace base) 
{
        array.set( 1, base.getCOSObject() );
}

This will set the base color space.

 public  void setHighValue(int high) 
{
        array.set( 2, high );
}

This will set the highest value that is allowed. This cannot be higher than 255.

 public  void setLookupColor(int lookupIndex,
    int componentNumber,
    int color) throws IOException 
{
        PDColorSpace baseColor = getBaseColorSpace();
        int numberOfComponents = baseColor.getNumberOfComponents();
        byte[] data = getLookupData();
        data[lookupIndex*numberOfComponents + componentNumber] = (byte)color;
        COSString string = new COSString( data );
        array.set( 3, string );
}

This will set a color in the color lookup table.