#include "FreeImage.h"

#include "Utilities.h"

#define RBLOCK 64 // image blocks of RBLOCK*RBLOCK pixels

template <class T> void

HorizontalSkewT(FIBITMAP *src, FIBITMAP *dst, int row, int iOffset, double weight, const void *bkcolor = NULL) {

}

static void

HorizontalSkew(FIBITMAP *src, FIBITMAP *dst, int row, int iOffset, double dWeight, const void *bkcolor) {

}

template <class T> void

VerticalSkewT(FIBITMAP *src, FIBITMAP *dst, int col, int iOffset, double weight, const void *bkcolor = NULL) {

}

static void

VerticalSkew(FIBITMAP *src, FIBITMAP *dst, int col, int iOffset, double dWeight, const void *bkcolor) {

}

static FIBITMAP*

Rotate90(FIBITMAP *src) {

const unsigned bpp = FreeImage_GetBPP(src);

const unsigned src_width = FreeImage_GetWidth(src);

const unsigned src_height = FreeImage_GetHeight(src);

const unsigned dst_width = src_height;

const unsigned dst_height = src_width;

FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(src);

// allocate and clear dst image

FIBITMAP *dst = FreeImage_AllocateT(image_type, dst_width, dst_height, bpp);

if(NULL == dst) return NULL;

// get src and dst scan width

const unsigned src_pitch = FreeImage_GetPitch(src);

const unsigned dst_pitch = FreeImage_GetPitch(dst);

switch(image_type) {

case FIT_BITMAP:

if(bpp == 1) {

// speedy rotate for BW images

BYTE *bsrc = FreeImage_GetBits(src);

BYTE *bdest = FreeImage_GetBits(dst);

BYTE *dbitsmax = bdest + dst_height * dst_pitch - 1;

for(unsigned y = 0; y < src_height; y++) {

// figure out the column we are going to be copying to

const div_t div_r = div(y, 8);

// set bit pos of src column byte

const BYTE bitpos = (BYTE)(128 >> div_r.rem);

BYTE *srcdisp = bsrc + y * src_pitch;

for(unsigned x = 0; x < src_pitch; x++) {

// get source bits

BYTE *sbits = srcdisp + x;

// get destination column

BYTE *nrow = bdest + (dst_height - 1 - (x * 8)) * dst_pitch + div_r.quot;

for (int z = 0; z < 8; z++) {

// get destination byte

BYTE *dbits = nrow - z * dst_pitch;

if ((dbits < bdest) || (dbits > dbitsmax)) break;

if (*sbits & (128 >> z)) *dbits |= bitpos;

}

}

}

}

else if((bpp == 8) || (bpp == 24) || (bpp == 32)) {

// anything other than BW :

// This optimized version of rotation rotates image by smaller blocks. It is quite

// a bit faster than obvious algorithm, because it produces much less CPU cache misses.

// This optimization can be tuned by changing block size (RBLOCK). 96 is good value for current

// CPUs (tested on Athlon XP and Celeron D). Larger value (if CPU has enough cache) will increase

// speed somehow, but once you drop out of CPU's cache, things will slow down drastically.

// For older CPUs with less cache, lower value would yield better results.

BYTE *bsrc = FreeImage_GetBits(src); // source pixels

BYTE *bdest = FreeImage_GetBits(dst); // destination pixels

// calculate the number of bytes per pixel (1 for 8-bit, 3 for 24-bit or 4 for 32-bit)

const unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);

// for all image blocks of RBLOCK*RBLOCK pixels

// x-segment

for(unsigned xs = 0; xs < dst_width; xs += RBLOCK) {

// y-segment

for(unsigned ys = 0; ys < dst_height; ys += RBLOCK) {

for(unsigned y = ys; y < MIN(dst_height, ys + RBLOCK); y++) { // do rotation

const unsigned y2 = dst_height - y - 1;

// point to src pixel at (y2, xs)

BYTE *src_bits = bsrc + (xs * src_pitch) + (y2 * bytespp);

// point to dst pixel at (xs, y)

BYTE *dst_bits = bdest + (y * dst_pitch) + (xs * bytespp);

for(unsigned x = xs; x < MIN(dst_width, xs + RBLOCK); x++) {

// dst.SetPixel(x, y, src.GetPixel(y2, x));

AssignPixel(dst_bits, src_bits, bytespp);

dst_bits += bytespp;

src_bits += src_pitch;

}

}

}

}

}

break;

case FIT_UINT16:

case FIT_RGB16:

case FIT_RGBA16:

case FIT_FLOAT:

case FIT_RGBF:

case FIT_RGBAF:

{

BYTE *bsrc = FreeImage_GetBits(src); // source pixels

BYTE *bdest = FreeImage_GetBits(dst); // destination pixels

// calculate the number of bytes per pixel

const unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);

for(unsigned y = 0; y < dst_height; y++) {

BYTE *src_bits = bsrc + (src_width - 1 - y) * bytespp;

BYTE *dst_bits = bdest + (y * dst_pitch);

for(unsigned x = 0; x < dst_width; x++) {

AssignPixel(dst_bits, src_bits, bytespp);

src_bits += src_pitch;

dst_bits += bytespp;

}

}

}

break;

}

return dst;

}

static FIBITMAP*

Rotate180(FIBITMAP *src) {

int x, y, k, pos;

const int bpp = FreeImage_GetBPP(src);

const int src_width = FreeImage_GetWidth(src);

const int src_height = FreeImage_GetHeight(src);

const int dst_width = src_width;

const int dst_height = src_height;

FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(src);

FIBITMAP *dst = FreeImage_AllocateT(image_type, dst_width, dst_height, bpp);

if(NULL == dst) return NULL;

switch(image_type) {

case FIT_BITMAP:

if(bpp == 1) {

for(int y = 0; y < src_height; y++) {

BYTE *src_bits = FreeImage_GetScanLine(src, y);

BYTE *dst_bits = FreeImage_GetScanLine(dst, dst_height - y - 1);

for(int x = 0; x < src_width; x++) {

// get bit at (x, y)

k = (src_bits[x >> 3] & (0x80 >> (x & 0x07))) != 0;

// set bit at (dst_width - x - 1, dst_height - y - 1)

pos = dst_width - x - 1;

k ? dst_bits[pos >> 3] |= (0x80 >> (pos & 0x7)) : dst_bits[pos >> 3] &= (0xFF7F >> (pos & 0x7));

}

}

break;

}

// else if((bpp == 8) || (bpp == 24) || (bpp == 32)) FALL TROUGH

case FIT_UINT16:

case FIT_RGB16:

case FIT_RGBA16:

case FIT_FLOAT:

case FIT_RGBF:

case FIT_RGBAF:

{

// Calculate the number of bytes per pixel

const int bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);

for(y = 0; y < src_height; y++) {

BYTE *src_bits = FreeImage_GetScanLine(src, y);

BYTE *dst_bits = FreeImage_GetScanLine(dst, dst_height - y - 1) + (dst_width - 1) * bytespp;

for(x = 0; x < src_width; x++) {

// get pixel at (x, y)

// set pixel at (dst_width - x - 1, dst_height - y - 1)

AssignPixel(dst_bits, src_bits, bytespp);

src_bits += bytespp;

dst_bits -= bytespp;

}

}

}

break;

}

return dst;

}

static FIBITMAP*

Rotate270(FIBITMAP *src) {

int x2, dlineup;

const unsigned bpp = FreeImage_GetBPP(src);

const unsigned src_width = FreeImage_GetWidth(src);

const unsigned src_height = FreeImage_GetHeight(src);

const unsigned dst_width = src_height;

const unsigned dst_height = src_width;

FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(src);

// allocate and clear dst image

FIBITMAP *dst = FreeImage_AllocateT(image_type, dst_width, dst_height, bpp);

if(NULL == dst) return NULL;

// get src and dst scan width

const unsigned src_pitch = FreeImage_GetPitch(src);

const unsigned dst_pitch = FreeImage_GetPitch(dst);

switch(image_type) {

case FIT_BITMAP:

if(bpp == 1) {

// speedy rotate for BW images

BYTE *bsrc = FreeImage_GetBits(src);

BYTE *bdest = FreeImage_GetBits(dst);

BYTE *dbitsmax = bdest + dst_height * dst_pitch - 1;

dlineup = 8 * dst_pitch - dst_width;

for(unsigned y = 0; y < src_height; y++) {

// figure out the column we are going to be copying to

const div_t div_r = div(y + dlineup, 8);

// set bit pos of src column byte

const BYTE bitpos = (BYTE)(1 << div_r.rem);

const BYTE *srcdisp = bsrc + y * src_pitch;

for(unsigned x = 0; x < src_pitch; x++) {

// get source bits

const BYTE *sbits = srcdisp + x;

// get destination column

BYTE *nrow = bdest + (x * 8) * dst_pitch + dst_pitch - 1 - div_r.quot;

for(unsigned z = 0; z < 8; z++) {

// get destination byte

BYTE *dbits = nrow + z * dst_pitch;

if ((dbits < bdest) || (dbits > dbitsmax)) break;

if (*sbits & (128 >> z)) *dbits |= bitpos;

}

}

}

}

else if((bpp == 8) || (bpp == 24) || (bpp == 32)) {

// anything other than BW :

// This optimized version of rotation rotates image by smaller blocks. It is quite

// a bit faster than obvious algorithm, because it produces much less CPU cache misses.

// This optimization can be tuned by changing block size (RBLOCK). 96 is good value for current

// CPUs (tested on Athlon XP and Celeron D). Larger value (if CPU has enough cache) will increase

// speed somehow, but once you drop out of CPU's cache, things will slow down drastically.

// For older CPUs with less cache, lower value would yield better results.

BYTE *bsrc = FreeImage_GetBits(src); // source pixels

BYTE *bdest = FreeImage_GetBits(dst); // destination pixels

// Calculate the number of bytes per pixel (1 for 8-bit, 3 for 24-bit or 4 for 32-bit)

const unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);

// for all image blocks of RBLOCK*RBLOCK pixels

// x-segment

for(unsigned xs = 0; xs < dst_width; xs += RBLOCK) {

// y-segment

for(unsigned ys = 0; ys < dst_height; ys += RBLOCK) {

for(unsigned x = xs; x < MIN(dst_width, xs + RBLOCK); x++) { // do rotation

x2 = dst_width - x - 1;

// point to src pixel at (ys, x2)

BYTE *src_bits = bsrc + (x2 * src_pitch) + (ys * bytespp);

// point to dst pixel at (x, ys)

BYTE *dst_bits = bdest + (ys * dst_pitch) + (x * bytespp);

for(unsigned y = ys; y < MIN(dst_height, ys + RBLOCK); y++) {

// dst.SetPixel(x, y, src.GetPixel(y, x2));

AssignPixel(dst_bits, src_bits, bytespp);

src_bits += bytespp;

dst_bits += dst_pitch;

}

}

}

}

}

break;

case FIT_UINT16:

case FIT_RGB16:

case FIT_RGBA16:

case FIT_FLOAT:

case FIT_RGBF:

case FIT_RGBAF:

{

BYTE *bsrc = FreeImage_GetBits(src); // source pixels

BYTE *bdest = FreeImage_GetBits(dst); // destination pixels

// calculate the number of bytes per pixel

const unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);

for(unsigned y = 0; y < dst_height; y++) {

BYTE *src_bits = bsrc + (src_height - 1) * src_pitch + y * bytespp;

BYTE *dst_bits = bdest + (y * dst_pitch);

for(unsigned x = 0; x < dst_width; x++) {

AssignPixel(dst_bits, src_bits, bytespp);

src_bits -= src_pitch;

dst_bits += bytespp;

}

}

}

break;

}

return dst;

}

static FIBITMAP*

Rotate45(FIBITMAP *src, double dAngle, const void *bkcolor) {

const double ROTATE_PI = double(3.1415926535897932384626433832795);

unsigned u;

const unsigned bpp = FreeImage_GetBPP(src);

const double dRadAngle = dAngle * ROTATE_PI / double(180); // Angle in radians

const double dSinE = sin(dRadAngle);

const double dTan = tan(dRadAngle / 2);

const unsigned src_width = FreeImage_GetWidth(src);

const unsigned src_height = FreeImage_GetHeight(src);

FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(src);

// Calc first shear (horizontal) destination image dimensions

const unsigned width_1 = src_width + unsigned((double)src_height * fabs(dTan) + 0.5);

const unsigned height_1 = src_height;

// Perform 1st shear (horizontal)

// ----------------------------------------------------------------------

// Allocate image for 1st shear

FIBITMAP *dst1 = FreeImage_AllocateT(image_type, width_1, height_1, bpp);

if(NULL == dst1) {

return NULL;

}

for(u = 0; u < height_1; u++) {

double dShear;

if(dTan >= 0) {

// Positive angle

dShear = (u + 0.5) * dTan;

}

else {

// Negative angle

dShear = (double(u) - height_1 + 0.5) * dTan;

}

int iShear = int(floor(dShear));

HorizontalSkew(src, dst1, u, iShear, dShear - double(iShear), bkcolor);

}

// Perform 2nd shear (vertical)

// ----------------------------------------------------------------------

// Calc 2nd shear (vertical) destination image dimensions

const unsigned width_2 = width_1;

unsigned height_2 = unsigned((double)src_width * fabs(dSinE) + (double)src_height * cos(dRadAngle) + 0.5) + 1;

// Allocate image for 2nd shear

FIBITMAP *dst2 = FreeImage_AllocateT(image_type, width_2, height_2, bpp);

if(NULL == dst2) {

FreeImage_Unload(dst1);

return NULL;

}

double dOffset; // Variable skew offset

if(dSinE > 0) {

// Positive angle

dOffset = (src_width - 1.0) * dSinE;

}

else {

// Negative angle

dOffset = -dSinE * (double(src_width) - width_2);

}

for(u = 0; u < width_2; u++, dOffset -= dSinE) {

int iShear = int(floor(dOffset));

VerticalSkew(dst1, dst2, u, iShear, dOffset - double(iShear), bkcolor);

}

// Perform 3rd shear (horizontal)

// ----------------------------------------------------------------------

// Free result of 1st shear

FreeImage_Unload(dst1);

// Calc 3rd shear (horizontal) destination image dimensions

const unsigned width_3 = unsigned(double(src_height) * fabs(dSinE) + double(src_width) * cos(dRadAngle) + 0.5) + 1;

const unsigned height_3 = height_2;

// Allocate image for 3rd shear

FIBITMAP *dst3 = FreeImage_AllocateT(image_type, width_3, height_3, bpp);

if(NULL == dst3) {

FreeImage_Unload(dst2);

return NULL;

}

if(dSinE >= 0) {

// Positive angle

dOffset = (src_width - 1.0) * dSinE * -dTan;

}

else {

// Negative angle

dOffset = dTan * ( (src_width - 1.0) * -dSinE + (1.0 - height_3) );

}

for(u = 0; u < height_3; u++, dOffset += dTan) {

int iShear = int(floor(dOffset));

HorizontalSkew(dst2, dst3, u, iShear, dOffset - double(iShear), bkcolor);

}

// Free result of 2nd shear

FreeImage_Unload(dst2);

// Return result of 3rd shear

return dst3;

}

static FIBITMAP*

