Brain Box: Acompanhamento do volume neural ao longo do tempo: 20 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-31 10:23

O avanço na fronteira de uma vida humana mais longa trouxe o surgimento de doenças não vistas por civilizações antes da nossa. Entre estes, o Alzheimer afetou aproximadamente 5,3 milhões de americanos idosos vivos em 2017, ou aproximadamente 1 em cada 10 americanos idosos (https://www.alz.org/facts/) e inúmeros outros com demência. Para ajudar na luta para entender o que está afligindo nossos idosos, este código irá equipar os futuros pesquisadores e curiosos com a capacidade de monitorar o volume do cérebro ao longo do tempo.

Etapa 1: usando o Brain Box

Para usar a caixa de cérebro, é necessário apenas o seguinte:

• Varreduras de ressonância magnética de um cérebro e o nome e formato de tais arquivos (todos devem ter aproximadamente as mesmas dimensões)
• Comprimento de uma varredura
• Distância entre cada camada (varredura de ressonância magnética)
• Nome do paciente (ao inserir, não inclua espaços e coloque o nome e o sobrenome em maiúscula, como: NomeSobrenome)

E, a partir disso, é possível acompanhar as tendências de volume cerebral de um indivíduo ao longo do tempo. Assim, os números das tendências de Alzheimer podem ser rastreados por este software. O comprimento que usamos no teste foi de 180 mm para o comprimento de uma varredura e 5 mm para a distância entre as varreduras de ressonância magnética, com base em números médios.

No entanto, a aplicação da caixa do cérebro não precisa ser restrita a esta tarefa. Se as seções transversais de um determinado sólido são fotografadas, como um tumor em si, as tendências nas mudanças de volume para eles também podem ser rastreadas no software.

Etapa 2: Introdução: Analisando as seções transversais

Em estruturas tridimensionais, os planos bidimensionais em que consistem seriam chamados de seções transversais. Imagine que uma pilha de papéis forma um prisma retangular, então cada pedaço de papel seria uma seção transversal do papel. Ao imaginar o cérebro, aplicamos a mesma linha de pensamento. MRI (imagem por ressonância magnética) (ver informações sobre MRI) captura as seções transversais do cérebro e, usando os limites definidos em cada "camada" do cérebro fornecida, podemos construir uma estrutura para modelar e encontrar o volume do cérebro. No entanto, devemos primeiro construir uma função para fornecer informações sobre esses limites.

Etapa 3: Configurando uma função: LevelCurveTracings.m

Primeiro, certifique-se de que o MATLAB_R2017b tenha sido baixado em seu computador (baixe aqui) e abra o MATLAB. Na interface do MATLAB, clique no botão no canto superior esquerdo da janela que diz "Novo" com um sinal de mais amarelo em negrito e selecione a opção "função", para abrir na janela do editor um espaço que se assemelha ao do terceira foto. Vamos nos concentrar em alterar a primeira linha para configurar a função. Onde diz "outputArg1", substitua por "brain", "outputArg2" para dizer "holes", "untitled2" para "exp2" e "inputArg1" para "image" e exclua "inputArg2". Agora você tem uma função a ser chamada usando "exp2", pegando um argumento "imagem" e gerando os limites de "cérebro" e "buracos". A primeira linha da função deve ser semelhante à linha representada na quarta imagem. Exclua todo o código abaixo desta linha inicial.

Etapa 4: desenvolvendo o algoritmo de limite: encontrando limites

Digite o código da seguinte maneira, abaixo da linha. Esta seção da função faz o seguinte linha por linha.

1. Carregue a imagem "image" na variável "mri".
2. Transforme "mri" em uma imagem feita de valores em uma faixa de números a uns e zeros (também conhecida como binarização) com base em um valor limite definido. Se o valor em um pixel for igual ou maior que 0,1, ele é definido como um; caso contrário, o valor naquele pixel é definido como zero.
3. As quatro linhas a seguir transformam 10 colunas e linhas nas bordas da camada de varredura de MRI em zeros, para evitar a leitura de valores impróprios como limites (conforme aprendido com a experiência com o código).
4. Na linha final, bwboundaries traça os limites da imagem binarizada "mri" e a define igual a "b", uma matriz com os elementos cujos índices correspondem aos dos limites definidos como um.

Etapa 5: Desenvolvendo o Algoritmo Bound: Gerando Matriz de Limite Externo

Acompanhe na janela do editor o seguinte código na imagem. Esta seção do código faz o seguinte linha por linha.

1. Encontre o comprimento de cada uma das linhas da imagem binarizada "b" (cellfun aplica o comprimento da função a cada linha).
2. Defina "loc" para armazenar os comprimentos máximos.
3. Encontre o índice do comprimento máximo, definido para armazenar em "maiorTrace".
4. Encontre o tamanho da imagem "mri", que consiste no mesmo tamanho que "b", e defina como "BWsize".
5. Encontre o número de linhas na matriz da imagem, defina como "ysize".
6. Encontre o número de colunas na matriz da imagem, defina como "xsize".
7. Gere o array "maiorTraceMat", uma matriz "ysize" por "xsize" de zeros.
8. Encontre o índice equivalente a partir dos valores subscritos correspondentes a onde estavam os maiores valores de Rastreio xey, armazene no vetor "lindex".
9. Na matriz de zeros, "maiorTraceMat", transforme os elementos nos índices que correspondem aos valores de índice armazenados como elementos em "lindex" em uns.

Assim, a matriz lógica "maiorTraceMat" tem a maior região limitada da seção transversal de varredura do cérebro dada plotada como uns com um fundo de zeros

Etapa 6: Desenvolvendo o Algoritmo Bound: Trabalhando com o Ponto Central

Em seguida, devemos testar para ver se a seção transversal consiste em mais de uma região (a maior). Ao testar o alinhamento do centroide da maior região, podemos ver se há uma região contígua, o que produziria um centróide mais centrado, ou a possibilidade de várias regiões.

1. Use "regionProps" para encontrar informações sobre os centróides presentes, definido igual ao array da estrutura "tempStruct"
2. Matriz de formulário "centroids" com dados do campo "centroid" concatenados verticalmente
3. Pegue os valores da segunda coluna de "centróides" (as coordenadas da dimensão horizontal)
4. Execute um filtro para verificar o alinhamento do centróide com o centro horizontal

Etapa 7: Desenvolvendo o algoritmo vinculado: quando um centróide não está centrado

No cenário em que o centróide da maior região de rastreamento não está centralizado, passamos pelas etapas a seguir. Como observamos nas imagens de ressonância magnética, a tendência era ter hemisférios do cérebro retratados na seção transversal quando não contíguos, então agora continuamos a traçar o segundo maior traço junto com o maior traço no "maiorTraceMat"

1. Defina a matriz rastreada para uma nova variável "b2"
2. Inicialize a matriz vazia "b2", com um conjunto indexado por "loc"
3. Crie uma condicional, para quando um centróide não estiver centralizado (ou seja, uma camada de várias regiões)
4. Defina um novo tamanho de rastreamento a ser encontrado para cada linha (traceSize2)
5. Defina "loc2" para encontrar os índices onde os limites estão presentes
6. Deixe as células especificadas por "loc2" em "b2" serem iguais a "maiorTrace2"
7. Converta os subscritos em índices, defina como "lindex"
8. Altere os elementos correspondentes a "lindex" em "maioresTraceMat" para 1
9. Inicialize a matriz vazia "b2", com um conjunto indexado por "loc2"

Etapa 8: Desenvolvendo o Algoritmo Bound: Interferência de Orifícios

Ao lidar com buracos, os valores armazenados em "b2" rastreiam estruturas diferentes do traço maior, e plotá-los em uma forma preenchida de "maiorTraceMat" revelará onde há buracos nas regiões do cérebro.

1. Crie a matriz "illedMat ", que é uma forma preenchida de" maiorTraceMat"
2. Crie a matriz "interferMat", uma matriz "ysize" por "xsize" de zeros
3. Crie a matriz "interferenceloc", para armazenar os valores de "b2", concatenados verticalmente
4. Crie a matriz "lindex" para armazenar os índices que correspondem a "interferenceloc"
5. Para índices em "interferMat" que correspondem a "lindex", defina o valor como 1, criando uma região limitada diferente

Etapa 9: desenvolvendo o algoritmo de limite: localizando buracos, finalizando limites do cérebro e limites de buracos

1. Defina a matriz "tempMat" igual a "interferMat" mais "PreenchidoMat", adicionando assim cada valor na matriz uns aos outros
2. Defina a matriz "holesLoc" igual aos índices onde "interferMat" e "Preenchido" ambos eram iguais a um
3. Configure "holesMat" como uma matriz zero de dimensões "ysize" x "xsize"
4. Defina índices em "holesMat" que são iguais a "holesLoc" como uns
5. Defina "cérebro" como "maiorTraceMat"
6. Defina "holes" como "holesMat"

Com a descoberta de onde os valores das matrizes adicionadas eram iguais a 2, os locais dos furos foram facilmente protegidos e plotados em uma matriz vazia.

Etapa 10: Registro de dados: Function PatientFiles.m

Muito parecido com a configuração da última função, clique no botão no canto superior esquerdo da janela que diz "Novo" com um sinal de adição amarelo em negrito e selecione a opção "função", para abrir na janela do editor um espaço que assemelha-se ao da terceira foto. Na primeira linha, exclua a matriz de saída e substitua apenas por "saída", substitua "untitled2" por "patientFiles", exclua todos os argumentos de entrada e siga a formatação especificada na quarta imagem da linha de código. A primeira linha desta função deve corresponder à formatação da imagem.

Etapa 11: registro de dados em arquivos

Para configurar um arquivo para registrar os dados encontrados pela função principal (ainda a serem descritos), devemos seguir estes passos (conforme prescrito pelo código linha a linha).

1. Verifique se a entrada para nomedopaciente é uma string.
2. Se não for uma string, exiba que a entrada do nomedopaciente deve ser uma string.
3. Finalize a instrução if (evita erros).
4. Configure uma declaração de string "Data e Hora" que fornecerá o seguinte formato: hora: minutos - mês / dia / ano.
5. Defina a variável fileName como o seguinte: patientName.m.

Agora, para a próxima seção da função: Já existe um arquivo com este nome?

1) Suponha que o arquivo com este nome já exista:

