android图片处理方法

//压缩图片大小  
    public static Bitmap compressImage(Bitmap image) {  
  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中  
        int options = 100;  
        while ( baos.toByteArray().length / 1024>100) {  //循环判断如果压缩后图片是否大于100kb,大于继续压缩         
            baos.reset();//重置baos即清空baos  
            image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中  
            options -= 10;//每次都减少10  
        }  
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中  
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片  
        return bitmap;  
    }  

Java代码  


/**  
     * 将彩色图转换为灰度图  
     * @param img 位图  
     * @return  返回转换好的位图  
     */    
    public Bitmap convertGreyImg(Bitmap img) {    
        int width = img.getWidth();         //获取位图的宽    
        int height = img.getHeight();       //获取位图的高    
            
        int []pixels = new int[width * height]; //通过位图的大小创建像素点数组    
            
        img.getPixels(pixels, 0, width, 0, 0, width, height);    
        int alpha = 0xFF << 24;     
        for(int i = 0; i < height; i++)  {    
            for(int j = 0; j < width; j++) {    
                int grey = pixels[width * i + j];    
                    
                int red = ((grey  & 0x00FF0000 ) >> 16);    
                int green = ((grey & 0x0000FF00) >> 8);    
                int blue = (grey & 0x000000FF);    
                    
                grey = (int)((float) red * 0.3 + (float)green * 0.59 + (float)blue * 0.11);    
                grey = alpha | (grey << 16) | (grey << 8) | grey;    
                pixels[width * i + j] = grey;    
            }    
        }    
        Bitmap result = Bitmap.createBitmap(width, height, Config.RGB_565);    
        result.setPixels(pixels, 0, width, 0, 0, width, height);    
        return result;    
    }    



将一个图片切割成多个图片

有种场景，我们想将一个图片切割成多个图片。比如我们在开发一个拼图的游戏，就首先要对图片进行切割。

以下是封装好的两个类，可以实现图片的切割。仅供参考和学习。

一个是ImagePiece类，此类保存了一个Bitmap对象和一个标识图片的顺序索引的int变量。

Java代码  


import android.graphics.Bitmap;   
public class ImagePiece {     
    public int index = 0;          
    public Bitmap bitmap = null;    
}  

一个是ImageSplitter类，有一个静态方法split，传入的参数是要切割的Bitmap对象，和横向和竖向的切割片数。比如传入的是3、3，则横竖向都切割成3片，最终会将整个图片切割成3X3=9片。

Java代码  


import java.util.ArrayList;    
import java.util.List;    
    
import android.graphics.Bitmap;    
    
public class ImageSplitter {    
    
    public static List<ImagePiece> split(Bitmap bitmap, int xPiece, int yPiece) {    
    
        List<ImagePiece> pieces = new ArrayList<ImagePiece>(xPiece * yPiece);    
        int width = bitmap.getWidth();    
        int height = bitmap.getHeight();    
        int pieceWidth = width / 3;    

1f0d8
        int pieceHeight = height / 3;    
        for (int i = 0; i < yPiece; i++) {    
            for (int j = 0; j < xPiece; j++) {    
                ImagePiece piece = new ImagePiece();    
                piece.index = j + i * xPiece;    
                int xValue = j * pieceWidth;    
                int yValue = i * pieceHeight;    
                piece.bitmap = Bitmap.createBitmap(bitmap, xValue, yValue,    
                        pieceWidth, pieceHeight);    
                pieces.add(piece);    
            }    
        }    
    
        return pieces;    
    }    
    
}  

1、图标加灰色过滤；

2、android的图片资源默认是静态的，单实例；如果两个IM好友的头像一样，最简单的都是用的软件自带头像，有一个在线，一个离线，直接改变头像的灰度，则两个用户的头像都会变灰或者在线，答案是：Drawable.mutate()。

Java代码  


Drawable mDrawable = context.getResources().getDrawable(R.drawable.face_icon);    
//Make this drawable mutable.    
//A mutable drawable is guaranteed to not share its state with any other drawable.    
mDrawable.mutate();    
ColorMatrix cm = new ColorMatrix();    
cm.setSaturation(0);    
ColorMatrixColorFilter cf = new ColorMatrixColorFilter(cm);    
mDrawable.setColorFilter(cf);  

生成缩略图，抠自android launcher源码：

Java代码  


/* 
 * Copyright (C) 2008 The Android Open Source Project 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */  
  
package com.android.launcher;  
  
import android.graphics.drawable.BitmapDrawable;  
import android.graphics.drawable.Drawable;  
import android.graphics.drawable.PaintDrawable;  
import android.graphics.Bitmap;  
import android.graphics.PixelFormat;  
import android.graphics.Canvas;  
import android.graphics.PaintFlagsDrawFilter;  
import android.graphics.Paint;  
import android.graphics.Rect;  
import android.content.res.Resources;  
import android.content.Context;  
  
/** 
 * Various utilities shared amongst the Launcher's classes. 
 */  
final class Utilities {  
    private static int sIconWidth = -1;  
    private static int sIconHeight = -1;  
  
    private static final Paint sPaint = new Paint();  
    private static final Rect sBounds = new Rect();  
    private static final Rect sOldBounds = new Rect();  
    private static Canvas sCanvas = new Canvas();  
  
