int timage_lua_comp(lua_State *L, char *path, timage_rectangle_t *orig_rect,
timage_rectangle_t *req_rect, timage_action_array_t **array)
{
if(luaL_loadfile(L, path) != 0) {
fprintf(stderr, "luaL_loadfile fail, %s\n", lua_tostring(L, -1));
return -1;
}
if(lua_pcall(L, 0, 0, 0) != 0) {
fprintf(stderr, "lua_pcall fail, %s\n", lua_tostring(L, -1));
return -1;
}
// 指定lua处理函数
// 传4个参数
lua_getglobal(L, "timage_main");
lua_pushnumber(L, orig_rect->width);
lua_pushnumber(L, orig_rect->height);
lua_pushnumber(L, req_rect->width);
lua_pushnumber(L, req_rect->height);
// 执行lua处理函数
// 弹出返回值
lua_call(L, 4, 1);
timage_action_array_t *actions = lua_touserdata(L, -1);
lua_pop(L, 1);
if(actions == NULL) return -1;
*array = actions;
return 0;
// 依次支持图片操作序列
#if 0
int i = 0;
timage_action_t *action = NULL;
for(i = 0; i < actions->size; i++) {
action = &(actions->actions[i]);
switch(action->action) {
case LUA_RET_COMP:
image = ThumbnailImage(image, action->rect.width, action->rect.height, &exception);
break;
case LUA_RET_CROP:
break;
case LUA_RET_PAD:
break;
default:
break;
}
// fprintf(stdout, "%d\n", action->action);
}
#endif
}
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)));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% 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);
}
MagickExport Image *MontageImageList(const ImageInfo *image_info,
const MontageInfo *montage_info,const Image *images,ExceptionInfo *exception)
{
#define MontageImageTag "Montage/Image"
#define TileImageTag "Tile/Image"
char
tile_geometry[MagickPathExtent],
*title;
const char
*value;
DrawInfo
*draw_info;
FrameInfo
frame_info;
Image
*image,
**image_list,
**master_list,
*montage,
*texture,
*tile_image,
*thumbnail;
ImageInfo
*clone_info;
MagickBooleanType
concatenate,
proceed,
status;
MagickOffsetType
tiles;
MagickProgressMonitor
progress_monitor;
MagickStatusType
flags;
register ssize_t
i;
RectangleInfo
bounds,
geometry,
extract_info;
size_t
border_width,
extent,
height,
images_per_page,
max_height,
number_images,
number_lines,
sans,
tiles_per_column,
tiles_per_page,
tiles_per_row,
title_offset,
total_tiles,
width;
ssize_t
bevel_width,
tile,
x,
x_offset,
y,
y_offset;
TypeMetric
metrics;
/*
Create image tiles.
*/
assert(images != (Image *) NULL);
assert(images->signature == MagickCoreSignature);
if (images->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
assert(montage_info != (MontageInfo *) NULL);
assert(montage_info->signature == MagickCoreSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
number_images=GetImageListLength(images);
master_list=ImageListToArray(images,exception);
image_list=master_list;
image=image_list[0];
if (master_list == (Image **) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
thumbnail=NewImageList();
for (i=0; i < (ssize_t) number_images; i++)
{
image=CloneImage(image_list[i],0,0,MagickTrue,exception);
if (image == (Image *) NULL)
break;
(void) ParseAbsoluteGeometry("0x0+0+0",&image->page);
progress_monitor=SetImageProgressMonitor(image,(MagickProgressMonitor) NULL,
image->client_data);
flags=ParseRegionGeometry(image,montage_info->geometry,&geometry,exception);
thumbnail=ThumbnailImage(image,geometry.width,geometry.height,exception);
if (thumbnail == (Image *) NULL)
break;
image_list[i]=thumbnail;
(void) SetImageProgressMonitor(image,progress_monitor,image->client_data);
proceed=SetImageProgress(image,TileImageTag,(MagickOffsetType) i,
number_images);
if (proceed == MagickFalse)
break;
image=DestroyImage(image);
}
if (i < (ssize_t) number_images)
{
if (thumbnail == (Image *) NULL)
i--;
for (tile=0; (ssize_t) tile <= i; tile++)
if (image_list[tile] != (Image *) NULL)
image_list[tile]=DestroyImage(image_list[tile]);
master_list=(Image **) RelinquishMagickMemory(master_list);
return((Image *) NULL);
}
/*
Sort image list by increasing tile number.
*/
for (i=0; i < (ssize_t) number_images; i++)
if (image_list[i]->scene == 0)
break;
if (i == (ssize_t) number_images)
qsort((void *) image_list,(size_t) number_images,sizeof(*image_list),
SceneCompare);
/*
Determine tiles per row and column.
*/
tiles_per_column=(size_t) sqrt((double) number_images);
tiles_per_row=(size_t) ceil((double) number_images/tiles_per_column);
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&tiles_per_column,&tiles_per_row);
/*
Determine tile sizes.
*/
concatenate=MagickFalse;
SetGeometry(image_list[0],&extract_info);
extract_info.x=(ssize_t) montage_info->border_width;
extract_info.y=(ssize_t) montage_info->border_width;
if (montage_info->geometry != (char *) NULL)
{
/*
Initialize tile geometry.
*/
flags=GetGeometry(montage_info->geometry,&extract_info.x,&extract_info.y,
&extract_info.width,&extract_info.height);
concatenate=((flags & RhoValue) == 0) && ((flags & SigmaValue) == 0) ?
MagickTrue : MagickFalse;
}
border_width=montage_info->border_width;
bevel_width=0;
(void) ResetMagickMemory(&frame_info,0,sizeof(frame_info));
if (montage_info->frame != (char *) NULL)
{
char
absolute_geometry[MagickPathExtent];
frame_info.width=extract_info.width;
frame_info.height=extract_info.height;
(void) FormatLocaleString(absolute_geometry,MagickPathExtent,"%s!",
montage_info->frame);
flags=ParseMetaGeometry(absolute_geometry,&frame_info.outer_bevel,
&frame_info.inner_bevel,&frame_info.width,&frame_info.height);
if ((flags & HeightValue) == 0)
frame_info.height=frame_info.width;
if ((flags & XiValue) == 0)
frame_info.outer_bevel=(ssize_t) frame_info.width/2-1;
if ((flags & PsiValue) == 0)
frame_info.inner_bevel=frame_info.outer_bevel;
frame_info.x=(ssize_t) frame_info.width;
frame_info.y=(ssize_t) frame_info.height;
bevel_width=(ssize_t) MagickMax(frame_info.inner_bevel,
frame_info.outer_bevel);
border_width=(size_t) MagickMax((ssize_t) frame_info.width,
(ssize_t) frame_info.height);
}
for (i=0; i < (ssize_t) number_images; i++)
{
if (image_list[i]->columns > extract_info.width)
extract_info.width=image_list[i]->columns;
if (image_list[i]->rows > extract_info.height)
extract_info.height=image_list[i]->rows;
}
/*
Initialize draw attributes.
*/
clone_info=CloneImageInfo(image_info);
clone_info->background_color=montage_info->background_color;
clone_info->border_color=montage_info->border_color;
draw_info=CloneDrawInfo(clone_info,(DrawInfo *) NULL);
if (montage_info->font != (char *) NULL)
(void) CloneString(&draw_info->font,montage_info->font);
if (montage_info->pointsize != 0.0)
draw_info->pointsize=montage_info->pointsize;
draw_info->gravity=CenterGravity;
draw_info->stroke=montage_info->stroke;
draw_info->fill=montage_info->fill;
draw_info->text=AcquireString("");
(void) GetTypeMetrics(image_list[0],draw_info,&metrics,exception);
texture=NewImageList();
if (montage_info->texture != (char *) NULL)
{
(void) CopyMagickString(clone_info->filename,montage_info->texture,
MagickPathExtent);
texture=ReadImage(clone_info,exception);
}
/*
Determine the number of lines in an next label.
*/
title=InterpretImageProperties(clone_info,image_list[0],montage_info->title,
exception);
title_offset=0;
if (montage_info->title != (char *) NULL)
title_offset=(size_t) (2*(metrics.ascent-metrics.descent)*
MultilineCensus(title)+2*extract_info.y);
number_lines=0;
for (i=0; i < (ssize_t) number_images; i++)
{
value=GetImageProperty(image_list[i],"label",exception);
if (value == (const char *) NULL)
continue;
if (MultilineCensus(value) > number_lines)
number_lines=MultilineCensus(value);
}
/*
Allocate next structure.
*/
tile_image=AcquireImage((ImageInfo *) NULL,exception);
montage=AcquireImage(clone_info,exception);
montage->background_color=montage_info->background_color;
montage->scene=0;
images_per_page=(number_images-1)/(tiles_per_row*tiles_per_column)+1;
tiles=0;
total_tiles=(size_t) number_images;
for (i=0; i < (ssize_t) images_per_page; i++)
{
/*
Determine bounding box.
*/
tiles_per_page=tiles_per_row*tiles_per_column;
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&sans,&sans);
tiles_per_page=tiles_per_row*tiles_per_column;
y_offset+=(ssize_t) title_offset;
max_height=0;
bounds.width=0;
bounds.height=0;
width=0;
for (tile=0; tile < (ssize_t) tiles_per_page; tile++)
{
if (tile < (ssize_t) number_images)
{
width=concatenate != MagickFalse ? image_list[tile]->columns :
extract_info.width;
if (image_list[tile]->rows > max_height)
max_height=image_list[tile]->rows;
}
x_offset+=(ssize_t) (width+2*(extract_info.x+border_width));
if (x_offset > (ssize_t) bounds.width)
bounds.width=(size_t) x_offset;
if (((tile+1) == (ssize_t) tiles_per_page) ||
(((tile+1) % tiles_per_row) == 0))
{
x_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y,
&sans,&sans);
height=concatenate != MagickFalse ? max_height : extract_info.height;
y_offset+=(ssize_t) (height+(extract_info.y+(ssize_t) border_width)*2+
(metrics.ascent-metrics.descent+4)*number_lines+
(montage_info->shadow != MagickFalse ? 4 : 0));
if (y_offset > (ssize_t) bounds.height)
bounds.height=(size_t) y_offset;
max_height=0;
}
}
if (montage_info->shadow != MagickFalse)
bounds.width+=4;
/*
Initialize montage image.
*/
(void) CopyMagickString(montage->filename,montage_info->filename,
MagickPathExtent);
montage->columns=(size_t) MagickMax((ssize_t) bounds.width,1);
montage->rows=(size_t) MagickMax((ssize_t) bounds.height,1);
(void) SetImageBackgroundColor(montage,exception);
/*
Set montage geometry.
*/
montage->montage=AcquireString((char *) NULL);
tile=0;
extent=1;
while (tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images))
{
extent+=strlen(image_list[tile]->filename)+1;
tile++;
}
montage->directory=(char *) AcquireQuantumMemory(extent,
sizeof(*montage->directory));
if ((montage->montage == (char *) NULL) ||
(montage->directory == (char *) NULL))
{
if (montage->montage != (char *) NULL)
montage->montage=(char *) RelinquishMagickMemory(montage->montage);
if (montage->directory != (char *) NULL)
montage->directory=(char *) RelinquishMagickMemory(
montage->directory);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&sans,&sans);
y_offset+=(ssize_t) title_offset;
(void) FormatLocaleString(montage->montage,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) (extract_info.width+
(extract_info.x+border_width)*2),(double) (extract_info.height+
(extract_info.y+border_width)*2+(double) ((metrics.ascent-
metrics.descent+4)*number_lines+(montage_info->shadow != MagickFalse ? 4 :
0))),(double) x_offset,(double) y_offset);
*montage->directory='\0';
tile=0;
while (tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images))
{
(void) ConcatenateMagickString(montage->directory,
image_list[tile]->filename,extent);
(void) ConcatenateMagickString(montage->directory,"\n",extent);
tile++;
}
progress_monitor=SetImageProgressMonitor(montage,(MagickProgressMonitor)
NULL,montage->client_data);
if (texture != (Image *) NULL)
(void) TextureImage(montage,texture,exception);
if (montage_info->title != (char *) NULL)
{
DrawInfo
*draw_clone_info;
TypeMetric
tile_metrics;
/*
Annotate composite image with title.
*/
draw_clone_info=CloneDrawInfo(image_info,draw_info);
draw_clone_info->gravity=CenterGravity;
draw_clone_info->pointsize*=2.0;
(void) GetTypeMetrics(image_list[0],draw_clone_info,&tile_metrics,
exception);
(void) FormatLocaleString(tile_geometry,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) montage->columns,(double)
(tile_metrics.ascent-tile_metrics.descent),0.0,
(double) extract_info.y+4);
(void) CloneString(&draw_clone_info->geometry,tile_geometry);
(void) CloneString(&draw_clone_info->text,title);
(void) AnnotateImage(montage,draw_clone_info,exception);
draw_clone_info=DestroyDrawInfo(draw_clone_info);
}
(void) SetImageProgressMonitor(montage,progress_monitor,
montage->client_data);
/*
Copy tile to the composite.
*/
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&sans,&sans);
x_offset+=extract_info.x;
y_offset+=(ssize_t) title_offset+extract_info.y;
max_height=0;
status=MagickTrue;
for (tile=0; tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images); tile++)
{
/*
Copy this tile to the composite.
*/
image=CloneImage(image_list[tile],0,0,MagickTrue,exception);
if (image == (Image *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
progress_monitor=SetImageProgressMonitor(image,
(MagickProgressMonitor) NULL,image->client_data);
width=concatenate != MagickFalse ? image->columns : extract_info.width;
if (image->rows > max_height)
max_height=image->rows;
height=concatenate != MagickFalse ? max_height : extract_info.height;
if (border_width != 0)
{
Image
*border_image;
RectangleInfo
border_info;
/*
Put a border around the image.
*/
border_info.width=border_width;
border_info.height=border_width;
if (montage_info->frame != (char *) NULL)
{
border_info.width=(width-image->columns+1)/2;
border_info.height=(height-image->rows+1)/2;
}
border_image=BorderImage(image,&border_info,image->compose,exception);
if (border_image != (Image *) NULL)
{
image=DestroyImage(image);
image=border_image;
}
if ((montage_info->frame != (char *) NULL) &&
(image->compose == DstOutCompositeOp))
{
(void) SetPixelChannelMask(image,AlphaChannel);
(void) NegateImage(image,MagickFalse,exception);
(void) SetPixelChannelMask(image,DefaultChannels);
}
}
/*
Gravitate as specified by the tile gravity.
*/
tile_image->columns=width;
tile_image->rows=height;
tile_image->gravity=montage_info->gravity;
if (image->gravity != UndefinedGravity)
tile_image->gravity=image->gravity;
(void) FormatLocaleString(tile_geometry,MagickPathExtent,
"%.20gx%.20g+0+0",(double) image->columns,(double) image->rows);
flags=ParseGravityGeometry(tile_image,tile_geometry,&geometry,exception);
x=(ssize_t) (geometry.x+border_width);
y=(ssize_t) (geometry.y+border_width);
if ((montage_info->frame != (char *) NULL) && (bevel_width > 0))
{
FrameInfo
frame_clone;
Image
*frame_image;
/*
Put an ornamental border around this tile.
*/
frame_clone=frame_info;
frame_clone.width=width+2*frame_info.width;
frame_clone.height=height+2*frame_info.height;
value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
frame_clone.height+=(size_t) ((metrics.ascent-metrics.descent+4)*
MultilineCensus(value));
frame_image=FrameImage(image,&frame_clone,image->compose,exception);
if (frame_image != (Image *) NULL)
{
image=DestroyImage(image);
image=frame_image;
}
x=0;
y=0;
}
if (LocaleCompare(image->magick,"NULL") != 0)
{
/*
Composite background with tile.
*/
if (montage_info->shadow != MagickFalse)
{
Image
*shadow_image;
/*
Shadow image.
*/
(void) QueryColorCompliance("#0000",AllCompliance,
&image->background_color,exception);
shadow_image=ShadowImage(image,80.0,2.0,5,5,exception);
if (shadow_image != (Image *) NULL)
{
(void) CompositeImage(shadow_image,image,OverCompositeOp,
MagickTrue,0,0,exception);
image=DestroyImage(image);
image=shadow_image;
}
}
(void) CompositeImage(montage,image,image->compose,MagickTrue,
x_offset+x,y_offset+y,exception);
value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
{
/*
Annotate composite tile with label.
*/
(void) FormatLocaleString(tile_geometry,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) ((montage_info->frame ?
image->columns : width)-2*border_width),(double)
(metrics.ascent-metrics.descent+4)*MultilineCensus(value),
(double) (x_offset+border_width),(double)
((montage_info->frame ? y_offset+height+border_width+4 :
y_offset+extract_info.height+border_width+
(montage_info->shadow != MagickFalse ? 4 : 0))+bevel_width));
(void) CloneString(&draw_info->geometry,tile_geometry);
(void) CloneString(&draw_info->text,value);
(void) AnnotateImage(montage,draw_info,exception);
}
}
x_offset+=(ssize_t) (width+2*(extract_info.x+border_width));
if (((tile+1) == (ssize_t) tiles_per_page) ||
(((tile+1) % tiles_per_row) == 0))
{
x_offset=extract_info.x;
y_offset+=(ssize_t) (height+(extract_info.y+border_width)*2+
(metrics.ascent-metrics.descent+4)*number_lines+
(montage_info->shadow != MagickFalse ? 4 : 0));
max_height=0;
}
if (images->progress_monitor != (MagickProgressMonitor) NULL)
{
proceed=SetImageProgress(image,MontageImageTag,tiles,total_tiles);
if (proceed == MagickFalse)
status=MagickFalse;
}
image_list[tile]=DestroyImage(image_list[tile]);
image=DestroyImage(image);
tiles++;
}
(void) status;
if ((i+1) < (ssize_t) images_per_page)
{
/*
Allocate next image structure.
*/
AcquireNextImage(clone_info,montage,exception);
if (GetNextImageInList(montage) == (Image *) NULL)
{
montage=DestroyImageList(montage);
return((Image *) NULL);
}
montage=GetNextImageInList(montage);
montage->background_color=montage_info->background_color;
image_list+=tiles_per_page;
number_images-=tiles_per_page;
}
}
tile_image=DestroyImage(tile_image);
if (texture != (Image *) NULL)
texture=DestroyImage(texture);
title=DestroyString(title);
master_list=(Image **) RelinquishMagickMemory(master_list);
draw_info=DestroyDrawInfo(draw_info);
clone_info=DestroyImageInfo(clone_info);
return(GetFirstImageInList(montage));
}
Image* generate_rendition(Image *const image, ImageInfo const*image_info, char const* spec, char const* rendition_path, ExceptionInfo *exception) {
unsigned long crop_x;
unsigned long crop_y;
unsigned long crop_width;
unsigned long crop_height;
unsigned long width;
unsigned long height;
unsigned int quality;
unsigned int resize;
double blur;
unsigned int is_progressive;
Image const* cropped;
Image *resized;
RectangleInfo geometry;
FilterTypes filter;
ImageInfo *rendition_info;
if (sscanf(spec, "%lux%lu+%lu+%lu+%lux%lu+%u+%lf+%u+%u", &crop_width, &crop_height, &crop_x, &crop_y, &width, &height, &resize, &blur, &quality, &is_progressive)) {
if (width > 0 && height > 0) {
if (crop_width > 0 && crop_height > 0) {
geometry.x = crop_x;
geometry.y = crop_y;
geometry.width = crop_width;
geometry.height = crop_height;
cropped = CropImage(image, &geometry, exception);
if (!cropped) {
CatchException(exception);
return NULL;
}
} else {
cropped = image;
}
filter = get_filter(resize);
switch (resize) {
case Sample:
resized = SampleImage(cropped, width, height, exception);
break;
case Scale:
resized = ScaleImage(cropped, width, height, exception);
break;
case Thumbnail:
resized = ThumbnailImage(cropped, width, height, exception);
break;
case Point:
case Box:
case Triangle:
case Hermite:
case Hanning:
case Hamming:
case Blackman:
case Gaussian:
case Quadratic:
case Cubic:
case Catrom:
case Mitchell:
case Lanczos:
case Bessel:
case Sinc:
resized = ResizeImage(cropped, width, height, filter, blur, exception);
break;
}
if (!resized) {
CatchException(exception);
return NULL;
}
rendition_info = CloneImageInfo(image_info);
rendition_info->quality = quality;
strncpy(resized->filename, rendition_path, MaxTextExtent);
if (is_progressive) {
rendition_info->interlace = LineInterlace;
printf("progressive: %s\n", rendition_path);
}
if (!WriteImage(rendition_info, resized)) {
CatchException(exception);
DestroyImageInfo(rendition_info);
return NULL;
}
printf("wrote %s\n", resized->filename);
DestroyImageInfo(rendition_info);
return resized;
}
}
return NULL;
}
