/* 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 );
}