66 #include <config_auto.h>
70 #include "allheaders.h"
72 static l_float64 *generateRandomNumberArray(l_int32 size);
74 l_float32 xfreq, l_float32 yfreq,
75 l_float64 *randa, l_int32 nx, l_int32 ny,
76 l_int32 xp, l_int32 yp,
77 l_float32 *px, l_float32 *py);
79 #define USE_SIN_TABLE 0
83 static const l_float32 DefaultRedWeight = 0.0;
84 static const l_float32 DefaultGreenWeight = 0.7;
85 static const l_float32 DefaultBlueWeight = 0.3;
119 l_float32 xmag[] = {7.0f, 5.0f, 4.0f, 3.0f};
120 l_float32 ymag[] = {10.0f, 8.0f, 6.0f, 5.0f};
121 l_float32 xfreq[] = {0.12f, 0.10f, 0.10f, 0.11f};
122 l_float32 yfreq[] = {0.15f, 0.13f, 0.13f, 0.11f};
123 PIX *pixg, *pixgb, *pixw, *pixd;
125 PROCNAME(
"pixSimpleCaptcha");
128 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
129 if (nterms < 1 || nterms > 4)
130 return (
PIX *)ERROR_PTR(
"nterms must be in {1,2,3,4}", procName, NULL);
136 nterms, nterms, seed, 255);
195 l_int32 w, h, d, i, j, wpls, wpld, val;
196 l_uint32 *datas, *datad, *lined;
201 PROCNAME(
"pixRandomHarmonicWarp");
204 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
207 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
215 randa = generateRandomNumberArray(5 * (nx + ny));
218 wpls = pixGetWpl(pixs);
220 wpld = pixGetWpl(pixd);
222 for (i = 0; i < h; i++) {
223 lined = datad + i * wpld;
224 for (j = 0; j < w; j++) {
241 generateRandomNumberArray(l_int32 size)
246 PROCNAME(
"generateRandomNumberArray");
248 if ((randa = (l_float64 *)LEPT_CALLOC(size,
sizeof(l_float64))) == NULL)
249 return (l_float64 *)ERROR_PTR(
"calloc fail for randa", procName, NULL);
252 for (i = 0; i < size; i++)
253 randa[i] = 0.5 * (1.0 + (l_float64)rand() / (l_float64)RAND_MAX);
278 l_float64 twopi, x, y, anglex, angley;
281 for (i = 0, x = xp; i < nx; i++) {
282 anglex = xfreq * randa[3 * i + 1] * xp + twopi * randa[3 * i + 2];
283 angley = yfreq * randa[3 * i + 3] * yp + twopi * randa[3 * i + 4];
284 x += xmag * randa[3 * i] * sin(anglex) * sin(angley);
286 for (i = nx, y = yp; i < nx + ny; i++) {
287 angley = yfreq * randa[3 * i + 1] * yp + twopi * randa[3 * i + 2];
288 anglex = xfreq * randa[3 * i + 3] * xp + twopi * randa[3 * i + 4];
289 y += ymag * randa[3 * i] * sin(angley) * sin(anglex);
302 static l_int32 applyWarpTransformLUT(l_float32 xmag, l_float32 ymag,
303 l_float32 xfreq, l_float32 yfreq,
304 l_float64 *randa, l_int32 nx, l_int32 ny,
305 l_int32 xp, l_int32 yp, l_float32 *lut,
306 l_int32 npts, l_float32 *px, l_float32 *py);
307 static l_int32 makeSinLUT(l_int32 npts,
NUMA **pna);
308 static l_float32 getSinFromLUT(l_float32 *tab, l_int32 npts,
332 pixRandomHarmonicWarpLUT(
PIX *pixs,
342 l_int32 w, h, d, i, j, wpls, wpld, val, npts;
343 l_uint32 *datas, *datad, *lined;
350 PROCNAME(
"pixRandomHarmonicWarp");
353 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
356 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
364 randa = generateRandomNumberArray(5 * (nx + ny));
367 wpls = pixGetWpl(pixs);
369 wpld = pixGetWpl(pixd);
372 makeSinLUT(npts, &na);
374 for (i = 0; i < h; i++) {
375 lined = datad + i * wpld;
376 for (j = 0; j < w; j++) {
377 applyWarpTransformLUT(xmag, ymag, xfreq, yfreq, randa, nx, ny,
378 j, i, lut, npts, &x, &y);
398 applyWarpTransformLUT(l_float32 xmag,
413 l_float64 twopi, x, y, anglex, angley, sanglex, sangley;
416 for (i = 0, x = xp; i < nx; i++) {
417 anglex = xfreq * randa[3 * i + 1] * xp + twopi * randa[3 * i + 2];
418 angley = yfreq * randa[3 * i + 3] * yp + twopi * randa[3 * i + 4];
419 sanglex = getSinFromLUT(lut, npts, anglex);
420 sangley = getSinFromLUT(lut, npts, angley);
421 x += xmag * randa[3 * i] * sanglex * sangley;
423 for (i = nx, y = yp; i < nx + ny; i++) {
424 angley = yfreq * randa[3 * i + 1] * yp + twopi * randa[3 * i + 2];
425 anglex = xfreq * randa[3 * i + 3] * xp + twopi * randa[3 * i + 4];
426 sanglex = getSinFromLUT(lut, npts, anglex);
427 sangley = getSinFromLUT(lut, npts, angley);
428 y += ymag * randa[3 * i] * sangley * sanglex;
438 makeSinLUT(l_int32 npts,
442 l_float32 delx, fval;
445 PROCNAME(
"makeSinLUT");
448 return ERROR_INT(
"&na not defined", procName, 1);
451 return ERROR_INT(
"npts < 2", procName, 1);
455 delx = 3.14159265 / (l_float32)npts;
457 for (i = 0; i < n / 2; i++)
459 for (i = 0; i < n / 2; i++) {
470 getSinFromLUT(l_float32 *tab,
475 l_float32 twopi, invtwopi, findex, diff;
479 invtwopi = 0.1591549;
481 radang += twopi * (1.0 - (l_int32)(-radang * invtwopi));
482 else if (radang > 0.0)
483 radang -= twopi * (l_int32)(radang * invtwopi);
486 findex = (2.0 * (l_float32)npts) * (radang * invtwopi);
487 index = (l_int32)findex;
488 if (index == 2 * npts)
490 diff = findex - index;
491 return (1.0 - diff) * tab[index] + diff * tab[index + 1];
598 l_int32 w, h, zshift;
600 BOX *boxleft, *boxright;
601 PIX *pix1, *pix2, *pix3, *pix4, *pixr, *pixg, *pixb;
602 PIX *pixv1, *pixv2, *pixv3, *pixv4;
606 PROCNAME(
"pixWarpStereoscopic");
609 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
618 boxright =
boxCreate(w / 2, 0, w - w / 2, h);
619 if (ybendt != 0 || ybendb != 0) {
678 if (zshiftt == 0 && zshiftb == 0) {
680 }
else if (zshiftt == zshiftb) {
683 angle = (l_float32)(zshiftb - zshiftt) /
684 L_MAX(1.0, (l_float32)pixGetHeight(pixrs));
685 zshift = (zshiftt + zshiftb) / 2;
746 PROCNAME(
"pixStretchHorizontal");
749 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
750 d = pixGetDepth(pixs);
751 if (d != 1 && d != 8 && d != 32)
752 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", procName, NULL);
754 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
756 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
758 return (
PIX *)ERROR_PTR(
"invalid operation", procName, NULL);
760 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
762 L_WARNING(
"Using sampling for 1 bpp\n", procName);
795 l_int32 i, j, jd, w, wm, h, d, wpls, wpld, val;
796 l_uint32 *datas, *datad, *lines, *lined;
799 PROCNAME(
"pixStretchHorizontalSampled");
802 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
804 if (d != 1 && d != 8 && d != 32)
805 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", procName, NULL);
807 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
809 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
811 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
817 wpls = pixGetWpl(pixs);
818 wpld = pixGetWpl(pixd);
820 for (jd = 0; jd < w; jd++) {
823 j = jd - (hmax * (wm - jd)) / wm;
825 j = jd - (hmax * (wm - jd) * (wm - jd)) / (wm * wm);
828 j = jd - (hmax * jd) / wm;
830 j = jd - (hmax * jd * jd) / (wm * wm);
832 if (j < 0 || j > w - 1)
continue;
837 for (i = 0; i < h; i++) {
838 lines = datas + i * wpls;
839 lined = datad + i * wpld;
846 for (i = 0; i < h; i++) {
847 lines = datas + i * wpls;
848 lined = datad + i * wpld;
854 for (i = 0; i < h; i++) {
855 lines = datas + i * wpls;
856 lined = datad + i * wpld;
857 lined[jd] = lines[j];
861 L_ERROR(
"invalid depth: %d\n", procName, d);
893 l_int32 i, j, jd, jp, jf, w, wm, h, d, wpls, wpld, val, rval, gval, bval;
894 l_uint32 word0, word1;
895 l_uint32 *datas, *datad, *lines, *lined;
898 PROCNAME(
"pixStretchHorizontalLI");
901 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
903 if (d != 8 && d != 32)
904 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
906 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
908 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
910 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
917 wpls = pixGetWpl(pixs);
918 wpld = pixGetWpl(pixd);
920 for (jd = 0; jd < w; jd++) {
923 j = 64 * jd - 64 * (hmax * (wm - jd)) / wm;
925 j = 64 * jd - 64 * (hmax * (wm - jd) * (wm - jd)) / (wm * wm);
928 j = 64 * jd - 64 * (hmax * jd) / wm;
930 j = 64 * jd - 64 * (hmax * jd * jd) / (wm * wm);
934 if (jp < 0 || jp > wm)
continue;
940 for (i = 0; i < h; i++) {
941 lines = datas + i * wpls;
942 lined = datad + i * wpld;
948 for (i = 0; i < h; i++) {
949 lines = datas + i * wpls;
950 lined = datad + i * wpld;
958 for (i = 0; i < h; i++) {
959 lines = datas + i * wpls;
960 lined = datad + i * wpld;
961 word0 = *(lines + jp);
962 word1 = *(lines + jp + 1);
963 rval = ((63 - jf) * ((word0 >> L_RED_SHIFT) & 0xff) +
964 jf * ((word1 >> L_RED_SHIFT) & 0xff) + 31) / 63;
965 gval = ((63 - jf) * ((word0 >> L_GREEN_SHIFT) & 0xff) +
966 jf * ((word1 >> L_GREEN_SHIFT) & 0xff) + 31) / 63;
967 bval = ((63 - jf) * ((word0 >> L_BLUE_SHIFT) & 0xff) +
968 jf * ((word1 >> L_BLUE_SHIFT) & 0xff) + 31) / 63;
972 for (i = 0; i < h; i++) {
973 lines = datas + i * wpls;
974 lined = datad + i * wpld;
975 lined[jd] = lines[jp];
980 L_ERROR(
"invalid depth: %d\n", procName, d);
1032 PROCNAME(
"pixQuadraticVShear");
1035 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1037 if (d != 1 && d != 8 && d != 32)
1038 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", procName, NULL);
1040 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
1042 return (
PIX *)ERROR_PTR(
"invalid operation", procName, NULL);
1044 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
1046 if (vmaxt == 0 && vmaxb == 0)
1050 L_WARNING(
"no interpolation for 1 bpp; using sampling\n", procName);
1083 l_int32 i, j, id, w, h, d, wm, hm, wpls, wpld, val;
1084 l_uint32 *datas, *datad, *lines, *lined;
1085 l_float32 delrowt, delrowb, denom1, denom2, dely;
1088 PROCNAME(
"pixQuadraticVShearSampled");
1091 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1093 if (d != 1 && d != 8 && d != 32)
1094 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", procName, NULL);
1096 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
1098 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
1100 if (vmaxt == 0 && vmaxb == 0)
1107 wpls = pixGetWpl(pixs);
1108 wpld = pixGetWpl(pixd);
1111 denom1 = 1. / (l_float32)h;
1112 denom2 = 1. / (l_float32)(wm * wm);
1113 for (j = 0; j < w; j++) {
1115 delrowt = (l_float32)(vmaxt * (wm - j) * (wm - j)) * denom2;
1116 delrowb = (l_float32)(vmaxb * (wm - j) * (wm - j)) * denom2;
1118 delrowt = (l_float32)(vmaxt * j * j) * denom2;
1119 delrowb = (l_float32)(vmaxb * j * j) * denom2;
1124 for (
id = 0;
id < h;
id++) {
1125 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1126 i =
id - (l_int32)(dely + 0.5);
1127 if (i < 0 || i > hm)
continue;
1128 lines = datas + i * wpls;
1129 lined = datad +
id * wpld;
1136 for (
id = 0;
id < h;
id++) {
1137 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1138 i =
id - (l_int32)(dely + 0.5);
1139 if (i < 0 || i > hm)
continue;
1140 lines = datas + i * wpls;
1141 lined = datad +
id * wpld;
1147 for (
id = 0;
id < h;
id++) {
1148 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1149 i =
id - (l_int32)(dely + 0.5);
1150 if (i < 0 || i > hm)
continue;
1151 lines = datas + i * wpls;
1152 lined = datad +
id * wpld;
1153 lined[j] = lines[j];
1157 L_ERROR(
"invalid depth: %d\n", procName, d);
1189 l_int32 i, j, id, yp, yf, w, h, d, wm, hm, wpls, wpld;
1190 l_int32 val, rval, gval, bval;
1191 l_uint32 word0, word1;
1192 l_uint32 *datas, *datad, *lines, *lined;
1193 l_float32 delrowt, delrowb, denom1, denom2, dely;
1197 PROCNAME(
"pixQuadraticVShearLI");
1200 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1203 return (
PIX *)ERROR_PTR(
"pixs is 1 bpp", procName, NULL);
1204 cmap = pixGetColormap(pixs);
1205 if (d != 8 && d != 32 && !cmap)
1206 return (
PIX *)ERROR_PTR(
"pixs not 8, 32 bpp, or cmap", procName, NULL);
1208 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
1210 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
1212 if (vmaxt == 0 && vmaxb == 0)
1220 d = pixGetDepth(pix);
1221 if (d != 8 && d != 32) {
1223 return (
PIX *)ERROR_PTR(
"invalid depth", procName, NULL);
1231 wpls = pixGetWpl(pix);
1232 wpld = pixGetWpl(pixd);
1235 denom1 = 1.0 / (l_float32)h;
1236 denom2 = 1.0 / (l_float32)(wm * wm);
1237 for (j = 0; j < w; j++) {
1239 delrowt = (l_float32)(vmaxt * (wm - j) * (wm - j)) * denom2;
1240 delrowb = (l_float32)(vmaxb * (wm - j) * (wm - j)) * denom2;
1242 delrowt = (l_float32)(vmaxt * j * j) * denom2;
1243 delrowb = (l_float32)(vmaxb * j * j) * denom2;
1248 for (
id = 0;
id < h;
id++) {
1249 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1250 i = 64 *
id - (l_int32)(64.0 * dely);
1253 if (yp < 0 || yp > hm)
continue;
1254 lines = datas + yp * wpls;
1255 lined = datad +
id * wpld;
1266 for (
id = 0;
id < h;
id++) {
1267 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1268 i = 64 *
id - (l_int32)(64.0 * dely);
1271 if (yp < 0 || yp > hm)
continue;
1272 lines = datas + yp * wpls;
1273 lined = datad +
id * wpld;
1275 word0 = *(lines + j);
1276 word1 = *(lines + wpls + j);
1277 rval = ((63 - yf) * ((word0 >> L_RED_SHIFT) & 0xff) +
1278 yf * ((word1 >> L_RED_SHIFT) & 0xff) + 31) / 63;
1279 gval = ((63 - yf) * ((word0 >> L_GREEN_SHIFT) & 0xff) +
1280 yf * ((word1 >> L_GREEN_SHIFT) & 0xff) + 31) / 63;
1281 bval = ((63 - yf) * ((word0 >> L_BLUE_SHIFT) & 0xff) +
1282 yf * ((word1 >> L_BLUE_SHIFT) & 0xff) + 31) / 63;
1285 lined[j] = lines[j];
1290 L_ERROR(
"invalid depth: %d\n", procName, d);
1342 l_int32 i, j, w, h, wpl1, wpl2, rval, gval, bval;
1343 l_uint32 word1, word2;
1344 l_uint32 *data1, *data2, *datad, *line1, *line2, *lined;
1348 PROCNAME(
"pixStereoFromPair");
1351 return (
PIX *)ERROR_PTR(
"pix1, pix2 not both defined", procName, NULL);
1352 if (pixGetDepth(pix1) != 32 || pixGetDepth(pix2) != 32)
1353 return (
PIX *)ERROR_PTR(
"pix1, pix2 not both 32 bpp", procName, NULL);
1357 if (rwt == 0.0 && gwt == 0.0 && bwt == 0.0) {
1358 rwt = DefaultRedWeight;
1359 gwt = DefaultGreenWeight;
1360 bwt = DefaultBlueWeight;
1362 sum = rwt + gwt + bwt;
1363 if (L_ABS(sum - 1.0) > 0.0001) {
1364 L_WARNING(
"weights don't sum to 1; maintaining ratios\n", procName);
1375 wpl1 = pixGetWpl(pix1);
1376 wpl2 = pixGetWpl(pix2);
1377 for (i = 0; i < h; i++) {
1378 line1 = data1 + i * wpl1;
1379 line2 = data2 + i * wpl2;
1380 lined = datad + i * wpl1;
1381 for (j = 0; j < w; j++) {
1382 word1 = *(line1 + j);
1383 word2 = *(line2 + j);
1384 rval = (l_int32)(rwt * ((word1 >> L_RED_SHIFT) & 0xff) +
1385 gwt * ((word1 >> L_GREEN_SHIFT) & 0xff) +
1386 bwt * ((word1 >> L_BLUE_SHIFT) & 0xff) + 0.5);
1387 gval = (word2 >> L_GREEN_SHIFT) & 0xff;
1388 bval = (word2 >> L_BLUE_SHIFT) & 0xff;
l_ok linearInterpolatePixelGray(l_uint32 *datas, l_int32 wpls, l_int32 w, l_int32 h, l_float32 x, l_float32 y, l_int32 grayval, l_int32 *pval)
linearInterpolatePixelGray()
#define SET_DATA_BIT(pdata, n)
#define GET_DATA_BYTE(pdata, n)
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_BIT(pdata, n)
void boxDestroy(BOX **pbox)
boxDestroy()
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
l_ok numaGetFValue(NUMA *na, l_int32 index, l_float32 *pval)
numaGetFValue()
NUMA * numaCreate(l_int32 n)
numaCreate()
void numaDestroy(NUMA **pna)
numaDestroy()
l_ok numaSetParameters(NUMA *na, l_float32 startx, l_float32 delx)
numaSetParameters()
l_float32 * numaGetFArray(NUMA *na, l_int32 copyflag)
numaGetFArray()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
PIX * pixCreateRGBImage(PIX *pixr, PIX *pixg, PIX *pixb)
pixCreateRGBImage()
PIX * pixAddBorder(PIX *pixs, l_int32 npix, l_uint32 val)
pixAddBorder()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_ok pixSetBlackOrWhite(PIX *pixs, l_int32 op)
pixSetBlackOrWhite()
PIX * pixClipRectangle(PIX *pixs, BOX *box, BOX **pboxc)
pixClipRectangle()
@ REMOVE_CMAP_BASED_ON_SRC
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixColorizeGray(PIX *pixs, l_uint32 color, l_int32 cmapflag)
pixColorizeGray()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
PIX * pixTranslate(PIX *pixd, PIX *pixs, l_int32 hshift, l_int32 vshift, l_int32 incolor)
pixTranslate()
l_ok pixRasterop(PIX *pixd, l_int32 dx, l_int32 dy, l_int32 dw, l_int32 dh, l_int32 op, PIX *pixs, l_int32 sx, l_int32 sy)
pixRasterop()
PIX * pixHShearLI(PIX *pixs, l_int32 yloc, l_float32 radang, l_int32 incolor)
pixHShearLI()
PIX * pixStretchHorizontalLI(PIX *pixs, l_int32 dir, l_int32 type, l_int32 hmax, l_int32 incolor)
pixStretchHorizontalLI()
PIX * pixStretchHorizontalSampled(PIX *pixs, l_int32 dir, l_int32 type, l_int32 hmax, l_int32 incolor)
pixStretchHorizontalSampled()
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)
pixRandomHarmonicWarp()
PIX * pixQuadraticVShearSampled(PIX *pixs, l_int32 dir, l_int32 vmaxt, l_int32 vmaxb, l_int32 incolor)
pixQuadraticVShearSampled()
PIX * pixSimpleCaptcha(PIX *pixs, l_int32 border, l_int32 nterms, l_uint32 seed, l_uint32 color, l_int32 cmapflag)
pixSimpleCaptcha()
PIX * pixWarpStereoscopic(PIX *pixs, l_int32 zbend, l_int32 zshiftt, l_int32 zshiftb, l_int32 ybendt, l_int32 ybendb, l_int32 redleft)
pixWarpStereoscopic()
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)
applyWarpTransform()
PIX * pixQuadraticVShearLI(PIX *pixs, l_int32 dir, l_int32 vmaxt, l_int32 vmaxb, l_int32 incolor)
pixQuadraticVShearLI()
PIX * pixQuadraticVShear(PIX *pixs, l_int32 dir, l_int32 vmaxt, l_int32 vmaxb, l_int32 operation, l_int32 incolor)
pixQuadraticVShear()
PIX * pixStereoFromPair(PIX *pix1, PIX *pix2, l_float32 rwt, l_float32 gwt, l_float32 bwt)
pixStereoFromPair()
PIX * pixStretchHorizontal(PIX *pixs, l_int32 dir, l_int32 type, l_int32 hmax, l_int32 operation, l_int32 incolor)
pixStretchHorizontal()