วิธีการวาดเส้นโค้งที่ราบรื่นผ่านจุด N โดยใช้ผ้าใบ HTML5 ของจาวาสคริปต์


133

สำหรับแอปพลิเคชันการวาดภาพฉันกำลังบันทึกพิกัดการเคลื่อนที่ของเมาส์ไปยังอาร์เรย์แล้ววาดด้วย lineTo เส้นที่เกิดจะไม่เรียบ ฉันจะสร้างเส้นโค้งเดียวระหว่างจุดที่รวบรวมทั้งหมดได้อย่างไร

ฉัน googled แต่ฉันได้พบเพียง 3 ฟังก์ชั่นสำหรับการวาดเส้น: สำหรับ 2 lineToจุดตัวอย่างการใช้งานเพียงแค่ สำหรับ 3 จุดตัวอย่างquadraticCurveToสำหรับ 4 จุดตัวอย่าง, bezierCurveTo.

(ฉันพยายามวาดจุดbezierCurveToทุกๆ 4 จุดในอาร์เรย์ แต่สิ่งนี้ทำให้เกิดการหักงอทุกๆ 4 จุดตัวอย่างแทนที่จะเป็นเส้นโค้งที่ราบรื่นต่อเนื่อง)

ฉันจะเขียนฟังก์ชันเพื่อวาดเส้นโค้งที่ราบรื่นโดยมีจุดตัวอย่าง 5 จุดขึ้นไปได้อย่างไร


5
คำว่า "เนียน" หมายถึงอะไร? แตกต่างอย่างไม่มีที่สิ้นสุด? แตกต่างกันสองเท่า? เส้นโค้งลูกบาศก์ ("เส้นโค้งเบเซียร์") มีคุณสมบัติที่ดีมากมายและแตกต่างกันได้สองเท่าและง่ายพอที่จะคำนวณ
Kerrek SB

7
@Kerrek SB โดย "เรียบ" ฉันหมายถึงมองไม่เห็นมุม / cusps ใด ๆ ฯลฯ
Homan

@sketchfemme คุณกำลังเรนเดอร์ไลน์แบบเรียลไทม์หรือชะลอการเรนเดอร์จนกว่าจะรวบรวมคะแนนได้
Crashalot

@Crashalot ฉันกำลังรวบรวมคะแนนลงในอาร์เรย์ คุณต้องมีอย่างน้อย 4 คะแนนเพื่อใช้อัลกอริทึมนี้ หลังจากนั้นคุณสามารถแสดงผลแบบเรียลไทม์บนผืนผ้าใบโดยการล้างหน้าจอในการเรียกเมาส์แต่ละครั้ง
Homan

1
@sketchfemme: อย่าลืมยอมรับคำตอบ มันเป็นเรื่องดีถ้ามันเป็นของคุณเอง
TJ Crowder

คำตอบ:


130

ปัญหาในการรวมจุดตัวอย่างที่ตามมาพร้อมกับฟังก์ชันประเภท "curveTo" ที่ไม่ปะติดปะต่อกันคือจุดที่เส้นโค้งมาบรรจบกันไม่ราบรื่น เนื่องจากเส้นโค้งทั้งสองมีจุดสิ้นสุดร่วมกัน แต่ได้รับอิทธิพลจากจุดควบคุมที่ไม่ปะติดปะต่อโดยสิ้นเชิง วิธีแก้ปัญหาอย่างหนึ่งคือ "เส้นโค้งไปที่" จุดกึ่งกลางระหว่างจุดตัวอย่าง 2 จุดถัดไปที่ตามมา การเข้าร่วมเส้นโค้งโดยใช้จุดที่สอดแทรกใหม่เหล่านี้ทำให้การเปลี่ยนแปลงที่ราบรื่นที่จุดสิ้นสุด (จุดสิ้นสุดของการวนซ้ำหนึ่งจุดคืออะไรจะกลายเป็นจุดควบคุมสำหรับการวนซ้ำครั้งต่อไป) กล่าวอีกนัยหนึ่งคือเส้นโค้งสองเส้นที่ไม่ปะติดปะต่อกันมีมากขึ้นในตอนนี้

โซลูชันนี้แยกออกมาจากหนังสือ "Foundation ActionScript 3.0 Animation: Making things move" หน้า 95 - เทคนิคการเรนเดอร์: สร้างเส้นโค้งหลายเส้น

หมายเหตุ: คำตอบนี้ไม่ได้ดึงผ่านแต่ละจุดซึ่งเป็นชื่อคำถามของฉัน (แต่จะประมาณเส้นโค้งผ่านจุดตัวอย่าง แต่ไม่ผ่านจุดตัวอย่าง) แต่สำหรับวัตถุประสงค์ของฉัน (แอปพลิเคชันการวาดภาพ) มันดีพอสำหรับฉันและด้วยสายตาคุณไม่สามารถบอกความแตกต่างได้ มีเป็นวิธีการแก้ปัญหาที่จะไปผ่านทุกจุดตัวอย่าง แต่มันมีความซับซ้อนมากขึ้น (ดูhttp://www.cartogrammar.com/blog/actionscript-curves-update/ )

นี่คือรหัสการวาดสำหรับวิธีการประมาณ:

// move to the first point
   ctx.moveTo(points[0].x, points[0].y);


   for (i = 1; i < points.length - 2; i ++)
   {
      var xc = (points[i].x + points[i + 1].x) / 2;
      var yc = (points[i].y + points[i + 1].y) / 2;
      ctx.quadraticCurveTo(points[i].x, points[i].y, xc, yc);
   }
 // curve through the last two points
 ctx.quadraticCurveTo(points[i].x, points[i].y, points[i+1].x,points[i+1].y);

+1 สิ่งนี้ใช้ได้ดีกับโปรเจ็กต์ JavaScript / canvas ที่ฉันกำลังทำอยู่
Matt

1
ดีใจที่ได้รับความช่วยเหลือ FYI ฉันได้เริ่มแผ่นวาดภาพแคนวาส html5 แบบโอเพนซอร์สที่เป็นปลั๊กอิน jQuery น่าจะเป็นจุดเริ่มต้นที่มีประโยชน์ github.com/homanchou/sketchyPad
Homan

4
นั่นเป็นสิ่งที่ดี แต่คุณจะสร้างเส้นโค้งอย่างไรเพื่อให้มันผ่านทุกจุด?
Richard

ด้วยอัลกอริทึมนี้แต่ละเส้นโค้งต่อเนื่องหมายถึงการเริ่มต้นจากจุดสิ้นสุดของเส้นโค้งก่อนหน้าหรือไม่?
Lee Brindley

ขอบคุณมาก Homan! มันได้ผล! ฉันใช้เวลาหลายวันในการแก้ปัญหานี้ และสวัสดีจากชุมชน Delphi Android / iOS!
alitrun

104

สายไปหน่อย แต่สำหรับการบันทึก

คุณสามารถบรรลุเส้นเรียบได้โดยใช้เส้นโค้งที่สำคัญ (หรือที่เรียกว่าเส้นโค้งมาตรฐาน) เพื่อวาดเส้นโค้งเรียบที่ผ่านจุดต่างๆ

ฉันสร้างฟังก์ชันนี้สำหรับแคนวาส - มันแบ่งออกเป็นสามฟังก์ชันเพื่อเพิ่มความคล่องตัว ฟังก์ชั่นเสื้อคลุมหลักมีลักษณะดังนี้:

function drawCurve(ctx, ptsa, tension, isClosed, numOfSegments, showPoints) {

    showPoints  = showPoints ? showPoints : false;

    ctx.beginPath();

    drawLines(ctx, getCurvePoints(ptsa, tension, isClosed, numOfSegments));

    if (showPoints) {
        ctx.stroke();
        ctx.beginPath();
        for(var i=0;i<ptsa.length-1;i+=2) 
                ctx.rect(ptsa[i] - 2, ptsa[i+1] - 2, 4, 4);
    }
}

ในการวาดเส้นโค้งให้มีอาร์เรย์ที่มีจุด x, y ตามลำดับ: x1,y1, x2,y2, ...xn,ynที่จุดในการสั่งซื้อนี้:

ใช้แบบนี้:

var myPoints = [10,10, 40,30, 100,10]; //minimum two points
var tension = 1;

drawCurve(ctx, myPoints); //default tension=0.5
drawCurve(ctx, myPoints, tension);

ฟังก์ชันด้านบนเรียกฟังก์ชันย่อยสองฟังก์ชันหนึ่งเพื่อคำนวณจุดที่เรียบ สิ่งนี้ส่งคืนอาร์เรย์ที่มีจุดใหม่ - นี่คือฟังก์ชันหลักที่คำนวณจุดที่เรียบ:

function getCurvePoints(pts, tension, isClosed, numOfSegments) {

    // use input value if provided, or use a default value   
    tension = (typeof tension != 'undefined') ? tension : 0.5;
    isClosed = isClosed ? isClosed : false;
    numOfSegments = numOfSegments ? numOfSegments : 16;

    var _pts = [], res = [],    // clone array
        x, y,           // our x,y coords
        t1x, t2x, t1y, t2y, // tension vectors
        c1, c2, c3, c4,     // cardinal points
        st, t, i;       // steps based on num. of segments

    // clone array so we don't change the original
    //
    _pts = pts.slice(0);

    // The algorithm require a previous and next point to the actual point array.
    // Check if we will draw closed or open curve.
    // If closed, copy end points to beginning and first points to end
    // If open, duplicate first points to befinning, end points to end
    if (isClosed) {
        _pts.unshift(pts[pts.length - 1]);
        _pts.unshift(pts[pts.length - 2]);
        _pts.unshift(pts[pts.length - 1]);
        _pts.unshift(pts[pts.length - 2]);
        _pts.push(pts[0]);
        _pts.push(pts[1]);
    }
    else {
        _pts.unshift(pts[1]);   //copy 1. point and insert at beginning
        _pts.unshift(pts[0]);
        _pts.push(pts[pts.length - 2]); //copy last point and append
        _pts.push(pts[pts.length - 1]);
    }

    // ok, lets start..

    // 1. loop goes through point array
    // 2. loop goes through each segment between the 2 pts + 1e point before and after
    for (i=2; i < (_pts.length - 4); i+=2) {
        for (t=0; t <= numOfSegments; t++) {

            // calc tension vectors
            t1x = (_pts[i+2] - _pts[i-2]) * tension;
            t2x = (_pts[i+4] - _pts[i]) * tension;

            t1y = (_pts[i+3] - _pts[i-1]) * tension;
            t2y = (_pts[i+5] - _pts[i+1]) * tension;

            // calc step
            st = t / numOfSegments;

            // calc cardinals
            c1 =   2 * Math.pow(st, 3)  - 3 * Math.pow(st, 2) + 1; 
            c2 = -(2 * Math.pow(st, 3)) + 3 * Math.pow(st, 2); 
            c3 =       Math.pow(st, 3)  - 2 * Math.pow(st, 2) + st; 
            c4 =       Math.pow(st, 3)  -     Math.pow(st, 2);

            // calc x and y cords with common control vectors
            x = c1 * _pts[i]    + c2 * _pts[i+2] + c3 * t1x + c4 * t2x;
            y = c1 * _pts[i+1]  + c2 * _pts[i+3] + c3 * t1y + c4 * t2y;

            //store points in array
            res.push(x);
            res.push(y);

        }
    }

    return res;
}

และในการวาดจุดเป็นเส้นโค้งที่เรียบ (หรือเส้นแบ่งส่วนอื่น ๆ ตราบใดที่คุณมีอาร์เรย์ x, y):

function drawLines(ctx, pts) {
    ctx.moveTo(pts[0], pts[1]);
    for(i=2;i<pts.length-1;i+=2) ctx.lineTo(pts[i], pts[i+1]);
}

ผลลัพธ์ในสิ่งนี้:

ตัวอย่าง Pix

คุณสามารถขยายผืนผ้าใบได้อย่างง่ายดายเพื่อให้เรียกแบบนี้แทน:

ctx.drawCurve(myPoints);

เพิ่มสิ่งต่อไปนี้ในจาวาสคริปต์:

if (CanvasRenderingContext2D != 'undefined') {
    CanvasRenderingContext2D.prototype.drawCurve = 
        function(pts, tension, isClosed, numOfSegments, showPoints) {
       drawCurve(this, pts, tension, isClosed, numOfSegments, showPoints)}
}

คุณสามารถหารุ่นที่ดีที่สุดมากกว่านี้ใน NPM ( npm i cardinal-spline-js) หรือบนGitLab


3
ก่อนอื่น: มันงดงามมาก :-) แต่เมื่อมองไปที่ภาพนั้นมันไม่ได้ให้ความรู้สึก (ทำให้เข้าใจผิด) ว่าค่าจริงไปต่ำกว่าค่า # 10 ระหว่าง # 9 และ # 10? (ฉันกำลังนับจากจุดจริงที่ฉันเห็นดังนั้น # 1 จะเป็นจุดที่อยู่ใกล้ด้านบนสุดของวิถีลงเริ่มต้น # 2 จุดที่อยู่ล่างสุด [จุดต่ำสุดในกราฟ] และอื่น ๆ ... )
TJ Crowder

6
แค่อยากจะบอกว่าหลังจากวันที่ของการค้นหานี้เป็นเพียง util ที่ทำงานจริงตรงตามที่ฉันต้องการ ขอบคุณมาก
cnp

4
ใช่ใช่ใช่ขอบคุณ! ฉันกระโดดขึ้นและเต้นด้วยความดีใจ
Jeffrey Sun

1
มีข้อผิดพลาดประเภทในรหัสของคุณ พารามิเตอร์ptsaควรเป็นptsหรือมิฉะนั้นจะทำให้เกิดความผิดพลาด
gfaceless

2
นานมาแล้วที่คุณโพสต์วิธีแก้ปัญหานี้และวันนี้คุณช่วยฉันแก้ปัญหาใหญ่ ขอบคุณมาก!
ÂlexBay

19

คำตอบแรกจะไม่ผ่านทุกข้อ กราฟนี้จะผ่านทุกจุดและจะเป็นเส้นโค้งที่สมบูรณ์แบบโดยมีจุดเป็น [{x:, y:}] n จุดดังกล่าว

var points = [{x:1,y:1},{x:2,y:3},{x:3,y:4},{x:4,y:2},{x:5,y:6}] //took 5 example points
ctx.moveTo((points[0].x), points[0].y);

for(var i = 0; i < points.length-1; i ++)
{

  var x_mid = (points[i].x + points[i+1].x) / 2;
  var y_mid = (points[i].y + points[i+1].y) / 2;
  var cp_x1 = (x_mid + points[i].x) / 2;
  var cp_x2 = (x_mid + points[i+1].x) / 2;
  ctx.quadraticCurveTo(cp_x1,points[i].y ,x_mid, y_mid);
  ctx.quadraticCurveTo(cp_x2,points[i+1].y ,points[i+1].x,points[i+1].y);
}

