/[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 1098 by jonathan, Fri May 30 06:27:44 2003 UTC revision 1352 by jonathan, Wed Jul 2 09:36:39 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'.
     could be fewer groups if '_list' contains fewer that 'numGroups' items.  
28    
29      _list -- any object that implements the iterator interface      _list -- any object that implements the iterator interface
30    
     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.  
   
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  
   
     ramp.SetNumGroups(numGroups)  
35    
36      for value, prop in zip(_list, ramp):      i = 0
37        for value in _list:
38            prop = ramp.GetProperties(float(i) / len(_list))
39          clazz.AppendGroup(ClassGroupSingleton(value, prop))          clazz.AppendGroup(ClassGroupSingleton(value, prop))
40            i += 1
41    
42      return clazz      return clazz
43    
44  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):  
45      """Generate a classification with numGroups range groups      """Generate a classification with numGroups range groups
46      each with the same interval.      each with the same interval.
47    
# Line 78  def GenUniformDistribution(min, max, num Line 52  def GenUniformDistribution(min, max, num
52      """      """
53    
54      clazz = Classification()      clazz = Classification()
     if numGroups == 0: return clazz  
   
     ramp.SetNumGroups(numGroups)  
   
     step = (max - min) / float(numGroups)  
   
     if intStep:  
         step = int(step)  
55    
56      cur_min = min      cur_min = min
     cur_max = cur_min + step  
57    
     i = 0  
58      end = "["      end = "["
59      for prop in ramp:      for i in range(1, numGroups + 1):
60    
61            prop = ramp.GetProperties(float(i-1) / numGroups)
62    
63            if intStep:
64                cur_max = min + int(round((i * (max - min + 1)) / float(numGroups)))
65            else:
66                cur_max = min + (i * (max - min)) / float(numGroups)
67    
68          if i == (numGroups - 1):          if i == numGroups:
69              cur_max = max              cur_max = max
70              end = "]"              end = "]"
71    
72            if cur_min == cur_max:
73                _range = Range(("[", cur_min, cur_max, "]"))
74            else:
75                _range = Range(("[", cur_min, cur_max, end))
76    
77          # 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))  
78    
79          cur_min = cur_max          cur_min = cur_max
         cur_max += step  
         i += 1  
80    
81      return clazz      return clazz
82    
83    def generate_quantiles(_list, percents, ramp, _range):
 def GenQuantiles(_list, percents, ramp, _range):  
84      """Generates a Classification which has groups of ranges that      """Generates a Classification which has groups of ranges that
85      represent quantiles of _list at the percentages given in percents.      represent quantiles of _list at the percentages given in percents.
86      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 92  def GenQuantiles(_list, percents, ramp,
92      _list -- a sort list of values      _list -- a sort list of values
93    
94      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
95                  represent the upper bound of each quantile                  represent the upper bound of each quantile. the
96                    union of all percentiles should be the entire
97                    range from 0.0-1.0
98    
99      ramp -- an object which implements the CustomRamp interface      ramp -- an object which implements the CustomRamp interface
100    
101      _range -- a Range object      _range -- a Range object
102    
103        Raises a Value Error if 'percents' has fewer than two items, or
104        does not cover the entire range.
105      """      """
106    
107      clazz = Classification()      clazz = Classification()
108      quantiles = CalculateQuantiles(_list, percents, _range)      quantiles = calculate_quantiles(_list, percents, _range)
109      adjusted = True      adjusted = True
110    
111      if quantiles is not None:      if quantiles is not None:
# Line 142  def GenQuantiles(_list, percents, ramp, Line 116  def GenQuantiles(_list, percents, ramp,
116    
117              adjusted = quantiles[0]              adjusted = quantiles[0]
118    
             ramp.SetNumGroups(numGroups)  
   
119              start, min, endMax, right = _range.GetRange()              start, min, endMax, right = _range.GetRange()
120    
121              oldp = 0              oldp = 0
122              i = 1              i = 1
123              end = "]"              end = "]"
124    
125              for (q, p), prop in zip(quantiles[3], ramp):              for (q, p) in quantiles[3]:
126    
127                    prop = ramp.GetProperties(float(i-1) / numGroups)
128    
129                  if i == numGroups:                  if i == numGroups:
130                      max = endMax                      max = endMax
131                      end = right                      end = right
132                  else:                  else:
133                      max = _list[q]                      max = _list[q]
134    
135                  group = ClassGroupRange(Range((start, min, max, end)),                  group = ClassGroupRange(Range((start, min, max, end)), prop)
                                         None, prop)  
136            
137                  group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),                  group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
138                                                  round(p*100, 2)))                                                  round(p*100, 2)))
# Line 170  def GenQuantiles(_list, percents, ramp, Line 144  def GenQuantiles(_list, percents, ramp,
144    
145      return (adjusted, clazz)      return (adjusted, clazz)
146    
147  def CalculateQuantiles(_list, percents, _range):  def GenQuantiles0(_list, percents, ramp, _range):
148        """Same as GenQuantiles, but the first class won't be added to
149        the classification.
150    
151        Returns a tuple (adjusted, Classification, upper_class0) where
152        upper_class0 is the highest value inside the first class.
153    
154        _list -- a sort list of values
155    
156        percents -- a sorted list of floats in the range 0.0-1.0 which
157                    represent the upper bound of each quantile. the
158                    union of all percentiles should be the entire
159                    range from 0.0-1.0
160    
161        ramp -- an object which implements the CustomRamp interface
162    
163        _range -- a Range object
164    
165        Raises a Value Error if 'percents' has fewer than two items, or
166        does not cover the entire range.
167        """
168    
169        clazz = Classification()
170        quantiles = calculate_quantiles(_list, percents, _range)
171        adjusted = True
172    
173        if quantiles is not None:
174    
175            numGroups = len(quantiles[3]) - 1
176    
177            if numGroups > 0:
178                adjusted = quantiles[0]
179    
180                start, min, endMax, right = _range.GetRange()
181    
182                class0 = quantiles[3][0]
183                min = _list[class0[0]]
184                oldp = class0[1]
185                i = 1
186                end = "]"
187    
188                for (q, p) in quantiles[3][1:]:
189                    prop = ramp.GetProperties(float(i) / numGroups)
190    
191                    if i == numGroups:
192                        max = endMax
193                        end = right
194                    else:
195                        max = _list[q]
196    
197                    group = ClassGroupRange(Range((start, min, max, end)), prop)
198        
199                    group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
200                                                    round(p*100, 2)))
201                    oldp = p
202                    start = "]"
203                    min = max
204                    clazz.AppendGroup(group)
205                    i += 1
206    
207        return (adjusted, clazz, _list[class0[0]])
208    
209    
210    def calculate_quantiles(_list, percents, _range):
211      """Calculate quantiles for the given _list of percents from the      """Calculate quantiles for the given _list of percents from the
212      sorted list of values that are in range.      sorted list of values that are in range.
213                                                                                                                                                            
# Line 192  def CalculateQuantiles(_list, percents, Line 229  def CalculateQuantiles(_list, percents,
229      _list -- a sort list of values      _list -- a sort list of values
230    
231      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
232                  represent the upper bound of each quantile                  represent the upper bound of each quantile. the
233                    union of all percentiles should be the entire
234                    range from 0.0-1.0
235    
236      _range -- a Range object      _range -- a Range object
237    
238        Raises a Value Error if 'percents' has fewer than two items, or
239        does not cover the entire range.
240      """      """
241    
242      quantiles = []      quantiles = []
243      adjusted = False      adjusted = False
244    
245      if len(percents) != 0:      if len(percents) <= 1:
246                                                                                      raise ValueError("percents parameter must have more than one item")
247    
248        if percents[-1] != 1.0:
249            raise ValueError("percents does not cover the entire range")
250    
251        #
252        # find what part of the _list range covers
253        #
254        minIndex = -1
255        maxIndex = -2
256        for i in xrange(0, len(_list), 1):
257            if operator.contains(_range, _list[i]):
258                minIndex = i
259                break
260    
261        for i in xrange(len(_list)-1, -1, -1):
262            if operator.contains(_range, _list[i]):
263                maxIndex = i
264                break
265    
266        numValues = maxIndex - minIndex + 1
267    
268        if numValues > 0:
269    
270          #          #
271          # find what part of the _list range covers          # build a list of unique indices into list of where each
272            # quantile *should* be. set adjusted if the resulting
273            # indices are different
274          #          #
275          minIndex = -1          quantiles = {}
276          maxIndex = -2          for p in percents:
277          for i in xrange(0, len(_list), 1):              index = min(minIndex + int(p*numValues)-1, maxIndex)
278              if operator.contains(_range, _list[i]):  
279                  minIndex = i              adjusted = adjusted \
280                  break                  or quantiles.has_key(index) \
281                    or ((index - minIndex + 1) / float(numValues)) != p
282    
283          for i in xrange(len(_list)-1, -1, -1):              quantiles[index] = 0
             if operator.contains(_range, _list[i]):  
                 maxIndex = i  
                 break  
284    
285          numValues = maxIndex - minIndex + 1          quantiles = quantiles.keys()
286            quantiles.sort()
287    
288          if numValues > 0:          #
289            # the current quantile index must be strictly greater than
290            # the lowerBound
291            #
292            lowerBound = minIndex - 1
293    
294            for qindex in xrange(len(quantiles)):
295                if lowerBound >= maxIndex:
296                    # discard higher quantiles
297                    quantiles = quantiles[:qindex]
298                    break
299    
300                # lowerBound + 1 is always a valid index
301    
302              #              #
303              # build a list of unique indices into list of where each              # bump up the current quantile index to be a usable index
304              # quantile *should* be. set adjusted if the resulting              # if it currently falls below the lowerBound
             # indices are different  
305              #              #
306              quantiles = {}              if quantiles[qindex] <= lowerBound:
307              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  
308    
309              quantiles = quantiles.keys()              listIndex = quantiles[qindex]
310              quantiles.sort()              value = _list[listIndex]
311    
312              #              #
313              # the current quantile index must be strictly greater than              # look for similar values around the quantile index
             # the lowerBound  
314              #              #
315              lowerBound = minIndex - 1              lindex = listIndex - 1
316                while lindex > lowerBound and value == _list[lindex]:
317              for qindex in xrange(len(quantiles)):                  lindex -= 1
318                  if lowerBound >= maxIndex:              lcount = (listIndex - 1) - lindex
319                      # discard higher quantiles  
320                      quantiles = quantiles[:qindex]              rindex = listIndex + 1
321                      break              while rindex < maxIndex + 1 and value == _list[rindex]:
322                    rindex += 1
323                  # lowerBound + 1 is always a valid index              rcount = (listIndex + 1) - rindex
   
                 #  
                 # bump up the current quantile index to be a usable index  
                 # if it currently falls below the lowerBound  
                 #  
                 if quantiles[qindex] <= lowerBound:  
                     quantiles[qindex] = lowerBound + 1  
       
                 listIndex = quantiles[qindex]  
                 value = _list[listIndex]  
324    
325                  #              #
326                  # look for similar values around the quantile index              # adjust the current quantile index based on how many
327                  #              # numbers in the _list are the same as the current value
328                  lindex = listIndex - 1              #
329                  while lindex > lowerBound and value == _list[lindex]:              newIndex = listIndex
330                      lindex -= 1              if lcount == rcount:
331                  lcount = (listIndex - 1) - lindex                  if lcount != 0:
332                        #
333                  rindex = listIndex + 1                      # there are an equal number of numbers to the left
334                  while rindex < maxIndex + 1 and value == _list[rindex]:                      # and right, try going to the left first unless
                     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  
335                      # doing so creates an empty quantile.                      # doing so creates an empty quantile.
336                        #
337                      if lindex != lowerBound:                      if lindex != lowerBound:
338                          newIndex = lindex                          newIndex = lindex
339                      else:                      else:
340                          newIndex = rindex - 1                          newIndex = rindex - 1
341    
342                  elif rcount < lcount:              elif lcount < rcount:
343                      # there are fewer items to the right, so go to the right                  # there are fewer items to the left, so
344                    # try going to the left first unless
345                    # doing so creates an empty quantile.
346                    if lindex != lowerBound:
347                        newIndex = lindex
348                    else:
349                      newIndex = rindex - 1                      newIndex = rindex - 1
350    
351                  adjusted = adjusted or newIndex != listIndex              elif rcount < lcount:
352                    # there are fewer items to the right, so go to the right
353                    newIndex = rindex - 1
354    
355                adjusted = adjusted or newIndex != listIndex
356    
357                  quantiles[qindex] = newIndex              quantiles[qindex] = newIndex
358                  lowerBound = quantiles[qindex]              lowerBound = quantiles[qindex]
359    
360      if len(quantiles) == 0:      if len(quantiles) == 0:
361          return None          return None
# Line 318  def CalculateQuantiles(_list, percents, Line 364  def CalculateQuantiles(_list, percents,
364                  [(q, (q - minIndex+1) / float(numValues)) \                  [(q, (q - minIndex+1) / float(numValues)) \
365                   for q in quantiles])                   for q in quantiles])
366    
 CLR  = 0  
 STEP = 1  
367  class CustomRamp:  class CustomRamp:
368    
369      def __init__(self, prop1, prop2):      def __init__(self, prop1, prop2):
370          self.prop1 = prop1          self.prop1 = prop1
371          self.prop2 = prop2          self.prop2 = prop2
372    
         self.count = 0  
   
     def __iter__(self):  
         return self  
   
373      def GetRamp(self):      def GetRamp(self):
374          return self          return self
375    
376      def SetNumGroups(self, num):      def GetProperties(self, index):
377            """Return a ClassGroupProperties object whose properties
378          if num <= 0:          represent a point at 'index' between prop1 and prop2 in
379              return False          the constructor.
380    
381          self.count = int(num)          index -- a value such that 0 <= index <= 1
382          num = float(num)          """
383    
384          prop1 = self.prop1          if not (0 <= index <= 1):
385          prop2 = self.prop2              raise ValueError(_("invalid index"))
386    
387          clr = prop1.GetLineColor()          newProps = ClassGroupProperties()
388          lineColor2 = prop2.GetLineColor()  
389                    color1 = self.prop1.GetLineColor()
390          self.noLine = clr is not Color.Transparent \          color2 = self.prop2.GetLineColor()
391                          and lineColor2 is not Color.Transparent  
392            self.__SetProperty(color1, color2, index, newProps.SetLineColor)
393            self.__SetProperty(color1, color2, index, newProps.SetFill)
394          self.lineInfo = self.__GetColorInfo(prop1.GetLineColor(),  
395                                              prop2.GetLineColor(),          w = (self.prop2.GetLineWidth() - self.prop1.GetLineWidth()) \
396                                              num)              * index \
397                + self.prop1.GetLineWidth()
398          self.fillInfo = self.__GetColorInfo(prop1.GetFill(),  
399                                              prop2.GetFill(),          newProps.SetLineWidth(int(round(w)))
400                                              num)  
401            return newProps
402          self.lineWidth = prop1.GetLineWidth()  
403          self.lineWidthStep = (prop2.GetLineWidth() - self.lineWidth) / num      def __SetProperty(self, color1, color2, index, setf):
404    
405          return True          if color1 is Transparent and color2 is Transparent:
406                setf(Transparent)
407      def next(self):          elif color1 is Transparent:
408          if self.count == 0:              setf(Color(
409              raise StopIteration                   color2.red   * index,
410                     color2.green * index,
411          prop = ClassGroupProperties()                   color2.blue  * index))
412            elif color2 is Transparent:
413          if self.lineInfo is None:              setf(Color(
414              prop.SetLineColor(Color.Transparent)                   color1.red   * index,
415          else:                   color1.green * index,
416              prop.SetLineColor(Color(self.lineInfo[CLR][0] / 255,                   color1.blue  * index))
                                     self.lineInfo[CLR][1] / 255,  
                                     self.lineInfo[CLR][2] / 255))  
   
             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)  
417          else:          else:
418              prop.SetFill(Color(self.fillInfo[CLR][0] / 255,              setf(Color(
419                              self.fillInfo[CLR][1] / 255,                  (color2.red   - color1.red)   * index + color1.red,
420                              self.fillInfo[CLR][2] / 255))                  (color2.green - color1.green) * index + color1.green,
421                    (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  
   
         self.count -= 1  
   
         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)  
   
   
         return (color, step)  
422    
423  class MonochromaticRamp(CustomRamp):  class MonochromaticRamp(CustomRamp):
424      def __init__(self, start, end):      def __init__(self, start, end):
# Line 441  class MonochromaticRamp(CustomRamp): Line 432  class MonochromaticRamp(CustomRamp):
432    
433          CustomRamp.__init__(self, sp, ep)          CustomRamp.__init__(self, sp, ep)
434    
435  class GreyRamp(MonochromaticRamp):  GreyRamp       = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, 0))
436      def __init__(self):  RedRamp        = MonochromaticRamp(Color(1, 1, 1),  Color(.8, 0, 0))
437          MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))  GreenRamp      = MonochromaticRamp(Color(1, 1, 1),  Color(0, .8, 0))
438    BlueRamp       = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, .8))
439  class RedRamp(MonochromaticRamp):  GreenToRedRamp = MonochromaticRamp(Color(1, .8, 1), 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))  
440    
441  class HotToColdRamp:  class HotToColdRamp:
442    
     def __iter__(self):  
         return self  
           
443      def GetRamp(self):      def GetRamp(self):
444          return self          return self
445    
446      def SetNumGroups(self, num):      def GetProperties(self, index):
447          if num < 0:          """Return a ClassGroupProperties object whose properties
448              return False          represent a point at 'index' between "hot" and "cold".
449    
450          self.num = float(num)          index -- a value such that 0 <= index <= 1
451          self.index = 0          """
   
         return True  
   
     def next(self):  
         if self.index == self.num:  
             raise StopIteration  
452    
453          clr = [1.0, 1.0, 1.0]          clr = [1.0, 1.0, 1.0]
454    
455          if self.index < (.25 * self.num):          if index < .25:
456              clr[0] = 0              clr[0] = 0
457              clr[1] = 4 * self.index / self.num              clr[1] = 4 * index
458          elif self.index < (.5 * self.num):          elif index < .5:
459              clr[0] = 0              clr[0] = 0
460              clr[2] = 1 + 4 * (.25 * self.num - self.index) / self.num              clr[2] = 1 + 4 * (.25 - index)
461          elif self.index < (.75 * self.num):          elif index < .75:
462              clr[0] = 4 * (self.index - .5 * self.num) / self.num              clr[0] = 4 * (index - .5)
463              clr[2] = 0              clr[2] = 0
464          else:          else:
465              clr[1] = 1 + 4 * (.75 * self.num - self.index) / self.num              clr[1] = 1 + 4 * (.75 - index)
466              clr[2] = 0              clr[2] = 0
467    
         self.index += 1  
   
468          prop = ClassGroupProperties()          prop = ClassGroupProperties()
469          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))
470          prop.SetFill(Color(clr[0], clr[1], clr[2]))          prop.SetFill(Color(clr[0], clr[1], clr[2]))
471    
472          return prop          return prop
473    
 #class Colors16Ramp:  
 #  
     #def __iter__(self):  
         #return self  
 #  
     #def GetRamp(self):  
         #return self  
 #  
     #def SetNumGroups(self, num):  
         #if num < 0:  
             #return False  
 #  
         #self.index = 0  
 #  
         #return True  
Legend:
Removed from v.1098  
changed lines
  Added in v.1352
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26