InglêsFrancêsEspanhol

Ad


favicon do OnWorks

minccalc - Online na nuvem

Execute o minccalc no provedor de hospedagem gratuita OnWorks no Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS

Este é o comando minccalc que pode ser executado no provedor de hospedagem gratuita OnWorks usando uma de nossas várias estações de trabalho online gratuitas, como Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS

PROGRAMA:

NOME


minccalc - executa operações matemáticas complexas em arquivos minc

SINOPSE


mincalc [ ] .mnc [ .mnc ...] .mnc

DESCRIÇÃO


Minccalc irá realizar operações matemáticas complexas de voxel por voxel, em um ou mais arquivos minc
da mesma forma e tendo a mesma amostragem de coordenadas, produzindo um único arquivo de saída.
As operações a serem realizadas são inseridas usando o -expressão argumento (ver EXPRESSÕES).
Por padrão, o arquivo de saída é o último argumento não opcional. No entanto, se o -arquivo de saída
opção for usada, então todos os argumentos não opcionais são considerados arquivos de entrada e a saída
os nomes dos arquivos vêm do -arquivo de saída opções, das quais pode haver mais de uma.

OPÇÕES


Observe que as opções podem ser especificadas de forma abreviada (desde que sejam exclusivas) e
pode ser fornecido em qualquer lugar na linha de comando.

-2 Crie arquivos de saída no formato MINC 2.0.

-Socorro Imprime o resumo das opções da linha de comando e sai.

-versão
Imprima o número da versão do programa e saia.

-espancar
Substitua um arquivo existente.

-noclobber
Não substitua um arquivo existente (padrão).

-no_clobber
Sinônimo de -noclobber.

-verboso
Imprima informações de progresso para cada bloco de dados copiado (padrão).

-quieto Não imprima informações de progresso.

-depurar Imprima informações de depuração.

-copy_header
Copia todas as informações do cabeçalho do primeiro arquivo de entrada (padrão para uma entrada
arquivo).

-nocopy_header
Não copie todo o cabeçalho do primeiro arquivo de entrada; copiar apenas coordenada
informações (padrão para mais de um arquivo de entrada).

-tipo de arquivo
Crie um arquivo de saída com o mesmo tipo do primeiro arquivo de entrada (padrão).

-byte Armazene voxels de saída em formato inteiro de 8 bits.

-baixo Armazene voxels de saída em formato inteiro de 16 bits.

-int Armazene voxels de saída em formato inteiro de 32 bits.

-longo Substituída por -int.

-flutuador Armazene voxels de saída em formato de ponto flutuante de 32 bits.

-Duplo
Armazene voxels de saída em formato de ponto flutuante de 64 bits.

-assinado
Use o formato inteiro com sinal e complemento de dois. Aplica-se apenas se o tipo de voxel de saída
é especificado para ser um tipo inteiro (um de -byte, -baixo, -int or -longo).

- sem assinatura
Use o formato de número inteiro sem sinal. Aplica-se apenas se o tipo de voxel de saída for especificado para
ser um tipo inteiro (um de -byte, -baixo, -int or -longo).

-alcance minutos max
Restrinja o intervalo válido de dados inteiros. Aplica-se apenas se um dos -byte,
-baixo, -int or -longo opções é especificado.

-max_buffer_size_in_kb tamanho
Especifique o tamanho máximo dos buffers internos (em kbytes). O padrão é 4096
(4MB).

-dimensão nome obscuro
Especifique uma dimensão ao longo da qual desejamos realizar uma operação cumulativa.

-check_dimensions
Verifique se todos os arquivos de entrada têm amostras correspondentes nas dimensões do mundo (padrão).

-nocheck_dimensions
Ignore quaisquer diferenças na amostragem de dimensões mundiais para arquivos de entrada.

-propagate_nan
Para operações vetoriais cumulativas (soma, estímulo e avg), dados inválidos (Not-A-Number
ou NaN) em qualquer elemento do vetor irá produzir dados inválidos no resultado
(predefinição).

-ignore_nan
Para operações vetoriais cumulativas, os dados inválidos (NaN) no vetor são ignorados, ou seja.
tratado como se não estivesse presente.

-na Quando uma operação ilegal é tentada em um voxel (como dividir por zero), o
o resultado são dados inválidos (NaN) (padrão). Não tendo dados de entrada válidos para um cumulativo
operação também é considerada uma operação ilegal quando -ignore_nan é usado.

-zero Quando uma operação ilegal é tentada em um voxel (como dividir por zero), o
o resultado é o valor zero.

-ilegal_value valor
Quando uma operação ilegal é tentada em um voxel (como dividir por zero), o
resultado é o valor especificado por esta opção.

