#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite-private.h"
#include "MagickCore/enhance.h"
#include "MagickCore/exception.h"
#include "MagickCore/monitor.h"
#include "MagickCore/monitor-private.h"
#include "MagickCore/option.h"
+#include "MagickCore/pixel.h"
#include "MagickCore/pixel-accessor.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
*clut_view,
*image_view;
- double
- *clut_map;
-
MagickBooleanType
status;
MagickOffsetType
progress;
+ PixelInfo
+ *clut_map;
+
register ssize_t
- x;
+ i;
- ssize_t
- adjust,
+ ssize_t adjust,
y;
assert(image != (Image *) NULL);
assert(clut_image->signature == MagickSignature);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- clut_map=(double *) AcquireQuantumMemory(MaxMap+1UL,GetPixelChannels(image)*
- sizeof(*clut_map));
- if (clut_map == (double *) NULL)
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ clut_map=(PixelInfo *) AcquireQuantumMemory(MaxMap+1UL,sizeof(*clut_map));
+ if (clut_map == (PixelInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
/*
status=MagickTrue;
progress=0;
adjust=(ssize_t) (clut_image->interpolate == IntegerInterpolatePixel ? 0 : 1);
- clut_view=AcquireCacheView(clut_image);
+ clut_view=AcquireVirtualCacheView(clut_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4)
#endif
- for (x=0; x <= (ssize_t) MaxMap; x++)
+ for (i=0; i <= (ssize_t) MaxMap; i++)
{
- register ssize_t
- i;
-
- for (i=0; i < (ssize_t) GetPixelChannels(clut_image); i++)
- (void) InterpolatePixelChannel(clut_image,clut_view,(PixelChannel) i,
- method,QuantumScale*x*(clut_image->columns-adjust),QuantumScale*x*
- (clut_image->rows-adjust),clut_map+x*GetPixelChannels(clut_image)+i,
- exception);
+ GetPixelInfo(clut_image,clut_map+i);
+ (void) InterpolatePixelInfo(clut_image,clut_view,method,
+ QuantumScale*i*(clut_image->columns-adjust),QuantumScale*i*
+ (clut_image->rows-adjust),clut_map+i,exception);
}
clut_view=DestroyCacheView(clut_view);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
+ PixelInfo
+ pixel;
+
register Quantum
*restrict q;
status=MagickFalse;
continue;
}
+ GetPixelInfo(image,&pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
- register ssize_t
- i;
-
if (GetPixelMask(image,q) != 0)
{
q+=GetPixelChannels(image);
continue;
}
- for (i=0; i < (ssize_t) GetPixelChannels(clut_image); i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- clut_traits,
- traits;
-
- channel=GetPixelChannelMapChannel(clut_image,i);
- clut_traits=GetPixelChannelMapTraits(clut_image,channel);
- traits=GetPixelChannelMapTraits(clut_image,channel);
- if ((traits == UndefinedPixelTrait) ||
- (clut_traits == UndefinedPixelTrait) ||
- ((traits & UpdatePixelTrait) == 0))
- continue;
- SetPixelChannel(clut_image,channel,ClampToQuantum(clut_map[
- ScaleQuantumToMap(GetPixelChannel(clut_image,channel,q))*
- GetPixelChannels(clut_image)+channel]),q);
- }
+ GetPixelInfoPixel(image,q,&pixel);
+ pixel.red=clut_map[ScaleQuantumToMap(pixel.red)].red;
+ pixel.green=clut_map[ScaleQuantumToMap(pixel.green)].green;
+ pixel.blue=clut_map[ScaleQuantumToMap(pixel.blue)].blue;
+ pixel.black=clut_map[ScaleQuantumToMap(pixel.black)].black;
+ pixel.alpha=clut_map[ScaleQuantumToMap(pixel.alpha)].alpha;
+ SetPixelInfoPixel(image,&pixel,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
}
}
image_view=DestroyCacheView(image_view);
- clut_map=(double *) RelinquishMagickMemory(clut_map);
+ clut_map=(PixelInfo *) RelinquishMagickMemory(clut_map);
if ((clut_image->matte != MagickFalse) &&
((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0))
(void) SetImageAlphaChannel(image,ActivateAlphaChannel,exception);
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ContrastStretchImage() is a simple image enhancement technique that attempts
-% to improve the contrast in an image by `stretching' the range of intensity
+% to improve the contrast in an image by 'stretching' the range of intensity
% values it contains to span a desired range of values. It differs from the
% more sophisticated histogram equalization in that it can only apply a
% linear scaling function to the image pixel values. As a result the
-% `enhancement' is less harsh.
+% 'enhancement' is less harsh.
%
% The format of the ContrastStretchImage method is:
%
status=MagickTrue;
(void) ResetMagickMemory(histogram,0,(MaxMap+1)*GetPixelChannels(image)*
sizeof(*histogram));
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
p+=GetPixelChannels(image);
}
}
+ image_view=DestroyCacheView(image_view);
/*
Find the histogram boundaries by locating the black/white levels.
*/
*/
status=MagickTrue;
progress=0;
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- enhance_view=AcquireCacheView(enhance_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ enhance_view=AcquireAuthenticCacheView(enhance_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
status=MagickTrue;
(void) ResetMagickMemory(histogram,0,(MaxMap+1)*GetPixelChannels(image)*
sizeof(*histogram));
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
p+=GetPixelChannels(image);
}
}
+ image_view=DestroyCacheView(image_view);
/*
Integrate the histogram to get the equalization map.
*/
Equalize image.
*/
progress=0;
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
assert(hald_image->signature == MagickSignature);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
/*
cube_size=level*level;
width=(double) hald_image->columns;
GetPixelInfo(hald_image,&zero);
- image_view=AcquireCacheView(image);
- hald_view=AcquireCacheView(hald_image);
+ hald_view=AcquireVirtualCacheView(hald_image,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
Form histogram.
*/
(void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram));
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
if (grayscale != MagickFalse)
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% NormalizeImage() enhances the contrast of a color image by mapping the
-% darkest 2 percent of all pixel to black and the brightest 1 percent to white.
+% The NormalizeImage() method enhances the contrast of a color image by
+% mapping the darkest 2 percent of all pixel to black and the brightest
+% 1 percent to white.
%
% The format of the NormalizeImage method is:
%
% sigmoidal contrast algorithm. Increase the contrast of the image using a
% sigmoidal transfer function without saturating highlights or shadows.
% Contrast indicates how much to increase the contrast (0 is none; 3 is
-% typical; 20 is pushing it); mid-point indicates where threshold 'knee' of
-% the curve falls (typical 50% for mid-gray). Set sharpen to MagickTrue to
-% increase the image contrast otherwise the contrast is reduced.
+% typical; 20 is pushing it); mid-point indicates where midtones fall in the
+% resultant image (0 is white; 50% is middle-gray; 100% is black). Set
+% sharpen to MagickTrue to increase the image contrast otherwise the contrast
+% is reduced.
%
% The format of the SigmoidalContrastImage method is:
%
{
if (sharpen != MagickFalse)
{
+#define sigmoidal(a,b,x) (1/(1+exp((a)*((b)-(x)))))
+#if 1
+ /* Simpilified function scaling,
+ * with better 'contrast=0' or 'flatline' handling (greyscale)
+ */
+ double
+ u0 = sigmoidal(contrast,QuantumScale*midpoint,0.0),
+ u1 = sigmoidal(contrast,QuantumScale*midpoint,1.0);
+ sigmoidal_map[i]=(MagickRealType) ScaleMapToQuantum(
+ (MagickRealType)(MaxMap*(
+ (sigmoidal(contrast,QuantumScale*midpoint,(double)i/MaxMap)
+ -(u0+u1)/2.0)/(u1-u0+MagickEpsilon)+0.5) ));
+#else
+ /* Scaled sigmoidal formula...
+ (1/(1+exp(a*(b-u))) - 1/(1+exp(a))) /
+ (1/(1+exp(a*(b-1)))/(1+exp(a)))) */
sigmoidal_map[i]=(MagickRealType) ScaleMapToQuantum((MagickRealType)
(MaxMap*((1.0/(1.0+exp(contrast*(midpoint/(double) QuantumRange-
- (double) i/MaxMap))))-(1.0/(1.0+exp(contrast*(midpoint/(double)
- QuantumRange)))))/((1.0/(1.0+exp(contrast*(midpoint/(double)
- QuantumRange-1.0))))-(1.0/(1.0+exp(contrast*(midpoint/(double)
- QuantumRange)))))+0.5));
+ (double) i/MaxMap))))-(1.0/(1.0+exp(contrast*(midpoint/
+ (double) QuantumRange)))))/((1.0/(1.0+exp(contrast*(midpoint/
+ (double) QuantumRange-1.0))))-(1.0/(1.0+exp(contrast*(midpoint/
+ (double) QuantumRange)))))+0.5));
+#endif
continue;
}
+#if 1
+ {
+ /* Inverse -- See
+ http://osdir.com/ml/video.image-magick.devel/2005-04/msg00006.html
+ */
+ double
+ min = sigmoidal(contrast,1.0,0.0),
+ max = sigmoidal(contrast,QuantumScale*midpoint,1.0),
+ xi = min+(double)i/MaxMap*(max-min);
+ sigmoidal_map[i]=(MagickRealType) ScaleMapToQuantum(
+ (MagickRealType)(MaxMap*(
+ QuantumScale*midpoint-log((1-xi)/xi)/contrast) ));
+ }
+#else
+ /* expanded form of the above */
sigmoidal_map[i]=(MagickRealType) ScaleMapToQuantum((MagickRealType)
- (MaxMap*(QuantumScale*midpoint-log((1.0-(1.0/(1.0+exp(midpoint/(double)
- QuantumRange*contrast))+((double) i/MaxMap)*((1.0/(1.0+exp(contrast*(
- midpoint/(double) QuantumRange-1.0))))-(1.0/(1.0+exp(midpoint/(double)
- QuantumRange*contrast))))))/(1.0/(1.0+exp(midpoint/(double) QuantumRange*
- contrast))+((double) i/MaxMap)*((1.0/(1.0+exp(contrast*(midpoint/(double)
- QuantumRange-1.0))))-(1.0/(1.0+exp(midpoint/(double) QuantumRange*
- contrast))))))/contrast)));
+ (MaxMap*(QuantumScale*midpoint-log((1.0-(1.0/(1.0+exp(midpoint/
+ (double) QuantumRange*contrast))+((double) i/MaxMap)*((1.0/
+ (1.0+exp(contrast*(midpoint/(double) QuantumRange-1.0))))-(1.0/
+ (1.0+exp(midpoint/(double) QuantumRange*contrast))))))/
+ (1.0/(1.0+exp(midpoint/(double) QuantumRange*contrast))+
+ ((double) i/MaxMap)*((1.0/(1.0+exp(contrast*(midpoint/
+ (double) QuantumRange-1.0))))-(1.0/(1.0+exp(midpoint/
+ (double) QuantumRange*contrast))))))/contrast)));
+#endif
}
if (image->storage_class == PseudoClass)
{
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
projects / imagemagick / blobdiff