function test_suite = test_fmri_dataset()
% tests for cosmo_fmri_dataset
%
% #   For CoSMoMVPA's copyright information and license terms,   #
% #   see the COPYING file distributed with CoSMoMVPA.           #
    try % assignment of 'localfunctions' is necessary in Matlab >= 2016
        test_functions=localfunctions();
    catch % no problem; early Matlab versions can use initTestSuite fine
    end
    initTestSuite;


function test_base_fmri_dataset()
    ds=get_base_dataset();
    assert_dataset_equal(ds, get_expected_dataset());

function test_afni_fmri_dataset()
    if cosmo_skip_test_if_no_external('afni')
        return;
    end

    ds=get_base_dataset();
    afni=cosmo_map2fmri(ds,'-afni');
    afni_expected=get_expected_afni();

    assertAlmostEqualWithTol(afni.img, afni_expected.img);
    afni_no_img=rmfield(afni,'img');
    afni_expected_no_img=rmfield(afni_expected,'img');
    assertEqual(afni_no_img,afni_expected_no_img);

    ds_afni=cosmo_fmri_dataset(afni);
    assert_dataset_equal(ds,ds_afni);

function test_nii_sform_fmri_dataset()
    ds=get_base_dataset();
    nii=cosmo_map2fmri(ds,'-nii');
    nii_expected=get_expected_nii_sform();
    assertEqual(nii.hdr, nii_expected.hdr);
    assertAlmostEqualWithTol(nii.img,nii_expected.img);
    ds_nii=cosmo_fmri_dataset(nii);
    assert_dataset_equal(ds,ds_nii);

function test_nii_qform_fmri_dataset()
    ds=get_base_dataset();
    nii=get_expected_nii_qform();
    ds_nii=cosmo_fmri_dataset(nii);
    assert_dataset_equal(ds,ds_nii);

    % check qform with illegal pixdims
    nii.hdr.dime.pixdim(1:4)=-1;
    nii.hdr.hist.quatern_b=1;
    nii.hdr.hist.quatern_c=0;
    nii.hdr.hist.quatern_d=0;

    ds_nii_alt=cosmo_fmri_dataset(nii);
    m=ds_nii_alt.a.vol.mat;
    assertEqual(diag(m),[1 -1 1 1]');
    assertEqual(m(1:3,4),[-2 0 -2]');


function test_nii_pixdim_fmri_dataset()
    ds=get_base_dataset();
    nii=get_expected_nii_pixdim();
    ds_nii=cosmo_fmri_dataset(nii);
    ds_nii.a.vol.mat(:,4)=ds.a.vol.mat(:,4);
    assert_dataset_equal(ds,ds_nii);

    nii.hdr.dime.scl_inter=200;
    nii.hdr.dime.scl_slope=17;

    ds_nii_scl=cosmo_fmri_dataset(nii);
    assertElementsAlmostEqual(17*ds.samples+200,ds_nii_scl.samples,...
                                    'absolute',1e-3);


function test_nii_sform_afni_5d_singleton_dataset()
    ds=get_base_dataset();
    nii=get_expected_nii_sform();

    % header: move 4th to 5th dimension
    nii.hdr.dime.dim(6)=nii.hdr.dime.dim(5);
    nii.hdr.dime.dim(5)=1;

    % data: move 4th to 5th dimension
    orig_size=size(nii.img);
    nii.img=reshape(nii.img,[orig_size(1:3) 1 orig_size(4)]);

    % test this test: verify size is ok
    assertEqual(nii.hdr.dime.dim(2:6),size(nii.img));

    ds_nii=cosmo_fmri_dataset(nii);
    assert_dataset_equal(ds,ds_nii);

function test_nii_sform_afni_5d_nonsingleton_dataset()
    ds=get_base_dataset();
    nii=get_expected_nii_sform();

    % header: add extra dimension
    nrep=ceil(rand()*3+2);
    nii.hdr.dime.dim(6)=nrep;

    % data: move 4th to 5th dimension
    img_rep=repmat({nii.img},1,nrep);
    nii.img=cat(5,img_rep{:});

    % test this test: verify size is ok
    assertEqual(nii.hdr.dime.dim(2:6),size(nii.img));

    % must not support this
    assertExceptionThrown(@()cosmo_fmri_dataset(nii),'');


function test_nii_sform_and_qform_fmri_dataset()
    ds=get_base_dataset();
    nii=get_expected_nii_sform_and_qform();
    ds_nii=cosmo_fmri_dataset(nii);
    assert_dataset_equal(ds,ds_nii);

    nii.hdr.hist.srow_x(1)=1;
    assertExceptionThrown(@()cosmo_fmri_dataset(nii),'');
    ds_nii_qform=cosmo_fmri_dataset(nii,'nifti_form','qform');
    assertEqual(ds_nii_qform,ds_nii);
    assertExceptionThrown(@()cosmo_fmri_dataset(nii,'nifti_form','X'),'');


function test_bv_vmr_fmri_dataset()
    if ~can_test_bv()
        return
    end
    uint_ds=get_uint8_dataset();
    bv_vmr=cosmo_map2fmri(uint_ds,'-bv_vmr');

    cleaner=onCleanup(@()bv_vmr.ClearObject());
    neuroelf_bless_wrapper(bv_vmr);

    assert_bv_equal(bv_vmr, get_expected_bv_vmr());
    ds_bv_vmr=cosmo_fmri_dataset(bv_vmr,'mask',false);
    ds_bv_vmr_lpi=cosmo_fmri_reorient(ds_bv_vmr,'LPI');
    assert_dataset_equal(uint_ds,ds_bv_vmr_lpi,'rotation');


function test_bv_vmp_fmri_dataset()
    if ~can_test_bv()
        return
    end

    ds=get_base_dataset();
    bv_vmp=cosmo_map2fmri(ds,'-bv_vmp');

    cleaner=onCleanup(@()bv_vmp.ClearObject());
    neuroelf_bless_wrapper(bv_vmp);

    assert_bv_equal(bv_vmp, get_expected_bv_vmp());
    ds_bv_vmp=cosmo_fmri_dataset(bv_vmp);
    ds_bv_vmp_lpi=cosmo_fmri_reorient(ds_bv_vmp,'LPI');
    assert_dataset_equal(ds,ds_bv_vmp_lpi,'translation');


function test_bv_msk_fmri_dataset()
    if ~can_test_bv()
        return
    end

    uint_ds=get_uint8_dataset();
    bv_msk=cosmo_map2fmri(uint_ds,'-bv_msk');

    cleaner=onCleanup(@()bv_msk.ClearObject());
    neuroelf_bless_wrapper(bv_msk);

    assert_bv_equal(bv_msk, get_expected_bv_msk());

    ds_bv_msk=cosmo_fmri_dataset(bv_msk,'mask',false);
    ds_bv_msk_lpi=cosmo_fmri_reorient(ds_bv_msk,'LPI');
    assert_dataset_equal(uint_ds,ds_bv_msk_lpi,'translation');


function test_bv_vtc_fmri_dataset()
    if ~can_test_bv()
        return
    end

    ds=get_base_dataset();
    ds.samples=round(ds.samples);
    ds.samples(ds.samples<0)=0;

    xff_bv_vtc=get_expected_xff_bv_vtc();
    cleaner=onCleanup(@()xff_bv_vtc.ClearObject());
    neuroelf_bless_wrapper(xff_bv_vtc);

    ds_bv_vtc=cosmo_fmri_dataset(xff_bv_vtc);
    ds_bv_glm_lpi=cosmo_fmri_reorient(ds_bv_vtc,'LPI');

    assert_dataset_equal(ds,ds_bv_glm_lpi,'translation');


function test_bv_glm_subject_fmri_dataset()
    if ~can_test_bv()
        return
    end

    % no support for map2fmri, so just test with neuroelf struct
    ds=get_base_dataset();

    xff_bv_glm=get_expected_xff_bv_glm();
    cleaner=onCleanup(@()xff_bv_glm.ClearObject());
    neuroelf_bless_wrapper(xff_bv_glm);

    ds_bv_glm=cosmo_fmri_dataset(xff_bv_glm);
    ds_bv_glm_lpi=cosmo_fmri_reorient(ds_bv_glm,'LPI');

    assert_dataset_equal(ds,ds_bv_glm_lpi,'translation');


function test_mask_fmri_dataset()
    aet=@(varargin)assertExceptionThrown(@()...
                        cosmo_fmri_dataset(varargin{:}),'');
    ds=cosmo_synthetic_dataset();
    ds.samples(:,[2 6])=0;

    x=cosmo_fmri_dataset(ds,'mask','-auto');
    assertEqual(x,cosmo_slice(ds,[1 3 4 5],2));
    x1=cosmo_fmri_dataset(ds,'mask',true);
    assertEqual(x1,x);
    x2=cosmo_fmri_dataset(ds,'mask',false);
    assertEqual(x2,ds);


    aet(ds,'mask','foo');
    aet(ds,'mask','-foo');
    aet(ds,'mask',ds);
    aet(ds,'mask',struct);

    ds.samples(1,2)=1;
    aet(ds,'mask','-auto');

    x3=cosmo_fmri_dataset(ds,'mask','-any');
    assertEqual(x3,x);

    x4=cosmo_fmri_dataset(ds,'mask','-all');
    assertEqual(x4,cosmo_slice(ds,[1 2 3 4 5],2));

    msk_ds=cosmo_slice(cosmo_slice(x,randperm(size(x.samples,2)),2),1);
    x5=cosmo_fmri_dataset(ds,'mask',msk_ds);
    assertEqual(x5,x);


function test_pymvpa_fmri_dataset()
    pymvpa_ds=get_pymvpa_dataset();
    ds=cosmo_fmri_dataset(pymvpa_ds);
    assert_dataset_equal(ds, get_expected_dataset(), 'translation');


function test_pymvpa_3d_string_array()
    py_ds=get_pymvpa_dataset();

    sa_labels={'foo';'bar'};
    sa_labels_3d=reshape(strvcat(sa_labels),[2 1 3]);
    py_ds.sa.labels=sa_labels_3d;

    fa_labels={'foox','barx','foobazx','1','2','3'};
    fa_labels_3d=reshape(strvcat(fa_labels),[1 6 7]);
    py_ds.fa.labels=fa_labels_3d;

    ds=cosmo_fmri_dataset(py_ds);
    assertEqual(ds.sa.labels,sa_labels);
    assertEqual(ds.fa.labels,fa_labels);


function test_meeg_source_fmri_dataset()
    ds=cosmo_synthetic_dataset('type','source');
    res=cosmo_fmri_dataset(ds);
    assertEqual(ds.samples,res.samples);
    assertEqual(diag(res.a.vol.mat),[10 10 10 1]');

function test_set_sa_fmri_dataset()
    ds=cosmo_synthetic_dataset();
    res=cosmo_fmri_dataset(ds,'targets',1:6,'chunks',3);
    assertEqual(res.sa.targets,(1:6)');
    assertEqual(res.sa.chunks,ones(6,1)*3);

    assertExceptionThrown(@()cosmo_fmri_dataset(ds,'targets',[1 2]),'');

function test_nan_warning_fmri_dataset()
    ds=cosmo_synthetic_dataset();
    ds.samples(1)=NaN;
    msk_ds=cosmo_slice(ds,2);

    orig_warning_state=cosmo_warning();
    warning_state_resetter=onCleanup(@()cosmo_warning(orig_warning_state));
    cosmo_warning('off');

    cosmo_fmri_dataset(ds,'mask',msk_ds);
    warning_state=cosmo_warning();

    warning_pos=strmatch('The input dataset has NaN',...
                    warning_state.shown_warnings);
    assert(~isempty(warning_pos));


function tf=can_test_bv()
    tf=~cosmo_skip_test_if_no_external('neuroelf');

function ds=get_base_dataset()
    ds=cosmo_synthetic_dataset('ntargets',2,'nchunks',1);

function ds=get_uint8_dataset()
    ds=cosmo_synthetic_dataset('ntargets',2,'nchunks',1);
    ds=cosmo_slice(ds,1);
    mn=min(ds.samples);
    mx=max(ds.samples);
    ds.samples=uint8((ds.samples-mn)/(mx-mn)*255);

function ds=get_pymvpa_dataset()
    ds=cosmo_synthetic_dataset('ntargets',2,'nchunks',1);

    % set .a
    ds.a.imgaffine=ds.a.vol.mat;
    ds.a.imgaffine(1:3,4)=ds.a.imgaffine(1:3,4)+...
                        ds.a.imgaffine(1:3,1:3)*ones(3,1);
    ds.a.voxel_eldim=single([3 3]);
    ds.a.voxel_dim=int64(ds.a.vol.dim(:));
    ds.a=rmfield(ds.a,'vol');
    ds.a=rmfield(ds.a,'fdim');

    % set .fa
    voxel_indices=int64([ds.fa.i; ds.fa.j; ds.fa.k]-1);
    ds.fa=struct();
    ds.fa.voxel_indices=voxel_indices;

    % set .samples
    ds.samples=single(ds.samples);



function assertAlmostEqualWithTol(x,y)
    assertElementsAlmostEqual(double(x),double(y),'relative',1e-3);


function assert_dataset_equal(x,y,opt)
    if nargin<3 || isempty(opt)
        opt='';
    end
    % dataset equality, without .sa
    assertAlmostEqualWithTol(x.samples, y.samples);
    assertEqual(x.fa, y.fa)

    switch opt
        case 'rotation'
            % BV VMR cannot store orientation, just check the rotation part
            assertEqual(x.a.fdim, y.a.fdim);
            assertAlmostEqualWithTol(x.a.vol.dim,y.a.vol.dim);
            assertAlmostEqualWithTol(x.a.vol.mat(1:3,1:3),...
                            y.a.vol.mat(1:3,1:3));
        case 'translation'
            % BV VMP or PyMVPA cannot store xform, just check the matrix
            assertEqual(x.a.fdim, y.a.fdim);
            assertAlmostEqualWithTol(x.a.vol.dim,y.a.vol.dim);
            assertAlmostEqualWithTol(x.a.vol.mat,y.a.vol.mat);
        otherwise
            assertEqual(x.a, y.a)
    end


function assert_bv_equal(x_xff, y_struct)
    % BV equality; first argument is xff class, second argument a struct
    % passes if all fields in y_struct have the same value in x_xff;
    % x_xff can have more fields than y_struct
    keys=fieldnames(y_struct);
    for k=1:numel(keys)
        key=keys{k};
        y=y_struct.(key);
        x=x_xff.(key);
        if isstruct(x)
            for j=1:numel(x)
                assert_bv_equal(x(j),y(j))
            end
        else
            assertAlmostEqualWithTol(x,y);
        end

    end

function xff_bv_glm=get_expected_xff_bv_glm()
    xff_bv_glm=xff('new:glm');
    xff_bv_glm.NrOfSubjects=1;
    xff_bv_glm.NrOfPredictors=2;
    xff_bv_glm.Predictor=struct('Name1',{'1','2'},...
                                'Name2',{'1','2'},...
                                'RGB',{[255 0 0] [0 255 0]});
    xff_bv_glm.Resolution=2;
    xff_bv_glm.XStart = 127;
    xff_bv_glm.XEnd = 131;
    xff_bv_glm.YStart = 129;
    xff_bv_glm.YEnd = 131;
    xff_bv_glm.ZStart = 125;
    xff_bv_glm.ZEnd = 131;

    data=zeros(2,1,3,2);
    data_size=size(data);
    mat_size=data_size(1:3);
    data(:,:,:,1)=reshape([ -0.2040   -1.0504   -0.2617 ...
                            -3.6849    1.3494    2.0317], mat_size);
    data(:,:,:,2)=reshape([0.4823 -1.3265 2.3387 ...
                            1.7235 -0.3973 0.5838], mat_size);
    xff_bv_glm.GLMData.BetaMaps=data;

function xff_bv_vtc=get_expected_xff_bv_vtc()
    xff_bv_vtc=xff('new:vtc');
    xff_bv_vtc.NrOfVolumes=2;

    xff_bv_vtc.Resolution=2;
    xff_bv_vtc.XStart = 127;
    xff_bv_vtc.XEnd = 131;
    xff_bv_vtc.YStart = 129;
    xff_bv_vtc.YEnd = 131;
    xff_bv_vtc.ZStart = 125;
    xff_bv_vtc.ZEnd = 131;

    data_orig=zeros(2,1,3,2);
    data_size=size(data_orig);
    mat_size=data_size(1:3);
    data_orig(:,:,:,1)=reshape([ -0.2040   -1.0504   -0.2617 ...
                            -3.6849    1.3494    2.0317], mat_size);
    data_orig(:,:,:,2)=reshape([0.4823 -1.3265 2.3387 ...
                            1.7235 -0.3973 0.5838], mat_size);

    data=uint16(data_orig);
    xff_bv_vtc.VTCData=zeros(2,2,1,3,'uint16');
    xff_bv_vtc.VTCData(1,:,:,:)=data(:,:,:,1);
    xff_bv_vtc.VTCData(2,:,:,:)=data(:,:,:,2);


function bv_msk=get_expected_bv_msk()
    bv_msk=struct();
    bv_msk.Resolution= 2 ;
    bv_msk.XStart = 127;
    bv_msk.XEnd = 131;
    bv_msk.YStart = 129;
    bv_msk.YEnd = 131;
    bv_msk.ZStart = 125;
    bv_msk.ZEnd = 131;

    data=zeros(2,1,3,'uint8');
    data(:,:,1) = [ 155 118 ];
    data(:,:,2) = [ 153 0 ];
    data(:,:,3) = [ 225 255 ];
    bv_msk.Mask=data;

function bv_vmp=get_expected_bv_vmp()
    bv_vmp=struct();
    bv_vmp.NrOfMaps = 2;
    bv_vmp.OverallMapType = 1;
    bv_vmp.OverallNrOfLags = [];
    bv_vmp.NrOfTimePoints = 0;
    bv_vmp.NrOfMapParameters = 0;
    bv_vmp.ShowParamsRangeFrom = 0;
    bv_vmp.ShowParamsRangeTo = 0;
    bv_vmp.FingerprintParamsRangeFrom = 0;
    bv_vmp.FingerprintParamsRangeTo = 0;
    bv_vmp.Resolution = 2;
    bv_vmp.XStart = 127;
    bv_vmp.XEnd = 131;
    bv_vmp.YStart = 129;
    bv_vmp.YEnd = 131;
    bv_vmp.ZStart = 125;
    bv_vmp.ZEnd = 131;

    map1.VMPData=reshape([-0.2040   -1.0504   -0.2617   ...
                            -3.6849    1.3494    2.0317],[2 1 3]);
    map2.VMPData=reshape([0.4823 -1.3265 2.3387 ...
                            1.7235 -0.3973 0.5838],[2 1 3]);
    bv_vmp.Map=cat(1,map1,map2);

function bv_vmr=get_expected_bv_vmr()

    bv_vmr=struct();
    bv_vmr.FileVersion = 3;
    bv_vmr.DimX = 2;
    bv_vmr.DimY = 1;
    bv_vmr.DimZ = 3;
    bv_vmr.VMRData16 = [];
    bv_vmr.OffsetX = 0;
    bv_vmr.OffsetY = 0;
    bv_vmr.OffsetZ = 0;
    bv_vmr.FramingCube = 256;
    bv_vmr.PosInfoVerified = false;
    bv_vmr.RowDirX = 0;
    bv_vmr.RowDirY = 1;
    bv_vmr.RowDirZ = 0;
    bv_vmr.ColDirX = 0;
    bv_vmr.ColDirY = 0;
    bv_vmr.ColDirZ = -1;
    bv_vmr.NRows = 256;
    bv_vmr.NCols = 256;
    bv_vmr.FoVRows = 256;
    bv_vmr.FoVCols = 256;
    bv_vmr.SliceThickness = 1;
    bv_vmr.GapThickness = 0;
    bv_vmr.ReferenceSpace = 0;
    bv_vmr.VoxResX = 2;
    bv_vmr.VoxResY = 2;
    bv_vmr.VoxResZ = 2;
    bv_vmr.VoxResInTalairach = false;
    bv_vmr.VoxResVerified = false;

    data=zeros(2,1,3,'uint8');
    data(:,:,1) = [ 155 118 ];
    data(:,:,2) = [ 153 0 ];
    data(:,:,3) = [ 225 255 ];
    bv_vmr.VMRData=data;



function afni=get_expected_afni()

    % header
    afni=struct();
    afni.SCENE_DATA = [ 0 11 1 ];
    afni.TYPESTRING = '3DIM_HEAD_FUNC' ;
    afni.BRICK_TYPES = [ 3 3 ];
    afni.BRICK_STATS = [];
    afni.BRICK_FLOAT_FACS = [ ];
    afni.DATASET_RANK = [ 3 2 ];
    afni.DATASET_DIMENSIONS = [ 3 2 1 ];
    afni.ORIENT_SPECIFIC = [ 1 2 4 ];
    afni.DELTA = [ -2 -2 2 ];
    afni.ORIGIN = [ 1 1 -1 ];
    afni.SCALE = 0;
    afni.BRICK_LABS = [];
    afni.BRICK_KEYWORDS = [];
    afni.BRICK_STATAUX = [];
    afni.STAT_AUX = [];
    afni.SCALE=0;
    afni.NOTES_COUNT=0;
    afni.WARP_TYPE=[0 0];
    afni.FileFormat='BRIK';
    [unused, unused, endian_ness] = computer();
    afni.BYTEORDER_STRING = sprintf('%sSB_FIRST',endian_ness );

    % data
    data=zeros(3,2,1,2);
    data(:,:,1,1)=[ 2.0317    1.3494;-3.6849   -0.2617;-1.0504   -0.2040];
    data(:,:,1,2)=[ 0.5838   -0.3973; 1.7235    2.3387;-1.3265    0.4823];

    % add to image
    afni.img=data;

function ds=get_expected_dataset()
    ds=struct();
    ds.samples=[ 2.0317   -3.6849   -1.0504    1.3494   -0.2617   -0.2040;
                 0.5838    1.7235   -1.3265   -0.3973    2.3387    0.4823];
    ds.fa.i=[1 2 3 1 2 3];
    ds.fa.j=[1 1 1 2 2 2];
    ds.fa.k=[1 1 1 1 1 1];
    ds.a.fdim.labels={'i';'j';'k'};
    ds.a.fdim.values={[1 2 3];[1 2];1};
    mat=diag([2 2 2 1]);
    mat(1:3,4)=-3;
    ds.a.vol.mat=mat;
    ds.a.vol.dim=[3 2 1];
    ds.a.vol.xform='scanner_anat';


function nii=get_expected_nii_pixdim()
    nii=get_expected_nii_helper();
    fields_to_clear={'quatern_b','quatern_c','quatern_d',...
                        'qoffset_x','qoffset_y','qoffset_z',...
                        'srow_x','srow_y','srow_z'};
    nii.hdr.hist=clear_fields(nii.hdr.hist,fields_to_clear);

function nii=get_expected_nii_sform_and_qform()
    nii=get_expected_nii_helper();
    nii.hdr.hist.sform_code = 1;
    nii.hdr.hist.qform_code = 1;

function nii=get_expected_nii_sform()
    nii=get_expected_nii_helper();
    nii.hdr.hist.sform_code = 1;

    fields_to_clear={'quatern_b','quatern_c','quatern_d',...
                        'qoffset_x','qoffset_y','qoffset_z'};
    nii.hdr.hist=clear_fields(nii.hdr.hist,fields_to_clear);

function nii=get_expected_nii_qform()
    nii=get_expected_nii_helper();
    nii.hdr.hist.qform_code = 1;

    fields_to_clear={'srow_x','srow_y','srow_z'};
    nii.hdr.hist=clear_fields(nii.hdr.hist,fields_to_clear);

function nii=get_expected_nii_helper()
    hdr=struct();
    hdr.dime.datatype = 16;
    hdr.dime.dim = [ 4 3 2 1 2 1 1 1 ];
    hdr.dime.pixdim = [ 0 2 2 2 0 0 0 0 ];
    hdr.dime.intent_p1 = 0;
    hdr.dime.intent_p2 = 0;
    hdr.dime.intent_p3 = 0;
    hdr.dime.intent_code = 0;
    hdr.dime.slice_start = 0;
    hdr.dime.slice_duration = 0;
    hdr.dime.slice_end = 0;
    hdr.dime.scl_slope = 0;
    hdr.dime.scl_inter = 0;
    hdr.dime.slice_code = 0;
    hdr.dime.cal_max = 0;
    hdr.dime.cal_min = 0;
    hdr.dime.toffset = 0;
    hdr.dime.xyzt_units = 10;
    hdr.hk.sizeof_hdr = 348;
    hdr.hk.data_type='';
    hdr.hk.db_name='';
    hdr.hk.extents = 0;
    hdr.hk.session_error = 0;
    hdr.hk.regular='r';
    hdr.hk.dim_info = 0;

    hdr.hist.descrip='';
    hdr.hist.aux_file='';
    hdr.hist.intent_name='';
    hdr.hist.srow_x = [ 2 0 0 -1 ];
    hdr.hist.srow_y = [ 0 2 0 -1 ];
    hdr.hist.srow_z = [ 0 0 2 -1 ];
    hdr.hist.quatern_c = 0;
    hdr.hist.originator = [ 2 1 1 1 ];

    hdr.hist.sform_code = 0;
    hdr.hist.qform_code = 0;

    % set up qform
    m=[hdr.hist.srow_x;hdr.hist.srow_y;hdr.hist.srow_z];
    quatern_a=.5*sqrt(1+m(1,1)+m(2,2)+m(3,3));
    hdr.hist.quatern_b = .25*(m(3,2)-m(2,3)) / quatern_a;
    hdr.hist.quatern_c = .25*(m(1,3)-m(3,1)) / quatern_a;
    hdr.hist.quatern_d = .25*(m(2,1)-m(1,2)) / quatern_a;

    hdr.hist.qoffset_x = m(1,4);
    hdr.hist.qoffset_y = m(2,4);
    hdr.hist.qoffset_z = m(3,4);

    data=zeros(3,2,1,2);
    data(:,:,1,1)=[ 2.0317  1.3494; -3.6849 -0.2617; -1.0504   -0.2040];
    data(:,:,1,2)=[ 0.5838 -0.3973;  1.7235  2.3387; -1.3265    0.4823];

    nii=struct();
    nii.hdr=hdr;
    nii.img=single(data);

function s=clear_fields(s,keys)
    n=numel(keys);
    for k=1:n
        key=keys{k};
        v=s.(key);
        v(:)=0;
        s.(key)=v;
    end

function result=neuroelf_bless_wrapper(arg)
    % deals with recent neuroelf (>v1.1), where bless is deprecated
    s=warning('off','neuroelf:xff:deprecated');
    resetter=onCleanup(@()warning(s));

    result=bless(arg);

