Archivo de la etiqueta: escaner

Indexar y buscar ficheros PDF

Bueno, PDF o de cualquier otro tipo. También en djvu, o documentos Word. Si usas tu escaner para gestión documental, sabrás apreciar esto porque tendrás un montón de PDF o DJVU en tu disco duro, y a veces querrás localizar uno de ellos según lo que contengan.

Te recomiendo Recoll, una herramienta basada en Qt, que es  bastante completita y fácil de usar. Está en los repositorios de Ubuntu, así que no deberías tener ningún problema para instalarla.

Eso si, Recoll necesita algunos programas para mejorar sus búsquedas. No son imprescidibles, pero ampliará los ficheros en los que puede buscar.

  • Haz un «apt-get install antiword» para instalar antiword.
  • Haz un «apt-get install djvulibre-bin para instalar djvutxt
  • Haz un «apt-get install aspell-es» para instalar los diccionarios castellanos de Aspell.

Vale, y además puedes editar tu «/etc/crontab» como root para añadir recollindex, una utilidad incluida en el paquete que reindexa tu disco duro. Por ejemplo, puedes añadir esto a tu «etc/crontab»:


24 * * * * lacofi  recollindex

Lo que significa que cada hora, a esa hora y 24 minutos, el usuario «lacofi» reindexará de nuevo su disco duro.

Hala, que lo disfrutes.

Marcar con fosforito los PDF.

Sip. Soy de los que con los apuntes hacían verdaderas escabechinas, marcando aquí y allá con fosforitos de colorines. Pero como ya sabes si me vienes siguiendo, ahora ya no uso papel prácticamente para nada: en lugar de eso lo escaneo todo y lo meto en el disco duro, que es más práctico y ocupa menos sitio. Salvo que el papel en cuestión sea un certificado, claro, o una garantía o un justificante… y poquitas más excepciones. La cuestión es cómo trabajar en pantalla como lo hacía en papel: con mis fosforitos, bolígrafo para hacer anotaciones y todas esas cosas.

Y es un problema porque resulta que, aunque hay lectores de PDF razonablemente buenos para linux (no excelentes, pero si buenos), no ocurre lo mismo con editores, o al menos lectores que permitan añadir comentarios, marcadores o resaltados.

Vaya, que no hay ninguno que yo sepa.

La esperanza la tengo puesta en Foxit Reader, un software para Windows que tiene una versión nativa para Linux. Muy rápida y ligera, por cierto, pero en inglés y sin las funcionalidades necesarias para añadir los comentarios ni resaltados que sí tiene la versión Windows.

Digo que tengo la esperanza puesta en ellos porque en su Web anuncian claramente y sin tapujos que su versión Linux no incluye nada de eso pero están trabajando para que sí lo incluyan próximas versiones, incluido también el soporte de múltiples idiomas, castellano incluido.

Buen software para Windows y buenas promesas para Linux. De momento no tenemos nada más que eso.

Hasta que Foxit cumpla lo prometido, habrá que conformarse con algún parche como el que yo te propongo: utilizar un programa Windows en tu Linux, gracias a Wine.

Concretamente, mi propuesta es el programa PDF-XChange Viewer, de la empresa Tracker Software Products. Tienen varios programas relacionados con los PDF, muchos de pago aunque con precios razonables. El visor más básico (PDF-XChange Viewer), resulta que es gratuito, no es tan básico como podrías pensar, e incluye todo lo que puedes necesitar normalmente, incluida la posibilidad de añadir o editar marcadores, resaltados, anotaciones, etc…

Y funciona perfectamente en Wine. Solo tienes que instalar el emulador (perdón… Wine Is Not an Emulator… ;-) con el típico comando «apt-get install wine» y después descargarte el fichero instalador de PDF-XChange Viewer, darle permisos de ejecución y ejecutarlo a golpe de click de ratón para que te lo instale en tu escritorio.

PDF con Wine

Y ahora me preguntarás… «¿y si uso un dispositivo móvil con Android?«.

Pues Repligo Reader, de Cerience Corporation, claro. Vamos, vamos, puedes hacer preguntas mucho mejores que esa… :-P

He actualizado mi Gentoo y ahora XSane no me detecta el escáner

Este problema me ha ocurrido en una de las últimas actualizaciones periódicas de mi Gentoo. Gentoo se mantiene al día con un solo comando «emerge -uDk world», que si lo haces con cierta frecuencia te mantiene todo el sistema como si lo acabaras de instalar nuevecito. Solo tienes que pararte un poco para actualizar las configuraciones. Afortunadamente es un proceso que está muy bien automatizado a través de la utilidad «dispatch-conf», que prácticamente piensa por sí misma y solo te pregunta cuando tiene dudas (y aprende sobre la marcha, con lo que una vez resueltas las dudas es muy probable que ya no vuelva a preguntar).

Pero recientemente debí meter la pata, y XSane dejó de detectar mis escáners (tengo dos, un Canon Lide 30 y un HP Scanjet 6300C con alimentador automático de hojas). Curiosamente, ambos eran detectados correctamente por sane-find-scanner, pero no por XSane ni tampoco por xscanimage.

Y el problema estaba en la configuración, así que estoy seguro de que cometí un error contestando a alguna pregunta que me hizo dispatch-conf. Concretamente, mi fichero /etc/sane.d/dll.conf quedó completamente vacío, con lo que sane no podía utilizar ninguno de los backend disponibles.

La solución es muy sencilla, casi un trámite. Vete a la página de SANE, concretamente al listado de fabricantes y busca el modelo de tu escáner en la tabla correspondiente a su fabricante. A la derecha, encuentra cuál es el backend apropiado para ese modelo concreto y luego mete el nombre del backend en el fichero /etc/sane.d/dll.conf. Si tienes varios escáners, entonces tendrás que poner un nombre de backend por cada línea. En mi caso, el fichero contendrá esto:

 
# sane backends para el Canon Lide 30 y HP Scanjet 6300C con ADF:
plustek
hp

Ya ves qué facil. ;-)

Escanear para gestión documental con DjVu

En mi trabajo se acumulan una enorme cantidad de papeles, asi que no quiero ni pensar lo que le ocurrire por ejemplo a un abogado. Pero en fin, la cuestión es que los dispositivos de almacenamiento masivo (por ejemplo, discos duros externos USB) han bajado tanto de precio que hoy en dia resulta muy factible ponerse a escanear como un loco y convertir nuestro ordenador en una máquina de microfilmado.

En realidad ésta es una vieja idea que me rondaba en la cabeza desde hace años. De hecho, en su día (cuando usaba Windows), manejaba habitualmente el Pagis Pro de Xerox, un programa que me encantaba. Pero dejé de hacerlo porque tropecé con muchas limitaciones técnicas propias del momento (discos duros pequeños, escaner lentiiiisimo a pesar de ser SCSI, etc). Hoy, ya no tengo Windows ni Pagis Pro, claro, pero el escaneo documental en forma de microfilmado o facsimil (Gestión Documental, que se llama) es ya rentable porque la tecnología ha mejorado mucho. Solo necesitamos un programa Linux que lo permita hacer de forma decente, y aunque éste es un capítulo pendiente en el mundo Linux, todavía podemos hacer cosas bastante interesantes con DjVu.

DjVu es la versión libre (aunque limitada) de un programa comercial creado por la empresa LizardTech. Lo que hace, concretamente, es tomar una imagen (PNM, por ejemplo), y comprimirla con algoritmos terriblemente eficientes. Parece una tontería, un compresor vulgar, pero os aseguro que es espectacular. Para que os hagais una idea, una imagen BW (Lineart), tomada de una página A4 a 300 dpi, pasa de 1,1 Mb (PNM) a 32 Kb (DjVu). Si, habeis oído bien: ¡¡32 Kb!!.

Djvu incluye tres compresores diferentes y unas cuantas utilidades. Los compresores son:

  1. cjb2: es el más importante y eficiente. Necesita imágenes Lineart (BW, imágenes de 1 bit), con lo que se usa para páginas de texto o con gráficos muy simples, sin gradación de grises. Parece limitado, pero en la práctica casi todas (si no todas) las páginas que vamos a escanear en Gestión Documental son precisamente de este tipo.
  2. cpaldjvu: es muy eficiente, pero solo con un tipo de imágenes de pocos colores y grandes áreas monocromáticas, por ejemplo capturas de pantalla. Es muy ineficiente con imagenes fotográficas que incluyan gradación de colores o de grises (es decir, la mayoría). En la práctica, yo no lo uso casi nunca.
  3. c44: es un compresor de imágenes fotográficas, ya sea en escala de grises o en color. Muy eficiente, con una compresión superior a la de otros formatos como JPEG.

Y para redondear, DjVu es un formato multipágina. Es decir, en un único fichero se almacenan todas las páginas de nuestro documento. Las páginas pueden ser de distinto tipo: la primera en color y las siguientes en BW, por ejemplo. El paquete de software también incluye otras utilidades adicionales así como un programa visor, DJView, que te permite ver los documentos microfilmados en Linux, pero para eso probablemente te sea más práctico usar Evince.

El programa comercial de Lizardtech es mucho más sofisticado que todo esto. Para que te hagas con la idea, lo que viene a hacer es tomar una página, sea como sea, por ejemplo con mezclas de diferentes tipos de gráficos y texto, y descomponerla adecuadamente para que los diferentes compresores hagan su trabajo, y luego ensamblarlo todo de nuevo en una única página DjVu que parece idéntica al documento original. Todo automáticamente. Puedes ver cómo sería, haciendo pruebas con ficheros PNM en el servidor Any2Djvu, que utiliza software de Lizartdtech para hacer las conversiones gratuitamente a quien lo solicite (eso si, es lento, ya te lo advierto).

Sinceramente, DjVu es tan práctico y eficiente, que he llegado a plantearme comprar el software comercial de Lizardtech. La versión profesional vienen a ser algo más de 300 euros, un poco caro pero asumible si de verdad lo vas a usar. El problema es que la versión profesional solo existe para Windows. Aaaaagh!. Hay otra versión, más avanzada, que es la versión empresarial y que sí incluye software Linux, pero el precio se vuelve inadmisible para un particular. Ya conoceis mi filosofía: no me gusta el pirateo, así que si no lo puedo comprar, no lo uso y punto. Afortunadamente, casi todo lo que vamos a necesitar puede apañarse perfectamente con el software libre de DjVu y unos cuantos scripts. Así que a ello vamos.

Lo que sigue son una serie de scripts personalizados para crear ficheros DjVu y organizarlos en una base de datos. Todo muy práctico para mi mismo, pero seguramente demasiado personalizado para tí, porque tendrás que adaptar o escribir de nuevo todos los scripts para que te funcionen en tu máquina. Al menos, servirá para darte unas cuantas ideas si sabes cómo programar scripts. Si no, seguramente preferirás algo más automático que funcione sin necesidad de hacer ninguna modificación al script, así que mejor échale un vistazo a mi script«escaneo», que lo hace todo de forma simple y automática. De nada. ;-)

