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

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

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

revision 1128 by tkoester, Tue Jun 3 17:00:47 2003 UTC revision 1525 by jonathan, Wed Jul 30 15:42:56 2003 UTC
# Line 15  __version__ = "$Revision$" Line 15  __version__ = "$Revision$"
15    
16  import operator  import operator
17    
18  from color import Color  from color import Color, Transparent
19  from range import Range  from range import Range
20  from classification import Classification, ClassGroupSingleton, \  from classification import Classification, ClassGroupSingleton, \
21      ClassGroupRange, ClassGroupProperties      ClassGroupRange, ClassGroupProperties
22    
23  def GenSingletonsFromList(_list, numGroups, ramp):  def generate_singletons(_list, ramp):
24      """Generate a new classification consisting solely of singletons.      """Generate a new classification consisting solely of singletons.
25    
26      The resulting classification will consist of at most 'numGroups'      The resulting classification will consist of one group for each
27      groups whose group properties ramp between 'prop1' and 'prop2'. There      item in _list whose properties ramp between 'prop1' and 'prop2'.
28      could be fewer groups if '_list' contains fewer that 'numGroups' items.  
29        _list -- a list of values for each singleton
     _list -- any object that implements the iterator interface  
   
     numGroups -- how many groups to generate. This can not be  
                  determined while the classification is being  
                  generated because the stepping values must  
                  be precalculated to ramp between prop1 and prop2.  
30    
31      ramp -- an object which implements the CustomRamp interface      ramp -- an object which implements the CustomRamp interface
32      """      """
33    
34      clazz = Classification()      clazz = Classification()
     if numGroups == 0: return clazz  
35    
36      ramp.SetNumGroups(numGroups)      i = 0
37        maxValue = float(len(_list) - 1)
38        if maxValue < 1: maxValue = 1
39    
40      for value, prop in zip(_list, ramp):      for value in _list:
41            prop = ramp.GetProperties(i / maxValue)
42          clazz.AppendGroup(ClassGroupSingleton(value, prop))          clazz.AppendGroup(ClassGroupSingleton(value, prop))
43            i += 1
44    
45      return clazz      return clazz
46    
47  def GenSingletons(min, max, numGroups, ramp):  def generate_uniform_distribution(min, max, numGroups, ramp, intStep = False):
   
     clazz = Classification()  
   
     #step = int((max - min) / float(numGroups))  
   
     if numGroups > 0:  
   
         step = int((max - min + 1) / float(numGroups))  
         cur_value = min  
   
         ramp.SetNumGroups(numGroups)  
   
         for prop in ramp:  
             clazz.AppendGroup(ClassGroupSingleton(cur_value), prop)  
             cur_value += step  
   
     return clazz  
   
 def GenUniformDistribution(min, max, numGroups,  
                            ramp, intStep = False):  
48      """Generate a classification with numGroups range groups      """Generate a classification with numGroups range groups
49      each with the same interval.      each with the same interval.
50    
# Line 78  def GenUniformDistribution(min, max, num Line 55  def GenUniformDistribution(min, max, num
55      """      """
56    
57      clazz = Classification()      clazz = Classification()
     if numGroups == 0: return clazz  
58    
59      ramp.SetNumGroups(numGroups)      cur_min = min
60    
61      step = (max - min) / float(numGroups)      end = "["
62        maxValue = float(numGroups - 1)
63        if maxValue < 1: maxValue = 1
64    
65      if intStep:      for i in range(1, numGroups + 1):
         step = int(step)  
66    
67      cur_min = min          prop = ramp.GetProperties(float(i-1) / maxValue)
     cur_max = cur_min + step  
68    
69      i = 0          if intStep:
70      end = "["              cur_max = min + int(round((i * (max - min + 1)) / float(numGroups)))
71      for prop in ramp:          else:
72                cur_max = min + (i * (max - min)) / float(numGroups)
73    
74          if i == (numGroups - 1):          if i == numGroups:
75              cur_max = max              cur_max = max
76              end = "]"              end = "]"
77    
78            if cur_min == cur_max:
79                _range = Range(("[", cur_min, cur_max, "]"))
80            else:
81                _range = Range(("[", cur_min, cur_max, end))
82    
83          # this check guards against rounding issues          clazz.AppendGroup(ClassGroupRange(_range, prop))
         if cur_min != cur_max:  
             range = Range(("[", cur_min, cur_max, end))  
             clazz.AppendGroup(ClassGroupRange(range, None, prop))  
84    
85          cur_min = cur_max          cur_min = cur_max
         cur_max += step  
         i += 1  
86    
87      return clazz      return clazz
88    
89    def generate_quantiles(_list, percents, ramp, _range):
 def GenQuantiles(_list, percents, ramp, _range):  
90      """Generates a Classification which has groups of ranges that      """Generates a Classification which has groups of ranges that
91      represent quantiles of _list at the percentages given in percents.      represent quantiles of _list at the percentages given in percents.
92      Only the values that fall within _range are considered.      Only the values that fall within _range are considered.
# Line 123  def GenQuantiles(_list, percents, ramp, Line 98  def GenQuantiles(_list, percents, ramp,
98      _list -- a sort list of values      _list -- a sort list of values
99    
100      percents -- a sorted list of floats in the range 0.0-1.0 which      percents -- a sorted list of floats in the range 0.0-1.0 which
101                  represent the upper bound of each quantile                  represent the upper bound of each quantile. the
102                    union of all percentiles should be the entire
103                    range from 0.0-1.0
104    
105      ramp -- an object which implements the CustomRamp interface      ramp -- an object which implements the CustomRamp interface
106    
107      _range -- a Range object      _range -- a Range object
108    
109        Raises a Value Error if 'percents' has fewer than two items, or
110        does not cover the entire range.
111      """      """
112    
113      clazz = Classification()      clazz = Classification()
114      quantiles = CalculateQuantiles(_list, percents, _range)      quantiles = calculate_quantiles(_list, percents, _range)
115      adjusted = True      adjusted = True
116    
117      if quantiles is not None:      if quantiles is not None:
# Line 142  def GenQuantiles(_list, percents, ramp, Line 122  def GenQuantiles(_list, percents, ramp,
122    
123              adjusted = quantiles[0]              adjusted = quantiles[0]
124    
             ramp.SetNumGroups(numGroups)  
   
125              start, min, endMax, right = _range.GetRange()              start, min, endMax, right = _range.GetRange()
126    
127              oldp = 0              oldp = 0
128              i = 1              i = 1
129              end = "]"              end = "]"
130    
131              for (q, p), prop in zip(quantiles[3], ramp):              maxValue = float(numGroups - 1)
132                if maxValue < 1: maxValue = 1
133                for (q, p) in quantiles[3]:
134    
135                    prop = ramp.GetProperties(float(i-1) / maxValue)
136    
137                  if i == numGroups:                  if i == numGroups:
138                      max = endMax                      max = endMax
139                      end = right                      end = right
140                  else:                  else:
141                      max = _list[q]                      max = _list[q]
142    
143                  group = ClassGroupRange(Range((start, min, max, end)),                  group = ClassGroupRange(Range((start, min, max, end)), prop)
                                         None, prop)  
144            
145                  group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),                  group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
146                                                  round(p*100, 2)))                                                  round(p*100, 2)))
# Line 170  def GenQuantiles(_list, percents, ramp, Line 152  def GenQuantiles(_list, percents, ramp,
152    
153      return (adjusted, clazz)      return (adjusted, clazz)
154    
   
