Brain Box: Pagsubaybay sa Neural Volume Sa paglipas ng Oras: 20 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-31 10:25

Ang pagsulong sa hangganan ng mas mahabang buhay ng tao ay naglabas ng pagtaas ng mga sakit na hindi nakita ng mga sibilisasyon bago ang atin. Kabilang dito, apektado ng Alzheimer ang humigit-kumulang na 5.3 milyong nabubuhay na mga matatandang Amerikano sa 2017, o humigit-kumulang na 1 sa 10 mga matatandang Amerikano (https://www.alz.org/fact/) at hindi mabilang na iba pa na may demensya. Upang matulungan ang laban na maunawaan kung ano ang nakakaapekto sa ating mga nakatatanda, ang code na ito ay magbibigay ng kasangkapan sa hinaharap na mga mananaliksik at sabik na malaman ang kakayahang subaybayan ang dami ng utak sa paglipas ng panahon.

Hakbang 1: Paggamit ng Brain Box

Upang magamit ang kahon ng utak, kailangan lamang ng isa ang mga sumusunod:

• Ang pag-scan ng MRI ng isang utak at ang pangalan at format ng naturang mga file (dapat lahat ay may halos magkatulad na mga sukat)
• Haba ng isang pag-scan
• Distansya sa pagitan ng bawat layer (MRI scan)
• Pangalan ng Pasyente (Kapag nag-input, huwag magsama ng mga puwang at mangyaring gawing malaking titik ang apelyido at apelyido, tulad ng: FirstnameLastname)

At mula dito, ang isa ay may kakayahang subaybayan ang mga indibidwal na kalakaran sa dami ng utak sa paglipas ng panahon. Kaya, ang mga numero para sa mga uso sa Alzheimer ay maaaring subaybayan ng software na ito. Ang haba na ginamit namin sa pagsubok ay 180 mm para sa haba ng isang pag-scan at 5 mm para sa distansya sa pagitan ng mga pag-scan ng MRI, batay sa average na mga numero.

Gayunpaman, ang aplikasyon ng kahon ng utak ay hindi dapat mapigilan sa isang gawaing ito. Kung ang mga seksyon ng krus ng isang naibigay na solid ay litrato, tulad ng isang tumor per se, ang mga kalakaran sa mga pagbabago sa dami ng mga ito ay maaari ding subaybayan sa software.

Hakbang 2: Intro: Sinusuri ang Mga Seksyon ng Cross

Sa tatlong mga dimensional na istraktura, ang dalawang dimensional na eroplano na tulad ng binubuo ay tatawaging mga seksyon ng krus. Isipin na ang isang stack ng mga papel ay bumubuo ng isang hugis-parihaba prisma, kung gayon ang bawat piraso ng papel ay magiging isang seksyon ng krus ng papel. Sa pag-iisip ng utak, inilalapat namin ang parehong kurso ng pag-iisip. Ang MRI (magnetic resonance imaging) (tingnan ang impormasyon sa MRI) ay kinukuha ang mga seksyon ng krus ng utak, at mula sa paggamit ng mga hangganan na tinukoy sa bawat "layer" ng utak na ibinigay, maaari kaming bumuo ng isang istraktura upang i-modelo at hanapin ang dami ng utak. Dapat muna tayong bumuo ng isang pagpapaandar upang magbigay ng impormasyon sa mga naturang hangganan gayunpaman.

Hakbang 3: Pag-set up ng isang Pag-andar: LevelCurveTracings.m

Una, tiyakin na ang iyong computer ay may MATLAB_R2017b na nai-download (mag-download dito) at buksan ang MATLAB. Sa interface ng MATLAB, mag-click sa pindutan sa kaliwang sulok sa itaas ng window na nagsasabing "Bago" na may naka-bold na dilaw na plus sign, at piliin ang pagpipiliang "function", upang buksan sa window ng editor ang isang puwang na kahawig ng sa pangatlong larawan. Magtutuon kami sa pagbabago ng unang linya upang mai-setup ang pagpapaandar. Kung saan sinasabing "outputArg1", palitan ito ng "utak", "outputArg2" upang sabihin ang "mga butas", "untitled2" sa "exp2", at "inputArg1" sa "imahe", at tanggalin ang "inputArg2". Mayroon ka ngayong pagpapaandar na tatawaging gumagamit ng "exp2", kumukuha ng isang argumento na "imahe" at naglalabas ng mga hangganan ng "utak" at "mga butas". Ang unang linya ng pag-andar ay dapat maging katulad ng linya na nakalarawan sa ika-apat na larawan. Tanggalin ang lahat ng code sa ibaba ng paunang linya na ito.

Hakbang 4: Pagbuo ng Bound Algorithm: Paghahanap ng Mga Hangganan

I-type ang code tulad ng sumusunod sa ibaba ng linya. Ang seksyon na ito ng pagpapaandar ay ginagawa ang sumusunod na linya-by-line.

1. I-load ang imahe na "imahe" sa variable na "mri".
2. Gawin ang "mri" sa isang imaheng ginawa ng mga halaga sa isang saklaw ng mga numero sa isa at mga zero (aka binarizing) batay sa isang itinakdang halaga ng threshold. Kung ang halaga sa isang pixel ay katumbas ng o higit sa 0.1, ito ay nakatakda sa isa, kung hindi, ang halaga sa pixel na iyon ay nakatakda sa zero.
3. Ang sumusunod na apat na linya ay ginagawang 10 mga haligi at hilera sa mga gilid ng layer ng pag-scan ng MRI sa mga zero, upang maiwasan ang pagbabasa ng mga hindi wastong halaga bilang paggawa ng mga hangganan (tulad ng natutunan mula sa pag-eksperimento sa code).
4. Sa huling linya, sinusundan ng mga bwboundaries ang mga hangganan ng binarized na imaheng "mri" at itinatakda itong katumbas ng "b", isang hanay na may mga elemento na ang mga indeks ay tumutugma sa mga hangganan na itinakda sa isa.

Hakbang 5: Pagbuo ng Bound Algorithm: pagbuo ng Outer Bound Array

Sundin kasama ang window ng editor kasama ang sumusunod na code sa larawan. Ang seksyon na ito ng code ay ang sumusunod na linya-by-line.

1. Hanapin ang haba ng bawat hilera ng binarized na imaheng "b" (inilalapat ng cellfun ang haba ng pag-andar sa bawat hilera).
2. Itakda ang "loc" upang maiimbak ang maximum na haba.
3. Hanapin ang index ng maximum na haba, itinakda upang mag-imbak sa "pinakamalakingTrace".
4. Hanapin ang laki ng imaheng "mri", na binubuo ng parehong laki tulad ng "b", at itakda sa "BWsize".
5. Hanapin ang bilang ng mga hilera sa array ng imahe, itakda sa "ysize".
6. Hanapin ang bilang ng mga haligi sa array ng imahe, itinakda sa "xsize".
7. Bumuo ng array na "pinakamalakingTraceMat", isang "ysize" ng "xsize" matrix ng mga zero.
8. Hanapin ang katumbas na index mula sa mga naka-subscript na halaga na tumutugma sa kung saan ang pinakamalaking halaga ngTrace x at mga halagang y, na nakaimbak sa vector na "lindex".
9. Sa matrix ng mga zero, "pinakamalakingTraceMat", i-on ang mga elemento sa mga indeks na tumutugma sa mga halaga ng index na nakaimbak bilang mga elemento sa "lindex" sa isa.

Sa gayon ang lohikal na hanay na "pinakamalakingTraceMat" ay may pinakamalaking sakop na rehiyon ng ibinigay na seksyon ng cross scan ng utak na naka-plot bilang mga may isang backdrop ng zero

Hakbang 6: Pagbuo ng Bound Algorithm: Paggawa Gamit ang Center Point

Susunod, dapat nating subukan upang makita kung ang cross section ay binubuo ng higit sa isang rehiyon (ang pinakamalaki). Sa pamamagitan ng pagsubok ng pagkakahanay ng centroid ng pinakamalaking rehiyon, maaari nating makita kung mayroong isang magkadikit na rehiyon, na magbubunga ng isang mas centered centroid, o ang posibilidad ng maraming mga rehiyon.

1. Gumamit ng "regionProps" upang makahanap ng impormasyon sa kasalukuyan na mga centroid, itinakda na katumbas ng istraktura ng array na "tempSonstr"
2. Bumuo ng array na "centroids" na may data mula sa patlang na "centroid" na pinagsama patayo
3. Kunin ang mga halagang haligi ng haligi ng "centroids" (ang pahalang na mga coordinate ng sukat)
4. Patakbuhin ang isang filter upang suriin ang pagkakahanay ng centroid sa pahalang na sentro

Hakbang 7: Pagbuo ng Bound Algorithm: Kapag ang isang Centroid ay Hindi Nakasentro

Sa senaryo na ang centroid ng pinakamalaking rehiyon ng bakas ay hindi nakasentro, dumaan kami sa mga sumusunod na hakbang. Tulad ng napagmasdan namin sa pag-scan ng MRI, ang ugali ay ang magkaroon ng hemispheres ng utak na nakalarawan sa seksyon ng krus kung hindi magkadikit, kaya't patuloy kaming naglalagay ng ikalawang pinakamalaking bakas kasama ang pinakamalaking bakas sa "pinakamalakingTraceMat"

1. Itakda ang na-trace na matrix sa isang bagong variable na "b2"
2. Simulan ang walang laman na matrix na "b2", na may isang hanay na na-index ng "loc"
3. Lumikha ng isang kondisyon, para kapag ang isang centroid ay hindi nakasentro (ibig sabihin, isang maramihang layer ng rehiyon)
4. Magtakda ng isang bagong laki ng bakas na matatagpuan para sa bawat hilera (traceSize2)
5. Itakda ang "loc2" upang mahanap ang mga indeks kung saan naroroon ang mga hangganan
6. Hayaan ang mga cell na tinukoy ng "loc2" sa "b2" na katumbas ng "pinakamalakingTrace2"
7. I-convert ang mga subscripts sa mga indeks, itinakda sa "lindex"
8. Baguhin ang mga elemento na naaayon sa "lindex" sa "pinakamalakingTraceMat" sa 1
9. Simulan ang walang laman na matrix na "b2", na may isang hanay na na-index ng "loc2"

Hakbang 8: Pagbuo ng Bound Algorithm: Pagkagambala ng mga butas

Sa pagharap sa mga butas, ang mga halagang nakaimbak sa "b2" ay nakasubaybay sa mga istraktura bukod sa pinakamalaking bakas, at ang paglalagay ng mga ito sa isang puno ng form na "pinakamalakingTraceMat" ay magbubunyag kung saan may mga butas sa mga rehiyon ng utak.

1. Lumikha ng array na "filledMat", na kung saan ay isang napunan sa anyo ng "pinakamalakingTraceMat"
2. Lumikha ng array na "interferensiMat", isang "ysize" ng "xsize" na hanay ng mga zero
3. Lumikha ng array na "interferenceloc", upang maiimbak ang mga halaga mula sa "b2", pinagsama patayo
4. Lumikha ng array na "lindex" upang maiimbak ang mga indeks na tumutugma sa "interferenceloc"
5. Para sa mga indeks sa "interferensiMat" na tumutugma sa "lindex", itakda ang halaga sa 1, na gumagawa ng ibang sakop na rehiyon

Hakbang 9: Pagbuo ng Bound Algorithm: Paghahanap ng Mga Lubso, Pagwawakas sa Mga Hangganan ng Utak at Mga Hangganan ng butas

1. Itakda ang array na "tempMat" na katumbas ng "interferensiMat" plus "filledMat", sa gayon ay idaragdag ang bawat halaga sa matrix sa bawat isa
2. Itakda ang array na "holeLoc" na katumbas ng mga indeks kung saan ang "interferensiMat" at "napunoMat" ay kapareho ng isa
3. I-setup ang "holeMat" bilang isang zero matrix ng mga sukat na "ysize" x "xsize"
4. Itakda ang mga indeks sa "holeMat" na katumbas ng "holeLoc" bilang isa
5. Itakda ang "utak" sa "pinakamalakingTraceMat"
6. Itakda ang "hole" sa "holeMat"

Sa paghanap kung saan ang mga halaga ng mga idinagdag na matrices ay katumbas ng 2, ang mga lokasyon ng butas ay madaling na-secure at naka-plot sa isang walang laman na matrix.

Hakbang 10: Data ng Pag-log: Pag-andar ng PatientFiles.m

Tulad ng pag-set up ng huling pagpapaandar, mag-click sa pindutan sa kaliwang sulok sa itaas ng window na nagsasabing "Bago" na may isang naka-bold na dilaw na plus sign, at piliin ang pagpipiliang "function", upang buksan sa window ng editor ang isang puwang na kahawig nito sa pangatlong larawan. Sa unang linya, tanggalin ang output matrix at palitan ng "output" lamang, palitan ang "untitled2" ng "patientFiles", tanggalin ang lahat ng mga argumento sa pag-input, at sa halip ay sundin ang pag-format na tinukoy sa ika-apat na larawan ng linya ng code. Ang unang linya ng pagpapaandar na ito ay dapat na tumutugma sa pag-format ng larawan.

Hakbang 11: Pag-log ng Data Sa Mga File

Upang mag-set up ng isang file upang mai-log ang data na natagpuan ng pangunahing pagpapaandar (na mailarawan pa), dapat naming sundin ang mga hakbang na ito (tulad ng inireseta ng linya ng linya sa linya).

1. Suriin kung ang input para sa pasyenteName ay isang string.
2. Kung hindi ito isang string, ipakita na ang input ng pasyenteName ay dapat na isang string.
3. Tapusin ang pahayag kung (maiwasan ang error).
4. Mag-set up ng isang string statement na "DateandTime" na magbibigay ng sumusunod na format: oras: minuto - buwan / araw / taon.
5. Itakda ang variable na fileName sa sumusunod: patientName.m.

Ngayon sa susunod na seksyon ng pagpapaandar: Mayroon bang isang file ng pangalang ito?

1) Ipagpalagay na mayroon nang file ng pangalang ito:

1. Patakbuhin ang file upang makuha ang mga halaga mula sa nakaraang nakapila
2. Idagdag ang data na "DateandTime" ng kasalukuyang pag-ulit bilang isang bagong cell sa cell array ng mga halagang x (index end + 1)
3. Idagdag ang kasalukuyang halaga ng "brainVolume" bilang isang bagong cell sa cell array ng mga halagang y (index end + 1)
4. I-save ang kasalukuyang mga variable na na-load sa file.

2) Ipagpalagay na ang file ng pangalang ito ay hindi umiiral:

1. Lumikha ng isang bagong file na may pangalan na nakaimbak sa variable na "pasyenteName"
2. Idagdag ang kasalukuyang data na "DateandTime" bilang isang cell sa walang laman na hanay ng mga halagang x
3. Idagdag ang kasalukuyang data na "utakVolume" bilang isang cell sa walang laman na hanay ng mga halagang y
4. I-save ang kasalukuyang mga variable na na-load sa file.

Hakbang 12: Data ng Pag-log: Nagpapakita ng isang Plot ng Dami ng Utak sa Paglipas ng Oras

1. I-convert ang x halaga ng array (xVals) sa isang kategoryang array (xValsCategorical), upang payagan ang paglalagay
2. Bumuo ng window ng figure 5
3. I-plot ang mga puntos na itinalaga ng "xValsCategorical" at "yVals" (naglalaman ng dami ng utak), gamit ang mga guwang na bilog upang ipahiwatig ang mga puntos at maiugnay sa mga tinurok na linya
4. Pamagat ng balangkas bilang: pasyenteName Brain Volume Data
5. Lagyan ng label ang x axis tulad ng ipinakita sa larawan
6. Lagyan ng label ang y axis tulad ng ipinakita sa larawan
7. Hayaan ang figure 5 na katumbas ng output

