/*!
* pixRotateBinaryNice()
*
* Input: pixs (1 bpp)
* angle (radians; clockwise is positive; about the center)
* 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) This does a computationally expensive rotation of 1 bpp images.
* The fastest rotators (using shears or subsampling) leave
* visible horizontal and vertical shear lines across which
* the image shear changes by one pixel. To ameliorate the
* visual effect one can introduce random dithering. One
* way to do this in a not-too-random fashion is given here.
* We convert to 8 bpp, do a very small blur, rotate using
* linear interpolation (same as area mapping), do a
* small amount of sharpening to compensate for the initial
* blur, and threshold back to binary. The shear lines
* are magically removed.
* (3) This operation is about 5x slower than rotation by sampling.
*/
PIX *
pixRotateBinaryNice(PIX *pixs,
l_float32 angle,
l_int32 incolor)
{
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixd;
PROCNAME("pixRotateBinaryNice");
if (!pixs || pixGetDepth(pixs) != 1)
return (PIX *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK)
return (PIX *)ERROR_PTR("invalid incolor", procName, NULL);
pixt1 = pixConvertTo8(pixs, 0);
pixt2 = pixBlockconv(pixt1, 1, 1); /* smallest blur allowed */
pixt3 = pixRotateAM(pixt2, angle, incolor);
pixt4 = pixUnsharpMasking(pixt3, 1, 1.0); /* sharpen a bit */
pixd = pixThresholdToBinary(pixt4, 128);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
return pixd;
}
// Creates and returns a Pix distorted by various means according to the bool
// flags. If boxes is not nullptr, the boxes are resized/positioned according to
// any spatial distortion and also by the integer reduction factor box_scale
// so they will match what the network will output.
// Returns nullptr on error. The returned Pix must be pixDestroyed.
Pix* PrepareDistortedPix(const Pix* pix, bool perspective, bool invert,
bool white_noise, bool smooth_noise, bool blur,
int box_reduction, TRand* randomizer,
GenericVector<TBOX>* boxes) {
Pix* distorted = pixCopy(nullptr, const_cast<Pix*>(pix));
// Things to do to synthetic training data.
if (invert && randomizer->SignedRand(1.0) < 0)
pixInvert(distorted, distorted);
if ((white_noise || smooth_noise) && randomizer->SignedRand(1.0) > 0.0) {
// TODO(rays) Cook noise in a more thread-safe manner than rand().
// Attempt to make the sequences reproducible.
srand(randomizer->IntRand());
Pix* pixn = pixAddGaussianNoise(distorted, 8.0);
pixDestroy(&distorted);
if (smooth_noise) {
distorted = pixBlockconv(pixn, 1, 1);
pixDestroy(&pixn);
} else {
distorted = pixn;
}
}
if (blur && randomizer->SignedRand(1.0) > 0.0) {
Pix* blurred = pixBlockconv(distorted, 1, 1);
pixDestroy(&distorted);
distorted = blurred;
}
if (perspective)
GeneratePerspectiveDistortion(0, 0, randomizer, &distorted, boxes);
if (boxes != nullptr) {
for (int b = 0; b < boxes->size(); ++b) {
(*boxes)[b].scale(1.0f / box_reduction);
if ((*boxes)[b].width() <= 0)
(*boxes)[b].set_right((*boxes)[b].left() + 1);
}
}
return distorted;
}
jint Java_com_googlecode_leptonica_android_Rotate_nativeCleanbackground(JNIEnv *env, jclass clazz,
jint nativePix) {
LOGV("%s",__FUNCTION__);
PIX *pixs = (PIX *) nativePix;
PIX *pixt1,*pixt2,*pixt3,*pixd;
pixt1 = pixCloseGray (pixs, 11, 11);
pixd = pixBlockconv(pixt1, 15, 15);
// pixt3 = pixConvertTo8(pixt2, FALSE);
// pixd = pixSubtract(NULL,pixs,pixt3);
pixDestroy(&pixt1);
// pixDestroy(&pixt2);
// pixDestroy(&pixt3);
return (jint) pixd;
}
// Build the projection profile given the input_block containing lists of
// blobs, a rotation to convert to image coords,
// and a full-resolution nontext_map, marking out areas to avoid.
// During construction, we have the following assumptions:
// The rotation is a multiple of 90 degrees, ie no deskew yet.
// The blobs have had their left and right rules set to also limit
// the range of projection.
void TextlineProjection::ConstructProjection(TO_BLOCK* input_block,
const FCOORD& rotation,
Pix* nontext_map) {
pixDestroy(&pix_);
TBOX image_box(0, 0, pixGetWidth(nontext_map), pixGetHeight(nontext_map));
x_origin_ = 0;
y_origin_ = image_box.height();
int width = (image_box.width() + scale_factor_ - 1) / scale_factor_;
int height = (image_box.height() + scale_factor_ - 1) / scale_factor_;
pix_ = pixCreate(width, height, 8);
ProjectBlobs(&input_block->blobs, rotation, image_box, nontext_map);
ProjectBlobs(&input_block->large_blobs, rotation, image_box, nontext_map);
Pix* final_pix = pixBlockconv(pix_, 1, 1);
// Pix* final_pix = pixBlockconv(pix_, 2, 2);
pixDestroy(&pix_);
pix_ = final_pix;
}
// Degrade the pix as if by a print/copy/scan cycle with exposure > 0
// corresponding to darkening on the copier and <0 lighter and 0 not copied.
// Exposures in [-2,2] are most useful, with -3 and 3 being extreme.
// If rotation is nullptr, rotation is skipped. If *rotation is non-zero, the
// pix
// is rotated by *rotation else it is randomly rotated and *rotation is
// modified.
//
// HOW IT WORKS:
// Most of the process is really dictated by the fact that the minimum
// available convolution is 3X3, which is too big really to simulate a
// good quality print/scan process. (2X2 would be better.)
// 1 pixel wide inputs are heavily smeared by the 3X3 convolution, making the
// images generally biased to being too light, so most of the work is to make
// them darker. 3 levels of thickening/darkening are achieved with 2 dilations,
// (using a greyscale erosion) one heavy (by being before convolution) and one
// light (after convolution).
// With no dilation, after covolution, the images are so light that a heavy
// constant offset is required to make the 0 image look reasonable. A simple
// constant offset multiple of exposure to undo this value is enough to achieve
// all the required lightening. This gives the advantage that exposure level 1
// with a single dilation gives a good impression of the broken-yet-too-dark
// problem that is often seen in scans.
// A small random rotation gives some varying greyscale values on the edges,
// and some random salt and pepper noise on top helps to realistically jaggy-up
// the edges.
// Finally a greyscale ramp provides a continuum of effects between exposure
// levels.
Pix* DegradeImage(Pix* input, int exposure, TRand* randomizer,
float* rotation) {
Pix* pix = pixConvertTo8(input, false);
pixDestroy(&input);
input = pix;
int width = pixGetWidth(input);
int height = pixGetHeight(input);
if (exposure >= 2) {
// An erosion simulates the spreading darkening of a dark copy.
// This is backwards to binary morphology,
// see http://www.leptonica.com/grayscale-morphology.html
pix = input;
input = pixErodeGray(pix, 3, 3);
pixDestroy(&pix);
}
// A convolution is essential to any mode as no scanner produces an
// image as sharp as the electronic image.
pix = pixBlockconv(input, 1, 1);
pixDestroy(&input);
// A small random rotation helps to make the edges jaggy in a realistic way.
if (rotation != nullptr) {
float radians_clockwise = 0.0f;
if (*rotation) {
radians_clockwise = *rotation;
} else if (randomizer != nullptr) {
radians_clockwise = randomizer->SignedRand(kRotationRange);
}
input = pixRotate(pix, radians_clockwise,
L_ROTATE_AREA_MAP, L_BRING_IN_WHITE,
0, 0);
// Rotate the boxes to match.
*rotation = radians_clockwise;
pixDestroy(&pix);
} else {
input = pix;
}
if (exposure >= 3 || exposure == 1) {
// Erosion after the convolution is not as heavy as before, so it is
// good for level 1 and in addition as a level 3.
// This is backwards to binary morphology,
// see http://www.leptonica.com/grayscale-morphology.html
pix = input;
input = pixErodeGray(pix, 3, 3);
pixDestroy(&pix);
}
// The convolution really needed to be 2x2 to be realistic enough, but
// we only have 3x3, so we have to bias the image darker or lose thin
// strokes.
int erosion_offset = 0;
// For light and 0 exposure, there is no dilation, so compensate for the
// convolution with a big darkening bias which is undone for lighter
// exposures.
if (exposure <= 0)
erosion_offset = -3 * kExposureFactor;
// Add in a general offset of the greyscales for the exposure level so
// a threshold of 128 gives a reasonable binary result.
erosion_offset -= exposure * kExposureFactor;
// Add a gradual fade over the page and a small amount of salt and pepper
// noise to simulate noise in the sensor/paper fibres and varying
// illumination.
l_uint32* data = pixGetData(input);
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
int pixel = GET_DATA_BYTE(data, x);
if (randomizer != nullptr)
pixel += randomizer->IntRand() % (kSaltnPepper*2 + 1) - kSaltnPepper;
if (height + width > kMinRampSize)
pixel -= (2*x + y) * 32 / (height + width);
pixel += erosion_offset;
if (pixel < 0)
pixel = 0;
if (pixel > 255)
pixel = 255;
SET_DATA_BYTE(data, x, pixel);
}
data += input->wpl;
}
return input;
}
/*!
* pixOtsuAdaptiveThreshold()
*
* Input: pixs (8 bpp)
* sx, sy (desired tile dimensions; actual size may vary)
* smoothx, smoothy (half-width of convolution kernel applied to
* threshold array: use 0 for no smoothing)
* scorefract (fraction of the max Otsu score; typ. 0.1;
* use 0.0 for standard Otsu)
* &pixth (<optional return> array of threshold values
* found for each tile)
* &pixd (<optional return> thresholded input pixs, based on
* the threshold array)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) The Otsu method finds a single global threshold for an image.
* This function allows a locally adapted threshold to be
* found for each tile into which the image is broken up.
* (2) The array of threshold values, one for each tile, constitutes
* a highly downscaled image. This array is optionally
* smoothed using a convolution. The full width and height of the
* convolution kernel are (2 * @smoothx + 1) and (2 * @smoothy + 1).
* (3) The minimum tile dimension allowed is 16. If such small
* tiles are used, it is recommended to use smoothing, because
* without smoothing, each small tile determines the splitting
* threshold independently. A tile that is entirely in the
* image bg will then hallucinate fg, resulting in a very noisy
* binarization. The smoothing should be large enough that no
* tile is only influenced by one type (fg or bg) of pixels,
* because it will force a split of its pixels.
* (4) To get a single global threshold for the entire image, use
* input values of @sx and @sy that are larger than the image.
* For this situation, the smoothing parameters are ignored.
* (5) The threshold values partition the image pixels into two classes:
* one whose values are less than the threshold and another
* whose values are greater than or equal to the threshold.
* This is the same use of 'threshold' as in pixThresholdToBinary().
* (6) The scorefract is the fraction of the maximum Otsu score, which
* is used to determine the range over which the histogram minimum
* is searched. See numaSplitDistribution() for details on the
* underlying method of choosing a threshold.
* (7) This uses enables a modified version of the Otsu criterion for
* splitting the distribution of pixels in each tile into a
* fg and bg part. The modification consists of searching for
* a minimum in the histogram over a range of pixel values where
* the Otsu score is within a defined fraction, @scorefract,
* of the max score. To get the original Otsu algorithm, set
* @scorefract == 0.
*/
l_int32
pixOtsuAdaptiveThreshold(PIX *pixs,
l_int32 sx,
l_int32 sy,
l_int32 smoothx,
l_int32 smoothy,
l_float32 scorefract,
PIX **ppixth,
PIX **ppixd)
{
l_int32 w, h, nx, ny, i, j, thresh;
l_uint32 val;
PIX *pixt, *pixb, *pixthresh, *pixth, *pixd;
PIXTILING *pt;
PROCNAME("pixOtsuAdaptiveThreshold");
if (!ppixth && !ppixd){
return ERROR_INT("neither &pixth nor &pixd defined", procName, 1);
LOGE("neither &pixth nor &pixd defined");
}
if (ppixth) *ppixth = NULL;
if (ppixd) *ppixd = NULL;
if (!pixs || pixGetDepth(pixs) != 8){
return ERROR_INT("pixs not defined or not 8 bpp", procName, 1);
LOGE("pixs not defined or not 8 bpp");
}
if (sx < 16 || sy < 16){
return ERROR_INT("sx and sy must be >= 16", procName, 1);
LOGE("sx and sy must be >= 16");
}
/* Compute the threshold array for the tiles */
pixGetDimensions(pixs, &w, &h, NULL);
nx = L_MAX(1, w / sx);
ny = L_MAX(1, h / sy);
smoothx = L_MIN(smoothx, (nx - 1) / 2);
smoothy = L_MIN(smoothy, (ny - 1) / 2);
pt = pixTilingCreate(pixs, nx, ny, 0, 0, 0, 0);
pixthresh = pixCreate(nx, ny, 8);
for (i = 0; i < ny; i++) {
for (j = 0; j < nx; j++) {
pixt = pixTilingGetTile(pt, i, j);
pixSplitDistributionFgBg(pixt, scorefract, 1, &thresh,
NULL, NULL, 0);
pixSetPixel(pixthresh, j, i, thresh); /* see note (4) */
pixDestroy(&pixt);
}
}
/* Optionally smooth the threshold array */
if (smoothx > 0 || smoothy > 0)
pixth = pixBlockconv(pixthresh, smoothx, smoothy);
else
pixth = pixClone(pixthresh);
pixDestroy(&pixthresh);
/* Optionally apply the threshold array to binarize pixs */
if (ppixd) {
pixd = pixCreate(w, h, 1);
for (i = 0; i < ny; i++) {
for (j = 0; j < nx; j++) {
pixt = pixTilingGetTile(pt, i, j);
pixGetPixel(pixth, j, i, &val);
pixb = pixThresholdToBinary(pixt, val);
pixTilingPaintTile(pixd, i, j, pixb, pt);
pixDestroy(&pixt);
pixDestroy(&pixb);
}
}
*ppixd = pixd;
}
if (ppixth)
*ppixth = pixth;
else
pixDestroy(&pixth);
pixTilingDestroy(&pt);
return 0;
}
main(int argc,
char **argv)
{
l_int32 d;
PIX *pixs, *pixc, *pixr, *pixg, *pixb, *pixsg, *pixsm, *pixd;
PIXA *pixa;
static char mainName[] = "livre_adapt";
if (argc != 1)
exit(ERROR_INT(" Syntax: livre_adapt", mainName, 1));
/* Read the image in at 150 ppi. */
pixDisplayWrite(NULL, -1);
if ((pixs = pixRead("brothers.150.jpg")) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
pixDisplayWriteFormat(pixs, 2, IFF_JFIF_JPEG);
/* Normalize for uneven illumination on RGB image */
pixBackgroundNormRGBArraysMorph(pixs, NULL, 4, 5, 200,
&pixr, &pixg, &pixb);
pixd = pixApplyInvBackgroundRGBMap(pixs, pixr, pixg, pixb, 4, 4);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixd);
/* Convert the RGB image to grayscale. */
pixsg = pixConvertRGBToLuminance(pixs);
pixDisplayWriteFormat(pixsg, 2, IFF_JFIF_JPEG);
/* Remove the text in the fg. */
pixc = pixCloseGray(pixsg, 25, 25);
pixDisplayWriteFormat(pixc, 2, IFF_JFIF_JPEG);
/* Smooth the bg with a convolution. */
pixsm = pixBlockconv(pixc, 15, 15);
pixDisplayWriteFormat(pixsm, 2, IFF_JFIF_JPEG);
pixDestroy(&pixc);
/* Normalize for uneven illumination on gray image. */
pixBackgroundNormGrayArrayMorph(pixsg, NULL, 4, 5, 200, &pixg);
pixc = pixApplyInvBackgroundGrayMap(pixsg, pixg, 4, 4);
pixDisplayWriteFormat(pixc, 2, IFF_JFIF_JPEG);
pixDestroy(&pixg);
/* Increase the dynamic range. */
pixd = pixGammaTRC(NULL, pixc, 1.0, 30, 180);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixc);
/* Threshold to 1 bpp. */
pixb = pixThresholdToBinary(pixd, 120);
pixDisplayWriteFormat(pixb, 2, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixb);
/* Generate the output image */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 350, 4, 0, 25, 2);
pixWrite("/tmp/adapt.jpg", pixd, IFF_JFIF_JPEG);
pixDisplayWithTitle(pixd, 100, 100, NULL, 1);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixsg);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, j;
l_float32 f;
l_uint32 redval, greenval;
PIX *pixs, *pixd, *pix0, *pix1, *pix2;
static char mainName[] = "locminmax_reg";
if (argc != 1)
return ERROR_INT("syntax: locminmax_reg", mainName, 1);
pixs = pixCreate(500, 500, 8);
for (i = 0; i < 500; i++) {
for (j = 0; j < 500; j++) {
f = 128.0 + 26.3 * sin(0.0438 * (l_float32)i);
f += 33.4 * cos(0.0712 * (l_float32)i);
f += 18.6 * sin(0.0561 * (l_float32)j);
f += 23.6 * cos(0.0327 * (l_float32)j);
pixSetPixel(pixs, j, i, (l_int32)f);
}
}
pixDisplay(pixs, 0, 0);
pixWrite("/tmp/junkpattern.png", pixs, IFF_PNG);
startTimer();
/* pixSelectedLocalExtrema(pixs, 1, &pix1, &pix2); */
pixLocalExtrema(pixs, 0, 0, &pix1, &pix2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixd = pixConvertTo32(pixs);
pixPaintThroughMask(pixd, pix2, 0, 0, greenval);
pixPaintThroughMask(pixd, pix1, 0, 0, redval);
pixDisplay(pixd, 510, 0);
pixWrite("/tmp/junkpixd.png", pixd, IFF_PNG);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixs);
pixDestroy(&pixd);
pix0 = pixRead("karen8.jpg");
pixs = pixBlockconv(pix0, 10, 10);
pixDisplay(pixs, 0, 400);
pixWrite("/tmp/junkconv.png", pixs, IFF_PNG);
startTimer();
/* pixSelectedLocalExtrema(pixs, 1, &pix1, &pix2); */
pixLocalExtrema(pixs, 50, 100, &pix1, &pix2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixd = pixConvertTo32(pixs);
pixPaintThroughMask(pixd, pix2, 0, 0, greenval);
pixPaintThroughMask(pixd, pix1, 0, 0, redval);
pixDisplay(pixd, 350, 400);
pixWrite("/tmp/junkpixd2.png", pixd, IFF_PNG);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixs);
pixDestroy(&pixd);
return 0;
}
main(int argc,
char **argv)
{
char *str;
l_int32 i, j, same, ok;
l_float32 sum, avediff, rmsdiff;
L_KERNEL *kel1, *kel2, *kel3, *kel4, *kelx, *kely;
BOX *box;
PIX *pix, *pixs, *pixb, *pixg, *pixr, *pixd, *pixp, *pixt;
PIX *pixt1, *pixt2, *pixt3;
PIXA *pixa;
SARRAY *sa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Test creating from a string */
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = kernelDisplayInPix(kel1, 41, 2);
pixWrite("/tmp/pixkern.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/pixkern.png"); /* 0 */
pixSaveTiled(pixd, pixa, 1, 1, 20, 8);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test read/write for kernel. Note that both get
* compared to the same golden file, which is
* overwritten with a copy of /tmp/kern2.kel */
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
kernelWrite("/tmp/kern1.kel", kel1);
regTestCheckFile(rp, "/tmp/kern1.kel"); /* 1 */
kel2 = kernelRead("/tmp/kern1.kel");
kernelWrite("/tmp/kern2.kel", kel2);
regTestCheckFile(rp, "/tmp/kern2.kel"); /* 2 */
regTestCompareFiles(rp, 1, 2); /* 3 */
kernelDestroy(&kel1);
kernelDestroy(&kel2);
/* Test creating from a file */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"# small 3x3 kernel", L_COPY);
sarrayAddString(sa, (char *)"3 5", L_COPY);
sarrayAddString(sa, (char *)"1 2", L_COPY);
sarrayAddString(sa, (char *)"20.5 50 80 50 20", L_COPY);
sarrayAddString(sa, (char *)"82. 120 180 120 80", L_COPY);
sarrayAddString(sa, (char *)"22.1 50 80 50 20", L_COPY);
str = sarrayToString(sa, 1);
l_binaryWrite("/tmp/kernfile.kel", "w", str, strlen(str));
kel2 = kernelCreateFromFile("/tmp/kernfile.kel");
pixd = kernelDisplayInPix(kel2, 41, 2);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/ker1.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker1.png"); /* 4 */
pixDestroy(&pixd);
sarrayDestroy(&sa);
lept_free(str);
kernelDestroy(&kel2);
/* Test creating from a pix */
pixt = pixCreate(5, 3, 8);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 0, 50);
pixSetPixel(pixt, 2, 0, 80);
pixSetPixel(pixt, 3, 0, 50);
pixSetPixel(pixt, 4, 0, 20);
pixSetPixel(pixt, 0, 1, 80);
pixSetPixel(pixt, 1, 1, 120);
pixSetPixel(pixt, 2, 1, 180);
pixSetPixel(pixt, 3, 1, 120);
pixSetPixel(pixt, 4, 1, 80);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 2, 50);
pixSetPixel(pixt, 2, 2, 80);
pixSetPixel(pixt, 3, 2, 50);
pixSetPixel(pixt, 4, 2, 20);
kel3 = kernelCreateFromPix(pixt, 1, 2);
pixd = kernelDisplayInPix(kel3, 41, 2);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker2.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker2.png"); /* 5 */
pixDestroy(&pixd);
pixDestroy(&pixt);
kernelDestroy(&kel3);
/* Test convolution with kel1 */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 3, COLOR_GREEN);
pixSaveTiled(pixg, pixa, 1, 1, 20, 0);
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = pixConvolve(pixg, kel1, 8, 1);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker3.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker3.png"); /* 6 */
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test convolution with flat rectangular kel; also test
* block convolution with tiling. */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 3, COLOR_GREEN);
kel2 = makeFlatKernel(11, 11, 5, 5);
pixd = pixConvolve(pixg, kel2, 8, 1);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/ker4.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker4.png"); /* 7 */
pixt = pixBlockconv(pixg, 5, 5);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker5.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker5.png"); /* 8 */
if (rp->display)
pixCompareGray(pixd, pixt, L_COMPARE_ABS_DIFF, GPLOT_X11, NULL,
NULL, NULL, NULL);
pixt2 = pixBlockconvTiled(pixg, 5, 5, 3, 6);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker5a.png", pixt2, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker5a.png"); /* 9 */
pixDestroy(&pixt2);
ok = TRUE;
for (i = 1; i <= 7; i++) {
for (j = 1; j <= 7; j++) {
if (i == 1 && j == 1) continue;
pixt2 = pixBlockconvTiled(pixg, 5, 5, j, i);
pixEqual(pixt2, pixd, &same);
if (!same) {
fprintf(stderr," Error for nx = %d, ny = %d\n", j, i);
ok = FALSE;
}
pixDestroy(&pixt2);
}
}
if (ok)
fprintf(stderr, "OK: Tiled results identical to pixConvolve()\n");
else
fprintf(stderr, "ERROR: Tiled results not identical to pixConvolve()\n");
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixDestroy(&pixt);
kernelDestroy(&kel2);
/* Do another flat rectangular test; this time with white at edge.
* About 1% of the pixels near the image edge differ by 1 between
* the pixConvolve() and pixBlockconv(). For what it's worth,
* pixConvolve() gives the more accurate result; namely, 255 for
* pixels at the edge. */
pix = pixRead("pageseg1.tif");
box = boxCreate(100, 100, 2260, 3160);
pixb = pixClipRectangle(pix, box, NULL);
pixs = pixScaleToGray4(pixb);
kel3 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt = pixConvolve(pixs, kel3, 8, 1);
fprintf(stderr, "Generic convolution time: %5.3f sec\n", stopTimer());
pixSaveTiled(pixt, pixa, 1, 1, 20, 0);
pixWrite("/tmp/conv1.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/conv1.png"); /* 10 */
startTimer();
pixt2 = pixBlockconv(pixs, 3, 3);
fprintf(stderr, "Flat block convolution time: %5.3f sec\n", stopTimer());
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/conv2.png", pixt2, IFF_PNG); /* ditto */
regTestCheckFile(rp, "/tmp/conv2.png"); /* 11 */
pixCompareGray(pixt, pixt2, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&avediff, &rmsdiff, NULL);
#ifndef _WIN32
sleep(1); /* give gnuplot time to write out the file */
#else
Sleep(1000);
#endif /* _WIN32 */
pixp = pixRead("/tmp/grayroot.png");
pixSaveTiled(pixp, pixa, 1, 0, 20, 0);
pixWrite("/tmp/conv3.png", pixp, IFF_PNG);
regTestCheckFile(rp, "/tmp/conv3.png"); /* 12 */
fprintf(stderr, "Ave diff = %6.4f, RMS diff = %6.4f\n", avediff, rmsdiff);
if (avediff <= 0.01)
fprintf(stderr, "OK: avediff = %6.4f <= 0.01\n", avediff);
else
fprintf(stderr, "Bad?: avediff = %6.4f > 0.01\n", avediff);
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDestroy(&pixp);
pixDestroy(&pix);
pixDestroy(&pixb);
boxDestroy(&box);
kernelDestroy(&kel3);
/* Do yet another set of flat rectangular tests, this time
* on an RGB image */
pixs = pixRead("test24.jpg");
kel4 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt1 = pixConvolveRGB(pixs, kel4);
fprintf(stderr, "Time 7x7 non-separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv4.jpg", pixt1, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv4.jpg"); /* 13 */
kelx = makeFlatKernel(1, 7, 0, 3);
kely = makeFlatKernel(7, 1, 3, 0);
startTimer();
pixt2 = pixConvolveRGBSep(pixs, kelx, kely);
fprintf(stderr, "Time 7x1,1x7 separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv5.jpg", pixt2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv5.jpg"); /* 14 */
startTimer();
pixt3 = pixBlockconv(pixs, 3, 3);
fprintf(stderr, "Time 7x7 blockconv: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv6.jpg", pixt3, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv6.jpg"); /* 15 */
regTestComparePix(rp, pixt1, pixt2); /* 16 */
regTestCompareSimilarPix(rp, pixt2, pixt3, 15, 0.0005, 0); /* 17 */
pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
kernelDestroy(&kel4);
kernelDestroy(&kelx);
kernelDestroy(&kely);
/* Test generation and convolution with gaussian kernel */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
kel1 = makeGaussianKernel(5, 5, 3.0, 5.0);
kernelGetSum(kel1, &sum);
fprintf(stderr, "Sum for gaussian kernel = %f\n", sum);
kernelWrite("/tmp/gauss.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 1);
pixt2 = pixConvolve(pixs, kel1, 16, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker6.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker6.png"); /* 18 */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixt = kernelDisplayInPix(kel1, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kel1);
pixDestroy(&pixs);
/* Test generation and convolution with separable gaussian kernel */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
makeGaussianKernelSep(5, 5, 3.0, 5.0, &kelx, &kely);
kernelGetSum(kelx, &sum);
fprintf(stderr, "Sum for x gaussian kernel = %f\n", sum);
kernelGetSum(kely, &sum);
fprintf(stderr, "Sum for y gaussian kernel = %f\n", sum);
kernelWrite("/tmp/gauss.kelx", kelx);
kernelWrite("/tmp/gauss.kely", kely);
pixt = pixConvolveSep(pixs, kelx, kely, 8, 1);
pixt2 = pixConvolveSep(pixs, kelx, kely, 16, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker7.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker7.png"); /* 19 */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixt = kernelDisplayInPix(kelx, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kelx);
kernelDestroy(&kely);
pixDestroy(&pixs);
/* Test generation and convolution with diff of gaussians kernel */
/* pixt = pixRead("marge.jpg");
pixs = pixConvertRGBToLuminance(pixt);
pixDestroy(&pixt); */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
kel1 = makeDoGKernel(7, 7, 1.5, 2.7);
kernelGetSum(kel1, &sum);
fprintf(stderr, "Sum for DoG kernel = %f\n", sum);
kernelWrite("/tmp/dog.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 0);
/* pixInvert(pixt, pixt); */
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker8.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker8.png"); /* 20 */
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kel1, 20, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kel1);
pixDestroy(&pixs);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixWrite("/tmp/kernel.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
regTestCleanup(rp);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, j, sizex, sizey, bias;
FPIX *fpixv, *fpixrv;
L_KERNEL *kel1, *kel2, *kel3x, *kel3y;
PIX *pixs, *pixacc, *pixg, *pixt, *pixd;
PIX *pixb, *pixm, *pixms, *pixrv, *pix1, *pix2, *pix3, *pix4;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Test pixBlockconvGray() on 8 bpp */
pixs = pixRead("test8.jpg");
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlockconvGray(pixs, pixacc, 3, 5);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 0 */
pixDisplayWithTitle(pixd, 100, 0, NULL, rp->display);
pixDestroy(&pixacc);
pixDestroy(&pixd);
/* Test pixBlockconv() on 8 bpp */
pixd = pixBlockconv(pixs, 9, 8);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 1 */
pixDisplayWithTitle(pixd, 200, 0, NULL, rp->display);
pixDestroy(&pixd);
pixDestroy(&pixs);
/* Test pixBlockrank() on 1 bpp */
pixs = pixRead("test1.png");
pixacc = pixBlockconvAccum(pixs);
for (i = 0; i < 3; i++) {
pixd = pixBlockrank(pixs, pixacc, 4, 4, 0.25 + 0.25 * i);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 2 - 4 */
pixDisplayWithTitle(pixd, 300 + 100 * i, 0, NULL, rp->display);
pixDestroy(&pixd);
}
/* Test pixBlocksum() on 1 bpp */
pixd = pixBlocksum(pixs, pixacc, 16, 16);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 5 */
pixDisplayWithTitle(pixd, 700, 0, NULL, rp->display);
pixDestroy(&pixd);
pixDestroy(&pixacc);
pixDestroy(&pixs);
/* Test pixCensusTransform() */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 2, COLOR_GREEN);
pixd = pixCensusTransform(pixg, 10, NULL);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 6 */
pixDisplayWithTitle(pixd, 800, 0, NULL, rp->display);
pixDestroy(&pixd);
/* Test generic convolution with kel1 */
kel1 = kernelCreateFromString(5, 5, 2, 2, kel1str);
pixd = pixConvolve(pixg, kel1, 8, 1);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 7 */
pixDisplayWithTitle(pixd, 100, 500, NULL, rp->display);
pixDestroy(&pixd);
/* Test convolution with flat rectangular kel */
kel2 = kernelCreate(11, 11);
kernelSetOrigin(kel2, 5, 5);
for (i = 0; i < 11; i++) {
for (j = 0; j < 11; j++)
kernelSetElement(kel2, i, j, 1);
}
pixd = pixConvolve(pixg, kel2, 8, 1);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd, 200, 500, NULL, rp->display);
pixDestroy(&pixd);
kernelDestroy(&kel1);
kernelDestroy(&kel2);
/* Test pixBlockconv() on 32 bpp */
pixt = pixScaleBySampling(pixs, 0.5, 0.5);
pixd = pixBlockconv(pixt, 4, 6);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixDisplayWithTitle(pixd, 300, 500, NULL, rp->display);
pixDestroy(&pixt);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
/* Test bias convolution non-separable with kel2 */
pixs = pixRead("marge.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 2, COLOR_GREEN);
kel2 = kernelCreateFromString(5, 5, 2, 2, kel2str);
pixd = pixConvolveWithBias(pixg, kel2, NULL, TRUE, &bias);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 10 */
pixDisplayWithTitle(pixd, 400, 500, NULL, rp->display);
fprintf(stderr, "bias = %d\n", bias);
kernelDestroy(&kel2);
pixDestroy(&pixd);
/* Test bias convolution separable with kel3x and kel3y */
kel3x = kernelCreateFromString(1, 5, 0, 2, kel3xstr);
kel3y = kernelCreateFromString(7, 1, 3, 0, kel3ystr);
pixd = pixConvolveWithBias(pixg, kel3x, kel3y, TRUE, &bias);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 500, 500, NULL, rp->display);
fprintf(stderr, "bias = %d\n", bias);
kernelDestroy(&kel3x);
kernelDestroy(&kel3y);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixg);
/* Test pixWindowedMean() and pixWindowedMeanSquare() on 8 bpp */
pixs = pixRead("feyn-fract2.tif");
pixg = pixConvertTo8(pixs, 0);
sizex = 5;
sizey = 20;
pixb = pixAddBorderGeneral(pixg, sizex + 1, sizex + 1,
sizey + 1, sizey + 1, 0);
pixm = pixWindowedMean(pixb, sizex, sizey, 1, 1);
pixms = pixWindowedMeanSquare(pixb, sizex, sizey, 1);
regTestWritePixAndCheck(rp, pixm, IFF_JFIF_JPEG); /* 12 */
pixDisplayWithTitle(pixm, 100, 0, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pixb);
/* Test pixWindowedVariance() on 8 bpp */
pixWindowedVariance(pixm, pixms, &fpixv, &fpixrv);
pixrv = fpixConvertToPix(fpixrv, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixrv, IFF_JFIF_JPEG); /* 13 */
pixDisplayWithTitle(pixrv, 100, 250, NULL, rp->display);
pix1 = fpixDisplayMaxDynamicRange(fpixv);
pix2 = fpixDisplayMaxDynamicRange(fpixrv);
pixDisplayWithTitle(pix1, 100, 500, "Variance", rp->display);
pixDisplayWithTitle(pix2, 100, 750, "RMS deviation", rp->display);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 14 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 15 */
fpixDestroy(&fpixv);
fpixDestroy(&fpixrv);
pixDestroy(&pixm);
pixDestroy(&pixms);
pixDestroy(&pixrv);
/* Test again all windowed functions with simpler interface */
pixWindowedStats(pixg, sizex, sizey, 0, NULL, NULL, &fpixv, &fpixrv);
pix3 = fpixDisplayMaxDynamicRange(fpixv);
pix4 = fpixDisplayMaxDynamicRange(fpixrv);
regTestComparePix(rp, pix1, pix3); /* 16 */
regTestComparePix(rp, pix2, pix4); /* 17 */
pixDestroy(&pixg);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
fpixDestroy(&fpixv);
fpixDestroy(&fpixrv);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
PIX *pixs;
l_int32 d;
static char mainName[] = "scaletest2";
if (argc != 2)
return ERROR_INT(" Syntax: scaletest2 filein", mainName, 1);
if ((pixs = pixRead(argv[1])) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
d = pixGetDepth(pixs);
#if 1
/* Integer scale-to-gray functions */
if (d == 1)
{
PIX *pixd;
pixd = pixScaleToGray2(pixs);
pixWrite("/tmp/s2g_2x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray3(pixs);
pixWrite("/tmp/s2g_3x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray4(pixs);
pixWrite("/tmp/s2g_4x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray6(pixs);
pixWrite("/tmp/s2g_6x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray8(pixs);
pixWrite("/tmp/s2g_8x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray16(pixs);
pixWrite("/tmp/s2g_16x", pixd, IFF_PNG);
pixDestroy(&pixd);
}
#endif
#if 1
/* Various non-integer scale-to-gray, compared with
* with different ways of getting similar results */
if (d == 1)
{
PIX *pixt, *pixd;
pixd = pixScaleToGray8(pixs);
pixWrite("/tmp/s2g_8.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray(pixs, 0.124);
pixWrite("/tmp/s2g_124.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray(pixs, 0.284);
pixWrite("/tmp/s2g_284.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleBySampling(pixt, 284./250., 284./250.);
pixWrite("/tmp/s2g_284.2.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleGrayLI(pixt, 284./250., 284./250.);
pixWrite("/tmp/s2g_284.3.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleBinary(pixs, 284./250., 284./250.);
pixd = pixScaleToGray4(pixt);
pixWrite("/tmp/s2g_284.4.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleGrayLI(pixt, 0.49, 0.49);
pixWrite("/tmp/s2g_42.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleSmooth(pixt, 0.49, 0.49);
pixWrite("/tmp/s2g_4sm.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleBinary(pixs, .16/.125, .16/.125);
pixd = pixScaleToGray8(pixt);
pixWrite("/tmp/s2g_16.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixd = pixScaleToGray(pixs, .16);
pixWrite("/tmp/s2g_16.2.png", pixd, IFF_PNG);
pixDestroy(&pixd);
}
#endif
#if 1
/* Antialiased (smoothed) reduction, along with sharpening */
if (d != 1)
{
PIX *pixt1, *pixt2;
startTimer();
pixt1 = pixScaleSmooth(pixs, 0.154, 0.154);
fprintf(stderr, "fast scale: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt1, 0, 0, "smooth scaling", DISPLAY);
pixWrite("/tmp/smooth1.png", pixt1, IFF_PNG);
pixt2 = pixUnsharpMasking(pixt1, 1, 0.3);
pixWrite("/tmp/smooth2.png", pixt2, IFF_PNG);
pixDisplayWithTitle(pixt2, 200, 0, "sharp scaling", DISPLAY);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
#endif
#if 1
/* Test a large range of scale-to-gray reductions */
if (d == 1)
{
l_int32 i;
l_float32 scale;
PIX *pixd;
for (i = 2; i < 15; i++) {
scale = 1. / (l_float32)i;
startTimer();
pixd = pixScaleToGray(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 75 * i, 100, "scaletogray", DISPLAY);
pixDestroy(&pixd);
}
for (i = 8; i < 14; i++) {
scale = 1. / (l_float32)(2 * i);
startTimer();
pixd = pixScaleToGray(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 100 * i, 600, "scaletogray", DISPLAY);
pixDestroy(&pixd);
}
}
#endif
#if 1
/* Test the same range of scale-to-gray mipmap reductions */
if (d == 1)
{
l_int32 i;
l_float32 scale;
PIX *pixd;
for (i = 2; i < 15; i++) {
scale = 1. / (l_float32)i;
startTimer();
pixd = pixScaleToGrayMipmap(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 75 * i, 100, "scale mipmap", DISPLAY);
pixDestroy(&pixd);
}
for (i = 8; i < 12; i++) {
scale = 1. / (l_float32)(2 * i);
startTimer();
pixd = pixScaleToGrayMipmap(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 100 * i, 600, "scale mipmap", DISPLAY);
pixDestroy(&pixd);
}
}
#endif
#if 1
/* Test several methods for antialiased reduction,
* along with sharpening */
if (d != 1)
{
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6, *pixt7;
l_float32 SCALING = 0.27;
l_int32 SIZE = 7;
l_int32 smooth;
l_float32 FRACT = 1.0;
smooth = SIZE / 2;
startTimer();
pixt1 = pixScaleSmooth(pixs, SCALING, SCALING);
fprintf(stderr, "fast scale: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt1, 0, 0, "smooth scaling", DISPLAY);
pixWrite("/tmp/sm_1.png", pixt1, IFF_PNG);
pixt2 = pixUnsharpMasking(pixt1, 1, 0.3);
pixDisplayWithTitle(pixt2, 150, 0, "sharpened scaling", DISPLAY);
startTimer();
pixt3 = pixBlockconv(pixs, smooth, smooth);
pixt4 = pixScaleBySampling(pixt3, SCALING, SCALING);
fprintf(stderr, "slow scale: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt4, 200, 200, "sampled scaling", DISPLAY);
pixWrite("/tmp/sm_2.png", pixt4, IFF_PNG);
startTimer();
pixt5 = pixUnsharpMasking(pixs, smooth, FRACT);
pixt6 = pixBlockconv(pixt5, smooth, smooth);
pixt7 = pixScaleBySampling(pixt6, SCALING, SCALING);
fprintf(stderr, "very slow scale + sharp: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt7, 500, 200, "sampled scaling", DISPLAY);
pixWrite("/tmp/sm_3.jpg", pixt7, IFF_JFIF_JPEG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
}
#endif
#if 1
/* Test the color scaling function, comparing the
* special case of scaling factor 2.0 with the
* general case. */
if (d == 32)
{
PIX *pix1, *pix2, *pixd;
NUMA *nar, *nag, *nab, *naseq;
GPLOT *gplot;
startTimer();
pix1 = pixScaleColorLI(pixs, 2.00001, 2.0);
fprintf(stderr, " Time with regular LI: %7.3f\n", stopTimer());
pixWrite("/tmp/color1.jpg", pix1, IFF_JFIF_JPEG);
startTimer();
pix2 = pixScaleColorLI(pixs, 2.0, 2.0);
fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer());
pixWrite("/tmp/color2.jpg", pix2, IFF_JFIF_JPEG);
pixd = pixAbsDifference(pix1, pix2);
pixGetColorHistogram(pixd, 1, &nar, &nag, &nab);
naseq = numaMakeSequence(0., 1., 256);
gplot = gplotCreate("/tmp/plot_absdiff", GPLOT_X11, "Number vs diff",
"diff", "number");
gplotSetScaling(gplot, GPLOT_LOG_SCALE_Y);
gplotAddPlot(gplot, naseq, nar, GPLOT_POINTS, "red");
gplotAddPlot(gplot, naseq, nag, GPLOT_POINTS, "green");
gplotAddPlot(gplot, naseq, nab, GPLOT_POINTS, "blue");
gplotMakeOutput(gplot);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixd);
numaDestroy(&naseq);
numaDestroy(&nar);
numaDestroy(&nag);
numaDestroy(&nab);
gplotDestroy(&gplot);
}
#endif
#if 1
/* Test the gray LI scaling function, comparing the
* special cases of scaling factor 2.0 and 4.0 with the
* general case */
if (d == 8 || d == 32)
{
PIX *pixt, *pix0, *pix1, *pix2, *pixd;
NUMA *nagray, *naseq;
GPLOT *gplot;
if (d == 8)
pixt = pixClone(pixs);
else
pixt = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33);
pix0 = pixScaleGrayLI(pixt, 0.5, 0.5);
#if 1
startTimer();
pix1 = pixScaleGrayLI(pix0, 2.00001, 2.0);
fprintf(stderr, " Time with regular LI 2x: %7.3f\n", stopTimer());
startTimer();
pix2 = pixScaleGrayLI(pix0, 2.0, 2.0);
fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer());
#else
startTimer();
pix1 = pixScaleGrayLI(pix0, 4.00001, 4.0);
fprintf(stderr, " Time with regular LI 4x: %7.3f\n", stopTimer());
startTimer();
pix2 = pixScaleGrayLI(pix0, 4.0, 4.0);
fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer());
#endif
pixWrite("/tmp/gray1", pix1, IFF_JFIF_JPEG);
pixWrite("/tmp/gray2", pix2, IFF_JFIF_JPEG);
pixd = pixAbsDifference(pix1, pix2);
nagray = pixGetGrayHistogram(pixd, 1);
naseq = numaMakeSequence(0., 1., 256);
gplot = gplotCreate("/tmp/g_absdiff", GPLOT_X11, "Number vs diff",
"diff", "number");
gplotSetScaling(gplot, GPLOT_LOG_SCALE_Y);
gplotAddPlot(gplot, naseq, nagray, GPLOT_POINTS, "gray");
gplotMakeOutput(gplot);
pixDestroy(&pixt);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixd);
numaDestroy(&naseq);
numaDestroy(&nagray);
gplotDestroy(&gplot);
}
#endif
pixDestroy(&pixs);
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, j, wc, hc, d;
L_KERNEL *kel1, *kel2;
PIX *pixs, *pixg, *pixacc, *pixd, *pixt;
char *filein, *fileout;
static char mainName[] = "convolvetest";
if (argc != 5)
exit(ERROR_INT(" Syntax: convolvetest filein wc hc fileout", mainName, 1));
filein = argv[1];
wc = atoi(argv[2]);
hc = atoi(argv[3]);
fileout = argv[4];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
#if 0 /* Measure speed */
pixacc = pixBlockconvAccum(pixs);
for (i = 0; i < NTIMES; i++) {
pixd = pixBlockconvGray(pixs, pixacc, wc, hc);
if ((i+1) % 10 == 0)
fprintf(stderr, "%d iters\n", i + 1);
pixDestroy(&pixd);
}
pixd = pixBlockconvGray(pixs, pixacc, wc, hc);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixacc);
#endif
#if 0 /* Test pixBlockconvGray() */
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlockconvGray(pixs, pixacc, wc, hc);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixacc);
#endif
#if 0 /* Test pixBlockconv() */
pixd = pixBlockconv(pixs, wc, hc);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
#endif
#if 0 /* Test pixBlockrank() */
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlockrank(pixs, pixacc, wc, hc, 0.5);
pixWrite(fileout, pixd, IFF_TIFF_G4);
pixDestroy(&pixacc);
#endif
#if 0 /* Test pixBlocksum() */
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlocksum(pixs, pixacc, wc, hc);
pixInvert(pixd, pixd);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixacc);
#endif
#if 0 /* Test pixCensusTransform() */
d = pixGetDepth(pixs);
if (d == 32)
pixt = pixConvertRGBToLuminance(pixs);
else
pixt = pixClone(pixs);
pixacc = pixBlockconvAccum(pixt);
pixd = pixCensusTransform(pixt, wc, NULL);
pixDestroy(&pixt);
pixDestroy(&pixacc);
pixWrite(fileout, pixd, IFF_PNG);
#endif
#if 1 /* Test generic convolution with kel1 */
if (pixGetDepth(pixs) == 32)
pixg = pixScaleRGBToGrayFast(pixs, 2, COLOR_GREEN);
else
pixg = pixScale(pixs, 0.5, 0.5);
pixDisplay(pixg, 0, 600);
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = pixConvolve(pixg, kel1, 8, 1);
pixDisplay(pixd, 700, 0);
pixWrite("/tmp/junkpixd4.bmp", pixd, IFF_BMP);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test convolution with flat rectangular kel */
kel2 = kernelCreate(11, 11);
kernelSetOrigin(kel2, 5, 5);
for (i = 0; i < 11; i++) {
for (j = 0; j < 11; j++)
kernelSetElement(kel2, i, j, 1);
}
startTimer();
pixd = pixConvolve(pixg, kel2, 8, 1);
fprintf(stderr, "Generic convolution: %7.3f sec\n", stopTimer());
pixDisplay(pixd, 1200, 0);
pixWrite("/tmp/junkpixd5.bmp", pixd, IFF_BMP);
startTimer();
pixt = pixBlockconv(pixg, 5, 5);
fprintf(stderr, "Block convolution: %7.3f sec\n", stopTimer());
pixDisplay(pixd, 1200, 600);
pixWrite("/tmp/junkpixd6.bmp", pixt, IFF_BMP);
pixCompareGray(pixd, pixt, L_COMPARE_ABS_DIFF, GPLOT_X11, NULL,
NULL, NULL, NULL);
pixDestroy(&pixg);
pixDestroy(&pixt);
kernelDestroy(&kel2);
#endif
pixDestroy(&pixs);
pixDestroy(&pixd);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, j, wc, hc, d, bias;
L_KERNEL *kel1, *kel2, *kel3x, *kel3y;
PIX *pix, *pixs, *pixg, *pixacc, *pixd, *pixt;
char *filein, *fileout;
static char mainName[] = "convolvetest";
if (argc != 5)
return ERROR_INT(" Syntax: convolvetest filein wc hc fileout",
mainName, 1);
filein = argv[1];
wc = atoi(argv[2]);
hc = atoi(argv[3]);
fileout = argv[4];
if ((pix = pixRead(filein)) == NULL)
return ERROR_INT("pix not made", mainName, 1);
d = pixGetDepth(pix);
if (d != 1 && d != 8 && d != 32)
pixs = pixConvertTo8(pix, 0);
else
pixs = pixClone(pix);
pixDestroy(&pix);
d = pixGetDepth(pixs);
if (d == 8 && (ALL || 0)) {
/* Measure speed */
pixacc = pixBlockconvAccum(pixs);
for (i = 0; i < NTIMES; i++) {
pixd = pixBlockconvGray(pixs, pixacc, wc, hc);
if ((i+1) % 10 == 0)
fprintf(stderr, "%d iters\n", i + 1);
pixDestroy(&pixd);
}
pixd = pixBlockconvGray(pixs, pixacc, wc, hc);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixacc);
}
if (d == 8 && (ALL || 0)) {
/* Test pixBlockconvGray() */
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlockconvGray(pixs, pixacc, wc, hc);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixacc);
}
if (ALL || 0) {
/* Test pixBlockconv() */
pixd = pixBlockconv(pixs, wc, hc);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
}
if (d == 1 && (ALL || 0)) {
/* Test pixBlockrank() */
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlockrank(pixs, pixacc, wc, hc, 0.5);
pixWrite(fileout, pixd, IFF_TIFF_G4);
pixDestroy(&pixacc);
}
if (d == 1 && (ALL || 0)) {
/* Test pixBlocksum() */
pixacc = pixBlockconvAccum(pixs);
pixd = pixBlocksum(pixs, pixacc, wc, hc);
pixInvert(pixd, pixd);
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixacc);
}
if (ALL || 0) {
/* Test pixCensusTransform() */
d = pixGetDepth(pixs);
if (d == 32)
pixt = pixConvertRGBToLuminance(pixs);
else
pixt = pixClone(pixs);
pixacc = pixBlockconvAccum(pixt);
pixd = pixCensusTransform(pixt, wc, NULL);
pixDestroy(&pixt);
pixDestroy(&pixacc);
pixWrite(fileout, pixd, IFF_PNG);
}
if (ALL || 0) {
/* Test generic convolution with kel1 */
lept_mkdir("lept");
if (pixGetDepth(pixs) == 32)
pixg = pixScaleRGBToGrayFast(pixs, 2, COLOR_GREEN);
else
pixg = pixScale(pixs, 0.5, 0.5);
pixDisplay(pixg, 0, 600);
kel1 = kernelCreateFromString(5, 5, 2, 2, kel1str);
pixd = pixConvolve(pixg, kel1, 8, 1);
pixDisplay(pixd, 700, 0);
pixWrite("/tmp/lept/convol_d4.bmp", pixd, IFF_BMP);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test convolution with flat rectangular kel */
kel2 = kernelCreate(11, 11);
kernelSetOrigin(kel2, 5, 5);
for (i = 0; i < 11; i++) {
for (j = 0; j < 11; j++)
kernelSetElement(kel2, i, j, 1);
}
startTimer();
pixd = pixConvolve(pixg, kel2, 8, 1);
fprintf(stderr, "Generic convolution: %7.3f sec\n", stopTimer());
pixDisplay(pixd, 1200, 0);
pixWrite("/tmp/lept/convol_d5.bmp", pixd, IFF_BMP);
startTimer();
pixt = pixBlockconv(pixg, 5, 5);
fprintf(stderr, "Block convolution: %7.3f sec\n", stopTimer());
pixDisplay(pixd, 1200, 600);
pixWrite("/tmp/lept/convol_d6.bmp", pixt, IFF_BMP);
pixCompareGray(pixd, pixt, L_COMPARE_ABS_DIFF, GPLOT_X11, NULL,
NULL, NULL, NULL);
pixDestroy(&pixg);
pixDestroy(&pixt);
kernelDestroy(&kel2);
}
if (ALL || 0) {
/* Test bias convolution with kel2 */
if (pixGetDepth(pixs) == 32)
pixg = pixScaleRGBToGrayFast(pixs, 2, COLOR_GREEN);
else
pixg = pixScale(pixs, 0.5, 0.5);
pixDisplay(pixg, 0, 600);
kel2 = kernelCreateFromString(5, 5, 2, 2, kel2str);
pixd = pixConvolveWithBias(pixg, kel2, NULL, TRUE, &bias);
pixDisplay(pixd, 700, 0);
fprintf(stderr, "bias = %d\n", bias);
pixWrite("/tmp/lept/convol_d6.png", pixd, IFF_PNG);
pixDestroy(&pixg);
kernelDestroy(&kel2);
pixDestroy(&pixd);
}
if (ALL || 1) {
/* Test separable bias convolution with kel3x, kel3y */
if (pixGetDepth(pixs) == 32)
pixg = pixScaleRGBToGrayFast(pixs, 2, COLOR_GREEN);
else
pixg = pixScale(pixs, 0.5, 0.5);
pixDisplay(pixg, 0, 600);
kel3x = kernelCreateFromString(1, 5, 0, 2, kel3xstr);
kel3y = kernelCreateFromString(7, 1, 3, 0, kel3ystr);
pixd = pixConvolveWithBias(pixg, kel3x, kel3y, TRUE, &bias);
pixDisplay(pixd, 700, 0);
fprintf(stderr, "bias = %d\n", bias);
pixWrite("/tmp/lept/convol_d7.png", pixd, IFF_PNG);
pixDestroy(&pixg);
kernelDestroy(&kel3x);
kernelDestroy(&kel3y);
pixDestroy(&pixd);
}
pixDestroy(&pixs);
return 0;
}
