1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:

procedure RotateBitmapA(var Bitmap: TBitmap; const ADegrees: Cardinal;
  const clBack: TColor);
const
  MaxPixelCount   =  32768;

type
  pRGBArray  =  ^TRGBArray;    // Use SysUtils.pByteArray for 8-bit color
  TRGBArray  =  array [0..MaxPixelCount-1] of TRGBTriple;

var
  cosTheta      :  DOUBLE;
  i             :  INTEGER;
  iRotationAxis :  INTEGER;
  iOriginal     :  INTEGER;
  iPrime        :  INTEGER;
  iPrimeRotated :  INTEGER;
  j             :  INTEGER;
  jRotationAxis :  INTEGER;
  jOriginal     :  INTEGER;
  jPrime        :  INTEGER;
  jPrimeRotated :  INTEGER;
  RowOriginal   :  pRGBArray;
  RowRotated    :  pRGBArray;
  sinTheta      :  DOUBLE;
  Theta         :  DOUBLE;       // radians

  OldHeight     :  INTEGER;
  OldWidth      :  INTEGER;
  NewWidth      :  INTEGER;
  NewHeight     :  INTEGER;
  BitmapRotated :  TBitmap;
  Back          :  RGBTriple;
begin
  Back.rgbtBlue := GetBValue(clBack);
  Back.rgbtGreen := GetGValue(clBack);
  Back.rgbtRed := GetRValue(clBack);

  Theta := ADegrees * PI /180;
  sinTheta := Sin(Theta);
  cosTheta := Cos(Theta);

  OldWidth := Bitmap.Width;
  OldHeight := Bitmap.Height;

  //An easy way to calculate the non-clipping rectangle
  NewWidth := Abs(Round(OldHeight * sinTheta)) + Abs(Round(OldWidth *
                cosTheta));
  NewHeight := Abs(Round(OldWidth * sinTheta)) + Abs(Round(OldHeight *
                 cosTheta));

  BitmapRotated := TBitmap.Create;
  BitmapRotated.Width  := NewWidth;
  BitmapRotated.Height := NewHeight;
  BitmapRotated.PixelFormat := pf24bit;
  BitmapRotated.Canvas.Brush.Color := clBack;
  BitmapRotated.Canvas.FillRect(Rect(0, 0, NewWidth, NewHeight));
//  BitmapRotated.Canvas.FillRect(Rect(0, 0, NewWidth, NewHeight));

  iRotationAxis := OldWidth div 2;
  jRotationAxis := OldHeight div 2;

  // Step through each row of rotated image.
  for J := BitmapRotated.Height - 1 downto 0 do begin
    RowRotated  := BitmapRotated.Scanline[J];
    // Assume the bitmap has an even number of pixels in both dimensions and
    // the axis of rotation is to be the exact middle of the image -- so this
    // axis of rotation is not at the middle of any pixel.

    // The transformation (i,j) to (iPrime, jPrime) puts the center of each
    // pixel at odd-numbered coordinates.  The left and right sides of each
    // pixel (as well as the top and bottom) then have even-numbered coordinates.

    // The point (iRotationAxis, jRotationAxis) identifies the axis of rotation.

    // For a 640 x 480 pixel image, the center point is (320, 240).  Pixels
    // numbered (index i) 0..319 are left of this point along the "X" axis and
    // pixels numbered 320..639 are right of this point.  Likewise, vertically
    // pixels are numbered (index j) 0..239 above the axis of rotation and
    // 240..479 below the axis of rotation.

    // The subtraction (i, j) - (iRotationAxis, jRotationAxis) moves the axis
    // of rotation from (i, j) to (iRotationAxis, jRotationAxis), which is the
    // center of the bitmap in this implementation.

    // offset origin by the growth factor (NewHeight - OldHeight) div 2
    jPrime := 2*(J - (NewHeight - OldHeight) div 2 - jRotationAxis) + 1 ;

    for I := NewWidth - 1 downto 0 do begin
      // offset origin by the growth factor (NewWidth - OldWidth) div 2
      iPrime := 2*(I - (NewWidth - OldWidth) div 2 - iRotationAxis) + 1;

      // Rotate (iPrime, jPrime) to location of desired pixel
      // Note:  There is negligible difference between floating point and
      // scaled integer arithmetic here, so keep the math simple (and readable).
      iPrimeRotated := Round(iPrime * CosTheta - jPrime * sinTheta);
      jPrimeRotated := Round(iPrime * sinTheta + jPrime * cosTheta);

      // Transform back to pixel coordinates of image, including translation
      // of origin from axis of rotation to origin of image.
      iOriginal := (iPrimeRotated - 1) div 2 + iRotationAxis;
      jOriginal := (jPrimeRotated - 1) div 2 + jRotationAxis;

      // Make sure (iOriginal, jOriginal) is in BitmapOriginal.  If not,
      // assign blue color to corner points.
      if   (iOriginal >= 0) and (iOriginal <= Bitmap.Width - 1)
      and  (jOriginal >= 0) and (jOriginal <= Bitmap.Height - 1) then begin
        // Assign pixel from rotated space to current pixel in BitmapRotated
        RowOriginal := Bitmap.Scanline[jOriginal];
        RowRotated[I]  := RowOriginal[iOriginal]
      end
{      else
        RowRotated[I] := Back;   }
    end;
  end;
  Bitmap.Assign(BitmapRotated);
  BitmapRotated.Free;
end;