Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.newdawn.slick.tools.scalar;
/**
* A simple implementation of the Scale2x algorithm for scaling raw
* image data.
*
* @author Kevin Glass
*/
public class RawScale2x
{
/** The src image data */
private int[] srcImage;
/** The dest image data */
private int[] dstImage;
/** The width of the source image */
private int width;
/** The height of the source image */
private int height;
/**
* Create a new scaler based on some raw data. Right now it doesn't
* matter what order the channels in, just that its an int per pixel
*
* @param imageData The source image data
* @param dataWidth The width of the source image
* @param dataHeight The height of the source image
*/
public RawScale2x(int[] imageData,int dataWidth,int dataHeight)
{
this.width = dataWidth;
this.height = dataHeight;
this.srcImage = imageData;
dstImage = new int[imageData.length*4];
}
/**
* Check if two pixels are different. Place holder for maybe
* some clever code about tolerance checking
*
* @param a The first pixel value
* @param b The second pixel value
* @return True if the pixels are different
*/
private boolean different(int a,int b)
{
return a != b;
}
/**
* Set a pixel in the destination image data
*
* @param x The x location of the pixel to set
* @param y The y location of the pixel to set
* @param p The value of the pixel to set
*/
private void setDestPixel(int x,int y,int p)
{
dstImage[x+(y*width*2)] = p;
}
/**
* Get a pixel from the source image. This handles bonds checks
* and resolves to edge pixels
*
* @param x The x location of the pixel to retrieve
* @param y The y location of the pixel to retrieve
* @return The pixel value at the specified location
*/
private int getSourcePixel(int x,int y)
{
x = Math.max(0,x);
x = Math.min(width-1,x);
y = Math.max(0,y);
y = Math.min(height-1,y);
return srcImage[x+(y*width)];
}
/**
* Process a specific pixel. This will generate 4 pixels in the destination
* image based on the scale2x algorithm
*
* @param x The x location in the source image of the pixel to process
* @param y The y location in the source image of the pixel to process
*/
private void process(int x,int y)
{
int A = getSourcePixel(x-1,y-1);
int B = getSourcePixel(x,y-1);
int C = getSourcePixel(x+1,y-1);
int D = getSourcePixel(x-1,y);
int E = getSourcePixel(x,y);
int F = getSourcePixel(x+1,y);
int G = getSourcePixel(x-1,y+1);
int H = getSourcePixel(x,y+1);
int I = getSourcePixel(x+1,y+1);
int E0 = E;
int E1 = E;
int E2 = E;
int E3 = E;
if (different(B,H) && different(D,F)) {
E0 = !different(D,B) ? D : E;
E1 = !different(B,F) ? F : E;
E2 = !different(D,H) ? D : E;
E3 = !different(H,F) ? F : E;
}
setDestPixel(x*2,y*2,E0);
setDestPixel((x*2)+1,y*2,E1);
setDestPixel((x*2),(y*2)+1,E2);
setDestPixel((x*2)+1,(y*2)+1,E3);
}
/**
* Get the scale image data. Note this is the method that does the work
* so it might take some time to process.
*
* @return An array of pixels 4 times the size of the input array containing
* the smoothly scaled image
*/
public int[] getScaledData()
{
for (int x=0;x
