102

私は合計n00bで、図形、色、テキストをレンダリングするためHTML5に作業しています。canvas私のアプリには、キャンバスを動的に作成し、コンテンツで埋めるビューアダプターがあります。これは、私のテキストが非常にぼやけている/ぼやけている/引き伸ばされていることを除いて、本当にうまく機能します。で幅高さCSS定義するとこの問題が発生する理由について、他にも多くの投稿を見てきましたが、すべてをで定義していますjavascript

関連するコード(フィドルを表示):

var width  = 500;//FIXME:size.w;
var height = 500;//FIXME:size.h;
    
var canvas = document.createElement("canvas");
//canvas.className="singleUserCanvas";
canvas.width=width;
canvas.height=height;
canvas.border = "3px solid #999999";
canvas.bgcolor = "#999999";
canvas.margin = "(0, 2%, 0, 2%)";
    
var context = canvas.getContext("2d");

//////////////////
////  SHAPES  ////
//////////////////
    
var left = 0;

//draw zone 1 rect
context.fillStyle = "#8bacbe";
context.fillRect(0, (canvas.height*5/6)+1, canvas.width*1.5/8.5, canvas.height*1/6);

left = left + canvas.width*1.5/8.5;

//draw zone 2 rect
context.fillStyle = "#ffe381";
context.fillRect(left+1, (canvas.height*5/6)+1, canvas.width*2.75/8.5, canvas.height*1/6);

left = left + canvas.width*2.75/8.5 + 1;

//draw zone 3 rect
context.fillStyle = "#fbbd36";
context.fillRect(left+1, (canvas.height*5/6)+1, canvas.width*1.25/8.5, canvas.height*1/6);

left = left + canvas.width*1.25/8.5;

//draw target zone rect
context.fillStyle = "#004880";
context.fillRect(left+1, (canvas.height*5/6)+1, canvas.width*0.25/8.5, canvas.height*1/6);

left = left + canvas.width*0.25/8.5;
    
//draw zone 4 rect
context.fillStyle = "#f8961d";
context.fillRect(left+1, (canvas.height*5/6)+1, canvas.width*1.25/8.5, canvas.height*1/6);

left = left + canvas.width*1.25/8.5 + 1;

//draw zone 5 rect
context.fillStyle = "#8a1002";
context.fillRect(left+1, (canvas.height*5/6)+1, canvas.width-left, canvas.height*1/6);

////////////////
////  TEXT  ////
////////////////

//user name
context.fillStyle = "black";
context.font = "bold 18px sans-serif";
context.textAlign = 'right';
context.fillText("User Name", canvas.width, canvas.height*.05);

//AT:
context.font = "bold 12px sans-serif";
context.fillText("AT: 140", canvas.width, canvas.height*.1);

//AB:
context.fillText("AB: 94", canvas.width, canvas.height*.15);
       
//this part is done after the callback from the view adapter, but is relevant here to add the view back into the layout.
var parent = document.getElementById("layout-content");
parent.appendChild(canvas);
<div id="layout-content"></div>

私が(Safariで)見ている結果は、フィドルに示されているよりもはるかに歪んでいます:

私の

Safariでレンダリングされた出力

フィドル

JSFiddleでレンダリングされた出力

私は間違って何をしていますか?テキスト要素ごとに個別のキャンバスが必要ですか?フォントですか?最初にHTML5レイアウトでキャンバスを定義する必要がありますか?タイプミスはありますか?迷っています。

4

12 に答える 12

178

キャンバス要素は、デバイスまたはモニターのピクセル比とは無関係に実行されます。

iPad 3+では、この比率は2です。これは基本的に、1000px幅のキャンバスがiPadディスプレイに表示されている幅と一致するように2000pxを埋める必要があることを意味します。幸いなことに、これはブラウザによって自動的に行われます。一方、これは、表示領域に直接フィットするように作成された画像やキャンバス要素の鮮明度が低くなる理由でもあります。キャンバスは1000pxを埋める方法しか知らないが、2000pxに描画するように求められるため、ブラウザは、要素を適切なサイズで表示するために、ピクセル間の空白をインテリジェントに埋める必要があります。

