Exemplo n.º 1
1
    def test_convolve2d_king(self):
        
        gfn = lambda r, s: np.power(2*np.pi*s**2,-1)*np.exp(-r**2/(2*s**2))
        kfn = lambda r, s, g: np.power(2*np.pi*s**2,-1)*(1.-1./g)* \
            np.power(1+0.5/g*(r/s)**2,-g)

        kfn0 = lambda x, y, mux, muy, s, g: kfn(np.sqrt((x-mux)**2+(y-muy)**2),s,g)

        xaxis = Axis.create(-3,3,501)
        yaxis = Axis.create(-3,3,501)

        x, y = np.meshgrid(xaxis.center,yaxis.center)
        xbin, ybin = np.meshgrid(xaxis.width,yaxis.width)

        r = np.sqrt(x**2+y**2)

        # Scalar Input

        mux = 0.5
        muy = -0.2
        mur = (mux**2+muy**2)**0.5

        gsig = 0.1
        ksig = 0.2
        kgam = 4.0

        fval0 = np.sum(kfn0(x,y,mux,muy,ksig,kgam)*gfn(r,gsig)*xbin*ybin)
        fval1 = convolve2d_king(lambda t: gfn(t,gsig),mur,ksig,kgam,3.0,
                                nstep=10000)
#        fval2 = convolve2d_gauss(lambda t: kfn(t,ksig,kgam),mur,gsig,3.0,
#                                 nstep=1000)
#        print fval0, fval1, fval2, fval1/fval0

        assert_almost_equal(fval0,fval1,4)
Exemplo n.º 2
0
    def __init__(self, Lx=600.0, Ly=600.0, nx=31, ny=31, dt=0.2, epsilon=0.02, h0=10.0, t0=0.0):
        """Initialization with grid parameters and initial conditions"""
        # store the parameters
        self.Lx, self.Ly = float(Lx), float(Ly)
        self.nx, self.ny = nx, ny
        self.dt = float(dt)
        self.dx = self.Lx / (self.nx - 1)
        self.dy = self.Ly / (self.ny - 1)
        self.h0 = h0
        self.epsilon = float(epsilon)
        self.t0 = float(t0)
        self.t = float(t0)
        self.i = 0

        # make axes
        self.xeta = np.linspace(0, self.Lx, self.nx)
        self.yeta = np.linspace(0, self.Ly, self.ny)
        self.xxeta, self.yyeta = np.meshgrid(self.xeta, self.yeta)
        self.xu = self.xeta + self.dx / 2.0
        self.yu = self.yeta + self.dy / 2.0
        self.xxu, self.yyu = np.meshgrid(self.xu, self.yu)

        # initialize the arrays
        shape = np.array((nx, ny)) + 2
        self.uold = np.zeros(shape)
        self.vold = np.zeros(shape)
        self.unew = np.zeros(shape)
        self.vnew = np.zeros(shape)
        self.etaold = np.zeros(shape)
        self.etaint = np.zeros(shape)
        self.etanew = np.zeros(shape)
        self.h = np.ones(shape, dtype=float) * h0

        self.gridargs = (self.nx, self.ny, self.dx, self.dy, self.dt)
def allowed_region( V_nj, ave_j ):

    # read PCs
    PC1 = V_nj[0]
    PC2 = V_nj[1]
    n_band = len( PC1 )
    band_ticks = np.arange( n_band )

    x_ticks = np.linspace(-0.4,0.2,RESOLUTION)
    y_ticks = np.linspace(-0.2,0.4,RESOLUTION)
    x_mesh, y_mesh, band_mesh = np.meshgrid( x_ticks, y_ticks, band_ticks, indexing='ij' )
    vec_mesh = x_mesh * PC1[ band_mesh ] + y_mesh * PC2[ band_mesh ] + ave_j[ band_mesh ]

    x_grid, y_grid = np.meshgrid( x_ticks, y_ticks, indexing='ij' )
    prohibited_grid = np.zeros_like( x_grid )

    for ii in xrange( len( x_ticks ) ) :
        for jj in xrange( len( y_ticks ) ) :

            if np.any( vec_mesh[ii][jj] < 0. ) :
                prohibited_grid[ii][jj] = 1
                if np.any( vec_mesh[ii][jj] > 1. ) :
                    prohibited_grid[ii][jj] = 3
            elif np.any( vec_mesh[ii][jj] > 1. ) :
                prohibited_grid[ii][jj] = 2
            else :
                prohibited_grid[ii][jj] = 0

    return x_grid, y_grid, prohibited_grid
Exemplo n.º 4
0
def test_kernel_error():
    """

    """
    for xx2d in [np.array(np.meshgrid(np.arange(-100, 100, 5),
                                      np.arange(-100, 100, 5))),

                 np.array(np.meshgrid(np.arange(-100, 100, 5),
                                      np.arange(-100, 100, 5))).reshape(2, -1)]:

        mean1 = [20, 20]
        sigma1 = [10, 10]
        params1 = np.hstack([mean1, sigma1])
        mean2 = [30, 40]
        sigma2 = [10, 50]
        params2 = np.hstack([mean2, sigma2])

        params = [params1, params2]
        betas = [0.3, 0.7]
        
        y = ebp.mixture_of_kernels(xx2d, betas, params,
                                   ebp.gaussian_kernel)

        err = ebp.kernel_err(y, xx2d, betas, params, ebp.gaussian_kernel)

        npt.assert_almost_equal(err, np.zeros(err.shape))
Exemplo n.º 5
0
 def get_gauss_points(self, ng):
     if isinstance(ng, int):
         return self.gauss_points.get(ng)
     elif isinstance(ng, list):
         if len(ng) > 3:
             raise Exception('Gauss points for 4 dimensions' +
                     'and above not supported')
         if len(ng) == 2:
             Xi1, W1 = self.get_gauss_points(ng[0])
             Xi2, W2 = self.get_gauss_points(ng[1])
             Xi1g, Xi2g = numpy.meshgrid(Xi1.flatten(), Xi2.flatten())
             Xi1 = numpy.array([Xi1g.flatten(), Xi2g.flatten()]).T
             W1g, W2g = numpy.meshgrid(W1.flatten(), W2.flatten())
             W1 = W1g.flatten() * W2g.flatten()
             return Xi1, W1
         elif len(ng) == 3:
             Xi1, W1 = self.get_gauss_points(ng[0])
             Xi2, W2 = self.get_gauss_points(ng[1])
             Xi3, W3 = self.get_gauss_points(ng[2])
             gindex = numpy.mgrid[0:ng[0], 0:ng[1], 0:ng[2]]
             gindex = numpy.array([
                 gindex[2, :, :].flatten(),
                 gindex[1, :, :].flatten(),
                 gindex[0, :, :].flatten()]).T
             Xi = numpy.array([
                 Xi1[gindex[:,0]], Xi2[gindex[:,1]], Xi3[gindex[:,2]]])[:,:,0].T
             W = numpy.array([
                 W1[gindex[:,0]], W2[gindex[:,1]], W3[gindex[:,2,]]]).T.prod(1)
             return Xi, W
         
     raise Exception('Invalid number of gauss points')
     return None, None    
Exemplo n.º 6
0
def getBoxbyX(X, grid=50, padding=True):
    '''
    Get the meshgrid X,Y given data set X
    :param X: dataset
    :param grid: meshgrid step size
    :param padding: if add extra padding around
    :return: X,Y
    '''
    if X.shape[1] > 2:
        print 'We can only get the grid in 2-d dimension!'
        return None
    else:
        minx = min(X[:,0])
        maxx = max(X[:,0])
        miny = min(X[:,1])
        maxy = max(X[:,1])
        padding_x = 0.05*(maxx-minx)
        padding_y = 0.05*(maxy-miny)
        if padding:
            X,Y = np.meshgrid(np.linspace(minx-padding_x, maxx+padding_x, grid), 
                              np.linspace(miny-padding_y, maxy+padding_y, grid))
        else:
            X,Y = np.meshgrid(np.linspace(minx, maxx, grid), 
                              np.linspace(miny, maxy, grid))
    return (X, Y)
Exemplo n.º 7
0
	def logLikelihood(self, data):
		assert self.numImages == data.numImages

		which = [np.nonzero(data.id == i)[0]\
				for i in xrange(0, self.numImages)]

		# Mean vector
		m = np.empty(data.t.size)
		for i in xrange(0, self.numImages):
			m[which[i]] = self.mag[i]

		# Covariance matrix
		[t1, t2] = np.meshgrid(data.t, data.t)
		lags = np.abs(t2 - t1)
		plt.imshow(lags)
		plt.show()
		ids = np.meshgrid(data.id, data.id)


		equal = ids[0] == ids[1]

##		try:
##			L = la.cholesky(C)
##		except:
##			return -np.inf
#		y = data.y - m
#		logDeterminant = 2.0*np.sum(np.log(np.diag(L)))
#		solution = la.cho_solve((L, True), y)
#		exponent = np.dot(y, solution)
#		logL = -0.5*data.t.size*np.log(2.0*np.pi) - 0.5*logDeterminant - 0.5*exponent
		return 0.
def makePathAndGrid(data, xsteps, ysteps, x_col='x_m', y_col='y_m'):
    x = data[x_col]
    y = data[y_col]

    xmin = min(x)
    xmax = max(x)
    ymin = min(y)
    ymax = max(y)

    # make grid
    dx = (xmax - xmin)/xsteps
    dy = (ymax - ymin)/ysteps
    XXraw, YYraw = np.meshgrid(np.arange(xmin, xmax, dx) + dx/2, np.arange(ymin, ymax, dy) + dy/2)

    x = ((x - xmin)/(xmax-xmin) * xsteps).astype(int)
    y = ((y - ymin)/(ymax-ymin) * ysteps).astype(int)

    xx = np.arange(0, xsteps)
    yy = np.arange(0, ysteps)

    M = np.zeros((len(xx),len(yy)))

    N = len(xx) * len(yy)
    idx = np.arange(N)
    np.random.shuffle(idx)
    XX, YY = np.meshgrid(xx, yy)

    XX = XX.reshape(N)
    YY = YY.reshape(N)
    XXraw = XXraw.reshape(N)
    YYraw = YYraw.reshape(N)

    return idx, np.c_[XXraw, YYraw].T, np.c_[XX, YY].T, M
  def check_cross_amplification(self, max_dist):
    pop_set = set()
    for pos in self.pairs_pos:
      p1,p2 = pos

      c1,a1,s1 = zip(*self.alignments_dict[p1])
      c2,a2,s2 = zip(*self.alignments_dict[p2])
     
      chrs_x, chrs_y = na.meshgrid(c1, c2)
      chrs_eq = chrs_x==chrs_y
    
      orient_x,orient_y = na.meshgrid(s1, s2)
      orient_fr = orient_x==na.logical_not(orient_y)
    
      pos_x,pos_y = na.meshgrid(a1, a2)
    
      # Filter by minimum distance.
      # And if orientation is forward/reverse
      # Amps is [Alignments i X Alignments j ]
      amps = na.logical_and(na.logical_and(na.abs(pos_x-pos_y)<max_dist, 
                      na.logical_and(orient_fr, pos_x<pos_y)), # Forward reverse if one position is less than the other and is forward, while the other is reverse              
              chrs_eq)
      number_of_amps = na.sum(amps)
      #assert number_of_amps!=0
      if number_of_amps>1:
        pop_set.add(pos)
        
    self.pairs_pos.difference_update(pop_set)
