#ifndef _ROTATE_BY_SHEAR_H_
#define _ROTATE_BY_SHEAR_H_
#include <math.h>
#ifndef _PROGRESS_AND_ABORT_CALL_BACK
#define _PROGRESS_AND_ABORT_CALL_BACK
typedef BOOL (*ProgressAnbAbortCallBack)(BYTE bPercentComplete);
#endif // _PROGRESS_AND_ABORT_CALL_BACK
template <class CPxl>
class CRotateByShear
{
public:
CRotateByShear (ProgressAnbAbortCallBack callback = NULL) :
m_Callback (callback) {}
virtual ~CRotateByShear() {}
CPxl * AllocAndRotate (
CPxl *pSrc, // Pointer to source image
SIZE sSrc, // Size of source image
double dAngle, // Rotation angle
SIZE *psDst, // Pointer to destination image size
COLORREF clrBack); // Background color
protected:
//
// You must override these 5 function in the derived class and implement
// specific pixel access functions according to the bitmap type you use.
//
// Get RGB value at given pixel coordinates
virtual COLORREF GetRGB (CPxl *pImage, // Pointer to image
SIZE sImage, // Size of image
UINT x, // X coordinate
UINT y // Y coordinate
) = 0;
// Set RGB value at given pixel coordinates
virtual void SetRGB (CPxl *pImage, // Pointer to image
SIZE sImage, // Size of image
UINT x, // X coordinate
UINT y, // Y coordinate
CPxl clr // New color to set
) = 0;
// Create a new bitmap, given a bitmap dimensions
virtual CPxl *CreateNewBitmap (SIZE sImage // Size of image
) = 0;
// Create a new bitmap which is an identical copy of the source bitmap
virtual CPxl *CopyBitmap (CPxl *pImage, // Pointer to source image
SIZE sImage // Size of source (and destination) image
) = 0;
// Destroy a bitmap previously created in call to CreateNewBitmap(..)
// or to CopyBitmap (...)
virtual void DestroyBitmap (CPxl *pImage, // Pointer to image
SIZE sImage // Size of image
) = 0;
private:
ProgressAnbAbortCallBack m_Callback;
void HorizSkew (CPxl *pSrc,
SIZE sSrc,
CPxl *pDst,
SIZE sDst,
UINT uRow,
int iOffset,
double dWeight,
COLORREF clrBack);
void VertSkew ( CPxl *pSrc,
SIZE sSrc,
CPxl *pDst,
SIZE sDst,
UINT uCol,
int iOffset,
double dWeight,
COLORREF clrBack);
CPxl * Rotate90 (CPxl *pSrc, SIZE sSrc, SIZE *psDst);
CPxl * Rotate180 (CPxl *pSrc, SIZE sSrc, SIZE *psDst);
CPxl * Rotate270 (CPxl *pSrc, SIZE sSrc, SIZE *psDst);
CPxl * Rotate45 (
CPxl *pSrc,
SIZE sSrc,
SIZE *psDst,
double dAngle,
COLORREF clrBack,
BOOL bMidImage);
}; // CRotateByShear
#ifdef ROTATE_PI
#undef ROTATE_PI
#endif // ROTATE_PI
#define ROTATE_PI double (3.1415926535897932384626433832795)
template <class CPxl>
void
CRotateByShear<CPxl>::HorizSkew (
CPxl *pSrc,
SIZE sSrc,
CPxl *pDst,
SIZE sDst,
UINT uRow,
int iOffset,
double dWeight,
COLORREF clrBack)
/*------------------------------------------------------------------------------
Function: HorizSkew
Purpose: Skews a row horizontally (with filtered weights)
Input: Image to skew (+ dimensions)
Destination of skewed image (+ dimensions)
Row index
Skew offset
Relative weight of right pixel
Background color
Output: None.
Remarks: Limited to 45 degree skewing only. Filters two adjacent pixels.
------------------------------------------------------------------------------*/
{
for (int i = 0; i < iOffset; i++)
{
// Fill gap left of skew with background
SetRGB (pDst, sDst, i, uRow, clrBack);
}
COLORREF pxlOldLeft = clrBack;
for (i = 0; i < sSrc.cx; i++)
{
// Loop through row pixels
COLORREF pxlSrc = GetRGB(pSrc, sSrc, i, uRow);
// Calculate weights
COLORREF pxlLeft = RGB (BYTE ( double (GetRValue (pxlSrc)) * dWeight ),
BYTE ( double (GetGValue (pxlSrc)) * dWeight ),
BYTE ( double (GetBValue (pxlSrc)) * dWeight ));
// Update left over on source
pxlSrc = RGB ( GetRValue (pxlSrc) - ( GetRValue (pxlLeft) - GetRValue (pxlOldLeft) ),
GetGValue (pxlSrc) - ( GetGValue (pxlLeft) - GetGValue (pxlOldLeft) ),
GetBValue (pxlSrc) - ( GetBValue (pxlLeft) - GetBValue (pxlOldLeft) ));
// Check boundries
if ((i + iOffset >= 0) && (i + iOffset < sDst.cx))
{
SetRGB (pDst, sDst, i + iOffset, uRow, pxlSrc);
}
// Save leftover for next pixel in scan
pxlOldLeft = pxlLeft;
}
// Go to rightmost point of skew
i += iOffset;
if (i < sDst.cx)
{
// If still in image bounds, put leftovers there
SetRGB (pDst, sDst, i, uRow, pxlOldLeft);
}
while (++i < sDst.cx)
{ // Clear to the right of the skewed line with background
SetRGB (pDst, sDst, i, uRow, clrBack);
}
} // CRotateByShear::HorizSkew
template <class CPxl>
void
CRotateByShear<CPxl>::VertSkew (
CPxl *pSrc,
SIZE sSrc,
CPxl *pDst,
SIZE sDst,
UINT uCol,
int iOffset,
double dWeight,
COLORREF clrBack)
/*------------------------------------------------------------------------------
Function: VertSkew
Purpose: Skews a column vertically (with filtered weights)
Input: Image to skew (+dimensions)
Destination of skewed image (+dimensions)
Column index
Skew offset
Relative weight of upper pixel
Background color
Output: None.
Remarks: Limited to 45 degree skewing only. Filters two adjacent pixels.
------------------------------------------------------------------------------*/
{
for (int i = 0; i < iOffset; i++)
{
// Fill gap above skew with background
SetRGB (pDst, sDst, uCol, i, clrBack);
}
COLORREF pxlOldLeft = clrBack;
int iYPos;
for (i = 0; i < sSrc.cy; i++)
{
// Loop through column pixels
COLORREF pxlSrc = GetRGB (pSrc, sSrc, uCol, i);
iYPos = i + iOffset;
// Calculate weights
COLORREF pxlLeft = RGB (BYTE ( double (GetRValue (pxlSrc)) * dWeight ),
BYTE ( double (GetGValue (pxlSrc)) * dWeight ),
BYTE ( double (GetBValue (pxlSrc)) * dWeight ));
// Update left over on source
pxlSrc = RGB ( GetRValue (pxlSrc) - ( GetRValue (pxlLeft) - GetRValue (pxlOldLeft) ),
GetGValue (pxlSrc) - ( GetGValue (pxlLeft) - GetGValue (pxlOldLeft) ),
GetBValue (pxlSrc) - ( GetBValue (pxlLeft) - GetBValue (pxlOldLeft) ));
// Check boundries
if ((iYPos >= 0) && (iYPos < sDst.cy))
{
SetRGB (pDst, sDst, uCol, iYPos, pxlSrc);
}
// Save leftover for next pixel in scan
pxlOldLeft = pxlLeft;
}
// Go to bottom point of skew
i = iYPos;
if (i < sDst.cy)
{
// If still in image bounds, put leftovers there
SetRGB (pDst, sDst, uCol, i, pxlOldLeft);
}
while (++i < sDst.cy)
{
// Clear below skewed line with background
SetRGB (pDst, sDst, uCol, i, clrBack);
}
} // CRotateByShear::VertSkew
template <class CPxl>
CPxl *
CRotateByShear<CPxl>::Rotate90 (CPxl *pSrc, SIZE sSrc, SIZE *psDst)
/*------------------------------------------------------------------------------
Function: Rotate90
Purpose: Rotates an image by 90 degrees (counter clockwise)
Input: Image to rotate (+dimensions)
Pointer to destination size
Output: Pointer to newly allocated rotated image
Remarks: Precise rotation, no filters required.
------------------------------------------------------------------------------*/
{
(*psDst).cx = sSrc.cy;
(*psDst).cy = sSrc.cx;
CPxl *pDst = CreateNewBitmap (*psDst);
if (NULL == pDst)
{
return NULL;
}
for (UINT uY = 0; uY < UINT(sSrc.cy); uY++)
{
for (UINT uX = 0; uX < UINT(sSrc.cx); uX++)
{
SetRGB (pDst, *psDst, uY, (*psDst).cy - uX - 1, GetRGB (pSrc, sSrc, uX, uY));
}
if (m_Callback)
{
// Report progress
if (!m_Callback (BYTE(double (uY) / double(sSrc.cy) * double(50.0))))
{
// Operation cancelled
DestroyBitmap (pDst, *psDst);
return NULL;
}
}
}
return pDst;
} // CRotateByShear::Rotate90
template <class CPxl>
CPxl *
CRotateByShear<CPxl>::Rotate180 (CPxl *pSrc, SIZE sSrc, SIZE *psDst)
/*------------------------------------------------------------------------------
Function: Rotate180
Purpose: Rotates an image by 180 degrees (counter clockwise)
Input: Image to rotate (+dimensions)
Pointer to destination size
Output: Pointer to newly allocated rotated image
Remarks: Precise rotation, no filters required.
------------------------------------------------------------------------------*/
{
*psDst = sSrc;
CPxl *pDst = CreateNewBitmap (*psDst);
if (NULL == pDst)
{
return NULL;
}
for (UINT uY = 0; uY < UINT(sSrc.cy); uY++)
{
for (UINT uX = 0; uX < UINT(sSrc.cx); uX++)
{
SetRGB (pDst, *psDst, (*psDst).cx - uX - 1, (*psDst).cy - uY - 1, GetRGB (pSrc, sSrc, uX, uY));
}
if (m_Callback)
{
// Report progress
if (!m_Callback (BYTE(double (uY) / double(sSrc.cy) * double(50.0))))
{
// Operation cancelled
DestroyBitmap (pDst, *psDst);
return NULL;
}
}
}
return pDst;
} // CRotateByShear::Rotate180
template <class CPxl>
CPxl *
CRotateByShear<CPxl>::Rotate270 (CPxl *pSrc, SIZE sSrc, SIZE *psDst)
/*------------------------------------------------------------------------------
Function: Rotate270
Purpose: Rotates an image by 270 degrees (counter clockwise)
Input: Image to rotate (+dimensions)
Pointer to destination size
Output: Pointer to newly allocated rotated image
Remarks: Precise rotation, no filters required.
------------------------------------------------------------------------------*/
{
(*psDst).cx = sSrc.cy;
(*psDst).cy = sSrc.cx;
CPxl *pDst = CreateNewBitmap (*psDst);
if (NULL == pDst)
{
return NULL;
}
for (UINT uY = 0; uY < UINT(sSrc.cy); uY++)
{
for (UINT uX = 0; uX < UINT(sSrc.cx); uX++)
{
SetRGB (pDst, *psDst, (*psDst).cx - uY - 1, uX, GetRGB (pSrc, sSrc, uX, uY));
}
if (m_Callback)
{
// Report progress
if (!m_Callback (BYTE(double (uY) / double(sSrc.cy) * double(50.0))))
{
// Operation cancelled
DestroyBitmap (pDst, *psDst);
return NULL;
}
}
}
return pDst;
} // CRotateByShear::Rotate270
template <class CPxl>
CPxl *
CRotateByShear<CPxl>::Rotate45 (
CPxl *pSrc,
SIZE sSrc,
SIZE *psDst,
double dAngle,
COLORREF clrBack,
BOOL bMidImage)
/*------------------------------------------------------------------------------
Function: Rotate45
Purpose: Rotates an image by a given degree in range [-45.0 .. +45.0]
(counter clockwise)
Input: Image to rotate (+dimensions)
Pointer to destination size
Degree of rotation
Background color
Was middle image used (for correct progress report)
Output: Pointer to newly allocated rotated image
Remarks: Using the 3-shear technique.
------------------------------------------------------------------------------*/
{
if (0.0 == dAngle)
{
// No rotation at all
(*psDst) = sSrc;
return CopyBitmap (pSrc, sSrc);
}
double dRadAngle = dAngle * ROTATE_PI / double(180); // Angle in radians
double dSinE = sin (dRadAngle);
double dTan = tan (dRadAngle / 2.0);
// Calc first shear (horizontal) destination image dimensions
SIZE sDst1;
sDst1.cx = sSrc.cx + int(double(sSrc.cy) * fabs(dTan));
sDst1.cy = sSrc.cy;
/******* Perform 1st shear (horizontal) ******/
// Allocate image for 1st shear
CPxl *pDst1 = CreateNewBitmap (sDst1);
if (NULL == pDst1)
{
return NULL;
}
for (UINT u = 0; u < UINT(sDst1.cy); u++)
{
double dShear;
if (dTan >= 0.0)
{
// Positive angle
dShear = (double(u) + 0.5) * dTan;
}
else
{
// Negative angle
dShear = (double (int(u) - sDst1.cy) + 0.5) * dTan;
}
int iShear = int (floor (dShear));
HorizSkew ( pSrc,
sSrc,
pDst1,
sDst1,
u,
iShear,
dShear - double(iShear),
clrBack);
if (m_Callback)
{
// Report progress
BYTE bProgress = bMidImage ? 50 + BYTE(double (u) / double(sDst1.cy) * double(50.0 / 3.0)) :
BYTE(double (u) / double(sDst1.cy) * double(33.33333));
if (!m_Callback (bProgress))
{
// Operation cancelled
DestroyBitmap (pDst1, sDst1);
return NULL;
}
}
}
/******* Perform 2nd shear (vertical) ******/
// Calc 2nd shear (vertical) destination image dimensions
SIZE sDst2;
sDst2.cx = sDst1.cx;
sDst2.cy = UINT (double (sSrc.cx) * fabs (dSinE) + double (sSrc.cy) * cos (dRadAngle)) + 1;
// Allocate image for 2nd shear
CPxl *pDst2 = CreateNewBitmap (sDst2);
if (NULL == pDst2)
{
DestroyBitmap (pDst1, sDst1);
return NULL;
}
double dOffset; // Variable skew offset
if (dSinE > 0.0)
{
// Positive angle
dOffset = double (sSrc.cx - 1) * dSinE;
}
else
{
// Negative angle
dOffset = -dSinE * double (sSrc.cx - sDst2.cx);
}
for (u = 0; u < UINT(sDst2.cx); u++, dOffset -= dSinE)
{
int iShear = int (floor (dOffset));
VertSkew ( pDst1,
sDst1,
pDst2,
sDst2,
u,
iShear,
dOffset - double(iShear),
clrBack);
if (m_Callback)
{
// Report progress
BYTE bProgress = bMidImage ? 66 + BYTE(double (u) / double(sDst2.cy) * double(50.0 / 3.0)) :
33 + BYTE(double (u) / double(sDst2.cy) * double(33.33333));
if (!m_Callback (bProgress))
{
// Operation cancelled
DestroyBitmap (pDst1, sDst1);
DestroyBitmap (pDst2, sDst2);
return NULL;
}
}
}
/******* Perform 3rd shear (horizontal) ******/
// Free result of 1st shear
DestroyBitmap (pDst1, sDst1);
// Calc 3rd shear (horizontal) destination image dimensions
(*psDst).cx = UINT (double(sSrc.cy) * fabs (dSinE) + double(sSrc.cx) * cos (dRadAngle)) + 1;
(*psDst).cy = sDst2.cy;
// Allocate image for 3rd shear
CPxl *pDst3 = CreateNewBitmap (*psDst);
if (NULL == pDst3)
{
DestroyBitmap (pDst2, sDst2);
return NULL;
}
if (dSinE >= 0.0)
{
// Positive angle
dOffset = double(sSrc.cx - 1) * dSinE * -dTan;
}
else
{
// Negative angle
dOffset = dTan * (double(sSrc.cx - 1) * -dSinE + double(1 - (*psDst).cy));
}
for (u = 0; u < UINT((*psDst).cy); u++, dOffset += dTan)
{
int iShear = int (floor(dOffset));
HorizSkew ( pDst2,
sDst2,
pDst3,
(*psDst),
u,
iShear,
dOffset - double (iShear),
clrBack
);
if (m_Callback)
{
// Report progress
BYTE bProgress = bMidImage ? 83 + BYTE(double (u) / double((*psDst).cy) * double(50.0 / 3.0)) :
66 + BYTE(double (u) / double((*psDst).cy) * double(33.33333));
if (!m_Callback (bProgress))
{
// Operation cancelled
DestroyBitmap (pDst2, sDst2);
DestroyBitmap (pDst3, *psDst);
return NULL;
}
}
}
// Free result of 2nd shear
DestroyBitmap (pDst2, sDst2);
// Return result of 3rd shear
return pDst3;
} // CRotateByShear::Rotate45
template <class CPxl>
CPxl *
CRotateByShear<CPxl>::AllocAndRotate (
CPxl *pSrc,
SIZE sSrc,
double dAngle,
SIZE *psDst,
COLORREF clrBack
)
/*------------------------------------------------------------------------------
Function: AllocAndRotate
Purpose: Rotates an image by a given degree
Input: Image to rotate (+dimensions)
Angle of rotation
Pointers to dimensions of rotated image
Background color
Output: Pointer to newly allocated rotated image
Remarks: Angle is unlimited. 3-shears technique is used.
------------------------------------------------------------------------------*/
{
CPxl *pMidImg = pSrc;
SIZE sMidImg = sSrc;
if (NULL == pSrc)
{
return NULL;
}
while (dAngle >= 360.0)
{
// Bring angle to range of (-INF .. 360.0)
dAngle -= 360.0;
}
while (dAngle < 0.0)
{
// Bring angle to range of [0.0 .. 360.0)
dAngle += 360.0;
}
if ((dAngle > 45.0) && (dAngle <= 135.0))
{
// Angle in (45.0 .. 135.0]
// Rotate image by 90 degrees into temporary image,
// so it requires only an extra rotation angle
// of -45.0 .. +45.0 to complete rotation.
pMidImg = Rotate90 (pSrc, sSrc, &sMidImg);
dAngle -= 90.0;
}
else if ((dAngle > 135.0) && (dAngle <= 225.0))
{
// Angle in (135.0 .. 225.0]
// Rotate image by 180 degrees into temporary image,
// so it requires only an extra rotation angle
// of -45.0 .. +45.0 to complete rotation.
pMidImg = Rotate180 (pSrc, sSrc, &sMidImg);
dAngle -= 180.0;
}
else if ((dAngle > 225.0) && (dAngle <= 315.0))
{
// Angle in (225.0 .. 315.0]
// Rotate image by 270 degrees into temporary image,
// so it requires only an extra rotation angle
// of -45.0 .. +45.0 to complete rotation.
pMidImg = Rotate270 (pSrc, sSrc, &sMidImg);
dAngle -= 270.0;
}
// If we got here, angle is in (-45.0 .. +45.0]
if (NULL == pMidImg)
{
// Failed to allocate middle image
return NULL;
}
CPxl *pDst = Rotate45 ( pMidImg,
sMidImg,
psDst,
dAngle,
clrBack,
pSrc != pMidImg);
if (pSrc != pMidImg)
{
// Middle image was required, free it now.
DestroyBitmap (pMidImg, sMidImg);
}
return pDst;
} // AllocAndRotate
#endif
Submit an article or tip