From 475b1746c133b0286871b7414918704557f1abcc Mon Sep 17 00:00:00 2001
From: "Daniel M. Pelt" <D.M.Pelt@cwi.nl>
Date: Mon, 9 Mar 2015 15:53:07 +0100
Subject: Remove old Logging code (only used in fft.cu)
---
include/astra/Logger.h | 72 --------------------------------------------------
1 file changed, 72 deletions(-)
delete mode 100644 include/astra/Logger.h
(limited to 'include/astra')
diff --git a/include/astra/Logger.h b/include/astra/Logger.h
deleted file mode 100644
index 34fd364..0000000
--- a/include/astra/Logger.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
------------------------------------------------------------------------
-Copyright: 2010-2015, iMinds-Vision Lab, University of Antwerp
- 2014-2015, CWI, Amsterdam
-
-Contact: astra@uantwerpen.be
-Website: http://sf.net/projects/astra-toolbox
-
-This file is part of the ASTRA Toolbox.
-
-
-The ASTRA Toolbox is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-The ASTRA Toolbox is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
-
------------------------------------------------------------------------
-$Id$
-*/
-
-#ifndef _INC_ASTRA_LOGGER
-#define _INC_ASTRA_LOGGER
-
-#include <cstdio>
-
-namespace astra
-{
-
-/**
- * This is the first stab at a decent logger. If the file "astra_logger.txt", it will be replaced
- * with the text sent to this logger. If the file doesn't exist when the app starts, nothing is written.
- */
-class CLogger
-{
- static std::FILE * m_pOutFile;
- static bool m_bInitialized;
-
- static void _assureIsInitialized();
-
- CLogger();
-
-public:
-
- /**
- * Writes a line to the log file (newline is added). Ignored if logging is turned off.
- *
- * @param _text char pointer to text in line
- */
- static void writeLine(const char * _text);
-
- /**
- * Formats and writes a CUDA error to the log file. Ignored if logging is turned off.
- *
- * @param _fileName filename where error occurred (typically __FILE__)
- * @param _line line in file (typically __LINE__)
- * @param _errString string describing the error, can be output of cudaGetErrorString
- */
- static void writeTerminalCUDAError(const char * _fileName, int _iLine, const char * _errString);
-};
-
-}
-
-#endif /* _INC_ASTRA_LOGGER */
-
--
cgit v1.2.3
From a1dff91d7d8db49ecd79dfbcc6a6a663b114f9fd Mon Sep 17 00:00:00 2001
From: "Daniel M. Pelt" <D.M.Pelt@cwi.nl>
Date: Mon, 9 Mar 2015 17:51:42 +0100
Subject: Adds new logging capabilities (based on clog.h)
---
include/astra/Logging.h | 147 ++++++++++++
include/astra/clog.h | 622 ++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 769 insertions(+)
create mode 100644 include/astra/Logging.h
create mode 100644 include/astra/clog.h
(limited to 'include/astra')
diff --git a/include/astra/Logging.h b/include/astra/Logging.h
new file mode 100644
index 0000000..ce777ae
--- /dev/null
+++ b/include/astra/Logging.h
@@ -0,0 +1,147 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2015, iMinds-Vision Lab, University of Antwerp
+ 2014-2015, CWI, Amsterdam
+
+Contact: astra@uantwerpen.be
+Website: http://sf.net/projects/astra-toolbox
+
+This file is part of the ASTRA Toolbox.
+
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+#ifndef _INC_ASTRA_LOGGING
+#define _INC_ASTRA_LOGGING
+
+#define ASTRA_LOG(id) __FILE__, __LINE__, id
+
+namespace astra
+{
+
+enum log_level {
+ LOG_DEBUG,
+ LOG_INFO,
+ LOG_WARN,
+ LOG_ERROR
+};
+
+class CLogger
+{
+ CLogger();
+ ~CLogger();
+ static bool m_bEnabledFile;
+ static bool m_bEnabledScreen;
+ static bool m_bFileProvided;
+ static bool m_bInitialized;
+ static void _assureIsInitialized();
+ static void _setLevel(int id, log_level m_eLevel);
+
+public:
+
+ /**
+ * Writes a line to the log file (newline is added). Ignored if logging is turned off.
+ *
+ * @param sfile
+ * The name of the source file making this log call (e.g. __FILE__).
+ *
+ * @param sline
+ * The line number of the call in the source code (e.g. __LINE__).
+ *
+ * @param id
+ * The id of the logger to write to.
+ *
+ * @param fmt
+ * The format string for the message (printf formatting).
+ *
+ * @param ...
+ * Any additional format arguments.
+ */
+ static void debug(const char *sfile, int sline, const char *fmt, ...);
+ static void info(const char *sfile, int sline, const char *fmt, ...);
+ static void warn(const char *sfile, int sline, const char *fmt, ...);
+ static void error(const char *sfile, int sline, const char *fmt, ...);
+
+ /**
+ * Sets the file to log to, with logging level.
+ *
+ * @param filename
+ * File to log to.
+ *
+ * @param m_eLevel
+ * Logging level (LOG_DEBUG, LOG_WARN, LOG_INFO, LOG_ERROR).
+ *
+ */
+ static void setOutputFile(const char *filename, log_level m_eLevel);
+
+ /**
+ * Sets the screen to log to, with logging level.
+ *
+ * @param screen_fd
+ * Screen file descriptor (1 for stdout, 2 for stderr)
+ *
+ * @param m_eLevel
+ * Logging level (LOG_DEBUG, LOG_WARN, LOG_INFO, LOG_ERROR).
+ *
+ */
+ static void setOutputScreen(int fd, log_level m_eLevel);
+
+ /**
+ * Set the format string for log messages. Here are the substitutions you may
+ * use:
+ *
+ * %f: Source file name generating the log call.
+ * %n: Source line number where the log call was made.
+ * %m: The message text sent to the logger (after printf formatting).
+ * %d: The current date, formatted using the logger's date format.
+ * %t: The current time, formatted using the logger's time format.
+ * %l: The log level (one of "DEBUG", "INFO", "WARN", or "ERROR").
+ * %%: A literal percent sign.
+ *
+ * The default format string is "%d %t %f(%n): %l: %m\n".
+ *
+ * @param fmt
+ * The new format string, which must be less than 256 bytes.
+ * You probably will want to end this with a newline (\n).
+ *
+ */
+ static void setFormatFile(const char *fmt);
+ static void setFormatScreen(const char *fmt);
+
+
+ /**
+ * Enable logging.
+ *
+ */
+ static void enable();
+ static void enableScreen();
+ static void enableFile();
+
+ /**
+ * Disable logging.
+ *
+ */
+ static void disable();
+ static void disableScreen();
+ static void disableFile();
+
+};
+
+}
+
+#endif /* _INC_ASTRA_LOGGING */
diff --git a/include/astra/clog.h b/include/astra/clog.h
new file mode 100644
index 0000000..4d8e39d
--- /dev/null
+++ b/include/astra/clog.h
@@ -0,0 +1,622 @@
+/* clog: Extremely simple logger for C.
+ *
+ * Features:
+ * - Implemented purely as a single header file.
+ * - Create multiple loggers.
+ * - Four log levels (debug, info, warn, error).
+ * - Custom formats.
+ * - Fast.
+ *
+ * Dependencies:
+ * - Should conform to C89, C++98 (but requires vsnprintf, unfortunately).
+ * - POSIX environment.
+ *
+ * USAGE:
+ *
+ * Include this header in any file that wishes to write to logger(s). In
+ * exactly one file (per executable), define CLOG_MAIN first (e.g. in your
+ * main .c file).
+ *
+ * #define CLOG_MAIN
+ * #include "clog.h"
+ *
+ * This will define the actual objects that all the other units will use.
+ *
+ * Loggers are identified by integers (0 - 15). It's expected that you'll
+ * create meaningful constants and then refer to the loggers as such.
+ *
+ * Example:
+ *
+ * const int MY_LOGGER = 0;
+ *
+ * int main() {
+ * int r;
+ * r = clog_init_path(MY_LOGGER, "my_log.txt");
+ * if (r != 0) {
+ * fprintf(stderr, "Logger initialization failed.\n");
+ * return 1;
+ * }
+ * clog_info(CLOG(MY_LOGGER), "Hello, world!");
+ * clog_free(MY_LOGGER);
+ * return 0;
+ * }
+ *
+ * The CLOG macro used in the call to clog_info is a helper that passes the
+ * __FILE__ and __LINE__ parameters for you, so you don't have to type them
+ * every time. (It could be prettier with variadic macros, but that requires
+ * C99 or C++11 to be standards compliant.)
+ *
+ * Errors encountered by clog will be printed to stderr. You can suppress
+ * these by defining a macro called CLOG_SILENT before including clog.h.
+ *
+ * License: Do whatever you want. It would be nice if you contribute
+ * improvements as pull requests here:
+ *
+ * https://github.com/mmueller/clog
+ *
+ * Copyright 2013 Mike Mueller <mike@subfocal.net>.
+ *
+ * As is; no warranty is provided; use at your own risk.
+ */
+
+#ifndef __CLOG_H__
+#define __CLOG_H__
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+/* Number of loggers that can be defined. */
+#define CLOG_MAX_LOGGERS 16
+
+/* Format strings cannot be longer than this. */
+#define CLOG_FORMAT_LENGTH 256
+
+/* Formatted times and dates should be less than this length. If they are not,
+ * they will not appear in the log. */
+#define CLOG_DATETIME_LENGTH 256
+
+/* Default format strings. */
+#define CLOG_DEFAULT_FORMAT "%d %t %f(%n): %l: %m\n"
+#define CLOG_DEFAULT_DATE_FORMAT "%Y-%m-%d"
+#define CLOG_DEFAULT_TIME_FORMAT "%H:%M:%S"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum clog_level {
+ CLOG_DEBUG,
+ CLOG_INFO,
+ CLOG_WARN,
+ CLOG_ERROR
+};
+
+struct clog;
+
+/**
+ * Create a new logger writing to the given file path. The file will always
+ * be opened in append mode.
+ *
+ * @param id
+ * A constant integer between 0 and 15 that uniquely identifies this logger.
+ *
+ * @param path
+ * Path to the file where log messages will be written.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_init_path(int id, const char *const path);
+
+/**
+ * Create a new logger writing to a file descriptor.
+ *
+ * @param id
+ * A constant integer between 0 and 15 that uniquely identifies this logger.
+ *
+ * @param fd
+ * The file descriptor where log messages will be written.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_init_fd(int id, int fd);
+
+/**
+ * Destroy (clean up) a logger. You should do this at the end of execution,
+ * or when you are done using the logger.
+ *
+ * @param id
+ * The id of the logger to destroy.
+ */
+void clog_free(int id);
+
+#define CLOG(id) __FILE__, __LINE__, id
+
+/**
+ * Log functions (one per level). Call these to write messages to the log
+ * file. The first three arguments can be replaced with a call to the CLOG
+ * macro defined above, e.g.:
+ *
+ * clog_debug(CLOG(MY_LOGGER_ID), "This is a log message.");
+ *
+ * @param sfile
+ * The name of the source file making this log call (e.g. __FILE__).
+ *
+ * @param sline
+ * The line number of the call in the source code (e.g. __LINE__).
+ *
+ * @param id
+ * The id of the logger to write to.
+ *
+ * @param fmt
+ * The format string for the message (printf formatting).
+ *
+ * @param ...
+ * Any additional format arguments.
+ */
+void clog_debug(const char *sfile, int sline, int id, const char *fmt, va_list ap);
+void clog_info(const char *sfile, int sline, int id, const char *fmt, va_list ap);
+void clog_warn(const char *sfile, int sline, int id, const char *fmt, va_list ap);
+void clog_error(const char *sfile, int sline, int id, const char *fmt, va_list ap);
+
+/**
+ * Set the minimum level of messages that should be written to the log.
+ * Messages below this level will not be written. By default, loggers are
+ * created with level == CLOG_DEBUG.
+ *
+ * @param id
+ * The identifier of the logger.
+ *
+ * @param level
+ * The new minimum log level.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_set_level(int id, enum clog_level level);
+
+/**
+ * Set the format string used for times. See strftime(3) for how this string
+ * should be defined. The default format string is CLOG_DEFAULT_TIME_FORMAT.
+ *
+ * @param fmt
+ * The new format string, which must be less than CLOG_FORMAT_LENGTH bytes.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_set_time_fmt(int id, const char *fmt);
+
+/**
+ * Set the format string used for dates. See strftime(3) for how this string
+ * should be defined. The default format string is CLOG_DEFAULT_DATE_FORMAT.
+ *
+ * @param fmt
+ * The new format string, which must be less than CLOG_FORMAT_LENGTH bytes.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_set_date_fmt(int id, const char *fmt);
+
+/**
+ * Set the format string for log messages. Here are the substitutions you may
+ * use:
+ *
+ * %f: Source file name generating the log call.
+ * %n: Source line number where the log call was made.
+ * %m: The message text sent to the logger (after printf formatting).
+ * %d: The current date, formatted using the logger's date format.
+ * %t: The current time, formatted using the logger's time format.
+ * %l: The log level (one of "DEBUG", "INFO", "WARN", or "ERROR").
+ * %%: A literal percent sign.
+ *
+ * The default format string is CLOG_DEFAULT_FORMAT.
+ *
+ * @param fmt
+ * The new format string, which must be less than CLOG_FORMAT_LENGTH bytes.
+ * You probably will want to end this with a newline (\n).
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_set_fmt(int id, const char *fmt);
+
+/*
+ * No need to read below this point.
+ */
+
+/**
+ * The C logger structure.
+ */
+struct clog {
+
+ /* The current level of this logger. Messages below it will be dropped. */
+ enum clog_level level;
+
+ /* The file being written. */
+ int fd;
+
+ /* The format specifier. */
+ char fmt[CLOG_FORMAT_LENGTH];
+
+ /* Date format */
+ char date_fmt[CLOG_FORMAT_LENGTH];
+
+ /* Time format */
+ char time_fmt[CLOG_FORMAT_LENGTH];
+
+ /* Tracks whether the fd needs to be closed eventually. */
+ int opened;
+};
+
+void _clog_err(const char *fmt, ...);
+
+#ifdef CLOG_MAIN
+struct clog *_clog_loggers[CLOG_MAX_LOGGERS] = { 0 };
+#else
+extern struct clog *_clog_loggers[CLOG_MAX_LOGGERS];
+#endif
+
+#ifdef CLOG_MAIN
+
+const char *const CLOG_LEVEL_NAMES[] = {
+ "DEBUG",
+ "INFO",
+ "WARN",
+ "ERROR",
+};
+
+int
+clog_init_path(int id, const char *const path)
+{
+ int fd = open(path, O_CREAT | O_WRONLY | O_APPEND, 0666);
+ if (fd == -1) {
+ _clog_err("Unable to open %s: %s\n", path, strerror(errno));
+ return 1;
+ }
+ if (clog_init_fd(id, fd)) {
+ close(fd);
+ return 1;
+ }
+ _clog_loggers[id]->opened = 1;
+ return 0;
+}
+
+int
+clog_init_fd(int id, int fd)
+{
+ struct clog *logger;
+
+ if (_clog_loggers[id] != NULL) {
+ _clog_err("Logger %d already initialized.\n", id);
+ return 1;
+ }
+
+ logger = (struct clog *) malloc(sizeof(struct clog));
+ if (logger == NULL) {
+ _clog_err("Failed to allocate logger: %s\n", strerror(errno));
+ return 1;
+ }
+
+ logger->level = CLOG_DEBUG;
+ logger->fd = fd;
+ logger->opened = 0;
+ strcpy(logger->fmt, CLOG_DEFAULT_FORMAT);
+ strcpy(logger->date_fmt, CLOG_DEFAULT_DATE_FORMAT);
+ strcpy(logger->time_fmt, CLOG_DEFAULT_TIME_FORMAT);
+
+ _clog_loggers[id] = logger;
+ return 0;
+}
+
+void
+clog_free(int id)
+{
+ if (_clog_loggers[id]) {
+ if (_clog_loggers[id]->opened) {
+ close(_clog_loggers[id]->fd);
+ }
+ free(_clog_loggers[id]);
+ _clog_loggers[id]=NULL;
+ }
+}
+
+int
+clog_set_level(int id, enum clog_level level)
+{
+ if (_clog_loggers[id] == NULL) {
+ return 1;
+ }
+ if ((unsigned) level > CLOG_ERROR) {
+ return 1;
+ }
+ _clog_loggers[id]->level = level;
+ return 0;
+}
+
+int
+clog_set_time_fmt(int id, const char *fmt)
+{
+ struct clog *logger = _clog_loggers[id];
+ if (logger == NULL) {
+ _clog_err("clog_set_time_fmt: No such logger: %d\n", id);
+ return 1;
+ }
+ if (strlen(fmt) >= CLOG_FORMAT_LENGTH) {
+ _clog_err("clog_set_time_fmt: Format specifier too long.\n");
+ return 1;
+ }
+ strcpy(logger->time_fmt, fmt);
+ return 0;
+}
+
+int
+clog_set_date_fmt(int id, const char *fmt)
+{
+ struct clog *logger = _clog_loggers[id];
+ if (logger == NULL) {
+ _clog_err("clog_set_date_fmt: No such logger: %d\n", id);
+ return 1;
+ }
+ if (strlen(fmt) >= CLOG_FORMAT_LENGTH) {
+ _clog_err("clog_set_date_fmt: Format specifier too long.\n");
+ return 1;
+ }
+ strcpy(logger->date_fmt, fmt);
+ return 0;
+}
+
+int
+clog_set_fmt(int id, const char *fmt)
+{
+ struct clog *logger = _clog_loggers[id];
+ if (logger == NULL) {
+ _clog_err("clog_set_fmt: No such logger: %d\n", id);
+ return 1;
+ }
+ if (strlen(fmt) >= CLOG_FORMAT_LENGTH) {
+ _clog_err("clog_set_fmt: Format specifier too long.\n");
+ return 1;
+ }
+ strcpy(logger->fmt, fmt);
+ return 0;
+}
+
+/* Internal functions */
+
+size_t
+_clog_append_str(char **dst, char *orig_buf, const char *src, size_t cur_size)
+{
+ size_t new_size = cur_size;
+
+ while (strlen(*dst) + strlen(src) >= new_size) {
+ new_size *= 2;
+ }
+ if (new_size != cur_size) {
+ if (*dst == orig_buf) {
+ *dst = (char *) malloc(new_size);
+ strcpy(*dst, orig_buf);
+ } else {
+ *dst = (char *) realloc(*dst, new_size);
+ }
+ }
+
+ strcat(*dst, src);
+ return new_size;
+}
+
+size_t
+_clog_append_int(char **dst, char *orig_buf, long int d, size_t cur_size)
+{
+ char buf[40]; /* Enough for 128-bit decimal */
+ if (snprintf(buf, 40, "%ld", d) >= 40) {
+ return cur_size;
+ }
+ return _clog_append_str(dst, orig_buf, buf, cur_size);
+}
+
+size_t
+_clog_append_time(char **dst, char *orig_buf, struct tm *lt,
+ const char *fmt, size_t cur_size)
+{
+ char buf[CLOG_DATETIME_LENGTH];
+ size_t result = strftime(buf, CLOG_DATETIME_LENGTH, fmt, lt);
+
+ if (result > 0) {
+ return _clog_append_str(dst, orig_buf, buf, cur_size);
+ }
+
+ return cur_size;
+}
+
+const char *
+_clog_basename(const char *path)
+{
+ const char *slash = strrchr(path, '/');
+ if (slash) {
+ path = slash + 1;
+ }
+#ifdef _WIN32
+ slash = strrchr(path, '\\');
+ if (slash) {
+ path = slash + 1;
+ }
+#endif
+ return path;
+}
+
+char *
+_clog_format(const struct clog *logger, char buf[], size_t buf_size,
+ const char *sfile, int sline, const char *level,
+ const char *message)
+{
+ size_t cur_size = buf_size;
+ char *result = buf;
+ enum { NORMAL, SUBST } state = NORMAL;
+ size_t fmtlen = strlen(logger->fmt);
+ size_t i;
+ time_t t = time(NULL);
+ struct tm *lt = localtime(&t);
+
+ sfile = _clog_basename(sfile);
+ result[0] = 0;
+ for (i = 0; i < fmtlen; ++i) {
+ if (state == NORMAL) {
+ if (logger->fmt[i] == '%') {
+ state = SUBST;
+ } else {
+ char str[2] = { 0 };
+ str[0] = logger->fmt[i];
+ cur_size = _clog_append_str(&result, buf, str, cur_size);
+ }
+ } else {
+ switch (logger->fmt[i]) {
+ case '%':
+ cur_size = _clog_append_str(&result, buf, "%", cur_size);
+ break;
+ case 't':
+ cur_size = _clog_append_time(&result, buf, lt,
+ logger->time_fmt, cur_size);
+ break;
+ case 'd':
+ cur_size = _clog_append_time(&result, buf, lt,
+ logger->date_fmt, cur_size);
+ break;
+ case 'l':
+ cur_size = _clog_append_str(&result, buf, level, cur_size);
+ break;
+ case 'n':
+ cur_size = _clog_append_int(&result, buf, sline, cur_size);
+ break;
+ case 'f':
+ cur_size = _clog_append_str(&result, buf, sfile, cur_size);
+ break;
+ case 'm':
+ cur_size = _clog_append_str(&result, buf, message,
+ cur_size);
+ break;
+ }
+ state = NORMAL;
+ }
+ }
+
+ return result;
+}
+
+void
+_clog_log(const char *sfile, int sline, enum clog_level level,
+ int id, const char *fmt, va_list ap)
+{
+ /* For speed: Use a stack buffer until message exceeds 4096, then switch
+ * to dynamically allocated. This should greatly reduce the number of
+ * memory allocations (and subsequent fragmentation). */
+ char buf[4096];
+ size_t buf_size = 4096;
+ char *dynbuf = buf;
+ char *message;
+ int result;
+ struct clog *logger = _clog_loggers[id];
+
+ if (!logger) {
+ _clog_err("No such logger: %d\n", id);
+ return;
+ }
+
+ if (level < logger->level) {
+ return;
+ }
+
+ /* Format the message text with the argument list. */
+ result = vsnprintf(dynbuf, buf_size, fmt, ap);
+ if ((size_t) result >= buf_size) {
+ buf_size = result + 1;
+ dynbuf = (char *) malloc(buf_size);
+ result = vsnprintf(dynbuf, buf_size, fmt, ap);
+ if ((size_t) result >= buf_size) {
+ /* Formatting failed -- too large */
+ _clog_err("Formatting failed (1).\n");
+ free(dynbuf);
+ return;
+ }
+ }
+
+ /* Format according to log format and write to log */
+ {
+ char message_buf[4096];
+ message = _clog_format(logger, message_buf, 4096, sfile, sline,
+ CLOG_LEVEL_NAMES[level], dynbuf);
+ if (!message) {
+ _clog_err("Formatting failed (2).\n");
+ if (dynbuf != buf) {
+ free(dynbuf);
+ }
+ return;
+ }
+ result = write(logger->fd, message, strlen(message));
+ if (result == -1) {
+ _clog_err("Unable to write to log file: %s\n", strerror(errno));
+ }
+ if (message != message_buf) {
+ free(message);
+ }
+ if (dynbuf != buf) {
+ free(dynbuf);
+ }
+ fsync(logger->fd);
+ }
+}
+
+void
+clog_debug(const char *sfile, int sline, int id, const char *fmt, va_list ap)
+{
+ _clog_log(sfile, sline, CLOG_DEBUG, id, fmt, ap);
+}
+
+void
+clog_info(const char *sfile, int sline, int id, const char *fmt, va_list ap)
+{
+ _clog_log(sfile, sline, CLOG_INFO, id, fmt, ap);
+}
+
+void
+clog_warn(const char *sfile, int sline, int id, const char *fmt, va_list ap)
+{
+ _clog_log(sfile, sline, CLOG_WARN, id, fmt, ap);
+}
+
+void
+clog_error(const char *sfile, int sline, int id, const char *fmt, va_list ap)
+{
+ _clog_log(sfile, sline, CLOG_ERROR, id, fmt, ap);
+}
+
+void
+_clog_err(const char *fmt, ...)
+{
+#ifdef CLOG_SILENT
+ (void) fmt;
+#else
+ va_list ap;
+
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+#endif
+}
+
+#endif /* CLOG_MAIN */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* __CLOG_H__ */
--
cgit v1.2.3
From c5507b6ef2abfab169150528a374526bb348bf62 Mon Sep 17 00:00:00 2001
From: "Daniel M. Pelt" <D.M.Pelt@cwi.nl>
Date: Fri, 13 Mar 2015 12:18:21 +0100
Subject: Adds ASTRA_*** defines for easier logging, and changes internal calls
to these defines
---
include/astra/Logging.h | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
(limited to 'include/astra')
diff --git a/include/astra/Logging.h b/include/astra/Logging.h
index ce777ae..5695663 100644
--- a/include/astra/Logging.h
+++ b/include/astra/Logging.h
@@ -29,7 +29,10 @@ $Id$
#ifndef _INC_ASTRA_LOGGING
#define _INC_ASTRA_LOGGING
-#define ASTRA_LOG(id) __FILE__, __LINE__, id
+#define ASTRA_DEBUG(...) astra::CLogger::debug(__FILE__,__LINE__, __VA_ARGS__)
+#define ASTRA_INFO(...) astra::CLogger::info(__FILE__,__LINE__, __VA_ARGS__)
+#define ASTRA_WARN(...) astra::CLogger::warn(__FILE__,__LINE__, __VA_ARGS__)
+#define ASTRA_ERROR(...) astra::CLogger::error(__FILE__,__LINE__, __VA_ARGS__)
namespace astra
{
--
cgit v1.2.3
From f21700e00e81538d5510973a51b8ae97fb4a24dd Mon Sep 17 00:00:00 2001
From: "Daniel M. Pelt" <D.M.Pelt@cwi.nl>
Date: Fri, 13 Mar 2015 17:12:42 +0100
Subject: Enable logging to Matlab window using callback function
Also introduces a mex initialize function that is called
at the first invocation of any mex method.
---
include/astra/Logging.h | 9 ++++++++-
include/astra/clog.h | 53 +++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 61 insertions(+), 1 deletion(-)
(limited to 'include/astra')
diff --git a/include/astra/Logging.h b/include/astra/Logging.h
index 5695663..e822c24 100644
--- a/include/astra/Logging.h
+++ b/include/astra/Logging.h
@@ -75,7 +75,7 @@ public:
* @param ...
* Any additional format arguments.
*/
- static void debug(const char *sfile, int sline, const char *fmt, ...);
+ static void debug(const char *sfile, int sline, const char *fmt, ...);
static void info(const char *sfile, int sline, const char *fmt, ...);
static void warn(const char *sfile, int sline, const char *fmt, ...);
static void error(const char *sfile, int sline, const char *fmt, ...);
@@ -143,6 +143,13 @@ public:
static void disableScreen();
static void disableFile();
+ /**
+ * Set callback function for logging to screen.
+ * @return whether callback was set succesfully.
+ *
+ */
+ static bool setCallbackScreen(void (*cb)(const char *msg, size_t len));
+
};
}
diff --git a/include/astra/clog.h b/include/astra/clog.h
index 4d8e39d..3b7e18b 100644
--- a/include/astra/clog.h
+++ b/include/astra/clog.h
@@ -231,6 +231,32 @@ int clog_set_date_fmt(int id, const char *fmt);
*/
int clog_set_fmt(int id, const char *fmt);
+/**
+ * Set the callback function.
+ *
+ * @param cb
+ * The new callback function.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_set_cb(int id, void (*cb)(const char *msg, size_t len));
+
+/**
+ * Set the file descriptor.
+ *
+ * @param id
+ * The identifier of the logger.
+ *
+ * @param fd
+ * The new file descriptor.
+ *
+ * @return
+ * Zero on success, non-zero on failure.
+ */
+int clog_set_fd(int id, int fd);
+
+
/*
* No need to read below this point.
*/
@@ -257,6 +283,9 @@ struct clog {
/* Tracks whether the fd needs to be closed eventually. */
int opened;
+
+ /* Callback function for each log message. */
+ void (*cb)(const char *msg, size_t len);
};
void _clog_err(const char *fmt, ...);
@@ -314,6 +343,7 @@ clog_init_fd(int id, int fd)
strcpy(logger->fmt, CLOG_DEFAULT_FORMAT);
strcpy(logger->date_fmt, CLOG_DEFAULT_DATE_FORMAT);
strcpy(logger->time_fmt, CLOG_DEFAULT_TIME_FORMAT);
+ logger->cb = NULL;
_clog_loggers[id] = logger;
return 0;
@@ -344,6 +374,16 @@ clog_set_level(int id, enum clog_level level)
return 0;
}
+int
+clog_set_fd(int id, int fd)
+{
+ if (_clog_loggers[id] == NULL) {
+ return 1;
+ }
+ _clog_loggers[id]->fd = fd;
+ return 0;
+}
+
int
clog_set_time_fmt(int id, const char *fmt)
{
@@ -392,6 +432,18 @@ clog_set_fmt(int id, const char *fmt)
return 0;
}
+int
+clog_set_cb(int id, void (*cb)(const char *msg, size_t len))
+{
+ struct clog *logger = _clog_loggers[id];
+ if (logger == NULL) {
+ _clog_err("clog_set_cb: No such logger: %d\n", id);
+ return 1;
+ }
+ logger->cb = cb;
+ return 0;
+}
+
/* Internal functions */
size_t
@@ -563,6 +615,7 @@ _clog_log(const char *sfile, int sline, enum clog_level level,
return;
}
result = write(logger->fd, message, strlen(message));
+ if (logger->cb) logger->cb(message,strlen(message));
if (result == -1) {
_clog_err("Unable to write to log file: %s\n", strerror(errno));
}
--
cgit v1.2.3
From 35fadf8641b05d357a37e8098b9a801ba0e815b9 Mon Sep 17 00:00:00 2001
From: "Daniel M. Pelt" <D.M.Pelt@cwi.nl>
Date: Fri, 13 Mar 2015 17:22:41 +0100
Subject: Use a less verbose default fmt for screen logging and cleaner
messages
---
include/astra/clog.h | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
(limited to 'include/astra')
diff --git a/include/astra/clog.h b/include/astra/clog.h
index 3b7e18b..ce082df 100644
--- a/include/astra/clog.h
+++ b/include/astra/clog.h
@@ -299,10 +299,10 @@ extern struct clog *_clog_loggers[CLOG_MAX_LOGGERS];
#ifdef CLOG_MAIN
const char *const CLOG_LEVEL_NAMES[] = {
- "DEBUG",
- "INFO",
- "WARN",
- "ERROR",
+ "Debug",
+ "Info",
+ "Warning",
+ "Error",
};
int
--
cgit v1.2.3
From d1ad446669cea2a76d7146023e4862a1fdbf3e13 Mon Sep 17 00:00:00 2001
From: Willem Jan Palenstijn <Willem.Jan.Palenstijn@cwi.nl>
Date: Thu, 19 Mar 2015 16:47:23 +0100
Subject: Fix windows build
---
include/astra/Logging.h | 4 +++-
include/astra/clog.h | 11 +++++++++++
2 files changed, 14 insertions(+), 1 deletion(-)
(limited to 'include/astra')
diff --git a/include/astra/Logging.h b/include/astra/Logging.h
index e822c24..8e19ea4 100644
--- a/include/astra/Logging.h
+++ b/include/astra/Logging.h
@@ -29,6 +29,8 @@ $Id$
#ifndef _INC_ASTRA_LOGGING
#define _INC_ASTRA_LOGGING
+#include "astra/Globals.h"
+
#define ASTRA_DEBUG(...) astra::CLogger::debug(__FILE__,__LINE__, __VA_ARGS__)
#define ASTRA_INFO(...) astra::CLogger::info(__FILE__,__LINE__, __VA_ARGS__)
#define ASTRA_WARN(...) astra::CLogger::warn(__FILE__,__LINE__, __VA_ARGS__)
@@ -44,7 +46,7 @@ enum log_level {
LOG_ERROR
};
-class CLogger
+class _AstraExport CLogger
{
CLogger();
~CLogger();
diff --git a/include/astra/clog.h b/include/astra/clog.h
index ce082df..c0cbae4 100644
--- a/include/astra/clog.h
+++ b/include/astra/clog.h
@@ -71,7 +71,15 @@
#include <stdio.h>
#include <string.h>
#include <time.h>
+#ifndef _MSC_VER
#include <unistd.h>
+#else
+#include <io.h>
+#define open _open
+#define close _close
+#define write _write
+#define snprintf _snprintf
+#endif
/* Number of loggers that can be defined. */
#define CLOG_MAX_LOGGERS 16
@@ -625,7 +633,10 @@ _clog_log(const char *sfile, int sline, enum clog_level level,
if (dynbuf != buf) {
free(dynbuf);
}
+#ifndef _MSC_VER
+ // FIXME
fsync(logger->fd);
+#endif
}
}
--
cgit v1.2.3
From 9ba78fcfa3dec88928df33be26821e3fd5a10727 Mon Sep 17 00:00:00 2001
From: Willem Jan Palenstijn <Willem.Jan.Palenstijn@cwi.nl>
Date: Fri, 20 Mar 2015 14:57:59 +0100
Subject: Use FlushFileBuffers in Windows
---
include/astra/clog.h | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
(limited to 'include/astra')
diff --git a/include/astra/clog.h b/include/astra/clog.h
index c0cbae4..6ffb660 100644
--- a/include/astra/clog.h
+++ b/include/astra/clog.h
@@ -74,6 +74,8 @@
#ifndef _MSC_VER
#include <unistd.h>
#else
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
#include <io.h>
#define open _open
#define close _close
@@ -634,8 +636,13 @@ _clog_log(const char *sfile, int sline, enum clog_level level,
free(dynbuf);
}
#ifndef _MSC_VER
- // FIXME
fsync(logger->fd);
+#else
+ HANDLE h = (HANDLE) _get_osfhandle(logger->fd);
+ if (h != INVALID_HANDLE_VALUE) {
+ // This call will fail on a console fd, but that's ok.
+ FlushFileBuffers(h);
+ }
#endif
}
}
--
cgit v1.2.3
From 1b32573046f33050b9300324e6c74e10abb6caaf Mon Sep 17 00:00:00 2001
From: "Daniel M. Pelt" <D.M.Pelt@cwi.nl>
Date: Thu, 9 Apr 2015 15:44:01 +0200
Subject: Add 'link' feature to Python (for 2D and 3D data)
---
include/astra/Float32ProjectionData2D.h | 25 +++++++++++++++++++++++++
include/astra/Float32VolumeData2D.h | 25 +++++++++++++++++++++++++
2 files changed, 50 insertions(+)
(limited to 'include/astra')
diff --git a/include/astra/Float32ProjectionData2D.h b/include/astra/Float32ProjectionData2D.h
index 7461491..bb99f4b 100644
--- a/include/astra/Float32ProjectionData2D.h
+++ b/include/astra/Float32ProjectionData2D.h
@@ -101,6 +101,19 @@ public:
* Copy constructor
*/
CFloat32ProjectionData2D(const CFloat32ProjectionData2D& _other);
+
+ /** Constructor. Create an instance of the CFloat32ProjectionData2D class with pre-allocated memory.
+ *
+ * Creates an instance of the CFloat32ProjectionData2D class. Memory
+ * is pre-allocated and passed via the abstract CFloat32CustomMemory handle
+ * class. The handle will be deleted when the memory can be freed.
+ * You should override the destructor to provide custom behaviour on free.
+ *
+ * @param _pGeometry Projection Geometry object. This object will be HARDCOPIED into this class.
+ * @param _pCustomMemory custom memory handle
+ *
+ */
+ CFloat32ProjectionData2D(CProjectionGeometry2D* _pGeometry, CFloat32CustomMemory* _pCustomMemory);
/**
* Assignment operator
@@ -148,6 +161,18 @@ public:
* @param _fScalar scalar value to be put at each index.
*/
bool initialize(CProjectionGeometry2D* _pGeometry, float32 _fScalar);
+
+ /** Initialization. Initializes an instance of the CFloat32ProjectionData2D class with pre-allocated memory.
+ *
+ * Memory is pre-allocated and passed via the abstract CFloat32CustomMemory handle
+ * class. The handle will be deleted when the memory can be freed.
+ * You should override the destructor to provide custom behaviour on free.
+ *
+ * @param _pGeometry Projection Geometry object. This object will be HARDCOPIED into this class.
+ * @param _pCustomMemory custom memory handle
+ *
+ */
+ bool initialize(CProjectionGeometry2D* _pGeometry, CFloat32CustomMemory* _pCustomMemory);
/** Get the number of detectors.
*
diff --git a/include/astra/Float32VolumeData2D.h b/include/astra/Float32VolumeData2D.h
index 4f44a8c..abecebf 100644
--- a/include/astra/Float32VolumeData2D.h
+++ b/include/astra/Float32VolumeData2D.h
@@ -92,6 +92,19 @@ public:
* Copy constructor
*/
CFloat32VolumeData2D(const CFloat32VolumeData2D& _other);
+
+ /** Constructor. Create an instance of the CFloat32VolumeData2D class with pre-allocated memory.
+ *
+ * Creates an instance of the CFloat32VolumeData2D class. Memory
+ * is pre-allocated and passed via the abstract CFloat32CustomMemory handle
+ * class. The handle will be deleted when the memory can be freed.
+ * You should override the destructor to provide custom behaviour on free.
+ *
+ * @param _pGeometry Volume Geometry object. This object will be HARDCOPIED into this class.
+ * @param _pCustomMemory custom memory handle
+ *
+ */
+ CFloat32VolumeData2D(CVolumeGeometry2D* _pGeometry, CFloat32CustomMemory* _pCustomMemory);
/**
* Assignment operator
@@ -132,6 +145,18 @@ public:
* @param _fScalar scalar value to be put at each index.
*/
bool initialize(CVolumeGeometry2D* _pGeometry, float32 _fScalar);
+
+ /** Initialization. Initializes an instance of the CFloat32VolumeData2D class with pre-allocated memory.
+ *
+ * Memory is pre-allocated and passed via the abstract CFloat32CustomMemory handle
+ * class. The handle will be deleted when the memory can be freed.
+ * You should override the destructor to provide custom behaviour on free.
+ *
+ * @param _pGeometry Volume Geometry object. This object will be HARDCOPIED into this class.
+ * @param _pCustomMemory custom memory handle
+ *
+ */
+ bool initialize(CVolumeGeometry2D* _pGeometry, CFloat32CustomMemory* _pCustomMemory);
/** Destructor.
*/
--
cgit v1.2.3
From 7b55ee5f60c5f5865726cf48636b642cd9de111d Mon Sep 17 00:00:00 2001
From: Willem Jan Palenstijn <Willem.Jan.Palenstijn@cwi.nl>
Date: Fri, 10 Apr 2015 12:29:22 +0200
Subject: Add changeGeometry function to Data3D classes
---
include/astra/Float32ProjectionData3D.h | 5 +++++
include/astra/Float32VolumeData3D.h | 5 +++++
2 files changed, 10 insertions(+)
(limited to 'include/astra')
diff --git a/include/astra/Float32ProjectionData3D.h b/include/astra/Float32ProjectionData3D.h
index 79b762e..329c9a4 100644
--- a/include/astra/Float32ProjectionData3D.h
+++ b/include/astra/Float32ProjectionData3D.h
@@ -196,6 +196,11 @@ public:
* @return pointer to projection geometry.
*/
virtual CProjectionGeometry3D* getGeometry() const;
+
+ /** Change the projection geometry.
+ * Note that this can't change the dimensions of the data.
+ */
+ virtual void changeGeometry(CProjectionGeometry3D* pGeometry);
};
diff --git a/include/astra/Float32VolumeData3D.h b/include/astra/Float32VolumeData3D.h
index d8f0ae9..07df78f 100644
--- a/include/astra/Float32VolumeData3D.h
+++ b/include/astra/Float32VolumeData3D.h
@@ -214,6 +214,11 @@ public:
* @return The geometry describing the data stored in this volume
*/
virtual CVolumeGeometry3D* getGeometry() const;
+
+ /** Change the projection geometry.
+ * Note that this can't change the dimensions of the data.
+ */
+ virtual void changeGeometry(CVolumeGeometry3D* pGeometry);
};
//----------------------------------------------------------------------------------------
--
cgit v1.2.3