rotateshear.c

Go to the documentation of this file.

/*====================================================================*
 -  Copyright (C) 2001 Leptonica.  All rights reserved.
 -
 -  Redistribution and use in source and binary forms, with or without
 -  modification, are permitted provided that the following conditions
 -  are met:
 -  1. Redistributions of source code must retain the above copyright
 -     notice, this list of conditions and the following disclaimer.
 -  2. Redistributions in binary form must reproduce the above
 -     copyright notice, this list of conditions and the following
 -     disclaimer in the documentation and/or other materials
 -     provided with the distribution.
 -
 -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
 -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================*/
 
#ifdef HAVE_CONFIG_H
#include <config_auto.h>
#endif  /* HAVE_CONFIG_H */
 
#include <math.h>
#include <string.h>
#include "allheaders.h"
 
    /* Angle limits:
     *     angle < MinAngleToRotate    ==>  clone
     *     angle > MaxTwoShearAngle    ==>  warning for 2-angle shears
     *     angle > MaxThreeShearAngle  ==>  warning for 3-angle shears
     *     angle > MaxShearAngle       ==>  error
     */
static const l_float32  MinAngleToRotate = 0.001f;   /* radians; ~0.06 deg */
static const l_float32  MaxTwoShearAngle = 0.06f;    /* radians; ~3 deg    */
static const l_float32  MaxThreeShearAngle = 0.35f;  /* radians; ~20 deg   */
static const l_float32  MaxShearAngle = 0.50f;       /* radians; ~29 deg   */
 
/*------------------------------------------------------------------*
 *                Rotations about an arbitrary point                *
 *------------------------------------------------------------------*/
PIX *
pixRotateShear(PIX       *pixs,
               l_int32    xcen,
               l_int32    ycen,
               l_float32  angle,
               l_int32    incolor)
{
    if (!pixs)
        return (PIX *)(PIX *)ERROR_PTR("pixs not defined", __func__, NULL);
    if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK)
        return (PIX *)(PIX *)ERROR_PTR("invalid incolor value", __func__, NULL);
 
    if (L_ABS(angle) > MaxShearAngle) {
        L_ERROR("%6.2f radians; too large for shear rotation\n", __func__,
                L_ABS(angle));
        return NULL;
    }
    if (L_ABS(angle) < MinAngleToRotate)
        return pixClone(pixs);
 
    if (L_ABS(angle) <= MaxTwoShearAngle)
        return pixRotate2Shear(pixs, xcen, ycen, angle, incolor);
    else
        return pixRotate3Shear(pixs, xcen, ycen, angle, incolor);
}
 
 
PIX *
pixRotate2Shear(PIX       *pixs,
                l_int32    xcen,
                l_int32    ycen,
                l_float32  angle,
                l_int32    incolor)
{
PIX  *pix1, *pix2, *pixd;
 
    if (!pixs)
        return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL);
    if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK)
        return (PIX *)(PIX *)ERROR_PTR("invalid incolor value", __func__, NULL);
 
    if (L_ABS(angle) > MaxShearAngle) {
        L_ERROR("%6.2f radians; too large for shear rotation\n", __func__,
                L_ABS(angle));
        return NULL;
    }
    if (L_ABS(angle) < MinAngleToRotate)
        return pixClone(pixs);
    if (L_ABS(angle) > MaxTwoShearAngle)
        L_WARNING("%6.2f radians; large angle for 2-shear rotation\n",
                  __func__, L_ABS(angle));
 
    if ((pix1 = pixHShear(NULL, pixs, ycen, angle, incolor)) == NULL)
        return (PIX *)ERROR_PTR("pix1 not made", __func__, NULL);
    pixd = pixVShear(NULL, pix1, xcen, angle, incolor);
    pixDestroy(&pix1);
    if (!pixd)
        return (PIX *)ERROR_PTR("pixd not made", __func__, NULL);
 
    if (pixGetDepth(pixs) == 32 && pixGetSpp(pixs) == 4) {
        pix1 = pixGetRGBComponent(pixs, L_ALPHA_CHANNEL);
            /* L_BRING_IN_WHITE brings in opaque for the alpha component */
        pix2 = pixRotate2Shear(pix1, xcen, ycen, angle, L_BRING_IN_WHITE);
        pixSetRGBComponent(pixd, pix2, L_ALPHA_CHANNEL);
        pixDestroy(&pix1);
        pixDestroy(&pix2);
    }
    return pixd;
}
 
 
PIX *
pixRotate3Shear(PIX       *pixs,
                l_int32    xcen,
                l_int32    ycen,
                l_float32  angle,
                l_int32    incolor)
{
l_float32  hangle;
PIX       *pix1, *pix2, *pixd;
 
    if (!pixs)
        return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL);
    if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK)
        return (PIX *)(PIX *)ERROR_PTR("invalid incolor value", __func__, NULL);
 
    if (L_ABS(angle) > MaxShearAngle) {
        L_ERROR("%6.2f radians; too large for shear rotation\n", __func__,
                L_ABS(angle));
        return NULL;
    }
    if (L_ABS(angle) < MinAngleToRotate)
        return pixClone(pixs);
    if (L_ABS(angle) > MaxThreeShearAngle) {
        L_WARNING("%6.2f radians; large angle for 3-shear rotation\n",
                  __func__, L_ABS(angle));
    }
 
    hangle = atan(sin(angle));
    if ((pixd = pixVShear(NULL, pixs, xcen, angle / 2.f, incolor)) == NULL)
        return (PIX *)ERROR_PTR("pixd not made", __func__, NULL);
    if ((pix1 = pixHShear(NULL, pixd, ycen, hangle, incolor)) == NULL) {
        pixDestroy(&pixd);
        return (PIX *)ERROR_PTR("pix1 not made", __func__, NULL);
    }
    pixVShear(pixd, pix1, xcen, angle / 2.f, incolor);
    pixDestroy(&pix1);
 
    if (pixGetDepth(pixs) == 32 && pixGetSpp(pixs) == 4) {
        pix1 = pixGetRGBComponent(pixs, L_ALPHA_CHANNEL);
            /* L_BRING_IN_WHITE brings in opaque for the alpha component */
        pix2 = pixRotate3Shear(pix1, xcen, ycen, angle, L_BRING_IN_WHITE);
        pixSetRGBComponent(pixd, pix2, L_ALPHA_CHANNEL);
        pixDestroy(&pix1);
        pixDestroy(&pix2);
    }
    return pixd;
}
 
 
/*------------------------------------------------------------------*
 *             Rotations in-place about an arbitrary point          *
 *------------------------------------------------------------------*/
l_ok
pixRotateShearIP(PIX       *pixs,
                 l_int32    xcen,
                 l_int32    ycen,
                 l_float32  angle,
                 l_int32    incolor)
{
l_float32  hangle;
 
    if (!pixs)
        return ERROR_INT("pixs not defined", __func__, 1);
    if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK)
        return ERROR_INT("invalid value for incolor", __func__, 1);
    if (pixGetColormap(pixs) != NULL)
        return ERROR_INT("pixs is colormapped", __func__, 1);
 
    if (angle == 0.0)
        return 0;
    if (L_ABS(angle) > MaxThreeShearAngle) {
        L_WARNING("%6.2f radians; large angle for in-place 3-shear rotation\n",
                  __func__, L_ABS(angle));
    }
 
    hangle = atan(sin(angle));
    pixHShearIP(pixs, ycen, angle / 2.f, incolor);
    pixVShearIP(pixs, xcen, hangle, incolor);
    pixHShearIP(pixs, ycen, angle / 2.f, incolor);
    return 0;
}
 
 
/*------------------------------------------------------------------*
 *                    Rotations about the image center              *
 *------------------------------------------------------------------*/
PIX *
pixRotateShearCenter(PIX       *pixs,
                     l_float32  angle,
                     l_int32    incolor)
{
    if (!pixs)
        return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL);
 
    return pixRotateShear(pixs, pixGetWidth(pixs) / 2,
                          pixGetHeight(pixs) / 2, angle, incolor);
}
 
 
l_ok
pixRotateShearCenterIP(PIX       *pixs,
                       l_float32  angle,
                       l_int32    incolor)
{
    if (!pixs)
        return ERROR_INT("pixs not defined", __func__, 1);
 
    return pixRotateShearIP(pixs, pixGetWidth(pixs) / 2,
                            pixGetHeight(pixs) / 2, angle, incolor);
}