自学教程：C++ FreeImage_GetPitch函数代码示例

/**Extract the luminance channel L from a RGBF image. Luminance is calculated from the sRGB model (RGB2XYZ matrix) using a D65 white point : L = ( 0.2126 * r ) + ( 0.7152 * g ) + ( 0.0722 * b )Reference : A Standard Default Color Space for the Internet - sRGB. [online] http://www.w3.org/Graphics/Color/sRGB*/FIBITMAP*  ConvertRGBFToY(FIBITMAP *src) {	if(FreeImage_GetImageType(src) != FIT_RGBF)		return FALSE;	unsigned width  = FreeImage_GetWidth(src);	unsigned height = FreeImage_GetHeight(src);	FIBITMAP *dst = FreeImage_AllocateT(FIT_FLOAT, width, height);	if(!dst) return NULL;	unsigned src_pitch  = FreeImage_GetPitch(src);	unsigned dst_pitch  = FreeImage_GetPitch(dst);		BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);	BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);	for(unsigned y = 0; y < height; y++) {		const FIRGBF *src_pixel = (FIRGBF*)src_bits;		float  *dst_pixel = (float*)dst_bits;		for(unsigned x = 0; x < width; x++) {			float L = 0.2126F * src_pixel[x].red + 0.7152F * src_pixel[x].green + 0.0722F * src_pixel[x].blue;			dst_pixel[x] = (L > 0) ? L : 0;		}		// next line		src_bits += src_pitch;		dst_bits += dst_pitch;	}	return dst;}

/**Red-black Gauss-Seidel relaxation for model problem. Updates the current value of the solutionu[0..n-1][0..n-1], using the right-hand side function rhs[0..n-1][0..n-1].*/static void fmg_relaxation(FIBITMAP *U, FIBITMAP *RHS, int n) {	int row, col, ipass, isw, jsw;	const float h = 1.0F / (n - 1);	const float h2 = h*h;	const int u_pitch  = FreeImage_GetPitch(U) / sizeof(float);	const int rhs_pitch  = FreeImage_GetPitch(RHS) / sizeof(float);		float *u_bits = (float*)FreeImage_GetBits(U);	const float *rhs_bits = (float*)FreeImage_GetBits(RHS);	for (ipass = 0, jsw = 1; ipass < 2; ipass++, jsw = 3-jsw) { // Red and black sweeps		float *u_scan = u_bits + u_pitch;		const float *rhs_scan = rhs_bits + rhs_pitch;		for (row = 1, isw = jsw; row < n-1; row++, isw = 3-isw) {			for (col = isw; col < n-1; col += 2) { 				// Gauss-Seidel formula				// calculate U(row, col) = 				// 0.25 * [ U(row+1, col) + U(row-1, col) + U(row, col+1) + U(row, col-1) - h2 * RHS(row, col) ]		 				float *u_center = u_scan + col;				const float *rhs_center = rhs_scan + col;				*u_center = *(u_center + u_pitch) + *(u_center - u_pitch) + *(u_center + 1) + *(u_center - 1);				*u_center -= h2 * *rhs_center;				*u_center *= 0.25F;			}			u_scan += u_pitch;			rhs_scan += rhs_pitch;		}	}}

	///////////////////////////////////////////////////////////////////////////	///	/// @fn bool glLoadTexture(const std::string& nomFichier, unsigned int& idTexture,	///                        bool genererTexture)	///	/// Cette fonction crée une texture OpenGL à partir d'une image contenu	/// dans un fichier.  FreeImage est utilisée pour lire l'image, donc tous	/// les formats reconnues par cette librairie devraient être supportés.	///	/// @param[in]  nomFichier     : Le nom du fichier image à charger.	/// @param[out] idTexture      : L'identificateur de la texture créée.	/// @param[in]  genererTexture : Doit-on demander à OpenGL de générer un numéro	///										de texture au préalable?	///	/// @return Vrai si le chargement a réussi, faux autrement.	///	///////////////////////////////////////////////////////////////////////////	bool glLoadTexture(const std::string& nomFichier, unsigned int& idTexture, bool genererTexture)	{		// Ce code de lecture générique d'un fichier provient de la		// documentation de FreeImage		FREE_IMAGE_FORMAT format = FIF_UNKNOWN;		// check the file signature and deduce its format		// (the second argument is currently not used by FreeImage)		format = FreeImage_GetFileType(nomFichier.c_str(), 0);		if(format == FIF_UNKNOWN) {			// no signature ?			// try to guess the file format from the file extension			format = FreeImage_GetFIFFromFilename(nomFichier.c_str());		}		// check that the plugin has reading capabilities ...		if((format == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading(format)) {			utilitaire::afficherErreur(				std::string("Format du fichier image /"") +				std::string(nomFichier.c_str()) + std::string("/" non supporté")				);			return false;		}		// ok, let's load the file		FIBITMAP* dib = FreeImage_Load(format, nomFichier.c_str(), 0);		if (dib == 0) {			utilitaire::afficherErreur(				std::string("Erreur à la lecture du fichier /"") +				std::string(nomFichier.c_str()) + std::string("/"")				);			return false;		}		FIBITMAP* dib32 = FreeImage_ConvertTo32Bits(dib);		if (dib32 == 0) {			utilitaire::afficherErreur(				std::string("Incapable de convertir le fichier /"") +				std::string(nomFichier.c_str()) + std::string("/" en 32 bpp.")				);			FreeImage_Unload(dib);			return false;		}		int pitch = FreeImage_GetPitch(dib32);		glCreateTexture(			FreeImage_GetBits(dib32),			FreeImage_GetWidth(dib32),			FreeImage_GetHeight(dib32),			FreeImage_GetBPP(dib32),			FreeImage_GetPitch(dib32),			idTexture,			genererTexture			);		FreeImage_Unload(dib32);		FreeImage_Unload(dib);		return true;	}

double ApplyCurve(FIBITMAP *src, FIBITMAP *dst, std::vector<cp> ctpts, int threadcount){    _mark();    unsigned spitch = FreeImage_GetPitch(src);    unsigned dpitch = FreeImage_GetPitch(dst);    unsigned w = FreeImage_GetWidth(src);    unsigned h = FreeImage_GetHeight(src);    BYTE * srcbits = FreeImage_GetBits(src);    BYTE * dstbits = FreeImage_GetBits(dst);    Curve c;    BYTE LUT8[256];    WORD LUT16[65536];    c.setControlPoints(ctpts);    int bpp = FreeImage_GetBPP(src);    if (bpp == 24) {        c.clampto(0.0,255.0);        for (int x=0; x<256; x++) {            LUT8[x] = (BYTE)floor(c.getpoint(x) + 0.5);        }        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < h; y++) {            for(unsigned x = 0; x < w; x++) {                BYTE * bdstpix = (BYTE *) dstbits + dpitch*y + 3*x;                BYTE *pixel = (BYTE *) (srcbits + spitch*y + 3*x);                bdstpix[FI_RGBA_RED]   = LUT8[pixel[FI_RGBA_RED]];                bdstpix[FI_RGBA_GREEN] = LUT8[pixel[FI_RGBA_GREEN]];                bdstpix[FI_RGBA_BLUE]  = LUT8[pixel[FI_RGBA_BLUE]];                //bdstpix[FI_RGBA_RED]   = ((BYTE *) LUT8)[pixel[FI_RGBA_RED]];                //bdstpix[FI_RGBA_GREEN] = ((BYTE *) LUT8)[pixel[FI_RGBA_GREEN]];                //bdstpix[FI_RGBA_BLUE]  = ((BYTE *) LUT8)[pixel[FI_RGBA_BLUE]];            }        }    }    if (bpp == 48) {        c.scalepoints(256.0);        c.clampto(0.0,65535.0);        for (int x=0; x<65536; x++) {            LUT16[x] = (WORD)floor(c.getpoint(x) + 0.5);        }        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < h; y++) {            for(unsigned x = 0; x < w; x++) {                FIRGB16 * wdstpix = (FIRGB16 *) (dstbits + dpitch*y + 6*x);                FIRGB16 * pixel   = (FIRGB16 *) (srcbits + spitch*y + 6*x);                wdstpix->red   = LUT16[pixel->red];                wdstpix->green = LUT16[pixel->green];                wdstpix->blue  = LUT16[pixel->blue];                //wdstpix->red   = ((WORD *) LUT16)[pixel->red];                //wdstpix->green = ((WORD *) LUT16)[pixel->green];                //wdstpix->blue  = ((WORD *) LUT16)[pixel->blue];            }        }    }    return _duration();}

double ApplyLUT(FIBITMAP *src, FIBITMAP *dst, char * LUT, int threadcount){    _mark();    unsigned spitch = FreeImage_GetPitch(src);    unsigned dpitch = FreeImage_GetPitch(dst);    unsigned w = FreeImage_GetWidth(src);    unsigned h = FreeImage_GetHeight(src);    BYTE * srcbits = FreeImage_GetBits(src);    BYTE * dstbits = FreeImage_GetBits(dst);    BYTE LUT8[256];    WORD LUT16[65536];    int bpp = FreeImage_GetBPP(src);    if (bpp == 24) {        for (int x=0; x<256; x++) {            LUT8[x] = ((BYTE *) LUT)[x];;        }        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < h; y++) {            for(unsigned x = 0; x < w; x++) {                BYTE * bdstpix = (BYTE *) (dstbits + dpitch*y + 3*x);                BYTE * pixel   = (BYTE *) (srcbits + spitch*y + 3*x);                bdstpix[FI_RGBA_RED]   = LUT8[pixel[FI_RGBA_RED]];                bdstpix[FI_RGBA_GREEN] = LUT8[pixel[FI_RGBA_GREEN]];                bdstpix[FI_RGBA_BLUE]  = LUT8[pixel[FI_RGBA_BLUE]];                //bdstpix[FI_RGBA_RED]   = ((BYTE *) LUT8)[pixel[FI_RGBA_RED]];                //bdstpix[FI_RGBA_GREEN] = ((BYTE *) LUT8)[pixel[FI_RGBA_GREEN]];                //bdstpix[FI_RGBA_BLUE]  = ((BYTE *) LUT8)[pixel[FI_RGBA_BLUE]];            }        }    }    if (bpp == 48) {        for (int x=0; x<65536; x++) {            LUT16[x] = ((WORD *)LUT)[x];        }        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < h-1; y++) {            for(unsigned x = 0; x < w-1; x++) {                FIRGB16 * wdstpix = (FIRGB16 *) (dstbits + dpitch*y + 6*x);                FIRGB16 * pixel   = (FIRGB16 *) (srcbits + spitch*y + 6*x);                wdstpix->red   = LUT16[pixel->red];                wdstpix->green = LUT16[pixel->green];                wdstpix->blue  = LUT16[pixel->blue];                //wdstpix->red   = ((WORD *) LUT16)[pixel->red];                //wdstpix->green = ((WORD *) LUT16)[pixel->green];                //wdstpix->blue  = ((WORD *) LUT16)[pixel->blue];            }        }    }    return _duration();}

double ApplyLUT2LUMA(FIBITMAP *src, FIBITMAP *dst, char * LUT, int threadcount){    _mark();    unsigned spitch = FreeImage_GetPitch(src);    unsigned dpitch = FreeImage_GetPitch(dst);    unsigned w = FreeImage_GetWidth(src);    unsigned h = FreeImage_GetHeight(src);    BYTE * srcbits = FreeImage_GetBits(src);    BYTE * dstbits = FreeImage_GetBits(dst);    BYTE LUT8[256];    WORD LUT16[65536];    int bpp = FreeImage_GetBPP(src);    if (bpp == 24) {        for (int x=0; x<256; x++) {            LUT8[x] = ((BYTE *) LUT)[x];        }        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < h; y++) {            for(unsigned x = 0; x < w; x++) {                BYTE * bdstpix = (BYTE *) (dstbits + dpitch*y + 3*x);                BYTE * pixel   = (BYTE *) (srcbits + spitch*y + 3*x);                int lumaorig = (int) LUMA(pixel[FI_RGBA_RED],pixel[FI_RGBA_GREEN],pixel[FI_RGBA_BLUE]);                int diff = lumaorig - LUT8[lumaorig];                bdstpix[FI_RGBA_RED]   = std::min(std::max(bdstpix[FI_RGBA_RED] + diff,0),255);                bdstpix[FI_RGBA_GREEN] = std::min(std::max(bdstpix[FI_RGBA_GREEN] + diff,0),255);                bdstpix[FI_RGBA_BLUE]  = std::min(std::max(bdstpix[FI_RGBA_BLUE]  + diff,0),255);            }        }    }    if (bpp == 48) {        for (int x=0; x<65536; x++) {            LUT16[x] = ((WORD *)LUT)[x];        }        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < h-1; y++) {            for(unsigned x = 0; x < w-1; x++) {                FIRGB16 * wdstpix = (FIRGB16 *) (dstbits + dpitch*y + 6*x);                FIRGB16 * pixel   = (FIRGB16 *) (srcbits + spitch*y + 6*x);                int lumaorig = (int) LUMA(pixel->red,pixel->green,pixel->blue);                int diff = lumaorig - LUT16[lumaorig];                wdstpix->red   = std::min(std::max(pixel->red + diff,0),65535);                wdstpix->green = std::min(std::max(pixel->green + diff,0),65535);                wdstpix->blue  = std::min(std::max(pixel->blue + diff,0),65535);            }        }    }    return _duration();}

double ApplyGray(FIBITMAP *src, FIBITMAP *dst, double redpct, double greenpct, double bluepct, int threadcount){    _mark();    int bpp = FreeImage_GetBPP(src);    unsigned spitch = FreeImage_GetPitch(src);    unsigned dpitch = FreeImage_GetPitch(dst);    BYTE * srcbits = FreeImage_GetBits(src);    BYTE * dstbits = FreeImage_GetBits(dst);    switch(bpp) {    case 48:        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < FreeImage_GetHeight(src); y++) {            for(unsigned x = 0; x < FreeImage_GetWidth(src); x++) {                FIRGB16 * wdstpix = (FIRGB16 *) (dstbits + dpitch*y + 6*x);                FIRGB16 * pixel   = (FIRGB16 *) (srcbits + spitch*y + 6*x);                double G = floor((double) pixel->red*redpct + (double) pixel->green*greenpct + (double) pixel->blue*bluepct)+0.5;                if (G>65535.0) G=65535.0;                if (G<0.0) G=0.0;                wdstpix->red = int(G);                wdstpix->green = int(G);                wdstpix->blue = int(G);            }        }        break;    case 24 :        #pragma omp parallel for num_threads(threadcount)        for(unsigned y = 0; y < FreeImage_GetHeight(src); y++) {            for(unsigned x = 0; x < FreeImage_GetWidth(src); x++) {                BYTE * bdstpix = (BYTE *) dstbits + dpitch*y + 3*x;                BYTE *pixel = (BYTE *) (srcbits + spitch*y + 3*x);                double G = floor((double) pixel[FI_RGBA_RED]*redpct + (double) pixel[FI_RGBA_GREEN]*greenpct + (double) pixel[FI_RGBA_BLUE]*bluepct)+0.5;                if (G>255.0) G=255.0;                if (G<0.0) G=0.0;                bdstpix[FI_RGBA_RED] = int(G);                bdstpix[FI_RGBA_GREEN] = int(G);                bdstpix[FI_RGBA_BLUE]= int(G);            }        }        break;    }    return _duration();}

std::ostream &operator <<(std::ostream &rOutputStream, const FIBITMAP &rBitmap){    unsigned int nImageWidth    = FreeImage_GetWidth(const_cast<FIBITMAP *>(&rBitmap));    unsigned int nImageHeight   = FreeImage_GetHeight(const_cast<FIBITMAP *>(&rBitmap));    unsigned int nPitch         = FreeImage_GetPitch(const_cast<FIBITMAP *>(&rBitmap));    unsigned int nBPP           = FreeImage_GetBPP(const_cast<FIBITMAP *>(&rBitmap));    FREE_IMAGE_COLOR_TYPE eType = FreeImage_GetColorType(const_cast<FIBITMAP *>(&rBitmap));    BITMAPINFO *pInfo          = FreeImage_GetInfo(const_cast<FIBITMAP *>(&rBitmap));    rOutputStream << "Size  (" << FreeImage_GetWidth(const_cast<FIBITMAP *>(&rBitmap)) << ", "                  << FreeImage_GetHeight(const_cast<FIBITMAP *>(&rBitmap)) << ")/n";    rOutputStream << "Pitch "  << FreeImage_GetPitch(const_cast<FIBITMAP *>(&rBitmap)) << "/n";    rOutputStream << "Type  ";    switch (eType)    {        case FIC_MINISWHITE:            rOutputStream << "FIC_MINISWHITE/n";            break;        case FIC_MINISBLACK:            rOutputStream << "FIC_MINISBLACK/n";            break;        case FIC_RGB:            rOutputStream << "FIC_RGB/n";            break;        case FIC_PALETTE:            rOutputStream << "FIC_PALETTE/n";            break;        case FIC_RGBALPHA:            rOutputStream << "FIC_RGBALPHA/n";            break;        case FIC_CMYK:            rOutputStream << "FIC_CMYK/n";            break;        default:            rOutputStream << "Unknown pixel format./n";    }    rOutputStream << "BPP   " << nBPP << std::endl;    return rOutputStream;}

/**Returns minus the residual for the model problem. Input quantities are u[0..n-1][0..n-1] andrhs[0..n-1][0..n-1], while res[0..n-1][0..n-1] is returned.*/static void fmg_residual(FIBITMAP *RES, FIBITMAP *U, FIBITMAP *RHS, int n) {	int row, col;	const float h = 1.0F / (n-1);		const float h2i = 1.0F / (h*h);	const int res_pitch  = FreeImage_GetPitch(RES) / sizeof(float);	const int u_pitch  = FreeImage_GetPitch(U) / sizeof(float);	const int rhs_pitch  = FreeImage_GetPitch(RHS) / sizeof(float);		float *res_bits = (float*)FreeImage_GetBits(RES);	const float *u_bits = (float*)FreeImage_GetBits(U);	const float *rhs_bits = (float*)FreeImage_GetBits(RHS);	// interior points	{		float *res_scan = res_bits + res_pitch;		const float *u_scan = u_bits + u_pitch;		const float *rhs_scan = rhs_bits + rhs_pitch;		for (row = 1; row < n-1; row++) {			for (col = 1; col < n-1; col++) {				// calculate RES(row, col) = 				// -h2i * [ U(row+1, col) + U(row-1, col) + U(row, col+1) + U(row, col-1) - 4 * U(row, col) ] + RHS(row, col);				float *res_center = res_scan + col;				const float *u_center = u_scan + col;				const float *rhs_center = rhs_scan + col;				*res_center = *(u_center + u_pitch) + *(u_center - u_pitch) + *(u_center + 1) + *(u_center - 1) - 4 * *u_center;				*res_center *= -h2i;				*res_center += *rhs_center;			}			res_scan += res_pitch;			u_scan += u_pitch;			rhs_scan += rhs_pitch;		}	}	// boundary points	{		memset(FreeImage_GetScanLine(RES, 0), 0, FreeImage_GetPitch(RES));		memset(FreeImage_GetScanLine(RES, n-1), 0, FreeImage_GetPitch(RES));		float *left = res_bits;		float *right = res_bits + (n-1);		for(int k = 0; k < n; k++) {			*left = 0;			*right = 0;			left += res_pitch;			right += res_pitch;		}	}}

void ImageLoader::compatible(){	// BITMAP数据是从下往上的, 需要翻转	FreeImage_FlipVertical(mDIB);	// FreeImage是BGR顺序, 与NVTT要求的一致, 而PVRT需要RGB顺序, 两者都需要32bits数据	if (config.imageCompressionType != CT_DXTC)	{		// 将BGR改为RGB, 交换R channel和B channel		const unsigned bytesperpixel = FreeImage_GetBPP(mDIB) / 8;		const unsigned height = FreeImage_GetHeight(mDIB);		const unsigned pitch = FreeImage_GetPitch(mDIB);		const unsigned lineSize = FreeImage_GetLine(mDIB);		BYTE* line = FreeImage_GetBits(mDIB);		for (unsigned y = 0; y < height; ++y, line += pitch) {			for (BYTE* pixel = line; pixel < line + lineSize; pixel += bytesperpixel) {				INPLACESWAP(pixel[0], pixel[2]);			}		}	}	if (FreeImage_GetBPP(mDIB) != 32)	{		FIBITMAP* convertDIB = FreeImage_ConvertTo32Bits(mDIB);		FreeImage_Unload(mDIB);		mDIB = convertDIB;	}}

FIBITMAP * CreateTemplete(FIBITMAP * hImage, unsigned ScreenWidth, unsigned ScreenHeight) // 创建空白PNG模版{	FIBITMAP * hPicTemplete;	RGBQUAD * palMain ;	RGBQUAD * palTemplete ;	unsigned ImgPitchLocal ;	BYTE * pBitLocal;	unsigned x, y, n;	hPicTemplete = FreeImage_Allocate(ScreenWidth, ScreenHeight, 8, 0, 0, 0);  //创建目标图像	palMain = FreeImage_GetPalette(hImage);	palTemplete = FreeImage_GetPalette(hPicTemplete);	for (n = 0 ; n < 256 ; n++) {		palTemplete[n].rgbRed = palMain[n].rgbRed ;		palTemplete[n].rgbGreen = palMain[n].rgbGreen ;		palTemplete[n].rgbBlue = palMain[n].rgbBlue ;	}	palTemplete[70].rgbRed = 255   ;	palTemplete[70].rgbGreen = 255 ;	palTemplete[70].rgbBlue = 255  ;//	FreeImage_SetTransparent(hPicTemplete, false);	// 所有像素颜色填充为 70 号索引	ImgPitchLocal = FreeImage_GetPitch(hPicTemplete) ;	pBitLocal = FreeImage_GetBits(hPicTemplete);	for (y = 0 ; y < ScreenHeight; y++) {		for (x = 0; x < ScreenWidth ; x++)			pBitLocal[x] = 70 ;		pBitLocal += ImgPitchLocal ; // 下一行	}	return hPicTemplete;}

Image *Image::New(FIBITMAP* dib) {  NanScope();  Local<Value> arg = NanNew<Integer>(0);  Local<Object> obj = NanNew<FunctionTemplate>(constructor_template)->GetFunction()->NewInstance(1, &arg);  Image *image = ObjectWrap::Unwrap<Image>(obj);  int w,h,pitch;  FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib);  obj->SetInternalField(0, NanNew<External>(dib));  obj->Set(NanNew<String>("width"), NanNew<Integer>(w=FreeImage_GetWidth(dib)));  obj->Set(NanNew<String>("height"), NanNew<Integer>(h=FreeImage_GetHeight(dib)));  obj->Set(NanNew<String>("bpp"), NanNew<Integer>((int)FreeImage_GetBPP(dib)));  obj->Set(NanNew<String>("pitch"), NanNew<Integer>(pitch=FreeImage_GetPitch(dib)));  obj->Set(NanNew<String>("type"), NanNew<Integer>(type));  obj->Set(NanNew<String>("redMask"), NanNew<Integer>((int)FreeImage_GetRedMask(dib)));  obj->Set(NanNew<String>("greenMask"), NanNew<Integer>((int)FreeImage_GetGreenMask(dib)));  obj->Set(NanNew<String>("blueMask"), NanNew<Integer>((int)FreeImage_GetBlueMask(dib)));  BYTE *bits = FreeImage_GetBits(dib);  obj->Set(NanNew<String>("buffer"), NanNewBufferHandle((char*) bits, h * pitch));  return image;}

voidFreeImageStack::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);}

	FreeImage::FreeImage( const FreeImage & freeImage, const Math::Vec2<Size> & newSize, Filter resampleFilter ) :		BasicLoadable( freeImage ),		fileName( freeImage.fileName ),		#ifdef WIN32		fileNameW( freeImage.fileNameW ),		#endif		size( newSize ),		invertY( freeImage.invertY ),		loadingType( freeImage.loadingType ),		BPP( freeImage.BPP ),		loadingFormat( freeImage.loadingFormat ),		resampleFilter( resampleFilter ) {		if ( freeImage.isLoaded() ) {			Math::Vec2<Size> toCopySize = freeImage.getSize();			if ( this -> size != toCopySize )				this -> freeImage = FreeImage_Rescale( freeImage.freeImage, this -> size.x, this -> size.y, ( FREE_IMAGE_FILTER ) this -> resampleFilter );			else				this -> freeImage = FreeImage_Clone( freeImage.freeImage );		} else {			this -> freeImage = freeImage.freeImage;	//Probably NULL		}		if ( this -> freeImage )			this -> stride = FreeImage_GetPitch( this -> freeImage );		else			this -> stride = 0;	}

/**Invert only color components, skipping Alpha/Black(Can be useful as public/utility function)*/staticBOOL invertColor(FIBITMAP* dib) {	FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib);	const unsigned Bpp = FreeImage_GetBPP(dib)/8;		if((type == FIT_BITMAP && Bpp == 4) || type == FIT_RGBA16) {		const unsigned width = FreeImage_GetWidth(dib);		const unsigned height = FreeImage_GetHeight(dib);		BYTE *line_start = FreeImage_GetScanLine(dib, 0);		const unsigned pitch = FreeImage_GetPitch(dib);		const unsigned triBpp = Bpp - (Bpp == 4 ? 1 : 2);						for(unsigned y = 0; y < height; y++) {			BYTE *line = line_start;			for(unsigned x = 0; x < width; x++) {				for(unsigned b=0; b < triBpp; ++b) {					line[b] = ~line[b];				}									line += Bpp;			}			line_start += pitch;		}				return TRUE;	}	else {		return FreeImage_Invert(dib);	}}

/**Get the maximum, minimum and average luminance@param dib Source Y image to analyze@param maxLum Maximum luminance@param minLum Minimum luminance@param worldLum Average luminance (world adaptation luminance)@return Returns TRUE if successful, returns FALSE otherwise@see ConvertRGBFToY*/BOOL LuminanceFromY(FIBITMAP *dib, float *maxLum, float *minLum, float *worldLum) {	if(FreeImage_GetImageType(dib) != FIT_FLOAT)		return FALSE;	unsigned width  = FreeImage_GetWidth(dib);	unsigned height = FreeImage_GetHeight(dib);	unsigned pitch  = FreeImage_GetPitch(dib);	float max_lum = -1e20F, min_lum = 1e20F;	double sum = 0;	BYTE *bits = (BYTE*)FreeImage_GetBits(dib);	for(unsigned y = 0; y < height; y++) {		const float *pixel = (float*)bits;		for(unsigned x = 0; x < width; x++) {			const float Y = pixel[x];			max_lum = (max_lum < Y) ? Y : max_lum;				// max Luminance in the scene			min_lum = ((Y > 0) && (min_lum < Y)) ? min_lum : Y;	// min Luminance in the scene			sum += log(2.3e-5 + Y);								// contrast constant in Tumblin paper		}		// next line		bits += pitch;	}	// maximum luminance	*maxLum = max_lum;	// minimum luminance	*minLum = min_lum;	// average log luminance	double avgLogLum = (sum / (width * height));	// world adaptation luminance	*worldLum = (float)exp(avgLogLum);	return TRUE;}

FIBITMAP* getBmpFromPixels(ofPixels_<PixelType> &pix){	PixelType* pixels = pix.getPixels();	unsigned int width = pix.getWidth();	unsigned int height = pix.getHeight();	unsigned int bpp = pix.getBitsPerPixel();		FREE_IMAGE_TYPE freeImageType = getFreeImageType(pix);	FIBITMAP* bmp = FreeImage_AllocateT(freeImageType, width, height, bpp);	unsigned char* bmpBits = FreeImage_GetBits(bmp);	if(bmpBits != NULL) {		int srcStride = width * pix.getBytesPerPixel();		int dstStride = FreeImage_GetPitch(bmp);		unsigned char* src = (unsigned char*) pixels;		unsigned char* dst = bmpBits;		for(int i = 0; i < (int)height; i++) {			memcpy(dst, src, dstStride);			src += srcStride;			dst += dstStride;		}	} else {		ofLogError() << "ofImage::getBmpFromPixels() unable to get FIBITMAP from ofPixels";	}		// ofPixels are top left, FIBITMAP is bottom left	FreeImage_FlipVertical(bmp);		return bmp;}

Image *Image::New(FIBITMAP* dib) {  HandleScope scope;  Local<Value> arg = Integer::NewFromUnsigned(0);  Local<Object> obj = constructor_template->GetFunction()->NewInstance(1, &arg);  Image *image = ObjectWrap::Unwrap<Image>(obj);  image->dib = dib;  int w,h,pitch;  FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib);  obj->SetInternalField(0, External::New(dib));  obj->Set(JS_STR("width"), JS_INT(w=FreeImage_GetWidth(dib)));  obj->Set(JS_STR("height"), JS_INT(h=FreeImage_GetHeight(dib)));  obj->Set(JS_STR("bpp"), JS_INT((int)FreeImage_GetBPP(dib)));  obj->Set(JS_STR("pitch"), JS_INT(pitch=FreeImage_GetPitch(dib)));  obj->Set(JS_STR("type"), JS_INT(type));  obj->Set(JS_STR("redMask"), JS_INT((int)FreeImage_GetRedMask(dib)));  obj->Set(JS_STR("greenMask"), JS_INT((int)FreeImage_GetGreenMask(dib)));  obj->Set(JS_STR("blueMask"), JS_INT((int)FreeImage_GetBlueMask(dib)));  BYTE *bits=FreeImage_GetBits(dib);  node::Buffer *buf = node::Buffer::New((char*)bits,h*pitch);  obj->Set(JS_STR("buffer"), buf->handle_);  return image;}

/**Get the maximum, minimum and average luminance.<br>On input, pixel->red == Y, pixel->green == x, pixel->blue == y@param Yxy Source Yxy image to analyze@param maxLum Maximum luminance@param minLum Minimum luminance@param worldLum Average luminance (world adaptation luminance)@return Returns TRUE if successful, returns FALSE otherwise*/BOOL LuminanceFromYxy(FIBITMAP *Yxy, float *maxLum, float *minLum, float *worldLum) {	if(FreeImage_GetImageType(Yxy) != FIT_RGBF)		return FALSE;	const unsigned width  = FreeImage_GetWidth(Yxy);	const unsigned height = FreeImage_GetHeight(Yxy);	const unsigned pitch  = FreeImage_GetPitch(Yxy);	float max_lum = 0, min_lum = 0;	double sum = 0;	BYTE *bits = (BYTE*)FreeImage_GetBits(Yxy);	for(unsigned y = 0; y < height; y++) {		const FIRGBF *pixel = (FIRGBF*)bits;		for(unsigned x = 0; x < width; x++) {			const float Y = MAX(0.0F, pixel[x].red);// avoid negative values			max_lum = (max_lum < Y) ? Y : max_lum;	// max Luminance in the scene			min_lum = (min_lum < Y) ? min_lum : Y;	// min Luminance in the scene			sum += log(2.3e-5F + Y);				// contrast constant in Tumblin paper		}		// next line		bits += pitch;	}	// maximum luminance	*maxLum = max_lum;	// minimum luminance	*minLum = min_lum;	// average log luminance	double avgLogLum = (sum / (width * height));	// world adaptation luminance	*worldLum = (float)exp(avgLogLum);	return TRUE;}

/**Custom gamma correction based on the ITU-R BT.709 standard@param dib RGBF image to be corrected@param gammaval Gamma value (2.2 is a good default value)@return Returns TRUE if successful, returns FALSE otherwise*/static BOOL REC709GammaCorrection(FIBITMAP *dib, const float gammaval) {	if(FreeImage_GetImageType(dib) != FIT_RGBF)		return FALSE;	float slope = 4.5F;	float start = 0.018F;		const float fgamma = (float)((0.45 / gammaval) * 2);	if(gammaval >= 2.1F) {		start = (float)(0.018 / ((gammaval - 2) * 7.5));		slope = (float)(4.5 * ((gammaval - 2) * 7.5));	} else if (gammaval <= 1.9F) {		start = (float)(0.018 * ((2 - gammaval) * 7.5));		slope = (float)(4.5 / ((2 - gammaval) * 7.5));	}	const unsigned width  = FreeImage_GetWidth(dib);	const unsigned height = FreeImage_GetHeight(dib);	const unsigned pitch  = FreeImage_GetPitch(dib);	BYTE *bits = (BYTE*)FreeImage_GetBits(dib);	for(unsigned y = 0; y < height; y++) {		float *pixel = (float*)bits;		for(unsigned x = 0; x < width; x++) {			for(int i = 0; i < 3; i++) {				*pixel = (*pixel <= start) ? *pixel * slope : (1.099F * pow(*pixel, fgamma) - 0.099F);				pixel++;			}		}		bits += pitch;	}	return TRUE;}

	FreeImage & FreeImage::operator=( const FreeImage & image ) {		this -> fileName = image.fileName;		#ifdef WIN32		this -> fileNameW = image.fileNameW;		#endif		this -> size = size;		this -> invertY = image.invertY;		this -> loadingType = image.loadingType;		this -> BPP = image.BPP;		this -> loadingFormat = image.loadingFormat;		this -> resampleFilter = image.resampleFilter;		if ( image.isLoaded() ) {			lock();			this -> freeImage = FreeImage_Clone( image.freeImage );			setLoaded( true );			unlock();		} else {			this -> freeImage = image.freeImage;	//Probably NULL			setLoaded( false );		}		if ( this -> freeImage )			this -> stride = FreeImage_GetPitch( this -> freeImage );		else			this -> stride = 0;		return *this;	}

	void FreeImage::loadFromDatas( unsigned char * datas, const Math::Vec2<Size> & size, Format format, bool datasInvertY ) {		unload();		lock();		setLoading( true );		_updateFormat( format );		this -> size = size;		this -> invertY = datasInvertY;		this -> loadingType = LoadingType::EMPTY;		this -> fileName.clear();			//we have no reason to keep a filepath now.		#ifdef WIN32		this -> fileNameW.clear();			//we have no reason to keep a filepath now.		#endif // WIN32		#ifdef WIN32 		if ( format == Format::RGB || format == Format::RGBA ) {			//because FreeImage do not care of MASK and use BGR on Windows			size_t numPixels = this -> size.x * this -> size.y;			size_t offsetPerPixel = ( this -> BPP / 8 );			unsigned char * newDatas = new unsigned char[offsetPerPixel * numPixels];			auto otherIt = datas;			auto thisIt = newDatas;			if ( format == Format::RGB ) {				for ( size_t i = 0; i < numPixels; i++ ) {					thisIt[0] = otherIt[2];					thisIt[1] = otherIt[1];					thisIt[2] = otherIt[0];					otherIt += offsetPerPixel;					thisIt += offsetPerPixel;				}			} else if ( format == Format::RGBA ) {				for ( size_t i = 0; i < numPixels; i++ ) {					thisIt[0] = otherIt[2];					thisIt[1] = otherIt[1];					thisIt[2] = otherIt[0];					thisIt[3] = otherIt[3];					otherIt += offsetPerPixel;					thisIt += offsetPerPixel;				}			}						this -> freeImage = FreeImage_ConvertFromRawBits( newDatas, this -> size.x, this -> size.y, this -> size.x * ( this -> BPP / 8 ), this -> BPP, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, this -> invertY );			delete[] newDatas;		} else {			this -> freeImage = FreeImage_ConvertFromRawBits( datas, this -> size.x, this -> size.y, this -> size.x * ( this -> BPP / 8 ), this -> BPP, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, this -> invertY );		}		#else		this -> freeImage = FreeImage_ConvertFromRawBits( datas, this -> size.x, this -> size.y, this -> size.x * ( this -> BPP / 8 ), this -> BPP, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, this -> invertY );		#endif		this -> stride = FreeImage_GetPitch( this -> freeImage );		setLoading( false );		setLoaded( true );		unlock();	}

/**Coarse-to-fine prolongation by bilinear interpolation. nf is the fine-grid dimension. The coarsegridsolution is input as uc[0..nc-1][0..nc-1], where nc = nf/2 + 1. The fine-grid solution isreturned in uf[0..nf-1][0..nf-1].*/static void fmg_prolongate(FIBITMAP *UF, FIBITMAP *UC, int nf) {	int row_uc, row_uf, col_uc, col_uf;	const int uf_pitch  = FreeImage_GetPitch(UF) / sizeof(float);	const int uc_pitch  = FreeImage_GetPitch(UC) / sizeof(float);		float *uf_bits = (float*)FreeImage_GetBits(UF);	const float *uc_bits = (float*)FreeImage_GetBits(UC);		// do elements that are copies	{		const int nc = nf/2 + 1;		float *uf_scan = uf_bits;		const float *uc_scan = uc_bits;				for (row_uc = 0; row_uc < nc; row_uc++) {			for (col_uc = 0, col_uf = 0; col_uc < nc; col_uc++, col_uf += 2) {				// calculate UF(2*row_uc, col_uf) = UC(row_uc, col_uc);				uf_scan[col_uf] = uc_scan[col_uc];			}			uc_scan += uc_pitch;			uf_scan += 2 * uf_pitch;		}	}	// do odd-numbered columns, interpolating vertically	{				for(row_uf = 1; row_uf < nf-1; row_uf += 2) {			float *uf_scan = uf_bits + row_uf * uf_pitch;			for (col_uf = 0; col_uf < nf; col_uf += 2) {				// calculate UF(row_uf, col_uf) = 0.5 * ( UF(row_uf+1, col_uf) + UF(row_uf-1, col_uf) )				uf_scan[col_uf] = 0.5F * ( *(uf_scan + uf_pitch + col_uf) + *(uf_scan - uf_pitch + col_uf) );			}		}	}	// do even-numbered columns, interpolating horizontally	{		float *uf_scan = uf_bits;		for(row_uf = 0; row_uf < nf; row_uf++) {			for (col_uf = 1; col_uf < nf-1; col_uf += 2) {				// calculate UF(row_uf, col_uf) = 0.5 * ( UF(row_uf, col_uf+1) + UF(row_uf, col_uf-1) )				uf_scan[col_uf] = 0.5F * ( uf_scan[col_uf + 1] + uf_scan[col_uf - 1] );			}			uf_scan += uf_pitch;		}	}}

/**Does coarse-to-fine interpolation and adds result to uf. nf is the fine-grid dimension. Thecoarse-grid solution is input as uc[0..nc-1][0..nc-1], where nc = nf/2+1. The fine-grid solutionis returned in uf[0..nf-1][0..nf-1]. res[0..nf-1][0..nf-1] is used for temporary storage.*/static void fmg_addint(FIBITMAP *UF, FIBITMAP *UC, FIBITMAP *RES, int nf) {	fmg_prolongate(RES, UC, nf);	const int uf_pitch  = FreeImage_GetPitch(UF) / sizeof(float);	const int res_pitch  = FreeImage_GetPitch(RES) / sizeof(float);		float *uf_bits = (float*)FreeImage_GetBits(UF);	const float *res_bits = (float*)FreeImage_GetBits(RES);	for(int row = 0; row < nf; row++) {		for(int col = 0; col < nf; col++) {			// calculate UF(row, col) = UF(row, col) + RES(row, col);			uf_bits[col] += res_bits[col];		}		uf_bits += uf_pitch;		res_bits += res_pitch;	}}

bool tpImageIO::readHDR(tpImageColorHDR& I, const char* path){	FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(path, 0);		if(fifmt == FIF_UNKNOWN)	{		std::cerr << "[Error] tpImageIO : Unknow type !" << std::endl; 		//TODO: Exceptions ?		return false;	}			FIBITMAP *dib = FreeImage_Load(fifmt, path,0);    	if( dib == NULL )	{		std::cerr << "[Error] tpImageIO : Impossible d'ouvrir l'image : " << path << std::endl;		// TODO: Exceptions ?		return false;	}	if(FreeImage_GetImageType(dib)!=FIT_RGBF)	{		std::cerr << "[Error] tpImageIO : Unknow type !" << std::endl; 		//TODO: Exceptions ?		return false;	}	unsigned width = FreeImage_GetWidth(dib);	unsigned height = FreeImage_GetHeight(dib);	unsigned pitch = FreeImage_GetPitch(dib);	I.resize(height,width);	FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);	// test pixel access avoiding scanline calculations	// to speed-up the image processing	if(image_type == FIT_RGBF) {		BYTE *bits = (BYTE*)FreeImage_GetBits(dib);		for(int y = 0; y < height; y++) {		FIRGBF *pixel = (FIRGBF*)bits;		for(int x = 0; x < width; x++) {		I[y][x].r = pixel[x].red;		I[y][x].g = pixel[x].green;		I[y][x].b = pixel[x].blue;		}		// next line		bits += pitch;		}	}	FreeImage_Unload(dib);	return true;}

		bool Image::load(const char* filename)		{			const uint32_t argb_r = 0xFF000000u;			const uint32_t argb_g = 0x00FF0000u;			const uint32_t argb_b = 0x0000FF00u;			const uint32_t argb_a = 0x000000FFu;			FREE_IMAGE_FORMAT format;			FIBITMAP* bitmap;			FIBITMAP* rgbamap;			int32_t w, h;			// Unload if image already loaded to protect from memory leak			unload();			// Get filetype			format = FreeImage_GetFileType(filename);			if (format == FIF_UNKNOWN)			{				fprintf(stderr, "Failed to ascertain filetype of %s/n",					filename);				return false;			}			// Load image			bitmap = FreeImage_Load(format, filename);			if (bitmap == nullptr)			{				fprintf(stderr, "Failed to load %s/n", filename);				return false;			}			// Get width and height			w = FreeImage_GetWidth(bitmap);			h = FreeImage_GetHeight(bitmap);			// Convert to RGBA if not already			rgbamap = FreeImage_ConvertTo32Bits(bitmap);			int32_t scan_width = FreeImage_GetPitch(rgbamap);			// Make copy			int32_t size = h * scan_width;			_pixels = malloc(size);			FreeImage_ConvertToRawBits((BYTE*)_pixels, bitmap, scan_width, 32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, true);			_width = w;			_height = h;			// Unload FreeImage bitmaps			FreeImage_Unload(bitmap);			FreeImage_Unload(rgbamap);			return true;		}

// Takes an image from the frame buffer and compresses itint writeFrame(FIMEMORY *fiBuffer, FIBITMAP *fiImage, unsigned char imageType) {	/*	char msg[1024];	sprintf_s(msg, 1024, "imageType: %i", imageType);	MessageBox(NULL,msg,"ADES DEBUG", MB_OK);	*/	imageType = 2;	int errStatus = 1;	u_short imageWidth, imageHeight;	unsigned width, height, pitch, line;	BYTE *bits;	// Package image using correct compression	switch(imageType) {	case 0: // Send a raw frame		// Get image characteristics		width = FreeImage_GetWidth(fiImage);		height = FreeImage_GetHeight(fiImage);		pitch = FreeImage_GetPitch(fiImage);		line = FreeImage_GetLine(fiImage);		// Write out width and height		errStatus = FreeImage_SeekMemory(fiBuffer, 0, SEEK_SET);		if (errStatus != 1) break;		imageWidth = htons(width);		errStatus = FreeImage_WriteMemory( &imageWidth, 2, 1, fiBuffer );		if (errStatus != 1) break;				imageHeight = htons(height);		errStatus = FreeImage_WriteMemory( &imageHeight, 2, 1, fiBuffer );		if (errStatus != 1) break;		// Write out image (convert the bitmap to raw bits, top-left pixel first)		bits = (BYTE*)malloc(height * pitch);		FreeImage_ConvertToRawBits(bits, fiImage, pitch, 24, 			FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, TRUE);		errStatus = FreeImage_WriteMemory( bits, height*pitch*sizeof(BYTE), 1, fiBuffer );		free(bits);		if (errStatus != 1) break;				break;	default: // Send a jpg frame		errStatus = FreeImage_SeekMemory(fiBuffer, 0, SEEK_SET);		if (errStatus != 1) break;		errStatus = FreeImage_SaveToMemory(FIF_JPEG, fiImage, fiBuffer, convertToJpegFlag(imageType));		if (errStatus != 1) break;		break;	}		// Clean up and exit	return errStatus;}

void putBmpIntoPixels(FIBITMAP * bmp, ofPixels_<PixelType> &pix, bool swapForLittleEndian = true) {	// convert to correct type depending on type of input bmp and PixelType	FIBITMAP* bmpConverted = NULL;	FREE_IMAGE_TYPE imgType = FreeImage_GetImageType(bmp);	if(sizeof(PixelType)==1 &&		(FreeImage_GetColorType(bmp) == FIC_PALETTE || FreeImage_GetBPP(bmp) < 8		||  imgType!=FIT_BITMAP)) {		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertTo32Bits(bmp);		} else {			bmpConverted = FreeImage_ConvertTo24Bits(bmp);		}		bmp = bmpConverted;	}else if(sizeof(PixelType)==2 && imgType!=FIT_UINT16 && imgType!=FIT_RGB16 && imgType!=FIT_RGBA16){		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBA16);		} else {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGB16);		}		bmp = bmpConverted;	}else if(sizeof(PixelType)==4 && imgType!=FIT_FLOAT && imgType!=FIT_RGBF && imgType!=FIT_RGBAF){		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBAF);		} else {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBF);		}		bmp = bmpConverted;	}	unsigned int width = FreeImage_GetWidth(bmp);	unsigned int height = FreeImage_GetHeight(bmp);	unsigned int bpp = FreeImage_GetBPP(bmp);	unsigned int channels = (bpp / sizeof(PixelType)) / 8;	unsigned int pitch = FreeImage_GetPitch(bmp);	// ofPixels are top left, FIBITMAP is bottom left	FreeImage_FlipVertical(bmp);		unsigned char* bmpBits = FreeImage_GetBits(bmp);	if(bmpBits != NULL) {		pix.setFromAlignedPixels((PixelType*) bmpBits, width, height, channels, pitch);	} else {		ofLogError("ofImage") << "putBmpIntoPixels(): unable to set ofPixels from FIBITMAP";	}		if(bmpConverted != NULL) {		FreeImage_Unload(bmpConverted);	}#ifdef TARGET_LITTLE_ENDIAN	if(swapForLittleEndian && sizeof(PixelType) == 1) {		pix.swapRgb();	}#endif}

// Gets a new FreeImage bitmap if we haven't got one yet or the current one is too small.// On entry the background thread must not be scanning the bitmap - eg waiting.// The parameter 'clear' is the value to clear the bitmap to - effectively clears to// a grey of colour RGB(clear, clear, clear), or -1 to not clear.void CHexEditDoc::GetAerialBitmap(int clear /*= 0xC0*/){    // If we already have a bitmap make sure it is big enough    if (dib_ != NULL)    {        int dib_size = FreeImage_GetPitch(dib_) * FreeImage_GetHeight(dib_);        int dib_rows = int(length_/bpe_/MAX_WIDTH) + 2;        if (dib_size >= MAX_WIDTH*dib_rows*3)        {            if (clear > -1)                memset(FreeImage_GetBits(dib_), clear, dib_size);            return;        }        // Not big enough so free it and reallocate (below)        FIBITMAP *dib = dib_;        dib_ = NULL;        TRACE("+++ FreeImage_Unload(%d)/n", dib);        FreeImage_Unload(dib);        if (clear <= -1)            clear = 0xC0;  // if we get a new bitmap we must clear it    }    // TBD: TODO we need user options for default bpe and MAX_BMP (min 16Mb = 1 TByte file @ BPE 65536)    bpe_ = 1;    // Keep increasing bpe_ by powers of two until we get a small enough bitmap    while (bpe_ <= 65536 && (length_*3)/bpe_ > theApp.aerial_max_)        bpe_ = bpe_<<1;    // Work out the number of bitmap rows we would need at the widest bitmap size    int rows = int(length_/bpe_/MAX_WIDTH) + 2;    // Round up to next row plus add one more row to allow for "reshaping"    ASSERT((rows-2)*MAX_WIDTH < theApp.aerial_max_);    dib_ = FreeImage_Allocate(MAX_WIDTH, rows, 24);    dib_size_ = MAX_WIDTH*rows*3;           // DIB size in bytes since we have 3 bytes per pixel and no pad bytes at the end of each scan line    ASSERT(dib_size_ == FreeImage_GetPitch(dib_) * FreeImage_GetHeight(dib_));    TRACE("+++ FreeImage_Allocate %d at %p end %p/n", dib_, FreeImage_GetBits(dib_), FreeImage_GetBits(dib_)+dib_size_);    if (clear > -1)        memset(FreeImage_GetBits(dib_), clear, dib_size_);       // Clear to a grey}