Low level functions for IO on .mnc and .xfm files

minc2_check( ex )

Macro to verify the return code

_hdr_convert!(hdr::MincHeader,dd)::MincHeader

internal function

attributes(h::VolumeHandle, g::String)

List attributes defined inside given group

close_minc_file(h::VolumeHandle)

Close currently open minc file, commit data on disk

copy_minc_metadata(i::VolumeHandle, o::VolumeHandle)

Copy metadata from one file to another

create_header_from_v2w(
    sz, t::AffineTransform{T};
    vector_dim::Bool=false, 
    time_step::Union{Float64,Nothing}=nothing,
    time_start::Union{Float64,Nothing}=nothing)::MincHeader

Internal: Generate header from the voxel to world transform and volume size

create_minc_file(h::VolumeHandle, path::AbstractString)

Create empty minc file on disk, structure need to be defined in advance

define_minc_file(hdr::MincHeader,::Type{Store}=Float32,::Type{Repr}=Store)

Define new minc file structure, return handle

empty_like_minc_volume_raw( h::VolumeHandle,
    ::Type{T}=Float32 )::Tuple{Array{T}, Minc2.MincHeader}

Allocate empty volume using handle return volume, storage header

empty_like_minc_volume_raw(path::String, ::Type{T}=Float32 )::
        Tuple{Array{T}, Minc2.MincHeader}

Create empty volume similar to existing file return volume, representation header,storage header

empty_like_minc_volume_std(h::VolumeHandle, 
    ::Type{T}=Float32 )::Tuple{Array{T}, Minc2.MincHeader, Minc2.MincHeader}

Read the actual volume using handle return volume, representation header,storage header

empty_like_minc_volume_std(path::String, 
    ::Type{T}=Float32 )::Tuple{Array{T}, Minc2.MincHeader, Minc2.MincHeader}

allocate empty volume using path as a reference return volume, representation header,storage header

empty_like_minc_volume_std_history(path::String, ::Type{T}=Float32 )

allocate empty volume using path return volume, representation header,storage header

get_attribute(h::VolumeHandle,g::String,a::String; default=missing)

Convenience function for reading specific attribute, return default value if not found also convert Array into the first value if it's a one-length array

groups(h::VolumeHandle)

List groups defined in minc2 file

Internal function that makes sure types are compatible

Internal function that makes shure types are compatible

Internal function that makes shure types are compatible

ndim(h::VolumeHandle)::Int

Query number of dimensions in the minc file

open_minc_file(fname::String)::VolumeHandle

Open minc file, return handle

read_attribute(h::VolumeHandle, 
    group::String,
    attribute::String)::Union{String, AbstractVector, Nothing}

Read minc2 header attribute :param group: attribute group name :param attribute: attribute name :return:

read_history(i::VolumeHandle)::Union{String, Nothing}

Return history string

read_minc_volume_raw(h::VolumeHandle, 
    ::Type{T}=Float32 )::Tuple{Array{T}, Minc2.MincHeader}

Read the actual volume using handle return volume, storage header

read_minc_volume_raw(path::String, ::Type{T}=Float32 )::
    Tuple{Array{T}, Minc2.MincHeader}

Read the actual volume using path return volume, representation header,storage header

read_minc_volume_raw_history(path::String, ::Type{T}=Float32 )

Read the actual volume using path return volume, representation header,storage header

read_minc_volume_std(h::VolumeHandle, 
    ::Type{T}=Float32 )::Tuple{Array{T}, Minc2.MincHeader, Minc2.MincHeader}

Read the actual volume using handle return volume, representation header,storage header

read_minc_volume_std(path::String, ::Type{T}=Float32 )::
    Tuple{Array{T}, Minc2.MincHeader, Minc2.MincHeader}

Read the actual volume using path return volume, representation header,storage header

read_minc_volume_std_history(path::String, ::Type{T}=Float32 )::
    Tuple{Array{T}, Minc2.MincHeader, Minc2.MincHeader, Union{String,Nothing}}

Read the actual volume using path return volume, representation header,storage header

representation_header(h::VolumeHandle)::MincHeader

Return volume representation header

store_type(h::VolumeHandle)::Type

Query representation data type of the minc file, WARNING: it doesn't nacessery mean that it's the same as store_type type

setup_standard_order(h::VolumeHandle)

Prepare to read volume in standard order: [V,X,Y,Z,TIME]

store_header(h::VolumeHandle)::MincHeader

Return volume on-disk stucture header

store_type(h::VolumeHandle)::Type

Query storage data type of the minc file, WARNING: it doesn't nacessery mean that it's the same as representation type

voxel_to_world(hdr::MincHeader)::AffineTransform{Float64}

Give AffineTransform for world to voxel transformation based on header

voxel_to_world(h::VolumeHandle,ijk::Vector{Float64})::Vector{Float64}

Convert contignuous 0-based voxel indexes (I,J,K) to world coordinates (X,Y,Z) 0-based

world_to_voxel(hdr::MincHeader)::AffineTransform{Float64}

Give AffineTransform for voxel to world transformation

world_to_voxel(h::VolumeHandle, xyz::Vector{Float64})::Vector{Float64}

Convert world coordinates (X,Y,Z) to contignuous voxel indexes (I,J,K) 0-based

write_attribute(h::VolumeHandle, group::String, attribute::String, value::T)

Store attribute into minc2 file :param group: group name :param attribute: attribute name :param value: attribute value :return:

write_history(i::VolumeHandle, history::String)

Write history string

write_minc_volume_raw(path::String, ::Type{Store}, 
    store_hdr::Union{MincHeader, Nothing}, 
    volume::Array{Repr};like::Union{String, Nothing}=nothing, 
    history::Union{String, Nothing}=nothing )

Write full volume to file, need to provide details of file structure return nothing

write_minc_volume_raw(h::VolumeHandle, volume::Array{T} )

write full volume to file, file should be defined and created return nothing

write_minc_volume_std(path::String, ::Type{Store}, 
    store_hdr::Union{MincHeader, Nothing}, 
    volume::Array{Repr};like::Union{String, Nothing}=nothing, 
    history::Union{String, Nothing}=nothing )

Write full volume to file, need to provide details of file structure return nothing

write_minc_volume_std(h::VolumeHandle, volume::Array{T} )

write full volume to file, file should be defined and created return nothing

Low Level: Axis types from MINC volume

MINC io exception

MincHeader

Structure describing spatial orientation and sampling of the minc file

Low Level: minc2_simple API status

VolumeHandle

minc2_simple volume handle

Low Level: map Julia types to minc2 data types

Low Level: Mapping MINC2 spatial dimensions to proper spatial dimension (should be identity for spatial dims)

Low Level: map MINC2 types to Julia

append_grid_transform(h::TransformHandle, grid_file::String; inv::Bool=false)

Low level: Append grid transform to an open transformation handle

append_linear_transform(h::TransformHandle, lin::AffineTransform)

Low level: Append affine transform to an open transformation handle

concat_xfm(h::TransformHandle, i::TransformHandle)

Low level: concatenate two transfomations

get_grid_transform(h::TransformHandle; n::Int64=0)

Low level: extract reference to a grid file from open handle

get_linear_transform(h::TransformHandle; n::Int64=0)::AffineTransform{Float64}

Low level: extract AffineTransform{Float64} from open handle

get_linear_transform_param(h::TransformHandle;n::Int64=0,center::Union{Nothing,Vector{Float64}}=nothing)

Low level: extact transformation parameters from affine transform , returns named tuple with fields center, translations, scales, shears, rotations

get_n_concat(h::TransformHandle)::Int64

Low level: Get number of transformations in open handle

get_n_type(h::TransformHandle; n::Int64=0)::XFM

Low level: Get transform type for nth transform in open handle

inverse_transform_point(h::TransformHandle, xyz::Vector{Float64})::Vector{Float64}

Low level: Inverse transform point xyz using minc transform h

invert_transform(h::TransformHandle)

Low level: Invert minc transform h

load_transforms(h::TransformHandle)::Vector{AnyTransform}

Low level: Load all transforms from open .XFM handle

load_transforms(fname::String)::Vector{AnyTransform}

Load transformations from .xfm file fname

Low level: Open transform xfm file, return handle

read_transforms(fname::String)::Vector{AnyTransform}

Read transformations from .xfm file fname

save_transforms(fname::String, 
    xfm::Union{Vector{XFM}, XFM};
    grid_store::Type{T}=Float32 ) where {T, XFM<:AnyTransform}

Save transformations into .xfm file,

Arguments

• fname: output file name
• xfm: vector of transformations to save, or a single transformation
• grid_store: type of storage for grid files (default: Float32)

save_xfm_file(h::TransformHandle, path::String)

Low level: Save information into file from an open handle

transform_point(h::TransformHandle, xyz::Vector{Float64})::Vector{Float64}

Low level: Transform point xyz using minc transform h

Low level: minc2_simple XFM transform handle

@enum XFM

Low level: transformation types stored in .xfm file