def __init__(self):
dynamic_reconfigure.server.Server(
DataCollectionServerConfig, self.reconfig_cb)
self.msg = {}
self.topics = rospy.get_param('~topics', [])
# validation for saving topics
for topic in self.topics:
required_fields = ['name', 'msg_class', 'fname', 'savetype']
for field in required_fields:
if field not in topic:
jsk_logfatal("Required field '{}' for topic is missing"
.format(field))
sys.exit(1)
self.params = rospy.get_param('~params', [])
self.slop = rospy.get_param('~slop', 0.1)
# validation for saving params
for param in self.params:
required_fields = ['key', 'fname', 'savetype']
for field in required_fields:
if field not in param:
jsk_logfatal("Required field '{}' for param is missing"
.format(field))
sys.exit(1)
self.server = rospy.Service('~save_request', Trigger, self.service_cb)
self.subs = []
for topic in self.topics:
msg_class = roslib.message.get_message_class(topic['msg_class'])
sub = rospy.Subscriber(topic['name'], msg_class, self.sub_cb,
callback_args=topic['name'])
self.subs.append(sub)
def __init__(self):
dynamic_reconfigure.server.Server(
DataCollectionServerConfig, self.reconfig_cb)
self.msg = {}
self.topics = rospy.get_param('~topics', [])
# validation for saving topics
for topic in self.topics:
required_fields = ['name', 'msg_class', 'fname', 'savetype']
for field in required_fields:
if field not in topic:
jsk_logfatal("Required field '{}' for topic is missing"
.format(field))
sys.exit(1)
self.params = rospy.get_param('~params', [])
self.slop = rospy.get_param('~slop', 0.1)
# validation for saving params
for param in self.params:
required_fields = ['key', 'fname', 'savetype']
for field in required_fields:
if field not in param:
jsk_logfatal("Required field '{}' for param is missing"
.format(field))
sys.exit(1)
if rospy.get_param('~with_request', True):
self.subs = []
for topic in self.topics:
msg_class = roslib.message.get_message_class(topic['msg_class'])
sub = rospy.Subscriber(topic['name'], msg_class, self.sub_cb,
callback_args=topic['name'])
self.subs.append(sub)
self.server = rospy.Service('~save_request', Trigger,
self.service_cb)
else:
self.subs = []
for topic in self.topics:
msg_class = roslib.message.get_message_class(topic['msg_class'])
sub = message_filters.Subscriber(topic['name'], msg_class)
self.subs.append(sub)
self.sync = message_filters.TimeSynchronizer(
self.subs, queue_size=rospy.get_param('~queue_size', 10))
self.sync.registerCallback(self.sync_sub_cb)
def test_jsk_logfatal(self, mock_get_name, mock_log):
mock_get_name.return_value = '/spam'
jsk_logfatal('spam')
mock_log.assert_called_with('[/spam] [TestJSKLogXXX::test_jsk_logfatal] spam')
def __init__(self):
dynamic_reconfigure.server.Server(DataCollectionServerConfig,
self.reconfig_cb)
self.msg = {}
self.topics = rospy.get_param('~topics', [])
# validation for saving topics
for topic in self.topics:
required_fields = ['name', 'msg_class', 'fname', 'savetype']
for field in required_fields:
if field not in topic:
jsk_logfatal(
"Required field '{}' for topic is missing".format(
field))
sys.exit(1)
self.params = rospy.get_param('~params', [])
self.slop = rospy.get_param('~slop', 0.1)
# validation for saving params
for param in self.params:
required_fields = ['key', 'fname', 'savetype']
for field in required_fields:
if field not in param:
jsk_logfatal(
"Required field '{}' for param is missing".format(
field))
sys.exit(1)
method = rospy.get_param('~method', 'request')
if method not in ['request', 'timer', 'all', 'message_filters']:
raise ValueError('Unexpected method: {}'.format(method))
use_message_filters = rospy.get_param('~message_filters', False)
self.timestamp_save_dir = rospy.get_param('~timestamp_save_dir', True)
self.wait_timer = rospy.get_param('~wait_timer', False)
self.wait_save_request = rospy.get_param('~wait_save_request', False)
if rospy.has_param('~with_request'):
rospy.logwarn('Deprecated param: ~with_request, Use ~method')
if not rospy.get_param('~with_request'):
use_message_filters = True
method = 'all'
if method == 'message_filters':
rospy.logwarn('Deprecated param: ~method: message_filters,'
'Use ~message_filters: true')
use_message_filters = True
method = 'all'
# set subscribers
self.subs = []
for topic in self.topics:
msg_class = roslib.message.get_message_class(topic['msg_class'])
if use_message_filters:
sub = message_filters.Subscriber(topic['name'], msg_class)
else:
sub = rospy.Subscriber(topic['name'],
msg_class,
self.sub_cb,
callback_args=topic['name'])
self.subs.append(sub)
# add synchoronizer if use_message_filters
if use_message_filters:
queue_size = rospy.get_param('~queue_size', 10)
approximate_sync = rospy.get_param('~approximate_sync', False)
if approximate_sync:
slop = rospy.get_param('~slop', 0.1)
self.sync = message_filters.ApproximateTimeSynchronizer(
self.subs, queue_size=queue_size, slop=slop)
else:
self.sync = message_filters.TimeSynchronizer(
self.subs, queue_size=queue_size)
# set collecting method
if method == 'request':
if use_message_filters:
self.sync.registerCallback(self.sync_sub_cb)
self.server = rospy.Service('~save_request', Trigger,
self.sync_service_cb)
else:
self.server = rospy.Service('~save_request', Trigger,
self.service_cb)
elif method == 'timer':
duration = rospy.Duration(1.0 / rospy.get_param('~hz', 1.0))
self.start = False
self.start_server = rospy.Service('~start_request', Trigger,
self.start_service_cb)
self.end_server = rospy.Service('~end_request', Trigger,
self.end_service_cb)
if use_message_filters:
self.sync.registerCallback(self.sync_sub_cb)
self.timer = rospy.Timer(duration, self.sync_timer_cb)
else:
self.timer = rospy.Timer(duration, self.timer_cb)
else:
assert method == 'all'
if use_message_filters:
self.sync.registerCallback(self.sync_sub_and_save_cb)
else:
rospy.logerr(
'~use_filters: False, ~method: all is not supported')
sys.exit(1)
def main():
rospy.init_node('fast_rcnn_caffenet')
# get parameters
try:
model_name = rospy.get_param('~model')
except KeyError as e:
rospy.logerr('Unspecified rosparam: {0}'.format(e))
sys.exit(1)
# FIXME: In CPU mode, there is no detections.
if not cuda.available:
jsk_logfatal('CUDA environment is required.')
sys.exit(1)
use_gpu = True
# setup model
PKG = 'jsk_perception'
rp = rospkg.RosPack()
data_path = osp.join(rp.get_path(PKG), 'trained_data')
if model_name == 'vgg_cnn_m_1024':
model = VGG_CNN_M_1024()
chainermodel = osp.join(data_path, 'vgg_cnn_m_1024.chainermodel')
elif model_name == 'vgg16':
model = VGG16FastRCNN()
chainermodel = osp.join(data_path, 'vgg16_fast_rcnn.chainermodel')
else:
rospy.logerr('Unsupported model: {0}'.format(model_name))
sys.exit(1)
jsk_loginfo('Loading chainermodel')
S.load_hdf5(chainermodel, model)
if use_gpu:
model.to_gpu()
jsk_loginfo('Finished loading chainermodel')
# assumptions
target_names = [
'__background__',
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor',
]
pixel_means = [102.9801, 115.9465, 122.7717]
fast_rcnn = FastRCNN(
model=model, target_names=target_names,
pixel_means=pixel_means, use_gpu=use_gpu)
rospy.spin()
def __init__(self):
dynamic_reconfigure.server.Server(
DataCollectionServerConfig, self.reconfig_cb)
self.msg = {}
self.topics = rospy.get_param('~topics', [])
# validation for saving topics
for topic in self.topics:
required_fields = ['name', 'msg_class', 'fname', 'savetype']
for field in required_fields:
if field not in topic:
jsk_logfatal("Required field '{}' for topic is missing"
.format(field))
sys.exit(1)
self.params = rospy.get_param('~params', [])
self.slop = rospy.get_param('~slop', 0.1)
# validation for saving params
for param in self.params:
required_fields = ['key', 'fname', 'savetype']
for field in required_fields:
if field not in param:
jsk_logfatal("Required field '{}' for param is missing"
.format(field))
sys.exit(1)
method = rospy.get_param('~method', 'request')
use_message_filters = rospy.get_param('~message_filters', False)
self.timestamp_save_dir = rospy.get_param('~timestamp_save_dir', True)
if rospy.has_param('~with_request'):
rospy.logwarn('Deprecated param: ~with_request, Use ~method')
if not rospy.get_param('~with_request'):
use_message_filters = True
method = None
if method == 'message_filters':
rospy.logwarn(
'Deprecated param: ~method: message_filters,'
'Use ~message_filters: true')
use_message_filters = True
method = None
# set subscribers
self.subs = []
for topic in self.topics:
msg_class = roslib.message.get_message_class(
topic['msg_class'])
if use_message_filters:
sub = message_filters.Subscriber(
topic['name'], msg_class)
else:
sub = rospy.Subscriber(
topic['name'], msg_class, self.sub_cb,
callback_args=topic['name'])
self.subs.append(sub)
# add synchoronizer if use_message_filters
if use_message_filters:
queue_size = rospy.get_param('~queue_size', 10)
approximate_sync = rospy.get_param('~approximate_sync', False)
if approximate_sync:
slop = rospy.get_param('~slop', 0.1)
self.sync = message_filters.ApproximateTimeSynchronizer(
self.subs, queue_size=queue_size, slop=slop)
else:
self.sync = message_filters.TimeSynchronizer(
self.subs, queue_size=queue_size)
# set collecting method
if method == 'request':
if use_message_filters:
self.sync.registerCallback(self.sync_sub_cb)
self.server = rospy.Service(
'~save_request', Trigger, self.sync_service_cb)
else:
self.server = rospy.Service(
'~save_request', Trigger, self.service_cb)
elif method == 'timer':
duration = rospy.Duration(1.0 / rospy.get_param('~hz', 1.0))
self.start = False
self.start_server = rospy.Service(
'~start_request', Trigger, self.start_service_cb)
self.end_server = rospy.Service(
'~end_request', Trigger, self.end_service_cb)
if use_message_filters:
self.sync.registerCallback(self.sync_sub_cb)
self.timer = rospy.Timer(duration, self.sync_timer_cb)
else:
self.timer = rospy.Timer(duration, self.timer_cb)
else:
if use_message_filters:
self.sync.registerCallback(self.sync_sub_and_save_cb)
else:
rospy.logerr(
'~use_filters: False, ~method: None is not supported')
sys.exit(1)
def main():
rospy.init_node("fast_rcnn_caffenet")
# get parameters
try:
model_name = rospy.get_param("~model")
except KeyError as e:
rospy.logerr("Unspecified rosparam: {0}".format(e))
sys.exit(1)
# FIXME: In CPU mode, there is no detections.
if not cuda.available:
jsk_logfatal("CUDA environment is required.")
sys.exit(1)
use_gpu = True
# setup model
PKG = "jsk_perception"
rp = rospkg.RosPack()
data_path = osp.join(rp.get_path(PKG), "trained_data")
if model_name == "vgg_cnn_m_1024":
model = VGG_CNN_M_1024()
chainermodel = osp.join(data_path, "vgg_cnn_m_1024.chainermodel")
elif model_name == "vgg16":
model = VGG16FastRCNN()
chainermodel = osp.join(data_path, "vgg16_fast_rcnn.chainermodel")
else:
rospy.logerr("Unsupported model: {0}".format(model_name))
sys.exit(1)
jsk_loginfo("Loading chainermodel")
S.load_hdf5(chainermodel, model)
if use_gpu:
model.to_gpu()
jsk_loginfo("Finished loading chainermodel")
# assumptions
target_names = [
"__background__",
"aeroplane",
"bicycle",
"bird",
"boat",
"bottle",
"bus",
"car",
"cat",
"chair",
"cow",
"diningtable",
"dog",
"horse",
"motorbike",
"person",
"pottedplant",
"sheep",
"sofa",
"train",
"tvmonitor",
]
pixel_means = [102.9801, 115.9465, 122.7717]
fast_rcnn = FastRCNN(model=model, target_names=target_names, pixel_means=pixel_means, use_gpu=use_gpu)
rospy.spin()
def test_jsk_logfatal(self, mock_log):
jsk_logfatal('spam')
mock_log.assert_called_with('[TestJSKLogXXX::test_jsk_logfatal] spam')
def main():
rospy.init_node('fast_rcnn_caffenet')
# get parameters
try:
model_name = rospy.get_param('~model')
except KeyError as e:
rospy.logerr('Unspecified rosparam: {0}'.format(e))
sys.exit(1)
# FIXME: In CPU mode, there is no detections.
if not cuda.available:
jsk_logfatal('CUDA environment is required.')
sys.exit(1)
use_gpu = True
# setup model
PKG = 'jsk_perception'
rp = rospkg.RosPack()
data_path = osp.join(rp.get_path(PKG), 'trained_data')
if model_name == 'vgg_cnn_m_1024':
model = VGG_CNN_M_1024()
chainermodel = osp.join(data_path, 'vgg_cnn_m_1024.chainermodel')
elif model_name == 'vgg16':
model = VGG16FastRCNN()
chainermodel = osp.join(data_path, 'vgg16_fast_rcnn.chainermodel')
else:
rospy.logerr('Unsupported model: {0}'.format(model_name))
sys.exit(1)
jsk_loginfo('Loading chainermodel')
S.load_hdf5(chainermodel, model)
if use_gpu:
model.to_gpu()
jsk_loginfo('Finished loading chainermodel')
# assumptions
target_names = [
'__background__',
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor',
]
pixel_means = [102.9801, 115.9465, 122.7717]
fast_rcnn = FastRCNN(
model=model, target_names=target_names,
pixel_means=pixel_means, use_gpu=use_gpu)
rospy.spin()
