Upload 2408 files

.gitattributes

@@ -57,3 +57,21 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints/export/Servo/1579781919/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints/model.ckpt-0.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints/model.ckpt-0.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints/model.ckpt-2000.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints/model.ckpt-2000.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/export/Servo/1579783100/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/model.ckpt-0.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/model.ckpt-0.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/model.ckpt-4149.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/model.ckpt-4149.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/model.ckpt-5000.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/checkpoints2/model.ckpt-5000.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/faster_rcnn_resnet50_coco/model.ckpt.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/faster_rcnn_resnet50_coco/model.ckpt.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/test.record filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/tfgraph/model.ckpt.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/tfgraph/model.ckpt.meta filter=lfs diff=lfs merge=lfs -text
+dfesa/Detection/train.record filter=lfs diff=lfs merge=lfs -text

dfesa/Detection/callmethiago.py

@@ -0,0 +1,4 @@
+import docker
+client = docker.from_env()
+client.containers.list()
+#client.containers.run("ubuntu", "echo hello world")

dfesa/Detection/check_xml_label.py

@@ -0,0 +1,43 @@
+import os
+import glob
+import pandas as pd
+import xml.etree.ElementTree as ET
+import pdb
+
+
+def xml_to_csv(path):
+    xml_list = []
+    #pdb.set_trace()
+    for xml_file in glob.glob(path + '/*.xml'):
+        tree = ET.parse(xml_file)
+        root = tree.getroot()
+        parsed_xml=xml_file.split('/')
+        label_name=parsed_xml[-1]
+        label_name=label_name.split('.')
+        #pdb.set_trace()
+        root.find('filename').text=label_name[0]+'.jpg'
+        ET.tostring(root)
+        tree.write(path+parsed_xml[-1])
+        #pdb.set_trace()
+
+    #return   
+
+
+
+for directory in ['train']:
+        #image_path = os.path.join(os.getcwd(), '/root/drive/My Drive/PLACAS_BUNGE/PLACAS_BUNGE/SO_PLACAS/train/'.format(directory))
+
+    image_path = os.path.join(os.getcwd(), '/home/dfesa/Python_code/DFESA/Detection/train/'.format(directory))
+    print(os.path.join(os.getcwd(), '/home/dfesa/Python_code/DFESA/Detection/train/'.format(directory)))
+    #pdb.set_trace()
+    xml_df = xml_to_csv(image_path)
+    #xml_df.to_csv('/home/dfesa/Python_code/DFESA/Detection/{}_labels.csv'.format(directory), index=None)
+    print('Partial fim')
+    #pdb.set_trace()
+for directory in ['test']:
+    #   image_path = os.path.join(os.getcwd(), '/root/drive/My Drive/PLACAS_BUNGE/PLACAS_BUNGE/SO_PLACAS/test/'.format(directory))
+    image_path = os.path.join(os.getcwd(), '/home/dfesa/Documentos/Ts/teste/'.format(directory))
+    #pdb.set_trace()
+    xml_df = xml_to_csv(image_path)
+    #xml_df.to_csv('/home/dfesa/Python_code/DFESA/Detection/{}_labels.csv'.format(directory), index=None)
+    print('Fim')

dfesa/Detection/checkpoints/checkpoint

@@ -0,0 +1,3 @@
+model_checkpoint_path: "model.ckpt-2000"
+all_model_checkpoint_paths: "model.ckpt-0"
+all_model_checkpoint_paths: "model.ckpt-2000"

dfesa/Detection/checkpoints/eval_0/events.out.tfevents.1579781919.dfesa-PC

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a45f60a417e26a4b2e6f88dd8b01aad1a294425e286f5c71af7803ab2b46d11c
+size 19590388

dfesa/Detection/checkpoints/events.out.tfevents.1579781609.dfesa-PC

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9f5ddade70d067c015e1c5359048a1387196b5c2037869a9146750b3613a3d1
+size 16772446

dfesa/Detection/checkpoints/export/Servo/1579781919/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6eef0b100d381449f79ccd06e4386c00861bfb5652036e82c0e9fd11ed626528
+size 2093058

dfesa/Detection/checkpoints/export/Servo/1579781919/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c2b0f7d9867a22b3393cfc583cb679a415ea42a0c907d669fd63813aaa39b97
+size 173307988

dfesa/Detection/checkpoints/model.ckpt-0.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75def7f119e6c6a832d0182fd013f89f40be5cc9dd89fe730dc30246d07521b2
+size 286454432

