I started playing around with s3cmd command line utility and I realize that is really powerful so, I decide to write my own scripts to be able to backup automatically all the important files of my servers to the cheaper and easy to use Amazon S3 service.

The whole system is based on two bash scripts, the crontab and a few extra applications like 7zip and s3cmd. I will explain step by step how I build up the system and at the end I’ll provide the full code of the scripts.

Requirements

The first step is to be sure that you have installed the 7zip and s3cmd tools, in my case I’m using ubuntu so, for me the command to install the tools is:

sudo apt-get install p7zip s3cmd

Basic setup

Now we can follow with the basic setup, I created a folder in the root of the filesystem called backups, the inside this folder I create serveral folders, at the end the structure is like follow:

/backups
    /compressed
    /data
        /db
        /svn
        /www
    /scripts

The compressed folder is used at the end of the script to compress all the files to one .7z file, in the data folder we will copy the information we want to backup and in the scripts folder we will store as it’s name says the two scripts we will use.

Backup script

Now, let’s have a look at those scripts. The first one is to do the backup, in my case I’m doing a backup of the subversion, mysql and files under /var/www.

The script starts with the following block:

echo `date '+%F %T'`: Starting the backup

#Dumping the repos
echo `date '+%F %T'`: Starting the dump of the repos
for i in /user/local/svn/*/; do
    repo=`basename $i`
    echo `date '+%F %T'`: Dumping repo $repo
    /usr/bin/svnadmin dump /usr/local/svn/$repo > /backups/data/svn/$repo.dump
    echo `date '+%F %T'`: Repo $repo dumped
done

We suppose that the svn folder is located at /usr/local/svn, basically here we are going through each folder inside /usr/local/svn/ and we call svnadmin dump to dump that repository in one file, that file is stored in /backups/data/svn/.

#Dumping the DB
echo `date '+%F %T'`: Starting the dump of the DataBases
for i in /var/lib/mysql/*/; do
    db=`basename $i`
    echo `date '+%F %T'`: Dumping DB $db
    /usr/bin/mysqldump -uroot -p$db_password $db > /backups/data/db/$db.sql
    echo `date '+%F %T'`: Database $db dumped
done

In this second block we are doing more or less the same thing, we are going through each folder on /var/lib/mysql/ and calling mysqldump to export each DB in one file stored at /backups/data/db/.

#Copy all the websites
echo `date '+%F %T'`: Starting the dump of websites
for i in /var/www/*/; do
    site=`basename $i`
    echo `date '+%F %T'`: Dumping site $site
    /usr/bin/7z a -mx6 -t7z /backups/data/www/$site.7z -p$compression_password /var/www/$site
    echo `date '+%F %T'`: Site $site dumped
done

In the third block we are dumping the websites, I have the websites stored at /var/www folder and each site is inside a folder with the domain as folder name. Basically we are doing the same, loop through /var/www/ and compressing each site individually in a .7z file with a compression level of 6 and secured with a password.
I store each site in a separate file because if I have to restore a site I don’t need to uncompress all the sites, just the main file and then the compressed site.
I was playing with different compression levels and 6 is the most suitable to maintain a good compression ratio without wasting a lot of time.

#Compressing all the data
echo `date '+%F %T'`: Compressing the info
filename=$(date +%Y%m%d)
/usr/bin/7z a -mx6 -t7z /backups/compressed/$filename.7z -p$password /backups/data/*
echo `date '+%F %T'`: Info compressed

Now with all the information we want to backup in place we will compress all together in one single file, that’s the purpose of this block of code, the final filename is a timestamp of today using the date command.

#Upload to Amazon S3
echo `date '+%F %T'`: Uploading to Amazon S3
/usr/bin/s3cmd put --no-progress /backups/compressed/$filename.7z s3://BUCKET_NAME/$filename.7z
echo `date '+%F %T'`: Upload completed

Ok, we have the compressed file and one of the final steps is upload this file to Amazon S3. For that task we are using the s3cmd tool passing the parameter –no-progress to avoid an “interactive” output of the upload status.

#Delete the local backups
echo `date '+%F %T'`: Cleaning up
rm -Rf /backups/data/svn/*
rm -Rf /backups/data/db/*
rm -Rf /backups/data/www/*
rm -Rf /backups/compressed/*
echo `date '+%F %T'`: Clean completed
echo `date '+%F %T'`: Backup completed

And the final block of code is just a clean up, after the upload to amazon we delete all the files we have generated inside the /backups folder.

Ok, seems complex but is pretty strightforward, also if you take a look you’ll see that all the messages contains a timestamp, with that information we are able to determine how many time we spend in each task.
One disadvantage of this script is that we are not checking if the file was uploaded correctly to Amazon, maybe this will be a future improvement.

Maintenance script

Now let’s take a look at the other script, the purpose is just delete old backups based on a timestamp, in my case we’re storing the backups for one month, it’s very affordable with the Amazon prices.

for filename in `s3cmd ls s3://$bucket`; do
    if [[ $filename =~ ([0-9]*)\.7z ]]; then
        timestamp=${BASH_REMATCH[1]}
        echo `date '+%F %T'` - Reading metadata of: $filename
        echo -e "\tFilename: $filename"
        echo -e "\tTimestamp: $timestamp"
        if [[ $timestamp -le $limit ]]; then
            let "total=total+1"
            echo -e "\tResult: Backup deleted\n"
            /usr/bin/s3cmd del $filename
        else
            echo -e "\tResult: Backup keeped\n"
        fi
    fi
done

This is the only code block we have in the maintenance script, the idea is to retrieve the list of files we have in the bucket with s3cmd, then we check if the gived part contains the pattern ([0-9]*)\.7z (because the command s3cmd ls gives more information rather than just the filenames).
If we detect a segment that matches the regex we get the filename without the extension (the timestamp of the backup), and we check in this case if the timestamp is older than one month (the timestamp of one month ago is stored in the $limit variable). If the backup is older we remove it calling the s3cmd del command.

If you need to store the files more time just change the $limit variable and that’s it.

Wow, seems a large process, ok, now let’s have a look at the last step to let this work, the cronjobs.
I created to cronjobs and redirected the output of them to the stdout because I want to receive an email after the backup, my crontab look like this:

# m h  dom mon dow   command
MAILTO=YOUR_EMAIL_ADDRESS_HERE
00 22 * * * /backups/scripts/s3backup 2>&1
00 23 * * * /backups/scripts/s3backup-maintenance 2>&1

Just put there the values you want to run the crons and don’t forget to put at the end 2>&1.

Conclusion

With this system you’ll have your backups in a safe and cheap place without headaches and with a full report in you email every time the script runs. For sure these scripts can be impoved with a few checks and you can extend it to fit your needs.
I hope you have enjoyed this HowTo and begin to use this scripts! For sure improvements are welcomed, don’t hesitate to comment!.

Source code

Grab the full source code of the backup script and the maintenance script.

We will try to get the same effect as the image below:

To create this effect you have to add the following lines on the html file:

<div class="background">
   <div class="white">This is an exemple with the CSS opacity property</div>
</div>

The first div have the class “background” to put a standard background and the second div is inside the first div to put another background called “white” over the first background.

Now you can customize the classes with the following attributes and values on your css file:

.background{
 background-image: url(caracol.png);
 width: 300px;
 height: 208px;
 border: 1px solid #000000;
}

.white{
 background-color: #ffffff;
 width: 250px;
 height: 158px;
 border: solid 1px #000000;
 margin: 25px 25px;
 opacity: 0.6;
 filter:alpha(opacity=60);
}

The class “background” contains an image background, the class “white” contains a background color with the opacity property to obtain the transparent effect. The attribute “opacity: 0.6;” is for Firefox and the values can go from 1.0 to 0.0, to be able to show this effect in IE you have to use the following code  “filter:alpha(opacity=60);” and the possible values can go from 100 to 0.

Remember to put the Doctype declaration on your HTML file to avoid the problems with the diferents bowsers and also write a stardard code.

I hope you enjoy it and do not hesitate if you have any doubt.

The tricky point was that the Array could contain more Arrays so we had to write a recursive function to accomplish our objective.

Tudor, at the end, gave the following method to be able to do the conversion.

/**
 * Recursively converts an array to a stdClass object
 *
 * @param array $array
 * @return stdClass
 */
 protected function _convertToStdObject(array $array){
   $obj = new stdClass();
   foreach($array as $key => $value) {
     if(!is_array($value)) {
       $obj->{$key} = $value;
     }else{
       $obj->{$key} = $this->_convertToStdObject($value);
     }
   }

   return $obj;
 }

Maybe, in the next interviews we will do to our PHP Developers candidates, we will ask about this and see how they solve the problem

Antes de nada debo decir que estos son los pasos que he seguido para instalar XDebug para PHP 5.2 usando MAMP Pro 1.8.4 bajo MacOS X Snow Leopard. Es posible que, si tenéis una configuración distinta, los pasos puedan variar un poco.

En primer lugar debemos descargarnos los binarios de XDebug en esta URL: http://aspn.activestate.com/ASPN/Downloads/Komodo/RemoteDebugging.

Descomprimimos el archivo .tgz que nos acabamos de descargar y veremos que hay una estructura de directorios que representa las diferentes versiones de PHP. Yo actualmente estoy utilizando PHP 5.2 (la que en estos momentos incluye por defecto MAMP y MAMP Pro) así que copiaré el fichero xdebug.so que hay dentro de esta carpeta.

Este archivo xdebug.so deberemos copiarlo en el directorio de extensiones de PHP, en MAMP es /Applications/MAMP/bin/php5/lib/php/extensions/no-debug-non-zts-20050922/.

Ahora deberemos añadir algunas líneas a nuestro php.ini para activar y configurar la extensión. La localización habitual del fichero php.ini en MAMP es /Applications/MAMP/conf/php5/php.ini pero (¡OJO!) si utilizáis MAMP Pro las modificaciones en este fichero serán en vano. Esto es debido a que MAMP Pro carga su propia copia del php.ini que se localiza en /Applications/MAMP PRO x.x.x/MAMP PRO.app/Contents/Resources/php5.ini (accediendo haciendo clic con botón derecho sobre la app de MAMP Pro y “Mostrar contenido del paquete“).

Una vez localizado el php.ini adecuado, debemos añadir la siguiente línea:

[xdebug]
zend_extension="/Applications/MAMP/bin/php5/lib/php/extensions/no-debug-non-zts-20060613/xdebug.so"

Si utilizáis el editor TextMate para programar, añadid también esta línea a continuación para que el debugger muestre los errores como enlaces a TextMate en la línea correcta:

xdebug.file_link_format = "txmt://open?url=file://%f&line=%l"

Si además váis a utilizar MacGDBp para debuggar y queréis que se ejecute el debugger por defecto (si lo tenéis abierto) podéis añadir también (sino deberéis añadir ?XDEBUG_SESSION_START=macgdbp a vuestra URL cada vez para iniciar el debugger):

xdebug.remote_enable = On
xdebug.remote_autostart = 1

Para que funcione todo correctamente posiblemente deberemos desactivar el Zend Optimizer, que viene activado por defecto en MAMP.  Para ello, comentamos las siguientes líneas:

;zend_optimizer.optimization_level=15
;zend_extension_manager.optimizer=/Applications/MAMP/bin/php5/zend/lib/Optimizer-3.3.3
;zend_optimizer.version=3.3.3

Ahora debéis reiniciar el servidor Apache y ya podréis comenzar a debuggar vuestras aplicaciones en PHP. Si ha funcionado ya os daréis cuenta de que los errores se muestran en una tabla muy colorida y hay una mejora muy sustancial a la hora de mostrar los resultados de var_dump.

Espero que os sea de utilidad y si tenéis problemas acudid a los comentarios para intentar resolverlos entre todos. ¡Salu2!

Fuentes

debuggable.com – http://debuggable.com/posts/setting-up-xdebug-on-mac-os-x-or-win32-linux:480f4dd6-0240-4a90-8fa1-4e41cbdd56cb

Techno Sophos – http://technosophos.com/content/debugging-your-php-code-xdebug-mamp-textmate-and-macgdbp-support

Desde la versión 4 de PHP existen dos funciones muy útiles para estos menesteres, fgetcsv y  fputcsv.

Según la documentación PHP la firma de esta función es la siguiente:

array fgetcsv (resource $handle [,int $length [,string $delimiter = ',' [,string $enclosure = '"' [,string $escape = '\\']]]])

Como podemos ver, el primer parámetro a proporcionar es el puntero al fichero que queremos leer y después toda una serie de parámetros opcionales como la dimensión de la cadena a leer, el delimitador de campos, el carácter de envoltorio de campos y el carácter para escapar símbolos poco comunes. Esta función, al ser llamada con los parámetros correctos, devolverá la línea que ha leído en formato de array, donde cada campo será una nueva entrada en el array.

Bien, en este punto y antes de mostrar un trozo de código tengo que hacer mención a un detalle, esta función puede ocasionar algunos problemas dependiendo del sistema operativo en el que estemos corriendo PHP. En mi caso, utilizando Mac OS X Snow Leopard, me he encontrado que la función no detecta bien el final de la línea con lo cuál, y para ahorrarnos problemas, vamos a utilizar también la siguiente instrucción:

ini_set('auto_detect_line_endings', TRUE);

Esta línea lo que hace es forzar a detectar el final de línea, lo que resuelve el problema en dichas plataformas.

Dicho todo esto, voy a mostrar un trozo de código que lo que hace es recorrer el fichero y generar una array de arrays con todo el fichero parseado.

<?php

//Prepare the auto detect line endings for some OS's
ini_set('auto_detect_line_endings', TRUE);

//Save the path to the file we want to open
$file = dirname(__FILE__) . 'test.csv';

//Create a file pointer to de file in read mode
$fp = fopen($file, 'r');

//Setup the result var
$parsedCSV = array();

/* Get the headers of the csv and store it in a special key in the array. Setting the max length to 0 strip the length constrain */
$parsedCSV['headers'] = fgetcsv($fp, 0, ',');

/* Loop to read the entire file, take a look at the comparison and remember that if fgetcsv arrives at the end of the file a FALSE will be returned. We use this to detect the EOF */
while(($line = fgetcsv($fp, 0, ',')) !== FALSE){
    $parsedCSV[] = $line;
}

//Print out the array
die(var_dump($parsedCSV));

Para detectar el final de fichero en este script estamos usando la comparación ($line = fgetcsv($fp, 0, ‘,’)) !== FALSE ya que fgetcsv devuelve FALSE en caso de error o EOF (End Of File).

Espero que este post os sea de ayuda y recordad que podéis preguntarnos mediante el sistema de comentarios.

Si nuestra aplicación sigue el paradigma de la orientación a objetos debemos almacenar el estado del objeto para recuperarlo a posteriori. Un posible enfoque sería almacenar toda esa información en una base de datos y trabajar así con un sistema gestor de base de datos (SGBD) como MySQL. Pero existe un inconveniente en este caso, que la mayoría de SGBD son relacionales y nuestro programa sigue el modelo de la orientación a objetos (OOP) y la conversión entre modelos muchas veces no es obvia.

La alternativa que pretendo explicaros en este post es la serialización de los objetos para que sean almacenados en ficheros de texto, dándo así persistencia a nuestras aplicaciones. Me he decidido a realizar la explicación en Python su excelente mecanismo para la serialización de objetos, Pickle.

Para el post he creado una sencilla clase llamada SFSaludador que se encarga de saludar al usuario imprimiendo un “Hola!” por pantalla. El objeto guardará el total de saludos y esa información se hará persistente en un fichero llamaso “sfsaludador.txt” serializanso mediante Pickle. Os dejo el código a continuación:

import os
import pickle

class SFSaludador(object):
	"""Clase SFSludador"""

	def __init__(self, totalSaludos):
		super(SFSaludador, self).__init__()
		self.__totalSaludos = totalSaludos

	def saluda(self):
		"""Saluda"""
		print "Hola!"
		self.__totalSaludos += 1

	def getTotalSaludos(self):
		"""Devuelve el total de saludos"""
		print "He saludado " + str(self.__totalSaludos) + " veces."

	def load(self):
		"""Obtiene la informacion del archivo"""
		dataFile = open('sfsaludador.txt','r')
		self.__totalSaludos = pickle.load(dataFile)
		dataFile.close()

	def write(self):
		"""Graba los datos en el fichero"""
		dataFile = open('sfsaludador.txt','w')
		pickle.dump( self.__totalSaludos, dataFile)
		dataFile.close()

def main():
	"""Main function"""

	miSaludador = SFSaludador(0)

	if (os.path.exists('sfsaludador.txt')):
		print("Archivos encontrados. Cargando...")
		miSaludador.load()
	else:
		print("Archivos no encontrados...")

	miSaludador.getTotalSaludos()
	miSaludador.saluda()
	miSaludador.getTotalSaludos()

	miSaludador.write()

if __name__ == '__main__':
	main()

Para ejecutar el programa utilizaremos el intérprete de Python por consola de la siguiente forma (en entornos UNIX):

python SFSaludador.py

Dónde SFSaluadador.py es el fichero con el código de nuestro programa de ejemplo.

La primera vez que ejecutamos el programa no encontrará ningún fichero (así nos lo comunicará nuestra aplicación) y será al final de esta ejecución cuando creará el fichero con el estado del objeto para cargarlo en siguiente ejecuciones. Si volvemos a ejecutarlo vemos como esta vez si encuentra el fichero y el total de saludos tiene en cuenta los saludos de ejecuciones anteriores.

A veces Pickle puede llegar a ser un poco lento si necesitamos serializar muchos ficheros. Para solucionar esto existe una implentación de la librería realizada en el lenguaje de programación C, llamada cPickle. Si queremos hacer uso de ella sin tener que realizar modificaciones en nuestro código solo debemos sustituir el import de la librería por:

import cPickle as pickle

Espero que con este breve post haya podido haceros llegar la idea de la persistencia de datos en ficheros y su implementación en el potente lenguaje Python. Como siempre, ¡os espero en los comentarios!

Uno de esos widgets es el acordeón. Al clicar en los títulos se extienden mostrando el contenido de estos.

Para realizar este efecto nos basaremos en el ejemplo de la propia web de jQuery UI dónde podréis comprobar otros efectos muy interesantes.

En primer lugar crearemos un documento html en el que añadiremos las diferentes secciones con sus correspondientes títulos y contenidos, nosotros en este ejemplo utilizaremos 3 secciones:

<div id="accordion">
 <h3><a href="#">Section 1</a></h3>
 <div>
 <p>
 Content
 </p>
 </div>
 <h3><a href="#">Section 2</a></h3>
 <div>
 <p>
 Content
 </p>
 </div>
 <h3><a href="#">Section 3</a></h3>
 <div>
 <p>
 Content
 </p>
 </div>
</div>

Hemos asignado la id “accordion” al div principal porque será el que le diremos a JQuery UI que utilice para montar el acordeón.

Para poder hacer uso de las librerías de jQuery el procedimiento es como el que utilizamos en otro post para incluir Prototype y Scriptaculous, la primera es descargarnos las librerías desde la web y llamarlas desde nuestro html y la segunda es incluirlas directamente desde la web oficial. Nosotros las incluiremos directamente desde la web oficial.

Para ello hay que añadir las siguientes líneas de código:

<link rel="stylesheet" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/themes/redmond/jquery-ui.css" type="text/css" media="all" />
<script type="text/javascript" charset="utf-8" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
<script type="text/javascript" charset="utf-8" src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js"></script>

La primera línea incluye el estilo visual. En este caso hemos utilizado el estilo “Redmond” pero ya veréis que en la web de jQuery UI tenéis mucha variedad y con la posibilidad de modificarlos desde la misma web con una interfaz gráfica.

Por último añadimos el script que coge el div “accordion” y llama al método accordion() que es el que monta el acordeón propiamente dicho:

<script type="text/javascript">
$(function() {
$("#accordion").accordion();
});
</script>

Y este es un ejemplo del resultado final:

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/

PHP posee en su librería estándar una función llamada mail() que nos va a permitir realizar esta tarea de una forma sencillísima. Como todas las funciones de este lenguaje, está perfectamente documentada en la web. Sin entreteneros más, os pongo el código:

<?php
$to = "test@segmentationfault.es";
$subject = "Segmentation Fault Mail From PHP";
$body = "This is a mail sent from PHP";
$headers = "From: gabi@segmentationfault.es" . "\r\n";

if (mail($to,$subject,$body,$headers)){
  echo "Mail successfully sent";
} else {
  echo "Error: mail could not be sent";
}

?>

A la función mail() le pasamos los parámetros:

• $to : dirección de correo a quien queremos enviar el mail.
• $subject : asunto del mail.
• $body : aquí incluiremos el cuerpo del mensaje.
• $headers (opcional): Aquí podemos incluir cabeceras específicas en el mail. En este caso hemos especificado la dirección del remitente, pero se pueden incluir más opciones.

Como la función mail() de PHP retorna un bool (true/false) podemos utilizarlo para identificar si el mail se ha enviado de forma satisfactoria o no y comunicárselo al usuario.

Ahora ya sabemos cómo enviar mail de texto simple mediante PHP. Pero no nos vamos a quedar sólo aquí, ahora vamos a aprender cómo enviar mails con contenido HTML (la base de cualquier boletín).

<?php

$to = "test@segmentationfault.es";
$subject = "Segmentation Fault Mail From PHP with HTML content";

$body = "<html><head>";
$body .= "<title>Segmentation Fault Mail From PHP with HTML content</title>";
$body .= "</head><body>";
$body .= "<h1>Segmentation Fault</h1>";
$body .= "<p>This is a <b>simple HTML mail</b> sent from PHP. You can know how to do it in <a href=\"http://segmentationfault.es\">SegmentationFault Blog</a>.</p>";
$body .= "</body></html>";

/* Headers necesarios para enviar contenido HTML */
$headers = "MIME-Version: 1.0" . "\r\n";
$headers .= "Content-type:text/html;charset=iso-8859-1" . "\r\n";

$headers .= "From: gabi@segmentationfault.es" . "\r\n";
$headers .= 'CC: noemi@segmentationfault.es' . "\r\n";

if (mail($to,$subject,$body,$headers)){
  echo "Mail successfully sent";
} else {
  echo "Error: mail could not be sent";
}

?>

En este segundo ejemplo, el cuerpo del mensaje es contenido HTML y para poder enviarlo necesitamos incluir headers adicionales. Además, hemos añadido un CC para mostrar cómo incluir diversos destinatarios de un mismo mail.

¡Enhorabuena! Ya sabéis enviar mails desde PHP de una forma rápida y simple. Si surgen dudas, haced uso de los comentarios. Salu2!

Fuentes

Documentación PHP – http://es.php.net/manual/en/function.mail.php

W3Schools – http://www.w3schools.com/php/func_mail_mail.asp

En primer lugar nuestra clase ciudadano va a necesitar guardar dos valores referentes al ciudadano al que representa, el primer dato será el material genético a guardar y el segundo caso el fitness actual del ciudadano, para ello emplearemos dos variables privadas ya que queremos controlar exactamente que se almacena en estas variables. Por lo tanto para poder manipular y ver estos datos vamos a necesitar los respectivos setters/getters.

Por último necesitaremos crear una función para calcular el fitness del ciudadano.

El fitness va muy ligado al problema a resolver, en nuestro caso como estamos desarrollando un Hello World el algoritmo va a tratar de llegar a una string objetivo a partir de una string aleatoria, con lo cuál una buena función de fitness debe atorgar una puntuación mas alta o baja dependiendo de lo cerca que estemos del objetivo. En mi caso voy a calcular la distancia entre las letras de la cadena objetivo y la cadena del ciudadano actual.

Atención, no me estoy refiriendo a la distancia Levenshtein. La distancia Levenshtein es el número mínimo de operaciones requeridas para transformar la cadena A en la cadena B, por ejemplo si tenemos la cadena “Manzana” y queremos conseguir “Manzanas” la distancia Levenshtein será 1.

Nuestra función de fitness para calcular lo bueno que es nuestro ciudadanos  va a sumar la diferencia carácter a carácter entre la string objetivo y la string actual a partir del número correspondiente ASCII de los caracteres. Es decir, entre la letra “A” (número 65 en la tabla ASCII) y la letra “P” (número 80 en la tabla ASCII) nuestra función debería retornar el número 15. Por lo tanto si tenemos la cadena “Manzana” y la cadena “Manzano” nuestra función retornará 14.

Cabe destacar que para que el algoritmo funcione correctamente hay que establecer unas cuantas limitaciones, de momento debemos establecer que las strings siempre van a ser del mismo tamaño, es decir en el momento de comparar las strings en nuestra función de fitness vamos a suponer que las strings miden lo mismo.

Por otra parte también quiero hacer notar que en el constructor de la clase inicializamos los datos de las variables, el fitness a -1 y el string a vacío.

Sin mas dilaciones aquí os dejo el código completo de nuestra clase Citizen.

<?php

class Citizen{

 private $data;
 private $fitness;

 public function __construct(){
   $this->data = '';
   $this->fitness = -1;
 }

 public function getData(){
   return $this->data;
 }

 public function setData($newData = NULL){
   try{
     if(!is_null($newData)){
     $this->data = $newData;
     }
   }catch(Exception $e){
     die($e->getMessage());
   }
 }

 public function getFitness(){
   return $this->fitness;
 }

 public function setFitness($newFitness = NULL){
   try{
     if(!is_null($newFitness)){
     $this->fitness = $newFitness;
     }
   }catch(Exception $e){
     die($e->getMessage());
   }

 }

 public function calculateFitness($objective = NULL){
   try{
     if(is_null($objective)){
       throw new Exception('Error, no se ha especificado objetivo');
     }

     $fitness = 0;
     for($x=0;$x<strlen($objective);$x++){
       $fitness += abs(ord($objective[$x]) - ord($this->data[$x]));
     }

     $this->setFitness($fitness);
   }catch(Exception $e){
     die($e->getMessage());
   }

 }

}

?>