public override bool Process(PointF [] imagePoints, System.Drawing.Bitmap [] frames)
{
lock (mutex)
{
if (finished)
{
return(false);
}
for (int i = 0; i < imagePoints.Length; i++)
{
curPoints[i].X = imagePoints[i].X;
curPoints[i].Y = imagePoints[i].Y;
}
if (curFrame == null)
{
curFrame = new CvImageWrapper(frames[0]);
}
else
{
curFrame.setImage(frames[0]);
}
return(true);
}
}
private void CaptureImages(PointF [] imagePoints, Bitmap frame)
{
try
{
if (curFrame == null)
{
curFrame = new CvImageWrapper(frame);
}
else
{
curFrame.setImage(frame);
}
for (int i = 0; i < imagePoints.Length; i++)
{
PointF imagePoint = imagePoints[i];
CvRect cropDimensions = new CvRect();
cropDimensions.x = (int)imagePoint.X - obsSize / 2;
cropDimensions.y = (int)imagePoint.Y - obsSize / 2;
cropDimensions.width = obsSize;
cropDimensions.height = obsSize;
CvImageWrapper curObs = curFrame.cropSubImage(cropDimensions);
this.templatesList[i].Add(curObs);
}
}
catch (Exception e)
{
}
}
public override void Process(Bitmap[] frames)
{
extraTrackingInfo = null;
Bitmap frame = frames[0];
if (frame == null)
{
throw new Exception("Frame is null!");
}
if (frame.Width != imageSize.Width || frame.Height != imageSize.Height)
{
throw new Exception("Invalid frame sizes");
}
_curFrame.setImage(frame);
CvImageWrapper.ConvertImageColor(_curFrame, _grey, ColorConversion.BGR2GRAY);
if (!validTrackPoints)
{
eyeLocator.AddImage(frame);
if (eyeLocator.TrackingPointsFound)
{
_current_track_points[MousePointIndex] = eyeLocator.MouseTrackingPoint;
_current_track_points[LeftEyePointIndex] = eyeLocator.LeftEyeTrackingPoint;
_current_track_points[RightEyePointIndex] = eyeLocator.RightEyeTrackingPoint;
leftEyeOffset.x = eyeLocator.LeftEyePoint.x - eyeLocator.LeftEyeTrackingPoint.x;
leftEyeOffset.y = eyeLocator.LeftEyePoint.y - eyeLocator.LeftEyeTrackingPoint.y;
rightEyeOffset.x = eyeLocator.RightEyePoint.x - eyeLocator.RightEyeTrackingPoint.x;
rightEyeOffset.y = eyeLocator.RightEyePoint.y - eyeLocator.RightEyeTrackingPoint.y;
validTrackPoints = true;
}
else
{
trackingSuiteAdapter.SendMessage(InitMessage);
}
}
for (int i = 0; i < NumberOfTrackingPoints; ++i)
{
SwapPoints(ref _current_track_points[i], ref _last_track_points[i]);
}
cvCalcOpticalFlowPyrLK(_prev_grey._rawPtr, _grey._rawPtr, _prev_pyramid._rawPtr,
_pyramid._rawPtr, _last_track_points, _current_track_points, NumberOfTrackingPoints, _pwinsz, 3,
_status, null, _criteria, _flowflags);
if (validTrackPoints)
{
for (int i = 0; i < NumberOfTrackingPoints; ++i)
{
if (_status[i] == 0)
{
validTrackPoints = false;
trackingSuiteAdapter.ToggleSetup(true);
eyeLocator.Reset();
break;
}
}
}
for (int i = 0; i < NumberOfTrackingPoints; ++i)
{
LimitTPDelta(ref _current_track_points[i], _last_track_points[i]);
}
SwapImages(ref _grey, ref _prev_grey);
SwapImages(ref _pyramid, ref _prev_pyramid);
if (validTrackPoints)
{
extraTrackingInfo = new BlinkLinkClickControlModule.BlinkLinkCMSExtraTrackingInfo(
new CvPoint2D32f(_current_track_points[LeftEyePointIndex].x + leftEyeOffset.x,
_current_track_points[LeftEyePointIndex].y + leftEyeOffset.y),
new CvPoint2D32f(_current_track_points[RightEyePointIndex].x + rightEyeOffset.x,
_current_track_points[RightEyePointIndex].y + rightEyeOffset.y));
imagePoint.X = _current_track_points[MousePointIndex].x;
imagePoint.Y = _current_track_points[MousePointIndex].y;
eyeImagePoints[0].X = _current_track_points[LeftEyePointIndex].x;
eyeImagePoints[0].Y = _current_track_points[LeftEyePointIndex].y;
eyeImagePoints[1].X = _current_track_points[RightEyePointIndex].x;
eyeImagePoints[1].Y = _current_track_points[RightEyePointIndex].y;
}
}
public override bool Process(PointF [] imagePoints, System.Drawing.Bitmap[] frames)
{
lock (mutex)
{
if (finished)
{
return(false);
}
if (centerPoint.IsEmpty)
{
centerPoint.X = imagePoints[0].X;
centerPoint.Y = imagePoints[0].Y;
return(true);
}
if (curFrame == null)
{
curFrame = new CvImageWrapper(frames[0]);
}
else
{
curFrame.setImage(frames[0]);
}
if (setupFrame == null)
{
setupFrame = new Bitmap(curFrame.Size.Width, curFrame.Size.Height);
InitSetupFrame();
}
relCurPoint = mouseControlStandard.ComputeRelCursorInWindow(imagePoints[0], centerPoint);
int xRectIndex = (int)Math.Floor((double)rectangleLength * relCurPoint.X);
int yRectIndex = (int)Math.Floor((double)rectangleLength * relCurPoint.Y);
if (xRectIndex >= rectangleLength)
{
xRectIndex = rectangleLength - 1;
}
if (yRectIndex >= rectangleLength)
{
yRectIndex = rectangleLength - 1;
}
if (xRectIndex < 0)
{
xRectIndex = 0;
}
if (yRectIndex < 0)
{
yRectIndex = 0;
}
if (rectangles[xRectIndex, yRectIndex] && !finished)
{
rectangles[xRectIndex, yRectIndex] = false;
curNumRectangles++;
for (int i = 0; i < imagePoints.Length; i++)
{
PointF imagePoint = imagePoints[i];
if (!(imagePoint.X <= obsSize / 2 || imagePoint.X >= curFrame.Size.Width - obsSize / 2) &&
!(imagePoint.Y <= obsSize / 2 || imagePoint.Y >= curFrame.Size.Height - obsSize / 2))
{
CvRect cropDimensions = new CvRect();
cropDimensions.x = (int)imagePoint.X - obsSize / 2;
cropDimensions.y = (int)imagePoint.Y - obsSize / 2;
cropDimensions.width = obsSize;
cropDimensions.height = obsSize;
CvImageWrapper curObs = curFrame.cropSubImage(cropDimensions);
this.templatesList[i].Add(curObs);
UpdateSetupFrame();
}
}
if (curNumRectangles == this.numTemplates)
{
this.finished = true;
return(false);
}
else
{
SendMessage();
}
}
else if (shouldSendMessage)
{
shouldSendMessage = false;
SendMessage();
}
return(true);
}
}