Logo Search packages:      
Sourcecode: leptonlib version File versions  Download package

ropiplow.c

/*====================================================================*
 -  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.
 *====================================================================*/

/*
 *  ropiplow.c
 *
 *      Low level in-place full height vertical block transfer
 *
 *           void     rasteropVipLow()
 *
 *      Low level in-place full width horizontal block transfer
 *
 *           void     rasteropHipLow()
 *           void     shiftDataHorizontalLow()
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "allheaders.h"


#define COMBINE_PARTIAL(d, s, m)     ( ((d) & ~(m)) | ((s) & (m)) )

static const l_uint32 lmask32[] = {0x0,
    0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
    0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
    0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
    0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
    0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
    0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
    0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
    0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff};

static const l_uint32 rmask32[] = {0x0,
    0x00000001, 0x00000003, 0x00000007, 0x0000000f,
    0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
    0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
    0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
    0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
    0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
    0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
    0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff};


/*--------------------------------------------------------------------*
 *                 Low-level Vertical In-place Rasterop               *
 *--------------------------------------------------------------------*/
/*!
 *  rasteropVipLow()
 *
 *      Input:  data   (ptr to image data)
 *              pixw   (width)
 *              pixh   (height)
 *              depth  (depth)
 *              wpl    (wpl)
 *              x      (x val of UL corner of rectangle)
 *              w      (width of rectangle)
 *              shift  (+ shifts data downward in vertical column)
 *      Return: 0 if OK; 1 on error.
 *
 *  Notes:
 *      (1) This clears the pixels that are left exposed after the
 *          translation.  You can consider them as pixels that are
 *          shifted in from outside the image.  This can be later
 *          overridden by the incolor parameter in higher-level functions
 *          that call this.  For example, for images with depth > 1,
 *          these pixels are cleared to black; to be white they
 *          must later be SET to white.  See, e.g., pixRasteropVip().
 *      (2) This function scales the width to accommodate any depth,
 *          performs clipping, and then does the in-place rasterop.
 */
