def saveFlowImFromFloDir(flo_dir,match_info_file,out_dir_flo_im):
    
    h5_files,img_files,img_sizes=po.parseInfoFile(match_info_file,lim=None)
    print len(img_files);
    flo_files=[os.path.join(flo_dir,file_name+'.flo') for file_name in util.getFileNames(img_files,ext=False)];
    out_files=[os.path.join(out_dir_flo_im,file_name+'.png') for file_name in util.getFileNames(img_files,ext=False)];

    args=[];
    for idx,(flo_file,out_file) in enumerate(zip(flo_files,out_files)):
        args.append((flo_file,out_file,idx))
    
    p=multiprocessing.Pool(multiprocessing.cpu_count())
    p.map(saveFlowImage,args)
def script_writeFloVizHTML(out_file_html,out_dir_viz,flo_files,im_files,tif_files,clusters,tifAsPng=False):

	img_paths=[];
	captions=[];
	# idx=0;
	for flo_file,im_file,tif_file in zip(flo_files,im_files,tif_files):
		# print idx;
		# print tif_file
		assert os.path.exists(tif_file);
		assert os.path.exists(im_file);
		# print tif_file
		# if not os.path.exists(tif_file) or not os.path.exists(im_file) :
		# 	continue;
		file_name=util.getFileNames([flo_file],ext=False)[0];
		out_file_pre=os.path.join(out_dir_viz,file_name);
		out_file_flo_viz=out_file_pre+'_flo.png';
		out_files_tif=[out_file_pre+'_tifim_x.png',out_file_pre+'_tifim_y.png',out_file_pre+'_tifflo.png'];
		if not os.path.exists(out_file_flo_viz):
			flo=util.readFlowFile(flo_file);
			po.saveFloFileViz(flo_file,out_file_flo_viz);
		for idx,out_file_tif_viz in enumerate(out_files_tif):
			tif=scipy.misc.imread(tif_file)[:,:,:2];
			if idx==0 and not os.path.exists(out_file_tif_viz):
				tif_flo=replaceClusterIdWithFlow(tif,clusters);
				po.saveMatFloViz(tif_flo,out_file_tif_viz);

			if not os.path.exists(out_file_tif_viz) and idx==1:
				tif_x=np.array(tif[:,:,0]*(255.0/clusters.shape[0]),dtype=int);
				tif_x=np.dstack((tif_x,tif_x,tif_x));
				scipy.misc.imsave(out_file_tif_viz,tif_x);

			if not os.path.exists(out_file_tif_viz) and idx==2:
				tif_x=np.array(tif[:,:,1]*(255.0/clusters.shape[0]),dtype=int);
				tif_x=np.dstack((tif_x,tif_x,tif_x));
				scipy.misc.imsave(out_file_tif_viz,tif_x);

			
		img_paths_curr=[im_file,out_file_flo_viz]+out_files_tif;
		im_name=util.getFileNames([im_file],ext=False)[0];
		captions_curr=[im_name,'flo_viz']+['tif_flo_viz']*len(out_files_tif)

		# if tifAsPng:
		# 	img_paths_curr.append(out_file_tif_viz.replace('_x.png','_y.png'));
		# 	captions_curr.append('tif_flo_viz');

		img_paths_curr=[util.getRelPath(file_curr) for file_curr in img_paths_curr];
		img_paths.append(img_paths_curr);
		captions.append(captions_curr);
		# idx=idx+1;

	visualize.writeHTML(out_file_html,img_paths,captions)
def script_testOnYoutube():
    val_file='/disk2/mayExperiments/finetuning_youtube_hmdb_llr/val_eq.txt'
    out_dir='/disk2/mayExperiments/eval_ucf_finetune';
    clusters_file='/home/maheenrashid/Downloads/debugging_jacob/optical_flow_prediction_test/examples/opticalflow/clusters.mat';
    gpu=0;

    util.mkdir(out_dir);
    # model_file='/home/maheenrashid/Downloads/debugging_jacob/optical_flow_prediction_test/examples/opticalflow/final.caffemodel';
    # out_dir_model=os.path.join(out_dir,'original_model');

    model_file='/disk2/mayExperiments/ft_youtube_hmdb_ucfClusters/OptFlow_youtube_hmdb__iter_55000.caffemodel';
    out_dir_model=os.path.join(out_dir,'ft_ucf_model');

    util.mkdir(out_dir_model);
    out_dir_flo=os.path.join(out_dir_model,'flo');
    out_dir_flo_viz=os.path.join(out_dir_model,'flo_viz');
    util.mkdir(out_dir_flo);util.mkdir(out_dir_flo_viz)

    num_to_pick=20;

    img_paths=util.readLinesFromFile(val_file);
    img_paths=[img_path[:img_path.index(' ')] for img_path in img_paths];
    class_names=[file_curr[:file_curr.index('_')] for file_curr in util.getFileNames(img_paths)];
    classes=list(set(class_names));
    class_names=np.array(class_names);
    
    img_paths_test=[];
    for class_curr in classes:
        idx_rel=np.where(class_names==class_curr)[0];
        idx_rel=idx_rel[:num_to_pick];
        img_paths_test.extend([img_paths[idx_curr] for idx_curr in idx_rel]);

    # po.script_saveFlosAndViz(img_paths_test,out_dir_flo,out_dir_flo_viz,gpu,model_file,clusters_file);

    out_file_html=os.path.join(out_dir,'model_comparison.html');
    out_dirs_flo_viz=[os.path.join(out_dir,'original_model','flo_viz'),os.path.join(out_dir,'ft_ucf_model','flo_viz')];
    out_dirs_flo_viz_captions=['original_model','ft_ucf_model'];
    img_paths_html=[];
    captions_html=[];
    img_names=util.getFileNames(img_paths_test,ext=False);
    for img_path_test,img_name in zip(img_paths_test,img_names):
        row_curr=[];
        row_curr.append(util.getRelPath(img_path_test));
        for out_dir_curr in out_dirs_flo_viz:
            file_curr=os.path.join(out_dir_curr,img_name+'.png');
            row_curr.append(util.getRelPath(file_curr));
        captions_curr=[img_name]+out_dirs_flo_viz_captions;
        img_paths_html.append(row_curr)
        captions_html.append(captions_curr);
    visualize.writeHTML(out_file_html,img_paths_html,captions_html);
