def _connect(self):
try:
if self.host is None:
self.dsock = rx.mkdatasock() #Connecting to localhost
elif self.multicast is not None and self.multicast is not '' and self.port is not None:
ColorTerminal().blue(
"NatnetReader connecting to natnet @ %s:%s (multicast: %s)"
% (self.host, self.port, self.multicast))
self.dsock = rx.mkdatasock(
ip_address=self.host,
multicast_address=self.multicast,
port=int(self.port)) #Connecting to multicast address
else:
ColorTerminal().blue(
"NatnetReader connecting to natnet @ %s:%s" %
(self.host, self.port))
self.dsock = rx.mkdatasock(
ip_address=self.host,
port=int(self.port)) # Connecting to IP address
self.dsock.setblocking(0)
self.connected = True
self.connectEvent(self)
ColorTerminal().green("NatnetReader Connected")
except:
ColorTerminal().red(
"NatnetReader encountered an error while connecting")
self._disconnect()
return self.connected
def startReading(self):
self.stopReading()
try:
if not self.path:
self.path = 'walk-198frames.binary.recording'
self.read_file = open(self.path, 'rb')
ColorTerminal().success("NatnetFile opened: %s" % self.path)
except:
ColorTerminal().fail("NatnetFile couldn't be opened: %s" %
self.path)
self.read_file = None
def _connect(self):
try:
self.client = OSC.OSCClient()
self.client.connect((self.host(), self.port()))
except OSC.OSCClientError as err:
ColorTerminal().error("OSC connection failure: {0}".format(err))
return False
self.connected = True
ColorTerminal().success("OSC client connected to " + self.host() +
':' + str(self.port()))
self.connectEvent(self)
return True
def startWriting(self):
self.stopWriting()
try:
if not self.path:
self.path = '/tmp/natnet_' + datetime.now().strftime(
'%Y_%m_%d_%H_%M_%S') + '.binary'
self.write_file = open(self.path, 'wb')
ColorTerminal().success("NatnetFile opened for writing: %s" %
self.path)
except:
ColorTerminal().fail(
"NatnetFile couldn't be opened for writing: %s" % self.path)
self.write_file = None
def _disconnect(self):
if hasattr(self, 'client') and self.client:
self.client.close()
self.client = None
self.connected = False
ColorTerminal().success("OSC client closed")
self.disconnectEvent(self)
def unhandle(self, handler):
try:
self.handlers.remove(handler)
except:
# raise ValueError("Handler is not handling this event, so cannot unhandle it.")
ColorTerminal().red('Event.unhandle got unknown handler')
return self
def start(self):
self._connect()
if not self.threaded:
# done here
return
if self.thread and self.thread.isAlive():
ColorTerminal().warn("NatnetReader - thread already running")
return
# start thread
self._kill = False
self.thread.start()
from pymocap.event import Event
from pymocap.color_terminal import ColorTerminal
try:
import optirx as rx
except ImportError:
ColorTerminal().warn(
"importing embedded version of the optirx library for PyMoCap.Manager")
import pymocap.dependencies.optirx as rx
class Manager:
def __init__(self):
# events
self.resetEvent = Event()
self.frameDataEvent = Event()
self.frameEvent = Event()
# for natnet data unpacking
self._natnet_version = (2, 7, 0, 0)
self.reset(False)
# resets the current state of the manager (removes current frames and thus all rigid bodies)
def reset(self, notify=True):
self.frame = None
if notify:
self.resetEvent(self)
# takes raw, binary, packed natnet frame data
# it unpacks the data, stores it without further processing
# and triggers notification
def _disconnect(self):
self.dsock = None
self.connected = False
self.connectionLostEvent(self)
ColorTerminal().green("NatnetReader Disconnected")
from pymocap.color_terminal import ColorTerminal
from pymocap.event import Event
try:
import optirx as rx
except ImportError:
ColorTerminal().warn(
"importing embedded version of the optirx library for NatnetReader")
import pymocap.dependencies.optirx as rx
import threading
class NatnetReader:
def __init__(self,
host='0.0.0.0',
multicast=None,
port=1511,
manager=None,
threaded=False,
autoStart=True):
# configuration
self.host = host
self.multicast = multicast
self.port = port
self.manager = manager
self.threaded = threaded
# networking attributes
self.connected = False
self.dsock = None
def stopWriting(self):
if self.write_file:
self.write_file.close()
self.write_file = None
ColorTerminal().blue('NatnetFile closed')
def stopReading(self):
if self.read_file:
self.read_file.close()
self.read_file = None
ColorTerminal().blue('NatnetFile closed')
from pymocap.color_terminal import ColorTerminal
from pymocap.event import Event
import json
try:
import OSC
except ImportError:
ColorTerminal().warn(
"importing embedded version of pyOSC library for OscWriter")
import pymocap.dependencies.OSC as OSC
class OscWriter:
def __init__(self, options={}):
# attributes
self.client = None
self.running = False
self.connected = False
# events
self.connectEvent = Event()
self.disconnectEvent = Event()
# configuration
self.options = {}
self.configure(options)
# autoStart is True by default
if not 'autoStart' in options or options['autoStart']:
self.start()