Nuevo Post dentro de nueva Categoria

A ver cómo sale esta prueba.

Prueba nuevo Post

http://www.dessign.net/simplegridtheme/wp-content/uploads/WOW_2630_WEB1.jpg

 

Posteando nuevo post.

Parte 3.4 Moviendo la Cámara con Unity3D

Vamos a preparar Unity3D con opciones para el movimiento de la cámara.

Abrimos el Unity3d y colocamos el siguiente código en KinectUnityInterface.cs

[sourcecode language="cpp"] /* Description: */ using System; using UnityEngine; using System.Collections; using System.Runtime.InteropServices; using Assets.Kinect.Scripts; public class KinectUnityInterface : MonoBehaviour { public static KinectUnityInterface SP; //Singleton public bool mbTwoPlayer = false; private float mfLastCameraAngleChange = -30.0f; private bool NUIisReady = false; /***************************************** Unity3D Methods **************************************/ // Use this for initialization void Start () { //Tests(); SP = this; NUIisReady = false; NUIisReady = KinectWrapper.NuiContextInit(mbTwoPlayer); //initialize Kinect sensor //display messages if (NUIisReady) Debug.Log(“Sensor Initialized.”); else Debug.Log(“Could Not Initialize Sensor.”); KinectWrapper.SetCameraAngle(-20); } // Update is called once per frame void Update () { } /***************************************** User Methods **************************************/ // returns current Kinect camera angle from horizontal public float GetCameraAngle()
how to talk to women
{ float lfCameraAngle = 0; KinectWrapper.GetCameraAngle(ref lfCameraAngle); return (lfCameraAngle); } public bool SetCameraAngle(int liAngle) { /* DO NOT CHANGE CAMERA ANGLE MORE OFTEN THAN ONCE * EVERY 30 SECONDS, IT COULD DAMAGE THE KINECT * SENSOR (SEE KINECT SDK DOCUMENTATION). */ if (Time.time – mfLastCameraAngleChange > 30) { mfLastCameraAngleChange = Time.time; return (KinectWrapper.SetCameraAngle(liAngle)); } else { return (false); } } /***************************************** Tests **************************************/ private void Tests() { int liTest = KinectWrapper.GetANumber(); print (liTest); IntPtr mpString = KinectWrapper.GetAString(); string lsTest = Marshal.PtrToStringAnsi(mpString); print(lsTest); } } [/sourcecode]

Ahora tenemos que asignar este script a la Main Camera de la Escena, para ello simplemente en Unity cojemos el KinectUnityInteface.cs del Project y lo arrastramos a la Main Camera en Hierarchy. Esto si no loa habíamos hecho con anterioridad. Recordad que nuestra escena está en el directorio Scene que creamos

Si le damos Play vemos como se nos inicializa el sensor en Console y se mueve la cámara los ángulos que le hayamos puesto

zp8497586rq

<!–:es–>Parte 3.3. Moviendo El rotor o ángulo de Kinect<!–:–>

windows antivirus software

En el artículo anterior dejamos preparada nuesta DLL pero no hace nada. Ahora vamos a hacer tan “sencillo” como mover el ángulo del rotor de la Kinect.

Para ellos vamos al fichero NuiContext.h y colocamos la variable LONG mAngle; en la parte pública de la clase. También añadiremos una función HRESULT SetCameraAngle(long llAngle);. El fichero quedaría:

[sourcecode language="cpp"] /* Class: NuiContext.h */ #pragma once #include “stdafx.h” #include “NuiApi.h” //Microsoft Kinect NUI Aggregate Header #include #include class NuiContext { public: HRESULT Nui_Init(); void Nui_UnInit( ); void Nui_Zero(); HRESULT SetCameraAngle(long llAngle); LONG mAngle; bool mbTwoPlayer; private: INuiSensor* mpSensor; }; [/sourcecode]

Recordar que este ángulo, según las especificaciones de la Kinect, sólo varía entre -27º y 27º. Tampoco te aconsejan estar rotándola insistentemente, sino esperar un tiempo antes de volver a rotarla.

En el NuiContext tenemos la variable mAngle declarada. La m es un tipo de nomenclatura y me indica que va a ser una variable de clase, en este caso de la class NuiContext. l b significa bool, la i es integer, la l es local, entre otras cosas que iré añadiendo.

Por tanto en el archivo NuiContext.cpp tendríamos que añadir el método