Esempio n. 4
0
def insertMsg(f9Dir, cwd, keywords = ["msg"]):
    fileNames = util.getFileNames(f9Dir, cwd, keywords)
    for fileName in fileNames:
        #get the msg file
        msgFile = fileName.replace(".j", "")
        msgFile += "_msg.txt"
        #read in the contents of the quest file
        #and clean out any previous messages
        w = open(fileName, 'r')
        t = w.read()
        t = getMsg.sub("", t)
        w.close()
        #open the message file up
        w = open(msgFile, 'r')
        msg = w.read()
        w.close()
        #clean up its newlines
        #and add our own, notated as \l
        msg = msg.replace("\n", "")
        msg = msg.replace("\l", "\n")
        #create our new quest file
        t = t.replace("SetDescription(q, )", 'SetDescription(q, "' + msg.encode("string-escape") + '")', 1)
        #t = getMsg.sub(msg, t)
        #open it up and replace its contents with the new msg
        w = open(fileName, 'w')
        print>>w, t
        w.close()
def saveSlidingWindows((im_path,stride,w,out_dir,idx)):
    print idx
    im=scipy.misc.imread(im_path);
    
    r_idx_all=range(0,im.shape[0],stride);
    c_idx_all=range(0,im.shape[1],stride);
    
    im_name=util.getFileNames([im_path],ext=False)[0];
    ext=im_path[im_path.rindex('.'):];
    
    out_files=[];

    for idx_r_idx,r_idx in enumerate(r_idx_all):
        end_r=r_idx+w;        
        if end_r>im.shape[0]:
            continue;
        
        for idx_c_idx,c_idx in enumerate(c_idx_all):
            out_file=os.path.join(out_dir,im_name+'_'+str(idx_r_idx)+'_'+str(idx_c_idx)+ext);
            end_c=c_idx+w;

            if end_c>im.shape[1]:
                continue;
            if len(im.shape)>2:
                im_curr=im[r_idx:end_r,c_idx:end_c,:];
            else:
                im_curr=im[r_idx:end_r,c_idx:end_c];

            out_files.append(out_file);
            scipy.misc.imsave(out_file,im_curr);

    return out_files;
Esempio n. 6
0
def insertMsg(f9Dir, cwd, keywords=["msg"]):
    fileNames = util.getFileNames(f9Dir, cwd, keywords)
    for fileName in fileNames:
        #get the msg file
        msgFile = fileName.replace(".j", "")
        msgFile += "_msg.txt"
        #read in the contents of the quest file
        #and clean out any previous messages
        w = open(fileName, 'r')
        t = w.read()
        t = getMsg.sub("", t)
        w.close()
        #open the message file up
        w = open(msgFile, 'r')
        msg = w.read()
        w.close()
        #clean up its newlines
        #and add our own, notated as \l
        msg = msg.replace("\n", "")
        msg = msg.replace("\l", "\n")
        #create our new quest file
        t = t.replace(
            "SetDescription(q, )",
            'SetDescription(q, "' + msg.encode("string-escape") + '")', 1)
        #t = getMsg.sub(msg, t)
        #open it up and replace its contents with the new msg
        w = open(fileName, 'w')
        print >> w, t
        w.close()
def makeImTifViz(img_paths_all,tif_paths_all,out_file_html,out_dir_tif,num_clusters=40,disk_path='/disk2'):
	out_files_tif_x=[os.path.join(out_dir_tif,img_name+'_x.png') for img_name in util.getFileNames(tif_paths_all,ext='False')];
	out_files_tif_y=[os.path.join(out_dir_tif,img_name+'_y.png') for img_name in util.getFileNames(tif_paths_all,ext='False')];
	

	for tif_path,out_file_x,out_file_y in zip(tif_paths_all,out_files_tif_x,out_files_tif_y):
		tif=scipy.misc.imread(tif_path);
		# print np.min(tif[:,:,:2]),np.max(tif[:,:,:2])
		assert np.min(tif[:,:,:2])>0 and np.max(tif[:,:,:2])<num_clusters+1;
		saveTifGray(tif,out_file_x,out_file_y,num_clusters)
	
	# out_file_html=out_dir_tif+'.html';
	img_paths_html=[[util.getRelPath(img_curr,disk_path) for img_curr in img_list] for img_list in zip(img_paths_all,out_files_tif_x,out_files_tif_y)];
	# captions_html=[[util.getFileNames([img_curr],ext=False)[0] for img_curr in img_list] for img_list in zip(img_paths_all,out_files_tif_x,out_files_tif_y)];
	captions_html=[['Image','Tif_x','Tif_y']]*len(img_paths_html);
	visualize.writeHTML(out_file_html,img_paths_html,captions_html);
Esempio n. 8
0
def constants(constantsDir, constantsFile, cwd, keywords = [], rawCode = "", suffix = "", alt = ""):
    fileNames = util.getFileNames(constantsDir, cwd, keywords)
    varNames = [util.getFileName.findall(x)[0] for x in fileNames]
    varNames = [x.replace("_hero", "") for x in varNames]
    varNames = [x.replace("_vendor", "") for x in varNames]
    path = os.path.join(CONSTANTS_DIR, constantsFile)
    w = open(path, 'w')
    header = "library " + (constantsDir + alt).title() + "Constants\n"
    header = header.replace("_", "")
    header += "globals\n"
    i = 0
    objID = rawCode + "000"
    if rawCode == "N":
        i = 1
    elif rawCode == "w":
        i = "vZZZ"
    elif rawCode == "g":
        objID = rawCode + "001"
    for var in varNames:
        value = i
        if rawCode != "" and rawCode != "w" and rawCode != "g":
            value = int2Rawcode(value, rawCode)
        elif rawCode == "w" or rawCode == "g":
            value = "'" + objID + "'"
            objID = util.add(objID)
        header += "\tconstant integer " + var.upper() + suffix + " = " + str(value) + "\n"
        if rawCode != "w" and rawCode != "g":
            i += 1
    header += "endglobals\nendlibrary"
    print>>w, header
    w.close()
