├── .gitignore ├── CHANGELOG ├── LICENSE ├── MANIFEST.in ├── README.md ├── openni ├── __init__.py ├── _nite2.py ├── _openni2.py ├── nite2.py ├── openni2.py └── utils.py └── setup.py /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | openni.egg-info/top_level.txt 3 | 4 | build/lib/openni/__init__.py 5 | 6 | build/lib/openni/_nite2.py 7 | 8 | build/lib/openni/_openni2.py 9 | 10 | build/lib/openni/nite2.py 11 | 12 | build/lib/openni/openni2.py 13 | 14 | build/lib/openni/utils.py 15 | 16 | dist/openni-2.2.0_6_mod_hjmr_1-py3.6.egg 17 | 18 | dist/openni-2.2.0_6.1-py3.6.egg 19 | 20 | dist/openni-2.2.0.post6+hjmr.1-py3.6.egg 21 | 22 | dist/openni-2.2.0.post6+hjmr.1-py3.7.egg 23 | 24 | openni.egg-info/dependency_links.txt 25 | 26 | openni.egg-info/PKG-INFO 27 | 28 | openni.egg-info/SOURCES.txt 29 | -------------------------------------------------------------------------------- /CHANGELOG: -------------------------------------------------------------------------------- 1 | v.2.3.0 2 | ------- 3 | 4 | - fix for Nite2.2 support (Hajime Murao) 5 | - code formatting (Hajime Murao) 6 | - fix a bug in UserTracker when device specfied (Hajime Murao) 7 | - add standard lib path on Linux to help with finding nite (Jerome Flesch) 8 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Python bindings, under the MIT License 2 | 3 | Copyright 2013, PrimeSense LTD. (http://www.primesense.com) 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 9 | of the Software, and to permit persons to whom the Software is furnished to do 10 | so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | 22 | 23 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include LICENSE 2 | include README.md 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | OpenNI2/NiTE2 Python Bindings 2 | ============================= 3 | 4 | Python bindings for [OpenNI2](https://github.com/OpenNI/OpenNI2) and 5 | [NiTE2](http://openni.ru/files/nite/). 6 | 7 | Based on [Primesense original 8 | bindings](https://pypi.python.org/pypi/primesense/2.2.0.30-5), with the bugs 9 | (well, at least some of them) fixed. 10 | 11 | Example of NiTE2 usage: 12 | 13 | ```python 14 | import sys 15 | from openni import openni2, nite2, utils 16 | 17 | openni2.initialize() 18 | nite2.initialize() 19 | 20 | dev = openni2.Device.open_any() 21 | 22 | try: 23 | userTracker = nite2.UserTracker(dev) 24 | except utils.NiteError as ne: 25 | logger.error("Unable to start the NiTE human tracker. Check " 26 | "the error messages in the console. Model data " 27 | "(s.dat, h.dat...) might be inaccessible.") 28 | sys.exit(-1) 29 | 30 | while True: 31 | 32 | frame = userTracker.read_frame() 33 | 34 | if frame.users: 35 | for user in frame.users: 36 | if user.is_new(): 37 | print("New human detected! Calibrating...") 38 | userTracker.start_skeleton_tracking(user.id) 39 | elif user.skeleton.state == nite2.SkeletonState.NITE_SKELETON_TRACKED: 40 | head = user.skeleton.joints[nite2.JointType.NITE_JOINT_HEAD] 41 | 42 | confidence = head.positionConfidence 43 | print("Head: (x:%dmm, y:%dmm, z:%dmm), confidence: %.2f" % ( 44 | head.position.x, 45 | head.position.y, 46 | head.position.z, 47 | confidence)) 48 | 49 | nite2.unload() 50 | openni2.unload() 51 | ``` 52 | 53 | Another example of NiTE2. Display skeletons over the depth stream. 54 | 55 | ``` python 56 | import sys 57 | import argparse 58 | from openni import openni2, nite2, utils 59 | import numpy as np 60 | import cv2 61 | 62 | GRAY_COLOR = (64, 64, 64) 63 | CAPTURE_SIZE_KINECT = (512, 424) 64 | CAPTURE_SIZE_OTHERS = (640, 480) 65 | 66 | 67 | def parse_arg(): 68 | parser = argparse.ArgumentParser(description='Test OpenNI2 and NiTE2.') 69 | parser.add_argument('-w', '--window_width', type=int, default=1024, 70 | help='Specify the window width.') 71 | return parser.parse_args() 72 | 73 | 74 | def draw_limb(img, ut, j1, j2, col): 75 | (x1, y1) = ut.convert_joint_coordinates_to_depth(j1.position.x, j1.position.y, j1.position.z) 76 | (x2, y2) = ut.convert_joint_coordinates_to_depth(j2.position.x, j2.position.y, j2.position.z) 77 | 78 | if (0.4 < j1.positionConfidence and 0.4 < j2.positionConfidence): 79 | c = GRAY_COLOR if (j1.positionConfidence < 1.0 or j2.positionConfidence < 1.0) else col 80 | cv2.line(img, (int(x1), int(y1)), (int(x2), int(y2)), c, 1) 81 | 82 | c = GRAY_COLOR if (j1.positionConfidence < 1.0) else col 83 | cv2.circle(img, (int(x1), int(y1)), 2, c, -1) 84 | 85 | c = GRAY_COLOR if (j2.positionConfidence < 1.0) else col 86 | cv2.circle(img, (int(x2), int(y2)), 2, c, -1) 87 | 88 | 89 | def draw_skeleton(img, ut, user, col): 90 | for idx1, idx2 in [(nite2.JointType.NITE_JOINT_HEAD, nite2.JointType.NITE_JOINT_NECK), 91 | # upper body 92 | (nite2.JointType.NITE_JOINT_NECK, nite2.JointType.NITE_JOINT_LEFT_SHOULDER), 93 | (nite2.JointType.NITE_JOINT_LEFT_SHOULDER, nite2.JointType.NITE_JOINT_TORSO), 94 | (nite2.JointType.NITE_JOINT_TORSO, nite2.JointType.NITE_JOINT_RIGHT_SHOULDER), 95 | (nite2.JointType.NITE_JOINT_RIGHT_SHOULDER, nite2.JointType.NITE_JOINT_NECK), 96 | # left hand 97 | (nite2.JointType.NITE_JOINT_LEFT_HAND, nite2.JointType.NITE_JOINT_LEFT_ELBOW), 98 | (nite2.JointType.NITE_JOINT_LEFT_ELBOW, nite2.JointType.NITE_JOINT_LEFT_SHOULDER), 99 | # right hand 100 | (nite2.JointType.NITE_JOINT_RIGHT_HAND, nite2.JointType.NITE_JOINT_RIGHT_ELBOW), 101 | (nite2.JointType.NITE_JOINT_RIGHT_ELBOW, nite2.JointType.NITE_JOINT_RIGHT_SHOULDER), 102 | # lower body 103 | (nite2.JointType.NITE_JOINT_TORSO, nite2.JointType.NITE_JOINT_LEFT_HIP), 104 | (nite2.JointType.NITE_JOINT_LEFT_HIP, nite2.JointType.NITE_JOINT_RIGHT_HIP), 105 | (nite2.JointType.NITE_JOINT_RIGHT_HIP, nite2.JointType.NITE_JOINT_TORSO), 106 | # left leg 107 | (nite2.JointType.NITE_JOINT_LEFT_FOOT, nite2.JointType.NITE_JOINT_LEFT_KNEE), 108 | (nite2.JointType.NITE_JOINT_LEFT_KNEE, nite2.JointType.NITE_JOINT_LEFT_HIP), 109 | # right leg 110 | (nite2.JointType.NITE_JOINT_RIGHT_FOOT, nite2.JointType.NITE_JOINT_RIGHT_KNEE), 111 | (nite2.JointType.NITE_JOINT_RIGHT_KNEE, nite2.JointType.NITE_JOINT_RIGHT_HIP)]: 112 | draw_limb(img, ut, user.skeleton.joints[idx1], user.skeleton.joints[idx2], col) 113 | 114 | 115 | # ------------------------------------------------------------- 116 | # main program from here 117 | # ------------------------------------------------------------- 118 | 119 | def init_capture_device(): 120 | 121 | openni2.initialize() 122 | nite2.initialize() 123 | return openni2.Device.open_any() 124 | 125 | 126 | def close_capture_device(): 127 | nite2.unload() 128 | openni2.unload() 129 | 130 | 131 | def capture_skeleton(): 132 | args = parse_arg() 133 | dev = init_capture_device() 134 | 135 | dev_name = dev.get_device_info().name.decode('UTF-8') 136 | print("Device Name: {}".format(dev_name)) 137 | use_kinect = False 138 | if dev_name == 'Kinect': 139 | use_kinect = True 140 | print('using Kinect.') 141 | 142 | try: 143 | user_tracker = nite2.UserTracker(dev) 144 | except utils.NiteError: 145 | print("Unable to start the NiTE human tracker. Check " 146 | "the error messages in the console. Model data " 147 | "(s.dat, h.dat...) might be inaccessible.") 148 | sys.exit(-1) 149 | 150 | (img_w, img_h) = CAPTURE_SIZE_KINECT if use_kinect else CAPTURE_SIZE_OTHERS 151 | win_w = args.window_width 152 | win_h = int(img_h * win_w / img_w) 153 | 154 | while True: 155 | ut_frame = user_tracker.read_frame() 156 | 157 | depth_frame = ut_frame.get_depth_frame() 158 | depth_frame_data = depth_frame.get_buffer_as_uint16() 159 | img = np.ndarray((depth_frame.height, depth_frame.width), dtype=np.uint16, 160 | buffer=depth_frame_data).astype(np.float32) 161 | if use_kinect: 162 | img = img[0:img_h, 0:img_w] 163 | 164 | (min_val, max_val, min_loc, max_loc) = cv2.minMaxLoc(img) 165 | if (min_val < max_val): 166 | img = (img - min_val) / (max_val - min_val) 167 | img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) 168 | 169 | if ut_frame.users: 170 | for user in ut_frame.users: 171 | if user.is_new(): 172 | print("new human id:{} detected.".format(user.id)) 173 | user_tracker.start_skeleton_tracking(user.id) 174 | elif (user.state == nite2.UserState.NITE_USER_STATE_VISIBLE and 175 | user.skeleton.state == nite2.SkeletonState.NITE_SKELETON_TRACKED): 176 | draw_skeleton(img, user_tracker, user, (255, 0, 0)) 177 | 178 | cv2.imshow("Depth", cv2.resize(img, (win_w, win_h))) 179 | if (cv2.waitKey(1) & 0xFF == ord('q')): 180 | break 181 | 182 | close_capture_device() 183 | 184 | 185 | if __name__ == '__main__': 186 | capture_skeleton() 187 | ``` 188 | 189 | ![Captured screen image for above example.](https://raw.githubusercontent.com/hjmr/openni-python/images/nite2-skeleton-image01.png) 190 | -------------------------------------------------------------------------------- /openni/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/severin-lemaignan/openni-python/97aaa6965f0012c68740d4a799b88f503f60c90f/openni/__init__.py -------------------------------------------------------------------------------- /openni/_nite2.py: -------------------------------------------------------------------------------- 1 | # Auto-generated file; do not edit directly 2 | # Tue Nov 12 13:59:13 2013 3 | import sys 4 | 5 | import ctypes 6 | from openni.utils import CEnum, UnloadedDLL 7 | 8 | TRUE = 1 9 | FALSE = 0 10 | ONI_MAX_STR = 256 11 | ONI_MAX_SENSORS = 10 12 | NITE_JOINT_COUNT = 15 13 | NITE_POSE_COUNT = 2 14 | NITE_VERSION_MAJOR = 2 15 | NITE_VERSION_MINOR = 3 16 | NITE_VERSION_MAINTENANCE = 0 17 | NITE_VERSION_BUILD = 16 18 | NITE_VERSION = (NITE_VERSION_MAJOR * 100000000 + NITE_VERSION_MINOR * 19 | 1000000 + NITE_VERSION_MAINTENANCE * 10000 + NITE_VERSION_BUILD) 20 | 21 | 22 | def _get_calling_conv(*args): 23 | if sys.platform == 'win32': 24 | return ctypes.WINFUNCTYPE(*args) 25 | else: 26 | return ctypes.CFUNCTYPE(*args) 27 | 28 | 29 | from openni._openni2 import OniStatus 30 | from openni._openni2 import OniSensorType 31 | from openni._openni2 import OniPixelFormat 32 | from openni._openni2 import OniDeviceState 33 | from openni._openni2 import OniImageRegistrationMode 34 | 35 | 36 | class _anon_enum_5(CEnum): 37 | _names_ = {'ONI_TIMEOUT_NONE': 0, 'ONI_TIMEOUT_FOREVER': -1} 38 | _values_ = {0: 'ONI_TIMEOUT_NONE', -1: 'ONI_TIMEOUT_FOREVER'} 39 | ONI_TIMEOUT_NONE = 0 40 | ONI_TIMEOUT_FOREVER = -1 41 | 42 | 43 | ONI_TIMEOUT_NONE = _anon_enum_5.ONI_TIMEOUT_NONE 44 | ONI_TIMEOUT_FOREVER = _anon_enum_5.ONI_TIMEOUT_FOREVER 45 | 46 | from openni._openni2 import OniCallbackHandleImpl 47 | from openni._openni2 import OniVersion 48 | from openni._openni2 import OniVideoMode 49 | from openni._openni2 import OniSensorInfo 50 | from openni._openni2 import OniDeviceInfo 51 | 52 | 53 | class _OniDevice(ctypes.Structure): 54 | 55 | def __repr__(self): 56 | return '_OniDevice()' % () 57 | 58 | 59 | class _OniStream(ctypes.Structure): 60 | 61 | def __repr__(self): 62 | return '_OniStream()' % () 63 | 64 | 65 | class _OniRecorder(ctypes.Structure): 66 | 67 | def __repr__(self): 68 | return '_OniRecorder()' % () 69 | 70 | 71 | from openni._openni2 import OniFrame 72 | from openni._openni2 import OniDeviceCallbacks 73 | from openni._openni2 import OniCropping 74 | from openni._openni2 import OniRGB888Pixel 75 | from openni._openni2 import OniYUV422DoublePixel 76 | from openni._openni2 import OniSeek 77 | 78 | 79 | class NiteJointType(CEnum): 80 | _names_ = {'NITE_JOINT_RIGHT_ELBOW': 5, 81 | 'NITE_JOINT_LEFT_ELBOW': 4, 82 | 'NITE_JOINT_RIGHT_KNEE': 12, 83 | 'NITE_JOINT_RIGHT_HAND': 7, 84 | 'NITE_JOINT_RIGHT_SHOULDER': 3, 85 | 'NITE_JOINT_HEAD': 0, 86 | 'NITE_JOINT_LEFT_HAND': 6, 87 | 'NITE_JOINT_LEFT_SHOULDER': 2, 88 | 'NITE_JOINT_LEFT_KNEE': 11, 89 | 'NITE_JOINT_TORSO': 8, 90 | 'NITE_JOINT_NECK': 1, 91 | 'NITE_JOINT_LEFT_HIP': 9, 92 | 'NITE_JOINT_RIGHT_HIP': 10, 93 | 'NITE_JOINT_LEFT_FOOT': 13, 94 | 'NITE_JOINT_RIGHT_FOOT': 14} 95 | _values_ = {0: 'NITE_JOINT_HEAD', 96 | 1: 'NITE_JOINT_NECK', 97 | 2: 'NITE_JOINT_LEFT_SHOULDER', 98 | 3: 'NITE_JOINT_RIGHT_SHOULDER', 99 | 4: 'NITE_JOINT_LEFT_ELBOW', 100 | 5: 'NITE_JOINT_RIGHT_ELBOW', 101 | 6: 'NITE_JOINT_LEFT_HAND', 102 | 7: 'NITE_JOINT_RIGHT_HAND', 103 | 8: 'NITE_JOINT_TORSO', 104 | 9: 'NITE_JOINT_LEFT_HIP', 105 | 10: 'NITE_JOINT_RIGHT_HIP', 106 | 11: 'NITE_JOINT_LEFT_KNEE', 107 | 12: 'NITE_JOINT_RIGHT_KNEE', 108 | 13: 'NITE_JOINT_LEFT_FOOT', 109 | 14: 'NITE_JOINT_RIGHT_FOOT'} 110 | NITE_JOINT_HEAD = 0 111 | NITE_JOINT_NECK = 1 112 | NITE_JOINT_LEFT_SHOULDER = 2 113 | NITE_JOINT_RIGHT_SHOULDER = 3 114 | NITE_JOINT_LEFT_ELBOW = 4 115 | NITE_JOINT_RIGHT_ELBOW = 5 116 | NITE_JOINT_LEFT_HAND = 6 117 | NITE_JOINT_RIGHT_HAND = 7 118 | NITE_JOINT_TORSO = 8 119 | NITE_JOINT_LEFT_HIP = 9 120 | NITE_JOINT_RIGHT_HIP = 10 121 | NITE_JOINT_LEFT_KNEE = 11 122 | NITE_JOINT_RIGHT_KNEE = 12 123 | NITE_JOINT_LEFT_FOOT = 13 124 | NITE_JOINT_RIGHT_FOOT = 14 125 | 126 | 127 | class NiteSkeletonState(CEnum): 128 | _names_ = {'NITE_SKELETON_CALIBRATION_ERROR_HEAD': 5, 129 | 'NITE_SKELETON_CALIBRATION_ERROR_NOT_IN_POSE': 3, 130 | 'NITE_SKELETON_TRACKED': 2, 131 | 'NITE_SKELETON_CALIBRATION_ERROR_LEGS': 6, 132 | 'NITE_SKELETON_CALIBRATION_ERROR_HANDS': 4, 133 | 'NITE_SKELETON_CALIBRATING': 1, 134 | 'NITE_SKELETON_CALIBRATION_ERROR_TORSO': 7, 135 | 'NITE_SKELETON_NONE': 0} 136 | _values_ = {0: 'NITE_SKELETON_NONE', 137 | 1: 'NITE_SKELETON_CALIBRATING', 138 | 2: 'NITE_SKELETON_TRACKED', 139 | 3: 'NITE_SKELETON_CALIBRATION_ERROR_NOT_IN_POSE', 140 | 4: 'NITE_SKELETON_CALIBRATION_ERROR_HANDS', 141 | 5: 'NITE_SKELETON_CALIBRATION_ERROR_HEAD', 142 | 6: 'NITE_SKELETON_CALIBRATION_ERROR_LEGS', 143 | 7: 'NITE_SKELETON_CALIBRATION_ERROR_TORSO'} 144 | NITE_SKELETON_NONE = 0 145 | NITE_SKELETON_CALIBRATING = 1 146 | NITE_SKELETON_TRACKED = 2 147 | NITE_SKELETON_CALIBRATION_ERROR_NOT_IN_POSE = 3 148 | NITE_SKELETON_CALIBRATION_ERROR_HANDS = 4 149 | NITE_SKELETON_CALIBRATION_ERROR_HEAD = 5 150 | NITE_SKELETON_CALIBRATION_ERROR_LEGS = 6 151 | NITE_SKELETON_CALIBRATION_ERROR_TORSO = 7 152 | 153 | 154 | class NiteUserState(CEnum): 155 | _names_ = {'NITE_USER_STATE_VISIBLE': 1, 'NITE_USER_STATE_NEW': 3, 'NITE_USER_STATE_LOST': 4} 156 | _values_ = {1: 'NITE_USER_STATE_VISIBLE', 3: 'NITE_USER_STATE_NEW', 4: 'NITE_USER_STATE_LOST'} 157 | NITE_USER_STATE_VISIBLE = 1 158 | NITE_USER_STATE_NEW = 3 159 | NITE_USER_STATE_LOST = 4 160 | 161 | 162 | class NiteStatus(CEnum): 163 | _names_ = {'NITE_STATUS_OUT_OF_FLOW': 3, 'NITE_STATUS_ERROR': 1, 'NITE_STATUS_BAD_USER_ID': 2, 'NITE_STATUS_OK': 0} 164 | _values_ = {0: 'NITE_STATUS_OK', 1: 'NITE_STATUS_ERROR', 2: 'NITE_STATUS_BAD_USER_ID', 3: 'NITE_STATUS_OUT_OF_FLOW'} 165 | NITE_STATUS_OK = 0 166 | NITE_STATUS_ERROR = 1 167 | NITE_STATUS_BAD_USER_ID = 2 168 | NITE_STATUS_OUT_OF_FLOW = 3 169 | 170 | 171 | class NitePoseType(CEnum): 172 | _names_ = {'NITE_POSE_CROSSED_HANDS': 1, 'NITE_POSE_PSI': 0} 173 | _values_ = {0: 'NITE_POSE_PSI', 1: 'NITE_POSE_CROSSED_HANDS'} 174 | NITE_POSE_PSI = 0 175 | NITE_POSE_CROSSED_HANDS = 1 176 | 177 | 178 | class NitePoseState(CEnum): 179 | _names_ = {'NITE_POSE_STATE_IN_POSE': 2, 'NITE_POSE_STATE_ENTER': 4, 180 | 'NITE_POSE_STATE_DETECTING': 1, 'NITE_POSE_STATE_EXIT': 8} 181 | _values_ = {8: 'NITE_POSE_STATE_EXIT', 1: 'NITE_POSE_STATE_DETECTING', 182 | 2: 'NITE_POSE_STATE_IN_POSE', 4: 'NITE_POSE_STATE_ENTER'} 183 | NITE_POSE_STATE_DETECTING = 1 184 | NITE_POSE_STATE_IN_POSE = 2 185 | NITE_POSE_STATE_ENTER = 4 186 | NITE_POSE_STATE_EXIT = 8 187 | 188 | 189 | class NiteGestureType(CEnum): 190 | _names_ = {'NITE_GESTURE_HAND_RAISE': 2, 'NITE_GESTURE_CLICK': 1, 'NITE_GESTURE_WAVE': 0} 191 | _values_ = {0: 'NITE_GESTURE_WAVE', 1: 'NITE_GESTURE_CLICK', 2: 'NITE_GESTURE_HAND_RAISE'} 192 | NITE_GESTURE_WAVE = 0 193 | NITE_GESTURE_CLICK = 1 194 | NITE_GESTURE_HAND_RAISE = 2 195 | 196 | 197 | class NiteGestureState(CEnum): 198 | _names_ = {'NITE_GESTURE_STATE_IN_PROGRESS': 2, 'NITE_GESTURE_STATE_COMPLETED': 4, 'NITE_GESTURE_STATE_NEW': 1} 199 | _values_ = {1: 'NITE_GESTURE_STATE_NEW', 2: 'NITE_GESTURE_STATE_IN_PROGRESS', 4: 'NITE_GESTURE_STATE_COMPLETED'} 200 | NITE_GESTURE_STATE_NEW = 1 201 | NITE_GESTURE_STATE_IN_PROGRESS = 2 202 | NITE_GESTURE_STATE_COMPLETED = 4 203 | 204 | 205 | class NiteHandState(CEnum): 206 | _names_ = {'NITE_HAND_STATE_NEW': 1, 'NITE_HAND_STATE_TRACKED': 2, 207 | 'NITE_HAND_STATE_LOST': 0, 'NITE_HAND_STATE_TOUCHING_FOV': 4} 208 | _values_ = {0: 'NITE_HAND_STATE_LOST', 1: 'NITE_HAND_STATE_NEW', 209 | 2: 'NITE_HAND_STATE_TRACKED', 4: 'NITE_HAND_STATE_TOUCHING_FOV'} 210 | NITE_HAND_STATE_LOST = 0 211 | NITE_HAND_STATE_NEW = 1 212 | NITE_HAND_STATE_TRACKED = 2 213 | NITE_HAND_STATE_TOUCHING_FOV = 4 214 | 215 | 216 | class NiteUserTracker(ctypes.Structure): 217 | 218 | def __repr__(self): 219 | return 'NiteUserTracker()' % () 220 | 221 | 222 | class NitePoint3f(ctypes.Structure): 223 | x = 'ctypes.c_float' 224 | y = 'ctypes.c_float' 225 | z = 'ctypes.c_float' 226 | 227 | def __repr__(self): 228 | return 'NitePoint3f(x = %r, y = %r, z = %r)' % (self.x, self.y, self.z) 229 | 230 | 231 | class NiteQuaternion(ctypes.Structure): 232 | x = 'ctypes.c_float' 233 | y = 'ctypes.c_float' 234 | z = 'ctypes.c_float' 235 | w = 'ctypes.c_float' 236 | 237 | def __repr__(self): 238 | return 'NiteQuaternion(x = %r, y = %r, z = %r, w = %r)' % (self.x, self.y, self.z, self.w) 239 | 240 | 241 | class NiteSkeletonJoint(ctypes.Structure): 242 | jointType = 'NiteJointType' 243 | position = 'NitePoint3f' 244 | positionConfidence = 'ctypes.c_float' 245 | orientation = 'NiteQuaternion' 246 | orientationConfidence = 'ctypes.c_float' 247 | 248 | def __repr__(self): 249 | return 'NiteSkeletonJoint(jointType = %r, position = %r, positionConfidence = %r, orientation = %r, orientationConfidence = %r)' % (self.jointType, self.position, self.positionConfidence, self.orientation, self.orientationConfidence) 250 | 251 | 252 | class NiteBoundingBox(ctypes.Structure): 253 | min = 'NitePoint3f' 254 | max = 'NitePoint3f' 255 | 256 | def __repr__(self): 257 | return 'NiteBoundingBox(min = %r, max = %r)' % (self.min, self.max) 258 | 259 | 260 | class NitePoseData(ctypes.Structure): 261 | type = 'NitePoseType' 262 | state = 'ctypes.c_int' 263 | 264 | def __repr__(self): 265 | return 'NitePoseData(type = %r, state = %r)' % (self.type, self.state) 266 | 267 | 268 | class NiteSkeleton(ctypes.Structure): 269 | joints = '(NiteSkeletonJoint * 15)' 270 | state = 'NiteSkeletonState' 271 | internalState = 'ctypes.c_int' 272 | 273 | def __repr__(self): 274 | return 'NiteSkeleton(joints = %r, state = %r, internalState = %r)' % (self.joints, self.state, self.internalState) 275 | 276 | 277 | class NiteUserData(ctypes.Structure): 278 | id = 'NiteUserId' 279 | boundingBox = 'NiteBoundingBox' 280 | centerOfMass = 'NitePoint3f' 281 | state = 'ctypes.c_int' 282 | skeleton = 'NiteSkeleton' 283 | poses = '(NitePoseData * 2)' 284 | 285 | def __repr__(self): 286 | return 'NiteUserData(id = %r, boundingBox = %r, centerOfMass = %r, state = %r, skeleton = %r, poses = %r)' % (self.id, self.boundingBox, self.centerOfMass, self.state, self.skeleton, self.poses) 287 | 288 | 289 | class NiteUserMap(ctypes.Structure): 290 | pixels = 'ctypes.POINTER(NiteUserId)' 291 | width = 'ctypes.c_int' 292 | height = 'ctypes.c_int' 293 | stride = 'ctypes.c_int' 294 | 295 | def __repr__(self): 296 | return 'NiteUserMap(pixels = %r, width = %r, height = %r, stride = %r)' % (self.pixels, self.width, self.height, self.stride) 297 | 298 | 299 | class NitePlane(ctypes.Structure): 300 | point = 'NitePoint3f' 301 | normal = 'NitePoint3f' 302 | 303 | def __repr__(self): 304 | return 'NitePlane(point = %r, normal = %r)' % (self.point, self.normal) 305 | 306 | 307 | class NiteUserTrackerFrame(ctypes.Structure): 308 | userCount = 'ctypes.c_int' 309 | pUser = 'ctypes.POINTER(NiteUserData)' 310 | userMap = 'NiteUserMap' 311 | pDepthFrame = 'ctypes.POINTER(OniFrame)' 312 | timestamp = 'ctypes.c_ulonglong' 313 | frameIndex = 'ctypes.c_int' 314 | floorConfidence = 'ctypes.c_float' 315 | floor = 'NitePlane' 316 | 317 | def __repr__(self): 318 | return 'NiteUserTrackerFrame(userCount = %r, pUser = %r, userMap = %r, pDepthFrame = %r, timestamp = %r, frameIndex = %r, floorConfidence = %r, floor = %r)' % (self.userCount, self.pUser, self.userMap, self.pDepthFrame, self.timestamp, self.frameIndex, self.floorConfidence, self.floor) 319 | 320 | 321 | class NiteUserTrackerCallbacks(ctypes.Structure): 322 | readyForNextFrame = 'OniGeneralCallback' 323 | 324 | def __repr__(self): 325 | return 'NiteUserTrackerCallbacks(readyForNextFrame = %r)' % (self.readyForNextFrame) 326 | 327 | 328 | class NiteHandData(ctypes.Structure): 329 | id = 'NiteHandId' 330 | position = 'NitePoint3f' 331 | state = 'ctypes.c_int' 332 | 333 | def __repr__(self): 334 | return 'NiteHandData(id = %r, position = %r, state = %r)' % (self.id, self.position, self.state) 335 | 336 | 337 | class NiteGestureData(ctypes.Structure): 338 | type = 'NiteGestureType' 339 | currentPosition = 'NitePoint3f' 340 | state = 'ctypes.c_int' 341 | 342 | def __repr__(self): 343 | return 'NiteGestureData(type = %r, currentPosition = %r, state = %r)' % (self.type, self.currentPosition, self.state) 344 | 345 | 346 | class NiteHandTrackerFrame(ctypes.Structure): 347 | handCount = 'ctypes.c_int' 348 | pHands = 'ctypes.POINTER(NiteHandData)' 349 | gestureCount = 'ctypes.c_int' 350 | pGestures = 'ctypes.POINTER(NiteGestureData)' 351 | pDepthFrame = 'ctypes.POINTER(OniFrame)' 352 | timestamp = 'ctypes.c_ulonglong' 353 | frameIndex = 'ctypes.c_int' 354 | 355 | def __repr__(self): 356 | return 'NiteHandTrackerFrame(handCount = %r, pHands = %r, gestureCount = %r, pGestures = %r, pDepthFrame = %r, timestamp = %r, frameIndex = %r)' % (self.handCount, self.pHands, self.gestureCount, self.pGestures, self.pDepthFrame, self.timestamp, self.frameIndex) 357 | 358 | 359 | class NiteHandTrackerCallbacks(ctypes.Structure): 360 | readyForNextFrame = 'OniGeneralCallback' 361 | 362 | def __repr__(self): 363 | return 'NiteHandTrackerCallbacks(readyForNextFrame = %r)' % (self.readyForNextFrame) 364 | 365 | 366 | class NiteVersion(ctypes.Structure): 367 | major = 'ctypes.c_int' 368 | minor = 'ctypes.c_int' 369 | maintenance = 'ctypes.c_int' 370 | build = 'ctypes.c_int' 371 | 372 | def __repr__(self): 373 | return 'NiteVersion(major = %r, minor = %r, maintenance = %r, build = %r)' % (self.major, self.minor, self.maintenance, self.build) 374 | 375 | 376 | class NiteHandTracker(ctypes.Structure): 377 | 378 | def __repr__(self): 379 | return 'NiteHandTracker()' % () 380 | 381 | 382 | OniBool = ctypes.c_int 383 | OniCallbackHandle = ctypes.POINTER(OniCallbackHandleImpl) 384 | OniHardwareVersion = ctypes.c_int 385 | OniDeviceHandle = ctypes.POINTER(_OniDevice) 386 | OniStreamHandle = ctypes.POINTER(_OniStream) 387 | OniRecorderHandle = ctypes.POINTER(_OniRecorder) 388 | OniNewFrameCallback = _get_calling_conv(None, OniStreamHandle, ctypes.c_void_p) 389 | OniGeneralCallback = _get_calling_conv(None, ctypes.c_void_p) 390 | OniDeviceInfoCallback = _get_calling_conv(None, ctypes.POINTER(OniDeviceInfo), ctypes.c_void_p) 391 | OniDeviceStateCallback = _get_calling_conv(None, ctypes.POINTER(OniDeviceInfo), OniDeviceState, ctypes.c_void_p) 392 | OniFrameAllocBufferCallback = _get_calling_conv(ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p) 393 | OniFrameFreeBufferCallback = _get_calling_conv(None, ctypes.c_void_p, ctypes.c_void_p) 394 | OniDepthPixel = ctypes.c_ushort 395 | OniGrayscale16Pixel = ctypes.c_ushort 396 | OniGrayscale8Pixel = ctypes.c_ubyte 397 | NiteUserId = ctypes.c_short 398 | NiteUserTrackerHandle = ctypes.POINTER(NiteUserTracker) 399 | NiteHandId = ctypes.c_short 400 | NiteHandTrackerHandle = ctypes.POINTER(NiteHandTracker) 401 | 402 | _OniDevice._fields_ = [ 403 | ] 404 | 405 | _OniStream._fields_ = [ 406 | ] 407 | 408 | _OniRecorder._fields_ = [ 409 | ] 410 | 411 | NiteUserTracker._fields_ = [ 412 | ] 413 | 414 | NitePoint3f._fields_ = [ 415 | ('x', ctypes.c_float), 416 | ('y', ctypes.c_float), 417 | ('z', ctypes.c_float), 418 | ] 419 | 420 | NiteQuaternion._fields_ = [ 421 | ('x', ctypes.c_float), 422 | ('y', ctypes.c_float), 423 | ('z', ctypes.c_float), 424 | ('w', ctypes.c_float), 425 | ] 426 | 427 | NiteSkeletonJoint._fields_ = [ 428 | ('jointType', NiteJointType), 429 | ('position', NitePoint3f), 430 | ('positionConfidence', ctypes.c_float), 431 | ('orientation', NiteQuaternion), 432 | ('orientationConfidence', ctypes.c_float), 433 | ] 434 | 435 | NiteBoundingBox._fields_ = [ 436 | ('min', NitePoint3f), 437 | ('max', NitePoint3f), 438 | ] 439 | 440 | NitePoseData._fields_ = [ 441 | ('type', NitePoseType), 442 | ('state', ctypes.c_int), 443 | ] 444 | 445 | NiteSkeleton._fields_ = [ 446 | ('joints', (NiteSkeletonJoint * 15)), 447 | ('state', NiteSkeletonState), 448 | ('internalState', ctypes.c_int), 449 | ] 450 | 451 | NiteUserData._fields_ = [ 452 | ('id', NiteUserId), 453 | ('boundingBox', NiteBoundingBox), 454 | ('centerOfMass', NitePoint3f), 455 | ('state', ctypes.c_int), 456 | ('skeleton', NiteSkeleton), 457 | ('poses', (NitePoseData * 2)), 458 | ] 459 | 460 | NiteUserMap._fields_ = [ 461 | ('pixels', ctypes.POINTER(NiteUserId)), 462 | ('width', ctypes.c_int), 463 | ('height', ctypes.c_int), 464 | ('stride', ctypes.c_int), 465 | ] 466 | 467 | NitePlane._fields_ = [ 468 | ('point', NitePoint3f), 469 | ('normal', NitePoint3f), 470 | ] 471 | 472 | NiteUserTrackerFrame._fields_ = [ 473 | ('userCount', ctypes.c_int), 474 | ('pUser', ctypes.POINTER(NiteUserData)), 475 | ('userMap', NiteUserMap), 476 | ('pDepthFrame', ctypes.POINTER(OniFrame)), 477 | ('timestamp', ctypes.c_ulonglong), 478 | ('frameIndex', ctypes.c_int), 479 | ('floorConfidence', ctypes.c_float), 480 | ('floor', NitePlane), 481 | ] 482 | 483 | NiteUserTrackerCallbacks._fields_ = [ 484 | ('readyForNextFrame', OniGeneralCallback), 485 | ] 486 | 487 | NiteHandData._fields_ = [ 488 | ('id', NiteHandId), 489 | ('position', NitePoint3f), 490 | ('state', ctypes.c_int), 491 | ] 492 | 493 | NiteGestureData._fields_ = [ 494 | ('type', NiteGestureType), 495 | ('currentPosition', NitePoint3f), 496 | ('state', ctypes.c_int), 497 | ] 498 | 499 | NiteHandTrackerFrame._fields_ = [ 500 | ('handCount', ctypes.c_int), 501 | ('pHands', ctypes.POINTER(NiteHandData)), 502 | ('gestureCount', ctypes.c_int), 503 | ('pGestures', ctypes.POINTER(NiteGestureData)), 504 | ('pDepthFrame', ctypes.POINTER(OniFrame)), 505 | ('timestamp', ctypes.c_ulonglong), 506 | ('frameIndex', ctypes.c_int), 507 | ] 508 | 509 | NiteHandTrackerCallbacks._fields_ = [ 510 | ('readyForNextFrame', OniGeneralCallback), 511 | ] 512 | 513 | NiteVersion._fields_ = [ 514 | ('major', ctypes.c_int), 515 | ('minor', ctypes.c_int), 516 | ('maintenance', ctypes.c_int), 517 | ('build', ctypes.c_int), 518 | ] 519 | 520 | NiteHandTracker._fields_ = [ 521 | ] 522 | 523 | _the_dll = UnloadedDLL 524 | _niteInitialize = UnloadedDLL 525 | _niteShutdown = UnloadedDLL 526 | _niteGetVersion = UnloadedDLL 527 | _niteShutdownUserTracker = UnloadedDLL 528 | _niteStartSkeletonTracking = UnloadedDLL 529 | _niteStopSkeletonTracking = UnloadedDLL 530 | _niteIsSkeletonTracking = UnloadedDLL 531 | _niteSetSkeletonSmoothing = UnloadedDLL 532 | _niteGetSkeletonSmoothing = UnloadedDLL 533 | _niteStartPoseDetection = UnloadedDLL 534 | _niteStopPoseDetection = UnloadedDLL 535 | _niteStopAllPoseDetection = UnloadedDLL 536 | _niteRegisterUserTrackerCallbacks = UnloadedDLL 537 | _niteUnregisterUserTrackerCallbacks = UnloadedDLL 538 | _niteReadUserTrackerFrame = UnloadedDLL 539 | _niteUserTrackerFrameAddRef = UnloadedDLL 540 | _niteUserTrackerFrameRelease = UnloadedDLL 541 | _niteShutdownHandTracker = UnloadedDLL 542 | _niteStartHandTracking = UnloadedDLL 543 | _niteStopHandTracking = UnloadedDLL 544 | _niteStopAllHandTracking = UnloadedDLL 545 | _niteSetHandSmoothingFactor = UnloadedDLL 546 | _niteGetHandSmoothingFactor = UnloadedDLL 547 | _niteRegisterHandTrackerCallbacks = UnloadedDLL 548 | _niteUnregisterHandTrackerCallbacks = UnloadedDLL 549 | _niteReadHandTrackerFrame = UnloadedDLL 550 | _niteHandTrackerFrameAddRef = UnloadedDLL 551 | _niteHandTrackerFrameRelease = UnloadedDLL 552 | _niteStartGestureDetection = UnloadedDLL 553 | _niteStopGestureDetection = UnloadedDLL 554 | _niteStopAllGestureDetection = UnloadedDLL 555 | _niteConvertJointCoordinatesToDepth = UnloadedDLL 556 | _niteConvertDepthCoordinatesToJoint = UnloadedDLL 557 | _niteConvertHandCoordinatesToDepth = UnloadedDLL 558 | _niteConvertDepthCoordinatesToHand = UnloadedDLL 559 | _niteInitializeUserTracker = UnloadedDLL 560 | _niteInitializeUserTrackerByDevice = UnloadedDLL 561 | _niteInitializeHandTracker = UnloadedDLL 562 | _niteInitializeHandTrackerByDevice = UnloadedDLL 563 | 564 | 565 | def load_dll(dllname): 566 | global _the_dll 567 | if _the_dll: 568 | raise ValueError('DLL already loaded') 569 | dll = ctypes.CDLL(dllname) 570 | 571 | global _niteInitialize 572 | _niteInitialize = dll.niteInitialize 573 | _niteInitialize.restype = NiteStatus 574 | _niteInitialize.argtypes = [] 575 | 576 | global _niteShutdown 577 | _niteShutdown = dll.niteShutdown 578 | _niteShutdown.restype = None 579 | _niteShutdown.argtypes = [] 580 | 581 | global _niteGetVersion 582 | _niteGetVersion = dll.niteGetVersion 583 | _niteGetVersion.restype = NiteVersion 584 | _niteGetVersion.argtypes = [] 585 | 586 | global _niteShutdownUserTracker 587 | _niteShutdownUserTracker = dll.niteShutdownUserTracker 588 | _niteShutdownUserTracker.restype = NiteStatus 589 | _niteShutdownUserTracker.argtypes = [NiteUserTrackerHandle] 590 | 591 | global _niteStartSkeletonTracking 592 | _niteStartSkeletonTracking = dll.niteStartSkeletonTracking 593 | _niteStartSkeletonTracking.restype = NiteStatus 594 | _niteStartSkeletonTracking.argtypes = [NiteUserTrackerHandle, NiteUserId] 595 | 596 | global _niteStopSkeletonTracking 597 | _niteStopSkeletonTracking = dll.niteStopSkeletonTracking 598 | _niteStopSkeletonTracking.restype = None 599 | _niteStopSkeletonTracking.argtypes = [NiteUserTrackerHandle, NiteUserId] 600 | 601 | global _niteIsSkeletonTracking 602 | _niteIsSkeletonTracking = dll.niteIsSkeletonTracking 603 | _niteIsSkeletonTracking.restype = ctypes.c_bool 604 | _niteIsSkeletonTracking.argtypes = [NiteUserTrackerHandle, NiteUserId] 605 | 606 | global _niteSetSkeletonSmoothing 607 | _niteSetSkeletonSmoothing = dll.niteSetSkeletonSmoothing 608 | _niteSetSkeletonSmoothing.restype = NiteStatus 609 | _niteSetSkeletonSmoothing.argtypes = [NiteUserTrackerHandle, ctypes.c_float] 610 | 611 | global _niteGetSkeletonSmoothing 612 | _niteGetSkeletonSmoothing = dll.niteGetSkeletonSmoothing 613 | _niteGetSkeletonSmoothing.restype = NiteStatus 614 | _niteGetSkeletonSmoothing.argtypes = [NiteUserTrackerHandle, ctypes.POINTER(ctypes.c_float)] 615 | 616 | global _niteStartPoseDetection 617 | _niteStartPoseDetection = dll.niteStartPoseDetection 618 | _niteStartPoseDetection.restype = NiteStatus 619 | _niteStartPoseDetection.argtypes = [NiteUserTrackerHandle, NiteUserId, NitePoseType] 620 | 621 | global _niteStopPoseDetection 622 | _niteStopPoseDetection = dll.niteStopPoseDetection 623 | _niteStopPoseDetection.restype = None 624 | _niteStopPoseDetection.argtypes = [NiteUserTrackerHandle, NiteUserId, NitePoseType] 625 | 626 | global _niteStopAllPoseDetection 627 | _niteStopAllPoseDetection = dll.niteStopAllPoseDetection 628 | _niteStopAllPoseDetection.restype = None 629 | _niteStopAllPoseDetection.argtypes = [NiteUserTrackerHandle, NiteUserId] 630 | 631 | global _niteRegisterUserTrackerCallbacks 632 | _niteRegisterUserTrackerCallbacks = dll.niteRegisterUserTrackerCallbacks 633 | _niteRegisterUserTrackerCallbacks.restype = NiteStatus 634 | _niteRegisterUserTrackerCallbacks.argtypes = [NiteUserTrackerHandle, 635 | ctypes.POINTER(NiteUserTrackerCallbacks), ctypes.c_void_p] 636 | 637 | global _niteUnregisterUserTrackerCallbacks 638 | _niteUnregisterUserTrackerCallbacks = dll.niteUnregisterUserTrackerCallbacks 639 | _niteUnregisterUserTrackerCallbacks.restype = None 640 | _niteUnregisterUserTrackerCallbacks.argtypes = [NiteUserTrackerHandle, ctypes.POINTER(NiteUserTrackerCallbacks)] 641 | 642 | global _niteReadUserTrackerFrame 643 | _niteReadUserTrackerFrame = dll.niteReadUserTrackerFrame 644 | _niteReadUserTrackerFrame.restype = NiteStatus 645 | _niteReadUserTrackerFrame.argtypes = [NiteUserTrackerHandle, ctypes.POINTER(ctypes.POINTER(NiteUserTrackerFrame))] 646 | 647 | global _niteUserTrackerFrameAddRef 648 | _niteUserTrackerFrameAddRef = dll.niteUserTrackerFrameAddRef 649 | _niteUserTrackerFrameAddRef.restype = NiteStatus 650 | _niteUserTrackerFrameAddRef.argtypes = [NiteUserTrackerHandle, ctypes.POINTER(NiteUserTrackerFrame)] 651 | 652 | global _niteUserTrackerFrameRelease 653 | _niteUserTrackerFrameRelease = dll.niteUserTrackerFrameRelease 654 | _niteUserTrackerFrameRelease.restype = NiteStatus 655 | _niteUserTrackerFrameRelease.argtypes = [NiteUserTrackerHandle, ctypes.POINTER(NiteUserTrackerFrame)] 656 | 657 | global _niteShutdownHandTracker 658 | _niteShutdownHandTracker = dll.niteShutdownHandTracker 659 | _niteShutdownHandTracker.restype = NiteStatus 660 | _niteShutdownHandTracker.argtypes = [NiteHandTrackerHandle] 661 | 662 | global _niteStartHandTracking 663 | _niteStartHandTracking = dll.niteStartHandTracking 664 | _niteStartHandTracking.restype = NiteStatus 665 | _niteStartHandTracking.argtypes = [NiteHandTrackerHandle, ctypes.POINTER(NitePoint3f), ctypes.POINTER(NiteHandId)] 666 | 667 | global _niteStopHandTracking 668 | _niteStopHandTracking = dll.niteStopHandTracking 669 | _niteStopHandTracking.restype = None 670 | _niteStopHandTracking.argtypes = [NiteHandTrackerHandle, NiteHandId] 671 | 672 | global _niteStopAllHandTracking 673 | _niteStopAllHandTracking = dll.niteStopAllHandTracking 674 | _niteStopAllHandTracking.restype = None 675 | _niteStopAllHandTracking.argtypes = [NiteHandTrackerHandle] 676 | 677 | global _niteSetHandSmoothingFactor 678 | _niteSetHandSmoothingFactor = dll.niteSetHandSmoothingFactor 679 | _niteSetHandSmoothingFactor.restype = NiteStatus 680 | _niteSetHandSmoothingFactor.argtypes = [NiteHandTrackerHandle, ctypes.c_float] 681 | 682 | global _niteGetHandSmoothingFactor 683 | _niteGetHandSmoothingFactor = dll.niteGetHandSmoothingFactor 684 | _niteGetHandSmoothingFactor.restype = NiteStatus 685 | _niteGetHandSmoothingFactor.argtypes = [NiteHandTrackerHandle, ctypes.POINTER(ctypes.c_float)] 686 | 687 | global _niteRegisterHandTrackerCallbacks 688 | _niteRegisterHandTrackerCallbacks = dll.niteRegisterHandTrackerCallbacks 689 | _niteRegisterHandTrackerCallbacks.restype = NiteStatus 690 | _niteRegisterHandTrackerCallbacks.argtypes = [NiteHandTrackerHandle, 691 | ctypes.POINTER(NiteHandTrackerCallbacks), ctypes.c_void_p] 692 | 693 | global _niteUnregisterHandTrackerCallbacks 694 | _niteUnregisterHandTrackerCallbacks = dll.niteUnregisterHandTrackerCallbacks 695 | _niteUnregisterHandTrackerCallbacks.restype = None 696 | _niteUnregisterHandTrackerCallbacks.argtypes = [NiteHandTrackerHandle, ctypes.POINTER(NiteHandTrackerCallbacks)] 697 | 698 | global _niteReadHandTrackerFrame 699 | _niteReadHandTrackerFrame = dll.niteReadHandTrackerFrame 700 | _niteReadHandTrackerFrame.restype = NiteStatus 701 | _niteReadHandTrackerFrame.argtypes = [NiteHandTrackerHandle, ctypes.POINTER(ctypes.POINTER(NiteHandTrackerFrame))] 702 | 703 | global _niteHandTrackerFrameAddRef 704 | _niteHandTrackerFrameAddRef = dll.niteHandTrackerFrameAddRef 705 | _niteHandTrackerFrameAddRef.restype = NiteStatus 706 | _niteHandTrackerFrameAddRef.argtypes = [NiteHandTrackerHandle, ctypes.POINTER(NiteHandTrackerFrame)] 707 | 708 | global _niteHandTrackerFrameRelease 709 | _niteHandTrackerFrameRelease = dll.niteHandTrackerFrameRelease 710 | _niteHandTrackerFrameRelease.restype = NiteStatus 711 | _niteHandTrackerFrameRelease.argtypes = [NiteHandTrackerHandle, ctypes.POINTER(NiteHandTrackerFrame)] 712 | 713 | global _niteStartGestureDetection 714 | _niteStartGestureDetection = dll.niteStartGestureDetection 715 | _niteStartGestureDetection.restype = NiteStatus 716 | _niteStartGestureDetection.argtypes = [NiteHandTrackerHandle, NiteGestureType] 717 | 718 | global _niteStopGestureDetection 719 | _niteStopGestureDetection = dll.niteStopGestureDetection 720 | _niteStopGestureDetection.restype = None 721 | _niteStopGestureDetection.argtypes = [NiteHandTrackerHandle, NiteGestureType] 722 | 723 | global _niteStopAllGestureDetection 724 | _niteStopAllGestureDetection = dll.niteStopAllGestureDetection 725 | _niteStopAllGestureDetection.restype = None 726 | _niteStopAllGestureDetection.argtypes = [NiteHandTrackerHandle] 727 | 728 | global _niteConvertJointCoordinatesToDepth 729 | _niteConvertJointCoordinatesToDepth = dll.niteConvertJointCoordinatesToDepth 730 | _niteConvertJointCoordinatesToDepth.restype = NiteStatus 731 | _niteConvertJointCoordinatesToDepth.argtypes = [NiteUserTrackerHandle, ctypes.c_float, 732 | ctypes.c_float, ctypes.c_float, ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float)] 733 | 734 | global _niteConvertDepthCoordinatesToJoint 735 | _niteConvertDepthCoordinatesToJoint = dll.niteConvertDepthCoordinatesToJoint 736 | _niteConvertDepthCoordinatesToJoint.restype = NiteStatus 737 | _niteConvertDepthCoordinatesToJoint.argtypes = [ 738 | NiteUserTrackerHandle, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float)] 739 | 740 | global _niteConvertHandCoordinatesToDepth 741 | _niteConvertHandCoordinatesToDepth = dll.niteConvertHandCoordinatesToDepth 742 | _niteConvertHandCoordinatesToDepth.restype = NiteStatus 743 | _niteConvertHandCoordinatesToDepth.argtypes = [NiteHandTrackerHandle, ctypes.c_float, 744 | ctypes.c_float, ctypes.c_float, ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float)] 745 | 746 | global _niteConvertDepthCoordinatesToHand 747 | _niteConvertDepthCoordinatesToHand = dll.niteConvertDepthCoordinatesToHand 748 | _niteConvertDepthCoordinatesToHand.restype = NiteStatus 749 | _niteConvertDepthCoordinatesToHand.argtypes = [ 750 | NiteHandTrackerHandle, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float)] 751 | 752 | global _niteInitializeUserTracker 753 | _niteInitializeUserTracker = dll.niteInitializeUserTracker 754 | _niteInitializeUserTracker.restype = NiteStatus 755 | _niteInitializeUserTracker.argtypes = [ctypes.POINTER(NiteUserTrackerHandle)] 756 | 757 | global _niteInitializeUserTrackerByDevice 758 | _niteInitializeUserTrackerByDevice = dll.niteInitializeUserTrackerByDevice 759 | _niteInitializeUserTrackerByDevice.restype = NiteStatus 760 | _niteInitializeUserTrackerByDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(NiteUserTrackerHandle)] 761 | 762 | global _niteInitializeHandTracker 763 | _niteInitializeHandTracker = dll.niteInitializeHandTracker 764 | _niteInitializeHandTracker.restype = NiteStatus 765 | _niteInitializeHandTracker.argtypes = [ctypes.POINTER(NiteHandTrackerHandle)] 766 | 767 | global _niteInitializeHandTrackerByDevice 768 | _niteInitializeHandTrackerByDevice = dll.niteInitializeHandTrackerByDevice 769 | _niteInitializeHandTrackerByDevice.restype = NiteStatus 770 | _niteInitializeHandTrackerByDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(NiteHandTrackerHandle)] 771 | 772 | _the_dll = dll 773 | 774 | 775 | import functools 776 | from openni.utils import NiteError 777 | 778 | 779 | def nite_call(func): 780 | @functools.wraps(func) 781 | def wrapper(*args): 782 | res = func(*args) 783 | if res != NiteStatus.NITE_STATUS_OK: 784 | raise NiteError(res) 785 | return res 786 | 787 | return wrapper 788 | 789 | 790 | @nite_call 791 | def niteInitialize(): 792 | '''NiteStatus niteInitialize()''' 793 | return _niteInitialize() 794 | 795 | 796 | def niteShutdown(): 797 | '''void niteShutdown()''' 798 | return _niteShutdown() 799 | 800 | 801 | def niteGetVersion(): 802 | '''NiteVersion niteGetVersion()''' 803 | return _niteGetVersion() 804 | 805 | 806 | @nite_call 807 | def niteShutdownUserTracker(userTracker): 808 | '''NiteStatus niteShutdownUserTracker(NiteUserTrackerHandle userTracker)''' 809 | return _niteShutdownUserTracker(userTracker) 810 | 811 | 812 | @nite_call 813 | def niteStartSkeletonTracking(userTracker, id): 814 | '''NiteStatus niteStartSkeletonTracking(NiteUserTrackerHandle userTracker, NiteUserId id)''' 815 | return _niteStartSkeletonTracking(userTracker, id) 816 | 817 | 818 | def niteStopSkeletonTracking(userTracker, id): 819 | '''void niteStopSkeletonTracking(NiteUserTrackerHandle userTracker, NiteUserId id)''' 820 | return _niteStopSkeletonTracking(userTracker, id) 821 | 822 | 823 | def niteIsSkeletonTracking(userTracker, id): 824 | '''bool niteIsSkeletonTracking(NiteUserTrackerHandle userTracker, NiteUserId id)''' 825 | return _niteIsSkeletonTracking(userTracker, id) 826 | 827 | 828 | @nite_call 829 | def niteSetSkeletonSmoothing(userTracker, factor): 830 | '''NiteStatus niteSetSkeletonSmoothing(NiteUserTrackerHandle userTracker, float factor)''' 831 | return _niteSetSkeletonSmoothing(userTracker, factor) 832 | 833 | 834 | @nite_call 835 | def niteGetSkeletonSmoothing(userTracker, pFactor): 836 | '''NiteStatus niteGetSkeletonSmoothing(NiteUserTrackerHandle userTracker, float* pFactor)''' 837 | return _niteGetSkeletonSmoothing(userTracker, pFactor) 838 | 839 | 840 | @nite_call 841 | def niteStartPoseDetection(userTracker, id, poseType): 842 | '''NiteStatus niteStartPoseDetection(NiteUserTrackerHandle userTracker, NiteUserId id, NitePoseType poseType)''' 843 | return _niteStartPoseDetection(userTracker, id, poseType) 844 | 845 | 846 | def niteStopPoseDetection(userTracker, id, poseType): 847 | '''void niteStopPoseDetection(NiteUserTrackerHandle userTracker, NiteUserId id, NitePoseType poseType)''' 848 | return _niteStopPoseDetection(userTracker, id, poseType) 849 | 850 | 851 | def niteStopAllPoseDetection(userTracker, id): 852 | '''void niteStopAllPoseDetection(NiteUserTrackerHandle userTracker, NiteUserId id)''' 853 | return _niteStopAllPoseDetection(userTracker, id) 854 | 855 | 856 | @nite_call 857 | def niteRegisterUserTrackerCallbacks(userTracker, pCallbacks, pCookie): 858 | '''NiteStatus niteRegisterUserTrackerCallbacks(NiteUserTrackerHandle userTracker, NiteUserTrackerCallbacks* pCallbacks, void* pCookie)''' 859 | return _niteRegisterUserTrackerCallbacks(userTracker, pCallbacks, pCookie) 860 | 861 | 862 | def niteUnregisterUserTrackerCallbacks(userTracker, pCallbacks): 863 | '''void niteUnregisterUserTrackerCallbacks(NiteUserTrackerHandle userTracker, NiteUserTrackerCallbacks* pCallbacks)''' 864 | return _niteUnregisterUserTrackerCallbacks(userTracker, pCallbacks) 865 | 866 | 867 | @nite_call 868 | def niteReadUserTrackerFrame(userTracker, pUserTrackerFrame): 869 | '''NiteStatus niteReadUserTrackerFrame(NiteUserTrackerHandle userTracker, NiteUserTrackerFrame** pUserTrackerFrame)''' 870 | return _niteReadUserTrackerFrame(userTracker, pUserTrackerFrame) 871 | 872 | 873 | @nite_call 874 | def niteUserTrackerFrameAddRef(userTracker, pUserTrackerFrame): 875 | '''NiteStatus niteUserTrackerFrameAddRef(NiteUserTrackerHandle userTracker, NiteUserTrackerFrame* pUserTrackerFrame)''' 876 | return _niteUserTrackerFrameAddRef(userTracker, pUserTrackerFrame) 877 | 878 | 879 | @nite_call 880 | def niteUserTrackerFrameRelease(userTracker, pUserTrackerFrame): 881 | '''NiteStatus niteUserTrackerFrameRelease(NiteUserTrackerHandle userTracker, NiteUserTrackerFrame* pUserTrackerFrame)''' 882 | return _niteUserTrackerFrameRelease(userTracker, pUserTrackerFrame) 883 | 884 | 885 | @nite_call 886 | def niteShutdownHandTracker(handTracker): 887 | '''NiteStatus niteShutdownHandTracker(NiteHandTrackerHandle handTracker)''' 888 | return _niteShutdownHandTracker(handTracker) 889 | 890 | 891 | @nite_call 892 | def niteStartHandTracking(handTracker, pPosition, pNewHandId): 893 | '''NiteStatus niteStartHandTracking(NiteHandTrackerHandle handTracker, NitePoint3f* pPosition, NiteHandId* pNewHandId)''' 894 | return _niteStartHandTracking(handTracker, pPosition, pNewHandId) 895 | 896 | 897 | def niteStopHandTracking(handTracker, id): 898 | '''void niteStopHandTracking(NiteHandTrackerHandle handTracker, NiteHandId id)''' 899 | return _niteStopHandTracking(handTracker, id) 900 | 901 | 902 | def niteStopAllHandTracking(handTracker): 903 | '''void niteStopAllHandTracking(NiteHandTrackerHandle handTracker)''' 904 | return _niteStopAllHandTracking(handTracker) 905 | 906 | 907 | @nite_call 908 | def niteSetHandSmoothingFactor(handTracker, factor): 909 | '''NiteStatus niteSetHandSmoothingFactor(NiteHandTrackerHandle handTracker, float factor)''' 910 | return _niteSetHandSmoothingFactor(handTracker, factor) 911 | 912 | 913 | @nite_call 914 | def niteGetHandSmoothingFactor(handTracker, pFactor): 915 | '''NiteStatus niteGetHandSmoothingFactor(NiteHandTrackerHandle handTracker, float* pFactor)''' 916 | return _niteGetHandSmoothingFactor(handTracker, pFactor) 917 | 918 | 919 | @nite_call 920 | def niteRegisterHandTrackerCallbacks(handTracker, pCallbacks, pCookie): 921 | '''NiteStatus niteRegisterHandTrackerCallbacks(NiteHandTrackerHandle handTracker, NiteHandTrackerCallbacks* pCallbacks, void* pCookie)''' 922 | return _niteRegisterHandTrackerCallbacks(handTracker, pCallbacks, pCookie) 923 | 924 | 925 | def niteUnregisterHandTrackerCallbacks(handTracker, pCallbacks): 926 | '''void niteUnregisterHandTrackerCallbacks(NiteHandTrackerHandle handTracker, NiteHandTrackerCallbacks* pCallbacks)''' 927 | return _niteUnregisterHandTrackerCallbacks(handTracker, pCallbacks) 928 | 929 | 930 | @nite_call 931 | def niteReadHandTrackerFrame(handTracker, pHandTrackerFrame): 932 | '''NiteStatus niteReadHandTrackerFrame(NiteHandTrackerHandle handTracker, NiteHandTrackerFrame** pHandTrackerFrame)''' 933 | return _niteReadHandTrackerFrame(handTracker, pHandTrackerFrame) 934 | 935 | 936 | @nite_call 937 | def niteHandTrackerFrameAddRef(handTracker, pHandTrackerFrame): 938 | '''NiteStatus niteHandTrackerFrameAddRef(NiteHandTrackerHandle handTracker, NiteHandTrackerFrame* pHandTrackerFrame)''' 939 | return _niteHandTrackerFrameAddRef(handTracker, pHandTrackerFrame) 940 | 941 | 942 | @nite_call 943 | def niteHandTrackerFrameRelease(handTracker, pHandTrackerFrame): 944 | '''NiteStatus niteHandTrackerFrameRelease(NiteHandTrackerHandle handTracker, NiteHandTrackerFrame* pHandTrackerFrame)''' 945 | return _niteHandTrackerFrameRelease(handTracker, pHandTrackerFrame) 946 | 947 | 948 | @nite_call 949 | def niteStartGestureDetection(handTracker, type): 950 | '''NiteStatus niteStartGestureDetection(NiteHandTrackerHandle handTracker, NiteGestureType type)''' 951 | return _niteStartGestureDetection(handTracker, type) 952 | 953 | 954 | def niteStopGestureDetection(handTracker, type): 955 | '''void niteStopGestureDetection(NiteHandTrackerHandle handTracker, NiteGestureType type)''' 956 | return _niteStopGestureDetection(handTracker, type) 957 | 958 | 959 | def niteStopAllGestureDetection(handTracker): 960 | '''void niteStopAllGestureDetection(NiteHandTrackerHandle handTracker)''' 961 | return _niteStopAllGestureDetection(handTracker) 962 | 963 | 964 | @nite_call 965 | def niteConvertJointCoordinatesToDepth(userTracker, x, y, z, pX, pY): 966 | '''NiteStatus niteConvertJointCoordinatesToDepth(NiteUserTrackerHandle userTracker, float x, float y, float z, float* pX, float* pY)''' 967 | return _niteConvertJointCoordinatesToDepth(userTracker, x, y, z, pX, pY) 968 | 969 | 970 | @nite_call 971 | def niteConvertDepthCoordinatesToJoint(userTracker, x, y, z, pX, pY): 972 | '''NiteStatus niteConvertDepthCoordinatesToJoint(NiteUserTrackerHandle userTracker, int x, int y, int z, float* pX, float* pY)''' 973 | return _niteConvertDepthCoordinatesToJoint(userTracker, x, y, z, pX, pY) 974 | 975 | 976 | @nite_call 977 | def niteConvertHandCoordinatesToDepth(handTracker, x, y, z, pX, pY): 978 | '''NiteStatus niteConvertHandCoordinatesToDepth(NiteHandTrackerHandle handTracker, float x, float y, float z, float* pX, float* pY)''' 979 | return _niteConvertHandCoordinatesToDepth(handTracker, x, y, z, pX, pY) 980 | 981 | 982 | @nite_call 983 | def niteConvertDepthCoordinatesToHand(handTracker, x, y, z, pX, pY): 984 | '''NiteStatus niteConvertDepthCoordinatesToHand(NiteHandTrackerHandle handTracker, int x, int y, int z, float* pX, float* pY)''' 985 | return _niteConvertDepthCoordinatesToHand(handTracker, x, y, z, pX, pY) 986 | 987 | 988 | @nite_call 989 | def niteInitializeUserTracker(pUserTracker): 990 | '''NiteStatus niteInitializeUserTracker(NiteUserTrackerHandle* pUserTracker)''' 991 | return _niteInitializeUserTracker(pUserTracker) 992 | 993 | 994 | @nite_call 995 | def niteInitializeUserTrackerByDevice(pDevice, pUserTracker): 996 | '''NiteStatus niteInitializeUserTrackerByDevice(void* pDevice, NiteUserTrackerHandle* pUserTracker)''' 997 | return _niteInitializeUserTrackerByDevice(pDevice, pUserTracker) 998 | 999 | 1000 | @nite_call 1001 | def niteInitializeHandTracker(pHandTracker): 1002 | '''NiteStatus niteInitializeHandTracker(NiteHandTrackerHandle* pHandTracker)''' 1003 | return _niteInitializeHandTracker(pHandTracker) 1004 | 1005 | 1006 | @nite_call 1007 | def niteInitializeHandTrackerByDevice(pDevice, pHandTracker): 1008 | '''NiteStatus niteInitializeHandTrackerByDevice(void* pDevice, NiteHandTrackerHandle* pHandTracker)''' 1009 | return _niteInitializeHandTrackerByDevice(pDevice, pHandTracker) 1010 | 1011 | 1012 | all_types = [ 1013 | OniStatus, 1014 | OniSensorType, 1015 | OniPixelFormat, 1016 | OniDeviceState, 1017 | OniImageRegistrationMode, 1018 | _anon_enum_5, 1019 | OniBool, 1020 | OniCallbackHandleImpl, 1021 | OniCallbackHandle, 1022 | OniVersion, 1023 | OniHardwareVersion, 1024 | OniVideoMode, 1025 | OniSensorInfo, 1026 | OniDeviceInfo, 1027 | _OniDevice, 1028 | OniDeviceHandle, 1029 | _OniStream, 1030 | OniStreamHandle, 1031 | _OniRecorder, 1032 | OniRecorderHandle, 1033 | OniFrame, 1034 | OniNewFrameCallback, 1035 | OniGeneralCallback, 1036 | OniDeviceInfoCallback, 1037 | OniDeviceStateCallback, 1038 | OniFrameAllocBufferCallback, 1039 | OniFrameFreeBufferCallback, 1040 | OniDeviceCallbacks, 1041 | OniCropping, 1042 | OniDepthPixel, 1043 | OniGrayscale16Pixel, 1044 | OniGrayscale8Pixel, 1045 | OniRGB888Pixel, 1046 | OniYUV422DoublePixel, 1047 | OniSeek, 1048 | NiteJointType, 1049 | NiteSkeletonState, 1050 | NiteUserState, 1051 | NiteStatus, 1052 | NitePoseType, 1053 | NitePoseState, 1054 | NiteGestureType, 1055 | NiteGestureState, 1056 | NiteHandState, 1057 | NiteUserId, 1058 | NiteUserTracker, 1059 | NiteUserTrackerHandle, 1060 | NitePoint3f, 1061 | NiteQuaternion, 1062 | NiteSkeletonJoint, 1063 | NiteBoundingBox, 1064 | NitePoseData, 1065 | NiteSkeleton, 1066 | NiteUserData, 1067 | NiteUserMap, 1068 | NitePlane, 1069 | NiteUserTrackerFrame, 1070 | NiteUserTrackerCallbacks, 1071 | NiteHandId, 1072 | NiteHandData, 1073 | NiteGestureData, 1074 | NiteHandTrackerFrame, 1075 | NiteHandTrackerCallbacks, 1076 | NiteVersion, 1077 | NiteHandTracker, 1078 | NiteHandTrackerHandle, 1079 | ] 1080 | 1081 | all_funcs = [ 1082 | niteInitialize, 1083 | niteShutdown, 1084 | niteGetVersion, 1085 | niteShutdownUserTracker, 1086 | niteStartSkeletonTracking, 1087 | niteStopSkeletonTracking, 1088 | niteIsSkeletonTracking, 1089 | niteSetSkeletonSmoothing, 1090 | niteGetSkeletonSmoothing, 1091 | niteStartPoseDetection, 1092 | niteStopPoseDetection, 1093 | niteStopAllPoseDetection, 1094 | niteRegisterUserTrackerCallbacks, 1095 | niteUnregisterUserTrackerCallbacks, 1096 | niteReadUserTrackerFrame, 1097 | niteUserTrackerFrameAddRef, 1098 | niteUserTrackerFrameRelease, 1099 | niteShutdownHandTracker, 1100 | niteStartHandTracking, 1101 | niteStopHandTracking, 1102 | niteStopAllHandTracking, 1103 | niteSetHandSmoothingFactor, 1104 | niteGetHandSmoothingFactor, 1105 | niteRegisterHandTrackerCallbacks, 1106 | niteUnregisterHandTrackerCallbacks, 1107 | niteReadHandTrackerFrame, 1108 | niteHandTrackerFrameAddRef, 1109 | niteHandTrackerFrameRelease, 1110 | niteStartGestureDetection, 1111 | niteStopGestureDetection, 1112 | niteStopAllGestureDetection, 1113 | niteConvertJointCoordinatesToDepth, 1114 | niteConvertDepthCoordinatesToJoint, 1115 | niteConvertHandCoordinatesToDepth, 1116 | niteConvertDepthCoordinatesToHand, 1117 | niteInitializeUserTracker, 1118 | niteInitializeUserTrackerByDevice, 1119 | niteInitializeHandTracker, 1120 | niteInitializeHandTrackerByDevice, 1121 | ] 1122 | -------------------------------------------------------------------------------- /openni/nite2.py: -------------------------------------------------------------------------------- 1 | # pylint: disable=W0212,W0603 2 | 3 | import sys 4 | import os 5 | import weakref 6 | import atexit 7 | import ctypes 8 | import platform 9 | from openni import _nite2 as c_api 10 | from openni import openni2 11 | from openni.utils import inherit_properties, ClosedHandle, HandleObject, InitializationError 12 | 13 | from openni._nite2 import NiteJointType as JointType 14 | from openni._nite2 import NiteSkeletonState as SkeletonState 15 | from openni._nite2 import NiteUserState as UserState 16 | from openni._nite2 import NitePoseType as PoseType 17 | from openni._nite2 import NiteGestureType as GestureType 18 | 19 | arch = int(platform.architecture()[0].lower().replace("bit", "")) 20 | 21 | _default_dll_directories = [] 22 | if arch == 32: 23 | if "NITE2_REDIST" in os.environ: 24 | _default_dll_directories.append(os.environ["NITE2_REDIST"]) 25 | elif arch == 64: 26 | if "NITE2_REDIST64" in os.environ: 27 | _default_dll_directories.append(os.environ["NITE2_REDIST64"]) 28 | elif "NITE2_REDIST" in os.environ: 29 | _default_dll_directories.append(os.environ["NITE2_REDIST"]) 30 | 31 | _default_dll_directories.append(".") 32 | 33 | if sys.platform == "win32": 34 | _dll_name = "NiTE2.dll" 35 | elif sys.platform == "darwin": 36 | _dll_name = "libNiTE2.dylib" 37 | else: 38 | _dll_name = "libNiTE2.so" 39 | 40 | 41 | _nite2_initialized = False 42 | loaded_dll_directory = None 43 | 44 | 45 | def initialize(dll_directories=_default_dll_directories): 46 | global _nite2_initialized 47 | global loaded_dll_directory 48 | if _nite2_initialized: 49 | return 50 | if isinstance(dll_directories, str): 51 | dll_directories = [dll_directories] 52 | 53 | if not openni2.is_initialized(): 54 | openni2.initialize() 55 | 56 | if loaded_dll_directory: 57 | c_api.niteInitialize() 58 | _nite2_initialized = True 59 | return 60 | 61 | found = False 62 | prev = os.getcwd() 63 | exceptions = [] 64 | dll_directories = [os.path.normpath(os.path.abspath(d)) for d in dll_directories] 65 | 66 | for dlldir in dll_directories: 67 | if not os.path.isdir(dlldir): 68 | exceptions.append((dlldir, "Directory does not exist")) 69 | continue 70 | fullpath = os.path.join(dlldir, _dll_name) 71 | if not os.path.isfile(fullpath): 72 | exceptions.append((fullpath, "file does not exist")) 73 | continue 74 | try: 75 | os.chdir(dlldir) 76 | c_api.load_dll(fullpath) 77 | c_api.niteInitialize() 78 | except Exception as ex: 79 | exceptions.append((fullpath, ex)) 80 | else: 81 | found = True 82 | loaded_dll_directory = dlldir 83 | break 84 | 85 | os.chdir(prev) 86 | if not found: 87 | raise InitializationError("NiTE2 could not be loaded:\n %s" % 88 | ("\n ".join("%s: %s" % (dir, ex) for dir, ex in exceptions)),) 89 | 90 | _nite2_initialized = True 91 | 92 | 93 | def is_initialized(): 94 | return _nite2_initialized 95 | 96 | 97 | _registered_user_trackers = weakref.WeakSet() 98 | _registered_user_tracker_frames = weakref.WeakSet() 99 | _registered_hand_trackers = weakref.WeakSet() 100 | _registered_hand_tracker_frames = weakref.WeakSet() 101 | _registered_user_tracker_listeners = weakref.WeakSet() 102 | _registered_hand_tracker_listeners = weakref.WeakSet() 103 | 104 | 105 | def unload(): 106 | global _nite2_initialized 107 | if not _nite2_initialized: 108 | return 109 | for coll in [_registered_user_tracker_frames, _registered_hand_tracker_frames, _registered_hand_trackers, 110 | _registered_user_trackers, _registered_user_tracker_listeners, _registered_hand_tracker_listeners]: 111 | for hndl in coll: 112 | hndl.close() 113 | coll.clear() 114 | 115 | _nite2_initialized = False 116 | c_api.niteShutdown() 117 | 118 | 119 | atexit.register(unload) 120 | 121 | 122 | def get_version(): 123 | return c_api.niteGetVersion() 124 | 125 | 126 | Point3f = c_api.NitePoint3f 127 | Plane = c_api.NitePlane 128 | Quaternion = c_api.NiteQuaternion 129 | BoundingBox = c_api.NiteBoundingBox 130 | UserId = c_api.NiteUserId 131 | HandId = c_api.NiteHandId 132 | UserMap = c_api.NiteUserMap 133 | SkeletonJoint = c_api.NiteSkeletonJoint 134 | 135 | 136 | @inherit_properties(c_api.NitePoseData, "_posedata") 137 | class PoseData(object): 138 | __slots__ = ["_posedata"] 139 | 140 | def __init__(self, posedata): 141 | self._posedata = posedata 142 | 143 | def is_held(self): 144 | return self.state == c_api.NitePoseState.NITE_POSE_STATE_IN_POSE 145 | 146 | def is_entered(self): 147 | return self.state == c_api.NitePoseState.NITE_POSE_STATE_ENTER 148 | 149 | def is_exited(self): 150 | return self.state == c_api.NitePoseState.NITE_POSE_STATE_EXIT 151 | 152 | 153 | @inherit_properties(c_api.NiteSkeleton, "_skeleton") 154 | class Skeleton(object): 155 | __slots__ = ["_skeleton"] 156 | 157 | def __init__(self, skeleton): 158 | self._skeleton = skeleton 159 | 160 | def get_joint(self, jointtype): 161 | return self.joints[jointtype] 162 | 163 | 164 | @inherit_properties(c_api.NiteUserData, "_userdata") 165 | class UserData(object): 166 | __slots__ = ["_userdata"] 167 | 168 | def __init__(self, userdata): 169 | self._userdata = userdata 170 | 171 | def is_new(self): 172 | return self.state == c_api.NiteUserState.NITE_USER_STATE_NEW 173 | 174 | def is_visible(self): 175 | return self.state == c_api.NiteUserState.NITE_USER_STATE_VISIBLE 176 | 177 | def is_lost(self): 178 | return self.state == c_api.NiteUserState.NITE_USER_STATE_LOST 179 | 180 | def get_pose(self, posetype): 181 | return PoseData(self.poses[posetype]) 182 | 183 | 184 | @inherit_properties(c_api.NiteUserTrackerFrame, "_frame") 185 | class UserTrackerFrame(HandleObject): 186 | __slots__ = ["_frame", "_user_tracker_handle", "_depth_frame", "users", "users_by_id", "__weakref__"] 187 | 188 | def __init__(self, pframe, user_tracker_handle): 189 | self._frame = pframe[0] 190 | self._user_tracker_handle = user_tracker_handle 191 | self._depth_frame = None 192 | c_api.niteUserTrackerFrameAddRef(user_tracker_handle, pframe) 193 | HandleObject.__init__(self, pframe) 194 | self.users = [] 195 | self.users_by_id = {} 196 | for i in range(self.userCount): 197 | u = UserData(self.pUser[i]) 198 | self.users.append(u) 199 | self.users_by_id[u.id] = u 200 | _registered_user_tracker_frames.add(self) 201 | 202 | def _close(self): 203 | if is_initialized(): 204 | c_api.niteUserTrackerFrameRelease(self._user_tracker_handle, self._handle) 205 | self._frame = ClosedHandle 206 | self._user_tracker_handle = ClosedHandle 207 | del self.users[:] 208 | 209 | def get_depth_frame(self): 210 | if self._depth_frame is None: 211 | self._depth_frame = openni2.VideoFrame(self.pDepthFrame) 212 | return self._depth_frame 213 | 214 | 215 | class _NiteDevStruct(ctypes.Structure): 216 | """ 217 | PlaybackControl* m_pPlaybackControl; 218 | 219 | OniDeviceHandle m_device; 220 | DeviceInfo m_deviceInfo; 221 | SensorInfo m_aSensorInfo[ONI_MAX_SENSORS]; 222 | 223 | bool m_isOwner; 224 | """ 225 | 226 | _fields_ = [ 227 | ("pPlaybackControl", ctypes.c_void_p), 228 | ("device", openni2.c_api.OniDeviceHandle), 229 | 230 | ("device_info", openni2.c_api.OniDeviceInfo), 231 | ("sensor_info", openni2.c_api.OniSensorInfo * 10), 232 | 233 | ("is_owner", ctypes.c_bool) 234 | ] 235 | 236 | 237 | class UserTracker(HandleObject): 238 | def __init__(self, device): 239 | handle = c_api.NiteUserTrackerHandle() 240 | if not device: 241 | c_api.niteInitializeUserTracker(ctypes.byref(handle)) 242 | else: 243 | self._devstruct = _NiteDevStruct() 244 | self._devstruct.pPlaybackControl = None 245 | self._devstruct.device = device._handle 246 | self._devstruct.device_info = device.get_device_info() 247 | # self._devstruct.sensor_info = device.get_sensor_infos(sensor_type) 248 | self._devstruct.is_owner = True 249 | c_api.niteInitializeUserTrackerByDevice(ctypes.byref(self._devstruct), ctypes.byref(handle)) 250 | 251 | HandleObject.__init__(self, handle) 252 | _registered_user_trackers.add(self) 253 | 254 | @classmethod 255 | def open_any(cls): 256 | return UserTracker(None) 257 | 258 | def _close(self): 259 | if is_initialized(): 260 | c_api.niteShutdownUserTracker(self._handle) 261 | 262 | def read_frame(self): 263 | pnf = ctypes.POINTER(c_api.NiteUserTrackerFrame)() 264 | c_api.niteReadUserTrackerFrame(self._handle, ctypes.byref(pnf)) 265 | return UserTrackerFrame(pnf, self._handle) 266 | 267 | def set_skeleton_smoothing_factor(self, factor): 268 | return c_api.niteSetSkeletonSmoothing(self._handle, factor) 269 | 270 | def get_skeleton_smoothing_factor(self): 271 | factor = ctypes.c_float() 272 | c_api.niteGetSkeletonSmoothing(self._handle, ctypes.byref(factor)) 273 | return factor.value 274 | skeleton_smoothing_factor = property(get_skeleton_smoothing_factor, set_skeleton_smoothing_factor) 275 | 276 | def start_skeleton_tracking(self, userid): 277 | c_api.niteStartSkeletonTracking(self._handle, userid) 278 | 279 | def stop_skeleton_tracking(self, userid): 280 | c_api.niteStopSkeletonTracking(self._handle, userid) 281 | 282 | def is_tracking(self, userid): 283 | c_api.niteIsSkeletonTracking(self._handle, userid) 284 | 285 | def start_pose_detection(self, userid, posetype): 286 | c_api.niteStartPoseDetection(self._handle, userid, posetype) 287 | 288 | def stop_pose_detection(self, userid, posetype): 289 | c_api.niteStopPoseDetection(self._handle, userid, posetype) 290 | 291 | def stop_all_pose_detection(self, userid): 292 | c_api.niteStopAllPoseDetection(self._handle, userid) 293 | 294 | def convert_joint_coordinates_to_depth(self, x, y, z): 295 | outX = ctypes.c_float() 296 | outY = ctypes.c_float() 297 | c_api.niteConvertJointCoordinatesToDepth(self._handle, x, y, z, ctypes.byref(outX), ctypes.byref(outY)) 298 | return (outX.value, outY.value) 299 | 300 | def convert_depth_coordinates_to_joint(self, x, y, z): 301 | outX = ctypes.c_float() 302 | outY = ctypes.c_float() 303 | c_api.niteConvertDepthCoordinatesToJoint(self._handle, x, y, z, ctypes.byref(outX), ctypes.byref(outY)) 304 | return (outX.value, outY.value) 305 | 306 | 307 | @inherit_properties(c_api.NiteGestureData, "_gesture") 308 | class GestureData(object): 309 | def __init__(self, gesture): 310 | self._gesture = gesture 311 | 312 | def is_complete(self): 313 | return self.state == c_api.NiteGestureState.NITE_GESTURE_STATE_COMPLETED 314 | 315 | def is_in_progress(self): 316 | return self.state == c_api.NiteGestureState.NITE_GESTURE_STATE_IN_PROGRESS 317 | 318 | 319 | @inherit_properties(c_api.NiteHandData, "_handdata") 320 | class HandData(object): 321 | def __init__(self, handdata): 322 | self._handdata = handdata 323 | 324 | def is_new(self): 325 | return self.state == c_api.NiteHandState.NITE_HAND_STATE_NEW 326 | 327 | def is_lost(self): 328 | return self.state == c_api.NiteHandState.NITE_HAND_STATE_LOST 329 | 330 | def is_tracking(self): 331 | return self.state == c_api.NiteHandState.NITE_HAND_STATE_TRACKED 332 | 333 | def is_touching_fov(self): 334 | return self.state == c_api.NiteHandState.NITE_HAND_STATE_TOUCHING_FOV 335 | 336 | 337 | @inherit_properties(c_api.NiteHandTrackerFrame, "_frame") 338 | class HandTrackerFrame(HandleObject): 339 | def __init__(self, hand_tracker_handle, pframe): 340 | self._hand_tracker_handle = hand_tracker_handle 341 | self._frame = pframe[0] 342 | c_api.niteHandTrackerFrameAddRef(hand_tracker_handle, pframe) 343 | HandleObject.__init__(self, pframe) 344 | self._depth_frame = None 345 | self._hands = None 346 | self._gestures = None 347 | _registered_hand_tracker_frames.add(self) 348 | 349 | def _close(self): 350 | if is_initialized(): 351 | c_api.niteHandTrackerFrameRelease(self._hand_tracker_handle, self._handle) 352 | 353 | @property 354 | def depth_frame(self): 355 | if self._depth_frame is None: 356 | self._depth_frame = openni2.VideoFrame(self._frame.pDepthFrame) 357 | return self._depth_frame 358 | 359 | @property 360 | def hands(self): 361 | if self._hands is None: 362 | self._hands = [self._frame.pHands[i] for i in range(self._frame.handCount)] 363 | return self._hands 364 | 365 | @property 366 | def gestures(self): 367 | if self._gestures is None: 368 | self._gestures = [self._frame.pGestures[i] for i in range(self._frame.gestureCount)] 369 | return self._gestures 370 | 371 | 372 | class HandTracker(HandleObject): 373 | def __init__(self, device): 374 | self.device = device 375 | handle = c_api.NiteHandTrackerHandle() 376 | if not device: 377 | c_api.niteInitializeHandTracker(ctypes.byref(handle)) 378 | else: 379 | self._devstruct = _NiteDevStruct() 380 | self._devstruct.device = device._handle 381 | c_api.niteInitializeHandTrackerByDevice(ctypes.byref(self._devstruct), ctypes.byref(handle)) 382 | HandleObject.__init__(self, handle) 383 | _registered_hand_trackers.add(self) 384 | 385 | @classmethod 386 | def open_any(cls): 387 | return cls(None) 388 | 389 | def _close(self): 390 | if is_initialized(): 391 | c_api.niteShutdownHandTracker(self._handle) 392 | 393 | def read_frame(self): 394 | pfrm = ctypes.POINTER(c_api.NiteHandTrackerFrame)() 395 | c_api.niteReadHandTrackerFrame(self._handle, ctypes.byref(pfrm)) 396 | return HandTrackerFrame(self._handle, pfrm) 397 | 398 | def set_smoothing_factor(self, factor): 399 | c_api.niteSetHandSmoothingFactor(self._handle, factor) 400 | 401 | def get_smoothing_factor(self): 402 | factor = ctypes.c_float() 403 | c_api.niteGetHandSmoothingFactor(self._handle, ctypes.byref(factor)) 404 | return factor.value 405 | smoothing_factor = property(get_smoothing_factor, set_smoothing_factor) 406 | 407 | def start_hand_tracking(self, *position): 408 | new_hand_id = HandId() 409 | if len(position) == 3: 410 | position = Point3f(*position) 411 | elif len(position) == 1: 412 | position = position[0] 413 | else: 414 | raise TypeError("Either Point3f or three values required") 415 | c_api.niteStartHandTracking(self._handle, ctypes.byref(position), ctypes.byref(new_hand_id)) 416 | return new_hand_id 417 | 418 | def stop_hand_tracking(self, handid): 419 | c_api.niteStopHandTracking(self._handle, handid) 420 | 421 | def start_gesture_detection(self, gesture_type): 422 | c_api.niteStartGestureDetection(self._handle, gesture_type) 423 | 424 | def stop_gesture_detection(self, gesture_type): 425 | c_api.niteStopGestureDetection(self._handle, gesture_type) 426 | 427 | def convert_hand_coordinates_to_depth(self, x, y, z): 428 | outX = ctypes.c_float() 429 | outY = ctypes.c_float() 430 | c_api.niteConvertHandCoordinatesToDepth(self._handle, x, y, z, ctypes.byref(outX), ctypes.byref(outY)) 431 | return outX.value, outY.value 432 | 433 | def convert_depth_coordinates_to_hand(self, x, y, z): 434 | outX = ctypes.c_float() 435 | outY = ctypes.c_float() 436 | c_api.niteConvertDepthCoordinatesToHand(self._handle, x, y, z, ctypes.byref(outX), ctypes.byref(outY)) 437 | return outX.value, outY.value 438 | 439 | def stop_all_hand_tracking(self): 440 | c_api.niteStopAllHandTracking(self._handle) 441 | 442 | def stop_all_gesture_detection(self): 443 | c_api.niteStopAllGestureDetection(self._handle) 444 | 445 | 446 | class UserTrackerListener(HandleObject): 447 | def __init__(self, user_tracker): 448 | self.user_tracker = user_tracker 449 | self._callbacks = c_api.NiteUserTrackerCallbacks( 450 | readyForNextFrame=c_api.OniGeneralCallback(self._on_ready_for_next_frame)) 451 | handle = ctypes.pointer(self._callbacks) 452 | c_api.niteRegisterUserTrackerCallbacks(self.user_tracker._handle, handle, None) 453 | HandleObject.__init__(self, handle) 454 | _registered_user_tracker_listeners.add(self) 455 | 456 | def unregister(self): 457 | self.close() 458 | 459 | def _close(self): 460 | if is_initialized(): 461 | c_api.niteUnregisterUserTrackerCallbacks(self.user_tracker._handle, self._handle) 462 | self.user_tracker = None 463 | 464 | def _on_ready_for_next_frame(self, _): 465 | self.on_ready_for_next_frame() 466 | 467 | def on_ready_for_next_frame(self): 468 | """Implement me""" 469 | pass 470 | 471 | 472 | class HandTrackerListener(HandleObject): 473 | def __init__(self, hand_tracker): 474 | self.hand_tracker = hand_tracker 475 | self._callbacks = c_api.NiteHandTrackerCallbacks( 476 | readyForNextFrame=c_api.OniGeneralCallback(self._on_ready_for_next_frame)) 477 | handle = ctypes.pointer(self._callbacks) 478 | c_api.niteRegisterHandTrackerCallbacks(self.hand_tracker._handle, handle, None) 479 | HandleObject.__init__(self, handle) 480 | _registered_hand_tracker_listeners.add(self) 481 | 482 | def _close(self): 483 | if is_initialized(): 484 | c_api.niteUnregisterHandTrackerCallbacks(self.hand_tracker._handle, self._handle) 485 | self.hand_tracker = None 486 | 487 | def _on_ready_for_next_frame(self, _): 488 | self.on_ready_for_next_frame() 489 | 490 | def on_ready_for_next_frame(self): 491 | """Implement me""" 492 | pass 493 | -------------------------------------------------------------------------------- /openni/openni2.py: -------------------------------------------------------------------------------- 1 | # pylint: disable=W0212,W0603 2 | 3 | import sys 4 | import os 5 | import ctypes 6 | import weakref 7 | import atexit 8 | import platform 9 | from openni import _openni2 as c_api 10 | from openni.utils import (inherit_properties, HandleObject, _py_to_ctype_obj, ClosedHandle, InitializationError, 11 | OpenNIError) 12 | 13 | 14 | arch = int(platform.architecture()[0].lower().replace("bit", "")) 15 | 16 | _default_dll_directories = [] 17 | if arch == 32: 18 | if "OPENNI2_REDIST" in os.environ: 19 | _default_dll_directories.append(os.environ["OPENNI2_REDIST"]) 20 | elif arch == 64: 21 | if "OPENNI2_REDIST64" in os.environ: 22 | _default_dll_directories.append(os.environ["OPENNI2_REDIST64"]) 23 | elif "OPENNI2_REDIST" in os.environ: 24 | _default_dll_directories.append(os.environ["OPENNI2_REDIST"]) 25 | 26 | _default_dll_directories.append(".") 27 | 28 | if sys.platform == "win32": 29 | _dll_name = "OpenNI2.dll" 30 | elif sys.platform == "darwin": 31 | _dll_name = "libOpenNI2.dylib" 32 | else: # GNU/Linux, *BSD, etc 33 | _default_dll_directories += [ 34 | "/lib", 35 | "/usr/lib", 36 | "/usr/local/lib", 37 | ] 38 | if arch == 64: 39 | _default_dll_directories.append("/lib64") 40 | _dll_name = "libOpenNI2.so" 41 | 42 | 43 | SENSOR_IR = c_api.OniSensorType.ONI_SENSOR_IR 44 | SENSOR_COLOR = c_api.OniSensorType.ONI_SENSOR_COLOR 45 | SENSOR_DEPTH = c_api.OniSensorType.ONI_SENSOR_DEPTH 46 | 47 | PIXEL_FORMAT_DEPTH_1_MM = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_DEPTH_1_MM 48 | PIXEL_FORMAT_DEPTH_100_UM = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_DEPTH_100_UM 49 | PIXEL_FORMAT_SHIFT_9_2 = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_SHIFT_9_2 50 | PIXEL_FORMAT_SHIFT_9_3 = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_SHIFT_9_3 51 | PIXEL_FORMAT_RGB888 = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_RGB888 52 | PIXEL_FORMAT_YUV422 = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_YUV422 53 | PIXEL_FORMAT_GRAY8 = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_GRAY8 54 | PIXEL_FORMAT_GRAY16 = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_GRAY16 55 | PIXEL_FORMAT_JPEG = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_JPEG 56 | PIXEL_FORMAT_YUYV = c_api.OniPixelFormat.ONI_PIXEL_FORMAT_YUYV 57 | 58 | IMAGE_REGISTRATION_DEPTH_TO_COLOR = c_api.OniImageRegistrationMode.ONI_IMAGE_REGISTRATION_DEPTH_TO_COLOR 59 | IMAGE_REGISTRATION_OFF = c_api.OniImageRegistrationMode.ONI_IMAGE_REGISTRATION_OFF 60 | 61 | 62 | _openni2_initialized = False 63 | loaded_dll_directory = None 64 | 65 | 66 | def initialize(dll_directories=_default_dll_directories): 67 | global _openni2_initialized 68 | global loaded_dll_directory 69 | if _openni2_initialized: 70 | return 71 | if isinstance(dll_directories, str): 72 | dll_directories = [dll_directories] 73 | if loaded_dll_directory: 74 | c_api.oniInitialize(c_api.ONI_API_VERSION) 75 | _openni2_initialized = True 76 | return 77 | 78 | found = False 79 | prev = os.getcwd() 80 | exceptions = [] 81 | dll_directories = [os.path.normpath(os.path.abspath(d)) for d in dll_directories] 82 | 83 | for dlldir in dll_directories: 84 | if not os.path.isdir(dlldir): 85 | exceptions.append((dlldir, "Directory does not exist")) 86 | continue 87 | fullpath = os.path.join(dlldir, _dll_name) 88 | if not os.path.isfile(fullpath): 89 | exceptions.append((fullpath, "file does not exist")) 90 | continue 91 | try: 92 | os.chdir(dlldir) 93 | c_api.load_dll(fullpath) 94 | c_api.oniInitialize(c_api.ONI_API_VERSION) 95 | except Exception as ex: 96 | exceptions.append((fullpath, ex)) 97 | else: 98 | found = True 99 | loaded_dll_directory = dlldir 100 | break 101 | 102 | os.chdir(prev) 103 | if not found: 104 | raise InitializationError("OpenNI2 could not be loaded:\n %s" % 105 | ("\n ".join("%s: %s" % (dir, ex) for dir, ex in exceptions)),) 106 | 107 | _openni2_initialized = True 108 | 109 | 110 | def is_initialized(): 111 | return _openni2_initialized 112 | 113 | 114 | _registered_devices = weakref.WeakSet() 115 | _registered_video_frames = weakref.WeakSet() 116 | _registered_video_streams = weakref.WeakSet() 117 | _registered_recorders = weakref.WeakSet() 118 | _registered_device_listeners = weakref.WeakSet() 119 | 120 | 121 | def unload(): 122 | global _openni2_initialized 123 | if not _openni2_initialized: 124 | return 125 | for coll in [_registered_video_frames, _registered_recorders, _registered_video_streams, _registered_device_listeners, 126 | _registered_devices]: 127 | for hndl in coll: 128 | hndl.close() 129 | coll.clear() 130 | 131 | _openni2_initialized = False 132 | c_api.oniShutdown() 133 | 134 | 135 | atexit.register(unload) 136 | 137 | 138 | def get_version(): 139 | return c_api.oniGetVersion() 140 | 141 | 142 | def wait_for_any_stream(streams, timeout=None): 143 | if timeout is None: 144 | timeout = c_api.ONI_TIMEOUT_FOREVER 145 | else: 146 | timeout = int(timeout * 1000) # in msec 147 | ready_stream_index = ctypes.c_int(-1) 148 | arr = (c_api.OniStreamHandle * len(streams))() 149 | for i, s in enumerate(streams): 150 | arr[i] = s._handle 151 | try: 152 | c_api.oniWaitForAnyStream(arr, len(streams), ctypes.byref(ready_stream_index), timeout) 153 | except OpenNIError as ex: 154 | if ex.code == c_api.OniStatus.ONI_STATUS_TIME_OUT: 155 | # timed out 156 | return None 157 | else: 158 | raise 159 | if ready_stream_index.value >= 0: 160 | return streams[ready_stream_index.value] 161 | else: 162 | return None 163 | 164 | 165 | VideoMode = c_api.OniVideoMode 166 | DeviceInfo = c_api.OniDeviceInfo 167 | 168 | 169 | class SensorInfo(object): 170 | def __init__(self, info): 171 | self.sensorType = info.sensorType 172 | self.videoModes = [info.pSupportedVideoModes[i] for i in range(info.numSupportedVideoModes)] 173 | 174 | @classmethod 175 | def from_stream_handle(cls, handle): 176 | pinfo = c_api.oniStreamGetSensorInfo(handle) 177 | if pinfo == 0: 178 | return None 179 | return cls(pinfo[0]) 180 | 181 | @classmethod 182 | def from_device_handle(cls, handle, sensor_type): 183 | pinfo = c_api.oniDeviceGetSensorInfo(handle, sensor_type) 184 | if not pinfo: 185 | return None 186 | return cls(pinfo[0]) 187 | 188 | 189 | class PlaybackSupport(object): 190 | __slots__ = ["device"] 191 | 192 | def __init__(self, device): 193 | self.device = weakref.proxy(device) 194 | 195 | def get_speed(self): 196 | return self.device.get_property(c_api.ONI_DEVICE_PROPERTY_PLAYBACK_SPEED, ctypes.c_float) 197 | 198 | def set_speed(self, speed): 199 | return self.device.set_property(c_api.ONI_DEVICE_PROPERTY_PLAYBACK_SPEED, speed) 200 | speed = property(get_speed, set_speed) 201 | 202 | def get_repeat_enabled(self): 203 | return bool(self.device.get_property(c_api.ONI_DEVICE_PROPERTY_PLAYBACK_REPEAT_ENABLED, c_api.OniBool)) 204 | 205 | def set_repeat_enabled(self, enable): 206 | self.device.set_property(c_api.ONI_DEVICE_PROPERTY_PLAYBACK_REPEAT_ENABLED, enable) 207 | repeat = property(get_repeat_enabled, set_repeat_enabled) 208 | 209 | def seek(self, stream, frame_index): 210 | seek = c_api.OniSeek(frameIndex=frame_index, stream=stream._handle) 211 | self.device.invoke(c_api.ONI_DEVICE_COMMAND_SEEK, seek) 212 | 213 | def get_number_of_frames(self, stream): 214 | return stream.get_number_of_frames() 215 | 216 | 217 | class Device(HandleObject): 218 | def __init__(self, uri, mode=None): 219 | self._orig_uri = uri 220 | self.uri = uri 221 | self._mode = mode 222 | HandleObject.__init__(self, None) 223 | self._reopen() 224 | _registered_devices.add(self) 225 | 226 | def _reopen(self): 227 | self.close() 228 | self._handle = c_api.OniDeviceHandle() 229 | assert not bool(self._handle) 230 | if self._mode: 231 | c_api.oniDeviceOpenEx(self._orig_uri, self._mode, ctypes.byref(self._handle)) 232 | else: 233 | c_api.oniDeviceOpen(self._orig_uri, ctypes.byref(self._handle)) 234 | assert bool(self._handle), "Handle is NULL after open" 235 | if self.is_file(): 236 | self.playback = PlaybackSupport(self) 237 | else: 238 | self.playback = None 239 | self._sensor_infos = {} 240 | self._devinfo = None 241 | self.get_device_info() 242 | 243 | @classmethod 244 | def enumerate_uris(cls): 245 | pdevs = ctypes.POINTER(c_api.OniDeviceInfo)() 246 | count = ctypes.c_int() 247 | c_api.oniGetDeviceList(ctypes.byref(pdevs), ctypes.byref(count)) 248 | uris = [pdevs[i].uri for i in range(count.value)] 249 | c_api.oniReleaseDeviceList(pdevs) 250 | return uris 251 | 252 | @classmethod 253 | def open_all(cls): 254 | return [cls(uri) for uri in cls.enumerate_uris()] 255 | 256 | @classmethod 257 | def open_any(cls): 258 | return cls(None) 259 | 260 | @classmethod 261 | def open_file(cls, filename): 262 | return cls(filename) 263 | 264 | def _close(self): 265 | if is_initialized(): 266 | c_api.oniDeviceClose(self._handle) 267 | self.playback = None 268 | 269 | def get_device_info(self): 270 | if self._devinfo is None: 271 | self._devinfo = c_api.OniDeviceInfo() 272 | c_api.oniDeviceGetInfo(self._handle, ctypes.byref(self._devinfo)) 273 | self.uri = self._devinfo.uri 274 | return self._devinfo 275 | device_info = property(get_device_info) 276 | 277 | def get_sensor_info(self, sensor_type): 278 | if sensor_type in self._sensor_infos: 279 | return self._sensor_infos[sensor_type] 280 | 281 | info = SensorInfo.from_device_handle(self._handle, sensor_type) 282 | self._sensor_infos[sensor_type] = info 283 | return info 284 | 285 | def has_sensor(self, sensor_type): 286 | return self.get_sensor_info(sensor_type) is not None 287 | 288 | def create_stream(self, sensor_type): 289 | return VideoStream(self, sensor_type) 290 | 291 | def create_depth_stream(self): 292 | if not self.has_sensor(SENSOR_DEPTH): 293 | return None 294 | return VideoStream(self, SENSOR_DEPTH) 295 | 296 | def create_color_stream(self): 297 | if not self.has_sensor(SENSOR_COLOR): 298 | return None 299 | return VideoStream(self, SENSOR_COLOR) 300 | 301 | def create_ir_stream(self): 302 | if not self.has_sensor(SENSOR_IR): 303 | return None 304 | return VideoStream(self, SENSOR_IR) 305 | 306 | def get_property(self, property_id, rettype): 307 | ret = rettype() 308 | size = ctypes.c_int(ctypes.sizeof(ret)) 309 | c_api.oniDeviceGetProperty(self._handle, property_id, ctypes.byref(ret), ctypes.byref(size)) 310 | return ret 311 | 312 | def get_int_property(self, property_id): 313 | return self.get_property(property_id, ctypes.c_int).value 314 | 315 | def set_property(self, property_id, obj, size=None): 316 | obj, size = _py_to_ctype_obj(obj) 317 | if size is None: 318 | size = ctypes.sizeof(obj) 319 | c_api.oniDeviceSetProperty(self._handle, property_id, ctypes.byref(obj), size) 320 | 321 | def is_property_supported(self, property_id): 322 | return bool(c_api.oniDeviceIsPropertySupported(self._handle, property_id)) 323 | 324 | def invoke(self, command_id, data, size=None): 325 | data, size = _py_to_ctype_obj(data) 326 | if size is None: 327 | size = ctypes.sizeof(data) 328 | c_api.oniDeviceInvoke(self._handle, command_id, ctypes.byref(data), size) 329 | 330 | def is_command_supported(self, command_id): 331 | return bool(c_api.oniDeviceIsCommandSupported(self._handle, command_id)) 332 | 333 | def is_image_registration_mode_supported(self, mode): 334 | return bool(c_api.oniDeviceIsImageRegistrationModeSupported(self._handle, mode)) 335 | 336 | def get_image_registration_mode(self): 337 | return self.get_property(c_api.ONI_DEVICE_PROPERTY_IMAGE_REGISTRATION, c_api.OniImageRegistrationMode) 338 | 339 | def set_image_registration_mode(self, mode): 340 | self.set_property(c_api.ONI_DEVICE_PROPERTY_IMAGE_REGISTRATION, mode) 341 | 342 | def is_file(self): 343 | return (self.is_property_supported(c_api.ONI_DEVICE_PROPERTY_PLAYBACK_SPEED) and 344 | self.is_property_supported(c_api.ONI_DEVICE_PROPERTY_PLAYBACK_REPEAT_ENABLED) and 345 | self.is_command_supported(c_api.ONI_DEVICE_COMMAND_SEEK)) 346 | 347 | def get_depth_color_sync_enabled(self): 348 | return bool(c_api.oniDeviceGetDepthColorSyncEnabled(self._handle)) 349 | 350 | def set_depth_color_sync_enabled(self, enable): 351 | if enable: 352 | c_api.oniDeviceEnableDepthColorSync(self._handle) 353 | else: 354 | c_api.oniDeviceDisableDepthColorSync(self._handle) 355 | depth_color_sync = property(get_depth_color_sync_enabled, set_depth_color_sync_enabled) 356 | 357 | 358 | @inherit_properties(c_api.OniFrame, "_frame") 359 | class VideoFrame(HandleObject): 360 | def __init__(self, pframe): 361 | self._frame = pframe[0] 362 | HandleObject.__init__(self, pframe) 363 | _registered_video_frames.add(self) 364 | 365 | def _close(self): 366 | if is_initialized(): 367 | c_api.oniFrameRelease(self._handle) 368 | self._frame = ClosedHandle 369 | 370 | def get_buffer_as(self, ctype): 371 | return (ctype * int(self.dataSize / ctypes.sizeof(ctype))).from_address(self.data) 372 | 373 | def get_buffer_as_uint8(self): 374 | return self.get_buffer_as(ctypes.c_uint8) 375 | 376 | def get_buffer_as_uint16(self): 377 | return self.get_buffer_as(ctypes.c_uint16) 378 | 379 | def get_buffer_as_triplet(self): 380 | return self.get_buffer_as(ctypes.c_uint8 * 3) 381 | 382 | 383 | class CameraSettings(object): 384 | __slots__ = ["stream"] 385 | 386 | def __init__(self, stream): 387 | self.stream = weakref.proxy(stream) 388 | 389 | def get_auto_exposure(self): 390 | return bool(self.stream.get_property(c_api.ONI_STREAM_PROPERTY_AUTO_EXPOSURE, c_api.OniBool)) 391 | 392 | def set_auto_exposure(self, enabled): 393 | self.stream.set_property(c_api.ONI_STREAM_PROPERTY_AUTO_EXPOSURE, enabled) 394 | auto_exposure = property(get_auto_exposure, set_auto_exposure) 395 | 396 | def get_auto_white_balance(self): 397 | return bool(self.stream.get_property(c_api.ONI_STREAM_PROPERTY_AUTO_WHITE_BALANCE, c_api.OniBool)) 398 | 399 | def set_auto_white_balance(self, enabled): 400 | return self.stream.set_property(c_api.ONI_STREAM_PROPERTY_AUTO_WHITE_BALANCE, enabled) 401 | auto_white_balance = property(get_auto_white_balance, set_auto_white_balance) 402 | 403 | def get_gain(self): 404 | try: 405 | return self.stream.get_property(c_api.ONI_STREAM_PROPERTY_GAIN, ctypes.c_int).value 406 | except OpenNIError: 407 | return 100 408 | 409 | def set_gain(self, gain): 410 | return self.stream.set_property(c_api.ONI_STREAM_PROPERTY_GAIN, gain) 411 | gain = property(get_gain, set_gain) 412 | 413 | def get_exposure(self): 414 | try: 415 | return self.stream.get_property(c_api.ONI_STREAM_PROPERTY_EXPOSURE, ctypes.c_int).value 416 | except OpenNIError: 417 | return 0 418 | 419 | def set_exposure(self, exposure): 420 | return self.stream.set_property(c_api.ONI_STREAM_PROPERTY_EXPOSURE, exposure) 421 | exposure = property(get_exposure, set_exposure) 422 | 423 | 424 | class VideoStream(HandleObject): 425 | def __init__(self, device, sensor_type): 426 | self.device = device 427 | self.sensor_type = sensor_type 428 | self._callbacks = {} 429 | handle = c_api.OniStreamHandle() 430 | c_api.oniDeviceCreateStream(self.device._handle, sensor_type, ctypes.byref(handle)) 431 | HandleObject.__init__(self, handle) 432 | _registered_video_streams.add(self) 433 | if (self.is_property_supported(c_api.ONI_STREAM_PROPERTY_AUTO_WHITE_BALANCE) and 434 | self.is_property_supported(c_api.ONI_STREAM_PROPERTY_AUTO_EXPOSURE)): 435 | self.camera = CameraSettings(self) 436 | else: 437 | self.camera = None 438 | 439 | def _close(self): 440 | if is_initialized(): 441 | self.unregister_all_new_frame_listeners() 442 | self.stop() 443 | c_api.oniStreamDestroy(self._handle) 444 | self.camera = None 445 | 446 | def get_sensor_info(self): 447 | return SensorInfo.from_stream_handle(self._handle) 448 | 449 | def get_recoder(self, filename, allow_lossy_compression=False): 450 | rec = Recorder(filename) 451 | rec.attach(self, allow_lossy_compression) 452 | return rec 453 | 454 | def start(self): 455 | c_api.oniStreamStart(self._handle) 456 | 457 | def stop(self): 458 | c_api.oniStreamStop(self._handle) 459 | 460 | def read_frame(self): 461 | pframe = ctypes.POINTER(c_api.OniFrame)() 462 | c_api.oniStreamReadFrame(self._handle, ctypes.byref(pframe)) 463 | return VideoFrame(pframe) 464 | 465 | def register_new_frame_listener(self, callback): 466 | """callback(stream : VideoStream) -> None""" 467 | if callback in self._callbacks: 468 | raise ValueError("Callback %r already registered" % (callback,)) 469 | 470 | def adapter(handle, cookie): 471 | callback(self) 472 | 473 | cb_handle = c_api.OniCallbackHandle() 474 | cbobj = c_api.OniNewFrameCallback(adapter) 475 | self._callbacks[callback] = (cb_handle, adapter, cbobj) 476 | c_api.oniStreamRegisterNewFrameCallback(self._handle, cbobj, None, ctypes.byref(cb_handle)) 477 | 478 | def unregister_new_frame_listener(self, callback): 479 | if callback not in self._callbacks: 480 | return 481 | cb_handle, _, _ = self._callbacks.pop(callback) 482 | c_api.oniStreamUnregisterNewFrameCallback(self._handle, cb_handle) 483 | 484 | def unregister_all_new_frame_listeners(self): 485 | for cb_handle, _, _ in self._callbacks.values(): 486 | c_api.oniStreamUnregisterNewFrameCallback(self._handle, cb_handle) 487 | self._callbacks.clear() 488 | 489 | def get_property(self, property_id, rettype): 490 | ret = rettype() 491 | size = ctypes.c_int(ctypes.sizeof(ret)) 492 | c_api.oniStreamGetProperty(self._handle, property_id, ctypes.byref(ret), ctypes.byref(size)) 493 | return ret 494 | 495 | def get_int_property(self, property_id): 496 | return self.get_property(property_id, ctypes.c_int).value 497 | 498 | def set_property(self, property_id, obj, size=None): 499 | obj, size = _py_to_ctype_obj(obj) 500 | if size is None: 501 | size = ctypes.sizeof(obj) 502 | c_api.oniStreamSetProperty(self._handle, property_id, ctypes.byref(obj), size) 503 | 504 | def is_property_supported(self, property_id): 505 | return bool(c_api.oniStreamIsPropertySupported(self._handle, property_id)) 506 | 507 | def invoke(self, command_id, data, size=None): 508 | data, size = _py_to_ctype_obj(data) 509 | if size is None: 510 | size = ctypes.sizeof(data) 511 | c_api.oniStreamInvoke(self._handle, command_id, data, size) 512 | 513 | def is_command_supported(self, command_id): 514 | return bool(c_api.oniStreamIsCommandSupported(self._handle, command_id)) 515 | 516 | def get_video_mode(self): 517 | return self.get_property(c_api.ONI_STREAM_PROPERTY_VIDEO_MODE, c_api.OniVideoMode) 518 | 519 | def set_video_mode(self, video_mode): 520 | self.set_property(c_api.ONI_STREAM_PROPERTY_VIDEO_MODE, video_mode) 521 | video_mode = property(get_video_mode, set_video_mode) 522 | 523 | def configure_mode(self, width, height, fps, pixel_format): 524 | """shortcut for set_video_mode""" 525 | mode = VideoMode(resolutionX=width, resolutionY=height, fps=fps, pixelFormat=pixel_format) 526 | self.set_video_mode(mode) 527 | 528 | def get_max_pixel_value(self): 529 | return self.get_int_property(c_api.ONI_STREAM_PROPERTY_MAX_VALUE) 530 | 531 | def get_min_pixel_value(self): 532 | return self.get_int_property(c_api.ONI_STREAM_PROPERTY_MIN_VALUE) 533 | 534 | def is_cropping_supported(self): 535 | return self.is_property_supported(c_api.ONI_STREAM_PROPERTY_CROPPING) 536 | 537 | def get_cropping(self): 538 | return self.get_property(c_api.ONI_STREAM_PROPERTY_CROPPING, c_api.OniCropping) 539 | 540 | def set_cropping(self, originX, originY, width, height): 541 | cropping = c_api.OniCropping(enabled=True, originX=originX, originY=originY, width=width, height=height) 542 | self.set_property(c_api.ONI_STREAM_PROPERTY_CROPPING, cropping) 543 | cropping = property(get_property, set_property) 544 | 545 | def reset_cropping(self): 546 | self.set_property(c_api.ONI_STREAM_PROPERTY_CROPPING, c_api.OniCropping(enabled=False)) 547 | 548 | def get_mirroring_enabled(self): 549 | return bool(self.get_property(c_api.ONI_STREAM_PROPERTY_MIRRORING, c_api.OniBool)) 550 | 551 | def set_mirroring_enabled(self, enabled): 552 | self.set_property(c_api.ONI_STREAM_PROPERTY_MIRRORING, enabled) 553 | mirroring_enabled = property(get_mirroring_enabled, set_mirroring_enabled) 554 | 555 | def get_horizontal_fov(self): 556 | return self.get_property(c_api.ONI_STREAM_PROPERTY_HORIZONTAL_FOV, ctypes.c_float).value 557 | 558 | def get_vertical_fov(self): 559 | return self.get_property(c_api.ONI_STREAM_PROPERTY_VERTICAL_FOV, ctypes.c_float).value 560 | 561 | def get_number_of_frames(self): 562 | return self.get_int_property(c_api.ONI_STREAM_PROPERTY_NUMBER_OF_FRAMES) 563 | 564 | def set_frame_buffers_allocator(self, allocator=None): 565 | if not allocator: 566 | c_api.oniStreamSetFrameBuffersAllocator(self._handle, None, None, None) 567 | else: 568 | return c_api.oniStreamSetFrameBuffersAllocator(self._handle, 569 | allocator._allocate_callback, allocator._free_callback, None) 570 | 571 | 572 | class FrameAllocator(object): 573 | def __init__(self): 574 | # keep reference to the methods (they are passed as callbacks) 575 | self._alloc_callback = c_api.OniFrameAllocBufferCallback(self._allocate_frame_buffer_callback) 576 | self._free_callback = c_api.OniFrameFreeBufferCallback(self._free_frame_buffer_callback) 577 | 578 | def allocate_frame_buffer(self, size): 579 | raise NotImplementedError() 580 | 581 | def free_frame_buffer(self, pdata): 582 | raise NotImplementedError() 583 | 584 | def _allocate_frame_buffer_callback(self, size, _): 585 | return self.allocate_frame_buffer(size) 586 | 587 | def _free_frame_buffer_callback(self, pdata, _): 588 | return self.free_frame_buffer(pdata) 589 | 590 | 591 | class Recorder(HandleObject): 592 | def __init__(self, filename): 593 | self.filename = filename 594 | handle = c_api.OniRecorderHandle() 595 | c_api.oniCreateRecorder(filename, ctypes.byref(handle)) 596 | HandleObject.__init__(self, handle) 597 | _registered_recorders.add(self) 598 | 599 | def _close(self): 600 | if is_initialized(): 601 | c_api.oniRecorderDestroy(ctypes.byref(self._handle)) 602 | 603 | def attach(self, stream, allow_lossy_compression=False): 604 | c_api.oniRecorderAttachStream(self._handle, stream._handle, allow_lossy_compression) 605 | 606 | def start(self): 607 | c_api.oniRecorderStart(self._handle) 608 | 609 | def stop(self): 610 | c_api.oniRecorderStop(self._handle) 611 | 612 | 613 | def convert_world_to_depth(depthStream, worldX, worldY, worldZ): 614 | """const VideoStream& depthStream, float worldX, float worldY, float worldZ""" 615 | out_depthX = ctypes.c_float() 616 | out_depthY = ctypes.c_float() 617 | out_depthZ = ctypes.c_float() 618 | c_api.oniCoordinateConverterWorldToDepth(depthStream._handle, worldX, worldY, worldZ, 619 | ctypes.byref(out_depthX), ctypes.byref(out_depthY), ctypes.byref(out_depthZ)) 620 | return out_depthX.value, out_depthY.value, out_depthZ.value 621 | 622 | 623 | def convert_depth_to_world(depthStream, depthX, depthY, depthZ): 624 | """const VideoStream& depthStream, float depthX, float depthY, float depthZ, float* pWorldX, float* pWorldY, float* pWorldZ""" 625 | out_depthX = ctypes.c_float() 626 | out_depthY = ctypes.c_float() 627 | out_depthZ = ctypes.c_float() 628 | c_api.oniCoordinateConverterDepthToWorld(depthStream._handle, depthX, depthY, depthZ, 629 | ctypes.byref(out_depthX), ctypes.byref(out_depthY), ctypes.byref(out_depthZ)) 630 | return out_depthX.value, out_depthY.value, out_depthZ.value 631 | 632 | 633 | def convert_depth_to_color(depthStream, colorStream, depthX, depthY, depthZ): 634 | """const VideoStream& depthStream, const VideoStream& colorStream, int depthX, int depthY, DepthPixel depthZ, int* pColorX, int* pColorY""" 635 | colorX = ctypes.c_int() 636 | colorY = ctypes.c_int() 637 | c_api.oniCoordinateConverterDepthToColor(depthStream._handle, colorStream._handle, depthX, depthY, depthZ, 638 | ctypes.byref(colorX), ctypes.byref(colorY)) 639 | return colorX.value, colorY.value 640 | 641 | 642 | def get_bytes_per_pixel(format): 643 | c_api.oniFormatBytesPerPixel(format) 644 | 645 | 646 | class DeviceListener(HandleObject): 647 | def __init__(self): 648 | handle = c_api.OniCallbackHandle() 649 | self._callbacks = c_api.OniDeviceCallbacks( 650 | deviceConnected=c_api.OniDeviceInfoCallback(self._on_connected), 651 | deviceDisconnected=c_api.OniDeviceInfoCallback(self._on_disconnected), 652 | deviceStateChanged=c_api.OniDeviceStateCallback(self._on_state_changed), 653 | ) 654 | c_api.oniRegisterDeviceCallbacks(self._callbacks, None, ctypes.byref(handle)) 655 | HandleObject.__init__(self, handle) 656 | _registered_device_listeners.add(self) 657 | self._connected_uris = set() 658 | self._disconnected_uris = set() 659 | 660 | def _close(self): 661 | if is_initialized(): 662 | c_api.oniUnregisterDeviceCallbacks(self._handle) 663 | 664 | def unregister(self): 665 | self.close() 666 | 667 | def _on_connected(self, pdevinfo, _): 668 | devinfo = pdevinfo[0] 669 | self._disconnected_uris.discard(devinfo.uri) 670 | if devinfo.uri in self._connected_uris: 671 | return 672 | self._connected_uris.add(devinfo.uri) 673 | self.on_connected(devinfo) 674 | 675 | def _on_disconnected(self, pdevinfo, _): 676 | devinfo = pdevinfo[0] 677 | self._connected_uris.discard(devinfo.uri) 678 | if devinfo.uri in self._disconnected_uris: 679 | return 680 | self._disconnected_uris.add(devinfo.uri) 681 | self.on_disconnected(devinfo) 682 | 683 | def _on_state_changed(self, pdevinfo, state, _): 684 | self.on_state_changed(pdevinfo[0], state) 685 | 686 | def on_connected(self, devinfo): 687 | """Implement me""" 688 | pass 689 | 690 | def on_disconnected(self, devinfo): 691 | """Implement me""" 692 | pass 693 | 694 | def on_state_changed(self, devinfo, state): 695 | """Implement me""" 696 | pass 697 | 698 | 699 | def get_log_filename(): 700 | buf = ctypes.create_string_buffer(1024) 701 | try: 702 | c_api.oniGetLogFileName(buf, ctypes.sizeof(buf)) 703 | except OpenNIError: 704 | # not logging to file 705 | return None 706 | else: 707 | return buf.value 708 | 709 | 710 | def configure_logging(directory=None, severity=None, console=None): 711 | """ 712 | directory: directory in which log files will be stored 713 | severity: 0 - Verbose; 1 - Info; 2 - Warning; 3 - Error. Default - None 714 | console: whether to print to the console (boolean) 715 | """ 716 | if directory is not None: 717 | c_api.oniSetLogOutputFolder(directory) 718 | c_api.oniSetLogFileOutput(True) 719 | else: 720 | c_api.oniSetLogFileOutput(False) 721 | 722 | if severity is not None: 723 | c_api.oniSetLogMinSeverity(severity) 724 | 725 | if console is not None: 726 | c_api.oniSetLogConsoleOutput(bool(console)) 727 | -------------------------------------------------------------------------------- /openni/utils.py: -------------------------------------------------------------------------------- 1 | import ctypes 2 | 3 | 4 | class InitializationError(Exception): 5 | pass 6 | 7 | 8 | class OpenNIError(Exception): 9 | def __init__(self, code, message, logfile): 10 | self.code = code 11 | self.logfile = logfile 12 | Exception.__init__(self, code, message, logfile) 13 | 14 | 15 | class NiteError(Exception): 16 | def __init__(self, code): 17 | Exception.__init__(self, code) 18 | 19 | 20 | def inherit_properties(struct, attrname): 21 | def deco(cls): 22 | for name, _ in struct._fields_: 23 | def getter(self, name=name): 24 | return getattr(getattr(self, attrname), name) 25 | 26 | def setter(self, value, name=name): 27 | return setattr(getattr(self, attrname), name, value) 28 | setattr(cls, name, property(getter, setter)) 29 | return cls 30 | return deco 31 | 32 | 33 | class ClosedHandleError(Exception): 34 | pass 35 | 36 | 37 | class ClosedHandle(object): 38 | def __getattr__(self, name): 39 | raise ClosedHandleError("Invalid handle") 40 | 41 | def __bool__(self): 42 | return False 43 | __nonzero__ = __bool__ 44 | 45 | 46 | ClosedHandle = ClosedHandle() 47 | 48 | 49 | class HandleObject(object): 50 | __slots__ = ["_handle"] 51 | 52 | def __init__(self, handle): 53 | self._handle = handle 54 | 55 | def __del__(self): 56 | self.close() 57 | 58 | def __enter__(self): 59 | return self 60 | 61 | def __exit__(self, t, v, tb): 62 | self.close() 63 | 64 | def __bool__(self): 65 | return hasattr(self, "_handle") and bool(self._handle) 66 | __nonzero__ = __bool__ 67 | 68 | def close(self): 69 | if hasattr(self, "_handle") and self._handle: 70 | self._close() 71 | self._handle = ClosedHandle 72 | 73 | def _close(self): 74 | raise NotImplementedError() 75 | 76 | 77 | def _py_to_ctype_obj(obj): 78 | size = None 79 | if isinstance(obj, (int, bool)): 80 | obj = ctypes.c_int(obj) 81 | elif isinstance(obj, float): 82 | obj = ctypes.c_float(obj) 83 | elif isinstance(obj, str): 84 | obj = ctypes.create_string_buffer(obj) 85 | size = len(obj) 86 | return obj, size 87 | 88 | 89 | class CEnumMeta(type(ctypes.c_int)): 90 | def __new__(cls, name, bases, namespace): 91 | cls2 = type(ctypes.c_int).__new__(cls, name, bases, namespace) 92 | if namespace.get("__module__") != __name__: 93 | namespace["_values_"].clear() 94 | for name in namespace["_names_"].keys(): 95 | if name.startswith("_"): 96 | continue 97 | setattr(cls2, name, cls2(namespace[name])) 98 | namespace["_names_"][name] = namespace[name] 99 | namespace["_values_"][namespace[name]] = name 100 | return cls2 101 | 102 | 103 | def with_meta(meta, base=object): 104 | return meta("NewBase", (base,), {"__module__": __name__}) 105 | 106 | 107 | class CEnum(with_meta(CEnumMeta, ctypes.c_int)): 108 | _names_ = {} 109 | _values_ = {} 110 | __slots__ = [] 111 | 112 | def __repr__(self): 113 | name = self._values_.get(self.value) 114 | if name is None: 115 | return "%s(%r)" % (self.__class__.__name__, self.val) 116 | else: 117 | return "%s.%s" % (self.__class__.__name__, name) 118 | 119 | @classmethod 120 | def from_param(cls, obj): 121 | return int(obj) 122 | 123 | @classmethod 124 | def from_name(cls, name): 125 | return cls._names_[name] 126 | 127 | @classmethod 128 | def from_value(cls, val): 129 | return getattr(self, cls._values_[val]) 130 | 131 | def __int__(self): 132 | return int(self.value) 133 | 134 | def __index__(self): 135 | return int(self) 136 | 137 | def __eq__(self, other): 138 | return int(self) == int(other) 139 | 140 | def __ne__(self, other): 141 | return int(self) != int(other) 142 | 143 | def __gt__(self, other): 144 | return int(self) > int(other) 145 | 146 | def __ge__(self, other): 147 | return int(self) >= int(other) 148 | 149 | def __lt__(self, other): 150 | return int(self) < int(other) 151 | 152 | def __le__(self, other): 153 | return int(self) <= int(other) 154 | 155 | def __hash__(self): 156 | return hash(int(self)) 157 | 158 | 159 | class DLLNotLoaded(Exception): 160 | pass 161 | 162 | 163 | class UnloadedDLL(object): 164 | __slots__ = [] 165 | 166 | def __bool__(self): 167 | return False 168 | __nonzero__ = __bool__ 169 | 170 | def __call__(self, *args, **kwargs): 171 | raise DLLNotLoaded("DLL is not loaded") 172 | 173 | def __getattr__(self, name): 174 | raise DLLNotLoaded("DLL is not loaded") 175 | 176 | 177 | UnloadedDLL = UnloadedDLL() 178 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | #-*- coding: UTF-8 -*- 3 | import os 4 | 5 | try: 6 | from setuptools import setup 7 | except ImportError: 8 | from distutils.core import setup 9 | 10 | setup(name = "openni", 11 | version = "2.3.0", 12 | description = "OpenNI2 and NiTE2 python bindings", 13 | author = "PrimeSense Inc, Séverin Lemaignan, Jerome Flesch, Hajime Murao", 14 | author_email = "primesense.com, severin.lemaignan@brl.ac.uk", 15 | license = "MIT", 16 | url = "https://github.com/severin-lemaignan/openni-python", 17 | packages = ["openni"], 18 | platforms = ["POSIX", "Windows"], 19 | provides = ["openni"], 20 | keywords = "PrimeSense, OpenNI, OpenNI2, Natural Interaction, NiTE, NiTE2", 21 | long_description = """\ 22 | Python-bindings for `OpenNI2 `_ 23 | and `NiTE2 `_. 24 | 25 | This package provides only the Python bindings; be sure to install OpenNI2 (and optionally NiTE2) first. 26 | 27 | Example:: 28 | 29 | from openni import openni2 30 | 31 | openni2.initialize() # can also accept the path of the OpenNI redistribution 32 | 33 | dev = openni2.Device.open_any() 34 | print dev.get_device_info() 35 | 36 | depth_stream = dev.create_depth_stream() 37 | depth_stream.start() 38 | frame = depth_stream.read_frame() 39 | frame_data = frame.get_buffer_as_uint16() 40 | depth_stream.stop() 41 | 42 | openni2.unload() 43 | 44 | 45 | .. note:: Refer to the OpenNI2/NiTE2 C API for complete documentation 46 | 47 | """, 48 | classifiers = [ 49 | "Development Status :: 4 - Beta", 50 | "License :: OSI Approved :: MIT License", 51 | "Operating System :: Microsoft :: Windows", 52 | "Operating System :: POSIX", 53 | "Operating System :: MacOS", 54 | "Programming Language :: Python :: 2.6", 55 | "Programming Language :: Python :: 2.7", 56 | "Programming Language :: Python :: 3", 57 | "Programming Language :: Python :: 3.2", 58 | "Programming Language :: Python :: 3.3", 59 | ], 60 | ) 61 | 62 | --------------------------------------------------------------------------------