def inner_extract(self,B,signature):
        w,h =B.shape[:2]
 
        LL,(HL,LH,HH) = pywt.dwt2(B[:32*(w//32),:32*(h//32)],''haar'') 
        LL_1,(HL_1,LH_1,HH_1) = pywt.dwt2(LL,''haar'') 
        LL_2,(HL_2,LH_2,HH_2) = pywt.dwt2(LL_1,''haar'') 
        LL_3,(HL_3,LH_3,HH_3) = pywt.dwt2(LL_2,''haar'')
        LL_4,(HL_4,LH_4,HH_4) = pywt.dwt2(LL_3,''haar'')
 
        _,_,ori_sig = self._gene_embed_space(HH_3)
 
        ext_sigs=[]
        ext_sigs.extend(self._extract_sig(ori_sig,len(signature)))
        ext_sigs.extend(self._extract_sig(np.rot90(ori_sig,1),2),3),len(signature)))
 
        return ext_sigs

def mk_rotations(img):
    #
    #   DESCRIPTION
    #       This function create 8 roatation image fro an input image 4 rotation from the raw image and 4 rotation form the transposed 
    #   
    #   INPUTS
    #       img np.array 
    #       
    #   OUTPUTS
    #       rotated_image_img,img90,img180,img270,imgT,imgT90,imgT180,imgT270
    #
    #
    img90 = np.rot90(img)
    img180 = np.rot90(img,k=2)
    img270 = np.rot90(img,k=3)
    imgT = np.zeros(img.shape)
    if np.size(img.shape)>2:
        for i in range(3):
            imgT[:,:,i] =img[:,i].T
    else:
        imgT = img.T
    imgT90 = np.rot90(imgT)
    imgT180 = np.rot90(imgT, k=2)
    imgT270 = np.rot90(imgT, k=3)
    return img, img90, img180, img270, imgT, imgT90, imgT180,imgT270

def unrotate(rot0, rot1, rot2, rot3, rot4, rot5, rot6, rot7):
    #
    #   DESCRIPTION 
    #       Functions that merges the 8 mapped images as described in the beginning of the file back to the original format
    #       Uses element wise product  
    #
    #
    unrot = np.copy(rot0)
    unrot*=np.rot90((rot1),k=3)
    unrot*=np.rot90((rot2),k=2)
    unrot*=np.rot90((rot3),k=1) 
 
    unrot*=(rot4.T)
    unrot*=np.rot90((rot5),k=3).T
    unrot*=np.rot90((rot6),k=2).T 
    unrot*=np.rot90((rot7),k=1).T 
 
    return unrot
 
##                      ##
##                      ##
##      EXECUTION       ##
##                      ##
##                      ##

def mk_rotations(img):
    ##INPUT:
    ##  img: a 3D RGB array
    ##OUTPUT
    ##  8 rotated and transposed versions of img
 
    img90 = np.rot90(img)
    img180 = np.rot90(img,imgT270
 
## Formats an image to save format

def getMagSpec(sig, rate, winlen, winstep, nfft):
 
    #get frames
    winfunc = lambda x:np.ones((x,))
    frames = psf.sigproc.framesig(sig, winlen*rate, winstep*rate, winfunc)        
 
    #Magnitude Spectrogram
    magspec = np.rot90(psf.sigproc.magspec(frames, nfft))
 
    return magspec
 
#Split signal into five-second chunks with overlap of 4 and minimum length of 3 seconds
#Use these settings for other chunk lengths:
#winlen,winstep,seconds
#0.05,0.0097,5s
#0.05,0.0195,10s
#0.05,0.0585,30s

def getMagSpec(sig, nfft))
 
    return magspec
 
#Split signal into five-second chunks with overlap of 4 and minimum length of 1 second
#Use these settings for other chunk lengths:
#winlen,30s

def test_discrete_phantom_uniform():
    """The uniform discrete phantom is the same after rotating 90 degrees."""
 
    d0 = discrete_phantom(p, 100, ratio=10, prop=''mass_atten'')
 
    p.rotate(theta=np.pi/2, point=Point([0.5, 0.5]))
    d1 = np.rot90(discrete_phantom(p, prop=''mass_atten''))
 
    # plot rotated phantom
    plot_phantom(p)
 
    # plot the error
    plt.figure()
    plt.imshow(d1-d0, interpolation=None)
    plt.colorbar()
 
    # plt.show(block=True)
    # assert_allclose(d0,d1)

def load_dotted_image(self, train_id, scale=1, border=0, circled=False):
        img = self._load_image(''dotted'', scale, border)
 
        if train_id in self.extra_masks:
            for row, col, radius in self.extra_masks[train_id]:
                rr, cc = skimage.draw.circle(row, radius, shape = img.shape)
                img = np.copy(img)
                img[rr, cc] = (0, 0, 0)
 
        # When dotted image is rotated relative to train,apply hot patch. (kudos: @authman)
        if train_id in self.dotted_rotate:
            rot = self.dotted_rotate[train_id]
            img = np.rot90(img, rot)
 
        if circled: 
            assert scale == 1
            assert border == 0
            img = np.copy(img)
            img = self.draw_circles(np.copy(img), self.tid_coords[train_id])        
 
        return img

def get_lateral(self, resolution=0.5):
        if hasattr(self, "lateral") and resolution == resolution:
            return self.lateral
        max_dist = self.get_max_dist()
        dim = np.ceil(np.absolute(max_dist / resolution))
        max_dist = dim * resolution
        self.resolution = resolution
        a = np.meshgrid(np.linspace(0, max_dist, dim), np.linspace(0, dim))
        r = (a[0]**2 + a[1]**2)**0.5
        sigma = self.sigma / ((8 * log(2))**0.5)
        lateral = 1 / ((2 * pi * sigma**2)**0.5) * np.exp(-(r**2) / (2 * sigma**2))
        tot_lat = np.zeros((2 * dim - 1, 2 * dim - 1))
 
        tot_lat[dim - 1:2 * dim - 1, dim - 1:2 * dim - 1] = lateral
        tot_lat[dim - 1:2 * dim - 1, 0:dim - 1] = np.rot90(lateral, 3)[:, 0:dim - 1]
        tot_lat[0:dim - 1, 2)[0:dim - 1, dim - 1:2 * dim - 1] = np.rot90(lateral)[0:dim - 1, :]
 
        self.lateral = tot_lat
        return self.lateral

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

def _augment_chunks(self, chunks):
        if self.choices_augmentation is None:
            return chunks
        chunks_new = []
        choice = np.random.choice(self.choices_augmentation)
        for chunk in chunks:
            chunk_new = chunk
            if choice in [1, 3, 5, 7]:
                chunk_new = np.flip(chunk_new, axis=1)
            if   choice in [2, 3]:
                chunk_new = np.rot90(chunk_new, 1, axes=(1, 2))
            elif choice in [4, 5]:
                chunk_new = np.rot90(chunk_new, 2, 2))
            elif choice in [6, 7]:
                chunk_new = np.rot90(chunk_new, 2))
            chunks_new.append(chunk_new)
        return chunks_new

