Import Ghostscript 9.54ghostscript-9.54

Signed-off-by: Thomas Deutschmann <whissi@gentoo.org>

1 files changed, 2446 insertions, 0 deletions

diff --git a/leptonica/src/sel1.c b/leptonica/src/sel1.c
new file mode 100644
index 00000000..492972cd
--- /dev/null
+++ b/leptonica/src/sel1.c
@@ -0,0 +1,2446 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+
+/*!
+ * \file sel1.c
+ * <pre>
+ *
+ *      Basic ops on Sels and Selas
+ *
+ *         Create/destroy/copy:
+ *            SELA      *selaCreate()
+ *            void       selaDestroy()
+ *            SEL       *selCreate()
+ *            void       selDestroy()
+ *            SEL       *selCopy()
+ *            SEL       *selCreateBrick()
+ *            SEL       *selCreateComb()
+ *
+ *         Helper proc:
+ *            l_int32  **create2dIntArray()
+ *
+ *         Extension of sela:
+ *            SELA      *selaAddSel()
+ *            static l_int32  selaExtendArray()
+ *
+ *         Accessors:
+ *            l_int32    selaGetCount()
+ *            SEL       *selaGetSel()
+ *            char      *selGetName()
+ *            l_int32    selSetName()
+ *            l_int32    selaFindSelByName()
+ *            l_int32    selGetElement()
+ *            l_int32    selSetElement()
+ *            l_int32    selGetParameters()
+ *            l_int32    selSetOrigin()
+ *            l_int32    selGetTypeAtOrigin()
+ *            char      *selaGetBrickName()
+ *            char      *selaGetCombName()
+ *     static char      *selaComputeCompositeParameters()
+ *            l_int32    getCompositeParameters()
+ *            SARRAY    *selaGetSelnames()
+ *
+ *         Max translations for erosion and hmt
+ *            l_int32    selFindMaxTranslations()
+ *
+ *         Rotation by multiples of 90 degrees
+ *            SEL       *selRotateOrth()
+ *
+ *         Sela and Sel serialized I/O
+ *            SELA      *selaRead()
+ *            SELA      *selaReadStream()
+ *            SEL       *selRead()
+ *            SEL       *selReadStream()
+ *            l_int32    selaWrite()
+ *            l_int32    selaWriteStream()
+ *            l_int32    selWrite()
+ *            l_int32    selWriteStream()
+ *
+ *         Building custom hit-miss sels from compiled strings
+ *            SEL       *selCreateFromString()
+ *            char      *selPrintToString()     [for debugging]
+ *
+ *         Building custom hit-miss sels from a simple file format
+ *            SELA      *selaCreateFromFile()
+ *            static SEL *selCreateFromSArray()
+ *
+ *         Making hit-only sels from Pta and Pix
+ *            SEL       *selCreateFromPta()
+ *            SEL       *selCreateFromPix()
+ *
+ *         Making hit-miss sels from Pix and image files
+ *            SEL       *selReadFromColorImage()
+ *            SEL       *selCreateFromColorPix()
+              SELA      *selaCreateFromColorPixa()
+ *
+ *         Printable display of sel
+ *            PIX       *selDisplayInPix()
+ *            PIX       *selaDisplayInPix()
+ *
+ *     Usage notes:
+ *        In this file we have seven functions that make sels:
+ *          (1)  selCreate(), with input (h, w, [name])
+ *               The generic function.  Roll your own, using selSetElement().
+ *          (2)  selCreateBrick(), with input (h, w, cy, cx, val)
+ *               The most popular function.  Makes a rectangular sel of
+ *               all hits, misses or don't-cares.  We have many morphology
+ *               operations that create a sel of all hits, use it, and
+ *               destroy it.
+ *          (3)  selCreateFromString() with input (text, h, w, [name])
+ *               Adam Langley's clever function, allows you to make a hit-miss
+ *               sel from a string in code that is geometrically laid out
+ *               just like the actual sel.
+ *          (4)  selaCreateFromFile() with input (filename)
+ *               This parses a simple file format to create an array of
+ *               hit-miss sels.  The sel data uses the same encoding
+ *               as in (3), with geometrical layout enforced.
+ *          (5)  selCreateFromPta() with input (pta, cy, cx, [name])
+ *               Another way to make a sel with only hits.
+ *          (6)  selCreateFromPix() with input (pix, cy, cx, [name])
+ *               Yet another way to make a sel from hits.
+ *          (7)  selCreateFromColorPix() with input (pix, name).
+ *               Another way to make a general hit-miss sel, starting with
+ *               an image editor.
+ *        In addition, there are three functions in selgen.c that
+ *        automatically generate a hit-miss sel from a pix and
+ *        a number of parameters.  This is useful for problems like
+ *        "find all patterns that look like this one."
+ *
+ *        Consistency, being the hobgoblin of small minds,
+ *        is adhered to here in the dimensioning and accessing of sels.
+ *        Everything is done in standard matrix (row, column) order.
+ *        When we set specific elements in a sel, we likewise use
+ *        (row, col) ordering:
+ *             selSetElement(), with input (row, col, type)
+ * </pre>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config_auto.h>
+#endif  /* HAVE_CONFIG_H */
+
+#include <string.h>
+#include "allheaders.h"
+
+    /* Bounds on sel ptr array size */
+static const l_uint32  MaxPtrArraySize = 10000;
+static const l_int32 InitialPtrArraySize = 50;      /*!< n'importe quoi */
+
+    /* Bounds on kernel size */
+static const l_uint32  MaxKernelSize = 10000;
+
+    /* Bounds on pix template size */
+static const l_uint32  MaxPixTemplateSize = 100;
+static const l_uint32  MaxPixTemplateHits = 1000;
+
+    /* Static functions */
+static l_int32 selaExtendArray(SELA *sela);
+static SEL *selCreateFromSArray(SARRAY *sa, l_int32 first, l_int32 last);
+
+struct CompParameterMap
+{
+    l_int32  size;
+    l_int32  size1;
+    l_int32  size2;
+    char     selnameh1[20];
+    char     selnameh2[20];
+    char     selnamev1[20];
+    char     selnamev2[20];
+};
+
+static const struct CompParameterMap  comp_parameter_map[] =
+    { { 2, 2, 1, "sel_2h", "", "sel_2v", "" },
+      { 3, 3, 1, "sel_3h", "", "sel_3v", "" },
+      { 4, 2, 2, "sel_2h", "sel_comb_4h", "sel_2v", "sel_comb_4v" },
+      { 5, 5, 1, "sel_5h", "", "sel_5v", "" },
+      { 6, 3, 2, "sel_3h", "sel_comb_6h", "sel_3v", "sel_comb_6v" },
+      { 7, 7, 1, "sel_7h", "", "sel_7v", "" },
+      { 8, 4, 2, "sel_4h", "sel_comb_8h", "sel_4v", "sel_comb_8v" },
+      { 9, 3, 3, "sel_3h", "sel_comb_9h", "sel_3v", "sel_comb_9v" },
+      { 10, 5, 2, "sel_5h", "sel_comb_10h", "sel_5v", "sel_comb_10v" },
+      { 11, 4, 3, "sel_4h", "sel_comb_12h", "sel_4v", "sel_comb_12v" },
+      { 12, 4, 3, "sel_4h", "sel_comb_12h", "sel_4v", "sel_comb_12v" },
+      { 13, 4, 3, "sel_4h", "sel_comb_12h", "sel_4v", "sel_comb_12v" },
+      { 14, 7, 2, "sel_7h", "sel_comb_14h", "sel_7v", "sel_comb_14v" },
+      { 15, 5, 3, "sel_5h", "sel_comb_15h", "sel_5v", "sel_comb_15v" },
+      { 16, 4, 4, "sel_4h", "sel_comb_16h", "sel_4v", "sel_comb_16v" },
+      { 17, 4, 4, "sel_4h", "sel_comb_16h", "sel_4v", "sel_comb_16v" },
+      { 18, 6, 3, "sel_6h", "sel_comb_18h", "sel_6v", "sel_comb_18v" },
+      { 19, 5, 4, "sel_5h", "sel_comb_20h", "sel_5v", "sel_comb_20v" },
+      { 20, 5, 4, "sel_5h", "sel_comb_20h", "sel_5v", "sel_comb_20v" },
+      { 21, 7, 3, "sel_7h", "sel_comb_21h", "sel_7v", "sel_comb_21v" },
+      { 22, 11, 2, "sel_11h", "sel_comb_22h", "sel_11v", "sel_comb_22v" },
+      { 23, 6, 4, "sel_6h", "sel_comb_24h", "sel_6v", "sel_comb_24v" },
+      { 24, 6, 4, "sel_6h", "sel_comb_24h", "sel_6v", "sel_comb_24v" },
+      { 25, 5, 5, "sel_5h", "sel_comb_25h", "sel_5v", "sel_comb_25v" },
+      { 26, 5, 5, "sel_5h", "sel_comb_25h", "sel_5v", "sel_comb_25v" },
+      { 27, 9, 3, "sel_9h", "sel_comb_27h", "sel_9v", "sel_comb_27v" },
+      { 28, 7, 4, "sel_7h", "sel_comb_28h", "sel_7v", "sel_comb_28v" },
+      { 29, 6, 5, "sel_6h", "sel_comb_30h", "sel_6v", "sel_comb_30v" },
+      { 30, 6, 5, "sel_6h", "sel_comb_30h", "sel_6v", "sel_comb_30v" },
+      { 31, 6, 5, "sel_6h", "sel_comb_30h", "sel_6v", "sel_comb_30v" },
+      { 32, 8, 4, "sel_8h", "sel_comb_32h", "sel_8v", "sel_comb_32v" },
+      { 33, 11, 3, "sel_11h", "sel_comb_33h", "sel_11v", "sel_comb_33v" },
+      { 34, 7, 5, "sel_7h", "sel_comb_35h", "sel_7v", "sel_comb_35v" },
+      { 35, 7, 5, "sel_7h", "sel_comb_35h", "sel_7v", "sel_comb_35v" },
+      { 36, 6, 6, "sel_6h", "sel_comb_36h", "sel_6v", "sel_comb_36v" },
+      { 37, 6, 6, "sel_6h", "sel_comb_36h", "sel_6v", "sel_comb_36v" },
+      { 38, 6, 6, "sel_6h", "sel_comb_36h", "sel_6v", "sel_comb_36v" },
+      { 39, 13, 3, "sel_13h", "sel_comb_39h", "sel_13v", "sel_comb_39v" },
+      { 40, 8, 5, "sel_8h", "sel_comb_40h", "sel_8v", "sel_comb_40v" },
+      { 41, 7, 6, "sel_7h", "sel_comb_42h", "sel_7v", "sel_comb_42v" },
+      { 42, 7, 6, "sel_7h", "sel_comb_42h", "sel_7v", "sel_comb_42v" },
+      { 43, 7, 6, "sel_7h", "sel_comb_42h", "sel_7v", "sel_comb_42v" },
+      { 44, 11, 4, "sel_11h", "sel_comb_44h", "sel_11v", "sel_comb_44v" },
+      { 45, 9, 5, "sel_9h", "sel_comb_45h", "sel_9v", "sel_comb_45v" },
+      { 46, 9, 5, "sel_9h", "sel_comb_45h", "sel_9v", "sel_comb_45v" },
+      { 47, 8, 6, "sel_8h", "sel_comb_48h", "sel_8v", "sel_comb_48v" },
+      { 48, 8, 6, "sel_8h", "sel_comb_48h", "sel_8v", "sel_comb_48v" },
+      { 49, 7, 7, "sel_7h", "sel_comb_49h", "sel_7v", "sel_comb_49v" },
+      { 50, 10, 5, "sel_10h", "sel_comb_50h", "sel_10v", "sel_comb_50v" },
+      { 51, 10, 5, "sel_10h", "sel_comb_50h", "sel_10v", "sel_comb_50v" },
+      { 52, 13, 4, "sel_13h", "sel_comb_52h", "sel_13v", "sel_comb_52v" },
+      { 53, 9, 6, "sel_9h", "sel_comb_54h", "sel_9v", "sel_comb_54v" },
+      { 54, 9, 6, "sel_9h", "sel_comb_54h", "sel_9v", "sel_comb_54v" },
+      { 55, 11, 5, "sel_11h", "sel_comb_55h", "sel_11v", "sel_comb_55v" },
+      { 56, 8, 7, "sel_8h", "sel_comb_56h", "sel_8v", "sel_comb_56v" },
+      { 57, 8, 7, "sel_8h", "sel_comb_56h", "sel_8v", "sel_comb_56v" },
+      { 58, 8, 7, "sel_8h", "sel_comb_56h", "sel_8v", "sel_comb_56v" },
+      { 59, 10, 6, "sel_10h", "sel_comb_60h", "sel_10v", "sel_comb_60v" },
+      { 60, 10, 6, "sel_10h", "sel_comb_60h", "sel_10v", "sel_comb_60v" },
+      { 61, 10, 6, "sel_10h", "sel_comb_60h", "sel_10v", "sel_comb_60v" },
+      { 62, 9, 7, "sel_9h", "sel_comb_63h", "sel_9v", "sel_comb_63v" },
+      { 63, 9, 7, "sel_9h", "sel_comb_63h", "sel_9v", "sel_comb_63v" } };
+
+
+
+/*------------------------------------------------------------------------*
+ *                      Create / Destroy / Copy                           *
+ *------------------------------------------------------------------------*/
+/*!
+ * \brief   selaCreate()
+ *
+ * \param[in]    n    initial number of sel ptrs; use 0 for default
+ * \return  sela, or NULL on error
+ */
+SELA *
+selaCreate(l_int32  n)
+{
+SELA  *sela;
+
+    PROCNAME("selaCreate");
+
+    if (n <= 0 || n > MaxPtrArraySize)
+        n = InitialPtrArraySize;
+
+        /* Make array of sel ptrs */
+    sela = (SELA *)LEPT_CALLOC(1, sizeof(SELA));
+    sela->nalloc = n;
+    sela->n = 0;
+    if ((sela->sel = (SEL **)LEPT_CALLOC(n, sizeof(SEL *))) == NULL) {
+        LEPT_FREE(sela);
+        return (SELA *)ERROR_PTR("sel ptrs not made", procName, NULL);
+    }
+    return sela;
+}
+
+
+/*!
+ * \brief   selaDestroy()
+ *
+ * \param[in,out]   psela    will be set to null before returning
+ * \return  void
+ */
+void
+selaDestroy(SELA  **psela)
+{
+SELA    *sela;
+l_int32  i;
+
+    if (!psela) return;
+    if ((sela = *psela) == NULL)
+        return;
+
+    for (i = 0; i < sela->n; i++)
+        selDestroy(&sela->sel[i]);
+    LEPT_FREE(sela->sel);
+    LEPT_FREE(sela);
+    *psela = NULL;
+}
+
+
+/*!
+ * \brief   selCreate()
+ *
+ * \param[in]    height
+ * \param[in]    width
+ * \param[in]    name      [optional] sel name; can be null
+ * \return  sel, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) selCreate() initializes all values to 0.
+ *      (2) After this call, (cy,cx) and nonzero data values must be
+ *          assigned.  If a text name is not assigned here, it will
+ *          be needed later when the sel is put into a sela.
+ * </pre>
+ */
+SEL *
+selCreate(l_int32      height,
+          l_int32      width,
+          const char  *name)
+{
+SEL  *sel;
+
+    PROCNAME("selCreate");
+
+    if ((sel = (SEL *)LEPT_CALLOC(1, sizeof(SEL))) == NULL)
+        return (SEL *)ERROR_PTR("sel not made", procName, NULL);
+    if (name)
+        sel->name = stringNew(name);
+    sel->sy = height;
+    sel->sx = width;
+    if ((sel->data = create2dIntArray(height, width)) == NULL) {
+        LEPT_FREE(sel->name);
+        LEPT_FREE(sel);
+        return (SEL *)ERROR_PTR("data not allocated", procName, NULL);
+    }
+
+    return sel;
+}
+
+
+/*!
+ * \brief   selDestroy()
+ *
+ * \param[in,out]   psel   will be set to null before returning
+ * \return  void
+ */
+void
+selDestroy(SEL  **psel)
+{
+l_int32  i;
+SEL     *sel;
+
+    PROCNAME("selDestroy");
+
+    if (psel == NULL)  {
+        L_WARNING("ptr address is NULL!\n", procName);
+        return;
+    }
+    if ((sel = *psel) == NULL)
+        return;
+
+    for (i = 0; i < sel->sy; i++)
+        LEPT_FREE(sel->data[i]);
+    LEPT_FREE(sel->data);
+    if (sel->name)
+        LEPT_FREE(sel->name);
+    LEPT_FREE(sel);
+    *psel = NULL;
+}
+
+
+/*!
+ * \brief   selCopy()
+ *
+ * \param[in]    sel
+ * \return  a copy of the sel, or NULL on error
+ */
+SEL *
+selCopy(SEL  *sel)
+{
+l_int32  sx, sy, cx, cy, i, j;
+SEL     *csel;
+
+    PROCNAME("selCopy");
+
+    if (!sel)
+        return (SEL *)ERROR_PTR("sel not defined", procName, NULL);
+
+    if ((csel = (SEL *)LEPT_CALLOC(1, sizeof(SEL))) == NULL)
+        return (SEL *)ERROR_PTR("csel not made", procName, NULL);
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+    csel->sy = sy;
+    csel->sx = sx;
+    csel->cy = cy;
+    csel->cx = cx;
+
+    if ((csel->data = create2dIntArray(sy, sx)) == NULL) {
+        LEPT_FREE(csel);
+        return (SEL *)ERROR_PTR("sel data not made", procName, NULL);
+    }
+
+    for (i = 0; i < sy; i++)
+        for (j = 0; j < sx; j++)
+            csel->data[i][j] = sel->data[i][j];
+
+    if (sel->name)
+        csel->name = stringNew(sel->name);
+
+    return csel;
+}
+
+
+/*!
+ * \brief   selCreateBrick()
+ *
+ * \param[in]    h, w      height, width
+ * \param[in]    cy, cx    origin, relative to UL corner at 0,0
+ * \param[in]    type      SEL_HIT, SEL_MISS, or SEL_DONT_CARE
+ * \return  sel, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This is a rectangular sel of all hits, misses or don't cares.
+ * </pre>
+ */
+SEL *
+selCreateBrick(l_int32  h,
+               l_int32  w,
+               l_int32  cy,
+               l_int32  cx,
+               l_int32  type)
+{
+l_int32  i, j;
+SEL     *sel;
+
+    PROCNAME("selCreateBrick");
+
+    if (h <= 0 || w <= 0)
+        return (SEL *)ERROR_PTR("h and w must both be > 0", procName, NULL);
+    if (type != SEL_HIT && type != SEL_MISS && type != SEL_DONT_CARE)
+        return (SEL *)ERROR_PTR("invalid sel element type", procName, NULL);
+
+    if ((sel = selCreate(h, w, NULL)) == NULL)
+        return (SEL *)ERROR_PTR("sel not made", procName, NULL);
+    selSetOrigin(sel, cy, cx);
+    for (i = 0; i < h; i++)
+        for (j = 0; j < w; j++)
+            sel->data[i][j] = type;
+
+    return sel;
+}
+
+
+/*!
+ * \brief   selCreateComb()
+ *
+ * \param[in]    factor1     contiguous space between comb tines
+ * \param[in]    factor2     number of comb tines
+ * \param[in]    direction   L_HORIZ, L_VERT
+ * \return  sel, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This generates a comb Sel of hits with the origin as
+ *          near the center as possible.
+ *      (2) In use, this is complemented by a brick sel of size %factor1,
+ *          Both brick and comb sels are made by selectComposableSels().
+ * </pre>
+ */
+SEL *
+selCreateComb(l_int32  factor1,
+              l_int32  factor2,
+              l_int32  direction)
+{
+l_int32  i, size, z;
+SEL     *sel;
+
+    PROCNAME("selCreateComb");
+
+    if (factor1 < 1 || factor2 < 1)
+        return (SEL *)ERROR_PTR("factors must be >= 1", procName, NULL);
+    if (direction != L_HORIZ && direction != L_VERT)
+        return (SEL *)ERROR_PTR("invalid direction", procName, NULL);
+
+    size = factor1 * factor2;
+    if (direction == L_HORIZ) {
+        if ((sel = selCreate(1, size, NULL)) == NULL)
+            return (SEL *)ERROR_PTR("horiz sel not made", procName, NULL);
+        selSetOrigin(sel, 0, size / 2);
+    } else {
+        if ((sel = selCreate(size, 1, NULL)) == NULL)
+            return (SEL *)ERROR_PTR("vert sel not made", procName, NULL);
+        selSetOrigin(sel, size / 2, 0);
+    }
+
+        /* Lay down the elements of the comb */
+    for (i = 0; i < factor2; i++) {
+        z = factor1 / 2 + i * factor1;
+/*        lept_stderr("i = %d, factor1 = %d, factor2 = %d, z = %d\n",
+                      i, factor1, factor2, z); */
+        if (direction == L_HORIZ)
+            selSetElement(sel, 0, z, SEL_HIT);
+        else
+            selSetElement(sel, z, 0, SEL_HIT);
+    }
+
+    return sel;
+}
+
+
+/*!
+ * \brief   create2dIntArray()
+ *
+ * \param[in]    sy     rows == height
+ * \param[in]    sx     columns == width
+ * \return  doubly indexed array i.e., an array of sy row pointers,
+ *              each of which points to an array of sx ints
+ *
+ * <pre>
+ * Notes:
+ *      (1) The array[sy][sx] is indexed in standard "matrix notation",
+ *          with the row index first.
+ * </pre>
+ */
+l_int32 **
+create2dIntArray(l_int32  sy,
+                 l_int32  sx)
+{
+l_int32    i, j, success;
+l_int32  **array;
+
+    PROCNAME("create2dIntArray");
+
+    if (sx <= 0 || sx > MaxKernelSize)
+        return (l_int32 **)ERROR_PTR("sx out of bounds", procName, NULL);
+    if (sy <= 0 || sy > MaxKernelSize)
+        return (l_int32 **)ERROR_PTR("sy out of bounds", procName, NULL);
+
+    if ((array = (l_int32 **)LEPT_CALLOC(sy, sizeof(l_int32 *))) == NULL)
+        return (l_int32 **)ERROR_PTR("ptr array not made", procName, NULL);
+    success = TRUE;
+    for (i = 0; i < sy; i++) {
+        if ((array[i] = (l_int32 *)LEPT_CALLOC(sx, sizeof(l_int32))) == NULL) {
+            success = FALSE;
+            break;
+        }
+    }
+    if (success) return array;
+
+        /* Cleanup after error */
+    for (j = 0; j < i; j++)
+        LEPT_FREE(array[j]);
+    LEPT_FREE(array);
+    return (l_int32 **)ERROR_PTR("array not made", procName, NULL);
+}
+
+
+
+/*------------------------------------------------------------------------*
+ *                           Extension of sela                            *
+ *------------------------------------------------------------------------*/
+/*!
+ * \brief   selaAddSel()
+ *
+ * \param[in]    sela
+ * \param[in]    sel        to be added
+ * \param[in]    selname    ignored if already defined in sel;
+ *                          req'd in sel when added to a sela
+ * \param[in]    copyflag   L_INSERT or L_COPY
+ * \return  0 if OK; 1 on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This adds a sel, either inserting or making a copy.
+ *      (2) Because every sel in a sela must have a name, it copies
+ *          the input name if necessary.  You can input NULL for
+ *          selname if the sel already has a name.
+ * </pre>
+ */
+l_ok
+selaAddSel(SELA        *sela,
+           SEL         *sel,
+           const char  *selname,
+           l_int32      copyflag)
+{
+l_int32  n;
+SEL     *csel;
+
+    PROCNAME("selaAddSel");
+
+    if (!sela)
+        return ERROR_INT("sela not defined", procName, 1);
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    if (!sel->name && !selname)
+        return ERROR_INT("added sel must have name", procName, 1);
+    if (copyflag != L_INSERT && copyflag != L_COPY)
+        return ERROR_INT("invalid copyflag", procName, 1);
+
+    if (copyflag == L_COPY) {
+        if ((csel = selCopy(sel)) == NULL)
+            return ERROR_INT("csel not made", procName, 1);
+    } else {  /* copyflag == L_INSERT */
+        csel = sel;
+    }
+    if (!csel->name)
+        csel->name = stringNew(selname);
+
+    n = selaGetCount(sela);
+    if (n >= sela->nalloc) {
+        if (selaExtendArray(sela)) {
+            if (copyflag != L_INSERT)
+                selDestroy(&csel);
+            return ERROR_INT("extension failed", procName, 1);
+        }
+    }
+
+    sela->sel[n] = csel;
+    sela->n++;
+    return 0;
+}
+
+
+/*!
+ * \brief   selaExtendArray()
+ *
+ * \param[in]    sela
+ * \return  0 if OK; 1 on error
+ */
+static l_int32
+selaExtendArray(SELA  *sela)
+{
+    PROCNAME("selaExtendArray");
+
+    if (!sela)
+        return ERROR_INT("sela not defined", procName, 1);
+
+    if ((sela->sel = (SEL **)reallocNew((void **)&sela->sel,
+                              sizeof(SEL *) * sela->nalloc,
+                              2 * sizeof(SEL *) * sela->nalloc)) == NULL)
+            return ERROR_INT("new ptr array not returned", procName, 1);
+
+    sela->nalloc = 2 * sela->nalloc;
+    return 0;
+}
+
+
+
+/*----------------------------------------------------------------------*
+ *                               Accessors                              *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selaGetCount()
+ *
+ * \param[in]    sela
+ * \return  count, or 0 on error
+ */
+l_int32
+selaGetCount(SELA  *sela)
+{
+    PROCNAME("selaGetCount");
+
+    if (!sela)
+        return ERROR_INT("sela not defined", procName, 0);
+
+    return sela->n;
+}
+
+
+/*!
+ * \brief   selaGetSel()
+ *
+ * \param[in]    sela
+ * \param[in]    i        index of sel to be retrieved not copied
+ * \return  sel, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This returns a ptr to the sel, not a copy, so the caller
+ *          must not destroy it!
+ * </pre>
+ */
+SEL *
+selaGetSel(SELA    *sela,
+           l_int32  i)
+{
+    PROCNAME("selaGetSel");
+
+    if (!sela)
+        return (SEL *)ERROR_PTR("sela not defined", procName, NULL);
+
+    if (i < 0 || i >= sela->n)
+        return (SEL *)ERROR_PTR("invalid index", procName, NULL);
+    return sela->sel[i];
+}
+
+
+/*!
+ * \brief   selGetName()
+ *
+ * \param[in]    sel
+ * \return  sel name not copied, or NULL if no name or on error
+ */
+char *
+selGetName(SEL  *sel)
+{
+    PROCNAME("selGetName");
+
+    if (!sel)
+        return (char *)ERROR_PTR("sel not defined", procName, NULL);
+
+    return sel->name;
+}
+
+
+/*!
+ * \brief   selSetName()
+ *
+ * \param[in]    sel
+ * \param[in]    name    [optional]; can be null
+ * \return  0 if OK, 1 on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) Always frees the existing sel name, if defined.
+ *      (2) If name is not defined, just clears any existing sel name.
+ * </pre>
+ */
+l_ok
+selSetName(SEL         *sel,
+           const char  *name)
+{
+    PROCNAME("selSetName");
+
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+
+    return stringReplace(&sel->name, name);
+}
+
+
+/*!
+ * \brief   selaFindSelByName()
+ *
+ * \param[in]    sela
+ * \param[in]    name      sel name
+ * \param[out]   pindex    [optional]
+ * \param[in]    psel      [optional] sel (not a copy)
+ * \return  0 if OK; 1 on error
+ */
+l_ok
+selaFindSelByName(SELA        *sela,
+                  const char  *name,
+                  l_int32     *pindex,
+                  SEL        **psel)
+{
+l_int32  i, n;
+char    *sname;
+SEL     *sel;
+
+    PROCNAME("selaFindSelByName");
+
+    if (pindex) *pindex = -1;
+    if (psel) *psel = NULL;
+
+    if (!sela)
+        return ERROR_INT("sela not defined", procName, 1);
+
+    n = selaGetCount(sela);
+    for (i = 0; i < n; i++)
+    {
+        if ((sel = selaGetSel(sela, i)) == NULL) {
+            L_WARNING("missing sel\n", procName);
+            continue;
+        }
+
+        sname = selGetName(sel);
+        if (sname && (!strcmp(name, sname))) {
+            if (pindex)
+                *pindex = i;
+            if (psel)
+                *psel = sel;
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+
+/*!
+ * \brief   selGetElement()
+ *
+ * \param[in]    sel
+ * \param[in]    row
+ * \param[in]    col
+ * \param[out]   ptype    SEL_HIT, SEL_MISS, SEL_DONT_CARE
+ * \return  0 if OK; 1 on error
+ */
+l_ok
+selGetElement(SEL      *sel,
+              l_int32   row,
+              l_int32   col,
+              l_int32  *ptype)
+{
+    PROCNAME("selGetElement");
+
+    if (!ptype)
+        return ERROR_INT("&type not defined", procName, 1);
+    *ptype = SEL_DONT_CARE;
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    if (row < 0 || row >= sel->sy)
+        return ERROR_INT("sel row out of bounds", procName, 1);
+    if (col < 0 || col >= sel->sx)
+        return ERROR_INT("sel col out of bounds", procName, 1);
+
+    *ptype = sel->data[row][col];
+    return 0;
+}
+
+
+/*!
+ * \brief   selSetElement()
+ *
+ * \param[in]    sel
+ * \param[in]    row
+ * \param[in]    col
+ * \param[in]    type    SEL_HIT, SEL_MISS, SEL_DONT_CARE
+ * \return  0 if OK; 1 on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) Because we use row and column to index into an array,
+ *          they are always non-negative.  The location of the origin
+ *          (and the type of operation) determine the actual
+ *          direction of the rasterop.
+ * </pre>
+ */
+l_ok
+selSetElement(SEL     *sel,
+              l_int32  row,
+              l_int32  col,
+              l_int32  type)
+{
+    PROCNAME("selSetElement");
+
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    if (type != SEL_HIT && type != SEL_MISS && type != SEL_DONT_CARE)
+        return ERROR_INT("invalid sel element type", procName, 1);
+    if (row < 0 || row >= sel->sy)
+        return ERROR_INT("sel row out of bounds", procName, 1);
+    if (col < 0 || col >= sel->sx)
+        return ERROR_INT("sel col out of bounds", procName, 1);
+
+    sel->data[row][col] = type;
+    return 0;
+}
+
+
+/*!
+ * \brief   selGetParameters()
+ *
+ * \param[in]    sel
+ * \param[out]   psy, psx, pcy, pcx    [optional] each can be null
+ * \return  0 if OK, 1 on error
+ */
+l_ok
+selGetParameters(SEL      *sel,
+                 l_int32  *psy,
+                 l_int32  *psx,
+                 l_int32  *pcy,
+                 l_int32  *pcx)
+{
+    PROCNAME("selGetParameters");
+
+    if (psy) *psy = 0;
+    if (psx) *psx = 0;
+    if (pcy) *pcy = 0;
+    if (pcx) *pcx = 0;
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    if (psy) *psy = sel->sy;
+    if (psx) *psx = sel->sx;
+    if (pcy) *pcy = sel->cy;
+    if (pcx) *pcx = sel->cx;
+    return 0;
+}
+
+
+/*!
+ * \brief   selSetOrigin()
+ *
+ * \param[in]    sel
+ * \param[in]    cy, cx
+ * \return  0 if OK; 1 on error
+ */
+l_ok
+selSetOrigin(SEL     *sel,
+             l_int32  cy,
+             l_int32  cx)
+{
+    PROCNAME("selSetOrigin");
+
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    sel->cy = cy;
+    sel->cx = cx;
+    return 0;
+}
+
+
+/*!
+ * \brief   selGetTypeAtOrigin()
+ *
+ * \param[in]    sel
+ * \param[out]   ptype    SEL_HIT, SEL_MISS, SEL_DONT_CARE
+ * \return  0 if OK; 1 on error or if origin is not found
+ */
+l_ok
+selGetTypeAtOrigin(SEL      *sel,
+                   l_int32  *ptype)
+{
+l_int32  sx, sy, cx, cy, i, j;
+
+    PROCNAME("selGetTypeAtOrigin");
+
+    if (!ptype)
+        return ERROR_INT("&type not defined", procName, 1);
+    *ptype = SEL_DONT_CARE;  /* init */
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+    for (i = 0; i < sy; i++) {
+        for (j = 0; j < sx; j++) {
+            if (i == cy && j == cx) {
+                selGetElement(sel, i, j, ptype);
+                return 0;
+            }
+        }
+    }
+
+    return ERROR_INT("sel origin not found", procName, 1);
+}
+
+
+/*!
+ * \brief   selaGetBrickName()
+ *
+ * \param[in]    sela
+ * \param[in]    hsize, vsize    of brick sel
+ * \return  sel name new string, or NULL if no name or on error
+ */
+char *
+selaGetBrickName(SELA    *sela,
+                 l_int32  hsize,
+                 l_int32  vsize)
+{
+l_int32  i, nsels, sx, sy;
+SEL     *sel;
+
+    PROCNAME("selaGetBrickName");
+
+    if (!sela)
+        return (char *)ERROR_PTR("sela not defined", procName, NULL);
+
+    nsels = selaGetCount(sela);
+    for (i = 0; i < nsels; i++) {
+        sel = selaGetSel(sela, i);
+        selGetParameters(sel, &sy, &sx, NULL, NULL);
+        if (hsize == sx && vsize == sy)
+            return stringNew(selGetName(sel));
+    }
+
+    return (char *)ERROR_PTR("sel not found", procName, NULL);
+}
+
+
+/*!
+ * \brief   selaGetCombName()
+ *
+ * \param[in]    sela
+ * \param[in]    size        the product of sizes of the brick and comb parts
+ * \param[in]    direction   L_HORIZ, L_VERT
+ * \return  sel name new string, or NULL if name not found or on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) Combs are by definition 1-dimensional, either horiz or vert.
+ *      (2) Use this with comb Sels; e.g., from selaAddDwaCombs().
+ * </pre>
+ */
+char *
+selaGetCombName(SELA    *sela,
+                l_int32  size,
+                l_int32  direction)
+{
+char    *selname;
+char     combname[256];
+l_int32  i, nsels, sx, sy, found;
+SEL     *sel;
+
+    PROCNAME("selaGetCombName");
+
+    if (!sela)
+        return (char *)ERROR_PTR("sela not defined", procName, NULL);
+    if (direction != L_HORIZ && direction != L_VERT)
+        return (char *)ERROR_PTR("invalid direction", procName, NULL);
+
+        /* Derive the comb name we're looking for */
+    if (direction == L_HORIZ)
+        snprintf(combname, sizeof(combname), "sel_comb_%dh", size);
+    else  /* direction == L_VERT */
+        snprintf(combname, sizeof(combname), "sel_comb_%dv", size);
+
+    found = FALSE;
+    nsels = selaGetCount(sela);
+    for (i = 0; i < nsels; i++) {
+        sel = selaGetSel(sela, i);
+        selGetParameters(sel, &sy, &sx, NULL, NULL);
+        if (sy != 1 && sx != 1)  /* 2-D; not a comb */
+            continue;
+        selname = selGetName(sel);
+        if (!strcmp(selname, combname)) {
+            found = TRUE;
+            break;
+        }
+    }
+
+    if (found)
+        return stringNew(selname);
+    else
+        return (char *)ERROR_PTR("sel not found", procName, NULL);
+}
+
+
+/* --------- Function used to generate code in this file  ---------- */
+#if 0
+static void selaComputeCompositeParameters(const char *fileout);
+
+/*!
+ * \brief   selaComputeCompParameters()
+ *
+ * \param[in]    fileout
+ * \return  void
+ *
+ * <pre>
+ * Notes:
+ *      (1) This static function was used to construct the comp_parameter_map[]
+ *          array at the top of this file.  It is static because it does
+ *          not need to be called again.  It remains here to show how
+ *          the composite parameter map was computed.
+ *      (2) The output file was pasted directly into comp_parameter_map[].
+ *          The composite parameter map is used to quickly determine
+ *          the linear decomposition parameters and sel names.
+ * </pre>
+ */
+static void
+selaComputeCompositeParameters(const char  *fileout)
+{
+char    *str, *nameh1, *nameh2, *namev1, *namev2;
+char     buf[256];
+l_int32  size, size1, size2, len;
+SARRAY  *sa;
+SELA    *selabasic, *selacomb;
+
+    selabasic = selaAddBasic(NULL);
+    selacomb = selaAddDwaCombs(NULL);
+    sa = sarrayCreate(64);
+    for (size = 2; size < 64; size++) {
+        selectComposableSizes(size, &size1, &size2);
+        nameh1 = selaGetBrickName(selabasic, size1, 1);
+        namev1 = selaGetBrickName(selabasic, 1, size1);
+        if (size2 > 1) {
+            nameh2 = selaGetCombName(selacomb, size1 * size2, L_HORIZ);
+            namev2 = selaGetCombName(selacomb, size1 * size2, L_VERT);
+        } else {
+            nameh2 = stringNew("");
+            namev2 = stringNew("");
+        }
+        snprintf(buf, sizeof(buf),
+                 "      { %d, %d, %d, \"%s\", \"%s\", \"%s\", \"%s\" },",
+                 size, size1, size2, nameh1, nameh2, namev1, namev2);
+        sarrayAddString(sa, buf, L_COPY);
+        LEPT_FREE(nameh1);
+        LEPT_FREE(nameh2);
+        LEPT_FREE(namev1);
+        LEPT_FREE(namev2);
+    }
+    str = sarrayToString(sa, 1);
+    len = strlen(str);
+    l_binaryWrite(fileout, "w", str, len + 1);
+    LEPT_FREE(str);
+    sarrayDestroy(&sa);
+    selaDestroy(&selabasic);
+    selaDestroy(&selacomb);
+}
+#endif
+/* -------------------------------------------------------------------- */
+
+
+/*!
+ * \brief   getCompositeParameters()
+ *
+ * \param[in]    size
+ * \param[out]   psize1    [optional] brick factor size
+ * \param[out]   psize2    [optional] comb factor size
+ * \param[out]   pnameh1   [optional] name of horiz brick
+ * \param[out]   pnameh2   [optional] name of horiz comb
+ * \param[out]   pnamev1   [optional] name of vert brick
+ * \param[out]   pnamev2   [optional] name of vert comb
+ * \return  0 if OK, 1 on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This uses the big lookup table at the top of this file.
+ *      (2) All returned strings are copies that must be freed.
+ * </pre>
+ */
+l_ok
+getCompositeParameters(l_int32   size,
+                       l_int32  *psize1,
+                       l_int32  *psize2,
+                       char    **pnameh1,
+                       char    **pnameh2,
+                       char    **pnamev1,
+                       char    **pnamev2)
+{
+l_int32  index;
+
+    PROCNAME("selaGetSelnames");
+
+    if (psize1) *psize1 = 0;
+    if (psize2) *psize2 = 0;
+    if (pnameh1) *pnameh1 = NULL;
+    if (pnameh2) *pnameh2 = NULL;
+    if (pnamev1) *pnamev1 = NULL;
+    if (pnamev2) *pnamev2 = NULL;
+    if (size < 2 || size > 63)
+        return ERROR_INT("valid size range is {2 ... 63}", procName, 1);
+    index = size - 2;
+    if (psize1)
+        *psize1 = comp_parameter_map[index].size1;
+    if (psize2)
+        *psize2 = comp_parameter_map[index].size2;
+    if (pnameh1)
+        *pnameh1 = stringNew(comp_parameter_map[index].selnameh1);
+    if (pnameh2)
+        *pnameh2 = stringNew(comp_parameter_map[index].selnameh2);
+    if (pnamev1)
+        *pnamev1 = stringNew(comp_parameter_map[index].selnamev1);
+    if (pnamev2)
+        *pnamev2 = stringNew(comp_parameter_map[index].selnamev2);
+    return 0;
+}
+
+
+/*!
+ * \brief   selaGetSelnames()
+ *
+ * \param[in]    sela
+ * \return  sa of all sel names, or NULL on error
+ */
+SARRAY *
+selaGetSelnames(SELA  *sela)
+{
+char    *selname;
+l_int32  i, n;
+SEL     *sel;
+SARRAY  *sa;
+
+    PROCNAME("selaGetSelnames");
+
+    if (!sela)
+        return (SARRAY *)ERROR_PTR("sela not defined", procName, NULL);
+    if ((n = selaGetCount(sela)) == 0)
+        return (SARRAY *)ERROR_PTR("no sels in sela", procName, NULL);
+
+    if ((sa = sarrayCreate(n)) == NULL)
+        return (SARRAY *)ERROR_PTR("sa not made", procName, NULL);
+    for (i = 0; i < n; i++) {
+        sel = selaGetSel(sela, i);
+        selname = selGetName(sel);
+        sarrayAddString(sa, selname, L_COPY);
+    }
+
+    return sa;
+}
+
+
+
+/*----------------------------------------------------------------------*
+ *                Max translations for erosion and hmt                  *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selFindMaxTranslations()
+ *
+ * \param[in]    sel
+ * \param[out]   pxp, pyp, pxn, pyn     max shifts
+ * \return  0 if OK; 1 on error
+ *
+ * <pre>
+ * Notes:
+          These are the maximum shifts for the erosion operation.
+ *        For example, when j < cx, the shift of the image
+ *        is +x to the cx.  This is a positive xp shift.
+ * </pre>
+ */
+l_ok
+selFindMaxTranslations(SEL      *sel,
+                       l_int32  *pxp,
+                       l_int32  *pyp,
+                       l_int32  *pxn,
+                       l_int32  *pyn)
+{
+l_int32  sx, sy, cx, cy, i, j;
+l_int32  maxxp, maxyp, maxxn, maxyn;
+
+    PROCNAME("selaFindMaxTranslations");
+
+    if (!pxp || !pyp || !pxn || !pyn)
+        return ERROR_INT("&xp (etc) defined", procName, 1);
+    *pxp = *pyp = *pxn = *pyn = 0;
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+
+    maxxp = maxyp = maxxn = maxyn = 0;
+    for (i = 0; i < sy; i++) {
+        for (j = 0; j < sx; j++) {
+            if (sel->data[i][j] == 1) {
+                maxxp = L_MAX(maxxp, cx - j);
+                maxyp = L_MAX(maxyp, cy - i);
+                maxxn = L_MAX(maxxn, j - cx);
+                maxyn = L_MAX(maxyn, i - cy);
+            }
+        }
+    }
+
+    *pxp = maxxp;
+    *pyp = maxyp;
+    *pxn = maxxn;
+    *pyn = maxyn;
+
+    return 0;
+}
+
+
+/*----------------------------------------------------------------------*
+ *                   Rotation by multiples of 90 degrees                *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selRotateOrth()
+ *
+ * \param[in]    sel
+ * \param[in]    quads    0 - 4; number of 90 degree cw rotations
+ * \return  seld, or NULL on error
+ */
+SEL  *
+selRotateOrth(SEL     *sel,
+              l_int32  quads)
+{
+l_int32  i, j, ni, nj, sx, sy, cx, cy, nsx, nsy, ncx, ncy, type;
+SEL     *seld;
+
+    PROCNAME("selRotateOrth");
+
+    if (!sel)
+        return (SEL *)ERROR_PTR("sel not defined", procName, NULL);
+    if (quads < 0 || quads > 4)
+        return (SEL *)ERROR_PTR("quads not in {0,1,2,3,4}", procName, NULL);
+    if (quads == 0 || quads == 4)
+        return selCopy(sel);
+
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+    if (quads == 1) {  /* 90 degrees cw */
+        nsx = sy;
+        nsy = sx;
+        ncx = sy - cy - 1;
+        ncy = cx;
+    } else if (quads == 2) {  /* 180 degrees cw */
+        nsx = sx;
+        nsy = sy;
+        ncx = sx - cx - 1;
+        ncy = sy - cy - 1;
+    } else {  /* 270 degrees cw */
+        nsx = sy;
+        nsy = sx;
+        ncx = cy;
+        ncy = sx - cx - 1;
+    }
+    seld = selCreateBrick(nsy, nsx, ncy, ncx, SEL_DONT_CARE);
+    if (sel->name)
+        seld->name = stringNew(sel->name);
+
+    for (i = 0; i < sy; i++) {
+        for (j = 0; j < sx; j++) {
+            selGetElement(sel, i, j, &type);
+            if (quads == 1) {
+               ni = j;
+               nj = sy - i - 1;
+            } else if (quads == 2) {
+               ni = sy - i - 1;
+               nj = sx - j - 1;
+            } else {  /* quads == 3 */
+               ni = sx - j - 1;
+               nj = i;
+            }
+            selSetElement(seld, ni, nj, type);
+        }
+    }
+
+    return seld;
+}
+
+
+/*----------------------------------------------------------------------*
+ *                       Sela and Sel serialized I/O                    *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selaRead()
+ *
+ * \param[in]    fname    filename
+ * \return  sela, or NULL on error
+ */
+SELA *
+selaRead(const char  *fname)
+{
+FILE  *fp;
+SELA  *sela;
+
+    PROCNAME("selaRead");
+
+    if (!fname)
+        return (SELA *)ERROR_PTR("fname not defined", procName, NULL);
+
+    if ((fp = fopenReadStream(fname)) == NULL)
+        return (SELA *)ERROR_PTR("stream not opened", procName, NULL);
+    if ((sela = selaReadStream(fp)) == NULL) {
+        fclose(fp);
+        return (SELA *)ERROR_PTR("sela not returned", procName, NULL);
+    }
+    fclose(fp);
+
+    return sela;
+}
+
+
+/*!
+ * \brief   selaReadStream()
+ *
+ * \param[in]    fp    file stream
+ * \return  sela, or NULL on error
+ */
+SELA  *
+selaReadStream(FILE  *fp)
+{
+l_int32  i, n, version;
+SEL     *sel;
+SELA    *sela;
+
+    PROCNAME("selaReadStream");
+
+    if (!fp)
+        return (SELA *)ERROR_PTR("stream not defined", procName, NULL);
+
+    if (fscanf(fp, "\nSela Version %d\n", &version) != 1)
+        return (SELA *)ERROR_PTR("not a sela file", procName, NULL);
+    if (version != SEL_VERSION_NUMBER)
+        return (SELA *)ERROR_PTR("invalid sel version", procName, NULL);
+    if (fscanf(fp, "Number of Sels = %d\n\n", &n) != 1)
+        return (SELA *)ERROR_PTR("not a sela file", procName, NULL);
+
+    if ((sela = selaCreate(n)) == NULL)
+        return (SELA *)ERROR_PTR("sela not made", procName, NULL);
+    sela->nalloc = n;
+
+    for (i = 0; i < n; i++) {
+        if ((sel = selReadStream(fp)) == NULL) {
+            selaDestroy(&sela);
+            return (SELA *)ERROR_PTR("sel not read", procName, NULL);
+        }
+        selaAddSel(sela, sel, NULL, 0);
+    }
+
+    return sela;
+}
+
+
+/*!
+ * \brief   selRead()
+ *
+ * \param[in]    fname    filename
+ * \return  sel, or NULL on error
+ */
+SEL  *
+selRead(const char  *fname)
+{
+FILE  *fp;
+SEL   *sel;
+
+    PROCNAME("selRead");
+
+    if (!fname)
+        return (SEL *)ERROR_PTR("fname not defined", procName, NULL);
+
+    if ((fp = fopenReadStream(fname)) == NULL)
+        return (SEL *)ERROR_PTR("stream not opened", procName, NULL);
+    if ((sel = selReadStream(fp)) == NULL) {
+        fclose(fp);
+        return (SEL *)ERROR_PTR("sela not returned", procName, NULL);
+    }
+    fclose(fp);
+
+    return sel;
+}
+
+
+/*!
+ * \brief   selReadStream()
+ *
+ * \param[in]    fp    file stream
+ * \return  sel, or NULL on error
+ */
+SEL  *
+selReadStream(FILE  *fp)
+{
+char     selname[256];
+char     linebuf[256];
+l_int32  sy, sx, cy, cx, i, j, version, ignore;
+SEL     *sel;
+
+    PROCNAME("selReadStream");
+
+    if (!fp)
+        return (SEL *)ERROR_PTR("stream not defined", procName, NULL);
+
+    if (fscanf(fp, "  Sel Version %d\n", &version) != 1)
+        return (SEL *)ERROR_PTR("not a sel file", procName, NULL);
+    if (version != SEL_VERSION_NUMBER)
+        return (SEL *)ERROR_PTR("invalid sel version", procName, NULL);
+
+    if (fgets(linebuf, sizeof(linebuf), fp) == NULL)
+        return (SEL *)ERROR_PTR("error reading into linebuf", procName, NULL);
+    sscanf(linebuf, "  ------  %200s  ------", selname);
+
+    if (fscanf(fp, "  sy = %d, sx = %d, cy = %d, cx = %d\n",
+               &sy, &sx, &cy, &cx) != 4)
+        return (SEL *)ERROR_PTR("dimensions not read", procName, NULL);
+
+    if ((sel = selCreate(sy, sx, selname)) == NULL)
+        return (SEL *)ERROR_PTR("sel not made", procName, NULL);
+    selSetOrigin(sel, cy, cx);
+
+    for (i = 0; i < sy; i++) {
+        ignore = fscanf(fp, "    ");
+        for (j = 0; j < sx; j++)
+            ignore = fscanf(fp, "%1d", &sel->data[i][j]);
+        ignore = fscanf(fp, "\n");
+    }
+    ignore = fscanf(fp, "\n");
+
+    return sel;
+}
+
+
+/*!
+ * \brief   selaWrite()
+ *
+ * \param[in]    fname    filename
+ * \param[in]    sela
+ * \return  0 if OK, 1 on error
+ */
+l_ok
+selaWrite(const char  *fname,
+          SELA        *sela)
+{
+FILE  *fp;
+
+    PROCNAME("selaWrite");
+
+    if (!fname)
+        return ERROR_INT("fname not defined", procName, 1);
+    if (!sela)
+        return ERROR_INT("sela not defined", procName, 1);
+
+    if ((fp = fopenWriteStream(fname, "wb")) == NULL)
+        return ERROR_INT("stream not opened", procName, 1);
+    selaWriteStream(fp, sela);
+    fclose(fp);
+
+    return 0;
+}
+
+
+/*!
+ * \brief   selaWriteStream()
+ *
+ * \param[in]    fp    file stream
+ * \param[in]    sela
+ * \return  0 if OK, 1 on error
+ */
+l_ok
+selaWriteStream(FILE  *fp,
+                SELA  *sela)
+{
+l_int32  i, n;
+SEL     *sel;
+
+    PROCNAME("selaWriteStream");
+
+    if (!fp)
+        return ERROR_INT("stream not defined", procName, 1);
+    if (!sela)
+        return ERROR_INT("sela not defined", procName, 1);
+
+    n = selaGetCount(sela);
+    fprintf(fp, "\nSela Version %d\n", SEL_VERSION_NUMBER);
+    fprintf(fp, "Number of Sels = %d\n\n", n);
+    for (i = 0; i < n; i++) {
+        if ((sel = selaGetSel(sela, i)) == NULL)
+            continue;
+        selWriteStream(fp, sel);
+    }
+    return 0;
+}
+
+
+/*!
+ * \brief   selWrite()
+ *
+ * \param[in]    fname    filename
+ * \param[in]    sel
+ * \return  0 if OK, 1 on error
+ */
+l_ok
+selWrite(const char  *fname,
+         SEL         *sel)
+{
+FILE  *fp;
+
+    PROCNAME("selWrite");
+
+    if (!fname)
+        return ERROR_INT("fname not defined", procName, 1);
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+
+    if ((fp = fopenWriteStream(fname, "wb")) == NULL)
+        return ERROR_INT("stream not opened", procName, 1);
+    selWriteStream(fp, sel);
+    fclose(fp);
+
+    return 0;
+}
+
+
+/*!
+ * \brief   selWriteStream()
+ *
+ * \param[in]    fp    file stream
+ * \param[in]    sel
+ * \return  0 if OK, 1 on error
+ */
+l_ok
+selWriteStream(FILE  *fp,
+               SEL   *sel)
+{
+l_int32  sx, sy, cx, cy, i, j;
+
+    PROCNAME("selWriteStream");
+
+    if (!fp)
+        return ERROR_INT("stream not defined", procName, 1);
+    if (!sel)
+        return ERROR_INT("sel not defined", procName, 1);
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+
+    fprintf(fp, "  Sel Version %d\n", SEL_VERSION_NUMBER);
+    fprintf(fp, "  ------  %s  ------\n", selGetName(sel));
+    fprintf(fp, "  sy = %d, sx = %d, cy = %d, cx = %d\n", sy, sx, cy, cx);
+    for (i = 0; i < sy; i++) {
+        fprintf(fp, "    ");
+        for (j = 0; j < sx; j++)
+            fprintf(fp, "%d", sel->data[i][j]);
+        fprintf(fp, "\n");
+    }
+    fprintf(fp, "\n");
+
+    return 0;
+}
+
+
+/*----------------------------------------------------------------------*
+ *           Building custom hit-miss sels from compiled strings        *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selCreateFromString()
+ *
+ * \param[in]    text
+ * \param[in]    h, w    height, width
+ * \param[in]    name    [optional] sel name; can be null
+ * \return  sel of the given size, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) The text is an array of chars (in row-major order) where
+ *          each char can be one of the following:
+ *             'x': hit
+ *             'o': miss
+ *             ' ': don't-care
+ *      (2) When the origin falls on a hit or miss, use an upper case
+ *          char (e.g., 'X' or 'O') to indicate it.  When the origin
+ *          falls on a don't-care, indicate this with a 'C'.
+ *          The string must have exactly one origin specified.
+ *      (3) The advantage of this method is that the text can be input
+ *          in a format that shows the 2D layout of the Sel; e.g.,
+ * \code
+ *              static const char *seltext = "x    "
+ *                                           "x Oo "
+ *                                           "x    "
+ *                                           "xxxxx";
+ * \endcode
+ * </pre>
+ */
+SEL *
+selCreateFromString(const char  *text,
+                    l_int32      h,
+                    l_int32      w,
+                    const char  *name)
+{
+SEL     *sel;
+l_int32  y, x, norig;
+char     ch;
+
+    PROCNAME("selCreateFromString");
+
+    if (!text || text[0] == '\0')
+        return (SEL *)ERROR_PTR("text undefined or empty", procName, NULL);
+    if (h < 1)
+        return (SEL *)ERROR_PTR("height must be > 0", procName, NULL);
+    if (w < 1)
+        return (SEL *)ERROR_PTR("width must be > 0", procName, NULL);
+    if (strlen(text) != (size_t)w * h)
+        return (SEL *)ERROR_PTR("text size != w * h", procName, NULL);
+
+    sel = selCreate(h, w, name);
+    norig = 0;
+    for (y = 0; y < h; ++y) {
+        for (x = 0; x < w; ++x) {
+            ch = *(text++);
+            switch (ch)
+            {
+                case 'X':
+                    norig++;
+                    selSetOrigin(sel, y, x);
+                    /* fall through */
+                case 'x':
+                    selSetElement(sel, y, x, SEL_HIT);
+                    break;
+
+                case 'O':
+                    norig++;
+                    selSetOrigin(sel, y, x);
+                    /* fall through */
+                case 'o':
+                    selSetElement(sel, y, x, SEL_MISS);
+                    break;
+
+                case 'C':
+                    norig++;
+                    selSetOrigin(sel, y, x);
+                    /* fall through */
+                case ' ':
+                    selSetElement(sel, y, x, SEL_DONT_CARE);
+                    break;
+
+                case '\n':
+                    /* ignored */
+                    continue;
+
+                default:
+                    selDestroy(&sel);
+                    return (SEL *)ERROR_PTR("unknown char", procName, NULL);
+            }
+        }
+    }
+    if (norig != 1) {
+        L_ERROR("Exactly one origin must be specified; this string has %d\n",
+                procName, norig);
+        selDestroy(&sel);
+    }
+
+    return sel;
+}
+
+
+/*!
+ * \brief   selPrintToString()
+ *
+ * \param[in]    sel
+ * \return  str string; caller must free
+ *
+ * <pre>
+ * Notes:
+ *      (1) This is an inverse function of selCreateFromString.
+ *          It prints a textual representation of the SEL to a malloc'd
+ *          string.  The format is the same as selCreateFromString
+ *          except that newlines are inserted into the output
+ *          between rows.
+ *      (2) This is useful for debugging.  However, if you want to
+ *          save some Sels in a file, put them in a Sela and write
+ *          them out with selaWrite().  They can then be read in
+ *          with selaRead().
+ * </pre>
+ */
+char *
+selPrintToString(SEL  *sel)
+{
+char     is_center;
+char    *str, *strptr;
+l_int32  type;
+l_int32  sx, sy, cx, cy, x, y;
+
+    PROCNAME("selPrintToString");
+
+    if (!sel)
+        return (char *)ERROR_PTR("sel not defined", procName, NULL);
+
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+    if ((str = (char *)LEPT_CALLOC(1, sy * (sx + 1) + 1)) == NULL)
+        return (char *)ERROR_PTR("calloc fail for str", procName, NULL);
+    strptr = str;
+
+    for (y = 0; y < sy; ++y) {
+        for (x = 0; x < sx; ++x) {
+            selGetElement(sel, y, x, &type);
+            is_center = (x == cx && y == cy);
+            switch (type) {
+                case SEL_HIT:
+                    *(strptr++) = is_center ? 'X' : 'x';
+                    break;
+                case SEL_MISS:
+                    *(strptr++) = is_center ? 'O' : 'o';
+                    break;
+                case SEL_DONT_CARE:
+                    *(strptr++) = is_center ? 'C' : ' ';
+                    break;
+            }
+        }
+        *(strptr++) = '\n';
+    }
+
+    return str;
+}
+
+
+/*----------------------------------------------------------------------*
+ *         Building custom hit-miss sels from a simple file format      *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selaCreateFromFile()
+ *
+ * \param[in]    filename
+ * \return  sela, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) The file contains a sequence of Sel descriptions.
+ *      (2) Each Sel is formatted as follows:
+ *           ~ Any number of comment lines starting with '#' are ignored
+ *           ~ The next line contains the selname
+ *           ~ The next lines contain the Sel data.  They must be
+ *             formatted similarly to the string format in
+ *             selCreateFromString(), with each line beginning and
+ *             ending with a double-quote, and showing the 2D layout.
+ *           ~ Each Sel ends when a blank line, a comment line, or
+ *             the end of file is reached.
+ *      (3) See selCreateFromString() for a description of the string
+ *          format for the Sel data.  As an example, here are the lines
+ *          of is a valid file for a single Sel.  In the file, all lines
+ *          are left-justified:
+ *                    # diagonal sel
+ *                    sel_5diag
+ *                    "x    "
+ *                    " x   "
+ *                    "  X  "
+ *                    "   x "
+ *                    "    x"
+ * </pre>
+ */
+SELA *
+selaCreateFromFile(const char  *filename)
+{
+char    *filestr, *line;
+l_int32  i, n, first, last, nsel, insel;
+size_t   nbytes;
+NUMA    *nafirst, *nalast;
+SARRAY  *sa;
+SEL     *sel;
+SELA    *sela;
+
+    PROCNAME("selaCreateFromFile");
+
+    if (!filename)
+        return (SELA *)ERROR_PTR("filename not defined", procName, NULL);
+
+    filestr = (char *)l_binaryRead(filename, &nbytes);
+    sa = sarrayCreateLinesFromString(filestr, 1);
+    LEPT_FREE(filestr);
+    n = sarrayGetCount(sa);
+    sela = selaCreate(0);
+
+        /* Find the start and end lines for each Sel.
+         * We allow the "blank" lines to be null strings or
+         * to have standard whitespace (' ','\t',\'n') or be '#'. */
+    nafirst = numaCreate(0);
+    nalast = numaCreate(0);
+    insel = FALSE;
+    for (i = 0; i < n; i++) {
+        line = sarrayGetString(sa, i, L_NOCOPY);
+        if (!insel &&
+            (line[0] != '\0' && line[0] != ' ' &&
+             line[0] != '\t' && line[0] != '\n' && line[0] != '#')) {
+            numaAddNumber(nafirst, i);
+            insel = TRUE;
+            continue;
+        }
+        if (insel &&
+            (line[0] == '\0' || line[0] == ' ' ||
+             line[0] == '\t' || line[0] == '\n' || line[0] == '#')) {
+            numaAddNumber(nalast, i - 1);
+            insel = FALSE;
+            continue;
+        }
+    }
+    if (insel)  /* fell off the end of the file */
+        numaAddNumber(nalast, n - 1);
+
+        /* Extract sels */
+    nsel = numaGetCount(nafirst);
+    for (i = 0; i < nsel; i++) {
+        numaGetIValue(nafirst, i, &first);
+        numaGetIValue(nalast, i, &last);
+        if ((sel = selCreateFromSArray(sa, first, last)) == NULL) {
+            lept_stderr("Error reading sel from %d to %d\n", first, last);
+            selaDestroy(&sela);
+            sarrayDestroy(&sa);
+            numaDestroy(&nafirst);
+            numaDestroy(&nalast);
+            return (SELA *)ERROR_PTR("bad sela file", procName, NULL);
+        }
+        selaAddSel(sela, sel, NULL, 0);
+    }
+
+    numaDestroy(&nafirst);
+    numaDestroy(&nalast);
+    sarrayDestroy(&sa);
+    return sela;
+}
+
+
+/*!
+ * \brief   selCreateFromSArray()
+ *
+ * \param[in]    sa
+ * \param[in]    first    line of sarray where Sel begins
+ * \param[in]    last     line of sarray where Sel ends
+ * \return  sela, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) The Sel contains the following lines:
+ *          ~ The first line is the selname
+ *          ~ The remaining lines contain the Sel data.  They must
+ *            be formatted similarly to the string format in
+ *            selCreateFromString(), with each line beginning and
+ *            ending with a double-quote, and showing the 2D layout.
+ *          ~ 'last' gives the last line in the Sel data.
+ *      (2) See selCreateFromString() for a description of the string
+ *          format for the Sel data.  As an example, here are the lines
+ *          of is a valid file for a single Sel.  In the file, all lines
+ *          are left-justified:
+ *                    # diagonal sel
+ *                    sel_5diag
+ *                    "x    "
+ *                    " x   "
+ *                    "  X  "
+ *                    "   x "
+ *                    "    x"
+ * </pre>
+ */
+static SEL *
+selCreateFromSArray(SARRAY  *sa,
+                    l_int32  first,
+                    l_int32  last)
+{
+char     ch;
+char    *name, *line;
+l_int32  n, len, i, w, h, y, x;
+SEL     *sel;
+
+    PROCNAME("selCreateFromSArray");
+
+    if (!sa)
+        return (SEL *)ERROR_PTR("sa not defined", procName, NULL);
+    n = sarrayGetCount(sa);
+    if (first < 0 || first >= n || last <= first || last >= n)
+        return (SEL *)ERROR_PTR("invalid range", procName, NULL);
+
+    name = sarrayGetString(sa, first, L_NOCOPY);
+    h = last - first;
+    line = sarrayGetString(sa, first + 1, L_NOCOPY);
+    len = strlen(line);
+    if (line[0] != '"' || line[len - 1] != '"')
+        return (SEL *)ERROR_PTR("invalid format", procName, NULL);
+    w = len - 2;
+    if ((sel = selCreate(h, w, name)) == NULL)
+        return (SEL *)ERROR_PTR("sel not made", procName, NULL);
+    for (i = first + 1; i <= last; i++) {
+        line = sarrayGetString(sa, i, L_NOCOPY);
+        y = i - first - 1;
+        for (x = 0; x < w; ++x) {
+            ch = line[x + 1];  /* skip the leading double-quote */
+            switch (ch)
+            {
+                case 'X':
+                    selSetOrigin(sel, y, x);  /* set origin and hit */
+                    /* fall through */
+                case 'x':
+                    selSetElement(sel, y, x, SEL_HIT);
+                    break;
+
+                case 'O':
+                    selSetOrigin(sel, y, x);  /* set origin and miss */
+                    /* fall through */
+                case 'o':
+                    selSetElement(sel, y, x, SEL_MISS);
+                    break;
+
+                case 'C':
+                    selSetOrigin(sel, y, x);  /* set origin and don't-care */
+                    /* fall through */
+                case ' ':
+                    selSetElement(sel, y, x, SEL_DONT_CARE);
+                    break;
+
+                default:
+                    selDestroy(&sel);
+                    return (SEL *)ERROR_PTR("unknown char", procName, NULL);
+            }
+        }
+    }
+
+    return sel;
+}
+
+
+/*----------------------------------------------------------------------*
+ *               Making hit-only SELs from Pta and Pix                  *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selCreateFromPta()
+ *
+ * \param[in]    pta
+ * \param[in]    cy, cx    origin of sel
+ * \param[in]    name      [optional] sel name; can be null
+ * \return  sel of minimum required size, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) The origin and all points in the pta must be positive.
+ * </pre>
+ */
+SEL *
+selCreateFromPta(PTA         *pta,
+                 l_int32      cy,
+                 l_int32      cx,
+                 const char  *name)
+{
+l_int32  i, n, x, y, w, h;
+BOX     *box;
+SEL     *sel;
+
+    PROCNAME("selCreateFromPta");
+
+    if (!pta)
+        return (SEL *)ERROR_PTR("pta not defined", procName, NULL);
+    if (cy < 0 || cx < 0)
+        return (SEL *)ERROR_PTR("(cy, cx) not both >= 0", procName, NULL);
+    n = ptaGetCount(pta);
+    if (n == 0)
+        return (SEL *)ERROR_PTR("no pts in pta", procName, NULL);
+
+    box = ptaGetBoundingRegion(pta);
+    boxGetGeometry(box, &x, &y, &w, &h);
+    boxDestroy(&box);
+    if (x < 0 || y < 0)
+        return (SEL *)ERROR_PTR("not all x and y >= 0", procName, NULL);
+
+    sel = selCreate(y + h, x + w, name);
+    selSetOrigin(sel, cy, cx);
+    for (i = 0; i < n; i++) {
+        ptaGetIPt(pta, i, &x, &y);
+        selSetElement(sel, y, x, SEL_HIT);
+    }
+
+    return sel;
+}
+
+
+/*!
+ * \brief   selCreateFromPix()
+ *
+ * \param[in]    pix
+ * \param[in]    cy, cx    origin of sel
+ * \param[in]    name      [optional] sel name; can be null
+ * \return  sel, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) The origin must be positive.
+ *      (2) The pix must not exceed MaxPixTemplateSize in either dimension.
+ *          and the total number of hits must not exceed MaxPixTemplateHits.
+ * </pre>
+ */
+SEL *
+selCreateFromPix(PIX         *pix,
+                 l_int32      cy,
+                 l_int32      cx,
+                 const char  *name)
+{
+SEL      *sel;
+l_int32   i, j, w, h, d, nhits;
+l_uint32  val;
+
+    PROCNAME("selCreateFromPix");
+
+    if (!pix)
+        return (SEL *)ERROR_PTR("pix not defined", procName, NULL);
+    if (cy < 0 || cx < 0)
+        return (SEL *)ERROR_PTR("(cy, cx) not both >= 0", procName, NULL);
+    pixGetDimensions(pix, &w, &h, &d);
+    if (d != 1)
+        return (SEL *)ERROR_PTR("pix not 1 bpp", procName, NULL);
+    if (w > MaxPixTemplateSize || h > MaxPixTemplateSize) {
+        L_ERROR("pix template too large (w = %d, h = %d)\n", procName, w, h);
+        return NULL;
+    }
+    pixCountPixels(pix, &nhits, NULL);
+    if (nhits > MaxPixTemplateHits) {
+        L_ERROR("too many hits (%d) in pix template\n", procName, nhits);
+        return NULL;
+    }
+
+    sel = selCreate(h, w, name);
+    selSetOrigin(sel, cy, cx);
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < w; j++) {
+            pixGetPixel(pix, j, i, &val);
+            if (val)
+                selSetElement(sel, i, j, SEL_HIT);
+        }
+    }
+
+    return sel;
+}
+
+
+/*----------------------------------------------------------------------*
+ *            Making hit-miss sels from color Pix and image files             *
+ *----------------------------------------------------------------------*/
+/*!
+ *
+ *  selReadFromColorImage()
+ *
+ * \param[in]    pathname
+ * \return  sel if OK; NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) Loads an image from a file and creates a (hit-miss) sel.
+ *      (2) The sel name is taken from the pathname without the directory
+ *          and extension.
+ * </pre>
+ */
+SEL *
+selReadFromColorImage(const char  *pathname)
+{
+PIX   *pix;
+SEL   *sel;
+char  *basename, *selname;
+
+    PROCNAME("selReadFromColorImage");
+
+    splitPathAtExtension (pathname, &basename, NULL);
+    splitPathAtDirectory (basename, NULL, &selname);
+    LEPT_FREE(basename);
+
+    if ((pix = pixRead(pathname)) == NULL) {
+        LEPT_FREE(selname);
+        return (SEL *)ERROR_PTR("pix not returned", procName, NULL);
+    }
+    if ((sel = selCreateFromColorPix(pix, selname)) == NULL)
+        L_ERROR("sel not made\n", procName);
+
+    LEPT_FREE(selname);
+    pixDestroy(&pix);
+    return sel;
+}
+
+
+/*!
+ *
+ *  selCreateFromColorPix()
+ *
+ * \param[in]    pixs      cmapped or rgb
+ * \param[in]    selname   [optional] sel name; can be null
+ * \return  sel if OK, NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) The sel size is given by the size of pixs.
+ *      (2) In pixs, hits are represented by green pixels, misses by red
+ *          pixels, and don't-cares by white pixels.
+ *      (3) In pixs, there may be no misses, but there must be at least 1 hit.
+ *      (4) At most there can be only one origin pixel, which is optionally
+ *          specified by using a lower-intensity pixel:
+ *            if a hit:  dark green
+ *            if a miss: dark red
+ *            if a don't care: gray
+ *          If there is no such pixel, the origin defaults to the approximate
+ *          center of the sel.
+ * </pre>
+ */
+SEL *
+selCreateFromColorPix(PIX         *pixs,
+                      const char  *selname)
+{
+PIXCMAP  *cmap;
+SEL      *sel;
+l_int32   hascolor, num_origins, nohits;
+l_int32   w, h, d, i, j, red, green, blue;
+l_uint32  pixval;
+
+    PROCNAME("selCreateFromColorPix");
+
+    if (!pixs)
+        return (SEL *)ERROR_PTR("pixs not defined", procName, NULL);
+
+    hascolor = FALSE;
+    cmap = pixGetColormap(pixs);
+    if (cmap)
+        pixcmapHasColor(cmap, &hascolor);
+    pixGetDimensions(pixs, &w, &h, &d);
+    if (hascolor == FALSE && d != 32)
+        return (SEL *)ERROR_PTR("pixs has no color", procName, NULL);
+
+    if ((sel = selCreate (h, w, NULL)) == NULL)
+        return (SEL *)ERROR_PTR ("sel not made", procName, NULL);
+    selSetOrigin (sel, h / 2, w / 2);  /* default */
+    selSetName(sel, selname);
+
+    num_origins = 0;
+    nohits = TRUE;
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < w; j++) {
+            pixGetPixel (pixs, j, i, &pixval);
+
+            if (cmap) {
+                pixcmapGetColor (cmap, pixval, &red, &green, &blue);
+            } else {
+                red = GET_DATA_BYTE (&pixval, COLOR_RED);
+                green = GET_DATA_BYTE (&pixval, COLOR_GREEN);
+                blue = GET_DATA_BYTE (&pixval, COLOR_BLUE);
+            }
+
+            if (red < 255 && green < 255 && blue < 255) {
+                num_origins++;
+                if (num_origins == 1)  /* first one found */
+                    selSetOrigin (sel, i, j);
+                if (num_origins == 2)
+                    L_WARNING("multiple origins in sel image\n", procName);
+            }
+            if (!red && green && !blue) {
+                nohits = FALSE;
+                selSetElement (sel, i, j, SEL_HIT);
+            } else if (red && !green && !blue) {
+                selSetElement (sel, i, j, SEL_MISS);
+            } else if (red && green && blue) {
+                selSetElement (sel, i, j, SEL_DONT_CARE);
+            } else {
+                selDestroy(&sel);
+                return (SEL *)ERROR_PTR("invalid color", procName, NULL);
+            }
+        }
+    }
+
+    if (nohits) {
+        selDestroy(&sel);
+        return (SEL *)ERROR_PTR("no hits in sel", procName, NULL);
+    }
+    return sel;
+}
+
+
+/*!
+ *
+ *  selaCreateFromColorPixa()
+ *
+ * \param[in]    pixa      color pixa representing the sels
+ * \param[in]    sa        sarray of sel names
+ * \return  sel if OK, NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) See notes in selCreateFromColorPix()
+ *      (2) sa is required because all sels that are put in a sela
+ *          must have a name.
+ * </pre>
+ */
+SELA *
+selaCreateFromColorPixa(PIXA    *pixa,
+                        SARRAY  *sa)
+{
+char    *str;
+l_int32  i, n;
+PIX     *pix;
+SEL     *sel;
+SELA    *sela;
+
+    PROCNAME("selaCreateFromColorPixa");
+
+    if (!pixa)
+        return (SELA *)ERROR_PTR("pixa not defined", procName, NULL);
+    if (!sa)
+        return (SELA *)ERROR_PTR("sa of sel names not defined", procName, NULL);
+
+    n = pixaGetCount(pixa);
+    if ((sela = selaCreate(n)) == NULL)
+        return (SELA *)ERROR_PTR("sela not allocated", procName, NULL);
+    for (i = 0; i < n; i++) {
+        pix = pixaGetPix(pixa, i, L_CLONE);
+        str = sarrayGetString(sa, i, L_NOCOPY);
+        sel = selCreateFromColorPix(pix, str);
+        selaAddSel(sela, sel, NULL, L_INSERT);
+        pixDestroy(&pix);
+    }
+    return sela;
+}
+
+
+/*----------------------------------------------------------------------*
+ *                     Printable display of sel                         *
+ *----------------------------------------------------------------------*/
+/*!
+ * \brief   selDisplayInPix()
+ *
+ * \param[in]    sel
+ * \param[in]    size     of grid interiors; odd; minimum size of 13 is enforced
+ * \param[in]    gthick   grid thickness; minimum size of 2 is enforced
+ * \return  pix display of sel, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This gives a visual representation of a general (hit-miss) sel.
+ *      (2) The empty sel is represented by a grid of intersecting lines.
+ *      (3) Three different patterns are generated for the sel elements:
+ *          ~ hit (solid black circle)
+ *          ~ miss (black ring; inner radius is radius2)
+ *          ~ origin (cross, XORed with whatever is there)
+ * </pre>
+ */
+PIX *
+selDisplayInPix(SEL     *sel,
+                l_int32  size,
+                l_int32  gthick)
+{
+l_int32  i, j, w, h, sx, sy, cx, cy, type, width;
+l_int32  radius1, radius2, shift1, shift2, x0, y0;
+PIX     *pixd, *pix2, *pixh, *pixm, *pixorig;
+PTA     *pta1, *pta2, *pta1t, *pta2t;
+
+    PROCNAME("selDisplayInPix");
+
+    if (!sel)
+        return (PIX *)ERROR_PTR("sel not defined", procName, NULL);
+    if (size < 13) {
+        L_WARNING("size < 13; setting to 13\n", procName);
+        size = 13;
+    }
+    if (size % 2 == 0)
+        size++;
+    if (gthick < 2) {
+        L_WARNING("grid thickness < 2; setting to 2\n", procName);
+        gthick = 2;
+    }
+    selGetParameters(sel, &sy, &sx, &cy, &cx);
+    w = size * sx + gthick * (sx + 1);
+    h = size * sy + gthick * (sy + 1);
+    pixd = pixCreate(w, h, 1);
+
+        /* Generate grid lines */
+    for (i = 0; i <= sy; i++)
+        pixRenderLine(pixd, 0, gthick / 2 + i * (size + gthick),
+                      w - 1, gthick / 2 + i * (size + gthick),
+                      gthick, L_SET_PIXELS);
+    for (j = 0; j <= sx; j++)
+        pixRenderLine(pixd, gthick / 2 + j * (size + gthick), 0,
+                      gthick / 2 + j * (size + gthick), h - 1,
+                      gthick, L_SET_PIXELS);
+
+        /* Generate hit and miss patterns */
+    radius1 = (l_int32)(0.85 * ((size - 1) / 2.0) + 0.5);  /* of hit */
+    radius2 = (l_int32)(0.65 * ((size - 1) / 2.0) + 0.5);  /* of inner miss */
+    pta1 = generatePtaFilledCircle(radius1);
+    pta2 = generatePtaFilledCircle(radius2);
+    shift1 = (size - 1) / 2 - radius1;  /* center circle in square */
+    shift2 = (size - 1) / 2 - radius2;
+    pta1t = ptaTransform(pta1, shift1, shift1, 1.0, 1.0);
+    pta2t = ptaTransform(pta2, shift2, shift2, 1.0, 1.0);
+    pixh = pixGenerateFromPta(pta1t, size, size);  /* hits */
+    pix2 = pixGenerateFromPta(pta2t, size, size);
+    pixm = pixSubtract(NULL, pixh, pix2);
+
+        /* Generate crossed lines for origin pattern */
+    pixorig = pixCreate(size, size, 1);
+    width = size / 8;
+    pixRenderLine(pixorig, size / 2, (l_int32)(0.12 * size),
+                           size / 2, (l_int32)(0.88 * size),
+                           width, L_SET_PIXELS);
+    pixRenderLine(pixorig, (l_int32)(0.15 * size), size / 2,
+                           (l_int32)(0.85 * size), size / 2,
+                           width, L_FLIP_PIXELS);
+    pixRasterop(pixorig, size / 2 - width, size / 2 - width,
+                2 * width, 2 * width, PIX_NOT(PIX_DST), NULL, 0, 0);
+
+        /* Specialize origin pattern for this sel */
+    selGetTypeAtOrigin(sel, &type);
+    if (type == SEL_HIT)
+        pixXor(pixorig, pixorig, pixh);
+    else if (type == SEL_MISS)
+        pixXor(pixorig, pixorig, pixm);
+
+        /* Paste the patterns in */
+    y0 = gthick;
+    for (i = 0; i < sy; i++) {
+        x0 = gthick;
+        for (j = 0; j < sx; j++) {
+            selGetElement(sel, i, j, &type);
+            if (i == cy && j == cx)  /* origin */
+                pixRasterop(pixd, x0, y0, size, size, PIX_SRC, pixorig, 0, 0);
+            else if (type == SEL_HIT)
+                pixRasterop(pixd, x0, y0, size, size, PIX_SRC, pixh, 0, 0);
+            else if (type == SEL_MISS)
+                pixRasterop(pixd, x0, y0, size, size, PIX_SRC, pixm, 0, 0);
+            x0 += size + gthick;
+        }
+        y0 += size + gthick;
+    }
+
+    pixDestroy(&pix2);
+    pixDestroy(&pixh);
+    pixDestroy(&pixm);
+    pixDestroy(&pixorig);
+    ptaDestroy(&pta1);
+    ptaDestroy(&pta1t);
+    ptaDestroy(&pta2);
+    ptaDestroy(&pta2t);
+    return pixd;
+}
+
+
+/*!
+ * \brief   selaDisplayInPix()
+ *
+ * \param[in]    sela
+ * \param[in]    size     of grid interiors; odd; minimum size of 13 is enforced
+ * \param[in]    gthick   grid thickness; minimum size of 2 is enforced
+ * \param[in]    spacing  between sels, both horizontally and vertically
+ * \param[in]    ncols    number of sels per "line"
+ * \return  pix display of all sels in sela, or NULL on error
+ *
+ * <pre>
+ * Notes:
+ *      (1) This gives a visual representation of all the sels in a sela.
+ *      (2) See notes in selDisplayInPix() for display params of each sel.
+ *      (3) This gives the nicest results when all sels in the sela
+ *          are the same size.
+ * </pre>
+ */
+PIX *
+selaDisplayInPix(SELA    *sela,
+                 l_int32  size,
+                 l_int32  gthick,
+                 l_int32  spacing,
+                 l_int32  ncols)
+{
+l_int32  nsels, i, w, width;
+PIX     *pixt, *pixd;
+PIXA    *pixa;
+SEL     *sel;
+
+    PROCNAME("selaDisplayInPix");
+
+    if (!sela)
+        return (PIX *)ERROR_PTR("sela not defined", procName, NULL);
+    if (size < 13) {
+        L_WARNING("size < 13; setting to 13\n", procName);
+        size = 13;
+    }
+    if (size % 2 == 0)
+        size++;
+    if (gthick < 2) {
+        L_WARNING("grid thickness < 2; setting to 2\n", procName);
+        gthick = 2;
+    }
+    if (spacing < 5) {
+        L_WARNING("spacing < 5; setting to 5\n", procName);
+        spacing = 5;
+    }
+
+        /* Accumulate the pix of each sel */
+    nsels = selaGetCount(sela);
+    pixa = pixaCreate(nsels);
+    for (i = 0; i < nsels; i++) {
+        sel = selaGetSel(sela, i);
+        pixt = selDisplayInPix(sel, size, gthick);
+        pixaAddPix(pixa, pixt, L_INSERT);
+    }
+
+        /* Find the tiled output width, using just the first
+         * ncols pix in the pixa.   If all pix have the same width,
+         * they will align properly in columns. */
+    width = 0;
+    ncols = L_MIN(nsels, ncols);
+    for (i = 0; i < ncols; i++) {
+        pixt = pixaGetPix(pixa, i, L_CLONE);
+        pixGetDimensions(pixt, &w, NULL, NULL);
+        width += w;
+        pixDestroy(&pixt);
+    }
+    width += (ncols + 1) * spacing;  /* add spacing all around as well */
+
+    pixd = pixaDisplayTiledInRows(pixa, 1, width, 1.0, 0, spacing, 0);
+    pixaDestroy(&pixa);
+    return pixd;
+}