public override void Render(double time, double timestretch, XElement channel)
{
int channelNum = 0;
int numOfChannels = 0;
// prüfen, ob eine bestimmte RenderSlice oder alle RenderSlice gerendert werden.
if (channel != null)
{
// wenn nur eine bestimmte RS gerendert werden soll, werden die For-Schleife nur einmal ausgeführt.
channelNum = MeasurementEntry.GetChannelNum(channel);
numOfChannels = channelNum + 1;
}
else
{
// Sonst werden alle Kanäle (alle RenderSlice) durch die Schleife neu gerendert.
channelNum = 0;
numOfChannels = this.channels;
}
for (int c = channelNum; c < numOfChannels; ++c)
{
if (RenderSlices[c] != null)
{
((RasterRenderSlice)RenderSlices[c]).WBmp.Lock();
}
}
double samplesperpixel = this.samplespersec * timestretch / this.imageheight;
// (kontinuierliche) nummer des samples
double s = time * this.samplespersec;
double peakend = s + samplesperpixel;
if (RendererManager.SampleAndHold)
{
this.RenderSampleAndHold(this.imageheight, samplesperpixel, s, peakend, channelNum, numOfChannels);
}
if (RendererManager.Point)
{
this.RenderPoint(this.imageheight, samplesperpixel, s, peakend, channelNum, numOfChannels);
}
if (RendererManager.Linear)
{
this.RenderLinear(this.imageheight, samplesperpixel, s, peakend, channelNum, numOfChannels);
}
for (int c = channelNum; c < numOfChannels; ++c)
{
if (RenderSlices[c] != null)
{
if (((RasterRenderSlice)RenderSlices[c]).WBmp.PixelWidth != this.dirtyrect.Width)
{
this.dirtyrect.Width = ((RasterRenderSlice)RenderSlices[c]).WBmp.PixelWidth;
}
((RasterRenderSlice)RenderSlices[c]).WBmp.AddDirtyRect(this.dirtyrect);
((RasterRenderSlice)RenderSlices[c]).WBmp.Unlock();
}
}
}
internal MeasurementEntryImpl(MeasurementEntry measurementEntry)
: base(measurementEntry)
{
adcResolution = measurementEntry.getAdcResolution();
adcZero = measurementEntry.getAdcZero();
baseline = measurementEntry.getBaseline();
channelNames = (string[])measurementEntry.getChannelNames().Clone();
dataType = measurementEntry.getDataType();
lsbValue = measurementEntry.getLsbValue();
unit = measurementEntry.getUnit();
}
/// <summary>
/// Gets the length of the signal.
/// </summary>
/// <param name="unisensxml">The unisensxml.</param>
/// <param name="selectedsignals">The selectedsignals.</param>
/// <returns>length of the signal</returns>
private static double GetSignalLength(XDocument unisensxml, IEnumerable <XElement> selectedsignals)
{
double length = -1;
try
{
XElement unisens = unisensxml.Root;
if (unisens != null)
{
XAttribute duration = unisens.Attribute("duration");
length = double.Parse(duration.Value, System.Globalization.CultureInfo.InvariantCulture);
}
}
catch (Exception)
{
foreach (XElement xe in selectedsignals)
{
// no DURATION attribut existent -> calculate duration (in seconds) with length of signal entry
switch (xe.Name.LocalName)
{
case "signalEntry":
case "valuesEntry":
case "customEntry":
// length = length_of_file / (bytes_per_sample * number_of_channels * sample_rate)
if (SignalEntry.GetFileFormat(xe) == FileFormat.Bin)
{
length = new FileInfo(SignalEntry.GetId(xe)).Length /
(SignalEntry.GetDataTypeBytes(SignalEntry.GetBinDataType(xe)) *
MeasurementEntry.GetNumChannels(xe) *
MeasurementEntry.GetSampleRate(xe));
}
break;
}
// Exit the foreach loop when length is calculated
if (length > 0)
{
break;
}
}
}
if (length < 0)
{
throw new Exception("Cannot cut a file without duration information");
}
return(length);
}
private static double GetMaxSampleRate(IEnumerable <XElement> selectedsignals)
{
double max = 0.0;
foreach (XElement xe in selectedsignals)
{
double sr = MeasurementEntry.GetSampleRate(xe);
if (sr > max)
{
max = sr;
}
}
return(max);
}
public IEnumerable <XElement> Main(XDocument unisensxml, IEnumerable <XElement> selectedsignals, double time_cursor, double time_start, double time_end, string parameter)
{
if (time_start >= time_end)
{
return(null);
}
if (MessageBox.Show("Es werden alle Messdaten unwiderruflich gelöscht, die außerhalb des markierten Bereichs liegen!", "Crop", MessageBoxButton.OKCancel, MessageBoxImage.Warning, MessageBoxResult.Cancel) == MessageBoxResult.Cancel)
{
return(null);
}
// If you want to delete more than 10 % of the signal, an extra warning is given.
double length = Crop.GetSignalLength(unisensxml, selectedsignals);
if (time_end - time_start < length * 0.9)
{
if (MessageBox.Show("Sind Sie Sich sicher, dass Sie mehr als 10% der Daten löschen wollen?", "Delete", MessageBoxButton.YesNo, MessageBoxImage.Warning, MessageBoxResult.No) == MessageBoxResult.No)
{
return(null);
}
}
foreach (XElement xe in selectedsignals)
{
switch (xe.Name.LocalName)
{
case "signalEntry":
case "eventEntry":
case "valuesEntry":
switch (MeasurementEntry.GetFileFormat(xe))
{
case FileFormat.Bin: CropBinary(xe, time_start, time_end); break;
case FileFormat.Csv: CropCsv(xe, time_start, time_end); break;
}
break;
}
}
return(null);
}
public static double GetSignalLength(XDocument unisensxml, IEnumerable <XElement> selectedsignals)
{
double length = 0;
try
{
XElement xUnisens = unisensxml.Root;
if (xUnisens != null)
{
length = double.Parse(xUnisens.Attribute("duration").Value);
}
}
catch (Exception e)
{
foreach (XElement xe in selectedsignals)
{
// no DURATION attribut existent -> calculate duration (in seconds) with length of signal entry
switch (xe.Name.LocalName)
{
case "signalEntry":
// length = length_of_file / (bytes_per_sample * number_of_channels * sample_rate)
length = new FileInfo(SignalEntry.GetId(xe)).Length /
(SignalEntry.GetDataTypeBytes(SignalEntry.GetBinDataType(xe)) *
MeasurementEntry.GetNumChannels(xe) *
MeasurementEntry.GetSampleRate(xe));
break;
}
// Exit the foreach loop when length is calculated
if (length > 0)
{
break;
}
}
}
return(length);
}
private void DropChannel(XElement channel, ObservableCollection <RenderSlice> rslist)
{
Renderer r = RendererManager.GetRenderer(channel.Parent);
if (r != null)
{
List <RenderSlice> renderSliceList = new List <RenderSlice>();
int channelNum = MeasurementEntry.GetChannelNum(channel);
if (channelNum != -1)
{
RenderSlice renderSlice = r.GetRenderSlice(channelNum);
this.AttachKillHandler(renderSlice);
this.MoveRenderSlice(renderSlice, rslist);
renderSliceList.Add(renderSlice);
}
RendererManager.AutoZoomIndividual(renderSliceList);
}
}
/// <summary>
/// Main function for plug-ins, called by UnisensViewer.
/// </summary>
/// <param name="unisensxml">unisens.xml file.</param>
/// <param name="selectedsignals">All information from unisens.xml of the selected signals.</param>
/// <param name="path">Path of the current unisens.xml file.</param>
/// <param name="time_cursor">Time in seconds of current cursor position. Is 0, if the plug-in is called via plug-in menu.</param>
/// <param name="time_start">Time in seconds of start of the current selection. Is 0, when no selection exists.</param>
/// <param name="time_end">Time in seconds of end of the current selection. Is 0, when no selection exists.</param>
/// <param name="parameter">Additional parameter of the key bindings.</param>
/// <returns>
/// Returned signals have to be described by the corresponding Unisens XML element (e.g. signalEntry or eventEntry). UnisensViewer displays the returned signals directly.
/// </returns>
public IEnumerable <XElement> Main(XDocument unisensxml, IEnumerable <XElement> selectedsignals, string path, double time_cursor, double time_start, double time_end, string parameter)
{
int sample_start = 0;
int sample_end = 0;
double sampleValueMin = 0;
double sampleValueMax = 0;
string clipboard = string.Empty;
int i = 1;
// When time_cursor is used (context menu or hot key), read data from cursor position. Otherwise read data from selection.
if (time_cursor != 0)
{
time_start = time_cursor;
time_end = time_cursor;
}
foreach (XElement xe in selectedsignals)
{
switch (xe.Name.LocalName)
{
case "signalEntry":
case "valuesEntry":
sample_start = (int)Math.Floor(MeasurementEntry.GetSampleRate(xe) * time_start);
time_start = sample_start / MeasurementEntry.GetSampleRate(xe);
sample_end = (int)Math.Ceiling(MeasurementEntry.GetSampleRate(xe) * time_end);
time_end = sample_end / MeasurementEntry.GetSampleRate(xe);
clipboard += "unisensViewer(" + i + ").cursorTime = [datenum('" + time_start + "', 'SS.FFF'), datenum('" + time_end + "', 'SS.FFF'), ];\n";
clipboard += "unisensViewer(" + i + ").sampleIndex = ['" + sample_start + "', '" + sample_end + "'];\n";
clipboard += "unisensViewer(" + i + ").unit = '" + MeasurementEntry.GetUnit(xe) + "';\n";
////TODO: Read values at position positionSampleStart and positionSampleEnd
sampleValueMin = 1;
sampleValueMax = 2;
clipboard += "unisensViewer(" + i + ").physicalValue = [" + ((sampleValueMin - MeasurementEntry.GetBaseline(xe)) * MeasurementEntry.GetLsbValue(xe)) + ", " + ((sampleValueMax - MeasurementEntry.GetBaseline(xe)) * MeasurementEntry.GetLsbValue(xe)) + "];\n";
clipboard += "unisensViewer(" + i + ").sampleValue = [" + sampleValueMin + ", " + sampleValueMax + "];\n";
i++;
break;
}
}
Clipboard.SetDataObject(clipboard, true);
MessageBox.Show("Cursor data at sample " + sample_start + " copied to clipbaord (Matlab style).\n" + clipboard, "Copy to Clipboard");
// Example (Matlab style):
// unisensViewer(1).cursorTime = ['00:00:00.123', '00:00:01.123'];
// unisensViewer(1).sampleIndex = [532, 2343];
// unisensViewer(1).physicalValue = [5.4384, 5.4385];
// unisensViewer(1).Unit = 'g';
// unisensViewer(1).sampleValue = [23452, 23453];
// Example (Excel style):
// cursor time sample index
// from 00:00:00.123 532
// to 00:00:01.123 2343
//
// physical value sample value
// min 5.4384g 23452
// max 5.4385g 23453
// Example (plain text):
// cursor time
// from 00:00:00.123
// to 00:00:01.123
//
// sample index
// from 532
// to 2343
//
// physical value
// min 5.4384g
// max 5.4385g
//
// sample value
// min 23452
// max 23453
////
return(null);
}
private static bool cropSelection(double time_start, double time_end, XDocument unisensxml, IEnumerable <XElement> selectedsignals)
{
// If you want to delete more than 10 % of the signal, an extra warning is given.
double length = Crop.GetSignalLength(unisensxml, selectedsignals);
if (time_end - time_start < length * 0.9)
{
if (MessageBox.Show("Sind Sie Sich sicher, dass Sie mehr als 10% der Daten löschen wollen?", "Delete", MessageBoxButton.YesNo, MessageBoxImage.Warning, MessageBoxResult.No) == MessageBoxResult.No)
{
return(false);
}
}
// Renderer schließen
foreach (XElement xe in selectedsignals)
{
RendererManager.CloseRenderer(xe);
}
foreach (XElement xe in selectedsignals)
{
switch (xe.Name.LocalName)
{
case "signalEntry":
case "eventEntry":
case "valuesEntry":
switch (MeasurementEntry.GetFileFormat(xe))
{
case FileFormat.Bin:
CropBinary(xe, time_start, time_end);
break;
case FileFormat.Csv:
CropCsv(xe, time_start, time_end);
break;
}
break;
}
}
// Renderer aktivieren
foreach (XElement xe in selectedsignals)
{
try
{
RendererManager.ReOpenRenderer(xe);
}
catch
{
RendererManager.KillRenderer(xe);
}
}
// If duration attribute is known: Recalculate duration attribute
ResetDuration(unisensxml, time_end - time_start);
ResetTimestampStart(unisensxml, time_start);
RendererManager.UpdateTimeMax();
return(true);
}
/// <summary>
/// This function renders a single Renderer Object with all render slices (when channel is null) or only a specific render slice or a renderer (when channel is not null).
/// </summary>
/// <param name="time">time in seconds at the beginning of the signal pane</param>
/// <param name="timestretch">length of the signal pane</param>
/// <param name="channel">specific channel</param>
public override void Render(double time, double timestretch, XElement channel)
{
int channelNum = 0;
int numOfChannels = 0;
// prüfen, ob eine bestimmte RenderSlice oder alle RenderSlice gerendert werden.
if (channel != null)
{
// wenn nur eine bestimmte RS gerendert werden soll, werden die For-Schleife nur einmal ausgeführt.
channelNum = MeasurementEntry.GetChannelNum(channel);
numOfChannels = channelNum + 1;
}
else
{
// Sonst werden alle Kanäle (alle RenderSlice) durch die Schleife neu gerendert.
channelNum = 0;
numOfChannels = this.channels;
}
// Locks all RenderSlice's bitmaps
for (int a = channelNum; a < numOfChannels; ++a)
{
if (this.RenderSlices[a] != null)
{
((RasterRenderSlice)this.RenderSlices[a]).WBmp.Lock();
}
}
double samplesperpixel = this.samplespersec * timestretch / this.imageheight;
// Perform signal interpolation, compression or just render the signal.
if (samplesperpixel < 1)
{
if (RendererManager.SincInterpolation)
{
this.RenderSinc(0, this.imageheight, time * this.samplespersec, samplesperpixel, channelNum, numOfChannels);
}
else
{
this.RenderSampleAndHold(0, this.imageheight, time * this.samplespersec, samplesperpixel, channelNum, numOfChannels);
}
}
else
{
if (RendererManager.PeakSamples)
{
this.RenderPeak(0, this.imageheight, time * this.samplespersec, samplesperpixel, channelNum, numOfChannels);
}
else
{
this.RenderSkip(0, this.imageheight, time * this.samplespersec, samplesperpixel, channelNum, numOfChannels);
}
}
// Change parts of the old bitmap with the new rendered bitmap.
for (int a = channelNum; a < numOfChannels; ++a)
{
if (RenderSlices[a] != null)
{
if (((RasterRenderSlice)this.RenderSlices[a]).WBmp.PixelWidth != this.dirtyrect.Width)
{
this.dirtyrect.Width = ((RasterRenderSlice)this.RenderSlices[a]).WBmp.PixelWidth;
}
((RasterRenderSlice)this.RenderSlices[a]).WBmp.AddDirtyRect(this.dirtyrect);
((RasterRenderSlice)this.RenderSlices[a]).WBmp.Unlock();
}
}
}
