MSI >> MATLAB

MSI to MATLAB conversion does not have to be a pain, it could be fun :)
First, one would create pdf object:

>>pdf = pdf4D(<filename>);

where <filename> is full path to the pdf (processed data file).

To get pdf header information all you have to do is

>>hdr = get(pdf, 'header');

or simply

>>hdr = pdf.header;

Since pdf object will also read config and hs_file from the same directory, you could get information from those file in similar way by using get or subsref methods.

Some methods of the pdf object:

+ get method

>>get(pdf);
    ver | version : pdf4D object version
    pdffound | filefound : true | false
    configfound : true | false
    hsfound | headshapefound : true | false
    pdfname | filename : full pdf filename
    configname : full config filename
    hsname | headshapename : full headshape filename
    id | ids : id structure
    patient | patientid : patient id
    scan | scanid : scan id
    session | sessionid : session id
    run | runid : run id
    pdf | pdfid : pdf id
    header : pdf header (structure)
    config : config info (structure)
    hs | headeshape : head shape info (structure)
    hsindex : index points from hs_file (structure)
    hspoint | hspoints : head shape points from hs_file
    df | dataformat : data format (string)
    sp | sampleperiod : sample period [sec]
    dr | digitizationrate : digitization rate [Hz]

>>hdr = get(pdf, 'header')

hdr = 

     header_data: [1x1 struct]
      epoch_data: {[1x1 struct]}
    channel_data: {1x276 cell}
      event_data: {[1x1 struct]}

>>cnf = get(pdf, 'config')

cnf = 

        config_data: [1x1 struct]
                Xfm: [4x4 double]
    user_block_data: {1x14 cell}
       channel_data: {1x387 cell}

>>hs = get(pdf, 'hs')

hs = 

      hdr: [1x1 struct]
    index: [1x1 struct]
    point: [3x2264 double]

>>get(pdf, 'dataformat')

ans =

float

+ subsref method

>>hdr = pdf.header

hdr = 

     header_data: [1x1 struct]
      epoch_data: {[1x1 struct]}
    channel_data: {1x248 cell}
      event_data: {[1x1 struct]}

>>cnf = pdf.config

cnf = 

        config_data: [1x1 struct]
                Xfm: [4x4 double]
    user_block_data: {1x14 cell}
       channel_data: {1x387 cell}

>>hs = pdf.hs

hs = 

      hdr: [1x1 struct]
    index: [1x1 struct]
    point: [3x2264 double]

+ set method

You could attach header, config or hs structures to the pdf object. That would make get calls faster.

>>set(pdf, 'header', hdr);

>>set(pdf, 'config', cnf);

>>set(pdf, 'hs', hs);

+ subsasgn method

Same as set, but different syntax

>>pdf.header = hdr;

>>pdf.config = cnf;

>>pdf.hs = hs;

+ sysconf method

If you need information from system config file, you could use sysconf method.

>>sys = pdf; % create copy of the pdf object

>>sys.config = sysconf(sys, <filename>); %file name could be absolute name or (if you run MSI) just "DAP name"

After that you could for example get position for the meg channels before transformation (see channel_position method)

+ channel_index method

You could get channel indexes sorted by channel name or channel label.
Channel type could be defined as 'meg', 'eeg' ..

>>chi = channel_index(pdf, 'meg', 'name');
>>whos chi

  Name      Size                    Bytes  Class

  chi       1x248                     496  uint16 array

Grand total is 248 elements using 496 bytes

or as cell array of names or labels:

>>chi = channel_index(pdf, {'TRIGGER' 'A1'}, 'name');
>>whos chi

  Name       Size                    Bytes  Class

  chi       1x1                         2  uint16 array

Grand total is 1 element using 2 bytes

+ channel_name method

>>chn = channel_name(pdf, chi);
>>whos chn

  Name      Size                    Bytes  Class

  chn       1x248                   16648  cell array

Grand total is 1132 elements using 16648 bytes

>>chn(1:10)

ans = 

    'A1'    'A2'    'A3'    'A4'    'A5'    'A6'    'A7'    'A8'    'A9'    'A10'

+ channel_label method

>>chl = channel_label(pdf, chi);
>>whos chl

  Name      Size                    Bytes  Class

  chn       1x248                   16648  cell array

Grand total is 1132 elements using 16648 bytes

>>chl(1:10)

ans = 

    'A1'    'A2'    'A3'    'A4'    'A5'    'A6'    'A7'    'A8'    'A9'    'A10'

+ channel_type method

>>cht = channel_type(pdf, chi);
>>whos cht

  Name      Size                    Bytes  Class

  chn       1x248                   16648  cell array

Grand total is 1132 elements using 16648 bytes

>>cht(1)

ans = 

    'meg'

+ channel_position method

>>chp = channel_position(pdf, chi);
>>whos chp

  Name      Size                    Bytes  Class

  chp       1x248                   53696  struct array

Grand total is 3472 elements using 53696 bytes

>>chp(1)

ans = 

     position: [3x2 double]
    direction: [3x2 double]

>>chp(1).position

ans =

    0.0373    0.0529
    0.0042    0.0057
    0.1506    0.1981

>>chp(1).direction

ans =

    0.3123   -0.3123
    0.0300   -0.0300
    0.9495   -0.9495

+ lat2ind method

Convert epoch number and latencies into data indexes:

>>lat = lat2ind(pdf, 4, [0 .2])

lat =

   136   271

Second argument is epoch number. Third argument is max and min latency [sec].

+ read_data_block method

With channel and latency indexes extracted we ready to read data:

>>data = read_data_block(pdf, lat, chi);

>>whos data

  Name       Size                    Bytes  Class

  data     248x136                  134912  single array

Grand total is 33728 elements using 134912 bytes

+ get_posted_data method

If you run MSI and MATLAB on the same computer (sorry for Windows users :() you could create pdf object for the posted pdf(s):

>>filename = get_posted_data(pdf4D) 

filename = 

    [1x74 char]

>>filename{1}

ans =

/home/whsbti/data/debian_data0/0823/DR_AMtag2/07%14%06@13:42/1/c,rfhp0.1Hz

>>pdf = pdf4D(get_posted_data(pdf4D))

ans = 

    Patient: '0823'
       Scan: 'DR_AMtag2'
    Session: '07/14/06 13:42'
        Run: '1'
        PDF: 'c,rfhp0.1Hz'

+ write_pdf method

If you have not too large piece of data (as result of some sort of processing) you could create new pdf by using write_pdf method:

>> write_pdf(pdf, data, pdf_id, chan_label, dr, trig)

where
data - channel by latency matrix
pdf_id - filename for the new pdf (the rest of ids taken from the pdf object)
chan_label - cell array of channel names (you could output of the channel_label method)
dr - digitization rate [Hz]
trig - trigger onset [sec]

This method creates temporary text file and then calls asc_to_pdf program.
For the huge data matrices we recommend to use duplicate duplicate and write_data_block methods.

+ duplicate method

As the first step to write large piece of data you could duplicate current pdf and the replace data with write_data_block method

>> new_pdf = duplicate(pdf, pdf_id);

where
pdf_id - filename for the new pdf (the rest of ids taken from the obj)
new_pdf - pdf4D object for the new pdf

+ write_data_block method

As the second step to write large piece of data you could use write_data_block method:

>>write_data_block(pdf, data, lat);

where
data - is channel by latency matrix
lat - first latency index, default is 1

+ simu method

To simulate data for the moving dipole you could use simu method:

>> [b, chl] = simu(pdf, r, q, ctr);

where
r - 3 by nt (number of time points) array of dipole position [cm]
q - 3 by nt array of dipole strength [nAm]
ctr - 3 by 1 vector of sphere center [cm]
b - nch (number of channels) by nt magnetic field matrix
chl - cell array of labels for meg channels

To get sphere center from hs_file for the current pdf you could use s_fit method.

+ s_fit method

To get sphere center from hs_file for the current pdf you could use s_fit method:

>> [ctr,r]=s_fit(pdf);

where
ctr - 3 by 1 - center of the sphere [cm]
r - radius of the sphere [cm]

+ dsel method

dsel (for Data Selector) is graphical interface to MSI data. You could select and sort data using regular expressions and apply you own tools to process selected data.

And here is the link to the zip file: pdf4D.zip

Copyleft (GPLv2) 2006, ude.revnedcu|grebnork.enegue#ude.revnedcu|grebnork.enegue