Geografic-Information-System/gui/wxpython/gui_modules/wxvdriver.py

"""!
@package wxvdriver.py

@brief wxGUI vector digitizer (display driver)

Code based on wxVdigit C++ component from GRASS 6.4.0
(gui/wxpython/vdigit). Converted to Python in 2010/12-2011/01.

List of classes:
 - DisplayDriver

(C) 2007-2011 by the GRASS Development Team

This program is free software under the GNU General Public License
(>=v2). Read the file COPYING that comes with GRASS for details.

@author Martin Landa <landa.martin gmail.com>
"""

import math

import wx

from debug import Debug
from preferences import globalSettings as UserSettings

from grass.lib.grass  import *
from grass.lib.vector import *
from grass.lib.vedit  import *

log      = None
progress = None

def print_error(msg, type):
    """!Redirect stderr"""
    global log
    if log:
        log.write(msg)
    else:
        print msg
    
    return 0

def print_progress(value):
    """!Redirect progress info"""
    global progress
    if progress:
        progress.SetValue(value)
    else:
        print value
    
    return 0

errtype = CFUNCTYPE(UNCHECKED(c_int), String, c_int)
errfunc = errtype(print_error)
pertype = CFUNCTYPE(UNCHECKED(c_int), c_int)
perfunc = pertype(print_progress)

