/[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 629 by jonathan, Wed Apr 9 10:09:44 2003 UTC revision 2099 by bh, Thu Mar 11 20:45:03 2004 UTC
# Line 1  Line 1 
1  # Copyright (c) 2003 by Intevation GmbH  # Copyright (c) 2003, 2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]>
4  #  #
5  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
6  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
7    
8  from Thuban import _  """The Classification Generator Dialog"""
9    
10  from wxPython.wx import *  __version__ = "$Revision$"
11    # $Source$
12    # $Id$
13    
 from Thuban.Model.classification import Classification, ClassGroupRange, \  
     ClassGroupSingleton, ClassGroupProperties  
14    
15  from Thuban.Model.table import Table, FIELDTYPE_INT, FIELDTYPE_DOUBLE, \  import sys
16       FIELDTYPE_STRING  
17    from wxPython.wx import *
18    
19    from Thuban import _
20    
21  from Thuban.Model.color import Color  from Thuban.Model.classification import ClassGroupProperties
22    
23  import classifier  from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
24         FIELDTYPE_STRING
25    
26  from Thuban.common import Str2Num  from Thuban.Model.layer import SHAPETYPE_ARC
27    from Thuban.Model.range import Range
28    from Thuban.UI.common import ThubanBeginBusyCursor, ThubanEndBusyCursor
29    
30    import classifier, resource
31    
32    from Thuban.Model.classgen import \
33        generate_uniform_distribution, generate_singletons, generate_quantiles, \
34        CustomRamp, grey_ramp, red_ramp, green_ramp, blue_ramp, green_to_red_ramp, \
35        HotToColdRamp, FixedRamp
36    
37    
38    USEALL_BMP  = "group_use_all"
39    USE_BMP     = "group_use"
40    USENOT_BMP  = "group_use_not"
41    USENONE_BMP = "group_use_none"
42    
43    GENCOMBOSTR_UNIFORM = _("Uniform Distribution")
44    GENCOMBOSTR_UNIQUE = _("Unique Values")
45    GENCOMBOSTR_QUANTILES = _("Quantiles from Table")
46    
47    PROPCOMBOSTR_CUSTOM     = _("Custom Ramp")
48    PROPCOMBOSTR_GREY       = _("Grey Ramp")
49    PROPCOMBOSTR_RED        = _("Red Ramp")
50    PROPCOMBOSTR_GREEN      = _("Green Ramp")
51    PROPCOMBOSTR_BLUE       = _("Blue Ramp")
52    PROPCOMBOSTR_GREEN2RED  = _("Green-to-Red Ramp")
53    PROPCOMBOSTR_HOT2COLD   = _("Hot-to-Cold Ramp")
54    
55  ID_CLASSGEN_GEN = 4001  ID_CLASSGEN_GENCOMBO = 4007
56  ID_CLASSGEN_CLOSE = 4002  ID_CLASSGEN_PROPCOMBO = 4008
 ID_CLASSGEN_COMBO = 4007  
57    
58  COMBOSTR_UNIFORM = _("Uniform Distribution")  ID_BORDER_COLOR = 4009
59  COMBOSTR_UNIQUE = _("Unique Values")  ID_BORDER_COLOR_CHANGE = 4010
60    
61  class ClassGenDialog(wxDialog):  class ClassGenDialog(wxDialog):
62                                                                                    
63      def __init__(self, parent, layer, fieldName):      def __init__(self, parent, layer, fieldName):
64          """Inialize the class generating dialog.          """Inialize the class generating dialog.
65    
# Line 38  class ClassGenDialog(wxDialog): Line 68  class ClassGenDialog(wxDialog):
68    
69          wxDialog.__init__(self, parent, -1, _("Generate Classification"),          wxDialog.__init__(self, parent, -1, _("Generate Classification"),
70                            style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)                            style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
71                                                                                    
72          self.parent = parent          self.parent = parent
73            self.layer = layer
74          self.clazz = None          self.clazz = None
75    
76          self.type, name, width, prec = layer.table.field_info_by_name(fieldName)          col = layer.ShapeStore().Table().Column(fieldName)
77            self.type = col.type
78    
79            self.fieldName = fieldName
80            self.fieldType = self.type
81    
82            self.curGenPanel = None
83    
84            self.genpanels = []
85    
86          #############          #############
87          # we need to create genButton first because when we create the          # we need to create genButton first because when we create the
88          # panels they will call AllowGenerate() which uses genButton.          # panels they will call AllowGenerate() which uses genButton.
89          #          #
90          buttonSizer = wxBoxSizer(wxHORIZONTAL)          self.genButton = wxButton(self, wxID_OK, _("Generate"))
91          self.genButton = wxButton(self, ID_CLASSGEN_GEN, _("Generate"))          self.cancelButton = wxButton(self, wxID_CANCEL, _("Close"))
92            self.genButton.SetDefault()
93    
94            self.genChoice = wxChoice(self, ID_CLASSGEN_GENCOMBO)
95    
96            self.genpanels.append((GENCOMBOSTR_UNIQUE, GenUniquePanel))
97            if self.type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):
98                self.genpanels.append((GENCOMBOSTR_UNIFORM, GenUniformPanel))
99                self.genpanels.append((GENCOMBOSTR_QUANTILES, GenQuantilesPanel))
100    
101            for name, clazz in self.genpanels:
102                self.genChoice.Append(name, [clazz, None])
103    
104            self.genChoice.SetSelection(0)
105    
106            for i in range(self.genChoice.GetCount()):
107                clazz, obj = self.genChoice.GetClientData(i)
108    
109                if obj is None:
110                    obj = clazz(self, self.layer, self.fieldName, self.fieldType)
111                    obj.Hide()
112                    self.genChoice.SetClientData(i, [clazz, obj])
113    
         buttonSizer.Add(self.genButton, 0, wxALL, 4)  
         buttonSizer.Add(60, 20, 0, wxALL, 4)  
         buttonSizer.Add(wxButton(self, ID_CLASSGEN_CLOSE, _("Close")),  
                         0, wxALL, 4)  
114    
115          #############          #############
116    
# Line 64  class ClassGenDialog(wxDialog): Line 120  class ClassGenDialog(wxDialog):
120                    0, wxALL, 4)                    0, wxALL, 4)
121          sizer.Add(wxStaticText(          sizer.Add(wxStaticText(
122              self, -1,              self, -1,
123              _("Field Type: %s") % classifier.Classifier.type2string[self.type]),              _("Data Type: %s") % classifier.Classifier.type2string[self.type]),
124              0, wxALL, 4)              0, wxALL, 4)
125    
126          psizer = wxBoxSizer(wxHORIZONTAL)          psizer = wxBoxSizer(wxHORIZONTAL)
127          psizer.Add(wxStaticText(          psizer.Add(wxStaticText(self, -1, _("Generate:")),
             self, -1,  
             _("Generate:")),  
128              0, wxALIGN_CENTER_VERTICAL, 0)              0, wxALIGN_CENTER_VERTICAL, 0)
129            psizer.Add(self.genChoice, 1, wxALL | wxGROW, 4)
         self.genCombo = wxComboBox(self,  
                                 ID_CLASSGEN_COMBO,  
                                 "", style = wxCB_READONLY)  
         psizer.Add(self.genCombo, 1, wxALL | wxGROW, 4)  
         EVT_COMBOBOX(self, ID_CLASSGEN_COMBO, self._OnGenTypeSelect)  
