# coding:utf-8
import os
import random
from PIL import Image
?
?
def deleteImages(file_path, file_list):
    """
    删除图片
    """
    for fileName in file_list:
        command = "del " + file_path + "\\" + fileName
        os.system(command)
?
?
def change_image_name(file_path, file_list):
    """
    修改图片名字
    """
    for index, fileName in enumerate(file_list):
        if fileName.find(‘.jpg‘) == -1:
            continue
        print(index, fileName)
        newFileName = str(‘%03d‘ % index) + ".jpg"
        print(newFileName)
        im = Image.open(file_path + ‘/‘ + fileName)
        im.save(file_path + ‘/‘ + newFileName)
?
?
def main():
    # file_path = ‘.\\train\\images‘
    file_path = ‘.\\test\\images‘
    file_list = os.listdir(file_path)
    random.shuffle(file_list)
?
    change_image_name(file_path, file_list)
    deleteImages(file_path, file_list)
?
?
if __name__ == ‘__main__‘:
    main()

import glob
import pandas as pd
import xml.etree.ElementTree as ET
?
# 需要修改地方：选择训练集train还是测试集test
datasets = ‘train‘
csv_path = ‘.\\‘ + datasets + ‘\\‘
xml_path = ‘.\\‘ + datasets + ‘\\labels\\‘
?
?
def xml_to_csv(path):
    """将xml转换成csv格式的数据"""
    xml_list = []
    for xml_file in glob.glob(path + ‘*.xml‘):
        tree = ET.parse(xml_file)
        root = tree.getroot()
        for member in root.findall(‘object‘):
            value = (root.find(‘filename‘).text,
                     int(root.find(‘size‘)[0].text),
                     int(root.find(‘size‘)[1].text),
                     member[0].text,
                     int(member[4][0].text),
                     int(member[4][1].text),
                     int(member[4][2].text),
                     int(member[4][3].text)
                     )
            xml_list.append(value)
    column_name = [‘filename‘, ‘width‘, ‘height‘, ‘class‘, ‘xmin‘, ‘ymin‘, ‘xmax‘, ‘ymax‘]
    xml_df = pd.DataFrame(xml_list, columns=column_name)
    return xml_df
?
?
def main():
    xml_df = xml_to_csv(xml_path)
    xml_df.to_csv(csv_path + datasets + ‘.csv‘, index=None)
    print(‘Successfully converted %s\‘s xml to csv.‘ % datasets)
?
?
if __name__ == ‘__main__‘:
    main()

import os
import io
import pandas as pd
import tensorflow as tf
?
from PIL import Image
from object_detection.utils import dataset_util
from collections import namedtuple
?
# 此时是训练集还是测试集
datasets = ‘train‘
flags = tf.app.flags
flags.DEFINE_string(‘csv_input‘, ‘./%s/%s.csv‘ % (datasets, datasets), ‘Path to the CSV input‘)
flags.DEFINE_string(‘output_path‘, ‘./%s/%s.tfrecord‘ % (datasets, datasets), ‘Path to output TFRecord‘)
flags.DEFINE_string(‘train_or_test‘, ‘%s‘ % datasets, ‘train/test datasets‘)
FLAGS = flags.FLAGS
?
?
# 这里将label修改成自己的类别
def class_text_to_int(row_label):
    if row_label == ‘face‘:
        return 1
    if row_label == ‘eye‘:
        return 2
    if row_label == ‘mouth‘:
        return 3
    else:
        None
?
?
def split(df, group):
    data = namedtuple(‘data‘, [‘filename‘, ‘object‘])
    gb = df.groupby(group)
    return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]
?
?
def create_tf_example(group, path):
    # 根据之前修改图像名字时给图像的命令来修改
    with tf.gfile.GFile(os.path.join(path, ‘%03d.jpg‘ % group.filename), ‘rb‘) as fid:
        encoded_jpg = fid.read()
    encoded_jpg_io = io.BytesIO(encoded_jpg)
    image = Image.open(encoded_jpg_io)
    width, height = image.size
