Adds ASTRA_*** defines for easier logging, and changes internal calls to these defines

12 files changed, 32 insertions, 29 deletions

diff --git a/cuda/2d/astra.cu b/cuda/2d/astra.cu
index 71fd089..2f72db0 100644
--- a/cuda/2d/astra.cu
+++ b/cuda/2d/astra.cu
@@ -564,7 +564,7 @@ bool AstraFBP::setFilter(E_FBPFILTER _eFilter, const float * _pfHostFilter /* =
 		}
 		default:
 		{
-			astra::CLogger::error(__FILE__,__LINE__,"AstraFBP::setFilter: Unknown filter type requested");
+			ASTRA_ERROR("AstraFBP::setFilter: Unknown filter type requested");
 			delete [] pHostFilter;
 			return false;
 		}
diff --git a/cuda/2d/fft.cu b/cuda/2d/fft.cu
index 468c7c2..49c696c 100644
--- a/cuda/2d/fft.cu
+++ b/cuda/2d/fft.cu
@@ -43,7 +43,7 @@ using namespace astra;
 #define CHECK_ERROR(errorMessage) do {                                     \
   cudaError_t err = cudaThreadSynchronize();                               \
   if( cudaSuccess != err) {                                                \
-      astra::CLogger::error(__FILE__,__LINE__,"Cuda error %s : %s",        \
+      ASTRA_ERROR("Cuda error %s : %s",                                    \
               errorMessage,cudaGetErrorString( err));                      \
       exit(EXIT_FAILURE);                                                  \
   } } while (0)
@@ -51,13 +51,13 @@ using namespace astra;
 #define SAFE_CALL( call) do {                                              \
   cudaError err = call;                                                    \
   if( cudaSuccess != err) {                                                \
-      astra::CLogger::error(__FILE__,__LINE__,"Cuda error: %s ",           \
+      ASTRA_ERROR("Cuda error: %s ",                                       \
               cudaGetErrorString( err));                                   \
       exit(EXIT_FAILURE);                                                  \
   }                                                                        \
   err = cudaThreadSynchronize();                                           \
   if( cudaSuccess != err) {                                                \
-      astra::CLogger::error(__FILE__,__LINE__,"Cuda error: %s : ",         \
+      ASTRA_ERROR("Cuda error: %s : ",                                     \
               cudaGetErrorString( err));                                   \
       exit(EXIT_FAILURE);                                                  \
   } } while (0)
@@ -137,7 +137,7 @@ static bool invokeCudaFFT(int _iProjectionCount, int _iDetectorCount,
 	result = cufftPlan1d(&plan, _iDetectorCount, CUFFT_R2C, _iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d r2c fft");
+        ASTRA_ERROR("Failed to plan 1d r2c fft");
 		return false;
 	}
 
@@ -146,7 +146,7 @@ static bool invokeCudaFFT(int _iProjectionCount, int _iDetectorCount,
 
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d r2c fft");
+        ASTRA_ERROR("Failed to exec 1d r2c fft");
 		return false;
 	}
 
@@ -163,7 +163,7 @@ static bool invokeCudaIFFT(int _iProjectionCount, int _iDetectorCount,
 	result = cufftPlan1d(&plan, _iDetectorCount, CUFFT_C2R, _iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d c2r fft");
+        ASTRA_ERROR("Failed to plan 1d c2r fft");
 		return false;
 	}
 
@@ -174,7 +174,7 @@ static bool invokeCudaIFFT(int _iProjectionCount, int _iDetectorCount,
 
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d c2r fft");
+        ASTRA_ERROR("Failed to exec 1d c2r fft");
 		return false;
 	}
 
@@ -630,7 +630,7 @@ void genFilter(E_FBPFILTER _eFilter, float _fD, int _iProjectionCount,
 		}
 		default:
 		{
-      astra::CLogger::error(__FILE__,__LINE__,"Cannot serve requested filter");
+            ASTRA_ERROR("Cannot serve requested filter");
 		}
 	}
 
@@ -764,13 +764,13 @@ void testCudaFFT()
 	result = cufftPlan1d(&plan, iDetectorCount, CUFFT_R2C, iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d r2c fft");
+        ASTRA_ERROR("Failed to plan 1d r2c fft");
 	}
 
 	result = cufftExecR2C(plan, pfDevProj, pDevFourProj);
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d r2c fft");
+        ASTRA_ERROR("Failed to exec 1d r2c fft");
 	}
 
 	cufftDestroy(plan);
@@ -794,13 +794,13 @@ void testCudaFFT()
 	result = cufftPlan1d(&plan, iDetectorCount, CUFFT_C2R, iProjectionCount);
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to plan 1d c2r fft");
+        ASTRA_ERROR("Failed to plan 1d c2r fft");
 	}
 
 	result = cufftExecC2R(plan, pDevFourProj, pfDevInFourProj);
 	if(result != CUFFT_SUCCESS)
 	{
-    astra::CLogger::error(__FILE__,__LINE__,"Failed to exec 1d c2r fft");
+        ASTRA_ERROR("Failed to exec 1d c2r fft");
 	}
 
 	cufftDestroy(plan);
diff --git a/cuda/2d/util.cu b/cuda/2d/util.cu
index 6ced557..a4f8f3e 100644
--- a/cuda/2d/util.cu
+++ b/cuda/2d/util.cu
@@ -93,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);
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%d GPU buffer", width, height);
+		ASTRA_ERROR("Failed to allocate %dx%d GPU buffer", width, height);
 		return false;
 	}
 
@@ -261,7 +261,7 @@ bool cudaTextForceKernelsCompletion()
 	cudaError_t returnedCudaError = cudaThreadSynchronize();
 
 	if(returnedCudaError != cudaSuccess) {
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to force completion of cuda kernels: %d: %s.", returnedCudaError, cudaGetErrorString(returnedCudaError));
+		ASTRA_ERROR("Failed to force completion of cuda kernels: %d: %s.", returnedCudaError, cudaGetErrorString(returnedCudaError));
 		return false;
 	}
 
@@ -271,7 +271,7 @@ bool cudaTextForceKernelsCompletion()
 void reportCudaError(cudaError_t err)
 {
 	if(err != cudaSuccess)
-		astra::CLogger::error(__FILE__,__LINE__,"CUDA error %d: %s.", err, cudaGetErrorString(err));
+		ASTRA_ERROR("CUDA error %d: %s.", err, cudaGetErrorString(err));
 }
 
 
diff --git a/cuda/3d/util3d.cu b/cuda/3d/util3d.cu
index f2d16b3..537ed69 100644
--- a/cuda/3d/util3d.cu
+++ b/cuda/3d/util3d.cu
@@ -48,7 +48,7 @@ cudaPitchedPtr allocateVolumeData(const SDimensions3D& dims)
 	cudaError err = cudaMalloc3D(&volData, extentV);
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU buffer", dims.iVolX, dims.iVolY, dims.iVolZ);
+		ASTRA_ERROR("Failed to allocate %dx%dx%d GPU buffer", dims.iVolX, dims.iVolY, dims.iVolZ);
 		volData.ptr = 0;
 		// TODO: return 0 somehow?
 	}
@@ -67,7 +67,7 @@ cudaPitchedPtr allocateProjectionData(const SDimensions3D& dims)
 	cudaError err = cudaMalloc3D(&projData, extentP);
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU buffer", dims.iProjU, dims.iProjAngles, dims.iProjV);
+		ASTRA_ERROR("Failed to allocate %dx%dx%d GPU buffer", dims.iProjU, dims.iProjAngles, dims.iProjV);
 		projData.ptr = 0;
 		// TODO: return 0 somehow?
 	}
@@ -305,7 +305,7 @@ cudaArray* allocateVolumeArray(const SDimensions3D& dims)
 	cudaError err = cudaMalloc3DArray(&cuArray, &channelDesc, extentA);
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU array", dims.iVolX, dims.iVolY, dims.iVolZ);
+		ASTRA_ERROR("Failed to allocate %dx%dx%d GPU array", dims.iVolX, dims.iVolY, dims.iVolZ);
 		return 0;
 	}
 
@@ -323,7 +323,7 @@ cudaArray* allocateProjectionArray(const SDimensions3D& dims)
 
 	if (err != cudaSuccess) {
 		astraCUDA::reportCudaError(err);
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to allocate %dx%dx%d GPU array", dims.iProjU, dims.iProjAngles, dims.iProjV);
+		ASTRA_ERROR("Failed to allocate %dx%dx%d GPU array", dims.iProjU, dims.iProjAngles, dims.iProjV);
 		return 0;
 	}
 
@@ -399,7 +399,7 @@ bool cudaTextForceKernelsCompletion()
 	cudaError_t returnedCudaError = cudaThreadSynchronize();
 
 	if(returnedCudaError != cudaSuccess) {
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to force completion of cuda kernels: %d: %s.", returnedCudaError, cudaGetErrorString(returnedCudaError));
+		ASTRA_ERROR("Failed to force completion of cuda kernels: %d: %s.", returnedCudaError, cudaGetErrorString(returnedCudaError));
 		return false;
 	}
 
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
 {
diff --git a/src/ConeProjectionGeometry3D.cpp b/src/ConeProjectionGeometry3D.cpp
index 13f147b..1976901 100644
--- a/src/ConeProjectionGeometry3D.cpp
+++ b/src/ConeProjectionGeometry3D.cpp
@@ -259,7 +259,7 @@ void CConeProjectionGeometry3D::projectPoint(float32 fX, float32 fY, float32 fZ,
 	// Scale fS to detector plane
 	fU = detectorOffsetXToColIndexFloat( (fS * (m_fOriginSourceDistance + m_fOriginDetectorDistance)) / fD );
 
-	astra::CLogger::debug(__FILE__,__LINE__,"alpha: %f, D: %f, V: %f, S: %f, U: %f", alpha, fD, fV, fS, fU);
+	ASTRA_DEBUG("alpha: %f, D: %f, V: %f, S: %f, U: %f", alpha, fD, fV, fS, fU);
 
 }
 
diff --git a/src/Config.cpp b/src/Config.cpp
index 0a85b3c..388cfdf 100644
--- a/src/Config.cpp
+++ b/src/Config.cpp
@@ -149,7 +149,7 @@ bool ConfigStackCheck<T>::stopParsing()
 	if (!errors.empty()) {
 		ostringstream os;
 		os << "Warning: " << name << ": unused configuration options: " << errors;
-		astra::CLogger::warn(__FILE__,__LINE__,os.str().c_str());
+		ASTRA_WARN(os.str().c_str());
 		return false;
 	}
 
diff --git a/src/CudaFilteredBackProjectionAlgorithm.cpp b/src/CudaFilteredBackProjectionAlgorithm.cpp
index 26b848e..0badc20 100644
--- a/src/CudaFilteredBackProjectionAlgorithm.cpp
+++ b/src/CudaFilteredBackProjectionAlgorithm.cpp
@@ -485,7 +485,7 @@ E_FBPFILTER CCudaFilteredBackProjectionAlgorithm::_convertStringToFilter(const c
 	}
 	else
 	{
-		astra::CLogger::error(__FILE__,__LINE__,"Failed to convert \"%s\" into a filter.",_filterType);
+		ASTRA_ERROR("Failed to convert \"%s\" into a filter.",_filterType);
 	}
 
 	return output;
diff --git a/src/CudaForwardProjectionAlgorithm.cpp b/src/CudaForwardProjectionAlgorithm.cpp
index 1ae6b83..19cadd6 100644
--- a/src/CudaForwardProjectionAlgorithm.cpp
+++ b/src/CudaForwardProjectionAlgorithm.cpp
@@ -106,7 +106,7 @@ bool CCudaForwardProjectionAlgorithm::initialize(const Config& _cfg)
 		id = boost::lexical_cast<int>(node->getContent());
 		CProjector2D *projector = CProjector2DManager::getSingleton().get(id);
 		if (!dynamic_cast<CCudaProjector2D*>(projector)) {
-			astra::CLogger::warn(__FILE__,__LINE__,"Warning: non-CUDA Projector2D passed to FP_CUDA");
+			ASTRA_WARN("Warning: non-CUDA Projector2D passed to FP_CUDA");
 		}
 		delete node;
 	}
diff --git a/src/CudaForwardProjectionAlgorithm3D.cpp b/src/CudaForwardProjectionAlgorithm3D.cpp
index 57e1094..8e6bab5 100644
--- a/src/CudaForwardProjectionAlgorithm3D.cpp
+++ b/src/CudaForwardProjectionAlgorithm3D.cpp
@@ -267,7 +267,7 @@ void CCudaForwardProjectionAlgorithm3D::run(int)
 		for (int k = 0; k < 2; ++k) {
 			float fU, fV;
 			projgeom->projectPoint(fX[i], fY[j], fZ[k], a, fU, fV);
-			astra::CLogger::debug(__FILE__,__LINE__,"%3d %c1,%c1,%c1 -> %12f %12f", a, i ? ' ' : '-', j ? ' ' : '-', k ? ' ' : '-', fU, fV);
+			ASTRA_DEBUG("%3d %c1,%c1,%c1 -> %12f %12f", a, i ? ' ' : '-', j ? ' ' : '-', k ? ' ' : '-', fU, fV);
 		}
 	}
 #endif
diff --git a/src/CudaReconstructionAlgorithm2D.cpp b/src/CudaReconstructionAlgorithm2D.cpp
index b434e8a..929f0f1 100644
--- a/src/CudaReconstructionAlgorithm2D.cpp
+++ b/src/CudaReconstructionAlgorithm2D.cpp
@@ -178,7 +178,7 @@ bool CCudaReconstructionAlgorithm2D::initialize(const Config& _cfg)
 		id = boost::lexical_cast<int>(node->getContent());
 		CProjector2D *projector = CProjector2DManager::getSingleton().get(id);
 		if (!dynamic_cast<CCudaProjector2D*>(projector)) {
-			astra::CLogger::warn(__FILE__,__LINE__,"Warning: non-CUDA Projector2D passed");
+			ASTRA_WARN("Warning: non-CUDA Projector2D passed");
 		}
 		delete node;
 	}
diff --git a/src/FilteredBackProjectionAlgorithm.cpp b/src/FilteredBackProjectionAlgorithm.cpp
index 47315bb..4a8e5ac 100644
--- a/src/FilteredBackProjectionAlgorithm.cpp
+++ b/src/FilteredBackProjectionAlgorithm.cpp
@@ -135,7 +135,7 @@ bool CFilteredBackProjectionAlgorithm::initialize(const Config& _cfg)
 		for (int i = 0; i < angleCount; i ++) {
 			if (projectionIndex[i] > m_pProjector->getProjectionGeometry()->getProjectionAngleCount() -1 )
 			{
-				astra::CLogger::error(__FILE__,__LINE__,"Invalid Projection Index");
+				ASTRA_ERROR("Invalid Projection Index");
 				return false;
 			} else {
 				int orgIndex = (int)projectionIndex[i];