-expressão corda
Especifique a expressão a ser avaliada em cada voxel (consulte EXPRESSÕES).

-expfile nome do arquivo
Especifique um arquivo contendo uma expressão para avaliar em cada voxel (ver
EXPRESSÕES). Se o nome do arquivo `` - '' for fornecido, então a expressão é lida de stdin.
A única diferença das expressões de linha de comando é que os comentários podem ser dados em
o arquivo. Uma linha de comentário é especificada colocando um `` # '' como o primeiro
caractere de espaço em branco da linha. Os scripts Minccalc podem ser criados configurando o
primeira linha para

#! / usr / local / mni / bin / minccalc -expfile

-arquivo de saída símbolo arquivo de saída
Especifique que a saída deve ser gravada no arquivo especificado, obtendo valores do
símbolo que deve ser criado na expressão (ver o EXEMPLOS seção). Se
esta opção é fornecida, então todos os argumentos não opcionais são tomados como arquivos de entrada. Esse
A opção pode ser usada várias vezes para vários arquivos de saída.

-eval_largura valor
Especifique o número de voxels a serem processados ​​em paralelo. O padrão é 200.

EXPRESSÕES


A -expressão argumento é uma única string que descreve a função a ser avaliada. o
a expressão da função é normalmente escrita em termos do vetor A.

Por exemplo, a seguinte expressão somará os dois primeiros arquivos de entrada juntos:

A [0] + A [1]

Várias expressões podem ser fornecidas separadas por ponto e vírgula, caso em que apenas o valor de
a última expressão é usada. Estas listas de expressão podem ser usadas com atribuição
expressões para tornar a sintaxe muito semelhante a C:

proporção = A [0] / A [1]; A [2] * exp (-ratio)

Uma lista de expressões entre colchetes é uma expressão válida e retorna o valor do último
expressão na lista. Isso é particularmente útil em para e if expressões (veja abaixo).

Existem dois tipos de valores na linguagem: vetores e escalares. Literais escalares são
números de ponto flutuante ou podem aparecer como símbolos cujo nome começa com uma letra minúscula.

Além de operadores escalares normais, como +, -, * e /, a linguagem da expressão também
suporta o operador de exponenciação infixo ^, os operadores relacionais usuais <, <=,>,
> =, ==,! = bem como os operadores booleanos && (e), || (ou e ! (não). Observe que o
&& e || Operadores booleanos sempre avaliam ambos os operandos, ao contrário de C. Matemática escalar
funções incluem abs, sqrt, exp, log, sem, carrinho, bronzeado, asin, acos e um bronzeado. Há também
algumas funções especializadas:

isnan (v) - 1 se v for inválido e 0 caso contrário
grampo (v1, v2, v3) - v1 limitado por [v2, v3]
segmento (v1, v2, v3) - testa se v1 está em [v2, v3]

A constante escalar NaN é definida de forma que isnan (NaN) retorne 1.

Os vetores podem ser escritos na seguinte forma `extensional '

[valor1, valor2, ...]

ou usando as seguintes notações geradoras de alcance:

[a: b] gera {a, a + 1, ..., b-1, b}
[a: b) gera {a, a + 1, ..., b-1}
(a: b] gera {a + 1, ..., b-1, b}
(a: b) gera {a + 1, ..., b-1}

ou ser gerado, por 'intensão'. A seguinte expressão de intensão gera o vetor
{3,2,1}:

{i em [1: 3] | 4 - eu}

Os vetores também podem aparecer como símbolos cujo nome começa com uma letra maiúscula.

Além dos operadores escalares, os seguintes operadores vetoriais são fornecidos:

avg - o valor médio dos escalares no vetor
len - o comprimento de
sum - a soma dos elementos de
prod - o produto dos elementos de
max - o valor máximo de
min - o valor mínimo de
imax - o índice do valor máximo de
imin - o índice do valor mínimo de
V [s] - o s'ésimo elemento do vetor V com origem 0.

Os nomes dos símbolos são introduzidos em uma tabela de símbolos global por expressões de atribuição do
formulário

a = A [2] * log(2)

Os símbolos que começam com uma letra minúscula representam escalares, enquanto aqueles que começam com um
letras maiúsculas representam vetores. Visto que = é um operador, seu resultado pode ser usado em um
expressão (como em C).

Algumas construções de controle são fornecidas:

Os loops For podem ser criados para percorrer um vetor, atribuindo cada valor a um símbolo e, em seguida,
avaliar uma expressão. Isso é feito com expressões do formulário

total = 0; para {i em [0: len (A))} total = total + A [i]; total

que é equivalente à soma (A). Observe que isso é semelhante a usar

total = 0; len {i in [0: len (A)) | total = total + A [i]}; total

uma vez que o para construção é na verdade um operador (embora geralmente seja usado apenas para
alterar os valores dos símbolos). Observe também que sem o "total" final, a expressão seria
não seria muito útil, pois retornaria apenas o comprimento do vetor.

Como em C, uma lista de expressões pode ser especificada em curvas:

total = total2 = 0;
para {i em [0: len (A))} {
total = total + A [i];
total2 = total2 + A [i] ^ 2
}

Existem também algumas formas de se-então-senão construir:

A [0] <0? 0: A [0]

if (A [0] <0) resultado = 0 else resultado = A [0]

A outro é opcional. Novamente, a construção if é um operador, e o então or outro
expressões podem ser listas de expressões em curvas, caso em que o valor do último
expressão é retornada. Se o outro expressão está faltando, então o valor 0 é retornado
quando a expressão de teste é 0 (falso).

A principal excentricidade com o para e if constrói é que, ao contrário das instruções C, eles devem
ser separado da próxima expressão por um ponto e vírgula, mesmo quando uma lista de expressões em
curlies é usado:

para i em [0: len (A)) {total = total + A [i]}; total / len (A)
if (A [i]> 0) {resultado = 2;} else {resultado = 1}; resultado * 5

Uma maneira alternativa de introduzir nomes de símbolo é por meio deixar-expressões. Por exemplo, o
a seguinte expressão sempre será avaliada como 3:

deixe a = 1, b = 2 em a + b

Eles foram originalmente projetados para criar variáveis ​​apenas dentro da expressão avaliada,
mas foram feitas modificações para que a tabela de símbolos global seja alterada.

EXEMPLOS


Aqui está uma expressão para calcular o desvio padrão, levando em consideração o
possibilidade de dados de entrada inválidos, que são ignorados:

s0 = s1 = s2 = 0;

para {i em [0: len (A))} {
v = A [i];
if (! isnan (v)) {
s0 = s0 + 1;
s1 = s1 + v;
s2 = s2 + v * v;
}
};

if (s0> 1) {
sqrt ((s2 - s1 * s1 / s0) / (s0-1));
}
else {
NaN;
};

O último if poderia ser alterado para retornar 0 se s0 for> 0, mas <= 1. Também eliminamos o encaracolado
colchetes, mas não deve haver um ";" entre o if e o else

if (s0> 1)
sqrt ((s2 - s1 * s1 / s0) / (s0-1))
else if (s0> 0)
0
outro
NaN

Se quisermos a média e o desvio padrão, podemos usar o -arquivo de saída opção,
invocando o comando com

minccalc -expfile stdev\
-outfile significa média.mnc \
-outfile stdev stdev.mnc\
arquivo1.mnc arquivo2.mnc ...

E usando o arquivo de expressão (com outra forma de expressão if):

s0 = s1 = s2 = 0;

para {i em [0: len (A))} {
v = A [i];
if (! isnan (v)) {
s0 = s0 + 1;
s1 = s1 + v;
s2 = s2 + v * v;
}
};

stdev = (s0> 1)? sqrt ((s2 - s1 * s1 / s0) / (s0-1)):
(s0> 0)? 0: NaN;
média = (s0> 0)? s1 / s0: NaN;

RESSALVAS


Algumas coisas que você deve lembrar ...

Variáveis ​​de vetor devem começar com uma letra maiúscula.

Os nomes das variáveis ​​vetoriais não devem ser uma das palavras-chave da função,
soma, len, prod, ... etc

For loops e expressões if sempre precisam ser separadas da próxima expressão por um
ponto e vírgula.

A tabela de símbolos é global.

Operadores booleanos && e || sempre avalie ambos os operandos.

Uma nota sobre paralelismo: por razões de eficiência, as avaliações são feitas em muitos voxels de uma vez
(o número de voxels é referido como a largura da avaliação e é alterado com
do -eval_largura opção). Uma consequência estranha disso é que ambos os lados de um if-else
declaração são sempre avaliadas (a menos que todos os voxels forneçam o mesmo resultado de teste), mas
declarações dentro de cada conseqüente são avaliadas apenas nos voxels apropriados. No
Em particular, as entradas na tabela de símbolos são modificadas apenas de acordo com uma máscara de voxel. UMA
O efeito colateral disso é que qualquer símbolo vetorial definido em um consequente if-else não deve mudar
o comprimento do símbolo (embora possa criá-lo) e ambos os lados do consequente devem
concordar sobre o comprimento de quaisquer símbolos de vetor que ambos modifiquem. Se isso não estiver claro,
apenas experimente - o programa reclamará se não estiver satisfeito.

Use minccalc online usando serviços onworks.net


Servidores e estações de trabalho gratuitos

Baixar aplicativos Windows e Linux

Comandos Linux

Ad