def stitchH5s(img_name,h5_files,img_files,C):
    if type(C)==type('str'):
        C=readClustersFile(C);
    num_parts_r=int(img_files[0].split('_')[-4]);
    num_parts_c=int(img_files[0].split('_')[-3]);

    img_files_names=util.getFileNames(img_files);
    file_pre=img_name+'_'+str(num_parts_r)+'_'+str(num_parts_c);

    for r_idx in range(num_parts_r):
        row_curr=[];
        for c_idx in range(num_parts_c):
            file_start=file_pre+'_'+str(r_idx)+'_'+str(c_idx);
            
            idx=[idx for idx,file_curr in enumerate(img_files_names) if file_curr.startswith(file_start)];
            # print len(idx),img_files_names
            assert len(idx)==1;
            idx=idx[0];

            np_data_curr=readH5(h5_files[idx]);
            np_data_curr=np_data_curr[0];
            # print 'np_data_curr.shape',np_data_curr.shape
            np_data_curr=np.transpose(np_data_curr,(1,2,0));
            # print 'np_data_curr.shape',np_data_curr.shape
            row_curr.append(np_data_curr)
        
        row_data=np.hstack(tuple(row_curr));
        # print 'row_data.shape',row_data.shape
        if r_idx==0:
            data_block=row_data;
        else:
            data_block=np.vstack((data_block,row_data));

    return data_block
def script_reSaveMatOverlap():

    dir_old='/disk3/maheen_data/pedro_val/mat_overlap';
    dir_new='/disk3/maheen_data/pedro_val/mat_overlap_check';

    util.mkdir(dir_new);
    
    path_to_im='/disk2/ms_coco/val2014';
    path_to_gt='/disk2/mayExperiments/validation_anno';

    mat_overlap_files=util.getFilesInFolder(dir_old,ext='.npz');
    im_names=util.getFileNames(mat_overlap_files,ext=False);

    args=[];
    for idx,(mat_overlap_file,im_name) in enumerate(zip(mat_overlap_files,im_names)):
        gt_file=os.path.join(path_to_gt,im_name+'.npy');
        im_file=os.path.join(path_to_im,im_name+'.jpg');
        out_file=os.path.join(dir_new,im_name+'.npz');
        # if os.path.exists(out_file):
        #     continue;

        args.append((mat_overlap_file,gt_file,im_file,out_file,idx));

    p = multiprocessing.Pool(32);
    p.map(fixMatOverlap, args);    
def rescaleImAndSaveMeta(img_paths,meta_dir,power_scale_range=(-2,1),step_size=0.5):
	img_names=util.getFileNames(img_paths);
	power_range=np.arange(power_scale_range[0],power_scale_range[1]+1,step_size);
	scales=[2**val for val in power_range];

	scale_infos=[];
	for idx,scale in enumerate(scales):
		out_dir_curr=os.path.join(meta_dir,str(idx));
		util.mkdir(out_dir_curr);
		scale_infos.append((out_dir_curr,scale));

	args=[];
	idx=0;
	for idx_img,img_path in enumerate(img_paths):
		for out_dir_curr,scale in scale_infos:
			out_file=os.path.join(out_dir_curr,img_names[idx_img]);
			
			if os.path.exists(out_file):
				continue;

			args.append((img_path,out_file,scale,idx));
			idx=idx+1;

	p=multiprocessing.Pool(multiprocessing.cpu_count());
	p.map(rescaleImAndSave,args);
Esempio n. 12
0
def script_saveHumanOnlyNeg():
    out_file='/disk2/aprilExperiments/positives_160_human.txt'
    out_dir='/disk2/aprilExperiments/negatives_npy_onlyHuman';
    util.mkdir(out_dir);
    im_pre='COCO_train2014_'

    lines=util.readLinesFromFile(out_file);
    img_files=[line[:line.index(' ')] for line in lines];

    img_names=util.getFileNames(img_files,ext=False);
    img_name=img_names[0];
    
    print img_name
    
    img_name_split=img_name.split('_');
    idx_all=[int(img_name.split('_')[-1]) for img_name in img_names];

    print len(img_names),len(idx_all),idx_all[0];
    cat_id=1;

    path_to_anno='/disk2/ms_coco/annotations';
    anno_file='instances_train2014.json';
    anno=json.load(open(os.path.join(path_to_anno,anno_file),'rb'))['annotations'];
    
    script_saveBboxFiles(anno,out_dir,im_pre,idx_all,cat_id)
def main():
    
    out_file_html='/disk3/maheen_data/headC_160_withFlow_justHuman/overlay_flo_50_viz.html'
    folders=['/disk3/maheen_data/headC_160_noFlow_justHuman/gt_overlap_50_viz','/disk3/maheen_data/headC_160_withFlow_justHuman/gt_overlap_50_viz','/disk3/maheen_data/headC_160_withFlow_justHuman/overlay_flo_50_viz'];
    img_names=util.getFileNames(util.getFilesInFolder(folders[0],ext='.png'),ext=True);
    height=500;
    width=500;
    captions=['no flo','with flo','boxes with flo']
    visualize.writeHTMLForDifferentFolders(out_file_html,folders,captions,img_names,height=height,width=width);
    print out_file_html;
    return

    params_dict={};
    params_dict ['mat_overlap_dir'] = '/disk3/maheen_data/headC_160_withFlow_justHuman/mat_overlaps_1000';
    params_dict ['gt_dir'] = '/disk3/maheen_data/val_anno_human_only';
    params_dict ['thresh_overlap'] = 0.5;
    params_dict ['flo_viz_dir'] = '/disk3/maheen_data/headC_160_withFlow_justHuman/im_with_padding/flo';
    params_dict ['results_dir_meta'] = '/disk3/maheen_data/headC_160_withFlow_justHuman/results';
    params_dict ['path_to_im_canon'] = '/disk3/maheen_data/headC_160_withFlow_justHuman/im/4';
    params_dict ['out_dir_overlay_flo'] = '/disk3/maheen_data/headC_160_withFlow_justHuman/overlay_flo_50_viz';
    params_dict ['gt_color'] = (255,0,0);
    params_dict ['pred_color'] = (255,255,255);
    params_dict ['alpha_overlay'] = 0.4;
    params_dict ['w'] = 160;
    params_dict ['stride'] = 16;
    params_dict ['power_scale_range'] = (-2,1);
    params_dict ['power_step_size'] = 0.5;
    params_dict ['num_threads'] =  multiprocessing.cpu_count();

    params=createParams('saveFloVizAll');
    params=params(**params_dict);

    script_saveFloVizAll(params)
    pickle.dump(params._asdict(),open(os.path.join(params.out_dir_overlay_flo,'params_saveFloVizAll.p'),'wb'));