155  def GenQuantiles0(_list, percents, ramp, _range):  def GenQuantiles0(_list, percents, ramp, _range):
156      """Same as GenQuantiles, but the first class won't be added to      """Same as GenQuantiles, but the first class won't be added to
157      the classification.      the classification.
# Line 181  def GenQuantiles0(_list, percents, ramp, Line 162  def GenQuantiles0(_list, percents, ramp,
162      _list -- a sort list of values      _list -- a sort list of values
163    
164      percents -- a sorted list of floats in the range 0.0-1.0 which      percents -- a sorted list of floats in the range 0.0-1.0 which
165                  represent the upper bound of each quantile                  represent the upper bound of each quantile. the
166                    union of all percentiles should be the entire
167                    range from 0.0-1.0
168    
169      ramp -- an object which implements the CustomRamp interface      ramp -- an object which implements the CustomRamp interface
170    
171      _range -- a Range object      _range -- a Range object
172    
173        Raises a Value Error if 'percents' has fewer than two items, or
174        does not cover the entire range.
175      """      """
176    
177      clazz = Classification()      clazz = Classification()
178      quantiles = CalculateQuantiles(_list, percents, _range)      quantiles = calculate_quantiles(_list, percents, _range)
179      adjusted = True      adjusted = True
180    
181      if quantiles is not None:      if quantiles is not None:
# Line 199  def GenQuantiles0(_list, percents, ramp, Line 185  def GenQuantiles0(_list, percents, ramp,
185          if numGroups > 0:          if numGroups > 0:
186              adjusted = quantiles[0]              adjusted = quantiles[0]
187    
             ramp.SetNumGroups(numGroups)  
   
188              start, min, endMax, right = _range.GetRange()              start, min, endMax, right = _range.GetRange()
189    
190              class0 = quantiles[3][0]              class0 = quantiles[3][0]
# Line 209  def GenQuantiles0(_list, percents, ramp, Line 193  def GenQuantiles0(_list, percents, ramp,
193              i = 1              i = 1
194              end = "]"              end = "]"
195    
196              for (q, p), prop in zip(quantiles[3][1:], ramp):              maxValue = float(numGroups - 1)
197                if maxValue < 1: maxValue = 1
198                for (q, p) in quantiles[3][1:]:
199                    prop = ramp.GetProperties(float(i-1) / maxValue)
200    
201                  if i == numGroups:                  if i == numGroups:
202                      max = endMax                      max = endMax
203                      end = right                      end = right
204                  else:                  else:
205                      max = _list[q]                      max = _list[q]
206    
207                  group = ClassGroupRange(Range((start, min, max, end)),                  group = ClassGroupRange(Range((start, min, max, end)), prop)
                                         None, prop)  
208            
209                  group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),                  group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
210                                                  round(p*100, 2)))                                                  round(p*100, 2)))
# Line 230  def GenQuantiles0(_list, percents, ramp, Line 217  def GenQuantiles0(_list, percents, ramp,
217      return (adjusted, clazz, _list[class0[0]])      return (adjusted, clazz, _list[class0[0]])
218    
219    
220  def CalculateQuantiles(_list, percents, _range):  def calculate_quantiles(_list, percents, _range):
221      """Calculate quantiles for the given _list of percents from the      """Calculate quantiles for the given _list of percents from the
222      sorted list of values that are in range.      sorted list of values that are in range.
223                                                                                                                                                            
# Line 252  def CalculateQuantiles(_list, percents, Line 239  def CalculateQuantiles(_list, percents,
239      _list -- a sort list of values      _list -- a sort list of values
240    
241      percents -- a sorted list of floats in the range 0.0-1.0 which      percents -- a sorted list of floats in the range 0.0-1.0 which
242                  represent the upper bound of each quantile                  represent the upper bound of each quantile. the
243                    union of all percentiles should be the entire
244                    range from 0.0-1.0
245    
246      _range -- a Range object      _range -- a Range object
247    
248        Raises a Value Error if 'percents' has fewer than two items, or
249        does not cover the entire range.
250      """      """
251    
252      quantiles = []      quantiles = []
253      adjusted = False      adjusted = False
254    
255      if len(percents) != 0:      if len(percents) <= 1:
256                                                                                      raise ValueError("percents parameter must have more than one item")
257    
258        if percents[-1] != 1.0:
259            raise ValueError("percents does not cover the entire range")
260    
261        #
262        # find what part of the _list range covers
263        #
264        minIndex = -1
265        maxIndex = -2
266        for i in xrange(0, len(_list), 1):
267            if operator.contains(_range, _list[i]):
268                minIndex = i
269                break
270    
271        for i in xrange(len(_list)-1, -1, -1):
272            if operator.contains(_range, _list[i]):
273                maxIndex = i
274                break
275    
276        numValues = maxIndex - minIndex + 1
277    
278        if numValues > 0:
279    
280          #          #
281          # find what part of the _list range covers          # build a list of unique indices into list of where each
282            # quantile *should* be. set adjusted if the resulting
283            # indices are different
284          #          #
285          minIndex = -1          quantiles = {}
286          maxIndex = -2          for p in percents:
287          for i in xrange(0, len(_list), 1):              index = min(minIndex + int(p*numValues)-1, maxIndex)
288              if operator.contains(_range, _list[i]):  
289                  minIndex = i              adjusted = adjusted \
290                  break                  or quantiles.has_key(index) \
291                    or ((index - minIndex + 1) / float(numValues)) != p
292    
293          for i in xrange(len(_list)-1, -1, -1):              quantiles[index] = 0
294              if operator.contains(_range, _list[i]):  
295                  maxIndex = i          quantiles = quantiles.keys()
296                  break          quantiles.sort()
297    
298          numValues = maxIndex - minIndex + 1          #
299            # the current quantile index must be strictly greater than
300            # the lowerBound
301            #
302            lowerBound = minIndex - 1
303    
304          if numValues > 0:          for qindex in xrange(len(quantiles)):
305                if lowerBound >= maxIndex:
306                    # discard higher quantiles
307                    quantiles = quantiles[:qindex]
308                    break
309    
310                # lowerBound + 1 is always a valid index
311    
312              #              #
313              # build a list of unique indices into list of where each              # bump up the current quantile index to be a usable index
314              # quantile *should* be. set adjusted if the resulting              # if it currently falls below the lowerBound
             # indices are different  
