def segment_trip_into_sections(user_id, trip_id):
    ts = esta.TimeSeries.get_time_series(user_id)
    trip = esdt.get_trip(trip_id)
    time_query = esdt.get_time_query_for_trip(trip_id)

    import emission.analysis.intake.segmentation.section_segmentation_methods.smoothed_high_confidence_motion as shcm
    shcmsm = shcm.SmoothedHighConfidenceMotion(60, [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, 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 = 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.
    trip_start_loc = ecwl.Location(ts.get_entry_at_ts("background/filtered_location", "data.ts", trip.start_ts)["data"])
    trip_end_loc = ecwl.Location(ts.get_entry_at_ts("background/filtered_location", "data.ts", trip.end_ts)["data"])
    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))
        start_loc = ecwl.Location(start_loc_doc)
        end_loc = ecwl.Location(end_loc_doc)
        logging.debug("start_loc = %s, end_loc = %s" % (start_loc, end_loc))

        section = esds.create_new_section(user_id, trip_id)
        if prev_section 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)

        if prev_section 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 = esdst.create_new_stop(user_id, trip_id)
            stitch_together(prev_section, stop, section)
            esdst.save_stop(stop)
            esds.save_section(prev_section) # Because we have now linked it to the stop, we need to save it again

        esds.save_section(section)
        prev_section = section
    def testCreateFromData(self):
        etc.setupRealExample(self, "emission/tests/data/real_examples/shankari_2015-aug-27")
        eaicf.filter_accuracy(self.testUUID)
        estfm.move_all_filters_to_data()
        eaist.segment_current_trips(self.testUUID)
        eaiss.segment_current_sections(self.testUUID)

        trips = esdctp.get_all_common_trips_for_user(self.testUUID)
        trips_list = []
        for p in trips:
            trips_list.append(esdctp.make_common_trip_from_json(p))
        for trip in trips_list:
            self.assertIsNotNone(trip.start_loc)
            self.assertIsNotNone(trip.end_loc)
            self.assertTrue(len(trip["trips"]) > 0)
            rand_id = random.choice(trip["trips"])
            self.assertEqual(type(esdtq.get_trip(rand_id)), ecwt.Trip) 
            self.assertTrue(trip.probabilites.sum() > 0)
            self.assertEqual(str(trip.user_id), "test2")
    def testCreateFromData(self):
        etc.setupRealExample(
            self, "emission/tests/data/real_examples/shankari_2015-aug-27")
        eaicf.filter_accuracy(self.testUUID)
        estfm.move_all_filters_to_data()
        eaist.segment_current_trips(self.testUUID)
        eaiss.segment_current_sections(self.testUUID)

        trips = esdctp.get_all_common_trips_for_user(self.testUUID)
        trips_list = []
        for p in trips:
            trips_list.append(esdctp.make_common_trip_from_json(p))
        for trip in trips_list:
            self.assertIsNotNone(trip.start_loc)
            self.assertIsNotNone(trip.end_loc)
            self.assertTrue(len(trip["trips"]) > 0)
            rand_id = random.choice(trip["trips"])
            self.assertEqual(type(esdtq.get_trip(rand_id)), ecwt.Trip)
            self.assertTrue(trip.probabilites.sum() > 0)
            self.assertEqual(str(trip.user_id), "test2")
Ejemplo n.º 4
0
def segment_trip_into_sections(user_id, trip_id, trip_source):
    ts = esta.TimeSeries.get_time_series(user_id)
    trip = esdt.get_trip(trip_id)
    time_query = esdt.get_time_query_for_trip(trip_id)

    if (trip_source == "DwellSegmentationTimeFilter"):
        import emission.analysis.intake.segmentation.section_segmentation_methods.smoothed_high_confidence_motion as shcm
        shcmsm = shcm.SmoothedHighConfidenceMotion(60, [
            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,
            [
                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, 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 = 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.
    trip_start_loc = ecwl.Location(
        ts.get_entry_at_ts("background/filtered_location", "data.ts",
                           trip.start_ts)["data"])
    trip_end_loc = ecwl.Location(
        ts.get_entry_at_ts("background/filtered_location", "data.ts",
                           trip.end_ts)["data"])
    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))
        start_loc = ecwl.Location(start_loc_doc)
        end_loc = ecwl.Location(end_loc_doc)
        logging.debug("start_loc = %s, end_loc = %s" % (start_loc, end_loc))

        section = esds.create_new_section(user_id, trip_id)
        if prev_section 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)

        if prev_section 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 = esdst.create_new_stop(user_id, trip_id)
            stitch_together(prev_section, stop, section)
            esdst.save_stop(stop)
            esds.save_section(
                prev_section
            )  # Because we have now linked it to the stop, we need to save it again

        esds.save_section(section)
        prev_section = section
 def testGetTrip(self):
     new_trip = self.create_fake_trip()
     ret_trip = esdt.get_trip(new_trip.get_id())
     self.assertEqual(ret_trip, new_trip)