Mula dito, ang function na tinatawag na pasyenteName ay magbubunga ng isang file na may na-edit na data na sinusubaybayan ang dami ng utak sa paglipas ng panahon, at isang balangkas na nagpapakita ng mga uso.

Hakbang 13: Mga Sara sa Pagsara sa Mga Subplot: Subplotclose.m

Ang pagpapaandar, na iniangkop mula sa code mula sa https://www.briandalessandro.com, ay gumagana upang isara ang mga puwang sa pagitan ng mga subplot na numero ng pangunahing code, kapag nilikha ang mga figure na nagpapakita ng mga imahe ng MRI at mga layer ng utak. Ang pagpapaandar ng subplot na ginamit sa loob ng subplotclose.m ayusin ang posisyon ng mga ibinigay na subplot upang magkasya nang magkakasama sa isa't isa sa aspeto ng mas mahabang sukat. Halimbawa, kung nilalayon ng code ang isang 7 x 3 matrix, magkakasya ang mga hilera habang mas mahaba ang sukat ng hilera. Kung nilalayon ng code ang isang 3 x 7 matrix, ang mga haligi ay magkakasya, at may mga puwang sa mga hilera, tulad ng ipinakita sa mga numero ng aming pangunahing code.

Hakbang 14: Ang Pangunahing Code: Pag-clear sa Lahat at Pag-uudyok para sa Mga Pag-input

Upang simulan ang pangunahing code, mag-click sa parehong pindutan na nagsasabing "Bago" sa kaliwang sulok sa itaas ng window, at piliin ang "Script" sa halip na "Pag-andar" mula sa mga naunang mga seksyon. I-type ang code tulad ng ipinapakita sa larawan sa loob ng window ng editor. Ang mga linya ng code ay ginagawa ang mga sumusunod na gawain nang maayos:

1. Isara ang lahat ng mga file na bukas maliban sa 0, 1, at 2.
2. Isara ang lahat ng window ng pigura.
3. I-clear ang lahat ng variable sa workspace.
4. I-clear ang Window ng Command.
5. Ipakita sa Command Window: Mangyaring i-input ang mga sumusunod na sukat para sa pag-scan ng MRI:
6. Sa isang bagong linya sa Command Window, tanungin: Ang haba ng isang pag-scan sa milimeter:. Ang tugon na inilagay ng gumagamit ay itatakda sa variable na "habaMM".
7. Sa isang bagong linya, tanungin: Distansya sa pagitan ng mga pag-scan ng MRI sa milimeter:. Ang tugon na inilagay ng gumagamit ay itatakda sa variable na "ZStacks".

Hakbang 15: Ang Pangunahing Code: Pagproseso ng Batch ng Mga Larawan

Sa seksyong ito, mai-load ng code ang mga imahe (na binubuo ng mga pag-scan ng MRI ng mga seksyon ng krus ng utak) at iimbak ang mga pangalan ng bawat file ng imahe sa variable na "Base" at ipapakita ang bawat pag-scan ng MRI. Mangyaring sundin kasama ang code sa larawan, na ginagawa ang mga sumusunod:

1. Lumikha ng istraktura ng array na "BrainImages" na naglalaman ng impormasyon sa lahat ng mga file sa loob ng kasalukuyang folder na umaangkop sa format ng pangalan ng MRI _ (). Png
2. Itakda ang variable na "NumberofImages" na katumbas ng bilang ng mga elemento sa istrakturang array na "BrainImages"
3. Buksan ang window ng pigura 1
4. Magtakda ng isang para sa loop upang paikutin para sa bilang ng mga imahe na binibilang sa file
5. Para sa bawat loop, ang "CurrentImage" ay ang kani-kanilang pangalan ng bawat file na MRI_i.png, na may bilang ng pag-ulit bilang 'i'
6. Bumuo ng isang 3 x 7 subplot upang ipakita ang 19 na mga imahe na mai-load ng "imshow"
7. Ipakita ang bawat imahe bilang isa pang elemento sa window ng subplot figure
8. Pamagat ng bawat elemento ng subplot bilang Antas_, kung saan blangko ang numero ng pag-ulit ng para sa loop.
9. Tapusin ang para sa loop (pag-iwas sa error)

Ipapakita ito sa window ng numero 1 lahat ng pag-scan ng MRI sa hilaw na form sa isang 3 x 7 na pagsasaayos na walang mga puwang sa oryentasyong x.

Hakbang 16: Ang Pangunahing Code: Padding

Sa padding, iniiwasan namin ang isyu ng bahagyang mga pagkakaiba sa mga laki ng imahe na maaaring magbunga ng error para sa hindi pagtutugma sa dimensyon sa kaso na ang isang larawan ay bahagyang mas malaki kaysa sa iba pa.

1. Buksan ang window ng figure 2
2. I-load ang imahe matrix mula sa MRI_1-p.webp" />
3. Hanapin ang laki ng matrix ng imahe at itakda sa "OriginalXPixels" (para sa bilang ng mga hilera) at "OriginalYPixels" (para sa bilang ng mga haligi)
4. I-setup ang matrix na "BrainMat" na binubuo ng lahat ng mga zero na may 20 higit pang mga hilera at 20 pang mga haligi para sa bawat eroplano, at 19 na kabuuang mga seksyon ng krus, isa bawat eroplano.
5. I-set up ang "HolesMat" na binubuo ng parehong tatlong dimensional na hanay ng mga zero upang mag-input ng mga hole coordinate sa paglaon
6. Lumikha ng "zeroMat" upang maging sukat ng pad kasama ang dalawampung hanay at dalawampung haligi, isang dalawang dimensional na hanay ng mga zero.

Hakbang 17: Ang Pangunahing Code: Pagtukoy ng Mga Hangganan

1. Magtakda ng isang para sa loop upang dumaan sa data mula sa bawat imahe na na-load nang mas maaga
2. Sa parehong paraan ng pagproseso ng batch nang mas maaga, ang "CurrentImage" ay naglo-load ng mga file na may "MRI_i.png", kung saan ako ang numero ng pag-ulit
3. Patakbuhin ang bawat imahe sa pamamagitan ng pag-andar ng pagpoproseso ng "LevelCurveTracings2.m" na ginawa mo nang mas maaga
4. Hanapin ang laki ng output na "Utak", itakda ang bilang ng mga hilera sa "Currentrow" at ang bilang ng mga haligi sa "Mga Kasalukuyang Column"
5. Itakda ang "CurrentMat" sa isang matrix ng zero na may mga sukat na tinukoy ng "Currentrow" at "Currentcolumns"
6. I-center ang data mula sa "Brain" sa "CurrentMat", na may margin na 10 mga hilera sa lahat ng panig
7. Bumuo ng isang subplot ng mga sukat 3 x 7, upang ipakita ang mga hangganan ng mga imahe
8. Pamagatan ang bawat isa sa mga elemento ng subplot sa window ng figure
9. Bumuo ng tatlong dimensional matrix na "BrainMat" na binubuo ng bawat layer ng mga hangganan na "CurrentMat"
10. Tapusin ang para sa loop (para sa pag-iwas sa mga error)

