/* dt of binary image using squared distance */
FIBITMAP *DLL_CALLCONV
FIA_DistanceTransform (FIBITMAP * src)
{
int width = FreeImage_GetWidth (src);
int height = FreeImage_GetHeight (src);
float *out_ptr;
unsigned char *src_ptr;
FIBITMAP *out = FIA_ConvertToGreyscaleFloatType (src, FIT_FLOAT);
for(register int y = 0; y < height; y++)
{
src_ptr = (unsigned char *) FreeImage_GetScanLine (src, y);
out_ptr = (float *) FreeImage_GetScanLine (out, y);
for(register int x = 0; x < width; x++)
{
if (src_ptr[x] == 0)
{
out_ptr[x] = 0.0f;
}
else
{
out_ptr[x] = INF;
}
}
}
dt2d (out);
// take square roots
for(register int y = 0; y < height; y++)
{
out_ptr = (float *) FreeImage_GetScanLine (out, y);
for(register int x = 0; x < width; x++)
{
out_ptr[x] = sqrt (out_ptr[x]);
}
}
FIBITMAP *ret = FreeImage_ConvertToStandardType (out, 1);
FreeImage_Unload (out);
return ret;
}
void
ShowImage(FIBITMAP *src)
{
MSG msg;
FIBITMAP *src2;
// initialize window classes
InitMainWnd();
hwndMain = CreateMainWnd();
hdc = GetDC(hwndMain);
assert(hdc != NULL);
src2 = FreeImage_ConvertToStandardType(src);
int width = FreeImage_GetWidth(src2);
int height = FreeImage_GetHeight(src2);
hbitmap = GetDibSection(src2, hdc, 0, 0, width, height);
assert(hbitmap != NULL);
hbitmap_hdc = CreateCompatibleDC(hdc);
// Associate the new DC with the bitmap for drawing
SelectObject( hbitmap_hdc, hbitmap );
ShowWindow(hwndMain, 1);
// message-loop
while(GetMessage(&msg, NULL, 0, 0) > 0)
{
DispatchMessage(&msg);
}
}
FIBITMAP* DLL_CALLCONV
FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear) {
FIBITMAP *dst = NULL;
if(!FreeImage_HasPixels(src)) return NULL;
// convert from src_type to dst_type
const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(src);
if(src_type == dst_type) {
return FreeImage_Clone(src);
}
const unsigned src_bpp = FreeImage_GetBPP(src);
switch(src_type) {
case FIT_BITMAP:
switch(dst_type) {
case FIT_UINT16:
dst = FreeImage_ConvertToUINT16(src);
break;
case FIT_INT16:
dst = (src_bpp == 8) ? convertByteToShort.convert(src, dst_type) : NULL;
break;
case FIT_UINT32:
dst = (src_bpp == 8) ? convertByteToULong.convert(src, dst_type) : NULL;
break;
case FIT_INT32:
dst = (src_bpp == 8) ? convertByteToLong.convert(src, dst_type) : NULL;
break;
case FIT_FLOAT:
dst = FreeImage_ConvertToFloat(src);
break;
case FIT_DOUBLE:
dst = (src_bpp == 8) ? convertByteToDouble.convert(src, dst_type) : NULL;
break;
case FIT_COMPLEX:
dst = (src_bpp == 8) ? convertByteToComplex.convert(src) : NULL;
break;
case FIT_RGB16:
dst = FreeImage_ConvertToRGB16(src);
break;
case FIT_RGBA16:
dst = FreeImage_ConvertToRGBA16(src);
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
dst = FreeImage_ConvertToRGBAF(src);
break;
}
break;
case FIT_UINT16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = FreeImage_ConvertToFloat(src);
break;
case FIT_DOUBLE:
dst = convertUShortToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertUShortToComplex.convert(src);
break;
case FIT_RGB16:
dst = FreeImage_ConvertToRGB16(src);
break;
case FIT_RGBA16:
dst = FreeImage_ConvertToRGBA16(src);
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
dst = FreeImage_ConvertToRGBAF(src);
break;
}
break;
case FIT_INT16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = convertShortToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertShortToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertShortToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_UINT32:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = convertULongToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertULongToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertULongToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_INT32:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_FLOAT:
dst = convertLongToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertLongToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertLongToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_FLOAT:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_DOUBLE:
dst = convertFloatToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertFloatToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
dst = FreeImage_ConvertToRGBAF(src);
break;
}
break;
case FIT_DOUBLE:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_COMPLEX:
dst = convertDoubleToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_COMPLEX:
switch(dst_type) {
case FIT_BITMAP:
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_DOUBLE:
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_RGB16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertTo24Bits(src);
break;
case FIT_UINT16:
dst = FreeImage_ConvertToUINT16(src);
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = FreeImage_ConvertToFloat(src);
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGBA16:
dst = FreeImage_ConvertToRGBA16(src);
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
dst = FreeImage_ConvertToRGBAF(src);
break;
}
break;
case FIT_RGBA16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertTo32Bits(src);
break;
case FIT_UINT16:
dst = FreeImage_ConvertToUINT16(src);
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = FreeImage_ConvertToFloat(src);
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGB16:
dst = FreeImage_ConvertToRGB16(src);
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
dst = FreeImage_ConvertToRGBAF(src);
break;
}
break;
case FIT_RGBF:
switch(dst_type) {
case FIT_BITMAP:
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = FreeImage_ConvertToFloat(src);
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBAF:
dst = FreeImage_ConvertToRGBAF(src);
break;
}
break;
case FIT_RGBAF:
switch(dst_type) {
case FIT_BITMAP:
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = FreeImage_ConvertToFloat(src);
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
}
break;
}
if(NULL == dst) {
FreeImage_OutputMessageProc(FIF_UNKNOWN, "FREE_IMAGE_TYPE: Unable to convert from type %d to type %d.\n No such conversion exists.", src_type, dst_type);
}
return dst;
}
FIBITMAP * DLL_CALLCONV
FreeImage_MakeThumbnail(FIBITMAP *dib, int max_pixel_size, BOOL convert) {
FIBITMAP *thumbnail = NULL;
int new_width, new_height;
if(!FreeImage_HasPixels(dib) || (max_pixel_size <= 0)) return NULL;
int width = FreeImage_GetWidth(dib);
int height = FreeImage_GetHeight(dib);
if(max_pixel_size == 0) max_pixel_size = 1;
if((width < max_pixel_size) && (height < max_pixel_size)) {
// image is smaller than the requested thumbnail
return FreeImage_Clone(dib);
}
if(width > height) {
new_width = max_pixel_size;
// change image height with the same ratio
double ratio = ((double)new_width / (double)width);
new_height = (int)(height * ratio + 0.5);
if(new_height == 0) new_height = 1;
} else {
new_height = max_pixel_size;
// change image width with the same ratio
double ratio = ((double)new_height / (double)height);
new_width = (int)(width * ratio + 0.5);
if(new_width == 0) new_width = 1;
}
const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
// perform downsampling using a bilinear interpolation
switch(image_type) {
case FIT_BITMAP:
case FIT_UINT16:
case FIT_RGB16:
case FIT_RGBA16:
case FIT_FLOAT:
case FIT_RGBF:
case FIT_RGBAF:
{
FREE_IMAGE_FILTER filter = FILTER_BILINEAR;
thumbnail = FreeImage_Rescale(dib, new_width, new_height, filter);
}
break;
case FIT_INT16:
case FIT_UINT32:
case FIT_INT32:
case FIT_DOUBLE:
case FIT_COMPLEX:
default:
// cannot rescale this kind of image
thumbnail = NULL;
break;
}
if((thumbnail != NULL) && (image_type != FIT_BITMAP) && convert) {
// convert to a standard bitmap
FIBITMAP *bitmap = NULL;
switch((int)image_type) {
case FIT_UINT16:
bitmap = FreeImage_ConvertTo8Bits(thumbnail);
break;
case FIT_RGB16:
bitmap = FreeImage_ConvertTo24Bits(thumbnail);
break;
case FIT_RGBA16:
bitmap = FreeImage_ConvertTo32Bits(thumbnail);
break;
case FIT_FLOAT:
bitmap = FreeImage_ConvertToStandardType(thumbnail, TRUE);
break;
case FIT_RGBF:
bitmap = FreeImage_ToneMapping(thumbnail, FITMO_DRAGO03);
break;
case FIT_RGBAF:
// no way to keep the transparency yet ...
FIBITMAP *rgbf = FreeImage_ConvertToRGBF(thumbnail);
bitmap = FreeImage_ToneMapping(rgbf, FITMO_DRAGO03);
FreeImage_Unload(rgbf);
break;
}
if(bitmap != NULL) {
FreeImage_Unload(thumbnail);
thumbnail = bitmap;
}
}
// copy metadata from src to dst
FreeImage_CloneMetadata(thumbnail, dib);
return thumbnail;
}
void fipWinImage::drawEx(HDC hDC, RECT& rcDest, BOOL useFileBkg, RGBQUAD *appBkColor, FIBITMAP *bg) const {
// Convert to a standard bitmap if needed
if(_bHasChanged) {
if(_bDeleteMe) {
FreeImage_Unload(_display_dib);
_display_dib = NULL;
_bDeleteMe = FALSE;
}
FREE_IMAGE_TYPE image_type = getImageType();
if(image_type == FIT_BITMAP) {
BOOL bHasBackground = FreeImage_HasBackgroundColor(_dib);
BOOL bIsTransparent = FreeImage_IsTransparent(_dib);
if(!bIsTransparent && (!bHasBackground || !useFileBkg)) {
// Copy pointer
_display_dib = _dib;
}
else {
// Create the transparent / alpha blended image
_display_dib = FreeImage_Composite(_dib, useFileBkg, appBkColor, bg);
if(_display_dib) {
// Remember to delete _display_dib
_bDeleteMe = TRUE;
} else {
// Something failed: copy pointers
_display_dib = _dib;
}
}
} else {
// Convert to a standard dib for display
if(image_type == FIT_COMPLEX) {
// Convert to type FIT_DOUBLE
FIBITMAP *dib_double = FreeImage_GetComplexChannel(_dib, FICC_MAG);
// Convert to a standard bitmap (linear scaling)
_display_dib = FreeImage_ConvertToStandardType(dib_double, TRUE);
// Free image of type FIT_DOUBLE
FreeImage_Unload(dib_double);
} else if((image_type == FIT_RGBF) || (image_type == FIT_RGB16)) {
// Apply a tone mapping algorithm and convert to 24-bit
_display_dib = FreeImage_ToneMapping(_dib, _tmo, _tmo_param_1, _tmo_param_2);
} else if(image_type == FIT_RGBA16) {
// Convert to 32-bit
FIBITMAP *dib32 = FreeImage_ConvertTo32Bits(_dib);
if(dib32) {
// Create the transparent / alpha blended image
_display_dib = FreeImage_Composite(dib32, useFileBkg, appBkColor, bg);
FreeImage_Unload(dib32);
}
} else {
// Other cases: convert to a standard bitmap (linear scaling)
_display_dib = FreeImage_ConvertToStandardType(_dib, TRUE);
}
// Remember to delete _display_dib
_bDeleteMe = TRUE;
}
_bHasChanged = FALSE;
}
// Draw the dib
SetStretchBltMode(hDC, COLORONCOLOR);
StretchDIBits(hDC, rcDest.left, rcDest.top,
rcDest.right-rcDest.left, rcDest.bottom-rcDest.top,
0, 0, FreeImage_GetWidth(_display_dib), FreeImage_GetHeight(_display_dib),
FreeImage_GetBits(_display_dib), FreeImage_GetInfo(_display_dib), DIB_RGB_COLORS, SRCCOPY);
}
FIBITMAP* DLL_CALLCONV
FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear) {
FIBITMAP *dst = NULL;
if(!src) return NULL;
// convert from src_type to dst_type
const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(src);
if(src_type == dst_type) {
return FreeImage_Clone(src);
}
if(src_type == FIT_BITMAP) {
const unsigned src_bpp = FreeImage_GetBPP(src);
if(((src_bpp == 24) || (src_bpp == 32)) && (dst_type != FIT_RGBF)) {
FreeImage_OutputMessageProc(FIF_UNKNOWN, "FREE_IMAGE_TYPE: Only 24-/32-bit dib can be converted to type %d.", dst_type);
return NULL;
}
else if(src_bpp != 8) {
FreeImage_OutputMessageProc(FIF_UNKNOWN, "FREE_IMAGE_TYPE: Only 8-bit dib can be converted to type %d.", dst_type);
return NULL;
}
}
switch(src_type) {
case FIT_BITMAP:
switch(dst_type) {
case FIT_UINT16:
dst = convertByteToUShort.convert(src, dst_type);
break;
case FIT_INT16:
dst = convertByteToShort.convert(src, dst_type);
break;
case FIT_UINT32:
dst = convertByteToULong.convert(src, dst_type);
break;
case FIT_INT32:
dst = convertByteToLong.convert(src, dst_type);
break;
case FIT_FLOAT:
dst = convertByteToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertByteToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertByteToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
break;
}
break;
case FIT_UINT16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = convertUShortToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertUShortToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertUShortToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_INT16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = convertShortToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertShortToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertShortToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_UINT32:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
dst = convertULongToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertULongToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertULongToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_INT32:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_FLOAT:
dst = convertLongToFloat.convert(src, dst_type);
break;
case FIT_DOUBLE:
dst = convertLongToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertLongToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_FLOAT:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_DOUBLE:
dst = convertFloatToDouble.convert(src, dst_type);
break;
case FIT_COMPLEX:
dst = convertFloatToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_DOUBLE:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertToStandardType(src, scale_linear);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_COMPLEX:
dst = convertDoubleToComplex.convert(src);
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_COMPLEX:
switch(dst_type) {
case FIT_BITMAP:
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_DOUBLE:
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_RGB16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertTo24Bits(src);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
break;
}
break;
case FIT_RGBA16:
switch(dst_type) {
case FIT_BITMAP:
dst = FreeImage_ConvertTo32Bits(src);
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGB16:
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
case FIT_RGBAF:
break;
}
break;
case FIT_RGBF:
switch(dst_type) {
case FIT_BITMAP:
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBAF:
break;
}
break;
case FIT_RGBAF:
switch(dst_type) {
case FIT_BITMAP:
break;
case FIT_UINT16:
break;
case FIT_INT16:
break;
case FIT_UINT32:
break;
case FIT_INT32:
break;
case FIT_FLOAT:
break;
case FIT_DOUBLE:
break;
case FIT_COMPLEX:
break;
case FIT_RGB16:
break;
case FIT_RGBA16:
break;
case FIT_RGBF:
dst = FreeImage_ConvertToRGBF(src);
break;
}
break;
}
if(NULL == dst) {
FreeImage_OutputMessageProc(FIF_UNKNOWN, "FREE_IMAGE_TYPE: Unable to convert from type %d to type %d.\n No such conversion exists.", src_type, dst_type);
} else {
// copy metadata from src to dst
FreeImage_CloneMetadata(dst, src);
}
return dst;
}
bool convert(const std::string &filename) {
std::string file = removePath(filename);
std::string outFile = getPrefix(filename, '.') + ".cfrt";
/* Retrieve file format */
FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(filename.c_str(), 0);
if (fif == FIF_UNKNOWN) fif = FreeImage_GetFIFFromFilename(filename.c_str());
if (fif == FIF_UNKNOWN) {
std::cout << "Unknown file format " << file << std::endl;
return false;
}
/* Load image */
FIBITMAP *dib = nullptr;
if (FreeImage_FIFSupportsReading(fif)) dib = FreeImage_Load(fif, filename.c_str());
if (!dib) {
std::cout << "Failed to load " << file << std::endl;
return false;
}
/* Convert to standard format if necessary */
if (FreeImage_GetImageType(dib) != FIT_BITMAP) {
FIBITMAP *tmp = dib;
dib = FreeImage_ConvertToStandardType(dib);
FreeImage_Unload(tmp);
if (!dib) {
std::cout << "Failed to convert " << file << " to standard type." << std::endl;
return false;
}
}
/* Convert bpp if needed */
unsigned int bpp = FreeImage_GetBPP(dib);
if (bpp <= 8) {
FIBITMAP *tmp = dib;
dib = FreeImage_ConvertToGreyscale(dib);
FreeImage_Unload(tmp);
bpp = 8;
if (!dib || FreeImage_GetBPP(dib) != 8) bpp = 0;
} else if (bpp > 32) {
FIBITMAP *tmp = dib;
dib = FreeImage_ConvertTo32Bits(dib);
FreeImage_Unload(tmp);
bpp = 32;
if (!dib || FreeImage_GetBPP(dib) != 32) bpp = 0;
}
/* Get image information */
unsigned int width = FreeImage_GetWidth(dib);
unsigned int height = FreeImage_GetHeight(dib);
unsigned int bytes = 1;
unsigned int channels = 0;
switch (bpp) {
case 8: channels = 1; break;
case 24: channels = 3; break;
case 32: channels = 4; break;
default: bpp = 0;
}
/* Check if image is valid */
if (!dib || bpp == 0 || width == 0 || height == 0 || !FreeImage_HasPixels(dib)) {
if (dib) FreeImage_Unload(dib);
std::cout << "Invalid image " << file << std::endl;
return false;
}
std::cout << file << " Loaded. Converting.\n";
/* Create CFR texture */
CFR::Texture texture(
width, height, 1,
channels, bytes
);
/* Set texture pixels */
for (unsigned int y = 0; y < height; y++) {
BYTE* bits = FreeImage_GetScanLine(dib, height - y - 1);
for (unsigned int x = 0; x < width; x++) {
CFR::Pixel8 pixel(0, 0, 0, 0);
BYTE *p = bits + (channels * x);
if (channels >= 1) pixel.r = p[FI_RGBA_RED];
if (channels >= 2) pixel.g = p[FI_RGBA_GREEN];
if (channels >= 3) pixel.b = p[FI_RGBA_BLUE];
if (channels >= 4) pixel.a = p[FI_RGBA_ALPHA];
texture.setPixel8(pixel, x, y, 0);
}
}
/* Unload image */
FreeImage_Unload(dib);
/* Save texture */
try {
texture.saveToFile(outFile);
} catch (CFR::Exception &fail) {
std::cout << "Failed to save " << removePath(outFile) << ": " << fail.what() << std::endl;
}
return true;
}
