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 = fmod(angle, 360.0);
  56         if (angle < 0.0)
  57                 angle += 360.0;
  58
  59         if (angle < min_usable_angle) {
  60                 /* Rotate by 0 degree */
  61                 return RCloneImage(image);
  62
  63         } else if ((angle > 90.0 - min_usable_angle) &&
  64                                   (angle < 90.0 + min_usable_angle)) {
  65                 nwidth = image->height;
  66                 nheight = image->width;
  67
  68                 img = RCreateImage(nwidth, nheight, True);
  69                 if (!img)
  70                         return NULL;
  71
  72                 if (bpp == 3) {
  73                         unsigned char *optr, *nptr;
  74
  75                         optr = image->data;
  76                         nptr = img->data;
  77
  78                         for (x = nwidth; x; x--) {
  79                                 nptr = img->data + 4 * (x - 1);
  80                                 for (y = nheight; y; y--) {
  81                                         nptr[0] = *optr++;
  82                                         nptr[1] = *optr++;
  83                                         nptr[2] = *optr++;
  84                                         nptr[3] = 255;
  85
  86                                         nptr += 4 * nwidth;
  87                                 }
  88                         }
  89                 } else {
  90                         unsigned char *optr, *nptr;
  91
  92                         optr = image->data;
  93                         nptr = img->data;
  94
  95                         for (x = nwidth; x; x--) {
  96                                 nptr = img->data + 4 * (x - 1);
  97                                 for (y = nheight; y; y--) {
  98                                         nptr[0] = *optr++;
  99                                         nptr[1] = *optr++;
 100                                         nptr[2] = *optr++;
 101                                         nptr[3] = *optr++;
 102
 103                                         nptr += 4 * nwidth;
 104                                 }
 105                         }
 106                 }
 107         } else if ((angle > 180.0 - min_usable_angle) &&
 108                                   (angle < 180.0 + min_usable_angle)) {
 109
 110                 nwidth = image->width;
 111                 nheight = image->height;
 112                 img = RCreateImage(nwidth, nheight, True);
 113                 if (!img)
 114                         return NULL;
 115
 116                 if (bpp == 3) {
 117                         unsigned char *optr, *nptr;
 118
 119                         optr = image->data;
 120                         nptr = img->data + nwidth * nheight * 4 - 4;
 121
 122                         for (y = 0; y < nheight; y++) {
 123                                 for (x = 0; x < nwidth; x++) {
 124                                         nptr[0] = optr[0];
 125                                         nptr[1] = optr[1];
 126                                         nptr[2] = optr[2];
 127                                         nptr[3] = 255;
 128
 129                                         optr += 3;
 130                                         nptr -= 4;
 131                                 }
 132                         }
 133                 } else {
 134                         unsigned *optr, *nptr;
 135
 136                         optr = (unsigned *)image->data;
 137                         nptr = (unsigned *)img->data + nwidth * nheight - 1;
 138
 139                         for (y = nheight * nwidth - 1; y >= 0; y--) {
 140                                 *nptr = *optr;
 141                                 optr++;
 142                                 nptr--;
 143                         }
 144                 }
 145         } else if ((angle > 270.0 - min_usable_angle) &&
 146                                   (angle < 270.0 + min_usable_angle)) {
 147                 nwidth = image->height;
 148                 nheight = image->width;
 149
 150                 img = RCreateImage(nwidth, nheight, True);
 151                 if (!img)
 152                         return NULL;
 153
 154                 if (bpp == 3) {
 155                         unsigned char *optr, *nptr;
 156
 157                         optr = image->data;
 158
 159                         for (x = nwidth; x; x--) {
 160                                 nptr = img->data + 4 * nwidth * nheight - x * 4;
 161                                 for (y = nheight; y; y--) {
 162                                         nptr[0] = *optr++;
 163                                         nptr[1] = *optr++;
 164                                         nptr[2] = *optr++;
 165                                         nptr[3] = 255;
 166
 167                                         nptr -= 4 * nwidth;
 168                                 }
 169                         }
 170                 } else {
 171                         unsigned char *optr, *nptr;
 172
 173                         optr = image->data;
 174
 175                         for (x = nwidth; x; x--) {
 176                                 nptr = img->data + 4 * nwidth * nheight - x * 4;
 177                                 for (y = nheight; y; y--) {
 178                                         nptr[0] = *optr++;
 179                                         nptr[1] = *optr++;
 180                                         nptr[2] = *optr++;
 181                                         nptr[3] = *optr++;
 182
 183                                         nptr -= 4 * nwidth;
 184                                 }
 185                         }
 186                 }
 187         } else {
 188                 img = rotateImage(image, angle);
 189         }
 190
 191         return img;
 192 }
 193
 194 /*
 195  * Image rotation through Bresenham's line algorithm:
 196  *
 197  * If a square must be rotate by angle a, like in:
 198  *  _______
 199  * |    B  |
 200  * |   /4\ |
 201  * |  /3 8\|
 202  * | /2 7 /|
 203  * |A1 6 / |      A_______B
 204  * | \5 / a| <--- |1 2 3 4|
 205  * |__C/_)_|      |5 6 7 8|
 206  *                C-------
 207  *
 208  * for each point P1 in the line from C to A
 209  *      for each point P2 in the perpendicular line starting at P1
 210  *              get pixel from the source and plot at P2
 211  *              increment pixel location from source
 212  *
 213  */
 214
 215 #if 0
 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 #endif
 296
 297 static RImage *rotateImage(RImage *image, float angle)
 298 {
 299         (void) angle;
 300         puts("NOT FULLY IMPLEMENTED");
 301         return RCloneImage(image);
 302 #if 0
 303         RImage *img;
 304         int nwidth, nheight;
 305         int x1, y1;
 306         int x2, y2;
 307         int dx, dy;
 308         int xi, yi;
 309         int xx, yy;
 310         unsigned char *src, *dst;
 311         int dpr, dpru, p;
 312
 313         /* only 180o for now */
 314         if (angle > 180.0)
 315                 angle -= 180.0;
 316
 317         angle = (angle * PI) / 180.0;
 318
 319         nwidth = ceil(abs(cos(angle) * image->width))
 320             + ceil(abs(cos(PI / 2 - angle) * image->width));
 321
 322         nheight = ceil(abs(sin(angle) * image->height))
 323             + ceil(abs(cos(PI / 2 - angle) * image->height));
 324
 325         img = RCreateImage(nwidth, nheight, True);
 326         if (!img)
 327                 return NULL;
 328
 329         src = image->data;
 330         dst = img->data;
 331
 332         x1 = floor(abs(cos(PI / 2 - angle) * image->width));
 333         y1 = 0;
 334
 335         x2 = 0;
 336         y2 = floor(abs(sin(PI / 2 - angle) * image->width));
 337
 338         xx = floor(abs(cos(angle) * image->height)) - 1;
 339         yy = nheight - 1;
 340
 341         printf("%ix%i, %i %i     %i %i %i\n", nwidth, nheight, x1, y1, x2, y2, (int)((angle * 180.0) / PI));
 342
 343         dx = abs(x2 - x1);
 344         dy = abs(y2 - y1);
 345
 346         if (x1 > x2)
 347                 xi = -1;
 348         else
 349                 xi = 1;
 350         if (y1 > y2)
 351                 yi = -1;
 352         else
 353                 yi = 1;
 354
 355         if (dx >= dy) {
 356                 dpr = dy << 1;
 357                 dpru = dpr - (dx << 1);
 358                 p = dpr - dx;
 359
 360                 while (dx-- >= 0) {
 361
 362                         copyLine(x1, y1, xx, yy, nwidth, image->format, dst, &src);
 363
 364                         /* calc next step */
 365
 366                         if (p > 0) {
 367                                 x1 += xi;
 368                                 y1 += yi;
 369                                 xx += xi;
 370                                 yy += yi;
 371                                 p += dpru;
 372                         } else {
 373                                 x1 += xi;
 374                                 xx += xi;
 375                                 p += dpr;
 376                         }
 377                 }
 378         } else {
 379                 dpr = dx << 1;
 380                 dpru = dpr - (dy << 1);
 381                 p = dpr - dy;
 382
 383                 while (dy-- >= 0) {
 384                         xx = abs(x1 * sin(angle * PI / 180.0));
 385                         yy = abs(y1 * cos(angle * PI / 180.0));
 386
 387                         copyLine(x1, y1, xx, yy, nwidth, image->format, dst, &src);
 388
 389                         /* calc next step */
 390                         if (p > 0) {
 391                                 x1 += xi;
 392                                 y1 += yi;
 393                                 p += dpru;
 394                         } else {
 395                                 y1 += yi;
 396                                 p += dpr;
 397                         }
 398                 }
 399         }
 400
 401         return img;
 402 #endif
 403 }