def random_augment_image(image, row):
    # start0_max,end0_max,start1_max,end1_max = get_bounding_Boxes_positions(image,row)
    # image = cv2.rectangle(image,(int(start1_max),int(start0_max)),(int(end1_max),int(end0_max)),(0,255),thickness=5)
    if random.randint(0, 1) == 0:
        image = return_random_crop(image, row)
    else:
        image = return_random_perspective(image, row)
    image = random_rotate(image)
 
    # all possible mirroring and flips (in total there are only 8 possible configurations)
    mirror = random.randint(0, 1)
    if mirror != 0:
        image = image[::-1, :, :]
    angle = random.randint(0, 3)
    if angle != 0:
        image = np.rot90(image, k=angle)
 
    image = lightning_change(image)
    image = blur_image(image)
 
    return image

def rot(self):
        for i in range(len(self.Q)):
            Q       = self.Q[i]
            ans     = self.ans[i]
            refarea = self.area[i]
            refMask = self.mask[i]
 
            for rotate in range(3):
                self.Q.append(Q)
                self.ans.append(ans)
 
                refarea = np.rot90(refarea)
                refMask = np.rot90(refMask)
 
                self.area.append(refarea)
                self.mask.append(refMask)
 
        return self

def rot90(img):
    ''''''
    rotate one or multiple grayscale or color images 90 degrees
    ''''''
    s = img.shape
    if len(s) == 3:
        if s[2] in (3, 4):  # color image
            out = np.empty((s[1], s[0], s[2]), dtype=img.dtype)
            for i in range(s[2]):
                out[:, i] = np.rot90(img[:, i])
        else:  # mutliple grayscale
            out = np.empty((s[0], s[2], s[1]), dtype=img.dtype)
            for i in range(s[0]):
                out[i] = np.rot90(img[i])
    elif len(s) == 2:  # one grayscale
        out = np.rot90(img)
    elif len(s) == 4 and s[3] in (3, 4):  # multiple color
        out = np.empty((s[0], s[1], s[3]), dtype=img.dtype)
        for i in range(s[0]):  # for each img
            for j in range(s[3]):  # for each channel
                out[i, j] = np.rot90(img[i, j])
    else:
        NotImplemented
    return out

