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

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

Parent Directory | Revision Log | View Patch Patch

-revision 895 by jonathan,
Mon May 12 11:21:02 2003 UTC
+revision 1759 by bh,
Fri Sep 26 18:36:01 2003 UTC
 Line 5
  # This program is free software under the GPL (>=v2)
  # Read the file COPYING coming with Thuban for details.
+ """
+ Functions to generate Classifications
+ """
+ __version__ = "$Revision$"
+ # $Source$
+ # $Id$
  import operator
- from color import Color
+ from color import Color, Transparent
  from range import Range
  from classification import Classification, ClassGroupSingleton, \
      ClassGroupRange, ClassGroupProperties
- class ClassGenerator:
+ def generate_singletons(_list, ramp):
+     """Generate a new classification consisting solely of singletons.
-     def GenSingletonsFromList(self, _list, numGroups, ramp):
+     The resulting classification will consist of one group for each
-         """Generate a new classification consisting solely of singletons.
+     item in _list whose properties ramp between 'prop1' and 'prop2'.
-         The resulting classification will consist of at most 'numGroups'
+     _list -- a list of values for each singleton
-         groups whose group properties ramp between 'prop1' and 'prop2'. There
-         could be fewer groups if '_list' contains fewer that 'numGroups' items.
-         _list -- any object that implements the iterator interface
+     ramp -- an object which implements the CustomRamp interface
+     """
-         numGroups -- how many groups to generate. This can not be
+     clazz = Classification()
-                      determined while the classification is being
-                      generated because the stepping values must
-                      be precalculated to ramp between prop1 and prop2.
-         prop1 -- initial group property values
+     i = 0
+     maxValue = float(len(_list) - 1)
+     if maxValue < 1: maxValue = 1
-         prop2 -- final group property values
+     for value in _list:
-         """
+         prop = ramp.GetProperties(i / maxValue)
+         clazz.AppendGroup(ClassGroupSingleton(value, prop))
+         i += 1
-         clazz = Classification()
+     return clazz
-         if numGroups == 0: return clazz
-         ramp.SetNumGroups(numGroups)
+ def generate_uniform_distribution(min, max, numGroups, ramp, intStep = False):
+     """Generate a classification with numGroups range groups
+     each with the same interval.
-         for value, prop in zip(_list, ramp):
+     intStep -- force the calculated stepping to an integer.
-             clazz.AppendGroup(ClassGroupSingleton(value, prop))
+                Useful if the values are integers but the
+                number of groups specified doesn't evenly
+                divide (max - min).
+     """
-         return clazz
+     clazz = Classification()
-     def GenSingletons(self, min, max, numGroups, ramp):
+     cur_min = min
-         clazz = Classification()
+     end = "["
+     maxValue = float(numGroups - 1)
+     if maxValue < 1: maxValue = 1
-         #step = int((max - min) / float(numGroups))
+     for i in range(1, numGroups + 1):
-         if numGroups > 0:
+         prop = ramp.GetProperties(float(i-1) / maxValue)
-             step = int((max - min + 1) / float(numGroups))
+         if intStep:
-             cur_value = min
+             cur_max = min + int(round((i * (max - min + 1)) / float(numGroups)))
+         else:
+             cur_max = min + (i * (max - min)) / float(numGroups)
-             ramp.SetNumGroups(numGroups)
+         if i == numGroups:
+             cur_max = max
+             end = "]"
-             for prop in ramp:
+         if cur_min == cur_max:
-                 clazz.AppendGroup(ClassGroupSingleton(cur_value), prop)
+             _range = Range(("[", cur_min, cur_max, "]"))
-                 cur_value += step
+         else:
+             _range = Range(("[", cur_min, cur_max, end))
-         return clazz
+         clazz.AppendGroup(ClassGroupRange(_range, prop))
-     def GenUnifromDistribution(self, min, max, numGroups,
+         cur_min = cur_max
-                                ramp, intStep = False):
-         """Generate a classification with numGroups range groups
-         each with the same interval.
-         intStep -- force the calculated stepping to an integer.
+     return clazz
-                    Useful if the values are integers but the
-                    number of groups specified doesn't evenly
-                    divide (max - min).
-         """
-         clazz = Classification()
+ def generate_quantiles(_list, percents, ramp, _range):
-         if numGroups == 0: return clazz
+     """Generates a Classification which has groups of ranges that
+     represent quantiles of _list at the percentages given in percents.
+     Only the values that fall within _range are considered.
-         ramp.SetNumGroups(numGroups)
+     Returns a tuple (adjusted, Classification) where adjusted is
+     True if the Classification does not exactly represent the given
+     range, or if the Classification is empty.
-         step = (max - min) / float(numGroups)
+     _list -- a sort list of values
-         if intStep:
+     percents -- a sorted list of floats in the range 0.0-1.0 which
-             step = int(step)
+                 represent the upper bound of each quantile. the
+                 union of all percentiles should be the entire
+                 range from 0.0-1.0
-         cur_min = min
+     ramp -- an object which implements the CustomRamp interface
-         cur_max = cur_min + step
-         i = 0
+     _range -- a Range object
-         end = "["
-         for prop in ramp:
-             if i == (numGroups - 1):
+     Raises a Value Error if 'percents' has fewer than two items, or
-                 cur_max = max
+     does not cover the entire range.
-                 end = "]"
+     """
+     clazz = Classification()
+     quantiles = calculate_quantiles(_list, percents, _range)
+     adjusted = True
-             # this check guards against rounding issues
+     if quantiles is not None:
-             if cur_min != cur_max:
-                 range = Range("[" + str(float(cur_min)) + ";" +
-                                     str(float(cur_max)) + end)
-                 clazz.AppendGroup(ClassGroupRange(range, None, prop))
-             cur_min = cur_max
+         numGroups = len(quantiles[3])
-             cur_max += step
-             i += 1
-         return clazz
+         if numGroups != 0:
+             adjusted = quantiles[0]
-     def GenQuantiles(self, _list, percents, ramp, _range):
+             start, min, endMax, right = _range.GetRange()
-         """Generates a Classification which has groups of ranges that
-         represent quantiles of _list at the percentages given in percents.
-         Only the values that fall within _range are considered.
-         Returns a tuple (adjusted, Classification) where adjusted is
+             oldp = 0
-         True if the Classification does not exactly represent the given
+             i = 1
-         range, or if the Classification is empty.
+             end = "]"
-         _list -- a sort list of values
+             maxValue = float(numGroups - 1)
+             if maxValue < 1: maxValue = 1
+             for (q, p) in quantiles[3]:
-         percents -- a sorted list of floats in the range 0.0-1.0 which
+                 prop = ramp.GetProperties(float(i-1) / maxValue)
-                     represent the upper bound of each quantile
-         ramp -- an object which implements the CustomRamp interface
+                 if i == numGroups:
+                     max = endMax
+                     end = right
+                 else:
+                     max = _list[q]
-         _range -- a Range object
+                 group = ClassGroupRange(Range((start, min, max, end)), prop)
-         """
+                 group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
+                                                 round(p*100, 2)))
+                 oldp = p
+                 start = "]"
+                 min = max
+                 clazz.AppendGroup(group)
+                 i += 1
+     return (adjusted, clazz)
+ def calculate_quantiles(_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.
+     _list -- a sort list of values
+     percents -- a sorted list of floats in the range 0.0-1.0 which
+                 represent the upper bound of each quantile. the
+                 union of all percentiles should be the entire
+                 range from 0.0-1.0
+     _range -- a Range object
+     Raises a Value Error if 'percents' has fewer than two items, or
+     does not cover the entire range.
+     """
+     quantiles = []
+     adjusted = False
+     if len(percents) <= 1:
+         raise ValueError("percents parameter must have more than one item")
+     if percents[-1] != 1.0:
+         raise ValueError("percents does not cover the entire range")
+     #
+     # 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
-         clazz = Classification()
+     numValues = maxIndex - minIndex + 1
-         quantiles = self.CalculateQuantiles(_list, percents, _range)
-         adjusted = True
-         if quantiles is not None:
+     if numValues > 0:
-             numGroups = len(quantiles[3])
+         #
+         # 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
-             if numGroups != 0:
+             quantiles[index] = 0
-                 adjusted = quantiles[0]
+         quantiles = quantiles.keys()
+         quantiles.sort()
-                 ramp.SetNumGroups(numGroups)
+         #
+         # the current quantile index must be strictly greater than
+         # the lowerBound
+         #
+         lowerBound = minIndex - 1
-                 min = _list[quantiles[1]]
+         for qindex in xrange(len(quantiles)):
-                 start = "["
+             if lowerBound >= maxIndex:
-                 oldp = 0
+                 # discard higher quantiles
-                 for (q, p), prop in zip(quantiles[3], ramp):
+                 quantiles = quantiles[:qindex]
-                     max = _list[q]
+                 break
-                     group = ClassGroupRange(Range(start + str(min) + ";" +
-                                                           str(max) + "]"),
-                                             None, prop)
-                     group.SetLabel("%s%% - %s%%" % (round(oldp*100, 2),
-                                                     round(p*100, 2)))
-                     oldp = p
-                     start = "]"
-                     min = max
-                     clazz.AppendGroup(group)
-         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.
-         _list -- a sort list of values
+             # lowerBound + 1 is always a valid index
-         percents -- a sorted list of floats in the range 0.0-1.0 which
+             #
-                     represent the upper bound of each quantile
+             # 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
-         _range -- a Range object
+             listIndex = quantiles[qindex]
-         """
+             value = _list[listIndex]
-         quantiles = []
-         adjusted = False
-         if len(percents) != 0:
              #
-             # find what part of the _list range covers
+             # look for similar values around the quantile index
              #
-             minIndex = -1
+             lindex = listIndex - 1
-             maxIndex = -2
+             while lindex > lowerBound and value == _list[lindex]:
-             for i in xrange(0, len(_list), 1):
+                 lindex -= 1
-                 if operator.contains(_range, _list[i]):
+             lcount = (listIndex - 1) - lindex
-                     minIndex = i
-                     break
+             rindex = listIndex + 1
+             while rindex < maxIndex + 1 and value == _list[rindex]:
-             for i in xrange(len(_list)-1, -1, -1):
+                 rindex += 1
-                 if operator.contains(_range, _list[i]):
+             rcount = (listIndex + 1) - rindex
-                     maxIndex = i
-                     break
+             #
+             # adjust the current quantile index based on how many
-             numValues = maxIndex - minIndex + 1
+             # numbers in the _list are the same as the current value
+             #
-             if numValues > 0:
+             newIndex = listIndex
+             if lcount == rcount:
-                 #
+                 if lcount != 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
+                     # there are an equal number of numbers to the left
-                     # numbers in the _list are the same as the current value
+                     # and right, try going to the left first unless
+                     # doing so creates an empty quantile.
                      #
-                     newIndex = listIndex
+                     if lindex != lowerBound:
-                     if lcount == rcount:
+                         newIndex = lindex
-                         if lcount != 0:
+                     else:
-                             #
-                             # 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
-                     quantiles[qindex] = newIndex
+             elif lcount < rcount:
-                     lowerBound = quantiles[qindex]
+                 # there are fewer items to the left, so
+                 # try going to the left first unless
-         #
+                 # doing so creates an empty quantile.
-         # since quantiles is only set if the code is at least a little
+                 if lindex != lowerBound:
-         # successful, an empty list will be generated in the case that
+                     newIndex = lindex
-         # we fail to get to the real body of the algorithm
+                 else:
-         #
+                     newIndex = rindex - 1
-         if len(quantiles) == 0:
-             return None
+             elif rcount < lcount:
-         else:
+                 # there are fewer items to the right, so go to the right
-             return (adjusted, minIndex, maxIndex,
+                 newIndex = rindex - 1
-                     [(q, (q - minIndex+1) / float(numValues)) \
-                      for q in quantiles])
+             adjusted = adjusted or newIndex != listIndex
+             quantiles[qindex] = newIndex
+             lowerBound = quantiles[qindex]
+     if len(quantiles) == 0:
+         return None
+     else:
+         return (adjusted, minIndex, maxIndex,
+                 [(q, (q - minIndex+1) / float(numValues)) \
+                  for q in quantiles])
- CLR  = 0
- STEP = 1
  class CustomRamp:
      def __init__(self, prop1, prop2):
+         """Create a ramp between prop1 and prop2."""
          self.prop1 = prop1
          self.prop2 = prop2
-         self.count = 0
-     def __iter__(self):
-         return self
      def GetRamp(self):
+         """Return this ramp."""
          return self
-     def SetNumGroups(self, num):
+     def GetProperties(self, index):
+         """Return a ClassGroupProperties object whose properties
-         if num <= 0:
+         represent a point at 'index' between prop1 and prop2 in
-             return False
+         the constructor.
-         self.count = int(num)
+         index -- a value such that 0 <= index <= 1
-         num = float(num)
+         """
-         prop1 = self.prop1
-         prop2 = self.prop2
-         clr = prop1.GetLineColor()
-         lineColor2 = prop2.GetLineColor()
-         self.noLine = clr is not Color.Transparent \
-                         and lineColor2 is not Color.Transparent
-         self.lineInfo = self.__GetColorInfo(prop1.GetLineColor(),
-                                             prop2.GetLineColor(),
-                                             num)
-         self.fillInfo = self.__GetColorInfo(prop1.GetFill(),
-                                             prop2.GetFill(),
-                                             num)
-         self.lineWidth = prop1.GetLineWidth()
-         self.lineWidthStep = (prop2.GetLineWidth() - self.lineWidth) / num
-         return True
-     def next(self):
+         if not (0 <= index <= 1):
-         if self.count == 0:
+             raise ValueError(_("invalid index"))
-             raise StopIteration
-         prop = ClassGroupProperties()
+         newProps = ClassGroupProperties()
-         if self.lineInfo is None:
+         self.__SetProperty(self.prop1.GetLineColor(),
-             prop.SetLineColor(Color.Transparent)
+                            self.prop2.GetLineColor(),
-         else:
+                            index, newProps.SetLineColor)
-             prop.SetLineColor(Color(self.lineInfo[CLR][0] / 255,
+         self.__SetProperty(self.prop1.GetFill(), self.prop2.GetFill(),
-                                     self.lineInfo[CLR][1] / 255,
+                            index, newProps.SetFill)
-                                     self.lineInfo[CLR][2] / 255))
+         w = (self.prop2.GetLineWidth() - self.prop1.GetLineWidth()) \
-             self.lineInfo[CLR][0] += self.lineInfo[STEP][0]
+             * index \
-             self.lineInfo[CLR][1] += self.lineInfo[STEP][1]
+             + self.prop1.GetLineWidth()
-             self.lineInfo[CLR][2] += self.lineInfo[STEP][2]
+         newProps.SetLineWidth(int(round(w)))
+         return newProps
+     def __SetProperty(self, color1, color2, index, setf):
+         """Use setf to set the appropriate property for the point
+         index percent between color1 and color2. setf is a function
+         to call that accepts a Color object or Transparent.
+         """
-         if self.fillInfo is None:
+         if color1 is Transparent and color2 is Transparent:
-             prop.SetFill(Color.Transparent)
+             setf(Transparent)
+         elif color1 is Transparent:
+             setf(Color(
+                  color2.red   * index,
+                  color2.green * index,
+                  color2.blue  * index))
+         elif color2 is Transparent:
+             setf(Color(
+                  color1.red   * index,
+                  color1.green * index,
+                  color1.blue  * index))
          else:
-             prop.SetFill(Color(self.fillInfo[CLR][0] / 255,
+             setf(Color(
-                             self.fillInfo[CLR][1] / 255,
+                 (color2.red   - color1.red)   * index + color1.red,
-                             self.fillInfo[CLR][2] / 255))
+                 (color2.green - color1.green) * index + color1.green,
+                 (color2.blue  - color1.blue)  * index + color1.blue))
-             self.fillInfo[CLR][0] += self.fillInfo[STEP][0]
+ class MonochromaticRamp(CustomRamp):
-             self.fillInfo[CLR][1] += self.fillInfo[STEP][1]
+     """Helper class to make ramps between two colors."""
-             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)
+     def __init__(self, start, end):
+         """Create a Monochromatic Ramp.
-         return (color, step)
+         start -- starting Color
- class MonochromaticRamp(CustomRamp):
+         end -- ending Color
-     def __init__(self, start, end):
+         """
          sp = ClassGroupProperties()
          sp.SetLineColor(start)
          sp.SetFill(start)
