コード例 #1
0
        private void CleanAHM()
        {
            lock (mutex)
            {
                if (_AHMBackFeature != null)
                {
                    CvImageWrapper.ReleaseImage(_AHMBackFeature);
                    _AHMBackFeature = null;
                }

                if (_AHMCurFeature != null)
                {
                    CvImageWrapper.ReleaseImage(_AHMCurFeature);
                    _AHMCurFeature = null;
                }

                if (_AHMRealtimeObs != null)
                {
                    CvImageWrapper.ReleaseImage(_AHMRealtimeObs);
                    _AHMRealtimeObs = null;
                }

                if (cameraMouseAssist != null)
                {
                    cameraMouseAssist.Dispose();
                    cameraMouseAssist = null;
                }

                if (ahmSetup != null)
                {
                    ahmSetup.Clean();
                    ahmSetup = null;
                }
            }
        }
コード例 #2
0
        private void SetupFinished()
        {
            lock (mutex)
            {
                cameraMouseAssists = new AHMCameraMouseAssist[NumberOfTrackingPoints];

                for (int j = 0; j < NumberOfTrackingPoints; j++)
                {
                    cameraMouseAssists[j] = new AHMCameraMouseAssist();

                    IntPtr[] images = new IntPtr[this.ahmSetup.TemplatesList[j].Count];

                    int i = 0;
                    foreach (CvImageWrapper imageWrapper in this.ahmSetup.TemplatesList[j])
                    {
                        images[i++] = imageWrapper._rawPtr;
                    }

                    int numSubset = (int)Math.Ceiling(Math.Sqrt(this.ahmSetup.TemplatesList[j].Count));

                    ahmSetup.TemplatesList[j].Clear();

                    int kernelType = 0;
                    if (kernelLightingCorrection)
                    {
                        kernelType = 2;
                    }

                    double dimension = this.cameraMouseAssists[j].init(images, numSubset, 10, 1, 0.6, kernelType);
                }
                ahmSetup.Clean();
            }
        }
コード例 #3
0
        private void StartAHMSetup()
        {
            lock (mutex)
            {
                if (cameraMouseAssist != null)
                {
                    cameraMouseAssist.Dispose();
                    cameraMouseAssist = null;
                }

                cameraMouseAssist = new AHMCameraMouseAssist();

                if (setupType.Equals(AHMSetupType.KeyPress))
                {
                    ahmSetup = new AHMKeyPressSetup();
                }
                else if (setupType.Equals(AHMSetupType.Movement30Sec))
                {
                    ahmSetup = new AHMRectangleSetup(30, mouseControlModuleStandard);
                }
                else if (setupType.Equals(AHMSetupType.Movement45Sec))
                {
                    ahmSetup = new AHMRectangleSetup(45, mouseControlModuleStandard);
                }
                else if (setupType.Equals(AHMSetupType.Movement60Sec))
                {
                    ahmSetup = new AHMRectangleSetup(60, mouseControlModuleStandard);
                }
                else if (setupType.Equals(AHMSetupType.MovementInfinite))
                {
                    ahmSetup = new AHMRectangleSetup(0, mouseControlModuleStandard);
                }
                else if (setupType.Equals(AHMSetupType.Timing15Sec))
                {
                    ahmSetup = new AHMTimingSetup(15);
                }
                else if (setupType.Equals(AHMSetupType.Timing10Sec))
                {
                    ahmSetup = new AHMTimingSetup(10);
                }

                ahmSetup.NumTemplates         = numTemplates;
                ahmSetup.TrackingSuiteAdapter = trackingSuiteAdapter;
                //ahmSetup.FinishedSetup = SetupFinished;
                ahmSetup.ImageSize = imageSize;
                ahmSetup.ObsSize   = obsSize;
                ahmSetup.RatioVideoInputToMaxOutput = trackingSuiteAdapter.GetRatioInputToOutput()[0];
                ahmSetup.Init(1);
            }
        }
コード例 #4
0
        public override void Init(Size[] imageSizes)
        {
            eyeLocator = new EyeLocator(EyeLocationImageCount);
            eyeLocator.Reset();
            eyeLocatorTickCount = Environment.TickCount;
            lastClickPoint      = Point.Empty;

            cameraMouseAssists = new AHMCameraMouseAssist[NumberOfTrackingPoints];

            int imageWidth  = imageSizes[0].Width;
            int imageHeight = imageSizes[0].Height;

            lock (mutex)
            {
                CleanStandard();
                InitStandard(imageWidth, imageHeight);
            }

            CMSTrackingSuiteAdapter.SendMessage(CMSConstants.PLEASE_CLICK_TF);
        }
コード例 #5
0
        private void ProcessAHM()
        {
            lock (mutex)
            {
                if (cameraMouseAssists == null)
                {
                    return;
                }

                double ccMinProjSqdDist = 0.0;
                double ccTanSqdDist     = 0.0;

                try
                {
                    List <Bitmap> images = null;
                    if (showMessages)
                    {
                        images = new List <Bitmap>();
                    }

                    long newTicks = Environment.TickCount;

                    if (newTicks - ticks > updateFrequency || updateFrequency == 0)
                    {
                        ticks = newTicks;
                        for (int i = 0; i < NumberOfTrackingPoints; i++)
                        {
                            AHMCameraMouseAssist cameraMouseAssist = cameraMouseAssists[i];
                            if (cameraMouseAssist == null)
                            {
                                continue;
                            }

                            if (cameraMouseAssist != null && cameraMouseAssist.isReady())
                            {
                                if (_AHMWeights == null || _AHMWeights.Length != this.numTemplates)
                                {
                                    _AHMWeights = new double[numTemplates];
                                }

                                float relX = 0.0f;
                                float relY = 0.0f;

                                if ((this._current_track_points[i].x >= obsSize / 2 + 10) && (_current_track_points[i].y >= obsSize / 2 + 10) &&
                                    ((_current_track_points[i].x + obsSize / 2 + 10) < imageSize.Width) &&
                                    ((_current_track_points[i].y + obsSize / 2 + 10) < imageSize.Height))
                                {
                                    if (this._AHMRealtimeObs == null)
                                    {
                                        this._AHMRealtimeObs = CvImageWrapper.CreateImage(new CvSize(obsSize + 20, obsSize + 20), 8, 3);
                                    }
                                    if (this._AHMBackFeature == null)
                                    {
                                        this._AHMBackFeature = CvImageWrapper.CreateImage(new CvSize(obsSize, obsSize), 8, 3);
                                    }
                                    if (this._AHMCurFeature == null)
                                    {
                                        this._AHMCurFeature = CvImageWrapper.CreateImage(new CvSize(obsSize, obsSize), 8, 3);
                                    }

                                    _AHMRect.x      = (int)_current_track_points[i].x - obsSize / 2 - 10;
                                    _AHMRect.y      = (int)_current_track_points[i].y - obsSize / 2 - 10;;
                                    _AHMRect.height = obsSize + 20;
                                    _AHMRect.width  = obsSize + 20;

                                    _curFrame.cropSubImage(_AHMRect, this._AHMRealtimeObs);

                                    unsafe
                                    {
                                        int dx = 0, dy = 0;

                                        IntPtr pMinProjSqdDist = new IntPtr(&ccMinProjSqdDist);
                                        IntPtr pTanSqdDist     = new IntPtr(&ccTanSqdDist);
                                        IntPtr pDx             = new IntPtr(&dx);
                                        IntPtr pDy             = new IntPtr(&dy);

                                        cameraMouseAssist.computeRelativePos(pMinProjSqdDist, pTanSqdDist, this._AHMRealtimeObs._rawPtr, pDx, pDy, _AHMWeights);

                                        /*
                                         * if (CMSLogger.CanCreateLogEvent(true, false, false, "AHMLogRealtimeEvent"))
                                         * {
                                         *  AHMLogRealtimeEvent lEvent = new AHMLogRealtimeEvent();
                                         *  if (lEvent != null)
                                         *  {
                                         *      lEvent.ProjSqrdDist = (float)ccMinProjSqdDist;
                                         *      lEvent.TanSqrdDist = (float)ccTanSqdDist;
                                         *      CMSLogger.SendLogEvent(lEvent);
                                         *  }
                                         * }*/


                                        _current_track_points[i].x = _current_track_points[i].x + dx;
                                        _current_track_points[i].y = _current_track_points[i].y + dy;

                                        if (i == 0)
                                        {
                                            imagePoint.X = _current_track_points[0].x;
                                            imagePoint.Y = _current_track_points[0].y;
                                        }
                                        else
                                        {
                                            eyeImagePoints[i - 1].X = (int)_current_track_points[i].x;
                                            eyeImagePoints[i - 1].Y = (int)_current_track_points[i].y;
                                        }



                                        if (showMessages)
                                        {
                                            cameraMouseAssist.retrieveBackFeature(this._AHMBackFeature._rawPtr);
                                            cameraMouseAssist.retrieveCurFeature(this._AHMCurFeature._rawPtr);

                                            images.Add(_AHMBackFeature.GetBitMap().Clone() as Bitmap);
                                            images.Add(_AHMCurFeature.GetBitMap().Clone() as Bitmap);
                                        }

                                        /*
                                         * AHMLogRealtimeFeatureImagesEvent realtimeEvent = null;
                                         * if (CMSLogger.CanCreateLogEvent(true, true, false, "AHMLogRealtimeFeatureImagesEvent"))
                                         * {
                                         *  realtimeEvent = new AHMLogRealtimeFeatureImagesEvent();
                                         * }
                                         * if (realtimeEvent != null)
                                         * {
                                         *  cameraMouseAssist.retrieveBackFeature(this._AHMBackFeature._rawPtr);
                                         *  cameraMouseAssist.retrieveCurFeature(this._AHMCurFeature._rawPtr);
                                         *
                                         *  extraImages[0] = _AHMBackFeature.GetBitMap().Clone() as Bitmap;
                                         *  extraImages[1] = _AHMCurFeature.GetBitMap().Clone() as Bitmap;
                                         *
                                         *  extraImages[0].RotateFlip(RotateFlipType.RotateNoneFlipX);
                                         *  extraImages[1].RotateFlip(RotateFlipType.RotateNoneFlipX);
                                         *
                                         *  realtimeEvent.SetImages(extraImages[0], extraImages[1]);
                                         *  CMSLogger.SendLogEvent(realtimeEvent);
                                         * }*/
                                    }
                                }
                            }
                        }
                    }
                    if (showMessages && images.Count > 0)
                    {
                        trackingSuiteAdapter.SendMessages(images.ToArray(), new string[] { "Left Back", "Left Cur", "Right Back", "Right Cur", "Mouth Back", "Mouth Cur" });
                    }
                }
                catch (Exception e)
                {
                }
            }
        }