Python计算机视觉编程第七章——图像搜索

（一）基于内容的图像检索

CBIR（Content-Based Image Retrieval，基于内容的图像检索）

定义 : 即从图像库中查找含有特定目标的图像，也包括从连续的视频图像中检索含有特定目标的视频片段。目前，对于通用的静止图像检索，用于检索的特征主要有颜色（Colour）、纹理（Texture）、草图（Sketch）、形状（Shape）等，其中颜色、形状、纹理等应用尤为普遍。

基本原理：任给定一个检索图像示例$P$，计算其特征向量$F=\left(F_1,F_2,F_3,...F_n\right)$，其中$F_i$为图像的第$i$种特征；根据F检索图像特征索引库，得到与$F$距离最小的特征向量$F^{\prime }$，则$F^{\prime }$所对应的图像$P^{\prime }$即为与P最相似的检索结果。

特点：

1. 模糊查询，检索结果不唯一 。（基于内容的图像检索与文字检索的一个主要区别是，基于内容的检索都是属于模糊查询，一般不会给出单一的检索结果，输出的是一个结果排序集合，按图像的相似程度，从最像到最不像）
2. 检索结果逐步逼近。（在检索过程中不断修订检索条件，可以逐步达到最终的检索结果，通过调整特征参数组合，可以得到不同的检索结果）
3. 计算工作量大。（每次查询都需要根据临时提交的特征标准，对全部特征值进行匹配运算；数据计算时对计算机的要求高，查询时间相对长一些）

基于内容的图像检索分为三个层次：

1. 依据提取图像本身的颜色、形状、纹理等低层特征进行检索；
   颜色检索：基于颜色特征的图像检索需要解决三个问题：颜色的表示（取决于色彩空间的选择，不同场合采用的方式也是不同，常见的有RGB,HSV模型等）、颜色特征的提取（在基于颜色特征的索引算法中通常用颜色统计直方图、颜色相关图，颜色矩，颜色一致性矢量来表示图像的颜色特征）和基于颜色的相似度量（颜色特征索引的相似度匹配算法根据其颜色索引内容和算法的不同而不同，主要包括直方图相交法，Manhattan距离、绝对距离（L1）、二次距离（L2）、欧几里德距离等。
   形状检索：基于形状的检索包括两种：一是基于轮廓线的检索，二是直接针对特定形状的图形进行检索。形状是物体的一个重要特征，但由于物体形状的自动获取很困难，基于形状的检索一般仅限于非常容易识别的物体。形状可以用面积、离心率、圆形度、形状度、曲率、分形维等全局和局部特征来表示。
   纹理检索：纹理特征代表了物体的视觉模式，它包含了物体表面的组织结构以及与周围环境之间的关系。图像的纹理特征主要有六个方面：粗糙度、对比度、方向度、线像度、规整度、粗略度，其中最重要的特征主要是纹理的粗糙度、对比度、方向度。
2. 基于图像的低层特征，通过识别图像中的对象类别以及对象之间的空间拓扑关系进行检索；
   对象检索：基于对象的方法用于检索图像对象或其子对象，是针对局部特征的。
   
3. 基于图像抽象属性（场景语义、行为语义、情感语义等）的推理学习进行检索；

矢量空间模型

定义：一个把文本文件表示为标识符（比如索引）向量的代数模型。文档和查询都用向量表示。
$$d_j=(w_{1,j},w_{2,j},...,w_{t,j})$$$$q=(w_{1,q},w_{2,q},...,w_{t,q})$$

每一维都对应于一个个别的词组。如果某个词组出现在了文档中，那它在向量中的值就非零。已经发展出了不少的方法来计算这些值，这些值叫做（词组）权重。其中一种最为知名的方式是tf-idf权重（term frequency-inverse document frequency，词频-逆向文档频率 ）（百度百科）