void
rasteropVipLow(l_uint32  *data,
               l_int32    pixw,
               l_int32    pixh,
             l_int32    depth,
             l_int32    wpl,
             l_int32    x,
             l_int32    w,
               l_int32    shift)
{
l_int32    fwpartb;    /* boolean (1, 0) if first word is partial */
l_int32    fwpart2b;   /* boolean (1, 0) if first word is doubly partial */
l_uint32   fwmask;     /* mask for first partial word */
l_int32    fwbits;     /* first word bits in ovrhang */
l_uint32  *pdfwpart;   /* ptr to first partial dest word */
l_uint32  *psfwpart;   /* ptr to first partial src word */
l_int32    fwfullb;    /* boolean (1, 0) if there exists a full word */
l_int32    nfullw;     /* number of full words */
l_uint32  *pdfwfull;   /* ptr to first full dest word */
l_uint32  *psfwfull;   /* ptr to first full src word */
l_int32    lwpartb;    /* boolean (1, 0) if last word is partial */
l_uint32   lwmask;     /* mask for last partial word */
l_int32    lwbits;     /* last word bits in ovrhang */
l_uint32  *pdlwpart;   /* ptr to last partial dest word */
l_uint32  *pslwpart;   /* ptr to last partial src word */
l_int32    dirwpl;     /* directed wpl (-wpl * sign(shift)) */
l_int32    absshift;   /* absolute value of shift; for use in iterator */
l_int32    vlimit;     /* vertical limit value for iterations */
l_int32    i, j;


   /*--------------------------------------------------------*
    *            Scale horizontal dimensions by depth        *
    *--------------------------------------------------------*/
    if (depth != 1) {
        pixw *= depth;
      x *= depth;
      w *= depth;
    }


   /*--------------------------------------------------------*
    *                   Clip horizontally                    *
    *--------------------------------------------------------*/
    if (x < 0) {
      w += x;    /* reduce w */
      x = 0;     /* clip to x = 0 */
    }
    if (x >= pixw || w <= 0)  /* no part of vertical slice is in the image */
      return;

    if (x + w > pixw)
      w = pixw - x;   /* clip to x + w = pixw */

    /*--------------------------------------------------------*
     *                Preliminary calculations                *
     *--------------------------------------------------------*/
      /* is the first word partial? */
    if ((x & 31) == 0) {  /* if not */
        fwpartb = 0;
      fwbits = 0;
    }
    else {  /* if so */
        fwpartb = 1;
      fwbits = 32 - (x & 31);
      fwmask = rmask32[fwbits];
      if (shift >= 0) { /* go up from bottom */
          pdfwpart = data + wpl * (pixh - 1) + (x >> 5);
          psfwpart = data + wpl * (pixh - 1 - shift) + (x >> 5);
      }
      else {  /* go down from top */
          pdfwpart = data + (x >> 5);
          psfwpart = data - wpl * shift + (x >> 5);
      }
    }

        /* is the first word doubly partial? */
    if (w >= fwbits)  /* if not */
        fwpart2b = 0;
    else {  /* if so */
        fwpart2b = 1;
        fwmask &= lmask32[32 - fwbits + w];
    }

        /* is there a full dest word? */
    if (fwpart2b == 1) {  /* not */
        fwfullb = 0;
      nfullw = 0;
    }
    else {
      nfullw = (w - fwbits) >> 5;
      if (nfullw == 0)  /* if not */
          fwfullb = 0;
      else {  /* if so */
          fwfullb = 1;
          if (fwpartb) {
            pdfwfull = pdfwpart + 1;
            psfwfull = psfwpart + 1;
          }
          else {
            if (shift >= 0) { /* go up from bottom */
                pdfwfull = data + wpl * (pixh - 1) + (x >> 5);
                psfwfull = data + wpl * (pixh - 1 - shift) + (x >> 5);
            }
            else {  /* go down from top */
                pdfwfull = data + (x >> 5);
                psfwfull = data - wpl * shift + (x >> 5);
            }
          }
      }
    }

      /* is the last word partial? */
    lwbits = (x + w) & 31;
    if (fwpart2b == 1 || lwbits == 0)  /* if not */
        lwpartb = 0;
    else {
      lwpartb = 1;
        lwmask = lmask32[lwbits];
      if (fwpartb) {
          pdlwpart = pdfwpart + 1 + nfullw;
          pslwpart = psfwpart + 1 + nfullw;
      }
      else {
          if (shift >= 0) { /* go up from bottom */
            pdlwpart = data + wpl * (pixh - 1) + (x >> 5) + nfullw;
            pslwpart = data + wpl * (pixh - 1 - shift) + (x >> 5) + nfullw;
          }
          else {  /* go down from top */
            pdlwpart = data + (x >> 5) + nfullw;
            pslwpart = data - wpl * shift + (x >> 5) + nfullw;
          }
      }
    }

      /* determine the direction of flow from the shift
       * If the shift >= 0, data flows downard from src
       * to dest, starting at the bottom and working up.
       * If shift < 0, data flows upward from src to 
       * dest, starting at the top and working down. */
    dirwpl = (shift >= 0) ? -wpl : wpl;
    absshift = L_ABS(shift);
    vlimit = L_MAX(0, pixh - absshift);


/*--------------------------------------------------------*
 *            Now we're ready to do the ops               *
 *--------------------------------------------------------*/

      /* Do the first partial word */
    if (fwpartb) {
      for (i = 0; i < vlimit; i++) {
          *pdfwpart = COMBINE_PARTIAL(*pdfwpart, *psfwpart, fwmask);
          pdfwpart += dirwpl;
          psfwpart += dirwpl;
      }

          /* Clear the incoming pixels */
      for (i = vlimit; i < pixh; i++) {
          *pdfwpart = COMBINE_PARTIAL(*pdfwpart, 0x0, fwmask);
          pdfwpart += dirwpl;
      }
    }

      /* Do the full words */
    if (fwfullb) {
      for (i = 0; i < vlimit; i++) {
          for (j = 0; j < nfullw; j++)
            *(pdfwfull + j) = *(psfwfull + j);
          pdfwfull += dirwpl;
          psfwfull += dirwpl;
      }

          /* Clear the incoming pixels */
      for (i = vlimit; i < pixh; i++) {
          for (j = 0; j < nfullw; j++)
            *(pdfwfull + j) = 0x0;
          pdfwfull += dirwpl;
      }
    }

      /* Do the last partial word */
    if (lwpartb) {
      for (i = 0; i < vlimit; i++) {
          *pdlwpart = COMBINE_PARTIAL(*pdlwpart, *pslwpart, lwmask);
          pdlwpart += dirwpl;
          pslwpart += dirwpl;
      }

          /* Clear the incoming pixels */
      for (i = vlimit; i < pixh; i++) {
          *pdlwpart = COMBINE_PARTIAL(*pdlwpart, 0x0, lwmask);
          pdlwpart += dirwpl;
      }
    } 

    return;
}



/*--------------------------------------------------------------------*
 *                 Low-level Horizontal In-place Rasterop             *
 *--------------------------------------------------------------------*/
