def __init__( self, *args, **kwargs ):
tk.Tk.__init__( self, *args, **kwargs )
self.protocol( "WM_DELETE_WINDOW", self.destroy )
self.wm_title("bent file explorer")
self.text_last_command = tk.StringVar()
#print( self.winfo_screenwidth() )
widget_file_explorer = Explorer( self )
frame_bottom = tk.Frame( self )
btn_quit = tk.Button( frame_bottom,
text="QUIT",
command=self.Quit )
lbl_last_command = tk.Label( frame_bottom,
textvariable = self.text_last_command )
widget_file_explorer.grid( row=0, sticky='nesw' )
#post grid row column configure - must be called after grid but should be specified by the widget itself, not here
widget_file_explorer.pgrc_configure()
frame_bottom.grid( row=1, sticky='nesw' )
btn_quit.grid( column=2, sticky='e' )
lbl_last_command.grid( column=0, sticky='w' )
self.rowconfigure('0', weight=1)
self.columnconfigure('all', weight=1)
frame_bottom.columnconfigure('all', weight=1)
def print_map(win_map, path, start_row, start_col):
"""
Prints a map of paths that lead to treasure
:param start_row: The starting row of the map
:param start_col: The starting column of the map
:param path: the stack of directions that have been made
:param win_map: The map that has the winning paths on it
:return: none
"""
if path.size() == 0:
return
else:
path = copy.deepcopy(path)
path.items.reverse()
winner = Explorer(start_row, start_col)
print(
"The following is the total paths to treasure. Underscore's denote the path to a treasure:"
)
for i in range(path.size() - 1):
forward = path.pop()
if forward == "north":
winner.move_n()
elif forward == "south":
winner.move_s()
elif forward == "east":
winner.move_e()
elif forward == "west":
winner.move_w()
win_map[winner.row][winner.col] = "_"
for i in win_map:
print(i)
def explore(fs):
from Explorer import Explorer
renderer = Explorer()
renderer.render(fs.root())
gtk.mainloop()
return
def explore(fs):
from Explorer import Explorer
renderer = Explorer()
renderer.render(fs.root())
gtk.mainloop()
return
def Run(self):
self._universe = Universe()
w = Explorer(self._universe, 0, self._maze._entrance, self._maze, {},
"")
self._universe.AddWorldsForEvaluation([w])
solutionWorld = self._universe.Run()
print(f"Short path to solution is {solutionWorld._generation}.")
return solutionWorld._generation
def main():
cave_map = parse_file("cave_2.txt")
win_map = copy.deepcopy(cave_map)
start_row, start_col = find_start(cave_map)
test = Explorer(start_row, start_col)
path = Stack()
not_finished = True
while not_finished:
not_finished = advance(test, cave_map, path, win_map, start_row,
start_col)
print("There was no more treasure.")
class Tester:
def __init__(self):
self.explorer = Explorer(True)
def test(self):
file = open('resultsfile.txt', 'w')
i = 0
for file_name in os.listdir('labelme-luna16-Data/test'):
print(file_name)
image = cv2.imread(
f'labelme-luna16-Data/test/{file_name}/images/img.png', 0)
image_label = cv2.imread(
f'labelme-luna16-Data/test/{file_name}/label_viz.png')
label = cv2.imread(
f'labelme-luna16-Data/test/{file_name}/masks/label.png')
label = cv2.cvtColor(label, cv2.COLOR_BGR2GRAY)
ret, label = cv2.threshold(label, 20, 255, cv2.THRESH_BINARY)
boxes, mask = self.explorer.explore(image)
image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
if not boxes.size == 0:
for box in boxes:
cls = str(box[0])
x1 = int(box[1])
y1 = int(box[2])
x2 = int(box[3])
y2 = int(box[4])
image = cv2.rectangle(image, (x1, y1), (x2, y2),
(0, 0, 255), 1)
image = cv2.putText(image, cls[:5], (x1, y1),
cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(0, 0, 255))
file.write(file_name + '\n')
file.write(str(int(boxes.size // 5)) + '\n')
if not boxes.size == 0:
for box in boxes:
cls = str(box[0])
x1 = int(box[1])
y1 = int(box[2])
w = int(box[3] - box[1])
h = int(box[4] - box[2])
file.write(f'{x1} {y1} {w} {h} {cls}\n')
# image = cv2.resize(image,None,fx=2,fy=2)
cv2.imshow('JK', image)
cv2.imshow('mask', mask)
cv2.imshow('labelviz', image_label)
cv2.imwrite(f'biaozhu/{i}.png', label)
cv2.imwrite(f'yuche/{i}.png', mask)
i += 1
#if cv2.waitKey(1) == ord('c'):
#break
file.close()
def __init__(self,
x_min,
y_min,
x_max,
y_max,
show_gui=False,
url="http://localhost:50000"):
self.__robot = Robot(url)
self.__robot_drive = RobotDrive(self.__robot)
# Map grid size in meters per square (robot is 450 x 400 x 243 (LxWxH))
MAP_GRID_SIZE = .2
# Set coordinates and dimensions of local map area within the world coordinate system
width_wcs = x_max - x_min
height_wcs = y_max - y_min
width_grid = math.ceil(width_wcs / MAP_GRID_SIZE)
height_grid = math.ceil(height_wcs / MAP_GRID_SIZE)
self.__local_map = OccupancyGrid(x_min, y_min, MAP_GRID_SIZE,
height_grid, width_grid)
self.__laser = LaserSensorModel(self.__robot, self.__local_map)
self.__show_map = ShowMap(height_grid, width_grid, show_gui)
self.__explorer = Explorer(self.__robot, self.__local_map)
self.__path_planner = WavefrontPlanner(self.__robot, self.__local_map)
self.__obstacle_avoider = ObstacleAvoider(self.__robot,
self.__local_map)
# Keep track of number of steps taken in the main_loop
self.__SCAN_FREQUENCY = 10
self.__cycles = 0
self.__loop_running = False
self.__take_a_scan = False
self.__determine_frontiers = False
self.__in_reactive_state = False
self.__in_warning = False
self.__in_danger = False
self.__in_reactive = False
def main():
parser = argparse.ArgumentParser(
description='Creates a classification dataset from a segmentation one.'
)
parser.add_argument(
'path',
type=str,
help='Absolute path containing the images and masks folders.')
parser.add_argument('--patch_size',
type=int,
default=224,
help='Size of each patch.')
parser.add_argument('--max_patches_per_image',
type=int,
default=100,
help='How many patches to extract from each image.')
args = parser.parse_args()
explorer = Explorer(args.path)
converter = Converter(explorer,
patch_size=args.patch_size,
max_patches_per_image=args.max_patches_per_image)
converter.process_images()
def sample(self, keep=None):
"""
Sample the posterior and return the weighted average result of the
Model.
The more sensible result of this method is a SampleList which contains
samples taken from the posterior distribution.
Parameters
----------
keep : None or dict of {int:float}
Dictionary of indices (int) to be kept at a fixed value (float)
Hyperparameters follow model parameters
The values will override those at initialization.
They are only used in this call of fit.
"""
if keep is None:
keep = self.keep
fitlist = self.makeFitlist(keep=keep)
self.initWalkers(fitlist=fitlist)
for eng in self.engines:
eng.walkers = self.walkers
self.distribution.ncalls = 0 # reset number of calls
self.plotData()
if self.verbose >= 1:
print("Fit", ("all" if keep is None else fitlist), "parameters of")
print(" ", self.model._toString(" "))
print("Using a", self.distribution, "with")
np = self.model.npchain
for name, hyp in zip(self.distribution.PARNAMES,
self.distribution.hyperpar):
print(" %-7.7s " % name, end="")
if np in fitlist:
print("unknown")
else:
print(" (fixed) ", hyp.hypar)
# print( "%7.2f (fixed)" % hyp.hypar )
np += 1
print("Moving the walkers with")
for eng in self.engines:
print(" ", eng)
if self.verbose >= 2:
print("Iteration logZ H LowL npar parameters")
explorer = Explorer(self)
self.logZ = -sys.float_info.max
self.info = 0
logWidth = math.log(1.0 -
math.exp((-1.0 * self.discard) / self.ensemble))
if self.optionalRestart():
logWidth -= self.iteration * (1.0 * self.discard) / self.ensemble
while self.iteration < self.getMaxIter():
# find worst walker(s) in ensemble
worst = self.findWorst()
worstLogW = logWidth + self.walkers[worst[-1]].logL
# Keep posterior samples
self.storeSamples(worst, worstLogW - math.log(self.discard))
# Update Evidence Z and Information H
logZnew = numpy.logaddexp(self.logZ, worstLogW)
self.info = (math.exp(worstLogW - logZnew) * self.lowLhood +
math.exp(self.logZ - logZnew) *
(self.info + self.logZ) - logZnew)
self.logZ = logZnew
if self.verbose >= 3 or (self.verbose >= 2
and self.iteration % 100 == 0):
kw = worst[0]
pl = self.walkers[kw].parlist[self.walkers[kw].fitIndex]
np = len(pl)
print(
"%8d %8.1f %8.1f %8.1f %6d " %
(self.iteration, self.logZ, self.info, self.lowLhood, np),
fmt(pl))
self.plotResult(worst[0], self.iteration)
self.samples.weed(self.maxsize) # remove overflow in samplelist
self.copyWalker(worst)
# Explore the copied walker(s)
explorer.explore(worst, self.lowLhood, fitlist)
# Shrink the interval
logWidth -= (1.0 * self.discard) / self.ensemble
self.iteration += 1
self.optionalSave()
# End of Sampling
self.addEnsembleToSamples(logWidth)
# Calculate weighted average and stdevs for the parameters;
self.samples.LogZ = self.logZ
self.samples.info = self.info
self.samples.normalize()
# put the info into the model
self.model.parameters = self.samples.parameters
self.model.stdevs = self.samples.stdevs
if self.verbose >= 1:
self.report()
return self.samples.average(self.xdata)
class RobotController:
def __init__(self,
x_min,
y_min,
x_max,
y_max,
show_gui=False,
url="http://localhost:50000"):
self.__robot = Robot(url)
self.__robot_drive = RobotDrive(self.__robot)
# Map grid size in meters per square (robot is 450 x 400 x 243 (LxWxH))
MAP_GRID_SIZE = .2
# Set coordinates and dimensions of local map area within the world coordinate system
width_wcs = x_max - x_min
height_wcs = y_max - y_min
width_grid = math.ceil(width_wcs / MAP_GRID_SIZE)
height_grid = math.ceil(height_wcs / MAP_GRID_SIZE)
self.__local_map = OccupancyGrid(x_min, y_min, MAP_GRID_SIZE,
height_grid, width_grid)
self.__laser = LaserSensorModel(self.__robot, self.__local_map)
self.__show_map = ShowMap(height_grid, width_grid, show_gui)
self.__explorer = Explorer(self.__robot, self.__local_map)
self.__path_planner = WavefrontPlanner(self.__robot, self.__local_map)
self.__obstacle_avoider = ObstacleAvoider(self.__robot,
self.__local_map)
# Keep track of number of steps taken in the main_loop
self.__SCAN_FREQUENCY = 10
self.__cycles = 0
self.__loop_running = False
self.__take_a_scan = False
self.__determine_frontiers = False
self.__in_reactive_state = False
self.__in_warning = False
self.__in_danger = False
self.__in_reactive = False
def main(self):
# Start program
self.__loop_running = True
self.__take_a_scan = True
self.__determine_frontiers = True
try:
self.main_loop()
self.end_program()
except KeyboardInterrupt:
self.__robot.setMotion(0, 0)
def main_loop(self):
while self.__loop_running:
# Force take a scan
if self.__cycles % self.__SCAN_FREQUENCY == 0:
self.__take_a_scan = True
# Update map if scan flag is true
if self.__take_a_scan:
self.__do_take_scan()
# Update frontier nodes
if self.__determine_frontiers:
self.__do_determine_frontiers()
# If robot has a point to navigate to, take next step
if self.__robot_drive.has_navigation_point():
self.__robot_drive.take_step()
# If no navigation point, determine new frontier nodes
if not self.__robot_drive.has_navigation_point():
self.__determine_frontiers = True
self.__robot.setMotion(0.0, 0.0)
# Check distance to obstacle and set flags
self.__in_danger, self.__in_warning = self.__obstacle_avoider.in_danger(
)
# If "too" close to obstacle, slow max speed
self.__robot_drive.warning(self.__in_warning)
# If in reactive mode but no longer in danger, break out of reactive mode
if not self.__in_danger and self.__in_reactive:
self.__in_reactive = False
# If in danger, but not in reactive mode, start reactive mode
if self.__in_danger and not self.__in_reactive:
self.__in_reactive = True
self.__determine_frontiers = True
self.__robot.setMotion(0.0, 0.0)
# Keep track of total cycles
self.__cycles += 1
# Wait before next cycle
time.sleep(.1)
def end_program(self):
self.__show_map.close()
self.__robot.setMotion(0.0, 0.0)
print("Map has been discovered. End Mapmaker program!")
def __do_take_scan(self):
# Get robot position
position_wcs = self.__robot.getPosition()
heading = self.__robot.getHeading()
self.__laser.update_grid(position_wcs['X'], position_wcs['Y'])
# Calculate the robot's position on the grid.
robot_col, robot_row = self.__local_map.wcs_to_grid(
position_wcs['X'], position_wcs['Y'])
# Update map with latest grid values and the robot's position
self.__show_map.updateMap(self.__local_map.get_grid(), robot_col,
robot_row, heading)
self.__show_map.close()
self.__take_a_scan = False
def __do_determine_frontiers(self):
frontiers = self.__explorer.get_frontiers()
if len(frontiers) > 0:
# add/update green dots on the image
self.__show_map.set_frontiers(frontiers)
# Get new path from the path planner
try:
path, frontier_x, frontier_y = self.__path_planner.get_path_to_frontier(
frontiers)
except:
self.__loop_running = False
return
path_grid = np.array(path)
# Convert path (grid) to WCS
path_x_wcs, path_y_wcs = self.__local_map.grid_to_wcs(
path_grid[:, 0], path_grid[:, 1])
path_wcs = np.zeros((len(path_x_wcs), 2))
path_wcs[:, 0] = path_x_wcs
path_wcs[:, 1] = path_y_wcs
# Give WCS path to robot drive
self.__robot_drive.set_WCS_path(np.array(path_wcs))
self.__show_map.set_path(path_grid)
# Close flag
self.__determine_frontiers = False
else:
## TODO what to do when no frontier nodes are returned
#raise Exception("no frontier nodes found")
self.__loop_running = False
def __init__(self):
self.explorer = Explorer(True)
class MainWindow:
PYCAMIMG_FILE_EXTENSION = ".cmmg"
PYCAMIMG_TITLE = "PyCamimg"
__DEFAULT_WINDOW_WIDTH__ = 800
__DEFAULT_WINDOW_HEIGHT__ = 600
def __init__(self,
cores,
domain=None,
languages=None,
currentLang=None,
setLanguage=None):
"""
@summary: Initialize PyCamimg main window.
@param cores: List of preloaded CamCores.
@param domain: GetText domain to use.
@param languages: List of languages that it can use.
@param currentLang: Current language of the list.
@param setLanguage: Function reference to set new language.
"""
# Initialize current tab
self.__lsTabs__ = []
self.__currentTab__ = None
# Language configuration
self.__langs__ = languages
self.__currLang__ = currentLang
# Set pycamimg domain if domain is None
if (domain == None):
domain = pycamimg.gettextName
# Initialize UI
self.__initUI__(domain)
# Initialize other treeviews
self.__initTargets__(cores)
def __initUI__(self, domain):
"""
@summary: Initialize UI of PyCamimg.
@param domain: GetText domain to use.
"""
self.__menuBar__ = None
self.__toolBar__ = None
__log__.debug("Initializing UI...")
# Create the toplevel window
self.__mainWindow__ = gtk.Window()
self.__mainWindow__.connect("destroy", self.__quitEvent__)
self.__mainWindow__.connect("delete-event", self.__queryQuitEvent__)
self.__mainWindow__.set_size_request(self.__DEFAULT_WINDOW_WIDTH__, self.__DEFAULT_WINDOW_HEIGHT__)
self.__mainWindow__.set_title(self.PYCAMIMG_TITLE)
self.__mainWindow__.set_icon_from_file(os.path.join(__ICONS_FOLDER__, "pycamimg.png"))
vbox = gtk.VBox()
self.__mainWindow__.add(vbox)
self.__initUIMenu__(domain)
if (self.__menuBar__ != None):
vbox.pack_start(self.__menuBar__, False)
# Recovers TreeViews
self.__eExplorer__ = Explorer(showHiddens=Configuration().getConfiguration().getboolean("NAVIGATOR", "show_hiddens"))
__log__.debug("\tExplorer widget: %s" % self.__eExplorer__)
# Enabled navigator buttons (back and forward buttons)
self.__eExplorer__.enabledNavigationButtons()
# self.__eExplorer__.goHome()
__log__.debug("Went to home directory");
self.__operations__ = RegOperations()
__log__.debug("\tOperations widget: %s" % self.__operations__)
hPaned = gtk.HPaned()
hPaned.set_position(int(self.__DEFAULT_WINDOW_WIDTH__ * 0.85))
hPaned.pack1(self.__eExplorer__.getControl())
hPaned.pack2(self.__operations__.getControl(), False, True)
vBoxWorkArea = gtk.VBox()
if (self.__toolBar__ != None):
vBoxWorkArea.pack_start(self.__toolBar__, False)
self.__nbProjects__ = gtk.Notebook()
self.__nbProjects__.set_tab_pos(gtk.POS_TOP)
self.__nbProjects__.set_scrollable(True)
self.__nbProjects__.set_show_border(True)
self.__nbProjects__.connect("switch-page", self.__changeProjectEvent__)
__log__.debug("Project Notebook: %s" % self.__nbProjects__)
vBoxWorkArea.pack_start(self.__nbProjects__, True, True)
vPaned = gtk.VPaned()
vPaned.set_position(int(self.__DEFAULT_WINDOW_HEIGHT__ * 0.40))
vPaned.add1(hPaned)
vPaned.add2(vBoxWorkArea)
vbox.pack_start(vPaned, True, True)
self.__statBar__ = gtk.Statusbar()
self.__statBar__.set_has_resize_grip(True)
vbox.pack_start(self.__statBar__, False)
# Search project plugins, that define the kind of project.
self.__searchPlugins__()
self.__enableOptions__(blockGtk=False)
def __initUIMenu__(self, domain):
"""
@summary: Initialize menu of window.
@param domain: Domain used to translation.
"""
actionGroupMenu = gtk.ActionGroup("ActionGroupMenu")
# Create actions
actionGroupMenu.add_actions([("FileMenuAction", None, _("_File")),
("NewProjectAction", None, _("New Project")),
("OpenProjectAction", gtk.STOCK_OPEN, _("_Open"), "<Control>o", _("Open PyCamimg project"), self.__openProjectEvent__),
("SaveProjectAction", gtk.STOCK_SAVE, _("_Save"), "<Control>s", _("Save current project"), self.__saveProjectEvent__),
("SaveAsProjectAction", gtk.STOCK_SAVE_AS, _("Save _As"), None, _("Save current project"), self.__saveAsProjectEvent__),
("QuitAction", gtk.STOCK_QUIT, _("_Quit"), "<Control>q", _("Quit PyCamimg"), self.__queryQuitMenuItemEvent__),
("ToolsMenuAction", None, _("_Tools")),
("OperationsAction", None, _("Operations")),
("PreferencesAction", gtk.STOCK_PREFERENCES, _("_Preferences"), None, _("Preferences of PyCamimg"), self.__openOptionsEvent__),
("PluginsAction", gtk.STOCK_CONNECT, _("P_lugins"), None, _("Plugins of PyCamimg"), self.__openPlunginsEvent__),
("HelpMenuAction", None, _("_Help")),
("AboutAction", gtk.STOCK_ABOUT, _("_About PyCamimg"), None, _("Preferences of PyCamimg"), self.__openAboutEvent__),
("AddItemAction", gtk.STOCK_ADD, _("Add Images"), None, _("Add selected images"), self.__addImageEvent__),
("DelItemAction", gtk.STOCK_DELETE, _("Delete Images"), None, _("Delete selected images"), self.__deleteImageEvent__),
("DelOperationsAction", gtk.STOCK_CLEAR, _("Delete Operations"), None, _("Delete selected operations"), self.__deleteOperationsEvent__),
("RunAction", gtk.STOCK_EXECUTE, _("Run"), None, _("Run current project"), self.__runEvent__)])
actionGroupMenu.add_toggle_actions([("ChangeViewAction", gtk.STOCK_CONVERT, _("Toggle view"), None, _("Toggle between differents views"), self.__changeViewProjectEvent__)])
actionGroupMenu.set_translation_domain(domain)
__log__.debug("There is a xml path. UI Menus and tools will be recovered from path %s" % __XMLUI_FOLDER__)
print __XMLUI_FOLDER__
self.__uiManager__ = FactoryControls.getUIManager(os.path.join(__XMLUI_FOLDER__, "MainMenu.xml"), self.__mainWindow__, actionGroupMenu)[0]
self.__menuBar__ = self.__uiManager__.get_widget("/MenuPyCaming")
self.__toolBar__ = self.__uiManager__.get_widget("/ToolsPyCamimg")
self.__toolBar__.set_style(gtk.TOOLBAR_BOTH_HORIZ)
self.__toolBar__.set_tooltips(True)
def __searchPlugins__(self):
"""
@summary: Search plugins of PyCamimg.
"""
self.__searchProjectPlugins__()
self.__searchOperationsPlugins__()
def __searchProjectPlugins__(self):
"""
@summary: Search new kind of projects, and create a menu item for each.
"""
__log__.debug("Project modules are loaded")
projectTypes = Loader.getPluginsType(pycamimg.core.plugins.ICamimgPlugin.PLUGIN_TYPE.PROJECT)
actionGroupProjectPlugins = gtk.ActionGroup("ActionGroupProjectPlugins")
self.__uiManager__.insert_action_group(actionGroupProjectPlugins, pos=-1)
for project in projectTypes:
__log__.debug("Processing plugin %s" % project[Loader.INDEX_PLUGIN].getName())
projectInstance = project[Loader.INDEX_PLUGIN_INSTANCE]()
__log__.debug("Creating new menu item for project type %s" % projectInstance.getTypeName())
aAction = projectInstance.getGtkAction()
if (aAction != None):
aAction.connect("activate", self.__newProjectEvent__, project[Loader.INDEX_PLUGIN_INSTANCE])
__log__.debug("Add activate signal to %s" % projectInstance.getTypeName())
actionGroupProjectPlugins.add_action(aAction)
else:
__log__.debug("There is not action for %s" % projectInstance.getTypeName())
if (projectInstance.getXmlLocation() != ""):
self.__uiManager__.add_ui_from_file(os.path.join(__XMLUI_FOLDER__, projectInstance.getXmlLocation()))
mi = self.__uiManager__.get_widget("/MenuPyCaming/FileMenu/NewProject/NewProjectAdditions/%s" % projectInstance.getTypeName())
if (mi != None):
iconPath = os.path.join(__ICONS_FOLDER__, projectInstance.getIconName())
__log__.debug("Get project icon from %s" % iconPath)
UIUtils.setImageToMenuItem(mi, iconPath, doGObject=False)
else:
__log__.warning("It could not update icon of %s. Action name %s was not found." % (projectInstance.getTypeName(), projectInstance.getTypeName()))
else:
__log__.debug("%s is not in menu." % projectInstance.getTypeName())
__log__.debug("Added new project type %s" % projectInstance.getTypeName())
def __searchOperationsPlugins__(self):
"""
@summary: Search operations, and create a menu item for each.
"""
__log__.debug("Project modules are loaded")
operationsPlugins = Loader.getPluginsType(pycamimg.core.plugins.ICamimgPlugin.PLUGIN_TYPE.OPERATION)
actionGroupOperationPlugins = gtk.ActionGroup("ActionGroupOperationPlugins")
self.__uiManager__.insert_action_group(actionGroupOperationPlugins, pos=-1)
for operation in operationsPlugins:
__log__.debug("Processing plugin %s" % operation[Loader.INDEX_PLUGIN])
operationInstance = operation[Loader.INDEX_PLUGIN_INSTANCE]()
__log__.debug("Creating operation %s" % operationInstance.getOperationName())
lActions = operationInstance.getActions()
if (lActions != None):
for aAction in lActions:
aAction.connect("activate", self.__activateOperation__, operationInstance.callbackAction)
__log__.debug("Add activate signal to %s" % operationInstance.getOperationName())
actionGroupOperationPlugins.add_action(aAction)
else:
__log__.debug("There is not action for %s" % operationInstance.getOperationName())
if (operationInstance.getXmlLocation() != ""):
self.__uiManager__.add_ui_from_file(os.path.join(__XMLUI_FOLDER__, operationInstance.getXmlLocation()))
dIcons = operationInstance.getIconsActions()
for actionPath, iconPath in dIcons.iteritems():
mi = self.__uiManager__.get_widget(actionPath)
if (mi != None):
iconPath = os.path.join(__ICONS_FOLDER__, iconPath)
__log__.debug("Get project icon from %s" % iconPath)
if (isinstance(mi, gtk.ImageMenuItem)):
UIUtils.setImageToMenuItem(mi, iconPath, doGObject=False)
elif (isinstance(mi, gtk.ToolButton)):
UIUtils.setImageToToolItem(mi, iconPath, size=self.__toolBar__.get_icon_size(), doGObject=False)
else:
__log__.warning("Unknown type control.")
else:
__log__.warning("It could not update icon of %s. Action name %s was not found." % (operationInstance.getOperationName(), actionPath))
else:
__log__.debug("%s is not in menu." % operationInstance.getOperationName())
__log__.debug("Added new operation %s" % operationInstance.getOperationName())
### INITIALIZE TreeViews ###
def __initTargets__(self, cores):
"""
@summary: Initialize tabs.
@param cores: A list of cores that are preloaded.
"""
for core in cores:
self.__addNewProject__(core)
__log__.info("Initialized target projects")
def __addNewProject__(self, core=None, threadBlock=True, focused=False, projectType=None):
"""
@summary: Add new project.
@param core: Core that will be added. Default value is None
@param threadBlock: True if it will be locked gtk-loop. Default True
@param focused: True if new tab project will get the focus.
"""
__log__.debug("Add new project: core=%s | threadBlock=%s | focused=%s | projectType=%s" % (core, threadBlock, focused, projectType))
if (core == None):
core = CamCore(temp=__TEMP_FOLDER__, projectType=projectType)
__log__.debug("New core created. %s" % core)
text = ""
if (core.getName() == ""):
text = "%s_%d" % (_("Project"), len(self.__lsTabs__))
else:
text = core.getName()
__log__.info("Project name %s" % text)
tab = TabProject(core, name=text, iconsPath=os.path.join(__ICONS_FOLDER__),
iconName=core.getProjectType().getIconName())
tab.setCloseCallback(self.__closeProject__)
__log__.debug("Callbacks set")
core.setName(text)
tab.addToNotebook(self.__nbProjects__, threadBlock=threadBlock, focused=focused)
tab.load()
self.__lsTabs__.append(tab)
if (self.__currentTab__ == None):
__log__.debug("There is not current tab. It will set %s as current tab." % core.getName())
self.__currentTab__ = tab
__log__.debug("New project added to project notebook")
self.__enableOptions__(blockGtk=threadBlock)
def __closeProject__(self, index):
"""
@summary: Runs when project is closed.
@param index: Index of project that will be closed.
"""
__log__.debug("Close project %d" % index)
tab = self.__lsTabs__[index]
if (tab != None):
core = tab.getCore()
if (core != None):
__log__.debug("%s will be deleted" % core.getName())
del core
core = None
self.__lsTabs__.remove(tab)
if (tab == self.__currentTab__):
self.__currentTab__ = None
tab.closeTab()
del tab
__log__.debug("Tab was closed and core was deleted")
else:
__log__.warn("Index %d does not exist" % index)
self.__enableOptions__(blockGtk=False)
def __refreshProjects__(self):
"""
@summary: Refresh all open projects.
"""
for tbTab in self.__lsTabs__:
if (tbTab != None):
tbTab.load()
__log__.debug("Core %s reloaded" % tbTab.getCore().getName())
def __enableOptions__(self, blockGtk=True):
"""
@summary: Enable or disable all options.
"""
enable = (self.__currentTab__ != None)
toolbar = self.__uiManager__.get_widget("/ToolsPyCamimg")
imiSave = self.__uiManager__.get_widget("/MenuPyCaming/FileMenu/SaveProject")
imiSaveAs = self.__uiManager__.get_widget("/MenuPyCaming/FileMenu/SaveAsProject")
iOptions = 0
mOperations = self.__uiManager__.get_widget("/MenuPyCaming/ToolsMenu/Operations")
if (mOperations != None):
if (mOperations.get_submenu() != None):
__log__.debug("Enabling operations of operation menu")
mOperations.get_submenu().foreach(lambda mi: UIUtils.enabledWidget(mi, enable, blockGtk))
else:
__log__.debug("Operation menu does not have menu")
if (toolbar != None):
iOptions = toolbar.get_n_items()
if (iOptions > 0):
for i in range(0, iOptions):
itItem = toolbar.get_nth_item(i)
if (itItem != None):
if (blockGtk):
gtk.gdk.threads_enter()
try:
itItem.set_sensitive(enable)
finally:
if (blockGtk):
gtk.gdk.threads_leave()
else:
__log__.warning("It could not recover item of index %d" % i)
else:
__log__.debug("There are not options.")
if (imiSave != None):
imiSave.set_sensitive(enable)
if (imiSaveAs != None):
imiSaveAs.set_sensitive(enable)
def __updateTitle__(self, threadBlock=False):
"""Update title of the window"""
title = ""
if (self.__currentTab__ != None):
if (self.__currentTab__.getCore().getFilename() != None):
title = "%s - %s - %s" % (self.__currentTab__.getCore().getName(),
self.__currentTab__.getCore().getFilename(),
self.PYCAMIMG_TITLE)
else:
title = "%s - %s" % (self.__currentTab__.getCore().getName(), self.PYCAMIMG_TITLE)
else:
title = self.PYCAMIMG_TITLE
__log__.debug("New window title %s" % title)
UIUtils.setTitleWindow(self.__mainWindow__, title, doGObject=threadBlock)
#####PUBLIC METHODS#######
# TOOLBAR ITEMS: CLICK EVENT
def __addImageEvent__ (self, b):
"""
@summary: Add into target TreeView selected files from the files TreeView.
@param b: Button that threw event.
"""
files = self.__eExplorer__.getSelectedFiles()
if (self.__currentTab__ != None):
# Send files to target TreeView
addThread = Thread(target=self.__currentTab__.addTargetFiles, args=(files,))
addThread.start()
__log__.debug("Add thread started. %s" % addThread)
else:
__log__.debug("There is not a tab selected")
def __deleteImageEvent__ (self, b):
"""
@summary: Delete files from target TreeView.
@param b: Button that threw event.
"""
if (self.__currentTab__ != None):
delThread = Thread(target=self.__currentTab__.deleteSelectedImages, args=())
delThread.start()
__log__.debug("Delete thread started. %s" % delThread)
else:
__log__.debug("There is not a tab selected")
def __deleteOperationsEvent__ (self, b):
"""
@summary: Delete operations of an item.
@param b: Button that threw event.
"""
if (self.__currentTab__ == None):
__log__.debug("There is not current project")
return
paths = self.__currentTab__.getSelection()
model = self.__currentTab__.getModel()
if ((paths == None) or (model == None)):
__log__.error("It can not recover tree selection. Set selection at 0.")
iNRows = 0
else:
iNRows = len(paths)
if iNRows > 0:
path = paths[0]
iter = model.get_iter(path)
if (iter != None):
file = model.get_value(iter, self.__currentTab__.COLUMN_SOURCE)
item = self.__currentTab__.getCore().getItem(file)
operationsDialog = OperationsDialog(
item,
iter,
callback=self.__applyDeleteOperationsItemCallback__,
parent=self.__mainWindow__)
__log__.debug("Operations dialog created. %s" % operationsDialog)
operationsDialog.run()
del operationsDialog
else:
__log__.error("It can not recover iter from path %s. Abort open delete operations dialog." % path)
FactoryControls.getMessage(_("It can not get item"),
title=_("Delete operations"),
type=gtk.MESSAGE_ERROR,
parent=self.__mainWindow__)
else:
FactoryControls.getMessage(_("Select one item"),
title=_("Delete operations"),
parent=self.__mainWindow__)
def __applyDeleteOperationsItemCallback__(self, item, iter):
"""
@summary: Apply changes on item.
@param item: Item that has changes.
@param iter: Iter where item is.
"""
if ((item != None) and (iter != None)):
self.__currentTab__.updateItemDescription(iter, item, gtkLock=False)
def openPreview (self, b):
"""
@summary: Open image.
@param b: Button that threw event.
"""
if (self.__currentTab__ == None):
__log__.debug("There is not current project")
return
paths = self.__currentTab__.getSelection()
model = self.__currentTab__.getModel()
if ((paths == None) or (model == None)):
__log__.error("It can not recover tree selection. Set selection at 0.")
iNRows = 0
else:
iNRows = len(paths)
if iNRows > 0:
path = paths[0]
iter = model.get_iter(path)
if (iter != None):
file = model.get_value(iter, 1)
meta = ImgMeta(file)
meta.show()
else:
__log__.error("It can not recover iter from path %s. Abort preview" % path)
FactoryControls.getMessage(_("It can not show image"),
title=_("Preview"),
type=gtk.MESSAGE_ERROR,
parent=self.__mainWindow__)
else:
FactoryControls.getMessage(_("Select one item"),
title=_("Preview"),
parent=self.__mainWindow__)
def __openPlunginsEvent__(self, b):
"""
@summary: Open plugins window.
@param b: Button that threw event.
"""
pluginsDialog = PluginsDialog(parent=self.__mainWindow__)
__log__.debug("Plugins dialog created. %s" % pluginsDialog)
pluginsDialog.run()
del pluginsDialog
pluginsDialog = None
def __openOptionsEvent__ (self, b):
"""
@summary: Open options window.
@param b: Button that threw event.
"""
optionsDialog = OptionsDialog(self.__langs__,
self.__currLang__,
callback=self.__applyConfigurationCallback__,
parent=self.__mainWindow__)
__log__.debug("Option dialog created. %s" % optionsDialog)
optionsDialog.run()
def __changeProjectEvent__ (self, notebook, page, pageNum):
"""
@summary: Handle change tab signal.
@param notebook: GtkNotebook control that threw event.
@param page: New page.
@param pageNum: Number of new page.
"""
if (self.__lsTabs__ != None):
if (len(self.__lsTabs__) > pageNum):
self.__currentTab__ = self.__lsTabs__[pageNum]
self.__updateTitle__(threadBlock=False)
self.__enableOptions__(blockGtk=False)
else:
__log__.warning("There is not tab at index %d" % pageNum)
else:
__log__.warning("There is not list of tabs.")
def __runEvent__ (self, b):
"""
@summary: Do current project.
@param b: Button that threw event.
"""
if (self.__currentTab__ != None):
self.__currentTab__.setOrderToCore()
exWindow = ExecuteWindow(self.__currentTab__.getCore(),
parent=self.__mainWindow__)
__log__.debug("Execute window created. %s" % exWindow)
exWindow.run()
else:
FactoryControls.getMessage(
_("There isn't current project"),
title=_("Execute"),
parent=self.__mainWindow__)
def __activateOperation__ (self, action, callback=None):
"""
@summary: Handle operation action.
@param action: Action that threw event.
@param callback: Function reference of operation.
"""
if (isinstance(action, gtk.Action)):
if (callback != None):
callback(action, self.__currentTab__, userData=self.__mainWindow__)
__log__.info("Action of operation %s threw." % action.get_name())
else:
__log__.debug("Callback of %s is None" % action.get_name())
else:
__log__.warning("action is not gtk.Action")
def __openAboutEvent__ (self, b):
"""
@summary: Handle button about.
@param b: Button that threw event.
"""
self.showAbout()
def __newProjectEvent__ (self, b, projectType=None):
"""
@summary: Handle new project action.
@param b: Button that threw event.
@param projectType: Class reference of project to create.
"""
self.__addNewProject__(threadBlock=False, projectType=projectType)
__log__.info("New project created.")
def __openProjectEvent__ (self, b):
"""
@summary: Handle open project action.
@param b: Button that threw event.
"""
fileSel = gtk.FileChooserDialog(title=_("Open project"),
parent=self.__mainWindow__,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT))
fileSel.set_default_response(gtk.RESPONSE_CANCEL)
filterCam = gtk.FileFilter()
filterCam.set_name(_("PyCamimg file"))
filterCam.add_pattern("*%s" % self.PYCAMIMG_FILE_EXTENSION)
fileSel.add_filter(filterCam)
fileSel.set_modal(True)
fileSel.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
if (fileSel.run() == gtk.RESPONSE_ACCEPT):
filename = fileSel.get_filename()
__log__.debug("Open project from %s" % filename)
if (not filename.endswith(self.PYCAMIMG_FILE_EXTENSION)):
filename = "%s%s" % (filename, self.PYCAMIMG_FILE_EXTENSION)
try:
core = CamCore.load(filename, tempFolder=__TEMP_FOLDER__)
except Exception, e:
__log__.error("It could not load project from %s. %s" % (filename, e))
FactoryControls.getMessage(_("An error was occurred when it was loading project from %s" % filename),
type=gtk.MESSAGE_ERROR,
title=_("Open project"),
parent=self.__mainWindow__)
return
finally:
def __initUI__(self, domain):
"""
@summary: Initialize UI of PyCamimg.
@param domain: GetText domain to use.
"""
self.__menuBar__ = None
self.__toolBar__ = None
__log__.debug("Initializing UI...")
# Create the toplevel window
self.__mainWindow__ = gtk.Window()
self.__mainWindow__.connect("destroy", self.__quitEvent__)
self.__mainWindow__.connect("delete-event", self.__queryQuitEvent__)
self.__mainWindow__.set_size_request(self.__DEFAULT_WINDOW_WIDTH__, self.__DEFAULT_WINDOW_HEIGHT__)
self.__mainWindow__.set_title(self.PYCAMIMG_TITLE)
self.__mainWindow__.set_icon_from_file(os.path.join(__ICONS_FOLDER__, "pycamimg.png"))
vbox = gtk.VBox()
self.__mainWindow__.add(vbox)
self.__initUIMenu__(domain)
if (self.__menuBar__ != None):
vbox.pack_start(self.__menuBar__, False)
# Recovers TreeViews
self.__eExplorer__ = Explorer(showHiddens=Configuration().getConfiguration().getboolean("NAVIGATOR", "show_hiddens"))
__log__.debug("\tExplorer widget: %s" % self.__eExplorer__)
# Enabled navigator buttons (back and forward buttons)
self.__eExplorer__.enabledNavigationButtons()
# self.__eExplorer__.goHome()
__log__.debug("Went to home directory");
self.__operations__ = RegOperations()
__log__.debug("\tOperations widget: %s" % self.__operations__)
hPaned = gtk.HPaned()
hPaned.set_position(int(self.__DEFAULT_WINDOW_WIDTH__ * 0.85))
hPaned.pack1(self.__eExplorer__.getControl())
hPaned.pack2(self.__operations__.getControl(), False, True)
vBoxWorkArea = gtk.VBox()
if (self.__toolBar__ != None):
vBoxWorkArea.pack_start(self.__toolBar__, False)
self.__nbProjects__ = gtk.Notebook()
self.__nbProjects__.set_tab_pos(gtk.POS_TOP)
self.__nbProjects__.set_scrollable(True)
self.__nbProjects__.set_show_border(True)
self.__nbProjects__.connect("switch-page", self.__changeProjectEvent__)
__log__.debug("Project Notebook: %s" % self.__nbProjects__)
vBoxWorkArea.pack_start(self.__nbProjects__, True, True)
vPaned = gtk.VPaned()
vPaned.set_position(int(self.__DEFAULT_WINDOW_HEIGHT__ * 0.40))
vPaned.add1(hPaned)
vPaned.add2(vBoxWorkArea)
vbox.pack_start(vPaned, True, True)
self.__statBar__ = gtk.Statusbar()
self.__statBar__.set_has_resize_grip(True)
vbox.pack_start(self.__statBar__, False)
# Search project plugins, that define the kind of project.
self.__searchPlugins__()
self.__enableOptions__(blockGtk=False)
#! /usr/bin/env python
'''
Robot side
'''
import rospy
from Drive import Drive_Keys
from Explorer import Explorer
from Runner import Runner
if __name__ == "__main__":
rospy.init_node('drive_bot')
explorer = Explorer()
runner = Runner()
drive_keys = Drive_Keys()
rospy.spin()
