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

int TextureLoader::LoadTexture(const char * imagepath){        // Load image using the Free Image library    FREE_IMAGE_FORMAT format = FreeImage_GetFileType(imagepath, 0);    FIBITMAP* image = FreeImage_Load(format, imagepath);    FIBITMAP* image32bits = FreeImage_ConvertTo32Bits(image);        // Get an available texture index from OpenGL    GLuint texture = 0;    glGenTextures(1, &texture);    assert(texture != 0);        // Set OpenGL filtering properties (bi-linear interpolation)    glBindTexture(GL_TEXTURE_2D, texture);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);        // Retrieve width and hight    int width = FreeImage_GetWidth(image32bits);    int height = FreeImage_GetHeight(image32bits);        // This will upload the texture to the GPU memory    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height,                 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(image32bits));        // Free images    FreeImage_Unload(image);    FreeImage_Unload(image32bits);     return texture;}

FIBITMAP *GraphicsHelps::loadImageRC(const char *file){    unsigned char *memory = nullptr;    size_t fileSize = 0;    SDL_assert_release(RES_getMem(file, memory, fileSize));    //{        //pLogCritical("Resource file /"%s/" is not found!", file);        //return nullptr;    //}    FIMEMORY *imgMEM = FreeImage_OpenMemory(memory, static_cast<FI_DWORD>(fileSize));    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);    if(formato == FIF_UNKNOWN)        return nullptr;    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);    FreeImage_CloseMemory(imgMEM);    if(!img)        return nullptr;    FIBITMAP *temp;    temp = FreeImage_ConvertTo32Bits(img);    if(!temp)        return nullptr;    FreeImage_Unload(img);    img = temp;    return img;}

GLuint Engine::useTexture(char* texDir, bool wrap) {	FIBITMAP* imagePtr =		FreeImage_ConvertTo32Bits(			FreeImage_Load(				FreeImage_GetFileType(texDir, 0), texDir)			);	GLuint texture;	glGenTextures(1, &texture); // i used to be 1	glBindTexture(GL_TEXTURE_2D, texture);	glTexImage2D(GL_TEXTURE_2D, 0,		GL_SRGB_ALPHA,		FreeImage_GetWidth(imagePtr),		FreeImage_GetHeight(imagePtr),		0, GL_BGRA, GL_UNSIGNED_BYTE,		(void*)FreeImage_GetBits(imagePtr));	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap ? GL_REPEAT : GL_CLAMP);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap ? GL_REPEAT : GL_CLAMP);	// Clear from RAM	FreeImage_Unload(imagePtr);	// Unbind when finished uplloading	glBindTexture(GL_TEXTURE_2D, 0);	return texture;}

std::shared_ptr<FIBITMAP> load_image(const std::wstring& filename){	if(!boost::filesystem::exists(filename))		BOOST_THROW_EXCEPTION(file_not_found() << boost::errinfo_file_name(narrow(filename)));	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;	fif = FreeImage_GetFileTypeU(filename.c_str(), 0);	if(fif == FIF_UNKNOWN) 		fif = FreeImage_GetFIFFromFilenameU(filename.c_str());			if(fif == FIF_UNKNOWN || !FreeImage_FIFSupportsReading(fif)) 		BOOST_THROW_EXCEPTION(invalid_argument() << msg_info("Unsupported image format."));			auto bitmap = std::shared_ptr<FIBITMAP>(FreeImage_LoadU(fif, filename.c_str(), 0), FreeImage_Unload);		  	if(FreeImage_GetBPP(bitmap.get()) != 32)	{		bitmap = std::shared_ptr<FIBITMAP>(FreeImage_ConvertTo32Bits(bitmap.get()), FreeImage_Unload);		if(!bitmap)			BOOST_THROW_EXCEPTION(invalid_argument() << msg_info("Unsupported image format."));				}	//PNG-images need to be premultiplied with their alpha	if(fif == FIF_PNG)	{		image_view<bgra_pixel> original_view(FreeImage_GetBits(bitmap.get()), FreeImage_GetWidth(bitmap.get()), FreeImage_GetHeight(bitmap.get()));		premultiply(original_view);	}		return bitmap;}

		GLubyte* Texture::loadToBitmap(std::string path, bool flip)		{			const char* pathCStr = path.c_str();			FREE_IMAGE_FORMAT format = FIF_UNKNOWN;			format = FreeImage_GetFileType(pathCStr);			if (format == FIF_UNKNOWN)				format = FreeImage_GetFIFFromFilename(pathCStr);			if (format == FIF_UNKNOWN) {				std::cout << "Failed to load image at " << pathCStr << std::endl;				return nullptr;			}			if (!FreeImage_FIFSupportsReading(format))			{				std::cout << "Detected image format cannot be read! " << pathCStr << std::endl;				return nullptr;			}			m_bitmap = FreeImage_Load(format, pathCStr);			if (flip)				FreeImage_FlipVertical(m_bitmap);			GLint bitsPerPixel = FreeImage_GetBPP(m_bitmap);			if (bitsPerPixel == 32)				m_bitmap32 = m_bitmap;			else				m_bitmap32 = FreeImage_ConvertTo32Bits(m_bitmap);			m_width = FreeImage_GetWidth(m_bitmap32);			m_height = FreeImage_GetHeight(m_bitmap32);			return FreeImage_GetBits(m_bitmap32);		}

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;	}}

image* createTexture(char* filePath){	//FreeImage_Initialise(FALSE);	FREE_IMAGE_FORMAT formato = FreeImage_GetFileType(filePath,0);//Automatocally detects the format(from over 20 formats!)	FIBITMAP* imagen = FreeImage_Load(formato, filePath,JPEG_ACCURATE);	FIBITMAP* temp = imagen;	imagen = FreeImage_ConvertTo32Bits(imagen);	FreeImage_Unload(temp);	int w = FreeImage_GetWidth(imagen);	int h = FreeImage_GetHeight(imagen);	GLubyte* textura = (GLubyte*) malloc(4*w*h);	char* pixeles = (char*)FreeImage_GetBits(imagen);	//FreeImage loads in BGR format, so you need to swap some bytes(Or use GL_BGR).	int j = 0;	for(; j<w*h; j++){		textura[j*4+0]= pixeles[j*4+2];		textura[j*4+1]= pixeles[j*4+1];		textura[j*4+2]= pixeles[j*4+0];		textura[j*4+3]= pixeles[j*4+3];	}	free(pixeles);	FreeImage_Unload(imagen);	image* imageToReturn = malloc(sizeof(image));	imageToReturn->height = h;	imageToReturn->width = w;	imageToReturn->texture = textura;	return imageToReturn;}

void loadTexture(char *textureFileName, GLuint &textureMapID)	{	FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(textureFileName, 0);	FIBITMAP *dib = FreeImage_Load(fifmt, textureFileName,0);	FIBITMAP *temp = dib;    dib = FreeImage_ConvertTo32Bits(temp);    FreeImage_Unload(temp);	 	    if( dib != NULL )	{                glGenTextures( 1, &textureMapID );		glBindTexture( GL_TEXTURE_2D, textureMapID );                         BYTE *pixels = (BYTE*)FreeImage_GetBits(dib);                //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels);		              ConfigureAndLoadTexture(pixels,  FreeImage_GetWidth(dib),  FreeImage_GetHeight(dib) );                 glActiveTexture (GL_TEXTURE0);                                                                                                                                                glBindTexture(GL_TEXTURE_2D, textureMapID); //===================================================================================================          //===================================================================================================                          free(pixels);        FreeImage_Unload(dib);	}}

BOOL fipImage::convertTo32Bits() {	if(_dib) {		FIBITMAP *dib32 = FreeImage_ConvertTo32Bits(_dib);		return replace(dib32);	}	return FALSE;}

int Init ( AAContext *aaContext ){    UserData *userData = (UserData*) aaContext->userData;	userData->animation = (Animation*) malloc(sizeof(Animation));	memset(userData->animation, 0x0, sizeof(Animation));    glGenTextures(1, &userData->earth_texture);	glBindTexture(GL_TEXTURE_2D, userData->earth_texture);    FIBITMAP* bitmap = FreeImage_Load(        FreeImage_GetFileType("earth.png", 0),        "earth.png");    FIBITMAP *pImage = FreeImage_ConvertTo32Bits(bitmap);    int nWidth = FreeImage_GetWidth(pImage);    int nHeight = FreeImage_GetHeight(pImage);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, nWidth, nHeight,		0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(pImage));	FreeImage_Unload(pImage);	FreeImage_Unload(bitmap); // correct?	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);   const char vShaderStr[] =  	  "uniform mat4 u_mvp;      					 /n"	  "attribute vec2 a_texCoords;                   /n"	  "varying vec2 v_texCoords;						 /n"      "attribute vec4 a_position;					 /n"	  "out float debug;								/n"      "void main()									 /n"      "{											 /n"	  "vec4 pos = u_mvp * a_position;		/n"	  "gl_Position = pos;                      /n"	  "v_texCoords = a_texCoords;					/n"	  "debug = a_position.y;                      /n"      "}                                             /n";      const char fShaderStr[] =  	  "in float debug;                                     /n"	  "varying vec2 v_texCoords;								/n"	  "uniform sampler2D s_earthTexture;                   /n"      "precision mediump float;                            /n"      "void main()                                         /n"      "{                                                   /n"	  "vec4 color = texture(s_earthTexture, v_texCoords);     /n"//	  "if(debug>0) /n"//	  "color = vec4(1.0, 0.0, 0.0, 1.0); /n"	  "gl_FragColor = color;                               /n"      "}                                                   /n";   // Load the shaders and get a linked program object   userData->programObject = LoadProgram ( vShaderStr, fShaderStr );   // Get the attribute locations   userData->positionLoc = glGetAttribLocation ( userData->programObject, "a_position" );   userData->mvpLoc = glGetUniformLocation(userData->programObject, "u_mvp");   userData->texCoordsLoc = glGetAttribLocation(userData->programObject, "a_texCoords");   userData->texLoc = glGetUniformLocation(userData->programObject, "s_earthTexture");   glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );   glEnable(GL_DEPTH_TEST);   return TRUE;}

RGBAImage* RGBAImage::ReadFromFile(const char* filename){	const FREE_IMAGE_FORMAT fileType = FreeImage_GetFileType(filename);	if(FIF_UNKNOWN == fileType)	{		printf("Unknown filetype %s/n", filename);		return 0;	}	FIBITMAP* freeImage = 0;	if(FIBITMAP* temporary = FreeImage_Load(fileType, filename, 0))	{		freeImage = FreeImage_ConvertTo32Bits(temporary);		FreeImage_Unload(temporary);	}	if(!freeImage)	{		printf( "Failed to load the image %s/n", filename);		return 0;	}	RGBAImage *result = ToRGBAImage(freeImage);	FreeImage_Unload(freeImage);	return result;}

GLuint make_texture(const char *filename) {    GLuint texture;    // Get the image file type from FreeImage.    FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(filename, 0);    // Actually load the image file.    FIBITMAP *dib = FreeImage_Load(fifmt, filename, 0);    // Now, there is no guarantee that the image file    // loaded will be GL_RGB, so we force FreeImage to    // convert the image to GL_RGB.    dib = FreeImage_ConvertTo32Bits(dib);    if (dib != NULL) {        glGenTextures(1, &texture);        glBindTexture(GL_TEXTURE_2D, texture);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);        // This is important to note, FreeImage loads textures in        // BGR format. Now we could just use the GL_BGR extension        // But, we will simply swap the B and R components ourselves.        // Firstly, allocate the new bit data doe the image.        //BYTE *bits = malloc(FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib) * 4);        // get a pointer to FreeImage's data.        BYTE *pixels = (BYTE*) FreeImage_GetBits(dib);        // Iterate through the pixels, copying the data        // from 'pixels' to 'bits' except in RGB format.        /*        int pix;        for (pix = 0; pix < FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib); pix++) {            bits[pix * 4 + 0] = pixels[pix * 4 + 2];            bits[pix * 4 + 1] = pixels[pix * 4 + 1];            bits[pix * 4 + 2] = pixels[pix * 4 + 0];            bits[pix * 4 + 3] = pixels[pix * 4 + 3];        }*/        // The new 'glTexImage2D' function, the prime difference        // being that it gets the width, height and pixel information        // from 'bits', which is the RGB pixel data..        //glTexImage2D(GL_TEXTURE_2D, 0, 4, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0,        //       GL_RGBA, GL_UNSIGNED_BYTE, bits);        glTexImage2D(GL_TEXTURE_2D, 0, 4, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0,                GL_BGRA, GL_UNSIGNED_BYTE, pixels);        // Unload the image.        // and free the bit data.        FreeImage_Unload(dib);        //free(bits);    } else {        fprintf(stderr, "Can't load texture: %s/n", filename);    }        return texture;}

bool FreeimagelibPlugin::LoadDoc(cpcl::IOStream *input, plcl::Doc **r) {	FREE_IMAGE_FORMAT fif = (FREE_IMAGE_FORMAT)freeimagelib_format;	FreeimagelibStuff stuff(input);	boost::shared_ptr<FIBITMAP> fibitmap(FreeImage_LoadFromHandle(fif, &stuff.io, stuff.io_handle), FreeImage_Unload);	if (!fibitmap) {		cpcl::Error(cpcl::StringPieceFromLiteral("FreeimagelibPlugin::LoadDoc(): unable to load image"));		return false;	}		if (FreeImage_GetImageType(fibitmap.get()) != FIT_BITMAP) {		boost::shared_ptr<FIBITMAP> tmp(FreeImage_ConvertToType(fibitmap.get(), FIT_BITMAP), FreeImage_Unload);		if (!tmp || (FreeImage_GetImageType(tmp.get()) != FIT_BITMAP)) {			cpcl::Error(cpcl::StringPieceFromLiteral("FreeimagelibPlugin::LoadDoc(): unable to convert the image to FIT_BITMAP"));			return false;		}		fibitmap = tmp;	}	unsigned int const bpp = FreeImage_GetBPP(fibitmap.get());	if (!(bpp == 24 || bpp == 32)) {		boost::shared_ptr<FIBITMAP> tmp((bpp > 32) ? FreeImage_ConvertTo32Bits(fibitmap.get()) : FreeImage_ConvertTo24Bits(fibitmap.get()), FreeImage_Unload);		if (!tmp) {			cpcl::Trace(CPCL_TRACE_LEVEL_ERROR,				"FreeimagelibPlugin::LoadDoc(): unable to convert image with bpp %u",				bpp);		}		fibitmap = tmp;	}	if (r)		*r = new FreeimagelibDoc(fibitmap);	return true;}

/** /brief Method that import a texture to be used on the model* /param[in] fTexture a constant char array containing the path to the file of the texture* /param[in] tex_number an unsigned integer representing the type of texture (i.e. 0 = Diffuse color, 1 = Normalmap, 2 = Specular Color)* /return a boolean indicating if the import was successful of not*/GLboolean Model::importTexture(const GLchar * fTexture, GLuint tex_number){	GLboolean import_is_ok = GL_FALSE;	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;	FIBITMAP *dib(0);	BYTE* bits(0);	GLuint width(0), height(0);	fif = FreeImage_GetFileType(fTexture, 0);	if (FreeImage_FIFSupportsReading(fif))	{		dib = FreeImage_Load(fif, fTexture);		dib = FreeImage_ConvertTo32Bits(dib);		bits = FreeImage_GetBits(dib);		width = FreeImage_GetWidth(dib);		height = FreeImage_GetHeight(dib);		import_is_ok = GL_TRUE;		glBindTexture(GL_TEXTURE_2D, m_texture_id[tex_number]);		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, &bits[0]);		glGenerateMipmap(GL_TEXTURE_2D);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);		FreeImage_Unload(dib);	}	return import_is_ok;}

/** * Helper to encapsulate Bpp conversion using FreeImage, taking into consideration color type. Creates a new bitmap if needed. Can return the same one. * @param pHandle		FIBITMAP as defined by the Freeimage library. * @param pNewBpp		the new bpp that the supplied FIBITMAP is to be coverted to. */FIBITMAP* FreeImageHelper::convertBpp(FIBITMAP* pHandle, int pNewBpp) {		//Convert the bit depth	FIBITMAP *converted = NULL;		//Convert Bpp only if needed	if (pNewBpp != static_cast<int>(FreeImage_GetBPP(pHandle))) {		//Transform bpp to the pixel format		switch (pNewBpp) {			case (4):				converted = FreeImage_ConvertTo4Bits(pHandle);				break;			case (8):				converted = FreeImage_ConvertTo8Bits(pHandle);				break;			case(16):				converted = FreeImage_ConvertTo16Bits565(pHandle);  //There's option of 16Bits555. But leaves unused bits. Chosen 565 because it's most common				break;			case(24):			   converted = FreeImage_ConvertTo24Bits(pHandle);    			    break;			case(32): {			    converted = FreeImage_ConvertTo32Bits (pHandle); 				}			    break;			default:				converted = NULL;				break;		}	} else {		//No change, just set 'converted' handle to current one		converted = pHandle;	}	return converted;}

void ofImage_<PixelType>::changeTypeOfPixels(ofPixels_<PixelType> &pix, ofImageType newType){	int oldType = pix.getImageType();			if (oldType == newType) {		return; // no need to reallocate	}	FIBITMAP * bmp = getBmpFromPixels(pix);	FIBITMAP * convertedBmp = nullptr;	switch (newType){		case OF_IMAGE_GRAYSCALE:			convertedBmp = FreeImage_ConvertToGreyscale(bmp);			break;		case OF_IMAGE_COLOR:			convertedBmp = FreeImage_ConvertTo24Bits(bmp);			break;		case OF_IMAGE_COLOR_ALPHA:			convertedBmp = FreeImage_ConvertTo32Bits(bmp);			break;		default:			ofLogError("ofImage") << "changeTypeOfPixels(): unknown image type: " << newType;			break;	}	    putBmpIntoPixels(convertedBmp, pix, false);	if (bmp != nullptr) {		FreeImage_Unload(bmp);	}	if (convertedBmp != nullptr) {		FreeImage_Unload(convertedBmp);	}}

void test32BitsChannels(unsigned width, unsigned height) {	BOOL bResult = FALSE;	// create a test 8-bit image	FIBITMAP *src = createZonePlateImage(width, height, 128);	if(src != NULL) {		// convert to 32-bit		FIBITMAP *tmp = FreeImage_ConvertTo32Bits(src);		FreeImage_Unload(src);		src = tmp;	}	assert(src != NULL);	// save for further examination	bResult = FreeImage_Save(FIF_PNG, src, "zoneplate.png", PNG_DEFAULT);	assert(bResult);	// test get/set channel	// -------------------------		FIBITMAP *channel = FreeImage_GetChannel(src, FICC_ALPHA);	assert(channel != NULL);	bResult = FreeImage_SetChannel(src, channel, FICC_ALPHA);	assert(bResult);		FreeImage_Unload(channel);	FreeImage_Unload(src);}

static voidTestFIA_DrawImageDstRectTest3(CuTest* tc){  const char *file = TEST_DATA_DIR "fly.bmp";  FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);  CuAssertTrue(tc, dib1 != NULL);  FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib1);    CuAssertTrue(tc, dib2 != NULL);    FIBITMAP *dst = FreeImage_Allocate(790,582, 32, 0, 0, 0);     CuAssertTrue(tc, dst != NULL);     FIA_Matrix *matrix = FIA_MatrixNew();  FIA_MatrixScale(matrix, 2.0, 2.0, FIA_MatrixOrderPrepend);     int err = FIA_DrawImageToDst(dst, dib2, matrix, 0,0,350/2,271/2, FIA_RGBQUAD(128,128,128), 1);  CuAssertTrue(tc, err != FIA_ERROR);    FIA_MatrixDestroy(matrix);    CuAssertTrue(tc, dst != NULL);  FIA_SaveFIBToFile(dst, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_DrawImageDstRectTest3.bmp", BIT24);  FreeImage_Unload(dib1);  FreeImage_Unload(dib2);  FreeImage_Unload(dst);}

HBITMAP BmpFilterLoadBitmap(BOOL *bIsTransparent, const wchar_t *ptszFilename){	FIBITMAP *dib = (FIBITMAP*)Image_Load(ptszFilename, IMGL_RETURNDIB);	if (dib == nullptr)		return nullptr;	FIBITMAP *dib32 = nullptr;	if (FreeImage_GetBPP(dib) != 32) {		dib32 = FreeImage_ConvertTo32Bits(dib);		FreeImage_Unload(dib);	}	else dib32 = dib;	if (dib32 == nullptr)		return nullptr;	if (FreeImage_IsTransparent(dib32))		if (bIsTransparent)			*bIsTransparent = TRUE;	if (FreeImage_GetWidth(dib32) > 128 || FreeImage_GetHeight(dib32) > 128) {		FIBITMAP *dib_new = FreeImage_MakeThumbnail(dib32, 128, FALSE);		FreeImage_Unload(dib32);		if (dib_new == nullptr)			return nullptr;		dib32 = dib_new;	}	HBITMAP bitmap = FreeImage_CreateHBITMAPFromDIB(dib32);	FreeImage_Unload(dib32);	FreeImage_CorrectBitmap32Alpha(bitmap, FALSE);	return bitmap;}

std::shared_ptr<RGBAImage> read_from_file(const std::string &filename){    const auto file_type = FreeImage_GetFileType(filename.c_str());    if (FIF_UNKNOWN == file_type)    {        throw RGBImageException("Unknown filetype '" + filename + "'");    }    FIBITMAP *free_image = nullptr;    if (auto temporary = FreeImage_Load(file_type, filename.c_str(), 0))    {        free_image = FreeImage_ConvertTo32Bits(temporary);        FreeImage_Unload(temporary);    }    if (not free_image)    {        throw RGBImageException("Failed to load the image " + filename);    }    auto result = to_rgba_image(free_image);    FreeImage_Unload(free_image);    return result;}

	bool readImage(SImage& image, MemChunk& data, int index)	{		// Get image info		SImage::info_t info;		FIBITMAP*      bm = getFIInfo(data, info);		// Check it created/read ok		if (!bm)		{			Global::error = "Unable to read image data (unsupported format?)";			return false;		}		// Get image palette if it exists		RGBQUAD* bm_pal = FreeImage_GetPalette(bm);		Palette  palette;		if (bm_pal)		{			int a = 0;			int b = FreeImage_GetColorsUsed(bm);			if (b > 256)				b = 256;			for (; a < b; a++)				palette.setColour(a, rgba_t(bm_pal[a].rgbRed, bm_pal[a].rgbGreen, bm_pal[a].rgbBlue, 255));		}		// Create image		if (info.has_palette)			image.create(info, &palette);		else			image.create(info);		uint8_t* img_data = imageData(image);		// Convert to 32bpp & flip vertically		FIBITMAP* rgba = FreeImage_ConvertTo32Bits(bm);		if (!rgba)		{			LOG_MESSAGE(1, "FreeImage_ConvertTo32Bits failed for image data");			Global::error = "Error reading PNG data";			return false;		}		FreeImage_FlipVertical(rgba);		// Load raw RGBA data		uint8_t* bits_rgba = FreeImage_GetBits(rgba);		int      c         = 0;		for (int a = 0; a < info.width * info.height; a++)		{			img_data[c++] = bits_rgba[a * 4 + 2]; // Red			img_data[c++] = bits_rgba[a * 4 + 1]; // Green			img_data[c++] = bits_rgba[a * 4];     // Blue			img_data[c++] = bits_rgba[a * 4 + 3]; // Alpha		}		// Free memory		FreeImage_Unload(rgba);		FreeImage_Unload(bm);		return true;	}

static voidTestFIA_DrawImageTest3(CuTest* tc){  const char *file = TEST_DATA_DIR "fly.bmp";  FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);  CuAssertTrue(tc, dib1 != NULL);  FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib1);    CuAssertTrue(tc, dib2 != NULL);    FIBITMAP *dst = FreeImage_Allocate(790,582, 32, 0, 0, 0);     CuAssertTrue(tc, dst != NULL);     int err = FIA_DrawImageFromSrcToDst(dst, dib2, NULL, 0,0,350,271, 350/2,271/2,350/2,271/2,      FIA_RGBQUAD(255,0,255), 0);    CuAssertTrue(tc, err != FIA_ERROR);    CuAssertTrue(tc, dst != NULL);  FIA_SaveFIBToFile(dst, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_DrawImageTest3.bmp", BIT24);  FreeImage_Unload(dib1);  FreeImage_Unload(dib2);  FreeImage_Unload(dst);}

static voidTestFIA_AffineTransorm32bitScaleTest(CuTest* tc){  const char *file = TEST_DATA_DIR "fly.bmp";  FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);  CuAssertTrue(tc, dib1 != NULL);  FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib1);    CuAssertTrue(tc, dib2 != NULL);    FIA_Matrix *matrix = FIA_MatrixNew();  FIA_MatrixScale(matrix, 2.0, 2.0, FIA_MatrixOrderPrepend);    FIBITMAP *transformed_dib = FIA_AffineTransform(dib2, 1000, 1000,                                matrix, FIA_RGBQUAD(255,0,255), 0);    FIA_MatrixDestroy(matrix);    CuAssertTrue(tc, transformed_dib != NULL);  FIA_SetGreyLevelPalette(transformed_dib);  FIA_SaveFIBToFile(transformed_dib, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_AffineTransorm32bitScaleTest.bmp", BIT24);  FreeImage_Unload(dib1);  FreeImage_Unload(dib2);  FreeImage_Unload(transformed_dib);}

static voidTestFIA_Colour32bitLineTest(CuTest* tc){    const char *file = TEST_DATA_DIR "bumblebee.jpg";    FIBITMAP *src = FIA_LoadFIBFromFile(file);    FIBITMAP *src32 = FreeImage_ConvertTo32Bits(src);    CuAssertTrue(tc, src != NULL);    FIAPOINT p1, p2, p3;    p1.x = 10;    p1.y = 10;    p2.x = 200;    p2.y = 300;    p3.x = 300;    p3.y = 300;        FIA_DrawColourLine (src32, p1, p2, FIA_RGBQUAD(255, 0, 0), 5, 0);        FIA_DrawColourLine (src32, p1, p3, FIA_RGBQUAD(0, 0, 255), 8, 1);    FIA_SaveFIBToFile(src32, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_Colour32bitLineTest.jpg", BIT24);    FreeImage_Unload(src);    FreeImage_Unload(src32);}

	///////////////////////////////////////////////////////////////////////////	///	/// @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;	}

		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;		}

void * RebGLSkinManager::LoadTexture(std::string filename){	FREE_IMAGE_FORMAT formato = FreeImage_GetFileType(filename.c_str(),0);//Automatocally detects the format(from over 20 formats!)	FIBITMAP* imagen = FreeImage_Load(formato, filename.c_str()); 	FIBITMAP* temp = imagen;	imagen = FreeImage_ConvertTo32Bits(imagen);	FreeImage_Unload(temp);	return imagen;}

/*! *	/brief Opens the image file using the FreeImage library in the specified orientation * 		   and builds the 2D Texture MipMaps. *	/param pathImagefile Path to the image file. *	/param bVertFlip	1, if the image texture must be vertically flipped * 						0, otherwise *	/param bHorzFlip	1, if the image texture must be horizontally flipped * 						0, otherwise  *	/return Texture ID. */GLuint loadTexture(const char* pathImagefile, int bVertFlip, int bHorzFlip){	GLuint textureID;	    FREE_IMAGE_FORMAT format = FreeImage_GetFileType(pathImagefile,0);	FIBITMAP* image = FreeImage_Load(format, pathImagefile,0);	int bRGBA = FreeImage_IsTransparent(image);		FIBITMAP* temp = image;	if(bRGBA)	{		image = FreeImage_ConvertTo32Bits(temp);	}	else	{		image = FreeImage_ConvertTo24Bits(temp);	}	FreeImage_Unload(temp);			if(bVertFlip)	{		FreeImage_FlipVertical(image);	}		if(bHorzFlip)	{		FreeImage_FlipHorizontal(image);	}			int w = FreeImage_GetWidth(image);	int h = FreeImage_GetHeight(image);		glGenTextures(1, &textureID);	glBindTexture(GL_TEXTURE_2D, textureID);		//// turn off bilinear filtering	//gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)	//gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);		if(bRGBA)	{		gluBuild2DMipmaps(GL_TEXTURE_2D, 4, w, h, GL_BGRA, GL_UNSIGNED_BYTE, FreeImage_GetBits(image));	}	else	{		gluBuild2DMipmaps(GL_TEXTURE_2D, 3, w, h, GL_BGR, GL_UNSIGNED_BYTE, FreeImage_GetBits(image));		}	FreeImage_Unload(image);		return textureID;}

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}

bool CTexture::Load(const char* texPath){	//if we already load texture, you have to delete previous...	if (TextureId != NULL) glDeleteTextures(1, &TextureId);	FREE_IMAGE_FORMAT format = FreeImage_GetFileType(texPath, 0);	FIBITMAP* image = FreeImage_Load(format, texPath);	if (format == FIF_UNKNOWN){		std::cout << "unknown texture format: file " << texPath << std::endl;		return false;	};	FIBITMAP* temp = image;	image = FreeImage_ConvertTo32Bits(image);	FreeImage_Unload(temp);	int w = FreeImage_GetWidth(image);	int h = FreeImage_GetHeight(image);	char* bits = (char*)FreeImage_GetBits(image);	// OpenGL stuff	/* TODO: Texture settings */	glGenTextures(1, &TextureId);	glBindTexture(GL_TEXTURE_2D, TextureId);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)bits);	/* Generate Mipmap */	glGenerateMipmap(GL_TEXTURE);	//glGenerateTextureMipmapEXT(TextureId);	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);	GLfloat fLargest;	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);	GLenum Error = glGetError();	if (Error){		std::cerr << "There was an error loading the texture" << std::endl;		return false;	}	return true;}