130    
131          sizer.Add(psizer, 0, wxALL | wxGROW, 4)          sizer.Add(psizer, 0, wxALL | wxGROW, 4)
132    
133          #############          self.sizer_genPanel = wxBoxSizer(wxVERTICAL)
134            sizer.Add(self.sizer_genPanel, 1, wxGROW | wxALL, 4)
         self.genPanel = None  
135    
136          panel = GenUniquePanel(self, layer, fieldName, self.type)          psizer = wxBoxSizer(wxHORIZONTAL)
137          self.genCombo.Append(COMBOSTR_UNIQUE)          psizer.Add(wxStaticText(self, -1, _("Color Scheme:")),
138          self.genCombo.SetClientData(self.genCombo.GetCount() - 1, panel)              0, wxALIGN_CENTER_VERTICAL, 0)
         sizer.Add(panel, 1, wxGROW | wxALL, 4)  
   
         self.genPanel = panel  
   
         if self.type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):  
             panel = GenUniformPanel(self, layer, fieldName, self.type)  
             self.genCombo.Append(COMBOSTR_UNIFORM)  
             self.genCombo.SetClientData(self.genCombo.GetCount() - 1, panel)  
             sizer.Add(panel, 0, wxGROW | wxALL, 4)  
             sizer.Show(panel, False)  
