Android imageview图片缩放实现

最新推荐文章于 2024-05-12 03:12:30 发布
最新推荐文章于 2024-05-12 03:12:30 发布
阅读量2.8k 收藏 2
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LZN51/article/details/52717243
版权

一、Matrix详解

在Android中，如果你用Matrix进行过图像处理，那么一定知道Matrix这个类。Android中的Matrix是一个3 x 3的矩阵，其内容如下：

 

Matrix的对图像的处理可分为四类基本变换：

Translate           平移变换

Rotate                旋转变换

Scale                  缩放变换

Skew                  错切变换


 从字面上理解，矩阵中的MSCALE用于处理缩放变换，MSKEW用于处理错切变换，MTRANS用于处理平移变换，MPERSP用于处理透视变换。实际中当然不能完全按照字面上的说法去理解Matrix。同时，在Android的文档中，未见到用Matrix进行透视变换的相关说明，所以本文也不讨论这方面的问题。

 

针对每种变换，Android提供了pre、set和post三种操作方式。其中

set用于设置Matrix中的值。

pre是先乘，因为矩阵的乘法不满足交换律，因此先乘、后乘必须要严格区分。先乘相当于矩阵运算中的右乘。

post是后乘，因为矩阵的乘法不满足交换律，因此先乘、后乘必须要严格区分。后乘相当于矩阵运算中的左乘。

 

除平移变换(Translate)外，旋转变换(Rotate)、缩放变换(Scale)和错切变换(Skew)都可以围绕一个中心点来进行，如果不指定，在默认情况下是围绕(0, 0)来进行相应的变换的。


二、如何获取ImageView中图片的四个坐标

要获取图片的四角坐标，我们需要结合image的Matrix和边界Rect来处理

// 获取image边界矩形
Rect rect = imageView.getDrawable().getBounds();
// 获取图片的Matrix
mMatrix.set(imageView.getImageMatrix());
// 将Matrix中9个参数赋值到values 
float[] values = new float[9];
mMatrix.getValues(values);

之后我们可以根据上述信息来获取四角坐标 

//计算图片四角坐标
float leftTopX = values[Matrix.MTRANS_X];
float leftTopY = values[Matrix.MTRANS_Y];
float leftBottomX = values[Matrix.MTRANS_X];
float leftBottomY = values[Matrix.MTRANS_Y] + rect.height() * values[Matrix.MSCALE_Y];
float rightTopX = values[Matrix.MTRANS_X] + rect.width() * values[Matrix.MSCALE_X];
float rightTopY = values[Matrix.MTRANS_Y];
float rightBottomX = values[Matrix.MTRANS_X] + rect.width() * values[Matrix.MSCALE_X];
float rightBottomY = values[Matrix.MTRANS_Y] + rect.height() * values[Matrix.MSCALE_Y];

三、详细实现代码

1 布局文件

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@android:color/black"
    android:orientation="vertical">

    <com.jyy.lzn.supportdesigntest.widget.JImageView
        android:id="@+id/news_image_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_centerVertical="true"
        android:layout_centerHorizontal="true"
        android:scaleType="center"/>

</RelativeLayout>

2 图片显示组件

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.app.NavUtils;
import android.support.v4.view.ViewPager;
import android.util.Log;
import android.view.GestureDetector;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;

import com.jyy.lzn.supportdesigntest.R;
import com.jyy.lzn.supportdesigntest.news.bean.Node;
import com.jyy.lzn.supportdesigntest.util.DisplayUtil;
import com.squareup.picasso.Picasso;

/**
 * Created by HP on 2016/9/22.
 */
public class NewsImageViewerFragment extends Fragment {

    public static final String TAG = "NewsImageViewerFragment";

    private ViewPager mViewPager;

    private Node mNode;

    private ImageView imageView;

    // 两手指间距离
    private float mFingerDistance = 0;
    // 当前触摸模式
    private int mOperateMode = -1;
    private static final int MOVE = 0;
    private static final int ZOOM = 1;
    // 当前位置
    private PointF mCurrentPointF = new PointF();
    // 两手指间中间坐标点
    private PointF mMidPointF = new PointF();

    private Matrix mMatrix = new Matrix();
    private Matrix mCurrentMatrix = new Matrix();

