private void CountProgress(long time, ROI.ROI roi)
{
foreach (IParentObserver observer in observers)
{
if (observer is ICountObserver)
{
ICountObserver ic = (ICountObserver)observer;
ic.CountProgress(time, roi);
}
}
}
/// <summary>
/// Creates and initializes a measure object based on information the ROI object
/// about the ROI.
/// </summary>
/// <param name="roi">ROI instance</param>
/// <param name="mAssist">Reference to controller class</param>
public Measurement(ROI roi, MeasureAssistant mAssist)
{
mMeasAssist = mAssist;
mEdgeXLD = new HXLDCont();
mMeasureRegion = new HRegion();
initROI(roi);
}
private void simpleButton5_Click(object sender, EventArgs e)
{
try
{
roiList.Clear();
ArrayList tempRoi = roiController.ROIList;
for (int i = 0; i < tempRoi.Count; i++)
{
ROI roi = (ROI)tempRoi[i];
if (roi.Type == "ROIRectangle1")
{
roi.Msize = new Size(4, 4);
roiList.Add(roi);
}
}
StaticOperate.WriteXML(inParam, settingPath);
CircleLine.hWindow_Final1.viewWindow.saveROI(roiList, roiPath);
inParam = LoadXml(station);
MessageBox.Show("保存成功！");
}
catch (Exception)
{
throw;
}
}
private void simpleButton4_Click(object sender, EventArgs e)
{
try
{
if (CircleLine.hWindow_Final1.Image == null || !CircleLine.hWindow_Final1.Image.IsInitialized())
{
return;
}
simpleButton3_Click(sender, e);
roiList.Clear();
ArrayList tempRoi = roiController.ROIList;
for (int i = 0; i < tempRoi.Count; i++)
{
ROI roi = (ROI)tempRoi[i];
if (roi.Type == "ROIRectangle1")
{
roi.Msize = new Size(1, 1);
roiList.Add(roi);
}
}
HTuple max = new HTuple();
string ok = RunMaxPoint(CircleLine.hWindow_Final1.Image, OrigImage, CircleLine.hWindow_Final1, new HTuple(), out fResult);
MessageBox.Show(ok);
}
catch (Exception)
{
throw;
}
}
void UpdateRoi(HObject Image)
{
List <ROI> temp = new List <ROI>();
List <ROI> temp2 = new List <ROI>();
ArrayList tempRoi = roiController.ROIList;
if (roiList.Count > 0)
{
for (int i = 0; i < 2; i++)
{
ROI roi = (ROI)tempRoi[i];
roi.Msize = new Size(4, 4);
temp.Add(roi);
}
for (int i = 2; i < tempRoi.Count; i++)
{
ROI roi = (ROI)tempRoi[i];
roi.Msize = new Size(2, 2);
temp2.Add(roi);
}
}
CircleLine.hWindow_Final1.HobjectToHimage(Image);
roiList = temp2;
CircleLine.roiList = temp;
CircleLine.hWindow_Final1.viewWindow.displayROI(ref temp);
CircleLine.hWindow_Final1.viewWindow.displayROI(ref roiList);
}
private void HWindowControl1_HMouseDown(object sender, HMouseEventArgs e)
{
if (drawFrame == DrawFrame.Brush)
{
HRegion region = new HRegion(e.Y, e.X, (int)brushSize);
if (e.Button == MouseButtons.Left)
{
ChangeMaskHRegion(region);
}
DisplayMaskRegion();
hWindowControl1.HalconWindow.SetColor("blue");
hWindowControl1.HalconWindow.DispObj(region);
region.Dispose();
}
if (ctrller.ActiveROIIndex < 0 && rOI == null && drawFrame != DrawFrame.Brush)
{
if (e.Button == MouseButtons.Left)
{
hWndCtrller.SetViewMode(HWndCtrller.MODE_VIEW_MOVE);
}
}
rOI = null;
}
private void SetMinMax(IEnumerable <IVoxelDataStructure> grids)
{
if (AutomaticMinMax)
{
Max = float.MinValue;
Min = float.MaxValue;
}
foreach (var grid in grids)
{
foreach (Voxel voxel in grid)
{
if (!(grid.ValueUnit == Unit.Gamma && voxel.Value == -1))
{
if (UseROI && ROI.ContainsPointNonInterpolated(voxel.Position.X, voxel.Position.Y, voxel.Position.Z))
{
CompareAndSetMax(voxel.Value * grid.Scaling);
CompareAndSetMin(voxel.Value * grid.Scaling);
}
else if (!UseROI)
{
CompareAndSetMax(voxel.Value * grid.Scaling);
CompareAndSetMin(voxel.Value * grid.Scaling);
}
}
}
}
}
public override bool Apply(ROI roi)
{
var fromY = roi.Height / 3 + 1;
var toY = 2 * roi.Height / 3;
foreach (var p in roi.GetOutsideBorder())
{
if (p.X < roi.X + roi.Width / 2 && p.Y >= fromY && p.Y <= toY)
{
Map.Cells[p.X, p.Y] = new Cell {
Type = CellType.OutsideElement
}
}
}
; //место под дорогу
var dx = Rnd.Next(roi.Width / 2);
if (Rnd.Next(2) == 1)
{
foreach (var p in roi.GetBorder())
{
if (p.X < roi.X + dx && p.Y >= fromY && p.Y <= toY)
{
Map.Cells[p.X, p.Y] = new Cell {
Type = CellType.OutsideElement
}
}
}
}
; //место под дорогу
return(true);
}
private void button2_Click(object sender, EventArgs e)
{
int index = comboBox2.SelectedIndex;
switch (index)
{
case 0:
rOI = new ROIRectangle1();
break;
case 1:
rOI = new ROICircle();
break;
case 2:
rOI = new ROIRectangle2();
break;
}
hWndCtrller.AddIconicVar(nCCModel.ModelImg);
ctrller.Reset();
ctrller.SetROISign(ROICtrller.SIGN_ROI_POS);
hWndCtrller.Repaint();
ctrller.SetROIShape(rOI);
SearchRegionCtrlFlag = false;
}
public ROI ConvertToProgROI(GeoDataGridViewModel raw, GeoDataGridViewModel[] dependROIs, int _circleDistanceSetting)
{
var model = convertToProgGraphicModel(raw, dependROIs);
ROI progROI = null;
switch (model.GeoType)
{
case MeasureType.Angle:
progROI = new ROIProgAngle(model);
break;
case MeasureType.Circle:
case MeasureType.PointCircle:
progROI = new ROIProgCircle(model)
{
CircleDistanceSetting = _circleDistanceSetting
};
break;
case MeasureType.CrossPoint:
progROI = new ROIProgPoint(model);
break;
case MeasureType.Distance:
case MeasureType.DistanceX:
case MeasureType.DistanceY:
progROI = new ROIProgDistance(model);
break;
case MeasureType.SymmetryLine:
progROI = new ROIProgSymmetryLine(model);
break;
}
return(progROI);
}
void FocusRegion(ROI rOI)
{
var obj = Points_obj.transform.Find(rOI.Region.ToUpper()).gameObject;
obj.transform.localScale = new Vector3(9f, 9f, 9f);
obj.GetComponent <Renderer>().material.shader = Shader.Find("Custom/Outline");
}
public ROI_Setting(Mat img)
{
InitializeComponent();
//원 이미지 저장
original = new Mat();
img.CopyTo(original);
temp = new Mat();
presets = new List <Preset>();
roitemp = new ROI(null, CheckType.Soldering);
roiRect = new Rect();
ROI_list = new ListBox.ObjectCollection(lstbxROI);
pictureBoxIpl1.Image = BitmapConverter.ToBitmap(img);
pictureBoxIpl1.SizeMode = PictureBoxSizeMode.StretchImage;
listbxPreset.BeginUpdate();
Preset.LoadJson(presets);
presets.ForEach(x => listbxPreset.Items.Add(x.PresetName));
listbxPreset.EndUpdate();
}
public void CreateROI(ROI roi)
{
this.blobs.List.Add(new Blob()
{
ROI = roi
});
}
public static async Task<List<ROI>> Load(StorageFile file)
{
// read content
var lines = await Windows.Storage.FileIO.ReadLinesAsync(file);
// Read in all the lines
//string[] lines = System.IO.File.ReadAllLines(_fullPath);
List<ROI> regionsOfInterest = new List<ROI>();
foreach (var line in lines)
{
var fields = line.Split('\t');
ROI roi = new ROI()
{
Index = Int32.Parse(fields[0]),
Name = fields[1],
Ident = Int32.Parse(fields[2]),
X = Double.Parse(fields[6]),
Y = Double.Parse(fields[7]),
Z = Double.Parse(fields[8]),
TX = Double.Parse(fields[10]),
TY = Double.Parse(fields[11]),
TZ = Double.Parse(fields[12]),
};
regionsOfInterest.Add(roi);
}
return regionsOfInterest;
}
/// <summary>
/// 建構子
/// </summary>
/// <param name="roi"></param>
/// <param name="mAssist"></param>
public MeasurementCircle(ROI roi, MeasureAssistant mAssist)
: base(roi, mAssist)
{
mResult = new CircleResult();
_cameraOut = new HTuple();
UpdateMeasure();
}
/// <summary>
/// Creates a measurement object for the provided ROI instance.
/// </summary>
/// <param name="roi">ROI instance</param>
/// <param name="mAssist">Reference to controller class</param>
public MeasurementPair(ROI roi, MeasureAssistant mAssist)
: base(roi, mAssist)
{
mResult = new PairResult();
mResultWorld = new PairResult();
UpdateMeasure();
}
public static DialogResult ShowCustomDialog(List <ROI> currentList, ROI region)
{
using (AddRegionDialog form = new AddRegionDialog(currentList, region))
{
return(form.ShowDialog());
}
}
private Histogramf buildHistogram(IVoxelDataStructure grid, IProgress <int> progress)
{
Histogramf histogram = new Histogramf(Min, Max, BinCount);
int numberOfVoxels = grid.NumberOfVoxels;
//Only report every 5%
int updateNumber = numberOfVoxels / 20;
int voxelNum = 0;
foreach (Voxel voxel in grid)
{
voxelNum++;
if (!(grid.ValueUnit == Unit.Gamma && voxel.Value == -1))
{
if (UseROI && ROI.ContainsPointNonInterpolated(voxel.Position))
{
histogram.AddDataPoint(voxel.Value * grid.Scaling);
}
else if (!UseROI)
{
histogram.AddDataPoint(voxel.Value * grid.Scaling);
}
}
if (voxelNum % updateNumber == 0)
{
progress.Report((int)(100 * ((double)voxelNum / (double)numberOfVoxels)));
}
}
return(histogram);
}
public override bool Apply(ROI roi)
{
var list = new List <Point>();
foreach (var point in roi.Where(t => Map.Cells[t.X, t.Y].Type == CellType.Flat))
{
if (!point.IsBorder())
{
list.Add(point);
}
}
for (int i = 0; i < Count; i++)
{
var p = list[Rnd.Next(list.Count)];
if (SpriteName.Contains("_part_1"))
{
// 2 x 2 tile
if (Map.Cells[p.X + 1, p.Y].Type == CellType.Flat &&
Map.Cells[p.X + 1, p.Y + 1].Type == CellType.Flat &&
Map.Cells[p.X, p.Y + 1].Type == CellType.Flat)
{
Map.Cells[p.X, p.Y] = new Cell {
SpriteName = SpriteName, Type = CellType.InsideElement
};
Map.Cells[p.X + 1, p.Y] = new Cell {
SpriteName = SpriteName.Replace("_part_1", "_part_2"), Type = CellType.InsideElement
};
Map.Cells[p.X, p.Y + 1] = new Cell {
SpriteName = SpriteName.Replace("_part_1", "_part_3"), Type = CellType.InsideElement
};
Map.Cells[p.X + 1, p.Y + 1] = new Cell {
SpriteName = SpriteName.Replace("_part_1", "_part_4"), Type = CellType.InsideElement
};
}
continue;
}
var cx = Rnd.Next(3);
var cy = Rnd.Next(3);
for (int x = 0; x < cx; x++)
{
for (int y = 0; y < cy; y++)
{
if (Map.Cells[p.X + x, p.Y + y].Type == CellType.Flat)
{
Map.Cells[p.X + x, p.Y + y] = new Cell {
SpriteName = SpriteName, Type = CellType.InsideElement
}
}
}
}
;
}
return(true);
}
// Update is called once per frame
void Update()
{
Ray lGaze = MyEyeTracker.leftGaze(); // here your eye-tracker needs to provide a Ray consisting of the position and direction vector from the left eye
Ray rGaze = MyEyeTracker.rightGaze();
roi1 = ProcessROI(roi1, cam, lGaze, rGaze); // this processes all the data relevant for this ROI.
roi2 = ProcessROI(roi2, cam, lGaze, rGaze);
}
public MeasurementDistanceY(ROI roiOne, ROI roiTwo, MeasureAssistant mAssist)
: base(null, mAssist)
{
var lineF = new MeasurementEdge(roiOne, mAssist);
var lineS = new MeasurementEdge(roiTwo, mAssist);
initialize(lineF.GetViewModel(), lineS.GetViewModel(), mAssist);
}
private void HWindowControl1_HMouseUp(object sender, HMouseEventArgs e)
{
HRegion region = null;
if (ctrller.ROIList.Count > 0)
{
if (ctrller.DefineModelROI())
{
region = ctrller.GetModelRegion();
}
if (DrawRegionCtrlFlag == 1)
{
if (Model.SearchRegion != null)
{
Model.SearchRegion.Dispose();
}
Model.SearchRegion = region.Clone();
}
else if (DrawRegionCtrlFlag == 2)
{
if (Model.ModelRegion != null)
{
Model.ModelRegion.Dispose();
}
Model.ModelRegion = region.Clone();
DeterminModel();
InspectModel();
Model.createNewModelID = true;
}
else if (DrawRegionCtrlFlag == 3)
{
if (Model.shapeModel != null && Model.shapeModel.IsInitialized())
{
ROI rOI = ctrller.GetActiveROI();
if (rOI is ROICross)
{
HTuple data = ((ROICross)rOI).GetModeData();
Model.SetModelOrigin(data[0], data[1]);
//Model.shapeModel.SetShapeModelOrigin(-Model.ModelImgRow+ data[0],-Model.ModelImgCol+ data[1]);
}
}
}
Model.OutputResult.Reset();
}
if (e.Button == MouseButtons.Right)
{
hWndCtrller.ResetWindow();
hWndCtrller.Repaint();
}
hWndCtrller.SetViewMode(HWndCtrller.MODE_VIEW_NONE);
}
public static TifFileInfo ProcessROI(string dir, ROI roi, TifFileInfo fi)
{
if (!roi.Checked || roi.Shape < 2)
{
return(null);
}
return(CropToolStripMenuItem_click(roi, dir, fi));
}
private void button3_Click(object sender, EventArgs e)
{
rOI = new ROIRectangle1();
ctrller.Reset();
ctrller.SetROISign(ROICtrller.SIGN_ROI_POS);
ctrller.SetROIShape(rOI);
DrawRegionCtrlFlag = 3;
}
/// <summary>
/// Recreate the entire measure object list, if the
/// measure edge type changes from edge pose to
/// edge pairs or vice versa
/// </summary>
public void UpdateMeasure()
{
RemoveAllMeasureObjects();
for (int i = 0; i < mROIList.Count; i++)
{
ROI roi = (ROI)mROIList[i];
mMeasureList.Add(CreateMeasure((ROI)mROIList[i], this));
}
NotifyMeasureObserver(EVENT_UPDATE_MEASUREMENT);
}
void RegionListController_OnFocus_rOI(ROI sel_rOI, ROI prev_sel_rOi)
{
if (prev_sel_rOi != null)
{
PointsController_RestoreROI(prev_sel_rOi);
FocusRegion(sel_rOI);
return;
}
FocusRegion(sel_rOI);
}
void ShowSection()
{
ROI line = roiController.getActiveROI();
HTuple lineCoord = line.getModelData();
HObject Rline = new HObject();
HOperatorSet.GenRegionLine(out Rline, lineCoord[0], lineCoord[1], lineCoord[2], lineCoord[3]);
HTuple row, col;
HObject Rline1 = new HObject();
HOperatorSet.GenContourRegionXld(Rline, out Rline1, "border");
HOperatorSet.GetContourXld(Rline1, out row, out col);
HTuple Zpoint = new HTuple(), Xpoint = new HTuple();
if (row.Length == 0)
{
return;
}
HTuple width, height, lessId1, lessId2;
HOperatorSet.GetImageSize(sw.hwnd[1].Image, out width, out height);
HOperatorSet.TupleLessElem(row, height, out lessId1);
HOperatorSet.TupleFind(lessId1, 1, out lessId1);
row = row[lessId1];
col = col[lessId1];
HOperatorSet.TupleLessElem(col, width, out lessId2);
HOperatorSet.TupleFind(lessId2, 1, out lessId2);
row = row[lessId2];
col = col[lessId2];
HOperatorSet.GetGrayval(sw.hwnd[1].Image, row, col, out Zpoint);
HTuple EqId = new HTuple();
HOperatorSet.TupleNotEqualElem(Zpoint, -30, out EqId);
HOperatorSet.TupleFind(EqId, 1, out EqId);
Zpoint = Zpoint[EqId];
HOperatorSet.TupleGenSequence(0, Zpoint.Length, context.xResolution, out Xpoint);
Zpoint = Zpoint * 50;
Xpoint = Xpoint * 50;
HTuple RowNew, ColNew;
HObject Region, Contour, ConstImage;
GenProfile(true, Zpoint, Xpoint, out RowNew, out ColNew, out Region, out Contour);
HOperatorSet.GenImageConst(out ConstImage, "byte", 1000, 1000);
sw.hwnd[0].HobjectToHimage(ConstImage);
sw.hwnd[0].viewWindow.displayHobject(Region, "red", true);
Rline.Dispose();
Rline1.Dispose();
ConstImage.Dispose();
Region.Dispose();
Contour.Dispose();
}
private void button1_Click(object sender, EventArgs e)
{
hWndCtrller.AddIconicVar(nCCModel.ModelImg);
rOI = new ROIRectangle1();
ctrller.Reset();
ctrller.SetROISign(ROICtrller.SIGN_ROI_POS);
hWndCtrller.Repaint();
ctrller.SetROIShape(rOI);
SearchRegionCtrlFlag = true;
}
private void button5_Click(object sender, EventArgs e)
{
hWndCtrller.AddIconicVar(Model.ModelImg);
rOI = new ROICross();
ctrller.Reset();
ctrller.SetROISign(ROICtrller.SIGN_ROI_NONE);
hWndCtrller.Repaint();
ctrller.SetROIShape(rOI);
DrawRegionCtrlFlag = 3;
}
private void hWindowControl1_HMouseDown(object sender, HMouseEventArgs e)
{
if (ctrller.ActiveROIIndex < 0 && rOI == null)
{
if (e.Button == MouseButtons.Left)
{
hWndCtrller.SetViewMode(HWndCtrller.MODE_VIEW_MOVE);
}
}
rOI = null;
}
/// <summary>
/// Factory method to create measure objects
/// </summary>
/// <param name="roi">Interactive ROI</param>
/// <param name="parent">
/// Reference to measure controller class
/// </param>
/// <returns>New measure object</returns>
public static Measurement CreateMeasure(ROI roi, MeasureAssistant parent)
{
if (parent.mSelPair)
{
return(new MeasurementPair(roi, parent));
}
else
{
return(new MeasurementEdge(roi, parent));
}
}
// this processes the roi, and updates all the internal variables
// leftGaze and rightGaze must be in world space, not local space!
public ROI ProcessROI(ROI roi, Camera cam, Ray leftGaze, Ray rightGaze)
{
// check if on Cam
if (roi.renderer.IsVisibleFrom(cam))
{
roi.onCam = true;
}
else
{
roi.onCam = false;
}
// check inlineOfSight
RaycastHit hit;
Vector3 direction = cam.transform.position - roi.transform.position;
if (Physics.Raycast(roi.transform.position, direction, out hit)) // then check if it is not occluded by other collider
{
if (hit.collider == cam.GetComponent <Collider>())
{
roi.inLineOfSight = true;
} // if the hit is the camera, there's nothing in between
}
else
{
roi.inLineOfSight = false;
}
// get distance
roi.distance = Vector3.Distance(cam.transform.position, roi.transform.position);
// get angles
roi.angleToRoi = Vector3.Angle(cam.transform.forward, roi.transform.position - cam.transform.position);
roi.angleToRoiRight = Vector3.Angle(rightGaze.direction, roi.transform.position - rightGaze.origin);
roi.angleToRoiLeft = Vector3.Angle(leftGaze.direction, roi.transform.position - leftGaze.origin);
roi.angleFromRoi = Vector3.Angle(roi.transform.forward, cam.transform.position - roi.transform.position);
// point on camera texture
roi.pointOnCam = cam.WorldToScreenPoint(roi.transform.position); // "Screenspace is defined in pixels. The bottom-left of the screen is (0,0); the right-top is (pixelWidth,pixelHeight). The z position is in world units from the camera."
// get angles in x and y axis
roi.ReferenceLeft.transform.position = leftGaze.origin;
roi.ReferenceLeft.transform.LookAt(roi.transform.position, Vector3.up); // rotate hypothetical eyes to look directly at the ROI
roi.ReferenceRight.transform.position = rightGaze.origin;
roi.ReferenceRight.transform.LookAt(roi.transform.position, Vector3.up); // rotate hypothetical eyes to look directly at the ROI
roi.lEye.transform.LookAt(roi.lEye.transform.position + LeftGaze.direction, Vector3.up); // and rotate these eyes to model the eyes of the user as tracked by the eye-tracker
roi.rEye.transform.LookAt(roi.rEye.transform.position + RightGaze.direction, Vector3.up);
roi.angleFromRoiLeftX = roi.lEye.transform.localEulerAngles.x; // localeulerangles now let us separate angle in x and y dimension. Note that rotation in y axis gives us left/right deviation
roi.angleFromRoiLeftY = roi.lEye.transform.localEulerAngles.y;
roi.angleFromRoiRightX = roi.rEye.transform.localEulerAngles.x;
roi.angleFromRoiRightY = roi.rEye.transform.localEulerAngles.y;
return(roi);
}
/// <summary>
/// Constructs an <c>ImageData</c> object with given parameters.
/// </summary>
/// <param name="origFilename">The filename of the image.</param>
/// <param name="reportFilename">The filename where the Excel report is stored.</param>
/// <param name="dateTimeFired">The date and time the target was fired upon.</param>
/// <param name="shooterLName">The shooter's last name.</param>
/// <param name="shooterFName">The shooter's first name.</param>
/// <param name="rangeLocation">The location of the range.</param>
/// <param name="distanceUnits">The units that the distance to target is measured in.</param>
/// <param name="distance">The distance to the target.</param>
/// <param name="temperature">The temperature on the range.</param>
/// <param name="weaponName">The name of the weapon.</param>
/// <param name="serialNumber">The serial number of the weapon.</param>
/// <param name="weaponNotes">Notes on the weapon.</param>
/// <param name="caliber">The units of caliber of the ammunition used.</param>
/// <param name="caliberValue">The caliber of the ammunition used.</param>
/// <param name="lotNumber">The lot number of the ammunition.</param>
/// <param name="projectileMassGrains">The projectile mass in units of grains.</param>
/// <param name="ammunitionNotes">Notes on the ammunition.</param>
/// <param name="scale">The scale information for the target.</param>
/// <param name="shotsFired">The number of shots fired.</param>
/// <param name="points">A list of points where bullet holes are located.</param>
/// <param name="roi">The region of interest for the target.</param>
public ImageData(String origFilename, String reportFilename, DateTime dateTimeFired,
String shooterLName, String shooterFName, String rangeLocation,
UnitsOfMeasure distanceUnits, int distance, Temperature temperature,
String weaponName, String serialNumber, String weaponNotes, CaliberUnit caliber,
double caliberValue, String lotNumber, int projectileMassGrains,
String ammunitionNotes, Scale scale, int shotsFired, IList<Point> points, ROI roi)
{
this.targetID = -1;
this.origFilename = origFilename;
this.reportFilename = reportFilename;
this.dateTimeFired = dateTimeFired;
this.shooterLName = shooterLName;
this.shooterFName = shooterFName;
this.rangeLocation = rangeLocation;
this.distanceUnits = distanceUnits;
this.distance = distance;
this.temperature = temperature;
this.weaponName = weaponName;
this.serialNumber = serialNumber;
this.weaponNotes = weaponNotes;
this.caliber = caliber;
this.caliberValue = caliberValue;
this.lotNumber = lotNumber;
this.projectileMassGrains = projectileMassGrains;
this.ammunitionNotes = ammunitionNotes;
this.scale = scale;
this.shotsFired = shotsFired;
this.points = points;
this.regionOfInterest = roi;
}
public BrainDataPoint(double x, double y, ROI roi)
{
this.x = x;
this.y = y;
this.roi = roi;
}
private void CountSelect(ROI.ROI roi, DateTime time, int count)
{
selectionState = CountSelectionState.Complete;
countSelectedAt = time;
roi = FindROIWithinGroup(count);
for (int i = 0; i < observers.Count; i++)
{
//if (observer.Equals(typeof(ICountObserver)))
Log(String.Format("Observer{0}", observers[i]));
if (observers[i] is ICountObserver)
{
ICountObserver ic = (ICountObserver)observers[i];
ic.CountComplete(null, roi, time, count, this, observers);
}
}
// Trigger a ROI set activation
if (roi.ToActivate != null && roi.ToActivate.Length > 0)
{
ActivateROISet(roi.ToActivate);
Log(String.Format("Activating ROI set: {0}", roi.ToActivate));
}
Log(String.Format("Count: CountSelect {0}", count));
}
private void CountStart(ROI.ROI roi, int count)
{
state = CountState.Counting;
selectionState = CountSelectionState.InProgress;
countStart = DateTime.Now;
countTotal = 0;
countFrames = 0;
for (int i = 0; i < observers.Count; i++ )
{
//if (observer.Equals(typeof(ICountObserver)))
Log(String.Format("Observer{0}", observers[i]));
if (observers[i] is ICountObserver)
{
ICountObserver ic = (ICountObserver)observers[i];
ic.CountStart(null, roi, count, this, observers);
}
}
Log(String.Format("Count: CountStart {0}", count));
}
public BrainDataPoint(double x, double y, ROI roi, double value)
: this(x, y, roi)
{
//this.Value = value;
}
public BrainScatterPoint(double x, double y, ROI roi, double value)
: base(x, y)
{
this.roi = roi;
this.Value = value;
}
private void CountProgress(long time, ROI.ROI roi)
{
foreach (ICountObserver observer in observers)
observer.CountProgress(time, roi);
}
private void CountSelect(ROI.ROI roi, DateTime time, int count)
{
selectionState = CountSelectionState.Complete;
countSelectedAt = time;
roi = FindROIWithinGroup(count);
foreach (ICountObserver observer in observers)
observer.CountComplete(null, roi, time, count);
// Trigger a ROI set activation
if (roi.ToActivate != null && roi.ToActivate.Length > 0)
{
ActivateROISet(roi.ToActivate);
Log(String.Format("Activating ROI set: {0}", roi.ToActivate));
}
Log(String.Format("Count: CountSelect {0}", count));
}
private void CountStart(ROI.ROI roi, int count)
{
state = CountState.Counting;
selectionState = CountSelectionState.InProgress;
countStart = DateTime.Now;
countTotal = 0;
countFrames = 0;
foreach (ICountObserver observer in observers)
observer.CountStart(null, roi, count);
Log(String.Format("Count: CountStart {0}", count));
}