Esempio n. 14
0
def writeTrainFilesWithFlow(old_train_file,dir_flo_im,new_train_file,ext='.png'):
    lines=util.readLinesFromFile(old_train_file);
    img_files=[line[:line.index(' ')] for line in lines];
    file_names=util.getFileNames(img_files,ext=False);
    flo_im_files=[os.path.join(dir_flo_im,file_name+ext) for file_name in file_names];
    for flo_im_file in flo_im_files:
        assert os.path.exists(flo_im_file);

    lines_new=[line+' '+flo_im_curr for line,flo_im_curr in zip(lines,flo_im_files)];
    util.writeFile(new_train_file,lines_new);
def script_saveSegSavingInfoFiles():

    dir_overlaps = '/disk3/maheen_data/headC_160_noFlow_bbox/mat_overlaps_no_neg_1000';
    out_dir='/disk3/maheen_data/debugging_score_and_scale';
    img_dir_meta='/disk2/mayExperiments/validation/rescaled_images';
    out_dir_npy=os.path.join(out_dir,'npy_for_idx');
    out_file_test_pre=os.path.join(out_dir,'test_with_seg');
    # out_file_test_big=os.path.join(out_dir,'test_with_seg_big.txt');
    util.mkdir(out_dir_npy);
    num_to_pick=10;


    mat_overlaps = util.getFilesInFolder(dir_overlaps,'.npz');
    # mat_overlaps = mat_overlaps[:10];

    args=[];
    for idx_mat_overlap_file,mat_overlap_file in enumerate(mat_overlaps):
        args.append((mat_overlap_file,num_to_pick,idx_mat_overlap_file));

    
    p = multiprocessing.Pool(multiprocessing.cpu_count());
    pred_scores_all = p.map(loadAndPickN,args);
    print len(args);


    lines_to_write={};
    # lines_to_write_big=[];
    img_names=util.getFileNames(mat_overlaps,ext=False);
    for img_name,pred_scores in zip(img_names,pred_scores_all):
        img_num_uni=np.unique(pred_scores[:,1]);
        for img_num in img_num_uni:
            img_num=int(img_num);
            curr_im=os.path.join(img_dir_meta,str(img_num),img_name+'.jpg');
            # print curr_im
            assert os.path.exists(curr_im);
            out_dir_npy_curr = os.path.join(out_dir_npy,str(img_num));
            util.mkdir(out_dir_npy_curr);
            out_file = os.path.join(out_dir_npy_curr,img_name+'.npy');
            pred_scores_rel = pred_scores[pred_scores[:,1]==img_num,:];

            np.save(out_file,pred_scores_rel);

            if img_num in lines_to_write:
                lines_to_write[img_num].append(curr_im+' '+out_file);
            else:
                lines_to_write[img_num]=[curr_im+' '+out_file];
            

    
    for img_num in lines_to_write.keys():
        out_file_test=out_file_test_pre+'_'+str(img_num)+'.txt';
        print out_file_test,len(lines_to_write[img_num]);
        util.writeFile(out_file_test,lines_to_write[img_num]);
def getRelevantFilesFromMatchFile(out_file_info,img_name):
    # print 'out_file_info',out_file_info
    h5_files,img_files,img_sizes=parseInfoFile(out_file_info);


    img_names=util.getFileNames(img_files,ext=False);
    idx_rel=[idx for idx,file_curr in enumerate(img_names) if file_curr.startswith(img_name)];
    
    h5_files=[h5_files[idx] for idx in idx_rel];
    img_files=[img_files[idx] for idx in idx_rel];
    img_sizes=[img_sizes[idx] for idx in idx_rel];
    return h5_files,img_files,img_sizes
Esempio n. 17
0
def script_saveFlowIm():
    pos_file='/disk2/aprilExperiments/positives_160_human.txt';
    # out_dir='/disk3/maheen_data/headC_160/noFlow_gaussian_human/pos_flos'

    out_dir='/disk3/maheen_data/headC_160/neg_flos'
    out_dir_flo_im=os.path.join(out_dir,'flo_im');
    util.mkdir(out_dir_flo_im);

    match_info_file=os.path.join(out_dir,'flo','match_info.txt');
    flo_dir=os.path.join(out_dir,'flo','flo_files');

    h5_files,img_files,img_sizes=po.parseInfoFile(match_info_file,lim=None)
    print len(img_files);
    flo_files=[os.path.join(flo_dir,file_name+'.flo') for file_name in util.getFileNames(img_files,ext=False)];
    out_files=[os.path.join(out_dir_flo_im,file_name+'.png') for file_name in util.getFileNames(img_files,ext=False)];

    args=[];
    for idx,(flo_file,out_file) in enumerate(zip(flo_files,out_files)):
        args.append((flo_file,out_file,idx))
    
    p=multiprocessing.Pool(multiprocessing.cpu_count())
    p.map(saveFlowImage,args)
Esempio n. 18
0
def script_sanityCheckEquivalenceClusters():
	old_train_txt='/disk2/mayExperiments/ft_youtube_hmdb_newClusters/train.txt';
	new_train_txt='/disk3/maheen_data/ft_youtube_40/train.txt';


	tif_list_old=getTifsFromTrain(old_train_txt);
	tif_list_new=getTifsFromTrain(new_train_txt);
	
	print len(tif_list_old),len(tif_list_new);

	dir_meta_old=getDirMetaFromTifPath(tif_list_old[0]);
	dir_meta_new=getDirMetaFromTifPath(tif_list_new[0]);
	image_dir_old=getImageDirFromTifPath(tif_list_old[0]);
	image_dir_new=getImageDirFromTifPath(tif_list_new[0]);


	print dir_meta_old,dir_meta_new,image_dir_old,image_dir_new

	# return 
	im_names_old=util.getFileNames(tif_list_old);
	im_names_new=util.getFileNames(tif_list_new);

	tif_list_both=list(set(im_names_old).intersection(set(im_names_new)));
	
	print len(tif_list_both)

	num_to_pick=100;
	random.shuffle(tif_list_both);
	tif_list_both=tif_list_both[:num_to_pick];
	for tif_name in tif_list_both:
		video_name=tif_name[:tif_name.index('.')];
		old_tif_path=os.path.join(dir_meta_old,video_name,image_dir_old,tif_name);
		new_tif_path=os.path.join(dir_meta_new,video_name,image_dir_new,tif_name);
		
		tif_new=scipy.misc.imread(new_tif_path);
		tif_old=scipy.misc.imread(old_tif_path);

		assert np.array_equal(tif_new,tif_old);
