Python numpy.flipud() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def plot_spectra(results):
    plt.figure(figsize=(10, 4))
    plt.imshow(
        np.concatenate(
            [np.flipud(results['x'].T),
             np.flipud(results['xh'].T),
             np.flipud(results['x_conv'].T)],
            0),
        aspect='auto',
        cmap='jet',
    )
    plt.colorbar()
    plt.title('Upper: Real input; Mid: Reconstrution; Lower: Conversion to target.')
    plt.savefig(
        os.path.join(
            args.logdir,
            '{}.png'.format(
                os.path.split(str(results['f'], 'utf-8'))[-1]
            )
        )
    ) 

Example 2

def cochleagram_extractor(xx, sr, win_len, shift_len, channel_number, win_type):
    fcoefs, f = make_erb_filters(sr, channel_number, 50)
    fcoefs = np.flipud(fcoefs)
    xf = erb_frilter_bank(xx, fcoefs)

    if win_type == 'hanning':
        window = np.hanning(channel_number)
    elif win_type == 'hamming':
        window = np.hamming(channel_number)
    elif win_type == 'triangle':
        window = (1 - (np.abs(channel_number - 1 - 2 * np.arange(1, channel_number + 1, 1)) / (channel_number + 1)))
    else:
        window = np.ones(channel_number)
    window = window.reshape((channel_number, 1))

    xe = np.power(xf, 2.0)
    frames = 1 + ((np.size(xe, 1)-win_len) // shift_len)
    cochleagram = np.zeros((channel_number, frames))
    for i in range(frames):
        one_frame = np.multiply(xe[:, i*shift_len:i*shift_len+win_len], np.repeat(window, win_len, 1))
        cochleagram[:, i] = np.sqrt(np.mean(one_frame, 1))

    cochleagram = np.where(cochleagram == 0.0, np.finfo(float).eps, cochleagram)
    return cochleagram 

Example 3

def ssh():
    from random import randint, seed
    import pandas as pd
    import matplotlib.pyplot as plt

    seed(1)
    df = pd.DataFrame(pd.read_csv('ssh.csv', sep=';'))[:20000]
    y = df.value.as_matrix()
    y_raw = numpy.flipud(y)
    y = numpy.append(y_raw, y_raw)
    y = numpy.append(y, y_raw)
    for i in range(len(y)):
        y[i] += randint(-10, 10)
    for i in range(46100, 46120):
        y[i] += 100
        y[i] *= 10

    x = [i for i in range(0, len(y) * 2, 2)]
    series = list(zip(x, y))
    result = StddevAnomaly().search_anomaly({}, len(series), series)
    print(result)
    plt.plot(*zip(*series))
    plt.plot(*zip(*result), 'x')
    plt.show() 

Example 4

def _process(self, img, key=None):
        if self.p.fast:
            return self._fast_process(img, key)
        proj = self.p.projection
        if proj == img.crs:
            return img
        x0, x1 = img.range(0)
        y0, y1 = img.range(1)
        xn, yn = img.interface.shape(img, gridded=True)[:2]
        px0, py0, px1, py1 = project_extents((x0, y0, x1, y1),
                                             img.crs, proj)
        src_ext, trgt_ext = (x0, x1, y0, y1), (px0, px1, py0, py1)
        arrays = []
        for vd in img.vdims:
            arr = img.dimension_values(vd, flat=False)
            projected, extents = warp_array(arr, proj, img.crs, (xn, yn),
                                            src_ext, trgt_ext)
            arrays.append(projected)
        projected = np.dstack(arrays) if len(arrays) > 1 else arrays[0]
        data = np.flipud(projected)
        bounds = (extents[0], extents[2], extents[1], extents[3])
        return img.clone(data, bounds=bounds, kdims=img.kdims,
                         vdims=img.vdims, crs=proj) 

Example 5

def n_even_fcn(f, o, w, l):
    """Even case."""
    # Variables :
    k = np.array(range(0, int(l) + 1, 1)) + 0.5
    b = np.zeros(k.shape)

    # # Run Loop :
    for s in range(0, len(f), 2):
        m = (o[s + 1] - o[s]) / (f[s + 1] - f[s])
        b1 = o[s] - m * f[s]
        b = b + (m / (4 * np.pi * np.pi) * (np.cos(2 * np.pi * k * f[
            s + 1]) - np.cos(2 * np.pi * k * f[s])) / (
            k * k)) * abs(np.square(w[round((s + 1) / 2)]))
        b = b + (f[s + 1] * (m * f[s + 1] + b1) * np.sinc(2 * k * f[
            s + 1]) - f[s] * (m * f[s] + b1) * np.sinc(2 * k * f[s])) * abs(
            np.square(w[round((s + 1) / 2)]))

    a = (np.square(w[0])) * 4 * b
    h = 0.5 * np.concatenate((np.flipud(a), a))

    return h 

Example 6

def NevenFcn(F, M, W, L):  # N is even
    # Variables :
    k = np.array(range(0, int(L) + 1, 1)) + 0.5
    b = np.zeros(k.shape)

    # # Run Loop :
    for s in range(0, len(F), 2):
        m = (M[s + 1] - M[s]) / (F[s + 1] - F[s])
        b1 = M[s] - m * F[s]
        b = b + (m / (4 * np.pi * np.pi) * (np.cos(2 * np.pi * k * F[
            s + 1]) - np.cos(2 * np.pi * k * F[s])) / (
            k * k)) * abs(np.square(W[round((s + 1) / 2)]))
        b = b + (F[s + 1] * (m * F[s + 1] + b1) * np.sinc(2 * k * F[
          s + 1]) - F[s] * (m * F[s] + b1) * np.sinc(2 * k * F[s])) * abs(
            np.square(W[round((s + 1) / 2)]))

    a = (np.square(W[0])) * 4 * b
    h = 0.5 * np.concatenate((np.flipud(a), a))

    return h


####################################################################
# - Filt the signal :
#################################################################### 

Example 7

def plot_feature_importances(feature_importances, title, feature_names):
    # Normalize the importance values 
    feature_importances = 100.0 * (feature_importances / max(feature_importances))

    # Sort the values and flip them
    index_sorted = np.flipud(np.argsort(feature_importances))

    # Arrange the X ticks
    pos = np.arange(index_sorted.shape[0]) + 0.5

    # Plot the bar graph
    plt.figure()
    plt.bar(pos, feature_importances[index_sorted], align='center')
    plt.xticks(pos, feature_names[index_sorted])
    plt.ylabel('Relative Importance')
    plt.title(title)
    plt.show() 

Example 8

def generate_plot(self, filename, title='', xlabel='', ylabel=''):

        data_keys = list(self.data.keys())
        key_num = len(data_keys)

        self.plot = plt.figure()
        if key_num == 1:
            splt = self.plot.add_subplot(1, 1, 1)
            im_data = splt.imshow(numpy.flipud(self.data[data_keys[0]][0]), origin='lower')
            splt.set_xlabel(xlabel)
            splt.set_ylabel(ylabel)
            splt.set_title(title)
        else:   ## still plotting multiple image in one figure still has problem. the visualization is not good
            logger.error('no supported yet')

        self.plot.colorbar(im_data)
        self.plot.savefig(filename)  #, bbox_inches='tight'

#class MultipleLinesPlot(PlotWithData):
#    def generate_plot(self, filename, title='', xlabel='', ylabel=''): 

Example 9

def update(self):
        self._display_init()

        x1, x2 = self.update_x1, self.update_x2
        y1, y2 = self.update_y1, self.update_y2

        region = self.buffer[y1:y2, x1:x2]

        if self.v_flip:
            region = numpy.fliplr(region)

        if self.h_flip:
            region = numpy.flipud(region)

        buf_red = numpy.packbits(numpy.where(region == RED, 1, 0)).tolist()
        if self.inky_version == 1:
            buf_black = numpy.packbits(numpy.where(region == 0, 0, 1)).tolist()
        else:
            buf_black = numpy.packbits(numpy.where(region == BLACK, 0, 1)).tolist()

        self._display_update(buf_black, buf_red)
        self._display_fini() 

Example 10

def plot_dZ_contours(x, y, dZ, axes=None, dZ_interval=0.5, verbose=False,
                               fig_kwargs={}):
    r"""For plotting seafloor deformation dZ"""
    import matplotlib.pyplot as plt

    dZ_max = max(dZ.max(), -dZ.min()) + dZ_interval
    clines1 = numpy.arange(dZ_interval, dZ_max, dZ_interval)
    clines = list(-numpy.flipud(clines1)) + list(clines1)

    # Create axes if needed
    if axes is None:
        fig = plt.figure(**fig_kwargs)
        axes = fig.add_subplot(111)

    if len(clines) > 0:
        if verbose:
            print "Plotting contour lines at: ",clines
        axes.contour(x, y, dZ, clines, colors='k')
    else:
        print "No contours to plot"

    return axes 

Example 11

def plot_dZ_contours(x, y, dZ, axes=None, dZ_interval=0.5, verbose=False,
                               fig_kwargs={}):
    r"""For plotting seafloor deformation dZ"""
    import matplotlib.pyplot as plt

    dZ_max = max(dZ.max(), -dZ.min()) + dZ_interval
    clines1 = numpy.arange(dZ_interval, dZ_max, dZ_interval)
    clines = list(-numpy.flipud(clines1)) + list(clines1)

    # Create axes if needed
    if axes is None:
        fig = plt.figure(**fig_kwargs)
        axes = fig.add_subplot(111)

    if len(clines) > 0:
        if verbose:
            print "Plotting contour lines at: ",clines
        axes.contour(x, y, dZ, clines, colors='k')
    else:
        print "No contours to plot"

    return axes 

Example 12

def from_catmaid_stack(stack_info, tile_source_parameters):
        # See https://catmaid.readthedocs.io/en/stable/tile_sources.html
        format_url = {
            1: '{source_base_url}{{z}}/{{row}}_{{col}}_{{zoom_level}}.{file_extension}',
            4: '{source_base_url}{{z}}/{{zoom_level}}/{{row}}_{{col}}.{file_extension}',
            5: '{source_base_url}{{zoom_level}}/{{z}}/{{row}}/{{col}}.{file_extension}',
            7: '{source_base_url}largeDataTileSource/{tile_width}/{tile_height}/'
               '{{zoom_level}}/{{z}}/{{row}}/{{col}}.{file_extension}',
            9: '{source_base_url}{{z}}/{{row}}_{{col}}_{{zoom_level}}.{file_extension}',
        }[tile_source_parameters['tile_source_type']].format(**tile_source_parameters)
        bounds = np.flipud(np.array(stack_info['bounds'], dtype=np.int64))
        resolution = np.flipud(np.array(stack_info['resolution']))
        tile_width = int(tile_source_parameters['tile_width'])
        tile_height = int(tile_source_parameters['tile_height'])
        return ImageStackVolume(bounds, resolution, tile_width, tile_height, format_url,
                                missing_z=stack_info['broken_slices']) 

Example 13

def _apply_transformations(plot_config, data_slice):
    """Rotate, flip and zoom the data slice.

    Depending on the plot configuration, this will apply some transformations to the given data slice.

    Args:
        plot_config (mdt.visualization.maps.base.MapPlotConfig): the plot configuration
        data_slice (ndarray): the 2d slice of data to transform

    Returns:
        ndarray: the transformed 2d slice of data
    """
    if plot_config.rotate:
        data_slice = np.rot90(data_slice, plot_config.rotate // 90)

    if not plot_config.flipud:
        # by default we flipud to correct for matplotlib lower origin. If the user
        # sets flipud, we do not need to to it
        data_slice = np.flipud(data_slice)

    data_slice = plot_config.zoom.apply(data_slice)
    return data_slice 

Example 14

def __model_form(self, tri_array):
        w = np.nan_to_num(self.weights/tri_array[:,:,:-1]**(2-self.alpha))
        x = np.nan_to_num(tri_array[:,:,:-1]*(tri_array[:,:,1:]*0+1))
        y = np.nan_to_num(tri_array[:,:,1:])
        LDF = np.sum(w*x*y,axis=1)/np.sum(w*x*x,axis=1)
        #Chainladder (alpha=1/delta=1)
        #LDF = np.sum(np.nan_to_num(tri_array[:,:,1:]),axis=1) / np.sum(np.nan_to_num((tri_array[:,:,1:]*0+1)*tri_array[:,:,:-1]),axis=1)
        #print(LDF.shape)
        # assumes no tail
        CDF = np.append(np.cumprod(LDF[:,::-1],axis=1)[:,::-1],np.array([1]*tri_array.shape[0]).reshape(tri_array.shape[0],1),axis=1)    
        latest = np.flip(tri_array,axis=1).diagonal(axis1=1,axis2=2)   
        ults = latest*CDF
        lu = list(ults)
        lc = list(CDF)
        exp_cum_triangle = np.array([np.flipud(lu[num].reshape(tri_array.shape[2],1).dot(1/lc[num].reshape(1,tri_array.shape[2]))) for num in range(tri_array.shape[0])])
        exp_incr_triangle = np.append(exp_cum_triangle[:,:,0,np.newaxis],np.diff(exp_cum_triangle),axis=2)
        return LDF, CDF, ults, exp_incr_triangle 

Example 15

def ensurebuf(self, invalidate=True):
        if self.dbuf is None:
            if self.dpil is not None:
                self.dbuf = self.dpil.tostring("raw", "RGBX", 0, 1)
            elif self.darr is not None:
                data = self.scaledpixelarray(0,255.999)
                self.dbuf = np.dstack(( np.flipud(np.rollaxis(data,1)).astype(np.uint8),
                                        np.zeros(self.shape[::-1],np.uint8) )).tostring()
            else:
                raise ValueError("No source data for conversion to buffer")
        if invalidate:
            self.dpil = None
            self.darr = None
            self.rangearr = None

    ## This private function ensures that there is a valid numpy array representation, converting from
    #  one of the other representations if necessary, and invalidating the other representations if requested. 

Example 16

def ensurearr(self, invalidate=True):
        if self.darr is None:
            if self.dpil is not None:
                self.darr = np.fromstring(self.dpil.tostring("raw", "RGB", 0, -1), np.uint8).astype(np.float64)
                self.darr = np.rollaxis(np.reshape(self.darr, (self.shape[1], self.shape[0], 3) ), 1)
            elif self.dbuf is not None:
                self.darr = np.fromstring(self.dbuf, np.uint8).astype(np.float64)
                self.darr = np.delete(np.reshape(self.darr, (self.shape[1], self.shape[0], 4) ), 3, 2)
                self.darr = np.rollaxis(np.flipud(self.darr), 1)
            else:
                raise ValueError("No source data for conversion to array")
            self.rangearr = ( 0, 255.999 )
        if invalidate:
            self.dpil = None
            self.dbuf = None

# -----------------------------------------------------------------

## This private helper function returns a 2-tuple containing the least and most significant 16-bit portion
# of the specified unsigned 32-bit integer value. 

Example 17

def ensurebuf(self, invalidate=True):
        if self.dbuf is None:
            if self.dpil is not None:
                self.dbuf = self.dpil.tostring("raw", "RGBX", 0, 1)
            elif self.darr is not None:
                data = self.scaledpixelarray(0,255.999)
                self.dbuf = np.dstack(( np.flipud(np.rollaxis(data,1)).astype(np.uint8),
                                        np.zeros(self.shape[::-1],np.uint8) )).tostring()
            else:
                raise ValueError("No source data for conversion to buffer")
        if invalidate:
            self.dpil = None
            self.darr = None
            self.rangearr = None

    ## This private function ensures that there is a valid numpy array representation, converting from
    #  one of the other representations if necessary, and invalidating the other representations if requested. 

Example 18

def ensurearr(self, invalidate=True):
        if self.darr is None:
            if self.dpil is not None:
                self.darr = np.fromstring(self.dpil.tostring("raw", "RGB", 0, -1), np.uint8).astype(np.float64)
                self.darr = np.rollaxis(np.reshape(self.darr, (self.shape[1], self.shape[0], 3) ), 1)
            elif self.dbuf is not None:
                self.darr = np.fromstring(self.dbuf, np.uint8).astype(np.float64)
                self.darr = np.delete(np.reshape(self.darr, (self.shape[1], self.shape[0], 4) ), 3, 2)
                self.darr = np.rollaxis(np.flipud(self.darr), 1)
            else:
                raise ValueError("No source data for conversion to array")
            self.rangearr = ( 0, 255.999 )
        if invalidate:
            self.dpil = None
            self.dbuf = None

# -----------------------------------------------------------------

## This private helper function returns a 2-tuple containing the least and most significant 16-bit portion
# of the specified unsigned 32-bit integer value. 

Example 19

def get_historical_data(self, num_periods=200):
        gdax_client = gdax.PublicClient()

        end = datetime.datetime.utcnow()
        end_iso = end.isoformat()
        start = end - datetime.timedelta(seconds=(self.period_size * num_periods))
        start_iso = start.isoformat()

        ret = gdax_client.get_product_historic_rates(self.product, granularity=self.period_size, start=start_iso, end=end_iso)
        # Check if we got rate limited, which will return a JSON message
        while not isinstance(ret, list):
            time.sleep(3)
            ret = gdax_client.get_product_historic_rates(self.product, granularity=self.period_size, start=start_iso, end=end_iso)
        hist_data = np.array(ret, dtype='object')
        for row in hist_data:
            row[0] = datetime.datetime.fromtimestamp(row[0], pytz.utc)
        return np.flipud(hist_data) 

Example 20

def sliceImages(inputImage, targetImage):
    inputSlices = []
    targetSlices = []
    sliceSize = 32
    for y in range(0,inputImage.shape[1]//sliceSize):
        for x in range(0,inputImage.shape[0]//sliceSize):
            inputSlice = inputImage[x*sliceSize:(x+1)*sliceSize,y*sliceSize:(y+1)*sliceSize]
            targetSlice = targetImage[x*sliceSize//2:(x+1)*sliceSize//2,y*sliceSize//2:(y+1)*sliceSize//2]
            # only add slices if they're not just empty space
            # if (np.any(targetSlice)):
                # Reweight smaller sizes
                # for i in range(0,max(1,128//inputImage.shape[1])**2):
            inputSlices.append(inputSlice)
            targetSlices.append(targetSlice)
                # inputSlices.append(np.fliplr(inputSlice))
                # targetSlices.append(np.fliplr(targetSlice))
                # inputSlices.append(np.flipud(inputSlice))
                # targetSlices.append(np.flipud(targetSlice))

                    # naiveSlice = imresize(inputSlice, 0.5)
                    # deltaSlice = targetSlice - naiveSlice
                    # targetSlices.append(deltaSlice)
    # return two arrays of images in a tuple
    return (inputSlices, targetSlices) 

Example 21

def transform(patch, flip=False, mirror=False, rotations=[]):
    """Perform data augmentation on a patch.

    Args:
        patch (numpy array): The patch to be processed.
        flip (bool, optional): Up/down symetry.
        mirror (bool, optional): left/right symetry.
        rotations (int list, optional) : rotations to perform (angles in deg).

    Returns:
        array list: list of augmented patches
    """
    transformed_patches = [patch]
    for angle in rotations:
        transformed_patches.append(skimage.img_as_ubyte(skimage.transform.rotate(patch, angle)))
    if flip:
        transformed_patches.append(np.flipud(patch))
    if mirror:
        transformed_patches.append(np.fliplr(patch))
    return transformed_patches


# In[4]: 

Example 22

def transformData(self, data):
		if(self.opts.has_key('newdims')):
			(H, W) = self.opts['newdims']
			data = misc.imresize(data, (H, W), interp='bilinear')

		if(self.opts.has_key('zeromean') and self.opts['zeromean']):
			mean = self.opts['dataset_mean'] # provided by bmanager
			data = data - mean


		if(self.opts.has_key('rangescale') and self.opts['rangescale']):
			min_ = self.opts['dataset_min']  # provided by bmanager
			min_ = np.abs(min_.min())
			max_ = self.opts['dataset_max']  # provided by bmanager
			max_ = np.abs(max_.max())
			data = 127 * data / max(min_, max_)
		else:
			data = data - 127.0

		if(self.opts.has_key('randomflip') and self.opts['randomflip']):
			if(np.random.rand() <= self.opts['randomflip_prob']):
				data = np.flipud(data)
				self.dataflip_state = True

		return data 

Example 23

def write_pfm(data, fpath, scale=1, file_identifier="Pf", dtype="float32"):
    # PFM format definition: http://netpbm.sourceforge.net/doc/pfm.html

    data = np.flipud(data)
    height, width = np.shape(data)[:2]
    values = np.ndarray.flatten(np.asarray(data, dtype=dtype))
    endianess = data.dtype.byteorder

    if endianess == '<' or (endianess == '=' and sys.byteorder == 'little'):
        scale *= -1

    with open(fpath, 'wb') as ff:
        ff.write(file_identifier + '\n')
        ff.write('%d %d\n' % (width, height))
        ff.write('%d\n' % scale)
        ff.write(values) 

Example 24

def Gaussian2D(image, sigma, padding=0):
    n, m = image.shape[0], image.shape[1]
    tmp = np.zeros((n + padding, m + padding))
    if tmp.shape[0] < 4:
        raise ValueError('Image and padding too small')
    if tmp.shape[1] < 4:
        raise ValueError('Image and padding too small')
    B, A = __gausscoeff(sigma)
    tmp[:n, :m] = image
    tmp = lfilter(B, A, tmp, axis=0)
    tmp = np.flipud(tmp)
    tmp = lfilter(B, A, tmp, axis=0)
    tmp = np.flipud(tmp)
    tmp = lfilter(B, A, tmp, axis=1)
    tmp = np.fliplr(tmp)
    tmp = lfilter(B, A, tmp, axis=1)
    tmp = np.fliplr(tmp)
    return tmp[:n, :m]
#----------------------------------------------------------------------------- 

Example 25

def generate_plot(self, filename, title='', xlabel='', ylabel=''):

        data_keys = self.data.keys()
        key_num = len(data_keys)

        self.plot = plt.figure()
        if key_num == 1:   
            splt = self.plot.add_subplot(1, 1, 1)
            im_data = splt.imshow(numpy.flipud(self.data[data_keys[0]][0]), origin='lower')
            splt.set_xlabel(xlabel)
            splt.set_ylabel(ylabel)
            splt.set_title(title)
        else:   ## still plotting multiple image in one figure still has problem. the visualization is not good
            logger.error('no supported yet')

        self.plot.colorbar(im_data)
        self.plot.savefig(filename)  #, bbox_inches='tight'

#class MultipleLinesPlot(PlotWithData):
#    def generate_plot(self, filename, title='', xlabel='', ylabel=''): 

Example 26

def make_G_matrix(T,g):
    ''' create matrix of autoregression to enforce indicator dynamics
    Inputs: 
    T: positive integer
        number of time-bins
    g: nd.array, vector p x 1
        Discrete time constants
        
    Output:
    G: sparse diagonal matrix
        Matrix of autoregression
    '''    
    if type(g) is np.ndarray:    
        if len(g) == 1 and g < 0:
            g=0
    
#        gs=np.matrix(np.hstack((-np.flipud(g[:]).T,1)))
        gs=np.matrix(np.hstack((1,-(g[:]).T)))
        ones_=np.matrix(np.ones((T,1)))
        G = spdiags((ones_*gs).T,range(0,-len(g)-1,-1),T,T)    
        
        return G
    else:
        raise Exception('g must be an array')
#%% 

Example 27

def fits2jpg(fname):
    hdu_list = fits.open(fname)
    image = hdu_list[0].data
    image = np.squeeze(image)
    img = np.copy(image)
    idx = np.isnan(img)
    img[idx] = 0
    img_clip = np.flipud(img)
    sigma = 3.0
    # Estimate stats
    mean, median, std = sigma_clipped_stats(img_clip, sigma=sigma, iters=10)
    # Clip off n sigma points
    img_clip = clip(img_clip,std*sigma)
    if img_clip.shape[0] !=150 or img_clip.shape[1] !=150:
        img_clip = resize(img_clip, (150,150))
    #img_clip = rgb2gray(img_clip)
    
    outfile = fname[0:-5] +'.png'
    imsave(outfile, img_clip)
    return img_clip,outfile




# Do the fusion classification 

Example 28

def photonsToFrame(photonposframe,imagesize,background):
        pixels = imagesize
        edges = range(0, pixels+1)
            # HANDLE CASE FOR NO PHOTONS DETECTED AT ALL IN FRAME
        if photonposframe.size == 0:
            simframe = _np.zeros((pixels, pixels))
        else:
            xx = photonposframe[:, 0]
            yy = photonposframe[:, 1]

            simframe, xedges, yedges = _np.histogram2d(yy, xx, bins=(edges, edges))
            simframe = _np.flipud(simframe)  # to be consistent with render

        #simframenoise = noisy(simframe,background,noise)
        simframenoise = noisy_p(simframe, background)
        simframenoise[simframenoise > 2**16-1] = 2**16-1
        simframeout = _np.round(simframenoise).astype('<u2')

        return simframeout 

Example 29

def generate_plot(self, filename, title='', xlabel='', ylabel=''):

        data_keys = self.data.keys()
        key_num = len(data_keys)

        self.plot = plt.figure()
        if key_num == 1:   
            splt = self.plot.add_subplot(1, 1, 1)
            im_data = splt.imshow(numpy.flipud(self.data[data_keys[0]][0]), origin='lower')
            splt.set_xlabel(xlabel)
            splt.set_ylabel(ylabel)
            splt.set_title(title)
        else:   ## still plotting multiple image in one figure still has problem. the visualization is not good
            logger.error('no supported yet')

        self.plot.colorbar(im_data)
        self.plot.savefig(filename)  #, bbox_inches='tight'

#class MultipleLinesPlot(PlotWithData):
#    def generate_plot(self, filename, title='', xlabel='', ylabel=''): 

Example 30

def compute_tbl_properties(y, uMean, nu, flip):
    """Compute various parameters of a TBL."""

    y = y[np.nonzero(y)]
    uMean = uMean[np.nonzero(uMean)]

    if flip:
        y = np.flipud(y)
        uMean = np.flipud(uMean)

    theta = momentum_thickness(y, uMean)
    delta = delta_99(y, uMean)
    deltaStar = delta_star(y, uMean)
    uTau = np.sqrt(nu*uMean[1]/y[1])
    u0 = uMean[-1]
    yPlus1 = y[1]*uTau/nu

    return theta, deltaStar, delta, uTau, u0, yPlus1 

Example 31

def DST4(samples):
    """
        Method to create DST4 transformation using DST3

        Arguments   :
            samples : (1D Array) Input samples to be transformed

        Returns     :
            y       :  (1D Array) Transformed output samples

    """

    # Initialize
    samplesup=np.zeros(2*N, dtype = np.float32)

    # Upsample signal
    # Reverse order to obtain DST4 out of DCT4:
    #samplesup[1::2]=np.flipud(samples)
    samplesup[0::2] = samples
    y = spfft.dst(samplesup,type=3,norm='ortho')*np.sqrt(2)#/2

    # Flip sign of every 2nd subband to obtain DST4 out of DCT4
    #y=(y[0:N])*(((-1)*np.ones(N, dtype = np.float32))**range(N))

    return y[0: N] 

Example 32

def ha2Fa3d_fast(qmfwin,N):
	#usage: Fa=ha2Fa3d_fast(ha,N);
	#produces the analysis polyphase folding matrix Fa with all polyphase components
	#in 3D matrix representation
	#from a basband filter ha with
	#a cosine modulation
	#N: Blocklength
	#using a fast implementation (important for large N)
	#See my book chapter about "Filter Banks", cosine modulated filter banks.
	#Gerald Schuller
	#[email protected]
	#Jan-23-16

	Fa=np.zeros((N,N,overlap))
 	for m in range(overlap/2):
	   Fa[:,:,2*m]+=np.fliplr(np.diag(np.flipud(-qmfwin[m*2*N:(m*2*N+N/2)]*((-1)**m)),k=-N/2))
	   Fa[:,:,2*m]+=(np.diag(np.flipud(qmfwin[m*2*N+N/2:(m*2*N+N)]*((-1)**m)),k=N/2))
	   Fa[:,:,2*m+1]+=(np.diag(np.flipud(qmfwin[m*2*N+N:(m*2*N+1.5*N)]*((-1)**m)),k=-N/2))
	   Fa[:,:,2*m+1]+=np.fliplr(np.diag(np.flipud(qmfwin[m*2*N+1.5*N:(m*2*N+2*N)]*((-1)**m)),k=N/2))
	   #print -qmfwin[m*2*N:(m*2*N+N/2)]*((-1)**m)
	return Fa 

Example 33

def ha2Fa3d_fast(qmfwin,N):
	#usage: Fa=ha2Fa3d_fast(ha,N);
	#produces the analysis polyphase folding matrix Fa with all polyphase components
	#in 3D matrix representation
	#from a basband filter ha with
	#a cosine modulation
	#N: Blocklength
	#using a fast implementation (important for large N)
	#See my book chapter about "Filter Banks", cosine modulated filter banks.
	#Gerald Schuller
	#[email protected]
	#Jan-23-16

	Fa=np.zeros((N,N,overlap))
 	for m in range(overlap/2):
	   Fa[:,:,2*m]+=np.fliplr(np.diag(np.flipud(-qmfwin[m*2*N:(m*2*N+N/2)]*((-1)**m)),k=-N/2))
	   Fa[:,:,2*m]+=(np.diag(np.flipud(qmfwin[m*2*N+N/2:(m*2*N+N)]*((-1)**m)),k=N/2))
	   Fa[:,:,2*m+1]+=(np.diag(np.flipud(qmfwin[m*2*N+N:(m*2*N+1.5*N)]*((-1)**m)),k=-N/2))
	   Fa[:,:,2*m+1]+=np.fliplr(np.diag(np.flipud(qmfwin[m*2*N+1.5*N:(m*2*N+2*N)]*((-1)**m)),k=N/2))
	   #print -qmfwin[m*2*N:(m*2*N+N/2)]*((-1)**m)
	return Fa 

Example 34

def ha2Fa3d_sinmod_fast(qmfwin,N):
	#usage: Fa=ha2Fa3d_fast(ha,N);
	#produces the analysis polyphase folding matrix Fa with all polyphase components
	#in 3D matrix representation
	#from a basband filter ha with
	#a cosine modulation
	#N: Blocklength
	#using a fast implementation (important for large N)
	#See my book chapter about "Filter Banks", cosine modulated filter banks.
	#Gerald Schuller
	#[email protected]
	#Jan-29-16

	Fa=np.zeros((N,N,overlap))
 	for m in range(overlap/2):
	   Fa[:,:,2*m]+=np.fliplr(np.diag(np.flipud(qmfwin[m*2*N:(m*2*N+N/2)]*((-1)**m)),k=-N/2))
	   Fa[:,:,2*m]+=(np.diag(np.flipud(qmfwin[m*2*N+N/2:(m*2*N+N)]*((-1)**m)),k=N/2))
	   Fa[:,:,2*m+1]+=(np.diag(np.flipud(qmfwin[m*2*N+N:(m*2*N+1.5*N)]*((-1)**m)),k=-N/2))
	   Fa[:,:,2*m+1]+=np.fliplr(np.diag(np.flipud(-qmfwin[m*2*N+1.5*N:(m*2*N+2*N)]*((-1)**m)),k=N/2))
	   #print -qmfwin[m*2*N:(m*2*N+N/2)]*((-1)**m)
	return Fa 

Example 35

def _get_wordcloud(img, patch, words, word_to_frequency=None, **wordcloud_kwargs):

    # get the boolean mask corresponding to each patch
    path = patch.get_path()
    mask = path.contains_points(img.pixel_coordinates).reshape((img.y_resolution, img.x_resolution))

    # make mask matplotlib-venn compatible
    mask = (~mask * 255).astype(np.uint8) # black indicates mask position
    mask = np.flipud(mask) # origin is in upper left

    # create wordcloud
    wc = WordCloud(mask=mask,
                   background_color=None,
                   mode="RGBA",
                   **wordcloud_kwargs)

    if not word_to_frequency:
        text = " ".join(words)
        wc.generate(text)
    else:
        wc.generate_from_frequencies({word: word_to_frequency[word] for word in words})

    return wc 

Example 36

def autocorrelation(self):
        "Autocorrelation as a function of time"
        if self.__autocorrelation is not None:
            return self.__autocorrelationTimeSeries, self.__autocorrelation
        
        negT = -np.flipud(self.timeSeries[1:])
        autocorrelationTime = np.hstack((negT, self.timeSeries))
        self.__autocorrelationTimeSeries = autocorrelationTime
        
        initialWF = self[0]
        ACF = []
        for WF in self:
            ACF.append(WF.overlap(initialWF))
        ACF = np.array(ACF)
        negACF = np.conj(np.flipud(ACF[1:]))
        totalACF = np.hstack((negACF, ACF))
        self.__autocorrelation = totalACF
        return self.__autocorrelationTimeSeries, self.__autocorrelation 

Example 37

def _applyImageFlips(image, flips):
    '''
    Apply left-right and up-down flips to an image
    
    Args:
        image (numpy array 2D/3D): image to be flipped
        flips (tuple):
            [0]: Boolean to flip horizontally
            [1]: Boolean to flip vertically

    Returns:
        Flipped image
    '''
    image = np.fliplr(image) if flips[0] else image
    image = np.flipud(image) if flips[1] else image

    return image 

Example 38

def convolve1d_2D_numpy(a, b, mode='full'):
  nwords, ndim = a.shape
  filter_width, ndim = b.shape
  b = np.flipud(b)  # flip the kernel
  if mode == 'full':
    pad = np.zeros((filter_width-1, ndim))
    a = np.vstack([pad, a, pad])
    shape = (nwords+filter_width-1, filter_width, ndim)
  elif mode == 'valid':
    shape = (nwords-filter_width+1, filter_width, ndim)

  strides = (a.strides[0],) + a.strides
  view = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

  conv_out = np.einsum('kij,ij->kj', view, b)
  return conv_out 

Example 39

def convolve1d_2D_numpy(a, b, mode='full'):
  nwords, ndim = a.shape
  filter_width, ndim = b.shape
  b = np.flipud(b)  # flip the kernel
  if mode == 'full':
    pad = np.zeros((filter_width-1, ndim))
    a = np.vstack([pad, a, pad])
    shape = (nwords+filter_width-1, filter_width, ndim)
  elif mode == 'valid':
    shape = (nwords-filter_width+1, filter_width, ndim)

  strides = (a.strides[0],) + a.strides
  view = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

  conv_out = np.einsum('kij,ij->kj', view, b)
  return conv_out 

Example 40

def captureLabelImage(self, filename):
        view = self.view
        self.disableLighting()
        im = sgp.saveScreenshot(view, filename, shouldRender=False, shouldWrite=False)

        if filename is not None:
            img = vnp.getNumpyFromVtk(im, 'ImageScalars')
            assert img.dtype == np.uint8

            img.shape = (im.GetDimensions()[1], im.GetDimensions()[0], 3)
            img = np.flipud(img)

            img = img[:,:,0]
            print 'writing:', filename
            scipy.misc.imsave(filename, img)

        return im 

Example 41

def _plot_displacement(ms):
        if not plot:
            ms.down
            return

        import matplotlib.pyplot as plt
        from matplotlib.patches import Polygon
        fig = plt.figure()
        ax = fig.gca()
        ms.processSources()

        ax.imshow(num.flipud(ms.down), aspect='equal',
                  extent=[0, ms.frame.E.max(), 0, ms.frame.N.max()])
        for src in ms.sources:
            for seg in src.segments:
                p = Polygon(seg.outline(), alpha=.8, fill=False)
                ax.add_artist(p)
            if isinstance(src, OkadaPath):
                nodes = num.array(src.nodes)
                ax.scatter(nodes[:, 0], nodes[:, 1], color='r')
        plt.show()
        fig.clear() 

Example 42

def _plot_displacement(ms):
        if not plot:
            ms.down
            return

        import matplotlib.pyplot as plt
        from matplotlib.patches import Polygon  # noqa
        fig = plt.figure()
        ax = fig.gca()
        ms.processSources()

        ax.imshow(num.flipud(ms.north), aspect='equal',
                  extent=[0, ms.frame.E.max(), 0, ms.frame.N.max()])
        # for src in ms.sources:
        #     for seg in src.segments:
        #         p = Polygon(seg.outline(), alpha=.8, fill=False)
        #         ax.add_artist(p)
        plt.show()
        fig.clear() 

Example 43

def img_reshape(input_img):
    """ (3, 64, 64) --> (64, 64, 3) """
    _img = np.transpose(input_img, (1, 2, 0))
    _img = np.flipud(_img)
    _img = np.reshape(_img, (1, img_dim[0], img_dim[1], img_dim[2]))
    return _img 

Example 44

def flip_plane(array,plane=0):
    # Flip axial plane LR, i.e. change left/right hemispheres. 3D tensors-only, batch_size=1.
    # n_slices = array.shape[2]
    # for i in range(n_slices):
    #     array[:,:,i] = np.flipud(array[:,:,i])
    # return array
    n_x = array.shape[plane]
    for i in range(n_x):
        if plane == 0:
            array[i,:,:] = np.flipud(array[i,:,:])
        if plane == 1:
            array[:,i,:] = np.flipud(array[:,i,:])
        if plane == 2:
            array[:,:,i] = np.flipud(array[:,:,i])
    return array 

Example 45

def _trim_silence(self, audio: ndarray) -> ndarray:
        def trim_start(sound: ndarray) -> ndarray:
            return numpy.array(list(dropwhile(lambda x: x < self.silence_threshold_for_not_normalized_sound, sound)))

        def trim_end(sound: ndarray) -> ndarray:
            return flipud(trim_start(flipud(sound)))

        return trim_start(trim_end(audio)) 

Example 46

def write_SSR_IRs(filename, time_data_l, time_data_r, wavformat="float"):
    """Takes two time signals and writes out the horizontal plane as HRIRs for the SoundScapeRenderer.
    Ideally, both hold 360 IRs but smaller sets are tried to be scaled up using repeat.

    Parameters
    ----------
    filename : string
       filename to write to
    time_data_l, time_data_l : io.ArraySignal
       ArraySignals for left/right ear
    wavformat : string
       wav file format to write. Either "float" or "int16"
    """
    equator_IDX_left = utils.nearest_to_value_logical_IDX(time_data_l.grid.colatitude, _np.pi / 2)
    equator_IDX_right = utils.nearest_to_value_logical_IDX(time_data_r.grid.colatitude, _np.pi / 2)

    IRs_left = time_data_l.signal.signal[equator_IDX_left]
    IRs_right = time_data_r.signal.signal[equator_IDX_right]

    if _np.mod(360 / IRs_left.shape[0], 1) == 0:
        IRs_left = _np.repeat(IRs_left, 360 / IRs_left.shape[0], axis=0)
    else:
        raise ValueError('Number of channels for left ear cannot be fit into 360.')
    if _np.mod(360 / IRs_right.shape[0], 1) == 0:
        IRs_right = _np.repeat(IRs_right, 360 / IRs_right.shape[0], axis=0)
    else:
        raise ValueError('Number of channels for left ear cannot be fit into 360.')

    IRs_to_write = utils.interleave_channels(IRs_left, IRs_right, style="SSR")
    data_to_write = utils.simple_resample(IRs_to_write, original_fs=time_data_l.signal.fs, target_fs=44100)

    # Fix SSR IR alignment stuff: left<>right flipped and 90 degree rotation
    data_to_write = _np.flipud(data_to_write)
    data_to_write = _np.roll(data_to_write, -90, axis=0)

    if wavformat == "float":
        sio.wavfile.write(filename, 44100, data_to_write.astype(_np.float32).T)
    elif wavformat == "int16":
        sio.wavfile.write(filename, 44100, (data_to_write * 32767).astype(_np.int16).T)
    else:
        raise TypeError("Format " + wavformat + "not known. Should be either 'float' or 'int16'.") 

Example 47

def parsedata(self, package):
        """
            This function parses the Data Package sent by MuLES to obtain all the data 
            available in MuLES as matrix of the size [n_samples, n_columns], therefore the
            total of elements in the matrix is n_samples * n_columns. Each column represents
            one channel
            
            Argument:
            package: Data package sent by MuLES.
        """
        size_element = 4           # Size of each one of the elements is 4 bytes

        n_columns = len(self.params['data format'])
        n_bytes = len(package)
        n_samples = (n_bytes/size_element) / n_columns
        ####mesData = np.uint8(mesData) # Convert from binary to integers (not necessary pyton)
        
        bytes_per_element = np.flipud(np.reshape(list(bytearray(package)), [size_element,-1],order='F'))
        # Changes "package" to a list with size (n_bytes,1) 
        # Reshapes the list into a matrix bytes_per_element which has the size: (4,n_bytes/4)
        # Flips Up-Down the matrix of size (4,n_bytes/4) to correct the swap in bytes    
                
        package_correct_order = np.uint8(np.reshape(bytes_per_element,[n_bytes,-1],order='F' ))
        # Unrolls the matrix bytes_per_element, in "package_correct_order" 
        # that has a size (n_bytes,1) 
             
        data_format_tags = self.params['data format']*n_samples
        # Tags used to map the elements into their corresponding representation
        package_correct_order_char = "".join(map(chr,package_correct_order))
            
        elements = struct.unpack(data_format_tags,package_correct_order_char)
        # Elements are cast in their corresponding representation
        data = np.reshape(np.array(elements),[n_samples,n_columns],order='C')
        # Elements are reshap into data [n_samples, n_columns]        
        
        return data 

Example 48

def display_current_results(self, visuals, epoch):
        if self.display_id > 0: # show images in the browser
            idx = 1
            for label, image_numpy in visuals.items():
                #image_numpy = np.flipud(image_numpy)
                self.vis.image(image_numpy.transpose([2,0,1]), opts=dict(title=label),
                                   win=self.display_id + idx)
                idx += 1

        if self.use_html: # save images to a html file
            for label, image_numpy in visuals.items():
                img_path = os.path.join(self.img_dir, 'epoch%.3d_%s.png' % (epoch, label))
                util.save_image(image_numpy, img_path)
            # update website
            webpage = html.HTML(self.web_dir, 'Experiment name = %s' % self.name, reflesh=1)
            for n in range(epoch, 0, -1):
                webpage.add_header('epoch [%d]' % n)
                ims = []
                txts = []
                links = []

                for label, image_numpy in visuals.items():
                    img_path = 'epoch%.3d_%s.png' % (n, label)
                    ims.append(img_path)
                    txts.append(label)
                    links.append(img_path)
                webpage.add_images(ims, txts, links, width=self.win_size)
            webpage.save()

    # errors: dictionary of error labels and values 

Example 49

def mirrorArray(self, x, direction="x"):
        X = x.reshape((self.nx_core, self.ny_core), order="F")
        if direction == "x" or direction == "y" :
            X2 = np.vstack((-np.flipud(X), X))
        else:
            X2 = np.vstack((np.flipud(X), X))
        return X2 

Example 50

def mirrorArray(self, x, direction="x"):
        X = x.reshape((self.nx_core, self.ny_core), order="F")
        if direction == "x" or direction == "y" :
            X2 = np.vstack((-np.flipud(X), X))
        else:
            X2 = np.vstack((np.flipud(X), X))
        return X2 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注