/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/classgen.py
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 834 by bh, Tue May 6 15:52:36 2003 UTC revision 1341 by jonathan, Tue Jul 1 16:10:42 2003 UTC
# Line 11  from Thuban import _ Line 11  from Thuban import _
11    
12  from wxPython.wx import *  from wxPython.wx import *
13    
14  from Thuban.Model.classification import Classification, ClassGroupRange, \  from Thuban.Model.classification import ClassGroupProperties
     ClassGroupSingleton, ClassGroupProperties  
15    
16  from Thuban.Model.table import Table, FIELDTYPE_INT, FIELDTYPE_DOUBLE, \  from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
17       FIELDTYPE_STRING       FIELDTYPE_STRING
18    
19  from Thuban.Model.color import Color  from Thuban.Model.range import Range
20    from Thuban.UI.common import ThubanBeginBusyCursor, ThubanEndBusyCursor
21    
22  import classifier  import classifier, resource
23    
24  import resource  from Thuban.Model.classgen import \
25        generate_uniform_distribution, generate_singletons, generate_quantiles, \
26  ID_CLASSGEN_GENCOMBO = 4007      CustomRamp, GreyRamp, RedRamp, GreenRamp, BlueRamp, GreenToRedRamp, \
27  ID_CLASSGEN_PROPCOMBO = 4008      HotToColdRamp
28    
29  USEALL_BMP  = "group_use_all"  USEALL_BMP  = "group_use_all"
30  USE_BMP     = "group_use"  USE_BMP     = "group_use"
# Line 33  USENONE_BMP = "group_use_none" Line 33  USENONE_BMP = "group_use_none"
33    
34  GENCOMBOSTR_UNIFORM = _("Uniform Distribution")  GENCOMBOSTR_UNIFORM = _("Uniform Distribution")
35  GENCOMBOSTR_UNIQUE = _("Unique Values")  GENCOMBOSTR_UNIQUE = _("Unique Values")
36    GENCOMBOSTR_QUANTILES = _("Quantiles from Table")
37    
38  PROPCOMBOSTR_CUSTOM     = _("Custom Ramp")  PROPCOMBOSTR_CUSTOM     = _("Custom Ramp")
39  PROPCOMBOSTR_GREY       = _("Grey Ramp")  PROPCOMBOSTR_GREY       = _("Grey Ramp")
40  PROPCOMBOSTR_RED        = _("Red Ramp")  PROPCOMBOSTR_RED        = _("Red Ramp")
41  PROPCOMBOSTR_GREEN      = _("Green Ramp")  PROPCOMBOSTR_GREEN      = _("Green Ramp")
42  PROPCOMBOSTR_BLUE       = _("Blue Ramp")  PROPCOMBOSTR_BLUE       = _("Blue Ramp")
43    PROPCOMBOSTR_GREEN2RED  = _("Green-to-Red Ramp")
44  PROPCOMBOSTR_HOT2COLD   = _("Hot-to-Cold Ramp")  PROPCOMBOSTR_HOT2COLD   = _("Hot-to-Cold Ramp")
45    
46    ID_CLASSGEN_GENCOMBO = 4007
47    ID_CLASSGEN_PROPCOMBO = 4008
48    
49  class ClassGenDialog(wxDialog):  class ClassGenDialog(wxDialog):
50    
51      def __init__(self, parent, layer, fieldName):      def __init__(self, parent, layer, fieldName):
# Line 53  class ClassGenDialog(wxDialog): Line 58  class ClassGenDialog(wxDialog):
58                            style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)                            style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
59    
60          self.parent = parent          self.parent = parent
61            self.layer = layer
62          self.clazz = None          self.clazz = None
63    
64          col = layer.table.Column(fieldName)          col = layer.ShapeStore().Table().Column(fieldName)
65          self.type = col.type          self.type = col.type
66    
67            self.fieldName = fieldName
68            self.fieldType = self.type
69    
70            self.curGenPanel = None
71    
72            self.genpanels = []
73    
74          #############          #############
75          # we need to create genButton first because when we create the          # we need to create genButton first because when we create the
76          # panels they will call AllowGenerate() which uses genButton.          # panels they will call AllowGenerate() which uses genButton.
77          #          #
78          self.genButton = wxButton(self, wxID_OK, _("Generate"))          self.genButton = wxButton(self, wxID_OK, _("Generate"))
79            self.cancelButton = wxButton(self, wxID_CANCEL, _("Close"))
80          self.genButton.SetDefault()          self.genButton.SetDefault()
81    
82          self.genChoice = wxChoice(self, ID_CLASSGEN_GENCOMBO)          self.genChoice = wxChoice(self, ID_CLASSGEN_GENCOMBO)
83    
84          uniq_panel = GenUniquePanel(self, layer, fieldName, self.type)          self.genpanels.append((GENCOMBOSTR_UNIQUE, GenUniquePanel))
   
         self.genPanel = uniq_panel  
         self.genChoice.Append(GENCOMBOSTR_UNIQUE, uniq_panel)  
   
85          if self.type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):          if self.type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):
86              uni_panel = GenUniformPanel(self, layer, fieldName, self.type)              self.genpanels.append((GENCOMBOSTR_UNIFORM, GenUniformPanel))
87              self.genChoice.Append(GENCOMBOSTR_UNIFORM, uni_panel)              self.genpanels.append((GENCOMBOSTR_QUANTILES, GenQuantilesPanel))
88    
89            for name, clazz in self.genpanels:
90                self.genChoice.Append(name, [clazz, None])
91    
92          self.genChoice.SetSelection(0)          self.genChoice.SetSelection(0)
93    
94          self.propPanel = None          for i in range(self.genChoice.GetCount()):
95          custom_ramp_panel = CustomRampPanel(self, layer.ShapeType())              clazz, obj = self.genChoice.GetClientData(i)
96    
97          self.propCombo = wxChoice(self, ID_CLASSGEN_PROPCOMBO)              if obj is None:
98          self.propCombo.Append(PROPCOMBOSTR_GREY,  GreyRamp())                  obj = clazz(self, self.layer, self.fieldName, self.fieldType)
99          self.propCombo.Append(PROPCOMBOSTR_RED,   RedRamp())                  obj.Hide()
100          self.propCombo.Append(PROPCOMBOSTR_GREEN, GreenRamp())                  self.genChoice.SetClientData(i, [clazz, obj])
         self.propCombo.Append(PROPCOMBOSTR_BLUE,  BlueRamp())  
         self.propCombo.Append(PROPCOMBOSTR_HOT2COLD,  HotToColdRamp())  
         self.propCombo.Append(PROPCOMBOSTR_CUSTOM, custom_ramp_panel)  
101    
         self.propCombo.SetSelection(0)  
102    
103          #############          #############
104    
# Line 108  class ClassGenDialog(wxDialog): Line 117  class ClassGenDialog(wxDialog):
117          psizer.Add(self.genChoice, 1, wxALL | wxGROW, 4)          psizer.Add(self.genChoice, 1, wxALL | wxGROW, 4)
118    
119          sizer.Add(psizer, 0, wxALL | wxGROW, 4)          sizer.Add(psizer, 0, wxALL | wxGROW, 4)
         sizer.Add(self.genPanel, 1, wxGROW | wxALL, 4)  
120    
121          sizer.Show(uniq_panel, True)          self.sizer_genPanel = wxBoxSizer(wxVERTICAL)
122          if self.type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):          sizer.Add(self.sizer_genPanel, 1, wxGROW | wxALL, 4)
             sizer.Add(uni_panel, 1, wxGROW | wxALL, 4)  
             sizer.Show(uni_panel, False)  
123    
124          psizer = wxBoxSizer(wxHORIZONTAL)          psizer = wxBoxSizer(wxHORIZONTAL)
125          psizer.Add(wxStaticText(self, -1, _("Color Scheme:")),          psizer.Add(wxStaticText(self, -1, _("Color Scheme:")),
126              0, wxALIGN_CENTER_VERTICAL, 0)              0, wxALIGN_CENTER_VERTICAL, 0)
127    
128            # Properties (Ramp) ComboBox
129            self.propCombo = wxChoice(self, ID_CLASSGEN_PROPCOMBO)
130    
131            self.propPanel = None
132            custom_ramp_panel = CustomRampPanel(self, layer.ShapeType())
133    
134            self.propCombo.Append(PROPCOMBOSTR_GREY,  GreyRamp)
135            self.propCombo.Append(PROPCOMBOSTR_RED,   RedRamp)
136            self.propCombo.Append(PROPCOMBOSTR_GREEN, GreenRamp)
137            self.propCombo.Append(PROPCOMBOSTR_BLUE,  BlueRamp)
138            self.propCombo.Append(PROPCOMBOSTR_GREEN2RED, GreenToRedRamp)
139            self.propCombo.Append(PROPCOMBOSTR_HOT2COLD,  HotToColdRamp())
140            self.propCombo.Append(PROPCOMBOSTR_CUSTOM, custom_ramp_panel)
141    
142            self.propCombo.SetSelection(0)
143    
144          psizer.Add(self.propCombo, 1, wxALL | wxGROW, 4)          psizer.Add(self.propCombo, 1, wxALL | wxGROW, 4)
145          sizer.Add(psizer, 0, wxALL | wxGROW, 4)          sizer.Add(psizer, 0, wxALL | wxGROW, 4)
146    
147          sizer.Add(custom_ramp_panel, 1, wxGROW | wxALL, 4)          sizer.Add(custom_ramp_panel, 1, wxGROW | wxALL, 4)
148          sizer.Show(custom_ramp_panel, False)          sizer.Show(custom_ramp_panel, False)
149    
150            # Finally place the main buttons
151          buttonSizer = wxBoxSizer(wxHORIZONTAL)          buttonSizer = wxBoxSizer(wxHORIZONTAL)
152          buttonSizer.Add(self.genButton, 0, wxALL, 4)          buttonSizer.Add(self.genButton, 0, wxRIGHT|wxEXPAND, 10)
153          buttonSizer.Add(60, 20, 0, wxALL, 4)          buttonSizer.Add(self.cancelButton, 0, wxRIGHT|wxEXPAND, 10)
154          buttonSizer.Add(wxButton(self, wxID_CANCEL, _("Close")),          sizer.Add(buttonSizer, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
                         0, wxALL, 4)  
         sizer.Add(buttonSizer, 0,  
                   wxALL | wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL, 4)  
155    
156          self.SetSizer(sizer)          self.SetSizer(sizer)
157          self.SetAutoLayout(True)          self.SetAutoLayout(True)
158          sizer.SetSizeHints(self)          sizer.SetSizeHints(self)
159    
160          self.sizer = sizer          self.topBox = sizer
161    
162            self.__DoOnGenTypeSelect()
163    
164          EVT_CHOICE(self, ID_CLASSGEN_GENCOMBO, self._OnGenTypeSelect)          EVT_CHOICE(self, ID_CLASSGEN_GENCOMBO, self._OnGenTypeSelect)
165          EVT_CHOICE(self, ID_CLASSGEN_PROPCOMBO, self._OnPropTypeSelect)          EVT_CHOICE(self, ID_CLASSGEN_PROPCOMBO, self._OnPropTypeSelect)
166          EVT_BUTTON(self, wxID_OK, self.OnOK)          EVT_BUTTON(self, wxID_OK, self.OnOK)
167          EVT_BUTTON(self, wxID_CANCEL, self.OnCancel)          EVT_BUTTON(self, wxID_CANCEL, self.OnCancel)
168    
169            self.__DoOnGenTypeSelect()
170    
171          self.genChoice.SetFocus()          self.genChoice.SetFocus()
172    
# Line 159  class ClassGenDialog(wxDialog): Line 183  class ClassGenDialog(wxDialog):
183    
184          index = self.genChoice.GetSelection()          index = self.genChoice.GetSelection()
185    
186            assert index != -1, "button should be disabled!"
187    
188          genSel = self.genChoice.GetString(index)          genSel = self.genChoice.GetString(index)
189          genPanel = self.genChoice.GetClientData(index)          clazz, genPanel = self.genChoice.GetClientData(index)
190    
191          propPanel = self.propPanel          propPanel = self.propPanel
192    
193          if genSel in (GENCOMBOSTR_UNIFORM, GENCOMBOSTR_UNIQUE):          if genSel in (GENCOMBOSTR_UNIFORM,          \
194                          GENCOMBOSTR_UNIQUE,           \
195                          GENCOMBOSTR_QUANTILES):
196    
197              numGroups = genPanel.GetNumGroups()              numGroups = genPanel.GetNumGroups()
198    
199              index = self.propCombo.GetSelection()              index = self.propCombo.GetSelection()
# Line 183  class ClassGenDialog(wxDialog): Line 212  class ClassGenDialog(wxDialog):
212                      and max is not None \                      and max is not None \
213                      and numGroups is not None:                      and numGroups is not None:
214    
215                      self.clazz = ClassGenerator().GenUnifromDistribution(                      self.clazz = generate_uniform_distribution(
216                                  min, max, numGroups, ramp,                                  min, max, numGroups, ramp,
217                                  self.type == FIELDTYPE_INT)                                  self.type == FIELDTYPE_INT)
218    
# Line 193  class ClassGenDialog(wxDialog): Line 222  class ClassGenDialog(wxDialog):
222    
223                  list = genPanel.GetValueList()                  list = genPanel.GetValueList()
224    
225                  if len(list) > 0 \                  if len(list) > 0:
226                      and numGroups is not None:                      self.clazz = generate_singletons(list, ramp)
227                        self.parent._SetClassification(self.clazz)
228    
229                      self.clazz = ClassGenerator().GenSingletonsFromList(              elif genSel == GENCOMBOSTR_QUANTILES:
                                     list, numGroups, ramp)  
230    
231                    _range = genPanel.GetRange()
232                    _list = genPanel.GetList()
233                    _list.sort()
234    
235                    delta = 1 / float(numGroups)
236                    percents = [delta * i for i in range(1, numGroups + 1)]
237                    adjusted, self.clazz = \
238                        generate_quantiles(_list, percents, ramp, _range)
239    
240                    if adjusted:
241                        dlg = wxMessageDialog(self,
242                            _("Based on the data from the table and the input\n" +
243                              "values, the exact quantiles could not be generated.\n\n" +
244                              "Accept a close estimate?"),
245                            _("Problem with Quantiles"),
246    
247                            wxYES_NO|wxYES_DEFAULT|wxICON_QUESTION)
248                        if dlg.ShowModal() == wxID_YES:
249                            self.parent._SetClassification(self.clazz)
250                    else:
251                      self.parent._SetClassification(self.clazz)                      self.parent._SetClassification(self.clazz)
252    
253      def OnCancel(self, event):      def OnCancel(self, event):
254          self.Close()          self.Close()
255    
256      def _OnGenTypeSelect(self, event):      def _OnGenTypeSelect(self, event):
257            self.__DoOnGenTypeSelect()
258            return
259    
260          combo = event.GetEventObject()          combo = event.GetEventObject()
261    
262          selIndex = combo.GetSelection()          selIndex = combo.GetSelection()
263    
264          if self.genPanel is not None:          if self.genPanel is not None:
265              self.sizer.Show(self.genPanel, False)              self.topBox.Show(self.genPanel, False)
266    
267          self.genPanel = combo.GetClientData(selIndex)          self.genPanel = combo.GetClientData(selIndex)
268          if self.genPanel is not None:          if self.genPanel is not None:
269              self.sizer.Show(self.genPanel, True)              self.topBox.Show(self.genPanel, True)
270    
271          self.sizer.SetSizeHints(self)          self.topBox.SetSizeHints(self)
272          self.sizer.Layout()          self.topBox.Layout()
273    
274      def _OnPropTypeSelect(self, event):      def _OnPropTypeSelect(self, event):
275          combo = event.GetEventObject()          combo = event.GetEventObject()
# Line 227  class ClassGenDialog(wxDialog): Line 278  class ClassGenDialog(wxDialog):
278          sel = combo.GetString(selIndex)          sel = combo.GetString(selIndex)
279    
280          if isinstance(self.propPanel, wxPanel):          if isinstance(self.propPanel, wxPanel):
281              self.sizer.Show(self.propPanel, False)              self.topBox.Show(self.propPanel, False)
282    
283          self.propPanel = combo.GetClientData(selIndex)          self.propPanel = combo.GetClientData(selIndex)
284    
285          if isinstance(self.propPanel, wxPanel):          if isinstance(self.propPanel, wxPanel):
286              self.sizer.Show(self.propPanel, True)              self.topBox.Show(self.propPanel, True)
287    
288            self.topBox.SetSizeHints(self)
289            self.topBox.Layout()
290    
291          self.sizer.SetSizeHints(self)      def __DoOnGenTypeSelect(self):
292          self.sizer.Layout()          choice = self.genChoice
293    
294            sel = choice.GetSelection()
295            if sel == -1: return
296    
297            clazz, obj = choice.GetClientData(sel)
298    
299            if self.curGenPanel is not None:
300                self.curGenPanel.Hide()
301                self.sizer_genPanel.Remove(self.curGenPanel)
302    
303            self.curGenPanel = obj
304            self.curGenPanel.Show()
305    
306            self.sizer_genPanel.Add(self.curGenPanel, 1,
307                wxALL|wxEXPAND|wxADJUST_MINSIZE, 3)
308            self.sizer_genPanel.Layout()
309            self.Layout()
310            self.topBox.SetSizeHints(self)
311    
312  ID_UNIFORM_MIN = 4001  ID_UNIFORM_MIN = 4001
313  ID_UNIFORM_MAX = 4002  ID_UNIFORM_MAX = 4002
# Line 430  class GenUniformPanel(wxPanel): Line 501  class GenUniformPanel(wxPanel):
501              self.parent.AllowGenerate(False)              self.parent.AllowGenerate(False)
502    
503      def _OnRetrieve(self, event):      def _OnRetrieve(self, event):
504            table = self.layer.ShapeStore().Table()
505          if self.layer.table is not None:          if table is not None:
506              wxBeginBusyCursor()              ThubanBeginBusyCursor()
507              min, max = self.layer.table.ValueRange(self.fieldName)              try:
508              self.minCtrl.SetValue(str(min))                  min, max = table.ValueRange(self.fieldName)
509              self.maxCtrl.SetValue(str(max))                  self.minCtrl.SetValue(str(min))
510              wxEndBusyCursor()                  self.maxCtrl.SetValue(str(max))
511                finally:
512                    ThubanEndBusyCursor()
513    
514      def __GetValidatedTypeEntry(self, win, value, type, badValue = None):      def __GetValidatedTypeEntry(self, win, value, type, badValue = None):
515    
# Line 478  class GenUniformPanel(wxPanel): Line 551  class GenUniformPanel(wxPanel):
551          return valid          return valid
552    
553      def __CalcStepping(self, min, max, ngroups):      def __CalcStepping(self, min, max, ngroups):
         step = (max - min) / float(ngroups)  
554          if self.fieldType == FIELDTYPE_INT:          if self.fieldType == FIELDTYPE_INT:
555              step = int(step)              step = int((max - min + 1) / float(ngroups))
556            else:
557                step = (max - min) / float(ngroups)
558    
559          return step          return step
560    
# Line 597  class GenUniquePanel(wxPanel): Line 671  class GenUniquePanel(wxPanel):
671          self.SetAutoLayout(True)          self.SetAutoLayout(True)
672          topSizer.SetSizeHints(self)          topSizer.SetSizeHints(self)
673    
674          self.parent.AllowGenerate(False)          width, height = self.list_avail.GetSizeTuple()
675            self.list_avail.SetColumnWidth(0,width)
676            width, height = self.list_use.GetSizeTuple()
677            self.list_use.SetColumnWidth(0,width)
678    
679          self.mylist = ["Hallo", "Welt!", "Wie", "geht", "es", "dir", "?"]          self.parent.AllowGenerate(False)
680    
681      def GetNumGroups(self):      def GetNumGroups(self):
682          return self.list_use.GetItemCount()          return self.list_use.GetItemCount()
# Line 640  class GenUniquePanel(wxPanel): Line 717  class GenUniquePanel(wxPanel):
717          self.list_avail.DeleteAllItems()          self.list_avail.DeleteAllItems()
718          self.list_avail_data = []          self.list_avail_data = []
719    
720          list = self.layer.table.UniqueValues(self.fieldName)          ThubanBeginBusyCursor()
721          index = 0          try:
722          for v in list:              list = self.layer.ShapeStore().Table().UniqueValues(self.fieldName)
723              self.dataList.append(v)              index = 0
724              i = self.list_avail.InsertStringItem(index, str(v))              for v in list:
725              self.list_avail.SetItemData(index, i)                  self.dataList.append(v)
726                    i = self.list_avail.InsertStringItem(index, str(v))
727              self.list_avail_data.append(v)                  self.list_avail.SetItemData(index, i)
728              index += 1      
729                    self.list_avail_data.append(v)
730                    index += 1
731            finally:
732                ThubanEndBusyCursor()
733    
734      def _OnUseAll(self, event):      def _OnUseAll(self, event):
735          for i in range(self.list_avail.GetItemCount()):          for i in range(self.list_avail.GetItemCount()):
# Line 695  class GenUniquePanel(wxPanel): Line 776  class GenUniquePanel(wxPanel):
776  #       list.SetColumnWidth(0, event.GetSize().GetWidth())  #       list.SetColumnWidth(0, event.GetSize().GetWidth())
777  #        #      
778    
779    ID_QUANTILES_RANGE = 4001
780    ID_QUANTILES_RETRIEVE = 4002
781    
782    class GenQuantilesPanel(wxPanel):
783    
784        def __init__(self, parent, layer, fieldName, fieldType):
785            wxPanel.__init__(self, parent, -1)
786    
787            self.parent = parent
788            self.layer = layer
789            self.fieldName = fieldName
790            self.fieldType = fieldType
791    
792            topBox = wxStaticBoxSizer(wxStaticBox(self, -1, ""),
793                                        wxVERTICAL)
794    
795            self.text_range = wxTextCtrl(self, ID_QUANTILES_RANGE, "")
796            self.button_retrieve = wxButton(self, ID_QUANTILES_RETRIEVE,
797                                            _("Retrieve from Table"))
798    
799            self.spin_numClasses = wxSpinCtrl(self, -1, style=wxTE_RIGHT)
800            self.spin_numClasses.SetRange(1, sys.maxint)
801            self.spin_numClasses.SetValue(1)
802    
803    
804            sizer = wxBoxSizer(wxHORIZONTAL)
805            sizer.Add(wxStaticText(self, -1, _("Apply to Range")), 0, wxALL, 4)
806            sizer.Add(self.text_range, 1, wxALL, 4)
807            sizer.Add(self.button_retrieve, 0, wxALL, 4)
808    
809            topBox.Add(sizer, 0, wxEXPAND, 0)
810    
811            sizer = wxBoxSizer(wxHORIZONTAL)
812            sizer.Add(wxStaticText(self, -1, _("Number of Classes:")), 0, wxALL, 4)
813            sizer.Add(self.spin_numClasses, 1, wxALL, 4)
814    
815            topBox.Add(sizer, 0, wxEXPAND, 0)
816    
817            self.SetSizer(topBox)
818            self.SetAutoLayout(True)
819            topBox.Fit(self)
820            topBox.SetSizeHints(self)
821    
822            EVT_TEXT(self, ID_QUANTILES_RANGE, self.OnRangeText)
823            EVT_BUTTON(self, ID_QUANTILES_RETRIEVE, self.OnRetrieve)
824    
825            self.__range = None
826    
827        def GetNumGroups(self):
828            return self.spin_numClasses.GetValue()
829    
830        def GetRange(self):
831            assert self.__range is not None
832    
833            return self.__range
834    
835        def GetList(self):
836            _list = []
837            table = self.layer.ShapeStore().Table()
838            if table is not None:
839                ThubanBeginBusyCursor()
840                try:
841                    #
842                    # FIXME: Replace with a call to table when the method
843                    # has been written to get all the values
844                    #
845                    for i in range(table.NumRows()):
846                        _list.append(table.ReadValue(i, self.fieldName))
847                finally:
848                    ThubanEndBusyCursor()
849    
850            return _list
851    
852        def OnRangeText(self, event):
853    
854            try:
855                self.__range = Range(self.text_range.GetValue())
856            except ValueError:
857                self.__range = None
858    
859            if self.__range is not None:
860                self.text_range.SetForegroundColour(wxBLACK)
861            else:
862                self.text_range.SetForegroundColour(wxRED)
863    
864        def OnRetrieve(self, event):
865            table = self.layer.ShapeStore().Table()
866            if table is not None:
867                ThubanBeginBusyCursor()
868                try:
869                    min, max = table.ValueRange(self.fieldName)
870                    self.text_range.SetValue("[" + str(min) + ";" + str(max) + "]")
871                finally:
872                    ThubanEndBusyCursor()
873    
874  ID_CUSTOMRAMP_COPYSTART = 4001  ID_CUSTOMRAMP_COPYSTART = 4001
875  ID_CUSTOMRAMP_COPYEND = 4002  ID_CUSTOMRAMP_COPYEND = 4002
876  ID_CUSTOMRAMP_EDITSTART = 4003  ID_CUSTOMRAMP_EDITSTART = 4003
# Line 783  class CustomRampPanel(wxPanel): Line 959  class CustomRampPanel(wxPanel):
959      def _OnEditEnd(self, event):      def _OnEditEnd(self, event):
960          self.endPropCtrl.DoEdit()          self.endPropCtrl.DoEdit()
961    
962  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  
         for prop in ramp:  
   
             if i == (numGroups - 1):  
                 cur_max = max  
   
             # this check guards against rounding issues  
             if cur_min != cur_max:  
                 clazz.AppendGroup(ClassGroupRange(cur_min, cur_max, prop))  
   
             cur_min = cur_max  
             cur_max += step  
             i += 1  
   
         return clazz  
   
 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 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  
   
       
Legend:
Removed from v.834  
changed lines
  Added in v.1341
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26