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: 
                                                                               
            #print "list:", list
            #print "percents:", percents
            #print "numGroups:", numGroups
    
            #
            # 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
            #print "minIndex:", minIndex, "maxIndex:", maxIndex
            if minIndex <= maxIndex:

                #
                # build a list of unique indices into list of where each
                # quantile should be
                #
                quantiles = {}
                for p in percents:
                    index = min(minIndex + int(p*numValues)-1, maxIndex)

                    adjusted = adjusted \
                        or quantiles.has_key(index) \
                        or ((index+1) / float(numValues)) != p

                    quantiles[index] = 0

                quantiles = quantiles.keys()
                quantiles.sort()

                #print "quantiles:", quantiles
    
                #
                # 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]]
    
                    #print "-----------------------------------"
                    #print "listIndex:", listIndex
                    #print "value:", value
    
                    #
                    # look for similar values around the quantile index
                    #
                
                    #print "lowerBound:", lowerBound
                    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
    
                    #print lcount, "(lcount)", rcount, "(rcount)"
                    #print lindex, "(lindex)", rindex, "(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
                                #quantiles[qindex] = lindex
                            else:
                                newIndex = rindex - 1
                                #quantiles[qindex] = 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
                            #quantiles[qindex] = lindex
                        else:
                            newIndex = rindex - 1
                            #quantiles[qindex] = rindex - 1
    
                    elif rcount < lcount:
                        # there are fewer items to the right, so go to the right
                        #quantiles[qindex] = rindex - 1
                        newIndex = rindex - 1
    
                    quantiles[qindex] = newIndex
                    lowerBound = quantiles[qindex]
    
                    #print "quantiles:", quantiles
                    #print "lowerBound:", lowerBound
        
                #print "================================="
                #print "quantiles:", quantiles
                #print "qindex:", qindex
    
        return (adjusted, [(q, (q+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	# 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	#print "list:", list
160	#print "percents:", percents
161	#print "numGroups:", numGroups
162
163	#
164	# find what part of the list range covers
165	#
166	minIndex = -1
167	maxIndex = -2
168	for i in xrange(0, len(list), 1):
169	if operator.contains(_range, list[i]):
170	minIndex = i
171	break
172
173	for i in xrange(len(list)-1, -1, -1):
174	if operator.contains(_range, list[i]):
175	maxIndex = i
176	break;
177
178	numValues = maxIndex - minIndex + 1
179	#print "minIndex:", minIndex, "maxIndex:", maxIndex
180	if minIndex <= maxIndex:
181
182	#
183	# build a list of unique indices into list of where each
184	# quantile should be
185	#
186	quantiles = {}
187	for p in percents:
188	index = min(minIndex + int(p*numValues)-1, maxIndex)
189
190	adjusted = adjusted \
191	or quantiles.has_key(index) \
192	or ((index+1) / float(numValues)) != p
193
194	quantiles[index] = 0
195
196	quantiles = quantiles.keys()
197	quantiles.sort()
198
199	#print "quantiles:", quantiles
200
201	#
202	# the current quantile index must be strictly greater than
203	# the lowerBound
204	#
205	lowerBound = minIndex - 1
206
207	for qindex in range(len(quantiles)):
208	if lowerBound >= maxIndex:
209	# discard higher quantiles
210	quantiles = quantiles[:qindex]
211	break
212
213	# lowerBound + 1 is always a valid index
214
215
216	#
217	# bump up the current quantile index to be a usable index
218	# if it currently falls below the lowerBound
219	#
220	if quantiles[qindex] <= lowerBound:
221	quantiles[qindex] = min(lowerBound + 1, maxIndex)
222
223	listIndex = quantiles[qindex]
224	value = list[quantiles[qindex]]
225
226	#print "-----------------------------------"
227	#print "listIndex:", listIndex
228	#print "value:", value
229
230	#
231	# look for similar values around the quantile index
232	#
233
234	#print "lowerBound:", lowerBound
235	lindex = listIndex - 1
236	lcount = 0
237	while lindex > lowerBound:
238	if value != list[lindex]: break
239	lcount += 1
240	lindex -= 1
241
242	rindex = listIndex + 1
243	rcount = 0
244	while rindex < maxIndex + 1:
245	if value != list[rindex]: break
246	rcount += 1
247	rindex += 1
248
249	#print lcount, "(lcount)", rcount, "(rcount)"
250	#print lindex, "(lindex)", rindex, "(rindex)"
251
252	#
253	# adjust the current quantile index based on how many
254	# numbers in the list are the same as the current value
255	#
256	newIndex = listIndex
257	if lcount == rcount:
258	if lcount != 0:
259	#
260	# there are an equal number of numbers to the left
261	# and right, try going to the left first unless
262	# doing so creates an empty quantile.
263	#
264	if lindex != lowerBound:
265	newIndex = lindex
266	#quantiles[qindex] = lindex
267	else:
268	newIndex = rindex - 1
269	#quantiles[qindex] = rindex - 1
270
271	elif lcount < rcount:
272	# there are fewer items to the left, so
273	# try going to the left first unless
274	# doing so creates an empty quantile.
275	if lindex != lowerBound:
276	newIndex = lindex
277	#quantiles[qindex] = lindex
278	else:
279	newIndex = rindex - 1
280	#quantiles[qindex] = rindex - 1
281
282	elif rcount < lcount:
283	# there are fewer items to the right, so go to the right
284	#quantiles[qindex] = rindex - 1
285	newIndex = rindex - 1
286
287	quantiles[qindex] = newIndex
288	lowerBound = quantiles[qindex]
289
290	#print "quantiles:", quantiles
291	#print "lowerBound:", lowerBound
292
293	#print "================================="
294	#print "quantiles:", quantiles
295	#print "qindex:", qindex
296
297	return (adjusted, [(q, (q+1) / float(numValues)) for q in quantiles])
298
299	CLR = 0
300	STEP = 1
301	class CustomRamp:
302
303	def __init__(self, prop1, prop2):
304	self.prop1 = prop1
305	self.prop2 = prop2
306
307	self.count = 0
308
309	def __iter__(self):
310	return self
311
312	def GetRamp(self):
313	return self
314
315	def SetNumGroups(self, num):
316
317	if num <= 0:
318	return False
319
320	self.count = int(num)
321	num = float(num)
322
323	prop1 = self.prop1
324	prop2 = self.prop2
325
326	clr = prop1.GetLineColor()
327	lineColor2 = prop2.GetLineColor()
328
329	self.noLine = clr is not Color.Transparent \
330	and lineColor2 is not Color.Transparent
331
332
333	self.lineInfo = self.__GetColorInfo(prop1.GetLineColor(),
334	prop2.GetLineColor(),
335	num)
336
337	self.fillInfo = self.__GetColorInfo(prop1.GetFill(),
338	prop2.GetFill(),
339	num)
340
341	self.lineWidth = prop1.GetLineWidth()
342	self.lineWidthStep = (prop2.GetLineWidth() - self.lineWidth) / num
343
344	return True
345
346	def next(self):
347	if self.count == 0:
348	raise StopIteration
349
350	prop = ClassGroupProperties()
351
352	if self.lineInfo is None:
353	prop.SetLineColor(Color.Transparent)
354	else:
355	prop.SetLineColor(Color(self.lineInfo[CLR][0] / 255,
356	self.lineInfo[CLR][1] / 255,
357	self.lineInfo[CLR][2] / 255))
358
359	self.lineInfo[CLR][0] += self.lineInfo[STEP][0]
360	self.lineInfo[CLR][1] += self.lineInfo[STEP][1]
361	self.lineInfo[CLR][2] += self.lineInfo[STEP][2]
362
363	if self.fillInfo is None:
364	prop.SetFill(Color.Transparent)
365	else:
366	prop.SetFill(Color(self.fillInfo[CLR][0] / 255,
367	self.fillInfo[CLR][1] / 255,
368	self.fillInfo[CLR][2] / 255))
369
370	self.fillInfo[CLR][0] += self.fillInfo[STEP][0]
371	self.fillInfo[CLR][1] += self.fillInfo[STEP][1]
372	self.fillInfo[CLR][2] += self.fillInfo[STEP][2]
373
374
375	prop.SetLineWidth(int(self.lineWidth))
376	self.lineWidth += self.lineWidthStep
377
378	self.count -= 1
379
380	return prop
381
382	def __GetColorInfo(self, color1, color2, numGroups):
383
384	if color1 is Color.Transparent and color2 is Color.Transparent:
385	#
386	# returning early
387	#
388	return None
389	elif color1 is not Color.Transparent and color2 is Color.Transparent:
390	color = [color1.red * 255,
391	color1.green * 255,
392	color1.blue * 255]
393	step = (0, 0, 0)
394	elif color1 is Color.Transparent and color2 is not Color.Transparent:
395	color = [color2.red * 255,
396	color2.green * 255,
397	color2.blue * 255]
398	step = (0, 0, 0)
399	else:
400	color = [color1.red * 255,
401	color1.green * 255,
402	color1.blue * 255]
403	step = ((color2.red * 255 - color1.red * 255) / numGroups,
404	(color2.green * 255 - color1.green * 255) / numGroups,
405	(color2.blue * 255 - color1.blue * 255) / numGroups)
406
407
408	return (color, step)
409
410	class MonochromaticRamp(CustomRamp):
411	def __init__(self, start, end):
412	sp = ClassGroupProperties()
413	sp.SetLineColor(start)
414	sp.SetFill(start)
415
416	ep = ClassGroupProperties()
417	ep.SetLineColor(end)
418	ep.SetFill(end)
419
420	CustomRamp.__init__(self, sp, ep)
421
422	class GreyRamp(MonochromaticRamp):
423	def __init__(self):
424	MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))
425
426	class RedRamp(MonochromaticRamp):
427	def __init__(self):
428	MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(.8, 0, 0))
429
430	class GreenRamp(MonochromaticRamp):
431	def __init__(self):
432	MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, .8, 0))
433
434	class BlueRamp(MonochromaticRamp):
435	def __init__(self):
436	MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, .8))
437
438	class GreenToRedRamp(MonochromaticRamp):
439	def __init__(self):
440	MonochromaticRamp.__init__(self, Color(0, .8, 0), Color(1, 0, 0))
441
442	class HotToColdRamp:
443
444	def __iter__(self):
445	return self
446
447	def GetRamp(self):
448	return self
449
450	def SetNumGroups(self, num):
451	if num < 0:
452	return False
453
454	self.num = float(num)
455	self.index = 0
456
457	return True
458
459	def next(self):
460	if self.index == self.num:
461	raise StopIteration
462
463	clr = [1.0, 1.0, 1.0]
464
465	if self.index < (.25 * self.num):
466	clr[0] = 0
467	clr[1] = 4 * self.index / self.num
468	elif self.index < (.5 * self.num):
469	clr[0] = 0
470	clr[2] = 1 + 4 * (.25 * self.num - self.index) / self.num
471	elif self.index < (.75 * self.num):
472	clr[0] = 4 * (self.index - .5 * self.num) / self.num
473	clr[2] = 0
474	else:
475	clr[1] = 1 + 4 * (.75 * self.num - self.index) / self.num
476	clr[2] = 0
477
478	self.index += 1
479
480	prop = ClassGroupProperties()
481	prop.SetLineColor(Color(clr[0], clr[1], clr[2]))
482	prop.SetFill(Color(clr[0], clr[1], clr[2]))
483
484	return prop
485
486	#class Colors16Ramp:
487	#
488	#def __iter__(self):
489	#return self
490	#
491	#def GetRamp(self):
492	#return self
493	#
494	#def SetNumGroups(self, num):
495	#if num < 0:
496	#return False
497	#
498	#self.index = 0
499	#
500	#return True
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision