def extract_feats(vidreader,
                  extract_path,
                  num_prev_frames,
                  num_blocks,
                  smoothMasks,
                  window=5,
                  overlap=2):
    assert (window >
            overlap), "Window size needs to be greater than overlap window"
    _file = open_write_header(extract_path)
    start = time.time()
    frame_idx = num_prev_frames + num_blocks / 2
    numFrames = len(smoothMasks)
    while (frame_idx < numFrames):
        #print 'Extracting Feats ... {0}%\r'.format((frame_idx*100/numFrames)),
        (cnt, frames) = vidreader.read(frame_idx, window)
        if cnt == window:
            w_frames = []
            for frame in frames:
                frame = GRAY(frame) * smoothMasks[frame_idx]
                w_frames.extend(frame.flatten())
            w_frames = np.array(w_frames) / float(255)
            w_frames.tofile(_file, ' ', '%0.3f')
            _file.write(os.linesep)
        frame_idx += window - overlap
    _file.close()
    time_taken = time.time() - start
Example #2
0
def extract_feats(extract_path,
                  vidreader,
                  smoothMasks,
                  window_centers,
                  window_size,
                  num_blocks,
                  num_prev_frames,
                  rsz_shape=[80, 60],
                  write_gray=False,
                  bgImpl=None,
                  window=5,
                  overlap=2):
    _file = open_write_header(extract_path)
    shape = [vidreader.width, vidreader.height]
    skip_frames = num_prev_frames + num_blocks / 2
    frame_idx = 0
    numFrames = len(smoothMasks)
    _frame = np.zeros((window_size[1], window_size[0], 3))
    _ratio = rsz_shape[0] / float(window_size[0])
    _frame = cv2.resize(_frame, None, fx=_ratio, fy=_ratio)
    _shape = _frame.shape
    x_l = rsz_shape[0] / 2 - _shape[1] / 2
    y_l = rsz_shape[1] / 2 - _shape[0] / 2
    zero_frame = np.zeros((rsz_shape[1], rsz_shape[0], 3))
    while (frame_idx < numFrames):
        if not bgImpl is None:
            (cnt, frames) = vidreader.read(frame_idx + skip_frames, window + 1)
            prev_frame = crop_frame(frames[0], window_centers[frame_idx][0],
                                    window_size, shape, rsz_shape)
            cnt -= 1
            frame_idx += 1
            frames = frames[1:]
        else:
            (cnt, frames) = vidreader.read(frame_idx + skip_frames, window)

        if cnt == window:
            w_frames = []
            for frame in frames:
                frame = crop_frame(frame, window_centers[frame_idx][0],
                                   window_size, shape, rsz_shape)
                if write_gray:
                    feats = GRAY(frame)
                else:
                    feats = frame
                if not bgImpl is None:
                    bg_variation = bgImpl.process(frame, [prev_frame])
                    bgmask = bgImpl.threshold_mask(bg_variation) * 255
                    prev_frame = frame
                    feats = np.dstack((feats, bgmask))
                w_frames.extend(feats.flatten())
            w_frames = np.array(w_frames) / float(255)
            w_frames.tofile(_file, ' ', '%0.3f')
            _file.write(os.linesep)
        frame_idx += window - overlap
    _file.close()
    time_taken = time.time() - start
Example #3
0
	def process(self,cur_frame,prev_frames):
		N = prev_frames.__len__();
		assert(self.K<=N ),("length of prev frames less than " + str(self.K))
		shape = cur_frame.shape[:2];
		prev_frames = [GRAY(frame).flatten() for frame in prev_frames];		
		cur_frame = GRAY(cur_frame)			
		mean = np.mean(prev_frames,axis=0)
		mean_subtracted = [frame - mean for frame in prev_frames];
		mean_subtracted = np.asarray(mean_subtracted)
		eigv,eigt = np.linalg.eig(np.cov(mean_subtracted));
		eigt = np.dot(mean_subtracted.T,eigt); 
		eigt = eigt / np.linalg.norm(eigt,axis=0)
		idx = np.argsort(eigv)[::-1]
		eigt = eigt[:,idx]; eigv = eigv[idx]	
		score = np.dot(cur_frame.flatten()-mean,eigt[:,:self.K])		
		recon = np.dot(eigt[:,:self.K],score)+mean
		recon = np.uint8(recon.reshape(shape))
		diff = self.__frame_differencing__(recon,cur_frame)
		return diff;