315              #              #
316              quantiles = {}              if quantiles[qindex] <= lowerBound:
317              for p in percents:                  quantiles[qindex] = lowerBound + 1
                 index = min(minIndex + int(p*numValues)-1, maxIndex)  
   
                 adjusted = adjusted \  
                     or quantiles.has_key(index) \  
                     or ((index - minIndex + 1) / float(numValues)) != p  
   
                 quantiles[index] = 0  
318    
319              quantiles = quantiles.keys()              listIndex = quantiles[qindex]
320              quantiles.sort()              value = _list[listIndex]
321    
322              #              #
323              # the current quantile index must be strictly greater than              # look for similar values around the quantile index
             # the lowerBound  
324              #              #
325              lowerBound = minIndex - 1              lindex = listIndex - 1
326                while lindex > lowerBound and value == _list[lindex]:
327                    lindex -= 1
328                lcount = (listIndex - 1) - lindex
329    
330                rindex = listIndex + 1
331                while rindex < maxIndex + 1 and value == _list[rindex]:
332                    rindex += 1
333                rcount = (listIndex + 1) - rindex
334    
335              for qindex in xrange(len(quantiles)):              #
336                  if lowerBound >= maxIndex:              # adjust the current quantile index based on how many
337                      # discard higher quantiles              # numbers in the _list are the same as the current value
338                      quantiles = quantiles[:qindex]              #
339                      break              newIndex = listIndex
340                if lcount == rcount:
341                  # lowerBound + 1 is always a valid index                  if lcount != 0:
342                        #
343                  #                      # there are an equal number of numbers to the left
344                  # bump up the current quantile index to be a usable index                      # and right, try going to the left first unless
                 # if it currently falls below the lowerBound  
                 #  
                 if quantiles[qindex] <= lowerBound:  
                     quantiles[qindex] = lowerBound + 1  
       
                 listIndex = quantiles[qindex]  
                 value = _list[listIndex]  
   
                 #  
                 # look for similar values around the quantile index  
                 #  
                 lindex = listIndex - 1  
                 while lindex > lowerBound and value == _list[lindex]:  
                     lindex -= 1  
                 lcount = (listIndex - 1) - lindex  
   
                 rindex = listIndex + 1  
                 while rindex < maxIndex + 1 and value == _list[rindex]:  
                     rindex += 1  
                 rcount = (listIndex + 1) - rindex  
   
                 #  
                 # adjust the current quantile index based on how many  
                 # numbers in the _list are the same as the current value  
                 #  
                 newIndex = listIndex  
                 if lcount == rcount:  
                     if lcount != 0:  
                         #  
                         # there are an equal number of numbers to the left  
                         # and right, try going to the left first unless  
                         # doing so creates an empty quantile.  
                         #  
                         if lindex != lowerBound:  
                             newIndex = lindex  
                         else:  
                             newIndex = rindex - 1  
   
                 elif lcount < rcount:  
                     # there are fewer items to the left, so  
                     # try going to the left first unless  
