diff --git a/Makefile b/Makefile index 4c666529..36de4184 100644 --- a/Makefile +++ b/Makefile @@ -37,7 +37,8 @@ ALL_DRIVERS = \ Source/Drivers/DummyDevice \ Source/Drivers/PS1080 \ Source/Drivers/PSLink \ - Source/Drivers/OniFile + Source/Drivers/OniFile \ + Source/Drivers/Libfreenect2 # list all wrappers ALL_WRAPPERS = \ @@ -48,7 +49,7 @@ ALL_WRAPPERS = \ ALL_TOOLS = \ Source/Drivers/PS1080/PS1080Console \ Source/Drivers/PSLink/PSLinkConsole - + # list all core projects ALL_CORE_PROJS = \ $(XNLIB) \ @@ -152,7 +153,7 @@ $(FINAL_DIR): doc: Source/Documentation/Runme.py rm -f Source/Documentation/html/*.md5 - + release: | all doc $(FINAL_DIR) Packaging/Harvest.py Packaging/$(PRODUCT_STRING) $(PLATFORM) cd Packaging; tar -cjf Final/$(PRODUCT_STRING).tar.bz2 $(PRODUCT_STRING) diff --git a/Packaging/Harvest.py b/Packaging/Harvest.py index 4ce9ed26..0aa31309 100755 --- a/Packaging/Harvest.py +++ b/Packaging/Harvest.py @@ -92,6 +92,7 @@ def copyRedistFiles(self, targetDir): self.copySharedObject(binDriversDir, 'OniFile', targetDriversDir) self.copySharedObject(binDriversDir, 'PS1080', targetDriversDir) self.copySharedObject(binDriversDir, 'PSLink', targetDriversDir) + self.copySharedObject(binDriversDir, 'Libfreenect2', targetDriversDir) shutil.copy(os.path.join(self.rootDir, 'Config', 'OpenNI2', 'Drivers', 'PS1080.ini'), targetDriversDir) shutil.copy(os.path.join(self.rootDir, 'Config', 'OpenNI2', 'Drivers', 'PSLink.ini'), targetDriversDir) if self.osName == 'Windows': diff --git a/Source/Drivers/Libfreenect2/LF2Common.h b/Source/Drivers/Libfreenect2/LF2Common.h new file mode 100644 index 00000000..466ea215 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Common.h @@ -0,0 +1,10 @@ +#ifndef LF2COMMON_H +#define LF2COMMON_H + +#define LF2_DEPTH_HORIZONTAL_FOV 70.6 +#define LF2_DEPTH_VERTICAL_FOV 60 + +#define LF2_COLOR_HORIZONTAL_FOV 84.1 +#define LF2_COLOR_VERTICAL_FOV 53.8 + +#endif // LF2COMMON_H diff --git a/Source/Drivers/Libfreenect2/LF2DepthStream.cpp b/Source/Drivers/Libfreenect2/LF2DepthStream.cpp new file mode 100644 index 00000000..16e0bb1c --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2DepthStream.cpp @@ -0,0 +1,96 @@ +#include "LF2DepthStream.h" +#include +#include "LF2Common.h" +#include + +using namespace LF2; + +int +LF2DepthStream::BuildFrame(libfreenect2::Frame* frame_in,OniFrame* frame_out) +{ + // 1 DepthPixel is 2 byte + frame_out->dataSize = frame_in->width * frame_in->height * 2; + + frame_out->data = xnOSMalloc (frame_out->dataSize); + + const float* const in_array = (float*) frame_in->data; + uint16_t* const out_array = (uint16_t*) frame_out->data; + unsigned int t = 0; + for (unsigned int y = 0; y < frame_in->height; y++) + { + for (unsigned int x = 0; x < frame_in->width; x++) + { + out_array[t] = in_array[t]; + ++t; + } + } + + + frame_out->frameIndex = frame_in->sequence; + frame_out->sensorType = ONI_SENSOR_DEPTH; + + frame_out->videoMode.pixelFormat = ONI_PIXEL_FORMAT_DEPTH_1_MM; + frame_out->videoMode.resolutionX = frame_in->width; + frame_out->videoMode.resolutionY = frame_in->height; + frame_out->videoMode.fps = 30; + + frame_out->width = frame_in->width; + frame_out->height = frame_in->height; + + frame_out->cropOriginX = frame_out->cropOriginY = 0; + frame_out->croppingEnabled = FALSE; + + frame_out->sensorType = ONI_SENSOR_DEPTH; + frame_out->stride = frame_in->width*sizeof(OniDepthPixel); + frame_out->timestamp = frame_in->sequence*33369; + + return 1; +} + +OniStatus +LF2DepthStream::getProperty(int propertyId, void* data, int* pDataSize) +{ + OniStatus status = ONI_STATUS_NOT_SUPPORTED; + + switch (propertyId) + { + case ONI_STREAM_PROPERTY_HORIZONTAL_FOV: + { + float* val = (float*)data; + XnDouble tmp; + tmp = LF2_DEPTH_HORIZONTAL_FOV * xnl::Math::DTR; + *val = (float)tmp; + status = ONI_STATUS_OK; + break; + } + case ONI_STREAM_PROPERTY_VERTICAL_FOV: + { + float* val = (float*)data; + XnDouble tmp; + tmp = LF2_DEPTH_VERTICAL_FOV * xnl::Math::DTR; + *val = (float)tmp; + status = ONI_STATUS_OK; + break; + } + case ONI_STREAM_PROPERTY_MAX_VALUE: + if (*pDataSize != sizeof(int)) + { + return ONI_STATUS_BAD_PARAMETER; + } + + *(int*)data = 10000; + return ONI_STATUS_OK; + case ONI_STREAM_PROPERTY_MIN_VALUE: + if (*pDataSize != sizeof(int)) + { + return ONI_STATUS_BAD_PARAMETER; + } + + *(int*)data = 0; + return ONI_STATUS_OK; + default: + return LF2Stream::getProperty(propertyId, data, pDataSize); + } + + return status; +} diff --git a/Source/Drivers/Libfreenect2/LF2DepthStream.h b/Source/Drivers/Libfreenect2/LF2DepthStream.h new file mode 100644 index 00000000..c0bf380f --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2DepthStream.h @@ -0,0 +1,49 @@ +#ifndef LF2DEPTH_STREAM_H +#define LF2DEPTH_STREAM_H + +#include "LF2Stream.h" + +namespace LF2 { + class LF2DepthStream : + public LF2Stream + { + public: + LF2DepthStream (libfreenect2::Freenect2Device * f2dev) : LF2Stream (f2dev) { + m_videoMode.pixelFormat = ONI_PIXEL_FORMAT_DEPTH_1_MM; + m_videoMode.resolutionX = 512; + m_videoMode.resolutionY = 424; + m_videoMode.fps = 30; + + m_frameType = libfreenect2::Frame::Depth; + } + + ~LF2DepthStream () + { + stop (); + } + + // function for OpenNI2 + OniStatus + start () + { + m_f2dev->setIrAndDepthFrameListener (this); + m_f2dev->start(); + return ONI_STATUS_OK; + } + + void + stop () + { + m_f2dev->setIrAndDepthFrameListener (NULL); + } + + OniStatus + getProperty(int propertyId, void* data, int* pDataSize); + + protected: + int + BuildFrame (libfreenect2::Frame*,OniFrame*); + }; +} + +#endif // LF2DEPTH_STREAM_H diff --git a/Source/Drivers/Libfreenect2/LF2Device.cpp b/Source/Drivers/Libfreenect2/LF2Device.cpp new file mode 100644 index 00000000..31fcd083 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Device.cpp @@ -0,0 +1,37 @@ +#include "XnLib.h" +#include "LF2Device.h" +#include "LF2DepthStream.h" +#include "LF2ImageStream.h" +#include "LF2IrStream.h" + +using namespace LF2; +using namespace oni::driver; + +StreamBase* +LF2Device::createStream (OniSensorType sensorType) +{ + if (sensorType == ONI_SENSOR_DEPTH) + { + LF2DepthStream* pDepth = XN_NEW(LF2DepthStream,m_f2dev); + return pDepth; + } + else if (sensorType == ONI_SENSOR_COLOR) + { + LF2ImageStream* pImage = XN_NEW(LF2ImageStream,m_f2dev); + return pImage; + } + else if (sensorType == ONI_SENSOR_IR) + { + LF2IrStream* pIr = XN_NEW(LF2IrStream,m_f2dev); + return pIr; + } + + return NULL; +} + +void +LF2Device::destroyStream (StreamBase* pStream) +{ + XN_DELETE (pStream); +} + diff --git a/Source/Drivers/Libfreenect2/LF2Device.h b/Source/Drivers/Libfreenect2/LF2Device.h new file mode 100644 index 00000000..be1d9859 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Device.h @@ -0,0 +1,74 @@ +#ifndef LF2DEVICE_H +#define LF2DEVICE_H + +#include +#include "libfreenect2/libfreenect2.hpp" +#include "Driver/OniDriverAPI.h" +#include "LF2Driver.h" + + +namespace LF2 { + class LF2Driver; + class LF2Device : + public oni::driver::DeviceBase + { + public : + LF2Device(libfreenect2::Freenect2Device* f2dev,LF2Driver* driver) + { + static const int DEFAULT_FPS = 30; + m_f2dev = f2dev; + m_driver = driver; + // this is actually 3. but now color and ir are not supprted yet. + + m_sensors[0].sensorType = ONI_SENSOR_DEPTH; + m_sensors[0].numSupportedVideoModes = 1; + m_sensors[0].pSupportedVideoModes = XN_NEW_ARR(OniVideoMode, 1); + m_sensors[0].pSupportedVideoModes[0].pixelFormat = ONI_PIXEL_FORMAT_DEPTH_1_MM; + m_sensors[0].pSupportedVideoModes[0].fps = DEFAULT_FPS; + m_sensors[0].pSupportedVideoModes[0].resolutionX = 512; + m_sensors[0].pSupportedVideoModes[0].resolutionY = 424; + + m_sensors[1].sensorType = ONI_SENSOR_COLOR; + m_sensors[1].numSupportedVideoModes = 2; + m_sensors[1].pSupportedVideoModes = XN_NEW_ARR(OniVideoMode, 1); + m_sensors[1].pSupportedVideoModes[0].pixelFormat = ONI_PIXEL_FORMAT_RGB888; + m_sensors[1].pSupportedVideoModes[0].fps = DEFAULT_FPS; + m_sensors[1].pSupportedVideoModes[0].resolutionX = 1920; + m_sensors[1].pSupportedVideoModes[0].resolutionY = 1080; + + m_sensors[2].sensorType = ONI_SENSOR_IR; + m_sensors[2].numSupportedVideoModes = 1; + m_sensors[2].pSupportedVideoModes = XN_NEW_ARR(OniVideoMode, 1); + m_sensors[2].pSupportedVideoModes[0].pixelFormat = ONI_PIXEL_FORMAT_GRAY16; + m_sensors[2].pSupportedVideoModes[0].fps = DEFAULT_FPS; + m_sensors[2].pSupportedVideoModes[0].resolutionX = 512; + m_sensors[2].pSupportedVideoModes[0].resolutionY = 424; + + } + + OniStatus + getSensorInfoList(OniSensorInfo** pSensors, int* numSensors) + { + *numSensors = m_numSensors; + *pSensors = m_sensors; + return ONI_STATUS_OK; + } + + oni::driver::StreamBase* + createStream (OniSensorType); + + void + destroyStream (oni::driver::StreamBase*); + protected: + static const int m_numSensors = 3; + OniSensorInfo m_sensors[m_numSensors]; + libfreenect2::Freenect2Device* m_f2dev; + LF2Driver* m_driver; + }; +} + +#endif // LF2DEVICE_H + + + + diff --git a/Source/Drivers/Libfreenect2/LF2Driver.cpp b/Source/Drivers/Libfreenect2/LF2Driver.cpp new file mode 100644 index 00000000..edafdd2d --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Driver.cpp @@ -0,0 +1,123 @@ +#include "LF2Driver.h" +#include "LF2Device.h" +#include +#include +#include + +static const char VENDOR_VAL[] = "Microsoft"; +static const char NAME_VAL[] = "Kinect v2"; + +using namespace LF2; +using namespace oni::driver; +using namespace libfreenect2; + +namespace libfreenect2 { + extern PacketPipeline *createDefaultPacketPipeline(); +} + + +DeviceBase* +LF2Driver::deviceOpen(const char * uri, const char *) +{ + Freenect2Device * f2dev; + LF2Device* pDevice = NULL; + + // if device was already opened for this uri, return the previous one + if (m_devices.Get (uri,pDevice) == XN_STATUS_OK) + { + getServices().errorLoggerAppend("Device is already open."); + return NULL; + } + + DepthPacketProcessor::Config config; + PacketPipeline* packetPipeline = createDefaultPacketPipeline(); + config.MaxDepth = 10000; + packetPipeline->getDepthPacketProcessor()->setConfiguration(config); + f2dev = m_f2.openDevice (uri,packetPipeline); + + if (f2dev == 0) + { + getServices().errorLoggerAppend("Could not open \"%s\"", uri); + return NULL; + } + + pDevice = XN_NEW(LF2Device, f2dev,this); + + // Add the device and return it. + m_devices[uri] = pDevice; + return pDevice; +} + +void +LF2Driver::deviceClose(DeviceBase* pDevice) +{ + for (xnl::StringsHash::Iterator iter = m_devices.Begin(); iter != m_devices.End(); ++iter) + { + if (iter->Value() == pDevice) + { + m_devices.Remove(iter); + XN_DELETE(pDevice); + return; + } + } + + // not our device?! + XN_ASSERT(FALSE); +} + + + +void +LF2Driver::shutdown () +{ + // delete devices + for (xnl::StringsHash::Iterator iter = m_devices.Begin(); iter != m_devices.End(); ++iter) + { + XN_DELETE(iter->Value ()); + } + + m_devices.Clear (); +} + +OniStatus +LF2Driver::initialize (DeviceConnectedCallback connectedCallback, DeviceDisconnectedCallback disconnectedCallback, DeviceStateChangedCallback deviceStateChangedCallback, void* pCookie) +{ + DriverBase::initialize (connectedCallback,disconnectedCallback,deviceStateChangedCallback,pCookie); + int num_of_device = m_f2.enumerateDevices (); + + if (num_of_device == 0) + { + return ONI_STATUS_OK; + } + + // discover Kinects + for (int t = 0; t < num_of_device; ++t) + { + Freenect2Device* dev = m_f2.openDevice (t); + OniDeviceInfo* pInfo = XN_NEW (OniDeviceInfo); + std::string serial = dev->getSerialNumber (); + + xnOSStrCopy (pInfo->uri,serial.c_str (),ONI_MAX_STR); + xnOSStrCopy (pInfo->vendor,VENDOR_VAL,ONI_MAX_STR); + xnOSStrCopy (pInfo->name, NAME_VAL,ONI_MAX_STR); + deviceConnected (pInfo); + deviceStateChanged (pInfo,false); + + dev->close (); + } + return ONI_STATUS_OK; +} + +OniStatus +LF2Driver::tryDevice (const char*) +{ + return ONI_STATUS_OK; +} + +ONI_EXPORT_DRIVER(LF2Driver); + + + + + + diff --git a/Source/Drivers/Libfreenect2/LF2Driver.h b/Source/Drivers/Libfreenect2/LF2Driver.h new file mode 100644 index 00000000..8a742809 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Driver.h @@ -0,0 +1,41 @@ +#ifndef LF2DRIVER_H +#define LF2DRIVER_H + +#include +#include "Driver/OniDriverAPI.h" +#include "LF2Device.h" +#include +#include + +namespace LF2 { + class LF2Device; + class LF2Driver : + public oni::driver::DriverBase + { + public: + LF2Driver(OniDriverServices* pDriverServices) : DriverBase(pDriverServices) {} + + virtual OniStatus + initialize(oni::driver::DeviceConnectedCallback, oni::driver::DeviceDisconnectedCallback, oni::driver::DeviceStateChangedCallback , void*); + + //! @note mode is no supported now. + oni::driver::DeviceBase* + deviceOpen (const char*,const char*); + + void + deviceClose (oni::driver::DeviceBase*); + + virtual OniStatus + tryDevice(const char* uri); + + void + shutdown (); + + protected: + libfreenect2::Freenect2 m_f2; + //uri -> LF2Device map + xnl::StringsHash m_devices; + }; +} + +#endif // LF2DRIVER_H diff --git a/Source/Drivers/Libfreenect2/LF2ImageStream.cpp b/Source/Drivers/Libfreenect2/LF2ImageStream.cpp new file mode 100644 index 00000000..f5304a37 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2ImageStream.cpp @@ -0,0 +1,68 @@ +#include "LF2ImageStream.h" +#include +#include "LF2Common.h" +#include + +using namespace LF2; + +int +LF2ImageStream::BuildFrame(libfreenect2::Frame* frame_in,OniFrame* frame_out) +{ + frame_out->dataSize = frame_in->width * frame_in->height * (sizeof (OniRGB888Pixel) +1); + + frame_out->data = xnOSMalloc (frame_out->dataSize); + + xnOSMemCopy (frame_out->data,frame_in->data,frame_out->dataSize); + + frame_out->frameIndex = frame_in->sequence; + frame_out->sensorType = ONI_SENSOR_COLOR; + + frame_out->videoMode.pixelFormat = ONI_PIXEL_FORMAT_RGB888; + frame_out->videoMode.resolutionX = frame_in->width; + frame_out->videoMode.resolutionY = frame_in->height; + frame_out->videoMode.fps = 30; + + frame_out->width = frame_in->width; + frame_out->height = frame_in->height; + + frame_out->cropOriginX = frame_out->cropOriginY = 0; + frame_out->croppingEnabled = FALSE; + + frame_out->sensorType = ONI_SENSOR_COLOR; + frame_out->stride = frame_in->width*sizeof(OniRGB888Pixel); + frame_out->timestamp = frame_in->sequence*33369; + + return 1; +} + +OniStatus +LF2ImageStream::getProperty(int propertyId, void* data, int* pDataSize) +{ + OniStatus status = ONI_STATUS_NOT_SUPPORTED; + + switch (propertyId) + { + case ONI_STREAM_PROPERTY_HORIZONTAL_FOV: + { + float* val = (float*)data; + XnDouble tmp; + tmp = LF2_COLOR_HORIZONTAL_FOV * xnl::Math::DTR; + *val = (float)tmp; + status = ONI_STATUS_OK; + break; + } + case ONI_STREAM_PROPERTY_VERTICAL_FOV: + { + float* val = (float*)data; + XnDouble tmp; + tmp = LF2_COLOR_VERTICAL_FOV * xnl::Math::DTR; + *val = (float)tmp; + status = ONI_STATUS_OK; + break; + } + default: + return LF2Stream::getProperty(propertyId, data, pDataSize); + } + + return status; +} diff --git a/Source/Drivers/Libfreenect2/LF2ImageStream.h b/Source/Drivers/Libfreenect2/LF2ImageStream.h new file mode 100644 index 00000000..6be1b89a --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2ImageStream.h @@ -0,0 +1,49 @@ +#ifndef LF2IMAGE_STREAM_H +#define LF2IMAGE_STREAM_H + +#include "LF2Stream.h" + +namespace LF2 { + class LF2ImageStream : + public LF2Stream + { + public: + LF2ImageStream (libfreenect2::Freenect2Device * f2dev) : LF2Stream (f2dev) { + m_videoMode.pixelFormat = ONI_PIXEL_FORMAT_RGB888; + m_videoMode.resolutionX = 1920; + m_videoMode.resolutionY = 1080; + m_videoMode.fps = 30; + + m_frameType = libfreenect2::Frame::Color; + } + + ~LF2ImageStream() + { + stop (); + } + + // function for OpenNI2 + OniStatus + start () + { + m_f2dev->setColorFrameListener (this); + m_f2dev->start (); + return ONI_STATUS_OK; + } + + void + stop () + { + m_f2dev->setColorFrameListener (NULL); + } + + OniStatus + getProperty(int propertyId, void* data, int* pDataSize); + + protected: + int + BuildFrame (libfreenect2::Frame*,OniFrame*); + }; +} + +#endif // LF2IMAGE_STREAM_H diff --git a/Source/Drivers/Libfreenect2/LF2IrStream.cpp b/Source/Drivers/Libfreenect2/LF2IrStream.cpp new file mode 100644 index 00000000..dd96cfb9 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2IrStream.cpp @@ -0,0 +1,80 @@ +#include "LF2IrStream.h" +#include +#include "LF2Common.h" +#include + +using namespace LF2; + +int +LF2IrStream::BuildFrame(libfreenect2::Frame* frame_in,OniFrame* frame_out) +{ + // 1 DepthPixel is 2 byte + frame_out->dataSize = frame_in->width * frame_in->height * sizeof (ONI_PIXEL_FORMAT_GRAY16); + + frame_out->data = xnOSMalloc (frame_out->dataSize); + + const float* const in_array = (float*) frame_in->data; + uint16_t* const out_array = (uint16_t*) frame_out->data; + unsigned int t = 0; + for (unsigned int y = 0; y < frame_in->height; y++) + { + for (unsigned int x = 0; x < frame_in->width; x++) + { + out_array[t] = in_array[t]; + ++t; + } + } + + + frame_out->frameIndex = frame_in->sequence; + frame_out->sensorType = ONI_SENSOR_IR; + + frame_out->videoMode.pixelFormat = ONI_PIXEL_FORMAT_GRAY16; + frame_out->videoMode.resolutionX = frame_in->width; + frame_out->videoMode.resolutionY = frame_in->height; + frame_out->videoMode.fps = 30; + + frame_out->width = frame_in->width; + frame_out->height = frame_in->height; + + frame_out->cropOriginX = frame_out->cropOriginY = 0; + frame_out->croppingEnabled = FALSE; + + frame_out->sensorType = ONI_SENSOR_IR; + frame_out->stride = frame_in->width*sizeof(ONI_PIXEL_FORMAT_GRAY16); + frame_out->timestamp = frame_in->sequence*33369; + + return 1; +} + +OniStatus +LF2IrStream::getProperty(int propertyId, void* data, int* pDataSize) +{ + OniStatus status = ONI_STATUS_NOT_SUPPORTED; + + switch (propertyId) + { + case ONI_STREAM_PROPERTY_HORIZONTAL_FOV: + { + float* val = (float*)data; + XnDouble tmp; + tmp = LF2_DEPTH_HORIZONTAL_FOV * xnl::Math::DTR; + *val = (float)tmp; + status = ONI_STATUS_OK; + break; + } + case ONI_STREAM_PROPERTY_VERTICAL_FOV: + { + float* val = (float*)data; + XnDouble tmp; + tmp = LF2_DEPTH_VERTICAL_FOV * xnl::Math::DTR; + *val = (float)tmp; + status = ONI_STATUS_OK; + break; + } + default: + return LF2Stream::getProperty(propertyId, data, pDataSize); + } + + return status; +} diff --git a/Source/Drivers/Libfreenect2/LF2IrStream.h b/Source/Drivers/Libfreenect2/LF2IrStream.h new file mode 100644 index 00000000..2105dcbb --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2IrStream.h @@ -0,0 +1,49 @@ +#ifndef LF2IR_STREAM_H +#define LF2IR_STREAM_H + +#include "LF2Stream.h" + +namespace LF2 { + class LF2IrStream : + public LF2Stream + { + public: + LF2IrStream (libfreenect2::Freenect2Device * f2dev) : LF2Stream (f2dev) { + m_videoMode.pixelFormat = ONI_PIXEL_FORMAT_GRAY16; + m_videoMode.resolutionX = 512; + m_videoMode.resolutionY = 424; + m_videoMode.fps = 30; + + m_frameType = libfreenect2::Frame::Ir; + } + + ~LF2IrStream() + { + stop (); + } + + // function for OpenNI2 + OniStatus + start () + { + m_f2dev->setIrAndDepthFrameListener (this); + m_f2dev->start(); + return ONI_STATUS_OK; + } + + void + stop () + { + m_f2dev->setIrAndDepthFrameListener (NULL); + } + + OniStatus + getProperty(int propertyId, void* data, int* pDataSize); + + protected: + int + BuildFrame (libfreenect2::Frame*,OniFrame*); + }; +} + +#endif // LF2IR_STREAM_H diff --git a/Source/Drivers/Libfreenect2/LF2Stream.cpp b/Source/Drivers/Libfreenect2/LF2Stream.cpp new file mode 100644 index 00000000..2c1887a6 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Stream.cpp @@ -0,0 +1,63 @@ +#include "LF2Stream.h" + +using namespace LF2; +using namespace oni::driver; +using namespace libfreenect2; + +bool +LF2Stream::onNewFrame (Frame::Type type,Frame* frame) +{ + if (m_frameType != type) + { + return false; + } + + OniFrame* pFrame = getServices ().acquireFrame (); + BuildFrame (frame,pFrame); + raiseNewFrame (pFrame); + getServices ().releaseFrame (pFrame); + return true; +} + +OniStatus +LF2Stream::getProperty(int propertyId, void* data, int* pDataSize) +{ + OniStatus status = ONI_STATUS_NOT_SUPPORTED; + + switch (propertyId) + { + case ONI_STREAM_PROPERTY_CROPPING: + { + if (*pDataSize != sizeof(OniCropping)) + { + printf("Unexpected size: %d != %ld\n", *pDataSize, sizeof(OniCropping)); + status = ONI_STATUS_ERROR; + } + ((OniCropping*) data)->enabled = false; + ((OniCropping*) data)->originX = 0; + ((OniCropping*) data)->originY = 0; + ((OniCropping*) data)->width = m_videoMode.resolutionX; + ((OniCropping*) data)->height = m_videoMode.resolutionY; + status = ONI_STATUS_OK; + break; + } + case ONI_STREAM_PROPERTY_VIDEO_MODE: + { + if (*pDataSize != sizeof(OniVideoMode)) + { + printf("Unexpected size: %d != %ld\n", *pDataSize, sizeof(OniVideoMode)); + status = ONI_STATUS_ERROR; + } + else + { + status = GetVideoMode((OniVideoMode*)data); + } + break; + } + default: + status = ONI_STATUS_NOT_SUPPORTED; + break; + } + + return status; +} diff --git a/Source/Drivers/Libfreenect2/LF2Stream.h b/Source/Drivers/Libfreenect2/LF2Stream.h new file mode 100644 index 00000000..6e351b56 --- /dev/null +++ b/Source/Drivers/Libfreenect2/LF2Stream.h @@ -0,0 +1,53 @@ +#ifndef LF2STREAM_H +#define LF2STREAM_H + +#include "Driver/OniDriverAPI.h" +#include +#include +#include + + +namespace LF2 { + class LF2Stream : + public oni::driver::StreamBase, + public libfreenect2::FrameListener + { + public: + LF2Stream (libfreenect2::Freenect2Device * f2dev) : oni::driver::StreamBase () + { + m_f2dev = f2dev; + } + + // function for libfreenect2 + bool + onNewFrame(libfreenect2::Frame::Type, libfreenect2::Frame*); + + // function for OpenNI2 + virtual OniStatus + start () = 0; + + virtual void + stop () = 0; + + virtual OniStatus + GetVideoMode (OniVideoMode* pVideoMode) + { + *pVideoMode = m_videoMode; + return ONI_STATUS_OK; + } + + virtual OniStatus + getProperty(int propertyId, void* data, int* pDataSize); + + protected: + virtual int + BuildFrame (libfreenect2::Frame*,OniFrame* pFrame) = 0; + + libfreenect2::Freenect2Device *m_f2dev; + + OniVideoMode m_videoMode; + libfreenect2::Frame::Type m_frameType; + }; +} + +#endif // LF2STREAM_H diff --git a/Source/Drivers/Libfreenect2/Makefile b/Source/Drivers/Libfreenect2/Makefile new file mode 100644 index 00000000..d9c073bd --- /dev/null +++ b/Source/Drivers/Libfreenect2/Makefile @@ -0,0 +1,37 @@ +include ../../../ThirdParty/PSCommon/BuildSystem/CommonDefs.mak + +BIN_DIR = ../../../Bin + +INC_DIRS = \ + . \ + ../../../Include \ + ../../../ThirdParty/PSCommon/XnLib/Include \ + ../../../ThirdParty/LibJPEG \ + Formats + +SRC_FILES = \ + *.cpp \ + Formats/*.cpp \ + XnLibExtensions/*.cpp \ + ../../../ThirdParty/LibJPEG/*.c + + +ifeq ("$(OSTYPE)","Darwin") + INC_DIRS += /opt/local/include + LIB_DIRS += /opt/local/lib +# LDFLAGS += -framework CoreFoundation -framework IOKit +endif + +LIB_NAME = Libfreenect2 + +LIB_DIRS = ../../../ThirdParty/PSCommon/XnLib/Bin/$(PLATFORM)-$(CFG) +USED_LIBS = XnLib pthread freenect2 +ifneq ("$(OSTYPE)","Darwin") + USED_LIBS += rt +endif + +CFLAGS += -Wall + +OUT_DIR := $(OUT_DIR)/OpenNI2/Drivers + +include ../../../ThirdParty/PSCommon/BuildSystem/CommonCppMakefile diff --git a/Source/Drivers/Libfreenect2/README.md b/Source/Drivers/Libfreenect2/README.md new file mode 100644 index 00000000..08f795cf --- /dev/null +++ b/Source/Drivers/Libfreenect2/README.md @@ -0,0 +1,26 @@ +Features +======== +* Depth,Image,Ir streams of Kinect v2 are available through OpenNI2 interface. +* Free from Kinect SDK, so you can use this even in Linux,Mac OSX, and so on. (I have tested on Ubuntu 14.10.) +* libfreenect2 is now experimental and this implementation is still more experimental. + +Requirement +=========== +* libfreenect2 (master is OK now!!) +* libfreenect2's patched libusb-1.0 (You may already have libusb, but you need to config to be loaded patched libusb.) +* Powerfull GPU resource +* USB3.0 port + +Getting Started +=============== +1. You should try example of libfreenect2 first. +2. install libfreenect2 +3. configure to be loaded patched libusb +4. write code of OpenNI2 +5. build and run!! + +Known Issue +=========== +* Xtion Pro Live's color stream returns BGR but Kinect v2's one returns RGB. +* Color Record does not work well. +