def extract_feats(vidreader,extract_path,num_prev_frames,num_blocks,smoothMasks,window=5,overlap=2):
	assert(window>overlap),"Window size needs to be greater than overlap window"
	_file = open_write_header(extract_path);
	start = time.time(); 
	frame_idx = num_prev_frames + num_blocks/2	
	numFrames= len(smoothMasks);
	while(frame_idx < numFrames):
		#print 'Extracting Feats ... {0}%\r'.format((frame_idx*100/numFrames)),
		(cnt,frames) = vidreader.read(frame_idx,window);	
		if cnt==window:
			w_frames = [];
			for frame in frames:
				frame = GRAY(frame) * smoothMasks[frame_idx]; 
				w_frames.extend(frame.flatten());
			w_frames = np.array(w_frames)/float(255);
			w_frames.tofile(_file,' ','%0.3f');
			_file.write(os.linesep)
		frame_idx += window-overlap;
	_file.close();
	time_taken = time.time()-start;	
Example #5
0
 def process(self, cur_frame, prev_frames):
     N = prev_frames.__len__()
     assert (self.K <= N), ("length of prev frames less than " +
                            str(self.K))
     shape = cur_frame.shape[:2]
     prev_frames = [GRAY(frame).flatten() for frame in prev_frames]
     cur_frame = GRAY(cur_frame)
     mean = np.mean(prev_frames, axis=0)
     mean_subtracted = [frame - mean for frame in prev_frames]
     mean_subtracted = np.asarray(mean_subtracted)
     eigv, eigt = np.linalg.eig(np.cov(mean_subtracted))
     eigt = np.dot(mean_subtracted.T, eigt)
     eigt = eigt / np.linalg.norm(eigt, axis=0)
     idx = np.argsort(eigv)[::-1]
     eigt = eigt[:, idx]
     eigv = eigv[idx]
     score = np.dot(cur_frame.flatten() - mean, eigt[:, :self.K])
     recon = np.dot(eigt[:, :self.K], score) + mean
     recon = np.uint8(recon.reshape(shape))
     diff = self.__frame_differencing__(recon, cur_frame)
     return diff
Example #6
0
	def __extract_texture__(self,frame,regions,region_props,useGLCM=True,useEigen=True):
		num_regions = len(np.unique(regions));
		gray = GRAY(frame)
		texture_data_glcm = None; texture_data_eig = None
		if useGLCM:
			def texture_prop(region,patch_size = 2):
				_mean_min = region_props[0][region]-patch_size;
				_mean_max = region_props[0][region]+patch_size;
				glcm = greycomatrix(gray_frame[_mean_min[0]:_mean_max[0],_mean_min[1]:_mean_max[1]],
							[3], [0], 256, symmetric=True, normed=True)
				_dis = greycoprops(glcm, 'dissimilarity')[0, 0];
				_cor = greycoprops(glcm, 'correlation')[0, 0];
				return (_dis,_cor);
			texture_data_glcm = np.array([texture_prop(region) for region in range(num_regions)])
		
		if useEigen:			
			eigen = cv2.cornerEigenValsAndVecs(gray,15,3);
			eigen = eigen.reshape(gray.shape[0], gray.shape[1], 3, 2)
			texture_mag = normalize(np.sqrt(eigen[:,:,0,0]**2 +  eigen[:,:,0,1]**2))
			texture_dir1 = normalize(np.arctan2(eigen[:,:,1,1],eigen[:,:,1,0]))
			texture_dir2 = normalize(np.arctan2(eigen[:,:,2,1],eigen[:,:,2,0]))
			texture_prop  = np.dstack((texture_mag,texture_dir1,texture_dir1));
			texture_data_eig = np.array([np.sum(texture_prop[np.where(regions==region)],0)
												for region in range(num_regions)])
			_inv_freq = 1/(region_props[1]+0.0000001); 	
			texture_data_eig = texture_data_eig * _inv_freq[:,None]
			
		if useGLCM and useEigen:
			texture_data = np.hstack((texture_data_glcm,texture_data_eig));
		elif useGLCM:
			texture_data = texture_data_glcm
		elif useEigen:
			texture_data = texture_data_eig
		else:
			raise ArgumentError("argument useGLCM and useEigen both cannot be false");
		return texture_data
Example #7
0
def sobel(frame):
	frame = GRAY(frame);
	gx = cv2.Sobel(frame, cv2.CV_32F, 1, 0)
	gy = cv2.Sobel(frame, cv2.CV_32F, 0, 1)
	mag, ang = cv2.cartToPolar(gx, gy)
	return normalize(mag);
Example #8
0
 def __frame_differencing__(self, prev_frame, cur_frame):
     diff = absdiff(cur_frame, prev_frame)
     if diff.ndim == 3:  #color input
         diff = GRAY(diff)
     variation = normalize(float32(diff))
     return variation