    // 最大放大倍数
    private static final float MAX_SCALE = 3f;
    private float MIN_SCALE = 1f;

    private boolean mIsReachMinScale = true;
    private boolean mIsReachMaxScale = false;

    // 手指间最小间隔距离
    private static final float MIN_FINGER_DISTANCE = 10f;

    // 图片默认宽高
    private int requestedWidth;
    private int requestedHeight;

    private GestureDetector mGestureDetector = new GestureDetector(getContext(), new GestureDetector.SimpleOnGestureListener());

    public static Fragment newInstance(Node node) {
        NewsImageViewerFragment newsImageViewerFragment = new NewsImageViewerFragment();
        Bundle bundle = new Bundle();
        bundle.putSerializable(TAG, node);
        newsImageViewerFragment.setArguments(bundle);
        return newsImageViewerFragment;
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mNode = (Node) getArguments().getSerializable(TAG);
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_news_image_viewer, container, false);
        mViewPager = ((ViewPager) getActivity().findViewById(R.id.news_image_view_pager));
        mGestureDetector.setOnDoubleTapListener(mOnDoubleTapListener);
        // 加载图片
        imageView = (ImageView) view.findViewById(R.id.news_image_view);
        imageView.setOnTouchListener(onTouchListener);
        // 重置ImageView尺寸
        requestedWidth = DisplayUtil.windowWidth(getContext());
        requestedHeight = (int) (requestedWidth / mNode.getAspectRatio());
        Picasso.with(getActivity()).load(mNode.getValue()).config(Bitmap.Config.ARGB_8888).resize(requestedWidth, requestedHeight).placeholder(R.drawable.imageview_default_bg).tag(TAG).into(imageView);
        return view;
    }

    private View.OnTouchListener onTouchListener = new View.OnTouchListener() {
        @Override
        public boolean onTouch(View view, MotionEvent event) {
            imageView.setScaleType(ImageView.ScaleType.MATRIX);
            if (mGestureDetector.onTouchEvent(event)) {
                return true;
            }
            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                // 单点触摸动作
                case MotionEvent.ACTION_DOWN:
                    mOperateMode = MOVE;
                    // 记录当前位置坐标
                    mCurrentPointF.set(event.getX(), event.getY());
                    mCurrentMatrix.set(imageView.getImageMatrix());
                    break;
                // 触摸点移动动作
                case MotionEvent.ACTION_MOVE:
                    mViewPager.requestDisallowInterceptTouchEvent(true);
                    if (mOperateMode == MOVE) {
                        drag(event);
                    } else if (mOperateMode == ZOOM) {
                        float endFingerDistance = fingerDistance(event);
                        if (endFingerDistance > MIN_FINGER_DISTANCE) {
                            float scale = endFingerDistance / mFingerDistance;
                            zoom(scale);
                        }
                    }
                    break;
                // 多点触摸动作
                case MotionEvent.ACTION_POINTER_DOWN:
                    mOperateMode = ZOOM;
                    // 记录当前位置坐标
                    mFingerDistance = fingerDistance(event);
                    if (mFingerDistance > MIN_FINGER_DISTANCE) {
                        mCurrentPointF.set(event.getX(), event.getY());
                        mCurrentMatrix.set(imageView.getImageMatrix());
                        midFingerDistance(event);
                    } else {
                        mOperateMode = MOVE;
                    }
                    break;
                // 单点触摸离开动作
                case MotionEvent.ACTION_UP:
                    mOperateMode = -1;
                    break;
                // 多点离开动作
                case MotionEvent.ACTION_POINTER_UP:
                    mOperateMode = -1;
                    adjustPosition();
                    break;
            }
            return true;
        }
    };

    /**
     * 调整图片位置
     */
    private void adjustPosition() {
        if (mIsReachMinScale) {
            imageView.setScaleType(ImageView.ScaleType.CENTER);
        }

        int screenWidth = DisplayUtil.windowWidth(getContext());

        Rect rect = imageView.getDrawable().getBounds();
        mMatrix.set(imageView.getImageMatrix());
        float[] values = new float[9];
        mMatrix.getValues(values);

        float leftTopX = values[Matrix.MTRANS_X];
        float rightTopX = values[Matrix.MTRANS_X] + rect.width() * values[Matrix.MSCALE_X];

        if (leftTopX > 0) {
            values[Matrix.MTRANS_X] = 0f;
        } else if (rightTopX < screenWidth) {
            values[Matrix.MTRANS_X] = screenWidth - (rect.width() * values[Matrix.MSCALE_X]);
        }
        // 调整上下边界
        float dy = DisplayUtil.windowHeight(getContext()) - DisplayUtil.getSystemStatueBarHeight(getContext()) - rect.height() * values[Matrix.MSCALE_Y];
        values[Matrix.MTRANS_Y] = dy / 2;
        // 更新图片矩阵
        mMatrix.setValues(values);
        imageView.setImageMatrix(mMatrix);
    }

    /**
     * 处理图片拖动
     *
     * @param event
     */
    private void drag(MotionEvent event) {
        if (mIsReachMinScale) {
            mViewPager.requestDisallowInterceptTouchEvent(false);
            return;
        }

        boolean isFullScreen;

        int screenWidth = DisplayUtil.windowWidth(getContext());
        int screenHeight = DisplayUtil.windowHeight(getContext());

        float transX = event.getX() - mCurrentPointF.x;
        float transY = event.getY() - mCurrentPointF.y;

        Rect rect = imageView.getDrawable().getBounds();

        float[] intiValues = new float[9];
        mCurrentMatrix.getValues(intiValues);
        float height = rect.height() * intiValues[Matrix.MSCALE_Y];
        // 图片没有充满屏幕 所以y轴禁止拖动
        if (height < screenHeight) {
            isFullScreen = false;
            transY = 0;
        } else {
            isFullScreen = true;
        }

        mMatrix.set(mCurrentMatrix);
        mMatrix.postTranslate(transX, transY);

        float[] values = new float[9];
        mMatrix.getValues(values);
        //计算图片四角坐标
        float leftTopX = values[Matrix.MTRANS_X];
        float leftTopY = values[Matrix.MTRANS_Y];
        float leftBottomX = values[Matrix.MTRANS_X];
        float leftBottomY = values[Matrix.MTRANS_Y] + rect.height() * values[Matrix.MSCALE_Y];
        float rightTopX = values[Matrix.MTRANS_X] + rect.width() * values[Matrix.MSCALE_X];
        float rightTopY = values[Matrix.MTRANS_Y];
        float rightBottomX = values[Matrix.MTRANS_X] + rect.width() * values[Matrix.MSCALE_X];
        float rightBottomY = values[Matrix.MTRANS_Y] + rect.height() * values[Matrix.MSCALE_Y];

        if (isFullScreen) { // 图片充满屏幕处理
            // 左上角越界处理
            if (leftTopX > 0 && leftTopY > 0) {
                values[Matrix.MTRANS_X] = 0f;
                values[Matrix.MTRANS_Y] = 0f;
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (leftTopX > 0 && leftTopY < 0) {
                values[Matrix.MTRANS_X] = 0f;
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (leftTopX < 0 && leftTopY > 0) {
                values[Matrix.MTRANS_Y] = 0f;
            }
            // 左下角越界处理
            if (leftBottomX > 0 && leftBottomY < screenHeight) {
                values[Matrix.MTRANS_X] = 0f;
                values[Matrix.MTRANS_Y] = screenHeight - (rect.height() * values[Matrix.MSCALE_Y]);
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (leftBottomX > 0 && leftBottomY > screenHeight) {
                values[Matrix.MTRANS_X] = 0f;
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (leftBottomX < 0 && leftBottomX > screenHeight) {
                values[Matrix.MTRANS_Y] = screenHeight - (rect.height() * values[Matrix.MSCALE_Y]);
            }
            // 右上角越界处理
            if (rightTopX < screenWidth && rightTopY > 0) {
                values[Matrix.MTRANS_X] = screenWidth - (rect.width() * values[Matrix.MSCALE_X]);
                values[Matrix.MTRANS_Y] = 0;
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (rightTopX < screenWidth && rightTopY < 0) {
                values[Matrix.MTRANS_X] = screenWidth - (rect.width() * values[Matrix.MSCALE_X]);
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (rightTopX > screenWidth && rightTopY > 0) {
                values[Matrix.MTRANS_Y] = 0;
            }
            // 右下角越界处理
            if (rightBottomX < screenWidth && rightBottomY < screenHeight) {
                values[Matrix.MTRANS_X] = screenWidth - (rect.width() * values[Matrix.MSCALE_X]);
                values[Matrix.MTRANS_Y] = screenHeight - (rect.height() * values[Matrix.MSCALE_Y]);
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (rightBottomX < screenWidth && rightBottomY > screenHeight) {
                values[Matrix.MTRANS_X] = screenWidth - (rect.width() * values[Matrix.MSCALE_X]);
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (rightBottomX > screenWidth && rightBottomY < screenHeight) {
                values[Matrix.MTRANS_Y] = screenHeight - (rect.height() * values[Matrix.MSCALE_Y]);
            }
        } else { // 图片没有充满屏幕处理
            if (leftTopX > 0) {
                values[Matrix.MTRANS_X] = 0f;
                mViewPager.requestDisallowInterceptTouchEvent(false);
            } else if (rightBottomX < screenWidth) {
                values[Matrix.MTRANS_X] = screenWidth - (rect.width() * values[Matrix.MSCALE_X]);
                mViewPager.requestDisallowInterceptTouchEvent(false);
            }
        }
        mMatrix.setValues(values);
        imageView.setImageMatrix(mMatrix);
    }

    /**
     * 处理图片缩放
     *
     * @param scale
     */
    private void zoom(float scale) {
        if (mIsReachMaxScale && scale > 1 || mIsReachMinScale && scale < 1) {
            return;
        }
        mMatrix.set(mCurrentMatrix);
        mMatrix.postScale(scale, scale, DisplayUtil.windowWidth(getContext()) / 2, DisplayUtil.windowHeight(getContext()) / 2 - DisplayUtil.getSystemStatueBarHeight(getContext()) / 2);
        float[] values = new float[9];
        mMatrix.getValues(values);
        if (values[Matrix.MSCALE_X] >= MAX_SCALE) {
            mIsReachMinScale = false;
            mIsReachMaxScale = true;
            values[Matrix.MSCALE_X] = MAX_SCALE;
            values[Matrix.MSCALE_Y] = MAX_SCALE;
        } else if (values[Matrix.MSCALE_X] <= MIN_SCALE) {
            mIsReachMinScale = true;
            mIsReachMaxScale = false;
            values[Matrix.MSCALE_X] = MIN_SCALE;
            values[Matrix.MSCALE_Y] = MIN_SCALE;
        } else {
            mIsReachMinScale = false;
            mIsReachMaxScale = false;
        }
        mMatrix.setValues(values);
        imageView.setImageMatrix(mMatrix);
    }

    /**
     * 计算两指之间距离
     *
     * @param event
     * @return
     */
    private float fingerDistance(MotionEvent event) {
        try {
            float dx = event.getX(1) - event.getX(0);
            float dy = event.getY(1) - event.getX(0);
            return (float) Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 计算两指间中间点
     *
     * @param event
     */
    private void midFingerDistance(MotionEvent event) {
        try {
            float dx = event.getX(1) + event.getX(0);
            float dy = event.getY(1) + event.getX(0);
            mMidPointF.set(dx / 2, dy / 2);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
    }

    private GestureDetector.OnDoubleTapListener mOnDoubleTapListener = new GestureDetector.OnDoubleTapListener() {
        @Override
        public boolean onSingleTapConfirmed(MotionEvent motionEvent) {
            if (NavUtils.getParentActivityName(getActivity()) != null) {
                NavUtils.navigateUpFromSameTask(getActivity());
            }
            return true;
        }

        @Override
        public boolean onDoubleTap(MotionEvent motionEvent) {
            mMatrix.set(imageView.getImageMatrix());
            if (mIsReachMinScale) {
                mMatrix.postScale(MAX_SCALE, MAX_SCALE, DisplayUtil.windowWidth(getContext()) / 2, DisplayUtil.windowHeight(getContext()) / 2 - DisplayUtil.getSystemStatueBarHeight(getContext()) / 2);
                imageView.setImageMatrix(mMatrix);
                mIsReachMinScale = false;
                mIsReachMaxScale = true;
                float[] values = new float[9];
                mMatrix.getValues(values);
                Log.d(TAG, "y: " + values[Matrix.MTRANS_Y]);
            } else {
                mMatrix.postScale(MIN_SCALE, MIN_SCALE, DisplayUtil.windowWidth(getContext()) / 2, DisplayUtil.windowHeight(getContext()) / 2);
                imageView.setImageMatrix(mMatrix);
                imageView.setScaleType(ImageView.ScaleType.CENTER);
                mIsReachMinScale = true;
                mIsReachMaxScale = false;
            }
            return true;
        }

        @Override
        public boolean onDoubleTapEvent(MotionEvent motionEvent) {
            return true;
        }
    };
}


注意点：由于ImageView设置的宽高是match_parent，所以在处理出示图片居中问题时，可以先将scaleType设置为center，之后再进行图片处理的时候将scaleType动态的设置为matrix


四、参考资料

1 http://blog.csdn.net/flash129/article/details/8234599

2 http://www.cnblogs.com/linjzong/p/4211661.html

lznnnnnnn
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android ImageView实现图片切换
yinzheyihao 雪剑
08-13 5453
Android ImageView实现图片切换
Android ImageView移动和缩放
刘永祥的专栏
11-17 2442
要实现ImageView的缩放就要使用到我们大学里面学习的线代里面的矩阵（Matrix）,我们看一下源码就可以知道 public static final int MSCALE_X = 0; //!< use with getValues/setValues public static final int MSKEW_X = 1; //!< use with getValue
Android Matrix处理ImageView中图片缩放，平移
GUITK的专栏
10-14 9145
1，Matrix 原理简单介绍
Android实现imageView在屏幕中缩放
make_progress的博客
07-04 1409
1、要求 Android中实现图片的缩放，并且图片不能完全离开屏幕。（需求比较特殊） （1）初始化自适应屏幕的宽和高； （2）图片可以缩放，限制图片的最大和最小缩放值； （3）图片可以移动，但不能完全移动屏幕，即在屏幕中移动； （4）向下移动，图片距离顶部不能超过paddingScreenMin，向上移动，图片距离底部不能超过paddingScreenMin； （5）向左移动，如果图片放大的宽...
移动开发最新三分钟学会图片（ImageView）拖动和放大缩小，2024年最新快速学会
最新发布
2401_84132685的博客
05-12 631
答应大伙的备战金三银四，大厂面试真题来啦！这份资料我从春招开始，就会将各博客、论坛。网站上等优质的Android开发中高级面试题收集起来，然后全网寻找最优的解答方案。每一道面试题都是百分百的大厂面经真题+最优解答。包知识脉络 + 诸多细节。节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。《960全网最全Android开发笔记》《379页Android开发面试宝典》包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。
Android系统ImageView图像显示控件ScaleType属性的八种缩放规则
bluefire1126的博客
09-04 960
Android系统ImageView图像显示控件ScaleType属性的八种缩放规则
Android ImageView视图的七种图片缩放类型
路宇的博客
07-31 5192
前言ImageView默认图片居中显示，默认图片的缩放类型为scaleType属性为fitCenter。一、scaleType属性为fitCenter，默认就是这个属性。七、scaleType属性为centerInside。六、scaleType属性为centerCrop。三、scaleType属性为fitStart。四、scaleType属性为fitEnd。五、scaleType属性为center。二、scaleType属性为fitXY。......
一起Talk Android吧（第五百四十二回：ImageView的缩放）
talk_8的专栏
04-08 730
本章回中主要介绍了如何对ImageView显示的图片进行缩放，介绍了实现缩放的方法，并且通过文字结合代码的方式进行了介绍。
Android实现ImageView图片缩放和拖动
09-01
综上所述，Android实现ImageView图片缩放和拖动主要涉及自定义View，实现OnTouchListener，处理MotionEvent的各种动作，以及利用矩阵变换进行图片的移动和缩放。这个过程既考验了开发者对触摸事件的理解，也要求对...
android imageview 图片缩放
03-16
本文将深入探讨如何在Android中实现ImageView的图片缩放功能，同时结合异步加载和Activity的半透明效果，提升用户体验。 首先，我们要理解Android中ImageView的基本用法。ImageView可以设置为固定大小或根据图片...
Android 自定义imageview实现图片缩放实例详解
08-30
总结来说，实现Android自定义ImageView的图片缩放功能涉及了手势识别、视图变换、边界检查以及兼容性处理等多个方面。通过自定义ImageView类并结合`ScaleGestureDetector`，我们可以创建一个能够平滑、流畅地缩放...
Android UI之ImageView实现图片旋转和缩放
01-05
android:sacleType属性指定ImageVIew控件显示图片的方式，例如：center表示图像以不缩放的方式显示在ImageView控件的中心，如果设置为fitCenter，表示图像按照比例缩放至合适的位置，并在ImageView控件的中心。...
Android实现图片宽度100%ImageView宽度且高度按比例自动伸缩
weixin_30706691的博客
02-13 1076
在ListView中为了实现图片宽度100%适应ImageView容器宽度，让高度自动按比例伸缩功能，查了很多资料，搞了一下午都没找出个现成的办法，不过貌似有个结论了，就是： Android自身不能实现这样的效果，只有自己动手丰衣足食 ImageView 中有个 scaleType 属性，设置图片在 view 中的缩放方式，本来以为 fit_center 可以实现，结果很无语...
Android 保持ImageVIew大小不变，让图片按比例拉伸
Canok
08-14 5536
所以保持图片宽高比总体有两种思路：(只需修改xml布局文件） 一： 让图片缩放，来适应控件大小。通过修改图片的缩放方式以及配合背景图 二： 让控件大小自适应，保持和图片一样的宽高比，来适应图片。 不要混着用， 同时修改android:adjustViewBounds 和android:scaleType 简直凌乱......
android imageView 安卓图片控件的属性( scaleType缩放类型)
技术应让更广泛的人群流入到实际产品开发中才是正统
09-18 552
imageView通常位于文件目录下，设置图源资源来源可以通过视图xml文件中的src。
Android设置ImageView可以移动、旋转、缩放
Kawa103的博客
04-21 1038
设置scaleType模式可以使用矩阵。
Android单点触控技术，对图片进行平移，缩放，旋转操作
dawuafang
01-19 691
转载请注明本文出自xiaanming的博客（http://blog.csdn.net/xiaanming/article/details/42833893），请尊重他人的辛勤劳动成果，谢谢！ 相信大家使用多点对图片进行缩放，平移的操作很熟悉了，大部分大图的浏览都具有此功能，有些app还可以对图片进行旋转操作，QQ的大图浏览就可以对图片进行旋转操作，大家都知道对图片进行缩放，平移，旋转等操作可以使用...
Android 对图片的缩放，拖地，跟系统图库的效果一样
qq_44906554的博客
05-03 224
Android 对图片的缩放，拖地，跟系统图库的效果一样
6、Android图片的拖拽与缩放
zwcshy的专栏
06-21 395
Android图片的拖拽与缩放 2014年5月9日  我们在使用应用当中经常需要浏览图片，比如在微信当中，点击图片之后可以对图片进行缩放。 本博客介绍如何对图片进行拖拽和缩放，这首先要了解Android中的触摸机制了，在屏幕中有手指按下、手指抬起、手指移动还有多个手指触摸的动作。我们要实现对图片的拖拽和缩放就是要基于这些动作来进行逻辑处理。 图片的拖拽主要是计算手指开始的位
androidstudio图片居中_android imageview图片居中技巧应用
05-31
要使Android中的ImageView图片居中，可以使用以下技巧： 1. 使用android:scaleType属性将图片缩放并居中。可以使用以下值： - center：将图片居中，不缩放。 - centerCrop：将图片缩放到ImageView的大小，并居中。如果图片比ImageView的大小小，则会被拉伸以填充整个ImageView。 - centerInside：将图片缩放到ImageView的大小，但不会拉伸。如果图片比ImageView的大小小，则居中显示。 示例代码： ``` <ImageView android:layout_width="match_parent" android:layout_height="match_parent" android:src="@drawable/my_image" android:scaleType="centerInside" /> ``` 2. 使用android:layout_gravity属性将ImageView居中。可以使用以下值： - center：将ImageView水平和垂直居中。 - center_horizontal：将ImageView水平居中。 - center_vertical：将ImageView垂直居中。 示例代码： ``` <ImageView android:layout_width="match_parent" android:layout_height="match_parent" android:src="@drawable/my_image" android:layout_gravity="center" /> ``` 这些技巧可以单独或组合使用，以实现不同的效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值