pygmi 2.2.7__zip

pygmi-2.2.7/pygmi/pfmod/menu.py

@@ -0,0 +1,107 @@
+# -----------------------------------------------------------------------------
+# Name:        menu.py (part of PyGMI)
+#
+# Author:      Patrick Cole
+# E-Mail:      pcole@geoscience.org.za
+#
+# Copyright:   (c) 2013 Council for Geoscience
+# Licence:     GPL-3.0
+#
+# This file is part of PyGMI
+#
+# PyGMI 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 3 of the License, or
+# (at your option) any later version.
+#
+# PyGMI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# -----------------------------------------------------------------------------
+""" Potential Field Modelling """
+
+from PyQt4 import QtGui
+from . import pfmod
+from . import cubes as mvis3d
+from . import iodefs
+
+
+class MenuWidget(object):
+    """
+    Widget class to call the main interface
+
+    This widget class creates the modelling menus to be found on the main
+    interface. Normal as well as context menus are defined here.
+
+    Attributes
+    ----------
+    parent : MainWidget
+        Reference to MainWidget class found in main.py
+    """
+    def __init__(self, parent):
+
+        self.parent = parent
+        self.parent.add_to_context('Model3D')
+        context_menu = self.parent.context_menu
+
+# Normal menus
+        self.menu = QtGui.QMenu(parent.menubar)
+        self.menu.setTitle("Potential Field Modelling")
+        parent.menubar.addAction(self.menu.menuAction())
+
+        self.action_import_mod3d = QtGui.QAction(parent)
+        self.action_import_mod3d.setText("Import 3D Model")
+        self.menu.addAction(self.action_import_mod3d)
+        self.action_import_mod3d.triggered.connect(self.import_mod3d)
+
+        self.action_prof_pic = QtGui.QAction(parent)
+        self.action_prof_pic.setText("Import Profile Picture")
+        self.menu.addAction(self.action_prof_pic)
+        self.action_prof_pic.triggered.connect(self.import_prof_pic)
+
+        self.menu.addSeparator()
+
+        self.action_pfmod = QtGui.QAction(self.parent)
+        self.action_pfmod.setText("Model Creation and Editing")
+        self.menu.addAction(self.action_pfmod)
+        self.action_pfmod.triggered.connect(self.pfmod)
+
+# Context Menu
+        context_menu['Model3D'].addSeparator()
+
+        self.action_mod3d = QtGui.QAction(self.parent)
+        self.action_mod3d.setText("3D Model Display")
+        context_menu['Model3D'].addAction(self.action_mod3d)
+        self.action_mod3d.triggered.connect(self.mod3d)
+
+        self.action_export_mod3d = QtGui.QAction(self.parent)
+        self.action_export_mod3d.setText("Export 3D Model")
+        context_menu['Model3D'].addAction(self.action_export_mod3d)
+        self.action_export_mod3d.triggered.connect(self.export_mod3d)
+
+    def export_mod3d(self):
+        """ Export 3D Model """
+        self.parent.launch_context_item(iodefs.ExportMod3D)
+
+    def pfmod(self):
+        """ voxel modelling of data"""
+        fnc = pfmod.MainWidget(self.parent)
+        self.parent.item_insert("Step", "Potential\nField\nModelling", fnc)
+
+    def mod3d(self):
+        """ 3D display of data"""
+        self.parent.launch_context_item(mvis3d.Mod3dDisplay)
+
+    def import_mod3d(self):
+        """ Imports data"""
+        fnc = iodefs.ImportMod3D(self.parent)
+        self.parent.item_insert("Io", "Import 3D Model", fnc)
+
+    def import_prof_pic(self):
+        """ Imports data"""
+        fnc = iodefs.ImportPicture(self.parent)
+        self.parent.item_insert("Io", "Import Profile\n Picture", fnc)

pygmi-2.2.7/pygmi/pfmod/misc.py