    static {  
        sCanvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.DITHER_FLAG,  
                Paint.FILTER_BITMAP_FLAG));  
    }  
  
    /** 
     * Returns a Drawable representing the thumbnail of the specified Drawable. 
     * The size of the thumbnail is defined by the dimension 
     * android.R.dimen.launcher_application_icon_size. 
     * 
     * This method is not thread-safe and should be invoked on the UI thread only. 
     * 
     * @param icon The icon to get a thumbnail of. 
     * @param context The application's context. 
     * 
     * @return A thumbnail for the specified icon or the icon itself if the 
     *         thumbnail could not be created.  
     */  
    static Drawable createIconThumbnail(Drawable icon, Context context) {  
        if (sIconWidth == -1) {  
            final Resources resources = context.getResources();  
            sIconWidth = sIconHeight = (int) resources.getDimension(android.R.dimen.app_icon_size);  
        }  
  
        int width = sIconWidth;  
        int height = sIconHeight;  
  
        float scale = 1.0f;  
        if (icon instanceof PaintDrawable) {  
            PaintDrawable painter = (PaintDrawable) icon;  
            painter.setIntrinsicWidth(width);  
            painter.setIntrinsicHeight(height);  
        } else if (icon instanceof BitmapDrawable) {  
            // Ensure the bitmap has a density.  
            BitmapDrawable bitmapDrawable = (BitmapDrawable) icon;  
            Bitmap bitmap = bitmapDrawable.getBitmap();  
            if (bitmap.getDensity() == Bitmap.DENSITY_NONE) {  
                bitmapDrawable.setTargetDensity(context.getResources().getDisplayMetrics());  
            }  
        }  
        int iconWidth = icon.getIntrinsicWidth();  
        int iconHeight = icon.getIntrinsicHeight();  
  
        if (width > 0 && height > 0) {  
            if (width < iconWidth || height < iconHeight || scale != 1.0f) {  
                final float ratio = (float) iconWidth / iconHeight;  
  
                if (iconWidth > iconHeight) {  
                    height = (int) (width / ratio);  
                } else if (iconHeight > iconWidth) {  
                    width = (int) (height * ratio);  
                }  
  
                final Bitmap.Config c = icon.getOpacity() != PixelFormat.OPAQUE ?  
                            Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;  
                final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);  
                final Canvas canvas = sCanvas;  
                canvas.setBitmap(thumb);  
                // Copy the old bounds to restore them later  
                // If we were to do oldBounds = icon.getBounds(),  
                // the call to setBounds() that follows would  
                // change the same instance and we would lose the  
                // old bounds  
                sOldBounds.set(icon.getBounds());  
                final int x = (sIconWidth - width) / 2;  
                final int y = (sIconHeight - height) / 2;  
                icon.setBounds(x, y, x + width, y + height);  
                icon.draw(canvas);  
                icon.setBounds(sOldBounds);  
                icon = new FastBitmapDrawable(thumb);  
            } else if (iconWidth < width && iconHeight < height) {  
                final Bitmap.Config c = Bitmap.Config.ARGB_8888;  
                final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);  
                final Canvas canvas = sCanvas;  
                canvas.setBitmap(thumb);  
                sOldBounds.set(icon.getBounds());  
                final int x = (width - iconWidth) / 2;  
                final int y = (height - iconHeight) / 2;  
                icon.setBounds(x, y, x + iconWidth, y + iconHeight);  
                icon.draw(canvas);  
                icon.setBounds(sOldBounds);  
                icon = new FastBitmapDrawable(thumb);  
            }  
        }  
  
        return icon;  
    }  
  
    /** 
     * Returns a Bitmap representing the thumbnail of the specified Bitmap. 
     * The size of the thumbnail is defined by the dimension 
     * android.R.dimen.launcher_application_icon_size. 
     * 
     * This method is not thread-safe and should be invoked on the UI thread only. 
     * 
     * @param bitmap The bitmap to get a thumbnail of. 
     * @param context The application's context. 
     * 
     * @return A thumbnail for the specified bitmap or the bitmap itself if the 
     *         thumbnail could not be created. 
     */  
    static Bitmap createBitmapThumbnail(Bitmap bitmap, Context context) {  
        if (sIconWidth == -1) {  
            final Resources resources = context.getResources();  
            sIconWidth = sIconHeight = (int) resources.getDimension(  
                    android.R.dimen.app_icon_size);  
        }  
  
        int width = sIconWidth;  
        int height = sIconHeight;  
  
        final int bitmapWidth = bitmap.getWidth();  
        final int bitmapHeight = bitmap.getHeight();  
  
        if (width > 0 && height > 0) {  
            if (width < bitmapWidth || height < bitmapHeight) {  
                final float ratio = (float) bitmapWidth / bitmapHeight;  
      
                if (bitmapWidth > bitmapHeight) {  
                    height = (int) (width / ratio);  
                } else if (bitmapHeight > bitmapWidth) {  
                    width = (int) (height * ratio);  
                }  
      
                final Bitmap.Config c = (width == sIconWidth && height == sIconHeight) ?  
                        bitmap.getConfig() : Bitmap.Config.ARGB_8888;  
                final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);  
                final Canvas canvas = sCanvas;  
                final Paint paint = sPaint;  
                canvas.setBitmap(thumb);  
                paint.setDither(false);  
                paint.setFilterBitmap(true);  
                sBounds.set((sIconWidth - width) / 2, (sIconHeight - height) / 2, width, height);  
                sOldBounds.set(0, 0, bitmapWidth, bitmapHeight);  
                canvas.drawBitmap(bitmap, sOldBounds, sBounds, paint);  
                return thumb;  
            } else if (bitmapWidth < width || bitmapHeight < height) {  
                final Bitmap.Config c = Bitmap.Config.ARGB_8888;  
                final Bitmap thumb = Bitmap.createBitmap(sIconWidth, sIconHeight, c);  
                final Canvas canvas = sCanvas;  
                final Paint paint = sPaint;  
                canvas.setBitmap(thumb);  
                paint.setDither(false);  
                paint.setFilterBitmap(true);  
                canvas.drawBitmap(bitmap, (sIconWidth - bitmapWidth) / 2,  
                        (sIconHeight - bitmapHeight) / 2, paint);  
                return thumb;  
            }  
        }  
  
        return bitmap;  
    }  
}  

Java代码  


