🐅 🎐 ❎ प्रक्षेप + (रैखिक | लघुगणक) पैमाने + C ++ 🙂 🐞 👨🏼‍🏭

मुझे किसी तरह "प्रतिरोध -> तापमान" फ़ंक्शन ग्राफ को माइक्रोकंट्रोलर में लोड करने के लिए एक इंटरफ़ेस बनाने की आवश्यकता थी (हमने कई बिंदुओं पर ग्राफ सेट करने का फैसला किया, और फिर उन्हें प्रक्षेपित किया)। इस प्रक्रिया में, यह पता चला कि ग्राफ बहुत गैर-रैखिक (180 ओम -> 100 ^ओ , 6,000 ओम -> 0 ^ओ , 30,000 ओम -> -30 ^ओ ) होगा। इसलिए मुझे लघुगणक तराजू के विषय में गोता लगाना पड़ा ... और तुरंत उभर आया, क्योंकि मुझे वह नहीं मिला जो मुझे चाहिए था। और मुझे बस ऐसे मामलों के गणित (और C ++ में कार्यान्वयन) को समझने की आवश्यकता थी। अद्भुत - यह ऐसा आवश्यक विषय लगता है, लेकिन चित्रित नहीं! खैर, सब ठीक है - दिमाग ने विश्वविद्यालय से उच्च गणित को याद किया और याद किया, और कार्यक्रम लिखा गया था। मैंने अपने क्रम का वर्णन यहाँ करने का निर्णय लिया - शायद कोई काम आएगा।

इस लेख में मैं सिद्धांत (साथ ही बुनियादी आभासी कक्षाएं) का वर्णन करूंगा, अगले में मैं क्यूटी का उपयोग करके विशिष्ट कार्यान्वयन करूंगा।

सावधानी: पाठ में बहुत सारे ग्राफिक्स हैं!

कार्य कहां से बढ़ता है

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

सामान्य तौर पर, मुझे वर्तमान तापमान को जानने की आवश्यकता है। इसे नियमित साधनों द्वारा मापने का निर्णय लिया गया था - एक थर्मिस्टर के साथ। हम उस पार वोल्टेज ड्रॉप को मापते हैं - हमें प्रतिरोध मिलता है। तालिका से आगे (चूंकि यह एक माइक्रोकंट्रोलर है) हम आवश्यक गति प्राप्त करते हैं।

यह तालिका सेट की जानी चाहिए (इसके लिए, प्रोग्राम Qt का उपयोग करके लिखा गया है)। मेरे पास कई बिंदु हैं "प्रतिरोध => तापमान"। मुझे प्रत्येक एडीसी कोड (अवशोषण के मूल्यों के लिए) के लिए उपयुक्त तापमान प्राप्त करने की आवश्यकता है। चूंकि अलग-अलग कारों के लिए ये मूल्य अलग-अलग हो सकते हैं, स्क्रीन पर यह आवश्यक है, टेबल की जांच करने, वक्र पर कई बिंदुओं को सेट करने के लिए।

इस प्रक्रिया में, यह पता चला कि यह ग्राफ स्पष्ट रूप से एक लघुगणकीय पैमाने पर होगा। तो, आपको इसे प्रदर्शित करने की आवश्यकता है। यह कैसे करें - पर पढ़ें।

समस्या का बयान

आइए अधिक विस्तार से वर्णन करें कि हमें क्या चाहिए:

फ़ंक्शन असाइनमेंट - यह कई बिंदुओं को सेट करने के लिए आवश्यक है, जिस पर ग्राफ बनाया गया है। सामान्य तौर पर, हम प्रक्षेप को याद करते हैं ;
एक समारोह की साजिश - हाँ, हाँ, मैं Qwt के बारे में जानता हूँ । शायद मैं उसे बहुत अच्छी तरह से नहीं जानता, क्योंकि मुझे उसमें निम्न संभावना नहीं मिली:
इंटरेक्टिव टास्क परिभाषा - मुझे उन बिंदुओं को स्थानांतरित करने की आवश्यकता है जिनके साथ फ़ंक्शन स्क्रीन पर सही तरीके से बनाया गया है, पैमाने के वर्तमान स्क्रीन निर्देशांक में, जो वास्तविक मूल्य में अनुवाद करता है;
लीनियर / लॉगरिदमिक पैमाना - चूँकि मान वैसा ही है जैसा मैंने लिखा था, मुझे पैमाना बदलना संभव बनाना था। और दोनों एक और दोनों एक ही बार में।

