Thuban/Model/classgen.py

# Copyright (c) 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

import operator

from color import Color
from range import Range
from classification import Classification, ClassGroupSingleton, \
    ClassGroupRange, ClassGroupProperties

class ClassGenerator:

    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.

        list -- any object that implements the iterator interface

        numGroups -- how many groups to generate. This can not be
                     determined while the classification is being
                     generated because the stepping values must
                     be precalculated to ramp between prop1 and prop2.

        prop1 -- initial group property values

        prop2 -- final group property values
        """

        clazz = Classification()
        if numGroups == 0: return clazz

        ramp.SetNumGroups(numGroups)

        for value, prop in zip(list, ramp):
            clazz.AppendGroup(ClassGroupSingleton(value, prop))

        return clazz

    def GenSingletons(self, min, max, numGroups, ramp):

        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 GenUnifromDistribution(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).
        """

        clazz = Classification()
        if numGroups == 0: return clazz

        ramp.SetNumGroups(numGroups)

        step = (max - min) / float(numGroups)

        if intStep:
            step = int(step)

        cur_min = min
        cur_max = cur_min + step

        i = 0
        end = "["
        for prop in ramp:

            if i == (numGroups - 1):
                cur_max = max
                end = "]"


            # this check guards against rounding issues
            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
            cur_max += step
            i += 1

        return clazz


    def GenQuantiles(self, list, percents, ramp, _range):
        clazz = Classification()
        quantiles = self.CalculateQuantiles(list, percents, _range)
        numGroups = len(quantiles[1])
        if numGroups == 0: return clazz

        ramp.SetNumGroups(numGroups)

        left, min, max, right = _range.GetRange()

        start = "["
        oldp = 0
        for (q, p), prop in zip(quantiles[1], ramp): 
            max = list[q]
            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 (quantiles[0], 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.
                                                                                
        percents is a sorted list of floats in the range 0.0-1.0

        This may not actually generate numGroups quantiles if
        many of the values that fall on quantile borders are the same.

        Returns a tuple of the form: (adjusted, [quantile_list])

        where adjusted is true if the the quantile percentages differ from
        those supplied, and quantile_list is a list of tuples of the form:
            (list_index, quantile_percentage)
        """
    
        quantiles = []
                                                                                
        adjusted = False
        if len(percents) != 0: 
                                                                               
            #
            # 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 minIndex <= maxIndex:

                #
                # 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 range(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] = min(lowerBound + 1, maxIndex)
        
                    listIndex = quantiles[qindex]
                    value = list[quantiles[qindex]]
    
                    #
                    # look for similar values around the quantile index
                    #
                    lindex = listIndex - 1
                    lcount = 0
                    while lindex > lowerBound:
                        if value != list[lindex]: break
                        lcount += 1
                        lindex -= 1
    
                    rindex = listIndex + 1
                    rcount = 0
                    while rindex < maxIndex + 1:
                        if value != list[rindex]: break
                        rcount += 1
                        rindex += 1
    
                    #
                    # 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
    
                    quantiles[qindex] = newIndex
                    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
        #
        return (adjusted, 
                [(q, (q - minIndex+1) / float(numValues)) for q in quantiles])

CLR  = 0
STEP = 1
class CustomRamp:

    def __init__(self, prop1, prop2):
        self.prop1 = prop1
        self.prop2 = prop2

        self.count = 0

    def __iter__(self):
        return self

    def GetRamp(self):
        return self

    def SetNumGroups(self, num):

        if num <= 0:
            return False

        self.count = int(num)
        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 self.count == 0:
            raise StopIteration

        prop = ClassGroupProperties()

        if self.lineInfo is None:
            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]

        if self.fillInfo is None:
            prop.SetFill(Color.Transparent)
        else:
            prop.SetFill(Color(self.fillInfo[CLR][0] / 255, 
                            self.fillInfo[CLR][1] / 255, 
                            self.fillInfo[CLR][2] / 255))

            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)

class MonochromaticRamp(CustomRamp):
    def __init__(self, start, end):
        sp = ClassGroupProperties()
        sp.SetLineColor(start)
        sp.SetFill(start)

        ep = ClassGroupProperties()
        ep.SetLineColor(end)
        ep.SetFill(end)

        CustomRamp.__init__(self, sp, ep)

class GreyRamp(MonochromaticRamp):
    def __init__(self):
        MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))

class RedRamp(MonochromaticRamp):
    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:

    def __iter__(self):
        return self
        
    def GetRamp(self):
        return self

    def SetNumGroups(self, num):
        if num < 0:
            return False

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