root/trunk/mlframework/src/eu/moonlight3d/common/image/pfm/ImageFormat.java

/*
 * Moonlight|3D Copyright (C) 2005 The Moonlight|3D team
 * 
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 * 
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * Created on Oct 31, 2005
 */
package eu.moonlight3d.common.image.pfm;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;

import eu.moonlight3d.common.image.core.Channel;
import eu.moonlight3d.common.image.core.Framebuffer;
import eu.moonlight3d.framework.State;
import eu.moonlight3d.framework.helper.FileType;
import eu.moonlight3d.framework.helper.StringTools;
import eu.moonlight3d.framework.localization.L10N;

/**
 * Support for the PFM immage file format.
 *
 * @author gregor
 */
public class ImageFormat implements eu.moonlight3d.common.image.core.ImageFormat {

        public String getName() {
                return "Portable Float Map";
        }

        public FileType getFileType() {
                ArrayList<String> patterns=new ArrayList<String>();
                patterns.add("*.pfm");
                return new FileType("Portable Float Map",patterns);
        }

        public boolean isLoadable() {
                return true;
        }
        
        public boolean canLoadFile(String filename) {
                try {
                        // check if file has required signature
                        RandomAccessFile input=new RandomAccessFile(filename,"r");
                        
                        String header=input.readLine();
                        if(header.equals("Pf")) {
                                State.getInstance().logger().warning(L10N.translate("Loading of grayscale portable float maps not implemented"));
                                return false;
                        }
                        if(!header.equals("PF")) { // TODO grayscale float maps
                                return false;
                        }
                        input.close();
                } catch (FileNotFoundException e) {
                        return false;
                } catch (IOException e) {
                        return false;
                }
                return true;
        }
        
        public Framebuffer loadFile(String filename) {
                try {
                        RandomAccessFile input=new RandomAccessFile(filename,"r");
                        
                        String header=input.readLine();

                        if(!header.equals("PF")) {
                                return null;
                        }
                        
                        String resString=input.readLine();
                        String res[]=StringTools.split(resString," ");
                        int width=Integer.parseInt(res[0]);
                        int height=Integer.parseInt(res[1]);
                        
                        String scaleString=input.readLine();
                        float scale=Float.parseFloat(scaleString);

                        ByteOrder byteOrder;
                        if(scale<0) {
                                byteOrder=ByteOrder.LITTLE_ENDIAN;
                        } else {
                                byteOrder=ByteOrder.BIG_ENDIAN;
                        }
                        scale=Math.abs(scale);
                        
                        Framebuffer framebuffer=new Framebuffer(width, height);
                        framebuffer.addChannel("red");
                        framebuffer.addChannel("green");
                        framebuffer.addChannel("blue");
                        
                        FileChannel fileChannel=input.getChannel();
                        MappedByteBuffer buffer=fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, input.length());
                        buffer.position((int)input.getFilePointer());
                        buffer.order(byteOrder);
                        
                        Channel red=framebuffer.getChannel("red");
                        Channel green=framebuffer.getChannel("green");
                        Channel blue=framebuffer.getChannel("blue");
                        for(int y=0;y<framebuffer.getHeight();y++) {
                                for(int x=0;x<framebuffer.getWidth();x++) {
                                        red.putPixel(x, y, scale*buffer.getFloat());
                                        green.putPixel(x, y, scale*buffer.getFloat());
                                        blue.putPixel(x, y, scale*buffer.getFloat());
                                }
                        }
                        
                        return framebuffer;
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                
                return null;
        }

        public boolean isSaveable() {
                return true;
        }

        public void saveFile(String filename, Framebuffer buffer) {
                try {
                        RandomAccessFile outputFile=new RandomAccessFile(filename,"rw");
                        
                        outputFile.setLength(0);
                        
                        outputFile.writeBytes("PF\n");
                        outputFile.writeBytes(buffer.getWidth() + " " + buffer.getHeight() + "\n");
                        if(ByteOrder.nativeOrder()==ByteOrder.BIG_ENDIAN) {
                                outputFile.writeBytes("1.0\n");
                        } else {
                                outputFile.writeBytes("-1.0\n");
                        }
                        
                        Channel red=buffer.getChannel("red");
                        Channel green=buffer.getChannel("green");
                        Channel blue=buffer.getChannel("blue");
                        for(int y=0;y<buffer.getHeight();y++) {
                                for(int x=0;x<buffer.getWidth();x++) {
                                        outputFile.writeFloat(red.getPixel(x, y));
                                        outputFile.writeFloat(green.getPixel(x, y));
                                        outputFile.writeFloat(blue.getPixel(x, y));
                                }
                        }

                        outputFile.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

}