/// <summary>
/// Constructeur lors de l'ouverture d'un document existant
/// </summary>
/// <param name="model">
/// Modèle associé
/// </param>
/// <param name="fileName">
/// Nom du document géré par ce contrôleur.
/// </param>
public DocumentController(IDocumentData model, string fileName)
{
this.model = model;
totalViews = 0;
isDocumentChanged = false;
DocumentName = fileName;
}
private void Load(IDocumentData data)
{
var flags = FlagsManager.LoadFlags(DefaultMerger.AddDefaults(data.DocumentWideFlags));
this.pageCollection = this.elementFactory.CreatePageCollection(flags);
this.pageCollection.SetCursor(false, this.cursor);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
Random2 rand = new Random2();
double std = param.GetParam<double>("Standard deviation").Value;
int[] inds = param.GetParam<int[]>("Columns").Value;
List<int> mainInds = new List<int>();
List<int> numInds = new List<int>();
foreach (int ind in inds){
if (ind < mdata.ColumnCount){
mainInds.Add(ind);
} else{
numInds.Add(ind - mdata.ColumnCount);
}
}
foreach (int j in mainInds){
for (int i = 0; i < mdata.RowCount; i++){
mdata.Values.Set(i, j, mdata.Values.Get(i, j) + (float) rand.NextGaussian(0, std));
}
}
foreach (int j in numInds){
for (int i = 0; i < mdata.RowCount; i++){
mdata.NumericColumns[j][i] += (float) rand.NextGaussian(0, std);
}
}
}
/// <summary>
/// Sauvegarde le modèle dans le fichier spécifié avec le sérialiseur donné
/// </summary>
/// <param name="model">modèle à sauvegarder</param>
/// <param name="filename">nom du fichier de destination</param>
/// <param name="serializer">sérialiseur utilisé</param>
public static void Save(IDocumentData model, string filename, ISerializer serializer)
{
/*IControlData[] controls = new IControlData[model.ControlsDictionary.Count()];
for(int i=0; i<model.ControlsDictionary.Count(); i++)
{
string key = model.ControlsDictionary.Keys[i];
IControlData control = model.ControlsDictionary[key];
controls[i] = control;
}
string serialization = serializer.Serialize(controls);*/
string[][] test = new string[model.ControlsDictionary.Count][];
ControlDataWrapper[] controls = new ControlDataWrapper[model.ControlsDictionary.Count];
for(int indexControl=0; indexControl<model.ControlsDictionary.Count; indexControl++)
{
string key = model.ControlsDictionary.Keys[indexControl];
SortedList<string, string> properties = model.ControlsDictionary[key].Properties;
PropertyDataWrapper[] listproperties = new PropertyDataWrapper[properties.Count];
test[indexControl] = new string[properties.Count];
for(int indexProperty=0; indexProperty<properties.Count(); indexProperty++)
{
string property = properties.Keys[indexProperty];
string value = properties[property];
listproperties[indexProperty] = new PropertyDataWrapper(property, value);
}
string controlName = model.ControlsDictionary[key].Name;
string controlType = model.ControlsDictionary[key].Type;
controls[indexControl] = new ControlDataWrapper(controlName, controlType, listproperties);
}
string serialization = serializer.Serialize(controls);
ControlDataWrapper[] final = serializer.UnSerialize(serialization);
SaveFile(filename, serialization);
}
public void ValidateFile(string file, IDocumentData doc, Action<int> progress, Action<string> status)
{
TextWriter outstream = doc != null ? new StreamWriter(new DocumentStream(doc)) : Console.Out;
Stream stream = new FileStream(file, FileMode.Open);
ValidateFile(stream, outstream, progress, status);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
const bool rows = false;
bool percentage;
int minValids = PerseusPluginUtils.GetMinValids(param, out percentage);
ParameterWithSubParams<int> modeParam = param.GetParamWithSubParams<int>("Mode");
int modeInd = modeParam.Value;
if (modeInd != 0 && mdata.CategoryRowNames.Count == 0){
processInfo.ErrString = "No grouping is defined.";
return;
}
if (modeInd != 0){
processInfo.ErrString = "Group-wise filtering can only be appled to rows.";
return;
}
FilteringMode filterMode;
double threshold;
double threshold2;
PerseusPluginUtils.ReadValuesShouldBeParams(param, out filterMode, out threshold, out threshold2);
if (modeInd != 0){
//TODO
} else{
PerseusPluginUtils.NonzeroFilter1(rows, minValids, percentage, mdata, param, threshold, threshold2, filterMode);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
Parameter<int> access = param.GetParam<int>("Matrix access");
bool rows = access.Value == 0;
UnitVectors(rows, mdata);
}
public SnapDocumentHelper(IDocumentData documentData, IObjectSpace objectSpace, XafApplication application, CriteriaOperator inPlaceCriteria)
{
this.documentData = documentData;
this.objectSpace = objectSpace;
this.application = application;
this.inPlaceCriteria = inPlaceCriteria;
}
public static void ShowDesigner(IDocumentData documentData, IObjectSpace objectSpace, XafApplication application)
{
SnapDocumentHelper helper = new SnapDocumentHelper(documentData, objectSpace, application);
SnapDesigner designer = new SnapDesigner(helper);
designer.ShowDialog();
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
bool rows = param.GetParam<int>("Matrix access").Value == 0;
double min = param.GetParam<double>("Minimum").Value;
double max = param.GetParam<double>("Maximum").Value;
MapToInterval1(rows, mdata, min, max, processInfo.NumThreads);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
string[] mods = param.GetParam<int[]>("Modifications").StringValue.Split(new[]{';'},
StringSplitOptions.RemoveEmptyEntries);
string[] up = mdata.StringColumns[param.GetParam<int>("Uniprot column").Value];
string[][] uprot = new string[up.Length][];
for (int i = 0; i < up.Length; i++){
uprot[i] = up[i].Length > 0 ? up[i].Split(';') : new string[0];
}
double[][] c = new double[mods.Length][];
for (int index = 0; index < mods.Length; index++){
string mod = mods[index];
string filename = PhosphoSitePlusParser.GetFilenameForMod(mod);
if (filename == null){
processInfo.ErrString = "File does not exist.";
return;
}
string[] seqWins;
string[] accs;
string[] pubmedLtp;
string[] pubmedMs2;
string[] cstMs2;
string[] species;
PhosphoSitePlusParser.ParseKnownMods(filename, out seqWins, out accs, out pubmedLtp, out pubmedMs2, out cstMs2, out species);
for (int i = 0; i < seqWins.Length; i++){
seqWins[i] = seqWins[i].ToUpper();
}
Dictionary<string, HashSet<string>> counts = new Dictionary<string, HashSet<string>>();
for (int i = 0; i < accs.Length; i++){
string acc = accs[i];
if (!counts.ContainsKey(acc)){
counts.Add(acc, new HashSet<string>());
}
counts[acc].Add(seqWins[i]);
}
c[index] = new double[up.Length];
for (int i = 0; i < up.Length; i++){
c[index][i] = CountSites(uprot[i], counts);
}
}
string[][] catCol = new string[up.Length][];
for (int i = 0; i < catCol.Length; i++){
List<string> x = new List<string>();
for (int j = 0; j < mods.Length; j++){
if (c[j][i] > 0){
x.Add(mods[j]);
}
}
x.Sort();
catCol[i] = x.ToArray();
}
mdata.AddCategoryColumn("Known modifications", "Known modifications", catCol);
for (int i = 0; i < mods.Length; i++){
mdata.AddNumericColumn(mods[i] + " count", mods[i] + " count", c[i]);
}
}
private System.Drawing.Image GetImage(IDocumentData documentData, XRect bounds)
{
var source = Source.ParseValue(documentData, null, null, false);
try
{
System.Drawing.Image imageData;
if (File.Exists(source))
{
imageData = System.Drawing.Image.FromFile(source);
}
else if (WebResourceExists(source, out imageData))
{
}
else if (!string.IsNullOrEmpty(source))
{
using (var stream = new MemoryStream(LongStringToBytes(source)))
{
using (var image = System.Drawing.Image.FromStream(stream))
{
imageData = new Bitmap(image.Width, image.Height);
using (var gfx = Graphics.FromImage(imageData))
{
gfx.DrawImage(image, 0, 0, image.Width, image.Height);
}
}
}
}
if (imageData == null)
{
throw new InvalidOperationException($"Cannot generate image data for source '{source}'.");
}
//if (imageData == null)
//{
// imageData = new Bitmap((int)bounds.Width, (int)bounds.Height);
// using (var gfx = Graphics.FromImage(imageData))
// {
// var pen = new Pen(Color.Red);
// gfx.DrawLine(pen, 0, 0, imageData.Width, imageData.Height);
// gfx.DrawLine(pen, imageData.Width, 0, 0, imageData.Height);
// var font = new System.Drawing.Font("Verdana", 10);
// var brush = new SolidBrush(Color.DarkRed);
// gfx.DrawString(string.Format("Image '{0}' is missing.", source), font, brush, 0, 0);
// }
//}
return(imageData);
}
catch (Exception exception)
{
exception.AddData("source", source);
throw;
}
}
public static string ParseValue(this string value, IDocumentData documentData, PageNumberInfo pageNumberInfo, DocumentProperties documentProperties, bool returnErrorMessage = true)
{
if (string.IsNullOrEmpty(value))
{
return(value);
}
//Pick data fields and replace them with correct data
var parsedValue = value;
var startIndex = 0;
var pos = parsedValue.IndexOf("{", startIndex, StringComparison.Ordinal);
while (pos != -1)
{
var posE = parsedValue.IndexOf("}", pos, StringComparison.Ordinal);
var dataName = parsedValue.Substring(pos + 1, posE - pos - 1);
string dataValue = null;
if (pageNumberInfo != null)
{
dataValue = pageNumberInfo.GetPageNumberInfo(dataName);
}
switch (dataName)
{
case "Author":
dataValue = documentProperties.Author;
break;
case "Subject":
dataValue = documentProperties.Subject;
break;
case "Title":
dataValue = documentProperties.Title;
break;
case "Creator":
dataValue = documentProperties.Creator;
break;
}
if (dataValue == null)
{
dataValue = (documentData != null && documentData.Get(dataName) != null) ? documentData.Get(dataName) : (returnErrorMessage ? string.Format("[Data '{0}' is missing]", dataName) : string.Empty);
}
startIndex = pos + dataValue.Length;
parsedValue = string.Format("{0}{1}{2}", parsedValue.Substring(0, pos), dataValue, parsedValue.Substring(posE + 1));
pos = parsedValue.IndexOf("{", startIndex, StringComparison.Ordinal);
}
return(parsedValue.TrimEnd(' '));
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
var vals = param.GetParam<Tuple<Regex, string>>("Regex").Value;
var pattern = vals.Item1;
string replacementStr = vals.Item2;
for (int i = 0; i < mdata.ColumnCount; i++){
mdata.ColumnNames[i] = pattern.Replace(mdata.ColumnNames[i], replacementStr);
}
}
/// <summary>
/// Constructeur
/// </summary>
public SimpleTextView(IDocumentData model, IDocumentController controller)
{
listControls = new SortedList<string, Control>();
availableTypes = new SortedList<string, Type>();
simpleName = "Vue texte simple";
Model = model;
Controller = controller;
InitializeComponent();
Initialize();
model.Change += new EventHandler(OnChange);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
string[] seqWins;
string[] subAccs;
string[] kinases;
string[] kinAccs;
string[] species;
PhosphoSitePlusParser.ParseKinaseSubstrate(out seqWins, out subAccs, out kinases, out kinAccs, out species);
if (seqWins == null){
processInfo.ErrString = "File does not exist.";
return;
}
string[] up = mdata.StringColumns[param.GetParam<int>("Uniprot column").Value];
string[][] uprot = new string[up.Length][];
for (int i = 0; i < up.Length; i++){
uprot[i] = up[i].Length > 0 ? up[i].Split(';') : new string[0];
}
string[] win = mdata.StringColumns[param.GetParam<int>("Sequence window").Value];
Dictionary<string, List<Tuple<string, string, string>>> substrateProperties =
new Dictionary<string, List<Tuple<string, string, string>>>();
for (int i = 0; i < seqWins.Length; i++){
string subAcc = subAccs[i];
if (!substrateProperties.ContainsKey(subAcc)){
substrateProperties.Add(subAcc, new List<Tuple<string, string, string>>());
}
substrateProperties[subAcc].Add(new Tuple<string, string, string>(seqWins[i], kinases[i], kinAccs[i]));
}
string[] kinaseNameColumn = new string[uprot.Length];
string[] kinaseUniprotColumn = new string[uprot.Length];
for (int i = 0; i < kinaseNameColumn.Length; i++){
string[] win1 = AddKnownSites.TransformIl(win[i]).Split(';');
HashSet<string> kinaseNamesHits = new HashSet<string>();
HashSet<string> kinaseUniprotHits = new HashSet<string>();
foreach (string ux in uprot[i]){
if (substrateProperties.ContainsKey(ux)){
List<Tuple<string, string, string>> properties = substrateProperties[ux];
foreach (Tuple<string, string, string> property in properties){
string w = property.Item1;
if (AddKnownSites.Contains(win1, AddKnownSites.TransformIl(w.ToUpper().Substring(1, w.Length - 2)))){
kinaseNamesHits.Add(property.Item2);
kinaseUniprotHits.Add(property.Item3);
}
}
}
}
kinaseNameColumn[i] = kinaseNamesHits.Count > 0 ? StringUtils.Concat(";", ArrayUtils.ToArray(kinaseNamesHits)) : "";
kinaseUniprotColumn[i] = kinaseUniprotHits.Count > 0
? StringUtils.Concat(";", ArrayUtils.ToArray(kinaseUniprotHits))
: "";
}
mdata.AddStringColumn("PhosphoSitePlus kinase", "", kinaseNameColumn);
mdata.AddStringColumn("PhosphoSitePlus kinase uniprot", "", kinaseUniprotColumn);
}
public RenderData(IGraphics graphics, XRect parentBounds, Section section, IDocumentData documentData, PageNumberInfo pageNumberInfo, IDebugData debugData, bool includeBackground, DocumentProperties documentProperties)
{
ParentBounds = parentBounds;
Section = section;
_graphics = graphics;
_documentData = documentData;
PageNumberInfo = pageNumberInfo;
_debugData = debugData;
_includeBackground = includeBackground;
_documentProperties = documentProperties;
}
private void DocumentDataController_ObjectCreating(object sender, ObjectCreatingEventArgs e)
{
if (!e.Cancel && typeof(IDocumentData).IsAssignableFrom(e.ObjectType) &&
Frame.Context != TemplateContext.LookupControl && Frame.Context != TemplateContext.LookupWindow)
{
e.ShowDetailView = false;
IDocumentData documentData = (IDocumentData)e.ObjectSpace.CreateObject(e.ObjectType);
e.NewObject = documentData;
ShowDesigner(documentData, e.ObjectSpace);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
string regexStr = param.GetParam<string>("Regular expression").Value;
Regex regex = new Regex(regexStr);
int[] inds = param.GetParam<int[]>("Columns").Value;
bool keepColumns = param.GetParam<bool>("Keep original columns").Value;
bool semicolons = param.GetParam<bool>("Strings separated by semicolons are independent").Value;
foreach (int col in inds){
ProcessCol(mdata, regex, col, keepColumns, semicolons);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
string colName = param.GetParam<string>("Name of new column").Value;
int[] columns = param.GetParam<int[]>("Categories").Value;
bool inverse = param.GetParam<bool>("Inverse").Value;
int[] catCols;
int[] stringCols;
Split(columns, out catCols, out stringCols, mdata.CategoryColumnCount);
string[] word1 = param.GetParam<string[]>("Search terms").Value;
if (word1.Length == 0){
processInfo.ErrString = "Please specify one or more search terms.";
return;
}
if (string.IsNullOrEmpty(colName)){
colName = word1[0];
}
string[] word = new string[word1.Length];
for (int i = 0; i < word.Length; i++){
word[i] = word1[i].ToLower().Trim();
}
bool[] indicator = new bool[mdata.RowCount];
foreach (int col in catCols){
for (int i = 0; i < mdata.RowCount; i++){
foreach (string s in mdata.GetCategoryColumnEntryAt(col, i)){
foreach (string s1 in word){
if (s.ToLower().Contains(s1)){
indicator[i] = true;
break;
}
}
}
}
}
foreach (string[] txt in stringCols.Select(col => mdata.StringColumns[col])){
for (int i = 0; i < txt.Length; i++){
string s = txt[i];
foreach (string s1 in word){
if (s.ToLower().Contains(s1)){
indicator[i] = true;
break;
}
}
}
}
string[][] newCol = new string[indicator.Length][];
for (int i = 0; i < newCol.Length; i++){
bool yes = inverse ? !indicator[i] : indicator[i];
newCol[i] = yes ? new[]{"+"} : new string[0];
}
mdata.AddCategoryColumn(colName, "", newCol);
}
protected override string GetValue(IDocumentData documentData, PageNumberInfo pageNumberInfo, DocumentProperties documentProperties)
{
if (!string.IsNullOrEmpty(HideValue))
{
var result = documentData.Get(HideValue);
if (string.IsNullOrEmpty(result))
{
return(string.Empty);
}
}
return(Value.ParseValue(documentData, pageNumberInfo, documentProperties));
}
public IMatrixData ProcessData(IMatrixData[] inputData, Parameters parameters, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
IMatrixData mdata1 = inputData[0];
Dictionary<string, string> map = GetMap(inputData[1], parameters);
IMatrixData result = (IMatrixData) mdata1.Clone();
int ind = parameters.GetParam<int>("Column in matrix 1 to be edited").Value;
string[] x = mdata1.StringColumns[ind];
for (int i = 0; i < x.Length; i++){
x[i] = Process(x[i], map);
}
return result;
}
public void InitializeFromModel(IDocumentData model)
{
foreach (string key in model.ControlsDictionary.Keys)
{
IControlData control = model.ControlsDictionary[key];
string[] description = { control.Name, control.Type };
AddControl(description);
foreach (string propertyname in control.Properties.Keys)
{
string[] arguments = { control.Name, propertyname };
ChangeProperty(arguments);
}
}
}
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 = StringUtils.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 ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
string word = param.GetParam<string>("Find what").Value;
int colInd = param.GetParam<int>("Look in").Value;
bool matchCase = param.GetParam<bool>("Match case").Value;
bool matchWholeWord = param.GetParam<bool>("Match whole word").Value;
string scolName = mdata.StringColumnNames[colInd];
string[] scol = mdata.StringColumns[colInd];
string[][] catCol = new string[mdata.RowCount][];
for (int i = 0; i < catCol.Length; i++){
bool found = Find(scol[i], word, matchCase, matchWholeWord);
catCol[i] = found ? new[]{"+"} : new string[0];
}
mdata.AddCategoryColumn("Search: " + scolName, "Search: " + scolName, catCol);
}
public void ProcessData(IMatrixData data, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] numColInds = param.GetParam<int[]>("Numerical rows").Value;
int[] multiNumColInds = param.GetParam<int[]>("Multi-numerical rows").Value;
int[] catColInds = param.GetParam<int[]>("Categorical rows").Value;
int[] textColInds = param.GetParam<int[]>("Text rows").Value;
data.NumericRows = ArrayUtils.SubList(data.NumericRows, numColInds);
data.NumericRowNames = ArrayUtils.SubList(data.NumericRowNames, numColInds);
data.NumericRowDescriptions = ArrayUtils.SubList(data.NumericRowDescriptions, numColInds);
data.MultiNumericRows = ArrayUtils.SubList(data.MultiNumericRows, multiNumColInds);
data.MultiNumericRowNames = ArrayUtils.SubList(data.MultiNumericRowNames, multiNumColInds);
data.MultiNumericRowDescriptions = ArrayUtils.SubList(data.MultiNumericRowDescriptions, multiNumColInds);
data.CategoryRows = PerseusPluginUtils.GetCategoryRows(data, catColInds);
data.CategoryRowNames = ArrayUtils.SubList(data.CategoryRowNames, catColInds);
data.CategoryRowDescriptions = ArrayUtils.SubList(data.CategoryRowDescriptions, catColInds);
data.StringRows = ArrayUtils.SubList(data.StringRows, textColInds);
data.StringRowNames = ArrayUtils.SubList(data.StringRowNames, textColInds);
data.StringRowDescriptions = ArrayUtils.SubList(data.StringRowDescriptions, textColInds);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int stringColumnIndx = param.GetParam<int>("Sequence window").Value;
string[] win = mdata.StringColumns[stringColumnIndx];
int start = param.GetParam<int>("Start").Value - 1;
int length = param.GetParam<int>("Length").Value;
if (start < 0){
processInfo.ErrString = "Start position cannot be smaller than 1.";
return;
}
if (start + length > win[0].Length){
processInfo.ErrString = "Start + length cannot exceed the total length of the sequence.";
return;
}
string[] shortenedMotifs = new string[win.Length];
for (int i = 0; i < mdata.RowCount; ++i){
shortenedMotifs[i] = win[i].Substring(start, length);
}
mdata.AddStringColumn("Short sequence window", "", shortenedMotifs);
}
public static void ShowPrintPreview(IDocumentData documentData, IObjectSpace objectSpace, CriteriaOperator inPlaceCriteria)
{
using (SnapDocumentServer server = new SnapDocumentServer()) {
SnapDocumentHelper helper = new SnapDocumentHelper(documentData, objectSpace, null, inPlaceCriteria);
helper.LoadDocument(server.Document);
// Mail Merge
if (server.Document.DataSources.Count == 1 && server.Options.SnapMailMergeVisualOptions.DataSource == server.Document.DataSources[0].DataSource)
{
using (MemoryStream stream = new MemoryStream()) {
server.SnapMailMerge(stream, SnapDocumentFormat.Snap);
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
server.LoadDocument(stream, SnapDocumentFormat.Snap);
}
}
using (PrintingSystem ps = new PrintingSystem()) {
PrintableComponentLink link = new PrintableComponentLink(ps);
link.Component = server;
link.CreateDocument();
link.ShowPreviewDialog();
}
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
string[][] col = mdata.GetCategoryColumnAt(param.GetParam<int>("Indicator column").Value);
string term = param.GetParam<string>("Value").Value;
List<int> inds = new List<int>();
for (int i = 0; i < col.Length; i++){
if (Contains(col[i], term)){
inds.Add(i);
}
}
double[][] profiles = new double[inds.Count][];
for (int i = 0; i < profiles.Length; i++){
profiles[i] = ArrayUtils.ToDoubles(mdata.Values.GetRow(inds[i]));
float mean = (float) ArrayUtils.Mean(profiles[i]);
for (int j = 0; j < profiles[i].Length; j++){
profiles[i][j] -= mean;
}
}
double[] totalProfile = new double[mdata.ColumnCount];
for (int i = 0; i < totalProfile.Length; i++){
List<double> vals = new List<double>();
foreach (double[] t in profiles){
double val = t[i];
if (double.IsNaN(val) || double.IsInfinity(val)){
continue;
}
vals.Add(val);
}
totalProfile[i] = vals.Count > 0 ? ArrayUtils.Median(vals) : double.NaN;
}
for (int i = 0; i < mdata.RowCount; i++){
for (int j = 0; j < mdata.ColumnCount; j++){
mdata.Values.Set(i, j, mdata.Values.Get(i, j)-(float) totalProfile[j]);
}
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
ParameterWithSubParams<int> p = param.GetParamWithSubParams<int>("Column");
int colInd = p.Value;
if (colInd < 0){
processInfo.ErrString = "No categorical columns available.";
return;
}
Parameter<int[]> mcp = p.GetSubParameters().GetParam<int[]>("Values");
int[] inds = mcp.Value;
if (inds.Length == 0){
processInfo.ErrString = "Please select at least one term for filtering.";
return;
}
string[] values = new string[inds.Length];
string[] v = mdata.GetCategoryColumnValuesAt(colInd);
for (int i = 0; i < values.Length; i++){
values[i] = v[inds[i]];
}
HashSet<string> value = new HashSet<string>(values);
bool remove = param.GetParam<int>("Mode").Value == 0;
List<int> valids = new List<int>();
for (int i = 0; i < mdata.RowCount; i++){
bool valid = true;
foreach (string w in mdata.GetCategoryColumnEntryAt(colInd, i)){
if (value.Contains(w)){
valid = false;
break;
}
}
if ((valid && remove) || (!valid && !remove)){
valids.Add(i);
}
}
PerseusPluginUtils.FilterRows(mdata, param, valids.ToArray());
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int colInd = param.GetParam<int>("Column").Value;
string searchString = param.GetParam<string>("Search string").Value;
if (string.IsNullOrEmpty(searchString)){
processInfo.ErrString = "Please provide a search string";
return;
}
bool remove = param.GetParam<int>("Mode").Value == 0;
bool matchCase = param.GetParam<bool>("Match case").Value;
bool matchWholeWord = param.GetParam<bool>("Match whole word").Value;
string[] vals = mdata.StringColumns[colInd];
List<int> valids = new List<int>();
for (int i = 0; i < vals.Length; i++){
bool matches = Matches(vals[i], searchString, matchCase, matchWholeWord);
if (matches && !remove){
valids.Add(i);
} else if (!matches && remove){
valids.Add(i);
}
}
PerseusPluginUtils.FilterRows(mdata, param, valids.ToArray());
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
const bool rows = true;
bool percentage;
int minValids = PerseusPluginUtils.GetMinValids(param, out percentage);
ParameterWithSubParams<int> modeParam = param.GetParamWithSubParams<int>("Mode");
int modeInd = modeParam.Value;
if (modeInd != 0 && mdata.CategoryRowNames.Count == 0){
processInfo.ErrString = "No grouping is defined.";
return;
}
FilteringMode filterMode;
double threshold;
double threshold2;
PerseusPluginUtils.ReadValuesShouldBeParams(param, out filterMode, out threshold, out threshold2);
if (modeInd != 0){
int gind = modeParam.GetSubParameters().GetParam<int>("Grouping").Value;
string[][] groupCol = mdata.GetCategoryRowAt(gind);
NonzeroFilterGroup(minValids, percentage, mdata, param, modeInd == 2, threshold, threshold2, filterMode, groupCol);
} else{
PerseusPluginUtils.NonzeroFilter1(rows, minValids, percentage, mdata, param, threshold, threshold2, filterMode);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
double width = param.GetParam<double>("Width").Value;
double shift = param.GetParam<double>("Down shift").Value;
bool separateColumns = param.GetParam<int>("Mode").Value == 1;
int[] cols = param.GetParam<int[]>("Columns").Value;
if (cols.Length == 0){
return;
}
if (separateColumns){
ReplaceMissingsByGaussianByColumn(width, shift, mdata, cols);
} else{
string err = ReplaceMissingsByGaussianWholeMatrix(width, shift, mdata, cols);
if (err != null){
processInfo.ErrString = err;
}
}
}
public void ProcessData(IMatrixData data, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
bool falseAreIndicated = param.GetSingleChoiceParam("Indicated are").Value == 0;
int catCol = param.GetSingleChoiceParam("In column").Value;
string word = param.GetStringParam("Indicator").Value;
int[] scoreColumns = param.GetMultiChoiceParam("Scores").Value;
if (scoreColumns.Length == 0){
processInfo.ErrString = "Please specify at least one column with scores.";
return;
}
bool largeIsGood = param.GetBoolParam("Large values are good").Value;
int[] showColumns = param.GetMultiChoiceParam("Display quantity").Value;
if (showColumns.Length == 0){
processInfo.ErrString = "Please select at least one quantity to display";
return;
}
bool[] indCol = GetIndicatorColumn(falseAreIndicated, catCol, word, data);
List<string> expColNames = new List<string>();
List<float[]> expCols = new List<float[]>();
foreach (int scoreColumn in scoreColumns){
double[] vals = scoreColumn < data.NumericColumnCount
? data.NumericColumns[scoreColumn]
: ArrayUtils.ToDoubles(data.GetExpressionColumn(scoreColumn - data.NumericColumnCount));
string name = scoreColumn < data.NumericColumnCount
? data.NumericColumnNames[scoreColumn] : data.ExpressionColumnNames[scoreColumn - data.NumericColumnCount];
int[] order = GetOrder(vals, largeIsGood);
CalcCurve(ArrayUtils.SubArray(indCol, order), showColumns, name, expCols, expColNames);
}
float[,] expData = ToMatrix(expCols);
data.SetData(data.Name, expColNames, expData, new List<string>(), new List<string[]>(), new List<string>(),
new List<string[][]>(), new List<string>(), new List<double[]>(), new List<string>(), new List<double[][]>());
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
SingleChoiceWithSubParams access = param.GetSingleChoiceWithSubParams("Matrix access");
bool rows = access.Value == 0;
int groupInd;
if (rows){
groupInd = access.GetSubParameters().GetSingleChoiceParam("Grouping").Value - 1;
} else{
groupInd = -1;
}
int what = param.GetSingleChoiceParam("Subtract what").Value;
if (groupInd < 0){
SubtractValues(rows, GetFunc(what), mdata, processInfo.NumThreads);
} else{
string[][] catRow = mdata.GetCategoryRowAt(groupInd);
foreach (string[] t in catRow){
if (t.Length > 1){
processInfo.ErrString = "The groups are overlapping.";
return;
}
}
SubtractGroups(mdata, catRow, GetFunc(what));
}
}
public Document(IKeyboardInputProvider keyboardInput, ICursor cursor, IElementFactory elementFactory, ITextScoper textScoper, IDocumentData data)
{
documentCount++;
this.keyboardInput = keyboardInput;
this.keyboardInput.RegisterCallback(this.HandleKeyboardInput);
this.cursor = cursor;
this.elementFactory = elementFactory;
this.textScoper = textScoper;
this.frame = (IButton)Global.FrameProvider.CreateFrame(FrameType.Button, "GHD_Document" + documentCount);
if (data != null)
{
this.Load(data);
}
else
{
this.New();
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
SingleChoiceWithSubParams scwsp = param.GetSingleChoiceWithSubParams("Action");
Parameters spar = scwsp.GetSubParameters();
switch (scwsp.Value){
case 0:
ProcessDataCreate(mdata, spar);
break;
case 1:
ProcessDataEdit(mdata, spar);
break;
case 2:
ProcessDataRename(mdata, spar);
break;
case 3:
ProcessDataDelete(mdata, spar);
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentBuffer"/> class.
/// </summary>
/// <param name="elementFactory"></param>
/// <param name="data"></param>
public DocumentBuffer(IElementFactory elementFactory, ITextScoper textScoper, IDocumentData data = null)
{
// TODO: Init the document deleter
this.Deleter = null;
this.elements = new List <BufferElement>();
this.elementFactory = elementFactory;
this.textScoper = textScoper;
}
internal void CreateNewDocument(SnapDocument document)
{
documentData = (IDocumentData)objectSpace.CreateObject(documentData.GetType());
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] cols = param.GetMultiChoiceParam("Columns").Value;
int truncIndex = param.GetSingleChoiceParam("Use for truncation").Value;
TestTruncation truncation = truncIndex == 0
? TestTruncation.Pvalue : (truncIndex == 1 ? TestTruncation.BenjaminiHochberg : TestTruncation.PermutationBased);
double threshold = param.GetDoubleParam("Threshold value").Value;
int sideInd = param.GetSingleChoiceParam("Side").Value;
TestSide side;
switch (sideInd){
case 0:
side = TestSide.Both;
break;
case 1:
side = TestSide.Left;
break;
case 2:
side = TestSide.Right;
break;
default:
throw new Exception("Never get here.");
}
foreach (int col in cols){
float[] r = mdata.GetExpressionColumn(col);
double[] pvals = CalcSignificanceA(r, side);
string[][] fdr;
switch (truncation){
case TestTruncation.Pvalue:
fdr = PerseusPluginUtils.CalcPvalueSignificance(pvals, threshold);
break;
case TestTruncation.BenjaminiHochberg:
fdr = PerseusPluginUtils.CalcBenjaminiHochbergFdr(pvals, threshold);
break;
default:
throw new Exception("Never get here.");
}
mdata.AddNumericColumn(mdata.ExpressionColumnNames[col] + " Significance A", "", pvals);
mdata.AddCategoryColumn(mdata.ExpressionColumnNames[col] + " A significant", "", fdr);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
if (!mdata.HasQuality){
processInfo.ErrString = "No quality data loaded.";
return;
}
double threshold = param.GetDoubleParam("Threshold").Value;
for (int i = 0; i < mdata.RowCount; i++){
for (int j = 0; j < mdata.ExpressionColumnCount; j++){
float value = mdata.QualityValues[i, j];
if (mdata.QualityBiggerIsBetter){
if (value < threshold){
mdata[i, j] = float.NaN;
}
} else{
if (value > threshold){
mdata[i, j] = float.NaN;
}
}
}
}
}
protected abstract string GetValue(IDocumentData documentData, PageNumberInfo pageNumberInfo, DocumentProperties documentProperties);
public static void ShowPrintPreview(IDocumentData documentData, IObjectSpace objectSpace)
{
ShowPrintPreview(documentData, objectSpace, null);
}
private string GetCode(IDocumentData documentData, PageNumberInfo pageNumberInfo)
{
return(Code.ParseValue(documentData, pageNumberInfo, null));
}
public SnapDocumentHelper(IDocumentData documentData, IObjectSpace objectSpace, XafApplication application)
: this(documentData, objectSpace, application, null)
{
}
public void ProcessData(IMatrixData data, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] exColInds = GetValidExCols(data);
int[] numColInds = GetValidNumCols(data);
int[] multiNumColInds = GetValidMultiNumCols(data);
int[] catColInds = GetValidCatCols(data);
int[] textColInds = GetValidTextCols(data);
if (exColInds.Length < data.ExpressionColumnCount){
data.ExtractExpressionColumns(exColInds);
}
if (numColInds.Length < data.NumericColumnCount){
data.NumericColumns = ArrayUtils.SubList(data.NumericColumns, numColInds);
data.NumericColumnNames = ArrayUtils.SubList(data.NumericColumnNames, numColInds);
data.NumericColumnDescriptions = ArrayUtils.SubList(data.NumericColumnDescriptions, numColInds);
}
if (multiNumColInds.Length < data.MultiNumericColumnCount){
data.MultiNumericColumns = ArrayUtils.SubList(data.MultiNumericColumns, multiNumColInds);
data.MultiNumericColumnNames = ArrayUtils.SubList(data.MultiNumericColumnNames, multiNumColInds);
data.MultiNumericColumnDescriptions = ArrayUtils.SubList(data.MultiNumericColumnDescriptions, multiNumColInds);
}
if (catColInds.Length < data.CategoryColumnCount){
data.CategoryColumns = PerseusPluginUtils.GetCategoryColumns(data, catColInds);
data.CategoryColumnNames = ArrayUtils.SubList(data.CategoryColumnNames, catColInds);
data.CategoryColumnDescriptions = ArrayUtils.SubList(data.CategoryColumnDescriptions, catColInds);
}
if (textColInds.Length < data.StringColumnCount){
data.StringColumns = ArrayUtils.SubList(data.StringColumns, textColInds);
data.StringColumnNames = ArrayUtils.SubList(data.StringColumnNames, textColInds);
data.StringColumnDescriptions = ArrayUtils.SubList(data.StringColumnDescriptions, textColInds);
}
}
private void ShowDesigner(IDocumentData documentData, IObjectSpace objectSpace)
{
objectSpace.Committed += delegate { ObjectSpace.Refresh(); };
SnapDocumentHelper.ShowDesigner(documentData, objectSpace, Application);
}