Esempio n. 19
0
def makeFloVizHTML(out_file_html,img_paths,dir_flo_viz):
    # out_file_html=os.path.join(out_dir,'flo_viz.html');
    img_paths_html=[];
    captions_html=[];
    for img_path,img_file_name in zip(img_paths,util.getFileNames(img_paths,ext=False)):
        out_file_flo_viz=os.path.join(dir_flo_viz,img_file_name+'.png');
        if img_path.startswith('/disk2'):
            img_path='/disk3'+img_path;

        img_paths_curr=[util.getRelPath(img_path,'/disk3'),util.getRelPath(out_file_flo_viz,'/disk3')];
        img_paths_html.append(img_paths_curr);
        captions_html.append([img_file_name,'flo']);

    visualize.writeHTML(out_file_html,img_paths_html,captions_html);
Esempio n. 20
0
def insert(insertFile, insertDir, newFile, cwd, header, keywords = []):
    fileNames = util.getFileNames(insertDir, cwd, keywords)
    insertFile = util.find(insertFile, util.find(cwd, util.root))
    insertions = ""
    for fileName in fileNames:
        w = open(fileName, 'r')
        insertions += w.read() + "\n"
        w.close()
    w = open(insertFile, 'r')
    t = w.read().replace(header, insertions)
    insertFile = insertFile.replace(getInsertFileDir.findall(insertFile)[-1], '')
    w = open(os.path.join(insertFile, newFile), 'w')
    print>>w, t
    w.close()    
Esempio n. 21
0
def script_checkSuppressFlowMatlabCode():
	dir_meta='/disk2/temp/aeroplane_10_3';
	dir_bef=os.path.join(dir_meta,'noThresh');
	dir_aft=os.path.join(dir_meta,'withThresh');
	out_dir=os.path.join(dir_meta,'viz');
	util.mkdir(out_dir)

	tif_files=util.getFilesInFolder(dir_bef,'.tif');
	tif_files=util.getFileNames(tif_files);
	for file_curr in tif_files:
		file_bef=os.path.join(dir_bef,file_curr);
		file_aft=os.path.join(dir_aft,file_curr);
		
		tif_bef_one=scipy.misc.imread(file_bef);
		tif_bef_one=tif_bef_one[:,:,0];

		tif_aft_one=scipy.misc.imread(file_aft);
		tif_aft_one=tif_aft_one[:,:,0];
		
		mat_info_bef=scipy.io.loadmat(os.path.join(dir_bef,file_curr[:file_curr.rindex('.')]+'.mat'));
		R=mat_info_bef['R'];
		L=mat_info_bef['L'];
		# print optFlow.shape,R.shape,L.shape
		# optFlow=np.dstack((optFlow,np.zeros((optFlow.shape[0],optFlow.shape[1],1))));
		# optFlow=cv2.resize(optFlow,(20,20));
		# optFlow=cv2.resize(optFlow,(R.shape[1],R.shape[0]));

		# print optFlow.shape
		# mag_bef_o=np.power(np.power(optFlow[:,:,0],2)+np.power(optFlow[:,:,1],2),0.5);
		mag_bef=np.power(np.power(R,2)+np.power(L,2),0.5);
		
		idx=np.where(mag_bef<1.0);
		# print idx[0].shape;
		# idx_o=np.where(mag_bef_o<1.0);
		# print idx_o[0].shape
		# print np.setdiff1d(idx[0],idx_o[0])
		# print np.setdiff1d(idx[1],idx_o[1])

		# break;


		print 'BEFORE'
		print np.unique(R[idx]);
		print np.unique(tif_bef_one[idx]);

		print 'AFTER'
		mat_info_aft=scipy.io.loadmat(os.path.join(dir_aft,file_curr[:file_curr.rindex('.')]+'.mat'));
		print np.unique(mat_info_aft['R'][idx]);
		print np.unique(tif_aft_one[idx]);
		assert np.unique(tif_aft_one[idx])[0]==40;
Esempio n. 22
0
def dialog(dialogDir, cwd, keywords = ["msg"]):
    fileNames = util.getFileNames(dialogDir, cwd, keywords)
    for fileName in fileNames:
        textFile = fileName.replace(".j", "")
        textFile += "_msg.txt"
        msgs = process(textFile)
        w = open(fileName, 'r')
        t = w.read()
        t = getMsg.sub("", t)
        w.close()
        for msg in msgs:
            t = t.replace("StoryMsg()", 'StoryMsg("' + msg.encode("string-escape") + '")', 1)
        w = open(fileName, 'w')
        print>>w, t
        w.close()
def averageMagnitudes((img_name,img_size_org,filter_size,step_size,img_files,h5_files,img_sizes,C,out_dir,idx_img_name)):
    print idx_img_name
    if type(C)==type('str'):
        C=readClustersFile(C);

    img_files_names=util.getFileNames(img_files,ext=False);
    r_pad=getPadTuple(img_size_org[0],filter_size,step_size);
    c_pad=getPadTuple(img_size_org[1],filter_size,step_size);
    
    

    new_shape=(img_size_org[0]+r_pad[0]+r_pad[1],img_size_org[1]+c_pad[0]+c_pad[1])
    assert (new_shape[0]-filter_size)%step_size==0
    num_parts_r = (new_shape[0]-filter_size)/step_size+1
    assert (new_shape[1]-filter_size)%step_size==0;
    num_parts_c = (new_shape[1]-filter_size)/step_size+1

    total_arr=np.zeros(new_shape);
    count_arr=np.zeros(new_shape);
    
    for r_idx_curr in range(num_parts_r):
        for c_idx_curr in range(num_parts_c):

            file_rel_start=img_name+'_'+str(r_idx_curr)+'_'+str(c_idx_curr);
            h5_file=h5_files[img_files_names.index(file_rel_start)];
            img_size=img_sizes[img_files_names.index(file_rel_start)];
    
            im_curr=getMatFromH5(h5_file,img_size,C)
            mag=getFlowMag(im_curr);
            
            start_r=r_idx_curr*step_size;
            start_c=c_idx_curr*step_size;
            
            end_r=start_r+filter_size;
            end_c=start_c+filter_size;
            
            assert end_r-start_r==mag.shape[0];
            assert end_c-start_c==mag.shape[1];

            total_arr[start_r:end_r,start_c:end_c]=total_arr[start_r:end_r,start_c:end_c]+mag;
            count_arr[start_r:end_r,start_c:end_c]=count_arr[start_r:end_r,start_c:end_c]+1;

    avg_arr=total_arr/count_arr;

    out_file_name=os.path.join(out_dir,img_name+'.npy');
    np.save(out_file_name,avg_arr);
    # util.writeFlowFile(total_arr/count_arr,out_file_name);
    return out_file_name
