/* find image profiles

 *

 * 11/8/99 JC

 *  - from im_cntlines()

 * 22/4/04

 *  - now outputs horizontal/vertical image

 * 9/11/10

 *  - any image format, any number of bands

 *  - gtk-doc

 * 21/9/13

 *  - rewrite as a class

 *  - output h and v profile in one pass

 *  - partial

 *  - output is int rather than ushort

 */

/*

  This file is part of VIPS.

  VIPS is free software; you can redistribute it and/or modify

  it under the terms of the GNU Lesser General Public License as published by

  the Free Software Foundation; either version 2 of the License, or

  (at your option) any later version.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License

  along with this program; if not, write to the Free Software

  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

  02110-1301  USA

 */

/*

  These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif /*HAVE_CONFIG_H*/

#include <glib/gi18n-lib.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <vips/vips.h>

#include "statistic.h"

struct _Edges;

typedef struct {

  /* Horizontal array: Ys of top-most non-zero pixel.

   */

  int *column_edges;

  /* Vertical array: Xs of left-most non-zero pixel.

   */

  int *row_edges;

} Edges;

typedef struct _VipsProfile {

  VipsStatistic parent_instance;

  /* Main edge set. Threads accumulate to this.

   */

  Edges *edges;

  /* Write profiles here.

   */

  VipsImage *columns;

  VipsImage *rows;

} VipsProfile;

typedef VipsStatisticClass VipsProfileClass;

G_DEFINE_TYPE(VipsProfile, vips_profile, VIPS_TYPE_STATISTIC);

static Edges *

edges_new(VipsProfile *profile)

{

  VipsStatistic *statistic = VIPS_STATISTIC(profile);

  VipsImage *in = statistic->ready;

  Edges *edges;

  int i;

  if (!(edges = VIPS_NEW(profile, Edges)))

    return NULL;

  edges->column_edges = VIPS_ARRAY(profile, in->Xsize * in->Bands, int);

  edges->row_edges = VIPS_ARRAY(profile, in->Ysize * in->Bands, int);

  if (!edges->column_edges ||

    !edges->row_edges)

    return NULL;

  for (i = 0; i < in->Xsize * in->Bands; i++)

    edges->column_edges[i] = in->Ysize;

  for (i = 0; i < in->Ysize * in->Bands; i++)

    edges->row_edges[i] = in->Xsize;

  return edges;

}

static int

vips_profile_build(VipsObject *object)

{

  VipsObjectClass *class = VIPS_OBJECT_GET_CLASS(object);

  VipsStatistic *statistic = VIPS_STATISTIC(object);

  VipsProfile *profile = (VipsProfile *) object;

  int y;

  if (statistic->in &&

    vips_check_noncomplex(class->nickname, statistic->in))

    return -1;

  g_object_set(object,

    "columns", vips_image_new(),

    "rows", vips_image_new(),

    NULL);

  /* main edge set made on first thread start.

   */

  if (VIPS_OBJECT_CLASS(vips_profile_parent_class)->build(object))

    return -1;

  /* Make the output image.

   */

  if (vips_image_pipelinev(profile->columns,

      VIPS_DEMAND_STYLE_ANY, statistic->ready, NULL) ||

    vips_image_pipelinev(profile->rows,

      VIPS_DEMAND_STYLE_ANY, statistic->ready, NULL))

    return -1;

  profile->columns->Ysize = 1;

  profile->columns->BandFmt = VIPS_FORMAT_INT;

  profile->columns->Type = VIPS_INTERPRETATION_HISTOGRAM;

  profile->rows->Xsize = 1;

  profile->rows->BandFmt = VIPS_FORMAT_INT;

  profile->rows->Type = VIPS_INTERPRETATION_HISTOGRAM;

  if (vips_image_write_line(profile->columns, 0,

      (VipsPel *) profile->edges->column_edges))

    return -1;

  for (y = 0; y < profile->rows->Ysize; y++)

    if (vips_image_write_line(profile->rows, y,

        (VipsPel *) profile->edges->row_edges +

          y * VIPS_IMAGE_SIZEOF_PEL(profile->rows)))

      return -1;

  return 0;

}

/* New edge accumulator.

 */

static void *

vips_profile_start(VipsStatistic *statistic)

{

  VipsProfile *profile = (VipsProfile *) statistic;

  /* Make the main hist, if necessary.

   */

  if (!profile->edges)

    profile->edges = edges_new(profile);

  return (void *) edges_new(profile);

}

/* We do this a lot.

 */

#define MINBANG(V, C) ((V) = VIPS_MIN(V, C))

/* Add a line of pixels.

 */

#define ADD_PIXELS(TYPE) \

  { \

    TYPE *p; \

    int *column_edges; \

    int *row_edges; \

\

    p = (TYPE *) in; \

    column_edges = edges->column_edges + x * nb; \

    row_edges = edges->row_edges + y * nb; \

    for (i = 0; i < n; i++) { \

      for (j = 0; j < nb; j++) { \

        if (p[j]) { \

          MINBANG(column_edges[j], y); \

          MINBANG(row_edges[j], x + i); \

        } \

      } \

\

      p += nb; \

      column_edges += nb; \

    } \

  }

/* Add a region to a profile.

 */

static int

vips_profile_scan(VipsStatistic *statistic, void *seq,

  int x, int y, void *in, int n)

{

  int nb = statistic->ready->Bands;

  Edges *edges = (Edges *) seq;

  int i, j;

  switch (statistic->ready->BandFmt) {

  case VIPS_FORMAT_UCHAR:

    ADD_PIXELS(guchar);

    break;

  case VIPS_FORMAT_CHAR:

    ADD_PIXELS(char);

    break;

  case VIPS_FORMAT_USHORT:

    ADD_PIXELS(gushort);

    break;

  case VIPS_FORMAT_SHORT:

    ADD_PIXELS(short);

    break;

  case VIPS_FORMAT_UINT:

    ADD_PIXELS(guint);

    break;

  case VIPS_FORMAT_INT:

    ADD_PIXELS(int);

    break;

  case VIPS_FORMAT_FLOAT:

    ADD_PIXELS(float);

    break;

  case VIPS_FORMAT_DOUBLE:

    ADD_PIXELS(double);

    break;

  default:

    g_assert_not_reached();

  }

  return 0;

}

/* Join a sub-profile onto the main profile.

 */

static int

vips_profile_stop(VipsStatistic *statistic, void *seq)

{

  VipsProfile *profile = (VipsProfile *) statistic;

  Edges *edges = profile->edges;

  Edges *sub_edges = (Edges *) seq;

  VipsImage *in = statistic->ready;

  int i;

  for (i = 0; i < in->Xsize * in->Bands; i++)

    MINBANG(edges->column_edges[i], sub_edges->column_edges[i]);

  for (i = 0; i < in->Ysize * in->Bands; i++)

    MINBANG(edges->row_edges[i], sub_edges->row_edges[i]);

  /* Blank out sub-profile to make sure we can't add it again.

   */

  sub_edges->row_edges = NULL;

  sub_edges->column_edges = NULL;

  return 0;

}

static void

vips_profile_class_init(VipsProfileClass *class)

{

  GObjectClass *gobject_class = (GObjectClass *) class;

  VipsObjectClass *object_class = (VipsObjectClass *) class;

  VipsStatisticClass *sclass = VIPS_STATISTIC_CLASS(class);

  gobject_class->set_property = vips_object_set_property;

  gobject_class->get_property = vips_object_get_property;

  object_class->nickname = "profile";

  object_class->description = _("find image profiles");

  object_class->build = vips_profile_build;

  sclass->start = vips_profile_start;

  sclass->scan = vips_profile_scan;

  sclass->stop = vips_profile_stop;

  VIPS_ARG_IMAGE(class, "columns", 100,

    _("Columns"),

    _("First non-zero pixel in column"),

    VIPS_ARGUMENT_REQUIRED_OUTPUT,

    G_STRUCT_OFFSET(VipsProfile, columns));

  VIPS_ARG_IMAGE(class, "rows", 101,

    _("Rows"),

    _("First non-zero pixel in row"),

    VIPS_ARGUMENT_REQUIRED_OUTPUT,

    G_STRUCT_OFFSET(VipsProfile, rows));

}

static void

vips_profile_init(VipsProfile *profile)

{

}

/**

 * vips_profile: (method)

 * @in: input image

 * @columns: (out): distances from top edge

 * @rows: (out): distances from left edge

 * @...: %NULL-terminated list of optional named arguments

 *

 * vips_profile() searches inward from the edge of @in and finds the

 * first non-zero pixel. Pixels in @columns have the distance from the top edge

 * to the first non-zero pixel in that column, @rows has the distance from the

 * left edge to the first non-zero pixel in that row.

 *

 * See also: vips_project(), vips_hist_find().

 *

 * Returns: 0 on success, -1 on error

 */

int

vips_profile(VipsImage *in, VipsImage **columns, VipsImage **rows, ...)

{

  va_list ap;

  int result;

  va_start(ap, rows);

  result = vips_call_split("profile", ap, in, columns, rows);

  va_end(ap);

  return result;

}