/*! * pixReadIndexed() * * Input: sarray (of full pathnames) * index (into pathname array) * Return: pix if OK; null if not found * * Notes: * (1) This function is useful for selecting image files from a * directory, where the integer @index is embedded into * the file name. * (2) This is typically done by generating the sarray using * getNumberedPathnamesInDirectory(), so that the @index * pathname would have the number @index in it. The size * of the sarray should be the largest number (plus 1) appearing * in the file names, respecting the constraints in the * call to getNumberedPathnamesInDirectory(). * (3) Consequently, for some indices into the sarray, there may * be no pathnames in the directory containing that number. * By convention, we place empty C strings ("") in those * locations in the sarray, and it is not an error if such * a string is encountered and no pix is returned. * Therefore, the caller must verify that a pix is returned. * (4) See convertSegmentedPagesToPS() in src/psio1.c for an * example of usage. */ PIX * pixReadIndexed(SARRAY *sa, l_int32 index) { char *fname; l_int32 n; PIX *pix; PROCNAME("pixReadIndexed"); if (!sa) return (PIX *)ERROR_PTR("sa not defined", procName, NULL); n = sarrayGetCount(sa); if (index < 0 || index >= n) return (PIX *)ERROR_PTR("index out of bounds", procName, NULL); fname = sarrayGetString(sa, index, L_NOCOPY); if (fname[0] == '\0') return NULL; if ((pix = pixRead(fname)) == NULL) { L_ERROR("pix not read from file %s\n", procName, fname); return NULL; } return pix; }
/*! * pixReadMemJp2k() * * Input: data (const; jpeg-encoded) * size (of data) * reduction (scaling factor: 1, 2, 4, 8) * box (<optional> for extracting a subregion), can be null * hint (a bitwise OR of L_JP2K_* values; 0 for default) * debug (output callback messages, etc) * Return: pix, or null on error * * Notes: * (1) This crashes when reading through the fmemopen cookie. * Until we can fix this, we use the file-based work-around. * And fixing this may take some time, because the basic * stream interface is no longer supported in openjpeg. * (2) See pixReadJp2k() for usage. */ PIX * pixReadMemJp2k(const l_uint8 *data, size_t size, l_uint32 reduction, BOX *box, l_int32 hint, l_int32 debug) { FILE *fp; PIX *pix; PROCNAME("pixReadMemJp2k"); if (!data) return (PIX *)ERROR_PTR("data not defined", procName, NULL); #if 0 /* Avoid the crash for now */ if ((fp = fmemopen((void *)data, size, "r")) == NULL) return (PIX *)ERROR_PTR("stream not opened", procName, NULL); #else L_WARNING("work-around: writing to a temp file\n", procName); if ((fp = tmpfile()) == NULL) return (PIX *)ERROR_PTR("tmpfile stream not opened", procName, NULL); fwrite(data, 1, size, fp); rewind(fp); #endif /* HAVE_FMEMOPEN */ pix = pixReadStreamJp2k(fp, reduction, box, hint, debug); fclose(fp); if (!pix) L_ERROR("pix not read\n", procName); return pix; }
/*! * pixReadRGBAPng() * * Input: filename (of png file) * Return: pix, or null on error * * Notes: * (1) Wrapper to keep the alpha channel of a png, if it exists. * (2) The default behavior of pix read functions is to ignore * the alpha channel. * (3) This always leaves alpha stripping in the same mode as * when this function begins. So if alpha stripping is in * default mode, this disables it, reads the file (including * the alpha channel), and resets back to stripping. Otherwise, * it leaves stripping disabled. */ PIX * pixReadRGBAPng(const char *filename) { l_int32 format; PIX *pix; PROCNAME("pixReadRGBAPng"); if (!filename) return (PIX *)ERROR_PTR("filename not defined", procName, NULL); /* Make sure it's a png file */ findFileFormat(filename, &format); if (format != IFF_PNG) { L_ERROR_STRING("file format is %s, not png", procName, ImageFileFormatExtensions[format]); return NULL; } /* If alpha channel reading is enabled, just read it */ if (var_PNG_STRIP_ALPHA == FALSE) return pixRead(filename); l_pngSetStripAlpha(0); pix = pixRead(filename); l_pngSetStripAlpha(1); /* reset to default */ if (!pix) L_ERROR("pix not read", procName); return pix; }
/*! * recogaReadStream() * * Input: stream * Return: recog, or null on error */ L_RECOGA * recogaReadStream(FILE *fp) { l_int32 version, i, nrec, ignore; L_RECOG *recog; L_RECOGA *recoga; PROCNAME("recogaReadStream"); if (!fp) return (L_RECOGA *)ERROR_PTR("stream not defined", procName, NULL); if (fscanf(fp, "\nRecoga Version %d\n", &version) != 1) return (L_RECOGA *)ERROR_PTR("not a recog file", procName, NULL); if (version != RECOG_VERSION_NUMBER) return (L_RECOGA *)ERROR_PTR("invalid recog version", procName, NULL); if (fscanf(fp, "Number of recognizers = %d\n\n", &nrec) != 1) return (L_RECOGA *)ERROR_PTR("nrec not read", procName, NULL); recoga = recogaCreate(nrec); for (i = 0; i < nrec; i++) { ignore = fscanf(fp, "==============================\n"); if (fscanf(fp, "Recognizer %d\n", &ignore) != 1) return (L_RECOGA *)ERROR_PTR("malformed file", procName, NULL); if ((recog = recogReadStream(fp)) == NULL) { recogaDestroy(&recoga); L_ERROR("recog read failed for recog %d\n", procName, i); return NULL; } ignore = fscanf(fp, "\n"); recogaAddRecog(recoga, recog); } return recoga; }
/** * Creates a new instance of the DataAccess class. Only one static connection * is made to the database in each program using this class, which is shared by * all instances. It is important to abort or commit transactions when they are * finished with to prevent database deadlock. */ DataAccess::DataAccess() { const char* routine = "DataAccess::DataAccess"; // For each instance increment counter. We can only close the connection // when the last instance is destroyed. DataAccess::instanceCount++; // If this is the first instance create the connection to database if (DataAccess::instanceCount == 1) { try { // Create connection C = new PqxxConnection( getConnectionString() ); L_INFO(LOG_DB,"Connected to database " + std::string(C->dbname())); L_INFO(LOG_DB," -> Backend version: " + dps_itoa(C->server_version())); L_INFO(LOG_DB," -> Protocal version: " + dps_itoa(C->protocol_version())); // Init the transaction mutex t_routine_mutex = new pthread_mutex_t; pthread_mutex_init(t_routine_mutex,NULL); W = 0; } catch (const std::exception &e) { L_ERROR(LOG_DB,"Exception: " + std::string(e.what())); throw; } catch (...) { // Whoops! We can't connect to the DB L_CRITICAL(LOG_DB,"An unexpected error occured"); throw; } } }
/*! * \brief pixReadMemJpeg() * * \param[in] data const; jpeg-encoded * \param[in] size of data * \param[in] cmflag colormap flag 0 means return RGB image if color; * 1 means create a colormap and return * an 8 bpp colormapped image if color * \param[in] reduction scaling factor: 1, 2, 4 or 8 * \param[out] pnwarn [optional] number of warnings * \param[in] hint a bitwise OR of L_JPEG_* values; 0 for default * \return pix, or NULL on error * * <pre> * Notes: * (1) The %size byte of %data must be a null character. * (2) The only hint flag so far is L_JPEG_READ_LUMINANCE, * given in the enum in imageio.h. * (3) See pixReadJpeg() for usage. * </pre> */ PIX * pixReadMemJpeg(const l_uint8 *data, size_t size, l_int32 cmflag, l_int32 reduction, l_int32 *pnwarn, l_int32 hint) { l_int32 ret; l_uint8 *comment; FILE *fp; PIX *pix; PROCNAME("pixReadMemJpeg"); if (pnwarn) *pnwarn = 0; if (!data) return (PIX *)ERROR_PTR("data not defined", procName, NULL); if ((fp = fopenReadFromMemory(data, size)) == NULL) return (PIX *)ERROR_PTR("stream not opened", procName, NULL); pix = pixReadStreamJpeg(fp, cmflag, reduction, pnwarn, hint); if (pix) { ret = fgetJpegComment(fp, &comment); if (!ret && comment) { pixSetText(pix, (char *)comment); LEPT_FREE(comment); } } fclose(fp); if (!pix) L_ERROR("pix not read\n", procName); return pix; }
/*! * kernelNormalize() * * Input: kels (source kel, to be normalized) * normsum (desired sum of elements in keld) * Return: keld (normalized version of kels), or null on error * or if sum of elements is very close to 0) * * Notes: * (1) If the sum of kernel elements is close to 0, do not * try to calculate the normalized kernel. Instead, * return a copy of the input kernel, with an error message. */ L_KERNEL * kernelNormalize(L_KERNEL *kels, l_float32 normsum) { l_int32 i, j, sx, sy, cx, cy; l_float32 sum, factor; L_KERNEL *keld; PROCNAME("kernelNormalize"); if (!kels) return (L_KERNEL *)ERROR_PTR("kels not defined", procName, NULL); kernelGetSum(kels, &sum); if (L_ABS(sum) < 0.01) { L_ERROR("null sum; not normalizing; returning a copy", procName); return kernelCopy(kels); } kernelGetParameters(kels, &sy, &sx, &cy, &cx); if ((keld = kernelCreate(sy, sx)) == NULL) return (L_KERNEL *)ERROR_PTR("keld not made", procName, NULL); keld->cy = cy; keld->cx = cx; factor = normsum / sum; for (i = 0; i < sy; i++) for (j = 0; j < sx; j++) keld->data[i][j] = factor * kels->data[i][j]; return keld; }
static node *uncle(node *n) { if (!n || !n->parent || !n->parent->parent) { L_ERROR("root and child of root have no uncle\n", "uncle"); return NULL; } return sibling(n->parent); }
/*! * \brief pixReadStreamGif() * * \param[in] fp file stream * \return pix, or NULL on error */ PIX * pixReadStreamGif(FILE *fp) { l_int32 fd; GifFileType *gif; PROCNAME("pixReadStreamGif"); #if GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 1 && GIFLIB_RELEASE == 2 /* 5.1.2 */ L_ERROR("Can't use giflib-5.1.2; suggest 5.1.1 or earlier\n", procName); return NULL; #endif /* 5.1.2 */ if ((fd = fileno(fp)) < 0) return (PIX *)ERROR_PTR("invalid file descriptor", procName, NULL); #ifdef _WIN32 fd = _dup(fd); #endif /* _WIN32 */ #ifndef _MSC_VER lseek(fd, 0, SEEK_SET); #else _lseek(fd, 0, SEEK_SET); #endif /* _MSC_VER */ if ((gif = DGifOpenFileHandle(fd, NULL)) == NULL) return (PIX *)ERROR_PTR("invalid file or file not found", procName, NULL); return gifToPix(gif); }
void Task::init() { L_FUNC(""); L_INFO("+++ test Logger"); L_FATAL("L_FATAL"); L_ERROR("L_ERROR"); L_WARN("L_WARN"); L_INFO("L_INFO"); L_DEBUG("L_DEBUG"); L_INFO("--- test Logger"); L_INFO(QString()); // --> "?" L_INFO(" \n Trimmed \n\n"); // --> whitespace removed from start and end L_INFO("UTF-8 Unicode text: äöü à éè"); QString formattedOutput1 = "JSON output 1:\n" "{\n" " \"firstName\": \"Mario\",\n" " \"age\": 44\n" "}" ; L_INFO(formattedOutput1); QString formattedOutput2 = "{<br> \"firstName\": \"Mario\",<br> \"age\": 44<br>}"; L_INFO(formattedOutput2.prepend("JSON output 2:<br>").replace("<br>", "\n")); QTimer::singleShot(1000, this, SLOT(slotRun())); QTimer::singleShot(1000, this, SLOT(slotRun())); QTimer::singleShot(3000, this, SLOT(slotRun())); QTimer::singleShot(6000, this, SLOT(theEnd())); }
/* ------------------------------------------------------------- * * Static red-black tree helpers * * ------------------------------------------------------------- */ static node *grandparent(node *n) { if (!n || !n->parent || !n->parent->parent) { L_ERROR("root and child of root have no grandparent\n", "grandparent"); return NULL; } return n->parent->parent; }
/** copies data from the head of the queue into passed buffer. * * if data from the head of the queue copied successfully * removes head of the queue. \n * if head of the queue was not removed successfully * logs warning. * * @param _root root node of the queue * @param _data buffer in which head's data would be copied * @param _size passed buffer size * * @return #true if successfully poped \n * #false otherwise * * @see d_list_get_head * @see d_list_remove_head */ bool d_queue_pop(QUEUE_ROOT* _root, void* _data, size_t _size) { /* #ifdef _DEBUG */ /* L_DEBUG( "0x%08x\n", _root ); */ /* #endif */ if ( !_root ) { L_ERROR( "_root == NULL\n", "" ); return false; } if ( d_list_get_head((LIST_ROOT*)_root, _data, _size) ) { if ( !d_list_remove_head((LIST_ROOT*)_root) ) { // pointer moved anyway // just let developers know that here is memleaks L_WARN( "unable to remove QUEUE_HEAD\n", "" ); } return true; } return false; }
/*! * recogStringToIndex() * * Input: recog * text (text string for some class) * &index (<return> index for that class; -1 if not found) * Return: 0 if OK, 1 on error (not finding the string is an error) */ l_int32 recogStringToIndex(L_RECOG *recog, char *text, l_int32 *pindex) { char *charstr; l_int32 i, n, diff; PROCNAME("recogStringtoIndex"); if (!pindex) return ERROR_INT("&index not defined", procName, 1); *pindex = -1; if (!recog) return ERROR_INT("recog not defined", procName, 1); if (!text) return ERROR_INT("text not defined", procName, 1); /* Search existing characters */ n = recog->setsize; for (i = 0; i < n; i++) { recogGetClassString(recog, i, &charstr); if (!charstr) { L_ERROR("string not found for index %d\n", procName, i); continue; } diff = strcmp(text, charstr); FREE(charstr); if (diff) continue; *pindex = i; return 0; } return 1; /* not found */ }
/** deinitializes #LIST_ROOT. * * removes all nodes in the list (by calling #d_list_remove_head) * and zeroes passed pointer to the #LIST_ROOT * * logs warning if #d_list_remove_head was not successfully done * * @param _root pointer to the root node * * @return currently #true in case of non-null pointer \n * #false otherwise */ bool d_list_deinit(LIST_ROOT* _root) { /* #ifdef _DEBUG */ /* L_DEBUG( "0x%08x\n", _root ); */ /* #endif */ if ( !_root ) { L_ERROR( "_root == NULL\n", "" ); return false; } bool clr = true; while ( _root->count ) { clr &= d_list_remove_head( _root ); } if ( !clr ) { L_WARN( "memleaks are possible\n", "" ); } memset( _root, 0, sizeof(_root) ); return true; }
/*! * boxaEncapsulateAligned() * * Input: boxa * num (number put into each boxa in the baa) * copyflag (L_COPY or L_CLONE) * Return: boxaa, or null on error * * Notes: * (1) This puts @num boxes from the input @boxa into each of a * set of boxa within an output boxaa. * (2) This assumes that the boxes in @boxa are in sets of @num each. */ BOXAA * boxaEncapsulateAligned(BOXA *boxa, l_int32 num, l_int32 copyflag) { l_int32 i, j, n, nbaa, index; BOX *box; BOXA *boxat; BOXAA *baa; PROCNAME("boxaEncapsulateAligned"); if (!boxa) return (BOXAA *)ERROR_PTR("boxa not defined", procName, NULL); if (copyflag != L_COPY && copyflag != L_CLONE) return (BOXAA *)ERROR_PTR("invalid copyflag", procName, NULL); n = boxaGetCount(boxa); nbaa = (n + num - 1) / num; if (n / num != nbaa) L_ERROR("inconsistent alignment: n / num not an integer", procName); baa = boxaaCreate(nbaa); for (i = 0, index = 0; i < nbaa; i++) { boxat = boxaCreate(num); for (j = 0; j < num; j++, index++) { box = boxaGetBox(boxa, index, copyflag); boxaAddBox(boxat, box, L_INSERT); } boxaaAddBoxa(baa, boxat, L_INSERT); } return baa; }
/*! * recogaDestroy() * * Input: &recoga (<will be set to null before returning>) * Return: void * * Notes: * (1) If a recog has a parent, the parent owns it. To destroy * a recog, it must first be "orphaned". */ void recogaDestroy(L_RECOGA **precoga) { l_int32 i; L_RECOG *recog; L_RECOGA *recoga; PROCNAME("recogaDestroy"); if (precoga == NULL) { L_WARNING("ptr address is null!\n", procName); return; } if ((recoga = *precoga) == NULL) return; rchaDestroy(&recoga->rcha); for (i = 0; i < recoga->n; i++) { if ((recog = recoga->recog[i]) == NULL) { L_ERROR("recog not found for index %d\n", procName, i); continue; } recog->parent = NULL; /* orphan it */ recogDestroy(&recog); } LEPT_FREE(recoga->recog); LEPT_FREE(recoga); *precoga = NULL; return; }
/*! * dewarpaRestoreModels() * * Input: dewa (populated with dewarp structs for pages) * Return: 0 if OK, 1 on error * * Notes: * (1) This puts all real models (and only real models) in the * primary dewarp array. First remove all dewarps that are * only references to other page models. Then move all models * that had been cached back into the primary dewarp array. * (2) After this is done, we still need to recompute and insert * the reference models before dewa->modelsready is true. */ l_int32 dewarpaRestoreModels(L_DEWARPA *dewa) { l_int32 i; L_DEWARP *dew; PROCNAME("dewarpaRestoreModels"); if (!dewa) return ERROR_INT("dewa not defined", procName, 1); /* Strip out ref models. Then only real models will be in the * primary dewarp array. */ dewarpaStripRefModels(dewa); /* The cache holds only real models, which are not necessarily valid. */ for (i = 0; i <= dewa->maxpage; i++) { if ((dew = dewa->dewarpcache[i]) != NULL) { if (dewa->dewarp[i]) { L_ERROR("dew in both cache and main array!: page %d\n", procName, i); } else { dewa->dewarp[i] = dew; dewa->dewarpcache[i] = NULL; } } } dewa->modelsready = 0; /* new ref models not yet inserted */ /* Regenerate the page lists */ dewarpaListPages(dewa); return 0; }
/* * pushNewPixel() * * Input: lqueue * x, y (pixel coordinates) * &minx, &maxx, &miny, &maxy (<return> bounding box update) * Return: void * * Notes: * (1) This is a wrapper for adding a NewPixel to a queue, which * updates the bounding box for all pixels on that queue and * uses the storage stack to retrieve a NewPixel. */ static void pushNewPixel(L_QUEUE *lq, l_int32 x, l_int32 y, l_int32 *pminx, l_int32 *pmaxx, l_int32 *pminy, l_int32 *pmaxy) { L_NEWPIXEL *np; PROCNAME("pushNewPixel"); if (!lq) { L_ERROR("queue not defined\n", procName); return; } /* Adjust bounding box */ *pminx = L_MIN(*pminx, x); *pmaxx = L_MAX(*pmaxx, x); *pminy = L_MIN(*pminy, y); *pmaxy = L_MAX(*pmaxy, y); /* Get a newpixel to use */ if (lstackGetCount(lq->stack) > 0) np = (L_NEWPIXEL *)lstackRemove(lq->stack); else np = (L_NEWPIXEL *)CALLOC(1, sizeof(L_NEWPIXEL)); np->x = x; np->y = y; lqueueAdd(lq, np); return; }
/** * Aborts any changes to the database in the last transaction and unlocks the * transaction lock. */ void DataAccess::abort(std::string name) { const char* routine = "DataAccess::abort"; // Lock routine mutex pthread_mutex_lock(t_routine_mutex); // If we abort a different transaction, we must be stupid if (transActive && transName != name) { pthread_mutex_unlock(t_routine_mutex); L_ERROR(LOG_DB,"Attempted to abort the wrong transaction!"); L_ERROR(LOG_DB,"Tried to abort " + name + " while " + transName + " is still active."); return; } // We're kind, so we'll let it pass if someone tries to abort a transaction // which doesn't exist. if (!W) { pthread_mutex_unlock(t_routine_mutex); return; } // Try to abort the transaction try { L_INFO(LOG_DB,"Aborting transaction '" + transName + "'"); W->abort(); } catch (const std::exception &e) { pthread_mutex_unlock(t_routine_mutex); L_ERROR(LOG_DB,"Exception: " + std::string(e.what())); throw -1; } catch (...) { pthread_mutex_unlock(t_routine_mutex); L_CRITICAL(LOG_DB,"Unexpected exception."); throw -1; } // Delete Work and set pointer to null delete W; W = 0; transActive = false; transName = ""; // Unlock routine mutex pthread_mutex_unlock(t_routine_mutex); }
void GLThreadCheck::check() { try { GL_thread->do_check(); } catch(WrongThreadError& e) { L_ERROR("Tried to call OpenGL dependent code from the wrong thread"); throw; } }
/* * l_rbtreePrint() * * Input: stream * t (rbtree) * Return: null */ void l_rbtreePrint(FILE *fp, L_RBTREE *t) { PROCNAME("l_rbtreePrint"); if (!fp) { L_ERROR("stream not defined\n", procName); return; } if (!t) { L_ERROR("tree not defined\n", procName); return; } print_tree_helper(fp, t->root, t->keytype, 0); fprintf(fp, "\n"); }
/** * Commits any changes to the database in the last transaction and unlocks the * transaction lock. */ void DataAccess::commit(std::string name) { const char* routine = "DataAccess::commit"; // Lock routine mutex pthread_mutex_lock(t_routine_mutex); // If we commit a different transaction, we must be stupid if (transActive && transName != name) { L_ERROR(LOG_DB,"Attempted to commit the wrong transaction!"); L_ERROR(LOG_DB,"Tried to commit " + name + " while " + transName + " is still active."); pthread_mutex_unlock(t_routine_mutex); return; } // We shouldn't try to commit when we've not done anything. Stupid. if (!W) { pthread_mutex_unlock(t_routine_mutex); throw -1; } // Try to commit the transaction try { L_INFO(LOG_DB,"Committing transaction '" + transName + "'"); W->commit(); } catch (const std::exception &e) { pthread_mutex_unlock(t_routine_mutex); L_ERROR(LOG_DB,"Exception: " + std::string(e.what())); throw -1; } catch (...) { pthread_mutex_unlock(t_routine_mutex); L_CRITICAL(LOG_DB,"Unexpected exception."); throw -1; } // Clean up Work and set pointer null delete W; W = 0; transActive = false; transName = ""; // Unlock routine mutex pthread_mutex_unlock(t_routine_mutex); }
static void verify_property_1(node *n) { if (node_color(n) != L_RED_NODE && node_color(n) != L_BLACK_NODE) { L_ERROR("color neither RED nor BLACK\n", "verify_property_1"); return; } if (n == NULL) return; verify_property_1(n->left); verify_property_1(n->right); }
/*! * \brief pixCountConnComp() * * \param[in] pixs 1 bpp * \param[in] connectivity 4 or 8 * \param[out] pcount * \return 0 if OK, 1 on error * * Notes: * (1 This is the top-level call for getting the number of * 4- or 8-connected components in a 1 bpp image. * 2 It works on a copy of the input pix. The c.c. are located * in raster order and erased one at a time. */ l_int32 pixCountConnComp(PIX *pixs, l_int32 connectivity, l_int32 *pcount) { l_int32 h, iszero; l_int32 x, y, xstart, ystart; PIX *pixt; L_STACK *stack, *auxstack; PROCNAME("pixCountConnComp"); if (!pcount) return ERROR_INT("&count not defined", procName, 1); *pcount = 0; /* initialize the count to 0 */ if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs not defined or not 1 bpp", procName, 1); if (connectivity != 4 && connectivity != 8) return ERROR_INT("connectivity not 4 or 8", procName, 1); pixt = NULL; stack = NULL; pixZero(pixs, &iszero); if (iszero) return 0; if ((pixt = pixCopy(NULL, pixs)) == NULL) return ERROR_INT("pixt not made", procName, 1); h = pixGetHeight(pixs); if ((stack = lstackCreate(h)) == NULL) { L_ERROR("stack not made\n", procName); goto cleanup; } auxstack = lstackCreate(0); stack->auxstack = auxstack; xstart = 0; ystart = 0; while (1) { if (!nextOnPixelInRaster(pixt, xstart, ystart, &x, &y)) break; pixSeedfill(pixt, stack, x, y, connectivity); (*pcount)++; xstart = x; ystart = y; } /* Cleanup, freeing the fillsegs on each stack */ cleanup: lstackDestroy(&stack, TRUE); pixDestroy(&pixt); return 0; }
static void delete_case6(L_RBTREE *t, node *n) { sibling(n)->color = node_color(n->parent); n->parent->color = L_BLACK_NODE; if (n == n->parent->left) { if (node_color(sibling(n)->right) != L_RED_NODE) { L_ERROR("right sibling is not RED", "delete_case6"); return; } sibling(n)->right->color = L_BLACK_NODE; rotate_left(t, n->parent); } else { if (node_color(sibling(n)->left) != L_RED_NODE) { L_ERROR("left sibling is not RED", "delete_case6"); return; } sibling(n)->left->color = L_BLACK_NODE; rotate_right(t, n->parent); } }
static node *maximum_node(node *n) { if (!n) { L_ERROR("n not defined\n", "maximum_node"); return NULL; } while (n->right != NULL) { n = n->right; } return n; }
static node *sibling(node *n) { if (!n || !n->parent) { L_ERROR("root has no sibling\n", "sibling"); return NULL; } if (n == n->parent->left) return n->parent->right; else return n->parent->left; }
/*! * l_pngSetZlibCompression() * * Input: val (zlib compression value) * Return: void * * Notes: * (1) Valid zlib compression values are in the interval [0 ... 9], * where, as defined in zlib.h: * 0 Z_NO_COMPRESSION * 1 Z_BEST_SPEED (poorest compression) * 9 Z_BEST_COMPRESSION * For the default value, use either of these: * 6 Z_DEFAULT_COMPRESSION * -1 (resolves to Z_DEFAULT_COMPRESSION) * (2) If you use the defined constants in zlib.h instead of the * compression integers given above, you must include zlib.h. */ void l_pngSetZlibCompression(l_int32 val) { PROCNAME("l_pngSetZlibCompression"); if (val < -1 || val > 9) { L_ERROR("Invalid zlib comp val; using default", procName); val = Z_DEFAULT_COMPRESSION; } var_ZLIB_COMPRESSION = val; }
/*! * dewarpSinglePageRun() * * Input: pixs (any depth) * pixb (1 bpp) * dewa (initialized) * &pixd (<return> dewarped result) * debug (1 for debugging output, 0 otherwise) * Return: 0 if OK, 1 on error (list of page numbers), or null on error * * Notes: * (1) Dewarps pixs and returns the result in &pixd. * (2) The model parameters must be set before calling this. * (3) If a model cannot be built, this returns a copy of pixs in &pixd. */ l_int32 dewarpSinglePageRun(PIX *pixs, PIX *pixb, L_DEWARPA *dewa, PIX **ppixd, l_int32 debug) { const char *debugfile; l_int32 vsuccess, ret; L_DEWARP *dew; PROCNAME("dewarpSinglePageRun"); if (!ppixd) return ERROR_INT("&pixd not defined", procName, 1); *ppixd = NULL; if (!pixs) return ERROR_INT("pixs not defined", procName, 1); if (!pixb) return ERROR_INT("pixs not defined", procName, 1); if (!dewa) return ERROR_INT("dewa not defined", procName, 1); /* Generate the page model */ lept_mkdir("lept"); dew = dewarpCreate(pixb, 0); dewarpaInsertDewarp(dewa, dew); debugfile = (debug) ? "/tmp/lept/singlepage_model.pdf" : NULL; dewarpBuildPageModel(dew, debugfile); dewarpaModelStatus(dewa, 0, &vsuccess, NULL); if (vsuccess == 0) { L_ERROR("failure to build model for vertical disparity\n", procName); *ppixd = pixCopy(NULL, pixs); return 0; } /* Apply the page model */ debugfile = (debug) ? "/tmp/lept/singlepage_apply.pdf" : NULL; ret = dewarpaApplyDisparity(dewa, 0, pixs, 255, 0, 0, ppixd, debugfile); if (ret) L_ERROR("invalid model; failure to apply disparity\n", procName); return 0; }
/*! * l_autodecode_137() * * Input: index into array of functions * Return: data struct (e.g., pixa) in memory */ void * l_autodecode_137(l_int32 index) { l_uint8 *data1, *data2; l_int32 size1; size_t size2; void *result = NULL; l_int32 nfunc = 2; PROCNAME("l_autodecode_137"); if (index < 0 || index >= nfunc) { L_ERROR("invalid index = %d; must be less than %d\n", procName, index, nfunc); return NULL; } lept_mkdir("lept/auto"); /* Unencode selected string, write to file, and read it */ switch (index) { case 0: data1 = decodeBase64(l_strdata_0, strlen(l_strdata_0), &size1); data2 = zlibUncompress(data1, size1, &size2); l_binaryWrite("/tmp/lept/auto/data.bin","w", data2, size2); result = (void *)pixaRead("/tmp/lept/auto/data.bin"); lept_free(data1); lept_free(data2); break; case 1: data1 = decodeBase64(l_strdata_1, strlen(l_strdata_1), &size1); data2 = zlibUncompress(data1, size1, &size2); l_binaryWrite("/tmp/lept/auto/data.bin","w", data2, size2); result = (void *)pixaRead("/tmp/lept/auto/data.bin"); lept_free(data1); lept_free(data2); break; default: L_ERROR("invalid index", procName); } return result; }