Welcome to Jianqing's Wiki

User Tools

Site Tools

You are here: Readme » android » Android Animation
Trace:
android:animation

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
android:animation [2012/05/10 09:28] – percyandroid:animation [2016/05/05 13:07] (current) – external edit 127.0.0.1
Line 1: Line 1:
 ====== Android Animation ====== ====== Android Animation ======
 +
 +===== Animation =====
 +  - Android API Animation:http://developer.android.com/reference/android/view/animation/Animation.html
 +  - Android Animation Guide:http://developer.android.com/guide/topics/graphics/animation.html
 +===== Camera =====
 +  - Android API Camera:http://developer.android.com/reference/android/graphics/Camera.html
  
  
Line 7: Line 13:
   - Android API Matrix:http://developer.android.com/reference/android/graphics/Matrix.html   - Android API Matrix:http://developer.android.com/reference/android/graphics/Matrix.html
   - pre/post/set Translate:http://stackoverflow.com/questions/8197656/looking-for-an-explanation-of-post-pre-set-translate-in-matrix-object-and-how   - pre/post/set Translate:http://stackoverflow.com/questions/8197656/looking-for-an-explanation-of-post-pre-set-translate-in-matrix-object-and-how
 +
 +===== Image Util =====
 +<file java ImageUtil.java>
 +
 +package me.pjq.imageutil;
 +
 +import android.graphics.Bitmap;
 +import android.graphics.BitmapFactory;
 +import android.graphics.Canvas;
 +import android.graphics.Color;
 +import android.graphics.Matrix;
 +import android.graphics.Rect;
 +import android.graphics.drawable.BitmapDrawable;
 +import android.graphics.drawable.Drawable;
 +import android.util.Log;
 +
 +import java.io.ByteArrayOutputStream;
 +
 +/**
 + * 图片处理 <br>
 + * Reference:http://blog.csdn.net/maylian7700/article/category/799453
 + * 
 + * @author pengjianqing@gmail.com
 + */
 +public class ImageUtil {
 +
 +    /**
 +     * 图片旋转
 +     * 
 +     * @param bmp 要旋转的图片
 +     * @param degree 图片旋转的角度，负值为逆时针旋转，正值为顺时针旋转
 +     * @return
 +     */
 +    public static Bitmap rotateBitmap(Bitmap bmp, float degree) {
 +        Matrix matrix = new Matrix();
 +        matrix.postRotate(degree);
 +        return Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true);
 +    }
 +
 +    /**
 +     * 图片缩放
 +     * 
 +     * @param bm
 +     * @param scale 值小于则为缩小，否则为放大
 +     * @return
 +     */
 +    public static Bitmap resizeBitmap(Bitmap bm, float scale) {
 +        Matrix matrix = new Matrix();
 +        matrix.postScale(scale, scale);
 +        return Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), matrix, true);
 +    }
 +
 +    /**
 +     * 图片缩放
 +     * 
 +     * @param bm
 +     * @param w 缩小或放大成的宽
 +     * @param h 缩小或放大成的高
 +     * @return
 +     */
 +    public static Bitmap resizeBitmap(Bitmap bm, int w, int h) {
 +        Bitmap BitmapOrg = bm;
 +
 +        int width = BitmapOrg.getWidth();
 +        int height = BitmapOrg.getHeight();
 +
 +        float scaleWidth = ((float) w) / width;
 +        float scaleHeight = ((float) h) / height;
 +
 +        Matrix matrix = new Matrix();
 +        matrix.postScale(scaleWidth, scaleHeight);
 +        return Bitmap.createBitmap(BitmapOrg, 0, 0, width, height, matrix, true);
 +    }
 +
 +    /**
 +     * 图片反转
 +     * 
 +     * @param bm
 +     * @param flag 0为水平反转，1为垂直反转
 +     * @return
 +     */
 +    public static Bitmap reverseBitmap(Bitmap bmp, int flag) {
 +        float[] floats = null;
 +        switch (flag) {
 +            case 0: // 水平反转
 +                floats = new float[] {
 +                        -1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f
 +                };
 +                break;
 +            case 1: // 垂直反转
 +                floats = new float[] {
 +                        1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f
 +                };
 +                break;
 +        }
 +
 +        if (floats != null) {
 +            Matrix matrix = new Matrix();
 +            matrix.setValues(floats);
 +            return Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true);
 +        }
 +
 +        return bmp;
 +    }
 +
 +    /**
 +     * 图片效果叠加
 +     * 
 +     * @param bmp 限制了尺寸大小的Bitmap
 +     * @return
 +     */
 +    public static Bitmap overlay(Bitmap bmp, Bitmap overlay)
 +    {
 +        long start = System.currentTimeMillis();
 +        int width = bmp.getWidth();
 +        int height = bmp.getHeight();
 +        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
 +
 +        // 对边框图片进行缩放
 +        // Bitmap overlay =
 +        // BitmapFactory.decodeResource(mContext.getResources(),
 +        // R.drawable.rainbow_overlay);
 +        int w = overlay.getWidth();
 +        int h = overlay.getHeight();
 +        float scaleX = width * 1F / w;
 +        float scaleY = height * 1F / h;
 +        Matrix matrix = new Matrix();
 +        matrix.postScale(scaleX, scaleY);
 +
 +        Bitmap overlayCopy = Bitmap.createBitmap(overlay, 0, 0, w, h, matrix, true);
 +
 +        int pixColor = 0;
 +        int layColor = 0;
 +
 +        int pixR = 0;
 +        int pixG = 0;
 +        int pixB = 0;
 +        int pixA = 0;
 +
 +        int newR = 0;
 +        int newG = 0;
 +        int newB = 0;
 +        int newA = 0;
 +
 +        int layR = 0;
 +        int layG = 0;
 +        int layB = 0;
 +        int layA = 0;
 +
 +        final float alpha = 0.5F;
 +
 +        int[] srcPixels = new int[width * height];
 +        int[] layPixels = new int[width * height];
 +        bmp.getPixels(srcPixels, 0, width, 0, 0, width, height);
 +        overlayCopy.getPixels(layPixels, 0, width, 0, 0, width, height);
 +
 +        int pos = 0;
 +        for (int i = 0; i < height; i++)
 +        {
 +            for (int k = 0; k < width; k++)
 +            {
 +                pos = i * width + k;
 +                pixColor = srcPixels[pos];
 +                layColor = layPixels[pos];
 +
 +                pixR = Color.red(pixColor);
 +                pixG = Color.green(pixColor);
 +                pixB = Color.blue(pixColor);
 +                pixA = Color.alpha(pixColor);
 +
 +                layR = Color.red(layColor);
 +                layG = Color.green(layColor);
 +                layB = Color.blue(layColor);
 +                layA = Color.alpha(layColor);
 +
 +                newR = (int) (pixR * alpha + layR * (1 - alpha));
 +                newG = (int) (pixG * alpha + layG * (1 - alpha));
 +                newB = (int) (pixB * alpha + layB * (1 - alpha));
 +                layA = (int) (pixA * alpha + layA * (1 - alpha));
 +
 +                newR = Math.min(255, Math.max(0, newR));
 +                newG = Math.min(255, Math.max(0, newG));
 +                newB = Math.min(255, Math.max(0, newB));
 +                newA = Math.min(255, Math.max(0, layA));
 +
 +                srcPixels[pos] = Color.argb(newA, newR, newG, newB);
 +            }
 +        }
 +
 +        bitmap.setPixels(srcPixels, 0, width, 0, 0, width, height);
 +        long end = System.currentTimeMillis();
 +        Log.d("may", "overlayAmeliorate used time=" + (end - start));
 +        return bitmap;
 +    }
 +
 +    /**
 +     * 浮雕效果
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static Bitmap emboss(Bitmap bmp)
 +    {
 +        int width = bmp.getWidth();
 +        int height = bmp.getHeight();
 +        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
 +
 +        int pixR = 0;
 +        int pixG = 0;
 +        int pixB = 0;
 +
 +        int pixColor = 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);
 +        int pos = 0;
 +        for (int i = 1, length = height - 1; i < length; i++)
 +        {
 +            for (int k = 1, len = width - 1; k < len; k++)
 +            {
 +                pos = i * width + k;
 +                pixColor = pixels[pos];
 +
 +                pixR = Color.red(pixColor);
 +                pixG = Color.green(pixColor);
 +                pixB = Color.blue(pixColor);
 +
 +                pixColor = pixels[pos + 1];
 +                newR = Color.red(pixColor) - pixR + 127;
 +                newG = Color.green(pixColor) - pixG + 127;
 +                newB = Color.blue(pixColor) - pixB + 127;
 +
 +                newR = Math.min(255, Math.max(0, newR));
 +                newG = Math.min(255, Math.max(0, newG));
 +                newB = Math.min(255, Math.max(0, newB));
 +
 +                pixels[pos] = Color.argb(255, newR, newG, newB);
 +            }
 +        }
 +
 +        bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
 +        return bitmap;
 +    }
 +
 +    /**
 +     * 叠加边框图片有用部分
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static Bitmap alphaLayer(Bitmap bmp, Bitmap overlay)
 +    {
 +        int width = bmp.getWidth();
 +        int height = bmp.getHeight();
 +        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
 +
 +        // 边框图片
 +        // Bitmap overlay =
 +        // BitmapFactory.decodeResource(mContext.getResources(),
 +        // R.drawable.black);
 +        int w = overlay.getWidth();
 +        int h = overlay.getHeight();
 +        float scaleX = width * 1F / w;
 +        float scaleY = height * 1F / h;
 +        Matrix matrix = new Matrix();
 +        matrix.postScale(scaleX, scaleY);
 +
 +        Bitmap overlayCopy = Bitmap.createBitmap(overlay, 0, 0, w, h, matrix, true);
 +
 +        int pixColor = 0;
 +        int layColor = 0;
 +        int newColor = 0;
 +
 +        int pixR = 0;
 +        int pixG = 0;
 +        int pixB = 0;
 +        int pixA = 0;
 +
 +        int newR = 0;
 +        int newG = 0;
 +        int newB = 0;
 +        int newA = 0;
 +
 +        int layR = 0;
 +        int layG = 0;
 +        int layB = 0;
 +        int layA = 0;
 +
 +        float alpha = 0.3F;
 +        float alphaR = 0F;
 +        float alphaG = 0F;
 +        float alphaB = 0F;
 +        for (int i = 0; i < width; i++)
 +        {
 +            for (int k = 0; k < height; k++)
 +            {
 +                pixColor = bmp.getPixel(i, k);
 +                layColor = overlayCopy.getPixel(i, k);
 +
 +                // 获取原图片的RGBA值
 +                pixR = Color.red(pixColor);
 +                pixG = Color.green(pixColor);
 +                pixB = Color.blue(pixColor);
 +                pixA = Color.alpha(pixColor);
 +
 +                // 获取边框图片的RGBA值
 +                layR = Color.red(layColor);
 +                layG = Color.green(layColor);
 +                layB = Color.blue(layColor);
 +                layA = Color.alpha(layColor);
 +
 +                // 颜色与纯黑色相近的点
 +                if (layR < 20 && layG < 20 && layB < 20)
 +                {
 +                    alpha = 1F;
 +                }
 +                else
 +                {
 +                    alpha = 0.3F;
 +                }
 +
 +                alphaR = alpha;
 +                alphaG = alpha;
 +                alphaB = alpha;
 +
 +                // 两种颜色叠加
 +                newR = (int) (pixR * alphaR + layR * (1 - alphaR));
 +                newG = (int) (pixG * alphaG + layG * (1 - alphaG));
 +                newB = (int) (pixB * alphaB + layB * (1 - alphaB));
 +                layA = (int) (pixA * alpha + layA * (1 - alpha));
 +
 +                // 值在0~255之间
 +                newR = Math.min(255, Math.max(0, newR));
 +                newG = Math.min(255, Math.max(0, newG));
 +                newB = Math.min(255, Math.max(0, newB));
 +                newA = Math.min(255, Math.max(0, layA));
 +
 +                newColor = Color.argb(newA, newR, newG, newB);
 +                bitmap.setPixel(i, k, newColor);
 +            }
 +        }
 +
 +        return bitmap;
 +    }
 +
 +    /**
 +     * Bitmap转换成byte数组
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static byte[] bitmap2Byte(Bitmap bmp)
 +    {
 +        ByteArrayOutputStream baos = new ByteArrayOutputStream();
 +        bmp.compress(Bitmap.CompressFormat.PNG, 100, baos);
 +        return baos.toByteArray();
 +    }
 +
 +    /**
 +     * 数组转换成Bitmap
 +     * 
 +     * @param buffer
 +     * @return
 +     */
 +    public static Bitmap byte2Bitmap(byte[] buffer)
 +    {
 +        return BitmapFactory.decodeByteArray(buffer, 0, buffer.length);
 +    }
 +
 +    /**
 +     * Bitmap转换成Drawable
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static Drawable bitmap2Drawable(Bitmap bmp)
 +    {
 +        return new BitmapDrawable(bmp);
 +    }
 +
 +    /**
 +     * BitmapDrawable转换成Bitmap
 +     * 
 +     * @param drawable
 +     * @return
 +     */
 +    public static Bitmap drawable2Bitmap(BitmapDrawable drawable)
 +    {
 +        return drawable.getBitmap();
 +    }
 +
 +    /**
 +     * 怀旧效果(相对之前做了优化快一倍)
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static Bitmap oldRemeber(Bitmap bmp)
 +    {
 +        // 速度测试
 +        long start = System.currentTimeMillis();
 +        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);
 +        long end = System.currentTimeMillis();
 +        Log.d("may", "used time=" + (end - start));
 +        return bitmap;
 +    }
 +
 +    /**
 +     * 模糊效果
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static Bitmap blurImage(Bitmap bmp)
 +    {
 +        int width = bmp.getWidth();
 +        int height = bmp.getHeight();
 +        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
 +
 +        int pixColor = 0;
 +
 +        int newR = 0;
 +        int newG = 0;
 +        int newB = 0;
 +
 +        int newColor = 0;
 +
 +        int[][] colors = new int[9][3];
 +        for (int i = 1, length = width - 1; i < length; i++)
 +        {
 +            for (int k = 1, len = height - 1; k < len; k++)
 +            {
 +                for (int m = 0; m < 9; m++)
 +                {
 +                    int s = 0;
 +                    int p = 0;
 +                    switch (m)
 +                    {
 +                        case 0:
 +                            s = i - 1;
 +                            p = k - 1;
 +                            break;
 +                        case 1:
 +                            s = i;
 +                            p = k - 1;
 +                            break;
 +                        case 2:
 +                            s = i + 1;
 +                            p = k - 1;
 +                            break;
 +                        case 3:
 +                            s = i + 1;
 +                            p = k;
 +                            break;
 +                        case 4:
 +                            s = i + 1;
 +                            p = k + 1;
 +                            break;
 +                        case 5:
 +                            s = i;
 +                            p = k + 1;
 +                            break;
 +                        case 6:
 +                            s = i - 1;
 +                            p = k + 1;
 +                            break;
 +                        case 7:
 +                            s = i - 1;
 +                            p = k;
 +                            break;
 +                        case 8:
 +                            s = i;
 +                            p = k;
 +                    }
 +                    pixColor = bmp.getPixel(s, p);
 +                    colors[m][0] = Color.red(pixColor);
 +                    colors[m][1] = Color.green(pixColor);
 +                    colors[m][2] = Color.blue(pixColor);
 +                }
 +
 +                for (int m = 0; m < 9; m++)
 +                {
 +                    newR += colors[m][0];
 +                    newG += colors[m][1];
 +                    newB += colors[m][2];
 +                }
 +
 +                newR = (int) (newR / 9F);
 +                newG = (int) (newG / 9F);
 +                newB = (int) (newB / 9F);
 +
 +                newR = Math.min(255, Math.max(0, newR));
 +                newG = Math.min(255, Math.max(0, newG));
 +                newB = Math.min(255, Math.max(0, newB));
 +
 +                newColor = Color.argb(255, newR, newG, newB);
 +                bitmap.setPixel(i, k, newColor);
 +
 +                newR = 0;
 +                newG = 0;
 +                newB = 0;
 +            }
 +        }
 +
 +        return bitmap;
 +    }
 +
 +    /**
 +     * 柔化效果(高斯模糊)(优化后比上面快三倍)
 +     * 
 +     * @param bmp
 +     * @return
 +     */
 +    public static Bitmap blurImageAmeliorate(Bitmap bmp)
 +    {
 +        long start = System.currentTimeMillis();
 +        // 高斯矩阵
 +        int[] gauss = new int[] {
 +                1, 2, 1, 2, 4, 2, 1, 2, 1
 +        };
 +
 +        int width = bmp.getWidth();
 +        int height = bmp.getHeight();
 +        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
 +
 +        int pixR = 0;
 +        int pixG = 0;
 +        int pixB = 0;
 +
 +        int pixColor = 0;
 +
 +        int newR = 0;
 +        int newG = 0;
 +        int newB = 0;
 +
 +        int delta = 16; // 值越小图片会越亮，越大则越暗
 +
 +        int idx = 0;
 +        int[] pixels = new int[width * height];
 +        bmp.getPixels(pixels, 0, width, 0, 0, width, height);
 +        for (int i = 1, length = height - 1; i < length; i++)
 +        {
 +            for (int k = 1, len = width - 1; k < len; k++)
 +            {
 +                idx = 0;
 +                for (int m = -1; m <= 1; m++)
 +                {
 +                    for (int n = -1; n <= 1; n++)
 +                    {
 +                        pixColor = pixels[(i + m) * width + k + n];
 +                        pixR = Color.red(pixColor);
 +                        pixG = Color.green(pixColor);
 +                        pixB = Color.blue(pixColor);
 +
 +                        newR = newR + (int) (pixR * gauss[idx]);
 +                        newG = newG + (int) (pixG * gauss[idx]);
 +                        newB = newB + (int) (pixB * gauss[idx]);
 +                        idx++;
 +                    }
 +                }
 +
 +                newR /= delta;
 +                newG /= delta;
 +                newB /= delta;
 +
 +                newR = Math.min(255, Math.max(0, newR));
 +                newG = Math.min(255, Math.max(0, newG));
 +                newB = Math.min(255, Math.max(0, newB));
 +
 +                pixels[i * width + k] = Color.argb(255, newR, newG, newB);
 +
 +                newR = 0;
 +                newG = 0;
 +                newB = 0;
 +            }
 +        }
 +
 +        bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
 +        long end = System.currentTimeMillis();
 +        Log.d("may", "used time=" + (end - start));
 +        return bitmap;
 +    }
 +
 +    /** 图片的上半部分标识 */
 +    public static final int FLAG_TOP = 0x1;
 +    /** 图片的下半部分标识 */
 +    public static final int FLAG_BOTTOM = FLAG_TOP << 1;
 +    /** 图片的左半部分标识 */
 +    public static final int FLAG_LEFT = FLAG_TOP << 2;
 +    /** 图片的右半部分标识 */
 +    public static final int FLAG_RIGHT = FLAG_TOP << 3;
 +
 +    public static Bitmap cropBitmap(Bitmap bmp)
 +    {
 +        // 将图片切成左右两块
 +        Bitmap left = cropBitmapLandscape(bmp, FLAG_LEFT);
 +        Bitmap right = cropBitmapLandscape(bmp, FLAG_RIGHT);
 +
 +        // 再将左右两块图片切成四块
 +        Bitmap leftTop = cropBitmapPortrait(left, FLAG_TOP);
 +        Bitmap leftBottom = cropBitmapPortrait(left, FLAG_BOTTOM);
 +        Bitmap rightTop = cropBitmapPortrait(right, FLAG_TOP);
 +        Bitmap rightBottom = cropBitmapPortrait(right, FLAG_BOTTOM);
 +
 +        // 原左右两块图片回收
 +        left.recycle();
 +        right.recycle();
 +        left = null;
 +        right = null;
 +
 +        // 创建新图片，中间留10个像素的间距
 +        final int width = bmp.getWidth() + 10;
 +        final int height = bmp.getHeight() + 10;
 +        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
 +
 +        // 组合图片
 +        final int leftPos = width - leftBottom.getWidth();
 +        final int topPos = height - leftBottom.getHeight();
 +        Canvas canvas = new Canvas(bitmap);
 +        canvas.drawBitmap(rightBottom, 0, 0, null); // 放在左上角
 +        canvas.drawBitmap(leftBottom, leftPos, 0, null); // 放在右上角
 +        canvas.drawBitmap(rightTop, 0, topPos, null); // 放在左下角
 +        canvas.drawBitmap(leftTop, leftPos, topPos, null); // 放在右下角
 +
 +        // 图片回收
 +        leftTop.recycle();
 +        leftBottom.recycle();
 +        rightTop.recycle();
 +        rightBottom.recycle();
 +
 +        rightTop = null;
 +        leftTop = null;
 +        leftBottom = null;
 +        rightBottom = null;
 +
 +        return bitmap;
 +    }
 +
 +    /**
 +     * 水平切割图片，也就是将图片分成左右两块
 +     * 
 +     * @param bmp 图片
 +     * @param flag 是保留左边还是右边的标识
 +     * @return
 +     */
 +    public static Bitmap cropBitmapLandscape(Bitmap bmp, int flag)
 +    {
 +        final int width = bmp.getWidth();
 +        final int height = bmp.getHeight();
 +        int startWidth = 0; // 起始宽度位置
 +        int endWidth = width / 2; // 结束宽度位置
 +        Bitmap bitmap = Bitmap.createBitmap(endWidth, height, Bitmap.Config.RGB_565); // 创建新的图片，宽度只有原来的一半
 +
 +        switch (flag)
 +        {
 +            case FLAG_LEFT:
 +                break;
 +            case FLAG_RIGHT:
 +                startWidth = endWidth;
 +                endWidth = width;
 +                break;
 +        }
 +
 +        Rect r = new Rect(startWidth, 0, endWidth, height); // 图片要切的范围
 +        Rect rect = new Rect(0, 0, width / 2, height); // 新图片的大小
 +        Canvas canvas = new Canvas(bitmap);
 +        canvas.drawBitmap(bmp, r, rect, null); // 切割图片
 +        return bitmap;
 +    }
 +
 +    /**
 +     * 垂直切割图片，也就是说将图片切成上下两块
 +     * 
 +     * @param bmp
 +     * @param flag 图片是保留上面还是下面
 +     * @return
 +     */
 +    public static Bitmap cropBitmapPortrait(Bitmap bmp, int flag)
 +    {
 +        final int width = bmp.getWidth();
 +        final int height = bmp.getHeight();
 +        int startHeight = 0; // 高度的起始位置
 +        int endHeight = height / 2; // 高度的结束位置
 +        Bitmap bitmap = Bitmap.createBitmap(width, height / 2, Bitmap.Config.RGB_565); // 创建新图片，高度只有原来的一半
 +
 +        switch (flag)
 +        {
 +            case FLAG_TOP:
 +                break;
 +            case FLAG_BOTTOM:
 +                startHeight = endHeight;
 +                endHeight = height;
 +                break;
 +        }
 +
 +        Rect r = new Rect(0, startHeight, width, endHeight); // 图片要切的范围
 +        Rect rect = new Rect(0, 0, width, height / 2); // 新图片的大小
 +        Canvas canvas = new Canvas(bitmap);
 +        canvas.drawBitmap(bmp, r, rect, null); // 切割图片
 +        return bitmap;
 +    }
 +
 +}
 +
 +
 +</file>
/var/www/dokuwiki/wiki/data/attic/android/animation.1336613338.txt.gz · Last modified: 2016/05/05 13:06 (external edit)