NetworkReaderTeleatlas.java

Go to the documentation of this file.

/* *********************************************************************** *
 * project: org.matsim.*
 * NetworkReaderTeleatlas.java
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 * copyright       : (C) 2008 by the members listed in the COPYING,        *
 *                   LICENSE and WARRANTY file.                            *
 * email           : info at matsim dot org                                *
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *   See also COPYING, LICENSE and WARRANTY file                           *
 *                                                                         *
 * *********************************************************************** */

package org.matsim.core.network.io;

import java.io.IOException;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.geotools.api.data.SimpleFeatureSource;
import org.geotools.api.feature.simple.SimpleFeature;
import org.geotools.api.geometry.BoundingBox;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.matsim.api.core.v01.Coord;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.network.Link;
import org.matsim.api.core.v01.network.Network;
import org.matsim.api.core.v01.network.Node;
import org.matsim.core.api.internal.MatsimSomeReader;
import org.matsim.core.network.NetworkUtils;
import org.matsim.core.utils.gis.GeoFileReader;

public final class NetworkReaderTeleatlas implements MatsimSomeReader {

    // ////////////////////////////////////////////////////////////////////
    // member variables
    // ////////////////////////////////////////////////////////////////////

    private final static Logger log = LogManager.getLogger(NetworkReaderTeleatlas.class);

    private final Network network;

    private final String jcShpFileName; // teleatlas junction shape file name

    private final String nwShpFileName; // teleatlas network shape file name

    public boolean ignoreFrcType8 = false;

    public boolean ignoreFrcType7onewayN = false;

    public int maxFrcTypeForDoubleLaneLink = 3;

    public int minSpeedForNormalCapacity = 40; // km/h

    private static final String NODE_ID_NAME = "ID";
    private static final String NODE_FEATTYP_NAME = "FEATTYP";
    private static final String NODE_JNCTTYP_NAME = "JNCTTYP";

    private static final String LINK_ID_NAME = "ID";
    private static final String LINK_FEATTYP_NAME = "FEATTYP";
    private static final String LINK_FERRYTYP_NAME = "FT";
    private static final String LINK_FJNCTID_NAME = "F_JNCTID";
    private static final String LINK_TJNCTID_NAME = "T_JNCTID";
    private static final String LINK_LENGTH_NAME = "METERS";
    private static final String LINK_FRCTYP_NAME = "FRC";
    private static final String LINK_ONEWAY_NAME = "ONEWAY";
    private static final String LINK_SPEED_NAME = "KPH";
    private static final String LINK_LANES_NAME = "LANES";

    // TODO balmermi: probably we also need to consider the following attributes
    // but for the ch-teleatlas-net version 2008 it was not necessary
    // PRIVATERD Private Road
    // 0: No Special Restriction (default)
    // 2: Not Publicly Accessible
    // CONSTATUS Construction Status
    // Blank: Not Under Construction (default)
    // FT: Under Construction in Positive Direction
    // N: Under Construction in Both Directions
    // TF: Under Construction in Negative Direction
    // F_BP From (Start) Blocked Passage
    // 0: No Blocked Passage at Start Junction (default)
    // 1: Blocked Passage at Start Junction
    // T_BP To (End) Blocked Passage
    // 0: No Blocked Passage at End Junction (default)
    // 2: Blocked Passage at End Junction

    // ////////////////////////////////////////////////////////////////////
    // constructors
    // ////////////////////////////////////////////////////////////////////

    public NetworkReaderTeleatlas(final Network network, final String jcShpFileName, final String nwShpFileName) {
        this.network = network;
        this.jcShpFileName = jcShpFileName;
        this.nwShpFileName = nwShpFileName;
    }

    // ////////////////////////////////////////////////////////////////////
    // read methods
    // ////////////////////////////////////////////////////////////////////

    public void read() throws IOException {
        log.info("reading nodes from Junction Shape file '" + this.jcShpFileName + "'...");
        this.readNodesFromJCshp();
        log.info("done.");
        log.info("reading links from Network Shape file '" + this.nwShpFileName + "'...");
        this.readLinksFromNWshp();
        log.info("done.");
        // TODO balmermi: adding date and check if you get more info from the input
        // files to include into the name
        network.setName("teleatlas");
    }