-Line 435 
 class MonochromaticRamp(CustomRamp):
+Line 391 
 class MonochromaticRamp(CustomRamp):
          CustomRamp.__init__(self, sp, ep)
- class GreyRamp(MonochromaticRamp):
+ grey_ramp         = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, 0))
-     def __init__(self):
+ red_ramp          = MonochromaticRamp(Color(1, 1, 1),  Color(.8, 0, 0))
-         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))
+ green_ramp        = MonochromaticRamp(Color(1, 1, 1),  Color(0, .8, 0))
+ blue_ramp         = MonochromaticRamp(Color(1, 1, 1),  Color(0, 0, .8))
- class RedRamp(MonochromaticRamp):
+ green_to_red_ramp = MonochromaticRamp(Color(0, .8, 0), Color(1, 0, 0))
-     def __init__(self):
-         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(.8, 0, 0))
- class GreenRamp(MonochromaticRamp):
-     def __init__(self):
-         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, .8, 0))
- class BlueRamp(MonochromaticRamp):
-     def __init__(self):
-         MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, .8))
- class GreenToRedRamp(MonochromaticRamp):
-     def __init__(self):
-         MonochromaticRamp.__init__(self, Color(0, .8, 0), Color(1, 0, 0))
  class HotToColdRamp:
+     """A ramp that generates properties with colors ranging from
+     'hot' colors (e.g. red, orange) to 'cold' colors (e.g. green, blue)
+     """
-     def __iter__(self):
-         return self
      def GetRamp(self):
