图形与图像处理

yehenanjing

于 2022-09-26 15:25:25 发布

阅读量1.3k

点赞数

文章标签：图像处理 android java

本文链接：https://blog.csdn.net/yehenanjing/article/details/126968765

版权

简单弹球游戏

package com.example.imagetest;

import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RadialGradient;
import android.graphics.Shader;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;

import java.lang.ref.WeakReference;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends Activity
{
    // 屏幕的宽度
    private float tableWidth;
    // 屏幕的高度
    private float tableHeight;
    // 球拍的垂直位置
    private float racketY;
    // 下面定义球拍的高度和宽度
    private float racketHeight;
    private float racketWidth;
    // 小球的大小
    private float ballSize;
    // 小球纵向的运行速度
    private int ySpeed = 15;
    private Random rand = new Random();
    // 返回一个-0.5~0.5的比率，用于控制小球的运行方向
    private double xyRate = rand.nextDouble() - 0.5;
    // 小球横向的运行速度
    private int xSpeed = (int) (ySpeed * xyRate * 2.0);
    // ballX和ballY代表小球的坐标
    private float ballX = rand.nextInt(200) + 20f;
    private float ballY = rand.nextInt(10) + 60f;
    // racketX代表球拍的水平位置
    private float racketX = rand.nextInt(200);
    // 游戏是否结束的旗标
    private boolean isLose;
    private GameView gameView;
    static class MyHandler extends Handler
    {
        private WeakReference<MainActivity> activity;
        MyHandler(WeakReference<MainActivity> activity)
        {
            this.activity = activity;
        }
        @Override
        public void handleMessage(Message msg)
        {
            if (msg.what == 0x123)
            {
                activity.get().gameView.invalidate();
            }
        }
    }
    private Handler handler = new MyHandler(new WeakReference<>(this));
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        // 去掉窗口标题
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        racketHeight = getResources().getDimension(R.dimen.racket_height);
        racketWidth = getResources().getDimension(R.dimen.racket_width);
        ballSize = getResources().getDimension(R.dimen.ball_size);
        // 全屏显示
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        // 创建GameView组件
        gameView = new GameView(this);
        setContentView(gameView);
        // 获取窗口管理器
        WindowManager windowManager = getWindowManager();
        Display display = windowManager.getDefaultDisplay();
        DisplayMetrics metrics = new DisplayMetrics();
        display.getMetrics(metrics);
        // 获得屏幕宽和高
        tableWidth = metrics.widthPixels;
        tableHeight = metrics.heightPixels;
        racketY = tableHeight - 80;
        gameView.setOnTouchListener((source, event) -> { // ②
            if (event.getX() <= tableWidth / 10)
            {
                // 控制挡板左移
                if (racketX > 0) racketX -= 10;
            }
            if (event.getX() >= tableWidth * 9 / 10)
            {
                // 控制挡板右移
                if (racketX < tableWidth - racketWidth) racketX += 10;
            }
            return true;
        });
        Timer timer = new Timer();
        timer.schedule(new TimerTask()  // ①
        {
            @Override
            public void run()
            {
                // 如果小球碰到左边边框
                if (ballX < ballSize || ballX >= tableWidth - ballSize)
                {
                    xSpeed = -xSpeed;
                }
                // 如果小球高度超出了球拍位置，且横向不在球拍范围之内，游戏结束
                if (ballY >= racketY - ballSize &&
                        (ballX < racketX || ballX > racketX + racketWidth))
                {
                    timer.cancel();
                    // 设置游戏是否结束的旗标为true
                    isLose = true;
                }
                // 如果小球位于球拍之内，且到达球拍位置，小球反弹
                else if (ballY < ballSize || (ballY >= racketY - ballSize &&
                        ballX > racketX && ballX <= racketX + racketWidth))
                {
                    ySpeed = -ySpeed;
                }
                // 小球坐标增加
                ballY += ySpeed;
                ballX += xSpeed;
                // 发送消息，通知系统重绘组件
                handler.sendEmptyMessage(0x123);
            }
        }, 0, 100);
    }
    class GameView extends View
    {
        private Paint paint = new Paint();
        private RadialGradient mShader = new RadialGradient(-ballSize/ 2,
                -ballSize/ 2, ballSize, Color.WHITE, Color.RED, Shader.TileMode.CLAMP);
        public GameView(Context context)
        {
            super(context);
            setFocusable(true);
            paint.setStyle(Paint.Style.FILL);
            // 设置去锯齿
            paint.setAntiAlias(true);
        }

        // 重写View的onDraw方法，实现绘画
        @Override
        public void onDraw(Canvas canvas)
        {
            // 如果游戏已经结束
            if (isLose)
            {
                paint.setColor(Color.RED);
                paint.setTextSize(40f);
                canvas.drawText("游戏已结束", tableWidth / 2 - 100, 200f, paint);
            }
            // 如果游戏还未结束
            else
            {
                canvas.save(); // 保存坐标系统
                // 将坐标系统平移到小球圆心处来绘制小球
                canvas.translate(ballX, ballY);
                // 设置渐变，并绘制小球
                paint.setShader(mShader);
                canvas.drawCircle(0f, 0f, ballSize, paint);
                canvas.restore(); // 恢复原来的坐标系统
                paint.setShader(null);
                // 设置颜色，并绘制球拍
                paint.setColor(Color.rgb(80, 80, 200));
                canvas.drawRect(racketX, racketY, racketX + racketWidth,
                        racketY + racketHeight, paint);
            }
        }
    }
}

扭曲图片

package com.example.ima;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.os.Bundle;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

import java.util.Spliterator;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new MyView(this,R.drawable.jinta));
    }
    private class MyView extends View{
        //横向纵向都划分20格
        private final static int WIDTH=20;
        private final static int HEIGHT=20;
        //记录图片上的441个顶点
        private final static int COUNT=(WIDTH+1)*(HEIGHT+1);
        //保存点的坐标
        private float[] verts = new float[COUNT*2];
        //保存扭曲后的点的坐标
        private float[] orig=new float[COUNT*2];
        private Bitmap bitmap;
        public MyView(Context context, int drawableId) {
            super(context);
            setFocusable(true);
            //加载图片
            bitmap= BitmapFactory.decodeResource(getResources(),drawableId);
            //获取图片宽高
            float bitmapWidth = bitmap.getWidth();
            float bitmapHeight = bitmap.getHeight();
            int index=0;
            for (int y=0;y<HEIGHT;y++){
                float fy=bitmapHeight*y/HEIGHT;
                for (int x=0;x<=WIDTH;x++){
                    float fx=bitmapWidth*x/WIDTH;
                    //初始化数组，保存坐标
                    verts[index*2]=fx;
                    orig[index*2]=verts[index*2];
                    verts[index*2+1]=fy;
                    orig[index*2+1]=verts[index*2+1];
                    index++;
                }
            }
            //设置背景色
            setBackgroundColor(Color.WHITE);
        }

        @Override
        public void onDraw(Canvas canvas) {
            //从第一个点开始扭曲
            canvas.drawBitmapMesh(bitmap,WIDTH,HEIGHT,verts,0,null,0,null);
        }
        //工具方法，用于根据触摸事件的位置计算verts数组里各元素的值
        private void wrap(float cx,float cy){
            for (int i = 0; i < COUNT*2; i+=2) {
                float dx = cx-orig[i];
                float dy = cx-orig[i+1];
                float dd = dx*dx+dy*dy;
                //计算每个坐标点与当前点（cx,cy）之间的距离
                float d = (float) Math.sqrt(dd);
                //计算扭曲度，距离当前点越远，扭曲度越小
                float pull = 20000/(dd*d);
                //对verts数组重新赋值
                if(pull>=1){
                    verts[i]=cx;
                    verts[i+1]=cy;
                }
                else {
                    //各顶点向触摸事件发生点偏移
                    verts[i]=orig[i]+dx*pull;
                    verts[i+1]=orig[i+1]+dy*pull;
                }
            }
            //重绘
            invalidate();
        }
        @Override
        public boolean onTouchEvent(MotionEvent event){
            //调用wrap方法根据触摸屏事件的坐标点来扭曲verts数组
            wrap(event.getX(),event.getY());
            return true;
        }
    }
}

大珠小珠落玉盘

package com.example.crazyit;

import androidx.appcompat.app.AppCompatActivity;

import android.animation.Animator;
import android.animation.AnimatorInflater;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ArgbEvaluator;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.RadialGradient;
import android.graphics.Shader;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.OvalShape;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.widget.LinearLayout;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {
    //小球大小
    public static final float BALL_SIZE=50f;
    //小球从屏幕上方落到屏幕下方需要的时间
    public static final float FULL_TIME=1000f;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        LinearLayout container=findViewById(R.id.container);
        //设置该窗口显示MyAnimationView组件
        container.addView(new MyAnimationView(this));
    }
    class MyAnimationView extends View{
        List<ShapeHolder> balls = new ArrayList<ShapeHolder>();
        public MyAnimationView(Context context) {
            super(context);
            //加载动画资源
            ObjectAnimator colorAnim = (ObjectAnimator) AnimatorInflater.loadAnimator(MainActivity.this,R.animator.color_anim);
            colorAnim.setEvaluator(new ArgbEvaluator());
            //对该View本身应用属性动画
            colorAnim.setTarget(this);
            //开始指定动画
            colorAnim.start();
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            //如果触碰事件不是按下、移动事件
            if(event.getAction()!=MotionEvent.ACTION_DOWN&&event.getAction()!=MotionEvent.ACTION_MOVE){
                return false;
            }
            //在事件发生点添加一个小球
            ShapeHolder newBall = addBall(event.getX(),event.getY());
            //计算小球下落动画开始时的y坐标
            float startY=newBall.getY();
            //计算小球下落动画结束时的y坐标
            float endY=getHeight()-BALL_SIZE;
            //获取屏幕高度
            float h=getHeight();
            float eventY=event.getY();
            //计算动画的持续时间
            int duration = (int) (FULL_TIME*(h-eventY)/h);
            //定义小球落下的动画
            //让newBall对象的y属性从事件发生点变化到屏幕最下方
            ObjectAnimator fallAnim = ObjectAnimator.ofFloat(newBall,"y",startY,endY);
            //设置fallAnim动画的持续时间
            fallAnim.setDuration(duration);
            //设置fallAnim动画的插值方式：加速插值
            fallAnim.setInterpolator(new AccelerateInterpolator());
            //定义小球“压扁”动画：该动画控制小球的x坐标“左移”半个球
            ObjectAnimator squashAnim1=ObjectAnimator.ofFloat(newBall,"x",newBall.getX(),newBall.getX()-BALL_SIZE/2);
            //设置squashAnim1动画的持续时间
            squashAnim1.setDuration(duration/4);
            //设置squashAnim1动画重复一次
            squashAnim1.setRepeatCount(1);
            //设置squashAnim1动画的持续方式
            squashAnim1.setRepeatMode(ValueAnimator.REVERSE);
            //设置squashAnim1动画的插值方式：减速插值
            squashAnim1.setInterpolator(new DecelerateInterpolator());
            //定义小球“压扁”动画：该动画控制小球的宽度加倍
            ObjectAnimator squashAnim2=ObjectAnimator.ofFloat(newBall,"width",newBall.getWidth(),newBall.getWidth()+BALL_SIZE);
            //设置squashAnim1动画的持续时间
            squashAnim2.setDuration(duration/4);
            //设置squashAnim2动画重复一次
            squashAnim2.setRepeatCount(1);
            //设置squashAnim1动画的持续方式
            squashAnim2.setRepeatMode(ValueAnimator.REVERSE);
            //设置squashAnim2动画的插值方式：减速插值
            squashAnim2.setInterpolator(new DecelerateInterpolator());
            //定义小球“弹起”的动画
            ObjectAnimator bounceBackAnim=ObjectAnimator.ofFloat(newBall,"y",endY,startY);
            //设置持续时间
            bounceBackAnim.setDuration(duration);
            //设置squashAnim2动画的插值方式：减速插值
            bounceBackAnim.setInterpolator(new DecelerateInterpolator());
            //使用AnimatorSet按顺序播放“下落/压扁&拉伸/弹起动画”
            AnimatorSet bouncer = new AnimatorSet();
            //定义在squashAnim1动画之前播放fallAnim动画
            bouncer.play(fallAnim).before(squashAnim1);
            //小球在屏幕下方弹起时，小球要被压扁
            bouncer.play(squashAnim1).with(squashAnim2);
            bouncer.play(squashAnim1).with(squashAnim1);
            bouncer.play(squashAnim1).with(squashAnim2);
            //播放squashAnim2动画后，播放弹起动画
            bouncer.play(bounceBackAnim).after(squashAnim2);
            //定义对newBall对象的alpha属性执行从1到0的动画（渐隐动画）
            ObjectAnimator fadeAnim=ObjectAnimator.ofFloat(newBall,"alpha",1f,0f);
            //设置动画持续时间
            fadeAnim.setDuration(250);
            //为fadeAnim动画添加监听器
            fadeAnim.addListener(new AnimatorListenerAdapter() {
                //当动画结束时
                @Override
                public void onAnimationCancel(Animator animation) {
                    //动画结束时将动画关联的ShapeHolder删除
                    balls.remove(((ObjectAnimator)animation).getTarget());
                }
            });
            //再次定义一个AnimatorSet来组合动画
            AnimatorSet animatorSet = new AnimatorSet();
            //指定在fadeAnim之前先播放bouncer动画
            animatorSet.play(bouncer).before(fadeAnim);
            //开始播放动画
            animatorSet.start();
            return true;
        }
        private ShapeHolder addBall(float x,float y){
            //创建一个椭圆
            OvalShape circle = new OvalShape();
            //设置椭圆的宽高
            circle.resize(BALL_SIZE,BALL_SIZE);
            //将椭圆包装成Drawable对象
            ShapeDrawable drawable = new ShapeDrawable(circle);
            //创建一个ShapeHolder对象
            ShapeHolder shapeHolder = new ShapeHolder(drawable);
            //设置ShapeHolder的x、y坐标
            shapeHolder.setX(x-BALL_SIZE/2);
            shapeHolder.setY(y-BALL_SIZE/2);
            int red = (int) (Math.random()*255);
            int green = (int) (Math.random()*255);
            int blue = (int) (Math.random()*255);
            //将三个随机数组合成ARGB颜色
            int color = -0x1000000|(red/4<<16)|(green/4<<8)|blue;
            //获取drawable上关联的画笔
            Paint paint = drawable.getPaint();
            int darkColor = (-0x1000000|(red/4<<15)|(green/4<<8)|blue/4);
            //创建圆形渐变
            RadialGradient gradient = new RadialGradient(37.2f,12.5f,BALL_SIZE,color,darkColor, Shader.TileMode.CLAMP);
            paint.setShader(gradient);
            //为shapeHolder设置paint画笔
            shapeHolder.setPaint(paint);
            balls.add(shapeHolder);
            return shapeHolder;
        }

        @Override
        protected void onDraw(Canvas canvas) {
            //遍历balls集合中的每个ShapeHolder对象
            for (ShapeHolder shapeHolder:balls){
                //保存canvas的当前坐标系统
                canvas.save();
                //坐标变换：将画布坐标系统平移到shapeHolder的x,y坐标处
                canvas.translate(shapeHolder.getX(),shapeHolder.getY());
                //将shapeHolder持有的圆形绘制在canvas上
                shapeHolder.getShape().draw(canvas);
                //恢复Canvas坐标系统
                canvas.restore();
            }
        }
    }
}

