470 lines
17 KiB
Java
470 lines
17 KiB
Java
package ar.com.hjg.pngj;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import ar.com.hjg.pngj.chunks.PngChunkPLTE;
|
|
import ar.com.hjg.pngj.chunks.PngChunkTRNS;
|
|
|
|
/**
|
|
* Bunch of utility static methods to proces an image line at the pixel level.
|
|
* <p>
|
|
* WARNING: this has little testing/optimizing, and this API is not stable. some
|
|
* methods will probably be changed or
|
|
* removed if future releases.
|
|
* <p>
|
|
* WARNING: most methods for getting/setting values work currently only for
|
|
* ImageLine or ImageLineByte
|
|
*/
|
|
public class ImageLineHelper {
|
|
|
|
static int[] DEPTH_UNPACK_1;
|
|
static int[] DEPTH_UNPACK_2;
|
|
static int[] DEPTH_UNPACK_4;
|
|
static int[][] DEPTH_UNPACK;
|
|
|
|
static {
|
|
ImageLineHelper.initDepthScale();
|
|
}
|
|
|
|
private static void initDepthScale() {
|
|
ImageLineHelper.DEPTH_UNPACK_1 = new int[2];
|
|
for (int i = 0; i < 2; i++)
|
|
ImageLineHelper.DEPTH_UNPACK_1[i] = i * 255;
|
|
ImageLineHelper.DEPTH_UNPACK_2 = new int[4];
|
|
for (int i = 0; i < 4; i++)
|
|
ImageLineHelper.DEPTH_UNPACK_2[i] = i * 255 / 3;
|
|
ImageLineHelper.DEPTH_UNPACK_4 = new int[16];
|
|
for (int i = 0; i < 16; i++)
|
|
ImageLineHelper.DEPTH_UNPACK_4[i] = i * 255 / 15;
|
|
ImageLineHelper.DEPTH_UNPACK = new int[][] { null, ImageLineHelper.DEPTH_UNPACK_1, ImageLineHelper.DEPTH_UNPACK_2, null, ImageLineHelper.DEPTH_UNPACK_4 };
|
|
}
|
|
|
|
/**
|
|
* When the bitdepth is less than 8, the imageLine is usually
|
|
* returned/expected unscaled. This method upscales it in
|
|
* place. Eg, if bitdepth=1, values 0-1 will be converted to 0-255
|
|
*/
|
|
public static void scaleUp(final IImageLineArray line) {
|
|
if (line.getImageInfo().indexed || line.getImageInfo().bitDepth >= 8)
|
|
return;
|
|
final int[] scaleArray = ImageLineHelper.DEPTH_UNPACK[line.getImageInfo().bitDepth];
|
|
if (line instanceof ImageLineInt) {
|
|
final ImageLineInt iline = (ImageLineInt) line;
|
|
for (int i = 0; i < iline.getSize(); i++)
|
|
iline.scanline[i] = scaleArray[iline.scanline[i]];
|
|
} else if (line instanceof ImageLineByte) {
|
|
final ImageLineByte iline = (ImageLineByte) line;
|
|
for (int i = 0; i < iline.getSize(); i++)
|
|
iline.scanline[i] = (byte) scaleArray[iline.scanline[i]];
|
|
} else
|
|
throw new PngjException("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Reverse of {@link #scaleUp(IImageLineArray)}
|
|
*/
|
|
public static void scaleDown(final IImageLineArray line) {
|
|
if (line.getImageInfo().indexed || line.getImageInfo().bitDepth >= 8)
|
|
return;
|
|
if (line instanceof ImageLineInt) {
|
|
final int scalefactor = 8 - line.getImageInfo().bitDepth;
|
|
if (line instanceof ImageLineInt) {
|
|
final ImageLineInt iline = (ImageLineInt) line;
|
|
for (int i = 0; i < line.getSize(); i++)
|
|
iline.scanline[i] = iline.scanline[i] >> scalefactor;
|
|
} else if (line instanceof ImageLineByte) {
|
|
final ImageLineByte iline = (ImageLineByte) line;
|
|
for (int i = 0; i < line.getSize(); i++)
|
|
iline.scanline[i] = (byte) ((iline.scanline[i] & 0xFF) >> scalefactor);
|
|
}
|
|
} else
|
|
throw new PngjException("not implemented");
|
|
}
|
|
|
|
public static byte scaleUp(final int bitdepth, final byte v) {
|
|
return bitdepth < 8 ? (byte) ImageLineHelper.DEPTH_UNPACK[bitdepth][v] : v;
|
|
}
|
|
|
|
public static byte scaleDown(final int bitdepth, final byte v) {
|
|
return bitdepth < 8 ? (byte) (v >> 8 - bitdepth) : v;
|
|
}
|
|
|
|
/**
|
|
* Given an indexed line with a palette, unpacks as a RGB array, or RGBA if
|
|
* a non nul PngChunkTRNS chunk is passed
|
|
*
|
|
* @param line
|
|
* ImageLine as returned from PngReader
|
|
* @param pal
|
|
* Palette chunk
|
|
* @param trns
|
|
* Transparency chunk, can be null (absent)
|
|
* @param buf
|
|
* Preallocated array, optional
|
|
* @return R G B (A), one sample 0-255 per array element. Ready for
|
|
* pngw.writeRowInt()
|
|
*/
|
|
public static int[] palette2rgb(final ImageLineInt line, final PngChunkPLTE pal, final PngChunkTRNS trns,
|
|
final int[] buf) {
|
|
return ImageLineHelper.palette2rgb(line, pal, trns, buf, false);
|
|
}
|
|
|
|
/**
|
|
* Warning: the line should be upscaled, see
|
|
* {@link #scaleUp(IImageLineArray)}
|
|
*/
|
|
static int[] lineToARGB32(final ImageLineByte line, final PngChunkPLTE pal, final PngChunkTRNS trns, int[] buf) {
|
|
final boolean alphachannel = line.imgInfo.alpha;
|
|
final int cols = line.getImageInfo().cols;
|
|
if (buf == null || buf.length < cols)
|
|
buf = new int[cols];
|
|
int index, rgb, alpha, ga, g;
|
|
if (line.getImageInfo().indexed) {// palette
|
|
final int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
|
|
for (int c = 0; c < cols; c++) {
|
|
index = line.scanline[c] & 0xFF;
|
|
rgb = pal.getEntry(index);
|
|
alpha = index < nindexesWithAlpha ? trns.getPalletteAlpha()[index] : 255;
|
|
buf[c] = alpha << 24 | rgb;
|
|
}
|
|
} else if (line.imgInfo.greyscale) { // gray
|
|
ga = trns != null ? trns.getGray() : -1;
|
|
for (int c = 0, c2 = 0; c < cols; c++) {
|
|
g = line.scanline[c2++] & 0xFF;
|
|
alpha = alphachannel ? line.scanline[c2++] & 0xFF : g != ga ? 255 : 0;
|
|
buf[c] = alpha << 24 | g | g << 8 | g << 16;
|
|
}
|
|
} else { // true color
|
|
ga = trns != null ? trns.getRGB888() : -1;
|
|
for (int c = 0, c2 = 0; c < cols; c++) {
|
|
rgb = (line.scanline[c2++] & 0xFF) << 16 | (line.scanline[c2++] & 0xFF) << 8 | line.scanline[c2++] & 0xFF;
|
|
alpha = alphachannel ? line.scanline[c2++] & 0xFF : rgb != ga ? 255 : 0;
|
|
buf[c] = alpha << 24 | rgb;
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* Warning: the line should be upscaled, see
|
|
* {@link #scaleUp(IImageLineArray)}
|
|
*/
|
|
static byte[] lineToRGBA8888(final ImageLineByte line, final PngChunkPLTE pal, final PngChunkTRNS trns,
|
|
byte[] buf) {
|
|
final boolean alphachannel = line.imgInfo.alpha;
|
|
final int cols = line.imgInfo.cols;
|
|
final int bytes = cols * 4;
|
|
if (buf == null || buf.length < bytes)
|
|
buf = new byte[bytes];
|
|
int index, rgb, ga;
|
|
byte val;
|
|
if (line.imgInfo.indexed) {// palette
|
|
final int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
|
|
for (int c = 0, b = 0; c < cols; c++) {
|
|
index = line.scanline[c] & 0xFF;
|
|
rgb = pal.getEntry(index);
|
|
buf[b++] = (byte) (rgb >> 16 & 0xFF);
|
|
buf[b++] = (byte) (rgb >> 8 & 0xFF);
|
|
buf[b++] = (byte) (rgb & 0xFF);
|
|
buf[b++] = (byte) (index < nindexesWithAlpha ? trns.getPalletteAlpha()[index] : 255);
|
|
}
|
|
} else if (line.imgInfo.greyscale) { //
|
|
ga = trns != null ? trns.getGray() : -1;
|
|
for (int c = 0, b = 0; b < bytes;) {
|
|
val = line.scanline[c++];
|
|
buf[b++] = val;
|
|
buf[b++] = val;
|
|
buf[b++] = val;
|
|
buf[b++] = alphachannel ? line.scanline[c++] : (val & 0xFF) == ga ? (byte) 0 : (byte) 255;
|
|
}
|
|
} else if (alphachannel) // same format!
|
|
System.arraycopy(line.scanline, 0, buf, 0, bytes);
|
|
else
|
|
for (int c = 0, b = 0; b < bytes;) {
|
|
buf[b++] = line.scanline[c++];
|
|
buf[b++] = line.scanline[c++];
|
|
buf[b++] = line.scanline[c++];
|
|
buf[b++] = (byte) 255; // tentative (probable)
|
|
if (trns != null && buf[b - 3] == (byte) trns.getRGB()[0] && buf[b - 2] == (byte) trns.getRGB()[1] && buf[b - 1] == (byte) trns.getRGB()[2]) // not
|
|
// very
|
|
// efficient,
|
|
// but
|
|
// not
|
|
// frecuent
|
|
buf[b - 1] = 0;
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static byte[] lineToRGB888(final ImageLineByte line, final PngChunkPLTE pal, byte[] buf) {
|
|
final boolean alphachannel = line.imgInfo.alpha;
|
|
final int cols = line.imgInfo.cols;
|
|
final int bytes = cols * 3;
|
|
if (buf == null || buf.length < bytes)
|
|
buf = new byte[bytes];
|
|
byte val;
|
|
final int[] rgb = new int[3];
|
|
if (line.imgInfo.indexed)
|
|
for (int c = 0, b = 0; c < cols; c++) {
|
|
pal.getEntryRgb(line.scanline[c] & 0xFF, rgb);
|
|
buf[b++] = (byte) rgb[0];
|
|
buf[b++] = (byte) rgb[1];
|
|
buf[b++] = (byte) rgb[2];
|
|
}
|
|
else if (line.imgInfo.greyscale)
|
|
for (int c = 0, b = 0; b < bytes;) {
|
|
val = line.scanline[c++];
|
|
buf[b++] = val;
|
|
buf[b++] = val;
|
|
buf[b++] = val;
|
|
if (alphachannel)
|
|
c++; // skip alpha
|
|
}
|
|
else if (!alphachannel) // same format!
|
|
System.arraycopy(line.scanline, 0, buf, 0, bytes);
|
|
else
|
|
for (int c = 0, b = 0; b < bytes;) {
|
|
buf[b++] = line.scanline[c++];
|
|
buf[b++] = line.scanline[c++];
|
|
buf[b++] = line.scanline[c++];
|
|
c++;// skip alpha
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* Same as palette2rgbx , but returns rgba always, even if trns is null
|
|
*
|
|
* @param line
|
|
* ImageLine as returned from PngReader
|
|
* @param pal
|
|
* Palette chunk
|
|
* @param trns
|
|
* Transparency chunk, can be null (absent)
|
|
* @param buf
|
|
* Preallocated array, optional
|
|
* @return R G B (A), one sample 0-255 per array element. Ready for
|
|
* pngw.writeRowInt()
|
|
*/
|
|
public static int[] palette2rgba(final ImageLineInt line, final PngChunkPLTE pal, final PngChunkTRNS trns,
|
|
final int[] buf) {
|
|
return ImageLineHelper.palette2rgb(line, pal, trns, buf, true);
|
|
}
|
|
|
|
public static int[] palette2rgb(final ImageLineInt line, final PngChunkPLTE pal, final int[] buf) {
|
|
return ImageLineHelper.palette2rgb(line, pal, null, buf, false);
|
|
}
|
|
|
|
/** this is not very efficient, only for tests and troubleshooting */
|
|
public static int[] convert2rgba(final IImageLineArray line, final PngChunkPLTE pal, final PngChunkTRNS trns,
|
|
int[] buf) {
|
|
final ImageInfo imi = line.getImageInfo();
|
|
final int nsamples = imi.cols * 4;
|
|
if (buf == null || buf.length < nsamples)
|
|
buf = new int[nsamples];
|
|
final int maxval = imi.bitDepth == 16 ? (1 << 16) - 1 : 255;
|
|
Arrays.fill(buf, maxval);
|
|
|
|
if (imi.indexed) {
|
|
final int tlen = trns != null ? trns.getPalletteAlpha().length : 0;
|
|
for (int s = 0; s < imi.cols; s++) {
|
|
final int index = line.getElem(s);
|
|
pal.getEntryRgb(index, buf, s * 4);
|
|
if (index < tlen)
|
|
buf[s * 4 + 3] = trns.getPalletteAlpha()[index];
|
|
}
|
|
} else if (imi.greyscale) {
|
|
int[] unpack = null;
|
|
if (imi.bitDepth < 8)
|
|
unpack = ImageLineHelper.DEPTH_UNPACK[imi.bitDepth];
|
|
for (int s = 0, i = 0, p = 0; p < imi.cols; p++) {
|
|
buf[s++] = unpack != null ? unpack[line.getElem(i++)] : line.getElem(i++);
|
|
buf[s] = buf[s - 1];
|
|
s++;
|
|
buf[s] = buf[s - 1];
|
|
s++;
|
|
if (imi.channels == 2)
|
|
buf[s++] = unpack != null ? unpack[line.getElem(i++)] : line.getElem(i++);
|
|
else
|
|
buf[s++] = maxval;
|
|
}
|
|
} else
|
|
for (int s = 0, i = 0, p = 0; p < imi.cols; p++) {
|
|
buf[s++] = line.getElem(i++);
|
|
buf[s++] = line.getElem(i++);
|
|
buf[s++] = line.getElem(i++);
|
|
buf[s++] = imi.alpha ? line.getElem(i++) : maxval;
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
private static int[] palette2rgb(final IImageLine line, final PngChunkPLTE pal, final PngChunkTRNS trns, int[] buf,
|
|
final boolean alphaForced) {
|
|
final boolean isalpha = trns != null;
|
|
final int channels = isalpha ? 4 : 3;
|
|
final ImageLineInt linei = (ImageLineInt) (line instanceof ImageLineInt ? line : null);
|
|
final ImageLineByte lineb = (ImageLineByte) (line instanceof ImageLineByte ? line : null);
|
|
final boolean isbyte = lineb != null;
|
|
final int cols = linei != null ? linei.imgInfo.cols : lineb.imgInfo.cols;
|
|
final int nsamples = cols * channels;
|
|
if (buf == null || buf.length < nsamples)
|
|
buf = new int[nsamples];
|
|
final int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
|
|
for (int c = 0; c < cols; c++) {
|
|
final int index = isbyte ? lineb.scanline[c] & 0xFF : linei.scanline[c];
|
|
pal.getEntryRgb(index, buf, c * channels);
|
|
if (isalpha) {
|
|
final int alpha = index < nindexesWithAlpha ? trns.getPalletteAlpha()[index] : 255;
|
|
buf[c * channels + 3] = alpha;
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* what follows is pretty uninteresting/untested/obsolete, subject to change
|
|
*/
|
|
/**
|
|
* Just for basic info or debugging. Shows values for first and last pixel.
|
|
* Does not include alpha
|
|
*/
|
|
public static String infoFirstLastPixels(final ImageLineInt line) {
|
|
return line.imgInfo.channels == 1 ? String.format("first=(%d) last=(%d)", line.scanline[0], line.scanline[line.scanline.length - 1]) : String.format("first=(%d %d %d) last=(%d %d %d)", line.scanline[0], line.scanline[1], line.scanline[2], line.scanline[line.scanline.length - line.imgInfo.channels], line.scanline[line.scanline.length - line.imgInfo.channels + 1], line.scanline[line.scanline.length - line.imgInfo.channels + 2]);
|
|
}
|
|
|
|
/**
|
|
* integer packed R G B only for bitdepth=8! (does not check!)
|
|
*
|
|
**/
|
|
public static int getPixelRGB8(final IImageLine line, final int column) {
|
|
if (line instanceof ImageLineInt) {
|
|
final int offset = column * ((ImageLineInt) line).imgInfo.channels;
|
|
final int[] scanline = ((ImageLineInt) line).getScanline();
|
|
return scanline[offset] << 16 | scanline[offset + 1] << 8 | scanline[offset + 2];
|
|
} else if (line instanceof ImageLineByte) {
|
|
final int offset = column * ((ImageLineByte) line).imgInfo.channels;
|
|
final byte[] scanline = ((ImageLineByte) line).getScanline();
|
|
return (scanline[offset] & 0xff) << 16 | (scanline[offset + 1] & 0xff) << 8 | scanline[offset + 2] & 0xff;
|
|
} else
|
|
throw new PngjException("Not supported " + line.getClass());
|
|
}
|
|
|
|
public static int getPixelARGB8(final IImageLine line, final int column) {
|
|
if (line instanceof ImageLineInt) {
|
|
final int offset = column * ((ImageLineInt) line).imgInfo.channels;
|
|
final int[] scanline = ((ImageLineInt) line).getScanline();
|
|
return scanline[offset + 3] << 24 | scanline[offset] << 16 | scanline[offset + 1] << 8 | scanline[offset + 2];
|
|
} else if (line instanceof ImageLineByte) {
|
|
final int offset = column * ((ImageLineByte) line).imgInfo.channels;
|
|
final byte[] scanline = ((ImageLineByte) line).getScanline();
|
|
return (scanline[offset + 3] & 0xff) << 24 | (scanline[offset] & 0xff) << 16 | (scanline[offset + 1] & 0xff) << 8 | scanline[offset + 2] & 0xff;
|
|
} else
|
|
throw new PngjException("Not supported " + line.getClass());
|
|
}
|
|
|
|
public static void setPixelsRGB8(final ImageLineInt line, final int[] rgb) {
|
|
for (int i = 0, j = 0; i < line.imgInfo.cols; i++) {
|
|
line.scanline[j++] = rgb[i] >> 16 & 0xFF;
|
|
line.scanline[j++] = rgb[i] >> 8 & 0xFF;
|
|
line.scanline[j++] = rgb[i] & 0xFF;
|
|
}
|
|
}
|
|
|
|
public static void setPixelRGB8(final ImageLineInt line, int col, final int r, final int g, final int b) {
|
|
col *= line.imgInfo.channels;
|
|
line.scanline[col++] = r;
|
|
line.scanline[col++] = g;
|
|
line.scanline[col] = b;
|
|
}
|
|
|
|
public static void setPixelRGB8(final ImageLineInt line, final int col, final int rgb) {
|
|
ImageLineHelper.setPixelRGB8(line, col, rgb >> 16 & 0xFF, rgb >> 8 & 0xFF, rgb & 0xFF);
|
|
}
|
|
|
|
public static void setPixelsRGBA8(final ImageLineInt line, final int[] rgb) {
|
|
for (int i = 0, j = 0; i < line.imgInfo.cols; i++) {
|
|
line.scanline[j++] = rgb[i] >> 16 & 0xFF;
|
|
line.scanline[j++] = rgb[i] >> 8 & 0xFF;
|
|
line.scanline[j++] = rgb[i] & 0xFF;
|
|
line.scanline[j++] = rgb[i] >> 24 & 0xFF;
|
|
}
|
|
}
|
|
|
|
public static void setPixelRGBA8(final ImageLineInt line, int col, final int r, final int g, final int b,
|
|
final int a) {
|
|
col *= line.imgInfo.channels;
|
|
line.scanline[col++] = r;
|
|
line.scanline[col++] = g;
|
|
line.scanline[col++] = b;
|
|
line.scanline[col] = a;
|
|
}
|
|
|
|
public static void setPixelRGBA8(final ImageLineInt line, final int col, final int rgb) {
|
|
ImageLineHelper.setPixelRGBA8(line, col, rgb >> 16 & 0xFF, rgb >> 8 & 0xFF, rgb & 0xFF, rgb >> 24 & 0xFF);
|
|
}
|
|
|
|
public static void setValD(final ImageLineInt line, final int i, final double d) {
|
|
line.scanline[i] = ImageLineHelper.double2int(line, d);
|
|
}
|
|
|
|
public static int interpol(final int a, final int b, final int c, final int d, final double dx, final double dy) {
|
|
// a b -> x (0-1)
|
|
// c d
|
|
final double e = a * (1.0 - dx) + b * dx;
|
|
final double f = c * (1.0 - dx) + d * dx;
|
|
return (int) (e * (1 - dy) + f * dy + 0.5);
|
|
}
|
|
|
|
public static double int2double(final ImageLineInt line, final int p) {
|
|
return line.imgInfo.bitDepth == 16 ? p / 65535.0 : p / 255.0;
|
|
// TODO: replace my multiplication? check for other bitdepths
|
|
}
|
|
|
|
public static double int2doubleClamped(final ImageLineInt line, final int p) {
|
|
// TODO: replace my multiplication?
|
|
final double d = line.imgInfo.bitDepth == 16 ? p / 65535.0 : p / 255.0;
|
|
return d <= 0.0 ? 0 : d >= 1.0 ? 1.0 : d;
|
|
}
|
|
|
|
public static int double2int(final ImageLineInt line, double d) {
|
|
d = d <= 0.0 ? 0 : d >= 1.0 ? 1.0 : d;
|
|
return line.imgInfo.bitDepth == 16 ? (int) (d * 65535.0 + 0.5) : (int) (d * 255.0 + 0.5); //
|
|
}
|
|
|
|
public static int double2intClamped(final ImageLineInt line, double d) {
|
|
d = d <= 0.0 ? 0 : d >= 1.0 ? 1.0 : d;
|
|
return line.imgInfo.bitDepth == 16 ? (int) (d * 65535.0 + 0.5) : (int) (d * 255.0 + 0.5); //
|
|
}
|
|
|
|
public static int clampTo_0_255(final int i) {
|
|
return i > 255 ? 255 : i < 0 ? 0 : i;
|
|
}
|
|
|
|
public static int clampTo_0_65535(final int i) {
|
|
return i > 65535 ? 65535 : i < 0 ? 0 : i;
|
|
}
|
|
|
|
public static int clampTo_128_127(final int x) {
|
|
return x > 127 ? 127 : x < -128 ? -128 : x;
|
|
}
|
|
|
|
public static int getMaskForPackedFormats(final int bitDepth) { // Utility function for pack/unpack
|
|
if (bitDepth == 4)
|
|
return 0xf0;
|
|
else if (bitDepth == 2)
|
|
return 0xc0;
|
|
else
|
|
return 0x80; // bitDepth == 1
|
|
}
|
|
|
|
public static int getMaskForPackedFormatsLs(final int bitDepth) { // Utility function for pack/unpack
|
|
if (bitDepth == 4)
|
|
return 0x0f;
|
|
else if (bitDepth == 2)
|
|
return 0x03;
|
|
else
|
|
return 0x01; // bitDepth == 1
|
|
}
|
|
|
|
}
|