def restoreTimeLayers(self, layerInfos):
"""Restore all time layers"""
if layerInfos:
if len(layerInfos) > 0:
self.guiControl.enableAnimationExport()
for l in layerInfos: # for every layer entry
try:
settings = layer_settings.getSettingsFromSaveStr(l)
if settings.layer is None:
error_msg = QCoreApplication.translate('TimeManager', "Could not restore layer with id {} from saved project line {}").format(
settings.layerId, l
)
error(error_msg)
self.showMessage(error_msg)
continue
timeLayer = TimeLayerFactory.get_timelayer_class_from_settings(settings)(
settings, iface=self.iface)
except Exception as e:
layerId = "unknown"
try:
layerId = settings.layerId
except Exception:
pass
error_msg = QCoreApplication.translate('TimeManager', "An error occured while trying to restore layer {} to TimeManager. {}").format(
layerId, str(e)
)
error(error_msg + traceback.format_exc(e))
self.showMessage(error_msg)
continue
self.timeLayerManager.registerTimeLayer(timeLayer)
self.guiControl.refreshMapCanvas('restoreTimeLayer')
def saveOptions(self):
self.getTimeLayerManager().clearTimeLayerList()
for row in range(self.guiControl.optionsDialog.tableWidget.rowCount()):
try:
layer = self.createTimeLayerFromRow(row)
except time_util.NoneValueDetectedException:
error_msg = QCoreApplication.translate(
'TimeManager',
"An error occurred while trying to add layer {0} to TimeManager because there are NULL values in the timestamp column."
)
error(error_msg)
self.showMessage(error_msg)
if layer is None:
continue
self.getTimeLayerManager().registerTimeLayer(layer)
# save animation options
animationFrameLength = self.guiControl.optionsDialog.spinBoxFrameLength.value(
)
playBackwards = self.guiControl.optionsDialog.checkBoxBackwards.isChecked(
)
loopAnimation = self.guiControl.optionsDialog.checkBoxLoop.isChecked(
)
self.setAnimationOptions(animationFrameLength, playBackwards,
loopAnimation)
self.guiControl.exportEmpty = not self.guiControl.optionsDialog.checkBoxDontExportEmpty.isChecked(
)
self.guiControl.showLabel = self.guiControl.optionsDialog.checkBoxLabel.isChecked(
)
self.guiControl.refreshMapCanvas('saveOptions')
self.guiControl.dock.pushButtonExportVideo.setEnabled(True)
self.timeLayerManager.refreshTimeRestrictions()
def __init__(self, settings, iface=None):
TimeLayer.__init__(self, settings.layer, settings.isEnabled)
try:
self.layer = settings.layer
self.iface = iface
self.minValue, self.maxValue = None, None
self.fromTimeAttribute = settings.startTimeAttribute
self.toTimeAttribute = settings.endTimeAttribute if settings.endTimeAttribute != "" \
else self.fromTimeAttribute
self.accumulate = settings.accumulate
self.resetsss = settings.resetSubsetString
self.originalSubsetString = settings.subsetStr
self.currSubsetString = self.originalSubsetString
if self.resetsss:
self.setSubsetString("")
else:
self.setSubsetString(self.originalSubsetString)
self.geometriesCount = settings.geometriesCount
self.type = time_util.DateTypes.determine_type(
self.getRawMinValue())
if self.type not in time_util.DateTypes.QDateTypes:
# call to throw an exception early if no format can be found
self.findValidValues(self.fromTimeAttribute,
settings.timeFormat)
if self.fromTimeAttribute != self.toTimeAttribute:
self.findValidValues(self.toTimeAttribute,
settings.timeFormat)
self.timeFormat = self.determine_format(self.getRawMinValue(),
settings.timeFormat)
if self.toTimeAttribute != self.fromTimeAttribute:
type2 = time_util.DateTypes.determine_type(
self.getRawMaxValue())
tf2 = self.determine_format(self.getRawMaxValue(),
settings.timeFormat)
if self.type != type2 or self.timeFormat != tf2:
raise InvalidTimeLayerError(
QCoreApplication.translate(
'TimeManager',
"Invalid time layer: To and From attributes must have "
"exact same format"))
self.offset = int(settings.offset)
assert (self.timeFormat != time_util.PENDING)
extents = self.getTimeExtents()
info("Layer extents" + str(extents))
if self.resetsss:
self.setSubsetString(self.originalSubsetString)
except ValueError as e:
# ValueErrors appear for virtual layers, see https://github.com/anitagraser/TimeManager/issues/219
error(traceback.format_exc(e))
raise InvalidTimeLayerError(
QCoreApplication.translate(
'TimeManager',
'This layer type is currently not supported. Cause:{}').
format(str(e)))
except Exception as e:
error(traceback.format_exc(e))
raise InvalidTimeLayerError(str(e))
def createTimeLayerFromRow(self, row, show_detailed_error_messages=False):
"""Create a TimeLayer from options set in the table row"""
settings = layer_settings.getSettingsFromRow(
self.guiControl.optionsDialog.tableWidget, row)
if show_detailed_error_messages:
timeLayer = TimeLayerFactory.get_timelayer_class_from_settings(
settings)(settings, self.iface)
return timeLayer
try:
timeLayer = TimeLayerFactory.get_timelayer_class_from_settings(
settings)(settings, self.iface)
except Exception as e:
layer_name = "unknown"
try:
layer_name = settings.layer.name()
except Exception:
pass
error_msg = QCoreApplication.translate(
'TimeManager',
"An error occurred while trying to add layer {0} to TimeManager. Cause: {1}"
).format(layer_name, str(e))
error(error_msg)
self.showMessage(error_msg)
return None
return timeLayer
def refreshGuiWithCurrentTime(self, currentTimePosition, sender=None):
"""
Update the gui when time has changed by refreshing/repainting the layers
and changing the time showing in dateTimeEditCurrentTime and horizontalTimeSlider
Setting the gui elements should not fire the event for
timeChanged, since they were changed to be in sync with the rest of the system on
purpose, no need to sync the system again
"""
self.setPropagateGuiChanges(False)
timeExtent = self.getTimeLayerManager().getProjectTimeExtents()
if currentTimePosition is None or timeExtent[0] is None or timeExtent[1] is None:
self.setPropagateGuiChanges(True)
return
time_util.updateUi(self.guiControl.getTimeWidget(), currentTimePosition)
timeval = time_util.datetime_to_epoch(currentTimePosition)
timeExtents = self.getTimeLayerManager().getProjectTimeExtents()
try:
pct = (timeval - time_util.datetime_to_epoch(timeExtents[0])) * 1.0 / (time_util.datetime_to_epoch(
timeExtents[1]) - time_util.datetime_to_epoch(timeExtents[0]))
sliderVal = self.guiControl.dock.horizontalTimeSlider.minimum() + int(pct * (
self.guiControl.dock.horizontalTimeSlider.maximum() -
self.guiControl.dock.horizontalTimeSlider.minimum()))
self.guiControl.dock.horizontalTimeSlider.setValue(sliderVal)
self.guiControl.repaintRasters()
self.guiControl.repaintJoined()
self.guiControl.repaintVectors()
self.guiControl.refreshMapCanvas()
self.updateLegendCount()
except Exception as e:
error(e)
finally:
self.setPropagateGuiChanges(True)
def __init__(self, settings, iface=None):
TimeLayer.__init__(self, settings.layer, settings.isEnabled)
try:
self.layer = settings.layer
self.iface = iface
self.minValue, self.maxValue = None, None
self.fromTimeAttribute = settings.startTimeAttribute
self.toTimeAttribute = settings.endTimeAttribute if settings.endTimeAttribute != "" \
else self.fromTimeAttribute
self.accumulate = settings.accumulate
self.resetsss = settings.resetSubsetString
self.originalSubsetString = settings.subsetStr
self.currSubsetString = self.originalSubsetString
if self.resetsss:
self.setSubsetString("")
else:
self.setSubsetString(self.originalSubsetString)
self.geometriesCount = settings.geometriesCount
self.type = time_util.DateTypes.determine_type(self.getRawMinValue())
if self.type not in time_util.DateTypes.QDateTypes:
# call to throw an exception early if no format can be found
self.findValidValues(self.fromTimeAttribute, settings.timeFormat)
if self.fromTimeAttribute != self.toTimeAttribute:
self.findValidValues(self.toTimeAttribute, settings.timeFormat)
self.timeFormat = self.determine_format(self.getRawMinValue(), settings.timeFormat)
if self.toTimeAttribute != self.fromTimeAttribute:
type2 = time_util.DateTypes.determine_type(self.getRawMaxValue())
tf2 = self.determine_format(self.getRawMaxValue(), settings.timeFormat)
if self.type != type2 or self.timeFormat != tf2:
raise InvalidTimeLayerError(
QCoreApplication.translate(
'TimeManager',
"Invalid time layer: To and From attributes must have "
"exact same format"
)
)
self.offset = int(settings.offset)
assert (self.timeFormat != time_util.PENDING)
extents = self.getTimeExtents()
info("Layer extents" + str(extents))
if self.resetsss:
self.setSubsetString(self.originalSubsetString)
except ValueError as e:
# ValueErrors appear for virtual layers, see https://github.com/anitagraser/TimeManager/issues/219
error(traceback.format_exc(e))
raise InvalidTimeLayerError(
QCoreApplication.translate(
'TimeManager',
'This layer type is currently not supported. Cause:{}'
).format(str(e))
)
except Exception as e:
error(traceback.format_exc(e))
raise InvalidTimeLayerError(str(e))
def vals_to_dt(vals, fmt):
res = []
for val in vals:
try:
dt = time_util.timeval_to_datetime(val, fmt)
res.append(dt)
# info("{} converted to {}".format(val, dt))
except Exception as e:
error(traceback.format_exc(e))
warn(QCoreApplication.translate('TimeManager', "Unparseable value {0} in layer {1} ignored. Cause {2}").format(val, self.layer.name(), e))
return res
def setArchaeology(self, enabled=0):
if enabled == 0:
if [
x for x in self.getTimeLayerManager().layers()
if time_util.is_archaeological_layer(x)
]:
QMessageBox.information(
self.iface.mainWindow(),
QCoreApplication.translate('TimeManager', 'Error'),
QCoreApplication.translate(
'TimeManager',
"Already have archaeological layers in the project."
"Please delete them to switch to normal mode"))
self.guiControl.setArchaeologyPressed(True)
return
time_util.setCurrentMode(time_util.NORMAL_MODE)
self.guiControl.setWindowTitle("Time Manager")
self.guiControl.setArchaeologyPressed(False)
self.guiControl.disableArchaeologyTextBox()
else:
if [
x for x in self.getTimeLayerManager().layers()
if not time_util.is_archaeological_layer(x)
]:
QMessageBox.information(
self.iface.mainWindow(),
QCoreApplication.translate('TimeManager', 'Error'),
QCoreApplication.translate(
'TimeManager',
"Already have non archaeological layers in the project."
"Please delete them to switch to archaeological mode"))
self.guiControl.setArchaeologyPressed(False)
return
time_util.setCurrentMode(time_util.ARCHAELOGY_MODE)
self.guiControl.setWindowTitle(
QCoreApplication.translate('TimeManager',
"Time Manager Archaeology Mode"))
self.guiControl.setArchaeologyPressed(True)
ctx = self.guiControl.dock.objectName()
try:
self.guiControl.setTimeFrameType(
QCoreApplication.translate(ctx, 'years'))
except Exception:
error(
QCoreApplication.translate(
'TimeManager', "should only happen during testing"))
self.guiControl.enableArchaeologyTextBox()
self.showMessage(
QCoreApplication.translate(
'TimeManager',
"Archaelogy mode enabled. Expecting data of the form {0} BC or {0} AD."
" Disable to work with regular datetimes from year 1 onwards"
).format("Y" * time_util.getArchDigits()))
def __init__(self, settings, iface=None):
TimeLayer.__init__(self, settings.layer, settings.isEnabled)
self.layer = settings.layer
self.iface = iface
self.minValue, self.maxValue = None, None
self.fromTimeAttribute = settings.startTimeAttribute
self.toTimeAttribute = settings.endTimeAttribute if settings.endTimeAttribute != "" \
else self.fromTimeAttribute
self.accumulate = settings.accumulate
self.resetsss = settings.resetSubsetString
self.originalSubsetString = settings.subsetStr
self.currSubsetString = self.originalSubsetString
if self.resetsss:
self.setSubsetString("")
else:
self.setSubsetString(self.originalSubsetString)
self.geometriesCount = settings.geometriesCount
if self.layer.dataProvider().storageType() == 'Memory storage':
self.raiseInvalidLayerError("Invalid time layer: Memory layers are not supported")
raw_min_value = self.getRawMinValue()
info("Raw min value: {}".format(raw_min_value))
self.timestamp_type = time_util.DateTypes.determine_type(raw_min_value)
info("Time stamp type: {}".format(self.timestamp_type))
try:
if self.timestamp_type not in time_util.DateTypes.QDateTypes:
# call to throw an exception early if no format can be found
self.findValidValues(self.fromTimeAttribute, settings.timeFormat)
if self.fromTimeAttribute != self.toTimeAttribute:
self.findValidValues(self.toTimeAttribute, settings.timeFormat)
self.timeFormat = self.determine_format(self.getFromValue(), settings.timeFormat)
info("Time format: {}".format(self.timeFormat))
if self.toTimeAttribute != self.fromTimeAttribute:
type2 = time_util.DateTypes.determine_type(self.getRawMaxValue())
tf2 = self.determine_format(self.getToValue(), settings.timeFormat)
if self.timestamp_type != type2 or self.timeFormat != tf2:
self.raiseInvalidLayerError("Invalid time layer: To and From attributes must have exact same format")
self.offset = int(settings.offset)
assert (self.timeFormat != time_util.PENDING)
extents = self.getTimeExtents()
info("Layer extents" + str(extents))
if self.resetsss:
self.setSubsetString(self.originalSubsetString)
except Exception as e:
error(e)
raise InvalidTimeLayerError(str(e))
def vals_to_dt(vals, fmt):
res = []
for val in vals:
try:
dt = time_util.timeval_to_datetime(val, fmt)
res.append(dt)
#info("{} converted to {}".format(val, dt))
except time_util.NoneValueDetectedException as e:
pass
#error(e)
#warn(QCoreApplication.translate('TimeManager', "An error occurred while trying to add layer {0} to TimeManager because there are NULL values in the timestamp column."))
except Exception as e:
error(e)
warn(QCoreApplication.translate('TimeManager', "Unparseable value {0} in layer {1} ignored. Cause {2}").format(val, self.layer.name(), e))
return res
def findValidValues(self, fieldName, fmt):
uniques = self.getUniques(fieldName)
at_least_one_valid = False
last_exc = None
for v in uniques:
try:
time_util.str_to_datetime(v, fmt)
at_least_one_valid = True
break
except Exception as e:
error(traceback.format_exc(e))
last_exc = e
continue
if not at_least_one_valid:
raise Exception(last_exc)
def vals_to_dt(vals, fmt):
res = []
for val in vals:
try:
dt = time_util.timeval_to_datetime(val, fmt)
res.append(dt)
# info("{} converted to {}".format(val, dt))
except Exception as e:
error(traceback.format_exc(e))
warn(
QCoreApplication.translate(
'TimeManager',
"Unparseable value {0} in layer {1} ignored. Cause {2}"
).format(val, self.layer.name(), e))
return res
def findValidValues(self, fieldName, fmt):
uniques = self.getUniques(fieldName)
at_least_one_valid = False
last_exception = None
for v in uniques:
try:
time_util.str_to_datetime(v, fmt)
at_least_one_valid = True
break
except time_util.UnsupportedFormatException as e:
error(e)
last_exception = e
continue
if not at_least_one_valid:
raise NoValidTimestampValuesException(last_exception)
def findValidValues(self, fieldName, fmt):
uniques = self.getUniques(fieldName)
at_least_one_valid = False
last_exc = None
for v in uniques:
try:
time_util.str_to_datetime(v, fmt)
at_least_one_valid = True
break
except Exception as e:
error(traceback.format_exc(e))
last_exc = e
continue
if not at_least_one_valid:
raise Exception(last_exc)
def toggleAnimation(self):
"""Toggle animation on/off"""
if self.animationActivated:
self.animationActivated = False
else:
self.animationActivated = True
self.animationFrameCounter = 0
expectedNumberOfFrames = self.timeLayerManager.getFrameCount()
if expectedNumberOfFrames == 0: # will be zero if no layer is time managed
self.animationActivated = False
if len(self.getTimeLayerManager().getTimeLayerList()) > 0:
error(QCoreApplication.translate('TimeManager', "Have layers, but animation not possible"))
self.exportNameDigits = len(str(expectedNumberOfFrames)) + 1 # add 1 to deal with cornercases (hacky fix)
self.startAnimation() # if animation is activated, it will start
def setTimeRestriction(self, timePosition, timeFrame):
"""Construct the query, including the original subset"""
if not self.isEnabled():
self.deleteTimeRestriction()
return
startTime = self.getStartTime(timePosition, timeFrame)
endTime = self.getEndTime(timePosition, timeFrame)
dateType = self.getDateType()
# determine which idioms should be tried
# SQL
idioms_to_try = [
query_builder.QueryIdioms.SQL, query_builder.QueryIdioms.OGR
]
# OGR
if dateType in time_util.DateTypes.QDateTypes:
idioms_to_try = [query_builder.QueryIdioms.OGR]
# Postgres
# use optimized query format for postgres + (timestamp|date) columns
if self.layer.dataProvider().storageType(
) == POSTGRES_TYPE and dateType in time_util.DateTypes.QDateTypes:
idioms_to_try = [query_builder.QueryIdioms.SQL]
tried = []
# now try them
for idiom in idioms_to_try:
subsetString = query_builder.build_query(
startTime,
endTime,
self.fromTimeAttribute,
self.toTimeAttribute,
date_type=dateType,
date_format=self.getTimeFormat(),
query_idiom=idiom,
acc=self.accumulateFeatures())
try:
self.setSubsetString(subsetString)
except SubstringException:
error(traceback.format_exc(e))
tried.append(subsetString)
# try the other one
# not sure if trying several idioms could make the screen flash
continue
return
raise SubstringException(
"Could not update subset string for layer {}. Tried: {}".format(
self.layer.name(), tried))
def setArchaeology(self, enabled=0):
if enabled == 0:
if [x for x in self.getTimeLayerManager().layers() if time_util.is_archaeological_layer(x)]:
QMessageBox.information(self.iface.mainWindow(),
QCoreApplication.translate('TimeManager', 'Error'),
QCoreApplication.translate('TimeManager', "Already have archaeological layers in the project."
"Please delete them to switch to normal mode"))
self.guiControl.setArchaeologyPressed(True)
return
time_util.setCurrentMode(time_util.NORMAL_MODE)
self.guiControl.setWindowTitle("Time Manager")
self.guiControl.setArchaeologyPressed(False)
self.guiControl.disableArchaeologyTextBox()
else:
if [x for x in self.getTimeLayerManager().layers() if not time_util.is_archaeological_layer(x)]:
QMessageBox.information(self.iface.mainWindow(),
QCoreApplication.translate('TimeManager', 'Error'),
QCoreApplication.translate('TimeManager', "Already have non archaeological layers in the project."
"Please delete them to switch to archaeological mode"))
self.guiControl.setArchaeologyPressed(False)
return
time_util.setCurrentMode(time_util.ARCHAELOGY_MODE)
self.guiControl.setWindowTitle(QCoreApplication.translate('TimeManager', "Time Manager Archaeology Mode"))
self.guiControl.setArchaeologyPressed(True)
ctx = self.guiControl.dock.objectName()
try:
self.guiControl.setTimeFrameType(QCoreApplication.translate(ctx, 'years'))
except Exception:
error(
QCoreApplication.translate(
'TimeManager',
"should only happen during testing"
)
)
self.guiControl.enableArchaeologyTextBox()
self.showMessage(
QCoreApplication.translate(
'TimeManager',
"Archaelogy mode enabled. Expecting data of the form {0} BC or {0} AD."
" Disable to work with regular datetimes from year 1 onwards"
).format(
"Y" * time_util.getArchDigits()
)
)
def createTimeLayerFromRow(self, row):
"""Create a TimeLayer from options set in the table row"""
try:
settings = layer_settings.getSettingsFromRow(self.guiControl.optionsDialog.tableWidget, row)
timeLayer = TimeLayerFactory.get_timelayer_class_from_settings(settings)(settings, self.iface)
except Exception as e:
layer_name = "unknown"
try:
layer_name = settings.layer.name()
except Exception:
pass
error_msg = QCoreApplication.translate(
'TimeManager',
"An error occured while trying to add layer {0} to TimeManager. Cause: {1}"
).format(layer_name, str(e))
error(error_msg + traceback.format_exc(e))
self.showMessage(error_msg)
return None
return timeLayer
def toggleAnimation(self):
"""Toggle animation on/off"""
if self.animationActivated:
self.animationActivated = False
else:
self.animationActivated = True
self.animationFrameCounter = 0
expectedNumberOfFrames = self.timeLayerManager.getFrameCount()
if expectedNumberOfFrames == 0: # will be zero if no layer is time managed
self.animationActivated = False
if len(self.getTimeLayerManager().getTimeLayerList()) > 0:
error(
QCoreApplication.translate(
'TimeManager',
"Have layers, but animation not possible"))
self.exportNameDigits = len(
str(expectedNumberOfFrames
)) + 1 # add 1 to deal with cornercases (hacky fix)
self.startAnimation() # if animation is activated, it will start
def make_animation(out_folder,
delay_millis,
frame_pattern=DEFAULT_FRAME_PATTERN):
if not can_animate():
error("Imagemagick is not in path")
raise Exception(
"Imagemagick is not in path. Please install ImageMagick!")
out_file = os.path.join(out_folder, DEFAULT_ANIMATION_NAME)
all_frames = glob.glob(os.path.join(out_folder, frame_pattern))
if len(all_frames) == 0:
msg = "Couldn't find any frames with pattern {} in folder {} to animate".format(
frame_pattern, out_folder)
error(msg)
raise Exception(msg)
all_frames.sort()
fps = 1000 / delay_millis
args = [IMAGEMAGICK, "-delay", "1x" + str(fps)] + all_frames + [out_file]
ret = subprocess.check_call(args)
if (ret != 0):
msg = "Something went wrong creating the animated gif from frames"
error(msg)
raise Exception(msg)
info("Exported {} frames to gif {} (call :{})".format(
len(all_frames), out_file, args))
return out_file
def changeI18n(self, new_lang):
"""
Change internationalisation for the plugin.
Override the system locale and then see if we can get a valid
translation file for whatever locale is effectively being used.
"""
# os.environ["LANG"] = str(new_lang)
root = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
translation_path = "TimeManager:i18n/{}_{}.qm".format(self.name, new_lang)
self.translator = QTranslator()
result = self.translator.load(translation_path)
if not result:
error(
"Translation file {} for lang {} was not loaded properly," +
"falling back to English".format(translation_path, new_lang)
)
return
if qVersion() > "4.3.3":
QCoreApplication.installTranslator(self.translator)
else:
self.translator = None
warn("Translation not supported for Qt <= {}".format(qVersion()))
def changeI18n(self, new_lang):
"""
Change internationalisation for the plugin.
Override the system locale and then see if we can get a valid
translation file for whatever locale is effectively being used.
"""
# os.environ["LANG"] = str(new_lang)
root = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir))
translation_path = "TimeManager:i18n/{}_{}.qm".format(
self.name, new_lang)
self.translator = QTranslator()
result = self.translator.load(translation_path)
if not result:
error("Translation file {} for lang {} was not loaded properly," +
"falling back to English".format(translation_path, new_lang))
return
if qVersion() > "4.3.3":
QCoreApplication.installTranslator(self.translator)
else:
self.translator = None
warn("Translation not supported for Qt <= {}".format(qVersion()))
def setTimeRestriction(self, timePosition, timeFrame):
"""Construct the query, including the original subset"""
if not self.isEnabled():
self.deleteTimeRestriction()
return
startTime = self.getStartTime(timePosition, timeFrame)
endTime = self.getEndTime(timePosition, timeFrame)
dateType = self.getDateType()
# determine which idioms should be tried
# SQL
idioms_to_try = [query_builder.QueryIdioms.SQL, query_builder.QueryIdioms.OGR]
# OGR
if dateType in time_util.DateTypes.QDateTypes:
idioms_to_try = [query_builder.QueryIdioms.OGR]
# Postgres
# use optimized query format for postgres + (timestamp|date) columns
if self.layer.dataProvider().storageType() == POSTGRES_TYPE and dateType in time_util.DateTypes.QDateTypes:
idioms_to_try = [query_builder.QueryIdioms.SQL]
tried = []
# now try them
for idiom in idioms_to_try:
subsetString = query_builder.build_query(
startTime, endTime, self.fromTimeAttribute, self.toTimeAttribute, date_type=dateType,
date_format=self.getTimeFormat(), query_idiom=idiom, acc=self.accumulateFeatures()
)
try:
self.setSubsetString(subsetString)
except SubstringException:
error(traceback.format_exc(e))
tried.append(subsetString)
# try the other one
# not sure if trying several idioms could make the screen flash
continue
return
raise SubstringException(
"Could not update subset string for layer {}. Tried: {}".format(self.layer.name(), tried))
def refreshGuiWithCurrentTime(self, currentTimePosition, sender=None):
"""
Update the gui when time has changed by refreshing/repainting the layers
and changing the time showing in dateTimeEditCurrentTime and horizontalTimeSlider
Setting the gui elements should not fire the event for
timeChanged, since they were changed to be in sync with the rest of the system on
purpose, no need to sync the system again
"""
self.setPropagateGuiChanges(False)
timeExtent = self.getTimeLayerManager().getProjectTimeExtents()
if currentTimePosition is None or timeExtent[0] is None or timeExtent[
1] is None:
self.setPropagateGuiChanges(True)
return
time_util.updateUi(self.guiControl.getTimeWidget(),
currentTimePosition)
timeval = time_util.datetime_to_epoch(currentTimePosition)
timeExtents = self.getTimeLayerManager().getProjectTimeExtents()
try:
pct = (timeval - time_util.datetime_to_epoch(timeExtents[0])
) * 1.0 / (time_util.datetime_to_epoch(timeExtents[1]) -
time_util.datetime_to_epoch(timeExtents[0]))
sliderVal = self.guiControl.dock.horizontalTimeSlider.minimum(
) + int(pct *
(self.guiControl.dock.horizontalTimeSlider.maximum() -
self.guiControl.dock.horizontalTimeSlider.minimum()))
self.guiControl.dock.horizontalTimeSlider.setValue(sliderVal)
self.guiControl.repaintRasters()
self.guiControl.repaintJoined()
self.guiControl.repaintVectors()
self.guiControl.refreshMapCanvas()
self.updateLegendCount()
except Exception as e:
error(e)
finally:
self.setPropagateGuiChanges(True)
def restoreTimeLayers(self, layerInfos):
"""Restore all time layers"""
if layerInfos:
if len(layerInfos) > 0:
self.guiControl.enableAnimationExport()
for l in layerInfos: # for every layer entry
try:
settings = layer_settings.getSettingsFromSaveStr(l)
if settings.layer is None:
error_msg = QCoreApplication.translate(
'TimeManager',
"Could not restore layer with id {} from saved project line {}"
).format(settings.layerId, l)
error(error_msg)
self.showMessage(error_msg)
continue
timeLayer = TimeLayerFactory.get_timelayer_class_from_settings(
settings)(settings, iface=self.iface)
except Exception as e:
layerId = "unknown"
try:
layerId = settings.layerId
except Exception:
pass
error_msg = QCoreApplication.translate(
'TimeManager',
"An error occured while trying to restore layer {} to TimeManager. {}"
).format(layerId, str(e))
error(error_msg + e)
self.showMessage(error_msg)
continue
self.timeLayerManager.registerTimeLayer(timeLayer)
self.guiControl.refreshMapCanvas('restoreTimeLayer')