//Android Matrix类实现镜像方法  
public void drawRegion(Image image_src,  
  
int x_src, int y_src,  
  
int width, int height,  
  
int transform,  
  
int x_dest, int y_dest,  
  
int anchor){  
  
if((anchor&VCENTER) != 0){  
  
y_dest -= height/2;  
  
}else if((anchor&BOTTOM) != 0){  
  
y_dest -= height;  
  
}  
  
if((anchor&RIGHT) != 0){  
  
x_dest -= width;  
  
}else if((anchor&HCENTER) != 0){  
  
x_dest -= width/2;  
  
}  
  
Bitmap newMap = Bitmap.createBitmap(image_src.getBitmap(), x_src, y_src, width, height);  
  
Matrix mMatrix = new Matrix();  
  
Matrix temp = new Matrix();  
  
Matrix temp2 = new Matrix();  
  
float[] mirrorY = {  
  
-1, 0, 0,  
0, 1, 0,  
0, 0, 1  
  
};  
  
temp.setValues(mirrorY);  
  
switch(transform){  
  
case Sprite.TRANS_NONE:  
  
break;  
  
case Sprite.TRANS_ROT90:  
  
mMatrix.setRotate(90,width/2, height/2);  
  
break;  
  
case Sprite.TRANS_ROT180:  
  
mMatrix.setRotate(180,width/2, height/2);  
  
break;  
  
case Sprite.TRANS_ROT270:  
  
mMatrix.setRotate(270,width/2, height/2);  
  
break;  
  
case Sprite.TRANS_MIRROR:  
  
mMatrix.postConcat(temp);  
  
break;  
  
case Sprite.TRANS_MIRROR_ROT90:  
  
mMatrix.postConcat(temp);  
  
mMatrix.setRotate(90,width/2, height/2);  
  
break;  
  
case Sprite.TRANS_MIRROR_ROT180:  
  
mMatrix.postConcat(temp);  
  
mMatrix.setRotate(180,width/2, height/2);  
  
break;  
  
case Sprite.TRANS_MIRROR_ROT270:  
  
mMatrix.postConcat(temp);  
  
mMatrix.setRotate(270,width/2, height/2);  
  
break;  
  
}  
  
mMatrix.setTranslate(x_dest, y_dest);  
  
canvas.drawBitmap(newMap, mMatrix, mPaint);  
  
}  

Java代码  


