def test_extract_patches_square(): # test same patch size for all dimensions face = downsampled_face i_h, i_w = face.shape p = 8 expected_n_patches = ((i_h - p + 1), (i_w - p + 1)) patches = extract_patches(face, patch_shape=p) assert_true(patches.shape == (expected_n_patches[0], expected_n_patches[1], p, p))
def image_conv_patches(image): # Convolution patches patches = extract_patches(image, 16) w, h = patches.shape[0], patches.shape[1] patches = patches.reshape((w*h,16 * 16)) # GCN patches = patches - patches.mean(axis=1)[:, np.newaxis] patches /= np.sqrt(patches.var(axis=1) + 10)[:, np.newaxis] return (w, h, patches)
def __init__(self, n_in, n_features, n_patches, sampling_method = None, *args, **kwargs): """ n_in: number of features in original space n_features: total number of features n_patches: how many random local patches to use in the original feature space so in each patch, there are n_features/n_patches clusters constructed sampling_method: {None, '1d', '2d'}: the way of finding random patchs None: no continousness constraint '1d': features sampled in the same patch are continous in 1D '2d': features sampled in the same patch are continous in 2D (e.g. for image), assume image dimension is sqrt(nin) x sqrt(nin) TODO: to fix the conceptual bug that number_of_orignal_features_in_each_patch = number_clusters_in_each_patch """ self.n_in = n_in self.n_features = n_features self.n_patches = n_patches self.sampling_method = sampling_method if self.sampling_method is None: #pure randomness self.feat_indices_ = np.array_split(np.random.randint(low = 0, high = n_in, size = n_features), n_patches) elif self.sampling_method is '1d': nfeat_perpatch = n_features / n_patches nfeat_last = n_features - nfeat_perpatch * (n_patches-1) feat_starts = np.random.randint(low=0, high=n_in-nfeat_perpatch, size=n_patches) self.feat_indices_ = [np.arange(start, start+nfeat_perpatch) for start in feat_starts[:-1]] self.feat_indices_.append(np.arange(feat_starts[-1], feat_starts[-1]+nfeat_last)) elif self.sampling_method is '2d': nrows = int(math.sqrt(n_in)) ncols = n_in / nrows grid = np.arange(nrows*ncols).reshape((nrows, ncols)) nfeat_perpatch = n_features / n_patches nfeat_perrow = int(math.sqrt(nfeat_perpatch)) nfeat_percol = nfeat_perpatch / nfeat_perrow nfeat_last = n_features - nfeat_perrow*nfeat_percol*n_patches self.feat_indices_ = (image.extract_patches(grid, (nfeat_perrow, nfeat_percol)) .reshape(-1, nfeat_perrow*nfeat_percol)) self.feat_indices_ = self.feat_indices_[np.random.choice(len(self.feat_indices_), n_patches)] if nfeat_last > 0: self.feat_indices_.append(np.random.randint(low = 0, high = n_in, size = nfeat_last)) else: raise ValueError('param sampling_method=%s is not understandable' % self.sampling_method) self.models_ = [cluster.MiniBatchKMeans(len(findex), *args, **kwargs) for findex in self.feat_indices_]
def featurize_image(shrink, alpha, dictionary, image): w, h, patches = image_conv_patches(image) nclusters = dictionary.shape[0] patches = dict_threshold(alpha, dictionary, patches) # Now, perform pooling (with averaging) patches = patches.reshape((w, h, -1)) wr = int(w / shrink) hr = int(h / shrink) step = min(wr-1,hr-1) patches = extract_patches(patches,patch_shape=(wr,hr,nclusters),extraction_step=step) nw, nh = patches.shape[0], patches.shape[1] patches = patches.reshape((nw,nh,wr,hr,nclusters)) patches = patches.mean(axis=(2,3)) patches = patches.reshape((nw*nh*nclusters)) return patches
def test_extract_patches_strided(): image_shapes_1D = [(10,), (10,), (11,), (10,)] patch_sizes_1D = [(1,), (2,), (3,), (8,)] patch_steps_1D = [(1,), (1,), (4,), (2,)] expected_views_1D = [(10,), (9,), (3,), (2,)] last_patch_1D = [(10,), (8,), (8,), (2,)] image_shapes_2D = [(10, 20), (10, 20), (10, 20), (11, 20)] patch_sizes_2D = [(2, 2), (10, 10), (10, 11), (6, 6)] patch_steps_2D = [(5, 5), (3, 10), (3, 4), (4, 2)] expected_views_2D = [(2, 4), (1, 2), (1, 3), (2, 8)] last_patch_2D = [(5, 15), (0, 10), (0, 8), (4, 14)] image_shapes_3D = [(5, 4, 3), (3, 3, 3), (7, 8, 9), (7, 8, 9)] patch_sizes_3D = [(2, 2, 3), (2, 2, 2), (1, 7, 3), (1, 3, 3)] patch_steps_3D = [(1, 2, 10), (1, 1, 1), (2, 1, 3), (3, 3, 4)] expected_views_3D = [(4, 2, 1), (2, 2, 2), (4, 2, 3), (3, 2, 2)] last_patch_3D = [(3, 2, 0), (1, 1, 1), (6, 1, 6), (6, 3, 4)] image_shapes = image_shapes_1D + image_shapes_2D + image_shapes_3D patch_sizes = patch_sizes_1D + patch_sizes_2D + patch_sizes_3D patch_steps = patch_steps_1D + patch_steps_2D + patch_steps_3D expected_views = expected_views_1D + expected_views_2D + expected_views_3D last_patches = last_patch_1D + last_patch_2D + last_patch_3D for (image_shape, patch_size, patch_step, expected_view, last_patch) in zip(image_shapes, patch_sizes, patch_steps, expected_views, last_patches): image = np.arange(np.prod(image_shape)).reshape(image_shape) patches = extract_patches(image, patch_shape=patch_size, extraction_step=patch_step) ndim = len(image_shape) assert_true(patches.shape[:ndim] == expected_view) last_patch_slices = [slice(i, i + j, None) for i, j in zip(last_patch, patch_size)] assert_true((patches[[slice(-1, None, None)] * ndim] == image[last_patch_slices].squeeze()).all())
def extract_patches_2d(image, patch_size, patch_stride=1, max_patches=None, random_state=None, reshape=True): from sklearn.utils.validation import check_array, check_random_state from sklearn.feature_extraction.image import extract_patches, _compute_n_patches i_h, i_w = image.shape[:2] p_h, p_w = patch_size if p_h > i_h: raise ValueError("Height of the patch should be less than the height" " of the image.") if p_w > i_w: raise ValueError("Width of the patch should be less than the width" " of the image.") image = check_array(image, allow_nd=True) image = image.reshape((i_h, i_w, -1)) n_colors = image.shape[-1] stride = patch_stride if type(patch_stride) is not int: assert len(stride) == 2 stride = np.ones(len(image.shape), dtype=int) stride[:2] = patch_stride extracted_patches = extract_patches(image, patch_shape=(p_h, p_w, n_colors), extraction_step=stride) if reshape: extracted_patches = extracted_patches.reshape(extracted_patches.shape[0], extracted_patches.shape[1], -1) n_patches = _compute_n_patches(i_h, i_w, p_h, p_w, max_patches) if max_patches: rng = check_random_state(random_state) i_s = rng.randint(extracted_patches.shape[0], size=n_patches) j_s = rng.randint(extracted_patches.shape[1], size=n_patches) patches = extracted_patches[i_s, j_s, :] else: patches = extracted_patches return patches
def array_to_patches(arr, patch_shape=(3,3,3), extraction_step=1, normalization=False): #Make use of skleanr function extract_patches #https://github.com/scikit-learn/scikit-learn/blob/51a765a/sklearn/feature_extraction/image.py """Extracts patches of any n-dimensional array in place using strides. Given an n-dimensional array it will return a 2n-dimensional array with the first n dimensions indexing patch position and the last n indexing the patch content. Parameters ---------- arr : 3darray 3-dimensional array of which patches are to be extracted patch_shape : integer or tuple of length arr.ndim Indicates the shape of the patches to be extracted. If an integer is given, the shape will be a hypercube of sidelength given by its value. extraction_step : integer or tuple of length arr.ndim Indicates step size at which extraction shall be performed. If integer is given, then the step is uniform in all dimensions. Returns ------- patches : strided ndarray 2n-dimensional array indexing patches on first n dimensions and containing patches on the last n dimensions. These dimensions are fake, but this way no data is copied. A simple reshape invokes a copying operation to obtain a list of patches: result.reshape([-1] + list(patch_shape)) """ patches = extract_patches(arr, patch_shape, extraction_step) patches = patches.reshape(-1, patch_shape[0],patch_shape[1],patch_shape[2]) patches = patches.reshape(patches.shape[0], -1) if normalization==True: patches = patches.astype(np.float32) patches -= np.mean(patches, axis=0) patches /= np.std(patches, axis=0) #print('%.2d patches have been extracted' % patches.shape[0]) return patches
def classify_test_data_3d(activate2, W_list, b_list, path, patch_size_x, patch_size_y, patch_size_z, prefix, recon_flag, writer, itk_py_converter): Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Folder = [] Recon = [] Subdir_array = [] # patch_size = 11 for subdir, dirs, files in os.walk(path): # if(len(Flair) is 1): # break for file1 in files: if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') Subdir_array.append(subdir[-5:]) elif file1[-3:]=='mha' and ('t1_z' in file1 or 'T1' in file1): T1.append(file1) elif file1[-3:]=='mha' and ('t2' in file1 or 'T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('t1c_z' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:]=='mha' and 'Recon' in file1: Recon.append(file1) number_of_images = len(Flair) for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] print '... predicting' Flair_image = mha.new(Folder[image_iterator]+Flair[image_iterator]) T1_image = mha.new(Folder[image_iterator]+T1[image_iterator]) T2_image = mha.new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = mha.new(Folder[image_iterator]+T_1c[image_iterator]) if recon_flag is True: Recon_image = mha.new(Folder[image_iterator]+Recon[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data if recon_flag is True: Recon_image = Recon_image.data xdim, ydim, zdim = Flair_image.shape prediction_image = [] Flair_patch = image.extract_patches(Flair_image, [patch_size_x,patch_size_y,patch_size_z]) T1_patch = image.extract_patches(T1_image, [patch_size_x,patch_size_y,patch_size_z]) T2_patch = image.extract_patches(T2_image, [patch_size_x,patch_size_y,patch_size_z]) T_1c_patch = image.extract_patches(T_1c_image, [patch_size_x,patch_size_y,patch_size_z]) if recon_flag is True: Recon_patch = image.extract_patches(Recon_image, [patch_size_x,patch_size_y,patch_size_z]) print 'Raw patches extracted' #print Flair_patch.shape #print T1_patch.shape #print T2_patch.shape #print T_1c_patch.shape for j in range(Flair_patch.shape[2]): #print 'Slice : ',j+1 F_slice = Flair_patch[:,:,j,:,:,:] T1_slice = T1_patch[:,:,j,:,:,:] T2_slice = T2_patch[:,:,j,:,:,:] T_1c_slice = T_1c_patch[:,:,j,:,:,:] if recon_flag is True: Recon_slice = Recon_patch[:,:,j,:,:,:] F_slice = F_slice.reshape(F_slice.shape[0]*F_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) T1_slice = T1_slice.reshape(T1_slice.shape[0]*T1_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) T2_slice = T2_slice.reshape(T2_slice.shape[0]*T2_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) T_1c_slice = T_1c_slice.reshape(T_1c_slice.shape[0]*T_1c_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) if recon_flag is True: Recon_slice = Recon_slice.reshape(Recon_slice.shape[0]*Recon_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) if recon_flag == True: temp_patch = np.concatenate([F_slice,T1_slice,T2_slice,T_1c_slice,Recon_slice],axis=1) else: temp_patch = np.concatenate([F_slice,T1_slice,T2_slice,T_1c_slice],axis=1) #print 'Size of temp_patch : ',temp_patch.shape prediction_slice = predictOutput(temp_patch, activate2, W_list, b_list) prediction_image.append(prediction_slice) prediction_image = np.array(prediction_image) prediction_image = np.transpose(prediction_image) prediction_image = prediction_image.reshape([xdim-patch_size_x+1, ydim-patch_size_y+1, zdim-patch_size_z+1]) output_image = np.zeros([xdim,ydim,zdim]) output_image[1+((patch_size_x-1)/2):xdim-((patch_size_x-1)/2)+1,1+((patch_size_y-1)/2):ydim-((patch_size_y-1)/2)+1,1+((patch_size_z-1)/2):zdim-((patch_size_z-1)/2)+1] = prediction_image # np.save(Folder[image_iterator]+Subdir_array[image_iterator]+'_'+prefix+'_output_image.npy',output_image)#TODO: save it in meaningful name in corresponding folder a=np.transpose(output_image) # for j in xrange(a.shape[0]): # a[j,:,:] = np.transpose(a[j,:,:]) #a=a.reshape(155,240,240) print 'writing mha...' output_image = itk_py_converter.GetImageFromArray(a.tolist()) writer.SetFileName(Folder[image_iterator]+Subdir_array[image_iterator]+'_'+prefix+'_.mha') writer.SetInput(output_image) writer.Update() print '########success########'
def extract_multiscale_patches_from_mri(data_index_list, data_dir, is_test=False, is_oversampling=True, \ row_size=16, channel_size=8, num_patch=100, proportion=0.1, \ addClinical=False, patch_r_stride=4, patch_c_stride=4, \ is_fixed_size=True, n_time_point=6, fixed_width=256, fixed_depth=32): """ is_oversampling : indicator for oversampling patches near the lesion, this deicides whether 'extract_train_core_multscale' is used or not is_test : indicator for extract y_label or not. Extract y_label when 'is_test' is false. """ if is_test is not True: img_list, label_list=load_mri_from_directory(data_index_list, fixed_width, fixed_depth, \ is_test=is_test, data_dir=data_dir, is_fixed_size=is_fixed_size) else: img_list=load_mri_from_directory(data_index_list, fixed_width, fixed_depth, \ is_test=is_test, data_dir=data_dir, is_fixed_size=is_fixed_size) n = len(img_list) if is_test is not True: """ Extract patches for training and validation time """ args = [] if is_oversampling is True: for k in xrange(n): args.append((extract_train_core_multiscale, \ (img_list[k], label_list[k], row_size, channel_size, num_patch, n_time_point, proportion))) else: for k in xrange(n): args.append((extract_val_core_multiscale, \ (img_list[k], label_list[k], row_size, channel_size, num_patch, n_time_point, proportion))) pool = Pool(processes=MULTI) batchsize = MULTI batches = n // batchsize + (n % batchsize != 0) logging.info('pooling : begin') result = [] for k in xrange(batches): logging.info("batch {:>2} / {}".format(k + 1, batches)) result.extend( pool.map(process, args[k * batchsize:(k + 1) * batchsize])) pool.close() logging.info('pooling : done') X_main = [] X_aug = [] Y = [] lesion_dicator_list = [] logging.info('number of extracted cases are :{}'.format(len(result))) for j in xrange(len(result)): X_main = X_main + result[j][0] X_aug = X_aug + result[j][1] Y = Y + result[j][2] lesion_dicator_list = lesion_dicator_list + result[j][3] X_main, X_aug, Y, lesion_dicator_list = np.array(X_main).astype('float32'), np.array(X_aug).astype('float32'), \ np.array(Y), np.array(lesion_dicator_list) if addClinical is True: pass else: return X_main, X_aug, Y, lesion_dicator_list else: """ Extract patches for test time """ X_main = [] X_aug = [] img_shape_cache = [] clinical_list = [] for k in xrange(n): x_main = [] x_aug = [] for time_point in xrange(n_time_point): #Load image img = img_list[k][time_point] img_aug = np.ones(img.shape + np.array( [row_size, row_size, channel_size])) * img[0, 0, 0] img_aug[(row_size/2):(img.shape[0] + row_size/2), \ (row_size/2):(img.shape[1] + row_size/2), \ (channel_size/2):(img.shape[2] + channel_size/2)] = img img_aug = transform_shrink(img_aug) #Transpose img = np.transpose(np.array(img), (2, 0, 1)) img_aug = np.transpose(np.array(img_aug), (2, 0, 1)) #Make patches patches = extract_patches(img, (channel_size, row_size, row_size), \ extraction_step=(patch_c_stride, patch_r_stride, patch_r_stride)) x_main.append(patches) patches_aug = extract_patches(img_aug, (channel_size, row_size, row_size), \ extraction_step=(patch_c_stride/2, patch_r_stride/2, patch_r_stride/2)) x_aug.append(patches_aug) N_patches = np.prod(patches.shape) // (channel_size * (row_size**2)) X_main.append(np.array(x_main)) X_aug.append(np.array(x_aug)) img_shape_cache.append(img.shape) if addClinical is True: pass else: return X_main, X_aug, img_shape_cache
print 'No truth file found' print '' continue print(truth_data.shape) image_data = imread(Image[i]) print(image_data.shape) image_data = image_data[:,:,2] print(image_data.shape) patch_size_x = 31 patch_size_y = 31 pixel_offset = 1 Image_patch = image.extract_patches(image_data,[patch_size_x,patch_size_y],extraction_step=pixel_offset) Image_patch = Image_patch.reshape(Image_patch.shape[0]*Image_patch.shape[1], patch_size_x, patch_size_y) print(Image_patch.shape) T_patch = image.extract_patches(truth_data,[patch_size_x,patch_size_y],extraction_step=pixel_offset) T_patch = T_patch.reshape(T_patch.shape[0]*T_patch.shape[1], patch_size_x, patch_size_y) T_patch = T_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2] print(np.unique(T_patch)) truth_patches = np.zeros(T_patch.shape) truth_patches[T_patch>200] = 1 truth_patches = truth_patches.astype(int) print(np.unique(truth_patches)) print(truth_patches.shape) # print T_patch.shape # grass_index = np.where(truth_patches == 0)
def fit(self, modality, ground_truth=None, cat=None): """Compute the images images. Parameters ---------- modality : object of type TemporalModality The modality object of interest. ground-truth : object of type GTModality or None The ground-truth of GTModality. If None, the whole data will be considered. cat : str or None String corresponding at the ground-truth of interest. Cannot be None if ground-truth is not None. Return ------ self : object Return self. """ super(DCTExtraction, self).fit(modality=modality, ground_truth=ground_truth, cat=cat) # Extract the set of patches from the modality data patches = extract_patches(modality.data_, patch_shape=self.patch_size) # Allocate the DCT maps, one for each feature that # will be computed nb_features = np.prod(self.patch_size) self.data_ = np.zeros((modality.data_.shape[0], modality.data_.shape[1], modality.data_.shape[2], nb_features)) # # Extract DCT feature for each patch # # Define the shift to apply if isinstance(self.patch_size, tuple): y_shift = int(np.ceil((self.patch_size[0] - 1) / 2.)) x_shift = int(np.ceil((self.patch_size[1] - 1) / 2.)) z_shift = int(np.ceil((self.patch_size[2] - 1) / 2.)) elif isinstance(self.patch_size, int): y_shift = int(np.ceil((self.patch_size - 1) / 2.)) x_shift = int(np.ceil((self.patch_size - 1) / 2.)) z_shift = int(np.ceil((self.patch_size - 1) / 2.)) # Create the list of indices to process yy, xx, zz = np.meshgrid(range(patches.shape[0]), range(patches.shape[1]), range(patches.shape[2])) # Linearize for fast processing yy = yy.reshape(-1) xx = xx.reshape(-1) zz = zz.reshape(-1) # Go for the parallel loop dct_features = Parallel(n_jobs=-1)(delayed( _compute_dct_features)(patches[y, x, z, :]) for y, x, z in zip(yy, xx, zz)) # Convert to numpy array dct_features = np.array(dct_features) # Reshape the feature matrix dct_features = dct_features.reshape((patches.shape[0], patches.shape[1], patches.shape[2], nb_features)) # Copy the feature into the object self.data_[y_shift : -y_shift, x_shift : -x_shift, z_shift : -z_shift] = dct_features return self
def B_Patch_Preprocess_recon_3D(patch_size_x=5, patch_size_y=5, patch_size_z=5, prefix='SdA', in_root='', out_root='', recon_flag=True): patch_pixels = patch_size_x * patch_size_y * patch_size_z pixel_offset_x = int(2 * patch_size_x * 0.7) pixel_offset_y = int(2 * patch_size_y * 0.7) pixel_offset_z = 1 padding = patch_size_x #threshold = patch_pixels*0.3 #patches = np.zeros(patch_pixels*4) if recon_flag is True: recon_num = 5 else: recon_num = 4 patches = np.zeros(patch_size_x * patch_size_y * patch_size_z * recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon = [] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: if file1[-3:] == 'mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir + '/') elif file1[-3:] == 'mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:] == 'mha' and ('T2' in file1): T2.append(file1) elif file1[-3:] == 'mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:] == 'mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:] == 'mha' and 'Recon' in file1: Recon.append(file1) number_of_images = len(Flair) print 'Number of Patients : ', number_of_images # # for image_iterator in range(number_of_images): print 'Image number : ', image_iterator + 1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator] + Flair[image_iterator]) T1_image = new(Folder[image_iterator] + T1[image_iterator]) T2_image = new(Folder[image_iterator] + T2[image_iterator]) T_1c_image = new(Folder[image_iterator] + T_1c[image_iterator]) # print 'image created' print Folder[image_iterator] + Truth[image_iterator] try: Truth_image = new(Folder[image_iterator] + Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator] + Truth[image_iterator]) # print 'image created' if recon_flag is True: Recon_image = new(Folder[image_iterator] + Recon[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data if recon_flag is True: Recon_image = Recon_image.data Truth_image = Truth_image.data x_span, y_span, z_span = np.where(Truth_image != 0) x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding + 1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding + 1 z_start = np.min(z_span) - padding z_stop = np.max(z_span) + padding + 1 Flair_patch = image.extract_patches( Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z], (pixel_offset_x, pixel_offset_y, pixel_offset_z)) T1_patch = image.extract_patches( T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z], (pixel_offset_x, pixel_offset_y, pixel_offset_z)) T2_patch = image.extract_patches( T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z], (pixel_offset_x, pixel_offset_y, pixel_offset_z)) T_1c_patch = image.extract_patches( T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z], (pixel_offset_x, pixel_offset_y, pixel_offset_z)) if recon_flag is True: Recon_patch = image.extract_patches( Recon_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z], (pixel_offset_x, pixel_offset_y, pixel_offset_z)) Truth_patch = image.extract_patches( Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z], (pixel_offset_x, pixel_offset_y, pixel_offset_z)) print 'Raw patches extracted' Flair_patch = Flair_patch.reshape( Flair_patch.shape[0] * Flair_patch.shape[1] * Flair_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T1_patch = T1_patch.reshape( T1_patch.shape[0] * T1_patch.shape[1] * T1_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T2_patch = T2_patch.reshape( T2_patch.shape[0] * T2_patch.shape[1] * T2_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T_1c_patch = T_1c_patch.reshape( T_1c_patch.shape[0] * T_1c_patch.shape[1] * T_1c_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) if recon_flag is True: Recon_patch = Recon_patch.reshape( Recon_patch.shape[0] * Recon_patch.shape[1] * Recon_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) Truth_patch = Truth_patch.reshape( Truth_patch.shape[0] * Truth_patch.shape[1] * Truth_patch.shape[2], patch_size_x, patch_size_y, patch_size_z) print 'Patches reshaped' if recon_flag is True: slice_patch = np.concatenate( [Flair_patch, T1_patch, T2_patch, T_1c_patch, Recon_patch], axis=1) else: slice_patch = np.concatenate( [Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:, (patch_size_x - 1) / 2, (patch_size_y - 1) / 2, (patch_size_z - 1) / 2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch), 1) #print '3. truth dimension :', Truth_patch.shape num_of_class = [] for i in xrange(1, 5): num_of_class.append(np.sum((Truth_patch == i).astype(int))) max_num = max(num_of_class) max_num_2 = max(x for x in num_of_class if x != max_num) Flair_patch = image.extract_patches( Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z]) Flair_patch = Flair_patch.reshape( Flair_patch.shape[0] * Flair_patch.shape[1] * Flair_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T1_patch = image.extract_patches( T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z]) T1_patch = T1_patch.reshape( T1_patch.shape[0] * T1_patch.shape[1] * T1_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T2_patch = image.extract_patches( T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z]) T2_patch = T2_patch.reshape( T2_patch.shape[0] * T2_patch.shape[1] * T2_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T_1c_patch = image.extract_patches( T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z]) T_1c_patch = T_1c_patch.reshape( T_1c_patch.shape[0] * T_1c_patch.shape[1] * T_1c_patch.shape[2], patch_size_x * patch_size_y * patch_size_z) T_patch = image.extract_patches( Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x, patch_size_y, patch_size_z]) T_patch = T_patch.reshape( T_patch.shape[0] * T_patch.shape[1] * T_patch.shape[2], patch_size_x, patch_size_y, patch_size_z) T_patch = T_patch[:, (patch_size_x - 1) / 2, (patch_size_y - 1) / 2, (patch_size_z - 1) / 2] for i in xrange(1, 5): #print 'Max : ', max_num_2 #print 'Present : ', np.sum(image_label==i).astype(int) diff = max_num_2 - np.sum(T_patch == i).astype(int) #print 'Difference: ', diff #print 'Diff : ', diff if np.sum(T_patch == i).astype(int) >= max_num_2: #print 'Continuing i = ', i continue #print 'TEST : ', Truth_patch.shape if i not in T_patch: continue #print T_patch.shape #print np.sum(T_patch==i).astype(int) index_x = np.where(T_patch == i) #print 'Length : ',len(index_x) index = np.arange(len(index_x)) shuffle(index) temp = T_patch[index_x[index[0:diff]]] temp = temp.reshape(len(temp), 1) Truth_patch = np.vstack([Truth_patch, temp]) #print 'pppp' #print len(index_x[index[0:diff]]) #print Flair_patch.shape F_p = Flair_patch[index_x[index[0:diff]], :] T1_p = T1_patch[index_x[index[0:diff]], :] T2_p = T2_patch[index_x[index[0:diff]], :] T_1c_p = T_1c_patch[index_x[index[0:diff]], :] temp_patch = np.concatenate([F_p, T1_p, T2_p, T_1c_p], axis=1) slice_patch = np.vstack([slice_patch, temp_patch]) print 'No. of 1 : ', np.sum((Truth_patch == 1).astype(int)) print 'No. of 2 : ', np.sum((Truth_patch == 2).astype(int)) print 'No. of 3 : ', np.sum((Truth_patch == 3).astype(int)) print 'No. of 4 : ', np.sum((Truth_patch == 4).astype(int)) patches = np.vstack([patches, slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) print ground_truth.shape print patches.shape # # #print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) #print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) # #print # ground_truth = ground_truth.reshape(len(ground_truth)) if recon_flag == False: patches = patches[:, 0:patch_size_x * patch_size_y * patch_size_z * 4] #np.save('Training_patches.npy',patches) #np.save('Training_labels.npy',ground_truth) #print ground_truth.shape #print patches.shape if 'training' in out_root and recon_flag == True: print '... Saving the balanced training patches' np.save(out_root + 'b_trainpatch_3D_' + prefix + '_.npy', patches) np.save(out_root + 'b_trainlabel_3D_' + prefix + '_.npy', ground_truth) elif recon_flag == True: print '... Saving the balance validation patches' np.save(out_root + 'b_validpatch_3D_' + prefix + '_.npy', patches) np.save(out_root + 'b_validlabel_3D_' + prefix + '_.npy', ground_truth) if 'training' in out_root and recon_flag == False: print '... Saving the balanced training patches' np.save(out_root + 'b_trainpatch_3D_' + prefix + '_.npy', patches) np.save(out_root + 'b_trainlabel_3D_' + prefix + '_.npy', ground_truth) elif recon_flag == False: print '... Saving the balanced testing patches' np.save(out_root + 'b_validpatch_3D_' + prefix + '_.npy', patches) np.save(out_root + 'b_validlabel_3D_' + prefix + '_.npy', ground_truth)
def slice_perfect_balance_2D(patch_size_x=5, patch_size_y=5, prefix='Sda', in_root='', out_root='', slice_num=1): #Initialize user variables patch_size = patch_size_x patch_pixels = patch_size * patch_size pixel_offset = patch_size padding = patch_size #threshold = patch_pixels*0.3 recon_num = 4 label_num = 5 patches = np.zeros(patch_pixels * recon_num) # ground_truth = np.zeros(1) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: #print file1 if file1[-3:] == 'nii' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir + '/') elif file1[-3:] == 'nii' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:] == 'nii' and ('T2' in file1): T2.append(file1) elif file1[-3:] == 'nii' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:] == 'mha' and 'OT' in file1: Truth.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Iteration : ', image_iterator + 1 print 'Folder : ', Folder[image_iterator] Flair_image = nib.load(Folder[image_iterator] + Flair[image_iterator]) T1_image = nib.load(Folder[image_iterator] + T1[image_iterator]) T2_image = nib.load(Folder[image_iterator] + T2[image_iterator]) T_1c_image = nib.load(Folder[image_iterator] + T_1c[image_iterator]) try: Truth_image = new(Folder[image_iterator] + Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator] + Truth[image_iterator]) Flair_image = Flair_image.get_data() T1_image = T1_image.get_data() T2_image = T2_image.get_data() T_1c_image = T_1c_image.get_data() Truth_image = Truth_image.data if slice_num == 2: Flair_image = np.swapaxes(Flair_image, 0, 1) Flair_image = np.swapaxes(Flair_image, 1, 2) T1_image = np.swapaxes(T1_image, 0, 1) T1_image = np.swapaxes(T1_image, 1, 2) T2_image = np.swapaxes(T2_image, 0, 1) T2_image = np.swapaxes(T2_image, 1, 2) T_1c_image = np.swapaxes(T_1c_image, 0, 1) T_1c_image = np.swapaxes(T_1c_image, 1, 2) Truth_image = np.swapaxes(Truth_image, 0, 1) Truth_image = np.swapaxes(Truth_image, 1, 2) elif slice_num == 3: Flair_image = np.swapaxes(Flair_image, 0, 1) Flair_image = np.swapaxes(Flair_image, 0, 2) T1_image = np.swapaxes(T1_image, 0, 1) T1_image = np.swapaxes(T1_image, 0, 2) T2_image = np.swapaxes(T2_image, 0, 1) T2_image = np.swapaxes(T2_image, 0, 2) T_1c_image = np.swapaxes(T_1c_image, 0, 1) T_1c_image = np.swapaxes(T_1c_image, 0, 2) Truth_image = np.swapaxes(Truth_image, 0, 1) Truth_image = np.swapaxes(Truth_image, 0, 2) # Truth_image[np.where(Truth_image==3)]=1 # Truth_image[np.where(Truth_image==4)]=1 x_span, y_span, z_span = np.where(Truth_image != 0) start_slice = min(z_span) stop_slice = max(z_span) x_start = min(x_span) - padding x_stop = max(x_span) + padding y_start = min(y_span) - padding y_stop = max(y_span) + padding Flair_patch = image.extract_patches( Flair_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1]) Flair_patch = Flair_patch.reshape( Flair_patch.shape[0] * Flair_patch.shape[1] * Flair_patch.shape[2], patch_size_x * patch_size_y) T1_patch = image.extract_patches( T1_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1]) T1_patch = T1_patch.reshape( T1_patch.shape[0] * T1_patch.shape[1] * T1_patch.shape[2], patch_size_x * patch_size_y) T2_patch = image.extract_patches( T2_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1]) T2_patch = T2_patch.reshape( T2_patch.shape[0] * T2_patch.shape[1] * T2_patch.shape[2], patch_size_x * patch_size_y) T_1c_patch = image.extract_patches( T_1c_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1]) T_1c_patch = T_1c_patch.reshape( T_1c_patch.shape[0] * T_1c_patch.shape[1] * T_1c_patch.shape[2], patch_size_x * patch_size_y) T_patch = image.extract_patches( Truth_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1]) T_patch = T_patch.reshape( T_patch.shape[0] * T_patch.shape[1] * T_patch.shape[2], patch_size_x, patch_size_y, 1) T_patch = T_patch[:, (patch_size - 1) / 2, (patch_size - 1) / 2] num_of_class = [] for i in xrange(0, label_num): num_of_class.append(np.sum((T_patch == i).astype(int))) minim = min(x for x in num_of_class if x != 0) if minim > 3000: minim = 3000 # flair_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t1_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t2_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t1c_patch = np.zeros(patch_size_x*patch_size_y*recon_num) slice_patch = np.zeros(patch_size_x * patch_size_y * recon_num) Truth_patch = np.zeros(1) # print minim # print for i in xrange(5): if num_of_class[i] == 0: continue index_x, index_y = np.where(T_patch == i) index1 = np.arange(len(index_x)) shuffle(index1) # print index1 # print index_x[index1[0:minim]].shape #print Flair_patch.shape slice_patch1 = np.concatenate([ Flair_patch[index_x[index1[0:minim]], :], T1_patch[index_x[index1[0:minim]], :], T2_patch[index_x[index1[0:minim]], :], T_1c_patch[index_x[index1[0:minim]], :] ], axis=1) slice_patch = np.vstack([slice_patch, slice_patch1]) # flair_patch = np.vstack([flair_patch, Flair_patch[index_x[index1[0:minim]],:]]) # t1_patch = np.vstack([t1_patch,T1_patch[index_x[index1[0:minim]],:]]) # t2_patch = np.vstack([t2_patch, T2_patch[index_x[index1[0:minim]],:]]) # t1c_patch = np.vstack([t1c_patch, T_1c_patch[index_x[index1[0:minim]],:]]) # print Truth_patch.shape # print T_patch.shape Truth_patch = np.vstack( [Truth_patch, T_patch[index_x[index1[0:minim]]]]) print 'No. of 0 : ', np.sum((Truth_patch == 0).astype(int)) print 'No. of 1 : ', np.sum((Truth_patch == 1).astype(int)) print 'No. of 2 : ', np.sum((Truth_patch == 2).astype(int)) print 'No. of 3 : ', np.sum((Truth_patch == 3).astype(int)) print 'No. of 4 : ', np.sum((Truth_patch == 4).astype(int)) Truth_patch = Truth_patch.reshape(len(Truth_patch)) print 'look here ---->', Truth_patch.shape # np.save(out_root+'patches_patient_flair'+str(image_iterator+1)+'.npy',flair_patch) # np.save(out_root+'patches_patient_t1'+str(image_iterator+1)+'.npy',t1_patch) # np.save(out_root+'patches_patient_t2'+str(image_iterator+1)+'.npy',t2_patch) # np.save(out_root+'patches_patient_t1c'+str(image_iterator+1)+'.npy',t1c_patch) # np.save(out_root+'patches_patient_'+str(image_iterator+1)+'.npy',slice_patch) # np.save(out_root+'labels_patient_'+str(image_iterator+1)+'.npy',Truth_patch) patches = np.vstack([patches, slice_patch]) print 'patches balanced shape', patches.shape ground_truth = np.append(ground_truth, Truth_patch) print 'ground shape--->', ground_truth.shape index1 = np.arange(patches.shape[0]) shuffle(index1) print np.shape(patches) patches = patches[index1, :] ground_truth = ground_truth[index1] patches = np.float32(patches) ground_truth = np.float32(ground_truth) if 'training' in out_root: np.save(out_root + 'perfect_balance_trainpatch_' + prefix + '_.npy', patches) np.save(out_root + 'perfect_balance_traintruth_' + prefix + '_.npy', ground_truth) else: np.save(out_root + 'perfect_balance_validpatch_' + prefix + '_.npy', patches) np.save(out_root + 'perfect_balance_validtruth_' + prefix + '_.npy', ground_truth)
#!/usr/bin/env python __author__ = 'ienek' from skimage import io, filter, feature from skimage.color import rgb2gray from sklearn.feature_extraction import image # test to load any image test = io.imread('n02854926_28_0.jpg') # loading to array img_arr = image.img_to_graph(test) patch_g = image.extract_patches(test, (4, 4, 2)) patch_g2 = image.extract_patches_2d(test, (4, 4)) print("Patch 1: %s " % str(patch_g.shape)) print("Patch 2: %s " % str(patch_g2.shape)) # grayscaling gray_test = rgb2gray(test) # building hog hog_ = feature.hog(gray_test) # building surf # ORB: An efficient alternative to SIFT and SURF surf_ = feature.ORB() surf_.detect_and_extract(gray_test)
def perfect_balance_3D(patch_size_x=5,patch_size_y=5,patch_size_z=5,prefix='SdA',in_root='',out_root='',recon_flag=False): patch_pixels = patch_size_x*patch_size_y*patch_size_z pixel_offset_x = int(patch_size_x*0.5) pixel_offset_y = int(patch_size_y*0.5) pixel_offset_z = 1 padding = patch_size_x #threshold = patch_pixels*0.3 #patches = np.zeros(patch_pixels*4) if recon_flag is True: recon_num = 5 else: recon_num = 4 patches = np.zeros(patch_size_x*patch_size_y*patch_size_z*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon=[] Folder = [] print 'Path: ',path for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='mha' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:]=='mha' and 'Recon' in file1: Recon.append(file1) number_of_images = len(T1) print 'Number of Patients : ', number_of_images # # for image_iterator in range(number_of_images): print 'Image number : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) # print 'image created' print Folder[image_iterator] + Truth[image_iterator] try: Truth_image = new( Folder[image_iterator] + Truth[image_iterator] ) except: Truth_image = new2( Folder[image_iterator] + Truth[image_iterator] ) # print 'image created' Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) ### have to change this and include condition i!=0 and i!=5... x,y,z=np.where(Truth_image!=0) and np.where(Truth_image!=5) x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 z_start = np.min(z_span) - padding z_stop = np.max(z_span) +padding+1 Flair_patch = image.extract_patches(Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z]) Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = image.extract_patches(T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = image.extract_patches(T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_patch = image.extract_patches(Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T_patch = T_patch.reshape(T_patch.shape[0]*T_patch.shape[1]*T_patch.shape[2],patch_size_x, patch_size_y, patch_size_z) T_patch = T_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2,(patch_size_z-1)/2] T_patch = T_patch.reshape(len(T_patch),1) num_of_class = [] for i in xrange(0,5): # have to change this too... 0,6 num_of_class.append(np.sum((T_patch==i).astype(int))) minim = min(x for x in num_of_class if x!=0) # have to change this too. include effect of class 5. Dont think this will create any issue and hence o change required.. if minim > 1000: minim = 1000 slice_patch = np.zeros(patch_size_x*patch_size_y*patch_size_z*recon_num) # print ' CHECK ', slice_patch.shape Truth_patch = np.zeros(1) # print minim # print for i in xrange(5): # change required. 6 if num_of_class[i]==0: # change required... continue # print 'LOOK ' , i index_x, index_y = np.where(T_patch==i) # print index_x index1 = np.arange(len(index_x)) shuffle(index1) # print index1 # print index_x[index1[0:minim]].shape slice_patch1 = np.concatenate([Flair_patch[index_x[index1[0:minim]],:],T1_patch[index_x[index1[0:minim]],:], T2_patch[index_x[index1[0:minim]],:], T_1c_patch[index_x[index1[0:minim]],:]], axis=1) # print 'Slice_patch 1', slice_patch1.shape # print 'Slice patch ', slice_patch.shape slice_patch = np.vstack([slice_patch, slice_patch1]) # print Truth_patch.shape # print T_patch.shape Truth_patch = np.vstack([Truth_patch, T_patch[index_x[index1[0:minim]]]]) print 'No. of 0 : ', np.sum((Truth_patch==0).astype(int)) print 'No. of 1 : ', np.sum((Truth_patch==1).astype(int)) print 'No. of 2 : ', np.sum((Truth_patch==2).astype(int)) print 'No. of 3 : ', np.sum((Truth_patch==3).astype(int)) print 'No. of 4 : ', np.sum((Truth_patch==4).astype(int)) print 'No. of class 5',np.sum((Truth_patch==5).astype(int)) # added now ... patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) print ground_truth.shape print patches.shape ground_truth = ground_truth.reshape(len(ground_truth)) print 'No. of 0 : ', np.sum((ground_truth==0).astype(int)) print 'No. of 1 : ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 : ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 : ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 : ', np.sum((ground_truth==4).astype(int)) print 'No. of 5 : ', np.sum((ground_truth==5).astype(int)) # added now... if recon_flag==False: patches = patches[:,0:patch_size_x*patch_size_y*patch_size_z*4] #np.save('Training_patches.npy',patches) #np.save('Training_labels.npy',ground_truth) #print ground_truth.shape #print patches.shape if 'training' in out_root and recon_flag==True: print'... Saving the balanced training patches' np.save(out_root+'b_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==True: print '... Saving the balance validation patches' np.save(out_root+'b_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_3D_'+prefix+'_.npy',ground_truth) if 'training' in out_root and recon_flag==False: print'... Saving the balanced training patches' np.save(out_root+'b_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==False: print '... Saving the balanced testing patches' np.save(out_root+'b_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_3D_'+prefix+'_.npy',ground_truth)
def build(self): # assume last axis indexes images patch_shape = (self.patch_size, self.patch_size, 1) self.patches = extract_patches(self.image3d, patch_shape)
images_path = '../../test_jpg/' # images_path_test = '../input/test_jpg/' names = [] extracted_features = [] file_path = '../input/deepIQA_features_test.csv' os.mknod(file_path) train_ids = next(os.walk(images_path))[2] f = True for name in tqdm(train_ids): try: img = cv2.imread(images_path + name) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) patches = extract_patches(img, (32, 32, 3), 32) X = np.transpose(patches.reshape((-1, 32, 32, 3)), (0, 3, 1, 2)) y = [] weights = [] batchsize = min(2000, X.shape[0]) t = xp.zeros((1, 1), np.float32) for i in six.moves.range(0, X.shape[0], batchsize): X_batch = X[i:i + batchsize] X_batch = xp.array(X_batch.astype(np.float32)) model.forward(X_batch, t, False, X_batch.shape[0]) y.append(xp.asnumpy(model.y[0].data).reshape((-1,))) weights.append(xp.asnumpy(model.a[0].data).reshape((-1,)))
def get_global_D(datasets, outfilename, block_size, ncores=None, batchsize=32, niter=500, use_std=False, positivity=False, fit_intercept=True, center=True): split_b0s = True b0_threshold = 20 # get the data shape so we can preallocate some arrays # we also have to assume all datasets have the same 3D shape obviously shape = nib.load(datasets[0]).header.get_data_shape() if len(block_size) < len(shape): # In the event that we only give out a 3D size and that we have b0s with different TE/TR, we remove those volumes # Therefore, we need to look at the total number of kept volumes, rather than the shape, to specify the last dimension properly last_shape = get_indexer(datasets[0]).sum( ) - 1 # We subtract 1 because block_size adds one b0 to it later down current_block_size = block_size + (last_shape, ) print('Using full 4D stuff') else: current_block_size = block_size n_atoms = int(np.prod(current_block_size) * 2) b0_block_size = tuple(current_block_size[:-1]) + ( (current_block_size[-1] + 1, )) overlap = b0_block_size to_denoise = np.empty(shape[:-1] + (current_block_size[-1] + 1, ), dtype=np.float32) train_list = [] variance_large = [] for filename in datasets: print('Now feeding dataset {}'.format(filename)) indexer = get_indexer(filename) mask = nib.load(filename.replace( '.nii', '_mask.nii.gz')).get_data(caching='unchanged') data = nib.load(filename).get_data(caching='unchanged') * mask[..., None] data = data[..., indexer] bvals = np.loadtxt(filename.replace('.nii', '.bval'))[indexer] bvecs = np.loadtxt(filename.replace('.nii', '.bvec'))[indexer] b0_loc = np.where(bvals <= b0_threshold)[0] dwis = np.where(bvals > b0_threshold)[0] num_b0s = len(b0_loc) # We also convert bvecs associated with b0s to exactly (0,0,0), which # is not always the case when we hack around with the scanner. bvecs = np.where(bvals[:, None] <= b0_threshold, 0, bvecs) # Average all b0s if we don't split them in the training set if num_b0s > 1 and not split_b0s: num_b0s = 1 data[..., b0_loc] = np.mean(data[..., b0_loc], axis=-1, keepdims=True) # Split the b0s in a cyclic fashion along the training data # If we only had one, cycle just return b0_loc indefinitely, # else we go through all indexes. np.random.shuffle(b0_loc) split_b0s_idx = cycle(b0_loc) sym_bvecs = np.vstack((bvecs, -bvecs)) neighbors = angular_neighbors( sym_bvecs, current_block_size[-1] - 1) % data.shape[-1] neighbors = neighbors[:data. shape[-1]] # everything was doubled for symmetry full_indexes = [(dwi, ) + tuple(neighbors[dwi]) for dwi in range(data.shape[-1]) if dwi in dwis] indexes = greedy_set_finder(full_indexes) # If we have more b0s than indexes, then we have to add a few more blocks since # we won't do a full cycle. If we have more b0s than indexes after that, then it breaks. if num_b0s > len(indexes): the_rest = [rest for rest in full_indexes if rest not in indexes] indexes += the_rest[:(num_b0s - len(indexes))] if num_b0s > len(indexes): error = ( 'Seems like you still have more b0s {} than available blocks {},' ' either average them or deactivate subsampling.'.format( num_b0s, len(indexes))) raise ValueError(error) # whole global centering if center: data -= data.mean(axis=-1, keepdims=True) for i, idx in enumerate(indexes): b0_loc = tuple((next(split_b0s_idx), )) to_denoise[..., 0] = data[..., b0_loc].squeeze() to_denoise[..., 1:] = data[..., idx] patches = extract_patches(to_denoise, b0_block_size, overlap) axis = tuple(range(patches.ndim // 2, patches.ndim)) mask_patch = np.sum(patches > 0, axis=axis) > np.prod(b0_block_size) // 2 patches = patches[mask_patch].reshape(-1, np.prod(b0_block_size)) if use_std: try: variance = nib.load(filename.replace( '.nii', '_std.nii.gz')).get_data()**2 * mask variance = np.broadcast_to(variance[..., None], data.shape) variance = extract_patches(variance, b0_block_size, overlap) axis = tuple(range(variance.ndim // 2, variance.ndim)) variance = np.median(variance, axis=axis)[mask_patch].ravel() print('variance shape', variance.shape) except IOError: print('Volume {} not found!'.format( filename.replace('.nii', '_std.nii.gz'))) variance = [None] else: variance = [None] # check to build with np.r_ the whole list from stringnames instead train_list += [patches] variance_large += list(variance) # train_data.extend(patches) # variance_large.extend(variance) print('train', len(train_list), data.shape, b0_block_size, overlap, patches.shape) del data, mask, patches, variance print('Fed everything in') lengths = [l.shape[0] for l in train_list] train_data = np.empty((np.sum(lengths), np.prod(b0_block_size))) print(train_data.shape) step = 0 for i in range(len(train_list)): length = lengths[i] idx = slice(step, step + length) train_data[idx] = train_list[i].reshape(-1, np.prod(b0_block_size)) step += length del train_list # if center: # train_data -= train_data.mean(axis=1, keepdims=True) # we have variance as a N elements list - so check one element to see if it's an array if variance_large[0] is not None: variance_large = np.asarray(variance_large).ravel() else: variance_large = None savename = 'Dic_' + outfilename + '_size_{}.npy'.format( block_size).replace(' ', '') D = online_DL(train_data, ncores=ncores, positivity=positivity, fit_intercept=fit_intercept, standardize=True, nlambdas=100, niter=niter, batchsize=batchsize, n_atoms=n_atoms, variance=variance_large, progressbar=True, disable_mkl=True, saveback=savename, use_joblib=False) return D
Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 z_start = np.min(z_span) - padding z_stop = np.max(z_span) +padding+1 Flair_patch = image.extract_patches(Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,1)) T1_patch = image.extract_patches(T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,1)) T2_patch = image.extract_patches(T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,1)) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,1)) Truth_patch = image.extract_patches(Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,1)) print 'Raw patches extracted' Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1]*Truth_patch.shape[2], patch_size_x, patch_size_y, patch_size_z) print 'Patches reshaped'
def crop_tiles(region, tile_size): tiles = extract_patches(np.array(region), (tile_size, tile_size, 3), extraction_step=tile_size) tiles = tiles.squeeze() # shape: (nrows, ncols, tile_size, tile_size, 3) return tiles
if FR: model = FRModel(top=args.top) else: model = Model(top=args.top) cuda.cudnn_enabled = True cuda.check_cuda_available() xp = cuda.cupy serializers.load_hdf5(args.model, model) model.to_gpu() if FR: ref_img = cv2.imread(args.REF) ref_img = cv2.cvtColor(ref_img, cv2.COLOR_BGR2RGB) patches = extract_patches(ref_img, (32,32,3), 32) X_ref = np.transpose(patches.reshape((-1, 32, 32, 3)), (0, 3, 1, 2)) img = cv2.imread(args.INPUT) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) patches = extract_patches(img, (32,32,3), 32) X = np.transpose(patches.reshape((-1, 32, 32, 3)), (0, 3, 1, 2)) y = [] weights = [] batchsize = min(2000, X.shape[0]) t = xp.zeros((1, 1), np.float32) for i in six.moves.range(0, X.shape[0], batchsize): X_batch = X[i:i + batchsize] X_batch = xp.array(X_batch.astype(np.float32))
def augment_slice_perfect_balance_2D( patch_size_x=5, patch_size_y=5, prefix="Sda", in_root="", out_root="", slice_num=1 ): # Initialize user variables patch_size = patch_size_x patch_pixels = patch_size * patch_size pixel_offset = patch_size padding = 2 * patch_size # threshold = patch_pixels*0.3 recon_num = 4 label_num = 5 patches = np.zeros(patch_pixels * recon_num) # ground_truth = np.zeros(1) ground_truth = np.zeros(1) # paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Folder = [] for subdir, dirs, files in os.walk(path): if len(Flair) is 1: break for file1 in files: # print file1 if file1[-3:] == "nii" and ("Flair" in file1): Flair.append(file1) Folder.append(subdir + "/") elif file1[-3:] == "nii" and ("T1" in file1 and "T1c" not in file1): T1.append(file1) elif file1[-3:] == "nii" and ("T2" in file1): T2.append(file1) elif file1[-3:] == "nii" and ("T1c" in file1 or "T_1c" in file1): T_1c.append(file1) elif file1[-3:] == "mha" and "OT" in file1: Truth.append(file1) number_of_images = len(Flair) print "Number of images : ", number_of_images for image_iterator in range(number_of_images): print "Iteration : ", image_iterator + 1 print "Folder : ", Folder[image_iterator] Flair_image = nib.load(Folder[image_iterator] + Flair[image_iterator]) T1_image = nib.load(Folder[image_iterator] + T1[image_iterator]) T2_image = nib.load(Folder[image_iterator] + T2[image_iterator]) T_1c_image = nib.load(Folder[image_iterator] + T_1c[image_iterator]) try: Truth_image = new(Folder[image_iterator] + Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator] + Truth[image_iterator]) Flair_image = Flair_image.get_data() T1_image = T1_image.get_data() T2_image = T2_image.get_data() T_1c_image = T_1c_image.get_data() Truth_image = Truth_image.data if slice_num == 2: Flair_image = np.swapaxes(Flair_image, 0, 1) Flair_image = np.swapaxes(Flair_image, 1, 2) T1_image = np.swapaxes(T1_image, 0, 1) T1_image = np.swapaxes(T1_image, 1, 2) T2_image = np.swapaxes(T2_image, 0, 1) T2_image = np.swapaxes(T2_image, 1, 2) T_1c_image = np.swapaxes(T_1c_image, 0, 1) T_1c_image = np.swapaxes(T_1c_image, 1, 2) Truth_image = np.swapaxes(Truth_image, 0, 1) Truth_image = np.swapaxes(Truth_image, 1, 2) elif slice_num == 3: Flair_image = np.swapaxes(Flair_image, 0, 1) Flair_image = np.swapaxes(Flair_image, 0, 2) T1_image = np.swapaxes(T1_image, 0, 1) T1_image = np.swapaxes(T1_image, 0, 2) T2_image = np.swapaxes(T2_image, 0, 1) T2_image = np.swapaxes(T2_image, 0, 2) T_1c_image = np.swapaxes(T_1c_image, 0, 1) T_1c_image = np.swapaxes(T_1c_image, 0, 2) Truth_image = np.swapaxes(Truth_image, 0, 1) Truth_image = np.swapaxes(Truth_image, 0, 2) # Truth_image[np.where(Truth_image==3)]=1 # Truth_image[np.where(Truth_image==4)]=1 x_span, y_span, z_span = np.where(Truth_image != 0) start_slice = min(z_span) stop_slice = max(z_span) x_start = min(x_span) - padding x_stop = max(x_span) + padding y_start = min(y_span) - padding y_stop = max(y_span) + padding Flair_patch = image.extract_patches( Flair_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1] ) Flair_patch = Flair_patch.reshape( Flair_patch.shape[0] * Flair_patch.shape[1] * Flair_patch.shape[2], patch_size_x, patch_size_y ) T1_patch = image.extract_patches( T1_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1] ) T1_patch = T1_patch.reshape( T1_patch.shape[0] * T1_patch.shape[1] * T1_patch.shape[2], patch_size_x, patch_size_y ) T2_patch = image.extract_patches( T2_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1] ) T2_patch = T2_patch.reshape( T2_patch.shape[0] * T2_patch.shape[1] * T2_patch.shape[2], patch_size_x, patch_size_y ) T_1c_patch = image.extract_patches( T_1c_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1] ) T_1c_patch = T_1c_patch.reshape( T_1c_patch.shape[0] * T_1c_patch.shape[1] * T_1c_patch.shape[2], patch_size_x, patch_size_y ) T_patch = image.extract_patches( Truth_image[x_start:x_stop, y_start:y_stop, start_slice:stop_slice], [patch_size_x, patch_size_y, 1] ) T_patch = T_patch.reshape(T_patch.shape[0] * T_patch.shape[1] * T_patch.shape[2], patch_size_x, patch_size_y, 1) T_patch = T_patch[:, (patch_size - 1) / 2, (patch_size - 1) / 2] num_of_class = [] for i in xrange(0, label_num): num_of_class.append(np.sum((T_patch == i).astype(int))) minim = min(x for x in num_of_class if x != 0) if minim > 3000: minim = 3000 # flair_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t1_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t2_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t1c_patch = np.zeros(patch_size_x*patch_size_y*recon_num) slice_patch = np.zeros(patch_size_x * patch_size_y * recon_num) Truth_patch = np.zeros(1) # print minim # print for i in xrange(5): if num_of_class[i] == 0: continue index_x, index_y = np.where(T_patch == i) index1 = np.arange(len(index_x)) shuffle(index1) # print index1 # print index_x[index1[0:minim]].shape # print Flair_patch.shape if i == 0: minim1 = min(4 * minim, num_of_class[0]) Fp = Flair_patch[index_x[index1[0:minim1]], :, :] T1p = T1_patch[index_x[index1[0:minim1]], :, :] T1cp = T_1c_patch[index_x[index1[0:minim1]], :, :] T2p = T2_patch[index_x[index1[0:minim1]], :, :] Fp = Fp.reshape(Fp.shape[0], patch_size_x * patch_size_y) T1p = T1p.reshape(T1p.shape[0], patch_size_x * patch_size_y) T1cp = T1p.reshape(T1cp.shape[0], patch_size_x * patch_size_y) T2p = T1p.reshape(T2p.shape[0], patch_size_x * patch_size_y) slice_patch1 = np.concatenate([Fp, T1p, T2p, T1cp], axis=1) print "adding : ", slice_patch1.shape[0] slice_patch = np.vstack([slice_patch, slice_patch1]) Truth_patch = np.vstack([Truth_patch, T_patch[index_x[index1[0:minim1]]]]) else: Fp = Flair_patch[index_x[index1[0:minim]], :, :] T1p = T1_patch[index_x[index1[0:minim]], :, :] T1cp = T_1c_patch[index_x[index1[0:minim]], :, :] T2p = T2_patch[index_x[index1[0:minim]], :, :] Fp_n = np.asarray(Fp) T1p_n = np.asarray(T1p) T2p_n = np.asarray(T2p) T1cp_n = np.asarray(T1cp) Fp_n = Fp_n.reshape(Fp_n.shape[0], patch_size_x * patch_size_y) T1p_n = T1p_n.reshape(T1p_n.shape[0], patch_size_x * patch_size_y) T2p_n = T2p_n.reshape(T2p_n.shape[0], patch_size_x * patch_size_y) T1cp_n = T1cp_n.reshape(T1cp_n.shape[0], patch_size_x * patch_size_y) sp_n = np.concatenate([Fp_n, T1p_n, T2p_n, T1cp_n], axis=1) print "adding : ", sp_n.shape[0] slice_patch = np.vstack([slice_patch, sp_n]) Truth_patch = np.vstack([Truth_patch, T_patch[index_x[index1[0:minim]]]]) for angle in range(3): Fp = np.asarray([np.rot90(Fp[x, :, :]) for x in range(Fp.shape[0])]) T1p = np.asarray([np.rot90(T1p[x, :, :]) for x in range(T1p.shape[0])]) T2p = np.asarray([np.rot90(T2p[x, :, :]) for x in range(T2p.shape[0])]) T1cp = np.asarray([np.rot90(T1cp[x, :, :]) for x in range(T1cp.shape[0])]) Fp_n = np.asarray(Fp) T1p_n = np.asarray(T1p) T2p_n = np.asarray(T2p) T1cp_n = np.asarray(T1cp) Fp_n = Fp_n.reshape(Fp_n.shape[0], patch_size_x * patch_size_y) T1p_n = T1p_n.reshape(T1p_n.shape[0], patch_size_x * patch_size_y) T2p_n = T2p_n.reshape(T2p_n.shape[0], patch_size_x * patch_size_y) T1cp_n = T1cp_n.reshape(T1cp_n.shape[0], patch_size_x * patch_size_y) sp_n = np.concatenate([Fp_n, T1p_n, T2p_n, T1cp_n], axis=1) print "adding : ", sp_n.shape[0] slice_patch = np.vstack([slice_patch, sp_n]) Truth_patch = np.vstack([Truth_patch, T_patch[index_x[index1[0:minim]]]]) print "No. of 0 : ", np.sum((Truth_patch == 0).astype(int)) print "No. of 1 : ", np.sum((Truth_patch == 1).astype(int)) print "No. of 2 : ", np.sum((Truth_patch == 2).astype(int)) print "No. of 3 : ", np.sum((Truth_patch == 3).astype(int)) print "No. of 4 : ", np.sum((Truth_patch == 4).astype(int)) Truth_patch = Truth_patch.reshape(len(Truth_patch)) print "look here ---->", Truth_patch.shape # np.save(out_root+'patches_patient_flair'+str(image_iterator+1)+'.npy',flair_patch) # np.save(out_root+'patches_patient_t1'+str(image_iterator+1)+'.npy',t1_patch) # np.save(out_root+'patches_patient_t2'+str(image_iterator+1)+'.npy',t2_patch) # np.save(out_root+'patches_patient_t1c'+str(image_iterator+1)+'.npy',t1c_patch) # np.save(out_root+'patches_patient_'+str(image_iterator+1)+'.npy',slice_patch) # np.save(out_root+'labels_patient_'+str(image_iterator+1)+'.npy',Truth_patch) patches = np.vstack([patches, slice_patch]) print "patches balanced shape", patches.shape ground_truth = np.append(ground_truth, Truth_patch) print "ground shape--->", ground_truth.shape index1 = np.arange(patches.shape[0]) shuffle(index1) print np.shape(patches) patches = patches[index1, :] ground_truth = ground_truth[index1] patches = np.float32(patches) ground_truth = np.float32(ground_truth) if "training" in out_root: np.save(out_root + "perfect_balance_trainpatch_" + prefix + "_.npy", patches) np.save(out_root + "perfect_balance_traintruth_" + prefix + "_.npy", ground_truth) else: np.save(out_root + "perfect_balance_validpatch_" + prefix + "_.npy", patches) np.save(out_root + "perfect_balance_validtruth_" + prefix + "_.npy", ground_truth)
def style_transfer(content, style, segmentation_mask, sigma_r=0.17, sigma_s=15): content_arr = build_gaussian_pyramid(content, LMAX) style_arr = build_gaussian_pyramid(style, LMAX) segm_arr = build_gaussian_pyramid(segmentation_mask, LMAX) # Initialize X with the content + strong noise. X = random_noise(content_arr[LMAX - 1], mode='gaussian', var=50) # Set up Content Fusion constants. fus_const1 = [] fus_const2 = [] for i in range(LMAX): sx, sy = segm_arr[i].shape curr_segm = segm_arr[i].reshape(sx, sy, 1) fus_const1.append(curr_segm * content_arr[i]) fus_const2.append(1.0 / (curr_segm + 1)) print('Starting Style Transfer..') for L in range(LMAX - 1, -1, -1): # over scale L print('Scale ', L) current_size = style_arr[L].shape[0] style_L_sx, style_L_sy, _ = style_arr[L].shape X = random_noise(X, mode='gaussian', var=20 / 250.0) for n in range(PATCH_SIZES.size): # over patch size n p_size = PATCH_SIZES[n] print('Patch Size', p_size) npatchx = int((style_L_sx - p_size) / SAMPLING_GAPS[n] + 1) # The images are padded to avoid side artifacts. padding = p_size - (style_L_sx - npatchx * SAMPLING_GAPS[n]) padding_arr = ((0, padding), (0, padding), (0, 0)) current_style = pad(style_arr[L], padding_arr, mode=PADDING_MODE) X = pad(X, padding_arr, mode=PADDING_MODE) const1 = pad(fus_const1[L], padding_arr, mode=PADDING_MODE) const2 = pad(fus_const2[L], padding_arr, mode=PADDING_MODE) style_patches = extract_patches(current_style, patch_shape=(p_size, p_size, 3), extraction_step=SAMPLING_GAPS[n]) npatchx, npatchy, _, _, _, _ = style_patches.shape npatches = npatchx * npatchy # Preparing for NN style_patches = style_patches.reshape(-1, p_size * p_size * 3) njobs = 1 if (L == 0) or (L == 1 and p_size <= 13): njobs = -1 projection_matrix = 0 # for small patch sizes perform PCA if p_size <= 21: new_style_patches, projection_matrix = pca(style_patches) neighbors = NearestNeighbors( n_neighbors=1, p=2, n_jobs=njobs).fit(new_style_patches) else: neighbors = NearestNeighbors(n_neighbors=1, p=2, n_jobs=njobs).fit(style_patches) style_patches = style_patches.reshape((-1, p_size, p_size, 3)) for k in range(IALG): # Steps 1 & 2: Patch-Extraction and and Robust Patch Aggregation X_patches_raw = extract_patches( X, patch_shape=(p_size, p_size, 3), extraction_step=SAMPLING_GAPS[n]) for i in range(IRLS_it): solve_irls(X, X_patches_raw, n, style_patches, neighbors, projection_matrix) # Step 3: Content Fusion X = const2 * (X + const1) # Step 4: Color Transfer X = color_transfer(X, style) # Step 5: Denoising X[:style_L_sx, :style_L_sx, :] = denoise( X[:style_L_sx, :style_L_sx, :], sigma_r=sigma_r, sigma_s=sigma_s) X = X[:style_L_sx, :style_L_sx, :] # Discard padding. # Upscale X if (L > 0): sizex, sizey, _ = content_arr[L - 1].shape X = cv2.resize(X, (sizex, sizey)) return X
img.shape[-1]), extraction_step=patch_spacing) patches_flattened = patches.reshape( -1, patch_size * patch_size * img.shape[-1]) # Normalize data and create PCA object fitted to patches patches_normalized = patches_flattened - np.mean(patches_flattened, axis=0) pca = PCA(n_components=0.95, svd_solver="full") pca_patches = pca.fit_transform(patches_normalized) # Create nearest neighbor matcher based on PCA domain patches nn_matcher = NearestNeighbors(n_neighbors=1, algorithm="auto") nn_matcher = nn_matcher.fit(pca_patches) return patches.reshape(-1, patch_size * patch_size, img.shape[-1]), pca, nn_matcher if __name__ == "__main__": img = cv2.imread(os.path.join("images", "contents", "dog.jpg"), cv2.IMREAD_COLOR) x = np.array([[0, 1, 3, 5], [0, 4, 3, 2], [4, 3, 0, 1]]) patches = extract_patches(x.reshape(4, 3), patch_shape=(1, 2), extraction_step=2) print(patches) print(x) patches[0][0][0] = [100, 100] print(patches) print(x)
def get_patch_matrix(source, invalid_pixels, patch_size, max_patches=None): MAX_MEM = 500e6 # Maximum memory allowed. These things can get big fast. I_s = np.copy(source) I_ip = np.copy(invalid_pixels) h, w, d = I_s.shape # Downsize if the patch matrix will be too big. factor = 1 mem = 8 * h * w * d * patch_size * patch_size if mem > MAX_MEM: factor = int(np.sqrt(mem / MAX_MEM)) + 1 mem = 8 * h / factor * w / factor * d * patch_size * patch_size if mem > MAX_MEM: print("Patch matrix too large. Size:", mem) sys.exit() # Mark invalid pixels. I_s[I_ip < 1, :] = 1e5 ## Generate the patch_matrix. # Returns a matrix of dims [h-ps, w-ps, 1, ps, ps, nc] # Where 'ps' is patch_size and 'nc' is number of colors (3 assumed.) patch_matrix = extract_patches(I_s, patch_shape=(patch_size, patch_size, 3), extraction_step=(factor, factor, 1)) pmh, pmw = patch_matrix.shape[:2] patch_matrix = patch_matrix.reshape((pmh, pmw, patch_size, patch_size, 3)) # Get the differences between adjacent patches in 2D. adh = patch_size * patch_size * 3 * np.ones((pmh, pmw)) adw = np.copy(adh) adh[1:, :] = np.sum((patch_matrix[:-1] - patch_matrix[1:]) ** 2, axis=(2, 3, 4)) adw[:, 1:] = np.sum((patch_matrix[:, :-1] - patch_matrix[:, 1:]) ** 2, axis=(2, 3, 4)) ad = np.copy(adh) replace = adw < adh ad[replace] = adw[replace] # Reshape to new dims [(h-ps) * (w-ps), ps, ps, nc] patch_matrix = patch_matrix.reshape(-1, patch_size, patch_size, 3) ad = ad.reshape(pmh * pmw) # Remove invalid patches. Assume image values in range 0.0 to 1.0 for now. patch_sum = np.sum(patch_matrix, axis=(1, 2, 3)) valid = patch_sum <= patch_size * patch_size * I_s.shape[2] patch_matrix = patch_matrix[valid] ad = ad[valid] # If a maximum number of patches is specified, reduce the size if necessary. # For speed, only checking for differences of adjacent patches for now. if max_patches is not None: if patch_matrix.shape[0] > max_patches: # adjacent patch difference, 'apd'. Keep patches with large differences. # apd = np.sum((patch_matrix[:-1] - patch_matrix[1:])**2, axis=(1,2,3)) cutoff = np.sort(ad)[::-1][max_patches] # valid = np.zeros((1 + ad.shape[0]), dtype=np.bool) # valid[0] = True # valid[1:] = ad >= cutoff valid = ad >= cutoff patch_matrix = patch_matrix[valid] patch_matrix = patch_matrix[:max_patches] return patch_matrix
list_label = [line.split()[0] for line in f_label.readlines()] ## get names of training images list_patch_img = [line.split()[0] for line in f_patch.readlines() ] ## get names of image patches f_patch.seek(0) ## reset file pointer list_patch = [line.split() for line in f_patch.readlines()] ## get patches info f_label.close() f_patch.close() print '-------------Load data-------------' train_patches = [] for i in range(train_img_num): patches = extract_patches(train[i][0], (3, 32, 32), 32) temp = patches.reshape((-1, 3, 32, 32)) ## select 128 top patches/image line_index = list_patch_img.index( list_label[i]) ## find the location of corresponding patches ## print i, line_index, list_patch_img[line_index], len(temp) temp_slice = [ temp[int(index)] for index in list_patch[line_index][1:patches_per_img + 1] ] ## print temp_slice ## temp_slice = random.sample(temp, patches_per_img) for j in range(len(temp_slice)):
def transform(self, X): if type(X) == csr_matrix: X = X.toarray() if type(X) == pd.DataFrame: X = X.as_matrix() return np.rollaxis(extract_patches(X, (self.patchsize, X.shape[1]), self.stepsize), 1, 4)
print(img_data.dtype) assert len(np.unique(img_data)) == 3 print(img_shape) plt.imshow(img_data[:, :, img_shape[-1] // 2], cmap='gray') viz.matplot(plt, opts={'title': 'case_original', 'showlegend': True}) mirrored = np.flip(img_data.copy(), axis=(0, 1, 2)) # print(mirrored.shape) # plt.imshow(mirrored[img_shape[-1] // 2, :, :], cmap='gray') # viz.matplot( # plt, # opts={ # 'title': 'case_mirrored', # 'showlegend': True # } # ) patches = image.extract_patches(img_data, patch_size, strides) print(patches.shape) m_patches = image.extract_patches(mirrored, patch_size, strides) print(m_patches.shape) # patches = patches.reshape((-1, patch_size[0], patch_size[1], patch_size[2])) recovered = reconstruct_labels(patches, img_shape, 3, strides, m_patches) plt.imshow(recovered[:, :, img_shape[-1] // 2], cmap='gray') viz.matplot(plt, opts={'title': 'case_recovered', 'showlegend': True}) ''' img_data = img_data[None, None, :, :, :] c = torch.zeros((img_data.shape)) # ---------- Preprocess -------------------------------------------------------------- img_shape = img_data.shape full_pred = torch.zeros((img_shape)) background_color = img_data.min() img_data = torch.tensor(img_data, dtype=torch.float32)
def B_Patch_Preprocess_recon_3D(patch_size_x=5,patch_size_y=5,patch_size_z=5,prefix='SdA',in_root='',out_root='',recon_flag=True): patch_pixels = patch_size_x*patch_size_y*patch_size_z pixel_offset_x = int(2*patch_size_x*0.7) pixel_offset_y = int(2*patch_size_y*0.7) pixel_offset_z = 1 padding = patch_size_x #threshold = patch_pixels*0.3 #patches = np.zeros(patch_pixels*4) if recon_flag is True: recon_num = 5 else: recon_num = 4 patches = np.zeros(patch_size_x*patch_size_y*patch_size_z*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon=[] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='mha' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:]=='mha' and 'Recon' in file1: Recon.append(file1) number_of_images = len(Flair) print 'Number of Patients : ', number_of_images # # for image_iterator in range(number_of_images): print 'Image number : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) # print 'image created' print Folder[image_iterator] + Truth[image_iterator] try: Truth_image = new( Folder[image_iterator] + Truth[image_iterator] ) except: Truth_image = new2( Folder[image_iterator] + Truth[image_iterator] ) # print 'image created' if recon_flag is True: Recon_image = new(Folder[image_iterator]+Recon[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data if recon_flag is True: Recon_image=Recon_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 z_start = np.min(z_span) - padding z_stop = np.max(z_span) +padding+1 Flair_patch = image.extract_patches(Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T1_patch = image.extract_patches(T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T2_patch = image.extract_patches(T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) if recon_flag is True: Recon_patch = image.extract_patches(Recon_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) Truth_patch = image.extract_patches(Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) print 'Raw patches extracted' Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) if recon_flag is True: Recon_patch = Recon_patch.reshape(Recon_patch.shape[0]*Recon_patch.shape[1]*Recon_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1]*Truth_patch.shape[2], patch_size_x, patch_size_y, patch_size_z) print 'Patches reshaped' if recon_flag is True: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch, Recon_patch], axis=1) else: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2,(patch_size_z-1)/2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch),1) #print '3. truth dimension :', Truth_patch.shape num_of_class = [] for i in xrange(1,5): num_of_class.append(np.sum((Truth_patch==i).astype(int))) max_num = max(num_of_class) max_num_2 = max(x for x in num_of_class if x!=max_num) Flair_patch = image.extract_patches(Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z]) Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = image.extract_patches(T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = image.extract_patches(T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_patch = image.extract_patches(Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T_patch = T_patch.reshape(T_patch.shape[0]*T_patch.shape[1]*T_patch.shape[2],patch_size_x, patch_size_y, patch_size_z) T_patch = T_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2,(patch_size_z-1)/2] for i in xrange(1,5): #print 'Max : ', max_num_2 #print 'Present : ', np.sum(image_label==i).astype(int) diff = max_num_2-np.sum(T_patch==i).astype(int) #print 'Difference: ', diff #print 'Diff : ', diff if np.sum(T_patch==i).astype(int) >= max_num_2: #print 'Continuing i = ', i continue #print 'TEST : ', Truth_patch.shape if i not in T_patch: continue #print T_patch.shape #print np.sum(T_patch==i).astype(int) index_x = np.where(T_patch==i) #print 'Length : ',len(index_x) index = np.arange(len(index_x)) shuffle(index) temp = T_patch[index_x[index[0:diff]]] temp=temp.reshape(len(temp),1) Truth_patch = np.vstack([Truth_patch,temp]) #print 'pppp' #print len(index_x[index[0:diff]]) #print Flair_patch.shape F_p = Flair_patch[index_x[index[0:diff]],:] T1_p = T1_patch[index_x[index[0:diff]],:] T2_p = T2_patch[index_x[index[0:diff]],:] T_1c_p = T_1c_patch[index_x[index[0:diff]],:] temp_patch = np.concatenate([F_p, T1_p, T2_p, T_1c_p], axis=1) slice_patch = np.vstack([slice_patch, temp_patch]) print 'No. of 1 : ', np.sum((Truth_patch==1).astype(int)) print 'No. of 2 : ', np.sum((Truth_patch==2).astype(int)) print 'No. of 3 : ', np.sum((Truth_patch==3).astype(int)) print 'No. of 4 : ', np.sum((Truth_patch==4).astype(int)) patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) print ground_truth.shape print patches.shape # # #print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) #print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) # #print # ground_truth = ground_truth.reshape(len(ground_truth)) if recon_flag==False: patches = patches[:,0:patch_size_x*patch_size_y*patch_size_z*4] #np.save('Training_patches.npy',patches) #np.save('Training_labels.npy',ground_truth) #print ground_truth.shape #print patches.shape if 'training' in out_root and recon_flag==True: print'... Saving the balanced training patches' np.save(out_root+'b_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==True: print '... Saving the balance validation patches' np.save(out_root+'b_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_3D_'+prefix+'_.npy',ground_truth) if 'training' in out_root and recon_flag==False: print'... Saving the balanced training patches' np.save(out_root+'b_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==False: print '... Saving the balanced testing patches' np.save(out_root+'b_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_3D_'+prefix+'_.npy',ground_truth)
def rebuild(data, mask, D, block_size, block_up, ncores=None, positivity=False, variance=None, fix_mean=True, fit_intercept=False, use_crossval=False): if ncores is None: ncores = cpu_count() elif ncores > cpu_count(): ncores = cpu_count() data = data * mask[..., None] if len(block_size) == len(block_up): last = block_up[-1] else: last = block_size[-1] factor = np.divide(block_up, block_size) new_shape = (int(data.shape[0] * factor[0]), int(data.shape[1] * factor[1]), int(data.shape[2] * factor[2]), last) overlap = (1, 1, 1, last) new_overlap = overlap print(new_shape, new_overlap, factor) if block_size == block_up: D_depimpe = np.copy(D) else: D_depimpe = depimp_zoom(D, block_size, block_up, zoomarray=False) blocks = extract_patches(data, block_size, overlap).reshape(-1, np.prod(block_size)) del data # original_shape = blocks.shape # # check if recon is correct / only reconstruct old school way from the blocks to be on the safe side maybe? # recon = reconstruct_from_blocks(blocks, new_shape, block_size, block_up[:-1], new_overlap, weights=None) # return recon # blocks = np.asarray(blocks).reshape(-1, np.prod(block_size)) # get the variance as blocks if variance is not None: variance *= mask print(variance.shape) variance = extract_patches(variance, block_size[:-1], overlap[:-1]) print(variance.shape) # axis = list(range(variance.ndim//2, variance.ndim)) # variance = np.median(variance, axis=axis) # print(variance.shape, np.prod(block_size[:-1]), np.prod(block_size), np.prod(variance.shape)) variance = np.asarray(variance).reshape(-1, np.prod(block_size[:-1])) print(variance.shape) # skip empty rows from training since they are probably masked background mask = blocks.sum(axis=1) > np.prod(block_size) // 2 if variance is not None: variance = np.median(variance, axis=-1) # if we are on an edge, variance can be 0, so truncate those cases as well np.logical_and(mask, variance > 0, out=mask) variance = variance[mask] print(variance.shape, np.sum(variance == 0)) print(blocks.shape) blocks = blocks[mask] print(blocks.shape, D.shape, D_depimpe.shape, mask.shape, block_size, block_up, new_shape, new_overlap, 'pre l1 stuff') # if center: # blocks_mean = blocks.mean(axis=1, keepdims=True) # blocks -= blocks_mean tt = time() X_small_denoised, alpha, intercept, _ = solve_l1(blocks, D_depimpe, variance=variance, return_all=True, nlambdas=100, use_joblib=True, positivity=positivity, fit_intercept=True, standardize=True, progressbar=True, method='fork', ncores=ncores, use_crossval=use_crossval) print(X_small_denoised.shape, D_depimpe.shape, alpha.shape, intercept.shape) # print(np.min(alpha), np.max(alpha), np.abs(alpha).min(), np.abs(alpha).max()) # print(np.min(intercept), np.max(intercept), np.abs(intercept).min(), np.abs(intercept).max()) print('total time was {}'.format(time() - tt)) # if fix_mean: # mean = blocks.mean(axis=1) # else: # mean = None # if center: # intercept += blocks_mean # # reconstructor = None # should we put block_up from the original? # tt = time() # recon = reconstruct_from_indexes(alpha, D, intercept, new_shape, new_overlap, mask, block_size, block_up) # # print('reconstruction took {}'.format(time() - tt)) # return recon # we actually only want alpha and intercept in this step and throw out X if we do upsampling normally # for ease of use reason, we now use directly X for the reconstruction, but we should # 1. multiply back X # 2a. feed X in an empty array with a mask # # OR # # 2b. reconstruct the array and average things internally according to a mask tt = time() X_final = np.zeros(((mask.shape[0], ) + block_up), dtype=np.float32) if block_size != block_up: X_small_denoised = np.dot(D, alpha).T + intercept print('multiply time was {}'.format(time() - tt)) tt = time() X_final[mask] = X_small_denoised.reshape(-1, *block_up) recon = reconstruct_from_blocks(X_final, new_shape, block_size, block_up[:-1], new_overlap, weights=None) print('recon time was {}'.format(time() - tt)) del X_final, mask return recon
def U_Patch_Preprocess_recon_2D(patch_size_x=5,patch_size_y=5,prefix='SdA',in_root='',out_root=''): #Initialize user variables patch_size = patch_size_x patch_pixels = patch_size*patch_size pixel_offset = int(patch_size*0.5) padding = patch_size #threshold = patch_pixels*0.3 recon_num = 4 patches = np.zeros(patch_pixels*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: #print file1 if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='mha' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) try: Truth_image = new(Folder[image_iterator]+Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator]+Truth[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) start_slice = min(z_span) stop_slice = max(z_span) image_patch = np.zeros(patch_size*patch_size*recon_num) image_label = np.zeros(1) for i in range(start_slice, stop_slice+1): Flair_slice = np.transpose(Flair_image[:,:,i]) T1_slice = np.transpose(T1_image[:,:,i]) T2_slice = np.transpose(T2_image[:,:,i]) T_1c_slice = np.transpose(T_1c_image[:,:,i]) Truth_slice = np.transpose(Truth_image[:,:,i]) x_dim,y_dim = np.size(Flair_slice,axis=0), np.size(Flair_slice, axis=1) x_span,y_span = np.where(Truth_slice!=0) if len(x_span)==0 or len(y_span)==0: continue x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 Flair_patch = image.extract_patches(Flair_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T1_patch = image.extract_patches(T1_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T2_patch = image.extract_patches(T2_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T_1c_patch = image.extract_patches(T_1c_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) Truth_patch = image.extract_patches(Truth_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) #print '1. truth dimension :', Truth_patch.shape Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1], patch_size*patch_size) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1], patch_size*patch_size) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1], patch_size*patch_size) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1], patch_size*patch_size) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1], patch_size, patch_size) #print '2. truth dimension :', Truth_patch.shape slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size-1)/2,(patch_size-1)/2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch),1) patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) # ground_truth[np.where(ground_truth==3)]=1 # ground_truth[np.where(ground_truth==4)]=1 print print 'No. of 1 : ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 : ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 : ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 : ', np.sum((ground_truth==4).astype(int)) ground_truth = ground_truth.reshape(len(ground_truth)) print 'Shape of Un-balanced patches numpy array : ',patches.shape print 'Shape of Un-balanced ground truth : ',ground_truth.shape patches = np.float32(patches) ground_truth = np.float32(ground_truth) if 'training' in out_root: print'... Saving the 2D training patches' np.save(out_root+'u_trainpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_trainlabel_2D_'+prefix+'_.npy',ground_truth) elif 'validation' in out_root: print '... Saving the 2D validation patches' np.save(out_root+'u_validpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_validlabel_2D_'+prefix+'_.npy',ground_truth)
def extract_patches(filename_base, num_images, patch_size=conf.patch_size, phase='train'): patches = [] for i in range(1, num_images + 1): if phase == 'train': imageid = "satImage_%.3d" % i image_filename = filename_base + imageid + ".png" if os.path.isfile(image_filename): img = mpimg.imread(image_filename) img = resize( img, (conf.train_image_resize, conf.train_image_resize)) patches.append( image.extract_patches(img, (patch_size, patch_size), extraction_step=1)) rot90img = rotate(img, 90, reshape=False, mode='reflect', order=3) patches.append( image.extract_patches(rot90img, (patch_size, patch_size), extraction_step=1)) rot45img = rotate(img, 45, reshape=False, mode='reflect', order=3) patches.append( image.extract_patches(rot45img, (patch_size, patch_size), extraction_step=1)) rot135img = rotate(img, 135, reshape=False, mode='reflect', order=3) patches.append( image.extract_patches(rot135img, (patch_size, patch_size), extraction_step=1)) elif phase == 'test': imageid = "raw_test_%d_pixels" % i image_filename = filename_base + imageid + ".png" if os.path.isfile(image_filename): img = mpimg.imread(image_filename) img = resize(img, (conf.test_image_resize, conf.test_image_resize)) patches.append( image.extract_patches(img, (patch_size, patch_size), extraction_step=1)) elif phase == 'train_cnn_output': imageid = "raw_satImage_%.3d_pixels" % i image_filename = filename_base + imageid + ".png" if os.path.isfile(image_filename): img = mpimg.imread(image_filename) img = resize( img, (conf.train_image_resize, conf.train_image_resize)) patches.append( image.extract_patches(img, (patch_size, patch_size), extraction_step=1)) else: raise ValueError('incorrect phase') return patches
def B_Patch_Preprocess_recon_2D(patch_size_x=5,patch_size_y=5,prefix='Sda',in_root='',out_root='',recon_flag=True): #Initialize user variables patch_size = patch_size_x patch_pixels = patch_size*patch_size pixel_offset = int(patch_size*0.7) padding = patch_size*2 #threshold = patch_pixels*0.3 if recon_flag == False: recon_num = 4 if recon_flag == True: recon_num = 5 patches = np.zeros(patch_pixels*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon=[] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: #print file1 if file1[-3:]=='mha' and ( 'Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('t1_z' in file1 or 'T1' in file1): T1.append(file1) elif file1[-3:]=='mha' and ('t2' in file1 or 'T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('t1c_z' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:]=='mha' and 'Recon' in file1: Recon.append(file1) #elif file1[-3:]=='mha' and 'Recon' in file1: # Recon.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) if recon_flag == True: Recon_image = new(Folder[image_iterator]+Recon[image_iterator]) Truth_image = new(Folder[image_iterator]+Truth[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data if recon_flag == True: Recon_image=Recon_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) start_slice = min(z_span) stop_slice = max(z_span) image_patch = np.zeros(patch_size*patch_size*recon_num) image_label = np.zeros(1) for i in range(start_slice, stop_slice+1): Flair_slice = np.transpose(Flair_image[:,:,i]) T1_slice = np.transpose(T1_image[:,:,i]) T2_slice = np.transpose(T2_image[:,:,i]) T_1c_slice = np.transpose(T_1c_image[:,:,i]) if recon_flag==True: Recon_slice = np.transpose(Recon_image[:,:,i]) Truth_slice = np.transpose(Truth_image[:,:,i]) x_dim,y_dim = np.size(Flair_slice,axis=0), np.size(Flair_slice, axis=1) x_span,y_span = np.where(Truth_slice!=0) if len(x_span)==0 or len(y_span)==0: continue x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 Flair_patch = image.extract_patches(Flair_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T1_patch = image.extract_patches(T1_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T2_patch = image.extract_patches(T2_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T_1c_patch = image.extract_patches(T_1c_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) if recon_flag==True: Recon_patch = image.extract_patches(Recon_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) Truth_patch = image.extract_patches(Truth_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) #print '1. truth dimension :', Truth_patch.shape Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1], patch_size*patch_size) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1], patch_size*patch_size) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1], patch_size*patch_size) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1], patch_size*patch_size) if recon_flag==True: Recon_patch = Recon_patch.reshape(Recon_patch.shape[0]*Recon_patch.shape[1], patch_size*patch_size) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1], patch_size, patch_size) #print '2. truth dimension :', Truth_patch.shape if recon_flag == True: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch,Recon_patch], axis=1) else: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size-1)/2,(patch_size-1)/2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch),1) #print '3. truth dimension :', Truth_patch.shape image_patch = np.vstack([image_patch,slice_patch]) image_label = np.vstack([image_label, Truth_patch]) num_of_class = [] for i in xrange(1,5): num_of_class.append(np.sum((image_label==i).astype(int))) max_num = max(num_of_class) max_num_2 = max(x for x in num_of_class if x!=max_num) Flair_patch = image.extract_patches(Flair_image[:,:,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y) T1_patch = image.extract_patches(T1_image[:,:,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y) T2_patch = image.extract_patches(T2_image[:,:,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y) T_1c_patch = image.extract_patches(T_1c_image[:,:,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y) Truth_patch = image.extract_patches(Truth_image[:,:,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1]*Truth_patch.shape[2],patch_size_x, patch_size_y, 1) Truth_patch = Truth_patch[:,(patch_size-1)/2,(patch_size-1)/2] for i in xrange(1,5): #print 'Max : ', max_num_2 #print 'Present : ', np.sum(image_label==i).astype(int) diff = max_num_2-np.sum(image_label==i).astype(int) #print 'Diff : ', diff if np.sum(image_label==i).astype(int) >= max_num_2: #print 'Continuing i = ', i continue #print 'TEST : ', Truth_patch.shape index_x,index_y = np.where(Truth_patch==i) #print 'Length : ',len(index_x) index = np.arange(len(index_x)) shuffle(index) temp = Truth_patch[index_x[index[0:diff]],:] image_label = np.vstack([image_label,temp]) F_p = Flair_patch[index_x[index[0:diff]],:] T1_p = T1_patch[index_x[index[0:diff]],:] T2_p = T2_patch[index_x[index[0:diff]],:] T_1c_p = T_1c_patch[index_x[index[0:diff]],:] temp_patch = np.concatenate([F_p, T1_p, T2_p, T_1c_p], axis=1) image_patch = np.vstack([image_patch, temp_patch]) # # #print 'image patch : ', image_patch.shape # #print 'image_label : ', image_label.shape # index_x,index_y = np.where(image_label==i) # temp_patch = image_patch[index_x,:] # temp_label = image_label[index_x,:] # index = np.arange(len(temp_patch)) # shuffle(index) # #print 'Temp patch : ', temp_patch.shape # #print 'Temp_label : ', temp_label.shape # if len(index)>min_num_2: # temp_patch = temp_patch[index[0:min_num_2],:] # temp_label = temp_label[index[0:min_num_2],:] patches = np.vstack([patches,image_patch]) ground_truth = np.vstack([ground_truth, image_label]) print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) print print 'No. of 1 : ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 : ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 : ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 : ', np.sum((ground_truth==4).astype(int)) # patches = np.vstack([patches,slice_patch]) # ground_truth = np.vstack([ground_truth, Truth_patch]) print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) print print 'No. of 1 : ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 : ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 : ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 : ', np.sum((ground_truth==4).astype(int)) ground_truth = ground_truth.reshape(len(ground_truth)) print 'Shape of balanced patches numpy array : ',patches.shape print 'Shape of balanced ground truth : ',ground_truth.shape if recon_flag==False: patches = patches[:,0:patch_size*patch_size*4] if 'training' in out_root and recon_flag == True: print'... Saving the 2D training patches' np.save(out_root+'b_trainpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_2D_'+prefix+'_.npy',ground_truth) elif recon_flag == True: print '... Saving the 2D validation patches' np.save(out_root+'b_validpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_2D_'+prefix+'_.npy',ground_truth) if 'training' in out_root and recon_flag == False: print'... Saving the 2D training patches' np.save(out_root+'b_trainpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_2D_'+prefix+'_.npy',ground_truth) elif recon_flag == False: print '... Saving the 2D validation patches' np.save(out_root+'b_validpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_2D_'+prefix+'_.npy',ground_truth)
truth_pixels = [] patches = np.zeros((1,patch_size,patch_size)) ground_truths = np.zeros((1)) print '==> Extracting patches..' stop_slice = img.shape[2] for j in xrange(0, stop_slice): image_slice = img[:,:,j] truth_slice = truth[:,:,j] patch = image.extract_patches(image_slice[100:300,100:300], patch_size, extraction_step = 3) patch = patch.reshape(patch.shape[0]*patch.shape[1],patch_size,patch_size) truth_patch = image.extract_patches(truth_slice[100:300,100:300], patch_size, extraction_step = 3) truth_patch = truth_patch.reshape(truth_patch.shape[0]*truth_patch.shape[1],patch_size,patch_size) truth_values = truth_patch[:, (patch_size - 1)/2, (patch_size -1)/2] patches = np.append(patches,patch,axis=0) ground_truths = np.append(ground_truths,truth_values,axis=0) patches = patches[1:patches.shape[0]] ground_truths = ground_truths[1:ground_truths.shape[0]] # background = patches[np.where(np.mean(patches,axis=(1,2))<0)] # background_truths = ground_truths[np.where(np.mean(patches,axis=(1,2))<0)]
def classify_test_data_3d(activate2, W_list, b_list): path = '../BRATS/10_1/Normalised_Test/' Flair = [] T1 = [] T2 = [] T_1c = [] Folder = [] Subdir_array = [] # patch_size = 11 patch_size_x = 5 patch_size_y = 5 patch_size_z = 5 for subdir, dirs, files in os.walk(path): if len(Flair) is 20: break for file1 in files: #print file1 if file1[-3:]=='mha' and 'Flair' in file1: Flair.append(file1) Folder.append(subdir+'/') Subdir_array.append(subdir[-5:]) elif file1[-3:]=='mha' and 'T1' in file1: T1.append(file1) elif file1[-3:]=='mha' and 'T2' in file1: T2.append(file1) elif file1[-3:]=='mha' and 'T_1c' in file1: T_1c.append(file1) number_of_images = len(Flair) for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] print '... predicting' Flair_image = mha.new(Folder[image_iterator]+Flair[image_iterator]) T1_image = mha.new(Folder[image_iterator]+T1[image_iterator]) T2_image = mha.new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = mha.new(Folder[image_iterator]+T_1c[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data xdim, ydim, zdim = Flair_image.shape prediction_image = [] Flair_patch = image.extract_patches(Flair_image, [patch_size_x,patch_size_y,patch_size_z]) T1_patch = image.extract_patches(T1_image, [patch_size_x,patch_size_y,patch_size_z]) T2_patch = image.extract_patches(T2_image, [patch_size_x,patch_size_y,patch_size_z]) T_1c_patch = image.extract_patches(T_1c_image, [patch_size_x,patch_size_y,patch_size_z]) print 'Raw patches extracted' print Flair_patch.shape print T1_patch.shape print T2_patch.shape print T_1c_patch.shape for j in range(Flair_patch.shape[2]): print 'Slice : ',j+1 F_slice = Flair_patch[:,:,j,:,:,:] T1_slice = T1_patch[:,:,j,:,:,:] T2_slice = T2_patch[:,:,j,:,:,:] T_1c_slice = T_1c_patch[:,:,j,:,:,:] F_slice = F_slice.reshape(F_slice.shape[0]*F_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) T1_slice = T1_slice.reshape(T1_slice.shape[0]*T1_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) T2_slice = T2_slice.reshape(T2_slice.shape[0]*T2_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) T_1c_slice = T_1c_slice.reshape(T_1c_slice.shape[0]*T_1c_slice.shape[1], patch_size_x*patch_size_y*patch_size_z) temp_patch = np.concatenate([F_slice,T1_slice,T2_slice,T_1c_slice],axis=1) print 'Size of temp_patch : ',temp_patch.shape prediction_slice = predictOutput(temp_patch, activate2, W_list, b_list) prediction_image.append(prediction_slice) prediction_image = np.array(prediction_image) prediction_image = np.transpose(prediction_image) prediction_image = prediction_image.reshape([xdim-patch_size_x+1, ydim-patch_size_y+1, zdim-patch_size_z+1]) output_image = np.zeros([xdim,ydim,zdim]) output_image[1+((patch_size_x-1)/2):xdim-((patch_size_x-1)/2)+1,1+((patch_size_y-1)/2):ydim-((patch_size_y-1)/2)+1,1+((patch_size_z-1)/2):zdim-((patch_size_z-1)/2)+1] = prediction_image np.save(Folder[image_iterator]+Subdir_array[image_iterator]+'_output_image.npy',output_image)#TODO: save it in meaningful name in corresponding folder
T1_slice = np.transpose(T1_image[:,:,i]) T2_slice = np.transpose(T2_image[:,:,i]) T_1c_slice = np.transpose(T_1c_image[:,:,i]) Truth_slice = np.transpose(Truth_image[:,:,i]) x_dim,y_dim = np.size(Flair_slice,axis=0), np.size(Flair_slice, axis=1) x_span,y_span = np.where(Truth_slice!=0) if len(x_span)==0 or len(y_span)==0: continue x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 Flair_patch = image.extract_patches(Flair_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T1_patch = image.extract_patches(T1_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T2_patch = image.extract_patches(T2_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T_1c_patch = image.extract_patches(T_1c_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) Truth_patch = image.extract_patches(Truth_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) #print '1. truth dimension :', Truth_patch.shape Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1], patch_size*patch_size) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1], patch_size*patch_size) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1], patch_size*patch_size) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1], patch_size*patch_size) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1], patch_size, patch_size) #print '2. truth dimension :', Truth_patch.shape
def get_hcp_2dpatches_SegmentationHR(extract_pourcent,patch_size = 128, n_patches = 1000, data = None): (T1s,T2s,T3s,T4s,masks) = data n_images = len(T2s) T1_patches = None T2_patches = None T3_patches= None T4_patches = None T1 = [] T2 = [] T3 = [] T4 = [] mask_extract = extract_pourcent patch_shape = (patch_size,patch_size) random_state = None for i in tqdm(range(n_images)): #Normalize data using mask T2_norm = array_normalization(X=T2s[i],M=masks[i],norm=0) mask = masks[i] T1_norm = T1s[i] T3_norm= T3s[i] T4_norm= T4s[i] for j in range(T1_norm.shape[2]): #Loop over the slices pT1 = extract_patches(T1_norm[:,:,j], patch_shape, extraction_step = 1) pT2 = extract_patches(T2_norm[:,:,j], patch_shape, extraction_step = 1) pT3 = extract_patches(T3_norm[:,:,j], patch_shape, extraction_step = 1) pT4 = extract_patches(T4_norm[:,:,j], patch_shape, extraction_step = 1) pmask = extract_patches(mask[:,:,j], patch_shape, extraction_step = 1) rng = check_random_state(random_state) i_s = rng.randint(T1_norm.shape[0] - patch_shape[0] + 1, size = n_patches) j_s = rng.randint(T1_norm.shape[1] - patch_shape[1] + 1, size = n_patches) pT1 = pT1[i_s, j_s] pT2 = pT2[i_s, j_s] pT3 = pT3[i_s, j_s] pT4 = pT4[i_s, j_s] pmask = pmask[i_s, j_s] #Channel last pT1 = pT1.reshape(-1, patch_shape[0], patch_shape[1]) pT2 = pT2.reshape(-1, patch_shape[0], patch_shape[1]) pT3 = pT3.reshape(-1, patch_shape[0], patch_shape[1]) pT4 = pT4.reshape(-1, patch_shape[0], patch_shape[1]) pmask = pmask.reshape(-1, patch_shape[0], patch_shape[1]) pmask = pmask.reshape(pmask.shape[0],-1) #Remove empty patches (<65% of mask) pmT1 = pT1[ np.mean(pmask,axis=1)>=mask_extract ] pmT2 = pT2[ np.mean(pmask,axis=1)>=mask_extract ] pmT3 = pT3[ np.mean(pmask,axis=1)>=mask_extract ] pmT4 = pT4[ np.mean(pmask,axis=1)>=mask_extract ] T1.append(pmT1) T2.append(pmT2) T3.append(pmT3) T4.append(pmT4) T1_patches = np.concatenate(T1,axis=0) T2_patches = np.concatenate(T2,axis=0) T3_patches = np.concatenate(T3,axis=0) T4_patches = np.concatenate(T4,axis=0) return (T1_patches,T2_patches,T3_patches,T4_patches)
def U_Patch_Preprocess_recon_3D(patch_size_x=5,patch_size_y=5,patch_size_z=5,prefix='SdA',in_root='',out_root='',recon_flag=True): patch_pixels = patch_size_x*patch_size_y*patch_size_z pixel_offset_x = int(patch_size_x*0.7) pixel_offset_y = int(patch_size_y*0.7) pixel_offset_z = 1 padding = patch_size_x #patches = np.zeros(patch_pixels*4) if recon_flag is True: recon_num = 5 else: recon_num = 4 patches = np.zeros(patch_size_x*patch_size_y*patch_size_z*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root print path Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon=[] Folder = [] for subdir, dirs, files in os.walk(path): if len(Flair) is 21: break for file1 in files: #print file1 if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='mha' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:]=='mha' and 'Recon' in file1: Recon.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Image number : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) if recon_flag is True: Recon_image = new(Folder[image_iterator]+Recon[image_iterator]) try: Truth_image = new(Folder[image_iterator]+Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator]+Truth[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data if recon_flag is True: Recon_image=Recon_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 z_start = np.min(z_span) - padding z_stop = np.max(z_span) +padding+1 Flair_patch = image.extract_patches(Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T1_patch = image.extract_patches(T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T2_patch = image.extract_patches(T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) if recon_flag is True: Recon_patch = image.extract_patches(Recon_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) Truth_patch = image.extract_patches(Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) print 'Raw patches extracted' Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) if recon_flag is True: Recon_patch = Recon_patch.reshape(Recon_patch.shape[0]*Recon_patch.shape[1]*Recon_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1]*Truth_patch.shape[2], patch_size_x, patch_size_y, patch_size_z) print 'Patches reshaped' if recon_flag is True: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch, Recon_patch], axis=1) else: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2,(patch_size_z-1)/2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch),1) #print '3. truth dimension :', Truth_patch.shape patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) # # print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) print print 'No. of 1 : ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 : ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 : ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 : ', np.sum((ground_truth==4).astype(int)) ground_truth = ground_truth.reshape(len(ground_truth)) if recon_flag==False: patches = patches[:,0:patch_size_x*patch_size_y*patch_size_z*4] #np.save('Training_patches.npy',patches) #np.save('Training_labels.npy',ground_truth) #print ground_truth.shape #print patches.shape if 'training' in out_root and recon_flag==True: print'... Saving the unbalanced training patches' np.save(out_root+'u_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'u_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==True: print '... Saving the unbalanced test ing patches' np.save(out_root+'u_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'u_validlabel_3D_'+prefix+'_.npy',ground_truth) if 'training' in out_root and recon_flag==False: print'... Saving the unbalanced training patches' np.save(out_root+'u_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'u_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==False: print '... Saving the unbalanced testing patches' np.save(out_root+'u_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'u_validlabel_3D_'+prefix+'_.npy',ground_truth)
def perfect_balance_3D(patch_size_x=5,patch_size_y=5,patch_size_z=5,prefix='SdA',in_root='',out_root='',recon_flag=False): patch_pixels = patch_size_x*patch_size_y*patch_size_z pixel_offset_x = int(patch_size_x*0.5) pixel_offset_y = int(patch_size_y*0.5) pixel_offset_z = 2 padding = patch_size_x #threshold = patch_pixels*0.3 #patches = np.zeros(patch_pixels*4) if recon_flag is True: recon_num = 5 else: recon_num = 4 patches = np.zeros(patch_size_x*patch_size_y*patch_size_z*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon=[] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='mha' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) elif file1[-3:]=='mha' and 'Recon' in file1: Recon.append(file1) number_of_images = len(Flair) print 'Number of Patients : ', number_of_images # # for image_iterator in range(number_of_images): print 'Image number : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) # print 'image created' print Folder[image_iterator] + Truth[image_iterator] try: Truth_image = new( Folder[image_iterator] + Truth[image_iterator] ) except: Truth_image = new2( Folder[image_iterator] + Truth[image_iterator] ) # print 'image created' Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data Truth_image = Truth_image.data ###################################################################### ##################Converting truth#################################### # new_Truth_image = np.zeros(Truth_image.shape,dtype=int) # new_Truth_image[np.where(Truth_image==0)] = 0 # new_Truth_image[np.where(Truth_image==1)] = 4 # new_Truth_image[np.where(Truth_image==2)] = 1 # new_Truth_image[np.where(Truth_image==3)] = 3 # new_Truth_image[np.where(Truth_image==4)] = 2 # Truth_image = new_Truth_image ###################################################################### x_span,y_span,z_span = np.where(Truth_image!=0) x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 z_start = np.min(z_span) - padding z_stop = np.max(z_span) +padding+1 Flair_patch = image.extract_patches(Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop], [patch_size_x,patch_size_y,patch_size_z]) Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = image.extract_patches(T1_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = image.extract_patches(T2_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_patch = image.extract_patches(Truth_image[x_start:x_stop, y_start:y_stop, z_start:z_stop],[patch_size_x,patch_size_y,patch_size_z]) T_patch = T_patch.reshape(T_patch.shape[0]*T_patch.shape[1]*T_patch.shape[2],patch_size_x, patch_size_y, patch_size_z) T_patch = T_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2,(patch_size_z-1)/2] T_patch = T_patch.reshape(len(T_patch),1) num_of_class = [] for i in xrange(0,5): num_of_class.append(np.sum((T_patch==i).astype(int))) minim = min(x for x in num_of_class if x!=0) if minim > 3000: minim = 3000 slice_patch = np.zeros(patch_size_x*patch_size_y*patch_size_z*recon_num) # print ' CHECK ', slice_patch.shape Truth_patch = np.zeros(1) # print minim # print for i in xrange(5): if num_of_class[i]==0: continue # print 'LOOK ' , i index_x, index_y = np.where(T_patch==i) # print index_x index1 = np.arange(len(index_x)) shuffle(index1) # print index1 # print index_x[index1[0:minim]].shape slice_patch1 = np.concatenate([Flair_patch[index_x[index1[0:minim]],:],T1_patch[index_x[index1[0:minim]],:], T2_patch[index_x[index1[0:minim]],:], T_1c_patch[index_x[index1[0:minim]],:]], axis=1) # print 'Slice_patch 1', slice_patch1.shape # print 'Slice patch ', slice_patch.shape slice_patch = np.vstack([slice_patch, slice_patch1]) # print Truth_patch.shape # print T_patch.shape Truth_patch = np.vstack([Truth_patch, T_patch[index_x[index1[0:minim]]]]) print 'No. of 0 Normal tissue : ', np.sum((Truth_patch==0).astype(int)) print 'No. of 1 Necrotic : ', np.sum((Truth_patch==1).astype(int)) print 'No. of 2 Edyma : ', np.sum((Truth_patch==2).astype(int)) print 'No. of 3 Non-Enhancing : ', np.sum((Truth_patch==3).astype(int)) print 'No. of 4 Enhancing : ', np.sum((Truth_patch==4).astype(int)) patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) ####################################################################### ##########Extracting more patches from ground truth#################### Flair_image[x_start:x_stop, y_start:y_stop, z_start:z_stop] = 0 Flair_patch = image.extract_patches(Flair_image, [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T1_patch = image.extract_patches(T1_image, [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T2_patch = image.extract_patches(T2_image, [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) T_1c_patch = image.extract_patches(T_1c_image, [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) Truth_patch = image.extract_patches(Truth_image, [patch_size_x,patch_size_y,patch_size_z],(pixel_offset_x,pixel_offset_y,pixel_offset_z)) print 'New Raw patches extracted' Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y*patch_size_z) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1]*Truth_patch.shape[2], patch_size_x, patch_size_y, patch_size_z) indexx = np.where(Flair_patch[:,int(patch_size_x*patch_size_y*patch_size_z/2)]>1.5) indexx = indexx[0] shuffle(indexx) if len(indexx)>500: indexx = indexx[0:500] # print indexx.shape Flair_patch = Flair_patch[indexx,:] T1_patch = T1_patch[indexx,:] T2_patch = T2_patch[indexx,:] T_1c_patch = T_1c_patch[indexx,:] Truth_patch =Truth_patch[indexx, :] # print Truth_patch.shape # print Flair_patch.shape slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size_x-1)/2,(patch_size_y-1)/2,(patch_size_z-1)/2] Truth_patch = np.array(Truth_patch) # print Truth_patch.shape Truth_patch = Truth_patch.reshape(len(Truth_patch),1) # slice_patch = slice_patch[0,:,:] # print patches.shape # print slice_patch.shape patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) print 'Extra patches added! ', len(indexx) print 'Patches reshaped' ####################################################################### print ground_truth.shape print patches.shape ground_truth = ground_truth.reshape(len(ground_truth)) print 'No. of 0 Normal tissue: ', np.sum((ground_truth==0).astype(int)) print 'No. of 1 Necrotic: ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 Edyma: ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 Non-enhancing: ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 Enhancing: ', np.sum((ground_truth==4).astype(int)) #np.save('Training_patches.npy',patches) #np.save('Training_labels.npy',ground_truth) #print ground_truth.shape #print patches.shape if 'training' in out_root and recon_flag==True: print'... Saving the balanced training patches' np.save(out_root+'b_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==True: print '... Saving the balance validation patches' np.save(out_root+'b_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_3D_'+prefix+'_.npy',ground_truth) if 'training' in out_root and recon_flag==False: print'... Saving the balanced training patches' np.save(out_root+'b_trainpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_trainlabel_3D_'+prefix+'_.npy',ground_truth) elif recon_flag==False: print '... Saving the balanced testing patches' np.save(out_root+'b_validpatch_3D_'+prefix+'_.npy',patches) np.save(out_root+'b_validlabel_3D_'+prefix+'_.npy',ground_truth)
Grafull_path = os.path.join(test_Graimg_path, line) f = Image.open(full_path) Graf = Image.open(Grafull_path) img = np.asarray(f, dtype=np.float32) Gra = np.asarray(Graf, dtype=np.float32) img = img.transpose(2, 0, 1) Gra = Gra.transpose(2, 0, 1) img1 = np.zeros((1, 3, Gra.shape[1], Gra.shape[2])) img1[0, :, :, :] = img Gra1 = np.zeros((1, 3, Gra.shape[1], Gra.shape[2])) Gra1[0, :, :, :] = Gra patches = extract_patches(img, (3, patchSize, patchSize), patchSize) Grapatches = extract_patches(Gra, (3, patchSize, patchSize), patchSize) test_patches = [] X = patches.reshape((-1, 3, patchSize, patchSize)) GraX = Grapatches.reshape((-1, 3, patchSize, patchSize)) y = [] t = xp.zeros((1, 1), np.float32) # t[0][0] = int(la) #for debug X_batch = np.zeros(X.shape) for i in range(len(X_batch)): X_batch[i] = X[int(i)] X_batch = X_batch[:patches_per_img] X_batch = xp.array(X_batch.astype(np.float32))
def perfect_balance_2D(patch_size_x=5,patch_size_y=5,prefix='Sda',in_root='',out_root=''): #Initialize user variables patch_size = patch_size_x patch_pixels = patch_size*patch_size pixel_offset = patch_size padding = patch_size #threshold = patch_pixels*0.3 recon_num = 4 label_num = 5 patches = np.zeros(patch_pixels*recon_num) # ground_truth = np.zeros(1) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: #print file1 if file1[-3:]=='mha' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='mha' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='mha' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = new(Folder[image_iterator]+Flair[image_iterator]) T1_image = new(Folder[image_iterator]+T1[image_iterator]) T2_image = new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = new(Folder[image_iterator]+T_1c[image_iterator]) try: Truth_image = new(Folder[image_iterator]+Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator]+Truth[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data Truth_image = Truth_image.data # Truth_image[np.where(Truth_image==3)]=1 # Truth_image[np.where(Truth_image==4)]=1 x_span,y_span,z_span = np.where(Truth_image!=0) start_slice = min(z_span) stop_slice = max(z_span) x_start = min(x_span)-30 x_stop = max(x_span)+30 y_start = min(y_span)-30 y_stop = max(y_span)+30 Flair_patch = image.extract_patches(Flair_image[x_start:x_stop,y_start:y_stop,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1]*Flair_patch.shape[2], patch_size_x*patch_size_y) T1_patch = image.extract_patches(T1_image[x_start:x_stop,y_start:y_stop,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1]*T1_patch.shape[2], patch_size_x*patch_size_y) T2_patch = image.extract_patches(T2_image[x_start:x_stop,y_start:y_stop,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1]*T2_patch.shape[2], patch_size_x*patch_size_y) T_1c_patch = image.extract_patches(T_1c_image[x_start:x_stop,y_start:y_stop,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1]*T_1c_patch.shape[2], patch_size_x*patch_size_y) T_patch = image.extract_patches(Truth_image[x_start:x_stop,y_start:y_stop,start_slice:stop_slice],[patch_size_x,patch_size_y,1]) T_patch = T_patch.reshape(T_patch.shape[0]*T_patch.shape[1]*T_patch.shape[2],patch_size_x, patch_size_y, 1) T_patch = T_patch[:,(patch_size-1)/2,(patch_size-1)/2] num_of_class = [] for i in xrange(0,label_num): num_of_class.append(np.sum((T_patch==i).astype(int))) minim = min(x for x in num_of_class if x!=0) if minim>3000: minim = 3000 # flair_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t1_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t2_patch = np.zeros(patch_size_x*patch_size_y*recon_num) # t1c_patch = np.zeros(patch_size_x*patch_size_y*recon_num) slice_patch = np.zeros(patch_size_x*patch_size_y*recon_num) Truth_patch = np.zeros(1) # print minim # print for i in xrange(5): if num_of_class[i]==0: continue index_x, index_y = np.where(T_patch==i) index1 = np.arange(len(index_x)) shuffle(index1) # print index1 # print index_x[index1[0:minim]].shape slice_patch1 = np.concatenate([Flair_patch[index_x[index1[0:minim]],:],T1_patch[index_x[index1[0:minim]],:], T2_patch[index_x[index1[0:minim]],:], T_1c_patch[index_x[index1[0:minim]],:]], axis=1) slice_patch = np.vstack([slice_patch, slice_patch1]) # flair_patch = np.vstack([flair_patch, Flair_patch[index_x[index1[0:minim]],:]]) # t1_patch = np.vstack([t1_patch,T1_patch[index_x[index1[0:minim]],:]]) # t2_patch = np.vstack([t2_patch, T2_patch[index_x[index1[0:minim]],:]]) # t1c_patch = np.vstack([t1c_patch, T_1c_patch[index_x[index1[0:minim]],:]]) # print Truth_patch.shape # print T_patch.shape Truth_patch = np.vstack([Truth_patch, T_patch[index_x[index1[0:minim]]]]) print 'No. of 0 : ', np.sum((Truth_patch==0).astype(int)) print 'No. of 1 : ', np.sum((Truth_patch==1).astype(int)) print 'No. of 2 : ', np.sum((Truth_patch==2).astype(int)) print 'No. of 3 : ', np.sum((Truth_patch==3).astype(int)) print 'No. of 4 : ', np.sum((Truth_patch==4).astype(int)) Truth_patch = Truth_patch.reshape(len(Truth_patch)) print 'look here ---->',Truth_patch.shape # np.save(out_root+'patches_patient_flair'+str(image_iterator+1)+'.npy',flair_patch) # np.save(out_root+'patches_patient_t1'+str(image_iterator+1)+'.npy',t1_patch) # np.save(out_root+'patches_patient_t2'+str(image_iterator+1)+'.npy',t2_patch) # np.save(out_root+'patches_patient_t1c'+str(image_iterator+1)+'.npy',t1c_patch) # np.save(out_root+'patches_patient_'+str(image_iterator+1)+'.npy',slice_patch) # np.save(out_root+'labels_patient_'+str(image_iterator+1)+'.npy',Truth_patch) patches = np.vstack([patches,slice_patch]) print 'patches balanced shape',patches.shape ground_truth = np.append(ground_truth, Truth_patch) print 'ground shape--->',ground_truth.shape index1 = np.arange(patches.shape[0]) shuffle(index1) print np.shape(patches) patches = patches[index1,:] ground_truth = ground_truth[index1] patches = np.float32(patches) ground_truth = np.float32(ground_truth) if 'training' in out_root: np.save(out_root+'perfect_balance_trainpatch_'+prefix+'_.npy',patches) np.save(out_root+'perfect_balance_traintruth_'+prefix+'_.npy',ground_truth) else: np.save(out_root+'perfect_balance_validpatch_'+prefix+'_.npy',patches) np.save(out_root+'perfect_balance_validtruth_'+prefix+'_.npy',ground_truth)
if FR: model = FRModel(top=args.top) else: model = Model(top=args.top) cuda.cudnn_enabled = True cuda.check_cuda_available() xp = cuda.cupy serializers.load_hdf5(args.model, model) model.to_gpu() if FR: ref_img = cv2.imread(args.REF) ref_img = cv2.cvtColor(ref_img, cv2.COLOR_BGR2RGB) patches = extract_patches(ref_img, (32, 32, 3), 32) X_ref = np.transpose(patches.reshape((-1, 32, 32, 3)), (0, 3, 1, 2)) img = cv2.imread(args.INPUT) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) patches = extract_patches(img, (32, 32, 3), 32) X = np.transpose(patches.reshape((-1, 32, 32, 3)), (0, 3, 1, 2)) y = [] weights = [] batchsize = min(2000, X.shape[0]) t = xp.zeros((1, 1), np.float32) for i in six.moves.range(0, X.shape[0], batchsize): X_batch = X[i:i + batchsize] X_batch = xp.array(X_batch.astype(np.float32))
def U_Patch_Preprocess_recon_2D(patch_size_x=5,patch_size_y=5,prefix='SdA',in_root='',out_root='',recon_flag=True): #Initialize user variables patch_size = patch_size_x patch_pixels = patch_size*patch_size pixel_offset = int(patch_size*0.7) padding = patch_size/2 threshold = patch_pixels*0.3 if recon_flag == False: recon_num = 4 if recon_flag == True: recon_num = 5 patches = np.zeros(patch_pixels*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Recon=[] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 4: # break for file1 in files: #print file1 if file1[-3:]=='mha' and 'Flair' in file1: Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='mha' and 'T1' in file1: T1.append(file1) elif file1[-3:]=='mha' and 'T2' in file1: T2.append(file1) elif file1[-3:]=='mha' and 'T_1c' in file1: T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) #elif file1[-3:]=='mha' and 'Recon' in file1: # Recon.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = mha.new(Folder[image_iterator]+Flair[image_iterator]) T1_image = mha.new(Folder[image_iterator]+T1[image_iterator]) T2_image = mha.new(Folder[image_iterator]+T2[image_iterator]) T_1c_image = mha.new(Folder[image_iterator]+T_1c[image_iterator]) if recon_flag == True: Recon_image = mha.new(Folder[image_iterator]+Recon[image_iterator]) Truth_image = mha.new(Folder[image_iterator]+Truth[image_iterator]) Flair_image = Flair_image.data T1_image = T1_image.data T2_image = T2_image.data T_1c_image = T_1c_image.data if recon_flag == True: Recon_image=Recon_image.data Truth_image = Truth_image.data x_span,y_span,z_span = np.where(Truth_image!=0) start_slice = min(z_span) stop_slice = max(z_span) image_patch = np.zeros(patch_size*patch_size*recon_num) image_label = np.zeros(1) for i in range(start_slice, stop_slice+1): Flair_slice = np.transpose(Flair_image[:,:,i]) T1_slice = np.transpose(T1_image[:,:,i]) T2_slice = np.transpose(T2_image[:,:,i]) T_1c_slice = np.transpose(T_1c_image[:,:,i]) if recon_flag==True: Recon_slice = np.transpose(Recon_image[:,:,i]) Truth_slice = np.transpose(Truth_image[:,:,i]) x_dim,y_dim = np.size(Flair_slice,axis=0), np.size(Flair_slice, axis=1) x_span,y_span = np.where(Truth_slice!=0) if len(x_span)==0 or len(y_span)==0: continue x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 Flair_patch = image.extract_patches(Flair_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T1_patch = image.extract_patches(T1_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T2_patch = image.extract_patches(T2_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T_1c_patch = image.extract_patches(T_1c_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) if recon_flag==True: Recon_patch = image.extract_patches(Recon_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) Truth_patch = image.extract_patches(Truth_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) #print '1. truth dimension :', Truth_patch.shape Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1], patch_size*patch_size) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1], patch_size*patch_size) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1], patch_size*patch_size) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1], patch_size*patch_size) if recon_flag==True: Recon_patch = Recon_patch.reshape(Recon_patch.shape[0]*Recon_patch.shape[1], patch_size*patch_size) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1], patch_size, patch_size) #print '2. truth dimension :', Truth_patch.shape if recon_flag == True: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch,Recon_patch], axis=1) else: slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size-1)/2,(patch_size-1)/2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch),1) #print '3. truth dimension :', Truth_patch.shape # image_patch = np.vstack([image_patch,slice_patch]) # image_label = np.vstack([image_label, Truth_patch]) # num_of_class = [] # for i in xrange(5): # num_of_class.append(np.sum((image_label==i).astype(int))) # min_num = min(num_of_class) # min_num_2 = min(x for x in num_of_class if x!=min_num) # for i in xrange(5): # #print 'image patch : ', image_patch.shape # #print 'image_label : ', image_label.shape # index_x,index_y = np.where(image_label==i) # temp_patch = image_patch[index_x,:] # temp_label = image_label[index_x,:] # index = np.arange(len(temp_patch)) # shuffle(index) # #print 'Temp patch : ', temp_patch.shape # #print 'Temp_label : ', temp_label.shape # if len(index)>min_num_2: # temp_patch = temp_patch[index[0:min_num_2],:] # temp_label = temp_label[index[0:min_num_2],:] # patches = np.vstack([patches,temp_patch]) # ground_truth = np.vstack([ground_truth, temp_label]) #------check indentation-----# patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) for k, item in enumerate(ground_truth): if item != 0: ground_truth[k] = 1 print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) ground_truth = ground_truth.reshape(len(ground_truth)) if recon_flag==False: patches = patches[:,0:patch_size*patch_size*4] if 'training' in out_root and recon_flag == True: print'... Saving the 2D training patches' np.save(out_root+'u_10_trainpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_10_trainlabel_2D_'+prefix+'_.npy',ground_truth) elif recon_flag == True: print '... Saving the 2D validation patches' np.save(out_root+'u_10_validpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_10_validlabel_2D_'+prefix+'_.npy',ground_truth) if 'training' in out_root and recon_flag == False: print'... Saving the 2D training patches' np.save(out_root+'u_10_trainpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_10_trainlabel_2D_'+prefix+'_.npy',ground_truth) elif recon_flag == False: print '... Saving the 2D validation patches' np.save(out_root+'u_10_validpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_10_validlabel_2D_'+prefix+'_.npy',ground_truth)
def make_pytable(img_path, label_path, patch_size, stride_size, pad_size, split, num_classes, imgtype, labeltype): img_dtype = {} img_dtype['mask'] = tables.UInt8Atom() img_dtype['img'] = tables.Float32Atom() train_file = glob(img_path + "*." + imgtype) num_train = int(len(train_file) * (1 - split)) val_file = train_file[num_train:] train_file = train_file[:num_train] phases = {} phases['train'], phases['val'] = train_file, val_file block_shape = {} block_shape['img'] = np.array((patch_size, patch_size, 3)) block_shape['mask'] = np.array((patch_size, patch_size, num_classes)) filters = tables.Filters(complevel=6, complib='zlib') storage = {} imgtypes = ['img', 'mask'] for phase in phases.key(): print(phase) table_file = tables.open_file(f"./table_{phase}.pytable", mode='w') for type in imgtypes: storage[type] = table_file.create_earray( table_file.root, type, img_dtype[type], shape=np.append([0], block_shape[type]), chunkshape=np.append([1], block_shape[type]), filters=filters) for f in phases[phase]: print(f) for type in imgtypes: if type == "img": img = cv2.cvtColor(cv2.imread(f), cv2.COLOR_BGR2RGB) img = stain_normalization.normalizeStaining(img) img = img / 255.0 img = np.pad(img, [(pad_size, pad_size), (pad_size, pad_size), (0, 0)]) img = extract_patches(img, (patch_size, patch_size, 3), stride_size) img = img.reshape(-1, patch_size, patch_size, 3) else: img = cv2.cvtColor( cv2.imread(label_path + f.replace(imgtype, labeltype)), cv2.IMREAD_GRAYSCALE) if num_classes > 1: img = to_categorical(img, num_classes=num_classes) else: img = img.reshape(img.shape[0], img.shape[1], 1) img = padAndPatch(img, pad_size, patch_size, stride_size) storage[type].append(img) table_file.close()
def fit(self, modality, ground_truth=None, cat=None): """Compute the images images. Parameters ---------- modality : object of type TemporalModality The modality object of interest. ground-truth : object of type GTModality or None The ground-truth of GTModality. If None, the whole data will be considered. cat : str or None String corresponding at the ground-truth of interest. Cannot be None if ground-truth is not None. Return ------ self : object Return self. """ super(HaralickExtraction, self).fit(modality=modality, ground_truth=ground_truth, cat=cat) # Get the data and rescale as integers within the given levels vol_haralick = ((modality.data_ - np.ndarray.min(modality.data_)) * ((self.levels -1) / (np.ndarray.max(modality.data_) - np.ndarray.min(modality.data_)))).astype(int) # Extract the set of patches from the modality data patches = extract_patches(vol_haralick, patch_shape=self.patch_size) # Allocate the haralick maps, one for each feature that # will be computed nb_directions = 13 nb_features = 13 self.data_ = np.zeros((modality.data_.shape[0], modality.data_.shape[1], modality.data_.shape[2], nb_directions, nb_features)) # WE NEED TO PARALLELIZE THIS CODE # # Extract Haralick feature for each patch # # Define the shift to apply if isinstance(self.patch_size, tuple): y_shift = int(np.ceil((self.patch_size[0] - 1) / 2.)) x_shift = int(np.ceil((self.patch_size[1] - 1) / 2.)) z_shift = int(np.ceil((self.patch_size[2] - 1) / 2.)) elif isinstance(self.patch_size, int): y_shift = int(np.ceil((self.patch_size - 1) / 2.)) x_shift = int(np.ceil((self.patch_size - 1) / 2.)) z_shift = int(np.ceil((self.patch_size - 1) / 2.)) # for y in range(patches.shape[0]): # for x in range(patches.shape[1]): # for z in range(patches.shape[2]): # print 'Compute for the pixel at position {}{}{}'.format( # y, x, z) # # Compute the haralick features # self.data_[y + y_shift, # x + x_shift, # z + z_shift, :] = haralick( # patches[y, x, z, :], # distance=self.distance) # Create the list of indices to process yy, xx, zz = np.meshgrid(range(patches.shape[0]), range(patches.shape[1]), range(patches.shape[2])) # Linearize for fast processing yy = yy.reshape(-1) xx = xx.reshape(-1) zz = zz.reshape(-1) # Go for the parallel loop haralick_features = Parallel(n_jobs=-1)(delayed( _compute_haralick_features)(patches[y, x, z, :], self.distance) for y, x, z in zip(yy, xx, zz)) # Convert to numpy array haralick_features = np.array(haralick_features) # Reshape the feature matrix haralick_features = haralick_features.reshape((patches.shape[0], patches.shape[1], patches.shape[2], nb_directions, nb_features)) # Copy the feature into the object self.data_[y_shift : -y_shift, x_shift : -x_shift, z_shift : -z_shift] = haralick_features return self
def LBPpdfExtraction(im, **kwargs): # GOAL: extract the LBP pdf from a 2D image # We can handle 2D image, 3D image. # We need to get the minimum and maximum of the image range_lbp = kwargs.pop('range_lbp', (np.min(im), np.max(im))) # We need to decide the number of bins to be considered for # the computation of the pdf bins = range_lbp[1] - range_lbp[0] # We need to know if we normalisaed the histogram or not density = kwargs.pop('density', True) # Check if we wish a sliding window strategy_win = kwargs.pop('strategy_win', None) # Check the dimension of the input image if len(im.shape) == 2: nd_im = 2 elif len(im.shape) == 3: nd_im = 3 # By default, we will extract the LBP along a given axis extr_3d = kwargs.pop('extr_3d', '2.5D') extr_axis = kwargs.pop('extr_axis', 'y') else: raise ValueError('mahotas.texture.haralick: Can only handle 2D' ' and 3D images.') if nd_im == 2: if strategy_win == 'sliding_win': win_size = kwargs.pop('win_size', (7, 7)) overlap = kwargs.pop('overlap', False) if not overlap: # Import the function needed to extract patches from sklearn.feature_extraction.image import extract_patches patches = extract_patches(im, patch_shape=win_size, extraction_step=(win_size[0])) patches = patches.reshape(-1, win_size[0], win_size[1]) else: patches = ExtractPatches2D(im, win_size) # The number of cores to use num_cores = kwargs.pop('num_cores', multiprocessing.cpu_count()) hist_dict = {'bins' : bins, 'range' : range_lbp, 'density' : density} vol_hist = Parallel(n_jobs=num_cores)(delayed(hist_alone) (p, **hist_dict) for p in patches) return np.array(vol_hist) else: hist_dict = {'bins' : bins, 'range' : range_lbp, 'density' : density} return hist_alone(im, **hist_dict) elif nd_im == 3: if extr_3d == '2.5D': # We will process in parallel the different slice # along the given axis # The data are stored in (x, y, z) manner. We need to swap to the # first position the axis that is not involved in the 2D image if extr_axis == 'x': # Do not do anythin vol = im elif extr_axis == 'y': # Move y at the beginning vol = np.swapaxes(im, 1, 0) elif extr_axis == 'z': # Move z at the beginning vol = np.swapaxes(im, 2, 0) # The number of cores to use num_cores = kwargs.pop('num_cores', multiprocessing.cpu_count()) if strategy_win == 'sliding_win': win_size = kwargs.pop('win_size', (21, 21)) overlap = kwargs.pop('overlap', False) if not overlap: # Import the function needed to extract patches from sklearn.feature_extraction.image import extract_patches patches = Parallel(n_jobs=num_cores)(delayed(extract_patches) (im, patch_shape=win_size, extraction_step=(win_size[0])) for im in vol) patches = np.array(patches).reshape(-1, win_size[0], win_size[1]) else: raise ValueError('Still did not implemented this feature.' ' It could take so much merory.') hist_dict = {'bins' : bins, 'range' : range_lbp, 'density' : density} vol_hist = Parallel(n_jobs=num_cores)(delayed(hist_alone) (p, **hist_dict) for p in patches) return np.array(vol_hist) else: # The number of cores to use num_cores = kwargs.pop('num_cores', multiprocessing.cpu_count()) hist_dict = {'bins' : bins, 'range' : range_lbp, 'density' : density} vol_hist = Parallel(n_jobs=num_cores)(delayed(hist_alone) (sl, **hist_dict) for sl in vol) return np.array(vol_hist) elif extr_3d == '3D': # We need to use the LBP TOP print 'This strategy is not yet implemented.'
def extract_3d_patches(img_data, gt_data, mask_data, is_extract_more_csf): # patch details # patch_size = 32 patch_shape = (patch_size, patch_size, patch_size) # empty matrix to hold patches imgs_patches_per_volume = np.empty( shape=[0, patch_size, patch_size, patch_size], dtype='int16') gt_patches_per_volume = np.empty( shape=[0, patch_size, patch_size, patch_size], dtype='int16') mask_patches_per_volume = np.empty( shape=[0, patch_size, patch_size, patch_size], dtype='int16') img_patches = extract_patches(img_data, patch_shape, extraction_step) gt_patches = extract_patches(gt_data, patch_shape, extraction_step) mask_patches = extract_patches(mask_data, patch_shape, extraction_step) rows = [] cols = [] depths = [] for i in range(0, mask_patches.shape[0]): for j in range(0, mask_patches.shape[1]): for k in range(0, mask_patches.shape[2]): Point1 = int(patch_size / 2 - 1) Point2 = int(patch_size / 2) a1 = mask_patches.item((i, j, k, Point1, Point1, Point1)) a2 = mask_patches.item((i, j, k, Point1, Point1, Point2)) a3 = mask_patches.item((i, j, k, Point1, Point2, Point1)) a4 = mask_patches.item((i, j, k, Point1, Point2, Point2)) a5 = mask_patches.item((i, j, k, Point2, Point1, Point1)) a6 = mask_patches.item((i, j, k, Point2, Point1, Point2)) a7 = mask_patches.item((i, j, k, Point2, Point2, Point1)) a8 = mask_patches.item((i, j, k, Point2, Point2, Point2)) Sum = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 if Sum > 0: rows.append(i) cols.append(j) depths.append(k) # number of non-zero patches N = len(rows) # select non-zero patches index selected_img_patches = img_patches[rows, cols, depths, :, :, :] selected_gt_patches = gt_patches[rows, cols, depths, :, :, :] # update database imgs_patches_per_volume = np.append(imgs_patches_per_volume, selected_img_patches, axis=0) gt_patches_per_volume = np.append(gt_patches_per_volume, selected_gt_patches, axis=0) # extract more patches for CSF if is_extract_more_csf: # create CSF mask extraction_step_csf = extraction_step_csf_only img_patches_csf = extract_patches(img_data, patch_shape, extraction_step_csf) gt_patches_csf = extract_patches(gt_data, patch_shape, extraction_step_csf) # extract CSF patches with small step rows = [] cols = [] depths = [] for i in range(0, gt_patches_csf.shape[0]): for j in range(0, gt_patches_csf.shape[1]): for k in range(0, gt_patches_csf.shape[2]): Point1 = int(patch_size / 2 - 1) Point2 = int(patch_size / 2) a1 = gt_patches_csf.item((i, j, k, Point1, Point1, Point1)) a2 = gt_patches_csf.item((i, j, k, Point1, Point1, Point2)) a3 = gt_patches_csf.item((i, j, k, Point1, Point2, Point1)) a4 = gt_patches_csf.item((i, j, k, Point1, Point2, Point2)) a5 = gt_patches_csf.item((i, j, k, Point2, Point1, Point1)) a6 = gt_patches_csf.item((i, j, k, Point2, Point1, Point2)) a7 = gt_patches_csf.item((i, j, k, Point2, Point2, Point1)) a8 = gt_patches_csf.item((i, j, k, Point2, Point2, Point2)) Sum = (a1 == 1 or a2 == 1 or a3 == 1 or a4 == 1 or a5 == 1 or a6 == 1 or a7 == 1 or a8 == 1) if Sum: rows.append(i) cols.append(j) depths.append(k) N = len(rows) if N is not 0: csf_more_img_patches = img_patches_csf[rows, cols, depths, :, :, :] csf_more_gt_patches = gt_patches_csf[rows, cols, depths, :, :, :] # update database imgs_patches_per_volume = np.append(imgs_patches_per_volume, csf_more_img_patches, axis=0) gt_patches_per_volume = np.append(gt_patches_per_volume, csf_more_gt_patches, axis=0) # convert to categorical gt_patches_per_volume = separate_labels(gt_patches_per_volume) return imgs_patches_per_volume, gt_patches_per_volume
def extract_2d_patches(img_data, gt_data, mask_data, is_extract_more_csf): patch_shape = (patch_size, patch_size) # empty matrix to hold patches imgs_patches_per_slice = np.empty(shape=[0, patch_size, patch_size], dtype='int16') gt_patches_per_slice = np.empty(shape=[0, patch_size, patch_size], dtype='int16') mask_patches_per_slice = np.empty(shape=[0, patch_size, patch_size], dtype='int16') img_patches = extract_patches(img_data, patch_shape, extraction_step) gt_patches = extract_patches(gt_data, patch_shape, extraction_step) mask_patches = extract_patches(mask_data, patch_shape, extraction_step) # extract patches which has center pixel lying inside mask rows = [] cols = [] for i in range(0, mask_patches.shape[0]): for j in range(0, mask_patches.shape[1]): a1 = mask_patches.item( (i, j, int(patch_size / 2 - 1), int(patch_size / 2 - 1))) a2 = mask_patches.item( (i, j, int(patch_size / 2 - 1), int(patch_size / 2))) a3 = mask_patches.item( (i, j, int(patch_size / 2), int(patch_size / 2 - 1))) a4 = mask_patches.item( (i, j, int(patch_size / 2), int(patch_size / 2))) Sum = a1 + a2 + a3 + a4 if Sum > 0: rows.append(i) cols.append(j) # number of n0m zero patches N = len(rows) # select nonzeropatches index selected_img_patches = img_patches[rows, cols, :, :] selected_gt_patches = gt_patches[rows, cols, :, :] # update database imgs_patches_per_slice = np.append(imgs_patches_per_slice, selected_img_patches, axis=0) gt_patches_per_slice = np.append(gt_patches_per_slice, selected_gt_patches, axis=0) #extract more pathes for CSF if is_extract_more_csf: #creat CSF mask extraction_step_csf = extraction_step_csf_only img_patches_csf = extract_patches(img_data, patch_shape, extraction_step_csf) gt_patches_csf = extract_patches(gt_data, patch_shape, extraction_step_csf) # extract CSF patches with small step rows = [] cols = [] for i in range(0, gt_patches_csf.shape[0]): for j in range(0, gt_patches_csf.shape[1]): a1 = gt_patches_csf.item( (i, j, int(patch_size / 2 - 1), int(patch_size / 2 - 1))) a2 = gt_patches_csf.item( (i, j, int(patch_size / 2 - 1), int(patch_size / 2))) a3 = gt_patches_csf.item( (i, j, int(patch_size / 2), int(patch_size / 2 - 1))) a4 = gt_patches_csf.item( (i, j, int(patch_size / 2), int(patch_size / 2))) Sum = (a1 == 1 or a2 == 1 or a3 == 1 or a4 == 1) if Sum: rows.append(i) cols.append(j) N = len(rows) if N is not 0: csf_more_img_patches = img_patches_csf[rows, cols, :, :] csf_more_gt_patches = gt_patches_csf[rows, cols, :, :] # update database imgs_patches_per_slice = np.append(imgs_patches_per_slice, csf_more_img_patches, axis=0) gt_patches_per_slice = np.append(gt_patches_per_slice, csf_more_gt_patches, axis=0) # convert to categorical gt_patches_per_slice = separate_labels(gt_patches_per_slice) return imgs_patches_per_slice, gt_patches_per_slice
def upsampler_3D(data, variance=None, block_size=(3, 3, 3), block_up=(5, 5, 5), mask=None, dtype=np.float64, ncores=-1, params=None): factor = np.array(block_up) / np.array(block_size)[:-1] print(block_size, factor, block_up) if mask is None: mask = np.ones(data.shape[:3]) if data.ndim == 4: overlap = (1, 1, 1, data.shape[-1]) # overlap = tuple(block_size[:-1]) + (data.shape[-1],) # new_overlap = tuple(block_size[:-1]) + (data.shape[-1],) # new_overlap = tuple(block_up) + (data.shape[-1],) new_overlap = overlap # new_overlap = (2, 2, 2, data.shape[-1]) # new_size = np.array(block_size[:-1]) * factor new_size = np.array(block_up, dtype=np.int16) new_shape = (np.array(data.shape[:-1]) * factor).astype(np.int16) # pad_shape = np.array(data.shape[:-1]) + (np.mod(data.shape[:-1], block_size[:-1]).astype(np.bool) * np.array(block_size[:-1])) - np.mod(data.shape[:-1], block_size[:-1]) # new_shape = (factor * pad_shape).astype(np.int16) # new_shape = np.ceil(np.array(data.shape[:-1]) * new_size // np.array(block_size[:-1]) * new_size).astype(np.int16) # new_shape = (new_shape * new_size).astype(np.int16) # print(new_shape, data.shape[:-1], factor, 'shape') # new_shape = (int(data.shape[0] + 2*nup), # int(data.shape[1] + 2*nup), # int(data.shape[2] + 2*nup)) # new_shape = np.array(new_shape) # new_overlap = np.array(overlap[:-1]) * factor # new_overlap = np.array(overlap[:-1]) # new_overlap = np.array([2,2,2,data.shape[-1]]) new_size = tuple(new_size) + (data.shape[-1], ) new_shape = tuple(new_shape) + (data.shape[-1], ) # new_overlap = tuple(new_overlap.astype(np.int16)) + (data.shape[-1],) else: overlap = (1, 1, 1) new_size = np.ceil(np.array(block_size) * factor).astype(np.int16) new_shape = np.ceil(np.array(data.shape) * factor).astype(np.int16) new_overlap = np.ceil(np.array(overlap) * factor).astype(np.int16) print(block_size, data.shape, overlap, factor) print(new_size, new_shape, new_overlap, factor) print('train 1', mask.shape, data.shape, new_size[:-1]) # print(mask.flags) # 1/0 # mask_col = extract_patches(np.broadcast_to(mask[..., None], data.shape), new_size, overlap) mask_col = extract_patches(mask, new_size[:-1], overlap[:-1]) print('train 2', mask_col.shape) # 1/0 dims = tuple(range(mask_col.ndim // 2, mask_col.ndim)) shape = mask_col.shape[mask_col.ndim // 2:] train_idx = np.sum(mask_col, axis=dims) > (np.prod(shape) // 2) print(np.sum(mask_col, axis=dims).max(), np.prod(shape), shape) # 1/0 print('train 3', train_idx.shape, train_idx.max(), train_idx.sum(), mask.sum(), mask_col.sum()) trainer = extract_patches(data, new_size, overlap) X_upsampled_shape = np.prod(trainer.shape[:trainer.ndim // 2]), np.prod( trainer.shape[trainer.ndim // 2:]) print(X_upsampled_shape, trainer.shape) # 1/0 # trainer_grad = extract_patches(np.sum(np.gradient(data), axis=0), new_size, overlap) # train_data = np.concatenate((trainer[train_idx], trainer_grad[train_idx])) # train_data = trainer_grad[train_idx] train_data = trainer[train_idx] # train_idx = train_idx.ravel() # print(trainer.shape, train_idx.shape, trainer[train_idx].shape) # 1/0 print(dims, train_data.shape) axis = tuple(range(1, train_data.ndim)) # train_data -= train_data.mean(axis=axis, keepdims=True) print('train 4', train_data.shape, trainer.shape, data.shape, new_size) print('Constructing big D matrix') t = time() if variance is None: variance_large = None else: mask_large = extract_patches(mask, new_size[:-1], overlap[:-1]) shape = mask_large.shape[mask_large.ndim // 2:] dims = tuple(range(mask_large.ndim // 2, mask_large.ndim)) variance_mask = np.sum(mask_large, axis=dims) > (np.prod(shape) // 2) # print('variance shape', variance.shape, 0, variance_mask.shape) # print(extract_patches(variance, new_size[:-1], overlap[:-1]).shape) # print(new_overlap[:-1], new_size[:-1], overlap[:-1]) # 1/0 variance_large = extract_patches(variance, new_size[:-1], overlap[:-1])[variance_mask] # 1/0 # variance_large = extract_patches(np.broadcast_to(variance[..., None], data.shape), new_size, overlap)[train_idx] print('variance shape', variance_large.shape, train_idx.shape, dims, data.shape) axis = tuple(range(1, variance_large.ndim)) variance_large = np.median(variance_large, axis=axis) print('variance shape', variance_large.shape) # if False:#'D' in params: # print('found big D, skipping') # D = params['D'].copy() # else: n_atoms = int(np.prod(block_size) * 2) # n_atoms = int(np.prod(new_size) * 2) D = online_DL(train_data, ncores=ncores, positivity=True, fit_intercept=True, standardize=True, nlambdas=100, niter=150, batchsize=256, n_atoms=n_atoms, variance=variance_large, progressbar=True) print(D.shape) params['D'] = D print('mean D', np.abs(D).mean()) print('The D is done, time {}'.format(time() - t), D.shape) # D_depimpe = depimp_mean(D, block_size, factor) # print(D_depimpe.shape, D.shape, block_size, factor, 'shape 1') D_depimpe = depimp_zoom(D, block_size, block_up) print(D_depimpe.shape, D.shape, block_size, block_up, factor, 'shape 1') del train_data, mask_col, shape t = time() # padding = tuple(np.array(block_up) - np.array(block_size[:-1])) + (0,) # padding = ((padding[0], padding[0]), # (padding[1], padding[1]), # (padding[2], padding[2]), # (padding[3], padding[3])) # broad_mask = np.broadcast_to(mask[..., None], data.shape) #np.pad(np.broadcast_to(mask[..., None], data.shape), padding, mode='constant') # mask_small = extract_patches(broad_mask, block_size, new_overlap) mask_small = extract_patches(mask, block_size[:-1], new_overlap[:-1]) dims = tuple(range(mask_small.ndim // 2, mask_small.ndim)) shape = mask_small.shape[mask_small.ndim // 2:] # train_small = np.sum(mask_small, axis=dims) > (np.prod(shape)//2) train_small = np.sum(mask_small, axis=dims) > (np.prod(shape) // 2) # print(padding, data.shape) # data = data#np.pad(data, padding, mode='constant') # print(padding, data.shape) X_small_full = extract_patches(data, block_size, new_overlap) # X_small_shape = (np.prod(X_small_full.shape[:X_small_full.ndim//2]), np.prod(shape)) X_small = X_small_full[train_small] # axis = tuple(range(1, X_small.ndim//2 + 1)) # alpha = np.zeros((D.shape[1], X_small_full.shape[0])) # print(X_small_full.shape, D_depimpe.shape, D.shape, 'shape 2') # dims = tuple(range(X_small.ndim//2, X_small.ndim)) axis = tuple(range(1, X_small.ndim)) X_mean = X_small.mean(axis=axis)[:, None] # X_small -= X_mean # print(X_small.shape, X_mean.shape, axis, 'axis') # return 1 # mkl.set_num_threads(1) if variance is not None: # broad_mask = mask #np.pad(mask, padding[:-1], mode='constant') # mask_small = extract_patches(broad_mask, block_size[:-1], new_overlap[:-1]) mask_small = extract_patches(mask, block_size[:-1], new_overlap[:-1]) shape = mask_small.shape[mask_small.ndim // 2:] dims = tuple(range(mask_small.ndim // 2, mask_small.ndim)) print(mask.shape, dims, mask_small.shape) variance_mask = np.sum(mask_small, axis=dims) > (np.prod(shape) // 2) print('variance shape', variance.shape, 0) # broad_variance = variance #np.pad(variance, padding[:-1], mode='constant') variance_small = extract_patches(variance, block_size[:-1], new_overlap[:-1])[variance_mask] print('variance shape', variance_small.shape, variance_mask.shape, dims) axis = range(1, variance_small.ndim) variance_small = np.median(variance_small, axis=axis) print('variance shape', variance_small.shape) X_small_denoised, alpha, intercept = solve_l1(X_small, D_depimpe, variance=variance_small, return_all=True, positivity=True, nlambdas=100, fit_intercept=True, standardize=True, progressbar=True) # reconstruct_by_indexes = False # if reconstruct_by_indexes: # mask = train_small.ravel() # return reconstruct_from_indexes(alpha, D, intercept, new_shape, mask, block_size, block_up) # X_small_denoised = np.zeros(10) # alpha = np.zeros((D.shape[1], X_small.shape[0])) # intercept = np.zeros((alpha.shape[1], 1)) # mkl.set_num_threads(ncores) # Xhat, alpha, intercept print('total time : {}'.format(time() - t), train_small.shape, D.shape, alpha.shape) print('mean alpha', np.abs(alpha).mean()) # print(X_small_denoised.shape, X_small.shape, X_upsampled_shape, D_depimpe.shape) # 1/0 del X_small_denoised # upsampled = np.zeros((X_small_shape[0], D.shape[0]), dtype=np.float32) indexes = train_small.ravel() upsampled = np.zeros((indexes.shape[0], ) + new_size, dtype=np.float32) full_weights = np.ones(indexes.shape[0], dtype=np.float32) print(train_small.shape, indexes.shape) # weights = 1. / (1. + np.sum(alpha != 0, axis=0, dtype=np.float32)) weights = 1. stuff = np.dot(D, alpha).T + intercept # fix offset to enforce original mean consistency # offset = X_mean - stuff.mean(axis=-1, keepdims=True) # stuff += offset print(train_small.shape, indexes.shape, new_shape) print(upsampled[indexes].shape, upsampled.shape) upsampled[indexes] = stuff.reshape((stuff.shape[0], ) + new_size) full_weights[indexes] = weights del stuff, weights, offset, indexes output = reconstruct_from_blocks(upsampled, new_shape, block_size, block_up, new_overlap, weights=full_weights) return output
def test_extract_patches_deprecated(): msg = ("The function feature_extraction.image.extract_patches has been " "deprecated in 0.22 and will be removed in 0.24.") with pytest.warns(FutureWarning, match=msg): extract_patches(downsampled_face)
def slice_U_Patch_Preprocess_recon_2D(patch_size_x=5,patch_size_y=5,prefix='SdA',in_root='',out_root='',slice_num=1, data_augment=False): #Initialize user variables patch_size = patch_size_x patch_pixels = patch_size*patch_size pixel_offset = int(patch_size*0.5) padding = patch_size #threshold = patch_pixels*0.3 recon_num = 4 patches = np.zeros(patch_pixels*recon_num) ground_truth = np.zeros(1) #paths to images path = in_root Flair = [] T1 = [] T2 = [] T_1c = [] Truth = [] Folder = [] for subdir, dirs, files in os.walk(path): # if len(Flair) is 1: # break for file1 in files: #print file1 if file1[-3:]=='nii' and ('Flair' in file1): Flair.append(file1) Folder.append(subdir+'/') elif file1[-3:]=='nii' and ('T1' in file1 and 'T1c' not in file1): T1.append(file1) elif file1[-3:]=='nii' and ('T2' in file1): T2.append(file1) elif file1[-3:]=='nii' and ('T1c' in file1 or 'T_1c' in file1): T_1c.append(file1) elif file1[-3:]=='mha' and 'OT' in file1: Truth.append(file1) number_of_images = len(Flair) print 'Number of images : ', number_of_images for image_iterator in range(number_of_images): print 'Iteration : ',image_iterator+1 print 'Folder : ', Folder[image_iterator] Flair_image = nib.load(Folder[image_iterator]+Flair[image_iterator]) T1_image = nib.load(Folder[image_iterator]+T1[image_iterator]) T2_image = nib.load(Folder[image_iterator]+T2[image_iterator]) T_1c_image = nib.load(Folder[image_iterator]+T_1c[image_iterator]) try: Truth_image = new(Folder[image_iterator]+Truth[image_iterator]) except: Truth_image = new2(Folder[image_iterator]+Truth[image_iterator]) Flair_image = Flair_image.get_data() T1_image = T1_image.get_data() T2_image = T2_image.get_data() T_1c_image = T_1c_image.get_data() Truth_image = Truth_image.data if slice_num ==2: Flair_image = np.swapaxes(Flair_image,0,1) Flair_image = np.swapaxes(Flair_image,1,2) T1_image = np.swapaxes(T1_image, 0,1) T1_image = np.swapaxes(T1_image, 1, 2) T2_image = np.swapaxes(T2_image, 0,1) T2_image = np.swapaxes(T2_image, 1, 2) T_1c_image = np.swapaxes(T_1c_image, 0,1) T_1c_image = np.swapaxes(T_1c_image, 1, 2) Truth_image = np.swapaxes(Truth_image,0,1) Truth_image = np.swapaxes(Truth_image,1,2) elif slice_num == 3: Flair_image = np.swapaxes(Flair_image,0,1) Flair_image = np.swapaxes(Flair_image,0,2) T1_image = np.swapaxes(T1_image, 0,1) T1_image = np.swapaxes(T1_image, 0, 2) T2_image = np.swapaxes(T2_image, 0,1) T2_image = np.swapaxes(T2_image, 0, 2) T_1c_image = np.swapaxes(T_1c_image, 0,1) T_1c_image = np.swapaxes(T_1c_image, 0, 2) Truth_image = np.swapaxes(Truth_image,0,1) Truth_image = np.swapaxes(Truth_image,0,2) x_span,y_span,z_span = np.where(Truth_image!=0) start_slice = min(z_span) stop_slice = max(z_span) print start_slice, stop_slice image_patch = np.zeros(patch_size*patch_size*recon_num) image_label = np.zeros(1) for i in range(start_slice, stop_slice+1): #print 'Slice : '+str(i) Flair_slice = np.transpose(Flair_image[:,:,i]) T1_slice = np.transpose(T1_image[:,:,i]) T2_slice = np.transpose(T2_image[:,:,i]) T_1c_slice = np.transpose(T_1c_image[:,:,i]) Truth_slice = np.transpose(Truth_image[:,:,i]) x_dim,y_dim = np.size(Flair_slice,axis=0), np.size(Flair_slice, axis=1) x_span,y_span = np.where(Truth_slice!=0) if len(x_span)==0 or len(y_span)==0: continue x_start = np.min(x_span) - padding x_stop = np.max(x_span) + padding+1 y_start = np.min(y_span) - padding y_stop = np.max(y_span) + padding+1 #print 'X start, X stop ', x_start,x_stop #print 'Y start, Y stop ', y_start, y_stop Flair_patch = image.extract_patches(Flair_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T1_patch = image.extract_patches(T1_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T2_patch = image.extract_patches(T2_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) T_1c_patch = image.extract_patches(T_1c_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) Truth_patch = image.extract_patches(Truth_slice[x_start:x_stop, y_start:y_stop], patch_size, extraction_step = pixel_offset) if data_augment == True: Fp = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1], patch_size_x, patch_size_y) T1p = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1], patch_size,patch_size) T2p = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1], patch_size,patch_size) T1cp = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1], patch_size,patch_size) Truthp = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1], patch_size, patch_size) Truthp = Truthp[:,(patch_size-1)/2,(patch_size-1)/2] Truthp = np.array(Truthp) Truthp = Truthp.reshape(len(Truthp)) indexx = np.where(Truthp!=0) # print indexx[0] indexx=indexx[0] Fp = Fp[indexx,:,:] T1p = T1p[indexx,:,:] T2p = T2p[indexx,:,:] T1cp = T1cp[indexx,:,:] Truthp = Truthp[indexx] for angle in range(3): Fp = np.asarray([np.rot90(Fp[x,:,:]) for x in range(Fp.shape[0])]) T1p = np.asarray([np.rot90(T1p[x,:,:]) for x in range(T1p.shape[0])]) T2p = np.asarray([np.rot90(T2p[x,:,:]) for x in range(T2p.shape[0])]) T1cp = np.asarray([np.rot90(T1cp[x,:,:]) for x in range(T1cp.shape[0])]) Fp_n = np.asarray(Fp) T1p_n = np.asarray(T1p) T2p_n = np.asarray(T2p) T1cp_n = np.asarray(T1cp) Fp_n = Fp_n.reshape(Fp_n.shape[0], patch_size_x*patch_size_y) T1p_n = T1p_n.reshape(T1p_n.shape[0], patch_size_x*patch_size_y) T2p_n = T2p_n.reshape(T2p_n.shape[0], patch_size_x*patch_size_y) T1cp_n = T1cp_n.reshape(T1cp_n.shape[0], patch_size_x*patch_size_y) Truthp_n = Truthp.reshape(len(Truthp),1) sp_n = np.concatenate([Fp_n, T1p_n, T2p_n, T1cp_n], axis=1) patches = np.vstack([patches, sp_n]) ground_truth = np.vstack([ground_truth, Truthp_n]) # print 'Angle : '+str(90*(angle+1)) # print 'Augmented Data: '+str(Fp_n.shape[0])+' patches' # print Flair_patch.shape Flair_patch = Flair_patch.reshape(Flair_patch.shape[0]*Flair_patch.shape[1], patch_size*patch_size) T1_patch = T1_patch.reshape(T1_patch.shape[0]*T1_patch.shape[1], patch_size*patch_size) T2_patch = T2_patch.reshape(T2_patch.shape[0]*T2_patch.shape[1], patch_size*patch_size) T_1c_patch = T_1c_patch.reshape(T_1c_patch.shape[0]*T_1c_patch.shape[1], patch_size*patch_size) Truth_patch = Truth_patch.reshape(Truth_patch.shape[0]*Truth_patch.shape[1], patch_size, patch_size) #print '2. truth dimension :', Truth_patch.shape slice_patch = np.concatenate([Flair_patch, T1_patch, T2_patch, T_1c_patch], axis=1) Truth_patch = Truth_patch[:,(patch_size-1)/2,(patch_size-1)/2] Truth_patch = np.array(Truth_patch) Truth_patch = Truth_patch.reshape(len(Truth_patch),1) patches = np.vstack([patches,slice_patch]) ground_truth = np.vstack([ground_truth, Truth_patch]) print 'Number of non-zeros in ground truth : ', np.sum((ground_truth!=0).astype(int)) print 'Number of zeros in ground truth : ', np.sum((ground_truth==0).astype(int)) # ground_truth[np.where(ground_truth==3)]=1 # ground_truth[np.where(ground_truth==4)]=1 print print 'No. of 1 : ', np.sum((ground_truth==1).astype(int)) print 'No. of 2 : ', np.sum((ground_truth==2).astype(int)) print 'No. of 3 : ', np.sum((ground_truth==3).astype(int)) print 'No. of 4 : ', np.sum((ground_truth==4).astype(int)) ground_truth = ground_truth.reshape(len(ground_truth)) print 'Shape of Un-balanced patches numpy array : ',patches.shape print 'Shape of Un-balanced ground truth : ',ground_truth.shape patches = np.float32(patches) ground_truth = np.float32(ground_truth) if 'training' in out_root: print'... Saving the 2D training patches' np.save(out_root+'u_trainpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_trainlabel_2D_'+prefix+'_.npy',ground_truth) elif 'validation' in out_root: print '... Saving the 2D validation patches' np.save(out_root+'u_validpatch_2D_'+prefix+'_.npy',patches) np.save(out_root+'u_validlabel_2D_'+prefix+'_.npy',ground_truth)
y_start = min(y_span) - padding y_stop = max(y_span) + padding + 1 if ((x_stop - x_start) * (y_stop - y_start)) < patch_size * patch_size: x_start = x_start - 20 x_stop = x_stop + 20 y_start = y_start - 20 y_stop = y_stop + 20 for j in xrange(start_slice, stop_slice): image_slice = img[:,:,j] truth_slice = truth[:,:,j] patch = image.extract_patches(image_slice[x_start:x_stop,y_start:y_stop], patch_size, extraction_step = 1) patch = patch.reshape(patch.shape[0]*patch.shape[1],patch_size,patch_size) truth_patch = image.extract_patches(truth_slice[x_start:x_stop,y_start:y_stop], patch_size, extraction_step = 1) truth_patch = truth_patch.reshape(truth_patch.shape[0]*truth_patch.shape[1],patch_size,patch_size) truth_values = truth_patch[:, (patch_size - 1)/2, (patch_size -1)/2] patches = np.append(patches,patch,axis=0) ground_truths = np.append(ground_truths,truth_values,axis=0) patches = patches[1:patches.shape[0]] ground_truths = ground_truths[1:ground_truths.shape[0]] except: print '==> Error in label: ', z