root/tools/routingservice/trunk/src/jp/co/orkney/restlet/geo/ShortestPath.java

/**
 * Copyright (c) 2007 Orkney, Inc. <http://www.orkney.co.jp/>
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package jp.co.orkney.restlet.geo;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.antlr.stringtemplate.StringTemplate;
import org.json.JSONException;

import jp.co.orkney.restlet.util.IOHelper;
import jp.co.orkney.restlet.util.LimitsHelper;
import jp.co.orkney.restlet.util.Log;
import jp.co.orkney.restlet.util.Point;
import jp.co.orkney.restlet.util.Configuration;
import jp.co.orkney.restlet.util.DatabaseConnection;

/**
 * <b>ShortestPath is a class which represents a "shortest path" algorithm.</b>
 * <p>
 * "shortest path" algorithm follows these steps:
 * <ul>
 * <li>Extract X and Y for start and end point</li>
 * <li>Start the database connection</li>
 * <li>Make the query</li>
 * <li>Send the query to the database</li>
 * <li>Transform the result in the specified format</li>
 * <li>Close the database connection</li>
 * </ul>
 * To do these steps, ShortestPath class calls some method in IOHelper and
 * DatabaseConnection
 * </p>
 * 
 * @author Matthieu Bilbille - Orkney Inc.
 * @version 1.0
 * @see IOHelper
 * @see DatabaseConnection
 */
public class ShortestPath extends GeoAction
{
    private Point startPoint;

    private Point endPoint;

    /**
         * Constructor ShortestPath
         * <p>
         * Creates a new ShortestPath object using the specified Configuration
         * object and extracts X and Y from the data provides by GET or POST
         * request into a new point (for start and end point).
         * </p>
         * 
         * @param configuration
         *                the current configuration
         */
    public ShortestPath(Configuration configuration,
            DatabaseConnection databaseConnection, IOHelper ioHelper, Log log)
    {
        super(configuration, databaseConnection, ioHelper, log);

        name = "Shortest path";

        // extract method for Geojson format
        if (configuration.getFormatIn().getName().equals("geojson"))
        {
            startPoint = ioHelper.extractGEOJSONPxPy(configuration.getService()
                    .getParameter("point_start").getValue());
            endPoint = ioHelper.extractGEOJSONPxPy(configuration.getService()
                    .getParameter("point_end").getValue());
        }
        // extract method for Gml format
        else if (configuration.getFormatIn().getName().equals("gml"))
        {
            startPoint = ioHelper.extractGMLPxPy(configuration.getService()
                    .getParameter("point_start").getValue());
            endPoint = ioHelper.extractGMLPxPy(configuration.getService()
                    .getParameter("point_end").getValue());
        }
        // extract method for lonlat format
        else if (configuration.getFormatIn().getName().equals("lonlat"))
        {
            startPoint = ioHelper.extractLONLATPxPy(configuration.getService()
                    .getParameter("point_start").getValue());
            endPoint = ioHelper.extractLONLATPxPy(configuration.getService()
                    .getParameter("point_end").getValue());
        }
        // extract method for wkt format
        else if (configuration.getFormatIn().getName().equals("wkt"))
        {
            startPoint = ioHelper.extractWKTPxPy(configuration.getService()
                    .getParameter("point_start").getValue());
            endPoint = ioHelper.extractWKTPxPy(configuration.getService()
                    .getParameter("point_end").getValue());
        }
        // extract method for kml format
        else if (configuration.getFormatIn().getName().equals("kml"))
        {
            startPoint = ioHelper.extractKMLPxPy(configuration.getService()
                    .getParameter("point_start").getValue());
            endPoint = ioHelper.extractKMLPxPy(configuration.getService()
                    .getParameter("point_end").getValue());
        }
    }

    /**
         * Gets the result of the shortest path algorithm
         * 
         * @return this shortest path's result
         */
    public String get()
    {
        return result;
    }

    /**
         * Starts the "shortest path" algorithm
         * 
         * @throws SQLException
         *                 error to send the query to the database
         * @throws JSONException
         *                 Error to transform the result in Geojson format
         */
    public void start() throws SQLException, JSONException
    {
        StringTemplate query = this.ioHelper.getQuery();
        ResultSet rs = null;

        float bboxSize = Float.parseFloat(configuration.getService()
                .getParameter("bbox").getValue());

        // We need to define the input projection and reproject the data.
        // This place is not beautiful yet and needs to be reconsidered.
        Point sPoint = startPoint;
        Point ePoint = endPoint;

        if (configuration.getService().getParameter("sridInput").getValue() != null)
        {
            sPoint = databaseConnection.transform(configuration.getService(),
                    startPoint, configuration.getService().getParameter(
                            "sridInput").getValue(), configuration.getService()
                            .getDataProjection());
            ePoint = databaseConnection.transform(configuration.getService(),
                    endPoint, configuration.getService().getParameter(
                            "sridInput").getValue(), configuration.getService()
                            .getDataProjection());
        }

        if (LimitsHelper.isDistanceAllowed(sPoint, ePoint, configuration
                .getService().getLimit().getDistance()))
        {

            this.log.write("Distance limit is "+configuration.getService().getLimit().getDistance(), 2);
            // Makes the SQL query
            query.setAttribute("sonStartX", startPoint.getX());
            query.setAttribute("sonStartY", startPoint.getY());
            query.setAttribute("sonEndX", endPoint.getX());
            query.setAttribute("sonEndY", endPoint.getY());
            query.setAttribute("saBoxSize", bboxSize);
            query.setAttribute("sridProvider", configuration.getService()
                    .getDataProjection());
            query.setAttribute("sridIn", configuration.getService()
                    .getParameter("sridInput").getValue());
            query.setAttribute("sridOut", configuration.getService()
                    .getParameter("sridOutput").getValue());

            // System.out.println(query.toString());
            this.log.write(query.toString(), 2);
            rs = databaseConnection.getResult(configuration.getService(), query
                    .toString());

        }
        else
        {
            this.log.write("Distance exceedes limits", 1);
            //There should be an exception in this case
            return;
        }

        String reqId = configuration.getService().getParameter("request_id")
                .getValue();

        StringTemplate template = this.configuration.getFormatOut()
                .getTemplate();

        result = this.ioHelper.fillTemplate(rs,
                this.configuration.getFormatOut().getName(), template, reqId);

        /*
         *  // Converts the SQL Result in Geojson if
         * (this.configuration.getFormatOut().getName().equals("geojson")) {
         * result = this.ioHelper.shortestPathGEOJSONResult(rs, reqId); } //
         * Converts the SQL Result in HTML else if
         * (this.configuration.getFormatOut().getName().equals("html")) { result =
         * this.ioHelper.shortestPathHTMLResult(rs, startPoint, endPoint,
         * reqId); } // Converts the SQL Result in XML else if
         * (this.configuration.getFormatOut().getName().equals("xml")) { result =
         * this.ioHelper.shortestPathXMLResult(rs, reqId); } // Converts the SQL
         * Result in GML else if
         * (this.configuration.getFormatOut().getName().equals("gml")) { result =
         * this.ioHelper.shortestPathGMLResult(rs, reqId); } // Converts the SQL
         * Result in WKT else if
         * (this.configuration.getFormatOut().getName().equals("wkt")) { result =
         * this.ioHelper.shortestPathWKTResult(rs); } // Converts the SQL Result
         * in KML else if
         * (this.configuration.getFormatOut().getName().equals("kml")) { result =
         * this.ioHelper.shortestPathKMLResult(rs); }
         */

    }

}