//图片Url保存为位图并进行缩放操作  
//通过传入图片url获取位图方法  
public Bitmap returnBitMap(String url) {  
        URL myFileUrl = null;  
        Bitmap bitmap = null;  
        try {  
            myFileUrl = new URL(url);  
        } catch (MalformedURLException e) {  
            e.printStackTrace();  
        }  
        try {  
            HttpURLConnection conn = (HttpURLConnection) myFileUrl  
                    .openConnection();  
            conn.setDoInput(true);  
            conn.connect();  
            InputStream is = conn.getInputStream();  
            bitmap = BitmapFactory.decodeStream(is);  
            is.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        Log.v(tag, bitmap.toString());  
  
        return bitmap;  
    }  
//通过传入位图,新的宽.高比进行位图的缩放操作  
public static Drawable resizeImage(Bitmap bitmap, int w, int h) {  
  
        // load the origial Bitmap  
        Bitmap BitmapOrg = bitmap;  
  
        int width = BitmapOrg.getWidth();  
        int height = BitmapOrg.getHeight();  
        int newWidth = w;  
        int newHeight = h;  
  
        Log.v(tag, String.valueOf(width));  
        Log.v(tag, String.valueOf(height));  
  
        Log.v(tag, String.valueOf(newWidth));  
        Log.v(tag, String.valueOf(newHeight));  
  
        // calculate the scale  
        float scaleWidth = ((float) newWidth) / width;  
        float scaleHeight = ((float) newHeight) / height;  
  
        // create a matrix for the manipulation  
        Matrix matrix = new Matrix();  
        // resize the Bitmap  
        matrix.postScale(scaleWidth, scaleHeight);  
        // if you want to rotate the Bitmap  
        // matrix.postRotate(45);  
  
        // recreate the new Bitmap  
        Bitmap resizedBitmap = Bitmap.createBitmap(BitmapOrg, 0, 0, width,  
                height, matrix, true);  
  
        // make a Drawable from Bitmap to allow to set the Bitmap  
        // to the ImageView, ImageButton or what ever  
        return new BitmapDrawable(resizedBitmap);  
  
    }  

Java代码  


1.图片加载方法，方便用户加载图片  
/*** 
* 加载本地图片 
* @param context：主运行函数实例 
* @param bitAdress：图片地址，一般指向R下的drawable目录 
* @return 
*/  
public final Bitmap CreatImage(Context context, int bitAdress) {  
Bitmap bitmaptemp = null;  
bitmaptemp = BitmapFactory.decodeResource(context.getResources(),  
bitAdress);  
return bitmaptemp;  
}  
2.图片平均分割方法，将大图平均分割为N行N列，方便用户使用  
/*** 
* 图片分割 
* 
* @param g 
* ：画布 
* @param paint 
* ：画笔 
* @param imgBit 
* ：图片 
* @param x 
* ：X轴起点坐标 
* @param y 
* ：Y轴起点坐标 
* @param w 
* ：单一图片的宽度 
* @param h 
* ：单一图片的高度 
* @param line 
* ：第几列 
* @param row 
* ：第几行 
*/  
public final void cuteImage(Canvas g, Paint paint, Bitmap imgBit, int x,  
int y, int w, int h, int line, int row) {  
g.clipRect(x, y, x + w, h + y);  
g.drawBitmap(imgBit, x – line * w, y – row * h, paint);  
g.restore();  
}  
3.图片缩放，对当前图片进行缩放处理  
/*** 
* 图片的缩放方法 
* 
* @param bgimage 
* ：源图片资源 
* @param newWidth 
* ：缩放后宽度 
* @param newHeight 
* ：缩放后高度 
* @return 
*/  
public Bitmap zoomImage(Bitmap bgimage, int newWidth, int newHeight) {  
// 获取这个图片的宽和高  
int width = bgimage.getWidth();  
int height = bgimage.getHeight();  
// 创建操作图片用的matrix对象  
Matrix matrix = new Matrix();  
// 计算缩放率，新尺寸除原始尺寸  
float scaleWidth = ((float) newWidth) / width;  
float scaleHeight = ((float) newHeight) / height;  
// 缩放图片动作  
matrix.postScale(scaleWidth, scaleHeight);  
Bitmap bitmap = Bitmap.createBitmap(bgimage, 0, 0, width, height,  
matrix, true);  
return bitmap;  
}  
4.绘制带有边框的文字，一般在游戏中起文字的美化作用  
/*** 
* 绘制带有边框的文字 
* 
* @param strMsg 
* ：绘制内容 
* @param g 
* ：画布 
* @param paint 
* ：画笔 
* @param setx 
* ：：X轴起始坐标 
* @param sety 
* ：Y轴的起始坐标 
* @param fg 
* ：前景色 
* @param bg 
* ：背景色 
*/  
public void drawText(String strMsg, Canvas g, Paint paint, int setx,  
int sety, int fg, int bg) {  
paint.setColor(bg);  
g.drawText(strMsg, setx + 1, sety, paint);  
g.drawText(strMsg, setx, sety – 1, paint);  
g.drawText(strMsg, setx, sety + 1, paint);  
g.drawText(strMsg, setx – 1, sety, paint);  
paint.setColor(fg);  
g.drawText(strMsg, setx, sety, paint);  
g.restore();  
}  
5.Android 图片透明度处理代码  
/** 
* 图片透明度处理 
* 
* @param sourceImg 
*            原始图片 
* @param number 
*            透明度 
* @return 
*/  
public static Bitmap setAlpha(Bitmap sourceImg, int number) {  
int[] argb = new int[sourceImg.getWidth() * sourceImg.getHeight()];  
sourceImg.getPixels(argb, 0, sourceImg.getWidth(), 0, 0,sourceImg.getWidth(), sourceImg.getHeight());// 获得图片的ARGB值  
number = number * 255 / 100;  
for (int i = 0; i < argb.length; i++) {  
argb = (number << 24) | (argb & 0×00FFFFFF);// 修改最高2位的值  
}  
sourceImg = Bitmap.createBitmap(argb, sourceImg.getWidth(), sourceImg.getHeight(), Config.ARGB_8888);  
return sourceImg;  
}  
6.图片翻转  
Resources res = this.getContext().getResources();  
img = BitmapFactory.decodeResource(res, R.drawable.slogo);  
Matrix matrix = new Matrix();  
matrix.postRotate(90);        /*翻转90度*/  
int width = img.getWidth();  
int height = img.getHeight();  
r_img = Bitmap.createBitmap(img, 0, 0, width, height, matrix, true);  

Java代码  


import android.graphics.Bitmap;  
import android.graphics.Canvas;  
import android.graphics.LinearGradient;  
import android.graphics.Matrix;  
import android.graphics.Paint;  
import android.graphics.PixelFormat;  
import android.graphics.PorterDuffXfermode;  
import android.graphics.Rect;  
import android.graphics.RectF;  
import android.graphics.Bitmap.Config;  
import android.graphics.PorterDuff.Mode;  
import android.graphics.Shader.TileMode;  
import android.graphics.drawable.Drawable;  
/** 
*  
* @author superdev 
* @version 1.0 
* 
*/  
public class ImageUtil {  
  
/** 
* 放大缩小图片 
*/  
public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) {  
   int width = bitmap.getWidth();  
   int height = bitmap.getHeight();  
   Matrix matrix = new Matrix();  
   float scaleWidht = ((float) w / width);  
   float scaleHeight = ((float) h / height);  
   matrix.postScale(scaleWidht, scaleHeight);  
   Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);  
   return newbmp;  
}  
  
/** 
* 将Drawable转化为Bitmap 
*/  
public static Bitmap drawableToBitmap(Drawable drawable) {  
   int width = drawable.getIntrinsicWidth();  
   int height = drawable.getIntrinsicHeight();  
   Bitmap bitmap = Bitmap.createBitmap(width, height, drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);  
   Canvas canvas = new Canvas(bitmap);  
   drawable.setBounds(0, 0, width, height);  
   drawable.draw(canvas);  
   return bitmap;  
  
}  
  
/** 
* 获得圆角图片的方法 
*/  
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {  
  
   Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);  
   Canvas canvas = new Canvas(output);  
  
   final int color = 0xff424242;  
   final Paint paint = new Paint();  
   final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());  
   final RectF rectF = new RectF(rect);  
  
   paint.setAntiAlias(true);  
   canvas.drawARGB(0, 0, 0, 0);  
   paint.setColor(color);  
   canvas.drawRoundRect(rectF, roundPx, roundPx, paint);  
  
   paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
   canvas.drawBitmap(bitmap, rect, rect, paint);  
  
   return output;  
}  
  
/** 
* 获得带倒影的图片方法 
*/  
public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {  
   final int reflectionGap = 4;  
   int width = bitmap.getWidth();  
   int height = bitmap.getHeight();  
  
   Matrix matrix = new Matrix();  
   matrix.preScale(1, -1);  
  
   Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2, width, height / 2, matrix, false);  
  
   Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height / 2), Config.ARGB_8888);  
  
   Canvas canvas = new Canvas(bitmapWithReflection);  
   canvas.drawBitmap(bitmap, 0, 0, null);  
   Paint deafalutPaint = new Paint();  
   canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);  
  
   canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);  
  
   Paint paint = new Paint();  
   LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0, bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP);  
   paint.setShader(shader);  
   // Set the Transfer mode to be porter duff and destination in  
   paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));  
   // Draw a rectangle using the paint with our linear gradient  
   canvas.drawRect(0, height, width, bitmapWithReflection.getHeight() + reflectionGap, paint);  
   return bitmapWithReflection;  
}  
}  

Java代码  


private byte[] Bitmap2Bytes(Bitmap bm){  
   ByteArrayOutputStream baos = new ByteArrayOutputStream();  
   bm.compress(Bitmap.CompressFormat.PNG, 100, baos);  
   return baos.toByteArray();  
}  
private Bitmap Bytes2Bimap(byte[] b){  
            if(b.length!=0){  
                return BitmapFactory.decodeByteArray(b, 0, b.length);  
            }  
            else {  
                return null;  
            }  
      }  
  
 /** 
     * create the bitmap from a byte array 
     *生成水印图片 
     * @param src the bitmap object you want proecss 
     * @param watermark the water mark above the src 
     * @return return a bitmap object ,if paramter's length is 0,return null 
     */  
    private Bitmap createBitmap( Bitmap src, Bitmap watermark )  
    {  
        String tag = "createBitmap";  
        Log.d( tag, "create a new bitmap" );  
        if( src == null )  
        {  
            return null;  
        }  
   
        int w = src.getWidth();  
        int h = src.getHeight();  
        int ww = watermark.getWidth();  
        int wh = watermark.getHeight();  
        //create the new blank bitmap  
        Bitmap newb = Bitmap.createBitmap( w, h, Config.ARGB_8888 );//创建一个新的和SRC长度宽度一样的位图  
        Canvas cv = new Canvas( newb );  
        //draw src into  
        cv.drawBitmap( src, 0, 0, null );//在 0，0坐标开始画入src  
        //draw watermark into  
        cv.drawBitmap( watermark, w - ww + 5, h - wh + 5, null );//在src的右下角画入水印  
        //save all clip  
        cv.save( Canvas.ALL_SAVE_FLAG );//保存  
        //store  
        cv.restore();//存储  
        return newb;  
    }  
   /** 重新编码Bitmap 
   *  
   * @param src 
   *          需要重新编码的Bitmap 
   * 
   * @param format 
   *          编码后的格式（目前只支持png和jpeg这两种格式） 
   * 
   * @param quality 
   *          重新生成后的bitmap的质量 
   * 
   * @return 
   *          返回重新生成后的bitmap 
   */  
 private static Bitmap codec(Bitmap src, Bitmap.CompressFormat format,  
                                    int quality) {  
            ByteArrayOutputStream os = new ByteArrayOutputStream();  
            src.compress(format, quality, os);              
  
            byte[] array = os.toByteArray();  
            return BitmapFactory.decodeByteArray(array, 0, array.length);  
        }  
  
//Stream转换成Byte  
static byte[] streamToBytes(InputStream is) {  
      ByteArrayOutputStream os = new ByteArrayOutputStream(1024);  
      byte[] buffer = new byte[1024];  
      int len;  
      try {  
             while ((len = is.read(buffer)) >= 0) {  
             os.write(buffer, 0, len);  
             }  
          } catch (java.io.IOException e) {  
  
          }  
          return os.toByteArray();  
}  
//把View转换成Bitmap  
  
    /** 
     * 把一个View的对象转换成bitmap 
     */  
    static Bitmap getViewBitmap(View v) {  
          
        v.clearFocus();  
        v.setPressed(false);  
  
        //能画缓存就返回false  
        boolean willNotCache = v.willNotCacheDrawing();  
        v.setWillNotCacheDrawing(false);   
        int color = v.getDrawingCacheBackgroundColor();  
        v.setDrawingCacheBackgroundColor(0);  
        if (color != 0) {  
            v.destroyDrawingCache();  
        }  
        v.buildDrawingCache();  
        Bitmap cacheBitmap = v.getDrawingCache();  
        if (cacheBitmap == null) {  
            Log.e(TAG, "failed getViewBitmap(" + v + ")", new RuntimeException());  
            return null;  
        }  
        Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);  
        // Restore the view  
        v.destroyDrawingCache();  
        v.setWillNotCacheDrawing(willNotCache);  
        v.setDrawingCacheBackgroundColor(color);  
        return bitmap;  
    }  

Java代码  


