मैं चिकना/गोलाकार/घुमावदार रेखा ग्राफ कैसे आकर्षित कर सकता हूं? (सी #)

Question

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

मैंने लाइन चिकनाई, एंटी-एलियासिंग, सरलीकरण और इन सभी चीजों के बारे में पढ़ा है। लेकिन जो कुछ भी मैंने पाया है वह कुछ और है।

मुझे एंटी-एलाइजिंग की आवश्यकता नहीं है, स्क्रीन पर लाइन खींचते समय .NET मेरे लिए पहले से ही ऐसा करता है।

मुझे सरलीकरण नहीं चाहिए। मुझे कम से कम उनमें से अधिकतर दिखाई देने के लिए अत्यधिक मूल्यों की आवश्यकता है।

मुझे लगता है कि यह स्पलीन वक्र की दिशा में जाता है लेकिन मुझे यह वर्णन करने के लिए बहुत अधिक उदाहरण छवियां नहीं मिल पाईं कि वर्णित चीज़ मैं चाहता हूं या नहीं। मुझे Google पुस्तकें में एक बहुत ही वैज्ञानिक पुस्तक मिली, हालांकि, आधे पृष्ठ के लंबे सूत्रों से भरा हुआ, जिसे मैं अब पढ़ना पसंद नहीं कर रहा था ...

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

मैं सी # कोड पसंद करूंगा लेकिन अन्य भाषाओं में एल्गोरिदम या कोड ठीक है, जब तक कि मैं बाहरी संदर्भों के बिना इसे सी # पर बंद कर सकता हूं।

Answer 1

आप कुछ डेटा-स्मूथिंग कर सकते हैं। वास्तविक डेटा का उपयोग करने के बजाय, एक सरल चिकनाई एल्गोरिदम लागू करें जो एक Savitzky-Golayfilter की तरह चोटियों को रखता है।

You can get the coefficients here।

सबसे आसान करने के लिए है:

मैं लिंक की गई वेबसाइट से शीर्ष गुणांक ले लो करने के लिए:

// For np = 5 = 5 data points 
var h = 35.0; 
var coeff = new float[] { 17, 12, -3 }; // coefficients from the site 
var easyCoeff = new float[] {-3, 12, 17, 12, -3}; // Its symmetrical 
var center = 2; // = the center of the easyCoeff array 

// अब आप एक सरल बिंदु की गणना अपने डेटा से प्रत्येक बिंदु:

smoothed[x] = 
    ((data[x - 2] * easyCoeff[center - 2]) + 
    (data[x - 1] * easyCoeff[center - 1]) + 
    (data[x - 0] * easyCoeff[center - 0]) + 
    (data[x + 1] * easyCoeff[center + 1]) + 
    (data[x + 2] * easyCoeff[center + 2]))/h; 

5 अंक का उपयोग करते समय आप पहले 2 और अंतिम 2 अंक चिकनी कर सकते हैं।

यदि आप चाहते हैं कि आपका डेटा अधिक "चिकना" हो, तो आप बड़े डेटा बिंदुओं के साथ गुणांक के साथ प्रयोग कर सकते हैं।

अब आप अपने "चिकना" डेटा के माध्यम से एक रेखा खींच सकते हैं। आपके एनपी = अंक की संख्या जितनी बड़ी होगी, उतना ही आसान डेटा होगा। लेकिन आप चरम सटीकता को भी खो देते हैं, लेकिन कुछ बिंदुओं को आसानी से औसत करते समय उतना ही नहीं।

Answer 2

मुझे लगता है कि आप जो खोज रहे हैं वह 'स्प्लिंस' प्रदान करने के लिए एक नियमित है।

http://en.wikipedia.org/wiki/Spline_(mathematics)

अगर ऐसी बात मैं एक पट्टी पुस्तकालय लिए कोई सुझाव नहीं है, लेकिन एक प्रारंभिक Google खोज एक गुच्छा कर दिया: यहाँ एक कड़ी splines वर्णित करते हैं।

कोई कोड के लिए खेद है, लेकिन आशा है कि शब्दावली को जानने से आपकी खोज में सहायता मिलेगी।

बॉब

Answer 3

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

Answer 4

आप इसे ग्राफिक्स कोड में ठीक नहीं कर सकते। यदि आपका डेटा शोर है तो ग्राफ़ शोर होने वाला है, इससे कोई फर्क नहीं पड़ता कि आप किस प्रकार की लाइन को एल्गोरिदम का उपयोग करते हैं। आपको पहले डेटा फ़िल्टर करना होगा। मूल डेटा से इंटरपोल किए गए बिंदुओं के साथ दूसरा डेटा सेट बनाएं। एक कम वर्ग फिट एक आम तकनीक है। औसत लागू करने के लिए सरल है लेकिन चरम सीमाओं को छिपाने के लिए जाता है।

Answer 5

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

यदि 10 पर्याप्त नहीं है तो आप कई और स्टोर कर सकते हैं।

new_average = (old_average*10 - replaced_sample + new_sample)/10 

आप सभी 10 स्टोर करने के लिए हालांकि, नहीं करना चाहते हैं, तो आप इस के साथ अनुमान लगा सकता है:

new_average = old_average*9/10 + new_sample/10 

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

आप इस को लागू करते हैं, तो कुछ इस तरह करते हैं:

new_average = old_average*min(9,number_of_samples)/10 + new_sample/10 
number_of_samples++ 

प्रारंभ में आगे बढ़ने से बचने के लिए। आपको प्रत्येक नमूने के समय अवधि को वास्तव में प्रतिबिंबित करने के लिए 9/10, 1/10 अनुपात को भी समायोजित करना चाहिए क्योंकि आपका टाइमर प्रति सेकंड एक बार ठीक आग नहीं करेगा।