बेजियर घटता के कार्यान्वयन के बारे में प्रश्न?

Question

मैंने बेजियर वक्र के लिए कुछ ट्यूटोरियल पढ़े हैं जैसे कि यह http://www.codeproject.com/KB/recipes/BezirCurves.aspx।

बेजियर वक्र बनाने का मूल विचार कुछ नियंत्रण बिंदुओं का उपयोग करना है और निर्णय लेना है कि कितने नए अंक बनाए जाने की आवश्यकता है। और फिर उन नए बिंदुओं को अलग करें।

मान लें मैं 1000 अंक है और मैं अधिक 2000 अंक को जोड़ चाहते हैं:

यहाँ सवाल है। नियंत्रण बिंदुओं की संख्या मैं उपयोग करना चाहता हूं 5. पैरामीटर टी [0, 1] की सीमा में है।

गिवेन्स अंक पी 0, पी 1, पी 2, पी 3, पी 4, पी 5, पी 6, ... पी 1000। मैं नए अंक उत्पन्न करने के लिए पी 0-पी 4 का उपयोग कर सकता हूं, फिर अगला क्या है? नए अंक उत्पन्न करने के लिए पी 5-पी 9 का उपयोग करें ??? मैं तुरंत देख सकता हूं कि पी 4 और पी 5 के बीच अचानक परिवर्तन होता है।

मैं इस मुद्दे को कैसे हल कर सकता हूं?

आप

धन्यवाद //////////////////////////////////////// ///////////// हैलो स्टार्गज़र 712,

जब तक यह कार्यान्वयन विधि तक नहीं पहुंच जाता तब तक मैं आपकी टिप्पणियों को समझता हूं।

मान लें हम निम्नलिखित बातों है:

A1->A2->A3->A4->A5->A6->A7->A8 initial points 

आपने कहा था कि हम हर दूसरे जोड़ी के मध्य में नया बिंदु जोड़ने की जरूरत है।

मेरा प्रश्न यह है कि नए बिंदु का आदेश क्या है?

Let उपयोग यह व्याख्या (A1 + A3)/2 == का उपयोग A12

अब निर्मित किए गए नए अंक

A13 A24 A35 A46 A57 A68 (this is what you mean "every other pair"? 

कहाँ मैं मूल सूची में उन बिंदुओं डालूँ कर रहे हैं?

मैं जो काम कर रहा हूं वह बाइनरी छवि से निकाला गया है। जेनरेटेड समोच्च ज़िग-ज़ैग आकार है। इस चिकनी विधि को लागू करने के बाद, यह आकार बहुत अधिक सुधार नहीं करता है। मुझे लगता है कि मुख्य कारण यह है कि पड़ोसी एक दूसरे के पास हैं और इंटरपोलेशन को उपयोगी नहीं बनाते हैं।

आप

धन्यवाद //////////////////////////////////////// ////////////

Answer 1

मुझे लगता है कि आप जो करने की कोशिश कर रहे हैं वह बिंदुओं को इंटरपोल करने के लिए एक चिकनी वक्र बनाना है। ऐसा करने के लिए, आपको बेजियर घटता के बारे में निम्नलिखित समझने की आवश्यकता है:

कहें कि हमारे पास अंक ए 1, ए 2, ए 3, ए 4, और बी 1, बी 2, बी 3 और बी 4 के साथ दो वक्र हैं।

यदि दो वक्र एक ही बिंदु पर समाप्त होते हैं, और यदि पहले का अंतिम नियंत्रण बिंदु अगले के पहले नियंत्रण बिंदु के साथ कॉलिनर है, तो वक्र चिकनी हो जाएंगे।इसलिए हमारे उदाहरण में, यदि:

• ए 4 == बी 1
• A3, A4, और बी 2 colinear हैं (ए 3, बी 1, बी 2 यह कहते हुए एक ही colinear हैं)

तब घटता जाएगा चिकनी हो।

अंक की मनमानी सूची लेने और एक चिकनी वक्र बनाने के लिए, हमें इन दोनों स्थितियों को सत्य होने की आवश्यकता है।

ऐसा करने के लिए, मान लीजिए कि है कि हम अंक का एक सेट के साथ शुरू:

उपरोक्त शर्तों के लिए मजबूर करने के लिए, कुछ अतिरिक्त अंक जोड़ सकते हैं। हम हर दूसरे जोड़ी के मध्य में एक नया बिंदु लगा देंगे दिखाया गया है:

अब हम 0-3 अंक, 3-6, 6-9, आदि के बीच बेज़ियर घटता आकर्षित कर सकते हैं

आशा इस मदद करता है:, और हम सुनिश्चित करें कि यह एक चिकनी वक्र बनेगी हो सकता है!

संपादित करें: यहां एक साधारण पायथन प्रोग्राम है जो ऊपर दिखाया गया था (और मेरा मतलब बिल्कुल) लागू करता है। आप अजगर और जनहित याचिका स्थापित करने की आवश्यकता:

from PIL import Image 
import math 

# 
# draws a single point on our image 
# 
def drawPoint(img, loc, size=5, color=(0,0,0)): 
    px = img.load() 
    for x in range(size): 
     for y in range(size): 
      xloc = loc[0] + x - size/2 
      yloc = loc[1] + y - size/2 
      px[ xloc, yloc ] = color 


# 
# draws a simple bezier curve with 4 points 
#    
def drawCurve(img, points): 

    steps = 20 
    for i in range(steps): 

     t = i/float(steps) 

     xloc = math.pow(1-t,3) * points[0][0] \ 
      + 3*t*math.pow(1-t,2) * points[1][0] \ 
      + 3*(1-t)*math.pow(t,2) * points[2][0] \ 
      + math.pow(t,3) * points[3][0] 
     yloc = math.pow(1-t,3) * points[0][1] \ 
      + 3*t*math.pow(1-t,2) * points[1][1] \ 
      + 3*(1-t)*math.pow(t,2) * points[2][1] \ 
      + math.pow(t,3) * points[3][1] 

     drawPoint(img, (xloc,yloc), size=2) 


# 
# draws a bezier curve with any number of points 
# 
def drawBezier(img, points): 

    for i in range(0,len(points),3): 
     if(i+3 < len(points)): 
      drawCurve(img, points[i:i+4]) 


# 
# draws a smooth bezier curve by adding points that 
# force smoothness 
# 
def drawSmoothBezier(img, points): 

    newpoints = [] 

    for i in range(len(points)): 

     # add the next point (and draw it) 
     newpoints.append(points[i]) 
     drawPoint(img, points[i], color=(255,0,0)) 

     if(i%2 == 0 and i>0 and i+1<len(points)): 

      # calculate the midpoint 
      xloc = (points[i][0] + points[i+1][0])/2.0 
      yloc = (points[i][1] + points[i+1][1])/2.0 

      # add the new point (and draw it) 
      newpoints.append((xloc, yloc)) 
      drawPoint(img, (xloc, yloc), color=(0,255,0)) 

    drawBezier(img, newpoints) 



# Create the image 
myImage = Image.new("RGB",(627,271),(255,255,255)) 

# Create the points 
points = [ (54,172), 
      (121,60), 
      (220,204), 
      (284,56), 
      (376,159), 
      (444,40), 
      (515,228), 
      (595,72) ] 

# Draw the curve 
drawSmoothBezier(myImage, points) 

# Save the image 
myImage.save("myfile.png","PNG") 

लाइन अंक के पैटर्न का पालन करेंगे। यदि आपका परिणाम ज़िग-ज़ैगड है, तो ऐसा इसलिए है क्योंकि रेखाएं जैसी दिखती हैं।