高解像度要素を作成する方法をより詳細に説明しているHTML5Rocksのこの記事を読むことを強くお勧めします。

tl; dr?これは、適切な解像度でキャンバスを吐き出すために自分のプロジェクトで使用する例(上記のツタンカーメンに基づく)です。

var PIXEL_RATIO = (function () {
    var ctx = document.createElement("canvas").getContext("2d"),
        dpr = window.devicePixelRatio || 1,
        bsr = ctx.webkitBackingStorePixelRatio ||
              ctx.mozBackingStorePixelRatio ||
              ctx.msBackingStorePixelRatio ||
              ctx.oBackingStorePixelRatio ||
              ctx.backingStorePixelRatio || 1;

    return dpr / bsr;
})();


createHiDPICanvas = function(w, h, ratio) {
    if (!ratio) { ratio = PIXEL_RATIO; }
    var can = document.createElement("canvas");
    can.width = w * ratio;
    can.height = h * ratio;
    can.style.width = w + "px";
    can.style.height = h + "px";
    can.getContext("2d").setTransform(ratio, 0, 0, ratio, 0, 0);
    return can;
}

//Create canvas with the device resolution.
var myCanvas = createHiDPICanvas(500, 250);

//Create canvas with a custom resolution.
var myCustomCanvas = createHiDPICanvas(500, 200, 4);

お役に立てれば!

于 2013-03-27T18:03:36.770 に答える
32

解決しました!

設定した幅高さの属性を変更してjavascript、それがキャンバスのサイズにどのように影響するかを確認することにしましたが、影響はありませんでした。解像度を変更します。

必要な結果を得るには、canvas.style.width属性を設定する必要がありました。これにより、canvas:の物理的なサイズが変更されます。

canvas.width=1000;//horizontal resolution (?) - increase for better looking text
canvas.height=500;//vertical resolution (?) - increase for better looking text
canvas.style.width=width;//actual width of canvas
canvas.style.height=height;//actual height of canvas
于 2013-03-27T14:44:49.737 に答える
14

@MyNameIsKoの回答は引き続き機能しますが、2020年には少し古くなっており、改善することができます。

function createHiPPICanvas(w, h) {
    let ratio = window.devicePixelRatio;
    let cv = document.createElement("canvas");
    cv.width = w * ratio;
    cv.height = h * ratio;
    cv.style.width = w + "px";
    cv.style.height = h + "px";
    cv.getContext("2d").scale(ratio, ratio);
    return cv;
}

一般的に、次の改善を行います。

  • 参照はどのブラウザにも重要な方法で実装されていないため、削除しbackingStorePixelRatioます(実際、Safariのみが以外のものを返しますundefined。このバージョンはSafariでも完全に機能します)。
  • window.devicePixelRatioその比率コードをすべて、素晴らしいサポートを備えたに置き換えます
  • これは、グローバルプロパティが1つ少ないことを宣言することも意味します--- hooray !!
  • || 1のフォールバックを削除することもできますwindow.devicePixelRatio。これは無意味です。このプロパティをサポートしていないすべてのブラウザはサポートしていないか、どちらかをサポートしていないため.setTransform.scaleフォールバックの有無にかかわらず、この関数は機能しません。
  • .setTransform幅と高さ.scaleを渡す方が変換行列を渡すよりも少し直感的であるため、で置き換えることができます。
  • 関数の名前がからcreateHiDPICanvasに変更されましたcreateHiPPICanvas。@MyNameIsKo自身が回答のコメントで言及しているように、DPI(Dots per Inch)は印刷用語です(プリンターは色付きのインクの小さな点から画像を作成するため)。同様ですが、モニターはピクセルを使用して画像を表示するため、PPI(Pixels per Inch)は私たちのユースケースの頭字語として適しています。

これらの単純化の大きな利点の1つは、この回答をTypeScriptで使用できるようになったことです// @ts-ignore(TSにはのタイプがないためbackingStorePixelRatio)。

