import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * The level is defined if all the tagged nodes show the same level
 * @param way
 * @return
 */
private Integer getLevel(Way way) {
    Integer guest = null;
    for(Node n : way.getNodes()) {
        if(n.getKeys().containsKey(LEVEL)) {
            int nextGuest = Integer.parseInt(n.get(LEVEL));
            if(null == guest) {
                guest = nextGuest;
            } else {
                if(guest != nextGuest) {
                    // The way cover at least 2 levels
                    return null;
                }
            }
        }
    }
    return guest;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
private Way createWay(final List<LngLatAlt> coordinates) {
    if (coordinates.isEmpty()) {
        return null;
    }
    final Way way = new Way();

    final List<Node> nodes = new ArrayList<>(coordinates.size());

    for (final LngLatAlt point : coordinates) {
        final Node node = createNode(point);

        nodes.add(node);
    }
    way.setNodes(nodes);

    dataSet.addPrimitive(way);

    return way;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Testing, is josm object bus stop node or contains bus stop node, defined by tag and its value
 * @param member Josm object
 * @param tag Tag name
 * @param tagValue Tag value
 * @return true, if josm object is bus stop node or contains bus stop node
 */
private Node searchBusStop(OsmPrimitive member, String tag, String tagValue)
{
	if(member instanceof Node)
	{			
		if(compareTag(member, tag, tagValue))
		{
			return (Node)member;
		}
	}
	else
	{
		Way memberWay = (Way) member;
		for(Node node : memberWay.getNodes())
		{
			if(compareTag(node, tag, tagValue))
			{
				return node;
			}					
		}
	}
	return null;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Clear excess tags from JOSM object and its nodes
 * @param commands Original command list
 * @param target JOSM object
 * @param tag Tag name
 * @param tagValue Tag value
 * @return Resulting command list
 */
private List<Command> clearExcessTags(List<Command> commands, OsmPrimitive target, String tag, String tagValue)
{
   	if(commands == null)
   		commands = new ArrayList<Command>();

   	if(compareTag(target, tag, tagValue))
	{
		commands = clearTag(commands, target, tag);
	}
	if(target instanceof Way)
	{
		Way memberWay = (Way) target;
		for(Node node : memberWay.getNodes())
		{
			if(compareTag(node, tag, tagValue))
			{
				commands = clearTag(commands, target, tag);
			}					
		}
	}
	return commands;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Create separate bus stop node or assign bus stop tag to platform node
 * @param commands Original command list
 * @param stopArea Stop area object
 * @param firstPlatform First platform in stop area relation
 * @param tag Tag name
 * @param tagValue Tag value
 * @return Resulting command list
 */
protected List<Command> createSeparateBusStopNode(List<Command> commands, StopArea stopArea, OsmPrimitive firstPlatform, String tag, String tagValue)
{
   	if(commands == null)
   		commands = new ArrayList<Command>();

   	LatLon centerOfPlatform = getCenterOfWay(firstPlatform);
	if(firstPlatform instanceof Way)
	{
		if(centerOfPlatform != null)
		{
			Node newNode =new Node();
			newNode.setCoor(centerOfPlatform);
	    	Main.main.undoRedo.add(new AddCommand(newNode));
	    	Main.main.undoRedo.add(new ChangePropertyCommand(newNode, tag, tagValue));
			commands = assignTag(commands, newNode, tag, tagValue);
			stopArea.otherMembers.add(newNode);
		}
	}
	else
	{
   		commands = assignTag(commands, firstPlatform, tag, tagValue);
	}
	return commands;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
   * Calculation of center of platform, if platform is way
   * @param platform Platform primitive
   * @return Coordinates of center of platform
   */
  public static LatLon getCenterOfWay(OsmPrimitive platform)
  {
if(platform instanceof Way)
{ 
	//p = mapView.getPoint((Node) stopArea.selectedObject);
	Double sumLat = 0.0;
	Double sumLon = 0.0;
	Integer countNode = 0;
	for(Node node : ((Way) platform).getNodes())
	{
		LatLon coord = node.getCoor();
		sumLat += coord.getX();
		sumLon += coord.getY();
		countNode++;
	}
	return new LatLon(sumLon / countNode, sumLat / countNode);		
}
return null;
  }
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Switches to Improving state
 *
 * @param targetWay Way that is going to be improved
 */
public void startImproving(Way targetWay) {
    state = State.improving;

    Collection<OsmPrimitive> currentSelection = getCurrentDataSet().getSelected();
    if (currentSelection.size() != 1
            || !currentSelection.iterator().next().equals(targetWay)) {
        selectionChangedBlocked = true;
        getCurrentDataSet().clearSelection();
        getCurrentDataSet().setSelected(targetWay.getPrimitiveId());
        selectionChangedBlocked = false;
    }

    this.targetWay = targetWay;
    this.candidateNode = null;
    this.candidateSegment = null;

    mv.repaint();
    updateStatusLine();
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Instantiates a new house number input handler.
 *
 * @param terracerAction the terracer action
 * @param outline the closed, quadrilateral way to terrace.
 * @param template the closed, template for the terrace
 * @param init The node that hints at which side to start the numbering
 * @param street the street, the buildings belong to (may be null)
 * @param streetName the name of the street, derived from either the street line or
 *            the house numbers which are guaranteed to have the same name
 *            attached (may be null)
 * @param buildingType The value to add for building key
 * @param associatedStreet a relation where we can add the houses (may be null)
 * @param housenumbers a list of house number nodes in this outline (may be empty)
 * @param title the title
 */
public HouseNumberInputHandler(final TerracerAction terracerAction,
        final Way outline, final Way template, final Node init, final Way street, final String streetName, final String buildingType,
        final Relation associatedStreet,
        final ArrayList<Node> housenumbers, final String title) {
    this.terracerAction = terracerAction;
    this.outline = outline;
    this.template = template;
    this.init = init;
    this.street = street;
    this.streetName = streetName;
    this.associatedStreet = associatedStreet;
    this.housenumbers = housenumbers;

    this.dialog = new HouseNumberInputDialog(this, street, streetName, buildingType,
            associatedStreet != null, housenumbers);
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Creates a node at a certain distance along a way, as calculated by the
 * great circle distance.
 *
 * Note that this really isn't an efficient way to do this and leads to
 * O(N^2) running time for the main algorithm, but its simple and easy
 * to understand, and probably won't matter for reasonable-sized ways.
 *
 * @param w The way to interpolate.
 * @param l The length at which to place the node.
 * @return A node at a distance l along w from the first point.
 */
private Node interpolateAlong(Way w, double l) {
    List<Pair<Node,Node>> pairs = w.getNodePairs(false);
    for (int i = 0; i < pairs.size(); ++i) {
        Pair<Node,Node> p = pairs.get(i);
        final double seg_length = p.a.getCoor().greatCircleDistance(p.b.getCoor());
        if (l <= seg_length || i == pairs.size() - 1) {
            // be generous on the last segment (numerical roudoff can lead to a small overshoot)
            return interpolateNode(p.a, p.b, l / seg_length);
        } else {
            l -= seg_length;
        }
    }
    // we shouldn't get here
    throw new IllegalStateException();
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Calculate "sideness" metric for each segment in a way.
 */
private double[] calculateSideness(Way w) {
    final int length = w.getNodesCount() - 1;
    double[] sideness = new double[length];

    sideness[0] = calculateSideness(w.getNode(length - 1), w.getNode(0), w
            .getNode(1), w.getNode(2));
    for (int i = 1; i < length - 1; ++i) {
        sideness[i] = calculateSideness(w.getNode(i - 1), w.getNode(i), w
                .getNode(i + 1), w.getNode(i + 2));
    }
    sideness[length - 1] = calculateSideness(w.getNode(length - 2), w
            .getNode(length - 1), w.getNode(length), w.getNode(1));

    return sideness;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
private void extractRelation(Relation rel) {
	List <RelationMember> members = rel.getMembers();
	for(RelationMember x : members) {
		if(x.getRole().equals("forward") || x.getRole().equals("backward") || x.getRole().equals(""))
			if(x.getType()==OsmPrimitiveType.WAY) {
				Way w = x.getWay();
				List <Node> y = w.getNodes();
				for(int i=0; i<y.size()-1; i++) {
					Node a = y.get(i);
					Node b = y.get(i+1);
					Pair <Node, Node> tmp2 = new Pair<>(a,b);
					pairsRelations.add(tmp2);
				}
			}
	}
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
public void putRelationWays(Relation x) {
	if(lay==null)
		return;
	List<Way> toAdd;
	List<String> forBack = new ArrayList<>();
	try {
		toAdd = lay.splitWays(forBack);
	int i=0;
	for(Way y : toAdd) {
		String foo = "";
		if(forBack!=null && forBack.size()>i && forBack.get(i)!=null)
			foo=forBack.get(i);
		RelationMember member = new RelationMember(foo, y);
		x.addMember(member);
		i++;
	}
	}catch (NodeConnectException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
void foo3(List<Node> lis) {
	try {
		Collection<Collection<String>> aktPreferences = Main.pref
				.getArray("easy-routes.weights");
		RoutingSpecial ws = new RoutingSpecial(aktPreferences);
		ws.splitWays(lis);
		getCurrentDataSet().clearSelection();
		List<Way> xd = ws.getWaysAfterSplit(lis);
		for (Way x : xd) {
			getCurrentDataSet().addSelected(x);
		}
	} catch (NodeConnectException e) {
		e.printStackTrace();
		new Notification(tr("Nodes are not connect together")).setIcon(
				JOptionPane.WARNING_MESSAGE).show();
	}
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent e) {
	if (!isEnabled() || !Main.map.mapView.isActiveLayerVisible())
		return;

	Collection<OsmPrimitive> selection = getCurrentDataSet().getSelected();
	List<Node> selection2 = OsmPrimitive.getFilteredList(selection,
			Node.class);
	List<Way> selection3 = OsmPrimitive.getFilteredList(selection,
			Way.class);
	if (selection2.size() > 1) {
		foo3(selection2);

	} else if (selection3.size()==2) {
		foo4(selection3);
	} else {
		new Notification(tr("Two or more nodes are necessary, or two ways.")).setIcon(
				JOptionPane.WARNING_MESSAGE).show();
	}
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
public void addToGraph(Node n, Relation g) {
    if(!g.getMemberPrimitives().contains(n)) {
        Main.debug("> Add node to relation");
        g.addMember(new RelationMember(Constants.OSM_RELATION_ROLE_STATE, n));
        // WORKAROUND2: Add to the graph the ways linked to the node
        for(OsmPrimitive p : n.getReferrers(false)) {
            if(p instanceof Way) {
                Main.debug("> I found a related way");
                addToGraph((Way)p, g);
            }
        }
    }
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Focus the map on a specific OSM primitive
 *
 * @param primitive
 *            The primitive to zoom to
 */
private void zoomTo(final OsmPrimitive primitive) {
    if (primitive == null) {
        return;
    }
    if (primitive instanceof Node) {
        MainApplication.getMap().mapView.zoomTo(((Node) primitive).getCoor());
        return;
    }
    final BoundingXYVisitor v = new BoundingXYVisitor();
    v.visit((Way) primitive);
    MainApplication.getMap().mapView.zoomTo(v.getBounds());
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
private void processLineString(final Feature feature, final List<LngLatAlt> coordinates) {
    if (coordinates.isEmpty()) {
        return;
    }
    final Way way = createWay(coordinates);

    fillTagsFromFeature(feature, way);
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Search of nearest points on ways 
 * @param platformCoord Platform coordinates 
 * @param stopArea Stop area object
 * @return Dictionary of founded points and distances from platform
 */
public AbstractMap.SimpleEntry<Double, Node> getNearestNode(LatLon platformCoord, StopArea stopArea)
{
	Point p = Main.map.mapView.getPoint(platformCoord);
	Map<Double, List<Node>> dist_nodes = getNearestNodesImpl(p);
	Double[] distances = dist_nodes.keySet().toArray(new Double[0]);
	distances = sort(distances);
	Integer distanceIndex = -1;
	Node nearestNode = null;
	while(++distanceIndex < distances.length && nearestNode == null)
	{
		List<Node> nodes = dist_nodes.get(distances[distanceIndex]);
		for(Node node : nodes)
		{
			for(Way way : getCurrentDataSet().getWays())
			{
				if(way.getNodes().contains(node) && testWay(way, stopArea))
				{
					nearestNode = node;
					return new AbstractMap.SimpleEntry<Double, Node> (distances[distanceIndex], nearestNode);
				}
			}
			if(nearestNode != null)
				break;
		}
	}
	return null;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Selection of ways for stop position by type of way and type of stop
 * @param way The way
 * @param stopArea Stop area
 * @return true, if way can contain stop position
 */
public Boolean testWay(Way way, StopArea stopArea)
{
	if(stopArea.isTrainStation || stopArea.isTrainStop)
	{
		if(OSMTags.RAIL_TAG_VALUE.equals(way.getKeys().get(OSMTags.RAILWAY_TAG)) && OSMTags.MAIN_TAG_VALUE.equals(way.getKeys().get(OSMTags.USAGE_TAG)))
			return true;
		return false;
	}

	if(stopArea.isTram)
	{
		if(OSMTags.TRAM_TAG_VALUE.equals(way.getKeys().get(OSMTags.RAILWAY_TAG)))
			return true;
		return false;
	}
	
	String[] highwayValues = {OSMTags.TRUNK_TAG_VALUE, OSMTags.PRIMARY_TAG_VALUE, OSMTags.SECONDARY_TAG_VALUE, OSMTags.TERTIARY_TAG_VALUE,
			OSMTags.UNCLASSIFIED_TAG_VALUE, OSMTags.RESIDENTIAL_TAG_VALUE, OSMTags.SERVICE_TAG_VALUE,
			OSMTags.BUS_GUIDEWAY_TAG_VALUE, OSMTags.ROAD_TAG_VALUE, OSMTags.TRUNK_LINK_TAG_VALUE, 
			OSMTags.PRIMARY_LINK_TAG_VALUE, OSMTags.SECONDARY_LINK_TAG_VALUE, OSMTags.TERTIARY_LINK_TAG_VALUE };
	if(stopArea.isBus || stopArea.isTrolleybus || stopArea.isShareTaxi)
	{
		String highway = way.getKeys().get(OSMTags.HIGHWAY_TAG);
		if(highway != null)
		for(Integer i = 0; i < highwayValues.length; i++)
		{
			if(highwayValues[i].equals(highway))
				return true;
		}
	}
	return false;
}
 

import org.openstreetmap.josm.data.osm.Way; //导入依赖的package包/类
/**
 * Creation of stop position node on nearest way
 * @param newStopNode New stop position node
 * @param waySegment Way segment including stop position node
 * @return Stop position node
 */
protected Node createNodeOnWay(Node newStopNode, WaySegment waySegment)
{
	Main.main.undoRedo.add(new AddCommand(newStopNode));
	List<Node> wayNodes = waySegment.way.getNodes();
	wayNodes.add(waySegment.lowerIndex + 1, newStopNode); 
	Way newWay = new Way(waySegment.way);
	newWay.setNodes(wayNodes);
	Main.main.undoRedo.add(new ChangeCommand(waySegment.way, newWay));
	return newStopNode;
}