public static int WriteRNAFiles(IMatrixData mdata, Parameters param, Parameters dataParam, string workingDirectory, out string errString, string RNAexp)
{
//need to write a general version
//accepts text only data for now
string fileTempY = System.IO.Path.Combine(workingDirectory, @".\tempY.txt");
string fileY = System.IO.Path.Combine(workingDirectory, @".\fileY.txt");
IMatrixData mCopyY = (IMatrixData)mdata.Clone();
int[] nameInd = new[] { param.GetParam <int>("Gene Name Column").Value };
int[] yInd = dataParam.GetParam <int[]>(RNAexp).Value;
double baseVal = GetBase(dataParam.GetParamWithSubParams <int>(PECAParameters.dataFormGeneric));
SetupMDataForInput(mCopyY, yInd, nameInd, baseVal);
try
{
//hacky way of removing comments
PerseusUtils.WriteMatrixToFile(mCopyY, fileTempY, false);
RemoveCommentsFromFile(fileTempY, fileY);
}
catch (Exception e)
{
//need to reorganize this
errString = e.ToString();
return(-1);
}
errString = null;
return(0);
}
public void ProcessData(IMatrixData inData, INetworkData outData, Parameters param, ref IData[] supplData, ProcessInfo processInfo)
{
var remoteExe = param.GetParam <string>(InterpreterLabel).Value;
var inFile = Path.GetTempFileName();
PerseusUtils.WriteMatrixToFile(inData, inFile, false);
var paramFile = Path.GetTempFileName();
param.ToFile(paramFile);
var outFolder = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
if (!TryGetCodeFile(param, out string codeFile))
{
processInfo.ErrString = $"Code file '{codeFile}' was not found";
return;
}
var suppFiles = SupplDataTypes.Select(Utils.CreateTemporaryPath).ToArray();
var args = $"{codeFile} {paramFile} {inFile} {outFolder} {string.Join(" ", suppFiles)}";
Debug.WriteLine($"executing > {remoteExe} {args}");
if (Utils.RunProcess(remoteExe, args, processInfo.Status, out string processInfoErrString) != 0)
{
processInfo.ErrString = processInfoErrString;
return;
}
;
FolderFormat.Read(outData, outFolder, processInfo);
supplData = Utils.ReadSupplementaryData(suppFiles, SupplDataTypes, processInfo);
}
public IAnalysisResult AnalyzeData(IMatrixData mdata, Parameters param, ProcessInfo processInfo)
{
var remoteExe = param.GetParam <string>(InterpreterLabel).Value;
if (string.IsNullOrWhiteSpace(remoteExe))
{
processInfo.ErrString = Resources.RemoteExeNotSpecified;
return(null);
}
var inFile = Path.GetTempFileName();
PerseusUtils.WriteMatrixToFile(mdata, inFile);
var outFiles = new[] { Path.GetTempFileName() }
.Concat(SupplDataTypes.Select(dataType => Path.GetTempFileName()))
.ToArray();
if (!TryGetCodeFile(param, out string codeFile))
{
processInfo.ErrString = $"Code file '{codeFile}' was not found";
return(null);
}
var commandLineArguments = GetCommandLineArguments(param);
var args = $"{codeFile} {commandLineArguments} {inFile} {string.Join(" ", outFiles)}";
if (Utils.RunProcess(remoteExe, args, processInfo.Status, out string errorString) != 0)
{
processInfo.ErrString = errorString;
return(null);
}
return(GenerateResult(outFiles, mdata, processInfo));
}
private static void ReadMatrixDataInto(IDataWithAnnotationColumns data, string file, ProcessInfo processInfo)
{
var mdata = PerseusFactory.CreateMatrixData();
PerseusUtils.ReadMatrixFromFile(mdata, processInfo, file, '\t');
data.CopyAnnotationColumnsFrom(mdata);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
Relation[] relations = PerseusUtils.GetRelationsNumFilter(param, out string errString, out int[] colInds, out bool and);
if (errString != null)
{
processInfo.ErrString = errString;
return;
}
double[][] rows = GetRows(mdata, colInds);
List <int> valids = new List <int>();
List <int> notvalids = new List <int>();
for (int i = 0; i < rows.Length; i++)
{
bool valid = PerseusUtils.IsValidRowNumFilter(rows[i], relations, and);
if (!valid)
{
notvalids.Add(i);
}
}
if (param.GetParam <int>("Filter mode").Value == 2)
{
supplTables = new[] { PerseusPluginUtils.CreateSupplTabSplit(mdata, notvalids.ToArray()) };
}
PerseusPluginUtils.FilterRowsNew(mdata, param, GetValids(mdata, colInds, relations, and));
}
public Parameters GetParameters(IMatrixData mdata, ref string errorString)
{
string[] selection = ArrayUtils.Concat(mdata.NumericColumnNames, mdata.ColumnNames);
return
(new Parameters(ArrayUtils.Concat(PerseusUtils.GetNumFilterParams(selection),
PerseusPluginUtils.CreateFilterModeParam(true))));
}
public IAnalysisResult AnalyzeData(IMatrixData mdata, Parameters param, ProcessInfo processInfo)
{
var remoteExe = param.GetParam <string>(InterpreterLabel).Value;
var inFile = Path.GetTempFileName();
PerseusUtils.WriteMatrixToFile(mdata, inFile);
var paramFile = Path.GetTempFileName();
param.ToFile(paramFile);
var outFile = Path.GetTempFileName();
if (!TryGetCodeFile(param, out string codeFile))
{
processInfo.ErrString = $"Code file '{codeFile}' was not found";
return(null);
}
var args = $"{codeFile} {paramFile} {inFile} {outFile}";
if (Utils.RunProcess(remoteExe, args, processInfo.Status, out string errorString) != 0)
{
processInfo.ErrString = errorString;
return(null);
}
return(GenerateResult(outFile, mdata, processInfo));
}
public void WriteDataWithAnnotationColumnsTest()
{
// main data
IDataWithAnnotationColumns mdata = PerseusFactory.CreateDataWithAnnotationColumns();
// annotation columns
mdata.AddStringColumn("strcol1", "this is stringcol1", new[] { "1", "2" });
mdata.AddStringColumn("strcol2", "", new[] { "", "hallo" });
mdata.AddNumericColumn("numcol", "", new[] { 1.0, 2.0 });
mdata.AddMultiNumericColumn("multnumcol", "this is multnumcol", new[] { new[] { -2.0, 2.0 }, new double[] {} });
mdata.AddCategoryColumn("catcol", "", new[] { new[] { "cat1", "cat1.1" }, new[] { "cat2", "cat1" } });
string mdataStr;
using (MemoryStream memstream = new MemoryStream())
using (StreamWriter writer = new StreamWriter(memstream)) {
PerseusUtils.WriteDataWithAnnotationColumns(mdata, writer);
writer.Flush();
mdataStr = Encoding.UTF8.GetString(memstream.ToArray());
}
IMatrixData mdata3 = PerseusFactory.CreateMatrixData();
PerseusUtils.ReadMatrix(mdata3, new ProcessInfo(new Settings(), status => { }, progress => { }, 1, i => { }),
() => {
StreamReader tmpStream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(mdataStr)));
return(tmpStream);
}, "matrix1", '\t');
IDataWithAnnotationColumns mdata2 = mdata3;
Assert.AreEqual(2, mdata2.RowCount);
Assert.AreEqual(2, mdata2.StringColumnCount);
Assert.AreEqual(1, mdata2.NumericColumnCount);
Assert.AreEqual(1, mdata2.CategoryColumnCount);
Assert.AreEqual(1, mdata2.MultiNumericColumnCount);
Assert.AreEqual("hallo", mdata2.StringColumns[mdata2.StringColumnNames.FindIndex(col => col.Equals("strcol2"))][1]);
}
public void LoadData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents,
ProcessInfo processInfo)
{
var remoteExe = GetExectuable(param);
var paramFile = Path.GetTempFileName();
param.ToFile(paramFile);
var outFile = Path.GetTempFileName();
if (!TryGetCodeFile(param, out string codeFile))
{
processInfo.ErrString = $"Code file '{codeFile}' was not found";
return;
}
;
if (supplTables == null)
{
supplTables = Enumerable.Range(0, NumSupplTables).Select(i => PerseusFactory.CreateMatrixData()).ToArray();
}
var suppFiles = supplTables.Select(i => Path.GetTempFileName()).ToArray();
var args = $"{codeFile} {paramFile} {outFile} {string.Join(" ", suppFiles)}";
Debug.WriteLine($"executing > {remoteExe} {args}");
if (Utils.RunProcess(remoteExe, args, processInfo.Status, out string processInfoErrString) != 0)
{
processInfo.ErrString = processInfoErrString;
return;
}
;
PerseusUtils.ReadMatrixFromFile(mdata, processInfo, outFile, '\t');
for (int i = 0; i < NumSupplTables; i++)
{
PerseusUtils.ReadMatrixFromFile(supplTables[i], processInfo, suppFiles[i], '\t');
}
}
/// <summary>
/// Read supplementary files according to file paths and data types.
/// </summary>
/// <param name="suppFiles"></param>
/// <param name="supplDataTypes"></param>
/// <param name="processInfo"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public static IData[] ReadSupplementaryData(string[] suppFiles, DataType[] supplDataTypes, ProcessInfo processInfo)
{
var numSupplTables = suppFiles.Length;
IData[] supplData = new IData[numSupplTables];
for (int i = 0; i < numSupplTables; i++)
{
switch (supplDataTypes[i])
{
case DataType.Matrix:
var mdata = PerseusFactory.CreateMatrixData();
PerseusUtils.ReadMatrixFromFile(mdata, processInfo, suppFiles[i], '\t');
supplData[i] = mdata;
break;
case DataType.Network:
var ndata = PerseusFactory.CreateNetworkData();
FolderFormat.Read(ndata, suppFiles[i], processInfo);
supplData[i] = ndata;
break;
default:
throw new NotImplementedException($"Data type {supplDataTypes[i]} not supported!");
}
}
return(supplData);
}
public void TestReadWriteMatrixRoundTrip()
{
var mdata = PerseusFactory.CreateMatrixData();
mdata.AddStringColumn("StringCol", "", new []
{
"Regular text",
"\"Regular quoted text\"",
"\"Quote stops\" in the middle",
"\"Escaped\tseparator\"with extra",
});
mdata.AddNumericColumn("NumCol", "", mdata.StringColumns[0].Select(_ => 1.0).ToArray());
mdata.AddCategoryColumn("CatCol", "", mdata.StringColumns[0].Select(_ => new string[0]).ToArray());
string content;
using (var memory = new MemoryStream())
using (var writer = new StreamWriter(memory))
{
PerseusUtils.WriteMatrix(mdata, writer);
writer.Flush();
content = Encoding.UTF8.GetString(memory.ToArray());
}
var mdata2 = PerseusFactory.CreateMatrixData();
var processInfo = new ProcessInfo(new Settings(), s => { }, i => { }, 1);
PerseusUtils.ReadMatrix(mdata2, processInfo, () => new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(content))), "name", '\t');
var expected = mdata.StringColumns[0];
expected[1] = expected[1].Trim('\"');
CollectionAssert.AreEqual(mdata.StringColumns[0], mdata2.StringColumns[0]);
}
public void TestReadMatrixFromTabsepFileWithDoubleQuotes()
{
var mdata = PerseusFactory.CreateMatrixData();
var processInfo = new ProcessInfo(new Settings(), s => { }, i => { }, 1);
var lines = new[]
{
"Col\tStringCol\tNumCol",
"#!{Type}E\tT\tN",
"-1.0\thello\t12",
"1.0\t\"Actin family, ARP subfamily\";Actin family\t4",
"2.0\t\"Regular quoted text\"\t4",
"3.0\t\"Escaped\tseparator\"with extra\t4",
"4.0\t\"Quote between separators\t\"\t4",
"4.0\tQuote \"in\tthe\" middle\t4",
};
var bytes = Encoding.UTF8.GetBytes(string.Join("\n", lines));
PerseusUtils.ReadMatrix(mdata, processInfo, () => new StreamReader(new MemoryStream(bytes)), "name", '\t');
Assert.AreEqual("Col", mdata.ColumnNames.Single());
Assert.AreEqual("StringCol", mdata.StringColumnNames.Single());
Assert.AreEqual("NumCol", mdata.NumericColumnNames.Single());
CollectionAssert.AreEqual(new [] { -1.0, 1.0, 2.0, 3.0, 4.0, 4.0 }, mdata.Values.GetColumn(0).ToArray());
CollectionAssert.AreEqual(new [] { "hello", "\"Actin family, ARP subfamily\";Actin family", "Regular quoted text", "\"Escaped\tseparator\"with extra", "Quote between separators", "Quote \"in\tthe\" middle" }, mdata.StringColumns.Single());
CollectionAssert.AreEqual(new [] { 12, 4, 4, 4, 4, 4 }, mdata.NumericColumns.Single());
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int nameCol = param.GetParam <int>("New column names").Value;
List <string> colNames;
if (nameCol >= 0)
{
HashSet <string> taken = new HashSet <string>();
colNames = new List <string>();
foreach (string n in mdata.StringColumns[nameCol])
{
string n1 = PerseusUtils.GetNextAvailableName(n, taken);
taken.Add(n1);
colNames.Add(n1);
}
}
else
{
colNames = new List <string>();
for (int i = 0; i < mdata.RowCount; i++)
{
colNames.Add("Column" + (i + 1));
}
}
List <string> rowNames = mdata.ColumnNames;
mdata.Values = mdata.Values.Transpose();
if (mdata.IsImputed != null)
{
mdata.IsImputed = mdata.IsImputed.Transpose();
}
if (mdata.Quality != null)
{
mdata.Quality = mdata.Quality.Transpose();
}
List <string> stringColumnNames = mdata.StringColumnNames;
List <string> categoryColumnNames = mdata.CategoryColumnNames;
List <string> numericColumnNames = mdata.NumericColumnNames;
List <string> multiNumericColumnNames = mdata.MultiNumericColumnNames;
List <string> stringColumnDescriptions = mdata.StringColumnDescriptions;
List <string> categoryColumnDescriptions = mdata.CategoryColumnDescriptions;
List <string> numericColumnDescriptions = mdata.NumericColumnDescriptions;
List <string> multiNumericColumnDescriptions = mdata.MultiNumericColumnDescriptions;
List <string[]> stringColumns = mdata.StringColumns;
List <string[][]> categoryColumns = GetCategoryColumns(mdata);
List <double[]> numericColumns = mdata.NumericColumns;
List <double[][]> multiNumericColumns = mdata.MultiNumericColumns;
mdata.SetAnnotationColumns(new List <string>(new[] { "Name" }), new List <string>(new[] { "Name" }),
new List <string[]>(new[] { rowNames.ToArray() }), mdata.CategoryRowNames, mdata.CategoryRowDescriptions,
GetCategoryRows(mdata), mdata.NumericRowNames, mdata.NumericRowDescriptions, mdata.NumericRows, new List <string>(),
new List <string>(), new List <double[][]>());
mdata.ColumnNames = colNames;
mdata.SetAnnotationRows(stringColumnNames, stringColumnDescriptions, stringColumns, categoryColumnNames,
categoryColumnDescriptions, categoryColumns, numericColumnNames, numericColumnDescriptions, numericColumns,
multiNumericColumnNames, multiNumericColumnDescriptions, multiNumericColumns);
}
public void Export(Parameters parameters, IMatrixData data, ProcessInfo processInfo)
{
string filename = parameters.GetParam <string>("File name").Value;
bool addtlMatrices = parameters.GetParam <bool>("Write quality and imputed matrices").Value;
addtlMatrices = addtlMatrices && data.IsImputed != null && data.Quality != null && data.IsImputed.IsInitialized() &&
data.Quality.IsInitialized();
PerseusUtils.WriteMatrixToFile(data, filename, addtlMatrices);
}
private static int GetRowCount(string filename, int[] mainColIndices, List <Tuple <Relation[], int[], bool> > filters,
char separator)
{
StreamReader reader = FileUtils.GetReader(filename);
StreamReader auxReader = FileUtils.GetReader(filename);
int count = PerseusUtils.GetRowCount(reader, auxReader, mainColIndices, filters, separator);
reader.Close();
return(count);
}
public void TestReadEmptyMatrixFromFile()
{
var data = PerseusFactory.CreateDataWithAnnotationColumns();
PerseusUtils.ReadDataWithAnnotationColumns(data, BaseTest.CreateProcessInfo(), () =>
{
var memstream = new MemoryStream(Encoding.UTF8.GetBytes("Node\n#!{Type}T\n"));
return(new StreamReader(memstream));
}, "test", '\t');
Assert.AreEqual(0, data.RowCount);
}
public void TestWriteMultiNumericColumnWithNulls()
{
var data = PerseusFactory.CreateDataWithAnnotationColumns();
data.AddMultiNumericColumn("Test", "", new double[1][]);
data.AddStringColumn("Test2", "", new string[1]);
Assert.AreEqual(1, data.RowCount);
var writer = new StreamWriter(new MemoryStream());
PerseusUtils.WriteDataWithAnnotationColumns(data, writer);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
Relation[] relations = PerseusUtils.GetRelationsNumFilter(param, out string errString, out int[] colInds, out bool and);
if (errString != null)
{
processInfo.ErrString = errString;
return;
}
PerseusPluginUtils.FilterRows(mdata, param, GetValids(mdata, colInds, relations, and));
}
public PerseusLoadMatrixControl(IList <string> items, string filename)
{
InitializeComponent();
MultiListSelector1.Init(items, new[] { "Main", "Numerical", "Categorical", "Text", "Multi-numerical" },
new Func <string[], Parameters>[] {
s => new Parameters(PerseusUtils.GetNumFilterParams(s)), s => new Parameters(PerseusUtils.GetNumFilterParams(s)),
null, null, null
});
if (!string.IsNullOrEmpty(filename))
{
UpdateFile(filename);
}
}
public void ReadMappingTest()
{
Assert.Inconclusive("Should be moved to integration tests, using conf");
//[DeploymentItem("conf", "conf")]
string[] baseNames, files;
var annots = PerseusUtils.GetAvailableAnnots(out baseNames, out files);
var uniprotIndex = baseNames.ToList().FindIndex(name => name.ToLower().Equals("uniprot"));
var selection = annots[uniprotIndex].ToList().FindIndex(name => name.ToLower().Equals("gene name"));
var ids = new[] { "P08908" };
var mapping = AddAnnotationToMatrix.ReadMapping(ids, files[1], new[] { selection });
CollectionAssert.AreEqual(new [] { "HTR1A" }, mapping[ids[0]]);
}
/// <summary>
/// Write the fiven network to the specified folder.
/// </summary>
public static void Write(INetworkDataAnnColumns ndata, string folder)
{
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
PerseusUtils.WriteDataWithAnnotationColumns(ndata, Path.Combine(folder, "networks.txt"));
foreach (var network in ndata)
{
PerseusUtils.WriteDataWithAnnotationColumns(network.NodeTable, Path.Combine(folder, $"{network.Guid}_nodes.txt"));
PerseusUtils.WriteDataWithAnnotationColumns(network.EdgeTable, Path.Combine(folder, $"{network.Guid}_edges.txt"));
}
}
public void GetAvailableAnnotsTest()
{
string[] annotFiles = PerseusUtils.GetAnnotFiles();
Assert.Inconclusive("Should be moved to integration tests, using conf");
//[DeploymentItem("conf", "conf")]
string[] baseNames;
string[] files;
string[][] annots = PerseusUtils.GetAvailableAnnots(out baseNames, out files);
Assert.AreEqual(3, files.Length);
Assert.AreEqual(3, baseNames.Length);
Assert.AreEqual(3, annots.Length);
CollectionAssert.AreEqual(new[] { "ENSG", "UniProt", "ENSG" }, baseNames);
CollectionAssert.AreEqual(new[] { "Chromosome", "Base pair index", "Orientation" }, annots[0]);
}
private static string[] GetBaseIds(Parameters para, IDataWithAnnotationColumns mdata)
{
string[] baseNames;
AnnotType[][] types;
string[] files;
PerseusUtils.GetAvailableAnnots(out baseNames, out types, out files);
ParameterWithSubParams <int> spd = para.GetParamWithSubParams <int>("Source");
int ind = spd.Value;
Parameters param = spd.GetSubParameters();
int baseCol = param.GetParam <int>(baseNames[ind] + " column").Value;
string[] baseIds = mdata.StringColumns[baseCol];
return(baseIds);
}
public void ProcessData(IMatrixData data, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] exColInds = param.GetParam <int[]>("Main columns").Value;
int[] numColInds = param.GetParam <int[]>("Numerical columns").Value;
int[] multiNumColInds = param.GetParam <int[]>("Multi-numerical columns").Value;
int[] catColInds = param.GetParam <int[]>("Categorical columns").Value;
int[] textColInds = param.GetParam <int[]>("Text columns").Value;
if (exColInds.Length > 0)
{
int ncol = data.ColumnCount;
data.ExtractColumns(ArrayUtils.Concat(ArrayUtils.ConsecutiveInts(data.ColumnCount), exColInds));
HashSet <string> taken = new HashSet <string>(data.ColumnNames);
for (int i = 0; i < exColInds.Length; i++)
{
string s = PerseusUtils.GetNextAvailableName(data.ColumnNames[ncol + i], taken);
data.ColumnNames[ncol + i] = s;
taken.Add(s);
}
}
foreach (int ind in numColInds)
{
HashSet <string> taken = new HashSet <string>(data.NumericColumnNames);
string s = PerseusUtils.GetNextAvailableName(data.NumericColumnNames[ind], taken);
data.AddNumericColumn(s, data.NumericColumnDescriptions[ind], (double[])data.NumericColumns[ind].Clone());
taken.Add(s);
}
foreach (int ind in multiNumColInds)
{
HashSet <string> taken = new HashSet <string>(data.MultiNumericColumnNames);
string s = PerseusUtils.GetNextAvailableName(data.MultiNumericColumnNames[ind], taken);
data.AddMultiNumericColumn(s, data.MultiNumericColumnDescriptions[ind],
(double[][])data.MultiNumericColumns[ind].Clone());
taken.Add(s);
}
foreach (int ind in catColInds)
{
HashSet <string> taken = new HashSet <string>(data.CategoryColumnNames);
string s = PerseusUtils.GetNextAvailableName(data.CategoryColumnNames[ind], taken);
data.AddCategoryColumn(s, data.CategoryColumnDescriptions[ind], data.GetCategoryColumnAt(ind));
taken.Add(s);
}
foreach (int ind in textColInds)
{
HashSet <string> taken = new HashSet <string>(data.StringColumnNames);
string s = PerseusUtils.GetNextAvailableName(data.StringColumnNames[ind], taken);
data.AddStringColumn(s, data.StringColumnDescriptions[ind], (string[])data.StringColumns[ind].Clone());
taken.Add(s);
}
}
public static ButtonParamWf DataPreviewButton(IMatrixData mdata)
{
return(new ButtonParamWf("Download data for preview", "save", (o, args) =>
{
var dialog = new SaveFileDialog
{
FileName = $"{mdata.Name}.txt",
Filter = "tab-separated data, *.txt|*.txt"
};
if (dialog.ShowDialog() == DialogResult.OK)
{
PerseusUtils.WriteMatrixToFile(mdata, dialog.FileName, false);
}
}));
}
private static int[] GetValids(IMatrixData mdata, int[] colInds, Relation[] relations, bool and)
{
double[][] rows = GetRows(mdata, colInds);
List <int> valids = new List <int>();
for (int i = 0; i < rows.Length; i++)
{
bool valid = PerseusUtils.IsValidRowNumFilter(rows[i], relations, and);
if (valid)
{
valids.Add(i);
}
}
return(valids.ToArray());
}
public void LoadData(IMatrixData mdata, Parameters parameters, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
PerseusLoadMatrixParam par = (PerseusLoadMatrixParam)parameters.GetParam("File");
string filename = par.Filename;
if (string.IsNullOrEmpty(filename))
{
processInfo.ErrString = "Please specify a filename";
return;
}
PerseusUtils.ReadMatrixFromFile(mdata, processInfo, filename, par.MainColumnIndices, par.NumericalColumnIndices,
par.CategoryColumnIndices, par.TextColumnIndices, par.MultiNumericalColumnIndices, par.MainFilterParameters,
par.NumericalFilterParameters, par.ShortenExpressionColumnNames);
}
private static void MakeNewNames(IList <string> newExColNames, IEnumerable <string> mainColumnNames)
{
HashSet <string> taken = new HashSet <string>(mainColumnNames);
for (int i = 0; i < newExColNames.Count; i++)
{
if (taken.Contains(newExColNames[i]))
{
string n1 = PerseusUtils.GetNextAvailableName(newExColNames[i], taken);
newExColNames[i] = n1;
taken.Add(n1);
}
else
{
taken.Add(newExColNames[i]);
}
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents,
ProcessInfo processInfo)
{
var remoteExe = param.GetParam <string>(InterpreterLabel).Value;
if (string.IsNullOrWhiteSpace(remoteExe))
{
processInfo.ErrString = Resources.RemoteExeNotSpecified;
return;
}
var inFile = Path.GetTempFileName();
PerseusUtils.WriteMatrixToFile(mdata, inFile, AdditionalMatrices);
var outFile = Path.GetTempFileName();
if (!TryGetCodeFile(param, out string codeFile))
{
processInfo.ErrString = $"Code file '{codeFile}' was not found";
return;
}
;
if (supplTables == null)
{
supplTables = Enumerable.Range(0, NumSupplTables).Select(i => PerseusFactory.CreateMatrixData()).ToArray();
}
var suppFiles = supplTables.Select(i => Path.GetTempFileName()).ToArray();
var commandLineArguments = GetCommandLineArguments(param);
var args = $"{codeFile} {commandLineArguments} {inFile} {outFile} {string.Join(" ", suppFiles)}";
Debug.WriteLine($"executing > {remoteExe} {args}");
if (Utils.RunProcess(remoteExe, args, processInfo.Status, out string processInfoErrString) != 0)
{
processInfo.ErrString = processInfoErrString;
return;
}
;
mdata.Clear();
PerseusUtils.ReadMatrixFromFile(mdata, processInfo, outFile, '\t');
for (int i = 0; i < NumSupplTables; i++)
{
PerseusUtils.ReadMatrixFromFile(supplTables[i], processInfo, suppFiles[i], '\t');
}
}
private static string[][] GetAvailableTextAnnots(out string[] baseNames, out int[][] inds, out string[] files)
{
AnnotType[][] types;
string[][] annots = PerseusUtils.GetAvailableAnnots(out baseNames, out types, out files);
inds = new int[files.Length][];
for (int i = 0; i < files.Length; i++)
{
List <int> result = new List <int>();
for (int j = 0; j < types[i].Length; j++)
{
if (types[i][j] == AnnotType.Text)
{
result.Add(j);
}
}
inds[i] = result.ToArray();
annots[i] = ArrayUtils.SubArray(annots[i], result);
}
return(annots);
}