Para organizarlo todo, vamos a suponer unas pocas cosas bastante elementales:

  1. Que tienes un escaner funcionando, lógicamente. En mi caso, se trata de un Canon Lide 30 USB, pero podría ser cualquier otro. Esto significa que tienes instalado y configurado SANE, y que el comando «scanimage -L» es capaz de identificar correctamente tu escaner.
  2. Que tienes instalado el programa xhkeys, que permite asignar comandos a una tecla especial del teclado. En el caso de Gentoo, solo tienes que hacer un «emerge xhkeys».
  3. Que arrancas una sesión en modo gráfico. En realidad, no es imprescindible: Para crear documentos DjVu podrías hacerlo todo perfectamente desde una consola (por ejemplo, podrías seguir almacenando documentos mientras está logada tu mujer, o desde una máquina remota de tu red local). Pero sí es necesaria una sesión gráfica para ver los documentos creados, claro. En mi caso, utilizo KDE, pero puede que tú uses otra cosa, como Gnome, o WindowMaker.
  4. Que tienes instalado DjVu, lógicamente. Si no es así, tienes que bajártelo y compilarlo o instalarlo de la forma adecuada para tu distribución Linux. En mi caso es Gentoo, así que me basta con un «emerge djvu», porque está incluido en los repositorios.
  5. No es imprescindible, pero te recomiendo también que instales GSDjVu, que es una utilidad que convierte los ficheros PDF a DjVu. No está incluido en los repositorios ni en el paquete principal de DjVu, porque su licencia es distinta (CPL en lugar de GPL), así que hay que compilarlo aparte. Las instrucciones son muy claras, así que no deberías tener problemas. Esto te proporciona un nuevo comando: «djvudigital», que transforma un PDF a DjVu de alta calidad.

Vale, ahora tienes que crear un archivo ejecutable que se llame /etc/scanbuttond/sbd-scan.sh y que contenga lo siguiente:

#!/bin/bash
device=`scanimage -L | grep plustek | cut -c 9-30`
tmpfile="$HOME/scan/scan"
ancho="215mm"
alto="295mm"
sonido="/usr/share/sounds/radarping.wav"

modo="Lineart"

if [ "$modo" = "Lineart" ]; then
  programa=cjb2
else
  programa=c44
fi

if [ -f $HOME/scan/.num ]; then
	touch $HOME/scan/.num
else
	echo 0 > $HOME/scan/.num
fi

reg=`cat $HOME/scan/.num`
num=`expr $reg + 1`
echo $num > $HOME/scan/.num
if [ $num -lt 100 ]; then
	corr="0"
else
	corr=""
fi
if [ $num -lt 10 ]; then
	recorr="0"
else
	recorr=""
fi
num=${corr}${recorr}${num}
scanimage --device-name ${device} --format pnm --mode $modo \
	 --resolution 300 -x $ancho -y $alto > ${tmpfile}${num}.pnm

$programa ${tmpfile}${num}.pnm ${tmpfile}${num}.tmp
djvm -c ${tmpfile}${num}.djvu ${tmpfile}${num}.tmp
rm ${tmpfile}*.tmp
if [ "$num" = "001" ]; then
	cp ${tmpfile}${num}.djvu ${tmpfile}_fichero.djvu
	chown lacofi:users ${tmpfile}_fichero.djvu
else
	djvm -i ${tmpfile}_fichero.djvu ${tmpfile}${num}.djvu
fi

sudo -u lacofi artsplay $sonido &

Vale, ahora fijaos en las líneas marcadas en color verde. Vamos a comentarlas un poco, porque son las que debeis configurar para vuestro sistema. El resto debería funcionar sin ningún cambio en cualquier ordenador.

En primer lugar, la linea «device=» debe indicar a tu escaner. En mi caso, el Canon Lide 30 es identificado como un Plustek porque usan el mismo chip. Ejecuta un «scanimage -L» a mano para hacerte una idea de cómo es identificado tu escáner y qué cadena tienes que poner después del grep.

En segundo lugar, la entrada «tmpfile» debe apuntar a un directorio vacío y que exista, y dentro de él a una raiz de fichero. Me explico. En mi caso apunta al directorio $HOME/scan, que está vacío pero existe, y a la raiz «scan». A esta raiz, el script irá añadiendo números, de tal forma que se irán creando ficheros tal que $HOME/scan/scan001.pnm, $HOME/scan/scan002.pnm, etc. Cuando ejecutemos el segundo script que explico más tarde, el escaneo termina, el fichero djvu resultante es copiado al directorio definitivo, y luego el directorio $HOME/scan es vaciado de nuevo para que pueda empezar un nuevo escaneo desde cero.

En tercer lugar, la entrada «sonido» apunta a un fichero wav de sonido que exista. Daos cuenta de que el escaneo va a ser todo ciego, es decir, sin teclear comandos ni ver el resultado. Ese sonido servirá de toque de atención, para decirnos en qué momento el sistema está listo para una nueva página. Como uso KDE, el sonido será tocado mediante artsplay. Observad también que llamo a artsplay a traves de sudo. Eso no tiene mucho sentido ahora, pero sí lo tendrá más adelante, cuando integremos este mismo script en el demonio scanbuttond. De momento solo hacedme caso, ¿vale?. Naturalmente, para que sudo funcione, teneis que añadir una linea en /etc/sudoers que diga esto:

%lacofi ALL=(ALL) NOPASSWD: /usr/bin/artsplay /usr/share/sounds/*.wav

Y lógicamente, puede que tú no seas el usuario «lacofi», así que tendrás que sustitulo por tu verdadero login, tanto en la llamada a sudo como en el fichero /etc/sudoers, o incluso meter todo un grupo de usuarios (por ejemplo con «%users»).

Ahora teneis que crear otro script idéntico a sbd-scan.sh pero que se llame /etc/scanbuttond/sbd-gris.sh. Es un script idéntico, pero en la línea «modo=» debe poner «Gray» en lugar de «Lineart». Y aún teneis que crear otro script más, que se llame /etc/scanbuttond/sbd-color.sh y que en la línea «modo=» ponga «Color».

Lo se, lo se. Un solo script hubiera bastado, metiendo la variable «modo» en línea de comandos. Pero esta forma de hacerlo con varios scripts será la correcta para cuando más adelante metamos estos scripts en scanbuttond.

Técnicamente ya podemos escanear, pero tendremos que ir tecleando los comandos que arrancan nuestros scripts, y nosotros pretendemos algo mucho más sencillo: que se pueda escanear pulsando una tecla. ;-)

Para eso utilizaremos el programa xhkeys, asignando nuestros tres script a tres teclas del teclado: F10 para escanear en BW, F11 para escanear en Grises, y F12 para escanear en Color. Para ello solo hay que configurar xhkeys:

[lacofi@jeanette ~]$  xhkconf
----------- ADD/MODIFY hot key -------------
Type a key combination you wish to add/modify
Quits if idle within 10 secs
[pulsamos F10]
Unused scan code;modifier:	76;0

Select command type
1. Internal Function
2. Application
3. Plugin Call
4. Key Event
5. Mouse Event
6. Cancel
Enter selection by number, or cap. letter:
[pulsamos 2]
Enter the shell command to call the application:
[Tecleamos: /etc/scanbuttond/sbd-scan.sh]

OSD title types:
        1. Standard (command line)
        2. Custom
        3. Disabled (no OSD message)
Select title type: [Pulsamos 2]
Enter OSD title: [Tecleamos "Facsimil BW"]

Scan code:  76 (0x4c)  State:   0 (0x00)
        OperType:  A [Application]
        OSD title: Facsimil BW
        Command:   /etc/scanbuttond/sbd_scan.sh

Accept? (y, n):  [Pulsamos y]

Repetimos la operación para configurar F11 hacia /etc/scanbuttond/sbd-gris.sh y F12 hacia /etc/scanbuttond/sbd-color.sh. Ahora solo nos queda hacer que un demonio xhkeys se ponga en marcha cada vez que arranquemos la sesión gráfica. En el caso de KDE es muy fácil:

[lacofi@jeanette ~]$ ln -s /usr/bin/xhkeys .kde/Autostart/xhkeys

Después tendremos que salir de KDE y volver a entrar, si queremos activar el demonio xhkeys inmediatamente, claro.

A partir de ahora, para escanear un documento de, pongamos, 10 páginas lo tendremos muy fácil:

  1. Ponemos la primera página en el escáner.
  2. Dependiendo de que sea texto (o texto con gráficos monocromos), gráficos en gris, o gráficos en color, pulsaremos F10, F11, o F12 respectivamente.
  3. Cuando oigamos el pitido de advertencia, significa que el escaneo de la página ha terminado, así que ponemos otra página en el escáner y repetimos la operación.
  4. Y así hasta que el documento esté escaneado por completo. El documento final será $HOME/scan/scan_fichero.djvu. Y eso es todo, puedes moverlo a donde quieras y renombrarlo para que tenga un nombre más decente. Acuérdate de borrar todo el contenido del directorio $HOME/scan antes de escanear de nuevo. Fácil, ¿no?.

Si tienes un escaner con alimentador de hojas, la cosa es mucho más fácil todavía, porque se pueden modificar los scripts para que cuando pulses la tecla empiece a escanear y convertir a formato djvu todas las páginas el solito sin necesidad de hacer nada.

Pero yo no me conformo con eso, naturalmente, así que podemos ir más allá y rizar un poco el rizo. Lo que sigue a partir de ahora es para nota, y completamente opcional. Por decirlo en dos palabras: vamos a crear un nuevo script que lo resetee todo y grabe el fichero DjVu definitivo en el sitio correcto, dejando listo un registro adecuado para importar los datos del documento en una base de datos Tellico. Esto lo haremos a traves del siguiente script:

#!/bin/bash

ejecuta="si"
carpeta=$PWD
raiz=`echo $carpeta| awk -F/ '{ print $2 }'`
clase=`echo $carpeta| awk -F/ '{ print $3 }'`
subclase=`echo $carpeta| awk -F/ '{ print $4 }'`
fichero=$1
database="/var/log/escaneo.csv"
log="/var/log/escaneo.log"
directorio="$HOME/scan"
insertar="no"
ejecuta="si"
valido="si"
campos_tipo=`cat $estructura | grep Campos_tipo`
color="$HOME/.colorscan"

azul="\033[0;34m"
azul_claro="\033[1;34m"
verde="\033[0;32m"
verde_claro="\033[1;32m"
oro="\033[0;33m"
oro_claro="\033[1;33m"
cian="\033[0;36m"
cian_claro="\033[1;36m"
rojo="\033[0;31m"
rojo_claro="\033[1;31m"
blanco="\033[1;37m"
nocolor="\033[0m"

declare -i error1
declare -i error2

function ayuda {
	echo -e " "
	echo -e "${oro}Uso:${nocolor} resetea ${verde}[version]${nocolor} fichero.djvu"
	echo -e " "
	echo -e "${verde}[version] puede ser:${nocolor}"
	echo -e "	${oro}-h o --help${nocolor} 	(saldra esta ayuda)"
	echo -e "	${oro}insertar numero${nocolor} (insertara en la posicion indicada)"
	echo -e "	${oro}agregar numero${nocolor}	(agregara en la posicion indicada)"
	echo -e "	${oro}borrar numero${nocolor}	(borra la pagina indicada)"
	echo -e "	${oro}nolog${nocolor} 		(borra logs anteriores y termina)"
	echo -e "	${oro}anota${nocolor}		(no hace nada, solo anota)"
	echo -e " "
}

function pregunta {
	if [ "$raiz" = "facsimil" ]; then
		if [ "$clase" = "personal" ]; then
			tipo=`echo $campos_tipo | awk -F, '{ print $2 }'`
		elif [ "$clase" = "profesional" ]; then
			case $subclase in
				administracion)
					tipo=`echo $campos_tipo | awk -F, '{ print $3 }'`
				;;
				apuntes)
					tipo=`echo $campos_tipo | awk -F, '{ print $4 }'`
				;;
				protocolos)
					tipo=`echo $campos_tipo | awk -F, '{ print $5 }'`
				;;
				revistas)
					echo "Es un libro (Si/No):"
					read libro
					if [ "$libro" = "si" ] ||
						[ "$libro" = "Si" ] ||
						[ "$libro" = "SI" ]; then
						tipo=`echo $campos_tipo | awk -F, '{ print $6 }'`
					else
						tipo=`echo $campos_tipo | awk -F, '{ print $7 }'`
					fi
				;;
				tutoria)
					tipo=`echo $campos_tipo | awk -F, '{ print $8 }'`
				;;
				*)
					echo "Estas en el directorio $PWD"
					echo "Se supone que no deberías ejecutar eso ahi!."
					echo " "
					ayuda
					ejecuta="no"
				;;
			esac
		else
			echo "Estas en el directorio $PWD"
			echo "y no deberias ejecutar esto ahi."
			echo " "
			ayuda
			ejecuta="no"
		fi
	else
			ayuda
			ejecuta="no"
	fi
	if [ "$ejecuta" = "si" ]; then
		echo "Dime el Autor:"
		read autor
		echo "Dame un titulo:"
		read titulo
		echo "Haz un comentario:"
		read comentario
		if [ "$comentario" = "" ]; then
			comentario=$titulo
		fi
		if [ "$clase" = "profesional" ] &&
			[ "$tipo" != "Libro" ]; then
			echo "Si es una revista, pon cual es:"
			read revista
			if [ "$revista" != "" ]; then
				if [ "$revista" = "Medicina Intensiva" ] ||
					[ "$revista" = "Med Intensiva" ]; then
					export revista="Medicina Intensiva"
					export medint="true"
				else
					export medint=""
				fi
				echo "Pon el volumen:"
				read volumen
				echo "Pon el numero:"
				read numero
				echo "Pon las paginas:"
				read paginas
			fi
		fi
		echo "Pon la fecha (AAAA | MM/AAAA | DD/MM/AAAA):"
		read fecha
		letras=`echo $fecha | wc -c`
		if [ $letras -eq 5 ]; then
			ano=$fecha
			mes=""
			dia=""
		elif [ $letras -eq 8 ]; then
			ano=`echo $fecha | cut -c 4-7`
			mes=`echo $fecha | cut -c 1-2`
			dia=""
		elif [ $letras -eq 11 ]; then
			ano=`echo $fecha | cut -c 7-10`
			mes=`echo $fecha | cut -c 4-5`
			dia=`echo $fecha | cut -c 1-2`
		else
			ano=""
			mes=""
			dia=""
		fi
		fecha=${ano}-${mes}-${dia}
	fi
}

function posicion {
	echo "Debes situarte en el directorio de destino"
	echo " "
}

function indefinido {
	echo "Uuups. Hubo un error."
	echo "Variable1= $1"
	echo "Variable2= $2"
	echo "Variable3= $3"
	echo " "
}

function limpia {
	if [ "$ejecuta" = "si" ]; then
		rm -Rf $directorio/*
		rm -f $directorio/.num
	fi
}

function registra {
	if [ "$ejecuta" = "si" ]; then
		echo " " >> $log
		date >> $log
		echo "-----------------------" >> $log
		echo "Fecha: $fecha" >> $log
		echo "Fichero: $fichero" >> $log
		echo "Directorio: $PWD" >> $log
		echo "Autor: $autor" >> $log
		echo "Titulo: $titulo" >> $log
		echo "Comentario: $comentario" >> $log
		echo "Tipo: $tipo" >> $log
		cod=`echo $tipo | cut -c 1-3`
		if [ "$cod" = "Art" ]; then
			echo "($revista $ano $volumen:$numero:$paginas)" >> $log
			echo "Medicina Intensiva = $medint" >> $log
		fi
		echo '"'$autor'"','"'$titulo'"','"'$PWD/$fichero'"',\
		'"'$comentario'"',$tipo,'"'$revista'"',$volumen,$numero,$paginas,$fecha,\
		Directorio,,,,true,$medint >> $database
	fi
}

if [ $# -eq 0 ]; then
	ayuda
	ejecuta="no"
	valido="si"
else
	case $# in
		1)
			extension=`echo $1 | rev | cut -c -4`
			;;
		2)
			extension=`echo $2 | rev | cut -c -4`
			;;
		3)
			extension=`echo $3 | rev | cut -c -4`
			;;
		*)
			extension="----"
			echo "El numero de parametros no es correcto"
			ejecuta="no"
			;;
	esac
	if [ "$extension" = "uvjd" ] ||
		[ "$extension" = "fdp." ] ||
		[ "$extension" = "fit." ] ||
		[ "$extension" = "ffit" ]; then
		valido="si"
	else
		valido="no"
	fi
fi

case $1 in
	-h|--help)
		ayuda
		;;
	nolog)
		echo "Esta subrutina vaciara el LOG donde se almacenan"
		echo "los datos de todos los escaneos."
		echo " "
		echo "Estas seguro? (Si/No)"
		read respuesta
		if [ "$respuesta" = "si" ] ||
			[ "$respuesta" = "Si" ] ||
			[ "$respuesta" = "SI" ]; then
			echo " " > $log
			echo "Autor,Titulo,Posicion,Descripcion,Publicado en,Revista,\
			Vol,Num,Pag,Fecha,Carpeta,Número,Tipo,Archivo,Facsimil,\
			Medicina Intensiva" > $database
		else
			echo "Ah, creia..."
		fi
		;;
	insertar|agregar|borrar)
		if [ "$ejecuta" = "si" ]; then
		if [ -f "$3" ] &&
			[ "$valido" = "si" ]; then
			mv $directorio/scan_fichero.djvu ./pag$2.djvu
			chmod go-w pag$2.djvu
			error=$?
			if [ $error -gt 0 ]; then
				posicion
				ejecuta="no"
			else
				limpia
			fi
			if [ "$ejecuta" = "si" ] ||
				[ "$1" = "borrar" ]; then
				if [ "$1" = "insertar" ] ||
					[ "$1" = "borrar" ]; then
					djvm -d $3 $2
					error1=$?
				else
					error1=0
				fi
				if [ "$1" = "insertar" ] ||
					[ "$1" = "agregar" ]; then
					djvm -i $3 pag$2.djvu $2
					error2=$?
				else
					error2=0
				fi
				if [ $error1 -eq 0 ] &&
					[ $error2 -eq 0 ]; then
						rm pag$2.djvu
				else
					ayuda
					indefinido
				fi
			fi
		else
			ayuda
		fi
		fi
		;;
	anota)
		fichero=$2
		if [ "$ejecuta" = "si" ] &&
			[ "$valido" = "si" ]; then
			pregunta
			registra
		fi
		;;
	*)
		if [ "$ejecuta" = "si" ] &&
			[ "$valido" = "si" ]; then
			pregunta
			if [ -f "$color" ]; then
				echo "Pronto en sus pantallas"
			else
				mv $directorio/scan_fichero.djvu ./$1
				chmod go-w $1
					error=$?
				if [ $error -gt 0 ]; then
					posicion
				else
					limpia
					registra
				fi
			fi
		fi
		;;
esac

Parece complicado, pero no lo es tanto si tienes un poco de idea de programación Bash (observa que tiene múltiples rutinas en forma de funciones).

Para entender este script y lo que hace, hay que tener en cuenta que guardo todos mis documentos en subdirectorios del siguiente árbol:

[lacofi@jeanette ~]$ tree -d -L 2 -I lost* /facsimil
/facsimil
|-- personal
|   |-- coche
|   |-- comunidad_vecinos
|   |-- docs_bancarios
|   |-- folletos_informacion
|   |-- libros
|   `-- notas_casa
`-- profesional
    |-- administracion
    |-- apuntes
    |-- protocolos
    |-- revistas
    `-- tutoria

13 directories

Partiendo de esta idea básica, este script tiene varias peculiaridades que restringen su funcionamiento y hacen que sea todo muy personalizado. No funcionará en tu sistema, asi que seguramente tendrás que reescribirlo entero, pero eso es precisamente lo más interesante. En cualquier caso, te será útil para darte unas cuantas ideas, a saber:

  1. En caso de error, el script abortará el proceso y sacará en pantalla una ayuda sobre la sintaxis correcta. Puede consultarse la sintaxis ejecutando el script sin argumentos, o con los argumentos -h o –help.
  2. El script no funcionará si no estas en el directorio adecuado (es decir, un subdirectorio de /facsimil/personal o /facsimil/profesional. Si has hecho un «cd» a cualquier otro lugar que no cumpla ese requisito, el script abortará y sacará la ayuda en pantalla.
  3. Si se cumplen las condiciones, el script hará unas cuantas preguntas pidiendo el autor, el título, etc, del documento que se está almacenando. Las preguntas son sensibles a contexto: dependiendo del directorio en que te encuentres, te hará unas preguntas u otras. Por ejemplo, si estás en /facsimil/personal no te preguntará si se trata de una revista. Si es un libro, no preguntará el volumen de la revista, etc. Si se deja en blanco el comentario, el script almacenará el título como comentario. Y así con unas cuantas cosas más. La idea es que el script saque un máximo de información haciendo un mínimo de preguntas.
  4. A partir de todo esto, el script guarda dos logs diferentes:
    1. Uno es /var/log/escaneo.log que es un archivo «legible por humanos» y que contiene toda la información que ha obtenido del usuario y del contexto, para que puedas consultarlo cómodamente en cualquier momento.
    2. El otro log es /var/log/escaneo.csv. Observa las líneas marcadas en verde: aquí lo he puesto en varias líneas para facilitar la lectura en la Web, pero en tu ordenador deberías poner ambas entradas en en una única línea. Lo interesante de este log es que se trata de una base de datos en formato CSV, cuya primera línea es el nombre de los campos. La gracia de esto es que casi todas las bases de datos saben importar ficheros CSV, lo que significa que podemos abrir nuestro programa Tellico y decirle simplemente que importe este archivo. Genial, ¿no?. Con este script ¡nuestra base de datos se rellena sola!. Naturalmente, eso exige que tengamos una base de datos Tellico ya creada y con los mismos campos que estamos introduciendo aquí, pero eso es de cajón.
  5. Además, el script es capaz de distinguir varios formatos de fecha, como: «1994», o «10/1994» (septiembre de 1994) o como «10/10/1994». No aceptará otros formatos. En cualquier caso, el script transforma la fecha así escrita a otro formato distinto, el que usa una base de datos Tellico. :-)

Bien, pues vamos a ejecutar el script:

[lacofi@jeanette ~]$  cd ~/facsimil/protocolos/vm
[lacofi@jeanette vm]$  resetea reclutamiento_sdra.djvu
Introduce el primer autor:

Contestamos tres o cuatro preguntas y ya está. El documento quedará archivado en el directorio adecuado, y $HOME/scan quedará vacío, listo para empezar un nuevo documento. El archivo /var/log/escaneo.log guardará información precisa de lo que ha hecho. Y lo que es más importante, el archivo /var/log/escaneo.csv guardará un nuevo registro CSV que nos permitirá importar todos esos datos en la base de datos Tellico (o cualquier otra que soporte importación de datos CSV).

A veces, si revisais el documento escaneado (djview reclutamiento_sdra.djvu), puede que una página esté mal escaneada, por ejemplo porque haya quedado torcida. No importa. Se escanea de nuevo, pero SOLO la página fallida, y luego se ejecuta «resetea» con el parámetro «insertar».

[lacofi@jeanette vm]$ resetea insertar 14 reclutamiento_sdra.djvu

Con lo que el documento reclutamiento_sdra.djvu es modificado para borrar la página errónea (la 14) y poner en su lugar la nueva página. Esta maniobra no quedará registrada en el fichero de log, claro. Más sencillo no puede ser.

Del mismo modo, podemos agregar una página (en vez de insertarla sustituyendo otra), o incluso borrarla por completo.

Pero ¿qué ocurre si no estamos logados?. ¿Podemos escanear?. Pues sí, claro. Estos mismos scripts (sbd-scan.sh sbd-gris.sh y sbd-color.sh) pueden ser asignados a los botones del escáner mediante el programa demonio scanbuttond. En el caso del Canon Lide 30, tiene tres botones frontales que se supone son para escanear, fotocopiar y enviar por correo electrónico, pero resulta más práctico asignarlos a nuestros scripts, al menos sbd-scan.sh y sbd-color.sh, dejando el botón del medio para fotocopiar. Luego podemos logarnos de forma remota para ejecutar «resetea».

En cualquier caso, la instalación y configuración de scanbuttond está bien documentada, así que no me voy a enrollar con ella. Los usuarios de Gentoo solo tienen que recurrir al gentoo-wiki, como siempre, pero los usuarios de otras distribuciones también deberían echarle un vistazo, porque viene todo muy bien explicado y con mucho detalle. ;-)

¿Funcionará ese scanner Canon Lide 30 en mi Linux?

Sí. Perfectamente. Solo necesitas instalar la última versión de los sane-backends. Con la 1.0.15 o superior será reconocido sin problemas, así que muy viejo tiene que ser tu sistema para no soportarlo. Eso sí, hay algunas cosas a tener en cuenta:

En el caso de Gentoo, tienes que hacer:

[root@claudia:~]# emerge sane-backends sane-frontends xsane 
[root@claudia:~]# emerge libusb hotplug

Sin embargo, debes añadir la opción «usb» a tu /etc/make.conf, en el apartado USE, o será incapaz de reconocerlo.

Y sea cual sea la distribución Linux que uses, también tendrás que tener soporte para USB, claro. No es imprescindible que tengas USB 2.0, pues funcionará incluso con USB 1.1, pero irá lentiiiiisimo. Te recomiendo encarecidamente USB 2.0. Y tendrás que cargar los módulos adecuados para activar el soporte, o recompilar tu kernel, si no los tienes. Estos módulos son usbcore, uhci-hcd (para 1.1) y ehci-hcd (para 2.0, pero necesita también el otro). Dmesg te dirá cómo reconoce al escaner:

hub 1-0:1.0: state 5 ports 4 chg fff0 evt 0002
ehci_hcd 0000:00:09.2: GetStatus port 1 status 001002 POWER sig=se0  CSC
hub 1-0:1.0: port 1, status 0100, change 0001, 12 Mb/s
hub 1-0:1.0: debounce: port 1: total 100ms stable 100ms status 0x100
hub 3-0:1.0: state 5 ports 2 chg fffc evt 0002
uhci_hcd 0000:00:09.0: port 1 portsc 008a,00
hub 3-0:1.0: port 1, status 0100, change 0003, 12 Mb/s
usb 3-1: USB disconnect, address 4
usb 3-1: usb_disable_device nuking all URBs
usb 3-1: unregistering interface 3-1:1.0
usb 3-1:1.0: hotplug
usb 3-1: unregistering device
usb 3-1: hotplug
hub 3-0:1.0: debounce: port 1: total 100ms stable 100ms status 0x100
hub 1-0:1.0: state 5 ports 4 chg fff0 evt 0002
ehci_hcd 0000:00:09.2: GetStatus port 1 status 001803 POWER sig=j  CSC CONNECT
hub 1-0:1.0: port 1, status 0501, change 0001, 480 Mb/s
hub 1-0:1.0: debounce: port 1: total 100ms stable 100ms status 0x501
ehci_hcd 0000:00:09.2: port 1 full speed --> companion
ehci_hcd 0000:00:09.2: GetStatus port 1 status 003801 POWER OWNER sig=j  CONNECT
hub 3-0:1.0: state 5 ports 2 chg fffc evt 0002
uhci_hcd 0000:00:09.0: port 1 portsc 0093,00
hub 3-0:1.0: port 1, status 0101, change 0001, 12 Mb/s
hub 3-0:1.0: debounce: port 1: total 100ms stable 100ms status 0x101
usb 3-1: new full speed USB device using uhci_hcd and address 6
usb 3-1: ep0 maxpacket = 8
usb 3-1: new device strings: Mfr=1, Product=2, SerialNumber=0
usb 3-1: default language 0x0409
usb 3-1: Product: CanoScan
usb 3-1: Manufacturer: Canon
usb 3-1: hotplug
usb 3-1: adding 3-1:1.0 (config #1, interface 0)
usb 3-1:1.0: hotplug
hub 3-0:1.0: state 5 ports 2 chg fffc evt 0002

Ahora podemos usar dos comandos que nos mostrarán que SANE también detecta el escaner:

[15:12:01/0][root@claudia:~]# sane-find-scanner
  # No SCSI scanners found. If you expected something different, make sure that
  # you have loaded a SCSI driver for your SCSI adapter.

found USB scanner (vendor=0x04a9 [Canon], product=0x220e 
	[CanoScan], chip=LM9832/3) at libusb:003:006
found USB scanner (vendor=0x05e3, product=0x0502 
	[USB Host To Host Bridge]) at libusb:003:005
  # Your USB scanner was (probably) detected. It may or may not be supported by
  # SANE. Try scanimage -L and read the backend's manpage.

  # Not checking for parallel port scanners.

  # Most Scanners connected to the parallel port or other proprietary ports
  # can't be detected by this program.
[15:12:01/0][root@claudia:~]# scanimage -L
device `plustek:libusb:003:006' is a Canon N1240U/LiDE30 USB flatbed scanner

Si ahora ejecutamos «xsane plustek» deberíamos poder escanear sin más problemas. Al menos como root.

Pero no como usario normal. Habitualmente, al instalar los backends de SANE, Gentoo crea un grupo especial que se llama «scanner». Podemos añadir ese grupo a los usuarios que queramos conceder permiso para usar el scanner. Para ello solo teneis que editar el fichero /etc/group y donde pone:

	scanner:!:501:

Debe poner:

	scanner:!:501:lacofi,maria

Los nuevos grupos y permisos de acceso solo estarán disponibles la próxima vez que nos logemos. Y solo queda un detalle: hay que poner en marcha el servicio hotplug. En el caso de gentoo:

[root@claudia:~]# /etc/init.d/hotplug start
[root@claudia:~]# rc-update add hotplug default
 * hotplug added to runlevel default
 * Caching service dependencies...
 * rc-update complete.

Mi escaner Mustek Paragon 800 II SP no funciona con Linux

Sí, si que funciona. Lo que no funciona es la mielda de tarjeta SCSI que viene con él.

Por cierto, ¿cómo es que tienes esa reliquia?. ¿De segunda mano, tal vez?. :-D

Yo lo tenía cuando usaba Windows, y me encontré con el problema fue cuando me pasé a Linux, con Red Hat. Lo configuré todo (más o menos), pero el escaner fue imposible. Así que, por una temporada (pequeña) seguí dependiendo de Windows para escanear.

Hasta que descubrí lo que pasaba: el problema no era el escaner (de hecho, en la documentación de SANE se recogía el Mustek Paragon 800 II SP como soportado), sino la tarjeta SCSI que venía incluida en el paquete, que era una verdadera porquería (entre otras cosas, no admitía interrupciones, con lo que la multitarea se iba al carajo en cuanto ).

Bien, pues los problemas se solucionaron de golpe comprando otra tarjeta SCSI, concretamente una Adaptec 2940 que me costó menos de 5000 pesetas (pesetas, la extinta moneda española, ¿recuerdas?… a ver… 5000 ptas equivalían a 30 euros… jesús, qué tiempos).

Eso fue todo. La tarjeta SCSI de Adaptec fue reconocida inmediatamente en cuanto reboté el sistema. Y solo con eso, el escaner empezó a funcionar con Linux mediante nuestro querido SANE.

Hasta que fue jubilado por un Canon Lide 30. Y luego por un scanner HP con alimentador de hojas que es una delicia. :-)