Input - npedotnet/npe-image-library GitHub Wiki

Input

DDS/PSD/TGA input support

Create from a TGA file

import java.io.FileInputStream;
import java.io.IOException;

import net.npe.image.PixelFormat;
import net.npe.image.PixelImage;
import net.npe.image.util.ImageReader;
import net.npe.image.util.ImageType;

public class Test {

  public static void main(String [] args) {

    try {
      FileInputStream fis = new FileInputStream("test.tga");
      byte [] buffer = new byte[fis.available()];
      fis.read(buffer);
      fis.close();

      PixelImage image = ImageReader.read(ImageType.TGA, PixelFormat.ARGB, buffer, 0);
    }
    catch(IOException e) {
      e.printStackTrace();
    }

  }

}

BufferedImage with ImageIO

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import net.npe.image.PixelFormat;
import net.npe.image.PixelImage;
import net.npe.image.util.ImageReader;
import net.npe.image.util.ImageType;

public class Test {

  public static void main(String [] args) {

    try {
      BufferedImage bufferedImage = ImageIO.read(new File("test.png"));
      int width = bufferedImage.getWidth();
      int height = bufferedImage.getHeight();
      int [] pixels = bufferedImage.getRGB(0, 0, width, height, null, 0, width);

      PixelImage image = new PixelImage(pixels, width, height, PixelFormat.ARGB);
    }
    catch(IOException e) {
      e.printStackTrace();
    }

  }

}

OpenGL Texture (JOGL)

import java.io.FileInputStream;
import java.io.IOException;

import java.nio.IntBuffer;

import net.npe.image.PixelFormat;
import net.npe.image.PixelImage;
import net.npe.image.util.ImageReader;
import net.npe.image.util.ImageType;

try {
  FileInputStream fis = new FileInputStream("test.tga");
  byte [] buffer = new byte[fis.available()];
  fis.read(buffer);
  fis.close();

  PixelImage image = ImageReader.read(ImageType.TGA, PixelFormat.ABGR, buffer, 0);

  int [] pixels = image.getPixels();
  int width = image.getWidth();
  int height = image.getHeight();

  gl.glEnable(GL_TEXTURE_2D);
  gl.glBindTexture(GL_TEXTURE_2D, texture);
  gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

  IntBuffer buffer = IntBuffer.wrap(pixels);
  gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);

  gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
catch(IOException e) {
  e.printStackTrace();
}

Android Bitmap

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;

private Bitmap createTGABitmap(String path) {
  Bitmap bitmap = null;
  try {
    InputStream is = getAssets().open(path);
    byte [] buffer = new byte[is.available()];
    is.read(buffer);
    is.close();

    PixelImage image = ImageReader.read(ImageType.TGA, PixelForamt.ARGB, buffer, 0);

    int [] pixels = image.getPixels();
    int width = image.getWidth();
    int height = image.getHeight();

    bitmap = Bitmap.createBitmap(pixels, 0, width, width, height, Config.ARGB_8888);
  }
  catch(Exception e) {
    e.printStackTrace();
  }
  return bitmap;
}

Android OpenGL Texture

import javax.microedition.khronos.opengles.GL10;

import static javax.microedition.khronos.opengles.GL10.*;

public int createTGATexture(GL10 gl, String path) {
  int texture = 0;
  try {

    InputStream is = getContext().getAssets().open(path);
    byte [] buffer = new byte[is.available()];
    is.read(buffer);
    is.close();

    PixelImage image = ImageReader.read(ImageType.TGA, PixelForamt.ABGR, buffer, 0);

    int [] pixels = image.getPixels();
    int width = image.getWidth();
    int height = image.getHeight();

    int [] textures = new int[1];
    gl.glGenTextures(1, textures, 0);

    gl.glEnable(GL_TEXTURE_2D);
    gl.glBindTexture(GL_TEXTURE_2D, textures[0]);
    gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    IntBuffer texBuffer = IntBuffer.wrap(pixels);
    gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, texBuffer);

    gl.glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    gl.glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    gl.glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    gl.glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    texture = textures[0];

  }
  catch (IOException e) {
    e.printStackTrace();
  }

  return texture;
}

GWT HTML5 Canvas

import com.google.gwt.canvas.client.Canvas;
import com.google.gwt.canvas.dom.client.CanvasPixelArray;
import com.google.gwt.canvas.dom.client.Context2d;
import com.google.gwt.canvas.dom.client.ImageData;
import com.google.gwt.typedarrays.client.Uint8ArrayNative;
import com.google.gwt.typedarrays.shared.ArrayBuffer;
import com.google.gwt.xhr.client.ReadyStateChangeHandler;
import com.google.gwt.xhr.client.XMLHttpRequest;
import com.google.gwt.xhr.client.XMLHttpRequest.ResponseType;

private void addTGACanvas(String url) {
  XMLHttpRequest request = XMLHttpRequest.create();
  request.open("GET", url);
  request.setResponseType(ResponseType.ArrayBuffer);
  request.setOnReadyStateChange(new ReadyStateChangeHandler() {
    @Override
    public void onReadyStateChange(XMLHttpRequest xhr) {
      if(xhr.getReadyState() == XMLHttpRequest.DONE) {
        if(xhr.getStatus() >= 400) {
          // error
          System.out.println("Error");
        }
        else {
          try {
            ArrayBuffer arrayBuffer = xhr.getResponseArrayBuffer();
            Uint8ArrayNative u8array = Uint8ArrayNative.create(arrayBuffer);
            byte [] buffer = new byte[u8array.length()];
            for(int i=0; i<buffer.length; i++) {
              buffer[i] = (byte)u8array.get(i);
            }

            PixelImage image = new ImageReader.read(ImageType.TGA, PixelFormat.ABGR, buffer, 0);

            Canvas canvas = createImageCanvas(image);
            panel.add(canvas);
          }
          catch(Exception e) {
            e.printStackTrace();
          }
        }
      }
    }
  });
  request.send();
}

private Canvas createImageCanvas(PixelImage image) {

  int [] pixels = image.getPixels();
  int width = image.getWidth();
  int height = image.getHeight();

  Canvas canvas = Canvas.createIfSupported();
  canvas.setCoordinateSpaceWidth(width);
  canvas.setCoordinateSpaceHeight(height);

  Context2d context = canvas.getContext2d();
  ImageData data = context.createImageData(width, height);

  CanvasPixelArray array = data.getData();
  for(int i=0; i<width*height; i++) { // ABGR
    array.set(4*i+0, pixels[i] & 0xFF);
    array.set(4*i+1, (pixels[i] >> 8) & 0xFF);
    array.set(4*i+2, (pixels[i] >> 16) & 0xFF);
    array.set(4*i+3, (pixels[i] >> 24) & 0xFF);
  }
  context.putImageData(data, 0, 0);

  return canvas;

}

GWT WebGL Texture (GwtGL)

import com.google.gwt.canvas.client.Canvas;
import com.google.gwt.canvas.dom.client.CanvasPixelArray;
import com.google.gwt.canvas.dom.client.Context2d;
import com.google.gwt.canvas.dom.client.ImageData;
import com.google.gwt.typedarrays.client.Uint8ArrayNative;
import com.google.gwt.typedarrays.shared.ArrayBuffer;
import com.google.gwt.xhr.client.ReadyStateChangeHandler;
import com.google.gwt.xhr.client.XMLHttpRequest;
import com.google.gwt.xhr.client.XMLHttpRequest.ResponseType;

import com.googlecode.gwtgl.binding.WebGLRenderingContext;
import com.googlecode.gwtgl.binding.WebGLTexture;

import static com.googlecode.gwtgl.binding.WebGLRenderingContext.*;

private void addTGACanvas(String url) {
  XMLHttpRequest request = XMLHttpRequest.create();
  request.open("GET", url);
  request.setResponseType(ResponseType.ArrayBuffer);
  request.setOnReadyStateChange(new ReadyStateChangeHandler() {
    @Override
    public void onReadyStateChange(XMLHttpRequest xhr) {
      if(xhr.getReadyState() == XMLHttpRequest.DONE) {
        if(xhr.getStatus() >= 400) {
          // error
          System.out.println("Error");
        }
        else {
          try {
            ArrayBuffer arrayBuffer = xhr.getResponseArrayBuffer();
            Uint8ArrayNative u8array = Uint8ArrayNative.create(arrayBuffer);
            byte [] buffer = new byte[u8array.length()];
            for(int i=0; i<buffer.length; i++) {
              buffer[i] = (byte)u8array.get(i);
            }

            PixelImage image = ImageReader.read(ImageType.TGA, PixelFormat.ABGR, buffer, 0);

            Canvas canvas = createImageCanvas(image);

            WebGLTexture texture = gl.createTexture();
            gl.enable(TEXTURE_2D);
            gl.bindTexture(TEXTURE_2D, texture);

            gl.texImage2D(TEXTURE_2D, 0, RGBA, RGBA, UNSIGNED_BYTE, canvas.getElement());

            gl.texParameteri(TEXTURE_2D, TEXTURE_WRAP_S, CLAMP_TO_EDGE);
            gl.texParameteri(TEXTURE_2D, TEXTURE_WRAP_T, CLAMP_TO_EDGE);
            gl.texParameteri(TEXTURE_2D, TEXTURE_MAG_FILTER, LINEAR);
            gl.texParameteri(TEXTURE_2D, TEXTURE_MIN_FILTER, LINEAR);

          }
          catch(Exception e) {
            e.printStackTrace();
          }
        }
      }
    }
  });
  request.send();
}

private WebGLRenderingContext gl;