1. Einführung in Canvas

​<canvas>JaHTML5Neu hinzugefügt, eines, das Skripte verwenden kann (normalerweiseJavaScript) zum Zeichnen von Bildern inHTMLElement.

Es wurde ursprünglich von Apple intern unter Verwendung seines eigenenMacOS X WebKiteingeführt, damit Anwendungen Komponenten wie Dashboard undSafariBrowser-Nutzung. Später, jemand durchGeckoKernel-Browser (insbesondereMozillaundFirefox),OperaundChromeund die Web Hypertext Application Technology Working Group schlug vor, dieses Element für Web-Technologien der nächsten Generation zu verwenden.

​CanvasistHTMLein durch Code definierter Zeichenbereich zusammen mit den Attributen height und width.JavaScriptCode kann auf diesen Bereich zugreifen, ähnlich wie bei anderen generischen zweidimensionalenAPI, durch einen vollständigen Satz von Zeichenfunktionen, um dynamisch Grafiken zu erzeugen.

Mozilla-Programme unterstützen es seit Gecko 1.8 (Firefox 1.5)<canvas>, Internet Explorer ab IE9<canvas>. Chrome und Opera 9+ unterstützen es ebenfalls<canvas>。


2. Grundlegende Verwendung von Canvas

<canvas id="tutorial" width="300" height="300"></canvas>

2.1 <canvas>Element

​<canvas>sieht genauso aus wie<img>das Tag, außer dass<canvas>hat nur zwei optionale Attributewidth、heigthAttribute, und keinesrc、altAttribute hinzu.

Wenn Sie nicht<canvas>setwidht、heightdie Attribute, dann standardmäßigwidthist 300,heightist 150, und die Einheiten sind allepx. Du kannst auchcssAttribute zum Festlegen von Breite und Höhe, aber wenn die Attribute width und height nicht mit dem ursprünglichen Seitenverhältnis übereinstimmen, wird es verzerrt. Daher wird empfohlen, niemalscssAttribute zu verwenden, um<canvas>die Breite und Höhe festzulegen.

Ersatzinhalt

Da einige ältere Browser (insbesondere IE-Browser vor IE9) oder Browser das HTML-Element nicht unterstützen<canvas>, sollten Sie in diesen Browsern den Ersatzinhalt anzeigen können.

Unterstützende<canvas>Browser werden nur<canvas>das Tag rendern und den darin enthaltenen Ersatzinhalt ignorieren. Browser, die nicht unterstützen<canvas>werden den Ersatzinhalt direkt rendern.

Durch Text ersetzen:

<canvas>
    你的浏览器不支持 canvas,请升级你的浏览器。
</canvas>

Verwenden Sie<img>Ersatz:

<canvas>
    <img src="./美女.jpg.html" alt=""> 
</canvas>

Das schließende Tag</canvas>darf nicht weggelassen werden.

und<img>Im Gegensatz zum Element,<canvas>das Element benötigt ein schließendes Tag (</canvas>). Wenn das schließende Tag nicht vorhanden ist, wird der Rest des Dokuments als Ersatzinhalt betrachtet und nicht angezeigt.

2.2 Rendering-Kontext (Der Rendering-Kontext)

​<canvas>erstellt ein Canvas mit fester Größe und stellt einen oder mehrereRendering-Kontexte(Pinsel) bereit, umRendering-Kontextzum Zeichnen und Verarbeiten des anzuzeigenden Inhalts zu verwenden.

Wir konzentrieren uns auf den 2D-Rendering-Kontext. Andere Kontexte werden wir vorerst nicht behandeln. Zum Beispiel verwendet WebGL einen 3D-Kontext, der auf OpenGL ES basiert ("experimental-webgl").

var canvas = document.getElementById('tutorial');
//获得 2d 上下文对象
var ctx = canvas.getContext('2d');

2.3 Unterstützung prüfen

var canvas = document.getElementById('tutorial');

if (canvas.getContext){
  var ctx = canvas.getContext('2d');
  // drawing code here
} else {
  // canvas-unsupported code here
}

2.4 Code-Vorlage

Beispiel

