static MagickBooleanType recolor(WandView *view, const ssize_t y, const int id, void *context){
RectangleInfo extent;
MagickPixelPacket pixel;
PixelWand **pixels;
register ssize_t x;
register float t;
extent = GetWandViewExtent(view);
pixels = GetWandViewPixels(view);
for (x = 0; x < (ssize_t) (extent.width - extent.x); x++){
PixelGetMagickColor(pixels[x], &pixel);
t = ScaleQuantumToChar(pixel.red);
pixel.red = get_color(t, 0);
pixel.green = get_color(t, 1);
pixel.blue = get_color(t, 2);
PixelSetMagickColor(pixels[x], &pixel);
}
return(MagickTrue);
}
void Resize(MagickWand *imagen, MagickWand *imagen2, int proporcion)
{
int ancho, largo, factor_conversion;
register ssize_t x;
size_t width, width2;
ssize_t y;
int ity, itx, index = 0;
MagickPixelPacket pixel, pixel2;
PixelIterator *iterator, *iterator2;
PixelWand **pixels, **pixels2;
PixelWand *bgw1 = NewPixelWand();
factor_conversion = abs(proporcion);
if(proporcion >= 0){
ancho = MagickGetImageWidth(imagen)*factor_conversion;
largo = MagickGetImageHeight(imagen)*factor_conversion;
}else{
ancho = (MagickGetImageWidth(imagen)/factor_conversion)+1;
largo = (MagickGetImageHeight(imagen)/factor_conversion)+1;
}
MagickNewImage(imagen2,ancho,largo,bgw1);
iterator = NewPixelIterator(imagen);
iterator2 = NewPixelIterator(imagen2);
if(proporcion >= 0){
//****************** ITERACION PIXEL POR PIXEL ***********************
for (y=0; y < (ssize_t) MagickGetImageHeight(imagen); y++)
{
pixels = PixelGetNextIteratorRow(iterator,&width);
if (pixels == (PixelWand **) NULL) break;
for(ity=0; ity < factor_conversion; ity++){
pixels2 = PixelGetNextIteratorRow(iterator2,&width2);
for (x=0; x < (ssize_t) width; x++)
{
PixelGetMagickColor(pixels[x],&pixel);
for(itx=0;itx<factor_conversion;itx++){
PixelGetMagickColor(pixels2[factor_conversion*x+itx],&pixel2);
pixel2.red = pixel.red;
pixel2.green = pixel.green;
pixel2.blue = pixel.blue;
PixelSetMagickColor(pixels2[factor_conversion*x+itx],&pixel2);
}
}
(void) PixelSyncIterator(iterator2);
}
(void) PixelSyncIterator(iterator);
}
//******************************************************************
}else{
//****************** ITERACION PIXEL POR PIXEL ***********************
for (y=0; y < (ssize_t) MagickGetImageHeight(imagen); y++)
{
pixels = PixelGetNextIteratorRow(iterator,&width);
if (pixels == (PixelWand **) NULL) break;
pixels2 = PixelGetNextIteratorRow(iterator2,&width2);
for (x=0; x < (ssize_t) width; x++)
{
if(x%factor_conversion == 0){
PixelGetMagickColor(pixels[x],&pixel);
PixelGetMagickColor(pixels2[index],&pixel2);
pixel2.red = pixel.red;
pixel2.green = pixel.green;
pixel2.blue = pixel.blue;
PixelSetMagickColor(pixels2[index],&pixel2);
index++;
}
}
index = 0;
for(ity=1;ity<factor_conversion;ity++){
pixels = PixelGetNextIteratorRow(iterator,&width);
}
(void) PixelSyncIterator(iterator2);
(void) PixelSyncIterator(iterator);
}
//******************************************************************
}
iterator = DestroyPixelIterator(iterator);
iterator = DestroyPixelIterator(iterator2);
}
int main(int argc, char **argv)
{
printf("Hello World\n");
#define QuantumScale ((MagickRealType) 1.0/(MagickRealType) QuantumRange)
#define SigmoidalContrast(x) (QuantumRange*(1.0/(1+exp(10.0*(0.5-QuantumScale*x)))-0.0066928509)*1.0092503)
#define ThrowWandException(wand)\
{\
char *description;\
ExceptionType\
severity;\
\
description=MagickGetException(wand,&severity);\
(void)fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description);\
exit(-1);\
}
long y;
MagickBooleanType status;
MagickPixelPacket pixel;
MagickWand *contrast_wand, *image_wand;
PixelIterator *contrast_iterator,*iterator;
PixelWand **contrast_pixels, **pixels;
register long x;
unsigned long width;
if (argc != 3)
{
(void)fprintf(stdout,"Usage: %s image sigmoidal-image\n",argv[0]);
exit(0);
}
/*
Read an Image
*/
MagickWandGenesis();
image_wand = NewMagickWand();
status = MagickReadImage(image_wand,argv[1]);
if(status == MagickFalse)
ThrowWandException(image_wand);
contrast_wand = CloneMagickWand(image_wand);
/*
Sigmoidal non-linearity contrast control.
*/
iterator = NewPixelIterator(image_wand);
contrast_iterator=NewPixelIterator(contrast_wand);
if((iterator == (PixelIterator*)NULL) || (contrast_iterator == (PixelIterator*)NULL))
ThrowWandException(image_wand);
for(y=0; y<(long)MagickGetImageHeight(image_wand); y++)
{
pixels = PixelGetNextIteratorRow(iterator,&width);
contrast_pixels = PixelGetNextIteratorRow(contrast_iterator,&width);
if((pixels==(PixelWand**)NULL) || (contrast_pixels == (PixelWand**)NULL))
break;
for(x = 0; x<(long)width; x++)
{
PixelGetMagickColor(pixels[x],&pixel);
pixel.red = SigmoidalContrast(pixel.red);
pixel.green = SigmoidalContrast(pixel.green);
pixel.blue = SigmoidalContrast(pixel.blue);
pixel.index = SigmoidalContrast(pixel.index);
PixelSetMagickColor(contrast_pixels[x],&pixel);
}
(void)PixelSyncIterator(contrast_iterator);
}
if(y < (long)MagickGetImageHeight(image_wand))
ThrowWandException(image_wand);
contrast_iterator = DestroyPixelIterator(contrast_iterator);
iterator = DestroyPixelIterator(iterator);
image_wand=DestroyMagickWand(image_wand);
status = MagickWriteImages(contrast_wand,argv[2],MagickTrue);
if(status == MagickFalse)
ThrowWandException(image_wand);
contrast_wand = DestroyMagickWand(contrast_wand);
MagickWandTerminus();
return 0;
}