1
นี่เป็นแนวทางที่ง่ายและถูกต้องที่สุด
haymez

10

ในฐานะที่เป็นจุดแดเนียลฮาวเวิร์ดออกร็อบสเปนเซอร์อธิบายถึงสิ่งที่คุณต้องการในhttp://scaledinnovation.com/analytics/splines/aboutSplines.html

นี่คือการสาธิตแบบโต้ตอบ: http://jsbin.com/ApitIxo/2/

นี่คือตัวอย่างข้อมูลในกรณีที่ jsbin ไม่ทำงาน

<!DOCTYPE html>
    <html>
      <head>
        <meta charset=utf-8 />
        <title>Demo smooth connection</title>
      </head>
      <body>
        <div id="display">
          Click to build a smooth path. 
          (See Rob Spencer's <a href="http://scaledinnovation.com/analytics/splines/aboutSplines.html">article</a>)
          <br><label><input type="checkbox" id="showPoints" checked> Show points</label>
          <br><label><input type="checkbox" id="showControlLines" checked> Show control lines</label>
          <br>
          <label>
            <input type="range" id="tension" min="-1" max="2" step=".1" value=".5" > Tension <span id="tensionvalue">(0.5)</span>
          </label>
        <div id="mouse"></div>
        </div>
        <canvas id="canvas"></canvas>
        <style>
          html { position: relative; height: 100%; width: 100%; }
          body { position: absolute; left: 0; right: 0; top: 0; bottom: 0; } 
          canvas { outline: 1px solid red; }
          #display { position: fixed; margin: 8px; background: white; z-index: 1; }
        </style>
        <script>
          function update() {
            $("tensionvalue").innerHTML="("+$("tension").value+")";
            drawSplines();
          }
          $("showPoints").onchange = $("showControlLines").onchange = $("tension").onchange = update;
      
          // utility function
          function $(id){ return document.getElementById(id); }
          var canvas=$("canvas"), ctx=canvas.getContext("2d");

          function setCanvasSize() {
            canvas.width = parseInt(window.getComputedStyle(document.body).width);
            canvas.height = parseInt(window.getComputedStyle(document.body).height);
          }
          window.onload = window.onresize = setCanvasSize();
      
          function mousePositionOnCanvas(e) {
            var el=e.target, c=el;
            var scaleX = c.width/c.offsetWidth || 1;
            var scaleY = c.height/c.offsetHeight || 1;
          
            if (!isNaN(e.offsetX)) 
              return { x:e.offsetX*scaleX, y:e.offsetY*scaleY };
          
            var x=e.pageX, y=e.pageY;
            do {
              x -= el.offsetLeft;
              y -= el.offsetTop;
              el = el.offsetParent;
            } while (el);
            return { x: x*scaleX, y: y*scaleY };
          }
      
          canvas.onclick = function(e){
            var p = mousePositionOnCanvas(e);
            addSplinePoint(p.x, p.y);
          };
      
          function drawPoint(x,y,color){
            ctx.save();
            ctx.fillStyle=color;
            ctx.beginPath();
            ctx.arc(x,y,3,0,2*Math.PI);
            ctx.fill()
            ctx.restore();
          }
          canvas.onmousemove = function(e) {
            var p = mousePositionOnCanvas(e);
            $("mouse").innerHTML = p.x+","+p.y;
          };
      
          var pts=[]; // a list of x and ys

          // given an array of x,y's, return distance between any two,
          // note that i and j are indexes to the points, not directly into the array.
          function dista(arr, i, j) {
            return Math.sqrt(Math.pow(arr[2*i]-arr[2*j], 2) + Math.pow(arr[2*i+1]-arr[2*j+1], 2));
          }

          // return vector from i to j where i and j are indexes pointing into an array of points.
          function va(arr, i, j){
            return [arr[2*j]-arr[2*i], arr[2*j+1]-arr[2*i+1]]
          }
      
          function ctlpts(x1,y1,x2,y2,x3,y3) {
            var t = $("tension").value;
            var v = va(arguments, 0, 2);
            var d01 = dista(arguments, 0, 1);
            var d12 = dista(arguments, 1, 2);
            var d012 = d01 + d12;
            return [x2 - v[0] * t * d01 / d012, y2 - v[1] * t * d01 / d012,
                    x2 + v[0] * t * d12 / d012, y2 + v[1] * t * d12 / d012 ];
          }

          function addSplinePoint(x, y){
            pts.push(x); pts.push(y);
            drawSplines();
          }
          function drawSplines() {
            clear();
            cps = []; // There will be two control points for each "middle" point, 1 ... len-2e
            for (var i = 0; i < pts.length - 2; i += 1) {
              cps = cps.concat(ctlpts(pts[2*i], pts[2*i+1], 
                                      pts[2*i+2], pts[2*i+3], 
                                      pts[2*i+4], pts[2*i+5]));
            }
            if ($("showControlLines").checked) drawControlPoints(cps);
            if ($("showPoints").checked) drawPoints(pts);
    
            drawCurvedPath(cps, pts);
 
          }
          function drawControlPoints(cps) {
            for (var i = 0; i < cps.length; i += 4) {
              showPt(cps[i], cps[i+1], "pink");
              showPt(cps[i+2], cps[i+3], "pink");
              drawLine(cps[i], cps[i+1], cps[i+2], cps[i+3], "pink");
            } 
          }
      
          function drawPoints(pts) {
            for (var i = 0; i < pts.length; i += 2) {
              showPt(pts[i], pts[i+1], "black");
            } 
          }
      
          function drawCurvedPath(cps, pts){
            var len = pts.length / 2; // number of points
            if (len < 2) return;
            if (len == 2) {
              ctx.beginPath();
              ctx.moveTo(pts[0], pts[1]);
              ctx.lineTo(pts[2], pts[3]);
              ctx.stroke();
            }
            else {
              ctx.beginPath();
              ctx.moveTo(pts[0], pts[1]);
              // from point 0 to point 1 is a quadratic
              ctx.quadraticCurveTo(cps[0], cps[1], pts[2], pts[3]);
              // for all middle points, connect with bezier
              for (var i = 2; i < len-1; i += 1) {
                // console.log("to", pts[2*i], pts[2*i+1]);
                ctx.bezierCurveTo(
                  cps[(2*(i-1)-1)*2], cps[(2*(i-1)-1)*2+1],
                  cps[(2*(i-1))*2], cps[(2*(i-1))*2+1],
                  pts[i*2], pts[i*2+1]);
              }
              ctx.quadraticCurveTo(
                cps[(2*(i-1)-1)*2], cps[(2*(i-1)-1)*2+1],
                pts[i*2], pts[i*2+1]);
              ctx.stroke();
            }
          }
          function clear() {
            ctx.save();
            // use alpha to fade out
            ctx.fillStyle = "rgba(255,255,255,.7)"; // clear screen
            ctx.fillRect(0,0,canvas.width,canvas.height);
            ctx.restore();
          }
      
          function showPt(x,y,fillStyle) {
            ctx.save();
            ctx.beginPath();
            if (fillStyle) {
              ctx.fillStyle = fillStyle;
            }
            ctx.arc(x, y, 5, 0, 2*Math.PI);
            ctx.fill();
            ctx.restore();
          }

          function drawLine(x1, y1, x2, y2, strokeStyle){
            ctx.beginPath();
            ctx.moveTo(x1, y1);
            ctx.lineTo(x2, y2);
            if (strokeStyle) {
              ctx.save();
              ctx.strokeStyle = strokeStyle;
              ctx.stroke();
              ctx.restore();
            }
            else {
              ctx.save();
              ctx.strokeStyle = "pink";
              ctx.stroke();
              ctx.restore();
            }
          }

        </script>


      </body>
    </html>


7

ฉันพบว่ามันใช้งานได้ดี

function drawCurve(points, tension) {
    ctx.beginPath();
    ctx.moveTo(points[0].x, points[0].y);

    var t = (tension != null) ? tension : 1;
    for (var i = 0; i < points.length - 1; i++) {
        var p0 = (i > 0) ? points[i - 1] : points[0];
        var p1 = points[i];
        var p2 = points[i + 1];
        var p3 = (i != points.length - 2) ? points[i + 2] : p2;

        var cp1x = p1.x + (p2.x - p0.x) / 6 * t;
        var cp1y = p1.y + (p2.y - p0.y) / 6 * t;

        var cp2x = p2.x - (p3.x - p1.x) / 6 * t;
        var cp2y = p2.y - (p3.y - p1.y) / 6 * t;

        ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, p2.x, p2.y);
    }
    ctx.stroke();
}

