代写 ECE297 Communication and Design

  • 100%原创包过,高质代写&免费提供Turnitin报告--24小时客服QQ&微信:120591129
  • ECE297 Communication and Design Winter 2016
    ECE297 Milestone 1
    Using the libstreetsdatabase API
    “There is more to life than increasing its speed.”
    –Mahatma Ghandi
    Assigned on Thursday Jan. 14th TA mark for style, unit tests, SVN use, etc. = 3/8
    Due on Monday Feb 1st Autotester = 5/8
    Total marks = 8/100
    1 Objectives
    This milestone focuses on using and extending an application programming interface (API).
    We have given you an API (StreetsDatabaseAPI.h) that allows you to query a geographic
    information database (data file) for basic information such as street names and intersection
    locations. This StreetsDatabaseAPI.h is made up of several functions, and each function
    gives you information about streets or intersections that exist in a libstreetsdatabase file.
    We’ll be testing your code with the data files for several cities, including Toronto, New York,
    Moscow and Cairo. In this milestone you will learn to use this API, and you will be asked to
    implement further functions that will be useful for your project; essentially you are creating
    a new, richer API. To make some of the functions in your new API fast, you will also need
    to create and load some data structures of your own to allow fast look-ups. We strongly
    encourage you to make use of the STL container classes such as vectors and maps that you
    recently learned about in the course tutorials to build your data structures quickly. Some of
    the tests we have released for this milestone test the speed of your new API; based on the
    results of these tests you can see where you need to optimize for speed.
    After completing this milestone you should be able to:
    1 Query the libstreetsdatabase using functions in the provided map API.
    2 Extend the map API with functions that return useful map information.
    3 Use STL data structures such as vectors and maps.
    4 Create and use unit tests to test your code.
    2 Problem Statement
    In this milestone you will load a skeleton C++ project in Netbeans and put it under re-
    vision control. This will be the C++ project on which you implement all of your ECE297
    Page 1 of 23
    ECE297 Communication and Design Winter 2016
    milestones. You will then start using some of the functions (such as getStreetName) in
    StreetsDatabaseAPI.h that is provided with the project – this API allows you to access
    the data loaded from a large binary file that describes all the streets and intersections in a
    city. You will then be asked to implement your own functions that perform useful libstreets-
    database queries. For example, you will implement a function that returns all intersections
    along a given street. Finally, you will test your code using the autotester, and submit it
    using the submit script. Note that you will be using SVN throughout the milestone to
    work effectively with your teammates.
    3 Walkthrough
    Even though your ECE297 project is divided up into milestones, all of the milestones are part
    of one project. You will be creating a simple mapping application similar to Google/Bing
    Maps. It is important to realize that everything you code in milestone 1, you will use in
    milestone 2. And everything you do in milestone 2 will be used in milestone 3, and so on.
    !
    Your project is divided into milestones, but you will use your solutions to
    the milestones in all subsequent milestones.
    This is also why you started off by learning how to use SVN. To build up on your project
    code efficiently, it is important to keep it under revision control and to commit often. This
    will allow you to divide tasks easily among your team members and keep track of all changes
    made to your project code. Note that your grade will depend on many things:
    1. Code correctness and performance will be mostly automatically graded.
    2. Coding style and commenting. You will get feedback on this through your TA.
    3. Your use of SVN. This will be checked by your TA.
    4. Your creation of unit tests for some functions. This will be checked by your TA.
    Page 1 of 1
    7/8/2014file:///C:/Users/Mohamed/Desktop/light-bulb-7.svg
    An effective team project is well-commented and uses revision control (such
    as SVN) to effectively divide work and maintain a history of code changes.
    In the following two subsections (3.1 and 3.2), we’ll outline how to initialize the repository.
    Note that Section 3.1 is only done by one team member, while Section 3.2 must be done by
    all team members.
    3.1 Set-up Project with Netbeans and SVN (1 team member)
    You will download the compressed project from the course website and open it in Netbeans.
    You will then create a repository under “/groups/ECE297S/cd-XXX” where XXX is team
    number assigned to you. This will allow you to import your project into the repository you
    created and maintain the project code under revision control.
    Page 2 of 23
    ECE297 Communication and Design Winter 2016
    If you need a refresher on revision control tasks read “ECE297 Quickstart
    Guide: SVN”.
    Perform the following steps to set up your project with Netbeans and SVN on the UG
    machines. Note that screenshots of the following steps are provided in Appendix A. Also
    note that only one of your 3 team members will perform the following steps to set up the
    repository.
    1. Download mapper.zip from the [code] link for milestone 1 on the course website and
    save it in your home directory.
    2. Open the project in Netbeans and save it in your home directory. You will notice that
    the project you just opened is divided into three parts:
    ˆ libstreetsdatabase: This library provides the functions for accessing the lib-
    streetsdatabase; it has been written for you. Look at the file StreetsDatabaseAPI.h;
    it shows the interfaces to all the functions that you will need for this milestone from
    that library.
    ˆ libstreetmap: This is the library that you will be creating throughout your
    ECE297 project. You will notice that it contains “m1.h” and “m1.cpp” – these
    are the header and a possible implementation file (you can create more .cpp files)
    that you will be working on in milestone 1 (this milestone).
    ˆ mapper: This project contains your “main.cpp” file; this is where your program
    starts executing. You can call the functions from libstreetsdatabase and libstreetmap
    here.
    libstreetmap
    m1.h
    libstreetsdatabase
    StreetsDatabaseAPI.h
    uses
    functions
    from
    parses
    data in
    toronto.streets.bin
    Figure 1: Project API layers.
    3. Create a repository (using svnadmin) under “/groups/ECE297S/cd-XXX”.
    Page 3 of 23
    ECE297 Communication and Design Winter 2016
    1 > svnadmin create /groups/ECE297S/cd-XXX/mapper_repo
    4. Set repository permissions so your group can commit to the repository
    1 > chmod -R g+rw /groups/ECE297S/cd-XXX/mapper_repo
    !
    After creating the repository with svnadmin and setting up revision
    control, do NOT touch the repository location or modify any files there
    as that will probably lead to loss of data in the repository.
    5. Import your opened projects (mapper, libstreetmap and libstreetsdatabase) into your
    repository. Make sure you only include the files that you want to keep under revision
    control (see Fig. 13 for files that you should exclude from revision control).
    3.2 Checkout Project (All 3 team members)
    Now that the project is stored in a repository, you or any of your team members can get a
    copy of the project using svn checkout. If you are the team member who did Section 3.1,
    delete your working copy of the project (your working copy is the version of the project that
    you have in your home directory) – we’ll checkout a fresh version to make sure everything is
    working fine. Now all three team members should go in their home directories and run the
    following command to checkout a working copy of the project.
    1 > svn checkout svn+ssh://ugZZZ.eecg.utoronto.ca/groups/ECE297S/cd-XXX/mapper_repo
    Note that ugZZZ must be replaced by a machine in the range ug132-ug180 or ug201-ug249
    as described here. Also note that in milestone 0, and in the svn tutorial we used a different
    protocol (file://) to access the repository. The “file://” protocol is suitable for accessing
    repositories on the same filesystem; however, by using the “svn+ssh” protocol here, we are
    able to access this repository from any computer inside or outside the EECG network. You
    will have to provide your eecg username and password as shown in the following figure.
    At this point, all three team members should have a working copy of the mapper project
    in their home directories. Make sure the project compiles and runs properly on Netbeans
    for all three user accounts before you proceed past this point.
    3.3 Understand StreetsDatabaseAPI.h
    Fig. 3 shows how a map is represented internally in the libstreetsdatabase. Each Intersection
    is a graph node and each Street Segment is a graph edge (which connects two Intersection
    nodes). Note that multiple Street Segments make up one Street – for example, the dotted
    Street Segments are all part of one Street (College St.).
    Page 4 of 23
    ECE297 Communication and Design Winter 2016
    Figure 2: SVN checkout dialog box in Netbeans.
    Page 1 of 1
    7/8/2014file:///C:/Users/Mohamed/Desktop/light-bulb-7.svg
    In the libstreetsdatabase graph, each graph node is an Intersection, and
    each graph edge (between 2 nodes) is a Street Segment.
    The provided StreetsDatabaseAPI has an unsigned integer id for each of the intersections;
    from 0 to getNumberOfIntersections()-1 – which is the total number of intersections. Sim-
    ilarly, each Street Segment has an unsigned integer id from 0 to getNumberOfStreetSegments()-1
    and each Street has an unsigned integer id from 0 to getNumberOfStreets()-1. Addition-
    ally, each Intersection has a name, and each Street has a name. Note that it is possible for
    two Streets to have the same name; there is more than one Main Street in Greater Toronto
    for example. Intersection names are formed from the names of the streets that meet at
    that intersection, and it is possible to have two intersections with the same name. Street
    Segments do not have unique names associated with them.
    Page 1 of 1
    7/8/2014file:///C:/Users/Mohamed/Desktop/light-bulb-7.svg
    Each Intersection, Street Segment, or Street has a unique unsigned integer
    ID. Only Intersections and Streets have names, and they may not be unique.
    Listing 1 shows “StreetsDatabaseAPI.h” which is included in your Netbeans Project
    under libstreetsdatabase – this contains the libstreetsdatabase API functions that you can
    use to retrieve information about the map-graph of Toronto. All function prototypes are
    commented; this is the best kind of documentation as it always remains with the code.
    Study the API and the comments, and try out the different functions to understand what
    each function does and how it works.
    Note that in addition to Streets, Street Segments and Intersections, the StreetsDatabaseAPI
    also provides ’Points of Interest’ which are simply interesting landmarks, such as Union Sta-
    tion or a Tim Horton’s store. Each ’Point of Interest’ has a location, name and a type
    (another string) only. There are also function calls to obtain natural features like the bound-
    aries of parks and lakes and function calls to obtain the unique OSMid (identifier) for each
    item in the database, but we will not use that part of the StreetsDatabaseAPI until milestone
    Page 5 of 23
    ECE297 Communication and Design Winter 2016
    Intersection
    Street Segment
    a) Snapshot of Bathurst/College area from Google Maps
    b) Map-database graph representation of Bathurst/College area
    College
    Street
    Street
    Segment
    Inter-
    section
    Figure 3: libstreetsdatabase contains a graph of intersections and street segments. You can query
    StreetsDatabaseAPI to find information about the graph. For example, you can find which street
    segments are at each intersection. Note that multiple Street Segments make up one Street – for
    example, the dotted Street Segments are all part of one Street (College St.).
    2.
    1
    1 The OSMid values allow you to use another API, in “OSMDatabaseAPI.h”, that contains even more information
    from the map database, but we will not use that API in this milestone and its use is optional even in later milestones.
    Page 6 of 23
    ECE297 Communication and Design Winter 2016
    1 #pragma once //protects against multiple inclusions of this header file
    2
    3 #include <string >
    4 #include "LatLon.h"
    5
    6 #include "Feature.h"
    7 #include "OSMEntityType.h"
    8
    9 // The ID in the global OSM database of a particular data item
    10 // You can use this ID to look up more detailed info about a data item
    11 // from the "layer -1" OSMDatabaseAPI.h
    12 typedef unsigned long long OSMID;
    13
    14 // Structure used to return information about a StreetSegment ,
    15 // which is the portion of a street between two intersections.
    16 struct StreetSegmentInfo {
    17 OSMID wayOSMID; // OSM ID of the source way
    18 unsigned from, to; // intersection ID this segment runs from/to
    19 bool oneWay; // if true, then can only travel in from->to direction
    20 unsigned curvePointCount; // number of curve points between the ends
    21 // will be 0 for straight StreetSegments
    22 float speedLimit; // speed limit in km/hr
    23 unsigned streetID; // index of street to which this segment belongs
    24 };
    25
    26 // load the layer -2 streets database. This is the easier to use API
    27 // that provides higher -level information than the raw OSM data.
    28 // To access the raw OSM data, use the layer -1 API in OSMDatabaseAPI.h
    29 bool loadStreetsDatabaseBIN(std::string);
    30 void closeStreetDatabase();
    31
    32 // aggregate queries
    33 unsigned getNumberOfStreets();
    34 unsigned getNumberOfStreetSegments();
    35 unsigned getNumberOfIntersections();
    36 unsigned getNumberOfPointsOfInterest();
    37 unsigned getNumberOfFeatures();
    38
    39 //------------------------------------------------
    40 // Intersection information
    41 std::string getIntersectionName(unsigned intersectionID);
    42 LatLon getIntersectionPosition(unsigned intersectionID);
    43 OSMID getIntersectionOSMNodeID(unsigned intersectionID);
    44
    45 //number of street segments at an intersection
    46 unsigned getIntersectionStreetSegmentCount(unsigned intersectionID);
    47
    48 // find the street segments at an intersection. idx is from
    49 // 0..streetSegmentCount -1 (at this intersection)
    50 unsigned getIntersectionStreetSegment(unsigned intersectionID , unsigned idx);
    51
    52
    53 //------------------------------------------------
    54 // Street segment information
    55
    56 //find the street to which this segment belongs
    57 StreetSegmentInfo getStreetSegmentInfo(unsigned streetSegmentID);
    58
    Page 7 of 23
    ECE297 Communication and Design Winter 2016
    59 //fetch the latlon of the idx’th curve point
    60 LatLon getStreetSegmentCurvePoint(unsigned streetSegmentID , unsigned idx);
    61
    62
    63 //------------------------------------------------
    64 // Street information
    65 std::string getStreetName(unsigned streetID);
    66
    67 //------------------------------------------------
    68 // Points of interest
    69 std::string getPointOfInterestType(unsigned pointOfInterestID);
    70 std::string getPointOfInterestName(unsigned pointOfInterestID);
    71 LatLon getPointOfInterestPosition(unsigned pointOfInterestID);
    72 OSMID getPointOfInterestOSMNodeID(unsigned pointOfInterestID);
    73
    74 //------------------------------------------------
    75 // Natural features
    76 const std::string& getFeatureName(unsigned featureID);
    77 FeatureType getFeatureType(unsigned featureID);
    78 OSMID getFeatureOSMID(unsigned featureID);
    79 OSMEntityType getFeatureOSMEntityType(unsigned featureID);
    80 unsigned getFeaturePointCount(unsigned featureID);
    81 LatLon getFeaturePoint(unsigned featureID , unsigned idx);
    Listing 1: libstreetsdatabase API.
    Page 8 of 23
    ECE297 Communication and Design Winter 2016
    3.4 Map Files
    The map file for Toronto is located at the path /cad2/ece297s/public/maps/toronto.
    streets.bin on the ugxxx machines. The .bin file which can be loaded using the lib-
    streetsdatabase API. Maps for several other cities are also located in the /cad2/ece297s/
    public/maps directory 2 .
    3.5 Implement Your Own Functions
    Listing 2 shows the header file for the extended API that you are going to implement in this
    milestone. Only the function prototypes are provided; you are to create the implementation
    .cpp files (you can use any set of .cpp files you wish) in which you implement each of the
    functions in “m1.h”, plus any helper functions or classes you require. Each function prototype
    is commented to indicate how to use the function and what it does; use this to guide your
    implementation.
    Page 1 of 1
    7/8/2014file:///C:/Users/Mohamed/Desktop/light-bulb-7.svg
    Comments in a header “.h” file, typically indicate how to use the function.
    While comments in the implementation “.cpp” file should indicate both
    how to use the function, and detailed comments about the implementation.
    1 #pragma once //protects against multiple inclusions of this header file
    2
    3 #include <string >
    4 #include <vector >
    5 #include "StreetsDatabaseAPI.h"
    6
    7 //use these defines if you need earth radius or conversion from degrees to radians
    8 #define EARTH_RADIUS_IN_METERS 6372797.560856
    9 #define DEG_TO_RAD 0.017453292519943295769236907684886
    10
    11 //function to load map streets.bin file
    12 bool load_map(std::string map_name);
    13
    14 //close the loaded map
    15 void close_map();
    16
    17 //function to return street id(s) for a street name
    18 //return a 0-length vector if no street with this name exists.
    19 std::vector <unsigned > find_street_ids_from_name(std::string street_name);
    20
    21 //function to return the street segments for a given intersection
    22 std::vector <unsigned > find_intersection_street_segments(unsigned intersection_id);
    23
    24 //function to return street names at an intersection (include duplicate street
    names in returned vector)
    25 std::vector <std::string > find_intersection_street_names(unsigned intersection_id);
    26
    2 You can generate .bin files for additional cities using the osm2bin utility, which converts an OpenStreetMap
    .osm file to the streets.bin format used by libstreetsdatabase.
    Page 9 of 23
    ECE297 Communication and Design Winter 2016
    27 //can you get from intersection1 to intersection2 using a single street segment (
    hint: check for 1-way streets too)
    28 //corner case: an intersection is considered to be connected to itself
    29 bool are_directly_connected(unsigned intersection_id1 , unsigned intersection_id2);
    30
    31 //find all intersections reachable by traveling down one street segment
    32 //from given intersection (hint: you can’t travel the wrong way on a 1-way street)
    33 //the returned vector should NOT contain duplicate intersections
    34 std::vector <unsigned > find_adjacent_intersections(unsigned intersection_id);
    35
    36 //for a given street , return all the street segments
    37 std::vector <unsigned > find_street_street_segments(unsigned street_id);
    38
    39 //for a given street , find all the intersections
    40 std::vector <unsigned > find_all_street_intersections(unsigned street_id);
    41
    42 //function to return all intersection ids for two intersecting streets
    43 //this function will typically return one intersection id between two street names
    44 //but duplicate street names are allowed , so more than 1 intersection id may exist
    for 2 street names
    45 std::vector <unsigned > find_intersection_ids_from_street_names(std::string
    street_name1 , std::string street_name2);
    46
    47 //find distance between two coordinates
    48 double find_distance_between_two_points(LatLon point1 , LatLon point2);
    49
    50 //find the length of a given street segment
    51 double find_street_segment_length(unsigned street_segment_id);
    52
    53 //find the length of a whole street
    54 double find_street_length(unsigned street_id);
    55
    56 //find the travel time to drive a street segment (time(minutes) = distance(km)/
    speed_limit(km/hr) * 60
    57 double find_street_segment_travel_time(unsigned street_segment_id);
    58
    59 //find the nearest point of interest to a given position
    60 unsigned find_closest_point_of_interest(LatLon my_position);
    61
    62 //find the nearest intersection (by ID) to a given position
    63 unsigned find_closest_intersection(LatLon my_position);
    Listing 2: Milestone 1 API “m1.h”.
    3.5.1 Computing Distance from Latitude/Longitude
    In this and the following subsections, some of the functions in StreetsDatabaseAPI.h are
    clarified.
    Locations in libstreetsdatabase are represented as latitude and longitude, in degrees.
    There are many ways to compute the distance between two latitude/longitude (lat/lon)
    points, some more accurate than others. We will be using Pythagoras’ theorem on an
    equirectangular projection 3 .
    3 A map projection is a translation from lat/lon to (x,y) coordinates. The projection basically draws out planet
    (which is almost spherical) on a rectangular coordinate system. You are encouraged to read more about map-making
    Page 10 of 23
    ECE297 Communication and Design Winter 2016
    Figure 4: Projecting part of the surface of the earth to a flat plane. Source: host-
    ing.soonet.ca/eliris/gpsgis/Lec2Geodesy.html.
    To compute (x,y) coordinates from lat/lon, do the following:
    (x,y) = (lon · cos(lat avg ), lat) (1)
    Where lat avg is the average latitude of the area being mapped. The equation above
    accounts for the fact that the distance between lines of latitude is the same everywhere
    on earth, while the distance between lines of longitude depends on how far away from the
    equator you are. At the equator (latitude = 0 degrees) the distance between two lines of
    longitude is equal to that between two lines of latitude. At the North or South Pole (latitude
    = 90 or -90 degrees, respectively) all the lines of longitude converge to a point so there is no
    distance between them.
    If we will use the (x,y) projection above to draw our map (as we will in milestone 2), then
    lat avg is the mid-latitude of the map we’re drawing, that is the average between the min/max
    latitudes of Toronto for our purpose
    lat min +lat max
    2
    . However, if we are using the projection to
    find the distance between two points (lon 1 ,lat 1 ) and (lon 2 ,lat 2 ) then it is more accurate to
    compute lat avg as
    lat 1 +lat 2
    2
    . This is the lat avg that you should be using to compute distance,
    and the autotester uses the same equation to verify your answers.
    To find the distance between two points, we convert (lon,lat), in radians, to (x,y), then
    use Pythagoras’ theorem and multiply by the radius of the earth R:
    d = R ·
    q
    (y 2 − y 1 ) 2 + (x 2 − x 1 ) 2 (2)
    We have defined a constant for the radius of the Earth in m1.h so you can implement the
    formula above precisely and match the autotester.
    3.5.2 Curve Points
    Not all street segments are perfectly straight lines between two intersections; some city
    blocks (street segments) are curved or even winding. Curve points are properties of street
    segments that allow the StreetsDatabaseAPI to represent such curved or winding roads
    between intersections. As Fig. 6 shows, some street segments have no curve points (they
    and more accurate projections: http://en.wikipedia.org/wiki/List_of_map_projections.
    Page 11 of 23
    ECE297 Communication and Design Winter 2016
    Figure 5: Parallels of latitude and lines of longitude. Source: blog.eogn.com/2014/09/16/convert-
    an-address-to-latitude-and-longitude/.
    are perfectly straight); the distance one must travel along the street segment between the
    two intersections can therefore be computed from the (Latitude/Longitude) locations of the
    two intersections. Other street segments have curve points, and each one is represented as a
    Latitude/Longitude pair. Therefore, to find the distance along such a street segment these
    curve points must be taken into account to find the correct driving distance.
    3.6 Unit Testing
    An important part of any software project is verifying that the code is correct. One popular
    and effective approach is called Unit Testing. With unit testing you verify the correctness
    of small ‘units’ of your code, such as individual functions or classes. Testing at such a low
    level is beneficial since errors are much easier to detect and debug since they are isolated to
    a small subset of your program.
    ~ 30mins
    To learn more about Unit Testing see the “ECE297 Quick Start Guide:
    Unit Testing”
    The public functionality tests are included in the file ‘libstreetmap/tests/m1 unittests.cpp’.
    You can run unit tests on your project from the command-line using ‘make test’, or from
    with-in Netbeans as described in the “ECE297 Quick Start Guide: Unit Testing”.
    If your project passes all unit tests the output will indicate success:
    Page 12 of 23
    ECE297 Communication and Design Winter 2016
    Intersection 1 Intersection 2
    Street segment
    (0 curve points)
    Street segment
    (2 curve points)
    Intersection 2
    Intersection 1
    (a)
    (b)
    Figure 6: A street segment exists between two intersections; in (a) the street segment has no
    curve points, while in (b) the street segment has 2 curve points. Note that you can get the
    latitude/longitude of each curve point or intersection.
    1 > ls #In the project directory
    2 Makefile libstreetmap libstreetsdatabase main nbproject


    代写 ECE297 Communication and Design


     
    3
    4 > make test
    5 #Output trimmed...
    6 Success: 15 tests passed.
    7 Test time: 0.07 seconds.
    Listing 3: Unit testing usage
    If your project fails unit tests the output will indicate the error and where it occurred:
    1 > ls #In the project directory
    2 Makefile libstreetmap libstreetsdatabase main nbproject
    3
    4 > make test #We have a bug in our program so this will error
    5 #Output trimmed...
    6 libstreetmap/tests/m1_unittests.cpp:514: error: Failure in
    directly_connected_functionality: !are_directly_connected(1358, 2709)
    7 FAILURE: 1 out of 15 tests failed (1 failures).
    8 Test time: 0.09 seconds.
    9 make: *** [test] Error 1
    Listing 4: Unit testing usage
    Any files defining new unit tests added to the ‘libstreetmap/tests’ folder will be run by
    ‘make test’.
    Page 13 of 23
    ECE297 Communication and Design Winter 2016
    3.6.1 Adding a Unit Test
    You are required to extend the unit tests included in the project by adding several new unit
    tests. Note that your unit tests need not be limited to the external API defined in m1.h;
    you are also encouraged to create unit tests for functions you created for internal use which
    are not exposed in m1.h.
    4
    The external API function std::vector<unsigned>find_street_ids_from_name(std::
    stringstreet_name) in m1.h does not have a public unit test. You are therfore required to
    write unit tests to verify the correctness of this function. You will need to show your new
    unit tests to your TA so he or she can assess their quality. To receive full marks, your unit
    tests for this function should:
    ˆ Test the function returns the right answer for hand-generated corner cases. What are
    the different cases this function could encounter, and do you have a test for each?
    ˆ Test at least some of the functionality of this routine with many automatically generated
    calls (thousands). How can you automatically call this routine with many different street
    names? How can you automatically check the answer is reasonable?
    ˆ Test the speed of the function. To get reliable time measurements, your unit tests should
    call the function enough times that the test takes at least 250 ms. The average time per
    function call should be no more than 250 ns per call (i.e. no more than 250 ms for 1,000,000
    calls).
    The unit tests we have provided in this milestone will only test your API with valid
    input. Integer ids will always be within the valid range for that id type, e.g. the argument
    will be between 0 and getNumberOfIntersections() -1 for intersection ids. You may wish
    to make your API test for invalid input (e.g. intersection ids that are out of range) and
    take some appropriate action (like printing an error message) since this will make your API
    more robust, and you will be building code that uses your API in the later milestones in this
    program. If you add error handling to your API, you can add some unit tests to verify the
    error handling, and this would be a good practice.
    3.7 Grading
    3.7.1 Using the Autotester
    After implementing the API functions (and testing with your unit test) use the autotester to
    check for both correctness and run-time performance. The autotester will give you testing
    information about each function; for example, how many of the testcases pass or fail, and how
    fast the function runs compared to the speed target. To get full marks you need to implement
    all functions, pass all testcases and meet the speed targets. Note that the autotester only
    exercises the public testcases which are not exhaustive. For grading, we will be testing your
    code with more (private) testcases as well so make sure your implementation handles any
    corner cases. Note that while you can use your main function to test your code, the main
    function will not be graded.
    4 If you add other unit tests also show then to your TA, and they will be considered when assigning grades.
    Page 14 of 23
    ECE297 Communication and Design Winter 2016
    !
    Use the autotester to test your implementation with public testcases for
    correctness and performance. Additional private testcases will also be used
    for grading.
    The autotester can be run using the ‘ece297exercise 1’ command:
    1 > ls #In the main project directory
    2 build libstreetmap.a libstreetsdatabase.a Makefile nbproject
    3 libstreetmap libstreetsdatabase main mapper
    4
    5 > ece297exercise 1 #Runs the autotester
    6 Running Tester: UnitTests
    7 Building UnitTests
    8 OK
    9 Running UnitTests
    10 #Output trimmed...
    11 Test Summary: PASS ( 0 of 31 failed)
    12 UnitTests PASS ( 0 of 31 failed)
    Listing 5: Exercise example
    The ece297exercise command runs the program executable in your current directory.
    For speed tests, you should make sure you are running the Release Configuration of your
    program (i.e. that you built the Release Configuration before running ece297exercise), as
    that is the fastest version of your program and that is how we will test your submission. As
    well, note that if your machine is heavily loaded by either you or other students running
    multiple CPU-intensive programs at the same time it can slow down your program. We will
    test your submission on an unloaded machine.
    3.7.2 Submitting Your Code
    Submit your project using the ‘ece297submit 1’ command:
    1 > ls #In the main project directory (must be under SVN)
    2 build libstreetmap.a libstreetsdatabase.a Makefile nbproject
    3 libstreetmap libstreetsdatabase main mapper
    4
    5 > ece297submit 1 #Submits the project
    6 #Output trimmed...
    7 Committing Submission
    8 Verified submitted file exists and matches size
    9 Successfully committed submission.
    Listing 6: Submission example
    3.7.3 Grading Scheme
    You are required to implement all the functions that are specified in “m1.h”, as well as the
    unit tests described earlier. In doing so you should also make sure that you comment your
    code well and commit to your SVN repository often; you should also use informative SVN
    commit messages as your TA will look at the SVN log. There are 8 marks assigned to this
    milestone and are divided as follows:
    Page 15 of 23
    ECE297 Communication and Design Winter 2016
    ˆ 5 marks: These marks will be graded automatically by the automarker and will check
    your code functionality (3 marks) and runtime (2 marks).
    ˆ 3 marks: The unit tests that you write will be checked by your TA, and you should
    be able to describe them and answer questions about their design. Effective use of SVN,
    code style and commenting will be also checked by your TA. Finally, you should be able
    to answer questions about how your code works and why it is structured the way it is.
    Note that different team members may receive different marks from the TA based on the
    clarity of their answers to questions, their contribution to the milestone as shown by SVN
    logs, and their knowledge of the code.
    Page 16 of 23
    ECE297 Communication and Design Winter 2016
    A Screenshots of Initial Repository Setup
    Figure 7: Import Project from Zip.
    Figure 8: Select the compressed project path, and the path to which you will extract your project.
    This can be anywhere in your home directory.
    Page 17 of 23
    ECE297 Communication and Design Winter 2016
    Figure 9: View of the imported projects and files.
    Page 18 of 23
    ECE297 Communication and Design Winter 2016
    Figure 10: Select all three projects then right-click and import into SVN repository.
    Page 19 of 23
    ECE297 Communication and Design Winter 2016
    Figure 11: Specify repository path.
    Figure 12: Write import message.
    Page 20 of 23
    ECE297 Communication and Design Winter 2016
    Figure 13: Select the files to keep under revision control. Exclude the folders “private”, “dist” and
    “build” – these contain files that are generated every time you compile your project.
    Figure 14: View of Projects after import – notice the small cylinder-icon which indicates there are
    uncommited changes in the working copy.
    Page 21 of 23
    ECE297 Communication and Design Winter 2016
    Figure 15: Compile your project (make sure it compiles fine) then invoke the svn status command
    (right-click→Show Changes).
    Page 22 of 23
    ECE297 Communication and Design Winter 2016
    Figure 16: You will find some files in the folder “private” that say “locally new” – we want to
    exclude those files from revision control because they are user-specific and should not be kept
    under revision control. Right-click→Ignore.
    Page 23 of 23

    代写 ECE297 Communication and Design