def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
runs_dir = 'RUNS'
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
logging.info("Evaluating on Validation data.")
logdir = os.path.join(runs_dir, FLAGS.RUN)
# logging.info("Output images will be saved to {}".format)
ana.do_analyze(logdir)
logging.info("Creating output on test data.")
kitti_test.do_inference(logdir)
logging.info("Analysis for pretrained model complete.")
logging.info("For evaluating your own models I recommend using:"
"`tv-analyze --logdir /path/to/run`.")
logging.info("tv-analysis has a much cleaner interface.")
def main(_):
utils.set_gpus_to_use()
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
logging.info("Start finetuning")
do_finetuning(hypes)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
#utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiBox')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
#train.maybe_download_and_extract(hypes)
logging.info("Start training")
train.do_training(hypes)
def main(_):
utils.set_gpus_to_use()
if tf.app.flags.FLAGS.logdir is None:
logging.error("No logdir is given.")
logging.info("Usage: python train.py --logdir rundir")
exit(1)
logging.info("Continuing training...")
train.continue_training(tf.app.flags.FLAGS.logdir)
def main(_):
"""Run main function."""
if FLAGS.logdir is None:
logging.error("No logdir is given.")
logging.error("Usage: tv-analyze --logdir dir")
exit(1)
utils.set_gpus_to_use()
utils.load_plugins()
logging.info("Starting to analyze model in '%s'", FLAGS.logdir)
do_analyze(FLAGS.logdir)
def main(_):
tv_utils.set_gpus_to_use()
runs_dir = 'RUNS'
logdir = os.path.join(runs_dir, default_run)
# Loading hyperparameters from logdir
hypes_i = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
print("Info: Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
print("Info: Modules loaded successfully. Starting to build tf graph.")
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl_i = tf.placeholder(tf.float32)
image = tf.expand_dims(image_pl_i, 0)
# build Tensorflow graph using the model from logdir
prediction_i = core.build_inference_graph(hypes_i,
modules,
image=image)
print("Info: Graph build successfully.")
# Create a session for running Ops on the Graph.
sess_i = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess_i, saver)
print("Info: Weights loaded successfully.")
# input_image = "DATA/demo/demo.png"
# print("Info: Starting inference using {} as input".format(input_image))
global hypes
hypes = hypes_i
global image_pl
image_pl = image_pl_i
global prediction
prediction = prediction_i
global sess
sess = sess_i
from moviepy.editor import VideoFileClip
myclip = VideoFileClip('project_video.mp4') #.subclip(40,43)
output_vid = 'output.mp4'
clip = myclip.fl_image(inference)
clip.write_videofile(output_vid, audio=False)
def main(_):
tv_utils.set_gpus_to_use()
if FLAGS.logdir is None:
# Download and use weights from the MultiNet Paper
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
else:
runs_dir = 'RUNS'
maybe_download_and_extract(runs_dir)
logdir = os.path.join(runs_dir, default_run)
else:
logging.info("Using weights found in {}".format(FLAGS.logdir))
logdir = FLAGS.logdir
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32)
image = tf.expand_dims(image_pl, 0)
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules,
image=image)
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
input_image = FLAGS.input_image
#logging.info("Starting inference using {} as input".format(input_image))
print("Tensorflow model initialized.")
#ros node class
path_detect = PathDetect(hypes, sess, image_pl, prediction)
rospy.spin()
def main(_):
utils.set_gpus_to_use()
load_weights = tf.app.flags.FLAGS.logdir is not None
if not load_weights:
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'MultiNet')
# with tf.Session() as sess:
# king
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True,
log_device_placement=True)) as sess:
if not load_weights:
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
# Build united Model
subhypes, submodules, subgraph, tv_sess = build_united_model(hypes)
start_step = 0
else:
logdir = tf.app.flags.FLAGS.logdir
logging_file = os.path.join(logdir, "output.log")
utils.create_filewrite_handler(logging_file, mode='a')
hypes, subhypes, submodules, subgraph, tv_sess, start_step = \
load_united_model(logdir)
if start_step is None:
start_step = 0
# Run united training
run_united_training(hypes,
subhypes,
submodules,
subgraph,
tv_sess,
start_step=start_step)
# stopping input Threads
tv_sess['coord'].request_stop()
tv_sess['coord'].join(tv_sess['threads'])
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
hypes['dist'] = FLAGS.dist
if FLAGS.layers:
hypes['arch']['layers'] = FLAGS.layers
if FLAGS.lr:
hypes['solver']['learning_rate'] = FLAGS.lr
if FLAGS.optimizer:
hypes['solver']['opt'] = FLAGS.optimizer
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
train.do_training(hypes)
def main(_):
utils.set_gpus_to_use()
sys.path.append("submodules/tensorflow-fcn")
sys.path.append("submodules/TensorVision")
import tensorvision.train
import tensorflow_fcn.utils
# try:
# import tensorvision.train
# import tensorflow_fcn.utils
# except ImportError:
# logging.error("Could not import the submodules.")
# logging.error("Please execute:"
# "'git submodule update --init --recursive'")
# exit(1)
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
logging.info("Start training")
train.do_training(hypes)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
logging.info("Start training")
encoder_path = hypes['model']['architecture_file']
hypes['model']['architecture_file'] = '../encoder/stub.py'
hypes['ga_data'] = 'ga_data.json'
run_genetic_algorithm(hypes, encoder_path)
def main(_):
tv_utils.set_gpus_to_use()
# Download and use weights from the MultiNet Paper
runs_dir = '.'
logdir = os.path.join(runs_dir, default_run)
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32, name='input_image')
image = tf.expand_dims(image_pl, 0)
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules,
image=image)
tf.identity(prediction['logits'], name='output_logits')
tf.identity(prediction['softmax'], name='output_softmax')
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
# Save model again with renamed tensors
saver.save(sess, 'renamed/KittiSeg_pretrained')
logging.info("Model saved successfully.")
def main(_):
utils.set_gpus_to_use()
# try:
# import tensorvision.train
# import tensorflow_fcn.utils
# except ImportError:
# logging.error("Could not import the submodules.")
# logging.error("Please execute:"
# "'git submodule update --init --recursive'")
# exit(1)
if tf.app.flags.FLAGS.logdir is None:
logging.error("No logdir is given.")
logging.info("Usage: python train.py --logdir dir")
exit(1)
logging.info("Continuing training...")
train.continue_training(tf.app.flags.FLAGS.logdir)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
else:
runs_dir = 'RUNS'
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
maybe_download_and_extract(runs_dir)
logging.info("Evaluating on Validation data.")
logdir = os.path.join(runs_dir, FLAGS.RUN)
# logging.info("Output images will be saved to {}".format)
ana.do_analyze(logdir)
logging.info("Creating output on test data.")
kitti_test.do_inference(logdir)
logging.info("Analysis for pretrained model complete.")
logging.info("For evaluating your own models I recommend using:"
"`tv-analyze --logdir /path/to/run`.")
logging.info("tv-analysis has a much cleaner interface.")
def main(_):
"""Run main function."""
if FLAGS.hypes is None:
logging.error("No hypes are given.")
logging.error("Usage: tv-train --hypes hypes.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.set_gpus_to_use()
utils.load_plugins()
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
logging.info("Initialize training folder")
initialize_training_folder(hypes)
maybe_download_and_extract(hypes)
logging.info("Start training")
do_training(hypes)
def main(_):
utils.set_gpus_to_use()
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'MediSeg')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Start training")
train.do_training(hypes)
def main(_):
"""Run main function."""
if FLAGS.hypes is None:
logging.error("No hypes are given.")
logging.error("Usage: tv-train --hypes hypes.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.set_gpus_to_use()
utils.load_plugins()
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
logging.info("Initialize training folder")
initialize_training_folder(hypes)
maybe_download_and_extract(hypes)
logging.info("Start training")
do_training(hypes)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
os.environ["TV_DIR_DATA"] = "../../SemSeg_DATA/DATA"
os.environ["TV_DIR_RUNS"] = "../../SemSeg_DATA/RUNS"
# print(os.environ["TV_DIR_DATA"])
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
logging.info("Start training")
train.do_training(hypes)
def main(_):
"""Run main function."""
if FLAGS.hypes is None:
logging.error("No hypes are given.")
logging.error("Usage: python train.py --hypes hypes.json")
logging.error(" tf: tv-train --hypes hypes.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
logging.info(
"Initializing GPUs, plugins and creating the essential folders")
utils.set_gpus_to_use()
utils.load_plugins()
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
initialize_training_folder(hypes)
logging.info("Training settings")
do_training(hypes)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'KittiBox')
else:
runs_dir = 'RUNS'
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
maybe_download_and_extract(runs_dir)
logging.info("Evaluating on Validation data.")
logdir = os.path.join(runs_dir, FLAGS.RUN)
# logging.info("Output images will be saved to {}".format)
ana.do_analyze(logdir, base_path='hypes')
logging.info("Analysis for pretrained model complete.")
logging.info("For evaluating your own models I recommend using:"
"`tv-analyze --logdir /path/to/run`.")
logging.info("")
logging.info(
"Output images can be found in {}/analyse/images.".format(logdir))
def main(_):
utils.set_gpus_to_use()
load_weights = tf.app.flags.FLAGS.logdir is not None
if not load_weights:
print("You must specify --logdir path/to/trained/model")
exit(1)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'MultiNet')
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1)
config = tf.ConfigProto(gpu_options=gpu_options)
with tf.Session(config=config) as sess:
logdir = tf.app.flags.FLAGS.logdir
logging_file = os.path.join(logdir, "output.log")
utils.create_filewrite_handler(logging_file, mode='a')
hypes, subhypes, submodules, subgraph, tv_sess, start_step = load_united_model(
logdir)
if start_step is None:
start_step = 0
# Run united training
run_united_evaluation(hypes,
subhypes,
submodules,
subgraph,
tv_sess,
step=start_step)
# stopping input Threads
tv_sess['coord'].request_stop()
tv_sess['coord'].join(tv_sess['threads'])
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
logging.info("Start training")
train.do_training(hypes)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
if tf.app.flags.FLAGS.hypes is None:
logging.error("No hype file is given.")
logging.info("Usage: python train.py --hypes hypes/KittiClass.json")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
utils.load_plugins()
if tf.app.flags.FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(tf.app.flags.FLAGS.mod)
dict_merge(hypes, mod_dict)
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'KittiSeg')
else:
runs_dir = 'RUNS'
logdir = os.path.join(runs_dir, FLAGS.RUN)
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.continue_training(logdir)
def main(_):
utils.set_gpus_to_use()
logdir = FLAGS.logdir
data_file = FLAGS.data
#if input is not given pass the error message
if logdir is None:
logging.error('Usage python predict_joint --logdir /path/to/logdir'
'--data /path/to/data/txt')
exit(1)
output_folder = os.path.join(logdir, res_folder)
if not os.path.exists(output_folder):
os.mkdir(output_folder)
logdir = logdir
utils.load_plugins()
#if data directory exist, join the path
if 'TV_DIR_DATA' in os.environ:
data_file = os.path.join(os.environ['TV_DIR_DATA'], data_file)
else:
#else create a directory DATA
data_file = os.path.join('DATA', data_file)
if not os.path.exists(data_file):
logging.error('Please provide a valid data_file.')
logging.error('Use --data_file')
exit(1)
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'UnitedVision2')
logging_file = os.path.join(output_folder, "analysis.log") #log file
utils.create_filewrite_handler(logging_file, mode='a')
load_out = load_united_model(logdir)
run_eval(load_out, output_folder, data_file)
def load(logdir):
import tensorflow as tf
import tensorvision.utils as tv_utils
import tensorvision.core as core
tv_utils.set_gpus_to_use()
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32,
shape=(hypes["image_height"],
hypes["image_width"], 3))
image = tf.expand_dims(image_pl, 0)
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules, image=image)
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
return image_pl, prediction, sess, hypes
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train2
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
os.environ['TV_DIR_RUNS'] = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiBox')
if FLAGS.logdir is None:
print(" Download and use weights from the MultiNet Paper")
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'KittiBox')
else:
runs_dir = 'RUNS'
maybe_download_and_extract(runs_dir)
logdir = os.path.join(runs_dir, default_run)
else:
logging.info("Using weights found in {}".format(FLAGS.logdir))
logdir = FLAGS.logdir
print("----------------")
print(logdir)
hypes = utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Start training")
print(logdir)
train.continue_training(logdir)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
logging.error("Please execute:"
"'git submodule update --init --recursive'")
exit(1)
hypes_path = FLAGS.logdir
hypes_path = os.path.join(hypes_path, "model_files/hypes.json")
with open(hypes_path, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'FacadeSeg')
else:
runs_dir = 'RUNS'
utils.set_dirs(hypes, FLAGS.hypes)
utils._add_paths_to_sys(hypes)
logging.info("Evaluating on Validation data.")
ana.do_analyze(FLAGS.logdir)
logging.info("Segmenting and test data. Creating output.")
ana.do_inference(FLAGS.logdir)
logging.info("Analysis for pretrained model complete.")
def main(_):
logging.info(
"Initializing GPUs, plugins and creating the essential folders")
utils.set_gpus_to_use()
if FLAGS.hypes is None:
logging.error("No hypes are given.")
logging.error("Usage: python train.py --hypes hypes.json")
logging.error(" tf: tv-train --hypes hypes.json")
exit(1)
with open(FLAGS.hypes) as f:
logging.info("f: %s", f)
hypes = commentjson.load(f)
if FLAGS.mod is not None:
import ast
mod_dict = ast.literal_eval(FLAGS.mod)
dict_merge(hypes, mod_dict)
logging.info("Loading plugins")
utils.load_plugins()
logging.info("Set dirs")
utils.set_dirs(hypes, FLAGS.hypes)
logging.info("Add paths to sys")
utils._add_paths_to_sys(hypes)
logging.info("Initialize training folder")
train.initialize_training_folder(hypes)
tf.reset_default_graph()
logging.info("Start training")
train.do_training(hypes)
def main(_):
utils.set_gpus_to_use()
try:
import tensorvision.train
import tensorflow_fcn.utils
except ImportError:
logging.error("Could not import the submodules.")
exit(1)
with open(tf.app.flags.FLAGS.hypes, 'r') as f:
logging.info("f: %s", f)
hypes = json.load(f)
utils.load_plugins()
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'VOCSeg')
else:
runs_dir = 'RUNS'
utils.set_dirs(hypes, tf.app.flags.FLAGS.hypes)
utils._add_paths_to_sys(hypes)
train.maybe_download_and_extract(hypes)
maybe_download_and_extract(runs_dir, "VOCSeg_2017_04_14_00.49")
logging.info("Evaluating on Validation data.")
logdir = os.path.join(runs_dir, "VOCSeg_2017_04_14_00.49")
# logging.info("Output images will be saved to {}".format)
# ana.do_analyze(logdir)
logging.info("Creating output on test data.")
voc_test.do_inference(logdir)
logging.info("Analysis for pretrained model complete.")
def main(_):
tv_utils.set_gpus_to_use()
if FLAGS.input_image is None:
logging.error("No input_image was given.")
logging.info(
"Usage: python demo.py --input_image data/test.png "
"[--output_image output_image] [--logdir /path/to/weights] "
"[--gpus GPUs_to_use] ")
exit(1)
if FLAGS.logdir is None:
# Download and use weights from the MultiNet Paper
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
else:
runs_dir = 'RUNS'
maybe_download_and_extract(runs_dir)
logdir = os.path.join(runs_dir, default_run)
else:
logging.info("Using weights found in {}".format(FLAGS.logdir))
logdir = FLAGS.logdir
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32)
image = tf.expand_dims(image_pl, 0)
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules,
image=image)
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
input_image = FLAGS.input_image
logging.info("Starting inference using {} as input".format(input_image))
# Load and resize input image
image = scp.misc.imread(input_image)
if hypes['jitter']['reseize_image']:
# Resize input only, if specified in hypes
image_height = hypes['jitter']['image_height']
image_width = hypes['jitter']['image_width']
image = scp.misc.imresize(image, size=(image_height, image_width),
interp='cubic')
# Run KittiSeg model on image
feed = {image_pl: image}
softmax = prediction['softmax']
output = sess.run([softmax], feed_dict=feed)
# Reshape output from flat vector to 2D Image
shape = image.shape
output_image = output[0][:, 1].reshape(shape[0], shape[1])
# Plot confidences as red-blue overlay
rb_image = seg.make_overlay(image, output_image)
# Accept all pixel with conf >= 0.5 as positive prediction
# This creates a `hard` prediction result for class street
threshold = 0.5
street_prediction = output_image > threshold
# Plot the hard prediction as green overlay
green_image = tv_utils.fast_overlay(image, street_prediction)
# Save output images to disk.
if FLAGS.output_image is None:
output_base_name = input_image
else:
output_base_name = FLAGS.output_image
raw_image_name = output_base_name.split('.')[0] + '_raw.png'
rb_image_name = output_base_name.split('.')[0] + '_rb.png'
green_image_name = output_base_name.split('.')[0] + '_green.png'
scp.misc.imsave(raw_image_name, output_image)
scp.misc.imsave(rb_image_name, rb_image)
scp.misc.imsave(green_image_name, green_image)
logging.info("")
logging.info("Raw output image has been saved to: {}".format(
os.path.realpath(raw_image_name)))
logging.info("Red-Blue overlay of confs have been saved to: {}".format(
os.path.realpath(rb_image_name)))
logging.info("Green plot of predictions have been saved to: {}".format(
os.path.realpath(green_image_name)))
logging.info("")
logging.warning("Do NOT use this Code to evaluate multiple images.")
logging.warning("Demo.py is **very slow** and designed "
"to be a tutorial to show how the KittiSeg works.")
logging.warning("")
logging.warning("Please see this comment, if you like to apply demo.py to"
"multiple images see:")
logging.warning("https://github.com/MarvinTeichmann/KittiBox/"
"issues/15#issuecomment-301800058")
def main(_):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
# config.gpu_options.per_process_gpu_memory_fraction = 0.7
tv_utils.set_gpus_to_use()
if FLAGS.input_image is None:
logging.error("No input_image was given.")
logging.info(
"Usage: python demo.py --input_image data/test.png "
"[--output_image output_image] [--logdir /path/to/weights] "
"[--gpus GPUs_to_use] ")
if FLAGS.logdir is None:
# Download and use weights from the MultiNet Paper
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'],
'KittiSeg')
else:
runs_dir = 'RUNS'
maybe_download_and_extract(runs_dir)
logdir = os.path.join(runs_dir, default_run)
else:
logging.info("Using weights found in {}".format(FLAGS.logdir))
logdir = FLAGS.logdir
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
num_classes = 5
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32)
image = tf.expand_dims(image_pl, 0)
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules,
image=image)
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session(config=config)
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
input_image = FLAGS.input_image
logging.info("Starting inference using {} as input".format(input_image))
#Dealing with video segmentation with frame by frame
#TODO: build a commandline
loaded_video = skvideo.io.vread('t1.avi')[:100]
writer = skvideo.io.FFmpegWriter("outputvideo.avi")
for image in loaded_video:
# Load and resize input image
if hypes['jitter']['reseize_image']:
# Resize input only, if specified in hypes
image_height = hypes['jitter']['image_height']
image_width = hypes['jitter']['image_width']
image = scp.misc.imresize(image, size=(image_height, image_width),
interp='cubic')
# Run KittiSeg model on image
feed = {image_pl: image}
softmax = prediction['softmax']
output = sess.run(softmax, feed_dict=feed)
print(len(output), type(output), output.shape)
# Reshape output from flat vector to 2D Image
output = np.transpose(output)
shape = image.shape
output = output.reshape(num_classes, shape[0], shape[1])
output_image = output[0].reshape(shape[0], shape[1])
# Plot confidences as red-blue overlay
rb_image = seg.make_overlay(image, output_image)
# Accept all pixel with conf >= 0.5 as positive prediction
# This creates a `hard` prediction result for class street
threshold = 0.5
street_prediction = output_image > threshold
street_predictions = output > threshold
# Plot the hard prediction as green overlay
green_image = tv_utils.fast_overlay(image, street_prediction)
green_images = []
rb_images = []
output_images = []
for c in range(0,5):
green_images.append(tv_utils.fast_overlay(image, street_predictions[c]))
rb_images.append(seg.make_overlay(image, output[c]))
output_images.append(output[c].reshape(shape[0], shape[1]))
# Save output images to disk.
if FLAGS.output_image is None:
output_base_name = input_image
else:
output_base_name = FLAGS.output_image
#Name and save the the red blue segmentation for first 5 frames as png to debug.
green_image_names = []
rb_image_names = []
raw_image_names = []
for c in range(1,6):
green_image_names.append(output_base_name.split('.')[0] + str(c) + '_green.png')
rb_image_names.append(output_base_name.split('.')[0] + str(c) + '_rb.png')
raw_image_names.append(output_base_name.split('.')[0] + str(c) + '_raw.png')
for c in range(0,5):
print(green_image_names[c], green_images[c].shape)
scp.misc.imsave(raw_image_names[c], output_images[c])
scp.misc.imsave(rb_image_names[c], rb_images[c])
scp.misc.imsave(green_image_names[c], green_images[c])
#Output the green masked video as a file and show it to screen
writer.writeFrame(green_images[4])
cv2.imshow('frame', green_images[4])
#user can press p to quit during processing.
if cv2.waitKey(1) & 0xFF == ord('q'):
break
writer.close()
def main(_):
tv_utils.set_gpus_to_use()
# if FLAGS.input_image is None:
# logging.error("No input_image was given.")
# logging.info(
# "Usage: python demo.py --input_image data/test.png "
# "[--output_image output_image] [--logdir /path/to/weights] "
# "[--gpus GPUs_to_use] ")
# exit(1)
if FLAGS.logdir is None:
# Download and use weights from the MultiNet Paper
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'KittiSeg')
else:
runs_dir = 'RUNS'
maybe_download_and_extract(runs_dir)
logdir = os.path.join(runs_dir, default_run)
else:
logging.info("Using weights found in {}".format(FLAGS.logdir))
logdir = FLAGS.logdir
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32)
image = tf.expand_dims(image_pl, 0)
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules, image=image)
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
dataset = kitti_object(
os.path.join(ROOT_DIR, 'free-space/dataset/KITTI/object'))
point_pub = rospy.Publisher('cloud', PointCloud2, queue_size=50)
# picture_pub = rospy.Publisher("kitti_image",newImage,queue_size=50)
rospy.init_node('point-cloud', anonymous=True)
# h = std_msgs.msg.Header()
# h.frame_id="base_link"
# h.stamp=rospy.Time.now()
#rate = rospy.Rate(10)
#point_msg=PointCloud2()
video_dir = '/home/user/Data/lrx_work/free-space/kitti.avi'
fps = 10
num = 4541
img_size = (1241, 376)
fourcc = 'mp4v'
videoWriter = cv2.VideoWriter(video_dir, cv2.VideoWriter_fourcc(*fourcc),
fps, img_size)
calib = dataset.get_calibration(0)
for data_idx in range(len(dataset)):
#objects = dataset.get_label_objects(data_idx)
# Load and resize input image
image = dataset.get_image(data_idx)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#scp.misc.imsave('new.png', image)
if hypes['jitter']['reseize_image']:
# Resize input only, if specified in hypes
image_height = hypes['jitter']['image_height']
image_width = hypes['jitter']['image_width']
image = scp.misc.imresize(image,
size=(image_height, image_width),
interp='cubic')
img_height, img_width, img_channel = image.shape
print("picture-shape")
print(len(image))
print(len(image[0]))
pc_velo = dataset.get_lidar(data_idx)[:, 0:3]
print(len(pc_velo))
velo_len = len(pc_velo)
#calib = dataset.get_calibration(data_idx)
# Run KittiSeg model on image
feed = {image_pl: image}
softmax = prediction['softmax']
output = sess.run([softmax], feed_dict=feed)
# Reshape output from flat vector to 2D Image
shape = image.shape
output_image = output[0][:, 1].reshape(shape[0], shape[1])
# Plot confidences as red-blue overlay
rb_image = seg.make_overlay(image, output_image)
# scp.misc.imsave('new0.png', rb_image)
# Accept all pixel with conf >= 0.5 as positive prediction
# This creates a `hard` prediction result for class street
threshold = 0.5
street_prediction = output_image > threshold
index = np.where(street_prediction == True)
chang = len(index[0])
print(chang)
# test = np.zeros((velo_len,2),dtype=np.int)
# for tmp0 in range(chang):
# test[tmp0][0]=index[0][tmp0]
# test[tmp0][1]=index[1][tmp0]
print("suoyindayin")
# if (chang>0):
# print(test[0][0])
# print(test[0][1])
pts_2d = calib.project_velo_to_image(pc_velo)
print(pts_2d.shape)
# print(pts_2d[1][0])
# print(pts_2d[1][1])
fig = mlab.figure(figure=None,
bgcolor=(0, 0, 0),
fgcolor=None,
engine=None,
size=(1000, 500))
fov_inds = (pts_2d[:,0]<1242) & (pts_2d[:,0]>=0) & \
(pts_2d[:,1]<370) & (pts_2d[:,1]>=0)
print(fov_inds.shape)
# print(fov_inds[1000])
# print(pc_velo.shape)
print("okok")
fov_inds = fov_inds & (pc_velo[:, 0] > 0)
print(fov_inds.shape)
imgfov_pts_2d = pts_2d[fov_inds, :]
imgfov_pc_velo = pc_velo[fov_inds, :]
pts_2d0 = calib.project_velo_to_image(imgfov_pc_velo)
fov_inds0 = (pts_2d0[:,0]<len(image[0])) & (pts_2d0[:,0]>=0) & \
(pts_2d0[:,1]<len(image)) & (pts_2d0[:,1]>=0)
fov_inds0 = fov_inds0 & (imgfov_pc_velo[:, 0] > 2.0)
print(fov_inds0.shape)
print(street_prediction.shape)
print(pts_2d0.shape)
# if(chang>0):
# print(int(imgfov_pts_2d[5,0]))
# print(int(imgfov_pts_2d[5,1]))
# print(street_prediction[int(imgfov_pts_2d[5,1]),int(imgfov_pts_2d[5,0])])
if (chang > 0):
for i in range(len(fov_inds0)):
if ((pts_2d0[i, 1] < len(street_prediction)) &
(pts_2d0[i, 0] < len(street_prediction[0]))):
fov_inds0[i] = fov_inds0[i] & (
street_prediction[int(pts_2d0[i, 1]),
int(pts_2d0[i, 0])] == True)
imgfov_pc_velo0 = imgfov_pc_velo[fov_inds0, :]
print("number")
green_image = tv_utils.fast_overlay(image, street_prediction)
# pub point-cloud topic
print(imgfov_pc_velo0.shape)
number = len(imgfov_pc_velo0)
header = std_msgs.msg.Header()
header.stamp = rospy.Time.now()
header.frame_id = "velodyne"
points = pc2.create_cloud_xyz32(header, imgfov_pc_velo0)
# point=Point()
# for t in range(0,number):
# point_x=imgfov_pc_velo0[t][0]
# point_y=imgfov_pc_velo0[t][1]
# point_z=imgfov_pc_velo0[t][2]
# point_msg.points[t].point.x=point_x
# point_msg.points[t].point.y=point_y
# point_msg.points[t].point.z=point_z
# point_pub.publish(points)
# videoWriter.write(green_image)
# bridge=CvBridge()
# picture_pub.publish(bridge.cv2_to_imgmsg(green_image,"rgb8"))
# minx=imgfov_pc_velo0[0][0]
# miny=imgfov_pc_velo0[0][1]
# minz=imgfov_pc_velo0[0][2]
# maxx=imgfov_pc_velo0[0][0]
# maxy=imgfov_pc_velo0[0][1]
# maxz=imgfov_pc_velo0[0][2]
# for t in range(len(imgfov_pc_velo0)):
# minx=min(minx,imgfov_pc_velo0[t][0])
# miny=min(miny,imgfov_pc_velo0[t][1])
# minz=min(minz,imgfov_pc_velo0[t][2])
# maxx=max(maxx,imgfov_pc_velo0[t][0])
# maxy=max(maxy,imgfov_pc_velo0[t][1])
# maxz=max(maxz,imgfov_pc_velo0[t][2])
# print(minx,miny,minz,maxx,maxy,maxz)
# width=1024
# height=1024
# img_res=np.zeros([width,height,3],dtype=np.uint8)
# for p in range(len(imgfov_pc_velo0)):
# velo_x=5*(int(imgfov_pc_velo0[p][0])+50)
# velo_y=5*(int(imgfov_pc_velo0[p][1])+50)
# img_res[velo_x][velo_y]=255
# scale=25
# if((velo_x>scale)&(velo_x+scale<1024)&(velo_y>scale)&(velo_y+scale<1024)):
# for q in range(scale):
# for m in range(scale):
# img_res[velo_x-q][velo_y-m]=255
# img_res[velo_x-q][velo_y+m]=255
# img_res[velo_x+q][velo_y-m]=255
# img_res[velo_x+q][velo_y+m]=255
# scp.misc.imsave('res.png',img_res)
draw_lidar(imgfov_pc_velo0, fig=fig)
# for obj in objects:
# if obj.type == 'DontCare': continue
# # Draw 3d bounding box
# box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
# box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
# # Draw heading arrow
# ori3d_pts_2d, ori3d_pts_3d = utils.compute_orientation_3d(obj, calib.P)
# ori3d_pts_3d_velo = calib.project_rect_to_velo(ori3d_pts_3d)
# x1, y1, z1 = ori3d_pts_3d_velo[0, :]
# x2, y2, z2 = ori3d_pts_3d_velo[1, :]
# draw_gt_boxes3d([box3d_pts_3d_velo], fig=fig)
# mlab.plot3d([x1, x2], [y1, y2], [z1, z2], color=(0.5, 0.5, 0.5),
# tube_radius=None, line_width=1, figure=fig)
#mlab.show(1)
# Plot the hard prediction as green overlay
# Save output images to disk.
if FLAGS.output_image is None:
output_base_name = image
else:
output_base_name = FLAGS.output_image
# raw_image_name = output_base_name.split('.')[0] + '_raw.png'
# rb_image_name = output_base_name.split('.')[0] + '_rb.png'
# green_image_name = output_base_name.split('.')[0] + '_green.png'
# scp.misc.imsave('1.png', output_image)
# scp.misc.imsave('2.png', rb_image)
# scp.misc.imsave('3.png', green_image)
raw_input()
def main(_):
tv_utils.set_gpus_to_use()
# if FLAGS.input_image is None:
# logging.error("No input_image was given.")
# logging.info(
# "Usage: python demo.py --input_image data/test.png "
# "[--output_image output_image] [--logdir /path/to/weights] "
# "[--gpus GPUs_to_use] ")
# exit(1)
if FLAGS.logdir is None:
# Download and use weights from the MultiNet Paper
if 'TV_DIR_RUNS' in os.environ:
runs_dir = os.path.join(os.environ['TV_DIR_RUNS'], 'KittiSeg')
else:
runs_dir = 'RUNS'
maybe_download_and_extract(runs_dir)
logdir = os.path.join(runs_dir, default_run)
else:
logging.info("Using weights found in {}".format(FLAGS.logdir))
logdir = FLAGS.logdir
# Loading hyperparameters from logdir
hypes = tv_utils.load_hypes_from_logdir(logdir, base_path='hypes')
logging.info("Hypes loaded successfully.")
# Loading tv modules (encoder.py, decoder.py, eval.py) from logdir
modules = tv_utils.load_modules_from_logdir(logdir)
logging.info("Modules loaded successfully. Starting to build tf graph.")
# Create tf graph and build module.
with tf.Graph().as_default():
# Create placeholder for input
image_pl = tf.placeholder(tf.float32)
image = tf.expand_dims(image_pl, 0)
image.set_shape([1, None, None, 3])
# build Tensorflow graph using the model from logdir
prediction = core.build_inference_graph(hypes, modules, image=image)
logging.info("Graph build successfully.")
# Create a session for running Ops on the Graph.
sess = tf.Session()
saver = tf.train.Saver()
# Load weights from logdir
core.load_weights(logdir, sess, saver)
logging.info("Weights loaded successfully.")
input_image = FLAGS.input_image
logging.info("Starting inference using {} as input".format(input_image))
# Load and resize input image
count = 1
duration = 0
video = cv2.VideoCapture(
"/home/zzhang52/Data/south_farm/front/VID_20170426_144800.mp4")
fourcc = cv2.VideoWriter_fourcc(*'XVID')
writer = cv2.VideoWriter("/home/zzhang52/Videos/visual_nav.avi", fourcc,
12.0, (960, 540))
while video.grab():
start = time()
_, image = video.retrieve()
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if hypes['jitter']['reseize_image']:
# Resize input only, if specified in hypes
image_height = hypes['jitter']['image_height']
image_width = hypes['jitter']['image_width']
image = scp.misc.imresize(image,
size=(image_height, image_width),
interp='bilinear')
# Run KittiSeg model on image
feed = {image_pl: image}
softmax = prediction['softmax']
output = sess.run([softmax], feed_dict=feed)
duration += time() - start
count += 1
# Reshape output from flat vector to 2D Image
shape = image.shape
output_image = output[0][:, 1].reshape(shape[0], shape[1])
# Plot confidences as red-blue overlay
# rb_image = seg.make_overlay(image, output_image)
# Accept all pixel with conf >= 0.5 as positive prediction
# This creates a `hard` prediction result for class street
threshold = 0.5
street_prediction = output_image > threshold
thresh = (255 * street_prediction).astype(np.uint8)
_, thresh = cv2.threshold(thresh, 100, 255, 0)
_, contours, _ = cv2.findContours(thresh,
mode=cv2.RETR_EXTERNAL,
method=cv2.CHAIN_APPROX_NONE)
contours.sort(key=cv2.contourArea, reverse=True)
mask = np.zeros(shape, np.uint8)
cv2.drawContours(mask, contours, 0, (0, 255, 0), -1)
cnt = np.asarray(contours[0])
cnt = np.squeeze(cnt)
cnt = cnt[np.argsort(cnt[:, 1])]
cnt = np.expand_dims(cnt, axis=1)
points = []
idx = 0
x_sum = 0
x_count = 0
for i in range(shape[0]):
while idx < cnt.shape[0] and cnt[idx][0][1] == i:
x_sum += float(cnt[idx][0][0])
x_count += 1
idx += 1
if x_count != 0:
avg = int(x_sum / x_count)
points.append(np.array([[avg, i]]))
x_sum = 0
x_count = 0
points = np.asarray(points)
# p1, p2, [vx,vy,x,y] = fitLine(points, shape[0], shape[1])
# [vx,vy,x,y] = cv2.fitLine(points, cv2.DIST_L2,0,0.01,0.01)
# lefty = int((-x*vy/vx) + y)
# righty = int(((shape[1]-x)*vy/vx)+y)
p1 = Point(points[0][0][0], points[0][0][1])
p2 = Point(points[-1][0][0], points[-1][0][1])
dx = float(p1.x - p2.x)
dy = float(p1.y - p2.y)
r = np.arctan(dx / dy) * 180 / np.pi
t = float(shape[1] / 2 - p2.x) / shape[1]
# r = np.sign(r) * (90 - abs(r))
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
alpha = 0.3
overlay = cv2.addWeighted(image, 1 - alpha, mask, alpha, 0)
# Plot the hard prediction as green overlay
# green_image = tv_utils.fast_overlay(image, street_prediction)
# green_image = cv2.cvtColor(green_image, cv2.COLOR_RGB2BGR)
cv2.line(overlay, (p1.x, p1.y), (p2.x, p2.y), (0, 0, 200), 2)
cv2.putText(overlay, "Heading: {:.2f}".format(r), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
cv2.putText(overlay, "Offset: {:.3e}".format(t), (10, 60),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
cv2.imshow("show", overlay)
writer.write(overlay)
if cv2.waitKey(15) == 27:
break
cv2.destroyAllWindows()
video.release()
writer.release()
# Save output images to disk.
# if FLAGS.output_image is None:
# output_base_name = input_image
# else:
# output_base_name = FLAGS.output_image
# raw_image_name = output_base_name.split('.')[0] + '_raw.png'
# rb_image_name = output_base_name.split('.')[0] + '_rb.png'
# green_image_name = output_base_name.split('.')[0] + '_green.png'
# scp.misc.imsave(raw_image_name, street_prediction)
# scp.misc.imsave(rb_image_name, rb_image)
# scp.misc.imsave(green_image_name, green_image)
# logging.info("")
# logging.info("Raw output image has been saved to: {}".format(
# os.path.realpath(raw_image_name)))
# logging.info("Red-Blue overlay of confs have been saved to: {}".format(
# os.path.realpath(rb_image_name)))
# logging.info("Green plot of predictions have been saved to: {}".format(
# os.path.realpath(green_image_name)))
print("FPS: {}".format(count / duration))
