精华内容
下载资源
问答
  • 图片压缩图片压缩图片压缩图片压缩图片压缩图片图片压缩压缩
  • 图片通过js代码压缩,通过base64压缩图片,修改图片质量或尺寸达到压缩图片体积
  • html5前端图片压缩上传

    热门讨论 2016-03-03 12:40:31
    利用html5 canvas处理图片,得到图片字节流,上传。前端canvas压缩,代码简洁亲测可用,参考博客 :https://blog.csdn.net/jialiuyang/article/details/50787636;
  • C#图片高效无损压缩 绝对有效

    热门讨论 2014-04-03 23:40:34
    C#图片无损压缩高效
  • js压缩图片到指定大小

    千次阅读 2019-09-02 14:23:23
    思路:利用canvas转blob的时候通过quality控制图片质量,达到压缩的目的。此方法有个缺点。只能对图片格式为jpeg或webp的图片有效。因此压缩的时候canvas.toBlob(callback, mimeType, quality)中的mimeType要设为'...

    需求:前端上传图片的时候通常需要提供指定大小以内的图片。比如不大于500KB。

    思路:利用canvas转blob的时候通过quality控制图片质量,达到压缩的目的。此方法有个缺点。只能对图片格式为jpeg或webp的图片有效。因此压缩的时候canvas.toBlob(callback, mimeType, quality)中的mimeType要设为'image/jpeg'。压缩完成可以自行转成想要的格式。这里最主要的是找到小于maxSize并且最接近maxSize的图片质量参数quality。

    效果图:用进度条模拟压缩的进度。支持同时上传多张图片同时压缩

     

     代码如下:

    import React from 'react';
    import PropTypes from 'prop-types';
    import styles from './upload.less';
    
    import compress from './compress';
    
    class Upload extends React.Component {
      constructor(props) {
        super(props);
        this.fileInput = React.createRef();
        this.state = {
          fileObjs: [], // item { originFile, compressBase64, compressFile }
        };
      }
    
      getFileUrl(file) {
        let url;
        const agent = navigator.userAgent;
        if (agent.indexOf('MSIE') >= 1) {
          url = file.value;
        } else if (agent.indexOf('Firefox') > 0 || agent.indexOf('Chrome') > 0) {
          url = window.URL.createObjectURL(file);
        }
        return url;
      }
    
      compressCallBack(file, fileObj, result) {
        const { fileObjs } = this.state;
        file.compressing = false; // 压缩完成
        fileObj.compressBase64 = result.compressBase64;
        fileObj.compressFile = result.compressFile;
        this.setState({ fileObjs: [...fileObjs] });
        if (fileObjs.length && fileObjs.every(fileObjItem => fileObjItem.compressBase64)) {
          console.log('全部压缩完成', fileObjs);
        }
      }
    
      onInputChange(e) {
        const { fileObjs } = this.state;
        Object.keys(e.target.files).forEach((key) => {
          const file = e.target.files[key];
    
          // 验证图片格式
          const type = file.name.split('.')[1];
          if (type !== 'png' && type !== 'jpg' && type !== 'jpeg') {
            console.warn('请上传png,jpg,jpeg格式的图片!');
            e.target.value = '';
            return;
          }
    
          file.url = this.getFileUrl(file);
          file.compressing = true; // 压缩状态,开始压缩
    
          const fileObj = { originFile: file, compressBase64: null, compressFile: null };
          fileObjs.push(fileObj);
    
          // 压缩图片的方法, maxSize单位为kb
          compress(file, 200).then((res) => {
            this.compressCallBack(file, fileObj, res);
          }, (err) => {
            // 压缩失败,则返回原图片的信息
            this.compressCallBack(file, fileObj, err);
          });
        });
    
        this.setState({ fileObjs: [...fileObjs] });
        e.target.value = '';
      }
    
      render() {
        const { fileObjs } = this.state;
        return (
          <div
            className={styles.uploadContainer}
          >
            <div className={styles.gridItem}>
              <div
                className={styles.inputContainer}
                onClick={() => {
                  this.fileInput.current.click();
                }}
              >
                <span className={styles.uploadIcon}>+</span>
                <input
                  className={styles.fileInput}
                  ref={this.fileInput}
                  type="file"
                  name="file"
                  multiple="multiple"
                  accept="image/*"
                  onChange={e => this.onInputChange(e)}
                />
              </div>
            </div>
            {
              fileObjs.map(fileObj => (
                <div className={styles.gridItem}>
                  <img
                    src={fileObj.compressBase64 ? fileObj.compressBase64 : fileObj.originFile.url}
                    className={fileObj.originFile.compressing && styles.filter}
                  />
                  {
                    fileObj.originFile.compressing ?
                      <div className={styles.progressContainer}>
                        <div className={styles.progress}>
                          <div className={styles.progressHighlight} />
                        </div>
                      </div> : ''
                  }
                </div>
              ))
            }
          </div>);
      }
    }
    
    Upload.propTypes = {
      dispatch: PropTypes.func.isRequired,
    };
    
    export default Upload;
    

    2.图片压缩主要代码compress.js

    
    // 将File(Blob)对象转变为一个dataURL字符串, 即base64格式
    const fileToDataURL = file => new Promise((resolve) => {
      const reader = new FileReader();
      reader.onloadend = e => resolve(e.target.result);
      reader.readAsDataURL(file);
    });
    
    // 将dataURL字符串转变为image对象,即base64转img对象
    const dataURLToImage = dataURL => new Promise((resolve) => {
      const img = new Image();
      img.onload = () => resolve(img);
      img.src = dataURL;
    });
    
    // 将一个canvas对象转变为一个File(Blob)对象
    const canvastoFile = (canvas, type, quality) => new Promise(resolve => canvas.toBlob(blob => resolve(blob), type, quality));
    
    const compress = (originfile, maxSize) => new Promise(async (resolve, reject) => {
      const originSize = originfile.size / 1024; // 单位为kb
      console.log('图片指定最大尺寸为', maxSize, '原始尺寸为:', originSize);
    
      // 将原图片转换成base64
      const base64 = await fileToDataURL(originfile);
    
      // 缩放图片需要的canvas
      const canvas = document.createElement('canvas');
      const context = canvas.getContext('2d');
    
      // 小于maxSize,则不需要压缩,直接返回
      if (originSize < maxSize) {
        resolve({ compressBase64: base64, compressFile: originfile });
        console.log(`图片小于指定大小:${maxSize}KB,不用压缩`);
        return;
      }
    
    
      const img = await dataURLToImage(base64);
    
      const scale = 1;
      const originWidth = img.width;
      const originHeight = img.height;
      const targetWidth = originWidth * scale;
      const targetHeight = originHeight * scale;
    
      canvas.width = targetWidth;
      canvas.height = targetHeight;
      context.clearRect(0, 0, targetWidth, targetHeight);
      context.drawImage(img, 0, 0, targetWidth, targetHeight);
    
      // 将Canvas对象转变为dataURL字符串,即压缩后图片的base64格式
      // const compressedBase64 = canvas.toDataURL('image/jpeg', 0.1);
      // 经过我的对比,通过scale控制图片的拉伸来压缩图片,能够压缩jpg,png等格式的图片
      // 通过canvastoFile方法传递quality来压缩图片,只能压缩jpeg类型的图片,png等格式不支持
      // scale的压缩效果没有canvastoFile好
      // 在压缩到指定大小时,通过scale压缩的图片比通过quality压缩的图片模糊的多
      // 压缩的思路,用二分法找最佳的压缩点
      // 这里为了规避浮点数计算的弊端,将quality转为整数再计算;
      // const preQuality = 100;
      const maxQualitySize = { quality: 100, size: Number.MAX_SAFE_INTEGER };
      const minQualitySize = { quality: 0, size: 0 };
      let quality = 100;
      let count = 0; // 压缩次数
      let compressFinish = false; // 压缩完成
      let invalidDesc = '';
      let compressBlob = null;
    
      // 二分法最多尝试8次即可覆盖全部可能
      while (!compressFinish && count < 12) {
        compressBlob = await canvastoFile(canvas, 'image/jpeg', quality / 100);
        const compressSize = compressBlob.size / 1024;
        count++;
        if (compressSize === maxSize) {
          console.log(`压缩完成,总共压缩了${count}次`);
          compressFinish = true;
          return;
        }
        if (compressSize > maxSize) {
          maxQualitySize.quality = quality;
          maxQualitySize.size = compressSize;
        }
        if (compressSize < maxSize) {
          minQualitySize.quality = quality;
          minQualitySize.size = compressSize;
        }
        console.log(`第${count}次压缩,压缩后大小${compressSize},quality参数:${quality}`);
    
        quality = Math.ceil((maxQualitySize.quality + minQualitySize.quality) / 2);
    
        if (maxQualitySize.quality - minQualitySize.quality < 2) {
          if (!minQualitySize.size && quality) {
            quality = minQualitySize.quality;
          } else if (!minQualitySize.size && !quality) {
            compressFinish = true;
            invalidDesc = '压缩失败,无法压缩到指定大小';
            console.log(`压缩完成,总共压缩了${count}次`);
          } else if (minQualitySize.size > maxSize) {
            compressFinish = true;
            invalidDesc = '压缩失败,无法压缩到指定大小';
            console.log(`压缩完成,总共压缩了${count}次`);
          } else {
            console.log(`压缩完成,总共压缩了${count}次`);
            compressFinish = true;
            quality = minQualitySize.quality;
          }
        }
      }
    
      if (invalidDesc) {
        // 压缩失败,则返回原始图片的信息
        console.log(`压缩失败,无法压缩到指定大小:${maxSize}KB`);
        reject({ msg: invalidDesc, compressBase64: base64, compressFile: originfile });
        return;
      }
    
      compressBlob = await canvastoFile(canvas, 'image/jpeg', quality / 100);
      const compressSize = compressBlob.size / 1024;
      console.log(`最后一次压缩(即第${count + 1}次),quality为:${quality},大小:${compressSize}`);
      const compressedBase64 = await fileToDataURL(compressBlob);
    
      const compressedFile = new File([compressBlob], originfile.name, { type: 'image/jpeg' });
    
      resolve({ compressFile: compressedFile, compressBase64: compressedBase64 });
    });
    
    
    export default compress;
    

    3.less

    .uploadContainer{
      display: grid;
      grid-template-columns: repeat(auto-fill,minmax(75px, 1fr));
      grid-row-gap: .10rem;
      grid-column-gap: .08rem;
      .gridItem{
        position: relative;
        width: 100%;
        height: 0;
        padding-top: 100%;
        .inputContainer{
          position: absolute;
          left: 0;
          top: 0;
          width: 100%;
          height: 100%;
          display: flex;
          align-items: center;
          justify-content: center;
          border-radius:8px;
          border:1px solid rgba(217,217,217,1);
          .fileInput{
            display: none;
          }
          .uploadIcon{
            font-size: 30px;
            color: lightgrey;
          }
        }
        img{
          position: absolute;
          left: 0;
          top: 0;
          width: 100%;
          height: 100%;
          border-radius:8px;
        }
        .delete{
          position: absolute;
          top: -9px;
          right: -9px;
          width: 18px;
          height: 18px;
          background: red;
          color: white;
          border-radius: 50%;
          display: flex;
          align-items: center;
          justify-content: center;
          font-size: 20px;
        }
        .filter{
          filter: blur(1px);
        }
        .progressContainer{
          position: absolute;
          width: 80%;
          left: 50%;
          top: 50%;
          transform: translate(-50%, -50%);
          font-size: 10px;
          .progress{
            width: 100%;
            height: 4px;
            border-radius: 3px;
            border: 1px solid rgba(0,0,0,0.1);
          }
          .progressHighlight{
            height: 100%;
            width: 100%;
            animation: progress 3s cubic-bezier(0.25,0.1,0.25,1) infinite;
            background: orange;
            border-radius: 3px;
          }
        }
    
      }
    }
    
    
    @keyframes progress
    {
      0%   {width: 0}
      to  {width: 100%}
    }
    

     

    展开全文
  • 主要介绍了vue中实现图片压缩 file文件的方法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • TIFF图片压缩工具

    2018-11-13 16:13:21
    支持对tiff格式图片进行压缩,也可将图片转换其他格式后进行压缩
  • Android中图片是以bitmap形式存在的,这篇文章主要介绍了Android实现图片压缩(bitmap的六种压缩方式),有兴趣的可以了解一下。
  • 前端压缩图片

    2016-06-27 09:16:02
    前端压缩图片
  • delphi压缩图片例子

    2013-08-01 18:25:55
    选择某个图片,把他压缩到指定大小,便于存储
  • java压缩图片文件大小

    热门讨论 2014-05-14 11:10:20
    java 开发压缩图片文件大小,2m-->200k 不是压缩宽高的
  • 前端JS实现图片压缩,直接浏览器打开后,选择要压缩的图片文件即可
  • 随着数码相机的普及,很多照片都是用数码相机拍摄出来的。但是数码相机拍摄出来的照片体积很大,不变在网络上传输, 因此要对图片进行处理。本实例就是对图片进行无损压缩,并且使相片的清晰度为最佳状态。
  • 在android开发中,经常遇到图片压缩问题,由此记录下以下压缩方法。 import java.io.File; import java.io.FileOutputStream; import java.io.IOException;import android.annotation.SuppressLint; import android....

    在android开发中,经常遇到图片压缩问题,由此记录下以下压缩方法。

    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import android.annotation.SuppressLint;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.Matrix;
    import android.media.ExifInterface;
    import android.text.TextUtils;
    import android.util.Log;
    
    public class ImageUtils {
    
            /**
             * 压缩图片到指定的位置
             * 
             * a,图片宽或者高均小于或等于1280时图片尺寸保持不变,但仍然经过图片压缩处理,得到小文件的同尺寸图片
             * b,宽或者高大于1280,但是图片宽度高度比小于或等于2,则将图片宽或者高取大的等比压缩至1280
             * c,宽或者高大于1280,但是图片宽高比大于2时,并且宽以及高均大于1280,则宽或者高取小的等比压缩至
             * d,宽或者高大于1280,但是图片宽高比大于2时,并且宽或者高其中一个小于1280,则压缩至同尺寸的小文件图片
             *
             * @param filePath 返回压缩后图片的路径
             * @return
             */
            @SuppressLint("NewApi")
            @SuppressWarnings("finally")
            public static String compressUpImage(String filePath) {
                if (TextUtils.isEmpty(filePath)) return null;
                //旋转角度
                int degree = readPictureDegree(filePath);
                BitmapFactory.Options opt = new BitmapFactory.Options();
                opt.inPurgeable = true;// 同时设置才会有效
                opt.inInputShareable = true;//。当系统内存不够时候图片自动被回收
                opt.inJustDecodeBounds = true;
                BitmapFactory.decodeFile(filePath, opt);
                opt.inSampleSize = calculateInSampleSize(opt, 1028, 1028);
                opt.inJustDecodeBounds = false;
                Bitmap cbitmap = BitmapFactory.decodeFile(filePath, opt);
                Log.i("==image==","压缩前的尺寸:  宽: " + opt.outWidth + " ----  高:" + opt.outHeight);
                Bitmap image = null;
                Bitmap upImage = null;
                int quality = 100;
                if (Math.abs(degree) > 0) {
                    try {
                        image = rotaingImage(degree, cbitmap);
                    } catch (Exception e) {
                        e.printStackTrace();
                        image = cbitmap;
                    }
                } else {
                    image = cbitmap;
                }
                if(image==null) return "";
                int width = image.getWidth();
                int height = image.getHeight();
                File tempFile = null;
                if (width <= 1028 && height <= 1028) {
                    upImage = image;
                    if(upImage!=null&&upImage.getByteCount()>102400) {
                        quality = 60;
                    }
                    Log.i("==image==","图片宽或者高均小于或等于1280时图片尺寸保持不变,但仍然经过图片压缩处理,得到小文件的同尺寸图片");
                } else if ((width > 1028 || height > 1028) && width / height <= 2) {
                    Log.i("==image==","宽或者高大于1280,但是图片宽度高度比小于或等于2,则将图片宽或者高取大的等比压缩至1280");
                    int newWidth = 1028;
                    int newHeight = 1028;
                    if (width <= height) {
                        newWidth = (int) ((width * 1028f) / height);
                    } else {
                        newHeight = (int) ((height * 1028f) / width);
                    }
                    upImage = Bitmap.createScaledBitmap(image, newWidth, newHeight, false);
                    if (image != null && !image.isRecycled()) {
                        image.recycle();
                    }
                    quality = 60;
                } else if (width > 1028 && height > 1028 && width / height > 2) {
                    Log.i("==image==","宽或者高大于1280,但是图片宽高比大于2时,并且宽以及高均大于1280,则宽或者高取小的等比压缩至1280");
                    int newWidth = 1028;
                    int newHeight = 1028;
                    if (width >= height) {
                        newWidth = (int) ((width * 1028f) / height);
                    } else {
                        newHeight = (int) ((height * 1028f) / width);
                    }
                    upImage = Bitmap.createScaledBitmap(image, newWidth, newHeight, false);
                    if (image != null && !image.isRecycled()) {
                        image.recycle();
                    }
                    quality = 60;
                } else if ((width > 1028 && height < 1028) || (width < 1028 && height > 1028) && width / height > 2) {
                    Log.i("==image==","宽或者高大于1280,但是图片宽高比大于2时,并且宽或者高其中一个小于1280,则压缩至同尺寸的小文件图片");
                    upImage = image;
                    quality = 60;
                } else {
                    upImage = image;
                    quality = 60;
                }
               Log.i("==image==","压缩后的尺寸:  宽:" + upImage.getWidth() + " ---  高: " + upImage.getHeight());
                FileOutputStream out = null;
                try {
                    //创建临时文件
                    tempFile = File.createTempFile("upImage", ".jpg");
                    out = new FileOutputStream(tempFile);
                    upImage.compress(Bitmap.CompressFormat.JPEG, quality, out);
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                } finally {
                    if (out != null) {
                        try {
                            out.flush();
                            out.close();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
    
                    if (tempFile == null) {
                        return null;
                    } else {
                        return tempFile.getAbsolutePath();
                    }
                }
            }
    
           /**
             * 读取图片属性:旋转的角度
             *
             * @param path 图片绝对路径
             * @return degree旋转的角度
             */
            public static int readPictureDegree(String path) {
                int degree = 0;
                try {
                    ExifInterface exifInterface = new ExifInterface(path);
                    int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
                    switch (orientation) {
                        case ExifInterface.ORIENTATION_ROTATE_90:
                            degree = 90;
                            break;
                        case ExifInterface.ORIENTATION_ROTATE_180:
                            degree = 180;
                            break;
                        case ExifInterface.ORIENTATION_ROTATE_270:
                            degree = 270;
                            break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return degree;
            }
    
          /**
           *计算图片的缩放值
           */
            public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
                final int height = options.outHeight;
                final int width = options.outWidth;
                int inSampleSize = 1;
    
                if (height > reqHeight || width > reqWidth) {
                    final int heightRatio = Math.round((float) height / (float) reqHeight);
                    final int widthRatio = Math.round((float) width / (float) reqWidth);
                    inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
                }
                return inSampleSize;
            }
    
    
           /*
            * 旋转图片
            * @param angle
            * @param bitmap
            * @return Bitmap
            */
            public static Bitmap rotaingImage(int angle, Bitmap bitmap) {
                //旋转图片 动作
                Matrix matrix = new Matrix();
                matrix.postRotate(angle);
               Log.i("==image==","angle=" + angle);
                // 创建新的图片
                Bitmap returnBm = null;
                try {
                    // 将原始图片按照旋转矩阵进行旋转,并得到新的图片
                    returnBm = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
                    if (returnBm == null) {
                        returnBm = bitmap;
                    }
                    if (bitmap != returnBm) {
                        bitmap.recycle();
                    }
                } catch (OutOfMemoryError e) {
                    e.printStackTrace();
                }
                return returnBm;
            }
    
    }
    
    展开全文
  • Java压缩图片util,可等比例宽高不失真压缩,也可直接指定压缩后的宽高,只能用炫酷来形容,感兴趣就下载看看吧
  • js图片压缩

    热门讨论 2013-07-24 10:34:49
    很好用的图片压缩,不会影响图片质量,好用,希望能帮到某些朋友
  • 目前一般手机的相机都能达到800万像素,像我的Galaxy Nexus才500万像素,拍摄的照片也有1.5M左右。这么大的照片上传到服务器,不仅浪费流量,同时还... 此demo 解决了Android压缩图片到100K以下并保持不失真的高效方法
  • Android图片无损压缩

    2016-04-19 09:37:36
    Android中进行图片无损压缩,基于JNI进行的图片压缩,调用底层C语言实现,效率很高,压缩效率10倍,无损!!!资源下载直接按照注释进行使用,或者关注个人博客有详细介绍,如果接入有不懂的可以联系我,关键是...
  • flutter压缩图片上传

    千次阅读 2020-11-29 23:26:09
    通过一些资料搜索,luban压缩是直接通过dart进行压缩的,在针对一些大图片,动不动就12-20m的图片,在部分旧手机的会直接出现闪退的情况。 当然,上面说得可能也不一定正确,下面我自己使用的是pub上比较popular的...

    前言:

    在android原生中比较常用的是luban压缩,当然,flutter版本也有luban压缩,
    通过一些资料搜索,luban压缩是直接通过dart进行压缩的,在针对一些大图片,动不动就12-20m的图片,在部分旧手机的会直接出现闪退的情况。

    当然,上面说得可能也不一定正确,下面我自己使用的是pub上比较popular的插件:flutter_image_compress: ^0.7.0

    使用方式:

    1. pubspec.yaml 添加依赖,如下:
      2.

    2. 使用命令:pub packages get

    3. 在上传的地方使用代码:

        Utils.showLoading(context, text: '正在压缩上传中,请耐心等待....');
        for (File item in assets) {
          final Directory _temp = await getTemporaryDirectory();
          final String _path = _temp.path;
          var path = item.path;
          var name = path.substring(path.lastIndexOf("/") + 1, path.length);
          FlutterImageCompress.compressAndGetFile(
            path, '$_path/img_$name.jpg',
            quality: 88,
            // format: format
          ).then((value) {
            uploads.add(value);
            upload(value);
          });
        }
    

    更多压缩方式如下:

      // 1. compress file and get Uint8List
      Future<Uint8List> testCompressFile(File file) async {
        var result = await FlutterImageCompress.compressWithFile(
          file.absolute.path,
          minWidth: 2300,
          minHeight: 1500,
          quality: 94,
          rotate: 90,
        );
        print(file.lengthSync());
        print(result.length);
        return result;
      }
    
      // 2. compress file and get file.
      Future<File> testCompressAndGetFile(File file, String targetPath) async {
        var result = await FlutterImageCompress.compressAndGetFile(
            file.absolute.path, targetPath,
            quality: 88,
            rotate: 180,
          );
    
        print(file.lengthSync());
        print(result.lengthSync());
    
        return result;
      }
    
      // 3. compress asset and get Uint8List.
      Future<Uint8List> testCompressAsset(String assetName) async {
        var list = await FlutterImageCompress.compressAssetImage(
          assetName,
          minHeight: 1920,
          minWidth: 1080,
          quality: 96,
          rotate: 180,
        );
    
        return list;
      }
    
      // 4. compress Uint8List and get another Uint8List.
      Future<Uint8List> testComporessList(Uint8List list) async {
        var result = await FlutterImageCompress.compressWithList(
          list,
          minHeight: 1920,
          minWidth: 1080,
          quality: 96,
          rotate: 135,
        );
        print(list.length);
        print(result.length);
        return result;
      }
    

    更多:

    如何写一个自己的小程序并上线

    Github搭建个人博客(2019最新版,亲测)

    关注下面公众号 ,在微信后台回复「领取资源」,获取IT资源200G干货大全。

    在微信后台回复「130个小程序」,即可免费领取享有导入就能跑的微信小程序
    在这里插入图片描述

    qq加油小程序
    徐代龙的技术博客

    展开全文
  • js压缩图片

    千次阅读 2018-10-17 17:37:00
    后台处理图片的话比较方便,但是由于可以多张图片上传,文件太大的话会影响传输速度,所以选择前台处理咯 参考了一些网友的分享,总结了一下,以下代码可以直接拿来用 function fileResizetoFile(file,quality,fn){...
    后台处理图片的话比较方便,但是由于可以多张图片上传,文件太大的话会影响传输速度,所以选择前台处理咯
    参考了一些网友的分享,总结了一下,以下代码可以直接拿来用

    关键代码:

    	function fileResizetoFile(file,quality,fn){
    	  filetoDataURL (file,function(dataurl){
    		dataURLtoImage(dataurl,function(image){
    		  canvasResizetoFile(imagetoCanvas(image),quality,fn);
    		})
    	  })
    	}
    	function filetoDataURL(file,fn){
    	  var reader = new FileReader();
    	  reader.onloadend = function(e){
    		fn(e.target.result);
    	  };
    	  reader.readAsDataURL(file);
    	};
    	function dataURLtoImage(dataurl,fn){
    	  var img = new Image();
    	  img.onload = function() {
    		fn(img);
    	  };
    	  img.src = dataurl;
    	};
    	function canvasResizetoFile(canvas,quality,fn){
    	  canvas.toBlob(function(blob) {
    		fn(blob);
    	  },'image/jpeg',quality);
    	};
    	function imagetoCanvas(image){
    	  var cvs = document.createElement("canvas");
    	  var ctx = cvs.getContext('2d');
    	  cvs.width = image.width;
    	  cvs.height = image.height;
    	  ctx.drawImage(image, 0, 0, cvs.width, cvs.height);
    	  return cvs ;
    	};
    	//上面是图片的处理  下面就是调用了
    	//因为我用的bootstrap的插件dropzone.js 所以是在它的添加文件的监听事件上处理的
    	this.on("addedfile",function(file){//添加一个文件时的监听事件  在这里进行文件压缩
    		//调用上面的方法
    		fileResizetoFile(file,0.1,function(res){//第二个参数范围是 0~1 用于调整图片质量
    			newfile.push(res);//这个newfile是我其他代码里定义的一个数组 把压缩的图片Blob一个个放进去
    		})
    	});
    
    如果有在dropzone.js插件上压缩图片的朋友不太会的话,可以联系我

    建议点这里先看看相关文档

    展开全文
  • 详情请移步:http://blog.csdn.net/alfred_c/article/details/50542741
  • H5js前端压缩图片

    千次阅读 2020-02-11 15:29:45
    1.压缩图片是通过canvas做到的。 具体原理【1】先获取图片的原始尺寸【2】确定压缩后的图片尺寸,(就是将图片尺寸都缩小达到压缩目的)【3】在canvas画布上重新画一遍这个缩小后尺寸的图片【4】把该图片转为blob...
  • 图片压缩节约内存

    2012-11-12 22:51:44
    实现图片压缩,可以节约内存,应用场合:ListView异步加载大量网络图片时,可以适当压缩显示,可以有效防止内存溢出,适合新手学习之用,gb编码
  • web前端压缩图片方法——加快页面加载速度
  • WEB前端大图片压缩并上传例子

    千次下载 热门讨论 2014-12-01 15:47:39
    手机上传图片到服务器时,如果是大文件图片肯定会很慢而且费流量,用户体验不好。本人用html5的canvas解决了这个问题,好东西一定要分享
  • python多种方法压缩图片,opencv、PIL、tinypng压缩图片文章目录:1 python+opncv实现图片的压缩2 python+PIL实现图片的压缩3 python+tinypng实现图片的压缩3.1 tinypng介绍3.2 tinypng压缩图片API使用3.2.1 ...
  • Java实现压缩图片

    千次阅读 2018-11-23 15:32:41
    一个google使用的开源的工具类Thumbnailator 超级好用,提供很多对图片操作的方法 github上面的地址是:https://github.com/coobird/thumbnailator maven的地址 &lt;dependency&gt;  &lt;groupId&...
  • java高清图片压缩的2种方法
  • 用opencv压缩图片

    千次阅读 2018-10-07 14:49:53
    由于前段时间用手机拍照,发现图片太大,一张就差不多5M,传到电脑后太大了,不方便处理,所以写了这个用opencv来压缩一下。 下面是具体代码,代码较简单,大家一看就懂。   #coding = utf-8 import cv2 import...
  • Thumbnails 压缩图片到指定kb

    千次阅读 2020-07-01 13:33:33
    -- google图片处理 --> <dependency> <groupId>net.coobird</groupId> <artifactId>thumbnailator</artifactId> <version>0.4.11</version> </dependency>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 313,994
精华内容 125,597
关键字:

压缩图片怎么压缩