electroduendes.com

import flash.geom.Point;
import mx.transitions.*;
import mx.transitions.easing.*;
// puntos de la goma
var pinit:Point = new Point(50, 100);
var pfin:Point = new Point(150, 100);
// la goma se va a dibujar con un vertice
var pVerticeCurva:Point = null;
// dragger es  la cruz
attachMovie("beizer", "dragger", 2);
init();
// crea el clip goma e inicializa la posicion del dragger y del enterFrame
function init() {
	var goma = _root.createEmptyMovieClip("goma", 1);
	// este punto se podría introducir a mano
	pVerticeCurva = new Point(Math.abs((pinit.x-pfin.x)/2)+pinit.x, 
								Math.abs((pinit.y-pfin.y)/2)+pinit.y);
	// colocamos el dragger en el punto de la curva
	_root["dragger"]._x = pVerticeCurva.x;
	_root["dragger"]._y = pVerticeCurva.y;
	goma.onEnterFrame = redibujar;
}
// dibuja la goma con los valores calculados
function redibujar() {
	with (goma) {
		clear();
		lineStyle(2, 0xc0c0c0, 100);
		moveTo(pinit.x, pinit.y);
		curveTo(_root["dragger"]._x, _root["dragger"]._y, pfin.x, pfin.y);
	}
}
dragger.onPress = function() {
	startDrag(this);
};
// cuando soltamos el dragger, movemos el punto de la curva...
dragger.onRelease = dragger.onReleaseOutside=function () {
	stopDrag();
	new Tween(this, "_x", Elastic.easeOut, this._x, pVerticeCurva.x, 1, true);
	new Tween(this, "_y", Elastic.easeOut, this._y, pVerticeCurva.y, 1, true);
};

 
//var mapa = _root.obj.contenidos.lista[i].elemento[j].mapa;
// Bug: ya había un mc que se llama mapa!
 
var sMapa:String = _root.obj.contenidos.lista[i].elemento[j].mapa;
 
/* 
Alejandro Sánchez:
la notación húngara y el strict data typing sirven para depurar 
errores como este.
ejemplo:
comentario:String = "llevo una hora intentando resolver este bug"
*/

/*
 * ImageUtils.java
 *
 * Created on 20 de julio de 2005, 11:47
 * Resizes jpeg image files on your file system.
 * Uses the com.sun.image.codec.jpeg package shipped
 * by Sun with Java 2 Standard Edition.
 *
 * @author Randy Belknap
 * @revision Alejandro Sánchez Marcos
 * se aprovecha la nueva clase ImageIO de 1.4
 * y se añaden algunos métodos nuevos 
 */
 
package com.electroduendes.util.image;
 
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import org.apache.log4j.Logger;
 
/**
 
 */
public class ImageUtils {
    static Logger logger = Logger.getLogger(ImageUtils.class);
    /*
     * devuelve la lista de formatos disponibles a leer por ImageIO
     * @return un array de strings con los mismos.
     */
    public static String[] getAvailableFormats(){
        return ImageIO.getReaderFormatNames();
    }
 
    /*
     * devuelve una imagen (buffer) en función de la ruta de un archivo
     * mejoras
     * @param la ruta del archivo con su nombre
     * @return BufferedImage la imagen en el buffer
     */
    public static BufferedImage loadBufferedImage(String fileName) {
        BufferedImage image = null;
        try {
            /*FileInputStream fis = new FileInputStream(fileName);JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(fis);bi = decoder.decodeAsBufferedImage();fis.close();*/
            // MAS RAPIDO a partir de 1.4
            image = ImageIO.read( new File( fileName ) );
        }
        catch (Exception e) {
            logger.debug("error al intentar leer la imágen");
            return null;
        }
        return image;
 
    }
    /**
     * comprueba que la imágen tiene un mínimo en pixels
     * width y height tienen que tener un tamaño igual o mayor que el pasado
     * como argumento
     *
     * @param w ancho mínimo
     * @param h alto mínimo
     * @return true o false
     *
     */
    public static boolean isGreaterThanMinSize(int w, int h, BufferedImage imgSrc){
        int nHeight = imgSrc.getHeight();
        int nWidth = imgSrc.getWidth();
        if ((nHeight<h ) || (nWidth<w)){
            return false;
        } else {
            return true;
        }
    }
 
    /*
     * calcula el factor de escala mínimo y en base a eso escala la imagen 
     * según el dicho factor. 
     * @param nMaxWidth minimo tamaño para el ancho
     * @param nMaxHeight minimo tamaño para el alto
     * @param imgSrc la imágen 
     */
    public static BufferedImage scaleToSize(int nMaxWidth, int nMaxHeight, BufferedImage imgSrc) {
        int nHeight = imgSrc.getHeight();
        int nWidth = imgSrc.getWidth();
        double scaleX = (double)nMaxWidth / (double)nWidth;
        double scaleY = (double)nMaxHeight / (double)nHeight;
        double fScale = Math.min(scaleX, scaleY);
        return scale(fScale, imgSrc);
    }
 
    /*
     * escala una imagen en porcentaje.
     * @param scale ejemplo: scale=0.6 (escala la imágen al 60%)
     * @param srcImg una imagen BufferedImage
     * @return un BufferedImage escalado
     */
    public static BufferedImage scale(double scale, BufferedImage srcImg) {
        if (scale == 1 ) {
            return srcImg;
        }
        AffineTransformOp op = new AffineTransformOp
        (AffineTransform.getScaleInstance(scale, scale), null);
 
        return op.filter(srcImg, null);
 
    }
 
    public static void saveImageToDisk(BufferedImage bi, String str, String format) {
        if (bi != null && str != null) {
 
            // más rápido con ImageIO
            try {
                ImageIO.write( bi, format /* formato */, new File( str ) /* destino */ );
            } catch (Exception e){}
        }
    }
 
 
    public static void main(String args[]) {
        if(args.length != 3){usage();}
        System.out.println(args[0]);
        BufferedImage bImg = loadBufferedImage(args[0]);
        System.out.println(bImg);
        BufferedImage bImgEscaladaG = scaleToSize(800, 600, bImg);
        BufferedImage bImgEscaladaP = scaleToSize(320, 200, bImg);
 
        saveImageToDisk(bImgEscaladaG, args[1],"JPEG");
        saveImageToDisk(bImgEscaladaP, args[2],"JPEG");
        System.exit(0);
    }
 
    public static void usage(){
        System.out.println("usage: java ImageUtils archivo_original imagen_grande imagen_pequeña ");
        System.exit(1);
    }
 
}