#include "MagickCore/cache-view.h"
#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
+#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite.h"
#include "MagickCore/decorate.h"
#include "MagickCore/distort.h"
*noise_image;
MagickBooleanType
+ concurrent,
status;
MagickOffsetType
status=MagickTrue;
progress=0;
random_info=AcquireRandomInfoThreadSet();
+ concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
+ MagickFalse;
image_view=AcquireCacheView(image);
noise_view=AcquireCacheView(noise_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) omp_concurrent(concurrent)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(noise_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
if ((traits == UndefinedPixelTrait) ||
(noise_traits == UndefinedPixelTrait))
continue;
- if (((noise_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(image,p) != 0))
+ if ((noise_traits & CopyPixelTrait) != 0)
{
SetPixelChannel(noise_image,channel,p[i],q);
continue;
const PixelInfo *colorize,ExceptionInfo *exception)
{
#define ColorizeImageTag "Colorize/Image"
+#define Colorize(pixel,blend_percentage,colorize) \
+ (pixel)=((pixel)*(100.0-(blend_percentage))+(colorize)*(blend_percentage))/100.0;
CacheView
*colorize_view,
flags;
PixelInfo
- pixel;
+ blend_percentage;
ssize_t
y;
colorize_image=DestroyImage(colorize_image);
return((Image *) NULL);
}
- if ((colorize->matte != MagickFalse) &&
- (colorize_image->matte == MagickFalse))
+ if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
+ (IsPixelInfoGray(colorize) != MagickFalse))
+ (void) SetImageColorspace(colorize_image,sRGBColorspace,exception);
+ if ((colorize_image->matte == MagickFalse) &&
+ (colorize->matte != MagickFalse))
(void) SetImageAlpha(colorize_image,OpaqueAlpha,exception);
if (blend == (const char *) NULL)
return(colorize_image);
- /*
- Determine RGB values of the fill color for pixel
- */
- GetPixelInfo(image,&pixel);
+ GetPixelInfo(image,&blend_percentage);
flags=ParseGeometry(blend,&geometry_info);
- pixel.red=geometry_info.rho;
- pixel.green=geometry_info.rho;
- pixel.blue=geometry_info.rho;
- pixel.alpha=100.0;
+ blend_percentage.red=geometry_info.rho;
+ blend_percentage.green=geometry_info.rho;
+ blend_percentage.blue=geometry_info.rho;
+ blend_percentage.black=geometry_info.rho;
+ blend_percentage.alpha=geometry_info.rho;
if ((flags & SigmaValue) != 0)
- pixel.green=geometry_info.sigma;
+ blend_percentage.green=geometry_info.sigma;
if ((flags & XiValue) != 0)
- pixel.blue=geometry_info.xi;
+ blend_percentage.blue=geometry_info.xi;
if ((flags & PsiValue) != 0)
- pixel.alpha=geometry_info.psi;
- if (pixel.colorspace == CMYKColorspace)
+ blend_percentage.alpha=geometry_info.psi;
+ if (blend_percentage.colorspace == CMYKColorspace)
{
- pixel.black=geometry_info.rho;
if ((flags & PsiValue) != 0)
- pixel.black=geometry_info.psi;
+ blend_percentage.black=geometry_info.psi;
if ((flags & ChiValue) != 0)
- pixel.alpha=geometry_info.chi;
+ blend_percentage.alpha=geometry_info.chi;
}
/*
Colorize DirectClass image.
MagickBooleanType
sync;
+ PixelInfo
+ pixel;
+
register const Quantum
*restrict p;
status=MagickFalse;
continue;
}
+ GetPixelInfo(colorize_image,&pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
- register ssize_t
- i;
-
- for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- colorize_traits,
- traits;
-
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- colorize_traits=GetPixelChannelMapTraits(colorize_image,channel);
- if ((traits == UndefinedPixelTrait) ||
- (colorize_traits == UndefinedPixelTrait))
- continue;
- if (((colorize_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(image,p) != 0))
- {
- SetPixelChannel(colorize_image,channel,p[i],q);
- continue;
- }
- switch (channel)
+ if (GetPixelMask(colorize_image,q) != 0)
{
- case RedPixelChannel:
- {
- SetPixelChannel(colorize_image,channel,ClampToQuantum((p[i]*
- (100.0-pixel.red)+colorize->red*pixel.red)/100.0),q);
- break;
- }
- case GreenPixelChannel:
- {
- SetPixelChannel(colorize_image,channel,ClampToQuantum((p[i]*
- (100.0-pixel.green)+colorize->green*pixel.green)/100.0),q);
- break;
- }
- case BluePixelChannel:
- {
- SetPixelChannel(colorize_image,channel,ClampToQuantum((p[i]*
- (100.0-pixel.blue)+colorize->blue*pixel.blue)/100.0),q);
- break;
- }
- case BlackPixelChannel:
- {
- SetPixelChannel(colorize_image,channel,ClampToQuantum((p[i]*
- (100.0-pixel.black)+colorize->black*pixel.black)/100.0),q);
- break;
- }
- case AlphaPixelChannel:
- {
- SetPixelChannel(colorize_image,channel,ClampToQuantum((p[i]*
- (100.0-pixel.alpha)+colorize->alpha*pixel.alpha)/100.0),q);
- break;
- }
- default:
- {
- SetPixelChannel(colorize_image,channel,p[i],q);
- break;
- }
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(colorize_image);
+ continue;
}
- }
+ GetPixelInfoPixel(image,p,&pixel);
+ Colorize(pixel.red,blend_percentage.red,colorize->red);
+ Colorize(pixel.green,blend_percentage.green,colorize->green);
+ Colorize(pixel.blue,blend_percentage.blue,colorize->blue);
+ Colorize(pixel.black,blend_percentage.black,colorize->black);
+ Colorize(pixel.alpha,blend_percentage.alpha,colorize->alpha);
+ SetPixelInfoPixel(colorize_image,&pixel,q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(colorize_image);
}
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(fx_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
MagickRealType
if ((traits == UndefinedPixelTrait) ||
(fx_traits == UndefinedPixelTrait))
continue;
- if (((fx_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(image,p) != 0))
+ if ((fx_traits & CopyPixelTrait) != 0)
{
SetPixelChannel(fx_image,channel,p[i],q);
continue;
register ssize_t
i;
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(morph_image);
+ continue;
+ }
for (i=0; i < (ssize_t) GetPixelChannels(morph_image); i++)
{
PixelChannel
if ((traits == UndefinedPixelTrait) ||
(morph_traits == UndefinedPixelTrait))
continue;
- if (((morph_traits & CopyPixelTrait) != 0) ||
- (GetPixelMask(image,p) != 0))
+ if ((morph_traits & CopyPixelTrait) != 0)
{
SetPixelChannel(morph_image,channel,p[i],q);
continue;
clone_image=CloneImage(image,0,0,MagickTrue,exception);
if (clone_image == (Image *) NULL)
return((Image *) NULL);
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
+ (void) TransformImageColorspace(clone_image,sRGBColorspace,exception);
(void) SetImageVirtualPixelMethod(clone_image,EdgeVirtualPixelMethod,
exception);
border_info.width=(size_t) floor(2.0*sigma+0.5);
*sketch_image;
MagickBooleanType
+ concurrent,
status;
RandomInfo
return((Image *) NULL);
status=MagickTrue;
random_info=AcquireRandomInfoThreadSet();
+ concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
+ MagickFalse;
random_view=AcquireCacheView(random_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) omp_concurrent(concurrent)
#endif
for (y=0; y < (ssize_t) random_image->rows; y++)
{
projects / imagemagick / blobdiff