精华内容
下载资源
问答
  • 本文通过实例代码给大家讲解了Android 在viewPager中双指缩放图片双击缩放图片单指拖拽图片的实现思路及解决方案,需要的朋友参考下吧
  • 核心代码使用view的缩放API即可 setScaleX(scale); setScaleY(scale); 在看下自定义可缩放的view package cn.xiayiye5.xiayiye5library.view; import android.content.Context; import android.util....

    老套路先上图

    核心代码使用view的缩放API即可

    setScaleX(scale);
    setScaleY(scale);

    在看下自定义可缩放的view

    package cn.xiayiye5.xiayiye5library.view;
    
    import android.content.Context;
    import android.util.AttributeSet;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    import android.widget.RelativeLayout;
    
    /**
     * @author : xiayiye5
     * @date : 2021/3/26 15:37
     * 类描述 : 缩放ViewGroup
     */
    public class ScaleLayout extends RelativeLayout implements View.OnTouchListener {
        private boolean isCanTouch = false;
        /**
         * 当前触摸的点数
         */
        private int pointNum = 0;
        //最大的缩放比例
        public static final float SCALE_MAX = 8.0f;
        private static final float SCALE_MIN = 1.0f;
    
        private double oldDist = 0;
        private double moveDist = 0;
        /**
         * 针对控件的坐标系,即控件左上角为原点
         */
        private double moveX = 0;
        private double moveY = 0;
    
        private double downX = 0;
        private double downY = 0;
        // 针对屏幕的坐标系,即屏幕左上角为原点
        private double moveRawX = 0;
        private double moveRawY = 0;
    
        public ScaleLayout(Context context) {
            this(context, null);
        }
    
        public ScaleLayout(Context context, AttributeSet attrs) {
            this(context, attrs, 0);
        }
    
        public ScaleLayout(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
            setOnTouchListener(this);
            init();
        }
    
        private void init() {
            setIsCanTouch(true);
        }
    
        public void setIsCanTouch(boolean canTouch) {
            isCanTouch = canTouch;
        }
    
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if (!isCanTouch) {
                return false;
            }
            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN:
                    pointNum = 1;
                    downX = event.getX();
                    downY = event.getY();
                    break;
                case MotionEvent.ACTION_UP:
                    pointNum = 0;
                    downX = 0;
                    downY = 0;
                    break;
                case MotionEvent.ACTION_MOVE:
                    if (pointNum == 1) {
                        //只有一个手指的时候才有移动的操作
                        float lessX = (float) (downX - event.getX());
                        float lessY = (float) (downY - event.getY());
                        moveX = event.getX();
                        moveY = event.getY();
                        moveRawX = event.getRawX();
                        moveRawY = event.getRawY();
                        setSelfPivot(lessX, lessY);
                        //setPivot(getPivotX() + lessX, getPivotY() + lessY);
                    } else if (pointNum == 2) {
                        //只有2个手指的时候才有放大缩小的操作
                        moveDist = spacing(event);
                        double space = moveDist - oldDist;
                        float scale = (float) (getScaleX() + space / getWidth());
                        if (scale > SCALE_MIN && scale < SCALE_MAX) {
                            setScale(scale);
                        } else if (scale < SCALE_MIN) {
                            setScale(SCALE_MIN);
                        }
                    }
                    break;
                case MotionEvent.ACTION_POINTER_DOWN:
                    //两点按下时的距离
                    oldDist = spacing(event);
                    pointNum += 1;
                    break;
                case MotionEvent.ACTION_POINTER_UP:
                    pointNum -= 1;
                    break;
                default:
                    break;
            }
            return true;
        }
    
        /**
         * 触摸使用的移动事件
         *
         * @param lessX x坐标
         * @param lessY y坐标
         */
        private void setSelfPivot(float lessX, float lessY) {
            float setPivotX = 0;
            float setPivotY = 0;
            setPivotX = getPivotX() + lessX;
            setPivotY = getPivotY() + lessY;
            Log.e("lawwingLog", "setPivotX:" + setPivotX + "  setPivotY:" + setPivotY
                    + "  getWidth:" + getWidth() + "  getHeight:" + getHeight());
            if (setPivotX < 0 && setPivotY < 0) {
                setPivotX = 0;
                setPivotY = 0;
            } else if (setPivotX > 0 && setPivotY < 0) {
                setPivotY = 0;
                if (setPivotX > getWidth()) {
                    setPivotX = getWidth();
                }
            } else if (setPivotX < 0 && setPivotY > 0) {
                setPivotX = 0;
                if (setPivotY > getHeight()) {
                    setPivotY = getHeight();
                }
            } else {
                if (setPivotX > getWidth()) {
                    setPivotX = getWidth();
                }
                if (setPivotY > getHeight()) {
                    setPivotY = getHeight();
                }
            }
            setPivot(setPivotX, setPivotY);
        }
    
        /**
         * 计算两个点的距离
         *
         * @param event 事件
         * @return 返回数值
         */
        private double spacing(MotionEvent event) {
            if (event.getPointerCount() == 2) {
                float x = event.getX(0) - event.getX(1);
                float y = event.getY(0) - event.getY(1);
                return Math.sqrt(x * x + y * y);
            } else {
                return 0;
            }
        }
    
        /**
         * 平移画面,当画面的宽或高大于屏幕宽高时,调用此方法进行平移
         *
         * @param x 坐标x
         * @param y 坐标y
         */
        public void setPivot(float x, float y) {
            setPivotX(x);
            setPivotY(y);
        }
    
        /**
         * 设置放大缩小
         *
         * @param scale 缩放值
         */
        public void setScale(float scale) {
            setScaleX(scale);
            setScaleY(scale);
        }
    
        /**
         * 初始化比例,也就是原始比例
         */
        public void setInitScale() {
            setScaleX(1.0f);
            setScaleY(1.0f);
            setPivot(getWidth() / 2f, getHeight() / 2f);
        }
    }
    

    上面代码可使用于View,ImageView等相关控件

    在看下xml布局怎么用

     <cn.xiayiye5.xiayiye5library.view.ScaleLayout
            android:id="@+id/sl"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1">
    
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerInParent="true"
                android:text="测试view group双指缩放" />
        </cn.xiayiye5.xiayiye5library.view.ScaleLayout>

    再看下activity

    package cn.xiayiye5.xiayiye5library.activity;
    
    import cn.xiayiye5.xiayiye5library.R;
    import cn.xiayiye5.xiayiye5library.view.ScaleLayout;
    import cn.xiayiye5.xiayiye5library.view.ScaleView;
    
    /**
     * @author : xiayiye5
     * @date : 2021/3/26 15:35
     * 类描述 :展示可缩放的页面
     */
    public class ScaleActivity extends BaseActivity {
    
        private ScaleView sv;
        private ScaleLayout sl;
    
        @Override
        protected int getLayoutView() {
            return R.layout.activity_scale;
        }
    
        @Override
        protected void initId() {
            sv = findViewById(R.id.sv);
            sl = findViewById(R.id.sl);
        }
    
        @Override
        protected void loadData() {
            //设置布局可以缩放
            sv.setIsCanTouch(true);
            sl.setIsCanTouch(true);
        }
    }
    

    好了代码如上图

    在此感谢原博主:博主直达

    GitHub源码下载源码页查看下载

    展开全文
  • 微信小程序实现双指缩放图片功能

    千次阅读 2020-04-27 10:27:35
    本文分析怎么在微信小程序实现双指缩放图片的功能。 实现过程 1. 文件index.wxml和index.wxss代码如下,这一块比较简单,可自行查看,不做过多分析; <!--index.wxml--> <view class='wrapper'> &...

    前言

    本文分析怎么在微信小程序实现双指缩放图片的功能。

    实现过程

    1. 文件index.wxml和index.wxss代码如下,这一块比较简单,可自行查看,不做过多分析;

    <!--index.wxml-->
    <view class='wrapper'>
      <view class="container">
        <view class="title">双指缩放图片</view>
        <scroll-view class='images' scroll-y="true" scroll-x="true" bindtouchmove="touchmoveCallback" bindtouchstart="touchstartCallback">
          <image mode="aspectFit" src="../../images/big.jpg" style="width:{{scaleWidth }}px;height:{{scaleHeight}}px" bindload="imgload"></image>
          <!-- <image mode="aspectFit" src="../../images/small.jpg" style="width:{{scaleWidth }}px;height:{{scaleHeight}}px" bindload="imgload"></image> -->
        </scroll-view>
      </view>  
    </view>
    /**index.wxss**/
    .container {
        margin-top: 30rpx;
    }
    
    .container .title {
        margin-bottom: 20rpx;
        font-weight: bold;
    }

    2. 文件index.js存放所有功能的逻辑代码,主要思路是先计算触摸时双指的距离(distance),然后计算移动过程的双指距离并跟触摸时的距离的差值(distanceDiff)来计算缩放比例(newScale),最后用计算出的缩放比例来缩放图片(scaleWidth和scaleHeight);代码实现如下:

    1)新建公共方法calcDistance,用来计算双指的距离;

    2)新建方法imgload,当图片载入完毕时获取图片实际宽度(baseWidth)和高度(baseHeight)、用来计算的固定宽度(initWidth,原图宽度大于屏幕宽度则设置为屏幕宽度,反之则设置为原图宽度)和高度(initHeight,原图宽度大于屏幕宽度则设置为原图高度/倍数,反之则设置为原图高度)、图片缩放后的宽度(scaleWidth,初始化跟initWidth一致)和高度(scaleHeight,初始化跟initHeight一致);

    3)新建方法touchstartCallback,计算双指触摸时双指的距离distance;

    4)新建方法touchmoveCallback,计算手指移动时双指的距离distance,跟触摸距离相减得出差值distanceDiff;然后利用差值计算出缩放比例newScale,最后使用newScale缩放图片,从而实现缩放效果。

    //index.js
    Page({
      /**
       * 页面的初始数据
       */
      data: {
        distance: 0, // 手指移动的距离
        scale: 1, // 缩放比例
        baseWidth: '', // 图片实际宽度
        baseHeight: '', // 图片实际高度
        initWidth: '', // 图片默认显示宽度
        initHeight: '', // 图片默认显示高度
        scaleWidth: '', // 图片缩放后的宽度
        scaleHeight: '', // 图片缩放后的高度
      },
      /**
       * 监听图片加载成功时触发
       */
      imgload: function (e) {
        this.multiple = e.detail.width / this.width; // 计算原图和默认显示的倍数
        let height = this.multiple > 1 ? e.detail.height / this.multiple : e.detail.height; // 等比例计算出默认高度
        let width = this.multiple > 1 ? this.width : e.detail.width;
        this.setData({
          baseWidth: e.detail.width, // 获取图片实际宽度
          baseHeight: e.detail.height, // 获取图片实际高度
          initWidth: width,
          initHeight: height,
          scaleWidth: width,
          scaleHeight: height,
        })
      },
      /**
       * 双手指触发开始 计算开始触发两个手指坐标的距离
       */
      touchstartCallback: function (e) {
        // 单手指缩放开始,不做任何处理
        if (e.touches.length == 1) return;
        let distance = this.calcDistance(e.touches[0], e.touches[1]);
        this.setData({
          'distance': distance,
        })
      },
      /**
       * 双手指移动   计算两个手指坐标和距离
       */
      touchmoveCallback: function (e) {
        // 单手指缩放不做任何操作
        if (e.touches.length == 1) return;
        let distance = this.calcDistance(e.touches[0], e.touches[1]);
        // 计算移动的过程中实际移动了多少的距离
        let distanceDiff = distance - this.data.distance;
        let newScale = this.data.scale + 0.005 * distanceDiff;
        
        if (newScale >= this.multiple && this.multiple > 2) { // 原图比较大情况
          newScale = this.multiple;
        } else if (this.multiple < 2 && newScale >= 2) { // 原图较小情况
          newScale = 2; // 最大2倍
        };
        // 最小缩放到0.3
        if (newScale <= 0.3) {
          newScale = 0.3;
        };
    
        let scaleWidth = newScale * this.data.initWidth;
        let scaleHeight = newScale * this.data.initHeight;
        this.setData({
          distance: distance,
          scale: newScale,
          scaleWidth: scaleWidth,
          scaleHeight: scaleHeight,
          diff: distanceDiff
        });
      },
      /**
       * 生命周期函数--监听页面加载
       */
      onLoad: function (options) {
        // 获取屏幕宽度
        this.width = wx.getSystemInfoSync().windowWidth;
      },
      /**
       * 计算两个手指距离
       */
      calcDistance(pos0, pos1) {
        let xMove = pos1.clientX - pos0.clientX;
        let yMove = pos1.clientY - pos0.clientY;
        return (Math.sqrt(xMove * xMove + yMove * yMove));
      }
    })

    扫描公众号,了解更多实例分享:

    展开全文
  • AndroidLesson20170425 作业 20160613 双指缩放图片 实现摇一摇核心功能
  • 主要介绍了JS实现移动端双指缩放和旋转方法,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 小程序图片双指缩放

    千次阅读 2019-10-23 14:42:34
    文章目录需求小程序提供的图片缩放能力自己实现的符合业务的图片缩放能力演示 需求 小程序提供的图片缩放能力 自己实现的符合业务的图片缩放能力 演示 ...

    需求

    项目需要做一个互动视频,需要提供白板功能,白板可以播放ppt,但是做ppt的人没考虑到手机屏幕的小,ppt很多的内容就看不清,所以,就需要把投屏的ppt放大。这里就需要用到双指缩放的能力。

    小程序提供的图片缩放能力

    • 小程序 movable-area movable-view组件,这俩个组件提供了可移动区域能力,不仅仅图片可以在里面被缩放,移动,所有组件都可以,但是这个组件提供的缩放能力不能大于手机屏幕大小,这种功能就不符合需求。
    • 小程序有个图片预览的api wx.previewImage()接口,可提供完美的图片缩放能力,但是这种功能类似相册预览,调用后,会掉起原生组件,组断视频流的传输,所以这个接口也不符合需求。

    自己实现的符合业务的图片缩放能力

    经过多次尝试,最终最佳的解决方案就是,根据手势,自己实现图片缩放能力,这样,与项目兼容好,符合项目要求。接下来就是参考各种轮子,实现自己的轮子。

    代码示例

    1. 我们首先先建个组件名子 zoomImgByView

    2. zoomImgByView.json

    {  
    	"component": true,
    	"usingComponents": {}
    }
    

    3. zoomImgByView.wxss

    4. zoomImgByView.html

    <view style="width:{{view_width}}px;height:{{view_height}}px;overflow: hidden; position: relative;">
      <image
        id="mapImage"
        style="width:{{imgWidth}}px;height:{{imgHeight}}px;margin-top:{{marginTop}}px;margin-left:{{marginLeft}}px;"
        src="{{img_src}}"
        mode="aspectFit"
        catchload="_imgLoadEvent"
        catchtouchstart="_touchStartEvent"
        catchtouchmove="_touchMoveEvent"
        catchtouchend="_touchEndEvent"
        catchtouchcancel="_touchEndEvent" />
    </view>
    

    5. zoomImgByView.js

    var lastTouchPoint = { x: 0, y: 0 };
    var newDist = 0;
    var oldDist = 0;
    var app = getApp();
    Component({
      /**
       * 组件的属性列表
       */
      properties: {
        // 图片地址
        img_src: {
          type: String
        },
        // 可视区域的大小
        view_width: {
          type: String
        },
        view_height: {
          type: String
        },
      },
    
      /**
       * 组件的初始数据
       */
      data: {
        imgWidth:0,
        imgHeight:0,
        marginTop:0,
        marginLeft:0
      },
    
      /**
       * 组件的方法列表
       */
      methods: {
        /**
         * 图片加载完成方法
         */
        _imgLoadEvent: function (event) {
          this.setData({
            imgWidth: this.data.view_width,
            imgHeight: this.data.view_height,
            marginLeft: 0,
            marginTop: 0,
          })
        },
        /**
         * 触摸开始事件
         */
        _touchStartEvent: function () {
          lastTouchPoint = { x: 0, y: 0 }
          oldDist = 0
        },
        /**
         * 手指移动事件
         */
        _touchMoveEvent: function (e) {
          // 单指移动事件
          if (e.touches.length == 1) {
            if (lastTouchPoint.x == 0 && lastTouchPoint.y == 0) {
              lastTouchPoint.x = e.touches[0].clientX
              lastTouchPoint.y = e.touches[0].clientY
            } else {
              var xOffset = e.touches[0].clientX - lastTouchPoint.x
              var yOffset = e.touches[0].clientY - lastTouchPoint.y
              this.setData({
                marginTop: this.data.marginTop + yOffset,
                marginLeft: this.data.marginLeft + xOffset,
              })
              lastTouchPoint.x = e.touches[0].clientX
              lastTouchPoint.y = e.touches[0].clientY
            }
          }
          // 双指缩放事件
          if (e.touches.length == 2) {
            if (oldDist == 0) {
              oldDist = this._spacing(e);
            } else {
              newDist = this._spacing(e);
              if (newDist > oldDist + 1) {
                this._zoom(newDist / oldDist, e);
                oldDist = newDist;
              }
              if (newDist < oldDist - 1) {
                this._zoom(newDist / oldDist, e);
                oldDist = newDist;
              }
            }
          }
        },
        /**
         * 触摸事件结束
         */
        _touchEndEvent: function () {
          this._reboundAnimation();
        },
        /**
         * 计算x轴上的双指中心点比例
         */
        _calcXRatio: function (event) {
          var xRatio = ((event.touches[0].clientX + event.touches[1].clientX) / 2 - this.data.marginLeft) / this.data.imgWidth
          return xRatio
        },
        /**
         * 计算y轴上的双指中心点比例 注意是图片的中心点
         */
        _calcYRatio: function (event) {
          let max, min;
          if (app.globalData.systemInfo.screenHeight > app.globalData.systemInfo.screenWidth) {
            max = app.globalData.systemInfo.screenHeight;
            min = app.globalData.systemInfo.screenWidth;
          } else {
            min = app.globalData.systemInfo.screenHeight;
            max = app.globalData.systemInfo.screenWidth;
          }
          let top;
          if (app.globalData.systemInfo.deviceOrientation === 'portrait' ) {
            top = 0.75 * min + 35 + 42;
          } else {
            if (app.globalData.systemInfo.model.indexOf('iPad') > -1) {
              top = 0.03 * max;
            } else {
              top = (min - 0.421875 * max) / 2;
            }
          }
          var yRatio = ((event.touches[0].clientY + event.touches[1].clientY) / 2 - this.data.marginTop - top) / this.data.imgHeight
          return yRatio
        },
        /**
         * 双指缩放
         */
        _zoom: function (f, event) {
          var xRatio = this._calcXRatio(event)
          var yRatio = this._calcYRatio(event)
          if (this.data.imgWidth <= this.data.view_width && f < 1) {
            var ratio = this.data.view_width / this.data.imgWidth
            this.setData({
              imgWidth: this.data.imgWidth * ratio,
              imgHeight: this.data.imgHeight * ratio
            })
            return;
          }
          if (this.data.imgHeight <= this.data.view_height && f < 1) {
            var ratio = this.data.view_height / this.data.imgHeight
            this.setData({
              imgWidth: this.data.imgWidth * ratio,
              imgHeight: this.data.imgHeight * ratio
            })
            return;
          }
          this.setData({
            // 此处的ratio为双指中心点在图片的百分比
            marginLeft: this.data.marginLeft + xRatio * this.data.imgWidth * (1 - f),
            marginTop: this.data.marginTop + yRatio * this.data.imgHeight * (1 - f),
            imgWidth: this.data.imgWidth * f,
            imgHeight: this.data.imgHeight * f,
          })
        },
        /**
         * 计算两指间距
         */
        _spacing: function (event) {
          var x = event.touches[0].clientX - event.touches[1].clientX;
          var y = event.touches[0].clientY - event.touches[1].clientY;
          return Math.sqrt(x * x + y * y);
        },
        /**
         * 边界的回弹动画
         */
        _reboundAnimation: function () {
          if (this.data.marginTop > 0) {
            this.setData({
              marginTop: 0
            })
          }
          if (this.data.marginLeft > 0) {
            this.setData({
              marginLeft: 0
            })
          }
          if (this.data.marginLeft < 0 && (this.data.imgWidth - Math.abs(this.data.marginLeft)) < this.data.view_width) {
            this.setData({
              marginLeft: this.data.view_width - this.data.imgWidth
            })
          }
          if (this.data.marginTop < 0 && (this.data.imgHeight - Math.abs(this.data.marginTop)) < this.data.view_height) {
            this.setData({
              marginTop: this.data.view_height - this.data.imgHeight
            })
          }
        },
        // 强制图片宽高缩放为1
        initImgSize(size) {
          this.setData({
            imgWidth: size.x,
            imgHeight: size.y,
            marginLeft: 0,
            marginTop: 0,
          })
        }
      }
    })
    
    

    6. 使用

    // 传入图片大小 和连接即可
    <zoomImgByView id="zoomImg" class="whiteboard-img" img_src="{{showDocumentUrl}}" view_width="{{boardArea.x}}" view_height="{{boardArea.y}}"/>
    

    要点

    1. 确定双指缩放中心点,xRatio yRatio,需要注意的是图片的中心点,不是屏幕的中心点,所以点的距离是到图片的边距,不是到屏幕的边距。
    2. 我们是通过margin 和 中心点来确定缩放后的图片位置移动。所以上边的中心点至关重要。
    3. 代码只是符合自己的项目需求,可参考代码实现自己的轮子。

    演示

    在这里插入图片描述

    展开全文
  • selector:要缩放图片,bg:图片的背景容器 var touchScale = function(seletor, bg) { var startX, endX, scale, x1, x2, y1, y2, imgLeft, imgTop, imgWidth, imgHeight, one = false, $touch = $(seletor),...

    1.可通过修改图片的宽高来缩放图片
    2.可通过修改transform进行缩放图片,使用transform默认的作用中心是元素的中心点,需要通过transform-origin:0 0调整作用中心点
    3.不足:没有实现从手指触碰的位置为作用中心达到缩放效果

    代码如下 :

    一.js

    selector:要缩放的图片

    var touchScale = function(seletor) {
        // 参数one是为了区分屏幕上现在是一根手指还是两根手指,因为在滑动的时候两根手指先离开一根会触发一根手指移动图片位置这个方法
          var one = false, 
              $touch = $(seletor),
              imgLeft = parseInt($touch.css('left')),
              imgTop = parseInt($touch.css('top')),
              originalWidth = $touch.width(),
              originalHeight = $touch.height(),
              baseScale = parseFloat(originalWidth/originalHeight);
          var store = {
            scale: 1
          };
          function siteData(name) {
              imgLeft = parseInt(name.css('left'));
              imgTop = parseInt(name.css('top'));
          }
          // 获取坐标之间的距离
          function getDistance(start, stop) {
            return Math.hypot(stop.x - start.x, stop.y - start.y);
          }
          // $(seletor).parent().selector让我们可以选择类,不一定要指定id
          // $('#'+).on('touchstart touchmove touchend', function(event){
          $(document).on('touchstart touchmove touchend', $(seletor).parent().selector, function(event){
              var $me = $(seletor),
                  touch1 = event.originalEvent.targetTouches[0],  // 第一根手指touch事件
                  touch2 = event.originalEvent.targetTouches[1],  // 第二根手指touch事件
                  fingers = event.originalEvent.touches.length;   // 屏幕上手指数量
              //手指放到屏幕上的时候,还没有进行其他操作
              if (event.type == 'touchstart') {
                  // 阻止事件冒泡
                  event.preventDefault();
                  // 第一个触摸点的坐标
                  store.pageX = touch1.pageX;
                  store.pageY = touch1.pageY;
                  if (fingers == 2) {
                      store.pageX2 = touch2.pageX;
                      store.pageY2 = touch2.pageY;
                      store.moveable = true;
                      one = false;
                  }
                  else if (fingers == 1) {
                      one = true;
                  }
                  store.originScale = store.scale || 1;
              }
              //手指在屏幕上滑动
              else if (event.type == 'touchmove') {
                  event.preventDefault();
                  if (fingers == 2) {
                      if (!store.moveable) {
                          return;
                      }
                      // 双指移动
                      if (touch2) {
                        if(!store.pageX2) {
                          store.pageX2 = touch2.pageX;
                        }
                        if(!store.pageY2) {
                          store.pageY2 = touch2.pageY;
                        }
                      }else{return
                      }
                      // 双指缩放比例计算:originScale/scale=初始距离/后来距离,即:scale=originScale*(后来距离/初始距离)
                      var zoom = getDistance({
                          x: touch1.pageX,
                          y: touch1.pageY
                      }, {
                          x: touch2.pageX,
                          y: touch2.pageY
                      }) /
                      getDistance({
                          x: store.pageX,
                          y: store.pageY
                      }, {
                          x: store.pageX2,
                          y: store.pageY2
                      });
                      var newScale = store.originScale * zoom
                      // 最大缩放比例限制
                      if (newScale > 3) {
                          newScale = 3;
                      }
                      // 记住当前缩放值
                      store.scale = newScale
                      // 图片缩放效果
                      $me.css({
                          'left' : imgLeft,
                          'top' : imgTop,
                          // 1.通过修改宽高缩放图片
                          'width' : originalWidth*newScale,
                          'height' : (originalWidth*newScale)/baseScale,
                          // 2.通过修改transform缩放图片,transform-origin作用中心点
                          // 'transform': 'scale('+newScale+')',
                          // 'transform-origin': '0 0' 
                      });
                  }else if (fingers == 1) {
                      if (one) {
                          $me.css({
                              'left' : imgLeft + (touch1.pageX - store.pageX),
                              'top' : imgTop + (touch1.pageY - store.page)
                          });
                      }
                  }
              }
              //手指移开屏幕
              else if (event.type == 'touchend') {
                 store.moveable = false;
                 delete store.pageX2;
                 delete store.pageY2;
              }
          });
      };
      touchScale('#map')
    
    二.html
    <div class="mapImgBox">
    	<div id="map"></div>
    </div>
    
    三.css
    .mapImgBox{
    	width: 100%;
    	height: 65vh;
    	border-radius: 10px;
    	background-color: #7F7F7F;
      	overflow: auto;
    }
    #map{
    	width: 40%;
    	height: 100%;
    	margin: 0 auto;
    	background-image: url(../images/map.png);
    	background-repeat:no-repeat;
    	background-size: 90% 90%;
    	background-position: center;
    }
    

    文章参考:
    通过transform缩放
    通过width、height缩放

    展开全文
  • Android图片双指缩放,单指移动实现

    千次阅读 2018-06-08 15:43:22
    Android 实现,图片双指缩放,单指移动。通过自定义ImageView控件实现。ZoomDragImageView.java代码如下: public class SwZoomDragImageView extends ImageView implements View.OnTouchListener{ private static...
  • uni-app双指缩放图片大小

    千次阅读 2020-04-01 18:02:32
    图片设置双指放大缩小这个功能相对来说比较简单的,是用于官方文档的路径(组件->视图容器->movable-area),movable-area可以做双指放大缩小,并且放大的同时可以左右移动图片(页面) 用HBuilder X编辑器创建个...
  • UI双指缩放代码

    2020-07-29 11:12:05
    } } void FingerControl() //两个手指放大图片的方法 { if (Input.touchCount > 1 && (Input. GetTouch(0).phase == TouchPhase.Moved || Input.GetTouch(1).phase == TouchPhase.Moved)) { DistanceNow = Vector2....
  • 前一段时间产品经理就着图片裁剪的功能找到我:小哥,这个图片裁剪怎么在华为手机上是一个圆形,而小米手机上是一个正方形啊;我说:是啊,咱用的是系统自带的图片裁剪功能,不同厂商对Google的裁剪框做了定制化,...
  • 记录一下最近项目中用到的点击图片出现一个遮罩层,同时放大图片显示,移动端可双指缩放图片并单指拖拽图片.再次点击遮罩层透明区域,遮罩层消失 一.实现效果: 页面原图展示: 点击图片后: 二.代码实现: 1.html部分: ...
  • 注意:如果对含有子类的viewGroup设置,子类的大小可能不变,因为缩放的效果代码用的是view.layout(),只是改变了当前设置触摸监听view的大小,里面子类的大小是没有变的; 如果想子类一起改变,需要用到View.set...
  • 通过双指移动的距离与初始距离的关系判断缩放 规定阈值,最大与最小缩放 开始操作 上传图片 由于上传的图片需要放大与缩小,所以我们首先要在style动态绑定width 和height,其次要设置overflow为scroll。 然后开...
  • 双指缩放图片,并且带拖动回弹居中的效果 这里是使用 Matrix +Bitmap 来进行图片缩放的。 首先,要对布局文件中的 ImageView 设置: android:scaleType="matrix" 在 MainActivity....
  • 在支持双指缩放的时候,首先要了解一下Android支持缩放的工具类ScaleGestureDetector,这个缩放是根据这个工具类来实现的。ScaleGestureDetector是用于处理缩放的工具类,用法与GestureDetector类似,都是通过...
  • 一般情况下我们用的比较多的手势就是单指拖拽、双指缩放图片这样的简单手势,下面的代码是ImageView实现单指和双指这两种手势的代码,没有用到GestureDetector,而是仅仅对onTouch事件进行处理: ...
  • 手游中经常会用到双指缩放的操作。双指缩放的逻辑很简单,只需要根据双指当前距离和双指刚按下时记录的距离进行比例缩放就可以了。 缩放位置不变稍微麻烦点,但是理解了思路就好做了,其实就是让两指中点与目标原点...
  • Laya引擎下实现双指缩放 首先要知道如何识别双指操作 //注册舞台鼠标滑动事件 Laya.stage.on(Laya.Event.MOUSE_MOVE, this, this.OnMouseMove); private OnMouseMove(p){ console.log(p)//可以打印看看这个p里边...
  • 一般情况下我们用的比较多的手势就是单指拖拽、双指缩放图片这样的简单手势,下面的代码是ImageView实现单指和双指这两种手势的代码,没有用到GestureDetector,而是仅仅对onTouch事件进行处理: 注:ImageView 中...
  • 双指放大和缩放图片

    千次阅读 2019-06-26 21:56:54
    <script src="js/pinchzoom.js"></script>//引入这个插件 ...//js代码处理 $('.BigImg').each(function () { new RTP.PinchZoom($(this), {}); }); //pinchzoom.js /* Copyright (c...
  • movable-area是微信小程序的新组件,可以用来移动视图区域movable-view。这篇文章主要介绍了微信小程序movable view移动图片和双指缩放实例代码,需要的朋友可以参考下
  •   之前需要在小程序里实现对一张图片的单指拖动双指缩放效果。试了网上很多别人的代码已经微信自己的一些控件,基本双指缩放的时候都是会以左上角为原点进行缩放,而微信自己的那些控件使用的时候又比较有局限性...
  • 这是微信小程序代码图片手指缩放功能,不过问题就是不能够固定后移动图片
  • 我们就把这个问题叫做图片查看器吧,它的主要功能有: ...2、双指缩放图片。 3、单指拖拽图片。 为此这个图片查看器需要考虑以下的技术点: 一、双击缩放图片: 1、如果图片高度比屏幕的高度小得...
  • 对于手机上图片缩放通常有两种: 介绍第一种情况的插件,pinchzoom.js,用法很简单,只需要修改img的路径,在引用pinchzoom.js以及你平时用的jquery就可以。 pinchzoom.js下载链接 链接: ...
  • 实现双指缩放图片的效果以及注意事项。
  • Creator双指缩放和拖动无黑边 源码在文末 效果 因为PC端不可以双指操作,所以这是现在手机上录屏再到电脑录GIF的结果 节点结构 遮挡节点 目标节点,也就是需要缩放和拖动的奥利给图片 创建一个脚本挂在canvas上 ...
  • 参考过的一篇文章:... html实例代码: 缩放图片需要放在class 为list 的div里面 <!doctype html> <html> <head> <meta http-equiv="Content-Type" co...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,875
精华内容 750
关键字:

双指缩放图片的代码