def __init__(self,
options,
title='Exclusive Options',
selected_index=None,
parent=None):
super(ExclusiveOptionGroup, self).__init__()
self.setTitle(title)
self.setLayout(QVBoxLayout())
self._button_group = QButtonGroup()
self._button_group.setExclusive(True)
self._options = options
if parent == None:
parent = self
for (button_id, option) in enumerate(self._options):
radio_button = QRadioButton(
option.get('title', 'option %d' % button_id))
radio_button.setEnabled(option.get('enabled', True))
radio_button.setChecked(
option.get('selected', False) or button_id == selected_index)
radio_button.setToolTip(option.get('tooltip', ''))
self._button_group.addButton(radio_button, button_id)
parent.layout().addWidget(radio_button)
if 'description' in option:
parent.layout().addWidget(QLabel(option['description']))
def add_config(self, title, choices, single_choice=True):
'''
create a UI element for selecting options for one variation
and put it in a scrollArea
'''
scroll = QScrollArea()
group_box = QGroupBox(title)
group_box.setFlat(True)
layout = QVBoxLayout()
if len(choices) > 5 and single_choice:
combo_box = QComboBox(group_box)
for obj in choices:
combo_box.addItem(obj)
layout.addWidget(combo_box)
else:
for obj in choices:
if single_choice:
layout.addWidget(QRadioButton(obj, group_box))
else:
layout.addWidget(QCheckBox(obj, group_box))
layout.addStretch(1)
group_box.setLayout(layout)
scroll.setWidget(group_box)
scroll.setWidgetResizable(True)
return group_box, scroll
def __init__(self, parent=None):
super(RawDataSelector, self).__init__()
self.parent = parent
self.setTitle('Select bag file')
# Init the components
self.bag1RadioBtn = QRadioButton('ground truth')
self.bag2RadioBtn = QRadioButton('camera')
# connect the signals to the slots
self.bag1RadioBtn.clicked.connect(self.btn1Clicked)
self.bag2RadioBtn.clicked.connect(self.btn2Clicked)
# layout
layout = QVBoxLayout()
layout.addWidget(self.bag1RadioBtn)
layout.addWidget(self.bag2RadioBtn)
self.setLayout(layout)
def setupButtons(self, yaml_file):
"""
Parse yaml file and setup Buttons. Format of the yaml file should be:
- name: 'button name' (required)
image: 'path to image for icon' (optional)
image_size: 'width and height of icon' (optional)
service: 'service' (required)
column: 'column index' (optional, defaults to 0)
"""
self.buttons = []
with open(yaml_file) as f:
yaml_data = yaml.load(f)
# lookup colum direction
direction = 'vertical'
for d in yaml_data:
if d.has_key('direction'):
if d['direction'] == 'horizontal':
direction = 'horizontal'
else: # d['direction'] == 'vertical':
direction = 'vertical'
yaml_data.remove(d)
break
# lookup column num
column_indices = [d['column'] for d in yaml_data]
max_column_index = max(*column_indices)
if direction == 'vertical':
self.layout = QHBoxLayout()
self.layout_boxes = [
QVBoxLayout() for i in range(max_column_index + 1)
]
else: # direction == 'horizontal'
self.layout = QVBoxLayout()
self.layout_boxes = [
QHBoxLayout() for i in range(max_column_index + 1)
]
self.button_groups = [
QGroupBox() for i in range(max_column_index + 1)
]
for button_data in yaml_data:
# check if all the field is available
if not button_data.has_key("name"):
self.showError("name field is missed in yaml")
raise Exception("name field is missed in yaml")
if not button_data.has_key("service"):
self.showError("service field is missed in yaml")
raise Exception("service field is missed in yaml")
if self.button_type == "push":
button = QToolButton()
else: # self.button_type == "radio":
button = QRadioButton()
button.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
if button_data.has_key("image"):
image_file = get_filename(
button_data["image"])[len("file://"):]
if os.path.exists(image_file):
icon = QtGui.QIcon(image_file)
button.setIcon(icon)
if button_data.has_key("image_size"):
button.setIconSize(
QSize(button_data["image_size"][0],
button_data["image_size"][1]))
else:
button.setIconSize(QSize(100, 100))
if button_data.has_key("name"):
name = button_data['name']
button.setText(name)
if button_data.has_key('service_type'):
if button_data['service_type'] == 'Trigger':
service_type = Trigger
elif button_data['service_type'] == 'Empty':
service_type = Empty
elif button_data['service_type'] == 'SetBool':
service_type = SetBool
else:
raise Exception("Unsupported service type: {}".format(
button_data['service_type']))
else:
service_type = Empty
if service_type == SetBool:
button.setCheckable(True)
button.clicked.connect(
self.buttonCallback(button_data['service'], service_type,
button))
if self.button_type == "push":
button.setToolButtonStyle(
QtCore.Qt.ToolButtonTextUnderIcon)
if ((self.button_type == "radio" or service_type == SetBool)
and ("default_value" in button_data
and button_data['default_value'])):
button.setChecked(True)
self.layout_boxes[button_data['column']].addWidget(button)
self.buttons.append(button)
for i in range(len(self.button_groups)):
self.button_groups[i].setLayout(self.layout_boxes[i])
for group in self.button_groups:
self.layout.addWidget(group)
self.setLayout(self.layout)
def __init__(self):
super(MyWidget, self).__init__()
self.brd = CvBridge()
self.view = RGB
ui_file = os.path.join(
rospkg.RosPack().get_path('balloon_color_picker'), 'resource',
'ColorPlugin.ui')
rospy.loginfo('uifile {}'.format(ui_file))
# self.log_info('uifile {}'.format(ui_file))
loadUi(ui_file, self)
# Give QObjects reasonable names
self.setObjectName('ColorPluginUi')
self.uav_name = os.environ['UAV_NAME']
self.orig_h = 920
self.orig_w = 1080
self.hist_hsv_orig_h = 180
self.hist_hsv_orig_w = 256
self.hist_lab_orig_h = 256
self.hist_lab_orig_w = 256
self.hist_status = HSV
self.select_status = HIST_SELECTION
self.crop_stat = IMG
self.hist_mask = np.zeros([self.hist_hsv_orig_h, self.hist_hsv_orig_w])
self.hist_mask_lab = np.zeros(
[self.hist_lab_orig_h, self.hist_lab_orig_w])
self.cur_hist_hs = None
self.cur_hist_ab = None
self.selected_count = 0
# ROS services
# #{ ros services
self.sigma_caller = rospy.ServiceProxy('change_sigma', ChangeSigma)
self.sigma_lab_caller = rospy.ServiceProxy('change_sigma_lab',
ChangeSigmaLab)
self.caller = rospy.ServiceProxy('capture', Capture)
self.capture_cropped_srv = rospy.ServiceProxy('capture_cropped',
CaptureCropped)
self.get_count = rospy.ServiceProxy('get_count', GetCount)
self.clear_count = rospy.ServiceProxy('clear_count', ClearCount)
self.get_config = rospy.ServiceProxy('get_config', GetConfig)
self.get_params = rospy.ServiceProxy('get_params', Params)
self.freeze_service = rospy.ServiceProxy('freeze', Freeze)
self.update_service = rospy.ServiceProxy('change_obd', UpdateObd)
self.change_callback = rospy.ServiceProxy('change_callback',
ChangeCallback)
self.capture_hist = rospy.ServiceProxy('capture_hist', CaptureHist)
# #} end of ros services rospy.wait_for_service('capture')
rospy.loginfo(
'waiting for service "get_params" from computation module \n if this is more than 5 secs check for topic remapping'
)
# self.log_info('waiting for service')
rospy.loginfo('uav_name {}'.format(os.environ['UAV_NAME']))
# self.log_info('uav_name {}'.format(os.environ['UAV_NAME']))
rospy.wait_for_service('get_params')
self.config_path, self.save_path, self.circled_param, self.circle_filter_param, self.circle_luv_param, self.object_detect_param, self.save_to_drone = self.set_params(
)
# SUBS
# #{ ros subs
self.balloon_sub = rospy.Subscriber(self.circled_param,
RosImg,
self.img_callback,
queue_size=1)
self.filter_sub = rospy.Subscriber(self.circle_filter_param,
RosImg,
self.filter_callback,
queue_size=1)
self.filter_luv = rospy.Subscriber(self.circle_luv_param,
RosImg,
self.luv_callback,
queue_size=1)
self.obj_det_sb = rospy.Subscriber(self.object_detect_param,
RosImg,
self.obj_det_callback,
queue_size=1)
# self.hsv = message_filters.Subscriber(self.circle_filter_param, RosImg)
# self.luv = message_filters.Subscriber(self.circle_luv_param, RosImg)
# self.ts = message_filters.ApproximateTimeSynchronizer([self.luv, self.hsv], 1, 0.5)
# self.ts.registerCallback(self.both_callback)
# #} end of ros subs
self.colors = self.load_config(self.config_path)
self.add_buttons(self.colors)
# # DEFAULT IMAGE
# img = cv2.imread('/home/mrs/balloon_workspace/src/ros_packages/balloon_color_picker/data/blue.png')
# cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# h,w,c = img.shape
# q_img = QImage(img.data, w,h,3*w, QImage.Format_RGB888)
# q = QPixmap.fromImage(q_img)
#DIRECTORY
#default
self.directory.setText(self.save_path + "Red.yaml")
self.color_name = "red"
self.save_button.clicked.connect(self.save_config)
#PLOT
self.figure = Figure()
self.figure_luv = Figure()
self.canvas = FigureCanvas(self.figure)
self.canvas_luv = FigureCanvas(self.figure_luv)
self.canvas.setParent(self.inner)
# self.toolbar = NavigationToolbar(self.canvas,self)
# self.toolbar_luv = NavigationToolbar(self.canvas_luv,self)
# self.toolbar.setParent(self.inner)
# self.toolbar_luv.setParent(self.inner_luv)
self.canvas_luv.setParent(self.inner_luv)
self.inner_luv.hide()
self.inner_luv_hist.hide()
#SLIDER CONFIG
# #{ slider config
self.sigma_slider.setRange(0, 100)
self.sigma_slider.setSingleStep(1)
self.sigma_slider.setValue(6)
self.sigma_slider.valueChanged.connect(self.slider_event)
self.sigma_slider_s.setRange(0, 100)
self.sigma_slider_s.setSingleStep(1)
self.sigma_slider_s.setValue(6)
self.sigma_slider_s.valueChanged.connect(self.slider_event)
self.sigma_slider_v.setRange(0, 100)
self.sigma_slider_v.setSingleStep(1)
self.sigma_slider_v.setValue(80)
self.sigma_slider_v.valueChanged.connect(self.slider_event)
self.sigma_slider_lab.setRange(0, 100)
self.sigma_slider_lab.setSingleStep(1)
self.sigma_slider_lab.setValue(80)
self.sigma_slider_lab.valueChanged.connect(self.slider_event_lab)
self.sigma_slider_a.setRange(0, 100)
self.sigma_slider_a.setSingleStep(1)
self.sigma_slider_a.setValue(6)
self.sigma_slider_a.valueChanged.connect(self.slider_event_lab)
self.sigma_slider_b.setRange(0, 100)
self.sigma_slider_b.setSingleStep(1)
self.sigma_slider_b.setValue(6)
self.sigma_slider_b.valueChanged.connect(self.slider_event_lab)
# #} end of slider config
# #{ font configs
#SIGMA TEXT
font = self.font()
font.setPointSize(16)
self.sigma_value.setFont(font)
self.sigma_value_s.setFont(font)
self.sigma_value_v.setFont(font)
self.sigma_value_lab.setFont(font)
self.sigma_value_a.setFont(font)
self.sigma_value_b.setFont(font)
#IMAGE COUNT TEXT
self.image_count.setFont(font)
#BOX FOR BUTTONS font
# self.color_buttons.setFont(font)
font.setPointSize(14)
self.sigma_value.setFont(font)
self.log_text.setFont(font)
#LAB HSV TEXT
font.setPointSize(23)
self.label_lab.setFont(font)
self.label_lab.hide()
self.label_hsv.setFont(font)
self.label_hsv.hide()
# #} end of font configs
# BUTTONS
self.change.clicked.connect(self.switch_view_hsv)
self.change_both.clicked.connect(self.switch_view_both)
self.change_luv.clicked.connect(self.switch_view_luv)
self.change_object.clicked.connect(self.switch_view_object_detect)
self.capture_button.clicked.connect(self.capture)
self.clear_button.clicked.connect(self.clear)
self.freeze_button.clicked.connect(self.freeze)
self.update_button.clicked.connect(self.update_obd)
# self.wdg_img.setPixmap(q)
# self.box_layout.addWidget(self.toolbar)
# self.inner.box_layout.addWidget(self.canvas)
#shortcuts
self.short_capture = QShortcut(QKeySequence("C"), self)
self.short_capture.activated.connect(self.capture)
self.short_hsv = QShortcut(QKeySequence("1"), self)
self.short_hsv.activated.connect(self.switch_view_hsv)
self.short_lab = QShortcut(QKeySequence("2"), self)
self.short_lab.activated.connect(self.switch_view_luv)
self.short_object_detect = QShortcut(QKeySequence("3"), self)
self.short_object_detect.activated.connect(
self.switch_view_object_detect)
self.short_object_detect_update = QShortcut(QKeySequence("U"), self)
self.short_object_detect_update.activated.connect(self.update_obd)
self.short_both = QShortcut(QKeySequence("4"), self)
self.short_both.activated.connect(self.switch_view_both)
self.short_save = QShortcut(QKeySequence("S"), self)
self.short_save.activated.connect(self.save_config)
self.short_clear = QShortcut(QKeySequence("N"), self)
self.short_clear.activated.connect(self.clear)
self.short_freeze = QShortcut(QKeySequence("F"), self)
self.short_freeze.activated.connect(self.freeze)
vbx = QVBoxLayout()
but_hsv = QRadioButton()
but_hsv.setText('HSV')
but_hsv.setChecked(True)
self.color_space = 'HSV'
but_hsv.clicked.connect(self.set_colorspace_hsv)
vbx.addWidget(but_hsv)
but_lab = QRadioButton()
but_lab.setText('LAB')
but_lab.clicked.connect(self.set_colorspace_lab)
vbx.addWidget(but_lab)
vbx.addStretch(1)
self.radio_buttons.setLayout(vbx)
vbx_method = QVBoxLayout()
but_lut = QRadioButton()
but_lut.setText('LUT')
but_lut.setChecked(False)
but_lut.clicked.connect(self.set_method_lut)
vbx_method.addWidget(but_lut)
but_thr = QRadioButton()
but_thr.setText('Threshold')
but_thr.setChecked(True)
but_thr.clicked.connect(self.set_method_thr)
vbx_method.addWidget(but_thr)
vbx.addStretch(1)
self.radio_buttons_method.setLayout(vbx_method)
self.load_method = 'THR'
# self.mousePressEvent.connect(self.mousePressEvent)
self.plotted = False
self._rubber = None
self.frozen = False
def __init__(self, context):
#Start client -rosbridge
self.client = roslibpy.Ros(host='localhost', port=5803)
self.client.run()
super(Dashboard, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('Dashboard')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
if not args.quiet:
print 'arguments: ', args
print 'unknowns: ', unknowns
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_dashboard'), 'resource', 'Dashboard.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('DashboardUi')
# Set up signal-slot connections
self._widget.set_imu_angle_button.clicked.connect(self.setImuAngle)
self._widget.imu_angle.valueChanged.connect(self.imuAngleChanged)
self._widget.auto_wall_dist_button.clicked.connect(self.setAutoWallDist)
self._widget.auto_wall_dist.valueChanged.connect(self.autoWallDistChanged)
self._widget.ball_reset_button.clicked.connect(self.resetBallCount)
self._widget.ball_reset_count.valueChanged.connect(self.resetBallChanged)
# Add buttons for auto modes
v_layout = self._widget.auto_mode_v_layout #vertical layout storing the buttons
self.auto_mode_button_group = QButtonGroup(self._widget) # needs to be a member variable so the publisher can access it to see which auto mode was selected
# Search for auto_mode config items
for i in range(1,100): # loop will exit when can't find the next auto mode, so really only a while loop needed, but exiting at 100 will prevent infinite looping
if rospy.has_param("/auto/auto_mode_" + str(i)):
auto_sequence = rospy.get_param("/auto/auto_mode_" + str(i))
new_auto_mode = QWidget()
new_h_layout = QHBoxLayout()
new_h_layout.setContentsMargins(0,0,0,0)
new_button = QRadioButton("Mode " + str(i))
new_button.setStyleSheet("font-weight: bold")
self.auto_mode_button_group.addButton(new_button, i) #second arg is the button's id
new_h_layout.addWidget( new_button )
new_h_layout.addWidget( QLabel(", ".join(auto_sequence)) )
hSpacer = QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum)
new_h_layout.addItem(hSpacer)
new_auto_mode.setLayout( new_h_layout )
v_layout.addWidget(new_auto_mode)
else:
print(str(i-1) + " auto modes found.")
# if no auto modes found, inform the user with a label
if (i-1) == 0:
v_layout.addWidget( QLabel("No auto modes found") )
break #break out of for loop searching for auto modes
# auto state stuff
self.autoState = 0
self.displayAutoState() #display initial auto state
# publish thread
publish_thread = Thread(target=self.publish_thread) #args=(self,))
publish_thread.start()
# number balls display
self.zero_balls = QPixmap(":/images/0_balls.png")
self.one_ball = QPixmap(":/images/1_ball.png")
self.two_balls = QPixmap(":/images/2_balls.png")
self.three_balls = QPixmap(":/images/3_balls.png")
self.four_balls = QPixmap(":/images/4_balls.png")
self.five_balls = QPixmap(":/images/5_balls.png")
self.more_than_five_balls = QPixmap(":/images/more_than_5_balls.png")
self.n_balls = -1 #don't know n balls at first
#in range stuff
self.shooter_in_range = False
self.turret_in_range = False
self.in_range_pixmap = QPixmap(":/images/GreenTarget.png")
self.not_in_range_pixmap = QPixmap(":/images/RedTarget.png")
self._widget.in_range_display.setPixmap(self.not_in_range_pixmap)
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
#initialize subscribers last, so that any callbacks they execute won't interfere with init
auto_state_listener = roslibpy.Topic(self.client, '/auto/auto_state', 'behavior_actions/AutoState')
self.auto_state_sub = auto_state_listener.subscribe(self.autoStateCallback)
n_balls_listener = roslibpy.Topic(self.client,'/num_powercells','std_msgs/UInt8')
self.n_balls_sub = n_balls_listener.subscribe(self.nBallsCallback)
shooter_in_range_listener = roslibpy.Topic(self.client, '/shooter/shooter_in_range', std_msgs.msg.Bool)
self.shooter_in_range_sub = shooter_in_range_listener.subscribe(self.shooterInRangeCallback)
turret_in_range_listener = roslibpy.Topic(self.client, '/align_to_shoot/turret_in_range', std_msgs.msg.Bool)
self.turret_in_range_sub = turret_in_range_listener.subscribe(self.turretInRangeCallback)
self.autoStateSignal.connect(self.autoStateSlot)
self.nBallsSignal.connect(self.nBallsSlot)
self.shooterInRangeSignal.connect(self.shooterInRangeSlot)
self.turretInRangeSignal.connect(self.turretInRangeSlot)
def __init__(self):
super(TopicSelection, self).__init__()
master = rosgraph.Master('rqt_bag_recorder')
self.setWindowTitle("Record a Simulation")
self.resize(650, 720)
pre = TS.get_time_series_pre_feature_options()
glob = TS.get_global_time_series_features_options()
# print pre
# print glob
all_topics = S.get_topics_options()
keys = all_topics.keys()
# print all_topics.keys()[0]
self.plp_filename = ""
self.group_selected_items = dict()
self.group_areas = dict()
self.group_main_widget = dict()
self.group_selection_vlayout = dict()
self.group_item_all = dict()
# self.main_vlayout = QVBoxLayout(self)
self.main_vlayout = QVBoxLayout(self)
self.group_label = dict()
self.selected_topics = []
self.items_list = []
for group_name in all_topics:
self.group_selected_items[group_name] = []
self.group_areas[group_name] = QScrollArea(self)
self.group_main_widget[group_name] = QWidget(
self.group_areas[group_name])
self.group_label[group_name] = QLabel(group_name, self)
self.group_label[group_name].setAlignment(Qt.AlignCenter)
self.main_vlayout.addWidget(self.group_label[group_name])
self.main_vlayout.addWidget(self.group_areas[group_name])
self.group_selection_vlayout[group_name] = QVBoxLayout(self)
self.group_item_all[group_name] = MyQCheckBox(
"All", self, self.group_selection_vlayout[group_name], None)
self.MakeCheckBoxList(self.group_selection_vlayout[group_name],
self.group_selected_items[group_name],
all_topics[group_name],
self.group_item_all[group_name])
self.group_main_widget[group_name].setLayout(
self.group_selection_vlayout[group_name])
self.group_areas[group_name].setWidget(
self.group_main_widget[group_name])
self.label1 = QLabel("Scenarios", self)
self.label1.setAlignment(Qt.AlignCenter)
self.main_vlayout.addWidget(self.label1)
scanarios = S.get_scenarios_options()
self.scanarios_answer = scanarios
self.map_answer = dict()
# print scanarios
keys1 = scanarios.keys()
# print keys1[0]
# print scanarios[keys1[0]]["name"]
# print scanarios[keys1[0]]["params"]
#
# for item in scanarios[keys1[0]]["params"]:
# print item
self.radio_items = dict()
self.number_group = QButtonGroup(self)
for id_radio in scanarios:
self.radio_items[id_radio] = QRadioButton(
scanarios[id_radio]["name"])
self.number_group.addButton(self.radio_items[id_radio])
self.main_vlayout.addWidget(self.radio_items[id_radio])
self.radio_items[id_radio].setChecked(False)
self.radio_items[id_radio].clicked.connect(
partial(self.callConsult, scanarios[id_radio]["params"],
id_radio))
self.select_path = QLineEdit()
self.save_path = QLineEdit()
self.select_path.setEnabled(False)
self.save_path.setEnabled(False)
self.plp_button = QPushButton("Select PLP Python File...", self)
self.plp_button.clicked.connect(self.onPlpClicked)
self.two_buttons1 = QHBoxLayout(self)
self.two_buttons1.addWidget(self.plp_button)
self.two_buttons1.addWidget(self.select_path)
self.main_vlayout.addLayout(self.two_buttons1)
# self.label = QLabel("live Topics", self)
# self.label.setAlignment(Qt.AlignCenter)
#
# self.main_vlayout.addWidget(self.label)
# self.area = QScrollArea(self)
# self.main_widget = QWidget(self.area)
self.ok_button = QPushButton("Record", self)
self.ok_button.clicked.connect(self.onButtonClicked)
self.ok_button.setEnabled(False)
self.choose_button = QPushButton("Get Last Export Choose", self)
self.choose_button.clicked.connect(self.onButtonChooseCliked)
self.clear_button = QPushButton("Clear Selection", self)
self.clear_button.clicked.connect(self.onClearClicked)
self.choose_clear_buttons = QHBoxLayout(self)
self.choose_clear_buttons.addWidget(self.choose_button)
self.choose_clear_buttons.addWidget(self.clear_button)
self.main_vlayout.addLayout(self.choose_clear_buttons)
# self.main_vlayout.addRow(self.choose_button, self.clear_button)
# self.from_nodes_button = QPushButton("From Nodes", self)
# self.from_nodes_button.clicked.connect(self.onFromNodesButtonClicked)
# self.main_vlayout.addWidget(self.area)
# self.main_vlayout.addWidget(self.choose_button)
self.main_vlayout.addWidget(self.ok_button)
# self.main_vlayout.addWidget(self.from_nodes_button)
self.setLayout(self.main_vlayout)
self.selection_vlayout = QVBoxLayout(self)
# self.item_all = MyQCheckBox("All", self, self.selection_vlayout, None)
# self.item_all.stateChanged.connect(lambda x: self.updateList(x, self.item_all, None))
# self.selection_vlayout.addWidget(self.item_all)
# topic_data_list4 = map(lambda l: l[0], master.getPublishedTopics(''))
# topic_data_list4.sort()
# for topic in topic_data_list4:
# self.addCheckBox(topic, self.selection_vlayout, self.selected_topics)
# self.main_widget.setLayout(self.selection_vlayout)
# self.area.setWidget(self.main_widget)
# print S.get_scenarios_options()
self.show()
def initRadioButtons(self):
for operation in self.operations:
btn = QRadioButton(operation)
btn.clicked.connect(lambda state, x=operation: self.switchOperation(x))
self.layout.addWidget(btn)