प्रसंस्करण और वीके एपीआई का उपयोग करके जन्मदिन की लोकप्रियता का नक्शा बनाएं

प्रविष्टि

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

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

कुछ समय बाद, दृश्य के लेखक ने उसी ब्लॉग पर एक दूसरी पोस्ट प्रकाशित की, जो छवि पर काम में उपयोग किए गए मूल डेटा पर ठीक से टिप्पणी किए बिना समुदाय को गुमराह करने के लिए माफी मांगता है। समस्या यह थी कि मूल डेटा सेट में किसी निश्चित दिन पर पैदा हुए लोगों की वास्तविक संख्या के बारे में जानकारी नहीं थी। जानकारी दूसरे रूप में दी गई थी - जन्मदिन की लोकप्रियता की "रेटिंग" में यह किस स्थान (रैंक) पर है।

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

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

सभी कार्यों के लिए, मैंने प्रसंस्करण वातावरण का उपयोग किया, जो परंपरागत रूप से ऐसे कार्यों के लिए उपयोग किया जाता है (आपको उपकरण चुनने की समस्या पर ध्यान नहीं देना चाहिए)।

तो, एक परियोजना पर काम करने की प्रक्रिया में एक स्थिर संरचना होती है और इसमें तीन चरण होते हैं:
डेटा संग्रह> डेटा सॉर्टिंग> डेटा विज़ुअलाइज़ेशन

हम इस संरचना का पालन करेंगे।

1. डेटा संग्रह

हम vk.com सोशल नेटवर्क उपयोगकर्ता प्रोफाइल से डेटा पुनः प्राप्त करेंगे। सौभाग्य से हमारे लिए, इसके एपीआई के कुछ तरीके खुले हैं और आवेदन प्राधिकरण की आवश्यकता नहीं है, जो कार्य को बहुत सरल करता है।

जाहिर है, मैंने पाया कि ये 100,000 प्रोफाइल कैलेंडर में जन्मदिन के वितरण में यादृच्छिक विषमताओं को बाहर करने के लिए पर्याप्त होंगे और मुख्य रुझानों की पहचान करेंगे। फिर भी, समय और प्रदर्शन को बचाने के लिए, हम 10,000 रिकॉर्ड एकत्र करेंगे। बाद में हम प्रोग्राम में जितने भी प्रोफाइल की जरूरत होती है, उसकी जगह ले सकते हैं।

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

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

इसलिए, हम प्रोग्राम के लिए खाली ब्लैंक लिखते हैं।

 void setup() { //   exit(); //   } 

अब देखते हैं कि वीके एपीआई कैसे काम करता है। हम अपने अनुरोध के मापदंडों वाले एक विशेष URL पर सर्वर का उपयोग करते हैं:

  http://api.vk.com/method/users.get.xml/uids=lookhere हमारे लिए ब्याज के उपयोगकर्ताओं की आईडी की सूची है, जो अल्पविराम द्वारा अलग की गई है} और फ़ील्ड = {यहां उपयोगकर्ता की रुचि के प्रोफ़ाइल के क्षेत्रों के नामों की सूची है}} 

यदि हम .xml के बिना विधि का नाम लिखते हैं, तो हमें JSON प्रारूप में एक स्ट्रिंग के रूप में सर्वर से एक प्रतिक्रिया प्राप्त होगी। यह एक विकल्प है, लेकिन इस उदाहरण में हम XML का उपयोग करेंगे। मान लीजिए कि हम vkontakte के संस्थापक पावेल डरोव के खाते से जानकारी प्राप्त करना चाहते हैं। हमारा पता:

  http://api.vk.com/method/users.get.xml?uids=1&fields=bdate 

उसकी प्रोफ़ाइल का आईडी - 1, हमारे लिए ब्याज का क्षेत्र - उसका जन्मदिन - जिसे bdate कहा जाता है।

आइए इस प्रोफ़ाइल के बारे में जानकारी प्राप्त करने का प्रयास करें। हम अंतर्निहित फ़ंक्शन लोडस्ट्रेस () का उपयोग करते हैं, जो एक पैरामीटर के रूप में हमें ब्याज की फ़ाइल के पते के साथ एक स्ट्रिंग के रूप में लेता है, और स्ट्रिंग की एक सरणी के रूप में फ़ाइल की सामग्री को लौटाता है।

 void setup() { String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=1&fields=bdate"); //  println(user); //   ( )   exit(); //   } 

कंसोल में प्रोग्राम शुरू करने के बाद, सर्वर से हमारी प्रतिक्रिया दिखाई देगी:

 [0] "<?xml version="1.0" encoding="utf-8"?>" [1] "<response list="true">" [2] " <user>" [3] " <uid>1</uid>" [4] " <first_name></first_name>" [5] " <last_name></last_name>" [6] " <bdate>10.10.1984</bdate>" [7] " </user>" [8] "</response>" 

वर्ग कोष्ठक की संख्या का अर्थ सरणी में रिकॉर्ड (सूचकांक) की संख्या है और यह सरणी की सामग्री से संबंधित नहीं है। इसके अलावा, प्रत्येक पंक्ति उद्धरण चिह्नों में संलग्न है। दरअसल, उद्धरण चिह्नों के बीच जो है वह हमारी सामग्री है। हम क्षेत्र में रुचि रखते हैं

  <Bdate> 

(लाइन [6])। इसमें वह जानकारी है जिसमें हम रुचि रखते हैं - एक समझने योग्य प्रारूप में उपयोगकर्ता संख्या 1 के जन्म की तारीख: 10 वें महीने का 10 वां दिन (अक्टूबर 1984)।

हम 10,000 जन्मतिथि जमा करने के लिए सहमत हुए। हम क्या कर रहे हैं? हम उपयोगकर्ता आईडी पर 1 से उस नंबर पर पुनरावृति करते हैं, जिसकी हमें आवश्यकता है। समस्या यह है कि सभी आईडी में वैध प्रोफाइल नहीं हैं और सभी उपयोगकर्ता अपनी जन्म तिथि नहीं खोलते हैं। इस प्रकार, हमें दो काउंटरों की आवश्यकता है: पहला काउंटर क्रम में उपयोगकर्ता आईडी की गणना करेगा, और दूसरा यह गिनती करेगा कि हम वास्तव में समय में बंद करने के लिए कितने दिनांक एकत्र किए थे। अनुभव के अनुसार, 10,000 तारीखें प्राप्त करने के लिए, आपको लगभग 15,000 खातों को छांटने की जरूरत है।

हम एक चक्र लिखते हैं:

 void setup() { int count = 0; //     for (int i = 1; count <= 10000; i++) { // id,  ,        10000 String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=" + str(i) + "&fields=bdate"); // ,     id for (int j = 0; j < user.length; j++) { //    if (user[j].indexOf("<bdate>") != -1) { //      println(i + "\t" + count + "\t" + user[j]); //    count++; //    1 } } } exit(); //   } 

ध्यान दें कि काउंटर I का मूल्य, जब हम इसे एक स्ट्रिंग में प्रतिस्थापित करते हैं, तो str () फ़ंक्शन द्वारा "लिपटे" होता है। एक नंबर से एक स्ट्रिंग तक डेटा प्रकार का अनुवाद करने की आवश्यकता है। कड़ाई से बोलते हुए, कार्यक्रम समझ जाएगा कि हम इस ऑपरेशन के बिना उससे क्या चाहते हैं, लेकिन यह तुरंत चीजों को नियंत्रित करने की आदत के रूप में बेहतर है कि डेटा को एक प्रकार से दूसरे में स्थानांतरित करना (कुछ स्थितियों में, स्वचालित अनुवाद काम नहीं करता है)।

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

जब हम कंसोल के लिए ब्याज का डेटा प्रदर्शित करते हैं, तो हम अतिरिक्त जानकारी जोड़ेंगे: प्रगति की निगरानी के लिए काउंटरों की स्थिति। Println () आउटपुट फ़ंक्शन के कोष्ठक में चर के मूल्यों को स्ट्रिंग "\ t" द्वारा अलग किया जाता है, जिसका अर्थ है टैब वर्ण।

यदि हम अब प्रोग्राम चलाते हैं, तो हम देखेंगे कि काउंटर वैल्यू जल्दी से डायवर्ट होते हैं। मेरे मामले में, 55 से अधिक आईडी के पुनरावृत्त होने के बाद, केवल 31 तारीखें एकत्र की गईं।

तो, ऐसा लगता है कि सब कुछ ठीक काम कर रहा है, यह केवल प्रोग्राम को फ़ाइल के लिए डेटा लिखने के लिए मजबूर करने के लिए रहता है। ऐसा करने के लिए, PrintWriter वर्ग का ऑब्जेक्ट बनाएं। इसे एक साधारण चर के रूप में घोषित किया जाता है, और एक नियम के रूप में, इसे तुरंत createWriter फ़ंक्शन (फ़ाइल पथ) का मान असाइन किया जाता है:

 PrintWriter p = createWriter("data/bdates.txt"); 

इस स्थिति में, हम ऑब्जेक्ट को "p" नाम देते हैं, इसे एक फाइल को "प्रोग्राम फ़ोल्डर / डेटा / bdates.txt" पते पर संलग्न करते हैं, जो हमें इस फाइल को लिखने की अनुमति देगा। हम यह कैसे करते हैं? आप हमारी वस्तु पर प्रिंटलाइन () विधि लागू कर सकते हैं, जो उसी नाम के कार्य के समान कार्य करता है, लेकिन कंसोल में नहीं, बल्कि निर्दिष्ट फ़ाइल में डेटा प्रदर्शित करता है। यह इस तरह दिखता है:

 p.println(); 

हमने अपनी फ़ाइल के साथ काम करने के बाद, आपको इसके साथ काम करना सही ढंग से पूरा करने की आवश्यकता है, अन्यथा इसकी जानकारी नहीं लिखी जाएगी। यह निम्नलिखित रिकॉर्ड का उपयोग करके किया जाता है:

 p.flush(); p.close(); 

ये दोनों फ़ंक्शन हमेशा फ़ाइल को एक साथ सही ढंग से पूरा करने के लिए उपयोग किए जाते हैं। हमारा कार्यक्रम:

 void setup() { PrintWriter p = createWriter("data/bdates.txt"); //      int count = 0; //     for (int i = 1; count <= 10000; i++) { // id,  ,        10000 String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=" + str(i) + "&fields=bdate"); // ,     id for (int j = 0; j < user.length; j++) { //    if (user[j].indexOf("<bdate>") != -1) { //      p.println(user[j]); //    println(count); //        count++; //    1 } } } p.flush(); p.close(); //    exit(); //   } 

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

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

अंधे भाग्य पर भरोसा नहीं करने के लिए, त्रुटि से निपटने का आविष्कार किया गया था। त्रुटियों को निम्नलिखित प्रविष्टि से नियंत्रित किया जाता है:

 try { // ,     } catch (  ) { // ,    ,    } 

कार्यक्रम को संभालने में त्रुटि:

 void setup() { PrintWriter p = createWriter("data/bdates.txt"); //      int count = 0; //     for (int i = 1; count <= 10000; i++) { // id,  ,        10000 String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=" + str(i) + "&fields=bdate"); // ,     id try { for (int j = 0; j < user.length; j++) { //    if (user[j].indexOf("<bdate>") != -1) { //      p.println(user[j]); //    println(count); //        count++; //    1 } } } catch (Exception e) {} } p.flush(); p.close(); //    exit(); //   } 

अब, यदि एरे को एक्सेस करते समय कोई त्रुटि होती है (यदि एरे खाली है), तो कोड निष्पादित किया जाएगा ... कोई कोड निष्पादित नहीं किया जाएगा, प्रोग्राम एक त्रुटि संदेश प्रदर्शित करेगा, लेकिन बंद नहीं होगा। हम केवल त्रुटि को अनदेखा करते हैं और आगे बढ़ते हैं - बस किसी अन्य उपयोगकर्ता की जानकारी का अनुरोध करना होगा। त्रुटि का प्रकार अपवाद द्वारा इंगित किया गया है, जिसका अर्थ है कि हम किसी भी त्रुटि को "पकड़ "ते हैं। त्रुटि के प्रकार के बाद ई लिखना आवश्यक है क्योंकि कार्यक्रम को किसी प्रकार के चर की आवश्यकता होती है जिसमें त्रुटि के बारे में जानकारी लिखना है। त्रुटियों को संसाधित करते समय हम इस चर तक पहुंच सकते हैं, लेकिन इस मामले में यह आवश्यक नहीं है।

2. सॉर्टिंग डेटा

कार्यक्रम शुरू करने के कुछ समय बाद (आमतौर पर आधे घंटे से अधिक नहीं), यह समाप्त हो जाएगा और हम पोषित संख्या 10 000 को कंसोल में देखेंगे। इसका मतलब है कि डेटा एकत्र किया गया है और छंटनी शुरू हो सकती है। पाठ संपादक में फ़ाइल खोलें और हमारे काम के परिणाम को देखें:

क्या गलत है? हाँ, हम पूरी तरह से भूल गए कि हम XML टैग्स के साथ फाइल में डेटा लिख ​​रहे थे। इससे कोई फर्क नहीं पड़ता! किसी भी टेक्स्ट एडिटर में, एक ऑटो-रिप्लेस फंक्शन है जिसके साथ आप अनावश्यक जानकारी से हमारी फाइल को साफ कर सकते हैं। कड़ाई से बोलते हुए, हम प्रोग्रामेटिक रूप से डेटा संग्रह चरण में "अतिरिक्त" पकड़ सकते हैं, लेकिन सिद्धांत रूप में, सादगी और समय की बचत के लिए, किसी भी उपलब्ध टूल का उपयोग करना शर्मनाक नहीं है।

फ़ाइल को साफ करने के बाद, इसे सहेजें और इसे बंद करें। अब कार्यक्रम सिर्फ इसे पढ़ेंगे।

3. डेटा विज़ुअलाइज़ेशन

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

 int[][] table = new int[12][31] 

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

हमारा कार्यक्रम कैसे चलेगा? हमें तारीख लेनी चाहिए, यह निर्धारित करना चाहिए कि इसमें कौन सा दिन और महीना शामिल है, और इसी सरणी सेल को एक करके बढ़ाएं।

दिन, महीने और वर्ष में स्ट्रिंग को विभाजित करने के लिए, हम विभाजन () विधि का उपयोग करेंगे। यह स्ट्रिंग्स की एक सरणी देता है, और एक तर्क के रूप में एक विभाजक स्ट्रिंग लेता है: निर्देश

 String[] s = "00010010".split("1"); 

सरणी के लिए मान असाइन करें

 [0] "000" [1] "00" [2] "0" 

हमारे अभ्यास के लिए इसका क्या अर्थ है? हम एक सरणी स्ट्रिंग लेते हैं और इसे एक विभाजक के रूप में एक डॉट चरित्र के साथ विभाजित करते हैं। एक तकनीकी समस्या है: डॉट प्रतीक किसी भी प्रतीक के लिए एक प्रतीक के रूप में आरक्षित है। इसलिए, इसके बजाय "।" एक तर्क के रूप में, हम "\\" पास करते हैं। - ऐसा रिकॉर्ड हमें उस बिंदु प्रतीक को दर्शाता है जिसकी हमें आवश्यकता है। यह इस तरह से निकला:

 void setup() { String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    } exit(); //   } 

अब सेल की तारीख में [0] महीने में दिन की संख्या के साथ एक पंक्ति होती है, और तारीख में [1] - महीने की संख्या। हमें तालिका सरणी के संबंधित सेल को एक से बढ़ाना चाहिए:

 table[int(table[1])-1][int(table[0])-1]++; 

तिथि के अनुसार सेल पते को निर्दिष्ट करके, हम स्ट्रिंग को इंट () फ़ंक्शन का उपयोग करके एक संख्या में अनुवाद करते हैं, और एक को घटाते भी हैं। यूनिट क्यों लें? फिर, कि सरणी की कोशिकाओं की गिनती शून्य से शुरू होती है। हमने 12 की लंबाई निर्दिष्ट की है, जिसका अर्थ है कि सरणी की कोशिकाएं 0 से 11. तक हैं। महीनों के विपरीत, जिन्हें 1 से 12 तक गिना जाता है। इस विसंगति को याद रखना चाहिए।

है न? यह सही है, लेकिन वास्तव में नहीं। यदि आप अब प्रोग्राम चलाते हैं, तो यह एक त्रुटि है। तथ्य यह है कि हमारा डेटा सेट सही नहीं है। किसी अज्ञात कारण से, जन्म क्षेत्र में कुछ उपयोगकर्ताओं के पास 666.666 या 32.13.88888888 जैसे कुछ अश्लील नंबर हैं। कभी-कभी आप उस उपयोगकर्ता से भी मिल सकते हैं जो पैदा हुआ था, उदाहरण के लिए, दिसंबर का पांचवां घटा। उन्हें क्रमबद्ध करने के लिए, आपको 12 से अधिक महीनों के मूल्यों और 31 से अधिक दिनों के मूल्यों को त्यागने की आवश्यकता है, साथ ही साथ सभी मान शून्य से कम या बराबर हैं:

 if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } 

पूरा कार्यक्रम:

 void setup() { String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } } exit(); //   } 

अब जब डेटा को अंततः प्रोग्राम की मेमोरी में संग्रहीत और संग्रहीत किया जाता है, तो आप अंततः काम करना शुरू कर सकते हैं - ड्राइंग। पहले हम उस रंग पर निर्णय लेते हैं जिसे हम आकर्षित करेंगे: मैंने कॉर्पोरेट नीले रंग का वीके लिया: आरजीबी 54, 99, 142। हम हर बार तीन क़ीमती संख्याओं को नहीं लिखने के लिए एक रंग चर घोषित करते हैं:

 color c = color(54, 99, 142); 

हमें यह भी तय करने की आवश्यकता है कि परंपरा के अनुसार (कार्यक्रम की शुरुआत में) हमारी छवि कितनी चौड़ाई और ऊँचाई पर होगी। ऐसा करने के लिए, हम एक फ़ंक्शन लिखते हैं:

 size(, ); 

हमारे पास क्या चौड़ाई और ऊंचाई होगी? मान लीजिए कि प्रत्येक हीट मैप सेल 40 पिक्सल चौड़ा है, और कोशिकाओं के बीच इंडेंटेशन के लिए एक पिक्सेल है। हम महीनों को चौड़ाई में स्थगित कर देते हैं। किनारे से इंडेंट के बारे में मत भूलना (10 पिक्सल)। यह 20 + 41 * 12 निकलता है। यदि आप अपने दिमाग में नहीं पढ़ना चाहते हैं या एक कैलकुलेटर एप्लिकेशन खोलना चाहते हैं, तो आप इस अभिव्यक्ति को प्रिंटलाइन फ़ंक्शन (20 + 41 * 12) के तर्क के रूप में लिख सकते हैं ; और उत्तर प्राप्त करें - 512. यह छवि की चौड़ाई है। 20 पिक्सेल की सेल ऊंचाई और किनारे से एक ही इंडेंट को देखते हुए, हमें यह मिलता है:

 size(512, 671); 

अब अस्थायी रूप से निकास () कमांड हटा दें ; कार्यक्रम के अंत में, ताकि हम पूरा होने के बाद कार्यक्रम से बाहर न निकलें, और कोड चलाएं:

 void setup() { size(512, 671); //  background(255); //  -  String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } } color c = color(54, 99, 142); // } 

फ़्रेम के आकार को निर्दिष्ट करने के बाद, मैंने सफेद पृष्ठभूमि को सेट करने के लिए कमांड जोड़ा: यदि हम रंग को एक संख्या के रूप में निर्दिष्ट करते हैं, तो इसे 0 से (ग्रे) के रंगों से 255 (सफेद) के रूप में पहचाना जाता है। जब कार्यक्रम शुरू होता है, तो एक खिड़की को उस आकार की एक सफेद पृष्ठभूमि के साथ खोलना चाहिए जो हमें चाहिए।

चलो अंत में आकर्षित करना शुरू करते हैं। हम कैसे आकर्षित करते हैं? हम तालिका सरणी पर जाते हैं - प्रत्येक पंक्ति (महीने) के लिए और कोशिकाओं के लिए प्रत्येक पंक्ति (इस महीने का दिन) में। सही जगह और रंग में 20 आयत द्वारा 40 ड्रा करें। स्थिति X की गणना कैसे की जाती है? 10 (इंडेंट) + 41 (चौड़ाई + के बीच की खाई) * i (महीना काउंटर)। स्थिति Y? 10 (इंडेंट) + 21 (ऊंचाई + के बीच निकासी) * j (दिन काउंटर)। आयत को आयत फ़ंक्शन (x, y, चौड़ाई, ऊंचाई) के साथ खींचा जाता है ; -

 rect(10+41*i, 10+21*j, 40, 20); 

कार्यक्रम:

 void setup() { size(512, 671); //  background(255); //  -  String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } } color c = color(54, 99, 142); // for (int i = 0; i < table.length; i++) { //   for (int j = 0; j < table[i].length; j++) { //   rect(10+41*i, 10+21*j, 40, 20); //     } } } 

यदि हम इस कोड को चलाते हैं, तो हमें एक स्ट्रोक के साथ आयतों द्वारा अजीब तरह से खींचा गया क्षेत्र मिलता है। सबसे पहले, ड्राइंग से पहले noStroke () कमांड जोड़कर स्ट्रोक को हटा दें ; । अब हमारे रंग को भरने के रूप में सेट करें: भरें (सी);

ठीक। अब वर्ग को सफेद नीली टाइलों के साथ सुंदर नीली टाइलों से टाइल किया गया है। इसके बाद, हमें किसी तरह टेबल वैल्यू को फिल कलर में एनकोड करना होगा। हम पारदर्शिता के साथ ऐसा करते हैं। रंग पारदर्शिता 0 से 255 तक मान लेती है। भरण लिखें (सी, 10); एक सूक्ष्म नीला रंग देगा, और फिल भरें (सी, 240); लगभग पूरी तरह से संतृप्त नीला रंग देगा। तो, पारदर्शिता की सीमा 0..255 है। हमारे सरणी में मानों की श्रेणी बहुत बड़ी (या कम) है। मान लीजिए कि हम किसी सरणी में अधिकतम मान जानते हैं। न्यूनतम, ज़ाहिर है, शून्य होगा। हमें किसी प्रकार सरणी से मान को 0..255 तक सीमा में दर्ज करने की आवश्यकता है, जैसे कि पैमाने को कम करना (बढ़ाना)। ऐसा करने के लिए, एक मैप फंक्शन (मान, सोर्स रेंज की शुरुआत, सोर्स रेंज का अंत, नई रेंज की शुरुआत, नई रेंज का अंत) होता है :

 map(table[i][j], 0, 1000, 0, 255); 

यहां हमने यह अनुमान लगाया कि सरणी का अधिकतम मान 1000 है। फिर, एक तालिका [i] [j] 1000 के मान के साथ, फ़ंक्शन 255 वापस आ जाएगा, और 0 के मान के साथ यह शून्य पर वापस आ जाएगा।

दो-आयामी सरणी के न्यूनतम और अधिकतम मूल्यों की गणना कैसे करें? एक-आयामी सरणी के लिए , क्रमशः कार्य मिनट () और अधिकतम () हैं। हम उनका उपयोग करते हैं। चलो "महीनों" के चक्र के माध्यम से चलते हैं और प्रत्येक "महीने" के न्यूनतम और अधिकतम मूल्यों की तुलना करते हैं (जो कि एक आयामी आयाम के रूप में पर्यावरण द्वारा माना जाता है) जो चर में वर्तमान न्यूनतम या अधिकतम मूल्य को संग्रहीत करते हैं। और एक और महत्वपूर्ण बात नहीं भूलना चाहिए: कभी-कभी डेटा सेट में गलत तारीखें सामने आई थीं, अर्थात्। कोई व्यक्ति 31 नवंबर या 30 फरवरी को जन्म तिथि का संकेत दे सकता है। ताकि यह तथ्य हमें परेशान न करे, हम सभी गैर-मौजूद तारीखों के मूल्य को शून्य पर सेट करते हैं।

 table[1][29] = 0; //30  table[1][30] = 0; //31  table[3][30] = 0; //31  table[5][30] = 0; //31  table[8][30] = 0; //31  table[10][30] = 0; //31  int mi = table[0][0]; //  int ma = table[0][0]; //  for (int i = 0; i < table.length; i++) { if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //           mi = min(table[i]); //    } if (max(table[i]) > ma) { //        ma = max(table[i]); //    } } println(mi + " " + ma); //  

मेरे मूल्य 14 और 47 हो गए हैं। सिद्धांत रूप में, यह महत्वपूर्ण नहीं है, क्योंकि हम चर के मूल्यों का उपयोग कर सकते हैं। अब हमें हर बार टेबल सेल का उपयोग करने की आवश्यकता है, अर्थात्। प्रत्येक आयत को खींचने से पहले, अपना भरण सेट करें:

 void setup() { size(512, 671); //  background(255); //  -  String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } } table[1][29] = 0; //30  table[1][30] = 0; //31  table[3][30] = 0; //31  table[5][30] = 0; //31  table[8][30] = 0; //31  table[10][30] = 0; //31  int mi = table[0][0]; //  int ma = table[0][0]; //  for (int i = 0; i < table.length; i++) { if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //           mi = min(table[i]); //    } if (max(table[i]) > ma) { //        ma = max(table[i]); //    } } color c = color(54, 99, 142); noStroke(); for (int i = 0; i < table.length; i++) { //   for (int j = 0; j < table[i].length; j++) { //   fill(c, map(table[i][j], 0, ma, 0, 255)); //  rect(10+41*i, 10+21*j, 40, 20); //     } } } 

? , . , 29 . , , , , ( 14, 0 — , 0 85. . map() , 12, 29 . - , 12, , , 0, . (-5 — 250!), , , . , «» :

 void setup() { size(512, 671); //  background(255); //  -  String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } } table[1][29] = 0; //30  table[1][30] = 0; //31  table[3][30] = 0; //31  table[5][30] = 0; //31  table[8][30] = 0; //31  table[10][30] = 0; //31  int mi = table[0][0]; //  int ma = table[0][0]; //  for (int i = 0; i < table.length; i++) { if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //           mi = min(table[i]); //    } if (max(table[i]) > ma) { //        ma = max(table[i]); //    } } color c = color(54, 99, 142); noStroke(); for (int i = 0; i < table.length; i++) { //   for (int j = 0; j < table[i].length; j++) { //   if (table[i][j] > 0) { fill(c, map(table[i][j], 12, ma, 0, 255)); //  rect(10+41*i, 10+21*j, 40, 20); //     } } } } 

? - 1 . . 300 000 , 1 , . , , , , . . , , table[0][0] . , saveFrame(«frame.jpg»); . .

:

 void setup() { size(512, 671); //  background(255); //  -  String[] file = loadStrings("data/bdates.txt"); //    int[][] table = new int[12][31]; for (int i = 0; i < file.length; i++) { //    String[] date = file[i].split("\\."); //   ,    if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //      table[int(date[1])-1][int(date[0])-1]++; //    1 } } table[0][0] = 0; //1  table[1][29] = 0; //30  table[1][30] = 0; //31  table[3][30] = 0; //31  table[5][30] = 0; //31  table[8][30] = 0; //31  table[10][30] = 0; //31  int mi = table[0][0]; //  int ma = table[0][0]; //  for (int i = 0; i < table.length; i++) { if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //           mi = min(table[i]); //    } if (max(table[i]) > ma) { //        ma = max(table[i]); //    } } color c = color(54, 99, 142); noStroke(); for (int i = 0; i < table.length; i++) { //   for (int j = 0; j < table[i].length; j++) { //   if (table[i][j] > 0) { fill(c, map(table[i][j], 12, ma, 0, 255)); //  rect(10+41*i, 10+21*j, 40, 20); //     } } } saveFrame("frame.jpg"); // } 

हो गया! , , , . 300 000 (, 100 , — , - Processing), ( ):

! ;]