HTML5 Canvas Resize(Downscale)Image High Quality?


149

私はhtml5キャンバス要素を使用して、ブラウザーで画像のサイズを変更します。品質が非常に低いことが判明しました。私はこれを見つけました:<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画像:

フォトショップ画像

GameAlchemistのアルゴリズム:

GameAlchemistのアルゴリズム


2
あなたのイメージをスケーリングインクリメンタルに試してみてください:stackoverflow.com/questions/18761404/...
Markeの

1
可能性のある重複のHTML5キャンバスのdrawImage:アンチエイリアスを適用する方法。それが機能しないかどうかを確認します。画像が大きく、小さいサイズに縮小されている場合は、段階的に行う必要があります(リンクのサンプル画像を参照)

2
@confileで補間をオフにすると、最悪になります。これを有効にしておく必要があります。上記で提供したリンクを見てください。大きな画像を縮小して品質を維持するための手順を使用する方法を示します。スコットが言うように、スピードよりも品質を優先したいのです。

1
@ Ken-AbdiasSoftwareアプローチを試してみましたが、問題は、ステップワイズスケーリングに使用するラウンド数が増えると悪化することです。それを修正する方法はありますか?
confile 2013

3
確かに、HTML5を使用して高価なプロの写真編集ソフトウェアの機能を複製する可能性はかなり少ないでしょう。おそらく近くにありますが、Photoshopで機能するのとまったく同じとは思えません。
Liam

回答:


171

あなたの問題は画像を縮小することなので、補間について話すことは意味がありません-それはピクセルの作成についてです-。ここでの問題は、ダウンサンプリングです。

画像をダウンサンプリングするには、元の画像のp * pピクセルの各正方形を宛先画像の単一のピクセルに変換する必要があります。

パフォーマンス上の理由から、ブラウザは非常に単純なダウンサンプリングを行います。小さい画像を構築するために、ブラウザはソースで1つのピクセルを選択し、その値を宛先に使用します。これは、いくつかの詳細を「忘れ」、ノイズを追加します。

ただし、これには例外があります。2X画像のダウンサンプリングは非常に簡単に計算でき(1つを作成するには平均4ピクセル)、網膜/ HiDPIピクセルに使用されるため、このケースは適切に処理されます。ブラウザは4ピクセルを使用して1-。

しかし、2倍のダウンサンプリングを数回使用すると、連続する丸め誤差によってノイズが多くなりすぎるという問題に直面します。
さらに悪いことに、常に2の累乗でサイズ変更されるわけではなく、最も近い累乗にサイズ変更する+最後のサイズ変更は非常にうるさいです。

求めているのは、ピクセルパーフェクトなダウンサンプリングです。つまり、すべての入力ピクセルを考慮に入れて、スケールを問わずに画像をリサンプリングします。
そのためには、入力ピクセルごとに、スケーリングされた入力ピクセルの投影が宛先ピクセルの内側にあるか、X境界、Y境界、またはその両方に重なっているかに応じて、1、2、または4つの宛先ピクセルへの寄与を計算する必要があります。 。
(スキームはここではいいですが、私は持っていません。)

以下は、ゾンバの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ミリ秒かかります。


キャンバスに配置する前に画像を拡大縮小すると、より速くなりますか?
confile 2013年

わかりません...それは私がやっていることのようです。バッファーとiキャンバス(resCV)は、スケーリングされたイメージのサイズを持ちます。それを速くする唯一の方法は、ブレシェンサムのような整数計算を使用することだと思います。ただし、40msはビデオゲーム(25 fps)の場合のみ遅く、描画アプリケーションの場合は遅くありません。
GameAlchemist 2013年

品質を維持しながらアルゴリズムを高速化するチャンスはありますか?
confile 2013年

1
私は0を使用してバッファ(アルゴリズムの最新の部分)を丸めようとしました| Mat.ceilの代わりに。少し速いです。しかし、いずれにしても、get / putImageDataにはかなりのオーバーヘッドがあり、ここでも各ピクセルの処理を回避できません。
GameAlchemist 2013年

4
わかりました、それで私はコードを見ました:あなたは解決策から非常に近かったです。2つの間違い:インデックスがtX + 1で1つずれていました(+ 4、+ 5、+ 6、+ 7ではなく+ 3、+ 4、+ 5、+ 6でした)。rgbaで行を変更することは問題です3ではなく4でテストしました。チェックする4つのランダムな値(0.1、0.15、0.33、0.8)をテストしただけで、問題はないようです。更新されたフィドルはここにあります:jsfiddle.net/gamealchemist/kpQyE/3
GameAlchemist

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);
}

最高の品質が必要
2013年

18
修正し、「良い」を「最高」に変更しました。これで大丈夫ですか?:D 一方、可能な限り最適なリサンプルが必要な場合は、imagemagickを使用してください。
ViliusL 2013年

@confile imgur.comはjsfiddleで安全に使用できましたが、管理者は何か間違ったことをしましたか?ブラウザーがCORSに致命的なエラーを与えるため、品質は良くありません。(リモートサイトの画像は使用できません)
ViliusL 2014

透明な領域を持つ他のPNG画像を使用できます。これについて何か考えはありますか?
confile

4
@confileあなたは正しかった、いくつかのケースで透明な画像はシャープな領域に問題がありました。テストでこれらのケースを見逃しました。サイズ変更の修正、フィドルのリモート画像サポートの修正:jsfiddle.net/9g9Nv/49
ViliusL

28

提案1-プロセスパイプラインを拡張する

あなたが参照しているリンクで説明しているようにステップダウンを使用できますが、それらを間違った方法で使用しているように見えます。