?
    # 根据之前修改图像名字时给图像的命令来修改
    filename = (‘%03d.jpg‘ % group.filename).encode(‘utf8‘)
    image_format = b‘jpg‘
    xmins = []
    xmaxs = []
    ymins = []
    ymaxs = []
    classes_text = []
    classes = []
?
    for index, row in group.object.iterrows():
        xmins.append(row[‘xmin‘] / width)
        xmaxs.append(row[‘xmax‘] / width)
        ymins.append(row[‘ymin‘] / height)
        ymaxs.append(row[‘ymax‘] / height)
        classes_text.append(row[‘class‘].encode(‘utf8‘))
        classes.append(class_text_to_int(row[‘class‘]))
?
    # 转换为tfrecords需要的格式
    tf_example = tf.train.Example(features=tf.train.Features(feature={
        ‘image/height‘: dataset_util.int64_feature(height),
        ‘image/width‘: dataset_util.int64_feature(width),
        ‘image/filename‘: dataset_util.bytes_feature(filename),
        ‘image/source_id‘: dataset_util.bytes_feature(filename),
        ‘image/encoded‘: dataset_util.bytes_feature(encoded_jpg),
        ‘image/format‘: dataset_util.bytes_feature(image_format),
        ‘image/object/bbox/xmin‘: dataset_util.float_list_feature(xmins),
        ‘image/object/bbox/xmax‘: dataset_util.float_list_feature(xmaxs),
        ‘image/object/bbox/ymin‘: dataset_util.float_list_feature(ymins),
        ‘image/object/bbox/ymax‘: dataset_util.float_list_feature(ymaxs),
        ‘image/object/class/text‘: dataset_util.bytes_list_feature(classes_text),
        ‘image/object/class/label‘: dataset_util.int64_list_feature(classes),
    }))
    return tf_example
?
?
def main(_):
    writer = tf.python_io.TFRecordWriter(FLAGS.output_path)
    path = os.path.join(os.getcwd() + ‘\\‘ + FLAGS.train_or_test, ‘images‘)
    examples = pd.read_csv(FLAGS.csv_input)
    grouped = split(examples, ‘filename‘)
    for group in grouped:
        tf_example = create_tf_example(group, path)
        writer.write(tf_example.SerializeToString())
?
    writer.close()
    print(‘Successfully created the TFRecords: {}‘.format(FLAGS.output_path))
?
?
if __name__ == ‘__main__‘:
    tf.app.run()

import os
import cv2
import sys
import numpy as np
from PIL import Image
import tensorflow as tf
?
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
from object_detection.utils import ops as utils_ops
from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as vis_util
?
?
# -----------------------------摄像头类定义----------------------------- #
class Camera(object):
    def __init__(self, channel):
        self.capture = cv2.VideoCapture(channel)
?
        self.fps = int(self.capture.get(cv2.CAP_PROP_FPS))
        self.video_height = int(self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
        self.video_width = int(self.capture.get(cv2.CAP_PROP_FRAME_WIDTH))
?
        self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, self.video_width)
        self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, self.video_height)
        self.capture.set(cv2.CAP_PROP_FPS, self.fps)
?
    def get_image(self):
        """
        获取图像
        """
        if self.capture.isOpened():
            ret, frame = self.capture.read()
            if ret is True:
                print(‘get picture success‘)
                return frame
            else:
                print(‘get picture failed‘)
                return None
?
    def release_camera(self):
        """
        释放摄像机资源
        """
        self.capture.release()
        cv2.destroyAllWindows()
?
# ------------------------------识别类定义----------------------------- #
class SSD_Model(object):
    def __init__(self, PATH_TO_FROZEN_GRAPH, PATH_TO_LABELS):
        self.PATH_TO_FROZEN_GRAPH = PATH_TO_FROZEN_GRAPH
        # 添加需要识别的标签
        PATH_TO_LABELS = PATH_TO_LABELS
        self.category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)
        self.detection_graph = self.load_model()
