// Annotate using specified text, bounding area, and placement
// gravity
annotateImage ( const std::string &text_,
- const Geometry &geometry_,
- const GravityType gravity_ );
+ const Geometry &geometry_,
+ const GravityType gravity_ );
// Annotate with text using specified text, bounding area,
// placement gravity, and rotation.
// Annotate with text (bounding area is entire image) and
// placement gravity.
annotateImage ( const std::string &text_,
- const GravityType gravity_ );
+ const GravityType gravity_ );
void operator()( Image &image_ ) const;
colorizeImage( const unsigned int opacityRed_,
const unsigned int opacityGreen_,
const unsigned int opacityBlue_,
- const Color &penColor_ );
+ const Color &penColor_ );
colorizeImage( const unsigned int opacity_,
const Color &penColor_ );
{
public:
compositeImage( const Image &compositeImage_,
- int xOffset_,
- int yOffset_,
- CompositeOperator compose_ = InCompositeOp );
+ int xOffset_,
+ int yOffset_,
+ CompositeOperator compose_ = InCompositeOp );
compositeImage( const Image &compositeImage_,
- const Geometry &offset_,
- CompositeOperator compose_ = InCompositeOp );
+ const Geometry &offset_,
+ CompositeOperator compose_ = InCompositeOp );
void operator()( Image &image_ ) const;
// Uses current fuzz setting when determining color match.
floodFillColorImage( const unsigned int x_,
const unsigned int y_,
- const Color &fillColor_ );
+ const Color &fillColor_ );
floodFillColorImage( const Geometry &point_,
- const Color &fillColor_ );
+ const Color &fillColor_ );
// Flood-fill color across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
floodFillColorImage( const unsigned int x_,
const unsigned int y_,
- const Color &fillColor_,
- const Color &borderColor_ );
+ const Color &fillColor_,
+ const Color &borderColor_ );
floodFillColorImage( const Geometry &point_,
- const Color &fillColor_,
- const Color &borderColor_ );
+ const Color &fillColor_,
+ const Color &borderColor_ );
void operator()( Image &image_ ) const;
// Uses current fuzz setting when determining color match.
floodFillTextureImage( const unsigned int x_,
const unsigned int y_,
- const Image &texture_ );
+ const Image &texture_ );
floodFillTextureImage( const Geometry &point_,
- const Image &texture_ );
+ const Image &texture_ );
// Flood-fill texture across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
floodFillTextureImage( const unsigned int x_,
const unsigned int y_,
- const Image &texture_,
- const Color &borderColor_ );
+ const Image &texture_,
+ const Color &borderColor_ );
floodFillTextureImage( const Geometry &point_,
- const Image &texture_,
- const Color &borderColor_ );
+ const Image &texture_,
+ const Color &borderColor_ );
void operator()( Image &image_ ) const;
frameImage( const Geometry &geometry_ = frameGeometryDefault );
frameImage( const unsigned int width_, const unsigned int height_,
- const int innerBevel_ = 6, const int outerBevel_ = 6 );
+ const int innerBevel_ = 6, const int outerBevel_ = 6 );
void operator()( Image &image_ ) const;
gammaImage( const double gamma_ );
gammaImage ( const double gammaRed_,
- const double gammaGreen_,
- const double gammaBlue_ );
+ const double gammaGreen_,
+ const double gammaBlue_ );
void operator()( Image &image_ ) const;
{
public:
matteFloodfillImage( const Color &target_ ,
- const unsigned int matte_,
- const int x_, const int y_,
- const PaintMethod method_ );
+ const unsigned int matte_,
+ const int x_, const int y_,
+ const PaintMethod method_ );
void operator()( Image &image_ ) const;
{
public:
modulateImage( const double brightness_,
- const double saturation_,
- const double hue_ );
+ const double saturation_,
+ const double hue_ );
void operator()( Image &image_ ) const;
{
public:
opaqueImage( const Color &opaqueColor_,
- const Color &penColor_ );
+ const Color &penColor_ );
void operator()( Image &image_ ) const;
{
public:
raiseImage( const Geometry &geometry_ = raiseGeometryDefault,
- const bool raisedFlag_ = false );
+ const bool raisedFlag_ = false );
void operator()( Image &image_ ) const;
{
public:
segmentImage( const double clusterThreshold_ = 1.0,
- const double smoothingThreshold_ = 1.5 );
+ const double smoothingThreshold_ = 1.5 );
void operator()( Image &image_ ) const;
{
public:
shadeImage( const double clusterThreshold_ = 1.0,
- const double smoothingThreshold_ = 1.5 );
+ const double smoothingThreshold_ = 1.5 );
void operator()( Image &image_ ) const;
{
public:
shearImage( const double xShearAngle_,
- const double yShearAngle_ );
+ const double yShearAngle_ );
void operator()( Image &image_ ) const;
transformImage( const Geometry &imageGeometry_ );
transformImage( const Geometry &imageGeometry_,
- const Geometry &cropGeometry_ );
+ const Geometry &cropGeometry_ );
void operator()( Image &image_ ) const;
{
public:
waveImage( const double amplitude_ = 25.0,
- const double wavelength_ = 150.0 );
+ const double wavelength_ = 150.0 );
void operator()( Image &image_ ) const;
public:
pixelColorImage( const unsigned int x_,
const unsigned int y_,
- const Color &color_);
+ const Color &color_);
void operator()( Image &image_ ) const;
{
public:
sigmoidalContrastImage( const unsigned int sharpen_,
- const double contrast,
- const double midpoint = QuantumRange / 2.0 );
+ const double contrast,
+ const double midpoint = QuantumRange / 2.0 );
void operator()( Image &image_ ) const;
// method in order to specify the entire container.
template <class InputIterator>
void linkImages( InputIterator first_,
- InputIterator last_ ) {
+ InputIterator last_ ) {
MagickCore::Image* previous = 0;
int scene = 0;
for ( InputIterator iter = first_; iter != last_; ++iter )
{
- // Unless we reduce the reference count to one, the same image
- // structure may occur more than once in the container, causing
- // the linked list to fail.
- iter->modifyImage();
+ // Unless we reduce the reference count to one, the same image
+ // structure may occur more than once in the container, causing
+ // the linked list to fail.
+ iter->modifyImage();
- MagickCore::Image* current = iter->image();
+ MagickCore::Image* current = iter->image();
- current->previous = previous;
- current->next = 0;
+ current->previous = previous;
+ current->next = 0;
- if ( previous != 0)
- previous->next = current;
+ if ( previous != 0)
+ previous->next = current;
- current->scene=scene;
- ++scene;
+ current->scene=scene;
+ ++scene;
- previous = current;
+ previous = current;
}
}
// back to its pristine un-linked state.
template <class InputIterator>
void unlinkImages( InputIterator first_,
- InputIterator last_ ) {
+ InputIterator last_ ) {
for( InputIterator iter = first_; iter != last_; ++iter )
{
- MagickCore::Image* image = iter->image();
- image->previous = 0;
- image->next = 0;
+ MagickCore::Image* image = iter->image();
+ image->previous = 0;
+ image->next = 0;
}
}
// The options are copied into the object.
template <class Container>
void insertImages( Container *sequence_,
- MagickCore::Image* images_ ) {
+ MagickCore::Image* images_ ) {
MagickCore::Image *image = images_;
if ( image )
{
- do
- {
- MagickCore::Image* next_image = image->next;
- image->next = 0;
-
- if (next_image != 0)
- next_image->previous=0;
-
- sequence_->push_back( Magick::Image( image ) );
-
- image=next_image;
- } while( image );
+ do
+ {
+ MagickCore::Image* next_image = image->next;
+ image->next = 0;
+
+ if (next_image != 0)
+ next_image->previous=0;
+
+ sequence_->push_back( Magick::Image( image ) );
+
+ image=next_image;
+ } while( image );
- return;
+ return;
}
}
template <class InputIterator>
void animateImages( InputIterator first_,
- InputIterator last_ ) {
+ InputIterator last_ ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
// vertical direction.
template <class InputIterator>
void appendImages( Image *appendedImage_,
- InputIterator first_,
- InputIterator last_,
- bool stack_ = false) {
+ InputIterator first_,
+ InputIterator last_,
+ bool stack_ = false) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::AppendImages( first_->image(),
- (MagickBooleanType) stack_,
- &exceptionInfo );
+ (MagickBooleanType) stack_,
+ &exceptionInfo );
unlinkImages( first_, last_ );
appendedImage_->replaceImage( image );
throwException( exceptionInfo );
// All the input images must be the same size in pixels.
template <class InputIterator>
void averageImages( Image *averagedImage_,
- InputIterator first_,
- InputIterator last_ ) {
+ InputIterator first_,
+ InputIterator last_ ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::AverageImages( first_->image(),
- &exceptionInfo );
+ &exceptionInfo );
unlinkImages( first_, last_ );
averagedImage_->replaceImage( image );
throwException( exceptionInfo );
//
template <class InputIterator>
void displayImages( InputIterator first_,
- InputIterator last_ ) {
+ InputIterator last_ ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
// This is useful for combining Photoshop layers into a single image.
template <class InputIterator>
void flattenImages( Image *flattendImage_,
- InputIterator first_,
- InputIterator last_ ) {
+ InputIterator first_,
+ InputIterator last_ ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(),
- FlattenLayer,&exceptionInfo );
+ FlattenLayer,&exceptionInfo );
unlinkImages( first_, last_ );
flattendImage_->replaceImage( image );
throwException( exceptionInfo );
// true in order to evaluate quantization error.
template <class InputIterator>
void mapImages( InputIterator first_,
- InputIterator last_,
- const Image& mapImage_,
- bool dither_ = false,
- bool measureError_ = false ) {
+ InputIterator last_,
+ const Image& mapImage_,
+ bool dither_ = false,
+ bool measureError_ = false ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
+ MagickCore::QuantizeInfo quantizeInfo;
+ MagickCore::GetQuantizeInfo( &quantizeInfo );
+ quantizeInfo = dither_ ? MagickCore::MagickTrue : MagickCore::MagickFalse;
linkImages( first_, last_ );
- MagickCore::MapImages( first_->image(),
- mapImage_.constImage(),
- dither_ ? MagickCore::MagickTrue : MagickCore::MagickFalse);
+ MagickCore::RemapImages( &quantizeInfo, first_->image(),
+ mapImage_.constImage());
MagickCore::GetImageException( first_->image(), &exceptionInfo );
if ( exceptionInfo.severity != MagickCore::UndefinedException )
{
- unlinkImages( first_, last_ );
- throwException( exceptionInfo );
+ unlinkImages( first_, last_ );
+ throwException( exceptionInfo );
}
MagickCore::Image* image = first_->image();
while( image )
{
- // Calculate quantization error
- if ( measureError_ )
- {
- MagickCore::GetImageQuantizeError( image );
- if ( image->exception.severity > MagickCore::UndefinedException )
- {
- unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- }
- }
-
- // Udate DirectClass representation of pixels
- MagickCore::SyncImage( image );
- if ( image->exception.severity > MagickCore::UndefinedException )
- {
- unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- }
-
- // Next image
- image=image->next;
+ // Calculate quantization error
+ if ( measureError_ )
+ {
+ MagickCore::GetImageQuantizeError( image );
+ if ( image->exception.severity > MagickCore::UndefinedException )
+ {
+ unlinkImages( first_, last_ );
+ throwException( exceptionInfo );
+ }
+ }
+
+ // Udate DirectClass representation of pixels
+ MagickCore::SyncImage( image );
+ if ( image->exception.severity > MagickCore::UndefinedException )
+ {
+ unlinkImages( first_, last_ );
+ throwException( exceptionInfo );
+ }
+
+ // Next image
+ image=image->next;
}
unlinkImages( first_, last_ );
// Create a composite image by combining several separate images.
template <class Container, class InputIterator>
void montageImages( Container *montageImages_,
- InputIterator first_,
- InputIterator last_,
- const Montage &montageOpts_ ) {
+ InputIterator first_,
+ InputIterator last_,
+ const Montage &montageOpts_ ) {
MagickCore::MontageInfo* montageInfo =
static_cast<MagickCore::MontageInfo*>(MagickCore::AcquireMagickMemory(sizeof(MagickCore::MontageInfo)));
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
MagickCore::Image *images = MagickCore::MontageImages( first_->image(),
- montageInfo,
- &exceptionInfo );
+ montageInfo,
+ &exceptionInfo );
if ( images != 0 )
{
- insertImages( montageImages_, images );
+ insertImages( montageImages_, images );
}
// Clean up any allocated data in montageInfo
// Apply transparency to montage images
if ( montageImages_->size() > 0 && montageOpts_.transparentColor().isValid() )
{
- for_each( first_, last_, transparentImage( montageOpts_.transparentColor() ) );
+ for_each( first_, last_, transparentImage( montageOpts_.transparentColor() ) );
}
// Report any transparentImage() error
// Morph a set of images
template <class InputIterator, class Container >
void morphImages( Container *morphedImages_,
- InputIterator first_,
- InputIterator last_,
- unsigned int frames_ ) {
+ InputIterator first_,
+ InputIterator last_,
+ unsigned int frames_ ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
// Build image list
linkImages( first_, last_ );
MagickCore::Image* images = MagickCore::MorphImages( first_->image(), frames_,
- &exceptionInfo);
+ &exceptionInfo);
// Unlink image list
unlinkImages( first_, last_ );
// Inlay a number of images to form a single coherent picture.
template <class InputIterator>
void mosaicImages( Image *mosaicImage_,
- InputIterator first_,
- InputIterator last_ ) {
+ InputIterator first_,
+ InputIterator last_ ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(),
- MosaicLayer,&exceptionInfo );
+ MosaicLayer,&exceptionInfo );
unlinkImages( first_, last_ );
mosaicImage_->replaceImage( image );
throwException( exceptionInfo );
// Set measureError_ to true in order to measure quantization error
template <class InputIterator>
void quantizeImages( InputIterator first_,
- InputIterator last_,
- bool measureError_ = false ) {
+ InputIterator last_,
+ bool measureError_ = false ) {
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::QuantizeImages( first_->quantizeInfo(),
- first_->image() );
+ first_->image() );
MagickCore::GetImageException( first_->image(), &exceptionInfo );
if ( exceptionInfo.severity > MagickCore::UndefinedException )
{
- unlinkImages( first_, last_ );
- throwException( exceptionInfo );
+ unlinkImages( first_, last_ );
+ throwException( exceptionInfo );
}
MagickCore::Image* image = first_->image();
while( image != 0 )
{
- // Calculate quantization error
- if ( measureError_ )
- MagickCore::GetImageQuantizeError( image );
+ // Calculate quantization error
+ if ( measureError_ )
+ MagickCore::GetImageQuantizeError( image );
- // Update DirectClass representation of pixels
- MagickCore::SyncImage( image );
+ // Update DirectClass representation of pixels
+ MagickCore::SyncImage( image );
- // Next image
- image=image->next;
+ // Next image
+ image=image->next;
}
unlinkImages( first_, last_ );
// FIXME: need a way to specify options like size, depth, and density.
template <class Container>
void readImages( Container *sequence_,
- const std::string &imageSpec_ ) {
+ const std::string &imageSpec_ ) {
MagickCore::ImageInfo *imageInfo = MagickCore::CloneImageInfo(0);
imageSpec_.copy( imageInfo->filename, MaxTextExtent-1 );
imageInfo->filename[ imageSpec_.length() ] = 0;
}
template <class Container>
void readImages( Container *sequence_,
- const Blob &blob_ ) {
+ const Blob &blob_ ) {
MagickCore::ImageInfo *imageInfo = MagickCore::CloneImageInfo(0);
MagickCore::ExceptionInfo exceptionInfo;
MagickCore::GetExceptionInfo( &exceptionInfo );
MagickCore::Image *images = MagickCore::BlobToImage( imageInfo,
- blob_.data(),
- blob_.length(), &exceptionInfo );
+ blob_.data(),
+ blob_.length(), &exceptionInfo );
MagickCore::DestroyImageInfo(imageInfo);
insertImages( sequence_, images );
throwException( exceptionInfo );
// Write Images
template <class InputIterator>
void writeImages( InputIterator first_,
- InputIterator last_,
- const std::string &imageSpec_,
- bool adjoin_ = true ) {
+ InputIterator last_,
+ const std::string &imageSpec_,
+ bool adjoin_ = true ) {
first_->adjoin( adjoin_ );
// Write images to BLOB
template <class InputIterator>
void writeImages( InputIterator first_,
- InputIterator last_,
- Blob *blob_,
- bool adjoin_ = true) {
+ InputIterator last_,
+ Blob *blob_,
+ bool adjoin_ = true) {
first_->adjoin( adjoin_ );
MagickCore::GetExceptionInfo( &exceptionInfo );
size_t length = 2048; // Efficient size for small images
void* data = MagickCore::ImagesToBlob( first_->imageInfo(),
- first_->image(),
- &length,
- &exceptionInfo);
+ first_->image(),
+ &length,
+ &exceptionInfo);
blob_->updateNoCopy( data, length, Magick::Blob::MallocAllocator );
unlinkImages( first_, last_ );
#include "magick/quantum-private.h"
#include "magick/registry.h"
#include "magick/resize.h"
+#include "magick/resource_.h"
#include "magick/segment.h"
#include "magick/shear.h"
#include "magick/signature.h"
}
if (LocaleCompare((const char *) tag, "profile") == 0)
{
- ImageInfo
- *clone_info;
-
if (msl_info->image[n] == (Image *) NULL)
{
ThrowMSLException(OptionError,"NoImagesDefined",
AppendImageToList(&msl_info->image[n],image);
break;
}
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- break;
- }
- case 'G':
- case 'g':
- {
- if (LocaleCompare(keyword,"gravity") == 0)
- {
- option=ParseMagickOption(MagickGravityOptions,MagickFalse,
- value);
- if (option < 0)
- ThrowMSLException(OptionError,"UnrecognizedGravityType",
- value);
- (void) SetImageOption(msl_info->image_info[n],keyword,
- value);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- break;
- }
- case 'P':
- case 'p':
- {
- if (LocaleCompare(keyword,"pointsize") == 0)
- {
- msl_info->image_info[n]->pointsize=atof(value);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- break;
- }
- case 'S':
- case 's':
- {
- if (LocaleCompare(keyword,"size") == 0)
- {
- msl_info->image_info[n]->size=AcquireString(value);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
+ (void) SetMSLAttributes(msl_info,keyword,value);
break;
}
default:
{
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
+ (void) SetMSLAttributes(msl_info,keyword,value);
break;
}
}
MaxTextExtent);
break;
}
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- }
- case 'Q':
- case 'q':
- {
- if (LocaleCompare(keyword,"quality") == 0)
- {
- msl_info->image_info[n]->quality=atol(value);
- msl_info->image[n]->quality=
- msl_info->image_info[n]->quality;
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
+ (void) SetMSLAttributes(msl_info,keyword,value);
}
default:
{
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
+ (void) SetMSLAttributes(msl_info,keyword,value);
break;
}
}
static MagickBooleanType SetMSLAttributes(MSLInfo *msl_info,const char *keyword,
const char *value)
{
+ Image
+ *attributes;
+
DrawInfo
*draw_info;
ExceptionInfo
*exception;
+ GeometryInfo
+ geometry_info;
+
Image
*image;
ImageInfo
*image_info;
+ int
+ flags;
+
long
n;
return(MagickTrue);
exception=msl_info->exception;
n=msl_info->n;
+ attributes=msl_info->attributes[n];
image_info=msl_info->image_info[n];
draw_info=msl_info->draw_info[n];
image=msl_info->image[n];
alpha=ParseMagickOption(MagickAlphaOptions,MagickFalse,value);
if (alpha < 0)
ThrowMSLException(OptionError,"UnrecognizedType",value);
- (void) SetImageAlphaChannel(image,(AlphaChannelType) alpha);
+ if (image != (Image *) NULL)
+ (void) SetImageAlphaChannel(image,(AlphaChannelType) alpha);
+ break;
+ }
+ if (LocaleCompare(keyword,"antialias") == 0)
+ {
+ long
+ antialias;
+
+ antialias=ParseMagickOption(MagickBooleanOptions,MagickFalse,value);
+ if (antialias < 0)
+ ThrowMSLException(OptionError,"UnrecognizedGravityType",value);
+ image_info->antialias=(MagickBooleanType) antialias;
+ break;
+ }
+ if (LocaleCompare(keyword,"area-limit") == 0)
+ {
+ MagickSizeType
+ limit;
+
+ limit=MagickResourceInfinity;
+ if (LocaleCompare(value,"unlimited") != 0)
+ limit=(MagickSizeType) StringToDouble(value,100.0);
+ (void) SetMagickResourceLimit(AreaResource,limit);
+ break;
+ }
+ if (LocaleCompare(keyword,"attenuate") == 0)
+ {
+ (void) SetImageOption(image_info,keyword,value);
+ break;
+ }
+ if (LocaleCompare(keyword,"authenticate") == 0)
+ {
+ (void) CloneString(&image_info->density,value);
break;
}
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
exception);
break;
}
+ if (LocaleCompare(keyword,"bias") == 0)
+ {
+ if (image == (Image *) NULL)
+ break;
+ image->bias=StringToDouble(value,QuantumRange);
+ break;
+ }
+ if (LocaleCompare(keyword,"blue-primary") == 0)
+ {
+ if (image == (Image *) NULL)
+ break;
+ flags=ParseGeometry(value,&geometry_info);
+ image->chromaticity.blue_primary.x=geometry_info.rho;
+ image->chromaticity.blue_primary.y=geometry_info.sigma;
+ if ((flags & SigmaValue) == 0)
+ image->chromaticity.blue_primary.y=
+ image->chromaticity.blue_primary.x;
+ break;
+ }
if (LocaleCompare(keyword,"bordercolor") == 0)
{
(void) QueryColorDatabase(value,&image_info->border_color,
(void) SetImageOption(image_info,keyword,value);
break;
}
+ if (LocaleCompare(keyword,"filename") == 0)
+ {
+ (void) CopyMagickString(image_info->filename,value,MaxTextExtent);
+ break;
+ }
+ ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
+ break;
+ }
+ case 'G':
+ case 'g':
+ {
+ if (LocaleCompare(keyword,"gravity") == 0)
+ {
+ long
+ gravity;
+
+ gravity=ParseMagickOption(MagickGravityOptions,MagickFalse,value);
+ if (gravity < 0)
+ ThrowMSLException(OptionError,"UnrecognizedGravityType",value);
+ (void) SetImageOption(image_info,keyword,value);
+ break;
+ }
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
break;
}
{
if (LocaleCompare(keyword,"id") == 0)
{
- (void) SetImageProperty(msl_info->attributes[n],keyword,NULL);
- (void) SetImageProperty(msl_info->attributes[n],keyword,value);
+ (void) SetImageProperty(attributes,keyword,value);
break;
}
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
{
if (LocaleCompare(keyword,"pointsize") == 0)
{
+ image_info->pointsize=atof(value);
draw_info->pointsize=atof(value);
break;
}
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
break;
}
+ case 'Q':
+ case 'q':
+ {
+ if (LocaleCompare(keyword,"quality") == 0)
+ {
+ image_info->quality=atol(value);
+ if (image == (Image *) NULL)
+ break;
+ image->quality=atol(value);
+ break;
+ }
+ break;
+ }
case 'S':
case 's':
{
*DrawContext;
extern WandExport double
- DrawGetFillAlpha(const DrawingWand *),
- DrawGetStrokeAlpha(const DrawingWand *);
+ DrawGetFillAlpha(const DrawingWand *) magick_attribute((deprecated)),
+ DrawGetStrokeAlpha(const DrawingWand *) magick_attribute((deprecated));
extern WandExport DrawInfo
- *DrawPeekGraphicWand(const DrawingWand *);
+ *DrawPeekGraphicWand(const DrawingWand *) magick_attribute((deprecated));
extern WandExport char
- *MagickDescribeImage(MagickWand *),
- *MagickGetImageAttribute(MagickWand *,const char *),
- *PixelIteratorGetException(const PixelIterator *,ExceptionType *);
+ *MagickDescribeImage(MagickWand *) magick_attribute((deprecated)),
+ *MagickGetImageAttribute(MagickWand *,const char *)
+ magick_attribute((deprecated)),
+ *PixelIteratorGetException(const PixelIterator *,ExceptionType *)
+ magick_attribute((deprecated));
extern WandExport long
- MagickGetImageIndex(MagickWand *);
+ MagickGetImageIndex(MagickWand *) magick_attribute((deprecated));
extern WandExport MagickBooleanType
- MagickClipPathImage(MagickWand *,const char *,const MagickBooleanType),
+ MagickClipPathImage(MagickWand *,const char *,const MagickBooleanType)
+ magick_attribute((deprecated)),
MagickColorFloodfillImage(MagickWand *,const PixelWand *,const double,
- const PixelWand *,const long,const long),
+ const PixelWand *,const long,const long) magick_attribute((deprecated)),
MagickGetImageChannelExtrema(MagickWand *,const ChannelType,unsigned long *,
- unsigned long *),
- MagickGetImageExtrema(MagickWand *,unsigned long *,unsigned long *),
- MagickGetImageMatte(MagickWand *),
+ unsigned long *) magick_attribute((deprecated)),
+ MagickGetImageExtrema(MagickWand *,unsigned long *,unsigned long *)
+ magick_attribute((deprecated)),
+ MagickGetImageMatte(MagickWand *) magick_attribute((deprecated)),
MagickGetImagePixels(MagickWand *,const long,const long,const unsigned long,
- const unsigned long,const char *,const StorageType,void *),
- MagickMapImage(MagickWand *,const MagickWand *,const MagickBooleanType),
+ const unsigned long,const char *,const StorageType,void *)
+ magick_attribute((deprecated)),
+ MagickMapImage(MagickWand *,const MagickWand *,const MagickBooleanType)
+ magick_attribute((deprecated)),
MagickMatteFloodfillImage(MagickWand *,const double,const double,
- const PixelWand *,const long,const long),
+ const PixelWand *,const long,const long) magick_attribute((deprecated)),
MagickOpaqueImage(MagickWand *,const PixelWand *,const PixelWand *,
- const double),
+ const double) magick_attribute((deprecated)),
MagickPaintFloodfillImage(MagickWand *,const ChannelType,const PixelWand *,
- const double,const PixelWand *,const long,const long),
+ const double,const PixelWand *,const long,const long)
+ magick_attribute((deprecated)),
MagickPaintOpaqueImage(MagickWand *,const PixelWand *,const PixelWand *,
- const double),
+ const double) magick_attribute((deprecated)),
MagickPaintOpaqueImageChannel(MagickWand *,const ChannelType,
- const PixelWand *,const PixelWand *,const double),
+ const PixelWand *,const PixelWand *,const double)
+ magick_attribute((deprecated)),
MagickPaintTransparentImage(MagickWand *,const PixelWand *,const double,
- const double),
- MagickSetImageAttribute(MagickWand *,const char *,const char *),
- MagickSetImageIndex(MagickWand *,const long),
- MagickSetImageOption(MagickWand *,const char *,const char *,const char *),
+ const double) magick_attribute((deprecated)),
+ MagickSetImageAttribute(MagickWand *,const char *,const char *)
+ magick_attribute((deprecated)),
+ MagickSetImageIndex(MagickWand *,const long) magick_attribute((deprecated)),
+ MagickSetImageOption(MagickWand *,const char *,const char *,const char *)
+ magick_attribute((deprecated)),
MagickSetImagePixels(MagickWand *,const long,const long,const unsigned long,
- const unsigned long,const char *,const StorageType,const void *),
+ const unsigned long,const char *,const StorageType,const void *)
+ magick_attribute((deprecated)),
MagickTransparentImage(MagickWand *,const PixelWand *,const double,
- const double);
+ const double) magick_attribute((deprecated));
extern WandExport MagickWand
- *MagickFlattenImages(MagickWand *),
- *MagickMosaicImages(MagickWand *),
+ *MagickFlattenImages(MagickWand *) magick_attribute((deprecated)),
+ *MagickMosaicImages(MagickWand *) magick_attribute((deprecated)),
*MagickRegionOfInterestImage(MagickWand *,const unsigned long,
- const unsigned long,const long,const long);
+ const unsigned long,const long,const long) magick_attribute((deprecated));
extern WandExport MagickSizeType
- MagickGetImageSize(MagickWand *);
+ MagickGetImageSize(MagickWand *) magick_attribute((deprecated));
extern WandExport PixelWand
- **PixelGetNextRow(PixelIterator *);
+ **PixelGetNextRow(PixelIterator *) magick_attribute((deprecated));
extern WandExport unsigned char
- *MagickWriteImageBlob(MagickWand *,size_t *);
+ *MagickWriteImageBlob(MagickWand *,size_t *) magick_attribute((deprecated));
extern WandExport void
- DrawPopGraphicContext(DrawingWand *),
- DrawPushGraphicContext(DrawingWand *),
- DrawSetFillAlpha(DrawingWand *,const double),
- DrawSetStrokeAlpha(DrawingWand *,const double);
+ DrawPopGraphicContext(DrawingWand *) magick_attribute((deprecated)),
+ DrawPushGraphicContext(DrawingWand *) magick_attribute((deprecated)),
+ DrawSetFillAlpha(DrawingWand *,const double) magick_attribute((deprecated)),
+ DrawSetStrokeAlpha(DrawingWand *,const double) magick_attribute((deprecated));
#endif
projects / imagemagick / commitdiff