यहाँ टीके है ... ठीक है, कुछ भी नहीं, मैंने किया! मुझे भी आपकी मदद करने दीजिए।

हां, जब तक आप गोता नहीं खाते - CodeCogs से समीकरण संपादक के लिए धन्यवाद! उनकी मदद से, मैंने प्रसिद्ध रूप से सभी गणितीय सूत्र बिना किसी Microsoft समीकरण संपादक के बनाए, जिन्हें तब भी ग्राफिक्स के साथ यहां एक निर्यात करने की आवश्यकता थी। वैसे, एक रूसी संपादक भी है। सामान्य तौर पर, मैं सलाह देता हूं!

ठीक है, अगर सूत्रों के बजाय आप खाली वर्गों को देखते हैं, तो यह समीकरण संपादक के लिए "धन्यवाद" भी है ...

एक्सेल फ़ाइल संलग्न

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

क्रियात्मक निर्भरता

तो, हमारे पास कुछ निर्भरता है - हम इसे नामित करेंगे

। यहाँ हमारे पास है

- ग्राफ का क्षैतिज अक्ष,

- लंबवत। मेरे मामले में

प्रतिरोध का मूल्य था,

- तापमान।

क्यों नहीं?

? आखिर ऐसा लगता है क्या? यह कैसे है, लेकिन ~~केवल~~ सबसे सरल मामले में ~~स्कूल~~ में।

विमान पर बिंदु के निर्देशांक हैं। सादगी के लिए, हम कार्टेशियन समन्वय प्रणाली का उपयोग करने का निर्णय लेते हैं: $छवि$ शून्य के सापेक्ष क्षैतिज अक्ष की ऊर्ध्वाधर ऑफसेट सेट करता है, $छवि$ शून्य के सापेक्ष ऊर्ध्वाधर अक्ष की क्षैतिज ऑफसेट सेट करता है।

जब हम कागज पर इस बहुत समन्वय प्रणाली को आकर्षित करते हैं और इसमें अंक डालते हैं तो सब ठीक है। वास्तव में - उन्होंने केंद्र को चुना, एक शासक के साथ यहां रखा, फिर वहां। लेकिन जब किसी कार्यक्रम में एक ग्राफ बनाते हैं, तो सूक्ष्मताएं शुरू होती हैं - क्या शून्य माना जाना चाहिए? "+" के रूप में क्या विचार करें, और "-" के लिए क्या? मैं इस लेख के लिए CorelDRAW में ग्राफिक्स खींचता हूं - वहां केंद्र को नीचे बाईं ओर से माना जाता है (इसे जहां आवश्यक हो वहां ले जाया जा सकता है)।

और किन इकाइयों में अनुसूची किसी तरह है? सेंटीमीटर में? और क्यों? मेरा अगला चरण Qt का उपयोग करते हुए C ++ में लागू किया जाएगा, इसलिए वहां मैं एक QWidget विंडो बनाऊंगा, जो शून्य पर डिफॉल्ट करता है - यह शीर्ष बाईं ओर है; माप की इकाइयाँ स्क्रीन पिक्सेल हैं।

खैर, यह मत भूलो कि ये सभी सुंदर तर्क अब तक रैखिक पैमाने के लिए मान्य हैं, और हमारे पास क्षितिज पर एक लघुगणक है। वहाँ शैतान जानता है कि क्या होगा!

लेकिन यह सिर्फ बात है। और हमारे पास किसी तरह की लाइन होगी, या बल्कि, बहुत सारी लाइनें होंगी। किस तरह के परिवर्तन होंगे?

यही कारण है कि हमें कार्यात्मक निर्भरता को स्पष्ट रूप से अलग करना चाहिए और परिवर्तनों को शुरू से ही समन्वित करना चाहिए।

तो, चलो निम्नलिखित पर सहमत हैं: हमारे पास कुछ सार प्रक्रिया है जो एक कार्यात्मक निर्भरता द्वारा वर्णित है । स्क्रीन पर प्रदर्शित होने पर, निर्देशांक में रूपांतरण का उपयोग किया जाता है $छवि$ जहाँ $छवि$ । $छवि$ । अगले चरण इन्हीं को स्पष्ट करने के लिए हैं

और

।

लेकिन अब के लिए, निर्देशांक को एक तरफ रख दें - क्या हमें किसी भी तरह से अपना फ़ंक्शन निर्धारित करना है (टीके याद रखें)? और उन बहुत सार निर्देशांक में पूछें

