Beispiel #1
0
 def testQueryStopsForTrip(self):
     new_trip = self.create_fake_trip()
     new_stop = ecws.Stop()
     new_stop.trip_id = new_trip.get_id()
     new_stop.enter_ts = 5
     new_stop.exit_ts = 6
     ts = esta.TimeSeries.get_time_series(self.testUserId)
     ts.insert_data(self.testUserId, esda.RAW_STOP_KEY, new_stop) 
     ret_entries = esdt.get_raw_stops_for_trip(self.testUserId, new_trip.get_id())
     self.assertEqual([entry.data for entry in ret_entries], [new_stop])
def get_stops_for_trip(user_id, trip_id):
    """
    Get the set of sections that are children of this trip.
    """
    stop_doc_cursor = edb.get_stop_db().find({
        "user_id": user_id,
        "trip_id": trip_id
    }).sort("enter_ts", pymongo.ASCENDING)
    logging.debug("About to execute query %s" % {
        "user_id": user_id,
        "trip_id": trip_id
    })
    return [ecwst.Stop(doc) for doc in stop_doc_cursor]
Beispiel #3
0
def get_filtered_stop(new_trip_entry, stop):
    """
    If we have filtered sections, I guess we need to have filtered stops as well.
    These should also point to the new trip

    :param new_trip_trip: the trip that this stop is part of
    :param stop: the section that this is part of
    :return: None
    """
    filtered_stop_data = ecwst.Stop()
    filtered_stop_data['_id'] = new_trip_entry.get_id()
    filtered_stop_data.trip_id = new_trip_entry.get_id()
    _copy_non_excluded(old_data=stop.data,
                       new_data=filtered_stop_data,
                       excluded_list=filtered_stop_excluded)
    return ecwe.Entry.create_entry(stop.user_id,
                                   esda.CLEANED_STOP_KEY,
                                   filtered_stop_data,
                                   create_id=True)
Beispiel #4
0
def segment_trip_into_sections(user_id, trip_entry, trip_source):
    ts = esta.TimeSeries.get_time_series(user_id)
    time_query = esda.get_time_query_for_trip_like(esda.RAW_TRIP_KEY,
                                                   trip_entry.get_id())
    distance_from_place = _get_distance_from_start_place_to_end(trip_entry)

    if (trip_source == "DwellSegmentationTimeFilter"):
        import emission.analysis.intake.segmentation.section_segmentation_methods.smoothed_high_confidence_motion as shcm
        shcmsm = shcm.SmoothedHighConfidenceMotion(60, 100, [
            ecwm.MotionTypes.TILTING, ecwm.MotionTypes.UNKNOWN,
            ecwm.MotionTypes.STILL
        ])
    else:
        assert (trip_source == "DwellSegmentationDistFilter")
        import emission.analysis.intake.segmentation.section_segmentation_methods.smoothed_high_confidence_with_visit_transitions as shcmvt
        shcmsm = shcmvt.SmoothedHighConfidenceMotionWithVisitTransitions(
            49,
            50,
            [
                ecwm.MotionTypes.TILTING,
                ecwm.MotionTypes.UNKNOWN,
                ecwm.MotionTypes.STILL,
                ecwm.MotionTypes.NONE,  # iOS only
                ecwm.MotionTypes.STOPPED_WHILE_IN_VEHICLE
            ])  # iOS only

    segmentation_points = shcmsm.segment_into_sections(ts, distance_from_place,
                                                       time_query)

    # Since we are segmenting an existing trip into sections, we do not need to worry about linking with
    # a prior place, since it will be linked through the trip object.
    # So this is much simpler than the trip case.
    # Again, since this is segmenting a trip, we can just start with a section

    prev_section_entry = None

    # TODO: Should we link the locations to the trips this way, or by using a foreign key?
    # If we want to use a foreign key, then we need to include the object id in the data df as well so that we can
    # set it properly.
    ts = esta.TimeSeries.get_time_series(user_id)

    get_loc_for_ts = lambda time: ecwl.Location(
        ts.get_entry_at_ts("background/filtered_location", "data.ts", time)[
            "data"])
    trip_start_loc = get_loc_for_ts(trip_entry.data.start_ts)
    trip_end_loc = get_loc_for_ts(trip_entry.data.end_ts)
    logging.debug("trip_start_loc = %s, trip_end_loc = %s" %
                  (trip_start_loc, trip_end_loc))

    for (i, (start_loc_doc, end_loc_doc,
             sensed_mode)) in enumerate(segmentation_points):
        logging.debug("start_loc_doc = %s, end_loc_doc = %s" %
                      (start_loc_doc, end_loc_doc))
        get_loc_for_row = lambda row: ts.df_row_to_entry(
            "background/filtered_location", row).data
        start_loc = get_loc_for_row(start_loc_doc)
        end_loc = get_loc_for_row(end_loc_doc)
        logging.debug("start_loc = %s, end_loc = %s" % (start_loc, end_loc))

        section = ecwc.Section()
        section.trip_id = trip_entry.get_id()
        if prev_section_entry is None:
            # This is the first point, so we want to start from the start of the trip, not the start of this segment
            start_loc = trip_start_loc
        if i == len(segmentation_points) - 1:
            # This is the last point, so we want to end at the end of the trip, not at the end of this segment
            # Particularly in this case, if we don't do this, then the trip end may overshoot the section end
            end_loc = trip_end_loc

        fill_section(section, start_loc, end_loc, sensed_mode)
        # We create the entry after filling in the section so that we know
        # that the data is included properly
        section_entry = ecwe.Entry.create_entry(user_id,
                                                esda.RAW_SECTION_KEY,
                                                section,
                                                create_id=True)

        if prev_section_entry is not None:
            # If this is not the first section, create a stop to link the two sections together
            # The expectation is prev_section -> stop -> curr_section
            stop = ecws.Stop()
            stop.trip_id = trip_entry.get_id()
            stop_entry = ecwe.Entry.create_entry(user_id,
                                                 esda.RAW_STOP_KEY,
                                                 stop,
                                                 create_id=True)
            logging.debug("stop = %s, stop_entry = %s" % (stop, stop_entry))
            stitch_together(prev_section_entry, stop_entry, section_entry)
            ts.insert(stop_entry)
            ts.update(prev_section_entry)

        # After we go through the loop, we will be left with the last section,
        # which does not have an ending stop. We insert that too.
        ts.insert(section_entry)
        prev_section_entry = section_entry
Beispiel #5
0
def _get_stops_for_query(stop_query, sort_key):
    logging.debug("Returning stops for query %s" % stop_query)
    stop_doc_cursor = edb.get_stop_db().find(stop_query).sort(
        sort_key, pymongo.ASCENDING)
    # TODO: Fix "TripIterator" and return it instead of this list
    return [ecws.Stop(doc) for doc in stop_doc_cursor]
Beispiel #6
0
def create_new_stop(user_id, trip_id):
    _id = edb.get_stop_db().save({'user_id': user_id, "trip_id": trip_id})
    logging.debug("Created new stop %s for user %s" % (_id, user_id))
    return ecws.Stop({"_id": _id, 'user_id': user_id, "trip_id": trip_id})
Beispiel #7
0
def get_stop(stop_id):
    return ecws.Stop(edb.get_stop_db().find_one({"_id": stop_id}))