public KinectController()
{
this.QueryPrimaryUserCallback = this.OnQueryPrimaryUserCallback;
this.PreEngagementUserColors = new Dictionary <int, Color>();
this.PostEngagementUserColors = new Dictionary <int, Color>();
this.engagementStateManager.TrackedUsersChanged += this.OnEngagementManagerTrackedUsersChanged;
this.engagementStateManager.CandidateUserChanged += this.OnEngagementManagerCandidateUserChanged;
this.engagementStateManager.EngagedUserChanged += this.OnEngagementManagerEngagedUserChanged;
this.engagementStateManager.PrimaryUserChanged += this.OnEngagementManagerPrimaryUserChanged;
this.handoffConfirmationStasisTimer.Tick += this.OnHandoffConfirmationStasisTimerTick;
this.disengagementNavigationTimer.Tick += this.OnDisengagementNavigationTick;
this.shutdownCommand = new RelayCommand(this.Cleanup);
this.engagementConfirmationCommand = new RelayCommand <RoutedEventArgs>(this.OnEngagementConfirmation);
this.engagementHandoffConfirmationCommand = new RelayCommand <RoutedEventArgs>(this.OnEngagementHandoffConfirmation);
if (KinectDeviceInstance.SensorChooser == null)
{
KinectDeviceInstance.SensorChooser = new KinectSensorChooser();
KinectDeviceInstance.SensorChooser.KinectChanged += this.SensorChooserOnKinectChanged;
KinectDeviceInstance.SensorChooser.Start();
}
sensorChooser = KinectDeviceInstance.SensorChooser;
}
public MainJogo()
{
InitializeComponent();
if (!IsInDesignMode)
{
// initialize the sensor chooser and UI
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
// Bind the sensor chooser's current sensor to the KinectRegion
var regionSensorBinding = new Binding("Kinect")
{
Source = this.sensorChooser
};
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
}
Loaded += (sender, e) =>
{
//var transparancyConverter = new TransparancyConverter(this);
//transparancyConverter.MakeTransparent();
};
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow"/> class.
/// </summary>
public MainWindow()
{
this.InitializeComponent();
// initialize the sensor chooser and UI
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
// Bind the sensor chooser's current sensor to the KinectRegion
var regionSensorBinding = new Binding("Kinect")
{
Source = this.sensorChooser
};
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
// Clear out placeholder content
this.wrapPanel.Children.Clear();
// Add in display content
for (var index = 0; index < 300; ++index)
{
var button = new KinectTileButton {
Label = (index + 1).ToString(CultureInfo.CurrentCulture)
};
this.wrapPanel.Children.Add(button);
}
// Bind listner to scrollviwer scroll position change, and check scroll viewer position
this.UpdatePagingButtonState();
scrollViewer.ScrollChanged += (o, e) => this.UpdatePagingButtonState();
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow"/> class.
/// </summary>
public MainWindow()
{
this.InitializeComponent();
// initialize the sensor chooser and UI
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
// Bind the sensor chooser's current sensor to the KinectRegion
var regionSensorBinding = new Binding("Kinect")
{
Source = this.sensorChooser
};
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
// Clear out placeholder content
//this.wrapPanel.Children.Clear();
// Add in display content
for (var index = 0; index < 300; ++index)
{
var button = new KinectTileButton {
Label = (index + 1).ToString(CultureInfo.CurrentCulture)
};
// this.wrapPanel.Children.Add(button);
}
// Bind listner to scrollviwer scroll position change, and check scroll viewer position
this.UpdatePagingButtonState();
scrollViewer.ScrollChanged += (o, e) => this.UpdatePagingButtonState();
// Inicialización de la detección de gestos.
sensor = KinectSensor.KinectSensors.Where(
s => s.Status == KinectStatus.Connected).FirstOrDefault();
if (sensor != null)
{
sensor.SkeletonStream.Enable();
sensor.SkeletonFrameReady += Sensor_SkeletonFrameReady;
_gestureR.GestureRecognized += Gesture_GestureRecognizedR;
_gestureL.GestureRecognized += Gesture_GestureRecognizedL;
//_gestureClapIn.GestureRecognized += Gesture_GestureRecognizedClapIn;
//_gestureClapOut.GestureRecognized += Gesture_GestureRecognizedClapOut;
_gestureSilenceIn.GestureRecognized += Gesture_GestureRecognizedSilenceIn;
_gestureSlideR.GestureRecognized += Gesture_GestureRecognizedSlideR;
sensor.Start();
}
// Reproductor de música.
player = new System.Media.SoundPlayer();
player.SoundLocation = "Media/vivaldi.wav";
player.Play();
isPlayerRunning = true;
}
public void Initialize(Action <KinectSensor> initializeResourcesMethod)
{
_initializeResourcesMethod = initializeResourcesMethod;
_kinectChooser = new KinectSensorChooser();
_kinectChooser.KinectChanged += KinectChooser_KinectChanged;
_kinectChooser.Start();
}
private void MainWindowLoaded(object sender, RoutedEventArgs e)
{
var sensorStatus = new KinectSensorChooser();
sensorStatus.KinectChanged += KinectSensorChooserKinectChanged;
kinectChooser.KinectSensorChooser = sensorStatus;
sensorStatus.Start();
}
public KinectChooser(KinectRegion kReg, KinectSensorChooserUI sensorChooserUi)
{
this.kReg = kReg;
sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
}
private void Form1_Load(object sender, EventArgs e)
{
var sensorStatus = new KinectSensorChooser();
sensorStatus.KinectChanged += KinectSensorChooserKinectChanged;
sensorStatus.Start();
}
// Constructor
public DragDropImages(int playerID, int gameMode)
{
InitializeComponent();
// Set screen to the center
WindowStartupLocation = WindowStartupLocation.CenterScreen;
// Kinect changed event listener
kinectSensorChooser = new KinectSensorChooser();
kinectSensorChooser.KinectChanged += KinectSensorChooser_KinectChanged;
// Set the player ID
this.playerID = playerID;
// Set the game mode
this.gameMode = gameMode;
// Reset the stopwatch
watch.Reset();
// Default value for the score, lives and time
currentScore = 0;
currentLives = 3;
currentTime = 0;
// Update the score, lives and time on screen
UpdateScoreLivesTime();
// Data binding
DataContext = this;
// Set up the font size and weight of score and lives
// Fontsize
score.FontSize = 22;
lives.FontSize = 22;
time.FontSize = 22;
// Fontweight
score.FontWeight = FontWeights.Bold;
lives.FontWeight = FontWeights.Bold;
time.FontWeight = FontWeights.Bold;
// Adjust the item width
itemWidth = imageWidth;
itemHeight = imageHeight;
// Get total item counts
totalItemCount = itemsRepository.GetCount();
itemGripped = new ItemGripped
{
GameMode = gameMode,
CurrentScore = currentScore,
CurrentLives = currentLives,
HandCursorOn = -1,
HandCursorOnSet = false,
};
}
public KinectManager()
{
sensorChooser = new KinectSensorChooser();
sensorManager = new KinectSensorManager();
KinectSensor sensor = new KinectSensor();
sensor.SkeletonFrameReady = null;
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
System.Media.SoundPlayer player = new System.Media.SoundPlayer(@"F:\Personal\Study\Assingment\PSM\E-SiLK\E-SiLK\Sound\bg.wav");
player.Play();
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
}
/// <summary>
/// Normal constructor : Detect and start the kinect
/// </summary>
/// <param name="game">Game linked to the captor</param>
public KinectCaptorV1(Game game)
{
gameHook = game;
KinectSensorChooser sensorStatus = new KinectSensorChooser();
sensorStatus.KinectChanged += KinectSensorChooserKinectChanged;
sensorStatus.Start();
}
public Game(KinectSensorChooser sensorChooser)
{
sensor = sensorChooser;
InitializeComponent();
sensorChooser.Kinect.SkeletonStream.Enable();
sensorChooser.Kinect.DepthStream.Enable();
sensorChooserUi.KinectSensorChooser = sensorChooser;
sensorChooser.Kinect.Start();
}
public MainWindow()
{
InitializeComponent();
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUI.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
}
public KinectDevice()
{
chooser = new KinectSensorChooser();
sensor = null;
oldSensor = null;
chooser.KinectChanged += OnSensorChanged;
chooser.PropertyChanged += OnStatusChanged;
chooser.Start();
}
private void Window_Loaded_1(object sender, RoutedEventArgs e)
{
Console.WriteLine("Main Windows Loading...");
//Kinect Event Handler Register
KinectSensor = new KinectSensorChooser();
KinectSensor.KinectChanged += KinectSensor_KinectChanged;
sensorChooserUI.KinectSensorChooser = KinectSensor;
KinectSensor.Start();
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
KinectSensorChooser sensorChooser = (KinectSensorChooser)this.Resources["sensorChooser"];
KinectState.Instance.KinectRegion = kinectRegion;
KinectState.Instance.PropertyChanged += KinectState_PropertyChanged;
sensorChooser.KinectChanged += KinectState.Instance.OnKinectChanged;
sensorChooser.Start();
}
private void Window_Loaded_1(object sender, RoutedEventArgs e)
{
/*comprueba si hay sensores*/
sKinect = new KinectSensorChooser();
/*comprueba el estado de la kinect*/
sKinect.KinectChanged += sKinect_KinectChanged;
/*muestra el estado de la conexion*/
sensorChooserUI.KinectSensorChooser = sKinect;
sKinect.Start();
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
// Color stream
//kinectSensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
//kinectSensor.ColorFrameReady += new EventHandler<ColorImageFrameReadyEventArgs>(kinectSensor_ColorFrameReady);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
MainCanvas.Height = System.Windows.SystemParameters.PrimaryScreenHeight;
MainCanvas.Width = System.Windows.SystemParameters.PrimaryScreenWidth;
mKinect = new KinectSensorChooser();
mKinect.KinectChanged += miKinect_KinectChanged; //detecta si un kinect se conecta o esta desconectado, etc... si lo desconectamos nos manda al evento
sensorChooserUI.KinectSensorChooser = mKinect;
mKinect.Start(); //inicializar el kinect
Log("Kinect Start");
}
private void OnWindowLoaded(object sender, RoutedEventArgs e)
{
IntializeTcpConnection();
_sensorManager = new KinectSensorManager();
_sensorManager.KinectSensorChanged += OnKinectSensorChanged;
_sensorChooser = new KinectSensorChooser();
_sensorChooser.KinectSensorChanged += OnKinectSensorChoosen;
_sensorChooser.PropertyChanged += OnKinectSensorChooserPropertyChanged;
_sensorChooser.Start();
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
if (DesignerProperties.GetIsInDesignMode(this))
{
return;
}
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUI.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
}
private void App_OnStartup(object sender, StartupEventArgs e)
{
var kinectSensorChooser = new KinectSensorChooser();
var kinectSensorManager = new KinectSensorManager();
var gesturesWithKeys = GesturesRegistry.CreateGesturesWithKeys();
var playerPreviewViewModel = new PlayerPreviewViewModel(kinectSensorChooser, kinectSensorManager);
var mainWindowViewModel = new MainViewModel(kinectSensorChooser, playerPreviewViewModel,
gesturesWithKeys, kinectSensorManager);
mainWindow = new MainWindow(mainWindowViewModel);
playerWindow = new PlayerPreviewWindow(playerPreviewViewModel)
{
Topmost = true,
WindowStyle = WindowStyle.None,
AllowsTransparency = true,
ShowInTaskbar = false,
};
imageWindow = new ImageWindow
{
Topmost = true,
WindowStyle = WindowStyle.None,
AllowsTransparency = true,
};
mainWindowViewModel.GestureRecognized += (_, args) =>
{
var imageSource = GetImageForGesture(args.GestureName);
if (imageSource == null)
{
return;
}
imageWindow.ShowImage(imageSource);
};
mainWindow.Closed += (_, __) =>
{
SaveConfig(gesturesWithKeys, playerPreviewViewModel);
imageWindow.Close();
playerWindow.Close();
};
mainWindow.Loaded += (_, __) => SetWindowsOnMainWindowScreen();
mainWindow.LocationChanged += (_, __) => SetWindowsOnMainWindowScreen();
LoadConfig(gesturesWithKeys, playerPreviewViewModel);
mainWindow.Show();
playerWindow.Show();
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow"/> class.
/// </summary>
public MainWindow()
{
this.InitializeComponent();
// initialize the sensor chooser and UI
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
// Bind the sensor chooser's current sensor to the KinectRegion
var regionSensorBinding = new Binding("Kinect")
{
Source = this.sensorChooser
};
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
// Clear out placeholder content
this.wrapPanel.Children.Clear();
// Add in display content
/*for (var index = 0; index < 300; ++index)
* {
* var button = new KinectTileButton { Label = (index + 1).ToString(CultureInfo.CurrentCulture) };
* this.wrapPanel.Children.Add(button);
* }*/
string[] Files = Directory.GetFiles("C:\\Borne_OTM", "*.*", SearchOption.AllDirectories);
foreach (string file in Files)
{
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.UriSource = new Uri(file, UriKind.Relative);
bi.EndInit();
var button = new KinectTileButton();
button.Height = 600;
button.Width = 400;
button.Background = new ImageBrush(bi);
this.wrapPanel.Children.Add(button);
}
// Bind listner to scrollviwer scroll position change, and check scroll viewer position
this.UpdatePagingButtonState();
scrollViewer.ScrollChanged += (o, e) => this.UpdatePagingButtonState();
}
static void Main(string[] args)
{
tc = new TcpClient("127.0.0.1", 14242);
tc.NoDelay = true;
sjw = new StreamWriter(tc.GetStream());
sjw.AutoFlush = true;
//Initialize Kinect
Console.WriteLine("Waiting for Kinect...");
KinectSensorChooser chooser = new KinectSensorChooser();
chooser.Start();
Console.WriteLine("Waiting for sensor");
while (chooser.Status != ChooserStatus.SensorStarted)
{
}
Console.WriteLine("Found and Started Kinect: " + chooser.Kinect.UniqueKinectId);
sensor = chooser.Kinect;
//Initialize speech recognition engine
RecognizerInfo ri = GetKinectRecognizer();
Console.WriteLine(ri.ToString());
sre = new SpeechRecognitionEngine(ri.Id);
sre.SpeechRecognized += SpeechRecognized;
sre.SpeechRecognitionRejected += SpeechRejected;
using (var memoryStream = new MemoryStream(Encoding.ASCII.GetBytes(File.ReadAllText("data\\SpeechGrammar2.xml"))))
{
var g = new Grammar(memoryStream);
sre.LoadGrammar(g);
}
sre.SetInputToAudioStream(sensor.AudioSource.Start(), new SpeechAudioFormatInfo(EncodingFormat.Pcm, 16000, 16, 1, 32000, 2, null));
sre.RecognizeAsync(RecognizeMode.Multiple);
while (!(Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape))
{
// do something
}
sre.RecognizeAsyncStop();
sre.Dispose();
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
this.sensorChooserUi.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
DispatcherTimer timer = new DispatcherTimer();
timer.Tick += new EventHandler(timer_Tick);
timer.Interval = new TimeSpan(0, 0, 0, 0, 50);
timer.Start();
}
public static void Init()
{
// First Load the XML File that contains the application configuration
_gestureMap = new GestureMap();
_gestureMap.LoadGesturesFromXml(GestureFileName);
_chooser = new KinectSensorChooser();
_chooser.KinectChanged += ChooserSensorChanged;
_chooser.Start();
// Instantiate the in memory representation of the gesture state for each player
_gestureMaps = new Dictionary <int, GestureMapState>();
}
public AboutICEI(KinectSensorChooser chooser)
{
InitializeComponent();
// initialize the sensor chooser and UI
sensorChooser = chooser;
var regionSensorBinding = new Binding("Kinect")
{
Source = this.sensorChooser
};
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
}
private void setupKinectSensor(ApplesGameConfig config = null)
{
this.sensorChooser = new KinectSensorChooser();
this.sensorChooser.KinectChanged += SensorChooserOnKinectChanged;
if (config == null)
{
this.sensorChooserUI.KinectSensorChooser = this.sensorChooser;
this.sensorChooser.Start();
var regionSensorBinding = new Binding("Kinect") { Source = this.sensorChooser };
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
}
else
{
this.sensorChooserUI.KinectSensorChooser = config.PassedKinectSensorChooser;
this.sensorChooser.Start();
var regionSensorBinding = new Binding("Kinect") { Source = config.PassedKinectSensorChooser };
BindingOperations.SetBinding(this.kinectRegion, KinectRegion.KinectSensorProperty, regionSensorBinding);
}
}
public MainWindow(BubblesGameConfig config)
{
InitializeComponent();
this.config = config;
this._sensorChooser = new KinectSensorChooser();
this._sensorChooser.KinectChanged += _sensorChooser_KinectChanged;
this.sensorChooserUi.KinectSensorChooser = this._sensorChooser;
this.config.PassedKinectSensorChooser = this._sensorChooser;
this._sensorChooser.Start();
}
//Manages establishing a connection to the Kinect Sensor
private void ManageSensor()
{
//An object which finds any connected Kinects (it's hard to not let those spellings overlap...)
//and selects one of them for the application. Once selected, it locks that Kinect to our process.
sensorChooser = new KinectSensorChooser();
sensorChooser.Start();
//An object which accesses the underlying data available from the Kinect, allowing us
// to specify particular settings we desire from it.
sensorManager = new KinectSensorManager();
sensorManager.KinectSensorChanged += this.KinectSensorChanged;
sensorManager.KinectSensor = sensorChooser.Kinect;
if(sensorManager.KinectSensor != null)
Console.WriteLine("*** Kinect Ready! ***");
}
