text: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  
  from scipy import misc
  import sys
  import os
  import argparse
  import tensorflow as tf
  import numpy as np
  # import facenet
  from facenet_recognition import facenet
  # import detect_face
  from facenet_recognition import detect_face
  import random
  from time import sleep
  from datetime import datetime
  os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
  
  
  def align_data(input_dir='./input_dir/', output_dir='./out_dir'):
      output_dir_path = output_dir
      output_dir = os.path.expanduser(output_dir_path)
      if not os.path.exists(output_dir):
              os.makedirs(output_dir)
      datadir = input_dir
      dataset = facenet.get_dataset(datadir)
      startTime = datetime.now()
      print('Creating networks and loading parameters')
      with tf.Graph().as_default():
          
  
  #        sess = tf.Session(config=tf.ConfigProto(log_device_placement=False))    #Removed gpu_options since commented out above
  #        with sess.as_default():
          pnet, rnet, onet = detect_face.create_mtcnn(None)   # From https://github.com/davidsandberg/facenet/issues/412
  
      minsize = 20  # minimum size of face
      threshold = [0.6, 0.7, 0.7]  # three steps's threshold
      factor = 0.709  # scale factor
      margin = 44
      image_size = 182
  
      # Add a random key to the filename to allow alignment using multiple processes
      random_key = np.random.randint(0, high=99999)
      bounding_boxes_filename = os.path.join(output_dir, 'bounding_boxes_%05d.txt' % random_key)
      print('Goodluck')
  
      with open(bounding_boxes_filename, "w") as text_file:
          nrof_images_total = 0
          nrof_successfully_aligned = 0
          for cls in dataset:
              output_class_dir = os.path.join(output_dir, cls.name)
              if not os.path.exists(output_class_dir):
                  os.makedirs(output_class_dir)
              for image_path in cls.image_paths:
                  nrof_images_total += 1
                  filename = os.path.splitext(os.path.split(image_path)[1])[0]
                  output_filename = os.path.join(output_class_dir, filename + '.png')
                  print(image_path)
                  if not os.path.exists(output_filename):
                      try:
                          img = misc.imread(image_path)
                          print('read data dimension: ', img.ndim)
                      except (IOError, ValueError, IndexError) as e:
                          errorMessage = '{}: {}'.format(image_path, e)
                          print(errorMessage)
                      else:
                          if img.ndim < 2:
                              print('Unable to align "%s"' % image_path)
                              # text_file.write('%s\n' % (output_filename))
                              continue
                          if img.ndim == 2:
                              img = facenet.to_rgb(img)
                              print('to_rgb data dimension: ', img.ndim)
                          img = img[:, :, 0:3]
                          print('after data dimension: ', img.ndim)
  
                          bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)
                          nrof_faces = bounding_boxes.shape[0]
                          print('detected_face: %d' % nrof_faces)
                          if nrof_faces > 0:
                              det = bounding_boxes[:, 0:4]
                              img_size = np.asarray(img.shape)[0:2]
                              if nrof_faces > 1:
                                  bounding_box_size = (det[:, 2] - det[:, 0]) * (det[:, 3] - det[:, 1])
                                  img_center = img_size / 2
                                  offsets = np.vstack([(det[:, 0] + det[:, 2]) / 2 - img_center[1],
                                                       (det[:, 1] + det[:, 3]) / 2 - img_center[0]])
                                  offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
                                  index = np.argmax(bounding_box_size - offset_dist_squared * 2.0)  # some extra weight on the centering
                                  det = det[index, :]
                              det = np.squeeze(det)
                              bb_temp = np.zeros(4, dtype=np.int32)
  
                              bb_temp[0] = det[0]
                              bb_temp[1] = det[1]
                              bb_temp[2] = det[2]
                              bb_temp[3] = det[3]
                              try:
                                  cropped_temp = img[bb_temp[1]:bb_temp[3], bb_temp[0]:bb_temp[2], :]
                                  scaled_temp = misc.imresize(cropped_temp, (image_size, image_size), interp='bilinear')
                                  nrof_successfully_aligned += 1
                                  misc.imsave(output_filename, scaled_temp)
                              # text_file.write('%s %d %d %d %d\n' % (output_filename, bb_temp[0], bb_temp[1], bb_temp[2], bb_temp[3]))
                              except Exception as e:
                                  os.remove(image_path)
                                  
                             
                          else:
                              print('Unable to align "%s"' % image_path)
                              os.remove(image_path)
                              print('removed file %s' % image_path)
                              # text_file.write('%s\n' % (output_filename))
      print('Total number of images: %d' % nrof_images_total)
      print('Number of successfully aligned images: %d' % nrof_successfully_aligned)
      os.remove(bounding_boxes_filename)
      print(datetime.now() - startTime) 
      
  # align_data('/Users/ishwarsawale/working_demos/face_rec_demo/input_dir',
  # '/Users/ishwarsawale/working_demos/face_rec_demo/out_dir')
  