ModelParser.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2012 Stefan Profanter. All rights reserved. This program and the accompanying
 * materials are made available under the terms of the GNU Public License v3.0 which accompanies
 * this distribution, and is available at http://www.gnu.org/licenses/gpl.html
 * 
 * Contributors: Stefan Profanter - initial API and implementation, Year: 2012
 ******************************************************************************/
package edu.tum.cs.vis.model.parser;

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;

import com.sun.j3d.utils.geometry.GeometryInfo;

import edu.tum.cs.ias.knowrob.utils.ResourceRetriever;
import edu.tum.cs.vis.model.Model;
import edu.tum.cs.vis.model.util.Vertex;

public abstract class ModelParser {

        private static final HashMap<String, Class<? extends ModelParser>>      extensionAssignment     = new HashMap<String, Class<? extends ModelParser>>();
        static {
                /*
                 * Add here other parsers with file extension
                 */
                extensionAssignment.put("dae", ColladaParser.class);
                extensionAssignment.put("kmz", ColladaParser.class);
                extensionAssignment.put("mesh", CustomParser.class);
                extensionAssignment.put("ply", PlyParser.class);
        }

        private static HashMap<String, Model>                                                           modelBuffer                     = new HashMap<String, Model>();

        public static Class<? extends ModelParser> findParser(String filename) {
                return extensionAssignment.get(getExtension(filename));
        }

        protected static String getExtension(String filename) {
                return filename.substring(filename.lastIndexOf('.') + 1);
        }

        protected Model model;

        protected boolean checkExtension(String filename) {
                if (!isValidExtension(filename)) {
                        System.out.println("Unknown file extension for class: " + this.getClass().getName()
                                        + " " + filename + "\n Must be one of: " + getValidExtensions());
                        return false;
                }
                return true;
        }

        public Model getModel() {
                return model;
        }

        protected String getValidExtensions() {
                Iterator<String> it = extensionAssignment.keySet().iterator();
                String extensions = "";
                while (it.hasNext()) {
                        String key = it.next();
                        Object val = extensionAssignment.get(key);
                        if (val.getClass() == this.getClass())
                                extensions += key + ", ";
                }
                return extensions;
        }

        protected boolean isValidExtension(String filename) {
                if (extensionAssignment.get(getExtension(filename)) == this.getClass())
                        return true;
                return false;
        }

        protected abstract boolean loadModel(String filename);

        public boolean parseModel(String filename) {
                Model m = modelBuffer.get(filename);
                boolean retVal = true;

                if (m == null) {
                        model = new Model();
                        // get / download file and determine local file path
                        String file = ResourceRetriever.retrieve(filename).getAbsolutePath();

                        if (!checkExtension(file)) {
                                return false;
                        }

                        if ((new File(file)).exists() == false) {
                                System.err.println("ERROR: Can't load model. File not found: " + file + "\n");
                                return false;
                        }

                        retVal = loadModel(file);
                        if (!retVal)
                                return false;
                        modelBuffer.put(filename, model);
                        model.getGroup().initialize(model.getTextureBasePath());
                } else
                        model = m;
                return retVal;
        }

        public static int[] polygonTriangulation(Vertex vertices[]) {
                float coord[] = new float[vertices.length * 3];
                for (int i = 0; i < vertices.length; i++) {
                        coord[i * 3] = vertices[i].x;
                        coord[i * 3 + 1] = vertices[i].y;
                        coord[i * 3 + 2] = vertices[i].z;
                }

                GeometryInfo gi = new GeometryInfo(GeometryInfo.POLYGON_ARRAY);
                gi.setCoordinates(coord);

                int[] stripCounts = { coord.length / 3 };
                gi.setStripCounts(stripCounts);
                gi.convertToIndexedTriangles();

                return gi.getCoordinateIndices();
        }

}