Camera图片特效处理综述（Bitmap的Pixels处理、Canvas/paint的drawBitmap处理、旋转图片、裁截图片、播放幻灯片浏览图片<线程固定时间显示一张>）

一种是直接对Bitmap的像素进行操作，如：叠加、边框、怀旧、（高斯）模糊、锐化（拉普拉斯变换）。

Bitmap.getPixels(srcPixels, 0, width, 0, 0, width, height);

　 newR = (int) (pixR * alpha + layR * (1 - alpha));
    newR = Math.min(255, Math.max(0, newR));
    。。。
    srcPixels[pos] = Color.argb(newA, newR, newG, newB);

Bitmap.setPixels(srcPixels, 0, width, 0, 0, width, height);

另一种是使用画布Canvas自带的函数进行处理，如：圆角、倒影、色相、饱和度、亮度、涂鸦：

Canvas canvas = new Canvas();//创建 空白画布，或new Canvas(bitmap)创建有背景画布，根据情况选择

Paint paint = new Paint();

。。。

canvas.drawBitmap(bitmap, null, rect, paint);

使用画布Canvas自带的函数进行处理的代码，以圆角特效为例：

        //圆角特效
        public static Bitmap getRoundCornerImage(Bitmap bitmap, int roundPixels, int width, int height )
        {
                //创建一个和原始图片一样大小位图
                Bitmap roundConcerImage = Bitmap.createBitmap(width, height, Config.ARGB_8888);
                //创建带有位图roundConcerImage的画布
                Canvas canvas = new Canvas(roundConcerImage);
                //创建画笔
                Paint paint = new Paint();
                //创建一个和原始图片一样大小的矩形
                Rect rect = new Rect(0, 0, width, height);
                RectF rectF = new RectF(rect);
                // 去锯齿
                paint.setAntiAlias(true);
                //画一个和原始图片一样大小的圆角矩形
                canvas.drawRoundRect(rectF, roundPixels, roundPixels, paint);
                //设置相交模式
                paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
                //把图片画到矩形去
                canvas.drawBitmap(bitmap, null, rect, paint);
                return roundConcerImage;
        }

直接对Bitmap的像素进行处理的代码，以怀旧特效为例：

Handler handler = new Handler(){
　　　　 @Override
　　　　 public void handleMessage(Message msg) {
　　　　　　 Drawable targetBitmapDrawable = new BitmapDrawable((Bitmap) msg.obj);// 将Bitmap转换为Drawable
　　　　　　 is.setImageDrawable(targetBitmapDrawable);
　　　　 }
　　 };
 
    /**
     * 怀旧效果
     * @param bmp
     * @return
     */
　　 private void oldRemeber(final Bitmap bmp)
    {
　　　　Thread thread = new Thread() {
　　　　@Override
　　　　public void run() {
 
        int width = bmp.getWidth();
        int height = bmp.getHeight();
        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
        int pixColor = 0;
        int pixR = 0;
        int pixG = 0;
        int pixB = 0;
        int newR = 0;
        int newG = 0;
        int newB = 0;
        int[] pixels = new int[width * height];
        bmp.getPixels(pixels, 0, width, 0, 0, width, height);
        for (int i = 0; i < height; i++)
        {
            for (int k = 0; k < width; k++)
            {
                pixColor = pixels[width * i + k];
                pixR = Color.red(pixColor);
                pixG = Color.green(pixColor);
                pixB = Color.blue(pixColor);
                newR = (int) (0.393 * pixR + 0.769 * pixG + 0.189 * pixB);
                newG = (int) (0.349 * pixR + 0.686 * pixG + 0.168 * pixB);
                newB = (int) (0.272 * pixR + 0.534 * pixG + 0.131 * pixB);
                int newColor = Color.argb(255, newR > 255 ? 255 : newR, newG > 255 ? 255 : newG, newB > 255 ? 255 : newB);
                pixels[width * i + k] = newColor;
            }
        }
        bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
 
　　　　 Message message = handler.obtainMessage();
　　　　 message.obj = bitmap;
　　　　 handler.sendMessage(message);
 
　　　　}
 
　　　　};
　　　　thread.start();
　　　　thread = null;
    }    

