void* magickminify(void* src, ssize_t src_len, ssize_t* dst_len){
Image *image, *resize;
ImageInfo image_info;
ExceptionInfo *exception;
size_t len;
void *ans;
GetImageInfo(&image_info);
exception = AcquireExceptionInfo();
image = BlobToImage(&image_info, src, src_len, exception);
if (exception->severity != UndefinedException)
CatchException(exception);
if (image == (Image *) NULL)
exit(1);
resize = MinifyImage(image, exception);
if (exception->severity != UndefinedException)
CatchException(exception);
if (image == (Image *) NULL)
exit(1);
ans = ImageToBlob(&image_info, resize, &len, exception);
if(dst_len != NULL)
*dst_len = len;
DestroyImage(image);
DestroyImage(resize);
DestroyExceptionInfo(exception);
return ans;
}
Image *get_image_from_path(char *path)
{
ImageInfo *image_info;
Image *img = NULL;
ExceptionInfo exception;
GetExceptionInfo(&exception);
if ((image_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(image_info);
DestroyImage(img);
return (NULL);
}
strcpy(image_info->filename, path);
if ((img = ReadImage(image_info, &exception)) == NULL)
{
CatchException(&exception);
DestroyImageInfo(image_info);
DestroyImage(img);
return (NULL);
}
DestroyImageInfo(image_info);
return (img);
}
/*----------------------------------------------------------------------- */
SEXP
lib_writeImages (SEXP x, SEXP files, SEXP quality) {
int nz, nfiles, i;
Image * images, * image;
ImageInfo *image_info;
ExceptionInfo exception;
/* basic checks */
validImage(x,0);
images = sexp2Magick (x);
nz = GetImageListLength(images);
nfiles = LENGTH (files);
if ( nfiles != 1 && nfiles != nz)
error ( "number of files must be 1, or equal to the size of the image stack" );
if ( images == NULL || GetImageListLength (images) < 1 )
error ( "cannot write an empty image" );
GetExceptionInfo (&exception);
image_info = CloneImageInfo ( (ImageInfo *)NULL );
/* set attributes in image_info*/
image_info->compression = images->compression;
image_info->quality = (unsigned int) INTEGER (quality)[0];
if ( nfiles == 1 ) {
/* save into a single file, TIFF, GIF, or automatically add file suffixes */
strcpy (image_info->filename, CHAR(STRING_ELT(files, 0)) );
/* we want to overwrite the feature imported from SEXP image */
strcpy (images->filename, image_info->filename);
WriteImages(image_info, images, CHAR(STRING_ELT(files, 0)), &exception);
CatchException (&exception);
}
else {
/* save each frame into a separate file */
for ( i = 0; i < nz; i++ ) {
image = GetImageFromList (images, i);
if ( image == NULL || GetImageListLength (image) < 1 ) {
warning ( "cannot write an empty image, skipping" );
continue;
}
strcpy (image_info->filename, CHAR(STRING_ELT(files, i)));
/* we want to overwrite the feature imported from SEXP image */
strcpy (image->filename, image_info->filename);
WriteImage (image_info, image);
CatchException (&image->exception);
// WriteImages(image_info, image, CHAR(STRING_ELT(files, i)), &exception);
// CatchException (&exception);
}
}
image_info = DestroyImageInfo (image_info);
images = DestroyImageList (images);
DestroyExceptionInfo(&exception);
return R_NilValue;
}
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 *crop_image(Image *img, char *path, int image_width, int image_height, int width_offset, int height_offset)
{
Image *new_img = NULL;
ImageInfo *image_info;
Image *tmp;
RectangleInfo *portion;
ExceptionInfo exception;
portion = malloc(sizeof(*portion));
portion->width = image_width;
portion->height = image_height;
portion->x = width_offset;
portion->y = height_offset;
GetExceptionInfo(&exception);
if ((image_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(image_info);
free(portion);
return (NULL);
}
strcpy(image_info->filename, path);
if ((new_img = ReadImage(image_info, &exception)) == NULL)
{
CatchException(&exception);
DestroyImage(new_img);
DestroyImageInfo(image_info);
free(portion);
return (NULL);
}
tmp = new_img;
if ((new_img = CropImage(img, portion, &exception)) == NULL) {
CatchException(&exception);
DestroyImage(tmp);
DestroyImageInfo(image_info);
free(portion);
return (NULL);
}
DestroyImage(img);
DestroyImage(tmp);
DestroyImageInfo(image_info);
free(portion);
SyncImagePixels(new_img);
free(path);
return (new_img);
}
bool ScImgDataLoader_GMagick::preloadAlphaChannel(const QString& fn, int /*page*/, int res, bool& hasAlpha)
{
initGraphicsMagick();
initialize();
hasAlpha = false;
if (!QFile::exists(fn))
return false;
ExceptionInfo exception;
GetExceptionInfo(&exception);
ImageInfo *image_info = CloneImageInfo(0);
strcpy(image_info->filename, fn.toUtf8().data());
image_info->units = PixelsPerInchResolution;
Image *image = PingImage(image_info, &exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (!image) {
qCritical() << "Failed to read image" << fn;
return false;
}
hasAlpha = image->matte;
if (!hasAlpha) return true;
return loadPicture(fn, 0, 0, false);
}
static
ERL_NIF_TERM exmagick_image_load_blob (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary blob;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (0 == enif_inspect_binary(env, argv[1], &blob))
{ EXM_FAIL(ehandler, "argv[1]: bad argument"); }
if (resource->image != NULL)
{
DestroyImage(resource->image);
resource->image = NULL;
}
resource->image = BlobToImage(resource->i_info, blob.data, blob.size, &resource->e_info);
if (resource->image == NULL)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static
ERL_NIF_TERM exmagick_image_dump_file (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
char filename[MaxTextExtent];
ErlNifBinary utf8;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (0 == exmagick_get_utf8str(env, argv[1], &utf8))
{ EXM_FAIL(ehandler, "argv[1]: bad argument"); }
exmagick_utf8strcpy (filename, &utf8, MaxTextExtent);
if (0 == WriteImages(resource->i_info, resource->image, filename, &resource->e_info))
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static
ERL_NIF_TERM exmagick_image_dump_blob (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
void *blob;
size_t size;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
blob = ImageToBlob(resource->i_info, resource->image, &size, &resource->e_info);
if (NULL == blob)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
return(enif_make_tuple2(env,
enif_make_atom(env, "ok"),
enif_make_resource_binary(env, resource, blob, size)));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
void ScImgDataLoader_GMagick::loadEmbeddedProfile(const QString& fn, int /*page*/)
{
initGraphicsMagick();
m_embeddedProfile.resize(0);
m_profileComponents = 0;
if (!QFile::exists(fn)) return;
ExceptionInfo exception;
GetExceptionInfo(&exception);
ImageInfo *image_info = CloneImageInfo(0);
strcpy(image_info->filename, fn.toUtf8().data());
image_info->units = PixelsPerInchResolution;
Image *image = ReadImage(image_info, &exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (!image) {
qCritical() << "Failed to read image" << fn;
return;
}
size_t length = 0;
const unsigned char *src = GetImageProfile(image, "ICM", &length);
char *dest = m_embeddedProfile.data();
if (image->colorspace == CMYKColorspace) {
m_profileComponents = 4;
} else if (image->colorspace == RGBColorspace) {
m_profileComponents = 3;
}
m_embeddedProfile.resize(length);
memcpy(dest, src, length);
}
int main ( int argc, char **argv )
{
Image *canvas = (Image *)NULL;
char outfile[MaxTextExtent];
int rows, columns = 0;
char size[MaxTextExtent];
ImageInfo *image_info;
ExceptionInfo exception;
if ( argc != 2 )
{
(void) printf ( "Usage: %s filename\n", argv[0] );
exit( 1 );
}
outfile[MaxTextExtent-1]='\0';
(void) strncpy( outfile, argv[1], MaxTextExtent-1 );
if (LocaleNCompare("drawtest",argv[0],7) == 0)
InitializeMagick((char *) NULL);
else
InitializeMagick(*argv);
/*
* Create canvas image
*/
columns=596;
rows=842;
image_info=CloneImageInfo((ImageInfo*)NULL);
GetExceptionInfo( &exception );
FormatString(size, "%dx%d", columns, rows);
(void) CloneString(&image_info->size, size);
(void) strcpy( image_info->filename, "xc:white");
canvas = ReadImage ( image_info, &exception );
if (exception.severity != UndefinedException)
CatchException(&exception);
if ( canvas == (Image *)NULL )
{
(void) printf ( "Failed to read canvas image %s\n", image_info->filename );
exit(1);
}
/*
* Scribble on image
*/
ScribbleImage( canvas );
/*
* Save image to file
*/
canvas->filename[MaxTextExtent-1]='\0';
(void) strncpy( canvas->filename, outfile, MaxTextExtent-1);
(void) WriteImage ( image_info, canvas );
DestroyExceptionInfo( &exception );
DestroyImage( canvas );
DestroyImageInfo( image_info );
DestroyMagick();
return 0;
}
bool ScImgDataLoader_GMagick::readCMYK(Image *input, RawImage *output, int width, int height)
{
/* Mapping:
red: cyan
green: magenta
blue: yellow
opacity: black
index: alpha
*/
//Copied from GraphicsMagick header and modified
#define GetCyanSample(p) (p.red)
#define GetMagentaSample(p) (p.green)
#define GetYellowSample(p) (p.blue)
#define GetCMYKBlackSample(p) (p.opacity)
#define GetAlphaSample(p) (p)
bool hasAlpha = input->matte;
if (!output->create(width, height, hasAlpha ? 5 : 4)) return false;
ExceptionInfo exception;
GetExceptionInfo(&exception);
const PixelPacket *pixels = AcquireImagePixels(input, 0, 0, width, height, &exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (!pixels) {
qCritical() << QObject::tr("Could not get pixel data!");
return false;
}
const IndexPacket *alpha = 0;
if (hasAlpha) {
alpha = AccessImmutableIndexes(input);
if (!alpha) {
qCritical() << QObject::tr("Could not get alpha channel data!");
return false;
}
}
unsigned char *buffer = output->bits();
if (!buffer) {
qCritical() << QObject::tr("Could not allocate output buffer!");
return false;
}
int i;
for (i = 0; i < width*height; i++) {
*buffer++ = ScaleQuantumToChar(GetCyanSample(pixels[i]));
*buffer++ = ScaleQuantumToChar(GetMagentaSample(pixels[i]));
*buffer++ = ScaleQuantumToChar(GetYellowSample(pixels[i]));
*buffer++ = ScaleQuantumToChar(GetCMYKBlackSample(pixels[i]));
if (hasAlpha) {
*buffer++ = 255 - ScaleQuantumToChar(GetAlphaSample(alpha[i]));
}
}
return true;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% V a l i d a t e I d e n t i f y C o m m a n d %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ValidateIdentifyCommand() validates the ImageMagick identify command line
% program and returns the number of validation tests that passed and failed.
%
% The format of the ValidateIdentifyCommand method is:
%
% unsigned long ValidateIdentifyCommand(ImageInfo *image_info,
% const char *reference_filename,const char *output_filename,
% unsigned long *fail,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o reference_filename: the reference image filename.
%
% o output_filename: the output image filename.
%
% o fail: return the number of validation tests that pass.
%
% o exception: return any errors or warnings in this structure.
%
*/
static unsigned long ValidateIdentifyCommand(ImageInfo *image_info,
const char *reference_filename,const char *output_filename,
unsigned long *fail,ExceptionInfo *exception)
{
char
**arguments,
command[MaxTextExtent];
int
number_arguments;
MagickBooleanType
status;
register long
i,
j;
unsigned long
test;
(void) output_filename;
test=0;
(void) fprintf(stdout,"validate identify command line program:\n");
for (i=0; identify_options[i] != (char *) NULL; i++)
{
CatchException(exception);
(void) fprintf(stdout," test %lu: %s",test++,identify_options[i]);
(void) FormatMagickString(command,MaxTextExtent,"%s %s",
identify_options[i],reference_filename);
arguments=StringToArgv(command,&number_arguments);
if (arguments == (char **) NULL)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
status=IdentifyImageCommand(image_info,number_arguments,arguments,
(char **) NULL,exception);
for (j=0; j < number_arguments; j++)
arguments[j]=DestroyString(arguments[j]);
arguments=(char **) RelinquishMagickMemory(arguments);
if (status != MagickFalse)
{
(void) fprintf(stdout,"... fail @ %s/%s/%lu.\n",GetMagickModule());
(*fail)++;
continue;
}
(void) fprintf(stdout,"... pass.\n");
}
(void) fprintf(stdout," summary: %lu subtests; %lu passed; %lu failed.\n",
test,test-(*fail),*fail);
return(test);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% M a i n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
int main(int argc,char **argv)
{
char
*option,
*text;
ExceptionInfo
*exception;
ImageInfo
*image_info;
MagickBooleanType
regard_warnings,
status;
register long
i;
MagickCoreGenesis(*argv,MagickTrue);
exception=AcquireExceptionInfo();
regard_warnings=MagickFalse;
for (i=1; i < (long) argc; i++)
{
option=argv[i];
if ((strlen(option) == 1) || ((*option != '-') && (*option != '+')))
continue;
if (LocaleCompare("debug",option+1) == 0)
(void) SetLogEventMask(argv[++i]);
if (LocaleCompare("regard-warnings",option+1) == 0)
regard_warnings=MagickTrue;
}
image_info=AcquireImageInfo();
text=(char *) NULL;
status=CompareImageCommand(image_info,argc,argv,&text,exception);
if ((status == MagickFalse) || (exception->severity != UndefinedException))
{
if ((exception->severity < ErrorException) &&
(regard_warnings == MagickFalse))
status=MagickTrue;
CatchException(exception);
}
if (text != (char *) NULL)
{
(void) fputs(text,stdout);
(void) fputc('\n',stdout);
text=DestroyString(text);
}
image_info=DestroyImageInfo(image_info);
exception=DestroyExceptionInfo(exception);
MagickCoreTerminus();
return(status == MagickFalse ? 1 : 0);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% M a i n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
int main(int argc,char **argv)
{
char
*option,
*text;
ExceptionInfo
exception;
ImageInfo
*image_info;
MagickBooleanType
status;
register long
i;
InitializeMagick(*argv);
GetExceptionInfo(&exception);
for (i=1; i < (long) argc; i++)
{
option=argv[i];
if ((strlen(option) == 1) || ((*option != '-') && (*option != '+')))
continue;
if ((LocaleCompare("debug",option+1) == 0) && (i < (long) (argc-1)))
(void) SetLogEventMask(argv[++i]);
if (LocaleCompare("version",option+1) == 0)
{
(void) fprintf(stdout,"Version: %s\n",
GetMagickVersion((unsigned long *) NULL));
(void) fprintf(stdout,"Copyright: %s\n\n",GetMagickCopyright());
exit(0);
}
}
image_info=CloneImageInfo((ImageInfo *) NULL);
text=(char *) NULL;
status=IdentifyImageCommand(image_info,argc,argv,&text,&exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (text != (char *) NULL)
{
(void) fputs(text,stdout);
(void) fputc('\n',stdout);
text=(char *) RelinquishMagickMemory(text);
}
image_info=DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
exit(!status);
return(MagickFalse);
}
Int ConsoleApplication::Run()
{
auto xc = CatchException( [ this ] { return this->Main(); } );
if ( xc )
{
TraceError( xc.TracingMessage() );
std::cout << std::endl
<< "Program caught an exception and exit abnormally." << std::endl;
std::cin.get();
}
return xc.Result();
}
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);
}
Image *crop_image_from_path(char *path, RectangleInfo *portion)
{
ImageInfo *image_info;
Image *img;
Image *tmp;
ExceptionInfo exception;
GetExceptionInfo(&exception);
if ((image_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(image_info);
return (NULL);
}
strcpy(image_info->filename, path);
if ((img = ReadImage(image_info, &exception)) == NULL)
{
CatchException(&exception);
DestroyImageInfo(image_info);
return (NULL);
}
tmp = img;
if ((img = CropImage(img, portion, &exception)) == NULL) {
CatchException(&exception);
DestroyImage(tmp);
DestroyImageInfo(image_info);
return (NULL);
}
DestroyImage(tmp);
DestroyImageInfo(image_info);
return (img);
}
static unsigned int
ngx_http_graphicsmagick_convert(char **argv, size_t argc)
{
// GraphicsMagick stuff
ngx_uint_t i;
char *option;
ExceptionInfo exception;
ImageInfo *image_info;
MagickBool regard_warnings, status;
// DO GraphicsMagick converting
InitializeMagick((char *) NULL);
GetExceptionInfo(&exception);
regard_warnings = 0;
for (i = 1; i < argc; i++) {
option = argv[i];
if ((ngx_strlen(option) == 1) || ((*option != '-') && (*option != '+'))) {
continue;
}
if (LocaleCompare("debug", option + 1) == 0) {
(void) SetLogEventMask(argv[++i]);
}
if (LocaleCompare("regard-warnings",option+1) == 0) {
regard_warnings = MagickTrue;
}
}
image_info = CloneImageInfo(0);
status = ConvertImageCommand(image_info, argc, argv, NULL, &exception);
if ((status == MagickFalse) || (exception.severity != UndefinedException)) {
if ((exception.severity < ErrorException) && (regard_warnings == MagickFalse)) {
status = MagickTrue;
}
CatchException(&exception);
}
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
return status;
}
static
ERL_NIF_TERM exmagick_crop (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
Image* cropped_image;
RectangleInfo rect;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (resource->image == NULL)
{ EXM_FAIL(ehandler, "image not loaded"); }
/* build rectangle */
if (0 == enif_get_long(env, argv[1], &rect.x))
{ EXM_FAIL(ehandler, "x0: bad argument"); }
if (0 == enif_get_long(env, argv[2], &rect.y))
{ EXM_FAIL(ehandler, "y0: bad argument"); }
if (0 == enif_get_ulong(env, argv[3], &rect.width))
{ EXM_FAIL(ehandler, "width: bad argument"); }
if (0 == enif_get_ulong(env, argv[4], &rect.height))
{ EXM_FAIL(ehandler, "height: bad argument"); }
/* actually crops image */
cropped_image = CropImage(resource->image, &rect, &resource->e_info);
if (cropped_image == NULL)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
DestroyImage(resource->image);
resource->image = cropped_image;
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
int dump_multi_image(Image *img, char *root_path, char *name, char *image_type)
{
char *final_path;
ImageInfo *image_info;
ExceptionInfo exception;
GetExceptionInfo(&exception);
if ((image_info = CloneImageInfo((ImageInfo *)NULL)) == NULL) {
CatchException(&exception);
DestroyImageInfo(image_info);
return -1;
}
asprintf(&final_path, "%s/%s.%s", root_path, name, image_type);
strcpy(img->filename, final_path);
WriteImage(image_info, img);
free(final_path);
return (0);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ C L I C a t c h E x c e p t i o n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CLICatchException() will report exceptions, either just non-fatal warnings
% only, or all errors, according to 'all_execeptions' boolean argument.
%
% The function returns true if errors are fatal, in which case the caller
% should abort and re-call with an 'all_exceptions' argument of true before
% quitting.
%
% The cut-off level between fatal and non-fatal may be controlled by options
% (FUTURE), but defaults to 'Error' exceptions.
%
% The format of the CLICatchException method is:
%
% MagickBooleanType CLICatchException(MagickCLI *cli_wand,
% const MagickBooleanType all_exceptions );
%
% Arguments are
%
% o cli_wand: The Wand CLI that holds the exception Information
%
% o all_exceptions: Report all exceptions, including the fatal one
%
*/
WandExport MagickBooleanType CLICatchException(MagickCLI *cli_wand,
const MagickBooleanType all_exceptions )
{
MagickBooleanType
status;
assert(cli_wand != (MagickCLI *) NULL);
assert(cli_wand->signature == WandSignature);
assert(cli_wand->wand.signature == WandSignature);
if (IfMagickTrue(cli_wand->wand.debug))
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",cli_wand->wand.name);
// FUTURE: '-regard_warning' should make this more sensitive.
// Note pipelined options may like more control over this level
status = IsMagickTrue(cli_wand->wand.exception->severity > ErrorException);
if ( IfMagickFalse(status) || IfMagickTrue(all_exceptions) )
CatchException(cli_wand->wand.exception); /* output and clear exceptions */
return(status);
}
bool ScImgDataLoader_GMagick::readRGB(Image *input, QImage *output, int width, int height)
{
bool hasAlpha = input->matte;
ExceptionInfo exception;
GetExceptionInfo(&exception);
const PixelPacket *pixels = AcquireImagePixels(input, 0, 0, width, height, &exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (!pixels) {
qCritical() << QObject::tr("Could not get pixel data!");
return false;
}
unsigned char *buffer = output->bits();
if (!buffer) {
qCritical() << QObject::tr("Could not allocate output buffer!");
return false;
}
QRgb *s = (QRgb*)(output->scanLine(0));
int i;
for (i = 0; i < width*height; i++)
{
unsigned char b = ScaleQuantumToChar(pixels[i].blue);
unsigned char g = ScaleQuantumToChar(pixels[i].green);
unsigned char r = ScaleQuantumToChar(pixels[i].red);
unsigned char a;
if (hasAlpha)
a = 255 - ScaleQuantumToChar(pixels[i].opacity);
else
a = 255;
*s = qRgba(r, g, b, a);
s++;
}
return true;
}
static
ERL_NIF_TERM exmagick_image_thumb (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
long width, height;
Image* thumb;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (resource->image == NULL)
{ EXM_FAIL(ehandler, "image not loaded"); }
if (0 == enif_get_long(env, argv[1], &width))
{ EXM_FAIL(ehandler, "width: bad argument"); }
if (0 == enif_get_long(env, argv[2], &height))
{ EXM_FAIL(ehandler, "height: bad argument"); }
thumb = ThumbnailImage(resource->image, width, height, &resource->e_info);
if (thumb == NULL)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
DestroyImage(resource->image);
resource->image = thumb;
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static int load_images(LogoPrivateData *pd)
{
Image *timg;
Image *nimg;
pd->images = GetFirstImageInList(pd->magick.image);
nimg = NewImageList();
while (pd->images != (Image *)NULL) {
if (pd->flip) {
timg = FlipImage(pd->images,
&pd->magick.exception_info);
if (timg == NULL) {
CatchException(&pd->magick.exception_info);
return TC_ERROR;
}
AppendImageToList(&nimg, timg);
}
pd->images = GetNextImageInList(pd->images);
pd->nr_of_images++;
}
// check for memleaks;
//DestroyImageList(image);
if (pd->flip) {
/* DANGEROUS!!! */
pd->magick.image = nimg;
}
/* for running through image sequence */
/* DANGEROUS!!! */
pd->images = pd->magick.image;
return TC_OK;
}
WandExport MagickBooleanType ConjureImageCommand(ImageInfo *image_info,
int argc,char **argv,char **wand_unused(metadata),ExceptionInfo *exception)
{
#define DestroyConjure() \
{ \
image=DestroyImageList(image); \
for (i=0; i < (ssize_t) argc; i++) \
argv[i]=DestroyString(argv[i]); \
argv=(char **) RelinquishMagickMemory(argv); \
}
#define ThrowConjureException(asperity,tag,option) \
{ \
(void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"'%s'", \
option); \
DestroyConjure(); \
return(MagickFalse); \
}
#define ThrowConjureInvalidArgumentException(option,argument) \
{ \
(void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
"InvalidArgument","'%s': %s",option,argument); \
DestroyConjure(); \
return(MagickFalse); \
}
char
filename[MaxTextExtent],
*option;
Image
*image;
MagickStatusType
status;
register ssize_t
i;
ssize_t
number_images;
/*
Set defaults.
*/
assert(image_info != (ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(exception != (ExceptionInfo *) NULL);
if (argc < 2)
return(ConjureUsage());
image=NewImageList();
number_images=0;
option=(char *) NULL;
/*
Conjure an image.
*/
ReadCommandlLine(argc,&argv);
status=ExpandFilenames(&argc,&argv);
if (status == MagickFalse)
ThrowConjureException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
for (i=1; i < (ssize_t) argc; i++)
{
option=argv[i];
if (IsCommandOption(option) != MagickFalse)
{
if (LocaleCompare("concurrent",option+1) == 0)
break;
if (LocaleCompare("debug",option+1) == 0)
{
ssize_t
event;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowConjureException(OptionError,"MissingArgument",option);
event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
if (event < 0)
ThrowConjureException(OptionError,"UnrecognizedEventType",
argv[i]);
(void) SetLogEventMask(argv[i]);
continue;
}
if (LocaleCompare("duration",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowConjureException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowConjureInvalidArgumentException(option,argv[i]);
continue;
}
if ((LocaleCompare("help",option+1) == 0) ||
(LocaleCompare("-help",option+1) == 0))
{
if (*option == '-')
return(ConjureUsage());
continue;
}
if (LocaleCompare("log",option+1) == 0)
{
if (*option == '-')
{
i++;
if (i == (ssize_t) argc)
ThrowConjureException(OptionError,"MissingLogFormat",option);
(void) SetLogFormat(argv[i]);
}
continue;
}
if (LocaleCompare("monitor",option+1) == 0)
continue;
if (LocaleCompare("quiet",option+1) == 0)
continue;
if (LocaleCompare("regard-warnings",option+1) == 0)
break;
if (LocaleCompare("seed",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowConjureException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowConjureInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("verbose",option+1) == 0)
{
image_info->verbose=(*option == '-') ? MagickTrue : MagickFalse;
continue;
}
if ((LocaleCompare("version",option+1) == 0) ||
(LocaleCompare("-version",option+1) == 0))
{
(void) FormatLocaleFile(stdout,"Version: %s\n",
GetMagickVersion((size_t *) NULL));
(void) FormatLocaleFile(stdout,"Copyright: %s\n",
GetMagickCopyright());
(void) FormatLocaleFile(stdout,"Features: %s\n\n",
GetMagickFeatures());
return(MagickFalse);
}
/*
Persist key/value pair.
*/
(void) DeleteImageOption(image_info,option+1);
status=SetImageOption(image_info,option+1,argv[i+1]);
if (status == MagickFalse)
ThrowConjureException(ImageError,"UnableToPersistKey",option);
i++;
continue;
}
/*
Interpret MSL script.
*/
(void) DeleteImageOption(image_info,"filename");
status=SetImageOption(image_info,"filename",argv[i]);
if (status == MagickFalse)
ThrowConjureException(ImageError,"UnableToPersistKey",argv[i]);
(void) FormatLocaleString(filename,MaxTextExtent,"msl:%s",argv[i]);
image=ReadImages(image_info,filename,exception);
CatchException(exception);
if (image != (Image *) NULL)
image=DestroyImageList(image);
status=image != (Image *) NULL ? MagickTrue : MagickFalse;
number_images++;
}
if (i != (ssize_t) argc)
ThrowConjureException(OptionError,"MissingAnImageFilename",argv[i]);
if (number_images == 0)
ThrowConjureException(OptionError,"MissingAnImageFilename",argv[argc-1]);
if (image != (Image *) NULL)
image=DestroyImageList(image);
for (i=0; i < (ssize_t) argc; i++)
argv[i]=DestroyString(argv[i]);
argv=(char **) RelinquishMagickMemory(argv);
return(status != 0 ? MagickTrue : MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d X T R N I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadXTRNImage() reads a XTRN 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 ReadXTRNImage method is:
%
% Image *ReadXTRNImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: Specifies a pointer to an ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadXTRNImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
ImageInfo
*clone_info;
void
*param1,
*param2,
*param3;
param1 = param2 = param3 = (void *) NULL;
image = (Image *) NULL;
clone_info=CloneImageInfo(image_info);
if (clone_info->filename == NULL)
{
clone_info=DestroyImageInfo(clone_info);
ThrowReaderException(FileOpenWarning,"No filename specified");
}
if (LocaleCompare(image_info->magick,"XTRNFILE") == 0)
{
image=ReadImage(clone_info,exception);
CatchException(exception);
}
else if (LocaleCompare(image_info->magick,"XTRNIMAGE") == 0)
{
Image
**image_ptr;
#ifdef ALL_IMAGEINFO
ImageInfo
**image_info_ptr;
#endif
(void) sscanf(clone_info->filename,"%lx,%lx",¶m1,¶m2);
image_ptr=(Image **) param2;
if (*image_ptr != (Image *)NULL)
image=CloneImage(*image_ptr,0,0,MagickFalse,&(*image_ptr)->exception);
#ifdef ALL_IMAGEINFO
image_info_ptr=(ImageInfo **) param1;
if (*image_info_ptr != (ImageInfo *)NULL)
image_info=*image_info_ptr;
#endif
}
else if (LocaleCompare(image_info->magick,"XTRNBLOB") == 0)
{
char
**blob_data;
size_t
*blob_length;
char
filename[MaxTextExtent];
(void) sscanf(clone_info->filename,"%lx,%lx,%s",¶m1,¶m2,&filename);
blob_data=(char **) param1;
blob_length=(size_t *) param2;
image=BlobToImage(clone_info,*blob_data,*blob_length,exception);
CatchException(exception);
}
else if (LocaleCompare(image_info->magick,"XTRNSTREAM") == 0)
{
#ifdef IMPLEMENT_THIS
MagickBooleanType
status;
#endif
char
filename[MaxTextExtent];
size_t
(*fifo)(const Image *,const void *,const size_t);
(void) sscanf(clone_info->filename,"%lx,%lx,%s",¶m1,¶m2,&filename);
fifo=(size_t (*)(const Image *,const void *,const size_t)) param1;
clone_info->client_data=param2;
#ifdef IMPLEMENT_THIS
status=ReadStream(clone_info,fifo,exception);
CatchException(exception);
#endif
}
else if (LocaleCompare(image_info->magick,"XTRNARRAY") == 0)
{
SAFEARRAY
*pSafeArray;
char
*blob_data;
size_t
blob_length;
long
lBoundl,
lBoundu;
HRESULT
hr;
char
filename[MaxTextExtent];
filename[0] = '\0';
(void) sscanf(clone_info->filename,"%lx,%s",¶m1,&filename);
hr = S_OK;
pSafeArray = (SAFEARRAY *) param1;
if (pSafeArray)
{
hr = SafeArrayGetLBound(pSafeArray, 1, &lBoundl);
if (SUCCEEDED(hr))
hr = SafeArrayGetUBound(pSafeArray, 1, &lBoundu);
if (SUCCEEDED(hr))
{
blob_length = lBoundu - lBoundl + 1;
hr = SafeArrayAccessData(pSafeArray, (void**)&blob_data);
if(SUCCEEDED(hr))
{
if (filename[0] != '\0')
{
(void) CopyMagickString(clone_info->filename,filename,
MaxTextExtent);
(void) CopyMagickString(clone_info->magick,filename,
MaxTextExtent);
}
else
{
*clone_info->magick = '\0';
clone_info->filename[0] = '\0';
}
image=BlobToImage(clone_info,blob_data,blob_length,exception);
hr = SafeArrayUnaccessData(pSafeArray);
CatchException(exception);
}
}
}
}
else if (LocaleCompare(image_info->magick,"XTRNBSTR") == 0)
{
BSTR
bstr;
char
*blob_data;
size_t
blob_length;
HRESULT
hr;
char
filename[MaxTextExtent];
filename[0] = '\0';
(void) sscanf(clone_info->filename,"%lx,%s",¶m1,&filename);
hr = S_OK;
bstr = (BSTR) param1;
blob_length = SysStringLen(bstr) * 2;
blob_data = (char *)bstr;
if ((blob_data != (char *)NULL) && (blob_length>0))
{
if (filename[0] != '\0')
{
(void) CopyMagickString(clone_info->filename,filename,
MaxTextExtent);
(void) CopyMagickString(clone_info->magick,filename,
MaxTextExtent);
}
else
{
*clone_info->magick = '\0';
clone_info->filename[0] = '\0';
}
image=BlobToImage(clone_info,blob_data,blob_length,exception);
CatchException(exception);
}
}
clone_info=DestroyImageInfo(clone_info);
return(image);
}
std::string
imageproc::ChangeImage(const std::string & inPath,
const std::string & tmpDir,
Type outputFormat,
const bp::List & transformations,
int quality,
unsigned int & x, unsigned int & y,
unsigned int & orig_x, unsigned int & orig_y,
std::string & oError)
{
ExceptionInfo exception;
Image *images;
ImageInfo *image_info;
orig_x = orig_y = x = y = 0;
GetExceptionInfo(&exception);
image_info = CloneImageInfo((ImageInfo *) NULL);
// first we read the image
if (exception.severity != UndefinedException)
{
if (exception.reason)
g_bpCoreFunctions->log(BP_ERROR, "after: %s\n",
exception.reason);
if (exception.description)
g_bpCoreFunctions->log(BP_ERROR, "after: %s\n",
exception.description);
CatchException(&exception);
}
(void) strcpy(image_info->filename, inPath.c_str());
images = IP_ReadImageFile(image_info, inPath, &exception);
if (exception.severity != UndefinedException)
{
if (exception.reason)
g_bpCoreFunctions->log(BP_ERROR, "after: %s\n",
exception.reason);
if (exception.description)
g_bpCoreFunctions->log(BP_ERROR, "after: %s\n",
exception.description);
CatchException(&exception);
}
if (!images)
{
oError.append("couldn't read image");
DestroyImageInfo(image_info);
image_info = NULL;
DestroyExceptionInfo(&exception);
return std::string();
}
g_bpCoreFunctions->log(
BP_INFO, "Image contains %lu frames, type: %s\n",
GetImageListLength(images),
images->magick);
// set quality
if (quality > 100) quality = 100;
if (quality < 0) quality = 0;
image_info->quality = quality;
g_bpCoreFunctions->log(
BP_INFO, "Quality set to %d (0-100, worst-best)", quality);
// execute 'actions'
images = runTransformations(images, transformations, quality, oError);
// was all that successful?
if (!images)
{
DestroyImageInfo(image_info);
image_info = NULL;
DestroyExceptionInfo(&exception);
return std::string();
}
// set the output size
orig_x = images->magick_columns;
orig_y = images->magick_rows;
x = images->columns;
y = images->rows;
// let's set the output format correctly (default to input format)
std::string name;
if (outputFormat == UNKNOWN) name.append(ft::basename(inPath));
else {
name.append("img.");
name.append(typeToExt(outputFormat));
(void) sprintf(images->magick, outputFormat);
g_bpCoreFunctions->log(BP_INFO, "Output to format: %s", outputFormat);
}
// Now let's go directly from blob to file. We bypass
// GM to-file functions so that we can handle wide filenames
// safely on win32 systems. A superior solution would
// be to use GM stream facilities (if they exist)
// upon success, will hold path to output file and will be returned to
// client
std::string rv;
{
size_t l = 0;
void * blob = NULL;
blob = ImageToBlob( image_info, images, &l, &exception );
if (exception.severity != UndefinedException)
{
oError.append("ImageToBlob failed.");
CatchException(&exception);
}
else
{
g_bpCoreFunctions->log(BP_INFO, "Writing %lu bytes to %s",
l, name.c_str());
if (!ft::mkdir(tmpDir, false)) {
oError.append("Couldn't create temp dir");
} else {
std::string outpath = ft::getPath(tmpDir, name);
FILE * f = ft::fopen_binary_write(outpath);
if (f == NULL) {
g_bpCoreFunctions->log(
BP_ERROR, "Couldn't open '%s' for writing!",
outpath.c_str());
oError.append("Error saving output image");
} else {
size_t wt;
wt = fwrite(blob, sizeof(char), l, f);
fclose(f);
if (wt != l) {
g_bpCoreFunctions->log(
BP_ERROR,
"Partial write (%lu/%lu) when writing resultant "
"image '%s'",
wt, l, outpath.c_str());
oError.append("Error saving output image");
} else {
// success!
rv = outpath;
}
}
}
}
}
DestroyImage(images);
DestroyImageInfo(image_info);
image_info = NULL;
DestroyExceptionInfo(&exception);
return rv;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d V I D I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadVIDImage reads one of more images and creates a Visual Image
% Directory file. It allocates the memory necessary for the new Image
% structure and returns a pointer to the new image.
%
% The format of the ReadVIDImage method is:
%
% Image *ReadVIDImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadVIDImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
#define ClientName "montage"
char
**filelist,
*label;
Image
*image,
*images,
*montage_image,
*next_image,
*thumbnail_image;
ImageInfo
*read_info;
int
number_files;
MagickBooleanType
status;
MontageInfo
*montage_info;
RectangleInfo
geometry;
register ssize_t
i;
/*
Expand the filename.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
filelist=(char **) AcquireAlignedMemory(1,sizeof(*filelist));
if (filelist == (char **) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
filelist[0]=ConstantString(image_info->filename);
number_files=1;
status=ExpandFilenames(&number_files,&filelist);
if ((status == MagickFalse) || (number_files == 0))
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
image=DestroyImage(image);
/*
Read each image and convert them to a tile.
*/
images=NewImageList();
read_info=CloneImageInfo(image_info);
SetImageInfoBlob(read_info,(void *) NULL,0);
(void) SetImageInfoProgressMonitor(read_info,(MagickProgressMonitor) NULL,
(void *) NULL);
if (read_info->size == (char *) NULL)
(void) CloneString(&read_info->size,DefaultTileGeometry);
for (i=0; i < (ssize_t) number_files; i++)
{
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"name: %s",
filelist[i]);
(void) CopyMagickString(read_info->filename,filelist[i],MaxTextExtent);
filelist[i]=DestroyString(filelist[i]);
*read_info->magick='\0';
next_image=ReadImage(read_info,exception);
CatchException(exception);
if (next_image == (Image *) NULL)
break;
label=InterpretImageProperties(image_info,next_image,DefaultTileLabel);
(void) SetImageProperty(next_image,"label",label);
label=DestroyString(label);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"geometry: %.20gx%.20g",(double) next_image->columns,(double)
next_image->rows);
SetGeometry(next_image,&geometry);
(void) ParseMetaGeometry(read_info->size,&geometry.x,&geometry.y,
&geometry.width,&geometry.height);
thumbnail_image=ThumbnailImage(next_image,geometry.width,geometry.height,
exception);
if (thumbnail_image != (Image *) NULL)
{
next_image=DestroyImage(next_image);
next_image=thumbnail_image;
}
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"thumbnail geometry: %.20gx%.20g",(double) next_image->columns,(double)
next_image->rows);
AppendImageToList(&images,next_image);
status=SetImageProgress(images,LoadImagesTag,i,number_files);
if (status == MagickFalse)
break;
}
read_info=DestroyImageInfo(read_info);
filelist=(char **) RelinquishMagickMemory(filelist);
if (images == (Image *) NULL)
ThrowReaderException(CorruptImageError,
"ImageFileDoesNotContainAnyImageData");
/*
Create the visual image directory.
*/
montage_info=CloneMontageInfo(image_info,(MontageInfo *) NULL);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"creating montage");
montage_image=MontageImageList(image_info,montage_info,
GetFirstImageInList(images),exception);
montage_info=DestroyMontageInfo(montage_info);
images=DestroyImageList(images);
return(montage_image);
}
dt_imageio_retval_t
dt_imageio_open_gm(
dt_image_t *img,
const char *filename,
dt_mipmap_cache_allocator_t a)
{
int err = DT_IMAGEIO_FILE_CORRUPTED;
float *buf = NULL;
ExceptionInfo exception;
Image *image = NULL;
ImageInfo *image_info = NULL;
uint32_t width, height, orientation;
if(!_supported_image(filename)) return DT_IMAGEIO_FILE_CORRUPTED;
if(!img->exif_inited)
(void) dt_exif_read(img, filename);
GetExceptionInfo(&exception);
image_info=CloneImageInfo((ImageInfo *) NULL);
g_strlcpy(image_info->filename,filename,sizeof(image_info->filename));
image=ReadImage(image_info,&exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (!image)
{
fprintf(stderr, "[GraphicsMagick_open] image `%s' not found\n", img->filename);
err = DT_IMAGEIO_FILE_NOT_FOUND;
goto error;
}
width = image->columns;
height = image->rows;
orientation = image->orientation;
if(orientation & 4)
{
img->width = height;
img->height = width;
}
else
{
img->width = width;
img->height = height;
}
img->bpp = 4*sizeof(float);
float *mipbuf = (float *)dt_mipmap_cache_alloc(img, DT_MIPMAP_FULL, a);
if(!mipbuf)
{
fprintf(stderr, "[GraphicsMagick_open] could not alloc full buffer for image `%s'\n", img->filename);
err = DT_IMAGEIO_CACHE_FULL;
goto error;
}
buf = (float *)dt_alloc_align(16, width*img->bpp);
if(!buf) goto error;
const int ht2 = orientation & 4 ? img->width : img->height; // pretend unrotated, rotate in write_pos
const int wd2 = orientation & 4 ? img->height : img->width;
for (uint32_t row = 0; row < height; row++)
{
int ret = DispatchImage(image, 0, row, width, 1, "RGBP", FloatPixel, (void *)buf, &exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if(ret != MagickPass)
{
fprintf(stderr, "[GraphicsMagick_open] error reading image `%s'\n", img->filename);
err = DT_IMAGEIO_FILE_CORRUPTED;
goto error;
}
for(uint32_t i=0; i<width; i++)
for(int k=0; k<4; k++) mipbuf[4*dt_imageio_write_pos(i, row, wd2, ht2, wd2, ht2, orientation) + k] = buf[4*i + k];
}
if(buf) dt_free_align(buf);
if(image) DestroyImage(image);
if(image_info) DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
img->filters = 0;
img->flags &= ~DT_IMAGE_RAW;
img->flags &= ~DT_IMAGE_HDR;
img->flags |= DT_IMAGE_LDR;
return DT_IMAGEIO_OK;
error:
if(buf) dt_free_align(buf);
if(image) DestroyImage(image);
if(image_info) DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
return err;
}
