import tensorflow as tf

# Read the graph.
with tf.gfile.FastGFile('dnn.pb') as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())

# Remove Const nodes.
for i in reversed(range(len(graph_def.node))):
    if graph_def.node[i].op == 'Const':
        del graph_def.node[i]
    for attr in ['T', 'data_format', 'Tshape', 'N', 'Tidx', 'Tdim',
                 'use_cudnn_on_gpu', 'Index', 'Tperm', 'is_training',
                 'Tpaddings']:
        if attr in graph_def.node[i].attr:
            del graph_def.node[i].attr[attr]

# Save as text.
tf.train.write_graph(graph_def, "", "dnn.pbtxt", as_text=True)

node {
  name: "MobilenetV1/Predictions/Reshape"
  op: "Reshape"
  input: "MobilenetV1/Logits/Conv2d_1c_1x1/biases"
  input: "MobilenetV1/Predictions/Reshape/shape"
}

onto:
node {
  name: "order"
  op: "Const"
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
        int_val: 1
        int_val: 2
        int_val: 3
      }
    }
  }
}
node {
  name: "transpose"
  op: "Transpose"
  input: "MobilenetV1/Logits/Conv2d_1c_1x1/BiasAdd"
  input: "order"
}
node {
  name: "MobilenetV1/Predictions/Reshape"
  op: "Reshape"
  input: "transpose"
  input: "MobilenetV1/Predictions/Reshape/shape"
}

import numpy as np
import tensorflow as tf
import time
import cv2 as cv

with tf.gfile.FastGFile('dnn.pb') as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())

img = cv.imread('b0.jpg')
img = cv.resize(img,(128,128))
#escala=1.0/255.0;
inp = cv.dnn.blobFromImage(img,1.0,(128,128),(127.5,127.5,127.5));
with tf.Session() as sess:
    sess.graph.as_default()
    tf.import_graph_def(graph_def, name='')
    for node in graph_def.node:
       print node.op, node.name

    #Generate input
    #np.random.seed(2701)
    #inp = np.random.standard_normal([1,128,128,3]).astype(np.float32)


    # Get output tensor
    outTensor = sess.graph.get_tensor_by_name('final_result:0')
    out = sess.run(outTensor, feed_dict={'input:0': inp.transpose(0,2,3,1)})

cvNet = cv.dnn.readNetFromTensorflow('dnn.pb','dnn.pbtxt')
cvNet.setInput(inp)
cvOut = cvNet.forward()
print cvOut,out
print np.max(np.abs(cvOut - out)) 	

int main(int argc, char* argv[]) {
	// These are the command-line flags the program can understand.
	// They define where the graph and input data is located, and what kind of
	// input the model expects. If you train your own model, or use something
	// other than inception_v3, then you'll need to update these.
	string image = "b0.jpg";
	string graph =
		"./models/dnn.pb";
	string labels =
		"./models/pics_labels.txt";
	int32 input_width = 128;
	int32 input_height = 128;
	int32 input_mean = 127.5;
	int32 input_std = 127.5;
	string input_layer = "input";
	string output_layer = "final_result";
	int32 self_test = 0;
	string root_dir = "";
	std::vector<Flag> flag_list = {
		Flag("image", &image, "image to be processed"),
		Flag("graph", &graph, "graph to be executed"),
		Flag("labels", &labels, "name of file containing labels"),
		Flag("input_width", &input_width, "resize image to this width in pixels"),
		Flag("input_height", &input_height,
		"resize image to this height in pixels"),
		Flag("input_mean", &input_mean, "scale pixel values to this mean"),
		Flag("input_std", &input_std, "scale pixel values to this std deviation"),
		Flag("input_layer", &input_layer, "name of input layer"),
		Flag("output_layer", &output_layer, "name of output layer"),
		Flag("self_test", &self_test, "run a self test"),
		Flag("root_dir", &root_dir,
		"interpret image and graph file names relative to this directory"),
	};
	string usage = tensorflow::Flags::Usage(argv[0], flag_list);
	const bool parse_result = tensorflow::Flags::Parse(&argc, argv, flag_list);
	if (!parse_result) {
		LOG(ERROR) << usage;
		return -1;
	}

	// We need to call this to set up global state for TensorFlow.
	tensorflow::port::InitMain(argv[0], &argc, &argv);
	if (argc > 1) {
		LOG(ERROR) << "Unknown argument " << argv[1] << "\n" << usage;
		return -1;
	}

	// First we load and initialize the model.
	std::unique_ptr<tensorflow::Session> session;
	string graph_path = tensorflow::io::JoinPath(root_dir, graph);
	Status load_graph_status = LoadGraph(graph_path, &session);
	if (!load_graph_status.ok()) {
		LOG(ERROR) << load_graph_status;
		return -1;
	}

	// Get the image from disk as a float array of numbers, resized and normalized
	// to the specifications the main graph expects.
	std::vector<Tensor> resized_tensors;
	string image_path = tensorflow::io::JoinPath(root_dir, image);
	Status read_tensor_status =
		ReadTensorFromImageFile(image_path, input_height, input_width, input_mean,
			input_std, &resized_tensors);
	if (!read_tensor_status.ok()) {
		LOG(ERROR) << read_tensor_status;
		return -1;
	}
	const Tensor& resized_tensor = resized_tensors[0];


	//std::cout << resized_tensors[0] <<std::endl;


	// Actually run the image through the model.
	std::vector<Tensor> outputs;
	Status run_status = session->Run({ { input_layer, resized_tensor } },
	{ output_layer }, {}, &outputs);
	if (!run_status.ok()) {
		LOG(ERROR) << "Running model failed: " << run_status;
		return -1;
	}

	// This is for automated testing to make sure we get the expected result with
	// the default settings. We know that label 653 (military uniform) should be
	// the top label for the Admiral Hopper image.
	if (self_test) {
		bool expected_matches;
		Status check_status = CheckTopLabel(outputs, 653, &expected_matches);
		if (!check_status.ok()) {
			LOG(ERROR) << "Running check failed: " << check_status;
			return -1;
		}
		if (!expected_matches) {
			LOG(ERROR) << "Self-test failed!";
			return -1;
		}
	}

	// Do something interesting with the results we've generated.
	Status print_status = PrintTopLabels(outputs, labels);
	if (!print_status.ok()) {
		LOG(ERROR) << "Running print failed: " << print_status;
		return -1;
	}

	return 0;
}