RotateAny(FIBITMAP *src, double dAngle, const void *bkcolor) {

if(NULL == src) {

return NULL;

}

FIBITMAP *image = src;

while(dAngle >= 360) {

// Bring angle to range of (-INF .. 360)

dAngle -= 360;

}

while(dAngle < 0) {

// Bring angle to range of [0 .. 360)

dAngle += 360;

}

if((dAngle > 45) && (dAngle <= 135)) {

// Angle in (45 .. 135]

// Rotate image by 90 degrees into temporary image,

// so it requires only an extra rotation angle

// of -45 .. +45 to complete rotation.

image = Rotate90(src);

dAngle -= 90;

}

else if((dAngle > 135) && (dAngle <= 225)) {

// Angle in (135 .. 225]

// Rotate image by 180 degrees into temporary image,

// so it requires only an extra rotation angle

// of -45 .. +45 to complete rotation.

image = Rotate180(src);

dAngle -= 180;

}

else if((dAngle > 225) && (dAngle <= 315)) {

// Angle in (225 .. 315]

// Rotate image by 270 degrees into temporary image,

// so it requires only an extra rotation angle

// of -45 .. +45 to complete rotation.

image = Rotate270(src);

dAngle -= 270;

}

// If we got here, angle is in (-45 .. +45]

if(NULL == image) {

// Failed to allocate middle image

return NULL;

}

if(0 == dAngle) {

if(image == src) {

// Nothing to do ...

return FreeImage_Clone(src);

} else {

// No more rotation needed

return image;

}

}

else {

// Perform last rotation

FIBITMAP *dst = Rotate45(image, dAngle, bkcolor);

if(src != image) {

// Middle image was required, free it now.

FreeImage_Unload(image);

}

return dst;

}

}

FIBITMAP *DLL_CALLCONV

FreeImage_Rotate(FIBITMAP *dib, double angle, const void *bkcolor) {

if(!FreeImage_HasPixels(dib)) return NULL;

if(0 == angle) {

return FreeImage_Clone(dib);

}

// DIB are stored upside down ...

angle *= -1;

try {

unsigned bpp = FreeImage_GetBPP(dib);

FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);

switch(image_type) {

case FIT_BITMAP:

if(bpp == 1) {

// only rotate for integer multiples of 90 degree

if(fmod(angle, 90) != 0)

return NULL;

// perform the rotation

FIBITMAP *dst = RotateAny(dib, angle, bkcolor);

if(!dst) throw(1);

// build a greyscale palette

RGBQUAD *dst_pal = FreeImage_GetPalette(dst);

if(FreeImage_GetColorType(dib) == FIC_MINISBLACK) {

dst_pal[0].rgbRed = dst_pal[0].rgbGreen = dst_pal[0].rgbBlue = 0;

dst_pal[1].rgbRed = dst_pal[1].rgbGreen = dst_pal[1].rgbBlue = 255;

} else {

dst_pal[0].rgbRed = dst_pal[0].rgbGreen = dst_pal[0].rgbBlue = 255;

dst_pal[1].rgbRed = dst_pal[1].rgbGreen = dst_pal[1].rgbBlue = 0;

}

// copy metadata from src to dst

FreeImage_CloneMetadata(dst, dib);

return dst;

}

else if((bpp == 8) || (bpp == 24) || (bpp == 32)) {

FIBITMAP *dst = RotateAny(dib, angle, bkcolor);

if(!dst) throw(1);

if(bpp == 8) {

// copy original palette to rotated bitmap

RGBQUAD *src_pal = FreeImage_GetPalette(dib);

RGBQUAD *dst_pal = FreeImage_GetPalette(dst);

memcpy(&dst_pal[0], &src_pal[0], 256 * sizeof(RGBQUAD));

// copy transparency table

FreeImage_SetTransparencyTable(dst, FreeImage_GetTransparencyTable(dib), FreeImage_GetTransparencyCount(dib));

// copy background color

RGBQUAD bkcolor;

if( FreeImage_GetBackgroundColor(dib, &bkcolor) ) {

FreeImage_SetBackgroundColor(dst, &bkcolor);

}

}

// copy metadata from src to dst

FreeImage_CloneMetadata(dst, dib);

return dst;

}

break;

case FIT_UINT16:

case FIT_RGB16:

case FIT_RGBA16:

case FIT_FLOAT:

case FIT_RGBF:

case FIT_RGBAF:

{

FIBITMAP *dst = RotateAny(dib, angle, bkcolor);

if(!dst) throw(1);

// copy metadata from src to dst

FreeImage_CloneMetadata(dst, dib);

return dst;

}

break;

}

} catch(int) {

return NULL;

}

return NULL;

}