示例#1
0
  /**
   * Return the ListEdge in the road network which is closest to the given coordinate, within the
   * given resolution
   *
   * @param c
   * @param resolution
   * @return
   */
  public ListEdge getClosestEdge(Coordinate c, double resolution) {

    // find the set of all edges within *resolution* of the given point
    Bag objects = networkEdgeLayer.getObjectsWithinDistance(fa.createPoint(c), resolution);
    if (objects == null || networkEdgeLayer.getGeometries().size() <= 0)
      return null; // problem with the network edge layer

    Point point = fa.createPoint(c);

    // find the closest edge among the set of edges
    double bestDist = resolution;
    ListEdge bestEdge = null;
    for (Object o : objects) {
      double dist = ((MasonGeometry) o).getGeometry().distance(point);
      if (dist < bestDist) {
        bestDist = dist;
        bestEdge =
            (ListEdge) ((AttributeValue) ((MasonGeometry) o).getAttribute("ListEdge")).getValue();
      }
    }

    // if it exists, return it
    if (bestEdge != null) return bestEdge;

    // otherwise return failure
    else return null;
  }
示例#2
0
  private School findAppropriateSchool(int age, Point location) {
    GeomVectorField zones;
    if (age < 11) {
      zones = elementarySchoolZones;
    } else if (age < 15) {
      zones = middleSchoolZones;
    } else {
      zones = highSchoolZones;
    }

    Bag catchment = zones.getContainingObjects(location);

    if (catchment.numObjs != 1) {
      System.out.format(
          "Error: school search (age: %d, location: %s) found %d catchments.\n",
          age, location, catchment.numObjs);
      for (int i = 0; i < catchment.numObjs; i++) {
        System.out.format(
            "    Catchment %d: %s\n",
            i, ((MasonGeometry) catchment.get(i)).getAttribute("SCHID_3"));
      }
      return null;
    }

    MasonGeometry mg = (MasonGeometry) catchment.get(0);
    Integer num = mg.getIntegerAttribute("SCHOOL_NUM");

    return schoolMap.get(num);
  }
示例#3
0
  private void addAgents() {
    // Agent a = null;

    for (int i = 0; i < NUM_AGENTS; i++) {
      // pick a random political region to plop the agent in
      Bag allRegions = county.getGeometries();

      if (allRegions.isEmpty()) {
        // Something went wrong.  We *should* have regions.
        throw new RuntimeException("No regions found.");
      }
      MasonGeometry region = ((MasonGeometry) allRegions.objs[random.nextInt(allRegions.numObjs)]);

      // give each agent a random direction to initially move in
      Agent a = new Agent(random.nextInt(8));

      // set each agent in the center of corresponding region
      a.setLocation(region.getGeometry().getCentroid());

      // place the agents in the GeomVectorField
      agents.addGeometry(new MasonGeometry(a.getGeometry()));

      // add the new agent the schedule
      schedule.scheduleRepeating(a);
    }
  }
示例#4
0
  @Override
  public void start() {
    super.start();

    agents.clear(); // remove any agents from previous runs

    // add agents to the simulation
    addAgents();

    // ensure both GeomFields Color same area
    agents.setMBR(county.getMBR());
  }
示例#5
0
  /**
   * populate network with lines from a GeomVectorField
   *
   * @param field containing line segments
   *     <p>Assumes that 'field' contains co-planar linear objects
   */
  public void createFromGeomField(GeomVectorField field) {
    Bag geometries = field.getGeometries();

    for (int i = 0; i < geometries.numObjs; i++) {
      if (((MasonGeometry) geometries.get(i)).geometry instanceof LineString) {
        addLineString((MasonGeometry) geometries.get(i));
      }
    }

    // Abandoned work on rectifying non-planar data. MAC 8/24/10.
    //        field.clear();
    //
    //        Collection<LineString> lines = lineMerger.getMergedLineStrings();
    //
    //        PrecisionModel pm = new PrecisionModel(PrecisionModel.FLOATING);
    //
    //        GeometryNoder noder = new GeometryNoder(pm);
    //
    //        Collection<LineString> more_lines = noder.node(lines);
    //
    //        // Now add nodes and edges to graph
    //
    //        for (LineString line : more_lines)
    //        {
    //            addLineString(line);
    //            field.addGeometry(new MasonGeometry(line));
    // }

  }
示例#6
0
 // reset the agent layer's MBR
 public void resetLayers() {
   MBR = roadLayer.getMBR();
   //		MBR.init(740000, 780000, 2000000, 2040000); // 35 22
   MBR.init(740000, 779000, 2009000, 2034000); // 35 22
   //		MBR.init(745000, 775000, 2015000, 2030000);
   this.humanLayer.setMBR(MBR);
   // this.baseLayer.setMBR(MBR);
 }