画像を1:2を超える比率に拡大縮小するためにステップダウンは必要ありません(通常、これに限定されません)。これは、画像のコンテンツに応じて2段階(まれに、それ以上)のステップに分割する必要がある大幅なダウンスケーリングを行う必要がある場所です(特に、細い線などの高周波が発生する場合)。

画像をダウンサンプリングするたびに、詳細や情報が失われます。結果の画像が元の画像ほど鮮明であるとは期待できません。

その後、多くの手順で画像を縮小すると、合計で多くの情報が失われ、すでに気づいたように結果は良くありません。

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よりも優れたパフォーマンスを実現できます。

紙からのスナップショット

(すべての詳細、式などについては、提供されているリンクを参照してください。)


これも素晴らしい解決策です。ありがとうございました!
confile

これは素晴らしいソリューションです。透明な領域のあるpngファイルで試してみました。結果は次のとおりです。jsfiddle.net / confile / 5CD4Nこれを機能させるために何をすべきか考えていますか?
confile 2014

1
これは天才です!しかし、あなたが正確に何をしているのか説明してもらえますか?笑..私は完全にインとアウトを知りたいです...多分学ぶためのリソース?
carinlynchin 2016年

1
@Carineは、コメントフィールドが不十分な場合には少し多くなる可能性がありますが、縮小すると、ピクセルのグループをリサンプルして、そのグループを表す新しいピクセルを平均化します。これは事実上、全体的にぼかしを導入するローパスフィルターです。シャープネスの損失を補正するには、シャープ化畳み込みを適用するだけです。シャープネスが非常に目立つ場合があるため、代わりに画像と混合してシャープネスのレベルを制御できます。それがいくつかの洞察を与えることを願っています。

21

キャンバスのみを使用する場合は、複数のダウンステップを使用するのが最良の結果です。しかし、それはまだ良い考えではありません。品質を高めるには、純粋なjs実装が必要です。私達はちょうどリリースさパイカ変数品質/速度で高速ダウンスケーラを- 。つまり、最高で1280 * 1024ピクセル(0.1秒以内)と5000 * 3000ピクセル(1秒以内)の画像を最高品質(3ローブのランチョスフィルター)でサイズ変更します。Picaにはデモがあり、画像や品質レベルで遊んだり、モバイルデバイスで試してみることができます。

ピカにはまだアンシャープマスクがありませんが、すぐに追加されます。これは、サイズ変更用の高速畳み込みフィルターを実装するよりもはるかに簡単です。


16

キャンバスを使用して画像のサイズを変更する理由 最近のブラウザーはすべて、バイキュービック補間(Photoshopで使用されているのと同じプロセス(正しく実行している場合))を使用しており、キャンバスプロセスよりも高速です。必要な画像サイズを指定するだけです(高さまたは幅の1つの寸法のみを使用して、比例してサイズを変更します)。

これは、IEの新しいバージョンを含むほとんどのブラウザーでサポートされています。以前のバージョンでは、ブラウザ固有のCSSが必要な場合があります。

画像のサイズを変更する簡単な関数(jQueryを使用)は次のようになります。

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

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

次に、返された値を使用して、画像のサイズを1つまたは両方のサイズに変更します。

明らかに、さまざまな改良が可能ですが、これで仕事が完了します。

次のコードをこのページのコンソールに貼り付けて、グラバーターがどうなるかを見てください。

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
また、1つの寸法のみを指定すると、(モダン)ブラウザーは自動的に画像の本来のアスペクト比を維持します。
アンドレ・ディオン

38
たぶん彼はサイズを変更した画像をサーバーに送信する必要があります。
セルジュパラシフ2013年

2
@Sergiu:必要ありませんが、非常に小さな画像から非常に大きな画像に変更する場合、サーバーからでも素晴らしい結果が得られないことに注意してください。
ロブスト

2
@Robusto後でキャンバスに画像を配置して、後でサーバーに送信する必要があります。大きな画像を小さな画像に縮小し、キャンバスで色を変更して、結果をサーバーに送信したいと思います。私は何をすべきだと思いますか?
2013年

9
@Robustoこれが問題です。クライアントに小さな画像を表示するのは簡単です。img.width nad img.heightは非常に簡単です。サーバー上では1度だけ縮小し、再度縮小しないでください。
confile

8

画像自体のサイズを実際に変更する必要がある人にとっては正しい答えではなく、ファイルサイズを縮小するだけです

私の顧客が「非圧縮」JPEGでアップロードすることが多い「カメラから直接」の写真に問題がありました。

あまり知られていないのは、キャンバスがJPEGの品質を変更することをサポートすることです(ほとんどのブラウザー2017)

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

このトリックで、> 10Mbの4k x 3k写真を1Mbまたは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

これは、ウィンドウがフリーズしないように1人のワーカーを利用する改良されたHermiteサイズ変更フィルターです。

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とその結果の画像を投稿してください。
confile、2014

下部にあるリンクであなたはこの技術を用いて結果の画像を見つけることができます
ヘスス・カレラ

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

特に大きな画像では、画像データの実行を避けようとしています。したがって、いくつかの追加の手順を使用して、制限や制限なしに画像サイズをきちんと縮小するかなり簡単な方法を考え出しました。このルーチンは、目的のターゲットサイズの前に、可能な限り低いハーフステップまで進みます。次に、ターゲットサイズの2倍に拡大し、次に半分に拡大します。最初はおかしいように聞こえますが、結果は驚くほど良く、すばやくそこに行きます。

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 Demoフィドラーで画像のサイズを変更します。

このサイズ変更を行う3つの異なる方法があり、コードがどのように機能し、その理由を理解するのに役立ちます。

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

デモの完全なコードと、コードで使用するTypeScriptメソッドは、GitHubプロジェクトにあります。

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
        }
    };
}}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.