+         """Return this ramp."""
          return self
-     def SetNumGroups(self, num):
+     def GetProperties(self, index):
-         if num < 0:
+         """Return a ClassGroupProperties object whose properties
-             return False
+         represent a point at 'index' between "hot" and "cold".
-         self.num = float(num)
+         index -- a value such that 0 <= index <= 1
-         self.index = 0
+         """
-         return True
-     def next(self):
-         if self.index == self.num:
-             raise StopIteration
          clr = [1.0, 1.0, 1.0]
-         if self.index < (.25 * self.num):
+         if index < .25:
              clr[0] = 0
-             clr[1] = 4 * self.index / self.num
+             clr[1] = 4 * index
-         elif self.index < (.5 * self.num):
+         elif index < .5:
              clr[0] = 0
-             clr[2] = 1 + 4 * (.25 * self.num - self.index) / self.num
+             clr[2] = 1 + 4 * (.25 - index)
-         elif self.index < (.75 * self.num):
+         elif index < .75:
-             clr[0] = 4 * (self.index - .5 * self.num) / self.num
+             clr[0] = 4 * (index - .5)
              clr[2] = 0
          else:
-             clr[1] = 1 + 4 * (.75 * self.num - self.index) / self.num
+             clr[1] = 1 + 4 * (.75 - index)
              clr[2] = 0
-         self.index += 1
          prop = ClassGroupProperties()
          prop.SetLineColor(Color(clr[0], clr[1], clr[2]))
          prop.SetFill(Color(clr[0], clr[1], clr[2]))
          return prop
- #class Colors16Ramp:
+ class FixedRamp:
- #
+     """FixedRamp allows particular properties of a ramp to be
-     #def __iter__(self):
+     held constant over the ramp.
-         #return self
+     """
- #
-     #def GetRamp(self):
+     def __init__(self, ramp, fixes):
-         #return self
+         """
- #
+         ramp -- a source ramp to get the default properties
-     #def SetNumGroups(self, num):
-         #if num < 0:
+         fixes -- a tuple (lineColor, lineWidth, fillColor) such that
-             #return False
+              if any item is not None, the appropriate property will
- #
+              be fixed to that item value.
-         #self.index = 0
+         """
- #
-         #return True
+         self.fixes = fixes
+         self.ramp = ramp
+     def GetRamp(self):
+         """Return this ramp."""
+         return self
+     def GetProperties(self, index):
+         """Return a ClassGroupProperties object whose properties
+         represent a point at 'index' between the properties in
+         the ramp that initialized this FixedRamp.
+         index -- a value such that 0 <= index <= 1
+         """
+         props = self.ramp.GetProperties(index)
+         if self.fixes[0] is not None: props.SetLineColor(self.fixes[0])
+         if self.fixes[1] is not None: props.SetLineWidth(self.fixes[1])
+         if self.fixes[2] is not None: props.SetFill(self.fixes[2])
+         return props

 Legend:



Removed from v.895
 


changed lines


 
Added in v.1759
 Legend:



Removed from v.895
 


changed lines


 
Added in v.1759
-Removed from v.895
+Added in v.1759

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26