1. Execute o arquivo para obter os valores do passado enfileirados
2. Adicione os dados "DateandTime" da iteração atual como uma nova célula na matriz de células de valores x (índice final + 1)
3. Adicione o valor "brainVolume" atual como uma nova célula na matriz de células de valores y (índice final + 1)
4. Salve as variáveis atuais carregadas no arquivo.

2) Suponha que o arquivo com este nome não exista:

1. Crie um novo arquivo com o nome armazenado na variável "nomedopaciente"
2. Adicione os dados "DateandTime" atuais como uma célula na matriz de células vazia de valores x
3. Adicione os dados "brainVolume" atuais como uma célula na matriz de células vazia de valores y
4. Salve as variáveis atuais carregadas no arquivo.

Etapa 12: Registro de dados: exibição de um gráfico do volume do cérebro ao longo do tempo

1. Converta a matriz de valores x (xVals) em uma matriz categórica (xValsCategorical), para permitir a plotagem
2. Gerar janela de figura 5
3. Trace os pontos designados por "xValsCategorical" e "yVals" (contendo o volume do cérebro), usando círculos vazios para indicar os pontos e serem conectados por linhas tracejadas
4. Título do gráfico como: PatientName Brain Volume Data
5. Rotule o eixo x como mostrado na imagem
6. Rotule o eixo y como mostrado na imagem
7. Deixe a figura 5 igual à saída

