Gecko [ www.finalhopeacademy.com ]

Name	Size	Permission
.git	[ DIR ]	drwxr-xr-x
.github	[ DIR ]	drwxr-xr-x
.libs	[ DIR ]	drwxr-xr-x
autom4te.cache	[ DIR ]	drwxr-xr-x
bisect	[ DIR ]	drwxr-xr-x
build	[ DIR ]	drwxr-xr-x
docker	[ DIR ]	drwxr-xr-x
examples	[ DIR ]	drwxr-xr-x
include	[ DIR ]	drwxr-xr-x
modules	[ DIR ]	drwxr-xr-x
rpm	[ DIR ]	drwxr-xr-x
tests	[ DIR ]	drwxr-xr-x
util	[ DIR ]	drwxr-xr-x
.gitignore	757 B	-rw-r--r--
.travis.yml	2.26 KB	-rw-r--r--
CREDITS	39 B	-rw-r--r--
ChangeLog	44.76 KB	-rw-r--r--
Imagick.stub.php	47.02 KB	-rw-r--r--
ImagickDraw.stub.php	11.53 KB	-rw-r--r--
ImagickDraw_arginfo.h	58.47 KB	-rw-r--r--
ImagickKernel.stub.php	648 B	-rw-r--r--
ImagickKernel_arginfo.h	4.14 KB	-rw-r--r--
ImagickPixel.stub.php	2.42 KB	-rw-r--r--
ImagickPixelIterator.stub.php	1.5 KB	-rw-r--r--
ImagickPixelIterator_arginfo.h	8.4 KB	-rw-r--r--
ImagickPixel_arginfo.h	10.03 KB	-rw-r--r--
Imagick_arginfo.h	210.9 KB	-rw-r--r--
LICENSE	3.14 KB	-rw-r--r--
Makefile	13.17 KB	-rw-r--r--
Makefile.fragments	0 B	-rw-r--r--
Makefile.objects	4.32 KB	-rw-r--r--
README.md	6.68 KB	-rw-r--r--
check-loaded.phpt	422 B	-rw-r--r--
clean.sh	158 B	-rw-r--r--
composer.json	510 B	-rw-r--r--
config.h	2.04 KB	-rw-r--r--
config.h.in	1.91 KB	-rw-r--r--
config.log	19.97 KB	-rw-r--r--
config.m4	3.54 KB	-rw-r--r--
config.nice	190 B	-rwxr-xr-x
config.status	20.95 KB	-rwxr-xr-x
config.w32	1.43 KB	-rw-r--r--
configure	458.31 KB	-rwxr-xr-x
configure.ac	5.17 KB	-rw-r--r--
docker-compose.yml	1.04 KB	-rw-r--r--
imagemagick.m4	7.4 KB	-rw-r--r--
imagemagick_dependency.sh	3.31 KB	-rwxr-xr-x
imagick.c	41.26 KB	-rw-r--r--
imagick.dep	11.41 KB	-rw-r--r--
imagick.la	827 B	-rw-r--r--
imagick.lo	305 B	-rw-r--r--
imagick_class.c	374.08 KB	-rw-r--r--
imagick_class.dep	11.07 KB	-rw-r--r--
imagick_class.lo	317 B	-rw-r--r--
imagick_file.c	10.36 KB	-rw-r--r--
imagick_file.dep	11.03 KB	-rw-r--r--
imagick_file.lo	315 B	-rw-r--r--
imagick_helpers.c	80.9 KB	-rw-r--r--
imagick_helpers.dep	11.03 KB	-rw-r--r--
imagick_helpers.lo	321 B	-rw-r--r--
imagickdraw_class.c	85.75 KB	-rw-r--r--
imagickdraw_class.dep	11.04 KB	-rw-r--r--
imagickdraw_class.lo	325 B	-rw-r--r--
imagickkernel_class.c	23.66 KB	-rw-r--r--
imagickkernel_class.dep	11.04 KB	-rw-r--r--
imagickkernel_class.lo	329 B	-rw-r--r--
imagickpixel_class.c	21.4 KB	-rw-r--r--
imagickpixel_class.dep	11.04 KB	-rw-r--r--
imagickpixel_class.lo	327 B	-rw-r--r--
imagickpixeliterator_class.c	18.93 KB	-rw-r--r--
imagickpixeliterator_class.dep	11.06 KB	-rw-r--r--
imagickpixeliterator_class.lo	343 B	-rw-r--r--
libtool	205.98 KB	-rwxr-xr-x
package.xml	26.7 KB	-rw-r--r--
php_imagemagick_version_defs.h	6.17 KB	-rw-r--r--
php_imagick.h	2.07 KB	-rw-r--r--
php_imagick_defs.h	38.99 KB	-rw-r--r--
php_imagick_file.h	2.88 KB	-rw-r--r--
php_imagick_helpers.h	4.47 KB	-rw-r--r--
php_imagick_macros.h	3.22 KB	-rw-r--r--
php_imagick_shared.h	1.79 KB	-rw-r--r--
regen_arginfo.sh	766 B	-rwxr-xr-x
run-tests.php	139.39 KB	-rw-r--r--
runDev.sh	100 B	-rw-r--r--
runTests.sh	213 B	-rw-r--r--
shim_im6_to_im7.c	23.76 KB	-rw-r--r--
shim_im6_to_im7.dep	11.08 KB	-rw-r--r--
shim_im6_to_im7.h	7.07 KB	-rw-r--r--
shim_im6_to_im7.lo	321 B	-rw-r--r--
shim_php7_to_php8.h	640 B	-rw-r--r--
validate_package.sh	233 B	-rw-r--r--

