תיבת המוח: מעקב אחר נפח עצבי לאורך זמן: 20 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-31 10:19

ההתקדמות לגבול חיי אדם ארוכים יותר הביאה את עליית המחלות שלא ראו הציביליזציות לפנינו. בין אלה, אלצהיימר פגע בכ -5.3 מיליון אמריקאים קשישים חיים בשנת 2017, או בערך אחד מכל עשרה קשישים אמריקאים (https://www.alz.org/facts/) ואינספור אחרים עם דמנציה. כדי לסייע במאבק להבין מה פוגע בזקנינו, קוד זה יצייד את החוקרים העתידיים והסקרן להוטים ביכולת לעקוב אחר נפח המוח לאורך זמן.

שלב 1: שימוש בתיבת המוח

כדי להשתמש בקופסת המוח, צריך רק את הדברים הבאים:

• סריקות MRI של מוח והשם והפורמט של קבצים כאלה (כולם צריכים להיות בעלי אותם מידות בערך)
• אורך סריקה אחת
• מרחק בין כל שכבה (סריקת MRI)
• שם המטופל (בעת הקלדה, אל תכלול רווחים, אנא השתמש באותיות רישיות ושם משפחה, כגון: FirstnameLastname)

ומכאן, יש לאדם לעקוב אחר מגמות של אנשים בנפח המוח לאורך זמן. לפיכך, ניתן לעקוב אחר נתוני מגמות האלצהיימר באמצעות תוכנה זו. האורך בו השתמשנו בניסוי היה 180 מ"מ באורך סריקה אחת ו -5 מ"מ למרחק בין סריקות MRI, בהתבסס על נתונים ממוצעים.

עם זאת, היישום של קופסת המוח לא צריך להיות מוגבל למשימה אחת זו. אם חתכי הרוחב של מוצק נתון הם תצלום, כמו גידול כשלעצמו, ניתן לעקוב גם אחר מגמות השינויים בנפח עבור אלה בתוכנה.

שלב 2: מבוא: ניתוח חתכים רוחביים

במבנים תלת מימדיים, המישורים הדו ממדיים שמהם מורכבים ייקראו חתכים. תארו לעצמכם שערימת ניירות מהווה מנסרה מלבנית, ואז כל פיסת נייר תהיה חתך רוחב של הנייר. בדמיון המוח אנו מיישמים את אותה דרך המחשבה. MRI (הדמיית תהודה מגנטית) (ראה מידע על MRI) לוכדת את חתכי המוח, ומתוך שימוש בגבולות המוגדרים בכל "שכבה" של המוח המסופק, אנו יכולים לבנות מבנה שידגם וימצא את נפח המוח. עלינו קודם כל לבנות פונקציה לספק מידע על גבולות כאלה.

שלב 3: הגדרת פונקציה: LevelCurveTracings.m

ראשית, וודא שהמחשב שלך הורד את MATLAB_R2017b (הורד כאן) ופתח את MATLAB. בממשק MATLAB, לחץ על הלחצן בפינה השמאלית העליונה של החלון שבו כתוב "חדש" עם סימן פלוס צהוב מודגש, ובחר באפשרות "פונקציה", כדי לפתוח בחלון העורך רווח הדומה לזה שב- תמונה שלישית. נתמקד בשינוי השורה הראשונה להתקנת הפונקציה. במקום בו כתוב "outputArg1", החלף אותו ב- "brain", "outputArg2" כדי לומר "חורים", "ללא כותרת 2" עד "exp2" ו- "inputArg1" ל- "image", ומחק "inputArg2". כעת יש לך פונקציה להיקרא באמצעות "exp2", תוך לקיחת טיעון אחד "תמונה" והוצאת גבולות "המוח" וה"חור ". השורה הראשונה של הפונקציה צריכה להיות דומה לקו המתואר בתמונה הרביעית. מחק את כל הקוד מתחת לשורה ראשונית זו.

שלב 4: פיתוח האלגוריתם הכבול: מציאת גבולות

הקלד את הקוד כדלקמן מתחת לשורה. קטע זה של הפונקציה מבצע את השורה-אחר-שורה הבאה.

1. טען בתמונה "תמונה" לתוך המשתנה "mri".
2. הפוך את "mri" לתמונה העשויה מערכים בטווח מספרים לאפסים ולאפסים (aka binarizing) בהתבסס על ערך סף מוגדר. אם הערך בפיקסל שווה או גדול מ- 0.1, הוא נקבע לאחד, אם לא, הערך בפיקסל זה מוגדר לאפס.
3. ארבע השורות הבאות הופכות 10 עמודות ושורות בשולי שכבת סריקת ה- MRI לאפסים, כדי להימנע מקריאת ערכים לא תקינים כגבולות (כפי שנלמדו מהתנסות בקוד).
4. בשורה הסופית, bwboundaries עוקב אחר גבולות התמונה binarized "mri" ומגדיר אותה שווה ל- "b", מערך עם האלמנטים שמדדיהם תואמים את אלה של הגבולות המוגדרים לאחד.

שלב 5: פיתוח האלגוריתם הקשור: יצירת מערך חיצוני חיצוני

עקוב אחר חלון העורך עם הקוד הבא בתמונה. חלק זה של הקוד מבצע את השורה-אחר-שורה הבאה.

1. מצא את האורך של כל אחת משורות השורות של התמונה binarized "b" (cellfun מחיל את אורך הפונקציה על כל שורה).
2. הגדר "loc" לאחסון האורך המרבי.
3. מצא את האינדקס של האורך המרבי, הגדר לאחסן ב- "LargestTrace".
4. מצא את גודל התמונה "mri", המורכבת מאותו גודל כמו "b", והגדר את "BWsize".
5. מצא את מספר השורות במערך התמונה, הגדר "ysize".
6. מצא את מספר העמודות במערך התמונה, הגדר "xsize".
7. צור מערך "largeTraceMat", מטריצת "ysize" לפי "xsize" של אפסים.
8. מצא את האינדקס המקביל מהערכים המנויים המתאימים למקום בו היו ערכי ה- Trace x והערכים y, אחסן אותו בווקטור "לינדקס".
9. במטריצת האפסים, "LargestTraceMat", הפכו את האלמנטים במדדים התואמים לערכי אינדקס המאוחסנים כאלמנטים ב"לינדקס "לאלו.

לפיכך המערך הלוגי "LargestTraceMat" כולל את האזור המוגבל הגדול ביותר של חתך סריקת המוח הנתון המתווה כאלו עם רקע של אפסים

שלב 6: פיתוח האלגוריתם הכבול: עבודה עם נקודת מרכז

לאחר מכן, עלינו לבדוק אם החתך מורכב מיותר מאזור אחד (הגדול ביותר). על ידי בדיקת היישור של צנטרואיד האזור הגדול ביותר, אנו יכולים לראות אם יש אזור אחד צמוד, שיניב צנטרואיד מרוכז יותר, או אפשרות של אזורים מרובים.

1. השתמש ב "regionProps" כדי למצוא מידע על הצנטרואידים הקיימים, שווים למערך המבנה "tempStruct"
2. מערך טופס "צנטרואידים" עם נתונים מהשדה "צנטרואיד" משולבים אנכית
3. קח את ערכי העמודה השנייה של "צנטרואידים" (קואורדינטות הממד האופקי)
4. הפעל מסנן כדי לבדוק את היישור של הצנטרואיד למרכז האופקי

שלב 7: פיתוח האלגוריתם הכבול: כאשר Centroid אינו מרוכז

בתרחיש שהמרכז של אזור העקבות הגדול ביותר אינו מרוכז, אנו עוברים את השלבים הבאים. כפי שראינו בסריקות ה- MRI, הנטייה הייתה להצטייר בחצאי המוח בחתך כשהוא לא רציף, ולכן אנו ממשיכים כעת לשרטט את העקוב השני בגודלו יחד עם העקוב הגדול ביותר ב- "LargestTraceMat"

1. הגדר את המטריצה המתוארת למשתנה חדש "b2"
2. אתחל את המטריצה הריקה "b2", עם קבוצה שנוספה לאינדקס לפי "loc"
3. צור מותנה, כאשר צנטרואיד אינו מרוכז (כלומר שכבת אזור מרובה)
4. הגדר גודל עקבות חדש שיימצא לכל שורה (traceSize2)
5. הגדר "loc2" כדי למצוא את המדדים שבהם קיימים גבולות
6. תן לתאים שצוין על ידי "loc2" ב- "b2" להיות שווים ל- "largeTrace2"
7. המר את כתבי המשנה למדדים, הגדר "לינדקס"
8. שנה את האלמנטים המתאימים ל- "lindex" ב- "LargestTraceMat" ל -1
9. אתחל את המטריצה הריקה "b2", עם קבוצה שנוספה לאינדקס לפי "loc2"

שלב 8: פיתוח האלגוריתם הכבול: הפרעה של חורים

בהתמודדות עם חורים, הערכים המאוחסנים ב- "b2" עקבו אחר מבנים אחרים מלבד העקוב הגדול ביותר, ושרטוטם על צורה מלאה של "LargestTraceMat" יחשוף היכן ישנם חורים באזורי המוח.

1. צור מערך "filledMat", שהוא מילוי בצורה של "LargestTraceMat"
2. צור מערך "interferenceMat", מערך "ysize" לפי "xsize" של אפסים
3. צור מערך "interferenceloc", כדי לאחסן את הערכים מ- "b2", המחוברים אנכית
4. צור מערך "לינדקס" לאחסון המדדים התואמים "interferenceloc"
5. עבור מדדים ב- "interferenceMat" התואמים ל- "lindex", הגדר ערך ל- 1, מה שהופך אזור שונה לתחום

שלב 9: פיתוח האלגוריתם הכבול: איתור חורים, סיום גבולות המוח וגבולות חורים

1. הגדר מערך "tempMat" שווה ל- "interferenceMat" פלוס "filledMat", ובכך הוסף כל ערך במטריצה זה לזה.
2. הגדר מערך "holesLoc" שווה למדדים שבהם "interferenceMat" ו- "filledMat" שניהם היו שווים לאחד
3. הגדר את "holeMat" כמטריצת אפס של ממדים "גודל" x "גודל"
4. הגדר מדדים ב- "holesMat" השווים ל- "holesLoc" כאחד
5. הגדר את "המוח" ל- "LargestTraceMat"
6. הגדר "חורים" ל "חורים מאט"

עם הממצא שבו ערכי המטריצות הנוספות היו שוות ל -2, מיקומי החורים היו מאובטחים בקלות ומתווים על מטריצה ריקה.

שלב 10: נתוני רישום: פונקציה PatientFiles.m

בדומה להתקנת הפונקציה האחרונה, לחץ על הלחצן בפינה השמאלית העליונה של החלון בו כתוב "חדש" עם סימן פלוס צהוב מודגש ובחר באפשרות "פונקציה", כדי לפתוח בחלון העורך רווח דומה לזה שבתמונה השלישית. בשורה הראשונה, מחק את מטריצת הפלט והחלף ב"פלט "בלבד, החלף" ללא כותרת "ב-" patientFiles ", מחק את כל ארגומנטים הקלט ובצע במקום זאת את העיצוב שצוין בתמונה הרביעית של שורת הקוד. השורה הראשונה של פונקציה זו צריכה להתאים לעיצוב התמונה.

שלב 11: רישום נתונים לקבצים

כדי להגדיר קובץ לרישום הנתונים שנמצאו על ידי הפונקציה הראשית (שעוד לא יתואר), עלינו לבצע את השלבים הבאים (כפי שנקבע על ידי הקוד שורה אחר שורה).

1. בדוק אם הקלט עבור patientname הוא מחרוזת.
2. אם זו אינה מחרוזת, הצג כי קלט שם המטופל צריך להיות מחרוזת.
3. סיים את המשפט if (למנוע שגיאה).
4. הגדר משפט מחרוזת "DateandTime" שייתן את הפורמט הבא: שעה: דקות-חודש/יום/שנה.
5. הגדר את שם הקובץ המשתנה לכתובת הבאה: patientname.m.

עכשיו לסעיף הבא של הפונקציה: האם קיים קובץ בשם זה כבר?

1) נניח שהקובץ בשם זה כבר קיים:

1. הפעל את הקובץ כדי לקבל את הערכים מהעבר בתור
2. הוסף את נתוני "DateandTime" של האיטרציה הנוכחית כתא חדש במערך התא של ערכי x (סוף אינדקס+1)
3. הוסף את ערך "brainVolume" הנוכחי כתא חדש במערך התא של ערכי y (סוף אינדקס+1)
4. שמור את המשתנים הנוכחיים הטעונים בקובץ.

2) נניח שהקובץ בשם זה אינו קיים:

1. צור קובץ חדש עם השם המאוחסן במשתנה "patientname"
2. הוסף את נתוני "DateandTime" הנוכחיים כתא למערך התאים הריק של ערכי x
3. הוסף את נתוני "brainVolume" הנוכחיים כתא למערך התאים הריק של ערכי y
4. שמור את המשתנים הנוכחיים הטעונים בקובץ.

שלב 12: נתוני רישום: הצגת חלקה של נפח המוח לאורך זמן

1. המר את מערך ערכי x (xVals) למערך קטגורי (xValsCategorical), כדי לאפשר תכנון
2. צור חלון דמות 5
3. משרטט את הנקודות המיועדות על ידי "xValsCategorical" ו- "yVals" (המכיל נפח מוח), בעזרת עיגולים חלולים לציון נקודות ולהתחבר בקווים מקווקים.
4. כותרת העלילה כ: patientName נתוני נפח המוח
5. סמן את ציר ה- x כפי שמוצג בתמונה
6. סמן את ציר ה- y כפי שמוצג בתמונה
7. תנו לדמות 5 שווה לפלט

מכאן שהפונקציה patientName הנקראת תניב קובץ עם נתונים ערוכים העוקבים אחר נפח המוח לאורך זמן ועלילה המציגה מגמות.

שלב 13: סגירת פערים בחלקות משנה: תת חלקה מ

הפונקציה, המותאמת מהקוד מ- https://www.briandalessandro.com, מתפקדת כדי לסגור את הפערים בין דמויות העלילה של הקוד הראשי, כאשר הדמויות המציגות את תמונות ה- MRI ושכבות המוח נוצרות. פונקציית החלקה המשמשת בתוך subplotclose.m מתאימה את המיקום של חלקות המשנה הנתונות כך שיתאימו זו לזו בהיבט של הממד הארוך יותר. לדוגמה, אם הקוד מתכוון למטריצה של 7 x 3, השורות יתאימו צמודות מכיוון שממד השורה ארוך יותר. אם הקוד מתכוון למטריצה של 3 x 7, העמודות יתאימו צמודות, עם פערים בשורות, כפי שמוצג בדמויות הקוד הראשי שלנו.

שלב 14: הקוד הראשי: ניקוי הכל ותשובה לתשומות

כדי להפעיל את הקוד הראשי, לחץ על אותו כפתור שאומר "חדש" בפינה השמאלית העליונה של החלון ובחר "סקריפט" במקום "פונקציה" מהקטעים הקודמים. הקלד את הקוד כפי שמוצג בתמונה בתוך חלון העורך. שורות הקוד מבצעות את המשימות הבאות לפי הסדר:

1. סגור את כל הקבצים הפתוחים למעט 0, 1 ו -2.
2. סגור את כל חלונות הדמויות.
3. נקה את כל המשתנים בסביבת העבודה.
4. נקה את חלון הפקודה.
5. הצג בחלון הפקודה: אנא הזן את הממדים הבאים עבור סריקות MRI:
6. בשורה חדשה בחלון הפקודה, שאל: אורך סריקה אחת במילימטרים:. התגובה שהעלה המשתמש תוגדר למשתנה "lengthMM".
7. בקו חדש, שאל: מרחק בין סריקות MRI במילימטרים:. התגובה שהעלה המשתמש תוגדר למשתנה "ZStacks".

שלב 15: הקוד הראשי: עיבוד אצווה של התמונות

בחלק זה, הקוד יטען את התמונות (המורכבות מסריקות MRI של חתכי המוח) ויאחסן את שמות כל קובץ תמונה במשתנה "Base" ויציג כל אחת מסריקות ה- MRI. אנא עקוב אחר הקוד שבתמונה, שעושה את הפעולות הבאות:

1. צור מערך מבנה "BrainImages" המכיל מידע על כל הקבצים בתוך התיקייה הנוכחית המתאימים לפורמט השם של MRI _ (). Png
2. הגדר משתנה "NumberofImages" השווה למספר האלמנטים במערך המבנה "BrainImages"
3. חלון דמות פתוח 1
4. הגדר לולאת for כדי לעבור בין מספר התמונות שנספרו בקובץ
5. עבור כל לולאה, "CurrentImage" הוא השם המתאים של כל קובץ MRI_i.png, כאשר מספר האיטרציה הוא 'i'
6. צור את עלילת המשנה בגודל 3 x 7 להצגת 19 התמונות להטענה על ידי "imshow"
7. הצג כל תמונה כרכיב נוסף בחלון דמות עלילת המשנה
8. כותרת כל רכיב תת חלק כרמה_, כאשר ריק הוא מספר האיטרציה של לולאת ה- for.
9. סיים את לולאת ה- for (הימנעות משגיאה)

זה יציג בחלון האיור 1 את כל סריקות ה- MRI בצורה גולמית בתצורת 3 x 7 ללא פערים בכיוון x.

שלב 16: הקוד הראשי: ריפוד

בעזרת ריפוד, אנו נמנעים מבעיות של אי התאמות קלות בגדלי התמונה שעשויות להניב שגיאות על אי התאמה בממדים במקרה שתמונה אחת מעט גדולה יותר מתמונה אחרת.

1. חלון דמות פתוח 2
2. טען את מטריצת התמונה מ- MRI_1-p.webp" />
3. מצא את גודל המטריצה של התמונה והגדר את "OriginalXPixels" (למספר שורות) ו- "OriginalYPixels" (למספר העמודות)
4. הגדר את המטריצה "BrainMat" שתכלול את כל האפסים עם 20 שורות נוספות ו -20 עמודות נוספות לכל מטוס, ו -19 חתכים רוחביים, אחד לכל מטוס.
5. הגדר את "HolesMat" כך שיורכב מאותו מערך תלת מימדי של אפסים לקואורדינטות חורי קלט מאוחר יותר
6. צור "zeroMat" בגודל של כרית בתוספת עשרים שורות ועשרים עמודות, מערך דו -ממדי של אפסים.

שלב 17: הקוד הראשי: קביעת גבולות

1. הגדר לולאת for לעבור את הנתונים מכל תמונה שהועלתה קודם לכן
2. באותו אופן עיבוד אצווה קודם לכן, "CurrentImage" טוען קבצים עם "MRI_i.png", כאשר i הוא מספר האיטרציה
3. הפעל כל תמונה באמצעות פונקציית העיבוד "LevelCurveTracings2.m" שביצעת קודם לכן
4. מצא את גודל הפלט "מוח", הגדר את מספר השורות ל- "Currentrow" ואת מספר העמודות ל- "Current columns"
5. הגדר את "CurrentMat" למטריצה של אפסים עם הממדים שצוין על ידי "Currentrow" ו- "Current columns"
6. מרכז את הנתונים מ- "Brain" ב- "CurrentMat", עם שוליים של 10 שורות מכל הצדדים
7. צור עלילת משנה במידות 3 x 7, להצגת גבולות התמונות
8. כותרת כל אחד מרכיבי עלילת המשנה בחלון הדמות
9. צור מטריצה תלת ממדית "BrainMat" המורכבת מכל שכבת גבולות "CurrentMat"
10. סיים את לולאת ה- for (למניעת שגיאות)