def shot_heatmap(df,sigma = 1,log=False,player_pic=True,ax=None,cmap=''jet''):
    ''''''
    This function plots a heatmap based on the shot chart.
    input - dataframe with x and y coordinates.
    optional - log (default false) plots heatmap in log scale. 
               player (default true) adds player''s picture and name if true 
               sigma - the sigma of the Gaussian kernel. In feet (default=1)
    ''''''
    n,_ = np.histogram2d( 0.1*df[''LOC_X''].values, 0.1*df[''LOC_Y''].values,bins = [500, 500],range = [[-25,25],[-5.25,44.75]])
    KDE = ndimage.filters.gaussian_filter(n,10.0*sigma)
    N = 1.0*KDE/np.sum(KDE)
    if ax is None:
        ax = plt.gca(xlim = [30,-30],ylim = [-7,43],xticks=[],yticks=[],aspect=1.0)
    court(ax,outer_lines=True,color=''black'',lw=2.0,direction=''down'')
    ax.axis(''off'')
    if log:
        ax.imshow(np.rot90(np.log10(N+1)),cmap=cmap,extent=[25.0, -25.0, -5.25, 44.75])
    else:
        ax.imshow(np.rot90(N), 44.75])
    if player_pic:
        player_id = df.PLAYER_ID.values[0]
        pic = players_picture(player_id)
        ax.imshow(pic,extent=[15,25,30,37.8261])
    ax.text(0,-7,''By: Doingthedishes'',color=''white'',horizontalalignment=''center'',fontsize=20,fontweight=''bold'')

def rot90(self, turns=1):
        """
        Rotates the blocks in the counter-clockwise direction. (As numpy
        does it.)
        """
        # Rotate the individual Y-layer matrices
        new_blocks = np.array([np.rot90(by, turns) for by in self.blocks])
        new_data = np.array([np.rot90(dy, turns) for dy in self.data])
        new_mask = np.array([np.rot90(my, turns) for my in self.mask])
 
        # Rotate the data (if applicable)
        for y in xrange(new_data.shape[0]):
            for z in xrange(new_data.shape[1]):
                for x in xrange(new_data.shape[2]):
                    b = new_blocks[y, z, x]
                    d = new_data[y, x]
                    new_data[y, x] = self.data_rot90(b, d, turns)
 
        return MaskedSubChunk(new_blocks, new_data, new_mask)

def data_rot90(self, block, data, turns):
        """
        Specially rotate this block,which has an orientation that depends on
        the data value.
        """
        blockname = blocks.block_names[block]
 
        # Torches (redstone and normal)
        torches = ["redstone_torch", "unlit_redstone_torch", "torch"]
        if blockname in torches:
            return blocks.Torch.rot90(data, turns)
 
        # Repeaters
        repeaters = ["unpowered_repeater", "powered_repeater"]
        if blockname in repeaters:
            return blocks.Repeater.rot90(data, turns)
 
        # Comparators
        comparators = ["unpowered_comparator", "powered_comparator"]
        if blockname in comparators:
            return blocks.Comparator.rot90(data, turns)
 
        return data

