Image *get_blue_channe_image(Image *img)
{
unsigned int i = 0;
unsigned int j = 0;
PixelPacket *px_original;
PixelPacket *px_new;
Image *new_img;
ExceptionInfo exception;
ImageInfo *new_img_info;
GetExceptionInfo(&exception);
if ((new_img_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(new_img_info);
return (NULL);
}
new_img_info->colorspace = RGBColorspace;
new_img = AllocateImage(new_img_info);
new_img->rows = img->rows;
new_img->columns = img->columns;
if ((px_original = GetImagePixelsEx(img, 0, 0, img->columns, img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
if ((px_new = SetImagePixelsEx(new_img, 0, 0, new_img->columns, new_img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
while (i < img->rows)
{
j = 0;
while (j < img->columns)
{
px_new[(new_img->columns * i) + j].red = 0;
px_new[(new_img->columns * i) + j].blue = px_original[(img->columns * i) + j].blue;
px_new[(new_img->columns * i) + j].green = 0;
j++;
}
i++;
}
SyncImagePixels(new_img);
DestroyImageInfo(new_img_info);
return (new_img);
}
Image *get_green_grayscale_image(Image *img)
{
unsigned int i = 0;
unsigned int j = 0;
PixelPacket *px_original;
Image *new_img;
ExceptionInfo exception;
unsigned char *new_raw_image;
GetExceptionInfo(&exception);
if ((px_original = GetImagePixelsEx(img, 0, 0, img->columns, img->rows, &exception)) == NULL)
{
CatchException(&exception);
return (NULL);
}
new_raw_image = malloc((img->rows * img->columns) * sizeof(*new_raw_image));
while (i < img->rows)
{
j = 0;
while (j < img->columns)
{
new_raw_image[(img->columns * i) + j] = px_original[(img->columns * i) + j].green;
j++;
}
i++;
}
if ((new_img = ConstituteImage(img->columns, img->rows, "I", CharPixel, new_raw_image, &exception)) == NULL) {
CatchException(&exception);
return (NULL);
}
free(new_raw_image);
return (new_img);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P i x e l I t e r a t e T r i p l e M o d i f y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PixelIterateTripleModify() iterates through pixel regions of three images
% and invokes a user-provided callback function (of type
% PixelIteratorTripleModifyCallback) for each row of pixels. The first two
% images are read-only, while the third image is read-write for update.
% Access of the first two images is done lock-step using the same coordinates.
% This is useful to support operations such as image differencing.
%
% The format of the PixelIterateTripleModify method is:
%
% MagickPassFail PixelIterateTripleModify(
% PixelIteratorTripleModifyCallback call_back,
% const PixelIteratorOptions *options,
% const char *description,
% void *mutable_data,
% const void *immutable_data,
% const unsigned long columns,
% const unsigned long rows,
% const Image *source1_image,
% const Image *source2_image,
% const long source_x,
% const long source_y,
% Image *update_image,
% const long update_x,
% const long update_y,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o call_back: A user-provided C callback function which reads from
% a region of source pixels and updates a region of destination pixels.
%
% o options: Pixel iterator execution options (may be NULL).
%
% o description: textual description of operation being performed.
%
% o mutable_data: User-provided mutable context data.
%
% o immutable_data: User-provided immutable context data.
%
% o columns: Width of pixel region
%
% o rows: Height of pixel region
%
% o source1_image: The address of the constant source 1 Image.
%
% o source2_image: The address of the constant source 2 Image.
%
% o source_x: The horizontal ordinate of the top left corner of the source regions.
%
% o source_y: The vertical ordinate of the top left corner of the source regions.
%
% o update_image: The address of the update Image.
%
% o update_x: The horizontal ordinate of the top left corner of the update region.
%
% o update_y: The vertical ordinate of the top left corner of the update region.
%
% o exception: If an error is reported, this argument is updated with the reason.
%
*/
static MagickPassFail
PixelIterateTripleImplementation(PixelIteratorTripleModifyCallback call_back,
const PixelIteratorOptions *options,
const char *description,
void *mutable_data,
const void *immutable_data,
const unsigned long columns,
const unsigned long rows,
const Image *source1_image,
const Image *source2_image,
const long source_x,
const long source_y,
Image *update_image,
const long update_x,
const long update_y,
ExceptionInfo *exception,
MagickBool set)
{
MagickPassFail
status = MagickPass;
register long
row;
unsigned long
row_count=0;
int
max_threads;
max_threads=omp_get_max_threads();
(void) SetRegionThreads(max_threads,options,columns,rows);
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(row_count, status)
#endif
for (row=0; row < (long) rows; row++)
{
MagickBool
thread_status;
const PixelPacket
*source1_pixels,
*source2_pixels;
const IndexPacket
*source1_indexes,
*source2_indexes;
PixelPacket
*update_pixels;
IndexPacket
*update_indexes;
long
source_row,
update_row;
thread_status=status;
if (thread_status == MagickFail)
continue;
source_row=source_y+row;
update_row=update_y+row;
/*
First image (read only).
*/
source1_pixels=AcquireImagePixels(source1_image, source_x, source_row,
columns, 1, exception);
if (!source1_pixels)
thread_status=MagickFail;
source1_indexes=AccessImmutableIndexes(source1_image);
/*
Second image (read only).
*/
source2_pixels=AcquireImagePixels(source2_image, source_x, source_row,
columns, 1, exception);
if (!source2_pixels)
thread_status=MagickFail;
source2_indexes=AccessImmutableIndexes(source2_image);
/*
Third image (read/write).
*/
if (set)
update_pixels=SetImagePixelsEx(update_image, update_x, update_row,
columns, 1, exception);
else
update_pixels=GetImagePixelsEx(update_image, update_x, update_row,
columns, 1, exception);
if (!update_pixels)
{
thread_status=MagickFail;
CopyException(exception,&update_image->exception);
}
update_indexes=AccessMutableIndexes(update_image);
if (thread_status != MagickFail)
status=(call_back)(mutable_data,immutable_data,
source1_image,source1_pixels,source1_indexes,
source2_image,source2_pixels,source2_indexes,
update_image,update_pixels,update_indexes,
columns,exception);
if (!SyncImagePixelsEx(update_image,exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_PixelIterateTripleImplementation)
#endif
{
row_count++;
if (QuantumTick(row_count,rows))
if (!MagickMonitorFormatted(row_count,rows,exception,description,
source1_image->filename,
source2_image->filename,
update_image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
omp_set_num_threads(max_threads);
return (status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P i x e l I t e r a t e M o n o M o d i f y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PixelIterateMonoModify() iterates through a region of an image and invokes
% a user-provided callback function (of type PixelIteratorMonoReadCallback)
% for a region of pixels. This is useful to support simple operations such as
% level shifting, colorspace translation, or thresholding.
%
% The format of the PixelIterateMonoModify method is:
%
% MagickPassFail PixelIterateMonoModify(
% PixelIteratorMonoModifyCallback call_back,
% const PixelIteratorOptions *options,
% const char *description,
% void *mutable_data,
% const void *immutable_data,
% const long x,
% const long y,
% const unsigned long columns,
% const unsigned long rows,
% Image *image,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o call_back: A user-provided C callback function which is passed the
% address of pixels from each image.
%
% o options: Pixel iterator execution options (may be NULL).
%
% o description: textual description of operation being performed.
%
% o mutable_data: User-provided mutable context data.
%
% o immutable_data: User-provided immutable context data.
%
% o x: The horizontal ordinate of the top left corner of the region.
%
% o y: The vertical ordinate of the top left corner of the region.
%
% o columns: Width of pixel region
%
% o rows: Height of pixel region
%
% o image: The address of the Image.
%
% o exception: If an error is reported, this argument is updated with the reason.
%
*/
MagickExport MagickPassFail
PixelIterateMonoModify(PixelIteratorMonoModifyCallback call_back,
const PixelIteratorOptions *options,
const char *description,
void *mutable_data,
const void *immutable_data,
const long x,
const long y,
const unsigned long columns,
const unsigned long rows,
Image *image,
ExceptionInfo *exception)
{
MagickPassFail
status = MagickPass;
register long
row;
unsigned long
row_count=0;
int
max_threads;
max_threads=omp_get_max_threads();
(void) SetRegionThreads(max_threads,options,columns,rows);
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(row_count, status)
#endif
for (row=y; row < (long) (y+rows); row++)
{
MagickBool
thread_status;
PixelPacket
*pixels;
IndexPacket
*indexes;
thread_status=status;
if (thread_status == MagickFail)
continue;
pixels=GetImagePixelsEx(image, x, row, columns, 1, exception);
if (!pixels)
thread_status=MagickFail;
indexes=AccessMutableIndexes(image);
if (thread_status != MagickFail)
thread_status=(call_back)(mutable_data,immutable_data,image,pixels,indexes,columns,exception);
if (thread_status != MagickFail)
if (!SyncImagePixelsEx(image,exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_PixelIterateMonoModify)
#endif
{
row_count++;
if (QuantumTick(row_count,rows))
if (!MagickMonitorFormatted(row_count,rows,exception,
description,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
omp_set_num_threads(max_threads);
return (status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d S C T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadSCTImage reads a Scitex image file and returns it. It allocates
% the memory necessary for the new Image structure and returns a pointer to
% the new image.
%
% The format of the ReadSCTImage method is:
%
% Image *ReadSCTImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadSCTImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadSCTImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
buffer[768],
magick[2];
Image
*image;
long
y;
register long
x;
register PixelPacket
*q;
int
c;
unsigned int
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Read control block.
*/
do
{
if (ReadBlob(image,80,(char *) buffer) != 80)
break;
if (ReadBlob(image,2,(char *) magick) != 2)
break;
if ((LocaleNCompare((char *) magick,"CT",2) != 0) &&
(LocaleNCompare((char *) magick,"LW",2) != 0) &&
(LocaleNCompare((char *) magick,"BM",2) != 0) &&
(LocaleNCompare((char *) magick,"PG",2) != 0) &&
(LocaleNCompare((char *) magick,"TX",2) != 0))
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
if ((LocaleNCompare((char *) magick,"LW",2) == 0) ||
(LocaleNCompare((char *) magick,"BM",2) == 0) ||
(LocaleNCompare((char *) magick,"PG",2) == 0) ||
(LocaleNCompare((char *) magick,"TX",2) == 0))
ThrowReaderException(CoderError,OnlyContinuousTonePictureSupported,image);
if (ReadBlob(image,174,(char *) buffer) != 174)
break;
if (ReadBlob(image,768,(char *) buffer) != 768)
break;
/*
Read parameter block.
*/
if (ReadBlob(image,32,(char *) buffer) != 32)
break;
if (ReadBlob(image,14,(char *) buffer) != 14)
break;
image->rows=MagickAtoL(buffer) & 0x7FFFFFFF;
if (ReadBlob(image,14,(char *) buffer) != 14)
break;
image->columns=MagickAtoL(buffer) & 0x7FFFFFFF;
if (ReadBlob(image,196,(char *) buffer) != 196)
break;
if (ReadBlob(image,768,(char *) buffer) != 768)
break;
image->colorspace=CMYKColorspace;
}
while (0);
if (EOFBlob(image))
ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);
if (image_info->ping)
{
CloseBlob(image);
return(image);
}
if (CheckImagePixelLimits(image, exception) != MagickPass)
ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image);
/*
Convert SCT raster image to pixel packets.
*/
for (y=0; y < (long) image->rows; y++)
{
q=SetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->red=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
q=GetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->green=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
q=GetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->blue=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
q=GetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->opacity=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if (!SyncImagePixelsEx(image,exception))
break;
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
if (EOFBlob(image))
break;
}
if (EOFBlob(image))
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
CloseBlob(image);
return(image);
}
static void XShearImage(Image *image,const double degrees,
const unsigned long width,const unsigned long height,
const long x_offset,long y_offset)
{
#define XShearImageText "[%s] X Shear: %+g degrees, region %lux%lu%+ld%+ld... "
long
y;
unsigned long
row_count=0;
unsigned int
is_grayscale;
MagickPassFail
status=MagickPass;
assert(image != (Image *) NULL);
is_grayscale=image->is_grayscale;
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(dynamic,8) shared(row_count, status)
#endif
for (y=0; y < (long) height; y++)
{
double
alpha,
displacement;
long
step;
PixelPacket
pixel;
register long
i;
register PixelPacket
*p,
*q;
enum
{
LEFT,
RIGHT
} direction;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
displacement=degrees*(y-height/2.0);
if (displacement == 0.0)
continue;
if (displacement > 0.0)
direction=RIGHT;
else
{
displacement*=(-1.0);
direction=LEFT;
}
step=(long) floor(displacement);
alpha=MaxRGBDouble*(displacement-step);
if (alpha == 0.0)
{
/*
No fractional displacement-- just copy.
*/
switch (direction)
{
case LEFT:
{
/*
Transfer pixels left-to-right.
*/
if (step > x_offset)
break;
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset;
q=p-step;
(void) memcpy(q,p,width*sizeof(PixelPacket));
q+=width;
for (i=0; i < (long) step; i++)
*q++=image->background_color;
break;
}
case RIGHT:
{
/*
Transfer pixels right-to-left.
*/
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset+width;
q=p+step;
for (i=0; i < (long) width; i++)
*--q=(*--p);
for (i=0; i < (long) step; i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_XShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,height))
if (!MagickMonitorFormatted(row_count,height,&image->exception,
XShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
continue;
}
/*
Fractional displacement.
*/
step++;
pixel=image->background_color;
switch (direction)
{
case LEFT:
{
/*
Transfer pixels left-to-right.
*/
if (step > x_offset)
break;
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset;
q=p-step;
for (i=0; i < (long) width; i++)
{
if ((x_offset+i) < step)
{
pixel=(*++p);
q++;
continue;
}
BlendCompositePixel(q,&pixel,p,alpha);
q++;
pixel=(*p++);
}
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
q++;
for (i=0; i < (step-1); i++)
*q++=image->background_color;
break;
}
case RIGHT:
{
/*
Transfer pixels right-to-left.
*/
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset+width;
q=p+step;
for (i=0; i < (long) width; i++)
{
p--;
q--;
if ((x_offset+width+step-i) >= image->columns)
continue;
BlendCompositePixel(q,&pixel,p,alpha);
pixel=(*p);
}
--q;
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
for (i=0; i < (step-1); i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_XShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,height))
if (!MagickMonitorFormatted(row_count,height,&image->exception,
XShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
if (is_grayscale && IsGray(image->background_color))
image->is_grayscale=True;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ Y S h e a r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Procedure YShearImage shears the image in the Y direction with a shear
% angle of 'degrees'. Positive angles shear counter-clockwise (right-hand
% rule), and negative angles shear clockwise. Angles are measured relative
% to a horizontal X-axis. Y shears will increase the height of an image
% creating 'empty' triangles on the top and bottom of the source image.
%
% The format of the YShearImage method is:
%
% void YShearImage(Image *image,const double degrees,
% const unsigned long width,const unsigned long height,long x_offset,
% const long y_offset)
%
% A description of each parameter follows.
%
% o image: The image.
%
% o degrees: A double representing the shearing angle along the Y axis.
%
% o width, height, x_offset, y_offset: Defines a region of the image
% to shear.
%
%
*/
static void YShearImage(Image *image,const double degrees,
const unsigned long width,const unsigned long height,long x_offset,
const long y_offset)
{
#define YShearImageText "[%s] Y Shear: %+g degrees, region %lux%lu%+ld%+ld... "
long
y;
unsigned long
row_count=0;
unsigned int
is_grayscale;
MagickPassFail
status=MagickPass;
assert(image != (Image *) NULL);
is_grayscale=image->is_grayscale;
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(dynamic,8) shared(row_count, status)
#endif
for (y=0; y < (long) width; y++)
{
double
alpha,
displacement;
enum
{
UP,
DOWN
} direction;
long
step;
register PixelPacket
*p,
*q;
register long
i;
PixelPacket
pixel;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
displacement=degrees*(y-width/2.0);
if (displacement == 0.0)
continue;
if (displacement > 0.0)
direction=DOWN;
else
{
displacement*=(-1.0);
direction=UP;
}
step=(long) floor(displacement);
alpha=(double) MaxRGB*(displacement-step);
if (alpha == 0.0)
{
/*
No fractional displacement-- just copy the pixels.
*/
switch (direction)
{
case UP:
{
/*
Transfer pixels top-to-bottom.
*/
if (step > y_offset)
break;
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset;
q=p-step;
(void) memcpy(q,p,height*sizeof(PixelPacket));
q+=height;
for (i=0; i < (long) step; i++)
*q++=image->background_color;
break;
}
case DOWN:
{
/*
Transfer pixels bottom-to-top.
*/
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset+height;
q=p+step;
for (i=0; i < (long) height; i++)
*--q=(*--p);
for (i=0; i < (long) step; i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_YShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,width))
if (!MagickMonitorFormatted(row_count,width,&image->exception,
YShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
continue;
}
/*
Fractional displacment.
*/
step++;
pixel=image->background_color;
switch (direction)
{
case UP:
{
/*
Transfer pixels top-to-bottom.
*/
if (step > y_offset)
break;
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset;
q=p-step;
for (i=0; i < (long) height; i++)
{
if ((y_offset+i) < step)
{
pixel=(*++p);
q++;
continue;
}
BlendCompositePixel(q,&pixel,p,alpha);
q++;
pixel=(*p++);
}
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
q++;
for (i=0; i < (step-1); i++)
*q++=image->background_color;
break;
}
case DOWN:
{
/*
Transfer pixels bottom-to-top.
*/
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset+height;
q=p+step;
for (i=0; i < (long) height; i++)
{
p--;
q--;
if ((y_offset+height+step-i) >= image->rows)
continue;
BlendCompositePixel(q,&pixel,p,alpha);
pixel=(*p);
}
--q;
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
for (i=0; i < (step-1); i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_YShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,width))
if (!MagickMonitorFormatted(row_count,width,&image->exception,
YShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
if (is_grayscale && IsGray(image->background_color))
image->is_grayscale=True;
}
Image *apply_green_contrast(Image *img, unsigned char min, unsigned char max)
{
unsigned int i = 0;
unsigned int j = 0;
PixelPacket *px_original;
PixelPacket *px_new;
Image *new_img;
ExceptionInfo exception;
ImageInfo *new_img_info;
unsigned char pixel_value;
unsigned int height = img->rows;
unsigned int width = img->columns;
unsigned int dataset_min = 255;
unsigned int dataset_max = 0;
GetExceptionInfo(&exception);
if ((new_img_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(new_img_info);
return (NULL);
}
new_img_info->colorspace = RGBColorspace;
new_img = AllocateImage(new_img_info);
new_img->rows = img->rows;
new_img->columns = img->columns;
if ((px_original = GetImagePixelsEx(img, 0, 0, img->columns, img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
if ((px_new = SetImagePixelsEx(new_img, 0, 0, new_img->columns, new_img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
while (i < height)
{
j = 0;
while (j < width)
{
pixel_value = px_original[(width * i) + j].green;
if (pixel_value < dataset_min)
dataset_min = pixel_value;
if (pixel_value > dataset_max)
dataset_max = pixel_value;
j++;
}
i++;
}
i = 0;
while (i < height)
{
j = 0;
while (j < width)
{
pixel_value = px_original[(width * i) + j].green;
pixel_value = (pixel_value >= 255 ? 254 : pixel_value);
pixel_value = get_contrasted_value(min, max, dataset_min, dataset_max, pixel_value);
px_new[(width * i) + j].red = 0;
px_new[(width * i) + j].green = pixel_value;
px_new[(width * i) + j].blue = 0;
j++;
}
i++;
}
SyncImagePixels(new_img);
DestroyImageInfo(new_img_info);
return(new_img);
}
Image *substract_grayscale_to_original(Image *img, Image *gray_img, int min, int max)
{
unsigned int i = 0;
unsigned int j = 0;
PixelPacket *px_original;
PixelPacket *px_gray;
PixelPacket *px_new;
Image *new_img;
ExceptionInfo exception;
ImageInfo *new_img_info;
GetExceptionInfo(&exception);
if ((new_img_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(new_img_info);
return (NULL);
}
new_img_info->colorspace = RGBColorspace;
new_img = AllocateImage(new_img_info);
new_img->rows = img->rows;
new_img->columns = img->columns;
if ((px_original = GetImagePixelsEx(img, 0, 0, img->columns, img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
if ((px_gray = GetImagePixelsEx(gray_img, 0, 0, img->columns, img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
if ((px_new = SetImagePixelsEx(new_img, 0, 0, new_img->columns, new_img->rows, &exception)) == NULL)
{
DestroyImage(new_img);
CatchException(&exception);
return (NULL);
}
while (i < img->rows)
{
j = 0;
while (j < img->columns)
{
if(px_gray[(new_img->columns * i) + j].red > max || px_gray[(new_img->columns * i) + j].red < min)
{
px_new[(new_img->columns * i) + j].red = 0;
px_new[(new_img->columns * i) + j].blue = 0;
px_new[(new_img->columns * i) + j].green = 0;
}
else
{
px_new[(new_img->columns * i) + j].red = px_original[(new_img->columns * i) + j].red;
px_new[(new_img->columns * i) + j].blue = px_original[(new_img->columns * i) + j].blue;
px_new[(new_img->columns * i) + j].green = px_original[(new_img->columns * i) + j].green;
}
j++;
}
i++;
}
SyncImagePixels(new_img);
DestroyImageInfo(new_img_info);
return (new_img);
}
