/*!
* boxaTransform()
*
* Input: boxa
* shiftx, shifty
* scalex, scaley
* Return: boxad, or null on error
*
* Notes:
* (1) This is a very simple function that first shifts, then scales.
*/
BOXA *
boxaTransform(BOXA *boxas,
l_int32 shiftx,
l_int32 shifty,
l_float32 scalex,
l_float32 scaley)
{
l_int32 i, n;
BOX *boxs, *boxd;
BOXA *boxad;
PROCNAME("boxaTransform");
if (!boxas)
return (BOXA *)ERROR_PTR("boxas not defined", procName, NULL);
n = boxaGetCount(boxas);
if ((boxad = boxaCreate(n)) == NULL)
return (BOXA *)ERROR_PTR("boxad not made", procName, NULL);
for (i = 0; i < n; i++) {
if ((boxs = boxaGetBox(boxas, i, L_CLONE)) == NULL)
return (BOXA *)ERROR_PTR("boxs not found", procName, NULL);
boxd = boxTransform(boxs, shiftx, shifty, scalex, scaley);
boxDestroy(&boxs);
boxaAddBox(boxad, boxd, L_INSERT);
}
return boxad;
}
/*!
* pixFindPageForeground()
*
* Input: pixs (full resolution (any type or depth)
* threshold (for binarization; typically about 128)
* mindist (min distance of text from border to allow
* cleaning near border; at 2x reduction, this
* should be larger than 50; typically about 70)
* erasedist (when conditions are satisfied, erase anything
* within this distance of the edge;
* typically 30 at 2x reduction)
* pagenum (use for debugging when called repeatedly; labels
* debug images that are assembled into pdfdir)
* showmorph (set to a negative integer to show steps in
* generating masks; this is typically used
* for debugging region extraction)
* display (set to 1 to display mask and selected region
* for debugging a single page)
* pdfdir (subdirectory of /tmp where images showing the
* result are placed when called repeatedly; use
* null if no output requested)
* Return: box (region including foreground, with some pixel noise
* removed), or null if not found
*
* Notes:
* (1) This doesn't simply crop to the fg. It attempts to remove
* pixel noise and junk at the edge of the image before cropping.
* The input @threshold is used if pixs is not 1 bpp.
* (2) There are several debugging options, determined by the
* last 4 arguments.
* (3) If you want pdf output of results when called repeatedly,
* the pagenum arg labels the images written, which go into
* /tmp/<pdfdir>/<pagenum>.png. In that case,
* you would clean out the /tmp directory before calling this
* function on each page:
* lept_rmdir(pdfdir);
* lept_mkdir(pdfdir);
*/
BOX *
pixFindPageForeground(PIX *pixs,
l_int32 threshold,
l_int32 mindist,
l_int32 erasedist,
l_int32 pagenum,
l_int32 showmorph,
l_int32 display,
const char *pdfdir)
{
char buf[64];
l_int32 flag, nbox, intersects;
l_int32 w, h, bx, by, bw, bh, left, right, top, bottom;
PIX *pixb, *pixb2, *pixseed, *pixsf, *pixm, *pix1, *pixg2;
BOX *box, *boxfg, *boxin, *boxd;
BOXA *ba1, *ba2;
PROCNAME("pixFindPageForeground");
if (!pixs)
return (BOX *)ERROR_PTR("pixs not defined", procName, NULL);
/* Binarize, downscale by 0.5, remove the noise to generate a seed,
* and do a seedfill back from the seed into those 8-connected
* components of the binarized image for which there was at least
* one seed pixel. Also clear out any components that are within
* 10 pixels of the edge at 2x reduction. */
flag = (showmorph) ? -1 : 0; /* if showmorph == -1, write intermediate
* images to /tmp/seq_output_1.pdf */
pixb = pixConvertTo1(pixs, threshold);
pixb2 = pixScale(pixb, 0.5, 0.5);
pixseed = pixMorphSequence(pixb2, "o1.2 + c9.9 + o3.5", flag);
pixsf = pixSeedfillBinary(NULL, pixseed, pixb2, 8);
pixSetOrClearBorder(pixsf, 10, 10, 10, 10, PIX_SET);
pixm = pixRemoveBorderConnComps(pixsf, 8);
if (display) pixDisplay(pixm, 100, 100);
/* Now, where is the main block of text? We want to remove noise near
* the edge of the image, but to do that, we have to be convinced that
* (1) there is noise and (2) it is far enough from the text block
* and close enough to the edge. For each edge, if the block
* is more than mindist from that edge, then clean 'erasedist'
* pixels from the edge. */
pix1 = pixMorphSequence(pixm, "c50.50", flag - 1);
ba1 = pixConnComp(pix1, NULL, 8);
ba2 = boxaSort(ba1, L_SORT_BY_AREA, L_SORT_DECREASING, NULL);
pixGetDimensions(pix1, &w, &h, NULL);
nbox = boxaGetCount(ba2);
if (nbox > 1) {
box = boxaGetBox(ba2, 0, L_CLONE);
boxGetGeometry(box, &bx, &by, &bw, &bh);
left = (bx > mindist) ? erasedist : 0;
right = (w - bx - bw > mindist) ? erasedist : 0;
top = (by > mindist) ? erasedist : 0;
bottom = (h - by - bh > mindist) ? erasedist : 0;
pixSetOrClearBorder(pixm, left, right, top, bottom, PIX_CLR);
boxDestroy(&box);
}
pixDestroy(&pix1);
boxaDestroy(&ba1);
boxaDestroy(&ba2);
/* Locate the foreground region; don't bother cropping */
pixClipToForeground(pixm, NULL, &boxfg);
/* Sanity check the fg region. Make sure it's not confined
* to a thin boundary on the left and right sides of the image,
* in which case it is likely to be noise. */
if (boxfg) {
boxin = boxCreate(0.1 * w, 0, 0.8 * w, h);
boxIntersects(boxfg, boxin, &intersects);
if (!intersects) {
L_INFO("found only noise on page %d\n", procName, pagenum);
boxDestroy(&boxfg);
}
boxDestroy(&boxin);
}
boxd = NULL;
if (!boxfg) {
L_INFO("no fg region found for page %d\n", procName, pagenum);
} else {
boxAdjustSides(boxfg, boxfg, -2, 2, -2, 2); /* tiny expansion */
boxd = boxTransform(boxfg, 0, 0, 2.0, 2.0);
/* Write image showing box for this page. This is to be
* bundled up into a pdf of all the pages, which can be
* generated by convertFilesToPdf() */
if (pdfdir) {
pixg2 = pixConvert1To4Cmap(pixb);
pixRenderBoxArb(pixg2, boxd, 3, 255, 0, 0);
snprintf(buf, sizeof(buf), "/tmp/%s/%05d.png", pdfdir, pagenum);
if (display) pixDisplay(pixg2, 700, 100);
pixWrite(buf, pixg2, IFF_PNG);
pixDestroy(&pixg2);
}
}
pixDestroy(&pixb);
pixDestroy(&pixb2);
pixDestroy(&pixseed);
pixDestroy(&pixsf);
pixDestroy(&pixm);
boxDestroy(&boxfg);
return boxd;
}
void createActors()
{
// Create Material
physx::PxMaterial* cubeMaterial = gPhysicsSDK->createMaterial(0.5f, 0.5f, 0.5f);
physx::PxMaterial* sphereMaterial = gPhysicsSDK->createMaterial(0.6f, 0.1f, 0.6f);
physx::PxMaterial* planeMaterial = gPhysicsSDK->createMaterial(0.5f, 0.5f, 0.5f);
// Create Floor
physx::PxReal d = 0.0f;
physx::PxTransform pose = physx::PxTransform( physx::PxVec3( 0.0f, 0, 0.0f ), physx::PxQuat( physx::PxHalfPi, physx::PxVec3( 0.0f, 0.0f, 1.0f )));
physx::PxRigidStatic* plane = gPhysicsSDK->createRigidStatic(pose);
if (!plane)
std::cerr << "create plane failed!" << std::endl;
physx::PxShape* shape = plane->createShape(physx::PxPlaneGeometry(), *planeMaterial);
if (!shape)
std::cerr << "create shape failed!" << std::endl;
gScene->addActor(*plane);
float gap_x = box_size.x * 2.0f;
float gap_y = box_size.y * 2.0f;
// Create boxes
if(total_boxes > 0)
{
physx::PxReal density = 1.0f;
physx::PxTransform boxTransform(physx::PxVec3(0.0f, 0.0f, 0.0f));
physx::PxBoxGeometry boxGeometry(box_size);
for(float i = -box_grid_width/2.0f; i < box_grid_width/2.0f; ++i)
{
for(unsigned int j = 0; j < box_grid_height; ++j)
{
boxTransform.p = physx::PxVec3((i * gap_x) + 1.0f, (j * gap_y) + 1.0f, 0.0f);
physx::PxRigidDynamic *boxActor = PxCreateDynamic(*gPhysicsSDK, boxTransform, boxGeometry, *cubeMaterial, density);
if (!boxActor)
std::cerr << "create actor failed!" << std::endl;
boxActor->setAngularDamping(0.75f);
boxActor->setLinearDamping(0.01f);
boxActor->setMass(10.0f);
gScene->addActor(*boxActor);
boxes_actors.push_back(boxActor);
}
}
}
// Create spheres
if(total_spheres > 0)
{
physx::PxReal density = 2.0f;
physx::PxTransform sphereTransform(physx::PxVec3(0.0f, 0.0f, 0.0f));
physx::PxSphereGeometry sphereGeometry(sphere_radius);
for(unsigned int i = 0; i < total_spheres; ++i)
{
sphereTransform.p = physx::PxVec3(0.0f, 0.0f, -30.0f);
physx::PxRigidDynamic *sphereActor = PxCreateDynamic(*gPhysicsSDK, sphereTransform, sphereGeometry, *sphereMaterial, density);
if (!sphereActor)
std::cerr << "create actor failed!" << std::endl;
sphereActor->setAngularDamping(0.2f);
sphereActor->setLinearDamping(0.1f);
sphereActor->setMass(5.0f);
sphereActor->setLinearVelocity(physx::PxVec3(1.3f, box_grid_height * 2, 60.0f));
gScene->addActor(*sphereActor);
spheres_actors.push_back(sphereActor);
}
}
}