Esempio n. 24
0
def dialog(dialogDir, cwd, keywords=["msg"]):
    fileNames = util.getFileNames(dialogDir, cwd, keywords)
    for fileName in fileNames:
        textFile = fileName.replace(".j", "")
        textFile += "_msg.txt"
        msgs = process(textFile)
        w = open(fileName, 'r')
        t = w.read()
        t = getMsg.sub("", t)
        w.close()
        for msg in msgs:
            t = t.replace("StoryMsg()",
                          'StoryMsg("' + msg.encode("string-escape") + '")', 1)
        w = open(fileName, 'w')
        print >> w, t
        w.close()
Esempio n. 25
0
def constantsStr(constantsDir, constantsFile, cwd, keywords = [], suffix = "_STR"):
    fileNames = util.getFileNames(constantsDir, cwd, keywords)
    varNames = [util.getFileName.findall(x)[0] for x in fileNames]
    path = os.path.join(CONSTANTS_DIR, constantsFile)
    w = open(path, 'w')
    header = "library " + constantsDir.title() + "StringConstants\n"
    header = header.replace("_", "")
    header += "globals\n"
    for x in range (0, len(fileNames)):
        u = open(fileNames[x], 'r')
        value = getObjectName.findall(u.read())[0]
        u.close()
        header += "\tconstant string " + varNames[x].upper() + suffix + " = \"" + value + "\"\n"
    header += "endglobals\nendlibrary"
    print>>w, header
    w.close()
Esempio n. 26
0
def insert(insertFile, insertDir, newFile, cwd, header, keywords = [], sort = False):
    fileNames = util.getFileNames(insertDir, cwd, keywords)
    if sort:
        fileNames = sorted(fileNames, key=lambda filename: os.stat(filename).st_ctime)
    insertFile = util.find(insertFile, util.find(cwd, util.root))
    insertions = ""
    for fileName in fileNames:
        w = open(fileName, 'r')
        insertions += w.read() + "\n"
        w.close()
    w = open(insertFile, 'r')
    t = w.read().replace(header, insertions)
    insertFile = insertFile.replace(getInsertFileDir.findall(insertFile)[-1], '')
    w = open(os.path.join(insertFile, newFile), 'w')
    print>>w, t
    w.close()
Esempio n. 27
0
def constantsLib(constantsDir, constantsFile, cwd, keywords = []):
    path = os.path.join(CONSTANTS_DIR, constantsFile)
    fileNames = util.getFileNames(constantsDir, cwd, keywords)
    requiresStr = " requires "
    p = re.compile(r', $')
    for fileName in fileNames:
        w = open(fileName, 'r')
        t = w.read()
        w.close()
        libName = getLibName.findall(t)
        if libName != []:
            requiresStr += libName[0] + ", "
    requiresStr = p.sub("", requiresStr)
    header = "library Constants" + requiresStr + "\nglobals\nendglobals\nendlibrary"
    w = open(path, 'w')
    print>>w, header
    w.close()
def script_saveFlosAndViz(img_paths,dir_test,flo_viz_dir,gpu,model_file,clusters_file,train_val_file=None,overwrite=False):
    # h5_dir=os.path.join(dir_test,'h5');
    # flo_dir=os.path.join(dir_test,'flo');
    # flo_viz_dir=os.path.join(dir_test,'flo_viz');
    # util.mkdir(h5_dir);
    # print train_val_file,'script_saveFlosAndViz';
    script_saveFlos(img_paths,dir_test,gpu,model_file,clusters_file,train_val_file=train_val_file,overwrite=overwrite)
    
    flo_dir=os.path.join(dir_test,'flo_files');
    
    flo_files=[os.path.join(flo_dir,file_curr) for file_curr in util.getFilesInFolder(flo_dir,'.flo')];
    flo_files_names=util.getFileNames(flo_files,ext=False);
    flo_files_viz=[os.path.join(flo_viz_dir,file_curr+'.png') for file_curr in flo_files_names];

    out_file_sh=flo_viz_dir+'.sh'
    writeScriptToGetFloViz(flo_files,flo_files_viz,out_file_sh);
    subprocess.call('sh '+out_file_sh,shell=True);
Esempio n. 29
0
def questMsg(questDir, cwd, keywords = ["msg"]):
    fileNames = util.getFileNames(questDir, cwd, keywords)
    for fileName in fileNames:
        textFile = fileName.replace(".j", "")
        textFile += "_msg.txt"
        w = open(fileName, 'r')
        t = w.read()
        t = getMsg.sub("", t)
        w.close()
        w = open(textFile, 'r')
        msg = w.read()
        w.close()
        msg = msg.replace("\n", "")
        msg = msg.replace("\\l", "\n")
        t = t.replace("setDescription()", 'setDescription("' + msg.encode("string-escape") + '")', 1)
        w = open(fileName, 'w')
        print>>w, t
        w.close()
Esempio n. 30
0
def questMsg(questDir, cwd, keywords=["msg"]):
    fileNames = util.getFileNames(questDir, cwd, keywords)
    for fileName in fileNames:
        textFile = fileName.replace(".j", "")
        textFile += "_msg.txt"
        w = open(fileName, "r")
        t = w.read()
        t = getMsg.sub("", t)
        w.close()
        w = open(textFile, "r")
        msg = w.read()
        w.close()
        msg = msg.replace("\n", "")
        msg = msg.replace("\\l", "\n")
        t = t.replace("setDescription()", 'setDescription("' + msg.encode("string-escape") + '")', 1)
        w = open(fileName, "w")
        print >> w, t
        w.close()
