import org.openstreetmap.josm.data.osm.Node; //导入依赖的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.Node; //导入依赖的package包/类
private void showDataFromLayer() {
    listModel.clear();
    indexToIdentifier.clear();
    identifierToIndex.clear();

    if (layer != null && layer.data != null && !layer.data.allPrimitives().isEmpty()) {
        int index = 0;

        // Build the maps and add the primitives to the list's model
        for (final OsmPrimitive osmPrimitive : layer.data.allPrimitives()) {
            if (osmPrimitive instanceof Node && osmPrimitive.getKeys().isEmpty()) { // skip points without tags
                    continue;
            }
            listModel.addElement(new PrintablePrimitive(index, osmPrimitive));
            indexToIdentifier.put(index, osmPrimitive.getPrimitiveId());
            identifierToIndex.put(osmPrimitive.getPrimitiveId(), index);
            index++;
        }
    }
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的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.Node; //导入依赖的package包/类
/**
 * The *result* does not depend on the current map selection state,
 * neither does the result *order*.
 * It solely depends on the distance to point p.
 *
 * This code is coped from JOSM code
 * 
 * @return a sorted map with the keys representing the distance of
 *      their associated nodes to point p.
 */
private Map<Double, List<Node>> getNearestNodesImpl(Point p) {
    TreeMap<Double, List<Node>> nearestMap = new TreeMap<>();
    DataSet ds = getCurrentDataSet();

    if (ds != null) {
        double dist, snapDistanceSq = 200;
        snapDistanceSq *= snapDistanceSq;

        for (Node n : ds.searchNodes(getBBox(p, 200))) {
            if ((dist = Main.map.mapView.getPoint2D(n).distanceSq(p)) < snapDistanceSq)
            {
                List<Node> nlist;
                if (nearestMap.containsKey(dist)) {
                    nlist = nearestMap.get(dist);
                } else {
                    nlist = new LinkedList<>();
                    nearestMap.put(dist, nlist);
                }
                nlist.add(n);
            }
        }
    }

    return nearestMap;
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的package包/类
/**
    * Forming commands for josm for saving stop area relation attributes
    * @param commands Original command list
 * @param stopArea Stop area object
    * @return Resulting command list
    */
private List<Command> createStopAreaRelation(List<Command> commands, StopArea stopArea) 
{
   	if(commands == null)
   		commands = new ArrayList<Command>();

   	Relation newRelation = new Relation();
	for(Node node : stopArea.stopPoints)
	{
		newRelation.addMember(new RelationMember(OSMTags.STOP_ROLE, node));
	}
	for(OsmPrimitive platform : stopArea.platforms)
	{
		newRelation.addMember(new RelationMember(OSMTags.PLATFORM_ROLE, platform));
	}
	for(OsmPrimitive otherMember : stopArea.otherMembers)
	{
		newRelation.addMember(new RelationMember("", otherMember));
	}
	Main.main.undoRedo.add(new AddCommand(newRelation));
	commands = generalTagAssign(newRelation, commands, stopArea);
	commands = assignTag(commands, newRelation, OSMTags.TYPE_TAG, OSMTags.PUBLIC_TRANSPORT_TAG);
	commands = assignTag(commands, newRelation, OSMTags.PUBLIC_TRANSPORT_TAG, OSMTags.STOP_AREA_TAG_VALUE);
   	return commands;
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的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.Node; //导入依赖的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.Node; //导入依赖的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.Node; //导入依赖的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.Node; //导入依赖的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.Node; //导入依赖的package包/类
/**
 * This method initializes numbers
 *
 * @return javax.swing.JTextField
 */
private JTextField getNumbers() {
    if (numbers == null) {
        numbers = new JTextField();

        Iterator<Node> it = housenumbers.iterator();
        StringBuilder s = new StringBuilder(256);
        if (it.hasNext()) {
            s.append(it.next().get("addr:housenumber"));
            while (it.hasNext()) {
                s.append(';').append(it.next().get("addr:housenumber"));
            }
        } else {
            numbersLabel.setVisible(false);
            numbers.setVisible(false);
        }

        numbers.setText(s.toString());
        numbers.setEditable(false);
    }
    return numbers;
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的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.Node; //导入依赖的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.Node; //导入依赖的package包/类
public List<Node> completeNetwork(List<Node> middleNodes, boolean newDData)
		throws NodeConnectException {
	if(newDData || osmNodeToRoutingNode==null || routingNodeToOsmNode==null)
		updateAllData();
	List<RoutingNode> wezly = new ArrayList<RoutingNode>();
	for (int i = 0; i < middleNodes.size() - 1; i++) {
		List<RoutingNode> wezlyTmp = dijkstraData.calculate(
				osmNodeToRoutingNode.get(middleNodes.get(i)),
				osmNodeToRoutingNode.get(middleNodes.get(i + 1)));
		if (i > 0)
			wezlyTmp = wezlyTmp.subList(1, wezlyTmp.size());
		wezly.addAll(wezlyTmp);
	}
	List<Node> wynik = new ArrayList<Node>();
	for (int i = 0; i < wezly.size(); i++) {
		wynik.add(routingNodeToOsmNode.get(wezly.get(i)));
	}
	return wynik;
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的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);
      if(selection2.size()<=1)
      {
          new Notification(
                  tr("Two or more nodes are necessary."))
                  .setIcon(JOptionPane.WARNING_MESSAGE)
                  .show();
      }
      RoutingLayer lay;
lay = new RoutingLayer(selection2, "xxx", new RoutingSpecial(Main.pref.getArray("easy-routes.weights")));
      Main.main.addLayer(lay);
  }
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的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.Node; //导入依赖的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.Node; //导入依赖的package包/类
public List <Node> getAllNodes() {
	if(middleNodes==null)
		return null;
	List <Node> wynik = new ArrayList<>();
	for(int i=0; i<middleNodes.size(); i++) {
		List <Node> mid = middleNodes.get(i);
		if(mid==null)
			return null;
		if(mid.size()<2)
			return null;
		for(int j=0; j<mid.size(); j++) {
			Node akt = mid.get(j);
			if(j>0 || i==0)
				wynik.add(akt);
		}
	}
	return wynik;
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的package包/类
private int getMiddleNodeId(Node n) {
	boolean containsAll = false;
	for(int i=0; i<middleNodes.size(); i++) {
		if(middleNodes.get(i)!=null && middleNodes.get(i).contains(n))
			containsAll = true;
	}
	if(!containsAll)
		return -1;
	if(crucialNodes.contains(n))
		return -1;
	for(int i=0; i<middleNodes.size(); i++) {
		if(middleNodes.get(i)!=null && middleNodes.get(i).contains(n))
			return i+1;
	}
	return -1;
}
 

import org.openstreetmap.josm.data.osm.Node; //导入依赖的package包/类
public void odswiez() {
	middleNodes = new ArrayList<>();
	boolean cale = true;
	for(int i=0; i<crucialNodes.size()-1; i++) {
		Node left = crucialNodes.get(i);
		Node right = crucialNodes.get(i+1);
		List <Node> tmp = new ArrayList<>();
		tmp.add(left);
		tmp.add(right);
		try {
			middleNodes.add(ws.completeNetwork(tmp, false));
		} catch (NodeConnectException e) {
			middleNodes.add(null);
			setName(desc+" NIEPOŁĄCZONE LINIE!");
			cale = false;
		}
	}
	if(cale)
		setName(desc);
	Main.map.repaint();
}