package com.example.crazyit;

import android.graphics.Paint;
import android.graphics.RadialGradient;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.Shape;

public class ShapeHolder {
    private float x=0,y=0;
    private ShapeDrawable shape;
    private int color;
    private RadialGradient gradient;
    private float alpha=1f;
    private Paint paint;

    public ShapeHolder(ShapeDrawable shape) {
        this.shape = shape;
    }

    public float getX() {
        return x;
    }

    public void setX(float x) {
        this.x = x;
    }

    public float getY() {
        return y;
    }

    public void setY(float y) {
        this.y = y;
    }

    public ShapeDrawable getShape() {
        return shape;
    }

    public void setShape(ShapeDrawable shape) {
        this.shape = shape;
    }

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public RadialGradient getGradient() {
        return gradient;
    }

    public void setGradient(RadialGradient gradient) {
        this.gradient = gradient;
    }

    public float getAlpha() {
        return alpha;
    }

    public void setAlpha(float alpha) {
        this.alpha = alpha;
    }

    public Paint getPaint() {
        return paint;
    }

    public void setPaint(Paint paint) {
        this.paint = paint;
    }
    public float getWidth(){
        return shape.getShape().getWidth();
    }
    public void setWidth(float width){
        Shape s = shape.getShape();
        s.resize(width,s.getWidth());
    }
    public float getHeight(){
        return shape.getShape().getHeight();
    }
    public void setHeight(float width){
        Shape s = shape.getShape();
        s.resize(width,s.getHeight());
    }
}

示波器

package com.example.shiboqi;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Button;

import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends AppCompatActivity {
    private SurfaceHolder holder;
    private Paint paint = new Paint();
    int HEIGHT = 400;
    int screenWidth;
    int X_OFFSET = 5;
    int cx = X_OFFSET;
    //实际的Y轴的位置
    int centerY = HEIGHT/2;
    Timer timer = new Timer();
    TimerTask task;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DisplayMetrics metrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(metrics);
        screenWidth=metrics.widthPixels;
        SurfaceView surfaceView = findViewById(R.id.show);
        //初始化SurfaceHolder对象
        holder = surfaceView.getHolder();
        paint.setColor(Color.GREEN);
        paint.setStrokeWidth(getResources().getDimension(R.dimen.stroke_width));
        Button sin = findViewById(R.id.sin);
        Button cos = findViewById(R.id.cos);
        View.OnClickListener listener=source->{
            drawBack(holder);
            cx=X_OFFSET;
            if(task!=null){
                task.cancel();
            }
            task=new TimerTask() {
                @Override
                public void run() {
                    paint.setColor(Color.GREEN);
                    int cy = source.getId() == R.id.sin?centerY-(int) (100*Math.sin((cx-5)*2*Math.PI/150)):centerY-(int) (100*Math.cos((cx-5)*2*Math.PI/150));
                    Canvas canvas = holder.lockCanvas(new Rect(cx,cy,cx+(int) paint.getStrokeWidth(),cy+(int) paint.getStrokeWidth()));
                    canvas.drawPoint(cx,cy,paint);
                    cx+=2;
                    if(cx>screenWidth){
                        task.cancel();
                        task=null;
                    }
                    holder.unlockCanvasAndPost(canvas);
                }
            };
            timer.schedule(task,0,10);
        };
        sin.setOnClickListener(listener);
        cos.setOnClickListener(listener);
        holder.addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(@NonNull SurfaceHolder surfaceHolder) {

            }

            @Override
            public void surfaceChanged(@NonNull SurfaceHolder surfaceHolder, int i, int i1, int i2) {
                drawBack(holder);
            }

            @Override
            public void surfaceDestroyed(@NonNull SurfaceHolder surfaceHolder) {
                timer.cancel();
            }
        });
    }
    private void drawBack(SurfaceHolder holder){
        Canvas canvas = holder.lockCanvas();
        //绘制白色背景
        canvas.drawColor(Color.WHITE);
        paint.setColor(Color.BLACK);
        //绘制坐标轴
        canvas.drawLine(X_OFFSET,centerY,screenWidth,centerY,paint);
        canvas.drawLine(X_OFFSET,40f,X_OFFSET,HEIGHT,paint);
        holder.unlockCanvasAndPost(canvas);
        holder.lockCanvas(new Rect(0,0,0,0));
        holder.unlockCanvasAndPost(canvas);
    }
}