139    
140          #############          # Properties (Ramp) ComboBox
141            self.propCombo = wxChoice(self, ID_CLASSGEN_PROPCOMBO)
142    
143          self.propPanel = None          self.propPanel = None
144            custom_ramp_panel = CustomRampPanel(self, layer.ShapeType())
145    
146          panel = CustomRampPanel(self, layer.ShapeType())          self.propCombo.Append(PROPCOMBOSTR_GREY,  grey_ramp)
147            self.propCombo.Append(PROPCOMBOSTR_RED,   red_ramp)
148            self.propCombo.Append(PROPCOMBOSTR_GREEN, green_ramp)
149            self.propCombo.Append(PROPCOMBOSTR_BLUE,  blue_ramp)
150            self.propCombo.Append(PROPCOMBOSTR_GREEN2RED, green_to_red_ramp)
151            self.propCombo.Append(PROPCOMBOSTR_HOT2COLD,  HotToColdRamp())
152            self.propCombo.Append(PROPCOMBOSTR_CUSTOM, custom_ramp_panel)
153    
154          self.propPanel = panel          self.propCombo.SetSelection(0)
155    
156          sizer.Add(panel, 1, wxALL | wxGROW, 4)          psizer.Add(self.propCombo, 1, wxALL | wxGROW, 4)
157            sizer.Add(psizer, 0, wxALL | wxGROW, 4)
158    
159          #############          if layer.ShapeType() != SHAPETYPE_ARC:
160                psizer = wxBoxSizer(wxHORIZONTAL)
161                self.fix_border_check = wxCheckBox(self, -1, _("Fix Border Color"))
162                psizer.Add(self.fix_border_check, 0, wxALL | wxGROW, 4)
163                self.border_color = classifier.ClassGroupPropertiesCtrl(
164                    self, ID_BORDER_COLOR,
165                    ClassGroupProperties(), SHAPETYPE_ARC,
166                    style=wxSIMPLE_BORDER, size=(40, 20))
167                psizer.Add(self.border_color, 0, wxALL | wxGROW, 4)
168                psizer.Add(wxButton(self, ID_BORDER_COLOR_CHANGE, _("Change")),
169                        0, wxALL, 4)
170                sizer.Add(psizer, 0, wxALL | wxGROW, 4)
171                EVT_BUTTON(self, ID_BORDER_COLOR_CHANGE, self.OnBorderColorChange)
172            else:
173                self.border_color = None
174    
175          sizer.Add(buttonSizer, 0,          sizer.Add(custom_ramp_panel, 1, wxGROW | wxALL, 4)
176                    wxALL | wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL, 4)          sizer.Show(custom_ramp_panel, False)
177    
178            # Finally place the main buttons
179            buttonSizer = wxBoxSizer(wxHORIZONTAL)
180            buttonSizer.Add(self.genButton, 0, wxRIGHT|wxEXPAND, 10)
181            buttonSizer.Add(self.cancelButton, 0, wxRIGHT|wxEXPAND, 10)
182            sizer.Add(buttonSizer, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
183    
184          self.SetSizer(sizer)          self.SetSizer(sizer)
185          self.SetAutoLayout(True)          self.SetAutoLayout(True)
186          sizer.SetSizeHints(self)          sizer.SetSizeHints(self)
187    
188          self.sizer = sizer          self.topBox = sizer
189    
190            self.__DoOnGenTypeSelect()
191    
192            EVT_CHOICE(self, ID_CLASSGEN_GENCOMBO, self._OnGenTypeSelect)
193            EVT_CHOICE(self, ID_CLASSGEN_PROPCOMBO, self._OnPropTypeSelect)
194            EVT_BUTTON(self, wxID_OK, self.OnOK)
195            EVT_BUTTON(self, wxID_CANCEL, self.OnCancel)
196    
197          EVT_BUTTON(self, ID_CLASSGEN_GEN, self._OnGenerate)          self.__DoOnGenTypeSelect()
198          EVT_BUTTON(self, ID_CLASSGEN_CLOSE, self._OnCloseBtn)  
199            self.genChoice.SetFocus()
200    
201      def GetClassification(self):      def GetClassification(self):
202          return self.clazz          return self.clazz
# Line 130  class ClassGenDialog(wxDialog): Line 204  class ClassGenDialog(wxDialog):
204      def AllowGenerate(self, on):      def AllowGenerate(self, on):
205          pass #self.genButton.Enable(on)          pass #self.genButton.Enable(on)
206    
207      def _OnGenerate(self, event):      def OnOK(self, event):
208            """This is really the generate button, but we want to override
209            the wxDialog class.
210            """
211    
212            index = self.genChoice.GetSelection()
213    
214          selIndex = self.genCombo.GetSelection()          assert index != -1, "button should be disabled!"
215    
216            genSel = self.genChoice.GetString(index)
217            clazz, genPanel = self.genChoice.GetClientData(index)
218    
         sel = self.genCombo.GetString(selIndex)  
         genPanel = self.genCombo.GetClientData(selIndex)  
219          propPanel = self.propPanel          propPanel = self.propPanel
220    
221          if sel == COMBOSTR_UNIFORM:          if genSel in (GENCOMBOSTR_UNIFORM,          \
222                          GENCOMBOSTR_UNIQUE,           \
223                          GENCOMBOSTR_QUANTILES):
224    
             min = genPanel.GetMin()  
             max = genPanel.GetMax()  
225              numGroups = genPanel.GetNumGroups()              numGroups = genPanel.GetNumGroups()
             sp = propPanel.GetStartProperties()  
             ep = propPanel.GetEndProperties()  
226    
227              if min is not None \              index = self.propCombo.GetSelection()
                 and max is not None \  
                 and numGroups is not None:  
228    
229                  self.clazz = ClassGenerator().GenUnifromDistribution(              propSel = self.propCombo.GetString(index)
230                               min, max, numGroups, sp, ep,              propPanel = self.propCombo.GetClientData(index)
                              self.type == FIELDTYPE_INT)  
231    
232                  self.parent._SetClassification(self.clazz)              ramp = propPanel.GetRamp()
233                if self.border_color and self.fix_border_check.IsChecked():
234                    props = self.border_color.GetProperties()
235                    ramp = FixedRamp(ramp,
236                        (props.GetLineColor(), props.GetLineWidth(), None))
237    
238          elif sel == COMBOSTR_UNIQUE:              if genSel == GENCOMBOSTR_UNIFORM:
239    
240              list = genPanel.GetValueList()                  min = genPanel.GetMin()
241              numGroups = genPanel.GetNumGroups()                  max = genPanel.GetMax()
             sp = propPanel.GetStartProperties()  
             ep = propPanel.GetEndProperties()  
242    
243              if len(list) > 0 \                  if min is not None \
244                  and numGroups is not None:                      and max is not None \
245                        and numGroups is not None:
246    
247                  self.clazz = ClassGenerator().GenSingletonsFromList(                      self.clazz = generate_uniform_distribution(
248                                  list, numGroups, sp, ep)                                  min, max, numGroups, ramp,
249                                    self.type == FIELDTYPE_INT)
250    
251                  self.parent._SetClassification(self.clazz)                      self.parent._SetClassification(self.clazz)
252    
253          else:              elif genSel == GENCOMBOSTR_UNIQUE:
254              pass  
255                    list = genPanel.GetValueList()
256    
257                    if len(list) > 0:
258                        self.clazz = generate_singletons(list, ramp)
259                        self.parent._SetClassification(self.clazz)
260    
261      def _OnCloseBtn(self, event):              elif genSel == GENCOMBOSTR_QUANTILES:
262    
263                    _range = genPanel.GetRange()
264                    _list = genPanel.GetList()
265                    _list.sort()
266    
267                    delta = 1 / float(numGroups)
268                    percents = [delta * i for i in range(1, numGroups + 1)]
269                    adjusted, self.clazz = \
270                        generate_quantiles(_list, percents, ramp, _range)
271    
272                    if adjusted:
273                        dlg = wxMessageDialog(self,
274                            _("Based on the data from the table and the input\n"
275                         "values, the exact quantiles could not be generated.\n\n"
276                              "Accept a close estimate?"),
277                            _("Problem with Quantiles"),
278    
279                            wxYES_NO|wxYES_DEFAULT|wxICON_QUESTION)
280                        if dlg.ShowModal() == wxID_YES:
281                            self.parent._SetClassification(self.clazz)
282                    else:
283                        self.parent._SetClassification(self.clazz)
284    
285        def OnCancel(self, event):
286          self.Close()          self.Close()
287    
288        def OnBorderColorChange(self, event):
289            self.border_color.DoEdit()
290    
291      def _OnGenTypeSelect(self, event):      def _OnGenTypeSelect(self, event):
292            self.__DoOnGenTypeSelect()
293            return
294    
295          combo = event.GetEventObject()          combo = event.GetEventObject()
296    
297          selIndex = combo.GetSelection()          selIndex = combo.GetSelection()
298    
299          if self.genPanel is not None:          if self.genPanel is not None:
300              self.sizer.Show(self.genPanel, False)              self.topBox.Show(self.genPanel, False)
301    
302          self.genPanel = combo.GetClientData(selIndex)          self.genPanel = combo.GetClientData(selIndex)
303          if self.genPanel is not None:          if self.genPanel is not None:
304              self.sizer.Show(self.genPanel, True)              self.topBox.Show(self.genPanel, True)
305    
306            self.topBox.SetSizeHints(self)
307            self.topBox.Layout()
308    
309        def _OnPropTypeSelect(self, event):
310            combo = event.GetEventObject()
311    
312            selIndex = combo.GetSelection()
313            sel = combo.GetString(selIndex)
314    
315            if isinstance(self.propPanel, wxPanel):
316                self.topBox.Show(self.propPanel, False)
317    
318          self.sizer.SetSizeHints(self)          self.propPanel = combo.GetClientData(selIndex)
         self.sizer.Layout()  
319    
320            if isinstance(self.propPanel, wxPanel):
321                self.topBox.Show(self.propPanel, True)
322    
323            self.topBox.SetSizeHints(self)
324            self.topBox.Layout()
325    
326        def __DoOnGenTypeSelect(self):
327            choice = self.genChoice
328    
329            sel = choice.GetSelection()
330            if sel == -1: return
331    
332            clazz, obj = choice.GetClientData(sel)
333    
334            if self.curGenPanel is not None:
335                self.curGenPanel.Hide()
336                self.sizer_genPanel.Remove(self.curGenPanel)
337    
338            self.curGenPanel = obj
339            self.curGenPanel.Show()
340    
341            self.sizer_genPanel.Add(self.curGenPanel, 1,
342                wxALL|wxEXPAND|wxADJUST_MINSIZE, 3)
343            self.sizer_genPanel.Layout()
344            self.Layout()
345            self.topBox.SetSizeHints(self)
346    
347  ID_UNIFORM_MIN = 4001  ID_UNIFORM_MIN = 4001
348  ID_UNIFORM_MAX = 4002  ID_UNIFORM_MAX = 4002
# Line 238  class GenUniformPanel(wxPanel): Line 388  class GenUniformPanel(wxPanel):
388          sizer = wxBoxSizer(wxHORIZONTAL)          sizer = wxBoxSizer(wxHORIZONTAL)
389    
390          sizer.Add(wxStaticText(self, -1, _("Number of Groups:")), 0, wxALL, 4)          sizer.Add(wxStaticText(self, -1, _("Number of Groups:")), 0, wxALL, 4)
391          self.numGroupsCtrl = wxSpinCtrl(self, ID_UNIFORM_NGROUPS, style=wxTE_RIGHT)          self.numGroupsCtrl = wxSpinCtrl(self, ID_UNIFORM_NGROUPS,
392                                            style=wxTE_RIGHT)
393          EVT_TEXT(self, ID_UNIFORM_NGROUPS, self._OnNumGroupsChanged)          EVT_TEXT(self, ID_UNIFORM_NGROUPS, self._OnNumGroupsChanged)
394          EVT_SPINCTRL(self, ID_UNIFORM_NGROUPS, self._OnNumGroupsChanged)          EVT_SPINCTRL(self, ID_UNIFORM_NGROUPS, self._OnNumGroupsChanged)
395          sizer.Add(self.numGroupsCtrl, 1, wxALL, 4)          sizer.Add(self.numGroupsCtrl, 1, wxALL, 4)
# Line 259  class GenUniformPanel(wxPanel): Line 410  class GenUniformPanel(wxPanel):
410          self.numGroupsChanging = False          self.numGroupsChanging = False
411          self.steppingChanging = False          self.steppingChanging = False
412    
413          self.numGroupsCtrl.SetRange(1, 100)          self.numGroupsCtrl.SetRange(1, sys.maxint)
414    
415          self.numGroupsCtrl.SetValue(1)          self.numGroupsCtrl.SetValue(1)
416          self.stepCtrl.SetValue("1")          self.stepCtrl.SetValue("1")
# Line 309  class GenUniformPanel(wxPanel): Line 460  class GenUniformPanel(wxPanel):
460          self.numGroupsCtrl.Enable(on)          self.numGroupsCtrl.Enable(on)
461          self.stepCtrl.Enable(on)          self.stepCtrl.Enable(on)
462    
         if on:  
             self.numGroupsCtrl.SetRange(1, abs(max - min) / 0.001)  
   
463          ngroups = self.GetNumGroups()          ngroups = self.GetNumGroups()
464    
465          if ngroups is not None  \          if ngroups is not None  \
# Line 342  class GenUniformPanel(wxPanel): Line 490  class GenUniformPanel(wxPanel):
490          min = self.GetMin()          min = self.GetMin()
491          max = self.GetMax()          max = self.GetMax()
492    
         if ngroups >= self.numGroupsCtrl.GetMax():  
             self.numGroupsCtrl.SetRange(1, ngroups + 1)  
   
493          if ngroups is not None  \          if ngroups is not None  \
494              and min is not None \              and min is not None \
495              and max is not None \              and max is not None \
# Line 391  class GenUniformPanel(wxPanel): Line 536  class GenUniformPanel(wxPanel):
536              self.parent.AllowGenerate(False)              self.parent.AllowGenerate(False)
537    
538      def _OnRetrieve(self, event):      def _OnRetrieve(self, event):
539            table = self.layer.ShapeStore().Table()
540          if self.layer.table is not None:          if table is not None:
541              range = self.layer.table.field_range(self.fieldName)              ThubanBeginBusyCursor()
542              self.minCtrl.SetValue(str(range[0][0]))              try:
543              self.maxCtrl.SetValue(str(range[1][0]))                  min, max = table.ValueRange(self.fieldName)
544                    self.minCtrl.SetValue(str(min))
545                    self.maxCtrl.SetValue(str(max))
546                finally:
547                    ThubanEndBusyCursor()
548    
549      def __GetValidatedTypeEntry(self, win, value, type, badValue = None):      def __GetValidatedTypeEntry(self, win, value, type, badValue = None):
550    
# Line 437  class GenUniformPanel(wxPanel): Line 586  class GenUniformPanel(wxPanel):
586          return valid          return valid
587    
588      def __CalcStepping(self, min, max, ngroups):      def __CalcStepping(self, min, max, ngroups):
         step = Str2Num(str((max - min) / float(ngroups)))  
589          if self.fieldType == FIELDTYPE_INT:          if self.fieldType == FIELDTYPE_INT:
590              step = int(step)              step = int((max - min + 1) / float(ngroups))
591            else:
592                step = (max - min) / float(ngroups)
593    
594          return step          return step
595    
# Line 461  ID_UNIQUE_DONTUSE = 4004 Line 611  ID_UNIQUE_DONTUSE = 4004
611  ID_UNIQUE_USENONE = 4005  ID_UNIQUE_USENONE = 4005
612  ID_UNIQUE_SORTAVAIL = 4006  ID_UNIQUE_SORTAVAIL = 4006
613  ID_UNIQUE_SORTUSE = 4007  ID_UNIQUE_SORTUSE = 4007
614    ID_UNIQUE_REVAVAIL = 4008
615    ID_UNIQUE_REVUSE = 4009
616    
617  class GenUniquePanel(wxPanel):  class GenUniquePanel(wxPanel):
618    
# Line 476  class GenUniquePanel(wxPanel): Line 628  class GenUniquePanel(wxPanel):
628                                      wxVERTICAL)                                      wxVERTICAL)
629    
630    
631            #bsizer = wxBoxSizer(wxVERTICAL)
632            topSizer.Add(wxButton(self, ID_UNIQUE_RETRIEVE,
633                                _("Retrieve From Table")),
634                       0, wxALL | wxALIGN_RIGHT, 4)
635    
636            EVT_BUTTON(self, ID_UNIQUE_RETRIEVE, self._OnRetrieve)
637    
638            #topSizer.Add(bsizer, 0, wxALL, 4)
639    
640          sizer = wxBoxSizer(wxHORIZONTAL)          sizer = wxBoxSizer(wxHORIZONTAL)
641    
642          self.dataList = []          self.dataList = []
# Line 487  class GenUniquePanel(wxPanel): Line 648  class GenUniquePanel(wxPanel):
648          self.list_avail_data = []          self.list_avail_data = []
649          psizer.Add(self.list_avail, 1, wxGROW, 0)          psizer.Add(self.list_avail, 1, wxGROW, 0)
650    
651          psizer.Add(wxButton(self, ID_UNIQUE_SORTAVAIL, _("Sort")))          bsizer = wxBoxSizer(wxHORIZONTAL)
652            bsizer.Add(wxButton(self, ID_UNIQUE_SORTAVAIL, _("Sort")))
653            EVT_BUTTON(self, ID_UNIQUE_SORTAVAIL, self._OnSortList)
654    
655          EVT_BUTTON(self, ID_UNIQUE_SORTAVAIL, self._OnSortAvailList)          bsizer.Add(wxButton(self, ID_UNIQUE_REVAVAIL, _("Reverse")))
656            EVT_BUTTON(self, ID_UNIQUE_REVAVAIL, self._OnReverseList)
657    
658            psizer.Add(bsizer, 0, wxGROW, 0)
659          sizer.Add(psizer, 1, wxGROW, 0)          sizer.Add(psizer, 1, wxGROW, 0)
660    
661                    
662          bsizer = wxBoxSizer(wxVERTICAL)          bsizer = wxBoxSizer(wxVERTICAL)
663          bsizer.Add(wxButton(self, ID_UNIQUE_USEALL, _("Use All")),  
664            bmp = resource.GetBitmapResource(USEALL_BMP, wxBITMAP_TYPE_XPM)
665            bsizer.Add(wxBitmapButton(self, ID_UNIQUE_USEALL, bmp),
666                     0, wxGROW | wxALL, 4)                     0, wxGROW | wxALL, 4)
667          bsizer.Add(wxButton(self, ID_UNIQUE_USE, _("Use >>")),          bmp = resource.GetBitmapResource(USE_BMP, wxBITMAP_TYPE_XPM)
668            bsizer.Add(wxBitmapButton(self, ID_UNIQUE_USE, bmp),
669                     0, wxGROW | wxALL, 4)                     0, wxGROW | wxALL, 4)
670          bsizer.Add(wxButton(self, ID_UNIQUE_DONTUSE, _("<< Don't Use")),          bmp = resource.GetBitmapResource(USENOT_BMP, wxBITMAP_TYPE_XPM)
671            bsizer.Add(wxBitmapButton(self, ID_UNIQUE_DONTUSE, bmp),
672                     0, wxGROW | wxALL, 4)                     0, wxGROW | wxALL, 4)
673          bsizer.Add(wxButton(self, ID_UNIQUE_USENONE, _("Use None")),          bmp = resource.GetBitmapResource(USENONE_BMP, wxBITMAP_TYPE_XPM)
674            bsizer.Add(wxBitmapButton(self, ID_UNIQUE_USENONE, bmp),
675                     0, wxGROW | wxALL, 4)                     0, wxGROW | wxALL, 4)
676    
677          EVT_BUTTON(self, ID_UNIQUE_USEALL, self._OnUseAll)          EVT_BUTTON(self, ID_UNIQUE_USEALL, self._OnUseAll)
# Line 518  class GenUniquePanel(wxPanel): Line 688  class GenUniquePanel(wxPanel):
688          self.list_use_data = []          self.list_use_data = []
689          psizer.Add(self.list_use, 1, wxGROW, 0)          psizer.Add(self.list_use, 1, wxGROW, 0)
690    
691          psizer.Add(wxButton(self, ID_UNIQUE_SORTUSE, _("Sort")))          bsizer = wxBoxSizer(wxHORIZONTAL)
692            bsizer.Add(wxButton(self, ID_UNIQUE_SORTUSE, _("Sort")))
693          EVT_BUTTON(self, ID_UNIQUE_SORTUSE, self._OnSortUseList)          EVT_BUTTON(self, ID_UNIQUE_SORTUSE, self._OnSortList)
694    
695          sizer.Add(psizer, 1, wxGROW, 0)          bsizer.Add(wxButton(self, ID_UNIQUE_REVUSE, _("Reverse")))
696            EVT_BUTTON(self, ID_UNIQUE_REVUSE, self._OnReverseList)
697    
698          bsizer = wxBoxSizer(wxVERTICAL)          psizer.Add(bsizer, 0, wxGROW, 0)
         bsizer.Add(wxButton(self, ID_UNIQUE_RETRIEVE,  
                             _("Retrieve From Table")),  
                    0, wxGROW | wxALL, 4)  
699    
700          EVT_BUTTON(self, ID_UNIQUE_RETRIEVE, self._OnRetrieve)          sizer.Add(psizer, 1, wxGROW, 0)
701    
         sizer.Add(bsizer, 0, wxALL, 4)  
702    
703          topSizer.Add(sizer, 1, wxGROW, 0)          topSizer.Add(sizer, 1, wxGROW, 0)
704    
# Line 539  class GenUniquePanel(wxPanel): Line 706  class GenUniquePanel(wxPanel):
706          self.SetAutoLayout(True)          self.SetAutoLayout(True)
707          topSizer.SetSizeHints(self)          topSizer.SetSizeHints(self)
708    
709          self.parent.AllowGenerate(False)          width, height = self.list_avail.GetSizeTuple()
710            self.list_avail.SetColumnWidth(0,width)
711            width, height = self.list_use.GetSizeTuple()
712            self.list_use.SetColumnWidth(0,width)
713    
714          self.mylist = ["Hallo", "Welt!", "Wie", "geht", "es", "dir", "?"]          self.parent.AllowGenerate(False)
715    
716      def GetNumGroups(self):      def GetNumGroups(self):
717          return self.list_use.GetItemCount()          return self.list_use.GetItemCount()
# Line 552  class GenUniquePanel(wxPanel): Line 722  class GenUniquePanel(wxPanel):
722              list.append(self.dataList[self.list_use.GetItemData(i)])              list.append(self.dataList[self.list_use.GetItemData(i)])
723          return list          return list
724    
725      def _OnSortAvailList(self, event):      def _OnSortList(self, event):
726          self.list_avail.SortItems(lambda i1, i2:          id = event.GetId()
727                                      cmp(self.dataList[i1],  
728                                          self.dataList[i2]))          if id == ID_UNIQUE_SORTUSE:
729                list = self.list_use
730      def _OnSortUseList(self, event):          else:
731          self.list_use.SortItems(lambda i1, i2:              list = self.list_avail
732                                      cmp(self.dataList[i1],  
733                                          self.dataList[i2]))          list.SortItems(lambda i1, i2: cmp(self.dataList[i1],
734                                              self.dataList[i2]))
735    
736        def _OnReverseList(self, event):
737            id = event.GetId()
738    
739            if id == ID_UNIQUE_REVUSE:
740                list = self.list_use
741            else:
742                list = self.list_avail
743    
744            #
745            # always returning 1 reverses the list
746            #
747            list.SortItems(lambda i1, i2: 1)
748    
749      def _OnRetrieve(self, event):      def _OnRetrieve(self, event):
750          self.list_use.DeleteAllItems()          self.list_use.DeleteAllItems()
# Line 568  class GenUniquePanel(wxPanel): Line 752  class GenUniquePanel(wxPanel):
752          self.list_avail.DeleteAllItems()          self.list_avail.DeleteAllItems()
753          self.list_avail_data = []          self.list_avail_data = []
754    
755          list = self.layer.table.GetUniqueValues(self.fieldName)          ThubanBeginBusyCursor()
756          index = 0          try:
757          for v in list:              list = self.layer.ShapeStore().Table().UniqueValues(self.fieldName)
758              self.dataList.append(v)              index = 0
759              i = self.list_avail.InsertStringItem(index, str(v))              for v in list:
760              self.list_avail.SetItemData(index, i)                  self.dataList.append(v)
761                    i = self.list_avail.InsertStringItem(index, str(v))
762              self.list_avail_data.append(v)                  self.list_avail.SetItemData(index, i)
763              index += 1      
764                    self.list_avail_data.append(v)
765                    index += 1
766            finally:
767                ThubanEndBusyCursor()
768    
769      def _OnUseAll(self, event):      def _OnUseAll(self, event):
770          for i in range(self.list_avail.GetItemCount()):          for i in range(self.list_avail.GetItemCount()):
771              self.__MoveListItem(0, self.list_avail, self.list_use)              self.__MoveListItem(0, self.list_avail, self.list_use)
772    
773      def _OnUse(self, event):      def _OnUse(self, event):
         print "_OnUse"  
774          self.__MoveSelectedItems(self.list_avail, self.list_use)          self.__MoveSelectedItems(self.list_avail, self.list_use)
775    
776      def _OnDontUse(self, event):      def _OnDontUse(self, event):
         print "_OnDontUse"  
777          self.__MoveSelectedItems(self.list_use, self.list_avail)          self.__MoveSelectedItems(self.list_use, self.list_avail)
778    
779      def _OnUseNone(self, event):      def _OnUseNone(self, event):
         print "_OnUseNone"  
780    
781          for i in range(self.list_use.GetItemCount()):          for i in range(self.list_use.GetItemCount()):
782              self.__MoveListItem(0, self.list_use, self.list_avail)              self.__MoveListItem(0, self.list_use, self.list_avail)
# Line 626  class GenUniquePanel(wxPanel): Line 811  class GenUniquePanel(wxPanel):
811  #       list.SetColumnWidth(0, event.GetSize().GetWidth())  #       list.SetColumnWidth(0, event.GetSize().GetWidth())
812  #        #      
813    
814    ID_QUANTILES_RANGE = 4001
815    ID_QUANTILES_RETRIEVE = 4002
816    
817    class GenQuantilesPanel(wxPanel):
818    
819        def __init__(self, parent, layer, fieldName, fieldType):
820            wxPanel.__init__(self, parent, -1)
821    
822            self.parent = parent
823            self.layer = layer
824            self.fieldName = fieldName
825            self.fieldType = fieldType
826    
827            topBox = wxStaticBoxSizer(wxStaticBox(self, -1, ""),
828                                        wxVERTICAL)
829    
830            self.text_range = wxTextCtrl(self, ID_QUANTILES_RANGE, "")
831            self.button_retrieve = wxButton(self, ID_QUANTILES_RETRIEVE,
832                                            _("Retrieve from Table"))
833    
834            self.spin_numClasses = wxSpinCtrl(self, -1, style=wxTE_RIGHT)
835            self.spin_numClasses.SetRange(1, sys.maxint)
836            self.spin_numClasses.SetValue(1)
837    
838    
839            sizer = wxBoxSizer(wxHORIZONTAL)
840            sizer.Add(wxStaticText(self, -1, _("Apply to Range")), 0, wxALL, 4)
841            sizer.Add(self.text_range, 1, wxALL, 4)
842            sizer.Add(self.button_retrieve, 0, wxALL, 4)
843    
844            topBox.Add(sizer, 0, wxEXPAND, 0)
845    
846            sizer = wxBoxSizer(wxHORIZONTAL)
847            sizer.Add(wxStaticText(self, -1, _("Number of Classes:")), 0, wxALL, 4)
848            sizer.Add(self.spin_numClasses, 1, wxALL, 4)
849    
850            topBox.Add(sizer, 0, wxEXPAND, 0)
851    
852            self.SetSizer(topBox)
853            self.SetAutoLayout(True)
854            topBox.Fit(self)
855            topBox.SetSizeHints(self)
856    
857            EVT_TEXT(self, ID_QUANTILES_RANGE, self.OnRangeText)
858            EVT_BUTTON(self, ID_QUANTILES_RETRIEVE, self.OnRetrieve)
859    
860            self.__range = None
861    
862        def GetNumGroups(self):
863            return self.spin_numClasses.GetValue()
864    
865        def GetRange(self):
866            assert self.__range is not None
867    
868            return self.__range
869    
870        def GetList(self):
871            _list = []
872            table = self.layer.ShapeStore().Table()
873            if table is not None:
874                ThubanBeginBusyCursor()
875                try:
876                    #
877                    # FIXME: Replace with a call to table when the method
878                    # has been written to get all the values
879                    #
880                    for i in range(table.NumRows()):
881                        _list.append(table.ReadValue(i, self.fieldName,
882                                                     row_is_ordinal = True)
883                finally:
884                    ThubanEndBusyCursor()
885    
886            return _list
887    
888        def OnRangeText(self, event):
889    
890            try:
891                self.__range = Range(self.text_range.GetValue())
892            except ValueError:
893                self.__range = None
894    
895            if self.__range is not None:
896                self.text_range.SetForegroundColour(wxBLACK)
897            else:
898                self.text_range.SetForegroundColour(wxRED)
899    
900        def OnRetrieve(self, event):
901            table = self.layer.ShapeStore().Table()
902            if table is not None:
903                ThubanBeginBusyCursor()
904                try:
905                    min, max = table.ValueRange(self.fieldName)
906                    self.text_range.SetValue("[" + str(min) + ";" + str(max) + "]")
907                finally:
908                    ThubanEndBusyCursor()
909    
910  ID_CUSTOMRAMP_COPYSTART = 4001  ID_CUSTOMRAMP_COPYSTART = 4001
911  ID_CUSTOMRAMP_COPYEND = 4002  ID_CUSTOMRAMP_COPYEND = 4002
912  ID_CUSTOMRAMP_EDITSTART = 4003  ID_CUSTOMRAMP_EDITSTART = 4003
# Line 657  class CustomRampPanel(wxPanel): Line 938  class CustomRampPanel(wxPanel):
938                        | wxALIGN_CENTER_VERTICAL, \                        | wxALIGN_CENTER_VERTICAL, \
939                     4)                     4)
940    
941            bmp = resource.GetBitmapResource(USE_BMP, wxBITMAP_TYPE_XPM)
942          bsizer = wxBoxSizer(wxVERTICAL)          bsizer = wxBoxSizer(wxVERTICAL)
943          bsizer.Add(wxButton(self, ID_CUSTOMRAMP_COPYSTART, _("Copy >>")),          bsizer.Add(wxBitmapButton(self, ID_CUSTOMRAMP_COPYSTART, bmp),
944                     0, wxGROW | wxALL, 4)                     0, wxGROW | wxALL, 4)
945          bsizer.Add(wxButton(self, ID_CUSTOMRAMP_COPYEND, _("<< Copy")),          bmp = resource.GetBitmapResource(USENOT_BMP, wxBITMAP_TYPE_XPM)
946            bsizer.Add(wxBitmapButton(self, ID_CUSTOMRAMP_COPYEND, bmp),
947                     0, wxGROW | wxALL, 4)                     0, wxGROW | wxALL, 4)
948    
949          topSizer.Add(bsizer,          topSizer.Add(bsizer,
# Line 696  class CustomRampPanel(wxPanel): Line 979  class CustomRampPanel(wxPanel):
979          self.SetAutoLayout(True)          self.SetAutoLayout(True)
980          topSizer.SetSizeHints(self)          topSizer.SetSizeHints(self)
981    
982      def GetStartProperties(self):      def GetRamp(self):
983          return self.startPropCtrl.GetProperties()          return CustomRamp(self.startPropCtrl.GetProperties(),
984                              self.endPropCtrl.GetProperties())
     def GetEndProperties(self):  
         return self.endPropCtrl.GetProperties()  
985    
986      def _OnCopyStart(self, event):      def _OnCopyStart(self, event):
987          self.endPropCtrl.SetProperties(self.startPropCtrl.GetProperties())          self.endPropCtrl.SetProperties(self.startPropCtrl.GetProperties())
# Line 714  class CustomRampPanel(wxPanel): Line 995  class CustomRampPanel(wxPanel):
995      def _OnEditEnd(self, event):      def _OnEditEnd(self, event):
996          self.endPropCtrl.DoEdit()          self.endPropCtrl.DoEdit()
997    
998  class ClassGenerator:    
   
     def GenSingletonsFromList(self, list, numGroups, prop1, prop2):  
         """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  
   
         for value, prop in zip(list, CustomRamp(numGroups, prop1, prop2)):  
             clazz.AppendGroup(ClassGroupSingleton(value, prop))  
   
         return clazz  
   
     def GenSingletons(self, min, max, numGroups, prop1, prop2):  
   
         clazz = Classification()  
   
         #step = int((max - min) / float(numGroups))  
         step = int(Str2Num(str((max - min + 1) / float(numGroups))))  
   
         if numGroups > 0:  
             cur_value = min  
   
             for prop in CustomRamp(numGroups, prop1, prop2):  
                 clazz.AppendGroup(  
                     ClassGroupSingleton(  
                         Str2Num(str(cur_value)),  
                         prop))  
                 cur_value += step  
   
         return clazz  
   
     def GenUnifromDistribution(self, min, max, numGroups,  
                                prop1, prop2, 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  
   
         step = Str2Num(str((max - min) / float(numGroups)))  
   
         if intStep:  
             step = int(step)  
   
         cur_min = min  
         cur_max = cur_min + step  
   
         i = 0  
         for prop in CustomRamp(numGroups, prop1, prop2):  
   
             if i == (numGroups - 1):  
                 cur_max = max  
   
             # this check guards against rounding issues  
             if cur_min != cur_max:  
                 clazz.AppendGroup(  
                     ClassGroupRange(  
                         Str2Num(str(cur_min)),  
                         Str2Num(str(cur_max)),  
                         prop))  
   
             cur_min = cur_max  
             cur_max += step  
             i += 1  
   
         return clazz  
   
 CLR  = 0  
 STEP = 1  
 class CustomRamp:  
   
     def __init__(self, num, prop1, prop2):  
   
         self.count = int(num)  
         num = float(num)  
   
         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  
   
     def __iter__(self):  
         return self  
   
     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)  
Legend:
Removed from v.629  
changed lines
  Added in v.2099
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26