读取raw资源文件中的mp3文件，然后通过音乐播放器播放：  
  
    /** 
     * 把mp3文件写入卡 
     *  
     * @param fileName 
     *             输出的文件名（全路径） 
     * @param context 
         *             context对象 
     */  
    private void writeMP3ToSDcard(String fileName, Context context) {  
        byte[] buffer = new byte[1024 * 8];  
        int read;  
        BufferedInputStream bin = new BufferedInputStream(context.getResources().openRawResource(R.raw.ring));  
        try {  
            BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(fileName));  
            while ((read = bin.read(buffer)) > -1) {  
                bout.write(buffer, 0, read);  
            }  
            bout.flush();  
            bout.close();  
            bin.close();  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
  
  
Intent intent = new Intent();  
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
intent.setAction(android.content.Intent.ACTION_VIEW);  
intent.setDataAndType(Uri.fromFile(newFile("XXXXmp3的文件全路径")),"audio/*");  
startActivity(intent);  

绘制图像倒影

Java代码  


private void    
_Init()     
{     
  m_paint = new Paint(Paint.ANTI_ALIAS_FLAG);     
  LinearGradient lg = new LinearGradient(     
    0, 0, 0, m_nShadowH,      
    0xB0FFFFFF, 0x00000000,     
    Shader.TileMode.CLAMP);     
  m_paint.setShader(lg);     
  m_paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));     
}     
    
@Override protected void      
onDraw(Canvas canvas)     
{     
  super.onDraw(canvas);     
    
  int nX = 0;     
  int nY = 20;     
    
  _DrawNormalImg(canvas, nX, nY);     
  _DrawMirror(canvas, nX, nY);     
}      
    
private void    
_DrawNormalImg(Canvas canvas, int nX, int nY)     
{     
  canvas.save(Canvas.MATRIX_SAVE_FLAG);     
  canvas.translate(nX, nY);        
  m_dw.draw(canvas);     
  canvas.restore();     
}     
    
private void    
_DrawMirror(Canvas canvas, int nX, int nY)     
{     
  int nW = m_dw.getIntrinsicWidth();     
  int nH = m_dw.getIntrinsicHeight();     
    
  ///////////////////////////////////     
  //draw mirror image     
  canvas.save(Canvas.MATRIX_SAVE_FLAG);     
  canvas.scale(1.0f, -1.0f);     
  canvas.translate(nX, -(nY + nH * 2));     
  canvas.clipRect(0, nH, nW, nH - m_nShadowH);     
  m_dw.draw(canvas);     
  canvas.restore();     
    
  //////////////////////////////     
  //draw mask     
  canvas.save();     
  canvas.translate(nX, nY + nH);     
  canvas.drawRect(0, 0, nW, m_nShadowH, m_paint);     
  canvas.restore();     
}    

Android 繪圖座標體系預設的原點在左上角，X 軸往右是越來越大的正值，而 Y 軸往下，則是越來越大的正值。要畫出垂直翻轉的圖片，其實也就是要垂直翻轉整個繪圖座標體系。在 Android 中，要如何做？答案就是 canvas.scale(1.0f, -1.0f)。很簡單吧，沒想到給 scale() 函式一個負值，就可以翻轉相對應的軸。

在 Photoshop 中，做鏡像特效的第二步是要對這翻轉的圖片，加個由灰到黑的漸層 mask。

在 Android 中，要畫漸層色，那就一定得用 LinearGradient 這個類別。至於要對背景圖加上個 mask，就請參考一下 Paint 的 setXfermode() 函式。_Init() 這個函式，就是負責生成一個由灰到黑漸層 mask 的 m_paint 物件。



http://blog.csdn.net/Android_Tutor/archive/2010/11/02/5981753.aspx

http://www.cnblogs.com/TerryBlog/archive/2012/01/08/2316482.html

android常用图片特效处理
http://www.eoeandroid.com/thread-170526-1-1.html

相机（Camera）实时滤镜效果
http://www.eoeandroid.com/thread-171528-1-1.html

Android, WindowsPhone7, IOS ,vc2010平台40多套图片滤镜开源
http://www.cnblogs.com/daizhj/archive/2012/05/15/2501406.html

Android实现获取本机中所有图片
http://www.cnblogs.com/hanyonglu/archive/2012/05/10/2494908.html