FreeImageStack::FreeImageStack(const std::string & rFileName,
unsigned int nWidth, unsigned int nHeight): sFileName_(rFileName)
, pImageStack_(0)
, nWidth_(nWidth)
, nHeight_(nHeight)
, pBitmap_32f_(0)
, nMaxXY_(0)
, nMaxOffset_(0)
{
// open the bitmap
pImageStack_ = FreeImage_OpenMultiBitmap(FIF_TIFF, (sFileName_ + "3D.tif").c_str(),
TRUE, // create new
FALSE, // open read-write
FALSE, // keep all slices in memory
TIFF_DEFAULT);
NPP_ASSERT_NOT_NULL(pImageStack_);
pBitmap_32f_ = FreeImage_AllocateT(FIT_FLOAT,
nWidth_, nHeight_,
32 /* bits per pixel */);
NPP_ASSERT_NOT_NULL(pBitmap_32f_);
nMaxXY_ = std::min(nWidth_, nHeight_);
nMaxOffset_ = static_cast<unsigned int>(sqrt(2 * static_cast<double>(nMaxXY_-1) * static_cast<double>(nMaxXY_-1)));
aTimeStepAverages_.reserve(512);
}
FreeImageStack::FreeImageStack(const std::string & rFileName): sFileName_(rFileName)
, pImageStack_(0)
, nWidth_(0)
, nHeight_(0)
, pBitmap_32f_(0)
, nMaxXY_(0)
, nMaxOffset_(0)
{
// open the bitmap
pImageStack_ = FreeImage_OpenMultiBitmap(FIF_TIFF, (sFileName_ + ".tif").c_str(),
FALSE, // create new
TRUE, // open read-only
FALSE, // keep all slices in memory
TIFF_DEFAULT);
NPP_ASSERT_NOT_NULL(pImageStack_);
NPP_ASSERT_NOT_NULL(slices());
FIBITMAP * pBitmap = FreeImage_LockPage(pImageStack_, 0);
// store away the size of the first image
// this information is later used to insure that all slices
// accessed are of the same size. if they are not an exception
// is thrown when such a deviating slice is being accessed
nWidth_ = FreeImage_GetWidth(pBitmap);
nHeight_ = FreeImage_GetHeight(pBitmap);
NPP_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);
NPP_ASSERT(FreeImage_GetBPP(pBitmap) == 8);
FreeImage_UnlockPage(pImageStack_, pBitmap, FALSE);
}
void
FreeImageStack::loadImage(unsigned int iSlice, npp::ImageNPP_8u_C1 & rImage)
const
{
NPP_ASSERT_MSG(iSlice < slices(), "Slice index exceeded number of slices in stack.");
FIBITMAP * pBitmap = FreeImage_LockPage(pImageStack_, iSlice);
NPP_ASSERT_NOT_NULL(pBitmap);
// make sure this is an 8-bit single channel image
NPP_DEBUG_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);
NPP_DEBUG_ASSERT(FreeImage_GetBPP(pBitmap) == 8);
NPP_DEBUG_ASSERT(FreeImage_GetWidth(pBitmap) == nWidth_);
NPP_DEBUG_ASSERT(FreeImage_GetHeight(pBitmap) == nHeight_);
unsigned int nSrcPitch = FreeImage_GetPitch(pBitmap);
unsigned char * pSrcData = FreeImage_GetBits(pBitmap);
if (rImage.width() == nWidth_ && rImage.height() == nHeight_)
{
NPP_CHECK_CUDA(cudaMemcpy2D(rImage.data(), rImage.pitch(), pSrcData, nSrcPitch,
nWidth_, nHeight_, cudaMemcpyHostToDevice));
}
else
{
// create new NPP image
npp::ImageNPP_8u_C1 oImage(nWidth_, nHeight_);
// transfer slice data into new device image
NPP_CHECK_CUDA(cudaMemcpy2D(oImage.data(), oImage.pitch(), pSrcData, nSrcPitch,
nWidth_, nHeight_, cudaMemcpyHostToDevice));
// swap the result image with the reference passed into this method
rImage.swap(oImage);
}
// release locked slice
FreeImage_UnlockPage(pImageStack_, pBitmap, FALSE);
}
// Save a gray-scale image to disk.
void
saveImage(const std::string & rFileName, const ImageCPU_8u_C1 & rImage)
{
// create the result image storage using FreeImage so we can easily
// save
FIBITMAP * pResultBitmap = FreeImage_Allocate(rImage.width(), rImage.height(), 8 /* bits per pixel */);
NPP_ASSERT_NOT_NULL(pResultBitmap);
unsigned int nDstPitch = FreeImage_GetPitch(pResultBitmap);
Npp8u * pDstLine = FreeImage_GetBits(pResultBitmap) + nDstPitch * (rImage.height()-1);
const Npp8u * pSrcLine = rImage.data();
unsigned int nSrcPitch = rImage.pitch();
for (size_t iLine = 0; iLine < rImage.height(); ++iLine)
{
memcpy(pDstLine, pSrcLine, rImage.width() * sizeof(Npp8u));
pSrcLine += nSrcPitch;
pDstLine -= nDstPitch;
}
// now save the result image
bool bSuccess;
bSuccess = FreeImage_Save(FIF_PGM, pResultBitmap, rFileName.c_str(), 0) == TRUE;
NPP_ASSERT_MSG(bSuccess, "Failed to save result image.");
}
int
main(int argc, char *argv[])
{
printf("%s Starting...\n\n", argv[0]);
try
{
std::string sFilename;
char *filePath = sdkFindFilePath("Lena.pgm", argv[0]);
if (filePath)
{
sFilename = filePath;
}
else
{
printf("Error unable to find Lena.pgm\n");
exit(EXIT_FAILURE);
}
// set your own FreeImage error handler
FreeImage_SetOutputMessage(FreeImageErrorHandler);
cudaDeviceInit(argc, (const char **)argv);
// Min spec is SM 1.0 devices
if (printfNPPinfo(argc, argv, 1, 0) == false)
{
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
if (argc > 1)
{
sFilename = argv[1];
}
// if we specify the filename at the command line, then we only test sFilename
// otherwise we will check both sFilename[0,1]
int file_errors = 0;
std::ifstream infile(sFilename.data(), std::ifstream::in);
if (infile.good())
{
std::cout << "freeImageInteropNPP opened: <" << sFilename.data() << "> successfully!" << std::endl;
file_errors = 0;
infile.close();
}
else
{
std::cout << "freeImageInteropNPP unable to open: <" << sFilename.data() << ">" << std::endl;
file_errors++;
infile.close();
}
if (file_errors > 0)
{
exit(EXIT_FAILURE);
}
std::string sResultFilename = sFilename;
std::string::size_type dot = sResultFilename.rfind('.');
if (dot != std::string::npos)
{
sResultFilename = sResultFilename.substr(0, dot);
}
sResultFilename += "_boxFilterFII.pgm";
if (argc >= 3)
{
sResultFilename = argv[2];
}
FREE_IMAGE_FORMAT eFormat = FreeImage_GetFileType(sFilename.c_str());
// no signature? try to guess the file format from the file extension
if (eFormat == FIF_UNKNOWN)
{
eFormat = FreeImage_GetFIFFromFilename(sFilename.c_str());
}
NPP_ASSERT(eFormat != FIF_UNKNOWN);
// check that the plugin has reading capabilities ...
FIBITMAP *pBitmap;
if (FreeImage_FIFSupportsReading(eFormat))
{
pBitmap = FreeImage_Load(eFormat, sFilename.c_str());
}
NPP_ASSERT(pBitmap != 0);
// Dump the bitmap information to the console
std::cout << (*pBitmap) << std::endl;
// make sure this is an 8-bit single channel image
NPP_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);
NPP_ASSERT(FreeImage_GetBPP(pBitmap) == 8);
unsigned int nImageWidth = FreeImage_GetWidth(pBitmap);
unsigned int nImageHeight = FreeImage_GetHeight(pBitmap);
unsigned int nSrcPitch = FreeImage_GetPitch(pBitmap);
unsigned char *pSrcData = FreeImage_GetBits(pBitmap);
int nSrcPitchCUDA;
Npp8u *pSrcImageCUDA = nppiMalloc_8u_C1(nImageWidth, nImageHeight, &nSrcPitchCUDA);
NPP_ASSERT_NOT_NULL(pSrcImageCUDA);
// copy image loaded via FreeImage to into CUDA device memory, i.e.
// transfer the image-data up to the GPU's video-memory
NPP_CHECK_CUDA(cudaMemcpy2D(pSrcImageCUDA, nSrcPitchCUDA, pSrcData, nSrcPitch,
nImageWidth, nImageHeight, cudaMemcpyHostToDevice));
// define size of the box filter
const NppiSize oMaskSize = {7, 7};
const NppiPoint oMaskAchnor = {0, 0};
// compute maximal result image size
const NppiSize oSizeROI = {nImageWidth - (oMaskSize.width - 1),
nImageHeight - (oMaskSize.height - 1)
};
// allocate result image memory
int nDstPitchCUDA;
Npp8u *pDstImageCUDA = nppiMalloc_8u_C1(oSizeROI.width, oSizeROI.height, &nDstPitchCUDA);
NPP_ASSERT_NOT_NULL(pDstImageCUDA);
NPP_CHECK_NPP(nppiFilterBox_8u_C1R(pSrcImageCUDA, nSrcPitchCUDA, pDstImageCUDA, nDstPitchCUDA,
oSizeROI, oMaskSize, oMaskAchnor));
// create the result image storage using FreeImage so we can easily
// save
FIBITMAP *pResultBitmap = FreeImage_Allocate(oSizeROI.width, oSizeROI.height, 8 /* bits per pixel */);
NPP_ASSERT_NOT_NULL(pResultBitmap);
unsigned int nResultPitch = FreeImage_GetPitch(pResultBitmap);
unsigned char *pResultData = FreeImage_GetBits(pResultBitmap);
NPP_CHECK_CUDA(cudaMemcpy2D(pResultData, nResultPitch, pDstImageCUDA, nDstPitchCUDA,
oSizeROI.width, oSizeROI.height, cudaMemcpyDeviceToHost));
// now save the result image
bool bSuccess;
bSuccess = FreeImage_Save(FIF_PGM, pResultBitmap, sResultFilename.c_str(), 0) == TRUE;
NPP_ASSERT_MSG(bSuccess, "Failed to save result image.");
//free nppiImage
nppiFree(pSrcImageCUDA);
nppiFree(pDstImageCUDA);
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
catch (npp::Exception &rException)
{
std::cerr << "Program error! The following exception occurred: \n";
std::cerr << rException << std::endl;
std::cerr << "Aborting." << std::endl;
exit(EXIT_FAILURE);
}
catch (...)
{
std::cerr << "Program error! An unknow type of exception occurred. \n";
std::cerr << "Aborting." << std::endl;
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}