private void UpdateTraceColorLegend()
{
SIGNAL_TYPE signal = m_visibleSignal;
foreach (KeyValuePair <int, MultiChartArray_TraceItem> item in m_vm.traces)
{
int id = item.Value.id;
Color color = m_vm.traceColors[Tuple.Create <int, SIGNAL_TYPE>(id, signal)];
// find the visibility checkbox stackpanel with this id
foreach (UIElement child1 in VisibilityStackPanel.Children)
{
if (child1.GetType() == typeof(StackPanel))
{
StackPanel stackpanel = (StackPanel)child1;
foreach (UIElement child2 in stackpanel.Children)
{
if (child2.GetType() == typeof(Rectangle))
{
Rectangle rect = (Rectangle)child2;
if ((int)rect.Tag == id)
{
rect.Fill = new SolidColorBrush(color);
}
}
}
}
}
}
}
public IndicatorItem(int indID, int methID, string desc, ref ObservableCollection <SignalTypeContainer> signalTypeList, ref ObservableCollection <FilterContainer> exFiltList, ref ObservableCollection <FilterContainer> emFiltList)
{
_indicatorID = indID;
_methodID = methID;
_description = desc;
_excitationFilterList = exFiltList;
_emissionsFilterList = emFiltList;
_signalTypeList = signalTypeList;
if (_excitationFilterList.Count() > 0)
{
FilterContainer filter = _excitationFilterList.ElementAt(0);
_excitationFilterPosition = filter.PositionNumber;
}
if (_emissionsFilterList.Count() > 0)
{
FilterContainer filter = _emissionsFilterList.ElementAt(0);
_emissionsFilterPosition = filter.PositionNumber;
}
if (_signalTypeList.Count() > 0)
{
SignalTypeContainer st = _signalTypeList.ElementAt(0);
_signalType = st.Value;
}
}
private void radioButtonSignalY_CheckedChanged(object sender, EventArgs e)
{
if (radioButtonConstantY.Checked)
{
m_signalType2D_Y = SIGNAL_TYPE.CONSTANT;
}
else if (radioButtonSquareY.Checked)
{
m_signalType2D_Y = SIGNAL_TYPE.SQUARE;
}
else if (radioButtonSinusY.Checked)
{
m_signalType2D_Y = SIGNAL_TYPE.SINE;
}
else if (radioButtonTriY.Checked)
{
m_signalType2D_Y = SIGNAL_TYPE.SAW;
}
else if (radioButtonSincY.Checked)
{
m_signalType2D_Y = SIGNAL_TYPE.SINC;
}
else if (radioButtonRandomY.Checked)
{
m_signalType2D_Y = SIGNAL_TYPE.RANDOM;
}
}
public void AppendData(float[] x, float[] y, SIGNAL_TYPE signal, int id)
{
// add data to chart array (the x array is superfluous since it contains all the same values, should just be an int, not int[])
//m_chartArrays[signal].AppendData(x, y);
if (m_traces.ContainsKey(id))
{
m_dataPipeline.Post(Tuple.Create <float[], float[], SIGNAL_TYPE, int>(x, y, signal, m_traces[id].traceNum));
m_newDataAdded = true;
}
}
public IndicatorItem(int indID, int methID, string desc, int exFiltPos, int emFiltPos, SIGNAL_TYPE signalType, ref ObservableCollection <SignalTypeContainer> signalTypeList, ref ObservableCollection <FilterContainer> exFiltList, ref ObservableCollection <FilterContainer> emFiltList)
{
_indicatorID = indID;
_methodID = methID;
_description = desc;
_excitationFilterPosition = exFiltPos;
_emissionsFilterPosition = emFiltPos;
_excitationFilterList = exFiltList;
_emissionsFilterList = emFiltList;
_signalTypeList = signalTypeList;
_signalType = signalType;
}
// //////////////////////////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////////////////////////
public void BuildChartArray()
{
m_chartArrays = new Dictionary <SIGNAL_TYPE, ChartArray>();
int initialYmax = 1;
int initialXmax = 10;
int aggregateWidth = 256;
int aggregateHeight = 256;
if (m_aggregateChart != null)
{
aggregateWidth = m_aggregateChart.m_width; aggregateHeight = m_aggregateChart.m_height;
}
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
m_chartArrays.Add(signal, new ChartArray());
m_chartArrays[signal].Init(m_rows, m_cols, m_chartArrayWidth, m_chartArrayHeight, m_margin, m_padding,
aggregateWidth, aggregateHeight,
Colors.DarkBlue, Colors.Black, Color.FromArgb(255, 85, 85, 85), Colors.Black, Colors.White,
Colors.Yellow,
0, initialXmax, 0, initialYmax, m_maxPoints, m_numTraces);
m_chartArrays[signal].Redraw();
m_chartArrays[signal].RedrawAggregate();
}
int maxTraces = m_chartArrays[SIGNAL_TYPE.RAW].GetMaxNumberOfTraces();
if (m_numTraces > maxTraces)
{
m_numTraces = maxTraces;
}
WriteableBitmap bmap = m_bitmap;
m_chartArrays[m_visibleSignal].Refresh(ref bmap);
if (m_aggregateChart != null)
{
WriteableBitmap aggregateBitmapRef = m_aggregateChart.m_bitmap;
m_chartArrays[m_visibleSignal].RefreshAggregate(ref aggregateBitmapRef);
}
// creat the range of each series
m_chartSelected = new bool[m_rows, m_cols];
m_allChartsInColumnSelected = new bool[m_cols];
m_allChartsInRowSelected = new bool[m_rows];
SetUpChartArrayButtons();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public ITargetBlock <Tuple <float[], float[], SIGNAL_TYPE, int> > CreateDataPipeline(CancellationToken cancelToken,
Dictionary <SIGNAL_TYPE, ChartArray> _charts)
{
Dictionary <SIGNAL_TYPE, ChartArray> charts = _charts;
float[] axisRange = new float[4];
var AddData = new ActionBlock <Tuple <float[], float[], SIGNAL_TYPE, int> >(inputData =>
{
// INPUTS:
// item 1 - x data array
// item 2 - y data array
// item 3 - the data's signal type, i.e. RAW, STATIC_RATIO, CONTROL_SUBTRACTION, or DYNAMIC_RATIO
// item 4 - the index of the indicator to which this data belongs
float[] x = inputData.Item1;
float[] y = inputData.Item2;
SIGNAL_TYPE signalType = inputData.Item3;
int indicatorNdx = inputData.Item4;
try
{
if (signalType == SIGNAL_TYPE.RAW)
{
m_totalPoints++;
}
charts[signalType].AppendData(x, y, indicatorNdx);
}
catch (OperationCanceledException)
{
return;
}
},
new ExecutionDataflowBlockOptions
{
// TaskScheduler = uiTask,
CancellationToken = cancelToken,
MaxDegreeOfParallelism = 1
});
return(AddData);
}
public void SetTraceColor(SIGNAL_TYPE signal, int traceNum, Color color)
{
m_chartArrays[signal].SetTraceColor(traceNum, color);
// find trace id from the given signal and traceNum
foreach (KeyValuePair <int, MultiChartArray_TraceItem> item in m_traces)
{
if (item.Value.traceNum == traceNum)
{
int id = item.Value.id;
m_traceColors[Tuple.Create <int, SIGNAL_TYPE>(id, signal)] = color;
break;
}
}
UpdateTraceColorLegend();
}
private void AnalysisRadioButton_Click(object sender, RoutedEventArgs e)
{
if (sender.GetType() != typeof(RadioButton))
{
return;
}
RadioButton rb = (RadioButton)sender;
string tag = (string)rb.Tag;
switch (tag)
{
case "Raw":
m_visibleSignal = SIGNAL_TYPE.RAW;
m_aggregateChart.SetHeaderText("Raw");
break;
case "StaticRatio":
m_visibleSignal = SIGNAL_TYPE.STATIC_RATIO;
m_aggregateChart.SetHeaderText("Static Ratio");
break;
case "ControlSubtraction":
m_visibleSignal = SIGNAL_TYPE.CONTROL_SUBTRACTION;
m_aggregateChart.SetHeaderText("Control Subtraction");
break;
case "DynamicRatio":
m_visibleSignal = SIGNAL_TYPE.DYNAMIC_RATIO;
m_aggregateChart.SetHeaderText("Dynamic Ratio");
break;
default:
m_visibleSignal = SIGNAL_TYPE.RAW;
m_aggregateChart.SetHeaderText("Raw");
break;
}
m_guiPipeline.Post(Tuple.Create <int[], int[], SIGNAL_TYPE, int, COMMAND_TYPE>(null, null, m_visibleSignal, 0, COMMAND_TYPE.REFRESH));
UpdateTraceColorLegend();
}
private void radioButtonSquare_CheckedChanged(object sender, EventArgs e)
{
if (radioButtonSquare.Checked)
{
m_signalType1D = SIGNAL_TYPE.SQUARE;
}
else if (radioButtonSine.Checked)
{
m_signalType1D = SIGNAL_TYPE.SINE;
}
else if (radioButtonTriangle.Checked)
{
m_signalType1D = SIGNAL_TYPE.SAW;
}
else if (radioButtonSinc.Checked)
{
m_signalType1D = SIGNAL_TYPE.SINC;
}
else if (radioButtonRandom.Checked)
{
m_signalType1D = SIGNAL_TYPE.RANDOM;
}
}
public void Init(int rows, int cols, int margin, int padding, int maxNumPoints, List <MultiChartArray_TraceItem> traces)
{
int numTraces = traces.Count;
m_vm = new MultiChartArray_ViewModel(rows, cols, padding, margin, maxNumPoints, traces);
DataContext = m_vm;
////////////////////////////////////////////////////////////////////////////////////////
m_mouseDownRow = -1;
m_mouseDownCol = -1;
m_numPoints = 0;
InitializeComponent();
m_visibleSignal = SIGNAL_TYPE.RAW;
m_buttonColorNotSelected = Colors.LightGray;
m_buttonColorSelected = Colors.Red;
m_rowButton = new List <Button>();
m_columnButton = new List <Button>();
BuildChartArray();
SetupVisiblityCheckBoxes(m_vm.traces);
m_refreshTimer = new DispatcherTimer();
m_refreshTimer.Tick += M_refreshTimer_Tick;
m_refreshTimer.Interval = TimeSpan.FromMilliseconds(100);
m_refreshTimer.Start();
m_newDataAdded = false;
m_dataPipeline = CreateDataPipeline(m_tokenSource.Token, m_chartArrays);
m_guiPipeline = CreateGuiPipeline(m_uiTask, m_tokenSource.Token, m_chartArrays, m_vm);
}
private void radioButton_arb_ch2_CheckedChanged(object sender, EventArgs e)
{
if (radioButton_arb_ch2.Checked)
{
takeGenSemaphore(5005);
signal_leng_ch2 = arb_signal_ch2.Length;
signalType_ch2 = SIGNAL_TYPE.ARB;
validateArbLength();
giveGenSemaphore();
}
}
public void Init(int rows, int cols, int maxNumPoints, List <MultiChartArray_TraceItem> traces, AggregateChart aggregateChart)
{
int numTraces = traces.Count;
int margin = 1;
int padding = 3;
////////////////////////////////////////////////////////////////////////////////////////////////
m_chartArrayWidth = 0;
m_chartArrayHeight = 0;
m_cols = cols;
m_rows = rows;
m_padding = padding;
m_margin = margin;
m_maxPoints = maxNumPoints;
m_numTraces = traces.Count;
m_aggregateChart = aggregateChart;
// initialize traces and trace colors
int traceNum = 0;
m_traces = new Dictionary <int, MultiChartArray_TraceItem>();
m_traceColors = new Dictionary <Tuple <int, MultiChartArray.SIGNAL_TYPE>, Color>();
foreach (MultiChartArray_TraceItem item in traces)
{
item.traceNum = traceNum;
m_traces.Add(item.id, item);
traceNum++;
// initialize trace colors
foreach (int value in Enum.GetValues(typeof(MultiChartArray.SIGNAL_TYPE)))
{
MultiChartArray.SIGNAL_TYPE signal = (MultiChartArray.SIGNAL_TYPE)value;
m_traceColors.Add(Tuple.Create <int, MultiChartArray.SIGNAL_TYPE>(item.id, signal), Colors.Yellow); // default to yellow
}
}
int pixelsPerChart = 42;
int newWidth = (pixelsPerChart * m_cols) + ((m_cols - 1) * m_padding) + (2 * m_margin);
int newHeight = (pixelsPerChart * m_rows) + ((m_rows - 1) * m_padding) + (2 * m_margin);
byte[] img = SynthesizeImage(newWidth, newHeight);
SetBitmap(img, newWidth, newHeight);
if (aggregateChart != null)
{
aggregateChart.SetBitmap(img, newWidth / 2, newHeight / 2);
aggregateChart.SetRanges(1, 0, 1);
}
////////////////////////////////////////////////////////////////////////////////////////
m_mouseDownRow = -1;
m_mouseDownCol = -1;
m_numPoints = 0;
InitializeComponent();
m_visibleSignal = SIGNAL_TYPE.RAW;
m_buttonColorNotSelected = Colors.LightGray;
m_buttonColorSelected = Colors.Red;
m_rowButton = new List <Button>();
m_columnButton = new List <Button>();
BuildChartArray();
SetupVisiblityCheckBoxes(m_traces);
m_refreshTimer = new DispatcherTimer();
m_refreshTimer.Tick += M_refreshTimer_Tick;
m_refreshTimer.Interval = TimeSpan.FromMilliseconds(100);
m_refreshTimer.Start();
m_newDataAdded = false;
m_dataPipeline = CreateDataPipeline(m_tokenSource.Token, m_chartArrays);
m_guiPipeline = CreateGuiPipeline(m_uiTask, m_tokenSource.Token, m_chartArrays, aggregateChart);
if (aggregateChart != null)
{
aggregateChart.SizeChanged += AggregateChart_SizeChanged;
}
}
private void radioButton_sine_ch1_CheckedChanged(object sender, EventArgs e)
{
if (radioButton_sine_ch1.Checked)
{
takeGenSemaphore(5001);
signalType_ch1 = SIGNAL_TYPE.SINE;
validateArbLength();
giveGenSemaphore();
}
}
public void SetTraceVisibility(SIGNAL_TYPE signal, int traceNum, bool isVisible)
{
m_chartArrays[signal].SetTraceVisibility(traceNum, isVisible);
}
private void radioButton_square_ch2_CheckedChanged(object sender, EventArgs e)
{
if (radioButton_square_ch2.Checked)
{
takeGenSemaphore(5007);
signalType_ch2 = SIGNAL_TYPE.SQUARE;
validateArbLength();
giveGenSemaphore();
}
}
public void SetDefaultChartRanges(SIGNAL_TYPE signal, float xmin, float xmax, float ymin, float ymax)
{
m_chartArrays[signal].SetIntialRanges((int)signal, xmin, xmax, ymin, ymax);
m_guiPipeline.Post(Tuple.Create <int[], int[], SIGNAL_TYPE, int, COMMAND_TYPE>(null, null, signal, 0, COMMAND_TYPE.RESET));
}
public ITargetBlock <Tuple <int[], int[], SIGNAL_TYPE, int, COMMAND_TYPE> > CreateGuiPipeline(TaskScheduler uiTask,
CancellationToken cancelToken,
Dictionary <SIGNAL_TYPE, ChartArray> _charts,
AggregateChart _aggregateChart)
{
Dictionary <SIGNAL_TYPE, ChartArray> charts = _charts;
AggregateChart aggregateChart = _aggregateChart;
SIGNAL_TYPE visibleSignal = SIGNAL_TYPE.RAW;
float[] axisRange = new float[4];
var GuiUpdates = new ActionBlock <Tuple <int[], int[], SIGNAL_TYPE, int, COMMAND_TYPE> >(inputData =>
{
// INPUTS:
// item 1 - x data array
// item 2 - y data array
// item 3 - the data's signal type, i.e. RAW, STATIC_RATIO, CONTROL_SUBTRACTION, or DYNAMIC_RATIO
// item 4 - the index of the indicator to which this data belongs
// item 5 - command type that is put on the queue. Depending on what this is, the previous parameters are
// interpreted differently. For example, if it is RESIZE, the new bitmap dimensions should be
// in x and y (items 1 and 2 above). The new chartArray should be x[0], y[0],
// and the new aggregate chart should be x[1], y[1].
if (inputData == null)
{
return;
}
int[] x = inputData.Item1;
int[] y = inputData.Item2;
SIGNAL_TYPE signalType = inputData.Item3;
int indicatorNdx = inputData.Item4;
COMMAND_TYPE commandType = inputData.Item5;
try
{
switch (commandType)
{
case COMMAND_TYPE.RESIZE:
// resize chartArray and aggregate bitmaps
// find the optimal size to best fit the Actual window size
int pixelWidthPerChart = (x[0] - (2 * m_margin) - ((m_cols - 1) * m_padding)) / m_cols;
int pixelHeightPerChart = (y[0] - (2 * m_margin) - ((m_rows - 1) * m_padding)) / m_rows;
int w = (pixelWidthPerChart * m_cols) + ((m_cols - 1) * m_padding) + (2 * m_margin);
int h = (pixelHeightPerChart * m_rows) + ((m_rows - 1) * m_padding) + (2 * m_margin);
if (w != m_chartArrayWidth || h != m_chartArrayHeight)
{
m_chartArrayWidth = w;
m_chartArrayHeight = h;
if (aggregateChart != null)
{
aggregateChart.SetBitmap(BitmapFactory.New(x[1], y[1]));
}
m_bitmap = BitmapFactory.New(w, h);
m_overlay = BitmapFactory.New(w, h);
imageBitmap.Source = m_bitmap;
overlayBitmap.Source = m_overlay;
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
charts[signal].Resize(w, h, x[1], y[1]);
}
}
// refresh chart array
charts[visibleSignal].Redraw();
WriteableBitmap bitmapRef4 = m_bitmap;
charts[visibleSignal].Refresh(ref bitmapRef4);
// refresh aggregate chart
if (aggregateChart != null)
{
charts[visibleSignal].RedrawAggregate();
WriteableBitmap aggregateBitmapRef4 = aggregateChart.m_bitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef4);
}
break;
case COMMAND_TYPE.REFRESH:
visibleSignal = signalType;
// refresh chart array image
charts[visibleSignal].Redraw();
WriteableBitmap bitmapRef1 = m_bitmap;
charts[visibleSignal].Refresh(ref bitmapRef1);
// refresh aggregate image
if (aggregateChart != null)
{
charts[visibleSignal].RedrawAggregate();
WriteableBitmap aggregateBitmapRef4 = aggregateChart.m_bitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef4);
// update the range labels
charts[visibleSignal].GetRanges(ref axisRange, indicatorNdx);
aggregateChart.SetRanges(axisRange[1], axisRange[2], axisRange[3]);
}
break;
case COMMAND_TYPE.RESET:
// clears data from all charts
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
charts[signal].Reset();
charts[signal].Redraw();
charts[signal].RedrawAggregate();
}
WriteableBitmap bitmapRef2 = m_bitmap;
charts[visibleSignal].Refresh(ref bitmapRef2);
if (aggregateChart != null)
{
WriteableBitmap aggregateBitmapRef2 = aggregateChart.m_bitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef2);
// update the range labels
charts[visibleSignal].GetRanges(ref axisRange, indicatorNdx);
aggregateChart.SetRanges(axisRange[1], axisRange[2], axisRange[3]);
}
m_totalPoints = 0;
break;
case COMMAND_TYPE.SET_SELECTED:
// have to convert to a 1D bool array, because that's what is needed by the C++ function
bool[] temp = new bool[m_rows * m_cols];
for (int r = 0; r < m_rows; r++)
{
for (int c = 0; c < m_cols; c++)
{
temp[r * m_cols + c] = m_chartSelected[r, c];
}
}
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
// refresh chart array
charts[signal].Redraw();
if (signal == visibleSignal)
{
WriteableBitmap bitmapRef3 = m_bitmap;
charts[signal].SetSelectedCharts(temp, ref bitmapRef3);
}
else
{
charts[signal].SetSelectedCharts(temp);
}
if (aggregateChart != null)
{
// refresh aggregate chart
charts[signal].RedrawAggregate();
if (signal == visibleSignal)
{
WriteableBitmap aggregateBitmapRef3 = aggregateChart.m_bitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef3);
}
}
}
break;
}
}
catch (OperationCanceledException)
{
return;
}
},
new ExecutionDataflowBlockOptions
{
TaskScheduler = uiTask,
CancellationToken = cancelToken,
MaxDegreeOfParallelism = 4
});
return(GuiUpdates);
}
