def image_search_upload():
    try:
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files['imagefile']
        filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
            werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        imagefile.save(filename)
        logging.info('Saving to %s.', filename)
        #image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return flask.render_template(
            'index_object_searching.html', has_result=True,
            result=[-1, 'Cannot open uploaded image.']
        )
    try:
        starttime = time.time()        
        image = exifutil.open_oriented_im(filename)        
        tmp_list = [filename]
        target_feature = image_feature_extract(tmp_list,1,1)
        
        
        L2_distance_feature = []
        res_images = []
        if app.is_gallery_feature_extract == True:
            logging.info('Begin to caculate L2_distance and sort.')
            for i in range(app.gallery_image_num):
                #caculate the L2 distance for f8 feature 
                tmp_distance = Euclidean_distance(app.gallery_features[i],target_feature[0])
                L2_distance_feature.append(tmp_distance)
            print "L2_distance_feature:",L2_distance_feature
            index = np.argsort(np.array(L2_distance_feature))                               
            for i in index:
                if L2_distance_feature[i] < app.threshold:
                    print 'Prepare output image, index: %d, distance:%d, name : %s \n'%(i,L2_distance_feature[i],app.gallery_image_name[i])
                    tmp_image = exifutil.open_oriented_im(app.gallery_image_name[i])
                    
                    res_images.append(embed_image_html(tmp_image))
                else:
                    break
            endtime = time.time()
            logging.info('Finish searching, output %d similar images.',len(res_images)) 
            return flask.render_template(
        'index_object_searching.html', has_result=True, result=[len(res_images),'%.3f' % (endtime - starttime)],result_images=res_images,imagesrc=embed_image_html(image) )

        else:
            endtime = time.time()
            return flask.render_template(
        'index_object_searching.html', has_result=True, result=[0,'%.3f' % (endtime - starttime)],result_images=res_images,imagesrc=embed_image_html(image) )
        
    except Exception as err:
            logging.info('Image searching error: %s', err)
            return flask.render_template(
            'index_object_searching.html', has_result=True,
            result=[-1, 'Something went wrong when searching image. '] )

