HullEdge.java

Go to the documentation of this file.

/* *********************************************************************** *
 * project: org.matsim.*
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 * copyright       : (C) 2013 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.algorithms.intersectionSimplifier.containers;

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

import org.locationtech.jts.geom.LineSegment;

public class HullEdge {
    private int id;
    
    private LineSegment geometry;

    private boolean border;

    private HullNode originNode;
    
    private HullNode destinationNode;

    private List<HullTriangle> triangles = new ArrayList<HullTriangle>();
    
    private List<HullEdge> incidentEdges = new ArrayList<HullEdge>();

    
    public HullEdge() {
        //
    }
    
    public HullEdge(int id) {
        this.id = id;
    }

    public HullEdge(int id, LineSegment geometry) {
        this.id = id;
        this.geometry = geometry;
    }

    public HullEdge(int id, boolean border) {
        this.id = id;
        this.border = border;
    }

    public HullEdge(int id, LineSegment geometry, boolean border) {
        this.id = id;
        this.geometry = geometry;
        this.border = border;
    }

    public HullEdge(int id, LineSegment geometry, HullNode oV, HullNode eV, boolean border) {
        this.id = id;
        this.geometry = geometry;
        this.originNode = oV;
        this.destinationNode = eV;
        this.border = border;
    }

    
    public int getId() {
        return this.id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public LineSegment getGeometry() {
        return this.geometry;
    }

    public void setGeometry(LineSegment geometry) {
        this.geometry = geometry;
    }

    public boolean isBorder() {
        return this.border;
        /*TODO Change this so that it checks the number of triangles with which
         * the edge is associated. At least throw a warning if the boolean
         * attribute remains, by checking the number of related triangles before
         * returning the boolean value. */
    }

    public void setBorder(boolean border) {
        this.border = border;
        
        /* If an edge is changed to a border edge, also flag both origin and 
         * destination node as border nodes. The opposite, however, is NOT true:
         * that is, if an edge is an internal edge, one (or both) of its nodes
         * may be border nodes.
         */
        if(border == true){
            this.originNode.setBorder(true);
            this.destinationNode.setBorder(true);
        }
    }
    
    public HullNode getOriginNode() {
        return this.originNode;
    }

    public void setOriginNode(HullNode originNode) {
        this.originNode = originNode;
    }

    public HullNode getDestinationNode() {
        return this.destinationNode;
    }

    public void setDestinationNode(HullNode destinationNodeV) {
        this.destinationNode = destinationNodeV;
    }
    
    public List<HullTriangle> getTriangles() {
        return this.triangles;
    }

    public void setTriangles(List<HullTriangle> triangles) {
        this.triangles = triangles;
    }

    public List<HullEdge> getIncidentEdges() {
        return this.incidentEdges;
    }

    public void setIncidentEdges(List<HullEdge> edges) {
        this.incidentEdges = edges;
    }

    public boolean addTriangle(HullTriangle triangle) {
        return getTriangles().add(triangle);
    }

    public boolean addTriangles(List<HullTriangle> triangles) {
        return getTriangles().addAll(triangles);
    }

    public boolean removeTriangle(HullTriangle triangle) {
        return getTriangles().remove(triangle);
    }

    public boolean removeTriangles(List<HullTriangle> triangles) {
        return getTriangles().removeAll(triangles);
    }

    public boolean addIncidentEdge(HullEdge edge) {
        return getIncidentEdges().add(edge);
    }

    public boolean addIncidentEdges(List<HullEdge> edges) {
        return getIncidentEdges().addAll(edges);
    }

    public boolean removeIncidentEdge(HullEdge edge) {
        return getIncidentEdges().remove(edge);
    }

    public boolean removeAllIncidentEdges(List<HullEdge> edges) {
        return getIncidentEdges().removeAll(edges);
    }
}