Voy a saltarme la explicación sobre cómo instalar las librerías de desarrollo de ImageMagick ya que varía ligeramente de una distribución a otra y no suele ser muy complicado (teniendo en cuenta que ImageMagick suele estar presente en los repositorios más comunes y accesible desde gestores de paquetes como Synaptic). De todas formas si os surge alguna duda utilizad los comentarios.

Para simplificar la aplicación, ésta carecerá de interfaz gráfica y se ejecutará por terminal. El input del programa serán dos imágenes del mismo tamaño y un número entero positivo que indicará el número de imágenes intermedias que queremos que genere el programa como resultado.

Antes de empezar a poneros código fuente os comentaré la estructura de directorios del proyecto. Llamaremos al proyecto SFFadeOut (de Segmentation Fault Fade Out), por lo que la carpeta contenedora tendrá ese nombre. Dentro crearemos 4 directorios más:

• /bin: para los ficheros binarios
• /inc: para los headers (.h) a incluir en el proyecto
• /obj: para los .o
• /src: para los ficheros de código fuente

Ahora sí, ¡veamos el código!

En primer lugar os dejo el código de los 2 ficheros que conforman la clase Imagen. Esta clase se encargará de almacenar la información de los píxeles así como de tener algunos métodos y operadores para facilitar el trabajo. Primero os dejo el fichero Imagen.h que estará en /SFFadeOut/inc:

#ifndef IMAGEN_H
#define IMAGEN_H

class Imagen
{
 public:
  int dim[2];
  double * datos;
  Imagen();
  Imagen(int fil, int col);
  Imagen(int fil, int col, double val);
  ~Imagen();

  void  operator=(Imagen &im2);

  int fils(){return dim[0];}
  int cols(){return dim[1];}

  inline double & operator()(int i, int j)
  {
    return(datos[i*dim[1]+j]);
  };

};

Imagen & lee(char * archima, int campo);
int compara_dims(Imagen & im1, Imagen & im2);
void escribe(char * archima, Imagen & imR, Imagen & imG, Imagen & imB);

#endif

En éste fichero se encuentra la definición estática de la clase. Podéis ver los atributos de la clase, los constructores, un par de operadores y métodos propios de la clase. A continuación os dejo su correspondiente Imagen.cpp:

#include <Imagen.h>
#include <stdio.h>
#include <math.h>

Imagen::Imagen()
{
  dim[0]=0;
  dim[1]=0;
  datos=new double[1];
}

Imagen::Imagen(int fil, int col)
{
  dim[0]=fil;
  dim[1]=col;
  datos=new double[fil*col];
}

Imagen::Imagen(int fil, int col, double val)
{
  dim[0]=fil;
  dim[1]=col;
  datos=new double[fil*col];
  for(int i=0; i<fil*col;i++)
    datos[i]=val;
}

Imagen::~Imagen()
{
  delete[] datos;
}

void Imagen::operator=(Imagen  &im2)
{
  // este operador no duplica la memoria //
  int fil2=im2.fils();
  int col2=im2.cols();
  if(dim[0]!=fil2 || dim[1]!=col2)
  {
		dim[0]=fil2;
		dim[1]=col2;
		delete[] datos;
		datos=new double[fil2*col2];
	}

  int largo=dim[0]*dim[1];
  for(int i=0; i<largo; i++)
    datos[i]=im2.datos[i];

  return;
}

Si os habéis dado cuenta, hay algunas funciones definidas en el header que no están implementadas en el .cpp. El motivo es que vamos a crear otro fichero llamado inout.cpp en el que incluir las funciones de lectura y escritura de imágenes (y también la función para comparar las dimesiones de las imágenes).

#include <Imagen.h>
#include <stdio.h>

#include <Magick++.h>
#include <iostream>
using namespace std;
using namespace Magick;

Imagen  & lee(char * archima, int campo)
{
  string filename(archima);
  Image image;
  image.read(filename);
  Geometry g = image.size();
  int ancho = g.width();
  int alto= g.height();
  double c=1.0/257.0;
  Imagen * im=new Imagen(alto,ancho,(double)0.0);

  for(int i=0;i<alto;i++)
    for(int j=0;j<ancho;j++)
      switch(campo)
      {
        case 0:
          (*im)(i,j)=c*( double (image.pixelColor(j,i).redQuantum()));
          break;
        case 1:
          (*im)(i,j)=c*( double(image.pixelColor(j,i).greenQuantum()));
          break;
        case 2:
          (*im)(i,j)=c*( double(image.pixelColor(j,i).blueQuantum()));
          break;
        default:
          fprintf(stderr,"\n Error en inout.cpp al leer archivo \n");
          break;
      }

   return(*im);
};

int compara_dims(Imagen & im1, Imagen & im2)
{
  if(im1.fils()!=im2.fils() | im1.cols()!=im2.cols())
    return 0;
  return 1;
};

void escribe(char * archima, Imagen & imR, Imagen & imG, Imagen & imB)
{
    int ancho=imR.cols();
    int alto=imR.fils();
  if(compara_dims(imR,imG)!=1 | compara_dims(imG,imB)!=1 )
    {
      fprintf(stderr,"\n Error al escribir en inout.cpp: imagenes R,G,B con distintas dimensiones. \n");
      return;
    }

  Geometry geom(ancho,alto);
  Image im(geom,"white");

  for(int i=0;i<alto;i++)
    for(int j=0;j<ancho;j++)
      {
        double R=imR(i,j);
        double G=imG(i,j);
        double B=imB(i,j);
        R/=255.0;
        G/=255.0;
        B/=255.0;
        ColorRGB col(R,G,B);
              im.pixelColor(j,i,col);
      }

  im.write(archima);
  return;
};

Explicar todo el código anterior es bastante complejo por lo que pretendo que lo toméis como una API que supone una capa más de abstracción sobre la librería de ImageMagick. Ahora sí que os dejo la parte interesante, el fichero fadeout.cpp en el cual está el main del programa. Lo primero que realiza es comprobar si son correctos los parámetros de entrada y en caso contrario alertar al usuario. A continuación lee las imágenes y las almacena en objetos de la clase Imagen anteriormente detallada. Crea también un objeto para las imágenes resultantes e intera para cada píxel de cada una de las imágenes resultantes n, realizando el fundido (FadeOut).

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <sstream>

#include <Imagen.h>
#include <Magick++.h>
#include <iostream>
using namespace std;
using namespace Magick;

void uso()
{
  fprintf(stderr,"Uso: prueba imagen0 imagen1 n \n");
  exit(1);
};

char * getImagename(int i){
	stringstream temp;

	temp << "imagen_resultante_" << i << ".tiff";
	string resultName = temp.str();

	char *cstr = new char [resultName.size()+1];
  strcpy (cstr, resultName.c_str());

	return cstr;

}

main(int argc,char **argv)
{

  //verifica que la cantidad de argumentos es correcta
  if(argc<4)
    uso();

  //almacena los argumentos en sus correspondientes variables
  argv++;
  char * nimagen0 =*argv++;
  char * nimagen1 =*argv++;
  int n=atoi(*argv++);

  //lee la primera imagen de entrada
  Imagen im0R=lee(nimagen0,0);
  Imagen im0G=lee(nimagen0,1);
  Imagen im0B=lee(nimagen0,2);

  //lee la segunda imagen de entrada
  Imagen im1R=lee(nimagen1,0);
  Imagen im1G=lee(nimagen1,1);
  Imagen im1B=lee(nimagen1,2);

	int cont;
 	int ancho=im0R.cols();
  int alto=im0R.fils();

	// crea un objeto Imagen para la imagen resultante
	Imagen resultR(ancho, alto);
	Imagen resultG(ancho, alto);
	Imagen resultB(ancho, alto);

	// la primera imagen resultante es la imagen de inicio
  escribe("imagen_resultante_0.tiff",im0R,im0G,im0B);

 	// bucle para generar n imágenes resultantes
	for(cont=0; cont <n; cont++){
		// doble bucle que recorre los píxeles
	  for(int i=0;i<alto;i++){
	    for(int j=0;j<ancho;j++){

				// realiza el fundido
      	resultR(i,j) = (float)(((float)(n+1)-(cont+1)) / (float)(n+1)) * im0R(i,j) + (float)((float)(cont+1) / (float)(n+1)) * im1R(i,j);
				resultG(i,j) = (float)(((float)(n+1)-(cont+1)) / (float)(n+1)) * im0G(i,j) + (float)((float)(cont+1) / (float)(n+1)) * im1G(i,j);
				resultB(i,j) = (float)(((float)(n+1)-(cont+1)) / (float)(n+1)) * im0B(i,j) + (float)((float)(cont+1) / (float)(n+1)) * im1B(i,j);
	    }
	  }
		// escribe la imagen resultante n
		escribe(getImagename(cont+1),resultR,resultG,resultB);
	}

	// escribe la imagen final
	escribe(getImagename(cont+1),im1R,im1G,im1B);

	fprintf(stdout,"\n\n Final del programa \n\n");
}

El cuerpo de los bucles es el que realiza el fundido propiamente dicho aplicando la fórmula:

Fórmula para implementar el fundido.

Para facilitar un poco más la tarea de compilar el programa os dejo también el Makefile que yo utilizo:

HOME = ..

TARGETS = $(SFFADEOUT)

OBJECTS = $(OBJSFFADEOUT)

###############################
# esto es general

CPP = g++

incdir1 = $(HOME)/inc
incdir2 = /usr/include/ImageMagick
#incdir2 = /usr/include/GraphicsMagick

SRC= $(HOME)/src
OBJ = $(HOME)/obj
bindir=$(HOME)/bin

INCLUDES = -I$(incdir2) -I$(incdir1)

CPPFLAGS = -g -O3

LIBS = -DHAVE_CONFIG_H -D_REENTRANT -D_FILE_OFFSET_BITS=64 -I/usr/include/magick -I/X11 -L/usr/lib -L/usr/X11R6/lib -lMagick++ -ltiff -ljpeg -lpng -lbz2 -lz -lpthread -lm -ldl -lxml2

##########################################
# SFFADEOUT

SFFADEOUT = sffadeout
OBJSFFADEOUT = fadeout.o Imagen.o inout.o

installsffadeout: $(bindir)/$(SFFADEOUT)
$(bindir)/sffadeout: $(OBJ)/sffadeout
	-rm $(bindir)/sffadeout
	cp -p $(OBJ)/sffadeout $(bindir)/sffadeout

sffadeout: $(OBJ)/sffadeout

$(OBJ)/sffadeout: $(addprefix $(OBJ)/, $(OBJSFFADEOUT))
	$(CPP) $(INCLUDES) $(CPPFLAGS) -o $(addprefix $(OBJ)/,$(SFFADEOUT)) $(addprefix $(OBJ)/, $(OBJSFFADEOUT)) -lpthread $(LIBS) $(MesaLibs)

#########################################
# reglas generales

$(OBJ)/%.o : %.cpp
	$(CPP) -c $(INCLUDES) $(CPPFLAGS)  $< -o $@

.PHONY: prueba

all: directorios $(TARGETS)

clean:
	-rm $(TARGETS)
	-rm $(OBJ)/*.o

cleanall: clean

build: clean all

install: $(subst $(OBJ),$(bindir),$(TARGETS))

directorios:
	@if [ ! -d $(bindir) ]; then mkdir $(bindir); fi
	@if [ ! -d $(OBJ) ]; then mkdir $(OBJ); fi

Utilizando el comando make sólo deberéis navegar hasta la ruta adecuada y ejecutar el Makefile:

make -k sffadeout

Recordad que para que todo funcione correctamente debéis ser fieles a la estructura que os he comentado al inicio del post. Es decir, al final debéis tener una estructura de:

• /SFFadeOut
  • /bin
  • /inc
    • Imagen.h
  • /obj
  • /src
    • fadeout.cpp
    • Imagen.cpp
    • inout.cpp
    • Makefile

Una vez compilado necesitáis un par de imágenes del mismo tamaño para provar si realmente funciona. Siendo fiel a mis anteriores artículos sobre procesamiento de imagen os animo a provar con la imagen de Lenna y una imagen negra.

Podéis ejecutar el programa con la instrucción (si las imágenes están en el directorio /SFFadeOut):

./obj/sffadeout ../lenna.png ../negro.jpg 4

El resultado con n=4 debería dar las siguientes imágenes:

Resultado con n=4.

Os dejo además un zip con todo el código estructurado en los directorios correctamente y con las imágenes de prueba que os he comentado. Para obtener mejores resultados probad con una n más alta y si queréis ver el fundido en acción os recomiendo crear un GIF animado.

Espero que os haya parecido interesante y no demasiado complicado. Seguro que hay fallos y mejoras así que os animo a todos a que expreséis vuestra opinión, sugerencias, problemas y demás en los comentarios.

Salu2!

Fuentes

Marcelo Bertalmío – http://www.tecn.upf.es/~mbertalmio/

Una vez instalado, nos disponemos a descargar la librería GLUT para Win32 desde la página de Nate Robins o directamente desde este enlace. Al descomprimir el zip descargado nos encontramos con 4 ficheros y un readme.

Ficheros de la librería GLUT para Win32

A continuación abrimos Visual C++ para empezar a configurarlo para incluir la librería. Primero vamos a Herramientas/Opciones….

Vamos a Herramientas/Opciones... para empezar a configurar.

En la ventana que se nos abre, seleccionamos en el árbol de la izquierda Proyectos y soluciones/Directorios de VC++.

Seleccionamos Proyectos y soluciones/Directorios de VC++.

En el desplegable de la esquina superior derecha seleccionamos “Archivos de inclusión“.

En el desplegable seleccionamos "Archivos de inclusión".

Hacemos clic sobre el icono de la carpeta para añadir un nuevo archivo de inclusión que podemos elegir haciendo clic en el botón con los tres puntos suspensivos. Ahí seleccionamos la carpeta de los archivos de glut (glut-3.7.6-bin).

Elegimos la carpeta glut-3.7.6-bin.

En esta misma ventana seleccionamos ahora “Archivos de biblioteca” mediante el mismo procedimiento incluyendo también la carpeta de la librería.

Realizamos el mismo procedimiento para archivos de biblioteca.

Elegimos la carpeta glut-3.7.6-bin.

Ahora debemos copiar la DLL que se incluye en el paquete de la librería en algún lugar en el que Windows la localice, por ejemplo, en C:\WINDOWS\system32.

Copiamos la glut32.dll en C:WINDOWSsystem32.

Ahora ya podemos crear un nuevo proyecto vacío mediante el menú Archivo/Nuevo/Proyecto.

Creamos un proyecto mediante el menú Archivo/Nuevo/Proyecto.

Elegimos en General, la opción de Proyecto vacío y establecemos un nombre para el proyecto, en este caso “Segmentation Fault”.

Elegimos Proyecto vacío y le damos un nombre.

A continuación, añadimos un fichero en el que incluir el código fuente haciendo clic derecho sobre Archivos de código fuente/Agregar/Nuevo Elemento….

Añadimos un nuevo fichero.

Le damos un nombre al fichero, por ejemplo, main.cpp.

Le damos un nombre al fichero.

En el nuevo fichero podemos incluir una ligera variante del código que propuse en el anterior post que os detallo a continuación:

#ifdef WIN32
#include <windows.h>
#endif

//include GLUT
#include <glut.h>

//set the macros for the window size
#define SIZEX 500
#define SIZEY 500

//initializing stuff
void init(void)
{
   glDisable( GL_DEPTH_TEST ); //triangles have two sides
   glDisable( GL_CULL_FACE ); //triangles have two sides
}

//Render one frame
void render(void)
{
   //Clear the window and the depth buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   //Render the triangle
   glBegin(GL_TRIANGLES);
   glColor3f(1.0f, 0.0f, 0.0f ); //change vertex color
   glVertex2d( -0.5f, -0.5f );

   glColor3f(0.0f, 1.0f, 0.0f ); //change vertex color
   glVertex2d( 0.5f, -0.5f );

   glColor3f(0.0f, 0.0f, 1.0f ); //change vertex color
   glVertex2d( 0.0f, 0.5f );
   glEnd();

   //Swap front and back buffer
   glutSwapBuffers();
}

int main(int argc, char **argv)
{
   //init all OpenGL stuff
   glutInit(&argc, argv); //init GLUT
   glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); //init framebuffer properties
   glutInitWindowSize(SIZEX, SIZEY); //init window dimensions
   glutCreateWindow("Segmentation Fault");  //create window

   //now that we have the window we can set the opengl state
   init();

   //set the callbacks
   glutDisplayFunc(render);  //render a frame
   glutIdleFunc(render);       //what to do when nothing happens

   //start the GLUT mainloop (this function will be executed in a loop)
   glutMainLoop();

   return 0;
}

El resultado debería ser, al igual que en la anterior entrega, un triángulo colorido.

Resultado final.

Os recuerdo, como siempre, que tenemos los comentarios para las dudas y problemas que os surjan. Salu2!

Fuentes

Javi Agenjo – http://www.tecn.upf.edu/~jagenjo/

En primer lugar debemos arrancar el entorno de desarrollo Xcode, por ejemplo desde la carpeta de Aplicaciones, y nos disponemos a crear un nuevo proyecto vacío haciendo clic en File/New Project y posteriormente, en la ventana emergente, Empty Project.

Creamos un nuevo proyecto en Xcode.

Seleccionamos proyecto vacío.

Luego debemos indicar un nombre para el proyecto. Para el ejemplo utilizaremos el nombre de “SegmentationFault”.

Damos nombre al proyecto.

Y ya tenemos el proyecto vacío creado. Ahora debemos empezar a configurarlo para que funcione con OpenGL y GLUT. Primero crearemos un nuevo Target, mediante Project/New Target o con el botón derecho encima de Targets y Add/New Target.

Añadimos un nuevo Target al proyecto.

Seleccionamos el tipo del Target como Cocoa Application y especificamos un nombre, por ejemplo, GLUT.

Seleccionamos Cocoa App como tipo de Target.

Especificamos un nombre para el Target.

A continuación se nos muestran las configuraciones por defecto del Target, de las cuales sólo deberemos modificar la entrada de GCC_PREFIX_HEADER para poner el campo en blanco. Recomiendo que utilicéis el buscador para encontrar la opción entre todas las existentes.

Configuración por defecto del nuevo Target.

Búsqueda de la entrada GCC_PREFIX_HEADER.

Eliminamos la información del campo Value.

Ahora debemos añadir a nuestro Target, los Frameworks de OpenGL y GLUT incluidos en la libraría del Sistema Operativo. Para ello clic derecho sobre el Target creado y seleccionamos Add/Existing Frameworks…

Añadimos los Frameworks de OpenGL y GLUT.

Nos aparecerá una ventana en la que deberemos seleccionar los Frameworks GLUT.framework y OpenGL.framework alojados en la carpeta /Sistema/Librería/Frameworks de nuestro disco duro. Podemos seleccionar ambos manteniendo pulsada la tecla cmd mientras clicamos.

Seleccionamos los frameworks GLUT y OpenGL de /System/Library/Framewoks.

En la ventana emergente que aparece después de seleccionarlos no modificamos nada y simplemente clicamos sobre Add.

Continuamos el proceso con las opciones por defecto pulsando Add.

Ahora ya tenemos configurado nuestro proyecto para que trabaje con las librerías OpenGL y GLUT. A continuación creamos un nuevo fichero de código fuente al proyecto para comprovar que todo funciona correctamente.

Añadimos nuevo fichero de código fuente.

Seleccionamos nuevo fichero vacío en el proyecto y especificamos un nombre, por ejemplo, main.cpp.

Seleccionamos nuevo fichero vacío.

Especificamos un nombre, p.e. main.cpp.

En el nuevo fichero podemos poner el código que os muestro a continuación que, si todo el proceso ha ido correctamente, debe renderizar un triángulo en pantalla.

//include GLUT
#include <GLUT/glut.h>;

//set the macros for the window size
#define SIZEX 500
#define SIZEY 500

//initializing stuff
void init(void)
{
   glDisable( GL_DEPTH_TEST ); //triangles have two sides
   glDisable( GL_CULL_FACE ); //triangles have two sides
}

//Render one frame
void render(void)
{
   //Clear the window and the depth buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   //Render the triangle
   glBegin(GL_TRIANGLES);
   glColor3f(1.0f, 0.0f, 0.0f ); //change vertex color
   glVertex2d( -0.5f, -0.5f );

   glColor3f(0.0f, 1.0f, 0.0f ); //change vertex color
   glVertex2d( 0.5f, -0.5f );

   glColor3f(0.0f, 0.0f, 1.0f ); //change vertex color
   glVertex2d( 0.0f, 0.5f );
   glEnd();

   //Swap front and back buffer
   glutSwapBuffers();
}

int main(int argc, char **argv)
{
   //init all OpenGL stuff
   glutInit(&amp;argc, argv); //init GLUT
   glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); //init framebuffer properties
   glutInitWindowSize(SIZEX, SIZEY); //init window dimensions
   glutCreateWindow("Segmentation Fault");	//create window

   //now that we have the window we can set the opengl state
   init();

   //set the callbacks
   glutDisplayFunc(render);  //render a frame
   glutIdleFunc(render);	     //what to do when nothing happens

   //start the GLUT mainloop (this function will be executed in a loop)
   glutMainLoop();

   return 0;
}

Y el resultado debe ser este:

Triángulo resultante del código del ejemplo.

Como siempre os digo, ante cualquier duda sabed que no cobramos por comentar. Salu2!

Fuentes

OneSadCookie – http://blog.onesadcookie.com/2007/12/xcodeglut-tutorial.html

Javi Agenjo – http://www.tecn.upf.edu/~jagenjo/

Pero además de el propio software en sí, existe un conjunto de librerías que nos permite aprovechar las funcionalidades de ImageMagick en nuestras propias aplicaciones. Hay librerías para los lenguajes de programación C, Ch, C++, Java, Lisp, Pascal, Perl, PHP, Python, Ruby y Tcl/Tk, aunque en este post me centraté en la versión para C++: Magick++.

Lo primero que deberemos hacer es descargarnos la librería desde la página web de ImageMagick. Yo he descargado la versión 6.5.1-9, sobre la que se basará el tutorial. La podéis descagar directamente desde aquí. A continuación os detallaré los pasos para instalar la librería en un entorno UNIX.

En primer lugar deberemos descomprimir el archivo. En mi caso he descargado un ZIP, por lo que podemos descomprimirlo mediante la interfaz gráfica o por terminal con:

unzip ImageMagick-6.5.1-9.zip

Una vez descomprimido accedemos al directorio adecuado y podemos observar los archivos de código fuente. Utilizaremos los tres comando básicos para compilar e instalar una librería en UNIX.

cd ImageMagick-6.5.1-9
./configure
make
sudo make install

Si todo ha ido bien, ya deberíamos tener la librería instalada y operativa para usarla en nuestro programa. ¡Vamos manos a la obra!

Para empezar, vamos a descargarnos una imagen sobre la que poder hacer nuestro primer ejemplo. ¿Se os ocurre qué imagen podemos escoger? ¡Sí amigos, Lenna! La podéis obtener de mi anterior post, en esta URL.

Ahora vamos ha realizar un pequeño programa que nos lea la imagen, nos la recorte y nos la guarde con un nombre distinto. El código es el siguiente:

#include <Magick++.h>
#include <iostream>

using namespace std;
using namespace Magick;

int main(int argc, char *argv[]) {

Image myPhoto;

try {
// Leemos la imagen "lenna-300x300.png"
myPhoto.read("lenna-300x300.png");

// Recortamos la imagen manteniendo los 150x150 píxeles
// superiores de la imagen especificando el tamaño
// en el formato (width, height, xOffset, yOffset)
myPhoto.crop( Geometry(150,150, 0, 0) );

// Guardamos la nueva imagen recortada
myPhoto.write("lenna-recortada.png");
} catch( Exception &error_ ) {
cout << 'Ha ocurrido un error: ' << error_.what() << endl;
return 1;
}
return 0;
}

Para compilarlo y ejecutarlo, navegaremos por el terminal hasta el directorio en el que tenemos el código C++ y la imagen descargada, y teclearemos el comando:

g++ ejemplo.cc -o ejemplo -l Magick++ && ./ejemplo

Dónde ejemplo.cc es el nombre del archivo con el código en C++. Utilizamos el compilador g++, que es la versión del archiconocido GCC para el lenguaje orientado a objetos. Con la opción -l Magick++ le indicamos que debe compilar/linkar la libreria Magick++.

El resultado es el siguiente:

Como podéis ver hemos conseguido recortar la imagen desde nuestro pequeño programa en C++. La librería nos permite muchísimas más opciones (hacer zoom, colorear, añadir ruido, y un larguísimo etc.) que podéis consultar en la documentación oficial. ¡Ahora ya sabéis como tratar imágenes desde vuestros programas! Si tenéis dudas utilizad los comentarios.

Fuentes:

Magick++ – http://www.imagemagick.org/Magick++/

Wikipedia – http://es.wikipedia.org/wiki/ImageMagick