/*! 
 *  rasteropHipLow()
 *
 *      Input:  data   (ptr to image data)
 *              pixh   (height)
 *              depth  (depth)
 *              wpl    (wpl)
 *              y      (y val of UL corner of rectangle)
 *              h      (height of rectangle)
 *              shift  (+ shifts data downward in vertical column)
 *      Return: 0 if OK; 1 on error.
 *
 *  Notes:
 *      (1) This clears the pixels that are left exposed after the rasterop.
 *          Therefore, for Pix with depth > 1, these pixels become black,
 *          and must be subsequently SET if they are to be white.  
 *          For example, see pixRasteropHip().
 *      (2) This function performs clipping and calls shiftDataHorizontalLine()
 *          to do the in-place rasterop on each line.
 */
void
rasteropHipLow(l_uint32  *data,
             l_int32    pixh,
             l_int32    depth,
             l_int32    wpl,
             l_int32    y,
             l_int32    h,
             l_int32    shift)
{
l_int32    i;
l_uint32  *line;

      /* clip band if necessary */
    if (y < 0) {
      h += y;  /* reduce h */
      y = 0;   /* clip to y = 0 */
    }
    if (h <= 0 || y > pixh)  /* no part of horizontal slice is in the image */
      return;

    if (y + h > pixh)
      h = pixh - y;   /* clip to y + h = pixh */

    for (i = y; i < y + h; i++) {
      line = data + i * wpl;
      shiftDataHorizontalLow(line, wpl, line, wpl, shift * depth);
    }
}


/*!
 *  shiftDataHorizontalLow()
 *
 *      Input:  datad  (ptr to beginning of dest line)
 *              wpld   (wpl of dest)
 *              datas  (ptr to beginning of src line)
 *              wpls   (wpl of src)
 *              shift  (horizontal shift of block; >0 is to right)
 *      Return: void
 *
 *  Notes:
 *      (1) This can also be used for in-place operation; see, e.g.,
 *          rasteropHipLow().
 *      (2) We are clearing the pixels that are shifted in from
 *          outside the image.  This can be overridden by the
 *          incolor parameter in higher-level functions that call this.
 */
void
shiftDataHorizontalLow(l_uint32  *datad,
                       l_int32    wpld,
                   l_uint32  *datas,
                   l_int32    wpls,
                   l_int32    shift)
{
l_int32    j, firstdw, wpl, rshift, lshift;
l_uint32  *lined, *lines;

    lined = datad;
    lines = datas;

    if (shift >= 0) {   /* src shift to right; data flows to
                         * right, starting at right edge and
                   * progressing leftward. */
        firstdw = shift / 32;
      wpl = L_MIN(wpls, wpld - firstdw);
      lined += firstdw + wpl - 1;
      lines += wpl - 1;
      rshift = shift & 31;
      if (rshift == 0) {
          for (j = 0; j < wpl; j++)
            *lined-- = *lines--;

            /* clear out the rest to the left edge */
          for (j = 0; j < firstdw; j++)
              *lined-- = 0;
      }
      else {
          lshift = 32 - rshift;
          for (j = 1; j < wpl; j++) {
            *lined-- = *(lines - 1) << lshift | *lines >> rshift;
            lines--;
          }
          *lined = *lines >> rshift;  /* partial first */

            /* clear out the rest to the left edge */
          *lined &= ~lmask32[rshift];
          lined--;
          for (j = 0; j < firstdw; j++)
              *lined-- = 0;
      }
    }
    else {  /* src shift to left; data flows to left, starting
             * at left edge and progressing rightward. */
        firstdw = (-shift) / 32;
      wpl = L_MIN(wpls - firstdw, wpld);
      lines += firstdw;
      lshift = (-shift) & 31;
      if (lshift == 0) {
          for (j = 0; j < wpl; j++)
            *lined++ = *lines++;

            /* clear out the rest to the right edge */
          for (j = 0; j < firstdw; j++)
              *lined++ = 0;
      }
      else {
          rshift = 32 - lshift;
          for (j = 1; j < wpl; j++) {
            *lined++ = *lines << lshift | *(lines + 1) >> rshift;
            lines++;
          }
          *lined = *lines << lshift;  /* partial last */

            /* clear out the rest to the right edge */
            /* first clear the lshift pixels of this partial word */
          *lined &= ~rmask32[lshift];
          lined++;
            /* then the remaining words to the right edge */
          for (j = 0; j < firstdw; j++)
              *lined++ = 0;
      }
    }

    return;
}


Generated by  Doxygen 1.6.0   Back to index