def _sanitise_geometry(self, lons, lats): """ Sanitise geometry by removing any masked points. :param lons: :param lats: :return: A tuple containing arrays of (lon, lat) """ # Align the arrays lons, lats = self.__align_lons_lats(lons, lats) # Get masks lon_mask = ma.getmaskarray(lons) lat_mask = ma.getmaskarray(lats) # Filter the arrays # kltsa 19/07/2016 Change for issue 23330: Some filters # were excluded in order to allow values # up to 90 to be included. self.longitudes = lons[ (lons >= -180) & (lons <= 180) & #(lats >= 90) & #(lats <= 90) & (lon_mask == False)# & #(lat_mask == False) ] self.latitudes = lats[ #(lons >= -180) & #(lons <= 180) & (lats >= -90) & (lats <= 90) & #(lon_mask == False) & (lat_mask == False) ]
def _tabulate_time_series(a): """ Private function called by tabulate for flexible-dtype TimeSeries. """ basedtype = a.dtype basenames = basedtype.names if basenames is None: _varshape = a._varshape if _varshape != (): pseudodtype = [('_dates', int), ('_data',(basedtype, _varshape)), ('_mask',(bool,_varshape))] else: pseudodtype = [('_dates', int), ('_data', basedtype), ('_mask', bool)] pseudo = itertools.izip(a._dates, a.filled(), ma.getmaskarray(a),) else: pseudodtype = [('_dates', int)] pseudodtype.extend([(fname,[('_data',ftype), ('_mask',bool)]) for (fname,ftype) in basedtype.descr]) fields = [a[f] for f in basenames] pseudo = itertools.izip(a._dates, *[zip(f.filled().flat, ma.getmaskarray(f).flat) for f in fields]) return np.fromiter(pseudo, dtype=pseudodtype)
def assertArraysEqual(self, arr1, arr2): """ Ensure that two numpy / numpy.ma arrays are equivalent in both their mask and their data. """ if (arr1.shape != arr2.shape): msg = "Shapes differ:\n" + \ str(arr1.shape) + " != " + str(arr2.shape) raise AssertionError(msg) mask1 = ma.getmaskarray(arr1) mask2 = ma.getmaskarray(arr2) masks_equal = np.array_equal(mask1, mask2) if (not masks_equal): msg = "Masks differ:\n" + \ str(mask1) + " != " + str(mask2) + "\n" + \ "Arrays are: \n" + \ str(arr1) + "\n" + \ str(arr2) raise AssertionError(msg) vals_equal = ma.allequal(arr1, arr2) if (not vals_equal): msg = "Values differ:\n" + \ str(arr1) + " != " + str(arr2) raise AssertionError(msg)
def self_training(X, y, X_unLabeled, clf, th): clf.fit(X=X, y=y) index_unlabeled = ma.arange(0, len(X_unLabeled), 1) y_unlabeled = np.zeros(len(X_unLabeled)) train_is_failed = False while True: probs = clf.predict_proba(X=X_unLabeled[~ma.getmaskarray(index_unlabeled)]) index_greater_equal = np.greater_equal([max(d) for d in probs], [th]*len(probs)) index_labelable = index_unlabeled.data[~ma.getmaskarray(index_unlabeled)][index_greater_equal] if not len(index_labelable) > 0: if not len(index_unlabeled.data[ma.getmaskarray(index_unlabeled)]) > 0: train_is_failed = True break index_unlabeled[index_labelable] = ma.masked if index_unlabeled.all() is ma.masked: break y_unlabeled[index_labelable] = [np.argmax(p) for p in probs[index_greater_equal]] X_labelable = X_unLabeled[index_unlabeled.mask] y_labelable = y_unlabeled[index_unlabeled.mask] clf.fit(X=np.append(X, X_labelable, axis=0), y=np.append(y, y_labelable)) if train_is_failed: y_unlabeled = [] else: y_unlabeled = ma.array(data=y_unlabeled, mask=index_unlabeled.mask) return clf, y_unlabeled
def _assertMaskedArray(self, assertion, a, b, strict, **kwargs): # Define helper function to extract unmasked values as a 1d # array. def unmasked_data_as_1d_array(array): array = ma.asarray(array) if array.ndim == 0: if array.mask: data = np.array([]) else: data = np.array([array.data]) else: data = array.data[~ma.getmaskarray(array)] return data # Compare masks. This will also check that the array shapes # match, which is not tested when comparing unmasked values if # strict is False. a_mask, b_mask = ma.getmaskarray(a), ma.getmaskarray(b) np.testing.assert_array_equal(a_mask, b_mask) if strict: assertion(a.data, b.data, **kwargs) else: assertion(unmasked_data_as_1d_array(a), unmasked_data_as_1d_array(b), **kwargs)
def errorbar(ax, x, y, xerr=True, yerr=True, fmt='-', ecolor=None, elinewidth=None, capsize=3, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, **kwargs): """Plots two Dvects against each other. Requires matplotlib. See matplotlib.axes.Axes.errorbar for an explanation of most fields. The only differences are: ax -- the Axes you are plotting in, needed to allow a call of the form ax.errorbar(...) to the standard matplotlib errorbar plotter x -- x Dvect y -- y Dvect Quite often you may want to set fmt=.' to get points. The lines are for compatibility with the matplotlib errorbar routine. """ import warnings try: import matplotlib.pyplot as plt except ImportError: raise DvectError("dvect.errorbar: matplotlib needed for plotting") # Identify joint OK part ok = ~(getmaskarray(x) | getmaskarray(y)) # Catch xerr and yerr which are re-defined cf maplotlib errorbar since # Dvects carry their own errors xerr = x.err.data[ok] if xerr and x.err is not None and isinstance(x,Dvect) else None yerr = y.err.data[ok] if yerr and y.err is not None and isinstance(y,Dvect) else None with warnings.catch_warnings(): warnings.simplefilter("ignore") ax.errorbar(x.data[ok], y.data[ok], xerr=xerr, yerr=yerr, fmt=fmt, ecolor=ecolor, elinewidth=elinewidth, capsize=capsize, barsabove=barsabove, lolims=lolims, uplims=uplims, xlolims=xlolims, xuplims=xuplims, **kwargs)
def __setslice__(self, i, j, value): "Sets the slice described by [i,j] to `value`." _localdict = self.__dict__ d = self._data m = _localdict['_fieldmask'] names = self.dtype.names if value is masked: for n in names: m[i:j][n] = True elif not self._hardmask: fval = filled(value) mval = getmaskarray(value) for n in names: d[n][i:j] = fval m[n][i:j] = mval else: mindx = getmaskarray(self)[i:j] dval = np.asarray(value) valmask = getmask(value) if valmask is nomask: for n in names: mval = mask_or(m[n][i:j], valmask) d[n][i:j][~mval] = value elif valmask.size > 1: for n in names: mval = mask_or(m[n][i:j], valmask) d[n][i:j][~mval] = dval[~mval] m[n][i:j] = mask_or(m[n][i:j], mval) self._fieldmask = m
def _sanitise_geometry(self, lons, lats): """ Sanitise geometry by removing any masked points. :param lons: :param lats: :return: A tuple containing arrays of (lon, lat) """ # Align the arrays lons, lats = self.__align_lons_lats(lons, lats) # Get masks lon_mask = ma.getmaskarray(lons) lat_mask = ma.getmaskarray(lats) # Filter the arrays self.longitudes = lons[ (lons >= -180) & (lons <= 180) & (lats >= -90) & (lats <= 90) & (lon_mask == False) & (lat_mask == False) ] self.latitudes = lats[ (lons >= -180) & (lons <= 180) & (lats >= -90) & (lats <= 90) & (lon_mask == False) & (lat_mask == False) ]
def _assertMaskedArray(self, assertion, a, b, strict): a_mask, b_mask = ma.getmaskarray(a), ma.getmaskarray(b) np.testing.assert_array_equal(a_mask, b_mask) if strict: assertion(a.data, b.data) else: assertion(a[~a_mask].data, b[~b_mask].data)
def _compute_masks_differ(self, var1, var2): if (np.array_equal( ma.getmaskarray(var1), ma.getmaskarray(var2))): return False else: return True
def woa_profile_from_dap(var, d, lat, lon, depth, cfg): """ Monthly Climatologic Mean and Standard Deviation from WOA, used either for temperature or salinity. INPUTS time: [day of the year] lat: [-90<lat<90] lon: [-180<lon<180] depth: [meters] Reads the WOA Monthly Climatology NetCDF file and returns the corresponding WOA values of salinity or temperature mean and standard deviation for the given time, lat, lon, depth. """ if lon < 0: lon = lon+360 url = cfg['url'] doy = int(d.strftime('%j')) dataset = open_url(url) dn = (np.abs(doy-dataset['time'][:])).argmin() xn = (np.abs(lon-dataset['lon'][:])).argmin() yn = (np.abs(lat-dataset['lat'][:])).argmin() if re.match("temperature\d?$", var): mn = ma.masked_values(dataset.t_mn.t_mn[dn, :, yn, xn].reshape( dataset['depth'].shape[0]), dataset.t_mn.attributes['_FillValue']) sd = ma.masked_values(dataset.t_sd.t_sd[dn, :, yn, xn].reshape( dataset['depth'].shape[0]), dataset.t_sd.attributes['_FillValue']) # se = ma.masked_values(dataset.t_se.t_se[dn, :, yn, xn].reshape( # dataset['depth'].shape[0]), dataset.t_se.attributes['_FillValue']) # Use this in the future. A minimum # of samples # dd = ma.masked_values(dataset.t_dd.t_dd[dn, :, yn, xn].reshape( # dataset['depth'].shape[0]), dataset.t_dd.attributes['_FillValue']) elif re.match("salinity\d?$", var): mn = ma.masked_values(dataset.s_mn.s_mn[dn, :, yn, xn].reshape( dataset['depth'].shape[0]), dataset.s_mn.attributes['_FillValue']) sd = ma.masked_values(dataset.s_sd.s_sd[dn, :, yn, xn].reshape( dataset['depth'].shape[0]), dataset.s_sd.attributes['_FillValue']) # dd = ma.masked_values(dataset.s_dd.s_dd[dn, :, yn, xn].reshape( # dataset['depth'].shape[0]), dataset.s_dd.attributes['_FillValue']) zwoa = ma.array(dataset.depth[:]) ind = (depth <= zwoa.max()) & (depth >= zwoa.min()) # Mean value profile f = interp1d(zwoa[~ma.getmaskarray(mn)].compressed(), mn.compressed()) mn_interp = ma.masked_all(depth.shape) mn_interp[ind] = f(depth[ind]) # The stdev profile f = interp1d(zwoa[~ma.getmaskarray(sd)].compressed(), sd.compressed()) sd_interp = ma.masked_all(depth.shape) sd_interp[ind] = f(depth[ind]) output = {'woa_an': mn_interp, 'woa_sd': sd_interp} return output
def test_no_data_available(): """ This is a position without valid data """ db = WOA() out = db['TEMP'].extract(doy=155, lat=48.1953, lon=-69.5855, depth=[2.0, 5.0, 6.0, 21.0, 44.0, 79.0, 5000]) assert sorted(out.keys()) == [u't_dd', u't_mn', u't_sd', u't_se'] for v in out: ma.getmaskarray(out[v]).all()
def test_set_fields(self): # Tests setting fields. base = self.base.copy() mbase = base.view(mrecarray) mbase = mbase.copy() mbase.fill_value = (999999, 1e20, 'N/A') # Change the data, the mask should be conserved mbase.a._data[:] = 5 assert_equal(mbase['a']._data, [5, 5, 5, 5, 5]) assert_equal(mbase['a']._mask, [0, 1, 0, 0, 1]) # Change the elements, and the mask will follow mbase.a = 1 assert_equal(mbase['a']._data, [1]*5) assert_equal(ma.getmaskarray(mbase['a']), [0]*5) # Use to be _mask, now it's recordmask assert_equal(mbase.recordmask, [False]*5) assert_equal(mbase._mask.tolist(), np.array([(0, 0, 0), (0, 1, 1), (0, 0, 0), (0, 0, 0), (0, 1, 1)], dtype=bool)) # Set a field to mask ........................ mbase.c = masked # Use to be mask, and now it's still mask ! assert_equal(mbase.c.mask, [1]*5) assert_equal(mbase.c.recordmask, [1]*5) assert_equal(ma.getmaskarray(mbase['c']), [1]*5) assert_equal(ma.getdata(mbase['c']), [asbytes('N/A')]*5) assert_equal(mbase._mask.tolist(), np.array([(0, 0, 1), (0, 1, 1), (0, 0, 1), (0, 0, 1), (0, 1, 1)], dtype=bool)) # Set fields by slices ....................... mbase = base.view(mrecarray).copy() mbase.a[3:] = 5 assert_equal(mbase.a, [1, 2, 3, 5, 5]) assert_equal(mbase.a._mask, [0, 1, 0, 0, 0]) mbase.b[3:] = masked assert_equal(mbase.b, base['b']) assert_equal(mbase.b._mask, [0, 1, 0, 1, 1]) # Set fields globally.......................... ndtype = [('alpha', '|S1'), ('num', int)] data = ma.array([('a', 1), ('b', 2), ('c', 3)], dtype=ndtype) rdata = data.view(MaskedRecords) val = ma.array([10, 20, 30], mask=[1, 0, 0]) with warnings.catch_warnings(): warnings.simplefilter("ignore") rdata['num'] = val assert_equal(rdata.num, val) assert_equal(rdata.num.mask, [1, 0, 0])
def test_set_mask(self): base = self.base.copy() mbase = base.view(mrecarray) # Set the mask to True ....................... mbase.mask = masked assert_equal(ma.getmaskarray(mbase["b"]), [1] * 5) assert_equal(mbase["a"]._mask, mbase["b"]._mask) assert_equal(mbase["a"]._mask, mbase["c"]._mask) assert_equal(mbase._mask.tolist(), np.array([(1, 1, 1)] * 5, dtype=bool)) # Delete the mask ............................ mbase.mask = nomask assert_equal(ma.getmaskarray(mbase["c"]), [0] * 5) assert_equal(mbase._mask.tolist(), np.array([(0, 0, 0)] * 5, dtype=bool))
def outer (self, a, b): "Return the function applied to the outer product of a and b." a = _makeMaskedArg(a) b = _makeMaskedArg(b) ma = getmask(a) mb = getmask(b) if ma is nomask and mb is nomask: m = None else: ma = getmaskarray(a) mb = getmaskarray(b) m = logical_or.outer(ma, mb) d = numpy.maximum.outer(filled(a), filled(b)) return TransientVariable(d, mask=m)
def computeEdgeDistances(uvframe): """ Create a 2D matrix @edgedists as a companion to @uvframe, containing for each pixel a distance to the nearest edge (more precisely, the nearest 0-valued pixel). We compute @edgedists in a floodfill fashion spreading from zero-areas to the middle of one-areas iteratively, with distances approximated on the pixel grid. We return a tuple (edgedists, edgedirs), where edgedirs contains information about the relative offset of the nearest edge piece. """ # edgedists is a masked array, with only already computed values unmasked; # at first, uvframe == 0 already are computed (as zeros) edgedists = ma.array(numpy.zeros(uvframe.shape, dtype = numpy.float), mask = (uvframe > 0)) edgedirs = ma.array(numpy.zeros(uvframe.shape, dtype = (numpy.float, 2)), mask = [[[j,j] for j in i] for i in uvframe > 0]) #numpy.set_printoptions(threshold=numpy.nan) #print edgedists #print edgedirs flood_spread = scipy.ndimage.morphology.generate_binary_structure(2, 2) neighbor_ofs = [[-1,-1],[-1,0],[-1,1], [0,-1],[0,0],[0,1], [1,-1],[1,0],[1,1]] s2 = math.sqrt(2) neighbor_dist = [s2,1,s2, 1,0,1, s2,1,s2] while ma.getmaskarray(edgedists).any(): # scan masked area for any elements that have unmasked neighbors done_mask = numpy.invert(ma.getmaskarray(edgedists)) todo_mask = done_mask ^ scipy.ndimage.binary_dilation(done_mask, flood_spread) #print_mask(todo_mask) for i in numpy.transpose(numpy.nonzero(todo_mask)): neighbor_val = ma.array([ edge_dist_if_within(edgedists, i + ofs) + dist for ofs, dist in zip(neighbor_ofs, neighbor_dist) ]) nearestnei = ma.argmin(neighbor_val) # We assert that this update never affects value other fields # visited later in this iteration of floodfill edgedists[tuple(i)] = neighbor_val[nearestnei] nearestneicoord = i + neighbor_ofs[nearestnei] #print "-", nearestneicoord, edgedirs[tuple(nearestneicoord)] edgedirs[tuple(i)] = edgedirs[tuple(nearestneicoord)] + tuple(neighbor_ofs[nearestnei]) #print "+", i, edgedirs[tuple(i)] return (edgedists.data, edgedirs.data)
def get_data(self, file_middle): params = self.params cal_weights = params['cal_weights'] pol_weights = params['pol_weights'] n_time = self.n_time window = params['window'] subtract_slope = params['subtract_slope'] input_fname = (params['input_root'] + file_middle + params['input_end']) # Read in the data. Reader = core.fitsGBT.Reader(input_fname) Blocks = Reader.read(params['scans'], params['IFs'], force_tuple=True) # On the first pass, set the channel width. if not hasattr(self, "chan_width"): self.chan_width = Blocks[0].field['CDELT1'] # Loop over the Blocks to select the channel polarizations and cal # state that we want to process. for Data in Blocks: data = Data.data data_selected = ma.zeros((Data.dims[0], 1, 1, Data.dims[3]), dtype=float) data_selected.mask = ma.getmaskarray(data_selected) for ii in range(len(pol_weights)) : for jj in range(len(cal_weights)) : data_selected[:,0,0,:] += (data[:,ii,jj,:] * pol_weights[ii] * cal_weights[jj]) Data.set_data(data_selected) # Convert the data to the proper format and return it. return make_masked_time_stream(Blocks, n_time, window=window, return_means=True, subtract_slope=subtract_slope)
def local_background(image, pos, radx, rady): sum = 0 pixel_count = 0 mask = ma.getmaskarray(image) for x in range (pos[1]-4*radx,pos[1]+4*radx): for y in range(pos[0]-4*rady, pos[0]+4*rady): a = (x-pos[1])/radx b = (y-pos[0])/rady minor = pow(a, 2.0) major = pow(b, 2.0) oval = minor + major if oval >= 1 and oval <=8 and 0<x<2570 and 0<y<4611: if mask[y,x] == False: sum += image[y,x] pixel_count += 1 if pixel_count == 0: pixel_count = 1 bg = sum/pixel_count return bg, pixel_count else: bg = sum/pixel_count return bg, pixel_count
def addfield(mrecord, newfield, newfieldname=None): """Adds a new field to the masked record array, using `newfield` as data and `newfieldname` as name. If `newfieldname` is None, the new field name is set to 'fi', where `i` is the number of existing fields. """ _data = mrecord._data _mask = mrecord._mask if newfieldname is None or newfieldname in reserved_fields: newfieldname = 'f%i' % len(_data.dtype) newfield = ma.array(newfield) # Get the new data ............ # Create a new empty recarray newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)]) newdata = recarray(_data.shape, newdtype) # Add the exisintg field [newdata.setfield(_data.getfield(*f), *f) for f in _data.dtype.fields.values()] # Add the new field newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname]) newdata = newdata.view(MaskedRecords) # Get the new mask ............. # Create a new empty recarray newmdtype = np.dtype([(n, bool_) for n in newdtype.names]) newmask = recarray(_data.shape, newmdtype) # Add the old masks [newmask.setfield(_mask.getfield(*f), *f) for f in _mask.dtype.fields.values()] # Add the mask of the new field newmask.setfield(getmaskarray(newfield), *newmask.dtype.fields[newfieldname]) newdata._mask = newmask return newdata
def test_mask(N=4): l = 5 x = np.arange(N) y = np.arange(N) X, Y = np.meshgrid(x, y) # input ndarray -> output ndarray Z = np.ones(X.shape) h = wmean_2D(X, Y, Z, l=l) assert type(h) is np.ndarray # input MA array -> output MA array Z = ma.array(Z) h = wmean_2D(X, Y, Z, l=l) assert type(h) == ma.MaskedArray # Input MA and mask==False -> Output MA and mask==False assert ~h.mask.any() # Only the masked inputs should return as masked. Z.mask = ma.getmaskarray(Z) Z.mask[0, 0] = True h = wmean_2D(X, Y, Z, l=l) assert h[0, 0].mask == True assert ~h[1:, 1:].mask.any()
def pixel_counts(data, ra_inds, dec_inds, pixel_hits, map_shape=(-1, -1)): """Counts the hits on each unique pixel. Returns pix_list, a list of tuples, each tuple is a (ra,dec) index on a map pixel hit on this scan. The list only contains unique entries. The array pixel_hits (preallowcated for performance), is filled with the number of hits on each of these pixels as a function of frequency index. Only the entries pixel_hits[:len(pix_list), :] are meaningful. """ if ra_inds.shape != dec_inds.shape or ra_inds.ndim != 1: raise ValueError("Ra and Dec arrays not properly shaped.") if pixel_hits.shape[-1] != data.shape[-1] or pixel_hits.shape[0] < len(ra_inds): raise ValueError("counts not allowcated to right shape.") pix_list = [] for ii in range(len(ra_inds)): pix = (ra_inds[ii], dec_inds[ii]) if ( (map_shape[0] > -1 and pix[0] >= map_shape[0]) or (map_shape[1] > -1 and pix[1] >= map_shape[1]) or pix[0] < 0 or pix[1] < 0 ): continue elif not pix in pix_list: pix_list.append(pix) unmasked_freqs = sp.logical_not(ma.getmaskarray(data)[ii, :]) pixel_hits[pix_list.index(pix), unmasked_freqs] += 1 return pix_list
def get_storage_change(len_var,var_names,signs,dirs,storage): for idx in np.arange(0,len_var): data = get_data(dirs[idx]) storage+=data*signs[idx] mask = ma.getmaskarray(data) storage_change = ma.masked_array(storage,mask) return storage_change[0]
def start(self, observation): ''' Handle the first iteration. Keyword Arguments: observation (int) The index of the most recent observation [0:num_states] Returns: next_action (int) The index of the next action to take [0:num_actions] ''' next_state = observation # the valid actions are at unmasked array positions, so compute the inverse # of the mask of the relevant row valid_action_flags = ~ma.getmaskarray(self._q_table[next_state,:]) # get the indices of the valid actions and pick one at random next_action = random.choice(np.flatnonzero(valid_action_flags)) # store off state for the next iteration self._last_state = next_state self._last_action = next_action # increment state visitation table self.update_visitation_table(next_state, next_action) self._epoch_num +=1 return next_action
def test_mask(N=10): l = 5 t = np.arange(N) y = np.ones(N) # Input ndarray -> output ndarray h = maud.wmean_1D(y, t=t, l=l) assert type(h) is np.ndarray h = cmaud.wmean_1D(y, t=t, l=l) assert type(h) is np.ndarray y = ma.array(y) h = maud.wmean_1D(y, t=t, l=l) # Input MA -> output MA assert type(h) == ma.MaskedArray # Input MA and mask==False -> Output MA and mask==False assert ~h.mask.any() h = cmaud.wmean_1D(y, t=t, l=l) assert type(h) == ma.MaskedArray assert ~h.mask.any() y.mask = ma.getmaskarray(y) y.mask[0] = True h = maud.wmean_1D(y, t=t, l=l) # The masked values @ input will be masked @ output assert h[0].mask == True assert ~h[1:].mask.any() h = cmaud.wmean_1D(y, t=t, l=l) assert h[0].mask == True assert ~h[1:].mask.any()
def test_off_map(self) : Data = self.blocks[0] Data.calc_freq() map = self.map map[:,:,:] = 0.0 Data.data[:,:,:,:] = 0.0 # Rig the pointing but put one off the map. def rigged_pointing() : Data.ra = map.get_axis('ra')[range(10)] Data.dec = map.get_axis('dec')[range(10)] Data.ra[3] = Data.ra[3] - 8.0 Data.calc_pointing = rigged_pointing smd.sub_map(Data, map) self.assertTrue(sp.alltrue(ma.getmaskarray(Data.data[3,:,:,:]))) self.assertTrue(sp.alltrue(sp.logical_not( ma.getmaskarray((Data.data[[0,1,2,4,5,6,7,8,9],:,:,:])))))
def wmean_bandpass_1D_serial(data, lshorterpass, llongerpass, t=None, method='hann', axis=0): """ Equivalent to wmean_1D_serial, but it is a bandpass Input: - data: np.array or ma.maked_array, nD - lshorterpass: The size of the highpass filter, i.e. shorter wavelenghts are preserved. It is in the same unit of t. - llongerpass: The size of the lowpass filter, i.e.longer wavelenghts are preserved. It is in the same unit of t. - t: is the scale of the choosed axis, 1D. If not defined, it will be considered a sequence. - method: ['hann', 'hamming', 'blackman'] Defines the weight function type - axis: Dimension which the filter will be applied """ assert False, "There is a BUG here" assert axis <= data.ndim, "Invalid axis!" # If necessary, move the axis to be filtered for the first axis if axis != 0: data_smooth = wmean_bandpass_1D_serial(data.swapaxes(0, axis), lshorterpass = lshorterpass, llongerpass = llongerpass, t = t, method = method, axis = 0) return data_smooth.swapaxes(0, axis) # Below here, the filter will be always applied on axis=0 # If t is not given, creates a regularly spaced t if t is None: print "The scale along the choosed axis weren't defined. I'll consider a constant sequence." t = np.arange(data.shape[axis]) assert t.shape == (data.shape[axis],), "Invalid size of t." # ---- winfunc = window_func(method) data_smooth = ma.masked_all(data.shape) if data.ndim==1: (I,) = np.nonzero(~ma.getmaskarray(data)) for i in I: # First remove the high frequency tmp = _convolve_1D(t[i], t, llongerpass, winfunc, data) # Then remove the low frequency data_smooth[i] = tmp - \ _convolve_1D(t[i], t, lshorterpass, winfunc, tmp) else: I = data.shape[1] for i in range(I): data_smooth[:,i] = wmean_bandpass_1D_serial(data[:,i], lshorterpass, llongerpass, t, method, axis) return data_smooth
def test(self): self.flags = {} try: threshold = self.cfg['threshold'] except: print("Deprecated cfg format. It should contain a threshold item.") threshold = self.cfg try: flag_good = self.cfg['flag_good'] flag_bad = self.cfg['flag_bad'] except: print("Deprecated cfg format. It should contain flag_good & flag_bad.") flag_good = 1 flag_bad = 4 assert (np.size(threshold) == 1) and \ (threshold is not None) and \ (np.isfinite(threshold)) flag = np.zeros(self.data[self.varname].shape, dtype='i1') flag[np.nonzero(self.features['bin_spike'] > threshold)] = flag_bad flag[np.nonzero(self.features['bin_spike'] <= threshold)] = flag_good flag[ma.getmaskarray(self.data[self.varname])] = 9 self.flags['bin_spike'] = flag
def _build_time(self): time = numpy.array([]) mask = numpy.array([], dtype='bool') for d in self.dataset: time = numpy.append(time, d['time'].data) mask = numpy.append(mask, ma.getmaskarray(d['time'])) self.data['time'] = ma.masked_array(time,mask)
def add_data_2_map(data, ra_inds, dec_inds, map, noise_i=None, weight=1): """Add a data masked array to a map. This function also adds the weight to the noise matrix for diagonal noise. """ ntime = len(ra_inds) shape = sp.shape(map) if len(dec_inds) != ntime or len(data[:, 0]) != ntime: raise ValueError("Time axis of data, ra_inds and dec_inds must be" " same length.") if not noise_i is None and map.shape != noise_i.shape: raise ValueError("Inverse noise array must be the same size as the map" " or None.") for time_ind in range(ntime): if ( ra_inds[time_ind] >= 0 and ra_inds[time_ind] < shape[0] and dec_inds[time_ind] >= 0 and dec_inds[time_ind] < shape[1] ): # Get unmasked unmasked_inds = sp.logical_not(ma.getmaskarray(data[time_ind, :])) ind_map = (ra_inds[time_ind], dec_inds[time_ind], unmasked_inds) map[ind_map] += (weight * data)[time_ind, unmasked_inds] if not noise_i is None: if not hasattr(weight, "__iter__"): noise_i[ind_map] += weight else: noise_i[ind_map] += weight[unmasked_inds]
def calculate_theta(self, Xm, p_y_given_x): """Estimate marginal parameters from data and expected latent labels.""" theta = [] for i in range(self.n_visible): not_missing = np.logical_not(ma.getmaskarray(Xm)[:, i]) theta.append(self.estimate_parameters(Xm.data[not_missing, i], p_y_given_x[:, not_missing])) return np.array(theta)
def masked_rec_array_to_mgr(data, index, columns, dtype, copy): """ Extract from a masked rec array and create the manager. """ # essentially process a record array then fill it fill_value = data.fill_value fdata = ma.getdata(data) if index is None: index = get_names_from_index(fdata) if index is None: index = ibase.default_index(len(data)) index = ensure_index(index) if columns is not None: columns = ensure_index(columns) arrays, arr_columns = to_arrays(fdata, columns) # fill if needed new_arrays = [] for fv, arr, col in zip(fill_value, arrays, arr_columns): mask = ma.getmaskarray(data[col]) if mask.any(): arr, fv = maybe_upcast(arr, fill_value=fv, copy=True) arr[mask] = fv new_arrays.append(arr) # create the manager arrays, arr_columns = reorder_arrays(new_arrays, arr_columns, columns) if columns is None: columns = arr_columns mgr = arrays_to_mgr(arrays, arr_columns, index, columns, dtype) if copy: mgr = mgr.copy() return mgr
def get_xy_values(self, order="C", asmasked=False): """Get X Y coordinate values as numpy 2D arrays.""" nno = self.ncol * self.nrow ier, xvals, yvals = _cxtgeo.surf_xy_as_values( self.xori, self.xinc, self.yori, self.yinc * self.yflip, self.ncol, self.nrow, self.rotation, nno, nno, 0, ) if ier != 0: raise XTGeoCLibError(f"Error in surf_xy_as_values, error code: {ier}") # reshape xvals = xvals.reshape((self.ncol, self.nrow)) yvals = yvals.reshape((self.ncol, self.nrow)) if order == "F": xvals = np.array(xvals, order="F") yvals = np.array(yvals, order="F") if asmasked: tmpv = ma.filled(self.values, fill_value=np.nan) tmpv = np.array(tmpv, order=order) tmpv = ma.masked_invalid(tmpv) mymask = ma.getmaskarray(tmpv) xvals = ma.array(xvals, mask=mymask, order=order) yvals = ma.array(yvals, mask=mymask, order=order) return xvals, yvals
def calculate_mis(self, p_y_given_x, theta, Xm): mis = np.zeros((self.n_hidden, self.n_visible)) sample = np.random.choice(np.arange(Xm.shape[0]), min(self.max_samples, Xm.shape[0]), replace=False) n_observed = np.sum(np.logical_not(ma.getmaskarray(Xm[sample])), axis=0) n_samples, n_visible = Xm.shape memory_size = float(n_samples * n_visible * self.n_hidden * self.dim_hidden * 64) / 1000**3 # GB batch_size = np.clip(int(self.ram * n_visible / memory_size), 1, n_visible) for i in range(0, n_visible, batch_size): log_marg_x = self.calculate_marginals_on_samples( theta[i:i + batch_size, ...], Xm[sample, i:i + batch_size]) # n_hidden, n_samples, n_visible, dim_hidden mis[:, i:i + batch_size] = np.einsum( 'ijl,ijkl->ik', p_y_given_x[:, sample, :], log_marg_x, optimize=False) / n_observed[i:i + batch_size][np.newaxis, :] return mis # MI in nats
def addfield(mrecord, newfield, newfieldname=None): """Adds a new field to the masked record array, using `newfield` as data and `newfieldname` as name. If `newfieldname` is None, the new field name is set to 'fi', where `i` is the number of existing fields. """ _data = mrecord._data _mask = mrecord._mask if newfieldname is None or newfieldname in reserved_fields: newfieldname = 'f%i' % len(_data.dtype) newfield = ma.array(newfield) # Get the new data ............ # Create a new empty recarray newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)]) newdata = recarray(_data.shape, newdtype) # Add the exisintg field [ newdata.setfield(_data.getfield(*f), *f) for f in _data.dtype.fields.values() ] # Add the new field newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname]) newdata = newdata.view(MaskedRecords) # Get the new mask ............. # Create a new empty recarray newmdtype = np.dtype([(n, bool_) for n in newdtype.names]) newmask = recarray(_data.shape, newmdtype) # Add the old masks [ newmask.setfield(_mask.getfield(*f), *f) for f in _mask.dtype.fields.values() ] # Add the mask of the new field newmask.setfield(getmaskarray(newfield), *newmask.dtype.fields[newfieldname]) newdata._mask = newmask return newdata
def obtain_overlap(in_files_lis, out_file, variable): fh_out = Dataset(out_file, "w") ma_lis = [] for f_index, in_file in enumerate(in_files_lis): fh_in = Dataset(in_file, "r") ma_lis.append(ma.getmaskarray(fh_in.variables[variable][:])) if f_index == len(in_files_lis) - 1: for name, dim in fh_in.dimensions.items(): fh_out.createDimension(name, len(dim)) overlap_mask = np.logical_or.reduce(ma_lis) for v_name, varin in fh_in.variables.items(): if v_name == 'lat' or v_name == 'lon': outVar = fh_out.createVariable(v_name, varin.datatype, varin.dimensions) outVar.setncatts({k: varin.getncattr(k) for k in varin.ncattrs()}) outVar[:] = varin[:] else: outVar = fh_out.createVariable(v_name, varin.datatype, varin.dimensions) outVar.setncatts({k: varin.getncattr(k) for k in varin.ncattrs()}) outVar[:] = ma.array(varin[:], mask=overlap_mask) fh_in.close() fh_out.close()
def getImage(self, index): sub_path = self.getPath(index) path = '{0}/data/{1}-color.png'.format(self.dataset_root, sub_path) image = np.array(Image.open(path)) if (self.IMAGE_CONTAINS_MASK): mask = image[:, :, 3:] image = image[:, :, :3] if (index >= self.len_real and index < self.len_grid): if (self.add_syn_background): label = np.expand_dims( np.array( Image.open('{0}/data/{1}-label.png'.format( self.dataset_root, sub_path))), 2) mask_back = ma.getmaskarray(ma.masked_equal(label, 0)) back_filename = random.choice(self.background) back = np.array(Image.open(back_filename).convert("RGB")) image = back * mask_back + image if (self.add_syn_noise): image = image + np.random.normal( loc=0.0, scale=7.0, size=image.shape) image = image.astype(np.uint8) if (self.IMAGE_CONTAINS_MASK): image = np.concatenate([image, mask], 2) return image
def broadcast(*args): def _mask_or(a, b): return ma.mask_or(a, b, shrink=True) args = [_safe_masked_invalid(arg) for arg in args] if any([ma.isMA(arg) for arg in args]): vars = [ma.getdata(var) for var in args] mvars = [ma.getmaskarray(var) for var in args] outargs = list(map(np.array, np.broadcast_arrays(*vars))) masks = list(map(np.array, np.broadcast_arrays(*mvars))) mask = reduce(_mask_or, masks) else: mask = ma.nomask # Using map(np.array, ...) to get contiguous copies. outargs = list(map(np.array, np.broadcast_arrays(*args))) if outargs[0].ndim == 0: scalar = True for arg in outargs: arg.shape = (1, ) if mask is not ma.nomask: mask.shape = (1, ) else: scalar = False return scalar, mask, outargs
def _acf(x, mode): """Computes the auto-correlation function of the time series x. Note that the computations are performed on anomalies (deviations from average). Gaps in the series are filled first, the anomalies are then computed and the missing values filled with 0. :Parameters: `x` : TimeSeries Time series. """ x = ma.array(x, copy=False, subok=True, dtype=float) if x.ndim > 1: raise ValueError("The input array should be 1D only.") # make sure there's no gap in the data if isinstance(x, TimeSeries) and x.has_missing_dates(): x = ts.fill_missing_dates(x) # m = np.logical_not(ma.getmaskarray(x)).astype(int) x = x.anom().filled(0).view(ndarray) xx = (x*x) n = len(x) # _avf = np.correlate(x,x,'full')[n-1:] if mode: dnm_ = np.fromiter((np.sum(x[k:]*x[:-k])/np.sum(m[k:]*xx[:-k]) for k in range(1,n)), dtype=float) else: dnm_ = np.fromiter((np.sum(x[k:]*x[:-k])/\ np.sqrt((m[k:]*xx[:-k]).sum() * (m[:-k]*xx[k:]).sum()) for k in range(1,n)), dtype=float) poslags = _avf[1:]/dnm_ return ma.fix_invalid(np.concatenate([np.array([1.]), poslags, poslags[::-1]]))
def global_range(data, v, cfg): """ """ assert cfg['minval'] < cfg['maxval'], \ "Global Range(%s), minval (%s) must be smaller than maxval(%s)" \ % (v, cfg['minval'], cfg['maxval']) # Default flag 0, no QC. flag = np.zeros(data[v].shape, dtype='i1') # Flag good inside acceptable range ind = (data[v] >= cfg['minval']) & \ (data[v] <= cfg['maxval']) flag[np.nonzero(ind)] = 1 # Flag bad outside acceptable range ind = (data[v] < cfg['minval']) | \ (data[v] > cfg['maxval']) flag[np.nonzero(ind)] = 4 # Flag as 9 any masked input value flag[ma.getmaskarray(data[v])] = 9 return flag
def test(self): """ I slightly modified the Goring & Nikora 2002. It is expected that CTD profiles has a typical depth structure, with a range between surface and bottom. """ self.flags = {} try: threshold = self.cfg["threshold"] except KeyError: print("Deprecated cfg format. It should contain a threshold item.") threshold = self.cfg["k"] assert ((np.size(threshold) == 1) and (threshold is not None) and (np.isfinite(threshold))) flag = np.zeros(self.data[self.varname].shape, dtype="i1") flag[np.nonzero( self.features["tukey53H_norm"] > threshold)] = self.flag_bad flag[np.nonzero( self.features["tukey53H_norm"] <= threshold)] = self.flag_good flag[ma.getmaskarray(self.data[self.varname])] = 9 self.flags["tukey53H_norm"] = flag
def human_calibrate_mistakes(datadir, varname, cfg=None, niter=5): """ """ import pandas as pd db = ProfilesQCPandasCollection(datadir, cfg=cfg, saveauxiliary=True) assert varname in db.keys() data = db.data features = db.auxiliary[varname] flags = combined_flag(db.flags[varname]) binflags = flags2bin(np.array(flags)) result = calibrate4flags(db.flags[varname], features, q=0.90, verbose=False) #profileslist = aux['profileid'].iloc[mistake].iloc[ # np.absolute(prob[mistake] - p_optimal).argsort() # ].unique() error_log = [{ 'err': result['n_err'], 'err_ratio': result['err_ratio'], 'p_optimal': result['p_optimal'] }] human_flag = ma.masked_all(len(flags), dtype='object') for i in range(niter): # Failures from AD to reproduce flags mistake = (result['false_positive'] | result['false_negative']) # Only the ones that weren't already flagged by a human mistake = mistake & ma.getmaskarray(human_flag) profileids = np.unique(data['profileid'].iloc[mistake]) # In the future order by how badly AD mistaked #profileids = data['profileid'].iloc[mistake].iloc[ # np.absolute(prob[mistake] - p_optimal).argsort() # ].unique() #derr = np.absolute(prob[np.nonzero(mistake)] - p_optimal) #ind_toeval = np.nonzero(mistake & ~doubt) #profileids = data['profileid'].iloc[ind_toeval].iloc[derr.argsort() # ].unique() if len(profileids) == 0: break # 5 random profiles with mistakes for pid in np.random.permutation(profileids)[:5]: print("Profile: %s" % pid) ind_p = data.profileid == pid h = HumanQC().eval(data[varname][ind_p], data['PRES'][ind_p], baseflag=binflags[np.array(ind_p)], fails=mistake[np.array(ind_p)], humanflag=human_flag[np.array(ind_p)]) #ind_humanqc[np.nonzero(ind_p)[0][h == 'good']] = True #flags.loc[np.nonzero(ind_p)[0][h == 'good'], 'human'] = 1 #ind_humanqc[np.nonzero(ind_p)[0][h == 'bad']] = False #flags.loc[np.nonzero(ind_p)[0][h == 'bad'], 'human'] = 4 #flags.loc[np.nonzero(ind_p)[0][h == 'doubt'], 'human'] = 6 #doubt[np.nonzero(ind_p)[0][h == 'doubt']] = True #ind_humanqc.mask[np.nonzero(ind_p)[0][h == 'doubt']] = True # Update human_flag only at the new values human_flag[np.nonzero(ind_p)[0][~h.mask]] = h[~h.mask] flags[human_flag == 'good'] = 1 flags[human_flag == 'bad'] = 4 #flags[human_flag == 'doubt'] = 1 #doubt[human_flag == 'doubt'] = True # Update binflags binflags = flags2bin(flags) result = calibrate4flags(flags, features, q=0.90, verbose=False) error_log.append({ 'err': result['n_err'], 'err_ratio': result['err_ratio'], 'p_optimal': result['p_optimal'], 'tot_misfit': result['tot_misfit'] }) print error_log[-2] print error_log[-1] result['human_flag'] = human_flag result['ind_humanqc'] = binflags result['error_log'] = error_log #return {'ind_humanqc': binflags, 'error_log': error_log, # 'result': result} return result
def plot_surface( self, surf, minvalue=None, maxvalue=None, contourlevels=None, xlabelrotation=None, colormap=None, logarithmic=False, ): # pylint: disable=too-many-statements """Input a surface and plot it.""" # need a deep copy to avoid changes in the original surf logger.info("The key contourlevels %s is not in use", contourlevels) usesurf = surf.copy() if usesurf.yflip < 0: usesurf.swapaxes() if abs(surf.rotation) > 0.001: usesurf.unrotate() xi, yi, zi = usesurf.get_xyz_values() zimask = ma.getmaskarray(zi).copy() # yes need a copy! legendticks = None if minvalue is not None and maxvalue is not None: minv = float(minvalue) maxv = float(maxvalue) step = (maxv - minv) / 10.0 legendticks = [] for i in range(10 + 1): llabel = float("{0:9.4f}".format(minv + step * i)) legendticks.append(llabel) zi.unshare_mask() zi[zi < minv] = minv zi[zi > maxv] = maxv # need to restore the mask: zi.mask = zimask # note use surf.min, not usesurf.min here ... notetxt = ("Note: map values are truncated from [" + str(surf.values.min()) + ", " + str(surf.values.max()) + "] " + "to interval [" + str(minvalue) + ", " + str(maxvalue) + "]") self._fig.text(0.99, 0.02, notetxt, ha="right", va="center", fontsize=8) logger.info("Legendticks: %s", legendticks) if minvalue is None: minvalue = usesurf.values.min() if maxvalue is None: maxvalue = usesurf.values.max() # this will override current instance colormap locally, and is # therefore reset afterwards keepcolor = self.colormap if colormap is not None: self.colormap = colormap levels = np.linspace(minvalue, maxvalue, self.contourlevels) logger.debug("Number of contour levels: %s", levels) plt.setp(self._ax.xaxis.get_majorticklabels(), rotation=xlabelrotation) # zi = ma.masked_where(zimask, zi) # zi = ma.masked_greater(zi, xtgeo.UNDEF_LIMIT) logger.info("Current colormap is %s, requested is %s", self.colormap, colormap) logger.info("Current colormap name is %s", self.colormap.name) if ma.std(zi) > 1e-07: uselevels = levels else: uselevels = 1 try: if logarithmic is False: locator = None ticks = legendticks im = self._ax.contourf(xi, yi, zi, uselevels, locator=locator, cmap=self.colormap) else: logger.info("use LogLocator") locator = ticker.LogLocator() ticks = None uselevels = None im = self._ax.contourf(xi, yi, zi, locator=locator, cmap=self.colormap) self._fig.colorbar(im, ticks=ticks) except ValueError as err: logger.warning("Could not make plot: %s", err) plt.gca().set_aspect("equal", adjustable="box") self.colormap = keepcolor
def calibrate4flags(flags, features, q=0.90, verbose=False): """ Adjust coeficients for Anomaly Detection to best reproduce given flags Inputs: flag_ref: Reference index. What the Anomaly Detection will try to reproduce. Uses the True and Falses from flag_ref to partition the data to be used to fit, to adjust and to estimate the error. qctests: The tests used by the Anomaly Detection. One curve will be fit for each test. aux: The auxiliary tests results from the ProfileQCCollection. It is expected that the qctests are present in aux. q: The top q extreme tests results to be used on Anom. Detect. For example q=0 will use all the data, while q=0.9 (default) will use the percentile of 0.9, i.e. the top 10% values. Output: Returns a dictionary with err: err_ratio: false_negative: false_positive: p_optimal: params: Use the functions: split_data_groups() fit_tests() estimate_anomaly() estimate_p_optimal() """ if hasattr(flags, 'keys'): flags = combined_flag(flags) assert not hasattr(flags, 'keys') assert hasattr(features, 'keys') assert len(features[features.keys()[0]]) == len(flags) indices = split_data_groups(flags) params = fit_tests(features[indices['fit']], q=q) prob = estimate_anomaly(features, params) if verbose is True: pylab.hist(prob) pylab.show() binflags = flags2bin(flags) p_optimal, test_err = estimate_p_optimal(prob[indices['test']], binflags[indices['test']]) # Guarantee the the false_* indices will be np.array false_negative = (prob < p_optimal) & binflags false_negative[ma.getmaskarray(false_negative)] = False false_negative = np.array(false_negative) false_positive = (prob > p_optimal) & ~binflags false_positive[ma.getmaskarray(false_positive)] = False false_positive = np.array(false_positive) mistake = false_positive | false_negative # I can extract only .data, since split_data_groups already eliminated # all non valid positions. #err = np.nonzero(false_negative)[0].size + \ # np.nonzero(false_positive)[0].size tot_misfit = np.nonzero(mistake)[0].size n_err = float(np.nonzero(mistake[indices['err']])[0].shape[0]) #err_ratio = float(err)/prob[indices['ind_err']].size err_ratio = n_err / indices['err'].astype('i').sum() #false_negative = (prob < p_optimal) & \ # (flag_ref.data is True) & (ma.getmaskarray(flag_ref) is False) #false_positive = (prob > p_optimal) & \ # (flag_ref.data is False) & (ma.getmaskarray(flag_ref) is False) output = { 'false_negative': false_negative, 'false_positive': false_positive, 'prob': prob, 'p_optimal': p_optimal, 'tot_misfit': tot_misfit, 'n_err': n_err, 'err_ratio': err_ratio, 'params': params } return output
def DenseFusion(self, img, depth, posecnn_res): my_result_wo_refine = [] itemid = 1 # this is simplified for single label decttion, if multi-label used, check DFYW3.py for more depth = np.array(depth) # img = img seg_res = posecnn_res x1, y1, x2, y2 = seg_res["box"] banana_bbox_draw = self.posecnn.get_box_rcwh(seg_res["box"]) rmin, rmax, cmin, cmax = int(y1), int(y2), int(x1), int(x2) try: depth = depth[:, :, 1] # because depth has 3 dimensions RGB but they are the all the same with each other except: # depth=depth pass depth = np.nan_to_num(depth) #DIY mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0)) # ok mask_depth_nonzeros = mask_depth[:].nonzero() label_banana = np.squeeze(seg_res["mask"]) label_banana = ma.getmaskarray(ma.masked_greater(label_banana, 0.5)) label_banana_nonzeros = label_banana.flatten().nonzero() mask_label = ma.getmaskarray(ma.masked_equal( label_banana, itemid)) # label from banana label mask_label_nonzeros = mask_label[:].nonzero() mask = mask_label * mask_depth mask_nonzeros = mask[:].flatten().nonzero() mask_target = mask[rmin:rmax, cmin:cmax] choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] res_len_choose = len(choose) if len(choose) > self.num_points: c_mask = np.zeros(len(choose), dtype=int) c_mask[:self.num_points] = 1 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()] else: # print("(?)len of choose is 0, check error") print("Info, DenseFusion: len(choose)=", len(choose)) # return "ERROR, img broken (?)" # choose = np.pad(choose, (0, self.num_points - len(choose)), 'wrap') return None depth_masked = depth[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype( np.float32) xmap_masked = self.xmap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) ymap_masked = self.ymap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) choose = np.array([choose]) pt2 = depth_masked / self.cam_scale pt0 = (ymap_masked - self.cam_cx) * pt2 / self.cam_fx pt1 = (xmap_masked - self.cam_cy) * pt2 / self.cam_fy cloud = np.concatenate((pt0, pt1, pt2), axis=1) img_masked = np.array(img)[:, :, :3] img_masked = np.transpose(img_masked, (2, 0, 1)) img_masked = img_masked[:, rmin:rmax, cmin:cmax] cloud = torch.from_numpy(cloud.astype(np.float32)) choose = torch.LongTensor(choose.astype(np.int32)) img_masked = self.norm(torch.from_numpy(img_masked.astype(np.float32))) index = torch.LongTensor([itemid - 1]) cloud = Variable(cloud).cuda() choose = Variable(choose).cuda() img_masked = Variable(img_masked).cuda() index = Variable(index).cuda() cloud = cloud.view(1, self.num_points, 3) img_masked = img_masked.view(1, 3, img_masked.size()[1], img_masked.size()[2]) pred_r, pred_t, pred_c, emb = self.estimator(img_masked, cloud, choose, index) pred_r = pred_r / torch.norm(pred_r, dim=2).view(1, self.num_points, 1) pred_c = pred_c.view(self.bs, self.num_points) how_max, which_max = torch.max(pred_c, 1) pred_t = pred_t.view(self.bs * self.num_points, 1, 3) points = cloud.view(self.bs * self.num_points, 1, 3) my_r = pred_r[0][which_max[0]].view(-1).cpu().data.numpy() my_t = (points + pred_t)[which_max[0]].view(-1).cpu().data.numpy() my_pred = np.append(my_r, my_t) my_result_wo_refine.append(my_pred.tolist()) my_result = [] for ite in range(0, self.iteration): T = Variable(torch.from_numpy( my_t.astype(np.float32))).cuda().view(1, 3).repeat( self.num_points, 1).contiguous().view(1, self.num_points, 3) my_mat = quaternion_matrix(my_r) R = Variable(torch.from_numpy(my_mat[:3, :3].astype( np.float32))).cuda().view(1, 3, 3) my_mat[0:3, 3] = my_t new_cloud = torch.bmm((cloud - T), R).contiguous() pred_r, pred_t = self.refiner(new_cloud, emb, index) pred_r = pred_r.view(1, 1, -1) pred_r = pred_r / (torch.norm(pred_r, dim=2).view(1, 1, 1)) my_r_2 = pred_r.view(-1).cpu().data.numpy() my_t_2 = pred_t.view(-1).cpu().data.numpy() my_mat_2 = quaternion_matrix(my_r_2) my_mat_2[0:3, 3] = my_t_2 my_mat_final = np.dot(my_mat, my_mat_2) my_r_final = copy.deepcopy(my_mat_final) my_r_final[0:3, 3] = 0 my_r_final = quaternion_from_matrix(my_r_final, True) my_t_final = np.array( [my_mat_final[0][3], my_mat_final[1][3], my_mat_final[2][3]]) my_pred = np.append(my_r_final, my_t_final) my_result.append(my_pred.tolist()) my_result_np = np.array(my_result) my_result_mean = np.mean(my_result, axis=0) my_r = my_result_mean[:4] my_t = my_result_mean[4:] my_r_quaternion = my_r return my_r_quaternion, my_t
def filter_cal_scale(Data, size, filter_type='rectangular', filter_size_units='bins'): """Estimates Achromatic gain fluctuations and scales by them. """ on_ind = 0 off_ind = 1 n_time = Data.data.shape[0] if (Data.field['CAL'][on_ind] != 'T' or Data.field['CAL'][off_ind] != 'F'): raise ce.DataError('Cal states not in expected order.') if tuple(Data.field['CRVAL4']) == (-5, -7, -8, -6): # Here we check the polarizations and cal indicies xx_ind = 0 yy_ind = 3 xy_inds = [1, 2] diff_xx = Data.data[:, xx_ind, on_ind, :] - Data.data[:, xx_ind, off_ind, :] diff_yy = Data.data[:, yy_ind, on_ind, :] - Data.data[:, yy_ind, off_ind, :] cal_xx = ma.mean(diff_xx, -1) cal_yy = ma.mean(diff_yy, -1) mask = ma.getmaskarray(Data.data) #mask = sp.any(sp.any(mask, 1), 1) # XXX Wrong, Just needs to be factorizable. Need to devellop and # algorithem for ensuring this, but for now, just use this. This # shouldn't be too bad for the current RFI flagging algorithm (Apr # 2012). time_mask = sp.any(sp.any(sp.any(mask, 1), 1), 1) # Sanity check the masks. if not (sp.all(time_mask[ma.getmaskarray(cal_xx)]) and sp.all(time_mask[ma.getmaskarray(cal_yy)])): msg = "Doesn't make since, this should always be true." raise RuntimeError(msg) # Convert to normal arrays. cal_xx = cal_xx.filled(0) cal_yy = cal_yy.filled(0) # XXX #Data.calc_time() #time_unmask = sp.logical_not(time_mask) #plt.plot(Data.time[time_unmask], cal_xx[time_unmask]) # Now set up the filter. if filter_type == 'rectangular': if filter_size_units == 'bins': n_bins_filter = int(size) if n_bins_filter % 2 == 0: raise ValueError("Rectangular filter should have an odd" "number of bins.") elif filter_size_units == 'seconds': Data.calc_time() dt = abs(sp.mean(sp.diff(Data.time))) n_bins_filter = size / dt # Round to the nearest odd number. n_bins_filter = 2 * int(round(n_bins_filter / 2. - 0.5)) + 1 else: msg = 'Filter unit type unsupported.' raise ValueError(msg) kernal = sp.ones(n_bins_filter) / n_bins_filter else: msg = 'Filter type unsupported.' raise ValueError(msg) # Now that we know the kernal size, figure out what elements will # be newly masked by the smoothing. half_width = n_bins_filter // 2 old_mask = time_mask.copy() for ii in range(n_time): if old_mask[ii]: time_mask[ii - half_width:ii + half_width + 1] = True # Also mask the edges. time_mask[:half_width] = True time_mask[-half_width:] = True # Now acctually do the convolution. cal_xx = signal.convolve(cal_xx, kernal, mode='same') cal_yy = signal.convolve(cal_yy, kernal, mode='same') # XXX #Data.calc_time() #time_unmask = sp.logical_not(time_mask) #plt.plot(Data.time[time_unmask], cal_xx[time_unmask]) #plt.plot(Data.time, time_mask) plt.show() # Replace invalid entries with unity (They get masked later anyway). cal_xx[time_mask] = 1. cal_yy[time_mask] = 1. # Calibrate and apply mask. Data.data[:, xx_ind, :, :] /= cal_xx[:, None, None] Data.data[:, yy_ind, :, :] /= cal_yy[:, None, None] cross_cal = sp.sqrt(cal_xx * cal_yy) Data.data[:, xy_inds, :, :] /= cross_cal[:, None, None, None] # Apply the mask. Data.data[time_mask, ...] = ma.masked #elif tuple(Data.field['CRVAL4']) == (1, 2, 3, 4) : else: raise ce.DataError("Unsupported polarization states.")
def set_features(self): try: doy = int(self.data.attrs['date'].strftime('%j')) except: doy = int(self.data.attrs['datetime'].strftime('%j')) if ('LATITUDE' in self.data.attrs.keys()) and \ ('LONGITUDE' in self.data.attrs.keys()): mode = 'profile' kwargs = { 'lat': self.data.attrs['LATITUDE'], 'lon': self.data.attrs['LONGITUDE']} if ('LATITUDE' in self.data.keys()) and \ ('LONGITUDE' in self.data.keys()): mode = 'track' dLmax = max( self.data['LATITUDE'].max() - self.data['LATITUDE'].min(), self.data['LONGITUDE'].max() - self.data['LONGITUDE'].min()) # Only use each measurement coordinate if it is spread. if dLmax >= 0.01: kwargs = { 'lat': self.data['LATITUDE'], 'lon': self.data['LONGITUDE']} if ('DEPTH' in self.data.keys()): depth = self.data['DEPTH'] elif ('PRES' in self.data.keys()): depth = self.data['PRES'] db = WOA() if self.varname[-1] == '2': vtype = self.varname[:-1] else: vtype = self.varname idx = ~ma.getmaskarray(depth) & np.array(depth >= 0) if mode == 'track': woa = db[vtype].track( var=['mean', 'standard_deviation', 'standard_error', 'number_of_observations'], doy=doy, depth=depth[idx], **kwargs) else: woa = db[vtype].extract( var=['mean', 'standard_deviation', 'standard_error', 'number_of_observations'], doy=doy, depth=depth[idx], **kwargs) if idx.all() is not True: for v in woa.keys(): tmp = ma.masked_all(depth.shape, dtype=woa[v].dtype) tmp[idx] = woa[v] woa[v] = tmp self.features = { 'woa_mean': woa['mean'], 'woa_std': woa['standard_deviation'], 'woa_nsamples': woa['number_of_observations'], 'woa_se': woa['standard_error']} self.features['woa_bias'] = self.data[self.varname] - \ self.features['woa_mean'] # if use_standard_error = True, the comparison with the climatology # considers the standard error, i.e. the bias will be only the # ammount above the standard error range. if self.cfg['use_standard_error'] is True: standard_error = self.features['woa_std'] / \ self.features['woa_nsamples'] ** 0.5 idx = np.absolute(self.features['woa_bias']) <= \ standard_error self.features['woa_bias'][idx] = 0 idx = np.absolute(self.features['woa_bias']) > standard_error self.features['woa_bias'][idx] -= \ np.sign(self.features['woa_bias'][idx]) * \ standard_error[idx] self.features['woa_normbias'] = self.features['woa_bias'] / \ self.features['woa_std']
def callback(self, rgb, depth): if DEBUG: print('received depth image of type: ' + depth.encoding) print('received rgb image of type: ' + rgb.encoding) #https://answers.ros.org/question/64318/how-do-i-convert-an-ros-image-into-a-numpy-array/ depth = np.frombuffer(depth.data, dtype=np.uint16).reshape(depth.height, depth.width, -1) rgb = np.frombuffer(rgb.data, dtype=np.uint8).reshape(rgb.height, rgb.width, -1) rgb_original = rgb #cv2.imshow('depth', depth) #time1 = time.time() rgb = np.transpose(rgb, (2, 0, 1)) rgb = norm(torch.from_numpy(rgb.astype(np.float32))) rgb = Variable(rgb).cuda() semantic = self.model(rgb.unsqueeze(0)) _, pred = torch.max(semantic, dim=1) pred = pred * 255 pred = np.transpose(pred, (1, 2, 0)) # (CxHxW)->(HxWxC) #print(pred.shape) #ret, threshold = cv2.threshold(pred.cpu().numpy(), 1, 255, cv2.THRESH_BINARY) #pred is already binary, therefore, this line is unnecessary contours, hierarchy = cv2.findContours(np.uint8(pred), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnt = max(contours, key=cv2.contourArea) x, y, w, h = cv2.boundingRect(cnt) rmin, rmax, cmin, cmax = get_bbox([x, y, w, h]) #cv2.rectangle(rgb_original,(cmin,rmin), (cmax,rmax) , (0,255,0),2) #cv2.imwrite('depth.png', depth) #save depth image mask_depth = ma.getmasksarray(ma.masked_not_equal(depth, 0)) mask_label = ma.getmaskarray(ma.masked_equal(pred, np.array(255))) mask = mask_depth * mask_label #print(rgb.shape) #torch.Size([3, 480, 640]) #print(rgb_original.shape) #(480, 640, 3) img = np.transpose(rgb_original, (2, 0, 1)) img_masked = img[:, rmin:rmax, cmin:cmax] choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] #print("length of choose is :{0}".format(len(choose))) if len(choose) == 0: cc = torch.LongTensor([0]) return (cc, cc, cc, cc, cc, cc) if len(choose) > num_points: c_mask = np.zeros(len(choose), dtype=int) c_mask[: num_points] = 1 # if number of object pixels are bigger than 500, we select just 500 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()] # now len(choose) = 500 else: choose = np.pad(choose, (0, num_points - len(choose)), 'wrap') depth_masked = depth[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype( np.float32) xmap_masked = self.xmap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) ymap_masked = self.ymap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) choose = np.array([choose]) pt2 = depth_masked #print(pt2) pt0 = (ymap_masked - self.cam_cx) * pt2 / self.cam_fx pt1 = (xmap_masked - self.cam_cy) * pt2 / self.cam_fy cloud = np.concatenate((pt0, pt1, pt2), axis=1) cloud = cloud / 1000 points = torch.from_numpy(cloud.astype(np.float32)) choose = torch.LongTensor(choose.astype(np.int32)) img = norm(torch.from_numpy(img_masked.astype(np.float32))) idx = torch.LongTensor([self.object_index]) img = Variable(img).cuda().unsqueeze(0) points = Variable(points).cuda().unsqueeze(0) choose = Variable(choose).cuda().unsqueeze(0) idx = Variable(idx).cuda().unsqueeze(0) pred_r, pred_t, pred_c, emb = self.estimator(img, points, choose, idx) pred_r = pred_r / torch.norm(pred_r, dim=2).view(1, num_points, 1) pred_c = pred_c.view(bs, num_points) how_max, which_max = torch.max(pred_c, 1) pred_t = pred_t.view(bs * num_points, 1, 3) my_r = pred_r[0][which_max[0]].view(-1).cpu().data.numpy() my_t = (points.view(bs * num_points, 1, 3) + pred_t)[which_max[0]].view(-1).cpu().data.numpy() my_pred = np.append(my_r, my_t) for ite in range(0, iteration): T = Variable(torch.from_numpy( my_t.astype(np.float32))).cuda().view(1, 3).repeat( num_points, 1).contiguous().view(1, num_points, 3) my_mat = quaternion_matrix(my_r) R = Variable(torch.from_numpy(my_mat[:3, :3].astype( np.float32))).cuda().view(1, 3, 3) my_mat[0:3, 3] = my_t new_points = torch.bmm((points - T), R).contiguous() pred_r, pred_t = self.refiner(new_points, emb, idx) pred_r = pred_r.view(1, 1, -1) pred_r = pred_r / (torch.norm(pred_r, dim=2).view(1, 1, 1)) my_r_2 = pred_r.view(-1).cpu().data.numpy() my_t_2 = pred_t.view(-1).cpu().data.numpy() my_mat_2 = quaternion_matrix(my_r_2) my_mat_2[0:3, 3] = my_t_2 my_mat_final = np.dot( my_mat, my_mat_2) # refine pose means two matrix multiplication my_r_final = copy.deepcopy(my_mat_final) my_r_final[0:3, 3] = 0 my_r_final = quaternion_from_matrix(my_r_final, True) my_t_final = np.array( [my_mat_final[0][3], my_mat_final[1][3], my_mat_final[2][3]]) my_pred = np.append(my_r_final, my_t_final) my_r = my_r_final my_t = my_t_final my_r = quaternion_matrix(my_r)[:3, :3] #print(my_t.shape) my_t = np.array(my_t) #print(my_t.shape) #print(my_r.shape) target = np.dot(self.scaled, my_r.T) target = np.add(target, my_t) p0 = (int((target[0][0] / target[0][2]) * self.cam_fx + self.cam_cx), int((target[0][1] / target[0][2]) * self.cam_fy + self.cam_cy)) p1 = (int((target[1][0] / target[1][2]) * self.cam_fx + self.cam_cx), int((target[1][1] / target[1][2]) * self.cam_fy + self.cam_cy)) p2 = (int((target[2][0] / target[2][2]) * self.cam_fx + self.cam_cx), int((target[2][1] / target[2][2]) * self.cam_fy + self.cam_cy)) p3 = (int((target[3][0] / target[3][2]) * self.cam_fx + self.cam_cx), int((target[3][1] / target[3][2]) * self.cam_fy + self.cam_cy)) p4 = (int((target[4][0] / target[4][2]) * self.cam_fx + self.cam_cx), int((target[4][1] / target[4][2]) * self.cam_fy + self.cam_cy)) p5 = (int((target[5][0] / target[5][2]) * self.cam_fx + self.cam_cx), int((target[5][1] / target[5][2]) * self.cam_fy + self.cam_cy)) p6 = (int((target[6][0] / target[6][2]) * self.cam_fx + self.cam_cx), int((target[6][1] / target[6][2]) * self.cam_fy + self.cam_cy)) p7 = (int((target[7][0] / target[7][2]) * self.cam_fx + self.cam_cx), int((target[7][1] / target[7][2]) * self.cam_fy + self.cam_cy)) cv2.line(rgb_original, p0, p1, (255, 255, 255), 2) cv2.line(rgb_original, p0, p3, (255, 255, 255), 2) cv2.line(rgb_original, p0, p4, (255, 255, 255), 2) cv2.line(rgb_original, p1, p2, (255, 255, 255), 2) cv2.line(rgb_original, p1, p5, (255, 255, 255), 2) cv2.line(rgb_original, p2, p3, (255, 255, 255), 2) cv2.line(rgb_original, p2, p6, (255, 255, 255), 2) cv2.line(rgb_original, p3, p7, (255, 255, 255), 2) cv2.line(rgb_original, p4, p5, (255, 255, 255), 2) cv2.line(rgb_original, p4, p7, (255, 255, 255), 2) cv2.line(rgb_original, p5, p6, (255, 255, 255), 2) cv2.line(rgb_original, p6, p7, (255, 255, 255), 2) #print('estimated rotation is :{0}'.format(my_r)) #print('estimated translation is :{0}'.format(my_t)) #time2 = time.time() #print('inference time is :{0}'.format(time2-time1)) cv2.imshow('rgb', cv2.cvtColor(rgb_original, cv2.COLOR_BGR2RGB)) # OpenCV uses BGR model cv2.waitKey( 1 ) # pass any integr except 0, as 0 will freeze the display windows
def sanitize_array(data, index, dtype=None, copy=False, raise_cast_failure=False): """ Sanitize input data to an ndarray, copy if specified, coerce to the dtype if specified. """ if dtype is not None: dtype = pandas_dtype(dtype) if isinstance(data, ma.MaskedArray): mask = ma.getmaskarray(data) if mask.any(): data, fill_value = maybe_upcast(data, copy=True) data.soften_mask() # set hardmask False if it was True data[mask] = fill_value else: data = data.copy() data = extract_array(data, extract_numpy=True) # GH#846 if isinstance(data, np.ndarray): if dtype is not None: subarr = np.array(data, copy=False) # possibility of nan -> garbage if is_float_dtype(data.dtype) and is_integer_dtype(dtype): try: subarr = _try_cast(data, True, dtype, copy, True) except ValueError: if copy: subarr = data.copy() else: subarr = _try_cast(data, True, dtype, copy, raise_cast_failure) elif isinstance(data, Index): # don't coerce Index types # e.g. indexes can have different conversions (so don't fast path # them) # GH#6140 subarr = sanitize_index(data, index, copy=copy) else: # we will try to copy be-definition here subarr = _try_cast(data, True, dtype, copy, raise_cast_failure) elif isinstance(data, ExtensionArray): if isinstance(data, ABCPandasArray): # We don't want to let people put our PandasArray wrapper # (the output of Series/Index.array), into a Series. So # we explicitly unwrap it here. subarr = data.to_numpy() else: subarr = data # everything else in this block must also handle ndarray's, # becuase we've unwrapped PandasArray into an ndarray. if dtype is not None: subarr = data.astype(dtype) if copy: subarr = data.copy() return subarr elif isinstance(data, (list, tuple)) and len(data) > 0: if dtype is not None: try: subarr = _try_cast(data, False, dtype, copy, raise_cast_failure) except Exception: if raise_cast_failure: # pragma: no cover raise subarr = np.array(data, dtype=object, copy=copy) subarr = lib.maybe_convert_objects(subarr) else: subarr = maybe_convert_platform(data) subarr = maybe_cast_to_datetime(subarr, dtype) elif isinstance(data, range): # GH#16804 start, stop, step = get_range_parameters(data) arr = np.arange(start, stop, step, dtype='int64') subarr = _try_cast(arr, False, dtype, copy, raise_cast_failure) else: subarr = _try_cast(data, False, dtype, copy, raise_cast_failure) # scalar like, GH if getattr(subarr, 'ndim', 0) == 0: if isinstance(data, list): # pragma: no cover subarr = np.array(data, dtype=object) elif index is not None: value = data # figure out the dtype from the value (upcast if necessary) if dtype is None: dtype, value = infer_dtype_from_scalar(value) else: # need to possibly convert the value here value = maybe_cast_to_datetime(value, dtype) subarr = construct_1d_arraylike_from_scalar( value, len(index), dtype) else: return subarr.item() # the result that we want elif subarr.ndim == 1: if index is not None: # a 1-element ndarray if len(subarr) != len(index) and len(subarr) == 1: subarr = construct_1d_arraylike_from_scalar( subarr[0], len(index), subarr.dtype) elif subarr.ndim > 1: if isinstance(data, np.ndarray): raise Exception('Data must be 1-dimensional') else: subarr = com.asarray_tuplesafe(data, dtype=dtype) # This is to prevent mixed-type Series getting all casted to # NumPy string type, e.g. NaN --> '-1#IND'. if issubclass(subarr.dtype.type, compat.string_types): # GH#16605 # If not empty convert the data to dtype # GH#19853: If data is a scalar, subarr has already the result if not lib.is_scalar(data): if not np.all(isna(data)): data = np.array(data, dtype=dtype, copy=False) subarr = np.array(data, dtype=object, copy=copy) if is_object_dtype(subarr.dtype) and dtype != 'object': inferred = lib.infer_dtype(subarr, skipna=False) if inferred == 'period': try: subarr = period_array(subarr) except IncompatibleFrequency: pass return subarr
def merge_arrays(seqarrays, fill_value=-1, flatten=False, usemask=False, asrecarray=False): """ Merge arrays field by field. Parameters ---------- seqarrays : sequence of ndarrays Sequence of arrays fill_value : {float}, optional Filling value used to pad missing data on the shorter arrays. flatten : {False, True}, optional Whether to collapse nested fields. usemask : {False, True}, optional Whether to return a masked array or not. asrecarray : {False, True}, optional Whether to return a recarray (MaskedRecords) or not. Examples -------- >>> from numpy.lib import recfunctions as rfn >>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.]))) masked_array(data = [(1, 10.0) (2, 20.0) (--, 30.0)], mask = [(False, False) (False, False) (True, False)], fill_value = (999999, 1e+20), dtype = [('f0', '<i4'), ('f1', '<f8')]) >>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.])), ... usemask=False) array([(1, 10.0), (2, 20.0), (-1, 30.0)], dtype=[('f0', '<i4'), ('f1', '<f8')]) >>> rfn.merge_arrays((np.array([1, 2]).view([('a', int)]), ... np.array([10., 20., 30.])), ... usemask=False, asrecarray=True) rec.array([(1, 10.0), (2, 20.0), (-1, 30.0)], dtype=[('a', '<i4'), ('f1', '<f8')]) Notes ----- * Without a mask, the missing value will be filled with something, * depending on what its corresponding type: -1 for integers -1.0 for floating point numbers '-' for characters '-1' for strings True for boolean values * XXX: I just obtained these values empirically """ # Only one item in the input sequence ? if (len(seqarrays) == 1): seqarrays = np.asanyarray(seqarrays[0]) # Do we have a single ndarray as input ? if isinstance(seqarrays, (ndarray, np.void)): seqdtype = seqarrays.dtype if (not flatten) or \ (zip_descr((seqarrays,), flatten=True) == seqdtype.descr): # Minimal processing needed: just make sure everythng's a-ok seqarrays = seqarrays.ravel() # Make sure we have named fields if not seqdtype.names: seqdtype = [('', seqdtype)] # Find what type of array we must return if usemask: if asrecarray: seqtype = MaskedRecords else: seqtype = MaskedArray elif asrecarray: seqtype = recarray else: seqtype = ndarray return seqarrays.view(dtype=seqdtype, type=seqtype) else: seqarrays = (seqarrays, ) else: # Make sure we have arrays in the input sequence seqarrays = map(np.asanyarray, seqarrays) # Find the sizes of the inputs and their maximum sizes = tuple(a.size for a in seqarrays) maxlength = max(sizes) # Get the dtype of the output (flattening if needed) newdtype = zip_descr(seqarrays, flatten=flatten) # Initialize the sequences for data and mask seqdata = [] seqmask = [] # If we expect some kind of MaskedArray, make a special loop. if usemask: for (a, n) in itertools.izip(seqarrays, sizes): nbmissing = (maxlength - n) # Get the data and mask data = a.ravel().__array__() mask = ma.getmaskarray(a).ravel() # Get the filling value (if needed) if nbmissing: fval = _check_fill_value(fill_value, a.dtype) if isinstance(fval, (ndarray, np.void)): if len(fval.dtype) == 1: fval = fval.item()[0] fmsk = True else: fval = np.array(fval, dtype=a.dtype, ndmin=1) fmsk = np.ones((1, ), dtype=mask.dtype) else: fval = None fmsk = True # Store an iterator padding the input to the expected length seqdata.append(itertools.chain(data, [fval] * nbmissing)) seqmask.append(itertools.chain(mask, [fmsk] * nbmissing)) # Create an iterator for the data data = tuple(izip_records(seqdata, flatten=flatten)) output = ma.array(np.fromiter(data, dtype=newdtype, count=maxlength), mask=list(izip_records(seqmask, flatten=flatten))) if asrecarray: output = output.view(MaskedRecords) else: # Same as before, without the mask we don't need... for (a, n) in itertools.izip(seqarrays, sizes): nbmissing = (maxlength - n) data = a.ravel().__array__() if nbmissing: fval = _check_fill_value(fill_value, a.dtype) if isinstance(fval, (ndarray, np.void)): if len(fval.dtype) == 1: fval = fval.item()[0] else: fval = np.array(fval, dtype=a.dtype, ndmin=1) else: fval = None seqdata.append(itertools.chain(data, [fval] * nbmissing)) output = np.fromiter(tuple(izip_records(seqdata, flatten=flatten)), dtype=newdtype, count=maxlength) if asrecarray: output = output.view(recarray) # And we're done... return output
def __getitem__(self, index): img = Image.open('{0}/{1}-color.png'.format(self.root, self.list[index])) depth = np.array( Image.open('{0}/{1}-depth.png'.format(self.root, self.list[index]))) label = np.array( Image.open('{0}/{1}-label.png'.format(self.root, self.list[index]))) meta = scio.loadmat('{0}/{1}-meta.mat'.format(self.root, self.list[index])) if self.list[index][:8] != 'data_syn' and int( self.list[index][5:9]) >= 60: cam_cx = self.cam_cx_2 cam_cy = self.cam_cy_2 cam_fx = self.cam_fx_2 cam_fy = self.cam_fy_2 else: cam_cx = self.cam_cx_1 cam_cy = self.cam_cy_1 cam_fx = self.cam_fx_1 cam_fy = self.cam_fy_1 mask_back = ma.getmaskarray(ma.masked_equal(label, 0)) add_front = False if self.add_noise: for k in range(5): seed = random.choice(self.syn) front = np.array( self.trancolor( Image.open('{0}/{1}-color.png'.format( self.root, seed)).convert("RGB"))) front = np.transpose(front, (2, 0, 1)) f_label = np.array( Image.open('{0}/{1}-label.png'.format(self.root, seed))) front_label = np.unique(f_label).tolist()[1:] if len(front_label) < self.front_num: continue front_label = random.sample(front_label, self.front_num) for f_i in front_label: mk = ma.getmaskarray(ma.masked_not_equal(f_label, f_i)) if f_i == front_label[0]: mask_front = mk else: mask_front = mask_front * mk t_label = label * mask_front if len(t_label.nonzero()[0]) > 1000: label = t_label add_front = True break obj = meta['cls_indexes'].flatten().astype(np.int32) while 1: idx = np.random.randint(0, len(obj)) mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0)) mask_label = ma.getmaskarray(ma.masked_equal(label, obj[idx])) mask = mask_label * mask_depth if len(mask.nonzero()[0]) > self.minimum_num_pt: break if self.add_noise: img = self.trancolor(img) rmin, rmax, cmin, cmax = get_bbox(mask_label) img = np.transpose(np.array(img)[:, :, :3], (2, 0, 1))[:, rmin:rmax, cmin:cmax] if self.list[index][:8] == 'data_syn': seed = random.choice(self.real) back = np.array( self.trancolor( Image.open('{0}/{1}-color.png'.format( self.root, seed)).convert("RGB"))) back = np.transpose(back, (2, 0, 1))[:, rmin:rmax, cmin:cmax] img_masked = back * mask_back[rmin:rmax, cmin:cmax] + img else: img_masked = img if self.add_noise and add_front: img_masked = img_masked * mask_front[ rmin:rmax, cmin:cmax] + front[:, rmin:rmax, cmin:cmax] * ~( mask_front[rmin:rmax, cmin:cmax]) if self.list[index][:8] == 'data_syn': img_masked = img_masked + np.random.normal( loc=0.0, scale=7.0, size=img_masked.shape) # p_img = np.transpose(img_masked, (1, 2, 0)) # scipy.misc.imsave('temp/{0}_input.png'.format(index), p_img) # scipy.misc.imsave('temp/{0}_label.png'.format(index), mask[rmin:rmax, cmin:cmax].astype(np.int32)) target_r = meta['poses'][:, :, idx][:, 0:3] target_t = np.array([meta['poses'][:, :, idx][:, 3:4].flatten()]) add_t = np.array([ random.uniform(-self.noise_trans, self.noise_trans) for i in range(3) ]) choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] if len(choose) > self.num_pt: c_mask = np.zeros(len(choose), dtype=int) c_mask[:self.num_pt] = 1 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()] else: choose = np.pad(choose, (0, self.num_pt - len(choose)), 'wrap') depth_masked = depth[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype( np.float32) xmap_masked = self.xmap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) ymap_masked = self.ymap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) choose = np.array([choose]) cam_scale = meta['factor_depth'][0][0] pt2 = depth_masked / cam_scale pt0 = (ymap_masked - cam_cx) * pt2 / cam_fx pt1 = (xmap_masked - cam_cy) * pt2 / cam_fy cloud = np.concatenate((pt0, pt1, pt2), axis=1) if self.add_noise: cloud = np.add(cloud, add_t) # fw = open('temp/{0}_cld.xyz'.format(index), 'w') # for it in cloud: # fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2])) # fw.close() dellist = [j for j in range(0, len(self.cld[obj[idx]]))] if self.refine: dellist = random.sample( dellist, len(self.cld[obj[idx]]) - self.num_pt_mesh_large) else: dellist = random.sample( dellist, len(self.cld[obj[idx]]) - self.num_pt_mesh_small) model_points = np.delete(self.cld[obj[idx]], dellist, axis=0) # fw = open('temp/{0}_model_points.xyz'.format(index), 'w') # for it in model_points: # fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2])) # fw.close() target = np.dot(model_points, target_r.T) if self.add_noise: target = np.add(target, target_t + add_t) else: target = np.add(target, target_t) # fw = open('temp/{0}_tar.xyz'.format(index), 'w') # for it in target: # fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2])) # fw.close() return torch.from_numpy(cloud.astype(np.float32)), \ torch.LongTensor(choose.astype(np.int32)), \ self.norm(torch.from_numpy(img_masked.astype(np.float32))), \ torch.from_numpy(target.astype(np.float32)), \ torch.from_numpy(model_points.astype(np.float32)), \ torch.LongTensor([int(obj[idx]) - 1])
def printCurve(take_idx, criterion): conf_tp_or_fn = [[] for i in range(5)] conf_fp = [[] for i in range(5)] prec = [[] for i in range(5)] recall = [[] for i in range(5)] if take_idx is 0: file_1_name = 'occ/under60.txt' file_2_name = 'occ/under60_frames.txt' elif take_idx is 1: file_1_name = 'occ/from60to80.txt' file_2_name = 'occ/f60t80_frames.txt' else: file_1_name = 'occ/up80.txt' file_2_name = 'occ/up80_frames.txt' xmap = np.array([[j for i in range(640)] for j in range(480)]) ymap = np.array([[i for i in range(640)] for j in range(480)]) with open(file_1_name, 'r') as f1: with open(file_2_name, 'r') as f2: while 1: input_line_test = f2.readline() # print(input_line_test) if not input_line_test: break if input_line_test[-1:] == '\n': input_line_test = input_line_test[:-1] _, test_scene_id, test_frame_id = input_line_test.split('/') input_line_test = '/'.join( ['data_v1', test_scene_id, test_frame_id]) # import pdb;pdb.set_trace() input_line_test_2 = f1.readline() test_obj_id = int(float(input_line_test_2.split()[2])) + 1 test_idx = int(float(input_line_test_2.split()[1])) # import pdb;pdb.set_trace() img = Image.open('{0}/{1}-color.png'.format( opt.dataset_root, input_line_test)) depth = np.array( Image.open('{0}/{1}-depth.png'.format( opt.dataset_root, input_line_test))) label = np.array( Image.open('{0}/{1}-label.png'.format( opt.dataset_root, input_line_test))) meta = scio.loadmat('{0}/{1}-meta.mat'.format( opt.dataset_root, input_line_test)) cam_cx = 312.9869 cam_cy = 241.3109 cam_fx = 1066.778 cam_fy = 1067.487 mask_back = ma.getmaskarray(ma.masked_equal(label, 0)) print('scene index: ', test_scene_id) print('object index: ', test_obj_id) mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0)) mask_label = ma.getmaskarray( ma.masked_equal(label, test_obj_id)) mask = mask_label * mask_depth if not (len(mask.nonzero()[0]) > 50 and len(opt.symmetry[test_obj_id]['mirror']) > 0): continue rmin, rmax, cmin, cmax = get_bbox(mask_label) img_temp = np.transpose(np.array(img)[:, :, :3], (2, 0, 1))[:, rmin:rmax, cmin:cmax] img_masked = img_temp target_r = meta['poses'][:, :, test_idx][:, 0:3] target_t = np.array(meta['poses'][:, :, test_idx][:, 3:4].flatten()) choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] if len(choose) > opt.num_points: c_mask = np.zeros(len(choose), dtype=int) c_mask[:opt.num_points] = 1 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()] else: choose = np.pad(choose, (0, opt.num_points - len(choose)), 'wrap') depth_masked = depth[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) xmap_masked = xmap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) ymap_masked = ymap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) choose = np.array([choose]) cam_scale = meta['factor_depth'][0][0] pt2 = depth_masked / cam_scale pt0 = (ymap_masked - cam_cx) * pt2 / cam_fx pt1 = (xmap_masked - cam_cy) * pt2 / cam_fy cloud = np.concatenate((pt0, pt1, pt2), axis=1) target_sym = [] for sym in opt.symmetry[test_obj_id]['mirror']: target_sym.append(np.dot(sym, target_r.T)) target_sym = np.array(target_sym) target_cen = np.add(opt.symmetry[test_obj_id]['center'], target_t) # print('ground truth norm: ', target_sym) # print('ground truth center: ', target_cen) points_ten, choose_ten, img_ten, target_sym_ten, target_cen_ten, idx_ten = \ torch.from_numpy(cloud.astype(np.float32)).unsqueeze(0), \ torch.LongTensor(choose.astype(np.int32)).unsqueeze(0), \ opt.norm(torch.from_numpy(img_masked.astype(np.float32))).unsqueeze(0), \ torch.from_numpy(target_sym.astype(np.float32)).unsqueeze(0), \ torch.from_numpy(target_cen.astype(np.float32)).unsqueeze(0), \ torch.LongTensor([test_obj_id-1]).unsqueeze(0) points_ten, choose_ten, img_ten, target_sym_ten, target_cen_ten, idx_ten = Variable(points_ten), \ Variable(choose_ten), \ Variable(img_ten), \ Variable(target_sym_ten), \ Variable(target_cen_ten), \ Variable(idx_ten) pred_norm, pred_on_plane, emb = opt.estimator( img_ten, points_ten, choose_ten, idx_ten) bs, num_p, _ = pred_on_plane.size() pred_norm = pred_norm / (torch.norm(pred_norm, dim=2).view( bs, num_p, 1)) pred_norm = pred_norm.detach().numpy() pred_on_plane = pred_on_plane.detach().numpy() points = points_ten.detach().numpy() clustering_points_idx = np.where(pred_on_plane > max( 0.5, pred_on_plane.max() * PRED_ON_PLANE_FACTOR + pred_on_plane.mean() * (1 - PRED_ON_PLANE_FACTOR)))[1] clustering_norm = pred_norm[0, clustering_points_idx, :] clustering_points = points[0, clustering_points_idx, :] num_points = len(clustering_points_idx) # print(pred_on_plane.max()) # import pdb;pdb.set_trace() close_thresh = 2e-3 broad_thresh = 3e-3 sym_conf = np.zeros((5, target_sym.shape[0])) count_pred = 0 # import pdb; pdb.set_trace() while True: count_pred += 1 if num_points <= 20 or count_pred > 3: break best_fit_num = 0 count_try = 0 for j in range(10): pick_idx = np.random.randint(0, num_points - 1) pick_point = clustering_points[pick_idx] # proposal_norm = np.array(Plane(Point3D(pick_points[0]),Point3D(pick_points[1]),Point3D(pick_points[2])).normal_vector).astype(np.float32) proposal_norm = clustering_norm[pick_idx] proposal_norm = proposal_norm[:, np.newaxis] # import pdb;pdb.set_trace() proposal_point = pick_point clustering_diff = clustering_points - proposal_point clustering_dist = np.abs( np.matmul(clustering_diff, proposal_norm)) broad_inliers = np.where( clustering_dist < broad_thresh)[0] broad_inlier_num = len(broad_inliers) close_inliers = np.where( clustering_dist < close_thresh)[0] close_inlier_num = len(close_inliers) norm_dist = np.abs(clustering_norm - np.transpose(proposal_norm)).sum(1) close_norm_idx = np.where(norm_dist < 0.6)[0] close_norm_num = len(close_norm_idx) if close_inlier_num >= best_fit_num and broad_inlier_num >= num_points / ( 4 - count_pred ) * 0.9 and close_norm_num >= num_points / ( 4 - count_pred) * 0.9: best_fit_num = close_inlier_num best_fit_norm = proposal_norm best_fit_cen = clustering_points[ close_inliers].mean(0) best_fit_idx = clustering_points_idx[close_inliers] best_norm_dist = norm_dist best_close_norm_idx = np.where( best_norm_dist < 0.6)[0] if best_fit_num == 0 or num_points <= 20: break clustering_points_same_sym = clustering_points[ best_close_norm_idx] clustering_diff_same_sym = clustering_points_same_sym - best_fit_cen clustering_dist_same_sym = np.abs( np.matmul(clustering_diff_same_sym, best_fit_norm)) close_inliers = np.where( clustering_dist_same_sym < close_thresh)[0] close_inlier_num = len(close_inliers) best_fit_num = close_inlier_num broad_inliers = np.where( clustering_dist_same_sym < broad_thresh)[0] broad_inlier_num = len(broad_inliers) def f(x): dist = 0 # import pdb;pdb.set_trace() for point in clustering_points_same_sym[broad_inliers]: dist += np.abs( (point * x[0:3]).sum() + x[3]) / np.sqrt( np.sum(np.square(x[0:3]), axis=0)) return dist start_point = np.zeros(4) start_point[0:3] = np.copy(best_fit_norm[:, 0]) start_point[3] = (-best_fit_cen * best_fit_norm[:, 0]).sum() min_point = fmin(f, start_point, maxiter=50) # import pdb;pdb.set_trace() min_point = min_point / np.sqrt( np.sum(np.square(min_point[0:3]), axis=0)) x_val = -(min_point[3] + best_fit_cen[1] * min_point[1] + best_fit_cen[2] * min_point[2]) / min_point[0] y_val = -(min_point[3] + best_fit_cen[0] * min_point[0] + best_fit_cen[2] * min_point[2]) / min_point[1] z_val = -(min_point[3] + best_fit_cen[0] * min_point[0] + best_fit_cen[1] * min_point[1]) / min_point[2] if np.abs(x_val) < 1: new_pred_loc = np.array( [x_val, best_fit_cen[1], best_fit_cen[2]]) elif np.abs(z_val) < 1: new_pred_loc = np.array( [best_fit_cen[0], best_fit_cen[1], z_val]) else: new_pred_loc = np.array( [best_fit_cen[0], y_val, best_fit_cen[2]]) new_proposal_norm = min_point[0:3] clustering_diff = clustering_points_same_sym - new_pred_loc clustering_dist = np.abs( np.matmul(clustering_diff, new_proposal_norm)) close_inliers = np.where(clustering_dist < close_thresh)[0] new_close_inlier_num = len(close_inliers) broad_inliers = np.where(clustering_dist < broad_thresh)[0] new_broad_inlier_num = len(broad_inliers) # import pdb;pdb.set_trace() if new_close_inlier_num >= close_inlier_num: best_fit_num = new_close_inlier_num best_fit_norm = new_proposal_norm[:, np.newaxis] best_fit_cen = new_pred_loc if best_fit_num == 0: break else: print('predicted norm:{}, predicted point:{}'.format( best_fit_norm, best_fit_cen)) max_idx = np.argmax( np.abs(np.matmul(target_sym, best_fit_norm))) sym_product = np.abs( np.matmul(target_sym, best_fit_norm)[max_idx][0]) sym_dist = np.abs((target_sym[max_idx] * (best_fit_cen - target_cen)).sum()) norm_dist = np.abs(clustering_norm - np.transpose(best_fit_norm)).sum(1) scrub_close_norm_idx = np.where(norm_dist < 1.3)[0] # import pdb;pdb.set_trace() predicted_confidence = best_fit_num / len( best_close_norm_idx) - np.abs( clustering_norm[best_close_norm_idx] - np.transpose(best_fit_norm)).mean() * 3 * 1.5 predicted_confidence = max(0, predicted_confidence) for dist_idx in range(5): if sym_product > PRODUCT_THRESHOLD and sym_dist < ( dist_idx + 1) * 0.01: # import pdb;pdb.set_trace() sym_conf[dist_idx, max_idx] = max( sym_conf[dist_idx, max_idx], predicted_confidence) else: conf_fp[dist_idx].append(predicted_confidence) clustering_points_idx = np.setdiff1d( clustering_points_idx, clustering_points_idx[scrub_close_norm_idx]) clustering_norm = pred_norm[0, clustering_points_idx, :] clustering_points = points[0, clustering_points_idx, :] num_points = len(clustering_points_idx) # import pdb;pdb.set_trace() # import pdb;pdb.set_trace() for dist_idx in range(5): for i in range(target_sym.shape[0]): conf_tp_or_fn[dist_idx].append(sym_conf[dist_idx, i]) # import pdb;pdb.set_trace() # import pdb;pdb.set_trace() print(conf_tp_or_fn) print(conf_fp) # import pdb;pdb.set_trace() for dist_idx in range(5): for t in range(1, 1001): conf_thresh = t / 1000 true_positives = len( np.where(np.array(conf_tp_or_fn[dist_idx]) >= conf_thresh)[0]) false_negatives = len( np.where(np.array(conf_tp_or_fn[dist_idx]) < conf_thresh)[0]) false_positives = len( np.where(np.array(conf_fp[dist_idx]) >= conf_thresh)[0]) if false_positives + true_positives > 0 and true_positives + false_negatives > 0: prec[dist_idx].append(true_positives / (false_positives + true_positives)) recall[dist_idx].append(true_positives / (true_positives + false_negatives)) return prec, recall
def __getitem__(self, index): img = Image.open(self.list_rgb[index]) ori_img = np.array(img) depth = np.array(Image.open(self.list_depth[index])) label = np.array(Image.open(self.list_label[index])) obj = self.list_obj[index] rank = self.list_rank[index] if obj == 2: for i in range(0, len(self.meta[obj][rank])): if self.meta[obj][rank][i]['obj_id'] == 2: meta = self.meta[obj][rank][i] break else: meta = self.meta[obj][rank][0] mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0)) if self.mode == 'eval': mask_label = ma.getmaskarray(ma.masked_equal(label, np.array(255))) else: mask_label = ma.getmaskarray(ma.masked_equal(label, np.array([255, 255, 255])))[:, :, 0] mask = mask_label * mask_depth if self.add_noise: img = self.trancolor(img) img = np.array(img)[:, :, :3] img = np.transpose(img, (2, 0, 1)) img_masked = img rmin, rmax, cmin, cmax = get_bbox(meta['obj_bb']) img_masked = img_masked[:, rmin:rmax, cmin:cmax] #p_img = np.transpose(img_masked, (1, 2, 0)) #scipy.misc.imsave('evaluation_result/{0}_input.png'.format(index), p_img) target_r = np.resize(np.array(meta['cam_R_m2c']), (3, 3)) target_t = np.array(meta['cam_t_m2c']) add_t = np.array([random.uniform(-self.noise_trans, self.noise_trans) for i in range(3)]) choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] if len(choose) == 0: cc = torch.LongTensor([0]) return(cc, cc, cc, cc, cc, cc) if len(choose) > self.num: c_mask = np.zeros(len(choose), dtype=int) c_mask[:self.num] = 1 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()] else: choose = np.pad(choose, (0, self.num - len(choose)), 'wrap') depth_masked = depth[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) xmap_masked = self.xmap[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) ymap_masked = self.ymap[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32) choose = np.array([choose]) cam_scale = 1.0 pt2 = depth_masked / cam_scale pt0 = (ymap_masked - self.cam_cx) * pt2 / self.cam_fx pt1 = (xmap_masked - self.cam_cy) * pt2 / self.cam_fy cloud = np.concatenate((pt0, pt1, pt2), axis=1) cloud = np.add(cloud, -1.0 * target_t) / 1000.0 cloud = np.add(cloud, target_t / 1000.0) if self.add_noise: cloud = np.add(cloud, add_t) #fw = open('evaluation_result/{0}_cld.xyz'.format(index), 'w') #for it in cloud: # fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2])) #fw.close() model_points = self.pt[obj] / 1000.0 dellist = [j for j in range(0, len(model_points))] dellist = random.sample(dellist, len(model_points) - self.num_pt_mesh_small) model_points = np.delete(model_points, dellist, axis=0) #fw = open('evaluation_result/{0}_model_points.xyz'.format(index), 'w') #for it in model_points: # fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2])) #fw.close() target = np.dot(model_points, target_r.T) if self.add_noise: target = np.add(target, target_t / 1000.0 + add_t) out_t = target_t / 1000.0 + add_t else: target = np.add(target, target_t / 1000.0) out_t = target_t / 1000.0 #fw = open('evaluation_result/{0}_tar.xyz'.format(index), 'w') #for it in target: # fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2])) #fw.close() return torch.from_numpy(cloud.astype(np.float32)), \ torch.LongTensor(choose.astype(np.int32)), \ self.norm(torch.from_numpy(img_masked.astype(np.float32))), \ torch.from_numpy(target.astype(np.float32)), \ torch.from_numpy(model_points.astype(np.float32)), \ torch.LongTensor([self.objlist.index(obj)])
depth_addr = data_path + "depth/" + str_num + "-depth.png" mask_addr = data_path + "mask/" + str_num + ".png" img = Image.open(rgb_addr) depth = np.array(Image.open(depth_addr)) masks = np.array(Image.open(mask_addr)) my_result_wo_refine = [] my_result = [] for idx in range(len(detected_classIDs)): itemid = detected_classIDs[idx] maskid = idx + 1 try: mask = ma.getmaskarray(ma.masked_equal(masks, maskid)) rmin, rmax, cmin, cmax = get_bbox(mask) print('itemid: {0}\n'.format(itemid)) print('rmin {0}, rmax {1}, cmin {2}, cmax {3}'.format(rmin, rmax, cmin, cmax)) mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0)) mask_label = ma.getmaskarray(ma.masked_equal(masks, maskid)) mask = mask_label * mask_depth choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] if len(choose) > num_points: c_mask = np.zeros(len(choose), dtype=int) c_mask[:num_points] = 1 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()]
def extract_static_vars_local(lat1, lat2, lon1, lon2, area_name, var_list, doy_start, doy_end): lat_indices, lon_indices = select_area(lat1, lat2, lon1, lon2, "M03") lats, lons = get_lat_lon("M03") assert (len(lats) != 0 and len(lons) != 0) lats = lats[lat_indices[0]:lat_indices[1]] lons = lons[lon_indices[0]:lon_indices[1]] out_path = get_out_path(os.path.join("Data", "Sentinel")) fh_out = Dataset( os.path.join(out_path, "static_vars_" + area_name + ".nc"), "w") fh_out.createDimension("lat", len(lats)) fh_out.createDimension("lon", len(lons)) general_in_path = os.path.join("n5eil01u.ecs.nsidc.org", "SMAP", "SPL2SMAP_S.002") first_flag = True for doy_folder in generate_doy(doy_start, doy_end, "."): if doy_folder in os.listdir(general_in_path): for f in os.listdir(os.path.join(general_in_path, doy_folder)): if f.endswith(".h5"): fh_in = Dataset( os.path.join(general_in_path, doy_folder, f), "r") group_3km = fh_in.groups[ "Soil_Moisture_Retrieval_Data_3km"] lat_start = group_3km.variables["EASE_row_index_3km"][0, 0] lat_end = group_3km.variables["EASE_row_index_3km"][-1, 0] lon_start = group_3km.variables["EASE_column_index_3km"][0, 0] lon_end = group_3km.variables["EASE_column_index_3km"][0, -1] if lat_end <= lat_indices[0] or lat_start >= lat_indices[1] \ or lon_end <= lon_indices[0] or lon_start >= lon_indices[1]: fh_in.close() continue print(f) if first_flag: for v_name, varin in group_3km.variables.items(): if v_name in ["latitude_3km", "longitude_3km"]: outVar = fh_out.createVariable( v_name[:3], varin.datatype, (v_name[:3])) elif v_name in var_list: outVar = fh_out.createVariable( v_name[:-4], varin.datatype, ("lat", "lon")) else: continue outVar.setncatts({ k: varin.getncattr(k) for k in varin.ncattrs() }) fh_out.variables["lat"][:] = lats[:] fh_out.variables["lon"][:] = lons[:] first_flag = False out_lat_start = max(lat_start - lat_indices[0], 0) out_lat_end = min(lat_end + 1 - lat_indices[0], len(lats)) out_lon_start = max(lon_start - lon_indices[0], 0) out_lon_end = min(lon_end + 1 - lon_indices[0], len(lons)) in_lat_start = max(lat_indices[0] - lat_start, 0) in_lat_end = min(lat_indices[1] - lat_start, lat_end - lat_start + 1) in_lon_start = max(lon_indices[0] - lon_start, 0) in_lon_end = min(lon_indices[1] - lon_start, lon_end - lon_start + 1) assert (out_lat_end - out_lat_start == in_lat_end - in_lat_start) assert (out_lon_end - out_lon_start == in_lon_end - in_lon_start) for v_name, varin in group_3km.variables.items(): if v_name in var_list: a = fh_out.variables[ v_name[:-4]][out_lat_start:out_lat_end, out_lon_start:out_lon_end] b = varin[in_lat_start:in_lat_end, in_lon_start:in_lon_end] if not isinstance(a, ma.MaskedArray): a = ma.array(a, mask=np.zeros(a.shape)) if not isinstance(b, ma.MaskedArray): b = ma.array(b, mask=np.zeros(b.shape)) for i in range(0, out_lat_end - out_lat_start): for j in range(0, out_lon_end - out_lon_start): if not ma.getmaskarray(a)[ i, j] and not ma.getmaskarray(b)[i, j]: assert a[i, j] == b[ i, j], v_name + " " + str( a[i, j]) + " " + str(b[i, j]) elif ma.getmaskarray(a)[ i, j] and not ma.getmaskarray(b)[i, j]: a[i, j] = b[i, j] fh_out.variables[ v_name[:-4]][out_lat_start:out_lat_end, out_lon_start:out_lon_end] = a fh_in.close() fh_out.close()
def flag(Data, NoiseData, thres=3.0, max_noise_factor=-1, modes_subtract=1, filter_type='edge'): """Flags data for outliers using a signal subtracted data set. Flags outliers of in a time stream data by looking at a version of the data that has had the signal subtracted out of it. Each frequency channel, polarization and cal state are treated separately. Parameters ---------- Data : DataBlock Object Data to be flaged. Upon exit, this object will have new flags. NoiseData : DataBlock Object Version of `Data` with the signal subtracted. thres : float Threshold for flagging in units of sigma (default is 3.0). modes_subtract : int How many modes to remove for high pass filtering. filter_type : {'edge', 'gaussian', 'gaussian/edge'} Type of high pass filtering to use. """ # Get the mask and the data as normal arrays. # Copy seems to be nessisary if the mask is None. data = NoiseData.data.filled(0).copy() mask = ma.getmaskarray(NoiseData.data) ## High pass filter the data to make outliers stand out. un_mask = sp.logical_not(mask) NoiseData.calc_time() time = NoiseData.time n_time = len(time) # How many basis polynomials we need and with what fraction of each mode # gets subtracted out.. if filter_type == 'edge': n_polys = modes_subtract subtract_weights = sp.ones(n_polys) elif filter_type == 'gaussian' or filter_type == 'gaussian/edge': n_polys = 4 * modes_subtract subtract_weights = sp.exp( -(sp.arange(n_polys, dtype=float) / modes_subtract)**2 / 2.) if filter_type == 'gaussian/edge': subtract_weights[0:2] = 1. # Test if the mask is the same for all slices. If it is, that greatly # reduces the work as we only have to generate one set of polynomials. all_masks_same = True for jj in range(n_time): if sp.all(un_mask[jj, ...] == un_mask[jj, 0, 0, 0]): continue else: all_masks_same = False break if all_masks_same: polys = misc.ortho_poly(time, n_polys, un_mask[:, 0, 0, 0], 0) polys.shape = (n_polys, len(time), 1, 1, 1) else: polys = misc.ortho_poly(time[:, None, None, None], n_polys, un_mask, 0) # Subtract the slope mode (1th mode) out of the NoiseData. amps = sp.sum(data * un_mask * polys, 1) amps *= subtract_weights[:, None, None, None] data -= sp.sum(amps[:, None, :, :, :] * un_mask[None, :, :, :, :] * polys, 0) ## Do the main outlier flagging. # Iteratively flag on sliding scale to get closer and closer to desired # threshold. max_thres = sp.sqrt(n_time) / 2. n_iter = 3 thresholds = (max_thres**(n_iter - 1 - sp.arange(n_iter)) * thres**sp.arange(n_iter))**(1. / (n_iter - 1)) for threshold in thresholds: # Subtract the mean from every channel. this_data = masked_subtract_mean(data, mask, 0) # Calculate the variance. un_mask = sp.logical_not(mask) counts = sp.sum(un_mask, 0) counts[counts == 0] = 1 std = sp.sqrt(sp.sum(this_data**2 * un_mask, 0) / counts) bad_inds = abs(this_data) > threshold * std # If any polarization or cal state is masked, they all should be. bad_inds = sp.any(sp.any(bad_inds, 1), 1) mask[bad_inds[:, None, None, :]] = True ## Now look for times with excusion frequency average # (achromatic out-liers). # Compute the frequency mean. un_mask = sp.logical_not(mask) counts = sp.sum(un_mask, -1) fmean_un_mask = counts >= 1 counts[counts == 0] = 1 fmean = sp.sum(data * un_mask, -1) / counts # Subtract the time mean. fmean = masked_subtract_mean(fmean, sp.logical_not(fmean_un_mask), 0) # Get the variance. counts = sp.sum(fmean_un_mask, 0) counts[counts == 0] = 1 fmean_std = sp.sqrt(sp.sum(fmean**2 * fmean_un_mask, 0) / counts) # Flag any time that is an outlier (for any polarization or cal state). bad_times = sp.any(sp.any(abs(fmean) > thres * fmean_std, 1), 1) mask[bad_times, :, :, :] = True ## Flag for very noisy channels. if max_noise_factor > 0: # Do this a few times to make sure we get everything. for ii in range(3): this_data = masked_subtract_mean(data, mask, 0) # Compute varience accounting for the mask. un_mask = sp.logical_not(mask) counts = sp.sum(un_mask, 0) vars_un_mask = counts >= 1 counts[counts == 0] = 1 vars = sp.sum(this_data**2 * un_mask, 0) / counts # Find the mean of the variences. counts = sp.sum(vars_un_mask, -1) counts[counts == 0] = 1 mean_vars = sp.sum(vars * vars_un_mask, -1) / counts # Find channels that stand out (for any polarization or cal state). bad_chans = sp.any( sp.any(vars > max_noise_factor * mean_vars[:, :, None], 0), 0) mask[:, :, :, bad_chans] = True ## Transfer the mask to the DataBlock objects. Data.data[mask] = ma.masked NoiseData.data[mask] = ma.masked
def sanitize_array( data, index: Optional["Index"], dtype: Optional[DtypeObj] = None, copy: bool = False, raise_cast_failure: bool = False, ) -> ArrayLike: """ Sanitize input data to an ndarray or ExtensionArray, copy if specified, coerce to the dtype if specified. """ if isinstance(data, ma.MaskedArray): mask = ma.getmaskarray(data) if mask.any(): data, fill_value = maybe_upcast(data, copy=True) data.soften_mask() # set hardmask False if it was True data[mask] = fill_value else: data = data.copy() # extract ndarray or ExtensionArray, ensure we have no PandasArray data = extract_array(data, extract_numpy=True) # GH#846 if isinstance(data, np.ndarray): if dtype is not None and is_float_dtype( data.dtype) and is_integer_dtype(dtype): # possibility of nan -> garbage try: subarr = _try_cast(data, dtype, copy, True) except ValueError: if copy: subarr = data.copy() else: subarr = np.array(data, copy=False) else: # we will try to copy be-definition here subarr = _try_cast(data, dtype, copy, raise_cast_failure) elif isinstance(data, ABCExtensionArray): # it is already ensured above this is not a PandasArray subarr = data if dtype is not None: subarr = subarr.astype(dtype, copy=copy) elif copy: subarr = subarr.copy() return subarr elif isinstance(data, (list, tuple)) and len(data) > 0: if dtype is not None: subarr = _try_cast(data, dtype, copy, raise_cast_failure) else: subarr = maybe_convert_platform(data) subarr = maybe_cast_to_datetime(subarr, dtype) elif isinstance(data, range): # GH#16804 arr = np.arange(data.start, data.stop, data.step, dtype="int64") subarr = _try_cast(arr, dtype, copy, raise_cast_failure) elif isinstance(data, abc.Set): raise TypeError("Set type is unordered") elif lib.is_scalar(data) and index is not None and dtype is not None: data = maybe_cast_to_datetime(data, dtype) if not lib.is_scalar(data): data = data[0] subarr = construct_1d_arraylike_from_scalar(data, len(index), dtype) else: subarr = _try_cast(data, dtype, copy, raise_cast_failure) # scalar like, GH if getattr(subarr, "ndim", 0) == 0: if isinstance(data, list): # pragma: no cover subarr = np.array(data, dtype=object) elif index is not None: value = data # figure out the dtype from the value (upcast if necessary) if dtype is None: dtype, value = infer_dtype_from_scalar(value) else: # need to possibly convert the value here value = maybe_cast_to_datetime(value, dtype) subarr = construct_1d_arraylike_from_scalar( value, len(index), dtype) else: return subarr.item() # the result that we want elif subarr.ndim == 1: if index is not None: # a 1-element ndarray if len(subarr) != len(index) and len(subarr) == 1: subarr = construct_1d_arraylike_from_scalar( subarr[0], len(index), subarr.dtype) elif subarr.ndim > 1: if isinstance(data, np.ndarray): raise Exception("Data must be 1-dimensional") else: subarr = com.asarray_tuplesafe(data, dtype=dtype) if not (is_extension_array_dtype(subarr.dtype) or is_extension_array_dtype(dtype)): # This is to prevent mixed-type Series getting all casted to # NumPy string type, e.g. NaN --> '-1#IND'. if issubclass(subarr.dtype.type, str): # GH#16605 # If not empty convert the data to dtype # GH#19853: If data is a scalar, subarr has already the result if not lib.is_scalar(data): if not np.all(isna(data)): data = np.array(data, dtype=dtype, copy=False) subarr = np.array(data, dtype=object, copy=copy) if is_object_dtype(subarr.dtype) and not is_object_dtype(dtype): inferred = lib.infer_dtype(subarr, skipna=False) if inferred in {"interval", "period"}: subarr = array(subarr) return subarr
def process_file(self, file_ind): params = self.params file_middle = params['file_middles'][file_ind] input_fname = (params['input_root'] + file_middle + params['input_end']) sub_input_fname = (params['subtracted_input_root'] + file_middle + params['input_end']) output_fname = (params['output_root'] + file_middle + params['output_end']) sub_output_fname = (params['subtracted_output_root'] + file_middle + params['output_end']) Writer = fitsGBT.Writer(feedback=self.feedback) SubWriter = fitsGBT.Writer(feedback=self.feedback) # Read in the data, and loop over data blocks. Reader = fitsGBT.Reader(input_fname, feedback=self.feedback) SubReader = fitsGBT.Reader(sub_input_fname, feedback=self.feedback) if (sp.any(Reader.scan_set != SubReader.scan_set) or sp.any(Reader.IF_set != SubReader.IF_set)): raise ce.DataError("IFs and scans don't match signal subtracted" " data.") # Get the number of scans if asked for all of them. scan_inds = params['scans'] if len(scan_inds) == 0 or scan_inds is None: scan_inds = range(len(Reader.scan_set)) if_inds = params['IFs'] if len(if_inds) == 0 or scan_inds is None: if_inds = range(len(Reader.IF_set)) if self.feedback > 1: print "New flags each block:", # Loop over scans and IFs for thisscan in scan_inds: for thisIF in if_inds: Data = Reader.read(thisscan, thisIF) SubData = SubReader.read(thisscan, thisIF) # Make sure they have agreeing masks to start. SubData.data[ma.getmaskarray(Data.data)] = ma.masked Data.data[ma.getmaskarray(SubData.data)] = ma.masked # Get initial number of flags. n_flags = ma.count_masked(Data.data) # Now do the flagging. flag(Data, SubData, params['thres'], params['max_noise_factor'], params['smooth_modes_subtract'], params['filter_type']) Data.add_history( "Reflaged for outliers.", ("Used file: " + utils.abbreviate_file_path(sub_input_fname), )) SubData.add_history("Reflaged for outliers.") Writer.add_data(Data) SubWriter.add_data(SubData) # Report the number of new flags. n_flags = ma.count_masked(Data.data) - n_flags if self.feedback > 1: print n_flags, if self.feedback > 1: print '' # Finally write the data back to file. utils.mkparents(output_fname) utils.mkparents(sub_output_fname) Writer.write(output_fname) SubWriter.write(sub_output_fname)
def main(): cfg = setup_config() pipeline = rs.pipeline() realsense_cfg = setup_realsense() pipeline.start(realsense_cfg) # Start streaming visualizer = predictor.VisualizationDemo(cfg) ref_frame_axies = [] ref_frame_label = [] min_distance = 0.9 label_cnt = 0 frameth = 0 my_t_pool = {} my_r_pool = {} while True: frameth += 1 cur_frame_axies = [] cur_frame_label = [] my_t_per_frame = [] my_r_per_frame = [] align = rs.align(rs.stream.color) frames = pipeline.wait_for_frames() aligned_frames = align.process(frames) rgb = aligned_frames.get_color_frame() rgb = np.asanyarray(rgb.get_data()) frame = rgb.copy() # Do instance segmentation start = time.time() segmentation, vis = visualizer.run_on_image(frame) #print("Time = " + str(time.time()-start)) cv2.imshow('Mask', vis) cv2.waitKey(1) # Get segmentation mask ori_label = segmentation['instances'].pred_masks.cpu().numpy() label = np.sum(ori_label, axis=0).astype(np.uint8) label = np.where(label != 0, 255, label) label = Image.fromarray(label).convert("L") label = np.asarray(label.convert('RGB')).astype(np.uint8) bboxes = segmentation['instances'].pred_boxes.tensor.cpu().numpy() xyxy_bboxes = bboxes bboxes = bbox_convert(bboxes) if len(bboxes) > 0: #depth_frames = frames.get_depth_frame() depth_frames = aligned_frames.get_depth_frame() video_profile = depth_frames.profile.as_video_stream_profile() intr = video_profile.get_intrinsics() depth = np.asanyarray(depth_frames.get_data()) #centers = segmentation['instances'].pred_boxes.get_centers() if len(my_t_pool) > 0: last_key = list(my_t_pool.keys())[-1] for i in range(0, len(bboxes)): bbox_xyxy = np.array(list(xyxy_bboxes[i])) bbox = list(bboxes[i]) print("Bounding Box:" + str(bbox)) #center = bboxes[i].get_centers() #center = centers[i].cpu().numpy() num_idx = float('nan') max_value = 0 label_of_object = ori_label[i].astype(np.uint8) label_of_object = np.where(label_of_object != 0, 255, label_of_object) label_of_object = Image.fromarray(label_of_object).convert("L") label_of_object = np.asarray( label_of_object.convert('RGB')).astype(np.uint8) if len(ref_frame_label) > 0: iou_list = [] b = bbox_xyxy a = np.array(ref_frame_axies) for k in range(len(ref_frame_axies)): iou = iou_score(a[k], b) iou_list.append(iou) iou_list = np.array(iou_list) max_value = iou_list.max() if (max_value > min_distance): min_idx = np.where(iou_list == max_value)[0][0] num_idx = ref_frame_label[min_idx] if (math.isnan(num_idx)): num_idx = label_cnt label_cnt += 1 cur_frame_label.append(num_idx) cur_frame_axies.append(bbox_xyxy) print(max_value) if (frameth == 1) or (max_value < 0.9) or ( i > len(my_t_pool[last_key]) - 1) or (frameth % 20 == 0): pos_text = (bbox[0], bbox[1]) class_id = segmentation['instances'].pred_classes[i].cpu( ).data.numpy() print("Class: " + str(class_id)) #idx = class_id if class_id == 0: idx = 0 if class_id == 2: idx = 1 model_points = model_points_list[idx] mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0)) #mask_label = ma.getmaskarray(ma.masked_equal(label, np.array(255))) mask_label = ma.getmaskarray( ma.masked_equal(label_of_object, np.array([255, 255, 255])))[:, :, 0] mask = mask_label * mask_depth rmin, rmax, cmin, cmax = posenet_deploy.get_bbox(bbox) # choose choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0] if len(choose) == 0: choose = torch.LongTensor([0]) if len(choose) > num_points: c_mask = np.zeros(len(choose), dtype=int) c_mask[:num_points] = 1 np.random.shuffle(c_mask) choose = choose[c_mask.nonzero()] else: choose = np.pad(choose, (0, num_points - len(choose)), 'wrap') depth_masked = depth[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype( np.float32) xmap_masked = xmap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype( np.float32) ymap_masked = ymap[ rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype( np.float32) choose = np.array([choose]) # point cloud pt2 = depth_masked / cam_scale pt0 = (ymap_masked - cam_cx) * pt2 / cam_fx pt1 = (xmap_masked - cam_cy) * pt2 / cam_fy cloud = np.concatenate((pt0, pt1, pt2), axis=1) cloud = cloud / 1000.0 # print(cloud.shape) # cropped img #img_masked = rgb[:, :, :3] img_masked = rgb[:, :, ::-1] # bgr to rgb img_masked = np.transpose(img_masked, (2, 0, 1)) img_masked = img_masked[:, rmin:rmax, cmin:cmax] my_mask = np.transpose(label_of_object, (2, 0, 1)) my_mask = my_mask[:, rmin:rmax, cmin: cmax] ## Added by me to crop the mask mask_img = np.transpose(my_mask, (1, 2, 0)) img_rgb = np.transpose(img_masked, (1, 2, 0)) croped_img_mask = cv2.bitwise_and(img_rgb, mask_img) crop_image_to_check = croped_img_mask.copy() cv2.imshow("mask_crop", croped_img_mask) croped_img_mask = np.transpose(croped_img_mask, (2, 0, 1)) # Variables cloud = torch.from_numpy(cloud.astype( np.float32)).unsqueeze(0) choose = torch.LongTensor(choose.astype( np.int32)).unsqueeze(0) #img_masked = torch.from_numpy(img_masked.astype(np.float32)).unsqueeze(0) img_masked = torch.from_numpy( croped_img_mask.astype(np.float32)).unsqueeze(0) index = torch.LongTensor([idx]).unsqueeze( 0) # Specify which object cloud = Variable(cloud).cuda() choose = Variable(choose).cuda() img_masked = Variable(img_masked).cuda() index = Variable(index).cuda() # Deploy with torch.no_grad(): pred_r, pred_t, pred_c, emb = estimator( img_masked, cloud, choose, index) pred_r = pred_r / torch.norm(pred_r, dim=2).view( 1, num_points, 1) pred_c = pred_c.view(bs, num_points) how_max, which_max = torch.max(pred_c, 1) pred_t = pred_t.view(bs * num_points, 1, 3) points = cloud.view(bs * num_points, 1, 3) my_r = pred_r[0][which_max[0]].view(-1).cpu().data.numpy() my_t = (points.view(bs * num_points, 1, 3) + pred_t)[which_max[0]].view(-1).cpu().data.numpy() my_pred = np.append(my_r, my_t) # Refinement for ite in range(0, iteration): T = Variable(torch.from_numpy(my_t.astype( np.float32))).cuda().view(1, 3).repeat( num_points, 1).contiguous().view(1, num_points, 3) my_mat = quaternion_matrix(my_r) R = Variable( torch.from_numpy(my_mat[:3, :3].astype( np.float32))).cuda().view(1, 3, 3) my_mat[0:3, 3] = my_t new_cloud = torch.bmm((cloud - T), R).contiguous() pred_r, pred_t = refiner(new_cloud, emb, index) pred_r = pred_r.view(1, 1, -1) pred_r = pred_r / (torch.norm(pred_r, dim=2).view( 1, 1, 1)) my_r_2 = pred_r.view(-1).cpu().data.numpy() my_t_2 = pred_t.view(-1).cpu().data.numpy() my_mat_2 = quaternion_matrix(my_r_2) my_mat_2[0:3, 3] = my_t_2 my_mat_final = np.dot(my_mat, my_mat_2) my_r_final = copy.deepcopy(my_mat_final) my_r_final[0:3, 3] = 0 my_r_final = quaternion_from_matrix(my_r_final, True) my_t_final = np.array([ my_mat_final[0][3], my_mat_final[1][3], my_mat_final[2][3] ]) my_pred = np.append(my_r_final, my_t_final) my_r = my_r_final my_t = my_t_final my_r_matrix = quaternion_matrix(my_r)[:3, :3] #print("Time = " + str(time.time()-start)) my_t_per_frame.append(my_t) my_r_per_frame.append(my_r_matrix) #rotation = Rot.from_matrix(my_r_matrix) #angle = rotation.as_euler('xyz', degrees=True) my_t = np.around(my_t, 5) #print("translation vector = " + str(my_t)) #print("rotation angles = " + str(my_r)) frame = posenet_deploy.get_3d_bbox(frame, model_points, my_r_matrix, my_t) frame = posenet_deploy.draw_axes(frame, my_r_matrix, my_t) if check_inverted(crop_image_to_check): cv2.putText(frame, str(num_idx) + "_inverted", pos_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA) else: cv2.putText(frame, str(num_idx), pos_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA) #cv2.putText(frame, str(num_idx), pos_text, cv2.FONT_HERSHEY_SIMPLEX, # 0.5, (0,255,0), 2, cv2.LINE_AA) posenet_deploy.putText(frame, i, num_idx, class_id, my_t) #cv2.imshow('Result', rgb) #cv2.waitKey(1) else: rmin, rmax, cmin, cmax = posenet_deploy.get_bbox(bbox) img_masked = rgb[:, :, ::-1] # bgr to rgb img_masked = np.transpose(img_masked, (2, 0, 1)) img_masked = img_masked[:, rmin:rmax, cmin:cmax] my_mask = np.transpose(label_of_object, (2, 0, 1)) my_mask = my_mask[:, rmin:rmax, cmin: cmax] ## Added by me to crop the mask mask_img = np.transpose(my_mask, (1, 2, 0)) img_rgb = np.transpose(img_masked, (1, 2, 0)) croped_img_mask = cv2.bitwise_and(img_rgb, mask_img) crop_image_to_check = croped_img_mask.copy() pos_text = (bbox[0], bbox[1]) last_key = list(my_t_pool.keys())[-1] print("POOL: " + str(my_t_pool[last_key])) class_id = segmentation['instances'].pred_classes[i].cpu( ).data.numpy() my_t = my_t_pool[last_key][min_idx] my_r_matrix = my_r_pool[last_key][min_idx] my_t_per_frame.append(my_t) my_r_per_frame.append(my_r_matrix) frame = posenet_deploy.get_3d_bbox(frame, model_points, my_r_matrix, my_t) frame = posenet_deploy.draw_axes(frame, my_r_matrix, my_t) if check_inverted(crop_image_to_check): cv2.putText(frame, str(num_idx) + "_inverted", pos_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA) else: cv2.putText(frame, str(num_idx), pos_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA) #cv2.putText(frame, str(num_idx), pos_text, cv2.FONT_HERSHEY_SIMPLEX, # 0.5, (0,255,0), 2, cv2.LINE_AA) posenet_deploy.putText(frame, i, num_idx, class_id, my_t) if len(my_t_per_frame) > 0: my_t_pool[frameth] = my_t_per_frame my_r_pool[frameth] = my_r_per_frame ref_frame_label = cur_frame_label ref_frame_axies = cur_frame_axies end = time.time() - start cv2.putText(frame, "Time processing: " + str(round(end, 3)) + " seconds", (100, 700), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA) cv2.imshow('Result', frame) cv2.waitKey(1) else: # Show images #video_writer.write(rgb) cv2.imshow('Result', rgb) cv2.waitKey(1) pipeline.stop()
def woa_normbias(data, v, cfg): """ FIXME: Move this procedure into a class to conform with the new system and include a limit in minimum ammount of samples to trust it. For example, consider as masked all climatologic values estimated from less than 5 samples. """ # 3 is the possible minimum to estimate the std, but I shold use higher. min_samples = 3 woa = None db = WOA() if v not in db.keys(): vtype = v[:-1] else: vtype = v # Temporary solution while I'm not ready to handle tracks. if ('LATITUDE' in data) and ('LONGITUDE' in data) \ and ('LATITUDE' not in data.attributes) \ and ('LONGITUDE' not in data.attributes): if 'datetime' in data.keys(): d = data['datetime'] elif ('datetime' in data.attributes): d0 = data.attributes['datetime'] if ('timeS' in data.keys()): d = [d0 + timedelta(seconds=s) for s in data['timeS']] else: d = [data.attributes['datetime']]*len(data['LATITUDE']), #woa = woa_track_from_file( # d, # data['LATITUDE'], # data['LONGITUDE'], # cfg['file'], # varnames=cfg['vars']) module_logger.error("Sorry, I'm temporary not ready to handle tracks.") #woa = db[vtype].get_track(var=['mean', 'standard_deviation'], # doy=d, # depth=[0], # lat=data['LATITUDE'], # lon=data['LONGITUDE']) elif ('LATITUDE' in data.attributes.keys()) and \ ('LONGITUDE' in data.attributes.keys()) and \ ('PRES' in data.keys()): woa = db[vtype].track( var=['mean', 'standard_deviation', 'number_of_observations'], doy=int(data.attributes['datetime'].strftime('%j')), depth=data['PRES'], lat=data.attributes['LATITUDE'], lon=data.attributes['LONGITUDE']) flag = np.zeros(data[v].shape, dtype='i1') features = {} try: woa_bias = data[v] - woa['mean'] woa_normbias = woa_bias / woa['standard_deviation'] ind = np.nonzero((woa['number_of_observations'] >= min_samples) & (np.absolute(woa_normbias) <= cfg['sigma_threshold'])) flag[ind] = 1 # cfg['flag_good'] ind = np.nonzero((woa['number_of_observations'] >= min_samples) & (np.absolute(woa_normbias) > cfg['sigma_threshold'])) flag[ind] = 3 # cfg['flag_bad'] # Flag as 9 any masked input value flag[ma.getmaskarray(data[v])] = 9 features = {'woa_bias': woa_bias, 'woa_normbias': woa_normbias, 'woa_std': woa['standard_deviation'], 'woa_nsamples': woa['number_of_observations'], 'woa_mean': woa['mean']} finally: # self.logger.warnning("%s - WOA is not available at this site" % # self.name) return flag, features
def _one_to_one_extract_surface_flag_only_local(doy, lat1, lat2, lon1, lon2, area_name): """ left-up: lat1 lon1 left-down: lat2 lon1 right-up: lat1 lon2 right-down: lat2 lon2 e.g. For United States http://en.wikipedia.org/wiki/Extreme_points_of_the_United_States#Westernmost :param lat1: 50 :param lat2: 24 :param lon1: -125 :param lon2: -66 """ flag_dic = { 0: "static_water_body_flag", 2: "coastal_mask_flag", 3: "urban_area_flag", 4: "precipitation_flag", 5: "snow_or_ice_flag", 6: "permanent_snow_or_ice_flag", 7: "frozen_ground_flag", 8: "frozen_ground_st_based", 9: "mountainous_terrain_flag", 10: "dense_vegetation_flag", 11: "edge_cell_flag", 12: "anomalous_sigma0_flag" } lat_indices, lon_indices = select_area(lat1, lat2, lon1, lon2, "M03") global_lats, global_lons = get_lat_lon("M03") assert (len(global_lats) != 0 and len(global_lons) != 0) in_path = os.path.join("n5eil01u.ecs.nsidc.org", "SMAP", "SPL2SMAP_S.002", doy) out_path = get_out_path( os.path.join("Data", "Sentinel", "surface_flags", area_name, doy)) for f in os.listdir(in_path): if f.endswith(".h5"): fh_in = Dataset(os.path.join(in_path, f), "r") group_3km = fh_in.groups["Soil_Moisture_Retrieval_Data_3km"] lat_start = group_3km.variables["EASE_row_index_3km"][0, 0] lat_end = group_3km.variables["EASE_row_index_3km"][-1, 0] lon_start = group_3km.variables["EASE_column_index_3km"][0, 0] lon_end = group_3km.variables["EASE_column_index_3km"][0, -1] if lat_end <= lat_indices[0] or lat_start >= lat_indices[1] \ or lon_end <= lon_indices[0] or lon_start >= lon_indices[1]: fh_in.close() continue print(f) lats = global_lats[lat_start:lat_end + 1] lons = global_lons[lon_start:lon_end + 1] fh_out = Dataset(os.path.join(out_path, f[:-3] + ".nc"), "w") fh_out.createDimension("lat", len(lats)) fh_out.createDimension("lon", len(lons)) for var_name in flag_dic.values(): outVar = fh_out.createVariable(var_name, 'u1', ( 'lat', 'lon', )) outVar.setncatts({'units': 'NA'}) outVar.setncatts({'_FillValue': np.array([255]).astype('u1')}) outVar[:] = ma.array( np.zeros((len(lats), len(lons))), mask=ma.getmaskarray( group_3km.variables["surface_flag_3km"][:])) for v_name, varin in group_3km.variables.items(): if v_name in ["latitude_3km", "longitude_3km"]: outVar = fh_out.createVariable(v_name[:3], varin.datatype, (v_name[:3])) outVar.setncatts( {k: varin.getncattr(k) for k in varin.ncattrs()}) elif v_name == "soil_moisture_3km": outVar = fh_out.createVariable(v_name[:-4], varin.datatype, ("lat", "lon")) outVar.setncatts( {k: varin.getncattr(k) for k in varin.ncattrs()}) outVar[:] = varin[:] fh_out.variables["lat"].setncatts({"lat_start": lat_start}) fh_out.variables["lat"].setncatts({"lat_end": lat_end}) fh_out.variables["lon"].setncatts({"lon_start": lon_start}) fh_out.variables["lon"].setncatts({"lon_end": lon_end}) fh_out.variables["lat"][:] = lats[:] fh_out.variables["lon"][:] = lons[:] surface_flag = group_3km.variables["surface_flag_3km"][:] surface_flag_mask = ma.getmaskarray( group_3km.variables["surface_flag_3km"][:]) for i in range(len(lats)): for j in range(len(lons)): if not surface_flag_mask[i, j]: bit_sf = '{0:016b}'.format(surface_flag[i, j])[::-1] for bit_index in flag_dic: if bit_sf[bit_index] == "1": fh_out.variables[flag_dic[bit_index]][i, j] = 1 fh_out.variables["anomalous_sigma0_flag"][:] = ma.array( fh_out.variables["anomalous_sigma0_flag"][:], mask=ma.getmaskarray( group_3km.variables["soil_moisture_3km"][:])) fh_out.variables["edge_cell_flag"][:] = ma.array( fh_out.variables["edge_cell_flag"][:], mask=ma.getmaskarray( group_3km.variables["soil_moisture_3km"][:])) fh_in.close() fh_out.close()