private void loadDSL()
{
OpenFileDialog fo = new OpenFileDialog();
fo.Filter = "MATLAB file (*.mat)|*.mat";
if (fo.ShowDialog() == DialogResult.OK)
{
matfile = fo.FileName;
try
{
MatFileReader r = new MatFileReader(fo.FileName);
Dictionary <string, MLArray> content = r.Content;
if (content["DSL"] is MLStructure)
{
MLStructure matStr = (MLStructure)content["DSL"];
for (int i = 0; i < matStr.N; i++)
{
//MLDouble attack = (MLDouble)matStr["attack\0",i];
MLDouble attack = (MLDouble)matStr["@", i];
//MLDouble attack = (MLDouble)matStr["", 0];
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error reading .MAT file" + ex, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show("You did not select a file! Using current parameter values", "No selection", MessageBoxButtons.OK, MessageBoxIcon.Information);
Filename = "";
}
toolStripStatusLabel1.Text = "Loaded DSL prescription " + Filename;
}
private static nirs.core.Probe loadSDprobe(string file)
{
MatFileReader mfr = new MatFileReader(file);
double[][] lambda2;
MLStructure SD = (mfr.Content["SD"] as MLStructure);
MLDouble MLlambda = null;
if (SD.Keys.Contains("Lambda"))
{
MLlambda = (SD["Lambda"] as MLDouble);
}
else if (SD.Keys.Contains("lambda"))
{
MLlambda = (SD["lambda"] as MLDouble);
}
lambda2 = MLlambda.GetArray();
int[] lambda = new int[lambda2[0].Length];
for (int i = 0; i < lambda2[0].Length; i++)
{
lambda[i] = (int)lambda2[0][i];
}
return(loadSDprobe(file, lambda));
}
static MLArray CreateStructArray()
{
var structure = new MLStructure("X", new[] { 1, 1 });
structure["w", 0] = new MLUInt8("", new byte[] { 1 }, 1);
structure["y", 0] = new MLUInt8("", new byte[] { 2 }, 1);
structure["z", 0] = new MLUInt8("", new byte[] { 3 }, 1);
return(structure);
}
//public void CreateCSVFile(DataTable dt, string strFilePath)
//{
// #region Export Grid to CSV
// // Create the CSV file to which grid data will be exported.
// StreamWriter sw = new StreamWriter(strFilePath, false);
// // First we will write the headers.
// //DataTable dt = m_dsProducts.Tables[0];
// int iColCount = dt.Columns.Count;
// for (int i = 0; i < iColCount; i++)
// {
// sw.Write(dt.Columns[i]);
// if (i < iColCount - 1)
// {
// sw.Write(",");
// }
// }
// sw.Write(sw.NewLine);
// // Now write all the rows.
// foreach (DataRow dr in dt.Rows)
// {
// for (int i = 0; i < iColCount; i++)
// {
// if (!Convert.IsDBNull(dr[i]))
// {
// sw.Write(dr[i].ToString());
// }
// if (i < iColCount - 1)
// {
// sw.Write(",");
// }
// }
// sw.Write(sw.NewLine);
// }
// sw.Close();
// #endregion
//}
private MLArray createStruct()
{
MLStructure outStruct = new MLStructure("kinectData", new int[] { 1, 1 });
//string[] headers = {"HipCenterX", "HipCenterY", "HipCenterZ", "SpineX", "SpineY", "SpineZ", "ShoulderCenterX",
// "ShoulderCenterY", "ShoulderCenterZ", "HeadX", "HeadY", "HeadZ", "ShoulderLeftX",
// "ShoulderLeftY", "ShoulderLeftZ", "ElbowLeftX", "ElbowLeftY", "ElbowLeftZ", "WristLeftX",
// "WristLeftY", "WristLeftZ", "HandLeftX", "HandLeftY", "HandLeftZ", "ShoulderRightX",
// "ShoulderRightY", "ShoulderRightZ", "ElbowRightX", "ElbowRightY", "ElbowRightZ",
// "WristRightX", "WristRightY", "WristRightZ", "HandRightX", "HandRightY", "HandRightZ",
// "HipLeftX", "HipLeftY", "HipLeftZ", "KneeLeftX", "KneeLeftY", "KneeLeftZ", "AnkleLeftX",
// "AnkleLeftY", "AnkleLeftZ", "FootLeftX", "FootLeftY", "FootLeftZ", "HipRightX", "HipRightY",
// "HipRightZ", "KneeRightX", "KneeRightY", "KneeRightZ", "AnkleRightX", "AnkleRightY",
// "AnkleRightZ", "FootRightX", "FootRightY", "FootRightZ"};
double criticalC1D = Convert.ToDouble(criticalC1);
double criticalC2D = Convert.ToDouble(criticalC2);
double criticalC3D = Convert.ToDouble(criticalC3);
double criticalC11D = Convert.ToDouble(criticalC11);
double criticalC21D = Convert.ToDouble(criticalC21);
double criticalC31D = Convert.ToDouble(criticalC31);
double criticalC12D = Convert.ToDouble(criticalC12);
double criticalC22D = Convert.ToDouble(criticalC22);
double criticalC32D = Convert.ToDouble(criticalC32);
double criticalC13D = Convert.ToDouble(criticalC13);
double criticalC23D = Convert.ToDouble(criticalC23);
double criticalC33D = Convert.ToDouble(criticalC33);
double criticalC14D = Convert.ToDouble(criticalC14);
double criticalC24D = Convert.ToDouble(criticalC24);
double criticalC34D = Convert.ToDouble(criticalC34);
double[] ccArray = { criticalC1D, criticalC2D, criticalC3D, criticalC11D, criticalC21D, criticalC31D, criticalC12D, criticalC22D, criticalC32D,
criticalC13D, criticalC23D, criticalC33D, criticalC14D, criticalC24D, criticalC34D };
Double[] skelDataA = (Double[])skelData.ToArray(typeof(double));
Double[] gpVectorA = (Double[])gpVector.ToArray(typeof(double));
Double[] kinectTiltA = (Double[])kinectTilt.ToArray(typeof(double));
outStruct["skelData", 0] = new MLDouble("", skelDataA, 60);
outStruct["dateHeader", 0] = new MLChar("", timeStamp);
outStruct["criticalComps", 0] = new MLDouble("", ccArray, 3);
outStruct["exercise", 0] = new MLChar("", exercise);
MLStructure groundStruct = new MLStructure("", new int[] { 1, 1 });
groundStruct["height", 0] = new MLDouble("", new double[] { 0.68 }, 1); // metres?
groundStruct["gpVector", 0] = new MLDouble("", gpVectorA, 4); //metres?
groundStruct["kinectTilt", 0] = new MLDouble("", kinectTiltA, 1); //degrees
outStruct["groundPlaneData", 0] = groundStruct;
return(outStruct);
}
internal void saveAsMAT()
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "MAT files (*.mat)|*.mat|All files (*.*)|*.*";
saveFileDialog.DefaultExt = "mat";
saveFileDialog.InitialDirectory = Properties.Settings.Default.saveImpedanceDirectory;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
string filename = saveFileDialog.FileName;
string tmpinfo = new FileInfo(filename).DirectoryName;
Properties.Settings.Default.saveImpedanceDirectory = tmpinfo;
List <MLArray> mlList = new List <MLArray>();
MLStructure structure = new MLStructure("imp", new int[] { 1, 1 });
structure["f", 0] = new MLDouble("", freqs, freqs.Length);
//Only add non-null (sampled) channels
int numNonNull = 0;
List <int> goodChannels = new List <int>();
for (int i = 0; i < impedance.Length; ++i)
{
if (impedance[i] != null)
{
++numNonNull;
goodChannels.Add(i);
}
}
double[][] nonNullImpedance = new double[numNonNull][];
for (int i = 0; i < numNonNull; ++i)
{
nonNullImpedance[i] = impedance[goodChannels[i]];
}
structure["z", 0] = new MLDouble("", nonNullImpedance);
mlList.Add(structure);
try
{
MatFileWriter mfw = new MatFileWriter(filename, mlList, true);
}
catch (Exception err)
{
MessageBox.Show("There was an error when creating the MAT-file: \n" + err.ToString(),
"MAT-File Creation Error!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
private static MLArray CreateTestStruct()
{
MLStructure outStruct = new MLStructure("kinectData", new int[] { 1, 1 });
double[] myRealNums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
// new MLInt64("IA", myRealNums, myImagNums, length);
// IA: matlab Name (blank for struct)
// realNumbers => Double array of the real parts
// imagNumbers => Double array of the img parts
// length => dimension of the matrix
outStruct["skelData", 0] = new MLDouble("", myRealNums, 2);
outStruct["dateHeader", 0] = new MLChar("", "January 29th... etc...");
MLStructure groundStruct = new MLStructure("", new int[] { 1, 1 });
groundStruct["height", 0] = new MLDouble("", new double[] { 0.68 }, 1); // metres?
groundStruct["gpVector", 0] = new MLDouble("", new double[] { 1.4, 1, 1, 1 }, 4); //metres?
groundStruct["kinectTilt", 0] = new MLInt16("", new Int16[] { -15 }, 1); //degrees
outStruct["groundPlaneData", 0] = groundStruct;
return(outStruct);
}
/// <summary>
/// Reads <c>miMATRIX</c> from the input stream.
/// </summary>
/// <remarks>
/// If reading was not finished (which is normal for filtered results)
/// returns <c>null</c>.
/// </remarks>
/// <param name="buf">The <c>BinaryReader</c> input stream.</param>
/// <param name="isRoot">When <c>true</c> informs that if this is a top level
/// matrix.</param>
/// <returns><c>MLArray</c> or <c>null</c> if matrix does not match <c>filter</c></returns>
private MLArray ReadMatrix(Stream buf, bool isRoot)
{
// result
MLArray mlArray = null;
ISMatTag tag;
// read flags
int[] flags = ReadFlags(buf);
int attributes = (flags.Length != 0) ? flags[0] : 0;
int nzmax = (flags.Length != 0) ? flags[1] : 0;
int type = attributes & 0xff;
// read Array dimension
int[] dims = ReadDimension(buf);
// read Array name
string name = ReadName(buf);
// If this array is filtered out return immediately
if (isRoot && !_filter.Matches(name))
{
return(null);
}
// read data
switch (type)
{
case MLArray.mxSTRUCT_CLASS:
MLStructure mlStruct = new MLStructure(name, dims, type, attributes);
BinaryReader br = new BinaryReader(buf);
// field name length - this subelement always uses the compressed data element format
tag = new ISMatTag(br.BaseStream);
int maxlen = br.ReadInt32();
// Read fields data as Int8
tag = new ISMatTag(br.BaseStream);
// calculate number of fields
int numOfFields = tag.Size / maxlen;
// padding after field names
int padding = (tag.Size % 8) != 0 ? 8 - tag.Size % 8 : 0;
string[] fieldNames = new string[numOfFields];
for (int i = 0; i < numOfFields; i++)
{
byte[] names = new byte[maxlen];
br.Read(names, 0, names.Length);
fieldNames[i] = ZeroEndByteArrayToString(names);
}
br.ReadBytes(padding);
// read fields
for (int index = 0; index < mlStruct.M * mlStruct.N; index++)
{
for (int i = 0; i < numOfFields; i++)
{
// read matrix recursively
tag = new ISMatTag(br.BaseStream);
if (tag.Size > 0)
{
MLArray fieldValue = ReadMatrix(br.BaseStream, false);
mlStruct[fieldNames[i], index] = fieldValue;
}
else
{
mlStruct[fieldNames[i], index] = new MLEmptyArray();
}
}
}
mlArray = mlStruct;
//br.Close();
break;
case MLArray.mxCELL_CLASS:
MLCell cell = new MLCell(name, dims, type, attributes);
for (int i = 0; i < cell.M * cell.N; i++)
{
tag = new ISMatTag(buf);
if (tag.Size > 0)
{
MLArray cellmatrix = ReadMatrix(buf, false);
cell[i] = cellmatrix;
}
else
{
cell[i] = new MLEmptyArray();
}
}
mlArray = cell;
break;
case MLArray.mxDOUBLE_CLASS:
mlArray = new MLDouble(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <double>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <double>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxSINGLE_CLASS:
mlArray = new MLSingle(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <float>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <float>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxUINT8_CLASS:
mlArray = new MLUInt8(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <byte>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <byte>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxINT8_CLASS:
mlArray = new MLInt8(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <sbyte>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <sbyte>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxUINT16_CLASS:
mlArray = new MLUInt16(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <ushort>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <ushort>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxINT16_CLASS:
mlArray = new MLInt16(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <short>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <short>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxUINT32_CLASS:
mlArray = new MLUInt32(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <uint>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <uint>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxINT32_CLASS:
mlArray = new MLInt32(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <int>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <int>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxUINT64_CLASS:
mlArray = new MLUInt64(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <ulong>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <ulong>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxINT64_CLASS:
mlArray = new MLInt64(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <long>)mlArray).RealByteBuffer,
(IByteStorageSupport)mlArray);
// read complex
if (mlArray.IsComplex)
{
tag = new ISMatTag(buf);
tag.ReadToByteBuffer(((MLNumericArray <long>)mlArray).ImaginaryByteBuffer,
(IByteStorageSupport)mlArray);
}
break;
case MLArray.mxCHAR_CLASS:
MLChar mlchar = new MLChar(name, dims, type, attributes);
//read real
tag = new ISMatTag(buf);
char[] ac = tag.ReadToCharArray();
for (int i = 0; i < ac.Length; i++)
{
mlchar.SetChar(ac[i], i);
}
mlArray = mlchar;
break;
case MLArray.mxSPARSE_CLASS:
MLSparse sparse = new MLSparse(name, dims, attributes, nzmax);
// read ir (row indices)
tag = new ISMatTag(buf);
int[] ir = tag.ReadToIntArray();
// read jc (column indices)
tag = new ISMatTag(buf);
int[] jc = tag.ReadToIntArray();
// read pr (real part)
tag = new ISMatTag(buf);
double[] ad1 = tag.ReadToDoubleArray();
int n = 0;
for (int i = 0; i < ir.Length; i++)
{
if (i < sparse.N)
{
n = jc[i];
}
sparse.SetReal(ad1[i], ir[i], n);
}
//read pi (imaginary part)
if (sparse.IsComplex)
{
tag = new ISMatTag(buf);
double[] ad2 = tag.ReadToDoubleArray();
int n1 = 0;
for (int i = 0; i < ir.Length; i++)
{
if (i < sparse.N)
{
n1 = jc[i];
}
sparse.SetImaginary(ad2[i], ir[i], n1);
}
}
mlArray = sparse;
break;
default:
throw new MatlabIOException("Incorrect Matlab array class: " + MLArray.TypeToString(type));
}
return(mlArray);
}
{ // methods devoted to file I/O
/// <subjid>.wl1 - wavelength #1 data
/// <subjid>.wl2 - wavelength #2 data
/// <subjid>_config.txt - config file
/// <subjid>.evt - stimulus events(data taken from config file)
/// <subjid>_probeInfo.mat - probe file
/// <subjid>.tpl -topology file(data taken from config file)
///
public static core.Data readNIRx(string filename)
{
core.Data data = new core.Data();
filename = filename.Substring(0, filename.IndexOf(".wl1", StringComparison.Ordinal));
// Read the header file
List <string> hdrFields = new List <string>();
List <string> hdrValues = new List <string>();
string line;
System.IO.StreamReader file = new System.IO.StreamReader(filename + ".hdr");
while ((line = file.ReadLine()) != null)
{
if (line.Contains("="))
{
int found = line.IndexOf("=", StringComparison.Ordinal);
hdrFields.Add(line.Substring(0, found));
string value = line.Substring(found + 1);
if (value.Contains("#"))
{
value = "";
while ((line = file.ReadLine()) != null)
{
if (line.Contains("#"))
{
break;
}
value = value + "\r" + line;
}
}
if (value.Contains("\""))
{
value = value.Substring(1, value.Length - 2);
}
hdrValues.Add(value);
}
}
file.Close();
string targetDirectory = Path.GetDirectoryName(filename + ".hdr");
string[] fileEntries = Directory.GetFiles(targetDirectory);
string probeFile = Path.Combine(targetDirectory, "Standard_probeInfo.mat");
foreach (string i in fileEntries)
{
if (i.Contains("probeInfo.mat"))
{
probeFile = Path.Combine(targetDirectory, i);
break;
}
}
// Now, read the Probe_info.mat file
MatFileReader mfr = new MatFileReader(probeFile);
MLStructure probeInfo = (mfr.Content["probeInfo"] as MLStructure);
MLStructure probes = (probeInfo["probes"] as MLStructure);
MLDouble coords_s2 = (probes["coords_s2"] as MLDouble);
MLDouble coords_d2 = (probes["coords_d2"] as MLDouble);
MLDouble coords_c2 = (probes["coords_c2"] as MLDouble);
double[][] srcpos = coords_s2.GetArray();
double[][] detpos = coords_d2.GetArray();
double[][] landpos = coords_c2.GetArray();
// TODO read all the 3D stuff too
MLDouble coords_s3 = (probes["coords_s3"] as MLDouble);
MLDouble coords_d3 = (probes["coords_d3"] as MLDouble);
MLDouble coords_c3 = (probes["coords_c3"] as MLDouble);
double[][] srcpos3D = coords_s3.GetArray();
double[][] detpos3D = coords_d3.GetArray();
double[][] landpos3D = coords_c3.GetArray();
data.probe.numSrc = srcpos.Length;
data.probe.numDet = detpos.Length;
data.probe.DetPos = new double[detpos.Length, 3];
data.probe.DetectorLabels = new string[detpos.Length];
for (int i = 0; i < detpos.Length; i++)
{
data.probe.DetPos[i, 0] = (float)detpos[i][0];
data.probe.DetPos[i, 1] = (float)detpos[i][1];
data.probe.DetPos[i, 2] = 0;
data.probe.DetectorLabels[i] = string.Format("Detector-{0}", i + 1);
}
data.probe.SrcPos = new double[srcpos.Length, 3];
data.probe.SourceLabels = new string[srcpos.Length];
for (int i = 0; i < srcpos.Length; i++)
{
data.probe.SrcPos[i, 0] = (float)srcpos[i][0];
data.probe.SrcPos[i, 1] = (float)srcpos[i][1];
data.probe.SrcPos[i, 2] = 0;
data.probe.SourceLabels[i] = string.Format("Source-{0}", i + 1);
}
data.probe.LandmarkPos = new double[landpos.Length, 3];
data.probe.LandmarkLabels = new string[landpos.Length];
for (int i = 0; i < landpos.Length; i++)
{
data.probe.LandmarkPos[i, 0] = (float)landpos[i][0];
data.probe.LandmarkPos[i, 1] = (float)landpos[i][1];
data.probe.LandmarkPos[i, 2] = 0;
data.probe.LandmarkLabels[i] = string.Format("Landmark(temp)-{0}", i + 1);
}
data.probe.DetPos3D = new double[detpos3D.Length, 3];
for (int i = 0; i < detpos3D.Length; i++)
{
data.probe.DetPos3D[i, 0] = (double)detpos3D[i][0];
data.probe.DetPos3D[i, 1] = (double)detpos3D[i][1];
data.probe.DetPos3D[i, 2] = (double)detpos3D[i][1];
}
data.probe.SrcPos3D = new double[srcpos3D.Length, 3];
for (int i = 0; i < srcpos3D.Length; i++)
{
data.probe.SrcPos3D[i, 0] = (double)srcpos3D[i][0];
data.probe.SrcPos3D[i, 1] = (double)srcpos3D[i][1];
data.probe.SrcPos3D[i, 2] = (double)srcpos3D[i][2];
}
data.probe.LandmarkPos3D = new double[landpos.Length, 3];
for (int i = 0; i < landpos.Length; i++)
{
data.probe.LandmarkPos3D[i, 0] = (float)landpos3D[i][0];
data.probe.LandmarkPos3D[i, 1] = (float)landpos3D[i][1];
data.probe.LandmarkPos3D[i, 2] = (float)landpos3D[i][2];
}
data.probe.isregistered = true;
int LambdaIdx = hdrFields.IndexOf("Wavelengths");
string[] lam = hdrValues[LambdaIdx].Split('\t');
double[] lambda = new double[lam.Length];
for (int i = 0; i < lam.Length; i++)
{
lambda[i] = Convert.ToDouble(lam[i]);
}
int SDmaskIdx = hdrFields.IndexOf("S-D-Mask");
string[] mask = hdrValues[SDmaskIdx].Split('\r');
bool[,] SDMask = new bool[data.probe.numSrc, data.probe.numDet];
for (int i = 1; i < data.probe.numSrc + 1; i++)
{
string[] mask2 = mask[i].Split('\t');
for (int j = 0; j < data.probe.numDet; j++)
{
SDMask[i - 1, j] = false;
if (mask2[j].Contains("1"))
{
SDMask[i - 1, j] = true;
}
}
}
int cnt = 0;
for (int i = 0; i < SDMask.GetLength(0); i++)
{
for (int j = 0; j < SDMask.GetLength(1); j++)
{
if (SDMask[i, j])
{
cnt++;
}
}
}
data.probe.ChannelMap = new ChannelMap[cnt * lambda.Length];
cnt = 0;
List <int> ChanIdx = new List <int>();
int cnt2 = 0;
for (int w = 0; w < lambda.Length; w++)
{
for (int i = 0; i < SDMask.GetLength(0); i++)
{
for (int j = 0; j < SDMask.GetLength(1); j++)
{
if (SDMask[i, j])
{
data.probe.ChannelMap[cnt] = new ChannelMap();
data.probe.ChannelMap[cnt].sourceindex = i;
data.probe.ChannelMap[cnt].detectorindex = j;
data.probe.ChannelMap[cnt].channelname = String.Format("Src{0}-Det{1}",
data.probe.ChannelMap[cnt].sourceindex + 1,
data.probe.ChannelMap[cnt].detectorindex + 1);
data.probe.ChannelMap[cnt].wavelength = lambda[w];
data.probe.ChannelMap[cnt].datasubtype = String.Format("{0}nm", data.probe.ChannelMap[cnt].wavelength);
cnt++;
if (w == 0)
{
ChanIdx.Add(cnt2);
}
}
cnt2++;
}
}
}
data.probe.numChannels = data.probe.ChannelMap.Length;
data.probe.measlistAct = new bool[data.probe.numChannels];
for (int i = 0; i < data.probe.numChannels; i++)
{
data.probe.measlistAct[i] = false;
}
data.probe.measlistAct[0] = true;
// read the actual data
System.IO.StreamReader file2 = new System.IO.StreamReader(filename + ".wl1");
string lines = file2.ReadToEnd();
string[] tpts = lines.Split('\r');
data.data = new List <double> [data.probe.numChannels];
for (int i = 0; i < data.data.Length; i++)
{
data.data[i] = new List <double>();
}
for (int i = 0; i < tpts.Length - 1; i++)
{
if (tpts[i].Contains("\n"))
{
tpts[i] = tpts[i].Substring(1, tpts[i].Length - 1);
}
string[] pts = tpts[i].Split(' ');
for (int j = 0; j < ChanIdx.Count; j++)
{
data.data[j].Add(Convert.ToDouble(pts[ChanIdx[j]]));
}
}
file2 = new System.IO.StreamReader(filename + ".wl2");
lines = file2.ReadToEnd();
tpts = lines.Split('\r');
for (int i = 0; i < tpts.Length - 1; i++)
{
if (tpts[i].Contains("\n"))
{
tpts[i] = tpts[i].Substring(1, tpts[i].Length - 1);
}
string[] pts = tpts[i].Split(' ');
for (int j = 0; j < ChanIdx.Count; j++)
{
data.data[j + data.probe.numChannels / 2].Add(Convert.ToDouble(pts[ChanIdx[j]]));
}
}
// finally, the time vector
int fsIdx = hdrFields.IndexOf("SamplingRate");
double fs = Convert.ToDouble(hdrValues[fsIdx]);
data.numsamples = data.data.GetLength(1);
data.time = new List <double>();
for (int i = 0; i < data.numsamples; i++)
{
data.time.Add(i / fs);
}
// TODO add stimulus information
int EventIdx = hdrFields.IndexOf("Events");
string[] eventline = hdrValues[EventIdx].Split('\r');
double[,] events = new double[eventline.Length - 1, 3];
for (int i = 1; i < eventline.Length; i++)
{
string[] eventline2 = eventline[i].Split('\t');
for (int j = 0; j < 2; j++)
{
events[i - 1, j] = Convert.ToDouble(eventline2[j]);
}
}
List <double> uniqEvents = new List <double>();
int[] uniqEventCount = new int[events.GetLength(0)];
for (int i = 0; i < events.GetLength(0); i++)
{
uniqEventCount[i] = 0;
if (!uniqEvents.Contains(events[i, 1]))
{
uniqEvents.Add(events[i, 1]);
}
int ii = uniqEvents.IndexOf(events[i, 1]);
uniqEventCount[ii]++;
}
data.stimulus = new List <Stimulus>();
for (int i = 0; i < uniqEvents.Count; i++)
{
Stimulus stimulus = new Stimulus();
stimulus.name = String.Format("Event-{0}", uniqEvents[i]);
stimulus.onsets = new List <double>();
stimulus.duration = new List <double>();
stimulus.amplitude = new List <double>();
int n = 0;
for (int j = 0; j < events.GetLength(0); j++)
{
if (Math.Abs(events[j, 1] - uniqEvents[i]) < 0.0001)
{
stimulus.onsets.Add(events[j, 0]);
stimulus.duration.Add(1);
stimulus.amplitude.Add(1);
n++;
}
}
data.stimulus.Add(stimulus);
}
//add demographics info
List <string> Fields = new List <string>()
{
"Subject", "notes", "FileName", "Date", "Device", "Source",
"Mod", "APD", "NIRStar", "Mod Amp"
};
for (int i = 0; i < Fields.Count; i++)
{
int idx = hdrFields.IndexOf(Fields[i]);
if (idx > -1)
{
data.demographics.set(Fields[i], hdrValues[idx]);
}
}
data.description = targetDirectory;
return(data);
}
private static nirs.core.Probe loadSDprobe(string file, int[] lambda)
{
nirs.core.Probe probe = new core.Probe();
MatFileReader mfr = new MatFileReader(file);
MLStructure SD = (mfr.Content["SD"] as MLStructure);
MLDouble MLsrcpos = null;
if (SD.Keys.Contains("SrcPos"))
{
MLsrcpos = (SD["SrcPos"] as MLDouble);
}
else if (SD.Keys.Contains("srcpos"))
{
MLsrcpos = (SD["srcpos"] as MLDouble);
}
MLDouble MLdetpos = null;
if (SD.Keys.Contains("DetPos"))
{
MLdetpos = (SD["DetPos"] as MLDouble);
}
else if (SD.Keys.Contains("detpos"))
{
MLdetpos = (SD["detpos"] as MLDouble);
}
if (MLdetpos != null)
{
double[][] detpos = MLdetpos.GetArray();
probe.DetPos = new double[detpos.Length, 3];
probe.DetectorLabels = new string[detpos.Length];
for (int i = 0; i < detpos.Length; i++)
{
probe.DetPos[i, 0] = (float)detpos[i][0];
probe.DetPos[i, 1] = (float)detpos[i][1];
probe.DetPos[i, 2] = (float)detpos[i][2];
probe.DetectorLabels[i] = String.Format("Detector-{0}", +1);
}
probe.numDet = detpos.Length;
}
if (MLsrcpos != null)
{
double[][] srcpos = MLsrcpos.GetArray();
probe.SrcPos = new double[srcpos.Length, 3];
probe.SourceLabels = new string[srcpos.Length];
for (int i = 0; i < srcpos.Length; i++)
{
probe.SrcPos[i, 0] = (float)srcpos[i][0];
probe.SrcPos[i, 1] = (float)srcpos[i][1];
probe.SrcPos[i, 2] = (float)srcpos[i][2];
probe.SourceLabels[i] = String.Format("Source-{0}", i + 1);
}
probe.numSrc = srcpos.Length;
}
MLDouble mlMeasList = null;
if (mfr.Content.ContainsKey("ml"))
{
mlMeasList = (mfr.Content["ml"] as MLDouble);
}
else
{
mlMeasList = (SD["MeasList"] as MLDouble);
}
if (mlMeasList != null)
{
double[][] ml = mlMeasList.GetArray();
probe.ChannelMap = new ChannelMap[ml.Length];
for (int i = 0; i < ml.Length; i++)
{
probe.ChannelMap[i] = new ChannelMap();
probe.ChannelMap[i].sourceindex = (int)ml[i][0] - 1;
probe.ChannelMap[i].detectorindex = (int)ml[i][1] - 1;
probe.ChannelMap[i].channelname = String.Format("Src{0}-Det{1}",
probe.ChannelMap[i].sourceindex + 1,
probe.ChannelMap[i].detectorindex + 1);
probe.ChannelMap[i].wavelength = lambda[(int)ml[i][3] - 1];
probe.ChannelMap[i].datasubtype = String.Format("{0}nm", probe.ChannelMap[i].wavelength);
}
}
probe.numChannels = probe.ChannelMap.Length;
probe.measlistAct = new bool[probe.numChannels];
for (int i = 0; i < probe.numChannels; i++)
{
probe.measlistAct[i] = false;
}
probe.measlistAct[0] = true;
probe.numWavelengths = lambda.Length;
return(probe);
}
public static void writeDOTnirs(core.Data data, string filename, int startIdx = 0, int endIdx = Int32.MaxValue)
{
// Store the data into the *.nirs matlab format
try
{
int numsamples = data.numsamples;
int numch = data.probe.numChannels;
int naux = data.auxillaries.Length;
numsamples = Math.Min(endIdx - startIdx, numsamples - startIdx);
// save the structure as mat file using MatFileWriter
List <MLArray> mlList = new List <MLArray>();
double[][] d = new double[numsamples][];
double[][] t = new double[numsamples][];
double[][] aux = new double[numsamples][];
for (int j = startIdx; j < startIdx + numsamples; j++)
{
double[] dloc = new double[numch];
for (int i = 0; i < numch; i++)
{
dloc[i] = data.data[i][j];
}
try
{
if (naux > 0)
{
double[] aloc = new double[naux];
for (int ii = 0; ii < naux; ii++)
{
aloc[ii] = data.auxillaries[ii].data[j];
}
aux[j - startIdx] = aloc;
}
else
{
double[] aa = new double[1];
aa[0] = 0;
aux[j - startIdx] = aa;
}
}
catch
{
// Console.WriteLine("error writing aux");
double[] aa = new double[1];
aa[0] = 0;
aux[j - startIdx] = aa;
}
double[] tt = new double[1];
double[] ss = new double[1];
ss[0] = 0;
tt[0] = data.time[j];
t[j - startIdx] = tt;
d[j - startIdx] = dloc;
}
MLDouble mldata = new MLDouble("d", d);
mlList.Add(mldata);
MLDouble mlaux = new MLDouble("aux", aux);
mlList.Add(mlaux);
MLDouble mltime = new MLDouble("t", t);
mlList.Add(mltime);
double[][] s = new double[numsamples][];
for (int j = startIdx; j < startIdx + numsamples; j++)
{
double[] dloc = new double[data.stimulus.Count];
double thistime = data.time[j];
for (int i = 0; i < data.stimulus.Count; i++)
{
dloc[i] = 0;
for (int k = 0; k < data.stimulus[i].onsets.Count; k++)
{
double onset = data.stimulus[i].onsets[k];
double dur = data.stimulus[i].duration[k];
if (thistime >= onset & thistime <= onset + dur)
{
dloc[i] = data.stimulus[i].amplitude[k];
}
}
}
s[j - startIdx] = dloc;
}
MLDouble mls = new MLDouble("s", s);
mlList.Add(mls);
MLCell condNames = new MLCell("CondNames", new int[] { 1, data.stimulus.Count });
for (int i = 0; i < data.stimulus.Count; i++)
{
condNames[0, i] = new MLChar(null, data.stimulus[i].name);
}
mlList.Add(condNames);
// Probe
MLStructure mlSD = new MLStructure("SD", new int[] { 1, 1 });
List <string> datasubtype = new List <string>();
for (int i = 0; i < data.probe.numChannels; i++)
{
if (!datasubtype.Contains(data.probe.ChannelMap[i].datasubtype))
{
datasubtype.Add(data.probe.ChannelMap[i].datasubtype);
}
}
double[] lambda = new double[datasubtype.Count];
for (int i = 0; i < data.probe.numChannels; i++)
{
lambda[datasubtype.IndexOf(data.probe.ChannelMap[i].datasubtype)] = data.probe.ChannelMap[i].wavelength;
}
double[][] srcpos = new double[data.probe.numSrc][];
for (int j = 0; j < data.probe.numSrc; j++)
{
double[] slo = new double[3];
for (int i = 0; i < 2; i++)
{
slo[i] = data.probe.SrcPos[j, i];
}
slo[2] = 0;
srcpos[j] = slo;
}
double[][] detpos = new double[data.probe.numDet][];
for (int j = 0; j < data.probe.numDet; j++)
{
double[] dlo = new double[3];
for (int i = 0; i < 2; i++)
{
dlo[i] = data.probe.DetPos[j, i];
}
dlo[2] = 0;
detpos[j] = dlo;
}
mlSD["NumDet", 0] = new MLDouble("", new double[] { data.probe.numDet }, 1);
mlSD["NumSrc", 0] = new MLDouble("", new double[] { data.probe.numSrc }, 1);
mlSD["Lambda", 0] = new MLDouble("", lambda, 1);
mlSD["SrcPos", 0] = new MLDouble("", srcpos);
mlSD["DetPos", 0] = new MLDouble("", detpos);
if (data.probe.isregistered)
{
double[][] srcpos3d = new double[data.probe.numSrc][];
for (int j = 0; j < data.probe.numSrc; j++)
{
double[] slo = new double[3];
for (int i = 0; i < 3; i++)
{
slo[i] = data.probe.SrcPos3D[j, i];
}
srcpos3d[j] = slo;
}
double[][] detpos3d = new double[data.probe.numDet][];
for (int j = 0; j < data.probe.numDet; j++)
{
double[] dlo = new double[3];
for (int i = 0; i < 3; i++)
{
dlo[i] = data.probe.DetPos3D[j, i];
}
detpos3d[j] = dlo;
}
mlSD["SrcPos3D", 0] = new MLDouble("", srcpos3d);
mlSD["DetPos3D", 0] = new MLDouble("", detpos3d);
}
// fixes for HOMER2
mlSD["SpatialUnit"] = new MLChar("", "mm");
// Add demographics as a struct
MLStructure demo = new MLStructure("demographics", new int[] { 1, 1 });
for (int i = 0; i < data.demographics.Keys.Count; i++)
{
object val = data.demographics.get(data.demographics.Keys[i]);
string valstr = string.Format("{0}", val);
demo[data.demographics.Keys[i], 0] = new MLChar("", valstr);
}
mlList.Add(demo);
double[][] ml = new double[data.probe.numChannels][];
for (int i = 0; i < data.probe.numChannels; i++)
{
double[] m = new double[4];
m[0] = data.probe.ChannelMap[i].sourceindex + 1;
m[1] = data.probe.ChannelMap[i].detectorindex + 1;
m[2] = 0;
m[3] = 1 + datasubtype.IndexOf(data.probe.ChannelMap[i].datasubtype);
ml[i] = m;
}
MLDouble mlml = new MLDouble("ml", ml);
mlList.Add(mlml);
mlSD["MeasList", 0] = new MLDouble("", ml);
mlList.Add(mlSD);
MLStructure mlStim = new MLStructure("StimDesign", new int[] { data.stimulus.Count, 1 });
for (int i = 0; i < data.stimulus.Count; i++)
{
mlStim["name", i] = new MLChar("", data.stimulus[i].name);
double[] onset = new double[data.stimulus[i].onsets.Count];
for (int ii = 0; ii < data.stimulus[i].onsets.Count; ii++)
{
onset[ii] = data.stimulus[i].onsets[ii];
}
double[] dur = new double[data.stimulus[i].duration.Count];
for (int ii = 0; ii < data.stimulus[i].duration.Count; ii++)
{
dur[ii] = data.stimulus[i].duration[ii];
}
double[] amp = new double[data.stimulus[i].amplitude.Count];
for (int ii = 0; ii < data.stimulus[i].amplitude.Count; ii++)
{
amp[ii] = data.stimulus[i].amplitude[ii];
}
mlStim["onset", i] = new MLDouble("", onset, 1);
mlStim["dur", i] = new MLDouble("", dur, 1);
mlStim["amp", i] = new MLDouble("", amp, 1);
}
if (data.stimulus.Count > 0)
{
mlList.Add(mlStim);
}
new MatFileWriter(filename, mlList, false);
}
catch
{
Console.WriteLine("Unable to save .nirs file");
}
return;
}
{ // methods devoted to file I/O
public static core.Data readDOTnirs(string filename)
{
core.Data data = new core.Data();
MatFileReader mfr = new MatFileReader(filename);
MLDouble mlD = (mfr.Content["d"] as MLDouble);
if (mlD != null)
{
double[][] d = mlD.GetArray();
double[] dd = d[0];
data.data = new List <double> [dd.Length];
for (int i = 0; i < dd.Length; i++)
{
data.data[i] = new List <double>();
}
for (int i = 0; i < d.Length; i++)
{
double[] dd3 = d[i];
for (int j = 0; j < dd3.Length; j++)
{
data.data[j].Add(dd3[j]);
}
}
}
MLDouble mlT = (mfr.Content["t"] as MLDouble);
if (mlT != null)
{
double[][] t = mlT.GetArray();
data.time = new List <double>();
for (int i = 0; i < t.Length; i++)
{
data.time.Add(t[i][0]);
}
}
data.numsamples = data.time.Count;
double[][] lambda;
MLStructure SD = (mfr.Content["SD"] as MLStructure);
MLDouble MLlambda = null;
if (SD.Keys.Contains("Lambda"))
{
MLlambda = (SD["Lambda"] as MLDouble);
}
else if (SD.Keys.Contains("lambda"))
{
MLlambda = (SD["lambda"] as MLDouble);
}
MLDouble MLsrcpos = null;
if (SD.Keys.Contains("SrcPos"))
{
MLsrcpos = (SD["SrcPos"] as MLDouble);
}
else if (SD.Keys.Contains("srcpos"))
{
MLsrcpos = (SD["srcpos"] as MLDouble);
}
MLDouble MLdetpos = null;
if (SD.Keys.Contains("DetPos"))
{
MLdetpos = (SD["DetPos"] as MLDouble);
}
else if (SD.Keys.Contains("detpos"))
{
MLdetpos = (SD["detpos"] as MLDouble);
}
if (MLdetpos != null)
{
double[][] detpos = MLdetpos.GetArray();
data.probe.DetPos = new double[detpos.Length, 3];
data.probe.DetectorLabels = new string[detpos.Length];
for (int i = 0; i < detpos.Length; i++)
{
data.probe.DetPos[i, 0] = (float)detpos[i][0];
data.probe.DetPos[i, 1] = (float)detpos[i][1];
data.probe.DetPos[i, 2] = (float)detpos[i][2];
data.probe.DetectorLabels[i] = String.Format("Detector-{0}", +1);
}
data.probe.numDet = detpos.Length;
}
if (MLsrcpos != null)
{
double[][] srcpos = MLsrcpos.GetArray();
data.probe.SrcPos = new double[srcpos.Length, 3];
data.probe.SourceLabels = new string[srcpos.Length];
for (int i = 0; i < srcpos.Length; i++)
{
data.probe.SrcPos[i, 0] = (float)srcpos[i][0];
data.probe.SrcPos[i, 1] = (float)srcpos[i][1];
data.probe.SrcPos[i, 2] = (float)srcpos[i][2];
data.probe.SourceLabels[i] = String.Format("Source-{0}", i + 1);
}
data.probe.numSrc = srcpos.Length;
}
if (MLlambda != null)
{
lambda = MLlambda.GetArray();
MLDouble mlMeasList = (mfr.Content["ml"] as MLDouble);
if (mlMeasList != null)
{
double[][] ml = mlMeasList.GetArray();
data.probe.ChannelMap = new ChannelMap[ml.Length];
for (int i = 0; i < ml.Length; i++)
{
data.probe.ChannelMap[i] = new ChannelMap();
data.probe.ChannelMap[i].sourceindex = (int)ml[i][0] - 1;
data.probe.ChannelMap[i].detectorindex = (int)ml[i][1] - 1;
data.probe.ChannelMap[i].channelname = String.Format("Src{0}-Det{1}",
data.probe.ChannelMap[i].sourceindex + 1,
data.probe.ChannelMap[i].detectorindex + 1);
data.probe.ChannelMap[i].wavelength = lambda[0][(int)ml[i][3] - 1];
data.probe.ChannelMap[i].datasubtype = String.Format("{0}nm", data.probe.ChannelMap[i].wavelength);
}
}
}
data.probe.numChannels = data.probe.ChannelMap.Length;
data.probe.measlistAct = new bool[data.probe.numChannels];
for (int i = 0; i < data.probe.numChannels; i++)
{
data.probe.measlistAct[i] = false;
}
data.probe.measlistAct[0] = true;
// TODO add stimulus information
// TODO add 3D probe information
// TODO add demographics info
// TODO add auxillary information
// TODO exceptipon catches for case-sensitive variable names
data.description = filename;
return(data);
}
public async static Task Export(String filename, Project project, ILogger logger = null, CancellationToken cancelletionToken = default(CancellationToken))
{
logger?.WriteLineInfo("");
logger?.WriteLineInfo("Saving project into MAT file!");
logger?.WriteLineInfo("MAT file location: " + filename);
List <MLArray> mlList = new List <MLArray>();
int pi = 0;
foreach (DataStream dataStream in project.DataStreams)
{
pi++;
cancelletionToken.ThrowIfCancellationRequested();
logger?.WriteLineInfo("Exporting " + dataStream.ShortName + " datastream...");
logger?.WriteProgress((double)pi / (double)project.DataStreams.Count() * 100.0);
MLStructure structDataStream = new MLStructure(dataStream.ShortName, new int[] { 1, 1 });
structDataStream["Name", 0] = new MLChar(null, dataStream.Name);
structDataStream["ShortName", 0] = new MLChar(null, dataStream.ShortName);
if (dataStream.DataLines.Count > 0)
{
// DataLines
MLCell arrayDataLines = new MLCell("DataLines", new int[] { dataStream.DataLines.Count, 1 });
int k = 0;
foreach (DataLine dataLine in dataStream.DataLines)
{
MLStructure structDataLine = new MLStructure(dataStream.ShortName, new int[] { 1, 1 });
structDataLine["Timestamp", 0] = new MLDouble("", new double[] { Utils.ConvertToUnixTimestamp(dataLine.TimeStamp) }, 1);
structDataLine["TimestampC", 0] = ConvertDateTimeToMLDouble(dataLine.TimeStamp);
if (dataLine is ImageDataLine)
{
structDataLine["ImageFileName", 0] = new MLChar(null, (dataLine as ImageDataLine).ImageFileName);
}
if (dataLine is VideoDataLine)
{
structDataLine["VideoFileName", 0] = new MLChar(null, (dataLine as VideoDataLine).VideoFileName);
}
arrayDataLines[k] = structDataLine;
k++;
}
structDataStream["DataLines", 0] = arrayDataLines;
}
if (dataStream is GPSDataStream)
{
GPSDataStream gpsDataStream = dataStream as GPSDataStream;
// Event Marker
if (gpsDataStream.MarkerEvents.Count > 0)
{
MLCell arrayMarkerEvents = new MLCell("MarkerEvents", new int[] { gpsDataStream.MarkerEvents.Count, 1 });
int k = 0;
foreach (EvenMarkerDataLine evnt in gpsDataStream.MarkerEvents)
{
MLStructure structEventMarkers = new MLStructure(dataStream.ShortName, new int[] { 1, 1 });
structEventMarkers["Timestamp", 0] = new MLDouble("", new double[] { (double)evnt.TimeStamp.Ticks }, 1);
structEventMarkers["TimestampC", 0] = ConvertDateTimeToMLDouble(evnt.TimeStamp);
structEventMarkers["Port", 0] = new MLChar(null, evnt.Port.ToString());
arrayMarkerEvents[k] = structEventMarkers;
k++;
}
structDataStream["MarkerEvents", 0] = arrayMarkerEvents;
}
// Positions
if (gpsDataStream.Positions.Count > 0)
{
double[][] points = new double[gpsDataStream.Positions.Count][];
int k = 0;
foreach (GPSPositionDataLine pt in gpsDataStream.Positions)
{
points[k] = new double[5];
points[k][0] = Utils.ConvertToUnixTimestamp(pt.TimeStamp);
points[k][1] = pt.Lat;
points[k][2] = pt.Lon;
points[k][3] = pt.Height;
points[k][4] = pt.Quality;
k++;
}
MLDouble arrayPoints = new MLDouble("Points", points);
structDataStream["Points", 0] = arrayPoints;
}
}
mlList.Add(structDataStream);
}
try
{
MatFileWriter mfw = new MatFileWriter(filename, mlList, false);
}
catch (Exception ex)
{
logger?.WriteLineError("Error occured: " + ex.ToString());
return;
}
logger?.WriteLineInfo("MAT file location: " + filename);
logger?.WriteLineInfo("Done.");
}
public static void ExportHotFrame(String rootFolder, String annotationName, HotFrame frame,
MatlabExporterOptions options = MatlabExporterOptions.Overwrite, ILogger logger = null, CancellationToken cancelletionToken = default(CancellationToken))
{
// delete features
/*List<Feature> newFeatureSet = new List<Feature>();
* foreach (Feature feature in frame.Features)
* {
* if (feature.DataStream != null) newFeatureSet.Add(feature);
* }
* frame.Features = newFeatureSet;*/
String folderName = rootFolder + "\\frame_" + annotationName;
String matFilePath = folderName + "\\frame_" + annotationName + ".mat";
Directory.CreateDirectory(folderName);
logger?.WriteLineInfo("");
logger?.WriteLineInfo("Convert frame to Matlab MAT format and export images!");
logger?.WriteLineInfo("Export folder: " + folderName);
logger?.WriteLineInfo("MAT file location: " + matFilePath);
List <MLArray> mlList = new List <MLArray>();
Dictionary <DataStream, List <VeloFeature> > velodyneData = new Dictionary <DataStream, List <VeloFeature> >();
if ((options == MatlabExporterOptions.Append) && (File.Exists(matFilePath)))
{
MatFileReader matReader = new MatFileReader(matFilePath);
mlList = matReader.Data;
}
int i = 0;
foreach (Feature feature in frame.Features)
{
logger?.WriteLineInfo("Exporting: " + feature.DataStream.ShortName);
MLStructure structFeatures = new MLStructure(feature.DataStream.ShortName, new int[] { 1, 1 });
structFeatures["Name", 0] = new MLChar(null, feature.DataStream.Name);
structFeatures["ShortName", 0] = new MLChar(null, feature.DataStream.ShortName);
if (cancelletionToken.IsCancellationRequested == true)
{
logger?.WriteLineWarning("Export cancelled!");
return;
}
if (feature is GPSFeature)
{
var gpsFeature = feature as GPSFeature;
structFeatures["Lat", 0] = new MLDouble("", new double[] { gpsFeature.Position.Lat }, 1);
structFeatures["Lon", 0] = new MLDouble("", new double[] { gpsFeature.Position.Lon }, 1);
structFeatures["Height", 0] = new MLDouble("", new double[] { gpsFeature.Position.Height }, 1);
structFeatures["Quality", 0] = new MLDouble("", new double[] { gpsFeature.Position.Quality }, 1);
mlList.Add(structFeatures);
}
else if (feature is ImageFeature)
{
ImageFeature imageFeature = feature as ImageFeature;
structFeatures["Timestamp", 0] = new MLDouble("", new double[] { Utils.ConvertToUnixTimestamp(imageFeature.TimeStamp) }, 1);
structFeatures["TimestampC", 0] = ConvertDateTimeToMLDouble(imageFeature.TimeStamp);
double[][] points = new double[imageFeature.Points.Count][];
int k = 0;
foreach (ImagePoint pt in ((ImageFeature)feature).Points)
{
points[k] = new double[3];
points[k][0] = pt.ID;
points[k][1] = pt.X;
points[k][2] = pt.Y;
k++;
}
if (k != 0)
{
MLDouble arrayPoints = new MLDouble("Points", points);
structFeatures["Points", 0] = arrayPoints;
}
// save images
if (imageFeature.Image != null)
{
using (Bitmap img = new Bitmap(imageFeature.Image))
{
img.Save(folderName + "\\frame_" + annotationName + "_" + feature.DataStream.ShortName + ".bmp");
}
// you can export the images here, but it's very slow and the code also needs to be tested!
/*using (Bitmap img = new Bitmap(imageFeature.Image))
* {
*
* int[] dims = new int[] { img.Width, img.Height, 3 };
* MLDouble arrImg = new MLDouble("Image", dims);
* for (int i = 0; i < img.Width; i++)
* {
* for (int j = 0; j < img.Height; j++)
* {
* Color col = img.GetPixel(i, j);
* arrImg.Set(col.R, i, j + img.Height * 0);
* arrImg.Set(col.G, i, j + img.Height * 1);
* arrImg.Set(col.B, i, j + img.Height * 2);
* }
* }
*
* structFeatures["Image", 0] = arrImg;
* }*/
}
mlList.Add(structFeatures);
}
else if (feature is VeloFeature)
{
VeloFeature veloFeature = feature as VeloFeature;
// if key does not exist create one
if (!velodyneData.ContainsKey(veloFeature.DataStream))
{
velodyneData.Add(veloFeature.DataStream, new List <VeloFeature>());
}
velodyneData[veloFeature.DataStream].Add(veloFeature);
}
i++;
logger?.WriteProgress((double)i / (double)frame.Features.Count() * 100.0);
}
// ok, now finalize velodyne data
foreach (KeyValuePair <DataStream, List <VeloFeature> > entry in velodyneData)
{
if (cancelletionToken.IsCancellationRequested == true)
{
logger?.WriteLineWarning("Export cancelled!");
return;
}
MLStructure structFeatures = new MLStructure(entry.Key.ShortName, new int[] { 1, 1 });
structFeatures["Name", 0] = new MLChar(null, entry.Key.Name);
structFeatures["ShortName", 0] = new MLChar(null, entry.Key.ShortName);
structFeatures["TimeStamp", 0] = new MLDouble("", new double[] { Utils.ConvertToUnixTimestamp(frame.Timestamp) }, 1);
// get number of points
long n_points = 0;
foreach (VeloFeature feature in entry.Value)
{
n_points += feature.Points.Count();
}
if (n_points == 0)
{
logger?.WriteLineWarning(entry.Key.ShortName + ": No features!");
continue;
}
// populate points
double[][] points = new double[n_points][];
int k = 0;
foreach (VeloFeature feature in entry.Value)
{
foreach (VelodynePoint pt in feature.Points)
{
points[k] = new double[9];
points[k][0] = feature.ID;
points[k][1] = pt.X;
points[k][2] = pt.Y;
points[k][3] = pt.Z;
points[k][4] = Convert.ToDouble(pt.Intensity);
points[k][5] = pt.Distance;
points[k][6] = pt.Hz;
points[k][7] = pt.Vz;
points[k][8] = pt.InternalTime;
k++;
}
}
MLDouble arrayPoints = new MLDouble("Points", points);
structFeatures["Points", 0] = arrayPoints;
mlList.Add(structFeatures);
}
try
{
logger?.WriteLineInfo("Saving mat file...");
MatFileWriter mfw = new MatFileWriter(matFilePath, mlList, true);
}
catch (Exception ex)
{
logger?.WriteLineError("Error occured: " + ex.ToString());
return;
}
logger?.WriteProgress(100.0);
logger?.WriteLineInfo("Done.");
}
