/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/classification.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/classification.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 397 by jonathan, Tue Feb 11 14:23:32 2003 UTC revision 410 by jonathan, Wed Feb 19 16:51:12 2003 UTC
# Line 38  RANGE_DATA = 2 Line 38  RANGE_DATA = 2
38    
39  class Classification:  class Classification:
40    
41      def __init__(self, layer, field = None):      def __init__(self, layer = None, field = None):
42          """Initialize a classification.          """Initialize a classification.
43    
44             layer -- the layer object who owns this classification             layer -- the layer object who owns this classification
# Line 50  class Classification: Line 50  class Classification:
50          self.layer = layer          self.layer = layer
51          self.points = {}          self.points = {}
52          self.ranges = []          self.ranges = []
53          self.DefaultData = ClassData()          self.maps   = []
54            self.DefaultData = ClassDataDefault()
55          self.field = field          self.field = field
56          #self.SetField(field)          #self.SetField(field)
57    
58        def SendMessage(self, message):
59            if self.layer is not None:
60                self.layer.changed(message, self.layer)
61        
62      def SetField(self, field):      def SetField(self, field):
63          """Set the name of the data table field to use.          """Set the name of the data table field to use.
64                    
# Line 61  class Classification: Line 66  class Classification:
66          """          """
67    
68          self.field = field          self.field = field
69          self.layer.changed(LAYER_LEGEND_CHANGED, self.layer)          self.SendMessage(LAYER_LEGEND_CHANGED)
70    
71      def GetField(self):      def GetField(self):
72          return self.field          return self.field
73    
74        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      def SetDefaultData(self, data):      def SetDefaultData(self, data):
82          """Set the data to be used when a value can't be classified.          """Set the data to be used when a value can't be classified.
83    
# Line 79  class Classification: Line 91  class Classification:
91    
92      def SetDefaultFill(self, fill):      def SetDefaultFill(self, fill):
93          self.DefaultData.SetFill(fill)          self.DefaultData.SetFill(fill)
94          self.layer.changed(LAYER_LEGEND_CHANGED, self.layer)          self.SendMessage(LAYER_LEGEND_CHANGED)
95                    
96      def GetDefaultFill(self):      def GetDefaultFill(self):
97          return self.DefaultData.GetFill()          return self.DefaultData.GetFill()
98                    
99      def SetDefaultStroke(self, stroke):      def SetDefaultStroke(self, stroke):
100          self.DefaultData.SetStroke(stroke)          self.DefaultData.SetStroke(stroke)
101          self.layer.changed(LAYER_LEGEND_CHANGED, self.layer)          self.SendMessage(LAYER_LEGEND_CHANGED)
102                    
103      def GetDefaultStroke(self):      def GetDefaultStroke(self):
104          return self.DefaultData.GetStroke()          return self.DefaultData.GetStroke()
105                    
106      def SetDefaultStrokeWidth(self, strokeWidth):      def SetDefaultStrokeWidth(self, strokeWidth):
107          self.DefaultData.SetStrokeWidth(strokeWidth)          self.DefaultData.SetStrokeWidth(strokeWidth)
108          self.layer.changed(LAYER_LEGEND_CHANGED, self.layer)          self.SendMessage(LAYER_LEGEND_CHANGED)
109                    
110      def GetDefaultStrokeWidth(self):      def GetDefaultStrokeWidth(self):
111          return self.DefaultData.GetStrokeWidth()          return self.DefaultData.GetStrokeWidth()
112                    
113      def AddRange(self, min, max, data):      def AddClassData(self, item):
114          """Add a new range to the classification.          type = item.GetType()
   
            A range allows a value to be classified if it falls between  
            min and max. Specifically, min <= value < max  
           
            min -- the lower bound.  
   
            max -- the upper bound.  
   
            data -- data that the value maps to. See class description.  
         """  
   
         if min >= max:  
             raise ValueError(_("Range minimum >= maximum!"))  
         self.ranges.append([min, max, data])  
         self.layer.changed(LAYER_LEGEND_CHANGED, self.layer)  
   
     def AddPoint(self, value, data):  
         """Associate a single value with data.  
115    
116             When this value is to be classified data will be returned.          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    
127             value -- classification value.          self.SendMessage(LAYER_LEGEND_CHANGED)
   
            data  -- data that the value maps to. See class description.  
         """  
   
         self.points[value] = data  
         self.layer.changed(LAYER_LEGEND_CHANGED, self.layer)  
128    
129      def GetProperties(self, value):      def GetProperties(self, value):
130          """Return the associated data, or the default data.          """Return the associated data, or the default data.
# Line 146  class Classification: Line 143  class Classification:
143    
144          if self.field is not None and value is not None:          if self.field is not None and value is not None:
145              #              #
146              # first check the discrete values              # check the discrete values
147              #              #
148              if self.points.has_key(value):              if self.points.has_key(value):
149                  return self.points[value]                  return self.points[value]
150    
151              #              #
152              # now check the ranges              # check the ranges
153              #              #
154              for p in self.ranges:              for p in self.ranges:
155                  if (p[RANGE_MIN] <= value) and (value < p[RANGE_MAX]):                  if p.InRange(value):
156                      return p[RANGE_DATA]                      return p
157    
158                #
159                # check the maps
160                #
161                for p in self.maps:
162                    try:
163                        return p.Map(value)
164                    except: pass
165    
166          return self.DefaultData          return self.DefaultData
167    
168      def TreeInfo(self):      def TreeInfo(self):
169          items = []          items = []
170    
171          #          def build_color_item(text, color):
172          # XXX: shouldn't print anything if there are no classifications              if color is Color.None:
173          #                  return ("%s: %s" % (text, _("None")), None)
174    
175                        return ("%s: (%.3f, %.3f, %.3f)" %
176          def color_string(color):                      (text, color.red, color.green, color.blue),
177              if color is None:                      color)
178                  return "None"  
179              return "(%.3f, %.3f, %.3f)" % (color.red, color.green, color.blue)          def build_item(data, string):
180                label = data.GetLabel()
181                if label == "":
182                    label = string
183                else:
184                    label += " (%s)" % string
185    
         def build_item(data):  
186              i = []              i = []
   
187              v = data.GetStroke()              v = data.GetStroke()
188              i.append((_("Stroke: %s") % color_string(v), v))              i.append(build_color_item(_("Stroke"), v))
189              v = data.GetStrokeWidth()              v = data.GetStrokeWidth()
190              i.append((_("Stroke Width: %s") % v))              i.append(_("Stroke Width: %s") % v)
191              v = data.GetFill()              v = data.GetFill()
192              i.append((_("Fill: %s") % color_string(v), v))              i.append(build_color_item(_("Fill"), v))
193              return i              return (label, i)
194    
195          items.append((_("'DEFAULT'"), build_item(self.DefaultData)))          items.append(build_item(self.DefaultData, _("'DEFAULT'")))
196    
197          for name, data in self.points.items():          for p in self.points.values():
198              items.append((_("%s") % name, build_item(data)))              items.append(build_item(p, str(p.GetValue())))
199    
200          for p in self.ranges:          for p in self.ranges:
201              data = p[RANGE_DATA]              items.append(build_item(p, "%s - %s" % (p.GetMin(), p.GetMax())))
             items.append((_("%s-%s") % (p[RANGE_MIN], p[RANGE_MAX])),  
                          build_item(data))  
202    
203          return (_("Classifications"), items)          return (_("Classifications"), items)
204    
205    
206  class ClassData:  class ClassData:
207    
208      def __init__(self):      INVALID = -1
209          self.stroke = None      DEFAULT = 0
210          self.stroke_width = 0      POINT = 1
211          self.fill = None      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          self.label = ""          self.label = ""
227            
228        def GetType(self):
229            return self.type
230    
231      def GetStroke(self):      def GetStroke(self):
232          return self.stroke          return self.stroke
233    
234      def SetStroke(self, stroke):      def SetStroke(self, stroke):
235            assert(isinstance(stroke, Color))
236          self.stroke = stroke          self.stroke = stroke
237    
238      def GetStrokeWidth(self):      def GetStrokeWidth(self):
239          return self.stroke_width          return self.stroke_width
240    
241      def SetStrokeWidth(self, stroke_width):      def SetStrokeWidth(self, stroke_width):
242            if (stroke_width < 1):
243                raise ValueError(_("stroke_width < 1"))
244    
245          self.stroke_width = stroke_width          self.stroke_width = stroke_width
246    
247      def GetFill(self):      def GetFill(self):
248          return self.fill          return self.fill
249    
250      def SetFill(self, fill):      def SetFill(self, fill):
251            assert(isinstance(fill, Color))
252          self.fill = fill          self.fill = fill
253    
254      def GetLabel(self):      def GetLabel(self):
# Line 230  class ClassData: Line 257  class ClassData:
257      def SetLabel(self, label):      def SetLabel(self, label):
258          self.label = label          self.label = label
259    
260    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    
Legend:
Removed from v.397  
changed lines
  Added in v.410
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26