docs: private Coordinate[] mergeBoundary(Relation relation) {
          List<List<Long>> bounds = new ArrayList<>();
          for (RelationMember relationMember : relation.getMembers()) {
              if (relationMember.getMemberType().equals(EntityType.Way)
                      && "outer".equalsIgnoreCase(relationMember.getMemberRole())) {
                  List<Long> waynodes = writer.findWayNodesByWayID(relationMember.getMemberId());
                  if (waynodes != null && !waynodes.isEmpty()) {
                      bounds.add(waynodes);
                      continue;
                  }
                  LOGGER.finer("\n---> Member not found | Membertype= " + relationMember.getMemberType().name()
                          + ", Memberrole= " + relationMember.getMemberRole() + "\n");
                  continue;
              }
              LOGGER.finer("\n---> Member not accepted | Membertype= " + relationMember.getMemberType().name()
                      + ", Memberrole= " + relationMember.getMemberRole() + "\n");
          }
          //Merge bound nodes (There's may a simpler method)
          if (bounds.isEmpty()) {
              return null;
          }
          LOGGER.fine("Administrative: " + writer.getTagValue(relation.getTags(), "name")
                  + " #Members: " + relation.getMembers().size()
                  + " #Segments: " + bounds.size());
  
          //Iterate through given list
          final double threshold = 20; //In meters;
          for (int i = 1; i < bounds.size(); i++) {
              //Create second list, to compare values
              List<Long> I = bounds.get(i);
              List<Long> check = I;
              long nIa = I.get(0);
              long nIb = I.get(I.size() - 1);
              LatLong Ia = writer.findNodeByID(I.get(0));
              LatLong Ib = writer.findNodeByID(I.get(I.size() - 1));
              for (int j = 0; j < bounds.size(); j++) {
                  if (i == j) continue;
                  //LOGGER.info("j: "+ j+"; i: "+i);
                  List<Long> J = bounds.get(j);
                  long nJa = J.get(0);
                  long nJb = J.get(J.size() - 1);
                  LatLong Ja = writer.findNodeByID(J.get(0));
                  LatLong Jb = writer.findNodeByID(J.get(J.size() - 1));
                  if (Ia == null || Ib == null || Ja == null || Jb == null) return null;
                  //If first of I and last of J matches: merge
                  if (Ia.sphericalDistance(Jb) < threshold) {
                      I.remove(0);
                      J.addAll(I);
                      bounds.set(j, J);
                      bounds.remove(i);
                      i--;
                      LOGGER.finest("matches: " + Ia.latitude + ", " + Ia.longitude
                              + "; Ids: " + nIa + ", " + nJb);
                      break;
                  } else if (Ib.sphericalDistance(Jb) < threshold) {
                      //If list I is reversed
                      I = Lists.reverse(I);
                      I.remove(0);
                      J.addAll(I);
                      bounds.set(j, J);
                      bounds.remove(i);
                      i--;
                      LOGGER.finest("reverse I matches: " + Ib.latitude + ", " + Ib.longitude
                              + "; Ids: " + nIb + ", " + nJb);
                      break;
                  } else if (Ia.sphericalDistance(Ja) < threshold) {
                      //If list J is reversed
                      J = Lists.reverse(J);
                      I.remove(0);
                      J.addAll(I);
                      bounds.set(j, J);
                      bounds.remove(i);
                      i--;
                      LOGGER.finest("reverse J matches: " + Ia.latitude + ", " + Ia.longitude
                              + "; Ids: " + nIa + ", " + nJb);
                      break;
                  } else if (Ib.sphericalDistance(Ja) < threshold) {
                      //If both are reversed
                      J = Lists.reverse(J);
                      I = Lists.reverse(I);
                      I.remove(0);
                      J.addAll(I);
                      bounds.set(j, J);
                      bounds.remove(i);
                      i--;
                      LOGGER.finest("reverse Both matches: " + Ib.latitude + ", " + Ib.longitude
                              + "; Ids: " + nIb + ", " + nJa);
                      break;
                  }
              }
              //One path does'not match, so return
              if (bounds.contains(check) && bounds.size() > 1) {
                  LOGGER.finer("Merging failed");
                  return null; //continue if you want to add all calculatated boundary parts.
              }
          }
          LOGGER.finer("Bound merging finished; Size= " + bounds.size());
          //Check the result
          //TODO Calculate areas which have more than 1 circle bound. (Simple cover func.)
          if (bounds.size() != 1) {
              return null;
          }
          LOGGER.finer("Bound has right size; ");
  
          Long[] area = bounds.get(0).toArray(new Long[bounds.get(0).size()]);
          LatLong node = writer.findNodeByID(area[0]);
          if (node == null || node.sphericalDistance(writer.findNodeByID(area[area.length - 1])) >= threshold) {
              return null;
          }
          area[0] = area[area.length - 1];
          LOGGER.finer("Last node is first node; ");
          // Convert the way to a JTS polygon
          Coordinate[] coordinates = new Coordinate[area.length];
          for (int j = 0; j < area.length; j++) {
              LatLong wayNode = writer.findNodeByID(area[j]);
              if (wayNode == null) return null;
              coordinates[j] = new Coordinate(wayNode.longitude, wayNode.latitude);
          }
  
          return coordinates;
      }