TextureManager::~TextureManager() {
// call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
FreeImage_DeInitialise();
#endif
UnloadAllTextures();
m_inst = 0;
}
int main(int argc, char** argv)
{
DLL_API void DLL_CALLCONV FreeImage_Initialise(BOOL load_local_plugins_only FI_DEFAULT(FALSE));
for(int i = 1; i < argc; i++)
{
fileRead(argv[i]);
}
FreeImage_DeInitialise();
return 0;
};
int
main(int argc, char *argv[]) {
// call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
FreeImage_Initialise();
#endif // FREEIMAGE_LIB
// initialize your own FreeImage error handler
FreeImage_SetOutputMessage(FreeImageErrorHandler);
// print version & copyright infos
printf("FreeImage version : %s", FreeImage_GetVersion());
printf("\n");
printf(FreeImage_GetCopyrightMessage());
printf("\n");
if(argc != 3) {
printf("Usage : CreateAlpha <input file name> <output file name>\n");
return 0;
}
// Load the source image
FIBITMAP *src = GenericLoader(argv[1], 0);
if(src) {
// Create a transparent image from the lightness image of src
FIBITMAP *dst = CreateAlphaFromLightness(src);
if(dst) {
// Save the destination image
bool bSuccess = GenericWriter(dst, argv[2], 0);
if(!bSuccess) {
printf("\nUnable to save %s file", argv[2]);
printf("\nThis format does not support 32-bit images");
}
// Free dst
FreeImage_Unload(dst);
}
// Free src
FreeImage_Unload(src);
}
// call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
FreeImage_DeInitialise();
#endif // FREEIMAGE_LIB
return 0;
}
//----------------------------------------------------------
// static variable for freeImage initialization:
void ofInitFreeImage(bool deinit=false){
// need a new bool to avoid c++ "deinitialization order fiasco":
// http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.15
static bool * bFreeImageInited = new bool(false);
if(!bFreeImageInited && !deinit){
FreeImage_Initialise();
*bFreeImageInited = true;
}
if(bFreeImageInited && deinit){
FreeImage_DeInitialise();
}
}
/**
* Frees the manager and all the objects that it contains.
*/
void IND_ImageManager::end() {
if (_ok) {
g_debug->header("Finalizing ImageManager", DebugApi::LogHeaderBegin);
g_debug->header("Freeing images" , DebugApi::LogHeaderBegin);
freeVars();
FreeImage_DeInitialise();
g_debug->header("Images freed", DebugApi::LogHeaderEnd);
g_debug->header("ImageManager finalized", DebugApi::LogHeaderEnd);
_ok = false;
}
}
//---------------------------------------------------------------------
void FreeImageCodec::shutdown(void)
{
FreeImage_DeInitialise();
for (RegisteredCodecList::iterator i = msCodecList.begin();
i != msCodecList.end(); ++i)
{
Codec::unRegisterCodec(*i);
OGRE_DELETE *i;
}
msCodecList.clear();
}
/**
* destructor
*/
fipImage::~fipImage(){
if ( pImageData ){
FreeImage_Unload( pImageData );
}
ulImageInstances--;
if ( ( ulImageInstances == 0 ) && bFreeImageInitialised ){
FreeImage_DeInitialise();
bFreeImageInitialised = false;
}
}
int main(int argc, char *argv[]) {
unsigned width = 512;
unsigned height = 512;
#if defined(_DEBUG) && defined(WIN32)
// check for memory leaks at program exit (after the 'return 0')
// through a call to _CrtDumpMemoryLeaks
// note that in debug mode, objects allocated with the new operator
// may be destroyed *after* the end of the main function.
_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
#endif
#if defined(FREEIMAGE_LIB) || !defined(WIN32)
FreeImage_Initialise();
#endif
// initialize our own FreeImage error handler
FreeImage_SetOutputMessage(FreeImageErrorHandler);
// test plugins capabilities
showPlugins();
// test the clone function
testAllocateCloneUnload("exif.jpg");
// test internal image types
testImageType(width, height);
// test loading / saving / converting image types using the TIFF plugin
testImageTypeTIFF(width, height);
// test multipage creation
testBuildMPage("sample.png", "sample.ico", FIF_ICO, 24);
testBuildMPage("sample.png", "sample.tif", FIF_TIFF, 24);
//testBuildMPage("sample.png", "sample.gif", FIF_GIF, 8);
// test multipage cache
testMPageCache("sample.png");
// test memory IO
testMemIO("sample.png");
// test JPEG lossless transform & cropping
testJPEG();
#if defined(FREEIMAGE_LIB) || !defined(WIN32)
FreeImage_DeInitialise();
#endif
return 0;
}
App::~App()
{
m_pluginManager.UnloadAll();
m_commandLineParser.DisposeCommands();
for (IdeType* type : m_ides)
{
delete type;
}
m_ides.clear();
FreeImage_DeInitialise();
}
Client::~Client()
{
enet_host_destroy(m_client);
delete m_mainPlayer;
// call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
FreeImage_DeInitialise();
#endif
SDL_DestroyWindow(m_window);
SDL_Quit();
}
BOOL CBigle3DApp::InitInstance()
{
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
// call this ONLY when linking with FreeImage as a static library
//FreeImage_Initialise();
// initialize your own FreeImage error handler
FreeImage_SetOutputMessage(MyMessageFunc);
CStartPP pp1;
CFondPP pp2;
CReliefPP pp3;
CCreateImgPP pp4;
CAboutPP pp5;
pp1.m_psp.dwFlags -= PSP_HASHELP;
pp2.m_psp.dwFlags -= PSP_HASHELP;
pp3.m_psp.dwFlags -= PSP_HASHELP;
pp4.m_psp.dwFlags -= PSP_HASHELP;
pp5.m_psp.dwFlags -= PSP_HASHELP;
m_ps.AddPage( &pp1 );
m_ps.AddPage( &pp2 );
m_ps.AddPage( &pp3 );
m_ps.AddPage( &pp4 );
m_ps.AddPage( &pp5 );
m_ps.SetWizardMode();
m_pMainWnd = &m_ps;
int nResponse = (int)m_ps.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
FreeImage_DeInitialise();
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
int main() {
#if defined(FREEIMAGE_LIB) || !defined(WIN32)
FreeImage_Initialise();
#endif
fipImage img;
img.load("img.png");
std::cout << img.getWidth() << "x" << img.getHeight() << std::endl;
#if defined(FREEIMAGE_LIB) || !defined(WIN32)
FreeImage_DeInitialise();
#endif
return 0;
}
void ThinLens::render_scene(World& w) {
RGBColor L;
Ray ray;
ViewPlane vp(w.vp);
FreeImage_Initialise();
FIBITMAP* bitmap = FreeImage_Allocate(vp.hres, vp.vres, 24);
RGBQUAD color;
int depth = 0;
Point2D sp;
Point2D pp;
Point2D dp;
Point2D lp;
vp.s /= zoom;
for(int r = 0; r < vp.vres; r++)
for(int c = 0 ; c < vp.hres; c++) {
L = black;
for(int n = 0; n < vp.num_samples; n++) {
sp = vp.sampler_ptr -> sample_unit_square();
pp.x = vp.s * (c - vp.hres / 2.0 + sp.x);
pp.y = vp.s * (r - vp.vres / 2.0 + sp.y);
dp = sampler_ptr -> sample_unit_disk();
lp = dp * lens_radius;
ray.o = eye + lp.x * u + lp.y * v;
ray.d = ray_direction(pp, lp);
L += w.tracer_ptr -> trace_ray(ray);
}
L /= vp.num_samples;
L *= exposure_time;
w.display_pixel(r, c, L);
color.rgbRed = (int)(L.r*255);
color.rgbGreen = (int)(L.g*255);
color.rgbBlue = (int)(L.b*255);
FreeImage_SetPixelColor(bitmap, c, r, &color);
}
if (FreeImage_Save(FIF_PNG, bitmap, "test.png", 0))
std::cout << "Image Successfully Saved!" << std::endl;
FreeImage_DeInitialise();
}
void Scene::saveImage(int t){
FreeImage_Initialise();
BYTE* pixels = new BYTE[ 3 * WIDTH * HEIGHT];
glReadPixels(0, 0, WIDTH, HEIGHT, GL_BGR, GL_UNSIGNED_BYTE, pixels);
FIBITMAP* image = FreeImage_ConvertFromRawBits(pixels, WIDTH, HEIGHT, 3 * WIDTH, 24, 0x0000FF, 0xFF0000, 0x00FF00, false);
// get a string to concat with an int
stringstream nameStream;
nameStream << "test" << t << ".png";
string name = nameStream.str();
char *a = new char[name.size() + 1];
a[name.size()] = 0;
memcpy(a, name.c_str(), name.size());
if(FreeImage_Save(FIF_BMP, image, a, 0))
cout << "Image " << t << " successfully saved! " << endl ;
FreeImage_DeInitialise(); //Cleanup !
}
BOOL APIENTRY
DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH :
FreeImage_Initialise(FALSE);
break;
case DLL_PROCESS_DETACH :
FreeImage_DeInitialise();
break;
case DLL_THREAD_ATTACH :
case DLL_THREAD_DETACH :
break;
}
return TRUE;
}
void Film::WriteImage(std::string fname){
/*Before you use FreeImage, call FreeImage_Initialise().
To record the colors for each pixel, use an array of one byte elements.
Then convert this array to a FIBITMAP object as follows, assuming the bytes are in RGB order:*/
FreeImage_Initialise();
int pix = width * height;
BYTE *pixels = new BYTE[3 * pix];
memcpy((void *)pixels, (void *)colorbuffer, width * height * 3);
FIBITMAP *img = FreeImage_ConvertFromRawBits(pixels, width, height, width * 3, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);
std::cout << "Saving screenshot: " << fname << "\n";
FreeImage_Save(FIF_PNG, img, fname.c_str(), 0);
delete pixels;
FreeImage_DeInitialise();
}
void Fisheye::render_scene(World& w) {
RGBColor L;
ViewPlane vp(w.vp);
FreeImage_Initialise();
FIBITMAP* bitmap = FreeImage_Allocate(vp.hres, vp.vres, 24);
RGBQUAD color;
int hres = vp.hres;
int vres = vp.vres;
float s = vp.s;
Ray ray;
int depth = 0;
Point2D sp;
Point2D pp;
float r_squared;
ray.o = eye;
for(int r = 0; r < vres; r++)
for(int c = 0; c < hres; c++) {
L = black;
for(int j = 0; j < vp.num_samples; j++) {
sp = vp.sampler_ptr -> sample_unit_square();
pp.x = s * (c - hres / 2.0 + sp.x);
pp.y = s * (r - vres / 2.0 + sp.y);
ray.d = ray_direction(pp, hres, vres, s, r_squared);
if(r_squared <= 1.0)
L += w.tracer_ptr -> trace_ray(ray);
}
L /= vp.num_samples;
L *= exposure_time;
w.display_pixel(r, c, L);
color.rgbRed = (int)(L.r*255);
color.rgbGreen = (int)(L.g*255);
color.rgbBlue = (int)(L.b*255);
FreeImage_SetPixelColor(bitmap, c, r, &color);
}
if (FreeImage_Save(FIF_PNG, bitmap, "test.png", 0))
std::cout << "Image Successfully Saved!" << std::endl;
FreeImage_DeInitialise();
}
int main(int argc, const char **argv) {
if (argc == 5) {
doingTransfer = true;
}
else {
doingTransfer = false;
}
if (argc != 3 && argc != 5) {
std::cerr << "usage: " << argv[0] << " <src> <dst> <src-crsp> <dst-crsp> " << std::endl;
return 2;
}
blockHeight = 64;
blockWidth = 64;
numIterations = 1;
vertOverlapAmount = 10;
horizOverlapAmount = 10;
FreeImage_Initialise(true);
const int rows = 8;
const int cols = 8;
Image * const src = new Image();
src->load(argv[1]);
Image * const dst = allocate(rows, cols);
srand(time(NULL));
Image * const src_crsp = doingTransfer ? new Image() : NULL;
Image * const dst_crsp = doingTransfer ? new Image() : NULL;
if (doingTransfer) {
src_crsp->load(argv[3]);
dst_crsp->load(argv[4]);
}
quilt(dst, dst_crsp, rows, cols, src, src_crsp);
dst->save(argv[2]);
delete dst;
delete src;
delete dst_crsp;
delete src_crsp;
FreeImage_DeInitialise();
}
void Globals::CleanUp()
{
SAFE_RELEASE(gEntityFactory);
SAFE_RELEASE(timer);
SAFE_RELEASE(gWorld);
SAFE_RELEASE(gKeyControl);
SAFE_DELETE(gFpsCamera);
SAFE_DELETE(gFollowCamera);
SAFE_DELETE(gRTSCamera);
gCurrentCamera = 0;
gAIControl = 0;
if (gDeleteAIPtr)
gDeleteAIPtr();
if (m_dll)
FreeModule(m_dll);
SAFE_DELETE(gFxEffectManager);
SAFE_DELETE(gRender);
SAFE_DELETE(gUI);
FreeImage_DeInitialise();
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
printf("Usage : cworld2img input_filename.bin output_filename.png\n\n");
return 0;
}
FreeImage_Initialise();
FIBITMAP *bitmap = FreeImage_Allocate(WORLD_WIDTH, WORLD_HEIGHT, 32);
if(!bitmap)
{
printf("Error while allocating image. Aborting");
return -1;
}
FILE *fd = fopen(argv[1], "rb");
fread(c_world.solids, sizeof(block), WORLD_HEIGHT * WORLD_WIDTH, fd);
fclose(fd);
for(int i = 0; i < WORLD_HEIGHT; i++)
{
for(int j = 0; j < WORLD_WIDTH; j++)
{
switch(c_world.solids[WORLD_WIDTH * i + j])
{
case BLCK_AIR:
FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_air);break;
case BLCK_DIRT:
FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_dirt);break;
default:
FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_unknown);break;
}
}
}
if(!FreeImage_Save(FIF_PNG, bitmap, argv[2], 0))
{
printf("Error while saving image. Aborting");
return -1;
}
FreeImage_DeInitialise();
return 0;
}
//----------------------------------------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------------------------------------
void azImage::Initialize()
{
azSz szFilePath = azL("F://Dev//Aztec//Bin//Debug//Test.png");
FreeImage_Initialise();
fipImage oFreeImage;
#ifdef UNICODE
azBool bLoaded = (0 != oFreeImage.loadU(szFilePath));
#else // UNICODE
azBool bLoaded = (0 != oFreeImage.load(szFilePath));
#endif // UNICODE
azAssert(bLoaded, "Image extension or format not supported");
azAssert(oFreeImage.getBitsPerPixel() <= 32, "More than 32 BPP images not yet supported, there will be some data loss");
// Always convert to RGBA 32 bits
azBool bConverted = (0 != oFreeImage.convertTo32Bits());
azAssert(bConverted, "Image recognized but we failed to convert it to 32 BPP");
m_uWidth = oFreeImage.getWidth();
m_uHeight = oFreeImage.getHeight();
m_uBpp = oFreeImage.getBitsPerPixel();
azAssert(m_uBpp == 32, "Convert didn't work properly");
azUInt uBufferSize = GetBufferSize();
m_abData = azNewArray(azByte, uBufferSize);
// There is no C++ wrapping for this method.
FreeImage_ConvertToRawBits(m_abData,
oFreeImage,
oFreeImage.getScanWidth(),
m_uBpp,
FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK,
true);
oFreeImage.clear();
FreeImage_DeInitialise();
}
unsigned char* Texture::loadTexture( const char* fileName_,
unsigned int &width_,
unsigned int &height_ )
{
FreeImage_Initialise(TRUE);
FREE_IMAGE_FORMAT format = FreeImage_GetFileType(fileName_, 0);
if (format == FIF_UNKNOWN)
format = FreeImage_GetFIFFromFilename(fileName_);
if ((format == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading(format))
return NULL;
FIBITMAP* img = FreeImage_Load(format, fileName_);
if (img == NULL)
return NULL;
FIBITMAP* tempImg = img;
img = FreeImage_ConvertTo32Bits(img);
FreeImage_Unload(tempImg);
width_ = FreeImage_GetWidth(img);
height_ = FreeImage_GetHeight(img);
//BGRA a RGBA
unsigned char * map = new unsigned char[4 * width_*height_];
char *buff = (char*)FreeImage_GetBits(img);
for (unsigned int j = 0; j<width_*height_; j++){
map[j * 4 + 0] = buff[j * 4 + 2];
map[j * 4 + 1] = buff[j * 4 + 1];
map[j * 4 + 2] = buff[j * 4 + 0];
map[j * 4 + 3] = buff[j * 4 + 3];
}
FreeImage_Unload(img);
FreeImage_DeInitialise();
return map;
}
Image::Image(const char *image_path, GLuint textureUnit, bool& success) {
success = true;
FreeImage_Initialise();
texture_unit = textureUnit;
// Load Texture
FREE_IMAGE_FORMAT image_format = FreeImage_GetFileType(image_path,0);
FIBITMAP* image_bgr = FreeImage_Load(image_format, image_path);
if (!image_bgr) {
fprintf(stdout, "Failed to load image %s", image_path);
success = false;
}
FIBITMAP* temp = image_bgr;
image_bgr = FreeImage_ConvertTo32Bits(image_bgr);
FreeImage_Unload(temp);
im_width = FreeImage_GetWidth(image_bgr);
im_height = FreeImage_GetHeight(image_bgr);
GLubyte* image_texture = new GLubyte[4*im_width*im_height];
char* image_pixeles = (char*)FreeImage_GetBits(image_bgr);
//FreeImage loads in BGR format, so you need to swap some bytes(Or use GL_BGR).
for(int j= 0; j<im_width*im_height; j++){
image_texture[j*4+0]= image_pixeles[j*4+2];
image_texture[j*4+1]= image_pixeles[j*4+1];
image_texture[j*4+2]= image_pixeles[j*4+0];
image_texture[j*4+3]= image_pixeles[j*4+3];
}
FreeImage_DeInitialise();
// Create one OpenGL texture
glGenTextures(1, &texture_handle);
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(GL_TEXTURE_2D, texture_handle);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA, im_width, im_height, 0, GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid*)image_texture );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,0);
}
GLuint scene::Loadtexture(const char* pFilename) {
FreeImage_Initialise();
GLuint texObject = 0;
glGenTextures(1, &texObject);
int error = glGetError();
FIBITMAP* pImage = FreeImage_Load(FreeImage_GetFileType(pFilename, 0), pFilename);
FIBITMAP *p32BitsImage = FreeImage_ConvertTo32Bits(pImage);
int iWidth = FreeImage_GetWidth(p32BitsImage);
int iHeight = FreeImage_GetHeight(p32BitsImage);
glBindTexture(GL_TEXTURE_2D, texObject);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iWidth, iHeight,
0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(p32BitsImage));
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
FreeImage_Unload(p32BitsImage);
FreeImage_Unload(pImage);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
return texObject;
FreeImage_DeInitialise();
}
int main(int argc,char* argv[]) {
//Initialize GLUT
FreeImage_Initialise();
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutCreateWindow("HW1: Transformations");
GLenum err = glewInit() ;
if (GLEW_OK != err) {
std::cerr << "Error: " << glewGetString(err) << std::endl;
}
init();
glutDisplayFunc(display);
glutSpecialFunc(specialKey);
glutKeyboardFunc(keyboard);
glutReshapeFunc(reshape);
glutReshapeWindow(w,h);
if(argc > 1) {
allowGrader = true;
grader.init(argv[1]);
grader.loadCommands(argv[1]);
grader.bindDisplayFunc(display);
grader.bindSpecialFunc(specialKey);
grader.bindKeyboardFunc(keyboard);
grader.bindScreenshotFunc(saveScreenshot);
}
printHelp();
glutMainLoop();
FreeImage_DeInitialise();
return 0;
}
void pre_lzw_mp::do_lzw(QString n){
QString job = n;
QString images_src = src + "\\" +n;
QString write_dst = dst + "\\" + n;
QString image_name, saved_name;
int dot_pos;
QString image_path;
QDir images_dir(images_src);
QDir write_dir(dst);
write_dir.mkdir(job);
qDebug()<<images_src;
qDebug()<<write_dst;
QFileInfoList images_info_list = images_dir.entryInfoList();
QList<QFileInfo>::iterator image_iter = images_info_list.begin();
FreeImage_Initialise(true);
for(; image_iter < images_info_list.end(); ++image_iter){
if((*image_iter).isDir()){
// qDebug()<<(*image_iter).fileName();
continue;
}
image_name = (*image_iter).fileName();
dot_pos = image_name.indexOf(".");
saved_name = write_dst + "\\" + image_name.left(dot_pos) + "_c.tif";
image_path = (*image_iter).absoluteFilePath();
FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(image_path.toStdString().c_str(), 0);
if(fif == FIF_UNKNOWN){
fif = FreeImage_GetFIFFromFilename(image_path.toStdString().c_str());
}
if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)){
FIBITMAP *image = FreeImage_Load(fif, image_path.toStdString().c_str());
FreeImage_Save(FIF_TIFF, image, saved_name.toStdString().c_str(), TIFF_LZW);
FreeImage_Unload(image);
}
}
FreeImage_DeInitialise();
}
void Texture::shutdownTextureSystem() {
freeimage_init_lock_.lock();
FreeImage_DeInitialise();
freeimage_init_ = false;
freeimage_init_lock_.unlock();
}
void releaseFreeImage() {
FreeImage_DeInitialise();
}
FreeImage::~FreeImage() {
FreeImage_DeInitialise();
}
int
main(int argc, char *argv[]) {
const char *input_dir = "d:\\images\\";
FIBITMAP *dib = NULL;
int id = 1;
// call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
FreeImage_Initialise();
#endif // FREEIMAGE_LIB
// initialize your own FreeImage error handler
FreeImage_SetOutputMessage(FreeImageErrorHandler);
// print version & copyright infos
printf(FreeImage_GetVersion());
printf("\n");
printf(FreeImage_GetCopyrightMessage());
printf("\n");
// open the log file
FILE *log_file = fopen("log_file.txt", "w");
// batch convert all supported bitmaps
_finddata_t finddata;
long handle;
char image_path[MAX_PATH];
// scan all files
strcpy(image_path, input_dir);
strcat(image_path, "*.*");
if ((handle = _findfirst(image_path, &finddata)) != -1) {
do {
// make a path to a directory
char *directory = new char[MAX_PATH];
strcpy(directory, input_dir);
strcat(directory, finddata.name);
// make a unique filename
char *unique = new char[128];
itoa(id, unique, 10);
strcat(unique, ".png");
// open and load the file using the default load option
dib = GenericLoader(directory, 0);
if (dib != NULL) {
// save the file as PNG
bool bSuccess = GenericWriter(dib, unique, PNG_DEFAULT);
// free the dib
FreeImage_Unload(dib);
if(bSuccess) {
fwrite(unique, strlen(unique), 1, log_file);
} else {
strcpy(unique, "FAILED");
fwrite(unique, strlen(unique), 1, log_file);
}
fwrite(" >> ", 4, 1, log_file);
fwrite(directory, strlen(directory), 1, log_file);
fwrite("\n", 1, 1, log_file);
id++;
}
delete [] unique;
delete [] directory;
} while (_findnext(handle, &finddata) == 0);
_findclose(handle);
}
fclose(log_file);
// call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
FreeImage_DeInitialise();
#endif // FREEIMAGE_LIB
return 0;
}
