/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* AndroidWorld Library, Copyright 2011 Bryan Chadwick *
* *
* FILE: ./android/image/Image.java *
* *
* This file is part of AndroidWorld. *
* *
* AndroidWorld is free software: you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation, either version *
* 3 of the License, or (at your option) any later version. *
* *
* AndroidWorld is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with AndroidWorld. If not, see . *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
package android.image;
import android.world.Posn;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Matrix;
/** An abstract class representing an Image. See subclasses for
* specific implementations. */
public abstract class Image{
protected static int OUTLINE = 0;
protected static int SOLID = 1;
public static Paint WHITE, BLACK_OUTLINE, CLEAR;
static{
WHITE = Image.painter(color("white"), Image.SOLID);
BLACK_OUTLINE = Image.painter(color("black"), Image.OUTLINE);
CLEAR = Image.painter(color("#00000000"), Image.SOLID);
}
/** Pinhole for alignment to other images */
protected double pinholeX, pinholeY;
/** Only for subclasses */
protected Image(double px, double py){
pinholeX = px;
pinholeY = py;
}
// Calculate Image size to the left/right/up/down of the pinhole
protected double leftOfPin(){ return pinholeX; }
protected double rightOfPin(){ return width()-pinholeX; }
protected double upOfPin(){ return pinholeY; }
protected double downOfPin(){ return height()-pinholeY; }
/** Overlay the given Image over this Image */
public Image overlay(Image top)
{ return new Overlay(top,this); }
/** Overlay the given Images over this Image */
public Image overlay(Image top, Image next, Image ... imgs){
return new Overlay(new Overlay(top, make(next, imgs, 0)), this);
}
/** Overlay the given Image over this Image offset (x,y) */
public Image overlayxy(Image top, int x, int y)
{ return new OverlayXY(top,x,y,this); }
/** Overlay the given Image over this Image offset (x,y) */
public Image overlayxy(Image top, double x, double y)
{ return overlayxy(top,(int)x,(int)y); }
/** Overlay the given Image over this Image offset Posn */
public Image overlayxy(Image top, Posn p)
{ return overlayxy(top,p.x,p.y); }
/** Overlay the given Image over this Image offset (x,y) */
public Image overlayxy(int x, int y, Image top)
{ return overlayxy(top,x,y); }
/** Overlay the given Image over this Image offset (x,y) */
public Image overlayxy(double x, double y, Image top)
{ return overlayxy(top,(int)x,(int)y); }
/** Overlay the given Image over this Image offset Posn */
public Image overlayxy(Posn p, Image top)
{ return overlayxy(top,p.x,p.y); }
/** Make a layered Image with top t and bottoms of imgs[i..] */
private static Image make(Image t, Image[] imgs, int i){
if(i == imgs.length)
return t;
return new Overlay(t, make(imgs[i], imgs, i+1));
}
/** Draw this image into a Graphics */
public abstract void paint(Canvas c, int x, int y);
/** Calculate the width of this Image */
public abstract int width();
/** Calculate the height of this Image */
public abstract int height();
/** Convert this image into a Scene containing the image without a background */
public Scene toScene(){
return new MT(ceil(this.width()+2), ceil(this.height()+2)).placeImage(this, this.pinholeX+1, this.pinholeY+1);
}
/** Convert this image into a Scene containing the image with a white background */
public Scene toWhiteScene(){
return new White(ceil(this.width()+2), ceil(this.height()+2)).placeImage(this, this.pinholeX+1, this.pinholeY+1);
}
/** Represents a truly empty scene... */
private static class MT extends EmptyScene{
MT(int w, int h){ super(w,h); }
/** Leave the graphics empty (translucent) */
public void paint(Canvas c, int x, int y){}
}
/** Represents a truly empty scene... */
private static class White extends EmptyScene{
White(int w, int h){ super(w,h); }
/** Fill with a white background */
public void paint(Canvas c, int x, int y){
c.drawRect(x, y, this.width, this.height, Image.WHITE);
}
}
/** Save this image to a file */
public boolean toFile(String name){
return toScene().toFile(name);
}
/** Save this image to a file */
public boolean toWhiteFile(String name){
return toWhiteScene().toFile(name);
}
/** Convert the mode string into an int representing Outline/Solid */
protected static int mode(String s){
if(s.equals("outline")) return OUTLINE;
if(s.equals("solid")) return SOLID;
throw new RuntimeException("Mode expected \"solid\" or \"outline\", got: \""+s+"\"");
}
/** Round the given Double to an Int */
protected static int round(double d){
return (int)Math.round(d);
}
/** Round the given Double to an Int */
protected static int ceil(double d){
return (int)Math.ceil(d);
}
/** Get the java.awt.Color represented by the given string */
protected static int color(String s){
return ColorDatabase.color(s);
}
/** Create a Paint */
protected static Paint painter(int color, int style){
Paint p = new Paint();
p.setColor(color);
p.setAntiAlias(true);
p.setStyle(style == Image.OUTLINE?Paint.Style.STROKE:Paint.Style.FILL);
p.setStrokeWidth(1);
return p;
}
/** Return a raster (buffered) version of this Image */
public RasterImage rasterize(){
RasterImage img = new RasterImage(ceil(this.width()), ceil(this.height()));
Canvas c = img.getCanvas();
this.paint(c, round(this.pinholeX), round(this.pinholeY));
return img;
}
/** Return a rotated version of this image by the given angle in degrees. */
public Image rotate(int ang){
return this.rotate((double)ang);
}
/** Return a rotated version of this image by the given angle in degrees.
*
* Any Image may be rotated several times, though for efficiency
* (when possible) the rotated image should be saved, rather than
* recreated.
*
*/
public Image rotate(double ang){
ang = (ang + 360.0) % 360.0;
int max = round(Math.max(Math.max(phDist(0,0),
phDist(0,this.height())),
Math.max(phDist(this.width(),0),
phDist(this.width(),this.height()))));
Matrix matrix = new Matrix();
matrix.postRotate(-(float)ang, max, max);
return this.transform(matrix, max*2, max*2, max, max);
}
/** Return a version of this Image scaled by the given int multiplier.
private RasterImage scale(int s){
return this.scale((double)s);
}
/** Return a version of this Image scaled by the given int X and Y multipliers.
private RasterImage scale(int sx, int sy){
return this.scale((double)sx, sy);
}
/** Return a version of this Image scaled by the given double multiplier.
private RasterImage scale(double s){
return this.scale(s, s);
}*/
/** Return a version of this Image scaled by the given double X and Y multipliers. */
private RasterImage scale(double sx, double sy){
Matrix matrix = new Matrix();
matrix.postScale((float)sx, (float)sy);
return this.transform(matrix, Math.abs(sx*this.width()), Math.abs(sy*this.height()),
this.width()/2.0/sx, this.height()/2.0/sy);
}
/** Return a version of this Image flipped horizontally (left to right). */
public RasterImage flipHorizontal(){
return scale(-1.0, 1.0);
}
/** Return a version of this Image flipped vertically (top to bottom). */
public RasterImage flipVertical(){
return scale(1.0, -1.0);
}
/** Return a transformed version of this Image */
protected RasterImage transform(Matrix newtform, double nw, double nh, double cx, double cy){
RasterImage img = new RasterImage(round(nw), round(nh));
Canvas c = img.getCanvas();
Matrix old = c.getMatrix();
c.setMatrix(newtform);
this.rasterize().paint(c, round(cx), round(cy));
c.setMatrix(old);
return img;
}
/** Maximum distance from the Pinhole to the given XY of this Image */
private double phDist(double x, double y){
double dx = x - this.pinholeX,
dy = y - this.pinholeY;
return Math.sqrt((dx*dx)+(dy*dy));
}
}