Thuban/Model/classification.py

# Copyright (c) 2001 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

__version__ = "$Revision$"

"""
A Classification provides a mapping from an input value
to data. This mapping can be specified in two ways. 
First, specific values can be associated with data. 
Second, ranges can be associated with data such that if 
an input value falls with a range that data is returned. 
If no mapping can be found then default data will 
be returned. Input values must be hashable objects

See the description of getProperties() for more information 
on the mapping algorithm.
"""
  
# fix for people using python2.1
from __future__ import nested_scopes

from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
     LAYER_VISIBILITY_CHANGED

from Thuban import _
from Thuban.Model.color import Color

from wxPython.wx import *

# constants
RANGE_MIN  = 0
RANGE_MAX  = 1
RANGE_DATA = 2

class Classification:

    def __init__(self, layer = None, field = None):
        """Initialize a classification.

           layer -- the layer object who owns this classification

           field -- the name of the data table field that 
                    is to be used to classify layer properties
        """
 
        self.layer = layer
        self.points = {}
        self.ranges = []
        self.maps   = []
        self.DefaultData = ClassDataDefault()
        self.field = field
        #self.SetField(field)

    def SendMessage(self, message):
        if self.layer is not None:
            self.layer.changed(message, self.layer)
    
    def SetField(self, field):
        """Set the name of the data table field to use.
         
           field -- if None then all values map to the default data 
        """

        self.field = field
        self.SendMessage(LAYER_LEGEND_CHANGED)

    def GetField(self):
        return self.field

    def SetLayer(self, layer):
        self.layer = layer
        self.SendMessage(LAYER_LEGEND_CHANGED)

    def GetLayer(self):
        return layer.self

    def SetDefaultData(self, data):
        """Set the data to be used when a value can't be classified.

           data -- data that the value maps to. See class description.
        """

        self.DefaultData = data

    def GetDefaultData(self):
        return self.DefaultData

    def SetDefaultFill(self, fill):
        self.DefaultData.SetFill(fill)
        self.SendMessage(LAYER_LEGEND_CHANGED)
        
    def GetDefaultFill(self):
        return self.DefaultData.GetFill()
        
    def SetDefaultStroke(self, stroke):
        self.DefaultData.SetStroke(stroke)
        self.SendMessage(LAYER_LEGEND_CHANGED)
        
    def GetDefaultStroke(self):
        return self.DefaultData.GetStroke()
        
    def SetDefaultStrokeWidth(self, strokeWidth):
        self.DefaultData.SetStrokeWidth(strokeWidth)
        self.SendMessage(LAYER_LEGEND_CHANGED)
        
    def GetDefaultStrokeWidth(self):
        return self.DefaultData.GetStrokeWidth()
        
    def AddClassData(self, item):
        type = item.GetType()

        if type == ClassData.POINT:
            self.points[item.GetValue()] = item
        elif type == ClassData.RANGE:
            self.ranges.append(item)
        elif type == ClassData.MAP:
            self.maps.append(item)
        elif type == ClassData.DEFAULT:
            self.DefaultData = item
        else:
            raise ValueError(_("Unrecognized ClassData type %s") % type)

        self.SendMessage(LAYER_LEGEND_CHANGED)

    def GetProperties(self, value):
        """Return the associated data, or the default data.

           The following search technique is used:
               (1) if the field is None, return the default data
               (2) check if the value exists as a single value
               (3) check if the value falls within a range. Ranges
                   are checked in the order they were added to 
                   the classification.

           value -- the value to classify. If there is no mapping,
                    or value is None, return the default data 
                    (which may be None)
        """

        if self.field is not None and value is not None:
            #
            # check the discrete values
            #
            if self.points.has_key(value):
                return self.points[value]

            #
            # check the ranges
            #
            for p in self.ranges:
                if p.InRange(value):
                    return p

            #
            # check the maps
            #
            for p in self.maps:
                try:
                    return p.Map(value)
                except: pass

        return self.DefaultData

    def TreeInfo(self):
        items = []

        def build_color_item(text, color):
            if color is Color.None:
                return ("%s: %s" % (text, _("None")), None)

            return ("%s: (%.3f, %.3f, %.3f)" % 
                    (text, color.red, color.green, color.blue),
                    color)

        def build_item(data, string):
            label = data.GetLabel()
            if label == "":
                label = string
            else:
                label += " (%s)" % string

            i = []
            v = data.GetStroke()
            i.append(build_color_item(_("Stroke"), v))
            v = data.GetStrokeWidth()
            i.append(_("Stroke Width: %s") % v)
            v = data.GetFill()
            i.append(build_color_item(_("Fill"), v))
            return (label, i)

        items.append(build_item(self.DefaultData, _("'DEFAULT'")))

        for p in self.points.values():
            items.append(build_item(p, str(p.GetValue())))

        for p in self.ranges:
            items.append(build_item(p, "%s - %s" % (p.GetMin(), p.GetMax())))

        return (_("Classifications"), items)
 

class ClassData:

    INVALID = -1
    DEFAULT = 0
    POINT = 1
    RANGE = 2
    MAP   = 3

    def __init__(self, type = INVALID, classData = None):

        if classData is not None:
            self.SetStroke(classData.GetStroke())
            self.SetStrokeWidth(classData.GetStrokeWidth())
            self.SetFill(classData.GetFill())
        else:
            self.SetStroke(Color.None)
            self.SetStrokeWidth(1)
            self.SetFill(Color.None)

        self.type = type
        self.label = ""
    
    def GetType(self):
        return self.type

    def GetStroke(self):
        return self.stroke

    def SetStroke(self, stroke):
        assert(isinstance(stroke, Color))
        self.stroke = stroke

    def GetStrokeWidth(self):
        return self.stroke_width

    def SetStrokeWidth(self, stroke_width):
        if (stroke_width < 1):
            raise ValueError(_("stroke_width < 1"))

        self.stroke_width = stroke_width

    def GetFill(self):
        return self.fill
 
    def SetFill(self, fill):
        assert(isinstance(fill, Color))
        self.fill = fill

    def GetLabel(self):
        return self.label
 
    def SetLabel(self, label):
        self.label = label

class ClassDataDefault(ClassData):
    def __init__(self, classData = None):
        ClassData.__init__(self, ClassData.DEFAULT, classData)
    
class ClassDataPoint(ClassData):

    def __init__(self, value = 0, classData = None):
        ClassData.__init__(self, ClassData.POINT, classData)

        self.value = value

    def GetValue(self):
        return self.value

    def SetValue(self, value):
        self.value = value

class ClassDataRange(ClassData):

    def __init__(self, min = 0, max = 1, classData = None):
        ClassData.__init__(self, ClassData.RANGE, classData)

        if min >= max:
            raise ValueError(_("ClassDataRange: %i(min) >= %i(max)!") %
                             (min, max))

        self.SetRange(min, max)

    def GetMin(self):
        return self.min

    def SetMin(self, min):
        self.SetRange(min, self.max)

    def GetMax(self):
        return self.max

    def SetMax(self, max):
        self.SetRange(self.min, max)

    def SetRange(self, min, max):
        self.min = min
        self.max = max
        if min >= max:
            raise ValueError(_("ClassDataRange: %i(min) >= %i(max)!") %
                             (min, max))

    def GetRange(self):
        return (self.min, self.max)

    def InRange(self, value):
        return self.min <= value < self.max

class ClassDataMap(ClassData):

    FUNC_ID = "id"

    def __init__(self, map_type = FUNC_ID, func = None, classData = None):
        ClassData.__init__(self, ClassData.MAP, classData)

        self.map_type = map_type
        self.func = func

        if self.func is None:
            self.func = func_id

    def Map(self, value):
        return self.func(value)

    #
    # built-in mappings
    #
    def func_id(value):
        return value

1	jonathan	371	# Copyright (c) 2001 by Intevation GmbH
2			# Authors:
3			# Jonathan Coles <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			__version__ = "$Revision$"
9
10			"""
11			A Classification provides a mapping from an input value
12			to data. This mapping can be specified in two ways.
13			First, specific values can be associated with data.
14			Second, ranges can be associated with data such that if
15			an input value falls with a range that data is returned.
16	jonathan	388	If no mapping can be found then default data will
17	jonathan	371	be returned. Input values must be hashable objects
18
19			See the description of getProperties() for more information
20			on the mapping algorithm.
21			"""
22
23	jonathan	397	# fix for people using python2.1
24			from __future__ import nested_scopes
25
26	jonathan	388	from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
27			LAYER_VISIBILITY_CHANGED
28
29	jan	374	from Thuban import _
30	jonathan	381	from Thuban.Model.color import Color
31	jan	374
32	jonathan	381	from wxPython.wx import *
33
34	jonathan	371	# constants
35			RANGE_MIN = 0
36			RANGE_MAX = 1
37			RANGE_DATA = 2
38
39			class Classification:
40
41	jonathan	410	def __init__(self, layer = None, field = None):
42	jonathan	371	"""Initialize a classification.
43
44	jonathan	388	layer -- the layer object who owns this classification
45
46	jonathan	371	field -- the name of the data table field that
47			is to be used to classify layer properties
48			"""
49
50	jonathan	388	self.layer = layer
51	jonathan	378	self.points = {}
52			self.ranges = []
53	jonathan	410	self.maps = []
54			self.DefaultData = ClassDataDefault()
55	jonathan	388	self.field = field
56			#self.SetField(field)
57
58	jonathan	410	def SendMessage(self, message):
59			if self.layer is not None:
60			self.layer.changed(message, self.layer)
61
62	jonathan	388	def SetField(self, field):
63	jonathan	371	"""Set the name of the data table field to use.
64
65	jonathan	388	field -- if None then all values map to the default data
66	jonathan	371	"""
67
68			self.field = field
69	jonathan	410	self.SendMessage(LAYER_LEGEND_CHANGED)
70	jonathan	371
71	jonathan	388	def GetField(self):
72			return self.field
73
74	jonathan	410	def SetLayer(self, layer):
75			self.layer = layer
76			self.SendMessage(LAYER_LEGEND_CHANGED)
77
78			def GetLayer(self):
79			return layer.self
80
81	jonathan	388	def SetDefaultData(self, data):
82	jonathan	371	"""Set the data to be used when a value can't be classified.
83
84			data -- data that the value maps to. See class description.
85			"""
86
87	jonathan	388	self.DefaultData = data
88	jonathan	371
89	jonathan	388	def GetDefaultData(self):
90			return self.DefaultData
91	jonathan	385
92	jonathan	388	def SetDefaultFill(self, fill):
93			self.DefaultData.SetFill(fill)
94	jonathan	410	self.SendMessage(LAYER_LEGEND_CHANGED)
95	jonathan	388
96			def GetDefaultFill(self):
97			return self.DefaultData.GetFill()
98
99			def SetDefaultStroke(self, stroke):
100			self.DefaultData.SetStroke(stroke)
101	jonathan	410	self.SendMessage(LAYER_LEGEND_CHANGED)
102	jonathan	388
103			def GetDefaultStroke(self):
104			return self.DefaultData.GetStroke()
105
106			def SetDefaultStrokeWidth(self, strokeWidth):
107			self.DefaultData.SetStrokeWidth(strokeWidth)
108	jonathan	410	self.SendMessage(LAYER_LEGEND_CHANGED)
109	jonathan	388
110			def GetDefaultStrokeWidth(self):
111			return self.DefaultData.GetStrokeWidth()
112
113	jonathan	410	def AddClassData(self, item):
114			type = item.GetType()
115	jonathan	371
116	jonathan	410	if type == ClassData.POINT:
117			self.points[item.GetValue()] = item
118			elif type == ClassData.RANGE:
119			self.ranges.append(item)
120			elif type == ClassData.MAP:
121			self.maps.append(item)
122			elif type == ClassData.DEFAULT:
123			self.DefaultData = item
124			else:
125			raise ValueError(_("Unrecognized ClassData type %s") % type)
126	jonathan	371
127	jonathan	410	self.SendMessage(LAYER_LEGEND_CHANGED)
128	jonathan	371
129	jonathan	388	def GetProperties(self, value):
130			"""Return the associated data, or the default data.
131	jonathan	371
132			The following search technique is used:
133	jonathan	388	(1) if the field is None, return the default data
134	jonathan	371	(2) check if the value exists as a single value
135			(3) check if the value falls within a range. Ranges
136			are checked in the order they were added to
137			the classification.
138
139	jonathan	388	value -- the value to classify. If there is no mapping,
140			or value is None, return the default data
141			(which may be None)
142	jonathan	371	"""
143
144	jonathan	388	if self.field is not None and value is not None:
145	jonathan	371	#
146	jonathan	410	# check the discrete values
147	jonathan	371	#
148	jonathan	378	if self.points.has_key(value):
149			return self.points[value]
150	jonathan	371
151			#
152	jonathan	410	# check the ranges
153	jonathan	371	#
154	jonathan	378	for p in self.ranges:
155	jonathan	410	if p.InRange(value):
156			return p
157	jonathan	371
158	jonathan	410	#
159			# check the maps
160			#
161			for p in self.maps:
162			try:
163			return p.Map(value)
164			except: pass
165	jonathan	371
166	jonathan	388	return self.DefaultData
167	jonathan	371
168	jonathan	381	def TreeInfo(self):
169			items = []
170	jonathan	378
171	jonathan	410	def build_color_item(text, color):
172			if color is Color.None:
173			return ("%s: %s" % (text, _("None")), None)
174	jonathan	381
175	jonathan	410	return ("%s: (%.3f, %.3f, %.3f)" %
176			(text, color.red, color.green, color.blue),
177			color)
178	jonathan	381
179	jonathan	410	def build_item(data, string):
180			label = data.GetLabel()
181			if label == "":
182			label = string
183			else:
184			label += " (%s)" % string
185
186	jonathan	381	i = []
187	jonathan	388	v = data.GetStroke()
188	jonathan	410	i.append(build_color_item(_("Stroke"), v))
189	jonathan	388	v = data.GetStrokeWidth()
190	jonathan	410	i.append(_("Stroke Width: %s") % v)
191	jonathan	388	v = data.GetFill()
192	jonathan	410	i.append(build_color_item(_("Fill"), v))
193			return (label, i)
194	jonathan	388
195	jonathan	410	items.append(build_item(self.DefaultData, _("'DEFAULT'")))
196	jonathan	388
197	jonathan	410	for p in self.points.values():
198			items.append(build_item(p, str(p.GetValue())))
199	jonathan	381
200			for p in self.ranges:
201	jonathan	410	items.append(build_item(p, "%s - %s" % (p.GetMin(), p.GetMax())))
202	jonathan	388
203	jonathan	381	return (_("Classifications"), items)
204
205	jonathan	388
206			class ClassData:
207
208	jonathan	410	INVALID = -1
209			DEFAULT = 0
210			POINT = 1
211			RANGE = 2
212			MAP = 3
213
214			def __init__(self, type = INVALID, classData = None):
215
216			if classData is not None:
217			self.SetStroke(classData.GetStroke())
218			self.SetStrokeWidth(classData.GetStrokeWidth())
219			self.SetFill(classData.GetFill())
220			else:
221			self.SetStroke(Color.None)
222			self.SetStrokeWidth(1)
223			self.SetFill(Color.None)
224
225			self.type = type
226	jonathan	388	self.label = ""
227
228	jonathan	410	def GetType(self):
229			return self.type
230
231	jonathan	388	def GetStroke(self):
232			return self.stroke
233
234			def SetStroke(self, stroke):
235	jonathan	410	assert(isinstance(stroke, Color))
236	jonathan	388	self.stroke = stroke
237
238			def GetStrokeWidth(self):
239			return self.stroke_width
240
241			def SetStrokeWidth(self, stroke_width):
242	jonathan	410	if (stroke_width < 1):
243			raise ValueError(_("stroke_width < 1"))
244
245	jonathan	388	self.stroke_width = stroke_width
246
247			def GetFill(self):
248			return self.fill
249
250			def SetFill(self, fill):
251	jonathan	410	assert(isinstance(fill, Color))
252	jonathan	388	self.fill = fill
253
254			def GetLabel(self):
255			return self.label
256
257			def SetLabel(self, label):
258			self.label = label
259
260	jonathan	410	class ClassDataDefault(ClassData):
261			def __init__(self, classData = None):
262			ClassData.__init__(self, ClassData.DEFAULT, classData)
263
264			class ClassDataPoint(ClassData):
265
266			def __init__(self, value = 0, classData = None):
267			ClassData.__init__(self, ClassData.POINT, classData)
268
269			self.value = value
270
271			def GetValue(self):
272			return self.value
273
274			def SetValue(self, value):
275			self.value = value
276
277			class ClassDataRange(ClassData):
278
279			def __init__(self, min = 0, max = 1, classData = None):
280			ClassData.__init__(self, ClassData.RANGE, classData)
281
282			if min >= max:
283			raise ValueError(_("ClassDataRange: %i(min) >= %i(max)!") %
284			(min, max))
285
286			self.SetRange(min, max)
287
288			def GetMin(self):
289			return self.min
290
291			def SetMin(self, min):
292			self.SetRange(min, self.max)
293
294			def GetMax(self):
295			return self.max
296
297			def SetMax(self, max):
298			self.SetRange(self.min, max)
299
300			def SetRange(self, min, max):
301			self.min = min
302			self.max = max
303			if min >= max:
304			raise ValueError(_("ClassDataRange: %i(min) >= %i(max)!") %
305			(min, max))
306
307			def GetRange(self):
308			return (self.min, self.max)
309
310			def InRange(self, value):
311			return self.min <= value < self.max
312
313			class ClassDataMap(ClassData):
314
315			FUNC_ID = "id"
316
317			def __init__(self, map_type = FUNC_ID, func = None, classData = None):
318			ClassData.__init__(self, ClassData.MAP, classData)
319
320			self.map_type = map_type
321			self.func = func
322
323			if self.func is None:
324			self.func = func_id
325
326			def Map(self, value):
327			return self.func(value)
328
329			#
330			# built-in mappings
331			#
332			def func_id(value):
333			return value
334
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision