void stereoview::save_image(logger& l, const image_id_type& id, const QString& filepath, int quality) const
{
    const option<QSize>& rs = rescale();
    const auto stimg = access_stored_image(id).atomic();
    const auto&& qimg = stimg->image(rs);

    l.msg(nfmt<5>("saving image ID:%1 with quality %2 at %3x%4 to file %5...") (id) (quality) (qimg.width()) (qimg.height()) (filepath));
    if (!qimg.save(filepath, NULL, quality))
        l.msg(nfmt<0>("ERROR: cannot save image to disk."));
}

void stereoview::parse_siftpp_keyfile(logger& l,
                               progress_tracker&&,
                               const image_id_type& id,
                               const QString& filepath,
                               const std::function<float(float)>& adapt_scale,
                               const std::function<float(float)>& adapt_rot,
                               const std::function<float(unsigned int)>& adapt_descr)
{
    QString&& ins = read_file_for_parsing(filepath);
    QTextStream s(&ins);
    l.msg(nfmt<1>("parsing SIFT++ keyfile '%1' with 128-dimesional descriptor...") (filepath));

    auto sl = access_stored_image(id).atomic();
    auto& stimg = *sl;

    // get the number of features
    unsigned int n_keyp = 0;
    {
        std::ifstream siftfile(filepath.toStdString().c_str());
        std::string dump;
        while(getline(siftfile,dump)) { ++n_keyp; }
        siftfile.close();
    }

    // parse the .sift file
    stimg.keypoints.clear();
    for (size_t cnt = 0; cnt < n_keyp; ++cnt)
    {
        if (is_parse_stream_past_end(s, filepath))
        {
            l.msg(HERE(nfmt<2>("end of stream reached while parsing '%1': %2 keypoints stored") (filepath) (cnt)));
            return;
        }

        keypoint128 kp;
        float scale, rot;

        s >> kp.x >> kp.y >> scale >> rot;
        kp.scale = adapt_scale(scale);
        kp.rotation = adapt_rot(rot);

        for (size_t di = 0; di < 128; ++di)
        {
            unsigned int x;
            s >> x;
            kp.descriptor[di] = adapt_descr(x);
        }
        stimg.keypoints.append(kp);
    } // next feature
}

	scope_logger(log_domain const &domain, const char* str) :
		ticks_(0),
		output_(NULL),
		str_()
	{
		if (!debug.dont_log(domain)) do_log_entry(domain, str);
	}

node::node(logger &l, const std::string &config_path) : m_node(NULL), m_log(NULL)
{
	struct dnet_config cfg;
	memset(&cfg, 0, sizeof(struct dnet_config));

	cfg.sock_type = SOCK_STREAM;
	cfg.proto = IPPROTO_TCP;

	m_log = reinterpret_cast<logger *>(l.clone());
	cfg.log = m_log->get_dnet_log();

	std::list<addr_tuple> remotes;
	std::vector<int> groups;

	parse_config(config_path, cfg, remotes, groups, cfg.log->log_level);

	m_node = dnet_node_create(&cfg);
	if (!m_node) {
		delete m_log;
		throw std::bad_alloc();
	}

	add_groups(groups);
	for (std::list<addr_tuple>::iterator it = remotes.begin(); it != remotes.end(); ++it) {
		try {
			add_remote(it->host.c_str(), it->port, it->family);
		} catch (...) {
			continue;
		}
	}
}

int main()
{
    // tell the logger to output all messages
    dlog.set_level(LALL);

    // Create an instance of our multi-threaded object.   
    my_object t;

    dlib::sleep(3000);
    
    // Tell the multi-threaded object to pause its threads.  This causes the
    // threads to block on their next calls to should_stop().
    t.pause();
    dlog << LINFO << "paused threads";

    dlib::sleep(3000);
    dlog << LINFO << "starting threads back up from paused state";

    // Tell the threads to unpause themselves.  This causes should_stop() to unblock 
    // and to let the threads continue.
    t.start();

    dlib::sleep(3000);

    // Let the program end.  When t is destructed it will gracefully terminate your
    // threads because we have set the destructor up to do so.
}