תת הסעיף הבא ממלא את החורים שנותרו בחלק העליון והתחתון של הצורה התלת ממדית המוצעת

1. הגדר את "LevelCurve1" שווה לשכבה הראשונה של "BrainMat" (תחתית מוצק)
2. הגדר את "LevelCurveEnd" שווה לשכבה האחרונה של "BrainMat" (החלק העליון של מוצק)
3. החלף את "LevelCurve1" בשכבה מלאה
4. החלף את "LevelCurveEnd" בשכבה מלאה
5. הגדר את השכבה המלאה כשכבה התחתונה של "BrainMat"
6. הגדר את השכבה המלאה כשכבה העליונה של "BrainMat"

שלב 18: הקוד הראשי: קביעת ממד Z הנכון

שלוש השורות הראשונות מורכבות מהקמת מערך ריק "z", וביצוע פעולות המרה פשוטות (חלוקת פיקסלים באורך) בכדי לקבל קריאה נכונה של עוצמת הקול ב- mm^3

1. צור לולאת for כדי לעבור בין כל שכבה
2. מצא את מספר האחד בשכבה נתונה
3. המר את קואורדינטות z לאלה לערכים המוקדמים ליחס הנכון, מוגדרים ל- "tempz", וקטור עמודה.
4. הוסף ערך z עבור עקומת הרמה לווקטור z

עם זה קואורדינטות z מותאמות כראוי.

שלב 19: הקוד הראשי: קביעת קואורדינטות X ו- Y

עכשיו לקבוע את מיקומי x ו- y של כל אחת מהנקודות בגבולות.

1. אתחל את "xBrain" כמערך ריק
2. אתחול "yBrain" כמערך ריק
3. הגדר לולאה עבור לולאה בכל תמונה נטענת
4. ערוך מטריצת שתי עמודות לאחסון הקואורדינטות המישוריות של כל נקודה במגבלה, המיוצגות על ידי וקטורי העמודה "RowBrain" ו- "ColumnBrain"
5. הוסף "xBrain" עם קואורדינטות "RowBrain" שנמצאות כעת
6. הוסף את "yBrain" עם הקואורדינטות "ColumnBrain" שנמצאות כעת
7. סיים את הלולאה for (למניעת שגיאות)

שלב 20: הקוד הראשי: תכנון מבנה תלת ממדי, מציאת נפח ונתוני רישום

בעזרת הפונקציה alphaShape ניצור מבנה תלת מימדי שממנו נוכל לחשב את נפח המוח.

1. השתמש בפונקציה alphaShape, חבר את הווקטורים "xBrain", "yBrain" ו- "z" עבור קואורדינטות x, y ו- z והגדר אותו שווה ל- "BrainPolyhedron"
2. חלון דמות פתוח 3
3. משרטטים את צורת האלפא המחושבת "BrainPolyhedron", מוצגים בחלון הדמות
4. חשב את עוצמת הקול של צורת האלפא, תוך שימוש בפונקציה "נפח" המתאימה לצורות אלפא
5. המר את עוצמת הקול ל- mm^3
6. הדפס את אמצעי האחסון של חומר מוצק בחלון הפקודה
7. בקש להגדיר שם למטופל כקלט
8. קבל את התאריך והשעה הנוכחיים עם השעון והגדר את "DateandTime"
9. קראו לפונקציית "patientFiles" כדי לרשום ולשרטט את הנתונים המחושבים

מכאן התמונה השנייה והשלישית אמורה להראות את הדמויות המופיעות, ואת התמונה הרביעית שצריכה להיות מוצגת בחלון הפקודה.