def show_diffeo_structure(dds, report, tolerance):
ds = DiffeoStructure(dds, tolerance=tolerance)
with report.subsection('display') as r:
ds.display(r)
with report.subsection('show_reduction_steps') as r:
ds.show_reduction_steps(r, max_nsteps=5)
with report.subsection('show_reduction') as r:
ds.show_reduction(r)
def set_discdds(self, discdds):
self.discdds = discdds
plans = self.plans_generator.get_plans(discdds)
reducer = DiffeoStructure(discdds, tolerance=self.reduce_tolerance)
red_plans, _ = reducer.get_minimal_equiv_set(plans)
# add back the empty plan
red_plans.append(())
print('reduced %d plans to %d' % (len(plans), len(red_plans)))
self.plans = red_plans
self.actions = [discdds.plan2action(p) for p in self.plans]
self.actions_i = [a.inverse() for a in self.actions]
print self.plans
def init(self, id_dds, dds):
self.ds = DiffeoStructure(dds=dds, **self.diffeo_structure_params)
self.original_dds = dds
dds_expanded = diffeosystem_expand(dds,
pr=self.ds.get_plan_reducer(),
heuristics=self.pre_expand)
# TODO: recompute structure
self.info('pre_expand: %s' % str(self.pre_expand))
self.info('Expanded to %s from %s actions' %
(len(dds_expanded.actions), len(dds.actions)))
super(InformedPlanner, self).init(id_dds, dds_expanded)
def __init__(self, id_dds, dds, tolerance, collapse_threshold,
min_visibility, debug_it, max_it):
self.dds = dds
self.ds = DiffeoStructure(dds, tolerance)
self.cover = DiffeoCover(id_dds,
self.dds,
self.ds,
collapse_threshold=collapse_threshold,
min_visibility=min_visibility,
debug_it=debug_it,
max_it=max_it)
self.cover.go()
def report_dds_geometry(id_discdds, tolerance):
dds = get_conftools_discdds().instance(id_discdds)
r = Report('dds_geometry-%s-%s' % (id_discdds, tolerance))
ds = DiffeoStructure(dds, tolerance=tolerance)
with r.subsection('display') as r:
ds.display(r)
with r.subsection('show_reduction_steps') as r:
ds.show_reduction_steps(r, max_nsteps=5)
with r.subsection('show_reduction') as r:
ds.show_reduction(r)
return r
def __init__(self, id_discdds, diffeo_structure_threshold, id_algo,
plan_length, num_tests, get_planning_thresholds, plans):
config = get_current_config()
self.config = config
# Load objects from configuration manager
self.discdds = config.discdds.instance(id_discdds)
self.algo = init_algorithm(self.config, id_algo, id_discdds,
self.discdds)
self.cmdlist = [
self.discdds.actions[i].original_cmd
for i in range(len(self.discdds.actions))
]
# pdb.set_trace()
self.metric_goal = self.algo.metric_goal
# Save input arguments
self.id_discdds = id_discdds
self.id_algo = id_algo
self.diffeo_structure_threshold = diffeo_structure_threshold
self.plan_length = plan_length
self.num_tests = num_tests
# Load orbit camera module
self.orbit_module = OrbitModule(self.discdds.get_shape())
# Set get_planning_thresholds function
if get_planning_thresholds.__class__ == 'str':
try:
self.get_planning_thresholds = eval(get_planning_thresholds)
except:
logger.info()
else:
self.get_planning_thresholds = get_planning_thresholds
self.get_planning_thresholds_name = str(get_planning_thresholds)
# Initiate diffeo_structure
self.diffeo_struct = DiffeoStructure(self.discdds,
diffeo_structure_threshold)
if plans == 'random':
self.plans = self.gennerate_random_plans()
elif plans.__class__ in [list, tuple]:
self.plans = tuple(plans)
else:
self.plans = eval(plans)
logger.info('Initialized with plans: ' + str(self.plans))
def __init__(self, id_discdds, plan_length):
'''
'''
self.plan_time = 1
self.metric = DistanceNorm(2)
# config_path = 'default:/home/adam/diffeo-data/'
# config = DiffeoplanConfigMaster()
# config.load(config_path)
# set_current_config(config)
config = get_current_config()
self.discdds = config.discdds.instance(id_discdds)
# Initiate diffeo_structure
diffeo_structure_threshold = 0.2
self.diffeo_struct = DiffeoStructure(self.discdds,
diffeo_structure_threshold)
# pdb.set_trace()
n = len(self.discdds.actions)
self.all_plans = []
for i in range(1, plan_length + 1):
self.all_plans += list(itertools.product(range(n), repeat=i))
self.plan_reduced = []
for plan in self.all_plans:
canon_plan = self.diffeo_struct.get_canonical(plan)
if self.plan_reduced.count(
canon_plan) == 0 and len(canon_plan) >= 1:
self.plan_reduced.append(canon_plan)
logger.info('Total number of plans initially: %g ' %
len(self.all_plans))
logger.info('Number of plans after reduction: %g ' %
len(self.plan_reduced))
print('Total number of plans initially: %g ' % len(self.all_plans))
print('Number of plans after reduction: %g ' % len(self.plan_reduced))
self.generate_diffeo(self.plan_reduced)
self.D = np.matrix(self.composed_discdds.actions_distance_L2())
logger.info('Action Graph Composed')
def __init__(self, id_dds, dds, tolerance, collapse_threshold,
min_visibility, debug_it, max_it):
self.dds = dds
self.ds = DiffeoStructure(dds, tolerance)
collapse_metric = DiffeoActionL2iwNormalized(self.ds)
self.cover = DiffeoCoverExp(
id_dds=id_dds,
dds=self.dds,
plan_reducer=self.ds.get_plan_reducer(),
collapse_metric=collapse_metric,
# collapse_threshold=collapse_threshold,
collapse_threshold=0.001,
max_depth=3,
debug_iterations=debug_it,
max_iterations=max_it)
self.cover.set_min_visibility(min_visibility)
self.cover.go()