class DisplayDriver:
    def __init__(self, device, deviceTmp, mapObj, window, glog, gprogress):
        """Display driver used by vector digitizer
        
        @param device    wx.PseudoDC device where to draw vector objects
        @param deviceTmp wx.PseudoDC device where to draw temporary vector objects
        @param mapOng    Map Object (render.Map)
        @param windiow   parent window for dialogs
        @param glog      logging device (None to discard messages)
        @param gprogress progress bar device (None to discard message)
        """
        global errfunc, perfunc, log, progress
        log = glog
        progress = gprogress
        
        G_gisinit('')             # initialize GRASS libs
        G_set_error_routine(errfunc) 
        G_set_percent_routine(perfunc)
        
        self.mapInfo   = None     # open vector map (Map_Info structure)
        self.poMapInfo = None     # pointer to self.mapInfo
        self.is3D      = False    # is open vector map 3D
        
        self.dc      = device     # PseudoDC devices
        self.dcTmp   = deviceTmp
        self.mapObj  = mapObj
        self.region  = mapObj.GetCurrentRegion()
        self.window  = window
        self.log     = log        # log device

        # GRASS lib
        self.poPoints = Vect_new_line_struct()
        self.poCats   = Vect_new_cats_struct()
        
        # selected objects
        self.selected = {
            'field'   : -1,      # field number
            'cats'    : list(),  # list of cats
            'ids'     : list(),  # list of ids
            'idsDupl' : list(),  # list of duplicated features
            }
        
        # digitizer settings
        self.settings = {
            'highlight'     : None,
            'highlightDupl' : { 'enabled' : False,
                                'color'   : None },
            'point'         : { 'enabled' : False,
                                'color'   : None },
            'line'          : { 'enabled' : False,
                                'color'   : None },
            'boundaryNo'    : { 'enabled' : False,
                                'color'   : None },
            'boundaryOne'   : { 'enabled' : False,
                                'color'   : None },
            'boundaryTwo'   : { 'enabled' : False,
                                'color'   : None },
            'centroidIn'    : { 'enabled' : False,
                                'color'   : None },
            'centroidOut'   : { 'enabled' : False,
                                'color'   : None },
            'centroidDup'   : { 'enabled' : False,
                                'color'   : None },
            'nodeOne'       : { 'enabled' : False,
                                'color'   : None },
            'nodeTwo'       : { 'enabled' : False,
                                'color'   : None },
            'vertex'        : { 'enabled' : False,
                                'color'   : None },
            'area'          : { 'enabled' : False,
                                'color'   : None },
            'direction'     : { 'enabled' : False,
                                'color'   : None },
            'lineWidth'     : -1,    # screen units 
            }
        
        # topology
        self._resetTopology()
        
        self.drawSelected = False
        self.drawSegments = False
        
        self.UpdateSettings()
        
        Vect_set_fatal_error(GV_FATAL_PRINT)
        
    def __del__(self):
        """!Close currently open vector map"""
        G_unset_error_routine()
        G_unset_percent_routine()
        
        if self.poMapInfo:
            self.CloseMap()
        
        Vect_destroy_line_struct(self.poPoints)
        Vect_destroy_cats_struct(self.poCats)

    def _resetTopology(self):
        """!Reset topology dict
        """
        self.topology = {
            'highlight'   : 0,
            'point'       : 0,
            'line'        : 0,
            'boundaryNo'  : 0,
            'boundaryOne' : 0,
            'boundaryTwo' : 0,
            'centroidIn'  : 0,
            'centroidOut' : 0,
            'centroidDup' : 0,
            'nodeOne'     : 0,
            'nodeTwo'     : 0,
            'vertex'      : 0,
            }
        
    def _cell2Pixel(self, east, north, elev):
        """!Conversion from geographic coordinates (east, north)
        to screen (x, y)
  
        @todo 3D stuff...

        @param east, north, elev geographical coordinates

        @return x, y screen coordinates (integer)
        """
        map_res = max(self.region['ewres'], self.region['nsres'])
        w = self.region['center_easting']  - (self.mapObj.width  / 2) * map_res
        n = self.region['center_northing'] + (self.mapObj.height / 2) * map_res
        
        return int((east - w) / map_res), int((n - north) / map_res)
    
    def _drawCross(self, pdc, point, size = 5):
        """!Draw cross symbol of given size to device content
   
        Used for points, nodes, vertices

        @param[in,out] PseudoDC where to draw
        @param point coordinates of center
        @param size size of the cross symbol
   
        @return 0 on success
        @return -1 on failure
        """
        if not pdc or not point:
            return -1
        
        pdc.DrawLine(point.x - size, point.y, point.x + size, point.y)
        pdc.DrawLine(point.x, point.y - size, point.x, point.y + size)
        
        return 0
    
    def _drawObject(self, robj):
        """!Draw given object to the device
        
        The object is defined as robject() from vedit.h.
        
        @param robj object to be rendered
        
        @return  1 on success
        @return -1 on failure (vector feature marked as dead, etc.)
        """
        if not self.dc or not self.dcTmp:
            return -1
        
        Debug.msg(3, "_drawObject(): type=%d npoints=%d", robj.type, robj.npoints)
        brush = None
        if self._isSelected(robj.fid):
            pdc = self.dcTmp
            if self.settings['highlightDupl']['enabled'] and self._isDuplicated(robj.fid):
                pen = wx.Pen(self.settings['highlightDupl'], self.settings['lineWidth'], wx.SOLID)
            else:            
                pen = wx.Pen(self.settings['highlight'], self.settings['lineWidth'], wx.SOLID)
            
            dcId = 1
            self.topology['highlight'] += 1
            if not self.drawSelected:
                return
        else:
            pdc = self.dc
            pen, brush = self._definePen(robj.type)
            dcId = 0
        
        pdc.SetPen(pen)        
        if brush:
            pdc.SetBrush(brush)
        
        if robj.type & (TYPE_POINT | TYPE_CENTROIDIN | TYPE_CENTROIDOUT | TYPE_CENTROIDDUP |
                        TYPE_NODEONE | TYPE_NODETWO | TYPE_VERTEX): # -> point
            for i in range(robj.npoints):
                p = robj.point[i]
                self._drawCross(pdc, p)
        else:
            if dcId > 0 and self.drawSegments:
                dcId = 2 # first segment
                i = 0
                while i < robj.npoints - 1:
                    point_beg = wx.Point(robj.point[i].x, robj.point[i].y)
                    point_end = wx.Point(robj.point[i+1].x, robj.point[i+1].y)
                    pdc.SetId(dcId) # set unique id & set bbox for each segment
                    pdc.SetPen(pen)
                    pdc.SetIdBounds(dcId - 1, wx.Rect(point_beg.x, point_beg.y, 0, 0))
                    pdc.SetIdBounds(dcId, wx.RectPP(point_beg, point_end))
                    pdc.DrawLine(point_beg.x, point_beg.y,
                                 point_end.x, point_end.y)
                    i    += 1
                    dcId += 2
                pdc.SetIdBounds(dcId - 1, wx.Rect(robj.point[robj.npoints - 1].x,
                                                  robj.point[robj.npoints - 1].y,
                                                  0, 0))
            else:
                points = list()
                for i in range(robj.npoints):
                    p = robj.point[i]
                    points.append(wx.Point(p.x, p.y))
                    
                if robj.type == TYPE_AREA:
                    pdc.DrawPolygon(points)
                else:
                    pdc.DrawLines(points)
        
    def _definePen(self, rtype):
        """!Define pen/brush based on rendered object)
        
        Updates also self.topology dict

        @return pen, brush
        """
        if rtype == TYPE_POINT:
            key = 'point'
        elif rtype == TYPE_LINE:
            key = 'line'
        elif rtype == TYPE_BOUNDARYNO:
            key = 'boundaryNo'
        elif rtype == TYPE_BOUNDARYTWO:
            key = 'boundaryTwo'
        elif rtype == TYPE_BOUNDARYONE:
            key = 'boundaryOne'
        elif rtype == TYPE_CENTROIDIN:
            key = 'centroidIn'
        elif rtype == TYPE_CENTROIDOUT:
            key = 'centroidOut'
        elif rtype == TYPE_CENTROIDDUP:
            key = 'centroidDup'
        elif rtype == TYPE_NODEONE:
            key = 'nodeOne'
        elif rtype == TYPE_NODETWO:
            key = 'nodeTwo'
        elif rtype == TYPE_VERTEX:
            key = 'vertex'
        elif rtype == TYPE_AREA:
            key = 'area' 
        elif rtype == TYPE_ISLE:
            key = 'isle'
        elif rtype == TYPE_DIRECTION:
            key = 'direction'
        
        if key not in ('direction', 'area', 'isle'):
            self.topology[key] += 1
        
        if key in ('area', 'isle'):
            pen = wx.TRANSPARENT_PEN
            if key == 'area':
                brush = wx.Brush(self.settings[key]['color'], wx.SOLID)
            else:
                brush = wx.TRANSPARENT_BRUSH
        else:
            pen = wx.Pen(self.settings[key]['color'], self.settings['lineWidth'], wx.SOLID)
            brush = None
        
        return pen, brush
        
    def _getDrawFlag(self):
        """!Get draw flag from the settings
        
        See vedit.h for list of draw flags.
        
        @return draw flag (int)
        """
        ret = 0
        if self.settings['point']['enabled']:
            ret |= DRAW_POINT
        if self.settings['line']['enabled']:
            ret |= DRAW_LINE
        if self.settings['boundaryNo']['enabled']:
            ret |= DRAW_BOUNDARYNO
        if self.settings['boundaryTwo']['enabled']:
            ret |= DRAW_BOUNDARYTWO
        if self.settings['boundaryOne']['enabled']:
            ret |= DRAW_BOUNDARYONE
        if self.settings['centroidIn']['enabled']:
            ret |= DRAW_CENTROIDIN
        if self.settings['centroidOut']['enabled']:
            ret |= DRAW_CENTROIDOUT
        if self.settings['centroidDup']['enabled']:
            ret |= DRAW_CENTROIDDUP
        if self.settings['nodeOne']['enabled']:
            ret |= DRAW_NODEONE
        if self.settings['nodeTwo']['enabled']:
            ret |= DRAW_NODETWO
        if self.settings['vertex']['enabled']:
            ret |= DRAW_VERTEX
        if self.settings['area']['enabled']:
            ret |= DRAW_AREA
        if self.settings['direction']['enabled']:
            ret |= DRAW_DIRECTION
        
        return ret
        
    def _printIds(self):
        pass

    def _isSelected(self, line, force = False):
        """!Check if vector object selected?
   
        @param line feature id

        @return True if vector object is selected
        @return False if vector object is not selected
        """
        if len(self.selected['cats']) < 1 or force:
            # select by id
            if line in self.selected['ids']:
                return True
        else: 
            # select by cat
            cats = self.poCats.contents
            for i in range(cats.n_cats):
                if cats.field[i] == self.selected['field'] and \
                        cats.cat[i] in self.selected['cats']:
                    # remember id
                    # -> after drawing all features selected.cats is reseted */
                    self.selected['ids'].append(line)
                    return True
        
        return False


    def _isDuplicated(self, featId):
        return False

    def _getRegionBox(self):
        """!Get bound_box() from current region

        @return bound_box
        """
        box = bound_box()
        
        box.N = self.region['n']
        box.S = self.region['s']
        box.E = self.region['e']
        box.W = self.region['w']
        box.T = PORT_DOUBLE_MAX
        box.B = -PORT_DOUBLE_MAX
        
        return box

    def DrawMap(self, force = False):
        """!Draw content of the vector map to the device
        
        @param force force drawing
        @return number of drawn features
        @return -1 on error
        """
        Debug.msg(1, "DisplayDriver.DrawMap(): force=%d", force)
        
        if not self.poMapInfo or not self.dc or not self.dcTmp:
            return -1
        
        rlist = Vedit_render_map(self.poMapInfo, byref(self._getRegionBox()), self._getDrawFlag(),
                                 self.region['center_easting'], self.region['center_northing'],
                                 self.mapObj.width, self.mapObj.height,
                                 max(self.region['nsres'], self.region['ewres'])).contents
        
        self._resetTopology()
        
        self.dc.BeginDrawing()
        self.dcTmp.BeginDrawing()
        
        # draw objects
        for i in range(rlist.nitems):
            robj = rlist.item[i].contents
            self._drawObject(robj)
        
        self.dc.EndDrawing()
        self.dcTmp.EndDrawing()
        
        # reset list of selected features by cat 
        # list of ids - see IsSelected()
        self.selected['field'] = -1
        self.selected['cats'] = list()
        
    def _getSelectType(self):
        """!Get type(s) to be selected

        Used by SelectLinesByBox() and SelectLinesByPoint()
        """
        ftype = 0
        for feature in (('point',    GV_POINT),
                        ('line',     GV_LINE),
                        ('centroid', GV_CENTROID),
                        ('boundary', GV_BOUNDARY)):
            if UserSettings.Get(group = 'vdigit', key = 'selectType',
                                subkey = [feature[0], 'enabled']):
                ftype |= feature[1]
        
        return ftype

    def SelectLinesByBox(self, bbox, drawSeg = False):
        """!Select vector objects by given bounding box
        
        If line id is already in the list of selected lines, then it will
        be excluded from this list.
        
        @param bbox bounding box definition
        @param drawSeg True to draw segments of line
        
        @return number of selected features
        @return -1 on error
        """
        if not self.poMapInfo:
            return -1
        
        self.drawSegments = drawSeg
        self.drawSelected = True
        
        # select by ids
        self.selected['cats'] = list()
        
        poList = Vect_new_list()
        poBbox = Vect_new_line_struct()
        x1, y1 = bbox[0]
        x2, y2 = bbox[1]
        Vect_append_point(poBbox, x1, y1, 0.0)
        Vect_append_point(poBbox, x2, y1, 0.0)
        Vect_append_point(poBbox, x2, y2, 0.0)
        Vect_append_point(poBbox, x1, y2, 0.0)
        Vect_append_point(poBbox, x1, y1, 0.0)
        
        Vect_select_lines_by_polygon(self.poMapInfo, poBbox,
                                     0, None, # isles
                                     self._getSelectType(), poList)
        
        flist = poList.contents
        nlines = flist.n_values
        for i in range(nlines):
            line = flist.value[i]
            if UserSettings.Get(group = 'vdigit', key = 'selectInside',
                                subkey = 'enabled'):
                inside = True
                Vect_read_line(self.poMapInfo, self.poPoints, None, line)
                points = poPoints.contents
                for p in range(points.n_points):
                    if not Vect_point_in_poly(points.x[p], points.y[p],
                                              byref(bbox)):
                        inside = False
                        break
                    
                if not inside:
                    continue # skip lines just overlapping bbox
        
            if not self._isSelected(line):
                self.selected['ids'].append(line)
            else:
                self.selected['ids'].remove(line)
        
        Vect_destroy_line_struct(poBbox)
        Vect_destroy_list(poList)
        
        return nlines

    def SelectLineByPoint(self, point):
        """!Select vector feature by given point in given
        threshold
   
        Only one vector object can be selected. Bounding boxes of
        all segments are stores.
        
        @param point points coordinates (x, y)
        
        @return point on line if line found
        """
        self.drawSelected = True
        
        poFound = Vect_new_list()
        # select by ids 
        self.selected['cats'] = list()
        
        line_nearest = Vect_find_line_list(self.poMapInfo, point[0], point[1], 0,
                                           self._getSelectType(), self.GetThreshold(), self.is3D,
                                           None, poFound)
        
        if line_nearest > 0:
            if not self._isSelected(line_nearest):
                self.selected['ids'].append(line_nearest)
            else:
                self.selected['ids'].remove(line_nearest)
        
        px = c_double()
        py = c_double()
        pz = c_double()
	ftype = Vect_read_line(self.poMapInfo, self.poPoints, self.poCats, line_nearest)
	Vect_line_distance (self.poPoints, point[0], point[1], 0.0, self.is3D,
			    byref(px), byref(py), byref(pz),
			    None, None, None)
        
	# check for duplicates 
	if self.settings['highlightDupl']['enabled']:
            found = poFound.contents
	    for i in range(found.n_values):
		line = found.value[i]
		if line != line_nearest:
                    self.selected['ids'].append(line)
	    
            self.getDuplicates()
	    
	    for i in range(found.n_values):
		line = found.value[i]
		if line != line_nearest and not self._isDuplicated(line):
                    self.selected['ids'].remove(line)
        
        Vect_destroy_list(poFound)
        
        # drawing segments can be very expensive
        # only one features selected
        self.drawSegments = True
        
        return (px.value, py.value, pz.value)
    
    def GetSelected(self, grassId = True):
        """!Get ids of selected objects
        
        @param grassId True for feature id, False for PseudoDC id
        
        @return list of ids of selected vector objects
        """
        if grassId:
            return self.selected['ids']
        
        dc_ids = list()
        
        if not self.drawSegments:
            dc_ids.append(1)
        elif len(self.selected['ids']) > 0:
            # only first selected feature
            Vect_read_line(self.poMapInfo, self.poPoints, None,
                           self.selected['ids'][0])
            points = self.poPoints.contents
            # node - segment - vertex - segment - node
            for i in range(1, 2 * points.n_points):
                dc_ids.append(i)
        
        return dc_ids
        
    def GetDuplicates(self):
        pass

    def GetRegionSelected(self):
        pass

    def SetSelected(self, ids, layer = -1):
        """!Set selected vector objects

        @param list of ids (None to unselect features)
        @param layer layer number for features selected based on category number
        """
        if ids:
            self.drawSelected = True
        else:
            self.drawSelected = False
        
        if layer > 0:
            selected.field = layer
            self.selected['cats'] = ids
        else:
            field = -1
            self.selected['ids'] = ids
    
    def GetSelectedVertex(self, pos):
        """Get PseudoDC vertex id of selected line

        Set bounding box for vertices of line.
        
        \param pos position
        
        \return id of center, left and right vertex
        \return 0 no line found
        \return -1 on error
        """
        returnId = list()
        # only one object can be selected
        if len(self.selected['ids']) != 1 or not self.drawSegments:
            return returnId
        
        startId = 1
        line = self.selected['ids'][0]
        
        ftype = Vect_read_line(self.poMapInfo, self.poPoints, self.poCats, line)
        
        minDist = 0.0
        Gid = -1
        # find the closest vertex (x, y)
        DCid = 1
        points = self.poPoints.contents
        for idx in range(points.n_points):
            dist = Vect_points_distance(pos[0], pos[1], 0.0,
                                        points.x[idx], points.y[idx], points.z[idx], 0)
            
            if idx == 0:
                minDist = dist
                Gid     = idx
            else:
                if minDist > dist:
                    minDist = dist
                    Gid = idx
            
            vx, vy = self._cell2Pixel(points.x[idx], points.y[idx], points.z[idx])
            rect = wx.Rect(vx, vy, 0, 0)
            self.dc.SetIdBounds(DCid, rect)
            DCid += 2
        
        if minDist > self.GetThreshold():
            return returnId
        
        # translate id
        DCid = Gid * 2 + 1
        
        # add selected vertex
        returnId.append(DCid)
        # left vertex
        if DCid == startId:
            returnId.append(-1)
        else:
            returnId.append(DCid - 2)
        # right vertex
        if DCid == (points.n_points - 1) * 2 + startId:
            returnId.append(-1)
        else:
            returnId.append(DCid + 2)
        
        return returnId

    def DrawSelected(self, flag):
        """!Draw selected features
        
        @param flag True to draw selected features
        """
        self.drawSelected = bool(flag)
        
    def CloseMap(self):
        """!Close vector map
        
        @return 0 on success
        @return non-zero on error
        """
        ret = 0
        if self.poMapInfo:
            # rebuild topology
            Vect_build_partial(self.poMapInfo, GV_BUILD_NONE)
            Vect_build(self.poMapInfo)

            # close map and store topo/cidx
            ret = Vect_close(self.poMapInfo)
            del self.mapInfo
            self.poMapInfo = self.mapInfo = None
        
        return ret
    
    def OpenMap(self, name, mapset, update = True):
        """!Open vector map by the driver
        
        @param name name of vector map to be open
        @param mapset name of mapset where the vector map lives
   
        @return map_info
        @return None on error
        """
        Debug.msg("DisplayDriver.OpenMap(): name=%s mapset=%s updated=%d",
                  name, mapset, update)
        if not self.mapInfo:
            self.mapInfo = Map_info()
            self.poMapInfo = pointer(self.mapInfo)
        
        # avoid GUI crash when G_fatal_error() is called (opening the vector map)
        Vect_set_fatal_error(GV_FATAL_PRINT)
        
        # open existing map
        if update:
            print >> sys.stderr, name, mapset
            ret = Vect_open_update(self.poMapInfo, name, mapset)
        else:
            ret = Vect_open_old(self.poMapInfo, name, mapset)
        self.is3D = Vect_is_3d(self.poMapInfo)
        
        if ret == -1: # error
            del self.mapInfo
            self.poMapInfo = self.mapInfo = None
        elif ret < 2:
            dlg = wx.MessageDialog(parent = self.window,
                                   message = _("Topology for vector map <%s> is not available. "
                                               "Topology is required by digitizer. Do you want to "
                                               "rebuild topology (takes some time) and open the vector map "
                                               "for editing?") % name,
                                   caption=_("Topology missing"),
                                   style = wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION | wx.CENTRE)
            ret = dlg.ShowModal()
            if ret != wx.ID_YES:
                del self.mapInfo
                self.poMapInfo = self.mapInfo = None
            else:
                Vect_build(self.poMapInfo)
        
        return self.poMapInfo
    
    def ReloadMap(self):
        pass

    def SetDevice(self):
        pass

    def GetMapBoundingBox(self):
        """!Get bounding box of (opened) vector map layer

        @return (w,s,b,e,n,t)
        """
        if not self.poMapInfo:
            return None
        
        bbox = bound_box()
        Vect_get_map_box(self.poMapInfo, byref(bbox))

        return bbox.W, bbox.S, bbox.B, \
            bbox.E, bbox.N, bbox.T
    
    def Is3D(self):
        pass

    def SetRegion(self):
        pass
    
    def UpdateSettings(self, alpha = 255):
        """!Update display driver settings

        @todo map units
        
        @alpha color value for aplha channel
        """
        color = dict()
        for key in self.settings.keys():
            if key == 'lineWidth':
                self.settings[key] = int(UserSettings.Get(group = 'vdigit', key = 'lineWidth',
                                                          subkey = 'value'))
                continue
            
            color = wx.Color(UserSettings.Get(group = 'vdigit', key = 'symbol',
                                              subkey = [key, 'color'])[0],
                             UserSettings.Get(group = 'vdigit', key = 'symbol',
                                              subkey = [key, 'color'])[1],
                             UserSettings.Get(group = 'vdigit', key = 'symbol',
                                              subkey = [key, 'color'])[2])
            
            if key == 'highlight':
                self.settings[key] = color
                continue
            
            if key == 'highlightDupl':
                self.settings[key]['enabled'] = bool(UserSettings.Get(group = 'vdigit', key = 'checkForDupl',
                                                                      subkey = 'enabled'))
            else:
                self.settings[key]['enabled'] = bool(UserSettings.Get(group = 'vdigit', key = 'symbol',
                                                                      subkey = [key, 'enabled']))
            
            self.settings[key]['color'] = color
        
    def UpdateRegion(self):
        """!Update geographical region used by display driver
        """
        self.region = self.mapObj.GetCurrentRegion()
        
    def GetSnapMode(self):
        """!Get snapping mode

        - snap to vertex
        - snap to nodes
        - no snapping
        
        @return snap mode
        """
        threshold = self.GetThreshold()
        if threshold > 0.0:
            if UserSettings.Get(group = 'vdigit', key = 'snapToVertex', subkey = 'enabled'):
                return SNAPVERTEX
            else:
                return SNAP
        else:
            return NO_SNAP
        
    def GetThreshold(self, type = 'snapping', value = None, units = None):
        """!Return threshold value in map units
        
        @param type snapping mode (node, vertex)
        @param value threshold to be set up
        @param units units (map, screen)

        @return threshold value
        """
        if value is None:
            value = UserSettings.Get(group = 'vdigit', key = type, subkey = 'value')
        
        if units is None:
            units = UserSettings.Get(group = 'vdigit', key = type, subkey = 'units')
        
        if value < 0:
            value = (self.region['nsres'] + self.region['ewres']) / 2.0
        
        if units == "screen pixels":
            # pixel -> cell
            res = max(self.region['nsres'], self.region['ewres'])
            return value * res
        
        return value