HTML5画布调整大小(缩小)图像的质量?


149

我使用html5 canvas元素在浏览器中调整图像大小。事实证明,质量很低。我发现了这一点:在缩放<canvas>时禁用插值,但它无助于提高质量。

下面是我的css和js代码,以及用Photoshop调用并在canvas API中缩放的图像。

在浏览器中缩放图像时,我该怎么做才能获得最佳质量?

注意:我想将大图像缩小为小图像,修改画布中的颜色并将结果从画布发送到服务器。

CSS:

canvas, img {
    image-rendering: optimizeQuality;
    image-rendering: -moz-crisp-edges;
    image-rendering: -webkit-optimize-contrast;
    image-rendering: optimize-contrast;
    -ms-interpolation-mode: nearest-neighbor;
}

JS:

var $img = $('<img>');
var $originalCanvas = $('<canvas>');
$img.load(function() {


   var originalContext = $originalCanvas[0].getContext('2d');   
   originalContext.imageSmoothingEnabled = false;
   originalContext.webkitImageSmoothingEnabled = false;
   originalContext.mozImageSmoothingEnabled = false;
   originalContext.drawImage(this, 0, 0, 379, 500);
});

图片使用Photoshop调整大小:

在此处输入图片说明

在画布上调整图像大小:

在此处输入图片说明

编辑:

我试图按照以下建议的多个步骤进行缩减:

调整HTML5画布Html5画布drawImage中图像的大小:如何应用抗锯齿

这是我使用的功能:

function resizeCanvasImage(img, canvas, maxWidth, maxHeight) {
    var imgWidth = img.width, 
        imgHeight = img.height;

    var ratio = 1, ratio1 = 1, ratio2 = 1;
    ratio1 = maxWidth / imgWidth;
    ratio2 = maxHeight / imgHeight;

    // Use the smallest ratio that the image best fit into the maxWidth x maxHeight box.
    if (ratio1 < ratio2) {
        ratio = ratio1;
    }
    else {
        ratio = ratio2;
    }

    var canvasContext = canvas.getContext("2d");
    var canvasCopy = document.createElement("canvas");
    var copyContext = canvasCopy.getContext("2d");
    var canvasCopy2 = document.createElement("canvas");
    var copyContext2 = canvasCopy2.getContext("2d");
    canvasCopy.width = imgWidth;
    canvasCopy.height = imgHeight;  
    copyContext.drawImage(img, 0, 0);

    // init
    canvasCopy2.width = imgWidth;
    canvasCopy2.height = imgHeight;        
    copyContext2.drawImage(canvasCopy, 0, 0, canvasCopy.width, canvasCopy.height, 0, 0, canvasCopy2.width, canvasCopy2.height);


    var rounds = 2;
    var roundRatio = ratio * rounds;
    for (var i = 1; i <= rounds; i++) {
        console.log("Step: "+i);

        // tmp
        canvasCopy.width = imgWidth * roundRatio / i;
        canvasCopy.height = imgHeight * roundRatio / i;

        copyContext.drawImage(canvasCopy2, 0, 0, canvasCopy2.width, canvasCopy2.height, 0, 0, canvasCopy.width, canvasCopy.height);

        // copy back
        canvasCopy2.width = imgWidth * roundRatio / i;
        canvasCopy2.height = imgHeight * roundRatio / i;
        copyContext2.drawImage(canvasCopy, 0, 0, canvasCopy.width, canvasCopy.height, 0, 0, canvasCopy2.width, canvasCopy2.height);

    } // end for


    // copy back to canvas
    canvas.width = imgWidth * roundRatio / rounds;
    canvas.height = imgHeight * roundRatio / rounds;
    canvasContext.drawImage(canvasCopy2, 0, 0, canvasCopy2.width, canvasCopy2.height, 0, 0, canvas.width, canvas.height);


}

如果我使用2步缩小尺寸,则结果如下:

在此处输入图片说明

如果我使用3步缩小尺寸,则结果如下:

在此处输入图片说明

如果我使用4步缩小尺寸,则结果如下:

在此处输入图片说明

如果我使用20步缩小尺寸,则结果如下:

在此处输入图片说明

注意:事实证明,从1步到2步,图像质量有了很大的提高,但是添加到过程中的步数越多,图像变得越模糊。

有没有办法解决您添加的步数越多图像越模糊的问题?

编辑2013-10-04:我尝试了GameAlchemist的算法。这是与Photoshop比较的结果。

PhotoShop图片:

PhotoShop图片

GameAlchemist的算法:

GameAlchemist的算法


2
您可以尝试逐步缩放图像:stackoverflow.com/questions/18761404/...
坊间

1
Html5 canvas drawImage的可能重复项:如何应用抗锯齿。看看是否可行。如果图像较大且缩小为较小尺寸,则需要

