Subversion Repositories mkgmap

/*
 * Copyright (C) 2007 Steve Ratcliffe
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  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.
 *
 *
 * Author: Steve Ratcliffe
 * Create date: Dec 1, 2007
 */
package uk.me.parabola.mkgmap.filters;

import java.util.ArrayList;
import java.util.List;

import uk.me.parabola.imgfmt.app.Coord;
import uk.me.parabola.log.Logger;
import uk.me.parabola.mkgmap.general.MapElement;
import uk.me.parabola.mkgmap.general.MapLine;
import uk.me.parabola.mkgmap.general.MapRoad;
import uk.me.parabola.mkgmap.general.MapShape;

/**
 * A filter that ensures that a line does not exceed the allowed number of
 * points that a line can have. If the line is split, the last part
 * will have at least 50 points to avoid that too small parts are filtered later.
 *
 * @author Steve Ratcliffe
 */
public class LineSplitterFilter implements MapFilter {
        private static final Logger log = Logger.getLogger(LineSplitterFilter.class);
       
        // Not sure of the value, probably 255.  Say 250 here.
        public static final int MAX_POINTS_IN_LINE = 250;
        public static final int MIN_POINTS_IN_LINE = 50;

        private int level;
        private boolean isRoutable;
        public void init(FilterConfig config) {
                this.level = config.getLevel();
                this.isRoutable = config.isRoutable();
        }

       
        /**
         * If the line is short enough then we just pass it on straight away.
         * Otherwise we cut it into pieces that are short enough and hand them
         * on.
         *
         * @param element A map element.
         * @param next This is used to pass the possibly transformed element onward.
         */
        public void doFilter(MapElement element, MapFilterChain next) {
                // We do not deal with shapes.
                assert !(element instanceof MapShape) && element instanceof MapLine;
               
                MapLine line = (MapLine) element;

                List<Coord> points = line.getPoints();
                int npoints = points.size();
                if (npoints <= MAX_POINTS_IN_LINE) {
                        next.doFilter(element);
                        return;
                }

                log.debug("line has too many points, splitting");
                if(line.isRoad() && level == 0 && isRoutable) {
                        MapRoad road = ((MapRoad)line);
                        if (log.isDebugEnabled())
                                log.debug("Way " + road.getRoadDef() + " has more than "+ MAX_POINTS_IN_LINE + " points and is about to be split");
                }

                MapLine l = line.copy();

                List<Coord> coords = new ArrayList<Coord>();
                int count = 0;
                boolean first = true;
                int remaining = points.size();
                int wantedSize = (remaining < MAX_POINTS_IN_LINE + MIN_POINTS_IN_LINE) ? remaining / 2 + 10 : MAX_POINTS_IN_LINE;

                for (Coord co : points) {
                        coords.add(co);
                        --remaining;
                       
                        if (++count >= wantedSize) {
                                if (first)
                                        log.debug("saving first part");
                                else
                                        log.debug("saving next part");
                                l.setPoints(coords);
                                if (l instanceof MapRoad){
                                        ((MapRoad)l).setSegmentsFollowing(true);
                                }
                                next.doFilter(l);

                                l = line.copy();
                                count = 0;
                                first = false;
                                coords = new ArrayList<Coord>();
                                coords.add(co);
                                // make sure that the last part has at least 50 points
                                if (remaining > MAX_POINTS_IN_LINE && remaining < MAX_POINTS_IN_LINE + MIN_POINTS_IN_LINE)
                                        wantedSize = remaining / 2 + 10;
                        }
                }

                if (count != 0) {
                        log.debug("saving a final part");
                        l.setPoints(coords);
                        next.doFilter(l);
                }
        }
}