示例#7
0
  public ColorWorld(long seed) {
    super(seed);

    // this line allows us to replace the standard MasonGeometry with our
    // own subclass of MasonGeometry; see CountingGeomWrapper.java for more info.
    // Note: this line MUST occur prior to ingesting the data
    URL politicalBoundaries = ColorWorld.class.getResource("data/pol.shp");

    Bag empty = new Bag();
    try {
      ShapeFileImporter.read(politicalBoundaries, county, empty, CountingGeomWrapper.class);
    } catch (Exception ex) {
      Logger.getLogger(ColorWorld.class.getName()).log(Level.SEVERE, null, ex);
    }

    // we use either the ConvexHull or Union to determine if the agents are within
    // Fairfax county or not
    county.computeConvexHull();
    county.computeUnion();
  }
示例#8
0
  /**
   * Return the GeoNode in the road network which is closest to the given coordinate
   *
   * @param c
   * @return
   */
  public GeoNode getClosestGeoNode(Coordinate c) {

    // find the set of all nodes within *resolution* of the given point
    Bag objects = networkLayer.getObjectsWithinDistance(fa.createPoint(c), resolution);
    if (objects == null || networkLayer.getGeometries().size() <= 0)
      return null; // problem with the network layer

    // among these options, pick the best
    double bestDist = resolution; // MUST be within resolution to count
    GeoNode best = null;
    for (Object o : objects) {
      double dist = ((GeoNode) o).geometry.getCoordinate().distance(c);
      if (dist < bestDist) {
        bestDist = dist;
        best = ((GeoNode) o);
      }
    }

    // if there is a best option, return that!
    if (best != null && bestDist == 0) return best;

    // otherwise, closest GeoNode is associated with the closest Edge, so look for that!

    ListEdge edge = getClosestEdge(c);

    // find that edge
    if (edge == null) {
      edge = getClosestEdge(c, resolution * 10);
      if (edge == null) return null;
    }

    // of that edge's endpoints, find the closer of the two and return it
    GeoNode n1 = (GeoNode) edge.getFrom();
    GeoNode n2 = (GeoNode) edge.getTo();

    if (n1.geometry.getCoordinate().distance(c) <= n2.geometry.getCoordinate().distance(c))
      return n1;
    else return n2;
  }
示例#9
0
  public void setupAgents(GeomVectorField populationLayer) {
    Bag nodeBag = majorRoadNodesLayer.getGeometries();

    int numNodes = nodeBag.size();
    for (Object o : populationLayer.getGeometries()) {
      MasonGeometry g = (MasonGeometry) o;
      Coordinate c = g.geometry.getCoordinate();
      for (int i = 0; i < 50; i++) {
        //				GeoNode gn = (GeoNode) nodeBag.get(random.nextInt(numNodes));
        //				Coordinate myHome = (Coordinate) gn.geometry.getCoordinate().clone();
        //				double distance = Math.abs(random.nextGaussian()) * 1500;
        //				double degrees = random.nextDouble() * 2 * Math.PI;
        //				double xOffset = distance * Math.cos(degrees) + c.x;
        double xOffset = random.nextGaussian() * 100 + c.x;
        //				double yOffset = distance * Math.sin(degrees) + c.y;
        double yOffset = random.nextGaussian() * 100 + c.y;
        Coordinate myHome = new Coordinate(xOffset, yOffset);
        Geometry point = fa.createPoint(myHome);
        if (!landArea.contains(point)) continue;
        HumanTeleporter hum = new HumanTeleporter("id_" + random.nextLong(), myHome, myHome, this);
        humans.add(hum);
      }
    }
  }
示例#10
0
  private void countCatchments(GeomVectorField catchments) {
    Bag geoms = catchments.getGeometries();
    for (int i = 0; i < geoms.numObjs; i++) {
      MasonGeometry mg = (MasonGeometry) geoms.get(i);

      Integer num = mg.getIntegerAttribute("SCHOOL_NUM");

      if (num != null) {
        School s = schoolMap.get(num);
        if (s != null) {
          s.catchmentCount++;
        } else {
          System.out.format("School %s not found.\n", num);
        }
      }
    }
  }
示例#11
0
  private void createSchoolsFromData(GeomVectorField schoolField) {

    Bag geoms = schoolField.getGeometries();
    for (int i = 0; i < geoms.numObjs; i++) {
      MasonGeometry mg = (MasonGeometry) geoms.get(i);

      Integer num = mg.getIntegerAttribute("SCHOOL_NUM");
      String name = mg.getStringAttribute("SCHOOL_NAM");
      String type = mg.getStringAttribute("SCHOOL_TYP");

      if (num != null) {
        School s = new School(this, name, type);
        schoolMap.put(num, s);
        schools.add(s);
      }
    }
  }
