/* vips_grid

 *

 * 4/8/05

 * 7/9/05

 *  - oops, clipping was wrong

 * 30/1/10

 *  - gtkdoc

 *  - small cleanups

 * 30/5/13

 *  - redo as a class

 */

/*

  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 "pconversion.h"

typedef struct _VipsGrid {

  VipsConversion parent_instance;

  VipsImage *in;

  int tile_height;

  int across;

  int down;

} VipsGrid;

typedef VipsConversionClass VipsGridClass;

G_DEFINE_TYPE(VipsGrid, vips_grid, VIPS_TYPE_CONVERSION);

static int

vips_grid_gen(VipsRegion *out_region,

  void *vseq, void *a, void *b, gboolean *stop)

{

  VipsRegion *ir = (VipsRegion *) vseq;

  VipsGrid *grid = (VipsGrid *) b;

  VipsRect *r = &out_region->valid;

  int twidth = grid->in->Xsize;

  int theight = grid->tile_height;

  int x, y;

  VipsRect tile;

  /* Find top left of tiles we need.

   */

  int xs = (r->left / twidth) * twidth;

  int ys = (r->top / theight) * theight;

  /* The tile enclosing the top-left corner of the requested area.

   */

  tile.left = xs;

  tile.top = ys;

  tile.width = twidth;

  tile.height = theight;

  /* If the request fits inside a single tile, we can just pointer-copy.

   */

  if (vips_rect_includesrect(&tile, r)) {

    VipsRect irect;

    /* Translate request to input space.

     */

    irect = *r;

    irect.left -= xs;

    irect.top -= ys;

    irect.top += grid->across * ys + theight * (xs / twidth);

    if (vips_region_prepare(ir, &irect) ||

      vips_region_region(out_region, ir, r, irect.left, irect.top))

      return -1;

    return 0;

  }

  for (y = ys; y < VIPS_RECT_BOTTOM(r); y += theight)

    for (x = xs; x < VIPS_RECT_RIGHT(r); x += twidth) {

      VipsRect paint;

      VipsRect input;

      /* Whole tile at x, y

       */

      tile.left = x;

      tile.top = y;

      tile.width = twidth;

      tile.height = theight;

      /* Which parts touch the area of the output we are

       * building.

       */

      vips_rect_intersectrect(&tile, r, &paint);

      g_assert(!vips_rect_isempty(&paint));

      /* Translate back to ir coordinates.

       */

      input = paint;

      input.left -= x;

      input.top -= y;

      input.top += grid->across * y + theight * (x / twidth);

      /* Render into out_region.

       */

      if (vips_region_prepare_to(ir, out_region, &input,

          paint.left, paint.top))

        return -1;

    }

  return 0;

}

static int

vips_grid_build(VipsObject *object)

{

  VipsObjectClass *class = VIPS_OBJECT_GET_CLASS(object);

  VipsConversion *conversion = VIPS_CONVERSION(object);

  VipsGrid *grid = (VipsGrid *) object;

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

    return -1;

  if (vips_check_coding_known(class->nickname, grid->in) ||

    vips_image_pio_input(grid->in))

    return -1;

  if (grid->in->Ysize % grid->tile_height != 0 ||

    grid->in->Ysize / grid->tile_height !=

      grid->across * grid->down) {

    vips_error(class->nickname, "%s", _("bad grid geometry"));

    return -1;

  }

  /* We can render small tiles with pointer copies.

   */

  if (vips_image_pipelinev(conversion->out,

      VIPS_DEMAND_STYLE_SMALLTILE, grid->in, NULL))

    return -1;

  conversion->out->Xsize = grid->in->Xsize * grid->across;

  conversion->out->Ysize = grid->tile_height * grid->down;

  if (vips_image_generate(conversion->out,

      vips_start_one, vips_grid_gen, vips_stop_one,

      grid->in, grid))

    return -1;

  return 0;

}

static void

vips_grid_class_init(VipsGridClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS(class);

  VipsObjectClass *vobject_class = VIPS_OBJECT_CLASS(class);

  gobject_class->set_property = vips_object_set_property;

  gobject_class->get_property = vips_object_get_property;

  vobject_class->nickname = "grid";

  vobject_class->description = _("grid an image");

  vobject_class->build = vips_grid_build;

  VIPS_ARG_IMAGE(class, "in", 1,

    _("Input"),

    _("Input image"),

    VIPS_ARGUMENT_REQUIRED_INPUT,

    G_STRUCT_OFFSET(VipsGrid, in));

  VIPS_ARG_INT(class, "tile_height", 3,

    _("Tile height"),

    _("Chop into tiles this high"),

    VIPS_ARGUMENT_REQUIRED_INPUT,

    G_STRUCT_OFFSET(VipsGrid, tile_height),

    1, 10000000, 128);

  VIPS_ARG_INT(class, "across", 4,

    _("Across"),

    _("Number of tiles across"),

    VIPS_ARGUMENT_REQUIRED_INPUT,

    G_STRUCT_OFFSET(VipsGrid, across),

    1, 10000000, 1);

  VIPS_ARG_INT(class, "down", 5,

    _("Down"),

    _("Number of tiles down"),

    VIPS_ARGUMENT_REQUIRED_INPUT,

    G_STRUCT_OFFSET(VipsGrid, down),

    1, 10000000, 1);

}

static void

vips_grid_init(VipsGrid *grid)

{

  grid->tile_height = 128;

  grid->across = 1;

  grid->down = 1;

}

/**

 * vips_grid: (method)

 * @in: input image

 * @out: (out): output image

 * @tile_height: chop into tiles this high

 * @across: tiles across

 * @down: tiles down

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

 *

 * Chop a tall thin image up into a set of tiles, lay the tiles out in a grid.

 *

 * The input image should be a very tall, thin image containing a list of

 * smaller images. Volumetric or time-sequence images are often laid out like

 * this. This image is chopped into a series of tiles, each @tile_height

 * pixels high and the width of @in. The tiles are then rearranged into a grid

 * @across tiles across and @down tiles down in row-major order.

 *

 * Supplying @tile_height, @across and @down is not strictly necessary, we

 * only really need two of these. Requiring three is a double-check that the

 * image has the expected geometry.

 *

 * ::: seealso

 *     [method@Image.embed], [method@Image.insert], [method@Image.join].

 *

 * Returns: 0 on success, -1 on error

 */

int

vips_grid(VipsImage *in, VipsImage **out,

  int tile_height, int across, int down, ...)

{

  va_list ap;

  int result;

  va_start(ap, down);

  result = vips_call_split("grid", ap,

    in, out, tile_height, across, down);

  va_end(ap);

  return result;

}