涂鸦特效再说明：

canvas = new Canvas(originalBitmap);//以原图片为背景创建画布

canvas.drawLine(startX, startY, clickX, clickY, paint);//根据手指移动画线条

canvas.drawBitmap(finalBitmap, 0, 0,null);//

左右旋转图片再说明：

File MatrixLeftFile=new File(currentImagePath);
try
{
　　BitmapOrgLeft = BitmapFactory.decodeStream(new FileInputStream(MatrixLeftFile), null, RotateOptions);
}
catch (FileNotFoundException e2)
{
　　// TODO 自动生成的 catch 块
　　e2.printStackTrace();
}
BitmapOrgLeft = Bitmap.createBitmap(BitmapOrgLeft, 0, 0, BitmapOrgLeft.getWidth(), BitmapOrgLeft.getHeight(), matrixleft, true);
try
{
　　bos = new BufferedOutputStream(new FileOutputStream(MatrixLeftFile));
}
catch (FileNotFoundException e1)
{
　　// TODO 自动生成的 catch 块
　　e1.printStackTrace();
}
            /* 采用压缩转档方法 */
            BitmapOrgLeft.compress(Bitmap.CompressFormat.JPEG, 100, bos);
            /* 调用flush()方法，更新BufferStream */
            try {
                bos.flush();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            /* 结束OutputStream */
            try {
                bos.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            imageAdapter.notifyDataSetChanged();
            //调用函数刷新图片
            Refresh_Rotating_Pictures();
            Toast.makeText(getBaseContext(),  "保存成功!", Toast.LENGTH_LONG).show();
            //及时的释放 Bitmap 对象
            if(BitmapOrgLeft != null && !BitmapOrgLeft.isRecycled())
            {
                BitmapOrgLeft.recycle();
                BitmapOrgLeft = null;
            } 

裁截图片再说明：

主要是两个函数和画布canvas的使用：

public void moveChooseArea(int move_x,int move_y){}：整体调整矩形的四条边，有最大最小限制。

private void pressLB(int x,int y)、 pressLT、 pressRB、 pressRT：调整相邻的某（左、上）两条边，有最大最小限制。

canvas.drawRect(ChooseArea, mPaint); 
        mPaint.setColor(Color.BLUE); 
        canvas.drawRect(recLT, mPaint); 
        canvas.drawRect(recLB, mPaint); 
        canvas.drawRect(recRT, mPaint);    
        canvas.drawRect(recRB, mPaint); 
         
        canvas.drawRect(leftRectL, leftAreaPaint); 
        canvas.drawRect(leftRectR, leftAreaPaint); 
        canvas.drawRect(leftRectT, leftAreaPaint); 
        canvas.drawRect(leftRectB, leftAreaPaint);

package com.cutPicture;
 
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.Bitmap.Config;
import android.graphics.drawable.BitmapDrawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.ImageView;
//http://www.cdtarena.com/gpx/201305/8653.html
public class MyCutView extends ImageView {  
 
    private final static int PRESS_LB = 0;//表示左下角矩形框
    private final static int PRESS_LT = 1;//表示左上角矩形框
    private final static int PRESS_RB = 2;//表示右下角矩形框
    private final static int PRESS_RT = 3;//表示右上角矩形框   
 
    private Bitmap bitMap = null;               //原始图片
    private RectF src = null;                   //经过比例转换后的裁剪区域
    private RectF dst = null;                   //图片显示区域，也就是drawBitmap函数中的目标dst
    private RectF ChooseArea = null;            //选择区域
    private Paint mPaint = null;                //画笔
    private Matrix matrix = null;               //矩阵   
 
    private int mx = 0;                         //存储触笔移动时，之前**的触笔的x坐标
    private int my = 0;                         //存储触笔移动时，之前**的触笔的y坐标
    private boolean touchFlag = false;          //触笔是否在屏幕之*?
    private boolean cutFlag = false;            //是否点击了menu上的裁剪按钮
    private int recFlag = -1;                   //用来存储触笔点击了哪个小矩形框（改变选择区域大小的小矩形框）
    private boolean firstFlag = false;  
 
    private RectF recLT = null;                 //左上角的小矩形框
    private RectF recRT = null;                 //右上角的小矩形框
    private RectF recLB = null;                 //左下角的小矩形框
    private RectF recRB = null;                 //右下角的小矩形框
    private static final int LEFT_AREA_ALPHA = 50 * 255 / 100;
    private RectF leftRectL = null;
    private RectF leftRectR = null;
    private RectF leftRectT = null;
    private RectF leftRectB = null;
    private Paint leftAreaPaint = null;  
 
    int padding=0;
 
    public String editImagePath=null;
    public MyCutView(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.init();
    }  
 
    public MyCutView(Context context) {
        super(context);
        this.init();
    }   
 
    public void init(){
        cutFlag = true;
        recLT = new RectF();
        recLB = new RectF();
        recRT = new RectF();
        recRB = new RectF();
        dst = new RectF();
        mPaint = new Paint();
        mPaint.setColor(Color.RED);
        mPaint.setStyle(Paint.Style.STROKE);      //将画笔的风格改为空心
        ChooseArea = new RectF();
        this.setPressRecLoc();
        src = null;
        firstFlag = true;  
 
        //选择框之外的灰色区域，分成四个矩形框   
 
        leftAreaPaint = new Paint();
        leftAreaPaint.setStyle(Paint.Style.FILL);
        leftAreaPaint.setAlpha(MyCutView.LEFT_AREA_ALPHA);
    }  
 
    public void setBitmap(Bitmap bitmap){
        BitmapDrawable bd = new BitmapDrawable(bitmap);
        src = new RectF(0,0,bd.getIntrinsicWidth(),bd.getIntrinsicHeight());
        this.bitMap = bitmap.copy(Config.ARGB_8888, true);  
 
        this.setImageBitmap(bitMap);
        leftRectB = new RectF();
        leftRectL = new RectF();
        leftRectR = new RectF();
        leftRectT = new RectF();
    }  
 
    public void imageScale(){
        matrix = this.getImageMatrix();
        matrix.mapRect(dst, src);
        padding = this.getPaddingBottom();
        /*
        int width = bitMap.getWidth();
        int height = bitMap.getHeight();
        //dst.set(dst.left+padding,dst.top+padding,dst.right+padding,dst.bottom+padding);
        if(height>width)
        {
            dst.set(dst.left,dst.top,width-7,height+100); 适用于android:layout_width="wrap_content"是FillParent并且没有android:layout_centerInParent="true"属性
        }
        else
        {
            dst.set(dst.left,dst.top,width-170,height+120);
        }
        */
        int w=this.getWidth();
        int h=this.getHeight();
        //if(h>w)
        {
            dst.set(dst.left+2,dst.top+2,w-4,h-6);
        }
        //else
        if(editImagePath!=null)
        {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(editImagePath, options);
            int tempH = options.outHeight;
            if(tempH==1944)
            {
                dst.set(dst.left+2,dst.top+2,w-4,h-67);
            }
        }
        ChooseArea = new RectF(dst);
        this.setPressRecLoc();
    }  
 
    public Bitmap getSubsetBitmap(){
        float ratioWidth = bitMap.getWidth()/(float)(dst.right-dst.left);
        float ratioHeight = bitMap.getHeight()/(float)(dst.bottom - dst.top);
        int left = (int)((ChooseArea.left - dst.left) * ratioWidth);
        int right = (int)(left + (ChooseArea.right - ChooseArea.left) * ratioWidth);
        int top = (int)((ChooseArea.top - dst.top) * ratioHeight);
        int bottom = (int)(top + (ChooseArea.bottom - ChooseArea.top) * ratioHeight);
        src = new RectF(left,top,right,bottom);
        firstFlag = true;
        set_LeftArea_Alpha();
        return Bitmap.createBitmap(bitMap, left, top, right-left, bottom-top);
    }  
 
    //获得ChooseArea对象
    public RectF getChooseArea(){
        return ChooseArea;
    }  
 
    public void moveChooseArea(int move_x,int move_y){
        if(ChooseArea.left + move_x >= dst.left && ChooseArea.right + move_x <= dst.right
        && ChooseArea.top + move_y >= dst.top && ChooseArea.bottom + move_y <= dst.bottom){
            ChooseArea.set(ChooseArea.left + move_x,ChooseArea.top+move_y
                    ,ChooseArea.right + move_x,ChooseArea.bottom+move_y);
        }else{
            if(ChooseArea.left + move_x < dst.left){
                ChooseArea.set(dst.left,ChooseArea.top
                        ,ChooseArea.right+dst.left-ChooseArea.left,ChooseArea.bottom);
            }
            if(ChooseArea.right + move_x > dst.right){
                ChooseArea.set(ChooseArea.left+dst.right-ChooseArea.right,ChooseArea.top
                        ,dst.right,ChooseArea.bottom);
            }  
 
            if(ChooseArea.top + move_y < dst.top){
                ChooseArea.set(ChooseArea.left,dst.top
                        ,ChooseArea.right,ChooseArea.bottom+dst.top-ChooseArea.top);
            }  
 
            if(ChooseArea.bottom + move_y > dst.bottom){
                ChooseArea.set(ChooseArea.left,ChooseArea.top+dst.bottom-ChooseArea.bottom
                        ,ChooseArea.right,dst.bottom);
            }
        }
        this.setPressRecLoc();
        mPaint.setColor(Color.GREEN);
        this.invalidate();
    }  
 
    public boolean onTouchEvent(MotionEvent event){
        mPaint.setColor(Color.RED);  
 
        if(event.getAction() == MotionEvent.ACTION_DOWN && cutFlag){
            //System.out.println(event.getX() + "," + event.getY());   
 
            mx = (int)event.getX();
            my = (int)event.getY();
            if(this.judgeLocation(mx,my)){
                touchFlag = true;
                mPaint.setColor(Color.GREEN);
                this.invalidate();
                return true;
            }else{  
 
                if(this.findPresseddst((int)event.getX(), (int)event.getY())){
                    touchFlag = true;
                    mPaint.setColor(Color.RED);
                    return true;
                }
            }
        }  
 
        if(event.getAction() == MotionEvent.ACTION_MOVE && touchFlag){
            //判断是否点击了哪个个小矩形框
            if(this.isOutOfArea((int)event.getX(), (int)event.getY())){
                return true;
            }  
 
            //www.cdtarena.com如果选择区域大小跟图像大小一样时，就不能移动
            if(ChooseArea.left == dst.left && ChooseArea.top == dst.top &&
               ChooseArea.right == dst.right && ChooseArea.bottom == dst.bottom){
            }else{
                this.moveChooseArea((int)event.getX() - mx, (int)event.getY() - my);
                mx = (int)event.getX();
                my = (int)event.getY();
            }
        }  
 
        if(event.getAction() == MotionEvent.ACTION_UP){
            recFlag = -1;
            this.invalidate();
            touchFlag = false;
        }  
 
        return super.onTouchEvent(event);
    }  
 
    private boolean isOutOfArea(int x,int y){
        switch(recFlag){
        case MyCutView.PRESS_LB:
            this.pressLB(x - mx, y - my);
            break;
        case MyCutView.PRESS_LT:
            this.pressLT(x - mx, y - my);
            break;
        case MyCutView.PRESS_RB:
            this.pressRB(x - mx, y - my);
            break;
        case MyCutView.PRESS_RT:
            this.pressRT(x - mx, y - my);
            break;
        default:return false;
        }
        mx = x;
        my = y;
        this.invalidate();
        return true;
    }  
 
    public boolean findPresseddst(int x,int y){
        boolean returnFlag = false;
        if(this.isInRect(x, y, recLB)){
            recFlag = MyCutView.PRESS_LB;
            returnFlag = true;
        }else if(this.isInRect(x, y, recLT)){
            recFlag = MyCutView.PRESS_LT;
            returnFlag = true;
        }else if(this.isInRect(x, y, recRB)){
            recFlag = MyCutView.PRESS_RB;
            returnFlag = true;
        }else if(this.isInRect(x, y, recRT)){
            recFlag = MyCutView.PRESS_RT;
            returnFlag = true;
        }  
 
        return returnFlag;
    }  
 
    public boolean isInRect(int x,int y,RectF rect){
        if(x >= rect.left -20 && x <= rect.right + 20 && y > rect.top - 20 && y < rect.bottom + 20){
            return true;
        }
        return false;
    }  
 
    private void pressLB(int x,int y){
        float left = ChooseArea.left + x;
        float right = ChooseArea.right;
        float top = ChooseArea.top;
        float bottom = ChooseArea.bottom + y;
        if(left <= right - 30 && left >= dst.left && bottom <= dst.bottom && bottom >= top + 30){
                ChooseArea.set(left,top,right,bottom);
        }else{
            if(left + x < dst.left){
                left = dst.left;
            }  
 
            if(bottom + y > dst.bottom){
                bottom = dst.bottom;
            }  
 
            if(ChooseArea.left + x > ChooseArea.right - 30){
                left = ChooseArea.right - 30;
            }  
 
            if(ChooseArea.bottom + y < ChooseArea.top + 30){
                bottom = ChooseArea.top + 30;
            }
            ChooseArea.set(left,top,right,bottom);
        }
        this.setPressRecLoc();
    }  
 
    private void pressLT(int x,int y){
        float left = ChooseArea.left + x;
        float right = ChooseArea.right;
        float top = ChooseArea.top + y;
        float bottom = ChooseArea.bottom;
        if(left <= right - 30 && left >= dst.left && top <= bottom - 30 && top >= dst.top){
            ChooseArea.set(left,top,right,bottom);
        }else{
            if(left < dst.left){
                left = dst.left;
            }  
 
            if(top < dst.top){
                top = dst.top;
            }  
 
            if(left > right - 30){
                left = right - 30;
            }  
 
            if(top > bottom - 30){
                top = bottom - 30;
            }
            ChooseArea.set(left,top,right,bottom);
        }
        this.setPressRecLoc();
    }  
 
    private void pressRT(int x,int y){
        float left = ChooseArea.left;
        float right = ChooseArea.right + x;
        float top = ChooseArea.top + y;
        float bottom = ChooseArea.bottom;  
 
        if(right <= dst.right && right >= left + 30 && top <= bottom - 30 && top >= dst.top){
            ChooseArea.set(left,top,right,bottom);
        }else{
            if(right > dst.right){
                right = dst.right;
            }  
 
            if(top < dst.top){
                top = dst.top;
            }  
 
            if(right < left + 30){
                right = left + 30;
            }  
 
            if(top > bottom - 30){
                top = bottom - 30;
            }
            ChooseArea.set(left,top,right,bottom);
        }
        this.setPressRecLoc();
    }  
 
    private void pressRB(int x,int y){
        float left = ChooseArea.left;
        float right = ChooseArea.right + x;
        float top = ChooseArea.top;
        float bottom = ChooseArea.bottom + y;  
 
        if(right<= dst.right && right >= left + 30 && bottom <= dst.bottom && bottom >= top + 30){
            ChooseArea.set(left,top,right,bottom);
        }else{
            if(right > dst.right){
                right = dst.right;
            }  
 
            if(bottom > dst.bottom){
                bottom = dst.bottom;
            }  
 
            if(right < left + 30){
                right = left + 30;
            }  
 
            if(bottom < top + 30){
                bottom = top + 30;
            }
            ChooseArea.set(left,top,right,bottom);
        }
        this.setPressRecLoc();
    }  
 
    //每次改变选择区域矩形的大小或者移动，各角落上的小矩形也要改变它的Location
    private void setPressRecLoc(){
        recLT.set(ChooseArea.left-5,ChooseArea.top-5 , ChooseArea.left+5, ChooseArea.top+5);
        recLB.set(ChooseArea.left-5,ChooseArea.bottom-5 , ChooseArea.left+5, ChooseArea.bottom+5);
        recRT.set(ChooseArea.right-5,ChooseArea.top-5 , ChooseArea.right+5, ChooseArea.top+5);
        recRB.set(ChooseArea.right-5,ChooseArea.bottom-5 , ChooseArea.right+5, ChooseArea.bottom+5);
    }  
 
    public boolean judgeLocation(float x,float y){
        float start_x = this.getChooseArea().left;
        float start_y = this.getChooseArea().top;
        float last_x = this.getChooseArea().right;
        float last_y = this.getChooseArea().bottom;
        //System.out.println("chubi:" + x + "," + y);
        //System.out.println(start_y + "," + last_y);
        if(x > start_x+10 && x < last_x-10 && y > start_y+10 && y < last_y-10){
            return true;
        }
        return false;
    }  
 
    public void onDraw(Canvas canvas){
        super.onDraw(canvas);
        if(firstFlag){
            this.imageScale();
            firstFlag = false;
            mPaint.setColor(Color.RED);
            System.out.println("Width: " + (dst.right - dst.left));
            System.out.println("Height: " + (dst.bottom - dst.top));
            System.out.println("Width: " + this.getDrawable().getIntrinsicWidth());
            System.out.println("Height: " + this.getDrawable().getIntrinsicHeight());
        }else{
            set_LeftArea_Alpha();
        }
        canvas.drawRect(ChooseArea, mPaint);
        mPaint.setColor(Color.BLUE);
        canvas.drawRect(recLT, mPaint);
        canvas.drawRect(recLB, mPaint);
        canvas.drawRect(recRT, mPaint);
        canvas.drawRect(recRB, mPaint);  
 
        canvas.drawRect(leftRectL, leftAreaPaint);
        canvas.drawRect(leftRectR, leftAreaPaint);
        canvas.drawRect(leftRectT, leftAreaPaint);
        canvas.drawRect(leftRectB, leftAreaPaint);  
 
    }  
 
    public void set_LeftArea_Alpha(){
        leftRectL.set(dst.left, dst.top, ChooseArea.left, dst.bottom);
        leftRectR.set(ChooseArea.right,dst.top,dst.right,dst.bottom);
        leftRectT.set(ChooseArea.left, dst.top, ChooseArea.right, ChooseArea.top);
        leftRectB.set(ChooseArea.left,ChooseArea.bottom,ChooseArea.right,dst.bottom);
    }
}

播放幻灯片浏览图片再说明：

使用两个全局变量：

public String[] myImageNames;   //所有的图片的名字

public int ImageNameId = 0;     //图片编号

public String picfolderPath;    //实际上是 文件夹 的路径

开个线程，每3秒显示一张图片：

ImagePath = picfolderPath + File.separator + myImageNames[ImageNameId];

ImageNameId++;

public String picfolderPath;    //实际上是 文件夹 的路径
public String[] myImageNames;   //所有的图片的名字
public int ImageNameId = 0;     //图片编号
public String ImagePath ;       //图片的路径
 
is = (ImageSwitcher) findViewById(R.id.slideshow_switcher);
is.setFactory(this);
is.setInAnimation(AnimationUtils.loadAnimation(this,android.R.anim.fade_in));
is.setOutAnimation(AnimationUtils.loadAnimation(this,android.R.anim.fade_out));
 
Runnable runnable=new Runnable() { //采用Handler的postDelayed(Runnable, long)方法 计时
     @Override
     public void run() {
      // TODO Auto-generated method stub
      if(ImageNameId < myImageNames.length)
      {
       is.reset();
       ImagePath = picfolderPath + File.separator + myImageNames[ImageNameId];
       ImageNameId++;
       getSampledBitmap(ImagePath);
      }
      else if(ImageNameId ==myImageNames.length)
      {
       is.reset();
       ImageNameId = 0; //重置 ImageNameId，实现循环播放
       ImagePath = picfolderPath + File.separator + myImageNames[ImageNameId];
       ImageNameId++;
       getSampledBitmap(ImagePath);
      }
      //handler.removeCallbacks(runnable);//停止计时器
      //handler.postDelayed(this, 3000);//3秒时间间隔
  　　}
 };