<canvas id="tutorial" width="300" height="300"></canvas> <script type="text/javascript">function draw(){ var canvas = document.getElementById('tutorial'); if(!canvas.getContext) return; var ctx = canvas.getContext("2d"); //startCode } draw();</script>

Jetzt ausprobieren »

2.5 Ein einfaches Beispiel

Das folgende Beispiel zeichnet zwei Rechtecke:

Beispiel

<canvas id="tutorial" width="300" height="300"></canvas> <script type="text/javascript">function draw(){ var canvas = document.getElementById('tutorial'); if(!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.fillStyle = "rgb(200,0,0)"; //System-Rechteck zeichnen ctx.fillRect (10, 10, 55, 50); ctx.fillStyle = "rgba(0, 0, 200, 0.5)"; ctx.fillRect (30, 30, 55, 50); } draw();</script>

Jetzt ausprobieren »

3. Formen zeichnen

3.1 Raster(grid)und Koordinatenraum

Wie in der Abbildung unten gezeigt,canvasdas Element standardmäßig von einem Raster überzogen wird. Im Allgemeinen entspricht eine Einheit im Rastercanvaseinem Pixel im Element. Der Ursprung des Rasters ist die obere linke Ecke mit den Koordinaten (0,0). Die Position aller Elemente wird relativ zum Ursprung positioniert. Daher hat die obere linke Ecke des blauen Quadrats in der Abbildung die Koordinaten (x, y), also x Pixel vom linken Rand (X-Achse) und y Pixel vom oberen Rand (Y-Achse).

Später behandeln wir die Verschiebung des Koordinatenursprungs, die Drehung des Rasters und die Skalierung usw.

3.2 Rechtecke zeichnen

​<canvas>Es wird nur eine Art des nativen Grafikzeichnens unterstützt:Rectangle. Alle anderen Grafiken erfordern das Erzeugen mindestens eines Pfads (path). Allerdings gibt es viele Methoden zur Pfaderzeugung, mit denen komplexe Grafiken gezeichnet werden können.

Canvas bietet drei Methoden zum Zeichnen von Rechtecken:

  • 1、fillRect(x, y, width, height): Zeichnet ein gefülltes Rechteck.
  • 2、strokeRect(x, y, width, height): Zeichnet den Rand eines Rechtecks.
  • 3、clearRect(x, y, widh, height): Löscht den angegebenen rechteckigen Bereich; danach wird dieser Bereich vollständig transparent.

Erklärung:Diese 3 Methoden haben dieselben Parameter.

  • x, y: Bezieht sich auf die Koordinaten der oberen linken Ecke des Rechtecks. (Relativ zum Koordinatenursprung des Canvas)
  • width, height: Bezieht sich auf die Breite und Höhe des zu zeichnenden Rechtecks.
function draw(){ var canvas = document.getElementById('tutorial'); if(!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.fillRect(10, 10, 100, 50); //Ein Rechteck zeichnen, die Standardfüllfarbe ist schwarz ctx.strokeRect(10, 70, 100, 50); //Zeichnen eines Rechteckrahmens } draw();

ctx.clearRect(15, 15, 50, 25);


4. Zeichnen von Pfaden (path)

Das grundlegende Element der Grafik ist ein Pfad.

Ein Pfad ist eine Sammlung von Punkten unterschiedlicher Formen, die durch das Verbinden von Liniensegmenten oder Kurven unterschiedlicher Farben und Breiten gebildet wird.

Ein Pfad oder sogar ein Unterpfad ist geschlossen.

Die Verwendung von Pfaden zum Zeichnen von Grafiken erfordert einige zusätzliche Schritte:

  1. Den Startpunkt des Pfades erstellen
  2. Zeichenmethoden aufrufen, um den Pfad zu zeichnen
  3. Pfad schließen
  4. Sobald der Pfad erzeugt wurde, rendern Sie die Grafik durch Konturieren oder Füllen des Pfadbereichs.

Die folgenden Methoden werden benötigt:

  1. beginPath()

    Erstellen Sie einen neuen Pfad. Sobald der Pfad erfolgreich erstellt wurde, werden die Grafikzeichenbefehle auf den Pfad gerichtet, um den Pfad zu erzeugen.

  2. moveTo(x, y)

    Bewegen Sie den Stift zu den angegebenen Koordinaten.(x, y)Entspricht dem Festlegen der Startpunktkoordinaten des Pfades.

  3. closePath()

    Nach dem Schließen des Pfades werden die Grafikzeichenbefehle auf den Kontext umgeleitet.

  4. stroke()

    Zeichnen Sie den Umriss der Form mit Linien.

  5. fill()

    Erzeugen Sie eine gefüllte Form, indem Sie den Inhaltsbereich des Pfades füllen.

4.1 Zeichnen von Liniensegmenten

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); //Erstellt einen neuen Pfad. ctx.moveTo(50, 50); //Bewegt den Stift zu den angegebenen Koordinaten. ctx.lineTo(200, 50); //Zeichne eine gerade Linie von der aktuellen Position zu den angegebenen Koordinaten (200, 50). //Schließe den Pfad. Er zeichnet eine gerade Linie vom aktuellen Punkt zum Startpunkt des Pfads. Wenn der aktuelle Punkt mit dem Startpunkt übereinstimmt, wird nichts ausgeführt. ctx.closePath(); ctx.stroke(); //Zeichne den Pfad. } draw();

4.2 Einen Dreiecksrahmen zeichnen

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.moveTo(50, 50); ctx.lineTo(200, 50); ctx.lineTo(200, 200); ctx.closePath(); //Obwohl wir nur zwei Liniensegmente gezeichnet haben, wird closePath den Pfad schließen, und es ist immer noch ein Dreieck. ctx.stroke(); //Strich. stroke() wird nicht automatisch closePath() aufrufen. } draw();

4.3 Ein Dreieck füllen

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.moveTo(50, 50); ctx.lineTo(200, 50); ctx.lineTo(200, 200); ctx.fill(); //Fülle den geschlossenen Bereich. Wenn der Pfad nicht geschlossen ist, wird fill() den Pfad automatisch schließen. } draw();

4.4 Bögen zeichnen

Es gibt zwei Methoden, Bögen zu zeichnen:

1、arc(x, y, r, startAngle, endAngle, anticlockwise): mit(x, y)als Mittelpunkt, mitrals Radius, vonstartAngleim Bogenmaß beginnt beiendAngleim Bogenmaß endet.anticlosewiseist ein boolescher Wert,truegibt gegen den Uhrzeigersinn an,falsegibt im Uhrzeigersinn an (Standard ist im Uhrzeigersinn).

Hinweis:

  1. Die Winkelangaben hier sind alle im Bogenmaß.

  2. 0Radiant bezieht sich auf diexpositive Richtung der Achse.

    radians=(Math.PI/180)*degrees   //角度转换成弧度

2、arcTo(x1, y1, x2, y2, radius): Zeichnet einen Bogen basierend auf den angegebenen Kontrollpunkten und dem Radius und verbindet schließlich die beiden Kontrollpunkte mit einer geraden Linie.

Bogen-Beispiel 1

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.arc(50, 50, 40, 0, Math.PI / 2, false); ctx.stroke(); } draw();

Bogen-Beispiel 2

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.arc(50, 50, 40, 0, Math.PI / 2, false); ctx.stroke(); ctx.beginPath(); ctx.arc(150, 50, 40, 0, -Math.PI / 2, true); ctx.closePath(); ctx.stroke(); ctx.beginPath(); ctx.arc(50, 150, 40, -Math.PI / 2, Math.PI / 2, false); ctx.fill(); ctx.beginPath(); ctx.arc(150, 150, 40, 0, Math.PI, false); ctx.fill(); } draw();

Bogen-Beispiel 3

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.moveTo(50, 50); //Parameter 1 und 2: Koordinaten des Kontrollpunkts 1; Parameter 3 und 4: Koordinaten des Kontrollpunkts 2; Parameter 4: Bogenradius ctx.arcTo(200, 50, 200, 200, 100); ctx.lineTo(200, 200) ctx.stroke(); ctx.beginPath(); ctx.rect(50, 50, 10, 10); ctx.rect(200, 50, 10, 10) ctx.rect(200, 200, 10, 10) ctx.fill() } draw();

arcToMethodenbeschreibung:

Diese Methode kann wie folgt verstanden werden. Der zu zeichnende Bogen wird durch zwei Tangenten bestimmt.

Die erste Tangente: die Gerade, die durch den Startpunkt und Kontrollpunkt 1 bestimmt wird.

Die zweite Tangente: die Gerade, die durch Kontrollpunkt 1 und Kontrollpunkt 2 bestimmt wird.

​Tatsächlich ist der gezeichnete Bogen der Bogen, der zu diesen beiden Geraden tangential ist.

4.5 Zeichnen von Bézier-Kurven

4.5.1 Was ist eine Bézier-Kurve

​

Eine Bézier-Kurve, auch bekannt als Bezier-Kurve, ist eine mathematische Kurve, die in zweidimensionalen Grafikanwendungen verwendet wird.

Allgemeine Vektorgrafiksoftware verwendet sie, um Kurven genau zu zeichnen. Eine Bézierkurve besteht aus Liniensegmenten und Knoten. Die Knoten sind ziehbare Drehpunkte, und die Liniensegmente sind wie dehnbare Gummibänder. Das Stiftwerkzeug, das wir in Zeichenwerkzeugen sehen, wird verwendet, um solche Vektorkurven zu erstellen.

Bézierkurven sind recht wichtige parametrische Kurven in der Computergrafik. Manche ausgereifte Bitmap-Software verfügt ebenfalls über Bézierkurven-Werkzeuge, wie etwa PhotoShop. In Flash4 gab es kein vollständiges Kurvenwerkzeug, aber Flash5 bot bereits ein Bézierkurven-Werkzeug.

Die Bézierkurve wurde 1962 von dem französischen Ingenieur Pierre Bézier weithin veröffentlicht, der sie zur Gestaltung von Automobilkarosserien einsetzte. Die Bézierkurve wurde ursprünglich 1959 von Paul de Casteljau unter Verwendung des de-Casteljau-Algorithmus entwickelt, einer numerisch stabilen Methode zum Auffinden von Bézierkurven.

Eine Bézierkurve erster Ordnung ist eigentlich eine gerade Linie.

Quadratische Bézierkurve

Kubische Bézierkurve

4.5.2 Bézierkurven zeichnen

Eine quadratische Bézierkurve zeichnen:

quadraticCurveTo(cp1x, cp1y, x, y)

Beschreibung:

  • Parameter 1 und 2: Koordinaten des Kontrollpunkts
  • Parameter 3 und 4: Koordinaten des Endpunkts
function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.moveTo(10, 200); //Startpunkt var cp1x = 40, cp1y = 100; //Kontrollpunkt var x = 200, y = 200; //Endpunkt //Zeichne eine quadratische Bézierkurve ctx.quadraticCurveTo(cp1x, cp1y, x, y); ctx.stroke(); ctx.beginPath(); ctx.rect(10, 200, 10, 10); ctx.rect(cp1x, cp1y, 10, 10); ctx.rect(x, y, 10, 10); ctx.fill(); } draw();

Zeichnen Sie eine kubische Bézier-Kurve:

bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y)

Beschreibung:

  • Parameter 1 und 2: Koordinaten von Kontrollpunkt 1
  • Parameter 3 und 4: Koordinaten von Kontrollpunkt 2
  • Parameter 5 und 6: Koordinaten des Endpunkts
function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.moveTo(40, 200); //Startpunkt var cp1x = 20, cp1y = 100; //Kontrollpunkt 1 var cp2x = 100, cp2y = 120; //Kontrollpunkt 2 var x = 200, y = 200; //Endpunkt //Zeichne eine quadratische Bézierkurve ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y); ctx.stroke(); ctx.beginPath(); ctx.rect(40, 200, 10, 10); ctx.rect(cp1x, cp1y, 10, 10); ctx.rect(cp2x, cp2y, 10, 10); ctx.rect(x, y, 10, 10); ctx.fill(); } draw();


5. Stile und Farben hinzufügen

Im vorherigen Kapitel über das Zeichnen von Rechtecken wurden nur die Standardlinien und Standardfarben verwendet.

Wenn Sie eine Form einfärben möchten, gibt es zwei wichtige Eigenschaften, mit denen dies möglich ist.

  1. fillStyle = colorLegt die Füllfarbe der Form fest.

  2. strokeStyle = colorLegt die Farbe der Formumrandung fest.

Notizen:

  • 1. Die Farbe kann eine Zeichenkette sein, die einen CSS-Farbwert, ein Farbverlaufsobjekt oder ein Musterobjekt darstellt.
  • 2. Standardmäßig sind sowohl die Linienfarbe als auch die Füllfarbe schwarz.
  • 3. Sobald Sie den Wert von strokeStyle oder fillStyle festlegen, wird dieser neue Wert zum Standard für neu gezeichnete Formen. Wenn Sie jeder Form eine andere Farbe geben möchten, müssen Sie den Wert von fillStyle oder strokeStyle zurücksetzen.

fillStyle

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); for (var i = 0; i < 6; i++){ for (var j = 0; j < 6; j++){ ctx.fillStyle = 'rgb(' + Math.floor(255 - 42.5 * i) + ',' + Math.floor(255 - 42.5 * j) + ',0)'; ctx.fillRect(j * 50, i * 50, 50, 50); } } } draw();

strokeStyle

function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); for (var i = 0; i < 6; i++){ for (var j = 0; j < 6; j++){ ctx.strokeStyle = `rgb(${randomInt(0, 255)},${randomInt(0, 255)},${randomInt(0, 255)})`; ctx.strokeRect(j * 50, i * 50, 40, 40); } } } draw(); /** Gibt eine zufällige ganze Zahl zwischen [from, to] zurück (einschließlich from und to).*/ function randomInt(from, to){ return parseInt(Math.random() * (to - from + 1) + from); }

Transparenz

globalAlpha = transparencyValue: Diese Eigenschaft wirkt sich auf die Transparenz aller Formen auf dem Canvas aus. Gültige Werte reichen von 0.0 (vollständig transparent) bis 1.0 (vollständig undurchsichtig), Standardwert ist 1.0.

​ globalAlphaDiese Eigenschaft ist ziemlich effizient, wenn Sie viele Formen mit derselben Transparenz zeichnen müssen. Ich denke jedoch, dass die Verwendung von rgba() zum Festlegen der Transparenz besser ist.

1、Linienstil

Linienbreite. Sie kann nur ein positiver Wert sein. Standard ist 1.0.

Die Linie, die Startpunkt und Endpunkt verbindet, ist die Mitte,Oben und unten nehmen jeweils die Hälfte der Linienbreite ein.。