। यही हम करेंगे।

प्रक्षेप

मेरे मामले में, कई बिंदु ज्ञात थे

, Ω	, ˚
180	100
6000	0
30000	-30

इतनी गर्म और बड़ी मेज जटिल नहीं है, लेकिन जाहिर है कि बहुत सारी खाली जगहें हैं। और क्या प्रतिरोध 60˚, -40 resistance, ... से मेल खाता है? सामान्य तौर पर, आपको लापता बिंदुओं को नीचे रखना होगा। और यह हमें प्रक्षेप , सन्निकटन और एक्सट्रपलेशन में मदद करेगा। हालांकि, चिंतित मत हो - आंखों के लिए बस प्रक्षेप पर्याप्त है।

कई प्रक्षेप विधियां हैं, मैं यहां सब कुछ पर विचार नहीं करूंगा। व्यक्तिगत रूप से, मुझे पहले लैग्रेग इंटरपोलेशन बहुपद में पसंद आया। गणना करना और लागू करना, साथ ही कॉन्फ़िगर करना बहुत सरल है। वहाँ यह माना जाता है कि इसका एक सेट

अंक देखें

(यहां हम फॉर्म में बिंदुओं के कार्य के लिए थोड़ी देर के लिए लौट आएंगे

- इसलिए इसे गणित में स्वीकार किया जाता है)।

बहुपद की गणना इस प्रकार की जाती है

जहाँ

।

मैथ डर गया? हम्म ... ठीक है, मैं C ++ में लिखूंगा:

typedef qreal Real; Real Lagranj (Real X) { static const int n = 3; static Real y[n] = {100, 0, -30}; static Real x[n] = {180, 6000, 30000}; Real L, l; int i, j; L = 0; for (i = 0; i < n; ++i) { l = 1; for (j = 0; j < n; ++j) if (i != j) l *= (X - x[j]) / (x[i] - x[j]); L += y[i] * l; } return L; } int main (int argc, char *argv[]) { Real y; y = Lagranj (180); y = Lagranj (500); y = Lagranj (1000); y = Lagranj (6000); y = Lagranj (10000); y = Lagranj (30000); y = Lagranj (0); y = Lagranj (100000); }

जैसा कि आप देख सकते हैं, सब कुछ काफी तुच्छ है (बहुपद कैसे तुच्छ हो सकता है)।

लैग्रेंज बहुपद का एक और बड़ा फायदा यह है कि उन्हें आसानी से एक्सेल टेबल में रखा जा सकता है, जो मैंने किया।

फिर, हालांकि, सब कुछ थोड़ा उदास हो गया, क्योंकि ये बहुपद, किसी भी अन्य की तरह, ग्राफ पर कंपन दिखाते हैं। यही है, वे सीधी रेखाएं नहीं दे सकते हैं - निरंतर मान। मेरे मामले में, मैं उन्हें जरूरी नहीं बता सका - वे स्पष्ट रूप से अमान्य संख्याओं में झुक गए। इसलिए, मुझे उन्हें त्यागना पड़ा ...

Corel में काम करते हुए, मैं Bezier घटता से बहुत परिचित था - सारणीबद्ध डेटा की काफी सुविधाजनक और सरल प्रस्तुति। प्रोग्रामिंग में इसे लागू करना बहुत आसान है। हालांकि, यह अब प्रक्षेप नहीं है, बल्कि बल्कि, सन्निकटन है, क्योंकि यहां आपको वक्र को वांछित रूप में फिट करना है।

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

गणित की भाषा में, हम अंकों के बीच हैं

और

प्रपत्र की सीधी रेखाएँ खींचें $छवि$ ।

