test_mapvisualization.py

# -*- coding: utf-8 -*-

"""
***************************************************************************
    
    ---------------------
    Date                 : 30.11.2017
    Copyright            : (C) 2017 by Benjamin Jakimow
    Email                : benjamin jakimow at geo dot hu-berlin dot de
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""
# noinspection PyPep8Naming

from eotimeseriesviewer.tests import initQgisApplication, createTimeSeries, testRasterFiles, TestObjects
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from qgis.core import *
from qgis.gui import *
import unittest
from eotimeseriesviewer.utils import *
from eotimeseriesviewer.timeseries import TimeSeries, TimeSeriesDate, TimeSeriesSource
from eotimeseriesviewer.mapcanvas import *
from eotimeseriesviewer.mapvisualization import *
from example.Images import Img_2014_05_07_LC82270652014127LGN00_BOA
QGIS_APP = initQgisApplication(loadProcessingFramework=False)

from eotimeseriesviewer import initResources
initResources()

SHOW_GUI = True and os.environ.get('CI') is None


def getChildElements(node):
    assert isinstance(node, QDomNode)
    childs = node.childNodes()
    return [childs.at(i) for i in range(childs.count())]


def compareXML(element1, element2):

    assert isinstance(element1, QDomNode)
    assert isinstance(element2, QDomNode)

    tag1 = element1.nodeName()
    tag2 = element2.nodeName()
    if tag1 != tag2:
        return False

    elts1 = getChildElements(element1)
    elts2 = getChildElements(element2)

    if len(elts1) != len(elts2):
        return False

    if len(elts1) == 0:


        value1 = element1.nodeValue()
        value2 = element2.nodeValue()

        if value1 != value2:
            return False
        else:
            return True
    else:
        for e1, e2 in zip(elts1, elts2):
            if not compareXML(e1, e2):
                return False

        return True


class testclassMapVisualization(unittest.TestCase):
    """Test resources work."""


    def test_mapWidget(self):

        TS = TestObjects.createTimeSeries()

        w = MapWidget()
        w.mMpMV = 1
        w.show()

        controllW = QWidget()
        controllW.setLayout(QGridLayout())
        g = controllW.layout()
        assert isinstance(g, QGridLayout)

        scroll = QScrollBar()
        scroll.setOrientation(Qt.Horizontal)
        scroll.setMinimum(0)
        scroll.setMaximum(len(TS)-1)
        scroll.setValue(0)
        def onTSDChanged(value):
            w.setCurrentDate(TS[value])
            for c in w.mapCanvases():
                c.update()
        scroll.valueChanged.connect(onTSDChanged)


        def onNMapViews(n):
            mvs = w.mapViews()

            if n < 0:
                return

            if n < len(mvs):
                toRemove = mvs[n:]
                for mv in toRemove:
                    w.removeMapView(mv)
            elif n > len(mvs):
                while len(w.mapViews()) < n:
                    mv = MapView()
                    mv.setTitle('MV {}'.format(len(w.mapViews())))
                    w.addMapView(mv)

        btnAMV = QPushButton('Add MapView')
        btnRMV = QPushButton('Remove MapView')
        btnAMV.clicked.connect(lambda : onNMapViews(len(w.mapViews()) + 1))
        btnRMV.clicked.connect(lambda : onNMapViews(len(w.mapViews()) - 1))

        sb = QSpinBox()
        sb.setMinimum(1)
        sb.setMaximum(100)
        sb.setValue(w.mMpMV)
        sb.valueChanged.connect(lambda v: w.setMapsPerMapView(v))

        sbX = QSpinBox()
        sbX.setRange(50,1000)
        sbX.setSingleStep(50)
        sbX.setValue(w.mMapSize.width())
        sbY = QSpinBox()
        sbY.setRange(50, 1000)
        sbY.setSingleStep(50)
        sbY.setValue(w.mMapSize.height())
        def onMapSizeChanged():

            s = QSize(sbX.value(), sbY.value())
            w.setMapSize(s)
        sbY.valueChanged.connect(onMapSizeChanged)
        sbX.valueChanged.connect(onMapSizeChanged)

        g.addWidget(scroll, 0, 0, 1, 2)
        g.addWidget(QLabel('n dates'), 1, 0)
        g.addWidget(sb, 1,1)
        g.addWidget(btnAMV,2,0)
        g.addWidget(btnRMV,2,1)

        g.addWidget(QLabel('Map Size'), 3,0)
        g.addWidget(sbX, 3,1)
        g.addWidget(sbY, 3, 2)
        controllW.show()



        mv1 = MapView(name='mv1')
        mv2 = MapView(name='mv2')
        mv3 = MapView(name='mv3')
        w.addMapView(mv1)

        if False:
            w.addMapView(mv2)

            self.assertEqual(w.mGrid.rowCount(), 2)
            w.addMapView(mv1)
            self.assertEqual(w.mGrid.rowCount(), 2)
            w.addMapView(mv3)
            self.assertEqual(w.mGrid.rowCount(), 3)
        #w.removeMapView(mv2)
        #self.assertEqual(w.mGrid.rowCount(), 2)
        #self.assertListEqual(w.mMapViews, [mv1, mv3])


        w.setTimeSeries(TS)
        w.setCurrentDate(TS[0])

        for c in w.mapCanvases():
            self.assertIsInstance(c, MapCanvas)
            c.mInfoItem.mUCText = '{}:{}'.format(c.tsd().date(), c.mapView().title())
            c.update()

        if SHOW_GUI:
            QGIS_APP.exec_()

    def test_mapview(self):

        TS = TestObjects.createTimeSeries()
        lyr = TestObjects.createVectorLayer()
        lyr.setName('Layer1 Name')
        lyr.setTitle('Layer1 title')
        lyr2 = TestObjects.createVectorLayer()
        lyr2.setName('Layer2 name')

        mapview = MapView()

        self.assertEqual([], mapview.sensors())

        for sensor in TS.sensors():
            self.assertIsInstance(sensor, SensorInstrument)
            mapview.addSensor(sensor)
        mapview.addLayer(lyr)
        mapview.addLayer(lyr2)
        self.assertEqual(TS.sensors(), mapview.sensors())

        from eotimeseriesviewer.mapcanvas import MapCanvas
        canvas = MapCanvas()
        tsd = TS[0]
        canvas.setTSD(tsd)
        mapview.registerMapCanvas(canvas)

        self.assertTrue(canvas in mapview.mapCanvases())
        canvas.show()
        self.assertEqual([], canvas.layers())
        canvas.timedRefresh()
        self.assertNotEqual([], canvas.layers())
        l = canvas.layers()[-1]
        canvas.setCrs(l.crs())
        canvas.setExtent(l.extent())

        if SHOW_GUI:
            w = QWidget()
            w.setLayout(QHBoxLayout())
            w.layout().addWidget(mapview)
            w.layout().addWidget(canvas)
            w.show()

            timer = QTimer()
            timer.timeout.connect(canvas.timedRefresh)
            timer.setInterval(500)
            timer.start()
            QGIS_APP.exec_()

    def test_mapViewDock(self):

        TS = TestObjects.createTimeSeries()

        dock = MapViewDock()
        self.assertIsInstance(dock, MapViewDock)
        dock.setTimeSeries(TS)
        mapView = dock.createMapView()
        self.assertIsInstance(mapView, MapView)
        mapView.setTimeSeries(TS)
        canvas = MapCanvas()
        canvas.setTSD(TS[0])
        tss = TS[0][0]
        self.assertIsInstance(tss, TimeSeriesSource)
        canvas.setCrs(tss.crs())
        canvas.setSpatialExtent(tss.spatialExtent())


        if SHOW_GUI:
            dock.show()
            canvas.show()

            timer = QTimer()
            timer.timeout.connect(canvas.timedRefresh)
            timer.setInterval(500)
            timer.start()

            QGIS_APP.exec_()



    def test_mapcanvas(self):

        files = testRasterFiles()

        lyr1 = QgsRasterLayer(files[0])


        m = MapCanvas()
        m.setLayers([])
        self.assertIsInstance(m, MapCanvas)
        m.show()


    def test_virtualLayers(self):

        lyr = TestObjects.createVectorLayer()
        self.assertIsInstance(lyr, QgsVectorLayer)
        VL = QgsVirtualLayerDefinition()
        s = ""
        self.assertTrue(1==1)


    def test_bandselection(self):

        lyr = QgsRasterLayer(Img_2014_05_07_LC82270652014127LGN00_BOA)

        wl, wlu = parseWavelength(lyr)
        self.assertIsInstance(wl, np.ndarray)
        self.assertIsInstance(wlu, str)
        self.assertEqual(wlu, 'um')
        refWL = [0.49,  0.56,  0.66,  0.84,  1.65,  2.2]

        self.assertEqual(len(wl), len(refWL))
        for wla, wlb in zip(wl, refWL):
            self.assertAlmostEqual(wla, wlb)

        self.assertEqual(0, bandClosestToWavelength(lyr, 'B'))
        s = ""

    def test_renderer(self):

        styleFiles = file_search(os.path.dirname(__file__), 'style*.txt')

        lyr = QgsRasterLayer(Img_2014_05_07_LC82270652014127LGN00_BOA)

        r0 = lyr.renderer()
        from eotimeseriesviewer.externals.qps.layerproperties import rendererFromXml, rendererToXml
        xml0 = rendererToXml(r0)
        r0b = rendererFromXml(xml0)
        self.assertTrue(type(r0), type(r0b))



        rasterRenderer = [QgsMultiBandColorRenderer(r0, 3,2,1, QgsContrastEnhancement(), QgsContrastEnhancement(), QgsContrastEnhancement()),
                          QgsPalettedRasterRenderer(r0,0, [
                              QgsPalettedRasterRenderer.Class(0, QColor('black'), 'class1'),
                              QgsPalettedRasterRenderer.Class(1, QColor('green'), 'class2'),
                          ] ),
                          QgsHillshadeRenderer(r0, 0, 0.0, 100.0),
                          QgsSingleBandPseudoColorRenderer(r0, 0, QgsRasterShader(0.0, 255.0)),
                          QgsSingleBandColorDataRenderer(r0, 0),
                          QgsSingleBandGrayRenderer(r0, 0)]

        vectorRenderer = []#[QgsSingleSymbolRenderer(QgsLineSymbol()), QgsPointDistanceRenderer()]

        for r1 in rasterRenderer + vectorRenderer:
            print('Test {}'.format(r1.__class__.__name__))
            xml1 = rendererToXml(r1)
            self.assertIsInstance(xml1, QDomDocument)


            r1b = rendererFromXml(xml1)
            self.assertTrue(type(r1), type(r1b))

            if isinstance(r1, QgsRasterRenderer):
                self.assertIsInstance(r1b, QgsRasterRenderer)
            elif isinstance(r1, QgsFeatureRenderer):
                self.assertIsInstance(r1b, QgsFeatureRenderer)

            xml2 = rendererToXml(r1b)
            self.assertIsInstance(xml2, QDomDocument)
            self.assertTrue(xml1.toString() == xml2.toString())


            rClone = r1.clone()
            self.assertTrue(type(r1), type(rClone))
            xmlClone =  rendererToXml(rClone)
            self.assertIsInstance(xmlClone, QDomDocument)

            similar = compareXML(xml1.firstChild(), xml2.firstChild())
            self.assertTrue(similar)






        for path in styleFiles:
            with open(path, encoding='utf8') as f:
                xml = ''.join(f.readlines())


                renderer = rendererFromXml(xml)
                self.assertTrue(renderer != None)

        s  =""




    def test_spatialTemporalVisualization(self):
        from eotimeseriesviewer.main import TimeSeriesViewer

        TSV = TimeSeriesViewer()
        TSV.loadExampleTimeSeries()
        TSV.show()

        SV = TSV.spatialTemporalVis
        self.assertIsInstance(SV, SpatialTemporalVisualization)
        QApplication.processEvents()
        # TSV.createMapView()

        import time
        time.sleep(5)

        SV.timedCanvasRefresh()


        visibleCanvases = []
        withLayers = []
        empty = []
        extent = None
        for mapCanvas in SV.mapCanvases():
            self.assertIsInstance(mapCanvas, MapCanvas)
            self.assertIsInstance(mapCanvas.spatialExtent(), SpatialExtent)

            if extent is None:
                extent = mapCanvas.spatialExtent()
            else:
                self.assertTrue(mapCanvas.spatialExtent() == extent)

            if len(mapCanvas.layers()) == 0:
                empty.append(mapCanvas)
            else:
                withLayers.append(mapCanvas)

        if True:
            QGIS_APP.exec_()

        self.assertTrue(len(withLayers) > 0)
        self.assertTrue(len(empty) > 0)

        # shift spatial extent
        extent2 = extent.setCenter(SpatialPoint(extent.crs(), extent.center().x()-100, extent.center().y()))
        SV.setSpatialExtent(extent2)
        SV.timedCanvasRefresh()
        for mapCanvas in SV.mapCanvases():
            self.assertIsInstance(mapCanvas, MapCanvas)
            if mapCanvas.isVisibleToViewport():
                self.assertTrue(mapCanvas.spatialExtent() == extent2)


        # shift spatial extent of single map canvas
        extent3 = extent.setCenter(SpatialPoint(extent.crs(), extent.center().x() + 100, extent.center().y()))
        canvas = SV.mapCanvases()[0]
        self.assertIsInstance(canvas, MapCanvas)
        canvas.setSpatialExtent(extent3)
        SV.timedCanvasRefresh()
        for mapCanvas in SV.mapCanvases():
            if mapCanvas.isVisibleToViewport():
                self.assertTrue(mapCanvas.spatialExtent() == extent3)

        # test map render changes
        for canvas in SV.mapCanvases():
            self.assertIsInstance(canvas, MapCanvas)
            menu = canvas.contextMenu()
            self.assertIsInstance(menu, QMenu)
            if canvas.isVisibleToViewport():

                for action in menu.findChildren(QAction):
                    self.assertIsInstance(action, QAction)
                    text = action.text()
                    if text in ['', 'Style', 'PNG', 'JPEG']:
                        # skip menu / blocking dialog options
                        continue
                    else:
                        print('Test QAction "{}"'.format(action.text()))
                        action.trigger()
                break
        s = ""



if __name__ == "__main__":
    unittest.main()
    print('Done')

TC = testclassMapVisualization()
TC.test_mapWidget()
QGIS_APP.quit()
exit(0)