A partir disso, a função patientName que está sendo chamada produzirá um arquivo com os dados editados, acompanhando o volume do cérebro ao longo do tempo e um gráfico exibindo as tendências.

Etapa 13: Fechando lacunas em subtramas: Subplotclose.m

A função, adaptada do código de https://www.briandalessandro.com, funciona para fechar as lacunas entre as figuras da subtrama do código principal, quando as figuras exibindo as imagens de ressonância magnética e as camadas do cérebro são criadas. A função subplot usada em subplotclose.m ajusta a posição dos subplots fornecidos para se ajustarem confortavelmente uns aos outros no aspecto da dimensão mais longa. Por exemplo, se o código pretende uma matriz 7 x 3, as linhas se ajustam perfeitamente, pois a dimensão da linha é mais longa. Se o código pretende uma matriz 3 x 7, as colunas se encaixarão bem, com lacunas nas linhas, conforme mostrado nas figuras de nosso código principal.

Etapa 14: O código principal: limpar tudo e solicitar entradas

Para iniciar o código principal, clique no mesmo botão que diz "Novo" no canto superior esquerdo da janela e selecione "Script" em vez de "Função" nas seções anteriores. Digite o código conforme mostrado na imagem dentro da janela do editor. As linhas de código realizam as seguintes tarefas em ordem:

1. Feche todos os arquivos abertos, exceto 0, 1 e 2.
2. Feche todas as janelas da figura.
3. Limpe todas as variáveis na área de trabalho.
4. Limpe a janela de comando.
5. Exibir na janela de comando: Insira as seguintes dimensões para os exames de ressonância magnética:
6. Em uma nova linha na janela de comando, pergunte: Comprimento de uma varredura em milímetros:. A resposta colocada pelo usuário será configurada para a variável "lengthMM".
7. Em uma nova linha, pergunte: Distância entre as varreduras de ressonância magnética em milímetros:. A resposta colocada pelo usuário será definida para a variável "ZStacks".

Etapa 15: O código principal: processamento em lote das imagens

Nesta seção, o código carregará as imagens (consistindo em varreduras de ressonância magnética das seções transversais do cérebro) e armazenará os nomes de cada arquivo de imagem na variável "Base" e exibirá cada uma das varreduras de ressonância magnética. Siga com o código na imagem, que faz o seguinte:

1. Crie um array de estrutura "BrainImages" que contém informações sobre todos os arquivos na pasta atual que se encaixam no formato de nome de MRI _ (). Png
2. Defina a variável "NumberofImages" igual ao número de elementos na estrutura da matriz "BrainImages"
3. Abra a janela da figura 1
4. Defina um loop for para percorrer o número de imagens contadas no arquivo
5. Para cada loop, "CurrentImage" é o respectivo nome de cada arquivo MRI_i.png, com o número da iteração como 'i'
6. Gere uma subtrama 3 x 7 para exibir as 19 imagens a serem carregadas por "imshow"
7. Exibir cada imagem como outro elemento na janela da subtrama
8. Dê um título a cada elemento do subplot como Level_, onde em branco é o número da iteração do loop for.
9. Fim do loop for (evitando erros)

Isso exibirá na janela da figura 1 todos os exames de ressonância magnética em formato bruto em uma configuração 3 x 7 sem lacunas na orientação x.

Etapa 16: O Código Principal: Preenchimento

Com o preenchimento, evitamos o problema de pequenas discrepâncias nos tamanhos da imagem que podem gerar erros de incompatibilidade de dimensão no caso de uma imagem ser ligeiramente maior que a outra.

1. Abra a janela da figura 2
2. Carregue a matriz de imagem de MRI_1-p.webp" />
3. Encontre o tamanho da matriz da imagem e defina como "OriginalXPixels" (para o número de linhas) e "OriginalYPixels" (para o número de colunas)
4. Configure a matriz "BrainMat" para consistir em todos os zeros com mais 20 linhas e mais 20 colunas para cada plano e 19 seções transversais totais, uma por plano.
5. Configure "HolesMat" para consistir na mesma matriz tridimensional de zeros para inserir as coordenadas do furo mais tarde
6. Crie "zeroMat" com o tamanho de um bloco mais vinte linhas e vinte colunas, uma matriz bidimensional de zeros.

