Use new logging API internally instead of printf / iostream

4 files changed, 31 insertions, 24 deletions

diff --git a/cuda/2d/astra.cu b/cuda/2d/astra.cu
index bcc1a50..71fd089 100644
--- a/cuda/2d/astra.cu
+++ b/cuda/2d/astra.cu
@@ -47,6 +47,8 @@ $Id$
 #include "../../include/astra/FanFlatProjectionGeometry2D.h"
 #include "../../include/astra/FanFlatVecProjectionGeometry2D.h"
 
+#include "../../include/astra/Logging.h"
+
 // For fan beam FBP weighting
 #include "../3d/fdk.h"
 
@@ -562,7 +564,7 @@ bool AstraFBP::setFilter(E_FBPFILTER _eFilter, const float * _pfHostFilter /* =
 		}
 		default:
 		{
-			fprintf(stderr, "AstraFBP::setFilter: Unknown filter type requested");
+			astra::CLogger::error(__FILE__,__LINE__,"AstraFBP::setFilter: Unknown filter type requested");
 			delete [] pHostFilter;
 			return false;
 		}
diff --git a/cuda/2d/fft.cu b/cuda/2d/fft.cu
index 5fef360..468c7c2 100644
--- a/cuda/2d/fft.cu
+++ b/cuda/2d/fft.cu
@@ -34,6 +34,7 @@ $Id$
 #include <cuda.h>
 #include <fstream>
 
+#include "../../include/astra/Logging.h"
 
 using namespace astra;
 
@@ -42,22 +43,22 @@ using namespace astra;
 #define CHECK_ERROR(errorMessage) do {                                     \
   cudaError_t err = cudaThreadSynchronize();                               \
   if( cudaSuccess != err) {                                                \
-      fprintf(stderr, "Cuda error: %s in file '%s' in line %i : %s.\n",    \
-              errorMessage, __FILE__, __LINE__, cudaGetErrorString( err) );\
+      astra::CLogger::error(__FILE__,__LINE__,"Cuda error %s : %s",        \
+              errorMessage,cudaGetErrorString( err));                      \
       exit(EXIT_FAILURE);                                                  \
   } } while (0)
 
 #define SAFE_CALL( call) do {                                              \
   cudaError err = call;                                                    \
   if( cudaSuccess != err) {                                                \
-      fprintf(stderr, "Cuda error in file '%s' in line %i : %s.\n",        \
-              __FILE__, __LINE__, cudaGetErrorString( err) );              \
+      astra::CLogger::error(__FILE__,__LINE__,"Cuda error: %s ",           \
+              cudaGetErrorString( err));                                   \
       exit(EXIT_FAILURE);                                                  \
   }                                                                        \
   err = cudaThreadSynchronize();                                           \
   if( cudaSuccess != err) {                                                \
-      fprintf(stderr, "Cuda error in file '%s' in line %i : %s.\n",        \
-              __FILE__, __LINE__, cudaGetErrorString( err) );              \
+      astra::CLogger::error(__FILE__,__LINE__,"Cuda error: %s : ",         \
+              cudaGetErrorString( err));                                   \
       exit(EXIT_FAILURE);                                                  \
   } } while (0)
 
@@ -136,7 +137,7 @@ static bool invokeCudaFFT(int _iProjectionCount, int _iDetectorCount,
 	result = cufftPlan1d(&plan, _iDetectorCount, CUFFT_R2C, _iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-		std::cerr << "Failed to plan 1d r2c fft" << std::endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d r2c fft");
 		return false;
 	}
 
@@ -145,7 +146,7 @@ static bool invokeCudaFFT(int _iProjectionCount, int _iDetectorCount,
 
 	if(result != CUFFT_SUCCESS)
 	{
-		std::cerr << "Failed to exec 1d r2c fft" << std::endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d r2c fft");
 		return false;
 	}
 
@@ -162,7 +163,7 @@ static bool invokeCudaIFFT(int _iProjectionCount, int _iDetectorCount,
 	result = cufftPlan1d(&plan, _iDetectorCount, CUFFT_C2R, _iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-		std::cerr << "Failed to plan 1d c2r fft" << std::endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d c2r fft");
 		return false;
 	}
 
@@ -173,7 +174,7 @@ static bool invokeCudaIFFT(int _iProjectionCount, int _iDetectorCount,
 
 	if(result != CUFFT_SUCCESS)
 	{
-		std::cerr << "Failed to exec 1d c2r fft" << std::endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d c2r fft");
 		return false;
 	}
 
@@ -629,7 +630,7 @@ void genFilter(E_FBPFILTER _eFilter, float _fD, int _iProjectionCount,
 		}
 		default:
 		{
-			std::cerr << "Cannot serve requested filter" << std::endl;
+      astra::CLogger::error(__FILE__,__LINE__,"Cannot serve requested filter");
 		}
 	}
 
@@ -763,13 +764,13 @@ void testCudaFFT()
 	result = cufftPlan1d(&plan, iDetectorCount, CUFFT_R2C, iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-		cerr << "Failed to plan 1d r2c fft" << endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d r2c fft");
 	}
 
 	result = cufftExecR2C(plan, pfDevProj, pDevFourProj);
 	if(result != CUFFT_SUCCESS)
 	{
-		cerr << "Failed to exec 1d r2c fft" << endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d r2c fft");
 	}
 
 	cufftDestroy(plan);
@@ -793,13 +794,13 @@ void testCudaFFT()
 	result = cufftPlan1d(&plan, iDetectorCount, CUFFT_C2R, iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-		cerr << "Failed to plan 1d c2r fft" << endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d c2r fft");
 	}
 
 	result = cufftExecC2R(plan, pDevFourProj, pfDevInFourProj);
 	if(result != CUFFT_SUCCESS)
 	{
-		cerr << "Failed to exec 1d c2r fft" << endl;
+    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d c2r fft");
 	}
 
 	cufftDestroy(plan);
diff --git a/cuda/2d/util.cu b/cuda/2d/util.cu
index 81e368f..6ced557 100644
--- a/cuda/2d/util.cu
+++ b/cuda/2d/util.cu
@@ -30,6 +30,8 @@ $Id$
 #include <cassert>
 #include "util.h"
 
+#include "../../include/astra/Logging.h"
+
 namespace astraCUDA {
 
 bool copyVolumeToDevice(const float* in_data, unsigned int in_pitch,
@@ -91,7 +93,7 @@ bool allocateVolume(float*& ptr, unsigned int width, unsigned int height, unsign
 	cudaError_t ret = cudaMallocPitch((void**)&ptr, &p, sizeof(float)*width, height);
 	if (ret != cudaSuccess) {
 		reportCudaError(ret);
-		fprintf(stderr, "Failed to allocate %dx%d GPU buffer\n", width, height);
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%d GPU buffer", width, height);
 		return false;
 	}
 
@@ -259,7 +261,7 @@ bool cudaTextForceKernelsCompletion()
 	cudaError_t returnedCudaError = cudaThreadSynchronize();
 
 	if(returnedCudaError != cudaSuccess) {
-		fprintf(stderr, "Failed to force completion of cuda kernels: %d: %s.\n", returnedCudaError, cudaGetErrorString(returnedCudaError));
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to force completion of cuda kernels: %d: %s.", returnedCudaError, cudaGetErrorString(returnedCudaError));
 		return false;
 	}
 
@@ -269,7 +271,7 @@ bool cudaTextForceKernelsCompletion()
 void reportCudaError(cudaError_t err)
 {
 	if(err != cudaSuccess)
-		fprintf(stderr, "CUDA error %d: %s.\n", err, cudaGetErrorString(err));
+		astra::CLogger::error(__FILE__,__LINE__,"CUDA error %d: %s.", err, cudaGetErrorString(err));
 }
 
 
diff --git a/cuda/3d/util3d.cu b/cuda/3d/util3d.cu
index d85a928..f2d16b3 100644
--- a/cuda/3d/util3d.cu
+++ b/cuda/3d/util3d.cu
@@ -31,6 +31,8 @@ $Id$
 #include "util3d.h"
 #include "../2d/util.h"
 
+#include "../../include/astra/Logging.h"
+
 namespace astraCUDA3d {
 
 
@@ -46,7 +48,7 @@ cudaPitchedPtr allocateVolumeData(const SDimensions3D& dims)
 	cudaError err = cudaMalloc3D(&volData, extentV);
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		fprintf(stderr, "Failed to allocate %dx%dx%d GPU buffer\n", dims.iVolX, dims.iVolY, dims.iVolZ);
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU buffer", dims.iVolX, dims.iVolY, dims.iVolZ);
 		volData.ptr = 0;
 		// TODO: return 0 somehow?
 	}
@@ -65,7 +67,7 @@ cudaPitchedPtr allocateProjectionData(const SDimensions3D& dims)
 	cudaError err = cudaMalloc3D(&projData, extentP);
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		fprintf(stderr, "Failed to allocate %dx%dx%d GPU buffer\n", dims.iProjU, dims.iProjAngles, dims.iProjV);
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU buffer", dims.iProjU, dims.iProjAngles, dims.iProjV);
 		projData.ptr = 0;
 		// TODO: return 0 somehow?
 	}
@@ -303,7 +305,7 @@ cudaArray* allocateVolumeArray(const SDimensions3D& dims)
 	cudaError err = cudaMalloc3DArray(&cuArray, &channelDesc, extentA);
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		fprintf(stderr, "Failed to allocate %dx%dx%d GPU array\n", dims.iVolX, dims.iVolY, dims.iVolZ);
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU array", dims.iVolX, dims.iVolY, dims.iVolZ);
 		return 0;
 	}
 
@@ -321,7 +323,7 @@ cudaArray* allocateProjectionArray(const SDimensions3D& dims)
 
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		fprintf(stderr, "Failed to allocate %dx%dx%d GPU array\n", dims.iProjU, dims.iProjAngles, dims.iProjV);
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU array", dims.iProjU, dims.iProjAngles, dims.iProjV);
 		return 0;
 	}
 
@@ -397,7 +399,7 @@ bool cudaTextForceKernelsCompletion()
 	cudaError_t returnedCudaError = cudaThreadSynchronize();
 
 	if(returnedCudaError != cudaSuccess) {
-		fprintf(stderr, "Failed to force completion of cuda kernels: %d: %s.\n", returnedCudaError, cudaGetErrorString(returnedCudaError));
+		astra::CLogger::error(__FILE__,__LINE__,"Failed to force completion of cuda kernels: %d: %s.", returnedCudaError, cudaGetErrorString(returnedCudaError));
 		return false;
 	}