Exemplo n.º 10
0
def P1(mode="a"):
    if mode=="a":
        fig = plt.figure()
        for N,p in [(8,221),(16,222),(32,223),(64,224)]:
            u = OneD(0.035,2.5,60,20,20,N,0.01,5)
            x = [i*2.5/N for i in range(N)]
            y = [j*0.01 for j in range(int(5/0.01))]
            X,Y = np.meshgrid(x,y)
            ax = fig.add_subplot(p, projection='3d')
            surf = ax.plot_surface(X,Y,u,rstride=1, cstride=1,linewidth=0, cmap=cm.coolwarm)
            ax.set_zlim(20,60.01)
            ax.set_xlabel('X Position (cm)')
            ax.set_ylabel('Time (s)')
            ax.set_zlabel('Temperature (C)')
            ax.set_title('N='+str(N))
            fig.colorbar(surf,ticks=[t for t in range(20,61,5)])
        plt.show()
    if mode == "b":
        fig = plt.figure()
        for t,p in [(0.001,221),(0.01,222),(0.1,223)]:
            u = OneD(0.035,2.5,60,20,20,32,t,5)
            x = [i*2.5/32 for i in range(32)]
            y = [j*t for j in range(int(5/t))]
            X,Y = np.meshgrid(x,y)
            ax = fig.add_subplot(p, projection='3d')
            surf = ax.plot_surface(X,Y,u,rstride=1, cstride=1,linewidth=0, cmap=cm.coolwarm)
            if t!=0.1:
                ax.set_zlim(20,60.01)
            ax.set_xlabel('X Position (cm)')
            ax.set_ylabel('Time (s)')
            ax.set_zlabel('Temperature (C)')
            ax.set_title('Timestep:'+str(t))
            if t != 0.1:
                fig.colorbar(surf,ticks=[t for t in range(20,61,5)])
        plt.show()
Exemplo n.º 11
0
def polyval2d_general(c, x, y, function="polynomial", minx=None, maxx=None, miny=None, maxy=None):
    if function == "polynomial":
        xx, yy = np.meshgrid(x, y)
        return np.polynomial.polynomial.polyval2d(xx, yy, c)
    elif function in ["legendre", "chebyshev"]:
        # Scale x-direction
        if minx is None or maxx is None:
            if np.size(x) == 1:
                xmin, xmax = -1.0, 1.0
            else:
                xmin, xmax = np.min(x), np.max(x)
        else:
            xmin, xmax = minx, maxx
        xv = 2.0 * (x-xmin)/(xmax-xmin) - 1.0
        # Scale y-direction
        if miny is None or maxy is None:
            if np.size(y) == 1:
                ymin, ymax = -1.0, 1.0
            else:
                ymin, ymax = np.min(y), np.max(y)
        else:
            ymin, ymax = miny, maxy
        yv = 2.0 * (y-ymin)/(ymax-ymin) - 1.0
        xx, yy = np.meshgrid(xv, yv)
        if function == "legendre":
            return np.polynomial.legendre.legval2d(xx, yy, c)
        elif function == "chebyshev":
            return np.polynomial.chebyshev.chebval2d(xx, yy, c)
    else:
        msgs.error("Function {0:s} has not yet been implemented".format(function))
    return None
Exemplo n.º 12
0
 def _calc_partials(self):
     """Calculate the partial derivatives
     
     Uses sympy.utilities.lambdify to convert equation into
     a function that can be easily computed.
     
     Raises:
       MissingEquationError: if method is called before equation is
         attached.
     """
     if not self.equation:
         raise self.MissingEquationError('No equation attached')
     
     x, y = sympy.symbols('x,y')
     compute_func = sympy.utilities.lambdify((x, y), self.equation)
     X, Y = np.meshgrid(self.xrange, self.yrange)
     DX, DY = np.meshgrid(np.zeros(len(self.xrange)),
                          np.zeros(len(self.yrange)))
     
     # Iterate through grid and compute function value at each point
     # If value cannot be computed, default to 0
     # If value can be computed, scale by sqrt of the magnitude
     for i, a in enumerate(self.xrange):
         for j, b in enumerate(self.yrange):
             dx = 1
             try:
                 dy = compute_func(a, b)
                 n = sqrt(dx**2 + dy**2)
                 dy /= sqrt(n)
                 dx /= sqrt(n)
                 DX[j][i] = dx
                 DY[j][i] = dy
             except (ValueError, ZeroDivisionError):
                 pass
     return X, Y, DX, DY
Exemplo n.º 13
0
def mask_polar_to_cart(mask, center, min_radius, max_radius, output_shape, zoom_factor=1):
    '''Converts a polar binary mask to Cartesian and places in an image of zeros'''

    # Account for upsampling
    if zoom_factor != 1:
        center = (center[0]*zoom_factor + zoom_factor/2, center[1]*zoom_factor + zoom_factor/2)
        min_radius = min_radius * zoom_factor
        max_radius = max_radius * zoom_factor
        output_shape = map(lambda a: a * zoom_factor, output_shape)

    # new image
    image = np.zeros(output_shape)

    # coordinate conversion
    theta, r = np.meshgrid(np.linspace(0, 2*np.pi, mask.shape[1]),
                           np.arange(0, max_radius))
    x, y = coord_polar_to_cart(r, theta, center)
    x, y = np.round(x), np.round(y)
    x, y = x.astype(int), y.astype(int)

    x = np.clip(x, 0, image.shape[0]-1)
    y = np.clip(y, 0, image.shape[1]-1)
    ix,iy = np.meshgrid(np.arange(0,mask.shape[1]), np.arange(0,mask.shape[0]))
    image[x,y] = mask

    # downsample image
    if zoom_factor != 1:
        zf = 1/float(zoom_factor)
        image = zoom(image, (zf, zf), order=4)

    # ensure image remains a filled binary mask
    image = (image > 0.5).astype(int)
    image = binary_fill_holes(image)
    return image
Exemplo n.º 14
0
def stmDatToArray(filename):
    with open(filename, 'r') as f:
        f.readline()
        delta = []
        for i in range(2):
            line = map(float, [entry for entry in f.readline().strip().split(' ') if entry!=''][:2])
            delta.append(line)

        shape = [entry for entry in f.readline().strip().split(' ') if len(entry)!=0]
        shape = map(int, shape[:2])

        arrays = []
        xm, ym = [delta[i][0] + np.arange(shape[i])*delta[i][1] for i in range(2)]
        xo, yo = [delta[i][0] - 0.5*delta[i][1]+ np.arange(shape[i] + 1)*delta[i][1] for i in range(2)]

        Xm, Ym = np.meshgrid(xm, ym)
        Xo, Yo = np.meshgrid(xo, yo)

        collect = []
        for line in f:
            try:
                line = [entry for entry in line.strip().split(' ') if len(entry)>0]
                line = map(float, line)
            except ValueError:
                break
            else:
                collect.extend(line)

        Z = np.reshape(collect, shape)

        return Xm, Ym, Z
Exemplo n.º 15
0
    def test_get_decomposition(self):
        # Test a stable entry to ensure that it's zero in the stable region
        entry = self.test_data['Zn'][12] # Should correspond to mp-2133
        self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, 10, 1),
                               0.0, 5, "Decomposition energy of ZnO is not 0.")

        # Test an unstable entry to ensure that it's never zero
        entry = self.test_data['Zn'][11]
        ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-2, 4))
        result = self.pbx_nofilter.get_decomposition_energy(entry, ph, v)
        self.assertTrue((result >= 0).all(),
                        "Unstable energy has hull energy of 0 or less")

        # Test an unstable hydride to ensure HER correction works
        self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, -3, -2),
                               11.093744395)
        # Test a list of pHs
        self.pbx.get_decomposition_energy(entry, np.linspace(0, 2, 5), 2)

        # Test a list of Vs
        self.pbx.get_decomposition_energy(entry, 4, np.linspace(-3, 3, 10))

        # Test a set of matching arrays
        ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-3, 3))
        self.pbx.get_decomposition_energy(entry, ph, v)
Exemplo n.º 16
0
def find_intersections(contour1, contour2):
    """
    Vectorized code to find intersections between contours. All
    successive duplicate vertices along the input contours must be
    removed to help avoid division-by-zero errors.

    There are cases were no intersection exists (eg. parallel lines)
    where division by zero and invalid value exceptions occur. These
    exceptions should be caught as warnings: these edge cases are
    unavoidable with this algorithm and do not indicate that the
    output is erroneous.
    """
    amin = lambda x1, x2: np.where(x1<x2, x1, x2)       # Elementwise min selection
    amax = lambda x1, x2: np.where(x1>x2, x1, x2)       # Elementwise max selection
    aall = lambda abools: np.dstack(abools).all(axis=2) # dstacks, checks True depthwise
    # Uses delta (using np.diff) to find successive slopes along path
    slope = lambda line: (lambda d: d[:,1]/d[:,0])(np.diff(line, axis=0))
    # Meshgrids between both paths (x and y). One element sliced off end/beginning
    x11, x21 = np.meshgrid(contour1[:-1, 0], contour2[:-1, 0])
    x12, x22 = np.meshgrid(contour1[1:, 0], contour2[1:, 0])
    y11, y21 = np.meshgrid(contour1[:-1, 1], contour2[:-1, 1])
    y12, y22 = np.meshgrid(contour1[1:, 1], contour2[1:, 1])
    # Meshgrid of all slopes for both paths
    m1, m2 = np.meshgrid(slope(contour1), slope(contour2))
    m2inv = 1/m2 # m1inv was not used.
    yi = (m1*(x21-x11-m2inv*y21) + y11)/(1 - m1*m2inv)
    xi = (yi - y21)*m2inv + x21 # (xi, yi) is intersection candidate
    # Bounding box type conditions for intersection candidates
    xconds = (amin(x11, x12) < xi, xi <= amax(x11, x12),
              amin(x21, x22) < xi, xi <= amax(x21, x22) )
    yconds = (amin(y11, y12) < yi, yi <= amax(y11, y12),
              amin(y21, y22) < yi, yi <= amax(y21, y22) )
    return xi[aall(xconds)], yi[aall(yconds)]
Exemplo n.º 17
0
def select_master_date(date_list, pbase_list=[]):
    """Select super master date based on input temporal and/or perpendicular baseline info.
    Return master date in YYYYMMDD format.
    """
    date8_list = ptime.yyyymmdd(date_list)
    if not pbase_list:
        # Choose date in the middle
        m_date8 = date8_list[int(len(date8_list)/2)]
    else:
        # Get temporal baseline list
        tbase_list = ptime.date_list2tbase(date8_list)[0]
        # Normalization (Pepe and Lanari, 2006, TGRS)
        temp2perp_scale = (max(pbase_list)-min(pbase_list)) / (max(tbase_list)-min(tbase_list))
        tbase_list = [tbase*temp2perp_scale for tbase in tbase_list]
        # Get distance matrix
        ttMat1, ttMat2 = np.meshgrid(np.array(tbase_list),
                                     np.array(tbase_list))
        ppMat1, ppMat2 = np.meshgrid(np.array(pbase_list),
                                     np.array(pbase_list))
        ttMat = np.abs(ttMat1 - ttMat2)  # temporal distance matrix
        ppMat = np.abs(ppMat1 - ppMat2)  # spatial distance matrix
        # 2D distance matrix in temp/perp domain
        disMat = np.sqrt(np.square(ttMat) + np.square(ppMat))

        # Choose date minimize the total distance of temp/perp baseline
        disMean = np.mean(disMat, 0)
        m_idx = np.argmin(disMean)
        m_date8 = date8_list[m_idx]
    return m_date8
Exemplo n.º 18
0
def increase_grid(x, y, z, increase_y = 0, increase_x = 0, new_y_lims = None, number=100):
    #generic use function to re-grid data
    x_grid,y_grid = np.meshgrid(x,y)
    input_grid = np.ones([len(x_grid.flatten()),2],dtype=float)
    input_grid[:,0]=x_grid.flatten()
    input_grid[:,1]=y_grid.flatten()
    if increase_x:
        x_out = np.linspace(min(x),max(x),num=number)
    else:
        x_out = x
    if increase_y:
        if new_y_lims == None:
            y_out = np.linspace(min(y),max(y),num=number)
        else:
            y_out = np.linspace(new_y_lims[0],new_y_lims[1],num=number)
    else:
        y_out = y
    x_grid_output, y_grid_output = np.meshgrid(x_out,y_out)
    output_grid = np.ones([len(x_grid_output.flatten()),2],dtype=float)
    output_grid[:,0]=x_grid_output.flatten()
    output_grid[:,1]=y_grid_output.flatten()

    z_out = griddata(input_grid,z.flatten(),output_grid)
    z_out.resize(len(y_out),len(x_out))
    return x_out, y_out, z_out
