वास्तविक समय के अनुप्रयोगों में ब्रेसेनहैम का एल्गोरिथ्म

ऐसे उपकरण हैं - जिन्हें स्कैनर या स्कैनर कहा जाता है, आमतौर पर विशेषण "लेजर" के साथ



विभिन्न लेजर स्कैनिंग तकनीकों में उनका उपयोग करें।

एक प्रोग्रामर के दृष्टिकोण से, एक लेजर स्कैनर दो रोटरी दर्पण हैं जो दो परस्पर लंबवत विमानों में एक लेजर बीम को विक्षेपित करते हैं, कोणों को डीएसी (और डीएसीएस के बाद खड़े होने वाले प्रतिक्रिया एम्पलीफायरों) की एक जोड़ी का उपयोग करके सेट किया जाता है। DAC आमतौर पर 12-16 बिट हो सकते हैं। वास्तव में, एक चित्र बनाने का कार्य या, थोड़ी अधिक वैज्ञानिक भाषा बोलना, इस तरह के डिवाइस पर जानकारी का आउटपुट प्राचीन एनालॉग ग्राफिक डिस्प्ले पर जानकारी के आउटपुट से अलग नहीं है।



इस तरह के स्कैनरों को आमतौर पर एक अलग (माइक्रो) कंट्रोलर का उपयोग करके नियंत्रित किया जाता है, जिसमें कंप्यूटर से "उच्च-स्तरीय कमांड" भेजे जाते हैं। मुख्य आदेश "इस तरह की और इस तरह की गति के साथ अब तक एक रेखा खींचना है।" एक बार जब हम एक रेखा और एक माइक्रोकंट्रोलर खींचते हैं, तो हम क्लासिक ब्रेसेनहैम एल्गोरिथ्म को याद करते हैं। ब्रेसेनहैम का एल्गोरिथ्म अच्छा है कि यह किसी भी "धीमी" फ्लोटिंग-पॉइंट ऑपरेशंस का उपयोग नहीं करता है, हालांकि आधुनिक 32-बिट माइक्रोकंट्रोलर्स के लिए यह 8 या 16-बिट्स के लिए उतना महत्वपूर्ण नहीं है।

/* Bresenham algorithm implementation   .. , .. ,  ,*/ void Line(int x1, int y1, int x2, int y2, int color) { int x1,y1,dx,dy,sx,sy,d,d1,d2; int i, x,y; if( x2 >= x1) { dx = x2 - x1; sx = 1; } else { dx = x1 - x2; sx = -1; } if( y2 >= y1) { dy = y2 - y1; sy = 1; } else { dy = y1 - y2; sy = -1; } if(dy <= dx) { d = (dy << 1) - dx; d1 = dy << 1; d2 = (dy - dx) << 1; for(x=x1+sx,y=y1,i=1; i <= dx ; i++,x+=sx) { if(d > 0) { d += d2; y += sy; } else { d += d1; } putpixel(x,y, color); } } else { d = (dx << 1) - dy; d1 = dx << 1; d2 = (dx - dy) << 1; for(x=x1,y=y1+sy,i=1;i <= dy ; i++,y += sy) { if(d > 0) { d += d2; x += sx; } else { d += d1; } putpixel(x,y, color); } } /* endif(dy <=dx) */ } 

हमारे मामले में, कोई रंग नहीं है, इसलिए रंग की अनदेखी की जाती है। लेकिन हमारे पास गति है।
उदाहरण के लिए, यदि हमारे पास n पिक्सेल का एक क्षैतिज या ऊर्ध्वाधर खंड है और V की गति (प्रति सेकंड पिक्सेल) है, तो प्रत्येक पिक्सेल को समय tp = 1 / V प्रदर्शित करना चाहिए

यदि खंड क्षैतिज नहीं है, तो इसकी लंबाई l = हाइप (x0-X1, y0-y1) है , पूरे खंड का आउटपुट समय t0 = l / V है , लेकिन प्रति बिंदु देरी की गणना करने के लिए, पुटिक्सल को कॉल की संख्या से t0 को विभाजित करना आवश्यक होगा, अर्थात। ई।

tp = t0 / max (| x0-X1 |; | y0-y1 |)

फिर, एल्गोरिथ्म में, रंग को केवल "प्वाइंट द्वारा देरी" प्रतीक्षा (= tp) द्वारा प्रतिस्थापित किया जाता है

 void Line(int x1, int y1, int x2, int y2, int wait) ...... putpixel(x,y, wait)); 

पहली नज़र में ही पुटिक्सल फ़ंक्शन कुछ इस तरह दिखना चाहिए

 void putpixel(int x, int y, int wait)) { outPortX(x); //    X  x outPortY(y); //    Y  y delay(wait); //  wait   } 

हालाँकि, DAC के कार्यान्वयन से जुड़ी बारीकियाँ यहाँ से शुरू होती हैं।

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

पहले मामले में, केवल X या केवल Y के आउटपुट में लिया गया समय, X और Y के सीरियल आउटपुट से लगभग दो गुना कम है। तदनुसार, स्रोत कोड पहले से ही ऐसा दिखता है

 void Line(int x1, int y1, int x2, int y2, int wait, int waitXY) { int dx,dy,sx,sy,d,d1,d2; int i, x,y; if( x2 >= x1) { dx = x2 - x1; sx = 1; } else { dx = x1 - x2; sx = -1; } if( y2 >= y1) { dy = y2 - y1; sy = 1; } else { dy = y1 - y2; sy = -1; } /****************************/ if(dy <= dx) { d = (dy << 1) - dx; d1 = dy << 1; d2 = (dy - dx) << 1; for(x=x1+sx,y=y1,i=1; i <= dx ; i++,x+=sx) { if(d > 0) { d += d2; y += sy; putXY(x,y,waitXY); } else { d += d1; putX(x, wait); } } } else { d = (dx << 1) - dy; d1 = dx << 1; d2 = (dx - dy) << 1; for(x=x1,y=y1+sy,i=1;i <= dy ; i++,y += sy) { if(d > 0) { d += d2; x += sx; putXY(x,y,waitXY); } else { d += d1; putY(y, wait); } } } /* endif(dy <=dx) */ } void putXY(int x, int y, int wait)) { outPortXY(x,y); //    X  Y  x  y //    #define outPortXY(x,y) outPortX(x); outPortY(y); delay(wait); //  wait   } void putX(int x, int wait)) { outPortX(x); //    X  x delay(wait); //  wait   } void putY(int y, int wait)) { outPortY(y); //    Y  y delay(wait); //  wait   } 

कॉल करते समय प्रतीक्षा और वेटएक्सवाई के मानों की गणना इस तथ्य के आधार पर की जा सकती है कि:

l = हाइप (x0-X1, y0-y1) , पूरे सेगमेंट का आउटपुट समय t0 = l / V , कॉल की संख्या putXY n1 = min (| x0-X1 |; | y0-y1 |), कॉल putX या putY n0 की संख्या। = अधिकतम (! x0-X1 | |; y0-y1 |) - मिनट (| x0-X1 | |, | y0-y1 |) |

इसके अलावा, आप outPortX, outPortY और outPortXY फ़ंक्शन के रनटाइम के लिए समायोजित कर सकते हैं। इन कार्यों के निष्पादन का समय अंशांकन प्रक्रिया के दौरान अग्रिम में निर्धारित किया जा सकता है।

मैं आपको याद दिलाता हूं कि हम नियंत्रण कंप्यूटर में देरी की सभी गणना करते हैं, और माइक्रोप्रोसेसर में नहीं, लेकिन सवाल में समय और देरी - माइक्रोसेकंड और उनके शेयर ...

खैर, वास्तव में अभी के लिए।

हम इंस्टॉलेशन को इकट्ठा करते हैं, नियंत्रण कंप्यूटर और माइक्रोप्रोसेसर के लिए प्रोग्राम लिखते हैं, इसे चालू करते हैं, कुछ सरल परीक्षण चित्र प्रदर्शित करते हैं और जो हुआ उसे देखते हैं

किसी को भी लगता है कि हम क्या देखेंगे? (जारी रखने के लिए)