148 #include <config_auto.h> 151 #include "allheaders.h" 153 static l_int32 blendComponents(l_int32 a, l_int32 b, l_float32 fract);
154 static l_int32 blendHardLightComponents(l_int32 a, l_int32 b, l_float32 fract);
182 l_int32 w1, h1, d1, d2;
184 PIX *pixc, *pixt, *pixd;
186 PROCNAME(
"pixBlend");
189 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, NULL);
191 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, NULL);
194 d1 = pixGetDepth(pixs1);
195 d2 = pixGetDepth(pixs2);
196 if (d1 == 1 && d2 > 1)
197 return (
PIX *)ERROR_PTR(
"mixing gray or color with 1 bpp",
202 d2 = pixGetDepth(pixt);
215 L_WARNING(
"box doesn't overlap pix\n", procName);
225 }
else if (d2 == 8) {
273 l_int32 i, j, d, wc, hc, w, h, wplc;
274 l_int32 val, rval, gval, bval;
276 l_uint32 *linec, *datac;
277 PIX *pixc, *pix1, *pix2;
279 PROCNAME(
"pixBlendMask");
282 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, NULL);
284 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, NULL);
285 if (pixGetDepth(pixs1) == 1)
286 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, NULL);
287 if (pixGetDepth(pixs2) != 1)
288 return (
PIX *)ERROR_PTR(
"pixs2 not 1 bpp", procName, NULL);
289 if (pixd == pixs1 && pixGetColormap(pixs1))
290 return (
PIX *)ERROR_PTR(
"inplace; pixs1 has colormap", procName, NULL);
291 if (pixd && (pixd != pixs1))
292 return (
PIX *)ERROR_PTR(
"pixd must be NULL or pixs1", procName, NULL);
293 if (fract < 0.0 || fract > 1.0) {
294 L_WARNING(
"fract must be in [0.0, 1.0]; setting to 0.5\n", procName);
299 L_WARNING(
"invalid blend type; setting to L_BLEND_WITH_INVERSE\n",
311 if (pixGetDepth(pix1) < 8)
322 wc = pixGetWidth(pixc);
323 hc = pixGetHeight(pixc);
325 wplc = pixGetWpl(pixc);
338 for (i = 0; i < hc; i++) {
339 if (i + y < 0 || i + y >= h)
continue;
340 linec = datac + i * wplc;
341 for (j = 0; j < wc; j++) {
342 if (j + x < 0 || j + x >= w)
continue;
349 val = (l_int32)(pixval + fract * (255 - 2 * pixval));
355 rval = (l_int32)(rval + fract * (255 - 2 * rval));
356 gval = (l_int32)(gval + fract * (255 - 2 * gval));
357 bval = (l_int32)(bval + fract * (255 - 2 * bval));
362 L_WARNING(
"d neither 8 nor 32 bpp; no blend\n",
374 for (i = 0; i < hc; i++) {
375 if (i + y < 0 || i + y >= h)
continue;
376 linec = datac + i * wplc;
377 for (j = 0; j < wc; j++) {
378 if (j + x < 0 || j + x >= w)
continue;
385 val = (l_int32)(pixval + fract * (255 - pixval));
391 rval = (l_int32)(rval + fract * (255 - rval));
392 gval = (l_int32)(gval + fract * (255 - gval));
393 bval = (l_int32)(bval + fract * (255 - bval));
398 L_WARNING(
"d neither 8 nor 32 bpp; no blend\n",
410 for (i = 0; i < hc; i++) {
411 if (i + y < 0 || i + y >= h)
continue;
412 linec = datac + i * wplc;
413 for (j = 0; j < wc; j++) {
414 if (j + x < 0 || j + x >= w)
continue;
421 val = (l_int32)((1. - fract) * pixval);
427 rval = (l_int32)((1. - fract) * rval);
428 gval = (l_int32)((1. - fract) * gval);
429 bval = (l_int32)((1. - fract) * bval);
434 L_WARNING(
"d neither 8 nor 32 bpp; no blend\n",
442 L_WARNING(
"invalid binary mask blend type\n", procName);
504 l_int32 i, j, d, wc, hc, w, h, wplc, wpld, delta;
505 l_int32 ival, irval, igval, ibval, cval, dval;
507 l_uint32 *linec, *lined, *datac, *datad;
508 PIX *pixc, *pix1, *pix2;
510 PROCNAME(
"pixBlendGray");
513 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
515 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
516 if (pixGetDepth(pixs1) == 1)
517 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, pixd);
518 if (pixd == pixs1 && pixGetColormap(pixs1))
519 return (
PIX *)ERROR_PTR(
"can't do in-place with cmap", procName, pixd);
520 if (pixd && (pixd != pixs1))
521 return (
PIX *)ERROR_PTR(
"pixd must be NULL or pixs1", procName, pixd);
522 if (fract < 0.0 || fract > 1.0) {
523 L_WARNING(
"fract must be in [0.0, 1.0]; setting to 0.5\n", procName);
527 L_WARNING(
"invalid blend type; setting to L_BLEND_GRAY\n", procName);
538 if (pixGetDepth(pix1) < 8)
548 wpld = pixGetWpl(pixd);
553 wplc = pixGetWpl(pixc);
562 for (i = 0; i < hc; i++) {
563 if (i + y < 0 || i + y >= h)
continue;
564 linec = datac + i * wplc;
565 lined = datad + (i + y) * wpld;
569 for (j = 0; j < wc; j++) {
570 if (j + x < 0 || j + x >= w)
continue;
572 if (transparent == 0 || cval != transpix) {
574 ival = (l_int32)((1. - fract) * dval + fract * cval);
580 for (j = 0; j < wc; j++) {
581 if (j + x < 0 || j + x >= w)
continue;
583 if (transparent == 0 || cval != transpix) {
584 val32 = *(lined + j + x);
586 irval = (l_int32)((1. - fract) * irval + fract * cval);
587 igval = (l_int32)((1. - fract) * igval + fract * cval);
588 ibval = (l_int32)((1. - fract) * ibval + fract * cval);
590 *(lined + j + x) = val32;
599 for (i = 0; i < hc; i++) {
600 if (i + y < 0 || i + y >= h)
continue;
601 linec = datac + i * wplc;
602 lined = datad + (i + y) * wpld;
616 for (j = 0; j < wc; j++) {
617 if (j + x < 0 || j + x >= w)
continue;
619 if (transparent == 0 || cval != transpix) {
621 delta = (128 - ival) * (255 - cval) / 256;
622 ival += (l_int32)(fract * delta + 0.5);
629 for (j = 0; j < wc; j++) {
630 if (j + x < 0 || j + x >= w)
continue;
632 if (transparent == 0 || cval != transpix) {
633 val32 = *(lined + j + x);
635 delta = (128 - irval) * (255 - cval) / 256;
636 irval += (l_int32)(fract * delta + 0.5);
637 delta = (128 - igval) * (255 - cval) / 256;
638 igval += (l_int32)(fract * delta + 0.5);
639 delta = (128 - ibval) * (255 - cval) / 256;
640 ibval += (l_int32)(fract * delta + 0.5);
642 *(lined + j + x) = val32;
701 l_int32 i, j, d, wc, hc, w, h, wplc, wpld;
702 l_int32 irval, igval, ibval, cval, dval;
705 l_uint32 *linec, *lined, *datac, *datad;
706 PIX *pixc, *pix1, *pix2;
708 PROCNAME(
"pixBlendGrayInverse");
711 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
713 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
714 if (pixGetDepth(pixs1) == 1)
715 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, pixd);
716 if (pixd == pixs1 && pixGetColormap(pixs1))
717 return (
PIX *)ERROR_PTR(
"can't do in-place with cmap", procName, pixd);
718 if (pixd && (pixd != pixs1))
719 return (
PIX *)ERROR_PTR(
"pixd must be NULL or pixs1", procName, pixd);
720 if (fract < 0.0 || fract > 1.0) {
721 L_WARNING(
"fract must be in [0.0, 1.0]; setting to 0.5\n", procName);
732 if (pixGetDepth(pix1) < 8)
742 wpld = pixGetWpl(pixd);
747 wplc = pixGetWpl(pixc);
750 for (i = 0; i < hc; i++) {
751 if (i + y < 0 || i + y >= h)
continue;
752 linec = datac + i * wplc;
753 lined = datad + (i + y) * wpld;
757 for (j = 0; j < wc; j++) {
758 if (j + x < 0 || j + x >= w)
continue;
761 a = (1.0 - fract) * dval + fract * (255.0 - dval);
762 dval = (l_int32)(cval * dval / 255.0 +
763 a * (255.0 - cval) / 255.0);
768 for (j = 0; j < wc; j++) {
769 if (j + x < 0 || j + x >= w)
continue;
771 val32 = *(lined + j + x);
773 a = (1.0 - fract) * irval + fract * (255.0 - irval);
774 irval = (l_int32)(cval * irval / 255.0 +
775 a * (255.0 - cval) / 255.0);
776 a = (1.0 - fract) * igval + fract * (255.0 - igval);
777 igval = (l_int32)(cval * igval / 255.0 +
778 a * (255.0 - cval) / 255.0);
779 a = (1.0 - fract) * ibval + fract * (255.0 - ibval);
780 ibval = (l_int32)(cval * ibval / 255.0 +
781 a * (255.0 - cval) / 255.0);
783 *(lined + j + x) = val32;
837 l_int32 i, j, wc, hc, w, h, wplc, wpld;
838 l_int32 rval, gval, bval, rcval, gcval, bcval;
839 l_uint32 cval32, val32;
840 l_uint32 *linec, *lined, *datac, *datad;
843 PROCNAME(
"pixBlendColor");
846 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, NULL);
848 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, NULL);
849 if (pixGetDepth(pixs1) == 1)
850 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, NULL);
851 if (pixd == pixs1 && pixGetDepth(pixs1) != 32)
852 return (
PIX *)ERROR_PTR(
"inplace; pixs1 not 32 bpp", procName, NULL);
853 if (pixd && (pixd != pixs1))
854 return (
PIX *)ERROR_PTR(
"pixd must be NULL or pixs1", procName, NULL);
855 if (fract < 0.0 || fract > 1.0) {
856 L_WARNING(
"fract must be in [0.0, 1.0]; setting to 0.5\n", procName);
868 wpld = pixGetWpl(pixd);
873 wplc = pixGetWpl(pixc);
876 for (i = 0; i < hc; i++) {
883 if (i + y < 0 || i + y >= h)
continue;
884 linec = datac + i * wplc;
885 lined = datad + (i + y) * wpld;
886 for (j = 0; j < wc; j++) {
887 if (j + x < 0 || j + x >= w)
continue;
888 cval32 = *(linec + j);
889 if (transparent == 0 ||
890 ((cval32 & 0xffffff00) != (transpix & 0xffffff00))) {
891 val32 = *(lined + j + x);
894 rval = (l_int32)((1. - fract) * rval + fract * rcval);
895 gval = (l_int32)((1. - fract) * gval + fract * gcval);
896 bval = (l_int32)((1. - fract) * bval + fract * bcval);
898 *(lined + j + x) = val32;
946 pixBlendColorByChannel(
PIX *pixd,
957 l_int32 i, j, wc, hc, w, h, wplc, wpld;
958 l_int32 rval, gval, bval, rcval, gcval, bcval;
959 l_uint32 cval32, val32;
960 l_uint32 *linec, *lined, *datac, *datad;
963 PROCNAME(
"pixBlendColorByChannel");
966 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
968 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
969 if (pixGetDepth(pixs1) == 1)
970 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, pixd);
971 if (pixd == pixs1 && pixGetDepth(pixs1) != 32)
972 return (
PIX *)ERROR_PTR(
"inplace; pixs1 not 32 bpp", procName, pixd);
973 if (pixd && (pixd != pixs1))
974 return (
PIX *)ERROR_PTR(
"pixd must be NULL or pixs1", procName, pixd);
984 wpld = pixGetWpl(pixd);
989 wplc = pixGetWpl(pixc);
992 for (i = 0; i < hc; i++) {
993 if (i + y < 0 || i + y >= h)
continue;
994 linec = datac + i * wplc;
995 lined = datad + (i + y) * wpld;
996 for (j = 0; j < wc; j++) {
997 if (j + x < 0 || j + x >= w)
continue;
998 cval32 = *(linec + j);
999 if (transparent == 0 ||
1000 ((cval32 & 0xffffff00) != (transpix & 0xffffff00))) {
1001 val32 = *(lined + j + x);
1004 rval = blendComponents(rval, rcval, rfract);
1005 gval = blendComponents(gval, gcval, gfract);
1006 bval = blendComponents(bval, bcval, bfract);
1008 *(lined + j + x) = val32;
1019 blendComponents(l_int32 a,
1024 return ((a < b) ? a : b);
1026 return ((a > b) ? a : b);
1027 return (l_int32)((1. - fract) * a + fract * b);
1084 l_int32 i, j, d, wc, hc, w, h, wplc, wpld, delta, overlap;
1085 l_int32 rval, gval, bval, cval, dval, mval, median, pivot;
1087 l_uint32 *linec, *lined, *datac, *datad;
1088 l_float32 fmedian, factor;
1090 PIX *pixc, *pix1, *pix2;
1092 PROCNAME(
"pixBlendGrayAdapt");
1095 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1097 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1098 if (pixGetDepth(pixs1) == 1)
1099 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, pixd);
1100 if (pixd == pixs1 && pixGetColormap(pixs1))
1101 return (
PIX *)ERROR_PTR(
"can't do in-place with cmap", procName, pixd);
1102 if (pixd && (pixd != pixs1))
1103 return (
PIX *)ERROR_PTR(
"pixd must be NULL or pixs1", procName, pixd);
1104 if (fract < 0.0 || fract > 1.0) {
1105 L_WARNING(
"fract must be in [0.0, 1.0]; setting to 0.5\n", procName);
1108 if (shift == -1) shift = 64;
1109 if (shift < 0 || shift > 127) {
1110 L_WARNING(
"invalid shift; setting to 64\n", procName);
1123 return (
PIX *)ERROR_PTR(
"no image overlap", procName, pixd);
1133 if (pixGetDepth(pix1) < 8)
1146 median = (l_int32)(fmedian + 0.5);
1148 pivot = median + shift;
1150 pivot = median - shift;
1156 d = pixGetDepth(pixd);
1157 wpld = pixGetWpl(pixd);
1161 wplc = pixGetWpl(pixc);
1162 for (i = 0; i < hc; i++) {
1163 if (i + y < 0 || i + y >= h)
continue;
1164 linec = datac + i * wplc;
1165 lined = datad + (i + y) * wpld;
1180 for (j = 0; j < wc; j++) {
1181 if (j + x < 0 || j + x >= w)
continue;
1184 delta = (pivot - dval) * (255 - cval) / 256;
1185 dval += (l_int32)(fract * delta + 0.5);
1203 for (j = 0; j < wc; j++) {
1204 if (j + x < 0 || j + x >= w)
continue;
1206 val32 = *(lined + j + x);
1208 mval = L_MAX(rval, gval);
1209 mval = L_MAX(mval, bval);
1210 mval = L_MAX(mval, 1);
1211 delta = (pivot - mval) * (255 - cval) / 256;
1212 factor = fract * delta / mval;
1213 rval += (l_int32)(factor * rval + 0.5);
1214 gval += (l_int32)(factor * gval + 0.5);
1215 bval += (l_int32)(factor * bval + 0.5);
1217 *(lined + j + x) = val32;
1255 l_int32 i, j, w, h, d, wb, hb, db, wd, hd, wplb, wpld;
1256 l_int32 valb, vald, nvald, rval, gval, bval, nrval, ngval, nbval;
1257 l_float32 nfactor, fract;
1258 l_uint32 val32, nval32;
1259 l_uint32 *lined, *datad, *lineb, *datab;
1262 PROCNAME(
"pixFadeWithGray");
1265 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1267 return (
PIX *)ERROR_PTR(
"pixb not defined", procName, NULL);
1268 if (pixGetDepth(
pixs) == 1)
1269 return (
PIX *)ERROR_PTR(
"pixs is 1 bpp", procName, NULL);
1272 return (
PIX *)ERROR_PTR(
"pixb not 8 bpp", procName, NULL);
1273 if (factor < 0.0 || factor > 255.0)
1274 return (
PIX *)ERROR_PTR(
"factor not in [0.0...255.0]", procName, NULL);
1276 return (
PIX *)ERROR_PTR(
"invalid fade type", procName, NULL);
1284 wpld = pixGetWpl(pixd);
1286 wplb = pixGetWpl(pixb);
1293 nfactor = factor / 255.;
1294 for (i = 0; i < h; i++) {
1295 lineb = datab + i * wplb;
1296 lined = datad + i * wpld;
1297 for (j = 0; j < w; j++) {
1299 fract = nfactor * (l_float32)valb;
1300 fract = L_MIN(fract, 1.0);
1304 nvald = vald + (l_int32)(fract * (255. - (l_float32)vald));
1306 nvald = vald - (l_int32)(fract * (l_float32)vald);
1312 nrval = rval + (l_int32)(fract * (255. - (l_float32)rval));
1313 ngval = gval + (l_int32)(fract * (255. - (l_float32)gval));
1314 nbval = bval + (l_int32)(fract * (255. - (l_float32)bval));
1316 nrval = rval - (l_int32)(fract * (l_float32)rval);
1317 ngval = gval - (l_int32)(fract * (l_float32)gval);
1318 nbval = bval - (l_int32)(fract * (l_float32)bval);
1366 pixBlendHardLight(
PIX *pixd,
1373 l_int32 i, j, w, h, d, wc, hc, dc, wplc, wpld;
1374 l_int32 cval, dval, rcval, gcval, bcval, rdval, gdval, bdval;
1375 l_uint32 cval32, dval32;
1376 l_uint32 *linec, *lined, *datac, *datad;
1379 PROCNAME(
"pixBlendHardLight");
1382 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1384 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1388 return (
PIX *)ERROR_PTR(
"pixs1 is 1 bpp", procName, pixd);
1389 if (dc != 8 && dc != 32)
1390 return (
PIX *)ERROR_PTR(
"pixs2 not 8 or 32 bpp", procName, pixd);
1391 if (pixd && (pixd != pixs1))
1392 return (
PIX *)ERROR_PTR(
"inplace and pixd != pixs1", procName, pixd);
1393 if (pixd == pixs1 && pixGetColormap(pixs1))
1394 return (
PIX *)ERROR_PTR(
"inplace and pixs1 cmapped", procName, pixd);
1395 if (pixd && d != 8 && d != 32)
1396 return (
PIX *)ERROR_PTR(
"inplace and not 8 or 32 bpp", procName, pixd);
1398 if (fract < 0.0 || fract > 1.0) {
1399 L_WARNING(
"fract must be in [0.0, 1.0]; setting to 0.5\n", procName);
1405 dc = pixGetDepth(pixc);
1413 if (pixGetColormap(pixs1)) {
1426 if (pixGetColormap(pixs1))
1430 d = pixGetDepth(pixd);
1433 if (!(d == 8 && dc == 8) &&
1434 !(d == 32 && dc == 8) &&
1435 !(d == 32 && dc == 32)) {
1437 return (
PIX *)ERROR_PTR(
"bad! -- invalid depth combo!", procName, pixd);
1440 wpld = pixGetWpl(pixd);
1443 wplc = pixGetWpl(pixc);
1444 for (i = 0; i < hc; i++) {
1445 if (i + y < 0 || i + y >= h)
continue;
1446 linec = datac + i * wplc;
1447 lined = datad + (i + y) * wpld;
1448 for (j = 0; j < wc; j++) {
1449 if (j + x < 0 || j + x >= w)
continue;
1450 if (d == 8 && dc == 8) {
1453 dval = blendHardLightComponents(dval, cval, fract);
1455 }
else if (d == 32 && dc == 8) {
1456 dval32 = *(lined + x + j);
1459 rdval = blendHardLightComponents(rdval, cval, fract);
1460 gdval = blendHardLightComponents(gdval, cval, fract);
1461 bdval = blendHardLightComponents(bdval, cval, fract);
1463 *(lined + x + j) = dval32;
1464 }
else if (d == 32 && dc == 32) {
1465 dval32 = *(lined + x + j);
1467 cval32 = *(linec + j);
1469 rdval = blendHardLightComponents(rdval, rcval, fract);
1470 gdval = blendHardLightComponents(gdval, gcval, fract);
1471 bdval = blendHardLightComponents(bdval, bcval, fract);
1473 *(lined + x + j) = dval32;
1530 static l_int32 blendHardLightComponents(l_int32 a,
1535 b = 0x80 - (l_int32)(fract * (0x80 - b));
1536 return (a * b) >> 7;
1538 b = 0x80 + (l_int32)(fract * (b - 0x80));
1539 return 0xff - (((0xff - b) * (0xff - a)) >> 7);
1581 l_int32 rval, gval, bval;
1582 l_int32 i, j, w, h, d, ncb, wb, hb, wpls;
1583 l_int32 index, val, nadded;
1586 l_uint32 *lines, *datas;
1587 PIXCMAP *cmaps, *cmapb, *cmapsc;
1589 PROCNAME(
"pixBlendCmap");
1592 return ERROR_INT(
"pixs not defined", procName, 1);
1594 return ERROR_INT(
"pixb not defined", procName, 1);
1595 if ((cmaps = pixGetColormap(
pixs)) == NULL)
1596 return ERROR_INT(
"no colormap in pixs", procName, 1);
1597 if ((cmapb = pixGetColormap(pixb)) == NULL)
1598 return ERROR_INT(
"no colormap in pixb", procName, 1);
1602 if (d != 2 && d != 4 && d != 8)
1603 return ERROR_INT(
"depth not in {2,4,8}", procName, 1);
1612 for (i = 0, nadded = 0; i < ncb; i++) {
1617 return ERROR_INT(
"not enough room in cmaps", procName, 1);
1635 wpls = pixGetWpl(
pixs);
1637 for (i = 0; i < hb; i++) {
1638 if (i + y < 0 || i + y >= h)
continue;
1639 lines = datas + (y + i) * wpls;
1640 for (j = 0; j < wb; j++) {
1641 if (j + x < 0 || j + x >= w)
continue;
1645 if (val == sindex) {
1652 if (val == sindex) {
1659 if (val == sindex) {
1665 return ERROR_INT(
"depth not in {2,4,8}", procName, 1);
1718 l_int32 w1, h1, d1, w2, h2, d2, spp, wg, hg, wmin, hmin, wpld, wpls, wplg;
1719 l_int32 i, j, val, dval, sval;
1720 l_int32 drval, dgval, dbval, srval, sgval, sbval;
1721 l_uint32 dval32, sval32;
1722 l_uint32 *datad, *datas, *datag, *lined, *lines, *lineg;
1724 PIX *pixr1, *pixr2, *pix1, *pix2, *pixg2, *pixd;
1726 PROCNAME(
"pixBlendWithGrayMask");
1729 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, NULL);
1731 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, NULL);
1734 if (d1 == 1 || d2 == 1)
1735 return (
PIX *)ERROR_PTR(
"pixs1 or pixs2 is 1 bpp", procName, NULL);
1737 if (pixGetDepth(pixg) != 8)
1738 return (
PIX *)ERROR_PTR(
"pixg not 8 bpp", procName, NULL);
1740 wmin = L_MIN(w2, wg);
1741 hmin = L_MIN(h2, hg);
1744 spp = pixGetSpp(pixs2);
1745 if (d2 != 32 || spp != 4)
1746 return (
PIX *)ERROR_PTR(
"no alpha; pixs2 not rgba", procName, NULL);
1757 d1 = pixGetDepth(pixr1);
1758 d2 = pixGetDepth(pixr2);
1765 }
else if (d2 == 32) {
1776 d1 = pixGetDepth(pix1);
1777 d2 = pixGetDepth(pix2);
1778 if (d1 != d2 || (d1 != 8 && d1 != 32)) {
1782 return (
PIX *)ERROR_PTR(
"depths not regularized! bad!", procName, NULL);
1799 wpld = pixGetWpl(pixd);
1800 wpls = pixGetWpl(pix2);
1801 wplg = pixGetWpl(pixg2);
1802 for (i = 0; i < hmin; i++) {
1803 if (i + y < 0 || i + y >= h1)
continue;
1804 lined = datad + (i + y) * wpld;
1805 lines = datas + i * wpls;
1806 lineg = datag + i * wplg;
1807 for (j = 0; j < wmin; j++) {
1808 if (j + x < 0 || j + x >= w1)
continue;
1810 if (val == 0)
continue;
1811 fract = (l_float32)val / 255.;
1815 dval = (l_int32)((1.0 - fract) * dval + fract * sval);
1818 dval32 = *(lined + j + x);
1819 sval32 = *(lines + j);
1822 drval = (l_int32)((1.0 - fract) * drval + fract * srval);
1823 dgval = (l_int32)((1.0 - fract) * dgval + fract * sgval);
1824 dbval = (l_int32)((1.0 - fract) * dbval + fract * sbval);
1826 *(lined + j + x) = dval32;
1876 PIX *pixt, *pixc, *pixr, *pixg;
1878 PROCNAME(
"pixBlendBackgroundToColor");
1881 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
1882 if (pixGetDepth(
pixs) != 32)
1883 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, pixd);
1884 if (pixd && (pixd !=
pixs))
1885 return (
PIX *)ERROR_PTR(
"pixd neither null nor pixs", procName, pixd);
1951 l_int32 i, j, bx, by, w, h, wpl;
1952 l_int32 red, green, blue, rval, gval, bval, nrval, ngval, nbval;
1953 l_float32 frval, fgval, fbval;
1954 l_uint32 *data, *line;
1957 PROCNAME(
"pixMultiplyByColor");
1960 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
1961 if (pixGetDepth(
pixs) != 32)
1962 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, pixd);
1963 if (pixd && (pixd !=
pixs))
1964 return (
PIX *)ERROR_PTR(
"pixd neither null nor pixs", procName, pixd);
1977 frval = (1. / 255.) * red;
1978 fgval = (1. / 255.) * green;
1979 fbval = (1. / 255.) * blue;
1981 wpl = pixGetWpl(pixt);
1983 for (i = 0; i < h; i++) {
1984 line = data + i * wpl;
1985 for (j = 0; j < w; j++) {
1987 nrval = (l_int32)(frval * rval + 0.5);
1988 ngval = (l_int32)(fgval * gval + 0.5);
1989 nbval = (l_int32)(fbval * bval + 0.5);
2029 PROCNAME(
"pixAlphaBlendUniform");
2032 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2033 if (pixGetDepth(
pixs) != 32)
2034 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
2035 if (pixGetSpp(
pixs) != 4) {
2036 L_WARNING(
"no alpha channel; returning clone\n", procName);
2081 PIX *pixd, *pix1, *pix2;
2083 PROCNAME(
"pixAddAlphaToBlend");
2086 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2087 if (fract < 0.0 || fract > 1.0)
2088 return (
PIX *)ERROR_PTR(
"invalid fract", procName, NULL);
2091 if (pixGetColormap(
pixs))
2138 PIX *pixd, *pix1, *pix2, *pix3, *pix4;
2140 PROCNAME(
"pixSetAlphaOverWhite");
2143 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2144 if (!(pixGetDepth(
pixs) == 32 || pixGetColormap(
pixs)))
2145 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp or cmapped", procName, NULL);
2201 l_float32 distfract,
2204 l_int32 i, j, w, h, d, wpl, xmin, ymin,
range, val, rval, gval, bval;
2205 l_float32 slope, limit, del;
2206 l_uint32 *data, *line;
2208 PROCNAME(
"pixLinearEdgeFade");
2211 return ERROR_INT(
"pixs not defined", procName, 1);
2212 if (pixGetColormap(
pixs) != NULL)
2213 return ERROR_INT(
"pixs has a colormap", procName, 1);
2215 if (d != 8 && d != 32)
2216 return ERROR_INT(
"pixs not 8 or 32 bpp", procName, 1);
2219 return ERROR_INT(
"invalid fade direction from edge", procName, 1);
2221 return ERROR_INT(
"invalid fadeto photometry", procName, 1);
2222 if (maxfade <= 0)
return 0;
2224 return ERROR_INT(
"invalid maxfade", procName, 1);
2225 if (distfract <= 0 || distfract * L_MIN(w, h) < 1.0) {
2226 L_INFO(
"distfract is too small\n", procName);
2229 if (distfract > 1.0)
2230 return ERROR_INT(
"invalid distfract", procName, 1);
2234 range = (l_int32)(distfract * w);
2236 slope = maxfade / (l_float32)
range;
2238 range = (l_int32)(distfract * w);
2240 slope = maxfade / (l_float32)
range;
2242 range = (l_int32)(distfract * h);
2244 slope = maxfade / (l_float32)
range;
2246 range = (l_int32)(distfract * h);
2248 slope = maxfade / (l_float32)
range;
2253 wpl = pixGetWpl(
pixs);
2255 for (j = 0; j <
range; j++) {
2257 : maxfade - slope * (
range - j);
2258 for (i = 0; i < h; i++) {
2259 line = data + i * wpl;
2262 val += (limit - val) * del + 0.5;
2266 rval += (limit - rval) * del + 0.5;
2267 gval += (limit - gval) * del + 0.5;
2268 bval += (limit - bval) * del + 0.5;
2274 for (i = 0; i <
range; i++) {
2275 del = (dir ==
L_FROM_TOP) ? maxfade - slope * i
2276 : maxfade - slope * (
range - i);
2277 line = data + (ymin + i) * wpl;
2278 for (j = 0; j < w; j++) {
2281 val += (limit - val) * del + 0.5;
2285 rval += (limit - rval) * del + 0.5;
2286 gval += (limit - gval) * del + 0.5;
2287 bval += (limit - bval) * del + 0.5;
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
l_ok pixSetRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixSetRGBComponent()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
PIX * pixBlendGray(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract, l_int32 type, l_int32 transparent, l_uint32 transpix)
pixBlendGray()
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 * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
PIX * pixBlendGrayAdapt(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract, l_int32 shift)
pixBlendGrayAdapt()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixInvert(PIX *pixd, PIX *pixs)
pixInvert()
#define SET_DATA_QBIT(pdata, n, val)
PIX * pixSetAlphaOverWhite(PIX *pixs)
pixSetAlphaOverWhite()
void pixcmapDestroy(PIXCMAP **pcmap)
pixcmapDestroy()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
PIX * pixRemoveColormapGeneral(PIX *pixs, l_int32 type, l_int32 ifnocmap)
pixRemoveColormapGeneral()
PIX * pixBlendColor(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract, l_int32 transparent, l_uint32 transpix)
pixBlendColor()
PIX * pixFadeWithGray(PIX *pixs, PIX *pixb, l_float32 factor, l_int32 type)
pixFadeWithGray()
#define GET_DATA_BIT(pdata, n)
PIX * pixClipRectangle(PIX *pixs, BOX *box, BOX **pboxc)
pixClipRectangle()
l_ok pixSetColormap(PIX *pix, PIXCMAP *colormap)
pixSetColormap()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
#define SET_DATA_DIBIT(pdata, n, val)
l_ok pixBlendCmap(PIX *pixs, PIX *pixb, l_int32 x, l_int32 y, l_int32 sindex)
pixBlendCmap()
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
l_int32 pixcmapGetIndex(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapGetIndex()
PIX * pixAlphaBlendUniform(PIX *pixs, l_uint32 color)
pixAlphaBlendUniform()
PIX * pixMultiplyByColor(PIX *pixd, PIX *pixs, BOX *box, l_uint32 color)
pixMultiplyByColor()
PIX * pixBlend(PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract)
pixBlend()
l_ok pixSetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 val)
pixSetPixel()
l_ok pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
PIX * pixBlendWithGrayMask(PIX *pixs1, PIX *pixs2, PIX *pixg, l_int32 x, l_int32 y)
pixBlendWithGrayMask()
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_QBIT(pdata, n)
PIX * pixBlendGrayInverse(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract)
pixBlendGrayInverse()
PIX * pixConvertRGBToGrayMinMax(PIX *pixs, l_int32 type)
pixConvertRGBToGrayMinMax()
#define GET_DATA_BYTE(pdata, n)
PIX * pixClone(PIX *pixs)
pixClone()
l_ok pixGetRankValueMasked(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 factor, l_float32 rank, l_float32 *pval, NUMA **pna)
pixGetRankValueMasked()
PIX * pixBlendMask(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract, l_int32 type)
pixBlendMask()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval)
pixGetPixel()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixAddAlphaToBlend(PIX *pixs, l_float32 fract, l_int32 invert)
pixAddAlphaToBlend()
PIX * pixDistanceFunction(PIX *pixs, l_int32 connectivity, l_int32 outdepth, l_int32 boundcond)
pixDistanceFunction()
#define GET_DATA_DIBIT(pdata, n)
l_ok pixMultConstantGray(PIX *pixs, l_float32 val)
pixMultConstantGray()
PIX * pixGammaTRC(PIX *pixd, PIX *pixs, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixGammaTRC()
void boxDestroy(BOX **pbox)
boxDestroy()
l_ok boxIntersects(BOX *box1, BOX *box2, l_int32 *presult)
boxIntersects()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
PIXCMAP * pixcmapCopy(const PIXCMAP *cmaps)
pixcmapCopy()
l_ok pixTransferAllData(PIX *pixd, PIX **ppixs, l_int32 copytext, l_int32 copyformat)
pixTransferAllData()
l_ok pixcmapAddColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapAddColor()
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
PIX * pixBlendBackgroundToColor(PIX *pixd, PIX *pixs, BOX *box, l_uint32 color, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixBlendBackgroundToColor()
l_ok pixLinearEdgeFade(PIX *pixs, l_int32 dir, l_int32 fadeto, l_float32 distfract, l_float32 maxfade)
pixLinearEdgeFade()