sure. it's a little convoluted, but i will try to explain it.
// basebandBits is my string of 1's and 0's.
// flagArray is the exact same length as basebandBits. if i want to graph the bit as white (i.e. no error), flagArray[index] = 0. if the bit is to be graphed
// in red, flagArray[index] = 1. my algorithm was to find groups of same color and graph the group.... meaning, if i find a white, graph as many whites as possible
// for efficiency reasons.
int index = 0;
// loop through the string of 1's and 0's
while (index < basebandBits.Length)
{
// these lists hold the info to be graphed.
ArrayList goodIndices = new ArrayList();
ArrayList badIndices = new ArrayList();
// while the flagArray[index] value is zero (i.e. no error, therefore, white graph)
while (flagArray[index] == 0)
{
// add the actual value to be graphed (either a 1 or 0) to goodIndices. cast it as double per
// PlotYAppend param reqs.
goodIndices.Add(Convert.ToInt32(basebandBits.Substring(index,1)));
// add a NaN to the badIndices array so that the graph is effectively blanked out over this index.
badIndices.Add(Double.NaN);
// determine if the next index is out of range (longer than baseband string)
if (index + 1 < basebandBits.Length)
{
// if not, increase the index and grab the next bit in the array.
index++;
}
else
{
index++;
break;
}
}
// these double arrays will be filled with the values populated in the ArrayLists.
// PlotYAppend will plot these arrays.
double[] goodDataToPlot =new double[goodIndices.Count];
double[] badDataNans = new double[badIndices.Count];
for (int x = 0; x < goodIndices.Count; x++)
{
goodDataToPlot[x] = Convert.ToInt32(goodIndices[x]);
badDataNans[x] = Double.NaN;
}
// plot.
signalPlotGood.PlotYAppend(goodDataToPlot);
signalPlotBad.PlotYAppend(badDataNans);
// clear the ArrayLists.
goodIndices.Clear();
badIndices.Clear();
