wrlib/rotate.c

   1 /* rotate.c - image rotation
   2  *
   3  *  Raster graphics library
   4  *
   5  *  Copyright (c) 2000 Alfredo K. Kojima
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <config.h>
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <X11/Xlib.h>
  28 #include "wraster.h"
  29
  30 #include <math.h>
  31
  32 #ifndef PI
  33 #define PI 3.14159265358979323846
  34 #endif
  35
  36
  37 static RImage *rotateImage(RImage *image, float angle);
  38
  39
  40 RImage *RRotateImage(RImage *image, float angle)
  41 {
  42     RImage *img;
  43     int nwidth, nheight;
  44     int x, y;
  45     int bpp = image->format == RRGBAFormat ? 4 : 3;
  46
  47     angle = ((int)angle % 360) + (angle - (int)angle);
  48
  49     if (angle == 0.0) {
  50         return RCloneImage(image);
  51
  52     } else if (angle == 90.0) {
  53         nwidth = image->height;
  54         nheight = image->width;
  55
  56         img = RCreateImage(nwidth, nheight, True);
  57         if (!img) {
  58             return NULL;
  59         }
  60
  61         if (bpp == 3) {
  62             unsigned char *optr, *nptr;
  63             unsigned offs;
  64
  65
  66             offs = nwidth * 4;
  67
  68             optr = image->data;
  69             nptr = img->data;
  70
  71             for (x = 0; x < nwidth; x++) {
  72                 nptr = img->data + x*4;
  73                 for (y = nheight; y; y--) {
  74                     nptr[0] = *optr++;
  75                     nptr[1] = *optr++;
  76                     nptr[2] = *optr++;
  77                     nptr[3] = 255;
  78
  79                     nptr += offs;
  80                 }
  81             }
  82         } else {
  83             unsigned *optr, *nptr;
  84             unsigned *p;
  85
  86             optr = (unsigned*)image->data;
  87             p = (unsigned*)img->data;
  88             for (x = 0; x < nwidth; x++) {
  89                 nptr = p++;
  90                 for (y = nheight; y; y--) {
  91                     *nptr = *optr++;
  92                     nptr += nwidth;
  93                 }
  94             }
  95         }
  96     } else if (angle == 180.0) {
  97
  98         nwidth = image->width;
  99         nheight = image->height;
 100         img = RCreateImage(nwidth, nheight, True);
 101         if (!img) {
 102             return NULL;
 103         }
 104
 105         if (bpp == 3) {
 106             unsigned char *optr, *nptr;
 107
 108             optr = image->data;
 109             nptr = img->data + nwidth * nheight * 4 - 4;
 110
 111             for (y = 0; y < nheight; y++) {
 112                 for (x = 0; x < nwidth; x++) {
 113                     nptr[0] = optr[0];
 114                     nptr[1] = optr[1];
 115                     nptr[2] = optr[2];
 116                     nptr[3] = 255;
 117
 118                     optr += 3;
 119                     nptr -= 4;
 120                 }
 121             }
 122         } else {
 123             unsigned *optr, *nptr;
 124
 125             optr = (unsigned*)image->data;
 126             nptr = (unsigned*)img->data + nwidth * nheight - 1;
 127
 128             for (y = nheight*nwidth-1; y >= 0; y--) {
 129                 *nptr = *optr;
 130                 optr++;
 131                 nptr--;
 132             }
 133         }
 134     } else if (angle == 270.0) {
 135         nwidth = image->height;
 136         nheight = image->width;
 137
 138         img = RCreateImage(nwidth, nheight, True);
 139         if (!img) {
 140             return NULL;
 141         }
 142
 143         if (bpp == 3) {
 144             unsigned char *optr, *nptr;
 145             unsigned offs;
 146
 147
 148             offs = nwidth * 4;
 149
 150             optr = image->data;
 151             nptr = img->data;
 152
 153             for (x = 0; x < nwidth; x++) {
 154                 nptr = img->data + x*4;
 155                 for (y = nheight; y; y--) {
 156                     nptr[0] = *optr++;
 157                     nptr[1] = *optr++;
 158                     nptr[2] = *optr++;
 159                     nptr[3] = 255;
 160
 161                     nptr += offs;
 162                 }
 163             }
 164         } else {
 165             unsigned *optr, *nptr;
 166             unsigned *p;
 167
 168             optr = (unsigned*)image->data;
 169             p = (unsigned*)img->data + nwidth*nheight;
 170             for (x = 0; x < nwidth; x++) {
 171                 nptr = p--;
 172                 for (y = nheight; y; y--) {
 173                     *nptr = *optr++;
 174                     nptr -= nwidth;
 175                 }
 176             }
 177         }
 178     } else {
 179         img = rotateImage(image, angle);
 180     }
 181
 182     return img;
 183 }
 184
 185
 186
 187
 188 /*
 189  * Image rotation through Bresenham's line algorithm:
 190  *
 191  * If a square must be rotate by angle a, like in:
 192  *  _______
 193  * |    B  |
 194  * |   /4\ |
 195  * |  /3 8\|
 196  * | /2 7 /|
 197  * |A1 6 / |      A_______B
 198  * | \5 / a| <--- |1 2 3 4|
 199  * |__C/_)_|      |5 6 7 8|
 200  *                C-------
 201  *
 202  * for each point P1 in the line from C to A
 203  *      for each point P2 in the perpendicular line starting at P1
 204  *              get pixel from the source and plot at P2
 205  *              increment pixel location from source
 206  *
 207  */
 208
 209
 210 static void copyLine(int x1, int y1, int x2, int y2, int nwidth, int format,
 211                      unsigned char *dst, unsigned char **src)
 212 {
 213     unsigned char *s = *src;
 214     int dx, dy;
 215     int xi, yi;
 216     int offset;
 217     int dpr, dpru, p;
 218
 219     dx = abs(x2 - x1);
 220     dy = abs(y2 - y1);
 221
 222     if (x1 > x2) xi = -1; else xi = 1;
 223     if (y1 > y2) yi = -1; else yi = 1;
 224
 225     if (dx >= dy) {
 226
 227         dpr = dy << 1;
 228         dpru = dpr - (dx << 1);
 229         p = dpr - dx;
 230
 231         while (dx-- >= 0) {
 232             /* fetch and draw the pixel */
 233             offset = (x1 + y1 * nwidth) << 2;
 234             dst[offset++] = *s++;
 235             dst[offset++] = *s++;
 236             dst[offset++] = *s++;
 237             if (format == RRGBAFormat)
 238                 dst[offset++] = *s++;
 239             else
 240                 dst[offset++] = 255;
 241
 242             /* calc next step */
 243             if (p > 0) {
 244                 x1 += xi;
 245                 y1 += yi;
 246                 p += dpru;
 247             } else {
 248                 x1 += xi;
 249                 p += dpr;
 250             }
 251         }
 252     } else {
 253
 254         dpr = dx << 1;
 255         dpru = dpr - (dy << 1);
 256         p = dpr - dy;
 257
 258         while (dy-- >= 0) {
 259             /* fetch and draw the pixel */
 260             offset = (x1 + y1 * nwidth) << 2;
 261             dst[offset++] = *s++;
 262             dst[offset++] = *s++;
 263             dst[offset++] = *s++;
 264             if (format == RRGBAFormat)
 265                 dst[offset++] = *s++;
 266             else
 267                 dst[offset++] = 255;
 268
 269             /* calc next step */
 270             if (p > 0) {
 271                 x1 += xi;
 272                 y1 += yi;
 273                 p += dpru;
 274             } else {
 275                 y1 += yi;
 276                 p += dpr;
 277             }
 278         }
 279     }
 280
 281
 282     *src = s;
 283 }
 284
 285
 286 static RImage *rotateImage(RImage *image, float angle)
 287 {
 288     RImage *img;
 289     int nwidth, nheight;
 290     int x1, y1;
 291     int x2, y2;
 292     int dx, dy;
 293     int xi, yi;
 294     int xx, yy;
 295     unsigned char *src, *dst;
 296     int dpr, dpru, p;
 297
 298     /* only 180o for now */
 299     if (angle > 180.0)
 300         angle -= 180.0;
 301
 302
 303     angle = (angle * PI) / 180.0;
 304
 305     nwidth = ceil(abs(cos(angle) * image->width))
 306         + ceil(abs(cos(PI/2 - angle) * image->width));
 307
 308     nheight = ceil(abs(sin(angle) * image->height))
 309         + ceil(abs(cos(PI/2 - angle) * image->height));
 310
 311     img = RCreateImage(nwidth, nheight, True);
 312     if (!img)
 313         return NULL;
 314
 315     src = image->data;
 316     dst = img->data;
 317
 318     x1 = floor(abs(cos(PI/2 - angle)*image->width));
 319     y1 = 0;
 320
 321     x2 = 0;
 322     y2 = floor(abs(sin(PI/2 - angle)*image->width));
 323
 324     xx = floor(abs(cos(angle)*image->height)) - 1;
 325     yy = nheight - 1;
 326
 327     printf("%ix%i, %i %i     %i %i %i\n",
 328            nwidth, nheight, x1, y1, x2, y2, (int)((angle*180.0)/PI));
 329
 330     dx = abs(x2 - x1);
 331     dy = abs(y2 - y1);
 332
 333     if (x1 > x2) xi = -1; else xi = 1;
 334     if (y1 > y2) yi = -1; else yi = 1;
 335
 336     if (dx >= dy) {
 337         dpr = dy << 1;
 338         dpru = dpr - (dx << 1);
 339         p = dpr - dx;
 340
 341         while (dx-- >= 0) {
 342
 343             copyLine(x1, y1, xx, yy, nwidth, image->format, dst, &src);
 344
 345             /* calc next step */
 346
 347             if (p > 0) {
 348                 x1 += xi;
 349                 y1 += yi;
 350                 xx += xi;
 351                 yy += yi;
 352                 p += dpru;
 353             } else {
 354                 x1 += xi;
 355                 xx += xi;
 356                 p += dpr;
 357             }
 358         }
 359     } else {
 360         puts("NOT IMPLEMTENED");
 361         return img;
 362         dpr = dx << 1;
 363         dpru = dpr - (dy << 1);
 364         p = dpr - dy;
 365
 366         while (dy-- >= 0) {
 367             xx = abs(x1*sin(angle*PI/180.0));
 368             yy = abs(y1*cos(angle*PI/180.0));
 369
 370             copyLine(x1, y1, xx, yy, nwidth, image->format, dst, &src);
 371
 372             /* calc next step*/
 373             if (p > 0) {
 374                 x1 += xi;
 375                 y1 += yi;
 376                 p += dpru;
 377             } else {
 378                 y1 += yi;
 379                 p += dpr;
 380             }
 381         }
 382     }
 383
 384     return img;
 385 }