/// <summary>
/// Template to get a fill path.
/// </summary>
/// <param name="gp">Graphics path to fill with data.</param>
/// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="range">The plot range to use.</param>
/// <param name="layer">Graphics layer.</param>
/// <param name="fillDirection">Designates a bound to fill to.</param>
/// <param name="linePoints">The points that mark the line.</param>
/// <param name="connectCircular">If true, a circular connection is drawn.</param>
private void FillOneRange_PreprocessedPoints(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
PointF[] linePoints,
bool connectCircular,
double logicalShiftX,
double logicalShiftY
)
{
if (connectCircular)
{
gp.AddBeziers(linePoints);
gp.CloseFigure();
}
else
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddBeziers(linePoints);
Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + linePoints.Length - 1));
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
/// <inheritdoc/>
public override void FillOneRange(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
bool ignoreMissingDataPoints,
bool connectCircular,
PointF[] allLinePointsShiftedAlready,
double logicalShiftX,
double logicalShiftY
)
{
if (range.Length < 2)
{
return;
}
PointF[] linePoints = Segment2Connection_GetSubPoints(allLinePointsShiftedAlready, range, layer, connectCircular, out var lastIdx);
if (connectCircular)
{
gp.AddLines(linePoints);
gp.CloseFigure();
}
else
{
int offs = range.LowerBound;
for (int i = 0; i < linePoints.Length - 1; i += 2)
{
Logical3D r0 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i));
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddLine(linePoints[i].X, linePoints[i].Y, linePoints[i + 1].X, linePoints[i + 1].Y);
Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i + 1));
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.StartFigure();
}
gp.CloseFigure();
}
}
/// <inheritdoc/>
public override void FillOneRange(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
bool ignoreMissingDataPoints,
bool connectCircular,
PointF[] allLinePoints,
double logicalShiftX,
double logicalShiftY
)
{
var circularLinePoints = new PointF[range.Length + (connectCircular ? 1 : 0)];
Array.Copy(allLinePoints, range.LowerBound, circularLinePoints, 0, range.Length); // Extract
if (connectCircular)
{
circularLinePoints[circularLinePoints.Length - 1] = circularLinePoints[0];
}
if (connectCircular)
{
gp.AddLines(circularLinePoints);
gp.CloseFigure();
}
else // not circular
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddLines(circularLinePoints);
Logical3D r1 = layer.GetLogical3D(pdata, connectCircular ? range.OriginalFirstPoint : range.OriginalLastPoint);
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
/// <summary>
/// Template to get a fill path.
/// </summary>
/// <param name="gp">Graphics path to fill with data.</param>
/// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="range">The plot range to use.</param>
/// <param name="layer">Graphics layer.</param>
/// <param name="fillDirection">Designates a bound to fill to.</param>
/// <param name="linePoints">The points that mark the line.</param>
/// <param name="connectCircular">If true, a circular connection is drawn.</param>
/// <param name="allLinePointsShiftedAlready">The plot positions, already shifted when a logical shift needed to be applied. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="logicalShiftX">The logical shift in x-direction.</param>
/// <param name="logicalShiftY">The logical shift in x-direction.</param>
public virtual void FillOneRange(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
PointF[] linePoints,
bool connectCircular,
PointF[] allLinePointsShiftedAlready,
double logicalShiftX,
double logicalShiftY
)
{
if (connectCircular)
{
gp.AddLines(linePoints);
gp.CloseFigure();
}
else
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddLines(linePoints);
Logical3D r1 = layer.GetLogical3D(pdata, range.OriginalLastPoint);
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
/// <summary>
/// Shift the plot points provided in <paramref name="pdata"/> with a logical shift in x- and/or y- direction.
/// </summary>
/// <param name="pdata">The plot point position data.</param>
/// <param name="layer">The plot layer for which the data are intended.</param>
/// <param name="logicalShiftX">The logical shift in x-direction.</param>
/// <param name="logicalShiftY">The logical shift in y-direction.</param>
/// <returns>Array of plot point positions, but now shifted by logical values in x-direction (<paramref name="logicalShiftX"/>) and y-direction (<paramref name="logicalShiftY"/>).</returns>
public static PointF[] GetPlotPointsInAbsoluteLayerCoordinatesWithShift(Processed2DPlotData pdata, IPlotArea layer, double logicalShiftX, double logicalShiftY)
{
var result = new PointF[pdata.PlotPointsInAbsoluteLayerCoordinates.Length];
foreach (PlotRange r in pdata.RangeList)
{
int lower = r.LowerBound;
int upper = r.UpperBound;
int offset = r.OffsetToOriginal;
for (int j = lower; j < upper; ++j)
{
int originalRow = j + offset;
Logical3D logicalMean = layer.GetLogical3D(pdata, originalRow);
logicalMean.RX += logicalShiftX;
logicalMean.RY += logicalShiftY;
layer.CoordinateSystem.LogicalToLayerCoordinates(logicalMean, out var x, out var y);
result[j] = new PointF((float)x, (float)y);
}
}
return(result);
}
/// <summary>
/// Template to get a fill path.
/// </summary>
/// <param name="gp">Graphics path to fill with data.</param>
/// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="range">The plot range to use.</param>
/// <param name="layer">Graphics layer.</param>
/// <param name="fillDirection">Designates a bound to fill to.</param>
/// <param name="linePoints">The points that mark the line.</param>
/// <param name="connectCircular">If true, a circular connection is drawn.</param>
/// <param name="allLinePointsShiftedAlready">The plot positions, already shifted when a logical shift needed to be applied. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="logicalShiftX">The logical shift in x-direction.</param>
/// <param name="logicalShiftY">The logical shift in x-direction.</param>
public virtual void FillOneRange(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
PointF[] linePoints,
bool connectCircular,
PointF[] allLinePointsShiftedAlready,
double logicalShiftX,
double logicalShiftY
)
{
if (connectCircular)
{
gp.AddLines(linePoints);
gp.CloseFigure();
}
else
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddLines(linePoints);
Logical3D r1 = layer.GetLogical3D(pdata, range.OriginalLastPoint);
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata)
{
PlotRangeList rangeList = pdata.RangeList;
PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
// adjust the skip frequency if it was not set appropriate
if (_skipFreq <= 0)
_skipFreq = 1;
// paint the drop style
if (this.DropLine.Count>0)
{
foreach (CSPlaneID id in _dropLine)
layer.UpdateCSPlaneID(id);
int rangeidx = 0;
PlotRange range = pdata.RangeList[rangeidx];
for (int j = 0; j < ptArray.Length; j += _skipFreq)
{
// syncronize range
while (j >= range.UpperBound)
{
rangeidx++;
range = pdata.RangeList[rangeidx];
}
Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal);
foreach(CSPlaneID id in _dropLine)
layer.CoordinateSystem.DrawIsolineFromPointToPlane(g,this._pen, r3d, id);
}
} // end paint the drop style
// paint the scatter style
if (this.Shape != XYPlotScatterStyles.Shape.NoSymbol)
{
// save the graphics stat since we have to translate the origin
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
float xpos = 0, ypos = 0;
float xdiff, ydiff;
for (int j = 0; j < ptArray.Length; j += _skipFreq)
{
xdiff = ptArray[j].X - xpos;
ydiff = ptArray[j].Y - ypos;
xpos = ptArray[j].X;
ypos = ptArray[j].Y;
g.TranslateTransform(xdiff, ydiff);
this.Paint(g);
} // end for
g.Restore(gs); // Restore the graphics state
}
}
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData)
{
if (this._labelColumnProxy.Document == null)
return;
if (null != _attachedPlane)
_attachedPlane = layer.UpdateCSPlaneID(_attachedPlane);
PlotRangeList rangeList = pdata.RangeList;
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
Altaxo.Data.IReadableColumn labelColumn = this._labelColumnProxy.Document;
bool isUsingVariableColorForLabelText = null != _cachedColorForIndexFunction && IsColorReceiver;
bool isUsingVariableColorForLabelBackground = null != _cachedColorForIndexFunction &&
(null != _backgroundStyle && _backgroundStyle.SupportsUserDefinedMaterial && (_backgroundColorLinkage == ColorLinkage.Dependent || _backgroundColorLinkage == ColorLinkage.PreserveAlpha));
bool isUsingVariableColor = isUsingVariableColorForLabelText || isUsingVariableColorForLabelBackground;
IMaterial clonedTextBrush = _material;
IMaterial clonedBackBrush = null;
if (isUsingVariableColorForLabelBackground)
clonedBackBrush = _backgroundStyle.Material;
// save the graphics stat since we have to translate the origin
var gs = g.SaveGraphicsState();
double xpos = 0, ypos = 0, zpos = 0;
double xpre, ypre, zpre;
double xdiff, ydiff, zdiff;
bool isFormatStringContainingBraces = _labelFormatString?.IndexOf('{') >= 0;
var culture = System.Threading.Thread.CurrentThread.CurrentCulture;
bool mustUseLogicalCoordinates = null != this._attachedPlane || 0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY || 0 != _cachedLogicalShiftZ;
for (int r = 0; r < rangeList.Count; r++)
{
int lower = rangeList[r].LowerBound;
int upper = rangeList[r].UpperBound;
int offset = rangeList[r].OffsetToOriginal;
for (int j = lower; j < upper; j += _skipFrequency)
{
string label;
if (string.IsNullOrEmpty(_labelFormatString))
{
label = labelColumn[j + offset].ToString();
}
else if (!isFormatStringContainingBraces)
{
label = labelColumn[j + offset].ToString(_labelFormatString, culture);
}
else
{
// the label format string can contain {0} for the label column item, {1} for the row index, {2} .. {4} for the x, y and z component of the data point
label = string.Format(_labelFormatString, labelColumn[j + offset], j + offset, pdata.GetPhysical(0, j + offset), pdata.GetPhysical(1, j + offset), pdata.GetPhysical(2, j + offset));
}
if (string.IsNullOrEmpty(label))
continue;
double localSymbolSize = _symbolSize;
if (null != _cachedSymbolSizeForIndexFunction)
{
localSymbolSize = _cachedSymbolSizeForIndexFunction(j + offset);
}
double localFontSize = _fontSizeOffset + _fontSizeFactor * localSymbolSize;
if (!(localFontSize > 0))
continue;
_font = _font.WithSize(localFontSize);
// Start of preparation of brushes, if a variable color is used
if (isUsingVariableColor)
{
var c = _cachedColorForIndexFunction(j + offset);
if (isUsingVariableColorForLabelText)
{
clonedTextBrush = clonedTextBrush.WithColor(new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e"));
}
if (isUsingVariableColorForLabelBackground)
{
if (_backgroundColorLinkage == ColorLinkage.PreserveAlpha)
clonedBackBrush = clonedBackBrush.WithColor(new NamedColor(AxoColor.FromArgb(clonedBackBrush.Color.Color.A, c.R, c.G, c.B), "e"));
else
clonedBackBrush = clonedBackBrush.WithColor(new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e"));
}
}
// end of preparation of brushes for variable colors
if (mustUseLogicalCoordinates) // we must use logical coordinates because either there is a shift of logical coordinates, or an attached plane
{
Logical3D r3d = layer.GetLogical3D(pdata, j + offset);
r3d.RX += _cachedLogicalShiftX;
r3d.RY += _cachedLogicalShiftY;
r3d.RZ += _cachedLogicalShiftZ;
if (null != this._attachedPlane)
{
var pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane, r3d);
xpre = pp.X;
ypre = pp.Y;
zpre = pp.Z;
}
else
{
PointD3D pt;
layer.CoordinateSystem.LogicalToLayerCoordinates(r3d, out pt);
xpre = pt.X;
ypre = pt.Y;
zpre = pt.Z;
}
}
else // no shifting, thus we can use layer coordinates
{
xpre = ptArray[j].X;
ypre = ptArray[j].Y;
zpre = ptArray[j].Z;
}
xdiff = xpre - xpos;
ydiff = ypre - ypos;
zdiff = zpre - zpos;
xpos = xpre;
ypos = ypre;
zpos = zpre;
g.TranslateTransform(xdiff, ydiff, zdiff);
g.RotateTransform(_rotationX, _rotationY, _rotationZ);
this.Paint(g, label, localSymbolSize, clonedTextBrush, clonedBackBrush);
g.RotateTransform(-_rotationX, -_rotationY, -_rotationZ);
} // end for
}
g.RestoreGraphicsState(gs); // Restore the graphics state
}
/// <summary>
/// Shift the plot points provided in <paramref name="pdata"/> with a logical shift in x- and/or y- direction.
/// </summary>
/// <param name="pdata">The plot point position data.</param>
/// <param name="layer">The plot layer for which the data are intended.</param>
/// <param name="logicalShiftX">The logical shift in x-direction.</param>
/// <param name="logicalShiftY">The logical shift in y-direction.</param>
/// <returns>Array of plot point positions, but now shifted by logical values in x-direction (<paramref name="logicalShiftX"/>) and y-direction (<paramref name="logicalShiftY"/>).</returns>
public static PointF[] GetPlotPointsInAbsoluteLayerCoordinatesWithShift(Processed2DPlotData pdata, IPlotArea layer, double logicalShiftX, double logicalShiftY)
{
var result = new PointF[pdata.PlotPointsInAbsoluteLayerCoordinates.Length];
foreach (PlotRange r in pdata.RangeList)
{
int lower = r.LowerBound;
int upper = r.UpperBound;
int offset = r.OffsetToOriginal;
for (int j = lower; j < upper; ++j)
{
int originalRow = j + offset;
Logical3D logicalMean = layer.GetLogical3D(pdata, originalRow);
logicalMean.RX += logicalShiftX;
logicalMean.RY += logicalShiftY;
double x, y;
layer.CoordinateSystem.LogicalToLayerCoordinates(logicalMean, out x, out y);
result[j] = new PointF((float)x, (float)y);
}
}
return result;
}
protected void PaintXErrorBars(System.Drawing.Graphics g, IPlotArea layer, Altaxo.Graph.Gdi.Plot.Data.Processed2DPlotData pdata)
{
// Plot error bars for the independent variable (x)
PlotRangeList rangeList = pdata.RangeList;
PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
INumericColumn posErrCol = _positiveErrorColumn.Document;
INumericColumn negErrCol = _negativeErrorColumn.Document;
if (posErrCol == null && negErrCol == null)
{
return; // nothing to do if both error columns are null
}
System.Drawing.Drawing2D.GraphicsPath errorBarPath = new System.Drawing.Drawing2D.GraphicsPath();
Region oldClippingRegion = g.Clip;
Region newClip = (Region)oldClippingRegion.Clone();
foreach (PlotRange r in rangeList)
{
int lower = r.LowerBound;
int upper = r.UpperBound;
int offset = r.OffsetToOriginal;
for (int j = lower; j < upper; j++)
{
AltaxoVariant x = pdata.GetXPhysical(j + offset);
Logical3D lm = layer.GetLogical3D(pdata, j + offset);
lm.RX += _cachedLogicalShiftOfIndependent;
if (lm.IsNaN)
{
continue;
}
Logical3D lh = lm;
Logical3D ll = lm;
bool lhvalid = false;
bool llvalid = false;
if (posErrCol != null)
{
lh.RX = layer.XAxis.PhysicalVariantToNormal(x + Math.Abs(posErrCol[j + offset]));
lhvalid = !lh.IsNaN;
}
if (negErrCol != null)
{
ll.RX = layer.XAxis.PhysicalVariantToNormal(x - Math.Abs(negErrCol[j + offset]));
llvalid = !ll.IsNaN;
}
if (!(lhvalid || llvalid))
{
continue; // nothing to do for this point if both pos and neg logical point are invalid.
}
// now paint the error bar
if (_symbolGap) // if symbol gap, then clip the painting, exclude a rectangle of size symbolSize x symbolSize
{
double xlm, ylm;
layer.CoordinateSystem.LogicalToLayerCoordinates(lm, out xlm, out ylm);
newClip.Union(oldClippingRegion);
newClip.Exclude(new RectangleF((float)(xlm - _symbolSize / 2), (float)(ylm - _symbolSize / 2), _symbolSize, _symbolSize));
g.Clip = newClip;
}
if (lhvalid && llvalid)
{
errorBarPath.Reset();
layer.CoordinateSystem.GetIsoline(errorBarPath, ll, lm);
layer.CoordinateSystem.GetIsoline(errorBarPath, lm, lh);
g.DrawPath(_strokePen, errorBarPath);
}
else if (llvalid)
{
layer.CoordinateSystem.DrawIsoline(g, _strokePen, ll, lm);
}
else if (lhvalid)
{
layer.CoordinateSystem.DrawIsoline(g, _strokePen, lm, lh);
}
// now the end bars
if (_showEndBars)
{
if (lhvalid)
{
PointF outDir;
layer.CoordinateSystem.GetNormalizedDirection(lm, lh, 1, new Logical3D(0, 1), out outDir);
outDir.X *= _symbolSize / 2;
outDir.Y *= _symbolSize / 2;
double xlay, ylay;
layer.CoordinateSystem.LogicalToLayerCoordinates(lh, out xlay, out ylay);
// Draw a line from x,y to
g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y));
}
if (llvalid)
{
PointF outDir;
layer.CoordinateSystem.GetNormalizedDirection(lm, ll, 1, new Logical3D(0, 1), out outDir);
outDir.X *= _symbolSize / 2;
outDir.Y *= _symbolSize / 2;
double xlay, ylay;
layer.CoordinateSystem.LogicalToLayerCoordinates(ll, out xlay, out ylay);
// Draw a line from x,y to
g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y));
}
}
}
}
g.Clip = oldClippingRegion;
}
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata)
{
PlotRangeList rangeList = pdata.RangeList;
PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
// adjust the skip frequency if it was not set appropriate
if (_skipFreq <= 0)
{
_skipFreq = 1;
}
// paint the drop style
if (this.DropLine.Count > 0)
{
foreach (CSPlaneID id in _dropLine)
{
layer.UpdateCSPlaneID(id);
}
int rangeidx = 0;
PlotRange range = pdata.RangeList[rangeidx];
for (int j = 0; j < ptArray.Length; j += _skipFreq)
{
// syncronize range
while (j >= range.UpperBound)
{
rangeidx++;
range = pdata.RangeList[rangeidx];
}
Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal);
foreach (CSPlaneID id in _dropLine)
{
layer.CoordinateSystem.DrawIsolineFromPointToPlane(g, this._pen, r3d, id);
}
}
} // end paint the drop style
// paint the scatter style
if (this.Shape != XYPlotScatterStyles.Shape.NoSymbol)
{
// save the graphics stat since we have to translate the origin
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
float xpos = 0, ypos = 0;
float xdiff, ydiff;
for (int j = 0; j < ptArray.Length; j += _skipFreq)
{
xdiff = ptArray[j].X - xpos;
ydiff = ptArray[j].Y - ypos;
xpos = ptArray[j].X;
ypos = ptArray[j].Y;
g.TranslateTransform(xdiff, ydiff);
this.Paint(g);
} // end for
g.Restore(gs); // Restore the graphics state
}
}
/// <inheritdoc/>
public override void FillOneRange(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
bool ignoreMissingDataPoints,
bool connectCircular,
PointF[] allLinePointsShiftedAlready,
double logicalShiftX,
double logicalShiftY
)
{
if (range.Length < 2)
return;
int lastIdx;
PointF[] linePoints = Segment2Connection_GetSubPoints(allLinePointsShiftedAlready, range, layer, connectCircular, out lastIdx);
if (connectCircular)
{
gp.AddLines(linePoints);
gp.CloseFigure();
}
else
{
int offs = range.LowerBound;
for (int i = 0; i < linePoints.Length - 1; i += 2)
{
Logical3D r0 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i));
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddLine(linePoints[i].X, linePoints[i].Y, linePoints[i + 1].X, linePoints[i + 1].Y);
Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i + 1));
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.StartFigure();
}
gp.CloseFigure();
}
}
protected void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata)
{
const double logicalClampMinimum = -10;
const double logicalClampMaximum = 11;
// Plot error bars for the dependent variable (y)
var columnX = ColumnX;
var columnY = ColumnY;
if (columnX == null || columnY == null)
return; // nothing to do if both error columns are null
if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType))
return; // TODO make this an runtime paint error to be reported
var strokePen = _strokePen.Clone();
using (GraphicsPath isoLine = new GraphicsPath())
{
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex);
strokePen.Width = (_lineWidth1Offset + _lineWidth1Factor * symbolSize);
if (null != _cachedColorForIndexFunction)
strokePen.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor");
if (!(strokePen.EndCap is LineCaps.FlatCap))
strokePen.EndCap = strokePen.EndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6);
// Calculate target
AltaxoVariant targetX, targetY;
switch (_meaningOfValues)
{
case ValueInterpretation.AbsoluteDifference:
{
targetX = pdata.GetXPhysical(originalRowIndex) + columnX[originalRowIndex];
targetY = pdata.GetYPhysical(originalRowIndex) + columnY[originalRowIndex];
}
break;
case ValueInterpretation.AbsoluteValue:
{
targetX = columnX[originalRowIndex];
targetY = columnY[originalRowIndex];
}
break;
default:
throw new NotImplementedException(nameof(_meaningOfValues));
}
var logicalTarget = layer.GetLogical3D(targetX, targetY);
var logicalOrigin = layer.GetLogical3D(pdata, originalRowIndex);
if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY))
{
logicalOrigin.RX += _cachedLogicalShiftX;
logicalOrigin.RY += _cachedLogicalShiftY;
logicalTarget.RX += _cachedLogicalShiftX;
logicalTarget.RY += _cachedLogicalShiftY;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RX, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RY, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RZ, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RX, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RY, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RZ, logicalClampMinimum, logicalClampMaximum))
continue;
isoLine.Reset();
layer.CoordinateSystem.GetIsoline(isoLine, logicalOrigin, logicalTarget);
if (null == isoLine)
continue;
PointF[] isoLinePathPoints = null;
if (_useManualVectorLength)
{
isoLine.Flatten();
isoLinePathPoints = isoLine.PathPoints;
double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize;
double isoLineLength = isoLinePathPoints.TotalLineLength();
isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length));
if (null == isoLine)
continue;
}
if (_useSymbolGap)
{
if (null == isoLinePathPoints)
{
isoLine.Flatten();
isoLinePathPoints = isoLine.PathPoints;
}
double gap = _symbolGapOffset + _symbolGapFactor * symbolSize;
if (gap != 0)
{
isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0));
if (null == isoLine)
continue;
}
}
if (null != isoLinePathPoints)
g.DrawLines(_strokePen, isoLinePathPoints);
else
g.DrawPath(strokePen, isoLine);
}
}
}
private void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata)
{
// adjust the skip frequency if it was not set appropriate
if (_skipFrequency <= 0)
{
_skipFrequency = 1;
}
var dropTargets = new List <CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id)));
if (_additionalDropTargetIsEnabled)
{
CSPlaneID userPlane;
if (_additionalDropTargetUsePhysicalBaseValue)
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue));
}
else
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue);
}
dropTargets.Add(userPlane);
}
// paint the scatter style
PointD3D pos = PointD3D.Empty;
var gpath = new GraphicsPath();
if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color
{
// update pen widths
var pen = _pen.Clone();
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
pen.Width = w1;
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex);
r3d.RX += _cachedLogicalShiftX;
r3d.RY += _cachedLogicalShiftY;
foreach (CSPlaneID id in dropTargets)
{
gpath.Reset();
layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id);
PointF[] shortenedPathPoints = null;
if (gapStart != 0 || gapEnd != 0)
{
gpath.Flatten();
var pathPoints = gpath.PathPoints;
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
if (null != shortenedPathPoints)
{
g.DrawLines(pen, shortenedPathPoints);
}
}
else
{
g.DrawPath(pen, gpath);
}
}
}
}
else // using a variable symbol size or variable symbol color
{
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
var pen = _pen.Clone();
if (null == _cachedColorForIndexFunction)
{
_cachedSymbolSize = _cachedSymbolSizeForIndexFunction(originalRowIndex);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
pen.Width = w1;
}
else
{
_cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
var customSymbolColor = _cachedColorForIndexFunction(originalRowIndex);
pen.Width = w1;
pen.Color = NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B);
}
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex);
r3d.RX += _cachedLogicalShiftX;
r3d.RY += _cachedLogicalShiftY;
foreach (CSPlaneID id in _dropTargets)
{
gpath.Reset();
layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id);
PointF[] shortenedPathPoints = null;
if (gapStart != 0 || gapEnd != 0)
{
gpath.Flatten();
var pathPoints = gpath.PathPoints;
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
if (null != shortenedPathPoints)
{
g.DrawLines(pen, shortenedPathPoints);
}
}
else
{
g.DrawPath(pen, gpath);
}
}
}
}
}
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData)
{
PlotRangeList rangeList = pdata.RangeList;
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
// adjust the skip frequency if it was not set appropriate
if (_skipFreq <= 0)
{
_skipFreq = 1;
}
var dropTargets = new List <CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id)));
if (_additionalDropTargetIsEnabled)
{
CSPlaneID userPlane;
if (_additionalDropTargetUsePhysicalBaseValue)
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue));
}
else
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue);
}
dropTargets.Add(userPlane);
}
// paint the scatter style
PointD3D pos = PointD3D.Empty;
if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color
{
var pen = _pen;
// update pen widths
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize;
pen = pen.WithThickness1(w1).WithThickness2(w2);
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
for (int r = 0; r < rangeList.Count; r++)
{
var range = rangeList[r];
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFreq)
{
Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal);
foreach (CSPlaneID id in dropTargets)
{
layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out var isoLine);
if (gapStart != 0 || gapEnd != 0)
{
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
}
if (null != isoLine)
{
g.DrawLine(pen, isoLine);
}
}
}
} // for each range
}
else // using a variable symbol size or variable symbol color
{
for (int r = 0; r < rangeList.Count; r++)
{
var range = rangeList[r];
int lower = range.LowerBound;
int upper = range.UpperBound;
int offset = range.OffsetToOriginal;
for (int j = lower; j < upper; j += _skipFreq)
{
var pen = _pen;
if (null == _cachedColorForIndexFunction)
{
_cachedSymbolSize = _cachedSymbolSizeForIndexFunction(j + offset);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize;
pen = _pen.WithThickness1(w1).WithThickness2(w2);
}
else
{
_cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(j + offset);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize;
var customSymbolColor = _cachedColorForIndexFunction(j + offset);
pen = _pen.WithThickness1(w1).WithThickness2(w2).WithColor(NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B));
}
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
Logical3D r3d = layer.GetLogical3D(pdata, j + rangeList[r].OffsetToOriginal);
foreach (CSPlaneID id in _dropTargets)
{
layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out var isoLine);
if (gapStart != 0 || gapEnd != 0)
{
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
}
if (null != isoLine)
{
g.DrawLine(pen, isoLine);
}
}
}
}
}
}
private void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata)
{
// adjust the skip frequency if it was not set appropriate
if (_skipFrequency <= 0)
_skipFrequency = 1;
var dropTargets = new List<CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id)));
if (_additionalDropTargetIsEnabled)
{
CSPlaneID userPlane;
if (_additionalDropTargetUsePhysicalBaseValue)
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue));
}
else
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue);
}
dropTargets.Add(userPlane);
}
// paint the scatter style
PointD3D pos = PointD3D.Empty;
var gpath = new GraphicsPath();
if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color
{
// update pen widths
var pen = _pen.Clone();
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
pen.Width = w1;
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex);
r3d.RX += _cachedLogicalShiftX;
r3d.RY += _cachedLogicalShiftY;
foreach (CSPlaneID id in dropTargets)
{
gpath.Reset();
layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id);
PointF[] shortenedPathPoints = null;
if (gapStart != 0 || gapEnd != 0)
{
gpath.Flatten();
var pathPoints = gpath.PathPoints;
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
if (null != shortenedPathPoints)
g.DrawLines(pen, shortenedPathPoints);
}
else
{
g.DrawPath(pen, gpath);
}
}
}
}
else // using a variable symbol size or variable symbol color
{
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
var pen = _pen.Clone();
if (null == _cachedColorForIndexFunction)
{
_cachedSymbolSize = _cachedSymbolSizeForIndexFunction(originalRowIndex);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
pen.Width = w1;
}
else
{
_cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
var customSymbolColor = _cachedColorForIndexFunction(originalRowIndex);
pen.Width = w1;
pen.Color = NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B);
}
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex);
r3d.RX += _cachedLogicalShiftX;
r3d.RY += _cachedLogicalShiftY;
foreach (CSPlaneID id in _dropTargets)
{
gpath.Reset();
layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id);
PointF[] shortenedPathPoints = null;
if (gapStart != 0 || gapEnd != 0)
{
gpath.Flatten();
var pathPoints = gpath.PathPoints;
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
if (null != shortenedPathPoints)
g.DrawLines(pen, shortenedPathPoints);
}
else
{
g.DrawPath(pen, gpath);
}
}
}
}
}
public void Paint(Graphics g,
IPlotArea layer,
Processed2DPlotData pdata)
{
if (this._labelColumn.Document == null)
{
return;
}
if (null != _attachedPlane)
{
layer.UpdateCSPlaneID(_attachedPlane);
}
PlotRangeList rangeList = pdata.RangeList;
PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
Altaxo.Data.IReadableColumn labelColumn = this._labelColumn.Document;
// save the graphics stat since we have to translate the origin
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
/*
* double bottomPosition = 0;
* double topPosition = 0;
* double leftPosition = 0;
* double rightPosition = 0;
*
* layer.CoordinateSystem.LogicalToLayerCoordinates(0, 0, out leftPosition, out bottomPosition);
* layer.CoordinateSystem.LogicalToLayerCoordinates(1, 1, out rightPosition, out topPosition);
*/
double xpos = 0, ypos = 0;
double xpre, ypre;
double xdiff, ydiff;
for (int r = 0; r < rangeList.Count; r++)
{
int lower = rangeList[r].LowerBound;
int upper = rangeList[r].UpperBound;
int offset = rangeList[r].OffsetToOriginal;
for (int j = lower; j < upper; j++)
{
string label = labelColumn[j + offset].ToString();
if (label == null || label == string.Empty)
{
continue;
}
xpre = ptArray[j].X;
ypre = ptArray[j].Y;
if (null != this._attachedPlane)
{
Logical3D r3d = layer.GetLogical3D(pdata, j + offset);
PointF pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane, r3d);
xpre = pp.X;
ypre = pp.Y;
}
xdiff = xpre - xpos;
ydiff = ypre - ypos;
xpos = xpre;
ypos = ypre;
g.TranslateTransform((float)xdiff, (float)ydiff);
if (this._rotation != 0)
{
g.RotateTransform((float)-this._rotation);
}
this.Paint(g, label);
if (this._rotation != 0)
{
g.RotateTransform((float)this._rotation);
}
} // end for
}
g.Restore(gs); // Restore the graphics state
}
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData)
{
const double logicalClampMinimum = -10;
const double logicalClampMaximum = 11;
// Plot error bars for the dependent variable (y)
PlotRangeList rangeList = pdata.RangeList;
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
var columnX = ColumnX;
var columnY = ColumnY;
var columnZ = ColumnZ;
if (columnX == null || columnY == null || columnZ == null)
return; // nothing to do if both error columns are null
if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType) || !typeof(double).IsAssignableFrom(columnZ.ItemType))
return; // TODO make this an runtime paint error to be reported
var strokePen = _strokePen;
foreach (PlotRange r in rangeList)
{
int lower = r.LowerBound;
int upper = r.UpperBound;
int offset = r.OffsetToOriginal;
for (int j = lower; j < upper; j += _skipFrequency)
{
int originalRow = j + offset;
double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRow);
strokePen = strokePen.WithThickness1(_lineWidth1Offset + _lineWidth1Factor * symbolSize);
strokePen = strokePen.WithThickness2(_lineWidth2Offset + _lineWidth2Factor * symbolSize);
if (null != _cachedColorForIndexFunction)
strokePen = strokePen.WithColor(GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRow), "VariableColor"));
if (null != strokePen.LineEndCap)
strokePen = strokePen.WithLineEndCap(strokePen.LineEndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6));
// Calculate target
AltaxoVariant targetX, targetY, targetZ;
switch (_meaningOfValues)
{
case ValueInterpretation.AbsoluteDifference:
{
targetX = pdata.GetXPhysical(originalRow) + columnX[originalRow];
targetY = pdata.GetYPhysical(originalRow) + columnY[originalRow];
targetZ = pdata.GetZPhysical(originalRow) + columnZ[originalRow];
}
break;
case ValueInterpretation.AbsoluteValue:
{
targetX = columnX[originalRow];
targetY = columnY[originalRow];
targetZ = columnZ[originalRow];
}
break;
default:
throw new NotImplementedException(nameof(_meaningOfValues));
}
var logicalTarget = layer.GetLogical3D(targetX, targetY, targetZ);
var logicalOrigin = layer.GetLogical3D(pdata, originalRow);
if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY || 0 != _cachedLogicalShiftZ))
{
logicalOrigin.RX += _cachedLogicalShiftX;
logicalOrigin.RY += _cachedLogicalShiftY;
logicalOrigin.RZ += _cachedLogicalShiftZ;
logicalTarget.RX += _cachedLogicalShiftX;
logicalTarget.RY += _cachedLogicalShiftY;
logicalTarget.RZ += _cachedLogicalShiftZ;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RX, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RY, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RZ, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RX, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RY, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RZ, logicalClampMinimum, logicalClampMaximum))
continue;
var isoLine = layer.CoordinateSystem.GetIsoline(logicalOrigin, logicalTarget);
if (null == isoLine)
continue;
if (_useManualVectorLength)
{
double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize;
double isoLineLength = isoLine.TotalLineLength;
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length));
if (null == isoLine)
continue;
}
if (_useSymbolGap)
{
double gap = _symbolGapOffset + _symbolGapFactor * symbolSize;
if (gap != 0)
{
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0));
if (null == isoLine)
continue;
}
}
g.DrawLine(strokePen, isoLine);
}
}
}
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData)
{
PlotRangeList rangeList = pdata.RangeList;
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
// adjust the skip frequency if it was not set appropriate
if (_skipFreq <= 0)
_skipFreq = 1;
var dropTargets = new List<CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id)));
if (_additionalDropTargetIsEnabled)
{
CSPlaneID userPlane;
if (_additionalDropTargetUsePhysicalBaseValue)
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue));
}
else
{
userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue);
}
dropTargets.Add(userPlane);
}
// paint the scatter style
PointD3D pos = PointD3D.Empty;
if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color
{
var pen = _pen;
// update pen widths
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize;
pen = pen.WithThickness1(w1).WithThickness2(w2);
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
for (int r = 0; r < rangeList.Count; r++)
{
var range = rangeList[r];
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFreq)
{
Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal);
foreach (CSPlaneID id in dropTargets)
{
IPolylineD3D isoLine;
layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out isoLine);
if (gapStart != 0 || gapEnd != 0)
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
if (null != isoLine)
g.DrawLine(pen, isoLine);
}
}
} // for each range
}
else // using a variable symbol size or variable symbol color
{
for (int r = 0; r < rangeList.Count; r++)
{
var range = rangeList[r];
int lower = range.LowerBound;
int upper = range.UpperBound;
int offset = range.OffsetToOriginal;
for (int j = lower; j < upper; j += _skipFreq)
{
var pen = _pen;
if (null == _cachedColorForIndexFunction)
{
_cachedSymbolSize = _cachedSymbolSizeForIndexFunction(j + offset);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize;
pen = _pen.WithThickness1(w1).WithThickness2(w2);
}
else
{
_cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(j + offset);
double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize;
double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize;
var customSymbolColor = _cachedColorForIndexFunction(j + offset);
pen = _pen.WithThickness1(w1).WithThickness2(w2).WithColor(NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B));
}
var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize);
var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize);
Logical3D r3d = layer.GetLogical3D(pdata, j + rangeList[r].OffsetToOriginal);
foreach (CSPlaneID id in _dropTargets)
{
IPolylineD3D isoLine;
layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out isoLine);
if (gapStart != 0 || gapEnd != 0)
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd));
if (null != isoLine)
g.DrawLine(pen, isoLine);
}
}
}
}
}
public void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata)
{
if (this._labelColumnProxy.Document == null)
return;
_cachedStringFormat.Alignment = GdiExtensionMethods.ToGdi(_alignmentX);
_cachedStringFormat.LineAlignment = GdiExtensionMethods.ToGdi(_alignmentY);
if (null != _attachedPlane)
_attachedPlane = layer.UpdateCSPlaneID(_attachedPlane);
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
Altaxo.Data.IReadableColumn labelColumn = this._labelColumnProxy.Document;
bool isUsingVariableColorForLabelText = null != _cachedColorForIndexFunction && IsColorReceiver;
bool isUsingVariableColorForLabelBackground = null != _cachedColorForIndexFunction &&
(null != _backgroundStyle && _backgroundStyle.SupportsBrush && (_backgroundColorLinkage == ColorLinkage.Dependent || _backgroundColorLinkage == ColorLinkage.PreserveAlpha));
bool isUsingVariableColor = isUsingVariableColorForLabelText || isUsingVariableColorForLabelBackground;
BrushX clonedTextBrush = null;
BrushX clonedBackBrush = null;
if (isUsingVariableColorForLabelText)
clonedTextBrush = _brush.Clone();
if (isUsingVariableColorForLabelBackground)
clonedBackBrush = _backgroundStyle.Brush.Clone();
// save the graphics stat since we have to translate the origin
var gs = g.Save();
double xpos = 0, ypos = 0;
double xpre, ypre;
double xdiff, ydiff;
bool isFormatStringContainingBraces = _labelFormatString?.IndexOf('{') >= 0;
var culture = System.Threading.Thread.CurrentThread.CurrentCulture;
bool mustUseLogicalCoordinates = null != this._attachedPlane || 0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY;
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j+=_skipFrequency)
{
int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
string label;
if (string.IsNullOrEmpty(_labelFormatString))
{
label = labelColumn[originalRowIndex].ToString();
}
else if (!isFormatStringContainingBraces)
{
label = labelColumn[originalRowIndex].ToString(_labelFormatString, culture);
}
else
{
// the label format string can contain {0} for the label column item, {1} for the row index, {2} .. {4} for the x, y and z component of the data point
label = string.Format(_labelFormatString, labelColumn[originalRowIndex], originalRowIndex, pdata.GetPhysical(0, originalRowIndex), pdata.GetPhysical(1, originalRowIndex), pdata.GetPhysical(2, originalRowIndex));
}
if (string.IsNullOrEmpty(label))
continue;
double localSymbolSize = _symbolSize;
if (null != _cachedSymbolSizeForIndexFunction)
{
localSymbolSize = _cachedSymbolSizeForIndexFunction(originalRowIndex);
}
double localFontSize = _fontSizeOffset + _fontSizeFactor * localSymbolSize;
if (!(localFontSize > 0))
continue;
_font = _font.WithSize(localFontSize);
// Start of preparation of brushes, if a variable color is used
if (isUsingVariableColor)
{
Color c = _cachedColorForIndexFunction(originalRowIndex);
if (isUsingVariableColorForLabelText)
{
clonedTextBrush.Color = new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e");
}
if (isUsingVariableColorForLabelBackground)
{
if (_backgroundColorLinkage == ColorLinkage.PreserveAlpha)
clonedBackBrush.Color = new NamedColor(AxoColor.FromArgb(clonedBackBrush.Color.Color.A, c.R, c.G, c.B), "e");
else
clonedBackBrush.Color = new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e");
}
}
// end of preparation of brushes for variable colors
if (mustUseLogicalCoordinates) // we must use logical coordinates because either there is a shift of logical coordinates, or an attached plane
{
Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex);
r3d.RX += _cachedLogicalShiftX;
r3d.RY += _cachedLogicalShiftY;
if (null != this._attachedPlane)
{
var pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane, r3d);
xpre = pp.X;
ypre = pp.Y;
}
else
{
PointD3D pt;
layer.CoordinateSystem.LogicalToLayerCoordinates(r3d, out xpre, out ypre);
}
}
else // no shifting, thus we can use layer coordinates
{
xpre = ptArray[j].X;
ypre = ptArray[j].Y;
}
xdiff = xpre - xpos;
ydiff = ypre - ypos;
xpos = xpre;
ypos = ypre;
g.TranslateTransform((float)xdiff, (float)ydiff);
if (this._rotation != 0)
g.RotateTransform((float)-this._rotation);
this.PaintOneItem(g, label, localSymbolSize, clonedTextBrush, clonedBackBrush);
if (this._rotation != 0)
g.RotateTransform((float)this._rotation);
}
g.Restore(gs); // Restore the graphics state
}
/// <summary>
/// Template to get a fill path.
/// </summary>
/// <param name="gp">Graphics path to fill with data.</param>
/// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="range">The plot range to use.</param>
/// <param name="layer">Graphics layer.</param>
/// <param name="fillDirection">Designates a bound to fill to.</param>
/// <param name="linePoints">The points that mark the line.</param>
/// <param name="connectCircular">If true, a circular connection is drawn.</param>
private void FillOneRange_PreprocessedPoints(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
PointF[] linePoints,
bool connectCircular,
double logicalShiftX,
double logicalShiftY
)
{
if (connectCircular)
{
gp.AddBeziers(linePoints);
gp.CloseFigure();
}
else
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddBeziers(linePoints);
Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + linePoints.Length - 1));
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
protected void PaintOneRange(int axisNumber, Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata)
{
const double logicalClampMinimum = -10;
const double logicalClampMaximum = 11;
_skipFrequency = Math.Max(1, _skipFrequency);
// Plot error bars for the dependent variable (y)
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
var posErrCol = PositiveErrorColumn;
var negErrCol = NegativeErrorColumn;
if (null != posErrCol && !typeof(double).IsAssignableFrom(posErrCol.ItemType))
posErrCol = null; // TODO make this an runtime paint error to be reported
if (null != negErrCol && !typeof(double).IsAssignableFrom(negErrCol.ItemType))
negErrCol = null; // TODO make this an runtime paint error to be reported
if (posErrCol == null && negErrCol == null)
return; // nothing to do if both error columns are null
var strokePen = _pen.Clone();
System.Drawing.Drawing2D.GraphicsPath errorBarPath = new System.Drawing.Drawing2D.GraphicsPath();
Region oldClippingRegion = g.Clip;
Region newClip = (Region)oldClippingRegion.Clone();
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex);
strokePen.Width = (_lineWidth1Offset + _lineWidth1Factor * symbolSize);
if (null != _cachedColorForIndexFunction)
strokePen.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor");
if (null != strokePen.EndCap)
strokePen.EndCap = strokePen.EndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6);
AltaxoVariant vMeanPhysical = pdata.GetPhysical(axisNumber, originalRowIndex);
Logical3D logicalMean = layer.GetLogical3D(pdata, originalRowIndex);
logicalMean.RX += _cachedLogicalShiftX;
logicalMean.RY += _cachedLogicalShiftY;
if (!Calc.RMath.IsInIntervalCC(logicalMean.RX, logicalClampMinimum, logicalClampMaximum))
continue;
if (!Calc.RMath.IsInIntervalCC(logicalMean.RY, logicalClampMinimum, logicalClampMaximum))
continue;
var vMeanLogical = logicalMean.GetR(axisNumber);
Logical3D logicalPos = logicalMean;
Logical3D logicalNeg = logicalMean;
bool logicalPosValid = false;
bool logicalNegValid = false;
switch (_meaningOfValues)
{
case ValueInterpretation.AbsoluteError:
{
if (posErrCol != null)
{
var vPosLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical + Math.Abs(posErrCol[originalRowIndex]));
vPosLogical = Calc.RMath.ClampToInterval(vPosLogical, logicalClampMinimum, logicalClampMaximum);
logicalPos.SetR(axisNumber, vPosLogical);
logicalPosValid = !logicalPos.IsNaN && vPosLogical != vMeanLogical;
}
if (negErrCol != null)
{
var vNegLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical - Math.Abs(negErrCol[originalRowIndex]));
vNegLogical = Calc.RMath.ClampToInterval(vNegLogical, logicalClampMinimum, logicalClampMaximum);
logicalNeg.SetR(axisNumber, vNegLogical);
logicalNegValid = !logicalNeg.IsNaN && vNegLogical != vMeanLogical;
}
}
break;
case ValueInterpretation.RelativeError:
{
if (posErrCol != null)
{
var vPosLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical * (1 + Math.Abs(posErrCol[originalRowIndex])));
vPosLogical = Calc.RMath.ClampToInterval(vPosLogical, logicalClampMinimum, logicalClampMaximum);
logicalPos.SetR(axisNumber, vPosLogical);
logicalPosValid = !logicalPos.IsNaN && vPosLogical != vMeanLogical;
}
if (negErrCol != null)
{
var vNegLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical * (1 - Math.Abs(negErrCol[originalRowIndex])));
vNegLogical = Calc.RMath.ClampToInterval(vNegLogical, logicalClampMinimum, logicalClampMaximum);
logicalNeg.SetR(axisNumber, vNegLogical);
logicalNegValid = !logicalNeg.IsNaN && vNegLogical != vMeanLogical;
}
}
break;
case ValueInterpretation.AbsoluteValue:
{
if (posErrCol != null)
{
var vPosLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(posErrCol[originalRowIndex]);
vPosLogical = Calc.RMath.ClampToInterval(vPosLogical, logicalClampMinimum, logicalClampMaximum);
logicalPos.SetR(axisNumber, vPosLogical);
logicalPosValid = !logicalPos.IsNaN && vPosLogical != vMeanLogical;
}
if (negErrCol != null)
{
var vNegLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(negErrCol[originalRowIndex]);
vNegLogical = Calc.RMath.ClampToInterval(vNegLogical, logicalClampMinimum, logicalClampMaximum);
logicalNeg.SetR(axisNumber, vNegLogical);
logicalNegValid = !logicalNeg.IsNaN && vNegLogical != vMeanLogical;
}
if (object.ReferenceEquals(negErrCol, posErrCol))
{
logicalNegValid = false; // then we need only to plot the positive column, since both colums are identical
}
}
break;
} // end switch
if (!(logicalPosValid || logicalNegValid))
continue; // nothing to do for this point if both pos and neg logical point are invalid.
if (logicalNegValid)
{
errorBarPath.Reset();
layer.CoordinateSystem.GetIsoline(errorBarPath, logicalMean, logicalNeg);
PointF[] shortenedPathPoints = null;
bool shortenedPathPointsCalculated = false;
if (_useSymbolGap)
{
double gap = _symbolGapOffset + _symbolGapFactor * symbolSize;
if (gap > 0)
{
errorBarPath.Flatten();
var pathPoints = errorBarPath.PathPoints;
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gap / 2), RADouble.NewAbs(0));
shortenedPathPointsCalculated = true;
if (null == shortenedPathPoints && _forceVisibilityOfEndCap && !(strokePen.EndCap is Altaxo.Graph.Gdi.LineCaps.FlatCap))
{
var totalLineLength = GdiExtensionMethods.TotalLineLength(pathPoints);
var shortTheLineBy = Math.Max(0, totalLineLength - 0.125 * strokePen.Width);
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(shortTheLineBy), RADouble.NewAbs(0));
}
}
}
if (shortenedPathPointsCalculated)
{
if (null != shortenedPathPoints)
{
g.DrawLines(strokePen, shortenedPathPoints);
}
}
else
{
g.DrawPath(strokePen, errorBarPath);
}
}
if (logicalPosValid)
{
errorBarPath.Reset();
layer.CoordinateSystem.GetIsoline(errorBarPath, logicalMean, logicalPos);
PointF[] shortenedPathPoints = null;
bool shortenedPathPointsCalculated = false;
if (_useSymbolGap)
{
double gap = _symbolGapOffset + _symbolGapFactor * symbolSize;
if (gap > 0)
{
errorBarPath.Flatten();
var pathPoints = errorBarPath.PathPoints;
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gap / 2), RADouble.NewAbs(0));
shortenedPathPointsCalculated = true;
if (null == shortenedPathPoints && _forceVisibilityOfEndCap && !(strokePen.EndCap is Altaxo.Graph.Gdi.LineCaps.FlatCap))
{
var totalLineLength = GdiExtensionMethods.TotalLineLength(pathPoints);
var shortTheLineBy = Math.Max(0, totalLineLength - 0.125 * strokePen.Width);
shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(shortTheLineBy), RADouble.NewAbs(0));
}
}
}
if (shortenedPathPointsCalculated)
{
if (null != shortenedPathPoints)
{
g.DrawLines(strokePen, shortenedPathPoints);
}
}
else
{
g.DrawPath(strokePen, errorBarPath);
}
}
}
g.Clip = oldClippingRegion;
}
/// <inheritdoc/>
public override void FillOneRange(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
bool ignoreMissingDataPoints,
bool connectCircular,
PointF[] allLinePoints,
double logicalShiftX,
double logicalShiftY
)
{
PointF[] circularLinePoints = new PointF[range.Length + (connectCircular ? 1 : 0)];
Array.Copy(allLinePoints, range.LowerBound, circularLinePoints, 0, range.Length); // Extract
if (connectCircular)
circularLinePoints[circularLinePoints.Length - 1] = circularLinePoints[0];
if (connectCircular)
{
gp.AddLines(circularLinePoints);
gp.CloseFigure();
}
else // not circular
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddLines(circularLinePoints);
Logical3D r1 = layer.GetLogical3D(pdata, connectCircular ? range.OriginalFirstPoint : range.OriginalLastPoint);
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
protected void PaintXErrorBars(System.Drawing.Graphics g, IPlotArea layer, Altaxo.Graph.Gdi.Plot.Data.Processed2DPlotData pdata)
{
// Plot error bars for the independent variable (x)
PlotRangeList rangeList = pdata.RangeList;
PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
INumericColumn posErrCol = _positiveErrorColumn.Document;
INumericColumn negErrCol = _negativeErrorColumn.Document;
if (posErrCol == null && negErrCol == null)
return; // nothing to do if both error columns are null
System.Drawing.Drawing2D.GraphicsPath errorBarPath = new System.Drawing.Drawing2D.GraphicsPath();
Region oldClippingRegion = g.Clip;
Region newClip = (Region)oldClippingRegion.Clone();
foreach (PlotRange r in rangeList)
{
int lower = r.LowerBound;
int upper = r.UpperBound;
int offset = r.OffsetToOriginal;
for (int j = lower; j < upper; j++)
{
AltaxoVariant x = pdata.GetXPhysical(j + offset);
Logical3D lm = layer.GetLogical3D(pdata, j + offset);
lm.RX += _cachedLogicalShiftOfIndependent;
if (lm.IsNaN)
continue;
Logical3D lh = lm;
Logical3D ll = lm;
bool lhvalid = false;
bool llvalid = false;
if (posErrCol != null)
{
lh.RX = layer.XAxis.PhysicalVariantToNormal(x + Math.Abs(posErrCol[j + offset]));
lhvalid = !lh.IsNaN;
}
if (negErrCol != null)
{
ll.RX = layer.XAxis.PhysicalVariantToNormal(x - Math.Abs(negErrCol[j + offset]));
llvalid = !ll.IsNaN;
}
if (!(lhvalid || llvalid))
continue; // nothing to do for this point if both pos and neg logical point are invalid.
// now paint the error bar
if (_symbolGap) // if symbol gap, then clip the painting, exclude a rectangle of size symbolSize x symbolSize
{
double xlm, ylm;
layer.CoordinateSystem.LogicalToLayerCoordinates(lm, out xlm, out ylm);
newClip.Union(oldClippingRegion);
newClip.Exclude(new RectangleF((float)(xlm - _symbolSize / 2), (float)(ylm - _symbolSize / 2), _symbolSize, _symbolSize));
g.Clip = newClip;
}
if (lhvalid && llvalid)
{
errorBarPath.Reset();
layer.CoordinateSystem.GetIsoline(errorBarPath, ll, lm);
layer.CoordinateSystem.GetIsoline(errorBarPath, lm, lh);
g.DrawPath(_strokePen, errorBarPath);
}
else if (llvalid)
{
layer.CoordinateSystem.DrawIsoline(g, _strokePen, ll, lm);
}
else if (lhvalid)
{
layer.CoordinateSystem.DrawIsoline(g, _strokePen, lm, lh);
}
// now the end bars
if (_showEndBars)
{
if (lhvalid)
{
PointF outDir;
layer.CoordinateSystem.GetNormalizedDirection(lm, lh, 1, new Logical3D(0, 1), out outDir);
outDir.X *= _symbolSize / 2;
outDir.Y *= _symbolSize / 2;
double xlay, ylay;
layer.CoordinateSystem.LogicalToLayerCoordinates(lh, out xlay, out ylay);
// Draw a line from x,y to
g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y));
}
if (llvalid)
{
PointF outDir;
layer.CoordinateSystem.GetNormalizedDirection(lm, ll, 1, new Logical3D(0, 1), out outDir);
outDir.X *= _symbolSize / 2;
outDir.Y *= _symbolSize / 2;
double xlay, ylay;
layer.CoordinateSystem.LogicalToLayerCoordinates(ll, out xlay, out ylay);
// Draw a line from x,y to
g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y));
}
}
}
}
g.Clip = oldClippingRegion;
}
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData)
{
const double logicalClampMinimum = -10;
const double logicalClampMaximum = 11;
// Plot error bars for the dependent variable (y)
PlotRangeList rangeList = pdata.RangeList;
var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
var columnX = ColumnX;
var columnY = ColumnY;
var columnZ = ColumnZ;
if (columnX == null || columnY == null || columnZ == null)
{
return; // nothing to do if both error columns are null
}
if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType) || !typeof(double).IsAssignableFrom(columnZ.ItemType))
{
return; // TODO make this an runtime paint error to be reported
}
var strokePen = _strokePen;
foreach (PlotRange r in rangeList)
{
int lower = r.LowerBound;
int upper = r.UpperBound;
int offset = r.OffsetToOriginal;
for (int j = lower; j < upper; j += _skipFrequency)
{
int originalRow = j + offset;
double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRow);
strokePen = strokePen.WithThickness1(_lineWidth1Offset + _lineWidth1Factor * symbolSize);
strokePen = strokePen.WithThickness2(_lineWidth2Offset + _lineWidth2Factor * symbolSize);
if (null != _cachedColorForIndexFunction)
{
strokePen = strokePen.WithColor(GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRow), "VariableColor"));
}
if (null != strokePen.LineEndCap)
{
strokePen = strokePen.WithLineEndCap(strokePen.LineEndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6));
}
// Calculate target
AltaxoVariant targetX, targetY, targetZ;
switch (_meaningOfValues)
{
case ValueInterpretation.AbsoluteDifference:
{
targetX = pdata.GetXPhysical(originalRow) + columnX[originalRow];
targetY = pdata.GetYPhysical(originalRow) + columnY[originalRow];
targetZ = pdata.GetZPhysical(originalRow) + columnZ[originalRow];
}
break;
case ValueInterpretation.AbsoluteValue:
{
targetX = columnX[originalRow];
targetY = columnY[originalRow];
targetZ = columnZ[originalRow];
}
break;
default:
throw new NotImplementedException(nameof(_meaningOfValues));
}
var logicalTarget = layer.GetLogical3D(targetX, targetY, targetZ);
var logicalOrigin = layer.GetLogical3D(pdata, originalRow);
if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY || 0 != _cachedLogicalShiftZ))
{
logicalOrigin.RX += _cachedLogicalShiftX;
logicalOrigin.RY += _cachedLogicalShiftY;
logicalOrigin.RZ += _cachedLogicalShiftZ;
logicalTarget.RX += _cachedLogicalShiftX;
logicalTarget.RY += _cachedLogicalShiftY;
logicalTarget.RZ += _cachedLogicalShiftZ;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RX, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RY, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RZ, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RX, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RY, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RZ, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
var isoLine = layer.CoordinateSystem.GetIsoline(logicalOrigin, logicalTarget);
if (null == isoLine)
{
continue;
}
if (_useManualVectorLength)
{
double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize;
double isoLineLength = isoLine.TotalLineLength;
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length));
if (null == isoLine)
{
continue;
}
}
if (_useSymbolGap)
{
double gap = _symbolGapOffset + _symbolGapFactor * symbolSize;
if (gap != 0)
{
isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0));
if (null == isoLine)
{
continue;
}
}
}
g.DrawLine(strokePen, isoLine);
}
}
}
protected void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata)
{
const double logicalClampMinimum = -10;
const double logicalClampMaximum = 11;
// Plot error bars for the dependent variable (y)
var columnX = ColumnX;
var columnY = ColumnY;
if (columnX == null || columnY == null)
{
return; // nothing to do if both error columns are null
}
if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType))
{
return; // TODO make this an runtime paint error to be reported
}
var strokePen = _strokePen.Clone();
using (var isoLine = new GraphicsPath())
{
int lower = range.LowerBound;
int upper = range.UpperBound;
for (int j = lower; j < upper; j += _skipFrequency)
{
int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j);
double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex);
strokePen.Width = (_lineWidth1Offset + _lineWidth1Factor * symbolSize);
if (null != _cachedColorForIndexFunction)
{
strokePen.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor");
}
if (!(strokePen.EndCap is LineCaps.FlatCap))
{
strokePen.EndCap = strokePen.EndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6);
}
// Calculate target
AltaxoVariant targetX, targetY;
switch (_meaningOfValues)
{
case ValueInterpretation.AbsoluteDifference:
{
targetX = pdata.GetXPhysical(originalRowIndex) + columnX[originalRowIndex];
targetY = pdata.GetYPhysical(originalRowIndex) + columnY[originalRowIndex];
}
break;
case ValueInterpretation.AbsoluteValue:
{
targetX = columnX[originalRowIndex];
targetY = columnY[originalRowIndex];
}
break;
default:
throw new NotImplementedException(nameof(_meaningOfValues));
}
var logicalTarget = layer.GetLogical3D(targetX, targetY);
var logicalOrigin = layer.GetLogical3D(pdata, originalRowIndex);
if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY))
{
logicalOrigin.RX += _cachedLogicalShiftX;
logicalOrigin.RY += _cachedLogicalShiftY;
logicalTarget.RX += _cachedLogicalShiftX;
logicalTarget.RY += _cachedLogicalShiftY;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RX, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RY, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RZ, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RX, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RY, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
if (!Calc.RMath.IsInIntervalCC(logicalTarget.RZ, logicalClampMinimum, logicalClampMaximum))
{
continue;
}
isoLine.Reset();
layer.CoordinateSystem.GetIsoline(isoLine, logicalOrigin, logicalTarget);
if (null == isoLine)
{
continue;
}
PointF[] isoLinePathPoints = null;
if (_useManualVectorLength)
{
isoLine.Flatten();
isoLinePathPoints = isoLine.PathPoints;
double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize;
double isoLineLength = isoLinePathPoints.TotalLineLength();
isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length));
if (null == isoLine)
{
continue;
}
}
if (_useSymbolGap)
{
if (null == isoLinePathPoints)
{
isoLine.Flatten();
isoLinePathPoints = isoLine.PathPoints;
}
double gap = _symbolGapOffset + _symbolGapFactor * symbolSize;
if (gap != 0)
{
isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0));
if (null == isoLine)
{
continue;
}
}
}
if (null != isoLinePathPoints)
{
g.DrawLines(_strokePen, isoLinePathPoints);
}
else
{
g.DrawPath(strokePen, isoLine);
}
}
}
}
public void Paint(Graphics g,
IPlotArea layer,
Processed2DPlotData pdata)
{
if (this._labelColumn.Document == null)
return;
if (null != _attachedPlane)
layer.UpdateCSPlaneID(_attachedPlane);
PlotRangeList rangeList = pdata.RangeList;
PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates;
Altaxo.Data.IReadableColumn labelColumn = this._labelColumn.Document;
// save the graphics stat since we have to translate the origin
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
/*
double bottomPosition = 0;
double topPosition = 0;
double leftPosition = 0;
double rightPosition = 0;
layer.CoordinateSystem.LogicalToLayerCoordinates(0, 0, out leftPosition, out bottomPosition);
layer.CoordinateSystem.LogicalToLayerCoordinates(1, 1, out rightPosition, out topPosition);
*/
double xpos = 0, ypos = 0;
double xpre, ypre;
double xdiff, ydiff;
for (int r = 0; r < rangeList.Count; r++)
{
int lower = rangeList[r].LowerBound;
int upper = rangeList[r].UpperBound;
int offset = rangeList[r].OffsetToOriginal;
for (int j = lower; j < upper; j++)
{
string label = labelColumn[j + offset].ToString();
if (label == null || label == string.Empty)
continue;
xpre = ptArray[j].X;
ypre = ptArray[j].Y;
if (null!=this._attachedPlane)
{
Logical3D r3d = layer.GetLogical3D(pdata, j + offset);
PointF pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane,r3d);
xpre = pp.X;
ypre = pp.Y;
}
xdiff = xpre - xpos;
ydiff = ypre - ypos;
xpos = xpre;
ypos = ypre;
g.TranslateTransform((float)xdiff, (float)ydiff);
if (this._rotation != 0)
g.RotateTransform((float)-this._rotation);
this.Paint(g, label);
if (this._rotation != 0)
g.RotateTransform((float)this._rotation);
} // end for
}
g.Restore(gs); // Restore the graphics state
}