    // ////////////////////////////////////////////////////////////////////

    private void readNodesFromJCshp() throws IOException {
        int nCnt = network.getNodes().size();
        SimpleFeatureSource fs = GeoFileReader.readDataFile(jcShpFileName);
        SimpleFeatureIterator fIt = fs.getFeatures().features();
        while (fIt.hasNext()) {
            SimpleFeature f = fIt.next();
            // get node attributes
            // Coordinate c = f.getBounds().centre();
            BoundingBox bb = f.getBounds();
            Coord c = new Coord((bb.getMinX() + bb.getMaxX()) / 2.0, (bb.getMinY() + bb.getMaxY()) / 2.0);

            Object id = f.getAttribute(NODE_ID_NAME);
            int feattyp = Integer.parseInt(f.getAttribute(NODE_FEATTYP_NAME).toString());
            if ((feattyp != 4120) && (feattyp != 4220)) {
                throw new IllegalArgumentException(NODE_ID_NAME + "=" + id + ": " + NODE_FEATTYP_NAME + "=" + feattyp + " not allowed.");
            }
            int jncttyp = Integer.parseInt(f.getAttribute(NODE_JNCTTYP_NAME).toString());
            if ((jncttyp < 0) || (jncttyp == 1) || (jncttyp > 6)) {
                throw new IllegalArgumentException(NODE_ID_NAME + "=" + id + ": " + NODE_JNCTTYP_NAME + "=" + jncttyp + " not allowed.");
            }
            if (id == null) {
                throw new IllegalArgumentException("In " + jcShpFileName + ": There is at least one feature that does not have an ID set.");
            }
            String type = feattyp + "-" + jncttyp;
            Node n = network.getFactory().createNode(Id.create(id.toString(), Node.class), c);
            final String type1 = type;
            Node r = n;
            NetworkUtils.setType(r,type1);
            network.addNode(n);
        }
        fIt.close();
        nCnt = network.getNodes().size() - nCnt;
        log.info("  " + nCnt + " nodes added to the network.");
    }

    // ////////////////////////////////////////////////////////////////////