2
@confile关闭插值将使情况更糟。您要保持启用状态。查看我上面提供的链接。我在那里展示了如何使用步骤缩小较大的图像并保持质量。正如Scott所说,您要优先考虑质量而不是速度。

1
@ Ken-AbdiasSoftware我尝试过采用这种方法,但是问题是,我逐步进行缩放时,回合会变得更糟。任何想法如何解决?
2013年

3
使用HTML5复制昂贵的专业照片编辑软件的功能的可能性肯定很小吗?您可能会靠近(ish),但正如它在Photoshop中正常工作一样,我想那是不可能的!
利亚姆

Answers:


171

由于您的问题是缩小图像,因此谈论插值(即创建像素)毫无意义。这里的问题是下采样。

要对图像进行降采样,我们需要将原始图像中每个p * p像素的正方形变成目标图像中的单个像素。

出于性能原因,浏览器进行了非常简单的下采样:要生成较小的图像,它们将仅在源中选择一个像素并将其值用作目标。这会“忘记”一些细节并增加噪音。

但是有个例外:由于2X图像下采样的计算非常简单(平均4个像素即可制作一个像素),并且用于视网膜/ HiDPI像素,因此这种情况得到了正确处理-浏览器确实使用4个像素来制作之一-。

但是...如果您多次使用2X下采样,则会遇到连续的舍入误差会增加过多噪声的问题。
更糟糕的是,您将无法始终将大小调整为2的幂,并且将大小调整为最接近的幂+最后一次调整大小非常嘈杂。

您要寻找的是像素完美的下采样,即:对图像进行重新采样,无论尺寸如何,都将考虑所有输入像素。
为此,我们必须针对每个输入像素计算其对一个,两个或四个目标像素的贡献,具体取决于输入像素的缩放投影是否恰好在目标像素内部,与X边界,Y边界或两者重叠。
(一个计划在这里会很好,但是我没有一个。)

这是一个画布缩放比例与我的像素完美缩放比例(在1/3缩放比例下)的示例。

请注意,图片可能会在浏览器中缩放,并以.jpeg格式化。
但是,我们看到的噪音要少得多,尤其是在袋熊后面的草丛和右边的树枝中。皮毛上的噪音使它更具反差,但看起来他像白发(与原始图片不同)。
正确的图像不那么吸引眼球,但绝对更好。

在此处输入图片说明

这是执行像素完美缩小的代码:

提琴结果:http : //jsfiddle.net/gamealchemist/r6aVp/embedded/result/
提琴本身:http : //jsfiddle.net/gamealchemist/r6aVp/

// scales the image by (float) scale < 1
// returns a canvas containing the scaled image.
function downScaleImage(img, scale) {
    var imgCV = document.createElement('canvas');
    imgCV.width = img.width;
    imgCV.height = img.height;
    var imgCtx = imgCV.getContext('2d');
    imgCtx.drawImage(img, 0, 0);
    return downScaleCanvas(imgCV, scale);
}

// scales the canvas by (float) scale < 1
// returns a new canvas containing the scaled image.
function downScaleCanvas(cv, scale) {
    if (!(scale < 1) || !(scale > 0)) throw ('scale must be a positive number <1 ');
    var sqScale = scale * scale; // square scale = area of source pixel within target
    var sw = cv.width; // source image width
    var sh = cv.height; // source image height
    var tw = Math.floor(sw * scale); // target image width
    var th = Math.floor(sh * scale); // target image height
    var sx = 0, sy = 0, sIndex = 0; // source x,y, index within source array
    var tx = 0, ty = 0, yIndex = 0, tIndex = 0; // target x,y, x,y index within target array
    var tX = 0, tY = 0; // rounded tx, ty
    var w = 0, nw = 0, wx = 0, nwx = 0, wy = 0, nwy = 0; // weight / next weight x / y
    // weight is weight of current source point within target.
    // next weight is weight of current source point within next target's point.
    var crossX = false; // does scaled px cross its current px right border ?
    var crossY = false; // does scaled px cross its current px bottom border ?
    var sBuffer = cv.getContext('2d').
    getImageData(0, 0, sw, sh).data; // source buffer 8 bit rgba
    var tBuffer = new Float32Array(3 * tw * th); // target buffer Float32 rgb
    var sR = 0, sG = 0,  sB = 0; // source's current point r,g,b
    /* untested !
    var sA = 0;  //source alpha  */    

    for (sy = 0; sy < sh; sy++) {
        ty = sy * scale; // y src position within target
        tY = 0 | ty;     // rounded : target pixel's y
        yIndex = 3 * tY * tw;  // line index within target array
        crossY = (tY != (0 | ty + scale)); 
        if (crossY) { // if pixel is crossing botton target pixel
            wy = (tY + 1 - ty); // weight of point within target pixel
            nwy = (ty + scale - tY - 1); // ... within y+1 target pixel
        }
        for (sx = 0; sx < sw; sx++, sIndex += 4) {
            tx = sx * scale; // x src position within target
            tX = 0 |  tx;    // rounded : target pixel's x
            tIndex = yIndex + tX * 3; // target pixel index within target array
            crossX = (tX != (0 | tx + scale));
            if (crossX) { // if pixel is crossing target pixel's right
                wx = (tX + 1 - tx); // weight of point within target pixel
                nwx = (tx + scale - tX - 1); // ... within x+1 target pixel
            }
            sR = sBuffer[sIndex    ];   // retrieving r,g,b for curr src px.
            sG = sBuffer[sIndex + 1];
            sB = sBuffer[sIndex + 2];

            /* !! untested : handling alpha !!
               sA = sBuffer[sIndex + 3];
               if (!sA) continue;
               if (sA != 0xFF) {
                   sR = (sR * sA) >> 8;  // or use /256 instead ??
                   sG = (sG * sA) >> 8;
                   sB = (sB * sA) >> 8;
               }
            */
            if (!crossX && !crossY) { // pixel does not cross
                // just add components weighted by squared scale.
                tBuffer[tIndex    ] += sR * sqScale;
                tBuffer[tIndex + 1] += sG * sqScale;
                tBuffer[tIndex + 2] += sB * sqScale;
            } else if (crossX && !crossY) { // cross on X only
                w = wx * scale;
                // add weighted component for current px
                tBuffer[tIndex    ] += sR * w;
                tBuffer[tIndex + 1] += sG * w;
                tBuffer[tIndex + 2] += sB * w;
                // add weighted component for next (tX+1) px                
                nw = nwx * scale
                tBuffer[tIndex + 3] += sR * nw;
                tBuffer[tIndex + 4] += sG * nw;
                tBuffer[tIndex + 5] += sB * nw;
            } else if (crossY && !crossX) { // cross on Y only
                w = wy * scale;
                // add weighted component for current px
                tBuffer[tIndex    ] += sR * w;
                tBuffer[tIndex + 1] += sG * w;
                tBuffer[tIndex + 2] += sB * w;
                // add weighted component for next (tY+1) px                
                nw = nwy * scale
                tBuffer[tIndex + 3 * tw    ] += sR * nw;
                tBuffer[tIndex + 3 * tw + 1] += sG * nw;
                tBuffer[tIndex + 3 * tw + 2] += sB * nw;
            } else { // crosses both x and y : four target points involved
                // add weighted component for current px
                w = wx * wy;
                tBuffer[tIndex    ] += sR * w;
                tBuffer[tIndex + 1] += sG * w;
                tBuffer[tIndex + 2] += sB * w;
                // for tX + 1; tY px
                nw = nwx * wy;
                tBuffer[tIndex + 3] += sR * nw;
                tBuffer[tIndex + 4] += sG * nw;
                tBuffer[tIndex + 5] += sB * nw;
                // for tX ; tY + 1 px
                nw = wx * nwy;
                tBuffer[tIndex + 3 * tw    ] += sR * nw;
                tBuffer[tIndex + 3 * tw + 1] += sG * nw;
                tBuffer[tIndex + 3 * tw + 2] += sB * nw;
                // for tX + 1 ; tY +1 px
                nw = nwx * nwy;
                tBuffer[tIndex + 3 * tw + 3] += sR * nw;
                tBuffer[tIndex + 3 * tw + 4] += sG * nw;
                tBuffer[tIndex + 3 * tw + 5] += sB * nw;
            }
        } // end for sx 
    } // end for sy

    // create result canvas
    var resCV = document.createElement('canvas');
    resCV.width = tw;
    resCV.height = th;
    var resCtx = resCV.getContext('2d');
    var imgRes = resCtx.getImageData(0, 0, tw, th);
    var tByteBuffer = imgRes.data;
    // convert float32 array into a UInt8Clamped Array
    var pxIndex = 0; //  
    for (sIndex = 0, tIndex = 0; pxIndex < tw * th; sIndex += 3, tIndex += 4, pxIndex++) {
        tByteBuffer[tIndex] = Math.ceil(tBuffer[sIndex]);
        tByteBuffer[tIndex + 1] = Math.ceil(tBuffer[sIndex + 1]);
        tByteBuffer[tIndex + 2] = Math.ceil(tBuffer[sIndex + 2]);
        tByteBuffer[tIndex + 3] = 255;
    }
    // writing result to canvas.
    resCtx.putImageData(imgRes, 0, 0);
    return resCV;
}

这是非常内存的贪婪,因为需要浮点缓冲区来存储目标图像的中间值(->如果我们对结果画布进行计数,则在此算法中我们使用源图像的6倍的内存)。
这也是相当昂贵的,因为无论目标大小如何都使用每个源像素,而且我们必须为getImageData / putImageDate付费,这也相当慢。
但是在这种情况下,没有比处理每个源值更快的方法了,情况也还不错:对于我的740 * 556的袋熊图像,处理时间在30到40毫秒之间。


