/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's 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.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// 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 the Intel Corporation or 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.
//
//M*/#include <stdlib.h>
#include <varargs.h>
#include <limits.h>
#include "eic.h"
#include <ipl.h>
#include "eicdllwrap.h"

#pragma warning (disable:4700) /*warning C4700: local variable 'v' used without having been initialized*/

static val_t eic_iplGetAffineTransform(void)
{
	val_t v;

	iplGetAffineTransform(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplGetAffineQuad(void)
{
	val_t v;

	iplGetAffineQuad(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplNot(void)
{
	val_t v;

	iplNot(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplSet(void)
{
	val_t v;

	iplSet(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int));

	return v;
}

static val_t eic_iplDecimate(void)
{
	val_t v;

	iplDecimate(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int),
		arg(3,getargs(),int),
		arg(4,getargs(),int),
		arg(5,getargs(),int),
		arg(6,getargs(),int));

	return v;
}

static val_t eic_iplLUV2RGB(void)
{
	val_t v;

	iplLUV2RGB(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplBitonalToGray(void)
{
	val_t v;

	iplBitonalToGray(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int),
		arg(3,getargs(),int));

	return v;
}

static val_t eic_iplGetBilinearQuad(void)
{
	val_t v;

	iplGetBilinearQuad(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplGetPerspectiveBound(void)
{
	val_t v;

	iplGetPerspectiveBound(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplNorm(void)
{
	val_t v;

	v.dval = iplNorm(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplRGB2XYZ(void)
{
	val_t v;

	iplRGB2XYZ(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplAddS(void)
{
	val_t v;

	iplAddS(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplMoments(void)
{
	val_t v;

	iplMoments(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplThreshold(void)
{
	val_t v;

	iplThreshold(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplMultiplySScale(void)
{
	val_t v;

	iplMultiplySScale(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplCreateROI(void)
{
	val_t v;

	v.p.ep = v.p.sp = v.p.p = iplCreateROI(arg(0,getargs(),int),
		arg(1,getargs(),int),
		arg(2,getargs(),int),
		arg(3,getargs(),int),
		arg(4,getargs(),int));

	return v;
}

static val_t eic_iplRealFft2D(void)
{
	val_t v;

	iplRealFft2D(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplFixedFilter(void)
{
	val_t v;

	v.ival = iplFixedFilter(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplRGB2HLS(void)
{
	val_t v;

	iplRGB2HLS(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplBlur(void)
{
	val_t v;

	iplBlur(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int),
		arg(3,getargs(),int),
		arg(4,getargs(),int),
		arg(5,getargs(),int));

	return v;
}

static val_t eic_iplSquare(void)
{
	val_t v;

	iplSquare(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplCloneImage(void)
{
	val_t v;

	v.p.ep = v.p.sp = v.p.p = iplCloneImage(arg(0,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplWarpBilinear(void)
{
	val_t v;

	iplWarpBilinear(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p,
		arg(3,getargs(),int),
		arg(4,getargs(),int));

	return v;
}

static val_t eic_iplMedianFilter(void)
{
	val_t v;

	iplMedianFilter(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int),
		arg(3,getargs(),int),
		arg(4,getargs(),int),
		arg(5,getargs(),int));

	return v;
}

static val_t eic_iplScaleFP(void)
{
	val_t v;

	v.ival = iplScaleFP(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),float),
		arg(3,getargs(),float));

	return v;
}

static val_t eic_iplClose(void)
{
	val_t v;

	iplClose(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplDeallocate(void)
{
	val_t v;

	iplDeallocate(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int));

	return v;
}

static val_t eic_iplGetNormalizedSpatialMoment(void)
{
	val_t v;

	v.dval = iplGetNormalizedSpatialMoment(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int),
		arg(2,getargs(),int));

	return v;
}

static val_t eic_iplGetConvKernelFP(void)
{
	val_t v;

	iplGetConvKernelFP(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p,
		arg(3,getargs(),ptr_t).p,
		arg(4,getargs(),ptr_t).p,
		arg(5,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplAdd(void)
{
	val_t v;

	iplAdd(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplConvolveSep2DFP(void)
{
	val_t v;

	iplConvolveSep2DFP(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p,
		arg(3,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplGetAffineBound(void)
{
	val_t v;

	iplGetAffineBound(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplDeleteConvKernel(void)
{
	val_t v;

	iplDeleteConvKernel(arg(0,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplAllocateImageFP(void)
{
	val_t v;

	iplAllocateImageFP(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int),
		arg(2,getargs(),float));

	return v;
}

static val_t eic_iplHLS2RGB(void)
{
	val_t v;

	iplHLS2RGB(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplMinFilter(void)
{
	val_t v;

	iplMinFilter(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int),
		arg(3,getargs(),int),
		arg(4,getargs(),int),
		arg(5,getargs(),int));

	return v;
}

static val_t eic_iplAlphaComposite(void)
{
	val_t v;

	iplAlphaComposite(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p,
		arg(3,getargs(),int),
		arg(4,getargs(),ptr_t).p,
		arg(5,getargs(),ptr_t).p,
		arg(6,getargs(),ptr_t).p,
		arg(7,getargs(),int),
		arg(8,getargs(),int));

	return v;
}

static val_t eic_iplPutPixel(void)
{
	val_t v;

	iplPutPixel(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int),
		arg(2,getargs(),int),
		arg(3,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplGetBilinearBound(void)
{
	val_t v;

	iplGetBilinearBound(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplResize(void)
{
	val_t v;

	iplResize(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),int),
		arg(3,getargs(),int),
		arg(4,getargs(),int),
		arg(5,getargs(),int),
		arg(6,getargs(),int));

	return v;
}

static val_t eic_iplSetFP(void)
{
	val_t v;

	iplSetFP(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),float));

	return v;
}

static val_t eic_iplPreMultiplyAlpha(void)
{
	val_t v;

	iplPreMultiplyAlpha(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int));

	return v;
}

static val_t eic_iplMultiplySFP(void)
{
	val_t v;

	iplMultiplySFP(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),float));

	return v;
}

static val_t eic_iplGetConvKernelChar(void)
{
	val_t v;

	iplGetConvKernelChar(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),ptr_t).p,
		arg(3,getargs(),ptr_t).p,
		arg(4,getargs(),ptr_t).p,
		arg(5,getargs(),ptr_t).p,
		arg(6,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplAbs(void)
{
	val_t v;

	iplAbs(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplScale(void)
{
	val_t v;

	v.ival = iplScale(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplRShiftS(void)
{
	val_t v;

	iplRShiftS(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),unsigned));

	return v;
}

static val_t eic_iplYUV2RGB(void)
{
	val_t v;

	iplYUV2RGB(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplRGB2HSV(void)
{
	val_t v;

	iplRGB2HSV(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplCopy(void)
{
	val_t v;

	iplCopy(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplDeallocateImage(void)
{
	val_t v;

	iplDeallocateImage(arg(0,getargs(),ptr_t).p);

	return v;
}

static void * EiC_Cfunc_0 = NULL;
static void __stdcall MiddleOne_0(const IplImage *x0, int x1, int x2, int x3 )
{
    setArg(0, EiC_Cfunc_0, const IplImage* ,x0);
    setArg(1, EiC_Cfunc_0, int ,x1);
    setArg(2, EiC_Cfunc_0, int ,x2);
    setArg(3, EiC_Cfunc_0, int ,x3);

    EiC_callBack(EiC_Cfunc_0);
}

static void * EiC_Cfunc_1 = NULL;
static void  __stdcall MiddleOne_1(const IplImage *x0,  int x1, int x2, int x3 )
{
    setArg(0, EiC_Cfunc_1, const IplImage * ,x0);
    setArg(1, EiC_Cfunc_1, int ,x1);
    setArg(2, EiC_Cfunc_1, int ,x2);
    setArg(3, EiC_Cfunc_1, int ,x3);

    EiC_callBack(EiC_Cfunc_1);
}

static void * EiC_Cfunc_2 = NULL;
static void  __stdcall MiddleOne_2(const IplImage *x0,  int x1, int x2, int x3 )
{
    setArg(0, EiC_Cfunc_2, const IplImage * ,x0);
    setArg(1, EiC_Cfunc_2, int ,x1);