Upload 3 files

keypoint_ops.py

@@ -0,0 +1,366 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Keypoint operations.
+
+Keypoints are represented as tensors of shape [num_instances, num_keypoints, 2],
+where the last dimension holds rank 2 tensors of the form [y, x] representing
+the coordinates of the keypoint.
+"""
+import numpy as np
+import tensorflow as tf
+
+
+def scale(keypoints, y_scale, x_scale, scope=None):
+  """Scales keypoint coordinates in x and y dimensions.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    y_scale: (float) scalar tensor
+    x_scale: (float) scalar tensor
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'Scale'):
+    y_scale = tf.cast(y_scale, tf.float32)
+    x_scale = tf.cast(x_scale, tf.float32)
+    new_keypoints = keypoints * [[[y_scale, x_scale]]]
+    return new_keypoints
+
+
+def clip_to_window(keypoints, window, scope=None):
+  """Clips keypoints to a window.
+
+  This op clips any input keypoints to a window.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+      window to which the op should clip the keypoints.
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'ClipToWindow'):
+    y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+    win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+    y = tf.maximum(tf.minimum(y, win_y_max), win_y_min)
+    x = tf.maximum(tf.minimum(x, win_x_max), win_x_min)
+    new_keypoints = tf.concat([y, x], 2)
+    return new_keypoints
+
+
+def prune_outside_window(keypoints, window, scope=None):
+  """Prunes keypoints that fall outside a given window.
+
+  This function replaces keypoints that fall outside the given window with nan.
+  See also clip_to_window which clips any keypoints that fall outside the given
+  window.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+      window outside of which the op should prune the keypoints.
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'PruneOutsideWindow'):
+    y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+    win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+
+    valid_indices = tf.logical_and(
+        tf.logical_and(y >= win_y_min, y <= win_y_max),
+        tf.logical_and(x >= win_x_min, x <= win_x_max))
+
+    new_y = tf.where(valid_indices, y, np.nan * tf.ones_like(y))
+    new_x = tf.where(valid_indices, x, np.nan * tf.ones_like(x))
+    new_keypoints = tf.concat([new_y, new_x], 2)
+
+    return new_keypoints
+
+
+def change_coordinate_frame(keypoints, window, scope=None):
+  """Changes coordinate frame of the keypoints to be relative to window's frame.
+
+  Given a window of the form [y_min, x_min, y_max, x_max], changes keypoint
+  coordinates from keypoints of shape [num_instances, num_keypoints, 2]
+  to be relative to this window.
+
+  An example use case is data augmentation: where we are given groundtruth
+  keypoints and would like to randomly crop the image to some window. In this
+  case we need to change the coordinate frame of each groundtruth keypoint to be
+  relative to this new window.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+      window we should change the coordinate frame to.
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'ChangeCoordinateFrame'):
+    win_height = window[2] - window[0]
+    win_width = window[3] - window[1]
+    new_keypoints = scale(keypoints - [window[0], window[1]], 1.0 / win_height,
+                          1.0 / win_width)
+    return new_keypoints
+
+
+def keypoints_to_enclosing_bounding_boxes(keypoints):
+  """Creates enclosing bounding boxes from keypoints.
+
+  Args:
+    keypoints: a [num_instances, num_keypoints, 2] float32 tensor with keypoints
+      in [y, x] format.
+
+  Returns:
+    A [num_instances, 4] float32 tensor that tightly covers all the keypoints
+    for each instance.
+  """
+  ymin = tf.math.reduce_min(keypoints[:, :, 0], axis=1)
+  xmin = tf.math.reduce_min(keypoints[:, :, 1], axis=1)
+  ymax = tf.math.reduce_max(keypoints[:, :, 0], axis=1)
+  xmax = tf.math.reduce_max(keypoints[:, :, 1], axis=1)
+  return tf.stack([ymin, xmin, ymax, xmax], axis=1)
+
+
+def to_normalized_coordinates(keypoints, height, width,
+                              check_range=True, scope=None):
+  """Converts absolute keypoint coordinates to normalized coordinates in [0, 1].
+
+  Usually one uses the dynamic shape of the image or conv-layer tensor:
+    keypoints = keypoint_ops.to_normalized_coordinates(keypoints,
+                                                       tf.shape(images)[1],
+                                                       tf.shape(images)[2]),
+
+  This function raises an assertion failed error at graph execution time when
+  the maximum coordinate is smaller than 1.01 (which means that coordinates are
+  already normalized). The value 1.01 is to deal with small rounding errors.
+
+  Args:
+    keypoints: A tensor of shape [num_instances, num_keypoints, 2].
+    height: Maximum value for y coordinate of absolute keypoint coordinates.
+    width: Maximum value for x coordinate of absolute keypoint coordinates.
+    check_range: If True, checks if the coordinates are normalized.
+    scope: name scope.
+
+  Returns:
+    tensor of shape [num_instances, num_keypoints, 2] with normalized
+    coordinates in [0, 1].
+  """
+  with tf.name_scope(scope, 'ToNormalizedCoordinates'):
+    height = tf.cast(height, tf.float32)
+    width = tf.cast(width, tf.float32)
+
+    if check_range:
+      max_val = tf.reduce_max(keypoints)
+      max_assert = tf.Assert(tf.greater(max_val, 1.01),
+                             ['max value is lower than 1.01: ', max_val])
+      with tf.control_dependencies([max_assert]):
+        width = tf.identity(width)
+
+    return scale(keypoints, 1.0 / height, 1.0 / width)
+
+
+def to_absolute_coordinates(keypoints, height, width,
+                            check_range=True, scope=None):
+  """Converts normalized keypoint coordinates to absolute pixel coordinates.
+
+  This function raises an assertion failed error when the maximum keypoint
+  coordinate value is larger than 1.01 (in which case coordinates are already
+  absolute).
+
+  Args:
+    keypoints: A tensor of shape [num_instances, num_keypoints, 2]
+    height: Maximum value for y coordinate of absolute keypoint coordinates.
+    width: Maximum value for x coordinate of absolute keypoint coordinates.
+    check_range: If True, checks if the coordinates are normalized or not.
+    scope: name scope.
+
+  Returns:
+    tensor of shape [num_instances, num_keypoints, 2] with absolute coordinates
+    in terms of the image size.
+
+  """
+  with tf.name_scope(scope, 'ToAbsoluteCoordinates'):
+    height = tf.cast(height, tf.float32)
+    width = tf.cast(width, tf.float32)
+
+    # Ensure range of input keypoints is correct.
+    if check_range:
+      max_val = tf.reduce_max(keypoints)
+      max_assert = tf.Assert(tf.greater_equal(1.01, max_val),
+                             ['maximum keypoint coordinate value is larger '
+                              'than 1.01: ', max_val])
+      with tf.control_dependencies([max_assert]):
+        width = tf.identity(width)
+
+    return scale(keypoints, height, width)
+
+
+def flip_horizontal(keypoints, flip_point, flip_permutation, scope=None):
+  """Flips the keypoints horizontally around the flip_point.
+
+  This operation flips the x coordinate for each keypoint around the flip_point
+  and also permutes the keypoints in a manner specified by flip_permutation.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    flip_point:  (float) scalar tensor representing the x coordinate to flip the
+      keypoints around.
+    flip_permutation: rank 1 int32 tensor containing the keypoint flip
+      permutation. This specifies the mapping from original keypoint indices
+      to the flipped keypoint indices. This is used primarily for keypoints
+      that are not reflection invariant. E.g. Suppose there are 3 keypoints
+      representing ['head', 'right_eye', 'left_eye'], then a logical choice for
+      flip_permutation might be [0, 2, 1] since we want to swap the 'left_eye'
+      and 'right_eye' after a horizontal flip.
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'FlipHorizontal'):
+    keypoints = tf.transpose(keypoints, [1, 0, 2])
+    keypoints = tf.gather(keypoints, flip_permutation)
+    v, u = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+    u = flip_point * 2.0 - u
+    new_keypoints = tf.concat([v, u], 2)
+    new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+    return new_keypoints
+
+
+def flip_vertical(keypoints, flip_point, flip_permutation, scope=None):
+  """Flips the keypoints vertically around the flip_point.
+
+  This operation flips the y coordinate for each keypoint around the flip_point
+  and also permutes the keypoints in a manner specified by flip_permutation.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    flip_point:  (float) scalar tensor representing the y coordinate to flip the
+      keypoints around.
+    flip_permutation: rank 1 int32 tensor containing the keypoint flip
+      permutation. This specifies the mapping from original keypoint indices
+      to the flipped keypoint indices. This is used primarily for keypoints
+      that are not reflection invariant. E.g. Suppose there are 3 keypoints
+      representing ['head', 'right_eye', 'left_eye'], then a logical choice for
+      flip_permutation might be [0, 2, 1] since we want to swap the 'left_eye'
+      and 'right_eye' after a horizontal flip.
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'FlipVertical'):
+    keypoints = tf.transpose(keypoints, [1, 0, 2])
+    keypoints = tf.gather(keypoints, flip_permutation)
+    v, u = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+    v = flip_point * 2.0 - v
+    new_keypoints = tf.concat([v, u], 2)
+    new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+    return new_keypoints
+
+
+def rot90(keypoints, scope=None):
+  """Rotates the keypoints counter-clockwise by 90 degrees.
+
+  Args:
+    keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+    scope: name scope.
+
+  Returns:
+    new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+  """
+  with tf.name_scope(scope, 'Rot90'):
+    keypoints = tf.transpose(keypoints, [1, 0, 2])
+    v, u = tf.split(value=keypoints[:, :, ::-1], num_or_size_splits=2, axis=2)
+    v = 1.0 - v
+    new_keypoints = tf.concat([v, u], 2)
+    new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+    return new_keypoints
+
+
+def keypoint_weights_from_visibilities(keypoint_visibilities,
+                                       per_keypoint_weights=None):
+  """Returns a keypoint weights tensor.
+
+  During training, it is often beneficial to consider only those keypoints that
+  are labeled. This function returns a weights tensor that combines default
+  per-keypoint weights, as well as the visibilities of individual keypoints.
+
+  The returned tensor satisfies:
+  keypoint_weights[i, k] = per_keypoint_weights[k] * keypoint_visibilities[i, k]
+  where per_keypoint_weights[k] is set to 1 if not provided.
+
+  Args:
+    keypoint_visibilities: A [num_instances, num_keypoints] boolean tensor
+      indicating whether a keypoint is labeled (and perhaps even visible).
+    per_keypoint_weights: A list or 1-d tensor of length `num_keypoints` with
+      per-keypoint weights. If None, will use 1 for each visible keypoint
+      weight.
+
+  Returns:
+    A [num_instances, num_keypoints] float32 tensor with keypoint weights. Those
+    keypoints deemed visible will have the provided per-keypoint weight, and
+    all others will be set to zero.
+  """
+  if per_keypoint_weights is None:
+    num_keypoints = keypoint_visibilities.shape.as_list()[1]
+    per_keypoint_weight_mult = tf.ones((1, num_keypoints,), dtype=tf.float32)
+  else:
+    per_keypoint_weight_mult = tf.expand_dims(per_keypoint_weights, axis=0)
+  return per_keypoint_weight_mult * tf.cast(keypoint_visibilities, tf.float32)
+
+
+def set_keypoint_visibilities(keypoints, initial_keypoint_visibilities=None):
+  """Sets keypoint visibilities based on valid/invalid keypoints.
+
+  Some keypoint operations set invisible keypoints (e.g. cropped keypoints) to
+  NaN, without affecting any keypoint "visibility" variables. This function is
+  used to update (or create) keypoint visibilities to agree with visible /
+  invisible keypoint coordinates.
+
+  Args:
+    keypoints: a float32 tensor of shape [num_instances, num_keypoints, 2].
+    initial_keypoint_visibilities: a boolean tensor of shape
+      [num_instances, num_keypoints]. If provided, will maintain the visibility
+      designation of a keypoint, so long as the corresponding coordinates are
+      not NaN. If not provided, will create keypoint visibilities directly from
+      the values in `keypoints` (i.e. NaN coordinates map to False, otherwise
+      they map to True).
+
+  Returns:
+    keypoint_visibilities: a bool tensor of shape [num_instances, num_keypoints]
+    indicating whether a keypoint is visible or not.
+  """
+  if initial_keypoint_visibilities is not None:
+    keypoint_visibilities = tf.cast(initial_keypoint_visibilities, tf.bool)
+  else:
+    keypoint_visibilities = tf.ones_like(keypoints[:, :, 0], dtype=tf.bool)
+
+  keypoints_with_nan = tf.math.reduce_any(tf.math.is_nan(keypoints), axis=2)
+  keypoint_visibilities = tf.where(
+      keypoints_with_nan,
+      tf.zeros_like(keypoint_visibilities, dtype=tf.bool),
+      keypoint_visibilities)
+  return keypoint_visibilities

label_map_util.py

@@ -0,0 +1,166 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Label map utility functions."""
+
+import logging
+
+import tensorflow as tf
+from google.protobuf import text_format
+import string_int_label_map_pb2
+
+
+def _validate_label_map(label_map):
+  """Checks if a label map is valid.
+
+  Args:
+    label_map: StringIntLabelMap to validate.
+
+  Raises:
+    ValueError: if label map is invalid.
+  """
+  for item in label_map.item:
+    if item.id < 1:
+      raise ValueError('Label map ids should be >= 1.')
+
+
+def create_category_index(categories):
+  """Creates dictionary of COCO compatible categories keyed by category id.
+
+  Args:
+    categories: a list of dicts, each of which has the following keys:
+      'id': (required) an integer id uniquely identifying this category.
+      'name': (required) string representing category name
+        e.g., 'cat', 'dog', 'pizza'.
+
+  Returns:
+    category_index: a dict containing the same entries as categories, but keyed
+      by the 'id' field of each category.
+  """
+  category_index = {}
+  for cat in categories:
+    category_index[cat['id']] = cat
+  return category_index
+
+
+def convert_label_map_to_categories(label_map,
+                                    max_num_classes,
+                                    use_display_name=True):
+  """Loads label map proto and returns categories list compatible with eval.
+
+  This function loads a label map and returns a list of dicts, each of which
+  has the following keys:
+    'id': (required) an integer id uniquely identifying this category.
+    'name': (required) string representing category name
+      e.g., 'cat', 'dog', 'pizza'.
+  We only allow class into the list if its id-label_id_offset is
+  between 0 (inclusive) and max_num_classes (exclusive).
+  If there are several items mapping to the same id in the label map,
+  we will only keep the first one in the categories list.
+
+  Args:
+    label_map: a StringIntLabelMapProto or None.  If None, a default categories
+      list is created with max_num_classes categories.
+    max_num_classes: maximum number of (consecutive) label indices to include.
+    use_display_name: (boolean) choose whether to load 'display_name' field
+      as category name.  If False or if the display_name field does not exist,
+      uses 'name' field as category names instead.
+  Returns:
+    categories: a list of dictionaries representing all possible categories.
+  """
+  categories = []
+  list_of_ids_already_added = []
+  if not label_map:
+    label_id_offset = 1
+    for class_id in range(max_num_classes):
+      categories.append({
+          'id': class_id + label_id_offset,
+          'name': 'category_{}'.format(class_id + label_id_offset)
+      })
+    return categories
+  for item in label_map.item:
+    if not 0 < item.id <= max_num_classes:
+      logging.info('Ignore item %d since it falls outside of requested '
+                   'label range.', item.id)
+      continue
+    if use_display_name and item.HasField('display_name'):
+      name = item.display_name
+    else:
+      name = item.name
+    if item.id not in list_of_ids_already_added:
+      list_of_ids_already_added.append(item.id)
+      categories.append({'id': item.id, 'name': name})
+  return categories
+
+
+def load_labelmap(path):
+  """Loads label map proto.
+
+  Args:
+    path: path to StringIntLabelMap proto text file.
+  Returns:
+    a StringIntLabelMapProto
+  """
+  with tf.compat.v2.io.gfile.GFile(path, 'r') as fid:
+    label_map_string = fid.read()
+    label_map = string_int_label_map_pb2.StringIntLabelMap()
+    try:
+      text_format.Merge(label_map_string, label_map)
+    except text_format.ParseError:
+      label_map.ParseFromString(label_map_string)
+  _validate_label_map(label_map)
+  return label_map
+
+
+def get_label_map_dict(label_map_path, use_display_name=False):
+  """Reads a label map and returns a dictionary of label names to id.
+
+  Args:
+    label_map_path: path to label_map.
+    use_display_name: whether to use the label map items' display names as keys.
+
+  Returns:
+    A dictionary mapping label names to id.
+  """
+  label_map = load_labelmap(label_map_path)
+  label_map_dict = {}
+  for item in label_map.item:
+    if use_display_name:
+      label_map_dict[item.display_name] = item.id
+    else:
+      label_map_dict[item.name] = item.id
+  return label_map_dict
+
+
+def create_category_index_from_labelmap(label_map_path):
+  """Reads a label map and returns a category index.
+
+  Args:
+    label_map_path: Path to `StringIntLabelMap` proto text file.
+
+  Returns:
+    A category index, which is a dictionary that maps integer ids to dicts
+    containing categories, e.g.
+    {1: {'id': 1, 'name': 'dog'}, 2: {'id': 2, 'name': 'cat'}, ...}
+  """
+  label_map = load_labelmap(label_map_path)
+  max_num_classes = max(item.id for item in label_map.item)
+  categories = convert_label_map_to_categories(label_map, max_num_classes)
+  return create_category_index(categories)
+
+
+def create_class_agnostic_category_index():
+  """Creates a category index with a single `object` class."""
+  return {1: {'id': 1, 'name': 'object'}}