345                      # doing so creates an empty quantile.                      # doing so creates an empty quantile.
346                        #
347                      if lindex != lowerBound:                      if lindex != lowerBound:
348                          newIndex = lindex                          newIndex = lindex
349                      else:                      else:
350                          newIndex = rindex - 1                          newIndex = rindex - 1
351    
352                  elif rcount < lcount:              elif lcount < rcount:
353                      # there are fewer items to the right, so go to the right                  # there are fewer items to the left, so
354                    # try going to the left first unless
355                    # doing so creates an empty quantile.
356                    if lindex != lowerBound:
357                        newIndex = lindex
358                    else:
359                      newIndex = rindex - 1                      newIndex = rindex - 1
360    
361                  adjusted = adjusted or newIndex != listIndex              elif rcount < lcount:
362                    # there are fewer items to the right, so go to the right
363                    newIndex = rindex - 1
364    
365                adjusted = adjusted or newIndex != listIndex
366    
367                  quantiles[qindex] = newIndex              quantiles[qindex] = newIndex
368                  lowerBound = quantiles[qindex]              lowerBound = quantiles[qindex]
369    
370      if len(quantiles) == 0:      if len(quantiles) == 0:
371          return None          return None
# Line 378  def CalculateQuantiles(_list, percents, Line 374  def CalculateQuantiles(_list, percents,
374                  [(q, (q - minIndex+1) / float(numValues)) \                  [(q, (q - minIndex+1) / float(numValues)) \
375                   for q in quantiles])                   for q in quantiles])
376    
 CLR  = 0  
 STEP = 1  
377  class CustomRamp:  class CustomRamp:
378    
379      def __init__(self, prop1, prop2):      def __init__(self, prop1, prop2):
380            """Create a ramp between prop1 and prop2."""
381          self.prop1 = prop1          self.prop1 = prop1
382          self.prop2 = prop2          self.prop2 = prop2
383    
         self.count = 0  
   
     def __iter__(self):  
         return self  
   
384      def GetRamp(self):      def GetRamp(self):
385            """Return this ramp."""
386          return self          return self
387    
388      def SetNumGroups(self, num):      def GetProperties(self, index):
389            """Return a ClassGroupProperties object whose properties
390          if num <= 0:          represent a point at 'index' between prop1 and prop2 in
391              return False          the constructor.
392    
393          self.count = int(num)          index -- a value such that 0 <= index <= 1
394          num = float(num)          """
395    
396          prop1 = self.prop1          if not (0 <= index <= 1):
397          prop2 = self.prop2              raise ValueError(_("invalid index"))
398    
399          clr = prop1.GetLineColor()          newProps = ClassGroupProperties()
400          lineColor2 = prop2.GetLineColor()  
401                    self.__SetProperty(self.prop1.GetLineColor(),
402          self.noLine = clr is not Color.Transparent \                             self.prop2.GetLineColor(),
403                          and lineColor2 is not Color.Transparent                             index, newProps.SetLineColor)
404            self.__SetProperty(self.prop1.GetFill(), self.prop2.GetFill(),
405                               index, newProps.SetFill)
406          self.lineInfo = self.__GetColorInfo(prop1.GetLineColor(),  
407                                              prop2.GetLineColor(),          w = (self.prop2.GetLineWidth() - self.prop1.GetLineWidth()) \
408                                              num)              * index \
409                + self.prop1.GetLineWidth()
410          self.fillInfo = self.__GetColorInfo(prop1.GetFill(),          newProps.SetLineWidth(int(round(w)))
411                                              prop2.GetFill(),  
412                                              num)          return newProps
413    
414          self.lineWidth = prop1.GetLineWidth()      def __SetProperty(self, color1, color2, index, setf):
415          self.lineWidthStep = (prop2.GetLineWidth() - self.lineWidth) / num          """Use setf to set the appropriate property for the point
416            index percent between color1 and color2. setf is a function
417          return True          to call that accepts a Color object or Transparent.
418            """
419      def next(self):  
420          if self.count == 0:          if color1 is Transparent and color2 is Transparent:
421              raise StopIteration              setf(Transparent)
422            elif color1 is Transparent:
423          prop = ClassGroupProperties()              setf(Color(
424                     color2.red   * index,
425          if self.lineInfo is None:                   color2.green * index,
426              prop.SetLineColor(Color.Transparent)                   color2.blue  * index))
427          else:          elif color2 is Transparent:
428              prop.SetLineColor(Color(self.lineInfo[CLR][0] / 255,              setf(Color(
429                                      self.lineInfo[CLR][1] / 255,                   color1.red   * index,
430                                      self.lineInfo[CLR][2] / 255))                   color1.green * index,
431                     color1.blue  * index))
             self.lineInfo[CLR][0] += self.lineInfo[STEP][0]  
             self.lineInfo[CLR][1] += self.lineInfo[STEP][1]  
             self.lineInfo[CLR][2] += self.lineInfo[STEP][2]  
   
         if self.fillInfo is None:  
             prop.SetFill(Color.Transparent)  
