public void StartSimulationTimer(int interval)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
LoadSimulationConfiguration();
int hBinning = 1, vBinning = 1;
ChartArray.BuildChartArray(m_mask.Rows, m_mask.Cols, hBinning, vBinning, m_indicatorList);
////////////////////////////////////////////////////
//m_uiTask = TaskScheduler.FromCurrentSynchronizationContext();
Dictionary <int, ImageDisplay> idDictionary = ChartArray.GetImageDisplayDictionary();
m_displayPipeline = m_imager.CreateDisplayPipeline(m_uiTask, idDictionary);
m_storagePipeline = m_imager.CreateImageStoragePipeline(GlobalVars.CompressionAlgorithm, m_iParams.imageWidth, m_iParams.imageHeight);
if (ChartArray != null)
{
m_analysisPipeline = m_imager.CreateAnalysisPipeline(ChartArray, m_mask, m_iParams.imageWidth,
m_iParams.imageHeight, m_iParams.HorzBinning, m_iParams.VertBinning,
m_iParams.ExperimentIndicatorID, m_controlSubtractionWellList, m_numFoFrames,
m_dynamicRatioNumerator.ExperimentIndicatorID,
m_dynamicRatioDenominator.ExperimentIndicatorID);
}
if (m_histogram != null)
{
m_histogramPipeline = m_imager.CreateHistogramPipeline(m_uiTask, m_histogram);
}
/////////////////////////////////////////////////////////
// use reference images as simulated images from camera
bool success = m_wgDB.GetAllReferenceImages();
m_simulationImageList = new List <ushort[]>();
foreach (ReferenceImageContainer image in m_wgDB.m_refImageList)
{
ushort[] img = new ushort[image.Width * image.Height];
Buffer.BlockCopy(image.ImageData, 0, img, 0, image.NumBytes);
m_simulationImageList.Add(img);
}
m_simulationTimer = new DispatcherTimer();
m_simulationTimer.Tick += m_simulationTimer_Tick;
m_simulationTimer.Interval = TimeSpan.FromMilliseconds(interval);
m_simulationTime = 0;
m_timerStartDateTime = DateTime.Now;
m_simulationTimer.Start();
stopwatch.Stop();
PostMessage("startup time = " + stopwatch.ElapsedMilliseconds.ToString());
}
public void Configure(ImagingParameters iParams, ProjectContainer project, PlateContainer plate, ExperimentContainer experiment,
MethodContainer method,
MaskContainer mask, PlateTypeContainer plateType,
ObservableCollection <ExperimentIndicatorContainer> indicatorList,
ObservableCollection <ExperimentCompoundPlateContainer> compoundPlateList,
ObservableCollection <Tuple <int, int> > controlSubtractionWellList,
int numFoFrames,
ExperimentIndicatorContainer dynamicRatioNumerator,
ExperimentIndicatorContainer dynamicRatioDenominator)
{
m_iParams = iParams;
m_project = project;
m_experimentPlate = plate;
m_experiment = experiment;
m_method = method;
m_mask = mask;
m_plateType = plateType;
m_indicatorList = indicatorList;
m_compoundPlateList = compoundPlateList;
m_controlSubtractionWellList = controlSubtractionWellList;
m_numFoFrames = numFoFrames;
m_dynamicRatioNumerator = dynamicRatioNumerator;
m_dynamicRatioDenominator = dynamicRatioDenominator;
m_vworksProtocolFilename = m_method.BravoMethodFile;
ChartArray.BuildChartArray(mask.Rows, mask.Cols, m_iParams.HorzBinning, m_iParams.VertBinning, m_indicatorList);
Dictionary <int, ImageDisplay> idDictionary = ChartArray.GetImageDisplayDictionary();
m_displayPipeline = m_imager.CreateDisplayPipeline(m_uiTask, idDictionary);
m_storagePipeline = m_imager.CreateImageStoragePipeline(GlobalVars.CompressionAlgorithm, m_iParams.imageWidth, m_iParams.imageHeight);
int numerID = 0;
int denomID = 0;
if (m_dynamicRatioNumerator != null)
{
numerID = m_dynamicRatioNumerator.ExperimentIndicatorID;
}
if (m_dynamicRatioDenominator != null)
{
denomID = m_dynamicRatioDenominator.ExperimentIndicatorID;
}
m_analysisPipeline = m_imager.CreateAnalysisPipeline(ChartArray, m_mask, m_iParams.imageWidth,
m_iParams.imageHeight, m_iParams.HorzBinning, m_iParams.VertBinning,
m_iParams.ExperimentIndicatorID, m_controlSubtractionWellList, m_numFoFrames,
numerID, denomID);
if (m_histogram != null)
{
m_histogramPipeline = m_imager.CreateHistogramPipeline(m_uiTask, m_histogram);
}
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
public async void StartVideo(ImagingParameters iParams)
{
if (m_imager == null)
{
return;
}
//m_uiTask = TaskScheduler.FromCurrentSynchronizationContext();
m_tokenSource = new CancellationTokenSource();
m_cancelToken = m_tokenSource.Token;
Progress <int> progress = new Progress <int>();
progress.ProgressChanged += (sender1, num) =>
{
VM.MessageText = num.ToString() + " images";
};
Dictionary <int, ImageDisplay> imageDisplayDictionary = ChartArray.GetImageDisplayDictionary();
foreach (KeyValuePair <int, ImageDisplay> entry in imageDisplayDictionary)
{
ImageDisplay imageDisplay = entry.Value;
imageDisplay.SetImageSize(iParams.imageWidth, m_iParams.imageHeight, m_iParams.maxPixelValue);
}
Task ImagingTask = Task.Factory.StartNew(() => m_imager.StartImaging(m_iParams,
Tuple.Create(m_mask, m_controlSubtractionWellList, m_numFoFrames,
m_dynamicRatioNumerator.ExperimentIndicatorID,
m_dynamicRatioDenominator.ExperimentIndicatorID),
m_cancelToken, m_uiTask, progress,
null, m_colorModel.m_colorMap, m_histogram, ChartArray), m_cancelToken);
try
{
await ImagingTask;
}
catch (AggregateException aggEx)
{
StringBuilder sb = new StringBuilder();
sb.Append("Exception(s) occurred: ");
foreach (Exception ex in aggEx.InnerExceptions)
{
sb.Append(ex.Message);
sb.Append(", ");
}
MessageBoxResult result = MessageBox.Show(sb.ToString(), "Exception(s) Occurred", MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
MessageBoxResult result = MessageBox.Show(ex.Message, "Unknown Exception Occurred", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
ImagingTask.Dispose();
}
}
void m_vworks_PostVWorksCommandEvent(object sender, WaveGuideEvents.VWorksCommandEventArgs e)
{
VWORKS_COMMAND command = e.Command;
int param1 = e.Param1;
string name = e.Name;
string desc = e.Description;
int sequenceNumber = m_imager.GetSequenceCount();
bool success;
EventMarkerContainer eventMarker;
switch (command)
{
case VWORKS_COMMAND.Protocol_Aborted:
PostMessage("VWorks - Protocol Aborted");
m_dispatcher.Invoke((Action)(() =>
{
m_timer.Stop();
VM.DelayText = "";
m_tokenSource.Cancel(); // stops the imaging task
VM.RunState = RunExperiment_ViewModel.RUN_STATE.ABORTED;
SetButton(VM.RunState);
}));
break;
case VWORKS_COMMAND.Protocol_Resumed:
PostMessage("VWorks - Protocol Resumed");
m_dispatcher.Invoke((Action)(() =>
{
m_timer.Stop();
VM.DelayText = "";
VM.DelayHeaderVisible = false;
}));
break;
case VWORKS_COMMAND.Protocol_Complete:
PostMessage("VWorks - Protocol Complete");
m_dispatcher.Invoke((Action)(() =>
{
m_timer.Stop();
VM.DelayText = "";
VM.DelayHeaderVisible = false;
m_tokenSource.Cancel(); // make sure the imaging task stops
VM.RunState = RunExperiment_ViewModel.RUN_STATE.FINISHED;
SetButton(VM.RunState);
ReportDialog dlg = new ReportDialog(m_project, m_experiment, m_indicatorList);
dlg.ShowDialog();
}));
break;
case VWORKS_COMMAND.Protocol_Paused:
PostMessage("VWorks - Protocol Paused");
m_dispatcher.Invoke((Action)(() =>
{
m_delayTime = param1;
VM.DelayHeaderVisible = true;
m_timer.Start();
}));
break;
case VWORKS_COMMAND.Event_Marker:
PostMessage("VWorks - Event Marker");
m_dispatcher.Invoke((Action)(() =>
{
ChartArray.AddEventMarker(sequenceNumber, desc);
eventMarker = new EventMarkerContainer();
eventMarker.Description = desc;
eventMarker.ExperimentID = m_experiment.ExperimentID;
eventMarker.Name = name;
eventMarker.SequenceNumber = sequenceNumber;
eventMarker.TimeStamp = DateTime.Now;
success = m_wgDB.InsertEventMarker(ref eventMarker);
if (!success)
{
PostMessage("Database Error in InsertEventMarker: " + m_wgDB.GetLastErrorMsg());
}
}));
break;
case VWORKS_COMMAND.Initialization_Complete:
PostMessage("VWorks Initialization Complete");
m_dispatcher.Invoke((Action)(() =>
{
BringWindowToFront();
}));
break;
case VWORKS_COMMAND.Pause_Until:
//PostMessage("VWorks - Pause Until");
m_dispatcher.Invoke((Action)(() =>
{
m_delayTime = param1;
VM.DelayHeaderVisible = true;
VM.DelayText = ((int)(m_delayTime / 1000)).ToString();
m_timer.Start();
}));
break;
case VWORKS_COMMAND.Set_Time_Marker:
//PostMessage("VWorks - Set Time Marker");
break;
case VWORKS_COMMAND.Start_Imaging:
PostMessage("VWorks - Start Imaging");
/////////////////////////////////////////////////////////////////////////////////
/// Start Imaging Task
m_dispatcher.Invoke((Action)(() =>
{
BringWindowToFront();
}));
StartImaging_2(10000);
////////////////////////////////////////////////////////////////////////////////
break;
case VWORKS_COMMAND.Stop_Imaging:
PostMessage("VWorks - Stop Imaging");
m_dispatcher.Invoke((Action)(() =>
{
StopImaging();
}));
break;
case VWORKS_COMMAND.Unrecoverable_Error:
PostMessage("VWorks - Unrecoverable Error" + ", " + name + ", " + desc);
m_dispatcher.Invoke((Action)(() =>
{
m_timer.Stop();
VM.DelayText = "";
m_tokenSource.Cancel(); // stops the imaging task
VM.RunState = RunExperiment_ViewModel.RUN_STATE.ERROR;
SetButton(VM.RunState);
}));
break;
case VWORKS_COMMAND.Error:
PostMessage("VWorks - Error" + ", " + name + ", " + desc);
m_dispatcher.Invoke((Action)(() =>
{
m_timer.Stop();
VM.DelayText = "";
VM.DelayHeaderVisible = false;
m_tokenSource.Cancel(); // stops the imaging task
VM.RunState = RunExperiment_ViewModel.RUN_STATE.ERROR;
SetButton(VM.RunState);
}));
break;
case VWORKS_COMMAND.Message:
PostMessage("VWorks - Message, " + name + ", " + desc);
break;
default:
break;
}
}