def script_saveFlos(img_paths,dir_test,gpu,model_file,clusters_file,overwrite=False,train_val_file=None):
    test_file=os.path.join(dir_test,'test.txt');
    out_file_info=os.path.join(dir_test,'match_info.txt');
    out_dir_flo=os.path.join(dir_test,'flo_files');
    util.mkdir(out_dir_flo);

    C=readClustersFile(clusters_file);
    # print overwrite

    if (not os.path.exists(test_file)) or overwrite:
        makeTestFile(img_paths,test_file);

        # call the network
        # print train_val_file
        command=stj.getCommandForTest(test_file,model_file,gpu,train_val_file=train_val_file);
        # print command
        # raw_input();

        # print command;
        # return
        subprocess.call(command,shell=True);


    # print overwrite;
    # raw_input();
    # # get the h5 and img file correspondences
    if (not os.path.exists(out_file_info)) or overwrite:
        # print 'hello'
        saveOutputInfoFileMP(os.path.join(dir_test,'results'),out_file_info,img_paths)
        # saveOutputInfoFile(os.path.join(dir_test,'results'),out_file_info);

    h5_files,img_files,img_sizes=parseInfoFile(out_file_info);
    print len(h5_files)
    out_files_flo=[os.path.join(out_dir_flo,file_curr+'.flo') for file_curr in util.getFileNames(img_files,ext=False)];
    args=[];
    for idx in range(len(h5_files)):
        if not overwrite:
            if os.path.exists(out_files_flo[idx]):
                continue;
        args.append((h5_files[idx],img_sizes[idx],C,out_files_flo[idx],idx))

    print len(args);
    p=multiprocessing.Pool(NUM_THREADS)
    p.map(saveH5AsFloMP,args)
Esempio n. 32
0
def script_seeMultipleClusters(dir_clusters=None,out_dir_plot=None):
	if dir_clusters is None:
		dir_clusters='/disk3/maheen_data/debug_networks/clusters_youtube_multiple';

	if out_dir_plot is None:
		out_dir_plot='/disk2/temp/cluster_plots';

	util.mkdir(out_dir_plot);	
	clusters_all=util.getFilesInFolder(dir_clusters,'.npy');
	print len(clusters_all);
	for idx_cluster_file,cluster_file in enumerate(clusters_all):
		print idx_cluster_file;
		cluster_name=util.getFileNames([cluster_file],ext=False)[0];
		out_file=os.path.join(out_dir_plot,cluster_name+'.png');
		cluster_curr=np.load(cluster_file);
		visualize.plotScatter([(cluster_curr[:,0],cluster_curr[:,1])],out_file,color='r');		
		# files_all.append(out_file);

	visualize.writeHTMLForFolder(out_dir_plot,ext='.png',height=300,width=300);
Esempio n. 33
0
def script_doEverything(path_to_npy,path_to_im,ext,lim,out_file,out_dir_scratch,window,step_size,thresh,scale_info,scale_all, scale_images,lim_cases,gpu,model_file,clusters_file,train_val_file=None,overwrite=False):
    for scale in scale_all:
        # script_saveImCrops(path_to_npy,path_to_im,ext,lim,out_file,out_dir_scratch,window,step_size,thresh,scale_info,scale,scale_images,lim_cases)

        for scale_image in scale_images:
            dir_scale=os.path.join(out_dir_scratch,scale+'_'+str(scale_image));
            
            scale_info=pickle.load(open(out_file,'rb'));
            img_dirs=[os.path.join(dir_scale,im_curr_info[0]) for im_curr_info in scale_info[scale][:lim_cases]]
            
            for img_dir in img_dirs:
                img_paths=util.getFilesInFolder(img_dir,ext='.png');
                
                if len(img_paths)==0:
                    'CONTINUING'
                    continue;

                img_paths=[img_path for img_path in img_paths if not img_path.endswith('onImg.png')];
                out_dir_flo=img_dir+'_pred_flo';
                out_dir_flo_viz=img_dir+'_pred_flo_viz';
                util.mkdir(out_dir_flo);
                util.mkdir(out_dir_flo_viz);
                po.script_saveFlosAndViz(img_paths,out_dir_flo,out_dir_flo_viz,gpu,model_file,clusters_file,train_val_file=train_val_file,overwrite=overwrite)
                img_names=util.getFileNames(img_paths,ext=False);
                out_dir_flo=img_dir+'_pred_flo';
                out_dir_flo_viz=img_dir+'_pred_flo_viz';
                out_file_html=img_dir+'.html';

                
                img_paths_html=[];
                captions_all=[];
                for img_name in img_names:
                    row_curr=[];
                    row_curr.append(util.getRelPath(os.path.join(img_dir,img_name+'_onImg.png')));
                    row_curr.append(util.getRelPath(os.path.join(img_dir,img_name+'.png')));
                    row_curr.append(util.getRelPath(os.path.join(out_dir_flo_viz,img_name+'.png')));
                    captions=['','','']
                    img_paths_html.append(row_curr);
                    captions_all.append(captions);

                visualize.writeHTML(out_file_html,img_paths_html,captions_all);
def script_saveMatOverlapInfo():
    val_file='/disk2/januaryExperiments/pedro_data/coco-proposals/val.npy';
    val_data=np.load(val_file);
    print val_data.shape;
    print val_data[101,:];
    print 'hello';

    path_to_im='/disk2/ms_coco/val2014';
    path_to_gt='/disk2/mayExperiments/validation_anno';
    path_to_pred_us='/disk3/maheen_data/headC_160_noFlow_bbox/mat_overlaps_1000';

    im_pre='COCO_val2014_';
    im_ids=val_data[:,0];
    im_ids=np.unique(im_ids);
    im_ids=np.sort(im_ids);
    # im_ids=im_ids[:5000];
    print im_ids;

    im_files=[dp.addLeadingZeros(int(im_id),os.path.join(path_to_im,im_pre),'.jpg') for im_id in im_ids];
    im_names=util.getFileNames(im_files,ext=False);
    print im_names[0]
    out_dir='/disk3/maheen_data/pedro_val/mat_overlap'

    idx_count=0;
    problem=0;
    for im_id,im_name,im_file in zip(im_ids,im_names,im_files):
        print idx_count
        rel_rows=val_data[val_data[:,0]==im_id,:];
        assert np.unique(rel_rows[:,0]).size==1
        out_file=os.path.join(out_dir,im_name+'.npz');
        gt_file=os.path.join(path_to_gt,im_name+'.npy');
        comparison_file=os.path.join(path_to_pred_us,im_name+'.npz');

        if os.path.exists(gt_file) and os.path.exists(comparison_file):
            idx_count=idx_count+1;
            saveMatOverlapInfo(out_file,gt_file,rel_rows)
        else:
            problem=problem+1;

        if idx_count==5000:
            break;  
