def main():
parser = argparse.ArgumentParser(description='Progressively loads a scene')
parser.add_argument('--capture', '-c', metavar='motioncap.json', type=argparse.FileType('r'),
help='File of the motion capture to use for the camera. If not specified, keyboard and mouse controls are enabled.')
parser.add_argument('--scene', '-s', metavar='scene.json', type=argparse.FileType('r'), required=True,
help='Scene file to render.')
parser.add_argument('--show-stats', action='store_true', default=False,
help='Display on-screen statistics about scene while loading')
parser.add_argument('--dump-screenshot', '-d', metavar='directory', help='Directory to dump screenshots to')
parser.add_argument('--cache-dir', metavar='directory', help='Directory to use for cache files')
parser.add_argument('--priority-algorithm', choices=priority.get_priority_algorithm_names(),
help='The algorithm used for prioritizing tasks')
parser.add_argument('--priority-input', metavar='vars.json', type=argparse.FileType('r'),
help='Input file for priority algorithm if chosen type is FromFile')
parser.add_argument('--cdn-domain', metavar='example.com')
args = parser.parse_args()
outdir = None
if args.dump_screenshot is not None:
outdir = os.path.abspath(args.dump_screenshot)
if os.path.exists(outdir) and not os.path.isdir(outdir):
parser.error('Invalid screenshots directory: %s' % outdir)
elif not os.path.exists(os.path.join(outdir, 'realtime')):
os.makedirs(os.path.join(outdir, 'realtime'))
cachedir = None
if args.cache_dir is not None:
cachedir = os.path.abspath(args.cache_dir)
if os.path.exists(cachedir) and not os.path.isdir(cachedir):
parser.error('Invalid cache directory: %s' % cachedir)
elif not os.path.exists(cachedir):
os.mkdir(cachedir)
cache.init_cache(cachedir)
if args.priority_algorithm is not None:
algorithm = priority.get_algorithm_by_name(args.priority_algorithm)
algo_inputs = []
if issubclass(algorithm, priority.FromFile):
if args.priority_input is None:
parser.error("An input file must be specified for FromFile priority algorithm")
algo_inputs = [args.priority_input]
priority.set_priority_algorithm(algorithm(*algo_inputs))
if args.cdn_domain is not None:
open3dhub.set_cdn_domain(args.cdn_domain)
app = loader.ProgressiveLoader(args.scene,
capturefile=args.capture,
showstats=args.show_stats,
screenshot_dir=outdir)
app.run()
def main():
parser = argparse.ArgumentParser(
description="Fully loads a scene and then captures screenshots based on a previous run of loadscene.py"
)
parser.add_argument(
"--scene", "-s", metavar="scene.json", type=argparse.FileType("r"), required=True, help="Scene file to render."
)
parser.add_argument(
"--screenshot-dir",
"-d",
metavar="directory",
default=list(),
action="append",
help="Directory where screenshots were dumped and will be dumped",
)
parser.add_argument("--cache-dir", metavar="directory", help="Directory to use for cache files")
parser.add_argument(
"--priority-algorithm",
choices=priority.get_priority_algorithm_names(),
help="The algorithm used for prioritizing tasks",
)
parser.add_argument("--cdn-domain", metavar="example.com")
args = parser.parse_args()
screenshot_dirs = []
for outdir in args.screenshot_dir:
outdir = os.path.abspath(outdir)
screenshot_dirs.append(outdir)
if os.path.exists(outdir) and not os.path.isdir(outdir):
parser.error("Invalid screenshots directory: %s" % outdir)
elif not os.path.exists(os.path.join(outdir, "groundtruth")):
os.makedirs(os.path.join(outdir, "groundtruth"))
cachedir = None
if args.cache_dir is not None:
cachedir = os.path.abspath(args.cache_dir)
if os.path.exists(cachedir) and not os.path.isdir(cachedir):
parser.error("Invalid cache directory: %s" % cachedir)
elif not os.path.exists(cachedir):
os.mkdir(cachedir)
cache.init_cache(cachedir)
if args.priority_algorithm is not None:
algorithm = priority.get_algorithm_by_name(args.priority_algorithm)
priority.set_priority_algorithm(algorithm())
if args.cdn_domain is not None:
open3dhub.set_cdn_domain(args.cdn_domain)
app = FullSceneScreenshotLoader(args.scene, screenshot_dirs)
app.run()
def main():
parser = argparse.ArgumentParser(description='Graphs the results of priority_experiment_runner.py')
parser.add_argument('--experiment-dir', '-d', metavar='directory', required=True,
help='Directory where experiment was output to')
parser.add_argument('--output-dir', '-o', metavar='directory', required=True,
help='Directory where graphs should be output to')
args = parser.parse_args()
outdir = os.path.abspath(args.experiment_dir)
if os.path.exists(outdir) and not os.path.isdir(outdir):
parser.error('Invalid directory: %s' % outdir)
graphdir = os.path.abspath(args.output_dir)
if os.path.exists(graphdir) and not os.path.isdir(graphdir):
parser.error('Invalid directory: %s' % outdir)
if not os.path.exists(graphdir):
os.mkdir(graphdir)
algo_means = collections.defaultdict(list)
algo_rawdata = collections.defaultdict(dict)
algo_motion_means = collections.defaultdict(dict)
for priority_algo_name in priority.get_priority_algorithm_names():
if priority_algo_name in ('FromFile', 'HandTuned1', 'SinglePerceptualErrorSAng', 'SinglePerceptualErrorScale'):
continue
algo_class = priority.get_algorithm_by_name(priority_algo_name)
friendly_name = algo_class.name
algo_dir = os.path.join(outdir, priority_algo_name)
capdirs = os.listdir(algo_dir)
for capname in capdirs:
capdir = os.path.join(algo_dir, capname)
trial_dirs = os.listdir(capdir)
trial_means = []
for trial_name in trial_dirs:
trial_dir = os.path.join(capdir, trial_name)
if not os.path.exists(os.path.join(trial_dir, 'perceptualdiff.json')):
continue
perceptual_data = json.loads(open(os.path.join(trial_dir, 'perceptualdiff.json'), 'r').read())
times = []
errvals = []
for ssdata in perceptual_data:
num = float('.'.join(ssdata['filename'].split('.')[:2]))
times.append(num)
err = ssdata['perceptualdiff']
errvals.append(err)
times = numpy.array(times)
errvals = numpy.array(errvals)
if capname not in algo_rawdata[priority_algo_name]:
algo_rawdata[priority_algo_name][capname] = []
algo_rawdata[priority_algo_name][capname].append({'times': times,
'errvals': errvals})
diffs = numpy.ediff1d(times, to_begin=times[0] - 0)
mean = numpy.sum(diffs * errvals) / times[-1]
trial_means.append(mean)
print priority_algo_name, capname, ['%.7g' % v for v in trial_means]
algo_motion_means[friendly_name][capname] = trial_means
algo_means[friendly_name].extend(trial_means)
algo_results = [(numpy.mean(vals), name) for name, vals in algo_means.iteritems()]
print
print 'Absolute values'
print '==============='
for mean, name in sorted(algo_results, reverse=True):
print '%s %0.7g' % (name.rjust(20), mean)
print
print 'Normalized'
print '=========='
for mean, name in sorted(algo_results, reverse=True):
print '%s %.4g' % (name.rjust(20), mean / max(dict(algo_results).keys()))
print
print 'As percentage of image size'
print '==========================='
for mean, name in sorted(algo_results, reverse=True):
print '%s %s %%' % (name.rjust(20), ('%0.1f' % ((mean / (1024 * 768)) * 100)).rjust(4))
individual_wanted = ['Random',
'SingleCameraAngleExp',
'SingleScale',
'OptimizationResult',
'SingleSolidAngle',
'SingleDistance'
]
H = [
'#222222',
'#E41A1C',
'#377EB8',
'#4DAF4A',
'#984EA3',
'#FF7F00',
]
rc('font', size='8')
rc('font', family='serif')
for capname in capdirs:
fig = plt.figure(figsize=(4,2))
ax1 = fig.add_subplot(111)
colors = iter(H)
markers = iter(['s', 'p', 'o', 'v', '^', 'h'])
legend_lines = []
legend_names = []
for algo_priority_name in individual_wanted:
motionpath_data = algo_rawdata[algo_priority_name]
legend_names.append(algo_priority_name)
algo_trials = motionpath_data[capname]
color = next(colors)
marker = next(markers)
for i, trial in enumerate(algo_trials):
errvals = (numpy.array(trial['errvals'], dtype=float) / (1024 * 768)) * 100
res = ax1.plot(trial['times'], errvals, color=color, marker=marker, markersize=2, linewidth=0.5, markeredgewidth=0.2)
if i == 0:
legend_lines.append(res)
break
prop = FontProperties(size=5)
l1, l2, l3, l4, l5, l6 = legend_lines
leg = plt.legend(l1+l2+l3+l4+l5+l6, legend_names, loc='upper right', prop=prop, ncol=4, frameon=False, columnspacing=0.5)
# swap_and_right_align_legend
for vp in leg._legend_box._children[-1]._children:
for c in vp._children:
c._children.reverse()
vp.align = "right"
dangling1 = leg._legend_box._children[-1]._children[0]._children.pop(0)
dangling2 = leg._legend_box._children[-1]._children[1]._children.pop(0)
leg._legend_box._children[-1]._children[2]._children.append(dangling1)
leg._legend_box._children[-1]._children[3]._children.append(dangling2)
#plt.title('Error Over Time (%s)' % capname[8:-5])
plt.xlabel('Time (s)')
plt.ylabel('Perceptual Error (\% screen size)')
plt.yticks(range(0, 109, 10))
plt.ylim((0, 113))
ax1.xaxis.set_ticks_position('bottom')
ax1.yaxis.set_ticks_position('left')
plt.subplots_adjust(left=0.12, right=0.97, top=0.95, bottom=0.15)
plt.savefig(os.path.join(graphdir, 'rawcaps-' + capname + '.pdf'))
positions = numpy.arange(len(algo_results)) + 0.2
names = []
percentages = []
for mean, name in sorted(algo_results):
names.append(name)
percentages.append((mean / (1024 * 768)) * 100)
fig = plt.figure(figsize=(4, 2.5))
ax1 = fig.add_subplot(111)
H = ['#FBB4AE',
'#B3CDE3',
'#CCEBC5',
'#DECBE4',
'#FED9A6',
'#ff0000']
H1, H2, H3, H4, H5, H6 = H
W = '#ffffff'
colors = [H1, H5, H1, H3, H2, W, H5, H3, H3, H3, W, H1, H1, H3, H3, H3]
colors = [H1, W, H2, H3, W, H1, H3, H2, H2, H2, W, H1, H2, H1, H2, H2]
rc('font', size='10')
rc('font', family='serif')
textprop1 = FontProperties(size=5)
textprop2 = FontProperties(size=7)
rects = ax1.bar(positions, percentages, color=colors)
def autolabel(rects, labels):
maxheight = max(rect.get_height() for rect in rects)
for i, (rect, label) in enumerate(zip(rects, labels)):
height = rect.get_height()
yloc = height + maxheight * 0.03
if i > 7:
yloc = 1
plt.text(rect.get_x() + rect.get_width() / 2.0, yloc, label,
ha='center', va='bottom', rotation=90, fontproperties=textprop2)
plt.text(rect.get_x() + rect.get_width() / 2.0, height - maxheight * 0.04, '%0.1f' % rect.get_height(),
ha='center', va='bottom', clip_on=True, fontproperties=textprop1)
autolabel(rects, names)
#ax1.get_xaxis().set_visible(False)
ax1.yaxis.set_ticks_position('left')
plt.yticks(range(0, 101, 10))
plt.xticks(positions+0.4, [chr(i+65) for i in range(len(positions))])
for t in ax1.xaxis.get_ticklines():
t.set_visible(False)
plt.ylabel('Mean Perceptual Error')
plt.xlim((0, max(positions)+rects[0].get_width()+0.2))
plt.ylim((0, max(percentages)+1))
#plt.title('Perceptual Error by Priority Algorithm')
plt.subplots_adjust(left=0.14, right=0.98, top=0.97, bottom=0.11)
plt.savefig(os.path.join(graphdir, 'algo-percentages-bar.pdf'))
rc('font', size='18')
rc('font', family='sans-serif')
fig = plt.figure(figsize=(11.5, 8))
ax1 = fig.add_subplot(111)
positions = numpy.arange(len(algo_results)) + 0.1
bar_width = 0.1
algo_order = [name for mean, name in sorted(algo_results)]
colors = iter(['b', 'r', 'g', 'k', 'y', 'b', 'r', 'g'])
cap_means = {}
cap_percentages = {}
cap_mins = {}
cap_maxes = {}
for capname in capdirs:
percentages = []
mins = []
maxes = []
for algo_name in algo_order:
meanval = (numpy.mean(algo_motion_means[algo_name][capname]) / (1024 * 768)) * 100
percentages.append(meanval)
minval = (numpy.min(algo_motion_means[algo_name][capname]) / (1024 * 768)) * 100
mins.append(meanval - minval)
maxval = (numpy.max(algo_motion_means[algo_name][capname]) / (1024 * 768)) * 100
maxes.append(maxval - meanval)
cap_mins[capname] = mins
cap_maxes[capname] = maxes
cap_percentages[capname] = percentages
cap_means[capname] = numpy.mean(percentages)
caps_sorted = sorted((capname, mean) for mean, capname in cap_means.iteritems())
caporder = [capname for mean, capname in caps_sorted]
rects = []
for i, capname in enumerate(caporder):
errvals = ((cap_mins[capname], cap_maxes[capname]))
rect = ax1.bar(positions + bar_width*i,
cap_percentages[capname],
bar_width,
yerr=errvals,
color=next(colors))
rects.append(rect)
def autolabel2(rects, labels):
maxheight = max(rect.get_height() for rect in rects)
for rect, label in zip(rects, labels):
height = rect.get_height()
plt.text(rect.get_x() + rect.get_width() / 2.0, height + maxheight * 0.2, label,
ha='center', va='bottom', rotation=90)
autolabel2(rects[1], algo_order)
ax1.get_xaxis().set_visible(False)
ax1.yaxis.set_ticks_position('left')
plt.yticks(range(0, 101, 10))
plt.ylabel('Average perceptual error (percentage of screen size)')
plt.ylim((0, 100))
plt.title('Perceptual Error by Priority Algorithm and Motion Path')
prop = FontProperties(size=12)
plt.legend([c[8:-5] for c in caporder], loc=2, prop=prop, ncol=7, frameon=False, handlelength=1, columnspacing=1, handletextpad=0.5)
plt.subplots_adjust(left=0.08, right=0.96, top=0.94, bottom=0.04)
plt.savefig(os.path.join(graphdir, 'algo-percentages-motion-bars.pdf'))