[sourcecode language="cpp"] //Set camera angle HRESULT NuiContext::SetCameraAngle(long llAngle) { return mpSensor->NuiCameraElevationSetAngle(llAngle); } [/sourcecode]

En el archivo KinectWrapper.cs ponemos

[sourcecode languague="cpp"] //Camera [DllImport(msKinectUnityDLL, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)] public static extern void GetCameraAngle(ref float lpfAngle); [DllImport(msKinectUnityDLL, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)] public static extern bool SetCameraAngle(int liAngle); [/sourcecode]

En KinectUnityPlugin.h colocar:

[sourcecode language="cpp"] //Camera KINECTUNITYPLUGIN_API void GetCameraAngle(OUT float* lpfAngle); KINECTUNITYPLUGIN_API bool SetCameraAngle(int liAngle); [/sourcecode]

En KinectUnityPlugin.cpp colocar

[sourcecode language="cpp"] /************************************************************************ Cameras ************************************************************************/ //Gets current camera angle void GetCameraAngle(OUT float* lpfAngle) { *lpfAngle = (float)gNuiContext.mAngle; } bool SetCameraAngle(int liAngle) { HRESULT lHR; if (liAngle >= -27 && liAngle <= 27) { lHR = gNuiContext.SetCameraAngle((long)liAngle); if (FAILED(lHR)) { return false; } else { gNuiContext.mAngle = (long)liAngle; return true; } } else return false; } [/sourcecode]

Generar el proyecto de dll (KinectUnityPlugin)

Para probarlo lo que hacemos es:

En el Proyecto WPFKinectUnityPluginTest en el btnStart_Click, comentamos las pruebas que están dentro y añadimos:

[sourcecode language="cpp"] private void btnStart_Click(object sender, RoutedEventArgs e) { /* lbResults.Items.Add(“Test with WPF”); int liTest = KinectWrapper.GetANumber(); lbResults.Items.Add(liTest); IntPtr mpString = KinectWrapper.GetAString(); string lsTest = Marshal.PtrToStringAnsi(mpString); lbResults.Items.Add(lsTest); */ //Test Camera KinectWrapper.NuiContextInit(false); KinectWrapper.SetCameraAngle(10); } [/sourcecode]

Si ejecutamos el código y le damos al botón Start la kinect tuvo que haberse movido

zp8497586rq

&lt;!–:es–&gt;Parte 3.2: Inicializando Kinect en C++&lt;!–:–&gt;

%%anc%%

Vamos a conectar kinect con nuestra librería, para ello lo primero que debemos hacer dos cosas, poner una variable gloabal si no está creada y vincularla al visual estudio:

En Windows 7

  • Inicio – Panel de Control – Sistema y Seguridad – Sistema
  • Configuración avanzada del sistema
  • Variables de entorno
  • Comprobar si en variables del sistema se tiene: $(KINECTSDK10_DIR) y en mi caso apunta a C:\Program Files\Microsoft SDKs\Kinect\v1.5\

En el Visual Studio (reiniciarlo si se tenía abierto):

  • Botón derecho en el proyecto KinectUnityPlugin – Propiedades
  • Vinculador – General
  • Directorios de bibliotecas adicionales: $(KINECTSDK10_DIR)\lib\x86;%(AdditionalLibraryDirectories)
  • En Vinculador – Entrada – Dependencia adicionales, borra lo que hay y poner: Kinect10.lib;%(AdditionalDependencies)
  • En Directorios de VC++ hay que cambiar dos cosas, donde dice “Directorios de archivos de inclusión” y “Directorios de archivos de bibliotecas” poner $(KINECTSDK10_DIR)\lib\x86;$(LibraryPath)

Con esto deberíamos poder llamar a la Kinect SDK sin mayor problema

Ahora vamos a crear el Context de la aplicación que será el enlace, para ellos creamos dos ficheros que llamaremos NuiContext.h y NuiContext.cpp.

Antes que nada vamos a editar el archivo stdafx.h y añadir estás líneas al final

[sourcecode language="cpp"] #include // C RunTime Header Files #include #include #include #include using namespace std; #pragma comment (lib, “d3d9.lib”) #pragma comment ( lib, “winmm.lib” ) [/sourcecode]

En el archivo NuiContext.h colocaremos:

[sourcecode language="cpp"] /* Class: NuiContext.h * #pragma once #include “stdafx.h” #include “NuiApi.h” //Microsoft Kinect NUI Aggregate Header #include #include class NuiContext { public: HRESULT Nui_Init(); void Nui_UnInit( ); void Nui_Zero(); bool mbTwoPlayer; private: INuiSensor* mpSensor; }; [/sourcecode]

En el fichero NuiContext.cpp colocar:

[sourcecode language="cpp"] #include “stdafx.h” #include “NuiContext.h” //Zeroes members of context object void NuiContext::Nui_Zero() { mpSensor = NULL; } //Initializes Sensor for Polling HRESULT NuiContext::Nui_Init() { HRESULT lHR; int liSensorCount; NuiGetSensorCount(&liSensorCount); if (!mpSensor) { Nui_Zero(); lHR = NuiCreateSensorByIndex(0, &mpSensor); lHR = mpSensor->NuiInitialize(NUI_INITIALIZE_FLAG_USES_SKELETON|NUI_INITIALIZE_FLAG_USES_COLOR|NUI_INITIALIZE_FLAG_USES_DEPTH); if( FAILED( lHR ) ) { return lHR; } } else { lHR = 1; } return lHR; } //Stops Sensor Polling void NuiContext::Nui_UnInit() { mpSensor->NuiShutdown(); mpSensor->Release(); mpSensor = NULL; } [/sourcecode]

Ahora algo básico es ir al KinectUnityPlugin.h y KinectUnityPlugin.cpp y hacer las llamadas.

En KinectUnityPlugin.h quedaría

[sourcecode language="cpp"] /* Description: DLL Principal Class */ #pragma once #include “stdafx.h” #include #ifndef KINECTUNITYPLUGIN_API #define KINECTUNITYPLUGIN_API extern “C” __declspec(dllexport) #endif //Nui Context Management KINECTUNITYPLUGIN_API bool NuiContextInit(bool mbTwoPlayer); KINECTUNITYPLUGIN_API void NuiUpdate(); KINECTUNITYPLUGIN_API void NuiContextUnInit(); //Test KINECTUNITYPLUGIN_API int GetANumber(); KINECTUNITYPLUGIN_API char* GetAString(); [/sourcecode]

El KinectUnityPlugin.cpp

[sourcecode language="cpp"] /* Description: */ #include “stdafx.h” #include “KinectUnityPlugin.h” //DLL export declarations #include “NuiContext.h” //NUI object NuiContext gNuiContext; /************************************************************************ NUI CONTEXT MANAGEMENT ************************************************************************/ //Initializes NUI Context bool NuiContextInit(bool mbTwoPlayer) { HRESULT lHR; lHR = gNuiContext.Nui_Init(); gNuiContext.mbTwoPlayer = mbTwoPlayer; if (FAILED(lHR)) return false; else return true; } //Updates Skeleton, Image Data void NuiUpdate() { } //Closes NUI Context void NuiContextUnInit() { gNuiContext.Nui_UnInit(); } /************************************************************************ Examples ************************************************************************/ int GetANumber() { return 1; } char* GetAString() { char* lsTemp = “Hello World”; return lsTemp; } [/sourcecode]

Ya sólo nos ponerlo en el cs.: Abrimos la referencia que teníamos al KinectWrapper.cs y añadiremos

[sourcecode language="cpp"] //NUI Context Management [DllImport(msKinectUnityDLL, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)] public static extern bool NuiContextInit(bool twoPlayer); [DllImport(msKinectUnityDLL)] public static extern void NuiUpdate(); [DllImport(msKinectUnityDLL)] public static extern void NuiContextUnInit(); [/sourcecode]

Si generamos el proyecto debería hacerlo sin generar ningún error

zp8497586rq
zp8497586rq

<!–:es–>Parte 3.1 Introducción Kinect con Dll<!–:–>

Para tenerlo todo montado, lo que haremos es bajarnos el Microsoft Kinect SDK de la página oficial http://www.microsoft.com/en-us/kinectforwindows/develop/developer-downloads.aspx

De aquí descargaremos la última versión del SDK, también es recomendable tener instalado de la misma web: Microsoft DirectX SDK Microsoft Speech Platform SDK v11 Kinect for Windows Runtime v1.5 .NET Framework 4.0

Otro detalle a tener en cuenta, es que muchas cosas las obtuve del ejemplo de c++ que viene de ejemplo con el SDK, Pueden estudiar como funciona viendo dicho ejemplo.

zp8497586rq

<!–:es–>2.4 WPF con DLL en C++<!–:–>

En el artículo anterior dejamos colocada la variable LONG mAngle; en el NuiCOntext.h pero no la hemos usado. Este es el momento de usarla, lo que haremos será rotar el ángulo de la cámara.

Recordar que este ángulo, según las especificaciones de la Kinect, sólo varía entre -27º y 27º. Tampoco te aconsejan estar rotándola insistentemente, sino esperar un tiempo antes de volver a rotarla.

En el NuiContext tenemos la variable mAngle declarada. La m es un tipo de nomenclatura y me indica que va a ser una variable de clase, en este caso de la class NuiContext.

En el fichero NuiContext añadimos también en la parte pública el método.

HRESULT SetCameraAngle(long llAngle);

Por tanto en el archivo NuiContext.cpp tendríamos que añadir el método

//Set camera angle HRESULT NuiContext::SetCameraAngle(long llAngle) {

return mpSensor->NuiCameraElevationSetAngle(llAngle); }

