जावास्क्रिप्ट एचटीएमएल 5 कैनवास का उपयोग करके एन बिंदुओं के माध्यम से चिकनी वक्र कैसे बनाएं?


133

एक ड्राइंग एप्लिकेशन के लिए, मैं माउस आंदोलन को एक सरणी के लिए समन्वयित कर रहा हूं, फिर उन्हें लाइनटॉ के साथ आरेखण कर रहा हूं। परिणामी लाइन चिकनी नहीं है। मैं सभी एकत्रित बिंदुओं के बीच एक एकल वक्र कैसे बना सकता हूं?

मैंने गुगली की है, लेकिन मुझे केवल रेखाएँ खींचने के लिए 3 कार्य मिले हैं: 2 नमूना बिंदुओं के लिए, बस उपयोग करें lineTo। 3 नमूना अंक के लिए quadraticCurveTo, 4 नमूना अंक के लिए, bezierCurveTo

(मैंने bezierCurveToसरणी में प्रत्येक 4 बिंदुओं के लिए ड्राइंग करने की कोशिश की , लेकिन यह निरंतर चिकनी वक्र के बजाय हर 4 नमूना बिंदुओं को डुबो देता है।)

मैं 5 नमूना बिंदुओं और उससे आगे के साथ एक चिकनी वक्र खींचने के लिए एक फ़ंक्शन कैसे लिखता हूं?


5
"सुचारू" से आपका क्या मतलब है? असीम रूप से भिन्न? दो बार अंतर करने योग्य? क्यूबिक स्प्लिन ("बेजियर कर्व्स") में कई अच्छे गुण होते हैं और दो बार भिन्न होते हैं, और गणना करने के लिए काफी आसान होते हैं।
केरेक एसबी

7
@ केर एसबी, "चिकनी" से मेरा मतलब है कि नेत्रहीन किसी भी कोने / क्यूप्स आदि का पता नहीं लगा सकते हैं
हॉनर

@sketchfemme, क्या आप वास्तविक समय में लाइनों को प्रस्तुत कर रहे हैं, या बिंदुओं का एक गुच्छा इकट्ठा करने के बाद तक प्रतिपादन में देरी कर रहे हैं?
Crashalot

@ चरसालोट मैं एक सरणी में अंक एकत्र कर रहा हूं। इस एल्गोरिथ्म का उपयोग करने के लिए आपको कम से कम 4 अंक चाहिए। उसके बाद आप MouseMove की प्रत्येक कॉल पर स्क्रीन को साफ़ करके एक कैनवास पर वास्तविक समय में प्रस्तुत कर सकते हैं
Homan

1
@sketchfemme: किसी उत्तर को स्वीकार करना न भूलें। यह ठीक है अगर यह आपका अपना है
टीजे क्राउडर

जवाबों:


130

असंतुष्ट "कर्टो" प्रकार के कार्यों के साथ बाद के नमूना बिंदुओं के साथ जुड़ने में समस्या यह है कि जहां वक्र मिलते हैं वह चिकना नहीं है। ऐसा इसलिए है क्योंकि दो घटता अंत बिंदु साझा करते हैं लेकिन पूरी तरह से नियंत्रण बिंदुओं से प्रभावित होते हैं। एक समाधान अगले 2 बाद के नमूना बिंदुओं के बीच के मध्य बिंदुओं को "वक्र" करना है। इन नए प्रक्षेपित बिंदुओं का उपयोग करते हुए घटता से जुड़ना अंत बिंदुओं पर एक चिकनी संक्रमण देता है (एक पुनरावृत्ति के लिए एक अंतिम बिंदु क्या है ) अगले पुनरावृत्ति के लिए एक नियंत्रण बिंदु बन जाता है ।

यह समाधान "फाउंडेशन एक्शनस्क्रिप्ट 3.0 एनिमेशन: मेकिंग थिंग्स मूव" पुस्तक से निकाला गया था। p.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 के लिए महान काम किया / कैनवास परियोजना मैं पर काम कर रहा हूँ
मैट

1
सहायता करके हमें खुशी होगी। FYI करें, मैंने एक ओपन सोर्स html5 कैनवास ड्राइंग पैड शुरू किया है जो एक jQuery प्लगइन है। यह एक उपयोगी प्रारंभिक बिंदु होना चाहिए। github.com/homanchou/sketchyPad
हैमन

4
यह अच्छा है, लेकिन आप वक्र कैसे बनाएंगे ताकि यह सभी बिंदुओं से होकर गुजरे?
रिचर्ड

इस एल्गोरिथ्म के साथ प्रत्येक क्रमिक वक्र पिछले वक्र अंत बिंदु से शुरू होता है?
ली ब्रिंडले

आपको बहुत बहुत धन्यवाद! यह काम करता हैं! मैंने इसे सुलझाने के लिए बहुत दिन बिताए। और डेल्फी एंड्रॉइड / आईओएस समुदाय से हाय!
एलिट्रन

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

यह इस में परिणाम है:

उदाहरण पिक्स

आप कैनवास को आसानी से बढ़ा सकते हैं ताकि आप इसे इस तरह से कॉल कर सकें:

ctx.drawCurve(myPoints);

जावास्क्रिप्ट में निम्नलिखित जोड़ें:

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

आप एनपीएम ( npm i cardinal-spline-js) या गिटलैब पर इसका अधिक अनुकूलित संस्करण पा सकते हैं ।


3
सबसे पहले: यह बहुत खूबसूरत है। :-) लेकिन उस छवि को देखते हुए, यह (भ्रामक) धारणा नहीं देता है कि मूल्य वास्तव में # 9 और # 10 के बीच # 10 एन मार्ग से नीचे गए हैं? (मैं वास्तविक डॉट्स से गिनती कर रहा हूं जो मैं देख सकता हूं, इसलिए # 1 प्रारंभिक डाउनवर्ड प्रक्षेपवक्र के शीर्ष के पास एक होगा, # 2 बहुत नीचे [ग्राफ में सबसे कम बिंदु], और इसी तरह ... )
टीजे क्राउडर

6
केवल यह कहना चाहता हूं कि खोज के दिनों के बाद, यह एकमात्र उपयोग था जो वास्तव में ठीक वैसा ही काम करता था जैसा मैं चाहता था। बहुत बहुत धन्यवाद
cnp

4
हाँ हाँ, धन्यवाद! मैं उछल पड़ा और खुशी में नाचने लगा।
जेफरी सन

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
यह अब तक का सबसे सरल और सही तरीका है।
हाइमज

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

मैं अपने समाधान को किसी अन्य पोस्ट पर पोस्ट करने के बजाय जोड़ने का फैसला करता हूं। नीचे दिए गए समाधान जो मैं बना रहा हूं, वे सही नहीं हो सकते हैं, लेकिन अभी तक उत्पादन अच्छा है।

महत्वपूर्ण: यह सभी बिंदुओं से होकर गुजरेगा!

यदि आपके पास इसे बेहतर बनाने के लिए कोई विचार है , तो कृपया मुझे साझा करें। धन्यवाद।

यहाँ पहले की तुलना के बाद हैं:

यहाँ छवि विवरण दर्ज करें

इसे जांचने के लिए इस कोड को 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

काइनेटिकस को एक कोशिश दें - आप एक सरणी को बिंदुओं के साथ परिभाषित कर सकते हैं। यहाँ एक उदाहरण है:

पुराना 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


कमाल का काम! कार्य के लिए सबसे अच्छा एक!
दिजाद बोरोवी

हाँ!! मुझे एक बंद आकार बनाने के लिए बूँद () फ़ंक्शन की आवश्यकता थी जो सभी बिंदुओं से गुजरता है।
AwokeKnowing

7
404 पृष्ठ नहीं मिला।
डाइटर

मूल लिंक - 404 नहीं मिला - web.archive.org/web/2014120404030628/http://…
satels

1

अविश्वसनीय रूप से देर से लेकिन होमन के शानदार सरल उत्तर से प्रेरित, मुझे एक अधिक सामान्य समाधान पोस्ट करने की अनुमति दें (सामान्य अर्थ में कि होमन का समाधान कम से कम 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 के कार्डिनल स्पाइन विधि में जोड़ने के लिए और शायद टीजे क्राउडर के भ्रामक स्थानों में घटता 'सूई' के बारे में चिंताओं को संबोधित करते हुए, मैंने 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 निर्देशांक क्रम में नहीं होना चाहिए। यह एक लैग्रेंज बहुपद का एक उदाहरण है ।

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