public static void Main()
{
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
// Set up our listener:
SampleListener listener = new SampleListener();
controller.Connect += listener.OnServiceConnect;
controller.Disconnect += listener.OnServiceDisconnect;
controller.FrameReady += listener.OnFrame;
controller.Device += listener.OnConnect;
controller.DeviceLost += listener.OnDisconnect;
controller.DeviceFailure += listener.OnDeviceFailure;
controller.LogMessage += listener.OnLogMessage;
ArduinoControllerMain controller = new ArduinoControllerMain();
controller.SetComPort();
for (int i = 0; i < 50; i++)
{
Console.WriteLine(SampleListener.data);
controller.SendArduino(16, 129, 6, 140, 4, 30);
controller.SendArduino(16, 127, 13, 255, 4, 30);
controller.SendArduino(16, 127, 13, 0, 4, 30);
}
controller.ClosePort();
// Keep this process running until Enter is pressed
Console.WriteLine("Press any key to quit...");
Console.ReadLine();
}
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
//if (IsInDesignMode)
//{
// // Code runs in Blend --> create design time data.
//}
//else
//{
// // Code runs "for real"
//}
mainModel = new MainModel();
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
// Set up our listener:
ListenerClass listener = new ListenerClass();
controller.Connect += listener.OnServiceConnect;
controller.Disconnect += listener.OnServiceDisconnect;
controller.FrameReady += OnFrame;
controller.Device += OnConnect;
controller.DeviceLost += OnDisconnect;
controller.DeviceFailure += listener.OnDeviceFailure;
controller.LogMessage += listener.OnLogMessage;
}
}
public static void Main()
{
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
// Set up our listener:
SampleListener listener = new SampleListener();
controller.Connect += listener.OnServiceConnect;
controller.Disconnect += listener.OnServiceDisconnect;
controller.FrameReady += listener.OnFrame;
controller.Device += listener.OnConnect;
controller.DeviceLost += listener.OnDisconnect;
controller.DeviceFailure += listener.OnDeviceFailure;
controller.LogMessage += listener.OnLogMessage;
ArduinoControllerMain ArduinoController = new ArduinoControllerMain();
ArduinoController.SetComPort();
while (true)
{
// Console.WriteLine(listener.GetHandData());
// ArduinoController.SendArduino(16, 129, 6, Convert.ToByte(listener.GetHandData().GetX()), 4, 30);
// ArduinoController.SendArduino(16, 127, 13, 255, 4, 30);
// ArduinoController.SendArduino(16, 127, 13, 0, 4, 30);
byte[] toArduino = listener.GetHandData().GetDataBytes();
ArduinoController.SendArduino(toArduino[0], toArduino[1], toArduino[2], toArduino[3], toArduino[4], toArduino[5], 50);
}
ArduinoController.ClosePort();
// Keep this process running until Enter is pressed
Console.WriteLine("Press any key to quit...");
Console.ReadLine();
}
}
public void OnInitialize(CommunicationService com, int interval)
{
OnRelease();
m_communication = com;
m_interval = interval;
m_timer = new Stopwatch();
m_timer.Start();
m_listener = new LeapListener(this);
m_controller = new Controller();
m_controller.SetPolicy(m_controller.PolicyFlags | Controller.PolicyFlag.POLICY_IMAGES | Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
m_controller.AddListener(m_listener);
}
/**
* Initializes the Leap Motion policy flags.
* The POLICY_OPTIMIZE_HMD flag improves tracking for head-mounted devices.
*/
void InitializeFlags()
{
//Optimize for top-down tracking if on head mounted display.
if (isHeadMounted)
{
leap_controller_.SetPolicy(Controller.PolicyFlag.POLICY_OPTIMIZE_HMD);
}
else
{
leap_controller_.ClearPolicy(Controller.PolicyFlag.POLICY_OPTIMIZE_HMD);
}
}
// Use this for initialization
void Start()
{
using (controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
// Set up our listener:
test = new MyListener();
controller.FrameReady += test.OnFrame;
}
click_flag = true;
click_str = "";
}
public MainWindow()
{
InitializeComponent();
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
Label[] l = new Label[] { label1, label2, label3 };
LeapListener listener = new LeapListener(l, Rects);
port = listener.port;
listener.InitLED(true);
controller.Device += listener.OnConnect;
controller.Disconnect += listener.OnDisconnect;
controller.FrameReady += listener.OnFrame;
}
}
public LeapMotionGestureControl()
{
// Set up listener and controller
listener = new LeapMotionGestureControlListener();
controller = new Controller();
// Allow background frames, otherwise.. well, it's useless
controller.SetPolicy(Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
// Watch for circles
controller.EnableGesture(Gesture.GestureType.TYPE_CIRCLE);
controller.EnableGesture(Gesture.GestureType.TYPE_KEY_TAP);
controller.EnableGesture(Gesture.GestureType.TYPE_SWIPE);
// Add on the listener
controller.AddListener(listener);
}
public override void OnConnect(Controller controller)
{
controller.SetPolicy(Controller.PolicyFlag.POLICY_IMAGES);
controller.EnableGesture(Gesture.GestureType.TYPE_SWIPE);
controller.EnableGesture(Gesture.GestureType.TYPE_CIRCLE);
controller.EnableGesture(Gesture.GestureType.TYPE_KEY_TAP);
controller.EnableGesture(Gesture.GestureType.TYPE_SCREEN_TAP);
controller.Config.SetFloat("Gesture.ScreenTap.MinForwardVelocity", 30.0f);
controller.Config.SetFloat("Gesture.ScreenTap.HistorySeconds", .5f);
controller.Config.SetFloat("Gesture.ScreenTap.MinDistance", 1.0f);
controller.Config.SetFloat("Gesture.Circle.MinRadius", 10.0f);
controller.Config.SetFloat("Gesture.Circle.MinArc", .5f);
controller.Config.SetFloat("Gesture.KeyTap.MinDownVelocity", 40.0f);
controller.Config.SetFloat("Gesture.KeyTap.HistorySeconds", .2f);
controller.Config.SetFloat("Gesture.KeyTap.MinDistance", 1.0f);
controller.Config.Save();
this.eventDelegate.LeapEventNotification("onConnect");
}
public static void Main()
{
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
// Set up our listener:
SampleListener listener = new SampleListener();
controller.Connect += listener.OnServiceConnect;
controller.Disconnect += listener.OnServiceDisconnect;
controller.FrameReady += listener.OnFrame;
controller.Device += listener.OnConnect;
controller.DeviceLost += listener.OnDisconnect;
controller.DeviceFailure += listener.OnDeviceFailure;
controller.LogMessage += listener.OnLogMessage;
// Keep this process running until Enter is pressed
Console.WriteLine("Press any key to quit...");
Console.ReadLine();
}
}
/// <summary>
/// Función que inicializa el listener del Arduino
/// </summary>
/// <param name="args">No arguments needed</param>
static void Main(string[] args)
{
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
// Iniciar el listener
LeapMotionListener listener = new LeapMotionListener();
controller.Connect += listener.OnServiceConnect;
controller.Disconnect += listener.OnServiceDisconnect;
controller.FrameReady += listener.OnFrame;
controller.Device += listener.OnConnect;
controller.DeviceLost += listener.OnDisconnect;
controller.DeviceFailure += listener.OnDeviceFailure;
controller.LogMessage += listener.OnLogMessage;
// Mantener el programa hasta que se pulse una tecla
Console.WriteLine(string.Format("Press any key to quit..."));
Console.ReadLine();
}
}
static void Main(string[] args)
{
using (Leap.IController controller = new Leap.Controller())
{
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_ALLOW_PAUSE_RESUME);
IPAddress ip;
int port;
bool useRightHand;
Console.WriteLine(string.Join("--", args));
if (args.Count() >= 3)
{
ip = IPAddress.Parse(args[0]);
port = int.Parse(args[1]);
useRightHand = bool.Parse(args[2]);
}
else
{
ip = IPAddress.Parse("127.0.0.1");
port = 8001;
useRightHand = true;
}
Console.WriteLine(string.Format("IP address is {0}, port is {1}, using {2} hand", ip, port, useRightHand ? "right" : "left"));
// Set up our listener:
QueueListener listener = new QueueListener(ip, port, useRightHand);
controller.Connect += listener.OnServiceConnect;
controller.Disconnect += listener.OnServiceDisconnect;
controller.FrameReady += listener.OnFrame;
controller.Device += listener.OnConnect;
controller.DeviceLost += listener.OnDisconnect;
controller.DeviceFailure += listener.OnDeviceFailure;
controller.LogMessage += listener.OnLogMessage;
// Keep this process running until Enter is pressed
Console.WriteLine("Press any key to quit...");
Console.ReadLine();
}
}
private void leapinit()
{
leapcontroller = new Controller();
leapcontroller.StopConnection();
Controller.PolicyFlag flags = Controller.PolicyFlag.POLICY_DEFAULT | Controller.PolicyFlag.POLICY_IMAGES;
if (FBckgFrames[0])
{
flags = flags | Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES;
}
if (FHMD[0])
{
flags = flags | Controller.PolicyFlag.POLICY_OPTIMIZE_HMD;
}
leapcontroller.SetPolicy(flags);
leapcontroller.StartConnection();
try
{
leapdevice = leapcontroller.Devices[0];
}
catch (Exception e) { }
}
public static void Main()
{
// Create a sample listener and controller
SampleListener listener = new SampleListener();
Controller controller = new Controller();
controller.SetPolicy(Leap.Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
// Have the sample listener receive events from the controller
controller.AddListener(listener);
//creating socket
// UdpClient sendingClient = new UdpClient();
//sendingClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
//sendingClient.Connect("localhost", 4200);
//Socket sending_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
// IPAddress send_to_address = IPAddress.Parse("127.0.0.1");//localhost, for broadcast use ("192.168.2.255");
// IPEndPoint sending_end_point = new IPEndPoint(send_to_address, 4200);
/*
while(true)
{
// String text_to_send = "VR_TRACKER_SENSOR_0 42 24 66 0 0 0 0 0 0 1 2 3 4";
//byte[] send_buffer = Encoding.ASCII.GetBytes(text_to_send);
//Console.WriteLine("sending to address: {0} port: {1}", sending_end_point.Address, sending_end_point.Port);
try
{
//sending_socket.SendTo(send_buffer, sending_end_point);
//sendingClient.Send(send_buffer, send_buffer.Length, sending_end_point);
}
catch (Exception send_exception)
{
//exception_thrown = true;
Console.WriteLine(" Exception {0}", send_exception.Message);
}
Console.ReadLine();
//System.Threading.Thread.Sleep(1000);
}
*/
// Keep this process running until Enter is pressed
Console.WriteLine("Press Enter to quit...");
Console.ReadLine();
// Remove the sample listener when done
controller.RemoveListener(listener);
controller.Dispose();
}
private void Window_Loaded( object sender, RoutedEventArgs e )
{
leap = new Controller();
leap.SetPolicy( Controller.PolicyFlag.POLICY_IMAGES );
CompositionTarget.Rendering += CompositionTarget_Rendering;
}
public MainWindow()
{
InitializeComponent();
this.controller = new Controller();
this.listener = new LeapEventListener(this);
controller.AddListener(listener);
controller.SetPolicy(Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
}
public override void OnConnect(Controller controller)
{
controller.SetPolicy(Controller.PolicyFlag.POLICY_IMAGES);
controller.EnableGesture(Gesture.GestureType.TYPE_SWIPE);
this.eventDelegate.LeapEventNotification("onConnect");
}
void Start ()
{
if (handController == null) {
Debug.LogWarning ("Cannot use LeapImageRetriever if there is no HandController!");
enabled = false;
return;
}
_controller = handController.GetLeapController ();
_controller.SetPolicy (Controller.PolicyFlag.POLICY_IMAGES);
}
void Start()
{
if (HandController.Main == null) {
Debug.LogWarning("Could not find Main Hand Controller. Cannot use LeapImageRetriever if there is no Main Hand Controller!");
enabled = false;
return;
}
float gamma = 1f;
if (QualitySettings.activeColorSpace != ColorSpace.Linear) {
gamma = -Mathf.Log10(Mathf.GammaToLinearSpace(0.1f));
}
Shader.SetGlobalFloat("_LeapGlobalColorSpaceGamma", gamma);
_eyeTextureData[0] = new EyeTextureData();
_eyeTextureData[1] = new EyeTextureData();
_cachedCamera = GetComponent<Camera>();
_controller = HandController.Main.GetLeapController();
_controller.SetPolicy(Controller.PolicyFlag.POLICY_IMAGES);
}
public MainWindow()
{
InitializeComponent();
this.controller = new Controller();
this.listener = new LeapEventListener(this);
this.iBox = controller.Frame().InteractionBox;
controller.AddListener(listener);
controller.SetPolicy(Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
Console.WriteLine("hi");
}
/// <summary>
/// Starts the controller.
/// </summary>
/// <param name="onFrameArrived">On frame arrived.</param>
public void StartController(Action<Frame> onFrameArrived)
{
_listener = new FrameListener(onFrameArrived);
_leapController = new Controller(_listener);
_leapController.SetPolicy(Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
}
private void leapinit()
{
leapcontroller = new Controller();
Controller.PolicyFlag flags = Controller.PolicyFlag.POLICY_DEFAULT;
if (FBckgFrames[0]) flags = flags | Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES;
if (FHMD[0]) flags = flags | Controller.PolicyFlag.POLICY_OPTIMIZE_HMD;
leapcontroller.SetPolicy(flags);
leapdevice = leapcontroller.Devices[0];
}
public override void OnConnect(Controller controller)
{
controller.SetPolicy(Controller.PolicyFlag.POLICY_IMAGES);
controller.EnableGesture(Gesture.GestureType.TYPE_SWIPE);
controller.EnableGesture(Gesture.GestureType.TYPE_CIRCLE);
controller.EnableGesture(Gesture.GestureType.TYPE_SCREEN_TAP);
controller.Config.SetFloat("Gesture.Swipe.minVelocity", 750f);
this.eventDelegate.LeapEventNotification("onConnect");
}
static void Init()
{
var count = 0;
var start = System.DateTime.Now;
var con = new Controller(new FrameListener(x =>
{
count++;
Console.SetCursorPosition(0, Console.CursorTop);
Console.Write("Frames: " + count);
var cur = System.DateTime.Now - start;
Console.Write(" | FPS: " + (count / cur.TotalSeconds));
OnFrameArrived(x);
}));
con.SetPolicy(Controller.PolicyFlag.POLICY_BACKGROUND_FRAMES);
}