432          else:          else:
433              prop.SetFill(Color(self.fillInfo[CLR][0] / 255,              setf(Color(
434                              self.fillInfo[CLR][1] / 255,                  (color2.red   - color1.red)   * index + color1.red,
435                              self.fillInfo[CLR][2] / 255))                  (color2.green - color1.green) * index + color1.green,
436                    (color2.blue  - color1.blue)  * index + color1.blue))
             self.fillInfo[CLR][0] += self.fillInfo[STEP][0]  
             self.fillInfo[CLR][1] += self.fillInfo[STEP][1]  
             self.fillInfo[CLR][2] += self.fillInfo[STEP][2]  
   
   
         prop.SetLineWidth(int(self.lineWidth))  
         self.lineWidth        += self.lineWidthStep  
437    
438          self.count -= 1  class MonochromaticRamp(CustomRamp):
439        """Helper class to make ramps between two colors."""
         return prop  
   
     def __GetColorInfo(self, color1, color2, numGroups):  
   
         if color1 is Color.Transparent and color2 is Color.Transparent:  
             #  
             # returning early  
             #  
             return None  
         elif color1 is not Color.Transparent and color2 is Color.Transparent:  
             color = [color1.red   * 255,  
                      color1.green * 255,  
                      color1.blue  * 255]  
             step = (0, 0, 0)  
         elif color1 is Color.Transparent and color2 is not Color.Transparent:  
             color = [color2.red   * 255,  
                      color2.green * 255,  
                      color2.blue  * 255]  
             step = (0, 0, 0)  
         else:  
             color = [color1.red   * 255,  
                      color1.green * 255,  
                      color1.blue  * 255]  
             step = ((color2.red   * 255 - color1.red   * 255)   / numGroups,  
                     (color2.green * 255 - color1.green * 255) / numGroups,  
                     (color2.blue  * 255 - color1.blue  * 255)  / numGroups)  
440    
441        def __init__(self, start, end):
442            """Create a Monochromatic Ramp.
443    
444          return (color, step)          start -- starting Color
445    
446  class MonochromaticRamp(CustomRamp):          end -- ending Color
447      def __init__(self, start, end):          """
448          sp = ClassGroupProperties()          sp = ClassGroupProperties()
449          sp.SetLineColor(start)          sp.SetLineColor(start)
450          sp.SetFill(start)          sp.SetFill(start)
# Line 501  class MonochromaticRamp(CustomRamp): Line 455  class MonochromaticRamp(CustomRamp):
455    
456          CustomRamp.__init__(self, sp, ep)          CustomRamp.__init__(self, sp, ep)
457    
458  class GreyRamp(MonochromaticRamp):  grey_ramp         = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, 0))
459      def __init__(self):  red_ramp          = MonochromaticRamp(Color(1, 1, 1),  Color(.8, 0, 0))
460          MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))  green_ramp        = MonochromaticRamp(Color(1, 1, 1),  Color(0, .8, 0))
461    blue_ramp         = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, .8))
462  class RedRamp(MonochromaticRamp):  green_to_red_ramp = MonochromaticRamp(Color(0, .8, 0), Color(1, 0, 0))
     def __init__(self):  
         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(.8, 0, 0))  
   
 class GreenRamp(MonochromaticRamp):  
     def __init__(self):  
         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, .8, 0))  
   
 class BlueRamp(MonochromaticRamp):  
     def __init__(self):  
         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, .8))  
   
 class GreenToRedRamp(MonochromaticRamp):  
     def __init__(self):  
         MonochromaticRamp.__init__(self, Color(0, .8, 0), Color(1, 0, 0))  
