/// <summary>
/// Pastes data from a table (usually deserialized table from the clipboard) into a worksheet, which has
/// currently selected rows. The number of selected rows has to match the number of rows of the source table.
/// </summary>
/// <param name="dg">The worksheet to paste into.</param>
/// <param name="sourcetable">The table which contains the data to paste into the worksheet.</param>
/// <remarks>The operation is defined as follows: if the is no column selection, the data are inserted beginning at the first column of the destination table.
/// If there is a column selection, the data are inserted in the selected columns, and then in the columns after the last selected columns.
/// No exception is thrown if a column type does not match the corresponding source column type.
/// The columns to paste into do not change their name, kind or group number. Property columns in the source table
/// are pasted into the destination table.</remarks>
protected static void PasteFromTableRowsToSelectedRows(GUI.WorksheetController dg, Altaxo.Data.DataTable sourcetable)
{
Altaxo.Data.DataTable desttable = dg.DataTable;
Altaxo.Data.DataColumn[] propertycolumnmap = MapOrCreatePropertyColumns(desttable, sourcetable);
Altaxo.Data.DataColumn[] destdatacolumnmap = MapOrCreateDataColumns(desttable, dg.SelectedDataColumns, sourcetable);
for (int nCol = 0; nCol < sourcetable.DataColumns.ColumnCount; nCol++)
{
// now fill the data into that column
try
{
int nDestRow = -1;
for (int nSrcRow = 0; nSrcRow < sourcetable.DataColumns.RowCount; nSrcRow++)
{
nDestRow = nSrcRow < dg.SelectedDataRows.Count ? dg.SelectedDataRows[nSrcRow] : nDestRow + 1;
destdatacolumnmap[nCol][nDestRow] = sourcetable.DataColumns[nCol][nSrcRow];
}
}
catch (Exception)
{
}
// also fill in the property values
int nDestColumnIndex = desttable.DataColumns.GetColumnNumber(destdatacolumnmap[nCol]);
FillRow(propertycolumnmap, nDestColumnIndex, sourcetable.PropCols, nCol);
} // for all data columns
}
public static void CopyToClipboard(GUI.WorksheetController dg)
{
Altaxo.Data.DataTable dt = dg.DataTable;
System.Windows.Forms.DataObject dao = new System.Windows.Forms.DataObject();
if (dg.AreDataCellsSelected)
{
WriteAsciiToClipBoardIfDataCellsSelected(dg, dao);
}
else if (dg.ArePropertyCellsSelected && !(dg.AreDataCellsSelected))
{
WriteAsciiToClipBoardIfOnlyPropertyCellsSelected(dg, dao);
}
if (dg.AreColumnsOrRowsSelected)
{
// copy the data as table with the selected columns
Altaxo.Data.DataTable.ClipboardMemento tablememento = new Altaxo.Data.DataTable.ClipboardMemento(
dg.DataTable, dg.SelectedDataColumns, dg.SelectedDataRows, dg.SelectedPropertyColumns, dg.SelectedPropertyRows);
dao.SetData("Altaxo.Data.DataTable.ClipboardMemento", tablememento);
// now copy the data object to the clipboard
System.Windows.Forms.Clipboard.SetDataObject(dao, true);
}
}
/// <summary>
/// Plots the currently selected data columns of a worksheet.
/// </summary>
/// <param name="dg">The worksheet controller where the columns are selected in.</param>
public static void PlotLinePolar(GUI.WorksheetController dg)
{
Altaxo.Graph.Gdi.GraphDocument graph = new Altaxo.Graph.Gdi.GraphDocument();
Altaxo.Graph.Gdi.XYPlotLayer layer = new Altaxo.Graph.Gdi.XYPlotLayer(graph.DefaultLayerPosition, graph.DefaultLayerSize, new Altaxo.Graph.Gdi.CS.G2DPolarCoordinateSystem());
layer.CreateDefaultAxes();
graph.Layers.Add(layer);
Current.Project.GraphDocumentCollection.Add(graph);
IGraphController gc = Plot(dg.DataTable, dg.SelectedDataColumns, graph, PlotStyle_Line, GroupStyle_Color_Line);
}
/// <summary>
/// Writes ASCII to the clipboard if data cells are selected.
/// </summary>
/// <param name="dg">The worksheet controller</param>
/// <param name="dao">The clipboard data object</param>
protected static void WriteAsciiToClipBoardIfDataCellsSelected(GUI.WorksheetController dg, System.Windows.Forms.DataObject dao)
{
// columns are selected
DataTable dt = dg.DataTable;
Altaxo.Collections.AscendingIntegerCollection selCols = dg.SelectedDataColumns;
Altaxo.Collections.AscendingIntegerCollection selRows = dg.SelectedDataRows;
Altaxo.Collections.AscendingIntegerCollection selPropCols = dg.SelectedPropertyColumns;
WriteAsciiToClipBoardIfDataCellsSelected(dt, selCols, selRows, selPropCols, dao);
}
/// <summary>
/// Writes ASCII to the clipboard if only property cells are selected.
/// </summary>
/// <param name="dg">The worksheet controller</param>
/// <param name="dao">The clipboard data object</param>
protected static void WriteAsciiToClipBoardIfOnlyPropertyCellsSelected(GUI.WorksheetController dg, System.Windows.Forms.DataObject dao)
{
// columns are selected
DataTable dt = dg.DataTable;
Altaxo.Collections.AscendingIntegerCollection selCols = dg.SelectedPropertyColumns;
Altaxo.Collections.AscendingIntegerCollection selRows = dg.SelectedPropertyRows;
if (selRows.Count == 0)
{
selRows = new Altaxo.Collections.AscendingIntegerCollection();
selRows.AddRange(0, dg.Doc.PropertyRowCount);
}
System.IO.StringWriter str = new System.IO.StringWriter();
for (int i = 0; i < selRows.Count; i++)
{
for (int j = 0; j < selCols.Count; j++)
{
str.Write(dt.PropertyColumns[selCols[j]][selRows[i]].ToString());
if (j < selCols.Count - 1)
{
str.Write(";");
}
else
{
str.WriteLine();
}
}
}
dao.SetData(System.Windows.Forms.DataFormats.CommaSeparatedValue, str.ToString());
// now also as tab separated text
System.IO.StringWriter sw = new System.IO.StringWriter();
for (int i = 0; i < selRows.Count; i++)
{
for (int j = 0; j < selCols.Count; j++)
{
sw.Write(dt.PropertyColumns[selCols[j]][selRows[i]].ToString());
if (j < selCols.Count - 1)
{
sw.Write("\t");
}
else
{
sw.WriteLine();
}
}
}
dao.SetData(sw.ToString());
}
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);
}
protected static string TwoDimFFT(Altaxo.AltaxoDocument mainDocument, GUI.WorksheetController dg, out double[] rePart, out double[] imPart)
{
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)
rePart = new double[rows * cols];
imPart = new double[rows * cols];
// fill the real part with the table contents
for (int i = 0; i < cols; i++)
{
Altaxo.Data.INumericColumn col = dg.Doc[i] as Altaxo.Data.INumericColumn;
if (null == col)
{
return(string.Format("Can't apply fourier transform, since column number {0}, name:{1} is not numeric", i, dg.Doc[i].FullName));
}
for (int j = 0; j < rows; j++)
{
rePart[i * rows + j] = col[j];
}
}
// test it can be done
if (!Pfa235FFT.CanFactorized(cols))
{
return(string.Format("Can't apply fourier transform, since the number of cols ({0}) are not appropriate for this kind of fourier transform.", cols));
}
if (!Pfa235FFT.CanFactorized(rows))
{
return(string.Format("Can't apply fourier transform, since the number of rows ({0}) are not appropriate for this kind of fourier transform.", rows));
}
// fourier transform
Pfa235FFT fft = new Pfa235FFT(cols, rows);
fft.FFT(rePart, imPart, FourierDirection.Forward);
// replace the real part by the amplitude
for (int i = 0; i < rePart.Length; i++)
{
rePart[i] = Math.Sqrt(rePart[i] * rePart[i] + imPart[i] * imPart[i]);
}
return(null);
}
/// <summary>
/// Pastes data from a table (usually deserialized table from the clipboard) into a worksheet, which has
/// currently selected columns. The number of selected columns has to match the number of columns of the source table.
/// </summary>
/// <param name="dg">The worksheet to paste into.</param>
/// <param name="sourcetable">The table which contains the data to paste into the worksheet.</param>
/// <remarks>The operation is defined as follows: if the is no ro selection, the data are inserted beginning at row[0] of the destination table.
/// If there is a row selection, the data are inserted in the selected rows, and then in the rows after the last selected rows.
/// No exception is thrown if a column type does not match the corresponding source column type.
/// The columns to paste into do not change their name, kind or group number. But property columns in the source table
/// are pasted into the destination table.</remarks>
protected static void PasteFromTableColumnsToSelectedColumns(GUI.WorksheetController dg, Altaxo.Data.DataTable sourcetable)
{
Altaxo.Data.DataTable desttable = dg.DataTable;
Altaxo.Data.DataColumn[] propertycolumnmap = MapOrCreatePropertyColumns(desttable, sourcetable);
// use the selected columns, then use the following columns, then add columns
int nDestCol = -1;
for (int nSrcCol = 0; nSrcCol < sourcetable.DataColumns.ColumnCount; nSrcCol++)
{
nDestCol = nSrcCol < dg.SelectedDataColumns.Count ? dg.SelectedDataColumns[nSrcCol] : nDestCol + 1;
Altaxo.Data.DataColumn destcolumn;
if (nDestCol < desttable.DataColumns.ColumnCount)
{
destcolumn = desttable.DataColumns[nDestCol];
}
else
{
string name = sourcetable.DataColumns.GetColumnName(nSrcCol);
int group = sourcetable.DataColumns.GetColumnGroup(nSrcCol);
Altaxo.Data.ColumnKind kind = sourcetable.DataColumns.GetColumnKind(nSrcCol);
destcolumn = (Altaxo.Data.DataColumn)Activator.CreateInstance(sourcetable.DataColumns[nSrcCol].GetType());
desttable.DataColumns.Add(destcolumn, name, kind, group);
}
// now fill the data into that column
Altaxo.Data.DataColumn sourcecolumn = sourcetable.DataColumns[nSrcCol];
try
{
int nDestRow = -1;
for (int nSrcRow = 0; nSrcRow < sourcetable.DataColumns.RowCount; nSrcRow++)
{
nDestRow = nSrcRow < dg.SelectedDataRows.Count ? dg.SelectedDataRows[nSrcRow] : nDestRow + 1;
destcolumn[nDestRow] = sourcecolumn[nSrcRow];
}
}
catch (Exception)
{
}
// also fill in the property values
int nDestColumnIndex = desttable.DataColumns.GetColumnNumber(destcolumn);
FillRow(propertycolumnmap, nDestColumnIndex, sourcetable.PropCols, nSrcCol);
} // for all data columns
}
public static void PasteFromClipboard(GUI.WorksheetController dg)
{
Altaxo.Data.DataTable dt = dg.DataTable;
System.Windows.Forms.DataObject dao = System.Windows.Forms.Clipboard.GetDataObject() as System.Windows.Forms.DataObject;
string[] formats = dao.GetFormats();
System.Diagnostics.Trace.WriteLine("Available formats:");
//foreach(string format in formats) System.Diagnostics.Trace.WriteLine(format);
if (dao.GetDataPresent("Altaxo.Data.DataTable.ClipboardMemento"))
{
Altaxo.Data.DataTable.ClipboardMemento tablememento = (Altaxo.Data.DataTable.ClipboardMemento)dao.GetData("Altaxo.Data.DataTable.ClipboardMemento");
PasteFromTable(dg, tablememento.DataTable);
return;
}
object clipboardobject = null;
Altaxo.Data.DataTable table = null;
if (dao.GetDataPresent("Csv"))
{
clipboardobject = dao.GetData("Csv");
}
else if (dao.GetDataPresent("Text"))
{
clipboardobject = dao.GetData("Text");
}
if (clipboardobject is System.IO.MemoryStream)
{
table = Altaxo.Serialization.Ascii.AsciiImporter.Import((System.IO.Stream)clipboardobject);
}
else if (clipboardobject is string)
{
table = Altaxo.Serialization.Ascii.AsciiImporter.Import((string)clipboardobject);
}
if (null != table)
{
PasteFromTable(dg, table);
}
}
/// <summary>
/// Plots a density image of the selected columns.
/// </summary>
/// <param name="dg"></param>
/// <param name="bLine"></param>
/// <param name="bScatter"></param>
public static void PlotDensityImage(GUI.WorksheetController dg, bool bLine, bool bScatter)
{
DensityImagePlotStyle plotStyle = new DensityImagePlotStyle();
// if nothing is selected, assume that the whole table should be plotted
int len = dg.SelectedDataColumns.Count;
XYZMeshedColumnPlotData assoc = new XYZMeshedColumnPlotData(dg.Doc.DataColumns, len == 0 ? null : dg.SelectedDataColumns);
// now create a new Graph with this plot associations
Altaxo.Graph.GUI.IGraphController gc = Current.ProjectService.CreateNewGraph();
IGPlotItem pi = new DensityImagePlotItem(assoc, plotStyle);
gc.Doc.Layers[0].PlotItems.Add(pi);
}
/// <summary>
/// Pastes data from a table (usually deserialized table from the clipboard) into a worksheet, which has
/// no current selections. This means that the data are appended to the end of the worksheet.
/// </summary>
/// <param name="dg">The worksheet to paste into.</param>
/// <param name="sourcetable">The table which contains the data to paste into the worksheet.</param>
protected static void PasteFromTableToUnselected(GUI.WorksheetController dg, Altaxo.Data.DataTable sourcetable)
{
Altaxo.Data.DataTable desttable = dg.DataTable;
Altaxo.Data.DataColumn[] propertycolumnmap = MapOrCreatePropertyColumns(desttable, sourcetable);
// add first the data columns to the end of the table
for (int nCol = 0; nCol < sourcetable.DataColumns.ColumnCount; nCol++)
{
string name = sourcetable.DataColumns.GetColumnName(nCol);
int group = sourcetable.DataColumns.GetColumnGroup(nCol);
Altaxo.Data.ColumnKind kind = sourcetable.DataColumns.GetColumnKind(nCol);
Altaxo.Data.DataColumn destcolumn = (Altaxo.Data.DataColumn)sourcetable.DataColumns[nCol].Clone();
desttable.DataColumns.Add(destcolumn, name, kind, group);
// also fill in the property values
int nDestColumnIndex = desttable.DataColumns.GetColumnNumber(destcolumn);
FillRow(propertycolumnmap, nDestColumnIndex, sourcetable.PropCols, nCol);
} // for all data columns
}
/// <summary>
/// Pastes data columns from the source table (usually deserialized table from the clipboard) into rows of the destination table, which has
/// currently selected rows. The number of selected rows has to match the number of columns of the source table.
/// </summary>
/// <param name="dg">The worksheet to paste into.</param>
/// <param name="sourcetable">The table which contains the data to paste into the worksheet.</param>
/// <remarks>The operation is defined as follows: if there is no column selection, the data are inserted beginning at the first column of the destination table.
/// If there is a column selection, the data are inserted in the selected columns, and then in the columns after the last selected columns.
/// No exception is thrown if a cell type does not match the corresponding source cell type.
/// The columns to paste into do not change their name, kind or group number. Property columns in the source table
/// are not used for this operation.</remarks>
protected static void PasteFromTableColumnsToSelectedRows(GUI.WorksheetController dg, Altaxo.Data.DataTable sourcetable)
{
Altaxo.Data.DataTable desttable = dg.DataTable;
Altaxo.Data.DataColumn[] destdatacolumnmap = MapOrCreateDataColumnsToRows(desttable, dg.SelectedDataColumns, sourcetable);
int nDestRow = -1;
for (int nSrcCol = 0; nSrcCol < sourcetable.DataColumns.ColumnCount; nSrcCol++)
{
nDestRow = nSrcCol < dg.SelectedDataRows.Count ? dg.SelectedDataRows[nSrcCol] : nDestRow + 1;
for (int nSrcRow = 0; nSrcRow < sourcetable.DataColumns.RowCount; nSrcRow++)
{
int nDestCol = nSrcRow;
try { destdatacolumnmap[nDestCol][nDestRow] = sourcetable.DataColumns[nSrcCol][nSrcRow]; }
catch (Exception) {}
}
}
}
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>
/// Pastes data from a table (usually deserialized table from the clipboard) into a worksheet.
/// The paste operation depends on the current selection of columns, rows, or property columns.
/// </summary>
/// <param name="dg">The worksheet to paste into.</param>
/// <param name="sourcetable">The table which contains the data to paste into the worksheet.</param>
/// <remarks>The paste operation is defined in the following way:
/// If nothing is currently selected, the columns are appended to the end of the worksheet and the property data
/// are set for that columns.
/// If only columns are currently selected, the data is pasted in that columns (column by column). If number of
/// selected columns not match the number of columns in the paste table, but match the number of rows in the paste table,
/// the paste is done column by row.
///
/// </remarks>
public static void PasteFromTable(GUI.WorksheetController dg, Altaxo.Data.DataTable sourcetable)
{
if (!dg.AreColumnsOrRowsSelected)
{
PasteFromTableToUnselected(dg, sourcetable);
}
else if (dg.SelectedDataColumns.Count > 0 && dg.SelectedDataColumns.Count == sourcetable.DataColumns.ColumnCount)
{
PasteFromTableColumnsToSelectedColumns(dg, sourcetable);
}
else if (dg.SelectedDataColumns.Count > 0 && dg.SelectedDataColumns.Count == sourcetable.DataColumns.RowCount)
{
PasteFromTableRowsToSelectedColumns(dg, sourcetable);
}
else if (dg.SelectedDataRows.Count > 0 && dg.SelectedDataRows.Count == sourcetable.DataColumns.RowCount)
{
PasteFromTableRowsToSelectedRows(dg, sourcetable);
}
else if (dg.SelectedDataRows.Count > 0 && dg.SelectedDataRows.Count == sourcetable.DataColumns.ColumnCount)
{
PasteFromTableColumnsToSelectedRows(dg, sourcetable);
}
else if (dg.SelectedPropertyColumns.Count > 0 && dg.SelectedPropertyColumns.Count == sourcetable.DataColumns.ColumnCount)
{
PasteFromTableColumnsToSelectedPropertyColumns(dg, sourcetable);
}
// now the not exact matches
else if (dg.SelectedDataColumns.Count > 0)
{
PasteFromTableColumnsToSelectedColumns(dg, sourcetable);
}
else if (dg.SelectedDataRows.Count > 0)
{
PasteFromTableRowsToSelectedRows(dg, sourcetable);
}
}
/// <summary>
/// Plots the currently selected data columns of a worksheet as horzizontal bar diagram.
/// </summary>
/// <param name="dg">The worksheet controller where the columns are selected in.</param>
public static void PlotColumnChartRelativeStack(GUI.WorksheetController dg)
{
Plot(dg.DataTable, dg.SelectedDataColumns, PlotStyle_Bar, GroupStyle_RelativeStack_Bar);
}
/// <summary>
/// Plots the currently selected data columns of a worksheet as horzizontal bar diagram.
/// </summary>
/// <param name="dg">The worksheet controller where the columns are selected in.</param>
public static void PlotBarChartRelativeStack(GUI.WorksheetController dg)
{
IGraphController gc = Plot(dg.DataTable, dg.SelectedDataColumns, PlotStyle_Bar, GroupStyle_RelativeStack_Bar);
((G2DCartesicCoordinateSystem)gc.Doc.Layers[0].CoordinateSystem).IsXYInterchanged = true;
}
/// <summary>
/// Plots the currently selected data columns of a worksheet.
/// </summary>
/// <param name="dg">The worksheet controller where the columns are selected in.</param>
public static void PlotLineWaterfall(GUI.WorksheetController dg)
{
Plot(dg.DataTable, dg.SelectedDataColumns, PlotStyle_Line, GroupStyle_Waterfall_Color_Line);
}
/// <summary>
/// Plots the currently selected data columns of a worksheet.
/// </summary>
/// <param name="dg">The worksheet controller where the columns are selected in.</param>
public static void PlotLineRelativeStack(GUI.WorksheetController dg)
{
Plot(dg.DataTable, dg.SelectedDataColumns, PlotStyle_Line, GroupStyle_RelativeStack_Color_Line);
}
/// <summary>
/// Plots the currently selected data columns of a worksheet.
/// </summary>
/// <param name="dg">The worksheet controller where the columns are selected in.</param>
/// <param name="bLine">If true, a line is plotted.</param>
/// <param name="bScatter">If true, scatter symbols are plotted.</param>
public static void PlotLine(GUI.WorksheetController dg, bool bLine, bool bScatter)
{
PlotLine(dg.DataTable, dg.SelectedDataColumns, bLine, bScatter);
}
protected static void PasteFromTableRowsToSelectedColumns(GUI.WorksheetController dg, Altaxo.Data.DataTable sourcetable)
{
PasteFromTableColumnsToSelectedRows(dg, sourcetable);
}