?
    def load_model(self):
        # 载入模型文件
        detection_graph = tf.Graph()
        with detection_graph.as_default():
            od_graph_def = tf.GraphDef()
            with tf.gfile.GFile(self.PATH_TO_FROZEN_GRAPH, ‘rb‘) as fid:
                serialized_graph = fid.read()
                od_graph_def.ParseFromString(serialized_graph)
                tf.import_graph_def(od_graph_def, name=‘‘)
        return detection_graph
?
    def run_inference_for_single_image(self, image):
        ‘‘‘
        对单幅图像进行推断
        ‘‘‘
        graph = self.detection_graph
        with graph.as_default():
            with tf.Session() as sess:
                # Get handles to input and output tensors
                ops = tf.get_default_graph().get_operations()
                all_tensor_names = {output.name for op in ops for output in op.outputs}
                tensor_dict = {}
                for key in [
                    ‘num_detections‘, ‘detection_boxes‘, ‘detection_scores‘,
                    ‘detection_classes‘, ‘detection_masks‘]:
                    tensor_name = key + ‘:0‘
                    if tensor_name in all_tensor_names:
                        tensor_dict[key] = tf.get_default_graph().get_tensor_by_name(
                            tensor_name)
                if ‘detection_masks‘ in tensor_dict:
                    # The following processing is only for single image
                    detection_boxes = tf.squeeze(tensor_dict[‘detection_boxes‘], [0])
                    detection_masks = tf.squeeze(tensor_dict[‘detection_masks‘], [0])
                    # Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
                    real_num_detection = tf.cast(tensor_dict[‘num_detections‘][0], tf.int32)
                    detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1])
                    detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1])
                    detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
                        detection_masks, detection_boxes, image.shape[1], image.shape[2])
                    detection_masks_reframed = tf.cast(
                        tf.greater(detection_masks_reframed, 0.5), tf.uint8)
                    # Follow the convention by adding back the batch dimension
                    tensor_dict[‘detection_masks‘] = tf.expand_dims(
                        detection_masks_reframed, 0)
                image_tensor = tf.get_default_graph().get_tensor_by_name(‘image_tensor:0‘)
?
                # Run inference
                output_dict = sess.run(tensor_dict,
                                       feed_dict={image_tensor: image})
?
                # all outputs are float32 numpy arrays, so convert types as appropriate
                output_dict[‘num_detections‘] = int(output_dict[‘num_detections‘][0])
                output_dict[‘detection_classes‘] = output_dict[
                    ‘detection_classes‘][0].astype(np.int64)
                output_dict[‘detection_boxes‘] = output_dict[‘detection_boxes‘][0]
                output_dict[‘detection_scores‘] = output_dict[‘detection_scores‘][0]
                if ‘detection_masks‘ in output_dict:
                    output_dict[‘detection_masks‘] = output_dict[‘detection_masks‘][0]
        return output_dict
?
?
def main():
    # 开启摄像头
    camera = Camera(0)
    # 输入模型
    recognize = SSD_Model(‘./training/output_model/frozen_inference_graph.pb‘,
                          ‘./training/data/face_detection.pbtxt‘)
?
    while camera.capture.isOpened():
    # if True:
        image = camera.get_image()
        # image = cv2.imread(‘./training/test_image/007.jpg‘)
        # the array based representation of the image will be used later in order to prepare the
        # result image with boxes and labels on it.
        image_np = np.array(image)
        # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
        image_np_expanded = np.expand_dims(image_np, axis=0)
        # Actual detection.
        output_dict = recognize.run_inference_for_single_image(image_np_expanded)
        # Visualization of the results of a detection.
        vis_util.visualize_boxes_and_labels_on_image_array(
            image_np,
            output_dict[‘detection_boxes‘],
            output_dict[‘detection_classes‘],
            output_dict[‘detection_scores‘],
            recognize.category_index,
            instance_masks=output_dict.get(‘detection_masks‘),
            use_normalized_coordinates=True,
            line_thickness=2)
?
        cv2.imshow(‘image‘, image_np)
        cv2.waitKey(20)
?
?
if __name__ == "__main__":
    main()
?