Android绘画之扭曲图像

本例使用drawBitmapMess方法对图像进行扭曲。为了实现动画效果，本例中使用定时器以100毫秒的频率按圆形轨迹扭曲图像。下面先看看扭曲后的效果，图1和图2是不同位置扭曲后的效果。

图1

图2

扭曲的关键是生成verts数组。本例一开始会先生成verts数组的初始值：有一定水平和垂直间距的网点坐标。然后通过warp方法按一定的数学方法变化verts数组中的坐标。本例的完整代码如下：

import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
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.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.FloatMath;
import android.util.Log;
import android.view.View;
 
public class Main extends Activity
{
    private static Bitmap bitmap;
    private MyView myView;
    private int angle = 0;                  // 圆形轨迹当前的角度
    private Handler handler = new Handler()
    {
        public void handleMessage(Message msg)
        {
            switch (msg.what)
            {
                case 1:
                    Random random = new Random();
                    //  计算图形中心点坐标
                    int centerX = bitmap.getWidth() / 2;
                    int centerY = bitmap.getHeight() / 2;
                    double radian = Math.toRadians((double) angle);
                    //  通过圆心坐标、半径和当前角度计算当前圆周的某点横坐标
                    int currentX = (int) (centerX + 100 * Math.cos(radian));
                    //  通过圆心坐标、半径和当前角度计算当前圆周的某点纵坐标
                    int currentY = (int) (centerY + 100 * Math.sin(radian));
                    //  重绘View，并在圆周的某一点扭曲图像
                    myView.mess(currentX, currentY);
                    angle += 2;
                    if (angle > 360)
                        angle = 0;
                    break;
            }
            super.handleMessage(msg);
        }
    };
    private TimerTask timerTask = new TimerTask()
    {
        public void run()
        {
            Message message = new Message();
            message.what = 1;
            handler.sendMessage(message);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        myView = new MyView(this);
        setContentView(myView);   
        Timer timer = new Timer();
        //  开始定时器
        timer.schedule(timerTask, 0, 100);
    }
    //  用于显示扭曲的图像
    private static class MyView extends View
    {
        private static final int WIDTH = 20;
        private static final int HEIGHT = 20;
        private static final int COUNT = (WIDTH + 1) * (HEIGHT + 1);
        private final float[] verts = new float[COUNT * 2];
        private final float[] orig = new float[COUNT * 2];
        private final Matrix matrix = new Matrix();
        private final Matrix m = new Matrix();
        //  设置verts数组的值
        private static void setXY(float[] array, int index, float x, float y)
        {
            array[index * 2 + 0] = x;
            array[index * 2 + 1] = y;
        }
        public MyView(Context context)
        {
            super(context);
            setFocusable(true);
            bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
            float w = bitmap.getWidth();
            float h = bitmap.getHeight();
            int index = 0;
            //  生成verts和orig数组的初始值，这两个数组的值是一样的，只是在扭曲的过程中需要修改verts
            //  的值，而修改verts的值要将原始的值保留在orig数组中
            for (int y = 0; y <= HEIGHT; y++)
            {
                float fy = h * y / HEIGHT;
                for (int x = 0; x <= WIDTH; x++)
                {
                    float fx = w * x / WIDTH;
                    setXY(verts, index, fx, fy);
                    setXY(orig, index, fx, fy);
                    index += 1;
                }
            }
            matrix.setTranslate(10, 10);
            setBackgroundColor(Color.WHITE);
        }
        @Override
        protected void onDraw(Canvas canvas)
        {
            canvas.concat(matrix);
            canvas.drawBitmapMesh(bitmap, WIDTH, HEIGHT, verts, 0, null, 0,null);
        }
        //  用于扭曲图像的方法，在该方法中根据当前扭曲的点（扭曲区域的中心点），也就是cx和cy参数，
        //  来不断变化verts数组中的坐标值
        private void warp(float cx, float cy)
        {
            final float K = 100000;   //  该值越大，扭曲得越严重（扭曲的范围越大）
            float[] src = orig;
            float[] dst = verts;
            //  按一定的数学规则生成verts数组中的元素值
            for (int i = 0; i < COUNT * 2; i += 2)
            {
                float x = src[i + 0];
                float y = src[i + 1];
                float dx = cx - x;
                float dy = cy - y;
                float dd = dx * dx + dy * dy;
                float d = FloatMath.sqrt(dd);
                float pull = K / ((float) (dd *d));
                if (pull >= 1)
                {
                    dst[i + 0] = cx;
                    dst[i + 1] = cy;
                }
                else
                {
                    dst[i + 0] = x + dx * pull;
                    dst[i + 1] = y + dy * pull;
                }
            }
        }
        //  用于MyView外部控制图像扭曲的方法。该方法在handleMessage方法中被调用
        public void mess(int x, int y)
        {
            float[] pt ={ x, y };
            m.mapPoints(pt);
            //  重新生成verts数组的值
            warp(pt[0], pt[1]);
            invalidate();
        }
    }
}