def get3DRecon(data): RefDs = data[0] data = np.delete(data,0,0) ConstPixelSpacing = (float(RefDs.PixelSpacing[0]), float(RefDs.PixelSpacing[1]), float(RefDs.SliceThickness)) try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(data) except dicom_numpy.DicomImportException as e: print("Handling incompatible dicom slices") makeCompatible(data, prec=5) voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(data) upper_thresh = 0 lower_thresh = 0 voxel_ndarray[voxel_ndarray > upper_thresh] = 1 voxel_ndarray[voxel_ndarray <= lower_thresh] = 0 return (voxel_ndarray,ijk_to_xyz)
def extract_voxel_data(DCM_files): datasets = [dicom.read_file(f) for f in DCM_files] try: voxel_ndarray, ijk_to_xyz = dn.combine_slices(datasets) except dn.DicomImportException as e: raise e return voxel_ndarray
def get3DRecon(data): RefDs = data[0] ConstPixelSpacing = (float(RefDs.PixelSpacing[0]), float(RefDs.PixelSpacing[1]), float(RefDs.SliceThickness)) try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(data) except dicom_numpy.DicomImportException as e: # invalid DICOM data raise NameError( 'Unable to do 3D reconstruction. Slice missing? or incompatible slice data?' ) # arbitrary for now, can be set to different values for CT scan as in Hounsfield unit, # bone is from +700 to +3000 """ upper_thresh = 0 lower_thresh = 0 voxel_ndarray[voxel_ndarray > upper_thresh] = 1 voxel_ndarray[voxel_ndarray <= lower_thresh] = 0 """ return (voxel_ndarray, ijk_to_xyz)
def load_dicom_dir_dicom_orientation(dicomdir, all_headers=False, include_file_list=False): """ Load the images from dicomdir into a numpy array, returned in "DICOM" standard dimension ordering (X, Y, Z), where Z==0 is the inferior ("feet") end, increasing Z is toward the superior ("head"). Y increases toward the posterior, X increases toward the patient's left. """ import logging logging.basicConfig() import dicom_numpy as dnp # https://github.com/innolitics/dicom-numpy slices = filter_duplicates_from_dicomdir(dicomdir) img, affine = dnp.combine_slices([s[1] for s in slices]) hdr = slices[0][1] hdr.Affine = affine hdr.RescaleIntercept = 0 hdr.RescaleSlope = 1.0 if all_headers or include_file_list: hdr = [s[1] for s in slices] if include_file_list == False else slices for h in hdr: if include_file_list: h = h[1] h.RescaleIntercept = 0 h.RescaleSlope = 1.0 h.Affine = affine return img, hdr
def read_dcm_dir(input_dir, header=False, globber='*', channels_axis=None, series=None): """ Reads a 3D dicom image: input path can be a file or directory (DICOM series). Return the image array, metadata, and whether it has channels """ # find all dicom files within the specified folder, read every file separately and sort them by InstanceNumber slices = PdcmIO.extract_slices(input_dir, globber=globber, series=series) img, affine = combine_slices(slices) metadata = PdcmIO.aff2meta(affine) if header: # TODO: add header support, something like # metdata.header = [{str(key): ds[key] for key in ds.keys()} for ds in slices] raise NotImplementedError( "header=True is currently not supported for a series") samples_per_pixel = slices[0].SamplesPerPixel img = PdcmIO.move_channels_axis( img, samples_per_pixel=samples_per_pixel, channels_axis=channels_axis, planar_configuration=slices[0].get('PlanarConfiguration', None), default_axes=PdcmIO.DEFAULT_CHANNELS_AXES_DICOM_NUMPY) return img, metadata, samples_per_pixel > 1
def read_dcm_file(filename, header=False, allow_default_affine=False, channels_axis=None): """ Read a single dicom file. Return the image array, metadata, and whether it has channels """ ds = pydicom.dcmread(filename) ds = convert_ds(ds) if ds.__class__ is MultiFrameFileDataset: img, affine = unpack_dataset( ds, allow_default_affine=allow_default_affine) else: img, affine = combine_slices([ds]) metadata = PdcmIO.aff2meta(affine) if header: metadata.header = {str(key): ds[key] for key in ds.keys()} samples_per_pixel = ds.SamplesPerPixel img = PdcmIO.move_channels_axis( img, samples_per_pixel=samples_per_pixel, channels_axis=channels_axis, planar_configuration=ds.get('PlanarConfiguration', None), default_axes=PdcmIO.DEFAULT_CHANNELS_AXES_PYDICOM) return img, metadata, samples_per_pixel > 1
def extract_voxel_data(list_of_dicom_files): datasets = [dicom.read_file(f) for f in list_of_dicom_files] try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(datasets) except dicom_numpy.DicomImportException as e: # invalid DICOM data raise return voxel_ndarray
def _extract_voxel_data(datasets): try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(datasets) except dicom_numpy.DicomImportException as e: print("Exception extracting voxel data: ", e) raise e except AttributeError as e: print("Exception extracting voxel data: ", e) raise dicom_numpy.DicomImportException('Invalid dicom.dataset.Dataset among datasets! ', e) return voxel_ndarray
def _extract_voxel_data(datasets): try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(datasets) except dicom_numpy.DicomImportException as e: print('Exception extracting voxel data: ', e) raise e except AttributeError as e: print('Exception extracting voxel data: ', e) raise dicom_numpy.DicomImportException('Invalid dicom.dataset.Dataset among datasets! ', e) return voxel_ndarray
def extract_voxel_data(dcm_lst): # https: // dicom - numpy.readthedocs.io / en / latest / import dicom import dicom_numpy datasets = [dicom.read_dile(fName) for fName in dcm_lst] try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices( slice_datasets=datasets) except dicom_numpy.DicomImportException as e: raise return voxel_ndarray
def test_dcmToSimpleITK(self): dcmFiles = [] for (dirPath, subDirs, fileNames) in os.walk(sample_dicom_folder): for fileName in fileNames: if not fileName.startswith('.'): dcmFiles.append(os.path.join(sample_dicom_folder, fileName)) datasets = [pydicom.dcmread(dcmSliceFile) for dcmSliceFile in dcmFiles] dicomAsArray, ijk_to_xyz = dicom_numpy.combine_slices(datasets) sITK_image = sitk.GetImageFromArray(dicomAsArray) assert (sITK_image == dcmToSimpleITK(sample_dicom_folder))
def read_dicom_folder(dicom_folder, rescale=None): ''' Reads all .dcm files in `dicom_folder` and merges them to one volume Returns: The volume and the affine transformation from pixel indices to xyz coordinates ''' dss = [ pydicom.dcmread(str(dicom_folder / dcm)) for dcm in os.listdir(dicom_folder) if dcm.endswith('.dcm') ] vol, mat = dicom_numpy.combine_slices(dss, rescale) return vol, dss[0]
def preprocess_dataset(raw_data_dir, out_dir, set): """ load and concat the raw dicom/nrrd data, resample it to equalize the spacings and save out the numpy arrays per patient. Additionally, determine the class_weights as 1-class_ratio """ set_dir = os.path.join(raw_data_dir, set) set_dir_seg = set_dir + '-segm' out_set_dir = os.path.join( out_dir, set) if set is not 'leaderboard' else os.path.join( out_dir, 'train') if not os.path.exists(out_set_dir): os.mkdir(out_set_dir) seg_paths = [ os.path.join(set_dir_seg, ii) for ii in os.listdir(set_dir_seg) ] collect_class_weights = [] ix = 0 for path, dirs, files in os.walk(set_dir): if len(files) > 0: dicom_slices = [ dicom.read_file(os.path.join(path, f)) for f in files ] img_arr, img_affine = dicom_numpy.combine_slices(dicom_slices) pid = path.split('/')[-3] seg_path = [seg_path for seg_path in seg_paths if pid in seg_path][0] seg_arr, seg_info = nrrd.read(seg_path) if img_arr.shape == seg_arr.shape: data_arr = np.concatenate( (img_arr[:, :, :, np.newaxis], seg_arr[:, :, :, np.newaxis]), axis=3) rs_data_arr = resample_array(data_arr, img_affine) class_ratios = np.unique(rs_data_arr[..., 1], return_counts=True)[1] / float( rs_data_arr[..., 1].size) collect_class_weights.append(class_ratios) np.save( os.path.join(out_set_dir, '{}.npy'.format(path.split('/')[-3])), rs_data_arr) print "processed", ix, os.path.join( out_set_dir, '{}.npy'.format(path.split('/')[-3])) else: print "failed to process due to shape mismatch: {} {} {} {}".format( img_arr.shape, seg_arr.shape, pid, set) ix += 1 class_weights = 1 - np.mean(np.array(collect_class_weights), axis=0) print "class weights for set {} and classes BG, PZ, GC:".format( set), class_weights
def dcmToSimpleITK(dcmDirectory): """Return a simple ITK image from a pile of dcm files. The returned sITK image has been rescaled based on the value of the rescale slope on the dicom tag. Array-like data of the 3D image can be obtained with the GetArrayFromImage() method""" list_dcmFiles = [] for directory, subDirectory, list_dcmFileNames in os.walk(dcmDirectory): for dcmFile in list_dcmFileNames: if '.dcm' in dcmFile.lower(): list_dcmFiles.append(os.path.join(directory, dcmFile)) dcmImage = [pydicom.dcmread(dcmSliceFile) for dcmSliceFile in list_dcmFiles] voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(dcmImage) sITK_image = sitk.GetImageFromArray(voxel_ndarray) return (sITK_image)
def load_dicom_as_numpy(dicom_dir: str) -> np.ndarray: """ Method to load ct image in numpy, slightly adapted form https://dicom-numpy.readthedocs.io/en/latest/ :param dicom_dir: directory where dicom data is located :return: numpy array of ct data """ datasets = [ pydicom.read_file(dicom_dir + f) for f in os.listdir(dicom_dir) ] try: voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices(datasets) except dicom_numpy.DicomImportException: raise return voxel_ndarray
def _loadFromDicom(self, filepath, *args, **kwargs): import pydicom import dicom_numpy if os.path.splitext(filepath)[1] not in self.dicom_extensions: if not os.path.isdir(filepath): raise TypeError('file must be a directory containing dicom files or a single dicom file') dcm_datasets = [pydicom.dcmread(os.path.join(filepath, x)) for x in os.listdir(filepath) if os.path.splitext(x)[1] in self.dicom_extensions] vol, affine = dicom_numpy.combine_slices(dcm_datasets) vol = vol.transpose(2,1,0).copy("C") self._cached_affine_matrix = affine return vol else: return np.expand_dims(pydicom.dcmread(filepath).pixel_array, axis=0) return None
def start(self): """ open a file and sends notifier """ super(DicomInput, self).start() datasets = [dicom.read_file(os.path.join(self.folder_path, f)) \ for f in os.listdir(self.folder_path)] try: voxel_ndarray, _ = dicom_numpy.combine_slices(datasets) except dicom_numpy.DicomImportException: # invalid DICOM data raise self.package['data'] = voxel_ndarray self.log_line('read dicom files') self.output_notifier.notify_observers(self.package)
def read_dcm_dir(input_dir, globber='*', channels_axis=None): """Reads a 3D dicom image: input path can be a file or directory (DICOM series)""" # find all dicom files within the specified folder, read every file separately and sort them by InstanceNumber files = list(Path(input_dir).glob(globber)) if len(files) == 0: raise FileNotFoundError( f'Received an empty directory: "{input_dir}"') slices = [pydicom.dcmread(filename) for filename in files] slices.sort(key=lambda ds: ds.get('InstanceNumber', 0)) img, affine = combine_slices(slices) metadata = PdcmIO.aff2meta(affine) img = PdcmIO.move_channels_axis( img, samples_per_pixel=slices[0].SamplesPerPixel, channels_axis=channels_axis) return img, metadata
def read_dcm_file(filename, header=False, allow_default_affine=False, channels_axis=None): """Read a single dicom file""" ds = pydicom.dcmread(filename) ds = convert_ds(ds) if ds.__class__ is MultiFrameFileDataset: img, affine = unpack_dataset( ds, allow_default_affine=allow_default_affine) else: img, affine = combine_slices([ds]) metadata = PdcmIO.aff2meta(affine) if header: metadata.header = {str(key): ds[key] for key in ds.keys()} img = PdcmIO.move_channels_axis(img, samples_per_pixel=ds.SamplesPerPixel, channels_axis=channels_axis) return img, metadata
def get_scan(dicom_path, scan_size): # Getting DICOM images from path: if not os.path.exists(dicom_path): print('DICOM files not exists!') return dicom_files = listdir(dicom_path) dicom_files.sort() voxel_ndarray, ijk_to_xyz = dicom_numpy.combine_slices([ pydicom.read_file(dicom_path + '/' + dcm_file, force=True) for dcm_file in dicom_files ]) vox_array = [] for i in range(voxel_ndarray.shape[-1]): if vox_array == []: vox_array = imresize(voxel_ndarray[:, :, i], scan_size) else: vox_array = np.dstack( (vox_array, imresize(voxel_ndarray[:, :, i], scan_size))) return vox_array
def create_DICOM_Array(PathDicom): filenames_list = [] file_list = os.listdir(PathDicom) for file in file_list: filenames_list.append(PathDicom + file) datasets = [dicom.read_file(f) \ for f in filenames_list] try: voxel_ndarray, _ = dicom_numpy.combine_slices(datasets) voxel_ndarray = voxel_ndarray.astype(float) voxel_ndarray = np.swapaxes(voxel_ndarray, 0, 1) print(voxel_ndarray.dtype) # voxel_ndarray = voxel_ndarray[:-1:] # print(voxel_ndarray.shape) except dicom_numpy.DicomImportException: # invalid DICOM data raise return voxel_ndarray
def create_DICOM_Array(mrt_Folder, proband, model): filenames_list = [] PathDicom = mrt_Folder + "/" + proband + "/dicom_sorted/" + model + "/" file_list = os.listdir(PathDicom) for file in file_list: filenames_list.append(PathDicom + file) datasets = [dicom.read_file(f) \ for f in filenames_list] try: voxel_ndarray, _ = dicom_numpy.combine_slices(datasets) print(voxel_ndarray.dtype) voxel_ndarray = voxel_ndarray.astype(float) #float voxel_ndarray = np.swapaxes(voxel_ndarray, 0, 1) print(voxel_ndarray.dtype) # voxel_ndarray = voxel_ndarray[:-1:] # print(voxel_ndarray.shape) except dicom_numpy.DicomImportException: # invalid DICOM data raise return voxel_ndarray
def get_DICOM_data(DICOM_dir, keys='minimal'): # find DICOM files in the specified directory DICOM_file_paths = glob(DICOM_dir + '*.dcm') DICOM_file_paths = natsorted(DICOM_file_paths) # initialise metadata dictionary metadata = {} # hard code basic dicom tags minimal_keys = [ 'EchoTime', 'RepetitionTime', 'AcquisitionNumber', 'SeriesNumber', 'InversionTime', 'FlipAngle', 'ImageOrientationPatient', 'ContentTime', 'ProtocolName', 'InstanceNumber', 'Rows', 'TriggerTime', 'AcquisitionTime', 'InPlanePhaseEncodingDirection', 'SeriesInstanceUID', 'Columns', 'PixelSpacing' ] ############################## DICOM_NUMPY ################################ datasets = [dicom.read_file(f) for f in DICOM_file_paths] # use dcmstack metadata if possible dcmstack_metadata = False try: DICOM_data, DICOM_affine = combine_slices(datasets) except Exception, e: print e print 'WARNING: could not assemble valid DICOM image for ' + DICOM_dir DICOM_data = np.array(-1) DICOM_affine = 'WARNING: could not get affine matrix' print 'Trying alternative method to construct DICOM image' ######################## DICOM STACK ################################## # read into stack of data DICOM_stack = dcmstack.DicomStack() try: for DICOM_file_path in DICOM_file_paths: DICOM_file = dicom.read_file(DICOM_file_path) DICOM_stack.add_dcm(DICOM_file) # get data and affine DICOM_data = DICOM_stack.get_data() DICOM_affine = DICOM_stack.get_affine() # get a nifti wrapper for the DICOM stack nii_wrp = DICOM_stack.to_nifti_wrapper() if keys == 'minimal': # just get minimal keys from the stack keys = DICOM_stack.minimal_keys elif keys == 'all': # get all metadata keys keys = nii_wrp.meta_ext.get_keys() else: print( 'WARNING: keys arguments must be set to "minimal" to search for a default set of basic DICOM tags, or "all" to search for all tags associated with each image.' ) # build dictionary of key-value pairs for the metadata for key in keys: metadata.update({key: nii_wrp.get_meta(key)}) dcmstack_metadata = True except Exception, e: print e print 'WARNING: could not assemble valid DICOM image for ' + DICOM_dir + 'with alternative method' DICOM_data = np.array(-1) DICOM_affine = 'WARNING: could not get affine matrix'
def load_MRT(self): mrt_layer_name = str( self.proband_str.get()) + "_" + self.mrt_model[str( self.artefact_str.get())] filenames_list = [] if mrt_layer_name in self.mrt_layer_names: pass else: self.mrt_layer_names.append(mrt_layer_name) PathDicom = self.sFolder + "/" + self.proband_str.get( ) + "/dicom_sorted/" + self.artefact_str.get() + "/" #load Dicom_Array files = sorted([ os.path.join(PathDicom, file) for file in os.listdir(PathDicom) ], key=os.path.getctime) datasets = [dicom.read_file(f) \ for f in files] try: voxel_ndarray, pixel_space = dicom_numpy.combine_slices( datasets) voxel_ndarray_matlab = voxel_ndarray.transpose(1, 0, 2) except dicom_numpy.DicomImportException: # invalid DICOM data raise dx, dy, dz = 1.0, 1.0, pixel_space[2][ 2] #pixel_space[0][0], pixel_space[1][1], pixel_space[2][2] pixel_array = voxel_ndarray[:, :, 0] x_1d = dx * np.arange(voxel_ndarray.shape[0]) y_1d = dy * np.arange(voxel_ndarray.shape[1]) z_1d = dz * np.arange(voxel_ndarray.shape[2]) smodel = self.mrt_smodel[str(self.artefact_str.get())] sartefact = self.mrt_artefact[str(self.artefact_str.get())] mrt_layer = MRT_Layer(voxel_ndarray.shape[0], voxel_ndarray.shape[1], voxel_ndarray.shape[2], sartefact, smodel, x_1d, y_1d, z_1d, voxel_ndarray, mrt_layer_name, voxel_ndarray_matlab) self.mrt_layer_set.append(mrt_layer) self.optionlist.append("(" + str(len(self.mrt_layer_set)) + ") " + mrt_layer_name + ": " + str(voxel_ndarray.shape[0]) + " x " + str(voxel_ndarray.shape[1])) self.refresh_option(self.optionlist) self.number_mrt_label.config(text="1/" + str(mrt_layer.get_number_mrt())) self.number_mrt_label.place(x=1330, y=10) self.art_mod_label.config( text="Proband: " + str(self.proband_str.get()) + "\nModel: " + str(self.artefact_str.get())) self.art_mod_label.place(x=5, y=5) plt.cla() plt.gca().set_aspect('equal') # plt.axes().set_aspect('equal') plt.xlim(0, voxel_ndarray.shape[0] * dx) plt.ylim(voxel_ndarray.shape[1] * dy, 0) plt.set_cmap(plt.gray()) self.pltc = plt.pcolormesh(x_1d, y_1d, np.swapaxes(pixel_array, 0, 1), vmin=0, vmax=2094) # load File_Path = self.Path_marking + self.proband_str.get() + ".slv" loadFile = shelve.open(File_Path) number_Patch = 0 cur_no = "0" if loadFile.has_key(self.artefact_str.get()): layer = loadFile[self.artefact_str.get()] while layer.has_key( cur_no + "_11_" + str(number_Patch)) or layer.has_key( cur_no + "_12_" + str(number_Patch)) or layer.has_key( cur_no + "_13_" + str(number_Patch)) or layer.has_key( cur_no + "_21_" + str(number_Patch)) or layer.has_key( cur_no + "_22_" + str(number_Patch)) or layer.has_key( cur_no + "_23_" + str(number_Patch) ) or layer.has_key( cur_no + "_31_" + str(number_Patch) ) or layer.has_key( cur_no + "_32_" + str(number_Patch) ) or layer.has_key(cur_no + "_33_" + str(number_Patch)): patch = None if layer.has_key(cur_no + "_11_" + str(number_Patch)): p = layer[cur_no + "_11_" + str(number_Patch)] patch = plt.Rectangle( (min(p[0], p[2]), min(p[1], p[3])), np.abs(p[0] - p[2]), np.abs(p[1] - p[3]), fill=False, edgecolor="red", lw=2) elif layer.has_key(cur_no + "_12_" + str(number_Patch)): p = layer[cur_no + "_12_" + str(number_Patch)] patch = plt.Rectangle( (min(p[0], p[2]), min(p[1], p[3])), np.abs(p[0] - p[2]), np.abs(p[1] - p[3]), fill=False, edgecolor="green", lw=2) elif layer.has_key(cur_no + "_13_" + str(number_Patch)): p = layer[cur_no + "_13_" + str(number_Patch)] patch = plt.Rectangle( (min(p[0], p[2]), min(p[1], p[3])), np.abs(p[0] - p[2]), np.abs(p[1] - p[3]), fill=False, edgecolor="blue", lw=2) elif layer.has_key(cur_no + "_21_" + str(number_Patch)): p = layer[cur_no + "_21_" + str(number_Patch)] patch = Ellipse( xy=(min(p[0], p[2]) + np.abs(p[0] - p[2]) / 2, min(p[1], p[3]) + np.abs(p[1] - p[3]) / 2), width=np.abs(p[0] - p[2]), height=np.abs(p[1] - p[3]), edgecolor="red", fc='None', lw=2) elif layer.has_key(cur_no + "_22_" + str(number_Patch)): p = layer[cur_no + "_22_" + str(number_Patch)] patch = Ellipse( xy=(min(p[0], p[2]) + np.abs(p[0] - p[2]) / 2, min(p[1], p[3]) + np.abs(p[1] - p[3]) / 2), width=np.abs(p[0] - p[2]), height=np.abs(p[1] - p[3]), edgecolor="green", fc='None', lw=2) elif layer.has_key(cur_no + "_23_" + str(number_Patch)): p = layer[cur_no + "_23_" + str(number_Patch)] patch = Ellipse( xy=(min(p[0], p[2]) + np.abs(p[0] - p[2]) / 2, min(p[1], p[3]) + np.abs(p[1] - p[3]) / 2), width=np.abs(p[0] - p[2]), height=np.abs(p[1] - p[3]), edgecolor="blue", fc='None', lw=2) elif layer.has_key(cur_no + "_31_" + str(number_Patch)): p = layer[cur_no + "_31_" + str(number_Patch)] patch = patches.PathPatch(p, fill=False, edgecolor='red', lw=2) elif layer.has_key(cur_no + "_32_" + str(number_Patch)): p = layer[cur_no + "_32_" + str(number_Patch)] patch = patches.PathPatch(p, fill=False, edgecolor='green', lw=2) elif layer.has_key(cur_no + "_33_" + str(number_Patch)): p = layer[cur_no + "_33_" + str(number_Patch)] patch = patches.PathPatch(p, fill=False, edgecolor='blue', lw=2) self.ax.add_patch(patch) number_Patch += 1 self.fig.canvas.draw()
import pydicom import dicom_numpy from os import listdir import numpy as np import math from copy import deepcopy # load data path='path_to_mri_folder' matrix = np.loadtxt('path_to xyz_to_ijk_matrix') spikes = np.loadtxt('path_to_meg_data') slices = [pydicom.read_file(path + '/' + s) for s in listdir(path)] slices.sort(key = lambda x: int(x.InstanceNumber)) voxel_ndarray, _ = dicom_numpy.combine_slices(slices) # you have to check that the orientation of slices and voxel_ndarray are the same # sometimes you have to inverse z orientation # voxel_ndarray = voxel_ndarray.T[::-1] # plt.imshow(voxel_ndarray[-67], cmap=plt.cm.bone) # plt.show() # plt.imshow(slices[-67].pixel_array, cmap=plt.cm.bone) # plt.show() # switch to ijk space spikes_in_ijk = np.dot(matrix, np.c_[spikes, np.ones(len(spikes))].T).T[:,:-1]*[1,1,1] voxel_ind = spikes_in_ijk.astype(int) # increase the intensity of the required voxels # indices are specified depending on the orientation of the original volume, # so that the coordinate system of the displayed data coincides