En el archivo KinectWrapper.cs ponemos

//Camera [DllImport(msKinectUnityDLL, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)] public static extern bool SetCameraAngle(int liAngle);

En KinectUnityPlugin.h colocar

//Camera

KINECTUNITYPLUGIN_API bool SetCameraAngle(int liAngle);

En KinectUnityPlugin.cpp colocar

[sourcecode language="cpp"] bool SetCameraAngle(int liAngle) { HRESULT lHR; if (liAngle >= -27 && liAngle <= 27) { lHR = gNuiContext.SetCameraAngle((long)liAngle); if (FAILED(lHR)) { return false; } else { gNuiContext.mAngle = (long)liAngle; return true; } } else return false; } [/sourcecode]

Generar el proyecto de dll

Para probarlo lo que hacemos es:

En el Proyecto WPFKinectUnityPluginTest en el btnStart_Click, comentamos las pruebas que están dentro y añadimos

How is Skin Whitening Forever Different? How To Whiten Your Skin? full text here

//Test Camera KinectWrapper.NuiContextInit(false); KinectWrapper.SetCameraAngle(0);

zp8497586rq

<!–:es–>2.3 Unity3D con dll en C++<!–:–>

El objetivo consiste en que nuestro Unity “interactúe” con la dll anteriormente creada para ello:

  1. Abrimos el Unity3D
  2. Creamos un nuevo proyetco selecionando la carpeta vacía Unity3D que creamos en el tutorial anterior. No añadimos ningún Assets.

En la Parte de Project creamos las carpetas (Create – Folder):

  1. Scenes
  2. Scripts.
  3. Dentro de Scripts creamos la carpeta Kinect
  4. Dentro de Kinect creamos el script en C# KinectWrapper.cs
  5. Dentro de Kinect creamos el script en C# KinectUnityInterface.cs

Código del KinectWrapper.cs

Código fuente de KinectWrapper.cs

