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