ब्रेन बॉक्स: समय के साथ तंत्रिका मात्रा को ट्रैक करना: 20 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-31 10:20

लंबे मानव जीवन की सीमा में आगे बढ़ने से हमारे सामने सभ्यताओं द्वारा नहीं देखी गई बीमारियों का उदय हुआ है। इनमें से, अल्जाइमर ने 2017 में लगभग 5.3 मिलियन जीवित बुजुर्ग अमेरिकियों को प्रभावित किया, या 10 बुजुर्ग अमेरिकियों में से लगभग 1 (https://www.alz.org/facts/) और अनगिनत अन्य लोगों को मनोभ्रंश से प्रभावित किया। यह समझने की लड़ाई में सहायता करने के लिए कि हमारे बुजुर्ग क्या पीड़ित हैं, यह कोड भविष्य के शोधकर्ताओं और उत्सुक जिज्ञासु को समय के साथ मस्तिष्क की मात्रा को ट्रैक करने की क्षमता से लैस करेगा।

चरण 1: ब्रेन बॉक्स का उपयोग करना

ब्रेन बॉक्स का उपयोग करने के लिए, केवल निम्नलिखित की आवश्यकता होती है:

• मस्तिष्क का एमआरआई स्कैन और ऐसी फाइलों का नाम और प्रारूप (सभी का आकार लगभग समान होना चाहिए)
• एक स्कैन की लंबाई
• प्रत्येक परत के बीच की दूरी (एमआरआई स्कैन)
• रोगी का नाम (इनपुट करते समय, रिक्त स्थान शामिल न करें और कृपया पहले नाम और अंतिम नाम को बड़े अक्षरों में लिखें, जैसे: FirstnameLastname)

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

हालाँकि, ब्रेन बॉक्स के अनुप्रयोग को इस एक कार्य के लिए बाध्य करने की आवश्यकता नहीं है। यदि किसी दिए गए ठोस के क्रॉस सेक्शन एक ट्यूमर की तरह फोटोग्राफ हैं, तो इनके लिए मात्रा में परिवर्तन के रुझान को सॉफ्टवेयर में भी ट्रैक किया जा सकता है।

चरण 2: परिचय: क्रॉस सेक्शन का विश्लेषण

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

चरण 3: एक फ़ंक्शन सेट करना: LevelCurveTracings.m

सबसे पहले, सुनिश्चित करें कि आपके कंप्यूटर में MATLAB_R2017b डाउनलोड हो गया है (यहां डाउनलोड करें) और MATLAB खोलें। MATLAB इंटरफ़ेस में, विंडो के ऊपरी बाएँ कोने में बटन पर क्लिक करें जो बोल्ड पीले प्लस चिह्न के साथ "नया" कहता है, और विकल्प "फ़ंक्शन" का चयन करें, संपादक विंडो में एक ऐसा स्थान खोलने के लिए जो कि जैसा दिखता है तीसरी तस्वीर। हम फ़ंक्शन को सेटअप करने के लिए पहली पंक्ति को बदलने पर ध्यान केंद्रित करेंगे। जहां यह "outputArg1" कहता है, इसे "ब्रेन", "outputArg2" से "छेद", "untitled2" से "exp2", और "inputArg1" से "image" कहने के लिए बदलें और "inputArg2" को हटा दें। अब आपके पास "exp2" का उपयोग करके कॉल करने के लिए एक फ़ंक्शन है, एक तर्क "छवि" लेते हुए और "मस्तिष्क" और "छेद" की सीमाओं को आउटपुट करना। फ़ंक्शन की पहली पंक्ति चौथी तस्वीर में दर्शाई गई रेखा से मिलती जुलती होनी चाहिए। इस प्रारंभिक पंक्ति के नीचे के सभी कोड को हटा दें।

चरण 4: बाउंड एल्गोरिथम विकसित करना: बाउंड्स ढूँढना

लाइन के नीचे इस प्रकार कोड टाइप करें। फ़ंक्शन का यह खंड निम्न पंक्ति-दर-पंक्ति करता है।

1. छवि "छवि" में चर "एमआरआई" में लोड करें।
2. एक सेट थ्रेशोल्ड मान के आधार पर "एमआरआई" को संख्याओं से लेकर एक और शून्य (उर्फ बिनराइजिंग) में मानों से बनी छवि में बदल दें। यदि पिक्सेल में मान 0.1 के बराबर या उससे अधिक है, तो इसे एक पर सेट किया जाता है, यदि नहीं, तो उस पिक्सेल का मान शून्य पर सेट होता है।
3. निम्नलिखित चार पंक्तियाँ MRI स्कैन परत के किनारों पर 10 स्तंभों और पंक्तियों को शून्य में बदल देती हैं, ताकि सीमा बनाने के रूप में अनुचित मानों को पढ़ने से बचा जा सके (जैसा कि कोड के साथ प्रयोग करने से सीखा गया है)।
4. अंतिम पंक्ति में, bwboundaries binarized छवि "mri" की सीमाओं का पता लगाता है और इसे "b" के बराबर सेट करता है, उन तत्वों के साथ एक सरणी जिसका सूचकांक उन सीमाओं के अनुरूप होता है जो एक पर सेट होते हैं।

चरण 5: बाउंड एल्गोरिथम विकसित करना: बाहरी बाउंड एरे बनाना

चित्र में निम्नलिखित कोड के साथ संपादक विंडो में अनुसरण करें। कोड का यह खंड निम्नलिखित पंक्ति-दर-पंक्ति करता है।

1. बिनारीकृत छवि "बी" की प्रत्येक पंक्ति की लंबाई ज्ञात करें (सेलफन प्रत्येक पंक्ति में फ़ंक्शन की लंबाई लागू करता है)।
2. अधिकतम लंबाई स्टोर करने के लिए "लोक" सेट करें।
3. "सबसे बड़ी ट्रेस" में स्टोर करने के लिए सेट अधिकतम लंबाई की अनुक्रमणिका खोजें।
4. छवि "एमआरआई" का आकार ढूंढें, जिसमें "बी" के समान आकार होता है, और "बीडब्ल्यूसाइज" पर सेट होता है।
5. छवि के सरणी में पंक्तियों की संख्या ज्ञात करें, "ysize" पर सेट करें।
6. छवि के सरणी में स्तंभों की संख्या ज्ञात करें, "xsize" पर सेट करें।
7. शून्य के "xsize" मैट्रिक्स द्वारा "सबसे बड़ा ट्रेसमैट", "ysize" सरणी उत्पन्न करें।
8. सबस्क्रिप्ट किए गए मानों से समतुल्य अनुक्रमणिका खोजें, जहां सबसे बड़ा ट्रेस x मान और y मान थे, वेक्टर "लिंडेक्स" में स्टोर करें।
9. शून्य के मैट्रिक्स में, "सबसे बड़ा ट्रेसमैट", उन तत्वों को इंडेक्स में बदल दें जो "लिंडेक्स" में तत्वों के रूप में संग्रहीत इंडेक्स मानों से मेल खाते हैं।

इस प्रकार तार्किक सरणी "सबसे बड़ा ट्रेसमैट" में दिए गए मस्तिष्क स्कैन क्रॉस सेक्शन का सबसे बड़ा बाध्य क्षेत्र है जिसे शून्य की पृष्ठभूमि वाले लोगों के रूप में प्लॉट किया गया है

चरण 6: बाउंड एल्गोरिथम विकसित करना: केंद्र बिंदु के साथ कार्य करना

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

1. मौजूद केन्द्रक के बारे में जानकारी प्राप्त करने के लिए "क्षेत्रप्रॉप्स" का उपयोग करें, संरचना सरणी "tempStruct" के बराबर सेट करें
2. फ़ॉर्म सरणी "सेंट्रोइड्स" फ़ील्ड "सेंट्रोइड" से डेटा के साथ लंबवत रूप से जुड़ा हुआ है
3. "सेंट्रोइड्स" का दूसरा कॉलम मान लें (क्षैतिज आयाम निर्देशांक)
4. केंद्रक के क्षैतिज केंद्र के संरेखण की जाँच करने के लिए एक फ़िल्टर चलाएँ

चरण 7: बाउंड एल्गोरिथम विकसित करना: जब एक सेंट्रोइड केंद्रित नहीं होता है

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

1. ट्रेस किए गए मैट्रिक्स को एक नए चर "बी 2" पर सेट करें
2. "लोक" द्वारा अनुक्रमित सेट के साथ खाली मैट्रिक्स "बी 2" प्रारंभ करें
3. एक सशर्त बनाएं, जब एक केन्द्रक केंद्रित नहीं होता है (अर्थात एक बहु क्षेत्र परत)
4. प्रत्येक पंक्ति के लिए पाया जाने वाला एक नया ट्रेस आकार सेट करें (traceSize2)
5. उन सूचकांकों को खोजने के लिए "loc2" सेट करें जहाँ सीमाएँ मौजूद हैं
6. "b2" में "loc2" द्वारा निर्दिष्ट कक्षों को "सबसे बड़े ट्रेस 2" के बराबर होने दें
7. सबस्क्रिप्ट को इंडेक्स में बदलें, "लिंडेक्स" पर सेट करें
8. "LarseTraceMat" में "Lindex" से संबंधित तत्वों को 1. में बदलें
9. "loc2" द्वारा अनुक्रमित सेट के साथ खाली मैट्रिक्स "बी 2" प्रारंभ करें

चरण 8: बाउंड एल्गोरिथम विकसित करना: छेदों का हस्तक्षेप

छिद्रों से निपटने में, "बी 2" में संग्रहीत मूल्यों ने सबसे बड़े ट्रेस के अलावा अन्य संरचनाओं का ट्रैक रखा, और इन्हें "सबसे बड़े ट्रेसमैट" के भरे हुए रूप में प्लॉट करने से पता चलेगा कि मस्तिष्क क्षेत्रों में छेद कहां हैं।

1. सरणी "भरा हुआ मैट" बनाएं, जो "सबसे बड़ा ट्रेसमैट" के रूप में भरा हुआ है
2. शून्य के "xsize" सरणी द्वारा सरणी "हस्तक्षेपमैट", एक "ysize" बनाएं
3. "बी 2" से मानों को संग्रहीत करने के लिए सरणी "हस्तक्षेप" बनाएं, लंबवत रूप से संयोजित
4. "हस्तक्षेप" के अनुरूप सूचकांकों को संग्रहीत करने के लिए सरणी "लिंडेक्स" बनाएं
5. "इंटरफेरेंसमैट" में सूचकांकों के लिए जो "लिंडेक्स" के अनुरूप हैं, एक अलग बाउंडेड क्षेत्र बनाते हुए 1 पर मान सेट करें

चरण 9: बाउंड एल्गोरिथम विकसित करना: होल्स का पता लगाना, ब्रेन बाउंड्स और होल बाउंड्स को अंतिम रूप देना

1. सरणी "tempMat" को "इंटरफेरेंसमैट" प्लस "फिल्डमैट" के बराबर सेट करें, इस प्रकार मैट्रिक्स में प्रत्येक मान को एक दूसरे से जोड़ते हैं
2. सेट सरणी "holesLoc" सूचकांक के बराबर जहां "हस्तक्षेप" और "भरा हुआ" दोनों एक के बराबर थे
3. "ysize" x "xsize" आयामों के शून्य मैट्रिक्स के रूप में सेटअप "holesMat"
4. "holesMat" में इंडेक्स सेट करें जो कि "holesLoc" के बराबर हों
5. "मस्तिष्क" को "सबसे बड़े ट्रेसमैट" पर सेट करें
6. "छेद" को "छेद मैट" पर सेट करें

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

चरण 10: लॉगिंग डेटा: फ़ंक्शन PatientFiles.m

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

चरण 11: फाइलों में डेटा लॉग करना

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

1. जांचें कि क्या रोगी नाम के लिए इनपुट एक स्ट्रिंग है।
2. यदि यह एक स्ट्रिंग नहीं है, तो प्रदर्शित करें कि पेशेंटनाम इनपुट एक स्ट्रिंग होना चाहिए।
3. अगर कथन समाप्त करें (त्रुटि को रोकें)।
4. एक स्ट्रिंग स्टेटमेंट "दिनांक और समय" सेट करें जो निम्नलिखित प्रारूप देगा: घंटा: मिनट--माह/दिन/वर्ष।
5. चर फ़ाइल नाम को निम्न पर सेट करें: रोगी नाम।

अब फ़ंक्शन के अगले भाग में: क्या इस नाम की कोई फ़ाइल पहले से मौजूद है?

1) मान लीजिए कि इस नाम की फाइल पहले से मौजूद है:

1. पिछली कतार से मान प्राप्त करने के लिए फ़ाइल चलाएँ
2. वर्तमान पुनरावृत्ति के "दिनांक और समय" डेटा को x मानों के सेल सरणी में एक नए सेल के रूप में जोड़ें (इंडेक्स एंड + 1)
3. y मानों के सेल सरणी में एक नए सेल के रूप में वर्तमान "ब्रेनवॉल्यूम" मान जोड़ें (इंडेक्स एंड + 1)
4. फ़ाइल में लोड किए गए वर्तमान चर सहेजें।

2) मान लें कि इस नाम की फ़ाइल मौजूद नहीं है:

1. चर "रोगीनाम" में संग्रहीत नाम के साथ एक नई फ़ाइल बनाएँ
2. वर्तमान "दिनांक और समय" डेटा को सेल के रूप में x मानों के खाली सेल सरणी में जोड़ें
3. वर्तमान "ब्रेनवॉल्यूम" डेटा को सेल के रूप में y मानों के खाली सेल सरणी में जोड़ें
4. फ़ाइल में लोड किए गए वर्तमान चर सहेजें।

चरण 12: लॉगिंग डेटा: समय के साथ मस्तिष्क की मात्रा का एक प्लॉट प्रदर्शित करना

1. प्लॉटिंग की अनुमति देने के लिए x मान सरणी (xVals) को एक श्रेणीबद्ध सरणी (xValsCategorical) में बदलें
2. आकृति विंडो उत्पन्न करें 5
3. "xValsCategorical" और "yVals" (मस्तिष्क की मात्रा युक्त) द्वारा निर्दिष्ट बिंदुओं को इंगित करने के लिए खोखले हलकों का उपयोग करके और धराशायी रेखाओं से जुड़े होने के लिए प्लॉट करें
4. प्लॉट का शीर्षक इस प्रकार है: पेशेंटनाम ब्रेन वॉल्यूम डेटा
5. चित्र में दिखाए अनुसार x अक्ष को लेबल करें
6. चित्र में दिखाए अनुसार y अक्ष को लेबल करें
7. मान लीजिए आंकड़ा 5 आउटपुट के बराबर है

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

चरण 13: सबप्लॉट्स में अंतराल को बंद करना: Subplotclose.m

फ़ंक्शन, https://www.briandalessandro.com से कोड से अनुकूलित, मुख्य कोड के सबप्लॉट आंकड़ों के बीच अंतराल को बंद करने के लिए कार्य करता है, जब एमआरआई छवियों और मस्तिष्क परतों को प्रदर्शित करने वाले आंकड़े बनाए जाते हैं। Subplotclose.m के भीतर उपयोग किया गया सबप्लॉट फ़ंक्शन दिए गए सबप्लॉट की स्थिति को लंबे आयाम के पहलू में एक दूसरे के साथ फिर से फिट करने के लिए समायोजित करता है। उदाहरण के लिए, यदि कोड 7 x 3 मैट्रिक्स का इरादा रखता है, तो पंक्तियाँ सहज रूप से फिट होंगी क्योंकि पंक्ति आयाम लंबा है। यदि कोड 3 x 7 मैट्रिक्स का इरादा रखता है, तो कॉलम पंक्तियों में अंतराल के साथ, हमारे मुख्य कोड के आंकड़ों में प्रदर्शित होने के साथ आराम से फिट होंगे।

चरण 14: मुख्य कोड: सभी को साफ़ करना और इनपुट के लिए संकेत देना

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

1. 0, 1, और 2 को छोड़कर सभी खुली हुई फाइलों को बंद करें।
2. सभी फिगर विंडो बंद करें।
3. कार्यक्षेत्र में सभी चर साफ़ करें।
4. कमांड विंडो साफ़ करें।
5. कमांड विंडो में प्रदर्शित करें: कृपया एमआरआई स्कैन के लिए निम्नलिखित आयामों को इनपुट करें:
6. कमांड विंडो में एक नई लाइन पर, पूछें: मिलीमीटर में एक स्कैन की लंबाई:। उपयोगकर्ता द्वारा दी गई प्रतिक्रिया चर "लंबाईएमएम" पर सेट की जाएगी।
7. एक नई लाइन पर, पूछें: मिलीमीटर में एमआरआई स्कैन के बीच की दूरी:। उपयोगकर्ता द्वारा दी गई प्रतिक्रिया चर "ZStacks" पर सेट की जाएगी।

चरण 15: मुख्य कोड: छवियों को संसाधित करने वाला बैच

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

1. संरचना सरणी "ब्रेनइमेज" बनाएं जिसमें वर्तमान फ़ोल्डर के भीतर सभी फाइलों की जानकारी हो जो एमआरआई_ () के नाम प्रारूप में फिट हो। पीएनजी
2. संरचना सरणी "BrainImages" में तत्वों की संख्या के बराबर चर "NumberofImages" सेट करें
3. ओपन फिगर विंडो 1
4. फ़ाइल में गिने जाने वाली छवियों की संख्या के लिए चक्र के लिए लूप के लिए सेट करें
5. प्रत्येक लूप के लिए, "CurrentImage" प्रत्येक फ़ाइल MRI_i-p.webp" />
6. "इमशो" द्वारा लोड की जाने वाली 19 छवियों को प्रदर्शित करने के लिए एक 3 x 7 सबप्लॉट उत्पन्न करें
7. सबप्लॉट फिगर विंडो में प्रत्येक छवि को दूसरे तत्व के रूप में प्रदर्शित करें
8. प्रत्येक सबप्लॉट तत्व को Level_ के रूप में शीर्षक दें, जहां रिक्त लूप के लिए पुनरावृत्ति संख्या है।
9. लूप के लिए समाप्त करें (त्रुटि से बचना)

यह चित्र विंडो 1 में सभी एमआरआई स्कैन को कच्चे रूप में 3 x 7 कॉन्फ़िगरेशन में प्रदर्शित करेगा जिसमें x ओरिएंटेशन में कोई अंतराल नहीं होगा।

चरण 16: मुख्य कोड: पैडिंग

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

1. ओपन फिगर विंडो 2
2. MRI_1-p.webp" />
3. छवि के मैट्रिक्स का आकार खोजें और "OriginalXPixels" (पंक्तियों की संख्या के लिए) और "OriginalYPixels" (कॉलम की संख्या के लिए) पर सेट करें
4. मैट्रिक्स "ब्रेनमैट" को 20 और पंक्तियों के साथ सभी शून्य और प्रत्येक विमान के लिए 20 और कॉलम, और 19 कुल क्रॉस सेक्शन, प्रति विमान एक से मिलकर सेट करें।
5. बाद में होल निर्देशांक इनपुट करने के लिए शून्य के समान तीन आयामी सरणी से मिलकर "होल्समैट" सेट करें
6. पैड प्लस बीस पंक्तियों और बीस स्तंभों के आकार के लिए "ज़ीरोमैट" बनाएं, शून्य की दो आयामी सरणी।

चरण 17: मुख्य कोड: सीमा निर्धारित करना

1. पहले लोड की गई प्रत्येक छवि से डेटा के माध्यम से जाने के लिए लूप के लिए सेट करें
2. पहले बैच प्रोसेसिंग के समान तरीके से, "करंटइमेज" "MRI_i.png" के साथ फाइलों को लोड करता है, जहां i पुनरावृत्ति संख्या है
3. प्रत्येक छवि को प्रसंस्करण फ़ंक्शन "LevelCurveTracings2.m" के माध्यम से चलाएँ जो आपने पहले बनाया था
4. आउटपुट "ब्रेन" के आकार का पता लगाएं, पंक्तियों की संख्या को "करंट्रो" और कॉलम की संख्या को "करंटकॉलम" पर सेट करें।
5. "CurrentMat" को "Currentrow" और "Currentcolumns" द्वारा निर्दिष्ट आयामों के साथ शून्य के मैट्रिक्स में सेट करें
6. "CurrentMat" में "ब्रेन" से डेटा को केंद्र में रखें, सभी तरफ 10 पंक्तियों के मार्जिन के साथ
7. छवियों की सीमाओं को प्रदर्शित करने के लिए आयाम 3 x 7 का एक सबप्लॉट बनाएं
8. फिगर विंडो में प्रत्येक सबप्लॉट तत्वों को शीर्षक दें
9. तीन आयामी मैट्रिक्स "ब्रेनमैट" उत्पन्न करें जिसमें प्रत्येक सीमा परत "करंटमैट" शामिल है
10. लूप के लिए समाप्त करें (त्रुटियों से बचने के लिए)

निम्नलिखित उपखंड प्रस्तावित तीन आयामी आकार के ऊपर और नीचे के छिद्रों में भरता है