如果先缩放图像然后再将其放入画布,会更快吗?
2013年

我不明白...看来这就是我所做的。缓冲区以及我创建的画布(resCV)具有缩放图像的大小。我认为提高速度的唯一方法是使用类似于breshensam的整数计算。但是40ms仅对于视频游戏(25 fps)较慢,而对于绘画应用程序则不然。
GameAlchemist 2013年

您是否有机会在保持质量的同时提高算法速度?

1
我试图使用0 |舍入缓冲区(算法的最新部分)。而不是Mat.ceil。它有点快。但是无论如何,get / putImageData会有很多开销,同样,我们不可避免地要处理每个像素。
GameAlchemist 2013年

4
好的,所以我看了代码:您离解决方案很近。两个错误:tX + 1的索引减少了一个(它们分别为+ 3,+ 4,+ 5,+ 6,而不是+ 4,+ 5,+ 6,+ 7),并且在rgba中更改行是多倍的乘以4,而不是3。我只是测试了4个随机值以进行检查(0.1、0.15、0.33、0.8),看起来还可以。您更新的小提琴在这里:jsfiddle.net/gamealchemist/kpQyE/3
GameAlchemist 2013年

51

快速进行高质量的画布重采样:http//jsfiddle.net/9g9Nv/442/

更新: 2.0版(更快,网络工作者+可转移对象)-https://github.com/viliusle/Hermite-resize

/**
 * Hermite resize - fast image resize/resample using Hermite filter. 1 cpu version!
 * 
 * @param {HtmlElement} canvas
 * @param {int} width
 * @param {int} height
 * @param {boolean} resize_canvas if true, canvas will be resized. Optional.
 */
function resample_single(canvas, width, height, resize_canvas) {
    var width_source = canvas.width;
    var height_source = canvas.height;
    width = Math.round(width);
    height = Math.round(height);

    var ratio_w = width_source / width;
    var ratio_h = height_source / height;
    var ratio_w_half = Math.ceil(ratio_w / 2);
    var ratio_h_half = Math.ceil(ratio_h / 2);

    var ctx = canvas.getContext("2d");
    var img = ctx.getImageData(0, 0, width_source, height_source);
    var img2 = ctx.createImageData(width, height);
    var data = img.data;
    var data2 = img2.data;

    for (var j = 0; j < height; j++) {
        for (var i = 0; i < width; i++) {
            var x2 = (i + j * width) * 4;
            var weight = 0;
            var weights = 0;
            var weights_alpha = 0;
            var gx_r = 0;
            var gx_g = 0;
            var gx_b = 0;
            var gx_a = 0;
            var center_y = (j + 0.5) * ratio_h;
            var yy_start = Math.floor(j * ratio_h);
            var yy_stop = Math.ceil((j + 1) * ratio_h);
            for (var yy = yy_start; yy < yy_stop; yy++) {
                var dy = Math.abs(center_y - (yy + 0.5)) / ratio_h_half;
                var center_x = (i + 0.5) * ratio_w;
                var w0 = dy * dy; //pre-calc part of w
                var xx_start = Math.floor(i * ratio_w);
                var xx_stop = Math.ceil((i + 1) * ratio_w);
                for (var xx = xx_start; xx < xx_stop; xx++) {
                    var dx = Math.abs(center_x - (xx + 0.5)) / ratio_w_half;
                    var w = Math.sqrt(w0 + dx * dx);
                    if (w >= 1) {
                        //pixel too far
                        continue;
                    }
                    //hermite filter
                    weight = 2 * w * w * w - 3 * w * w + 1;
                    var pos_x = 4 * (xx + yy * width_source);
                    //alpha
                    gx_a += weight * data[pos_x + 3];
                    weights_alpha += weight;
                    //colors
                    if (data[pos_x + 3] < 255)
                        weight = weight * data[pos_x + 3] / 250;
                    gx_r += weight * data[pos_x];
                    gx_g += weight * data[pos_x + 1];
                    gx_b += weight * data[pos_x + 2];
                    weights += weight;
                }
            }
            data2[x2] = gx_r / weights;
            data2[x2 + 1] = gx_g / weights;
            data2[x2 + 2] = gx_b / weights;
            data2[x2 + 3] = gx_a / weights_alpha;
        }
    }
    //clear and resize canvas
    if (resize_canvas === true) {
        canvas.width = width;
        canvas.height = height;
    } else {
        ctx.clearRect(0, 0, width_source, height_source);
    }

    //draw
    ctx.putImageData(img2, 0, 0);
}

我需要最好的品质

18
固定,我将“好”更改为“最好”,现在可以吗?:D 另一方面,如果您想获得最好的重采样效果,请使用imagemagick。
ViliusL 2013年