Exemplo n.º 19
0
    def pflux(self, p, x):
        Egam = x * 1e-9  # in TeV

        if self.EG is None:
            self.EG, self.EP = np.meshgrid(Egam, self.Ep)
            self.Fgam = self.F_gamma(self.EG, self.EP)
        elif np.array_equal(Egam, self.EG[0, :]) is False:
            print(Egam.shape, self.EG.shape)
            print("Warning different internal vectors. Recomputing.")
            self.EG, self.EP = np.meshgrid(Egam, self.Ep)
            self.Fgam = self.F_gamma(self.EG, self.EP)

        # proton_spec = p[3]*np.exp(-self.EP*p[1]*1e-3)*(self.EP/p[0])**(-p[2])
        proton_spec = np.exp(-self.EP * p[1] * 1e-3) * (self.EP / p[0]) ** (-p[2])

        if self.Fgam is None:
            self.Fgam = self.F_gamma(self.EG, self.EP)

        res = self.Fgam * proton_spec
        integral = 3e10 * res.sum(0) * self.lbsize / np.log(10.)

        # Normalize with proton energy content at 1 kpc for n_H = 1 cm^-3
        pe_spec = self.Ep ** 2 * np.exp(-self.Ep * p[1] * 1e-3) * (self.Ep / p[0]) ** (-p[2])
        pe_spec = pe_spec[(self.Ep >= p[4]) * (self.Ep <= p[5])]
        norm = 4 * np.pi * (3.1e21) ** 2 * 1.602e9 * pe_spec.sum() * self.lbsize / np.log(10.) / 1e50

        #        return 3e10*res.sum(0)*self.lbsize/np.log(10.)*1e-9   # per TeV not keV
        return integral / norm * p[3]
Exemplo n.º 20
0
def VectorField(ax, VelocityField = None):
    if VelocityField is not None:
	
        # Get all velocities
        x, y, z, u, v, w = VelocityField.GetVelocity()
        #print(x.shape)
        #print(y.shape)
        #print(z.shape)
        #print(u.shape)
        #print(v.shape)
        #print(w.shape)
		
                
        #pdb.set_trace()
        # Meshgrid the vectors
        x_rec, y_rec, z_rec = np.meshgrid(x, y, z)
        u_rec, v_rec, w_rec = np.meshgrid(u, v, w)
        #pdb.set_trace()
		
        # Plot Vector field of velocity
        ax.quiver(x_rec, y_rec, z_rec, u_rec, v_rec, w_rec, length = 0.5)
        
		# Set axis labels
        ax.set_xlabel('X')
        ax.set_ylabel('Y')
        ax.set_zlabel('Z')
		
		# Show photo
        plt.show()
Exemplo n.º 21
0
def generate_ind_pairs(img_num_per_cam_person, person_inds, cam_inds):
    positive_pair_a = numpy.asarray([], dtype='int32')
    positive_pair_b = numpy.asarray([], dtype='int32')
    negative_pair_a = numpy.asarray([], dtype='int32')
    negative_pair_b = numpy.asarray([], dtype='int32')

    past_person_inds = numpy.asarray([], dtype='int32')
    for i in person_inds:
        past_person_inds = numpy.append(past_person_inds, i)
        past_cam_inds = numpy.asarray([], dtype='int32')
        for j in cam_inds:
            past_cam_inds = numpy.append(past_cam_inds, j)
            target_abs_inds = get_abs_ind_one(img_num_per_cam_person, i, j)
            pos_cand_abs_inds = get_abs_ind_per_cam_person(img_num_per_cam_person,
                                                           numpy.asarray([i], dtype='int32'),
                                                           numpy.setdiff1d(cam_inds, past_cam_inds))
            neg_cand_abs_inds = get_abs_ind_per_cam_person(img_num_per_cam_person,
                                                       numpy.setdiff1d(person_inds, past_person_inds),
                                                       numpy.setdiff1d(cam_inds, j))

            [tmp_a, tmp_b] = numpy.meshgrid(pos_cand_abs_inds, target_abs_inds)
            positive_pair_a = numpy.append(positive_pair_a, tmp_b.flatten())
            positive_pair_b = numpy.append(positive_pair_b, tmp_a.flatten())
            [tmp_a, tmp_b] = numpy.meshgrid(neg_cand_abs_inds, target_abs_inds)
            negative_pair_a = numpy.append(negative_pair_a, tmp_b.flatten())
            negative_pair_b = numpy.append(negative_pair_b, tmp_a.flatten())

    return [positive_pair_a, positive_pair_b, negative_pair_a, negative_pair_b]
Exemplo n.º 22
0
    def _init_grid(self):
        """ Initialize (x,y,z) coordinate grid + (re)draw plot."""
        phi_UC = np.linspace(0, 2*pi, 400, endpoint=True) # angles for unit circle
        self.xy_UC = np.exp(1j * phi_UC) # x,y coordinates of unity circle

        steps = 100              # number of steps for x, y, r, phi
        #
        self.xmin = -1.5; self.xmax = 1.5  # cartesian range limits
        self.ymin = -1.5; self.ymax = 1.5

        rmin = 0;    rmax = self.xmin  # polar range limits

        # Calculate grids for 3D-Plots
        dr = rmax / steps * 2 # grid size for polar range
        dx = (self.xmax - self.xmin) / steps
        dy = (self.ymax - self.ymin) / steps # grid size cartesian range

        if self.chkPolar.isChecked(): # # Plot circular range in 3D-Plot
            [r, phi] = np.meshgrid(np.arange(rmin, rmax, dr),
                            np.linspace(0, 2 * pi, steps, endpoint=True))
            self.x = r * cos(phi)
            self.y = r * sin(phi)
        else: # cartesian grid
            [self.x, self.y] = np.meshgrid(np.arange(self.xmin, self.xmax, dx),
                                            np.arange(self.ymin, self.ymax, dy))

        self.z = self.x + 1j*self.y # create coordinate grid for complex plane

        self.draw() # initial plot
Exemplo n.º 23
0
    def __init__(self):
        # sift features
        self.gS = 8
        self.pS = 16
        self.nrml_thres = 1.0
        self.sigma = 0.8
        self.sift_thres = 0.2
        self.Nangles = 8
        self.Nbins = 4
        self.Nsamples = self.Nbins**2
        self.alpha = 9.0
        self.angles = np.array(range(self.Nangles))*2.0*np.pi/self.Nangles

        self.GH, self.GW = self.gen_dgauss(self.sigma)

        # compute the weight contribution map
        # weights is the contribution of each pixel to the corresponding bin center
        sample_res = self.pS / np.double(self.Nbins)
        sample_p = np.array(range(self.pS))
        sample_ph, sample_pw = np.meshgrid(sample_p,sample_p)
        sample_ph.resize(sample_ph.size)
        sample_pw.resize(sample_pw.size)
        bincenter = np.array(range(1,self.Nbins*2,2)) / 2.0 / self.Nbins * self.pS - 0.5
        bincenter_h, bincenter_w = np.meshgrid(bincenter,bincenter)
        bincenter_h.resize((bincenter_h.size,1))
        bincenter_w.resize((bincenter_w.size,1))
        dist_ph = abs(sample_ph - bincenter_h)
        dist_pw = abs(sample_pw - bincenter_w)
        weights_h = dist_ph / sample_res
        weights_w = dist_pw / sample_res
        weights_h = (1-weights_h) * (weights_h <= 1)
        weights_w = (1-weights_w) * (weights_w <= 1)
        self.weights = weights_h * weights_w
Exemplo n.º 24
0
    def graph(self, x_axis, y_axis, image, params, result = None):
        #plot the sample data
        from matplotlib import pyplot
        pyplot.figure()
        pyplot.subplot(2,1,1)
        pyplot.contourf(x_axis, y_axis, image, alpha = 0.5)
        #plot the fit
        #sample the fit with more precision

        x_axis_fit = np.linspace(x_axis.min(), x_axis.max(), x_axis.size * 5)
        y_axis_fit = np.linspace(y_axis.min(), y_axis.max(), y_axis.size * 5)
        xx, yy = np.meshgrid(x_axis_fit, y_axis_fit)
        params['background_level'].value = 0                                                                                
        fit_1d = self.ion_model(params, xx, yy, use_1d=True)
        xx, yy = np.meshgrid(x_axis, y_axis)
        pyplot.subplot(2,1,2)
        ximage = image.sum(axis=0)
        ximage = ximage - ximage[0]
        a1d = np.ones_like(self.allions_1d)
        #low_values_indices = self.allions_1d - bg < (0.5)*params['amplitude'].value  # Where values are low
        low_values_indices = self.allions_1d < self.model_threshold  # Where values are low
        a1d[low_values_indices] = 0  # All low values set to 0
        pyplot.plot(x_axis, a1d * ximage.max())
        #pyplot.plot(x_axis, ximage * a1d, 'o', markersize=10)
        pyplot.plot(x_axis, ximage)
        pyplot.plot(x_axis_fit, fit_1d)
        pyplot.tight_layout()
        pyplot.show()
Exemplo n.º 25
0
def get_patches(data, var, dql, centers, patch_size=5):
    """
    Return patched data, etc, at given centers.
    """
    buff = (patch_size - 1) / 2

    # SExtractor doesnt alway put peak on brightest pixel
    # find shifts, up to 1 pixel that correct for this
    x, y = np.meshgrid(range(-2, 3),
                       range(-2, 3))
    xcs = (x[None, :, :] + centers[:,0][:, None, None]).astype(np.int)
    ycs = (y[None, :, :] + centers[:,1][:, None, None]).astype(np.int)
    
    for i in range(centers.shape[0]):
        test = data[xcs[i], ycs[i]]
        ind = (test == np.max(test))
        centers[i, 0] += x[ind]
        centers[i, 1] += y[ind]

    # Full patch indices
    x, y = np.meshgrid(range(-buff, buff + 1),
                       range(-buff, buff + 1))
    xcs = (x[None, :, :] + centers[:,0][:, None, None]).astype(np.int)
    ycs = (y[None, :, :] + centers[:,1][:, None, None]).astype(np.int)
    
    return data[xcs, ycs], var[xcs, ycs], dql[xcs, ycs], xcs, ycs, \
        centers
    def __init__(self, gridSpacing, patchSize, nrml_thres=1.0, sigma_edge=0.8, sift_thres=0.2):
        """
gridSpacing: the spacing for sampling dense descriptors
patchSize: the size for each sift patch
nrml_thres: low contrast normalization threshold
sigma_edge: the standard deviation for the gaussian smoothing
before computing the gradient
sift_thres: sift thresholding (0.2 works well based on
Lowe's SIFT paper)
"""
        self.gS = gridSpacing
        self.pS = patchSize
        self.nrml_thres = nrml_thres
        self.sigma = sigma_edge
        self.sift_thres = sift_thres
        # compute the weight contribution map
        sample_res = self.pS / np.double(Nbins)
        sample_p = np.array(range(self.pS))
        sample_ph, sample_pw = np.meshgrid(sample_p, sample_p)
        sample_ph.resize(sample_ph.size)
        sample_pw.resize(sample_pw.size)
        bincenter = np.array(range(1, Nbins * 2, 2)) / 2.0 / Nbins * self.pS - 0.5
        bincenter_h, bincenter_w = np.meshgrid(bincenter, bincenter)
        bincenter_h.resize((bincenter_h.size, 1))
        bincenter_w.resize((bincenter_w.size, 1))
        dist_ph = abs(sample_ph - bincenter_h)
        dist_pw = abs(sample_pw - bincenter_w)
        weights_h = dist_ph / sample_res
        weights_w = dist_pw / sample_res
        weights_h = (1 - weights_h) * (weights_h <= 1)
        weights_w = (1 - weights_w) * (weights_w <= 1)
        # weights is the contribution of each pixel to the corresponding bin center
        self.weights = weights_h * weights_w
def test_label_propagation_closed_form():
    n_classes = 2
    X, y = make_classification(n_classes=n_classes, n_samples=200,
                               random_state=0)
    y[::3] = -1
    Y = np.zeros((len(y), n_classes + 1))
    Y[np.arange(len(y)), y] = 1
    unlabelled_idx = Y[:, (-1,)].nonzero()[0]
    labelled_idx = (Y[:, (-1,)] == 0).nonzero()[0]

    clf = label_propagation.LabelPropagation(max_iter=10000,
                                             gamma=0.1)
    clf.fit(X, y)
    # adopting notation from Zhu et al 2002
    T_bar = clf._build_graph()
    Tuu = T_bar[tuple(np.meshgrid(unlabelled_idx, unlabelled_idx,
                      indexing='ij'))]
    Tul = T_bar[tuple(np.meshgrid(unlabelled_idx, labelled_idx,
                                  indexing='ij'))]
    Y = Y[:, :-1]
    Y_l = Y[labelled_idx, :]
    Y_u = np.dot(np.dot(np.linalg.inv(np.eye(Tuu.shape[0]) - Tuu), Tul), Y_l)

    expected = Y.copy()
    expected[unlabelled_idx, :] = Y_u
    expected /= expected.sum(axis=1)[:, np.newaxis]

    assert_array_almost_equal(expected, clf.label_distributions_, 4)
Exemplo n.º 28
0
    def find_intersections(self, A, B):
        ''' (matrix, matrix -> bool'''
        amin = lambda x1, x2: np.where(x1<x2, x1, x2)
        amax = lambda x1, x2: np.where(x1>x2, x1, x2)
        aall = lambda abools: np.dstack(abools).all(axis=2)
        slope = lambda line: (lambda d: d[:,1]/d[:,0])(np.diff(line, axis=0))

        x11, x21 = np.meshgrid(A[:-1, 0], B[:-1, 0])
        x12, x22 = np.meshgrid(A[1:, 0], B[1:, 0])
        y11, y21 = np.meshgrid(A[:-1, 1], B[:-1, 1])
        y12, y22 = np.meshgrid(A[1:, 1], B[1:, 1])

        m1, m2 = np.meshgrid(slope(A), slope(B))
        m1inv, m2inv = 1/m1, 1/m2

        yi = (m1*(x21-x11-m2inv*y21) + y11)/(1 - m1*m2inv)
        xi = (yi - y21)*m2inv + x21

        xconds = (amin(x11, x12) < xi, xi <= amax(x11, x12), 
                  amin(x21, x22) < xi, xi <= amax(x21, x22) )
        yconds = (amin(y11, y12) < yi, yi <= amax(y11, y12),
                  amin(y21, y22) < yi, yi <= amax(y21, y22) )
        if xi[aall(xconds)] and yi[aall(yconds)]:
            return  xi[aall(xconds)], yi[aall(yconds)], True # intersection, don't go!
        return  xi[aall(xconds)], yi[aall(yconds)], False
Exemplo n.º 29
0
    def _make_carts_dict(self):
        """ Return a carts dictionary, distances in meters. """
        az_deg, range_km, el_deg = self._calc_geometry()
        # simple calculation involving 4/3 earth radius
        nsweeps = self.master_header['max_nz']
        nrays = self.master_header['max_ny']
        ngates = self.master_header['max_nx']
        xx = np.empty([nsweeps, nrays, ngates], dtype=np.float32)
        yy = np.empty([nsweeps, nrays, ngates], dtype=np.float32)
        zz = np.empty([nsweeps, nrays, ngates], dtype=np.float32)

        if self.projection == 'rhi':
            rg, ele = np.meshgrid(range_km, el_deg)
            rg = np.array(rg, dtype=np.float64)
            ele = np.array(ele, dtype=np.float64)
            for aznum in range(nsweeps):
                azg = np.ones(rg.shape, dtype=np.float64) * az_deg[aznum]
                x, y, z = antenna_to_cartesian(rg, azg, ele)
                zz[aznum, :, :] = z
                xx[aznum, :, :] = x
                yy[aznum, :, :] = y

        elif self.projection == 'ppi':
            rg, azg = np.meshgrid(range_km, az_deg)
            rg = np.array(rg, dtype=np.float64)
            azg = np.array(azg, dtype=np.float64)
            for elnum in range(nsweeps):
                ele = np.ones(rg.shape, dtype=np.float64) * el_deg[elnum]
                x, y, z = antenna_to_cartesian(rg, azg, ele)
                zz[elnum, :, :] = z
                xx[elnum, :, :] = x
                yy[elnum, :, :] = y

        return {'x': xx, 'y': yy, 'z': zz}
Exemplo n.º 30
0
def plot_beam(dirname, input_beam, Rho, Phi, ref_output_fluence):
    filename = lambda name: os.path.join(dirname, name)
    
    if len(Rho) > 1:
        vfluence = np.vectorize(input_beam.fluence)
        ref_input_fluence = vfluence(*np.meshgrid(Rho, Phi)).T
        norm_input_fluence = ref_input_fluence / input_beam.ref_fluence
        norm_output_fluence = ref_output_fluence / input_beam.ref_fluence
        max_output_fluence = np.amax(norm_output_fluence)
        
        n_ref = -1
        for n, phi in enumerate(Phi):
            if n_ref < 0 or abs(phi - input_beam.phi_ref) < abs(Phi[n_ref] - input_beam.phi_ref):
                n_ref = n
        rholim = (Rho[0], Rho[-1])
        plot.plot_data(filename("fluences"), "Input and Output Fluence", ((Rho,)*2, None, rholim, rho_label), ((norm_input_fluence[:, n_ref], norm_output_fluence[:, n_ref]), None, None, fluence_rel_label), ("input beam", "output beam"))
        plot.plot_data(filename("fluences_norm"), "Normalized Input and Output Fluence", ((Rho,)*2, None, rholim, rho_label), ((norm_input_fluence[:, n_ref], norm_output_fluence[:, n_ref] / max_output_fluence), None, None, fluence_norm_rel_label), ("input beam", "output beam"))
        
        if len(Phi) > 1:
            FR, RF = np.meshgrid(Phi, Rho)
            XY, YX = RF * np.cos(FR), RF * np.sin(FR)
            stride_rho = max(len(Rho) // params.out_count_rho, 1)
            stride_phi = max(len(Phi) // params.out_count_phi, 1)
            plot.plot_projection(filename("fluence_in"), "Input Fluence", (XY, None, x_label), (YX, None, y_label), (norm_input_fluence, None, fluence_rel_label), (30, -60), (stride_rho, stride_phi))
            plot.plot_projection(filename("fluence_out"), "Output Fluence", (XY, None, x_label), (YX, None, y_label), (norm_output_fluence, None, fluence_rel_label), (30, -60), (stride_rho, stride_phi))
if __name__ == '__main__':
    # # xor exmaple
    #     X = np.array([[0,0], [0,1], [1,0], [1,1]])
    #     y = np.array([[0,1,1,0]]).T
    #     nn = Neural_Network([2,2,1], learning_rate=1, opt=False, check_gradients=True, epochs=100000, batch_size=4)
    #     nn.fit(X, y)

    # Another example with two random circlular regions as positive class
    X = np.random.rand(300, 2)
    y = np.atleast_2d(1 * np.logical_or(
        (X[:, 0] - .8)**2 + (X[:, 1] - .5)**2 < .03,
        (X[:, 0] - .2)**2 + (X[:, 1] - .8)**2 < .03)).T

    nn = Neural_Network([2, 10, 1],
                        learning_rate=1,
                        C=0,
                        opt=False,
                        check_gradients=True,
                        batch_size=50,
                        epochs=100000)
    nn.fit(X, y)

    xx, yy = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
    Z = np.round(nn.predict(np.c_[xx.ravel(), yy.ravel()]))
    Z = Z.reshape(xx.shape)
    plt.figure(figsize=(10, 8))
    plt.contourf(xx, yy, Z, alpha=.8)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=60)
    plt.title("Neural Net Accuracy is " + str(np.round(nn.score(X, y), 2)))
    plt.show()
Exemplo n.º 32
0
        climo = climoU[i]
    elif i > 1:
        var = diffZ[i - 2]
        pvar = pZ[i - 2]
        climo = climoZ[i - 2]

    ax1 = plt.subplot(2, 2, i + 1)
    m = Basemap(projection='ortho',
                lon_0=0,
                lat_0=89,
                resolution='l',
                area_thresh=10000.)

    var, lons_cyclic = addcyclic(var, lon)
    var, lons_cyclic = shiftgrid(180., var, lons_cyclic, start=False)
    lon2d, lat2d = np.meshgrid(lons_cyclic, lat)
    x, y = m(lon2d, lat2d)

    pvar, lons_cyclic = addcyclic(pvar, lon)
    pvar, lons_cyclic = shiftgrid(180., pvar, lons_cyclic, start=False)
    climoq, lons_cyclic = addcyclic(climo, lon)
    climoq, lons_cyclic = shiftgrid(180., climoq, lons_cyclic, start=False)

    m.drawmapboundary(fill_color='white', color='dimgray', linewidth=0.7)

    cs = m.contourf(x, y, var, limit, extend='both')
    cs1 = m.contourf(x,
                     y,
                     pvar,
                     colors='None',
                     hatches=['....'],
Exemplo n.º 33
0
        return surf,

    anim = animation.FuncAnimation(fig, update_surf,
                                   frames=len(eta_list), interval=10, blit=False)
    mpeg_writer = animation.FFMpegWriter(fps=24, bitrate=10000,
                                         codec="libx264", extra_args=["-pix_fmt", "yuv420p"])
    anim.save("{}.mp4".format(filename), writer=mpeg_writer)
    return anim


if __name__ == '__main__':
    eta_list = []
    x = np.asarray([i for i in range(100)])
    y = np.asarray([i for i in range(100)])

    x, y = np.meshgrid(x, y)
    for i in range(0, 10001, 10):
        eta = []
        file = open(f"result/outputH_{i}.txt")
        lines = file.readlines()[1:]
        for line in lines:
            tmp = [float(x) for x in line.split()]
            eta.append(tmp)

        eta = np.asarray(eta) - 1
        eta_list.append(eta)

        if i in [0, 10, 100, 1000, 10000]:
            surface_plot3d(x, y, eta, f"img/H{i}.png", i)
    eta_animation3d(x, y, eta_list, 10, "h")
Exemplo n.º 34
0
    d = computeGrad(X, y, theta, reg)

    theta[0] -= step_size * d[0]
    theta[1] -= step_size * d[1]

    # WRITEME: write your update rule(s) here

# TODO: remove this line below once you have correctly implemented/gradient-checked your various sub-routines
# sys.exit(0)

# evaluate training set accuracy
scores, probs = predict(X, theta)
predicted_class = np.argmax(scores, axis=1)
print('training accuracy: %.2f' % (np.mean(predicted_class == y)))

# plot the resulting classifier
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.savefig(os.getcwd() + '/out/spiral_linear.png')

plt.show()
Exemplo n.º 35
0
 def grid(self):
     grid = [np.linspace(0, 2 * np.pi, num=self.resolution, endpoint=False) for _ in range(self.units.lattice.D)]
     return np.meshgrid(*grid)
Exemplo n.º 36
0
plt.scatter(x, y)
plt.title("scatter")

plt.subplot(233)
plt.pie(y)
plt.title("pie")

plt.subplot(234)
plt.bar(x, y)
plt.title("bar")

# 2D data
import numpy as np
delta = 0.025
x = y = np.arange(-3.0, 3.0, delta)
X, Y = np.meshgrid(x, y)
Z    = Y**2 + X**2

plt.subplot(235)
plt.contour(X,Y,Z)
plt.colorbar()
plt.title("contour")

# read image
import matplotlib.image as mpimg
img=mpimg.imread('marvin.jpg')

plt.subplot(236)
plt.imshow(img)
plt.title("imshow")
Exemplo n.º 37
0
import matplotlib.pylab as plt
import numpy as np
import pandas as pd
from matplotlib import cm
from scipy.stats import norm,chi2,binom,gamma
import seaborn as sns
from math import cos, sin,log,tan,pi,exp,sqrt,cosh,sinh,tanh,atan,atan2,e
from cmath import exp as cexp, log as clog
from mpl_toolkits.mplot3d import Axes3D

for i,t in enumerate(np.linspace(0,2*pi,360)):
    fig = plt.figure(figsize=(16,16))
    ax = fig.add_subplot(111, projection='3d',facecolor='black')
    p = plt.axis('off')
    x = np.linspace(-2*pi,2*pi,1000)
    y = np.linspace(-2*pi,2*pi,1000)
    xx, yy = np.meshgrid(x, y, sparse=True)
    z = np.cos(xx*yy +6*t+pi)
    ax.view_init(t*180/(pi),t*180/(4*pi))
    ax.set_zlim(-3,3)
    ax.plot_surface(xx, yy, z, antialiased=True, shade=True,cmap=cm.winter,alpha=0.8)
    p = plt.savefig(f'C:/Users/Alejandro/Pictures/RandomPlots/15052020/plot{i}.PNG',facecolor='black')
Exemplo n.º 38
0
def readVar(varnames, qbophase, period):
    ### Call function for surface temperature data from reach run
    lat, lon, time, lev, tashit = MO.readExperiAll('%s' % varnames, 'HIT',
                                                   'surface')
    lat, lon, time, lev, tasfict = MO.readExperiAll('%s' % varnames, 'FICT',
                                                    'surface')

    ### Create 2d array of latitude and longitude
    lon2, lat2 = np.meshgrid(lon, lat)

    ### Read in QBO phases
    filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
    filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
    filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
    filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
    filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
    filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
    pos_hit = np.append(
        np.genfromtxt(filenamehitp, unpack=True, usecols=[0], dtype='int'),
        np.genfromtxt(filenamehitp2, unpack=True, usecols=[0], dtype='int') +
        101)
    non_hit = np.append(
        np.genfromtxt(filenamehitno, unpack=True, usecols=[0], dtype='int'),
        np.genfromtxt(filenamehitno2, unpack=True, usecols=[0], dtype='int') +
        101)
    neg_hit = np.append(
        np.genfromtxt(filenamehitn, unpack=True, usecols=[0], dtype='int'),
        np.genfromtxt(filenamehitn2, unpack=True, usecols=[0], dtype='int') +
        101)

    filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
    filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
        1]
    filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
    filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
        0]
    filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
        1]
    filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
        2]
    pos_fict = np.append(
        np.genfromtxt(filenamefictp, unpack=True, usecols=[0], dtype='int'),
        np.genfromtxt(filenamefictp2, unpack=True, usecols=[0], dtype='int') +
        101)
    non_fict = np.append(
        np.genfromtxt(filenamefictno, unpack=True, usecols=[0], dtype='int'),
        np.genfromtxt(filenamefictno2, unpack=True, usecols=[0], dtype='int') +
        101)
    neg_fict = np.append(
        np.genfromtxt(filenamefictn, unpack=True, usecols=[0], dtype='int'),
        np.genfromtxt(filenamefictn2, unpack=True, usecols=[0], dtype='int') +
        101)

    ### Concatonate runs
    runs = [tashit, tasfict]

    ### Separate per periods (ON,DJ,FM)
    if period == 'ON':
        tas_mo = np.empty(
            (3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i] = np.nanmean(runs[i][:, 9:11, :, :], axis=1)
    elif period == 'DJ':
        tas_mo = np.empty(
            (3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i], tas_mo[i] = UT.calcDecJan(runs[i], runs[i], lat, lon,
                                                 'surface', 1)
    elif period == 'FM':
        tas_mo = np.empty(
            (3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i] = np.nanmean(runs[i][:, 1:3, :, :], axis=1)
    elif period == 'DJF':
        tas_mo = np.empty(
            (3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i], tas_mo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon,
                                                    'surface', 1)
    elif period == 'M':
        tas_mo = np.empty(
            (3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i] = runs[i][:, 2, :, :]
    elif period == 'D':
        tas_mo = np.empty(
            (3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i] = runs[i][:, -1, :, :]
    elif period == 'N':
        tas_mo = np.empty(
            (3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i] = runs[i][:, -2, :, :]
    elif period == 'ND':
        tas_mo = np.empty(
            (3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
        for i in range(len(runs)):
            tas_mo[i] = np.nanmean(runs[i][:, -2:, :, :], axis=1)
    else:
        ValueError('Wrong period selected! (ON,DJ,FM)')

    ### Composite by QBO phase
    tas_mohitpos = tas_mo[0][pos_hit, :, :]
    tas_mofictpos = tas_mo[1][pos_fict, :, :]

    tas_mohitneg = tas_mo[0][neg_hit, :, :]
    tas_mofictneg = tas_mo[1][neg_fict, :, :]

    ### Compute climatology
    climohitpos = np.nanmean(tas_mohitpos, axis=0)
    climohitneg = np.nanmean(tas_mohitneg, axis=0)
    climo = [climohitpos, climohitneg]

    ### Compute comparisons for months - taken ensemble average
    ficthitpos = np.nanmean(tas_mofictpos - tas_mohitpos, axis=0)
    ficthitneg = np.nanmean(tas_mofictneg - tas_mohitneg, axis=0)
    diffruns_mo = [ficthitpos, ficthitneg]

    ### Calculate significance for ND
    stat_FICTHITpos, pvalue_FICTHITpos = UT.calc_indttest(
        tas_mo[1][pos_fict, :, :], tas_mo[0][pos_hit, :, :])
    stat_FICTHITnon, pvalue_FICTHITnon = UT.calc_indttest(
        tas_mo[1][non_fict, :, :], tas_mo[0][non_hit, :, :])
    stat_FICTHITneg, pvalue_FICTHITneg = UT.calc_indttest(
        tas_mo[1][neg_fict, :, :], tas_mo[0][neg_hit, :, :])

    pruns_mo = [pvalue_FICTHITpos, pvalue_FICTHITneg]

    return lat, lon, climo, diffruns_mo, pruns_mo
Exemplo n.º 39
0
    Mxx = globalMatrix1D(pde.a, mesh, fem, 1, fem, 1, ng)
    M00 = globalMatrix1D(pde.c, mesh, fem, 0, fem, 0, ng)
    f = globalVec1D(pde.f, mesh, fem, 0, ng)

    #%% 5 Dirichlet boundary condition
    uD = pde.gD(fem.p)
    uD[fem.dof] = 0.0
    bxx = Mxx @ uD
    b00 = M00 @ uD

    #%% 6 Neumann boundary condition
    bN = np.zeros(np.shape(fem.p))
    bN[fem.ptype == 2] = pde.gN(fem.p[fem.ptype == 2])

    #%% 7 Extract degree of freedom
    ii, jj = np.meshgrid(fem.dof, fem.dof, indexing='ij')
    A = Mxx[ii, jj] + M00[ii, jj]
    b = f[fem.dof] + bN[fem.dof] - bxx[fem.dof] - b00[fem.dof]

    #%% 8 Solve Linear Sysetem
    uDof = inv(A) @ b
    uh = np.copy(uD)
    uh[fem.dof] = uDof

    #%%
    fig, axs = plt.subplots(1, 1, sharex=True, sharey=True, figsize=(8, 6))
    tu = pde.exactu(fem.p)
    for k in range(n):
        vert = mesh.p[mesh.t[k, :]]
        x = np.linspace(vert[0], vert[1], 11)
Exemplo n.º 40
0
def putVecMaps(centerA, centerB, accumulate_vec_map, count, params_transform,
               thre):
    """Implement Part Affinity Fields
    :param centerA: int with shape (2,) or (3,), centerA will pointed by centerB.
    :param centerB: int with shape (2,) or (3,), centerB will point to centerA.
    :param accumulate_vec_map: one channel of paf.
    :param count: store how many pafs overlaped in one coordinate of accumulate_vec_map.
    :param params_transform: store the value of stride and crop_szie_y, crop_size_x                 
    """

    centerA = centerA.astype(float)
    centerB = centerB.astype(float)

    stride = params_transform['stride']
    crop_size_y = params_transform['crop_size_y']
    crop_size_x = params_transform['crop_size_x']
    grid_y = crop_size_y / stride
    grid_x = crop_size_x / stride
    centerB = centerB / stride
    centerA = centerA / stride

    limb_vec = centerB - centerA
    norm = np.linalg.norm(limb_vec)
    if norm < 1.0:
        # print 'limb is too short, ignore it...'
        return accumulate_vec_map, count
    limb_vec_unit = limb_vec / norm
    # print 'limb unit vector: {}'.format(limb_vec_unit)

    # To make sure not beyond the border of this two points
    min_x = max(int(round(min(centerA[0], centerB[0]) - thre)), 0)
    max_x = min(int(round(max(centerA[0], centerB[0]) + thre)), grid_x)
    min_y = max(int(round(min(centerA[1], centerB[1]) - thre)), 0)
    max_y = min(int(round(max(centerA[1], centerB[1]) + thre)), grid_y)

    range_x = list(range(int(min_x), int(max_x), 1))
    range_y = list(range(int(min_y), int(max_y), 1))
    xx, yy = np.meshgrid(range_x, range_y)
    ba_x = xx - centerA[0]  # the vector from (x,y) to centerA
    ba_y = yy - centerA[1]
    limb_width = np.abs(ba_x * limb_vec_unit[1] - ba_y * limb_vec_unit[0])
    mask = limb_width < thre  # mask is 2D

    vec_map = np.copy(accumulate_vec_map) * 0.0
    vec_map[:, yy, xx] = np.repeat(mask[np.newaxis, :, :], 2, axis=0)
    vec_map[:, yy, xx] *= limb_vec_unit[:, np.newaxis, np.newaxis]

    mask = np.logical_or.reduce(
        (np.abs(vec_map[0, :, :]) > 0, np.abs(vec_map[1, :, :]) > 0))

    accumulate_vec_map = np.multiply(accumulate_vec_map,
                                     count[np.newaxis, :, :])
    accumulate_vec_map += vec_map
    count[mask == True] += 1

    mask = count == 0

    count[mask == True] = 1

    accumulate_vec_map = np.divide(accumulate_vec_map, count[np.newaxis, :, :])
    count[mask == True] = 0

    return accumulate_vec_map, count
Exemplo n.º 41
0
def main():
  optimizers = ['L2L', 'L2L_adv', 'Adam', 'Momentum', 'SGD', 'NAG', 'RMSProp']

  problem_path = './problems/quadratic.npz'
  npzfile = np.load(problem_path)
  problems_w, problems_b = npzfile['arr_0'], npzfile['arr_1']
  prob_num = len(problems_w)
  x = {}
  obj = {}

  for optimizer in optimizers:
    x[optimizer] = np.load(osp.join('./results', optimizer + '.npy'))

  print('problem_w', problems_w)
  print('problem_b', problems_b)
  for prob_idx in range(prob_num):
    fig = plt.figure(figsize=(10, 6))
    for optimizer in optimizers:
      obj[optimizer] = list(
        map(lambda x: np.sum((problems_w[prob_idx].dot(x) - problems_b[prob_idx].squeeze()) ** 2),
            x[optimizer][prob_idx]))
      plt.plot(obj[optimizer], label=optimizer)
      print('Plotting: problem {}, optimizer {}, loss {}, x {}'.format(prob_idx, optimizer, obj[optimizer][-1], x[optimizer][prob_idx][-1]))
    plt.legend(loc='upper right')
    plt.xlabel('number of iterations')
    plt.ylabel('objective value')
    ax = fig.add_subplot(1, 1, 1)
    ax.set_yscale("log")
    plt.savefig('./figs/loss_prob_{}.png'.format(prob_idx))
    # X = {}  # dictionary to store data
    # obj = {}  # dictionary to store obj value
    # W = 0.5 * np.eye(2)
    # Y = 0.5 * np.ones(2)
    # for name in names:
    #     X[name] = np.loadtxt(name + '.txt')
    #     obj[name] = list(map(lambda x: LA.norm(W.dot(x) - Y) ** 2, X[name]))
    #     plt.plot(obj[name], label=name)
    # plt.legend(loc='upper right')
    # plt.xlabel('number of iterations')
    # plt.ylabel('objective value')
    #

    # # plot level set and trajectory for SGD
    # W = 0.5 * np.eye(2)
    # Y = 0.5 * np.ones(2)




  n = len(optimizers)
  for prob_idx in range(prob_num):
    fig = plt.figure(figsize=(12, 8))
    for i, optimizer in enumerate(optimizers):
      W = problems_w[prob_idx]
      Y = problems_b[prob_idx]
      minx = np.min(x[optimizer][prob_idx][:, 0])
      miny = np.min(x[optimizer][prob_idx][:, 1])
      maxx = np.max(x[optimizer][prob_idx][:, 0])
      maxy = np.max(x[optimizer][prob_idx][:, 1])
      min_plot = min(minx, miny)
      max_plot = max(maxx, maxy)
      t_min = min_plot - 0.3 * (max_plot - min_plot)
      t_max = max_plot + 0.3 * (max_plot - min_plot)
      x1 = np.linspace(t_min, t_max, num=50)
      x2 = np.linspace(t_min, t_max, num=50)
      X1, X2 = np.meshgrid(x1, x2)
      Z = f_quad(X1, X2, W, Y.squeeze())
      ax = fig.add_subplot(2, (n+1)/2, i+1)
      ax.contour(X1, X2, Z, 20)
      ax.set_aspect('equal')
      ax.axis([t_min, t_max, t_min, t_max])
      ax.set_title(optimizer)
      ax.scatter(x[optimizer][prob_idx][:, 0], x[optimizer][prob_idx][:, 1], s=5, edgecolors='r', facecolors='none',
                  marker='o')
      ax.plot(x[optimizer][prob_idx][:, 0], x[optimizer][prob_idx][:, 1], color='r')
  #plt.colorbar()
      plt.savefig('./figs/contour_{}.png'.format(prob_idx))
Exemplo n.º 42
0
def _all_rgb():
    """Return all 256**3 valid rgb tuples."""
    base = np.arange(256, dtype=np.uint8)
    r, g, b = np.meshgrid(base, base, base, indexing='ij')
    return np.stack((r, g, b), axis=-1).reshape((-1, 3))
Exemplo n.º 43
0
# Predicting the Test set results
y_pred = classifier.predict(X_test)

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred)

# Visualising the Training set results
from matplotlib.colors import ListedColormap

X_set, y_set = X_train, y_train
X1, X2 = np.meshgrid(
    np.arange(start=X_set[:, 0].min() - 1,
              stop=X_set[:, 0].max() + 1,
              step=0.01),
    np.arange(start=X_set[:, 1].min() - 1,
              stop=X_set[:, 1].max() + 1,
              step=0.01))
plt.contourf(X1,
             X2,
             classifier.predict(np.array([X1.ravel(),
                                          X2.ravel()]).T).reshape(X1.shape),
             alpha=0.75,
             cmap=ListedColormap(('red', 'green', 'blue')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
    plt.scatter(X_set[y_set == j, 0],
                X_set[y_set == j, 1],
                c=ListedColormap(('red', 'green', 'blue'))(i),
Exemplo n.º 44
0

if __name__ == '__main__':
    n = 4
    V = np.arange(0, n, 1)
    E = [(0, 1, 1.0), (0, 2, 1.0), (1, 2, 1.0), (3, 2, 1.0), (3, 1, 1.0)]

    G = nx.Graph()
    G.add_nodes_from(V)
    G.add_weighted_edges_from(E)

    step_size = 0.1

    a_gamma = np.arange(0, np.pi, step_size)
    a_beta = np.arange(0, np.pi, step_size)
    a_gamma, a_beta = np.meshgrid(a_gamma, a_beta)

    F1 = 3 - (np.sin(2 * a_beta) ** 2 * np.sin(2 * a_gamma) ** 2 - 0.5 * np.sin(4 * a_beta) * np.sin(4 * a_gamma)) * (
                1 + np.cos(4 * a_gamma) ** 2)

    result = np.where(F1 == np.amax(F1))
    a = list(zip(result[0], result[1]))[0]

    gamma = a[0] * step_size
    beta = a[1] * step_size

    prog = make_circuit(4)
    sample_shot =3962
    writefile = open("../data/startQiskit_noisy414.csv", "w")
    # prog.draw('mpl', filename=(kernel + '.png'))
    backend = FakeYorktown()
Exemplo n.º 45
0
    else:
        m = Basemap(projection='cyl',
                    llcrnrlat=llat,
                    urcrnrlat=ulat,
                    llcrnrlon=llon,
                    urcrnrlon=ulon,
                    resolution='c',
                    area_thresh=1000.,
                    ax=ax[mon])

    m.drawcoastlines(linewidth=0.5)
    m.drawcountries(linewidth=0.5)
    m.drawparallels(np.arange(-90., 90., 10.))
    m.drawmeridians(np.arange(-180., 180., 10.))
    #m.drawlsmask(land_color='lightgrey',ocean_color='grey')
    lats = range(-90, 90)
    lons = range(-180, 180)
    X, Y = np.meshgrid(lons, lats)
    m.pcolormesh(X,
                 Y,
                 mongrid[mon],
                 norm=colors.LogNorm(vmin=np.nanmin(mongrid[mon]),
                                     vmax=np.nanmax(mongrid[mon])),
                 cmap='jet')
    ax[mon].title.set_text(names[mon])
plt.tight_layout()
plt.suptitle(year)  #+' - surface to '+str(limit)+'m')
plt.savefig(path + '/plots/' + year + '_' + site + '.png')
plt.close()
print('Plot saved')
Exemplo n.º 46
0
# ---------------------------------------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------------------------


	# PLOT ALL BAND STRUCTURES (ONE FOR EACH VALUE OF KZ) ON 3D PLOT

	if delta > 0:
		fig4 = plt.figure()
		ax4 = fig4.gca(projection='3d')

		x = range(len(freqss[0]))
		kz = kz_list
		X, KZ = np.meshgrid(x, kz)

	# Plot bands

		for index in integer_list: 
			ax4.plot(x, freqss[index], zs=kz[index], zdir='y', color='red', alpha=0.2)
	    
		ax4.set_xlim([x[0], x[-1]])	# x-axis goes from x[0] = 0 to x[-1] = 33; x[-1] = x[33], x[-2] = x[32], etc.
		ax4.set_ylim([0.0, max_kz])
		upper_z = freqss[-1][-1][-1] + 0.05
		ax4.set_zlim([0.0, upper_z])	# z-axis goes from 0 to upper_z

	# Plot labels
		if block == 'y':
			plt.title('Band Structure of Square Photonic Bandgap Fiber; $\epsilon$_core = ' + coreepsilonstring + '; $\epsilon$_PC = ' + pcepsilonstring, size=18)
		else:
Exemplo n.º 47
0
# Define datasets
blobs_params = dict(random_state=0, n_samples=n_inliers, n_features=2)
datasets = [
    make_blobs(centers=[[0, 0], [0, 0]], cluster_std=0.5,
               **blobs_params)[0],
    make_blobs(centers=[[2, 2], [-2, -2]], cluster_std=[0.5, 0.5],
               **blobs_params)[0],
    make_blobs(centers=[[2, 2], [-2, -2]], cluster_std=[1.5, .3],
               **blobs_params)[0],
    4. * (make_moons(n_samples=n_samples, noise=.05, random_state=0)[0] -
          np.array([0.5, 0.25])),
    14. * (np.random.RandomState(42).rand(n_samples, 2) - 0.5)]

# Compare given classifiers under given settings
xx, yy = np.meshgrid(np.linspace(-7, 7, 150),
                     np.linspace(-7, 7, 150))

plt.figure(figsize=(len(anomaly_algorithms) * 2 + 3, 12.5))
plt.subplots_adjust(left=.02, right=.98, bottom=.001, top=.96, wspace=.05,
                    hspace=.01)

plot_num = 1
rng = np.random.RandomState(42)

for i_dataset, X in enumerate(datasets):
    # Add outliers
    X = np.concatenate([X, rng.uniform(low=-6, high=6,
                       size=(n_outliers, 2))], axis=0)

    for name, algorithm in anomaly_algorithms:
        t0 = time.time()
"""

iris = datasets.load_iris()
X = iris.data[:, :2]
Y = iris.target

# 建模
Linearsvc = svm.LinearSVC(dual=False).fit(X, Y)
Linear_svc = svm.SVC(kernel='linear').fit(X, Y)           # Linear kernel
Poly_svc = svm.SVC(kernel='poly').fit(X, Y)               # Ploy kernel
Rbf_svc = svm.SVC(C=2.0).fit(X, Y)                        # Rbf kernel

# 网格
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                     np.arange(y_min, y_max, 0.02))       # 生成采样点

# Title
titles = ['LinearSVC (linear kernel)',
          'SVC with linear kernel',
          'SVC with polynomial kernel',
          'SVC with RBF kernel']

for i, clf in enumerate((Linearsvc, Linear_svc, Poly_svc, Rbf_svc)):
    plt.subplot(2, 2, i+1)
    plt.subplots_adjust(wspace=0.3, hspace=0.6)           # 控制图之间的间隙

    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.coolwarm, alpha=0.8)

    plt.scatter(X[:, 0], X[:, 1], c=Y, s=30, cmap=plt.cm.coolwarm, alpha=0.8)
Exemplo n.º 49
0
def make_meshgrid(x, y, h=.02):
    x_min, x_max = x.min() - 1, x.max() + 1
    y_min, y_max = y.min() - 1, y.max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    return xx, yy
Exemplo n.º 50
0
    def __init__(self, use_kmeans_anchors=False):
        super(RPN, self).__init__()

        if use_kmeans_anchors:
            print('using k-means anchors')
            self.anchor_scales = self.anchor_scales_kmeans
            self.anchor_ratios = self.anchor_ratios_kmeans
            self.anchor_scales_region = self.anchor_scales_kmeans_region
            self.anchor_ratios_region = self.anchor_ratios_kmeans_region
        else:
            print('using normal anchors')
            self.anchor_scales, self.anchor_ratios = \
                np.meshgrid(self.anchor_scales_normal, self.anchor_ratios_normal, indexing='ij')
            self.anchor_scales = self.anchor_scales.reshape(-1)
            self.anchor_ratios = self.anchor_ratios.reshape(-1)
            self.anchor_scales_region, self.anchor_ratios_region = \
                np.meshgrid(self.anchor_scales_normal_region, self.anchor_ratios_normal_region, indexing='ij')
            self.anchor_scales_region = self.anchor_scales_region.reshape(-1)
            self.anchor_ratios_region = self.anchor_ratios_region.reshape(-1)

        self.anchor_num = len(self.anchor_scales)
        self.anchor_num_region = len(self.anchor_scales_region)

        # self.features = VGG16(bn=False)
        self.features = models.vgg16(pretrained=True).features
        self.features.__delattr__('30')  # to delete the max pooling
        # by default, fix the first four layers
        network.set_trainable_param(list(self.features.parameters())[:8],
                                    requires_grad=False)

        # self.features = models.vgg16().features
        self.conv1 = Conv2d(512, 512, 3, same_padding=True)
        self.score_conv = Conv2d(512,
                                 self.anchor_num * 2,
                                 1,
                                 relu=False,
                                 same_padding=False)
        self.bbox_conv = Conv2d(512,
                                self.anchor_num * 4,
                                1,
                                relu=False,
                                same_padding=False)

        self.conv1_region = Conv2d(512, 512, 3, same_padding=True)
        self.score_conv_region = Conv2d(512,
                                        self.anchor_num_region * 2,
                                        1,
                                        relu=False,
                                        same_padding=False)
        self.bbox_conv_region = Conv2d(512,
                                       self.anchor_num_region * 4,
                                       1,
                                       relu=False,
                                       same_padding=False)

        # loss
        self.cross_entropy = None
        self.loss_box = None
        self.cross_entropy_region = None
        self.loss_box_region = None

        # initialize the parameters
        self.initialize_parameters()
Exemplo n.º 51
0
def do_elastic_transform2(image, mask, grid=32, distort=0.2):
    borderMode = cv2.BORDER_REFLECT_101
    height, width = image.shape[:2]

    x_step = int(grid)
    xx = np.zeros(width, np.float32)
    prev = 0
    for x in range(0, width, x_step):
        start = x
        end = x + x_step
        if end > width:
            end = width
            cur = width
        else:
            cur = prev + x_step * (1 + random.uniform(-distort, distort))

        xx[start:end] = np.linspace(prev, cur, end - start)
        prev = cur

    y_step = int(grid)
    yy = np.zeros(height, np.float32)
    prev = 0
    for y in range(0, height, y_step):
        start = y
        end = y + y_step
        if end > height:
            end = height
            cur = height
        else:
            cur = prev + y_step * (1 + random.uniform(-distort, distort))

        yy[start:end] = np.linspace(prev, cur, end - start)
        prev = cur

    #grid
    map_x, map_y = np.meshgrid(xx, yy)
    map_x = map_x.astype(np.float32)
    map_y = map_y.astype(np.float32)

    #image = map_coordinates(image, coords, order=1, mode='reflect').reshape(shape)
    image = cv2.remap(image,
                      map_x,
                      map_y,
                      interpolation=cv2.INTER_LINEAR,
                      borderMode=borderMode,
                      borderValue=(
                          0,
                          0,
                          0,
                      ))

    mask = cv2.remap(mask,
                     map_x,
                     map_y,
                     interpolation=cv2.INTER_NEAREST,
                     borderMode=borderMode,
                     borderValue=(
                         0,
                         0,
                         0,
                     ))
    mask = (mask > 0.5).astype(np.float32)
    return image, mask
Exemplo n.º 52
0
def get_radolan_grid(nrows=None, ncols=None, trig=False, wgs84=False):
    """Calculates x/y coordinates of radolan grid of the German Weather Service

    .. versionadded:: 0.4.0

    Returns the x,y coordinates of the radolan grid positions
    (lower left corner of every pixel). The radolan grid is a
    polarstereographic projection, the projection information was taken from
    RADOLAN-RADVOR-OP Kompositformat_2.2.2  :cite:`DWD2009`

    .. table:: Coordinates for 900km x 900km grid

        +------------+-----------+------------+-----------+-----------+
        | Coordinate |   lon     |     lat    |     x     |     y     |
        +============+===========+============+===========+===========+
        | LowerLeft  |  3.5889E  |  46.9526N  | -523.4622 | -4658.645 |
        +------------+-----------+------------+-----------+-----------+
        | LowerRight | 14.6209E  |  47.0705N  |  376.5378 | -4658.645 |
        +------------+-----------+------------+-----------+-----------+
        | UpperRight | 15.7208E  |  54.7405N  |  376.5378 | -3758.645 |
        +------------+-----------+------------+-----------+-----------+
        | UpperLeft  |  2.0715E  |  54.5877N  | -523.4622 | -3758.645 |
        +------------+-----------+------------+-----------+-----------+

    .. table:: Coordinates for 1100km x 900km grid

        +------------+-----------+------------+-----------+-----------+
        | Coordinate |   lon     |     lat    |     x     |     y     |
        +============+===========+============+===========+===========+
        | LowerLeft  |  4.6759E  |  46.1929N  | -443.4622 | -4758.645 |
        +------------+-----------+------------+-----------+-----------+
        | LowerRight | 15.4801E  |  46.1827N  |  456.5378 | -4758.645 |
        +------------+-----------+------------+-----------+-----------+
        | UpperRight | 17.1128E  |  55.5342N  |  456.5378 | -3658.645 |
        +------------+-----------+------------+-----------+-----------+
        | UpperLeft  |  3.0889E  |  55.5482N  | -433.4622 | -3658.645 |
        +------------+-----------+------------+-----------+-----------+

    .. table:: Coordinates for 1500km x 1400km grid

        +------------+-----------+------------+-----------+-----------+
        | Coordinate |   lon     |     lat    |     x     |     y     |
        +============+===========+============+===========+===========+
        | LowerLeft  |  2.3419E  |  43.9336N  | -673.4622 | -5008.645 |
        +------------+-----------+------------+-----------+-----------+

    Parameters
    ----------
    nrows : int
        number of rows (460, 900 by default, 1100, 1500)
    ncols : int
        number of columns (460, 900 by default, 1400)
    trig : boolean
        if True, uses trigonometric formulas for calculation
        if False, uses osr spatial reference system to transform between
        projections
        `trig` is recommended to be False, however, the two ways of computation
        are expected to be equivalent.
    wgs84 : boolean
        if True, output coordinates are in wgs84 lonlat format (default: False)

    Returns
    -------
    radolan_grid : :class:`numpy:numpy.ndarray`
        Array of shape (rows, cols, 2) xy- or lonlat-grid.

    Examples
    --------

    >>> # using osr spatial reference transformation
    >>> import wradlib.georef as georef  # noqa
    >>> radolan_grid = georef.get_radolan_grid()
    >>> print("{0}, ({1:.4f}, {2:.4f})".format(radolan_grid.shape, *radolan_grid[0,0,:]))  # noqa
    (900, 900, 2), (-523.4622, -4658.6447)

    >>> # using pure trigonometric transformations
    >>> import wradlib.georef as georef
    >>> radolan_grid = georef.get_radolan_grid(trig=True)
    >>> print("{0}, ({1:.4f}, {2:.4f})".format(radolan_grid.shape, *radolan_grid[0,0,:]))  # noqa
    (900, 900, 2), (-523.4622, -4658.6447)

    >>> # using osr spatial reference transformation
    >>> import wradlib.georef as georef
    >>> radolan_grid = georef.get_radolan_grid(1500, 1400)
    >>> print("{0}, ({1:.4f}, {2:.4f})".format(radolan_grid.shape, *radolan_grid[0,0,:]))  # noqa
    (1500, 1400, 2), (-673.4622, -5008.6447)

    >>> # using osr spatial reference transformation
    >>> import wradlib.georef as georef
    >>> radolan_grid = georef.get_radolan_grid(900, 900, wgs84=True)
    >>> print("{0}, ({1:.4f}, {2:.4f})".format(radolan_grid.shape, *radolan_grid[0,0,:]))  # noqa
    (900, 900, 2), (3.5889, 46.9526)

    See :ref:`notebooks/radolan/radolan_grid.ipynb#Polar-Stereographic-Projection`.  # noqa

    Raises
    ------
        TypeError, ValueError
    """

    # setup default parameters in dicts
    tiny = {'j_0': 450, 'i_0': 450, 'res': 2}
    small = {'j_0': 460, 'i_0': 460, 'res': 2}
    normal = {'j_0': 450, 'i_0': 450, 'res': 1}
    normal_wx = {'j_0': 370, 'i_0': 550, 'res': 1}
    extended = {'j_0': 600, 'i_0': 800, 'res': 1}
    griddefs = {(450, 450): tiny, (460, 460): small,
                (900, 900): normal, (1100, 900): normal_wx,
                (1500, 1400): extended}

    # type and value checking
    if nrows and ncols:
        if not (isinstance(nrows, int) and isinstance(ncols, int)):
            raise TypeError("wradlib.georef: Parameter *nrows* "
                            "and *ncols* not integer")
        if (nrows, ncols) not in griddefs.keys():
            raise ValueError("wradlib.georef: Parameter *nrows* "
                             "and *ncols* mismatch.")
    else:
        # fallback for call without parameters
        nrows = 900
        ncols = 900

    # tiny, small, normal or extended grid check
    # reference point changes according to radolan composit format
    j_0 = griddefs[(nrows, ncols)]['j_0']
    i_0 = griddefs[(nrows, ncols)]['i_0']
    res = griddefs[(nrows, ncols)]['res']

    x_0, y_0 = get_radolan_coords(9.0, 51.0, trig=trig)

    x_arr = np.arange(x_0 - j_0, x_0 - j_0 + ncols * res, res)
    y_arr = np.arange(y_0 - i_0, y_0 - i_0 + nrows * res, res)
    x, y = np.meshgrid(x_arr, y_arr)

    radolan_grid = np.dstack((x, y))

    if wgs84:

        if trig:
            # inverse projection
            lon0 = 10.  # central meridian of projection
            lat0 = 60.  # standard parallel of projection

            sinlat0 = np.sin(np.radians(lat0))

            fac = (6370.040 ** 2.) * ((1. + sinlat0) ** 2.)
            lon = np.degrees(np.arctan((-x / y))) + lon0
            lat = np.degrees(np.arcsin((fac - (x ** 2. + y ** 2.)) /
                                       (fac + (x ** 2. + y ** 2.))))
            radolan_grid = np.dstack((lon, lat))
        else:
            # create radolan projection osr object
            proj_stereo = create_osr("dwd-radolan")

            # create wgs84 projection osr object
            proj_wgs = get_default_projection()

            radolan_grid = reproject(radolan_grid,
                                     projection_source=proj_stereo,
                                     projection_target=proj_wgs)

    return radolan_grid
Exemplo n.º 53
0
xx = np.linspace(4, 7.2)

plt.scatter(X[y == 0, 0], X[y == 0, 1], color=MAROON, label='\emph{Iris setosa}')
plt.scatter(X[y == 1, 0], X[y == 1, 1], color=BLUE, label='\emph{Iris versicolor}')

plt.xlim(xx.min(), xx.max())
plt.ylim(1, 5)

ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx = np.linspace(xlim[0], xlim[1], 30)
yy = np.linspace(ylim[0], ylim[1], 30)
h = 0.002
xx, yy = np.meshgrid(np.arange(xx.min(), xx.max() + h, h),
                     np.arange(1, 5 + h, h))
Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])
Z = Z[:, 0] - Z[:, 1]
Z = Z.reshape(xx.shape)

ax.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
           linestyles=['--', '-', '--'])

ax.contourf(xx, yy, Z, colors=[MAROON, BLUE], levels=[-1, 0, 1], alpha=0.2)
ax.contourf(xx, yy, Z, colors=[MAROON, ], levels=[-100, -1], alpha=0.5)
ax.contourf(xx, yy, Z, colors=[BLUE, ], levels=[1, 1000], alpha=0.5)
plt.legend(loc=1)

plt.title('MLP')

plt.xlabel('Sepal length')
Exemplo n.º 54
0
def read(dictArgs):
    """Function to read in the data. Returns xarray datasets"""

    infile = dictArgs["infile"]

    # Open ice model output and the static file
    ds = xr.open_mfdataset(infile, combine="by_coords")
    if "siconc" in ds.variables:
        ds["CN"] = ds["siconc"]
        if ds["CN"].max() > 1.0:
            ds["CN"] = ds["CN"] / 100.0
    else:
        ds["CN"] = ds["CN"].sum(dim="ct")

    # Detect if we are native grid or 1x1
    if (ds.CN.shape[-2] == 180) and (ds.CN.shape[-1] == 360):
        standard_grid = True
    else:
        standard_grid = False

    if dictArgs["model"] is not None:
        # use dataset from catalog, either from command line or default
        cat_platform = (
            f"catalogs/{dictArgs['model']}_catalog_{dictArgs['platform']}.yml"
        )
        catfile = pkgr.resource_filename("om4labs", cat_platform)
        cat = intake.open_catalog(catfile)
        if standard_grid is True:
            dstatic = cat["ice_static_1x1"].to_dask()
        else:
            dstatic = cat["ice_static"].to_dask()

    # Override static file if provided
    if dictArgs["static"] is not None:
        dstatic = xr.open_dataset(dictArgs["static"])

    # Append static fields to the return Dataset
    if standard_grid is True:
        _lon = np.array(dstatic["lon"].to_masked_array())
        _lat = np.array(dstatic["lat"].to_masked_array())
        X, Y = np.meshgrid(_lon, _lat)
        ds["GEOLON"] = xr.DataArray(X, dims=["lat", "lon"])
        ds["GEOLAT"] = xr.DataArray(Y, dims=["lat", "lon"])
        _AREA = standard_grid_cell_area(_lat, _lon)
        _MASK = np.array(dstatic["mask"].fillna(0.0).to_masked_array())
        _AREA = _AREA * _MASK
        ds["CELL_AREA"] = xr.DataArray(_AREA, dims=["lat", "lon"])
        ds["AREA"] = xr.DataArray(_AREA, dims=["lat", "lon"])
        ds = ds.rename({"lon": "x", "lat": "y"})
    else:
        ds["CELL_AREA"] = dstatic["CELL_AREA"]
        ds["GEOLON"] = dstatic["GEOLON"]
        ds["GEOLAT"] = dstatic["GEOLAT"]
        ds["AREA"] = dstatic["CELL_AREA"] * 4.0 * np.pi * (6.378e6 ** 2)

    # Get Valid Mask
    valid_mask = np.where(ds["CELL_AREA"] == 0.0, True, False)

    # Open observed SIC on 25-km EASE grid (coords already named lat and lon)
    if dictArgs["obsfile"] is not None:
        dobs = xr.open_dataset(dictArgs["obsfile"])
    else:
        cat_platform = "catalogs/obs_catalog_" + dictArgs["platform"] + ".yml"
        catfile = pkgr.resource_filename("om4labs", cat_platform)
        cat = intake.open_catalog(catfile)
        dobs = cat[dictArgs["dataset"]].to_dask()

    # Close the static file (no longer used)
    dstatic.close()

    return ds, dobs, valid_mask
Exemplo n.º 55
0
def dataproc(ruta, path, paleta):

    # Open NC file
    nc = Dataset(path)

    # Load data
    data_subset = nc.variables['CMI'][:][:, :]

    # Create the projection variables
    ori_proj = nc.variables['goes_imager_projection']
    sat_h = ori_proj.perspective_point_height
    sat_lon = ori_proj.longitude_of_projection_origin
    sat_sweep = ori_proj.sweep_angle_axis
    # The projection x and y coordinates equals
    # the scanning angle (in radians) multiplied by the satellite height (http://proj4.org/projections/geos.html)
    X = nc.variables['x'][:] * sat_h
    Y = nc.variables['y'][:] * sat_h
    p = Proj(proj='geos', h=sat_h, lon_0=sat_lon, sweep=sat_sweep)
    # Convert map points to latitude and longitude with the magic provided by Pyproj
    XX, YY = np.meshgrid(X, Y)
    lons, lats = p(XX, YY, inverse=True)

    ii = []
    jj = []
    for i in range(lons.shape[1]):
        for j in range(lats.shape[0]):
            if lons[1515, i] >= -100.0 and lats[j, 2325] >= 15.0 and lons[
                    1515, i] <= -65.0 and lats[j, 2325] <= 40.0:
                ii.append(i)
                jj.append(j)

    jmin, jmax = (int(np.min(ii)), int(np.max(ii)))
    imin, imax = (int(np.min(jj)), int(np.max(jj)))

    # Create map
    DPI = 150
    ax = plt.figure(figsize=(2000 / float(DPI), 2000 / float(DPI)),
                    frameon=True,
                    dpi=DPI)
    bmap = Basemap(projection='cyl',
                   llcrnrlon=lons[1515, jmin],
                   llcrnrlat=lats[imax, 2325],
                   urcrnrlon=lons[1515, jmax],
                   urcrnrlat=lats[imin, 2325],
                   resolution='l')

    bmap.drawparallels(np.arange(-90.0, 90.0, 10.0),
                       linewidth=0.1,
                       color='black',
                       labels=[True, False, False, True])
    bmap.drawmeridians(np.arange(0.0, 360.0, 10.0),
                       linewidth=0.1,
                       color='black',
                       labels=[True, False, False, True])

    # Load Shapefile
    #    bmap.readshapefile('Nueva_DPA','Nueva_DPA',linewidth=0.90,color='darkslategray')
    #    bmap.readshapefile('ne_10m_admin_0_countries','ne_10m_admin_0_countries',linewidth=0.90,color='darkslategray')
    bmap.drawstates(color='gray', linewidth=0.25)
    bmap.drawcoastlines(color='k', linewidth=0.9)
    bmap.drawcountries(color='k', linewidth=0.9)

    # Converts a CPT file to be used in Python
    cpt = loadCPT(paleta)
    # Makes a linear interpolation
    cpt_convert = LinearSegmentedColormap('cpt', cpt)

    # Plot the GOES-16 channel with the converted CPT colors
    #bmap.pcolormesh(lons[imin:imax,jmin:jmax],lats[imin:imax,jmin:jmax],data_subset[imin:imax,jmin:jmax], cmap=cpt_convert, vmin=170, vmax=378)
    bmap.pcolormesh(lons[imin:imax, jmin:jmax],
                    lats[imin:imax, jmin:jmax],
                    data_subset[imin:imax, jmin:jmax] - 273.15,
                    cmap=cpt_convert,
                    vmin=-103,
                    vmax=104)

    # Search for the GOES-16 channel in the file name
    Band = (path[path.find("M3C") + 3:path.find("_G16")])
    # Search for the Scan start in the file name
    Start = (path[path.find("_s") + 2:path.find("_e")])
    Start_Formatted = Start[0:4] + " Day " + Start[4:7] + " - " + Start[
        7:9] + ":" + Start[9:11] + ":" + Start[11:13] + "." + Start[
            13:14] + " UTC"
    # Search for the Scan end in the file name
    End = (path[path.find("_e") + 2:path.find("_c")])
    End_Formatted = End[0:4] + " Day " + End[4:7] + " - " + End[
        7:9] + ":" + End[9:11] + ":" + End[11:13] + "." + End[13:14] + " UTC"

    # Add a title to the plot
    plt.title("GOES-16 ABI Band " + Band + "\n Scan from " + Start_Formatted +
              " to " + End_Formatted,
              fontsize=10)

    #bmap.colorbar(location='right', label='Brightness Temperature [K]')
    bmap.colorbar(location='right', label='Brightness Temperature [C]')

    # Save the result
    # Converting from julian day to dd-mm-yyyy
    year = int(Start[0:4])
    dayjulian = int(
        Start[4:7]) - 1  # Subtract 1 because the year starts at "0"
    dayconventional = datetime.datetime(year, 1, 1) + datetime.timedelta(
        dayjulian)  # Convert from julian to conventional
    date = dayconventional.strftime(
        '%d-%b-%Y')  # Format the date according to the strftime directives
    date_save = dayconventional.strftime('%d%m%Y')
    time_save = Start[7:9] + Start[9:11] + Start[11:13]
    plt.savefig('G16_C' + str(Band) + '_' + date_save + '_' + time_save +
                '_fulldisk.png',
                dpi=DPI,
                bbox_inches='tight',
                pad_inches=0)
    plt.clf()
    plt.cla()
Exemplo n.º 56
0
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
import numpy as np

map = Basemap(projection='sinu', lat_0=0, lon_0=0)

lons = np.arange(30, 390, 30)
lats = np.arange(0, 100, 10)

data = np.indices((lats.shape[0], lons.shape[0]))
data = data[0] + data[1]

print data

print lons

lons, data = map.shiftdata(lons, datain=data, lon_0=0)

print lons

llons, llats = np.meshgrid(lons, lats)

x, y = map(llons, llats)

map.contourf(x, y, data)

map.drawcoastlines()
plt.show()
font = {'family': 'Arial',
        'weight': 'bold',
        'size': 10,
        }
####LOAD DATA ####

obs_data_full = np.genfromtxt('model-data/contour_plot_data.csv', delimiter=',', skip_header=1)

####Interpolation for contours and heatmap
R0 = obs_data_full[:,0]
I0 = np.log10(obs_data_full[:,1])
prob = obs_data_full[:,4]

xi_full, yi_full2 = np.linspace(I0.min(), 2, 300), np.linspace(R0.min(), 1.5, 300)
xi_full, yi_full2 = np.meshgrid(xi_full, yi_full2)
zi_full2 = scipy.interpolate.griddata((I0, R0), prob, (xi_full, yi_full2), method='linear')


#### Make plot
fig3 = plt.subplot(1,1,1)
plt.contourf(xi_full, yi_full2, zi_full2, 9, cmap=plt.cm.jet, alpha = 0.75)
plt.colorbar() 
CS = plt.contour(xi_full, yi_full2, zi_full2, 9, colors='black', linewidth=.5)


# for labels but plotted on the log scale
class nf(float):
    def __repr__(self):
        str = '%.1f' % (self.__float__(),)
        if str[-1] == '0':
# =============================================================================
# First file: full-lift-down
# =============================================================================

### Start with uncertainty bars on landline and spaceline
## Load file archive and get data
filename = './../results/sweeps/Neptune_27_3sigLow_0.25_180_0522005334.npz'
data = np.load(filename, allow_pickle=True)
# params = data['params'][0] # array of 1
outsList = data['outsList']
efpaList = data['efpaList']
BCList = data['BCList']

## Create mesh grid for contour plots, reshape result arrays
BCgrid, EFPAgrid = np.meshgrid(BCList, efpaList)
fpafgrid = np.reshape([out.fpaf for out in outsList], BCgrid.shape)
engfgrid = np.reshape([out.engf for out in outsList], BCgrid.shape)

# find line between landing and aerocapture
landline_BC_low = BCList
landline_EFPA_low = []
for rind in range(fpafgrid.shape[1]):
    ind = next(ind for ind, val in enumerate(fpafgrid[:,rind])\
               if val < 0)
    landline_EFPA_low.append(efpaList[ind])
    
# find line between aerocapture and escape
spaceline_BC_low = []
spaceline_EFPA_low = []
for rind in range(engfgrid.shape[1]):
Exemplo n.º 59
0
def tile_anchors_3d(area_extents, anchor_3d_sizes, anchor_stride,
                    ground_plane):
    """
    Tiles anchors over the area extents by using meshgrids to
    generate combinations of (x, y, z), (l, w, h) and ry.

    Args:
        area_extents: [[min_x, max_x], [min_y, max_y], [min_z, max_z]]
        anchor_3d_sizes: list of 3d anchor sizes N x (l, w, h)
        anchor_stride: stride lengths (x_stride, z_stride)
        ground_plane: coefficients of the ground plane e.g. [0, -1, 0, 0]

    Returns:
        boxes: list of 3D anchors in box_3d format N x [x, y, z, l, w, h, ry]
    """
    # Convert sizes to ndarray
    anchor_3d_sizes = np.asarray(anchor_3d_sizes)

    anchor_stride_x = anchor_stride[0]
    anchor_stride_z = anchor_stride[1]
    anchor_rotations = np.asarray([0, np.pi / 2.0])

    x_start = area_extents[0][0] + anchor_stride[0] / 2.0
    x_end = area_extents[0][1]
    x_centers = np.array(np.arange(x_start, x_end, step=anchor_stride_x),
                         dtype=np.float32)

    z_start = area_extents[2][1] - anchor_stride[1] / 2.0
    z_end = area_extents[2][0]
    z_centers = np.array(np.arange(z_start, z_end, step=-anchor_stride_z),
                         dtype=np.float32)

    # Use ranges for substitution
    size_indices = np.arange(0, len(anchor_3d_sizes))
    rotation_indices = np.arange(0, len(anchor_rotations))

    # Generate matrix for substitution
    # e.g. for two sizes and two rotations
    # [[x0, z0, 0, 0], [x0, z0, 0, 1], [x0, z0, 1, 0], [x0, z0, 1, 1],
    #  [x1, z0, 0, 0], [x1, z0, 0, 1], [x1, z0, 1, 0], [x1, z0, 1, 1], ...]
    before_sub = np.stack(np.meshgrid(x_centers, z_centers, size_indices,
                                      rotation_indices),
                          axis=4).reshape(-1, 4)

    # Place anchors on the ground plane
    a, b, c, d = ground_plane
    all_x = before_sub[:, 0]
    all_z = before_sub[:, 1]
    all_y = -(a * all_x + c * all_z + d) / b

    # Create empty matrix to return
    num_anchors = len(before_sub)
    all_anchor_boxes_3d = np.zeros((num_anchors, 7))

    # Fill in x, y, z
    all_anchor_boxes_3d[:, 0:3] = np.stack((all_x, all_y, all_z), axis=1)

    # Fill in shapes
    sizes = anchor_3d_sizes[np.asarray(before_sub[:, 2], np.int32)]
    all_anchor_boxes_3d[:, 3:6] = sizes

    # Fill in rotations
    rotations = anchor_rotations[np.asarray(before_sub[:, 3], np.int32)]
    all_anchor_boxes_3d[:, 6] = rotations

    return all_anchor_boxes_3d
Exemplo n.º 60
0
ax = plt.subplot(111)
ZM = np.arange(1, 200, 0.35)

nx = 384
ny = 216
n_iter = 80

for zm in ZM:
    zmf = np.exp(-zm/20.)

    x1 = x0 - 2 * zmf
    x2 = x0 + 2 * zmf
    y1 = y0 - 1.13 * zmf
    y2 = y0 + 1.13 * zmf


    x, y = np.meshgrid(np.linspace(x1, x2, nx), np.linspace(y1, y2, ny))
    c = x + 1j*y
    z = np.zeros(c.shape)
    I = np.zeros(c.shape)

    for k in range(n_iter):
        z = z ** degree + c
        ind = (np.abs(z) > tol) * (I == 0)
        I[ind] = 255 - k

    ax.imshow(I, extent=(x1, x2, y1, y2)) #, shape=(3840, 2160), interpolation='bilinear')
    plt.pause(0.001)
    ax.cla()