dfesa/Detection/checkpoints/model.ckpt-0.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5455f6f4d5587834646dd37f307f4c983f548ba92da7bb788a6ec8aaccd70617
+size 4635924

dfesa/Detection/checkpoints/model.ckpt-2000.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b472400b3a6d1dc439790bd79e9d3bb78b0686868e356328e9bcf8a9c7d88d38
+size 286454432

dfesa/Detection/checkpoints/model.ckpt-2000.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a949423d814e29e901a0851a337fa56f35f64050971f92676f6f4d7be3fc139b
+size 4635924

dfesa/Detection/checkpoints2/checkpoint

@@ -0,0 +1,4 @@
+model_checkpoint_path: "model.ckpt-5000"
+all_model_checkpoint_paths: "model.ckpt-0"
+all_model_checkpoint_paths: "model.ckpt-4149"
+all_model_checkpoint_paths: "model.ckpt-5000"

dfesa/Detection/checkpoints2/eval_0/events.out.tfevents.1579782968.dfesa-PC

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2dc31bb1d5f95772b09d897e61d8b33dd68857cca1e69a93d49f5e41079c245
+size 33693216

dfesa/Detection/checkpoints2/events.out.tfevents.1579782350.dfesa-PC

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:873979fac8b1d159876c7aeac13aadbc66430f54510135c4f5e8b5a701ad4ffd
+size 16779067

dfesa/Detection/checkpoints2/export/Servo/1579783100/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3530bce2d17f6bac71b213fe74b28efb992648ec71607204377604108a88ea0
+size 2093058

dfesa/Detection/checkpoints2/export/Servo/1579783100/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59f193cbdbe97493e1b29d55790ddfa79be507ea4cea6007597894b08ea9428e
+size 173307988

dfesa/Detection/checkpoints2/model.ckpt-0.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f8b1fdb2a2bee54c653bc9cd9e899df9cd2ef67aa8cf12320a761b6c1b47c61
+size 286454432

dfesa/Detection/checkpoints2/model.ckpt-0.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31455795e5cb0933f546cf939d876cc370832f00b31624aeece4b52d5883968b
+size 4635942

dfesa/Detection/checkpoints2/model.ckpt-4149.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dbec6243a38712f5ba98590b2f842e05420e9cdc50be7ab82d750ea0dc4c9900
+size 286454432

dfesa/Detection/checkpoints2/model.ckpt-4149.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff039f80aaf679ef53885ad74ddda3c9a55d190bfa23ebf105a17cc0d9e861b5
+size 4635942

dfesa/Detection/checkpoints2/model.ckpt-5000.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bdfdd32cd644b986441ad9e32856dbcb4805c41264dfe107b9e60e86df7cf26
+size 286454432

dfesa/Detection/checkpoints2/model.ckpt-5000.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ce5d36f27f7959b4deb87e687a8f83d69f2d03b49a281dd21bd4f1d53fba2b3
+size 4635942

dfesa/Detection/csv2tfrecords.py

@@ -0,0 +1,108 @@
+"""
+Usage:
+  # From the data set dir
+  # Create train data:
+  python ../generate_tfrecord.py --csv_input=data/train_labels.csv  --output_path=train.record
+"""
+from __future__ import division
+from __future__ import print_function
+from __future__ import absolute_import
+
+import os
+import io
+import pandas as pd
+import tensorflow as tf
+import pdb
+
+from PIL import Image
+from object_detection.utils import dataset_util
+from collections import namedtuple, OrderedDict
+
+flags = tf.app.flags
+flags.DEFINE_string('csv_input', '', 'Path to the CSV input')
+flags.DEFINE_string('output_path', '', 'Path to output TFRecord')
+FLAGS = flags.FLAGS
+
+
+# TO-DO replace this with label map
+def class_text_to_int(row_label):
+    if row_label == 'Falta':
+        return 1
+    if row_label == 'Objeto':
+        return 2
+    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, '{}'.format(group.filename)), 'rb') as fid:
+        encoded_jpg = fid.read()
+    encoded_jpg_io = io.BytesIO(encoded_jpg)
+    #pdb.set_trace()
+    image = Image.open(encoded_jpg_io)
+    #pdb.set_trace()
+    width, height = image.size
+
+    filename = 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']))
+        #pdb.set_trace()
+
+    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())
+    path=path+'/teste/'
+    #pdb.set_trace()
+    examples = pd.read_csv(FLAGS.csv_input)
+    grouped = split(examples, 'filename')
+    
+    #pdb.set_trace()
+    for group in grouped:
+        #pdb.set_trace()
+        tf_example = create_tf_example(group, path)
+        writer.write(tf_example.SerializeToString())
+
+    writer.close()
+    output_path = os.path.join(os.getcwd(), FLAGS.output_path)
+    print('Successfully created the TFRecords: {}'.format(output_path))
+
+
+if __name__ == '__main__':
+    tf.app.run()