def _display_pixels(x, y, counts, pixelsize):
    """
    display pixels at coordinates (x,y) coloured with "counts".
    This routine is fast but not fully general as it assumes the spaxels
    are on a regular grid. This needs not be the case for Voronoi binning.
 
    """
    xmin, xmax = np.min(x), np.max(x)
    ymin, ymax = np.min(y), np.max(y)
    nx = int(round((xmax - xmin)/pixelsize) + 1)
    ny = int(round((ymax - ymin)/pixelsize) + 1)
    img = np.full((nx, ny), np.nan)  # use nan for missing data
    j = np.round((x - xmin)/pixelsize).astype(int)
    k = np.round((y - ymin)/pixelsize).astype(int)
    img[j, k] = counts
 
    plt.imshow(np.rot90(img), interpolation=''nearest'', cmap=''prism'',
               extent=[xmin - pixelsize/2, xmax + pixelsize/2,
                       ymin - pixelsize/2, ymax + pixelsize/2])
 
#----------------------------------------------------------------------

def visualize2D(fig, ax, xs, ys, bins=200,
                xlabel=''x'', ylabel=''y'',
                xlim=None, ylim=None):
    H, xedges, yedges = numpy.histogram2d(xs, bins)
    H = numpy.rot90(H)
    H = numpy.flipud(H)
    Hmasked = numpy.ma.masked_where(H == 0, H)
 
    ax.pcolormesh(xedges, yedges, Hmasked)
 
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
 
    if xlim is None:
        xlim = (min(xs), max(xs))
    if ylim is None:
        ylim = (min(ys), max(ys))
    ax.set_xlim(*xlim)
    ax.set_ylim(*ylim)
    fig.colorbar(pyplot.contourf(Hmasked))

def rot180(images):
    """
    ????180??
    ??HW/CHW/NCHW?????images?
    """
    out = np.empty(shape=images.shape, dtype=images.dtype)
    if images.ndim == 2:
        out = np.rot90(images, k=2)
    elif images.ndim == 3:
        for c in xrange(images.shape[0]):
            out[c] = np.rot90(images[c], k=2)
    elif images.ndim == 4:
        for n in xrange(images.shape[0]):
            for c in xrange(images.shape[1]):
                out[n][c] = np.rot90(images[n][c], k=2)
    else:
        raise Exception(''Invalid ndim: '' + str(images.ndim) +
                        '',only support ndim between 2 and 4.'')
    return out
 
 
# ????f????x???f???df???x???

def grad_magnitude(img):
    """Calculate the gradient magnitude of an image.
    Args:
        img The image
    Returns:
        gradient image"""
    img = img / 255.0
    sobel_y = np.array([
        [-1, -2, -1],
        [0, 0],
        [1, 1]
    ])
    sobel_x = np.rot90(sobel_y) # rotates counter-clockwise
 
    # apply x/y sobel filter to get x/y gradients
    imgx = signal.correlate(img, sobel_x, mode="same")
    imgy = signal.correlate(img, sobel_y, mode="same")
    imgmag = np.sqrt(imgx**2 + imgy**2)
 
    return imgmag

def main():
    """Load image,apply filter,plot."""
    img = data.camera()
 
    # just like sobel,but no -2/+2 in the middle
    prewitt_y = np.array([
        [-1, -1, 1]
    ])
    prewitt_x = np.rot90(prewitt_y) # rotates counter-clockwise
 
    img_sx = signal.correlate(img, prewitt_x, mode="same")
    img_sy = signal.correlate(img, prewitt_y, mode="same")
    g_magnitude = np.sqrt(img_sx**2 + img_sy**2)
 
    ground_truth = skifilters.prewitt(data.camera())
 
    util.plot_images_grayscale(
        [img, img_sx, img_sy, g_magnitude, ground_truth],
        ["Image", "Prewitt (x)", "Prewitt (y)", "Prewitt (both/magnitude)",
         "Prewitt (Ground Truth)"]
    )

def augment_image(self, image, i):
    if i == 0:
      return np.rot90(image)
    elif i == 1:
      return np.rot90(image,2)
    elif i == 2:
      return np.rot90(image,3)
    elif i == 3:
      return image
    elif i == 4:
      return np.fliplr(image)
    elif i == 5:
      return np.flipud(image)
    elif i == 6:
      return image.transpose(1,0,2)
    elif i == 7:
      return np.fliplr(np.rot90(image))