/* This file is part of GEGL

 *

 * GEGL 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 3 of the License, or (at your option) any later version.

 *

 * GEGL 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 GEGL; if not, see <http://www.gnu.org/licenses/>.

 *

 * Copyright 2003 Calvin Williamson

 */

#ifndef __GEGL_UTILS_H__

#define __GEGL_UTILS_H__

G_BEGIN_DECLS

/***

 * GeglRectangle:

 *

 * GeglRectangles are used in #gegl_node_get_bounding_box and #gegl_node_blit

 * for specifying rectangles.

 *

 * 
struct GeglRectangle

 * {

 *   gint x;

 *   gint y;

 *   gint width;

 *   gint height;

 * };

 *

 */

/**

 * gegl_rectangle_set:

 * @rectangle: a #GeglRectangle

 * @x: upper left x coordinate

 * @y: upper left y coordinate

 * @width: width in pixels.

 * @height: height in pixels.

 *

 * Sets the @x, @y, @width and @height on @rectangle.

 */

void        gegl_rectangle_set           (GeglRectangle       *rectangle,

                                          gint                 x,

                                          gint                 y,

                                          guint                width,

                                          guint                height);

/**

 * gegl_rectangle_equal:

 * @rectangle1: a #GeglRectangle

 * @rectangle2: a #GeglRectangle

 *

 * Check if two #GeglRectangles are equal.

 *

 * Returns TRUE if @rectangle and @rectangle2 are equal.

 */

gboolean    gegl_rectangle_equal         (const GeglRectangle *rectangle1,

                                          const GeglRectangle *rectangle2);

/**

 * gegl_rectangle_equal_coords:

 * @rectangle: a #GeglRectangle

 * @x: X coordinate

 * @y: Y coordinate

 * @width: width of rectangle

 * @height: height of rectangle

 *

 * Check if a rectangle is equal to a set of parameters.

 *

 * Returns TRUE if @rectangle and @x,@y @width x @height are equal.

 */

gboolean    gegl_rectangle_equal_coords  (const GeglRectangle *rectangle,

                                          gint                 x,

                                          gint                 y,

                                          gint                 width,

                                          gint                 height);

/**

 * gegl_rectangle_is_empty:

 * @rectangle: a #GeglRectangle

 *

 * Check if a rectangle has zero area.

 *

 * Returns TRUE if @rectangle height and width are both zero.

 */

gboolean    gegl_rectangle_is_empty     (const GeglRectangle *rectangle);

/**

 * gegl_rectangle_copy:

 * @destination: a #GeglRectangle

 * @source: a #GeglRectangle

 *

 * Copies the rectangle information stored in @source over the information in

 * @destination.

 */

void        gegl_rectangle_copy          (GeglRectangle       *destination,

                                          const GeglRectangle *source);

/**

 * gegl_rectangle_bounding_box:

 * @destination: a #GeglRectangle

 * @source1: a #GeglRectangle

 * @source2: a #GeglRectangle

 *

 * Computes the bounding box of the rectangles @source1 and @source2 and stores the

 * resulting bounding box in @destination.

 */

void        gegl_rectangle_bounding_box  (GeglRectangle       *destination,

                                          const GeglRectangle *source1,

                                          const GeglRectangle *source2);

/**

 * gegl_rectangle_intersect:

 * @dest: return location for the intersection of @src1 and @src2, or NULL.

 * @src1: a #GeglRectangle

 * @src2: a #GeglRectangle

 *

 * Calculates the intersection of two rectangles. It is allows for dest to be the same

 * as either @src1 or @src2. If the rectangles do not intersect, dest's width and height

 * are set to 0 and its x and y values are undefined.

 *

 * Returns TRUE if the rectangles intersect.

 */

gboolean    gegl_rectangle_intersect     (GeglRectangle       *dest,

                                          const GeglRectangle *src1,

                                          const GeglRectangle *src2);

/**

 * gegl_rectangle_contains:

 * @parent: a #GeglRectangle

 * @child: a #GeglRectangle

 *

 * Checks if the #GeglRectangle @child is fully contained within @parent.

 *

 * Returns TRUE if the @child is fully contained in @parent.

 */

gboolean    gegl_rectangle_contains      (const GeglRectangle *parent,

                                          const GeglRectangle *child);

/**

 * gegl_rectangle_infinite_plane:

 *

 * Returns a GeglRectangle that represents an infininte plane.

 */

GeglRectangle gegl_rectangle_infinite_plane (void);

/**

 * gegl_rectangle_is_infinite_plane:

 * @rectangle: A GeglRectangle.

 *

 * Returns TRUE if the GeglRectangle represents an infininte plane,

 * FALSE otherwise.

 */

gboolean gegl_rectangle_is_infinite_plane (const GeglRectangle *rectangle);

/**

 * gegl_rectangle_dump:

 * @rectangle: A GeglRectangle.

 *

 * For debugging purposes, not stable API.

 */

void     gegl_rectangle_dump              (const GeglRectangle *rectangle);

/***

 * Aligned memory:

 *

 * GEGL provides functions to allocate and free buffers that are guaranteed to

 * be on 16 byte aligned memory addresses.

 */

/**

 * gegl_malloc: (skip)

 * @n_bytes: the number of bytes to allocte.

 *

 * Allocates @n_bytes of memory. If n_bytes is 0 it returns NULL.

 *

 * Returns a pointer to the allocated memory.

 */

gpointer gegl_malloc                  (gsize    n_bytes);

/**

 * gegl_free:

 * @mem: the memory to free.

 *

 * Frees the memory pointed to by @mem, if @mem is NULL it will warn and abort.

 */

void     gegl_free                    (gpointer mem);

#define GEGL_FLOAT_EPSILON            (1e-5)

#define GEGL_FLOAT_IS_ZERO(value)     (_gegl_float_epsilon_zero ((value)))

#define GEGL_FLOAT_EQUAL(v1, v2)      (_gegl_float_epsilon_equal ((v1), (v2)))

#define INT_MULT(a,b,t)  ((t) = (a) * (b) + 0x80, ((((t) >> 8) + (t)) >> 8))

/***

 */

inline gint _gegl_float_epsilon_zero  (float     value);

gint        _gegl_float_epsilon_equal (float     v1,

                                       float     v2);

G_END_DECLS

#endif /* __GEGL_UTILS_H__ */