示例#12
0
  private void createHouseholds() {
    // create households
    households.clear();
    householdsField.clear();
    householdsField.setMBR(highSchoolZones.getMBR());

    Envelope bounds = highSchoolZones.getMBR();

    // this is needed because
    Geometry exemplar = ((MasonGeometry) highSchoolZones.getGeometries().get(0)).getGeometry();

    for (int i = 0; i < numHouseholds; i++) {
      Household h = new Household(this);
      households.add(h);
      Coordinate coord;
      do {
        coord = getRandomCoordinate(bounds);
      } while (!highSchoolZones.isCovered(coord));

      Point pt = GeometryFactory.createPointFromInternalCoord(coord, exemplar);
      h.location = pt;
      householdsField.addGeometry(new MasonGeometry(pt));
    }
  }
示例#13
0
  /** Read in data and set up the simulation */
  public void start() {
    super.start();
    try {

      GeomVectorField populationLayer = new GeomVectorField(grid_width, grid_height);

      //////////////////////////////////////////////
      ///////////// READING IN DATA ////////////////
      //////////////////////////////////////////////

      readInVectorLayer(baseLayer, dirName + "haiti/haiti_meters.shp", "area", new Bag());
      readInVectorLayer(
          populationLayer,
          dirName + "population/popCentroids_meters.shp",
          "residential areas",
          new Bag());
      readInVectorLayer(roadLayer, dirName + "roads/roads_meters.shp", "road network", new Bag());
      readInVectorLayer(
          waterwayLayer, dirName + "waterways/rivers_meters.shp", "waterways", new Bag());
      readInVectorLayer(
          medicalLayer,
          dirName + "healthFacilities/health_meters.shp",
          "health facilities",
          new Bag());

      //////////////////////////////////////////////
      ////////////////// CLEANUP ///////////////////
      //////////////////////////////////////////////

      // standardize the MBRs so that the visualization lines up

      MBR = roadLayer.getMBR();
      //			MBR.init(740000, 780000, 2000000, 2040000); // 35 22
      MBR.init(740000, 779000, 2009000, 2034000); // 35 22
      //			MBR.init(750000, 772000, 2009500, 2028500); // 22 18
      //			MBR.init(756000, 766000, 2015500, 2022500);
      roadLayer.setMBR(MBR);
      // baseLayer.setMBR(MBR);

      this.grid_width = roadLayer.fieldWidth;
      this.grid_height = roadLayer.fieldHeight;

      // base layer

      landArea = (Geometry) ((MasonGeometry) baseLayer.getGeometries().get(0)).geometry.clone();
      for (Object o : baseLayer.getGeometries()) {
        MasonGeometry g = (MasonGeometry) o;
        landArea = landArea.union(g.geometry);
      }

      // clean up the road network

      System.out.print("Cleaning the road network...");

      roads =
          NetworkUtilities.multipartNetworkCleanup(roadLayer, roadNodes, resolution, fa, random, 0);
      roadNodes = roads.getAllNodes();
      testNetworkForIssues(roads);

      /*			// set up roads as being "open" and assemble the list of potential terminii
      			roadLayer = new GeomVectorField(grid_width, grid_height);
      			for(Object o: roadNodes){
      				GeoNode n = (GeoNode) o;
      				networkLayer.addGeometry(n);

      				boolean potential_terminus = false;

      				// check all roads out of the nodes
      				for(Object ed: roads.getEdgesOut(n)){

      					// set it as being (initially, at least) "open"
      					ListEdge edge = (ListEdge) ed;
      					((MasonGeometry)edge.info).addStringAttribute("open", "OPEN");
      					networkEdgeLayer.addGeometry( (MasonGeometry) edge.info);
      					roadLayer.addGeometry((MasonGeometry) edge.info);
      					((MasonGeometry)edge.info).addAttribute("ListEdge", edge);

      					String type = ((MasonGeometry)edge.info).getStringAttribute("highway");
      					if(type.equals("motorway") || type.equals("primary") || type.equals("trunk"))
      						potential_terminus = true;
      				}

      				// check to see if it's a terminus
      				if(potential_terminus && !MBR.contains(n.geometry.getCoordinate()) && roads.getEdges(n, null).size() == 1){
      					terminus_points.add(n);
      				}

      			}
      */
      // reset MBRS in case it got messed up during all the manipulation
      roadLayer.setMBR(MBR);
      networkLayer.setMBR(MBR);
      networkEdgeLayer.setMBR(MBR);
      waterwayLayer.setMBR(MBR);
      baseLayer.setMBR(MBR);
      medicalLayer.setMBR(MBR);
      humanLayer.setMBR(MBR);
      homesLayer.setMBR(MBR);
      diseasesLayer.setMBR(MBR);

      System.out.println("done");

      /////////////////////
      ///////// Clean up roads for Agents to use ///////////
      /////////////////////

      /*	Network majorRoads = extractMajorRoads();
      		testNetworkForIssues(majorRoads);

      		// assemble list of secondary versus local roads
      		ArrayList <Edge> myEdges = new ArrayList <Edge> ();
      		GeomVectorField secondaryRoadsLayer = new GeomVectorField(grid_width, grid_height);
      		GeomVectorField localRoadsLayer = new GeomVectorField(grid_width, grid_height);
      		for(Object o: majorRoads.allNodes){

      			majorRoadNodesLayer.addGeometry((GeoNode)o);

      			for(Object e: roads.getEdges(o, null)){
      				Edge ed = (Edge) e;

      				myEdges.add(ed);

      				String type = ((MasonGeometry)ed.getInfo()).getStringAttribute("highway");
      				if(type.equals("secondary"))
      						secondaryRoadsLayer.addGeometry((MasonGeometry) ed.getInfo());
      				else if(type.equals("local"))
      						localRoadsLayer.addGeometry((MasonGeometry) ed.getInfo());
      			}
      		}

      */ System.gc();

      //////////////////////////////////////////////
      ////////////////// AGENTS ///////////////////
      //////////////////////////////////////////////

      // set up the agents in the simulation
      setupAgents(populationLayer);
      humanLayer.setMBR(MBR);
      homesLayer.setMBR(MBR);

      /*			// for each of the Agents, set up relevant, environment-specific information
      			int aindex = 0;
      			for(Human a: humans){

      				if(a.familiarRoadNetwork == null){

      					// the Human knows about major roads
      					Network familiar = majorRoads.cloneGraph();

      					// connect the major network to the Human's location
      					connectToMajorNetwork(a.getNode(), familiar);

      					a.familiarRoadNetwork = familiar;

      					// add local roads into the network
      					for(Object o: humanLayer.getObjectsWithinDistance(a, 50)){
      						Human b = (Human) o;
      						if(b == a || b.familiarRoadNetwork != null || b.getNode() != a.getNode()) continue;
      						b.familiarRoadNetwork = familiar.cloneGraph();
      					}

      				}

      				// connect the Human's work into its personal network
      				if(a.getWork() != null)
      					connectToMajorNetwork(getClosestGeoNode(a.getWork()), a.familiarRoadNetwork);

      				// set up its basic paths (fast and quicker and recomputing each time)
      				a.setupPaths();

      				if(aindex % 100 == 0){ // print report of progress
      					System.out.println("..." + aindex + " of " + humans.size());
      				}
      				aindex++;
      			}
      */
      //			Disease d = new Disease();
      Cholera d = new Cholera();
      HumanTeleporter h = humans.get(random.nextInt(humans.size()));
      h.acquireDisease(d);

      // seed the simulation randomly
      //			seedRandom(System.currentTimeMillis());

      // schedule the reporter to run
      //			setupReporter();

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
示例#14
0
  private void readData() {
    try {
      // read the data
      ShapeFileImporter.read(
          SickStudentsModel.class.getResource("data/ES_ATTENDANCE_AREAS.shp"),
          elementarySchoolZones);
      ShapeFileImporter.read(
          SickStudentsModel.class.getResource("data/MS_ATTENDANCE_AREAS.shp"), middleSchoolZones);
      ShapeFileImporter.read(
          SickStudentsModel.class.getResource("data/HS_ATTENDANCE_AREAS.shp"), highSchoolZones);
      ShapeFileImporter.read(
          SickStudentsModel.class.getResource("data/ElementarySchools.shp"), elementarySchools);
      ShapeFileImporter.read(
          SickStudentsModel.class.getResource("data/MiddleSchools.shp"), middleSchools);
      ShapeFileImporter.read(
          SickStudentsModel.class.getResource("data/HighSchools.shp"), highSchools);

      // Make all the bounding rectangles match one another
      Envelope MBR = elementarySchoolZones.getMBR();
      MBR.expandToInclude(middleSchoolZones.getMBR());
      MBR.expandToInclude(highSchoolZones.getMBR());
      MBR.expandToInclude(elementarySchools.getMBR());
      MBR.expandToInclude(middleSchools.getMBR());
      MBR.expandToInclude(highSchools.getMBR());

      elementarySchoolZones.setMBR(MBR);
      middleSchoolZones.setMBR(MBR);
      highSchoolZones.setMBR(MBR);
      elementarySchools.setMBR(MBR);
      middleSchools.setMBR(MBR);
      highSchools.setMBR(MBR);
    } catch (Exception ex) {
      System.out.println("Error opening shapefile!" + ex);
      System.exit(-1);
    }
  }