Esempio n. 1
0
        private async void ConfirmButton_Click(object sender, RoutedEventArgs e)
        {
            if (!string.IsNullOrWhiteSpace(UserNameBox.Text))
            {
                // Create or open the folder in which the Whitelist is stored
                StorageFolder whitelistFolder = await KnownFolders.PicturesLibrary.CreateFolderAsync(GeneralConstants.WhiteListFolderName, CreationCollisionOption.OpenIfExists);

                // Create a folder to store this specific user's photos
                StorageFolder currentFolder = await whitelistFolder.CreateFolderAsync(UserNameBox.Text, CreationCollisionOption.ReplaceExisting);

                // Move the already captured photo the user's folder
                await currentIdPhotoFile.MoveAsync(currentFolder);

                // Add user to Oxford database
                OxfordFaceAPIHelper.AddUserToWhitelist(UserNameBox.Text, currentFolder);

                // Stop live camera feed
                await webcam.StopCameraPreview();

                var parameters = new NewUserPage
                {
                    Dummy     = ((Button)sender).Name.ToString(),
                    ToWelcome = "true",
                    UserName  = UserNameBox.Text
                };

                // Navigate back to MainPage
                this.Frame.Navigate(typeof(MainPage), parameters);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Called once, when the app is first opened. Initializes Oxford facial recognition.
        /// </summary>
        public async void InitializeOxford()
        {
            // initializedOxford bool will be set to true when Oxford has finished initialization successfully
            initializedOxford = await OxfordFaceAPIHelper.InitializeOxford();

            // Populates UI grid with whitelisted visitors
            UpdateWhitelistedVisitors();
        }
Esempio n. 3
0
        public async Task CapturePhoto()
        {
            await webcam.InitializeCameraAsync();

            if (!webcam.IsInitialized())
            {
                Debug.WriteLine("Not initialied");
            }
            StorageFile image = await webcam.CapturePhoto();

            try
            {
                // Oxford determines whether or not the visitor is on the Whitelist and returns true if so
                recognizedVisitors = await OxfordFaceAPIHelper.IsFaceInWhitelist(image);
            }
            catch (FaceRecognitionException fe)
            {
                switch (fe.ExceptionType)
                {
                // Fails and catches as a FaceRecognitionException if no face is detected in the image
                case FaceRecognitionExceptionType.NoFaceDetected:
                    Debug.WriteLine("WARNING: No face detected in this image.");
                    break;
                }
            }
            catch (FaceAPIException faceAPIEx)
            {
                Debug.WriteLine("FaceAPIException in IsFaceInWhitelist(): " + faceAPIEx.ErrorMessage);
            }
            catch
            {
                // General error. This can happen if there are no visitors authorized in the whitelist
                Debug.WriteLine("WARNING: Oxford just threw a general expception.");
            }

            if (recognizedVisitors.Count > 0)
            {
                // If everything went well and a visitor was recognized, unlock the door:
                Ledpin.Write(GpioPinValue.Low);
            }
            else
            {
                // Create or open the folder in which the Whitelist is stored
                StorageFolder folder = await KnownFolders.PicturesLibrary.CreateFolderAsync("Banned", CreationCollisionOption.OpenIfExists);

                // Move the already captured photo the user's folder
                await image.MoveAsync(folder);

                var model = new Models.Database.Ban()
                {
                    Image = image.Name,
                    Time  = DateTime.Now
                };
                Ledpin.Write(GpioPinValue.High);
                database.InsertModel <Models.Database.Ban>(model);
            }
            isCapturing = false;
        }
        /// <summary>
        /// Triggered when the user clicks the add photo button located in the app bar
        /// </summary>
        private async void AddButton_Tapped(object sender, TappedRoutedEventArgs e)
        {
            // Captures photo from current webcam stream
            StorageFile imageFile = await webcam.CapturePhoto();

            // Moves the captured file to the current user's ID image folder
            await imageFile.MoveAsync(currentUser.ImageFolder);

            // Update photo grid
            PopulatePhotoGrid();
            // Add to Oxford
            OxfordFaceAPIHelper.AddImageToWhitelist(imageFile, currentUser.Name);
        }
        /// <summary>
        /// Triggered when the user clicks the delete user button located in the app bar
        /// </summary>
        private async void DeleteButton_Tapped(object sender, TappedRoutedEventArgs e)
        {
            // Delete the user's folder
            await currentUser.ImageFolder.DeleteAsync();

            // Remove user from Oxford
            OxfordFaceAPIHelper.RemoveUserFromWhitelist(currentUser.Name);

            // Stop camera preview
            await webcam.StopCameraPreview();

            // Navigate to MainPage
            Frame.Navigate(typeof(MainPage));
        }
Esempio n. 6
0
        /// <summary>
        /// Called once, when the app is first opened. Initializes Oxford facial recognition.
        /// </summary>
        public async void InitializeOxford()
        {
            // initializedOxford bool will be set to true when Oxford has finished initialization successfully
            initializedOxford = await OxfordFaceAPIHelper.InitializeOxford(this.speech);

            // Populates UI grid with whitelisted visitors
            UpdateWhitelistedVisitors();

            if (initializedOxford)
            {
                this.imageFromCameraWithFaces.PerformRecognition = true;
                await speech.Read("Система распознавания лиц инициализирована успешно.");

                this.cameraControl.EnableAutoCaptureMode     = true;
                this.cameraControl.FilterOutSmallFaces       = true;
                this.cameraControl.AutoCaptureStateChanged  += CameraControl_AutoCaptureStateChanged;
                this.cameraControl.CameraAspectRatioChanged += CameraControl_CameraAspectRatioChanged;

                //   this.cameraControl.CameraRestarted += CameraControl_CameraRestarted;

                // If user has set the DisableLiveCameraFeed within Constants.cs to true, disable the feed:
                if (GeneralConstants.DisableLiveCameraFeed)
                {
                    cameraHostGrid.Visibility   = Visibility.Collapsed;
                    DisabledFeedGrid.Visibility = Visibility.Visible;
                }
                else
                {
                    cameraHostGrid.Visibility   = Visibility.Visible;
                    DisabledFeedGrid.Visibility = Visibility.Collapsed;
                }
            }
            else
            {
                await speech.Read("Ошибка инициализации системы распознавания лиц.");
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Called when user hits physical or vitual doorbell buttons. Captures photo of current webcam view and sends it to Oxford for facial recognition processing.
        /// </summary>
        private async Task DoorbellPressed()
        {
            // Display analysing visitors grid to inform user that doorbell press was registered
            AnalysingVisitorGrid.Visibility = Visibility.Visible;

            // List to store visitors recognized by Oxford Face API
            // Count will be greater than 0 if there is an authorized visitor at the door
            List <string> recognizedVisitors = new List <string>();

            // Confirms that webcam has been properly initialized and oxford is ready to go
            if (webcam.IsInitialized() && initializedOxford)
            {
                // Stores current frame from webcam feed in a temporary folder
                StorageFile image = await webcam.CapturePhoto();

                try
                {
                    // Oxford determines whether or not the visitor is on the Whitelist and returns true if so
                    recognizedVisitors = await OxfordFaceAPIHelper.IsFaceInWhitelist(image);
                }
                catch (FaceRecognitionException fe)
                {
                    switch (fe.ExceptionType)
                    {
                    // Fails and catches as a FaceRecognitionException if no face is detected in the image
                    case FaceRecognitionExceptionType.NoFaceDetected:
                        Debug.WriteLine("WARNING: No face detected in this image.");
                        break;
                    }
                }
                catch (FaceAPIException faceAPIEx)
                {
                    Debug.WriteLine("FaceAPIException in IsFaceInWhitelist(): " + faceAPIEx.ErrorMessage);
                }
                catch
                {
                    // General error. This can happen if there are no visitors authorized in the whitelist
                    Debug.WriteLine("WARNING: Oxford just threw a general expception.");
                }

                if (recognizedVisitors.Count > 0)
                {
                    // If everything went well and a visitor was recognized, unlock the door:
                    AuthenticateUser(recognizedVisitors[0]);
                }
                else
                {
                    // Otherwise, inform user that they were not recognized by the system
                    await speech.Read(SpeechContants.VisitorNotRecognizedMessage);
                }
            }
            else
            {
                if (!webcam.IsInitialized())
                {
                    // The webcam has not been fully initialized for whatever reason:
                    Debug.WriteLine("Unable to analyze visitor at door as the camera failed to initlialize properly.");
                    await speech.Read(SpeechContants.NoCameraMessage);
                }

                if (!initializedOxford)
                {
                    // Oxford is still initializing:
                    Debug.WriteLine("Unable to analyze visitor at door as Oxford Facial Recogntion is still initializing.");
                }
            }

            doorbellJustPressed             = false;
            AnalysingVisitorGrid.Visibility = Visibility.Collapsed;
        }