iplwrap.c

guide and some example with visualC++

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

	return v;
}

static val_t eic_iplColorTwistFP(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplNormalizedCentralMoment(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplShear(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplConvolve2D(void)
{
	val_t v;

	iplConvolve2D(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_iplDeleteConvKernelFP(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGetConvKernel(void)
{
	val_t v;

	iplGetConvKernel(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_iplGetPerspectiveTransform(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplWarpAffine(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplMultiplyS(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplEqual(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGetSpatialMoment(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplOrS(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplWarpPerspectiveQ(void)
{
	val_t v;

	iplWarpPerspectiveQ(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_iplSubtract(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGetNormalizedCentralMoment(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplComputeHisto(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplCreateColorTwist(void)
{
	val_t v;

	v.p.ep = v.p.sp = v.p.p = iplCreateColorTwist(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),int));

	return v;
}

static val_t eic_iplSubtractSFP(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGreaterSFP(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplRGB2YCrCb(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplDeleteROI(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGrayToColor(void)
{
	val_t v;

	iplGrayToColor(arg(0,getargs(),ptr_t).p,
		arg(1,getargs(),ptr_t).p,
		arg(2,getargs(),float),
		arg(3,getargs(),float),
		arg(4,getargs(),float));

	return v;
}

static val_t eic_iplConvert(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplMinMaxFP(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplHSV2RGB(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplMultiplyScale(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplHistoEqualize(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplYCrCb2RGB(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplSpatialMoment(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGreaterS(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplEqualFPEps(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplOpen(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGetRotateShift(void)
{
	val_t v;

	iplGetRotateShift(arg(0,getargs(),double),
		arg(1,getargs(),double),
		arg(2,getargs(),double),
		arg(3,getargs(),ptr_t).p,
		arg(4,getargs(),ptr_t).p);

	return v;
}

static val_t eic_iplConvertFromDIBSep(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplDeallocateHeader(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplZoom(void)
{
	val_t v;

	iplZoom(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_iplConvertFromDIB(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplLessS(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplGetPerspectiveQuad(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplConvolve2DFP(void)
{
	val_t v;

	iplConvolve2DFP(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_iplRGB2YUV(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplAlphaCompositeC(void)
{
	val_t v;

	iplAlphaCompositeC(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),
		arg(5,getargs(),int),
		arg(6,getargs(),int),
		arg(7,getargs(),int));

	return v;
}

static val_t eic_iplLessSFP(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplWarpBilinearQ(void)
{
	val_t v;

	iplWarpBilinearQ(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_iplReduceBits(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplNormalizedSpatialMoment(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplAllocateImage(void)
{
	val_t v;

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

	return v;
}

static val_t eic_iplCreateImageHeader(void)
{
	val_t v;

	v.p.ep = v.p.sp = v.p.p = iplCreateImageHeader(arg(0,getargs(),int),
		arg(1,getargs(),int),
		arg(2,getargs(),int),
		arg(3,getargs(),ptr_t).p,
		arg(4,getargs(),ptr_t).p,
		arg(5,getargs(),int),
		arg(6,getargs(),int),
		arg(7,getargs(),int),
		arg(8,getargs(),int),
		arg(9,getargs(),int),
		arg(10,getargs(),ptr_t).p,
		arg(11,getargs(),ptr_t).p,
		arg(12,getargs(),ptr_t).p,
		arg(13,getargs(),ptr_t).p);

	return v;
}

/**********************************/

void module_ipl()
{
}

/**********************************/

char* eic_function_names[] = {
    "iplCreateImageHeader", "iplAllocateImage", "iplNormalizedSpatialMoment", "iplReduceBits", "iplWarpBilinearQ", 
    "iplLessSFP", "iplAlphaCompositeC", "iplRGB2YUV", "iplConvolve2DFP", "iplGetPerspectiveQuad", 
    "iplLessS", "iplConvertFromDIB", "iplZoom", "iplDeallocateHeader", "iplConvertFromDIBSep", 
    "iplGetRotateShift", "iplOpen", "iplEqualFPEps", "iplGreaterS", "iplSpatialMoment", 
    "iplYCrCb2RGB", "iplHistoEqualize", "iplMultiplyScale", "iplHSV2RGB", "iplMinMaxFP", 
    "iplConvert", "iplGrayToColor", "iplDeleteROI", "iplRGB2YCrCb", "iplGreaterSFP", 
    "iplSubtractSFP", "iplCreateColorTwist", "iplComputeHisto", "iplGetNormalizedCentralMoment", "iplSubtract", 
    "iplWarpPerspectiveQ", "iplOrS", "iplGetSpatialMoment", "iplEqual", "iplMultiplyS", 
    "iplWarpAffine", "iplGetPerspectiveTransform", "iplGetConvKernel", "iplDeleteConvKernelFP", "iplConvolve2D", 
    "iplShear", "iplNormalizedCentralMoment", "iplColorTwistFP", "iplDeleteTileInfo", "iplTranslateDIB", 
    "iplSetColorTwist", "iplGetBilinearTransform", "iplGetPixel", "iplEqualSFPEps", "iplErode", 
    "iplRemap", "iplCentralMoment", "iplXorS", "iplCcsFft2D", "iplColorToGray", 
    "iplLess", "iplEqualSFP", "iplCreateConvKernel", "iplGreater", "iplSetROI", 
    "iplYCC2RGB", "iplCreateImageJaehne", "iplXYZ2RGB", "iplConvertToDIB", "iplWarpPerspective", 
    "iplConvolveSep2D", "iplOr", "iplSetTileInfo", "iplExchange", "iplMultiply", 
    "iplGetCentralMoment", "iplRGB2LUV", "iplContrastStretch", "iplConvertToDIBSep", "iplLShiftS", 
    "iplAndS", "iplMpyRCPack2D", "iplMirror", "iplSubtractS", "iplApplyColorTwist", 
    "iplRotate", "iplCreateConvKernelFP", "iplDilate", "iplDeleteColorTwist", "iplXor", 
    "iplCreateConvKernelChar", "iplMaxFilter", "iplEqualS", "iplAddSFP", "iplDecimateExt", 
    "iplDCT2D", "iplAnd", "iplSetBorderMode", "iplCreateTileInfo", "iplDeallocateImage", 
    "iplCopy", "iplRGB2HSV", "iplYUV2RGB", "iplRShiftS", "iplScale", 
    "iplAbs", "iplGetConvKernelChar", "iplMultiplySFP", "iplPreMultiplyAlpha", "iplSetFP", 
    "iplResize", "iplGetBilinearBound", "iplPutPixel", "iplAlphaComposite", "iplMinFilter", 
    "iplHLS2RGB", "iplAllocateImageFP", "iplDeleteConvKernel", "iplGetAffineBound", "iplConvolveSep2DFP", 
    "iplAdd", "iplGetConvKernelFP", "iplGetNormalizedSpatialMoment", "iplDeallocate", "iplClose", 
    "iplScaleFP", "iplMedianFilter", "iplWarpBilinear", "iplCloneImage", "iplSquare", 
    "iplBlur", "iplRGB2HLS", "iplFixedFilter", "iplRealFft2D", "iplCreateROI", 
    "iplMultiplySScale", "iplThreshold", "iplMoments", "iplAddS", "iplRGB2XYZ", 
    "iplNorm", "iplGetPerspectiveBound", "iplGetBilinearQuad", "iplBitonalToGray", "iplLUV2RGB", 
    "iplDecimate", "iplSet", "iplNot", "iplGetAffineQuad", "iplGetAffineTransform"};

val_t (*eic_functions[])(void) = {    
    eic_iplCreateImageHeader, eic_iplAllocateImage, eic_iplNormalizedSpatialMoment, eic_iplReduceBits, eic_iplWarpBilinearQ, 
    eic_iplLessSFP, eic_iplAlphaCompositeC, eic_iplRGB2YUV, eic_iplConvolve2DFP, eic_iplGetPerspectiveQuad, 
    eic_iplLessS, eic_iplConvertFromDIB, eic_iplZoom, eic_iplDeallocateHeader, eic_iplConvertFromDIBSep, 
    eic_iplGetRotateShift, eic_iplOpen, eic_iplEqualFPEps, eic_iplGreaterS, eic_iplSpatialMoment, 
    eic_iplYCrCb2RGB, eic_iplHistoEqualize, eic_iplMultiplyScale, eic_iplHSV2RGB, eic_iplMinMaxFP, 
    eic_iplConvert, eic_iplGrayToColor, eic_iplDeleteROI, eic_iplRGB2YCrCb, eic_iplGreaterSFP, 
    eic_iplSubtractSFP, eic_iplCreateColorTwist, eic_iplComputeHisto, eic_iplGetNormalizedCentralMoment, eic_iplSubtract, 
    eic_iplWarpPerspectiveQ, eic_iplOrS, eic_iplGetSpatialMoment, eic_iplEqual, eic_iplMultiplyS, 
    eic_iplWarpAffine, eic_iplGetPerspectiveTransform, eic_iplGetConvKernel, eic_iplDeleteConvKernelFP, eic_iplConvolve2D, 
    eic_iplShear, eic_iplNormalizedCentralMoment, eic_iplColorTwistFP, eic_iplDeleteTileInfo, eic_iplTranslateDIB, 
    eic_iplSetColorTwist, eic_iplGetBilinearTransform, eic_iplGetPixel, eic_iplEqualSFPEps, eic_iplErode, 
    eic_iplRemap, eic_iplCentralMoment, eic_iplXorS, eic_iplCcsFft2D, eic_iplColorToGray, 
    eic_iplLess, eic_iplEqualSFP, eic_iplCreateConvKernel, eic_iplGreater, eic_iplSetROI, 
    eic_iplYCC2RGB, eic_iplCreateImageJaehne, eic_iplXYZ2RGB, eic_iplConvertToDIB, eic_iplWarpPerspective, 
    eic_iplConvolveSep2D, eic_iplOr, eic_iplSetTileInfo, eic_iplExchange, eic_iplMultiply, 
    eic_iplGetCentralMoment, eic_iplRGB2LUV, eic_iplContrastStretch, eic_iplConvertToDIBSep, eic_iplLShiftS, 
    eic_iplAndS, eic_iplMpyRCPack2D, eic_iplMirror, eic_iplSubtractS, eic_iplApplyColorTwist, 
    eic_iplRotate, eic_iplCreateConvKernelFP, eic_iplDilate, eic_iplDeleteColorTwist, eic_iplXor, 
    eic_iplCreateConvKernelChar, eic_iplMaxFilter, eic_iplEqualS, eic_iplAddSFP, eic_iplDecimateExt, 
    eic_iplDCT2D, eic_iplAnd, eic_iplSetBorderMode, eic_iplCreateTileInfo, eic_iplDeallocateImage, 
    eic_iplCopy, eic_iplRGB2HSV, eic_iplYUV2RGB, eic_iplRShiftS, eic_iplScale, 
    eic_iplAbs, eic_iplGetConvKernelChar, eic_iplMultiplySFP, eic_iplPreMultiplyAlpha, eic_iplSetFP, 
    eic_iplResize, eic_iplGetBilinearBound, eic_iplPutPixel, eic_iplAlphaComposite, eic_iplMinFilter, 
    eic_iplHLS2RGB, eic_iplAllocateImageFP, eic_iplDeleteConvKernel, eic_iplGetAffineBound, eic_iplConvolveSep2DFP, 
    eic_iplAdd, eic_iplGetConvKernelFP, eic_iplGetNormalizedSpatialMoment, eic_iplDeallocate, eic_iplClose, 
    eic_iplScaleFP, eic_iplMedianFilter, eic_iplWarpBilinear, eic_iplCloneImage, eic_iplSquare, 
    eic_iplBlur, eic_iplRGB2HLS, eic_iplFixedFilter, eic_iplRealFft2D, eic_iplCreateROI, 
    eic_iplMultiplySScale, eic_iplThreshold, eic_iplMoments, eic_iplAddS, eic_iplRGB2XYZ, 
    eic_iplNorm, eic_iplGetPerspectiveBound, eic_iplGetBilinearQuad, eic_iplBitonalToGray, eic_iplLUV2RGB, 
    eic_iplDecimate, eic_iplSet, eic_iplNot, eic_iplGetAffineQuad, eic_iplGetAffineTransform};

void GetFunctions(char*** func_names, val_t (***funcs)(void), int* funcs_count)
{
    *func_names = eic_function_names;
    *funcs = eic_functions;
    *funcs_count = sizeof(eic_functions)/sizeof(eic_functions[0]);
}

void PluginGetInfo(plugin_info* info)
{
    strcpy(info->name, "IPL 2.5");
    strcpy(info->library_path, "ipl.dll");
    info->type = PLUG_WRAPPERS;
}