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;
126 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
127 if (nterms < 1 || nterms > 4)
128 return (
PIX *)ERROR_PTR(
"nterms must be in {1,2,3,4}", __func__, NULL);
134 nterms, nterms, seed, 255);
193 l_int32 w, h, d, i, j, wpls, wpld, val;
194 l_uint32 *datas, *datad, *lined;
200 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
203 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", __func__, NULL);
211 randa = generateRandomNumberArray(5 * (nx + ny));
214 wpls = pixGetWpl(pixs);
216 wpld = pixGetWpl(pixd);
218 for (i = 0; i < h; i++) {
219 lined = datad + i * wpld;
220 for (j = 0; j < w; j++) {
237 generateRandomNumberArray(l_int32 size)
242 if ((randa = (l_float64 *)LEPT_CALLOC(size,
sizeof(l_float64))) == NULL)
243 return (l_float64 *)ERROR_PTR(
"calloc fail for randa", __func__, NULL);
246 for (i = 0; i < size; i++)
247 randa[i] = 0.5 * (1.0 + (l_float64)rand() / (l_float64)RAND_MAX);
272 l_float64 twopi, x, y, anglex, angley;
275 for (i = 0, x = xp; i < nx; i++) {
276 anglex = xfreq * randa[3 * i + 1] * xp + twopi * randa[3 * i + 2];
277 angley = yfreq * randa[3 * i + 3] * yp + twopi * randa[3 * i + 4];
278 x += xmag * randa[3 * i] * sin(anglex) * sin(angley);
280 for (i = nx, y = yp; i < nx + ny; i++) {
281 angley = yfreq * randa[3 * i + 1] * yp + twopi * randa[3 * i + 2];
282 anglex = xfreq * randa[3 * i + 3] * xp + twopi * randa[3 * i + 4];
283 y += ymag * randa[3 * i] * sin(angley) * sin(anglex);
296 static l_int32 applyWarpTransformLUT(l_float32 xmag, l_float32 ymag,
297 l_float32 xfreq, l_float32 yfreq,
298 l_float64 *randa, l_int32 nx, l_int32 ny,
299 l_int32 xp, l_int32 yp, l_float32 *lut,
300 l_int32 npts, l_float32 *px, l_float32 *py);
301 static l_int32 makeSinLUT(l_int32 npts,
NUMA **pna);
302 static l_float32 getSinFromLUT(l_float32 *tab, l_int32 npts,
326 pixRandomHarmonicWarpLUT(
PIX *pixs,
336 l_int32 w, h, d, i, j, wpls, wpld, val, npts;
337 l_uint32 *datas, *datad, *lined;
345 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
348 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", __func__, NULL);
356 randa = generateRandomNumberArray(5 * (nx + ny));
359 wpls = pixGetWpl(pixs);
361 wpld = pixGetWpl(pixd);
364 makeSinLUT(npts, &na);
366 for (i = 0; i < h; i++) {
367 lined = datad + i * wpld;
368 for (j = 0; j < w; j++) {
369 applyWarpTransformLUT(xmag, ymag, xfreq, yfreq, randa, nx, ny,
370 j, i, lut, npts, &x, &y);
390 applyWarpTransformLUT(l_float32 xmag,
405 l_float64 twopi, x, y, anglex, angley, sanglex, sangley;
408 for (i = 0, x = xp; i < nx; i++) {
409 anglex = xfreq * randa[3 * i + 1] * xp + twopi * randa[3 * i + 2];
410 angley = yfreq * randa[3 * i + 3] * yp + twopi * randa[3 * i + 4];
411 sanglex = getSinFromLUT(lut, npts, anglex);
412 sangley = getSinFromLUT(lut, npts, angley);
413 x += xmag * randa[3 * i] * sanglex * sangley;
415 for (i = nx, y = yp; i < nx + ny; i++) {
416 angley = yfreq * randa[3 * i + 1] * yp + twopi * randa[3 * i + 2];
417 anglex = xfreq * randa[3 * i + 3] * xp + twopi * randa[3 * i + 4];
418 sanglex = getSinFromLUT(lut, npts, anglex);
419 sangley = getSinFromLUT(lut, npts, angley);
420 y += ymag * randa[3 * i] * sangley * sanglex;
430 makeSinLUT(l_int32 npts,
434 l_float32 delx, fval;
438 return ERROR_INT(
"&na not defined", __func__, 1);
441 return ERROR_INT(
"npts < 2", __func__, 1);
445 delx = 3.14159265 / (l_float32)npts;
447 for (i = 0; i < n / 2; i++)
449 for (i = 0; i < n / 2; i++) {
460 getSinFromLUT(l_float32 *tab,
465 l_float32 twopi, invtwopi, findex, diff;
469 invtwopi = 0.1591549;
471 radang += twopi * (1.0 - (l_int32)(-radang * invtwopi));
472 else if (radang > 0.0)
473 radang -= twopi * (l_int32)(radang * invtwopi);
476 findex = (2.0 * (l_float32)npts) * (radang * invtwopi);
477 index = (l_int32)findex;
478 if (index == 2 * npts)
480 diff = findex - index;
481 return (1.0 - diff) * tab[index] + diff * tab[index + 1];
588 l_int32 w, h, zshift;
590 BOX *boxleft, *boxright;
591 PIX *pix1, *pix2, *pix3, *pix4, *pixr, *pixg, *pixb;
592 PIX *pixv1, *pixv2, *pixv3, *pixv4;
597 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
606 boxright =
boxCreate(w / 2, 0, w - w / 2, h);
607 if (ybendt != 0 || ybendb != 0) {
666 if (zshiftt == 0 && zshiftb == 0) {
668 }
else if (zshiftt == zshiftb) {
671 angle = (l_float32)(zshiftb - zshiftt) /
672 L_MAX(1.0, (l_float32)pixGetHeight(pixrs));
673 zshift = (zshiftt + zshiftb) / 2;
735 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
736 d = pixGetDepth(pixs);
737 if (d != 1 && d != 8 && d != 32)
738 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", __func__, NULL);
740 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
742 return (
PIX *)ERROR_PTR(
"invalid type", __func__, NULL);
744 return (
PIX *)ERROR_PTR(
"invalid operation", __func__, NULL);
746 return (
PIX *)ERROR_PTR(
"invalid incolor", __func__, NULL);
748 L_WARNING(
"Using sampling for 1 bpp\n", __func__);
781 l_int32 i, j, jd, w, wm, h, d, wpls, wpld, val;
782 l_uint32 *datas, *datad, *lines, *lined;
786 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
788 if (d != 1 && d != 8 && d != 32)
789 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", __func__, NULL);
791 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
793 return (
PIX *)ERROR_PTR(
"invalid type", __func__, NULL);
795 return (
PIX *)ERROR_PTR(
"invalid incolor", __func__, NULL);
801 wpls = pixGetWpl(pixs);
802 wpld = pixGetWpl(pixd);
804 for (jd = 0; jd < w; jd++) {
807 j = jd - (hmax * (wm - jd)) / wm;
809 j = jd - (hmax * (wm - jd) * (wm - jd)) / (wm * wm);
812 j = jd - (hmax * jd) / wm;
814 j = jd - (hmax * jd * jd) / (wm * wm);
816 if (j < 0 || j > w - 1)
continue;
821 for (i = 0; i < h; i++) {
822 lines = datas + i * wpls;
823 lined = datad + i * wpld;
830 for (i = 0; i < h; i++) {
831 lines = datas + i * wpls;
832 lined = datad + i * wpld;
838 for (i = 0; i < h; i++) {
839 lines = datas + i * wpls;
840 lined = datad + i * wpld;
841 lined[jd] = lines[j];
845 L_ERROR(
"invalid depth: %d\n", __func__, d);
877 l_int32 i, j, jd, jp, jf, w, wm, h, d, wpls, wpld, val, rval, gval, bval;
878 l_uint32 word0, word1;
879 l_uint32 *datas, *datad, *lines, *lined;
883 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
885 if (d != 8 && d != 32)
886 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", __func__, NULL);
888 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
890 return (
PIX *)ERROR_PTR(
"invalid type", __func__, NULL);
892 return (
PIX *)ERROR_PTR(
"invalid incolor", __func__, NULL);
899 wpls = pixGetWpl(pixs);
900 wpld = pixGetWpl(pixd);
902 for (jd = 0; jd < w; jd++) {
905 j = 64 * jd - 64 * (hmax * (wm - jd)) / wm;
907 j = 64 * jd - 64 * (hmax * (wm - jd) * (wm - jd)) / (wm * wm);
910 j = 64 * jd - 64 * (hmax * jd) / wm;
912 j = 64 * jd - 64 * (hmax * jd * jd) / (wm * wm);
916 if (jp < 0 || jp > wm)
continue;
922 for (i = 0; i < h; i++) {
923 lines = datas + i * wpls;
924 lined = datad + i * wpld;
930 for (i = 0; i < h; i++) {
931 lines = datas + i * wpls;
932 lined = datad + i * wpld;
940 for (i = 0; i < h; i++) {
941 lines = datas + i * wpls;
942 lined = datad + i * wpld;
943 word0 = *(lines + jp);
944 word1 = *(lines + jp + 1);
945 rval = ((63 - jf) * ((word0 >> L_RED_SHIFT) & 0xff) +
946 jf * ((word1 >> L_RED_SHIFT) & 0xff) + 31) / 63;
947 gval = ((63 - jf) * ((word0 >> L_GREEN_SHIFT) & 0xff) +
948 jf * ((word1 >> L_GREEN_SHIFT) & 0xff) + 31) / 63;
949 bval = ((63 - jf) * ((word0 >> L_BLUE_SHIFT) & 0xff) +
950 jf * ((word1 >> L_BLUE_SHIFT) & 0xff) + 31) / 63;
954 for (i = 0; i < h; i++) {
955 lines = datas + i * wpls;
956 lined = datad + i * wpld;
957 lined[jd] = lines[jp];
962 L_ERROR(
"invalid depth: %d\n", __func__, d);
1015 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1017 if (d != 1 && d != 8 && d != 32)
1018 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", __func__, NULL);
1020 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
1022 return (
PIX *)ERROR_PTR(
"invalid operation", __func__, NULL);
1024 return (
PIX *)ERROR_PTR(
"invalid incolor", __func__, NULL);
1026 if (vmaxt == 0 && vmaxb == 0)
1030 L_WARNING(
"no interpolation for 1 bpp; using sampling\n", __func__);
1063 l_int32 i, j, id, w, h, d, wm, hm, wpls, wpld, val;
1064 l_uint32 *datas, *datad, *lines, *lined;
1065 l_float32 delrowt, delrowb, denom1, denom2, dely;
1069 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1071 if (d != 1 && d != 8 && d != 32)
1072 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", __func__, NULL);
1074 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
1076 return (
PIX *)ERROR_PTR(
"invalid incolor", __func__, NULL);
1078 if (vmaxt == 0 && vmaxb == 0)
1085 wpls = pixGetWpl(pixs);
1086 wpld = pixGetWpl(pixd);
1089 denom1 = 1. / (l_float32)h;
1090 denom2 = 1. / (l_float32)(wm * wm);
1091 for (j = 0; j < w; j++) {
1093 delrowt = (l_float32)(vmaxt * (wm - j) * (wm - j)) * denom2;
1094 delrowb = (l_float32)(vmaxb * (wm - j) * (wm - j)) * denom2;
1096 delrowt = (l_float32)(vmaxt * j * j) * denom2;
1097 delrowb = (l_float32)(vmaxb * j * j) * denom2;
1102 for (
id = 0;
id < h;
id++) {
1103 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1104 i =
id - (l_int32)(dely + 0.5);
1105 if (i < 0 || i > hm)
continue;
1106 lines = datas + i * wpls;
1107 lined = datad +
id * wpld;
1114 for (
id = 0;
id < h;
id++) {
1115 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1116 i =
id - (l_int32)(dely + 0.5);
1117 if (i < 0 || i > hm)
continue;
1118 lines = datas + i * wpls;
1119 lined = datad +
id * wpld;
1125 for (
id = 0;
id < h;
id++) {
1126 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1127 i =
id - (l_int32)(dely + 0.5);
1128 if (i < 0 || i > hm)
continue;
1129 lines = datas + i * wpls;
1130 lined = datad +
id * wpld;
1131 lined[j] = lines[j];
1135 L_ERROR(
"invalid depth: %d\n", __func__, d);
1167 l_int32 i, j, id, yp, yf, w, h, d, wm, hm, wpls, wpld;
1168 l_int32 val, rval, gval, bval;
1169 l_uint32 word0, word1;
1170 l_uint32 *datas, *datad, *lines, *lined;
1171 l_float32 delrowt, delrowb, denom1, denom2, dely;
1176 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1179 return (
PIX *)ERROR_PTR(
"pixs is 1 bpp", __func__, NULL);
1180 cmap = pixGetColormap(pixs);
1181 if (d != 8 && d != 32 && !cmap)
1182 return (
PIX *)ERROR_PTR(
"pixs not 8, 32 bpp, or cmap", __func__, NULL);
1184 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
1186 return (
PIX *)ERROR_PTR(
"invalid incolor", __func__, NULL);
1188 if (vmaxt == 0 && vmaxb == 0)
1196 d = pixGetDepth(pix);
1197 if (d != 8 && d != 32) {
1199 return (
PIX *)ERROR_PTR(
"invalid depth", __func__, NULL);
1207 wpls = pixGetWpl(pix);
1208 wpld = pixGetWpl(pixd);
1211 denom1 = 1.0 / (l_float32)h;
1212 denom2 = 1.0 / (l_float32)(wm * wm);
1213 for (j = 0; j < w; j++) {
1215 delrowt = (l_float32)(vmaxt * (wm - j) * (wm - j)) * denom2;
1216 delrowb = (l_float32)(vmaxb * (wm - j) * (wm - j)) * denom2;
1218 delrowt = (l_float32)(vmaxt * j * j) * denom2;
1219 delrowb = (l_float32)(vmaxb * j * j) * denom2;
1224 for (
id = 0;
id < h;
id++) {
1225 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1226 i = 64 *
id - (l_int32)(64.0 * dely);
1229 if (yp < 0 || yp > hm)
continue;
1230 lines = datas + yp * wpls;
1231 lined = datad +
id * wpld;
1242 for (
id = 0;
id < h;
id++) {
1243 dely = (delrowt * (hm - id) + delrowb *
id) * denom1;
1244 i = 64 *
id - (l_int32)(64.0 * dely);
1247 if (yp < 0 || yp > hm)
continue;
1248 lines = datas + yp * wpls;
1249 lined = datad +
id * wpld;
1251 word0 = *(lines + j);
1252 word1 = *(lines + wpls + j);
1253 rval = ((63 - yf) * ((word0 >> L_RED_SHIFT) & 0xff) +
1254 yf * ((word1 >> L_RED_SHIFT) & 0xff) + 31) / 63;
1255 gval = ((63 - yf) * ((word0 >> L_GREEN_SHIFT) & 0xff) +
1256 yf * ((word1 >> L_GREEN_SHIFT) & 0xff) + 31) / 63;
1257 bval = ((63 - yf) * ((word0 >> L_BLUE_SHIFT) & 0xff) +
1258 yf * ((word1 >> L_BLUE_SHIFT) & 0xff) + 31) / 63;
1261 lined[j] = lines[j];
1266 L_ERROR(
"invalid depth: %d\n", __func__, d);
1318 l_int32 i, j, w, h, wpl1, wpl2, rval, gval, bval;
1319 l_uint32 word1, word2;
1320 l_uint32 *data1, *data2, *datad, *line1, *line2, *lined;
1325 return (
PIX *)ERROR_PTR(
"pix1, pix2 not both defined", __func__, NULL);
1326 if (pixGetDepth(pix1) != 32 || pixGetDepth(pix2) != 32)
1327 return (
PIX *)ERROR_PTR(
"pix1, pix2 not both 32 bpp", __func__, NULL);
1331 if (rwt == 0.0 && gwt == 0.0 && bwt == 0.0) {
1332 rwt = DefaultRedWeight;
1333 gwt = DefaultGreenWeight;
1334 bwt = DefaultBlueWeight;
1336 sum = rwt + gwt + bwt;
1337 if (L_ABS(sum - 1.0) > 0.0001) {
1338 L_WARNING(
"weights don't sum to 1; maintaining ratios\n", __func__);
1349 wpl1 = pixGetWpl(pix1);
1350 wpl2 = pixGetWpl(pix2);
1351 for (i = 0; i < h; i++) {
1352 line1 = data1 + i * wpl1;
1353 line2 = data2 + i * wpl2;
1354 lined = datad + i * wpl1;
1355 for (j = 0; j < w; j++) {
1356 word1 = *(line1 + j);
1357 word2 = *(line2 + j);
1358 rval = (l_int32)(rwt * ((word1 >> L_RED_SHIFT) & 0xff) +
1359 gwt * ((word1 >> L_GREEN_SHIFT) & 0xff) +
1360 bwt * ((word1 >> L_BLUE_SHIFT) & 0xff) + 0.5);
1361 gval = (word2 >> L_GREEN_SHIFT) & 0xff;
1362 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()