单词 w 在文档 d 中的词频是：
$$t{f}_{w,d}=\frac{n_w}{{\sum }_j^{}{n}_j}$$
解释：TF=(该词在文件中的出现次数）/（整个文档中单词的总数）

逆向文档频率为：

$$id{f}_{w,d}=log\frac{|(D)|}{|\left\{d:wϵd\right\}|}$$

解释：IDF=log（语料库D中的文件总数）/（包含单词w 的文档数d）

举例：
假设现在一篇文件的总词语数是1000个，单词"water"出现了20次，则"water"一词在该文件中的词频就是20/1000=0.02。如果“water"一词在100份文件中出现过，文件总数是10000份，则其逆向文件频率就是log(10000/100)=2，最后tf-idf为0.02*2=0.04。

tf-idf计算实验代码：

# -*-coding:utf-8 -*-

# 在词袋模型中,文档的特征就是其包含的word,corpus的每一个元素对应一篇文档
texts = [['human', 'interface', 'computer'],
         ['survey', 'user', 'computer', 'system', 'response', 'time'],
         ['eps', 'use', 'interface', 'system'],
         ['system', 'human', 'system', 'eps'],
         ['user', 'response', 'time'],
         ['trees'],
         ['graph', 'trees'],
         ['graph', 'minors', 'trees'],
         ['graph', 'minors', 'survey']]

# 训练语料的预处理,将原始文本特征表达转换成词袋模型对应的系数向量
from gensim import corpora

# from gensim.models.word2vec import Word2Vec
dictionary = corpora.Dictionary(texts)  # texts就是若干个被拆成单词集合的文档的集合，而dictionary就是把所有单词取一个set(),并对set中每个单词分配一个Id号的map
print(dictionary)
# 是把文档 doc变成一个稀疏向量，[(0, 1), (1, 1)]，表明id为0,1的词汇出现了1次，至于其他词汇，没有出现,在这里可以看出set()中computer的id是0,human的id是1...
corpus = [dictionary.doc2bow(text) for text in texts]
print(corpus)  # 输出为[(0, 1), (1, 1), (2, 1)],就表示id为0,1,2,即单词computer,human,interface,在第一个维度中都出现了一次

# tf-idf的计算
from gensim import models

tfidf = models.TfidfModel(corpus)
print(tfidf)
doc_bow = [(0, 1), (1, 1)]
print(tfidf[doc_bow])
print(tfidf.idfs)

TF-IDF实际上是：TF * IDF。主要思想是：如果某个词或短语在一篇文章中出现的频率高（即TF高），并且在其他文章中很少出现（即IDF高），则认为此词或者短语具有很好的类别区分能力，适合用来分类。

（二）视觉单词

SIFT 局部描述子的思想是将描述子空间量化成一些典型实例，并将图像中的每个描述子指派到其中的某个实例中。这些典型实例可以通过分析训练图像集确定，并被视为视觉单词。所有这些视觉单词构成的集合称为视觉词汇，有时也称为视觉码本。对于给定的问题、图像类型，或在通常情况下仅需呈现视觉内容，可以创建特定的词汇。

利用一些聚类算法可以构建出视觉单词。在采用 K-means 进行聚类时得到的视觉单词是聚类质心。用视觉单词直方图来表示图像，则该模型便称为 BOW 模型。

创建词汇：

创建名为 vocabulary.py 的文件，将下面代码添加进去。该代码创建了一个词汇类，以及在训练图像数据集上训练出一个词汇的方法：

from numpy import *
from scipy.cluster.vq import *

from PCV.localdescriptors import sift


class Vocabulary(object):
    
    def __init__(self,name):
        self.name = name
        self.voc = []
        self.idf = []
        self.trainingdata = []
        self.nbr_words = 0
    
    def train(self,featurefiles,k=100,subsampling=10):
        """ 用含有k个单词的 K-means 列出在 featurefiles 中的特征文件训练出一个词汇。对训练数据下采样可以加快训练速度 """
        
        nbr_images = len(featurefiles)
        # 从文件中读取特征 
        descr = []
        descr.append(sift.read_features_from_file(featurefiles[0])[1])
        # 将所有的特征并在一起，以便后面进行 K-means 聚类 
        descriptors = descr[0] 
        for i in arange(1,nbr_images):
            descr.append(sift.read_features_from_file(featurefiles[i])[1])
            descriptors = vstack((descriptors,descr[i]))
            
        #K-means: 最后一个参数决定运行次数 
        self.voc,distortion = kmeans(descriptors[::subsampling,:],k,1)
        self.nbr_words = self.voc.shape[0]
        
        # 遍历所有的训练图像，并投影到词汇上 
        imwords = zeros((nbr_images,self.nbr_words))
        for i in range( nbr_images ):
            imwords[i] = self.project(descr[i])
        
        nbr_occurences = sum( (imwords > 0)*1 ,axis=0)
        
        self.idf = log( (1.0*nbr_images) / (1.0*nbr_occurences+1) )
        self.trainingdata = featurefiles
    
    def project(self,descriptors):
        """ 将描述子投影到词汇上，以创建单词直方图  """
        
        # 图像单词直方图
        imhist = zeros((self.nbr_words))
        words,distance = vq(descriptors,self.voc)
        for w in words:
            imhist[w] += 1
        
        return imhist

# -*- coding: utf-8 -*-
import pickle
from PCV.imagesearch import vocabulary
from PCV.tools.imtools import get_imlist
from PCV.localdescriptors import sift

#获取图像列表
imlist = get_imlist('first1000/')
nbr_images = len(imlist)
#获取特征列表
featlist = [imlist[i][:-3]+'sift' for i in range(nbr_images)]

#提取文件夹下图像的sift特征
for i in range(nbr_images):
    sift.process_image(imlist[i], featlist[i])

#生成词汇
voc = vocabulary.Vocabulary('ukbenchtest')
voc.train(featlist, 1000, 10)
#保存词汇
with open('first1000/vocabulary.pkl', 'wb') as f:
    pickle.dump(voc, f)
print ('vocabulary is:', voc.name, voc.nbr_words)

(‘vocabulary is:’, ‘ukbenchtest’, 1000)

Vocabulary 类包含了一个由单词聚类中心 VOC 与每个单词对应的逆向文档频率构成的向量，为了在某些图像集上训练词汇，train() 方法获取包含有 .sift 描后缀的述子文件列表和词汇单词数k。在 K-means 聚类阶段可以对训练数据下采样，因为如果使用过多特征，会耗费很长时间。可以看到在计算机文件夹中，保存了图像及提取出来的 sift 特征文件。代码最后部分用 pickle 模块保存了整个词汇对象以便后面使用。

（三）图像索引

对图像进行索引就是从这些图像中提取描述子，利用词汇将描述子转换成视觉单词，并保存视觉单词及对应图像的单词直方图。从而可以利用图像对数据库进行查询，并返回相似的图像作为搜索结果。在开始搜索之前，需要建立图像数据库和图像的视觉单词表示。

3.1 建立数据库

使用SQLite 作为数据库。SQLite 将所有信息都保存到一个文件，是一个易于安装和使用的数据库。不涉及数据库和服务器的配置，很容易上手。SQLite 对应的Python 版本是pysqlite，可以从 http://code.google.com/p/pysqlite/ 获取。

在开始之前，首先需要创建表、索引和索引器 Indexer 类，以便将图像数据写入数据库。首先，创建一个名为 imagesearch.py 的文件，

from numpy import *
import pickle
import sqlite3
from functools import cmp_to_key
import operator

class Indexer(object):
    
    def __init__(self,db,voc):
        """ 初始化数据库的名称及词汇对象  """
            
        self.con = sqlite3.connect(db)
        self.voc = voc
    
    def __del__(self):
        self.con.close()
    
    def db_commit(self):
        self.con.commit()
    
    def create_tables(self): 
        """ Create the database tables. """
        
        self.con.execute('create table imlist(filename)')
        self.con.execute('create table imwords(imid,wordid,vocname)')
        self.con.execute('create table imhistograms(imid,histogram,vocname)')        
        self.con.execute('create index im_idx on imlist(filename)')
        self.con.execute('create index wordid_idx on imwords(wordid)')
        self.con.execute('create index imid_idx on imwords(imid)')
        self.con.execute('create index imidhist_idx on imhistograms(imid)')
        self.db_commit()

用pickle 模块将这些数组编码成字符串以及将字符串进行解码； SQLite 可以从 pysqlite2 模块中导入。 Indexer 类连接数据 库，并且一旦创建（调用 init() 方法）后就可以保存词汇对象。del() 方法 可以确保关闭数据库连接，db_commit() 可以将更改写入数据库文件。

我们仅需一个包含三个表单的简单数据库模式。

表单 imlist 包含所有要索引的图像文件名；imwords 包含了一个那些单词的单词索引、用到了哪个词汇、以及单词出现在哪些图像中；最后，imhistograms 包含了全部每幅图像的单词直方图。根据矢量空间模型，我们需要这些以便进行图像比较。

3.2 添加图像

有了数据库表单，便可以在索引中添加图像。为了实现该功能，需要在 Indexer 类中添加 add_to_index() 方法。将下面的方法添加到 imagesearch.py 中：

def add_to_index(self,imname,descr):
        """ 获取一幅带有特征描述子的图像，投影到词汇上并添加进数据库  """
            
        if self.is_indexed(imname): return
        print 'indexing', imname
        
        # 获取图像id
        imid = self.get_id(imname)
        
        # 获取单词
        imwords = self.voc.project(descr)
        nbr_words = imwords.shape[0]
        
        #将每个单词与图像链接起来 
        for i in range(nbr_words):
            word = imwords[i]
        #  wordid 就是单词本身的数字 
            self.con.execute("insert into imwords(imid,wordid,vocname) values (?,?,?)", (imid,word,self.voc.name))
            
        # 存储图像的单词直方图
        # 用 pickle 模块将 NumPy 数组编码成字符串
        self.con.execute("insert into imhistograms(imid,histogram,vocname) values (?,?,?)", (imid,pickle.dumps(imwords),self.voc.name))
    

该方法获取图像文件名与 Numpy 数组，该数组包含的是在图像找到的描述子。这些描述子投影到词汇上，并插入到 imwords（逐字）和 imhistograms 表单中。使用两个辅助函数：is_indxed() 用来检查图像是否已经被索引，get_id() 则对一幅图像文件名给定 id 号。将下面的代码添加进 imagesearch.py：

def is_indexed(self,imname):
        """ 如果图像名字（imname）被索引到，就返回 True"""
        
        im = self.con.execute("select rowid from imlist where filename='%s'" % imname).fetchone()
        return im != None
 def get_id(self,imname):
        """ 获取图像 id，如果不存在，就进行添加 ""
        
        cur = self.con.execute(
        "select rowid from imlist where filename='%s'" % imname)
        res=cur.fetchone()
        if res==None:
            cur = self.con.execute(
            "insert into imlist(filename) values ('%s')" % imname)
            return cur.lastrowid
        else:
            return res[0] 

import sqlite3
con = sqlite3.connect('testImaAdd.db')
print con.execute('select count (filename) from imlist').fetchone()
print con.execute('select * from imlist').fetchone()

控制台打印结果如下：

最后一行用 fetchall() 来代替 fetchone()，会得到一个包含所有文件名的长列表：

（四）在数据库中搜索图像

建立好图像的索引，我们就可以在数据库中搜索相似的图像了。这里，我们用BoW （Bag-of-Word，词袋模型）来表示整个图像。

为实现搜索，我们在 imagesearch.py 中添加 Searcher 类：

class Searcher(object):
    
    def __init__(self,db,voc):
        """ 初始化数据库的名称. """
        self.con = sqlite.connect(db)
        self.voc = voc
    
    def __del__(self):
        self.con.close()

一个新的 Searcher 对象连接到数据库，一旦删除便关闭连接，这与之前的 Indexer 类中的处理过程相同。如果图像数据库很大，逐一比较整个数据库中的所有直方图往往是不可行的。我们需要找到一个大小合理的候选集（这里的“合理”是通过搜索响应时间、所需内存等确定的），单词索引的作用便在于此：我们可以利用单词索引获得候选集，然后只需在候选集上进行逐一比较。

4.1 利用索引获取候选图像

可以利用建立起来的索引找到包含特定单词的所有图像，这不过是对数据库做 一次简单的查询。在 Searcher 类中加入 candidates_from_word() 方法：

    def candidates_from_word(self, imword):
        """  获取包含 imword 的图像列. """

        im_ids = self.con.execute(
            "select distinct imid from imwords where wordid=%d" % imword).fetchall()
        return [i[0] for i in im_ids]

上面会给出包含特定单词的所有图像 id 号。为了获得包含多个单词的候选图像，例 如一个单词直方图中的全部非零元素，我们在每个单词上进行遍历，得到包含该单 词的图像，并合并这些列表 。

这里，我们仍然需要在合并了的列表中对每一个图像 id 出现的次数进行跟踪，因为这可以显示有多少单词与单词直方图中的单词匹配。 该过程可以通过下面的 candidates_from_histogram 方法完成：

    def candidates_from_histogram(self, imwords):
        """ 获取具有相似单词的图像列表 """

        # 获取单词 id
        words = imwords.nonzero()[0]

        # 寻找候选图像
        candidates = []
        for word in words:
            c = self.candidates_from_word(word)
            candidates += c

        # 获取所有唯一的单词，并按出现次数反向排序 
        tmp = [(w, candidates.count(w)) for w in set(candidates)]
        tmp.sort(key=cmp_to_key(lambda x, y: operator.gt(x[1], y[1])))
        tmp.reverse()

        # 返回排序后的列表，最匹配的排在最前面
        return [w[0] for w in tmp]

该方法从图像单词直方图的非零项创建单词 id 列表，检索每个单词获得候选集并将其合并到candidates 列表中，然后创建一个元组列表每个元组由单词 id 和次数 count 构成，其中次数 count 是候选列表中每个单词出现的次数。同时，以元组中的第二个元素为准，用 sort() 方法和一个自定义的比较函数对列表进行排序（考虑到后面的效率）。该自定义比较函数进行用 lambda 函数内联声明，对于单行函数声明，使用 lambda 函数非常方便。最后结果返回一个包含图像 id 的列表，排在列表最前面的是最好的匹配图像。

src = imagesearch.Searcher('testImaAdd.db', voc)
locs,descr = sift.read_features_from_file(featlist[0])
iw = voc.project(descr)
print 'ask using a histogram...'
print src.candidates_from_histogram(iw)[:10]

打印了从索引中查找出的前 10 个图像 id，结果如下：

4.2 用一幅图像进行查询

利用一幅图像进行查询时，没有必要进行完全的搜索。为了比较单词直方图，Searcher 类需要从数据库读入图像的单词直方图。将下面的方法添加到 Searcher 类中：

 def get_imhistogram(self, imname):
        """ 返回一幅图像的单词直方图 . """

        im_id = self.con.execute(
            "select rowid from imlist where filename='%s'" % imname).fetchone()
        s = self.con.execute(
            "select histogram from imhistograms where rowid='%d'" % im_id).fetchone()

        # 用 pickle 模块从字符串解码 Numpy 数组
        return pickle.loads(str(s[0]))

这里，为了在字符串和 NumPy 数组间进行转换，我们再次用到了 pickle 模块，这次使用的是 loads()。

现在，我们可以全部合并到查询方法中：

    def query(self, imname):
        """ 查找所有与 imname 匹配的图像列表 . """

        h = self.get_imhistogram(imname)
        candidates = self.candidates_from_histogram(h)

        matchscores = []
        for imid in candidates:
            # 获取名字 
            cand_name = self.con.execute(
                "select filename from imlist where rowid=%d" % imid).fetchone()
            cand_h = self.get_imhistogram(cand_name)
            cand_dist = sqrt(sum(self.voc.idf * (h - cand_h) ** 2))
            matchscores.append((cand_dist, imid))

        # 返回排序后的距离及对应数据库 ids 列表 
        matchscores.sort()
        return matchscores

该 query() 方法获取图像的文件名，检索其单词直方图及候选图像列表（如果你的数据集很大，候选集的大小应该限制在某个最大值）。对于每个候选图像，用标准的欧式距离比较它和查询图像间的直方图，并返回一个经排序的包含距离及图像 id的元组列表。

尝试对前一节的图像进行查询

src = imagesearch.Searcher('testImaAdd.db', voc)
print 'try a query...'
print src.query(imlist[0])[:10]

打印了前 10 个结果，包括候选图像与查询图像间的距离。

（五）使用几何特性对结果排序

BoW 模型的一个主要缺点是在用视觉单词表示图像时不包含图像特征的位置信息，这是为获取速度和可伸缩性而付出的代价。利用一些考虑到特征几何关系的准则重排搜索到的靠前结果，可以提高准确率。最常用的方法是在查询图像与靠前图像的特征位置间拟合单应性。

为了提高效率，可以将特征位置存储在数据库中，并由特征的单词 id 决定它们之间的关联（要注意的是，只有在词汇足够大，使单词 id 包含很多准确匹配时，它才起作用）。

下面是一个载入所有模型文件并用单应性对靠前的图像进行重排的完整例子：

# -*- coding: utf-8 -*-
import pickle
from PCV.localdescriptors import sift
from PCV.imagesearch import imagesearch
from PCV.geometry import homography
from PCV.tools.imtools import get_imlist

# load image list and vocabulary
#载入图像列表
imlist = get_imlist('first1000/')
nbr_images = len(imlist)
#载入特征列表
featlist = [imlist[i][:-3]+'sift' for i in range(nbr_images)]

#载入词汇
with open('first1000/vocabulary.pkl', 'rb') as f:
    voc = pickle.load(f)

src = imagesearch.Searcher('testImaAdd.db',voc)

# index of query image and number of results to return
#查询图像索引和查询返回的图像数
q_ind = 0
nbr_results = 20

# regular query
# 常规查询(按欧式距离对结果排序)
res_reg = [w[1] for w in src.query(imlist[q_ind])[:nbr_results]]
print 'top matches (regular):', res_reg

# load image features for query image
#载入查询图像特征
q_locs,q_descr = sift.read_features_from_file(featlist[q_ind])
fp = homography.make_homog(q_locs[:,:2].T)

# RANSAC model for homography fitting
#用单应性进行拟合建立RANSAC模型
model = homography.RansacModel()
rank = {}

# load image features for result
#载入候选图像的特征
for ndx in res_reg[1:]:
    locs,descr = sift.read_features_from_file(featlist[ndx])  # because 'ndx' is a rowid of the DB that starts at 1
    # get matches
    matches = sift.match(q_descr,descr)
    ind = matches.nonzero()[0]
    ind2 = matches[ind]
    tp = homography.make_homog(locs[:,:2].T)
    # compute homography, count inliers. if not enough matches return empty list
    try:
        H,inliers = homography.H_from_ransac(fp[:,ind],tp[:,ind2],model,match_theshold=4)
    except:
        inliers = []
    # store inlier count
    rank[ndx] = len(inliers)

# sort dictionary to get the most inliers first
sorted_rank = sorted(rank.items(), key=lambda t: t[1], reverse=True)
res_geom = [res_reg[0]]+[s[0] for s in sorted_rank]
print ('top matches (homography):', res_geom)

# 显示查询结果
imagesearch.plot_results(src,res_reg[:8]) #常规查询
imagesearch.plot_results(src,res_geom[:8]) #重排后的结果

控制台输出结果：

可视化常规查询图像：

可视化排序后图像:

整个过程，首先载入图像列表、特征列表（分别包含图像文件名和 SIFT 特征文件）及词汇。 然后，创建一个 Searcher 对象，执行定期查询，并将结果保存在 res_reg 列表中。然后载入 res_reg 列表中每一幅图像的特征，并和查询图像进行匹配。单应性通过计算 匹配数和计数内点数得到。最终，我们可以通过减少内点的数目对包含图像索引和内点数的字典进行排序，可以看到排序效果较好。

（六）建立演示程序及 Web 应用

首先，我们需要用一些 HTML 标签进行初始化，并用 Pickle 载入数据。另外，还需要有与数据库进行交互的 Searcher 对象词汇。创建一个名为 searchdemo.py 的文件， 并添加下面具有两个方法的 Search Demo 类：

# -*- coding: utf-8 -*-
import cherrypy
import pickle
import urllib
import os
from numpy import *
#from PCV.tools.imtools import get_imlist
from PCV.imagesearch import imagesearch
import random

"""
This is the image search demo in Section 7.6.
"""


class SearchDemo:

    def __init__(self):
        # 载入图像列表
        self.path = 'first1000/'
        #self.path = 'D:/python_web/isoutu/first500/'
        self.imlist = [os.path.join(self.path,f) for f in os.listdir(self.path) if f.endswith('.jpg')]
        #self.imlist = get_imlist('./first500/')
        #self.imlist = get_imlist('E:/python/isoutu/first500/')
        self.nbr_images = len(self.imlist)
        print (self.imlist)
        print (self.nbr_images)
        self.ndx = list(range(self.nbr_images))
        print (self.ndx)

        # 载入词汇
        # f = open('first1000/vocabulary.pkl', 'rb')
        with open('first1000/vocabulary.pkl','rb') as f:
            self.voc = pickle.load(f)
        #f.close()

        # 显示搜索返回的图像数
        self.maxres = 10

        # header and footer html
        self.header = """
            
            
            
            
            
            """
        self.footer = """
            
            
            """

    def index(self, query=None):
        self.src = imagesearch.Searcher('testImaAdd.db', self.voc)

        html = self.header
        html += """
            

            Click an image to search.  Random selection  of images.
            


            """
        if query:
            # query the database and get top images
            #查询数据库，并获取前面的图像
            res = self.src.query(query)[:self.maxres]
            for dist, ndx in res:
                imname = self.src.get_filename(ndx)
                html += ""
                
                html += ""
                print (imname+"################")
                html += ""
            # show random selection if no query
            # 如果没有查询图像则随机显示一些图像
        else:
            random.shuffle(self.ndx)
            for i in self.ndx[:self.maxres]:
                imname = self.imlist[i]
                html += ""
                
                html += ""
                print (imname+"################")
                html += ""

        html += self.footer
        return html

    index.exposed = True
cherrypy.quickstart(SearchDemo(), '/', config=os.path.join(os.path.dirname(__file__), 'service.conf'))

该类包含一个初始化 int() 方法和一个“索引”页面 index() 方法。这两个方法可以自动地映射至 URL，并且方法中的参数可以直接传递到 URL 中。index 方法里有一个查询参数，在本例中，该参数是查询图像，用来对其他图像排序。如果该参数是空的， 就会随机显示一些图像。

index.exposed = True

上面一行使索引 URL 可以被访问，上面 searchsemo.py 中紧接着该行的最后一行通过读取 service.conf 配置文件开启 CherryPy Web服务器。在这个例子中，配置文件如下：

[global]
server.socket_host = “127.0.0.1”
server.socket_port = 8080
server.thread_pool = 50
tools.sessions.on = True
[/]
tools.staticdir.root = “D:\Python\chapter7\BOW\”
tools.staticdir.on = True
tools.staticdir.dir = “”

第一部分指定使用的 IP 地址和端口，第二部分确保本地文件夹可以读取。

打开浏览器，在地址栏输入http://127.0.0.1:8080/，你可以看到随机挑选出来的图像的初始页面：


点击一幅图像进行查询，会显示出搜索出来的前几幅图像：

在搜索出来的图像中单击某图像可以开始新的查询：