于 2020-12-03T11:16:39.027 に答える
8

この100%は私のためにそれを解決しました:

var canvas = document.getElementById('canvas');
canvas.width = canvas.getBoundingClientRect().width;
canvas.height = canvas.getBoundingClientRect().height;

(これはAdamMańkowskiのソリューションに近いです)。

于 2018-01-17T19:56:40.433 に答える
7

cssを使用してcanvas要素のサイズを変更し、親要素の幅全体を取得します。要素の幅と高さがスケーリングされていないことに気づきました。サイズを設定する最良の方法を探していました。

canvas.width = canvas.clientWidth;
canvas.height = canvas.clientHeight;

使用する画面に関係なく、この簡単な方法でキャンバスを完全に設定できます。

于 2016-08-27T13:30:45.587 に答える
6

キャンバスでこの1行のCSSを試してください。 image-rendering: pixelated

MDNによると:

画像を拡大するときは、画像が大きなピクセルで構成されているように見えるように、最近傍アルゴリズムを使用する必要があります。

したがって、アンチエイリアシングを完全に防ぎます。

于 2019-05-31T11:20:42.063 に答える
5

他の回答に記載されていない詳細に気づきました。キャンバスの解像度は整数値に切り捨てられます。

デフォルトのキャンバス解像度の寸法はとcanvas.width: 300ですcanvas.height: 150

私の画面では、window.devicePixelRatio: 1.75

したがって、設定canvas.height = 1.75 * 150すると、値は目的の値からに切り捨てられ262.5ます262

window.devicePixelRatio解決策は、解像度のスケーリング時に切り捨てが発生しないように、特定のCSSレイアウトの寸法を選択することです。

たとえば、を使用するwidth: 300pxと、height: 152pxを掛けると整数が得られ1.75ます。

編集:別の解決策は、CSSピクセルが分数である可能性があるという事実を利用して、スケーリングキャンバスピクセルの切り捨てを打ち消すことです。

以下は、この戦略を使用したデモです。

編集:この戦略を使用するために更新されたOPのフィドルは次のとおりです:http://jsfiddle.net/65maD/83/

main();

// Rerun on window resize.
window.addEventListener('resize', main);


function main() {
  // Prepare canvas with properly scaled dimensions.
  scaleCanvas();

  // Test scaling calculations by rendering some text.
  testRender();
}


function scaleCanvas() {
  const container = document.querySelector('#container');
  const canvas = document.querySelector('#canvas');

  // Get desired dimensions for canvas from container.
  let {width, height} = container.getBoundingClientRect();

  // Get pixel ratio.
  const dpr = window.devicePixelRatio;
  
  // (Optional) Report the dpr.
  document.querySelector('#dpr').innerHTML = dpr.toFixed(4);

  // Size the canvas a bit bigger than desired.
  // Use exaggeration = 0 in real code.
  const exaggeration = 20;
  width = Math.ceil (width * dpr + exaggeration);
  height = Math.ceil (height * dpr + exaggeration);

  // Set the canvas resolution dimensions (integer values).
  canvas.width = width;
  canvas.height = height;

  /*-----------------------------------------------------------
                         - KEY STEP -
   Set the canvas layout dimensions with respect to the canvas
   resolution dimensions. (Not necessarily integer values!)
   -----------------------------------------------------------*/
  canvas.style.width = `${width / dpr}px`;
  canvas.style.height = `${height / dpr}px`;

  // Adjust canvas coordinates to use CSS pixel coordinates.
  const ctx = canvas.getContext('2d');
  ctx.scale(dpr, dpr);
}


function testRender() {
  const canvas = document.querySelector('#canvas');
  const ctx = canvas.getContext('2d');
  
  // fontBaseline is the location of the baseline of the serif font
  // written as a fraction of line-height and calculated from the top
  // of the line downwards. (Measured by trial and error.)
  const fontBaseline = 0.83;
  
  // Start at the top of the box.
  let baseline = 0;

  // 50px font text
  ctx.font = `50px serif`;
  ctx.fillText("Hello World", 0, baseline + fontBaseline * 50);
  baseline += 50;

  // 25px font text
  ctx.font = `25px serif`;
  ctx.fillText("Hello World", 0, baseline + fontBaseline * 25);
  baseline += 25;

  // 12.5px font text
  ctx.font = `12.5px serif`;
  ctx.fillText("Hello World", 0, baseline + fontBaseline * 12.5);
}
/* HTML is red */

#container
{
  background-color: red;
  position: relative;
  /* Setting a border will mess up scaling calculations. */
  
  /* Hide canvas overflow (if any) in real code. */
  /* overflow: hidden; */
}

/* Canvas is green */ 

#canvas
{
  background-color: rgba(0,255,0,.8);
  animation: 2s ease-in-out infinite alternate both comparison;
}

/* animate to compare HTML and Canvas renderings */

@keyframes comparison
{
  33% {opacity:1; transform: translate(0,0);}
  100% {opacity:.7; transform: translate(7.5%,15%);}
}

/* hover to pause */

#canvas:hover, #container:hover > #canvas
{
  animation-play-state: paused;
}

/* click to translate Canvas by (1px, 1px) */

#canvas:active
{
  transform: translate(1px,1px) !important;
  animation: none;
}

/* HTML text */

.text
{
  position: absolute;
  color: white;
}

.text:nth-child(1)
{
  top: 0px;
  font-size: 50px;
  line-height: 50px;
}

.text:nth-child(2)
{
  top: 50px;
  font-size: 25px;
  line-height: 25px;
}

.text:nth-child(3)
{
  top: 75px;
  font-size: 12.5px;
  line-height: 12.5px;
}
<!-- Make the desired dimensions strange to guarantee truncation. -->
<div id="container" style="width: 313.235px; height: 157.122px">
  <!-- Render text in HTML. -->
  <div class="text">Hello World</div>
  <div class="text">Hello World</div>
  <div class="text">Hello World</div>
  
  <!-- Render text in Canvas. -->
  <canvas id="canvas"></canvas>
</div>

<!-- Interaction instructions. -->
<p>Hover to pause the animation.<br>
Click to translate the green box by (1px, 1px).</p>

<!-- Color key. -->
<p><em style="color:red">red</em> = HTML rendered<br>
<em style="color:green">green</em> = Canvas rendered</p>

<!-- Report pixel ratio. -->
<p>Device pixel ratio: <code id="dpr"></code>
<em>(physical pixels per CSS pixel)</em></p>

<!-- Info. -->
<p>Zoom your browser to re-run the scaling calculations.
(<code>Ctrl+</code> or <code>Ctrl-</code>)</p>

于 2019-01-03T17:48:39.593 に答える
3

canvg(SVGからCanvas jsライブラリ)の下でMyNameIsKoコードを少し変更しました。私はしばらく混乱し、これにしばらく時間を費やしました。これが誰かを助けることを願っています。

HTML

<div id="chart"><canvas></canvas><svg>Your SVG here</svg></div>

Javascript

window.onload = function() {

var PIXEL_RATIO = (function () {
    var ctx = document.createElement("canvas").getContext("2d"),
        dpr = window.devicePixelRatio || 1,
        bsr = ctx.webkitBackingStorePixelRatio ||
              ctx.mozBackingStorePixelRatio ||
              ctx.msBackingStorePixelRatio ||
              ctx.oBackingStorePixelRatio ||
              ctx.backingStorePixelRatio || 1;

    return dpr / bsr;
})();

setHiDPICanvas = function(canvas, w, h, ratio) {
    if (!ratio) { ratio = PIXEL_RATIO; }
    var can = canvas;
    can.width = w * ratio;
    can.height = h * ratio;
    can.style.width = w + "px";
    can.style.height = h + "px";
    can.getContext("2d").setTransform(ratio, 0, 0, ratio, 0, 0);
}

var svg = document.querySelector('#chart svg'),
    canvas = document.querySelector('#chart canvas');

var svgSize = svg.getBoundingClientRect();
var w = svgSize.width, h = svgSize.height;
setHiDPICanvas(canvas, w, h);

var svgString = (new XMLSerializer).serializeToString(svg);
var ctx = canvas.getContext('2d');
ctx.drawSvg(svgString, 0, 0, w, h);

}
于 2016-11-12T04:01:39.353 に答える
2