ctx.beginPath(); ctx.moveTo(10, 10); ctx.lineTo(100, 10); ctx.lineWidth = 10; ctx.stroke(); ctx.beginPath(); ctx.moveTo(110, 10); ctx.lineTo(160, 10) ctx.lineWidth = 20; ctx.stroke()

2. lineCap = type

Stil der Linienenden.

Es gibt 3 Werte:

  1. butt: Das Ende des Liniensegments endet mit einem Quadrat.

  2. round: Das Ende des Liniensegments endet mit einem Kreis.

  3. square: Das Ende des Liniensegments endet mit einem Quadrat, aber es wird ein rechteckiger Bereich hinzugefügt, dessen Breite der des Liniensegments entspricht und dessen Höhe die Hälfte der Linienstärke beträgt.

    var lineCaps = ["butt", "round", "square"]; for (var i = 0; i < 3; i++){ ctx.beginPath(); ctx.moveTo(20 + 30 * i, 30); ctx.lineTo(20 + 30 * i, 100); ctx.lineWidth = 20; ctx.lineCap = lineCaps[i]; ctx.stroke(); } ctx.beginPath(); ctx.moveTo(0, 30); ctx.lineTo(300, 30); ctx.moveTo(0, 100); ctx.lineTo(300, 100) ctx.strokeStyle = "red"; ctx.lineWidth = 1; ctx.stroke();

    3. lineJoin = type

    Legen Sie innerhalb desselben Pfads den Stil der Verbindungen zwischen Linien fest.

    Es gibt 3 Werte.round, bevelundmiter:

    1. roundZeichnen Sie die Form der Ecke, indem Sie einen zusätzlichen Sektor füllen, dessen Mittelpunkt am Ende des verbundenen Teils liegt. Der Radius der abgerundeten Ecke ist die Breite des Liniensegments.

    2. bevelFüllen Sie am Ende des verbundenen Teils einen zusätzlichen dreieckförmigen Bereich; jeder Teil hat seine eigene unabhängige rechteckige Ecke.

    3. miter(Standard) Verlängern Sie die Außenkanten der verbundenen Teile so, dass sie sich in einem Punkt schneiden und einen zusätzlichen rautenförmigen Bereich bilden.

      function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); var lineJoin = ['round', 'bevel', 'miter']; ctx.lineWidth = 20; for (var i = 0; i < lineJoin.length; i++){ ctx.lineJoin = lineJoin[i]; ctx.beginPath(); ctx.moveTo(50, 50 + i * 50); ctx.lineTo(100, 100 + i * 50); ctx.lineTo(150, 50 + i * 50); ctx.lineTo(200, 100 + i * 50); ctx.lineTo(250, 50 + i * 50); ctx.stroke(); } } draw();
    4. 4. Gestrichelte Linien

      Verwenden SiesetLineDashDie Methode undlineDashOffsetEigenschaft wird verwendet, um gestrichelte Linienstile zu definieren.setLineDashDie Methode akzeptiert ein Array, um den Wechsel von Liniensegmenten und Lücken anzugeben;lineDashOffsetDie Eigenschaft legt den Startversatz fest.

      function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.setLineDash([20, 5]); //[Länge der durchgezogenen Linie, Lückenlänge] ctx.lineDashOffset = -0; ctx.strokeRect(50, 50, 210, 210); } draw();

      Hinweis: getLineDash() gibt ein Array zurück, das den aktuellen Stil der gestrichelten Linie enthält, mit einer nicht negativen geraden Länge.


      6. Text zeichnen

      Zwei Methoden zum Zeichnen von Text

      canvas bietet zwei Methoden zum Rendern von Text:

      1. fillText(text, x, y [, maxWidth])Füllt den angegebenen Text an der angegebenen (x, y)-Position aus; die maximale Breite zum Zeichnen ist optional.

      2. strokeText(text, x, y [, maxWidth])Zeichnet einen Textrahmen an der angegebenen (x, y)-Position; die maximale Breite zum Zeichnen ist optional.

        var ctx; function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; ctx = canvas.getContext("2d"); ctx.font = "100px sans-serif" ctx.fillText("Wenn der Himmel Gefühle hat", 10, 100); ctx.strokeText("Wenn der Himmel Gefühle hat", 10, 200) } draw();
      3. Stile zu Text hinzufügen

        1. font = valueDer Stil, den wir derzeit zum Zeichnen von Text verwenden. Dieser String verwendet dieselbe Syntax wie dieCSS fontEigenschaft. Die Standardschriftart ist10px sans-serif。

        2. textAlign = valueTextausrichtungsoption. Optionale Werte umfassen:start, end, left, right oder center. Der Standardwert iststart。

        3. textBaseline = valueOption zur Grundlinienausrichtung, optionale Werte umfassen:top, hanging, middle, alphabetic, ideographic, bottom. Der Standardwert istalphabetic。。

        4. direction = valueTextrichtung. Mögliche Werte umfassen:ltr, rtl, inherit. Der Standardwert istinherit。


        7. Bilder zeichnen

        Wir können auchcanvasBilder direkt darauf zeichnen.

        7.1 Ein Bild von Grund auf erstellen

        var img = new Image(); //Ein <img>-Element erstellen img.src = 'myImage.png'; //Bildquelladresse festlegen

        Nachdem das Skript ausgeführt wurde, beginnt das Bild zu laden.

        Zeichnenimg

        // 参数 1:要绘制的 img  
        // 参数 2、3:绘制的 img 在 canvas 中的坐标
        ctx.drawImage(img,0,0); 

        Hinweis: Da das Bild aus dem Netzwerk geladen wird, wenndrawImagezu diesem Zeitpunkt das Bild noch nicht vollständig geladen wurde, wird nichts unternommen, und einige Browser lösen möglicherweise eine Ausnahme aus. Wir sollten also sicherstellen, dass nachimgAbschluss des Zeichnens danndrawImage。

        var img = new Image(); //Ein img-Element erstellen img.onload = function(){ ctx.drawImage(img, 0, 0) } img.src = 'myImage.png'; //Bildquelladresse festlegen

        7.2 ZeichnenimgBilder im Tag-Element

        ​imgcannewEs kann auch von unserer Seite stammen<img>-Tag anzeigen können.

        <img src="./beauty.jpg" alt="" width="300"><br> <canvas id="tutorial" width="600" height="400"></canvas> function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); var img = document.querySelector("img"); ctx.drawImage(img, 0, 0); } document.querySelector("img").onclick = function (){ draw(); }

        Das erste Bild ist das in der Seite<img>Tag:

        7.3 Skalieren von Bildern

        drawImage()Sie können auch zwei weitere Parameter hinzufügen:

        drawImage(image, x, y, width, height)

        Diese Methode hat 2 zusätzliche Parameter:widthundheight, diese beiden Parameter steuern den Maßstab, in dem das Bild gezeichnet werden soll, wenn es auf das Canvas gezeichnet wird.

        ctx.drawImage(img, 0, 0, 400, 200)

        7.4 Ausschneiden (slice)

        drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight)

        Der erste Parameter ist derselbe wie bei den anderen; er ist eine Referenz auf ein Bild oder ein anderes Canvas.

        Die anderen 8 Parameter:

        Die ersten 4 definieren die Position und Größe des Ausschnitts in der Bildquelle, und die letzten 4 definieren die Ziel-Anzeigeposition und -Größe des Ausschnitts.


        8. Speichern und Wiederherstellen des Zustands

        Saving and restoring stateist ein wesentlicher Vorgang beim Zeichnen komplexer Grafiken.

        save()undrestore()

        saveundrestoreDie Methode dient zum Speichern und Wiederherstellencanvasdes Zustands, und sie nimmt keine Parameter an.

        ​CanvasDer Zustand ist eine Momentaufnahme aller Stile und Transformationen, die auf das aktuelle Canvas angewendet wurden.

        1. Zu save(): Der Canvas-Zustand wird in einem Stack gespeichert. Wann immer die Methode save() aufgerufen wird, wird der aktuelle Zustand auf den Stack gelegt und gespeichert.

        Ein Zeichnungszustand umfasst:

        • Die aktuell angewendeten Transformationen (d. h. Translation, Rotation und Skalierung)

        • strokeStyle, fillStyle, globalAlpha, lineWidth, lineCap, lineJoin, miterLimit, shadowOffsetX, shadowOffsetY, shadowBlur, shadowColor, globalCompositeOperation 的值

        • Der aktuelle Beschneidungspfad (clipping path)

          ​

          kann beliebig oft aufgerufen werdensaveMethode (ähnlich wie bei Arrays'push())。

        kann beliebig oft aufgerufen werdensaveMethode(ähnlich wie bei Arrays'push())。

        2. Zu restore(): Jedes Mal, wenn die restore-Methode aufgerufen wird, wird der zuletzt gespeicherte Zustand vom Stack entfernt und alle Einstellungen werden wiederhergestellt (ähnlich wie bei Arrays'pop())。

        var ctx; function draw(){ var canvas = document.getElementById('tutorial'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.fillRect(0, 0, 150, 150); //Zeichne ein Rechteck mit den Standardeinstellungen ctx.save(); //Speichere den Standardzustand ctx.fillStyle = 'red' //Nimm Änderungen an der Farbe basierend auf der ursprünglichen Konfiguration vor ctx.fillRect(15, 15, 120, 120); //Zeichne ein Rechteck mit den neuen Einstellungen ctx.save(); //Speichere den aktuellen Zustand ctx.fillStyle = '#FFF' //Ändere die Farbkonfiguration erneut ctx.fillRect(30, 30, 90, 90); //Zeichne ein Rechteck mit der neuen Konfiguration ctx.restore(); //Lade den vorherigen Farbzustand erneut ctx.fillRect(45, 45, 60, 60); //Zeichne ein Rechteck mit der vorherigen Konfiguration ctx.restore(); //Lade die Standard-Farbkonfiguration ctx.fillRect(60, 60, 30, 30); //Zeichne ein Rechteck mit der geladenen Konfiguration } draw();

        9. Transformationen

        9.1 translate

        translate(x, y)

        Dient zum VerschiebencanvasdesUrsprungsan eine angegebene Position

        ​translateDie Methode akzeptiert zwei Parameter.xist der horizontale Versatz,yist der vertikale Versatz, wie in der Abbildung rechts gezeigt.

        Den Zustand zu speichern, bevor man Transformationen durchführt, ist eine gute Angewohnheit. In den meisten Fällen ist der Aufrufrestoreder Methode viel einfacher als das manuelle Wiederherstellen des ursprünglichen Zustands. Wenn Sie außerdem Translationen in einer Schleife durchführen, aber den Zustand nicht speichern und wiederherstellen,canvaswerden Sie am Ende möglicherweise feststellen, dass etwas fehlt, weil es wahrscheinlich übercanvasden Gültigkeitsbereich hinausgegangen ist.

        Hinweis:translateWas verschoben wird, istcanvasder Koordinatenursprung des Canvas (Koordinatentransformation).

        var ctx; function draw(){ var canvas = document.getElementById('tutorial1'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.save(); //Zustand speichern, bevor der Ursprung verschoben wird ctx.translate(100, 100); ctx.strokeRect(0, 0, 100, 100) ctx.restore(); //Zum Ausgangszustand wiederherstellen ctx.translate(220, 220); ctx.fillRect(0, 0, 100, 100) } draw();

        9.2 rotate

        rotate(angle)
        ​

        Drehen Sie die Koordinatenachsen.

        ​

        Diese Methode akzeptiert nur einen Parameter: den Drehwinkel, der im Uhrzeigersinn im Bogenmaß angegeben wird.

        Das Drehzentrum ist der Koordinatenursprung.

        var ctx; function draw(){ var canvas = document.getElementById('tutorial1'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.fillStyle = "red"; ctx.save(); ctx.translate(100, 100); ctx.rotate(Math.PI / 180 * 45); ctx.fillStyle = "blue"; ctx.fillRect(0, 0, 100, 100); ctx.restore(); ctx.save(); ctx.translate(0, 0); ctx.fillRect(0, 0, 50, 50) ctx.restore(); } draw();

        9.3 scale

        scale(x, y)

        Wir verwenden es, um die Anzahl der Pixel der Form aufcanvasdem Canvas zu erhöhen oder zu verringern, um Formen und Bitmaps zu verkleinern oder zu vergrößern.

        scaleDie Methode akzeptiert zwei Parameter.x,ySie sind die Skalierungsfaktoren für die horizontale Achse bzw. die vertikale Achse, und beide müssen positive Werte sein. Ein Wert kleiner als 1.0 bedeutet Verkleinerung, größer als 1.0 bedeutet Vergrößerung, und ein Wert von 1.0 hat keine Wirkung.

        Standardmäßig,canvas1 Einheit auf dem Canvas ist 1 Pixel. Wenn wir beispielsweise den Skalierungsfaktor auf 0.5 setzen, wird 1 Einheit zu 0.5 Pixeln, sodass die gezeichnete Form halb so groß wie das Original ist. Ähnlich wird bei einer Einstellung auf 2.0 aus 1 Einheit 2 Pixel, und das Zeichnungsergebnis ist die um das Zweifache vergrößerte Form.

        9.4 transform (Transformationsmatrix)

        transform(a, b, c, d, e, f)

        • a (m11): Horizontale Skalierung.
        • b (m12): Horizontale Scherung.
        • c (m21): Vertikale Scherung.
        • d (m22): Vertikale Skalierung.
        • e (dx): Horizontale Verschiebung.
        • f (dy): Vertikale Verschiebung.
        var ctx; function draw(){ var canvas = document.getElementById('tutorial1'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.transform(1, 1, 0, 1, 0, 0); ctx.fillRect(0, 0, 100, 100); } draw();


        10. Compositing

        ​

        In allen vorherigen Beispielen zeichnen wir immer eine Form über eine andere. Für viele andere Fälle ist dies allein bei Weitem nicht ausreichend. Beispielsweise kann bei zusammengesetzten Grafiken die Zeichenreihenfolge eingeschränkt werden. Wir können jedoch die Eigenschaft globalCompositeOperation verwenden, um diese Situation zu ändern.

        globalCompositeOperation = type
        var ctx; function draw(){ var canvas = document.getElementById('tutorial1'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.fillStyle = "blue"; ctx.fillRect(0, 0, 200, 200); ctx.globalCompositeOperation = "source-over"; //Globale Compositing-Operationen ctx.fillStyle = "red"; ctx.fillRect(100, 100, 200, 200); } draw();

        Hinweis: In der folgenden Demonstration ist Blau das Original und Rot das Neue.

        type ist einer der folgenden 13 String-Werte:

        1. Dies ist die Standardeinstellung; das neue Bild überdeckt das ursprüngliche Bild.

        2. source-in

        Nur der überlappende Teil des neuen Bildes und des ursprünglichen Bildes erscheint; alle anderen Bereiche werden transparent. (Auch andere Bereiche des alten Bildes werden transparent)

        3. source-out

        Zeigt nur die Teile, in denen sich das neue Bild und das alte Bild nicht überlappen; der Rest ist vollständig transparent. (Das alte Bild wird ebenfalls nicht angezeigt)

        4. source-atop

        Das neue Bild zeigt nur den Überlappungsbereich mit dem alten Bild. Das alte Bild kann weiterhin angezeigt werden.

        5. destination-over

        Das neue Bild wird unter dem alten Bild angezeigt.

        6. destination-in

        Nur das alte Bild im Überlappungsbereich des neuen und alten Bildes wird angezeigt; alle anderen Bereiche sind transparent.

        7. destination-out

        Nur die Teile, in denen sich das alte Bild und das neue Bild nicht überlappen. Beachten Sie, dass Teile des alten Bildes angezeigt werden.

        8. destination-atop

        Das alte Bild zeigt nur den überlappenden Teil an, und das neue Bild wird unter dem alten Bild angezeigt.

        9. lighter

        Sowohl das neue als auch das alte Bild werden angezeigt, aber die Farben im Überlappungsbereich werden additiv verarbeitet.

        10. darken

        Behält die dunkelsten Pixel im überlappenden Teil. (Jeder Farbkanal wird verglichen, wobei der kleinste genommen wird)

        blue: #0000FF
        red: #FF0000

        Also die Farbe des überlappenden Teils:#000000。

        11. Aufhellen

        Sorgt für die hellsten Pixel im überlappenden Teil. (Jeder Farbkanal wird verglichen, wobei der größte genommen wird)

        blue: #0000FF
        red: #FF0000

        Also die Farbe des überlappenden Teils:#ff00ff。

        12. xor

        Der überlappende Teil wird transparent.

        13. Kopieren

        Nur das neue Bild wird beibehalten; alles andere wird gelöscht (wird transparent).


        11. Beschneidungspfade

        clip()
        ​

        Einen bereits erstellten Pfad in einen Beschneidungspfad umwandeln.

        ​

        Die Funktion eines Beschneidungspfads ist eine Maske. Nur der Bereich innerhalb des Beschneidungspfads wird angezeigt; der Bereich außerhalb des Beschneidungspfads wird ausgeblendet.

        ​

        Hinweis:clip() kann nur Bilder maskieren, die gezeichnet werden, nachdem diese Methode aufgerufen wurde. Wenn das Bild vor dem Aufruf der clip()-Methode gezeichnet wurde, kann keine Maskierung erreicht werden.

        var ctx; function draw(){ var canvas = document.getElementById('tutorial1'); if (!canvas.getContext) return; var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.arc(20,20, 100, 0, Math.PI * 2); ctx.clip(); ctx.fillStyle = "pink"; ctx.fillRect(20, 20, 100,100); } draw();

        12. Animation

        Grundlegende Schritte der Animation

        1. KlarcanvasBevor Sie jedes Frame der Animation zeichnen, müssen Sie alles löschen. Der einfachste Weg, alles zu löschen, ist dieclearRect()Methode.

        2. SavecanvasstateWenn Sie während des Zeichenvorgangs änderncanvasden Canvas-Zustand (Farbe, verschobener Koordinatenursprung usw.), und wenn jeder Frame vom ursprünglichen Zustand aus starten soll, ist es am besten, den zu speicherncanvasZustand.

        3. Zeichnen Sie die AnimationsgrafikenDieser Schritt ist das eigentliche Zeichnen des Animationsframes

        4. WiederherstellencanvasstateWenn Sie dencanvasstate früher gespeichert haben, sollten Sie ihn nach dem Zeichnen eines Frames wiederherstellen.canvasZustand.

        Animation steuern

        Wir können diecanvasMethoden oder benutzerdefinierte Methoden, um das Bild auf diecanvasZeichenfläche zu zeichnen. Normalerweise können wir das Zeichnungsergebnis erst nach dem Ende der Skriptausführung sehen. Zum Beispiel können wir eine Animation nicht innerhalb einerforSchleife abschließen.

        Das heißt, um eine Animation auszuführen, benötigen wir einige Methoden, die Neuzeichnungen zu geplanten Zeiten ausführen können.

        Im Allgemeinen werden die folgenden drei Methoden verwendet:

        1. setInterval()
        2. setTimeout()
        3. requestAnimationFrame()

        Fall 1: Sonnensystem

        let sun; let earth; let moon; let ctx; function init(){ sun = new Image(); earth = new Image(); moon = new Image(); sun.src = "sun.png"; earth.src = "earth.png"; moon.src = "moon.png"; let canvas = document.querySelector("#solar"); ctx = canvas.getContext("2d"); sun.onload = function (){ draw() } } init(); function draw(){ ctx.clearRect(0, 0, 300, 300); //Alle Inhalte löschen /*Die Sonne zeichnen*/ ctx.drawImage(sun, 0, 0, 300, 300); ctx.save(); ctx.translate(150, 150); //Die Erdumlaufbahn zeichnen ctx.beginPath(); ctx.strokeStyle = "rgba(255,255,0,0.5)"; ctx.arc(0, 0, 100, 0, 2 * Math.PI) ctx.stroke() let time = new Date(); //Zeichne die Erde ctx.rotate(2 * Math.PI / 60 * time.getSeconds() + 2 * Math.PI / 60000 * time.getMilliseconds()) ctx.translate(100, 0); ctx.drawImage(earth, -12, -12) //Zeichne die Umlaufbahn des Mondes ctx.beginPath(); ctx.strokeStyle = "rgba(255,255,255,.3)"; ctx.arc(0, 0, 40, 0, 2 * Math.PI); ctx.stroke(); //Zeichne den Mond ctx.rotate(2 * Math.PI / 6 * time.getSeconds() + 2 * Math.PI / 6000 * time.getMilliseconds()); ctx.translate(40, 0); ctx.drawImage(moon, -3.5, -3.5); ctx.restore(); requestAnimationFrame(draw); }

        Fall 2: Analoge Uhr

        init(); function init(){ let canvas = document.querySelector("#solar"); let ctx = canvas.getContext("2d"); draw(ctx); } function draw(ctx){ requestAnimationFrame(function step(){ drawDial(ctx); //Zeichne das Zifferblatt drawAllHands(ctx); //Zeichne die Stunden-, Minuten- und Sekundenzeiger requestAnimationFrame(step); }); } /*Zeichne die Stunden-, Minuten- und Sekundenzeiger*/ function drawAllHands(ctx){ let time = new Date(); let s = time.getSeconds(); let m = time.getMinutes(); let h = time.getHours(); let pi = Math.PI; let secondAngle = pi / 180 * 6 * s; //Berechne das Bogenmaß des Sekundenzeigers let minuteAngle = pi / 180 * 6 * m + secondAngle / 60; //Berechne das Bogenmaß des Minutenzeigers let hourAngle = pi / 180 * 30 * h + minuteAngle / 12; //Berechne das Bogenmaß des Stundenzeigers drawHand(hourAngle, 60, 6, "red", ctx); //Zeichne den Stundenzeiger drawHand(minuteAngle, 106, 4, "green", ctx); //Zeichne den Minutenzeiger drawHand(secondAngle, 129, 2, "blue", ctx); //Zeichne den Sekundenzeiger } /*Zeichne den Stundenzeiger, Minutenzeiger oder Sekundenzeiger * Parameter 1: der Winkel des zu zeichnenden Zeigers * Parameter 2: die Länge des zu zeichnenden Zeigers * Parameter 3: die Breite des zu zeichnenden Zeigers * Parameter 4: die Farbe des zu zeichnenden Zeigers * Parameter 4: ctx **/ function drawHand(angle, len, width, color, ctx){ ctx.save(); ctx.translate(150, 150); //Verschiebe den Ursprung der Koordinatenachsen zum ursprünglichen Mittelpunkt ctx.rotate(-Math.PI / 2 + angle); //Drehe die Koordinatenachsen. Die x-Achse ist der Winkel des Zeigers. ctx.beginPath(); ctx.moveTo(-4, 0); ctx.lineTo(len, 0); //Zeichne den Zeiger entlang der x-Achse ctx.lineWidth = width; ctx.strokeStyle = color; ctx.lineCap = "round"; ctx.stroke(); ctx.closePath(); ctx.restore(); } /*Zeichne das Zifferblatt*/ function drawDial(ctx){ let pi = Math.PI; ctx.clearRect(0, 0, 300, 300); //Alle Inhalte löschen ctx.save(); ctx.translate(150, 150); //Verschiebe den Koordinatenursprung zum ursprünglichen Mittelpunkt ctx.beginPath(); ctx.arc(0, 0, 148, 0, 2 * pi); //Zeichne den Kreis ctx.stroke(); ctx.closePath(); for (let i = 0; i < 60; i++){//Zeichnen Sie die Teilstriche. ctx.save(); ctx.rotate(-pi / 2 + i * pi / 30); //Drehen Sie die Koordinatenachsen. Die positive Richtung der x-Achse geht von der nach oben weisenden Richtung aus. ctx.beginPath(); ctx.moveTo(110, 0); ctx.lineTo(140, 0); ctx.lineWidth = i % 5 ? 2 : 4; ctx.strokeStyle = i % 5 ? "blue" : "red"; ctx.stroke(); ctx.closePath(); ctx.restore(); } ctx.wiederherstellen(); }

        Ausprobieren »

        Originalautor: 做人要厚道2013

        Original-URL: https://blog.csdn.net/u012468376/article/details/73350998