public void LoadCamera(CameraModel camera)
        {
            string path = String.Format(AppDomain.CurrentDomain.BaseDirectory + "\\cfg\\{0}.cam.json", camera.GUID);
            if (!File.Exists(path))
            {
                camera.Name = "Camera " + camera.TrackerId;
            }
            else
            {
                TextReader reader = null;
                try
                {
                    reader = new StreamReader(path);
                }
                finally
                {
                    if (reader != null)
                    {
                        string fileContents = reader.ReadToEnd();
                        CameraModel tmp = JsonConvert.DeserializeObject<CameraModel>(fileContents);

                        camera.Name = tmp.Name;
                        camera.FPS = tmp.FPS;
                        camera.Annotate = tmp.Annotate;

                        reader.Close();
                    }
                }
            }
        }
        public CameraViewModel(
            CameraModel camera, 
            ITrackerService trackerService, 
            ICameraService cameraService, 
            IConsoleService consoleService,
            HelixCameraVisualizationService visualizationService)
        {
            Camera = camera;
            TrackerService = trackerService;
            CameraService = cameraService;
            ConsoleService = consoleService;
            VisualizationService = visualizationService;

            CameraService.Initialize(Camera);
            TrackerService.Initialize(Camera);
            VisualizationService.Initialize(Camera);

            if (!IsInDesignMode)
            {
                Messenger.Default.Register<AddMotionControllerMessage>(this,
                    message =>
                    {
                        TrackerService.AddMotionController(message.MotionController);
                    });

                Messenger.Default.Register<RemoveMotionControllerMessage>(this,
                    message =>
                    {
                        TrackerService.RemoveMotionController(message.MotionController);
                    });

                // add existing controllers
                foreach (MotionControllerViewModel mcvw in SimpleIoc.Default.GetAllCreatedInstances<MotionControllerViewModel>())
                {
                    TrackerService.AddMotionController(mcvw.MotionController);
                }

                SimpleIoc.Default.Register(() => this, Camera.GUID, true);
                Messenger.Default.Send(new AddCameraMessage(Camera));
                // try loading previously saved configurations for this camera
                SimpleIoc.Default.GetInstance<ISettingsService>().LoadCamera(camera);
                Camera.Calibration = SimpleIoc.Default.GetInstance<SettingsViewModel>().SettingsService.LoadCalibration(Camera.GUID);
            }
        }
 public CameraCalibrationViewModel()
 {
     if (IsInDesignMode)
     {
         Camera = new CameraModel();
         Camera.Calibration = new CameraCalibrationModel
         {
             CurrentMode = CameraCalibrationMode.Calibrated,
             FrameBufferSize = 100,
             Error = 0.0,
         };
     }
     else
     {
         if (SimpleIoc.Default.IsRegistered<CameraCalibrationService>())
         {
             CalibrationService = SimpleIoc.Default.GetInstance<CameraCalibrationService>();
         }
         else
         {
             CalibrationService = new CameraCalibrationService(new JsonSettingsService());
         }
     }
 }
        public void AddAvailableCameras()
        {
            int count = CLEyeCameraDevice.CameraCount;

            for(int i = 0; i < count; i++)
            {
                CameraModel camera = new CameraModel
                {
                    TrackerId = i,
                    Name = "Camera " + i
                };
                IConsoleService consoleService = new ConsoleService();
                new CameraViewModel(
                    camera,
                    new TrackerService(consoleService),
                    new ClEyeService(consoleService),
                    consoleService,
                    new HelixCameraVisualizationService());

            }
            Refresh();
        }
 public void Initialize(CameraModel camera)
 {
     _camera = camera;
 }
        /// <summary>
        /// for design purposes only
        /// </summary>
        public MotionControllerViewModel()
            : this(new MotionControllerModel
            {
                Design = true,
                Id = MotionControllerModel.COUNTER,
                Name = "Design " + MotionControllerModel.COUNTER,
                Serial = "00:00:00:00:00:0" + MotionControllerModel.COUNTER++,
            }, 
            new DesignMotionControllerService())
        {
            #if DEBUG
            Random rnd = new Random();
            if (IsInDesignMode)
            {
                CameraModel cam0 = new CameraModel { Name = "cam0" };
                CameraModel cam1 = new CameraModel { Name = "cam1" };

                MotionController = new MotionControllerModel
                {
                    Name = "Design " + rnd.Next(10),
                    Serial = "00:00:00:00:00:0" + rnd.Next(10),
                    RawPosition = new ObservableConcurrentDictionary<CameraModel, Vector3>
                {
                    {cam0, new Vector3(rnd.Next(640), rnd.Next(480), rnd.Next(30))},
                    {cam1, new Vector3(rnd.Next(640), rnd.Next(480), rnd.Next(30))}
                },
                    FusionPosition = new ObservableConcurrentDictionary<CameraModel, Vector3>
                {
                    {cam0, new Vector3(rnd.Next(-50, 50), rnd.Next(-50, 50), rnd.Next(-50, 50))},
                    {cam1, new Vector3(rnd.Next(640), rnd.Next(480), rnd.Next(30))}
                },
                    CameraPosition = new ObservableConcurrentDictionary<CameraModel, Vector3>
                {
                    {cam0, new Vector3(rnd.Next(-50, 50), rnd.Next(-50, 50), rnd.Next(-50, 50))},
                    {cam1, new Vector3(rnd.Next(640), rnd.Next(480), rnd.Next(30))}
                },
                    WorldPosition = new ObservableConcurrentDictionary<CameraModel, Vector3>
                {
                    {cam0, new Vector3(rnd.Next(-50, 50), rnd.Next(-50, 50), rnd.Next(-50, 50))},
                    {cam1, new Vector3(rnd.Next(640), rnd.Next(480), rnd.Next(30))}
                }
                };
            }

            MotionController.Circle = rnd.Next(2) > 0;
            MotionController.Cross = rnd.Next(2) > 0;
            MotionController.Triangle = rnd.Next(2) > 0;
            MotionController.Square = rnd.Next(2) > 0;
            MotionController.Start = rnd.Next(2) > 0;
            MotionController.Select = rnd.Next(2) > 0;
            MotionController.Move = rnd.Next(2) > 0;
            MotionController.PS = rnd.Next(2) > 0;
            MotionController.Trigger = rnd.Next(256);
            #endif
        }
 public void Initialize(CameraModel camera)
 {
     _camera = camera;
     _camera.GUID = _camera.TrackerId + "1245678-9ABC-DEFG-HIJK-LMNOPQRSTUVW";
 }
 public AddCameraMessage(CameraModel camera)
 {
     Camera = camera;
 }
        public void DoRefresh()
        {
            ObservableCollection<CameraModel> existingCameras = new ObservableCollection<CameraModel>();
            AvailableCameras.Clear();
            NewCamera = new CameraModel
            {
                Name = null,
                Design = true
            };
            NewCamerasDetected = false;

            ICameraService cameraService = new ClEyeService(new ConsoleService());
            int connectedCount = cameraService.GetConnectedCount();
            if (connectedCount > 0)
            {
                foreach (CameraViewModel cameraViewModel in SimpleIoc.Default.GetAllCreatedInstances<CameraViewModel>())
                {
                    existingCameras.Add(cameraViewModel.Camera);
                }

                for (int i = 0; i < connectedCount; i++)
                {
                    CameraModel tmp = new CameraModel();
                    tmp.TrackerId = i;
                    cameraService.Initialize(tmp);
                    if(existingCameras.Count > 0)
                    {
                        bool duplicate = false;
                        foreach (CameraModel sc in existingCameras)
                        {
                            if (tmp.GUID.Equals(sc.GUID))
                            {
                                duplicate = true;
                                break;
                            }
                        }
                        if (!duplicate) AvailableCameras.Add(tmp);
                    }
                    else
                    {
                        AvailableCameras.Add(tmp);
                    }

                    cameraService.Destroy();
                }

                if (AvailableCameras.Count > 0)
                {
                    NewCamerasDetected = true;
                }
            }
        }
 public RemoveCameraMessage(CameraModel camera, Action<bool> feedback)
 {
     Camera = camera;
     Feedback = feedback;
 }
 public RemoveCameraMessage(CameraModel camera)
 {
     Camera = camera;
 }
        void FindHomographyMatrix(CameraModel cam1, CameraModel cam2)
        {
            PointF[] src = new PointF[4] {
                cam1.Calibration.ObjectPointsProjected[0],
                cam1.Calibration.ObjectPointsProjected[1],
                cam1.Calibration.ObjectPointsProjected[2],
                cam1.Calibration.ObjectPointsProjected[3]
            };

            PointF[] dst = new PointF[4] {
                cam2.Calibration.ObjectPointsProjected[0],
                cam2.Calibration.ObjectPointsProjected[1],
                cam2.Calibration.ObjectPointsProjected[2],
                cam2.Calibration.ObjectPointsProjected[3]
            };

            HomographyMatrix h = CameraCalibration.FindHomography(src, dst, HOMOGRAPHY_METHOD.RANSAC, 3);

            PointF test = cam1.Calibration.ObjectPointsProjected[0];
        }
        Matrix<double> FindFundamentalMatrix(CameraModel cam1, CameraModel cam2)
        {
            IntPtr points1Ptr = CvHelper.CreatePointListPointer(CvHelper.NormalizePoints(cam1.Calibration.ObjectPointsProjected, cam1.Calibration.IntrinsicParameters));
            IntPtr points2Ptr = CvHelper.CreatePointListPointer(CvHelper.NormalizePoints(cam2.Calibration.ObjectPointsProjected, cam1.Calibration.IntrinsicParameters));

            Matrix<double> fundamentalMatrix = new Matrix<double>(3, 3);

            IntPtr fundamentalMatrixPtr = CvInvoke.cvCreateMat(3, 3, MAT_DEPTH.CV_32F);
            CvInvoke.cvFindFundamentalMat(points1Ptr, points2Ptr, fundamentalMatrix.Ptr, CV_FM.CV_FM_RANSAC, 3, 0.99, IntPtr.Zero);

            return fundamentalMatrix;
        }
        public void Initialize(CameraModel camera)
        {
            _camera = camera;
            Device = new CLEyeCameraDevice();
            Device.BitmapReady += Device_BitmapReady;
            Device.Resolution = CLEyeCameraResolution.CLEYE_VGA;
            Device.ColorMode = CLEyeCameraColorMode.CLEYE_COLOR_RAW;
            //CLEYE_QVGA - 15, 30, 60, 75, 100, 125
            //CLEYE_VGA - 15, 30, 40, 50, 60, 75
            Device.Framerate = 60;
            _camera.GUID = CLEyeCameraDevice.CameraUUID(_camera.TrackerId).ToString();

            ConsoleService.Write(string.Format("[Camera, {0}] Initialized", _camera.GUID));
        }
 public void SaveCamera(CameraModel cameraModel)
 {
     TextWriter writer = null;
     try
     {
         string json = JsonConvert.SerializeObject(cameraModel, Formatting.Indented);
         writer = new StreamWriter(String.Format(AppDomain.CurrentDomain.BaseDirectory + "\\cfg\\{0}.cam.json", cameraModel.GUID), false);
         writer.Write(json);
     }
     finally
     {
         if (writer != null) writer.Close();
     }
 }