HTML5 Canvas Resize (Downscale) Image 高质量?

IT技术 javascript css html canvas html5-canvas
2021-01-31 04:32:57

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

下面是我的 css 和 js 代码以及用 Photoshop 调用并在画布 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 图像

游戏炼金术士的算法:

游戏炼金术士算法

6个回答

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

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

出于性能原因,浏览器做了一个非常简单的下采样:为了构建较小的图像,他们将只在源中选择一个像素并将其值用于目标。它“忘记”了一些细节并增加了噪音。

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

但是...如果您多次使用 2X 下采样,您将面临连续舍入误差会增加太多噪音的问题。
更糟糕的是,您不会总是以 2 的幂调整大小,并且调整到最接近的幂 + 最后一次调整大小非常嘈杂。

您寻求的是像素完美的下采样,即:图像的重新采样,将考虑所有输入像素 - 无论比例如何 -。
为此,我们必须为每个输入像素计算其对一个、两个或四个目标像素的贡献,具体取决于输入像素的缩放投影是否正好位于目标像素内部、与 X 边界、Y 边界重叠,或两者兼而有之.
(这里有一个计划会很好,但我没有。)

这是画布比例与我的像素完美比例在 zombat 的 1/3 比例上的示例。

请注意,图片可能会在您的浏览器中缩放,并由 SO 进行 .jpegized。
然而,我们看到噪音要小得多,尤其是在袋熊身后的草地和它右边的树枝上。毛皮中的噪点使其对比更加鲜明,但看起来他有白发 - 与源图片不同 - 。
正确的图像不那么吸引人,但绝对更好。

在此处输入图片说明

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

小提琴结果: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 毫秒。

如果在将图像放入画布之前缩放图像会更快吗?
2021-03-13 04:32:57
我尝试使用 0 来舍入缓冲区(算法的最新部分) | 而不是 Mat.ceil。它有点快。但无论如何,get/putImageData 有相当多的开销,而且我们无法避免处理每个像素。
2021-03-14 04:32:57
好的,所以我看了代码:你离解决方案很近。两个错误:你的索引在 tX+1 上偏移了一个(它们是 +3、+4、+5、+6 而不是 +4、+5、+6、+7),并且在 rgba 中改变线是一个 mul到 4,而不是 3。我只是测试了 4 个随机值来检查 (0.1, 0.15, 0.33, 0.8) 看起来没问题。你更新的小提琴在这里:jsfiddle.net/gamealchemist/kpQyE/3
2021-03-24 04:32:57
我不明白……这似乎是我所做的。缓冲区以及我创建的画布 (resCV) 具有缩放图像的大小。我认为让它更快的唯一方法是使用类似 breshensam 的整数计算。但是 40 毫秒仅对于视频游戏 (25 fps) 来说很慢,对于绘图应用程序则不然。
2021-04-07 04:32:57
您是否有机会在保持质量的同时使算法更快?
2021-04-10 04:32:57

质量好的快速画布重采样: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);
}
@confile imgur.com 在 jsfiddle 中使用是安全的,但管理员做错了什么?你没有看到好的质量,因为你的浏览器给出了 CORS 致命错误。(不能使用来自远程站点的图像)
2021-03-17 04:32:57
已修复,我将“好”改为“最佳”,现在可以了吗? :D。另一方面,如果您想要最好的重新采样 - 使用 imagemagick。
2021-03-18 04:32:57
我需要最好的品质
2021-03-23 04:32:57
好的,您可以使用任何其他带有透明区域的 PNG 图像。对此有什么想法吗?
2021-03-23 04:32:57
@confile 你是对的,在某些情况下,透明图像在尖锐区域有问题。我在测试中错过了这些案例。固定调整大小也固定了小提琴上的远程图像支持:jsfiddle.net/9g9Nv/49
2021-03-30 04:32:57

建议 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 的Interpolation-Dependent Image Downsampling (2011)。
这是该论文的全文链接 (PDF)

目前在 JavaScript AFAIK 中没有此算法的实现,因此如果您想全身心地投入到这项任务中,您将需要全力以赴。

实质是(论文节选):

抽象的

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

纸上的快照

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

@Carine 对于糟糕的评论字段来说可能有点多:) 但是,缩小对一组像素的重新采样以平均代表该组的新像素。这实际上是一个低通滤波器,它在整体上引入了一些模糊。为了补偿锐度的损失,只需应用锐化卷积。由于锐化可能非常明显,我们可以将其与图像混合,以便控制锐化水平。希望能提供一些见解。
2021-03-14 04:32:57
这是一个很好的解决方案。我在带有透明区域的 png 文件上进行了尝试。结果如下:jsfiddle.net/confile/5CD4N你知道怎么做才能让它工作吗?
2021-04-06 04:32:57
这是天才!但请你能解释一下你到底在做什么吗?大声笑......我完全想知道来龙去脉......也许是学习资源?
2021-04-08 04:32:57

如果您只想使用画布,最好的结果将是多个步骤。但这还不够好。为了获得更好的质量,您需要纯 js 实现。我们刚刚发布了pica - 具有可变质量/速度的高速降频器。简而言之,它在大约 0.1 秒内调整 1280*1024 像素的大小,并在 1 秒内调整 5000*3000 像素的图像,并具有最高质量(具有 3 个波瓣的 lanczos 过滤器)。Pica 有演示,您可以在其中使用您的图像、质量级别,甚至可以在移动设备上试用。

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

为什么要使用画布来调整图像大小?现代浏览器都使用双三次插值——与 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}           
}

然后只需使用返回值在一个或两个维度上调整图像大小。

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

将以下代码粘贴到此页面的控制台中,然后观察 Gravatars 会发生什么:

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";
});
@Sergiu:没有必要,但请注意,如果您从一个非常小的图像转换为一个非常大的图像,即使从服务器上也不会获得很好的结果。
2021-03-20 04:32:57
另请注意,如果您只指定一个维度,(现代)浏览器将自动保持图像的自然纵横比。
2021-03-21 04:32:57
@Robusto 这就是问题所在。在客户端上显示小图像很容易。img.width nad img.height 是如此微不足道。我只想将它缩小一次,而不是在服务器上再次缩小。
2021-04-01 04:32:57
@Robusto 之后我需要将图像放入画布中,然后将其发送到服务器。我想将大图像缩小为小图像,修改画布中的颜色并将结果发送到服务器。你觉得我该怎么做?
2021-04-05 04:32:57
也许他需要将调整大小的图像发送到服务器。
2021-04-07 04:32:57