def classify_upload_json():
    try:
        # We will save the file to disk for possible data collection.
        logging.info('In classify upload...')
        imagefile = flask.request.files['imagefile']
        filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
            werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        imagefile.save(filename)
        logging.info('Saving to %s.', filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return flask.render_template(
            'index.html', has_result=True,
            result=(False, 'Cannot open uploaded image.')
        )

    result = app.clf.classify_image(image)
    
    #done with image file; no need to keep it around

    #os.remove(os.path.join(UPLOAD_FOLDER, filename))
    #logging.info('Deleted file with name, %s', (os.path.join(UPLOAD_FOLDER, filename)))

    return jsonify(result=result)

def classify_upload():
    try:
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files['imagefile']
        filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
            werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        imagefile.save(filename)
        logging.info('Saving to %s.', filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return flask.render_template(
            'index.html', has_result=True,
            result=(False, 'Cannot open uploaded image.')
        )

    result = app.clf.classify_image(image)
    #print '----                         ..'
    #print result
    return flask.render_template(
        'index.html', has_result=True, result=result,
        imagesrc=embed_image_html(image)
    )

def enroll_upload():
  try:
    # We will save the file to disk for possible data collection.
    imagefile = flask.request.files['imagefile_enroll']
    filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
      werkzeug.secure_filename(imagefile.filename)
    filename = os.path.join(ENROLL_FOLDER, filename_)
    imagefile.save(filename)
    image = exifutil.open_oriented_im(filename)
    im = PIL.Image.fromarray(np.asarray(image * 255.).astype(np.uint8))
    im = im.resize( (384, 384), PIL.Image.ANTIALIAS )
    thumb_filename = filename #+ '_thumb.jpg'
    im.save(thumb_filename)
    #scp_command = 'scp %s [email protected]:%s' % (thumb_filename, ENROLL_FOLDER)
    #os.system(scp_command)
    logging.info('Saving to %s. done', thumb_filename)
    logging.info('%s done', scp_command)

  except Exception as err:
    logging.info('Uploaded image open error: %s', err)
    return flask.render_template(
      'index.html', has_result=True,
      result=(False, 'Cannot open uploaded image.')
    )

  result = app.clf.enroll_image(image, filename_)
  return flask.render_template('index.html', \
    has_result=True, result=result, imagesrc=embed_image_html(image))

def classify_upload():
    try:
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files['imagefile']
        filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
            werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        imagefile.save(filename)
        path, extension = os.path.splitext(filename)
        if extension == '.png':
            im = Image.open(filename)
            filename = "%s.jpg" % path
            im.save(filename)

        logging.info('Saving to %s.', filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return flask.render_template(
            'index.html', has_result=True,
            result=(False, 'Cannot open uploaded image.')
        )

    names, probs, time_cost, accuracy = app.clf.classify_image(
        open(os.path.join(filename), "rb").read())
    return flask.render_template(
        'index.html', has_result=True, result=[True, zip(names, probs), '%.3f' % time_cost],
        imagesrc=embed_image_html(image)
    )

def classify_upload():
    try:
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files['imagefile']
        # filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
        #     werkzeug.secure_filename(imagefile.filename)
        filename_ = str(uuid.uuid1()) + "_" + str(datetime.datetime.now()).replace(' ', '_') + "." + imagefile.filename.rsplit('.', 1)[1]
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        imagefile.save(filename)
        logging.info('Saving to %s.', filename)
        filenameMd5 = md5(filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return flask.render_template(
            'index.html', has_result=True, has_images=False,
            result=(False, 'Cannot open uploaded image.')
        )

    result = app.clf.classify_image(image)

    try:
        dyCom = reClassify.DynamoCommunicator()
        s3 = reClassify.S3Wrapper()
        classes = []
        for item in result[2]:
            classes.append(item[0])

        if (not dyCom.isStored(filenameMd5)):

            s3.transfer.upload_file(filename, s3.BUCKET_NAME, s3.IMAGES_FOLDER + filename_, extra_args={'ACL': 'public-read'})
            dyCom.add_md5_and_image(filenameMd5,filename_)
            dyCom.add_image_to_classes(filename_, classes)
            dyCom.add_image_and_classes(filename_,classes, filenameMd5)


        images = dyCom.get_images(classes)

        imgIDs = []
        s3URL = "https://s3.amazonaws.com"
        s3URL = os.path.join(s3URL, s3.BUCKET_NAME, s3.IMAGES_FOLDER)

        for item in images:
	    samp = min(5,len(images[item]))
            for it in random.sample(images[item],samp):
                imgIDs.append(os.path.join(s3URL, str(it)))

    except Exception as err:
        # For any exception we encounter in reading the image, we will just
        # not continue.
        logging.info('AWS Error: %s', err)
        return flask.render_template(
            'index.html', has_result=True, has_images=False,
            result=(False, "AWS Error" + err.message)
        )
    return flask.render_template(
        'index.html', has_result=True, result=result,
        imagesrc=embed_image_html(image), has_images=True, images=imgIDs
    )

def classify(net,labels,imagesFname):
    images = []
    for i in range(len(imagesFname)):
        images.append(exifutil.open_oriented_im(str(i)+'.jpg'))
    scores = net.predict(images, oversample=False)
    scoresLabels = [ labels[(-x).argsort()[:1][0] ] for x in scores ]
    output = zip( imagesFname, scoresLabels )
    return output

def save_image(imagefile):
    filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
        werkzeug.secure_filename(imagefile.filename)
    filename = os.path.join(UPLOAD_FOLDER, filename_)
    imagefile.save(filename)
    logging.info('Saving to %s.', filename)
    image = exifutil.open_oriented_im(filename)
    return (filename, image)

def show_team():
    photos = []
    
    filename1 = './templates/team-members-photo/wangbo.jpg'
    image1 = exifutil.open_oriented_im(filename1)
    member1=embed_image_html(image1)
    photos.append(member1)
        
    filename2 = './templates/team-members-photo/zdh.jpg'
    image2 = exifutil.open_oriented_im(filename2)
    member2=embed_image_html(image2)
    photos.append(member2)    
    
    filename3 = './templates/team-members-photo/zhuhao.jpg'
    image3 = exifutil.open_oriented_im(filename3)
    member3=embed_image_html(image3)
    photos.append(member3)
    
    return flask.render_template('index_team.html', has_result=False,imagesrc=photos)

def classify_upload():
    imagefile = request.files['imagefile']
    filename_ = werkzeug.secure_filename(imagefile.filename)
    filename = os.path.join(UPLOADS_FOLDER,filename_)
    imagefile.save(filename)
    image = exifutil.open_oriented_im(filename)
    result = classify_image(filename)
    print result
    imagesrc=embed_image_html(image)
    return render_template('index.html', has_result=True, result=result, imagesrc=imagesrc)

def classify_upload():
    try:
        # We will save the file to disk for possible data collection.
        filename = flask.request.args["image"]
        logging.info("Saving to %s.", filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info("Uploaded image open error: %s", err)
        return flask.render_template("index.html", has_result=True, result=(False, "Cannot open uploaded image."))

    result = app.clf.classify_image(image)
    return flask.jsonify(result[2])

def myclassify_dog_upload():
    try:
        logging.info('in classify_upload')
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files['imagefile']
        logging.info('in classify_upload 1')
        filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
            werkzeug.secure_filename(imagefile.filename)
        logging.info('in classify_upload 2')
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        logging.info('in classify_upload 3')
        imagefile.save(filename)
        logging.info('Saving to %s.', filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return flask.render_template(
            'responseDogs.html', has_result=True,
            result=(False, 'Cannot open uploaded image.')
        )

    result = app.clf.classify_image(image)
    i = 0
    while i < len(result[1]):
         single_pred = result[1][i]
         if not(p.match(single_pred[0])):
           logging.info(single_pred[0] + " i=" + str(i))
           del result[1][i]
         else:
           #image support
           searchre = re.compile('.*'+single_pred[0].lower()+'.*',re.IGNORECASE)
           defkey = "borzoi"
           for key in dogs:
             if searchre.match(key):
               defkey = key
               break
           result[1][i] = [ single_pred[0], single_pred[1], dogs[defkey][2]]
           '''
           if single_pred[0].lower() in dogs:
             result[1][i] = [ single_pred[0], single_pred[1], dogs[single_pred[0].lower()][2]]
           else: 
             result[1][i] = [ single_pred[0], single_pred[1], dogs["borzoi"][2]]
           '''
           i = i + 1
 
    return flask.render_template(
        'responseDogs.html', has_result=True, result=result,
        imagesrc=embed_image_html(image)
    )

def classify_dir(imagedir,test):
  global f
  if test=='test':
    f=open('/opt/data/1000caffefileout-test.txt','a')
    for root, directories, filenames in os.walk(imagedir):
      for filename in filenames:
        if 'test' in root:
          if filename not in 'Thumbs.db':
            lfname =os.path.join(root,filename)
            catlog=root.split('/')[-3]
            cimage = exifutil.open_oriented_im(lfname)
            app.clf.classify_image(cimage,catlog,lfname)
    f.close()
  else:
    f=open('/opt/data/1000caffefileout.txt','a')
    for root, directories, filenames in os.walk(imagedir):
      for filename in filenames:
        if 'test' not in root:
          if filename not in 'Thumbs.db':
            lfname =os.path.join(root,filename)
            catlog=root.split('/')[-2]
            cimage = exifutil.open_oriented_im(lfname)
            app.clf.classify_image(cimage,catlog,lfname)
    f.close()

def classify_upload():
    try:
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files["imagefile"]
        filename_ = str(datetime.datetime.now()).replace(" ", "_") + werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(UPLOAD_FOLDER, filename_)
        imagefile.save(filename)
        logging.info("Saving to %s.", filename)
        image = exifutil.open_oriented_im(filename)

    except Exception as err:
        logging.info("Uploaded image open error: %s", err)
        return flask.render_template("index.html", has_result=True, result=(False, "Cannot open uploaded image."))

    result = app.clf.classify_image(image)
    return flask.render_template("classify.html", has_result=True, result=result, imagesrc=embed_image_html(image))

def classifyy_upload():
    try:
        imagefile = request.files['imagefile']
        filename_ = str(datetime.datetime.now()).replace(' ', '_') + werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(UPLOADS_FOLDER, filename_)
        imagefile.save(filename)
        logging.info('Saving to %s.', filename)
        image = exifutil.open_oriented_im(filename)
        
    except Exception as err:
        logging.info('Uploaded image open error: %s', err)
        return render_template('index.html', has_result=True,result=(False, 'Cannot open uploaded image.'))
    
    logging.info('Image: %s', image_url)
    result = app.clf.classify_image(image)
    
    

def enroll_upload():
    try:
        # We will save the file to disk for possible data collection.
        imagefile = flask.request.files["imagefile_enroll"]
        filename_ = str(datetime.datetime.now()).replace(" ", "_") + werkzeug.secure_filename(imagefile.filename)
        filename = os.path.join(ENROLL_FOLDER, filename_)
        imagefile.save(filename)
        image = exifutil.open_oriented_im(filename)
        im = PIL.Image.fromarray(np.asarray(image * 255.0).astype(np.uint8))
        im = im.resize((256, 256), PIL.Image.ANTIALIAS)
        thumb_filename = filename + "_thumb.jpg"
        im.save(thumb_filename)
        logging.info("Saving to %s. done", thumb_filename)

    except Exception as err:
        logging.info("Uploaded image open error: %s", err)
        return flask.render_template("index.html", has_result=True, result=(False, "Cannot open uploaded image."))

    result = app.clf.enroll_image(image, filename_)
    return flask.render_template("index.html", has_result=True, result=result, imagesrc=embed_image_html(image))

def doframeclassify():
    print 'Starting ..'
    global net
    global labels
    global capframe
    global adblock
    global size
    global adchange
    while True:
        if capframe != None:
            cv2.imwrite('img' + '.jpg', capframe )
            images = [exifutil.open_oriented_im('img.jpg')]
            scores = net.predict(images, oversample=False)
            scoresLabels = [ labels[(-x).argsort()[:1][0] ] for x in scores ]  
            sstr = ' '.join(scoresLabels[0].split(' > ')[-2:]).replace('&','').split()
            img, title = getamazonres(sstr)
            print scoresLabels[0]
            createadchange(img,title,size)
            adchange = True
        capframe = None

def classify_url():
    imageurl = flask.request.args.get('imageurl', '')
    try:
        bytes = urllib2.urlopen(imageurl).read()
        string_buffer = StringIO.StringIO(bytes)
        image = exifutil.open_oriented_im(string_buffer)

    except Exception as err:
        # For any exception we encounter in reading the image, we will just
        # not continue.
        logging.info('URL Image open error: %s', err)
        return flask.render_template(
            'index.html', has_result=True,
            result=(False, 'Cannot open image from URL.')
        )

    app.logger.info('Image: %s', imageurl)
    names, probs, time_cost, accuracy = app.clf.classify_image(bytes)
    return flask.render_template(
        'index.html', has_result=True, result=[True, zip(names, probs), '%.3f' % time_cost],
        imagesrc=embed_image_html(image)
    )

def classify_url():
    if 'url' in flask.request.args:
        imageurl = flask.request.args.get('url', '')
        try:
            string_buffer = StringIO.StringIO(
                urllib.urlopen(imageurl).read())
            image = caffe.io.load_image(string_buffer)

        except Exception as err:
            # For any exception we encounter in reading the image, we will just
            # not continue.
            logging.info('URL Image open error: %s', err)
            return json.dumps({ 'accuracy': [], 'specificity': [] })

        logging.info('Image: %s', imageurl)
        result = app.clf.classify_image(image)
        accuracy = [{ 'label': label, 'score': score } for label, score in result[2]]
        return json.dumps({ 'image': embed_image_html(image), 'accuracy': accuracy, 'specificity': accuracy })
    else:
        try:
            # We will save the file to disk for possible data collection.
            imagefile = flask.request.files['file']
            filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
                werkzeug.secure_filename(imagefile.filename)
            filename = os.path.join(UPLOAD_FOLDER, filename_)
            imagefile.save(filename)
            logging.info('Saving to %s.', filename)
            image = exifutil.open_oriented_im(filename)

        except Exception as err:
            logging.info('Uploaded image open error: %s', err)
            return json.dumps({ 'accuracy': [], 'specificity': [] })

        result = app.clf.classify_image(image)
        accuracy = [{ 'label': label, 'score': score } for label, score in result[2]]
        return json.dumps({ 'image': embed_image_html(image), 'accuracy': accuracy, 'specificity': accuracy })

def image_search_url():
    imageurl = flask.request.args.get('imageurl', '')
    try:
        # string_buffer = StringIO.StringIO(
        #    urllib.urlopen(imageurl).read())
        #image_filename = imageurl.split('/')[-1]  
        image_filename = str(datetime.datetime.now()).replace(' ', '_')+'.jpg'
        filename = os.path.join(UPLOAD_FOLDER, image_filename)
        data = urllib.urlopen(imageurl).read()  

        f = file(filename,"wb")  
        f.write(data)  
        f.close()  


        #image = caffe.io.load_image(string_buffer)
        #filename_ = str(datetime.datetime.now()).replace(' ', '_')+'.jpg'
        #filename = os.path.join(UPLOAD_FOLDER, filename_)
        #image.save(filename)
        #logging.info('Saving to %s.', filename)
    except Exception as err:
        # For any exception we encounter in reading the image, we will just
        # not continue.
        logging.info('URL Image open error: %s', err)
        return flask.render_template(
            'index_object_searching.html', has_result=True,
            result=[-1, 'Cannot open image from URL.']
        )

    logging.info('Image: %s', imageurl)
    
    try:
        starttime = time.time()
        
        image = exifutil.open_oriented_im(filename)
        
        tmp_list = [filename]
        target_feature = image_feature_extract(tmp_list,1,1)
        
        L2_distance_feature = []
        res_images = []
        if app.is_gallery_feature_extract == True:
            logging.info('Begin to caculate L2_distance and sort.')
            for i in range(app.gallery_image_num):
                #caculate the L2 distance for f8 feature 
                tmp_distance = Euclidean_distance(app.gallery_features[i],target_feature[0])
                L2_distance_feature.append(tmp_distance)
            print "L2_distance_feature:",L2_distance_feature
            index = np.argsort(np.array(L2_distance_feature))
            
            for i in index:
                if L2_distance_feature[i] < app.threshold:
                    tmp_image = exifutil.open_oriented_im(app.gallery_image_name[i])
                    print 'Prepare output image, index: %d, distance:%d, name : %s \n'%(i,L2_distance_feature[i],app.gallery_image_name[i])
                    res_images.append(embed_image_html(tmp_image))
                else:
                    break
            endtime = time.time()
            logging.info('Finish searching, output %d similar images.',len(res_images)) 
            return flask.render_template(
        'index_object_searching.html', has_result=True, result=[len(res_images),'%.3f' % (endtime - starttime)],result_images=res_images,imagesrc=embed_image_html(image) )

        else:
            endtime = time.time()
            return flask.render_template(
        'index_object_searching.html', has_result=True, result=[0,'%.3f' % (endtime - starttime)],result_images=res_images,imagesrc=embed_image_html(image) )
        
    except Exception as err:
            logging.info('Image searching error: %s', err)
            return flask.render_template(
            'index_object_searching.html', has_result=True,
            result=[-1, 'Something went wrong when searching image. '] )