/// <summary>
/// Exports a table into an Ascii file.
/// </summary>
/// <param name="filename">The filename used to export the file.</param>
/// <param name="table">The table to export.</param>
/// <param name="separator">The separator char used to export the table. Normally, you should use a tabulator here.</param>
public static void ExportAscii(string filename, Altaxo.Data.DataTable table, char separator)
{
var options = new AsciiExportOptions();
options.SetSeparator(separator);
ExportAscii(filename, table, options);
}
public void EhView_CopyParameterNVV()
{
System.Windows.Forms.DataObject dao = new System.Windows.Forms.DataObject();
Altaxo.Data.TextColumn txt = new Altaxo.Data.TextColumn();
Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn();
Altaxo.Data.DoubleColumn var = new Altaxo.Data.DoubleColumn();
for (int i = 0; i < _doc.CurrentParameters.Count; i++)
{
txt[i] = _doc.CurrentParameters[i].Name;
col[i] = _doc.CurrentParameters[i].Parameter;
var[i] = _doc.CurrentParameters[i].Variance;
}
Altaxo.Data.DataTable tb = new Altaxo.Data.DataTable();
tb.DataColumns.Add(txt, "Name", Altaxo.Data.ColumnKind.V, 0);
tb.DataColumns.Add(col, "Value", Altaxo.Data.ColumnKind.V, 0);
tb.DataColumns.Add(var, "Variance", Altaxo.Data.ColumnKind.V, 0);
Altaxo.Worksheet.Commands.EditCommands.WriteAsciiToClipBoardIfDataCellsSelected(
tb, new Altaxo.Collections.AscendingIntegerCollection(),
new Altaxo.Collections.AscendingIntegerCollection(),
new Altaxo.Collections.AscendingIntegerCollection(),
dao);
System.Windows.Forms.Clipboard.SetDataObject(dao, true);
}
public override void Run(Altaxo.Worksheet.GUI.WorksheetController ctrl)
{
Altaxo.Data.DataTable dataTable = ctrl.DataTable;
if (ctrl.SelectedPropertyColumns.Count == 0)
{
return;
}
m_Column = dataTable.PropertyColumns[ctrl.SelectedPropertyColumns[0]];
IScriptText script = (IScriptText)dataTable.PropertyColumns.ColumnScripts[m_Column];
if (script == null)
{
script = new PropertyColumnScript();
}
object[] args = new object[] { script, new ScriptExecutionHandler(this.EhScriptExecution) };
if (Current.Gui.ShowDialog(args, "PropertyColumnScript of " + m_Column.Name))
{
if (null != dataTable.PropertyColumns.ColumnScripts[m_Column])
{
dataTable.PropertyColumns.ColumnScripts[m_Column] = (IColumnScriptText)args[0];
}
else
{
dataTable.PropertyColumns.ColumnScripts.Add(m_Column, args[0]);
}
}
this.m_Column = null;
}
public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
{
Altaxo.Data.DataTable s = (Altaxo.Data.DataTable)obj;
info.AddValue("Name", s._tableName); // name of the Table
info.AddValue("DataCols", s._dataColumns);
info.AddValue("PropCols", s._propertyColumns); // the property columns of that table
}
public override void Run()
{
var conn = new OriginConnection();
conn.Connect(true);
if (!conn.IsConnected())
return;
var list = new List<Tuple<string, Origin.WorksheetPage>>();
ListAllWorksheetsInFolderAndSubfolders(conn.Application.RootFolder, string.Empty, list);
int count = conn.Application.WorksheetPages.Count;
for (int i = 0; i < list.Count; i++)
{
var path = list[i].Item1;
var page = list[i].Item2;
string name = page.Name;
string lname = page.LongName;
var newTable = new Altaxo.Data.DataTable();
newTable.Name = path + (string.IsNullOrEmpty(lname) ? name : lname);
string err = WorksheetActions.GetTable(page, newTable);
if (null == err)
{
Current.ProjectService.CreateNewWorksheet(newTable);
}
else
{
Current.Gui.ErrorMessageBox(err);
}
}
conn.Disconnect(false, null, false);
}
public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
{
Altaxo.Data.DataTable s = (Altaxo.Data.DataTable)obj;
info.AddValue("Name", s._tableName); // name of the Table
info.AddValue("DataCols", s._dataColumns);
info.AddValue("PropCols", s._propertyColumns); // the property columns of that table
// new in version 1
info.AddValue("TableScript", s._tableScript);
// new in version 2 - Add table properties
int numberproperties = s._tableProperties == null ? 0 : s._tableProperties.Keys.Count;
info.CreateArray("TableProperties", numberproperties);
if (s._tableProperties != null)
{
foreach (string propkey in s._tableProperties.Keys)
{
if (propkey.StartsWith("tmp/"))
{
continue;
}
info.CreateElement("e");
info.AddValue("Key", propkey);
object val = s._tableProperties[propkey];
info.AddValue("Value", info.IsSerializable(val) ? val : null);
info.CommitElement();
}
}
info.CommitArray();
}
/// <summary>
/// Exports a table to Ascii using a stream. The stream is <b>not</b> closed at the end of this function.
/// </summary>
/// <param name="myStream">The stream the table should be exported to.</param>
/// <param name="table">The table that is to be exported.</param>
/// <param name="separator">The separator char that separates the items from each other.</param>
public static void ExportAscii(System.IO.Stream myStream, Altaxo.Data.DataTable table, char separator)
{
var options = new AsciiExportOptions();
options.SetSeparator(separator);
ExportAscii(myStream, table, options);
}
/// <summary>
/// Exports a table into an Ascii file.
/// </summary>
/// <param name="filename">The filename used to export the file.</param>
/// <param name="table">The table to export.</param>
/// <param name="options">The Ascii export options used for export.</param>
public static void ExportAscii(string filename, Altaxo.Data.DataTable table, AsciiExportOptions options)
{
using (var myStream = new System.IO.FileStream(filename, System.IO.FileMode.Create))
{
ExportAscii(myStream, table, options);
myStream.Close();
}
}
public bool ExecuteWithBackgroundDialogAndSuspendNotifications(Altaxo.Data.DataTable myTable)
{
var reporter = new Altaxo.Main.Services.ExternalDrivenBackgroundMonitor();
var t = new System.Threading.Thread(() => ExecuteWithSuspendedNotifications(myTable, reporter));
t.Start();
return(Current.Gui.ShowBackgroundCancelDialog(1000, t, reporter));
}
/// <summary>
/// Exports a table into an Ascii file.
/// </summary>
/// <param name="filename">The filename used to export the file.</param>
/// <param name="table">The table to export.</param>
/// <param name="separator">The separator char used to export the table. Normally, you should use a tabulator here.</param>
static public void ExportAscii(string filename, Altaxo.Data.DataTable table, char separator)
{
System.IO.FileStream myStream = new System.IO.FileStream(filename, System.IO.FileMode.Create);
ExportAscii(myStream, table, separator);
myStream.Close();
}
public void GetObjectData(object obj, System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
{
Altaxo.Data.DataTable s = (Altaxo.Data.DataTable)obj;
info.AddValue("Name", s._tableName); // name of the Table
info.AddValue("DataCols", s.DataColumns); // the data columns of that table
info.AddValue("PropCols", s._propertyColumns); // the property columns of that table
}
/// <summary>
/// Creates a view content for a table.
/// </summary>
/// <param name="table">The table which should be viewed.</param>
/// <returns>The view content for the provided table.</returns>
public Altaxo.Worksheet.GUI.IWorksheetController CreateNewWorksheet(Altaxo.Data.DataTable table)
{
if (table.ParentObject == null)
{
this.CurrentOpenProject.DataTableCollection.Add(table);
}
return(CreateNewWorksheet(table, this.CurrentOpenProject.CreateNewTableLayout(table)));
}
public object SetObjectData(object obj, System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context, System.Runtime.Serialization.ISurrogateSelector selector)
{
Altaxo.Data.DataTable s = (Altaxo.Data.DataTable)obj;
s._tableName = info.GetString("Name");
s._dataColumns = (DataColumnCollection)info.GetValue("DataCols", typeof(DataColumnCollection));
s._propertyColumns = (DataColumnCollection)info.GetValue("PropCols", typeof(DataColumnCollection));
return(s);
}
public static void Duplicate(WorksheetController ctrl)
{
Altaxo.Data.DataTable clonedTable = (Altaxo.Data.DataTable)ctrl.DataTable.Clone();
// find a new name for the cloned table and add it to the DataTableCollection
clonedTable.Name = Data.DataTableCollection.GetParentDataTableCollectionOf(ctrl.DataTable).FindNewTableName();
Data.DataTableCollection.GetParentDataTableCollectionOf(ctrl.DataTable).Add(clonedTable);
Current.ProjectService.CreateNewWorksheet(clonedTable);
}
/// <summary>
/// Creates the controller for the Galactic SPC file export dialog.
/// </summary>
/// <param name="table">The data table which is about to be exported.</param>
/// <param name="selectedRows">The selected rows of the data table.</param>
/// <param name="selectedColumns">The selected columns of the data table.</param>
public ExportGalacticSpcFileDialogController(
Altaxo.Data.DataTable table,
IAscendingIntegerCollection selectedRows,
IAscendingIntegerCollection selectedColumns)
{
m_Table = table;
m_SelectedRows = selectedRows;
m_SelectedColumns = selectedColumns;
InitializeElements();
}
public Altaxo.Worksheet.WorksheetLayout CreateNewTableLayout(Altaxo.Data.DataTable table)
{
if (!_dataTables.Contains(table))
{
_dataTables.Add(table);
}
var layout = new Altaxo.Worksheet.WorksheetLayout(table);
_tableLayouts.Add(layout);
return(layout);
}
public void Remove(Altaxo.Data.DataTable theTable)
{
if (m_TablesByName.ContainsValue(theTable))
{
m_TablesByName.Remove(theTable.Name);
theTable.ParentChanged -= new Main.ParentChangedEventHandler(this.EhTableParentChanged);
theTable.NameChanged -= new Main.NameChangedEventHandler(this.EhTableNameChanged);
theTable.ParentObject = null;
}
this.SelfChanged(ChangedEventArgs.IfTableRemoved);
}
/// <summary>
/// Exports a table to Ascii using a stream. The stream is <b>not</b> closed at the end of this function.
/// </summary>
/// <param name="myStream">The stream the table should be exported to.</param>
/// <param name="table">The table that is to be exported.</param>
/// <param name="separator">The separator char that separates the items from each other.</param>
static public void ExportAscii(System.IO.Stream myStream, Altaxo.Data.DataTable table, char separator)
{
StreamWriter strwr = new StreamWriter(myStream, System.Text.Encoding.Default); // Change to Unicode or quest encoding by a dialog box
ExportDataColumnNames(strwr, table, separator);
ExportPropertyColumns(strwr, table.PropCols, table.DataColumns.ColumnCount, separator);
ExportDataColumns(strwr, table.DataColumns, separator);
strwr.Flush();
}
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
Altaxo.Data.DataTable s = null != o ? (Altaxo.Data.DataTable)o : new Altaxo.Data.DataTable();
s._tableName = info.GetString("Name");
s._dataColumns = (DataColumnCollection)info.GetValue("DataCols", s);
s._dataColumns.ParentObject = s;
s._propertyColumns = (DataColumnCollection)info.GetValue("PropCols", s);
s._propertyColumns.ParentObject = s;
return(s);
}
/// <summary>
/// Executes the script. If no instance of the script object exists, a error message will be stored and the return value is false.
/// If the script object exists, the data change notifications will be switched of (for all tables).
/// Then the Execute function of this script object is called. Afterwards, the data changed notifications are switched on again.
/// </summary>
/// <param name="myTable">The data table this script is working on.</param>
/// <returns>True if executed without exceptions, otherwise false.</returns>
/// <remarks>If exceptions were thrown during execution, the exception messages are stored
/// inside the column script and can be recalled by the Errors property.</remarks>
public bool ExecuteWithSuspendedNotifications(Altaxo.Data.DataTable myTable)
{
bool bSucceeded = true;
Altaxo.Data.DataTableCollection myDataSet = null;
// first, test some preconditions
if (null == m_ScriptObject)
{
m_Errors = new string[1] {
"Script Object is null"
};
return(false);
}
myDataSet = Altaxo.Data.DataTableCollection.GetParentDataTableCollectionOf(myTable);
if (null != myDataSet)
{
myDataSet.Suspend();
}
else if (null != myTable)
{
myTable.Suspend();
}
try
{
((Altaxo.Calc.TableScriptExeBase)m_ScriptObject).Execute(myTable);
}
catch (Exception ex)
{
bSucceeded = false;
m_Errors = new string[1];
m_Errors[0] = ex.ToString();
}
finally
{
if (null != myDataSet)
{
myDataSet.Resume();
}
else if (null != myTable)
{
myTable.Resume();
}
}
return(bSucceeded);
}
public Altaxo.Data.DataTable CreateNewTable(string worksheetName, bool bCreateDefaultColumns)
{
var dt1 = new Altaxo.Data.DataTable(worksheetName);
if (bCreateDefaultColumns)
{
dt1.DataColumns.Add(new Altaxo.Data.DoubleColumn(), "A", Altaxo.Data.ColumnKind.X);
dt1.DataColumns.Add(new Altaxo.Data.DoubleColumn(), "B");
}
DataTableCollection.Add(dt1);
return(dt1);
}
public string GetName(int level)
{
IReadableColumn col = this.Document; // this may have the side effect that the object is tried to resolve, is this o.k.?
if (col is Data.DataColumn)
{
Altaxo.Data.DataTable table = Altaxo.Data.DataTable.GetParentDataTableOf((DataColumn)col);
string tablename = table == null ? string.Empty : table.Name + "\\";
string collectionname = table == null ? string.Empty : (table.PropertyColumns.ContainsColumn((DataColumn)col) ? "PropCols\\" : "DataCols\\");
if (level <= 0)
{
return(((DataColumn)col).Name);
}
else if (level == 1)
{
return(tablename + ((DataColumn)col).Name);
}
else
{
return(tablename + collectionname + ((DataColumn)col).Name);
}
}
else if (base._docNodePath != null)
{
string path = _docNodePath.ToString();
int idx = 0;
if (level <= 0)
{
idx = path.LastIndexOf('/');
if (idx < 0)
{
idx = 0;
}
else
{
idx++;
}
}
return(path.Substring(idx));
}
else if (col != null)
{
return(col.ToString());
}
else
{
return(string.Empty);
}
}
/// <summary>
/// Executes the script. If no instance of the script object exists, a error message will be stored and the return value is false.
/// If the script object exists, the data change notifications will be switched of (for all tables).
/// Then the Execute function of this script object is called. Afterwards, the data changed notifications are switched on again.
/// </summary>
/// <param name="myTable">The data table this script is working on.</param>
/// <param name="reporter">Progress reporter that can be used by the script to report the progress of its work.</param>
/// <returns>True if executed without exceptions, otherwise false.</returns>
/// <remarks>If exceptions were thrown during execution, the exception messages are stored
/// inside the column script and can be recalled by the Errors property.</remarks>
public bool ExecuteWithSuspendedNotifications(Altaxo.Data.DataTable myTable, Altaxo.IProgressReporter reporter)
{
bool bSucceeded = true;
Altaxo.Data.DataTableCollection myDataSet = null;
if (null == _scriptObject && !_wasTriedToCompile)
{
Compile();
}
// first, test some preconditions
if (null == _scriptObject)
{
_errors = ImmutableArray.Create(new CompilerDiagnostic(null, null, DiagnosticSeverity.Error, "Script Object is null"));
return(false);
}
myDataSet = Altaxo.Data.DataTableCollection.GetParentDataTableCollectionOf(myTable);
IDisposable suspendToken = null;
if (null != myDataSet)
{
suspendToken = myDataSet.SuspendGetToken();
}
else if (null != myTable)
{
suspendToken = myTable.SuspendGetToken();
}
try
{
((Altaxo.Calc.TableScriptExeBase)_scriptObject).Execute(myTable, reporter);
}
catch (Exception ex)
{
bSucceeded = false;
_errors = ImmutableArray.Create(new CompilerDiagnostic(null, null, DiagnosticSeverity.Error, ex.ToString()));
}
finally
{
if (null != suspendToken)
{
suspendToken.Dispose();
}
}
return(bSucceeded);
}
/// <summary>
/// Exports to a single SPC spectrum from a single table column.
/// </summary>
/// <param name="filename">The name of the file where to export to.</param>
/// <param name="table">The table from which to export.</param>
/// <param name="columnnumber">The number of the table column that contains the data to export.</param>
/// <param name="xcolumn">The x column that contains the x data.</param>
/// <param name="selectedRows">The rows that where selected in the table, i.e. the rows which are exported. If this parameter is null
/// or no rows are selected, then all data of a column will be exported.</param>
/// <returns>Null if export was successfull, error description otherwise.</returns>
public static string FromColumn(
string filename,
Altaxo.Data.DataTable table,
int columnnumber,
Altaxo.Data.INumericColumn xcolumn,
IAscendingIntegerCollection selectedRows)
{
if (!(table.DataColumns[columnnumber] is Altaxo.Data.INumericColumn))
{
return(string.Format("Table column[{0}] ({1}) is not a numeric column!", columnnumber, table.DataColumns[columnnumber].FullName));
}
// test that all x and y cells have numeric values
bool bUseSel = null != selectedRows && selectedRows.Count > 0;
int spectrumlen = (bUseSel)? selectedRows.Count : table.DataColumns[columnnumber].Count;
int i, j;
for (j = 0; j < spectrumlen; j++)
{
i = bUseSel ? selectedRows[j] : j;
if (xcolumn[i] == Double.NaN)
{
return(string.Format("X column at index {i} has no numeric value!", i));
}
if (((Altaxo.Data.INumericColumn)table.DataColumns[columnnumber])[i] == Double.NaN)
{
return(string.Format("Table cell [{0},{1}] (column {2}) has no numeric value!", columnnumber, i, table.DataColumns[columnnumber].FullName));
}
}
// this first test was successfull, so start exporting now
double[] xvalues = new double[spectrumlen];
double[] yvalues = new double[spectrumlen];
for (j = 0; j < spectrumlen; j++)
{
i = bUseSel ? selectedRows[j] : j;
xvalues[j] = xcolumn[i];
yvalues[j] = ((Altaxo.Data.INumericColumn)table.DataColumns[columnnumber])[i];
}
return(FromArrays(xvalues, yvalues, filename));
}
public static string TwoDimCenteredFFT(Altaxo.AltaxoDocument mainDocument, GUI.WorksheetController dg)
{
int rows = dg.Doc.DataColumns.RowCount;
int cols = dg.Doc.DataColumns.ColumnCount;
// reserve two arrays (one for real part, which is filled with the table contents)
// and the imaginary part - which is left zero here)
double[] rePart;
double[] imPart;
string stringresult = TwoDimFFT(mainDocument, dg, out rePart, out imPart);
if (stringresult != null)
{
return(stringresult);
}
Altaxo.Data.DataTable table = new Altaxo.Data.DataTable("Fourieramplitude of " + dg.Doc.Name);
// Fill the Table so that the zero frequency point is in the middle
// this means for the point order:
// for even number of points, i.e. 8 points, the frequencies are -3, -2, -1, 0, 1, 2, 3, 4 (the frequency 4 is the nyquist part)
// for odd number of points, i.e. 9 points, the frequencies are -4, -3, -2, -1, 0, 1, 2, 3, 4 (for odd number of points there is no nyquist part)
table.Suspend();
int colsNegative = (cols - 1) / 2; // number of negative frequency points
int colsPositive = cols - colsNegative; // number of positive (or null) frequency points
int rowsNegative = (rows - 1) / 2;
int rowsPositive = rows - rowsNegative;
for (int i = 0; i < cols; i++)
{
int sc = i < colsNegative ? i + colsPositive : i - colsNegative;// source column index centered
Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn();
for (int j = 0; j < rows; j++)
{
int sr = j < rowsNegative ? j + rowsPositive : j - rowsNegative; // source row index centered
col[j] = rePart[sc * rows + sr];
}
table.DataColumns.Add(col);
}
table.Resume();
mainDocument.DataTableCollection.Add(table);
// create a new worksheet without any columns
Current.ProjectService.CreateNewWorksheet(table);
return(null);
}
/// <summary>
/// Creates a view content for a table.
/// </summary>
/// <param name="table">The table which should be viewed.</param>
/// <param name="layout">The layout for the table.</param>
/// <returns>The view content for the provided table.</returns>
public Altaxo.Worksheet.GUI.IWorksheetController CreateNewWorksheet(Altaxo.Data.DataTable table, Altaxo.Worksheet.WorksheetLayout layout)
{
layout.DataTable = table;
Altaxo.Gui.SharpDevelop.SDWorksheetViewContent ctrl = new Altaxo.Gui.SharpDevelop.SDWorksheetViewContent(layout);
Altaxo.Worksheet.GUI.WorksheetView view = new Altaxo.Worksheet.GUI.WorksheetView();
ctrl.Controller.View = view;
if (null != Current.Workbench)
{
Current.Workbench.ShowView(ctrl);
}
return(ctrl.Controller);
}
/// <summary>
/// Imports ascii from a memory stream into a table. Returns null (!) if nothing is imported.
/// </summary>
/// <param name="stream">The stream to import ascii from. Is not (!) closed at the end of this function.</param>
/// <returns>The table representation of the imported text, or null if nothing is imported.</returns>
public static Altaxo.Data.DataTable Import(System.IO.Stream stream)
{
Altaxo.Data.DataTable table = new Altaxo.Data.DataTable();
Altaxo.Serialization.Ascii.AsciiImporter importer = new Altaxo.Serialization.Ascii.AsciiImporter(stream);
Altaxo.Serialization.Ascii.AsciiImportOptions options = importer.Analyze(20, new Altaxo.Serialization.Ascii.AsciiImportOptions());
if (options != null)
{
importer.ImportAscii(options, table);
return(table);
}
else
{
return(null);
}
}
/// <summary>
/// Opens a view that shows the table <code>table</code>. If no view for the table can be found,
/// a new default view is created for the table.
/// </summary>
/// <param name="table">The table for which a view must be found.</param>
/// <returns>The view content for the provided table.</returns>
private object OpenOrCreateWorksheetForTable_Unsynchronized(Altaxo.Data.DataTable table)
{
// if a content exist that show that table, activate that content
var foundContent = GetViewContentsForDocument(table).FirstOrDefault();
if (foundContent != null)
{
foundContent.IsVisible = true;
foundContent.IsActive = true;
return(foundContent);
}
// otherwise create a new Worksheet
return(CreateNewWorksheet_Unsynchronized(table));
}
/// <summary>
/// This will create a property column as text column with the names of the data columns.
/// </summary>
/// <param name="table">The data table.</param>
public static void CreatePropertyColumnOfColumnNames(Altaxo.Data.DataTable table)
{
const string NameColumnName = "LongName";
var col = (Altaxo.Data.TextColumn)table.PropertyColumns.EnsureExistence(NameColumnName, typeof(Altaxo.Data.TextColumn), Altaxo.Data.ColumnKind.Label, 0);
using (var suspendToken = col.SuspendGetToken())
{
for (int i = table.DataColumnCount - 1; i >= 0; i--)
{
col[i] = table.DataColumns.GetColumnName(i);
}
suspendToken.Resume();
}
}
/// <summary>
/// Opens a view that shows the table <code>table</code>. If no view for the table can be found,
/// a new default view is created for the table.
/// </summary>
/// <param name="table">The table for which a view must be found.</param>
/// <returns>The view content for the provided table.</returns>
public object OpenOrCreateWorksheetForTable(Altaxo.Data.DataTable table)
{
// if a content exist that show that table, activate that content
List <IViewContent> foundContent = SearchContentForDocument(table, 1);
if (foundContent.Count > 0)
{
foundContent[0].WorkbenchWindow.SelectWindow();
return(foundContent[0]);
}
// otherwise create a new Worksheet
return(CreateNewWorksheet(table));
}
public static void ImportImage(Altaxo.Data.DataTable table)
{
ColorAmplitudeFunction colorfunc;
System.IO.Stream myStream;
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.InitialDirectory = "c:\\";
openFileDialog1.Filter = "Image files (*.bmp;*.jpg;*.png,*.tif)|*.bmp;*.jpg;*.png,*.tif|All files (*.*)|*.*";
openFileDialog1.FilterIndex = 1;
openFileDialog1.RestoreDirectory = true;
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
if ((myStream = openFileDialog1.OpenFile()) != null)
{
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(myStream);
int sizex = bmp.Width;
int sizey = bmp.Height;
//if(Format16bppGrayScale==bmp.PixelFormat)
colorfunc = new ColorAmplitudeFunction(ColorToBrightness);
// add here other function or the result of a dialog box
// now add new columns to the worksheet,
// the name of the columns should preferabbly simply
// the index in x direction
table.Suspend();
for (int i = 0; i < sizex; i++)
{
Altaxo.Data.DoubleColumn dblcol = new Altaxo.Data.DoubleColumn();
for (int j = sizey - 1; j >= 0; j--)
{
dblcol[j] = colorfunc(bmp.GetPixel(i, j));
}
table.DataColumns.Add(dblcol, table.DataColumns.FindUniqueColumnName(i.ToString())); // Spalte hinzufügen
} // end for all x coordinaates
table.Resume();
myStream.Close();
myStream = null;
} // end if myStream was != null
}
}
public virtual void Dispose()
{
var view = ViewObject;
this.ViewObject = null;
if (view is IDisposable)
((IDisposable)view).Dispose();
if (null != _table)
{
_weakTableNameChangedHandler.Remove();
}
_table = null;
_worksheetLayout = null; // removes also the event handler(s)
}
public WorksheetRenameValidator(DataTable table)
: base("The worksheet name must not be empty! Please enter a valid name.")
{
_table = table;
}
public override void Run(Altaxo.Worksheet.GUI.WorksheetController ctrl)
{
m_Table = ctrl.DataTable;
ExtractTableDataScript script = ctrl.DataTable.GetTableProperty(ExtractTableDataScriptPropertyName) as ExtractTableDataScript;
if(script==null)
script = new ExtractTableDataScript();
object[] args = new object[]{script,new ScriptExecutionHandler(this.EhScriptExecution)};
if(Current.Gui.ShowDialog(args, "WorksheetScript of " + m_Table.Name))
{
m_Table.SetTableProperty(ExtractTableDataScriptPropertyName, args[0]);
}
this.m_Table = null;
}
public WorksheetRenameValidator(Altaxo.Data.DataTable tab, WorksheetController ctrl)
: base("The worksheet name must not be empty! Please enter a valid name.")
{
m_Table = tab;
m_Ctrl = ctrl;
}
public void EhView_CopyParameterNVV()
{
System.Windows.Forms.DataObject dao = new System.Windows.Forms.DataObject();
Altaxo.Data.TextColumn txt = new Altaxo.Data.TextColumn();
Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn();
Altaxo.Data.DoubleColumn var = new Altaxo.Data.DoubleColumn();
for (int i = 0; i < _doc.CurrentParameters.Count; i++)
{
txt[i] = _doc.CurrentParameters[i].Name;
col[i] = _doc.CurrentParameters[i].Parameter;
var[i] = _doc.CurrentParameters[i].Variance;
}
Altaxo.Data.DataTable tb = new Altaxo.Data.DataTable();
tb.DataColumns.Add(txt, "Name", Altaxo.Data.ColumnKind.V, 0);
tb.DataColumns.Add(col, "Value", Altaxo.Data.ColumnKind.V, 0);
tb.DataColumns.Add(var, "Variance", Altaxo.Data.ColumnKind.V, 0);
Altaxo.Worksheet.Commands.EditCommands.WriteAsciiToClipBoardIfDataCellsSelected(
tb, new Altaxo.Collections.AscendingIntegerCollection(),
new Altaxo.Collections.AscendingIntegerCollection(),
new Altaxo.Collections.AscendingIntegerCollection(),
dao);
System.Windows.Forms.Clipboard.SetDataObject(dao, true);
}
public WorksheetLayout(Altaxo.Data.DataTable table)
: this()
{
m_DataTable = table;
}
/// <summary>
/// Creates the controller for the Galactic SPC file export dialog.
/// </summary>
/// <param name="table">The data table which is about to be exported.</param>
/// <param name="selectedRows">The selected rows of the data table.</param>
/// <param name="selectedColumns">The selected columns of the data table.</param>
public ExportGalacticSpcFileDialogController(
Altaxo.Data.DataTable table,
IAscendingIntegerCollection selectedRows,
IAscendingIntegerCollection selectedColumns)
{
m_Table = table;
m_SelectedRows = selectedRows;
m_SelectedColumns = selectedColumns;
InitializeElements();
}
protected virtual void InternalInitializeWorksheetLayout(WorksheetLayout value)
{
if (null != _worksheetLayout)
throw new ApplicationException("This controller is already controlling a layout");
if (null != _table)
throw new ApplicationException("This controller is already controlling a table");
if (null == value)
throw new ArgumentNullException("value");
if (null == value.DataTable)
throw new ApplicationException("The DataTable of the WorksheetLayout is null");
_worksheetLayout = value;
_table = _worksheetLayout.DataTable;
var table = _table; // use local variable for anonymous method below
_table.Changed += (_weakTableNameChangedHandler = new WeakEventHandler(this.EhTableNameChanged, x => table.Changed -= x));
OnTitleNameChanged();
}
public static string TwoDimFFT(Altaxo.AltaxoDocument mainDocument, GUI.WorksheetController dg)
{
int rows = dg.Doc.DataColumns.RowCount;
int cols = dg.Doc.DataColumns.ColumnCount;
// reserve two arrays (one for real part, which is filled with the table contents)
// and the imaginary part - which is left zero here)
double[] rePart;
double[] imPart;
string stringresult = TwoDimFFT(mainDocument,dg,out rePart, out imPart);
if(stringresult!=null)
return stringresult;
Altaxo.Data.DataTable table = new Altaxo.Data.DataTable("Fourieramplitude of " + dg.Doc.Name);
// Fill the Table
table.Suspend();
for(int i=0;i<cols;i++)
{
Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn();
for(int j=0;j<rows;j++)
col[j] = rePart[i*rows+j];
table.DataColumns.Add(col);
}
table.Resume();
mainDocument.DataTableCollection.Add(table);
// create a new worksheet without any columns
Current.ProjectService.CreateNewWorksheet(table);
return null;
}
/// <summary>
/// Imports ascii from a memory stream into a table. Returns null (!) if nothing is imported.
/// </summary>
/// <param name="stream">The stream to import ascii from. Is not (!) closed at the end of this function.</param>
/// <returns>The table representation of the imported text, or null if nothing is imported.</returns>
public static Altaxo.Data.DataTable Import(System.IO.Stream stream)
{
Altaxo.Data.DataTable table = new Altaxo.Data.DataTable();
Altaxo.Serialization.Ascii.AsciiImporter importer = new Altaxo.Serialization.Ascii.AsciiImporter(stream);
Altaxo.Serialization.Ascii.AsciiImportOptions options = importer.Analyze(20,new Altaxo.Serialization.Ascii.AsciiImportOptions());
if(options!=null)
{
importer.ImportAscii(options,table);
return table;
}
else
{
return null;
}
}
} // end of function ImportAscii
/// <summary>
/// Imports ascii from a string into a table. Returns null (!) if nothing is imported.
/// </summary>
/// <param name="text">The text to import as ascii.</param>
/// <returns>The table representation of the imported text, or null if nothing is imported.</returns>
public static Altaxo.Data.DataTable Import(string text)
{
System.IO.MemoryStream memstream = new System.IO.MemoryStream();
System.IO.TextWriter textwriter = new System.IO.StreamWriter(memstream);
textwriter.Write(text);
textwriter.Flush();
memstream.Position = 0;
Altaxo.Data.DataTable table = new Altaxo.Data.DataTable();
Altaxo.Serialization.Ascii.AsciiImporter importer = new Altaxo.Serialization.Ascii.AsciiImporter(memstream);
Altaxo.Serialization.Ascii.AsciiImportOptions options = importer.Analyze(20,new Altaxo.Serialization.Ascii.AsciiImportOptions());
if(options!=null)
{
importer.ImportAscii(options,table);
return table;
}
else
{
return null;
}
}
public AltaxoTableConnector(Altaxo.Data.DataTable table)
{
_table = table;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="table">The table.</param>
/// <param name="layout">The layout of the table.</param>
public TablePlusLayout(Altaxo.Data.DataTable table, Altaxo.Worksheet.WorksheetLayout layout)
{
_table = table;
_layout = layout;
}
private void EhCurvePointsCopyTriggered()
{
var points = _view.CurvePoints;
var dao = Current.Gui.GetNewClipboardDataObject();
Altaxo.Data.DoubleColumn xcol = new Altaxo.Data.DoubleColumn();
Altaxo.Data.DoubleColumn ycol = new Altaxo.Data.DoubleColumn();
for (int i = 0; i < points.Count; i++)
{
xcol[i] = new DimensionfulQuantity(points[i].X, Units.Length.Point.Instance).AsValueIn(PositionEnvironment.Instance.DefaultUnit);
ycol[i] = new DimensionfulQuantity(points[i].Y, Units.Length.Point.Instance).AsValueIn(PositionEnvironment.Instance.DefaultUnit);
}
Altaxo.Data.DataTable tb = new Altaxo.Data.DataTable();
tb.DataColumns.Add(xcol, "XPosition", Altaxo.Data.ColumnKind.V, 0);
tb.DataColumns.Add(ycol, "YPosition", Altaxo.Data.ColumnKind.V, 0);
Altaxo.Worksheet.Commands.EditCommands.WriteAsciiToClipBoardIfDataCellsSelected(
tb, new Altaxo.Collections.AscendingIntegerCollection(),
new Altaxo.Collections.AscendingIntegerCollection(),
new Altaxo.Collections.AscendingIntegerCollection(),
dao);
Current.Gui.SetClipboardDataObject(dao, true);
}
public TransposeWorksheetController(Altaxo.Data.DataTable table)
{
_table = table;
}
public static string TwoDimCenteredFFT(Altaxo.AltaxoDocument mainDocument, GUI.WorksheetController dg)
{
int rows = dg.Doc.DataColumns.RowCount;
int cols = dg.Doc.DataColumns.ColumnCount;
// reserve two arrays (one for real part, which is filled with the table contents)
// and the imaginary part - which is left zero here)
double[] rePart;
double[] imPart;
string stringresult = TwoDimFFT(mainDocument,dg,out rePart, out imPart);
if(stringresult!=null)
return stringresult;
Altaxo.Data.DataTable table = new Altaxo.Data.DataTable("Fourieramplitude of " + dg.Doc.Name);
// Fill the Table so that the zero frequency point is in the middle
// this means for the point order:
// for even number of points, i.e. 8 points, the frequencies are -3, -2, -1, 0, 1, 2, 3, 4 (the frequency 4 is the nyquist part)
// for odd number of points, i.e. 9 points, the frequencies are -4, -3, -2, -1, 0, 1, 2, 3, 4 (for odd number of points there is no nyquist part)
table.Suspend();
int colsNegative = (cols-1)/2; // number of negative frequency points
int colsPositive = cols - colsNegative; // number of positive (or null) frequency points
int rowsNegative= (rows-1)/2;
int rowsPositive = rows - rowsNegative;
for(int i=0;i<cols;i++)
{
int sc = i<colsNegative ? i + colsPositive : i - colsNegative; // source column index centered
Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn();
for(int j=0;j<rows;j++)
{
int sr = j<rowsNegative ? j + rowsPositive : j - rowsNegative; // source row index centered
col[j] = rePart[sc*rows+sr];
}
table.DataColumns.Add(col);
}
table.Resume();
mainDocument.DataTableCollection.Add(table);
// create a new worksheet without any columns
Current.ProjectService.CreateNewWorksheet(table);
return null;
}
public override void Run(Altaxo.Worksheet.GUI.WorksheetController ctrl)
{
m_Table = ctrl.DataTable;
IScriptText script = m_Table.TableScript;
if(script==null)
script = new TableScript();
object[] args = new object[]{script,new Altaxo.Gui.Scripting.ScriptExecutionHandler(this.EhScriptExecution)};
if(Current.Gui.ShowDialog(args, "WorksheetScript of " + m_Table.Name))
{
m_Table.TableScript = (TableScript)args[0];
}
this.m_Table = null;
}
public PredictionModelExporter(Altaxo.Data.DataTable table, int numberOfFactors)
{
_table = table;
_memento = table.GetTableProperty("Content") as MultivariateContentMemento;
_numberOfFactors = numberOfFactors;
}
