मैं अपने HTML5 कैनवास में धुंधले पाठ को कैसे ठीक करूं?


89

मैं एक कुल हूं 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>

मैं ( सफारी में ) जो परिणाम देख रहा हूं, वे फिडेल की तुलना में बहुत अधिक तिरछे हैं।

मेरी

सफारी में आउटपुट दिया गया

बेला

JSFiddle पर प्रस्तुत आउटपुट

मैं गलत क्या कर रहा हूँ? क्या मुझे प्रत्येक पाठ तत्व के लिए एक अलग कैनवास की आवश्यकता है? क्या यह फॉन्ट है? क्या मुझे पहले HTML5 लेआउट में कैनवास को परिभाषित करने की आवश्यकता है? क्या कोई टाइपो है? मै खो गया हूँ।


ऐसा लगता है जैसे आप कॉल नहीं कर रहे हैं clearRect
डेविड

1
यह पॉलीफ़िल HiDPI ब्राउज़र के साथ सबसे बुनियादी कैनवास संचालन को ठीक करता है जो स्वचालित रूप से upscale नहीं करता है (वर्तमान में सफारी केवल एक ही है) ... github.com/jondavidjohn/hidpi-canvas-polyfill
jondubidjohn

मैं एक JS फ्रेमवर्क विकसित कर रहा हूँ जो DIV मोज़ेक के साथ कैनवस ब्लर की समस्या को हल करता है। मैं mem / cpu js2dx.com के
गोंकी

जवाबों:


160

कैनवास तत्व डिवाइस या मॉनिटर के पिक्सेल अनुपात से स्वतंत्र चलता है।

IPad 3+ पर, यह अनुपात 2. है। इसका अनिवार्य रूप से यह अर्थ है कि आपके 1000px चौड़ाई के कैनवास को अब iPad प्रदर्शन पर बताई गई चौड़ाई से मिलान करने के लिए 2000px को भरना होगा। सौभाग्य से हमारे लिए, यह ब्राउज़र द्वारा स्वचालित रूप से किया जाता है। दूसरी ओर, यही कारण है कि आप छवियों और कैनवास तत्वों पर कम परिभाषा देखते हैं जो सीधे उनके दृश्य क्षेत्र को फिट करने के लिए बनाए गए थे। क्योंकि आपका कैनवास केवल 1000px को भरना जानता है, लेकिन 2000px तक आकर्षित करने के लिए कहा जाता है, इसलिए ब्राउज़र को अपने उचित आकार में तत्व प्रदर्शित करने के लिए पिक्सल के बीच रिक्त स्थान को समझदारी से भरना होगा।

मैं आपको अत्यधिक मात्रा में तत्व बनाने के तरीके के बारे में अधिक विस्तार से बताने वाले HTML5Rocks के इस लेख को पढ़ने की अत्यधिक सलाह दूंगा

tl; डॉ? यहाँ एक उदाहरण (उपरोक्त टोट पर आधारित) है, जिसका उपयोग मैं अपनी परियोजनाओं में उचित संकल्प के साथ एक कैनवास को थूकने के लिए करता हूं:

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

उम्मीद है की यह मदद करेगा!


2
सोचा कि यह उल्लेखनीय होगा कि मेरी createHiDPI () पद्धति कुछ हद तक खराब है। DPI केवल प्रिंट के लिए एक शब्द है और PPI एक अधिक उचित संक्षिप्त विवरण है, क्योंकि मॉनिटर पिक्सेल के साथ डॉट्स के विपरीत छवियों का प्रदर्शन करते हैं।
MyNameIsKo

3
ध्यान दें कि यह अनुपात वास्तव में पृष्ठ के जीवनकाल के दौरान बदल सकता है। उदाहरण के लिए, यदि मैं एक पुराने विंडो "मानक" से क्रोम विंडो को खींचता हूं, तो एक मैकबुक की अंतर्निहित रेटिना स्क्रीन में बाहरी मॉनिटर को कोड अलग अनुपात की गणना करेगा। यदि आप इस मूल्य को कैश करने की योजना बना रहे हैं तो बस एक FYI करें। (बाहरी अनुपात 1 था, रेटिना स्क्रीन 2 मामले में आप उत्सुक हैं)
Aardvark

1
इस स्पष्टीकरण के लिए धन्यवाद। लेकिन छवि संपत्ति के बारे में कैसे? क्या हमें दोहरे संकल्प पर प्रत्येक कैनवास छवि की आपूर्ति करने की आवश्यकता है और इसे मैन्युअल रूप से मापना है?
कोकोडोको

1
अधिक सामान्य ज्ञान: Windows Phone 8 का IE हमेशा window.devicePixelRatio के लिए 1 रिपोर्ट करता है (और बैकिंग पिक्सेल कॉल काम नहीं करता है)। 1 पर भयानक लगता है, फिर भी 2 का अनुपात अच्छा दिखता है। अब मेरे अनुपात की गणना के लिए वैसे भी कम से कम 2 (भद्दा वर्कअराउंड) लौटते हैं, लेकिन मेरे लक्ष्य प्लेटफॉर्म आधुनिक फोन हैं जो लगभग सभी उच्च डीपीआई स्क्रीन वाले लगते हैं)। HTC 8X और Lumia 1020 पर परीक्षण किया गया।
Aardvark

1
@Aardvark: ऐसा भी लगता है कि msBackingStorePixelRatio हमेशा अपरिभाषित है। उस बारे में एक नया सवाल पूछा गया: stackoverflow.com/questions/22483296/…
टीवी का फ्रैंक

29

हल किया!

मैंने यह देखने का निर्णय लिया कि मैंने कैनवास की आकार को कैसे प्रभावित किया, यह देखने के लिए मैंने किस चौड़ाई और ऊँचाई की विशेषताओं को बदल दिया 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

1
आदर्श परिणामों के लिए आपको कैनवास की शैली विशेषताओं को बिल्कुल भी नहीं छूना चाहिए और केवल कैनवास की चौड़ाई और ऊंचाई की विशेषताओं के साथ आकार को नियंत्रित करना चाहिए। इस तरह आप यह सुनिश्चित करते हैं कि कैनवास पर एक पिक्सेल स्क्रीन पर एक पिक्सेल के बराबर है।
फिलिप

7
मैं असहमत हूं। Style. उपलब्धता / ऊँचाई विशेषताओं को बदलना बिल्कुल वैसा ही है जब आप HiDPI कैनवास बनाते हैं।
MyNameIsKo

2
आपके उत्तर में, आप कैनवास को 1000 पर सेट करते हैं और 500 पर आधे में कैनवास.स्टाइल.लिफ्ट को सेट करते हैं। यह काम करता है, लेकिन केवल 2 के पिक्सेल अनुपात के साथ एक डिवाइस के लिए। नीचे दी गई किसी भी चीज के लिए, जैसे कि आपका डेस्कटॉप मॉनिटर, कैनवास अब है। अनावश्यक पिक्सेल के लिए ड्राइंग। उच्च अनुपात के लिए आप अब ठीक पीछे हैं जहाँ आपने एक धुंधली, कम रेस परिसंपत्ति / तत्व के साथ शुरुआत की थी। एक और मुद्दा जो फिलिप को अटपटा लग रहा था, वह यह है कि आपके संदर्भ में जो कुछ भी आप आकर्षित करते हैं, उसे अब आपकी दोगुनी चौड़ाई / ऊंचाई तक खींचा जाना चाहिए, भले ही वह उस मूल्य पर आधा प्रदर्शित हो रहा हो। इसे ठीक करने के लिए अपने कैनवास के संदर्भ को दोगुना करना होगा।
MyNameIsKo

3
वहाँ है window.devicePixelRatio, और यह सबसे आधुनिक ब्राउज़रों में अच्छी तरह से लागू है।
चेन

6

मैं मूल तत्व की संपूर्ण चौड़ाई लेने के लिए सीएसएस के माध्यम से कैनवास तत्व का आकार बदलता हूं। मैंने देखा कि मेरे तत्व की चौड़ाई और ऊँचाई को नहीं बढ़ाया गया है। मैं आकार सेट करने के लिए सबसे अच्छा तरीका ढूंढ रहा था जो कि होना चाहिए।

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

इस सरल तरीके से आपका कैनवास पूरी तरह से सेट हो जाएगा, चाहे आप किसी भी स्क्रीन का उपयोग करें।


5

इस 100% ने मेरे लिए इसे हल किया:

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

(यह एडम माकोव्स्की के समाधान के करीब है)।


4

मैंने अन्य उत्तरों में उल्लेखित विवरण पर ध्यान नहीं दिया। कैनवास रिज़ॉल्यूशन पूर्णांक मानों को काट देता है।

डिफ़ॉल्ट कैनवास रिज़ॉल्यूशन आयाम हैं canvas.width: 300और canvas.height: 150

मेरी स्क्रीन पर, window.devicePixelRatio: 1.75

इसलिए जब मैं सेट canvas.height = 1.75 * 150करता हूं तो वांछित वांछित से 262.5नीचे तक काट दिया जाता है 262

एक समाधान के लिए सीएसएस लेआउट आयामों को चुनना है, window.devicePixelRatioजैसे कि रिज़ॉल्यूशन स्केल करने पर ट्रंकेशन नहीं होगा।

उदाहरण के लिए, मैं उपयोग कर सकता हूं width: 300pxऔर height: 152pxजब गुणा करने पर पूरे नंबर मिलेंगे 1.75

संपादित करें : इस तथ्य का लाभ उठाने के लिए एक और समाधान है कि सीएसएस पिक्सल को स्केलिंग कैनवस पिक्सल के ट्रंकेशन का मुकाबला करने के लिए आंशिक किया जा सकता है।

नीचे इस रणनीति का उपयोग करते हुए एक डेमो है।

संपादित करें : यहाँ इस रणनीति का उपयोग करने के लिए ओपी की फ़िडेल को अद्यतन किया गया है: 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>


3

मैंने canvg (SVG to Canvas js पुस्तकालय) के तहत MyNameIsKo कोड को थोड़ा अनुकूलित किया । मैं थोड़ी देर के लिए उलझन में था और इसके लिए कुछ समय बिताता था। आशा है कि यह किसी की मदद करेंगे।

एचटीएमएल

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

जावास्क्रिप्ट

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

}

2

आपके द्वारा अभिक्रिया में काम करने वालों के लिए, मैंने 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}/>
        )
    }
}

इस उदाहरण में, मैं प्रॉपर के रूप में कैनवास की चौड़ाई और ऊंचाई में गुजरता हूं।


2

अपने कैनवास पर CSS की इस एक लाइन को आज़माएं: image-rendering: pixelated

MDN के अनुसार :

छवि को स्केल करते समय, निकटतम-पड़ोसी एल्गोरिथ्म का उपयोग किया जाना चाहिए, ताकि छवि बड़े पिक्सेल से बना प्रतीत हो।

इस प्रकार यह पूरी तरह से एंटी-अलियासिंग को रोकता है।


2

जबकि @ 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संदर्भों को हटा देते हैं, क्योंकि ये वास्तव में किसी भी महत्वपूर्ण तरीके से किसी भी ब्राउज़र में कार्यान्वित नहीं किए जाते हैं (वास्तव में, केवल सफारी के अलावा कुछ undefinedऔर लौटता है , और यह संस्करण अभी भी सफारी में पूरी तरह से काम करता है);
  • हम उस सभी अनुपात कोड को बदल देते हैं window.devicePixelRatio, जिसमें शानदार समर्थन होता है
  • इसका मतलब यह भी है कि हम एक कम वैश्विक संपत्ति की घोषणा करते हैं --- हुर्रे !!
  • हम || 1कमबैक को भी हटा सकते हैं window.devicePixelRatio, क्योंकि यह व्यर्थ है: इस संपत्ति का समर्थन नहीं करने वाले सभी ब्राउज़र .setTransformया .scaleतो समर्थन नहीं करते हैं, इसलिए यह फ़ंक्शन उन पर काम नहीं करेगा, कमबैक या नहीं;
  • हम जगह ले सकता है .setTransformद्वारा .scaleएक चौड़ाई में गुजर के रूप में, और ऊंचाई एक परिवर्तन मैट्रिक्स में गुजर की तुलना में थोड़ा अधिक सहज ज्ञान युक्त है।
  • फ़ंक्शन का नाम बदल दिया गया createHiDPICanvasहै createHiPPICanvas। जैसा कि @MyNameIsKo स्वयं अपने उत्तर की टिप्पणियों में उल्लेख करते हैं, डीपीआई (डॉट्स प्रति इंच) मुद्रण शब्दावली है (जैसे प्रिंटर रंगीन स्याही के छोटे डॉट्स से चित्र बनाते हैं)। इसी तरह, मॉनिटर पिक्सेल का उपयोग करके छवियों को प्रदर्शित करता है, और जैसे कि पीपीआई (पिक्सल प्रति इंच) हमारे उपयोग के मामले के लिए एक बेहतर परिचित है।

इन सरलीकरणों का एक बड़ा लाभ यह है कि इस उत्तर का उपयोग अब टाइपस्क्रिप्ट में किया जा सकता है // @ts-ignore(जैसा कि TS के लिए प्रकार नहीं है backingStorePixelRatio)।


0

मेरे लिए, केवल अलग-अलग 'पिक्सेल परफेक्ट' तकनीकों के संयोजन ने परिणामों को संग्रहीत करने में मदद की:

  1. @MyNameIsKo के रूप में पिक्सेल अनुपात के साथ प्राप्त करें और स्केल करें।

    pixelRatio = window.devicePixelRatio / ctx.backingStorePixelRatio

  2. आकार को कैनवास पर स्केल करें (कैनवास डिफ़ॉल्ट खिंचाव स्केलिंग से बचें)।

  3. उचित 'वास्तविक' पिक्सेल लाइन मोटाई को खोजने के लिए पिक्सेल लाइन के साथ कई लाइनवार्ड:

    reference.lineWidth = मोटाई * pixelRatio;

  4. जांचें कि लाइन की मोटाई विषम है या नहीं। विषम मोटाई मानों के लिए लाइन स्थिति में आधे पिक्सेल जोड़ें।

    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>

आकार बदलने की घटना स्निप में निकाल नहीं दी गई है ताकि आप फ़ाइल को गीथब पर आज़मा सकें


0

मेरे लिए यह केवल छवि नहीं थी, लेकिन पाठ की गुणवत्ता खराब थी। रेटिना / गैर-रेटिना डिस्प्ले के लिए सबसे सरल क्रॉस ब्राउज़र काम कर रहा समाधान छवि को दो बार के रूप में प्रस्तुत करना था, जैसा कि इस आदमी ने सुझाव दिया और बड़े पैमाने पर कैनवास का संदर्भ दिया: https://stackoverflow.com/a/53921030/4837965

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.