@confile imgur.com在jsfiddle中可以安全使用,但是管理员做错了什么?您没有看到好的质量,因为您的浏览器出现了CORS致命错误。(无法使用来自远程站点的图像)
ViliusL 2014年

好的,您可以在透明区域使用其他任何PNG图像。有什么想法吗?
2014年

4
@confile您是正确的,在某些情况下,透明图像在锐利区域存在问题。我的测试错过了这些案例。修复了调整大小的问题,还修复了对提琴的远程图像支持:jsfiddle.net/9g9Nv/49
ViliusL 2014年

28

建议1-延长工艺管线

您可以按照我在所引用的链接中描述的方式使用降压功能,但您似乎以错误的方式使用它们。

不需要降级将图像缩放到1:2以上的比例(通常但不限于此)。在这里,您需要进行急剧的缩小,您需要根据图像的内容(尤其是在发生诸如细线之类的高频率情况)将其分成两个(很少有更多)步骤。

每次对图像进行降采样时,都会丢失细节和信息。您不能期望得到的图像像原始图像一样清晰。

如果然后按多个步骤缩小图像,则总共将丢失很多信息,结果将很差,您已经注意到了。

尝试只执行一个额外步骤,或尝试执行顶部两个步骤。

卷积

如果是Photoshop,请注意,在对图像重新采样后会应用卷积,例如锐化。不仅发生双三次插值,因此为了完全模拟Photoshop,我们还需要添加Photoshop正在执行的步骤(使用默认设置)。

对于此示例,我将使用您在帖子中引用的原始答案,但我对其添加了锐化卷积以提高后期处理的质量(请参阅底部的演示)。

这是添加锐化滤镜的代码(它基于通用的卷积滤镜-我在其中放入了用于锐化的权重矩阵以及用于调整效果发音的混合因子):

用法:

sharpen(context, width, height, mixFactor);

mixFactor值介于[0.0,1.0]之间,可让您淡化锐化效果-经验法则:大小越小,所需效果越少。

功能(基于此代码段):

function sharpen(ctx, w, h, mix) {

    var weights =  [0, -1, 0,  -1, 5, -1,  0, -1, 0],
        katet = Math.round(Math.sqrt(weights.length)),
        half = (katet * 0.5) |0,
        dstData = ctx.createImageData(w, h),
        dstBuff = dstData.data,
        srcBuff = ctx.getImageData(0, 0, w, h).data,
        y = h;
        
    while(y--) {

        x = w;

        while(x--) {

            var sy = y,
                sx = x,
                dstOff = (y * w + x) * 4,
                r = 0, g = 0, b = 0, a = 0;

            for (var cy = 0; cy < katet; cy++) {
                for (var cx = 0; cx < katet; cx++) {

                    var scy = sy + cy - half;
                    var scx = sx + cx - half;

                    if (scy >= 0 && scy < h && scx >= 0 && scx < w) {

                        var srcOff = (scy * w + scx) * 4;
                        var wt = weights[cy * katet + cx];

                        r += srcBuff[srcOff] * wt;
                        g += srcBuff[srcOff + 1] * wt;
                        b += srcBuff[srcOff + 2] * wt;
                        a += srcBuff[srcOff + 3] * wt;
                    }
                }
            }

            dstBuff[dstOff] = r * mix + srcBuff[dstOff] * (1 - mix);
            dstBuff[dstOff + 1] = g * mix + srcBuff[dstOff + 1] * (1 - mix);
            dstBuff[dstOff + 2] = b * mix + srcBuff[dstOff + 2] * (1 - mix)
            dstBuff[dstOff + 3] = srcBuff[dstOff + 3];
        }
    }

    ctx.putImageData(dstData, 0, 0);
}

使用此组合的结果将是:

在线演示

结果下采样并提高卷积

根据要添加到混合中的锐化程度,可以从默认“模糊”获得非常锐利的结果:

锐化的变化

建议2-低层算法的实现

如果要在质量上获得最好的结果,则需要进行低级处理,并考虑实施例如这种全新的算法来做到这一点。

请参阅IEEE的插值相关图像下采样(2011)。
这是全文的链接(PDF)

目前,JavaScript AFAIK中没有该算法的实现,因此,如果您想自己完成此任务,则不容错过。

本质是(摘录自论文):

抽象

针对低比特率图像编码,提出了一种面向插值的自适应下采样算法。给定图像,所提出的算法能够获得低分辨率图像,从中可以插值具有与输入图像相同分辨率的高质量图像。与传统的下采样算法不同,传统的下采样算法独立于插值过程,所提出的下采样算法将下采样与插值过程联系在一起。因此,所提出的下采样算法能够最大程度地保持输入图像的原始信息。然后将降采样后的图像送入JPEG。然后将基于总变化量(TV)的后处理应用于解压缩的低分辨率图像。最终,实验结果证明,利用所提算法的降采样图像,可以得到质量更高的插值图像。此外,对于低比特率图像编码,该算法能够实现优于JPEG的性能。