फिर, सी ++ में, यह इस तरह दिखेगा:

 typedef qreal Real; Real Linear (Real X) { static const int n = 3; static Real y[n] = {100, 0, -30}; static Real x[n] = {180, 6000, 30000}; static Real k[n] = { (y[1] - y[0]) / (x[1] - x[0]), (y[2] - y[1]) / (x[2] - x[1]), (y[3] - y[2]) / (x[3] - x[2])}; static Real b[n] = { y[0] - k[0] * x[0], y[1] - k[1] * x[1], y[2] - k[2] * x[2]}; int i; // .   ? if (X <= x[0]) return y[0]; else if (X >= x[n-1]) return y[n-1]; // .  ? for (i = 0; i < n-1; ++i) if (X == x[i]) return y[i]; // .  ? for (i = 0; i < n-1; ++i) if (X >= x[i] && X <= x[i + 1]) return k[i] * X + b[i]; return 0; //  -      !!! } int main (int argc, char *argv[]) { Real y; y = Linear (180); y = Linear (500); y = Linear (1000); y = Linear (6000); y = Linear (10000); y = Linear (30000); y = Linear (0); y = Linear (100000); }

क्रांतिकारी कुछ भी नहीं, क्या यह है?

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

हालांकि, अब हम प्रक्षेप तरीकों के साथ परेशान नहीं करेंगे। चलो बेहतर है कि हम एक आधार वर्ग बनाते हैं जिससे हम विभिन्न तरीकों के कार्यान्वयन को विरासत में लेंगे ~~# * @!~~ polation।

किसी फ़ंक्शन को निर्दिष्ट / गणना करने के लिए बेस क्लास

यह वर्ग क्या करने में सक्षम होना चाहिए? मुझे ऐसा लगता है कि इस तरह की एक कक्षा होनी चाहिए:

फ़ंक्शन के मूल्य को तर्क के आधार पर देने के लिए - वास्तव में, जिसके लिए हम इसे बनाते हैं;
प्रक्षेप बिंदुओं में परिवर्तन के लिए प्रतिक्रिया (चाल और पुनरावृत्ति) - कुछ समन्वय में दबाने / जारी करने का तथ्य इनपुट को खिलाया जाता है, जिसके परिणामस्वरूप पैरामीटर पुनर्गणना होते हैं;
सिंगल और डबल माउस क्लिक के बीच अंतर करना - मेरे लिए एक सिंगल क्लिक, एक बिंदु के आंदोलन को इंगित करता है; डबल एक नया बिंदु बनाता है;
जब वे आगे बढ़ रहे हैं, तो उनके बिना और उनके बिना प्रक्षेप प्रक्षेप बिंदु - क्योंकि विभिन्न प्रक्षेप तरीकों में प्रक्षेप बिंदुओं के अलग-अलग सहज ज्ञान वाले मान होंगे, फिर व्युत्पन्न वर्ग उन्हें आउटपुट करना चाहिए (उदाहरण के लिए, प्रक्षेप में, बिंदु ग्राफ का हिस्सा है; सन्निकटन में, बिंदु नहीं होता है; आवश्यक रूप से ग्राफ पर निहित है, बेजियर घटता में, कुछ बिंदु ग्राफ पर स्थित हैं, भाग आकार निर्धारित करता है);
वर्तमान गतिमान बिंदु के निर्देशांक दें - इस बिंदु के निर्देशांक का पाठ प्रदर्शित करना आवश्यक है;
सेवा की जानकारी प्रदान करें - उदाहरण के लिए, "एक फ़ंक्शन परिभाषित है?", "प्रक्षेप के लिए कितने बिंदुओं का उपयोग किया जाता है?", "अंक के निर्देशांक प्राप्त करें", आदि ये डेटा आपको वर्तमान सेटिंग्स को बचाने की अनुमति देंगे;
सेटिंग्स बनाएं - "अधिक से अधिक अंक वितरित करें", "बिंदु के निर्देशांक सेट करें" - यह हमें सहेजे गए सेटिंग्स को पुनर्स्थापित करने की अनुमति देगा।

अभी भी विचार है? यदि हां, तो टिप्पणियों में लिखें, जोड़ें!

यह इस तरह के एक वर्ग निकला:

 class FunctorBase { protected: virtual QPointF &get_point (const int Pos) = 0; //    virtual QPointF get_point (const int Pos) const = 0; //    public: // .  virtual void MouseClicked (const QPointF &Pt) = 0; //       Pt virtual void MouseDblClicked (const QPointF &Pt) = 0; //        Pt virtual void MouseReleased (void) = 0; //    virtual void MouseMove (const QPointF &Pt) = 0; //   (   ),   Pt virtual void DrawPoints (QPainter &p, const ScaleBase &X, const ScaleBase &Y, const int ptRadius, QPen &pnCircle, QBrush &brCircle) = 0; //    ,   virtual void DrawCurPoint (QPainter &p, const ScaleBase &X, const ScaleBase &Y, const int ptRadius, QPen &pnCircle, QBrush &brCircle) = 0; //     (   ,  ) // .  virtual qreal f (const qreal t) const = 0; //     virtual QPointF *point (void) const = 0; //   ;    -  NULL virtual bool is_specified (void) const = 0; //   virtual int num_points (void) const = 0; //     QPointF point (const int Num) const; //      // .  virtual bool set_points (const int Num) = 0; //   ;    QPointF &point (const int Num); //      void set_point (const int Num, const QPointF &Pt); //       // .   qreal operator() (const qreal t) const { return f(t); } //     operator bool (void) const { return is_specified (); } //   QPointF &operator[] (const int Num) { return point (Num); } //      QPointF operator[] (const int Num) const { return point (Num); } //      }; // class FunctorBase inline QPointF &FunctorBase::point (const int Num) { Q_ASSERT_X (Num < num_points (), "receiving points", (QString ("incorrect point index %1 for array size %2 is used"). arg (Num). arg (num_points())).toAscii().constData()); return get_point (Num); } inline QPointF FunctorBase::point (const int Num) const { Q_ASSERT_X (Num < num_points (), "receiving points", (QString ("incorrect point index %1 for array size %2 is used"). arg (Num). arg (num_points())).toAscii().constData()); return get_point (Num); } void FunctorBase::set_point (const int Num, const QPointF &Pt) { point (Num) = Pt; }

(उन लोगों के लिए जो मेरी शैली और संरचना से असंतुष्ट हैं - उद्देश्यपूर्वक बेहतर पेशकश करते हैं!)
(कोड में त्रुटियां खोजने वालों के लिए - धन्यवाद!)

मुझे लगता है कि यहां सब कुछ स्पष्ट है।

निर्देशांक के लिए, बिंदु को QPointF (क्यूरियल, क्यूरियल के रूप में संख्याओं की एक जोड़ी के रूप में दर्शाया गया है। "एआरएम को छोड़कर सभी प्लेटफार्मों पर डबल का उपयोग किया जाता है" - जैसा कि क्यूटी 4.8 के लिए लिखा गया है )।

माउस बटन MouseClicked MouseDblClicked , MouseReleased , MouseReleased और MouseReleased फ़ंक्शन के साथ कार्यान्वित किया जाता है। यह माना जाता है कि विशिष्ट कार्यान्वयन में संबंधित प्रतिक्रियाएं होंगी।

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

फ़ंक्शन का वर्तमान मान f (const qreal) विधि और अतिभारित ऑपरेटर फ़ंक्शन operator() (const qreal) ।

संरचना सेट करने के लिए, set_points (Num) फ़ंक्शन का उपयोग किया जाता है - बिंदुओं की संख्या, point (Num) , set_point (Num) , get_point (Num) निर्धारित करने के लिए - एक विशिष्ट बिंदु के निर्देशांक सेट करने के लिए। num_points () const - बिंदुओं की संख्या लौटाता है, point (Num) const get_point (Num) const , get_point (Num) const बिंदु के निर्देशांक लौटाता है। यदि फ़ंक्शन की संरचना दी गई true तो is_specified () const true है।

अगले लेख में, हम इस वर्ग को लागू करने के लिए कुछ विकल्प लिखेंगे।

ऊर्ध्वाधर / क्षैतिज पैमाने के लिए रूपांतरण समारोह

रैखिक और लघुगणक तराजू हैं। यह देखते हुए कि ऊर्ध्वाधर पैमाने को एक प्रारूप में बनाया जा सकता है, और दूसरे में क्षैतिज एक, हमें चार्ट के लिए चार विकल्प मिलते हैं:

विकल्प एक - दोनों पैमाने रैखिक हैं। विकल्प दो - दोनों लघुगणक। विकल्प तीन और चार मिश्रित ग्राफिक्स हैं। वैसे, मेरे मामले में, यह मिश्रित मामला था जो आखिरकार सामने आया, क्योंकि क्षैतिज रूप से मुझे एक लघुगणकीय पैमाने की आवश्यकता थी, लंबवत - रैखिक।

इसलिए, दोनों अक्षों के लिए मैपिंग समस्या को अलग से हल किया जाना चाहिए।

याद रखें कि स्क्रीन पर प्रदर्शित होने पर, निर्देशांक में रूपांतरण का उपयोग किया जाता है $छवि$ जहाँ $छवि$ । $छवि$ । हमारा अगला कार्य रैखिक और लघुगणक मामलों के लिए इन कार्यों का निर्माण करना है।

ये किस प्रकार के कार्य हैं? इनपुट में उन्हें सार (स्क्रीन पर कंप्यूटर सबरूटीन डिस्प्ले के लिए) निर्देशांक में समन्वय प्राप्त होता है, आउटपुट स्क्रीन में दिया जाता है ("स्क्रीन" निर्देशांक अलग-अलग ऑपरेटिंग सिस्टम के लिए अलग होंगे ") गणना के लिए, उन्हें निम्नलिखित जानने की आवश्यकता है:

अमूर्त निर्देशांक की सीमाएं तर्क और कार्य को सीमित करती हैं जो हमें रुचती हैं। यह होगा । क्षैतिज अक्ष के लिए और । ऊर्ध्वाधर के लिए। कोई क्लासिक गलती करने की आवश्यकता नहीं: । ! उपरोक्त उदाहरण में, यह सचित्र है;
स्क्रीन निर्देशांक की सीमाएं - चित्र की सीमाएं जिसमें ग्राफ खींचा गया है। स्वाभाविक रूप से, वर्तमान स्क्रीन में निर्देशांक। ग्राफ पर यह $छवि$ । $छवि$ क्षैतिज अक्ष के लिए और $छवि$ । $छवि$ ऊर्ध्वाधर के लिए;
स्क्रीन समन्वय कदम - वर्तमान पिक्सेल कदम $छवि$ । $छवि$ । साधारण मामले में, यह एक इकाई होगी। लेकिन Qt में, एक ऊर्ध्वाधर शून्य खिड़की के ऊपर है। इसलिए, $छवि$ । और सभी प्रकार के परिवर्तनों को लागू किया जा सकता है, और कदम पहले से ही किसी भी तरह से नहीं होगा।

कृपया ध्यान दें - रूपांतरण की समस्या के लिए यह कोई मायने नहीं रखता है कि यह एक ऊर्ध्वाधर अक्ष है या नहीं! यह (कार्य) इनपुट, आउटपुट, और आउटपुट मापदंडों के चरण के सीमा मूल्यों के साथ संचालित होता है। इसलिए, समस्या को सामान्यीकृत किया जा सकता है: पैरामीटर को बदलना आवश्यक है इसकी सीमा के आधार पर । उत्पादन करने के लिए इसकी सीमाओं को ध्यान में रखते हुए । और कदम । यहां जानबूझकर नोटेशन पेश किया गया है।

।

सामान्य के बजाय $छवि$ । $छवि$ , क्योंकि अन्यथा भ्रम होगा। एक महत्वपूर्ण इसके अलावा:

।

स्केल परिवर्तनों के लिए बेस क्लास

आइए एक पैमाने के लिए वर्चुअल ट्रांसफॉर्मेशन क्लास की वांछित कार्यक्षमता तैयार करें जिसमें से पैमाने पर कार्यान्वयन विरासत में मिलेगा:

स्क्रीन समन्वय से सार और इसके विपरीत में परिवर्तन - तार्किक रूप से, इसके लिए हम इसे करते हैं;
रूपांतरण सेटिंग भी तार्किक है;
गुण - वर्तमान परिवर्तन गुण (न्यूनतम / अधिकतम मान, विभिन्न मूल्यों के लिए कदम);
ग्रिड की जानकारी - बड़े पैमाने पर मोटे और महीन ग्रिड, लेबल के लिए स्थिति।

एक कार्यान्वयन इस तरह लग सकता है:

 class ScaleBase { public: // .  virtual qreal scr (const qreal Val) const = 0; //       virtual qreal val (const qreal Scr) const = 0; //       // .  virtual const QVector<qreal> &scr_values (void) const = 0; //   ,  [  (    )] int num_scr_values (void) const; virtual const QVector<int> &scr_min_grid (void) const = 0; //      int num_scr_min_grid (void) const; virtual const QVector<int> &scr_maj_grid (void) const = 0; //      int num_scr_maj_grid (void) const; virtual const QVector<int> &scr_text_pos (void) const = 0; //       int num_scr_text_pos (void) const; virtual const QVector<QString> &scr_text_str (void) const = 0; //       int num_scr_text_str (void) const; // .  virtual qreal val_min (void) const = 0; //     ,    virtual qreal val_max (void) const = 0; //     ,    virtual qreal scr_min (void) const = 0; //      virtual qreal scr_max (void) const = 0; //      virtual bool is_specified (void) const = 0; //   // .  virtual void set_val_min (const qreal Val) = 0; //     ,    virtual void set_val_max (const qreal Val) = 0; //     ,    virtual void set_scr_min (const qreal Src) = 0; //      virtual void set_scr_max (const qreal Src) = 0; //      virtual void set_scr_point (const qreal Src) = 0; //     () // .  void Resized (const qreal Size) = 0; //    // .   operator bool (void) const { return is_specified (); } //   }; // class ScaleBase int ScaleBase::num_scr_values (void) const { return scr_values().size(); } int ScaleBase::num_scr_min_grid (void) const { return scr_min_grid().size(); } int ScaleBase::num_scr_max_grid (void) const { return scr_max_grid().size(); } int ScaleBase::num_scr_text_str (void) const { return scr_text_str().size(); } int ScaleBase::num_scr_text_pos (void) const { return scr_text_pos().size(); } virtual qreal ScaleBase::scr_step (const int Num) const { Q_ASSERT_X (Num < num_scr_values (), "receiving step", (QString ("incorrect step index %1 for array size %2 is used"). arg (Num). arg (num_scr_values())).toAscii().constData()); return scr_values()[Num + 1] - scr_values()[Num]; }

स्केल समायोजन set_... (Val) फ़ंक्शन द्वारा किया जाता है। आवश्यक मानों की पुनर्गणना उसी कार्यों में की जानी चाहिए। जब विंडो को Resized (Size) विधि Resized (Size) ।

उत्पादकता बढ़ाने के लिए, आप एक बार स्क्रीन पर एक बिंदु के पत्राचार और मूल, सार निर्देशांक में उसके मूल्य की गणना कर सकते हैं। इस सरणी को scr_values () const विधि द्वारा वापस किया जाता है। इसके अलावा, सरणियों की गणना एक बड़े और छोटे ग्रिड (फ़ंक्शन scr_maj_grid () और scr_min_grid () क्रमशः उन्हें वापस करने के लिए की जाती है। सरणी की लंबाई इन पंक्तियों की संख्या से मेल खाती है, मूल्य स्क्रीन पर पैमाने की शुरुआत के सापेक्ष ऑफसेट से मेल खाती है (यानी, पहले सरणी का सूचकांक)। दो सरणियों की भी अग्रिम गणना की जाती है - शुरुआत ( scr_text_pos () फ़ंक्शन) के सापेक्ष स्केल ( scr_text_str () फ़ंक्शन) और इन हस्ताक्षरों के विस्थापन पर हस्ताक्षर का scr_text_pos () ।

अंत में, प्रत्यक्ष रूपांतरण - अमूर्त से स्क्रीन निर्देशांक तक - scr (Val) फ़ंक्शन द्वारा किया जाता है, रिवर्स वैल (Scr) फ़ंक्शन द्वारा किया जाता है।

रैखिक रूपांतरण

आइए क्षैतिज और ऊर्ध्वाधर अक्ष के लिए रैखिक परिवर्तन पर एक नज़र डालें।

हमारे पास कुछ कार्य हैं - एक प्रतिनिधित्व में एक वक्र। दूसरे के लिए, हमें इसे संकीर्ण करना था और इसे दाईं ओर स्थानांतरित करना था (स्क्रीन पर विंडो कम हो गई थी और दाईं ओर ले जाया गया था)। एक अन्य दृश्य के लिए, हमें इसे बाईं ओर शिफ्ट करना पड़ा (विंडो को बाईं ओर ले जाया गया)। यह गणितीय रूप से कैसे वर्णित है? काफी सरल: $छवि$ । पहले मामले में, ऐसा लगता है

दूसरे में $छवि$ ।

एक अन्य मामले में, हमें वक्र के ऊर्ध्वाधर प्रतिनिधित्व को संकीर्ण करना था और इसे ऊपर ले जाना था। और फिर, सामान्य तौर पर, इसे पलट दें। इन दोनों परिवर्तनों का वर्णन किया गया है $छवि$ । पहले मामले में

। $छवि$ । दूसरे मामले में $छवि$ ।

दोनों परिवर्तनों का गणितीय विवरण समान है:

। इस विवरण में दो स्थिरांक हैं जो परिवर्तन को परिभाषित करते हैं - $छवि$ और $छवि$ । पहला झुकाव के कोण को निर्धारित करता है, दूसरा - शून्य के सापेक्ष ऑफसेट।

इन स्थिरांक की गणना काफी सरल है - यह दो समीकरणों की एक प्रणाली का समाधान है:

$छवि$

।

उलटा परिवर्तन करने में सक्षम होना भी महत्वपूर्ण है - उदाहरण के लिए, माउस पॉइंटर के निर्देशांक को सार निर्देशांक में अनुवाद करें। इसके अलावा कुछ भी जटिल नहीं है:

$छवि$

।

कदम

इस मामले में, इसका उपयोग गणना के लिए नहीं किया जाता है, लेकिन फिर ऑफसेट गणना के लिए यह C ++ कार्यान्वयन में हमारे लिए उपयोगी होगा।

यह व्यवहार में कैसे उपयोग किया जाएगा? हाँ, सब कुछ सरल है! क्षैतिज रूपांतरण:

- ग्राफिक छवि की सीमा

(आमतौर पर बाईं ओर)

(आमतौर पर सही)

- क्षैतिज छवि आउटपुट चरण। ऊर्ध्वाधर परिवर्तन - इसी तरह, लेकिन लंबवत (क्यूटी में)

तस्वीर की निचली सीमा होगी,

- शीर्ष, और

)।

लघुगणक रूपांतरण

और अब हम वहां डुबकी लगाएंगे, जिसके लिए यह सब कुछ है:

(ग्राफ़ पर एक लघुगणक नहीं बनाया गया है, लेकिन इसके समान कुछ है। यह उद्देश्य पर किया जाता है, क्योंकि यहाँ लघुगणक बहुत स्पष्ट नहीं होगा)

अगर

पूरे पैमाने पर फिर वही

हर जगह अलग होगा! यह किस कानून से बदलता है? यह सही है - एक लघुगणक तरीके से! आइए सबसे पहले इसकी पहचान करना सीखें

।

हमारे पास कुल अंक होंगे $छवि$ (जैसे,

।

; तब हमारे पास 3 अंक होंगे)। यह इनपुट मानों की श्रेणी से मेल खाता है। $छवि$ । अर्थ $छवि$ से मेल खाती है $छवि$ । $छवि$ से मेल खाती है $छवि$ । अंतिम बिंदु का एक सूचकांक है $छवि$ । इससे क्या मेल खाता है? $छवि$ ?

रैखिक पैमाने के लिए $छवि$ जहाँ

इनपुट मानों की सीमा द्वारा निर्धारित किया जाता है। यहाँ आप एक ही कर सकते हैं, केवल गुणन के बजाय एक शक्ति को बढ़ाएँगे: $छवि$ (याद है कि $छवि$ )। वहाँ एक है, तथापि, अति सूक्ष्म अंतर: जब

हमारे साथ

, लेकिन चाहिए। यह बस हल है - यूनिट घटाना: $छवि$ । और फिर शून्य मामले के लिए सब कुछ परिवर्तित होता है। गणना कैसे करें

इस मामले में अलग-अलग विकल्प हैं। मैं इसे इस प्रकार करना पसंद करता हूं।

हम जानते हैं कि $छवि$ । उसी समय, अब हम जानते हैं कि $छवि$ । यह समीकरण निकला: $छवि$ । हम इसे सम्मान के साथ हल करते हैं

। याद करना क्या बराबरी है

और घातांक के साथ रूट को बदलने पर, हमें कंप्यूटर के लिए स्वीकार्य दृश्य मिलता है:

(याद है कि

)। महान, आधार मूल्य प्राप्त किया जाता है!

वास्तव में, हमें स्क्रीन से अमूर्त में परिवर्तित करने के लिए एक एल्गोरिथ्म मिला - उलटा समस्या। अब प्रत्यक्ष कार्य मोड एक अमूर्त समन्वय से स्क्रीन समन्वय के लिए परिवर्तित करना है। कार्य को हल करना मुश्किल नहीं है। वास्तव में, आपको खोजने की आवश्यकता है

, और उसके लिए यह आसान और है $छवि$ ।

खोजने के लिए

समीकरण को हल करने की जरूरत है

के बारे में

। ठीक है, तो लघुगणक के गुणों से हमें वह मिलता है

। अच्छी तरह से और आगे, स्क्रीन को ढलान के साथ एक लाइन के रूप में समन्वयित करने पर विचार करते हुए, हमें वह मिलता है $छवि$ (संपूर्ण सौंदर्य के लिए

के साथ बदलें

)।

इसे मूल गणित माना जाता है। मिली त्रुटियां या गलतियाँ - टिप्पणियों में लिखें, मैं आभारी रहूंगा!

समय के साथ, मैं निम्नलिखित लेख लिखूंगा - C ++ में Qt टूल का उपयोग करके इस गणित का कार्यान्वयन।

प्रक्षेप + (रैखिक | लघुगणक) पैमाने + C ++