def resize_mean(inFile, outFile, imSz):
	mn = mp.read_mean(inFile)
	dType = mn.dtype
	ch, rows, cols = mn.shape
	mn = mn.transpose((1,2,0))
	mn = scm.imresize(mn, (imSz, imSz)).transpose((2,0,1)).reshape((1,ch,imSz,imSz))
	write_proto(mn.astype(dType), outFile)
Example #2
0
 def load_mean(self):
     self.mu_ = None
     if self.param_.mean_file is not None:
         print('READING MEAN FROM %s', self.param_.mean_file)
         if self.param_.mean_file[-3:] == 'pkl':
             meanDat = pickle.load(open(self.param_.mean_file, 'r'))
             self.mu_ = meanDat['mu'].astype(np.float32).transpose(
                 (2, 0, 1))
         else:
             #Mean is assumbed to be in BGR format
             self.mu_ = mp.read_mean(self.param_.mean_file)
             self.mu_ = self.mu_.astype(np.float32)
         if self.param_.mean_type == '3val':
             self.mu_ = np.mean(self.mu_, axis=(1, 2)).reshape(1, 3, 1, 1)
             self.mu_ = np.concatenate((self.mu_, self.mu_), axis=1)
         elif self.param_.mean_type == 'img':
             ch, h, w = self.mu_.shape
             assert (h >= self.param_.crop_size
                     and w >= self.param_.crop_size)
             y1 = int(h / 2 - (self.param_.crop_size / 2))
             x1 = int(w / 2 - (self.param_.crop_size / 2))
             y2 = int(y1 + self.param_.crop_size)
             x2 = int(x1 + self.param_.crop_size)
             self.mu_ = self.mu_[:, y1:y2, x1:x2]
             self.mu_ = self.mu_.reshape((1, ) + self.mu_.shape)
         else:
             raise Exception('Mean type %s not recognized' %
                             self.param_.mean_type)
Example #3
0
def resize_mean(inFile, outFile, imSz):
    mn = mp.read_mean(inFile)
    dType = mn.dtype
    ch, rows, cols = mn.shape
    mn = mn.transpose((1, 2, 0))
    mn = scm.imresize(mn, (imSz, imSz)).transpose((2, 0, 1)).reshape(
        (1, ch, imSz, imSz))
    write_proto(mn.astype(dType), outFile)
def mean2graymean(inFile, outFile):
	assert not os.path.exists(outFile), '%s already exists' % outFile
	mn    = mp.read_mean(inFile)
	dType = mn.dtype
	ch = mn.shape[0]
	assert ch==3
	mn = rgb2gray(mn.transpose((1,2,0))).reshape((1,1,mn.shape[1],mn.shape[2]))
	print "New mean shape: ", mn.shape, dType
	write_proto(mn.astype(dType), outFile)
def siamese_mean2mean(inFile, outFile):
	assert not os.path.exists(outFile), '%s already exists' % outFile
	mn = mp.read_mean(inFile)
	ch = mn.shape[0]
	assert np.mod(ch,2)==0
	ch = ch / 2
	print "New number of channels: %d" % ch
	newMn = mn[0:ch].reshape(1,ch,mn.shape[1],mn.shape[2])
	write_proto(newMn.astype(mn.dtype), outFile)
def mean2siamese_mean(inFile, outFile, isGray=False):
	mn = mp.read_mean(inFile)
	if isGray:
		mn = mn.reshape((1,mn.shape[0],mn.shape[1]))
	mn    = np.concatenate((mn, mn))
	dType = mn.dtype 
	mn = mn.reshape((1, mn.shape[0], mn.shape[1], mn.shape[2]))
	print "New mean shape: ", mn.shape, dType
	write_proto(mn, outFile)
Example #7
0
def siamese_mean2mean(inFile, outFile):
    assert not os.path.exists(outFile), '%s already exists' % outFile
    mn = mp.read_mean(inFile)
    ch = mn.shape[0]
    assert np.mod(ch, 2) == 0
    ch = ch / 2
    print "New number of channels: %d" % ch
    newMn = mn[0:ch].reshape(1, ch, mn.shape[1], mn.shape[2])
    write_proto(newMn.astype(mn.dtype), outFile)
Example #8
0
def mean2siamese_mean(inFile, outFile, isGray=False):
    mn = mp.read_mean(inFile)
    if isGray:
        mn = mn.reshape((1, mn.shape[0], mn.shape[1]))
    mn = np.concatenate((mn, mn))
    dType = mn.dtype
    mn = mn.reshape((1, mn.shape[0], mn.shape[1], mn.shape[2]))
    print "New mean shape: ", mn.shape, dType
    write_proto(mn, outFile)
Example #9
0
def mean2graymean(inFile, outFile):
    assert not os.path.exists(outFile), '%s already exists' % outFile
    mn = mp.read_mean(inFile)
    dType = mn.dtype
    ch = mn.shape[0]
    assert ch == 3
    mn = rgb2gray(mn.transpose((1, 2, 0))).reshape(
        (1, 1, mn.shape[1], mn.shape[2]))
    print "New mean shape: ", mn.shape, dType
    write_proto(mn.astype(dType), outFile)