main.ipynb

@@ -0,0 +1,197 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "fb70944c",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'simplejson'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_23568/1068728291.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mflask\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mFlask\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrequest\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mResponse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0msimplejson\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mtensorflow\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mvisualization_utils\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mvis_util\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mPIL\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mImage\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'simplejson'"
+     ]
+    }
+   ],
+   "source": [
+    "from flask import Flask, request, Response\n",
+    "import simplejson\n",
+    "import tensorflow\n",
+    "import visualization_utils as vis_util\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import label_map_util\n",
+    "import tensorflow as tf\n",
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "import time\n",
+    "import cv2\n",
+    "from numpy import asarray\n",
+    "\n",
+    "# Creation of the Flask app\n",
+    "app = Flask(__name__)\n",
+    "# Flask route for Liveness checks\n",
+    "\n",
+    "\n",
+    "@app.route(\"/isalive\")\n",
+    "def isalive():\n",
+    "    print(\"/isalive request\")\n",
+    "    status_code = Response(status=200)\n",
+    "    return status_code\n",
+    "\n",
+    "\n",
+    "# Flask route for predictions\n",
+    "\n",
+    "\n",
+    "@app.route('/predict', methods=['GET', 'POST'])\n",
+    "def prediction():\n",
+    "    total_time_start = time.time()\n",
+    "\n",
+    "\n",
+    "    def loadImageIntoNumpyArray(image):\n",
+    "        (im_width, im_height) = image.size\n",
+    "        if image.getdata().mode == \"RGBA\":\n",
+    "            image = image.convert('RGB')\n",
+    "        return asarray(image).reshape((im_height, im_width, 3)).astype(np.uint8)\n",
+    "\n",
+    "    def main(image_path,model_path,model_PATH_TO_CKPT,path_to_labels):\n",
+    "        image = Image.open(image_path)\n",
+    "        image_np = loadImageIntoNumpyArray(image)\n",
+    "        image_np_expanded = np.expand_dims(image_np, axis=0)\n",
+    "        label_map = label_map_util.load_labelmap(path_to_labels)\n",
+    "    #     print(\"label_map------->\",type(label_map))\n",
+    "        categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=100, use_display_name=True)\n",
+    "        category_index = label_map_util.create_category_index(categories)\n",
+    "    #     print(\"category index-->\",category_index)\n",
+    "\n",
+    "        detection_graph = tf.Graph()\n",
+    "        with detection_graph.as_default():\n",
+    "            od_graph_def = tf.compat.v1.GraphDef()\n",
+    "            with tf.compat.v2.io.gfile.GFile(model_PATH_TO_CKPT, 'rb') as fid:\n",
+    "                serialized_graph = fid.read()\n",
+    "                od_graph_def.ParseFromString(serialized_graph)\n",
+    "                tf.import_graph_def(od_graph_def, name='')\n",
+    "        sess = tf.compat.v1.Session(graph=detection_graph)\n",
+    "        # Input tensor is the image\n",
+    "        image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')\n",
+    "        # Output tensors are the detection boxes, scores, and classes\n",
+    "        # Each box represents a part of the image where a particular object was detected\n",
+    "        detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')\n",
+    "        # Each score represents level of confidence for each of the objects.\n",
+    "        # The score is shown on the result image, together with the class label.\n",
+    "        detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')\n",
+    "        detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')\n",
+    "        # Number of objects detected\n",
+    "        num_detections = detection_graph.get_tensor_by_name('num_detections:0')\n",
+    "        (boxes, scores, classes, num) = sess.run(\n",
+    "            [detection_boxes, detection_scores, detection_classes, num_detections],\n",
+    "            feed_dict={image_tensor: image_np_expanded})\n",
+    "        vis_util.visualize_boxes_and_labels_on_image_array(\n",
+    "            image_np,\n",
+    "            np.squeeze(boxes),\n",
+    "            np.squeeze(classes).astype(np.int32),\n",
+    "            np.squeeze(scores),\n",
+    "            category_index,\n",
+    "            use_normalized_coordinates=True,\n",
+    "            line_thickness=8,\n",
+    "            min_score_thresh=0.1)\n",
+    "        %matplotlib inline\n",
+    "        from matplotlib import pyplot as plt\n",
+    "    #     print(\"boxes:\",boxes)\n",
+    "    #     print(\"class:\",classes)\n",
+    "        objects = []\n",
+    "        threshold = 0.5\n",
+    "    #     print(\"category:\",category_index)\n",
+    "        boxes = boxes[0]\n",
+    "        for index, value in enumerate(classes[0]):\n",
+    "            object_dict = {}\n",
+    "            if scores[0, index] > threshold:\n",
+    "                object_dict[\"class\"] = (category_index.get(value)).get('name')\n",
+    "                object_dict[\"score\"] = round(scores[0, index] * 100,2)\n",
+    "                box = tuple(boxes[index].tolist())\n",
+    "                ymin, xmin, ymax, xmax= box\n",
+    "                im_width,im_height = 360,360\n",
+    "                left, right, top, bottom = (xmin * im_width, xmax * im_width, \n",
+    "                                  ymin * im_height, ymax * im_height)\n",
+    "                object_dict[\"box\"] = (int(left), int(right), int(top), int(bottom))\n",
+    "                objects.append(object_dict)\n",
+    "\n",
+    "        image_orignal = Image.open(image_path)\n",
+    "        image_np_orignal = loadImageIntoNumpyArray(image_orignal)\n",
+    "\n",
+    "\n",
+    "        fig, ax = plt.subplots(1,2)\n",
+    "\n",
+    "        fig.suptitle('Tag Deciphering')\n",
+    "\n",
+    "        ax[0].imshow(image_np_orignal,aspect='auto');\n",
+    "        ax[1].imshow(image_np,aspect='auto');\n",
+    "\n",
+    "\n",
+    "        return objects\n",
+    "\n",
+    "    image_path = \"C://Users//thirdeye//Documents//ytag_gcp//test_images//33102340_20221005_1.JPG\"\n",
+    "    model_path = \"C://Users//thirdeye//Documents//ytag_gcp//ytag//yellow-black-28-may-22-inc-30-april-21\"\n",
+    "    model_PATH_TO_CKPT = model_path+\"//inference//frozen_inference_graph.pb\"\n",
+    "    path_to_labels = \"C://Users//thirdeye//Documents//ytag_gcp//ytag//tf_label_map.pbtxt\"\n",
+    "\n",
+    "    result = main(image_path,model_path,model_PATH_TO_CKPT,path_to_labels)\n",
+    "    # print(\"result-\",result)\n",
+    "    # list_to_be_sorted= [{'class': 'Y', 'score': 99.97, 'box': (157, 191, 269, 288)}, {'class': '6', 'score': 99.93, 'box': (158, 191, 247, 267)}, {'class': '9', 'score': 99.88, 'box': (156, 190, 179, 196)}, {'class': '4', 'score': 99.8, 'box': (156, 189, 198, 219)}, {'class': '1', 'score': 99.65, 'box': (157, 189, 222, 244)}, {'class': 'F', 'score': 63.4, 'box': (155, 185, 157, 175)}]\n",
+    "    newlist = sorted(result, key=lambda k: k['box'][3],reverse=False)\n",
+    "\n",
+    "    text =''\n",
+    "    for each in newlist:\n",
+    "        if(each['score']>65):\n",
+    "            text += each['class']\n",
+    "    # print(\"text:\",text)\n",
+    "    if(text!=\"\"):\n",
+    "        text = text.replace(\"yellowTag\", \"\") \n",
+    "        result = text\n",
+    "    else:\n",
+    "        result = \"No Vertical Tag Detected\"\n",
+    "    response = {\"predictions\": [result]}\n",
+    "    total_time_end = time.time()\n",
+    "    print(\"total time : \",round((total_time_end-total_time_start),2))\n",
+    "    return simplejson.dumps(response)\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    app.run(debug=True, host='0.0.0.0', port=8087)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7 (tags/v3.9.7:1016ef3, Aug 30 2021, 20:19:38) [MSC v.1929 64 bit (AMD64)]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "c58a6b68d966fd9b37abe1a881a7bc4a5fe187b07fe812e6c998975c787534e1"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}