Changeset 3537:3fec380f8e63 in orange


Ignore:
Timestamp:
04/16/07 10:22:52 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
70ca464e42041e34fe973c93e053ee35c5300cbe
Message:
  • fixed several bugs
Location:
orange
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/OWFreeVizOptimization.py

    r3485 r3537  
    193193            positions = numpy.array([x[:2] for x in self.graph.anchorData]) 
    194194            attrList = self.getShownAttributeList() 
     195            if not attrList: 
     196                return 
    195197 
    196198            if self.restrain == 1: 
     
    234236    def removeHidden(self): 
    235237        rad2 = (self.graph.hideRadius/10)**2 
    236         rem = 0 
    237238        newAnchorData = [] 
     239        shownAttrList = [] 
    238240        for i, t in enumerate(self.graph.anchorData): 
    239             if t[0]**2 + t[1]**2 < rad2: 
    240                 self.parentWidget.hiddenAttribsLB.insertItem(self.parentWidget.shownAttribsLB.pixmap(i-rem), self.parentWidget.shownAttribsLB.text(i-rem)) 
    241                 self.parentWidget.shownAttribsLB.removeItem(i-rem) 
    242                 rem += 1 
    243             else: 
     241            if t[0]**2 + t[1]**2 >= rad2: 
     242                shownAttrList.append(t[2]) 
    244243                newAnchorData.append(t) 
     244        self.parentWidget.setShownAttributeList(self.parentWidget.data, shownAttrList) 
    245245        self.graph.anchorData = newAnchorData 
    246246        self.graph.updateData() 
  • orange/orngScaleData.py

    r3493 r3537  
    110110        self.attrValues = {} 
    111111        self.attrSubValues = {} 
     112        self.normalizers = [] 
    112113 
    113114 
     
    135136        if data == None or len(data) == 0: 
    136137            self.originalData = self.scaledData = self.noJitteringScaledData = self.validDataArray = None 
     138            self.domainDataStat = [];       self.attributeNames = [] 
     139            self.attributeNameIndex = {};   self.attributeFlipInfo = {} 
    137140            return 
    138141 
     
    155158        self.originalData = arr.copy() 
    156159        self.scaledData = numpy.zeros([len(data.domain), len(data)], numpy.float) 
    157         self.noJitteringScaledData = numpy.zeros([len(data.domain), len(data)], numpy.float) 
    158160 
    159161        # see if the values for discrete attributes have to be resorted 
     
    218220#            return 
    219221 
    220         if not subData: 
     222        if not subData or not self.rawdata: 
     223            return 
     224 
     225        try: 
     226            subData = subData.select(self.rawdata.domain) 
     227        except: 
     228            print "Warning: Subset data domain incompatible with data domain.\nData domain: %s\n Subset data domain: %s\n" % (self.rawdata.domain, subData.domain) 
    221229            return 
    222230 
     
    234242                if self.scalingByVariance or self.globalValueScaling: 
    235243                    continue 
    236                 projMin = (Min - self.offsets[index]) / self.normalizers[index] 
    237                 projMax = (Max - self.offsets[index]) / self.normalizers[index] 
     244                normalizer = self.normalizers[index] or 1 
     245                projMin = (Min - self.offsets[index]) / normalizer 
     246                projMax = (Max - self.offsets[index]) / normalizer 
    238247                if projMin < 0.0 or projMax > 1.0: 
    239248                    self.subDataMinMaxDict[attr.name] = (min(projMin, 0.0), max(1.0, projMax)) 
     
    365374    # get array of 0 and 1 of len = len(self.rawdata). if there is a missing value at any attribute in indices return 0 for that example 
    366375    def getValidList(self, indices): 
     376        if self.validDataArray == None: 
     377            return numpy.array([], numpy.bool) 
    367378        selectedArray = numpy.take(self.validDataArray, indices, axis = 0) 
    368379        arr = numpy.add.reduce(selectedArray) 
     
    371382    # get array of 0 and 1 of len = len(self.subsetData). if there is a missing value at any attribute in indices return 0 for that example 
    372383    def getValidSubList(self, indices): 
     384        if self.validSubDataArray == None: 
     385            return numpy.array([], numpy.bool) 
    373386        selectedArray = numpy.take(self.validSubDataArray, indices, axis = 0) 
    374387        arr = numpy.add.reduce(selectedArray) 
  • orange/orngScaleLinProjData.py

    r3413 r3537  
    1010        self.lastAttrIndices = None 
    1111        self.anchorDict = {} 
    12          
     12 
    1313    def setAnchors(self, xAnchors, yAnchors, attributes): 
    1414        if attributes: 
    15             if xAnchors and yAnchors: 
     15            if xAnchors != None and yAnchors != None: 
    1616                self.anchorData = [(xAnchors[i], yAnchors[i], attributes[i]) for i in range(len(attributes))] 
    1717            else: 
    1818                self.anchorData = self.createAnchors(len(attributes), attributes) 
    19          
     19 
    2020    # create anchors around the circle 
    2121    def createAnchors(self, numOfAttr, labels = None): 
     
    2626        else: 
    2727            return [(xAnchors[i], yAnchors[i]) for i in range(numOfAttr)] 
    28          
     28 
    2929    def createXAnchors(self, numOfAttrs): 
    3030        if not self.anchorDict.has_key(numOfAttrs): 
     
    5454        if attrIndices != self.lastAttrIndices: 
    5555            print "getProjectedPointPosition. Warning: Possible bug. The set of attributes is not the same as when computing the whole projection" 
    56          
     56 
    5757        if XAnchors != None and YAnchors != None: 
    5858            XAnchors = numpy.array(XAnchors) 
     
    7474                #m = min(m, 0.0); M = max(M, 1.0); diff = max(M-m, 1e-10) 
    7575                #values = [(val-m) / float(diff) for val in values] 
    76              
     76 
    7777            s = sum(numpy.array(values)*anchorRadius) 
    7878            if s == 0: return [0.0, 0.0] 
     
    8585        return [x, y] 
    8686 
    87     # create the projection of attribute indices given in attrIndices and create an example table with it.  
     87    # create the projection of attribute indices given in attrIndices and create an example table with it. 
    8888    def createProjectionAsExampleTable(self, attrIndices, **settingsDict): 
    8989        if self.rawdata.domain.classVar: 
     
    9696        else: 
    9797            return orange.ExampleTable(domain) 
    98          
     98 
    9999 
    100100    def createProjectionAsNumericArray(self, attrIndices, **settingsDict): 
     
    111111        removeMissingData = settingsDict.get("removeMissingData", 1) 
    112112        #minmaxVals = settingsDict.get("minmaxVals", None) 
    113          
     113 
    114114        # if we want to use anchor data we can get attrIndices from the anchorData 
    115115        if useAnchorData and self.anchorData: 
     
    132132            selectedData = numpy.compress(validData, selectedData, axis = 1) 
    133133            if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    134                 classList = numpy.compress(validData, classList)     
     134                classList = numpy.compress(validData, classList) 
    135135 
    136136        """ 
     
    153153            r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
    154154            if normalize == 1 or (normalize == None and self.normalizeExamples): 
    155                 XAnchors *= r                                                
     155                XAnchors *= r 
    156156                YAnchors *= r 
    157157        elif (XAnchors != None and YAnchors != None): 
     
    179179                x_validData = x_positions 
    180180                y_validData = y_positions 
    181             self.trueScaleFactor = scaleFactor / math.sqrt(max(x_validData*x_validData + y_validData*y_validData)) 
     181            dist = math.sqrt(max(x_validData*x_validData + y_validData*y_validData)) or 1 
     182            self.trueScaleFactor = scaleFactor / dist 
    182183 
    183184        self.unscaled_x_positions = numpy.array(x_positions) 
     
    187188            x_positions *= self.trueScaleFactor 
    188189            y_positions *= self.trueScaleFactor 
    189      
     190 
    190191        if jitterSize > 0.0: 
    191192            x_positions += numpy.random.uniform(-jitterSize, jitterSize, len(x_positions)) 
     
    198199            return numpy.transpose(numpy.array((x_positions, y_positions))) 
    199200 
    200      
     201 
    201202    # ############################################################## 
    202203    # function to compute the sum of all values for each element in the data. used to normalize. 
     
    210211        if len(numpy.nonzero(sum_i)) < len(sum_i):    # test if there are zeros in sum_i 
    211212            sum_i += numpy.where(sum_i == 0, 1.0, 0.0) 
    212         return sum_i       
     213        return sum_i 
  • orange/orngScalePolyvizData.py

    r3413 r3537  
    1515        orngScaleLinProjData.setData(self, data) 
    1616         
    17         if data == None: return 
     17        if data == None or len(data) == 0: return 
    1818 
    1919        if self.globalValueScaling: 
     
    2121                if data.domain[index].varType == orange.VarTypes.Discrete: 
    2222                    self.attrLocalValues[data.domain[index].name] = [0, len(data.domain[index].values)-1] 
    23                 elif self.domainDataStat[index]: 
    24                     self.attrLocalValues[data.domain[index].name] = [self.domainDataStat[index].min, self.domainDataStat[index].max] 
     23                elif self.domainDataStat[data.domain[index].name]: 
     24                    self.attrLocalValues[data.domain[index].name] = [self.domainDataStat[data.domain[index].name].min, self.domainDataStat[data.domain[index].name].max] 
    2525                else: 
    2626                    self.attrLocalValues[data.domain[index].name] = [0, 1] 
  • orange/orngVizRank.py

    r3492 r3537  
    439439            prediction = [val*100.0 for val in prediction] 
    440440        elif self.qualityMeasure == AUC: 
    441             return orngStat.AUC(results)[0], None 
     441            aucResult = orngStat.AUC(results) 
     442            if aucResult: 
     443                return aucResult[0], None 
     444            else: 
     445                return 0, None 
    442446 
    443447        # compute accuracy only for classes that are selected as interesting. other class values do not participate in projection evaluation 
Note: See TracChangeset for help on using the changeset viewer.