wrlib/rotate.c

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