Ang sumusunod na subseksyon ay pinupunan ang mga butas na natira sa tuktok at ibaba ng ipinanukalang tatlong dimensional na hugis

1. Itakda ang "LevelCurve1" na katumbas ng unang layer ng "BrainMat" (ilalim ng solid)
2. Itakda ang "LevelCurveEnd" na katumbas ng pangwakas na layer ng "BrainMat" (tuktok ng solid)
3. Overwrite ang "LevelCurve1" na may isang pinuno ng layer
4. Overwrite ang "LevelCurveEnd" na may isang napuno ng layer
5. Itakda ang napuno sa layer bilang ilalim na layer ng "BrainMat"
6. Itakda ang napuno sa layer bilang tuktok na layer ng "BrainMat"

Hakbang 18: Ang Pangunahing Code: Pagtukoy sa Wastong Sukat ng Z

Ang unang tatlong mga linya ay binubuo ng pag-set up ng isang walang laman na array na "z", at paggawa ng mga simpleng operasyon ng conversion (hatiin ang mga pixel sa haba) upang makakuha ng wastong pagbabasa ng dami sa mm ^ 3

1. Lumikha ng isang para sa loop upang ikot sa bawat layer
2. Hanapin ang bilang ng mga nasa isang ibinigay na layer
3. I-convert ang mga coordinate ng z para sa isa sa mga halagang na-scale sa tamang ratio, na nakatakda sa "tempz", isang vector vector
4. Magdagdag ng halaga ng z para sa antas ng curve sa vector z

Sa mga z coordinate na ito ay nababagay nang maayos.

Hakbang 19: Ang Pangunahing Code: Pagtukoy sa Mga Coordinate ng X at Y

Ngayon upang matukoy ang x at y posisyon ng bawat isa sa mga puntos sa mga hangganan.

1. Simulan ang "xBrain" bilang isang walang laman na array
2. Simulan ang "yBrain" bilang isang walang laman na array
3. Mag-set up ng isang para sa loop sa loop sa bawat imahe na na-load
4. Magtala ng dalawang haligi ng matris upang maiimbak ang mga planar na koordinasyon ng bawat punto sa nakagapos, na kinakatawan ng mga haligi ng mga vector na "RowBrain" at "ColumnBrain"
5. Idagdag ang "xBrain" na may kasalukuyang nahanap na mga coordinate na "RowBrain"
6. Idagdag ang "yBrain" na may kasalukuyang nahanap na mga coordinate na "ColumnBrain"
7. Tapusin ang para sa loop (para sa pag-iwas sa error)

Hakbang 20: Ang Pangunahing Code: Plotting a Three Dimensional Structure, Finding Volume, and Logging Data

Gamit ang pagpapaandar na alphaShape, lilikha kami ng isang tatlong dimensional na istraktura na kung saan maaari naming kalkulahin ang dami ng utak.

1. Gumamit ng function na alphaShape, isaksak ang mga vector na "xBrain", "yBrain" at "z" para sa mga coordinate ng x, y, at z, at itakda ang katumbas ng "BrainPolyhedron"
2. Buksan ang window ng figure 3
3. I-plot ang kinakalkula na alpha na hugis na "BrainPolyhedron", ipakita sa window ng figure
4. Kalkulahin ang dami ng hugis ng alpha, gamit ang isang function na "dami" na gumagana para sa mga hugis ng alpha
5. I-convert ang dami sa mm ^ 3
6. I-print ang dami ng solid sa Command Window
7. Prompt para sa isang pangalan ng pasyente na maitakda bilang isang input
8. Kunin ang kasalukuyang petsa at oras sa orasan, at itakda sa "DateandTime"
9. Tumawag sa pagpapaandar na "patientFiles" upang mag-log at balangkas ang data na kinakalkula

Mula dito ang pangalawa at pangatlong larawan ay dapat ipakita ang mga figure na pop up, at ang ika-apat na larawan na dapat ipakita sa Command Window.