def exit_plot():
"""
Close all TAP tool windows and exit the program
"""
log.info("Exiting TAP Tool")
sys.exit(0)
def onPointChanged(self, lat, lng):
"""
Retrieve the coordinate values in decimal degrees from the leaflet map
Note: This should work for either usage type of PyQt(WebView and WebEngineView)
Args:
lat: Latitude of mouse-click
lng: Longitude of mouse-click
Returns:
None
"""
coords = GeoInfo.get_geocoordinate(xstring=str(lng), ystring=str(lat))
xy = GeoInfo.unit_conversion(coord=coords,
src="lat/long",
dest="meters")
h, v = GeoInfo.get_hv(xy.x, xy.y)
tile = "h{:02}v{:02}".format(h, v)
log.info("New point selected from locator map: %s" % str(coords))
# If necessary, convert to meters before updating the coordinate text on the GUI
if UNITS[self.gui.selected_units]["unit"] == "meters":
coords = GeoInfo.unit_conversion(coords,
src="lat/long",
dest="meters")
coords = GeoInfo.get_geocoordinate(str(int(coords.x)),
str(int(coords.y)))
# Update the X and Y coordinates in the GUI with the new point
self.gui.ui.LineEdit_x1.setText(str(coords.x))
self.gui.ui.LineEdit_y1.setText(str(coords.y))
self.gui.check_values()
# Clear the list of previously clicked ARD observations because they can't be referenced in the new time-series
self.gui.ui.ListWidget_selected.clear()
# Display the coordinate in the QLabel window below the map
self.text.setText(
f"SELECTED - Tile {tile} | Lat/Lng {lat}, {lng} | Meters XY {int(xy.x)}, {int(xy.y)}"
)
return None
def main():
log.debug('*** System Information ***')
log.debug('Platform: %s' % sys.platform)
log.debug('Python: %s' % str(sys.version).replace('\n', ''))
log.debug('Pip: %s' % ', '.join(freeze.freeze()))
log.info("Running lcmap-tap version %s" % __version__)
# Create a QApplication object, necessary to manage the GUI control flow and settings
app = QApplication(sys.argv)
# session_id = "session_{}".format(MainControls.get_time())
control_window = MainControls()
if control_window:
# Enter the main event loop, begin event handling for application widgets until exit() is called
sys.exit(app.exec_())
def check_cache(self, key, cache, items):
"""
Check the contents of the cache file for pre-existing data to avoid making redundant chipmunk requests
Args:
key (Tuple[int, int]): The chip upper-left coordinates
cache (dict): Pre-loaded ARD, could be empty dict if cache file didn't exist
items (list): ubids for the requested bands and indices
Returns:
Tuple[list, list]
[0]: List of ubids that exist in the cache
[1]: List of ubids that will be requested using merlin
"""
if key in cache.keys():
try:
sequence = self.get_sequence(
((_key, item) for _key, item in cache[key].items()),
self.geo.pixel_coord_ul)
required = [i for i in items if i not in sequence.keys()]
cached = [
i for i in sequence.keys() if i not in items or i is 'qas'
]
except KeyError:
required = items
cached = list()
else:
required = items
cached = list()
# remove duplicates (e.g. 'qas')
required = list(set(required))
log.info("Required: %s" % required)
log.info("Cached: %s " % cached)
return cached, required
def show_model_params(self, results, geo):
"""
Print the model results out to the GUI QPlainTextEdit widget
Args:
results: Class instance containing change model results and parameters
geo: Class instance containing geographic info
"""
log.info(
"Plotting for tile H{:02}V{:02} at point ({}, {}) meters".format(
geo.H, geo.V, geo.coord.x, geo.coord.y))
try:
self.ui.PlainTextEdit_results.appendPlainText(
"\n\nBegin Date: {}".format(results.begin))
log.info("Begin Date: {}".format(results.begin))
self.ui.PlainTextEdit_results.appendPlainText(
"End Date: {}\n".format(results.end))
log.info("End Date: {}".format(results.end))
for num, result in enumerate(results.results["change_models"]):
self.ui.PlainTextEdit_results.appendPlainText(
"Result: {}".format(num + 1))
log.info("Result: {}".format(num + 1))
self.ui.PlainTextEdit_results.appendPlainText(
"Start Date: {}".format(
dt.datetime.fromordinal(result["start_day"])))
log.info("Start Date: {}".format(
dt.datetime.fromordinal(result["start_day"])))
self.ui.PlainTextEdit_results.appendPlainText(
"End Date: {}".format(
dt.datetime.fromordinal(result["end_day"])))
log.info("End Date: {}".format(
dt.datetime.fromordinal(result["end_day"])))
self.ui.PlainTextEdit_results.appendPlainText(
"Break Date: {}".format(
dt.datetime.fromordinal(result["break_day"])))
log.info("Break Date: {}".format(
dt.datetime.fromordinal(result["break_day"])))
self.ui.PlainTextEdit_results.appendPlainText("QA: {}".format(
result["curve_qa"]))
log.info("QA: {}".format(result["curve_qa"]))
self.ui.PlainTextEdit_results.appendPlainText(
"Change prob: {}\n".format(result["change_probability"]))
log.info("Change prob: {}".format(
result["change_probability"]))
except (ValueError, TypeError) as _e:
log.error('Exception: %s' % _e, exc_info=True)
pass
def __init__(self,
ard: dict,
change: CCDReader,
segs: SegmentClasses,
items: list,
begin: dt.date = dt.date(year=1982, month=1, day=1),
end: dt.date = dt.date(year=2017, month=12, day=31)):
"""
Args:
ard: The ARD observations for a given point (ARDData.pixel_ard)
change: PyCCD results for a given point (CCDReader.results)
segs: Classification results (SegmentClasses.results)
begin: Beginning day of PyCCD
end: Ending day of PyCCD
"""
self.begin = begin
self.end = end
self.items = items
self.ard = self.make_arrays(ard)
self.dates = self.ard['dates']
try:
self.results = change.results
self.ccd_mask = np.array(self.results['processing_mask'],
dtype=np.bool)
except (AttributeError, TypeError) as e:
# log.debug('Exception: %s' % e, exc_info=True)
log.info('No CCD results were found')
self.results = None
self.ccd_mask = []
try:
self.segment_classes = segs.results
except (AttributeError, TypeError) as e:
# log.debug('Exception: %s' % e, exc_info=True)
log.info('No classification results were found')
self.segment_classes = None
self.date_mask = self.mask_daterange(dates=self.dates,
start=begin,
stop=end)
self.dates_in = self.ard['dates'][self.date_mask]
self.dates_out = self.ard['dates'][~self.date_mask]
self.qa_mask = np.isin(self.ard['qas'], [66, 68, 322, 324])
self.fill_mask = np.isin(
self.ard['qas'], [n for n in np.unique(self.ard['qas']) if n != 1])
self.fill_in = self.fill_mask[self.date_mask]
self.fill_out = self.fill_mask[~self.date_mask]
# # self.total_mask = np.logical_and(self.ccd_mask, self.fill_in)
# self.total_mask = np.logical_and(self.qa_mask[date_mask], self.fill_in)
# Check for presence of thermals, rescale if present
if 'thermals' in self.ard.keys():
self.rescale_thermal()
self.index_to_observations()
if self.results is not None:
self.predicted_values, \
self.prediction_dates, \
self.break_dates, \
self.start_dates, \
self.end_dates = self.get_modelled_specs(self.results)
else:
self.predicted_values = []
self.prediction_dates = []
self.break_dates = []
self.start_dates = []
self.end_dates = []
self.index_lookup, self.band_lookup, self.all_lookup = self.get_lookups(
results=self.results, predicted_values=self.predicted_values)
def __init__(self,
tile,
root,
geo,
version,
begin_year=1984,
end_year=2015):
super(MapsViewer, self).__init__()
icon = QIcon(
QPixmap(
pkg_resources.resource_filename(
"lcmap_tap", "/".join(("Auxiliary", "icon.PNG")))))
self.setWindowIcon(icon)
self.tile = tile
self.root = root
self.geo_info = geo
self.current_pixel = None
self.pixel_rowcol = self.geo_info.geo_to_rowcol(
affine=self.geo_info.PIXEL_AFFINE, coord=self.geo_info.coord)
self.row = self.pixel_rowcol.row
self.col = self.pixel_rowcol.column
log.debug("MAP VIEWER, tile_pixel_rowcol: %s" % str(self.pixel_rowcol))
if not os.path.exists(os.path.join(self.root, version)):
self.version = self.get_version()
else:
self.version = version
self.root = os.path.join(self.root, self.version)
log.info("MAP VIEWER using version %s" % self.version)
log.debug("MAP VIEWER, root: %s" % self.root)
self.get_product_root_directories()
self.ui = Ui_MapViewer()
self.ui.setupUi(self)
self.graphics_view = ImageViewer()
self.ui.scrollArea.setWidget(self.graphics_view)
self.img_list1 = list()
self.pixel_map = None
self.ui.date_slider.setMinimum(begin_year)
self.ui.date_slider.setMaximum(end_year)
self.ui.date_slider.setTickPosition(QSlider.TicksBothSides)
self.ui.date_slider.setTickInterval(1)
# This show's the left-most value of the time slider initially, 1984
self.ui.show_date.setText(str(self.ui.date_slider.value()))
self.ui.move_left.clicked.connect(self.move_left)
self.ui.move_right.clicked.connect(self.move_right)
self.ui.date_slider.valueChanged.connect(self.date_changed)
self.ui.pushButton_zoom.clicked.connect(self.zoom_to_point)
self.ui.comboBox_map1.currentIndexChanged.connect(self.browse_map)
self.ui.exit_QPush.clicked.connect(self.exit)
self.make_rect()
self.init_ui()
from PyQt5.QtWebEngineWidgets import QWebEngineView
USE = 'UseWebEngineView'
except ImportError as e:
log.error('Exception: %s' % e, exc_info=True)
# noinspection PyUnresolvedReferences
from PyQt5.QtWebKitWidgets import QWebView
USE = 'UseWebView'
HTML = pkg_resources.resource_filename(
'lcmap_tap', '/'.join(('MapCanvas', USE, 'index.html')))
log.info("PyQt version=%s" % PYQT_VERSION_STR)
log.info("Qt Web Map using %s" % USE)
sys.excepthook = exc_handler
class Backend(QObject):
"""
Only used with QWebEngineView
"""
pointChanged = pyqtSignal(float, float)
@pyqtSlot(float, float)
def pointClicked(self, x, y):
self.pointChanged.emit(x, y)
