/*====================================================================*
- 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.
*====================================================================*/
/*
* warper.c
*
* High-level captcha interface
* PIX *pixSimpleCaptcha()
*
* Random sinusoidal warping
* PIX *pixRandomHarmonicWarp()
*
* Helper functions
* static l_float64 *generateRandomNumberArray()
* static l_int32 applyWarpTransform()
*
* Version using a LUT for sin
* PIX *pixRandomHarmonicWarpLUT()
* static l_int32 applyWarpTransformLUT()
* static l_int32 makeSinLUT()
* static l_float32 getSinFromLUT()
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "allheaders.h"
static l_float64 *generateRandomNumberArray(l_int32 size);
static l_int32 applyWarpTransform(l_float32 xmag, l_float32 ymag,
l_float32 xfreq, l_float32 yfreq,
l_float64 *randa, l_int32 nx, l_int32 ny,
l_int32 xp, l_int32 yp,
l_float32 *px, l_float32 *py);
#define USE_SIN_TABLE 0
/*----------------------------------------------------------------------*
* High-level example captcha interface *
*----------------------------------------------------------------------*/
/*!
* pixSimpleCaptcha()
*
* Input: pixs (8 bpp; no colormap)
* border (added white pixels on each side)
* nterms (number of x and y harmonic terms)
* seed (of random number generator)
* color (for colorizing; in 0xrrggbb00 format; use 0 for black)
* cmapflag (1 for colormap output; 0 for rgb)
* Return: pixd (8 bpp cmap or 32 bpp rgb), or null on error
*
* Notes:
* (1) This uses typical default values for generating captchas.
* The magnitudes of the harmonic warp are typically to be
* smaller when more terms are used, even though the phases
* are random. See, for example, prog/warptest.c.
*/
PIX *
pixSimpleCaptcha(PIX *pixs,
l_int32 border,
l_int32 nterms,
l_uint32 seed,
l_uint32 color,
l_int32 cmapflag)
{
l_int32 k;
l_float32 xmag[] = {7.0, 5.0, 4.0, 3.0};
l_float32 ymag[] = {10.0, 8.0, 6.0, 5.0};
l_float32 xfreq[] = {0.12, 0.10, 0.10, 0.11};
l_float32 yfreq[] = {0.15, 0.13, 0.13, 0.11};
PIX *pixg, *pixgb, *pixw, *pixd;
PROCNAME("pixSimpleCaptcha");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (nterms < 1 || nterms > 4)
return (PIX *)ERROR_PTR("nterms must be in {1,2,3,4}", procName, NULL);
k = nterms - 1;
pixg = pixConvertTo8(pixs, 0);
pixgb = pixAddBorder(pixg, border, 255);
pixw = pixRandomHarmonicWarp(pixgb, xmag[k], ymag[k], xfreq[k], yfreq[k],
nterms, nterms, seed, 255);
pixd = pixColorizeGray(pixw, color, cmapflag);
pixDestroy(&pixg);
pixDestroy(&pixgb);
pixDestroy(&pixw);
return pixd;
}
/*----------------------------------------------------------------------*
* Random sinusoidal warping *
*----------------------------------------------------------------------*/
/*!
* pixRandomHarmonicWarp()
*
* Input: pixs (8 bpp; no colormap)
* xmag, ymag (maximum magnitude of x and y distortion)
* xfreq, yfreq (maximum magnitude of x and y frequency)
* nx, ny (number of x and y harmonic terms)
* seed (of random number generator)
* grayval (color brought in from the outside;
* 0 for black, 255 for white)
* Return: pixd (8 bpp; no colormap), or null on error
*
* Notes:
* (1) To generate the warped image p(x',y'), set up the transforms
* that are in getWarpTransform(). For each (x',y') in the
* dest, the warp function computes the originating location
* (x, y) in the src. The differences (x - x') and (y - y')
* are given as a sum of products of sinusoidal terms. Each
* term is multiplied by a maximum amplitude (in pixels), and the
* angle is determined by a frequency and phase, and depends
* on the (x', y') value of the dest. Random numbers with
* a variable input seed are used to allow the warping to be
* unpredictable. A linear interpolation is used to find
* the value for the source at (x, y); this value is written
* into the dest.
* (2) This can be used to generate 'captcha's, which are somewhat
* randomly distorted images of text. A typical set of parameters
* for a captcha are:
* xmag = 4.0 ymag = 6.0
* xfreq = 0.10 yfreq = 0.13
* nx = 3 ny = 3
* Other examples can be found in prog/warptest.c.
*/
PIX *
pixRandomHarmonicWarp(PIX *pixs,
l_float32 xmag,
l_float32 ymag,
l_float32 xfreq,
l_float32 yfreq,
l_int32 nx,
l_int32 ny,
l_uint32 seed,
l_int32 grayval)
{
l_int32 w, h, d, i, j, wpls, wpld, val;
l_uint32 *datas, *datad, *lined;
l_float32 x, y;
l_float64 *randa;
PIX *pixd;
PROCNAME("pixRandomHarmonicWarp");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 8)
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
/* Compute filter output at each location. We iterate over
* the destination pixels. For each dest pixel, use the
* warp function to compute the four source pixels that
* contribute, at the location (x, y). Each source pixel
* is divided into 16 x 16 subpixels to get an approximate value. */
srand(seed);
randa = generateRandomNumberArray(5 * (nx + ny));
pixd = pixCreateTemplate(pixs);
datas = pixGetData(pixs);
wpls = pixGetWpl(pixs);
datad = pixGetData(pixd);
wpld = pixGetWpl(pixd);
for (i = 0; i < h; i++) {
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
applyWarpTransform(xmag, ymag, xfreq, yfreq, randa, nx, ny,
j, i, &x, &y);
linearInterpolatePixelGray(datas, wpls, w, h, x, y, grayval, &val);
SET_DATA_BYTE(lined, j, val);
}
}
FREE(randa);
return pixd;
}
/*----------------------------------------------------------------------*
* Static helper functions *
*----------------------------------------------------------------------*/
static l_float64 *
generateRandomNumberArray(l_int32 size)
{
l_int32 i;
l_float64 *randa;
PROCNAME("generateRandomNumberArray");
if ((randa = (l_float64 *)CALLOC(size, sizeof(l_float64))) == NULL)
return (l_float64 *)ERROR_PTR("calloc fail for randa", procName, NULL);
/* Return random values between 0.5 and 1.0 */
for (i = 0; i < size; i++)
randa[i] = 0.5 * (1.0 + (l_float64)rand() / (l_float64)RAND_MAX);
return randa;
}
/*!
* applyWarpTransform()
*
* Notes:
* (1) Uses the internal sin function.
*/
static l_int32
applyWarpTransform(l_float32 xmag,
l_float32 ymag,
l_float32 xfreq,
l_float32 yfreq,
l_float64 *randa,
l_int32 nx,
l_int32 ny,
l_int32 xp,
l_int32 yp,
l_float32 *px,
l_float32 *py)
{
l_int32 i;
l_float64 twopi, x, y, anglex, angley;
twopi = 6.283185;
for (i = 0, x = xp; i < nx; i++) {
anglex = xfreq * randa[3 * i + 1] * xp + twopi * randa[3 * i + 2];
angley = yfreq * randa[3 * i + 3] * yp + twopi * randa[3 * i + 4];
x += xmag * randa[3 * i] * sin(anglex) * sin(angley);
}
for (i = nx, y = yp; i < nx + ny; i++) {
angley = yfreq * randa[3 * i + 1] * yp + twopi * randa[3 * i + 2];
anglex = xfreq * randa[3 * i + 3] * xp + twopi * randa[3 * i + 4];
y += ymag * randa[3 * i] * sin(angley) * sin(anglex);
}
*px = (l_float32)x;
*py = (l_float32)y;
return 0;
}
#if USE_SIN_TABLE
/*----------------------------------------------------------------------*
* Version using a LUT for sin *
*----------------------------------------------------------------------*/
static l_int32 applyWarpTransformLUT(l_float32 xmag, l_float32 ymag,
l_float32 xfreq, l_float32 yfreq,
l_float64 *randa, l_int32 nx, l_int32 ny,
l_int32 xp, l_int32 yp, l_float32 *lut,
l_int32 npts, l_float32 *px, l_float32 *py);
static l_int32 makeSinLUT(l_int32 npts, NUMA **pna);
static l_float32 getSinFromLUT(l_float32 *tab, l_int32 npts,
l_float32 radang);
/*!
* pixRandomHarmonicWarpLUT()
*
* Input: pixs (8 bpp; no colormap)
* xmag, ymag (maximum magnitude of x and y distortion)
* xfreq, yfreq (maximum magnitude of x and y frequency)
* nx, ny (number of x and y harmonic terms)
* seed (of random number generator)
* grayval (color brought in from the outside;
* 0 for black, 255 for white)
* Return: pixd (8 bpp; no colormap), or null on error
*
* Notes:
* (1) See notes and inline comments in pixRandomHarmonicWarp().
* This version uses a LUT for the sin function. It is not
* appreciably faster than using the built-in sin function,
* and is here for comparison only.
*/
PIX *
pixRandomHarmonicWarpLUT(PIX *pixs,
l_float32 xmag,
l_float32 ymag,
l_float32 xfreq,
l_float32 yfreq,
l_int32 nx,
l_int32 ny,
l_uint32 seed,
l_int32 grayval)
{
l_int32 w, h, d, i, j, wpls, wpld, val, npts;
l_uint32 *datas, *datad, *lined;
l_float32 x, y;
l_float32 *lut;
l_float64 *randa;
NUMA *na;
PIX *pixd;
PROCNAME("pixRandomHarmonicWarp");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 8)
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
/* Compute filter output at each location. We iterate over
* the destination pixels. For each dest pixel, use the
* warp function to compute the four source pixels that
* contribute, at the location (x, y). Each source pixel
* is divided into 16 x 16 subpixels to get an approximate value. */
srand(seed);
randa = generateRandomNumberArray(5 * (nx + ny));
pixd = pixCreateTemplate(pixs);
datas = pixGetData(pixs);
wpls = pixGetWpl(pixs);
datad = pixGetData(pixd);
wpld = pixGetWpl(pixd);
npts = 100;
makeSinLUT(npts, &na);
lut = numaGetFArray(na, L_NOCOPY);
for (i = 0; i < h; i++) {
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
applyWarpTransformLUT(xmag, ymag, xfreq, yfreq, randa, nx, ny,
j, i, lut, npts, &x, &y);
linearInterpolatePixelGray(datas, wpls, w, h, x, y, grayval, &val);
SET_DATA_BYTE(lined, j, val);
}
}
numaDestroy(&na);
FREE(randa);
return pixd;
}
/*!
* applyWarpTransformLUT()
*
* Notes:
* (1) Uses an LUT for computing sin(theta). There is little speed
* advantage to using the LUT.
*/
static l_int32
applyWarpTransformLUT(l_float32 xmag,
l_float32 ymag,
l_float32 xfreq,
l_float32 yfreq,
l_float64 *randa,
l_int32 nx,
l_int32 ny,
l_int32 xp,
l_int32 yp,
l_float32 *lut,
l_int32 npts,
l_float32 *px,
l_float32 *py)
{
l_int32 i;
l_float64 twopi, x, y, anglex, angley, sanglex, sangley;
twopi = 6.283185;
for (i = 0, x = xp; i < nx; i++) {
anglex = xfreq * randa[3 * i + 1] * xp + twopi * randa[3 * i + 2];
angley = yfreq * randa[3 * i + 3] * yp + twopi * randa[3 * i + 4];
sanglex = getSinFromLUT(lut, npts, anglex);
sangley = getSinFromLUT(lut, npts, angley);
x += xmag * randa[3 * i] * sanglex * sangley;
}
for (i = nx, y = yp; i < nx + ny; i++) {
angley = yfreq * randa[3 * i + 1] * yp + twopi * randa[3 * i + 2];
anglex = xfreq * randa[3 * i + 3] * xp + twopi * randa[3 * i + 4];
sanglex = getSinFromLUT(lut, npts, anglex);
sangley = getSinFromLUT(lut, npts, angley);
y += ymag * randa[3 * i] * sangley * sanglex;
}
*px = (l_float32)x;
*py = (l_float32)y;
return 0;
}
static l_int32
makeSinLUT(l_int32 npts,
NUMA **pna)
{
l_int32 i, n;
l_float32 delx, fval;
NUMA *na;
PROCNAME("makeSinLUT");
if (!pna)
return ERROR_INT("&na not defined", procName, 1);
*pna = NULL;
if (npts < 2)
return ERROR_INT("npts < 2", procName, 1);
n = 2 * npts + 1;
na = numaCreate(n);
*pna = na;
delx = 3.14159265 / (l_float32)npts;
numaSetXParameters(na, 0.0, delx);
for (i = 0; i < n / 2; i++)
numaAddNumber(na, (l_float32)sin((l_float64)i * delx));
for (i = 0; i < n / 2; i++) {
numaGetFValue(na, i, &fval);
numaAddNumber(na, -fval);
}
numaAddNumber(na, 0);
return 0;
}
static l_float32
getSinFromLUT(l_float32 *tab,
l_int32 npts,
l_float32 radang)
{
l_int32 index;
l_float32 twopi, invtwopi, findex, diff;
/* Restrict radang to [0, 2pi] */
twopi = 6.283185;
invtwopi = 0.1591549;
if (radang < 0.0)
radang += twopi * (1.0 - (l_int32)(-radang * invtwopi));
else if (radang > 0.0)
radang -= twopi * (l_int32)(radang * invtwopi);
/* Interpolate */
findex = (2.0 * (l_float32)npts) * (radang * invtwopi);
index = (l_int32)findex;
if (index == 2 * npts)
return tab[index];
diff = findex - index;
return (1.0 - diff) * tab[index] + diff * tab[index + 1];
}
#endif /* USE_SIN_TABLE */