    private void readLinksFromNWshp() throws IOException {
        int lCnt = network.getLinks().size();
        int ignoreCnt = 0;
        SimpleFeatureSource fs = GeoFileReader.readDataFile(this.nwShpFileName);
        SimpleFeatureIterator fIt = fs.getFeatures().features();
        while (fIt.hasNext()) {
            SimpleFeature f = fIt.next();
            boolean ignore = false;
            // get link attributes
            Object id = f.getAttribute(LINK_ID_NAME);
            int featTyp = Integer.parseInt(f.getAttribute(LINK_FEATTYP_NAME).toString());
            if ((featTyp != 4110) && (featTyp != 4130) && (featTyp != 4165)) {
                throw new IllegalArgumentException(LINK_ID_NAME + "=" + id + ": " + LINK_FEATTYP_NAME + "=" + featTyp + " not allowed.");
            }
            int ferryType = Integer.parseInt(f.getAttribute(LINK_FERRYTYP_NAME).toString());
            if ((ferryType < 0) || (ferryType > 2)) {
                throw new IllegalArgumentException(LINK_ID_NAME + "=" + id + ": " + LINK_FERRYTYP_NAME + "=" + ferryType + " not allowed.");
            }
            Id<Node> fromJunctionId = Id.create(f.getAttribute(LINK_FJNCTID_NAME).toString(), Node.class);
            Id<Node> toJunctionId = Id.create(f.getAttribute(LINK_TJNCTID_NAME).toString(), Node.class);
            double length = Double.parseDouble(f.getAttribute(LINK_LENGTH_NAME).toString());
            int linksType = Integer.parseInt(f.getAttribute(LINK_FRCTYP_NAME).toString());
            if ((linksType < -1) || (linksType > 8)) {
                throw new IllegalArgumentException(LINK_ID_NAME + "=" + id + ": " + LINK_FRCTYP_NAME + "=" + linksType + " not allowed.");
            }
            String oneway = f.getAttribute(LINK_ONEWAY_NAME).toString();
            if (!oneway.equals(" ") && !oneway.equals("FT") && !oneway.equals("TF") && !oneway.equals("N")) {
                throw new IllegalArgumentException(LINK_ID_NAME + "=" + id + ": " + LINK_ONEWAY_NAME + "=" + oneway + " not allowed.");
            }
            double speed = Double.parseDouble(f.getAttribute(LINK_SPEED_NAME).toString());
            double lanes = Double.parseDouble(f.getAttribute(LINK_LANES_NAME).toString());
            // ignore link where from node or to node is missing
            Node fNode = network.getNodes().get(fromJunctionId);
            Node tNode = network.getNodes().get(toJunctionId);
            if ((fNode == null) || (tNode == null)) {
                log.warn("  linkId=" + id.toString()
                        + ": at least one of the two junctions do not exist. Ignoring and proceeding anyway...");
                ignore = true;
            }
            // ignore link that is not a 'Road Element' (4110) or a 'Ferry Connection Element' (4130)
            // There are 'Address Area Boundary Element' (4165) links that will be ignored
            if ((featTyp != 4110) && (featTyp != 4130)) {
                log.trace("  linkId=" + id.toString() + ": ignoring " + LINK_FEATTYP_NAME + "=" + featTyp + ".");
                ignore = true;
            }
            // ignore links FRC types = -1 [Not Applicable (for FeatTyp 4165)]
            if (linksType < 0) {
                log.trace("  linkId=" + id.toString() + ": ignoring " + LINK_FRCTYP_NAME + "=" + linksType + ".");
                ignore = true;
            }
            // option flag: ignore links FRC type = 8 [Other Road]
            if (this.ignoreFrcType8 && (7 < linksType)) {
                log.trace("  linkId=" + id.toString() + ": ignoring " + LINK_FRCTYP_NAME + "=" + linksType + ".");
                ignore = true;
            }
            // ignore links FRC types = 7 [Local Road of Minor Importance] that are ONEWAY = N [Closed in Both Directions]
            // links with type < 7 also contains ONEWAY = N but should be open anyway....
            if (this.ignoreFrcType7onewayN && ((linksType == 7) && oneway.equals("N"))) {
                log.trace("  linkId=" + id.toString() + ": ignoring " + LINK_FRCTYP_NAME + "=" + linksType + " with " + LINK_ONEWAY_NAME
                        + "=" + oneway);
                ignore = true;
            }

            // simple rule for number of lanes (a lot of them are = 0, so we need to define something)
            if (lanes < 1) {
                if (linksType <= this.maxFrcTypeForDoubleLaneLink) {
                    lanes = 2;
                } else {
                    lanes = 1;
                }
            }
            // simple rule for setting capacities
            double cap;
            if (speed < minSpeedForNormalCapacity) {
                cap = lanes * 1000;
            } else {
                cap = lanes * 2000;
            }

            if (ignore) {
                ignoreCnt++;
            } else {
                if (oneway.equals(" ") || oneway.equals("N")) {
                    Link l = network.getFactory().createLink(Id.create(id.toString() + "FT", Link.class), fNode, tNode);
                    l.setLength(length);
                    l.setFreespeed(speed / 3.6);
                    l.setCapacity(cap);
                    l.setNumberOfLanes(lanes);
                    NetworkUtils.setOrigId(l, id.toString() ) ;
                    NetworkUtils.setType(l, linksType + "-" + featTyp + "-" + ferryType);
                    l = network.getFactory().createLink(Id.create(id.toString() + "TF", Link.class), tNode, fNode);
                    l.setLength(length);
                    l.setFreespeed(speed / 3.6);
                    l.setCapacity(cap);
                    l.setNumberOfLanes(lanes);
                    NetworkUtils.setOrigId(l, id.toString() ) ;
                    NetworkUtils.setType(l, linksType + "-" + featTyp + "-" + ferryType);
                } else if (oneway.equals("FT")) {
                    Link l = network.getFactory().createLink(Id.create(id.toString() + oneway, Link.class), fNode, tNode);
                    l.setLength(length);
                    l.setFreespeed(speed / 3.6);
                    l.setCapacity(cap);
                    l.setNumberOfLanes(lanes);
                    NetworkUtils.setOrigId(l, id.toString() ) ;
                    NetworkUtils.setType(l, linksType + "-" + featTyp + "-" + ferryType);
                } else if (oneway.equals("TF")) {
                    Link l = network.getFactory().createLink(Id.create(id.toString() + oneway, Link.class), tNode, fNode);
                    l.setLength(length);
                    l.setFreespeed(speed / 3.6);
                    l.setCapacity(cap);
                    l.setNumberOfLanes(lanes);
                    NetworkUtils.setOrigId(l, id.toString() ) ;
                    NetworkUtils.setType(l, linksType + "-" + featTyp + "-" + ferryType);
                } else {
                    throw new IllegalArgumentException("linkId=" + id.toString() + ": " + LINK_ONEWAY_NAME + "=" + oneway + " not known!");
                }
            }
        }
        fIt.close();

        network.setCapacityPeriod(3600.0);

        lCnt = network.getLinks().size() - lCnt;
        log.info("  " + lCnt + " links added to the network layer.");
        log.info("  " + ignoreCnt + " links ignored from the input shape file.");
    }

