बेज़ियर वक्र चाप की लंबाई

Question

यह भी देखें: Math.SE पर एक ही सवाल

मैं एक बेजियर वक्र की गति कैसे पा सकता हूं? उदाहरण के लिए, एक रैखिक बेजियर वक्र की लंबाई है:

length = sqrt(pow(x[1] - x[0], 2) + pow(y[1] - y[0], 2));

लेकिन द्विघात, घन या एन-डिग्री बेजियर घटता के बारे में क्या?

(मेरा लक्ष्य पहले से ही एक सैंपलिंग रिज़ॉल्यूशन का अनुमान लगाना था, इसलिए अगर अगले बिंदु को अंतिम बिंदु को छूना है तो मुझे समय की जाँच करने की ज़रूरत नहीं है।)

Comments

आपको वक्र की लंबाई को संदर्भित करने के लिए प्रश्न को फिर से लिखना चाहिए, जो कि बहुत अधिक सीधा (और खोज योग्य) शब्द है।

— स्पेर

मैं इसे गणित पर पोस्ट करने का सुझाव देता हूं, मुझे यकीन है कि वहाँ पर कुछ चतुर चेहरा आपको उनमें से एक चतुर वेब फोंट का जवाब देगा: पी

— टोर वालोमा

@ मैंने (कल) किया था, लेकिन मुझे बताया गया है कि यह बहुत जटिल है, और इसलिए अव्यावहारिक है। [ math.stackexchange.com/q/12186/2736 ]

— मतीन उलहाक

माना जाता है कि क्लॉथॉइड कर्व्स / स्प्लिन्स बीज़ियर्स का एक विकल्प है, और इसमें क्लोज-फॉर्म अरक्लोप्रेशन एक्सप्रेशन हैं, लेकिन मुझे इसके बारे में अभी ज्यादा जानकारी नहीं है। (एक वक्र के साथ समान-दूरी के बिंदु उत्पन्न करने की कोशिश कर रहा है।) कैटेनरीज़ में क्लोज-फॉर्म आर्क लंबाई के भाव भी हैं?

— अंतिम

Answer 1

क्यूबिक बेज़ियर्स का एक सरल तरीका यह है कि वक्र को एन सेगमेंट में विभाजित किया जाए और सेगमेंट की लंबाई को योग किया जाए।

हालाँकि, जैसे ही आपको वक्र के केवल भाग की लंबाई की आवश्यकता होती है (जैसे एक बिंदु तक की लंबाई 30%), चाप-लंबाई का पैरामीटरकरण खेल में आ जाएगा। मैंने सरल नमूने कोड के साथ Béziers के बारे में अपने स्वयं के प्रश्नों में एक काफी लंबा उत्तर पोस्ट किया ।

Comments

मैं यह लेगो माइंडस्टॉर्म एनएक्सटी के लिए कर रहा हूं, जिसमें वास्तव में कमजोर प्रोसेसर (48 एमएचज़) है, इसलिए मुझे यथासंभव गति की आवश्यकता है। मैं कुछ गति का संरक्षण करने के लिए विभाजन दृष्टिकोण ले जाऊंगा, और इसे सटीक रूप से पर्याप्त ("गैर-वास्तविक समय" प्रतिपादन के लिए) प्राप्त करूंगा। मेरे पास एक विकल्प भी है जिसमें आप 1.0/t(बुलाया resolution) का मान सेट कर सकते हैं , इसलिए यह "रीयलटाइम" (जो धीमे NXT पर सर्वश्रेष्ठ 10fps पर है) के लिए है। प्रत्येक पुनरावृत्ति, t += resolutionऔर एक नया बिंदु / रेखा खींची गई है। वैसे भी, विचार के लिए धन्यवाद।

— मतीन उलहाक

Answer 2

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

वास्तव में, मेरा मानना ​​है कि यह दृष्टिकोण आमतौर पर तब लिया जाता है जब ग्राफिक्स सबसिस्टम को एक बेज़ियर वक्र खींचना होता है। लेकिन इस पर मुझे उद्धृत न करें, मेरे पास फिलहाल हाथ नहीं है।

व्यवहार में यह इस तरह दिखेगा: (भाषा अप्रासंगिक होने के अलावा)

public static Line[] toLineStrip(BezierCurve bezierCurve, double epsilon) {
    ArrayList<Line> lines = new ArrayList<Line>();

    Stack<BezierCurve> parts = new Stack<BezierCurve>();
    parts.push(bezierCurve);

    while (!parts.isEmpty()) {
        BezierCurve curve = parts.pop();
        if (distanceToBaseline(curve) < epsilon) {
            lines.add(new Line(curve.get(0), curve.get(1)));
        } else {
            parts.addAll(curve.split(0.5));
        }
    }

    return lines.toArray(new Line[0]);
}

Comments

हालांकि यह एक अच्छा दृष्टिकोण है, मैंने उच्च-क्रम के बेजियर घटता पर संख्यात्मक अस्थिरता के बारे में सुना है, जिसके लिए एक और विचार की आवश्यकता होती है: उच्च क्रम वाले घटता को छोटे घन घटता में विभाजित करना।

— मतीन उल्हाक

इसके अलावा, यदि अंतिम लक्ष्य एक सटीक अनुमान है, तो यह सुनिश्चित करने के लिए कि हम उच्च वक्रता वाले स्थानों पर अपने अनुमान को नहीं समझते हैं, लाइनों के बजाय क्वाड्रैटिक्स के साथ अनुमानित करना एक अच्छा विचार हो सकता है।

— मतीन उल्हाक

Answer 3

बेज़ियर घटता के लिए आर्क की लंबाई केवल रैखिक और द्विघात के लिए बंद रूप है। क्यूबिक्स के लिए, यह एक बंद समाधान होने की गारंटी नहीं है। कारण चाप की लंबाई को एक कट्टरपंथी अभिन्न द्वारा परिभाषित किया गया है, जिसके लिए केवल 2 डिग्री बहुपद के लिए एक बंद है।

बस संदर्भ के लिए: अंक (ए, पी) (बी, क्यू) और (सी, आर) के लिए एक द्विघाती बेज़ियर की लंबाई है

(a ^ 2 · (q ^ 2 - 2 · q · r + r ^ 2) + 2 · a · (r - q) · (b · (p - r) + c · (q - p) + () b · (p - r) + c · (q - p)) ^ 2) · LN ((√ (a ^ 2 - 2 · a · b + b ^ 2 + p ^ 2 - 2 · p · q + q ^ 2) · 2 (ए ^ 2 + 2 · ए (सी - 2 · बी) + 4 · बी ^ 2 - 4 · बी · सी + सी ^ 2 + (पी - 2 · क्यू + आर) ^ 2) + a ^ 2 + a · (c - 3 · b) + 2 · b ^ 2 - b · c + (p - q) · (p - 2 · q + r)) / (√ ^ ^ 2 + 2 · एक · (सी - 2 · बी) + 4 · बी ^ 2 - 4 · बी · सी + सी ^ 2 + (पी - 2 · क्यू + आर) ^ 2) · √ (बी ^ 2 - 2 · बी · c + c ^ 2 + q ^ 2 - 2 · q · r + r ^ 2) + a · (b - c) - 2 · b ^ 2 + 3 · b · c - 2 ^ (p - 2 ·) q + r) · (q - r)) / (a ​​^ 2 + 2 · a · (c - 2 · b) + 4 · b ^ 2 - 4 · b · c + c ^ 2 + (p - 2 · Q + r) ^ 2) ^ (3/2) + (a (a ^ 2 - 2 · a · b + b ^ 2 + p ^ 2 - 2 · p · q + q ^ 2) · (a) 2 + ए · (सी - 3 · बी) + 2 · बी ^ 2 - बी · सी + (पी - क्यू) · (पी - 2 · क्यू + आर)) - √ (बी ^ 2 - 2 · बी · सी + c ^ 2 + q ^ 2 - 2 · q · r + r ^ 2) · (a · (b - c) - 2 · b ^ 2 + 3 · b · c - 2 + (p - 2 ·) q + r) · (q - r)) / (a ​​^ 2 + 2 · a · (c - 2 · b) + 4 · b ^ 2 - 4 · b · c + c ^ 2 + (p - 2 · Q + r) ^ 2)

जहां एलएन प्राकृतिक लघुगणक है, और ^ शक्ति और power वर्गमूल को दर्शाता है।

इसलिए, यह किसी अन्य नियम द्वारा बहुभुज या एकीकरण योजना जैसे सिम्पसन के नियम की तरह आसान और सस्ता होना चाहिए, क्योंकि वर्गमूल एलएन महंगे ऑपरेशन हैं।

Answer 4

मैंने 3 पॉइंट बेज़ियर (नीचे) के लिए लंबाई के बंद फॉर्म अभिव्यक्ति पर काम किया। मैंने 4+ बिंदुओं के लिए एक बंद फ़ॉर्म का काम करने का प्रयास नहीं किया है। इसका प्रतिनिधित्व करना और संभालना सबसे मुश्किल या जटिल होगा। हालाँकि, एक संख्यात्मक सन्निकटन तकनीक जैसे कि रंज-कुट्टा एकीकरण एल्गोरिथ्म चाप लंबाई सूत्र का उपयोग करके एकीकृत करके बहुत अच्छा काम करेगा । MSE पर RK45 पर मेरा Q & A , RK45 के कार्यान्वयन में मदद कर सकता है।

यहाँ कुछ बिंदुओं के साथ , और a, 3 पॉइंट बेजियर की चाप लंबाई के लिए कुछ जावा कोड है ।bc

    v.x = 2*(b.x - a.x);
    v.y = 2*(b.y - a.y);
    w.x = c.x - 2*b.x + a.x;
    w.y = c.y - 2*b.y + a.y;

    uu = 4*(w.x*w.x + w.y*w.y);

    if(uu < 0.00001)
    {
        return (float) Math.sqrt((c.x - a.x)*(c.x - a.x) + (c.y - a.y)*(c.y - a.y));
    }

    vv = 4*(v.x*w.x + v.y*w.y);
    ww = v.x*v.x + v.y*v.y;

    t1 = (float) (2*Math.sqrt(uu*(uu + vv + ww)));
    t2 = 2*uu+vv;
    t3 = vv*vv - 4*uu*ww;
    t4 = (float) (2*Math.sqrt(uu*ww));

    return (float) ((t1*t2 - t3*Math.log(t2+t1) -(vv*t4 - t3*Math.log(vv+t4))) / (8*Math.pow(uu, 1.5)));