def _otsu(data: torch.Tensor, **kwargs): """ Use Otsu's method, which assumes a GMM with 2 components but uses some heuristic to maximize the variance differences. """ h = 2 ** int(1 + math.log2(data.shape[0]) / 2) fake_img = data.view(h, -1).cpu().numpy() return otsu(fake_img, h)
def median_otsu(mean_b0, median_radius=4, numpass=2, dilate=1): mask = multi_median(mean_b0.eval(), median_radius, numpass) thresh = tf.constant(otsu(mask)) mask = tf.constant(mask) > tf.to_float(thresh) for _ in range(dilate): mask = dilation(mask) return tf.squeeze(mask)
def imagen_auto_segmentada(prom_masDesvEstandar, prom_menosDesvEstandar, pintar=True): imagen_auto1 = np.zeros((230, 350), dtype="float64") imagen_auto2 = np.zeros((230, 350), dtype="float64") cap = cv.VideoCapture("Videos/Personas.mp4") while (cap.isOpened()): ret, frame = cap.read() if (not ret): break gray = cv.cvtColor(frame, cv.COLOR_RGBA2GRAY) gray = gray[200:430, 500:850] imagen_auto1 = gray < prom_menosDesvEstandar imagen_auto2 = gray > prom_masDesvEstandar imagen_or = np.bitwise_or( imagen_auto1, imagen_auto2) #func_or(imagen_auto1,imagen_auto2) s = 10 w = 3 t = (((w - 1) / 2) - 0.5) / s imagen_filtrada = gaussian(imagen_or, sigma=s, truncate=t) umbral = otsu(imagen_filtrada) imagen_filtrada = imagen_filtrada > umbral imagen_filtrada = median(imagen_or, np.ones((5, 5))) num_pixeles = np.sum(imagen_filtrada) / 255 num_personas = num_pixeles / 1200 num_personas_t = round(num_personas) #num_ceil = ceil(num_personas) #num_floor = floor(num_personas) print("Num pixeles = {pixeles} Num personas = {personas} ceil={trun}". format(pixeles=num_pixeles, personas=num_personas, trun=num_personas_t)) imagen_resultante = gray * imagen_filtrada cv.imshow("Imagen segmentada binaria", imagen_filtrada) cv.imshow("Video segmentado", imagen_resultante) cv.imshow("Video leido", frame) #time.sleep(.20) if (cv.waitKey(0) & 0xff == ord("q")): break #time.sleep(.20) cap.release() cv.destroyAllWindows()
def _otsu(data: torch.Tensor, **kwargs) -> float: """ Returns an intensity threshold for an image that separates it into backgorund and foreground pixels. The implementation uses Otsu's method, which assumes a GMM with 2 components but uses some heuristic to maximize the variance differences. The input data is shaped into a 2D image for the purpose of evaluating the threshold value. Args: data: Pytorch tensor containing the data. Returns: Threshold value determined via Otsu's method. """ h = 2**int(1 + math.log2(data.shape[0]) / 2) fake_img = data.view(h, -1).cpu().numpy() return otsu(fake_img, h)
def otsu_filter(dataset_to_filter: np.array): dataset_shape_entries_pos = 0 img_entries = dataset_to_filter.shape[dataset_shape_entries_pos] img_height = 32 img_width = 32 dataset_filtered_shape = (img_entries, img_height, img_width,\ greyscaled_colour_channels) dataset_filtered = np.empty(dataset_filtered_shape) cur_img = 0 for data in dataset_to_filter: # fromarray gives a too many dimensions error with # image colour channels included. otsu_mask = otsu(data) image_filtered = data < otsu_mask image_filtered = image_filtered.astype(np.float32) # resize to ensure image array shape correct. image_filtered = image_filtered.reshape((img_height, \ img_width, greyscaled_colour_channels)) dataset_filtered[cur_img] = image_filtered cur_img += 1 return dataset_filtered
image_2 = cv.imread("Personas/segmentacion/programa/%d.jpg" % indice, cv.IMREAD_GRAYSCALE) image_3 = cv.imread("Personas/segmentacion/programa_2/%d.jpg" % indice, cv.IMREAD_GRAYSCALE) image_1 = image_1[30:250, 85:435] image_2 = image_2[40:247, 55:388] image_3 = image_3[40:247, 55:388] image_1 = tr.resize(image_1, (220, 360), mode='constant') image_2 = tr.resize( image_2, (220, 360), mode='constant') #tr.resize() Aplica un escalamiento a la imagen image_3 = tr.resize(image_3, (220, 360), mode='constant') umbral1 = otsu(image_1) umbral2 = otsu(image_2) umbral3 = otsu(image_3) """ plt.title("Segmentada Manual {indice}".format(indice=indice)) plt.imshow(image_1,cmap="gray") plt.show() plt.title("Segmentada Programa {indice}".format(indice=indice)) plt.imshow(image_2,cmap="gray") plt.show() plt.title("Segmentada Programa_2 {indice}".format(indice=indice)) plt.imshow(image_3,cmap="gray") plt.show()
def median_otsu(input_volume, median_radius=4, numpass=4, autocrop=False, vol_idx=None, dilate=None): """Simple brain extraction tool method for images from DWI data. It uses a median filter smoothing of the input_volumes `vol_idx` and an automatic histogram Otsu thresholding technique, hence the name *median_otsu*. This function is inspired from Mrtrix's bet which has default values ``median_radius=3``, ``numpass=2``. However, from tests on multiple 1.5T and 3T data from GE, Philips, Siemens, the most robust choice is ``median_radius=4``, ``numpass=4``. Parameters ---------- input_volume : ndarray ndarray of the brain volume median_radius : int Radius (in voxels) of the applied median filter (default: 4). numpass: int Number of pass of the median filter (default: 4). autocrop: bool, optional if True, the masked input_volume will also be cropped using the bounding box defined by the masked data. Should be on if DWI is upsampled to 1x1x1 resolution. (default: False). vol_idx : None or array, optional 1D array representing indices of ``axis=3`` of a 4D `input_volume` None (the default) corresponds to ``(0,)`` (assumes first volume in 4D array). dilate : None or int, optional number of iterations for binary dilation Returns ------- maskedvolume : ndarray Masked input_volume mask : 3D ndarray The binary brain mask Notes ----- Copyright (C) 2011, the scikit-image team All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of skimage nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ if len(input_volume.shape) == 4: if vol_idx is not None: b0vol = np.mean(input_volume[..., tuple(vol_idx)], axis=3) else: b0vol = input_volume[..., 0].copy() else: b0vol = input_volume.copy() # Make a mask using a multiple pass median filter and histogram # thresholding. mask = multi_median(b0vol, median_radius, numpass) thresh = otsu(mask) mask = mask > thresh if dilate is not None: cross = generate_binary_structure(3, 1) mask = binary_dilation(mask, cross, iterations=dilate) # Auto crop the volumes using the mask as input_volume for bounding box # computing. if autocrop: mins, maxs = bounding_box(mask) mask = crop(mask, mins, maxs) croppedvolume = crop(input_volume, mins, maxs) maskedvolume = applymask(croppedvolume, mask) else: maskedvolume = applymask(input_volume, mask) return maskedvolume, mask
def imagen_auto_segmentada(prom_masDesvEstandar, prom_menosDesvEstandar, pintar=True): imagen_auto1 = np.zeros((220, 360), dtype="float64") imagen_auto2 = np.zeros((220, 360), dtype="float64") nombre = 0 #randint(1,339) detect = [] for indice in range(100): nombre = indice + 1 imagen = cv.imread("Autos/segmentacion/imagenes/%d.jpg" % nombre, cv.IMREAD_GRAYSCALE) imagen_auto1 = imagen < prom_menosDesvEstandar imagen_auto2 = imagen > prom_masDesvEstandar imagen_or = np.bitwise_or( imagen_auto1, imagen_auto2) #func_or(imagen_auto1,imagen_auto2) s = 10 w = 5 t = (((w - 1) / 2) - 0.5) / s imagen_filtrada = gaussian(imagen_or, sigma=s, truncate=t) imagen_filtrada = median(imagen_or, np.ones((10, 10))) umbral = otsu(imagen_filtrada) plt.title("Imagen_or_umbralada") plt.imshow(imagen_filtrada, cmap="gray") plt.savefig("Autos/segmentacion/programa/%d.jpg" % nombre) plt.show() imagen_filtrada = imagen_filtrada > umbral #print(imagen_filtrada.shape) region1 = imagen_filtrada[0:60, 0:360] region2 = imagen_filtrada[61:120, 0:360] region3 = imagen_filtrada[121:220, 0:360] pix_1 = np.sum(region1) pix_2 = np.sum(region2) pix_3 = np.sum(region3) #print(num_pixeles) num_1 = pix_1 / 1600 num_2 = pix_2 / 3000 num_3 = pix_3 / 5400 num_autos = num_1 + num_2 + num_3 redondeo = round(num_autos) detect.append(redondeo) print("pix_1 = {pixeles} Num autos = {autos}".format(pixeles=pix_1, autos=num_1)) print("pix_2 = {pixeles} Num autos = {autos}".format(pixeles=pix_2, autos=num_2)) print("pix_3 = {pixeles} Num autos = {autos}".format(pixeles=pix_3, autos=num_3)) print("Num_autos = {autos} redondeo = {red}".format(autos=num_autos, red=redondeo)) """ umbral_rango = umbral * 255 rango_imagen_filtrada = imagen_filtrada * 255 rango_imagen_filtrada = np.array(rango_imagen_filtrada,dtype=np.uint8) histograma = np.zeros((256,1),dtype = np.double) filas,columnas = rango_imagen_filtrada.shape for i in range(filas): for j in range(columnas): histograma[rango_imagen_filtrada[i,j]][0] += 1 linea = np.zeros((256,1),dtype = np.double) linea[int(umbral_rango)] = 600 """ if (pintar == True): plt.title('Imagen Auto leida %d' % nombre) plt.imshow(imagen, cmap='gray') plt.show() plt.title('Imagen Auto < prom_menosDesvEstandar') plt.imshow(imagen_auto1, cmap='gray') plt.savefig("imMenor_autos.jpg") plt.show() plt.title('Imagen Auto > prom_masDesvEstandar') plt.imshow(imagen_auto2, cmap='gray') plt.savefig("imMayor_autos.jpg") plt.show() plt.title("Imagen_or_umbralada") plt.imshow(imagen_filtrada, cmap="gray") plt.savefig("Autos/segmentacion/programa/%d.jpg" % nombre) plt.show() imagen_filtrada = imagen_filtrada > umbral num_pixeles = np.sum(imagen_filtrada) num_autos = num_pixeles / 4300 redondeo = round(num_autos) print("Num pixeles = {pixeles} Num autos = {autos} redondeo={red}". format(pixeles=num_pixeles, autos=num_autos, red=redondeo)) plt.title("Imagen_or") plt.imshow(imagen_or, cmap="gray") plt.savefig("imOr_autos.jpg") plt.show() """ plt.title('Histograma') plt.plot(histograma) plt.plot(linea) plt.text(int(umbral_rango),500,u'umbral_otsu',fontsize = 10,horizontalalignment = 'center') plt.axis([0,255,0,600]) plt.show() """ imagen_resultante = imagen * imagen_filtrada return imagen_resultante, detect
def extract_kidney_mask(self, outputPath=None): ''' Extract kidney mask in smallest resolution ''' # Gaussian blur wsi_blur = gaussian(np.uint8(self.wsi), sigma=1) # gray level kidneyMask = rgb2gray(wsi_blur) # binary by OTSU thresholding thresh = otsu(kidneyMask, nbins=256) kidneyMask = kidneyMask <= thresh # morphological operations kidneyMask = binary_fill_holes(kidneyMask) kidneyMask = binary_opening(kidneyMask, structure=np.ones((3, 3)), iterations=3) # Get biggest area(s) labeledImg = label(kidneyMask) props = regionprops(labeledImg) all_areas = [] for i, _ in enumerate(props): all_areas.append([props[i]['area'], i]) all_areas.sort(reverse=True) # Deciding if there are one or two kidneys ''' First extract the biggest area. If: second biggest area is at least as big as half the first biggest area, this WSI shows two kidneys. Extract mask for two kidneys. Else: Extract only one mask. ''' kidney_areas = [] ind = [] if len(all_areas) == 1: kidney_areas.extend([all_areas[0][0]]) ind.extend([all_areas[0][1]]) elif all_areas[1][0] >= int( all_areas[0][0] * .5): # bigger than 50% biggest area kidney_areas.extend([all_areas[0][0], all_areas[1][0]]) ind.extend([all_areas[0][1], all_areas[1][1]]) else: kidney_areas.extend([all_areas[0][0]]) ind.extend([all_areas[0][1]]) # Delete all small blobs from kidney mask for i, _ in enumerate(props): if i not in ind: coord = props[i]['bbox'] kidneyMask[coord[0]:coord[2], coord[1]:coord[3]] = 0 ''' If two kidneys, kidneyMask is a 3-channel image ''' labeledImg = label(kidneyMask) props = regionprops(labeledImg) _, offset = self.get_params(self.slide.level_count - 1, self.highestOffset) self.all_coord = [] if len(np.unique(labeledImg)) == 3: self.nr_kidneys = 2 tempMask = np.zeros( (np.shape(labeledImg)[0], np.shape(labeledImg)[1], 3)) for i, region in enumerate(props): coord = region['bbox'] # To make sure all kidney tissue is covered while extracting patches coord = (max(coord[0] - offset, 0), max(coord[1] - offset, 0), min(coord[2] + offset, self.slide.level_dimensions[-1][1]), min(coord[3] + offset, self.slide.level_dimensions[-1][0])) self.all_coord.append(coord) tempMask[:, :, i][coord[0]:coord[2], coord[1]:coord[3]] = kidneyMask[coord[0]:coord[2], coord[1]:coord[3]] kidneyMask = tempMask else: coord = props[0]['bbox'] # To make sure all kidney tissue is covered while extracting patches coord = (max(coord[0] - offset, 0), max(coord[1] - offset, 0), min(coord[2] + offset, self.slide.level_dimensions[-1][1]), min(coord[3] + offset, self.slide.level_dimensions[-1][0])) self.all_coord = coord self.nr_kidneys = 1 ''' Important for assigning kidneyIdentifier: Upper/Left kidney = kidneyMask[:,:,0] Lower/Right kidney = kidneyMask[:,:,1] ''' if self.nr_kidneys > 1: if self.all_coord[0][0] >= self.all_coord[1][0] or self.all_coord[ 0][2] >= self.all_coord[1][2]: # swap coords self.all_coord[0], self.all_coord[1] = self.all_coord[ 1], self.all_coord[0] # swap kidney images temp = np.zeros_like(kidneyMask[:, :, 0]) temp = kidneyMask[:, :, 0].copy() kidneyMask[:, :, 0] = kidneyMask[:, :, 1] kidneyMask[:, :, 1] = temp # make sure user inputs valid kidneyIdentifier self.check_kidneyIdentifier( self.kidneyIdentifier ) # (self, kidneyIdentifier=self.kidneyIdentifier) # plt.imsave(os.path.join(outputPath, self.fileName + '_' + str(self.kidneyIdentifier) + '.jpg'), kidneyMask) return kidneyMask, self.all_coord, self.nr_kidneys
def median_otsu(input_volume, vol_idx=None, median_radius=4, numpass=4, autocrop=False, dilate=None): """Simple brain extraction tool method for images from DWI data. It uses a median filter smoothing of the input_volumes `vol_idx` and an automatic histogram Otsu thresholding technique, hence the name *median_otsu*. This function is inspired from Mrtrix's bet which has default values ``median_radius=3``, ``numpass=2``. However, from tests on multiple 1.5T and 3T data from GE, Philips, Siemens, the most robust choice is ``median_radius=4``, ``numpass=4``. Parameters ---------- input_volume : ndarray 3D or 4D array of the brain volume. vol_idx : None or array, optional. 1D array representing indices of ``axis=3`` of a 4D `input_volume`. None is only an acceptable input if ``input_volume`` is 3D. median_radius : int Radius (in voxels) of the applied median filter (default: 4). numpass: int Number of pass of the median filter (default: 4). autocrop: bool, optional if True, the masked input_volume will also be cropped using the bounding box defined by the masked data. Should be on if DWI is upsampled to 1x1x1 resolution. (default: False). dilate : None or int, optional number of iterations for binary dilation Returns ------- maskedvolume : ndarray Masked input_volume mask : 3D ndarray The binary brain mask Notes ----- Copyright (C) 2011, the scikit-image team All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of skimage nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ if len(input_volume.shape) == 4: if vol_idx is not None: b0vol = np.mean(input_volume[..., tuple(vol_idx)], axis=3) else: raise ValueError("For 4D images, must provide vol_idx input") else: b0vol = input_volume # Make a mask using a multiple pass median filter and histogram # thresholding. mask = multi_median(b0vol, median_radius, numpass) thresh = otsu(mask) mask = mask > thresh if dilate is not None: cross = generate_binary_structure(3, 1) mask = binary_dilation(mask, cross, iterations=dilate) # Auto crop the volumes using the mask as input_volume for bounding box # computing. if autocrop: mins, maxs = bounding_box(mask) mask = crop(mask, mins, maxs) croppedvolume = crop(input_volume, mins, maxs) maskedvolume = applymask(croppedvolume, mask) else: maskedvolume = applymask(input_volume, mask) return maskedvolume, mask
def compute_hardi_bounds(data, alpha, mask=None): """ Compute fidelity bounds for (subdomain) of HARDI signal `data`. Args: data : QBallData, data description data.raw : numpy array of shape (B,X,Y,Z,L) three-dim. (B-batch of) HARDI signals with L b-vectors data.slice : indexing into (X,Y,Z) of raw data bounds are only computed for this slice data.b_sph : Sphere object from b-vectors alpha : confidence level mask : numpy array of shape (X,Y,Z) foreground mask, containing only 1s and 0s Returns: nothing, sets data.bounds to (alpha, fl, fu), where fl, fu : numpy arrays of shape (L,N) lower and upper bounds for averaged log(-log(data)) the image dimensions are raveled """ if data.bounds is not None and data.bounds_alpha == alpha: return data_raw = np.array(data.raw, dtype=np.float64) if len(data_raw.shape) < 5: data_raw = data_raw[None] where_b0 = (data.gtab.bvals == 0) where_dwi = (data.gtab.bvals > 0) # scale data to [0.0,0.8] (restored after parameter estimation) scaling_factor = np.amax(data_raw.ravel()) / 0.8 data_raw /= scaling_factor b_batch = data_raw.shape[0] l_labels = data.b_sph.mdims['l_labels'] if mask is None: # automatically estimate foreground from histogram thresholding (Otsu) mask = np.mean(data_raw[..., where_dwi], axis=(0, -1)) thresh = otsu(mask) mask = (mask <= thresh) if len(mask[data.slice].shape) == 2: logging.debug("\n%s" % matrix2brl(mask[data.slice].astype(int))) mask = np.tile(mask, (1, 1, 1, data_raw.shape[-1])).ravel() sigma = rice_sigma_mle(data_raw.reshape(b_batch, -1), mask) logging.info('Rescaled sigma=%.5f.', sigma * scaling_factor) logging.info( 'Computing confidence intervals with confidence level %.3f' ' from batch of size %d...', alpha, b_batch) data_sliced = data_raw[(slice(None), ) + data.slice] imagedims = data_sliced.shape[1:-1] n_image = np.prod(imagedims) data_flat = data_sliced.reshape(b_batch, -1) _, data_l, data_u = rice_nu_paramci_batch(data_flat, sigma, alpha) # -------------- Postprocessing of bounds ---------------------------------- # Restore original scaling data_l = scaling_factor * data_l.reshape(data_sliced.shape) data_u = scaling_factor * data_u.reshape(data_sliced.shape) # normalize data according to b0-image if not data.normed: data_l.clip(1.0, out=data_l) data_u.clip(1.0, out=data_u) b0_l = data_l[..., where_b0].mean(-1) b0_u = data_u[..., where_b0].mean(-1) data_l /= b0_u[..., None] data_u /= b0_l[..., None] data_l = data_l[..., where_dwi] data_u = data_u[..., where_dwi] # clip data away from 0 and 1 clip_hardi_data(data_l) clip_hardi_data(data_u) assert ((data_l <= data_u).all()) # apply log(-log) fl = np.zeros((l_labels, n_image), order='C') fu = np.zeros((l_labels, n_image), order='C') fl[:] = np.log(-np.log(data_u)).reshape(-1, l_labels).T fu[:] = np.log(-np.log(data_l)).reshape(-1, l_labels).T assert ((fl <= fu).all()) # subtract mean fl_mean = np.einsum('ki,k->i', fl, data.b_sph.b) / (4 * np.pi) fu_mean = np.einsum('ki,k->i', fu, data.b_sph.b) / (4 * np.pi) fu -= fl_mean fl -= fu_mean data.bounds = (alpha, fl, fu)
def imagen_auto_segmentada(prom_masDesvEstandar,prom_menosDesvEstandar,pintar=True): imagen_auto1 = np.zeros((230,350),dtype="float64") imagen_auto2 = np.zeros((230,350),dtype="float64") nombre = 0#randint(1,339) detect = [] for indice in range(100): nombre = indice + 1 imagen = cv.imread("Personas/segmentacion/imagenes/%d.jpg"%nombre,cv.IMREAD_GRAYSCALE) imagen_auto1 = imagen < prom_menosDesvEstandar imagen_auto2 = imagen > prom_masDesvEstandar imagen_or = np.bitwise_or(imagen_auto1,imagen_auto2) #func_or(imagen_auto1,imagen_auto2) s = 10 w = 3 t = (((w-1)/2)-0.5)/s imagen_filtrada = gaussian(imagen_or,sigma = s,truncate = t) imagen_filtrada = median(imagen_or,np.ones((5,5))) umbral = otsu(imagen_filtrada) imagen_filtrada = imagen_filtrada > umbral imagen_resultante = imagen * imagen_filtrada num_pixeles = np.sum(imagen_filtrada) num_personas = num_pixeles / 1200 num_personas_t = round(num_personas) detect.append(num_personas_t) plt.title('Imagen filtrada') plt.imshow(imagen_filtrada,cmap='gray') plt.savefig("Personas/segmentacion/programa/%d.jpg"%nombre) plt.show() print("{cont} Num pixeles = {pixeles} Num personas = {personas} round={trun}".format(cont=nombre,pixeles = num_pixeles,personas=num_personas,trun=num_personas_t)) """ umbral_rango = umbral * 255 rango_imagen_filtrada = imagen_filtrada * 255 rango_imagen_filtrada = np.array(rango_imagen_filtrada,dtype=np.uint8) histograma = np.zeros((256,1),dtype = np.double) filas,columnas = rango_imagen_filtrada.shape for i in range(filas): for j in range(columnas): histograma[rango_imagen_filtrada[i,j]][0] += 1 linea = np.zeros((256,1),dtype = np.double) linea[int(umbral_rango)] = 600 """ if(pintar == True): plt.title('Imagen leida %d'%nombre) plt.imshow(imagen,cmap='gray') plt.show() plt.title('Imagen filtrada') plt.imshow(imagen_filtrada,cmap='gray') plt.savefig("Personas/segmentacion/programa/%d.jpg"%nombre) plt.show() plt.title("Imagen segmentada") plt.imshow(imagen_resultante,cmap="gray") plt.savefig("imSegmentada_personas.jpg") plt.show() plt.title('Imagen leida < prom_menosDesvEstandar') plt.imshow(imagen_auto1,cmap='gray') plt.savefig("imMenor_personas.jpg") plt.show() plt.title('Imagen Auto > prom_masDesvEstandar') plt.imshow(imagen_auto2,cmap='gray') plt.savefig("imMayor_personas.jpg") plt.show() """ plt.title("Imagen_or") plt.imshow(imagen_or,cmap="gray") plt.savefig("imSegmentada_personas.jpg") #plt.savefig("Personas/resultadoPersonas/%d.jpg"%nombre) plt.show() plt.title('Histograma') plt.plot(histograma) plt.plot(linea) plt.text(int(umbral_rango),500,u'umbral_otsu',fontsize = 10,horizontalalignment = 'center') plt.axis([0,255,0,600]) plt.show() """ return imagen_resultante,detect
def median_otsu(input_volume, median_radius=4, numpass=4, autocrop=False, vol_idx=None, dilate=None): """ Simple brain extraction tool method for images from DWI data It uses a median filter smoothing of the input_volumes `vol_idx` and an automatic histogram Otsu thresholding technique, hence the name *median_otsu*. This function is inspired from Mrtrix's bet which has default values ``median_radius=3``, ``numpass=2``. However, from tests on multiple 1.5T and 3T data from GE, Philips, Siemens, the most robust choice is ``median_radius=4``, ``numpass=4``. Parameters ---------- input_volume : ndarray ndarray of the brain volume median_radius : int Radius (in voxels) of the applied median filter(default 4) numpass: int Number of pass of the median filter (default 4) autocrop: bool, optional if True, the masked input_volume will also be cropped using the bounding box defined by the masked data. Should be on if DWI is upsampled to 1x1x1 resolution. (default False) vol_idx : None or array, optional 1D array representing indices of ``axis=3`` of a 4D `input_volume` None (the default) corresponds to ``(0,)`` (assumes first volume in 4D array) dilate : None or int, optional number of iterations for binary dilation Returns ------- maskedvolume : ndarray Masked input_volume mask : 3D ndarray The binary brain mask """ if len(input_volume.shape) == 4: if vol_idx is not None: b0vol = np.mean(input_volume[..., tuple(vol_idx)], axis=3) else: b0vol = input_volume[..., 0].copy() else: b0vol = input_volume.copy() # Make a mask using a multiple pass median filter and histogram thresholding. mask = multi_median(b0vol, median_radius, numpass) thresh = otsu(mask) mask = mask > thresh if dilate is not None: cross = generate_binary_structure(3, 1) mask = binary_dilation(mask, cross, iterations=dilate) # Auto crop the volumes using the mask as input_volume for bounding box computing. if autocrop: mins, maxs = bounding_box(mask) mask = crop(mask, mins, maxs) croppedvolume = crop(input_volume, mins, maxs) maskedvolume = applymask(croppedvolume, mask) else: maskedvolume = applymask(input_volume, mask) return maskedvolume, mask
return 'tangerine' else: return 'unknown' f = open('feature.csv', 'w') f.write( 'area,bbox_area,centroidX,centroidY,convex_area,eccentricity,equivalent_diameter,euler_number,extent,filled_area,major_axis_length,.minor_axis_length,orientation,perimeter,solidity,kelas\n' ) for i in os.listdir('.'): if i.endswith('.jpg'): temp = i.split('.') kelas = leavesClass(int(temp[0])) img = io.imread(i) imgGray = rgb2gray(img) threshold = otsu(imgGray, 256) x, y = imgGray.shape for k in range(x): for l in range(y): if imgGray[k][l] > threshold: imgGray[k][l] = 0 else: imgGray[k][l] = 1 imgLabel = label(imgGray) props = regionprops(imgLabel) centroid = props[0].centroid f.write( str(props[0].area) + ',' + str(props[0].bbox_area) + ',' + str(centroid[0]) + ',' + str(centroid[1]) + ',' + str(props[0].convex_area) + ',' + str(props[0].eccentricity) +