int magickUnsharpMaskImage(const char *imageFile, const char *outputImage, double radius, double sigma, double amount, double threshold){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
// MagickResetIterator(magick_wand);
// while (MagickNextImage(magick_wand) != MagickFalse)
MagickUnsharpMaskImage(magick_wand, radius, sigma, amount, threshold);
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
int barcode_to_png (char *image_name) {
MagickWand *magick_wand;
MagickBooleanType status;
int width, height, pad, half_pad;
/* read a barcode image */
MagickWandGenesis();
magick_wand = NewMagickWand();
MagickSetResolution(magick_wand, 300, 300);
status = MagickReadImage(magick_wand, image_name);
if (status == MagickFalse) ThrowWandException(magick_wand, 1);
/* trim the image, resample it, and pad it by [10% of the long side] per side */
MagickTrimImage(magick_wand, 10);
width = MagickGetImageWidth(magick_wand);
height = MagickGetImageHeight(magick_wand);
pad = determine_padding(width, height);
half_pad = round(pad/2);
MagickExtentImage(magick_wand, width+pad, height+pad, -half_pad, -half_pad);
/* write image (a PNG version and a formatted PS version) */
status=MagickWriteImage(magick_wand, chop_path(image_name, ".png"));
if (status == MagickFalse) ThrowWandException(magick_wand, 2);
status=MagickWriteImage(magick_wand, chop_path(image_name, ".ps"));
if (status == MagickFalse) ThrowWandException(magick_wand, 2);
/* clean up */
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return 0;
}
int main(int argc, char *argv[]) {
int compare_size = COMPARE_SIZE;
unsigned int maxerr = COMPARE_THRESHOLD;
if (argc < 3) {
fprintf(stdout, "\nERROR: Not enough arguments\n");
usage();
exit(1);
}
char *sql_info = argv[1];
int portno = atoi(argv[2]);
if (!portno) {
fprintf(stdout, "\nERROR: Invalid port\n");
usage();
exit(1);
}
// Work out how many CPUs we have. Default to 2
global_cpu_count = get_cpu_count(stdout);
if (global_cpu_count == 0) {
global_cpu_count = 2;
}
MagickWandGenesis();
server_loop(stdout, sql_info, portno, compare_size, maxerr);
MagickWandTerminus();
/* The final thing that main() should do */
pthread_exit(NULL);
exit(0);
}
int magickChopImage(const char *imageFile, const char *outputImage, int width, int height, int xPos, int yPos){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
MagickChopImage(magick_wand, width, height, xPos, yPos);
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
int magickCompressImage(const char *imageFile, const char *outputImage, const char *format, int compressionType, double compressionRate){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
// printf("compressionRate: %d", compressionRate);
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
// MagickResetIterator(magick_wand);
// while (MagickNextImage(magick_wand) != MagickFalse){
MagickSetFormat(magick_wand, (char *)format);
MagickSetImageCompression(magick_wand, compressionType);
MagickSetImageCompressionQuality(magick_wand, compressionRate);
// }
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
int magickResizeImage(const char *imageFile, const char *outputImage, int columns, int rows, int magickFilter, double blur){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
MagickResizeImage(magick_wand, columns, rows, LanczosFilter, blur);
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
int magickRotateImage(const char *imageFile, const char *outputImage, double degree){
MagickBooleanType status;
MagickWand *magick_wand;
PixelWand * bg = malloc(sizeof(PixelWand *));
/*
Read an image.
*/
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
MagickRotateImage(magick_wand, bg, degree);
// MagickSetImageCompression(magick_wand, MW_JPEGCompression);
// MagickUnsharpMaskImage( magick_wand, 4.5, 4.0, 4.5, 0.02 );
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
int main(int argc,char **argv) {
MagickWand *magick_wand;
MagickBooleanType status;
MagickWandGenesis();
magick_wand = NewMagickWand();
//This is a color image
status = MagickReadImage(magick_wand, "./Biter_500.jpg");
MagickScaleImage(magick_wand, 16, 16);
// MagickQuantizeImage(
// magick_wand,
// //Changing to 255 makes the image change to grayscale
// 255,
// GRAYColorspace,
// 0,
// 0,
// 0
// );
status = MagickWriteImages(magick_wand, "./67258.jpg", MagickTrue);
MagickWandTerminus();
return(0);
}
int magickModulateImage(const char *imageFile, const char *outputImage, double brightness, double saturation, double hue){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
MagickModulateImage(magick_wand, brightness, saturation, hue);
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
int main(int argc,char **argv) {
MagickWand *magick_wand_background;
MagickWand *magick_wand_foreground;
MagickWandGenesis();
magick_wand_background = NewMagickWand();
magick_wand_foreground = NewMagickWand();
MagickReadImage(magick_wand_background, "magick:logo");
MagickReadImage(magick_wand_foreground, "magick:rose");
MagickSetGravity(magick_wand_background, CenterGravity);
MagickSetGravity(magick_wand_foreground, CenterGravity);
MagickCompositeImage(
magick_wand_background,
magick_wand_foreground,
AtopCompositeOp,
0, 0
);
MagickSetFormat(magick_wand_background, "png");
MagickWriteImage(magick_wand_background, "./output/gravity.png");
MagickWandTerminus();
return 0;
}
/**
* Helper function to provide a visual interpretation of the accumulator.
*/
void print_accumulator(char* name) {
MagickWand *mw = NULL;
PixelWand **pmw = NULL;
PixelIterator *imw = NULL;
MagickWandGenesis();
unsigned long width, height;
width = _circumference;
height = _dimensions.semi_diagonal;
mw = NewMagickWand();
MagickSetSize(mw, width, height);
MagickReadImage(mw, "xc:black");
imw = NewPixelIterator(mw);
int y, x;
for (y=0; y<height; y++) {
pmw = PixelGetNextIteratorRow(imw, &width);
for (x=0; x< (long) width; x++) {
_CELL_TYPE* cell = &_accumulator[x][height-y-1];
PixelSetRed(pmw[x], 1.0/20.0 * cell->count);
}
PixelSyncIterator(imw);
}
MagickWriteImage(mw, name);
if(mw)
mw = DestroyMagickWand(mw);
MagickWandTerminus();
}
int main(int argc, char* argv[]) {
MagickWand *mw = NULL;
DrawingWand *dw = NULL;
PixelWand *fill = NULL;
int x,y;
MagickWandGenesis();
mw = NewMagickWand();
MagickReadImage(mw,"logo:");
fill = NewPixelWand();
dw = NewDrawingWand();
PixelSetColor(fill,"green");
DrawSetFillColor(dw,fill);
for (x=200;x<210;x++)
for (y=100;y<110;y++)
DrawPoint(dw,x,y);
MagickDrawImage(mw,dw);
MagickWriteImage(mw,"logo.jpg");
if (dw) dw = DestroyDrawingWand(dw);
if (fill) fill = DestroyPixelWand(fill);
if (mw) mw = DestroyMagickWand(mw);
MagickWandTerminus();
}
int main(int argc,char **argv) {
MagickWand *magick_wand;
MagickBooleanType status;
MagickWandGenesis();
magick_wand = NewMagickWand();
MagickSetResourceLimit(MemoryResource, 1000 * 1000);
MagickSetResourceLimit(DiskResource, 1000 * 1000);
status = MagickReadImage(magick_wand, "./images/picture-100M-6000x6000.png");
if (status == MagickFalse) {
printf("Failed to MagickReadImage");
return -1;
}
printf("This shouldn't be reached - the image is larger than the area resource.\n");
MagickSetImageFormat(magick_wand, "png");
status = MagickWriteImages(magick_wand, "./output/resource_output.png", MagickTrue);
if (status == MagickFalse) {
printf("Failed to MagickWriteImages");
return -1;
}
MagickWandTerminus();
return(0);
}
void *libInit( void *sb )
{
struct ImageLibrary *l = NULL;
DEBUG("IMAGE LIBRARY INIT\n");
if( ( l = calloc( 1, sizeof( struct ImageLibrary ) ) ) == NULL )
return NULL;
l->l_Name = LIB_NAME;
l->l_Version = LIB_VERSION;
l->libClose = dlsym( l->l_Handle, "libClose");
l->GetVersion = dlsym( l->l_Handle, "GetVersion");
l->GetRevision = dlsym( l->l_Handle, "GetRevision");
// user.library structure
l->ResizeImage = dlsym( l->l_Handle, "FResizeImage");
l->ImageRead = dlsym( l->l_Handle, "ImageRead");
l->ImageWrite = dlsym( l->l_Handle, "ImageWrite");
l->sb = sb;
#ifdef USE_IMAGE_MAGICK
MagickWandGenesis();
#endif
return ( void *)l;
}
static PyObject *
im_InitMagick(PyObject *self, PyObject *args) {
MagickWandGenesis();
Py_INCREF(Py_None);
return Py_None;
}
ARUint8* loadImage(char* filename, int* xsize, int* ysize)
{
ARUint8 *dptr;
Image *image;
MagickWand* magick_wand;
MagickWandGenesis();
magick_wand=NewMagickWand();
if( magick_wand == NULL) {
fprintf(stderr, "bad magickwand\n");
}
MagickBooleanType status=MagickReadImage(magick_wand,filename);
if (status == MagickFalse) {
//fprintf(stderr, "%s can't be read\n", filename);
//exit(1);
//return; //(1);
ThrowWandException(magick_wand);
}
image = GetImageFromMagickWand(magick_wand);
//ContrastImage(image,MagickTrue);
//EnhanceImage(image,&image->exception);
int index;
*xsize = image->columns;
*ysize = image->rows;
dptr = malloc(sizeof(ARUint8) * 3 * image->rows * *xsize);
int y;
index = 0;
for (y=0; y < (long) image->rows; y++)
{
const PixelPacket *p = AcquireImagePixels(image,0,y,*xsize,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
int x;
for (x=0; x < (long) *xsize; x++)
{
/// convert to ARUint8 dptr
/// probably a faster way to give the data straight over
/// in BGR format
dptr[index*3+2] = p->red/256;
dptr[index*3+1] = p->green/256;
dptr[index*3] = p->blue/256;
//fprintf(stderr,"%d, %d, %d\t%d\t%d\n", x, y, p->red/256, p->green/256, p->blue/256);
p++;
index++;
}
}
return dptr;
}
int main(int argc,char **argv)
{
char
filename[MaxTextExtent];
MagickBooleanType
status;
MagickWand
*canvas;
if (argc != 2)
{
(void) printf ("Usage: %s filename\n",argv[0]);
exit(1);
}
(void) CopyMagickString(filename,argv[1],MaxTextExtent);
/*
Create canvas image.
*/
MagickWandGenesis();
canvas=NewMagickWand();
status=MagickSetSize(canvas,596,842);
if (status == MagickFalse)
ThrowWandException(canvas);
status=MagickReadImage(canvas,"xc:white");
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Scribble on image.
*/
status=ScribbleImage(canvas);
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Set pixel depth to 8.
*/
status=MagickSetImageDepth(canvas,8);
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Set output as RLE compressed.
*/
status=MagickSetImageCompression(canvas,RLECompression);
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Save image to file.
*/
status=MagickWriteImage(canvas,filename);
if (status == MagickFalse)
ThrowWandException(canvas);
canvas=DestroyMagickWand(canvas);
MagickWandTerminus();
return(0);
}
bool ImageMagickGIFEncoderOpen(struct ImageMagickGIFEncoder* encoder, const char* outfile) {
MagickWandGenesis();
encoder->wand = NewMagickWand();
MagickSetImageFormat(encoder->wand, "GIF");
MagickSetImageDispose(encoder->wand, PreviousDispose);
encoder->outfile = strdup(outfile);
encoder->frame = malloc(VIDEO_HORIZONTAL_PIXELS * VIDEO_VERTICAL_PIXELS * 4);
encoder->currentFrame = 0;
return true;
}
void register_fuppes_plugin(plugin_info* info)
{
strcpy(info->plugin_name, "magickWand");
strcpy(info->plugin_author, "Ulrich Voelkel");
info->plugin_type = PT_TRANSCODER;
//#ifdef WIN32
MagickWandGenesis();
//#endif
}
void main(void)
{
clock_t begin, end;
double time_spent;
double imageAspectRatio = 0;
double originalWidth;
double originalHeight;
double masterAspectRatio = 1.77;
MagickWand *m_wand = NULL;
int width,height;
MagickWandGenesis();
m_wand = NewMagickWand();
MagickReadImage(m_wand,"mona-lisa.JPG");
begin = clock();
originalWidth = MagickGetImageWidth(m_wand);
originalHeight = MagickGetImageHeight(m_wand);
imageAspectRatio = originalWidth/originalHeight;
if(imageAspectRatio <= masterAspectRatio)
{
MagickCropImage(m_wand,originalWidth,(int)(originalWidth/masterAspectRatio),0,(originalHeight-(int)(originalWidth/masterAspectRatio))/2 );
printf("%d X %d ",MagickGetImageWidth(m_wand) , MagickGetImageHeight(m_wand));
}
else
{
MagickCropImage(m_wand,(int)(originalHeight * masterAspectRatio),originalHeight,(originalWidth - (int)(originalHeight * masterAspectRatio))/2,0);
}
if (originalWidth > 1920)
MagickResizeImage(m_wand,1920,1080,LanczosFilter,1);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("Time taken is %f\n",time_spent);
// MagickCropImage(m_wand,originalWidth/2,originalHeight/2,0,0);
// Set the compression quality to 95 (high quality = low compression)
//MagickSetImageCompressionQuality(m_wand,95);
/* Write the new image */
MagickWriteImage(m_wand,"master.jpg");
/* Clean up */
if(m_wand)m_wand = DestroyMagickWand(m_wand);
MagickWandTerminus();}
bool
img_init (img_t *im)
{
MagickWandGenesis();
if (im) {
im->screen = (void *) NewMagickWand();
im->banner = (void *) NewMagickWand();
return true;
}
return false;
}
int main (int argc, const char *argv[])
{
// option pre-scan
int quiet = 0;
int display = 1;
MagickWandGenesis();
processor = zbar_processor_create(0);
assert(processor);
if(zbar_processor_init(processor, NULL, display))
{
zbar_processor_error_spew(processor, 0);
return(1);
}
if(display)
zbar_processor_set_visible(processor, 1);
IplImage * image = cvLoadImage(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
if(scan_image(image))
return (exit_code);
if(num_images && !quiet && xmllvl <= 0)
{
fprintf(stderr, "scanned %d barcode symbols from %d images",
num_symbols, num_images);
#ifdef HAVE_SYS_TIMES_H
#ifdef HAVE_UNISTD_H
long clk_tck = sysconf(_SC_CLK_TCK);
struct tms tms;
if(clk_tck > 0 && times(&tms) >= 0)
{
double secs = tms.tms_utime + tms.tms_stime;
secs /= clk_tck;
fprintf(stderr, " in %.2g seconds\n", secs);
}
#endif
#endif
fprintf(stderr, "\n");
if(notfound)
fprintf(stderr, "%s", warning_not_found);
}
if(num_images && notfound && !exit_code)
exit_code = 4;
zbar_processor_destroy(processor);
MagickWandTerminus();
return(exit_code);
}
int main(int argc, char **argv){
if (argc != 4){
(void) fprintf(stdout,"Usage: %s palette input-file output-file\n",argv[0]);
exit(0);
}
read_palette(argv[1]);
print_palette();
char *description;
ExceptionType severity;
#define ThrowWandException(wand) \
{ \
description=MagickGetException(wand,&severity); \
(void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); \
description=(char *) MagickRelinquishMemory(description); \
exit(-1); \
}
MagickBooleanType status;
MagickPixelPacket pixel;
MagickWand *wand;
WandView *view;
/*
Read an image.
*/
MagickWandGenesis();
wand = NewMagickWand();
status = MagickReadImage(wand, argv[2]);
if (status == MagickFalse) ThrowWandException(wand);
/*
Sigmoidal non-linearity contrast control.
*/
view = NewWandView(wand);
if (view == (WandView *) NULL) ThrowWandException(wand);
status = UpdateWandViewIterator(view, recolor, (void *)NULL);
if (status == MagickFalse) ThrowWandException(wand);
view = DestroyWandView(view);
/*
Write the image then destroy it.
*/
status = MagickWriteImages(wand, argv[3], MagickTrue);
if (status == MagickFalse) ThrowWandException(wand);
wand = DestroyMagickWand(wand);
MagickWandTerminus();
return 0;
}
/**
* Prints count lines on output with background bg. Lines can be scaled by using factor.
* NOTE: This performs some filtering removing lines passing through origin
*/
void print_lines(char* output, char* bg, LINE_TYPE* lines, sizep_t count, double factor) {
MagickWand *mw = NULL;
DrawingWand *dw = NULL;
PixelWand *pmw = NULL;
unsigned long width, semi_width, height, semi_height;
MagickWandGenesis();
mw = NewMagickWand();
dw = NewDrawingWand();
pmw = NewPixelWand();
MagickReadImage(mw, bg);
width = MagickGetImageWidth(mw);
semi_width = ceil(width/2.0);
height = MagickGetImageHeight(mw);
semi_height = ceil(height/2.0);
PixelSetColor(pmw,"red");
DrawSetStrokeColor(dw, pmw);
DrawSetStrokeWidth(dw, .5*factor);
DrawSetStrokeAntialias(dw, 0);
sizep_t n;
for(n=0; n<count; n++) {
LINE_TYPE cline = lines[n];
double m = -cos(cline.t)/sin(cline.t);
double b = cline.r/sin(cline.t);
if ((-0.5 < m && m < 0.5) || (-1 < b && b < 1)) continue; // remove lines too horizontal
double x0 = - ((long) semi_width); double y0 = x0*m+b;
double x1 = ((long) semi_width); double y1 = x1*m+b;
// Apply factor
x0 *= factor; y0 *= factor; x1 *= factor; y1 *= factor;
// Fix coordinates and plot over the image
DrawLine(dw, x0+semi_width, height-y0-semi_height, x1+semi_width, height-y1-semi_height);
}
MagickDrawImage(mw,dw);
MagickWriteImage(mw, output);
pmw = DestroyPixelWand(pmw);
mw = DestroyMagickWand(mw);
dw = DestroyDrawingWand(dw);
MagickWandTerminus();
}
/**
* initialize ImageMagick
*/
NftResult im_init(struct Ledcat *c)
{
#if HAVE_IMAGEMAGICK == 1
/* initialize magickWand */
if(!c->raw)
{
MagickWandGenesis();
if(!(c->mw = NewMagickWand()))
return FALSE;
}
#endif
return TRUE;
}
int main (int argc,char **argv)
{
FILE *fp;
unsigned char *polje;
char format[5] = {0};
int len;
size_t width, height;
MagickWand *image_wand;
MagickBooleanType status;
//ucitavanje slike
if( (fp = fopen(argv[1],"rb")) == NULL)
printf("nemoze otvorit sliku\n");
fseek(fp,0,SEEK_END);
len = ftell(fp);
fseek(fp,0,SEEK_SET);
polje = (unsigned char*) malloc (len);
fread(polje,1,len,fp);
//ucitavanje u imagemagick
MagickWandGenesis();
image_wand = NewMagickWand();
status = MagickReadImageBlob(image_wand, polje, len);
free(polje);
if (status == MagickFalse)
{printf("\nnevalja status\n"); exit(-1);}
strcpy(format,MagickGetImageFormat(image_wand));
width = MagickGetImageWidth(image_wand);
height = MagickGetImageHeight(image_wand);
printf("width = %d\nheight = %d\nformat = %s\n",width,height,format);
fclose(fp);
image_wand = DestroyMagickWand(image_wand);
MagickWandTerminus();
system("pause");
return 0;
}
void im_connect (void *appdata)
{
im_IMVERSION = box_dv_short_string (IM_VERSION);
im_lib_mutex = mutex_allocate ();
bif_define ("IM ResizeImageFile", bif_im_ResizeImageFile);
bif_define ("IM ThumbnailImageFile", bif_im_ThumbnailImageFile);
bif_define ("IM ConvertImageFile", bif_im_ConvertImageFile);
bif_define ("IM ResampleImageFile", bif_im_ResampleImageFile);
bif_define ("IM RotateImageFile", bif_im_RotateImageFile);
bif_define ("IM CropImageFile", bif_im_CropImageFile);
bif_define ("IM GetImageFileAttribute", bif_im_GetImageFileAttribute);
bif_define ("IM GetImageFileFormat", bif_im_GetImageFileFormat);
bif_define ("IM GetImageFileIdentify", bif_im_GetImageFileIdentify);
bif_define ("IM GetImageBlobIdentify", bif_im_GetImageBlobIdentify);
bif_define ("IM GetImageFileWidth", bif_im_GetImageFileWidth);
bif_define ("IM GetImageFileHeight", bif_im_GetImageFileHeight);
bif_define ("IM GetImageFileDepth", bif_im_GetImageFileDepth);
bif_define ("IM GetImageFileWH", bif_im_GetImageFileWH);
bif_define ("IM ResizeImageFileToBlob", bif_im_ResizeImageFileToBlob);
bif_define ("IM ThumbnailImageFileToBlob", bif_im_ThumbnailImageFileToBlob);
bif_define ("IM ResampleImageFileToBlob", bif_im_ResampleImageFileToBlob);
bif_define ("IM RotateImageFileToBlob", bif_im_RotateImageFileToBlob);
bif_define ("IM CropImageFileToBlob", bif_im_CropImageFileToBlob);
bif_define ("IM GetImageBlobAttribute", bif_im_GetImageBlobAttribute);
bif_define ("IM GetImageBlobFormat", bif_im_GetImageBlobFormat);
bif_define ("IM GetImageBlobWidth", bif_im_GetImageBlobWidth);
bif_define ("IM GetImageBlobHeight", bif_im_GetImageBlobHeight);
bif_define ("IM GetImageBlobDepth", bif_im_GetImageBlobDepth);
bif_define ("IM GetImageBlobWH", bif_im_GetImageBlobWH);
bif_define ("IM ConvertImageBlob", bif_im_ConvertImageBlob);
bif_define ("IM ResizeImageBlob", bif_im_ResizeImageBlob);
bif_define ("IM ThumbnailImageBlob", bif_im_ThumbnailImageBlob);
bif_define ("IM DeepZoom4to1", bif_im_DeepZoom4to1);
bif_define ("IM ResampleImageBlob", bif_im_ResampleImageBlob);
bif_define ("IM RotateImageBlob", bif_im_RotateImageBlob);
bif_define ("IM CropImageBlob", bif_im_CropImageBlob);
bif_define ("IM CropAndResizeImageBlob", bif_im_CropAndResizeImageBlob);
#if defined(HasTTF) || defined(HasFREETYPE)
bif_define ("IM AnnotateImageBlob", bif_im_AnnotateImageBlob);
#endif
bif_define ("IM CreateImageBlob", bif_im_CreateImageBlob);
bif_define ("IM XYtoMorton", bif_im_XY_to_Morton);
MagickWandGenesis();
}
void saveImage(char* input,char* output)
{
printf("save-Image\n");
MagickWand *m_wand = NULL;
MagickWandGenesis();
m_wand = NewMagickWand();
//open
MagickReadImage(m_wand,input);
//save
MagickWriteImage(m_wand,output);
/* Clean up */
if(m_wand)m_wand = DestroyMagickWand(m_wand);
MagickWandTerminus();
}
/**
* Extracts from a binary image white points and consider them as information
* filling sample array and setting size structure.
*
* NOTE: When extracting points origin is moved to the center of the image:
*
* +semi_height
* Image Origin
* +-----------|
* | |
* | |
* | | Hough Origin
* -semi_width ------------+------------- +semi_width
* |
* |
* |
* |
*
* -semi_height
*/
sizep_t get_points(char* name, POINT_TYPE **sample, SIZE_TYPE *size) {
MagickWand *mw = NULL;
PixelWand **pmw = NULL;
PixelIterator *imw = NULL;
MagickWandGenesis();
mw = NewMagickWand();
MagickReadImage(mw, name);
unsigned long width, semi_width, height, semi_height;
width = MagickGetImageWidth(mw);
semi_width = ceil(width/2.0);
height = MagickGetImageHeight(mw);
semi_height = ceil(height/2.0);
imw = NewPixelIterator(mw);
sizep_t count = 0;
POINT_TYPE *aux = (POINT_TYPE*) malloc(sizeof(POINT_TYPE)*width*height);
// Extract white points
int y, x;
for (y=0; y<height; y++) {
pmw = PixelGetNextIteratorRow(imw, &width);
for (x=0; x< (long) width; x++) {
if (PixelGetBlack(pmw[x])) {
aux[count].x = x-semi_width;
aux[count].y = (height-y)-semi_height;
count++;
}
}
}
POINT_TYPE* output = (POINT_TYPE*) malloc(sizeof(POINT_TYPE)*count);
memcpy(output, aux, sizeof(POINT_TYPE)*count);
free(aux); aux = NULL;
if(mw)
mw = DestroyMagickWand(mw);
MagickWandTerminus();
(*sample) = output;
size->width = width;
size->height = height;
return count;
}
int main(int argc, char *argv[])
{
MagickWand *wand = NULL;
MagickBooleanType ret;
char *description;
ExceptionType excep;
if (argc < 2) {
fprintf(stderr, "Usage: %s file\n", argv[0]);
return 1;
}
MagickWandGenesis();
wand = NewMagickWand();
if (wand == NULL) {
description = MagickGetException(wand, &excep);
fprintf(stderr, "%s; %s\n", "NewMagickWand() failed", description);
MagickRelinquishMemory(description);
return 1;
}
ret = MagickReadImage(wand, argv[1]);
if (ret != MagickTrue) {
description = MagickGetException(wand, &excep);
fprintf(stderr, "%s; %s\n", "MagickReadImage() failed", description);
MagickRelinquishMemory(description);
return 1;
}
printf("Format: %s\n", MagickGetImageFormat(wand));
printf("Filename: %s\n", MagickGetImageFilename(wand));
printf("Compression Quality: %ld\n", MagickGetCompressionQuality(wand));
printf("Signature: %s\n", MagickGetImageSignature(wand));
printf("Width: %ld\n", MagickGetImageWidth(wand));
printf("Height: %ld\n", MagickGetImageHeight(wand));
if (wand != NULL) {
DestroyMagickWand(wand);
}
MagickWandTerminus();
return 0;
}