Esempio n. 35
0
def script_saveNonHumanOnlyNeg():
    neg_file='/disk2/marchExperiments/deep_proposals/negatives.txt';
    out_dir='/disk2/aprilExperiments/negatives_npy_onlyHuman'

    lines=util.readLinesFromFile(neg_file);
    npy_files=[line[line.index(' ')+1:] for line in lines];
    npy_file_names=util.getFileNames(npy_files);

    exists=0;
    for idx_npy_file_name,npy_file_name in enumerate(npy_file_names):
        if idx_npy_file_name%100==0:
            print idx_npy_file_name;

        file_curr=os.path.join(out_dir,npy_file_name);
        if os.path.exists(file_curr):
            exists+=1;
        else:
            zeros=np.zeros((0,4));
            np.save(file_curr,zeros);

    print exists,len(npy_file_names);
def reshapeFloFiles(flo_files,tif_files,out_dir_new_flos):
	for flo_file,tif_file in zip(flo_files,tif_files):
		# print flo_file
		flo=util.readFlowFile(flo_file);
		# print flo.shape
		tif=scipy.misc.imread(tif_file);
		# print tif.shape;

		flo_rs=cv2.resize(flo,(tif.shape[1],tif.shape[0]));
		# print flo_rs.shape

		flo_rs[:,:,0]=flo_rs[:,:,0]*(tif.shape[0]/float(flo.shape[0]));
		flo_rs[:,:,1]=flo_rs[:,:,1]*(tif.shape[1]/float(flo.shape[1]));
 		flo_rs=flo_rs*5;

 	# 	print np.min(flo_rs[:,:,0]),np.max(flo_rs[:,:,1])
		# print np.min(flo[:,:,0]),np.max(flo[:,:,1])

 		flo_name=util.getFileNames([flo_file],ext=True)[0];
 		# print flo_name
 		out_file_curr=os.path.join(out_dir_new_flos,flo_name);
 		util.writeFlowFile(flo_rs,out_file_curr);
Esempio n. 37
0
def saveBBoxImage(out_file, path_to_anno, out_dir_im, class_name='horse'):
    files = util.readLinesFromFile(out_file)
    just_names = util.getFileNames(files, ext=False)
    annotations = [
        os.path.join(path_to_anno, just_name + '.xml')
        for just_name in just_names
    ]

    print len(annotations)
    for im_file, anno, just_name in zip(files, annotations, just_names):

        out_file_pre = os.path.join(out_dir_im, just_name + '_')
        obj = untangle.parse(anno)

        for idx_object_curr, object_curr in enumerate(obj.annotation.object):
            if object_curr.name.cdata == class_name:
                out_file = out_file_pre + str(idx_object_curr) + '.jpg'
                # if os.path.exists(out_file):
                # 	continue;

                bnd_box = [
                    object_curr.bndbox.xmin.cdata,
                    object_curr.bndbox.ymin.cdata,
                    object_curr.bndbox.xmax.cdata,
                    object_curr.bndbox.ymax.cdata
                ]
                bnd_box = [int(coord) for coord in bnd_box]

                # print bnd_box;

                im = scipy.misc.imread(im_file)
                if len(im.shape) < 3:
                    crop = im[bnd_box[1]:bnd_box[3], bnd_box[0]:bnd_box[2]]
                else:
                    crop = im[bnd_box[1]:bnd_box[3], bnd_box[0]:bnd_box[2], :]

                print out_file
                scipy.misc.imsave(out_file, crop)
Esempio n. 38
0
def main():
    # print 'hello';
    train_val_txt = '/Users/maheenrashid/Dropbox (Personal)/Davis_docs/Research/VOCdevkit 2/VOC2012/ImageSets/Main/horse_trainval.txt'
    path_to_im = '/Users/maheenrashid/Dropbox (Personal)/Davis_docs/Research/VOCdevkit 2/VOC2012/JPEGImages'
    path_to_anno = '/Users/maheenrashid/Dropbox (Personal)/Davis_docs/Research/VOCdevkit 2/VOC2012/Annotations'

    out_dir = '../pascal'
    util.mkdir(out_dir)

    out_file = os.path.join(out_dir, 'horse.txt')

    out_dir_im = '../pascal/just_horse_im'
    util.mkdir(out_dir_im)

    # saveBBoxImage(out_file,path_to_anno,out_dir_im)
    im_files = util.getFilesInFolder(out_dir_im, ext='.jpg')
    file_names = util.getFileNames(im_files, ext=True)
    batch_size = 20

    batch_idx = util.getIdxRange(len(file_names), batch_size)
    print len(batch_idx)
    args = []
    counter = 0
    for idx_batch_start, batch_start in enumerate(batch_idx[:-1]):
        batch_end = batch_idx[idx_batch_start + 1]
        im_files_rel = im_files[batch_start:batch_end]
        file_names_rel = file_names[batch_start:batch_end]
        out_dir_curr = os.path.join(out_dir_im, str(idx_batch_start))
        util.mkdir(out_dir_curr)
        for file_name, im_file_curr in zip(file_names_rel, im_files_rel):
            out_file = os.path.join(out_dir_curr, file_name)
            if not os.path.exists(out_file):
                args.append((im_file_curr, out_file, counter))
                counter += 1

    p = multiprocessing.Pool(multiprocessing.cpu_count())
    print len(args)
    p.map(copyfile_wrapper, args)
Esempio n. 39
0
def insert(insertFile,
           insertDir,
           newFile,
           cwd,
           header,
           keywords=[],
           sort=False):
    fileNames = util.getFileNames(insertDir, cwd, keywords)
    if sort:
        fileNames = sorted(fileNames,
                           key=lambda filename: os.stat(filename).st_ctime)
    insertFile = util.find(insertFile, util.find(cwd, util.root))
    insertions = ""
    for fileName in fileNames:
        w = open(fileName, 'r')
        insertions += w.read() + "\n"
        w.close()
    w = open(insertFile, 'r')
    t = w.read().replace(header, insertions)
    insertFile = insertFile.replace(
        getInsertFileDir.findall(insertFile)[-1], '')
    w = open(os.path.join(insertFile, newFile), 'w')
    print >> w, t
    w.close()
Esempio n. 40
0
def writeImport(importDir, cwd, fileName, keywords = []):
    fileNames = util.getFileNames(importDir, cwd, keywords)
    w = open(os.path.join(SCRIPTS_DIR, fileName), 'w')
    for fileName in fileNames:
        print>>w, IMPORT_HEADER + '"' + fileName + '"'
    w.close()