463    
464  class HotToColdRamp:  class HotToColdRamp:
465        """A ramp that generates properties with colors ranging from
466        'hot' colors (e.g. red, orange) to 'cold' colors (e.g. green, blue)
467        """
468    
     def __iter__(self):  
         return self  
           
469      def GetRamp(self):      def GetRamp(self):
470            """Return this ramp."""
471          return self          return self
472    
473      def SetNumGroups(self, num):      def GetProperties(self, index):
474          if num < 0:          """Return a ClassGroupProperties object whose properties
475              return False          represent a point at 'index' between "hot" and "cold".
476    
477          self.num = float(num)          index -- a value such that 0 <= index <= 1
478          self.index = 0          """
   
         return True  
   
     def next(self):  
         if self.index == self.num:  
             raise StopIteration  
479    
480          clr = [1.0, 1.0, 1.0]          clr = [1.0, 1.0, 1.0]
481    
482          if self.index < (.25 * self.num):          if index < .25:
483              clr[0] = 0              clr[0] = 0
484              clr[1] = 4 * self.index / self.num              clr[1] = 4 * index
485          elif self.index < (.5 * self.num):          elif index < .5:
486              clr[0] = 0              clr[0] = 0
487              clr[2] = 1 + 4 * (.25 * self.num - self.index) / self.num              clr[2] = 1 + 4 * (.25 - index)
488          elif self.index < (.75 * self.num):          elif index < .75:
489              clr[0] = 4 * (self.index - .5 * self.num) / self.num              clr[0] = 4 * (index - .5)
490              clr[2] = 0              clr[2] = 0
491          else:          else:
492              clr[1] = 1 + 4 * (.75 * self.num - self.index) / self.num              clr[1] = 1 + 4 * (.75 - index)
493              clr[2] = 0              clr[2] = 0
494    
         self.index += 1  
   
495          prop = ClassGroupProperties()          prop = ClassGroupProperties()
496          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))
497          prop.SetFill(Color(clr[0], clr[1], clr[2]))          prop.SetFill(Color(clr[0], clr[1], clr[2]))
498    
499          return prop          return prop
500    
501  #class Colors16Ramp:  class FixedRamp:
502  #      """FixedRamp allows particular properties of a ramp to be
503      #def __iter__(self):      held constant over the ramp.
504          #return self      """
505  #  
506      #def GetRamp(self):      def __init__(self, ramp, fixes):
507          #return self          """
508  #          ramp -- a source ramp to get the default properties
509      #def SetNumGroups(self, num):  
510          #if num < 0:          fixes -- a tuple (lineColor, lineWidth, fillColor) such that
511              #return False               if any item is not None, the appropriate property will
512  #               be fixed to that item value.
513          #self.index = 0          """
514  #  
515          #return True          self.fixes = fixes
516            self.ramp = ramp
517    
518        def GetRamp(self):
519            """Return this ramp."""
520            return self
521    
522        def GetProperties(self, index):
523            """Return a ClassGroupProperties object whose properties
524            represent a point at 'index' between the properties in
525            the ramp that initialized this FixedRamp.
526    
527            index -- a value such that 0 <= index <= 1
528            """
529    
530            props = self.ramp.GetProperties(index)
531            if self.fixes[0] is not None: props.SetLineColor(self.fixes[0])
532            if self.fixes[1] is not None: props.SetLineWidth(self.fixes[1])
533            if self.fixes[2] is not None: props.SetFill(self.fixes[2])
534    
535            return props
Legend:
Removed from v.1128  
changed lines
  Added in v.1525
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26