def setUp(self):
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]},
'D', 'E', 'F']
self.stuff = Stuff(states, machine_cls=Machine)
self.stuff.heavy_processing = heavy_processing
self.stuff.machine.add_transition('process', '*', 'B', before='heavy_processing')
self.stuff.informer = rsb.createInformer(self.TEST_SCOPE, dataType=int)
converter = rsb.converter.ProtocolBufferConverter(messageClass=Value)
rsb.converter.registerGlobalConverter(converter, True)
self.stuff.informer_rst = rsb.createInformer(self.TEST_SCOPE, dataType=Value)
def __init__(self, rsb_scope, rsb_config, wamp, message_type, mode=BIDIRECTIONAL, wamp_scope=None):
logger.info("register scopes:")
self.mode = mode
self.rsb_scope = rsb_scope
self.wamp_scope = rsb_scope[1:].replace('/', '.') if wamp_scope is None else wamp_scope
self.converter = None
self.skipNext = False
self.rsb_publisher = None
self.rsb_listener = None
logger.info("RSB Scope %s" % self.rsb_scope)
logger.info("WAMP Scope is %s" % self.wamp_scope)
self.wamp = wamp
if message_type in PubSubBridge.basic_types:
self.wamp_callback = self.send_primitive_data
self.rsb_callback = self.on_primitive_message
self.rsb_type = PubSubBridge.basic_types[message_type]
else:
self.wamp_callback = self.send_rst
self.rsb_callback = self.on_bytearray_message
self.rsb_type = str('.' + message_type)
# RSB_TO_WAMP
if mode % 2 > 0:
logger.info('listening on rsb scope %s' % self.rsb_scope)
self.rsb_listener = rsb.createListener(self.rsb_scope, config=rsb_config)
self.rsb_listener.addHandler(self.rsb_callback)
# WAMP_TO_RSB
if mode > 1:
logger.info('listening on wamp scope %s' % self.wamp_scope)
self.wamp_listener = self.wamp.subscribe(self.on_wamp_message, self.wamp_scope)
self.rsb_publisher = rsb.createInformer(self.rsb_scope, config=rsb_config)
def test_rpc_protobuf(self):
def echo(value):
value.string = "received"
return value
def raw_received(session, event):
msg = '\0' + base64.b64encode(event.data[1]).decode('ascii')
res = session.call_rpc('/test/rpc', 'echo', msg, 'rst.generic.Value', 'rst.generic.Value')
session.scopes['/test/out'].on_wamp_message(res)
def protobuf_received(passed, lock, event):
if hasattr(event.data, 'type') and event.data.string == 'received':
passed()
lock.release()
rsb.converter.registerGlobalConverter(
rsb.converter.ProtocolBufferConverter(messageClass=Value), True)
self.session.register_scope('/test/scope', 'rst.generic.Value')
self.session.register_scope('/test/out', 'rst.generic.Value')
with rsb.createLocalServer('/test/rpc') as server:
server.addMethod('echo', echo, Value, Value)
with rsb.createListener('/test/scope', config=self.session.rsb_conf) as listener:
listener.addHandler(partial(raw_received, self.session))
with rsb.createListener('/test/out') as out:
out.addHandler(partial(protobuf_received, self.passed, self.lock))
with rsb.createInformer('/test/scope', dataType=Value) as informer:
v = Value()
v.type = Value.STRING
v.string = "hello"
informer.publishData(v)
self.lock.acquire()
self.assertTrue(self.passed.called)
def _get_informer(self, iu_category):
'''Return (or create, store and return) an informer object for IUs of the specified category.'''
if iu_category in self._informer_store:
LOGGER.info("Returning informer on scope "+"/ipaaca/channel/"+str(self._channel)+"/category/"+str(iu_category))
return self._informer_store[iu_category]
informer_iu = rsb.createInformer(
rsb.Scope("/ipaaca/channel/"+str(self._channel)+"/category/"+str(iu_category)),
config=self._participant_config,
dataType=object)
self._informer_store[iu_category] = informer_iu #new_tuple
LOGGER.info("Returning NEW informer on scope "+"/ipaaca/channel/"+str(self._channel)+"/category/"+str(iu_category))
return informer_iu #return new_tuple
def setUp(self):
states = [
'A', 'B', {
'name': 'C',
'children':
['1', '2', {
'name': '3',
'children': ['a', 'b', 'c']
}]
}, 'D', 'E', 'F'
]
self.stuff = Stuff(states, machine_cls=Machine)
self.stuff.heavy_processing = heavy_processing
self.stuff.machine.add_transition('process',
'*',
'B',
before='heavy_processing')
self.stuff.informer = rsb.createInformer(self.TEST_SCOPE, dataType=int)
converter = rsb.converter.ProtocolBufferConverter(messageClass=Value)
rsb.converter.registerGlobalConverter(converter, True)
self.stuff.informer_rst = rsb.createInformer(self.TEST_SCOPE,
dataType=Value)
def testUserRoundtrip(self):
scope = Scope("/test/it")
inConnector = self._getInPushConnector(scope, activate=False)
outConnector = self._getOutConnector(scope, activate=False)
outConfigurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[outConnector])
inConfigurator = rsb.eventprocessing.InPushRouteConfigurator(
connectors=[inConnector])
publisher = createInformer(scope,
dataType=str,
configurator=outConfigurator)
listener = createListener(scope, configurator=inConfigurator)
receiver = SettingReceiver(scope)
listener.addHandler(receiver)
data1 = "a string to test"
sentEvent = Event(EventId(uuid.uuid4(), 0))
sentEvent.setData(data1)
sentEvent.setType(str)
sentEvent.setScope(scope)
sentEvent.getMetaData().setUserInfo("test", "it")
sentEvent.getMetaData().setUserInfo("test again", "it works?")
sentEvent.getMetaData().setUserTime("blubb", 234234)
sentEvent.getMetaData().setUserTime("bla", 3434343.45)
sentEvent.addCause(EventId(uuid.uuid4(), 1323))
sentEvent.addCause(EventId(uuid.uuid4(), 42))
publisher.publishEvent(sentEvent)
with receiver.resultCondition:
while receiver.resultEvent is None:
receiver.resultCondition.wait(10)
if receiver.resultEvent is None:
self.fail("Listener did not receive an event")
self.assertTrue(
receiver.resultEvent.metaData.createTime <= receiver.
resultEvent.metaData.sendTime <= receiver.resultEvent.metaData.
receiveTime <= receiver.resultEvent.metaData.deliverTime)
sentEvent.metaData.receiveTime = \
receiver.resultEvent.metaData.receiveTime
sentEvent.metaData.deliverTime = \
receiver.resultEvent.metaData.deliverTime
self.assertEqual(sentEvent, receiver.resultEvent)
listener.deactivate()
publisher.deactivate()
def __init__(self):
self.__logger = getLoggerByClass(self.__class__)
self.__participants = []
self.__process = ProcessInfo()
self.__host = HostInfo()
self.__informer = rsb.createInformer(PARTICIPANTS_SCOPE)
self.__listener = rsb.createListener(PARTICIPANTS_SCOPE)
def handle(event):
# TODO use filter when we get conjunction filter
if event.method not in ['REQUEST', 'SURVEY']:
return
participantId = None
participant = None
if len(event.scope.components) > \
len(PARTICIPANTS_SCOPE.components):
try:
participantId = uuid.UUID(event.scope.components[-1])
if participantId is not None:
participant = next((p for p in self.__participants
if p.id == participantId),
None)
except Exception, e:
self.__logger.warn('Query event %s does not '
'properly address a participant: %s',
event, e)
def process(thunk):
if participant is not None and event.method == 'REQUEST':
thunk(query=event, participant=participant)
elif participant is None and event.method == 'SURVEY':
for p in self.__participants:
thunk(query=event, participant=p)
else:
self.__logger.warn('Query event %s not understood', event)
if event.data is None:
process(self.sendHello)
elif event.data == 'ping':
process(self.sendPong)
else:
self.__logger.warn('Query event %s not understood', event)
def testHierarchySending(self):
sendScope = Scope("/this/is/a/test")
superScopes = sendScope.superScopes(True)
outConnector = self._getOutConnector(sendScope, activate=False)
outConfigurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[outConnector])
informer = createInformer(sendScope,
dataType=str,
configurator=outConfigurator)
# set up listeners on the complete hierarchy
listeners = []
receivers = []
for scope in superScopes:
inConnector = self._getInPushConnector(scope, activate=False)
inConfigurator = rsb.eventprocessing.InPushRouteConfigurator(
connectors=[inConnector])
listener = createListener(scope, configurator=inConfigurator)
listeners.append(listener)
receiver = SettingReceiver(scope)
listener.addHandler(receiver)
receivers.append(receiver)
data = "a string to test"
informer.publishData(data)
for receiver in receivers:
with receiver.resultCondition:
while receiver.resultEvent is None:
receiver.resultCondition.wait(10)
if receiver.resultEvent is None:
self.fail("Listener on scope %s did not receive an event" %
receiver.scope)
self.assertEqual(receiver.resultEvent.data, data)
for listener in listeners:
listener.deactivate()
informer.deactivate()
def main():
converter = ProtocolBufferConverter(messageClass=JointAngles)
rsb.converter.registerGlobalConverter(converter)
rsb.setDefaultParticipantConfig(rsb.ParticipantConfig.fromDefaultSources())
# print("Registered converter %s" % converter)
# print("Registered converters:\n%s "
# % rsb.converter.getGlobalConverterMap(bytearray))
with rsb.createInformer("/my/input", dataType=JointAngles) as informer:
# Send and event using a method that directly accepts data.
message = JointAngles()
message.angles.extend([0.707]*29)
informer.publishData(message)
print "Message sent: " + str(message)
def main():
converter = ProtocolBufferConverter(messageClass=JointAngles)
rsb.converter.registerGlobalConverter(converter)
rsb.setDefaultParticipantConfig(rsb.ParticipantConfig.fromDefaultSources())
# print("Registered converter %s" % converter)
# print("Registered converters:\n%s "
# % rsb.converter.getGlobalConverterMap(bytearray))
with rsb.createInformer("/my/input", dataType=JointAngles) as informer:
# Send and event using a method that directly accepts data.
message = JointAngles()
message.angles.extend([0.707] * 29)
informer.publishData(message)
print "Message sent: " + str(message)
def test_send_protobuf(self):
def protobuf_received(passed, lock, event):
if hasattr(event.data, 'type'):
passed()
lock.release()
rsb.converter.registerGlobalConverter(
rsb.converter.ProtocolBufferConverter(messageClass=Value), True)
self.session.register_scope('/test/scope', 'rst.generic.Value')
with rsb.createListener('/test/scope') as listener:
listener.addHandler(partial(protobuf_received, self.passed, self.lock))
with rsb.createInformer('/test/scope', dataType=Value) as informer:
v = Value()
v.type = Value.STRING
v.string = "hello"
informer.publishData(v)
self.lock.acquire()
self.assertTrue(self.passed.called)
def testUserPullRoundtrip(self):
scope = Scope("/test/it/pull")
try:
inConnector = self._getInPullConnector(scope, activate=False)
except NotImplementedError:
return
outConnector = self._getOutConnector(scope, activate=False)
outConfigurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[outConnector])
inConfigurator = rsb.eventprocessing.InPullRouteConfigurator(
connectors=[inConnector])
publisher = createInformer(scope,
dataType=str,
configurator=outConfigurator)
reader = createReader(scope, configurator=inConfigurator)
data1 = "a string to test"
sentEvent = Event(EventId(uuid.uuid4(), 0))
sentEvent.setData(data1)
sentEvent.setType(str)
sentEvent.setScope(scope)
sentEvent.getMetaData().setUserInfo("test", "it")
sentEvent.getMetaData().setUserInfo("test again", "it works?")
sentEvent.getMetaData().setUserTime("blubb", 234234)
sentEvent.getMetaData().setUserTime("bla", 3434343.45)
sentEvent.addCause(EventId(uuid.uuid4(), 1323))
sentEvent.addCause(EventId(uuid.uuid4(), 42))
publisher.publishEvent(sentEvent)
resultEvent = reader.read(True)
self.assertTrue(resultEvent.metaData.createTime <= resultEvent.
metaData.sendTime <= resultEvent.metaData.receiveTime
<= resultEvent.metaData.deliverTime)
sentEvent.metaData.receiveTime = resultEvent.metaData.receiveTime
sentEvent.metaData.deliverTime = resultEvent.metaData.deliverTime
self.assertEqual(sentEvent, resultEvent)
reader.deactivate()
publisher.deactivate()
def testInformerListenerRoundtrip(self):
with rsb.createInformer(self.scope, dataType=str) as informer, \
rsb.createListener(self.scope) as listener:
def setReceived(event):
with self.receivedCondition:
self.receivedData = event.data
self.receivedCondition.notifyAll()
listener.addHandler(setReceived)
data = 'our little test'
informer.publishData(data)
start = time.time()
with self.receivedCondition:
while self.receivedData is None:
self.receivedCondition.wait(1)
if time.time() > start + 10:
break
self.assertEqual(data, self.receivedData)
def __init__(self):
self.informer = rsb.createInformer(str(sys.argv[1]), dataType=cv2.cv.iplimage)
import rsb
import rsb.converter
# See ./registration.py.
import sys
sys.path.append('.')
from SimpleImage_pb2 import SimpleImage
if __name__ == '__main__':
# Pacify logger.
logging.basicConfig()
# See ./registration.py.
converter = rsb.converter.ProtocolBufferConverter(messageClass=SimpleImage)
rsb.converter.registerGlobalConverter(converter)
rsb.setDefaultParticipantConfig(rsb.ParticipantConfig.fromDefaultSources())
# Create an informer that will send the events carrying protocol
# buffer payloads. See the informer.py example for a more detailed
# explanation of informer creation.
with rsb.createInformer("/example/converter",
dataType=SimpleImage) as informer:
image = SimpleImage()
image.width = 100
image.height = 100
image.data = str('bla')
informer.publishData(image)
# mark-end::body
def updateRobotInfo():
global robotname
# print 'Number of arguments:', len(sys.argv), 'arguments.'
# print 'Argument List:', str(sys.argv)
if len(sys.argv) == 2:
robotname = str(sys.argv[1])
print "set robotname to " + robotname
print "init updater"
rospy.init_node('updateRobotInfos', anonymous=True)
print "ros connection established"
rsb_informer = rsb.createInformer("/tobi", dataType=str)
rate = rospy.Rate(1)
def checkForNavGoal():
headers = {'Content-type': 'application/json'}
r = requests.get(serverurl + robotname + "/setlocation",
headers=headers)
# pos = r.json().split(',')
# x = pos[0]
# y = pos[1]
# theta = pos[2]
if r.json() == 'called':
print "navgoal detected"
headers = {'Content-type': 'application/json'}
payload = 'none'
r = requests.put(serverurl + robotname + "/setlocation",
headers=headers,
data=json.dumps(payload))
# robot_call = "komm"
# pub_called.publish(robot_call)
# Create an informer for strings on scope "/example/informer".
rsb_informer.publishData("")
def positionCB(data):
global current_location
x = data.pose.pose.position.x
y = data.pose.pose.position.y
print "callback: " + str(x) + ", " + str(y)
# get location from Position (e.g "kitchen")
if (pointInPoly((x, y), kitchen)):
location = "er ist in der kche"
elif (pointInPoly((x, y), livingroom)):
location = "er ist im wohnzimmer"
elif (pointInPoly((x, y), bedroom)):
location = "er ist im schlafzimmer"
elif (pointInPoly((x, y), diningroom)):
location = "er ist im esszimmer"
else:
location = "er ist ausserhalb der arena"
if current_location != location:
print location
current_location = location
headers = {'Content-type': 'application/json'}
payload = location
r = requests.put(serverurl + robotname + "/location",
headers=headers,
data=json.dumps(payload))
print r.json()
def personsCB(data):
global last_people_update
global current_number_of_people
last_people_update = time.time()
numberOfPeople = str(len(data.people))
# get number of persons from Persons (e.g. "2")
# send curl -i -H 'Content-Type: application/json' -X PUT -d '"2"' http://localhost:5000/pepper/persons
if numberOfPeople != current_number_of_people:
current_number_of_people = numberOfPeople
headers = {'Content-type': 'application/json'}
payload = numberOfPeople
r = requests.put(serverurl + robotname + "/numberOfPersons",
headers=headers,
data=json.dumps(payload))
print r.json()
position_sub = rospy.Subscriber('/amcl_pose', PoseWithCovarianceStamped,
positionCB)
person_sub = rospy.Subscriber('/people_tracker/people', People, personsCB)
resetPeople()
while not rospy.is_shutdown():
rate.sleep()
checkForNavGoal()
if time.time() - last_people_update > 1:
resetPeople()
def testInformer(self):
participant = None
with rsb.createInformer('/') as informer:
participant = informer
self.assertEqual(self.creationCalls, [(participant, None)])
self.assertEqual(self.destructionCalls, [participant])
def testCreateInformer(self):
self.assert_(rsb.createInformer("/"))
def __init__(self):
self._current = None
self._mode = 'detect'
self.rsb_informer = rsb.createInformer(rsb_face_scope)
self.rsb_listener = rsb.createListener(rsb_face_mode)
self.rsb_listener.addHandler(self.on_mode_change)
def makeInformer(self):
return rsb.createInformer(self.scope,
self.config,
parent=self,
dataType=self.requestType)
def __init__(self):
Gtk.Window.__init__(self, title="Robot GUI Quick Hack")
self.set_border_width(3)
self.informer = rsb.createInformer("/coman/left_arm/JointPositionCtrl", dataType=JointAngles)
# TODO get home / safe posture
self.commanded = [0] * 7;
pane = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
pane.set_border_width(10)
self.notebook = Gtk.Notebook()
pane.add(self.notebook)
button = Gtk.Button(label="Apply")
button.connect("clicked", self.button_clicked)
pane.add(button)
self.add(pane)
robot = {}
robot['Torso'] = {}
robot['Torso']['WaistLat'] = JointInfo(0, 0, -1.57, 1.57)
robot['Torso']['WaistSag'] = JointInfo(0, 0, -1.57, 1.57)
robot['Torso']['WaistYaw'] = JointInfo(0, 0, -1.57, 1.57)
# LArm
robot['Left Arm'] = {}
robot['Left Arm']['LShSag'] = JointInfo(0, 0, -3.40, 1.65)
robot['Left Arm']['LShLat'] = JointInfo(0, 0, -0.3, 2)
robot['Left Arm']['LShYaw'] = JointInfo(0, 0, -1.57, 1.57)
robot['Left Arm']['LElbj'] = JointInfo(0, 0, -2.3, 0)
robot['Left Arm']['LForearmPlate'] = JointInfo(0, 0, -1.57, 1.57)
robot['Left Arm']['LWrj1'] = JointInfo(0, 0, -0.5, 0.5)
robot['Left Arm']['LWrj2'] = JointInfo(0, 0, -0.78, 1.39)
for chain, joints in robot.iteritems():
page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
page.set_border_width(10)
for name, info in joints.iteritems():
hbox = Gtk.Box(spacing=6)
label = Gtk.Label(name)
label.set_size_request(100, 30)
hbox.add(label)
# two adjustments (initial value, min value, max value,
# step increment - press cursor keys to see!,
# page increment - click around the handle to see!,
# page size - not used here)
ad1 = Gtk.Adjustment(info.initial, info.min, info.max, 0.1, 1, 0)
# an horizontal scale
h_scale = Gtk.Scale(
orientation=Gtk.Orientation.HORIZONTAL, adjustment=ad1)
# of integers (no digits)
h_scale.set_digits(1)
# that can expand horizontally if there is space in the grid (see
# below)
h_scale.set_hexpand(True)
# that is aligned at the top of the space allowed in the grid (see
# below)
h_scale.set_valign(Gtk.Align.START)
h_scale.set_size_request(280, 30)
# hbox.pack_start(h_scale, False, False, 0)
hbox.add(h_scale)
h_scale.connect("value-changed", self.scale_moved, h_scale, name)
# adjustment = Gtk.Adjustment(0, 0, 100, 1, 10, 0)
# spinbutton = Gtk.SpinButton()
# spinbutton.set_adjustment(adjustment)
# hbox.pack_start(spinbutton, False, False, 0)
# check_numeric = Gtk.CheckButton("Numeric")
# check_numeric.connect("toggled", self.on_numeric_toggled)
# hbox.pack_start(check_numeric, False, False, 0)
# check_ifvalid = Gtk.CheckButton("If Valid")
# #check_ifvalid.connect("toggled", self.on_ifvalid_toggled)
# hbox.pack_start(check_ifvalid, False, False, 0)
page.add(hbox)
self.notebook.append_page(page, Gtk.Label(chain))
# on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
# express or implied. See the LGPL for the specific language
# governing rights and limitations.
#
# You should have received a copy of the LGPL along with this
# program. If not, go to http://www.gnu.org/licenses/lgpl.html
# or write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# The development of this software was supported by:
# CoR-Lab, Research Institute for Cognition and Robotics
# Bielefeld University
#
# ============================================================
# mark-start::body
import logging
import rsb
if __name__ == '__main__':
# Pacify logger.
logging.basicConfig()
# Create an informer for strings on scope "/example/informer".
with rsb.createInformer("/example/informer", dataType=str) as informer:
# Send and event using a method that directly accepts data.
informer.publishData("example payload")
# mark-end::body
def __init__(self):
Gtk.Window.__init__(self, title="Robot GUI Quick Hack")
self.set_border_width(3)
self.informer = rsb.createInformer("/coman/left_arm/JointPositionCtrl",
dataType=JointAngles)
# TODO get home / safe posture
self.commanded = [0] * 7
pane = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
pane.set_border_width(10)
self.notebook = Gtk.Notebook()
pane.add(self.notebook)
button = Gtk.Button(label="Apply")
button.connect("clicked", self.button_clicked)
pane.add(button)
self.add(pane)
robot = {}
robot['Torso'] = {}
robot['Torso']['WaistLat'] = JointInfo(0, 0, -1.57, 1.57)
robot['Torso']['WaistSag'] = JointInfo(0, 0, -1.57, 1.57)
robot['Torso']['WaistYaw'] = JointInfo(0, 0, -1.57, 1.57)
# LArm
robot['Left Arm'] = {}
robot['Left Arm']['LShSag'] = JointInfo(0, 0, -3.40, 1.65)
robot['Left Arm']['LShLat'] = JointInfo(0, 0, -0.3, 2)
robot['Left Arm']['LShYaw'] = JointInfo(0, 0, -1.57, 1.57)
robot['Left Arm']['LElbj'] = JointInfo(0, 0, -2.3, 0)
robot['Left Arm']['LForearmPlate'] = JointInfo(0, 0, -1.57, 1.57)
robot['Left Arm']['LWrj1'] = JointInfo(0, 0, -0.5, 0.5)
robot['Left Arm']['LWrj2'] = JointInfo(0, 0, -0.78, 1.39)
for chain, joints in robot.iteritems():
page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
page.set_border_width(10)
for name, info in joints.iteritems():
hbox = Gtk.Box(spacing=6)
label = Gtk.Label(name)
label.set_size_request(100, 30)
hbox.add(label)
# two adjustments (initial value, min value, max value,
# step increment - press cursor keys to see!,
# page increment - click around the handle to see!,
# page size - not used here)
ad1 = Gtk.Adjustment(info.initial, info.min, info.max, 0.1, 1,
0)
# an horizontal scale
h_scale = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
adjustment=ad1)
# of integers (no digits)
h_scale.set_digits(1)
# that can expand horizontally if there is space in the grid (see
# below)
h_scale.set_hexpand(True)
# that is aligned at the top of the space allowed in the grid (see
# below)
h_scale.set_valign(Gtk.Align.START)
h_scale.set_size_request(280, 30)
# hbox.pack_start(h_scale, False, False, 0)
hbox.add(h_scale)
h_scale.connect("value-changed", self.scale_moved, h_scale,
name)
# adjustment = Gtk.Adjustment(0, 0, 100, 1, 10, 0)
# spinbutton = Gtk.SpinButton()
# spinbutton.set_adjustment(adjustment)
# hbox.pack_start(spinbutton, False, False, 0)
# check_numeric = Gtk.CheckButton("Numeric")
# check_numeric.connect("toggled", self.on_numeric_toggled)
# hbox.pack_start(check_numeric, False, False, 0)
# check_ifvalid = Gtk.CheckButton("If Valid")
# #check_ifvalid.connect("toggled", self.on_ifvalid_toggled)
# hbox.pack_start(check_ifvalid, False, False, 0)
page.add(hbox)
self.notebook.append_page(page, Gtk.Label(chain))
print str(e)
return headobj
def publish(rstdata):
informer.publishData(rstdata)
def callback(data):
rospy.loginfo(rospy.get_caller_id() + ' Received %s', data)
rstdata = convert(data)
publish(rstdata)
def ros_listen():
rospy.init_node('poselistener', anonymous=True)
rospy.Subscriber('/some/topic', String, callback)
rospy.spin()
if __name__ == '__main__':
logging.basicConfig()
rsb.converter.registerGlobalConverter(
rsb.converter.ProtocolBufferConverter(messageClass=HeadObject))
with rsb.createInformer("/pepper/headpose",
dataType=HeadObject) as informer:
ros_listen()
pass
self.listener = rsb.createListener(inscope)
self.lastImage = Queue(1)
self.restart_listener = rsb.createListener(self.notification_scope)
self.last_restart_request = Queue(1)
try:
rsb.converter.registerGlobalConverter(rsb.converter.ProtocolBufferConverter(messageClass=HeadObjects))
except Exception, e:
# If they are already loaded, the lib throws an exception ...
# print ">> [Error] While loading RST converter: ", e
pass
self.person_publisher = rsb.createInformer(outscope, dataType=HeadObjects)
# This must be set at last!
rsb.setDefaultParticipantConfig(rsb.ParticipantConfig.fromDefaultSources())
def add_last_image(self, image_event):
try:
self.lastImage.get(False)
except Exception, e:
pass
self.lastImage.put((np.asarray(image_event.data[:, :]), image_event.getId()), False)
def add_restart_request(self, restart_event):
try:
self.last_restart_request.get(False)
except Exception, e:
def __init__(self):
self.informer = rsb.createInformer(str(sys.argv[1]), dataType=np.ndarray)
self.listener = rsb.createListener(inscope)
self.lastImage = Queue(1)
self.restart_listener = rsb.createListener(self.notification_scope)
self.last_restart_request = Queue(1)
try:
rsb.converter.registerGlobalConverter(
rsb.converter.ProtocolBufferConverter(
messageClass=HeadObjects))
except Exception, e:
# If they are already loaded, the lib throws an exception ...
# print ">> [Error] While loading RST converter: ", e
pass
self.person_publisher = rsb.createInformer(outscope,
dataType=HeadObjects)
# This must be set at last!
rsb.setDefaultParticipantConfig(
rsb.ParticipantConfig.fromDefaultSources())
def add_last_image(self, image_event):
try:
self.lastImage.get(False)
except Exception, e:
pass
self.lastImage.put(
(np.asarray(image_event.data[:, :]), image_event.getId()), False)
def add_restart_request(self, restart_event):
try:
def mode(self, value):
self._mode = value
with rsb.createInformer(rsb_face_mode) as informer:
informer.publishData(value)
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import rsb
import logging
import optparse
if __name__ == '__main__':
usage = "Usage: %prog [options] <person_label>"
parser = optparse.OptionParser(usage=usage)
parser.add_option("-s", "--scope", action="store", type="string", dest="scope",
default="/ocvfacerec/trainer/retrainperson",
help="Send a Re-Train Command to this Scope")
(options, args) = parser.parse_args()
# Pacify logger.
logging.basicConfig()
if len(args) < 1:
print "Warning: You did not provide a person_label - will only retrain and restart the classifier!"
args.append("")
with rsb.createInformer(options.scope, dataType=str) as informer:
print "Publishing name '%s' to scope '%s'" % (str(args[0]), options.scope)
informer.publishData(str(args[0]))