1. "LevelCurve1" को "ब्रेनमैट" (ठोस के नीचे) की पहली परत के बराबर सेट करें
2. "LevelCurveEnd" को "ब्रेनमैट" (ठोस के ऊपर) की अंतिम परत के बराबर सेट करें
3. भरी हुई परत के साथ "LevelCurve1" को अधिलेखित करें
4. भरी हुई परत के साथ "LevelCurveEnd" को अधिलेखित करें
5. भरी हुई परत को "ब्रेनमैट" की निचली परत के रूप में सेट करें
6. भरी हुई परत को "ब्रेनमैट" की शीर्ष परत के रूप में सेट करें

चरण 18: मुख्य कोड: उचित Z आयाम का निर्धारण

पहली तीन पंक्तियों में एक खाली सरणी "z" सेट करना और मिमी ^ 3 में वॉल्यूम की उचित रीडिंग प्राप्त करने के लिए सरल रूपांतरण संचालन (पिक्सेल को लंबाई से विभाजित करना) करना शामिल है।

1. प्रत्येक परत के माध्यम से चक्र के लिए लूप बनाएं
2. किसी दी गई परत में लोगों की संख्या ज्ञात कीजिए
3. z निर्देशांक को उन मानों में परिवर्तित करें जिन्हें उचित अनुपात में बढ़ाया गया है, "tempz" पर सेट किया गया है, जो एक स्तंभ वेक्टर है
4. वेक्टर z. के स्तर वक्र के लिए z मान जोड़ें

इसके साथ z निर्देशांक ठीक से समायोजित किए जाते हैं।

चरण 19: मुख्य कोड: X और Y निर्देशांक निर्धारित करना

अब सीमाओं में प्रत्येक बिंदु की x और y स्थिति निर्धारित करना है।

1. "xBrain" को एक खाली सरणी के रूप में प्रारंभ करें
2. "yBrain" को एक खाली सरणी के रूप में प्रारंभ करें
3. लोड की गई प्रत्येक छवि के माध्यम से लूप के लिए लूप सेट करें
4. कॉलम वैक्टर "रोब्रेन" और "कॉलमब्रेन" द्वारा दर्शाए गए बाउंड में प्रत्येक बिंदु के प्लानर निर्देशांक को स्टोर करने के लिए दो कॉलम मैट्रिक्स संकलित करें।
5. वर्तमान में पाए गए "रोब्रेन" निर्देशांक के साथ "xBrain" जोड़ें
6. वर्तमान में पाए गए "कॉलमब्रेन" निर्देशांक के साथ "yBrain" जोड़ें
7. लूप के लिए समाप्त करें (त्रुटि से बचने के लिए)

चरण 20: मुख्य कोड: तीन आयामी संरचना की साजिश रचना, वॉल्यूम ढूँढना, और डेटा लॉग करना

अल्फाशैप फ़ंक्शन का उपयोग करके, हम एक त्रि-आयामी संरचना बनाएंगे जिससे हम मस्तिष्क की मात्रा की गणना कर सकते हैं।

1. x, y, और z निर्देशांकों के लिए फंक्शन alphaShape, सदिश "xBrain", "yBrain" और "z" में प्लग इन करें और "BrainPolyhedron" के बराबर सेट करें
2. ओपन फिगर विंडो 3
3. गणना की गई अल्फा आकृति "ब्रेनपॉलीहेड्रॉन" को प्लॉट करें, आकृति विंडो में प्रदर्शित करें
4. अल्फा आकार के लिए काम करने वाले फ़ंक्शन "वॉल्यूम" का उपयोग करके अल्फा आकार की मात्रा की गणना करें
5. वॉल्यूम को mm^3. में बदलें
6. कमांड विंडो में सॉलिड का वॉल्यूम प्रिंट करें
7. रोगी के नाम को इनपुट के रूप में सेट करने के लिए संकेत
8. घड़ी के साथ वर्तमान दिनांक और समय प्राप्त करें, और "दिनांक और समय" पर सेट करें
9. गणना किए गए डेटा को लॉग और प्लॉट करने के लिए फ़ंक्शन "रोगीफाइल" को कॉल करें

यहां से दूसरे और तीसरे चित्र में आने वाले आंकड़े दिखाई देने चाहिए, और चौथी तस्वीर जो कमांड विंडो में प्रदर्शित होनी चाहिए।