def read_wsi_mask(self, wsi_path, mask_path): try: self.cur_wsi_path = wsi_path self.wsi_image = OpenSlide(wsi_path) self.mask_image = OpenSlide(mask_path) self.level_used = min(self.def_level, self.wsi_image.level_count - 1, self.mask_image.level_count - 1) self.mask_pil = self.mask_image.read_region( (0, 0), self.level_used, self.mask_image.level_dimensions[self.level_used]) self.mask = np.array(self.mask_pil) except OpenSlideUnsupportedFormatError: print('Exception: OpenSlideUnsupportedFormatError') return False return True
def read_wsi_tumor(wsi_tumor_path, wsi_mask_path, resolution_level=None): try: wsi_tumor = OpenSlide(wsi_tumor_path) if resolution_level is None: resolution_level = wsi_tumor.level_count - 1 wsi_tumor_sample = wsi_tumor.read_region( (0, 0), resolution_level, wsi_tumor.level_dimensions[resolution_level]) wsi_tumor.close() wsi_tumor_mask = OpenSlide(wsi_mask_path) wsi_tumor_mask_sample = wsi_tumor_mask.read_region( (0, 0), resolution_level, wsi_tumor_mask.level_dimensions[resolution_level]) wsi_tumor_mask.close() except Exception as e: return None, None return wsi_tumor_sample, wsi_tumor_mask_sample
def get_label(path): """ gets the label image of a wsi using openslide :param path str: path to the wsi returns pil image of label or 1 for fail """ try: image = OpenSlide(path) # open svs image return image.associated_images["label"] except KeyError as e: return 1
def __init__(self, image_path): super(Slide, self).__init__() self.image_path = image_path.strip() self.image_file = os.path.basename(image_path) self.image_name, self.suffix = self.image_file.split('.') if not self.suffix in config.format_mapping.keys(): raise Exception('Error: File format ' + self.suffix + ' is supported yet.') self._slide = OpenSlide(image_path) self._level_downsamples = self._slide.level_downsamples self._level_dimensions = self._slide.level_dimensions self.width, self.height = self._level_dimensions[0]
def sample_tumor_coord(self, coords_path: str, wsi_path: str, mask_path: str, annot_path: str, wsi_level: int = 0): '''Sample a center coordinate of a normal patch from - Args coords_path: Path to the pre-sampled tumor coordinates wsi_path: Path to the wsi mask_path: Path to the binary mask of wsi annot_path: Path to the annotations directory wsi_level: Level of the given wsi - Returns A center coordinate of tumor patch; tuple of int ''' # If the cache of tumor coordinates(tumor_coords.json) does not exist if not os.path.exists(coords_path): slide = OpenSlide(wsi_path) slide_width, slide_height = slide.level_dimensions[wsi_level] roi_mask = np.load(mask_path) roi_mask_width, roi_mask_height = roi_mask.shape assert (slide_width // roi_mask_width) == (slide_height // roi_mask_height), \ f'Dimension does not match: slide_width({slide_width})//mask_width({roi_mask_width}) != \ slide_height({slide_height})//mask_height({roi_mask_height})' resolution = slide_width // roi_mask_width roi_x_coords, roi_y_coords = np.where(roi_mask) roi_coords = zip(roi_x_coords, roi_y_coords) roi_coords = list(roi_coords) roi_coords = [ self.scale_coord(coord, resolution) for coord in roi_coords ] roi_coords = np.array(roi_coords) lesion_annots = LesionAnnotations(annot_path) tumor_coords = lesion_annots.filter_tumor_coords(coords_path, roi_coords, is_pos=True) # If the cache of tumor coordinates(tumor_coords.json) exists else: with open(coords_path, 'r', encoding='utf-8') as f: tumor_coords_dict = json.load(f) tumor_coords = tumor_coords_dict['tumor_coords'] picked_tumor_coord = random.choice(tumor_coords) return picked_tumor_coord
def tile(image_file, outdir, level, std_img, path_to_slide=str(cwd+"/../images/"), dp=None, ft=1): slide = OpenSlide(path_to_slide+image_file) slp = str(path_to_slide+image_file) print(slp) print(slide.level_dimensions) bounds_width = slide.level_dimensions[level][0] bounds_height = slide.level_dimensions[level][1] x = 0 y = 0 half_width_region = 49*ft full_width_region = 299*ft stepsize = (full_width_region - half_width_region) n_x = int((bounds_width - 1) / stepsize) n_y = int((bounds_height - 1) / stepsize) lowres = slide.read_region((x, y), level+1, (int(n_x*stepsize/4), int(n_y*stepsize/4))) lowres = np.array(lowres)[:,:,:3] x0 = 0 # create multiporcessing pool print(mp.cpu_count()) pool = mp.Pool(processes=mp.cpu_count()) tasks = [] while x0 < n_x: task = tuple((slp, n_y, x, y, full_width_region, stepsize, x0, outdir, level, dp, std_img)) tasks.append(task) x0 += 1 # slice images with multiprocessing temp = pool.starmap(v_slide, tasks) tempdict = list(temp) temp = None pool.close() pool.join() tempdict = list(filter(None, tempdict)) imloc = [] list(map(imloc.extend, tempdict)) imlocpd = pd.DataFrame(imloc, columns = ["X_pos", "Y_pos", "X", "Y", "Loc"]) imlocpd = imlocpd.sort_values(["X_pos", "Y_pos"], ascending=[True, True]) imlocpd = imlocpd.reset_index(drop=True) imlocpd = imlocpd.reset_index(drop=False) imlocpd.columns = ["Num", "X_pos", "Y_pos", "X", "Y", "Loc"] if dp: imlocpd.to_csv(outdir + "/{}_dict.csv".format(dp), index=False) else: imlocpd.to_csv(outdir + "/dict.csv", index=False) tempdict = None ct = len(imloc) print(ct) return n_x, n_y, lowres, ct
def get_slide(fn_slide): if not exists(fn_slide): print('This file does NOT exist. Check the path : ' + fn_slide) slide = None return slide try: slide = OpenSlide(fn_slide) except: print('Can NOT open this slide with OpenSlide : ' + fn_slide) print('I do not know why. Just can not read !!') slide = None return slide
def process(opts): i, pid, x_center, y_center, file_path_tif, path_patch, patch_size, patch_level = opts x = int(int(float(x_center)) - 1024 / 2) y = int(int(float(y_center)) - 1024 / 2) wsi_path = os.path.join(file_path_tif + pid + '.svs') slide = OpenSlide(wsi_path) img = slide.read_region((x, y), 0, (1024, 1024)).convert('RGB') if not os.path.exists(os.path.join(path_patch, pid + "_" + str(i) + '.png')): print(os.path.join(path_patch, pid + "_" + str(i) + '.png')) img.save(os.path.join(path_patch, pid + "_" + str(i) + '.png'))
def load_image(fn, mode=None): "Open and load a `PIL.Image` and convert to `mode`" wsi_name, x, y, level, crop_size = fn.split(',') x=int(x); y=int(y); level=int(level); crop_size=int(crop_size) im = OpenSlide(wsi_name[2:]).read_region((x, y), level, (crop_size, crop_size)) im = im._new(im.im) return im.convert(mode) if mode else im
def read_wsi_mask(mask_path, level=def_level): try: wsi_mask = OpenSlide(mask_path) mask_image = np.array(wsi_mask.read_region((0, 0), level, wsi_mask.level_dimensions[level])) except OpenSlideUnsupportedFormatError: print('Exception: OpenSlideUnsupportedFormatError') return None, None return wsi_mask, mask_image
def get_thumbnails(): import os from openslide import OpenSlide data_dir = '/media/hui/Local Disk1/work/Data/Liver_Multi_Modality/Pathology/SlideImages/20-1018 PURU_VINOD' save_dir = '/media/hui/Local Disk1/work/Data/Liver_Multi_Modality/Pathology/thumbnails' os.makedirs(save_dir, exist_ok=True) filelist = os.listdir(data_dir) for file in filelist: wsi_file = OpenSlide('{:s}/{:s}'.format(data_dir, file)) thumbnail = wsi_file.get_thumbnail((1000, 1000)) thumbnail.save('{:s}/{:s}.png'.format(save_dir, file.split('.')[0]))
def check_wsi(num): folder_name = 'patient_' + num folder_dir = root_dir + folder_name + '/' files_list = os.listdir(folder_dir) for filename in files_list: file_path = folder_dir + filename try: slide = OpenSlide(file_path) print("Slide is ok: {}".format(filename)) except: print("Error opening {}".format(filename)) continue
def read_image(image_path): try: image = OpenSlide(image_path) w, h = image.dimensions n = int(math.floor((h - 0) / 224)) m = int(math.floor((w - 0) / 224)) level = image.level_count - 1 downsample_image = np.array(image.read_region((0, 0), level, image.level_dimensions[level])) except OpenSlideUnsupportedFormatError: print('Exception: OpenSlideUnsupportedFormatError') return None, None, None, None return image, downsample_image, level, m, n
def getImageTiles(filenameImage, filenameXML, size=128): #Getting the appropriate upper left coordinates rRegionList = getCoordinates(filenameXML, size) image = OpenSlide(filenameImage) regionList = [] for region in tqdm(rRegionList): regionImg = image.read_region(region, 0, (size, size)) regionList.append(regionImg) return regionList
def get(self, path): with self._lock: if path in self._cache: # Move to end of LRU slide = self._cache.pop(path) self._cache[path] = slide return slide slide = DeepZoomGenerator(OpenSlide(path), **self.dz_opts) with self._lock: if path not in self._cache: if len(self._cache) == self.cache_size: self._cache.popitem(last=False) self._cache[path] = slide return slide
def get_image_metadata(): """ Read slide and process :return: """ p = Path(os.path.join(SLIDE_DIR, (CASE_ID + '.svs'))) osr = OpenSlide(str(p)) # props = osr.properties # props.__getitem__('openslide.level[0].width') # props.__getitem__('openslide.level[0].height') image_width = osr.dimensions[0] image_height = osr.dimensions[1] osr.close() return image_width, image_height
def export_images(slide_pos_by_global, slidedir, leaves_by_trunc, outfolder, slidetype=".mrxs", level=1, size=299, maxperconcept=1000): """ Export images for every truncated leaf. Loop over slides, For every patch in slide, extract patch and put it in the right folder. """ # Now, for every significant leaf concept, we get the corresponding images and store them significant_concept_counter = 1 for trunc, leaves in leaves_by_trunc.items(): print("processing significant concept {} / {}".format(significant_concept_counter, len(leaves_by_trunc))) print("#" * 20) # create the directory if does not exists folder = os.path.join(outfolder, str(trunc)) if not os.path.exists(folder): print("creating significant concept folder") os.makedirs(folder) # get unique slidenames in leaf_concepts as well as their count names, c = numpy.unique([slide_pos_by_global[idx]["Slidename"] for idx in leaves], return_counts=True) print("significant concept id={} has {} leaf-concepts".format(trunc, len(leaves))) print("leaf-concepts lay in {} different slides".format(len(names))) n_per_slide = int(float(maxperconcept) / c.sum()) subconcept_counter = 1 for global_id in leaves: # It is obvious that one global_id can only have one slidename. slidename = slide_pos_by_global[global_id]["Slidename"] positions = slide_pos_by_global[global_id]["Positions"] print("- processing concept {} / {} | id={} | slidename={} | patch extraction={}".format(subconcept_counter, len(leaves), global_id, slidename, n_per_slide)) for p in numpy.random.permutation(positions)[0:min(n_per_slide, len(positions))]: slidepath = os.path.join(slidedir, slidename + slidetype) slide = OpenSlide(slidepath) image = slide.read_region(p, level, (size, size)) image = numpy.array(image)[:, :, 0:3] imsave(os.path.join(folder, "{}_{}_{}.png".format(slidename, p[0], p[1])), image) subconcept_counter += 1 significant_concept_counter += 1
def save_slide_cutting(file_path, save_location, level): slide = OpenSlide(file_path) print('==> saving slide_lv_' + str(level) + ' at ' + save_location) x_lv_, y_lv_ = 0, 0 w_lv_, h_lv_ = slide.level_dimensions[level] try: wsi_pil_lv_ = slide.read_region((0, 0), level, \ (w_lv_, h_lv_)) wsi_ary_lv_ = np.array(wsi_pil_lv_) wsi_bgr_lv_ = cv2.cvtColor(wsi_ary_lv_, cv2.COLOR_RGBA2BGR) cv2.imwrite(save_location, wsi_bgr_lv_) except: print(file_path)
def read_wsi_tumor(self, wsi_path, mask_path): """ # ===================================================================================== # read WSI image and resize # Due to memory constraint, we use down sampled (4th level, 1/32 resolution) image # ====================================================================================== """ try: self.cur_wsi_path = wsi_path self.wsi_image = OpenSlide(wsi_path) self.mask_image = OpenSlide(mask_path) self.level_used = min(self.def_level, self.wsi_image.level_count - 1, self.mask_image.level_count - 1) self.rgb_image_pil = self.wsi_image.read_region((0, 0), self.level_used, self.wsi_image.level_dimensions[self.level_used]) self.rgb_image = np.array(self.rgb_image_pil) except OpenSlideUnsupportedFormatError: print('Exception: OpenSlideUnsupportedFormatError') return False return True
def export_segimages(slide, data,outputfolder,filename): cmap = matplotlib.cm.viridis norm = mpl.colors.Normalize(vmin=0, vmax=1) if not os.path.exists(outputfolder): os.makedirs(outputfolder) # compute segmentation image xs = list() ys = list() for patch in data.keys(): xs.append(data[patch]['x']) ys.append(data[patch]['y']) xmin = min(xs) xmax = max(xs) ymin = min(ys) ymax = max(ys) print(xmin,xmax,ymin,ymax) dx = xmax - xmin dy = ymax - ymin segimage = numpy.zeros((int(dy / args.delta) + 1, int(dx / args.delta) + 1, 3), float) print("created image's shape ",segimage.shape) for patch in data.keys(): x = data[patch]['x'] - xmin y = data[patch]['y'] - ymin x = int(x / args.delta) y = int(y / args.delta) #Implemented for a binary classification problem if data[patch]['feature'][0] > 0.5 and data[patch]['var'][0] < args.var: segimage[y, x, 0] = 1.0 segimage[y, x, 1] = 1.0 segimage[y, x, 2] = 1.0 if data[patch]['feature'][1] > 0.5 and data[patch]['var'][1] < args.var: segimage[y, x, 0] = 1.0 segimage[y, x, 1] = 0.0 segimage[y, x, 2] = 0.0 imsave(os.path.join(outputfolder, filename+'_'+str(args.var)+"_hypothese.png"), img_as_ubyte(segimage)) print("working on ",slide) slide = OpenSlide(slide) img = slide.read_region((0, 0),7, slide.level_dimensions[7]) img = numpy.array(img)[:, :, 0:-1] empty_img = numpy.zeros(shape=(img.shape),dtype='uint8') print('shape vide = ',empty_img.shape) imsave(os.path.join(outputfolder, filename+"empty.png"), empty_img)
def denoising(inputsvs, magnification="20x", filtering="GaussianBlur", patch_size=(256, 256), upperlimit=1100, lowerlimit=300, red_value=(80, 220), green_value=(80, 200), blue_value=(80, 170), Annotation=None, Annotatedlevel=0, Requiredlevel=0): slide = OpenSlide(inputsvs) slide_dimensions = slide.level_dimensions img, slide_dimensions = readWSI(inputsvs, magnification, Annotation, Annotatedlevel, Requiredlevel) dictx = dictionary(slide_dimensions) if filtering == "GaussianBlur": out = denoising_using_GaussianBlur(inputsvs, magnification, dictx, patch_size, upperlimit, lowerlimit, Annotation, Annotatedlevel, Requiredlevel) elif filtering == "RGB": mask = denoising_RGB_Thersholding(img, slide_dimensions, magnification, dictx, patch_size, red_value, green_value, blue_value) out = np.zeros_like(img) print("cleaning image at high mignification") mask = mask.astype(np.bool) out[mask] = img[mask] out = np.where(out != [0, 0, 0], out, [255, 255, 255]) print("cleaning WSI done") # cv2.imwrite("/home/pagenet2/PageNet2/Data Preprocessing Pipeline/WSI_Precessing_test/cleanedimages/%s/cleanedsmallf.png"%(inputsvs.split("/")[-1][:-4]),out) garbage_collector() print("exisiting cleaning") else: mask = denoising_No_filters(img, slide_dimensions, magnification, dictx) out = np.zeros_like(img) print("cleaning image at high mignification") mask = mask.astype(np.bool) out[mask] = img[mask] out = np.where(out != [0, 0, 0], out, [255, 255, 255]) print("cleaning WSI done") # cv2.imwrite("/home/pagenet2/PageNet2/Data Preprocessing Pipeline/WSI_Precessing_test/cleanedimages/%s/cleanedsmallf.png"%(inputsvs.split("/")[-1][:-4]),out) garbage_collector() print("exisiting cleaning") return out
def convert_image(path_img, level=DEFAULT_LEVEL, overwrite=False): """ convert TIFF/SVS image to standard format The output image has the same name and it is exported in the same folder :param str path_img: path to the input image :param int level: selected level of the internal pyramid representation the level 0 means full scale and higher number is small image in pyramid scaling :param bool overwrite: whether overwrite existing image on output """ slide_img = OpenSlide(path_img) if level >= len(slide_img.level_dimensions): raise ValueError('unsupported level %i of %i' % (level, slide_img.level_count)) path_img_new = os.path.splitext(path_img)[0] + IMAGE_EXTENSION if os.path.isfile(path_img_new) and not overwrite: logging.warning('existing "%s"', path_img_new) return level_size = slide_img.level_dimensions[level] level_scale = slide_img.level_downsamples[level] level_downsample = 1 while max(np.array(level_size) / level_downsample) > MAX_LOAD_IMAGE_SIZE: level_downsample *= 2 logging.debug('using down-sample: %i', level_downsample) tile_size = (np.array(level_size) / level_downsample).astype(int) locations = [(i * tile_size[0], j * tile_size[1]) for i in range(level_downsample) for j in range(level_downsample)] im = np.array(slide_img.read_region((0, 0), 0, size=(10, 10))) nb_channels = min(3, im.shape[2]) if im.ndim == 3 else 1 img_size = list(tile_size * level_downsample)[::-1] + [nb_channels] image = np.zeros(img_size, dtype=np.uint8) for loc_i, loc_j in tqdm.tqdm(locations, desc=os.path.basename(path_img)): loc_img = int(loc_i * level_scale), int(loc_j * level_scale) img = np.array(slide_img.read_region(loc_img, level, size=tile_size)) image[loc_j:loc_j + img.shape[0], loc_i:loc_i + img.shape[1], ...] = img[:, :, :nb_channels] del img if nb_channels == 2: image = image[:, :, 0] logging.debug('save image: "%s"', path_img_new) cv.imwrite(path_img_new, image, params=(cv.IMWRITE_PNG_COMPRESSION, 9)) gc.collect() time.sleep(1)
def conver_axis_to_large_mrxs(xmin, ymin, xmax, ymax, mrxs_filename, image, index): overlap_ratio = 10 osr = OpenSlide(mrxs_filename) props = osr.properties w, h = osr.level_dimensions[0] nums = round(w / image.shape(1)) xmin_change = xmin / ww_ratio ymin_change = ymin / hh_ratio xmax_change = xmax / ww_ratio ymax_change = ymax / hh_ratio [x1 + xmin_change, y1 + ymin_change, x2 + xmax_change, y2 + ymax_change] return xmin, ymin, xmax, ymax
def get_property(request, slide_id): try: s = Alopecia.objects.get(pk=slide_id) except Alopecia.DoesNotExist: raise Http404 if s.SlideType == 2: file = path.join(settings.HISTOSLIDE_SLIDEROOT, str(s.UrlPath)) slide = OpenSlide(file) return JsonResponse({ 'status': 'success', 'data': dict(slide.properties) }) else: return JsonResponse({'status': 'success', 'data': dict()})
def load_tile( slide_path: str, width: int, downscale: int, coords: Tuple[int, Tuple[int, int]]): # Load slide from global. reader = OpenSlide(slide_path) i, (x, y) = coords out_shape = (int(width/downscale), int(width/downscale)) try: tile = reader.read_region((x, y), 0, (width, width)).convert('RGB') tile = cv2.resize(np.array(tile), out_shape, cv2.INTER_LANCZOS4) except: tile = np.zeros(out_shape + (3,)).astype(np.uint8) return i, tile
def get_label(slide, slide_name, masks_dir): h, w = slide.level_dimensions[_SAMPLE_LEVEL] label_mask = np.full((w, h), False) label_slide = None label_path = masks_dir / f'{slide_name}_Mask.tif' if label_path.is_file(): label_slide = OpenSlide(str(label_path)) label_dim = label_slide.level_dimensions[_SAMPLE_LEVEL] label_img = label_slide.read_region((0, 0), _SAMPLE_LEVEL, label_dim) label_img = np.array(label_img.convert('L')) init_label(label_mask, label_img) return label_mask, label_slide
def save_level_images(input_folder, output_folder, level): ndpi_id = ndpi_file[:-5] ndpi_path = os.path.join(input_folder, ndpi_file) ndpi_slide = OpenSlide(ndpi_path) width = ndpi_slide.level_dimensions[level][0] height = ndpi_slide.level_dimensions[level][1] image = ndpi_slide.read_region((0, 0), level, (width, height)) image = np.array(image) if image.shape[2] > 3: image = image[:, :, 0:3] # convert from RGBA to RGB image_path = os.path.join(output_folder, ndpi_id + '.tif') skimage.io.imsave(image_path, image)
def process(opts): i, pid, x, y, file_path_tif, patch_path, patch_size, patch_level, class_dir = opts dir = pid.split("/")[-1] dir_split = dir.split("-")[:3] dir_name = dir_split[0] + '-' + dir_split[1] + '-' + dir_split[2] x = int(float(x)) y = int(float(y)) wsi_path = os.path.join(file_path_tif, dir + '.svs') slide = OpenSlide(wsi_path) img = slide.read_region((x, y), 1, (256, 256)) wsi_ary_lv_ = np.array(img) img = cv2.cvtColor(wsi_ary_lv_, cv2.COLOR_RGBA2BGR) cv2.imwrite(os.path.join(class_dir, dir_name + "_" + str(i) + '.png'), img)
def __init__(self, path): self.warning = '' self.path = path self.reader = None self.tilesize = 1024 self.ext = check_ext(path) self.default_dtype = np.uint16 if self.ext == '.ome.tif' or self.ext == '.ome.tiff': self.io = TiffFile(self.path, is_ome=False) self.group = zarr.open(self.io.series[0].aszarr()) self.reader = 'tifffile' self.ome_version = self._get_ome_version() print("OME ", self.ome_version) num_channels = self.get_shape()[0] tile_0 = self.get_tifffile_tile(num_channels, 0, 0, 0, 0, 1024) if tile_0 is not None: self.default_dtype = tile_0.dtype if (num_channels == 3 and tile_0.dtype == 'uint8'): self.rgba = True self.rgba_type = '3 channel' elif (num_channels == 1 and tile_0.dtype == 'uint8'): self.rgba = True self.rgba_type = '1 channel' else: self.rgba = False self.rgba_type = None print("RGB ", self.rgba) print("RGB type ", self.rgba_type) elif self.ext == '.svs': self.io = OpenSlide(self.path) self.dz = DeepZoomGenerator(self.io, tile_size=1024, overlap=0, limit_bounds=True) self.reader = 'openslide' self.rgba = True self.rgba_type = None self.default_dtype = np.uint8 print("RGB ", self.rgba) print("RGB type ", self.rgba_type) else: self.reader = None
def split_region_around(max_length, image_num, file_dir): osr = OpenSlide(file_dir + '.mrxs') props = osr.properties axis_list = read_label(file_dir) for ID, axis in axis_list: print("axis:", axis) width = float(axis[2]) - float(axis[0]) height = float(axis[3]) - float(axis[1]) print("width:", width, ",height:", height) label_list = [] for i in range(image_num): #print(props) radioX = random.uniform(0, 1 - width / max_length) radioY = random.uniform(0, 1 - height / max_length) crop_xl = math.floor(max(float(axis[0]) - max_length * radioX, 0)) crop_yl = math.floor(max(float(axis[1]) - max_length * radioY, 0)) crop_xr = crop_xl + max_length crop_yr = crop_yl + max_length #print("crop_xl:", crop_xl) img = osr.read_region((crop_xl, crop_yl), 0, (max_length, max_length)).convert("RGB") #draw = ImageDraw.Draw(img) #draw.rectangle((radioX * max_length, radioY * max_length, width, height), None, "red") labelxmin = math.floor(radioX * max_length) labelymin = math.floor(radioY * max_length) labelxmax = math.floor(radioX * max_length + width) labelymax = math.floor(radioY * max_length + height) label_list.append([labelxmin, labelymin, labelxmax, labelymax]) for ID_other, axis_other in axis_list: width_other = float(axis_other[2]) - float(axis_other[0]) height_other = float(axis_other[3]) - float(axis_other[1]) labelxmin_other = max(math.floor(axis_other[0]), crop_xl) labelymin_other = max(math.floor(axis_other[1]), crop_yl) labelxmax_other = min(math.floor(axis_other[2]), crop_xr) labelymax_other = min(math.floor(axis_other[3]), crop_yr) if labelxmin_other == labelxmin and labelymin_other == labelymin and labelxmax_other == labelxmax \ and labelymax_other == labelymax: continue if width_other > max_length or height_other > max_length: logger.error( "The label box is too large, its width or height is bigger than the crop max /" "length {}".format(max_length)) continue label_list.append([ labelxmin_other, labelymin_other, labelxmax_other, labelymax_other ])