6

ฉันตัดสินใจที่จะเพิ่มมากกว่าที่จะโพสต์วิธีแก้ปัญหาในโพสต์อื่น ด้านล่างนี้คือโซลูชันที่ฉันสร้างขึ้นอาจไม่สมบูรณ์แบบ แต่จนถึงขณะนี้ผลลัพธ์ยังดี

สำคัญ:มันจะผ่านทุกจุด!

หากคุณมีความคิดใด ๆ ที่จะทำให้ดีขึ้นโปรดแบ่งปันกับฉัน ขอบคุณ

นี่คือการเปรียบเทียบ before after:

ป้อนคำอธิบายภาพที่นี่

บันทึกรหัสนี้เป็น HTML เพื่อทดสอบ

    <!DOCTYPE html>
    <html>
    <body>
    	<canvas id="myCanvas" width="1200" height="700" style="border:1px solid #d3d3d3;">Your browser does not support the HTML5 canvas tag.</canvas>
    	<script>
    		var cv = document.getElementById("myCanvas");
    		var ctx = cv.getContext("2d");
    
    		function gradient(a, b) {
    			return (b.y-a.y)/(b.x-a.x);
    		}
    
    		function bzCurve(points, f, t) {
    			//f = 0, will be straight line
    			//t suppose to be 1, but changing the value can control the smoothness too
    			if (typeof(f) == 'undefined') f = 0.3;
    			if (typeof(t) == 'undefined') t = 0.6;
    
    			ctx.beginPath();
    			ctx.moveTo(points[0].x, points[0].y);
    
    			var m = 0;
    			var dx1 = 0;
    			var dy1 = 0;
    
    			var preP = points[0];
    			for (var i = 1; i < points.length; i++) {
    				var curP = points[i];
    				nexP = points[i + 1];
    				if (nexP) {
    					m = gradient(preP, nexP);
    					dx2 = (nexP.x - curP.x) * -f;
    					dy2 = dx2 * m * t;
    				} else {
    					dx2 = 0;
    					dy2 = 0;
    				}
    				ctx.bezierCurveTo(preP.x - dx1, preP.y - dy1, curP.x + dx2, curP.y + dy2, curP.x, curP.y);
    				dx1 = dx2;
    				dy1 = dy2;
    				preP = curP;
    			}
    			ctx.stroke();
    		}
    
    		// Generate random data
    		var lines = [];
    		var X = 10;
    		var t = 40; //to control width of X
    		for (var i = 0; i < 100; i++ ) {
    			Y = Math.floor((Math.random() * 300) + 50);
    			p = { x: X, y: Y };
    			lines.push(p);
    			X = X + t;
    		}
    
    		//draw straight line
    		ctx.beginPath();
    		ctx.setLineDash([5]);
    		ctx.lineWidth = 1;
    		bzCurve(lines, 0, 1);
    
    		//draw smooth line
    		ctx.setLineDash([0]);
    		ctx.lineWidth = 2;
    		ctx.strokeStyle = "blue";
    		bzCurve(lines, 0.3, 1);
    	</script>
    </body>
    </html>


5

ลองใช้ KineticJS - คุณสามารถกำหนด Spline ด้วยอาร์เรย์ของจุดต่างๆ นี่คือตัวอย่าง:

URL เก่า: http://www.html5canvastutorials.com/kineticjs/html5-canvas-kineticjs-spline-tutorial/

ดู URL ที่เก็บถาวร: https://web.archive.org/web/20141204030628/http://www.html5canvastutorials.com/kineticjs/html5-canvas-kineticjs-spline-tutorial/


lib ที่น่าทึ่ง! สิ่งที่ดีที่สุดสำหรับงาน!
Dziad Borowy

ใช่!! ฉันต้องการฟังก์ชัน blob () เพื่อสร้างรูปร่างปิดที่ผ่านทุกจุด
AwokeKnowing

7
404. ไม่พบหน้า.
dieter

ลิงค์ต้นฉบับ - 404 dnot found - ดูweb.archive.org/web/20141204030628/http://…
satels

1

สายอย่างไม่น่าเชื่อ แต่ได้รับแรงบันดาลใจจากคำตอบง่ายๆที่ยอดเยี่ยมของ Homan อนุญาตให้ฉันโพสต์วิธีแก้ปัญหาทั่วไป (โดยทั่วไปในแง่ที่โซลูชันของ Homan ขัดข้องในอาร์เรย์ของจุดที่มีจุดยอดน้อยกว่า 3 จุด):

function smooth(ctx, points)
{
    if(points == undefined || points.length == 0)
    {
        return true;
    }
    if(points.length == 1)
    {
        ctx.moveTo(points[0].x, points[0].y);
        ctx.lineTo(points[0].x, points[0].y);
        return true;
    }
    if(points.length == 2)
    {
        ctx.moveTo(points[0].x, points[0].y);
        ctx.lineTo(points[1].x, points[1].y);
        return true;
    }
    ctx.moveTo(points[0].x, points[0].y);
    for (var i = 1; i < points.length - 2; i ++)
    {
        var xc = (points[i].x + points[i + 1].x) / 2;
        var yc = (points[i].y + points[i + 1].y) / 2;
        ctx.quadraticCurveTo(points[i].x, points[i].y, xc, yc);
    }
    ctx.quadraticCurveTo(points[i].x, points[i].y, points[i+1].x, points[i+1].y);
}

0

เพื่อเพิ่มวิธีการที่สำคัญของ K3N และอาจกล่าวถึงความกังวลของ TJ Crowder เกี่ยวกับเส้นโค้ง 'จุ่ม' ในสถานที่ที่ทำให้เข้าใจผิดฉันได้ใส่รหัสต่อไปนี้ในgetCurvePoints()ฟังก์ชันก่อนหน้านี้res.push(x);

if ((y < _pts[i+1] && y < _pts[i+3]) || (y > _pts[i+1] && y > _pts[i+3])) {
    y = (_pts[i+1] + _pts[i+3]) / 2;
}
if ((x < _pts[i] && x < _pts[i+2]) || (x > _pts[i] && x > _pts[i+2])) {
    x = (_pts[i] + _pts[i+2]) / 2;
}

สิ่งนี้จะสร้างกรอบ (มองไม่เห็น) ระหว่างจุดต่อเนื่องแต่ละคู่ได้อย่างมีประสิทธิภาพและทำให้เส้นโค้งอยู่ภายในกรอบขอบเขตนี้นั่นคือ ถ้าจุดบนเส้นโค้งอยู่เหนือ / ล่าง / ซ้าย / ขวาของจุดทั้งสองจุดนั้นจะเปลี่ยนตำแหน่งให้อยู่ในกรอบ ที่นี่มีการใช้จุดกึ่งกลาง แต่สิ่งนี้สามารถปรับปรุงได้โดยอาจใช้การแก้ไขเชิงเส้น


0

หากคุณต้องการกำหนดสมการของเส้นโค้งผ่าน n จุดรหัสต่อไปนี้จะให้ค่าสัมประสิทธิ์ของพหุนามของดีกรี n-1 และบันทึกค่าสัมประสิทธิ์เหล่านี้ลงในcoefficients[]อาร์เรย์ (เริ่มจากระยะคงที่) พิกัด x ไม่จำเป็นต้องเรียงตามลำดับ นี่คือตัวอย่างของหนึ่งพหุนาม Lagrange

var xPoints=[2,4,3,6,7,10]; //example coordinates
var yPoints=[2,5,-2,0,2,8];
var coefficients=[];
for (var m=0; m<xPoints.length; m++) coefficients[m]=0;
    for (var m=0; m<xPoints.length; m++) {
        var newCoefficients=[];
        for (var nc=0; nc<xPoints.length; nc++) newCoefficients[nc]=0;
        if (m>0) {
            newCoefficients[0]=-xPoints[0]/(xPoints[m]-xPoints[0]);
            newCoefficients[1]=1/(xPoints[m]-xPoints[0]);
    } else {
        newCoefficients[0]=-xPoints[1]/(xPoints[m]-xPoints[1]);
        newCoefficients[1]=1/(xPoints[m]-xPoints[1]);
    }
    var startIndex=1; 
    if (m==0) startIndex=2; 
    for (var n=startIndex; n<xPoints.length; n++) {
        if (m==n) continue;
        for (var nc=xPoints.length-1; nc>=1; nc--) {
        newCoefficients[nc]=newCoefficients[nc]*(-xPoints[n]/(xPoints[m]-xPoints[n]))+newCoefficients[nc-1]/(xPoints[m]-xPoints[n]);
        }
        newCoefficients[0]=newCoefficients[0]*(-xPoints[n]/(xPoints[m]-xPoints[n]));
    }    
    for (var nc=0; nc<xPoints.length; nc++) coefficients[nc]+=yPoints[m]*newCoefficients[nc];
}
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.