纸质快照

(有关所有详细信息,公式等,请参见提供的链接)


这也是一个很好的解决方案。谢谢!
2014年

这是一个很好的解决方案。我在具有透明区域的png文件上尝试过。结果是:jsfiddle.net/confile/5CD4N您是否知道如何使它工作?

1
这是GENIUS!但是请您能解释一下您到底在做什么?大声笑..我完全想知道来龙去脉...也许学习的资源?
carinlynchin

1
@Carine对于较差的评论字段可能会有点:),但是按比例缩小会重新采样一组像素,以平均代表该组的一个像素。实际上,这是一个低通滤波器,总体上会引入一些模糊。为了补偿清晰度损失,只需应用锐化卷积即可。由于锐化可能非常明显,因此我们可以将其与图像混合,这样我们就可以控制锐化的级别。希望能提供一些见识。

21

如果您只想使用画布,则最好的结果将是多次降级。但这还不是个好主意。为了获得更好的质量,您需要纯js实现。我们刚刚发布了pica-具有可变质量/速度的高速降频器。简而言之,它以最高的质量(在3个裂点的lanczos滤镜)在约0.1s的时间内调整了1280 * 1024px的图像,并在1s的时间内调整了5000 * 3000px的图像。Pica具有演示,您可以在其中播放图像,质量等级,甚至可以在移动设备上尝试。

Pica还没有锐化蒙版,但是很快就会添加。这比实现高速卷积滤波器调整大小要容易得多。


16

为什么使用画布调整图像大小?现代浏览器都使用三次三次插值(与Photoshop所用的过程相同(如果您做对的话)),并且比画布处理要快。只需指定所需的图像尺寸即可(仅使用一个尺寸,高度或宽度按比例调整尺寸)。

大多数浏览器(包括更高版本的IE)都支持此功能。早期版本可能需要特定于浏览器的CSS

一个简单的函数(使用jQuery)来调整图像大小将如下所示:

function resizeImage(img, percentage) {
    var coeff = percentage/100,
        width = $(img).width(),
        height = $(img).height();

    return {"width": width*coeff, "height": height*coeff}           
}

然后,只需使用返回的值即可在一维或二维中调整图像大小。

显然,您可以进行不同的改进,但这可以完成工作。

将以下代码粘贴到此页面的控制台中,观察凹版发生了什么:

function resizeImage(img, percentage) {
    var coeff = percentage/100,
        width = $(img).width(),
        height = $(img).height();

    return {"width": width*coeff, "height": height*coeff}           
}

$('.user-gravatar32 img').each(function(){
  var newDimensions = resizeImage( this, 150);
  this.style.width = newDimensions.width + "px";
  this.style.height = newDimensions.height + "px";
});