int main()
{
    // Every logger has a logging level (given by dlog.level()).  Each log message is tagged with a
    // level and only levels equal to or higher than dlog.level() will be printed.  By default all 
    // loggers start with level() == LERROR.  In this case I'm going to set the lowest level LALL 
    // which means that dlog will print all logging messages it gets.
    dlog.set_level(LALL);


    // print our first message.  It will go to cout because that is the default.
    dlog << LINFO << "This is an informational message.";

    // now print a debug message.
    int variable = 8;
    dlog << LDEBUG << "The integer variable is set to " << variable;

    // the logger can be used pretty much like any ostream object.  But you have to give a logging
    // level first.  But after that you can chain << operators like normal.
    
    if (variable > 4)
        dlog << LWARN << "The variable is bigger than 4!  Its value is " << variable;



    dlog << LINFO << "we are going to sleep for half a second.";
    // sleep for half a second
    dlib::sleep(500);
    dlog << LINFO << "we just woke up";



    dlog << LINFO << "program ending";
}

	scope_logger(log_domain const &domain, const std::string& str) :
		ticks_(0),
		output_(0),
		str_()
	{
		if (!debug.dont_log(domain)) do_log_entry(domain, str);
	}

 void runner::run(const test &t, logger &lgr)
 {
     try
     {
         lgr.record("pre_test", data("name", t.name)("line", t.line)("file", t.file)("time", t.time)("date", t.date));
         t.function(lgr);
         lgr.record("post_test", data("result", "ok"));
     }
     catch (const data &dat)
     {
         lgr.record("post_test", dat);
     }
     catch (...)
     {
         lgr.record("post_test", data("result", "aborted")("reason", "an uncaught exception ended the test"));
     }
 }

static option<float> extract_focal_length_from_image(logger& l, const QString& path, float ccd_width)
{
    //return some((3310.4 + 3325.5) / 2.); // dino ring
    return some(810.); // stereo experiments (ueye 640x512)

    float r;
    const auto&& c = extract_focal_length(path.toStdString().c_str(), &r, ccd_width);
    switch (c)
    {
    case FOCAL_LENGTH_OK:
        l.msg(nfmt<3>("EXIF chunk specifies focal length = %2 / CCD width = %3 for image file '%1'") (path) (r) (ccd_width));
        return some(r);
    case FOCAL_LENGTH_INVALID_EXIF:
        l.critical(nfmt<1>("invalid EXIF chunk in image file '%1'") (path));
        return none;
    case FOCAL_LENGTH_NO_CCD_DATA:
        l.critical(nfmt<1>("cannot find CCD data in image '%1'") (path));
        return none;
    default:
        l.unexpected_error(HERE(nfmt<1>("unknown return code %1") (c)));
        return none;
    }
}

void AgentConfiguration::configureLogger()
{
  // Load logger configuration
  set_all_logging_levels(LINFO);
  set_all_logging_headers((dlib::logger::print_header_type) print_ts_logger_header);
  configure_loggers_from_file(mConfigFile.c_str());
  
  if (mIsDebug) {
    set_all_logging_output_streams(cout);
    set_all_logging_levels(LDEBUG);
  } else if (mIsService && sLogger.output_streambuf() == cout.rdbuf()) {
    ostream *file = new std::ofstream("agent.log");
    set_all_logging_output_streams(*file);
  }
}

void stereoview::parse_keyfile(logger& l,
                               progress_tracker&& prog,
                               const image_id_type& id,
                               const QString& filepath,
                               const std::function<float(float)>& adapt_scale,
                               const std::function<float(float)>& adapt_rot,
                               const std::function<float(float)>& adapt_descr)
{
    QString&& ins = read_file_for_parsing(filepath);
    QTextStream s(&ins);

    unsigned int expected_keypoints, descr_dim;
    s >> expected_keypoints >> descr_dim;
    check_parse_stream_not_past_end(s, filepath);

    if (descr_dim != keypoint128::descriptor_dim)
        throw localized_runtime_error(HERE(nfmt<2>("descriptor dimension in keyfile '%1' is %2 while 128 was expected") (filepath) (descr_dim)));

    l.msg(nfmt<3>("parsing keyfile '%1': %2 keypoints with %3-dimesional descriptor...")
          (filepath) (expected_keypoints) (descr_dim));

    {
        auto sl = access_stored_image(id).atomic();
        auto& stimg = *sl;
        stimg.keypoints.clear();
        auto stepper = prog.section(expected_keypoints);
        for (size_t i = 0; i < expected_keypoints; ++i)
        {
            keypoint128 kp;
            float scale, rot;

            s >> kp.y >> kp.x >> scale >> rot;
            kp.scale = adapt_scale(scale);
            kp.rotation = adapt_rot(rot);

            for (size_t di = 0; di < descr_dim; ++di)
            {
                float x;
                s >> x;
                kp.descriptor[di] = adapt_descr(x);
            }

            check_parse_stream_not_past_end(s, filepath);
            stimg.keypoints.append(kp);
            ++stepper;
        }
    }
}

void stereoview::generate_keyfiles(logger& l,
                                   progress_tracker&& prog,
                                   const QVector<image_id_type>& imgids,
                                   const QDir& outdir,
                                   const QString& listfilepath,
                                   const std::function<QString(float)>& pretty_descr) const
{
    QFile listf(listfilepath);
    if (!listf.open(QFile::WriteOnly | QIODevice::Text | QFile::Truncate))
        throw localized_runtime_error(HERE(nfmt<1>("cannot open keyfile list file for writing: %1") (QFileInfo(listf).absoluteFilePath())));
    QTextStream ls(&listf);

    auto imgstepper = prog.section(imgids.size());
    foreach (const auto& id, imgids)
    {
        auto sl = access_stored_image(id).atomic();
        const auto& kps = sl->keypoints;
        if (kps.isEmpty())
            throw localized_invalid_argument(HERE(nfmt<1>("keypoints of image ID:%1 must be detected for tracking to make effect")(id)));
        const QString keyfilename = nfmt<1>("%1.key") (id);
        QFile f(outdir.absoluteFilePath(keyfilename));
        if(!f.open(QFile::WriteOnly | QIODevice::Text | QFile::Truncate))
            throw localized_runtime_error(HERE(nfmt<1>("cannot open keyfile for writing: %1") (QFileInfo(f).absoluteFilePath())));

        l.msg(nfmt<2>("generating keyfile '%1' (%2 keypoints)...") (f.fileName()) (kps.size()));
        QTextStream s(&f);
        s << kps.size() << " " << keypoint128::descriptor_dim << uendl;

        auto kpstepper = imgstepper.sub().section(kps.size());
        foreach (const auto& kp, kps)
        {
            s << kp.y << " " << kp.x << " " << kp.scale << " " << kp.rotation;
            for (size_t i = 0; i < keypoint128::descriptor_dim; ++i)
            {
                // follow indentation
                if (i % 20 == 0) s << uendl;
                s << " " << pretty_descr(kp.descriptor[i]);
            }
            s << uendl;
            ++kpstepper;
        }

namespace lg {

/**
 * Helper class to redirect the output of the logger in a certain scope.
 *
 * The main usage of the redirection is for the unit tests to validate the
 * ourput on the logger with the expected output.
 */
class tredirect_output_setter
{
public:

	/**
	 * Constructor.
	 *
	 * @param stream              The stream to direct the output to.
	 */
	explicit tredirect_output_setter(std::ostream& stream);

	~tredirect_output_setter();

private:

	/**
	 * The previously set redirection.
	 *
	 * This value is stored here to be restored in this destructor.
	 */
	std::ostream* old_stream_;
};

class logger;

typedef std::pair<const std::string, int> logd;

class log_domain {
	logd *domain_;
public:
	log_domain(char const *name);
	friend class logger;
};

bool set_log_domain_severity(std::string const &name, int severity);
std::string list_logdomains(const std::string& filter);

class logger {
	char const *name_;
	int severity_;
public:
	logger(char const *name, int severity): name_(name), severity_(severity) {}
	std::ostream &operator()(log_domain const &domain,
		bool show_names = true, bool do_indent = false) const;

	bool dont_log(log_domain const &domain) const
	{
		return severity_ > domain.domain_->second;
	}
};

void timestamps(bool);
std::string get_timestamp(const time_t& t, const std::string& format="%Y%m%d %H:%M:%S ");

extern logger err, warn, info, debug;
extern log_domain general;

class scope_logger
{
	int ticks_;
	std::ostream *output_;
	std::string str_;
public:
	scope_logger(log_domain const &domain, const char* str) :
		ticks_(0),
		output_(0),
		str_()
	{
		if (!debug.dont_log(domain)) do_log_entry(domain, str);
	}
	scope_logger(log_domain const &domain, const std::string& str) :
		ticks_(0),
		output_(0),
		str_()
	{
		if (!debug.dont_log(domain)) do_log_entry(domain, str);
	}
	~scope_logger()
	{
		if (output_) do_log_exit();
	}
	void do_indent() const;
private:
	void do_log_entry(log_domain const &domain, const std::string& str);
	void do_log_exit();
};

/**
 * Use this logger to send errors due to deprecated WML.
 * The preferred format is:
 * xxx is deprecated, support will be removed in version X. or
 * xxx is deprecated, support has been removed in version X.
//.........这里部分代码省略.........

namespace lg {

class logger;

typedef std::pair<const std::string, int> logd;

class log_domain {
	logd *domain_;
public:
	log_domain(char const *name);
	friend class logger;
};

bool set_log_domain_severity(std::string const &name, int severity);
std::string list_logdomains();

class logger {
	char const *name_;
	int severity_;
public:
	logger(char const *name, int severity): name_(name), severity_(severity) {}
	std::ostream &operator()(log_domain const &domain,
		bool show_names = true, bool do_indent = false) const;

	bool dont_log(log_domain const &domain) const
	{
		return severity_ > domain.domain_->second;
	}
};

void timestamps(bool);
std::string get_timestamp(const time_t& t, const std::string& format="%Y%m%d %H:%M:%S ");

extern logger err, warn, info, debug;
extern log_domain general;

class scope_logger
{
	int ticks_;
	std::ostream *output_;
	std::string str_;
public:
	scope_logger(log_domain const &domain, const char* str) :
		ticks_(0),
		output_(0),
		str_()
	{
		if (!debug.dont_log(domain)) do_log_entry(domain, str);
	}
	scope_logger(log_domain const &domain, const std::string& str) :
		ticks_(0),
		output_(0),
		str_()
	{
		if (!debug.dont_log(domain)) do_log_entry(domain, str);
	}
	~scope_logger()
	{
		if (output_) do_log_exit();
	}
	void do_indent() const;
private:
	void do_log_entry(log_domain const &domain, const std::string& str);
	void do_log_exit();
};

/**
 * Use this logger to send errors due to deprecated WML.
 * The preferred format is:
 * xxx is deprecated, support will be removed in version X. or
 * xxx is deprecated, support has been removed in version X.
 *
 * After every wml-event the errors are shown to the user,
 * so they can inform the campaign maintainer.
 */
extern std::stringstream wml_error;

} // namespace lg

int main()
{
    // tell the logger to print out everything
    dlog.set_level(LALL);


    dlog << LINFO << "schedule a few tasks";

    test mytask;
    // Schedule the thread pool to call mytask.task().  Note that all forms of add_task()
    // pass in the task object by reference.  This means you must make sure, in this case,
    // that mytask isn't destructed until after the task has finished executing.
    tp.add_task(mytask, &test::task);

    // You can also pass task objects to a thread pool by value.  So in this case we don't
    // have to worry about keeping our own instance of the task.  Here we construct a temporary 
    // add_value object and pass it right in and everything works like it should.
    future<int> num = 3;
    tp.add_task_by_value(add_value(7), num);  // adds 7 to num
    int result = num.get();
    dlog << LINFO << "result = " << result;   // prints result = 10





// uncomment this line if your compiler supports the new C++0x lambda functions
//#define COMPILER_SUPPORTS_CPP0X_LAMBDA_FUNCTIONS
#ifdef COMPILER_SUPPORTS_CPP0X_LAMBDA_FUNCTIONS

    // In the above examples we had to explicitly create task objects which is
    // inconvenient.  If you have a compiler which supports C++0x lambda functions
    // then you can use the following simpler method.

    // make a task which will just log a message
    tp.add_task_by_value([](){
                         dlog << LINFO << "A message from a lambda function running in another thread."; 
                         });

    // Here we make 10 different tasks, each assigns a different value into 
    // the elements of the vector vect.
    std::vector<int> vect(10);
    for (unsigned long i = 0; i < vect.size(); ++i)
    {
        // Make a lambda function which takes vect by reference and i by value.  So what
        // will happen is each assignment statement will run in a thread in the thread_pool.
        tp.add_task_by_value([&vect,i](){
                             vect[i] = i;
                             });
    }
    // Wait for all tasks which were requested by the main thread to complete.
    tp.wait_for_all_tasks();
    for (unsigned long i = 0; i < vect.size(); ++i)
    {
        dlog << LINFO << "vect["<<i<<"]: " << vect[i];
    }
#endif



    /* A possible run of this program might produce the following output (the first column is 
       the time the log message occurred and the value in [] is the thread id for the thread
       that generated the log message):

    1 INFO  [0] main: schedule a few tasks
    1 INFO  [1] main: task start
    1 INFO  [0] main: result = 10
  201 INFO  [2] main: subtask end 
  201 INFO  [1] main: var = 2
  201 INFO  [2] main: A message from a lambda function running in another thread.
  301 INFO  [3] main: subtask2 end 
  301 INFO  [1] main: task end
  301 INFO  [0] main: vect[0]: 0
  301 INFO  [0] main: vect[1]: 1
  301 INFO  [0] main: vect[2]: 2
  301 INFO  [0] main: vect[3]: 3
  301 INFO  [0] main: vect[4]: 4
  301 INFO  [0] main: vect[5]: 5
  301 INFO  [0] main: vect[6]: 6
  301 INFO  [0] main: vect[7]: 7
  301 INFO  [0] main: vect[8]: 8
  301 INFO  [0] main: vect[9]: 9
    */
}

void logger_log(logger &log, const char *msg, int level)
{
	log.log(level, msg);
}

bool set_log_domain_severity(const std::string& name, const logger &lg) {
	return set_log_domain_severity(name, lg.get_severity());
}

void set_strict_severity(const logger &lg) {
	set_strict_severity(lg.get_severity());
}

void print_line(const logger & log)
{
	cout << "Session: " << log.last_line() << endl;
}