def plotWinterMaps(dataset, dataVar, winter, minval, maxval, cbarTicks = None, title = "", cmap = 'viridis'): """Plot maps of the arctic on North Pole Stereo projection with several months of data overlayed, along with the sea ice edge for each month. Args: dataset (xr Dataset): dataset from google bucket dataVar (str): variable of interest winter (list): list of pandas Timestamp objects generated by getWinterDateRange(startYear, endYear) minval, maxval (int): minimum and maximum values for the data variable cbarTicks (list or np array of length 2): ticks to use on colorbar (default to [minval + 1, maxval +1]) title (str, optional): title of subplots (default to empty string) cmap (str, optional): color map (default to viridis) Returns: Figure displayed in notebook """ #format time for plotting timeFormatted = list(pd.to_datetime(winter).strftime('%B %Y')) #define projection and transform proj = ccrs.NorthPolarStereo(central_longitude = -45) transform = ccrs.PlateCarree() #define arguments if not inputted cbarTicks = np.arange(minval, maxval + 1, 1) if cbarTicks is None else cbarTicks #plot the data im = dataset[dataVar].where(dataset['seaice_conc_monthly_cdr'] > 0.5).sel(time = winter).plot(x = 'longitude', y = 'latitude', vmin = minval, vmax = maxval, cmap = cmap, extend='both', levels=20, transform = transform, col='time', add_colorbar = True, zorder = 2, figsize = (8,8), col_wrap = 3, cbar_kwargs = {'ticks': cbarTicks, 'label': "\n".join(wrap(dataset[dataVar].attrs['long_name'] + ' (' + dataset[dataVar].attrs['units'] + ')', 50)), 'orientation': 'horizontal', 'shrink': 0.4, 'pad': 0.025}, subplot_kws = {'projection': proj}) #add a title plt.suptitle(title + ': ' + dataset[dataVar].attrs['long_name'], fontsize = 20, y = 0.99, fontweight = 'medium') i = 0 #indexer to go through timeFormatted and winter arrays and assign the correct data to each month for ax in im.axes.flat: ax.coastlines(linewidth=0.25, color = 'black', zorder = 10) #add coastlines ax.add_feature(cfeature.LAND, color ='0.95', zorder = 5) #add land ax.add_feature(cfeature.LAKES, color = 'grey', zorder = 5) #add lakes ax.gridlines(draw_labels = False, linewidth = 0.25, color = 'gray', alpha = 0.75, linestyle='--', zorder = 6) #add gridlines ax.set_extent([-179, 179, 50, 90], crs = transform) #zoom in so map only displays the Arctic ax.set_title(timeFormatted[i]) #plot sea ice concentration SICarray = dataset['seaice_conc_monthly_cdr'].sel(time = winter[i]).where(dataset['region_mask']!=21) #dont plot contour along coastlines lonGreater = ma.masked_greater(SICarray.longitude.values, -0.01) lonLesser = ma.masked_less(SICarray.longitude.values, 0) latGreater = ma.MaskedArray(SICarray.latitude.values, mask = lonGreater.mask) latLesser = ma.MaskedArray(SICarray.latitude.values, mask = lonLesser.mask) dataGreater = ma.MaskedArray(SICarray.values, mask = lonGreater.mask) dataLesser = ma.MaskedArray(SICarray.values, mask = lonLesser.mask) im2a = ax.contour(lonGreater, latGreater, dataGreater, levels = [0.5], transform = transform, colors = 'magenta', linewidths = 0.8, zorder = 5, alpha = 1) im2b = ax.contour(lonLesser, latLesser, dataLesser, levels = [0.5], transform = transform, colors = 'magenta', linewidths = 0.8, zorder = 5, alpha = 1) #update indexer i += 1 #display figure in notebook plt.show()
def bin_masked_image(image, mask, bin_fac): """bins the image using masked array, taking care of the fact that some pixels are masked image - 2d array, image you want to downsize mask - 2d array, pixels to mask bin_fac - factor by which to down size the image """ # check if shape of image are integer multiples of bin_fac if image.shape[0] % bin_fac or image.shape[1] % bin_fac: x = int(self.Y * bin_fac) y = int(self.X * bin_fac) new_img = np.zeros((x, y), dtype=np.float64) new_mask = np.zeros((x, y), dtype=np.bool) new_img[:image.shape[0], :image.shape[1]] = image new_mask[:image.shape[0], :image.shape[1]] = mask img = ma.MaskedArray(new_img, mask=~new_mask.astype(bool)) else: img = ma.MaskedArray(image, mask=~mask.astype(bool)) Nsmallx = int(img.shape[0] / bin_fac) Nsmally = int(img.shape[1] / bin_fac) binned_img = img.reshape([Nsmallx, int(bin_fac), Nsmally, int(bin_fac)]).mean(3).mean(1) return binned_img.data
def setUp(self): rng = np.random.RandomState(713244122) self.nside = 16 self.radius = 1.8 self.testslicer = HealpixSlicer(nside=self.nside, verbose=False, latLonDeg=False, lonCol='ra', latCol='dec', radius=self.radius) nvalues = 10000 self.dv = makeDataValues(size=nvalues, minval=0., maxval=1., ramin=0, ramax=2 * np.pi, decmin=-np.pi, decmax=0, random=66) self.testslicer.setupSlicer(self.dv) self.metricdata = ma.MaskedArray(data=np.zeros(len(self.testslicer), dtype='float'), mask=np.zeros(len(self.testslicer), 'bool'), fill_value=self.testslicer.badval) for i, b in enumerate(self.testslicer): idxs = b['idxs'] if len(idxs) > 0: self.metricdata.data[i] = np.mean(self.dv['testdata'][idxs]) else: self.metricdata.mask[i] = True self.metricdata2 = ma.MaskedArray(data=rng.rand(len(self.testslicer)), mask=np.zeros( len(self.testslicer), 'bool'), fill_value=self.testslicer.badval)
def readData(self, infilename): """ Read metric data from disk, along with the info to rebuild the slicer (minus new slicing capability). infilename: the filename containing the metric data. """ import lsst.sims.maf.slicers as slicers restored = np.load(infilename) # Get metric data set if restored['mask'][()] is None: metricValues = ma.MaskedArray(data=restored['metricValues']) else: metricValues = ma.MaskedArray(data=restored['metricValues'], mask=restored['mask'], fill_value=restored['fill']) # Get Metadata & other simData info. header = restored['header'][()] # extra brackets restore dictionary to dictionary status. # Get slicer instantiated. slicer_init = restored['slicer_init'][()] # Backwards compatibility issue - map 'spatialkey1/spatialkey2' to 'lonCol/latCol'. if 'spatialkey1' in slicer_init: slicer_init['lonCol'] = slicer_init['spatialkey1'] del(slicer_init['spatialkey1']) if 'spatialkey2' in slicer_init: slicer_init['latCol'] = slicer_init['spatialkey2'] del(slicer_init['spatialkey2']) slicer = getattr(slicers, str(restored['slicerName']))(**slicer_init) # Restore slicePoint metadata. slicer.nslice = restored['slicerNSlice'] slicer.slicePoints = restored['slicePoints'][()] slicer.shape = restored['slicerShape'] return metricValues, slicer, header
def _bin_masked_image(self, image, mask, bin_fac): # check if shape of image are integer multiples of bin_fac if image.shape[0] % bin_fac or image.shape[1] % bin_fac: x = int(self.Y * bin_fac) y = int(self.X * bin_fac) new_img = np.zeros((x, y), dtype=np.float64) new_mask = np.zeros((x, y), dtype=np.bool) new_img[:image.shape[0], :image.shape[1]] = image new_mask[:image.shape[0], :image.shape[1]] = mask img = ma.MaskedArray(new_img, mask=~new_mask.astype(bool)) else: img = ma.MaskedArray(image, mask=~mask.astype(bool)) Nsmallx = int(img.shape[0] / bin_fac) Nsmally = int(img.shape[1] / bin_fac) binned_img = img.reshape( [Nsmallx, int(bin_fac), Nsmally, int(bin_fac)]).mean(3).mean(1) return binned_img.data
def test_increase_cube_dimensionality(self): with self.assertRaises(ValueError): # This would increase the dimensionality of the cube due to auto broadcasting cubex = iris.cube.Cube(ma.MaskedArray([[ 9, ]], mask=[[0]])) cubex + ma.MaskedArray([[3, 3, 3, 3]], mask=[[0, 1, 0, 1]])
def resample_from_array( in_raster=None, in_affine=None, out_tile=None, resampling="nearest", nodataval=0 ): """ Extract and resample from array to target tile. Parameters ---------- in_raster : array in_affine : ``Affine`` out_tile : ``BufferedTile`` resampling : string one of rasterio's resampling methods (default: nearest) nodataval : integer or float raster nodata value (default: 0) Returns ------- resampled array : array """ if isinstance(in_raster, ma.MaskedArray): pass if isinstance(in_raster, np.ndarray): in_raster = ma.MaskedArray(in_raster, mask=in_raster == nodataval) elif isinstance(in_raster, ReferencedRaster): in_affine = in_raster.affine in_raster = in_raster.data elif isinstance(in_raster, tuple): in_raster = ma.MaskedArray( data=np.stack(in_raster), mask=np.stack([ band.mask if isinstance(band, ma.masked_array) else np.where(band == nodataval, True, False) for band in in_raster ]), fill_value=nodataval ) else: raise TypeError("wrong input data type: %s" % type(in_raster)) if in_raster.ndim == 2: in_raster = ma.expand_dims(in_raster, axis=0) elif in_raster.ndim == 3: pass else: raise TypeError("input array must have 2 or 3 dimensions") if in_raster.fill_value != nodataval: ma.set_fill_value(in_raster, nodataval) out_shape = (in_raster.shape[0], ) + out_tile.shape dst_data = np.empty(out_shape, in_raster.dtype) in_raster = ma.masked_array( data=in_raster.filled(), mask=in_raster.mask, fill_value=nodataval) reproject( in_raster, dst_data, src_transform=in_affine, src_crs=out_tile.crs, dst_transform=out_tile.affine, dst_crs=out_tile.crs, resampling=Resampling[resampling]) return ma.MaskedArray(dst_data, mask=dst_data == nodataval)
def plotOneMonth(dataset, dataVar, month, minval, maxval, cbarTicks = None, cmap = 'viridis'): """Plots map of the arctic on North Pole Stereo projection with one month of data overlayed, along with the sea ice edge for each month. Args: dataset (xr Dataset): dataset from google bucket dataVar (str): variable of interest month (str): month and year of interest, i.e. 'Dec 2019' (does not need to be in any particular format) minval, maxval (int): minimum and maximum values for the data variable cbarTicks (list or np array of length 2): ticks to use on colorbar (default to [minval + 1, maxval +1]) cmap (str, optional): color map (default to viridis) Returns: Figure displayed in notebook """ #define projection and transform proj = ccrs.NorthPolarStereo(central_longitude = -45) transform = ccrs.PlateCarree() #initialize the figure and axes plt.figure(figsize=(6, 6)) ax = plt.axes(projection = proj) #define arguments if not inputted cbarTicks = np.arange(minval, maxval + 1, 1) if cbarTicks is None else cbarTicks #plot sea ice concentraion SICarray = dataset['seaice_conc_monthly_cdr'].sel(time = month).where(dataset['region_mask']!=21) #dont plot contour along coastlines #stackexchange workaround for plotting on a rotated grid lonGreater = ma.masked_greater(SICarray.longitude.values, -0.01) lonLesser = ma.masked_less(SICarray.longitude.values, 0) latGreater = ma.MaskedArray(SICarray.latitude.values, mask = lonGreater.mask) latLesser = ma.MaskedArray(SICarray.latitude.values, mask = lonLesser.mask) dataGreater = ma.MaskedArray(SICarray.values[0], mask = lonGreater.mask) dataLesser = ma.MaskedArray(SICarray.values[0], mask = lonLesser.mask) #plot contour using each part of the 2 masked data sets im2a = ax.contour(lonGreater, latGreater, dataGreater, levels = [0.5], transform = transform, colors = 'magenta', linewidths = 0.9, zorder=5, alpha=1) im2b = ax.contour(lonLesser, latLesser, dataLesser, levels = [0.5], transform = transform, colors = 'magenta', linewidths = 0.9, zorder=5, alpha=1) #im = ax.contour(SICarray.longitude.values, SICarray.latitude.values, SICarray.values[0], levels = [0.15], transform = transform, colors = 'magenta', linewidths = 0.8, zorder=15, alpha=1) #plot the data dataset[dataVar].where(dataset['seaice_conc_monthly_cdr'] > 0.5).sel(time = month).plot(x = 'longitude', y = 'latitude', vmin = minval, vmax = maxval, extend = 'both', ax = ax, add_colorbar = True, transform = transform, zorder = 2, cmap = cmap, cbar_kwargs = {'label': "\n".join(wrap(dataset[dataVar].attrs['long_name'] + ' (' + dataset[dataVar].attrs['units'] + ')', 50)), 'orientation': 'horizontal', 'shrink': 0.75, 'pad': 0.025}) #add features to the map ax.coastlines(linewidth=0.15, color = 'black', zorder = 10) #add coastlines ax.add_feature(cfeature.LAND, color ='0.95', zorder = 5) #add land ax.add_feature(cfeature.LAKES, color = 'grey', zorder = 5) #add lakes ax.gridlines(draw_labels = False, linewidth = 0.25, color = 'gray', alpha = 0.7, linestyle = '--', zorder = 6) #add gridlines ax.set_extent([-179, 179, 55, 90], crs = transform) #zoom in so map only displays the Arctic ax.set_title("\n".join(wrap(month + ": " + dataset[dataVar].attrs['long_name'], 38)), fontsize = 'x-large') #display figure in notebook plt.show()
def generation(data): neighbors= ndi.convolve(data, KERNEL, mode='constant', cval=0) has_bugs = data == 1 dies = np.logical_and(has_bugs, neighbors != 1) spawns = np.logical_and(~has_bugs, np.logical_or(neighbors == 1, neighbors == 2)) result = ma.MaskedArray(data, mask=dies).filled(0) return ma.MaskedArray(result, mask=spawns).filled(1)
def _get_warped_array( input_file=None, band_idx=None, dst_bounds=None, dst_shape=None, dst_affine=None, dst_crs=None, resampling="nearest" ): """Extract a numpy array from a raster file.""" LOGGER.debug("read array using rasterio") with rasterio.open(input_file, "r") as src: if dst_crs == src.crs: src_left, src_bottom, src_right, src_top = dst_bounds else: # Return empty array if destination bounds don't intersect with # file bounds. file_bbox = box(*src.bounds) tile_bbox = reproject_geometry( box(*dst_bounds), src_crs=dst_crs, dst_crs=src.crs) if not file_bbox.intersects(tile_bbox): LOGGER.debug("file bounding box does not intersect with tile") return ma.MaskedArray( data=ma.zeros(dst_shape, dtype=src.profile["dtype"]), mask=ma.ones(dst_shape), fill_value=src.nodata) # Reproject tile bounds to source file SRS. src_left, src_bottom, src_right, src_top = transform_bounds( dst_crs, src.crs, *dst_bounds, densify_pts=21) if float('Inf') in (src_left, src_bottom, src_right, src_top): # Maybe not the best way to deal with it, but if bounding box # cannot be translated, it is assumed that data is emtpy LOGGER.debug("tile seems to be outside of input CRS bounds") return ma.MaskedArray( data=ma.zeros(dst_shape, dtype=src.profile["dtype"]), mask=ma.ones(dst_shape), fill_value=src.nodata) # Read data window. window = src.window( src_left, src_bottom, src_right, src_top, boundless=True) start = time.time() src_band = src.read(band_idx, window=window, boundless=True) LOGGER.debug("window read in %ss" % round(time.time() - start, 3)) # Quick fix because None nodata is not allowed. nodataval = 0 if not src.nodata else src.nodata # Prepare reprojected array. dst_band = np.empty(dst_shape, src.dtypes[band_idx-1]) # Run rasterio's reproject(). start = time.time() reproject( src_band, dst_band, src_transform=src.window_transform(window), src_crs=src.crs, src_nodata=nodataval, dst_transform=dst_affine, dst_crs=dst_crs, dst_nodata=nodataval, resampling=RESAMPLING_METHODS[resampling]) LOGGER.debug( "window reprojected in %ss" % round(time.time() - start, 3)) return ma.MaskedArray(dst_band, mask=dst_band == nodataval)
def readData(self, infilename): """ Read metric data from disk, along with the info to rebuild the slicer (minus new slicing capability). Parameters ----------- infilename: str The filename containing the metric data. Returns ------- np.ma.MaskedArray, lsst.sims.maf.slicer, dict MetricValues stored in data file, the slicer basis for those metric values, and a dictionary containing header information (runName, metadata, etc.). """ import lsst.sims.maf.slicers as slicers # Allowing pickles here is required, because otherwise we cannot restore data saved as objects. restored = np.load(infilename, allow_pickle=True) # Get metadata and other simData info. header = restored['header'][()] slicer_init = restored['slicer_init'][()] slicerName = str(restored['slicerName']) slicePoints = restored['slicePoints'][()] # Backwards compatibility issue - map 'spatialkey1/spatialkey2' to 'lonCol/latCol'. if 'spatialkey1' in slicer_init: slicer_init['lonCol'] = slicer_init['spatialkey1'] del (slicer_init['spatialkey1']) if 'spatialkey2' in slicer_init: slicer_init['latCol'] = slicer_init['spatialkey2'] del (slicer_init['spatialkey2']) try: slicer = getattr(slicers, slicerName)(**slicer_init) except TypeError: warnings.warn( 'Cannot use saved slicer init values; falling back to defaults' ) slicer = getattr(slicers, slicerName)() # Restore slicePoint metadata. slicer.nslice = restored['slicerNSlice'] slicer.slicePoints = slicePoints slicer.shape = restored['slicerShape'] # Get metric data set if restored['mask'][()] is None: metricValues = ma.MaskedArray(data=restored['metricValues']) else: metricValues = ma.MaskedArray(data=restored['metricValues'], mask=restored['mask'], fill_value=restored['fill']) return metricValues, slicer, header
def colorNormReinhard(image): #Takes image as a float64 values in range [0,1] mst = np.array(([77.5121, 270.5718], [8.9287, -23.6535], [2.9664, 8.3857])) M = image.shape[0] N = image.shape[1] lab = customRGB2LAB(image) bcg = bcg_func(image) bcg_inverse = (bcg - 1) * -1 bcgvect = np.reshape(bcg, (M * N)) bcgv_i = np.reshape(bcg_inverse, (M * N)) labvect = np.transpose(np.reshape(lab, (M * N, 3))) labL = ma.MaskedArray(labvect[0, :], mask=bcgvect) labA = ma.MaskedArray(labvect[1, :], mask=bcgvect) labB = ma.MaskedArray(labvect[2, :], mask=bcgvect) # labL_inv = ma.MaskedArray(labvect[0,:], mask=bcgv_i) # labA_inv = ma.MaskedArray(labvect[1,:], mask=bcgv_i) # labB_inv = ma.MaskedArray(labvect[2,:], mask=bcgv_i) labLm = labL.mean() labAm = labA.mean() labBm = labB.mean() labLs = labL.std() labAs = labA.std() labBs = labB.std() labLn = ((labvect[0, :] - labLm) / labLs) * mst[0, 0] + mst[0, 1] labAn = ((labvect[1, :] - labAm) / labAs) * mst[1, 0] + mst[1, 1] labBn = ((labvect[2, :] - labBm) / labBs) * mst[2, 0] + mst[2, 1] labL = np.multiply(labLn, bcgv_i) / 255 + np.multiply(labL, bcgvect) labA = np.multiply(labAn, bcgv_i) / 255 + np.multiply(labA, bcgvect) labB = np.multiply(labBn, bcgv_i) / 255 + np.multiply(labB, bcgvect) # labL = ((labL-labLm)/labLs)*mst[0,0]+mst[0,1] # labA = ((labA-labAm)/labAs)*mst[1,0]+mst[1,1] # labB = ((labB-labBm)/labBs)*mst[2,0]+mst[2,1] labnorm = np.array((labL, labA, labB)) labnorm = np.reshape(np.transpose(labnorm), (M, N, 3)) rgbnorm = customLAB2RGB(labnorm) return rgbnorm
def aggregate2DTrial(sp, varList, trialNumList, fReduce=np.mean, ignoreNaNs=False): '''Aggregate all the data from a 2D Parameter space (:class:`~grid_cell_model.parameters.param_space.JobTrialSpace2D`). In the process, apply ``fReduce`` on the trials of all the data sets in the parameter space. Parameters ---------- sp : ParamSpace A parameter space to apply the reduction on. varList : list of strings A variable list, specifying the location of the variable to reduce. This will be prefixed with ['analysis'] trialNumList : list of ints A list specifying exactly which trials are to be processed. fReduce : a function f(data, axis) A reduction function. ignoreNaNs : bool, optional If True, mask the NaN values. output : a 2D numpy array of the reduced values ''' varList = ['analysis'] + varList retVar = sp.aggregateData(varList, trialNumList, funReduce=np.mean, saveData=False) if (ignoreNaNs): nans = np.isnan(retVar) retVar = ma.MaskedArray(retVar, mask=nans) return fReduce(retVar, 2)
def denoise_sst(sst, bt11, kernel='boxcar', width=20, show=False): """ """ if kernel == 'boxcar': ker = np.ones((width, width)) elif kernel == 'gaussian': gau = gaussian(3 * width, width / 2.) ker = np.outer(gau, gau) else: raise Exception('Unknown kernel') mask = ma.getmaskarray(sst) | ma.getmaskarray(bt11) sst.data[mask] = 0. bt11.data[mask] = 0. corr = convolve((sst - 273.15) * 0.9 + 273.15 - bt11, ker) #corr = convolve(sst - bt11, ker) #corr = convolve((sst - 273) * 0.9 + 273 - bt11, ker) norm = convolve(1. - mask, ker) corr[mask] = 0 corr[~mask] /= norm[~mask] denoised_sst = bt11 + corr denoised_sst.mask = mask if show == True: import matplotlib.pyplot as plt vmin = min([bt11.min(), sst.min(), denoised_sst.min()]) vmax = max([bt11.max(), sst.max(), denoised_sst.max()]) corr = ma.MaskedArray(corr, mask=mask) for ivar, var in enumerate([sst, bt11, corr, denoised_sst]): plt.figure() if ivar == 2: plt.imshow(var, interpolation='nearest') else: plt.imshow(var, vmin=vmin, vmax=vmax, interpolation='nearest') plt.colorbar() plt.show() return denoised_sst
def makeMetricData(slicer, dtype='float', seed=8800): rng = np.random.RandomState(seed) metricValues = rng.rand(len(slicer)).astype(dtype) metricValues = ma.MaskedArray(data=metricValues, mask=np.zeros(len(slicer), 'bool'), fill_value=slicer.badval) return metricValues
def setUp(self): """Prepare tests.""" self.cube = Cube( ma.MaskedArray([1.e36], mask=(False, )), var_name='od550aer', ) self.fix = Od550Aer(None)
def fancy_plot(self): """Make a fancier looking sky map of the footprint. """ if not (fancyplot): print( 'Cannot make this fancy plot; MAF plotting utilities unavailable.' ) return None # fieldRA / fieldDec are dictionaries - key=prop slicer = slicers.OpsimFieldSlicer() fignum = None colorlist = [[1, 1, 0], [.5, 0, .5], [0, .25, .5], [0, 1, 0], [0, 0, 0], [1, 0, 0], [.5, .5, 1]] ci = 0 colors = {} add_planes = True for name in self.regions: print(name) # Modify slicer so we can use it for plotting. slicer.slicePoints['ra'] = np.radians(self.regions[name]['ra']) slicer.slicePoints['dec'] = np.radians(self.regions[name]['dec']) fieldLocs = ma.MaskedArray(data=np.empty(len(self.regions[name]), object), mask=np.zeros(len(self.regions[name]), bool), fill_value=-99) colors[name] = [ colorlist[ci][0], colorlist[ci][1], colorlist[ci][2], 0.4 ] ci += 1 if ci == len(colorlist): ci = 0 for i in range(len(self.regions[name])): fieldLocs.data[i] = colors[name] skymap = plots.BaseSkyMap() fignum = skymap(fieldLocs, slicer, { 'metricIsColor': True, 'bgcolor': 'lightgray', 'raCen': 0, 'figsize': (10, 8), 'ecPlane': add_planes, 'mwZone': add_planes }, fignum=fignum) add_planes = False fig = plt.figure(fignum) labelcolors = [] labeltext = [] for name in self.regions: el = Ellipse( (0, 0), 0.03, 0.03, fc=(colors[name][0], colors[name][1], colors[name][2]), alpha=colors[name][3]) labelcolors.append(el) labeltext.append(name) plt.legend(labelcolors, labeltext, loc=(0.85, 0.9), fontsize='smaller') return fig
def _prepare_iterable(data, masked, nodata, dtype): out_data = () out_mask = () for band in data: if isinstance(band, ma.MaskedArray): try: out_data += (band.data, ) if masked: assert band.shape == band.mask.shape out_mask += (band.mask, ) except AssertionError: out_mask += ( np.where(band.data == nodata, True, False), ) elif isinstance(band, np.ndarray): out_data += (band, ) if masked: out_mask += (np.where(band == nodata, True, False), ) else: raise ValueError("input data bands must be NumPy arrays") if masked: assert len(out_data) == len(out_mask) return ma.MaskedArray( data=np.stack(out_data).astype(dtype), mask=np.stack(out_mask)) else: return np.stack(out_data).astype(dtype)
def setUp(self): self.data1 = ma.MaskedArray([[9, 9, 9], [ 8, 8, 8, ]], mask=[[0, 1, 0], [0, 0, 1]]) self.data2 = ma.MaskedArray([[3, 3, 3], [ 2, 2, 2, ]], mask=[[0, 1, 0], [0, 1, 1]]) self.cube1 = iris.cube.Cube(self.data1) self.cube2 = iris.cube.Cube(self.data2)
def update_background(fn): with fits.open(fn, mode='update') as hdu: im = hdu[0].data.copy() mask = ~np.isfinite(im) + (im < DATA_FLOOR) if 'MASK' in hdu: mask += hdu['MASK'].data > 0 im = ma.MaskedArray(im, mask=mask, copy=True) scim = sigma_clip(im) mean = ma.mean(scim) mean = mean if mean is not ma.masked else 0 median = ma.median(scim) median = median if median is not ma.masked else 0 stdev = ma.std(scim) stdev = stdev if stdev is not ma.masked else 0 hdu['SCI'].header['bgmean'] = (mean, 'background sigma-clipped mean') hdu['SCI'].header['bgmedian'] = (median, 'background sigma-clipped median') hdu['SCI'].header['bgstdev'] = ( stdev, 'background sigma-clipped standard dev.') hdu['SCI'].header['nbg'] = (ma.sum(~scim.mask), 'area considered in background stats.')
def plotACTrial(sp, varList, iterList, noise_sigma, trialNumList=[0], **kw): '''Plot parameter sweep of gamma autocorrelation peaks.''' #kw arguments r = kw.pop('r', 0) c = kw.pop('c', 0) cbar = kw.pop('cbar', True) sigmaTitle = kw.pop('sigmaTitle', True) annotations = kw.pop('annotations', None) if isinstance(sp, aggr.AggregateData): C, X, Y = sp.getData() else: C = aggr.aggregate2DTrial(sp, varList, trialNumList) Y, X = aggr.computeYX(sp, iterList, r=r, c=c) C = ma.MaskedArray(C, mask=np.isnan(C)) C, ax, cax = plot2DTrial(X, Y, C, colorBar=cbar, **kw) print(" max(C): {0}".format(np.max(C))) print(" min(C): {0}".format(np.min(C))) if (sigmaTitle): ax.set_title('$\sigma$ = {0} pA'.format(int(noise_sigma))) if (annotations is not None): for a in annotations: plotSweepAnnotation(X=X, Y=Y, ax=ax, **a) return C, ax, cax
def plotVelTrial(sp, varList, iterList, noise_sigma, **kw): '''Plot a parameter sweep of velocity data. These are either bump slope or line fit error. ''' # process kwargs r = kw.pop('r', 0) c = kw.pop('c', 0) sigmaTitle = kw.pop('sigmaTitle', True) cbar = kw.pop('cbar', True) annotations = kw.pop('annotations', None) C = aggr.aggregate2D(sp, varList, funReduce = np.sum) C = ma.MaskedArray(C, mask = np.isnan(C)) Y, X = aggr.computeVelYX(sp, iterList, r=r, c=c) C, ax, cax = plot2DTrial(X, Y, C, colorBar=cbar, **kw) print("plotVelTrial: max(C): {0}".format(np.max(C.ravel()))) print("plotVelTrial: min(C): {0}".format(np.min(C.ravel()))) if (sigmaTitle): ax.set_title('$\sigma$ = {0} pA'.format(int(noise_sigma))) if (annotations is not None): for a in annotations: plotSweepAnnotation(X=X, Y=Y, ax=ax, **a) return C, ax, cax
def addVar(self, url, Vars=None, Verbose=True, Levels=None): """ Sample variable along DIAL track. """ from grads import GrADS ga = GrADS(Window=False, Echo=False) fh = ga.open(url) if Levels is not None: ga('set lev %s' % Levels) qh = ga.query('dims') if Vars is None: Vars = ga.query('file').vars elif type(Vars) is StringType: Vars = [ Vars, ] for var in Vars: if Verbose: print ' Working on <%s>' % var if fh.Vars[var.lower()].levs == 0: ga('set lev 1') # 2D variable else: ga.setdim(qh) q = ga.sampleXYT(var, self.lon, self.lat, self.tyme, Verbose=Verbose).data self.__dict__[var] = ma.MaskedArray(q, mask=q >= MAPL_UNDEF)
def plotFRTrial(sp, varList, iterList, noise_sigma, trialNumList=[0], thr=np.infty, **kw): r = kw.pop('r', 0) c = kw.pop('c', 0) ignoreNaNs = kw.pop('ignoreNaNs', False) sigmaTitle = kw.pop('sigmaTitle', True) cbar = kw.pop('cbar', True) annotations = kw.pop('annotations', None) C = aggr.aggregate2DTrial(sp, varList, trialNumList, ignoreNaNs=ignoreNaNs) C = ma.MaskedArray(C, mask=np.logical_or(np.isnan(C), C > thr)) Y, X = aggr.computeYX(sp, iterList, r=r, c=c) C, ax, cax = plot2DTrial(X, Y, C, colorBar=cbar, **kw) print(" max(C): {0}".format(np.max(C))) print(" min(C): {0}".format(np.min(C))) if (sigmaTitle): ax.set_title('$\sigma$ = {0} pA'.format(int(noise_sigma))) if (annotations is not None): for a in annotations: plotSweepAnnotation(X=X, Y=Y, ax=ax, **a) return C, ax, cax
def pixeldata(self, img): if isinstance(img, str): self.__pixeldata = ma.asarray(fits.getdata(img)).astype('<f4') elif isinstance(img, np.ndarray): self.__pixeldata = ma.MaskedArray(img, mask=False).astype('<f4') elif isinstance(img, fits.HDUList): if img[0].is_image: self.__pixeldata = ma.asarray(img[0].data).astype('<f4') elif isinstance(img, fits.PrimaryHDU): if img.is_image: self.__pixeldata = ma.asarray(img.data).astype('<f4') if self.borders: sx, sy = self.__pixeldata.shape line = self.__pixeldata.data[sx // 2, :] pxsum = 0 for x, px in enumerate(line): pxsum += px if pxsum > 0.: ldx = x break for dx in range(ldx): if not np.sum(self.__pixeldata.data[:dx, :]) == 0: ldx = dx break pxsum = 0 for x, px in enumerate(np.flip(line, axis=0)): pxsum += px if pxsum > 0.: rdx = sx - x break for dx in range(x): if not np.sum(self.__pixeldata.data[-dx - 1:, :]) == 0: rdx = sx - dx break col = self.__pixeldata.data[:, sy // 2] pxsum = 0 for y, px in enumerate(col): pxsum += px if pxsum > 0.: ldy = y break for dy in range(ldy): if not np.sum(self.__pixeldata.data[:, :dy]) == 0: ldy = dy break pxsum = 0 for y, px in enumerate(np.flip(line, axis=0)): pxsum += px if pxsum > 0.: rdy = sy - y break for dy in range(y): if not np.sum(self.__pixeldata.data[:, -dy - 1:]) == 0: rdy = sy - dy break self.__pixeldata = self.__pixeldata[ldx:rdx, ldy:rdy] if not np.sum(self.crop) == 0.: dx, dy = self.crop self.__pixeldata = self.__pixeldata[dx[0]:-dx[1], dy[0]:-dy[1]] self.__pixeldata = self.__pixeldata * self.__gain
def setUp(self): self.data = ma.MaskedArray( [[9, 9, 9], [8, 8, 8]], mask=[[0, 1, 0], [0, 0, 1]], dtype=np.float64, ) self.cube = iris.cube.Cube(self.data)
def test_incompatible_dimensions(self): data3 = ma.MaskedArray( [[3, 3, 3, 4], [2, 2, 2]], mask=[[0, 1, 0, 0], [0, 1, 1]] ) with self.assertRaises(ValueError): # Incompatible dimensions. self.cube + data3
def maskedEqual(array, missingValue): """ Mask an array where equal to a given (missing)value. Unfortunately ma.masked_equal does not work with structured arrays. See: https://mail.scipy.org/pipermail/numpy-discussion/2011-July/057669.html If the data is a structured array the mask is applied for every field (i.e. forming a logical-and). Otherwise ma.masked_equal is called. """ if array_is_structured(array): # Enforce the array to be masked if not isinstance(array, ma.MaskedArray): array = ma.MaskedArray(array) # Set the mask separately per field for nr, field in enumerate(array.dtype.names): if hasattr(missingValue, '__len__'): fieldMissingValue = missingValue[nr] else: fieldMissingValue = missingValue array[field] = ma.masked_equal(array[field], fieldMissingValue) check_class(array, ma.MaskedArray) # post-condition check return array else: # masked_equal works with missing is None result = ma.masked_equal(array, missingValue, copy=False) check_class(result, ma.MaskedArray) # post-condition check return result
def plotGridTrial(sp, varList, iterList, noise_sigma, trialNumList=[0], **kw): '''Plot a parameter sweep of gridness score.''' #kw arguments r = kw.pop('r', 0) c = kw.pop('c', 0) nansAs0 = kw.pop('nansAs0', False) ignoreNaNs = kw.pop('ignoreNaNs', False) sigmaTitle = kw.pop('sigmaTitle', True) cbar = kw.pop('cbar', True) annotations = kw.pop('annotations', None) if isinstance(sp, aggr.AggregateData): G, X, Y = sp.getData() else: G = aggr.aggregate2DTrial(sp, varList, trialNumList, ignoreNaNs=ignoreNaNs) Y, X = aggr.computeYX(sp, iterList, r=r, c=c) nans = np.isnan(G) if (nansAs0): G[nans] = 0 else: G = ma.MaskedArray(G, mask=nans) G, ax, cax = plot2DTrial(X, Y, G, colorBar=cbar, **kw) print(" max(G): {0}".format(np.max(G))) print(" min(G): {0}".format(np.min(G))) if (sigmaTitle): ax.set_title('$\sigma$ = {0} pA'.format(int(noise_sigma))) if (annotations is not None): for a in annotations: plotSweepAnnotation(X=X, Y=Y, ax=ax, **a) return G, ax, cax
def test_add_masked(self, default): data = np.random.rand(5 * 6 * 7, 3) masked = ma.MaskedArray(data, mask=data < .4, fill_value=42.) default.add(masked, 'D') result_masked = str(default) default.add(np.where(masked.mask, masked.fill_value, masked), 'D') assert result_masked == str(default)