def renderold(self, t):
M = np.eye(4, dtype=np.float32)
transforms.translate(M, -.5, 0, 0)
transforms.rotate(M, t*360, 0, 0, 1)
transforms.scale(M, 5, 5, 5)
p = math.floor(t / 8)
off = t - p * 8
b = max(0, 1 - ((t % 1) * 4))
m = 1 if off % 0.75 < 0.2 else 0
d = max(0, 1 - ((t % 16) * 1))
self.square.setProjection(self.projection)
self.square.setModelView(M)
self.square.setColor((b,m,d,1))
self.square.render()
M = np.eye(4, dtype=np.float32)
transforms.translate(M, -.5, 0, 0)
transforms.rotate(M, t*360+180, 0, 0, 1)
transforms.scale(M, 5, 5, 5)
self.square.setProjection(self.projection)
self.square.setModelView(M)
#self.square.setColor((.1,.1,.1,1))
self.square.render()
def render(self, t):
reltime = t - self.start
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1.5/50, .4, 1)
transforms.translate(M, (self.slot+.5) * 2.0/50 - 1, (reltime / -5) +.6 , 0)
self.bar.setModelView(M)
self.bar.render()
def render(self, t):
reltime = t - self.start
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1.5 / 50, .4, 1)
transforms.translate(M, (self.slot + .5) * 2.0 / 50 - 1,
(reltime / -5) + .6, 0)
self.bar.setModelView(M)
self.bar.render()
def render(self, t):
M = np.eye(4, dtype=np.float32)
transforms.scale(M, self.size, self.size, 1)
transforms.translate(M, self.pos[0], self.pos[1])
transforms.translate(M, math.sin(t * math.pi * 2 / 2 + self.phase) * 0.008 , 0)
self.geometry.setModelView(M)
self.geometry.setProjection(self.projection)
self.geometry.setColor(self.color)
self.geometry.render()
def render(self, t):
self.update(t - self.reltime)
M = np.eye(4, dtype=np.float32)
transforms.scale(M, self.size, self.size, 1)
transforms.translate(M, self.pos[0], self.pos[1])
self.geometry.setColor(self.color)
self.geometry.setModelView(M)
self.geometry.setProjection(self.projection)
self.geometry.render()
def render(self, t):
self.update(t - self.reltime)
M = np.eye(4, dtype=np.float32)
transforms.scale(M, self.size, self.size, 1)
transforms.translate(M, self.pos[0], self.pos[1])
self.geometry.setColor(self.color)
self.geometry.setModelView(M)
self.geometry.setProjection(self.projection)
self.geometry.render()
def render(self, t):
M = np.eye(4, dtype=np.float32)
transforms.scale(M, self.size, self.size, 1)
transforms.translate(M, self.pos[0], self.pos[1])
transforms.translate(
M,
math.sin(t * math.pi * 2 / 2 + self.phase) * 0.008, 0)
self.geometry.setModelView(M)
self.geometry.setProjection(self.projection)
self.geometry.setColor(self.color)
self.geometry.render()
def one2one_identity(self, im1, im2):
normalized_im1 = T.normalize(im1, mean=self.mean, std=self.std)
scale_im1, scale_ratio1 = T.scale(normalized_im1, short_size=self.base_size)
input_im1 = T.center_crop(scale_im1, crop_size=self.crop_size)
normalized_im2 = T.normalize(im2, mean=self.mean, std=self.std)
scale_im2, scale_ratio2 = T.scale(normalized_im2, short_size=self.base_size)
input_im2 = T.center_crop(scale_im2, crop_size=self.crop_size)
batch = np.asarray([input_im1, input_im2], dtype=np.float32)
scores = self.inference(batch, output_layer=self.prob_layer)
return M.cosine_similarity(scores[0], scores[1])
def render(self, t):
M = np.eye(4, dtype=np.float32)
transforms.scale(M, .03 * self.m, .03 * self.m, 1)
transforms.translate(M, self.pos[0], self.pos[1], 0)
if t > self.flicker:
dt = t - self.flicker
a = max(0, .5 - (dt/4))
n = math.sin(dt*20)/2 + 0.5
self.part.setColor((1,.5 + n * .5, n, a))
self.part.setModelView(M)
self.part.render()
def render(self, t):
M = np.eye(4, dtype=np.float32)
transforms.scale(M, .03 * self.m, .03 * self.m, 1)
transforms.translate(M, self.pos[0], self.pos[1], 0)
if t > self.flicker:
dt = t - self.flicker
a = max(0, .5 - math.pow(dt/4, 2))
n = math.sin(dt*30)/2 + 0.5
self.part.setColor((1,.5 + n * .5, n, a))
self.part.setModelView(M)
self.part.render()
def render(self, t):
n = 0
d = (t * 10) % len(self.lamps)
for p in self.lamps:
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1.0 / 60, 1.0 / 60, 1)
transforms.translate(M, p[0], p[1], 0)
self.star.setModelView(M)
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1, 1, 1)
self.star.setProjection(M)
if self.enabledLamp is not None:
self.star.color = (1, 1, 1,
1) if n == self.enabledLamp else (.1, 0, 0,
1)
else:
self.star.color = (1, 1, 1, 1) if int(d) == n else (.1, 0, 0,
1)
self.star.render()
n += 1
def cls_batch(self, batch_ims):
input_ims = []
for im in batch_ims:
im = im.astype(np.float32, copy=True)
normalized_im = T.normalize(im, mean=self.mean, std=self.std)
scale_im, scale_ratio = T.scale(normalized_im, short_size=self.base_size)
input_ims.append(T.center_crop(scale_im, crop_size=self.crop_size))
scores = self.inference(np.asarray(input_ims, dtype=np.float32), output_layer=self.prob_layer)
return scores
def det_im(self, im):
im = im.astype(np.float32, copy=True)
normalized_im = T.normalize(im, mean=self.mean, std=self.std)
scale_im, scale_ratio = T.scale(normalized_im, short_size=self.scales[0], max_size=self.max_sizes[0])
input_data = scale_im.transpose(2, 0, 1)
input_data = input_data.reshape((1,) + input_data.shape)
self.net.blobs['data'].reshape(*input_data.shape)
input_blob = {'data': input_data, 'rois': None}
input_blob['im_info'] = np.array([[scale_im.shape[0], scale_im.shape[1], 1.0]], dtype=np.float32)
self.net.blobs['im_info'].reshape(*input_blob['im_info'].shape)
# do forward
forward_kwargs = {'data': input_blob['data'].astype(np.float32, copy=False)}
forward_kwargs['im_info'] = input_blob['im_info'].astype(np.float32, copy=False)
output_blob = self.net.forward(**forward_kwargs)
rois = self.net.blobs['rois'].data.copy()
boxes = rois[:, 1:5]
scores = output_blob['cls_prob']
scores = scores.reshape(*scores.shape[:2])
# Apply bounding-box regression deltas
box_deltas = output_blob['bbox_pred']
box_deltas = box_deltas.reshape(*box_deltas.shape[:2])
pred_boxes = bbox_transform_inv(boxes, box_deltas)
pred_boxes = clip_boxes(pred_boxes, scale_im.shape)
objs = []
for cls_ind, cls in enumerate(self.class_map[1:]):
cls_ind += 1 # because we skipped background
if cfg.TEST.AGNOSTIC:
cls_boxes = pred_boxes[:, 4:8]
else:
cls_boxes = pred_boxes[:, cls_ind * 4:(cls_ind + 1) * 4]
cls_scores = scores[:, cls_ind]
dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
inds = np.where(dets[:, 4] > self.conf_thresh)
cls_dets = dets[inds]
keep = nms(cls_dets, self.nms_thresh)
dets_NMSed = cls_dets[keep, :]
if self.box_vote:
VOTEed = bbox_vote(dets_NMSed, cls_dets)
else:
VOTEed = dets_NMSed
_obj = boxes_filter(VOTEed, bbox_id=cls_ind, class_name=cls, color=self.color_map[cls_ind],
scale=scale_ratio, thresh=self.conf_thresh)
objs.extend(_obj)
return objs
def render(self, t):
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
M = np.eye(4, dtype=np.float32)
#transforms.rotate(M, t*20, 0, 1, 0)
#transforms.rotate(M, t*20, 1, 0, 0)
transforms.scale(M, .5, .5, .5)
transforms.translate(M, 0, 0, -2)
transforms.rotate(M, 00, 1, 0, 0)
transforms.scale(M, .4, .4, .4)
transforms.translate(M, 0, 0, -10)
projection = pyrr.matrix44.create_perspective_projection(
3, 1, 0.001, 10000)
self.tree.setProjection(projection)
self.tree.setModelView(M)
self.tree.render()
# self.lt.render()
gl.glDisable(gl.GL_DEPTH_TEST)
def render(self, t):
dt = t - self.last
if int(t * self.freq) > int(self.last * self.freq):
x = int(random.uniform(-25, 25))
y = int(random.uniform(-5, 5))
self.addstar(t, x, y)
self.last = t
positions = []
colors = []
for star in self.stars:
star.step(t, dt)
positions.append((star.x, star.y))
colors.append(star.color)
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1.0 / 25, 1.0 / 25, 1)
self.geometry.setStars(positions, colors)
self.geometry.setModelView(M)
self.geometry.render()
def cls_im(self, im):
im = im.astype(np.float32, copy=True)
normalized_im = T.normalize(im, mean=self.mean, std=self.std)
scale_im, scale_ratio = T.scale(normalized_im, short_size=self.base_size)
crop_ims = []
if self.crop_type == 'center' or self.crop_type == 'single': # for single crop
crop_ims.append(T.center_crop(scale_im, crop_size=self.crop_size))
elif self.crop_type == 'mirror' or self.crop_type == 'multi': # for 10 crops
crop_ims.extend(T.mirror_crop(scale_im, crop_size=self.crop_size))
else:
crop_ims.append(scale_im)
scores = self.inference(np.asarray(crop_ims, dtype=np.float32), output_layer=self.prob_layer)
return np.sum(scores, axis=0)
def render(self, t):
dt = t - self.last
x,y = self.getCenter(t)
dx = (x - self.lastx)/dt
dy = (y - self.lasty)/dt
self.lastx = x
self.lasty = y
if int(t*self.freq) > int(self.last*self.freq):
self.addstar(t, dx, dy)
self.last = t
positions = []
colors = []
for star in self.stars:
star.step(t, dt)
positions.append((star.x, star.y))
colors.append(star.color)
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1.0/25, 1.0/25, 1)
self.geometry.setStars(positions, colors)
self.geometry.setModelView(M)
self.geometry.render()
now = datetime.now()
digits = [ now.hour / 10, now.hour % 10, now.minute / 10, now.minute % 10, now.second / 10, now.second % 10 ]
digits = [ int(x) for x in digits ]
n = 0
for digit in digits:
M = np.eye(4, dtype=np.float32)
d = now.microsecond / 1000000
s = 1.2 - d * 0.2
transforms.scale(M, s, s, 1)
transforms.scale(M, 1.0/12, -1.0/10, 1)
transforms.translate(M, -.8 + (n * 0.3 ) , 0, 0)
if n % 2 == 0:
transforms.translate(M, 0.1 , 0, 0)
self.digits[digit].setModelView(M)
#self.digits[digit].color = (1,1,1, 0.5 + (1-d) * 0.5)
self.digits[digit].render()
n += 1
signalgenerator.setTexture(mainfbo.getTexture())
elif args.display == 'hub75e':
signalgenerator = geometry.hub75e.signalgenerator()
signalgenerator.setTexture(mainfbo.getTexture())
# Emulation shader
texquad = geometry.simple.texquad()
texquad.setTexture(mainfbo.getTexture())
# Tree emulator
tree = assembly.tree.tree(layoutfile)
tree.setTexture(mainfbo.getTexture())
# Projection matrix
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1, 1, 1)
# Effect
try:
i = __import__('assembly.%s' % args.effect)
effect = getattr(getattr(i, args.effect), args.effect)()
effect.setProjection(M)
except ImportError:
print('Unable to initialize effect %s' % args.effect)
raise
if args.music:
start_music()
if not args.raw and not args.preview and not args.emulate:
def __init__(self, factors, name=''):
super(ScaleNode, self).__init__(
name + " <scale by %s>" % str(tuple(factors.flatten())),
transforms.scale(factors))
def eval_batch():
# shuffle_conv1_channel()
eval_len = len(SET_DICT)
# eval_len = 1000
accuracy = np.zeros(len(args.top_k))
start_time = datetime.datetime.now()
for i in xrange(eval_len - args.skip_num):
im = cv2.imread(SET_DICT[i + args.skip_num]['path'])
if (PIXEL_MEANS == np.array([103.52, 116.28, 123.675])).all() and \
(PIXEL_STDS == np.array([57.375, 57.12, 58.395])).all():
scale_im = T.pil_scale(Image.fromarray(im), args.base_size)
scale_im = np.asarray(scale_im)
else:
scale_im, _ = T.scale(im, short_size=args.base_size)
input_im = T.normalize(scale_im, mean=PIXEL_MEANS, std=PIXEL_STDS)
crop_ims = []
if args.crop_type == 'center': # for single crop
crop_ims.append(T.center_crop(input_im, crop_size=args.crop_size))
elif args.crop_type == 'multi': # for 10 crops
crop_ims.extend(T.mirror_crop(input_im, crop_size=args.crop_size))
else:
crop_ims.append(input_im)
score_vec = np.zeros(args.class_num, dtype=np.float32)
iter_num = int(len(crop_ims) / args.batch_size)
timer_pt1 = datetime.datetime.now()
for j in xrange(iter_num):
scores = CLS.inference(
np.asarray(crop_ims, dtype=np.float32)[j * args.batch_size:(j + 1) * args.batch_size],
output_layer=args.prob_layer
)
score_vec += np.sum(scores, axis=0)
score_index = (-score_vec / len(crop_ims)).argsort()
timer_pt2 = datetime.datetime.now()
SET_DICT[i + args.skip_num]['evaluated'] = True
SET_DICT[i + args.skip_num]['score_vec'] = score_vec / len(crop_ims)
print 'Testing image: {}/{} {} {}/{} {}s' \
.format(str(i + 1), str(eval_len - args.skip_num), str(SET_DICT[i + args.skip_num]['path'].split('/')[-1]),
str(score_index[0]), str(SET_DICT[i + args.skip_num]['gt']),
str((timer_pt2 - timer_pt1).microseconds / 1e6 + (timer_pt2 - timer_pt1).seconds)),
for j in xrange(len(args.top_k)):
if SET_DICT[i + args.skip_num]['gt'] in score_index[:args.top_k[j]]:
accuracy[j] += 1
tmp_acc = float(accuracy[j]) / float(i + 1)
if args.top_k[j] == 1:
print '\ttop_' + str(args.top_k[j]) + ':' + str(tmp_acc),
else:
print 'top_' + str(args.top_k[j]) + ':' + str(tmp_acc)
end_time = datetime.datetime.now()
w = open(LOG_PTH, 'w')
s1 = 'Evaluation process ends at: {}. \nTime cost is: {}. '.format(str(end_time), str(end_time - start_time))
s2 = '\nThe model is: {}. \nThe val file is: {}. \n{} images has been tested, crop_type is: {}, base_size is: {}, ' \
'crop_size is: {}.'.format(args.model_weights, args.val_file, str(eval_len - args.skip_num),
args.crop_type, str(args.base_size), str(args.crop_size))
s3 = '\nThe PIXEL_MEANS is: ({}, {}, {}), PIXEL_STDS is : ({}, {}, {}).' \
.format(str(PIXEL_MEANS[0]), str(PIXEL_MEANS[1]), str(PIXEL_MEANS[2]), str(PIXEL_STDS[0]), str(PIXEL_STDS[1]),
str(PIXEL_STDS[2]))
s4 = ''
for i in xrange(len(args.top_k)):
_acc = float(accuracy[i]) / float(eval_len - args.skip_num)
s4 += '\nAccuracy of top_{} is: {}; correct num is {}.'.format(str(args.top_k[i]), str(_acc),
str(int(accuracy[i])))
print s1, s2, s3, s4
w.write(s1 + s2 + s3 + s4)
w.close()
if args.save_score_vec:
w = open(LOG_PTH.replace('.txt', 'scorevec.txt'), 'w')
for i in xrange(eval_len - args.skip_num):
w.write(SET_DICT[i + args.skip_num]['score_vec'])
w.close()
print('DONE!')
