/*!
* l_dnaaWriteStream()
*
* Input: stream, daa
* Return: 0 if OK, 1 on error
*/
l_int32
l_dnaaWriteStream(FILE *fp,
L_DNAA *daa)
{
l_int32 i, n;
L_DNA *da;
PROCNAME("l_dnaaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!daa)
return ERROR_INT("daa not defined", procName, 1);
n = l_dnaaGetCount(daa);
fprintf(fp, "\nL_Dnaa Version %d\n", DNA_VERSION_NUMBER);
fprintf(fp, "Number of L_Dna = %d\n\n", n);
for (i = 0; i < n; i++) {
if ((da = l_dnaaGetDna(daa, i, L_CLONE)) == NULL)
return ERROR_INT("da not found", procName, 1);
fprintf(fp, "L_Dna[%d]:", i);
l_dnaWriteStream(fp, da);
l_dnaDestroy(&da);
}
return 0;
}
/*!
* recogDestroy()
*
* Input: &recog (<will be set to null before returning>)
* Return: void
*
* Notes:
* (1) If a recog has a parent, the parent owns it. A recogDestroy()
* will fail if there is a parent.
*/
void
recogDestroy(L_RECOG **precog)
{
L_RECOG *recog;
PROCNAME("recogDestroy");
if (!precog) {
L_WARNING("ptr address is null\n", procName);
return;
}
if ((recog = *precog) == NULL) return;
if (recogGetParent(recog) != NULL) {
L_ERROR("recog has parent; can't be destroyed\n", procName);
return;
}
FREE(recog->bootdir);
FREE(recog->bootpattern);
FREE(recog->bootpath);
FREE(recog->centtab);
FREE(recog->sumtab);
FREE(recog->fname);
sarrayDestroy(&recog->sa_text);
l_dnaDestroy(&recog->dna_tochar);
pixaaDestroy(&recog->pixaa_u);
pixaDestroy(&recog->pixa_u);
ptaaDestroy(&recog->ptaa_u);
ptaDestroy(&recog->pta_u);
numaDestroy(&recog->nasum_u);
numaaDestroy(&recog->naasum_u);
pixaaDestroy(&recog->pixaa);
pixaDestroy(&recog->pixa);
ptaaDestroy(&recog->ptaa);
ptaDestroy(&recog->pta);
numaDestroy(&recog->nasum);
numaaDestroy(&recog->naasum);
pixaDestroy(&recog->pixa_tr);
pixaDestroy(&recog->pixadb_ave);
pixaDestroy(&recog->pixa_id);
pixDestroy(&recog->pixdb_ave);
pixDestroy(&recog->pixdb_range);
pixaDestroy(&recog->pixadb_boot);
pixaDestroy(&recog->pixadb_split);
FREE(recog->fontdir);
bmfDestroy(&recog->bmf);
rchDestroy(&recog->rch);
rchaDestroy(&recog->rcha);
recogDestroyDid(recog);
FREE(recog);
*precog = NULL;
return;
}
/*!
* \brief recogDestroy()
*
* \param[in,out] precog will be set to null before returning
* \return void
*/
void
recogDestroy(L_RECOG **precog)
{
L_RECOG *recog;
PROCNAME("recogDestroy");
if (!precog) {
L_WARNING("ptr address is null\n", procName);
return;
}
if ((recog = *precog) == NULL) return;
LEPT_FREE(recog->centtab);
LEPT_FREE(recog->sumtab);
sarrayDestroy(&recog->sa_text);
l_dnaDestroy(&recog->dna_tochar);
pixaaDestroy(&recog->pixaa_u);
pixaDestroy(&recog->pixa_u);
ptaaDestroy(&recog->ptaa_u);
ptaDestroy(&recog->pta_u);
numaDestroy(&recog->nasum_u);
numaaDestroy(&recog->naasum_u);
pixaaDestroy(&recog->pixaa);
pixaDestroy(&recog->pixa);
ptaaDestroy(&recog->ptaa);
ptaDestroy(&recog->pta);
numaDestroy(&recog->nasum);
numaaDestroy(&recog->naasum);
pixaDestroy(&recog->pixa_tr);
pixaDestroy(&recog->pixadb_ave);
pixaDestroy(&recog->pixa_id);
pixDestroy(&recog->pixdb_ave);
pixDestroy(&recog->pixdb_range);
pixaDestroy(&recog->pixadb_boot);
pixaDestroy(&recog->pixadb_split);
bmfDestroy(&recog->bmf);
rchDestroy(&recog->rch);
rchaDestroy(&recog->rcha);
recogDestroyDid(recog);
LEPT_FREE(recog);
*precog = NULL;
return;
}
/*!
* l_dnaaGetNumberCount()
*
* Input: daa
* Return: count (total number of numbers in the l_dnaa),
* or 0 if no numbers or on error
*/
l_int32
l_dnaaGetNumberCount(L_DNAA *daa)
{
L_DNA *da;
l_int32 n, sum, i;
PROCNAME("l_dnaaGetNumberCount");
if (!daa)
return ERROR_INT("daa not defined", procName, 0);
n = l_dnaaGetCount(daa);
for (sum = 0, i = 0; i < n; i++) {
da = l_dnaaGetDna(daa, i, L_CLONE);
sum += l_dnaGetCount(da);
l_dnaDestroy(&da);
}
return sum;
}
/*!
* l_dnaaAddNumber()
*
* Input: daa
* index (of l_dna within l_dnaa)
* val (number to be added; stored as a double)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Adds to an existing l_dna only.
*/
l_int32
l_dnaaAddNumber(L_DNAA *daa,
l_int32 index,
l_float64 val)
{
l_int32 n;
L_DNA *da;
PROCNAME("l_dnaaAddNumber");
if (!daa)
return ERROR_INT("daa not defined", procName, 1);
n = l_dnaaGetCount(daa);
if (index < 0 || index >= n)
return ERROR_INT("invalid index in daa", procName, 1);
da = l_dnaaGetDna(daa, index, L_CLONE);
l_dnaAddNumber(da, val);
l_dnaDestroy(&da);
return 0;
}
/*!
* l_dnaaReplaceDna()
*
* Input: daa
* index (to the index-th l_dna)
* l_dna (insert and replace any existing one)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Any existing l_dna is destroyed, and the input one
* is inserted in its place.
* (2) If the index is invalid, return 1 (error)
*/
l_int32
l_dnaaReplaceDna(L_DNAA *daa,
l_int32 index,
L_DNA *da)
{
l_int32 n;
PROCNAME("l_dnaaReplaceDna");
if (!daa)
return ERROR_INT("daa not defined", procName, 1);
if (!da)
return ERROR_INT("da not defined", procName, 1);
n = l_dnaaGetCount(daa);
if (index < 0 || index >= n)
return ERROR_INT("index not valid", procName, 1);
l_dnaDestroy(&daa->dna[index]);
daa->dna[index] = da;
return 0;
}
/*!
* \brief l_dnaHashDestroy()
*
* \param[in,out] pdahash to be nulled, if it exists
* \return void
*/
void
l_dnaHashDestroy(L_DNAHASH **pdahash)
{
L_DNAHASH *dahash;
l_int32 i;
PROCNAME("l_dnaHashDestroy");
if (pdahash == NULL) {
L_WARNING("ptr address is NULL!\n", procName);
return;
}
if ((dahash = *pdahash) == NULL)
return;
for (i = 0; i < dahash->nbuckets; i++)
l_dnaDestroy(&dahash->dna[i]);
LEPT_FREE(dahash->dna);
LEPT_FREE(dahash);
*pdahash = NULL;
}
/*!
* \brief l_dnaUnionByAset()
*
* \param[in] da1, da2
* \return dad with the union of the set of numbers, or NULL on error
*
* <pre>
* Notes:
* (1) See sarrayUnionByAset() for the approach.
* (2) Here, the key in building the sorted tree is the number itself.
* (3) Operations using an underlying tree are O(nlogn), which is
* typically less efficient than hashing, which is O(n).
* </pre>
*/
L_DNA *
l_dnaUnionByAset(L_DNA *da1,
L_DNA *da2)
{
L_DNA *da3, *dad;
PROCNAME("l_dnaUnionByAset");
if (!da1)
return (L_DNA *)ERROR_PTR("da1 not defined", procName, NULL);
if (!da2)
return (L_DNA *)ERROR_PTR("da2 not defined", procName, NULL);
/* Join */
da3 = l_dnaCopy(da1);
l_dnaJoin(da3, da2, 0, -1);
/* Eliminate duplicates */
dad = l_dnaRemoveDupsByAset(da3);
l_dnaDestroy(&da3);
return dad;
}
/*!
* l_dnaaDestroy()
*
* Input: &dnaa <to be nulled if it exists>
* Return: void
*/
void
l_dnaaDestroy(L_DNAA **pdaa)
{
l_int32 i;
L_DNAA *daa;
PROCNAME("l_dnaaDestroy");
if (pdaa == NULL) {
L_WARNING("ptr address is NULL!\n", procName);
return;
}
if ((daa = *pdaa) == NULL)
return;
for (i = 0; i < daa->n; i++)
l_dnaDestroy(&daa->dna[i]);
FREE(daa->dna);
FREE(daa);
*pdaa = NULL;
return;
}
/*!
* \brief recogReadStream()
*
* \param[in] fp file stream
* \return recog, or NULL on error
*/
L_RECOG *
recogReadStream(FILE *fp)
{
l_int32 version, setsize, threshold, scalew, scaleh, linew;
l_int32 maxyshift, nc;
L_DNA *dna_tochar;
PIXAA *paa;
L_RECOG *recog;
SARRAY *sa_text;
PROCNAME("recogReadStream");
if (!fp)
return (L_RECOG *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\nRecog Version %d\n", &version) != 1)
return (L_RECOG *)ERROR_PTR("not a recog file", procName, NULL);
if (version != RECOG_VERSION_NUMBER)
return (L_RECOG *)ERROR_PTR("invalid recog version", procName, NULL);
if (fscanf(fp, "Size of character set = %d\n", &setsize) != 1)
return (L_RECOG *)ERROR_PTR("setsize not read", procName, NULL);
if (fscanf(fp, "Binarization threshold = %d\n", &threshold) != 1)
return (L_RECOG *)ERROR_PTR("binary thresh not read", procName, NULL);
if (fscanf(fp, "Maxyshift = %d\n", &maxyshift) != 1)
return (L_RECOG *)ERROR_PTR("maxyshift not read", procName, NULL);
if (fscanf(fp, "Scale to width = %d\n", &scalew) != 1)
return (L_RECOG *)ERROR_PTR("width not read", procName, NULL);
if (fscanf(fp, "Scale to height = %d\n", &scaleh) != 1)
return (L_RECOG *)ERROR_PTR("height not read", procName, NULL);
if (fscanf(fp, "Normalized line width = %d\n", &linew) != 1)
return (L_RECOG *)ERROR_PTR("line width not read", procName, NULL);
if ((recog = recogCreate(scalew, scaleh, linew, threshold,
maxyshift)) == NULL)
return (L_RECOG *)ERROR_PTR("recog not made", procName, NULL);
if (fscanf(fp, "\nLabels for character set:\n") != 0) {
recogDestroy(&recog);
return (L_RECOG *)ERROR_PTR("label intro not read", procName, NULL);
}
l_dnaDestroy(&recog->dna_tochar);
if ((dna_tochar = l_dnaReadStream(fp)) == NULL) {
recogDestroy(&recog);
return (L_RECOG *)ERROR_PTR("dna_tochar not read", procName, NULL);
}
recog->dna_tochar = dna_tochar;
sarrayDestroy(&recog->sa_text);
if ((sa_text = sarrayReadStream(fp)) == NULL) {
recogDestroy(&recog);
return (L_RECOG *)ERROR_PTR("sa_text not read", procName, NULL);
}
recog->sa_text = sa_text;
if (fscanf(fp, "\nPixaa of all samples in the training set:\n") != 0) {
recogDestroy(&recog);
return (L_RECOG *)ERROR_PTR("pixaa intro not read", procName, NULL);
}
if ((paa = pixaaReadStream(fp)) == NULL) {
recogDestroy(&recog);
return (L_RECOG *)ERROR_PTR("pixaa not read", procName, NULL);
}
recog->setsize = setsize;
nc = pixaaGetCount(paa, NULL);
if (nc != setsize) {
recogDestroy(&recog);
pixaaDestroy(&paa);
L_ERROR("(setsize = %d) != (paa count = %d)\n", procName,
setsize, nc);
return NULL;
}
recogAddAllSamples(&recog, paa, 0); /* this finishes */
pixaaDestroy(&paa);
if (!recog)
return (L_RECOG *)ERROR_PTR("bad templates", procName, NULL);
return recog;
}
l_int32 main(int argc,
char **argv)
{
L_ASET *set;
L_DNA *da1, *da2, *da3, *da4, *da5, *da6, *da7, *da8, *dav, *dac;
L_DNAHASH *dahash;
NUMA *nav, *nac;
PTA *pta1, *pta2, *pta3;
SARRAY *sa1, *sa2, *sa3, *sa4;
lept_mkdir("lept/hash");
#if 1
/* Test string hashing with aset */
fprintf(stderr, "Set results with string hashing:\n");
sa1 = BuildShortStrings(3, 0);
sa2 = BuildShortStrings(3, 1);
fprintf(stderr, " size with unique strings: %d\n", sarrayGetCount(sa1));
fprintf(stderr, " size with dups: %d\n", sarrayGetCount(sa2));
startTimer();
set = l_asetCreateFromSarray(sa2);
fprintf(stderr, " time to make set: %5.3f sec\n", stopTimer());
fprintf(stderr, " size of set without dups: %d\n", l_asetSize(set));
l_asetDestroy(&set);
startTimer();
sa3 = sarrayRemoveDupsByAset(sa2);
fprintf(stderr, " time to remove dups: %5.3f sec\n", stopTimer());
fprintf(stderr, " size without dups = %d\n", sarrayGetCount(sa3));
startTimer();
sa4 = sarrayIntersectionByAset(sa1, sa2);
fprintf(stderr, " time to intersect: %5.3f sec\n", stopTimer());
fprintf(stderr, " intersection size = %d\n", sarrayGetCount(sa4));
sarrayDestroy(&sa3);
sarrayDestroy(&sa4);
/* Test sarray set operations with dna hash.
* We use the same hash function as is used with aset. */
fprintf(stderr, "\nDna hash results for sarray:\n");
fprintf(stderr, " size with unique strings: %d\n", sarrayGetCount(sa1));
fprintf(stderr, " size with dups: %d\n", sarrayGetCount(sa2));
startTimer();
dahash = l_dnaHashCreateFromSarray(sa2);
fprintf(stderr, " time to make hashmap: %5.3f sec\n", stopTimer());
fprintf(stderr, " entries in hashmap with dups: %d\n",
l_dnaHashGetTotalCount(dahash));
l_dnaHashDestroy(&dahash);
startTimer();
sarrayRemoveDupsByHash(sa2, &sa3, NULL);
fprintf(stderr, " time to remove dups: %5.3f sec\n", stopTimer());
fprintf(stderr, " size without dups = %d\n", sarrayGetCount(sa3));
startTimer();
sa4 = sarrayIntersectionByHash(sa1, sa2);
fprintf(stderr, " time to intersect: %5.3f sec\n", stopTimer());
fprintf(stderr, " intersection size = %d\n", sarrayGetCount(sa4));
sarrayDestroy(&sa3);
sarrayDestroy(&sa4);
sarrayDestroy(&sa1);
sarrayDestroy(&sa2);
#endif
#if 1
/* Test point hashing with aset.
* Enter all points within a 1500 x 1500 image in pta1, and include
* 450,000 duplicates in pta2. With this pt hashing function,
* there are no hash collisions among any of the 400 million pixel
* locations in a 20000 x 20000 image. */
pta1 = BuildPointSet(1500, 1500, 0);
pta2 = BuildPointSet(1500, 1500, 1);
fprintf(stderr, "\nSet results for pta:\n");
fprintf(stderr, " pta1 size with unique points: %d\n", ptaGetCount(pta1));
fprintf(stderr, " pta2 size with dups: %d\n", ptaGetCount(pta2));
startTimer();
pta3 = ptaRemoveDupsByAset(pta2);
fprintf(stderr, " Time to remove dups: %5.3f sec\n", stopTimer());
fprintf(stderr, " size without dups = %d\n", ptaGetCount(pta3));
ptaDestroy(&pta3);
startTimer();
pta3 = ptaIntersectionByAset(pta1, pta2);
fprintf(stderr, " Time to intersect: %5.3f sec\n", stopTimer());
fprintf(stderr, " intersection size = %d\n", ptaGetCount(pta3));
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
#endif
#if 1
/* Test pta set operations with dna hash, using the same pt hashing
* function. Although there are no collisions in 20K x 20K images,
* the dna hash implementation works properly even if there are some. */
pta1 = BuildPointSet(1500, 1500, 0);
pta2 = BuildPointSet(1500, 1500, 1);
fprintf(stderr, "\nDna hash results for pta:\n");
fprintf(stderr, " pta1 size with unique points: %d\n", ptaGetCount(pta1));
fprintf(stderr, " pta2 size with dups: %d\n", ptaGetCount(pta2));
startTimer();
ptaRemoveDupsByHash(pta2, &pta3, NULL);
fprintf(stderr, " Time to remove dups: %5.3f sec\n", stopTimer());
fprintf(stderr, " size without dups = %d\n", ptaGetCount(pta3));
ptaDestroy(&pta3);
startTimer();
pta3 = ptaIntersectionByHash(pta1, pta2);
fprintf(stderr, " Time to intersect: %5.3f sec\n", stopTimer());
fprintf(stderr, " intersection size = %d\n", ptaGetCount(pta3));
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
#endif
/* Test dna set and histo operations using dna hash */
#if 1
fprintf(stderr, "\nDna hash results for dna:\n");
da1 = l_dnaMakeSequence(0.0, 0.125, 8000);
da2 = l_dnaMakeSequence(300.0, 0.125, 8000);
da3 = l_dnaMakeSequence(600.0, 0.125, 8000);
da4 = l_dnaMakeSequence(900.0, 0.125, 8000);
da5 = l_dnaMakeSequence(1200.0, 0.125, 8000);
l_dnaJoin(da1, da2, 0, -1);
l_dnaJoin(da1, da3, 0, -1);
l_dnaJoin(da1, da4, 0, -1);
l_dnaJoin(da1, da5, 0, -1);
l_dnaRemoveDupsByHash(da1, &da6, &dahash);
l_dnaHashDestroy(&dahash);
fprintf(stderr, " dna size with dups = %d\n", l_dnaGetCount(da1));
fprintf(stderr, " dna size of unique numbers = %d\n", l_dnaGetCount(da6));
l_dnaMakeHistoByHash(da1, &dahash, &dav, &dac);
nav = l_dnaConvertToNuma(dav);
nac = l_dnaConvertToNuma(dac);
fprintf(stderr, " dna number of histo points = %d\n", l_dnaGetCount(dac));
gplotSimpleXY1(nav, nac, GPLOT_IMPULSES, GPLOT_PNG,
"/tmp/lept/hash/histo", "Histo");
da7 = l_dnaIntersectionByHash(da2, da3);
fprintf(stderr, " dna number of points: da2 = %d, da3 = %d\n",
l_dnaGetCount(da2), l_dnaGetCount(da3));
fprintf(stderr, " dna number of da2/da3 intersection points = %d\n",
l_dnaGetCount(da7));
l_fileDisplay("/tmp/lept/hash/histo.png", 700, 100, 1.0);
l_dnaDestroy(&da1);
l_dnaDestroy(&da2);
l_dnaDestroy(&da3);
l_dnaDestroy(&da4);
l_dnaDestroy(&da5);
l_dnaDestroy(&da6);
l_dnaDestroy(&da7);
l_dnaDestroy(&dac);
l_dnaDestroy(&dav);
l_dnaHashDestroy(&dahash);
numaDestroy(&nav);
numaDestroy(&nac);
#endif
#if 1
da1 = l_dnaMakeSequence(0, 3, 10000);
da2 = l_dnaMakeSequence(0, 5, 10000);
da3 = l_dnaMakeSequence(0, 7, 10000);
l_dnaJoin(da1, da2, 0, -1);
l_dnaJoin(da1, da3, 0, -1);
fprintf(stderr, "\nDna results using set:\n");
fprintf(stderr, " da1 count: %d\n", l_dnaGetCount(da1));
set = l_asetCreateFromDna(da1);
fprintf(stderr, " da1 set size: %d\n\n", l_asetSize(set));
l_asetDestroy(&set);
da4 = l_dnaUnionByAset(da2, da3);
fprintf(stderr, " da4 count: %d\n", l_dnaGetCount(da4));
set = l_asetCreateFromDna(da4);
fprintf(stderr, " da4 set size: %d\n\n", l_asetSize(set));
l_asetDestroy(&set);
da5 = l_dnaIntersectionByAset(da1, da2);
fprintf(stderr, " da5 count: %d\n", l_dnaGetCount(da5));
set = l_asetCreateFromDna(da5);
fprintf(stderr, " da5 set size: %d\n\n", l_asetSize(set));
l_asetDestroy(&set);
da6 = l_dnaMakeSequence(100000, 11, 5000);
l_dnaJoin(da6, da1, 0, -1);
fprintf(stderr, " da6 count: %d\n", l_dnaGetCount(da6));
set = l_asetCreateFromDna(da6);
fprintf(stderr, " da6 set size: %d\n\n", l_asetSize(set));
l_asetDestroy(&set);
da7 = l_dnaIntersectionByAset(da6, da3);
fprintf(stderr, " da7 count: %d\n", l_dnaGetCount(da7));
set = l_asetCreateFromDna(da7);
fprintf(stderr, " da7 set size: %d\n\n", l_asetSize(set));
l_asetDestroy(&set);
da8 = l_dnaRemoveDupsByAset(da1);
fprintf(stderr, " da8 count: %d\n\n", l_dnaGetCount(da8));
l_dnaDestroy(&da1);
l_dnaDestroy(&da2);
l_dnaDestroy(&da3);
l_dnaDestroy(&da4);
l_dnaDestroy(&da5);
l_dnaDestroy(&da6);
l_dnaDestroy(&da7);
l_dnaDestroy(&da8);
#endif
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, nbins, ival;
l_float64 pi, angle, val, sum;
L_DNA *da1, *da2, *da3, *da4, *da5;
L_DNAA *daa1, *daa2;
GPLOT *gplot;
NUMA *na, *nahisto, *nax;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pi = 3.1415926535;
da1 = l_dnaCreate(50);
for (i = 0; i < 5000; i++) {
angle = 0.02293 * i * pi;
val = 999. * sin(angle);
l_dnaAddNumber(da1, val);
}
/* Conversion to Numa; I/O for Dna */
na = l_dnaConvertToNuma(da1);
da2 = numaConvertToDna(na);
l_dnaWrite("/tmp/dna1.da", da1);
l_dnaWrite("/tmp/dna2.da", da2);
da3 = l_dnaRead("/tmp/dna2.da");
l_dnaWrite("/tmp/dna3.da", da3);
regTestCheckFile(rp, "/tmp/dna1.da"); /* 0 */
regTestCheckFile(rp, "/tmp/dna2.da"); /* 1 */
regTestCheckFile(rp, "/tmp/dna3.da"); /* 2 */
regTestCompareFiles(rp, 1, 2); /* 3 */
/* I/O for Dnaa */
daa1 = l_dnaaCreate(3);
l_dnaaAddDna(daa1, da1, L_INSERT);
l_dnaaAddDna(daa1, da2, L_INSERT);
l_dnaaAddDna(daa1, da3, L_INSERT);
l_dnaaWrite("/tmp/dnaa1.daa", daa1);
daa2 = l_dnaaRead("/tmp/dnaa1.daa");
l_dnaaWrite("/tmp/dnaa2.daa", daa2);
regTestCheckFile(rp, "/tmp/dnaa1.daa"); /* 4 */
regTestCheckFile(rp, "/tmp/dnaa2.daa"); /* 5 */
regTestCompareFiles(rp, 4, 5); /* 6 */
l_dnaaDestroy(&daa1);
l_dnaaDestroy(&daa2);
/* Just for fun -- is the numa ok? */
nahisto = numaMakeHistogramClipped(na, 12, 2000);
nbins = numaGetCount(nahisto);
nax = numaMakeSequence(0, 1, nbins);
gplot = gplotCreate("/tmp/historoot", GPLOT_PNG, "Histo example",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
regTestCheckFile(rp, "/tmp/historoot.png"); /* 7 */
gplotDestroy(&gplot);
numaDestroy(&na);
numaDestroy(&nax);
numaDestroy(&nahisto);
/* Handling precision of int32 in double */
da4 = l_dnaCreate(25);
for (i = 0; i < 1000; i++)
l_dnaAddNumber(da4, 1928374 * i);
l_dnaWrite("/tmp/dna4.da", da4);
da5 = l_dnaRead("/tmp/dna4.da");
sum = 0;
for (i = 0; i < 1000; i++) {
l_dnaGetIValue(da5, i, &ival);
sum += L_ABS(ival - i * 1928374); /* we better be adding 0 each time */
}
regTestCompareValues(rp, sum, 0.0, 0.0); /* 8 */
l_dnaDestroy(&da4);
l_dnaDestroy(&da5);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char *str;
l_uint8 *data1, *data2;
l_int32 i, n, same1, same2;
size_t size1, size2, slice, total, start, end;
FILE *fp;
L_DNA *da;
SARRAY *sa;
L_BYTEA *lba1, *lba2, *lba3, *lba4, *lba5;
static char mainName[] = "byteatest";
if (argc != 1)
return ERROR_INT("syntax: byteatest", mainName, 1);
lept_mkdir("bytea");
/* Test basic init, join and split */
lba1 = l_byteaInitFromFile("feyn.tif");
lba2 = l_byteaInitFromFile("test24.jpg");
size1 = l_byteaGetSize(lba1);
size2 = l_byteaGetSize(lba2);
l_byteaJoin(lba1, &lba2);
lba3 = l_byteaInitFromMem(lba1->data, size1);
lba4 = l_byteaInitFromMem(lba1->data + size1, size2);
/* Split by hand */
l_binaryWrite("/tmp/bytea/junk1.dat", "w", lba3->data, lba3->size);
l_binaryWrite("/tmp/bytea/junk2.dat", "w", lba4->data, lba4->size);
filesAreIdentical("feyn.tif", "/tmp/bytea/junk1.dat", &same1);
filesAreIdentical("test24.jpg", "/tmp/bytea/junk2.dat", &same2);
if (same1 && same2)
fprintf(stderr, "OK for join file\n");
else
fprintf(stderr, "Error: files are different!\n");
/* Split by function */
l_byteaSplit(lba1, size1, &lba5);
l_binaryWrite("/tmp/bytea/junk3.dat", "w", lba1->data, lba1->size);
l_binaryWrite("/tmp/bytea/junk4.dat", "w", lba5->data, lba5->size);
filesAreIdentical("feyn.tif", "/tmp/bytea/junk3.dat", &same1);
filesAreIdentical("test24.jpg", "/tmp/bytea/junk4.dat", &same2);
if (same1 && same2)
fprintf(stderr, "OK for split file\n");
else
fprintf(stderr, "Error: files are different!\n");
l_byteaDestroy(&lba1);
l_byteaDestroy(&lba2);
l_byteaDestroy(&lba3);
l_byteaDestroy(&lba4);
l_byteaDestroy(&lba5);
/* Test appending with strings */
data1 = l_binaryRead("kernel_reg.c", &size1);
sa = sarrayCreateLinesFromString((char *)data1, 1);
lba1 = l_byteaCreate(0);
n = sarrayGetCount(sa);
for (i = 0; i < n; i++) {
str = sarrayGetString(sa, i, L_NOCOPY);
l_byteaAppendString(lba1, str);
l_byteaAppendString(lba1, (char *)"\n");
}
data2 = l_byteaGetData(lba1, &size2);
l_binaryWrite("/tmp/bytea/junk5.dat", "w", data2, size2);
filesAreIdentical("kernel_reg.c", "/tmp/bytea/junk5.dat", &same1);
if (same1)
fprintf(stderr, "OK for appended string data\n");
else
fprintf(stderr, "Error: appended string data is different!\n");
lept_free(data1);
sarrayDestroy(&sa);
l_byteaDestroy(&lba1);
/* Test appending with binary data */
slice = 1000;
total = nbytesInFile("breviar-a38.jp2");
lba1 = l_byteaCreate(100);
n = 1 + total / slice;
fprintf(stderr, "******************************************************\n");
fprintf(stderr, "* Testing error checking: ignore two reported errors *\n");
for (i = 0, start = 0; i <= n; i++, start += slice) {
data1 = l_binaryReadSelect("breviar-a38.jp2", start, slice, &size1);
l_byteaAppendData(lba1, data1, size1);
lept_free(data1);
}
fprintf(stderr, "******************************************************\n");
data2 = l_byteaGetData(lba1, &size2);
l_binaryWrite("/tmp/bytea/junk6.dat", "w", data2, size2);
filesAreIdentical("breviar-a38.jp2", "/tmp/bytea/junk6.dat", &same1);
if (same1)
fprintf(stderr, "OK for appended binary data\n");
else
fprintf(stderr, "Error: appended binary data is different!\n");
l_byteaDestroy(&lba1);
/* Test search */
convertToPdf("test24.jpg", L_JPEG_ENCODE, 0, "/tmp/bytea/junk7.pdf",
0, 0, 100, NULL, NULL, 0);
lba1 = l_byteaInitFromFile("/tmp/bytea/junk7.pdf");
l_byteaFindEachSequence(lba1, (l_uint8 *)" 0 obj\n", 7, &da);
/* l_dnaWriteStream(stderr, da); */
n = l_dnaGetCount(da);
if (n == 6)
fprintf(stderr, "OK for search: found 6 instances\n");
else
fprintf(stderr, "Error in search: found %d instances, not 6\n", n);
l_byteaDestroy(&lba1);
l_dnaDestroy(&da);
/* Test write to file */
lba1 = l_byteaInitFromFile("feyn.tif");
fp = lept_fopen("/tmp/bytea/junk8.dat", "wb");
size1 = l_byteaGetSize(lba1);
for (start = 0; start < size1; start += 1000) {
end = L_MIN(start + 1000 - 1, size1 - 1);
l_byteaWriteStream(fp, lba1, start, end);
}
lept_fclose(fp);
filesAreIdentical("feyn.tif", "/tmp/bytea/junk8.dat", &same1);
if (same1)
fprintf(stderr, "OK for written binary data\n");
else
fprintf(stderr, "Error: written binary data is different!\n");
l_byteaDestroy(&lba1);
return 0;
}
main(int argc,
char **argv)
{
char *str;
l_uint8 *data1, *data2;
l_int32 i, n, start, end, same1, same2;
size_t size1, size2;
FILE *fp;
L_DNA *da;
SARRAY *sa;
L_BYTEA *lba1, *lba2, *lba3, *lba4, *lba5;
static char mainName[] = "byteatest";
if (argc != 1)
exit(ERROR_INT("syntax: whatever11", mainName, 1));
/* Test basic init, join and split */
lba1 = l_byteaInitFromFile("feyn.tif");
lba2 = l_byteaInitFromFile("test24.jpg");
size1 = l_byteaGetSize(lba1);
size2 = l_byteaGetSize(lba2);
l_byteaJoin(lba1, &lba2);
lba3 = l_byteaInitFromMem(lba1->data, size1);
lba4 = l_byteaInitFromMem(lba1->data + size1, size2);
/* Split by hand */
l_binaryWrite("junk1", "w", lba3->data, lba3->size);
l_binaryWrite("junk2", "w", lba4->data, lba4->size);
filesAreIdentical("feyn.tif", "junk1", &same1);
filesAreIdentical("test24.jpg", "junk2", &same2);
if (same1 && same2)
fprintf(stderr, "OK for join file\n");
else
fprintf(stderr, "Error: files are different!\n");
/* Split by function */
l_byteaSplit(lba1, size1, &lba5);
l_binaryWrite("junk3", "w", lba1->data, lba1->size);
l_binaryWrite("junk4", "w", lba5->data, lba5->size);
filesAreIdentical("feyn.tif", "junk3", &same1);
filesAreIdentical("test24.jpg", "junk4", &same2);
if (same1 && same2)
fprintf(stderr, "OK for split file\n");
else
fprintf(stderr, "Error: files are different!\n");
l_byteaDestroy(&lba1);
l_byteaDestroy(&lba2);
l_byteaDestroy(&lba3);
l_byteaDestroy(&lba4);
l_byteaDestroy(&lba5);
/* Test appending */
data1 = l_binaryRead("whatever10.c", &size1);
sa = sarrayCreateLinesFromString((char *)data1, 1);
lba1 = l_byteaCreate(0);
n = sarrayGetCount(sa);
for (i = 0; i < n; i++) {
str = sarrayGetString(sa, i, L_NOCOPY);
l_byteaAppendString(lba1, str);
l_byteaAppendString(lba1, (char *)"\n");
}
data2 = l_byteaGetData(lba1, &size2);
l_binaryWrite("junk1.txt", "w", data2, size2);
filesAreIdentical("whatever10.c", "junk1.txt", &same1);
if (same1)
fprintf(stderr, "OK for appended file\n");
else
fprintf(stderr, "Error: appended file is different!\n");
lept_free(data1);
sarrayDestroy(&sa);
l_byteaDestroy(&lba1);
/* Test search */
convertToPdf("test24.jpg", L_JPEG_ENCODE, 0, "junk3.pdf",
0, 0, 100, NULL, 0, NULL);
lba1 = l_byteaInitFromFile("junk3.pdf");
l_byteaFindEachSequence(lba1, (l_uint8 *)" 0 obj\n", 7, &da);
l_dnaWriteStream(stderr, da);
l_byteaDestroy(&lba1);
l_dnaDestroy(&da);
/* Test write to file */
lba1 = l_byteaInitFromFile("feyn.tif");
fp = lept_fopen("junk5", "wb");
size1 = l_byteaGetSize(lba1);
for (start = 0; start < size1; start += 1000) {
end = L_MIN(start + 1000 - 1, size1 - 1);
l_byteaWriteStream(fp, lba1, start, end);
}
lept_fclose(fp);
l_byteaDestroy(&lba1);
return 0;
}
