propagate silent flag and add --log-file

Author: aothms

edge_detect.h

@@ -20,12 +20,16 @@ class post_process {
 		if (application_progress_callback) {
 			(*application_progress_callback)(f);
 		}
-		if (progress_callback) {
-			(*progress_callback)(static_cast<int>(f * 100.));
+		if (!silent) {
+			if (progress_callback) {
+				(*progress_callback)(static_cast<int>(f * 100.));
+			}
 		}
 	}
 
 public:
+	bool silent = false;
+
 	void set_progress_callback(boost::optional<std::function<void(int)>> cb) {
 		progress_callback = cb;
 	}
@@ -52,7 +56,7 @@ class threaded_post_process : public post_process {
 	{}
 
 	regular_voxel_storage* operator()(regular_voxel_storage* storage) {
-		progress_writer p(typeid(T).name());
+		progress_writer p(typeid(T).name(), silent);
 
 		std::vector<std::thread> ts;
 		std::vector<regular_voxel_storage*> results(n_);

progress_writer.cpp

@@ -6,6 +6,8 @@
 static std::mutex progress_mtx;
 
 void threaded_progress_writer::operator()(int n, int i)  {
+	if (silent_) return;
+
 	if (ps_[n] == i) {
 		return;
 	}

progress_writer.h

@@ -13,11 +13,12 @@ class threaded_progress_writer {
 	std::vector<int> ps_;
 	std::string item_;
 	mutable bool ended_;
+	bool silent_;
 public:
 	boost::optional<std::function<void(float)>> application_progress_callback;
 
-	threaded_progress_writer(const std::string& item, int n)
-		: item_(item), ended_(false)
+	threaded_progress_writer(const std::string& item, int n, bool silent=false)
+		: item_(item), ended_(false), silent_(silent)
 	{
 		ps_.resize(n);
 	}
@@ -29,6 +30,7 @@ class threaded_progress_writer {
 	void operator()(int n, int i);
 
 	void end() const {
+		if (silent_) return;
 		if (!ended_) {
 			std::cerr << std::endl;
 			ended_ = true;
@@ -46,8 +48,8 @@ class progress_writer {
 
 	progress_writer() : silent_(true) {}
 
-	progress_writer(const std::string& item)
-		: item_(item), ended_(false), silent_(false) {}
+	progress_writer(const std::string& item, bool silent = false)
+		: item_(item), ended_(false), silent_(silent) {}
 
 	~progress_writer() {
 		end();
@@ -71,7 +73,7 @@ class progress_writer {
 	}
 
 	threaded_progress_writer thread(int n) {
-		return threaded_progress_writer(item_, n);
+		return threaded_progress_writer(item_, n, silent_);
 	}
 };
 

voxec.cpp

@@ -105,37 +105,44 @@ std::ostream& operator<<(std::ostream& a, const statement_type& b) {
 	return a;
 }
 
-class print_visitor {
+class log_visitor {
+private:
+	json_logger::meta_value v_;
 public:
+	const json_logger::meta_value& value() const { return v_; }
+
 	typedef void result_type;
 
-	void operator()(const boost::blank&) const {
-		std::cerr << "(void:)" << std::endl;
+	void operator()(const boost::blank&) {
+		v_ = std::string("void");
 	}
 
-	void operator()(int v) const {
-		std::cerr << "(integer:)" << v << std::endl;
+	void operator()(int v) {
+		v_ = (long) v;
 	}
 
-	void operator()(double v) const {
-		std::cerr << "(real:)" << v << std::endl;
+	void operator()(double v) {
+		v_ = v;
 	}
 
-	void operator()(const std::string& v) const {
+	void operator()(const std::string& v) {
 		if (v.at(0) == '"') {
-			std::cerr << "(string:)" << v.substr(1, v.size() - 2) << std::endl;
+			v_ = v.substr(1, v.size() - 2);
+		}
+		else {
+			v_ = v;
 		}
 	}
 
-	void operator()(const function_arg_value_type& v) const {
+	void operator()(const function_arg_value_type& v) {
 		v.apply_visitor(*this);
 	}
 
-	void operator()(filtered_files_t const v) const {	}
+	void operator()(filtered_files_t const v) {	}
 
-	void operator()(geometry_collection_t* const v) const {	}
+	void operator()(geometry_collection_t* const v) { }
 
-	void operator()(abstract_voxel_storage* const v) const { }
+	void operator()(abstract_voxel_storage* const v) { }
 };
 
 
@@ -180,6 +187,7 @@ scope_map run(const std::vector<statement_type>& statements, double size, size_t
 
 		voxel_operation_runner op(st);
 		op.application_progress_callback = apfn;
+		op.silent = with_progress_on_cout;
 		context[st.assignee()] = op.run(st, context);
 
 		if (context[st.assignee()].which() == HAS_VOXELS) {
@@ -205,12 +213,7 @@ scope_map run(const std::vector<statement_type>& statements, double size, size_t
 
 				json_logger::message(json_logger::LOG_NOTICE, "storing {value} in {variable}", {
 					{"variable", {{"name", st.assignee()}}},
-					{"value", {
-						{"count", (long) voxels->count()},
-						{"grid", left.format() + " - " + right.format()},
-						{"bounds", voxels->bounds()[0].format() + " - " + voxels->bounds()[1].format()},
-						{"world", left_world.format() + " - " + right_world.format()},
-					}},
+					{"value", dump_info(voxels)},
 				});
 			}
 		}
@@ -223,8 +226,12 @@ scope_map run(const std::vector<statement_type>& statements, double size, size_t
 	}
 
 	if (statements.size()) {
-		print_visitor v;
-		context[statements.back().assignee()].apply_visitor(v);
+		log_visitor v;
+		context[statements.back().assignee()].apply_visitor(std::ref(v));
+
+		json_logger::message(json_logger::LOG_NOTICE, "scripted finished with {variable}", {
+				{"variable", {{"value", v.value()}}},
+		});
 	} else {
 		json_logger::message(json_logger::LOG_WARNING, "no operations in input", {});
 	}

voxec.h

@@ -7,6 +7,7 @@
 #include "offset.h"
 #include "fill_gaps.h"
 #include "traversal.h"
+#include "json_logger.h"
 
 #ifdef WITH_IFC
 #include <ifcparse/IfcFile.h>
@@ -138,6 +139,7 @@ struct argument_spec {
 class voxel_operation {
 public:
 	boost::optional<std::function<void(float)>> application_progress_callback;
+	bool silent = false;
 
 	virtual const std::vector<argument_spec>& arg_names() const = 0;
 	virtual symbol_value invoke(const scope_map& scope) const = 0;
@@ -384,20 +386,22 @@ class op_create_geometry : public voxel_operation {
 				}
 
 				if (old_progress != iterator.progress()) {
-					std::cerr << "\rparsing geometry " << iterator.progress();
 					old_progress = iterator.progress();
+					if (application_progress_callback) {
+						(*application_progress_callback)(old_progress / 100.f);
+					}
 				}
 
 				if (!iterator.next()) {
-					std::cerr << std::endl;
 					break;
 				}
 			}
 
-		}
+		}		
 
 		if (!at_least_one_succesful) {
-			throw std::runtime_error("Failed to generate geometry");
+			json_logger::message(json_logger::LOG_FATAL, "Failed to generate geometry");
+			abort();
 		}
 
 		std::random_shuffle(geometries->begin(), geometries->end());
@@ -415,7 +419,7 @@ namespace {
 		return voxels;
 	}
 
-	abstract_voxel_storage* voxelize(geometry_collection_t* surfaces, double vsize, int chunksize, const boost::optional<int>& threads) {
+	abstract_voxel_storage* voxelize(geometry_collection_t* surfaces, double vsize, int chunksize, const boost::optional<int>& threads, bool silent = false) {
 		double x1, y1, z1, x2, y2, z2;
 		int nx, ny, nz;
 
@@ -439,7 +443,7 @@ namespace {
 		nz += PADDING * 2;
 
 		if (threads) {
-			progress_writer progress("voxelize");
+			progress_writer progress("voxelize", silent);
 			threaded_processor p(x1, y1, z1, vsize, nx, ny, nz, chunksize, *threads, progress);
 			p.process(surfaces->begin(), surfaces->end(), SURFACE(), output(MERGED()));
 			return p.voxels();
@@ -471,7 +475,7 @@ class op_voxelize : public voxel_operation {
 			// Just some arbitrary empty region
 			return (abstract_voxel_storage*) new chunked_voxel_storage<bit_t>(make_vec<long>(0,0,0), vsize, cs, make_vec<size_t>(1U,1U,1U));
 		} else {
-			return voxelize(surfaces, vsize, cs, t);
+			return voxelize(surfaces, vsize, cs, t, silent);
 		}
 	}
 };
@@ -493,7 +497,7 @@ class op_print_components : public voxel_operation {
 };
 
 namespace {
-	void dump_info(abstract_voxel_storage* voxels) {
+	json_logger::meta_data dump_info(abstract_voxel_storage* voxels) {
 		if (dynamic_cast<abstract_chunked_voxel_storage*>(voxels)) {
 			auto left = dynamic_cast<abstract_chunked_voxel_storage*>(voxels)->grid_offset();
 			auto nc = dynamic_cast<abstract_chunked_voxel_storage*>(voxels)->num_chunks();
@@ -502,14 +506,15 @@ namespace {
 			auto szl = (long)dynamic_cast<abstract_chunked_voxel_storage*>(voxels)->chunk_size();
 			auto left_world = ((voxels->bounds()[0].as<long>() + left * szl).as<double>() * sz);
 			auto right_world = ((voxels->bounds()[1].as<long>() + left * szl).as<double>() * sz);
-			std::cerr << "voxels: "
-				<< left.format() << " - " << right.format()
-				<< " ; count: " << voxels->count()
-				<< " ; bounds: " << voxels->bounds()[0].format()
-				<< " - " << voxels->bounds()[1].format() << std::endl
-				<< " ; world: " << left_world.format()
-				<< " - " << right_world.format() << std::endl;
+
+			return {
+				{"count", (long)voxels->count()},
+				{"grid", left.format() + " - " + right.format()},
+				{"bounds", voxels->bounds()[0].format() + " - " + voxels->bounds()[1].format()},
+				{"world", left_world.format() + " - " + right_world.format()},
+			};
 		}
+		return {};
 	}
 
 	template <typename Fn, typename Fn2>
@@ -811,6 +816,7 @@ class op_fill_gaps : public voxel_operation {
 		abstract_voxel_storage* voxels = scope.get_value<abstract_voxel_storage*>("input");
 		threaded_post_process<fill_gaps> tpp(scope.get_value<int>("THREADS"));
 		tpp.set_progress_callback(application_progress_callback);
+		tpp.silent = silent;
 		return tpp((regular_voxel_storage*) voxels);
 	}
 };
@@ -825,6 +831,7 @@ class op_offset : public voxel_operation {
 		abstract_voxel_storage* voxels = scope.get_value<abstract_voxel_storage*>("input");
 		threaded_post_process< offset<> > tpp(scope.get_value<int>("THREADS"));
 		tpp.set_progress_callback(application_progress_callback);
+		tpp.silent = silent;
 		return tpp((regular_voxel_storage*)voxels);
 	}
 };
@@ -853,7 +860,10 @@ class op_offset_xy : public voxel_operation {
 #else
 		auto current = (regular_voxel_storage*) voxels->copy();
 		while (d) {
-			auto ofs = threaded_post_process< offset<1, 2> >(scope.get_value<int>("THREADS"))(current);
+			threaded_post_process< offset<1, 2> > tpp(scope.get_value<int>("THREADS"));
+			// @todo progress not propagated as it's within a loop
+			tpp.silent = silent;
+			auto ofs = tpp(current);
 			auto next = (regular_voxel_storage*) current->boolean_union(ofs);
 			delete ofs;
 			delete current;
@@ -877,6 +887,7 @@ class op_outmost : public voxel_operation {
 		abstract_voxel_storage* voxels = scope.get_value<abstract_voxel_storage*>("input");
 		threaded_post_process<keep_outmost> tpp(1);
 		tpp.set_progress_callback(application_progress_callback);
+		tpp.silent = silent;
 		return tpp((regular_voxel_storage*)voxels);
 	}
 };
@@ -904,6 +915,7 @@ class op_volume : public voxel_operation {
 		abstract_voxel_storage* voxels = scope.get_value<abstract_voxel_storage*>("input");
 		threaded_post_process<traversal_voxel_filler_separate_components> tpp(1);
 		tpp.set_progress_callback(application_progress_callback);
+		tpp.silent = silent;
 		return tpp((regular_voxel_storage*)voxels);
 	}
 };
@@ -921,6 +933,7 @@ class op_volume_2 : public voxel_operation {
 		}
 		threaded_post_process<traversal_voxel_filler_inverse> tpp(1);
 		tpp.set_progress_callback(application_progress_callback);
+		tpp.silent = silent;
 		return ((regular_voxel_storage*)voxels);
 	}
 };
@@ -935,6 +948,7 @@ class op_volume_inverted : public voxel_operation {
 		abstract_voxel_storage* voxels = scope.get_value<abstract_voxel_storage*>("input");
 		threaded_post_process<traversal_voxel_filler_inverted> tpp(1);
 		tpp.set_progress_callback(application_progress_callback);
+		tpp.silent = silent;
 		return tpp((regular_voxel_storage*)voxels);
 	}
 };
@@ -1327,13 +1341,15 @@ class voxel_operation_runner {
 public:
 	const statement_type& statement_;
 	boost::optional<std::function<void(float)>> application_progress_callback;
+	bool silent = false;
 
 	voxel_operation_runner(const statement_type& statement) :
 		statement_(statement) {}
 
 	symbol_value run(const statement_type& st, scope_map& context) {
 		voxel_operation* op = voxel_operation_map::create(statement_.call().name());
 		op->application_progress_callback = application_progress_callback;
+		op->silent = silent;
 
 		bool has_keyword = false;
 		std::map<std::string, function_arg_value_type> function_values;

voxec_main.cpp

@@ -10,12 +10,12 @@
 namespace po = boost::program_options;
 
 int main(int argc, char** argv) {
-	// json_logger::register_output(json_logger::FMT_JSON, &std::cerr);
-	json_logger::register_output(json_logger::FMT_TEXT, &std::cerr);
+	std::unique_ptr<std::ofstream> log_file;
 
 	po::options_description opts("Command line options");
 	opts.add_options()
 		("quiet,q", "limit output on stdout to progress indication")
+		("log-file", po::value<std::string>(), "filename to log json message")
 		("threads,t", po::value<size_t>(), "number of parallel processing threads")
 		("size,d", po::value<double>(), "voxel size in meters")
 		("chunk,c", po::value<size_t>(), "chunk size in number of voxels")
@@ -63,10 +63,20 @@ int main(int argc, char** argv) {
 		chunk = vmap["chunk"].as<size_t>();
 	}
 
+	if (vmap.count("log-file")) {
+		const std::string log_filename = vmap["log-file"].as<std::string>();
+		log_file = std::make_unique<std::ofstream>(log_filename.c_str());
+		json_logger::register_output(json_logger::FMT_TEXT, &*log_file);
+	}
+
 	const std::string input_filename = vmap["input-file"].as<std::string>();
 	const bool with_mesh = vmap.count("mesh") != 0;
 	const bool quiet = vmap.count("quiet") != 0;
 
+	if (!quiet) {
+		json_logger::register_output(json_logger::FMT_TEXT, &std::cerr);
+	}
+
 	std::ifstream ifs(input_filename.c_str(), std::ios::binary);
 	if (!ifs.good()) {
 		json_logger::message(json_logger::LOG_FATAL, "unable to open file {file}", {