/[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 1335 by jonathan, Tue Jul 1 16:09:09 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, None, 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
# Line 170  def GenQuantiles(_list, percents, ramp, Line 145  def GenQuantiles(_list, percents, ramp,
145    
146      return (adjusted, clazz)      return (adjusted, clazz)
147    
148  def CalculateQuantiles(_list, percents, _range):  def GenQuantiles0(_list, percents, ramp, _range):
149        """Same as GenQuantiles, but the first class won't be added to
150        the classification.
151    
152        Returns a tuple (adjusted, Classification, upper_class0) where
153        upper_class0 is the highest value inside the first class.
154    
155        _list -- a sort list of values
156    
157        percents -- a sorted list of floats in the range 0.0-1.0 which
158                    represent the upper bound of each quantile. the
159                    union of all percentiles should be the entire
160                    range from 0.0-1.0
161    
162        ramp -- an object which implements the CustomRamp interface
163    
164        _range -- a Range object
165    
166        Raises a Value Error if 'percents' has fewer than two items, or
167        does not cover the entire range.
168        """
169    
170        clazz = Classification()
171        quantiles = calculate_quantiles(_list, percents, _range)
172        adjusted = True
173    
174        if quantiles is not None:
175    
176            numGroups = len(quantiles[3]) - 1
177    
178            if numGroups > 0:
179                adjusted = quantiles[0]
180    
181                start, min, endMax, right = _range.GetRange()
182    
183                class0 = quantiles[3][0]
184                min = _list[class0[0]]
185                oldp = class0[1]
186                i = 1
187                end = "]"
188    
189                for (q, p) in quantiles[3][1:]:
190                    prop = ramp.GetProperties(float(i) / numGroups)
191    
192                    if i == numGroups:
193                        max = endMax
194                        end = right
195                    else:
196                        max = _list[q]
197    
198                    group = ClassGroupRange(Range((start, min, max, end)),
199                                            None, prop)
200        
201                    group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
202                                                    round(p*100, 2)))
203                    oldp = p
204                    start = "]"
205                    min = max
206                    clazz.AppendGroup(group)
207                    i += 1
208    
209        return (adjusted, clazz, _list[class0[0]])
210    
211    
212    def calculate_quantiles(_list, percents, _range):
213      """Calculate quantiles for the given _list of percents from the      """Calculate quantiles for the given _list of percents from the
214      sorted list of values that are in range.      sorted list of values that are in range.
215                                                                                                                                                            
# Line 192  def CalculateQuantiles(_list, percents, Line 231  def CalculateQuantiles(_list, percents,
231      _list -- a sort list of values      _list -- a sort list of values
232    
233      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
234                  represent the upper bound of each quantile                  represent the upper bound of each quantile. the
235                    union of all percentiles should be the entire
236                    range from 0.0-1.0
237    
238      _range -- a Range object      _range -- a Range object
239    
240        Raises a Value Error if 'percents' has fewer than two items, or
241        does not cover the entire range.
242      """      """
243    
244      quantiles = []      quantiles = []
245      adjusted = False      adjusted = False
246    
247      if len(percents) != 0:      if len(percents) <= 1:
248                                                                                      raise ValueError("percents parameter must have more than one item")
249    
250        if percents[-1] != 1.0:
251            raise ValueError("percents does not cover the entire range")
252    
253        #
254        # find what part of the _list range covers
255        #
256        minIndex = -1
257        maxIndex = -2
258        for i in xrange(0, len(_list), 1):
259            if operator.contains(_range, _list[i]):
260                minIndex = i
261                break
262    
263        for i in xrange(len(_list)-1, -1, -1):
264            if operator.contains(_range, _list[i]):
265                maxIndex = i
266                break
267    
268        numValues = maxIndex - minIndex + 1
269    
270        if numValues > 0:
271    
272          #          #
273          # find what part of the _list range covers          # build a list of unique indices into list of where each
274            # quantile *should* be. set adjusted if the resulting
275            # indices are different
276          #          #
277          minIndex = -1          quantiles = {}
278          maxIndex = -2          for p in percents:
279          for i in xrange(0, len(_list), 1):              index = min(minIndex + int(p*numValues)-1, maxIndex)
280              if operator.contains(_range, _list[i]):  
281                  minIndex = i              adjusted = adjusted \
282                  break                  or quantiles.has_key(index) \
283                    or ((index - minIndex + 1) / float(numValues)) != p
284    
285          for i in xrange(len(_list)-1, -1, -1):              quantiles[index] = 0
286              if operator.contains(_range, _list[i]):  
287                  maxIndex = i          quantiles = quantiles.keys()
288                  break          quantiles.sort()
289    
290            #
291            # the current quantile index must be strictly greater than
292            # the lowerBound
293            #
294            lowerBound = minIndex - 1
295    
296          numValues = maxIndex - minIndex + 1          for qindex in xrange(len(quantiles)):
297                if lowerBound >= maxIndex:
298                    # discard higher quantiles
299                    quantiles = quantiles[:qindex]
300                    break
301    
302          if numValues > 0:              # lowerBound + 1 is always a valid index
303    
304              #              #
305              # build a list of unique indices into list of where each              # bump up the current quantile index to be a usable index
306              # quantile *should* be. set adjusted if the resulting              # if it currently falls below the lowerBound
             # indices are different  