reactjsで作業している方のために、MyNameIsKoの回答を採用しましたが、うまく機能しています。これがコードです。

import React from 'react'

export default class CanvasComponent extends React.Component {
    constructor(props) {
        this.calcRatio = this.calcRatio.bind(this);
    } 

    // Use componentDidMount to draw on the canvas
    componentDidMount() {  
        this.updateChart();
    }

    calcRatio() {
        let ctx = document.createElement("canvas").getContext("2d"),
        dpr = window.devicePixelRatio || 1,
        bsr = ctx.webkitBackingStorePixelRatio ||
          ctx.mozBackingStorePixelRatio ||
          ctx.msBackingStorePixelRatio ||
          ctx.oBackingStorePixelRatio ||
          ctx.backingStorePixelRatio || 1;
        return dpr / bsr;
    }

    // Draw on the canvas
    updateChart() {

        // Adjust resolution
        const ratio = this.calcRatio();
        this.canvas.width = this.props.width * ratio;
        this.canvas.height = this.props.height * ratio;
        this.canvas.style.width = this.props.width + "px";
        this.canvas.style.height = this.props.height + "px";
        this.canvas.getContext("2d").setTransform(ratio, 0, 0, ratio, 0, 0);
        const ctx = this.canvas.getContext('2d');

       // now use ctx to draw on the canvas
    }


    render() {
        return (
            <canvas ref={el=>this.canvas=el} width={this.props.width} height {this.props.height}/>
        )
    }
}

この例では、キャンバスの幅と高さを小道具として渡します。

于 2018-04-23T15:24:35.327 に答える
0

私にとって、結果をアーカイブするのに役立ったのは、さまざまな「ピクセルパーフェクト」テクニックの組み合わせだけでした。

  1. @MyNameIsKoが提案したように、ピクセル比で取得してスケーリングします。

    pixelRatio = window.devicePixelRatio / ctx.backingStorePixelRatio

  2. サイズ変更時にキャンバスをスケーリングします(キャンバスのデフォルトのストレッチスケーリングは避けてください)。

  3. lineWidthにpixelRatioを掛けて、適切な「実際の」ピクセル線の太さを見つけます。

    context.lineWidth=厚さ*pixelRatio;

  4. 線の太さが奇数か偶数かを確認してください。奇数の太さの値の線の位置にpixelRatioの半分を追加します。

    x = x + pixelRatio / 2;

奇数の線はピクセルの中央に配置されます。上記の行は、少し移動するために使用されます。

function getPixelRatio(context) {
  dpr = window.devicePixelRatio || 1,
    bsr = context.webkitBackingStorePixelRatio ||
    context.mozBackingStorePixelRatio ||
    context.msBackingStorePixelRatio ||
    context.oBackingStorePixelRatio ||
    context.backingStorePixelRatio || 1;

  return dpr / bsr;
}


var canvas = document.getElementById('canvas');
var context = canvas.getContext("2d");
var pixelRatio = getPixelRatio(context);
var initialWidth = canvas.clientWidth * pixelRatio;
var initialHeight = canvas.clientHeight * pixelRatio;


window.addEventListener('resize', function(args) {
  rescale();
  redraw();
}, false);

function rescale() {
  var width = initialWidth * pixelRatio;
  var height = initialHeight * pixelRatio;
  if (width != context.canvas.width)
    context.canvas.width = width;
  if (height != context.canvas.height)
    context.canvas.height = height;

  context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
}

function pixelPerfectLine(x) {

  context.save();
  context.beginPath();
  thickness = 1;
  // Multiple your stroke thickness  by a pixel ratio!
  context.lineWidth = thickness * pixelRatio;

  context.strokeStyle = "Black";
  context.moveTo(getSharpPixel(thickness, x), getSharpPixel(thickness, 0));
  context.lineTo(getSharpPixel(thickness, x), getSharpPixel(thickness, 200));
  context.stroke();
  context.restore();
}

function pixelPerfectRectangle(x, y, w, h, thickness, useDash) {
  context.save();
  // Pixel perfect rectange:
  context.beginPath();

  // Multiple your stroke thickness by a pixel ratio!
  context.lineWidth = thickness * pixelRatio;
  context.strokeStyle = "Red";
  if (useDash) {
    context.setLineDash([4]);
  }
  // use sharp x,y and integer w,h!
  context.strokeRect(
    getSharpPixel(thickness, x),
    getSharpPixel(thickness, y),
    Math.floor(w),
    Math.floor(h));
  context.restore();
}

function redraw() {
  context.clearRect(0, 0, canvas.width, canvas.height);
  pixelPerfectLine(50);
  pixelPerfectLine(120);
  pixelPerfectLine(122);
  pixelPerfectLine(130);
  pixelPerfectLine(132);
  pixelPerfectRectangle();
  pixelPerfectRectangle(10, 11, 200.3, 443.2, 1, false);
  pixelPerfectRectangle(41, 42, 150.3, 443.2, 1, true);
  pixelPerfectRectangle(102, 100, 150.3, 243.2, 2, true);
}

function getSharpPixel(thickness, pos) {

  if (thickness % 2 == 0) {
    return pos;
  }
  return pos + pixelRatio / 2;

}

rescale();
redraw();
canvas {
  image-rendering: -moz-crisp-edges;
  image-rendering: -webkit-crisp-edges;
  image-rendering: pixelated;
  image-rendering: crisp-edges;
  width: 100vh;
  height: 100vh;
}
<canvas id="canvas"></canvas>

サイズ変更イベントはスニップで発生しないため、 githubでファイルを試すことができます

于 2019-07-11T21:36:06.357 に答える
0

私にとっては、画像だけでなくテキストの品質も悪かった。Retina / Non-Retinaディスプレイ用の最も単純なクロスブラウザ作業ソリューションは、画像を意図した2倍の大きさにレンダリングし、この男が提案したようにキャンバスコンテキストを拡大縮小することでした:https ://stackoverflow.com/a/53921030/4837965

于 2020-09-11T14:16:50.347 に答える
0

次のコードは私のために直接機能しました(他のコードは機能しませんでした):

    const myCanvas = document.getElementById("myCanvas");
    const originalHeight = myCanvas.height;
    const originalWidth = myCanvas.width;
    render();
    function render() {
      let dimensions = getObjectFitSize(
        true,
        myCanvas.clientWidth,
        myCanvas.clientHeight,
        myCanvas.width,
        myCanvas.height
      );
      const dpr = window.devicePixelRatio || 1;
      myCanvas.width = dimensions.width * dpr;
      myCanvas.height = dimensions.height * dpr;

      let ctx = myCanvas.getContext("2d");
      let ratio = Math.min(
        myCanvas.clientWidth / originalWidth,
        myCanvas.clientHeight / originalHeight
      );
      ctx.scale(ratio * dpr, ratio * dpr); //adjust this!
    }

    // adapted from: https://www.npmjs.com/package/intrinsic-scale
    function getObjectFitSize(
      contains /* true = contain, false = cover */,
      containerWidth,
      containerHeight,
      width,
      height
    ) {
      var doRatio = width / height;
      var cRatio = containerWidth / containerHeight;
      var targetWidth = 0;
      var targetHeight = 0;
      var test = contains ? doRatio > cRatio : doRatio < cRatio;

      if (test) {
        targetWidth = containerWidth;
        targetHeight = targetWidth / doRatio;
      } else {
        targetHeight = containerHeight;
        targetWidth = targetHeight * doRatio;
      }

      return {
        width: targetWidth,
        height: targetHeight,
        x: (containerWidth - targetWidth) / 10,
        y: (containerHeight - targetHeight) / 10
      };
    }

実装は、このMediumの投稿から採用されました。

于 2021-05-30T17:50:27.847 に答える