/*!
* fpixAddBorder()
*
* Input: fpixs
* left, right, top, bot (pixels on each side to be added)
* Return: fpixd, or null on error
*
* Notes:
* (1) Adds border of '0' 32-bit pixels
*/
FPIX *
fpixAddBorder(FPIX *fpixs,
l_int32 left,
l_int32 right,
l_int32 top,
l_int32 bot)
{
l_int32 ws, hs, wd, hd;
FPIX *fpixd;
PROCNAME("fpixAddBorder");
if (!fpixs)
return (FPIX *)ERROR_PTR("fpixs not defined", procName, NULL);
if (left <= 0 && right <= 0 && top <= 0 && bot <= 0)
return fpixCopy(NULL, fpixs);
fpixGetDimensions(fpixs, &ws, &hs);
wd = ws + left + right;
hd = hs + top + bot;
if ((fpixd = fpixCreate(wd, hd)) == NULL)
return (FPIX *)ERROR_PTR("fpixd not made", procName, NULL);
fpixCopyResolution(fpixd, fpixs);
fpixRasterop(fpixd, left, top, ws, hs, fpixs, 0, 0);
return fpixd;
}
/*!
* fpixRemoveBorder()
*
* Input: fpixs
* left, right, top, bot (pixels on each side to be removed)
* Return: fpixd, or null on error
*/
FPIX *
fpixRemoveBorder(FPIX *fpixs,
l_int32 left,
l_int32 right,
l_int32 top,
l_int32 bot)
{
l_int32 ws, hs, wd, hd;
FPIX *fpixd;
PROCNAME("fpixRemoveBorder");
if (!fpixs)
return (FPIX *)ERROR_PTR("fpixs not defined", procName, NULL);
if (left <= 0 && right <= 0 && top <= 0 && bot <= 0)
return fpixCopy(NULL, fpixs);
fpixGetDimensions(fpixs, &ws, &hs);
wd = ws - left - right;
hd = hs - top - bot;
if (wd <= 0 || hd <= 0)
return (FPIX *)ERROR_PTR("width & height not both > 0", procName, NULL);
if ((fpixd = fpixCreate(wd, hd)) == NULL)
return (FPIX *)ERROR_PTR("fpixd not made", procName, NULL);
fpixCopyResolution(fpixd, fpixs);
fpixRasterop(fpixd, 0, 0, wd, hd, fpixs, left, top);
return fpixd;
}
/*!
* fpixLinearCombo()
*
* Input: fpixd (<optional>; this can be null, equal to fpixs1, or
* different from fpixs1)
* fpixs1 (can be == to fpixd)
* fpixs2
* Return: pixd always
*
* Notes:
* (1) Computes pixelwise linear combination: a * src1 + b * src2
* (2) Alignment is to UL corner.
* (3) There are 3 cases. The result can go to a new dest,
* in-place to fpixs1, or to an existing input dest:
* * fpixd == null: (src1 + src2) --> new fpixd
* * fpixd == fpixs1: (src1 + src2) --> src1 (in-place)
* * fpixd != fpixs1: (src1 + src2) --> input fpixd
* (4) fpixs2 must be different from both fpixd and fpixs1.
*/
FPIX *
fpixLinearCombination(FPIX *fpixd,
FPIX *fpixs1,
FPIX *fpixs2,
l_float32 a,
l_float32 b)
{
l_int32 i, j, ws, hs, w, h, wpls, wpld;
l_float32 val;
l_float32 *datas, *datad, *lines, *lined;
PROCNAME("fpixLinearCombination");
if (!fpixs1)
return (FPIX *)ERROR_PTR("fpixs1 not defined", procName, fpixd);
if (!fpixs2)
return (FPIX *)ERROR_PTR("fpixs2 not defined", procName, fpixd);
if (fpixs1 == fpixs2)
return (FPIX *)ERROR_PTR("fpixs1 == fpixs2", procName, fpixd);
if (fpixs2 == fpixd)
return (FPIX *)ERROR_PTR("fpixs2 == fpixd", procName, fpixd);
if (fpixs1 != fpixd)
fpixd = fpixCopy(fpixd, fpixs1);
datas = fpixGetData(fpixs2);
datad = fpixGetData(fpixd);
wpls = fpixGetWpl(fpixs2);
wpld = fpixGetWpl(fpixd);
fpixGetDimensions(fpixs2, &ws, &hs);
fpixGetDimensions(fpixd, &w, &h);
w = L_MIN(ws, w);
h = L_MIN(hs, h);
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
if (a == 1.0 && b == 1.0) { /* sum */
for (j = 0; j < w; j++)
*(lined + j) += *(lines + j);
}
else if (a == 1.0 && b == -1.0) { /* diff */
for (j = 0; j < w; j++)
*(lined + j) -= *(lines + j);
}
else if (a == -1.0 && b == 1.0) { /* diff */
for (j = 0; j < w; j++) {
val = *(lined + j);
*(lined + j) = -val + *(lines + j);
}
}
else if (a == -1.0 && b == -1.0) {
for (j = 0; j < w; j++) {
val = *(lined + j);
*(lined + j) = -val - *(lines + j);
}
}
else {
for (j = 0; j < w; j++)
*(lined + j) = a * lined[j] + b * lines[j];
}
}
return fpixd;
}
/*!
* dewarpPopulateFullRes()
*
* Input: dew
* pix (<optional>, to give size of actual image)
* x, y (origin for generation of disparity arrays)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) If the full resolution vertical and horizontal disparity
* arrays do not exist, they are built from the subsampled ones.
* (2) If pixs is not given, the size of the arrays is determined
* by the original image from which the sampled version was
* generated. Any values of (x,y) are ignored.
* (3) If pixs is given, the full resolution disparity arrays must
* be large enough to accommodate it.
* (a) If the arrays do not exist, the value of (x,y) determines
* the origin of the full resolution arrays without extension,
* relative to pixs. Thus, (x,y) gives the amount of
* slope extension in (left, top). The (right, bottom)
* extension is then determined by the size of pixs and
* (x,y); the values should never be < 0.
* (b) If the arrays exist and pixs is too large, the existing
* full res arrays are destroyed and new ones are made,
* again using (x,y) to determine the extension in the
* four directions.
*/
l_int32
dewarpPopulateFullRes(L_DEWARP *dew,
PIX *pix,
l_int32 x,
l_int32 y)
{
l_int32 width, height, fw, fh, deltaw, deltah, redfactor;
FPIX *fpixt1, *fpixt2;
PROCNAME("dewarpPopulateFullRes");
if (!dew)
return ERROR_INT("dew not defined", procName, 1);
if (!dew->sampvdispar)
return ERROR_INT("no sampled vert disparity", procName, 1);
if (x < 0) x = 0;
if (y < 0) y = 0;
/* Establish the target size for the full res arrays */
if (pix)
pixGetDimensions(pix, &width, &height, NULL);
else {
width = dew->w;
height = dew->h;
}
/* Destroy the existing arrays if they are too small */
if (dew->fullvdispar) {
fpixGetDimensions(dew->fullvdispar, &fw, &fh);
if (width > fw || height > fw)
fpixDestroy(&dew->fullvdispar);
}
if (dew->fullhdispar) {
fpixGetDimensions(dew->fullhdispar, &fw, &fh);
if (width > fw || height > fw)
fpixDestroy(&dew->fullhdispar);
}
/* Find the required width and height expansion deltas */
deltaw = width - dew->sampling * (dew->nx - 1) + 2;
deltah = height - dew->sampling * (dew->ny - 1) + 2;
redfactor = dew->redfactor;
deltaw = redfactor * L_MAX(0, deltaw);
deltah = redfactor * L_MAX(0, deltah);
/* Generate the full res vertical array if it doesn't exist,
* extending it as required to make it big enough. Use x,y
* to determine the amounts on each side. */
if (!dew->fullvdispar) {
fpixt1 = fpixCopy(NULL, dew->sampvdispar);
if (redfactor == 2)
fpixAddMultConstant(fpixt1, 0.0, (l_float32)redfactor);
fpixt2 = fpixScaleByInteger(fpixt1, dew->sampling * redfactor);
fpixDestroy(&fpixt1);
if (deltah == 0 && deltaw == 0) {
dew->fullvdispar = fpixt2;
}
else {
dew->fullvdispar = fpixAddSlopeBorder(fpixt2, x, deltaw - x,
y, deltah - y);
fpixDestroy(&fpixt2);
}
}
/* Similarly, generate the full res horizontal array if it
* doesn't exist. Do this even if useboth == 0. */
if (!dew->fullhdispar && dew->samphdispar) {
fpixt1 = fpixCopy(NULL, dew->samphdispar);
if (redfactor == 2)
fpixAddMultConstant(fpixt1, 0.0, (l_float32)redfactor);
fpixt2 = fpixScaleByInteger(fpixt1, dew->sampling * redfactor);
fpixDestroy(&fpixt1);
if (deltah == 0 && deltaw == 0) {
dew->fullhdispar = fpixt2;
}
else {
dew->fullhdispar = fpixAddSlopeBorder(fpixt2, x, deltaw - x,
y, deltah - y);
fpixDestroy(&fpixt2);
}
}
return 0;
}
