1.3.2 preparations
This commit is contained in:
Arndt
parent
14a18fd770
commit
3e50846135
17 changed files with 1929 additions and 1906 deletions
|
|
@ -1,464 +1,170 @@
|
|||
package btools.util;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.zip.*;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.zip.CRC32;
|
||||
import java.util.zip.Deflater;
|
||||
import java.util.zip.DeflaterOutputStream;
|
||||
|
||||
public class Raster2Png extends Object {
|
||||
public class Raster2Png extends ByteDataWriter
|
||||
{
|
||||
/** Constants for filter (NONE) */
|
||||
public static final int FILTER_NONE = 0;
|
||||
|
||||
/** Constant specifying that alpha channel should be encoded. */
|
||||
public static final boolean ENCODE_ALPHA = true;
|
||||
/** IHDR tag. */
|
||||
protected static final byte IHDR[] = { 73, 72, 68, 82 };
|
||||
|
||||
/** Constant specifying that alpha channel should not be encoded. */
|
||||
public static final boolean NO_ALPHA = false;
|
||||
/** IDAT tag. */
|
||||
protected static final byte IDAT[] = { 73, 68, 65, 84 };
|
||||
|
||||
/** Constants for filter (NONE) */
|
||||
public static final int FILTER_NONE = 0;
|
||||
/** IEND tag. */
|
||||
protected static final byte IEND[] = { 73, 69, 78, 68 };
|
||||
|
||||
/** Constants for filter (SUB) */
|
||||
public static final int FILTER_SUB = 1;
|
||||
/** geometry */
|
||||
protected int width, height;
|
||||
|
||||
/** Constants for filter (UP) */
|
||||
public static final int FILTER_UP = 2;
|
||||
protected int[] imagePixels;
|
||||
|
||||
/** Constants for filter (LAST) */
|
||||
public static final int FILTER_LAST = 2;
|
||||
|
||||
/** IHDR tag. */
|
||||
protected static final byte IHDR[] = {73, 72, 68, 82};
|
||||
|
||||
/** IDAT tag. */
|
||||
protected static final byte IDAT[] = {73, 68, 65, 84};
|
||||
|
||||
/** IEND tag. */
|
||||
protected static final byte IEND[] = {73, 69, 78, 68};
|
||||
/** CRC. */
|
||||
protected CRC32 crc = new CRC32();
|
||||
|
||||
/** The png bytes. */
|
||||
protected byte[] pngBytes;
|
||||
public Raster2Png()
|
||||
{
|
||||
super( null );
|
||||
}
|
||||
|
||||
/** The prior row. */
|
||||
protected byte[] priorRow;
|
||||
/**
|
||||
* Converts a pixel array to it's PNG equivalent
|
||||
*/
|
||||
public byte[] pngEncode( int width, int height, int[] imagePixels ) throws IOException
|
||||
{
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
this.imagePixels = imagePixels;
|
||||
|
||||
/** The left bytes. */
|
||||
protected byte[] leftBytes;
|
||||
// user a buffer large enough to hold the png
|
||||
ab = new byte[( ( width + 1 ) * height * 3 ) + 200];
|
||||
|
||||
/** The width. */
|
||||
protected int width, height;
|
||||
byte[] pngIdBytes =
|
||||
{ -119, 80, 78, 71, 13, 10, 26, 10 };
|
||||
write( pngIdBytes );
|
||||
writeHeader();
|
||||
writeImageData();
|
||||
return toByteArray();
|
||||
}
|
||||
|
||||
/** The byte position. */
|
||||
protected int bytePos, maxPos;
|
||||
/**
|
||||
* Write a PNG "IHDR" chunk into the pngBytes array.
|
||||
*/
|
||||
protected void writeHeader()
|
||||
{
|
||||
writeInt( 13 );
|
||||
int startPos = aboffset;
|
||||
write( IHDR );
|
||||
writeInt( width );
|
||||
writeInt( height );
|
||||
writeByte( 8 ); // bit depth
|
||||
writeByte( 2 ); // direct model
|
||||
writeByte( 0 ); // compression method
|
||||
writeByte( 0 ); // filter method
|
||||
writeByte( 0 ); // no interlace
|
||||
crc.reset();
|
||||
crc.update( ab, startPos, aboffset - startPos );
|
||||
writeInt( (int) crc.getValue() );
|
||||
}
|
||||
|
||||
protected int[] imagePixels;
|
||||
/**
|
||||
* Write the image data into the pngBytes array. This will write one or more
|
||||
* PNG "IDAT" chunks. In order to conserve memory, this method grabs as many
|
||||
* rows as will fit into 32K bytes, or the whole image; whichever is less.
|
||||
*/
|
||||
protected void writeImageData() throws IOException
|
||||
{
|
||||
int rowsLeft = height; // number of rows remaining to write
|
||||
int startRow = 0; // starting row to process this time through
|
||||
int nRows; // how many rows to grab at a time
|
||||
|
||||
/** CRC. */
|
||||
protected CRC32 crc = new CRC32();
|
||||
byte[] scanLines; // the scan lines to be compressed
|
||||
int scanPos; // where we are in the scan lines
|
||||
|
||||
/** The CRC value. */
|
||||
protected long crcValue;
|
||||
byte[] compressedLines; // the resultant compressed lines
|
||||
int nCompressed; // how big is the compressed area?
|
||||
|
||||
/** The filter type. */
|
||||
protected int filter;
|
||||
int bytesPerPixel = 3;
|
||||
|
||||
/** The bytes-per-pixel. */
|
||||
protected int bytesPerPixel;
|
||||
Deflater scrunch = new Deflater( 6 );
|
||||
ByteArrayOutputStream outBytes = new ByteArrayOutputStream( 1024 );
|
||||
|
||||
/** The compression level. */
|
||||
protected int compressionLevel;
|
||||
|
||||
private boolean encodeAlpha = false;
|
||||
|
||||
/**
|
||||
* Class constructor specifying filter to use and compression level.
|
||||
*
|
||||
* @param whichFilter 0=none, 1=sub, 2=up
|
||||
* @param compLevel 0..9
|
||||
*/
|
||||
public Raster2Png(int whichFilter, int compLevel, int width, int height, int[] imagePixels ) {
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
this.imagePixels = imagePixels;
|
||||
|
||||
setFilter(whichFilter);
|
||||
|
||||
if (compLevel >= 0 && compLevel <= 9) {
|
||||
this.compressionLevel = compLevel;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an array of bytes that is the PNG equivalent of the current image, specifying
|
||||
* whether to encode alpha or not.
|
||||
*
|
||||
* @param encodeAlpha boolean false=no alpha, true=encode alpha
|
||||
* @return an array of bytes, or null if there was a problem
|
||||
*/
|
||||
public byte[] pngEncode() {
|
||||
byte[] pngIdBytes = {-119, 80, 78, 71, 13, 10, 26, 10};
|
||||
|
||||
if (imagePixels == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/*
|
||||
* start with an array that is big enough to hold all the pixels
|
||||
* (plus filter bytes), and an extra 200 bytes for header info
|
||||
*/
|
||||
pngBytes = new byte[((width + 1) * height * 3) + 200];
|
||||
|
||||
/*
|
||||
* keep track of largest byte written to the array
|
||||
*/
|
||||
maxPos = 0;
|
||||
|
||||
bytePos = writeBytes(pngIdBytes, 0);
|
||||
//hdrPos = bytePos;
|
||||
writeHeader();
|
||||
//dataPos = bytePos;
|
||||
if (writeImageData()) {
|
||||
writeEnd();
|
||||
pngBytes = resizeByteArray(pngBytes, maxPos);
|
||||
}
|
||||
else {
|
||||
pngBytes = null;
|
||||
}
|
||||
return pngBytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the filter to use
|
||||
*
|
||||
* @param whichFilter from constant list
|
||||
*/
|
||||
public void setFilter(int whichFilter) {
|
||||
this.filter = FILTER_NONE;
|
||||
if (whichFilter <= FILTER_LAST) {
|
||||
this.filter = whichFilter;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the compression level to use
|
||||
*
|
||||
* @param level 0 through 9
|
||||
*/
|
||||
public void setCompressionLevel(int level) {
|
||||
if (level >= 0 && level <= 9) {
|
||||
this.compressionLevel = level;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Increase or decrease the length of a byte array.
|
||||
*
|
||||
* @param array The original array.
|
||||
* @param newLength The length you wish the new array to have.
|
||||
* @return Array of newly desired length. If shorter than the
|
||||
* original, the trailing elements are truncated.
|
||||
*/
|
||||
protected byte[] resizeByteArray(byte[] array, int newLength) {
|
||||
byte[] newArray = new byte[newLength];
|
||||
int oldLength = array.length;
|
||||
|
||||
System.arraycopy(array, 0, newArray, 0, Math.min(oldLength, newLength));
|
||||
return newArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write an array of bytes into the pngBytes array.
|
||||
* Note: This routine has the side effect of updating
|
||||
* maxPos, the largest element written in the array.
|
||||
* The array is resized by 1000 bytes or the length
|
||||
* of the data to be written, whichever is larger.
|
||||
*
|
||||
* @param data The data to be written into pngBytes.
|
||||
* @param offset The starting point to write to.
|
||||
* @return The next place to be written to in the pngBytes array.
|
||||
*/
|
||||
protected int writeBytes(byte[] data, int offset) {
|
||||
maxPos = Math.max(maxPos, offset + data.length);
|
||||
if (data.length + offset > pngBytes.length) {
|
||||
pngBytes = resizeByteArray(pngBytes, pngBytes.length + Math.max(1000, data.length));
|
||||
}
|
||||
System.arraycopy(data, 0, pngBytes, offset, data.length);
|
||||
return offset + data.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write an array of bytes into the pngBytes array, specifying number of bytes to write.
|
||||
* Note: This routine has the side effect of updating
|
||||
* maxPos, the largest element written in the array.
|
||||
* The array is resized by 1000 bytes or the length
|
||||
* of the data to be written, whichever is larger.
|
||||
*
|
||||
* @param data The data to be written into pngBytes.
|
||||
* @param nBytes The number of bytes to be written.
|
||||
* @param offset The starting point to write to.
|
||||
* @return The next place to be written to in the pngBytes array.
|
||||
*/
|
||||
protected int writeBytes(byte[] data, int nBytes, int offset) {
|
||||
maxPos = Math.max(maxPos, offset + nBytes);
|
||||
if (nBytes + offset > pngBytes.length) {
|
||||
pngBytes = resizeByteArray(pngBytes, pngBytes.length + Math.max(1000, nBytes));
|
||||
}
|
||||
System.arraycopy(data, 0, pngBytes, offset, nBytes);
|
||||
return offset + nBytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a two-byte integer into the pngBytes array at a given position.
|
||||
*
|
||||
* @param n The integer to be written into pngBytes.
|
||||
* @param offset The starting point to write to.
|
||||
* @return The next place to be written to in the pngBytes array.
|
||||
*/
|
||||
protected int writeInt2(int n, int offset) {
|
||||
byte[] temp = {(byte) ((n >> 8) & 0xff), (byte) (n & 0xff)};
|
||||
return writeBytes(temp, offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a four-byte integer into the pngBytes array at a given position.
|
||||
*
|
||||
* @param n The integer to be written into pngBytes.
|
||||
* @param offset The starting point to write to.
|
||||
* @return The next place to be written to in the pngBytes array.
|
||||
*/
|
||||
protected int writeInt4(int n, int offset) {
|
||||
byte[] temp = {(byte) ((n >> 24) & 0xff),
|
||||
(byte) ((n >> 16) & 0xff),
|
||||
(byte) ((n >> 8) & 0xff),
|
||||
(byte) (n & 0xff)};
|
||||
return writeBytes(temp, offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a single byte into the pngBytes array at a given position.
|
||||
*
|
||||
* @param b The integer to be written into pngBytes.
|
||||
* @param offset The starting point to write to.
|
||||
* @return The next place to be written to in the pngBytes array.
|
||||
*/
|
||||
protected int writeByte(int b, int offset) {
|
||||
byte[] temp = {(byte) b};
|
||||
return writeBytes(temp, offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a PNG "IHDR" chunk into the pngBytes array.
|
||||
*/
|
||||
protected void writeHeader() {
|
||||
int startPos;
|
||||
|
||||
startPos = bytePos = writeInt4(13, bytePos);
|
||||
bytePos = writeBytes(IHDR, bytePos);
|
||||
bytePos = writeInt4(width, bytePos);
|
||||
bytePos = writeInt4(height, bytePos);
|
||||
bytePos = writeByte(8, bytePos); // bit depth
|
||||
bytePos = writeByte((encodeAlpha) ? 6 : 2, bytePos); // direct model
|
||||
bytePos = writeByte(0, bytePos); // compression method
|
||||
bytePos = writeByte(0, bytePos); // filter method
|
||||
bytePos = writeByte(0, bytePos); // no interlace
|
||||
crc.reset();
|
||||
crc.update(pngBytes, startPos, bytePos - startPos);
|
||||
crcValue = crc.getValue();
|
||||
bytePos = writeInt4((int) crcValue, bytePos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform "sub" filtering on the given row.
|
||||
* Uses temporary array leftBytes to store the original values
|
||||
* of the previous pixels. The array is 16 bytes long, which
|
||||
* will easily hold two-byte samples plus two-byte alpha.
|
||||
*
|
||||
* @param pixels The array holding the scan lines being built
|
||||
* @param startPos Starting position within pixels of bytes to be filtered.
|
||||
* @param width Width of a scanline in pixels.
|
||||
*/
|
||||
protected void filterSub(byte[] pixels, int startPos, int width) {
|
||||
int i;
|
||||
int offset = bytesPerPixel;
|
||||
int actualStart = startPos + offset;
|
||||
int nBytes = width * bytesPerPixel;
|
||||
int leftInsert = offset;
|
||||
int leftExtract = 0;
|
||||
|
||||
for (i = actualStart; i < startPos + nBytes; i++) {
|
||||
leftBytes[leftInsert] = pixels[i];
|
||||
pixels[i] = (byte) ((pixels[i] - leftBytes[leftExtract]) % 256);
|
||||
leftInsert = (leftInsert + 1) % 0x0f;
|
||||
leftExtract = (leftExtract + 1) % 0x0f;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform "up" filtering on the given row.
|
||||
* Side effect: refills the prior row with current row
|
||||
*
|
||||
* @param pixels The array holding the scan lines being built
|
||||
* @param startPos Starting position within pixels of bytes to be filtered.
|
||||
* @param width Width of a scanline in pixels.
|
||||
*/
|
||||
protected void filterUp(byte[] pixels, int startPos, int width) {
|
||||
int i, nBytes;
|
||||
byte currentByte;
|
||||
|
||||
nBytes = width * bytesPerPixel;
|
||||
|
||||
for (i = 0; i < nBytes; i++) {
|
||||
currentByte = pixels[startPos + i];
|
||||
pixels[startPos + i] = (byte) ((pixels[startPos + i] - priorRow[i]) % 256);
|
||||
priorRow[i] = currentByte;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write the image data into the pngBytes array.
|
||||
* This will write one or more PNG "IDAT" chunks. In order
|
||||
* to conserve memory, this method grabs as many rows as will
|
||||
* fit into 32K bytes, or the whole image; whichever is less.
|
||||
*
|
||||
*
|
||||
* @return true if no errors; false if error grabbing pixels
|
||||
*/
|
||||
protected boolean writeImageData() {
|
||||
int rowsLeft = height; // number of rows remaining to write
|
||||
int startRow = 0; // starting row to process this time through
|
||||
int nRows; // how many rows to grab at a time
|
||||
|
||||
byte[] scanLines; // the scan lines to be compressed
|
||||
int scanPos; // where we are in the scan lines
|
||||
int startPos; // where this line's actual pixels start (used for filtering)
|
||||
|
||||
byte[] compressedLines; // the resultant compressed lines
|
||||
int nCompressed; // how big is the compressed area?
|
||||
|
||||
//int depth; // color depth ( handle only 8 or 32 )
|
||||
|
||||
// PixelGrabber pg;
|
||||
|
||||
bytesPerPixel = (encodeAlpha) ? 4 : 3;
|
||||
|
||||
Deflater scrunch = new Deflater(compressionLevel);
|
||||
ByteArrayOutputStream outBytes = new ByteArrayOutputStream(1024);
|
||||
|
||||
DeflaterOutputStream compBytes = new DeflaterOutputStream(outBytes, scrunch);
|
||||
try {
|
||||
while (rowsLeft > 0) {
|
||||
nRows = Math.min(32767 / (width * (bytesPerPixel + 1)), rowsLeft);
|
||||
nRows = Math.max( nRows, 1 );
|
||||
|
||||
int[] pixels = new int[width * nRows];
|
||||
|
||||
getPixels(startRow, nRows, pixels);
|
||||
|
||||
/*
|
||||
* Create a data chunk. scanLines adds "nRows" for
|
||||
* the filter bytes.
|
||||
*/
|
||||
scanLines = new byte[width * nRows * bytesPerPixel + nRows];
|
||||
|
||||
if (filter == FILTER_SUB) {
|
||||
leftBytes = new byte[16];
|
||||
}
|
||||
if (filter == FILTER_UP) {
|
||||
priorRow = new byte[width * bytesPerPixel];
|
||||
}
|
||||
|
||||
scanPos = 0;
|
||||
startPos = 1;
|
||||
for (int i = 0; i < width * nRows; i++) {
|
||||
if (i % width == 0) {
|
||||
scanLines[scanPos++] = (byte) filter;
|
||||
startPos = scanPos;
|
||||
}
|
||||
scanLines[scanPos++] = (byte) ((pixels[i] >> 16) & 0xff);
|
||||
scanLines[scanPos++] = (byte) ((pixels[i] >> 8) & 0xff);
|
||||
scanLines[scanPos++] = (byte) ((pixels[i]) & 0xff);
|
||||
if (encodeAlpha) {
|
||||
scanLines[scanPos++] = (byte) ((pixels[i] >> 24) & 0xff);
|
||||
}
|
||||
if ((i % width == width - 1) && (filter != FILTER_NONE)) {
|
||||
if (filter == FILTER_SUB) {
|
||||
filterSub(scanLines, startPos, width);
|
||||
}
|
||||
if (filter == FILTER_UP) {
|
||||
filterUp(scanLines, startPos, width);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Write these lines to the output area
|
||||
*/
|
||||
compBytes.write(scanLines, 0, scanPos);
|
||||
|
||||
startRow += nRows;
|
||||
rowsLeft -= nRows;
|
||||
}
|
||||
compBytes.close();
|
||||
|
||||
/*
|
||||
* Write the compressed bytes
|
||||
*/
|
||||
compressedLines = outBytes.toByteArray();
|
||||
nCompressed = compressedLines.length;
|
||||
|
||||
crc.reset();
|
||||
bytePos = writeInt4(nCompressed, bytePos);
|
||||
bytePos = writeBytes(IDAT, bytePos);
|
||||
crc.update(IDAT);
|
||||
bytePos = writeBytes(compressedLines, nCompressed, bytePos);
|
||||
crc.update(compressedLines, 0, nCompressed);
|
||||
|
||||
crcValue = crc.getValue();
|
||||
bytePos = writeInt4((int) crcValue, bytePos);
|
||||
scrunch.finish();
|
||||
return true;
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.err.println(e.toString());
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a PNG "IEND" chunk into the pngBytes array.
|
||||
*/
|
||||
protected void writeEnd() {
|
||||
bytePos = writeInt4(0, bytePos);
|
||||
bytePos = writeBytes(IEND, bytePos);
|
||||
crc.reset();
|
||||
crc.update(IEND);
|
||||
crcValue = crc.getValue();
|
||||
bytePos = writeInt4((int) crcValue, bytePos);
|
||||
}
|
||||
|
||||
private void getPixels( int startRow, int nRows, int[] pixels)
|
||||
DeflaterOutputStream compBytes = new DeflaterOutputStream( outBytes, scrunch );
|
||||
while (rowsLeft > 0)
|
||||
{
|
||||
for( int i=0; i<nRows; i++ )
|
||||
{
|
||||
int ir = i + startRow;
|
||||
for( int ic=0; ic<width; ic++ )
|
||||
{
|
||||
pixels[ i*width + ic ] = imagePixels[ ir*width + ic];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private int pseudoLog( short sval )
|
||||
{
|
||||
int val = 30 + sval;
|
||||
if ( val < 0 ) { val = 0; }
|
||||
if ( val > 2000 ) return 255;
|
||||
int res = 0;
|
||||
int div = 1;
|
||||
while ( val > 0 )
|
||||
{
|
||||
int d = val > 127 ? 127 : val;
|
||||
val -= d;
|
||||
res += d / div;
|
||||
div *= 2;
|
||||
}
|
||||
return res < 255 ? res : 255;
|
||||
}
|
||||
nRows = Math.min( 32767 / ( width * ( bytesPerPixel + 1 ) ), rowsLeft );
|
||||
nRows = Math.max( nRows, 1 );
|
||||
|
||||
int[] pixels = new int[width * nRows];
|
||||
|
||||
getPixels( startRow, nRows, pixels );
|
||||
|
||||
/*
|
||||
* Create a data chunk. scanLines adds "nRows" for the filter bytes.
|
||||
*/
|
||||
scanLines = new byte[width * nRows * bytesPerPixel + nRows];
|
||||
|
||||
scanPos = 0;
|
||||
for ( int i = 0; i < width * nRows; i++ )
|
||||
{
|
||||
if ( i % width == 0 )
|
||||
{
|
||||
scanLines[scanPos++] = (byte) FILTER_NONE;
|
||||
}
|
||||
scanLines[scanPos++] = (byte) ( ( pixels[i] >> 16 ) & 0xff );
|
||||
scanLines[scanPos++] = (byte) ( ( pixels[i] >> 8 ) & 0xff );
|
||||
scanLines[scanPos++] = (byte) ( ( pixels[i] ) & 0xff );
|
||||
}
|
||||
|
||||
/*
|
||||
* Write these lines to the output area
|
||||
*/
|
||||
compBytes.write( scanLines, 0, scanPos );
|
||||
|
||||
startRow += nRows;
|
||||
rowsLeft -= nRows;
|
||||
}
|
||||
compBytes.close();
|
||||
|
||||
/*
|
||||
* Write the compressed bytes
|
||||
*/
|
||||
compressedLines = outBytes.toByteArray();
|
||||
nCompressed = compressedLines.length;
|
||||
|
||||
crc.reset();
|
||||
writeInt( nCompressed );
|
||||
write( IDAT );
|
||||
crc.update( IDAT );
|
||||
write( compressedLines );
|
||||
crc.update( compressedLines, 0, nCompressed );
|
||||
|
||||
writeInt( (int) crc.getValue() );
|
||||
scrunch.finish();
|
||||
|
||||
// Write a PNG "IEND" chunk into the pngBytes array.
|
||||
writeInt( 0 );
|
||||
write( IEND );
|
||||
crc.reset();
|
||||
crc.update( IEND );
|
||||
writeInt( (int) crc.getValue() );
|
||||
}
|
||||
|
||||
private void getPixels( int startRow, int nRows, int[] pixels )
|
||||
{
|
||||
for ( int i = 0; i < nRows; i++ )
|
||||
{
|
||||
int ir = i + startRow;
|
||||
for ( int ic = 0; ic < width; ic++ )
|
||||
{
|
||||
pixels[i * width + ic] = imagePixels[ir * width + ic];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue