/*! * pixAddConstantGray() * * Input: pixs (8, 16 or 32 bpp) * val (amount to add to each pixel) * Return: 0 if OK, 1 on error * * Notes: * (1) In-place operation. * (2) No clipping for 32 bpp. * (3) For 8 and 16 bpp, if val > 0 the result is clipped * to 0xff and 0xffff, rsp. * (4) For 8 and 16 bpp, if val < 0 the result is clipped to 0. */ l_int32 pixAddConstantGray(PIX *pixs, l_int32 val) { l_int32 i, j, w, h, d, wpl, pval; l_uint32 *data, *line; PROCNAME("pixAddConstantGray"); if (!pixs) return ERROR_INT("pixs not defined", procName, 1); pixGetDimensions(pixs, &w, &h, &d); if (d != 8 && d != 16 && d != 32) return ERROR_INT("pixs not 8, 16 or 32 bpp", procName, 1); data = pixGetData(pixs); wpl = pixGetWpl(pixs); for (i = 0; i < h; i++) { line = data + i * wpl; if (d == 8) { if (val < 0) { for (j = 0; j < w; j++) { pval = GET_DATA_BYTE(line, j); pval = L_MAX(0, pval + val); SET_DATA_BYTE(line, j, pval); } } else { /* val >= 0 */ for (j = 0; j < w; j++) { pval = GET_DATA_BYTE(line, j); pval = L_MIN(255, pval + val); SET_DATA_BYTE(line, j, pval); } } } else if (d == 16) { if (val < 0) { for (j = 0; j < w; j++) { pval = GET_DATA_TWO_BYTES(line, j); pval = L_MAX(0, pval + val); SET_DATA_TWO_BYTES(line, j, pval); } } else { /* val >= 0 */ for (j = 0; j < w; j++) { pval = GET_DATA_TWO_BYTES(line, j); pval = L_MIN(0xffff, pval + val); SET_DATA_TWO_BYTES(line, j, pval); } } } else { /* d == 32; no check for overflow (< 0 or > 0xffffffff) */ for (j = 0; j < w; j++) *(line + j) += val; } } return 0; }
/*! * addConstantGrayLow() */ void addConstantGrayLow(l_uint32 *data, l_int32 w, l_int32 h, l_int32 d, l_int32 wpl, l_int32 val) { l_int32 i, j, pval; l_uint32 *line; for (i = 0; i < h; i++) { line = data + i * wpl; if (d == 8) { if (val < 0) { for (j = 0; j < w; j++) { pval = GET_DATA_BYTE(line, j); pval = L_MAX(0, pval + val); SET_DATA_BYTE(line, j, pval); } } else { /* val >= 0 */ for (j = 0; j < w; j++) { pval = GET_DATA_BYTE(line, j); pval = L_MIN(255, pval + val); SET_DATA_BYTE(line, j, pval); } } } else if (d == 16) { if (val < 0) { for (j = 0; j < w; j++) { pval = GET_DATA_TWO_BYTES(line, j); pval = L_MAX(0, pval + val); SET_DATA_TWO_BYTES(line, j, pval); } } else { /* val >= 0 */ for (j = 0; j < w; j++) { pval = GET_DATA_TWO_BYTES(line, j); pval = L_MIN(0xffff, pval + val); SET_DATA_TWO_BYTES(line, j, pval); } } } else { /* d == 32; no check for overflow (< 0 or > 0xffffffff) */ for (j = 0; j < w; j++) *(line + j) += val; } } return; }
/*! * pixSetPixel() * * Input: pix * (x,y) pixel coords * val (value to be inserted) * Return: 0 if OK; 1 on error * * Notes: * (1) Warning: the input value is not checked for overflow with respect * the the depth of @pix, and the sign bit (if any) is ignored. * * For d == 1, @val > 0 sets the bit on. * * For d == 2, 4, 8 and 16, @val is masked to the maximum allowable * pixel value, and any (invalid) higher order bits are discarded. * (2) See pixGetPixel() for information on performance. */ LEPTONICA_EXPORT l_int32 pixSetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 val) { l_int32 w, h, d, wpl; l_uint32 *line, *data; PROCNAME("pixSetPixel"); if (!pix) return ERROR_INT("pix not defined", procName, 1); pixGetDimensions(pix, &w, &h, &d); if (x < 0 || x >= w) return ERROR_INT("x out of bounds", procName, 1); if (y < 0 || y >= h) return ERROR_INT("y out of bounds", procName, 1); data = pixGetData(pix); wpl = pixGetWpl(pix); line = data + y * wpl; switch (d) { case 1: if (val) SET_DATA_BIT(line, x); else CLEAR_DATA_BIT(line, x); break; case 2: SET_DATA_DIBIT(line, x, val); break; case 4: SET_DATA_QBIT(line, x, val); break; case 8: SET_DATA_BYTE(line, x, val); break; case 16: SET_DATA_TWO_BYTES(line, x, val); break; case 32: line[x] = val; break; default: return ERROR_INT("depth must be in {1,2,4,8,16,32} bpp", procName, 1); } return 0; }
/*! * finalAccumulateLow() */ void finalAccumulateLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 d, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_uint32 offset) { l_int32 i, j; l_int32 val; l_uint32 *lines, *lined; switch (d) { case 8: for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val = lines[j] - offset; val = L_MAX(0, val); val = L_MIN(255, val); SET_DATA_BYTE(lined, j, (l_uint8)val); } } break; case 16: for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val = lines[j] - offset; val = L_MAX(0, val); val = L_MIN(0xffff, val); SET_DATA_TWO_BYTES(lined, j, (l_uint16)val); } } break; case 32: for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) lined[j] = lines[j] - offset; } break; } return; }
/*! * pixMultConstantGray() * * Input: pixs (8, 16 or 32 bpp) * val (>= 0.0; amount to multiply by each pixel) * Return: 0 if OK, 1 on error * * Notes: * (1) In-place operation; val must be >= 0. * (2) No clipping for 32 bpp. * (3) For 8 and 16 bpp, the result is clipped to 0xff and 0xffff, rsp. */ l_int32 pixMultConstantGray(PIX *pixs, l_float32 val) { l_int32 i, j, w, h, d, wpl, pval; l_uint32 upval; l_uint32 *data, *line; PROCNAME("pixMultConstantGray"); if (!pixs) return ERROR_INT("pixs not defined", procName, 1); pixGetDimensions(pixs, &w, &h, &d); if (d != 8 && d != 16 && d != 32) return ERROR_INT("pixs not 8, 16 or 32 bpp", procName, 1); if (val < 0.0) return ERROR_INT("val < 0.0", procName, 1); data = pixGetData(pixs); wpl = pixGetWpl(pixs); for (i = 0; i < h; i++) { line = data + i * wpl; if (d == 8) { for (j = 0; j < w; j++) { pval = GET_DATA_BYTE(line, j); pval = (l_int32)(val * pval); pval = L_MIN(255, pval); SET_DATA_BYTE(line, j, pval); } } else if (d == 16) { for (j = 0; j < w; j++) { pval = GET_DATA_TWO_BYTES(line, j); pval = (l_int32)(val * pval); pval = L_MIN(0xffff, pval); SET_DATA_TWO_BYTES(line, j, pval); } } else { /* d == 32; no clipping */ for (j = 0; j < w; j++) { upval = *(line + j); upval = (l_uint32)(val * upval); *(line + j) = upval; } } } return 0; }
/*! * multConstantGrayLow() */ void multConstantGrayLow(l_uint32 *data, l_int32 w, l_int32 h, l_int32 d, l_int32 wpl, l_float32 val) { l_int32 i, j, pval; l_uint32 upval; l_uint32 *line; for (i = 0; i < h; i++) { line = data + i * wpl; if (d == 8) { for (j = 0; j < w; j++) { pval = GET_DATA_BYTE(line, j); pval = (l_int32)(val * pval); pval = L_MIN(255, pval); SET_DATA_BYTE(line, j, pval); } } else if (d == 16) { for (j = 0; j < w; j++) { pval = GET_DATA_TWO_BYTES(line, j); pval = (l_int32)(val * pval); pval = L_MIN(0xffff, pval); SET_DATA_TWO_BYTES(line, j, pval); } } else { /* d == 32; no clipping */ for (j = 0; j < w; j++) { upval = *(line + j); upval = (l_uint32)(val * upval); *(line + j) = upval; } } } return; }
/*! * addGrayLow() */ void addGrayLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 d, l_int32 wpld, l_uint32 *datas, l_int32 wpls) { l_int32 i, j, val, sum; l_uint32 *lines, *lined; for (i = 0; i < h; i++) { lined = datad + i * wpld; lines = datas + i * wpls; if (d == 8) { for (j = 0; j < w; j++) { sum = GET_DATA_BYTE(lines, j) + GET_DATA_BYTE(lined, j); val = L_MIN(sum, 255); SET_DATA_BYTE(lined, j, val); } } else if (d == 16) { for (j = 0; j < w; j++) { sum = GET_DATA_TWO_BYTES(lines, j) + GET_DATA_TWO_BYTES(lined, j); val = L_MIN(sum, 0xffff); SET_DATA_TWO_BYTES(lined, j, val); } } else { /* d == 32; no clipping */ for (j = 0; j < w; j++) *(lined + j) += *(lines + j); } } return; }
/*! * subtractGrayLow() */ void subtractGrayLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 d, l_int32 wpld, l_uint32 *datas, l_int32 wpls) { l_int32 i, j, val, diff; l_uint32 *lines, *lined; for (i = 0; i < h; i++) { lined = datad + i * wpld; lines = datas + i * wpls; if (d == 8) { for (j = 0; j < w; j++) { diff = GET_DATA_BYTE(lined, j) - GET_DATA_BYTE(lines, j); val = L_MAX(diff, 0); SET_DATA_BYTE(lined, j, val); } } else if (d == 16) { for (j = 0; j < w; j++) { diff = GET_DATA_TWO_BYTES(lined, j) - GET_DATA_TWO_BYTES(lines, j); val = L_MAX(diff, 0); SET_DATA_TWO_BYTES(lined, j, val); } } else { /* d == 32; no clipping */ for (j = 0; j < w; j++) *(lined + j) -= *(lines + j); } } return; }
/*! * expandBinaryPower2Low() */ l_int32 expandBinaryPower2Low(l_uint32 *datad, l_int32 wd, l_int32 hd, l_int32 wpld, l_uint32 *datas, l_int32 ws, l_int32 hs, l_int32 wpls, l_int32 factor) { l_int32 i, j, k, sdibits, sqbits, sbytes; l_uint8 sval; l_uint16 *tab2; l_uint32 *tab4, *tab8; l_uint32 *lines, *lined; PROCNAME("expandBinaryPower2Low"); switch (factor) { case 2: if ((tab2 = makeExpandTab2x()) == NULL) return ERROR_INT("tab2 not made", procName, 1); sbytes = (ws + 7) / 8; for (i = 0; i < hs; i++) { lines = datas + i * wpls; lined = datad + 2 * i * wpld; for (j = 0; j < sbytes; j++) { sval = GET_DATA_BYTE(lines, j); SET_DATA_TWO_BYTES(lined, j, tab2[sval]); } memcpy((char *)(lined + wpld), (char *)lined, 4 * wpld); } FREE(tab2); break; case 4: if ((tab4 = makeExpandTab4x()) == NULL) return ERROR_INT("tab4 not made", procName, 1); sbytes = (ws + 7) / 8; for (i = 0; i < hs; i++) { lines = datas + i * wpls; lined = datad + 4 * i * wpld; for (j = 0; j < sbytes; j++) { sval = GET_DATA_BYTE(lines, j); lined[j] = tab4[sval]; } for (k = 1; k < 4; k++) memcpy((char *)(lined + k * wpld), (char *)lined, 4 * wpld); } FREE(tab4); break; case 8: if ((tab8 = makeExpandTab8x()) == NULL) return ERROR_INT("tab8 not made", procName, 1); sqbits = (ws + 3) / 4; for (i = 0; i < hs; i++) { lines = datas + i * wpls; lined = datad + 8 * i * wpld; for (j = 0; j < sqbits; j++) { sval = GET_DATA_QBIT(lines, j); if (sval > 15) L_WARNING_INT("sval = %d; should be < 16", procName, sval); lined[j] = tab8[sval]; } for (k = 1; k < 8; k++) memcpy((char *)(lined + k * wpld), (char *)lined, 4 * wpld); } FREE(tab8); break; case 16: sdibits = (ws + 1) / 2; for (i = 0; i < hs; i++) { lines = datas + i * wpls; lined = datad + 16 * i * wpld; for (j = 0; j < sdibits; j++) { sval = GET_DATA_DIBIT(lines, j); lined[j] = expandtab16[sval]; } for (k = 1; k < 16; k++) memcpy((char *)(lined + k * wpld), (char *)lined, 4 * wpld); } break; default: return ERROR_INT("expansion factor not in {2,4,8,16}", procName, 1); } return 0; }
/*! * pixRunlengthTransform() * * Input: pixs (1 bpp) * color (0 for white runs, 1 for black runs) * direction (L_HORIZONTAL_RUNS, L_VERTICAL_RUNS) * depth (8 or 16 bpp) * Return: pixd (8 or 16 bpp), or null on error * * Notes: * (1) The dest Pix is 8 or 16 bpp, with the pixel values * equal to the runlength in which it is a member. * The length is clipped to the max pixel value if necessary. * (2) The color determines if we're labelling white or black runs. * (3) A pixel that is not a member of the chosen color gets * value 0; it belongs to a run of length 0 of the * chosen color. * (4) To convert for maximum dynamic range, either linear or * log, use pixMaxDynamicRange(). */ PIX * pixRunlengthTransform(PIX *pixs, l_int32 color, l_int32 direction, l_int32 depth) { l_int32 i, j, w, h, wpld, bufsize, maxsize, n; l_int32 *start, *end, *buffer; l_uint32 *datad, *lined; PIX *pixt, *pixd; PROCNAME("pixRunlengthTransform"); if (!pixs) return (PIX *) ERROR_PTR("pixs not defined", procName, NULL); if (pixGetDepth(pixs) != 1) return (PIX *) ERROR_PTR("pixs not 1 bpp", procName, NULL); if (depth != 8 && depth != 16) return (PIX *) ERROR_PTR("depth must be 8 or 16 bpp", procName, NULL); pixGetDimensions(pixs, &w, &h, NULL); if (direction == L_HORIZONTAL_RUNS) maxsize = 1 + w / 2; else if (direction == L_VERTICAL_RUNS) maxsize = 1 + h / 2; else return (PIX *) ERROR_PTR("invalid direction", procName, NULL); bufsize = L_MAX(w, h); if ((pixd = pixCreate(w, h, depth)) == NULL) return (PIX *) ERROR_PTR("pixd not made", procName, NULL); datad = pixGetData(pixd); wpld = pixGetWpl(pixd); if ((start = (l_int32 *) CALLOC(maxsize, sizeof(l_int32))) == NULL) return (PIX *) ERROR_PTR("start not made", procName, NULL); if ((end = (l_int32 *) CALLOC(maxsize, sizeof(l_int32))) == NULL) return (PIX *) ERROR_PTR("end not made", procName, NULL); if ((buffer = (l_int32 *) CALLOC(bufsize, sizeof(l_int32))) == NULL) return (PIX *) ERROR_PTR("buffer not made", procName, NULL); /* Use fg runs for evaluation */ if (color == 0) pixt = pixInvert(NULL, pixs); else pixt = pixClone(pixs); if (direction == L_HORIZONTAL_RUNS) { for (i = 0; i < h; i++) { pixFindHorizontalRuns(pixt, i, start, end, &n); runlengthMembershipOnLine(buffer, w, depth, start, end, n); lined = datad + i * wpld; if (depth == 8) { for (j = 0; j < w; j++) SET_DATA_BYTE(lined, j, buffer[j]); } else { /* depth == 16 */ for (j = 0; j < w; j++) SET_DATA_TWO_BYTES(lined, j, buffer[j]); } } } else { /* L_VERTICAL_RUNS */ for (j = 0; j < w; j++) { pixFindVerticalRuns(pixt, j, start, end, &n); runlengthMembershipOnLine(buffer, h, depth, start, end, n); if (depth == 8) { for (i = 0; i < h; i++) { lined = datad + i * wpld; SET_DATA_BYTE(lined, j, buffer[i]); } } else { /* depth == 16 */ for (i = 0; i < h; i++) { lined = datad + i * wpld; SET_DATA_TWO_BYTES(lined, j, buffer[i]); } } } } pixDestroy(&pixt); FREE(start); FREE(end); FREE(buffer); return pixd; }
/*! * pixSubtractGray() * * Input: pixd (<optional>; this can be null, equal to pixs1, or * different from pixs1) * pixs1 (can be == to pixd) * pixs2 * Return: pixd always * * Notes: * (1) Arithmetic subtraction of two 8, 16 or 32 bpp images. * (2) Source pixs2 is always subtracted from source pixs1. * (3) Do explicit clipping to 0. * (4) Alignment is to UL corner. * (5) There are 3 cases. The result can go to a new dest, * in-place to pixs1, or to an existing input dest: * (a) pixd == null (src1 - src2) --> new pixd * (b) pixd == pixs1 (src1 - src2) --> src1 (in-place) * (d) pixd != pixs1 (src1 - src2) --> input pixd * (6) pixs2 must be different from both pixd and pixs1. */ PIX * pixSubtractGray(PIX *pixd, PIX *pixs1, PIX *pixs2) { l_int32 i, j, w, h, ws, hs, d, wpls, wpld, val, diff; l_uint32 *datas, *datad, *lines, *lined; PROCNAME("pixSubtractGray"); if (!pixs1) return (PIX *)ERROR_PTR("pixs1 not defined", procName, pixd); if (!pixs2) return (PIX *)ERROR_PTR("pixs2 not defined", procName, pixd); if (pixs2 == pixs1) return (PIX *)ERROR_PTR("pixs2 and pixs1 must differ", procName, pixd); if (pixs2 == pixd) return (PIX *)ERROR_PTR("pixs2 and pixd must differ", procName, pixd); d = pixGetDepth(pixs1); if (d != 8 && d != 16 && d != 32) return (PIX *)ERROR_PTR("pix are not 8, 16 or 32 bpp", procName, pixd); if (pixGetDepth(pixs2) != d) return (PIX *)ERROR_PTR("depths differ (pixs1, pixs2)", procName, pixd); if (pixd && (pixGetDepth(pixd) != d)) return (PIX *)ERROR_PTR("depths differ (pixs1, pixd)", procName, pixd); if (!pixSizesEqual(pixs1, pixs2)) L_WARNING("pixs1 and pixs2 not equal in size\n", procName); if (pixd && !pixSizesEqual(pixs1, pixd)) L_WARNING("pixs1 and pixd not equal in size\n", procName); if (pixs1 != pixd) pixd = pixCopy(pixd, pixs1); /* pixd - pixs2 ==> pixd */ datas = pixGetData(pixs2); datad = pixGetData(pixd); wpls = pixGetWpl(pixs2); wpld = pixGetWpl(pixd); pixGetDimensions(pixs2, &ws, &hs, NULL); pixGetDimensions(pixd, &w, &h, NULL); w = L_MIN(ws, w); h = L_MIN(hs, h); for (i = 0; i < h; i++) { lined = datad + i * wpld; lines = datas + i * wpls; if (d == 8) { for (j = 0; j < w; j++) { diff = GET_DATA_BYTE(lined, j) - GET_DATA_BYTE(lines, j); val = L_MAX(diff, 0); SET_DATA_BYTE(lined, j, val); } } else if (d == 16) { for (j = 0; j < w; j++) { diff = GET_DATA_TWO_BYTES(lined, j) - GET_DATA_TWO_BYTES(lines, j); val = L_MAX(diff, 0); SET_DATA_TWO_BYTES(lined, j, val); } } else { /* d == 32; no clipping */ for (j = 0; j < w; j++) *(lined + j) -= *(lines + j); } } return pixd; }
/*! * pixMinOrMax() * * Input: pixd (<optional> destination: this can be null, * equal to pixs1, or different from pixs1) * pixs1 (can be == to pixd) * pixs2 * type (L_CHOOSE_MIN, L_CHOOSE_MAX) * Return: pixd always * * Notes: * (1) This gives the min or max of two images, component-wise. * (2) The depth can be 8 or 16 bpp for 1 component, and 32 bpp * for a 3 component image. For 32 bpp, ignore the LSB * of each word (the alpha channel) * (3) There are 3 cases: * - if pixd == null, Min(src1, src2) --> new pixd * - if pixd == pixs1, Min(src1, src2) --> src1 (in-place) * - if pixd != pixs1, Min(src1, src2) --> input pixd */ PIX * pixMinOrMax(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 type) { l_int32 d, ws, hs, w, h, wpls, wpld, i, j, vals, vald, val; l_int32 rval1, gval1, bval1, rval2, gval2, bval2, rval, gval, bval; l_uint32 *datas, *datad, *lines, *lined; PROCNAME("pixMinOrMax"); if (!pixs1) return (PIX *)ERROR_PTR("pixs1 not defined", procName, pixd); if (!pixs2) return (PIX *)ERROR_PTR("pixs2 not defined", procName, pixd); if (pixs1 == pixs2) return (PIX *)ERROR_PTR("pixs1 and pixs2 must differ", procName, pixd); if (type != L_CHOOSE_MIN && type != L_CHOOSE_MAX) return (PIX *)ERROR_PTR("invalid type", procName, pixd); d = pixGetDepth(pixs1); if (pixGetDepth(pixs2) != d) return (PIX *)ERROR_PTR("depths unequal", procName, pixd); if (d != 8 && d != 16 && d != 32) return (PIX *)ERROR_PTR("depth not 8, 16 or 32 bpp", procName, pixd); if (pixs1 != pixd) pixd = pixCopy(pixd, pixs1); pixGetDimensions(pixs2, &ws, &hs, NULL); pixGetDimensions(pixd, &w, &h, NULL); w = L_MIN(w, ws); h = L_MIN(h, hs); datas = pixGetData(pixs2); datad = pixGetData(pixd); wpls = pixGetWpl(pixs2); wpld = pixGetWpl(pixd); for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; if (d == 8) { for (j = 0; j < w; j++) { vals = GET_DATA_BYTE(lines, j); vald = GET_DATA_BYTE(lined, j); if (type == L_CHOOSE_MIN) val = L_MIN(vals, vald); else /* type == L_CHOOSE_MAX */ val = L_MAX(vals, vald); SET_DATA_BYTE(lined, j, val); } } else if (d == 16) { for (j = 0; j < w; j++) { vals = GET_DATA_TWO_BYTES(lines, j); vald = GET_DATA_TWO_BYTES(lined, j); if (type == L_CHOOSE_MIN) val = L_MIN(vals, vald); else /* type == L_CHOOSE_MAX */ val = L_MAX(vals, vald); SET_DATA_TWO_BYTES(lined, j, val); } } else { /* d == 32 */ for (j = 0; j < w; j++) { extractRGBValues(lines[j], &rval1, &gval1, &bval1); extractRGBValues(lined[j], &rval2, &gval2, &bval2); if (type == L_CHOOSE_MIN) { rval = L_MIN(rval1, rval2); gval = L_MIN(gval1, gval2); bval = L_MIN(bval1, bval2); } else { /* type == L_CHOOSE_MAX */ rval = L_MAX(rval1, rval2); gval = L_MAX(gval1, gval2); bval = L_MAX(bval1, bval2); } composeRGBPixel(rval, gval, bval, lined + j); } } } return pixd; }
/*! * \brief pixReadStreamPnm() * * \param[in] fp file stream opened for read * \return pix, or NULL on error */ PIX * pixReadStreamPnm(FILE *fp) { l_uint8 val8, rval8, gval8, bval8; l_uint16 val16; l_int32 w, h, d, bpl, wpl, i, j, type; l_int32 val, rval, gval, bval; l_uint32 rgbval; l_uint32 *line, *data; PIX *pix; PROCNAME("pixReadStreamPnm"); if (!fp) return (PIX *)ERROR_PTR("fp not defined", procName, NULL); if (freadHeaderPnm(fp, &w, &h, &d, &type, NULL, NULL)) return (PIX *)ERROR_PTR( "header read failed", procName, NULL); if ((pix = pixCreate(w, h, d)) == NULL) return (PIX *)ERROR_PTR( "pix not made", procName, NULL); pixSetInputFormat(pix, IFF_PNM); data = pixGetData(pix); wpl = pixGetWpl(pix); /* Old "ascii" format */ if (type <= 3) { for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (type == 1 || type == 2) { if (pnmReadNextAsciiValue(fp, &val)) return (PIX *)ERROR_PTR( "read abend", procName, pix); pixSetPixel(pix, j, i, val); } else { /* type == 3 */ if (pnmReadNextAsciiValue(fp, &rval)) return (PIX *)ERROR_PTR( "read abend", procName, pix); if (pnmReadNextAsciiValue(fp, &gval)) return (PIX *)ERROR_PTR( "read abend", procName, pix); if (pnmReadNextAsciiValue(fp, &bval)) return (PIX *)ERROR_PTR( "read abend", procName, pix); composeRGBPixel(rval, gval, bval, &rgbval); pixSetPixel(pix, j, i, rgbval); } } } return pix; } /* "raw" format for 1 bpp */ if (type == 4) { bpl = (d * w + 7) / 8; for (i = 0; i < h; i++) { line = data + i * wpl; for (j = 0; j < bpl; j++) { if (fread(&val8, 1, 1, fp) != 1) return (PIX *)ERROR_PTR( "read error in 4", procName, pix); SET_DATA_BYTE(line, j, val8); } } return pix; } /* "raw" format for grayscale */ if (type == 5) { bpl = (d * w + 7) / 8; for (i = 0; i < h; i++) { line = data + i * wpl; if (d != 16) { for (j = 0; j < w; j++) { if (fread(&val8, 1, 1, fp) != 1) return (PIX *)ERROR_PTR( "error in 5", procName, pix); if (d == 2) SET_DATA_DIBIT(line, j, val8); else if (d == 4) SET_DATA_QBIT(line, j, val8); else /* d == 8 */ SET_DATA_BYTE(line, j, val8); } } else { /* d == 16 */ for (j = 0; j < w; j++) { if (fread(&val16, 2, 1, fp) != 1) return (PIX *)ERROR_PTR( "16 bpp error", procName, pix); SET_DATA_TWO_BYTES(line, j, val16); } } } return pix; } /* "raw" format, type == 6; rgb */ for (i = 0; i < h; i++) { line = data + i * wpl; for (j = 0; j < wpl; j++) { if (fread(&rval8, 1, 1, fp) != 1) return (PIX *)ERROR_PTR( "read error type 6", procName, pix); if (fread(&gval8, 1, 1, fp) != 1) return (PIX *)ERROR_PTR( "read error type 6", procName, pix); if (fread(&bval8, 1, 1, fp) != 1) return (PIX *)ERROR_PTR( "read error type 6", procName, pix); composeRGBPixel(rval8, gval8, bval8, &rgbval); line[j] = rgbval; } } return pix; }
/*! * fpixConvertToPix() * * Input: fpixs * outdepth (0, 8, 16 or 32 bpp) * negvals (L_CLIP_TO_ZERO, L_TAKE_ABSVAL) * errorflag (1 to output error stats; 0 otherwise) * Return: pixd, or null on error * * Notes: * (1) Use @outdepth = 0 to programmatically determine the * output depth. If no values are greater than 255, * it will set outdepth = 8; otherwise to 16 or 32. * (2) Because we are converting a float to an unsigned int * with a specified dynamic range (8, 16 or 32 bits), errors * can occur. If errorflag == TRUE, output the number * of values out of range, both negative and positive. * (3) If a pixel value is positive and out of range, clip to * the maximum value represented at the outdepth of 8, 16 * or 32 bits. */ PIX * fpixConvertToPix(FPIX *fpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag) { l_int32 w, h, i, j, wpls, wpld, maxval; l_uint32 vald; l_float32 val; l_float32 *datas, *lines; l_uint32 *datad, *lined; PIX *pixd; PROCNAME("fpixConvertToPix"); if (!fpixs) return (PIX *)ERROR_PTR("fpixs not defined", procName, NULL); if (negvals != L_CLIP_TO_ZERO && negvals != L_TAKE_ABSVAL) return (PIX *)ERROR_PTR("invalid negvals", procName, NULL); if (outdepth != 0 && outdepth != 8 && outdepth != 16 && outdepth != 32) return (PIX *)ERROR_PTR("outdepth not in {0,8,16,32}", procName, NULL); fpixGetDimensions(fpixs, &w, &h); datas = fpixGetData(fpixs); wpls = fpixGetWpl(fpixs); /* Adaptive determination of output depth */ if (outdepth == 0) { outdepth = 8; for (i = 0; i < h; i++) { lines = datas + i * wpls; for (j = 0; j < w; j++) { if (lines[j] > 65535.5) { outdepth = 32; break; } if (lines[j] > 255.5) outdepth = 16; } if (outdepth == 32) break; } } maxval = (1 << outdepth) - 1; /* Gather statistics if @errorflag = TRUE */ if (errorflag) { l_int32 negs = 0; l_int32 overvals = 0; for (i = 0; i < h; i++) { lines = datas + i * wpls; for (j = 0; j < w; j++) { val = lines[j]; if (val < 0.0) negs++; else if (val > maxval) overvals++; } } if (negs > 0) L_ERROR_INT("Number of negative values: %d", procName, negs); if (overvals > 0) L_ERROR_INT("Number of too-large values: %d", procName, overvals); } /* Make the pix and convert the data */ if ((pixd = pixCreate(w, h, outdepth)) == NULL) return (PIX *)ERROR_PTR("pixd not made", procName, NULL); datad = pixGetData(pixd); wpld = pixGetWpl(pixd); for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val = lines[j]; if (val >= 0.0) vald = (l_uint32)(val + 0.5); else { /* val < 0.0 */ if (negvals == L_CLIP_TO_ZERO) vald = 0; else vald = (l_uint32)(-val + 0.5); } if (vald > maxval) vald = maxval; if (outdepth == 8) SET_DATA_BYTE(lined, j, vald); else if (outdepth == 16) SET_DATA_TWO_BYTES(lined, j, vald); else /* outdepth == 32 */ SET_DATA_FOUR_BYTES(lined, j, vald); } } return pixd; }
/*! * pixMinOrMax() * * Input: pixd (<optional> destination: this can be null, * equal to pixs1, or different from pixs1) * pixs1 (can be == to pixd) * pixs2 * type (L_CHOOSE_MIN, L_CHOOSE_MAX) * Return: pixd always * * Notes: * (1) This gives the min or max of two images. * (2) The depth can be 8 or 16 bpp. * (3) There are 3 cases: * - if pixd == null, Min(src1, src2) --> new pixd * - if pixd == pixs1, Min(src1, src2) --> src1 (in-place) * - if pixd != pixs1, Min(src1, src2) --> input pixd */ PIX * pixMinOrMax(PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 type) { l_int32 d, ws, hs, w, h, wpls, wpld, i, j; l_int32 vals, vald, val; l_uint32 *datas, *datad, *lines, *lined; PROCNAME("pixMinOrMax"); if (!pixs1) return (PIX *)ERROR_PTR("pixs1 not defined", procName, pixd); if (!pixs2) return (PIX *)ERROR_PTR("pixs2 not defined", procName, pixd); if (pixs1 == pixs2) return (PIX *)ERROR_PTR("pixs1 and pixs2 must differ", procName, pixd); if (type != L_CHOOSE_MIN && type != L_CHOOSE_MAX) return (PIX *)ERROR_PTR("invalid type", procName, pixd); d = pixGetDepth(pixs1); if (pixGetDepth(pixs2) != d) return (PIX *)ERROR_PTR("depths unequal", procName, pixd); if (d != 8 && d != 16) return (PIX *)ERROR_PTR("depth not 8 or 16 bpp", procName, pixd); if (pixs1 != pixd) pixd = pixCopy(pixd, pixs1); pixGetDimensions(pixs2, &ws, &hs, NULL); pixGetDimensions(pixd, &w, &h, NULL); w = L_MIN(w, ws); h = L_MIN(h, hs); datas = pixGetData(pixs2); datad = pixGetData(pixd); wpls = pixGetWpl(pixs2); wpld = pixGetWpl(pixd); for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; if (d == 8) { if (type == L_CHOOSE_MIN) { for (j = 0; j < w; j++) { vals = GET_DATA_BYTE(lines, j); vald = GET_DATA_BYTE(lined, j); val = L_MIN(vals, vald); SET_DATA_BYTE(lined, j, val); } } else { /* type == L_CHOOSE_MAX */ for (j = 0; j < w; j++) { vals = GET_DATA_BYTE(lines, j); vald = GET_DATA_BYTE(lined, j); val = L_MAX(vals, vald); SET_DATA_BYTE(lined, j, val); } } } else { /* d == 16 */ if (type == L_CHOOSE_MIN) { for (j = 0; j < w; j++) { vals = GET_DATA_TWO_BYTES(lines, j); vald = GET_DATA_TWO_BYTES(lined, j); val = L_MIN(vals, vald); SET_DATA_TWO_BYTES(lined, j, val); } } else { /* type == L_CHOOSE_MAX */ for (j = 0; j < w; j++) { vals = GET_DATA_TWO_BYTES(lines, j); vald = GET_DATA_TWO_BYTES(lined, j); val = L_MAX(vals, vald); SET_DATA_TWO_BYTES(lined, j, val); } } } } return pixd; }
/*! * pixThresholdToValue() * * Input: pixd (<optional>; if not null, must be equal to pixs) * pixs (8, 16, 32 bpp) * threshval * setval * Return: pixd always * * Notes: * - operation can be in-place (pixs == pixd) or to a new pixd * - if setval > threshval, sets pixels with a value >= threshval to setval * - if setval < threshval, sets pixels with a value <= threshval to setval * - if setval == threshval, no-op */ PIX * pixThresholdToValue(PIX *pixd, PIX *pixs, l_int32 threshval, l_int32 setval) { l_int32 i, j, w, h, d, wpld, setabove; l_uint32 *datad, *lined; PROCNAME("pixThresholdToValue"); if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", procName, pixd); d = pixGetDepth(pixs); if (d != 8 && d != 16 && d != 32) return (PIX *)ERROR_PTR("pixs not 8, 16 or 32 bpp", procName, pixd); if (pixd && (pixs != pixd)) return (PIX *)ERROR_PTR("pixd exists and is not pixs", procName, pixd); if (threshval < 0 || setval < 0) return (PIX *)ERROR_PTR("threshval & setval not < 0", procName, pixd); if (d == 8 && setval > 255) return (PIX *)ERROR_PTR("setval > 255 for 8 bpp", procName, pixd); if (d == 16 && setval > 0xffff) return (PIX *)ERROR_PTR("setval > 0xffff for 16 bpp", procName, pixd); if (!pixd) pixd = pixCopy(NULL, pixs); if (setval == threshval) { L_WARNING("setval == threshval; no operation\n", procName); return pixd; } datad = pixGetData(pixd); pixGetDimensions(pixd, &w, &h, NULL); wpld = pixGetWpl(pixd); if (setval > threshval) setabove = TRUE; else setabove = FALSE; for (i = 0; i < h; i++) { lined = datad + i * wpld; if (setabove == TRUE) { if (d == 8) { for (j = 0; j < w; j++) { if (GET_DATA_BYTE(lined, j) - threshval >= 0) SET_DATA_BYTE(lined, j, setval); } } else if (d == 16) { for (j = 0; j < w; j++) { if (GET_DATA_TWO_BYTES(lined, j) - threshval >= 0) SET_DATA_TWO_BYTES(lined, j, setval); } } else { /* d == 32 */ for (j = 0; j < w; j++) { if (*(lined + j) >= threshval) *(lined + j) = setval; } } } else { /* set if below or at threshold */ if (d == 8) { for (j = 0; j < w; j++) { if (GET_DATA_BYTE(lined, j) - threshval <= 0) SET_DATA_BYTE(lined, j, setval); } } else if (d == 16) { for (j = 0; j < w; j++) { if (GET_DATA_TWO_BYTES(lined, j) - threshval <= 0) SET_DATA_TWO_BYTES(lined, j, setval); } } else { /* d == 32 */ for (j = 0; j < w; j++) { if (*(lined + j) <= threshval) *(lined + j) = setval; } } } } return pixd; }
/*! * thresholdToValueLow() */ void thresholdToValueLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 d, l_int32 wpld, l_int32 threshval, l_int32 setval) { l_int32 i, j, setabove; l_uint32 *lined; if (setval > threshval) setabove = TRUE; else setabove = FALSE; for (i = 0; i < h; i++) { lined = datad + i * wpld; if (setabove == TRUE) { if (d == 8) { for (j = 0; j < w; j++) { if (GET_DATA_BYTE(lined, j) - threshval >= 0) SET_DATA_BYTE(lined, j, setval); } } else if (d == 16) { for (j = 0; j < w; j++) { if (GET_DATA_TWO_BYTES(lined, j) - threshval >= 0) SET_DATA_TWO_BYTES(lined, j, setval); } } else { /* d == 32 */ for (j = 0; j < w; j++) { if (*(lined + j) >= threshval) *(lined + j) = setval; } } } else { /* set if below or at threshold */ if (d == 8) { for (j = 0; j < w; j++) { if (GET_DATA_BYTE(lined, j) - threshval <= 0) SET_DATA_BYTE(lined, j, setval); } } else if (d == 16) { for (j = 0; j < w; j++) { if (GET_DATA_TWO_BYTES(lined, j) - threshval <= 0) SET_DATA_TWO_BYTES(lined, j, setval); } } else { /* d == 32 */ for (j = 0; j < w; j++) { if (*(lined + j) <= threshval) *(lined + j) = setval; } } } } return; }
/*! * pixFinalAccumulate() * * Input: pixs (32 bpp) * offset (same as used for initialization) * depth (8, 16 or 32 bpp, of destination) * Return: pixd (8, 16 or 32 bpp), or null on error * * Notes: * (1) The offset must be >= 0 and should not exceed 0x40000000. * (2) The offset is subtracted from the src 32 bpp image * (3) For 8 bpp dest, the result is clipped to [0, 0xff] * (4) For 16 bpp dest, the result is clipped to [0, 0xffff] */ PIX * pixFinalAccumulate(PIX *pixs, l_uint32 offset, l_int32 depth) { l_int32 i, j, w, h, wpls, wpld, val; l_uint32 *datas, *datad, *lines, *lined; PIX *pixd; PROCNAME("pixFinalAccumulate"); if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); if (pixGetDepth(pixs) != 32) return (PIX *)ERROR_PTR("pixs not 32 bpp", procName, NULL); if (depth != 8 && depth != 16 && depth != 32) return (PIX *)ERROR_PTR("dest depth not 8, 16, 32 bpp", procName, NULL); if (offset > 0x40000000) offset = 0x40000000; pixGetDimensions(pixs, &w, &h, NULL); if ((pixd = pixCreate(w, h, depth)) == NULL) return (PIX *)ERROR_PTR("pixd not made", procName, NULL); pixCopyResolution(pixd, pixs); /* but how did pixs get it initially? */ datas = pixGetData(pixs); datad = pixGetData(pixd); wpls = pixGetWpl(pixs); wpld = pixGetWpl(pixd); if (depth == 8) { for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val = lines[j] - offset; val = L_MAX(0, val); val = L_MIN(255, val); SET_DATA_BYTE(lined, j, (l_uint8)val); } } } else if (depth == 16) { for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val = lines[j] - offset; val = L_MAX(0, val); val = L_MIN(0xffff, val); SET_DATA_TWO_BYTES(lined, j, (l_uint16)val); } } } else { /* depth == 32 */ for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) lined[j] = lines[j] - offset; } } return pixd; }
/*! * absDifferenceLow() * * Finds the absolute value of the difference of each pixel, * for 8 and 16 bpp gray and for 32 bpp rgb. For 32 bpp, the * differences are found for each of the RGB components * separately, and the LSB component is ignored. * The results are written into datad. */ void absDifferenceLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas1, l_uint32 *datas2, l_int32 d, l_int32 wpls) { l_int32 i, j, val1, val2, diff; l_uint32 word1, word2; l_uint32 *lines1, *lines2, *lined, *pdword; PROCNAME("absDifferenceLow"); switch (d) { case 8: for (i = 0; i < h; i++) { lines1 = datas1 + i * wpls; lines2 = datas2 + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val1 = GET_DATA_BYTE(lines1, j); val2 = GET_DATA_BYTE(lines2, j); diff = L_ABS(val1 - val2); SET_DATA_BYTE(lined, j, diff); } } break; case 16: for (i = 0; i < h; i++) { lines1 = datas1 + i * wpls; lines2 = datas2 + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { val1 = GET_DATA_TWO_BYTES(lines1, j); val2 = GET_DATA_TWO_BYTES(lines2, j); diff = L_ABS(val1 - val2); SET_DATA_TWO_BYTES(lined, j, diff); } } break; case 32: for (i = 0; i < h; i++) { lines1 = datas1 + i * wpls; lines2 = datas2 + i * wpls; lined = datad + i * wpld; for (j = 0; j < w; j++) { word1 = lines1[j]; word2 = lines2[j]; pdword = lined + j; val1 = GET_DATA_BYTE(&word1, COLOR_RED); val2 = GET_DATA_BYTE(&word2, COLOR_RED); diff = L_ABS(val1 - val2); SET_DATA_BYTE(pdword, COLOR_RED, diff); val1 = GET_DATA_BYTE(&word1, COLOR_GREEN); val2 = GET_DATA_BYTE(&word2, COLOR_GREEN); diff = L_ABS(val1 - val2); SET_DATA_BYTE(pdword, COLOR_GREEN, diff); val1 = GET_DATA_BYTE(&word1, COLOR_BLUE); val2 = GET_DATA_BYTE(&word2, COLOR_BLUE); diff = L_ABS(val1 - val2); SET_DATA_BYTE(pdword, COLOR_BLUE, diff); } } break; default: L_ERROR("source depth must be 8, 16 or 32 bpp", procName); break; } return; }
/*! * pixAbsDifference() * * Input: pixs1, pixs2 (both either 8 or 16 bpp gray, or 32 bpp RGB) * Return: pixd, or null on error * * Notes: * (1) The depth of pixs1 and pixs2 must be equal. * (2) Clips computation to the min size, aligning the UL corners * (3) For 8 and 16 bpp, assumes one gray component. * (4) For 32 bpp, assumes 3 color components, and ignores the * LSB of each word (the alpha channel) * (5) Computes the absolute value of the difference between * each component value. */ PIX * pixAbsDifference(PIX *pixs1, PIX *pixs2) { l_int32 i, j, w, h, w2, h2, d, wpls1, wpls2, wpld, val1, val2, diff; l_int32 rval1, gval1, bval1, rval2, gval2, bval2, rdiff, gdiff, bdiff; l_uint32 *datas1, *datas2, *datad, *lines1, *lines2, *lined; PIX *pixd; PROCNAME("pixAbsDifference"); if (!pixs1) return (PIX *)ERROR_PTR("pixs1 not defined", procName, NULL); if (!pixs2) return (PIX *)ERROR_PTR("pixs2 not defined", procName, NULL); d = pixGetDepth(pixs1); if (d != pixGetDepth(pixs2)) return (PIX *)ERROR_PTR("src1 and src2 depths unequal", procName, NULL); if (d != 8 && d != 16 && d != 32) return (PIX *)ERROR_PTR("depths not in {8, 16, 32}", procName, NULL); pixGetDimensions(pixs1, &w, &h, NULL); pixGetDimensions(pixs2, &w2, &h2, NULL); w = L_MIN(w, w2); h = L_MIN(h, h2); if ((pixd = pixCreate(w, h, d)) == NULL) return (PIX *)ERROR_PTR("pixd not made", procName, NULL); pixCopyResolution(pixd, pixs1); datas1 = pixGetData(pixs1); datas2 = pixGetData(pixs2); datad = pixGetData(pixd); wpls1 = pixGetWpl(pixs1); wpls2 = pixGetWpl(pixs2); wpld = pixGetWpl(pixd); if (d == 8) { for (i = 0; i < h; i++) { lines1 = datas1 + i * wpls1; lines2 = datas2 + i * wpls2; lined = datad + i * wpld; for (j = 0; j < w; j++) { val1 = GET_DATA_BYTE(lines1, j); val2 = GET_DATA_BYTE(lines2, j); diff = L_ABS(val1 - val2); SET_DATA_BYTE(lined, j, diff); } } } else if (d == 16) { for (i = 0; i < h; i++) { lines1 = datas1 + i * wpls1; lines2 = datas2 + i * wpls2; lined = datad + i * wpld; for (j = 0; j < w; j++) { val1 = GET_DATA_TWO_BYTES(lines1, j); val2 = GET_DATA_TWO_BYTES(lines2, j); diff = L_ABS(val1 - val2); SET_DATA_TWO_BYTES(lined, j, diff); } } } else { /* d == 32 */ for (i = 0; i < h; i++) { lines1 = datas1 + i * wpls1; lines2 = datas2 + i * wpls2; lined = datad + i * wpld; for (j = 0; j < w; j++) { extractRGBValues(lines1[j], &rval1, &gval1, &bval1); extractRGBValues(lines2[j], &rval2, &gval2, &bval2); rdiff = L_ABS(rval1 - rval2); gdiff = L_ABS(gval1 - gval2); bdiff = L_ABS(bval1 - bval2); composeRGBPixel(rdiff, gdiff, bdiff, lined + j); } } } return pixd; }
main(int argc, char **argv) { l_int32 x, y, i, j, k, w, h, w2, w4, w8, w16, w32, wpl, nerrors; l_int32 count1, count2, count3, ret, val1, val2; l_uint32 val32; l_uint32 *data, *line, *line1, *line2, *data1, *data2; void **lines1, **linet1, **linet2; PIX *pixs, *pixt1, *pixt2; static char mainName[] = "lowaccess_reg"; pixs = pixRead("feyn.tif"); /* width divisible by 16 */ pixGetDimensions(pixs, &w, &h, NULL); data = pixGetData(pixs); wpl = pixGetWpl(pixs); lines1 = pixGetLinePtrs(pixs, NULL); /* Get timing for the 3 different methods */ startTimer(); for (k = 0; k < 10; k++) { count1 = 0; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (GET_DATA_BIT(lines1[i], j)) count1++; } } } fprintf(stderr, "Time with line ptrs = %5.3f sec, count1 = %d\n", stopTimer(), count1); startTimer(); for (k = 0; k < 10; k++) { count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; for (j = 0; j < w; j++) { if (l_getDataBit(line, j)) count2++; } } } fprintf(stderr, "Time with l_get* = %5.3f sec, count2 = %d\n", stopTimer(), count2); startTimer(); for (k = 0; k < 10; k++) { count3 = 0; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { pixGetPixel(pixs, j, i, &val32); count3 += val32; } } } fprintf(stderr, "Time with pixGetPixel() = %5.3f sec, count3 = %d\n", stopTimer(), count3); pixt1 = pixCreateTemplate(pixs); data1 = pixGetData(pixt1); linet1 = pixGetLinePtrs(pixt1, NULL); pixt2 = pixCreateTemplate(pixs); data2 = pixGetData(pixt2); linet2 = pixGetLinePtrs(pixt2, NULL); nerrors = 0; /* Test different methods for 1 bpp */ count1 = 0; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { val1 = GET_DATA_BIT(lines1[i], j); count1 += val1; if (val1) SET_DATA_BIT(linet1[i], j); } } count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w; j++) { val2 = l_getDataBit(line, j); count2 += val2; if (val2) l_setDataBit(line2, j); } } ret = compareResults(pixs, pixt1, pixt2, count1, count2, "1 bpp"); nerrors += ret; /* Test different methods for 2 bpp */ count1 = 0; w2 = w / 2; for (i = 0; i < h; i++) { for (j = 0; j < w2; j++) { val1 = GET_DATA_DIBIT(lines1[i], j); count1 += val1; val1 += 0xbbbbbbbc; SET_DATA_DIBIT(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w2; j++) { val2 = l_getDataDibit(line, j); count2 += val2; val2 += 0xbbbbbbbc; l_setDataDibit(line2, j, val2); } } ret = compareResults(pixs, pixt1, pixt2, count1, count2, "2 bpp"); nerrors += ret; /* Test different methods for 4 bpp */ count1 = 0; w4 = w / 4; for (i = 0; i < h; i++) { for (j = 0; j < w4; j++) { val1 = GET_DATA_QBIT(lines1[i], j); count1 += val1; val1 += 0xbbbbbbb0; SET_DATA_QBIT(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w4; j++) { val2 = l_getDataQbit(line, j); count2 += val2; val2 += 0xbbbbbbb0; l_setDataQbit(line2, j, val2); } } ret = compareResults(pixs, pixt1, pixt2, count1, count2, "4 bpp"); nerrors += ret; /* Test different methods for 8 bpp */ count1 = 0; w8 = w / 8; for (i = 0; i < h; i++) { for (j = 0; j < w8; j++) { val1 = GET_DATA_BYTE(lines1[i], j); count1 += val1; val1 += 0xbbbbbb00; SET_DATA_BYTE(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w8; j++) { val2 = l_getDataByte(line, j); count2 += val2; val2 += 0xbbbbbb00; l_setDataByte(line2, j, val2); } } ret = compareResults(pixs, pixt1, pixt2, count1, count2, "8 bpp"); nerrors += ret; /* Test different methods for 16 bpp */ count1 = 0; w16 = w / 16; for (i = 0; i < h; i++) { for (j = 0; j < w16; j++) { val1 = GET_DATA_TWO_BYTES(lines1[i], j); count1 += val1; val1 += 0xbbbb0000; SET_DATA_TWO_BYTES(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w16; j++) { val2 = l_getDataTwoBytes(line, j); count2 += val2; val2 += 0xbbbb0000; l_setDataTwoBytes(line2, j, val2); } } ret = compareResults(pixs, pixt1, pixt2, count1, count2, "16 bpp"); nerrors += ret; /* Test different methods for 32 bpp */ count1 = 0; w32 = w / 32; for (i = 0; i < h; i++) { for (j = 0; j < w32; j++) { val1 = GET_DATA_FOUR_BYTES(lines1[i], j); count1 += val1 & 0xfff; SET_DATA_FOUR_BYTES(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line = data + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w32; j++) { val2 = l_getDataFourBytes(line, j); count2 += val2 & 0xfff; l_setDataFourBytes(line2, j, val2); } } ret = compareResults(pixs, pixt1, pixt2, count1, count2, "32 bpp"); nerrors += ret; if (!nerrors) fprintf(stderr, "**** No errors ****\n"); else fprintf(stderr, "**** %d errors found! ****\n", nerrors); pixDestroy(&pixs); pixDestroy(&pixt1); pixDestroy(&pixt2); lept_free(lines1); lept_free(linet1); lept_free(linet2); return 0; }
/*! * pixExpandBinaryPower2() * * Input: pixs (1 bpp) * factor (expansion factor: 1, 2, 4, 8, 16) * Return: pixd (expanded 1 bpp by replication), or null on error */ PIX * pixExpandBinaryPower2(PIX *pixs, l_int32 factor) { l_uint8 sval; l_uint16 *tab2; l_int32 i, j, k, w, h, d, wd, hd, wpls, wpld, sdibits, sqbits, sbytes; l_uint32 *datas, *datad, *lines, *lined, *tab4, *tab8; PIX *pixd; PROCNAME("pixExpandBinaryPower2"); if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); pixGetDimensions(pixs, &w, &h, &d); if (d != 1) return (PIX *)ERROR_PTR("pixs not binary", procName, NULL); if (factor == 1) return pixCopy(NULL, pixs); if (factor != 2 && factor != 4 && factor != 8 && factor != 16) return (PIX *)ERROR_PTR("factor must be in {2,4,8,16}", procName, NULL); wpls = pixGetWpl(pixs); datas = pixGetData(pixs); wd = factor * w; hd = factor * h; if ((pixd = pixCreate(wd, hd, 1)) == NULL) return (PIX *)ERROR_PTR("pixd not made", procName, NULL); pixCopyResolution(pixd, pixs); pixScaleResolution(pixd, (l_float32)factor, (l_float32)factor); wpld = pixGetWpl(pixd); datad = pixGetData(pixd); if (factor == 2) { if ((tab2 = makeExpandTab2x()) == NULL) return (PIX *)ERROR_PTR("tab2 not made", procName, NULL); sbytes = (w + 7) / 8; for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + 2 * i * wpld; for (j = 0; j < sbytes; j++) { sval = GET_DATA_BYTE(lines, j); SET_DATA_TWO_BYTES(lined, j, tab2[sval]); } memcpy((char *)(lined + wpld), (char *)lined, 4 * wpld); } FREE(tab2); } else if (factor == 4) { if ((tab4 = makeExpandTab4x()) == NULL) return (PIX *)ERROR_PTR("tab4 not made", procName, NULL); sbytes = (w + 7) / 8; for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + 4 * i * wpld; for (j = 0; j < sbytes; j++) { sval = GET_DATA_BYTE(lines, j); lined[j] = tab4[sval]; } for (k = 1; k < 4; k++) memcpy((char *)(lined + k * wpld), (char *)lined, 4 * wpld); } FREE(tab4); } else if (factor == 8) { if ((tab8 = makeExpandTab8x()) == NULL) return (PIX *)ERROR_PTR("tab8 not made", procName, NULL); sqbits = (w + 3) / 4; for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + 8 * i * wpld; for (j = 0; j < sqbits; j++) { sval = GET_DATA_QBIT(lines, j); if (sval > 15) L_WARNING("sval = %d; should be < 16\n", procName, sval); lined[j] = tab8[sval]; } for (k = 1; k < 8; k++) memcpy((char *)(lined + k * wpld), (char *)lined, 4 * wpld); } FREE(tab8); } else { /* factor == 16 */ sdibits = (w + 1) / 2; for (i = 0; i < h; i++) { lines = datas + i * wpls; lined = datad + 16 * i * wpld; for (j = 0; j < sdibits; j++) { sval = GET_DATA_DIBIT(lines, j); lined[j] = expandtab16[sval]; } for (k = 1; k < 16; k++) memcpy((char *)(lined + k * wpld), (char *)lined, 4 * wpld); } } return pixd; }
int main(int argc, char **argv) { l_int32 i, j, k, w, h, w2, w4, w8, w16, w32, wpl; l_int32 count1, count2, count3; l_uint32 val32, val1, val2; l_uint32 *data1, *line1, *data2, *line2; void **lines1, **linet1, **linet2; PIX *pixs, *pix1, *pix2; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; pixs = pixRead("feyn-fract.tif"); pixGetDimensions(pixs, &w, &h, NULL); data1 = pixGetData(pixs); wpl = pixGetWpl(pixs); lines1 = pixGetLinePtrs(pixs, NULL); /* Get timing for the 3 different methods */ startTimer(); for (k = 0; k < 10; k++) { count1 = 0; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (GET_DATA_BIT(lines1[i], j)) count1++; } } } fprintf(stderr, "Time with line ptrs = %5.3f sec, count1 = %d\n", stopTimer(), count1); startTimer(); for (k = 0; k < 10; k++) { count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; for (j = 0; j < w; j++) { if (l_getDataBit(line1, j)) count2++; } } } fprintf(stderr, "Time with l_get* = %5.3f sec, count2 = %d\n", stopTimer(), count2); startTimer(); for (k = 0; k < 10; k++) { count3 = 0; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { pixGetPixel(pixs, j, i, &val32); count3 += val32; } } } fprintf(stderr, "Time with pixGetPixel() = %5.3f sec, count3 = %d\n", stopTimer(), count3); pix1 = pixCreateTemplate(pixs); linet1 = pixGetLinePtrs(pix1, NULL); pix2 = pixCreateTemplate(pixs); data2 = pixGetData(pix2); linet2 = pixGetLinePtrs(pix2, NULL); /* ------------------------------------------------- */ /* Test different methods for 1 bpp */ /* ------------------------------------------------- */ count1 = 0; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { val1 = GET_DATA_BIT(lines1[i], j); count1 += val1; if (val1) SET_DATA_BIT(linet1[i], j); } } count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w; j++) { val2 = l_getDataBit(line1, j); count2 += val2; if (val2) l_setDataBit(line2, j); } } CompareResults(pixs, pix1, pix2, count1, count2, "1 bpp", rp); /* ------------------------------------------------- */ /* Test different methods for 2 bpp */ /* ------------------------------------------------- */ count1 = 0; w2 = w / 2; for (i = 0; i < h; i++) { for (j = 0; j < w2; j++) { val1 = GET_DATA_DIBIT(lines1[i], j); count1 += val1; val1 += 0xbbbbbbbc; SET_DATA_DIBIT(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w2; j++) { val2 = l_getDataDibit(line1, j); count2 += val2; val2 += 0xbbbbbbbc; l_setDataDibit(line2, j, val2); } } CompareResults(pixs, pix1, pix2, count1, count2, "2 bpp", rp); /* ------------------------------------------------- */ /* Test different methods for 4 bpp */ /* ------------------------------------------------- */ count1 = 0; w4 = w / 4; for (i = 0; i < h; i++) { for (j = 0; j < w4; j++) { val1 = GET_DATA_QBIT(lines1[i], j); count1 += val1; val1 += 0xbbbbbbb0; SET_DATA_QBIT(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w4; j++) { val2 = l_getDataQbit(line1, j); count2 += val2; val2 += 0xbbbbbbb0; l_setDataQbit(line2, j, val2); } } CompareResults(pixs, pix1, pix2, count1, count2, "4 bpp", rp); /* ------------------------------------------------- */ /* Test different methods for 8 bpp */ /* ------------------------------------------------- */ count1 = 0; w8 = w / 8; for (i = 0; i < h; i++) { for (j = 0; j < w8; j++) { val1 = GET_DATA_BYTE(lines1[i], j); count1 += val1; val1 += 0xbbbbbb00; SET_DATA_BYTE(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w8; j++) { val2 = l_getDataByte(line1, j); count2 += val2; val2 += 0xbbbbbb00; l_setDataByte(line2, j, val2); } } CompareResults(pixs, pix1, pix2, count1, count2, "8 bpp", rp); /* ------------------------------------------------- */ /* Test different methods for 16 bpp */ /* ------------------------------------------------- */ count1 = 0; w16 = w / 16; for (i = 0; i < h; i++) { for (j = 0; j < w16; j++) { val1 = GET_DATA_TWO_BYTES(lines1[i], j); count1 += val1; val1 += 0xbbbb0000; SET_DATA_TWO_BYTES(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w16; j++) { val2 = l_getDataTwoBytes(line1, j); count2 += val2; val2 += 0xbbbb0000; l_setDataTwoBytes(line2, j, val2); } } CompareResults(pixs, pix1, pix2, count1, count2, "16 bpp", rp); /* ------------------------------------------------- */ /* Test different methods for 32 bpp */ /* ------------------------------------------------- */ count1 = 0; w32 = w / 32; for (i = 0; i < h; i++) { for (j = 0; j < w32; j++) { val1 = GET_DATA_FOUR_BYTES(lines1[i], j); count1 += val1 & 0xfff; SET_DATA_FOUR_BYTES(linet1[i], j, val1); } } count2 = 0; for (i = 0; i < h; i++) { line1 = data1 + i * wpl; line2 = data2 + i * wpl; for (j = 0; j < w32; j++) { val2 = l_getDataFourBytes(line1, j); count2 += val2 & 0xfff; l_setDataFourBytes(line2, j, val2); } } CompareResults(pixs, pix1, pix2, count1, count2, "32 bpp", rp); pixDestroy(&pixs); pixDestroy(&pix1); pixDestroy(&pix2); lept_free(lines1); lept_free(linet1); lept_free(linet2); return regTestCleanup(rp); }
/*! * pixRotateBySampling() * * Input: pixs (1, 2, 4, 8, 16, 32 bpp rgb; can be cmapped) * xcen (x value of center of rotation) * ycen (y value of center of rotation) * angle (radians; clockwise is positive) * incolor (L_BRING_IN_WHITE, L_BRING_IN_BLACK) * Return: pixd, or null on error * * Notes: * (1) For very small rotations, just return a clone. * (2) Rotation brings either white or black pixels in * from outside the image. * (3) Colormaps are retained. */ PIX * pixRotateBySampling(PIX *pixs, l_int32 xcen, l_int32 ycen, l_float32 angle, l_int32 incolor) { l_int32 w, h, d, i, j, x, y, xdif, ydif, wm1, hm1, wpld; l_uint32 val; l_float32 sina, cosa; l_uint32 *datad, *lined; void **lines; PIX *pixd; PROCNAME("pixRotateBySampling"); if (!pixs) return (PIX *) ERROR_PTR("pixs not defined", procName, NULL); if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK) return (PIX *) ERROR_PTR("invalid incolor", procName, NULL); pixGetDimensions(pixs, &w, &h, &d); if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) return (PIX *) ERROR_PTR("invalid depth", procName, NULL); if (L_ABS(angle) < MIN_ANGLE_TO_ROTATE) return pixClone(pixs); if ((pixd = pixCreateTemplateNoInit(pixs)) == NULL) return (PIX *) ERROR_PTR("pixd not made", procName, NULL); pixSetBlackOrWhite(pixd, incolor); sina = sin(angle); cosa = cos(angle); datad = pixGetData(pixd); wpld = pixGetWpl(pixd); wm1 = w - 1; hm1 = h - 1; lines = pixGetLinePtrs(pixs, NULL); /* Treat 1 bpp case specially */ if (d == 1) { for (i = 0; i < h; i++) { /* scan over pixd */ lined = datad + i * wpld; ydif = ycen - i; for (j = 0; j < w; j++) { xdif = xcen - j; x = xcen + (l_int32)(-xdif * cosa - ydif * sina); if (x < 0 || x > wm1) continue; y = ycen + (l_int32)(-ydif * cosa + xdif * sina); if (y < 0 || y > hm1) continue; if (incolor == L_BRING_IN_WHITE) { if (GET_DATA_BIT(lines[y], x)) SET_DATA_BIT(lined, j); } else { if (!GET_DATA_BIT(lines[y], x)) CLEAR_DATA_BIT(lined, j); } } } FREE(lines); return pixd; } for (i = 0; i < h; i++) { /* scan over pixd */ lined = datad + i * wpld; ydif = ycen - i; for (j = 0; j < w; j++) { xdif = xcen - j; x = xcen + (l_int32)(-xdif * cosa - ydif * sina); if (x < 0 || x > wm1) continue; y = ycen + (l_int32)(-ydif * cosa + xdif * sina); if (y < 0 || y > hm1) continue; switch (d) { case 8: val = GET_DATA_BYTE(lines[y], x); SET_DATA_BYTE(lined, j, val); break; case 32: val = GET_DATA_FOUR_BYTES(lines[y], x); SET_DATA_FOUR_BYTES(lined, j, val); break; case 2: val = GET_DATA_DIBIT(lines[y], x); SET_DATA_DIBIT(lined, j, val); break; case 4: val = GET_DATA_QBIT(lines[y], x); SET_DATA_QBIT(lined, j, val); break; case 16: val = GET_DATA_TWO_BYTES(lines[y], x); SET_DATA_TWO_BYTES(lined, j, val); break; default: return (PIX *) ERROR_PTR("invalid depth", procName, NULL); } } } FREE(lines); return pixd; }