Example #10
0
	def load_mean(self):
		self.mu_ = None
		if len(self.param_.mean_file) > 0:
			#Mean is assumbed to be in BGR format
			self.mu_ = mp.read_mean(self.param_.mean_file)
			self.mu_ = self.mu_.astype(np.float32)
			ch, h, w = self.mu_.shape
			assert (h >= self.param_.crop_size and w >= self.param_.crop_size)
			y1 = int(h/2 - (self.param_.crop_size/2))
			x1 = int(w/2 - (self.param_.crop_size/2))
			y2 = int(y1 + self.param_.crop_size)
			x2 = int(x1 + self.param_.crop_size)
			self.mu_ = self.mu_[:,y1:y2,x1:x2]
 def load_mean(self):
     self.mu_ = None
     if 'binaryproto' in self.param_.mean_file:
         print('##### MEAN FILE FOUND ######')
         #Mean is assumbed to be in BGR format
         self.mu_ = mp.read_mean(self.param_.mean_file)
         self.mu_ = self.mu_.astype(np.float32)
         ch, h, w = self.mu_.shape
         assert (h >= self.param_.im_size and w >= self.param_.im_size)
         y1 = int(h / 2 - (self.param_.im_size / 2))
         x1 = int(w / 2 - (self.param_.im_size / 2))
         y2 = int(y1 + self.param_.im_size)
         x2 = int(x1 + self.param_.im_size)
         self.mu_ = self.mu_[:, y1:y2, x1:x2]
Example #12
0
def vis_generic_window_data(protoDef, numLabels, layerName='window_data', phase='TEST',
												maxVis=100):
	'''
		layerName: The name of the generic_window_data layer
		numLabels: The number of labels. 
	'''
	#Just write the data part of the file. 
	if not isinstance(protoDef, mpu.ProtoDef):
		protoDef = mpu.ProtoDef(protoDef)
	protoDef.del_all_layers_above(layerName)
	randInt = np.random.randint(1e+10)
	outProto = os.path.join(TMP_DATA_DIR, 'gn_window_%d.prototxt' % randInt)
	protoDef.write(outProto)		
	#Extract the name of the data and the label blobs. 
	dataName  = protoDef.get_layer_property(layerName, 'top', propNum=0)[1:-1]
	labelName = protoDef.get_layer_property(layerName, 'top', propNum=1)[1:-1]
	crpSize   = int(protoDef.get_layer_property(layerName, ['crop_size']))
	mnFile    = protoDef.get_layer_property(layerName, ['mean_file'])[1:-1]
	mnDat     = mp.read_mean(mnFile)
	ch,nr,nc  = mnDat.shape
	xMn       = int((nr - crpSize)/2)
	mnDat     = mnDat[:,xMn:xMn+crpSize,xMn:xMn+crpSize]
	print mnDat.shape
	
	#Create a network	
	if phase=='TRAIN':	
		net     = caffe.Net(outProto, caffe.TRAIN)
	else:
		net     = caffe.Net(outProto, caffe.TEST)

	lblStr = ''.join('lb-%d: %s, ' % (i,'%.2f') for i in range(numLabels))
	figDt = plt.figure()
	plt.ion()
	for i in range(maxVis):
		allDat  = net.forward([dataName,labelName])
		imData  = allDat[dataName] + mnDat
		lblDat  = allDat[labelName]
		batchSz = imData.shape[0]
		for b in range(batchSz):
			#Plot network data. 
			im1 = imData[b,0:3].transpose((1,2,0))
			im2 = imData[b,3:6].transpose((1,2,0))
			im1 = im1[:,:,[2,1,0]]
			im2 = im2[:,:,[2,1,0]]
			lb  = lblDat[b].squeeze()
			lbStr = lblStr % tuple(lb)	
			plot_pairs(im1, im2, figDt, lbStr) 
			raw_input()
Example #13
0
def vis_results_pose(prms, cPrms, modelIter):
    #Initialize the network
    exp = se.setup_experiment(prms, cPrms)
    modelFile = exp.get_snapshot_name(numIter=modelIter)
    defFile = exp.expFile_.def_
    net = caffe.Net(defFile, modelFile, caffe.TEST)
    bSz = exp.get_layer_property('window_data', 'batch_size', phase='TEST')
    crpSz = int(
        exp.get_layer_property('window_data', 'crop_size', phase='TEST'))
    muFile = exp.get_layer_property('window_data', 'mean_file')[1:-1]
    mn = mp.read_mean(muFile).transpose(1, 2, 0)
    st = int((227 - 101) / 2.0)
    print mn.shape
    mn = mn[st:st + 101, st:st + 101, :]
    mn = mn[:, :, [2, 1, 0]]
    plt.ion()
    count = 0
    numBatches = 5
    fig = plt.figure()
    for nb in range(numBatches):
        #Generate results on test set
        data = net.forward(['data', 'data_p', 'pose_fc', 'pose_label'])
        for b in range(int(bSz)):
            predLbl = data['pose_fc'][b].squeeze()
            predEuler = ru.quat2euler(predLbl)
            gtLbl = data['pose_label'][b].squeeze()
            gtEuler = ru.quat2euler(gtLbl)
            tStr = 'GT- roll: %.2f, yaw: %.2f, pitch: %.2f\n'\
                + 'PD- roll: %.2f, yaw: %.2f, pitch: %.2f'
            #pdb.set_trace()
            tStr = tStr % (gtEuler + predEuler)
            im1 = data['data'][b].transpose(1, 2, 0).squeeze()
            im2 = data['data_p'][b].transpose(1, 2, 0).squeeze()
            im1 = np.maximum(0, np.minimum(255, im1[:, :, [2, 1, 0]] + mn))
            im2 = np.maximum(0, np.minimum(255, im2[:, :, [2, 1, 0]] + mn))
            #pdb.set_trace()
            vu.plot_pairs(im1, im2, fig, figTitle=tStr)
            count += 1
            imName = exp.paths.testImVis % count
            plt.savefig(imName)