diff --git a/AffdexMe/AffdexMe.csproj b/AffdexMe/AffdexMe.csproj
new file mode 100644
index 0000000..fce5f81
--- /dev/null
+++ b/AffdexMe/AffdexMe.csproj
@@ -0,0 +1,116 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {5B893EA1-EB11-425A-BF8A-05822F5E2C9A}
+ WinExe
+ Properties
+ AffdexMe
+ AffdexMe
+ v4.5
+ 512
+ {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
+ 4
+
+
+ x86
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ $(ProjectDir)Resources\AffdexMe_Logo.ico
+
+
+ x86
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+
+ ..\..\Program Files (x86)\Affectiva\Affdex SDK\bin\debug\Affdex.dll
+
+
+ ..\..\Program Files (x86)\Affectiva\Affdex SDK\bin\release\Affdex.dll
+
+
+
+
+
+
+
+
+
+
+
+ 4.0
+
+
+
+
+
+
+
+ MSBuild:Compile
+ Designer
+
+
+ Code
+
+
+ $(ProjectDir)MainWindow.xaml
+ Code
+
+
+
+
+ Code
+
+
+ True
+ True
+ Resources.resx
+
+
+ True
+ $(ProjectDir)Settings.settings
+ True
+
+
+ ResXFileCodeGenerator
+ $(ProjectDir)Resources.Designer.cs
+
+
+
+ SettingsSingleFileGenerator
+ $(ProjectDir)Settings.Designer.cs
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/AffdexMe/App.config b/AffdexMe/App.config
new file mode 100644
index 0000000..8e15646
--- /dev/null
+++ b/AffdexMe/App.config
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/AffdexMe/App.cs b/AffdexMe/App.cs
new file mode 100644
index 0000000..9168056
--- /dev/null
+++ b/AffdexMe/App.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+using Microsoft.VisualBasic.ApplicationServices;
+
+namespace AffdexMe
+{
+ ///
+ /// Interaction logic for App.xaml
+ ///
+ public partial class App : Application
+ {
+ }
+
+
+ ///
+ /// From reference source: https://msdn.microsoft.com/en-us/library/vstudio/ms771662(v=vs.90).aspx
+ ///
+ public class EntryPoint
+ {
+ [STAThread]
+ public static void Main(string[] args)
+ {
+ SingleInstanceManager manager = new SingleInstanceManager();
+ manager.Run(args);
+ }
+ }
+
+ // Using VB bits to detect single instances and process accordingly:
+ // * OnStartup is fired when the first instance loads
+ // * OnStartupNextInstance is fired when the application is re-run again
+ // NOTE: it is redirected to this instance thanks to IsSingleInstance
+ public class SingleInstanceManager : WindowsFormsApplicationBase
+ {
+ SingleInstanceApplication app;
+
+ public SingleInstanceManager()
+ {
+ this.IsSingleInstance = true;
+ }
+
+
+ protected override bool OnStartup(Microsoft.VisualBasic.ApplicationServices.StartupEventArgs e)
+ {
+ // First time app is launched
+ app = new SingleInstanceApplication();
+ app.Run();
+ return false;
+ }
+
+ protected override void OnStartupNextInstance(StartupNextInstanceEventArgs eventArgs)
+ {
+ // Subsequent launches
+ base.OnStartupNextInstance(eventArgs);
+ app.Activate();
+ }
+ }
+
+ public class SingleInstanceApplication : Application
+ {
+
+ protected override void OnStartup(System.Windows.StartupEventArgs e)
+ {
+ base.OnStartup(e);
+
+ // Create and show the application's main window
+ MainWindow window = new MainWindow();
+ window.Show();
+ }
+
+ public void Activate()
+ {
+ // Reactivate application's main window
+ this.MainWindow.Activate();
+ }
+ }
+}
diff --git a/AffdexMe/App.xaml b/AffdexMe/App.xaml
new file mode 100644
index 0000000..868f299
--- /dev/null
+++ b/AffdexMe/App.xaml
@@ -0,0 +1,8 @@
+
+
+
+
+
diff --git a/AffdexMe/App.xaml.cs b/AffdexMe/App.xaml.cs
new file mode 100644
index 0000000..8514a22
--- /dev/null
+++ b/AffdexMe/App.xaml.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace AffdexMe
+{
+ ///
+ /// Interaction logic for App.xaml
+ ///
+ public partial class App : Application
+ {
+ }
+}
diff --git a/AffdexMe/Fonts/Square.ttf b/AffdexMe/Fonts/Square.ttf
new file mode 100644
index 0000000..9f1867e
Binary files /dev/null and b/AffdexMe/Fonts/Square.ttf differ
diff --git a/AffdexMe/MainWindow.xaml b/AffdexMe/MainWindow.xaml
new file mode 100644
index 0000000..264d2ab
--- /dev/null
+++ b/AffdexMe/MainWindow.xaml
@@ -0,0 +1,248 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/AffdexMe/MainWindow.xaml.cs b/AffdexMe/MainWindow.xaml.cs
new file mode 100644
index 0000000..9052a1b
--- /dev/null
+++ b/AffdexMe/MainWindow.xaml.cs
@@ -0,0 +1,755 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+
+using Microsoft.Win32;
+
+namespace AffdexMe
+{
+ ///
+ /// Interaction logic for MainWindow.xaml
+ ///
+ public partial class MainWindow : Window
+ {
+ ///
+ /// Location of Affdex Data files
+ ///
+ private const String AFFDEX_DATA_PATH = "C:\\Program Files (x86)\\Affectiva\\Affdex SDK\\data";
+
+ ///
+ /// Location of AffdexSDK Licence file
+ ///
+ private const String AFFDEX_LICENSE_FILE = "C:\\Affectiva\\Build\\AffdexfaceWindows\\bin\\affdex.license";
+
+ #region Member Variables and Enums
+
+ enum AffdexFaceClassifiers : int
+ {
+ Smile = 0,
+ BrowFurrow = 1,
+ BrowRaise = 2,
+ LipCornerDepressor = 3,
+ Engagement = 4,
+ Valence = 5
+ };
+
+ ///
+ /// The minimum length of the Classifier Value textbox
+ ///
+ const int ClassiferValueDisplayLength = 90;
+
+ ///
+ /// So the Classifiers can be cached
+ ///
+ int[] mAffdexClassifierValues = new int[6];
+
+ ///
+ /// Once a face has been recognized, the number of captures that occur before the classifiers get zero displayed
+ /// This helps prevent classifier numbers from flashing on the screen.
+ ///
+ int mCachedSkipFaceResultsCount;
+
+ ///
+ /// Once a face's feature points get displayed, the number of successive captures that occur without
+ /// the points getting redrawn in the OnResults callback.
+ ///
+ int mFeaturePointsSkipCount;
+
+ ///
+ /// Used to delay the display of the Classifier panel until the 1st face is recognized
+ ///
+ bool mFirstFaceRecognized;
+
+ private Affdex.CameraDetector mCameraDetector;
+
+ private DateTime mStartTime;
+
+ private float mCurrentTimeStamp;
+
+ ///
+ /// Scale factor based on ratio between current and original size
+ ///
+ private double mImageXScaleFactor;
+ private double mImageYScaleFactor;
+
+ private bool mShowFacePoints;
+
+ #endregion
+
+ #region Image and Results Arg Classes
+ ///
+ ///
+ ///
+ class ImageCaptureDataUpdateArgs
+ {
+ public float ImageCaptureTimeStamp {get; set;}
+ public Affdex.Frame Image { get; set; }
+ }
+
+ ///
+ ///
+ ///
+ class ImageResultsDataUpdateArgs
+ {
+ public float ImageResultsTimeStamp { get; set; }
+ public Affdex.Frame Image { get; set; }
+ public Affdex.Face Face { get; set; }
+ }
+
+ #endregion
+
+ #region Listener Implementation
+
+ ///
+ ///
+ ///
+ class Listener : Affdex.ImageListener, Affdex.ProcessStatusListener
+ {
+ public event EventHandler ImageCaptureUpdate;
+ public event EventHandler ImageResultsUpdate;
+ public event EventHandler ExceptionHandler;
+
+ public void onImageResults(Dictionary faces, Affdex.Frame image)
+ {
+ // For now only single face is supported
+ if ((faces.Count() >= 1))
+ {
+ Affdex.Face face = faces[0];
+
+ if (ImageResultsUpdate != null)
+ {
+ ImageResultsDataUpdateArgs imageResultsData = new ImageResultsDataUpdateArgs()
+ {
+ Image = image,
+ ImageResultsTimeStamp = image.getTimestamp(),
+ Face = face
+ };
+ ImageResultsUpdate(this, imageResultsData);
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ ///
+ public void onImageCapture(Affdex.Frame image)
+ {
+ if (ImageCaptureUpdate != null)
+ {
+ ImageCaptureDataUpdateArgs imageCaptureData = new ImageCaptureDataUpdateArgs()
+ {
+ Image = image,
+ ImageCaptureTimeStamp = image.getTimestamp()
+ };
+ ImageCaptureUpdate(this, imageCaptureData);
+
+ }
+ }
+
+ public void onProcessingException(Affdex.AffdexException ex)
+ {
+ if (ExceptionHandler != null)
+ {
+ ExceptionHandler(this, ex);
+ }
+ }
+
+ public void onProcessingFinished()
+ {
+ }
+ };
+
+ #endregion
+
+ private void ShowExceptionAndShutDown(String exceptionMessage)
+ {
+ MessageBoxResult result = MessageBox.Show(exceptionMessage,
+ "AffdexMe Error",
+ MessageBoxButton.OK,
+ MessageBoxImage.Error);
+ this.Dispatcher.BeginInvoke((Action)(() =>
+ {
+ StopCameraProcessing();
+ }));
+ }
+
+ public MainWindow()
+ {
+ InitializeComponent();
+ CenterWindowOnScreen();
+ }
+
+ private void Window_Loaded(object sender, RoutedEventArgs e)
+ {
+ InitializeCameraApp();
+
+ // Enable/Disable buttons on start
+ btnStartCamera.IsEnabled =
+ btnResetCamera.IsEnabled =
+ btnShowPoints.IsEnabled =
+ btnStopCamera.IsEnabled =
+ btnExit.IsEnabled = true;
+
+ this.ContentRendered += MainWindow_ContentRendered;
+ }
+
+ ///
+ /// Once the window las been loaded and the content rendered, the camera
+ /// can be initialized and started. This sequence allows for the underlying controls
+ /// and watermark logo to be displayed.
+ ///
+ ///
+ ///
+ void MainWindow_ContentRendered(object sender, EventArgs e)
+ {
+ StartCameraProcessing();
+ }
+
+ ///
+ ///
+ ///
+ private void CenterWindowOnScreen()
+ {
+ double screenWidth = System.Windows.SystemParameters.PrimaryScreenWidth;
+ double screenHeight = System.Windows.SystemParameters.PrimaryScreenHeight;
+ double windowWidth = this.Width;
+ double windowHeight = this.Height;
+ this.Left = (screenWidth / 2) - (windowWidth / 2);
+ this.Top = (screenHeight / 2) - (windowHeight / 2);
+ }
+
+ private BitmapSource ConstructImage(byte[] imageData, int width, int height)
+ {
+ try
+ {
+ if (imageData != null && imageData.Length > 0)
+ {
+ var stride = (width * PixelFormats.Bgr24.BitsPerPixel + 7) / 8;
+ var imageSrc = BitmapSource.Create(width, height, 96d, 96d, PixelFormats.Bgr24, null, imageData, stride);
+ return imageSrc;
+ }
+ }
+ catch(Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+
+ return null;
+ }
+
+ private void DisplayFeaturePoints(Affdex.Frame affdexImage, Affdex.Face affdexFace)
+ {
+ try
+ {
+ // Plot Face Points
+ if ((mShowFacePoints) && (affdexFace != null))
+ {
+ canvasFacePoints.Dispatcher.BeginInvoke((Action)(() =>
+ {
+ if ((mCameraDetector != null) && (mCameraDetector.isRunning()))
+ {
+ // Clear the previous points
+ canvasFacePoints.Children.Clear();
+ canvasFacePoints.Width = imgAffdexFaceDisplay.ActualWidth;
+ canvasFacePoints.Height = imgAffdexFaceDisplay.ActualHeight;
+
+ mImageXScaleFactor = imgAffdexFaceDisplay.ActualWidth / affdexImage.getWidth();
+ mImageYScaleFactor = imgAffdexFaceDisplay.ActualHeight / affdexImage.getHeight();
+
+ SolidColorBrush pointBrush = new SolidColorBrush(Colors.Cornsilk);
+ var featurePoints = affdexFace.getFeaturePoints();
+ foreach (var point in featurePoints)
+ {
+ Ellipse ellipse = new Ellipse()
+ {
+ Width = 4,
+ Height = 4,
+ Fill = pointBrush
+ };
+
+ canvasFacePoints.Children.Add(ellipse);
+ Canvas.SetLeft(ellipse, point.x * mImageXScaleFactor);
+ Canvas.SetTop(ellipse, point.y * mImageYScaleFactor);
+ }
+
+ // Draw Face Bounding Rectangle
+ var xMax = featurePoints.Max(r => r.x);
+ var xMin = featurePoints.Min(r => r.x);
+ var yMax = featurePoints.Max(r => r.y);
+ var yMin = featurePoints.Min(r => r.y);
+
+ // Adjust the x/y min to accomodate all points
+ xMin -= 2;
+ yMin -= 2;
+
+ // Increase the width/height to accomodate the entire max pixel position
+ // EllipseWidth + N to make sure max points in the box
+ double width = (xMax - xMin + 6) * mImageXScaleFactor;
+ double height = (yMax - yMin + 6) * mImageYScaleFactor;
+
+ SolidColorBrush boundingBrush = new SolidColorBrush(Colors.Bisque);
+ Rectangle boundingBox = new Rectangle()
+ {
+ Width = width,
+ Height = height,
+ Stroke = boundingBrush,
+ StrokeThickness = 1,
+ };
+
+ canvasFacePoints.Children.Add(boundingBox);
+ Canvas.SetLeft(boundingBox, xMin * mImageXScaleFactor);
+ Canvas.SetTop(boundingBox, yMin * mImageYScaleFactor);
+
+ mFeaturePointsSkipCount = 0;
+
+ affdexFace.Dispose();
+ affdexImage.Dispose();
+ }
+ }));
+ }
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+
+ ///
+ /// Since the panel is getting updated from a separate callback thread, access to controls must be
+ /// made through BeginInvoke()
+ ///
+ ///
+ private void UpdateClassifierPanel(Affdex.Face face = null)
+ {
+ try
+ {
+ bool displayClassifiers = (imgAffdexFaceDisplay.Visibility == Visibility.Hidden)? false : true;
+
+ if (mCameraDetector.isRunning() == true)
+ {
+ // A Face was found - this comes from ImageResults CallBack
+ if (face != null)
+ {
+ // Convert classifier value to Integer (percentage) for display purposes
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.Smile] = Convert.ToInt32(Math.Round(face.getSmileScore(), MidpointRounding.AwayFromZero));
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.BrowFurrow] = Convert.ToInt32(Math.Round(face.getBrowFurrowScore(), MidpointRounding.AwayFromZero));
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.BrowRaise] = Convert.ToInt32(Math.Round(face.getBrowRaiseScore(), MidpointRounding.AwayFromZero));
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.LipCornerDepressor] = Convert.ToInt32(Math.Round(face.getLipCornerDepressorScore(), MidpointRounding.AwayFromZero));
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.Engagement] = Convert.ToInt32(Math.Round(face.getEngagementScore(), MidpointRounding.AwayFromZero));
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.Valence] = Convert.ToInt32(Math.Round(face.getValenceScore(), MidpointRounding.AwayFromZero));
+
+ // Reset the cache count
+ mCachedSkipFaceResultsCount = 0;
+ mFirstFaceRecognized =
+ displayClassifiers = true;
+ }
+ else if (mFirstFaceRecognized == false)
+ {
+ displayClassifiers = false;
+ }
+ else if (++mCachedSkipFaceResultsCount > 10)
+ {
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.Smile] =
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.BrowFurrow] =
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.BrowRaise] =
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.LipCornerDepressor] =
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.Engagement] =
+ mAffdexClassifierValues[(int)AffdexFaceClassifiers.Valence] = 0;
+
+ // If we haven't seen a face in the past 30 frames (roughly 30/15fps seconds), don't display the classifiers
+ if (mCachedSkipFaceResultsCount >= 30)
+ {
+ displayClassifiers = false;
+ }
+ }
+
+ // Only display the classifiers and FacePoints if we've had a re
+ if (displayClassifiers)
+ {
+ // Update the Classifier Display
+ UpdateClassifier(txtSmileClassifierName, txtSmileClassifierValue, txtSmileClassifierValueBackground, AffdexFaceClassifiers.Smile);
+ UpdateClassifier(txtFrownClassifierName, txtFrownClassifierValue, txtFrownClassifierValueBackground, AffdexFaceClassifiers.LipCornerDepressor);
+ UpdateClassifier(txtBrowRaiseClassifierName, txtBrowRaiseClassifierValue, txtBrowRaiseClassifierValueBackground, AffdexFaceClassifiers.BrowRaise);
+ UpdateClassifier(txtValenceClassifierName, txtValenceClassifierValue, txtValenceClassifierValueBackground, AffdexFaceClassifiers.Valence);
+ UpdateClassifier(txtBrowLowerClassifierName, txtBrowLowerClassifierValue, txtBrowLowerClassifierValueBackground, AffdexFaceClassifiers.BrowFurrow);
+ UpdateClassifier(txtEngagementClassifierName, txtEngagementClassifierValue, txtEngagementClassifierValueBackground, AffdexFaceClassifiers.Engagement);
+ }
+
+ // Update the Image control from the UI thread
+ stackPanelClassifiers.Dispatcher.BeginInvoke((Action)(() =>
+ {
+ if ((mCameraDetector != null) && (mCameraDetector.isRunning()))
+ {
+ if (imgAffdexFaceDisplay.Visibility == Visibility.Hidden)
+ {
+ imgAffdexFaceDisplay.Visibility =
+ stackPanelClassifiersBackground.Visibility =
+ stackPanelLogoBackground.Visibility = Visibility.Visible;
+ }
+ stackPanelClassifiers.Visibility = (displayClassifiers)?Visibility.Visible : Visibility.Hidden;
+ }
+ }));
+ }
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ private void UpdateClassifier(TextBlock txtClassifier, TextBlock txtClassifierValue,
+ TextBlock txtClassifierValueBackground, AffdexFaceClassifiers classifierIndex)
+ {
+ try
+ {
+ int classifierValue = mAffdexClassifierValues[(int)classifierIndex];
+
+ // Calculate the width
+ double width = ClassiferValueDisplayLength * Math.Abs(classifierValue) / 100;
+
+ var backgroundColor = Colors.Transparent;
+
+ if (classifierValue > 0)
+ {
+ backgroundColor = Colors.LimeGreen;
+ }
+ else if (classifierValue < 0)
+ {
+ backgroundColor = Colors.Red;
+ }
+
+ txtClassifierValue.Dispatcher.BeginInvoke((Action)(() =>
+ {
+ txtClassifierValueBackground.Background = new SolidColorBrush(backgroundColor);
+ txtClassifierValueBackground.Width = width;
+ txtClassifierValue.Text = String.Format("{0}%", classifierValue);
+ }));
+
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ private void DisplayImageToOffscreenCanvas(Affdex.Frame image)
+ {
+ // Update the Image control from the UI thread
+ imgAffdexFaceDisplay.Dispatcher.BeginInvoke((Action)(() =>
+ {
+ try
+ {
+ mCurrentTimeStamp = image.getTimestamp();
+
+ // Update the Image control from the UI thread
+ //imgAffdexFaceDisplay.Source = rtb;
+ imgAffdexFaceDisplay.Source = ConstructImage(image.getBGRByteArray(), image.getWidth(), image.getHeight());
+
+ // Allow N successive OnCapture callbacks before the FacePoint drawing canvas gets cleared.
+ if (++mFeaturePointsSkipCount > 4)
+ {
+ canvasFacePoints.Children.Clear();
+ mFeaturePointsSkipCount = 0;
+ }
+
+ if (image != null)
+ {
+ image.Dispose();
+ }
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }));
+ }
+
+ ///
+ ///
+ ///
+ private void InitializeCameraApp()
+ {
+ try
+ {
+ mCameraDetector = null;
+
+ // Initialize Button Click Handlers
+ btnStartCamera.Click += btnStartCamera_Click;
+ btnStopCamera.Click += btnStopCamera_Click;
+ btnShowPoints.Click += btnShowPoints_Click;
+ btnResetCamera.Click += btnResetCamera_Click;
+ btnExit.Click += btnExit_Click;
+
+ // Disable Stop/Reset buttons
+ btnResetCamera.IsEnabled =
+ btnStopCamera.IsEnabled = false;
+
+ mFeaturePointsSkipCount =
+ mCachedSkipFaceResultsCount = 0;
+
+ // Initially hide Classifier Panels
+ stackPanelLogoBackground.Visibility =
+ stackPanelClassifiersBackground.Visibility =
+ stackPanelClassifiers.Visibility = Visibility.Hidden;
+
+ // Face Points are off by default
+ mShowFacePoints = false;
+
+ // Show the logo
+ imgAffdexLogoDisplay.Visibility = Visibility.Visible;
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ void btnShowPoints_Click(object sender, RoutedEventArgs e)
+ {
+ try
+ {
+ Style style;
+ String buttonText = String.Empty;
+
+ mShowFacePoints = !mShowFacePoints;
+ if (mShowFacePoints)
+ {
+ style = this.FindResource("PointsOnButtonStyle") as Style;
+ buttonText = "Hide Points";
+ }
+ else
+ {
+ style = this.FindResource("CustomButtonStyle") as Style;
+ buttonText = "Show Points";
+ }
+
+ btnShowPoints.Style = style;
+ btnShowPoints.Content = buttonText;
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ private void btnResetCamera_Click(object sender, RoutedEventArgs e)
+ {
+ ResetCameraProcessing();
+ }
+
+ void btnStartCamera_Click(object sender, RoutedEventArgs e)
+ {
+ try
+ {
+ StartCameraProcessing();
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ void btnStopCamera_Click(object sender, RoutedEventArgs e)
+ {
+ StopCameraProcessing();
+ ResetDisplayArea();
+ }
+
+ void btnExit_Click(object sender, RoutedEventArgs e)
+ {
+ Application.Current.Shutdown();
+ }
+
+ private void ClearClassifiersAndPointsDisplay()
+ {
+ // Hide AffdexFace Image
+ imgAffdexFaceDisplay.Visibility =
+ stackPanelLogoBackground.Visibility =
+ stackPanelClassifiersBackground.Visibility = Visibility.Hidden;
+
+ // Hide the Classifier Panel
+ stackPanelClassifiers.Visibility = Visibility.Hidden;
+
+ // Clear any Face Points
+ canvasFacePoints.Children.Clear();
+ }
+
+ private void ResetDisplayArea()
+ {
+ try
+ {
+ ClearClassifiersAndPointsDisplay();
+
+ // Show the logo
+ imgAffdexLogoDisplay.Visibility = Visibility.Visible;
+ }
+ catch (Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ private void StartCameraProcessing()
+ {
+ try
+ {
+ // Instantiate CameraDetector using default camera ID
+ mCameraDetector = new Affdex.CameraDetector();
+ mCameraDetector.setClassifierPath(AFFDEX_DATA_PATH);
+
+ // Set the Classifiers that we are interested in tracking
+ mCameraDetector.setDetectSmile(true);
+ mCameraDetector.setDetectBrowFurrow(true);
+ mCameraDetector.setDetectBrowRaise(true);
+ mCameraDetector.setDetectLipCornerDepressor(true);
+ mCameraDetector.setDetectEngagement(true);
+ mCameraDetector.setDetectValence(true);
+
+ // Initialize Classifier cache
+ for (int index = 0; index < mAffdexClassifierValues.Count(); index++)
+ {
+ mAffdexClassifierValues[index] = 0;
+ }
+
+ mCachedSkipFaceResultsCount = 0;
+
+ Listener listener = new Listener();
+ listener.ImageCaptureUpdate += imageListener_ImageCaptureUpdate;
+ listener.ImageResultsUpdate += imageListener_ImageResultsUpdate;
+ listener.ExceptionHandler += imageListener_ExceptionHandler;
+
+ mCameraDetector.setImageListener(listener);
+ mCameraDetector.setProcessStatusListener(listener);
+
+ btnStartCamera.IsEnabled = false;
+ btnResetCamera.IsEnabled =
+ btnShowPoints.IsEnabled =
+ btnStopCamera.IsEnabled =
+ btnExit.IsEnabled = true;
+
+ // Set the License Path
+ mCameraDetector.setLicensePath(AFFDEX_LICENSE_FILE);
+
+ mStartTime = DateTime.Now;
+ mCameraDetector.start();
+
+ // Delay loading the Classifier panel until 1st face
+ mFirstFaceRecognized = false;
+
+ // Hide the logo
+ imgAffdexLogoDisplay.Visibility = Visibility.Hidden;
+ }
+ catch(Affdex.AffdexException ex)
+ {
+ if (!String.IsNullOrEmpty(ex.Message))
+ {
+ // If this is a camera failure, then reset the application to allow the user to turn on/enable camera
+ if (ex.Message.Equals("Unable to open webcam."))
+ {
+ MessageBoxResult result = MessageBox.Show(ex.Message,
+ "AffdexMe Error",
+ MessageBoxButton.OK,
+ MessageBoxImage.Error);
+ StopCameraProcessing();
+ return;
+ }
+ }
+
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ catch(Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ void imageListener_ExceptionHandler(object sender, Affdex.AffdexException ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+
+ void imageListener_ImageResultsUpdate(object sender, MainWindow.ImageResultsDataUpdateArgs e)
+ {
+ UpdateClassifierPanel(e.Face);
+ DisplayFeaturePoints(e.Image, e.Face);
+ }
+
+ void imageListener_ImageCaptureUpdate(object sender, MainWindow.ImageCaptureDataUpdateArgs e)
+ {
+ UpdateClassifierPanel();
+ DisplayImageToOffscreenCanvas(e.Image);
+ }
+
+ private void ResetCameraProcessing()
+ {
+ try
+ {
+ mCameraDetector.reset();
+ }
+ catch(Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ private void StopCameraProcessing()
+ {
+ try
+ {
+ if ((mCameraDetector != null) && (mCameraDetector.isRunning()))
+ {
+ mCameraDetector.stop();
+ mCameraDetector.Dispose();
+ mCameraDetector = null;
+ }
+
+ // Enable/Disable buttons on start
+ btnStartCamera.IsEnabled = true;
+ btnResetCamera.IsEnabled =
+ btnStopCamera.IsEnabled = false;
+
+ }
+ catch(Exception ex)
+ {
+ String message = String.IsNullOrEmpty(ex.Message) ? "AffdexMe error encountered." : ex.Message;
+ ShowExceptionAndShutDown(message);
+ }
+ }
+
+ private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
+ {
+ StopCameraProcessing();
+ Application.Current.Shutdown();
+ }
+
+ }
+}
diff --git a/AffdexMe/Properties/AssemblyInfo.cs b/AffdexMe/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..9a16c40
--- /dev/null
+++ b/AffdexMe/Properties/AssemblyInfo.cs
@@ -0,0 +1,55 @@
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Windows;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("AffdexMe")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("AffdexMe")]
+[assembly: AssemblyCopyright("Copyright © 2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+//In order to begin building localizable applications, set
+//CultureYouAreCodingWith in your .csproj file
+//inside a . For example, if you are using US english
+//in your source files, set the to en-US. Then uncomment
+//the NeutralResourceLanguage attribute below. Update the "en-US" in
+//the line below to match the UICulture setting in the project file.
+
+//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+
+[assembly: ThemeInfo(
+ ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+ //(used if a resource is not found in the page,
+ // or application resource dictionaries)
+ ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+ //(used if a resource is not found in the page,
+ // app, or any theme specific resource dictionaries)
+)]
+
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/AffdexMe/Properties/Resources.Designer.cs b/AffdexMe/Properties/Resources.Designer.cs
new file mode 100644
index 0000000..766f7c6
--- /dev/null
+++ b/AffdexMe/Properties/Resources.Designer.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:4.0.30319.34209
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace AffdexMe.Properties
+{
+
+
+ ///
+ /// A strongly-typed resource class, for looking up localized strings, etc.
+ ///
+ // This class was auto-generated by the StronglyTypedResourceBuilder
+ // class via a tool like ResGen or Visual Studio.
+ // To add or remove a member, edit your .ResX file then rerun ResGen
+ // with the /str option, or rebuild your VS project.
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ internal class Resources
+ {
+
+ private static global::System.Resources.ResourceManager resourceMan;
+
+ private static global::System.Globalization.CultureInfo resourceCulture;
+
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal Resources()
+ {
+ }
+
+ ///
+ /// Returns the cached ResourceManager instance used by this class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Resources.ResourceManager ResourceManager
+ {
+ get
+ {
+ if ((resourceMan == null))
+ {
+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("AffdexMe.Properties.Resources", typeof(Resources).Assembly);
+ resourceMan = temp;
+ }
+ return resourceMan;
+ }
+ }
+
+ ///
+ /// Overrides the current thread's CurrentUICulture property for all
+ /// resource lookups using this strongly typed resource class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Globalization.CultureInfo Culture
+ {
+ get
+ {
+ return resourceCulture;
+ }
+ set
+ {
+ resourceCulture = value;
+ }
+ }
+ }
+}
diff --git a/AffdexMe/Properties/Resources.resx b/AffdexMe/Properties/Resources.resx
new file mode 100644
index 0000000..af7dbeb
--- /dev/null
+++ b/AffdexMe/Properties/Resources.resx
@@ -0,0 +1,117 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
\ No newline at end of file
diff --git a/AffdexMe/Properties/Settings.Designer.cs b/AffdexMe/Properties/Settings.Designer.cs
new file mode 100644
index 0000000..20ed2e1
--- /dev/null
+++ b/AffdexMe/Properties/Settings.Designer.cs
@@ -0,0 +1,30 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:4.0.30319.34209
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace AffdexMe.Properties
+{
+
+
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
+ internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+ {
+
+ private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+ public static Settings Default
+ {
+ get
+ {
+ return defaultInstance;
+ }
+ }
+ }
+}
diff --git a/AffdexMe/Properties/Settings.settings b/AffdexMe/Properties/Settings.settings
new file mode 100644
index 0000000..033d7a5
--- /dev/null
+++ b/AffdexMe/Properties/Settings.settings
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/AffdexMe/README.md b/AffdexMe/README.md
new file mode 100644
index 0000000..70b6497
--- /dev/null
+++ b/AffdexMe/README.md
@@ -0,0 +1,53 @@
+# AffdexMe
+
+**Affdex SDK** is the culmination of years of scientific research into emotion detection, validated across thousands of tests worldwide on PC platforms, and now made available as a software development kit for Windows. Affdex SDK turns your ordinary app into an extraordinary app by emotion-enabling it to respond in real-time to user emotions.
+
+**AffdexMe** is a windows application that demonstrates the use of the Affdex SDK for Windows. It uses the camera on your Windows PC to view, process and analyze live video of your face. Start the app and you will see your own face on the screen, and metrics describing your expressions.
+
+#### This app includes the following command buttons:
+
+* Start - Starts the camera processing.
+* Reset - Resets the context of the video frames.
+* ShowPoints/HidePoints - toggles the display of facial feature points, which Affdex uses to detect expressions.
+* Stop - Stops the camera processing.
+* Exit - exits the application.
+
+This application runs on Windows 7.0, 8.0 and 8.1
+
+#### To use this project, you will need:
+
+* Visual Studio 2013
+
+* To download and install the Windows SDK from Affectiva By default, the Windows SDK is installed to the following location: C:\Program Files (x86)\Affectiva\Affdex SDK
+
+ If you have installed the SDK to a location other than the default, you will have to modify the following String constants located in the MainWindow.xaml.cs file:
+
+ * **AFFDEX_DATA_PATH** - the classifier data path
+ * **AFFDEX_LICENSE_FILE** - the full path to the Affdex license file (including the license file name)
+* The AffdexMe app can be built and run in either debug or release mode.
+
+ **To build and run in Debug Mode**
+
+ * Through Visual Studio select the "Debug" configuration.
+
+ * Add the following to your system path: C:\Program Files (x86)\Affectiva\Affdex SDK\bin\debug
+
+ * Clean, rebuild and then run the project.
+
+ **To build and run in Release Mode:**
+
+ * Through Visual Studio select the "Debug" configuration.
+
+ * Add the following to your system path: C:\Program Files (x86)\Affectiva\Affdex SDK\bin\release
+
+ * Clean, rebuild and then run the project.
+
+ **It is important** not to mix Release and Debug versions of the DLLs. If you run into issues when switching between the two different build types, check to make sure that your system path points to the matching build type.
+
+* In order to modify the system path, from the Control Panel, navigiate to the following: **Control Panel -> Advanced System Settings -> Environment Variables -> System Variables -> Path**
+
+* Build the project
+
+* Run the app through Visual Studio
+
+Copyright (c) 2015 Affectiva. All rights reserved.
diff --git a/AffdexMe/Resources/AffdexMe_Logo.ico b/AffdexMe/Resources/AffdexMe_Logo.ico
new file mode 100644
index 0000000..c8d8a83
Binary files /dev/null and b/AffdexMe/Resources/AffdexMe_Logo.ico differ
diff --git a/AffdexMe/Resources/AffectivaLogo1.png b/AffdexMe/Resources/AffectivaLogo1.png
new file mode 100644
index 0000000..831ef03
Binary files /dev/null and b/AffdexMe/Resources/AffectivaLogo1.png differ
diff --git a/affdex-win-samples.sln b/affdex-win-samples.sln
index a394f84..6b925f4 100644
--- a/affdex-win-samples.sln
+++ b/affdex-win-samples.sln
@@ -1,10 +1,12 @@
Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Express 2013 for Windows Desktop
-VisualStudioVersion = 12.0.30723.0
+# Visual Studio 2013
+VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opencv-webcam-demo", "opencv-webcam-demo\opencv-webcam-demo.vcxproj", "{8DCDC209-C25D-4C61-B2AC-2FBA1775DD6B}"
EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AffdexMe", "AffdexMe\AffdexMe.csproj", "{5B893EA1-EB11-425A-BF8A-05822F5E2C9A}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Release|Win32 = Release|Win32
@@ -12,6 +14,7 @@ Global
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8DCDC209-C25D-4C61-B2AC-2FBA1775DD6B}.Release|Win32.ActiveCfg = Release|Win32
{8DCDC209-C25D-4C61-B2AC-2FBA1775DD6B}.Release|Win32.Build.0 = Release|Win32
+ {5B893EA1-EB11-425A-BF8A-05822F5E2C9A}.Release|Win32.ActiveCfg = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE