def retrieve(self, request, pano_id=None, heading=0):
        target_heading = get_int_value(
            request, 'heading', default=heading, upper=360, strategy='modulo')

        target_width = get_int_value(
            request, 'width', default=750,
            lower=1, upper=1600, strategy='cutoff')

        target_fov = get_int_value(
            request, 'fov', default=80, upper=120, strategy='cutoff')

        target_width, target_fov = self._max_fov_per_width(target_width, target_fov)

        target_horizon = get_float_value(
            request, 'horizon', default=0.3, lower=0.0, upper=1.0)
        target_aspect = get_float_value(
            request, 'aspect', default=1.5, lower=1.0)

        pano = get_object_or_404(Panoramas, pano_id=pano_id)
        thumb = Thumbnail(pano)
        thumb_img = thumb.get_image(target_width=target_width,
                                    target_fov=target_fov,
                                    target_horizon=target_horizon,
                                    target_heading=target_heading,
                                    target_aspect=target_aspect)

        response = HttpResponse(content_type="image/jpeg")
        misc.toimage(thumb_img).save(response, "JPEG")
        return response

   def _data_images():
       """ Make images with linear scaling, sqrt scaling, log scaling.
       This might take a little bit of time. """
       mag, phase = np.abs(self.rs_data), np.angle(self.rs_data)
       mag *= self.blocker
       
       # resize, then save the color and scale permutations of first_frame.
       linr = mag
       sqrt = np.sqrt(mag)
       logd = np.log((mag-mag.min())/mag.max()*1000+1)
 
       self.rs_image_linr = io.complex_hsv_image(linr)
       self.rs_image_sqrt = io.complex_hsv_image(sqrt*np.exp(1j*phase))
       self.rs_image_log = io.complex_hsv_image(logd*np.exp(1j*phase))
       
       imgs = {'logd':smp.toimage(self.rs_image_log),
               'sqrt':smp.toimage(self.rs_image_sqrt),
               'linr':smp.toimage(self.rs_image_linr)}
       
       base = './static/imaging/images/ifth_session%s_id%s_%s_%s.%s'
       for key, val in imgs.items():
           val.save(base%(self.session_id, self.data_id,
                          self.blocker_power, key, 'png'))
           val.save(base%(self.session_id, self.data_id,
                          self.blocker_power, key, 'jpg'))

    def print_map(self):
        ocmap = []
        for line in self.occupancy_map:
            ocmap.append([cell[0] for cell in line])

        npmap = np.array(ocmap)
        toimage(npmap, cmin=0.0, cmax=1.0).save('occupancy_map.jpeg')

def detect_blur(f):
  print "Processing %s" % f
  im = Image.open("images/orig_"+f+".jpeg") 
  im = im.convert('F')
  im = array(im)

  im = filters.laplace(im)
  laplacien_im = im
  toimage(im).save(out_dir+"/laplacien_"+f+".png", "png")
  im = morphology.white_tophat(im, (3,3))
  tophat_im = im
  toimage(im).save(out_dir+"/tophat_"+f+".png", "png")
  
  im = filters.percentile_filter(im, 30, 1)

  toimage(im).save(out_dir+"/final_"+f+".png", "png")
  
  subprocess.call("/usr/local/bin/convert %s/final_%s.png %s/ppm_final_%s.ppm" % (out_dir, f, out_dir,f), shell=True)
  
  subprocess.call("./segment/segment 0.8 100 100 %s/ppm_final_%s.ppm %s/segment_%s.ppm" % (out_dir, f, out_dir,f), shell=True)
  
  im_seg = Image.open("%s/segment_%s.ppm" % (out_dir, f))
  im_seg = array(im_seg)
  
  print "laplacien"
  
  laplacian_mask = build_mask(im_seg, laplacien_im)
  toimage(laplacian_mask).save(out_dir+"/laplacian_mask_"+f+".png", "png")
  
  print "tophat"
  
  tophat_mask = build_mask(im_seg, tophat_im, 10)
  toimage(tophat_mask).save(out_dir+"/tophat_mask_"+f+".png", "png")

def rgbtiffstojpg(files, path, name):
    '''
    files: a list of files ordered as follow. 0: Blue Band 1: Green Band 2: Red Band
    path: the path to look for the tiff files and to save the jpg
    '''
    import scipy.misc as sm
    import gdal
    import numpy as np
    b2_link = gdal.Open(path+"/tiff/"+files[0])
    b3_link = gdal.Open(path+"/tiff/"+files[1])
    b4_link = gdal.Open(path+"/tiff/"+files[2])

    # call the norm function on each band as array converted to float
    def norm(band):
        band_min, band_max = band.min(), band.max()
        return ((band - band_min) / (band_max - band_min))

    b2 = norm(b2_link.ReadAsArray().astype(np.float))
    b3 = norm(b3_link.ReadAsArray().astype(np.float))
    b4 = norm(b4_link.ReadAsArray().astype(np.float))

    # Create RGB
    rgb = np.dstack((b4, b3, b2))
    del b2, b3, b4
    sm.toimage(rgb, cmin=np.percentile(rgb,2), cmax=np.percentile(rgb,98)).save(path+'/images/'+name)

 def arrayVisualizeS1(self): # Used to plot all of the arrays
     for a,n in zip(self.S1.arrays,range(12)): # Plots all of the S1 arrays
         array = a.arr
         ph = np.empty(array.shape)
         for i in range(array.shape[0]):
             for j in range(array.shape[1]):
                 ph[i,j]= array[i,j].output
                 img = toimage(ph)
         plt.subplot(5,3,n+1)
         plt.imshow(img)
         plt.title('S1_{0}'.format(n+1))
     ph = np.empty(self.C0.arrays[0].arr.shape)
     for i in range(self.C0.arrays[0].arr.shape[0]): # Plots the input array
             for j in range(self.C0.arrays[0].arr.shape[1]):
                 ph[i,j]= self.C0.arrays[0].arr[i,j].output
                 img = toimage(ph)
     plt.subplot(5,3,13)
     for i in range(self.V0.arrays[0].arr.shape[0]): # Plots the inhibitory array
         for j in range(self.V0.arrays[0].arr.shape[1]):
             ph[i,j]= self.V0.arrays[0].arr[i,j].output
             img = toimage(ph)
     plt.subplot(5,3,13)
     plt.imshow(img)
     # plt.subplot(5,3,13)
     plt.title('C0')
     plt.tight_layout()
     plt.draw()

def pairdump():
    "可视化模型列"
    from layerbase import DrawPatch
    import cPickle
    sparsedirect = cPickle.load(file('sparselinked','rb'))
    drec = sparsedirect.components_.reshape((-1,1,70-25,90-0))
    misc.toimage(DrawPatch(drec)).save('dictpair.jpg')

def overlay_predictions(image, im_softmax,image_shape, threshold, channel, seg_color=(0,255,0,172)):
    """creates a overlay using pixels with p(class) > threshold"""

    segmentation = np.expand_dims(im_softmax[:,:,channel] > threshold, 2)
    mask = segmentation * np.reshape(np.array(seg_color), (1,1,-1))
    mask = misc.toimage(mask, mode="RGBA")
    street_im = misc.toimage(image)
    street_im.paste(mask, box=None, mask=mask)
    return street_im

def test_jpg(w, img):
    prev_i = 100
    for i in range(prev_i, 0, -5):
        print i,
        misc.toimage(img).save("out.jpg", quality = i)
        if w.extract(misc.imread("out.jpg")) is None:
            return prev_i
        prev_i = i
    return "unbound"

def test_jpg(w, img):
    prev_i = 100
    for i in range(prev_i, 0, -5):
        misc.toimage(img).save("out.jpg", quality = i)
        try:
            w.extract(misc.imread("out.jpg"))
        except ReedSolomonError:
            return prev_i
        prev_i = i
    return 5

def showtransform():
    "显示神经网络转换结果"
    trans = np.load('transform.npy')[:,0]
    glassmodel = np.load('glassline.npy').astype('f').reshape((-1,45,90))
    glassmodel /= np.max(glassmodel)
    trans = np.insert(trans,2,glassmodel,axis=1)
    p = trans[:,0].reshape((trans.shape[0],-1))
    trans[:,0] -= ((p.max(axis=1)+p.mean(axis=1))*0.5).reshape((-1,1,1))
    trans[:,0] = np.where(trans[:,0]>0, trans[:,0],0)
    from layerbase import DrawPatch
    misc.toimage(DrawPatch(trans,False,'bgy')).save('nntrans.png')

def reshapeAndPrint( components, fold ):
    '''Takes in the vector encoding of each of the nmf components
    and plots them to file'''
    imHeight = 192
    imWidth = 168
    nComp = np.shape(components)[0]
    for comp in range(nComp):
        image = np.reshape(components[comp,:],(imHeight,imWidth),order='C')
        savestring = './Results/images/nComp' + str(nComp) + \
            '_comp' + str(comp) + '_fold' + str(fold) + '.jpg'
        misc.toimage(image, cmin=0.0, cmax=...).save(savestring)

def png_buffer(array):
    """Convert an array to PNG, handling transparency in an
    at-least-partially-sane manner."""
    assert array.ndim == 2

    im = toimage(array)
    alpha = toimage(array != 0)
    im.putalpha(alpha)

    # Return format is a buffer of PNG-encoded data
    fp = BytesIO()
    im.save(fp, format='png')

    return fp.getbuffer()

def main():
    image = bayer("itau02.png")
    template = bayer("keyboard.png")

    correlation = correlate(image, template)
    c_max = max(correlation)
    c_min = min(correlation)

    signal = (correlation - c_min) * 255 / (c_max - c_min)
    toimage(signal).save("signal.png")

    winner = where(correlation == c_max, 255, 0)
    toimage(winner).save("winner.png")
    print searchmax(winner)

def get_phase(args):
    
    filename = args[0]
    path = args[1]
    path_raw = args[2]
    path_images = args[3]
    mask = args[4]
    coord = args[5]

    file_in = os.path.join(path,filename)
    file_raw = os.path.join(path_raw,'raw_'+filename)
    image_phase = os.path.join(path_images,'wrapped'+filename[4:11]+'bmp')
    binary_phase = os.path.join(path_raw,'wrapped'+filename[4:11]+'dat')
    mod_arr = os.path.join(path_raw,'mod'+filename[4:11]+'dat')
    mod_image = os.path.join(path_images,'mod'+filename[4:11]+'bmp')
    qual_arr = os.path.join(path_raw,'qual'+filename[4:11]+'dat')
    qual_image = os.path.join(path_images,'qual'+filename[4:11]+'bmp')
    # Open meas file and grab dataset
    try:
        f = File(file_in, 'r')
    except:
        print 'Corrupt h5 file: '+filename+' ignoring'
        return
    sub = f.get(r'measurement0/frames/frame_full/data')
    data = np.array(sub[coord[0]-1:coord[1]+1,coord[2]-1:coord[3]+1],'f')
    f.close()

    # Get phase
    phase, modulation, intensity = calc_phase(data)
    # Apply mask
    phase[~mask] = 0
    intensity[~mask] = 0
    modulation[~mask] = 0
    #phase = phase[coord[0]:coord[1],coord[2]:coord[3]]
    
    # Save phase
    toimage(phase).save(image_phase)
    phase.tofile(binary_phase)


    ave_mod = np.average(modulation[mask])
    ave_int = np.average(intensity[mask])
    '''
    if ave_mod < 0.6:
        print filename+' low mod:', ave_mod
    else:
        sys.stdout.write('.')
    '''
    return "%s,%f,%f\n" % (filename, ave_int, ave_mod)

def main():
    # image_array = load_images('olsh.dat')
    # im = Image.open("test_image_1.png")
    gray = ndimage.imread("test_image_1.png", flatten=True)
    # toimage(gray).show()

    subsamples = get_subsamples([gray])    

    for i, sample in enumerate(subsamples):
        pca = PCA.PCA(sample, 90)
        compressed = toimage(pca.get_compressed_matrix())
        filename = 'pca_images/im_ex' + str(i) + '.png'
        print filename
        imsave(filename, compressed)
        toimage(compressed).show()

def original_color_transform(content, generated, mask=None):
    generated = fromimage(toimage(generated, mode='RGB'), mode='YCbCr')  # Convert to YCbCr color space

    if mask is None:
        generated[:, :, 1:] = content[:, :, 1:]  # Generated CbCr = Content CbCr
    else:
        width, height, channels = generated.shape

        for i in range(width):
            for j in range(height):
                if mask[i, j] == 1:
                    generated[i, j, 1:] = content[i, j, 1:]

    generated = fromimage(toimage(generated, mode='YCbCr'), mode='RGB')  # Convert to RGB color space
    return generated

def domedmask():
    diff = np.load('rpca_diff.npy').reshape((-1,70-25,90-0))
    diffmask = np.where(diff>50,255,0)
    from bigrec import bigrec
    maskall = np.zeros((diff.shape[0],105,90),np.int0)
    glassorig = np.load('glassorig.npy').reshape((-1,105,90))
    noglass = np.zeros_like(glassorig)
    for i in range(diff.shape[0]):
        print i
        maskall[i] = bigrec(diffmask[i], maskall[i])
        medresult = maskedmedfilt(glassorig[i], maskall[i], 6,4)
        noglass[i] = np.where(maskall[i], medresult, glassorig[i])
    np.save('medfilt_noglass.npy',noglass)
    from layerbase import DrawPatch
    misc.toimage(DrawPatch(noglass.reshape((-1,1,105,90)))).save('mednoglass.png')
    misc.toimage(DrawPatch(maskall.reshape((-1,1,105,90)))).save('medmask.png')

    def image_from_bits(self, bits, filename):

        # declare pixels matrix (list of lists)
        pixels = []

        # turning list of bits to matrix of bits
        for y in range(0,32):
            i = y * 32
            pixels.append(bits[i:i+32])

        # convert to 0's and 255's
        for y in range(len(pixels)):
            row = pixels[y]
            for x in range(len(row)):
                val = row[x]
                if val == 1:
                    val = 255
                pixels[y][x] = val

        # convert pixels to image and save
        imd = numpy.array(pixels)
        im = toimage(imd)
        im = im.convert('RGB')
        im.save(filename, 'PNG')

        pass 

    def parse(self):
        """runs each mask(crop) across the image file to improve OCR functionality"""
        image = Image.open(self.image_path)
        for form_field, bounding_box in self.bounding_box_dict.items():
            # the crops are scaled up and the contrast maxed out in order to enhance character
            # features and increase OCR success
            x1, y1, x2, y2  = bounding_box
            xx              = (x2-x1) << 2
            yy              = (y2-y1) << 2
            the_crop        = image.crop(bounding_box)
            the_crop        = the_crop.resize((xx,yy),PIL.Image.LANCZOS)
            area            = (xx * yy)
            gray            = the_crop.convert('L')
            bw              = np.asarray(gray).copy()
            bw[bw  < 200]   = 0
            bw[bw >= 200]   = 255
            the_crop        = misc.toimage(bw)

            # use this to check out a particular mask
            #if "box_c_address_city_town_zip_postal_code" is form_field:
            #    the_crop.show()

            if "checkbox" in form_field:
                # a box is considered checked if 10% or more of it's area is black
                checked = np.sum(bw) >= (0.1 * area)
                self.component_contents_dict[form_field] = checked
            else:
                self.component_contents_dict[form_field] = self.clean_text(pytesseract.image_to_string(the_crop))
        print([self.component_contents_dict['box_c_address_city_town_zip_postal_code']])