/// <summary>Adds the y-values of a plot item to an array of y-values..</summary>
/// <param name="vArray">The y array to be added to. If null, a new array will be allocated (and filled with the y-values of the plot item).</param>
/// <param name="pdata">The pdata.</param>
/// <returns>If the parameter <paramref name="vArray"/> was not null, then that <paramref name="vArray"/> is returned. Otherwise the newly allocated array is returned.</returns>
public static AltaxoVariant[] AddUp(AltaxoVariant[] vArray, Processed3DPlotData pdata)
{
if (null == pdata)
{
throw new ArgumentNullException(nameof(pdata));
}
if (vArray == null)
{
vArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
vArray[j] = pdata.GetZPhysical(originalIndex);
}
}
else // this is not the first item
{
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
vArray[j] += pdata.GetZPhysical(originalIndex);
}
}
return(vArray);
}
/// <summary>
/// calculates the axis org and end using the databounds
/// the org / end is adjusted only if it is not fixed
/// and the DataBound object contains valid data
/// </summary>
public override void ProcessDataBounds(AltaxoVariant org, bool orgfixed, AltaxoVariant end, bool endfixed)
{
DateTime dorg;
DateTime dend;
if (org.IsType(AltaxoVariant.Content.VDateTime))
{
dorg = (DateTime)org;
}
else if (org.CanConvertedToDouble)
{
dorg = new DateTime((long)(org.ToDouble() * 1E7));
}
else
{
throw new ArgumentException("Variant org is not a DateTime nor a numeric value");
}
if (end.IsType(AltaxoVariant.Content.VDateTime))
{
dend = (DateTime)end;
}
else if (end.CanConvertedToDouble)
{
dend = new DateTime((long)(end.ToDouble() * 1E7));
}
else
{
throw new ArgumentException("Variant end is not a DateTime nor a numeric value");
}
ProcessDataBounds(dorg, orgfixed, dend, endfixed);
}
private void DisplayCrossCoordinatesAndDifference(PointD2D rootLayerCoord)
{
if (_showRootLayerPrintCoordinates)
{
var crossLayerCoord = _cachedActiveLayerTransformation.InverseTransformPoint(_positionOfCrossInRootLayerCoordinates);
var layerCoord = _cachedActiveLayerTransformation.InverseTransformPoint(rootLayerCoord);
Current.DataDisplay.WriteTwoLines(
string.Format("Layer({0}) XS={1} pt, YS={2} pt", _cachedActiveLayer.Name, crossLayerCoord.X, crossLayerCoord.Y),
string.Format("DeltaXS={0} pt, DeltaYS={1} pt, Distance={2} pt", layerCoord.X - crossLayerCoord.X, layerCoord.Y - crossLayerCoord.Y, Calc.RMath.Hypot(layerCoord.X - crossLayerCoord.X, layerCoord.Y - crossLayerCoord.Y))
);
}
else
{
if (CalculateCrossCoordinates(_positionOfCrossInRootLayerCoordinates, out var xphys, out var yphys) && CalculateCrossCoordinates(rootLayerCoord, out var xphys2, out var yphys2))
{
double distance = double.NaN;
AltaxoVariant dx = double.NaN, dy = double.NaN;
try
{
dx = xphys2 - xphys;
dy = yphys2 - yphys;
var r2 = dx * dx + dy * dy;
distance = Math.Sqrt(r2);
}
catch (Exception)
{
}
Current.DataDisplay.WriteTwoLines(
string.Format("Layer({0}) X={1}, Y={2}", _cachedActiveLayer.Name, xphys, yphys),
string.Format("DeltaX={0}, DeltaY={1}, Distance={2}", dx, dy, distance)
);
}
}
}
public static bool TryParseMultipleAltaxoVariant(string s, out AltaxoVariant[] vals)
{
vals = null;
bool failed = false;
string[] parts = s.Split(new char[] { '\t', '\r', '\n', ';' }, StringSplitOptions.RemoveEmptyEntries);
var result = new AltaxoVariant[parts.Length];
for (int i = 0; i < result.Length; i++)
{
if (IsDouble(parts[i], out var dd))
{
result[i] = dd;
}
else if (IsDateTime(parts[i], out var dt))
{
result[i] = dt;
}
else
{
result[i] = parts[i];
}
}
if (failed)
{
return(false);
}
vals = result;
return(true);
}
public CSPlaneID(CSPlaneID from)
{
this._perpendicularAxisNumber = from._perpendicularAxisNumber;
this._logicalValue = from._logicalValue;
this._usePhysicalValue = from._usePhysicalValue;
this._physicalValue = from._physicalValue;
}
/// <summary>
/// calculates the axis org and end using the databounds
/// the org / end is adjusted only if it is not fixed
/// and the DataBound object contains valid data
/// </summary>
public override void ProcessDataBounds(AltaxoVariant org, bool orgfixed, AltaxoVariant end, bool endfixed)
{
double dorg = org.ToDouble();
double dend = end.ToDouble();
ProcessDataBounds(dorg, orgfixed, dend, endfixed);
}
private CSPlaneID(int perpendicularAxisNumer, double logicalValue, bool usePhysicalValue, double physicalValue)
{
_perpendicularAxisNumber = perpendicularAxisNumer;
_logicalValue = logicalValue;
_usePhysicalValue = usePhysicalValue;
_physicalValue = physicalValue;
}
protected override string FormatItem(AltaxoVariant item)
{
if (item.IsType(AltaxoVariant.Content.VDateTime) && !string.IsNullOrEmpty(_formatString))
{
var dt = item.ToDateTime();
switch (_timeConversion)
{
case TimeConversion.ToLocal:
dt = dt.ToLocalTime();
break;
case TimeConversion.ToUtc:
dt = dt.ToUniversalTime();
break;
}
bool showAlternate = false;
showAlternate |= (_showAlternateFormattingAtMidnight && Math.Abs(dt.TimeOfDay.TotalSeconds) < 1);
showAlternate |= (_showAlternateFormattingAtNoon && Math.Abs((dt.TimeOfDay - TimeSpan.FromHours(12)).TotalSeconds) < 1);
try
{
return(string.Format(showAlternate ? _formatStringAlternate : _formatString, dt));
}
catch (Exception)
{
}
}
return(item.ToString());
}
private static void ConvertOrgEndToDateTimeValues(AltaxoVariant org, AltaxoVariant end, out DateTime dorg, out DateTime dend)
{
if (org.IsType(AltaxoVariant.Content.VDateTime))
{
dorg = org;
}
else if (org.CanConvertedToDouble)
{
dorg = new DateTime((long)(org.ToDouble() * 1E7));
}
else
{
throw new ArgumentException("Variant org is not a DateTime nor a numeric value");
}
if (end.IsType(AltaxoVariant.Content.VDateTime))
{
dend = end;
}
else if (end.CanConvertedToDouble)
{
dend = new DateTime((long)(end.ToDouble() * 1E7));
}
else
{
throw new ArgumentException("Variant end is not a DateTime nor a numeric value");
}
}
public void MergeYBoundsInto(IPlotArea layer, IPhysicalBoundaries pb, PlotItemCollection coll)
{
var pbclone = (IPhysicalBoundaries)pb.Clone(); // before we can use CanUseStyle, we have to give physical y boundaries template
CoordinateTransformingStyleBase.MergeYBoundsInto(pbclone, coll);
if (!CanUseStyle(layer, coll, out var plotDataList))
{
pb.Add(pbclone);
return;
}
// we put zero into the y-Boundaries, since the addition starts with that value
pb.Add(new AltaxoVariant(0.0));
AltaxoVariant[] ySumArray = null;
int idx = -1;
foreach (IGPlotItem pi in coll)
{
if (pi is G2DPlotItem)
{
idx++;
var gpi = (G2DPlotItem)pi;
Processed2DPlotData pdata = plotDataList[gpi];
if (null != pdata)
{
// Note: we can not use AddUp function here, since
// when we have positive/negative items, the intermediate bounds
// might be wider than the bounds of the end result
if (ySumArray == null)
{
ySumArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
ySumArray[j] = pdata.GetYPhysical(originalIndex);
pb.Add(ySumArray[j]);
}
}
else // this is not the first item
{
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
ySumArray[j] += pdata.GetYPhysical(originalIndex);
pb.Add(ySumArray[j]);
}
}
}
}
}
}
/// <summary>
/// Determines whether the plot items in <paramref name="coll"/> can be plotted as stack. Presumption is that all plot items
/// have the same number of plot points, and that all items have the same order of x values associated with the plot points.
/// </summary>
/// <param name="layer">Plot layer.</param>
/// <param name="coll">Collection of plot items.</param>
/// <param name="plotDataList">Output: dictionary with associates each plot item with a list of processed plot data.</param>
/// <returns>Returns <c>true</c> if the plot items in <paramref name="coll"/> can be plotted as stack; otherwise, <c>false</c>.</returns>
public static bool CanUseStyle(IPlotArea layer, PlotItemCollection coll, out Dictionary <G3DPlotItem, Processed3DPlotData> plotDataList)
{
plotDataList = new Dictionary <G3DPlotItem, Processed3DPlotData>();
AltaxoVariant[] xArray = null;
AltaxoVariant[] yArray = null;
int idx = -1;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
idx++;
var gpi = (G3DPlotItem)pi;
Processed3DPlotData pdata = gpi.GetRangesAndPoints(layer);
plotDataList.Add(gpi, pdata);
if (xArray == null)
{
xArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
yArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
xArray[j] = pdata.GetXPhysical(originalIndex);
yArray[j] = pdata.GetYPhysical(originalIndex);
}
}
else // this is not the first item
{
if (pdata.RangeList.PlotPointCount != xArray.Length)
{
return(false);
}
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
if (xArray[j] != pdata.GetXPhysical(originalIndex))
{
return(false);
}
if (yArray[j] != pdata.GetYPhysical(originalIndex))
{
return(false);
}
}
}
}
}
return(idx >= 1);
}
public AltaxoVariant Transform(AltaxoVariant value)
{
foreach (var item in _transformations)
{
value = item.Transform(value);
}
return(value);
}
public RangeOfNumericalValues()
{
_lowerValue = 0;
_isLowerInclusive = true;
_upperValue = 1;
_isUpperInclusive = true;
_columnProxy = null;
}
public Logical3D GetLogical3D(AltaxoVariant x, AltaxoVariant y)
{
var shifted = new Logical3D(
_xScale.PhysicalVariantToNormal(x),
_yScale.PhysicalVariantToNormal(y));
return(shifted);
}
public RangeOfNumericalValues(double lower, bool isLowerInclusive, double upper, bool isUpperInclusive, IReadableColumn column)
{
_lowerValue = lower;
_isLowerInclusive = isLowerInclusive;
_upperValue = upper;
_isUpperInclusive = isUpperInclusive;
ChildSetMember(ref _columnProxy, ReadableColumnProxyBase.FromColumn(column));
}
/// <summary>
/// Deserialization constructor. Initializes a new instance of the <see cref="RangeOfNumericalValues"/> class.
/// </summary>
/// <param name="info">The deserialization information.</param>
/// <param name="lower">The lower.</param>
/// <param name="isLowerInclusive">if set to <c>true</c> [is lower inclusive].</param>
/// <param name="upper">The upper.</param>
/// <param name="isUpperInclusive">if set to <c>true</c> [is upper inclusive].</param>
/// <param name="columnProxy">The column.</param>
protected RangeOfNumericalValues(Altaxo.Serialization.Xml.IXmlDeserializationInfo info, double lower, bool isLowerInclusive, double upper, bool isUpperInclusive, IReadableColumnProxy columnProxy)
{
_lowerValue = lower;
_isLowerInclusive = isLowerInclusive;
_upperValue = upper;
_isUpperInclusive = isUpperInclusive;
ChildSetMember(ref _columnProxy, columnProxy);
}
public void PaintPreprocessing(IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
if (!CanUseStyle(layer, coll, out var plotDataDict))
{
return;
}
else
{
paintContext.AddValue(this, plotDataDict);
}
AltaxoVariant[] vSumArray = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
var gpi = pi as G3DPlotItem;
var pdata = plotDataDict[gpi];
vSumArray = AbsoluteStackTransform.AddUp(vSumArray, pdata);
}
}
// now plot the data - the summed up y is in yArray
AltaxoVariant[] vArray = null;
Processed3DPlotData previousItemData = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
var gpi = pi as G3DPlotItem;
var pdata = plotDataDict[gpi];
vArray = AbsoluteStackTransform.AddUp(vArray, pdata);
var localArray = new AltaxoVariant[vArray.Length];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
AltaxoVariant v = 100 * vArray[j] / vSumArray[j];
localArray[j] = v;
var rel = new Logical3D(
layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)),
layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalIndex)),
layer.ZAxis.PhysicalVariantToNormal(v));
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var pabs);
pdata.PlotPointsInAbsoluteLayerCoordinates[j] = pabs;
}
// we have also to exchange the accessor for the physical z value and replace it by our own one
pdata.ZPhysicalAccessor = new IndexedPhysicalValueAccessor(delegate(int i)
{ return(localArray[i]); });
pdata.PreviousItemData = previousItemData;
previousItemData = pdata;
}
}
}
public Logical3D GetLogical3D(AltaxoVariant x, AltaxoVariant y)
{
Logical3D r;
r.RX = XAxis.PhysicalVariantToNormal(x);
r.RY = YAxis.PhysicalVariantToNormal(y);
r.RZ = 0;
return(r);
}
private string DefaultTextConverter(AltaxoVariant x)
{
string s = x.ToString();
s = s.Replace('\r', ' ');
s = s.Replace('\n', ' ');
return(s);
}
void DisplayData(object plotItem, int rowIndex, AltaxoVariant x, AltaxoVariant y)
{
Current.DataDisplay.WriteOneLine(string.Format(
"{0}[{1}] X={2}, Y={3}",
plotItem.ToString(),
rowIndex,
x,
y));
}
public void Paint(System.Drawing.Graphics g, IPlotArea layer, PlotItemCollection coll)
{
System.Drawing.Region[] clippingColl = new System.Drawing.Region[coll.Count];
Processed2DPlotData[] plotDataColl = new Processed2DPlotData[coll.Count];
double[] xincColl = new double[coll.Count];
double[] yincColl = new double[coll.Count];
int idx = -1;
Processed2DPlotData previousPlotData = null;
for (int i = 0; i < coll.Count; i++)
{
if (coll[i] is G2DPlotItem)
{
idx++;
double currxinc = xincColl[i] = idx * _xinc * _scaleXInc;
double curryinc = yincColl[i] = idx * _yinc * _scaleYInc;
G2DPlotItem gpi = coll[i] as G2DPlotItem;
Processed2DPlotData plotdata = plotDataColl[i] = gpi.GetRangesAndPoints(layer);
plotdata.PreviousItemData = previousPlotData;
previousPlotData = plotdata;
int j = -1;
foreach (int rowIndex in plotdata.RangeList.OriginalRowIndices())
{
j++;
AltaxoVariant xx = plotdata.GetXPhysical(rowIndex) + currxinc;
AltaxoVariant yy = plotdata.GetYPhysical(rowIndex) + curryinc;
Logical3D rel = new Logical3D(layer.XAxis.PhysicalVariantToNormal(xx), layer.YAxis.PhysicalVariantToNormal(yy));
double xabs, yabs;
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out xabs, out yabs);
plotdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs);
}
if (_useClipping)
{
GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
}
}
}
for (int i = coll.Count - 1; i >= 0; i--)
{
if (null == plotDataColl[i])
{
coll[i].Paint(g, layer);
}
else
{
TransformedLayerWrapper layerwrapper = new TransformedLayerWrapper(layer, xincColl[i], yincColl[i]);
((G2DPlotItem)coll[i]).Paint(g, layerwrapper, plotDataColl[i]);
}
}
}
public override AltaxoVariant[] GetMinorTicksAsVariant()
{
double[] ticks = GetMinorTicks();
AltaxoVariant[] vticks = new AltaxoVariant[ticks.Length];
for (int i = 0; i < ticks.Length; ++i)
{
vticks[i] = ticks[i];
}
return(vticks);
}
private void DisplayData(object plotItem, int rowIndex, AltaxoVariant x, AltaxoVariant y)
{
Current.DataDisplay.WriteOneLine(string.Format(
"{0}: {1}[{2}] X={3}, Y={4}",
_layer.Name,
plotItem.ToString(),
rowIndex,
x,
y));
}
public override Altaxo.Data.AltaxoVariant[] GetMinorTicksAsVariant()
{
AltaxoVariant[] result = new AltaxoVariant[_dataBounds.NumberOfItems + 1];
for (int i = 0; i < result.Length; i++)
{
result[i] = new Altaxo.Data.AltaxoVariant(i + 0.5);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="RangeOfNumericalValues"/> class.
/// </summary>
/// <param name="from">Instance to copy the values from.</param>
public RangeOfNumericalValues(RangeOfNumericalValues from)
{
_lowerValue = from._lowerValue;
_isLowerInclusive = from._isLowerInclusive;
;
_upperValue = from._upperValue;
_isUpperInclusive = from._isUpperInclusive;
ChildCloneToMember(ref _columnProxy, from._columnProxy);
}
public static CSPlaneID FromPhysicalVariant(int perpendicularAxisNumber, AltaxoVariant physicalValue)
{
#pragma warning disable CS1718 // Comparison made to same variable
if (!(physicalValue == physicalValue))
{
throw new ArgumentException("You can not set physical values that return false when compared to itself, value is: " + physicalValue.ToString());
}
#pragma warning restore CS1718 // Comparison made to same variable
return(new CSPlaneID(perpendicularAxisNumber, double.NaN, true, physicalValue));
}
public override Altaxo.Data.AltaxoVariant[] GetMajorTicksAsVariant()
{
var result = new Altaxo.Data.AltaxoVariant[_dataBounds.NumberOfItems];
for (int i = 0; i < result.Length; i++)
{
result[i] = new AltaxoVariant(_dataBounds.GetItem(i));
}
return(result);
}
public override AltaxoVariant[] GetMajorTicksAsVariant()
{
DateTime[] ticks = GetMajorTicks();
var vticks = new AltaxoVariant[ticks.Length];
for (int i = 0; i < ticks.Length; ++i)
{
vticks[i] = ticks[i];
}
return(vticks);
}
public CSLineID(CSLineID from)
{
this._parallelAxisNumber = from._parallelAxisNumber;
this._logicalValueFirstOther = from._logicalValueFirstOther;
this._usePhysicalValueFirstOther = from._usePhysicalValueFirstOther;
this._physicalValueFirstOther = from._physicalValueFirstOther;
this._logicalValueSecondOther = from._logicalValueSecondOther;
this._usePhysicalValueSecondOther = from._usePhysicalValueSecondOther;
this._physicalValueSecondOther = from._physicalValueSecondOther;
}
protected virtual void UpdateTicksAndOrgEndUsingRescalingObject()
{
if (null == TickSpacing)
{
SetScaleOrgEnd(Rescaling.ResultingOrg, Rescaling.ResultingEnd);
}
else
{
AltaxoVariant org = Rescaling.ResultingOrg, end = Rescaling.ResultingEnd;
TickSpacing.PreProcessScaleBoundaries(ref org, ref end, !Rescaling.IsResultingOrgFixed, !Rescaling.IsResultingEndFixed);
SetScaleOrgEnd(org, end);
TickSpacing.FinalProcessScaleBoundaries(org, end, this);
}
}
public AltaxoVariant Transform(AltaxoVariant value)
{
return -value;
}
public AltaxoVariant Transform(AltaxoVariant value)
{
return Math.Pow(10, value);
}
public Logical3D GetLogical3D(AltaxoVariant x, AltaxoVariant y)
{
Logical3D r;
r.RX = XAxis.PhysicalVariantToNormal(x);
r.RY = YAxis.PhysicalVariantToNormal(y);
r.RZ = 0;
return r;
}
public AltaxoVariant Transform(AltaxoVariant value)
{
return Math.Exp(value);
}
public AltaxoVariant Transform(AltaxoVariant value)
{
return _offset + value;
}
public AltaxoVariant Transform(AltaxoVariant value)
{
return _scale * value;
}
