void drawChrom(VisSerie visSerie, WriteableBitmap bitmap)
{
VisPoint[] visPoints;
Rect visRect;
Color color;
int ncells;
float r, g, b;
float weight = 1;
double cx, cy;
int pixelWidth, pixelHeight;
int x, y;
visPoints = visSerie.visPoints;
ncells = visPoints.Length;
color = visSerie.drawColor;
weight = visSerie.drawWeight;
r = color.ScR * weight;
g = color.ScG * weight;
b = color.ScB * weight;
visRect = visSerie.visRect;
pixelWidth = (int)(width * visRect.Width);
pixelHeight = (int)(height * visRect.Height);
if (visSerie.type == VisSerieType.Units)
{
foreach (VisPoint point in visPoints)
{
cx = convVirtX(point.vx);
cy = convVirtY(point.vy);
foreach (System.Drawing.Point circlePoint in circlePattern)
{
x = (int)(cx + circlePoint.X);
y = (int)(cy + circlePoint.Y);
if (x >= 0 && x < pixelWidth && y >= 0 && y < pixelHeight)
{
rBuffer[x, y] += r;
gBuffer[x, y] += g;
bBuffer[x, y] += b;
totBuffer[x, y] += weight;
}
}
}
}
}
public VisOutSet updateVisOutVar(OutSet outSet, ViewParams viewParams)
{
VisOutSet visOutSet = new VisOutSet();
List <VisSerie> visSeries;
List <VisSerie> visRawSeries = null;
VisSerie visSerie;
List <VisPoint> visPoints;
OutCell[][] rawOutCells = outSet.rawOutCells;
OutCell[] compRawOutCells;
OutCell outCell;
OutComp outComp;
VisComp visComp;
VisAxes visAxes = new VisAxes();
VisAxis visAxis;
Axes axes = outSet.axes;
Axis xaxis = new Axis();
Axis yaxis = new Axis();
PhaseType phase = new PhaseType();
int nphases;
int ncomps;
int npoints;
int nseries;
int ncells;
bool previewMode = (viewParams.viewType == ViewType.Setup);
bool dispDualTime = (viewParams.phaseDisplay == PhaseDisplayType.UpperLowerTime);
bool dispDual = (viewParams.phaseDisplay == PhaseDisplayType.UpperLower || dispDualTime);
bool usePrefixes = (viewParams.exponentType == ExponentType.Prefixes);
bool scaleDrawReverse;
bool scaleSet;
bool sum;
float maxcon = 0;
float con = 0;
float rangey = 0;
float rangex = 0;
float range;
float rangey0;
float scaleu, scalel;
float miny, maxy;
float minvx = 0;
float maxvx = 0;
float minxlabel = 0;
float maxxlabel = 0;
float k;
float flow;
float pos;
float vceff;
RectangleF allrect = new RectangleF(0, 0, 1, 1);
RectangleF vrect = allrect;
RectangleF rawvrect = allrect;
float unitsize = 0.025f;
float vx, vy;
int s = 0;
int c;
string label = "";
MassUnitsType prefMassUnits = inParams.massUnits;
int prefMassUnitsi;
float multiplier = 1;
// general vars
if (dispDual && !previewMode)
{
nphases = 2;
}
else
{
nphases = 1;
}
ncomps = inParams.comps.Count;
nseries = outSet.outCells.Length;
if (ncomps == 0)
{
return(visOutSet);
}
// update outComps units
foreach (OutComp outComp0 in outSet.comps)
{
outComp0.units = inParams.viewUnits;
outComp0.volUnits = inParams.volUnits;
outComp0.timeUnits = inParams.timeUnits;
outComp0.massUnits = inParams.massUnits;
}
// convert out to units
outSet.unitsOutCells = new OutCell[outSet.outCells.Length][];
for (s = 0; s < nseries; s++)
{
c = s / nphases;
if (viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (nphases > 1)
{
phase = (PhaseType)((s % nphases) + 1);
}
ncells = outSet.outCells[s].Length;
outSet.unitsOutCells[s] = new OutCell[ncells];
for (int i = 0; i < ncells; i++)
{
pos = inParams.convertUnit(outSet.outCells[s][i].pos, inParams.natUnits, viewParams.viewUnits, phase);
con = outSet.outCells[s][i].con;
outSet.unitsOutCells[s][i] = new OutCell(pos, con);
}
}
// initialise vis series
visSeries = new List <VisSerie>(nseries);
if (viewParams.showProbUnits)
{
visRawSeries = new List <VisSerie>(nseries);
}
if (viewParams.showProbUnits)
{
if (dispDual)
{
rawvrect.Height = unitsize * 2;
}
else
{
rawvrect.Height = unitsize;
}
vrect.Y = rawvrect.Bottom;
vrect.Height = 1 - vrect.Y;
}
// Axes
axes = outSet.axes;
// Set maxcon / rangey
if (viewParams.yScale == YScaleType.Absolute)
{
// * not exactly correct; should use maxcon from first (time) step
maxcon = 0;
for (int i = 0; i < outSet.comps.Count; i++)
{
if (outSet.comps[i].m > maxcon)
{
maxcon = outSet.comps[i].m;
}
}
rangey = maxcon;
}
else if (viewParams.yScale == YScaleType.Normalised)
{
rangey = 0;
}
else // Auto or Log scale
{
maxcon = 0;
for (int i = 0; i < axes.maxcon.Count; i++)
{
if (axes.maxcon[i] > maxcon)
{
maxcon = axes.maxcon[i];
}
}
if (viewParams.yScale == YScaleType.Automatic)
{
rangey = maxcon;
}
else if (axes.logScale)
{
maxcon = (float)Math.Ceiling(Math.Log(maxcon)); // Nearest E power
rangey = 5;
// Scale: E^maxcon ... E^(maxcon-rangey)
}
}
// Column lines
if (viewParams.showProbUnits)
{
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
visAxis.point1 = new VisPoint(vrect.Left, rawvrect.Top);
visAxis.point2 = new VisPoint(vrect.Left, rawvrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
visAxis.point1 = new VisPoint(vrect.Right, rawvrect.Top);
visAxis.point2 = new VisPoint(vrect.Right, rawvrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.point1 = new VisPoint(vrect.Left, rawvrect.Top);
visAxis.point2 = new VisPoint(vrect.Right, rawvrect.Top);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.point1 = new VisPoint(vrect.Left, rawvrect.Bottom);
visAxis.point2 = new VisPoint(vrect.Right, rawvrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showCol)
{
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
vx = axes.colstart / axes.rangex * allrect.Width + allrect.Left;
visAxis.point1 = new VisPoint(vx, allrect.Top);
visAxis.point2 = new VisPoint(vx, allrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
vx = axes.colend / axes.rangex * allrect.Width + allrect.Left;
visAxis.point1 = new VisPoint(vx, allrect.Top);
visAxis.point2 = new VisPoint(vx, allrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showDeadvolstart)
{
visAxis = new VisAxis();
vx = axes.deadvolstart / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showDeadvolend)
{
visAxis = new VisAxis();
vx = axes.deadvolend / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showDeadvolinsert)
{
visAxis = new VisAxis();
vx = axes.deadvolinjectstart / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
vx = axes.deadvolinjectend / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
// X Axis
if (viewParams.syncScales && viewParams.viewUnits != QuantityType.ReS)
{
minxlabel = inParams.convertUnit(axes.scaleminulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
maxxlabel = inParams.convertUnit(axes.scalemaxulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
scaleu = Math.Abs(maxxlabel - minxlabel);
minxlabel = inParams.convertUnit(axes.scaleminllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
maxxlabel = inParams.convertUnit(axes.scalemaxllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
scalel = Math.Abs(maxxlabel - minxlabel);
if (scaleu != 0 && scalel != 0)
{
axes.sync(scaleu, scalel);
}
}
label = "";
for (int phasei = 0; phasei < 2; phasei++)
{
if (dispDual)
{
vy = vrect.Top + 0.5f * vrect.Height;
scaleDrawReverse = ((PhaseType)(phasei + 1) == PhaseType.Lower);
}
else
{
vy = vrect.Bottom;
scaleDrawReverse = false;
}
scaleSet = false;
if ((PhaseType)(phasei + 1) == PhaseType.Upper && (inParams.runMode != RunModeType.LowerPhase || (inParams.eeMode != EEModeType.None && inParams.isPosEEdir())) && viewParams.phaseDisplay != PhaseDisplayType.Lower)
{
// show Up axis
minvx = vrect.Left + axes.scaleminu / axes.rangexu * vrect.Width;
maxvx = vrect.Left + axes.scalemaxu / axes.rangexu * vrect.Width;
minxlabel = inParams.convertUnit(axes.scaleminulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
maxxlabel = inParams.convertUnit(axes.scalemaxulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
rangex = Math.Abs(axes.scalemaxu - axes.scaleminu);
scaleSet = true;
}
else if ((PhaseType)(phasei + 1) == PhaseType.Lower && (inParams.runMode != RunModeType.UpperPhase || (inParams.eeMode != EEModeType.None && !inParams.isPosEEdir())) && viewParams.phaseDisplay != PhaseDisplayType.Upper)
{
// show Lp axis
minvx = vrect.Left + axes.scaleminl / axes.rangexl * vrect.Width;
maxvx = vrect.Left + axes.scalemaxl / axes.rangexl * vrect.Width;
minxlabel = inParams.convertUnit(axes.scaleminllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
maxxlabel = inParams.convertUnit(axes.scalemaxllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
rangex = Math.Abs(axes.scalemaxl - axes.scaleminl);
scaleSet = true;
}
if (scaleSet)
{
range = maxxlabel - minxlabel;
// if syncScales: use same divs/stepsize as other axis
if (phasei == 0 || !viewParams.syncScales || viewParams.phaseDisplay == PhaseDisplayType.Upper || viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
xaxis.calcScale(range);
}
if (label == "")
{
// only do first label
label = inParams.getXaxisLegend();
}
else
{
label = "";
}
visAxes.addAxis(label,
minvx, vy, maxvx, vy,
false, true, true, !previewMode, !dispDual, scaleDrawReverse, false,
false, 1,
Colors.Black, 1,
minxlabel, maxxlabel, xaxis.nMajorDivs, xaxis.majorStepSize, xaxis.nMinorDivs, xaxis.minorStepSize);
if (viewParams.viewUnits == QuantityType.ReS)
{
// ReS (K-values) scale: overwrite labels
visAxis = visAxes.visAxes[visAxes.visAxes.Count - 1];
visAxis.clearLabels();
for (int i = 0; i <= 8; i++)
{
if (i > 4)
{
k = (float)4 / (8 - i);
}
else
{
k = (float)i / 4;
}
flow = Equations.calcFlow(inParams.kDefinition, inParams.fu, -inParams.fl, k);
if (flow < 0 && inParams.runMode == RunModeType.DualMode)
{
vceff = inParams.injectPos * inParams.vc;
}
else
{
vceff = (1 - inParams.injectPos) * inParams.vc;
}
if (flow != 0)
{
if (float.IsInfinity(k))
{
pos = Equations.calcInfPos(inParams.kDefinition, vceff, inParams.lf, inParams.uf, inParams.fu, inParams.fl);
}
else
{
pos = Equations.calcPos(inParams.kDefinition, vceff, inParams.lf, inParams.uf, flow, k);
}
if ((PhaseType)(phasei + 1) == PhaseType.Lower)
{
pos = -pos;
}
pos = inParams.convertUnit(pos, QuantityType.Time, inParams.natUnits, (PhaseType)(phasei + 1));
if (pos > 0 && !float.IsInfinity(pos))
{
vx = minvx + pos / rangex * (maxvx - minvx);
visAxis.addLabel(Util.toString(k, 2), vx, vy);
}
}
}
}
}
}
// Y Axis
range = rangey;
if (!axes.logScale)
{
// normal scale
yaxis.calcScale(range);
rangey = yaxis.scale;
miny = 0;
maxy = rangey;
}
else
{
// log scale
yaxis.majorStepSize = 1;
yaxis.nMajorDivs = (int)rangey;
yaxis.minorStepSize = 0;
yaxis.nMinorDivs = 0;
miny = maxcon - rangey;
maxy = maxcon;
}
if (usePrefixes)
{
prefMassUnitsi = (int)inParams.massUnits;
rangey0 = rangey;
while (rangey0 >= 1000 && prefMassUnitsi < Enum.GetValues(typeof(MassUnitsType)).Length)
{
rangey0 /= 1000;
multiplier /= 1000;
prefMassUnitsi++;
}
while (rangey0 < 1 && prefMassUnitsi > 0)
{
rangey0 *= 1000;
multiplier *= 1000;
prefMassUnitsi--;
}
prefMassUnits = (MassUnitsType)prefMassUnitsi;
label = inParams.getYaxisLegend(prefMassUnits);
}
else
{
label = inParams.getYaxisLegend(null);
}
if (dispDual)
{
vy = vrect.Top + 0.5f * vrect.Height;
// positive y scale
visAxes.addAxis("Upper Phase " + label,
vrect.Left, vy, vrect.Left, vrect.Top,
!previewMode, true, true, !previewMode, !axes.logScale, false, axes.logScale,
!usePrefixes, multiplier,
Colors.Black, 1,
miny, maxy, yaxis.nMajorDivs, yaxis.majorStepSize, yaxis.nMinorDivs, yaxis.minorStepSize);
// negative y scale
if (!axes.logScale)
{
yaxis.inverse();
miny = -miny;
maxy = -maxy;
}
visAxes.addAxis("Lower Phase " + label,
vrect.Left, vy, vrect.Left, vrect.Bottom,
!previewMode, true, true, !previewMode, false, false, axes.logScale,
!usePrefixes, multiplier,
Colors.Black, 1,
miny, maxy, yaxis.nMajorDivs, yaxis.majorStepSize, yaxis.nMinorDivs, yaxis.minorStepSize);
}
else
{
visAxes.addAxis(label,
vrect.Left, vrect.Bottom, vrect.Left, vrect.Top,
!previewMode, true, true, !previewMode, true, false, axes.logScale,
!usePrefixes, multiplier,
Colors.Black, 1,
miny, maxy, yaxis.nMajorDivs, yaxis.majorStepSize, yaxis.nMinorDivs, yaxis.minorStepSize);
}
// Raw Series (units)
if (viewParams.showProbUnits)
{
for (s = 0; s < rawOutCells.Length; s++)
{
compRawOutCells = rawOutCells[s];
npoints = compRawOutCells.Length;
c = s / nphases;
visSerie = new VisSerie();
visSerie.type = VisSerieType.Units;
visSerie.visRect = new Rect(rawvrect.X, rawvrect.Y, rawvrect.Width, rawvrect.Height);
visSerie.compi = c;
visSerie.drawSize = unitsize;
visSerie.drawWeight = outSet.comps[c].m;
visPoints = new List <VisPoint>();
if (viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (nphases > 1)
{
phase = (PhaseType)((s % nphases) + 1);
}
if (phase == PhaseType.Upper)
{
rangex = axes.rangexu;
}
else
{
rangex = axes.rangexl;
}
if (c < ncomps)
{
visSerie.drawColor = Util.colorRange(c, ncomps);
}
else
{
visSerie.drawColor = Colors.Gray;
}
for (int i = 0; i < npoints; i++)
{
outCell = compRawOutCells[i];
vx = rawvrect.Left + outCell.pos / rangex * rawvrect.Width;
if (s % nphases == 0)
{
vy = rawvrect.Top;
}
else
{
vy = rawvrect.Top + 0.5f * rawvrect.Height;
}
visPoints.Add(new VisPoint(vx, vy));
}
visSerie.visPoints = visPoints.ToArray();
visRawSeries.Add(visSerie);
}
visOutSet.visRawSeries = visRawSeries.ToArray();
if (dispDual)
{
visAxis = new VisAxis();
visAxis.point1 = new VisPoint(rawvrect.Left, 0.5f * rawvrect.Height);
visAxis.point2 = new VisPoint(rawvrect.Right, 0.5f * rawvrect.Height);
visAxes.visAxes.Add(visAxis);
}
}
visOutSet.visAxes = visAxes;
// Series
if (viewParams.yScale == YScaleType.Automatic)
{
maxcon = rangey;
}
for (s = 0; s < nseries; s++)
{
npoints = outSet.outCells[s].Length;
c = s / nphases;
visSerie = new VisSerie();
visSerie.type = VisSerieType.Graph;
visSerie.visRect = new Rect(vrect.X, vrect.Y, vrect.Width, vrect.Height);
visSerie.compi = c;
visPoints = new List <VisPoint>();
if (nphases > 1)
{
phase = (PhaseType)((s % nphases) + 1);
}
else if (viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (phase == PhaseType.Upper)
{
rangex = axes.rangexu;
}
else
{
rangex = axes.rangexl;
}
if (c < ncomps)
{
visSerie.drawWeight = outSet.comps[c].m;
visSerie.multiColor = false;
visSerie.drawColor = Util.colorRange(c, ncomps);
sum = false;
}
else
{
visSerie.multiColor = true;
visSerie.drawColor = Colors.Gray;
sum = true;
}
if (viewParams.peaksDisplay != PeaksDisplayType.Sum || sum)
{
// Sum graph: multi color
if (viewParams.yScale == YScaleType.Normalised)
{
maxcon = axes.maxcon[c];
}
for (int i = 0; i < npoints; i++)
{
outCell = outSet.outCells[s][i];
vx = vrect.Left + outCell.pos / rangex * vrect.Width;
if (viewParams.yScale == YScaleType.Logarithmic)
{
if (outCell.con != 0 && maxcon != 0)
{
con = (float)(1 + (Math.Log(Math.Abs(outCell.con)) - maxcon) / rangey);
if (con < 0)
{
con = 0;
}
if (outCell.con < 0)
{
con = -con;
}
}
else
{
con = 0;
}
}
else
{
if (maxcon != 0)
{
con = outCell.con / maxcon;
}
}
if (dispDual)
{
vy = vrect.Top + (1 - con) / 2 * vrect.Height;
}
else
{
vy = vrect.Bottom - con * vrect.Height;
}
if (c < ncomps)
{
visPoints.Add(new VisPoint(vx, vy));
}
else
{
visPoints.Add(new VisPoint(vx, vy, outCell.color));
}
}
visSerie.visPoints = visPoints.ToArray();
visSeries.Add(visSerie);
}
}
visOutSet.visSeries = visSeries.ToArray();
// Peaks
for (int i = 0; i < outSet.comps.Count; i++)
{
outComp = outSet.comps[i];
if (outComp.phase == PhaseType.Upper)
{
vx = vrect.Left + outComp.drawPosition / axes.rangexu * vrect.Width;
}
else if (outComp.phase == PhaseType.Lower)
{
vx = vrect.Left + outComp.drawPosition / axes.rangexl * vrect.Width;
}
else
{
vx = vrect.Left + outComp.drawPosition / axes.rangex * vrect.Width;
}
if (dispDual && outComp.phase == PhaseType.Lower)
{
vy = vrect.Bottom;
}
else
{
vy = vrect.Top;
}
visComp = new VisComp(new VisPoint(vx, vy, Util.colorRange(i, ncomps, 0.5f)), outComp.label, Util.colorRange(i, ncomps, 2));
visOutSet.comps.Add(visComp);
}
visOutSet.posUnits = inParams.getXaxisUnits();
visOutSet.useMultiplier = usePrefixes;
if (usePrefixes)
{
visOutSet.conMultiplier = multiplier;
visOutSet.conUnits = inParams.getYaxisUnits(prefMassUnits);
}
else
{
visOutSet.conMultiplier = 1;
visOutSet.conUnits = inParams.getYaxisUnits(null);
}
visOutSet.timeUnits = inParams.timeUnits.ToString();
return(visOutSet);
}
public void drawChrom(VisSerie visSerie)
{
VisPoint[] visPoints;
PointCollection drawPoints = new PointCollection();
Polyline polyline = new Polyline();
Line line;
double thickness = 2 * penwidth;
int ncells;
double vx, vy;
int vn;
double x, y, lastx, lasty;
bool visible, lastvisible;
bool reduce = false;
int step = 1;
bool multiColor = visSerie.multiColor;
visPoints = visSerie.visPoints;
ncells = visPoints.Length;
if (visSerie.type == VisSerieType.Graph)
{
if (width > 0)
{
step = (int)(ncells / (width * zoom));
reduce = (step > 1);
if (step < 1)
{
step = 1;
}
}
lastvisible = false;
lastx = 0;
lasty = 0;
for (int i = 0; i < ncells; i += step)
{
if (!reduce)
{
vx = visPoints[i].vx;
vy = visPoints[i].vy;
}
else
{
vx = 0;
vy = 0;
vn = 0;
for (int j = 0; j < step; j++)
{
if (i + j < visPoints.Length)
{
vx += visPoints[i + j].vx;
vy += visPoints[i + j].vy;
vn++;
}
}
vx /= vn;
vy /= vn;
}
x = convVirtX(vx);
y = convVirtY(vy);
visible = checkOnScreenX(x);
if (visible || lastvisible)
{
if (!multiColor)
{
drawPoints.Add(new Point(x, y));
}
else if (i > 0)
{
line = new Line();
line.Stroke = new SolidColorBrush(visPoints[i].color);
line.StrokeThickness = thickness;
line.X1 = lastx;
line.Y1 = lasty;
line.X2 = x;
line.Y2 = y;
addMouseHandler(line, visSerie.compi);
mainCanvas.Children.Add(line);
}
}
lastx = x;
lasty = y;
lastvisible = visible;
}
if (!multiColor)
{
polyline = new Polyline();
polyline.Stroke = new SolidColorBrush(visSerie.drawColor);
polyline.StrokeThickness = thickness;
polyline.Points = drawPoints;
addMouseHandler(polyline, visSerie.compi);
mainCanvas.Children.Add(polyline);
}
}
}