dfesa/Detection/detect_object.py

@@ -0,0 +1,170 @@
+import numpy as np
+import os
+import six.moves.urllib as urllib
+import sys
+import tarfile
+import tensorflow as tf
+import zipfile
+import tkinter
+import matplotlib
+import pdb
+import pandas as pd 
+from distutils.version import StrictVersion
+from collections import defaultdict
+from io import StringIO
+from matplotlib import pyplot as plt
+from PIL import Image
+
+matplotlib.use('TkAgg')
+
+config = tf.ConfigProto()
+config.gpu_options.per_process_gpu_memory_fraction=0.8
+config.gpu_options.allow_growth = True
+sess = tf.Session(config=config)
+
+# This is needed since the notebook is stored in the object_detection folder.
+sys.path.append("/home/dfesa/models/research/")
+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
+
+
+MODEL_NAME = '/home/dfesa/Python_code/DFESA/Detection/tfgraph'
+
+PATH_TO_FROZEN_GRAPH = MODEL_NAME + '/frozen_inference_graph.pb'
+#PATH_TO_FROZEN_GRAPH = '/frozen_inference_graph.pb'
+PATH_TO_LABELS =  '/home/dfesa/Python_code/DFESA/Detection/label_map.pbtxt'
+
+
+
+def detect_object(image_file):
+
+
+  NUM_CLASSES = 2
+
+  detection_graph = tf.Graph()
+  with detection_graph.as_default():
+    od_graph_def = tf.GraphDef()
+    with tf.gfile.GFile(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='')
+
+  category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)
+
+  def load_image_into_numpy_array(image):
+    (im_width, im_height) = image.size
+    return np.array(image.getdata()).reshape(
+        (im_height, im_width, 3)).astype(np.uint8)
+
+  # Size, in inches, of the output images.
+  IMAGE_SIZE = (12, 8)
+
+  imagem = '/home/dfesa/Python_code/DFESA/Detection/teste/DJI_0652_01_02.jpg'
+
+  def run_inference_for_single_image(image, 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]
+        #pdb.set_trace()
+        if 'detection_masks' in output_dict:
+          output_dict['detection_masks'] = output_dict['detection_masks'][0]
+    return output_dict
+
+  # Commented out IPython magic to ensure Python compatibility.
+  #SINGLE PREDICTION
+
+  # %matplotlib inline
+
+
+  image = Image.open(imagem)
+  #  image = (imagem)
+    # 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 = load_image_into_numpy_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 = run_inference_for_single_image(image_np_expanded, detection_graph)
+    # Visualization of the results of a detection.
+  dtaf=pd.DataFrame.from_dict(output_dict,orient="index")
+  #pdb.set_trace()
+  #largest_detection=dtaf.loc['detection_scores'][0].max()
+  #print(largest_detection)
+
+  maptrue=dtaf.loc['detection_scores'][0]>0.8
+  centerx=[]
+  centery=[]
+  centers=[]
+  yesno=[]
+
+  if np.any(maptrue == True):
+    boxes=dtaf.loc['detection_boxes'][0][maptrue]
+    for box in boxes:
+      centerx.append((box[0]+box[1])/2)
+      centery.append((box[2]+box[3])/2)
+    pdb.set_trace()
+    npcenterx=np.asarray(centerx)
+    npcentery=np.asarray(centery)
+    npcenterx=npcenterx.reshape(-1,1)
+    npcentery=npcentery.reshape(-1,1)
+    pdb.set_trace()
+    #TODO FIX THIS CENTERS
+    centers=np.concatenate((npcenterx,npcentery),axis=1)
+  return centers
+
+
+
+
+  # if largest_detection>0.8:
+  #   yesno=True
+  # else:
+  #   yesno=False
+
+
+  # return yesno
+
+pdb.set_trace()
+imagem2 = '/home/dfesa/Python_code/DFESA/Detection/teste/DJI_0652_01_02.jpg'
+ave=detect_object(imagem2)
+for i in ave:
+  print(i)
+pdb.set_trace()