@@ -0,0 +1,301 @@
+# -----------------------------------------------------------------------------
+# Name:        misc.py (part of PyGMI)
+#
+# Author:      Patrick Cole
+# E-Mail:      pcole@geoscience.org.za
+#
+# Copyright:   (c) 2013 Council for Geoscience
+# Licence:     GPL-3.0
+#
+# This file is part of PyGMI
+#
+# PyGMI 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 3 of the License, or
+# (at your option) any later version.
+#
+# PyGMI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# -----------------------------------------------------------------------------
+""" These are miscellaneous functions for the program """
+
+from PyQt4 import QtGui, QtCore
+import pygmi.menu_default as menu_default
+import time
+
+
+def update_lith_lw(lmod, lwidget):
+    """ Updates the lithology list widget """
+    lwidget.clear()
+    for i in lmod.lith_list.keys():
+        lwidget.addItem(i)
+
+    for i in range(lwidget.count()):
+        tmp = lwidget.item(i)
+        tindex = lmod.lith_list[str(tmp.text())].lith_index
+        tcol = lmod.mlut[tindex]
+        tmp.setBackground(QtGui.QColor(tcol[0], tcol[1], tcol[2], 255))
+
+
+class RangedCopy(QtGui.QDialog):
+    """ Class to call up a dialog for ranged copying """
+    def __init__(self, parent=None):
+        QtGui.QDialog.__init__(self, parent)
+
+        self.sb_master = QtGui.QSpinBox()
+        self.sb_start = QtGui.QSpinBox()
+        self.lw_lithdel = QtGui.QListWidget()
+        self.lw_lithcopy = QtGui.QListWidget()
+        self.sb_end = QtGui.QSpinBox()
+
+        self.setupui()
+
+    def setupui(self):
+        """ Setup UI """
+        gridlayout = QtGui.QGridLayout(self)
+        buttonbox = QtGui.QDialogButtonBox()
+        helpdocs = menu_default.HelpButton('pygmi.pfmod.misc.rangedcopy')
+
+        label = QtGui.QLabel()
+        label_2 = QtGui.QLabel()
+        label_3 = QtGui.QLabel()
+        label_4 = QtGui.QLabel()
+        label_5 = QtGui.QLabel()
+
+        self.sb_master.setMaximum(999999999)
+        self.sb_start.setMaximum(999999999)
+        self.lw_lithcopy.setSelectionMode(self.lw_lithcopy.MultiSelection)
+        self.lw_lithdel.setSelectionMode(self.lw_lithdel.MultiSelection)
+        buttonbox.setOrientation(QtCore.Qt.Horizontal)
+        buttonbox.setStandardButtons(buttonbox.Cancel | buttonbox.Ok)
+        self.sb_end.setMaximum(999999999)
+
+        self.setWindowTitle("Ranged Copy")
+        label.setText("Range Start")
+        label_2.setText("Master Profile")
+        label_3.setText("Lithologies To Copy")
+        label_4.setText("Lithologies To Overwrite")
+        label_5.setText("Range End")
+
+        gridlayout.addWidget(label_2, 0, 0, 1, 1)
+        gridlayout.addWidget(self.sb_master, 0, 1, 1, 1)
+        gridlayout.addWidget(label, 1, 0, 1, 1)
+        gridlayout.addWidget(self.sb_start, 1, 1, 1, 1)
+        gridlayout.addWidget(label_5, 2, 0, 1, 1)
+        gridlayout.addWidget(self.sb_end, 2, 1, 1, 1)
+        gridlayout.addWidget(label_3, 3, 0, 1, 1)
+        gridlayout.addWidget(self.lw_lithcopy, 3, 1, 1, 1)
+        gridlayout.addWidget(label_4, 4, 0, 1, 1)
+        gridlayout.addWidget(self.lw_lithdel, 4, 1, 1, 1)
+        gridlayout.addWidget(helpdocs, 5, 0, 1, 1)
+        gridlayout.addWidget(buttonbox, 5, 1, 1, 1)
+
+        buttonbox.accepted.connect(self.accept)
+        buttonbox.rejected.connect(self.reject)
+
+
+def rcopy_dialog(lmod1, islayer=True, is_ew=True):
+    """ Main routine to perform actual ranged copy """
+    rcopy = RangedCopy()
+    for i in lmod1.lith_list.keys():
+        rcopy.lw_lithcopy.addItem(i)
+        rcopy.lw_lithdel.addItem(i)
+
+    if islayer is True:
+        rmax = lmod1.numz-1
+    elif is_ew is True:
+        rmax = lmod1.numy-1
+    else:
+        rmax = lmod1.numx-1
+
+    rcopy.sb_start.setMaximum(rmax)
+    rcopy.sb_end.setMaximum(rmax)
+    rcopy.sb_end.setValue(rmax)
+
+    if islayer is True:
+        rcopy.sb_master.setValue(lmod1.curlayer)
+    else:
+        rcopy.sb_master.setValue(lmod1.curprof)
+
+    tmp = rcopy.exec_()
+    if tmp == 0:
+        return
+
+    lithcopy = rcopy.lw_lithcopy.selectedItems()
+    lithdel = rcopy.lw_lithdel.selectedItems()
+    lstart = rcopy.sb_start.value()
+    lend = rcopy.sb_end.value()
+    lmaster = rcopy.sb_master.value()
+
+    if lstart > lend:
+        lstart, lend = lend, lstart
+
+    if islayer is True:
+        mtmp = lmod1.lith_index[:, :, lmaster]
+        if lend > lmod1.numz:
+            lend = lmod1.numz
+    else:
+        if is_ew is True:
+            mtmp = lmod1.lith_index[:, lmaster, ::-1]
+            if lend > lmod1.numy:
+                lend = lmod1.numy
+        else:
+            mtmp = lmod1.lith_index[lmaster, :, ::-1]
+            if lend > lmod1.numx:
+                lend = lmod1.numx
+
+    mslice = mtmp * 0
+    for i in lithcopy:
+        mslice[mtmp == lmod1.lith_list[i.text()].lith_index] = 1
+
+    for i in range(lstart, lend+1):
+        if islayer is True:
+            ltmp = lmod1.lith_index[:, :, i]
+        else:
+            if is_ew is True:
+                ltmp = lmod1.lith_index[:, i, ::-1]
+            else:
+                ltmp = lmod1.lith_index[i, :, ::-1]
+
+        lslice = ltmp * 0
+        for j in lithdel:
+            lslice[ltmp == lmod1.lith_list[j.text()].lith_index] = 1
+        mlslice = mslice + lslice
+        mlslice[mlslice == 1] = 0
+        mlslice[mlslice > 0] = 1
+        mtmp2 = mtmp.copy()
+        mtmp2[mlslice == 0] = 0
+        ltmp[mlslice == 1] = 0
+        ltmp += mtmp2
+
+
+class ProgressBar(object):
+    """ Wrapper for a progress bar """
+    def __init__(self, pbar, pbarmain):
+        self.pbar = pbar
+        self.pbarmain = pbarmain
+        self.max = 1
+        self.value = 0
+        self.mmax = 1
+        self.mvalue = 0
+        self.otime = None
+        self.mtime = None
+        self.resetall()
+
+    def incr(self):
+        """ increases value by one """
+        if self.value < self.max:
+            self.value += 1
+            if self.value == self.max and self.mvalue < self.mmax:
+                self.mvalue += 1
+                self.value = 0
+                self.pbarmain.setValue(self.mvalue)
+            if self.mvalue == self.mmax:
+                self.value = self.max
+            self.pbar.setValue(self.value)
+
+        QtCore.QCoreApplication.processEvents()
+
+    def iter(self, iterable):
+        """
+        Iterator Routine
+        """
+        total = len(iterable)
+        self.max = total
+        self.pbar.setMaximum(total)
+        self.pbar.setMinimum(0)
+        self.pbar.setValue(0)
+
+        self.otime = time.clock()
+        time1 = self.otime
+        time2 = self.otime
+
+        n = 0
+        for obj in iterable:
+            yield obj
+            n += 1
+
+            time2 = time.clock()
+            if time2-time1 > 1:
+                self.pbar.setValue(n)
+                tleft = (total-n)*(time2-self.otime)/n
+                if tleft > 60:
+                    tleft = int(tleft // 60)
+                    self.pbar.setFormat('%p% '+str(tleft)+'min left')
+                else:
+                    tleft = int(tleft)
+                    self.pbar.setFormat('%p% '+str(tleft)+'s left')
+                QtGui.QApplication.processEvents()
+                time1 = time2
+
+        self.pbar.setFormat('%p%')
+        self.pbar.setValue(total)
+
+        self.incrmain()
+        self.value = 0
+        QtGui.QApplication.processEvents()
+
+    def incrmain(self, i=1):
+        """ increases value by one """
+        self.mvalue += i
+        self.pbarmain.setValue(self.mvalue)
+
+        n = self.mvalue
+        total = self.mmax
+        tleft = (total-n)*(time.clock()-self.mtime)/n
+        if tleft > 60:
+            tleft = int(tleft // 60)
+            self.pbarmain.setFormat('%p% '+str(tleft)+'min left')
+        else:
+            tleft = int(tleft)
+            self.pbarmain.setFormat('%p% '+str(tleft)+'s left')
+        QtGui.QApplication.processEvents()
+
+    def maxall(self):
+        """ Sets all progress bars to maximum value """
+        self.mvalue = self.mmax
+        self.value = self.max
+        self.pbarmain.setValue(self.mvalue)
+        self.pbar.setValue(self.value)
+        self.pbar.setFormat('%p%')
+        self.pbarmain.setFormat('%p%')
+
+    def resetall(self, maximum=1, mmax=1):
+        """ Sets min and max and resets all bars to 0 """
+
+        self.pbar.setFormat('%p%')
+        self.pbarmain.setFormat('%p%')
+        self.mtime = time.clock()
+
+        self.max = maximum
+        self.value = 0
+        self.mmax = mmax
+        self.mvalue = 0
+        self.pbar.setMinimum(self.value)
+        self.pbar.setMaximum(self.max)
+        self.pbar.setValue(self.value)
+        self.pbarmain.setMinimum(self.mvalue)
+        self.pbarmain.setMaximum(self.mmax)
+        self.pbarmain.setValue(self.mvalue)
+
+    def resetsub(self, maximum=1):
+        """ Sets min and max and resets sub bar to 0 """
+
+        self.pbar.setFormat('%p%')
+        self.max = maximum
+        self.value = 0
+        self.pbar.setMinimum(self.value)
+        self.pbar.setMaximum(self.max)
+        self.pbar.setValue(self.value)
+
+    def busysub(self):
+        """ Busy """
+        self.pbar.setMinimum(0)
+        self.pbar.setMaximum(0)
+        self.pbar.setValue(-1)
+        QtCore.QCoreApplication.processEvents()

pygmi-2.2.7/pygmi/pfmod/pfmod.py

@@ -0,0 +1,248 @@
+# -----------------------------------------------------------------------------
+# Name:        pfmod.py (part of PyGMI)
+#
+# Author:      Patrick Cole
+# E-Mail:      pcole@geoscience.org.za
+#
+# Copyright:   (c) 2013 Council for Geoscience
+# Licence:     GPL-3.0
+#
+# This file is part of PyGMI
+#
+# PyGMI 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 3 of the License, or
+# (at your option) any later version.
+#
+# PyGMI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# -----------------------------------------------------------------------------
+""" This is the main program for the modelling package """
+
+from PyQt4 import QtGui, QtCore
+
+# Other dependancies
+from . import misc
+from . import tab_ddisp
+from . import tab_layer
+from . import tab_prof
+from . import tab_pview
+from . import tab_param
+from . import tab_mext
+from . import grvmag3d
+from . import iodefs
+from .datatypes import LithModel
+import pygmi.menu_default as menu_default
+import pygmi.misc as pmisc
+
+
+class MainWidget(QtGui.QMainWindow):
+    """ Widget class to call the main interface """
+    def __init__(self, parent=None):
+        QtGui.QMainWindow.__init__(self, parent)
+
+        self.indata = {}
+        self.inraster = {}
+        self.outdata = {}
+        self.parent = parent
+        self.showprocesslog = self.parent.showprocesslog
+        self.lmod1 = LithModel()  # actual model
+        self.lmod2 = LithModel()  # regional model
+
+# General
+        self.txtmsg = ''
+        self.modelfilename = r'./tmp'
+
+        self.toolbar = QtGui.QToolBar()
+        self.statusbar = QtGui.QStatusBar()
+        self.tabwidget = QtGui.QTabWidget()
+        self.pbar_sub = pmisc.ProgressBar()
+        self.pbar_main = pmisc.ProgressBar()
+        self.textbrowser = QtGui.QTextBrowser()
+        self.actionsave = QtGui.QPushButton()
+
+        self.tabwidget.setCurrentIndex(0)
+        self.oldtab = self.tabwidget.tabText(0)
+        self.pbars = misc.ProgressBar(self.pbar_sub, self.pbar_main)
+        self.outdata['Raster'] = list(self.lmod1.griddata.values())
+
+# Model Extent Tab
+        self.mext = tab_mext.MextDisplay(self)
+        self.tabwidget.addTab(self.mext.userint, "Model Extent Parameters")
+
+# Geophysical Parameters Tab
+        self.param = tab_param.ParamDisplay(self)
+        self.tabwidget.addTab(self.param.userint, "Geophysical Parameters")
+
+# Data Display Tab
+        self.ddisp = tab_ddisp.DataDisplay(self)
+        self.tabwidget.addTab(self.ddisp.userint, "Data Display")
+
+# Layer Editor Tab
+        self.layer = tab_layer.LayerDisplay(self)
+        self.tabwidget.addTab(self.layer.userint, "Layer Editor")
+
+# Profile Editor Tab
+        self.profile = tab_prof.ProfileDisplay(self)
+        self.tabwidget.addTab(self.profile.userint, "Profile Editor")
+
+# Profile Viewer Tab
+        self.pview = tab_pview.ProfileDisplay(self)
+        self.tabwidget.addTab(self.pview.userint, "Custom Profile Editor")
+
+# Gravity and magnetic modelling routines
+        self.grvmag = grvmag3d.GravMag(self)
+
+        self.setupui()
+
+    def setupui(self):
+        """ Setup for the GUI """
+        centralwidget = QtGui.QWidget(self)
+        verticallayout = QtGui.QVBoxLayout(centralwidget)
+        hlayout = QtGui.QHBoxLayout()
+
+        helpdocs = menu_default.HelpButton()
+
+        self.setCentralWidget(centralwidget)
+        self.resize(1024, 768)
+        self.toolbar.setStyleSheet('QToolBar{spacing:10px;}')
+        self.setStatusBar(self.statusbar)
+        self.addToolBar(QtCore.Qt.TopToolBarArea, self.toolbar)
+        self.textbrowser.setFrameShape(QtGui.QFrame.StyledPanel)
+#        self.pbar_sub.setTextVisible(False)
+#        self.pbar_main.setTextVisible(False)
+        self.toolbar.setMovable(True)
+        self.toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
+        self.toolbar.addWidget(self.actionsave)
+
+        self.setWindowTitle("Potential Field Modelling")
+        self.actionsave.setText("Save Model")
+
+        hlayout.addWidget(self.textbrowser)
+        hlayout.addWidget(helpdocs)
+        verticallayout.addWidget(self.tabwidget)
+        verticallayout.addLayout(hlayout)
+        verticallayout.addWidget(self.pbar_sub)
+        verticallayout.addWidget(self.pbar_main)
+
+        helpdocs.clicked.disconnect()
+        helpdocs.clicked.connect(self.help_docs)
+        self.actionsave.clicked.connect(self.savemodel)
+        self.tabwidget.currentChanged.connect(self.tab_change)
+
+    def savemodel(self):
+        """ Model Save """
+        tmp = iodefs.ExportMod3D(self)
+        tmp.indata = self.outdata
+        tmp.run()
+
+        del tmp
+
+    def help_docs(self):
+        """
+        Help Routine
+        """
+        index = self.tabwidget.currentIndex()
+        htmlfile = ''
+
+        if self.tabwidget.tabText(index) == 'Geophysical Parameters':
+            htmlfile += 'pygmi.pfmod.param'
+
+        if self.tabwidget.tabText(index) == 'Model Extent Parameters':
+            htmlfile += 'pygmi.pfmod.mext'
+
+        if self.tabwidget.tabText(index) == 'Profile Editor':
+            htmlfile += 'pygmi.pfmod.prof'
+
+        if self.tabwidget.tabText(index) == 'Custom Profile Editor':
+            htmlfile += 'pygmi.pfmod.pview'
+
+        if self.tabwidget.tabText(index) == 'Layer Editor':
+            htmlfile += 'pygmi.pfmod.layer'
+
+        if self.tabwidget.tabText(index) == 'Data Display':
+            htmlfile += 'pygmi.pfmod.ddisp'
+
+        menu_default.HelpDocs(self, htmlfile)
+
+    def settings(self):
+        """ Settings """
+        if 'Raster' not in self.indata:
+            self.indata['Raster'] = list(self.lmod1.griddata.values())
+
+        for i in self.indata['Raster']:
+            self.inraster[i.dataid] = i
+        if 'Model3D' in self.indata.keys():
+            self.lmod1 = self.indata['Model3D'][0]
+#            self.lmod1.init_calc_grids()
+            self.lmod2 = self.indata['Model3D'][-1]
+#            self.lmod2.init_calc_grids()
+
+        self.outdata['Model3D'] = [self.lmod1]
+        self.mext.update_combos()
+        self.mext.tab_activate()
+        self.outdata['Raster'] = list(self.lmod1.griddata.values())
+
+        if 'ProfPic' in self.indata:
+            icnt = 0
+            for i in self.indata['ProfPic']:
+                icnt += 1
+                self.lmod1.profpics['Profile: '+str(icnt)] = i
+
+        self.show()
+
+        return True
+
+    def showtext(self, txt, replacelast=False):
+        """ Show text on the text panel of the main user interface"""
+        if replacelast is True:
+            self.txtmsg = self.txtmsg[:self.txtmsg.rfind('\n')]
+            self.txtmsg = self.txtmsg[:self.txtmsg.rfind('\n')]
+            self.txtmsg += '\n'
+        self.txtmsg += txt + '\n'
+        self.textbrowser.setPlainText(self.txtmsg)
+        tmp = self.textbrowser.verticalScrollBar()
+        tmp.setValue(tmp.maximumHeight())
+        self.repaint()
+
+    def tab_change(self, index=None):
+        """ This gets called any time we change a tab, and activates the
+        routines behind the new tab """
+
+        index = self.tabwidget.currentIndex()
+        self.profile.change_defs()
+        self.layer.change_defs()
+
+        if self.oldtab == 'Layer Editor':
+            self.layer.update_model()
+
+        if self.oldtab == 'Profile Editor':
+            self.profile.update_model()
+
+        if self.oldtab == 'Custom Profile Editor':
+            self.pview.update_model()
+
+        if self.tabwidget.tabText(index) == 'Geophysical Parameters':
+            self.param.tab_activate()
+
+        if self.tabwidget.tabText(index) == 'Model Extent Parameters':
+            self.mext.tab_activate()
+
+        if self.tabwidget.tabText(index) == 'Profile Editor':
+            self.profile.tab_activate()
+
+        if self.tabwidget.tabText(index) == 'Custom Profile Editor':
+            self.pview.tab_activate()
+
+        if self.tabwidget.tabText(index) == 'Layer Editor':
+            self.layer.tab_activate()
+
+        if self.tabwidget.tabText(index) == 'Data Display':
+            self.ddisp.tab_activate()
+
+        self.oldtab = self.tabwidget.tabText(index)