473 lines
16 KiB
Java
473 lines
16 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 {
|
|
initDepthScale();
|
|
}
|
|
|
|
private static void initDepthScale() {
|
|
DEPTH_UNPACK_1 = new int[2];
|
|
for (int i = 0; i < 2; i++)
|
|
DEPTH_UNPACK_1[i] = i * 255;
|
|
DEPTH_UNPACK_2 = new int[4];
|
|
for (int i = 0; i < 4; i++)
|
|
DEPTH_UNPACK_2[i] = (i * 255) / 3;
|
|
DEPTH_UNPACK_4 = new int[16];
|
|
for (int i = 0; i < 16; i++)
|
|
DEPTH_UNPACK_4[i] = (i * 255) / 15;
|
|
DEPTH_UNPACK = new int[][] { null, DEPTH_UNPACK_1, DEPTH_UNPACK_2, null, 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(IImageLineArray line) {
|
|
if (line.getImageInfo().indexed || line.getImageInfo().bitDepth >= 8)
|
|
return;
|
|
final int[] scaleArray = DEPTH_UNPACK[line.getImageInfo().bitDepth];
|
|
if (line instanceof ImageLineInt) {
|
|
ImageLineInt iline = (ImageLineInt) line;
|
|
for (int i = 0; i < iline.getSize(); i++)
|
|
iline.scanline[i] = scaleArray[iline.scanline[i]];
|
|
} else if (line instanceof ImageLineByte) {
|
|
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(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) {
|
|
ImageLineInt iline = (ImageLineInt) line;
|
|
for (int i = 0; i < line.getSize(); i++)
|
|
iline.scanline[i] = iline.scanline[i] >> scalefactor;
|
|
} else if (line instanceof ImageLineByte) {
|
|
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(int bitdepth, byte v) {
|
|
return bitdepth < 8 ? (byte) DEPTH_UNPACK[bitdepth][v] : v;
|
|
}
|
|
|
|
public static byte scaleDown(int bitdepth, 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(ImageLineInt line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
|
|
return palette2rgb(line, pal, trns, buf, false);
|
|
}
|
|
|
|
/**
|
|
* Warning: the line should be upscaled, see
|
|
* {@link #scaleUp(IImageLineArray)}
|
|
*/
|
|
static int[] lineToARGB32(ImageLineByte line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
|
|
boolean alphachannel = line.imgInfo.alpha;
|
|
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
|
|
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(ImageLineByte line, PngChunkPLTE pal, PngChunkTRNS trns, byte[] buf) {
|
|
boolean alphachannel = line.imgInfo.alpha;
|
|
int cols = line.imgInfo.cols;
|
|
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
|
|
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++] : ((int) (val & 0xFF) == ga) ? (byte) 0 : (byte) 255;
|
|
}
|
|
} else { // true color
|
|
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(ImageLineByte line, PngChunkPLTE pal, byte[] buf) {
|
|
boolean alphachannel = line.imgInfo.alpha;
|
|
int cols = line.imgInfo.cols;
|
|
int bytes = cols * 3;
|
|
if (buf == null || buf.length < bytes)
|
|
buf = new byte[bytes];
|
|
byte val;
|
|
int[] rgb = new int[3];
|
|
if (line.imgInfo.indexed) {// palette
|
|
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 { // true color
|
|
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(ImageLineInt line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
|
|
return palette2rgb(line, pal, trns, buf, true);
|
|
}
|
|
|
|
public static int[] palette2rgb(ImageLineInt line, PngChunkPLTE pal, int[] buf) {
|
|
return palette2rgb(line, pal, null, buf, false);
|
|
}
|
|
|
|
/** this is not very efficient, only for tests and troubleshooting */
|
|
public static int[] convert2rgba(IImageLineArray line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
|
|
ImageInfo imi = line.getImageInfo();
|
|
int nsamples = imi.cols * 4;
|
|
if (buf == null || buf.length < nsamples)
|
|
buf = new int[nsamples];
|
|
int maxval = imi.bitDepth == 16 ? (1 << 16) - 1 : 255;
|
|
Arrays.fill(buf, maxval);
|
|
|
|
if (imi.indexed) {
|
|
int tlen = trns != null ? trns.getPalletteAlpha().length : 0;
|
|
for (int s = 0; s < imi.cols; s++) {
|
|
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(IImageLine line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf,
|
|
boolean alphaForced) {
|
|
boolean isalpha = trns != null;
|
|
int channels = isalpha ? 4 : 3;
|
|
ImageLineInt linei = (ImageLineInt) (line instanceof ImageLineInt ? line : null);
|
|
ImageLineByte lineb = (ImageLineByte) (line instanceof ImageLineByte ? line : null);
|
|
boolean isbyte = lineb != null;
|
|
int cols = linei != null ? linei.imgInfo.cols : lineb.imgInfo.cols;
|
|
int nsamples = cols * channels;
|
|
if (buf == null || buf.length < nsamples)
|
|
buf = new int[nsamples];
|
|
int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
|
|
for (int c = 0; c < cols; c++) {
|
|
int index = isbyte ? (lineb.scanline[c] & 0xFF) : linei.scanline[c];
|
|
pal.getEntryRgb(index, buf, c * channels);
|
|
if (isalpha) {
|
|
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(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(IImageLine line, int column) {
|
|
if (line instanceof ImageLineInt) {
|
|
int offset = column * ((ImageLineInt) line).imgInfo.channels;
|
|
int[] scanline = ((ImageLineInt) line).getScanline();
|
|
return (scanline[offset] << 16) | (scanline[offset + 1] << 8) | (scanline[offset + 2]);
|
|
} else if (line instanceof ImageLineByte) {
|
|
int offset = column * ((ImageLineByte) line).imgInfo.channels;
|
|
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(IImageLine line, int column) {
|
|
if (line instanceof ImageLineInt) {
|
|
int offset = column * ((ImageLineInt) line).imgInfo.channels;
|
|
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) {
|
|
int offset = column * ((ImageLineByte) line).imgInfo.channels;
|
|
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(ImageLineInt line, 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(ImageLineInt line, int col, int r, int g, int b) {
|
|
col *= line.imgInfo.channels;
|
|
line.scanline[col++] = r;
|
|
line.scanline[col++] = g;
|
|
line.scanline[col] = b;
|
|
}
|
|
|
|
public static void setPixelRGB8(ImageLineInt line, int col, int rgb) {
|
|
setPixelRGB8(line, col, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
|
|
}
|
|
|
|
public static void setPixelsRGBA8(ImageLineInt line, 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(ImageLineInt line, int col, int r, int g, int b, 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(ImageLineInt line, int col, int rgb) {
|
|
setPixelRGBA8(line, col, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF, (rgb >> 24) & 0xFF);
|
|
}
|
|
|
|
public static void setValD(ImageLineInt line, int i, double d) {
|
|
line.scanline[i] = double2int(line, d);
|
|
}
|
|
|
|
public static int interpol(int a, int b, int c, int d, double dx, double dy) {
|
|
// a b -> x (0-1)
|
|
// c d
|
|
double e = a * (1.0 - dx) + b * dx;
|
|
double f = c * (1.0 - dx) + d * dx;
|
|
return (int) (e * (1 - dy) + f * dy + 0.5);
|
|
}
|
|
|
|
public static double int2double(ImageLineInt line, 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(ImageLineInt line, int p) {
|
|
// TODO: replace my multiplication?
|
|
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(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(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(int i) {
|
|
return i > 255 ? 255 : (i < 0 ? 0 : i);
|
|
}
|
|
|
|
public static int clampTo_0_65535(int i) {
|
|
return i > 65535 ? 65535 : (i < 0 ? 0 : i);
|
|
}
|
|
|
|
public static int clampTo_128_127(int x) {
|
|
return x > 127 ? 127 : (x < -128 ? -128 : x);
|
|
}
|
|
|
|
public static int getMaskForPackedFormats(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(int bitDepth) { // Utility function for pack/unpack
|
|
if (bitDepth == 4)
|
|
return 0x0f;
|
|
else if (bitDepth == 2)
|
|
return 0x03;
|
|
else
|
|
return 0x01; // bitDepth == 1
|
|
}
|
|
|
|
}
|