def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.recipeModel = recipeModel.Model(self.recipeTable)
self.instructionModel = instructionModel.Model(self.instructionTable)
self.windowManager = WindowManager(self.windowsMenu)
self.recipe_manager = RecipeManager("kitchenModel_1.5.pck")
self.recipeBrowser = recipeBrowser.MainWindow(self.recipe_manager)
self.recipeBrowser.show()
self.windowManager.addWindow(self.recipeBrowser)
self.costFunctionBrowser = costFunctionBrowser.MainWindow(
[0, 10, 0, 10], self.recipe_manager.task_planner)
self.costFunctionBrowser.save_state_tree = True
self.costFunctionBrowser.allow_null_action = False
self.windowManager.addWindow(self.costFunctionBrowser)
self.connect(
self.recipeTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectRecipe)
self.connect(self.sendInstructionButton, SIGNAL("clicked()"),
self.sendInstruction)
self.connect(self.sendRecipeButton, SIGNAL("clicked()"),
self.sendRecipe)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.windowManager = WindowManager(self.windowsMenu)
self.limits = [-2, 8, -2, 8]
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - State Action Browser")
self.contextWindow.setVisible(True)
self.windowManager.addWindow(self.contextWindow)
self.state = DiaperState.example_state()
self.contextWindow.setContext(self.state.to_context())
self.draw()
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.nodeModel = nodeModel.Model(self.nodeTable)
self.nodeResultsModel = nodeResultsModel.Model(self.nodeResultsTable)
self.factorResultsModel = factorResultsModel.Model(
self.factorResultsTable)
self.featureModel = featureModel.Model(self.featureTable)
self.entropyMetricModel = entropyMetricModel.Model(
self.entropyMetricTable)
self.windowManager = WindowManager(self.windowsMenu)
self.contextWindow = context3d.MainWindow()
#self.context3dFrame.layout().addWidget(self.contextWindow.centralWidget())
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - Node Feature Weights")
#self.contextWindow.show()
self.windowManager.addWindow(self.contextWindow)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.limits = [-20, 30, 10, 51]
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.cf_obj = None
self.connect(
self.nodeTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectNode)
self.connect(
self.nodeResultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectNodeResult)
self.connect(
self.factorResultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectFactorResult)
class MainWindow(QMainWindow, state_action_browser_ui.Ui_MainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.windowManager = WindowManager(self.windowsMenu)
self.limits = [-2, 8, -2, 8]
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - State Action Browser")
self.contextWindow.setVisible(True)
self.windowManager.addWindow(self.contextWindow)
self.state = DiaperState.example_state()
self.contextWindow.setContext(self.state.to_context())
self.draw()
def draw(self):
self.axes.clear()
self.artists = []
for g in self.state.to_context().objects:
drawObject(self.axes, g)
self.restoreLimits()
self.figure.canvas.draw()
def updateLimits(self, mplEvent):
self.saveLimits()
def saveLimits(self):
self.limits = self.axes.axis()
def restoreLimits(self):
if self.limits != None:
self.axes.axis(self.limits)
def __init__(self, taskPlanner=None, initialState=True):
QMainWindow.__init__(self)
self.setupUi(self)
self.featureModel = featureModel.Model(self.featureTable)
self.candidateModel = candidateModel.Model(self.factorCandidateTable)
self.groundingsModel = groundingsModel.Model(self.groundingTable)
self.windowManager = WindowManager(self.windowsMenu)
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - CRF Feature Weights")
self.windowManager.addWindow(self.contextWindow)
self.connect(
self.factorCandidateTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectCandidate)
self.connect(
self.groundingTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.draw)
self.connect(self.shouldDrawTextCheckBox, SIGNAL("stateChanged(int)"),
self.draw)
self.connect(self.shouldDrawIconsCheckBox, SIGNAL("stateChanged(int)"),
self.draw)
self.connect(self.shouldDrawAgentCheckBox, SIGNAL("stateChanged(int)"),
self.draw)
self.connect(self.shouldDrawObjectGeomCheckBox,
SIGNAL("stateChanged(int)"), self.draw)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.limits = [-20, 30, 10, 51]
#self.limits = [10, 40, 10, 40]
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.figure.canvas.mpl_connect('button_press_event', self.mapClick)
self.costImage = None
def __init__(self,
limits,
taskPlanner=None,
initialState=True,
show_gui=True,
merging_mode="merge_none",
start_command=None):
QMainWindow.__init__(self)
self.setupUi(self)
self.windowManager = WindowManager(self.windowsMenu)
self.artists = []
self.extractor = None
self.taskPlanner = taskPlanner
self.plansDict = None
self.currAnnotation = None
self.save_state_tree = True
self.allow_null_action = False
self.command = ""
if start_command:
self.command = start_command
self.commandEdit.setPlainText(start_command)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.limits = limits
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.esdcFeatureBrowser = esdcFeatureBrowser.MainWindow()
self.esdcFeatureBrowser.setWindowTitle(
str(self.esdcFeatureBrowser.windowTitle()) +
" (ESDC Feature Browser)")
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - Cost Function Browser")
self.windowManager.addWindow(self.contextWindow)
self.gggWindow = gggBrowser.MainWindow()
self.gggWindow.setWindowTitle(self.gggWindow.windowTitle() +
"(GGG Visualizer)")
self.windowManager.addWindow(self.gggWindow)
self.crfFeatureWeights = crfFeatureWeights.MainWindow()
self.crfFeatureWeights.setWindowTitle(
str(self.crfFeatureWeights.windowTitle()) + " (CFB)")
self.windowManager.addWindow(self.crfFeatureWeights)
self.nodeFeatureWeights = nodeFeatureWeights.MainWindow()
self.nodeFeatureWeights.setWindowTitle(
str(self.nodeFeatureWeights.windowTitle()) + " (CFB)")
self.windowManager.addWindow(self.nodeFeatureWeights)
self.esdcModel = esdcTreeModel.Model(self.esdcView)
self.plansModel = plansModel.Model(self.plansView)
self.connect(self.submitButton, SIGNAL("clicked()"),
self.followCommandSelf)
self.connect(
self.esdcView.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectEsdc)
self.connect(
self.plansView.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectPlan)
self.connect(self.esdcParserComboBox,
SIGNAL("currentIndexChanged( QString)"),
self.selectEsdcExtractor)
self.connect(self.esdcParserModelButton, SIGNAL("clicked()"),
self.askForEsdcParserModel)
self.connect(self.actionLoadContext, SIGNAL("triggered()"),
self.loadContext)
self.connect(self.actionSaveState, SIGNAL("triggered()"),
self.saveState)
self.connect(self.actionLoadState, SIGNAL("triggered()"),
self.loadState)
self.connect(self.actionGroundingProbabilityGraph,
SIGNAL("triggered()"), self.groundingProbabilityGraph)
self.esdcParserModelButton.setText(
"%s/data/directions/direction_training/annotation/models/crf_discrete_esdcs_1.5.pck"
% SLU_HOME)
self.esdcs = []
self.factors_to_esdcs = None
self.gggs = None
#self.selectEsdcExtractor()
self.merging_mode = merging_mode
class MainWindow(QMainWindow, costFunctionBrowser_ui.Ui_MainWindow):
def mpl_draw(self):
self.restoreLimits()
self.figure.canvas.draw()
def __init__(self,
limits,
taskPlanner=None,
initialState=True,
show_gui=True,
merging_mode="merge_none",
start_command=None):
QMainWindow.__init__(self)
self.setupUi(self)
self.windowManager = WindowManager(self.windowsMenu)
self.artists = []
self.extractor = None
self.taskPlanner = taskPlanner
self.plansDict = None
self.currAnnotation = None
self.save_state_tree = True
self.allow_null_action = False
self.command = ""
if start_command:
self.command = start_command
self.commandEdit.setPlainText(start_command)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.limits = limits
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.esdcFeatureBrowser = esdcFeatureBrowser.MainWindow()
self.esdcFeatureBrowser.setWindowTitle(
str(self.esdcFeatureBrowser.windowTitle()) +
" (ESDC Feature Browser)")
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - Cost Function Browser")
self.windowManager.addWindow(self.contextWindow)
self.gggWindow = gggBrowser.MainWindow()
self.gggWindow.setWindowTitle(self.gggWindow.windowTitle() +
"(GGG Visualizer)")
self.windowManager.addWindow(self.gggWindow)
self.crfFeatureWeights = crfFeatureWeights.MainWindow()
self.crfFeatureWeights.setWindowTitle(
str(self.crfFeatureWeights.windowTitle()) + " (CFB)")
self.windowManager.addWindow(self.crfFeatureWeights)
self.nodeFeatureWeights = nodeFeatureWeights.MainWindow()
self.nodeFeatureWeights.setWindowTitle(
str(self.nodeFeatureWeights.windowTitle()) + " (CFB)")
self.windowManager.addWindow(self.nodeFeatureWeights)
self.esdcModel = esdcTreeModel.Model(self.esdcView)
self.plansModel = plansModel.Model(self.plansView)
self.connect(self.submitButton, SIGNAL("clicked()"),
self.followCommandSelf)
self.connect(
self.esdcView.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectEsdc)
self.connect(
self.plansView.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectPlan)
self.connect(self.esdcParserComboBox,
SIGNAL("currentIndexChanged( QString)"),
self.selectEsdcExtractor)
self.connect(self.esdcParserModelButton, SIGNAL("clicked()"),
self.askForEsdcParserModel)
self.connect(self.actionLoadContext, SIGNAL("triggered()"),
self.loadContext)
self.connect(self.actionSaveState, SIGNAL("triggered()"),
self.saveState)
self.connect(self.actionLoadState, SIGNAL("triggered()"),
self.loadState)
self.connect(self.actionGroundingProbabilityGraph,
SIGNAL("triggered()"), self.groundingProbabilityGraph)
self.esdcParserModelButton.setText(
"%s/data/directions/direction_training/annotation/models/crf_discrete_esdcs_1.5.pck"
% SLU_HOME)
self.esdcs = []
self.factors_to_esdcs = None
self.gggs = None
#self.selectEsdcExtractor()
self.merging_mode = merging_mode
def loadContext(self):
fname = QFileDialog.getOpenFileName(self)
context = Context.fromYaml(yaml.load(open(fname)))
def saveState(self):
fname = QFileDialog.getSaveFileName(self)
pickle_util.save(fname, self.state)
def loadState(self):
fname = QFileDialog.getOpenFileName(self)
state = pickle_util.load(fname)
self.setState(state)
def show(self):
QMainWindow.show(self)
def askForEsdcParserModel(self):
existingFname = str(self.esdcParserModelButton.text())
fname = str(
QFileDialog.getOpenFileName(self,
directory=dirname(existingFname)))
print "fname", fname, fname.__class__
if fname != "":
self.esdcParserModelButton.setText(fname)
def selectEsdcExtractor(self):
esdc_extractor = str(self.esdcParserComboBox.currentText())
esdc_extractor_model = str(self.esdcParserModelButton.text())
self.extractor = extractor_utils.make_extractor_func(
esdc_extractor, esdc_extractor_model)
def updateEsdcs(self, esdcs, gggs=None):
self.esdcs = esdcs
self.esdcModel.setData(self.esdcs)
self.esdcView.expandAll()
self.updateCommand(self.esdcs.text)
self.gggs = gggs
def setState(self, state):
self.state = state
self.contextWindow.setContext(state.to_context())
self.drawStateOnly()
def setContext(self, context):
state = self.state.from_context(context)
self.setState(state)
def updateCommand(self, command):
self.command = command
self.commandEdit.setPlainText(command)
def followCommandSelf(self):
command = str(self.commandEdit.toPlainText())
state = self.state
esdcs = None
self.followCommand(command, state, esdcs)
def followCommand(self,
command=None,
state=None,
esdcs=None,
first_esdc_only=False,
verbose=True,
input_gggs=None):
if command != None:
self.updateCommand(command)
if state != None:
self.state = state
command = str(self.commandEdit.toPlainText())
if input_gggs != None:
self.esdcs = input_gggs[0].esdcs
elif esdcs != None and command == self.command:
self.esdcs = esdcs
else:
class AnnotationStub:
def __init__(self, command):
self.entireText = command
self.esdcs = self.extractor(AnnotationStub(command))
if len(self.esdcs) == 0:
return [], []
if first_esdc_only:
self.esdcs = ExtendedSdcGroup([self.esdcs[0]])
self.flattenedEsdcs = self.esdcs.flattenedEsdcs
print "esdcs", esdcIo.toYaml(self.esdcs)
#print "flattened esdcs", self.flattenedEsdcs
self.esdcModel.setData(self.esdcs)
self.esdcView.expandAll()
#convert to a list of plans
if input_gggs != None:
gggs = input_gggs
elif self.gggs != None:
gggs = self.gggs
else:
if self.merging_mode == "merge_coreferences":
from coreference.bag_of_words_resolver import BagOfWordsResolver
from coreference.merge_coreferences import merge_coreferences
resolver = BagOfWordsResolver(
"%s/tools/coreference/models/coref_1.5.pck" % SLU_HOME)
gggs = merge_coreferences(self.esdcs, resolver)
if len(gggs) > 1:
gggs = [gggs[0]]
elif self.merging_mode == "merge_events":
from coreference.event_resolver import EventResolver
from coreference.merge_coreferences import merge_coreferences
resolver = EventResolver()
gggs = merge_coreferences(self.esdcs, resolver)
gggs = gggs[0:1]
for i, ggg in enumerate(gggs):
#ggg.to_latex("ggg_%d.pdf" % i)
pass
# export parses, when saving ground truth parses from asr evaluation run
# -- stefie10 7/19/2012
#from esdcs.esdcIo import toYaml
#import yaml
#import os
#with open("esdcs_%d.txt" % os.getpid(), "a") as f:
# f.write(yaml.dump([toYaml(self.esdcs)]))
if len(self.esdcs) != 1:
raise ValueError("ESDCs didn't parse right: " +
` self.esdcs `)
# print "merging events", self.esdcs.entireText
# from coreference.merge_coreferences import merge_toplevel_events
# #resolver = EventResolver()
# #gggs = merge_coreferences(self.esdcs, resolver,
# # verbose=False)
# gggs = gggs_from_esdc_group(self.esdcs)
# gggs = [merge_toplevel_events(gggs)]
assert len(gggs) == 1, (len(gggs), self.esdcs.text)
elif self.merging_mode == "merge_none":
gggs = gggs_from_esdc_group(self.esdcs)
else:
raise ValueError("Bad merging mode: " + ` self.merging_mode `)
if gggs[0].context == None:
gggs[0].context = self.state.to_context()
assert gggs[0].context.agent != None
def run():
try:
assert gggs[0].context.agent != None
self.plansList = self.taskPlanner.find_plan(
self.state,
gggs,
beam_width=self.beamWidthBox.value(),
beam_width_sequence=self.seqBeamWidthBox.value(),
search_depth_event=self.searchDepthBox.value(),
beam_width_event=self.beamWidthEventBox.value(),
save_state_tree=self.save_state_tree,
allow_null_action=self.allow_null_action)
except:
print "excption on gggs"
#for i, ggg in enumerate(gggs):
# ggg.to_latex("ggg_%d.pdf" % i)
raise
start = time.time()
cProfile.runctx("run()", globals(), locals(), "out.prof")
end = time.time()
if verbose:
print "Cost Function Browser took", (end - start), "seconds."
plansList = self.plansList
if len(plansList) == 0:
return [], []
else:
self.plans = plansModel.Plan.from_inference_result(
self.taskPlanner, plansList)
self.plansModel.setData(self.plans)
self.nodeFeatureWeights.load(self.taskPlanner.cf_obj,
gggs,
self.plans,
context=self.state.to_context())
self.plansView.selectRow(0)
self.gggWindow.load(plansList[0][2],
groundingSpace=self.state.objects)
return self.esdcs, self.plans
def drawState(self):
artists = []
#index of manipulated object, e.g. pallet for forklift
# index = self.browserTools.manipulated_object_index(self.state)
# TODO remove browser tools
index = -1
if self.state != None:
objects = self.state.getObjectsSet()
# print "list of objects: ", objects
for i, ob in enumerate(objects):
obj = self.state.getGroundableById(ob)
oldTags = obj.tags
#newTags = tuple([t for t in oldTags if len(t) > 4][0:1])
#obj.tags = newTags
if i == index: #plot the manipulated object in red
self.artists.extend(
drawObject(self.axes, obj, plotArgs=dict(color="red")))
else: #plot everything else in blue
self.artists.extend(
drawObject(self.axes, obj,
plotArgs=dict(color="blue")))
obj.tags = oldTags
return artists
def drawStateOnly(self):
self.axes.clear()
self.artists = []
self.artists.extend(self.drawState())
self.artists.extend(self.drawTopologicalMap())
x, y = self.state.getPosition()
theta = self.state.orientation
self.artists.extend(drawRobot(self.axes, x, y, theta, facecolor="red"))
self.restoreLimits()
self.figure.canvas.draw()
def draw(self):
self.axes.clear()
self.artists = []
self.artists.extend(self.drawTopologicalMap())
self.artists.extend(self.drawAgentPath())
self.artists.extend(self.drawState())
self.artists.extend(self.drawBoundObjects())
self.artists.extend(self.drawActualPath())
x, y = self.state.getPosition()
theta = self.state.orientation
self.artists.extend(drawRobot(self.axes, x, y, theta, facecolor="red"))
self.restoreLimits()
self.figure.canvas.draw()
def drawBoundObjects(self):
ggg = self.plansModel.selectedData().ggg
artists = []
selectedEsdc = self.esdcModel.selectedEsdc()
def callback(esdc):
if selectedEsdc == esdc:
selected = True
else:
selected = False
artists.extend(self.drawGroundingsForEsdc(esdc, ggg, selected))
breadthFirstTraverse(self.esdcs, callback)
return artists
def drawGroundingsForEsdc(self, esdc, ggg, selected=False):
artists = []
factor = ggg.esdc_to_factor(esdc)
if factor == None:
return []
#print "***** groundings"
#print "esdc is:", esdc
groundings = ggg.evidences[factor.nodes_for_link("top")[0].id]
#print repr(groundings)
#print "-----lambdas"
#print ggg.evidences[factor.nodes_with_type("lambda")[0].id]
if len(groundings) == 0:
print 'no groundings', esdc
return artists
value = groundings[0]
#print "value", value, value.__class__
if isinstance(value, PhysicalObject) or isinstance(value, Place):
#print "drawing obj", value
if selected:
plotArgs = dict(color="yellow", linewidth=3)
else:
plotArgs = dict(color="black")
artists.extend(drawObject(self.axes, value, plotArgs))
elif isinstance(value, Path):
X, Y = value.points_xy
args = dict(color="green", linewidth=1)
artists.extend(self.axes.plot(X, Y, "ro-", markersize=1, **args))
elif isinstance(value, list): #then value is a sequence of actions
raise ValueError("no longer supported")
self.mpl_draw()
return artists
def drawTopologicalMap(self):
args = dict(linewidth=1, color="red")
artists = []
nodeLocs = []
nodeLocs = self.state.topological_locations
for loc in nodeLocs:
x, y = loc
artists.extend(
self.axes.plot([x], [y], "ro-", markersize=3, **args))
return artists
def drawAgentPath(self):
plan = self.plansModel.selectedData()
artists = []
if plan != None:
state = plan.state
agent = state.getGroundableById(state.getAgentId())
artists.extend(
drawObject(self.axes, agent, shouldDrawStartAndEnd=True))
return artists
def drawActualPath(self):
artists = []
if (self.currAnnotation):
path = self.currAnnotation.agent.path
plotArgs = dict(color="red", linewidth=3)
artists.extend(drawPath(self.axes, path, plotArgs))
return artists
def selectEsdc(self):
# if self.esdcModel.selectedEsdc() in self.plansDict:
# self.plansModel.setData(self.plansDict[self.esdcModel.selectedEsdc()])
# self.esdcFeatureBrowser.selectEsdc(self.esdcModel.selectedEsdc())
self.draw()
esdc = self.esdcModel.selectedEsdc()
plan = self.plansModel.selectedData()
ggg = plan.ggg
factor = ggg.esdc_to_factor(esdc)
print "factor", factor, esdc
if factor != None:
print "loading crf feature weights"
self.crfFeatureWeights.load(ggg.context, self.taskPlanner.cf_obj,
factor)
def selectPlan(self):
#selectedAnnotation = self.plansModel.selectedPlan()
#print selectedAnnotation.toYaml()
#self.esdcFeatureBrowser.loadAnnotations([selectedAnnotation])
state, ggg = self.plansModel.selectedPlan()
self.contextWindow.setContext(state.to_context())
self.contextWindow.highlightGroundings(ggg.groundings)
print self.plansModel.selectedData().plan_string
self.draw()
def updateLimits(self, mplEvent):
self.saveLimits()
def saveLimits(self):
self.limits = self.axes.axis()
def restoreLimits(self):
if self.limits != None:
self.axes.axis(self.limits)
def groundingProbabilityGraph(self):
print "graph"
mpl.figure()
selectedEsdc = self.esdcModel.selectedEsdc()
if selectedEsdc == None:
return
values_to_prob = {}
values_to_groundings = {}
for plan in self.plansModel._data:
factor = plan.ggg.esdc_to_factor(selectedEsdc)
assert len(factor.gamma_nodes) == 1
node = factor.gamma_nodes[0]
node_value = plan.ggg.evidence_for_node(node)[0].withoutPath()
node_value_hash = tuple(node_value.hash_string)
cost = plan.ggg.cost_for_factor(factor)
prob = math.exp(-cost)
if node_value_hash in values_to_prob:
assert values_to_prob[node_value_hash] == prob
else:
values_to_prob[node_value_hash] = prob
values_to_groundings[node_value_hash] = node_value
X = []
heights = []
labels = []
for i, (key, prob) in enumerate(values_to_prob.iteritems()):
grounding = values_to_groundings[key]
X.append(i)
heights.append(prob)
labels.append(grounding.tags)
mpl.bar(X, heights)
mpl.xticks(na.array(X) + 0.4, labels)
mpl.ylabel("Probability")
mpl.ylim(0, 1)
mpl.show()
class MainWindow(QMainWindow, recipeCorpusBrowser_ui.Ui_MainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.recipeModel = recipeModel.Model(self.recipeTable)
self.instructionModel = instructionModel.Model(self.instructionTable)
self.windowManager = WindowManager(self.windowsMenu)
self.recipe_manager = RecipeManager("kitchenModel_1.5.pck")
self.recipeBrowser = recipeBrowser.MainWindow(self.recipe_manager)
self.recipeBrowser.show()
self.windowManager.addWindow(self.recipeBrowser)
self.costFunctionBrowser = costFunctionBrowser.MainWindow(
[0, 10, 0, 10], self.recipe_manager.task_planner)
self.costFunctionBrowser.save_state_tree = True
self.costFunctionBrowser.allow_null_action = False
self.windowManager.addWindow(self.costFunctionBrowser)
self.connect(
self.recipeTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectRecipe)
self.connect(self.sendInstructionButton, SIGNAL("clicked()"),
self.sendInstruction)
self.connect(self.sendRecipeButton, SIGNAL("clicked()"),
self.sendRecipe)
def sendRecipe(self):
ar = self.recipeModel.selectedEntry()
self.recipeBrowser.load(ar)
def sendInstruction(self):
entry = self.instructionModel.selectedEntry()
recipe = self.recipeModel.selectedEntry()
esdc, ggg = self.recipe_manager.make_ggg_for_instruction(entry.text)
self.costFunctionBrowser.gggs = [ggg]
self.costFunctionBrowser.esdcs = [esdc]
start_state = recipe.idx_to_start_state(entry.idx)
print 'start', start_state
self.costFunctionBrowser.followCommand(entry.text,
state=start_state,
esdcs=[esdc])
for plan in self.costFunctionBrowser.plansList[0:10]:
result = self.recipe_manager.sequence(plan)
string = planningLanguage.decompile(result)
print "planning language", string
def selectRecipe(self):
ar = self.recipeModel.selectedEntry()
self.recipeTextEdit.setPlainText(ar.recipe_text)
self.instructionModel.setRecipe(ar)
self.instructionTable.selectRow(0)
def load(self, fname):
self.recipeTable.selectRow(0)
self.instructionTable.selectRow(0)
training_set = pickle_util.load("training.pck")
print "training", training_set
recipes = Corpus(fname, training_set)
self.recipeModel.setData(recipes)
self.recipeTable.sortByColumn(recipeModel.COL_IS_TRAINING_SET,
Qt.AscendingOrder)
self.recipeTable.selectRow(0)
class MainWindow(QMainWindow, nodeFeatureWeights_ui.Ui_MainWindow):
def mpl_draw(self):
self.restoreLimits()
self.figure.canvas.draw()
def updateLimits(self, mplEvent):
self.saveLimits()
def saveLimits(self):
self.limits = self.axes.axis()
def restoreLimits(self):
if self.limits != None:
self.axes.axis(self.limits)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.nodeModel = nodeModel.Model(self.nodeTable)
self.nodeResultsModel = nodeResultsModel.Model(self.nodeResultsTable)
self.factorResultsModel = factorResultsModel.Model(
self.factorResultsTable)
self.featureModel = featureModel.Model(self.featureTable)
self.entropyMetricModel = entropyMetricModel.Model(
self.entropyMetricTable)
self.windowManager = WindowManager(self.windowsMenu)
self.contextWindow = context3d.MainWindow()
#self.context3dFrame.layout().addWidget(self.contextWindow.centralWidget())
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - Node Feature Weights")
#self.contextWindow.show()
self.windowManager.addWindow(self.contextWindow)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.limits = [-20, 30, 10, 51]
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.cf_obj = None
self.connect(
self.nodeTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectNode)
self.connect(
self.nodeResultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectNodeResult)
self.connect(
self.factorResultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectFactorResult)
def selectNode(self):
node = self.nodeModel.selectedNode()
node_results = []
for i, plan in enumerate(self.plans):
try:
nr = NodeResult(i, plan.ggg, node, plan.ggg)
nr.state = plan.state
except:
print "couldn't get top factors for node", node
print plan.ggg.node_to_top_esdc(node)
raise
node_results.append(nr)
#self.entropyMetricModel.setData(entropy_metrics.metrics.values(), node_results)
self.nodeResultsModel.setData(node_results)
def selectNodeResult(self):
r = []
for nr in self.nodeResultsModel.selectedEntries():
print "selected nr", nr
r.extend([
factorResultsModel.Entry(i, nr.end_ggg, factor)
for i, factor in enumerate(nr.node.factors)
])
self.factorResultsModel.setData(r)
overall_cost = sum(x.cost for x in r)
self.overallCostLabel.setText("%.3e" % overall_cost)
self.overallProbLabel.setText("%.3e" % math.exp(-overall_cost))
nr = self.nodeResultsModel.selectedEntry()
print 'highlight'
self.contextWindow.setContext(nr.state.to_context())
self.contextWindow.highlightGroundings([nr.inferred_pobj],
color="yellow")
groundings = []
for other_node in nr.node.factor_for_link("top").nodes:
if other_node.is_object:
groundings.extend(nr.ggg.evidence_for_node(other_node))
self.contextWindow.highlightGroundings(groundings, color="green")
def selectFactorResult(self):
factors = self.factorResultsModel.selectedEntries()
if len(factors) != 0:
fr = factors[0]
entry = fr.ggg.entry_for_factor(fr.factor)
self.featureModel.setData(self.cf_obj.lccrf, entry.dobs)
def load(self, cf_obj, gggs, plans, context=None):
self.cf_obj = cf_obj
self.ggg = gggs[0]
self.plans = plans
self.nodeModel.setData(self.ggg.gamma_nodes, self.ggg)
if context != None:
self.contextWindow.setContext(context)
self.selectNode()
self.selectNodeResult()
self.nodeResultsTable.selectRow(0)
self.selectFactorResult()
def draw(self):
self.axes.clear()
self.restoreLimits()
self.figure.canvas.draw()
class MainWindow(QMainWindow, crfFeatureWeights_ui.Ui_MainWindow):
def mpl_draw(self):
self.restoreLimits()
self.figure.canvas.draw()
def updateLimits(self, mplEvent):
self.saveLimits()
def saveLimits(self):
self.limits = self.axes.axis()
def restoreLimits(self):
if self.limits != None:
self.axes.axis(self.limits)
def __init__(self, taskPlanner=None, initialState=True):
QMainWindow.__init__(self)
self.setupUi(self)
self.featureModel = featureModel.Model(self.featureTable)
self.candidateModel = candidateModel.Model(self.factorCandidateTable)
self.groundingsModel = groundingsModel.Model(self.groundingTable)
self.windowManager = WindowManager(self.windowsMenu)
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - CRF Feature Weights")
self.windowManager.addWindow(self.contextWindow)
self.connect(
self.factorCandidateTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectCandidate)
self.connect(
self.groundingTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.draw)
self.connect(self.shouldDrawTextCheckBox, SIGNAL("stateChanged(int)"),
self.draw)
self.connect(self.shouldDrawIconsCheckBox, SIGNAL("stateChanged(int)"),
self.draw)
self.connect(self.shouldDrawAgentCheckBox, SIGNAL("stateChanged(int)"),
self.draw)
self.connect(self.shouldDrawObjectGeomCheckBox,
SIGNAL("stateChanged(int)"), self.draw)
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.axes.set_aspect("equal")
self.oldParent = self.figure.canvas.parent()
self.figure.canvas.setParent(self)
self.matplotlibFrame.layout().addWidget(self.figure.canvas)
self.toolbar = NavigationToolbar2QT(self.figure.canvas, self)
self.addToolBar(self.toolbar)
self.limits = [-20, 30, 10, 51]
#self.limits = [10, 40, 10, 40]
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.figure.canvas.mpl_connect('button_press_event', self.mapClick)
self.costImage = None
def load(self, context, cf_obj, factor):
self.cf_obj = cf_obj
self.candidateModel.setData(cf_obj.factor_to_cost[factor], cf_obj)
self.factorCandidateTable.selectRow(0)
if context == None:
context = Context.empty_context()
self.contextWindow.setContext(context)
def selectCandidate(self):
entry = self.candidateModel.selectedEntry()
if entry != None:
self.featureModel.setData(self.cf_obj.lccrf, entry.candidate.dobs)
self.featureTable.sortByColumn(featureModel.COL_WEIGHT_ABS)
self.groundingsModel.setData(list(entry.groundings))
self.groundingTable.selectAll()
import math
for phi in [True, False]:
ev = entry.ggg.evidences.add(entry.factor.phi_node.id, phi)
ggg = GGG.from_ggg_and_evidence(entry.ggg, ev)
cost, cobs, dobs = self.cf_obj.compute_factor_cost(
entry.factor, ggg, entry.states)
prob = math.exp(-cost)
print phi, prob
entry.ggg.set_evidence_for_node(entry.factor.phi_node, phi)
print "highlighting", entry.groundings
self.contextWindow.highlightGroundings(entry.all_groundings)
self.draw()
def draw(self):
self.axes.clear()
#self.axes.set_xticks([])
#self.axes.set_yticks([])
if self.costImage:
self.axes.imshow(
self.costImage.costs,
origin="lower",
extent=(self.costImage.xmin, self.costImage.xmax,
self.costImage.ymin, self.costImage.ymax),
# cmap=mpl.cm.gray)
cmap=mpl.cm.jet)
#norm=matplotlib.colors.Normalize(vmin=0.0, vmax=1.0))
for grounding in self.groundingsModel.selectedGroundings():
drawGrounding(self.axes,
grounding,
shouldDrawIcon=self.shouldDrawIcons,
shouldDrawText=self.shouldDrawText,
plotArgs=dict(color="black", lw=4))
if self.shouldDrawAgent:
for candidate in self.candidateModel.selectedEntries():
if candidate.ggg.context != None:
agent = candidate.ggg.context.agent
if agent != None:
ax, ay, az, ath = agent.path.locationAtT(0)
drawRobot(self.axes, ax, ay, ath)
drawObject(self.axes, agent, shouldDrawPath=True)
self.restoreLimits()
self.figure.canvas.draw()
def mapClick(self, mouseevent):
if not self.costImage or mouseevent.key != 'shift':
return
x = mouseevent.xdata
y = mouseevent.ydata
for (xe, ye), entries in self.costImage.costEntries:
if x > xe:
continue
if y > ye:
continue
break
for i in range(self.candidateModel.rowCount(None)):
if self.candidateModel.get(i).candidate in entries:
self.factorCandidateTable.selectRow(i)
break
def setCostImage(self, costs, xmin, xmax, ymin, ymax):
self.costImage = CostImage(costs, xmin, xmax, ymin, ymax)
self.limits = [xmin, xmax, ymin, ymax]
@property
def shouldDrawIcons(self):
return qt_utils.isChecked(self.shouldDrawIconsCheckBox)
@property
def shouldDrawAgent(self):
return qt_utils.isChecked(self.shouldDrawAgentCheckBox)
@property
def shouldDrawObjectGeom(self):
return qt_utils.isChecked(self.shouldDrawObjectGeomCheckBox)
@property
def shouldDrawText(self):
return qt_utils.isChecked(self.shouldDrawIconsCheckBox)
def __init__(self, model):
QMainWindow.__init__(self)
self.setupUi(self)
self.windowManager = WindowManager(self.windowsMenu)
self.taskPlanner = nodeSearch.BeamSearch(
cf.CostFnCrf.from_mallet(model))
self.cfBrowser = costFunctionBrowser.MainWindow(
limits=[10, 40, 10, 40],
taskPlanner=self.taskPlanner,
initialState=False)
self.cfBrowser.setWindowTitle(
str(self.cfBrowser.windowTitle()) +
" (Evaluation Results Browser)")
self.windowManager.addWindow(self.cfBrowser)
self.nodeFeatureWeights = nodeFeatureWeights.MainWindow()
self.gggBrowser = gggBrowser.MainWindow()
self.gggBrowser.setWindowTitle(self.gggBrowser.windowTitle() +
" (Evaluation Results Browser)")
self.windowManager.addWindow(self.gggBrowser)
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - Annotation")
self.windowManager.addWindow(self.contextWindow)
self.contextWindowInferred = context3d.MainWindow()
self.contextWindowInferred.setWindowTitle(
self.contextWindow.windowTitle() + " - Inferred")
self.windowManager.addWindow(self.contextWindowInferred)
self.original_commands_fname = None
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.limits = [10, 40, 10, 40]
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.resultsModel = resultsModel.Model(self.resultsTable)
self.resultListModel = resultsModel.Model(self.resultListTable)
self.nodeResultsModel = nodeResultsModel.Model(self.nodeResultsTable)
self.model = None
self.dataset = None
self.connect(
self.resultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectResult)
self.connect(
self.nodeResultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectNodeResult)
self.connect(self.sendToCfbButton, SIGNAL("clicked()"), self.sendToCfb)
self.connect(self.recomputeEntropyButton, SIGNAL("clicked()"),
self.recomputeEntropy)
self.connect(self.saveNodeResultsButton, SIGNAL("clicked()"),
self.saveNodeResults)
self.connect(self.plotEntropyButton, SIGNAL("clicked()"),
self.plotEntropy)
self.connect(self.sendToCfbNodeButton, SIGNAL("clicked()"),
self.sendToCfbNode)
self.connect(self.esdcFilter, SIGNAL("editingFinished()"),
self.filterEsdcs)
self.connect(self.nodeFilter, SIGNAL("editingFinished()"),
self.filterNodes)
print "adding export button"
self.connect(self.exportResultsButton, SIGNAL("clicked()"),
self.sendToClipboard)
print "adding export button"
self.connect(self.exportNodeResultsButton, SIGNAL("clicked()"),
self.sendToClipboardNodeResults)
self.filterEsdcs()
self.filterNodes()
self.resultsTable.selectRow(0)
signal.signal(signal.SIGINT, lambda *s: self.cleanup())
class MainWindow(QMainWindow, evaluationResultsBrowser_ui.Ui_MainWindow):
def cleanup(self):
sys.exit(1)
def mpl_draw(self):
self.restoreLimits()
self.figure.canvas.draw()
def __init__(self, model):
QMainWindow.__init__(self)
self.setupUi(self)
self.windowManager = WindowManager(self.windowsMenu)
self.taskPlanner = nodeSearch.BeamSearch(
cf.CostFnCrf.from_mallet(model))
self.cfBrowser = costFunctionBrowser.MainWindow(
limits=[10, 40, 10, 40],
taskPlanner=self.taskPlanner,
initialState=False)
self.cfBrowser.setWindowTitle(
str(self.cfBrowser.windowTitle()) +
" (Evaluation Results Browser)")
self.windowManager.addWindow(self.cfBrowser)
self.nodeFeatureWeights = nodeFeatureWeights.MainWindow()
self.gggBrowser = gggBrowser.MainWindow()
self.gggBrowser.setWindowTitle(self.gggBrowser.windowTitle() +
" (Evaluation Results Browser)")
self.windowManager.addWindow(self.gggBrowser)
self.contextWindow = context3d.MainWindow()
self.contextWindow.setWindowTitle(self.contextWindow.windowTitle() +
" - Annotation")
self.windowManager.addWindow(self.contextWindow)
self.contextWindowInferred = context3d.MainWindow()
self.contextWindowInferred.setWindowTitle(
self.contextWindow.windowTitle() + " - Inferred")
self.windowManager.addWindow(self.contextWindowInferred)
self.original_commands_fname = None
self.figure = mpl.figure()
self.axes = self.figure.gca()
self.limits = [10, 40, 10, 40]
self.restoreLimits()
self.figure.canvas.mpl_connect('draw_event', self.updateLimits)
self.resultsModel = resultsModel.Model(self.resultsTable)
self.resultListModel = resultsModel.Model(self.resultListTable)
self.nodeResultsModel = nodeResultsModel.Model(self.nodeResultsTable)
self.model = None
self.dataset = None
self.connect(
self.resultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectResult)
self.connect(
self.nodeResultsTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectNodeResult)
self.connect(self.sendToCfbButton, SIGNAL("clicked()"), self.sendToCfb)
self.connect(self.recomputeEntropyButton, SIGNAL("clicked()"),
self.recomputeEntropy)
self.connect(self.saveNodeResultsButton, SIGNAL("clicked()"),
self.saveNodeResults)
self.connect(self.plotEntropyButton, SIGNAL("clicked()"),
self.plotEntropy)
self.connect(self.sendToCfbNodeButton, SIGNAL("clicked()"),
self.sendToCfbNode)
self.connect(self.esdcFilter, SIGNAL("editingFinished()"),
self.filterEsdcs)
self.connect(self.nodeFilter, SIGNAL("editingFinished()"),
self.filterNodes)
print "adding export button"
self.connect(self.exportResultsButton, SIGNAL("clicked()"),
self.sendToClipboard)
print "adding export button"
self.connect(self.exportNodeResultsButton, SIGNAL("clicked()"),
self.sendToClipboardNodeResults)
self.filterEsdcs()
self.filterNodes()
self.resultsTable.selectRow(0)
signal.signal(signal.SIGINT, lambda *s: self.cleanup())
def sendToClipboard(self):
self.resultsModel.sendToClipboard()
def sendToClipboardNodeResults(self):
self.nodeResultsModel.sendToClipboard()
def sendToCfbNode(self):
result = self.nodeResultsModel.selectedEntry().best_result
self.sendResultToCfb(result)
def sendResultToCfb(self, result):
self.cfBrowser.updateEsdcs(result.esdcs, result.start_gggs)
self.cfBrowser.currAnnotation = result.annotation
self.cfBrowser.setState(result.start_state)
def sendToCfb(self):
'''send a command to the cost function browser'''
selectedResults = self.resultListModel.selectedData()
selectedResult = selectedResults[0]
self.sendResultToCfb(selectedResult)
def filterNodes(self):
expr = self.nodeFilter.text()
print expr
try:
filterFunction = eval(str(expr))
except:
raise
self.nodeResultsModel.setFilter(filterFunction)
self.updateNodeLabels()
def filterEsdcs(self):
expr = self.esdcFilter.text()
print expr
try:
filterFunction = eval(str(expr))
except:
raise
self.resultsModel.setFilter(filterFunction)
def plotEntropy(self):
print "making figure"
entries = self.nodeResultsModel.selectedEntries()
plot_entropy_curves(entries, "%d entries " % len(entries))
mpl.show()
def saveNodeResults(self):
entries = self.nodeResultsModel.entries
for e in entries:
e.ggg = None
e.annotation = None
#e.results = [e.results[0]] + random.sample(e.results[1:], 50)
for r in e.results:
r.end_ggg.remove_cost_entries()
fname = "node_results.pck"
print "saving", fname, "..."
pickle_util.save("node_results.pck", entries)
print "done"
def recomputeEntropy(self):
print "making figure"
fname = "%s/tools/g3/python/g3/evaluator/test_metric.py" % SLU_HOME
locals_dict = {}
execfile(fname, globals(), locals_dict)
metric = locals_dict["metric"]
entries = self.nodeResultsModel.entries
for entry in entries:
entry.entropy = metric(entry.results, entry.node)
self.nodeResultsModel.reset()
plot_entropy_curves(entries, "%d entries " % len(entries))
mpl.show()
def selectNodeResult(self, newSelection, oldSelection):
result = self.nodeResultsModel.selectedEntry()
self.contextWindowInferred.setContext(
result.annotation.context.withoutPaths())
self.contextWindowInferred.highlightGroundings([result.labeled_pobj],
color="green")
if result.inferred_pobj != None:
self.contextWindowInferred.highlightGroundings(
[result.inferred_pobj], color="red")
highlightTextLabel(self.entireEsdcTextNode, result.node_esdc)
self.updateNodeLabels()
self.gggBrowser.load(result.ggg)
def updateNodeLabels(self):
self.updateAccuracyLabel(self.nodeResultsModel.selectedEntries(),
self.selectedNodeAccuracyLabel)
self.updateAccuracyLabel(self.nodeResultsModel.allData(),
self.overallNodeAccuracyLabel)
def updateAccuracyLabel(self, data, label):
if len(data) == 0:
accuracy = 0
num = 0
denom = 0
else:
num = float(len([r for r in data if r.correct]))
denom = len(data)
accuracy = num / denom
label.setText("%.3f (%d of %d)" % (accuracy, num, denom))
def selectResult(self, newSelection, oldSelection):
selectedResults = self.resultsModel.selectedData()
result = selectedResults[0]
self.contextWindow.setContext(result.annotation.context)
self.contextWindowInferred.setContext(
result.annotation.context.withoutPaths())
self.contextWindowInferred.highlightGroundings(
result.end_ggg.groundings, color="cyan")
highlightTextLabel(self.entireEsdcText, result.esdcs)
self.resultListModel.loadResults(result)
self.resultListTable.selectRow(0)
self.nodeResultsModel.setData(
compute_node_results(selectedResults,
self.original_commands_fname))
self.updateNodeLabels()
def load(self, dataset_fname, results_dir, original_commands_fname):
self.resultsFile = ResultsFile(results_dir)
self.original_commands_fname = original_commands_fname
with open("%s/parameters.yaml" % results_dir, "r") as f:
self.parameters = yaml.load(f)
self.cfBrowser.beamWidthBox.setValue(self.parameters['beam_width'])
self.cfBrowser.seqBeamWidthBox.setValue(
self.parameters['beam_width_sequence'])
self.cfBrowser.searchDepthBox.setValue(
self.parameters['search_depth_event'])
self.cfBrowser.beamWidthEventBox.setValue(
self.parameters['beam_width_event'])
self.agileRunSummaryLog = "%s/agile_run_summary_log.txt" % results_dir
if (os.path.exists(self.agileRunSummaryLog) == False):
f = open(self.agileRunSummaryLog, 'w')
f.write('# ' + results_dir + '\n')
f.write('# EvaluationTimeSec LCMCommandLog\n')
f.close()
self.setWindowTitle("Evaluation Results Browser: " + results_dir)
self.resultsModel.loadResultsFile(self.resultsFile)
def updateLimits(self, mplEvent):
self.saveLimits()
def saveLimits(self):
self.limits = self.axes.axis()
def restoreLimits(self):
if self.limits != None:
self.axes.axis(self.limits)
class MainWindow(QMainWindow, recipeBrowser_ui.Ui_MainWindow):
def __init__(self, recipe_manager):
QMainWindow.__init__(self)
self.setupUi(self)
self.recipe_manager = recipe_manager
self.instructionModel = instructionModel.Model(self.instructionTable)
self.windowManager = WindowManager(self.windowsMenu)
self.recipe_manager = RecipeManager("kitchenModel_1.5.pck")
self.costFunctionBrowser = costFunctionBrowser.MainWindow(
[0, 10, 0, 10], self.recipe_manager.task_planner)
self.costFunctionBrowser.save_state_tree = True
self.costFunctionBrowser.allow_null_action = False
self.windowManager.addWindow(self.costFunctionBrowser)
self.connect(
self.instructionTable.selectionModel(),
SIGNAL("selectionChanged ( QItemSelection, QItemSelection )"),
self.selectInstruction)
self.connect(self.inferPlanButton, SIGNAL("clicked()"), self.inferPlan)
self.connect(self.sendToRobotButton, SIGNAL("clicked()"),
self.sendToRobot)
self.connect(self.sendInstructionToCfbButton, SIGNAL("clicked()"),
self.sendInstructionToCfb)
self.start_state = None
def selectInstruction(self):
print "select instruction"
def sendInstructionToCfb(self):
entry = self.instructionModel.selectedEntry()
esdc, ggg = self.recipe_manager.make_ggg_for_instruction(entry.text)
self.costFunctionBrowser.gggs = [ggg]
self.costFunctionBrowser.esdcs = [esdc]
self.costFunctionBrowser.followCommand(entry.text,
state=entry.start_state,
esdcs=[esdc])
for plan in self.costFunctionBrowser.plansList:
result = self.recipe_manager.sequence(plan)
string = planningLanguage.decompile(result)
print "planning language", string
def sendToRobot(self):
ingredients_str = "\n".join(i.ros_str()
for i in self.start_state.ingredients)
plan_string = "\n".join(
[e.annotation for e in self.instructionModel.entries])
print "send to robot."
print "ingredients"
print ingredients_str
print "plan"
print plan_string
self.sendToRos(ingredients_str + '\n' + plan_string)
def sendToRos(self, string):
import roslib
roslib.load_manifest('bakebot')
from services.bakebot_recipe_service import BakebotClient
status = BakebotClient.execute_recipe(string, debug=True)
print "ros status", status
def inferPlan(self):
print "follow command"
recipe_text = str(self.recipeTextEdit.toPlainText())
sequence = self.recipe_manager.find_plan(recipe_text, self.start_state)
entries = []
for i, (instruction, states, cost) in enumerate(sequence):
if i == 0:
start_state = self.start_state
else:
start_state = sequence[i - 1][1][-1][1]
annotation = planningLanguage.decompile(states)
entry = instructionModel.Entry(i, instruction.text, annotation,
start_state, cost)
entries.append(entry)
self.instructionModel.setData(entries)
def load(self, annotated_recipe):
self.recipeTextEdit.setPlainText(annotated_recipe.instruction_text)
self.recipeTitleLabel.setText(annotated_recipe.name)
self.start_state = annotated_recipe.start_state
self.annotated_recipe = annotated_recipe