307              #              #
308              quantiles = {}              if quantiles[qindex] <= lowerBound:
309              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  
310    
311                  quantiles[index] = 0              listIndex = quantiles[qindex]
312                value = _list[listIndex]
             quantiles = quantiles.keys()  
             quantiles.sort()  
313    
314              #              #
315              # the current quantile index must be strictly greater than              # look for similar values around the quantile index
             # the lowerBound  
316              #              #
317              lowerBound = minIndex - 1              lindex = listIndex - 1
318                while lindex > lowerBound and value == _list[lindex]:
319              for qindex in xrange(len(quantiles)):                  lindex -= 1
320                  if lowerBound >= maxIndex:              lcount = (listIndex - 1) - lindex
321                      # discard higher quantiles  
322                      quantiles = quantiles[:qindex]              rindex = listIndex + 1
323                      break              while rindex < maxIndex + 1 and value == _list[rindex]:
324                    rindex += 1
325                  # 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]  
326    
327                  #              #
328                  # look for similar values around the quantile index              # adjust the current quantile index based on how many
329                  #              # numbers in the _list are the same as the current value
330                  lindex = listIndex - 1              #
331                  while lindex > lowerBound and value == _list[lindex]:              newIndex = listIndex
332                      lindex -= 1              if lcount == rcount:
333                  lcount = (listIndex - 1) - lindex                  if lcount != 0:
334                        #
335                  rindex = listIndex + 1                      # there are an equal number of numbers to the left
336                  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  
337                      # doing so creates an empty quantile.                      # doing so creates an empty quantile.
338                        #
339                      if lindex != lowerBound:                      if lindex != lowerBound:
340                          newIndex = lindex                          newIndex = lindex
341                      else:                      else:
342                          newIndex = rindex - 1                          newIndex = rindex - 1
343    
344                  elif rcount < lcount:              elif lcount < rcount:
345                      # there are fewer items to the right, so go to the right                  # there are fewer items to the left, so
346                    # try going to the left first unless
347                    # doing so creates an empty quantile.
348                    if lindex != lowerBound:
349                        newIndex = lindex
350                    else:
351                      newIndex = rindex - 1                      newIndex = rindex - 1
352    
353                  adjusted = adjusted or newIndex != listIndex              elif rcount < lcount:
354                    # there are fewer items to the right, so go to the right
355                    newIndex = rindex - 1
356    
357                  quantiles[qindex] = newIndex              adjusted = adjusted or newIndex != listIndex
358                  lowerBound = quantiles[qindex]  
359                quantiles[qindex] = newIndex
360                lowerBound = quantiles[qindex]
361    
362      if len(quantiles) == 0:      if len(quantiles) == 0:
363          return None          return None
# Line 318  def CalculateQuantiles(_list, percents, Line 366  def CalculateQuantiles(_list, percents,
366                  [(q, (q - minIndex+1) / float(numValues)) \                  [(q, (q - minIndex+1) / float(numValues)) \
367                   for q in quantiles])                   for q in quantiles])
368    
 CLR  = 0  
 STEP = 1  
369  class CustomRamp:  class CustomRamp:
370    
371      def __init__(self, prop1, prop2):      def __init__(self, prop1, prop2):
372          self.prop1 = prop1          self.prop1 = prop1
373          self.prop2 = prop2          self.prop2 = prop2
374    
         self.count = 0  
   
     def __iter__(self):  
         return self  
   
