| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| |
| /* |
| * rotateorth.c |
| * |
| * Top-level rotation by multiples of 90 degrees |
| * PIX *pixRotateOrth() |
| * |
| * 180-degree rotation |
| * PIX *pixRotate180() |
| * |
| * 90-degree rotation (both directions) |
| * PIX *pixRotate90() |
| * |
| * Left-right flip |
| * PIX *pixFlipLR() |
| * |
| * Top-bottom flip |
| * PIX *pixFlipTB() |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "allheaders.h" |
| |
| |
| /*! |
| * pixRotateOrth() |
| * |
| * Input: pixs (all depths) |
| * quads (0-3; number of 90 degree cw rotations) |
| * Return: pixd, or null on error |
| */ |
| PIX * |
| pixRotateOrth(PIX *pixs, |
| l_int32 quads) |
| { |
| PROCNAME("pixRotateOrth"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (quads < 0 || quads > 4) |
| return (PIX *)ERROR_PTR("quads not in {0,1,2,3,4}", procName, NULL); |
| |
| if (quads == 0 || quads == 4) |
| return pixCopy(NULL, pixs); |
| else if (quads == 1) |
| return pixRotate90(pixs, 1); |
| else if (quads == 2) |
| return pixRotate180(NULL, pixs); |
| else /* quads == 3 */ |
| return pixRotate90(pixs, -1); |
| } |
| |
| |
| /*! |
| * pixRotate180() |
| * |
| * Input: pixd (<optional>; can be null, equal to pixs, |
| * or different from pixs) |
| * pixs (all depths) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) This does a 180 rotation of the image about the center, |
| * which is equivalent to a left-right flip about a vertical |
| * line through the image center, followed by a top-bottom |
| * flip about a horizontal line through the image center. |
| * (2) There are 3 cases for input: |
| * (a) pixd == null (creates a new pixd) |
| * (b) pixd == pixs (in-place operation) |
| * (c) pixd != pixs (existing pixd) |
| * (3) For clarity, use these three patterns, respectively: |
| * (a) pixd = pixRotate180(NULL, pixs); |
| * (b) pixRotate180(pixs, pixs); |
| * (c) pixRotate180(pixd, pixs); |
| */ |
| PIX * |
| pixRotate180(PIX *pixd, |
| PIX *pixs) |
| { |
| l_int32 d; |
| |
| PROCNAME("pixRotate180"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| d = pixGetDepth(pixs); |
| if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) |
| return (PIX *)ERROR_PTR("pixs not in {1,2,4,8,16,32} bpp", |
| procName, NULL); |
| |
| /* Prepare pixd for in-place operation */ |
| if ((pixd = pixCopy(pixd, pixs)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| |
| pixFlipLR(pixd, pixd); |
| pixFlipTB(pixd, pixd); |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixRotate90() |
| * |
| * Input: pixs (all depths) |
| * direction (1 = clockwise, -1 = counter-clockwise) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) This does a 90 degree rotation of the image about the center, |
| * either cw or ccw, returning a new pix. |
| * (2) The direction must be either 1 (cw) or -1 (ccw). |
| */ |
| PIX * |
| pixRotate90(PIX *pixs, |
| l_int32 direction) |
| { |
| l_int32 wd, hd, d, wpls, wpld; |
| l_uint32 *datas, *datad; |
| PIX *pixd; |
| |
| PROCNAME("pixRotate90"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| d = pixGetDepth(pixs); |
| if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) |
| return (PIX *)ERROR_PTR("pixs not in {1,2,4,8,16,32} bpp", |
| procName, NULL); |
| if (direction != 1 && direction != -1) |
| return (PIX *)ERROR_PTR("invalid direction", procName, NULL); |
| |
| hd = pixGetWidth(pixs); |
| wd = pixGetHeight(pixs); |
| if ((pixd = pixCreate(wd, hd, d)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyColormap(pixd, pixs); |
| pixCopyResolution(pixd, pixs); |
| pixCopyInputFormat(pixd, pixs); |
| |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| rotate90Low(datad, wd, hd, d, wpld, datas, wpls, direction); |
| |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixFlipLR() |
| * |
| * Input: pixd (<optional>; can be null, equal to pixs, |
| * or different from pixs) |
| * pixs (all depths) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) This does a left-right flip of the image, which is |
| * equivalent to a rotation out of the plane about a |
| * vertical line through the image center. |
| * (2) There are 3 cases for input: |
| * (a) pixd == null (creates a new pixd) |
| * (b) pixd == pixs (in-place operation) |
| * (c) pixd != pixs (existing pixd) |
| * (3) For clarity, use these three patterns, respectively: |
| * (a) pixd = pixFlipLR(NULL, pixs); |
| * (b) pixFlipLR(pixs, pixs); |
| * (c) pixFlipLR(pixd, pixs); |
| * (4) If an existing pixd is not the same size as pixs, the |
| * image data will be reallocated. |
| */ |
| PIX * |
| pixFlipLR(PIX *pixd, |
| PIX *pixs) |
| { |
| l_uint8 *tab; |
| l_int32 w, h, d, wpld; |
| l_uint32 *datad, *buffer; |
| |
| PROCNAME("pixFlipLR"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) |
| return (PIX *)ERROR_PTR("pixs not in {1,2,4,8,16,32} bpp", |
| procName, NULL); |
| |
| /* Prepare pixd for in-place operation */ |
| if ((pixd = pixCopy(pixd, pixs)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| switch (d) |
| { |
| case 1: |
| tab = makeReverseByteTab1(); |
| break; |
| case 2: |
| tab = makeReverseByteTab2(); |
| break; |
| case 4: |
| tab = makeReverseByteTab4(); |
| break; |
| default: |
| tab = NULL; |
| break; |
| } |
| |
| if ((buffer = (l_uint32 *)CALLOC(wpld, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("buffer not made", procName, NULL); |
| |
| flipLRLow(datad, w, h, d, wpld, tab, buffer); |
| |
| FREE(buffer); |
| if (tab) FREE(tab); |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixFlipTB() |
| * |
| * Input: pixd (<optional>; can be null, equal to pixs, |
| * or different from pixs) |
| * pixs (all depths) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) This does a top-bottom flip of the image, which is |
| * equivalent to a rotation out of the plane about a |
| * horizontal line through the image center. |
| * (2) There are 3 cases for input: |
| * (a) pixd == null (creates a new pixd) |
| * (b) pixd == pixs (in-place operation) |
| * (c) pixd != pixs (existing pixd) |
| * (3) For clarity, use these three patterns, respectively: |
| * (a) pixd = pixFlipTB(NULL, pixs); |
| * (b) pixFlipTB(pixs, pixs); |
| * (c) pixFlipTB(pixd, pixs); |
| * (4) If an existing pixd is not the same size as pixs, the |
| * image data will be reallocated. |
| */ |
| PIX * |
| pixFlipTB(PIX *pixd, |
| PIX *pixs) |
| { |
| l_int32 h, d, wpld; |
| l_uint32 *datad, *buffer; |
| |
| PROCNAME("pixFlipTB"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, NULL, &h, &d); |
| if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) |
| return (PIX *)ERROR_PTR("pixs not in {1,2,4,8,16,32} bpp", |
| procName, NULL); |
| |
| /* Prepare pixd for in-place operation */ |
| if ((pixd = pixCopy(pixd, pixs)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| if ((buffer = (l_uint32 *)CALLOC(wpld, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("buffer not made", procName, NULL); |
| |
| flipTBLow(datad, h, wpld, buffer); |
| |
| FREE(buffer); |
| return pixd; |
| } |
| |
