import image_slicer import os # image_slicer.slice('CarPlateFull/31.jpg', 50) # to crop all image in the directory into smaller images subdirs = [x[0] for x in os.walk("CarPlateFull")] for subdir in subdirs: files = os.walk(subdir).next()[2] if (len(files) > 0): for file in files: print file tiles = image_slicer.slice("CarPlateFull/"+file, 50, save=False) image_slicer.save_tiles(tiles, directory='CarPlateFull/Tiled', prefix=file)
def test_all_files_saved(self): save_tiles(self.tiles, prefix="x", directory=TEST_DIR, format="gif") self.assertEqual( sorted(os.listdir(TEST_DIR)), [ "x_01_01.gif", "x_01_02.gif", "x_01_03.gif", "x_01_04.gif", "x_01_05.gif", "x_02_01.gif", "x_02_02.gif", "x_02_03.gif", "x_02_04.gif", "x_02_05.gif", "x_03_01.gif", "x_03_02.gif", "x_03_03.gif", "x_03_04.gif", "x_03_05.gif", "x_04_01.gif", "x_04_02.gif", "x_04_03.gif", "x_04_04.gif", "x_04_05.gif", ], )
def getSlicedFeatures(path, name): size = 0 if name == "ts": size = 144 elif name == "ts1": size = 48 elif name == "ts2": size = 57 elif name == "ts3": size = 39 elif name == "tr": size = 264 elif name == "tr1": size = 88 elif name == "tr2": size = 88 elif name == "tr3": size = 88 curr_dir = os.getcwd() folder_path = path + "/" save_path = curr_dir + "/dataset2/sliced/" N = 4 dataset_sub = np.zeros(size * 6).reshape((size, 6)) i = 0 for filename in os.listdir(folder_path): print("filename is: " + filename) tiles = image_slicer.slice(folder_path + filename, N, save=False) image_slicer.save_tiles(tiles, directory=save_path) dataset_sub[i] = getFeatures("sub", name) return dataset_sub
def call_game(ia_final_move, squareside, allcase, gamemode, fenetre): tiles = image_slicer.slice("/Users/gkuma/Downloads/photo_" + str(squareside * 100) + "_.jpg", squareside * squareside, save=False) image_slicer.save_tiles(tiles, directory='/Users/gkuma/Downloads/', prefix='') replay = 1 while (replay == 1): blocks = [] blocks = utils.build_board(allcase, squareside, blocks, fenetre) fond = pygame.image.load("/Users/gkuma/Downloads/background.jpg") fenetre.blit(fond, (0, 0)) first_draw(squareside, fenetre, blocks, gamemode) pygame.display.flip() if gamemode == 'ia': main_loop(ia_final_move, squareside, fenetre, blocks, fond) if gamemode == 'solo': main_loop_solo(squareside, fenetre, blocks, fond) pygame.time.wait(3000) menu_items = ('Replay', 'MainMenu', 'Quit') pygame.display.set_caption('Replay') replay_menu = ReplayMenu(fenetre, menu_items) # return the choice enter in the menu replay = replay_menu.run() if replay == 2: replay = 1 return replay
def sliceImages(foldername, image_name): directory = root + "\\" + foldername + "\\" os.makedirs(directory) image_tiles = image_slicer.slice(image_name, 50, save=False) image_slicer.save_tiles(image_tiles, directory=directory, prefix=image_name)
def uploader(): if request.method == 'POST': f = request.files['file'] #files = glob.glob('/Users/liule/att/lei-connector-cooler/test/*') #for f in files: #os.remove(f) #f.save(secure_filename(f.filename)) #shutil.rmtree('/Users/liule/att/lei-connector-cooler/test') #os.mkdir('/Users/liule/att/lei-connector-cooler/test') f.save( os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f.filename))) for root, dirs, files in os.walk( "/Users/liule/att/lei-connector-cooler/test"): for filename in files: print(filename) tiles = image_slicer.slice( '/Users/liule/att/lei-connector-cooler/test/' + filename, 4, save=False) image_slicer.save_tiles( tiles, directory='/Users/liule/att/lei-connector-cooler/test', prefix='slice' + filename) os.remove("/Users/liule/att/lei-connector-cooler/test/" + secure_filename(f.filename)) IMAGE = "/Users/liule/att/lei-connector-cooler/test" # if 'Image' in req_data: # IMAGE = req_data['Image'] #print(request.headers) #data_headers = {'Content-type': 'application/json', 'Accept': 'text/plain'} # create slice files here return render_template('/pages/connector_cooler.html')
def slicing_of_image(dimensions, desired_size, image_path, resized_path, sliced_path, image_type): #Calculation to equally slice up the image to the desired size number = dimensions[0] / desired_size x = math.log(number, 2) if dimensions[0] == desired_size: split = 2 else: split = 2**(x * 2) for file in glob.glob(image_path + "/*" + image_type): imageName = file.split('\\')[6][ 0: -4] #Change the values in regards to the position of the directory img = cv2.imread(file, -1) img = cv2.resize(img, dimensions, interpolation=cv2.INTER_AREA) os.chdir(resized_path) cv2.imwrite(imageName + image_type, img) for file in glob.glob(resized_path + "/*" + image_type): imageName = file.split('\\')[6][ 0: -4] #Change the values in regards to the position of the directory tiles = image_slicer.slice(file, split, save=False) image_slicer.save_tiles(tiles, directory=sliced_path, prefix=imageName, format=image_type[1:])
def slice_and_save(s_dir, t_dir, v_dir, n, m): # t_dir holds unsliced images, s_dir will contain sliced images, n is number of tiles for sd in get_subdirs(s_dir): print "SUB DIR: {}".format(sd) # Create sub-directories if they do not already exist if not os.path.exists(os.path.join(v_dir, sd)): os.makedirs(os.path.join(v_dir, sd)) if not os.path.exists(os.path.join(t_dir, sd)): os.makedirs(os.path.join(t_dir, sd)) # Iterate through all images and labels, slice, and save into t_dir, and v_dir for i, f in enumerate(get_file_names(os.path.join(s_dir, sd))): if i % m == 0: # save to v_dir/sd/ tiles = slice(f, n, save=False) save_tiles(tiles, prefix=get_basename(f), directory=os.path.join(v_dir, sd)) print "{} sliced and saved to {}".format( f, os.path.join(v_dir, sd)) else: # save to t_dir/sd/ tiles = slice(f, n, save=False) save_tiles(tiles, prefix=get_basename(f), directory=os.path.join(t_dir, sd)) print "{} sliced and saved to {}".format( f, os.path.join(t_dir, sd)) print "============================"
def slice(self, portions): self.img_dir_path = self.slides_dir + "/image_2048" self.label_dir_path = self.slides_dir + "/label_2048" self.sliced_img_path = self.slides_dir + "/image_1024" self.sliced_lbl_path = self.slides_dir + "/label_1024" for filename in os.listdir(self.img_dir_path): file_path = self.img_dir_path + '/' + filename tiles = image_slicer.slice(file_path, portions, save=False) filename_no_sufix = filename[:-4] # slice_name = staining + '_' + filename_no_sufix + '_Mask' image_slicer.save_tiles(tiles, directory=self.sliced_img_path, prefix=filename_no_sufix, format='PNG') portion_name = filename[-9:-4] mask_file_path = self.label_dir_path + "/" + filename #[:-4] + "-labelled.png" # ipdb.set_trace() # mask_file_path_to_save = test_labels_1024_path + '/' + filename_no_sufix + '.png' tiles = image_slicer.slice(mask_file_path, portions, save=False) image_slicer.save_tiles(tiles, directory=self.sliced_lbl_path, prefix=filename_no_sufix, format='PNG')
def slice_img(orig_img, img_name, path_img_rot, angle, control): if control == 0: pos_x = 0 pos_y = 0 img_rot = cv.imread(os.path.join(path_img_rot + r'/' + img_name)) cv.imwrite(os.path.join(path_tiles, img_name), img_rot) orig_img = detect_face_cnn(orig_img, img_name, angle, pos_x, pos_y) orig_img.save(path_output + r'/' + img_name) # cv.imwrite(os.path.join(path_output, img_name), orig_img) else: tiles = image_slicer.slice(path_img_rot + r'/' + img_name, 2, save=False) image_slicer.save_tiles(tiles, directory=path_tiles, prefix='slice') slice_name = 'slice_01_01.png' pos_x = tiles[0].coords[0] pos_y = tiles[0].coords[1] orig_img = detect_face_cnn(orig_img, slice_name, angle, pos_x, pos_y) slice_name = 'slice_01_02.png' pos_x = tiles[1].coords[0] pos_y = tiles[1].coords[1] orig_img = detect_face_cnn(orig_img, slice_name, angle, pos_x, pos_y) orig_img.save(path_output + r'/' + img_name) tiles[0].image = Image.open(path_tiles + r'/' + 'slice_01_01.png') tiles[1].image = Image.open(path_tiles + r'/' + 'slice_01_02.png') image = image_slicer.join(tiles) image.save(path_result + r'/' + str(angle) + '_' + img_name)
def home(request): if request.method == 'POST' and request.FILES['myfile']: myfile = request.FILES['myfile'] fs = FileSystemStorage() filename = fs.save(myfile.name, myfile) uploaded_file_url = fs.path(filename) tiles = image_slicer.slice(uploaded_file_url, 9, save=False) image_slicer.save_tiles(tiles, directory='media/', prefix='slice', format='png') os.remove(uploaded_file_url) z = zipstream.ZipFile(mode='w', compression=zipstream.ZIP_DEFLATED) z.write('media/slice_01_01.png', 'slice_01_01.png') z.write('media/slice_01_02.png', 'slice_01_02.png') z.write('media/slice_01_03.png', 'slice_01_03.png') z.write('media/slice_02_01.png', 'slice_02_01.png') z.write('media/slice_02_02.png', 'slice_02_02.png') z.write('media/slice_02_03.png', 'slice_02_03.png') z.write('media/slice_03_01.png', 'slice_03_01.png') z.write('media/slice_03_02.png', 'slice_03_02.png') z.write('media/slice_03_03.png', 'slice_03_03.png') response = StreamingHttpResponse(z, content_type='application/zip') response['Content-Disposition'] = 'attachment; filename={}'.format( 'files.zip') return response return render(request, 'core/simple_upload.html')
def preparation_of_image(dimensions, desired_size, image_path, resized_path, sliced_path, image_type, predicted_path, recombined_path, threshold): segmentation_model = tf.keras.models.load_model( "Model/UNetW.h5") #Loading UNet Model #To determine how many portions to split to achieve desired size number = dimensions[0] / desired_size x = math.log(number, 2) if dimensions[0] == desired_size: split = 2 else: split = 2**(x * 2) imageName = os.path.basename( os.path.normpath(image_path) )[:-4] #Getting the test image name from the test image path img = cv2.imread( image_path + image_type, cv2.IMREAD_GRAYSCALE) #Reading the test image in grayscale img = cv2.resize(img, dimensions, interpolation=cv2.INTER_AREA ) #Resizing the test image into the correct size os.chdir( resized_path) #Changing the directory for the test image to be saved cv2.imwrite(imageName + image_type, img) #Saving the test image tiles = image_slicer.slice((resized_path + "/" + imageName + image_type), split, save=False) #Slicing the test image up image_slicer.save_tiles( tiles, directory=sliced_path, prefix=imageName, format=image_type[1:] ) #Saving the sliced test images into the next folder for file in glob.glob(sliced_path + "/*" + image_type): img = cv2.imread( file, cv2.IMREAD_GRAYSCALE) #Reading the sliced image into an array base_name = os.path.basename( os.path.normpath(file)) #Getting image names img = np.expand_dims(img, -1) #Expanding dimensions img = np.expand_dims(img, 0) #Expanding dimensions img = img / 255.0 #Normalising values predicted_image = segmentation_model.predict( img) #Predicting the image predicted_image = predicted_image[ 0, :, :, 0] #Removing the dimensions to (256,256) predicted_image = predicted_image > threshold #Setting the threshold to filter out the noise ~ recommended is 0.99 predicted_image = predicted_image * 255 #Reverse normalising to get exact shades of colour os.chdir(predicted_path) #Changing directory for it to be saved cv2.imwrite(base_name, predicted_image) #Saving predicted image newtiles = image_slicer.open_images_in( 'D:/Project/FYP/Data For Gavin/Inserts/Results/.' ) #Opening image in tiled predicted images imageAll = image_slicer.join(newtiles) #Joining the images together imageAll.save('D:/Project/FYP/Data For Gavin/Inserts/Results/' + imageName + '.png') #Saving the combined image together return imageName
def slice_jpeg(jpeg_img, num_slices, jpeg_slices_folder, slice_name): tiles = image_slicer.slice( jpeg_img, num_slices, save=False) image_slicer.save_tiles(tiles, directory=jpeg_slices_folder, prefix=slice_name, format='jpeg') return
def _shatter(impath, savedir, k): im = Image.open(impath) basename = os.path.basename(impath)[:-4] try: tiles = image_slicer.slice(impath, k, save=False) image_slicer.save_tiles(tiles, directory=savedir, prefix=basename) except Exception as e: print(e)
def slice(number, IMAGE, location): ''' called by startPredicting() slice image to (number param) slices and add to the slices folder (location param) name of each slice is the coordinates of the slice based on the IMAGE ''' print("slicing...") tiles = image_slicer.slice(IMAGE, number, save=False) image_slicer.save_tiles(tiles, directory=location, prefix='slice')
def openCV(raw_img): link = "C:/Users/no1do/Desktop/daramg/" tiles = image_slicer.slice(str(link) + 'Rasp/' + raw_img, 4, save=False) image_slicer.save_tiles(tiles, directory=str(link) + 'split/', prefix=raw_img[:-4]) s = os.path.splitext(raw_img) s = os.path.split(s[0]) link = 'C:/Users/no1do/Desktop/daramg/split/' img_list = [ str(link) + s[1] + '_01_01.png', str(link) + s[1] + '_01_02.png', str(link) + s[1] + '_02_01.png', str(link) + s[1] + '_02_02.png' ] # 경로값 ìˆ˜ì • result = [] for i in img_list: img = cv2.imread(i) img = cv2.resize(img, None, fx=0.4, fy=0.4) height, width, channels = img.shape blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True, crop=False) net.setInput(blob) outs = net.forward(output_layers) class_ids = [] confidences = [] boxes = [] for out in outs: for detection in out: scores = detection[5:] class_id = np.argmax(scores) confidence = scores[class_id] if confidence > 0.5: # Object detected center_x = int(detection[0] * width) center_y = int(detection[1] * height) w = int(detection[2] * width) h = int(detection[3] * height) # Rectangle coordinates x = int(center_x - w / 2) y = int(center_y - h / 2) boxes.append([x, y, w, h]) confidences.append(float(confidence)) class_ids.append(class_id) if 0 in class_ids: result.append(1) else: result.append(0) return result
def slicing(img_path, save_path, no_of_slices): # slicing the binary mask images into 49 slices(7*7) using image_slicer tiles = image_slicer.slice(img_path, no_of_slices, save=False) # saving the sliced images of binary mask in the respective folders image_slicer.save_tiles(tiles, directory=save_path, prefix='slice', format="jpeg") return tiles
def slice_img(path_img): # Variaveis qtd_slices = 64 #8x8 #Criar o diretorio caso nao exista dir = cria_diretorio() # Dividir a imagem em 64 partes tiles = image_slicer.slice(path_img, qtd_slices, save=False) image_slicer.save_tiles(tiles, directory=dir, format='JPEG')
def slice_screenshot(screen): dim = 175 y, x = 714, 15 crop = screen[y:y+6*dim, x:x+6*dim] cv2.imwrite('board.png', crop) tiles = image_slicer.slice('board.png', 36, save=False) image_slicer.save_tiles(tiles, directory=PATH_SLICES) slices_dir = os.listdir(PATH_SLICES) return slices_dir
def slicer(): directory_in_str = '/Users/travis.howe/Desktop/rc/vocab_images' for file in os.listdir(directory_in_str): tiles = image_slicer.slice('{0}/{1}'.format(directory_in_str, file), 8, save=False) image_slicer.save_tiles( tiles, directory='{0}_sliced'.format(directory_in_str), prefix=file)
def sliceup(): for picture in directory: newFolderName = os.path.splitext(picture)[0] folderpath = outpath + "/" + newFolderName inputpath = startpath + "/" + picture outputpath = folderpath tiles = image_slicer.slice(inputpath, 256, save=False) image_slicer.save_tiles(tiles, directory=outputpath, prefix='slice', format='png')
def save_pictures(tiles, save_path): try: os.mkdir(save_path) except: print("Folder is already exists") save_path = "%s/" % save_path # print(save_path) image_slicer.save_tiles(tiles, directory=save_path, prefix='slice') return save_path
def split_images(images_folder, cls, num_splits): os.mkdir(os.path.join(images_folder, 'split_' + cls)) for directory, subdirectories, files in os.walk( os.path.join(images_folder, cls)): for file in files: file_name = os.path.join(images_folder, cls, file) tiles = image_slicer.slice(file_name, int(num_splits), save=False) image_slicer.save_tiles(tiles, directory=os.path.join( images_folder, 'split_' + cls), prefix=get_basename(file_name))
def image_splitter(solved_jigsaw_image, unsolved_jigsaw_image, n_pieces, save=False): tiles = image_slicer.slice(solved_jigsaw_image, n_pieces, save=False) if save is True: new_directory = PATH + unsolved_jigsaw_image[:-4] if not os.path.exists(new_directory): os.mkdir(new_directory) image_slicer.save_tiles(tiles, directory=new_directory, prefix='slice', format='png') return tiles
def split_image_directory(directory, number_of_tiles, Package_dir): for dirpath, _, filenames in os.walk(directory): for f in filenames: abspath = os.path.abspath(os.path.join(dirpath, f)) if f != ".DS_Store": tiles = image_slicer.slice(abspath, number_of_tiles, save=False) image_slicer.save_tiles(tiles, directory=Package_dir + "/tile_images", prefix=f.split('.')[0]) print("image ", f, " processed")
def startCutting(startpath, outpath, gridoutpath, directory, outputs): for file in directory: if not file.startswith('.'): newFolderName = os.path.splitext(file)[0] folderpath = outpath + "/" + newFolderName inputpath = startpath + "/" + file outputpath = folderpath tiles = image_slicer.slice(inputpath, 1024, save=False) image_slicer.save_tiles(tiles, directory=outputpath, prefix='slice', format='png') print("cut")
def cut_frames(PATH_FRAMES, PATH_FRAMES_PIECES): """ This function cuts a frame in 6 """ count = 0 # nframe = 0 for foto in glob.glob(PATH_FRAMES + "*.jpg"): frames = image_slicer.slice(foto, 6, save=False) image_slicer.save_tiles(frames, directory=PATH_FRAMES_PIECES, prefix='slice' + str(count)) count += 1 return True
def slice_img(indir_slicing, train_path, n_tiles, test_path, perc_test): ''' Split images in n tiles. Default is 4. Supports .png and .jpg files ''' for root, dirs, filenames in os.walk(indir_slicing): for file in filenames: if file.endswith('.png') or file.endswith('.jpg'): tiles = image_slicer.slice(os.path.join(indir_slicing, file), n_tiles, save=False) image_slicer.save_tiles(tiles, directory=train_path, prefix=file)
def startCutting(): for picture in directory: newFolderName = os.path.splitext(picture)[0] folderpath = outpath + "/" + newFolderName os.mkdir(folderpath) inputpath = startpath + "/" + picture outputpath = folderpath print(inputpath) print(outpath) tiles = image_slicer.slice(inputpath, 256, save=False) image_slicer.save_tiles(tiles, directory=outputpath, prefix='slice', format='png') print("words")
def slice(path): clsLabels = np.array(['etyn', 'etym', 'etyo']) import glob for i in range(0, len(clsLabels)): filesCls = glob.glob(path + '/*/*' + clsLabels[i] + ".jpg") for k in range(0, len(filesCls)): tiles = image_slicer.slice(filesCls[k], 25, save=False) image_slicer.save_tiles( tiles, directory=r'C:\Users\covac\Desktop\img\All_tiles_in1', prefix=filesCls[k], format='jpeg') import shutil shutil.move( filesCls[k], r'C:\Users\covac\Desktop\img\All_pics_1' + os.path.basename(filesCls[k]))
def SplitImage(img, N): #creates tiles from image given #image is split into equally sized tiles tiles = image_slicer.slice(img, N, save=False) #saves files in directory image_slicer.save_tiles(tiles, directory=mypath, prefix='slices') #stores a list of sorted tiles in variable 'onlyfiles' with file extension '.png' tile_img = [ f for f in listdir(mypath) if isfile(join(mypath, f)) if f.startswith('slices') if f.endswith(".png") ] tile_img.sort() rgbtiles = most_frequent_color(tile_img) rgbimg = ResizeImg(tile_img[0]) # a list of tuples containging rgb values are stored in variable 'rgbimg' #returns a list of rgb values in tuples return rgbtiles, rgbimg
def slice_folder(self, input_path): """ This function should be called with a path to a folder as argument. It will extract images from the folder with NO recursivity and will slice them if the weight is > to the height. :param input_path: path/to/folder/bigImage.jpg output = path/to/folder_sliced/bigImage-0_01_01.jpg path/to/folder_sliced/bigImage-0_01_02.jpg """ print("Parsing folder: " + input_path) if input_path[-1] == self.sep: path_out = input_path[:-1] + suffix_sliced else: path_out = input_path + suffix_sliced try: os.mkdir(path_out) except OSError: pass for files in sorted(os.listdir(input_path)): ext = files[-3:].lower() if ext in images: file_to_add = os.path.join(input_path, files) im = Image.open(file_to_add) (w, h) = im.size if w > h: if self.verbose: # Note: If verbose print(" Slicing ", file_to_add, str(w) + "x" + str(h)) tiles = image_slicer.slice(file_to_add, 2, save=False) size_tile = len(tiles) if self.reverse: # If it's a manga, then the first page is the right page for a in tiles: pos_tile = a.position a.position = (size_tile, pos_tile[1]) size_tile -= 1 image_slicer.save_tiles(tiles, directory=path_out, prefix=files[:-4], format='jpg') else: shutil.copy(file_to_add, path_out) return path_out
sample_size = int(round( len(slicedf) * 0.01 )) slicedf = slicedf.sample(n=sample_size) idxlist = list(slicedf.sliceidx.unique()) tmp = tmp.loc[idxlist,:] for u in tmp.index: path = tmp.local_path.loc[u] slices = list(slicedf.slicenum[slicedf.sliceidx==u]) nslice = tmp.nslice.loc[u] try: tiles = image_slicer.slice(path,nslice,save=False) tile_subset = tuple(tiles[v] for v in slices) image_slicer.save_tiles(tile_subset, directory=SLICEDIR, prefix=str(u)) except Exception as e: print(e) print(i,yr,"slice",u,"of",len(tmp)) actslicedf = pd.DataFrame() actslice_paths = glob.glob(os.path.join(SLICEDIR,"*.png")) actslicedf['local_path'] = [item for item in actslice_paths] actslicedf['basename'] = actslicedf.local_path.apply(os.path.basename) actslicedf['idx'] = [int(item.split("_")[0]) for item in actslicedf.basename] tmp = tmp[['secpast']] tmp['idx'] = tmp.index tmp.set_index("idx",inplace=True)
infile = "/data/damoncrockett/downtown_SD_Flickr/data/all_image_exists.csv" num_slices = 2048 df = pd.read_csv(infile) df = df.sample(n=16384) # Okay this is hacky...I don't care. Science awaits. BASE_DIR = "/data/damoncrockett/downtown_SD_Flickr/images_sliced_" counter=-1 for file in df.local_folder: counter +=1 print counter try: tiles = image_slicer.slice(file,num_slices,save=False) if counter > 12000: ext = "4/" elif counter > 8000: ext = "3/" elif counter > 4000: ext = "2/" else: ext = "1/" image_slicer.save_tiles(tiles, directory=BASE_DIR+ext, prefix=str(counter)) except: print 'err'
import image_slicer from PIL import Image from PIL import ImageDraw, ImageFont play = 0 score = 4 while play == 0: tiles = image_slicer.slice(input('Enter File Name:'), 4, save=False) for tile in tiles: overlay = ImageDraw.Draw(tile.image) image_slicer.save_tiles(tiles) image1 = Image.open('C:\\Users\\Michael\\Documents\\205Project2\\Project2\\_02_02.png') image2 = Image.open('C:\\Users\\Michael\\Documents\\205Project2\\Project2\\_02_01.png') image3 = Image.open('C:\\Users\\Michael\\Documents\\205Project2\\Project2\\_01_02.png') image4 = Image.open('C:\\Users\\Michael\\Documents\\205Project2\\Project2\\_01_01.png') width,height = image1.size width = (width * 2) + 20 height = (height * 2) + 20 jigsaw = Image.new('RGB',(width,height)) width,height = image1.size jigsaw.paste(image1,(0,0)) jigsaw.paste(image2,(width + 10,0)) jigsaw.paste(image3,(0,height + 10)) jigsaw.paste(image4,(width + 10, height + 10))
import image_slicer import pandas as pd import os import sys infile = sys.argv[1] num_slices = int(sys.argv[2]) target = sys.argv[3] df = pd.read_csv(infile) # option to sample df = df.sample(n=360) df.reset_index(drop=True,inplace=True) n = len(df.index) for i in range(n): try: file = df.filename.loc[i] tiles = image_slicer.slice(file,num_slices,save=False) image_slicer.save_tiles(tiles,directory=target,prefix=os.path.basename(file)) print i except: print 'err'
TILEPATH = './static/images/tiles/' TARGETFILE = 'brain.png' NTILES = 16 # first delete all the files in the static/images/tiles folder files = os.listdir(TILEPATH) for myfile in files: if myfile != 'placeholder.txt': print "removing existing file", TILEPATH+myfile os.remove(TILEPATH+myfile) # query existing pixels Pixels.query.delete() # create the tiles using the target image tiles = image_slicer.slice(TARGETFILE, NTILES, save=False) image_slicer.save_tiles(tiles, prefix='tile', directory='static/images/tiles', format='png') # add tiles to database for tile in tiles: pixel_width, pixel_height = tile.image.size print "dimensions:", (pixel_width, pixel_height) , "filename:", tile.filename pixel_attributes = dict(filename = tile.filename, n_completed = 0, width = pixel_width, height = pixel_height) pixel = Pixels(**pixel_attributes) db_session.add(pixel) db_session.commit()
import image_slicer import glob import os import sys input_file = "/Users/damoncrockett/Desktop/encanto_4096.tif" num_slices = float(sys.argv[1]) target = "/Users/damoncrockett/Desktop/enc/slices/" # don't need informative filenames at this stage tiles = image_slicer.slice(input_file,num_slices,save=False) image_slicer.save_tiles(tiles,directory=target) new_target = "/Users/damoncrockett/Desktop/enc/slices_of_slices/" # can adjust num_slices if need be counter=-1 for file in glob.glob(os.path.join(target,'*.png')): counter +=1 print counter try: tiles = image_slicer.slice(file,num_slices,save=False) image_slicer.save_tiles(tiles, directory=new_target, prefix=str(counter)) except: print 'err'