375      def GetRamp(self):      def GetRamp(self):
376          return self          return self
377    
378      def SetNumGroups(self, num):      def GetProperties(self, index):
379            """Return a ClassGroupProperties object whose properties
380          if num <= 0:          represent a point at 'index' between prop1 and prop2 in
381              return False          the constructor.
382    
383          self.count = int(num)          index -- a value such that 0 <= index <= 1
384          num = float(num)          """
385    
386          prop1 = self.prop1          if not (0 <= index <= 1):
387          prop2 = self.prop2              raise ValueError(_("invalid index"))
388    
389          clr = prop1.GetLineColor()          newProps = ClassGroupProperties()
390          lineColor2 = prop2.GetLineColor()  
391                    color1 = self.prop1.GetLineColor()
392          self.noLine = clr is not Color.Transparent \          color2 = self.prop2.GetLineColor()
393                          and lineColor2 is not Color.Transparent  
394            self.__SetProperty(color1, color2, index, newProps.SetLineColor)
395            self.__SetProperty(color1, color2, index, newProps.SetFill)
396          self.lineInfo = self.__GetColorInfo(prop1.GetLineColor(),  
397                                              prop2.GetLineColor(),          w = (self.prop2.GetLineWidth() - self.prop1.GetLineWidth()) \
398                                              num)              * index \
399                + self.prop1.GetLineWidth()
400          self.fillInfo = self.__GetColorInfo(prop1.GetFill(),  
401                                              prop2.GetFill(),          newProps.SetLineWidth(int(round(w)))
402                                              num)  
403            return newProps
404          self.lineWidth = prop1.GetLineWidth()  
405          self.lineWidthStep = (prop2.GetLineWidth() - self.lineWidth) / num      def __SetProperty(self, color1, color2, index, setf):
406    
407          return True          if color1 is Transparent and color2 is Transparent:
408                setf(Transparent)
409      def next(self):          elif color1 is Transparent:
410          if self.count == 0:              setf(Color(
411              raise StopIteration                   color2.red   * index,
412                     color2.green * index,
413          prop = ClassGroupProperties()                   color2.blue  * index))
414            elif color2 is Transparent:
415          if self.lineInfo is None:              setf(Color(
416              prop.SetLineColor(Color.Transparent)                   color1.red   * index,
417          else:                   color1.green * index,
418              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)  
419          else:          else:
420              prop.SetFill(Color(self.fillInfo[CLR][0] / 255,              setf(Color(
421                              self.fillInfo[CLR][1] / 255,                  (color2.red   - color1.red)   * index + color1.red,
422                              self.fillInfo[CLR][2] / 255))                  (color2.green - color1.green) * index + color1.green,
423                    (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)  
424    
425  class MonochromaticRamp(CustomRamp):  class MonochromaticRamp(CustomRamp):
426      def __init__(self, start, end):      def __init__(self, start, end):
# Line 441  class MonochromaticRamp(CustomRamp): Line 434  class MonochromaticRamp(CustomRamp):
434    
435          CustomRamp.__init__(self, sp, ep)          CustomRamp.__init__(self, sp, ep)
436    
437  class GreyRamp(MonochromaticRamp):  GreyRamp       = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, 0))
438      def __init__(self):  RedRamp        = MonochromaticRamp(Color(1, 1, 1),  Color(.8, 0, 0))
439          MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))  GreenRamp      = MonochromaticRamp(Color(1, 1, 1),  Color(0, .8, 0))
440    BlueRamp       = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, .8))
441  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))  
442    
443  class HotToColdRamp:  class HotToColdRamp:
444    
     def __iter__(self):  
         return self  
           
445      def GetRamp(self):      def GetRamp(self):
446          return self          return self
447    
448      def SetNumGroups(self, num):      def GetProperties(self, index):
449          if num < 0:          """Return a ClassGroupProperties object whose properties
450              return False          represent a point at 'index' between "hot" and "cold".
451    
452          self.num = float(num)          index -- a value such that 0 <= index <= 1
453          self.index = 0          """
   
         return True  
   
     def next(self):  
         if self.index == self.num:  
             raise StopIteration  
454    
455          clr = [1.0, 1.0, 1.0]          clr = [1.0, 1.0, 1.0]
456    
457          if self.index < (.25 * self.num):          if index < .25:
458              clr[0] = 0              clr[0] = 0
459              clr[1] = 4 * self.index / self.num              clr[1] = 4 * index
460          elif self.index < (.5 * self.num):          elif index < .5:
461              clr[0] = 0              clr[0] = 0
462              clr[2] = 1 + 4 * (.25 * self.num - self.index) / self.num              clr[2] = 1 + 4 * (.25 - index)
463          elif self.index < (.75 * self.num):          elif index < .75:
464              clr[0] = 4 * (self.index - .5 * self.num) / self.num              clr[0] = 4 * (index - .5)
465              clr[2] = 0              clr[2] = 0
466          else:          else:
467              clr[1] = 1 + 4 * (.75 * self.num - self.index) / self.num              clr[1] = 1 + 4 * (.75 - index)
468              clr[2] = 0              clr[2] = 0
469    
         self.index += 1  
   
470          prop = ClassGroupProperties()          prop = ClassGroupProperties()
471          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))
472          prop.SetFill(Color(clr[0], clr[1], clr[2]))          prop.SetFill(Color(clr[0], clr[1], clr[2]))
473    
474          return prop          return prop
475    
 #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.1335
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26