92 #include <config_auto.h> 97 #include "allheaders.h" 122 l_int32 i, j, w, h, d, wpl, pval;
123 l_uint32 *data, *line;
125 PROCNAME(
"pixAddConstantGray");
128 return ERROR_INT(
"pixs not defined", procName, 1);
130 if (d != 8 && d != 16 && d != 32)
131 return ERROR_INT(
"pixs not 8, 16 or 32 bpp", procName, 1);
134 wpl = pixGetWpl(pixs);
135 for (i = 0; i < h; i++) {
136 line = data + i * wpl;
139 for (j = 0; j < w; j++) {
141 pval = L_MAX(0, pval + val);
145 for (j = 0; j < w; j++) {
147 pval = L_MIN(255, pval + val);
151 }
else if (d == 16) {
153 for (j = 0; j < w; j++) {
155 pval = L_MAX(0, pval + val);
159 for (j = 0; j < w; j++) {
161 pval = L_MIN(0xffff, pval + val);
166 for (j = 0; j < w; j++)
193 l_int32 i, j, w, h, d, wpl, pval;
195 l_uint32 *data, *line;
197 PROCNAME(
"pixMultConstantGray");
200 return ERROR_INT(
"pixs not defined", procName, 1);
202 if (d != 8 && d != 16 && d != 32)
203 return ERROR_INT(
"pixs not 8, 16 or 32 bpp", procName, 1);
205 return ERROR_INT(
"val < 0.0", procName, 1);
208 wpl = pixGetWpl(pixs);
209 for (i = 0; i < h; i++) {
210 line = data + i * wpl;
212 for (j = 0; j < w; j++) {
214 pval = (l_int32)(val * pval);
215 pval = L_MIN(255, pval);
218 }
else if (d == 16) {
219 for (j = 0; j < w; j++) {
221 pval = (l_int32)(val * pval);
222 pval = L_MIN(0xffff, pval);
226 for (j = 0; j < w; j++) {
228 upval = (l_uint32)(val * upval);
269 l_int32 i, j, d, ws, hs, w, h, wpls, wpld, val, sum;
270 l_uint32 *datas, *datad, *lines, *lined;
272 PROCNAME(
"pixAddGray");
275 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
277 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
279 return (
PIX *)ERROR_PTR(
"pixs2 and pixs1 must differ", procName, pixd);
281 return (
PIX *)ERROR_PTR(
"pixs2 and pixd must differ", procName, pixd);
282 d = pixGetDepth(pixs1);
283 if (d != 8 && d != 16 && d != 32)
284 return (
PIX *)ERROR_PTR(
"pix are not 8, 16 or 32 bpp", procName, pixd);
285 if (pixGetDepth(pixs2) != d)
286 return (
PIX *)ERROR_PTR(
"depths differ (pixs1, pixs2)", procName, pixd);
287 if (pixd && (pixGetDepth(pixd) != d))
288 return (
PIX *)ERROR_PTR(
"depths differ (pixs1, pixd)", procName, pixd);
291 L_WARNING(
"pixs1 and pixs2 not equal in size\n", procName);
293 L_WARNING(
"pixs1 and pixd not equal in size\n", procName);
301 wpls = pixGetWpl(pixs2);
302 wpld = pixGetWpl(pixd);
307 for (i = 0; i < h; i++) {
308 lined = datad + i * wpld;
309 lines = datas + i * wpls;
311 for (j = 0; j < w; j++) {
313 val = L_MIN(sum, 255);
316 }
else if (d == 16) {
317 for (j = 0; j < w; j++) {
320 val = L_MIN(sum, 0xffff);
324 for (j = 0; j < w; j++)
325 *(lined + j) += *(lines + j);
361 l_int32 i, j, w, h, ws, hs, d, wpls, wpld, val, diff;
362 l_uint32 *datas, *datad, *lines, *lined;
364 PROCNAME(
"pixSubtractGray");
367 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
369 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
371 return (
PIX *)ERROR_PTR(
"pixs2 and pixs1 must differ", procName, pixd);
373 return (
PIX *)ERROR_PTR(
"pixs2 and pixd must differ", procName, pixd);
374 d = pixGetDepth(pixs1);
375 if (d != 8 && d != 16 && d != 32)
376 return (
PIX *)ERROR_PTR(
"pix are not 8, 16 or 32 bpp", procName, pixd);
377 if (pixGetDepth(pixs2) != d)
378 return (
PIX *)ERROR_PTR(
"depths differ (pixs1, pixs2)", procName, pixd);
379 if (pixd && (pixGetDepth(pixd) != d))
380 return (
PIX *)ERROR_PTR(
"depths differ (pixs1, pixd)", procName, pixd);
383 L_WARNING(
"pixs1 and pixs2 not equal in size\n", procName);
385 L_WARNING(
"pixs1 and pixd not equal in size\n", procName);
393 wpls = pixGetWpl(pixs2);
394 wpld = pixGetWpl(pixd);
399 for (i = 0; i < h; i++) {
400 lined = datad + i * wpld;
401 lines = datas + i * wpls;
403 for (j = 0; j < w; j++) {
405 val = L_MAX(diff, 0);
408 }
else if (d == 16) {
409 for (j = 0; j < w; j++) {
412 val = L_MAX(diff, 0);
416 for (j = 0; j < w; j++)
417 *(lined + j) -= *(lines + j);
453 l_int32 i, j, w, h, d, ws, hs, ds, wpls, wplg, wpld;
454 l_int32 rval, gval, bval, rval2, gval2, bval2, vals, valg, val, maxgray;
456 l_uint32 *datas, *datag, *datad, *lines, *lineg, *lined;
459 PROCNAME(
"pixMultiplyGray");
462 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
464 if (ds != 8 && ds != 32)
465 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
467 return (
PIX *)ERROR_PTR(
"pixg not defined", procName, NULL);
470 return (
PIX *)ERROR_PTR(
"pixg not 8 bpp", procName, NULL);
474 norm = (maxgray > 0) ? 1.0 / (l_float32)maxgray : 1.0;
478 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
482 wpls = pixGetWpl(pixs);
483 wplg = pixGetWpl(pixg);
484 wpld = pixGetWpl(pixd);
487 for (i = 0; i < h; i++) {
488 lines = datas + i * wpls;
489 lineg = datag + i * wplg;
490 lined = datad + i * wpld;
492 for (j = 0; j < w; j++) {
495 val = (l_int32)(vals * valg * norm + 0.5);
496 val = L_MIN(255, val);
500 for (j = 0; j < w; j++) {
501 val32 = *(lines + j);
504 rval2 = (l_int32)(rval * valg * norm + 0.5);
505 rval2 = L_MIN(255, rval2);
506 gval2 = (l_int32)(gval * valg * norm + 0.5);
507 gval2 = L_MIN(255, gval2);
508 bval2 = (l_int32)(bval * valg * norm + 0.5);
509 bval2 = L_MIN(255, bval2);
545 l_int32 i, j, w, h, d, wpld, setabove;
546 l_uint32 *datad, *lined;
548 PROCNAME(
"pixThresholdToValue");
551 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
552 d = pixGetDepth(pixs);
553 if (d != 8 && d != 16 && d != 32)
554 return (
PIX *)ERROR_PTR(
"pixs not 8, 16 or 32 bpp", procName, pixd);
555 if (pixd && (pixs != pixd))
556 return (
PIX *)ERROR_PTR(
"pixd exists and is not pixs", procName, pixd);
557 if (threshval < 0 || setval < 0)
558 return (
PIX *)ERROR_PTR(
"threshval & setval not < 0", procName, pixd);
559 if (d == 8 && setval > 255)
560 return (
PIX *)ERROR_PTR(
"setval > 255 for 8 bpp", procName, pixd);
561 if (d == 16 && setval > 0xffff)
562 return (
PIX *)ERROR_PTR(
"setval > 0xffff for 16 bpp", procName, pixd);
566 if (setval == threshval) {
567 L_WARNING(
"setval == threshval; no operation\n", procName);
573 wpld = pixGetWpl(pixd);
574 if (setval > threshval)
579 for (i = 0; i < h; i++) {
580 lined = datad + i * wpld;
581 if (setabove == TRUE) {
583 for (j = 0; j < w; j++) {
587 }
else if (d == 16) {
588 for (j = 0; j < w; j++) {
593 for (j = 0; j < w; j++) {
594 if (*(lined + j) >= threshval)
595 *(lined + j) = setval;
600 for (j = 0; j < w; j++) {
604 }
else if (d == 16) {
605 for (j = 0; j < w; j++) {
610 for (j = 0; j < w; j++) {
611 if (*(lined + j) <= threshval)
612 *(lined + j) = setval;
655 PROCNAME(
"pixInitAccumulate");
657 if ((pixd =
pixCreate(w, h, 32)) == NULL)
658 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
659 if (offset > 0x40000000)
687 l_int32 i, j, w, h, wpls, wpld, val;
688 l_uint32 *datas, *datad, *lines, *lined;
691 PROCNAME(
"pixFinalAccumulate");
694 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
695 if (pixGetDepth(pixs) != 32)
696 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
697 if (depth != 8 && depth != 16 && depth != 32)
698 return (
PIX *)ERROR_PTR(
"dest depth not 8, 16, 32 bpp", procName, NULL);
699 if (offset > 0x40000000)
703 if ((pixd =
pixCreate(w, h, depth)) == NULL)
704 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
705 pixCopyResolution(pixd, pixs);
708 wpls = pixGetWpl(pixs);
709 wpld = pixGetWpl(pixd);
711 for (i = 0; i < h; i++) {
712 lines = datas + i * wpls;
713 lined = datad + i * wpld;
714 for (j = 0; j < w; j++) {
715 val = lines[j] - offset;
717 val = L_MIN(255, val);
721 }
else if (depth == 16) {
722 for (i = 0; i < h; i++) {
723 lines = datas + i * wpls;
724 lined = datad + i * wpld;
725 for (j = 0; j < w; j++) {
726 val = lines[j] - offset;
728 val = L_MIN(0xffff, val);
733 for (i = 0; i < h; i++) {
734 lines = datas + i * wpls;
735 lined = datad + i * wpld;
736 for (j = 0; j < w; j++)
737 lined[j] = lines[j] - offset;
764 l_int32 i, j, w, h, wpls, wpld, val;
765 l_uint32 *datas, *datad, *lines, *lined;
768 PROCNAME(
"pixFinalAccumulateThreshold");
771 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
772 if (pixGetDepth(pixs) != 32)
773 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
774 if (offset > 0x40000000)
779 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
780 pixCopyResolution(pixd, pixs);
783 wpls = pixGetWpl(pixs);
784 wpld = pixGetWpl(pixd);
785 for (i = 0; i < h; i++) {
786 lines = datas + i * wpls;
787 lined = datad + i * wpld;
788 for (j = 0; j < w; j++) {
789 val = lines[j] - offset;
790 if (val >= threshold) {
821 l_int32 i, j, w, h, d, wd, hd, wpls, wpld;
822 l_uint32 *datas, *datad, *lines, *lined;
825 PROCNAME(
"pixAccumulate");
827 if (!pixd || (pixGetDepth(pixd) != 32))
828 return ERROR_INT(
"pixd not defined or not 32 bpp", procName, 1);
830 return ERROR_INT(
"pixs not defined", procName, 1);
831 d = pixGetDepth(pixs);
832 if (d != 1 && d != 8 && d != 16 && d != 32)
833 return ERROR_INT(
"pixs not 1, 8, 16 or 32 bpp", procName, 1);
834 if (op != L_ARITH_ADD && op != L_ARITH_SUBTRACT)
835 return ERROR_INT(
"op must be in {L_ARITH_ADD, L_ARITH_SUBTRACT}",
840 wpls = pixGetWpl(pixs);
841 wpld = pixGetWpl(pixd);
847 for (i = 0; i < h; i++) {
848 lines = datas + i * wpls;
849 lined = datad + i * wpld;
850 if (op == L_ARITH_ADD) {
851 for (j = 0; j < w; j++)
854 for (j = 0; j < w; j++)
859 for (i = 0; i < h; i++) {
860 lines = datas + i * wpls;
861 lined = datad + i * wpld;
862 if (op == L_ARITH_ADD) {
863 for (j = 0; j < w; j++)
866 for (j = 0; j < w; j++)
870 }
else if (d == 16) {
871 for (i = 0; i < h; i++) {
872 lines = datas + i * wpls;
873 lined = datad + i * wpld;
874 if (op == L_ARITH_ADD) {
875 for (j = 0; j < w; j++)
878 for (j = 0; j < w; j++)
883 for (i = 0; i < h; i++) {
884 lines = datas + i * wpls;
885 lined = datad + i * wpld;
886 if (op == L_ARITH_ADD) {
887 for (j = 0; j < w; j++)
888 lined[j] += lines[j];
890 for (j = 0; j < w; j++)
891 lined[j] -= lines[j];
920 l_int32 i, j, w, h, wpl, val;
921 l_uint32 *data, *line;
923 PROCNAME(
"pixMultConstAccumulate");
926 return ERROR_INT(
"pixs not defined", procName, 1);
927 if (pixGetDepth(pixs) != 32)
928 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
929 if (offset > 0x40000000)
934 wpl = pixGetWpl(pixs);
935 for (i = 0; i < h; i++) {
936 line = data + i * wpl;
937 for (j = 0; j < w; j++) {
938 val = line[j] - offset;
939 val = (l_int32)(val * factor);
941 line[j] = (l_uint32)val;
973 l_int32 i, j, w, h, w2, h2, d, wpls1, wpls2, wpld, val1, val2, diff;
974 l_int32 rval1, gval1, bval1, rval2, gval2, bval2, rdiff, gdiff, bdiff;
975 l_uint32 *datas1, *datas2, *datad, *lines1, *lines2, *lined;
978 PROCNAME(
"pixAbsDifference");
981 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, NULL);
983 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, NULL);
984 d = pixGetDepth(pixs1);
985 if (d != pixGetDepth(pixs2))
986 return (
PIX *)ERROR_PTR(
"src1 and src2 depths unequal", procName, NULL);
987 if (d != 8 && d != 16 && d != 32)
988 return (
PIX *)ERROR_PTR(
"depths not in {8, 16, 32}", procName, NULL);
995 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
996 pixCopyResolution(pixd, pixs1);
1000 wpls1 = pixGetWpl(pixs1);
1001 wpls2 = pixGetWpl(pixs2);
1002 wpld = pixGetWpl(pixd);
1004 for (i = 0; i < h; i++) {
1005 lines1 = datas1 + i * wpls1;
1006 lines2 = datas2 + i * wpls2;
1007 lined = datad + i * wpld;
1008 for (j = 0; j < w; j++) {
1011 diff = L_ABS(val1 - val2);
1015 }
else if (d == 16) {
1016 for (i = 0; i < h; i++) {
1017 lines1 = datas1 + i * wpls1;
1018 lines2 = datas2 + i * wpls2;
1019 lined = datad + i * wpld;
1020 for (j = 0; j < w; j++) {
1023 diff = L_ABS(val1 - val2);
1028 for (i = 0; i < h; i++) {
1029 lines1 = datas1 + i * wpls1;
1030 lines2 = datas2 + i * wpls2;
1031 lined = datad + i * wpld;
1032 for (j = 0; j < w; j++) {
1035 rdiff = L_ABS(rval1 - rval2);
1036 gdiff = L_ABS(gval1 - gval2);
1037 bdiff = L_ABS(bval1 - bval2);
1070 l_int32 i, j, w, h, d, w2, h2, d2, wplc1, wplc2, wpld;
1071 l_int32 rval1, gval1, bval1, rval2, gval2, bval2, rval, gval, bval;
1072 l_uint32 *datac1, *datac2, *datad, *linec1, *linec2, *lined;
1073 PIX *pixc1, *pixc2, *pixd;
1075 PROCNAME(
"pixAddRGB");
1078 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, NULL);
1080 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, NULL);
1083 if (!pixGetColormap(pixs1) && d != 32)
1084 return (
PIX *)ERROR_PTR(
"pixs1 not cmapped or rgb", procName, NULL);
1085 if (!pixGetColormap(pixs2) && d2 != 32)
1086 return (
PIX *)ERROR_PTR(
"pixs2 not cmapped or rgb", procName, NULL);
1087 if (pixGetColormap(pixs1))
1091 if (pixGetColormap(pixs2))
1099 pixCopyResolution(pixd, pixs1);
1103 wplc1 = pixGetWpl(pixc1);
1104 wplc2 = pixGetWpl(pixc2);
1105 wpld = pixGetWpl(pixd);
1106 for (i = 0; i < h; i++) {
1107 linec1 = datac1 + i * wplc1;
1108 linec2 = datac2 + i * wplc2;
1109 lined = datad + i * wpld;
1110 for (j = 0; j < w; j++) {
1113 rval = L_MIN(255, rval1 + rval2);
1114 gval = L_MIN(255, gval1 + gval2);
1115 bval = L_MIN(255, bval1 + bval2);
1157 l_int32 d, ws, hs, w, h, wpls, wpld, i, j, vals, vald, val;
1158 l_int32 rval1, gval1, bval1, rval2, gval2, bval2, rval, gval, bval;
1159 l_uint32 *datas, *datad, *lines, *lined;
1161 PROCNAME(
"pixMinOrMax");
1164 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1166 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1168 return (
PIX *)ERROR_PTR(
"pixs1 and pixs2 must differ", procName, pixd);
1169 if (type != L_CHOOSE_MIN && type != L_CHOOSE_MAX)
1170 return (
PIX *)ERROR_PTR(
"invalid type", procName, pixd);
1171 d = pixGetDepth(pixs1);
1172 if (pixGetDepth(pixs2) != d)
1173 return (
PIX *)ERROR_PTR(
"depths unequal", procName, pixd);
1174 if (d != 8 && d != 16 && d != 32)
1175 return (
PIX *)ERROR_PTR(
"depth not 8, 16 or 32 bpp", procName, pixd);
1186 wpls = pixGetWpl(pixs2);
1187 wpld = pixGetWpl(pixd);
1188 for (i = 0; i < h; i++) {
1189 lines = datas + i * wpls;
1190 lined = datad + i * wpld;
1192 for (j = 0; j < w; j++) {
1195 if (type == L_CHOOSE_MIN)
1196 val = L_MIN(vals, vald);
1198 val = L_MAX(vals, vald);
1201 }
else if (d == 16) {
1202 for (j = 0; j < w; j++) {
1205 if (type == L_CHOOSE_MIN)
1206 val = L_MIN(vals, vald);
1208 val = L_MAX(vals, vald);
1212 for (j = 0; j < w; j++) {
1215 if (type == L_CHOOSE_MIN) {
1216 rval = L_MIN(rval1, rval2);
1217 gval = L_MIN(gval1, gval2);
1218 bval = L_MIN(bval1, bval2);
1220 rval = L_MAX(rval1, rval2);
1221 gval = L_MAX(gval1, gval2);
1222 bval = L_MAX(bval1, bval2);
1257 l_int32 i, j, w, h, d, wpls, wpld, max;
1258 l_uint32 *datas, *datad;
1259 l_uint32 word, sval;
1260 l_uint32 *lines, *lined;
1265 PROCNAME(
"pixMaxDynamicRange");
1268 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1270 if (d != 4 && d != 8 && d != 16 && d != 32)
1271 return (
PIX *)ERROR_PTR(
"pixs not in {4,8,16,32} bpp", procName, NULL);
1272 if (type != L_LINEAR_SCALE && type != L_LOG_SCALE)
1273 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
1275 if ((pixd =
pixCreate(w, h, 8)) == NULL)
1276 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1277 pixCopyResolution(pixd, pixs);
1280 wpls = pixGetWpl(pixs);
1281 wpld = pixGetWpl(pixd);
1285 for (i = 0; i < h; i++) {
1286 lines = datas + i * wpls;
1287 for (j = 0; j < wpls; j++) {
1288 word = *(lines + j);
1290 max = L_MAX(max, word >> 28);
1291 max = L_MAX(max, (word >> 24) & 0xf);
1292 max = L_MAX(max, (word >> 20) & 0xf);
1293 max = L_MAX(max, (word >> 16) & 0xf);
1294 max = L_MAX(max, (word >> 12) & 0xf);
1295 max = L_MAX(max, (word >> 8) & 0xf);
1296 max = L_MAX(max, (word >> 4) & 0xf);
1297 max = L_MAX(max, word & 0xf);
1298 }
else if (d == 8) {
1299 max = L_MAX(max, word >> 24);
1300 max = L_MAX(max, (word >> 16) & 0xff);
1301 max = L_MAX(max, (word >> 8) & 0xff);
1302 max = L_MAX(max, word & 0xff);
1303 }
else if (d == 16) {
1304 max = L_MAX(max, word >> 16);
1305 max = L_MAX(max, word & 0xffff);
1307 max = L_MAX(max, word);
1314 if (type == L_LINEAR_SCALE) {
1315 factor = 255. / (l_float32)max;
1316 for (i = 0; i < h; i++) {
1317 lines = datas + i * wpls;
1318 lined = datad + i * wpld;
1319 for (j = 0; j < w; j++) {
1321 dval = (l_uint8)(factor * (l_float32)sval + 0.5);
1326 tab = makeLogBase2Tab();
1327 factor = 255. / getLogBase2(max, tab);
1328 for (i = 0; i < h; i++) {
1329 lines = datas + i * wpls;
1330 lined = datad + i * wpld;
1331 for (j = 0; j < w; j++) {
1333 dval = (l_uint8)(factor * getLogBase2(sval, tab) + 0.5);
1339 }
else if (d == 8) {
1340 if (type == L_LINEAR_SCALE) {
1341 factor = 255. / (l_float32)max;
1342 for (i = 0; i < h; i++) {
1343 lines = datas + i * wpls;
1344 lined = datad + i * wpld;
1345 for (j = 0; j < w; j++) {
1347 dval = (l_uint8)(factor * (l_float32)sval + 0.5);
1352 tab = makeLogBase2Tab();
1353 factor = 255. / getLogBase2(max, tab);
1354 for (i = 0; i < h; i++) {
1355 lines = datas + i * wpls;
1356 lined = datad + i * wpld;
1357 for (j = 0; j < w; j++) {
1359 dval = (l_uint8)(factor * getLogBase2(sval, tab) + 0.5);
1365 }
else if (d == 16) {
1366 if (type == L_LINEAR_SCALE) {
1367 factor = 255. / (l_float32)max;
1368 for (i = 0; i < h; i++) {
1369 lines = datas + i * wpls;
1370 lined = datad + i * wpld;
1371 for (j = 0; j < w; j++) {
1373 dval = (l_uint8)(factor * (l_float32)sval + 0.5);
1378 tab = makeLogBase2Tab();
1379 factor = 255. / getLogBase2(max, tab);
1380 for (i = 0; i < h; i++) {
1381 lines = datas + i * wpls;
1382 lined = datad + i * wpld;
1383 for (j = 0; j < w; j++) {
1385 dval = (l_uint8)(factor * getLogBase2(sval, tab) + 0.5);
1392 if (type == L_LINEAR_SCALE) {
1393 factor = 255. / (l_float32)max;
1394 for (i = 0; i < h; i++) {
1395 lines = datas + i * wpls;
1396 lined = datad + i * wpld;
1397 for (j = 0; j < w; j++) {
1399 dval = (l_uint8)(factor * (l_float32)sval + 0.5);
1404 tab = makeLogBase2Tab();
1405 factor = 255. / getLogBase2(max, tab);
1406 for (i = 0; i < h; i++) {
1407 lines = datas + i * wpls;
1408 lined = datad + i * wpld;
1409 for (j = 0; j < w; j++) {
1411 dval = (l_uint8)(factor * getLogBase2(sval, tab) + 0.5);
1444 l_int32 i, j, w, h, wpls, wpld, max;
1445 l_uint32 sval, dval, word;
1446 l_uint32 *datas, *datad;
1447 l_uint32 *lines, *lined;
1452 PROCNAME(
"pixMaxDynamicRangeRGB");
1454 if (!pixs || pixGetDepth(pixs) != 32)
1455 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
1456 if (type != L_LINEAR_SCALE && type != L_LOG_SCALE)
1457 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
1463 wpls = pixGetWpl(pixs);
1464 wpld = pixGetWpl(pixd);
1467 for (i = 0; i < h; i++) {
1468 lines = datas + i * wpls;
1469 for (j = 0; j < wpls; j++) {
1471 max = L_MAX(max, word >> 24);
1472 max = L_MAX(max, (word >> 16) & 0xff);
1473 max = L_MAX(max, (word >> 8) & 0xff);
1477 L_WARNING(
"max = 0; setting to 1\n", procName);
1482 if (type == L_LINEAR_SCALE) {
1483 factor = 255. / (l_float32)max;
1484 for (i = 0; i < h; i++) {
1485 lines = datas + i * wpls;
1486 lined = datad + i * wpld;
1487 for (j = 0; j < w; j++) {
1494 tab = makeLogBase2Tab();
1495 factor = 255. / getLogBase2(max, tab);
1496 for (i = 0; i < h; i++) {
1497 lines = datas + i * wpls;
1498 lined = datad + i * wpld;
1499 for (j = 0; j < w; j++) {
1537 dval = ((l_uint8)(factor * (sval >> 24) + 0.5) << 24) |
1538 ((l_uint8)(factor * ((sval >> 16) & 0xff) + 0.5) << 16) |
1539 ((l_uint8)(factor * ((sval >> 8) & 0xff) + 0.5) << 8) |
1571 dval = ((l_uint8)(factor * getLogBase2(sval >> 24, tab) + 0.5) << 24) |
1572 ((l_uint8)(factor * getLogBase2(((sval >> 16) & 0xff), tab) + 0.5)
1574 ((l_uint8)(factor * getLogBase2(((sval >> 8) & 0xff), tab) + 0.5)
1590 makeLogBase2Tab(
void)
1596 PROCNAME(
"makeLogBase2Tab");
1598 if ((tab = (l_float32 *)LEPT_CALLOC(256,
sizeof(l_float32))) == NULL)
1599 return (l_float32 *)ERROR_PTR(
"tab not made", procName, NULL);
1601 log2 = (l_float32)log((l_float32)2);
1602 for (i = 0; i < 256; i++)
1603 tab[i] = (l_float32)log((l_float32)i) / log2;
1617 getLogBase2(l_int32 val,
1620 PROCNAME(
"getLogBase2");
1623 return ERROR_INT(
"logtab not defined", procName, 0);
1627 else if (val < 0x10000)
1628 return 8.0 + logtab[val >> 8];
1629 else if (val < 0x1000000)
1630 return 16.0 + logtab[val >> 16];
1632 return 24.0 + logtab[val >> 24];
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
l_ok pixMultConstAccumulate(PIX *pixs, l_float32 factor, l_uint32 offset)
pixMultConstAccumulate()
l_uint32 linearScaleRGBVal(l_uint32 sval, l_float32 factor)
linearScaleRGBVal()
PIX * pixMaxDynamicRange(PIX *pixs, l_int32 type)
pixMaxDynamicRange()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixFinalAccumulateThreshold(PIX *pixs, l_uint32 offset, l_uint32 threshold)
pixFinalAccumulateThreshold()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
#define SET_DATA_QBIT(pdata, n, val)
l_uint32 * pixGetData(PIX *pix)
pixGetData()
PIX * pixAddRGB(PIX *pixs1, PIX *pixs2)
pixAddRGB()
#define GET_DATA_BIT(pdata, n)
PIX * pixMultiplyGray(PIX *pixs, PIX *pixg, l_float32 norm)
pixMultiplyGray()
PIX * pixMaxDynamicRangeRGB(PIX *pixs, l_int32 type)
pixMaxDynamicRangeRGB()
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
PIX * pixSubtractGray(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixSubtractGray()
l_ok pixGetExtremeValue(PIX *pixs, l_int32 factor, l_int32 type, l_int32 *prval, l_int32 *pgval, l_int32 *pbval, l_int32 *pgrayval)
pixGetExtremeValue()
PIX * pixAbsDifference(PIX *pixs1, PIX *pixs2)
pixAbsDifference()
PIX * pixInitAccumulate(l_int32 w, l_int32 h, l_uint32 offset)
pixInitAccumulate()
l_ok pixAccumulate(PIX *pixd, PIX *pixs, l_int32 op)
pixAccumulate()
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_QBIT(pdata, n)
#define GET_DATA_BYTE(pdata, n)
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixFinalAccumulate(PIX *pixs, l_uint32 offset, l_int32 depth)
pixFinalAccumulate()
PIX * pixThresholdToValue(PIX *pixd, PIX *pixs, l_int32 threshval, l_int32 setval)
pixThresholdToValue()
l_uint32 logScaleRGBVal(l_uint32 sval, l_float32 *tab, l_float32 factor)
logScaleRGBVal()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixAddGray(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixAddGray()
#define GET_DATA_TWO_BYTES(pdata, n)
l_ok pixMultConstantGray(PIX *pixs, l_float32 val)
pixMultConstantGray()
PIX * pixMinOrMax(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 type)
pixMinOrMax()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_int32 pixSizesEqual(const PIX *pix1, const PIX *pix2)
pixSizesEqual()
#define SET_DATA_TWO_BYTES(pdata, n, val)
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
#define SET_DATA_BIT(pdata, n)
l_ok pixAddConstantGray(PIX *pixs, l_int32 val)
pixAddConstantGray()