2
另请注意,如果仅指定一个尺寸,(现代)浏览器将自动保持图像的自然长宽比。
安德烈·迪翁(

38
也许他需要将调整大小后的图像发送到服务器。
2013年

2
@Sergiu:没必要,但是请注意,如果要从很小的图像变为很大的图像,即使从服务器也无法获得很好的效果。
Robusto

2
@Robusto之后,我需要将图像放在画布中,然后再将其发送到服务器。我想将大图像缩小为小图像,在画布上修改颜色并将结果发送到服务器。你觉得我应该怎么做?
提交

9
@Robusto这是问题。在客户端上显示小图像很容易。img.width和img.height都很琐碎。我只想按比例缩小一次,而不要在服务器上按比例缩小。

8

对于确实需要调整图像本身大小的人来说,这不是正确的答案,而仅仅是缩小文件大小

我的“直接来自相机”图片有问题,我的客户经常以“未压缩” JPEG格式上传图片。

不太知名的是,canvas支持(在大多数浏览器2017中)更改JPEG的质量

data=canvas.toDataURL('image/jpeg', .85) # [1..0] default 0.92

使用此技巧,我可以将> 10Mb的4k x 3k图片减少到1或2Mb,请确保这取决于您的需求。

看这里


4

这是可重用的Angular服务,用于高质量图像/画布大小调整:https : //gist.github.com/fisch0920/37bac5e741eaec60e983

该服务支持lanczos卷积和逐步缩小。卷积方法具有较高的质量,但代价是速度较慢,而逐步缩小的方法可产生合理的抗锯齿结果,并且速度明显更快。

用法示例:

angular.module('demo').controller('ExampleCtrl', function (imageService) {
  // EXAMPLE USAGE
  // NOTE: it's bad practice to access the DOM inside a controller, 
  // but this is just to show the example usage.

  // resize by lanczos-sinc filter
  imageService.resize($('#myimg')[0], 256, 256)
    .then(function (resizedImage) {
      // do something with resized image
    })

  // resize by stepping down image size in increments of 2x
  imageService.resizeStep($('#myimg')[0], 256, 256)
    .then(function (resizedImage) {
      // do something with resized image
    })
})

4

这是改进的Hermite调整大小过滤器,它使用1个工作器,因此窗口不会冻结。

https://github.com/calvintwr/blitz-hermite-resize

const blitz = Blitz.create()

/* Promise */
blitz({
    source: DOM Image/DOM Canvas/jQuery/DataURL/File,
    width: 400,
    height: 600
}).then(output => {
    // handle output
})catch(error => {
    // handle error
})

/* Await */
let resized = await blizt({...})

/* Old school callback */
const blitz = Blitz.create('callback')
blitz({...}, function(output) {
    // run your callback.
})

3

我找到了一种解决方案,不需要直接访问像素数据并循环遍历即可执行下采样。根据图像的大小,这可能会占用大量资源,因此最好使用浏览器的内部算法。

所述的drawImage()函数是使用线性内插,最近邻居重采样方法。这工作得很好,当你不调整下跌超过一半的原始大小

如果循环一次仅将最大大小调整为一半,则结果将非常好,并且比访问像素数据快得多。

此功能一次将采样率降低一半,直到达到所需大小:

  function resize_image( src, dst, type, quality ) {
     var tmp = new Image(),
         canvas, context, cW, cH;

     type = type || 'image/jpeg';
     quality = quality || 0.92;

     cW = src.naturalWidth;
     cH = src.naturalHeight;

     tmp.src = src.src;
     tmp.onload = function() {

        canvas = document.createElement( 'canvas' );

        cW /= 2;
        cH /= 2;

        if ( cW < src.width ) cW = src.width;
        if ( cH < src.height ) cH = src.height;

        canvas.width = cW;
        canvas.height = cH;
        context = canvas.getContext( '2d' );
        context.drawImage( tmp, 0, 0, cW, cH );

        dst.src = canvas.toDataURL( type, quality );

        if ( cW <= src.width || cH <= src.height )
           return;

        tmp.src = dst.src;
     }

  }
  // The images sent as parameters can be in the DOM or be image objects
  resize_image( $( '#original' )[0], $( '#smaller' )[0] );

您能否发布一个jsfiddle和一些生成的图像?

在底部的链接,你可以找到导致使用这种技术的图像
赫苏斯·卡雷拉

1

也许您可以尝试一下,这是我在项目中经常使用的方法。这样,您不仅可以获取高质量的图像,还可以获取画布上的任何其他元素。

/* 
 * @parame canvas => canvas object
 * @parame rate => the pixel quality
 */
function setCanvasSize(canvas, rate) {
    const scaleRate = rate;
    canvas.width = window.innerWidth * scaleRate;
    canvas.height = window.innerHeight * scaleRate;
    canvas.style.width = window.innerWidth + 'px';
    canvas.style.height = window.innerHeight + 'px';
    canvas.getContext('2d').scale(scaleRate, scaleRate);
}

0

如果添加1.0,则代替.85。您将得到确切的答案。

data=canvas.toDataURL('image/jpeg', 1.0);

您可以获得清晰明亮的图像。请检查


0

我确实尝试避免遍历图像数据,尤其是在较大的图像上。因此,我想出了一种相当简单的方法,可以通过一些额外的步骤来适当地减小图像大小,而没有任何限制。该例程下降到所需目标大小之前的最低可能半步。然后将其缩放到目标大小的两倍,然后再扩大一半。乍一看听起来很有趣,但结果出奇的好,并且很快就实现了。

function resizeCanvas(canvas, newWidth, newHeight) {
  let ctx = canvas.getContext('2d');
  let buffer = document.createElement('canvas');
  buffer.width = ctx.canvas.width;
  buffer.height = ctx.canvas.height;
  let ctxBuf = buffer.getContext('2d');
  

  let scaleX = newWidth / ctx.canvas.width;
  let scaleY = newHeight / ctx.canvas.height;

  let scaler = Math.min(scaleX, scaleY);
  //see if target scale is less than half...
  if (scaler < 0.5) {
    //while loop in case target scale is less than quarter...
    while (scaler < 0.5) {
      ctxBuf.canvas.width = ctxBuf.canvas.width * 0.5;
      ctxBuf.canvas.height = ctxBuf.canvas.height * 0.5;
      ctxBuf.scale(0.5, 0.5);
      ctxBuf.drawImage(canvas, 0, 0);
      ctxBuf.setTransform(1, 0, 0, 1, 0, 0);
      ctx.canvas.width = ctxBuf.canvas.width;
      ctx.canvas.height = ctxBuf.canvas.height;
      ctx.drawImage(buffer, 0, 0);

      scaleX = newWidth / ctxBuf.canvas.width;
      scaleY = newHeight / ctxBuf.canvas.height;
      scaler = Math.min(scaleX, scaleY);
    }
    //only if the scaler is now larger than half, double target scale trick...
    if (scaler > 0.5) {
      scaleX *= 2.0;
      scaleY *= 2.0;
      ctxBuf.canvas.width = ctxBuf.canvas.width * scaleX;
      ctxBuf.canvas.height = ctxBuf.canvas.height * scaleY;
      ctxBuf.scale(scaleX, scaleY);
      ctxBuf.drawImage(canvas, 0, 0);
      ctxBuf.setTransform(1, 0, 0, 1, 0, 0);
      scaleX = 0.5;
      scaleY = 0.5;
    }
  } else
    ctxBuf.drawImage(canvas, 0, 0);

  //wrapping things up...
  ctx.canvas.width = newWidth;
  ctx.canvas.height = newHeight;
  ctx.scale(scaleX, scaleY);
  ctx.drawImage(buffer, 0, 0);
  ctx.setTransform(1, 0, 0, 1, 0, 0);
}

-1

context.scale(xScale, yScale)

<canvas id="c"></canvas>
<hr/>
<img id="i" />

<script>
var i = document.getElementById('i');

i.onload = function(){
    var width = this.naturalWidth,
        height = this.naturalHeight,
        canvas = document.getElementById('c'),
        ctx = canvas.getContext('2d');

    canvas.width = Math.floor(width / 2);
    canvas.height = Math.floor(height / 2);

    ctx.scale(0.5, 0.5);
    ctx.drawImage(this, 0, 0);
    ctx.rect(0,0,500,500);
    ctx.stroke();

    // restore original 1x1 scale
    ctx.scale(2, 2);
    ctx.rect(0,0,500,500);
    ctx.stroke();
};

i.src = 'https://static.md/b70a511140758c63f07b618da5137b5d.png';
</script>

-1

演示:使用JS和HTML Canvas演示提琴手调整图像大小。

您可能会发现3种不同的方法来进行此大小调整,这将帮助您了解代码的工作方式以及原因。

https://jsfiddle.net/1b68eLdr/93089/

可以在GitHub项目中找到演示的完整代码以及可能要在代码中使用的TypeScript方法。

https://github.com/eyalc4/ts-image-resizer

这是最终代码:

export class ImageTools {
base64ResizedImage: string = null;

constructor() {
}

ResizeImage(base64image: string, width: number = 1080, height: number = 1080) {
    let img = new Image();
    img.src = base64image;

    img.onload = () => {

        // Check if the image require resize at all
        if(img.height <= height && img.width <= width) {
            this.base64ResizedImage = base64image;

            // TODO: Call method to do something with the resize image
        }
        else {
            // Make sure the width and height preserve the original aspect ratio and adjust if needed
            if(img.height > img.width) {
                width = Math.floor(height * (img.width / img.height));
            }
            else {
                height = Math.floor(width * (img.height / img.width));
            }

            let resizingCanvas: HTMLCanvasElement = document.createElement('canvas');
            let resizingCanvasContext = resizingCanvas.getContext("2d");

            // Start with original image size
            resizingCanvas.width = img.width;
            resizingCanvas.height = img.height;


            // Draw the original image on the (temp) resizing canvas
            resizingCanvasContext.drawImage(img, 0, 0, resizingCanvas.width, resizingCanvas.height);

            let curImageDimensions = {
                width: Math.floor(img.width),
                height: Math.floor(img.height)
            };

            let halfImageDimensions = {
                width: null,
                height: null
            };

            // Quickly reduce the size by 50% each time in few iterations until the size is less then
            // 2x time the target size - the motivation for it, is to reduce the aliasing that would have been
            // created with direct reduction of very big image to small image
            while (curImageDimensions.width * 0.5 > width) {
                // Reduce the resizing canvas by half and refresh the image
                halfImageDimensions.width = Math.floor(curImageDimensions.width * 0.5);
                halfImageDimensions.height = Math.floor(curImageDimensions.height * 0.5);

                resizingCanvasContext.drawImage(resizingCanvas, 0, 0, curImageDimensions.width, curImageDimensions.height,
                    0, 0, halfImageDimensions.width, halfImageDimensions.height);

                curImageDimensions.width = halfImageDimensions.width;
                curImageDimensions.height = halfImageDimensions.height;
            }

            // Now do final resize for the resizingCanvas to meet the dimension requirments
            // directly to the output canvas, that will output the final image
            let outputCanvas: HTMLCanvasElement = document.createElement('canvas');
            let outputCanvasContext = outputCanvas.getContext("2d");

            outputCanvas.width = width;
            outputCanvas.height = height;

            outputCanvasContext.drawImage(resizingCanvas, 0, 0, curImageDimensions.width, curImageDimensions.height,
                0, 0, width, height);

            // output the canvas pixels as an image. params: format, quality
            this.base64ResizedImage = outputCanvas.toDataURL('image/jpeg', 0.85);

            // TODO: Call method to do something with the resize image
        }
    };
}}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.