dfesa/Detection/docker/Dockerfile

@@ -0,0 +1,53 @@
+FROM ubuntu:18.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+# Common, note that two updates are needed
+RUN apt-get update
+
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install --assume-yes git && \ 
+    apt-get install build-essential -y --no-install-recommends python3 python3-pip python3-virtualenv python3-tk  protobuf-compiler python-pil python-lxml python-tk
+
+ENV VIRTUAL_ENV=/opt/venv
+RUN python3 -m virtualenv --python=/usr/bin/python3 $VIRTUAL_ENV$
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Install dependencies
+
+RUN pip3 install --upgrade pip
+RUN pip3 install setuptools
+RUN pip3 install sklearn
+RUN pip3 install pandas
+RUN pip3 install matplotlib
+RUN pip3 install pillow
+RUN pip3 install requests
+RUN pip3 install Cython
+RUN pip3 install contextlib2
+RUN pip3 install lxml
+#RUN pip3 install h5py
+RUN pip3 install tensorflow==1.14
+#RUN pip3 install xgboost
+RUN pip3 install -U Flask
+RUN pip3 install requests
+
+# Download tensorflow models
+RUN git clone https://github.com/tensorflow/models.git /tensorflow/models
+WORKDIR /tensorflow/models/research 
+RUN protoc object_detection/protos/*.proto --python_out=.
+RUN export PYTHONPATH=$PYTHONPATH:`pwd`:`pwd`/slim
+
+
+
+RUN pwd
+RUN ls
+
+#Run the application
+RUN mkdir -p /tffiles
+RUN mkdir -p /tempimgs
+
+COPY ./label_map.pbtxt /tffiles/
+COPY ./frozen_inference_graph.pb /tffiles/
+COPY ./2DJI_0707_02_01.jpg /tffiles/
+COPY v1A.py .
+CMD ["python3","v1A.py"]

dfesa/Detection/docker/callmethiago.py

@@ -0,0 +1,45 @@
+import docker
+import requests
+import time
+import pdb
+import json
+
+client = docker.from_env()
+
+#client.containers.run("upbeat", detach=True)
+#client.containers.run("ubuntu:latest", "echo hello world",detach=True)
+print("uiases")
+
+#print(client.containers.list())
+#payload = {'dir1': '/tempimgs/DJI_0732_01_01.jpg'}
+payload{'images': ['/tempimgs/DJI_0732_01_01.jpg', '/tempimgs/DJI_0732_01_01.jpg']}
+json_string = json.dumps(payload)
+#print(json_string)
+#pdb.set_trace()
+
+
+objeto=client.containers.run("upbeat",detach=True,ports= {'5000/tcp': ('localhost', 5000)},volumes={'/home/dfesa/.local/share/Agisoft/Metashape Pro/Projects/temp_files/': {'bind': '/tempimgs/', 'mode': 'rw'}} )
+#pdb.set_trace()
+time.sleep(3)
+#route_get='localhost:5000/teste'
+#headers = {'content-type': 'application/json'}
+
+#json_string = json.dumps(payload)
+
+response_get = requests.post('http://localhost:5000/teste',json=json_string)
+#pdb.set_trace()
+print(response_get.json())
+
+#pdb.set_trace()
+#pdb.set_trace()
+print("asehsa2")
+if response_get.status_code == 200:
+	#pdb.set_trace()
+	print(response_get.text)
+else:
+	#pdb.set_trace()
+	print(response_get.status_code)
+
+#pdb.set_trace()
+#client.containers.kill()
+ 

dfesa/Detection/docker/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '2.3'
+
+networks:
+    jupyter-newtwork:
+
+services:
+    jupyter:
+        container_name: jupyter
+        build: .
+        ports:
+            - "8080:8080"
+        volumes:
+            - /home/dfesa/Python_code/DFESA/Detection/docker:/root/mount/
+            - "/home/dfesa/.local/share/Agisoft/Metashape Pro/Projects/temp_files:/tempimgs"
+        restart: always

dfesa/Detection/docker/frozen_inference_graph.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec109a26af464c42e6cbaf94fc2f63e460a80e1f632728d56fa8a71eca797470
+size 114026995

dfesa/Detection/docker/label_map.pbtxt

@@ -0,0 +1,9 @@
+item {
+  id: 1
+  name: 'Falta'
+}
+
+item {
+  id: 2
+  name: 'Objeto'
+}

dfesa/Detection/docker/tuto.txt

@@ -0,0 +1,11 @@
+docker build . -t upbeat
+docker run upbeat
+
+docker run -p 5000:5000 -d upbeat (flask)
+
+
+
+docker ps
+docker kill 
+docker build . -t upbeat
+

dfesa/Detection/docker/v1Ad.py

@@ -0,0 +1,157 @@
+import numpy as np
+import os
+import six.moves.urllib as urllib
+import sys
+import tarfile
+import tensorflow as tf
+import zipfile
+import tkinter
+import matplotlib
+import pdb
+import pandas as pd 
+from distutils.version import StrictVersion
+from collections import defaultdict
+from io import StringIO
+from matplotlib import pyplot as plt
+from PIL import Image
+from flask import Flask
+import json
+import requests
+from flask import request
+from flask import jsonify
+
+
+#matplotlib.use('TkAgg')
+config = tf.ConfigProto()
+config.gpu_options.per_process_gpu_memory_fraction=0.8
+config.gpu_options.allow_growth = True
+sess = tf.Session(config=config)
+
+currentdir=os.getcwd()
+print("asiufhsaueh")
+print(currentdir)
+
+# # This is needed since the notebook is stored in the object_detection folder.
+sys.path.append("/models/research/")
+#sys.path.append("/models/research/")
+
+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
+
+MODEL_NAME = '/tffiles'
+
+PATH_TO_FROZEN_GRAPH = MODEL_NAME + '/frozen_inference_graph.pb'
+#PATH_TO_FROZEN_GRAPH = '/frozen_inference_graph.pb'
+PATH_TO_LABELS =  '/tffiles/label_map.pbtxt'
+
+
+
+NUM_CLASSES = 2
+
+detection_graph = tf.Graph()
+with detection_graph.as_default():
+  od_graph_def = tf.GraphDef()
+  with tf.gfile.GFile(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='')
+
+category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)
+
+def load_image_into_numpy_array(image):
+  (im_width, im_height) = image.size
+  return np.array(image.getdata()).reshape(
+      (im_height, im_width, 3)).astype(np.uint8)
+
+# Size, in inches, of the output images.
+IMAGE_SIZE = (12, 8)
+
+
+def run_inference_for_single_image(image, 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
+
+
+fy({'prediction': list(prediction)})
+
+
+app = Flask(__name__)
+@app.route('/teste',methods=['POST'])
+def find_failure():
+
+	imagem=request.json
+	
+	json_data = json.loads(imagem)
+
+	imagem =json_data['dir1']
+
+
+#-------------------------------------------------------------------------
+	image = Image.open(imagem)
+
+	image_np = load_image_into_numpy_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 = run_inference_for_single_image(image_np_expanded, detection_graph)
+	  # Visualization of the results of a detection.
+	dtaf=pd.DataFrame.from_dict(output_dict,orient="index")
+	largest_detection=dtaf.loc['detection_scores'][0].max()
+	print(largest_detection)
+
+	if largest_detection>0.8:
+		yesno="1"
+	else:
+		yesno="0"
+	print(yesno)
+	return jsonify(yesno)
+
+#-------------------------------------------------------------------------------
+
+
+if __name__ == '__main__':
+	app.run(host='0.0.0.0', port='5000', debug=True)
+   

dfesa/Detection/faster_rcnn_resnet50_coco.config

@@ -0,0 +1,145 @@
+# Faster R-CNN with Resnet-50 (v1), configuration for MSCOCO Dataset.
+# Users should configure the fine_tune_checkpoint field in the train config as
+# well as the label_map_path and input_path fields in the train_input_reader and
+# eval_input_reader. Search for "PATH_TO_BE_CONFIGURED" to find the fields that
+# should be configured.
+
+model {
+  faster_rcnn {
+    num_classes: 2
+    image_resizer {
+      keep_aspect_ratio_resizer {
+        min_dimension: 600
+        max_dimension: 1024
+      }
+    }
+    feature_extractor {
+      type: 'faster_rcnn_resnet50'
+      first_stage_features_stride: 16
+    }
+    first_stage_anchor_generator {
+      grid_anchor_generator {
+        scales: [0.25, 0.5, 1.0, 2.0]
+        aspect_ratios: [0.5, 1.0, 2.0]
+        height_stride: 16
+        width_stride: 16
+      }
+    }
+    first_stage_box_predictor_conv_hyperparams {
+      op: CONV
+      regularizer {
+        l2_regularizer {
+          weight: 0.0
+        }
+      }
+      initializer {
+        truncated_normal_initializer {
+          stddev: 0.01
+        }
+      }
+    }
+    first_stage_nms_score_threshold: 0.0
+    first_stage_nms_iou_threshold: 0.7
+    first_stage_max_proposals: 300
+    first_stage_localization_loss_weight: 2.0
+    first_stage_objectness_loss_weight: 1.0
+    initial_crop_size: 14
+    maxpool_kernel_size: 2
+    maxpool_stride: 2
+    second_stage_box_predictor {
+      mask_rcnn_box_predictor {
+        use_dropout: false
+        dropout_keep_probability: 1.0
+        fc_hyperparams {
+          op: FC
+          regularizer {
+            l2_regularizer {
+              weight: 0.0
+            }
+          }
+          initializer {
+            variance_scaling_initializer {
+              factor: 1.0
+              uniform: true
+              mode: FAN_AVG
+            }
+          }
+        }
+      }
+    }
+    second_stage_post_processing {
+      batch_non_max_suppression {
+        score_threshold: 0.0
+        iou_threshold: 0.6
+        max_detections_per_class: 100
+        max_total_detections: 300
+      }
+      score_converter: SOFTMAX
+    }
+    second_stage_localization_loss_weight: 2.0
+    second_stage_classification_loss_weight: 1.0
+  }
+}
+
+train_config: {
+  batch_size: 1
+  optimizer {
+    momentum_optimizer: {
+      learning_rate: {
+        manual_step_learning_rate {
+          initial_learning_rate: 0.0003
+          schedule {
+            step: 900000
+            learning_rate: .00003
+          }
+          schedule {
+            step: 1200000
+            learning_rate: .000003
+          }
+        }
+      }
+      momentum_optimizer_value: 0.9
+    }
+    use_moving_average: false
+  }
+  gradient_clipping_by_norm: 10.0
+  fine_tune_checkpoint: "/home/dfesa/Python_code/DFESA/Detection/faster_rcnn_resnet50_coco/model.ckpt"
+  from_detection_checkpoint: true
+  # Note: The below line limits the training process to 200K steps, which we
+  # empirically found to be sufficient enough to train the pets dataset. This
+  # effectively bypasses the learning rate schedule (the learning rate will
+  # never decay). Remove the below line to train indefinitely.
+  num_steps: 200000
+  data_augmentation_options {
+    random_horizontal_flip {
+    }
+  }
+  data_augmentation_options {
+    random_image_scale {
+    }
+  }
+}
+
+train_input_reader: {
+  tf_record_input_reader {
+    input_path: "/home/dfesa/Python_code/DFESA/Detection/train.record"
+  }
+  label_map_path: "/home/dfesa/Python_code/DFESA/Detection/label_map.pbtxt"
+}
+
+eval_config: {
+  batch_size: 1
+  num_examples: 97
+  # Note: The below line limits the evaluation process to 10 evaluations.
+  # Remove the below line to evaluate indefinitely.
+  # max_evals: 10
+}
+
+eval_input_reader: {
+  tf_record_input_reader {
+    input_path: "/home/dfesa/Python_code/DFESA/Detection/test.record"
+  }
+  label_map_path: "/home/dfesa/Python_code/DFESA/Detection/label_map.pbtxt"
+  shuffle: false
+  num_readers: 1
+}

dfesa/Detection/faster_rcnn_resnet50_coco/checkpoint

@@ -0,0 +1,2 @@
+model_checkpoint_path: "model.ckpt"
+all_model_checkpoint_paths: "model.ckpt"

dfesa/Detection/faster_rcnn_resnet50_coco/frozen_inference_graph.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e12cca9868c73f83940adafdcb18cda429ff398454505a721f95277b728c82af
+size 120549957

dfesa/Detection/faster_rcnn_resnet50_coco/model.ckpt.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:118f28f83927eb96e72edf5e3c85e397bb07a6f83a9527d95f75c1b7e02fe831
+size 176914228

dfesa/Detection/faster_rcnn_resnet50_coco/model.ckpt.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a248853b541d36bdf98550b6c94913e9c9a4e057fbad0cb7a8862068ef288aab
+size 5675175