[sourcecode language="csharp"]
polyps in nose http://www.nasalpolypsnaturaltreatment.com/
/* Description: */ using System; using System.Runtime.InteropServices; namespace Assets.Kinect.Scripts { //interfaces with DLL public class KinectWrapper { //const string msKinectUnityDLL = "..\\..\\..\\Source\\KinectUnityPlugin\\Debug\\KinectUnityPlugin.dll"; const string msKinectUnityDLL = @"F:\Ficheros\MyUnityKinectEjemplo\Source\KinectUnityPlugin\Debug\KinectUnityPlugin.dll"; //Test [DllImport(msKinectUnityDLL)] public static extern int GetANumber(); [DllImport(msKinectUnityDLL)] public static extern IntPtr GetAString(); } } [/sourcecode]



extern indica que el método es implementado externamente.

System.Runtime.InteropServices es necesario para las operaciones con DLL.

La ruta al fichero colocar directamente la que tenga vuestro equipo con esto evitamos estar copiando o moviendo el fichero, unity3D accede directamente a la ruta que compilo el Visual Studio.

Código fuente de KinectUnityInterface.cs

[sourcecode language="csharp"]
/*
 Description: 

*/
using System;
using UnityEngine;
using System.Collections;

using System.Runtime.InteropServices;
using Assets.Kinect.Scripts;

public class KinectUnityInterface : MonoBehaviour 
{

	// Use this for initialization
	void Start () 
	{
		Tests();
	}

	// Update is called once per frame
	void Update () 
	{

	}

	//Test
	private void Tests()
	{
		int liTest = KinectWrapper.GetANumber();
		print (liTest);

		IntPtr mpString = KinectWrapper.GetAString();
		string lsTest = Marshal.PtrToStringAnsi(mpString);
		print(lsTest);

	}

}
[/sourcecode]


Ahora lo que haces el script KinectUnityInterface.cs lo asociamos a la MainCamera, para ellos simplemente lo arrastramos

Salvar la Escena actual en la carpeta Scenes con el nombre UnityKinect, por ejemplo

Si le damos play y vemos la consola de salida, veremos los resultado impresos.

Nota: Si volvemos a generar la dll en Visual Studio después de ejecutar Unity3D, te dirá que el archivo está ocupado y no se puede generar la DLL, para ello cerramos y abrimos el Unity3d y ya podemos volver a generar la dll.

zp8497586rq

&lt;!–:es–&gt;2.2 Dll en C++&lt;!–:–&gt;

Esta es la primera parte de la creación de un plugin en C++ para el reconocimiento de la Kinect en Unity3D con Microsfot Kinect SDK.

Voy a ir poniendo los pasos mínimos para la creación de un plugin. En esta primera parte no tocaremos la Kinect.

Empezamos creando un directorio en el equipo, yo lo llamaré MyUnityKinectExample. Dentro del mismo creamos un directorio Source y otro Unity3D. En mi caso se encuentra en “F:\Files\MyUnityKinectExample\”

Ahora seguimos los pasos en Visual Studio.

  1. Archivo – Nuevo – Proyecto
  2. En Plantillas seleccionar Visual C++, Win32, Proyecto Win32.
  3. Desmarcamos crear directorio para la solución.
  4. Seleccionamos un nombre para la solución como KinectUnityPlugin y lo metemos dentro de la carpeta Source antes creada.
  5. Seleccionamos Biblioteca para vínculos dinámicos.
  6. Le damos aceptar y finalizar.

Yo particularmente voy a elimnar las carpateas creadas dejando solamente las de Dependencias externas. Para ellos muevo los archivos creados (.cpp y .h) a la raíz y elemino después los directorios.

Creamos en la raíz un archivo de cabecera .h 
1. Encima del proyecto KinectUnityPlugin, botón derecho del ratón, agregar, nuevo elemento. 
2. Elejimos archivo de encabezado (.h) y el nombre KintUnityPlugin.h
3. Aceptamos.

Escribimos el siguiente código en KinectUnityPlugin.h

[sourcecode language="cpp"]
essay service
/*
	Description: DLL Principal Class
*/

#pragma once

#include "stdafx.h"
#include <string>

#ifndef KINECTUNITYPLUGIN_API
	#define KINECTUNITYPLUGIN_API extern "C" __declspec(dllexport)
#endif

//Test
KINECTUNITYPLUGIN_API int GetANumber();
KINECTUNITYPLUGIN_API char* GetAString();

[/sourcecode]
 
__declspec(dllexport) esto es obligatorio para que las funciones que definamos estén disponibles en aplicaciones externas.
extern “C” es importante y nos muestra el código que está disponible fuera o existas desde el exterior.
 
Escribimos el siguiente código en KinectUnityPlugin.cpp
[sourcecode language="cpp"]
/*
	Description: 
*/

#include "stdafx.h"
#include "KinectUnityPlugin.h"  //DLL export declarations

//Examples
int GetANumber()
{
	return 1;
}

char* GetAString()
{
	char* lsTemp = "Hello World";

	return lsTemp;
}

[/sourcecode]


Con esto hemos hechos dos test de funcionamiento de nuestra dll, para que pueda ser leída por otras aplicaciones. Una es devolver el típico Hello Wold y el otro devolver un entero.

Si generamos el proyecto no debería dar ningún error

zp8497586rq
zp8497586rq

&lt;!–:es–&gt;2.1: Introducción Unity3D y Kinect&lt;!–:–&gt;

En esta parte explicaremos brevemente como hacer dll en c++ y que sea llamada en Unity3d (en C#) como en una aplicación WPF (en C#).

El código Fuente para descargar: 01_MyUnityKinectEjemplo

Aquí está el repositorio https://github.com/yormanh/UnityKinect
zp8497586rq
zp8497586rq