/*!
* bmfGetWidth()
*
* Input: bmf
* chr (should be one of the 95 supported bitmaps)
* &w (<return> character width; -1 if not printable)
* Return: 0 if OK, 1 on error
*/
l_int32
bmfGetWidth(L_BMF *bmf,
char chr,
l_int32 *pw)
{
l_int32 i, index;
PIX *pix;
PIXA *pixa;
PROCNAME("bmfGetWidth");
if (!pw)
return ERROR_INT("&w not defined", procName, 1);
*pw = -1;
if (!bmf)
return ERROR_INT("bmf not defined", procName, 1);
if ((index = (l_int32)chr) == 10) /* NL */
return 0;
i = bmf->fonttab[index];
if (i == UNDEF) {
L_ERROR_INT("no bitmap representation for %d", procName, index);
return 1;
}
if ((pixa = bmf->pixa) == NULL)
return ERROR_INT("pixa not found", procName, 1);
if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL)
return ERROR_INT("pix not found", procName, 1);
*pw = pixGetWidth(pix);
pixDestroy(&pix);
return 0;
}
/*!
* bmfGetBaseline()
*
* Input: bmf
* chr (should be one of the 95 supported bitmaps)
* &baseline (<return>; distance below UL corner of bitmap char)
* Return: 0 if OK, 1 on error
*/
l_int32
bmfGetBaseline(L_BMF *bmf,
char chr,
l_int32 *pbaseline)
{
l_int32 bl, index;
PROCNAME("bmfGetBaseline");
if (!pbaseline)
return ERROR_INT("&baseline not defined", procName, 1);
*pbaseline = 0;
if (!bmf)
return ERROR_INT("bmf not defined", procName, 1);
if ((index = (l_int32)chr) == 10) /* NL */
return 0;
bl = bmf->baselinetab[index];
if (bl == UNDEF) {
L_ERROR_INT("no bitmap representation for %d", procName, index);
return 1;
}
*pbaseline = bl;
return 0;
}
/*!
* ptraCompactArray()
*
* Input: ptra
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This compacts the items on the array, filling any empty ptrs.
* (2) This does not change the size of the array of ptrs.
*/
l_int32
ptraCompactArray(L_PTRA *pa)
{
l_int32 i, imax, nactual, index;
PROCNAME("ptraCompactArray");
if (!pa)
return ERROR_INT("pa not defined", procName, 1);
ptraGetMaxIndex(pa, &imax);
ptraGetActualCount(pa, &nactual);
if (imax + 1 == nactual) return 0;
/* Compact the array */
for (i = 0, index = 0; i <= imax; i++) {
if (pa->array[i])
pa->array[index++] = pa->array[i];
}
pa->imax = index - 1;
if (nactual != index)
L_ERROR_INT("index = %d; != nactual", procName, index);
return 0;
}
/*!
* bmfGetPix()
*
* Input: bmf
* chr (should be one of the 95 supported printable bitmaps)
* Return: pix (clone of pix in bmf), or null on error
*/
PIX *
bmfGetPix(L_BMF *bmf,
char chr)
{
l_int32 i, index;
PIXA *pixa;
PROCNAME("bmfGetPix");
if ((index = (l_int32)chr) == 10) /* NL */
return NULL;
if (!bmf)
return (PIX *)ERROR_PTR("bmf not defined", procName, NULL);
i = bmf->fonttab[index];
if (i == UNDEF) {
L_ERROR_INT("no bitmap representation for %d", procName, index);
return NULL;
}
if ((pixa = bmf->pixa) == NULL)
return (PIX *)ERROR_PTR("pixa not found", procName, NULL);
return pixaGetPix(pixa, i, L_CLONE);
}
/*!
* 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;
}