Code Editor : shim_im6_to_im7.c

/*
   +----------------------------------------------------------------------+
   | Imagick                                                              |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.php.net/license/3_01.txt                                  |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
*/

#include "php_imagick.h"
#include "php_imagick_defs.h"
#include "php_imagick_macros.h"
#include "php_imagick_helpers.h"
#include "php_imagick_file.h"

#if MagickLibVersion >= 0x700

// Functions that have been replaced by channel aware versions
MagickBooleanType MagickAdaptiveBlurImageChannel(MagickWand *wand,const ChannelType channel,const double radius, const double sigma) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickAdaptiveBlurImage(wand, radius, sigma);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickAdaptiveSharpenImageChannel(MagickWand *wand, const ChannelType channel, const double radius, const double sigma) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickAdaptiveSharpenImage(wand, radius, sigma);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickAddNoiseImageChannel(MagickWand *wand,const ChannelType channel,const NoiseType noise_type) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

//TODO - what is the value meant to be?
	status = MagickAddNoiseImage(wand, noise_type, 1.0);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

// This is not actually an ImageMagick function, but the name is likely to
// avoid any symbol clash for the foreseeable.
MagickBooleanType MagickAddNoiseImageChannelWithAttenuate(MagickWand *wand,const ChannelType channel,const NoiseType noise_type, double attenuate) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickAddNoiseImage(wand, noise_type, attenuate);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickAutoGammaImageChannel(MagickWand *wand, const ChannelType channel) {
  	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickAutoGammaImage(wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickAutoLevelImageChannel(MagickWand *wand,
  const ChannelType channel) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickAutoLevelImage(wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickBlurImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickBlurImage(wand, radius,sigma);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickBrightnessContrastImageChannel(MagickWand *wand,const ChannelType channel,const double brightness, const double contrast) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickBrightnessContrastImage(wand, brightness, contrast);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickClampImageChannel(MagickWand *wand, const ChannelType channel) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickClampImage(wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickClutImageChannel(
	MagickWand *wand,
	const ChannelType channel,
	const MagickWand *clut_wand
) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;
	PixelInterpolateMethod pixelInterpolateMethod;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

pixelInterpolateMethod = MagickGetInterpolateMethod(wand);
	status = MagickClutImage(wand, clut_wand, pixelInterpolateMethod);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickCompositeImageChannel(MagickWand *wand,
  const ChannelType channel,const MagickWand *source_wand,
  const CompositeOperator compose,const ssize_t x,const ssize_t y) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

long clip_to_self = 1;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickCompositeImage(wand, source_wand, compose, clip_to_self, x,y);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickWand *MagickCompareImageChannels(MagickWand *wand, const MagickWand *reference, const ChannelType channel, const MetricType metric, double *distortion) {

MagickWand *tmp_wand;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

tmp_wand = MagickCompareImages(wand, reference, metric, distortion);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}
	return tmp_wand;
}

MagickBooleanType MagickContrastStretchImageChannel(MagickWand *wand,
  const ChannelType channel,const double black_point,
  const double white_point) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickContrastStretchImage(wand, black_point, white_point);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickConvolveImageChannel(MagickWand *wand,
  const ChannelType channel, const KernelInfo *kernel){

MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickConvolveImage(wand, kernel);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickEqualizeImageChannel(MagickWand *wand,
  const ChannelType channel) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickEqualizeImage(wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;  
}

MagickBooleanType MagickEvaluateImageChannel(MagickWand *wand,
  const ChannelType channel,const MagickEvaluateOperator op,const double value) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickEvaluateImage(wand,op,value);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

//MagickBooleanType MagickFilterImageChannel(MagickWand *wand,
//  const ChannelType channel,const KernelInfo *kernel) {
//	MagickBooleanType status;
//	ChannelType previous_channel_mask;
//
//	if (channel != UndefinedChannel) {
//		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
//	}
//
//	status = MagickFilterImage(wand, kernel);
//
//	if (channel != UndefinedChannel) {
//		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
//	}
//
//	return status; 
//}

MagickBooleanType MagickFloodfillPaintImageChannel(MagickWand *wand,
  const ChannelType channel,const PixelWand *fill,const double fuzz,
  const PixelWand *bordercolor,const ssize_t x,const ssize_t y,
  const MagickBooleanType invert) {

MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickFloodfillPaintImage(wand, fill, fuzz, bordercolor, x, y, invert);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;  
}

MagickBooleanType MagickFunctionImageChannel(MagickWand *wand,
  const ChannelType channel,const MagickFunction function,
  const size_t number_arguments,const double *arguments) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickFunctionImage(wand,function,number_arguments,arguments);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickWand *MagickFxImageChannel(MagickWand *wand, const ChannelType channel,const char *expression) {

MagickWand *result_wand;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

result_wand = MagickFxImage(wand, expression);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return result_wand;
}

MagickBooleanType MagickGammaImageChannel(MagickWand *wand,
  const ChannelType channel,const double gamma) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickGammaImage(wand,gamma);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickGaussianBlurImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickGaussianBlurImage(wand,radius,sigma);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

size_t MagickGetImageChannelDepth(MagickWand *wand, const ChannelType channel) {
	size_t depth;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

depth = MagickGetImageDepth(wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return depth;
}

MagickBooleanType MagickGetImageChannelMean(MagickWand *wand, const ChannelType channel,double *mean,
  double *standard_deviation) {
  	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickGetImageMean(wand, mean, standard_deviation);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickSetImageChannelDepth(MagickWand *wand, const ChannelType channel,
  const size_t depth) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickSetImageDepth(wand, depth);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}
  
MagickBooleanType MagickGetImageChannelDistortion(MagickWand *wand,
  const MagickWand *reference,const ChannelType channel,const MetricType metric,
  double *distortion) {
  	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickGetImageDistortion(wand, reference, metric, distortion);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}
  
MagickBooleanType MagickGetImageChannelKurtosis(MagickWand *wand,const ChannelType channel,
  double *kurtosis,double *skewness) {
  	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickGetImageKurtosis(wand,kurtosis,skewness);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickGetImageChannelRange(MagickWand *wand,const ChannelType channel,double *minima,
  double *maxima) {
  	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickGetImageRange(wand, minima, maxima);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickOrderedPosterizeImageChannel(MagickWand *wand,const ChannelType channel,
  const char *threshold_map) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickOrderedDitherImage(wand, threshold_map);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

ChannelStatistics *MagickGetImageChannelStatistics(MagickWand *wand) {
	return MagickGetImageStatistics(wand);
}

MagickBooleanType MagickHaldClutImageChannel(MagickWand *wand, const ChannelType channel,const MagickWand *hald_wand) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickHaldClutImage(wand, hald_wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickLevelImageChannel(MagickWand *wand,
  const ChannelType channel,const double black_point,const double gamma,
  const double white_point) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickLevelImage(wand,black_point,gamma, white_point);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickMorphologyImageChannel(MagickWand *wand,
  ChannelType channel,MorphologyMethod method,const ssize_t iterations,
  KernelInfo *kernel) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickMorphologyImage(wand, method, iterations, kernel);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickMotionBlurImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma,
  const double angle) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickMotionBlurImage(wand, radius, sigma,angle);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickNegateImageChannel(MagickWand *wand,const ChannelType channel,const MagickBooleanType gray) {

MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickNegateImage(wand, gray);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickNormalizeImageChannel(MagickWand *wand,
  const ChannelType channel) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickNormalizeImage(wand);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickOpaquePaintImageChannel(MagickWand *wand,
  const ChannelType channel,const PixelWand *target,
  const PixelWand *fill,const double fuzz,const MagickBooleanType invert) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickOpaquePaintImage(wand, target, fill, fuzz, invert);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickRandomThresholdImageChannel(MagickWand *wand,
  const ChannelType channel,const double low,const double high) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickRandomThresholdImage(wand, low, high);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickRotationalBlurImageChannel(MagickWand *wand,
  const ChannelType channel,const double angle) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickRotationalBlurImage(wand, angle);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickSelectiveBlurImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma,
  const double threshold) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickSelectiveBlurImage(wand, radius, sigma, threshold);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickSeparateImageChannel(MagickWand *wand,const ChannelType channel) {
	return MagickSeparateImage(wand, channel);
}

MagickBooleanType MagickSharpenImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickSharpenImage(wand, radius, sigma);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickSigmoidalContrastImageChannel(
  MagickWand *wand,const ChannelType channel,const MagickBooleanType sharpen,
  const double alpha,const double beta) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickSigmoidalContrastImage(wand, sharpen, alpha, beta);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickSolarizeImageChannel(MagickWand *wand, const ChannelType channel,const double threshold) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickSolarizeImage(wand, threshold);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickSparseColorImageChannel(MagickWand *wand, const ChannelType channel,const SparseColorMethod method, const size_t number_arguments,const double *arguments) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickSparseColorImage(wand, method, number_arguments, arguments);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

MagickBooleanType MagickStatisticImageChannel(MagickWand *wand,
  const ChannelType channel,const StatisticType type,const size_t width,
  const size_t height) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickStatisticImage(wand, type, width, height);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

//MagickBooleanType MagickThresholdImageChannel(MagickWand *wand,
//  const ChannelType channel,const double threshold) {
//	MagickBooleanType status;
//	ChannelType previous_channel_mask;
//
//	if (channel != UndefinedChannel) {
//		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
//	}
//
//	status = MagickThresholdImage(wand, threshold);
//
//	if (channel != UndefinedChannel) {
//		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
//	}
//
//	return status;
//}

MagickBooleanType MagickUnsharpMaskImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma,
  const double amount,const double threshold) {
	MagickBooleanType status;
	ChannelType previous_channel_mask;

if (channel != UndefinedChannel) {
		previous_channel_mask = MagickSetImageChannelMask(wand, channel);
	}

status = MagickUnsharpMaskImage(wand, radius, sigma, amount, threshold);

if (channel != UndefinedChannel) {
		(void) MagickSetImageChannelMask(wand, previous_channel_mask);
	}

return status;
}

#endif

${this.title}

Code Editor : shim_im6_to_im7.c