def high_zero_crossing_rate(frames): """ Return the high zero-crossing rate of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, the function computes high zero-crossing rate (HZCR) per segment. The output values are stored in 1D numpy array (elements hold the HZCR of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: HZCR: (numpy array) high zero-crossing rate vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute and segment zero crossing rate LEN = 100 ZCR = seg.segment(zero_crossing_rate(frames), LEN, 0) # Compute high zero-crossing rate HZCR = np.sum(np.sign(ZCR-1.5*np.mean(ZCR, axis=0))+1)/(2*LEN); # Return high zero-crossing rate vector return np.array(HZCR)
def low_squared_energy_operator(frames): """ Return the low squared energy operator of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes low squared energy operator (LSEO) per segment. The output values are stored in 1D numpy array (elements hold the LSEO of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: LSEO: (numpy array) low squared energy operator vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute and segment squared energy operator LEN = 100 SEO = seg.segment(squared_energy_operator(frames), LEN, 0) # Compute low squared energy operator LSEO = np.sum(np.sign(0.5*np.mean(SEO, axis=0)-SEO)+1)/(2*LEN); # Return low squared energy operator vector return np.array(LSEO)
def test_im_shape_segment(): im = np.array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]) with pytest.raises(RuntimeError) as excinfo: segmentation.segment(im) excinfo.match( "Need to provide an array with shape \(n, m\). Provided array has shape \(2, 2, 2\)" )
def test_provided_function_returns_correct_types(): im = np.array([[1, 2, 3], [1, 2, 3]]) def bad_func(im): return ('Hello, world!') with pytest.raises(RuntimeError) as excinfo: segmentation.segment(im, thresh_func=bad_func) excinfo.match("The provided function must output a numeric or array \ provided function returns type <class 'str'>")
def test_provided_function_returns_correct_shape(): im = np.array([[1, 2, 3], [1, 2, 3]]) def bad_func(im): return (np.array([[1, 2], [1, 2]])) with pytest.raises(RuntimeError) as excinfo: segmentation.segment(im, thresh_func=bad_func) excinfo.match( "Array output of the function must have same shape as the image \ the output array has shape \(2, 2\), image has shape \(2, 3\)" )
def run(self, options): """ Define the code to be run by this plugin app. """ if options.b_version: print(Neuproseg.VERSION) sys.exit(0) print('Multistream = ' + str(options.b_multistream)) segmentation.segment(inputDirectory=options.inputdir, outputDirectory=options.outputdir, multistream=options.b_multistream)
def thumbnail(audio, fs, length, include_self=True, seg_method='regular'): # Segment the audio segments_in_seconds = seg.segment(audio, fs, length=length, method=seg_method) segments = segments_in_seconds * fs # Calculate the self-similarity matrix num_segments = segments_in_seconds.shape[0] similarity = np.zeros((num_segments, num_segments)) for i in range(0, num_segments): cur_start = int(segments[i]) cur_end = int(segments[i] + (length * fs)) cur_sound = audio[cur_start: cur_end] # Calculate similarity with matched filter cur_matches = np.abs(matched_filter(cur_sound, audio, segments)) if include_self is False: cur_matches[i] = 0 similarity[:, i] = cur_matches # Row normalization (after similarity calculation) similarity = 0.5 * (similarity.T + similarity) similarity = seg.row_normalize(segments, similarity) # Identify the thumbnail sim_curve = np.sum(similarity, axis=1) / np.sum(similarity) thumb_idx = np.argmax(sim_curve) thumb_start = int(segments[thumb_idx]) thumb_end = int(segments[thumb_idx] + (length * fs)) thumb = audio[thumb_start: thumb_end] return thumb, sim_curve, segments_in_seconds, similarity
def squared_energy_operator(frames): """ Return the squared energy operator of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes squared energy operator (SEO) per segment. The output values are stored in 1D numpy array (elements hold the SEO of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: SEO: (numpy array) squared energy operator vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute squared energy operator (per segment) SEO = [] for i in xrange(0,frames.shape[1]): frame = frames[:,i].copy() energy = np.sum(frame**2)/np.float64(len(frame)) SEO.append(energy) # Return squared energy operator vector return np.array(SEO)
def zero_crossing_rate(frames): """ Return the zero-crossing rate of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, the function computes zero-crossing rate (ZCR) per segment. The output values are stored in 1D numpy array (elements hold the ZCR of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: ZCR: (numpy array) zero-crossing rate vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute zero-crossing rate (per segment) ZCR = [] for i in xrange(0,frames.shape[1]): frame = frames[:,i].copy() count = np.sum(np.abs(np.diff(np.sign(frame))))/2 ZCR.append(np.float64(count)/np.float64(len(frame)-1.0)) # Return zero-crossing rate vector return np.array(ZCR)
def evalulate(model, image): segments = segmentation.segment(image) predicted = [] for i in range(len(segments)): digit = predict(model, segments[i]) predicted.append(digit) return ''.join(predicted)
def preprocess(s): array = seg.segment(s) if (len(array) < 1): keras.backend.clear_session() return "Not segmentable!" image = array[0] image = i.img_to_array(image) image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR) image = np.expand_dims(image, axis=0) return image
def segmentData(input_directory): symbols = load_images_from_folder(input_directory) for i in range(len(symbols)): images = segmentation.segment(symbols[i]) for thing in range(len(CLASSES)): cv2.imwrite(thing + '/' + thing + '_' + str(i) + '.png', images[thing])
def segmentData(input_directory, classes): symbols = load_images_from_folder(input_directory) for i in range(len(symbols)): images = segmentation.segment(symbols[i]) for class_ in range(len(classes)): cv2.imwrite( classes[class_] + '/' + classes[class_] + '_' + str(i) + '.png', images[class_])
def main(video_path, model_path, background, foreground, output_path, frame_rate, keep_temp=False, gpus=1): video_name = get_base_name(video_path) style_name = get_base_name(model_path) audio_file = create_audio_file(video_path) # Get all the frames_path print("Extracting frames...") frame_dir = extract_video_frames(video_path) print("Styling frames...") style_dir = style_frames(model_path, frame_dir, style_dir="{}_styled/".format(video_name)) if background or foreground: print( "Applying segmentation...(will take a while (~10 min per 500 frames)" ) segmentation_dir = segment(video_name, frame_dir, "{}_segmented/".format(video_name), gpus) print("Merging styled and segmented frames...") segmented_styled_frames = apply_style_over_segmentation( original_folder=frame_dir, style_folder=style_dir, segmentation_folder=segmentation_dir, output_folder="{}_final".format(video_name), mode=0 if foreground else 1) styled_video = frames_to_video(frames_path=segmented_styled_frames, video_name=video_name, output_path=output_path, frame_rate=frame_rate) else: styled_video = frames_to_video(frames_path=style_dir, video_name=video_name, output_path=output_path, frame_rate=frame_rate) final_video_name = os.path.join( output_path, video_name + "_{}_style.mp4".format(style_name)) add_audio_to_video(styled_video, audio_file, final_video_name) assert (os.path.isfile(final_video_name)) if not keep_temp: cleanup_files = { "directories": [frame_dir, style_dir], "files": [styled_video, audio_file] } cleanup_temp_files(cleanup_files) return final_video_name
def open_xml(self, file_data): sents = [] dghs = [] with open(file_data[0]) as fobj: if file_data[2] > str(self.date_hsd.value()): return [file_data[3], [{}]] xml = fobj.read() root = etree.fromstring(xml.encode('utf-8')) descs = extract_desc(xml) for desc in descs: if desc != []: sents = segment(desc).split("\n") # for sent in sents: dghs.append(extract_func(sents[0])) return [file_data[3], dghs, file_data[2], file_data[0]]
def count_cars(image, **kwargs): segments = segment(image) padded, segment_val = padded_segments(image, segments, list(range(segments.max() + 1)), mask=kwargs.get("mask", None)) predictions = model.predict(padded) count = 0 result = image.copy() for val, pred in zip(segment_val, predictions): result[segments == val] = [255 * pred[1], 255 * pred[0], 0] count += pred[0] > threshold return (count, result)
def spectral_distance(frames): """ Return the spectral distance of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes spectral distance (SD) per segment The output values are stored in 1D numpy array (elements hold the SD of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: Tuple composed of SD_mag: (numpy array) spectral distance based on module vector SD_phs: (numpy array) spectral distance based on phase vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute spectral distance (per segment) SD_mag = [] SD_phs = [] for i in xrange(1,frames.shape[1]): p_frame = frames[:,i-1].copy() ps_mag = np.abs(fft(p_frame)[0:frames.shape[0]]) ps_phs = np.angle(fft(p_frame)[0:frames.shape[0]]) ps_mag /= ps_mag.max() ps_phs /= ps_phs.max() a_frame = frames[:,i].copy() as_mag = np.abs(fft(a_frame)[0:frames.shape[0]]) as_phs = np.angle(fft(a_frame)[0:frames.shape[0]]) as_mag /= as_mag.max() as_phs /= as_phs.max() SD_mag.append(np.sum(abs(ps_mag-as_mag))) SD_phs.append(np.sum(abs(ps_phs-as_phs))) # Return pectral tuple of distance vectors return (np.array(SD_mag), np.array(SD_phs))
def thumbnail(audio, fs, length, include_self=True, seg_method='regular'): # Segment the audio segments_in_seconds = seg.segment(audio, fs, length=length, method=seg_method) segments = segments_in_seconds * fs # Calculate the self-similarity matrix num_segments = segments_in_seconds.shape[0] similarity = np.zeros((num_segments, num_segments)) segment_fp = [] # Pre-compute Shazam fingerprints for i in range(0, num_segments): cur_start = int(segments[i]) cur_end = int(segments[i] + (length * fs)) cur_sound = audio[cur_start:cur_end] cur_fp, _, _ = shazam.fingerprint(cur_sound) segment_fp.append(cur_fp) for i in range(0, num_segments): # Calculate similarity (forwards only, for a symmetric measure) cur_matches = np.zeros(num_segments) for j in range(i, num_segments): if include_self is False and i == j: continue cur_matches[j] = shazam.hash_search(segment_fp[i], segment_fp[j]) similarity[:, i] = cur_matches # Row normalization (after similarity calculation) similarity = 0.5 * (similarity.T + similarity) similarity = seg.row_normalize(segments, similarity) # Identify the thumbnail sim_curve = np.sum(similarity, axis=1) / np.sum(similarity) thumb_idx = np.argmax(sim_curve) thumb_start = int(segments[thumb_idx]) thumb_end = int(segments[thumb_idx] + (length * fs)) thumb = audio[thumb_start:thumb_end] return thumb, sim_curve, segments_in_seconds, similarity
def spectral_flatness(frames): """ Return the spectral flatness of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes spectral flatness (SF) per segment The output values are stored in 1D numpy array (elements hold the SF of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: SF: (numpy array) spectral flatness vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute spectral flatness (per segment) SF = [] for i in xrange(0,frames.shape[1]): frame = frames[:,i].copy() spect = abs(fft(frame)[0:frames.shape[0]])**2 spect /= spect.max() gMean = np.float64(0) aMean = 0 for i in range(len(spect)): sample = np.float64(spect[i]) gMean += np.float64(log(sample)) aMean += sample gMean /= np.float64(len(spect)) gMean = exp(gMean) aMean /= float(len(spect)) SF.append(gMean/aMean) # Return spectral flatness vector return np.array(SF)
def resize(im_dir, out_dir, csv_file, unet=None): csv_data = pd.DataFrame.from_csv(csv_file, index_col=None) if unet: unet = SegmentUnet(None, unet) for image, row in csv_data.iterrows(): im_path = join(im_dir, row['image']) + '.jpeg' level = 'Healthy' if row['level'] < 2 else 'Diseased' im_arr = cv2.imread(im_path)[:, :, ::-1] resized_im = imresize(im_arr, (480, 640), interp='bicubic') if unet: resized_im = segment(resized_im, unet) level_dir = make_sub_dir(out_dir, level) visualize(resized_im, join(level_dir, row['image']))
def spectral_flux(frames): """ Return the spectral flux of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes spectral flux (SF) per segment. The output values are stored in 1D numpy array (elements hold the SF of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Returns: SF: (numpy array) spectral flux vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute spectral flux (per segments) SF = [] for i in xrange(1,frames.shape[1]): p_frame = frames[:,i-1].copy() p_spect = abs(fft(p_frame)[0:frames.shape[0]]) p_spect /= p_spect.max() a_frame = frames[:,i].copy() a_spect = abs(fft(a_frame)[0:frames.shape[0]]) a_spect /= a_spect.max() a_overall = a_spect/np.sum(a_spect) p_overall = p_spect/np.sum(p_spect) SF.append(np.sum((a_overall - p_overall)**2)) # Return spectral flux vector return np.array(SF)
def spectral_rolloff(frames, c=0.8): """ Return the spectral roll-off of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes spectral roll-off (SR) per segment The output values are stored in 1D numpy array (elements hold the SR of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) c: (float) roll-off factor (default=0.8) Returns: SR: (numpy array) spectral roll-off vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute spectral roll-off (per segment) SR = [] for i in xrange(0,frames.shape[1]): frame = frames[:,i].copy() spect = abs(fft(frame)[0:frames.shape[0]]) spect /= spect.max() [pos,] = np.nonzero(np.cumsum(spect**2) > c*np.sum(spect**2)) if len(pos) > 0: SR.append(np.float64(pos[0])/(float(len(spect)))) else: SR.append(0.0) # Return spectral roll-off vector return np.array(SR)
def spectral_spread(frames, Fs): """ Return the spectral spread of an input signal The input signal can be an 1D numpy array (waveform), or 2D numpy array. If the input signal is one-dimensional, function performs a segmentation to automatically segment the signal into frames of predefined length and overlap. Otherwise, function computes spectral spread (SS) per segment. The output values are stored in 1D numpy array (elements hold the SS of all segments). Args: frames: (numpy array) input data vector (one/two-dimensional) Fs: (int) sampling rate (frequency) Returns: SS: (numpy array) spectral spread vector """ # Perform segmentation if necesary frames = seg.segment(frames) # Compute spectral spread (per segment) SS = [] ID = (np.arange(1,frames.shape[0]+1))*(Fs/(2.0*frames.shape[0])) for i in xrange(0,frames.shape[1]): frame = frames[:,i].copy() spect = abs(fft(frame)[0:frames.shape[0]]) spect /= spect.max() NUM = np.sum(ID*spect) DEN = np.sum(spect)+0.010 SC = ((NUM/DEN)/(Fs/2.0)) SS.append(np.sqrt(np.sum(((ID-SC)**2)*spect)/DEN)) # Return spectral spread vector return np.array(SS)
def confusion_matrix(image, model, **kwargs): threshold = kwargs.get("threshold", default_threshold) segments = segment(image) segment_values = range(segments.max() + 1) selection = default_selection ground_truth = [True if i in selection else False for i in segment_values] padded, padded_segment_values = padded_segments(image, segments, segment_values) partial_predictions = model.predict(padded)[:,0] > threshold predictions = [] index = 0 for i in segment_values: if i in padded_segment_values: predictions.append(partial_predictions[index]) index += 1 else: predictions.append(False) return [[sum(array_and(ground_truth, predictions)), sum(array_and(ground_truth, array_not(predictions)))], [sum(array_and(array_not(ground_truth), predictions)), sum(array_not(array_or(ground_truth, predictions)))]]
import segmentation import cv2 import os # Classes CLASSES = ['one','two','three','four','five','six','seven', 'eight','nine','plus','minus','multiplication', 'division1', 'division2', 'period'] def load_images_from_folder(folder): images = [] for filename in os.listdir(folder): img = os.path.join(folder,filename) if img is not None: images.append(img) print (images) return images def segmentData(input_directory): print("5") symbols = load_images_from_folder(input_directory) for i in range(len(symbols)): images = segmentation.segment(symbols[i]) for thing in range(len(CLASSES)): cv2.imwrite(thing + '/' + thing + '_' + str(i) + '.png', images[thing]) segmentData('images')
from segment import segment msg('starting segmentation') #sys('chmod 777 blackandwhite.jpg') imageAddress = str(sys.argv[1]) #img = cv.imread(imageAddress) #img = preprocess(img) #msg(str(img.shape)) #cv.imwrite('/home/rathod/saving.jpg',img) msg('removing mitotic') system('rm -rf ./segmented_data/mitotic/*') msg('removing nonmitotic') system('rm -rf ./segmented_data/non_mitotic/*') msg('removing pickles') system('rm -rf ./processed_dataset/*') msg('reading image ' + imageAddress) n = len(imageAddress) csvAddress = imageAddress[:n - 3] + "csv" msg('reading csv') destinaton = "/var/www/html/Models-Comparison-Cls-Imb/pp/segmented_data/" misCount = 0 #msg("misCount is "+(str(misCount))) msg('starting segmentation') misCount = segment(imageAddress, csvAddress, destinaton) msg('end') msg('creating pickle') create_pickle('./segmented_data/', './processed_dataset/') f = open('status.xml', 'w') f.write("<msg>1</msg>") f.close()
sys.path.insert(0, caffe_root + 'python') import caffe caffe.set_mode_cpu() from classify import prediction import segmentation if os.path.isdir("segmentation") is not True: os.makedirs("segmentation") input_image = sys.argv[1] print "image is " + input_image showname([input_image], 1, "Original Image") segments = segmentation.segment(input_image) showname(segments, 3, "Segmentation Results") #weight = "weights/lenet_iter_3000.caffemodel" categories = prediction(segments, model, weight) print categories """ result = {} for i in xrange(len(categories)): print i print categories[i] result[categories[i]] = segments[i] showwithtitle(result,5) """
def seg(): return segmentation.segment(request.json.get('data'), './dic.json', cls_rnn, segmodel, cwsInfo)
# LDA analysis for each user's blog set user_blogs = sorted(os.listdir('./data/user_blogs/')) with open('./data/user_feature_mean.txt', 'w') as fuser_mean: for user in user_blogs: # for each user blogs = pd.read_csv('./data/user_blogs/' + user, header=None, sep='\001', names=['id', 'title', 'text']) # Increase the weight of the title and remove the ellipsis texts = [ re.sub('\.\.+', '.', str(row[1]['title'] * 6 + row[1]['text']).lower()) for row in blogs.iterrows() ] corpus = [' '.join(line) for line in segment(texts)] # get document-term matrix vec = CountVectorizer(stop_words=stop_words) vec_tf = vec.fit_transform(corpus) # LDA analysis n_components = 4 lda = LatentDirichletAllocation(n_components=n_components, learning_method='batch', max_iter=50, n_jobs=4) lda.fit(vec_tf) # select 40 words words = [] len_feature = lda.components_.shape[1] vec_feature_names = vec.get_feature_names() for k in range(n_components):
from sklearn.feature_extraction.text import TfidfVectorizer import pandas as pd from segmentation import segment, stop_words # make_Tfidfvectorizer def make_idf(corpus): vectorizer = TfidfVectorizer(stop_words=stop_words) vectorizer.fit_transform(corpus) return vectorizer if __name__ == '__main__': with open("./data/blog_article_original.txt", "r", encoding='utf-8') as fblog: text = fblog.readlines() # segmentation corpus = [' '.join(line) for line in segment(text)] # make idf.txt vec = make_idf(corpus) pd.DataFrame({'col1':vec.get_feature_names(), 'col2':vec.idf_}).to_csv("./model/idf.txt", encoding='utf-8', sep=' ', index=None, header=None)
def main(dataset, results_path, method='color', k=400): segmentation_path = os.path.join(results_path, 'our_segmentation') figures_path = os.path.join(results_path, 'figures') all_mse = [] all_jaccard = [] all_acc = [] print("{:10} {:20} {:20}".format('Imagen', 'MSE', 'JACCARD')) for image_idx in range(dataset.num_images): image = dataset.image_names[image_idx] # reads the image information from the dataset original_image = dataset.get_image_data(image_idx) # Gets the mask to avoid dark areas in segmentation mask = get_mask(original_image.shape[0:2]) I = gray2rgb(mask) * original_image GT = (rgb2gray( dataset.get_ground_truth_data(image_idx).astype(float) * 255) * mask) > 0 #Segment the each mole print('Segmenting image {0} ({1} / {2})'.format( dataset.image_names[image_idx], image_idx + 1, dataset.num_images)) Isegmented, LMerged, Islic2, IOtsu, Superpixels = segment( I, mask, method=method, k=k) auxmse = compare_mse(GT, Isegmented) all_mse.append(auxmse) aux_jaccard = compare_jaccard(GT, Isegmented) aux_acc = 1.0 - np.sum(np.logical_xor(GT, Isegmented)) / float(GT.size) all_jaccard.append(aux_jaccard) all_acc.append(aux_acc) print("Image name, MSE, JACCARD_IDX, ACC") print("{:10} {:0.25f} {:0.25f} {:0.25f}".format( image, auxmse, aux_jaccard, aux_acc)) if not os.path.exists(segmentation_path): os.makedirs(segmentation_path) if not os.path.exists(figures_path): os.makedirs(figures_path) subplot(2, 3, 1) title('Original + Superpixels') imshow(Superpixels) subplot(2, 3, 2) title('Ground Truth') imshow(GT, cmap='gray') subplot(2, 3, 3) title('Our Segmentation') imshow(Isegmented, cmap='gray') subplot(2, 3, 4) title('Labels') imshow(LMerged) subplot(2, 3, 5) title('Merged Superpixels') imshow(Islic2) subplot(2, 3, 6) title('Otsu') imshow(IOtsu, cmap='gray') savefig(figures_path + '/' + image + '_all.png') imsave(segmentation_path + '/' + image + '_our.png', 255 * Isegmented.astype(int), cmap='gray') C = np.zeros_like(Isegmented).astype(int) a = np.where(np.logical_and(GT, Isegmented)) # TP b = np.where(np.logical_and(GT, np.logical_not(Isegmented))) #FN d = np.where(np.logical_and(Isegmented, np.logical_not(GT))) #FP C[a] = 1 C[b] = 2 C[d] = 3 figure() title('Seg. comparison') imshow(C) savefig(figures_path + '/' + image + '_k_{}_seg_comp.png'.format(k)) figure() title('SLIC Segmentation, k = {}'.format(k)) imshow(Superpixels) savefig(figures_path + '/' + image + '_k_{}_seg.png'.format(k)) figure() title('Merged superpixels') imshow(Islic2) savefig(figures_path + '/' + image + '_k_{}_merged.png'.format(k)) figure() title('Otsu') imshow(IOtsu, cmap='gray') savefig(figures_path + '/' + image + '_k_{}_otsu.png'.format(k)) print('jaccard overall: {}'.format(np.mean(np.array(all_jaccard)))) print('acc. overall: {}'.format(np.mean(np.array(all_acc))))