Etapa 17: O Código Principal: Determinando Limites

1. Defina um loop for para percorrer os dados de cada imagem carregada anteriormente
2. Da mesma maneira do processamento em lote anterior, "CurrentImage" carrega arquivos com "MRI_i.png", onde i é o número da iteração
3. Execute cada imagem por meio da função de processamento "LevelCurveTracings2.m" que você criou anteriormente
4. Encontre o tamanho da saída "Brain", defina o número de linhas como "Currentrow" e o número de colunas como "Currentcolumns"
5. Defina "CurrentMat" para uma matriz de zeros com as dimensões especificadas por "Currentrow" e "Currentcolumns"
6. Centralize os dados de "Brain" em "CurrentMat", com uma margem de 10 linhas em todos os lados
7. Gere um subplot de dimensões 3 x 7, para exibir os limites das imagens
8. Dê um título a cada um dos elementos do subplot na janela da figura
9. Gerar matriz tridimensional "BrainMat" composta de cada camada de limites "CurrentMat"
10. Finalize o loop for (para evitar erros)

A subseção a seguir preenche os orifícios deixados na parte superior e inferior da forma tridimensional proposta

1. Defina "LevelCurve1" igual à primeira camada de "BrainMat" (parte inferior do sólido)
2. Defina "LevelCurveEnd" igual à camada final de "BrainMat" (topo do sólido)
3. Substitua "LevelCurve1" por uma camada preenchida
4. Substitua "LevelCurveEnd" por uma camada preenchida
5. Defina a camada preenchida como a camada inferior de "BrainMat"
6. Defina a camada preenchida como a camada superior de "BrainMat"

Etapa 18: O Código Principal: Determinando a Dimensão Z Adequada

As primeiras três linhas consistem em configurar um array vazio "z" e fazer operações de conversão simples (dividir os pixels pelo comprimento) para obter uma leitura adequada do volume em mm ^ 3

1. Crie um loop for para percorrer cada camada
2. Encontre o número de unidades em uma determinada camada
3. Converta as coordenadas z para aqueles em valores que são escalados para a proporção adequada, defina como "tempz", um vetor de coluna
4. Adicione o valor z para a curva de nível ao vetor z

Com isso, as coordenadas z são ajustadas corretamente.

Etapa 19: O Código Principal: Determinando as Coordenadas X e Y

Agora, para determinar as posições xey de cada um dos pontos nos limites.

1. Inicialize "xBrain" como uma matriz vazia
2. Inicialize "yBrain" como uma matriz vazia
3. Configure um loop for para percorrer cada imagem carregada
4. Compile uma matriz de duas colunas para armazenar as coordenadas planas de cada ponto no limite, representadas pelos vetores de coluna "RowBrain" e "ColumnBrain"
5. Anexe "xBrain" com as coordenadas "RowBrain" atualmente encontradas
6. Anexe "yBrain" com as coordenadas "ColumnBrain" atualmente encontradas
7. Finalize o loop for (para evitar erros)

Etapa 20: O código principal: traçando uma estrutura tridimensional, encontrando o volume e registrando os dados

Usando a função alphaShape, criaremos uma estrutura tridimensional a partir da qual podemos calcular o volume do cérebro.

1. Use a função alphaShape, insira os vetores "xBrain", "yBrain" e "z" para as coordenadas x, y e z e defina igual a "BrainPolyhedron"
2. Abra a janela da figura 3
3. Trace a forma alfa calculada "BrainPolyhedron", exibida na janela da figura
4. Calcule o volume da forma alfa, usando uma função "volume" que funciona para formas alfa
5. Converta o volume em mm ^ 3
6. Imprime o volume do sólido na janela de comando
7. Solicita que o nome de um paciente seja definido como uma entrada
8. Obtenha a data e a hora atuais com o relógio e defina como "Data e Hora"
9. Chame a função "patientFiles" para registrar e plotar os dados calculados

A partir daqui, a segunda e a terceira imagens devem mostrar as figuras que aparecem, e a quarta imagem aquela que deve ser exibida na janela de comando.