def test_datetime_loaded_by_vector2(self):
        """Testing for the file provided by https://github.com/henrikkriisa"""
        layer = self.layer_dtimes
        attr = "measuredts"
        settings = LayerSettings()
        settings.layer = layer
        settings.startTimeAttribute = attr
        settings.endTimeAttribute = attr
        timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
        self.tlm.registerTimeLayer(timeLayer)

        self.assertEquals(timeLayer.getDateType(),
                          timevectorlayer.DateTypes.DatesAsQDateTimes)
        self.tlm.setTimeFrameType("minutes")
        self.tlm.stepForward()
        subsetString = layer.subsetString()
        expectedSubsetString = STRINGCAST_FORMAT.format(
            attr, self.comparison_op,
            time_util.datetime_to_str(
                self.tlm.getCurrentTimePosition() + timedelta(minutes=1),
                timeLayer.getTimeFormat()), attr,
            time_util.datetime_to_str(self.tlm.getCurrentTimePosition(),
                                      timeLayer.getTimeFormat()))
        self.assertEqual(timeLayer.getTimeFormat(),
                         time_util.OGR_DATETIME_FORMAT)
        self.assertEquals(subsetString, expectedSubsetString)
    def test_datetime_loaded_by_vector2(self):
        """Testing for the file provided by https://github.com/henrikkriisa"""
        layer = self.layer_dtimes
        attr = "measuredts"
        settings = LayerSettings()
        settings.layer = layer
        settings.startTimeAttribute = attr
        settings.endTimeAttribute = attr
        timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
        self.tlm.registerTimeLayer(timeLayer)

        self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.DatesAsQDateTimes)
        self.tlm.setTimeFrameType("minutes")
        self.tlm.stepForward()
        subsetString = layer.subsetString()
        expectedSubsetString = STRINGCAST_FORMAT.format(
            attr,
            self.comparison_op,
            time_util.datetime_to_str(
                self.tlm.getCurrentTimePosition() + timedelta(minutes=1), timeLayer.getTimeFormat()
            ),
            attr,
            time_util.datetime_to_str(self.tlm.getCurrentTimePosition(), timeLayer.getTimeFormat()),
        )
        self.assertEqual(timeLayer.getTimeFormat(), time_util.OGR_DATETIME_FORMAT)
        self.assertEquals(subsetString, expectedSubsetString)
    def _test_spatialite_layer(self, attr, layer, is_int=False):

        settings = LayerSettings()
        settings.layer = layer
        settings.startTimeAttribute = attr
        settings.endTimeAttribute = attr

        timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
        self.tlm.registerTimeLayer(timeLayer)
        if is_int:
            self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.IntegerTimestamps)
            self.assertEquals(timeLayer.getTimeFormat(), time_util.UTC)
        else:
            self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.DatesAsStrings)
            self.assertEquals(timeLayer.getTimeFormat(), time_util.DEFAULT_FORMAT)
        start_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[0], time_util.PENDING)
        self.assertEquals(time_util.epoch_to_datetime(STARTTIME), start_time)

        self.tlm.setTimeFrameType("minutes")
        self.tlm.stepForward()
        assert start_time + timedelta(minutes=1) == self.tlm.getCurrentTimePosition()
        # only one feature is selected now, because there is one feature per minute
        self.assertEquals(layer.featureCount(), 1)
        FS = 5
        self.tlm.setTimeFrameSize(FS)
        # we have one feature per minute
        self.assertEquals(layer.featureCount(), FS)
        subsetString = layer.subsetString()

        if is_int:
            expectedSubsetString = INT_FORMAT.format(
                attr,
                self.comparison_op,
                time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition() + timedelta(minutes=FS)),
                attr,
                time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition()),
            )

            self.assertEquals(subsetString, expectedSubsetString)
            minimum_bound_seconds = int(subsetString.split(" ")[6])
            self.assertEquals(self.tlm.getCurrentTimePosition(), time_util.epoch_to_datetime(minimum_bound_seconds))
        if not is_int:
            self.assertEqual(timeLayer.getTimeFormat(), time_util.DEFAULT_FORMAT)
            expectedSubsetString = STRING_FORMAT.format(
                attr,
                self.comparison_op,
                time_util.datetime_to_str(
                    self.tlm.getCurrentTimePosition() + timedelta(minutes=FS), timeLayer.getTimeFormat()
                ),
                attr,
                time_util.datetime_to_str(self.tlm.getCurrentTimePosition(), timeLayer.getTimeFormat()),
            )

            self.assertEquals(subsetString, expectedSubsetString)

        self.tlm.stepForward()
        self.assertEquals(layer.featureCount(), FS)
    def test_datetime_loaded_by_vector(self):
        layer = self.layer_loaded_as_vector
        attr = STRING_TIMESTAMP
        settings = LayerSettings()
        settings.layer = layer
        settings.startTimeAttribute = attr
        settings.endTimeAttribute = attr
        timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
        self.tlm.registerTimeLayer(timeLayer)

        self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.DatesAsQDateTimes)
