def compare_pngs(actual, expected): """ Compare two images using RMS approach. Actual and expected are paths to PNG files. Returns True for mismatch, False otherwise. """ # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) num_values = np.prod(expectedImage.shape) abs_diff_image = abs(expectedImage - actualImage) histogram = np.bincount(abs_diff_image.ravel(), minlength=256) sum_of_squares = np.sum(histogram * np.arange(len(histogram)) ** 2) rms = np.sqrt(float(sum_of_squares) / num_values) return rms
def encode(message): """Encode the message string into images based on PNGs in pool/, and store the resulting images in encoded/. """ if len(message) == 0: return pool_list = ["pool/" + f for f in os.listdir("pool/") if '.png' in f] assert len(message) <= max_length() int_list = [ord(c) for c in message] + [0] for i in range(len(pool_list)): pool_im = mpng.read_png_int(pool_list[i]) assert pool_im.shape[2] == 3 #check if RGB image # print(len(tiles(pool_im.shape[0], pool_im.shape[1])), (pool_im.shape[0]//2) * (pool_im.shape[1]//8)) for tile in tiles(pool_im.shape[0], pool_im.shape[1]): encode_int(pool_im, tile, int_list.pop(0)) if len(int_list) == 0: break png.from_array(pool_im, mode='RGB').save("encoded/image_{0}.png".format(i)) if len(int_list) <= 1: break return
def __init__(self, img_path): self.img = png.read_png_int(img_path) self.traffic_light = [] self.traffic_lights_3d_location = [] self.EM = [] self.corresponding_ind = [] self.valid = []
def test_imread_png_uint16(): from matplotlib import _png img = _png.read_png_int(os.path.join(os.path.dirname(__file__), 'baseline_images/test_png/uint16.png')) assert (img.dtype == np.uint16) assert np.sum(img.flatten()) == 134184960
def test_imread_png_uint16(): from matplotlib import _png with (Path(__file__).parent / 'baseline_images/test_png/uint16.png').open('rb') as file: img = _png.read_png_int(file) assert (img.dtype == np.uint16) assert np.sum(img.flatten()) == 134184960
def main(): plt.ion() im2 = png.read_png_int('0_disc.png') im1 = png.read_png_int('0_macular.png') # im1 = matplotlib.image.imread('orange.jpg') # im1 = matplotlib.image.imread('0_disc.png') im1, im2 = preprocess_images(im1, im2) gp_1, gp_2 = [gaussian_pyramid(im) for im in [im1, im2]] lp_1, lp_2 = [laplacian_pyramid(gp) for gp in [gp_1, gp_2]] lp_join = laplacian_pyr_join(lp_1, lp_2) im_join = laplacian_collapse(lp_join) np.clip(im_join, 0, 255, out=im_join) im_join = np.uint8(im_join) plt.imsave('orapple.jpg', im_join) return 0
def max_length(): """Returns max. length message that can be encoded based on PNGs in pool/ and SPACING. """ pool_list = ["pool/" + f for f in os.listdir("pool/") if '.png' in f] max_chars = 0 for pool_im_name in pool_list: pool_im = mpng.read_png_int(pool_im_name) max_chars += len(tiles(pool_im.shape[0], pool_im.shape[1])) return max_chars
def do_spline(img1_path, img2_path): input_img1 = png.read_png_int(img1_path) input_img2 = png.read_png_int(img2_path) input_img1, input_img2 = preprocess_images(input_img1, input_img2) img_nonzero = [np.nonzero(input_img1), np.nonzero(input_img2)] img1_L = img_nonzero[0][1][0] img2_L = img_nonzero[1][1][0] L_min = np.argmax([img1_L, img2_L]) if L_min == 0: img1 = input_img2 img2 = input_img1 else: img1 = input_img1 img2 = input_img2 gp_1, gp_2 = [gaussian_pyramid(im) for im in [img1, img2]] lp_1, lp_2 = [laplacian_pyramid(gp) for gp in [gp_1, gp_2]] lp_join = laplacian_pyr_join(lp_1, lp_2) im_join = laplacian_collapse(lp_join) np.clip(im_join, 0, 255, out=im_join) im_join = np.uint8(im_join) # plt.imsave('orapple.jpg', im_join) return im_join
def decode(): """Decode message from PNGs in encoded/. Returns the decoded message string. """ number_encoded_images = len( [f for f in os.listdir("encoded/") if '.png' in f]) decoded_ints = [] for i in range(number_encoded_images): encoded_im = mpng.read_png_int("encoded/image_{0}.png".format(i)) for tile in tiles(encoded_im.shape[0], encoded_im.shape[1]): decoded_int = decode_int(encoded_im, tile) if decoded_int == 0: return ''.join([chr(c) for c in decoded_ints]) decoded_ints.append(decoded_int) return ''.join([chr(c) for c in decoded_ints])
y_cb_cr_img[i, j, 1] + ratio_as_al, y_cb_cr_img[i, j, 2] + ratio_as_al ] # covert the YCbCr image to the BGR image return cv2.cvtColor(y_cb_cr_img, cv2.COLOR_YCR_CB2BGR) def thresholding(img): return cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2) if __name__ == "__main__": test_images = np.array([ png.read_png_int('./data_road/training/image_2/um_000001.png'), png.read_png_int('./data_road/training/image_2/um_000002.png'), png.read_png_int('./data_road/training/image_2/um_000003.png'), png.read_png_int('./data_road/training/image_2/um_000004.png'), png.read_png_int('./data_road/training/image_2/um_000005.png'), png.read_png_int('./data_road/training/image_2/um_000006.png'), ]) #show_images(test_images) white_yellow_images = list(map(select_white_yellow, test_images)) #show_images(white_yellow_images) gray_images = list(map(convert_gray_scale, white_yellow_images)) #show_images(gray_images) #gray_images = list(map(thresholding, gray_images)) blurred_images = list( map(lambda image: apply_smoothing(image), gray_images))
import time data = [] for compression in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9): for filter in (-1, 'NONE', 'SUB', 'UP', 'AVG', 'PAETH'): if not isinstance(filter, int): filter_no = getattr(_png, 'PNG_FILTER_' + filter) else: filter = 'XXX' filter_no = -1 times = 0 sizes = 0 for i in range(16): filename = 'test{0:04d}.png'.format(i) image = _png.read_png_int(filename) t = time.time() buffer = _png.write_png(image, None, compression=compression, filter=filter_no) times += (time.time() - t) sizes += len(buffer) print(compression, filter, times, sizes) data.append((compression, filter, times, sizes)) print(data)
dtype=np.uint8, ) # Loop over all lines and draw them on the blank image. for line in lines: for x1, y1, x2, y2 in line: cv2.line(line_img, (x1, y1), (x2, y2), color, thickness) # Merge the image with the lines onto the original. img = cv2.addWeighted(img, 0.8, line_img, 1.0, 0.0) # Return the modified image. return img if __name__ == "__main__": image = png.read_png_int( '/Users/jeong-yeonji/mobNavigation/kitti/data_road/training/image_2/um_000012.png' ) height, width = image.shape[:2] plt.figure() plt.imshow(image) region_of_interest_vertices = [ [0, height], [width / 3, height / 2], [width * (2 / 3), height / 2], [width, height], ] # # cropped_image = region_of_interest( # image, # [np.array(region_of_interest_vertices, np.int32)],
def compare_images(expected, actual, tol, in_decorator=False): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a unitless float). This is used to determine the 'fuzziness' to use when comparing images. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if extension != 'png': actual = convert(actual) expected = convert(expected) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # normalize the images expectedImage = image_util.autocontrast(expectedImage, 2) actualImage = image_util.autocontrast(actualImage, 2) # compare the resulting image histogram functions rms = 0 bins = np.arange(257) for i in xrange(0, 3): h1p = expectedImage[:, :, i] h2p = actualImage[:, :, i] h1h = np.histogram(h1p, bins=bins)[0] h2h = np.histogram(h2p, bins=bins)[0] rms += np.sum(np.power((h1h - h2h), 2)) rms = np.sqrt(rms / (256 * 3)) diff_image = os.path.join(os.path.dirname(actual), 'failed-diff-' + os.path.basename(actual)) if ((rms / 10000.0) <= tol): if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image(expected, actual, diff_image) if in_decorator: results = dict( rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms / 10000.0 ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def compare_images( expected, actual, tol, in_decorator=False ): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a unitless float). This is used to determine the 'fuzziness' to use when comparing images. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int( expected ) actualImage = _png.read_png_int( actual ) actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # compare the resulting image histogram functions expected_version = version.LooseVersion("1.6") found_version = version.LooseVersion(np.__version__) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if ( (rms / 10000.0) <= tol ): if os.path.exists(diff_image): os.unlink(diff_image) return None # For Agg-rendered images, we can retry by ignoring pixels with # differences of only 1 if extension == 'png': # Remove differences of only 1 diffImage = np.abs(np.asarray(actualImage, dtype=np.int) - np.asarray(expectedImage, dtype=np.int)) actualImage = np.where(diffImage <= 1, expectedImage, actualImage) rms = calculate_rms(expectedImage, actualImage) if ( (rms / 10000.0) <= tol ): if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image( expected, actual, diff_image ) if in_decorator: results = dict( rms = rms, expected = str(expected), actual = str(actual), diff = str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms / 10000.0 ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def compare_images( expected, actual, tol, in_decorator=False ): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int( expected ) actualImage = _png.read_png_int( actual ) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if rms <= tol: if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image( expected, actual, diff_image ) if in_decorator: results = dict( rms = rms, expected = str(expected), actual = str(actual), diff = str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
# project_clip = VideoFileClip("project_video.mp4") # # # Importing calibration images # cal_filenames = glob.glob('camera_cal/*.jpg') # cal_images = np.array([np.array(plt.imread(img)) for img in cal_filenames]) # # # Importing test images # test_filenames = glob.glob('test_images/*.jpg') # test_images = np.array([np.array(plt.imread(img)) for img in test_filenames]) # # # Chessboard edges # nx = 9 # ny = 6 test_images = np.array([ png.read_png_int('./../../kitti/data_road/training/image_2/um_000000.png'), png.read_png_int('./../../kitti/data_road/training/image_2/um_000001.png'), png.read_png_int('./../../kitti/data_road/training/image_2/um_000002.png'), ]) img = test_images[0] img_y, img_x = (img.shape[0], img.shape[1]) offset = 50 # Lane masking and coordinates for perspective transform # source = np.float32([ # MASK # [img_y - offset, offset], # bottom left # [img_y - offset, img_x - offset], # bottom right # [offset, offset], # top left # [offset, img_x - offset]]) # top right source = np.float32([
assert len( sys.argv) == 3, "Usage : python execute.py <input_dir> <output_dir>" input_dir = sys.argv[1] output_dir = sys.argv[2] input_dir = os.path.join(os.path.join(input_dir, "training"), "image_2") filenames = os.listdir(input_dir) um_images = [filename for filename in filenames if filename[:3] == "um_"] um_images.sort() os.makedirs(output_dir, exist_ok=True) for filename in um_images: png_image = png.read_png_int(os.path.join(input_dir, filename)) white_yellow_image = select_white_yellow(png_image) gray_image = convert_gray_scale(white_yellow_image) gray_image = thresholding(gray_image) blurred_image = apply_smoothing(gray_image) edge_image = detect_edges(blurred_image) roi_image = select_region(edge_image) lines = hough_lines(roi_image) lane_line = detect_lanes(roi_image, lines) o_blurred_image = apply_smoothing(png_image) o_edge_image = detect_edges(o_blurred_image) o_roi_image = select_region(o_edge_image) o_lines = hough_lines(o_roi_image) o_lane_line = detect_lanes(o_roi_image, o_lines)
def mura_preprocess(train_path): train_path = "MURA-v1.1/" csv_train_filess = os.path.join("dataloader", train_path, "train_labeled_studies.csv") csv_valid_filess = os.path.join("dataloader", train_path, "valid_labeled_studies.csv") train_df = pd.read_csv(csv_train_filess, names=['img', 'label'], header=None) valid_df = pd.read_csv(csv_valid_filess, names=['img', 'label'], header=None) train_img_paths = train_df.img.values.tolist() valid_img_paths = valid_df.img.values.tolist() train_labels_patient = train_df.label.values.tolist() valid_labels_patient = valid_df.label.values.tolist() train_data_list = [] train_labels = [] valid_data_list = [] valid_labels = [] for i in range(len(train_img_paths) / 100): patient_dir = os.path.join("dataloader", train_img_paths[i]) msg = "\r Loading: %s (%d/%d) " % (patient_dir, i + 1, len(train_img_paths)) sys.stdout.write(msg) sys.stdout.flush() for f in glob.glob(patient_dir + "*"): train_data_patient = [] train_img = png.read_png_int(f) if train_img.shape != (512, 512): if len(train_img.shape) > 2: train_img = train_img[:, :, 1] l, w = train_img.shape train_img = np.pad(train_img, [((512 - l) / 2, 512 / 2 - l / 2), ((512 - w) / 2, 512 / 2 - w / 2)], 'constant', constant_values=0) train_img = imresize(train_img, (256, 256)) # you can replace 256 with other number but any number greater then 256 will exceed the memory limit of 12GB train_img = np.stack((train_img, ) * 3, -1) train_data_patient.append(train_img) train_data_list.extend(train_data_patient) for _ in range(len(train_data_patient)): lst = [0, 0] lst[train_labels_patient[i]] = 1 train_labels.append(lst) train_data = np.asarray(train_data_list) for i in range(len(valid_img_paths) / 10): patient_dir = os.path.join("dataloader", valid_img_paths[i]) msg = "\r Loading: %s (%d/%d) " % (patient_dir, i + 1, len(valid_img_paths)) sys.stdout.write(msg) sys.stdout.flush() for f in glob.glob(patient_dir + "*"): valid_data_patient = [] valid_img = png.read_png_int(f) if train_img.shape != (512, 512): if len(valid_img.shape) > 2: valid_img = valid_img[:, :, 1] l, w = valid_img.shape valid_img = np.pad(valid_img, [((512 - l) / 2, 512 / 2 - l / 2), ((512 - w) / 2, 512 / 2 - w / 2)], 'constant', constant_values=0) valid_img = imresize(valid_img, (256, 256)) valid_img = np.stack((valid_img, ) * 3, -1) valid_data_patient.append(valid_img) valid_data_list.extend(valid_data_patient) for _ in range(len(valid_data_patient)): lst = [0, 0] lst[valid_labels_patient[i]] = 1 valid_labels.append(lst) valid_data = np.asarray(valid_data_list) return np.array(train_data), np.array(train_labels), np.array( valid_data), np.array(valid_labels)
def compare_images(expected, actual, tol, in_decorator=False): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a unitless float). This is used to determine the 'fuzziness' to use when comparing images. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # compare the resulting image histogram functions expected_version = version.LooseVersion("1.6") found_version = version.LooseVersion(np.__version__) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if ((rms / 10000.0) <= tol): if os.path.exists(diff_image): os.unlink(diff_image) return None # For Agg-rendered images, we can retry by ignoring pixels with # differences of only 1 if extension == 'png': # Remove differences of only 1 diffImage = np.abs( np.asarray(actualImage, dtype=np.int) - np.asarray(expectedImage, dtype=np.int)) actualImage = np.where(diffImage <= 1, expectedImage, actualImage) rms = calculate_rms(expectedImage, actualImage) if ((rms / 10000.0) <= tol): if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image(expected, actual, diff_image) if in_decorator: results = dict( rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms / 10000.0 ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def time_imread_png_uint16(): img = _png.read_png_int( os.path.join(os.path.dirname(__file__), 'data/uint16.png'))
import glob import matplotlib.pyplot as plt import matplotlib._png as png import h5py import numpy as np shuffle_data = True # shuffle the addresses before saving hdf5_path = '/home/mak/Desktop/Stroboscopy/dataset1.hdf5' # address to where you want to save the hdf5 file train_path = '/home/mak/Desktop/Stroboscopy/AllImages/*.png' # read addresses and labels from the 'train' folder addrs = glob.glob(train_path) # to shuffle data train_addrs = addrs hdf5_file = h5py.File(hdf5_path, mode='w') train_shape = (len(train_addrs), 576, 720, 3) hdf5_file.create_dataset("train_img", train_shape, np.uint8) for i in range(len(train_addrs)): # print how many images are saved every 1000 images if i % 100 == 0 and i > 1: print 'Train data: {}/{}'.format(i, len(train_addrs)) # read an image and resize to (224, 224) # cv2 load images as BGR, convert it to RGB addr = train_addrs[i] img = png.read_png_int(addr) print img.dtype # add any image pre-processing here # if the data order is Theano, axis orders should change hdf5_file["train_img"][i, :, :, :] = img # hdf5_file.close()
import matplotlib.pyplot as plt import matplotlib._png as png import numpy as np path = "/home/mak/Desktop/Stroboscopy/AllImages/3.png" img = png.read_png_int(path) print img.dtype print img[0:10, 0:10, 0] plt.imshow(img) plt.show()
def compare_images( expected, actual, tol, in_decorator=False ): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int( expected ) actualImage = _png.read_png_int( actual ) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) # compare the resulting image histogram functions expected_version = version.LooseVersion("1.6") found_version = version.LooseVersion(np.__version__) # On Numpy 1.6, we can use bincount with minlength, which is much faster than # using histogram if found_version >= expected_version: rms = 0 for i in xrange(0, 3): h1p = expectedImage[:,:,i] h2p = actualImage[:,:,i] h1h = np.bincount(h1p.ravel(), minlength=256) h2h = np.bincount(h2p.ravel(), minlength=256) rms += np.sum(np.power((h1h-h2h), 2)) else: rms = 0 ns = np.arange(257) for i in xrange(0, 3): h1p = expectedImage[:,:,i] h2p = actualImage[:,:,i] h1h = np.histogram(h1p, bins=ns)[0] h2h = np.histogram(h2p, bins=ns)[0] rms += np.sum(np.power((h1h-h2h), 2)) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if rms <= tol: if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image( expected, actual, diff_image ) if in_decorator: results = dict( rms = rms, expected = str(expected), actual = str(actual), diff = str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def compare_images(expected, actual, tol, in_decorator=False): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if rms <= tol: if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image(expected, actual, diff_image) if in_decorator: results = dict( rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def compare_images(expected, actual, tol, in_decorator=False): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) # compare the resulting image histogram functions expected_version = version.LooseVersion("1.6") found_version = version.LooseVersion(np.__version__) # On Numpy 1.6, we can use bincount with minlength, which is much faster than # using histogram if found_version >= expected_version: rms = 0 for i in xrange(0, 3): h1p = expectedImage[:, :, i] h2p = actualImage[:, :, i] h1h = np.bincount(h1p.ravel(), minlength=256) h2h = np.bincount(h2p.ravel(), minlength=256) rms += np.sum(np.power((h1h - h2h), 2)) else: rms = 0 ns = np.arange(257) for i in xrange(0, 3): h1p = expectedImage[:, :, i] h2p = actualImage[:, :, i] h1h = np.histogram(h1p, bins=ns)[0] h2h = np.histogram(h2p, bins=ns)[0] rms += np.sum(np.power((h1h - h2h), 2)) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if rms <= tol: if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image(expected, actual, diff_image) if in_decorator: results = dict( rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def mura_preprocess(train_path): train_path = "MURA-v1.1/" csv_train_filess = os.path.join("dataloader", train_path, "train_labeled_studies.csv") csv_valid_filess = os.path.join("dataloader", train_path, "valid_labeled_studies.csv") train_df = pd.read_csv(csv_train_filess, names=['img', 'label'], header=None) valid_df = pd.read_csv(csv_valid_filess, names=['img', 'label'], header=None) # train_data_list=[] # train_labels=[] # for i in range(len(train_img_paths)): # patient_dir=os.path.join("dataloader", train_img_paths[i]) # print("Loading: %s (%d/%d)"%(patient_dir, i, len(train_img_paths))) # for f in glob.glob(patient_dir + "*"): # train_data_patient=[] # train_img=png.read_png_int(f).tolist() # train_data_patient.append(train_img) # train_data_list.extend(train_data_patient) # for _ in range(len(train_data_patient)): # train_labels.append(train_labels_patient[i]) train_img_paths = train_df.img.values.tolist() valid_img_paths = valid_df.img.values.tolist() train_labels_patient = train_df.label.values.tolist() valid_labels_patient = valid_df.label.values.tolist() train_data_list = [] train_labels = [] valid_data_list = [] valid_labels = [] for i in range(len(valid_img_paths) // 3): patient_dir = os.path.join("dataloader", train_img_paths[i]) print("Loading: %s (%d/%d)" % (patient_dir, i, len(train_img_paths))) for f in glob.glob(patient_dir + "*"): valid_data_patient = [] valid_img = png.read_png_int(f) valid_img = imresize(valid_img, (64, 64)) valid_img = np.stack((valid_img, ) * 3, -1) valid_data_patient.append(valid_img) train_data_list.extend(valid_data_patient) for _ in range(len(valid_data_patient)): lst = [0, 0] lst[train_labels_patient[i]] = 1 train_labels.append(lst) train_data = np.asarray(train_data_list) for i in range(len(valid_img_paths) // 3): patient_dir = os.path.join("dataloader", valid_img_paths[i]) print("Loading: %s (%d/%d)" % (patient_dir, i, len(valid_img_paths))) for f in glob.glob(patient_dir + "*"): valid_data_patient = [] valid_img = png.read_png_int(f) valid_img = imresize(valid_img, (64, 64)) valid_img = np.stack((valid_img, ) * 3, -1) valid_data_patient.append(valid_img) valid_data_list.extend(valid_data_patient) for _ in range(len(valid_data_patient)): lst = [0, 0] lst[valid_labels_patient[i]] = 1 valid_labels.append(lst) valid_data = np.asarray(valid_data_list) # return train_data, train_labels, valid_data, valid_labels return np.array(train_data), np.array(train_labels), np.array( valid_data), np.array(valid_labels)
def new_test_func(*args, **kwargs): if inspect.ismethod(original): result = original.__func__(*args, **kwargs) else: result = original(*args, **kwargs) for baseline_image, test_image, baseline_rcparams, test_rcparams in self._get_baseline_result_pairs( test_suite_name, filename, self.extensions): # save image fig = plt.gcf() if fig is not None: if self.fig_size is not None: fig.set_size_inches(self.fig_size) fig.set_tight_layout(True) fig.savefig(test_image, **self.savefig_kwargs) # save rcParams with open(test_rcparams, "w") as rcfile: from pprint import pprint rc = matplotlib.rcParams.copy() rc.pop("datapath") # hide datapath pprint(rc, rcfile) import pytest if self.is_compare_image and os.path.exists( baseline_image): msg = compare_images(baseline_image, test_image, tol=self.tolerance) if msg is not None: msg += "\n" msg += self.compare_rcParam( baseline_rcparams, test_rcparams) # print image in base64 # print("====================") # print("Expected Image:") # self._print_image_base64(baseline_image) # print("Actual Image:") # self._print_image_base64(test_image) # print("====================") self.print_image_testing_note(file=sys.stderr) if self.on_compare_fail is not None: self.on_compare_fail() if self.on_fail is not None: self.on_fail() pytest.fail(msg, pytrace=False) else: # clearup the image as they are the same with the baseline os.remove(test_image) os.remove(test_rcparams) if not os.listdir(os.path.dirname(test_image)): os.rmdir(os.path.dirname(test_image)) else: # checking if the created image is empty verify(test_image) actual_image = _png.read_png_int(test_image) actual_image = actual_image[:, :, : 3] # remove the alpha channel (if exists) import numpy as np if np.any(actual_image): self.print_image_testing_note(file=sys.stderr) if self.is_compare_image: pytest.skip( "Image file not found for comparison test " "(This is expected for new tests.)\nGenerated Image: " "\n\t{test}".format(test=test_image)) else: self._logger.info( "\nGenerated Image: {test}".format( test=test_image)) else: # empty image created if self.on_empty_image is not None: self.on_empty_image() if self.on_fail is not None: self.on_fail() pytest.fail( "Image file not found for comparison test " "(This is expected for new tests.)," " but the new image created is empty.") return result
def compare_images(expected, actual, tol, in_decorator=False): """ Compare two "image" files checking differences within a tolerance. The two given filenames may point to files which are convertible to PNG via the `.converter` dictionary. The underlying RMS is calculated with the `.calculate_rms` function. Parameters ---------- expected : str The filename of the expected image. actual : str The filename of the actual image. tol : float The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. in_decorator : bool Determines the output format. If called from image_comparison decorator, this should be True. (default=False) Returns ------- comparison_result : None or dict or str Return *None* if the images are equal within the given tolerance. If the images differ, the return value depends on *in_decorator*. If *in_decorator* is true, a dict with the following entries is returned: - *rms*: The RMS of the image difference. - *expected*: The filename of the expected image. - *actual*: The filename of the actual image. - *diff_image*: The filename of the difference image. - *tol*: The comparison tolerance. Otherwise, a human-readable multi-line string representation of this information is returned. Examples -------- :: img1 = "./baseline/plot.png" img2 = "./output/plot.png" compare_images(img1, img2, 0.001) """ from matplotlib import _png if not os.path.exists(actual): raise Exception("Output image %s does not exist." % actual) if os.stat(actual).st_size == 0: raise Exception("Output image file %s is empty." % actual) # Convert the image to png extension = expected.split('.')[-1] if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expected_image = _png.read_png_int(expected) actual_image = _png.read_png_int(actual) expected_image = expected_image[:, :, :3] actual_image = actual_image[:, :, :3] actual_image, expected_image = crop_to_same( actual, actual_image, expected, expected_image) diff_image = make_test_filename(actual, 'failed-diff') if tol <= 0: if np.array_equal(expected_image, actual_image): return None # convert to signed integers, so that the images can be subtracted without # overflow expected_image = expected_image.astype(np.int16) actual_image = actual_image.astype(np.int16) rms = calculate_rms(expected_image, actual_image) if rms <= tol: return None save_diff_image(expected, actual, diff_image) results = dict(rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), tol=tol) if not in_decorator: # Then the results should be a string suitable for stdout. template = ['Error: Image files did not match.', 'RMS Value: {rms}', 'Expected: \n {expected}', 'Actual: \n {actual}', 'Difference:\n {diff}', 'Tolerance: \n {tol}', ] results = '\n '.join([line.format(**results) for line in template]) return results
def compare_images(expected, actual, tol, in_decorator=False): """ Compare two "image" files checking differences within a tolerance. The two given filenames may point to files which are convertible to PNG via the `.converter` dictionary. The underlying RMS is calculated with the `.calculate_rms` function. Parameters ---------- expected : str The filename of the expected image. actual : str The filename of the actual image. tol : float The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. in_decorator : bool Determines the output format. If called from image_comparison decorator, this should be True. (default=False) Returns ------- comparison_result : None or dict or str Return *None* if the images are equal within the given tolerance. If the images differ, the return value depends on *in_decorator*. If *in_decorator* is true, a dict with the following entries is returned: - *rms*: The RMS of the image difference. - *expected*: The filename of the expected image. - *actual*: The filename of the actual image. - *diff_image*: The filename of the difference image. - *tol*: The comparison tolerance. Otherwise, a human-readable multi-line string representation of this information is returned. Examples -------- :: img1 = "./baseline/plot.png" img2 = "./output/plot.png" compare_images(img1, img2, 0.001) """ from matplotlib import _png actual = os.fspath(actual) if not os.path.exists(actual): raise Exception("Output image %s does not exist." % actual) if os.stat(actual).st_size == 0: raise Exception("Output image file %s is empty." % actual) # Convert the image to png expected = os.fspath(expected) if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) extension = expected.split('.')[-1] if extension != 'png': actual = convert(actual, cache=False) expected = convert(expected, cache=True) # open the image files and remove the alpha channel (if it exists) with open(expected, "rb") as expected_file: expected_image = _png.read_png_int(expected_file)[:, :, :3] with open(actual, "rb") as actual_file: actual_image = _png.read_png_int(actual_file)[:, :, :3] actual_image, expected_image = crop_to_same( actual, actual_image, expected, expected_image) diff_image = make_test_filename(actual, 'failed-diff') if tol <= 0: if np.array_equal(expected_image, actual_image): return None # convert to signed integers, so that the images can be subtracted without # overflow expected_image = expected_image.astype(np.int16) actual_image = actual_image.astype(np.int16) rms = calculate_rms(expected_image, actual_image) if rms <= tol: return None save_diff_image(expected, actual, diff_image) results = dict(rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), tol=tol) if not in_decorator: # Then the results should be a string suitable for stdout. template = ['Error: Image files did not match.', 'RMS Value: {rms}', 'Expected: \n {expected}', 'Actual: \n {actual}', 'Difference:\n {diff}', 'Tolerance: \n {tol}', ] results = '\n '.join([line.format(**results) for line in template]) return results
def compare_images( expected, actual, tol, in_decorator=False ): '''Compare two image files - not the greatest, but fast and good enough. = EXAMPLE # img1 = "./baseline/plot.png" # img2 = "./output/plot.png" # # compare_images( img1, img2, 0.001 ): = INPUT VARIABLES - expected The filename of the expected image. - actual The filename of the actual image. - tol The tolerance (a unitless float). This is used to determine the 'fuzziness' to use when comparing images. - in_decorator If called from image_comparison decorator, this should be True. (default=False) ''' verify(actual) # Convert the image to png extension = expected.split('.')[-1] if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int( expected ) actualImage = _png.read_png_int( actual ) actualImage, expectedImage = crop_to_same(actual, actualImage, expected, expectedImage) # compare the resulting image histogram functions expected_version = version.LooseVersion("1.6") found_version = version.LooseVersion(np.__version__) # On Numpy 1.6, we can use bincount with minlength, which is much faster than # using histogram if found_version >= expected_version: rms = 0 for i in xrange(0, 3): h1p = expectedImage[:,:,i] h2p = actualImage[:,:,i] h1h = np.bincount(h1p.ravel(), minlength=256) h2h = np.bincount(h2p.ravel(), minlength=256) rms += np.sum(np.power((h1h-h2h), 2)) else: rms = 0 bins = np.arange(257) for i in xrange(0, 3): h1p = expectedImage[:,:,i] h2p = actualImage[:,:,i] h1h = np.histogram(h1p, bins=bins)[0] h2h = np.histogram(h2p, bins=bins)[0] rms += np.sum(np.power((h1h-h2h), 2)) rms = np.sqrt(rms / (256 * 3)) diff_image = make_test_filename(actual, 'failed-diff') if ( (rms / 10000.0) <= tol ): if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image( expected, actual, diff_image ) if in_decorator: results = dict( rms = rms, expected = str(expected), actual = str(actual), diff = str(diff_image), ) return results else: # old-style call from mplTest directory msg = " Error: Image files did not match.\n" \ " RMS Value: " + str( rms / 10000.0 ) + "\n" \ " Expected:\n " + str( expected ) + "\n" \ " Actual:\n " + str( actual ) + "\n" \ " Difference:\n " + str( diff_image ) + "\n" \ " Tolerance: " + str( tol ) + "\n" return msg
def compare_images(expected, actual, tol, in_decorator=False): """ Compare two "image" files checking differences within a tolerance. The two given filenames may point to files which are convertible to PNG via the `.converter` dictionary. The underlying RMS is calculated with the `.calculate_rms` function. Parameters ---------- expected : str The filename of the expected image. actual :str The filename of the actual image. tol : float The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. in_decorator : bool If called from image_comparison decorator, this should be True. (default=False) Example ------- img1 = "./baseline/plot.png" img2 = "./output/plot.png" compare_images( img1, img2, 0.001 ): """ if not os.path.exists(actual): msg = "Output image %s does not exist." % actual raise Exception(msg) if os.stat(actual).st_size == 0: msg = "Output image file %s is empty." % actual raise Exception(msg) verify(actual) # Convert the image to png extension = expected.split('.')[-1] if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] actualImage, expectedImage = crop_to_same( actual, actualImage, expected, expectedImage) # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) rms = calculate_rms(expectedImage, actualImage) diff_image = make_test_filename(actual, 'failed-diff') if rms <= tol: if os.path.exists(diff_image): os.unlink(diff_image) return None save_diff_image(expected, actual, diff_image) results = dict(rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image)) if not in_decorator: # Then the results should be a string suitable for stdout. template = ['Error: Image files did not match.', 'RMS Value: {rms}', 'Expected: \n {expected}', 'Actual: \n {actual}', 'Difference:\n {diff}', 'Tolerance: \n {tol}', ] results = '\n '.join([line.format(**results) for line in template]) return results
def mura_preprocess(train_path, study_type): #train_path = "MURA-v1.1/" csv_train_filess = os.path.join(train_path, "MURA-v1.1/", "train_{}.csv".format(study_type)) csv_valid_filess = os.path.join(train_path, "MURA-v1.1/", "valid_{}.csv".format(study_type)) train_df = pd.read_csv(csv_train_filess, names=['img', 'count', 'label'], header=None) valid_df = pd.read_csv(csv_valid_filess, names=['img', 'count', 'label'], header=None) train_img_paths = train_df.img.values.tolist() valid_img_paths = valid_df.img.values.tolist() train_labels_patient = train_df.label.values.tolist() valid_labels_patient = valid_df.label.values.tolist() train_data_list = [] train_labels = [] valid_data_list = [] valid_labels = [] for i in range(len(train_img_paths)): patient_dir = os.path.join(train_path, train_img_paths[i]) msg = "\r Loading: %s (%d/%d) " % (patient_dir, i + 1, len(train_img_paths)) sys.stdout.write(msg) sys.stdout.flush() train_data_patient = [] for f in glob.glob(patient_dir + "*"): train_img = png.read_png_int(f) if len(train_img.shape) == 2: train_img = np.stack((train_img, ) * 3, -1) train_img = normalize(np.array(train_img)) # you can replace 256 with other number but any number greater then 256 will exceed the memory limit of 12GB train_data_patient.append(train_img) train_data_list.extend(train_data_patient) for _ in range(len(train_data_patient)): lst = [0, 0] lst[train_labels_patient[i]] = 1 #lst = train_labels_patient[i] train_labels.append(lst) train_data = np.asarray(train_data_list) for i in range(len(valid_img_paths)): patient_dir = os.path.join(train_path, valid_img_paths[i]) msg = "\r Loading: %s (%d/%d) " % (patient_dir, i + 1, len(valid_img_paths)) sys.stdout.write(msg) sys.stdout.flush() valid_data_patient = [] for f in glob.glob(patient_dir + "*"): valid_img = png.read_png_int(f) if len(valid_img.shape) == 2: valid_img = np.stack((valid_img, ) * 3, -1) valid_img = normalize(np.array(valid_img)) valid_data_patient.append(valid_img) valid_data_list.extend(valid_data_patient) for _ in range(len(valid_data_patient)): lst = [0, 0] lst[valid_labels_patient[i]] = 1 valid_labels.append(lst) valid_data = np.asarray(valid_data_list) np.save('MURA_{}_train.npy'.format(study_type), np.array(train_data)) print("【Saving data to MURA_{}_train.npy】".format(study_type)) np.save('MURA_{}_valid.npy'.format(study_type), np.array(valid_data)) print("【Saving data to MURA_{}_valid.npy】".format(study_type)) np.save('MURA_{}_train_lab.npy'.format(study_type), np.array(train_labels)) np.save('MURA_{}_valid_lab.npy'.format(study_type), np.array(valid_labels))
def compare_images(expected, actual, tol, in_decorator=False): """ Compare two "image" files checking differences within a tolerance. The two given filenames may point to files which are convertible to PNG via the `.converter` dictionary. The underlying RMS is calculated with the `.calculate_rms` function. Parameters ---------- expected : str The filename of the expected image. actual :str The filename of the actual image. tol : float The tolerance (a color value difference, where 255 is the maximal difference). The test fails if the average pixel difference is greater than this value. in_decorator : bool If called from image_comparison decorator, this should be True. (default=False) Examples -------- img1 = "./baseline/plot.png" img2 = "./output/plot.png" compare_images( img1, img2, 0.001 ): """ if not os.path.exists(actual): raise Exception("Output image %s does not exist." % actual) if os.stat(actual).st_size == 0: raise Exception("Output image file %s is empty." % actual) # Convert the image to png extension = expected.split('.')[-1] if not os.path.exists(expected): raise IOError('Baseline image %r does not exist.' % expected) if extension != 'png': actual = convert(actual, False) expected = convert(expected, True) # open the image files and remove the alpha channel (if it exists) expectedImage = _png.read_png_int(expected) actualImage = _png.read_png_int(actual) expectedImage = expectedImage[:, :, :3] actualImage = actualImage[:, :, :3] actualImage, expectedImage = crop_to_same( actual, actualImage, expected, expectedImage) diff_image = make_test_filename(actual, 'failed-diff') if tol <= 0.0: if np.array_equal(expectedImage, actualImage): return None # convert to signed integers, so that the images can be subtracted without # overflow expectedImage = expectedImage.astype(np.int16) actualImage = actualImage.astype(np.int16) rms = calculate_rms(expectedImage, actualImage) if rms <= tol: return None save_diff_image(expected, actual, diff_image) results = dict(rms=rms, expected=str(expected), actual=str(actual), diff=str(diff_image), tol=tol) if not in_decorator: # Then the results should be a string suitable for stdout. template = ['Error: Image files did not match.', 'RMS Value: {rms}', 'Expected: \n {expected}', 'Actual: \n {actual}', 'Difference:\n {diff}', 'Tolerance: \n {tol}', ] results = '\n '.join([line.format(**results) for line in template]) return results
), dtype=np.uint8, ) # Loop over all lines and draw them on the blank image. for line in lines: for x1, y1, x2, y2 in line: cv2.line(line_img, (x1, y1), (x2, y2), color, thickness) # Merge the image with the lines onto the original. img = cv2.addWeighted(img, 0.8, line_img, 1.0, 0.0) # Return the modified image. return img if __name__=="__main__": image = png.read_png_int('/Users/junho/PycharmProjects/road_detection/data_road/training/image_2/um_000000.png') height, width = image.shape[:2] plt.figure() plt.imshow(image) region_of_interest_vertices = [ [0, height], [width / 3, height/2], [width*(2/3), height/2], [width, height], ] # # cropped_image = region_of_interest( # image, # [np.array(region_of_interest_vertices, np.int32)], # )