    // ////////////////////////////////////////////////////////////////////
    // print methods
    // ////////////////////////////////////////////////////////////////////

    public final void printInfo(final String prefix) {
        System.out.println(prefix + "configuration of " + this.getClass().getName() + ":");
        System.out.println(prefix + "  MATSim network:");
        System.out.println(prefix + "    ignoreFrcType8:              " + ignoreFrcType8);
        System.out.println(prefix + "    ignoreFrcType7onewayN:       " + ignoreFrcType7onewayN);
        System.out.println(prefix + "    maxFrcTypeForDoubleLaneLink: " + maxFrcTypeForDoubleLaneLink);
        System.out.println(prefix + "    minSpeedForNormalCapacity:   " + minSpeedForNormalCapacity);
        System.out.println(prefix + "  junction shape:");
        System.out.println(prefix + "    jcShpFileName:      " + jcShpFileName);
        System.out.println(prefix + "    NODE_ID_NAME:       " + NODE_ID_NAME);
        System.out.println(prefix + "    NODE_FEATTYP_NAME:  " + NODE_FEATTYP_NAME);
        System.out.println(prefix + "    NODE_JNCTTYP_NAME:  " + NODE_JNCTTYP_NAME);
        System.out.println(prefix + "  network shape:");
        System.out.println(prefix + "    nwShpFileName:      " + nwShpFileName);
        System.out.println(prefix + "    LINK_ID_NAME:       " + LINK_ID_NAME);
        System.out.println(prefix + "    LINK_FEATTYP_NAME:  " + LINK_FEATTYP_NAME);
        System.out.println(prefix + "    LINK_FERRYTYP_NAME: " + LINK_FERRYTYP_NAME);
        System.out.println(prefix + "    LINK_FJNCTID_NAME:  " + LINK_FJNCTID_NAME);
        System.out.println(prefix + "    LINK_TJNCTID_NAME:  " + LINK_TJNCTID_NAME);
        System.out.println(prefix + "    LINK_LENGTH_NAME:   " + LINK_LENGTH_NAME);
        System.out.println(prefix + "    LINK_FRCTYP_NAME:   " + LINK_FRCTYP_NAME);
        System.out.println(prefix + "    LINK_ONEWAY_NAME:   " + LINK_ONEWAY_NAME);
        System.out.println(prefix + "    LINK_SPEED_NAME:    " + LINK_SPEED_NAME);
        System.out.println(prefix + "    LINK_LANES_NAME:    " + LINK_LANES_NAME);
        System.out.println(prefix + "done.");
    }
}