void LoadSimulationConfiguration()
{
// m_iParams = iParams;
// m_project = project;
// m_experimentPlate = plate;
// 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;
//ChartArray.BuildChartArray(mask.Rows, mask.Cols, m_indicatorList);
////////////////////////
// set up project
m_project = null;
bool success = m_wgDB.GetAllProjects(false);
foreach (ProjectContainer project in m_wgDB.m_projectList)
{
if (project.Description.Equals("Debug", StringComparison.OrdinalIgnoreCase))
{
m_project = project;
break;
}
}
if (m_project == null) // not found in database, so create it
{
m_project = new ProjectContainer();
m_project.Description = "Debug";
m_project.TimeStamp = DateTime.Now;
m_project.Archived = false;
success = m_wgDB.InsertProject(ref m_project);
}
////////////////////////
// set up plateType
m_plateType = null;
success = m_wgDB.GetAllPlateTypes();
if (m_wgDB.m_plateTypeList.Count() > 0)
{
m_plateType = m_wgDB.m_plateTypeList.ElementAt(0);
}
else
{
// create a new plateType
m_plateType = new PlateTypeContainer();
m_plateType.Cols = 24;
m_plateType.Description = "Debug";
m_plateType.IsDefault = false;
m_plateType.Rows = 16;
success = m_wgDB.InsertPlateType(ref m_plateType);
}
////////////////////////
// set up experiment plate
m_experimentPlate = null;
success = m_wgDB.GetAllPlatesForProject(m_project.ProjectID);
if (m_wgDB.m_plateList.Count() > 0)
{
m_experimentPlate = m_wgDB.m_plateList.ElementAt(0);
}
else
{
// create a new plate
m_experimentPlate = new PlateContainer();
m_experimentPlate.Barcode = "12345678";
m_experimentPlate.Description = "Debug";
m_experimentPlate.IsPublic = true;
m_experimentPlate.OwnerID = GlobalVars.UserID;
m_experimentPlate.PlateTypeID = m_plateType.PlateTypeID;
m_experimentPlate.ProjectID = m_project.ProjectID;
success = m_wgDB.InsertPlate(ref m_experimentPlate);
}
////////////////////////
// set up method
m_method = null;
success = m_wgDB.GetAllMethodsForUser(GlobalVars.UserID);
foreach (MethodContainer method in m_wgDB.m_methodList)
{
if (method.Description.Equals("Debug", StringComparison.OrdinalIgnoreCase))
{
m_method = method;
break;
}
}
if (m_method == null)
{
m_method = new MethodContainer();
m_method.BravoMethodFile = "";
m_method.Description = "Debug";
m_method.IsPublic = true;
m_method.OwnerID = GlobalVars.UserID;
success = m_wgDB.InsertMethod(ref m_method);
}
success = m_wgDB.GetAllIndicatorsForMethod(m_method.MethodID);
if (m_wgDB.m_indicatorList.Count < 1)
{
// create indicators for this new method
IndicatorContainer ind = new IndicatorContainer();
ind.Description = "Debug";
ind.EmissionsFilterPosition = 6;
ind.ExcitationFilterPosition = 4;
ind.MethodID = m_method.MethodID;
ind.SignalType = SIGNAL_TYPE.UP;
success = m_wgDB.InsertIndicator(ref ind);
}
////////////////////////
// set up experiment
m_experiment = null;
ObservableCollection <ExperimentContainer> expList;
success = m_wgDB.GetAllExperimentsForPlate(m_experimentPlate.PlateID, out expList);
if (expList.Count() > 0)
{
m_experiment = expList.ElementAt(0);
}
else
{
m_experiment = new ExperimentContainer();
m_experiment.Description = "Debug";
m_experiment.HorzBinning = 1;
m_experiment.MethodID = m_method.MethodID;
m_experiment.PlateID = m_experimentPlate.PlateID;
m_experiment.ROI_Height = GlobalVars.PixelHeight;
m_experiment.ROI_Width = GlobalVars.PixelWidth;
m_experiment.ROI_Origin_X = 1;
m_experiment.ROI_Origin_Y = 1;
m_experiment.TimeStamp = DateTime.Now;
m_experiment.VertBinning = 1;
success = m_wgDB.InsertExperiment(ref m_experiment);
}
////////////////////////
// set up mask
m_mask = null;
success = m_wgDB.GetAllMasksForPlateType(m_experimentPlate.PlateTypeID);
if (m_wgDB.m_maskList.Count() > 0)
{
m_mask = m_wgDB.m_maskList.ElementAt(0);
}
else
{
// create a new mask
m_mask = new MaskContainer();
m_mask.Angle = 0.0;
m_mask.Cols = 24;
m_mask.Description = "Debug";
m_mask.IsDefault = false;
m_mask.NumEllipseVertices = 24;
m_mask.PlateTypeID = m_experimentPlate.PlateTypeID;
m_mask.ReferenceImageID = 0;
m_mask.Rows = 16;
m_mask.Shape = 0;
m_mask.XOffset = 28;
m_mask.XSize = 28;
m_mask.XStep = 41.522;
m_mask.YOffset = 190;
m_mask.YSize = 28;
m_mask.YStep = 41.467;
success = m_wgDB.InsertMask(ref m_mask);
}
////////////////////////////////////
// setup test indicator(s)
m_indicatorList = new ObservableCollection <ExperimentIndicatorContainer>();
ObservableCollection <ExperimentIndicatorContainer> expIndList;
success = m_wgDB.GetAllExperimentIndicatorsForExperiment(m_experiment.ExperimentID, out expIndList);
if (expIndList.Count > 0)
{
foreach (ExperimentIndicatorContainer ex in expIndList)
{
m_indicatorList.Add(ex);
}
}
else
{
success = m_wgDB.GetAllIndicatorsForMethod(m_method.MethodID);
foreach (IndicatorContainer ind in m_wgDB.m_indicatorList)
{
ExperimentIndicatorContainer exInd = new ExperimentIndicatorContainer();
exInd.Description = ind.Description;
FilterContainer filter;
success = m_wgDB.GetExcitationFilterAtPosition(ind.ExcitationFilterPosition, out filter);
exInd.ExcitationFilterDesc = filter.Description;
success = m_wgDB.GetEmissionFilterAtPosition(ind.EmissionsFilterPosition, out filter);
exInd.EmissionFilterDesc = filter.Description;
exInd.EmissionFilterPos = ind.EmissionsFilterPosition;
exInd.ExcitationFilterPos = ind.ExcitationFilterPosition;
exInd.ExperimentID = m_experiment.ExperimentID;
exInd.Exposure = 150;
exInd.Gain = 5;
exInd.MaskID = m_mask.MaskID;
exInd.SignalType = SIGNAL_TYPE.UP;
exInd.Verified = true;
success = m_wgDB.InsertExperimentIndicator(ref exInd);
m_indicatorList.Add(exInd);
}
}
////////////////////////////////////
// compound plates
m_compoundPlateList = new ObservableCollection <ExperimentCompoundPlateContainer>();
////////////////////////////////////
// control subtraction well list
m_controlSubtractionWellList = new ObservableCollection <Tuple <int, int> >();
// all wells in last row = control wells
for (int c = 0; c < m_mask.Cols; c++)
{
m_controlSubtractionWellList.Add(Tuple.Create(m_mask.Rows - 1, c));
}
////////////////////////////////////
//m_numFoFrames = numFoFrames;
m_numFoFrames = 5;
if (m_indicatorList.Count() > 1)
{
////////////////////////////////////
//m_dynamicRatioNumerator = dynamicRatioNumerator;
m_dynamicRatioNumerator = m_indicatorList.ElementAt(0);
////////////////////////////////////
//m_dynamicRatioDenominator = dynamicRatioDenominator;
m_dynamicRatioDenominator = m_indicatorList.ElementAt(1);
}
else
{
m_dynamicRatioNumerator = new ExperimentIndicatorContainer();
m_dynamicRatioNumerator.ExperimentIndicatorID = 0;
m_dynamicRatioDenominator = new ExperimentIndicatorContainer();
m_dynamicRatioDenominator.ExperimentIndicatorID = 0;
}
if (m_iParams == null)
{
m_iParams = new ImagingParameters();
}
m_iParams.maxPixelValue = GlobalVars.MaxPixelValue;
m_iParams.imageWidth = GlobalVars.PixelWidth;
m_iParams.imageHeight = GlobalVars.PixelHeight;
m_iParams.Image_StartCol = 1;
m_iParams.Image_EndCol = GlobalVars.PixelWidth;
m_iParams.Image_StartRow = 1;
m_iParams.Image_EndRow = GlobalVars.PixelHeight;
m_iParams.BravoMethodFilename = "";
m_iParams.CameraTemperature = GlobalVars.CameraTargetTemperature;
m_iParams.HorzBinning = 1;
m_iParams.VertBinning = 1;
m_iParams.EmissionFilterChangeSpeed = GlobalVars.FilterChangeSpeed;
m_iParams.ExcitationFilterChangeSpeed = GlobalVars.FilterChangeSpeed;
m_iParams.LightIntensity = 100;
m_iParams.NumImages = 1000000; // artificial limit on number of images
m_iParams.NumIndicators = m_indicatorList.Count;
m_iParams.SyncExcitationFilterWithImaging = true;
m_iParams.CycleTime = new int[m_indicatorList.Count];
m_iParams.EmissionFilter = new byte[m_indicatorList.Count];
m_iParams.ExcitationFilter = new byte[m_indicatorList.Count];
m_iParams.Exposure = new float[m_indicatorList.Count];
m_iParams.Gain = new int[m_indicatorList.Count];
m_iParams.ExperimentIndicatorID = new int[m_indicatorList.Count];
m_iParams.IndicatorName = new string[m_indicatorList.Count];
m_iParams.LampShutterIsOpen = new bool[m_indicatorList.Count];
int i = 0;
foreach (ExperimentIndicatorContainer ind in m_indicatorList)
{
m_iParams.CycleTime[i] = 1000;
m_iParams.EmissionFilter[i] = (byte)ind.EmissionFilterPos;
m_iParams.ExcitationFilter[i] = (byte)ind.ExcitationFilterPos;
m_iParams.Exposure[i] = (float)ind.Exposure / 1000;
m_iParams.Gain[i] = ind.Gain;
m_iParams.ExperimentIndicatorID[i] = 0; // created by the RunExperiment object when the experiment is run
m_iParams.IndicatorName[i] = ind.Description;
m_iParams.LampShutterIsOpen[i] = true;
m_iParams.ExperimentIndicatorID[i] = ind.ExperimentIndicatorID;
i++;
}
}
private void MethodComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (VM.ExpParams.compoundPlateList != null)
{
VM.ExpParams.compoundPlateList.Clear();
}
if (VM.ExpParams.indicatorList != null)
{
VM.ExpParams.indicatorList.Clear();
}
// get selection
VM.ExpParams.method = (MethodContainer)MethodComboBox.SelectedItem;
if (VM.ExpParams.method != null)
{
// get all the compound plates for the Method
bool success = wgDB.GetAllCompoundPlatesForMethod(VM.ExpParams.method.MethodID);
if (success)
{
if (VM.ExpParams.compoundPlateList != null)
{
VM.ExpParams.compoundPlateList.Clear();
}
else
{
VM.ExpParams.compoundPlateList = new ObservableCollection <ExperimentCompoundPlateContainer>();
}
foreach (CompoundPlateContainer cpdPlate in wgDB.m_compoundPlateList)
{
ExperimentCompoundPlateContainer expCpdPlate = new ExperimentCompoundPlateContainer();
expCpdPlate.Barcode = "";
expCpdPlate.Description = cpdPlate.Description;
expCpdPlate.ExperimentCompoundPlateID = 0;
expCpdPlate.ExperimentID = 0;
expCpdPlate.PlateIDResetBehavior = cpdPlate.BarcodeReset;
VM.ExpParams.compoundPlateList.Add(expCpdPlate);
}
// get all the indicators for the Method
success = wgDB.GetAllIndicatorsForMethod(VM.ExpParams.method.MethodID);
if (success)
{
if (VM.ExpParams.indicatorList != null)
{
VM.ExpParams.indicatorList.Clear();
}
else
{
VM.ExpParams.indicatorList = new ObservableCollection <ExperimentIndicatorContainer>();
}
int i = 0;
foreach (IndicatorContainer indicator in wgDB.m_indicatorList)
{
ExperimentIndicatorContainer expIndicator = new ExperimentIndicatorContainer();
expIndicator.Description = indicator.Description;
expIndicator.EmissionFilterPos = indicator.EmissionsFilterPosition;
expIndicator.ExcitationFilterPos = indicator.ExcitationFilterPosition;
expIndicator.ExperimentID = 0; // defined when experiment launched
expIndicator.ExperimentIndicatorID = i; // defined when experiment launched
expIndicator.Exposure = 1; // default
expIndicator.Gain = 1; // default
expIndicator.PreAmpGain = 1; // default
expIndicator.MaskID = 0; // not defined at this point. Assigned when Mask is selected.
expIndicator.Verified = false;
expIndicator.FlatFieldRefImageID = 0; // defined at Indicator Verify
expIndicator.DarkFieldRefImageID = 0; // defined at Indicator Verify
expIndicator.FlatFieldCorrection = FLATFIELD_SELECT.NONE; // default
expIndicator.CycleTime = GlobalVars.Instance.CameraDefaultCycleTime;
expIndicator.SignalType = indicator.SignalType;
FilterContainer filter;
success = wgDB.GetExcitationFilterAtPosition(indicator.ExcitationFilterPosition, out filter);
if (success)
{
if (filter != null)
{
expIndicator.ExcitationFilterDesc = filter.Description;
}
}
success = wgDB.GetEmissionFilterAtPosition(indicator.EmissionsFilterPosition, out filter);
if (success)
{
if (filter != null)
{
expIndicator.EmissionFilterDesc = filter.Description;
}
}
VM.ExpParams.indicatorList.Add(expIndicator);
i++; // increment dummy ExperimentIndicatorID
}
}
}
}
VM.SetExperimentStatus();
if (m_imager.m_ImagingDictionary == null)
{
m_imager.m_ImagingDictionary = new Dictionary <int, ImagingParamsStruct>();
}
else
{
m_imager.m_ImagingDictionary.Clear();
}
foreach (ExperimentIndicatorContainer eic in VM.ExpParams.indicatorList)
{
ImagingParamsStruct ips = new ImagingParamsStruct();
ips.emissionFilterPos = (byte)eic.EmissionFilterPos;
ips.excitationFilterPos = (byte)eic.ExcitationFilterPos;
ips.experimentIndicatorID = eic.ExperimentIndicatorID;
ips.flatfieldType = eic.FlatFieldCorrection;
ips.indicatorName = eic.Description;
ips.binning = m_imager.m_camera.m_acqParams.HBin;
m_imager.m_ImagingDictionary.Add(eic.ExperimentIndicatorID, ips);
}
}
public void Configure(Imager _imager, int indicatorID, bool AllowCameraConfiguration, bool IsManualMode)
{
m_imager = _imager;
m_camera = m_imager.m_camera;
vm = new CameraSetupModel(m_imager, m_wgDB, AllowCameraConfiguration, IsManualMode);
m_ID = indicatorID;
if (IsManualMode) // if this is manual operation (i.e. NOT a verify, prep-for-run, operation), then enable filter changes based on combo-box changes
{
EmissionFilterCB.SelectionChanged += EmissionFilterCB_SelectionChanged;
ExcitationFilterCB.SelectionChanged += ExcitationFilterCB_SelectionChanged;
}
///////////////////////////////////////////////////////////////////////////////////
// Set ImagingParamsStruct
ImagingParamsStruct ips;
if (m_imager.m_ImagingDictionary.ContainsKey(m_ID))
{
ips = m_imager.m_ImagingDictionary[m_ID];
vm.Exposure = (int)(ips.exposure * 1000);
vm.EMGain = ips.gain;
vm.Binning = ips.binning;
vm.MinCycleTime = m_imager.m_camera.GetCycleTime();
if (ips.cycleTime < vm.MinCycleTime)
{
vm.CycleTime = vm.MinCycleTime;
}
else
{
vm.CycleTime = ips.cycleTime;
}
FilterContainer filter;
if (m_wgDB.GetEmissionFilterAtPosition(ips.emissionFilterPos, out filter))
{
vm.EmFilter = filter;
}
else
{
vm.EmFilter = null;
}
if (m_wgDB.GetExcitationFilterAtPosition(ips.excitationFilterPos, out filter))
{
vm.ExFilter = filter;
}
else
{
vm.ExFilter = null;
}
ips.histBitmap = BitmapFactory.New(m_imager.m_histogramImageWidth, m_imager.m_histogramImageHeight);
HistImage.Source = ips.histBitmap;
ips.ImageControl = ImageDisplayControl;
ips.indicatorName = "Setup";
m_imager.m_ImagingDictionary[m_ID] = ips;
m_imager.ConfigImageDisplaySurface(m_ID, m_camera.m_acqParams.BinnedFullImageWidth, m_camera.m_acqParams.BinnedFullImageHeight, false);
}
else
{
ips = new ImagingParamsStruct();
float exposure = 0;
float accum = 0;
float kin = 0;
m_imager.m_camera.MyCamera.GetAcquisitionTimings(ref exposure, ref accum, ref kin);
if (exposure < 0.002)
{
exposure = 0.002f;
}
ips.exposure = exposure;
ips.binning = 1;
ips.cycleTime = (int)(exposure * 1000) + 50;
ips.emissionFilterPos = 0;
ips.excitationFilterPos = 0;
ips.experimentIndicatorID = m_ID;
ips.flatfieldType = FLATFIELD_SELECT.NONE;
ips.gain = 5;
ips.histBitmap = BitmapFactory.New(m_imager.m_histogramImageWidth, m_imager.m_histogramImageHeight);
HistImage.Source = ips.histBitmap;
ips.ImageControl = ImageDisplayControl;
ips.indicatorName = "Setup";
vm.EMGain = 1;
vm.Binning = 1;
vm.Exposure = (int)(ips.exposure * 1000);
vm.CycleTime = GlobalVars.Instance.CameraDefaultCycleTime;
vm.MinCycleTime = 100;
m_wgDB.GetAllEmissionFilters();
if (m_wgDB.m_filterList.Count > 0)
{
vm.EmFilter = m_wgDB.m_filterList[0];
}
else
{
vm.EmFilter = null;
}
m_wgDB.GetAllExcitationFilters();
if (m_wgDB.m_filterList.Count > 0)
{
vm.ExFilter = m_wgDB.m_filterList[0];
}
else
{
vm.ExFilter = null;
}
m_imager.m_ImagingDictionary.Add(m_ID, ips);
m_imager.ConfigImageDisplaySurface(m_ID, m_camera.m_acqParams.BinnedFullImageWidth, m_camera.m_acqParams.BinnedFullImageHeight, false);
m_imager.m_lambda.MoveFilterABandCloseShutterA((byte)vm.ExFilter.PositionNumber, (byte)vm.EmFilter.PositionNumber, GlobalVars.Instance.FilterChangeSpeed, GlobalVars.Instance.FilterChangeSpeed);
}
///////////////////////////////////////////////////////////////////////////////////
// Set CameraParams and AcquisitionParams
CameraParams cParams;
AcquisitionParams aParams;
m_imager.m_camera.GetCurrentCameraSettings(out cParams, out aParams);
vm.Binning = aParams.HBin;
vm.ApplyMask = m_imager.m_UseMask;
vm.EmFilterList = m_imager.m_emFilterList;
vm.ExFilterList = m_imager.m_exFilterList;
vm.PreAmpGainIndex = cParams.PreAmpGainIndex;
vm.UseEMAmp = cParams.UseEMAmp;
vm.UseFrameTransfer = cParams.UseFrameTransfer;
vm.VertClockAmpIndex = cParams.VertClockAmpIndex;
vm.VSSIndex = cParams.VSSIndex;
vm.HSSIndex = cParams.HSSIndex;
vm.SliderLowPosition = 0.0;
vm.SliderHighPosition = 100.0;
if (ips.optimizeWellList != null)
{
vm.WellSelectionPBLabel = ips.optimizeWellList.Count.ToString();
}
else
{
vm.WellSelectionPBLabel = (m_imager.m_mask.Rows * m_imager.m_mask.Cols).ToString();
}
if (m_imager.m_mask == null)
{
m_imager.SetMask(null);
}
this.DataContext = vm;
m_imager.m_imagerEvent += m_imager_m_imagerEvent;
m_camera.m_cameraParams.Updated += m_cameraParams_Updated;
m_camera.m_acqParams.Updated += m_acqParams_Updated;
RangeSlider.RangeChanged += RangeSlider_RangeChanged;
m_imager.m_lambda.MoveFilterABandCloseShutterA((byte)vm.ExFilter.PositionNumber, (byte)vm.EmFilter.PositionNumber, GlobalVars.Instance.FilterChangeSpeed, GlobalVars.Instance.FilterChangeSpeed);
}