示例#5
0
    def test_datetime_loaded_by_vector(self):
        layer = self.layer_loaded_as_vector
        attr=STRING_TIMESTAMP
        settings = LayerSettings()
        settings.layer = layer
        settings.startTimeAttribute = attr
        settings.endTimeAttribute = attr
        timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
        self.tlm.registerTimeLayer(timeLayer)

        self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.DatesAsQDateTimes)
示例#6
0
    def _test_spatialite_layer(self, attr, layer, is_int=False):

        settings = LayerSettings()
        settings.layer = layer
        settings.startTimeAttribute = attr
        settings.endTimeAttribute = attr

        timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
        self.tlm.registerTimeLayer(timeLayer)
        if is_int:
            self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.IntegerTimestamps)
            self.assertEquals(timeLayer.getTimeFormat(),time_util.UTC)
        else:
            self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.DatesAsStrings)
            self.assertEquals(timeLayer.getTimeFormat(),time_util.DEFAULT_FORMAT)
        start_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[0], time_util.PENDING)
        self.assertEquals(time_util.epoch_to_datetime(STARTTIME), start_time)

        self.tlm.setTimeFrameType("minutes")
        self.tlm.stepForward()
        assert( start_time + timedelta(minutes=1)==self.tlm.getCurrentTimePosition())
        # only one feature is selected now, because there is one feature per minute
        self.assertEquals(layer.featureCount(), 1)
        FS = 5
        self.tlm.setTimeFrameSize(FS)
        # we have one feature per minute
        self.assertEquals(layer.featureCount(), FS)
        subsetString = layer.subsetString()

        if is_int:
            expectedSubsetString = INT_FORMAT.format(attr,self.comparison_op,
                                    time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition()+timedelta(minutes=FS)),
                                    attr,
                                    time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition()))

            self.assertEquals(subsetString, expectedSubsetString)
            minimum_bound_seconds = int(subsetString.split(" ")[6] )
            self.assertEquals(self.tlm.getCurrentTimePosition(), time_util.epoch_to_datetime(
                minimum_bound_seconds))
        if not is_int:
            self.assertEqual(timeLayer.getTimeFormat(), time_util.DEFAULT_FORMAT)
            expectedSubsetString = STRING_FORMAT.format(attr,self.comparison_op,
                                    time_util.datetime_to_str(self.tlm.getCurrentTimePosition()+timedelta(minutes=FS)
                                    ,timeLayer.getTimeFormat()),attr,
                                    time_util.datetime_to_str(self.tlm.getCurrentTimePosition(),
                                                              timeLayer.getTimeFormat()))

            self.assertEquals(subsetString, expectedSubsetString)

        self.tlm.stepForward()
        self.assertEquals(layer.featureCount(), FS)
 def test_layer_always_has_a_feature_per_unique_id(self):
     settings = LayerSettings()
     settings.layer = self.layer
     settings.interpolationMode = conf.LINEAR_POINT_INTERPOLATION
     settings.startTimeAttribute = TIMESTAMP
     settings.endTimeAttribute = TIMESTAMP
     settings.interpolationEnabled = True
     settings.idAttribute = ID
     timeLayer = TimeVectorInterpolatedLayer(settings, iface=Mock())
     self.tlm.registerTimeLayer(timeLayer)
     self.tlm.setTimeFrameType("seconds")
     for i in range(11):
         self.assertTrue(timeLayer.layer.featureCount() + timeLayer.memLayer.featureCount() ==
                         UNIQUE_IDS)
         self.tlm.stepForward()
 def test_layer_always_has_a_feature_per_unique_id(self):
     settings = LayerSettings()
     settings.layer = self.layer
     settings.interpolationMode = conf.LINEAR_POINT_INTERPOLATION
     settings.startTimeAttribute = TIMESTAMP
     settings.endTimeAttribute = TIMESTAMP
     settings.interpolationEnabled = True
     settings.idAttribute = ID
     timeLayer = TimeVectorInterpolatedLayer(settings, iface=Mock())
     self.tlm.registerTimeLayer(timeLayer)
     self.tlm.setTimeFrameType("seconds")
     for i in range(11):
         self.assertTrue(timeLayer.layer.featureCount()+ timeLayer.memLayer.featureCount() ==
                         UNIQUE_IDS)
         self.tlm.stepForward()