Ignore:
Timestamp:
03/08/12 19:44:26 (2 years ago)
Author:
Matija Polajnar <matija.polajnar@…>
Branch:
default
Message:

Major refactorization of linear projections, fixing some bugs in the process.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/preprocess/scaling.py

    r10020 r10475  
    442442        if also_class_if_exists and self.data_has_class:  
    443443            inds.append(self.data_class_index)  
    444         selectedArray = self.valid_data_array.take(inds, axis = 0) 
    445         arr = numpy.add.reduce(selectedArray) 
     444        selected_array = self.valid_data_array.take(inds, axis = 0) 
     445        arr = numpy.add.reduce(selected_array) 
    446446        return numpy.equal(arr, len(inds)) 
    447447     
     
    459459        if also_class_if_exists and self.data_class_index:  
    460460            inds.append(self.data_class_index) 
    461         selectedArray = self.valid_subset_data_array.take(inds, axis = 0) 
    462         arr = numpy.add.reduce(selectedArray) 
     461        selected_array = self.valid_subset_data_array.take(inds, axis = 0) 
     462        arr = numpy.add.reduce(selected_array) 
    463463        return numpy.equal(arr, len(inds)) 
    464464     
     
    470470        valid data value. 
    471471        """ 
    472         validList = self.get_valid_list(indices) 
    473         return numpy.nonzero(validList)[0] 
     472        valid_list = self.get_valid_list(indices) 
     473        return numpy.nonzero(valid_list)[0] 
    474474     
    475475    getValidIndices = get_valid_indices 
     
    480480        valid data value. 
    481481        """ 
    482         validList = self.get_valid_subset_list(indices) 
    483         return numpy.nonzero(validList)[0] 
     482        valid_list = self.get_valid_subset_list(indices) 
     483        return numpy.nonzero(valid_list)[0] 
    484484     
    485485    getValidSubsetIndices = get_valid_subset_indices 
     
    608608 
    609609    @deprecated_keywords({"attrIndices": "attr_indices", 
    610                           "settingsDict": "settings_dict"}) 
     610                          "settingsDict": "settings_dict", 
     611                          "useAnchorData": "use_anchor_data", 
     612                          "xAnchors": "xanchors", 
     613                          "yAnchors": "yanchors", 
     614                          "anchorRadius": "anchor_radius", 
     615                          "normalizeExample": "normalize_example" 
     616                          }) 
    611617    def get_projected_point_position(self, attr_indices, values, **settings_dict): 
    612618        """ 
     
    617623        """ 
    618624        # load the elements from the settings dict 
    619         use_anchor_data = settings_dict.get("useAnchorData") 
    620         xanchors = settings_dict.get("xAnchors") 
    621         yanchors = settings_dict.get("yAnchors") 
    622         anchor_radius = settings_dict.get("anchorRadius") 
    623         normalize_example = settings_dict.get("normalizeExample") 
     625        use_anchor_data = settings_dict.get("use_anchor_data") 
     626        xanchors = settings_dict.get("x_anchors") 
     627        yanchors = settings_dict.get("y_anchors") 
     628        anchor_radius = settings_dict.get("anchor_radius") 
     629        normalize_example = settings_dict.get("normalize_example") 
    624630 
    625631        if attr_indices != self.last_attr_indices: 
     
    695701 
    696702    @deprecated_keywords({"attrIndices": "attr_indices", 
    697                           "settingsDict": "settings_dict"}) 
     703                          "settingsDict": "settings_dict", 
     704                          "validData": "valid_data", 
     705                          "classList": "class_list", 
     706                          "XAnchors": "xanchors", 
     707                          "YAnchors": "yanchors", 
     708                          "scaleFactor": "scale_factor", 
     709                          "jitterSize": "jitter_size", 
     710                          "useAnchorData": "use_anchor_data", 
     711                          "removeMissingData": "remove_missing_data", 
     712                          "useSubsetData": "use_subset_data", 
     713                          }) 
    698714    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    699715        # load the elements from the settings dict 
    700         validData = settings_dict.get("validData") 
    701         classList = settings_dict.get("classList") 
     716        valid_data = settings_dict.get("valid_data") 
     717        class_list = settings_dict.get("class_list") 
    702718        sum_i     = settings_dict.get("sum_i") 
    703         XAnchors = settings_dict.get("XAnchors") 
    704         YAnchors = settings_dict.get("YAnchors") 
    705         scaleFactor = settings_dict.get("scaleFactor", 1.0) 
     719        xanchors = settings_dict.get("xanchors") 
     720        yanchors = settings_dict.get("yanchors") 
     721        scale_factor = settings_dict.get("scale_factor", 1.0) 
    706722        normalize = settings_dict.get("normalize") 
    707         jitterSize = settings_dict.get("jitterSize", 0.0) 
    708         useAnchorData = settings_dict.get("useAnchorData", 0) 
    709         removeMissingData = settings_dict.get("removeMissingData", 1) 
    710         useSubsetData = settings_dict.get("useSubsetData", 0)        # use the data or subsetData? 
     723        jitter_size = settings_dict.get("jitter_size", 0.0) 
     724        use_anchor_data = settings_dict.get("use_anchor_data", 0) 
     725        remove_missing_data = settings_dict.get("remove_missing_data", 1) 
     726        use_subset_data = settings_dict.get("use_subset_data", 0)        # use the data or subsetData? 
    711727        #minmaxVals = settings_dict.get("minmaxVals", None) 
    712728 
    713729        # if we want to use anchor data we can get attr_indices from the anchor_data 
    714         if useAnchorData and self.anchor_data: 
     730        if use_anchor_data and self.anchor_data: 
    715731            attr_indices = [self.attribute_name_index[val[2]] for val in self.anchor_data] 
    716732 
    717         if validData == None: 
    718             if useSubsetData: validData = self.get_valid_subset_list(attr_indices) 
    719             else:             validData = self.get_valid_list(attr_indices) 
    720         if sum(validData) == 0: 
     733        if valid_data == None: 
     734            if use_subset_data: valid_data = self.get_valid_subset_list(attr_indices) 
     735            else:             valid_data = self.get_valid_list(attr_indices) 
     736        if sum(valid_data) == 0: 
    721737            return None 
    722738 
    723         if classList == None and self.data_domain.class_var: 
    724             if useSubsetData: classList = self.original_subset_data[self.data_class_index] 
    725             else:             classList = self.original_data[self.data_class_index] 
     739        if class_list == None and self.data_domain.class_var: 
     740            if use_subset_data: class_list = self.original_subset_data[self.data_class_index] 
     741            else:             class_list = self.original_data[self.data_class_index] 
    726742 
    727743        # if jitterSize is set below zero we use scaled_data that has already jittered data 
    728         if useSubsetData: 
    729             if jitterSize < 0.0: data = self.scaled_subset_data 
     744        if use_subset_data: 
     745            if jitter_size < 0.0: data = self.scaled_subset_data 
    730746            else:                data = self.no_jittering_scaled_subset_data 
    731747        else: 
    732             if jitterSize < 0.0: data = self.scaled_data 
     748            if jitter_size < 0.0: data = self.scaled_data 
    733749            else:                data = self.no_jittering_scaled_data 
    734750 
    735751        selectedData = numpy.take(data, attr_indices, axis = 0) 
    736         if removeMissingData: 
    737             selectedData = numpy.compress(validData, selectedData, axis = 1) 
    738             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    739                 classList = numpy.compress(validData, classList) 
    740  
    741         if useAnchorData and self.anchor_data: 
    742             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    743             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    744             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
     752        if remove_missing_data: 
     753            selectedData = numpy.compress(valid_data, selectedData, axis = 1) 
     754            if class_list != None and len(class_list) != numpy.shape(selectedData)[1]: 
     755                class_list = numpy.compress(valid_data, class_list) 
     756 
     757        if use_anchor_data and self.anchor_data: 
     758            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     759            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     760            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors)     # compute the distance of each anchor from the center of the circle 
    745761            if normalize == 1 or (normalize == None and self.normalize_examples): 
    746                 XAnchors *= r 
    747                 YAnchors *= r 
    748         elif (XAnchors != None and YAnchors != None): 
    749             XAnchors = numpy.array(XAnchors); YAnchors = numpy.array(YAnchors) 
    750             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
    751         else: 
    752             XAnchors = self.create_xanchors(len(attr_indices)) 
    753             YAnchors = self.create_yanchors(len(attr_indices)) 
    754             r = numpy.ones(len(XAnchors), numpy.float) 
    755  
    756         x_positions = numpy.dot(XAnchors, selectedData) 
    757         y_positions = numpy.dot(YAnchors, selectedData) 
     762                xanchors *= r 
     763                yanchors *= r 
     764        elif (xanchors != None and yanchors != None): 
     765            xanchors = numpy.array(xanchors); yanchors = numpy.array(yanchors) 
     766            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors)     # compute the distance of each anchor from the center of the circle 
     767        else: 
     768            xanchors = self.create_xanchors(len(attr_indices)) 
     769            yanchors = self.create_yanchors(len(attr_indices)) 
     770            r = numpy.ones(len(xanchors), numpy.float) 
     771 
     772        x_positions = numpy.dot(xanchors, selectedData) 
     773        y_positions = numpy.dot(yanchors, selectedData) 
    758774 
    759775        if normalize == 1 or (normalize == None and self.normalize_examples): 
    760776            if sum_i == None: 
    761                 sum_i = self._getSum_i(selectedData, useAnchorData, r) 
     777                sum_i = self._getSum_i(selectedData, use_anchor_data, r) 
    762778            x_positions /= sum_i 
    763779            y_positions /= sum_i 
    764             self.trueScaleFactor = scaleFactor 
    765         else: 
    766             if not removeMissingData: 
     780            self.trueScaleFactor = scale_factor 
     781        else: 
     782            if not remove_missing_data: 
    767783                try: 
    768                     x_validData = numpy.compress(validData, x_positions) 
    769                     y_validData = numpy.compress(validData, y_positions) 
     784                    x_valid_data = numpy.compress(valid_data, x_positions) 
     785                    y_valid_data = numpy.compress(valid_data, y_positions) 
    770786                except: 
    771                     print validData 
     787                    print valid_data 
    772788                    print x_positions 
    773                     print numpy.shape(validData) 
     789                    print numpy.shape(valid_data) 
    774790                    print numpy.shape(x_positions) 
    775791            else: 
    776                 x_validData = x_positions 
    777                 y_validData = y_positions 
     792                x_valid_data = x_positions 
     793                y_valid_data = y_positions 
    778794             
    779             dist = math.sqrt(max(x_validData*x_validData + y_validData*y_validData)) or 1 
    780             self.trueScaleFactor = scaleFactor / dist 
     795            dist = math.sqrt(max(x_valid_data*x_valid_data + y_valid_data*y_valid_data)) or 1 
     796            self.trueScaleFactor = scale_factor / dist 
    781797 
    782798        self.unscaled_x_positions = numpy.array(x_positions) 
     
    787803            y_positions *= self.trueScaleFactor 
    788804 
    789         if jitterSize > 0.0: 
    790             x_positions += numpy.random.uniform(-jitterSize, jitterSize, len(x_positions)) 
    791             y_positions += numpy.random.uniform(-jitterSize, jitterSize, len(y_positions)) 
     805        if jitter_size > 0.0: 
     806            x_positions += numpy.random.uniform(-jitter_size, jitter_size, len(x_positions)) 
     807            y_positions += numpy.random.uniform(-jitter_size, jitter_size, len(y_positions)) 
    792808 
    793809        self.last_attr_indices = attr_indices 
    794         if classList != None: 
    795             return numpy.transpose(numpy.array((x_positions, y_positions, classList))) 
     810        if class_list != None: 
     811            return numpy.transpose(numpy.array((x_positions, y_positions, class_list))) 
    796812        else: 
    797813            return numpy.transpose(numpy.array((x_positions, y_positions))) 
     
    818834     
    819835    _getSum_i = _getsum_i 
     836 
     837graph_deprecator = deprecated_members({"setData": "set_data", 
     838                                       "updateData": "update_data", 
     839                                       "scaleFactor": "scale_factor"}) 
    820840 
    821841ScaleLinProjData = deprecated_members({"setAnchors": "set_anchors", 
     
    834854                                       "anchorData": "anchor_data", 
    835855                                       "lastAttrIndices": "last_attr_indices", 
    836                                        "anchorDict": "anchor_dict", 
    837                                       })(ScaleLinProjData) 
     856                                       "anchorDict": "anchor_dict"})(ScaleLinProjData) 
    838857 
    839858class ScaleLinProjData3D(ScaleData): 
     
    927946 
    928947    @deprecated_keywords({"attrIndices": "attr_indices", 
    929                           "settingsDict": "settings_dict"}) 
     948                          "settingsDict": "settings_dict", 
     949                          "useAnchorData": "use_anchor_data", 
     950                          "xAnchors": "xanchors", 
     951                          "yAnchors": "yanchors", 
     952                          "zAnchors": "zanchors", 
     953                          "anchorRadius": "anchor_radius", 
     954                          "normalizeExample": "normalize_example", 
     955                          }) 
    930956    def get_projected_point_position(self, attr_indices, values, **settings_dict): 
    931957        """ 
     
    936962        """ 
    937963        # load the elements from the settings dict 
    938         use_anchor_data = settings_dict.get("useAnchorData") 
    939         xanchors = settings_dict.get('xAnchors') 
    940         yanchors = settings_dict.get('yAnchors') 
    941         zanchors = settings_dict.get('zAnchors') 
    942         anchor_radius = settings_dict.get("anchorRadius") 
    943         normalize_example = settings_dict.get("normalizeExample") 
     964        use_anchor_data = settings_dict.get("use_anchor_data") 
     965        xanchors = settings_dict.get('xanchors') 
     966        yanchors = settings_dict.get('yanchors') 
     967        zanchors = settings_dict.get('zanchors') 
     968        anchor_radius = settings_dict.get("anchor_radius") 
     969        normalize_example = settings_dict.get("normalize_example") 
    944970 
    945971        if attr_indices != self.last_attr_indices: 
     
    9821008            s = sum(numpy.array(values)*anchor_radius) 
    9831009            if s == 0: return [0.0, 0.0] 
    984             x = self.trueScaleFactor * numpy.dot(xanchors*anchor_radius, 
     1010            x = self.true_scale_factor * numpy.dot(xanchors*anchor_radius, 
    9851011                                                 values) / float(s) 
    986             y = self.trueScaleFactor * numpy.dot(yanchors*anchor_radius, 
     1012            y = self.true_scale_factor * numpy.dot(yanchors*anchor_radius, 
    9871013                                                 values) / float(s) 
    988             z = self.trueScaleFactor * numpy.dot(zanchors*anchor_radius, 
     1014            z = self.true_scale_factor * numpy.dot(zanchors*anchor_radius, 
    9891015                                                 values) / float(s) 
    9901016        else: 
    991             x = self.trueScaleFactor * numpy.dot(xanchors, values) 
    992             y = self.trueScaleFactor * numpy.dot(yanchors, values) 
    993             z = self.trueScaleFactor * numpy.dot(zanchors, values) 
     1017            x = self.true_scale_factor * numpy.dot(xanchors, values) 
     1018            y = self.true_scale_factor * numpy.dot(yanchors, values) 
     1019            z = self.true_scale_factor * numpy.dot(zanchors, values) 
    9941020 
    9951021        return [x, y, z] 
     
    10261052 
    10271053    @deprecated_keywords({"attrIndices": "attr_indices", 
    1028                           "settingsDict": "settings_dict"}) 
     1054                          "settingsDict": "settings_dict", 
     1055                          "validData": "valid_data", 
     1056                          "classList": "class_list", 
     1057                          "XAnchors": "xanchors", 
     1058                          "YAnchors": "yanchors", 
     1059                          "ZAnchors": "zanchors", 
     1060                          "scaleFactor": "scale_factor", 
     1061                          "jitterSize": "jitter_size", 
     1062                          "useAnchorData": "use_anchor_data", 
     1063                          "removeMissingData": "remove_missing_data", 
     1064                          "useSubsetData": "use_subset_data", 
     1065                          }) 
    10291066    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    10301067        # load the elements from the settings dict 
    1031         validData = settings_dict.get("validData") 
    1032         classList = settings_dict.get("classList") 
     1068        valid_data = settings_dict.get("valid_data") 
     1069        class_list = settings_dict.get("class_list") 
    10331070        sum_i     = settings_dict.get("sum_i") 
    1034         XAnchors = settings_dict.get("XAnchors") 
    1035         YAnchors = settings_dict.get("YAnchors") 
    1036         ZAnchors = settings_dict.get("ZAnchors") 
    1037         scaleFactor = settings_dict.get("scaleFactor", 1.0) 
     1071        xanchors = settings_dict.get("xanchors") 
     1072        yanchors = settings_dict.get("yanchors") 
     1073        zanchors = settings_dict.get("zanchors") 
     1074        scale_factor = settings_dict.get("scale_factor", 1.0) 
    10381075        normalize = settings_dict.get("normalize") 
    1039         jitterSize = settings_dict.get("jitterSize", 0.0) 
    1040         useAnchorData = settings_dict.get("useAnchorData", 0) 
    1041         removeMissingData = settings_dict.get("removeMissingData", 1) 
    1042         useSubsetData = settings_dict.get("useSubsetData", 0)        # use the data or subsetData? 
     1076        jitter_size = settings_dict.get("jitter_size", 0.0) 
     1077        use_anchor_data = settings_dict.get("use_anchor_data", 0) 
     1078        remove_missing_data = settings_dict.get("remove_missing_data", 1) 
     1079        use_subset_data = settings_dict.get("use_subset_data", 0)        # use the data or subsetData? 
    10431080        #minmaxVals = settings_dict.get("minmaxVals", None) 
    10441081 
    10451082        # if we want to use anchor data we can get attr_indices from the anchor_data 
    1046         if useAnchorData and self.anchor_data: 
     1083        if use_anchor_data and self.anchor_data: 
    10471084            attr_indices = [self.attribute_name_index[val[3]] for val in self.anchor_data] 
    10481085 
    1049         if validData == None: 
    1050             if useSubsetData: validData = self.get_valid_subset_list(attr_indices) 
    1051             else:             validData = self.get_valid_list(attr_indices) 
    1052         if sum(validData) == 0: 
     1086        if valid_data == None: 
     1087            if use_subset_data: valid_data = self.get_valid_subset_list(attr_indices) 
     1088            else:             valid_data = self.get_valid_list(attr_indices) 
     1089        if sum(valid_data) == 0: 
    10531090            return None 
    10541091 
    1055         if classList == None and self.data_domain.class_var: 
    1056             if useSubsetData: classList = self.original_subset_data[self.data_class_index] 
    1057             else:             classList = self.original_data[self.data_class_index] 
     1092        if class_list == None and self.data_domain.class_var: 
     1093            if use_subset_data: class_list = self.original_subset_data[self.data_class_index] 
     1094            else:             class_list = self.original_data[self.data_class_index] 
    10581095 
    10591096        # if jitterSize is set below zero we use scaled_data that has already jittered data 
    1060         if useSubsetData: 
    1061             if jitterSize < 0.0: data = self.scaled_subset_data 
     1097        if use_subset_data: 
     1098            if jitter_size < 0.0: data = self.scaled_subset_data 
    10621099            else:                data = self.no_jittering_scaled_subset_data 
    10631100        else: 
    1064             if jitterSize < 0.0: data = self.scaled_data 
     1101            if jitter_size < 0.0: data = self.scaled_data 
    10651102            else:                data = self.no_jittering_scaled_data 
    10661103 
    1067         selectedData = numpy.take(data, attr_indices, axis=0) 
    1068         if removeMissingData: 
    1069             selectedData = numpy.compress(validData, selectedData, axis=1) 
    1070             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    1071                 classList = numpy.compress(validData, classList) 
    1072  
    1073         if useAnchorData and self.anchor_data: 
    1074             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    1075             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    1076             ZAnchors = numpy.array([val[2] for val in self.anchor_data]) 
    1077             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors + ZAnchors*ZAnchors)     # compute the distance of each anchor from the center of the circle 
     1104        selected_data = numpy.take(data, attr_indices, axis=0) 
     1105        if remove_missing_data: 
     1106            selected_data = numpy.compress(valid_data, selected_data, axis=1) 
     1107            if class_list != None and len(class_list) != numpy.shape(selected_data)[1]: 
     1108                class_list = numpy.compress(valid_data, class_list) 
     1109 
     1110        if use_anchor_data and self.anchor_data: 
     1111            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     1112            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     1113            zanchors = numpy.array([val[2] for val in self.anchor_data]) 
     1114            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors + zanchors*zanchors)     # compute the distance of each anchor from the center of the circle 
    10781115            if normalize == 1 or (normalize == None and self.normalize_examples): 
    1079                 XAnchors *= r 
    1080                 YAnchors *= r 
    1081                 ZAnchors *= r 
    1082         elif (XAnchors != None and YAnchors != None and ZAnchors != None): 
    1083             XAnchors = numpy.array(XAnchors) 
    1084             YAnchors = numpy.array(YAnchors) 
    1085             ZAnchors = numpy.array(ZAnchors) 
    1086             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors + ZAnchors*ZAnchors)     # compute the distance of each anchor from the center of the circle 
     1116                xanchors *= r 
     1117                yanchors *= r 
     1118                zanchors *= r 
     1119        elif (xanchors != None and yanchors != None and zanchors != None): 
     1120            xanchors = numpy.array(xanchors) 
     1121            yanchors = numpy.array(yanchors) 
     1122            zanchors = numpy.array(zanchors) 
     1123            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors + zanchors*zanchors)     # compute the distance of each anchor from the center of the circle 
    10871124        else: 
    10881125            self.create_anchors(len(attr_indices)) 
    1089             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    1090             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    1091             ZAnchors = numpy.array([val[2] for val in self.anchor_data]) 
    1092             r = numpy.ones(len(XAnchors), numpy.float) 
    1093  
    1094         x_positions = numpy.dot(XAnchors, selectedData) 
    1095         y_positions = numpy.dot(YAnchors, selectedData) 
    1096         z_positions = numpy.dot(ZAnchors, selectedData) 
     1126            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     1127            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     1128            zanchors = numpy.array([val[2] for val in self.anchor_data]) 
     1129            r = numpy.ones(len(xanchors), numpy.float) 
     1130 
     1131        x_positions = numpy.dot(xanchors, selected_data) 
     1132        y_positions = numpy.dot(yanchors, selected_data) 
     1133        z_positions = numpy.dot(zanchors, selected_data) 
    10971134 
    10981135        if normalize == 1 or (normalize == None and self.normalize_examples): 
    10991136            if sum_i == None: 
    1100                 sum_i = self._getSum_i(selectedData, useAnchorData, r) 
     1137                sum_i = self._getSum_i(selected_data, use_anchor_data, r) 
    11011138            x_positions /= sum_i 
    11021139            y_positions /= sum_i 
    11031140            z_positions /= sum_i 
    1104             self.trueScaleFactor = scaleFactor 
    1105         else: 
    1106             if not removeMissingData: 
     1141            self.true_scale_factor = scale_factor 
     1142        else: 
     1143            if not remove_missing_data: 
    11071144                try: 
    1108                     x_validData = numpy.compress(validData, x_positions) 
    1109                     y_validData = numpy.compress(validData, y_positions) 
    1110                     z_validData = numpy.compress(validData, z_positions) 
     1145                    x_valid_data = numpy.compress(valid_data, x_positions) 
     1146                    y_valid_data = numpy.compress(valid_data, y_positions) 
     1147                    z_valid_data = numpy.compress(valid_data, z_positions) 
    11111148                except: 
    1112                     print validData 
     1149                    print valid_data 
    11131150                    print x_positions 
    1114                     print numpy.shape(validData) 
     1151                    print numpy.shape(valid_data) 
    11151152                    print numpy.shape(x_positions) 
    11161153            else: 
    1117                 x_validData = x_positions 
    1118                 y_validData = y_positions 
    1119                 z_validData = z_positions 
    1120  
    1121             dist = math.sqrt(max(x_validData*x_validData + y_validData*y_validData + z_validData*z_validData)) or 1 
    1122             self.trueScaleFactor = scaleFactor / dist 
     1154                x_valid_data = x_positions 
     1155                y_valid_data = y_positions 
     1156                z_valid_data = z_positions 
     1157 
     1158            dist = math.sqrt(max(x_valid_data*x_valid_data + y_valid_data*y_valid_data + z_valid_data*z_valid_data)) or 1 
     1159            self.true_scale_factor = scale_factor / dist 
    11231160 
    11241161        self.unscaled_x_positions = numpy.array(x_positions) 
     
    11261163        self.unscaled_z_positions = numpy.array(z_positions) 
    11271164 
    1128         if self.trueScaleFactor != 1.0: 
    1129             x_positions *= self.trueScaleFactor 
    1130             y_positions *= self.trueScaleFactor 
    1131             z_positions *= self.trueScaleFactor 
    1132  
    1133         if jitterSize > 0.0: 
    1134             x_positions += numpy.random.uniform(-jitterSize, jitterSize, len(x_positions)) 
    1135             y_positions += numpy.random.uniform(-jitterSize, jitterSize, len(y_positions)) 
    1136             z_positions += numpy.random.uniform(-jitterSize, jitterSize, len(z_positions)) 
     1165        if self.true_scale_factor != 1.0: 
     1166            x_positions *= self.true_scale_factor 
     1167            y_positions *= self.true_scale_factor 
     1168            z_positions *= self.true_scale_factor 
     1169 
     1170        if jitter_size > 0.0: 
     1171            x_positions += numpy.random.uniform(-jitter_size, jitter_size, len(x_positions)) 
     1172            y_positions += numpy.random.uniform(-jitter_size, jitter_size, len(y_positions)) 
     1173            z_positions += numpy.random.uniform(-jitter_size, jitter_size, len(z_positions)) 
    11371174 
    11381175        self.last_attr_indices = attr_indices 
    1139         if classList != None: 
    1140             return numpy.transpose(numpy.array((x_positions, y_positions, z_positions, classList))) 
     1176        if class_list != None: 
     1177            return numpy.transpose(numpy.array((x_positions, y_positions, z_positions, class_list))) 
    11411178        else: 
    11421179            return numpy.transpose(numpy.array((x_positions, y_positions, z_positions))) 
     
    11781215                                       "lastAttrIndices": "last_attr_indices", 
    11791216                                       "anchorDict": "anchor_dict", 
     1217                                       "trueScaleFactor": "true_scale_factor" 
    11801218                                      })(ScaleLinProjData3D) 
    11811219 
     
    12101248     
    12111249    @deprecated_keywords({"attrIndices": "attr_indices", 
    1212                           "settingsDict": "settings_dict"}) 
     1250                          "settingsDict": "settings_dict", 
     1251                          "validData": "valid_data", 
     1252                          "classList": "class_list", 
     1253                          "XAnchors": "xanchors", 
     1254                          "YAnchors": "yanchors", 
     1255                          "scaleFactor": "scale_factor", 
     1256                          "jitterSize": "jitter_size", 
     1257                          "removeMissingData": "remove_missing_data", 
     1258                          }) 
    12131259    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    12141260        # load the elements from the settings dict 
    1215         attributeReverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
    1216         validData = settings_dict.get("validData") 
    1217         classList = settings_dict.get("classList") 
     1261        attribute_reverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
     1262        valid_data = settings_dict.get("valid_data") 
     1263        class_list = settings_dict.get("class_list") 
    12181264        sum_i     = settings_dict.get("sum_i") 
    1219         XAnchors  = settings_dict.get("XAnchors") 
    1220         YAnchors  = settings_dict.get("YAnchors") 
    1221         scaleFactor = settings_dict.get("scaleFactor", 1.0) 
    1222         jitterSize  = settings_dict.get("jitterSize", 0.0) 
    1223         removeMissingData = settings_dict.get("removeMissingData", 1) 
    1224          
    1225         if validData == None: 
    1226             validData = self.get_valid_list(attr_indices) 
    1227         if sum(validData) == 0: 
     1265        xanchors  = settings_dict.get("xanchors") 
     1266        yanchors  = settings_dict.get("yanchors") 
     1267        scale_factor = settings_dict.get("scale_factor", 1.0) 
     1268        jitter_size  = settings_dict.get("jitter_size", 0.0) 
     1269        remove_missing_data = settings_dict.get("remove_missing_data", 1) 
     1270         
     1271        if valid_data == None: 
     1272            valid_data = self.get_valid_list(attr_indices) 
     1273        if sum(valid_data) == 0: 
    12281274            return None 
    12291275 
    1230         if classList == None and self.data_has_class: 
    1231             classList = self.original_data[self.data_class_index]   
    1232  
    1233         if removeMissingData: 
    1234             selectedData = numpy.compress(validData, 
     1276        if class_list == None and self.data_has_class: 
     1277            class_list = self.original_data[self.data_class_index] 
     1278 
     1279        if remove_missing_data: 
     1280            selected_data = numpy.compress(valid_data, 
    12351281                                          numpy.take(self.no_jittering_scaled_data, 
    12361282                                                     attr_indices, axis = 0), 
    12371283                                                     axis = 1) 
    1238             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    1239                 classList = numpy.compress(validData, classList) 
    1240         else: 
    1241             selectedData = numpy.take(self.no_jittering_scaled_data, 
     1284            if class_list != None and len(class_list) != numpy.shape(selected_data)[1]: 
     1285                class_list = numpy.compress(valid_data, class_list) 
     1286        else: 
     1287            selected_data = numpy.take(self.no_jittering_scaled_data, 
    12421288                                      attr_indices, axis = 0) 
    12431289         
    12441290        if sum_i == None: 
    1245             sum_i = self._getSum_i(selectedData) 
    1246  
    1247         if XAnchors == None or YAnchors == None: 
    1248             XAnchors = self.create_xanchors(len(attr_indices)) 
    1249             YAnchors = self.create_yanchors(len(attr_indices)) 
    1250  
    1251         xanchors = numpy.zeros(numpy.shape(selectedData), numpy.float) 
    1252         yanchors = numpy.zeros(numpy.shape(selectedData), numpy.float) 
     1291            sum_i = self._getSum_i(selected_data) 
     1292 
     1293        if xanchors == None or yanchors == None: 
     1294            xanchors = self.create_xanchors(len(attr_indices)) 
     1295            yanchors = self.create_yanchors(len(attr_indices)) 
     1296 
     1297        xanchors = numpy.zeros(numpy.shape(selected_data), numpy.float) 
     1298        yanchors = numpy.zeros(numpy.shape(selected_data), numpy.float) 
    12531299        length = len(attr_indices) 
    12541300 
    12551301        for i in range(length): 
    1256             if attributeReverse[i]: 
    1257                 xanchors[i] = selectedData[i] * XAnchors[i] + (1-selectedData[i]) * XAnchors[(i+1)%length] 
    1258                 yanchors[i] = selectedData[i] * YAnchors[i] + (1-selectedData[i]) * YAnchors[(i+1)%length] 
     1302            if attribute_reverse[i]: 
     1303                xanchors[i] = selected_data[i] * xanchors[i] + (1-selected_data[i]) * xanchors[(i+1)%length] 
     1304                yanchors[i] = selected_data[i] * yanchors[i] + (1-selected_data[i]) * yanchors[(i+1)%length] 
    12591305            else: 
    1260                 xanchors[i] = (1-selectedData[i]) * XAnchors[i] + selectedData[i] * XAnchors[(i+1)%length] 
    1261                 yanchors[i] = (1-selectedData[i]) * YAnchors[i] + selectedData[i] * YAnchors[(i+1)%length] 
    1262  
    1263         x_positions = numpy.sum(numpy.multiply(xanchors, selectedData), axis=0)/sum_i 
    1264         y_positions = numpy.sum(numpy.multiply(yanchors, selectedData), axis=0)/sum_i 
     1306                xanchors[i] = (1-selected_data[i]) * xanchors[i] + selected_data[i] * xanchors[(i+1)%length] 
     1307                yanchors[i] = (1-selected_data[i]) * yanchors[i] + selected_data[i] * yanchors[(i+1)%length] 
     1308 
     1309        x_positions = numpy.sum(numpy.multiply(xanchors, selected_data), axis=0)/sum_i 
     1310        y_positions = numpy.sum(numpy.multiply(yanchors, selected_data), axis=0)/sum_i 
    12651311        #x_positions = numpy.sum(numpy.transpose(xanchors* numpy.transpose(selectedData)), axis=0) / sum_i 
    12661312        #y_positions = numpy.sum(numpy.transpose(yanchors* numpy.transpose(selectedData)), axis=0) / sum_i 
    12671313 
    1268         if scaleFactor != 1.0: 
    1269             x_positions = x_positions * scaleFactor 
    1270             y_positions = y_positions * scaleFactor 
    1271         if jitterSize > 0.0: 
    1272             x_positions += (numpy.random.random(len(x_positions))-0.5)*jitterSize 
    1273             y_positions += (numpy.random.random(len(y_positions))-0.5)*jitterSize 
    1274  
    1275         if classList != None: 
    1276             return numpy.transpose(numpy.array((x_positions, y_positions, classList))) 
     1314        if scale_factor != 1.0: 
     1315            x_positions = x_positions * scale_factor 
     1316            y_positions = y_positions * scale_factor 
     1317        if jitter_size > 0.0: 
     1318            x_positions += (numpy.random.random(len(x_positions))-0.5)*jitter_size 
     1319            y_positions += (numpy.random.random(len(y_positions))-0.5)*jitter_size 
     1320 
     1321        if class_list != None: 
     1322            return numpy.transpose(numpy.array((x_positions, y_positions, class_list))) 
    12771323        else: 
    12781324            return numpy.transpose(numpy.array((x_positions, y_positions))) 
     
    12811327 
    12821328    @deprecated_keywords({"attrIndices": "attr_indices", 
    1283                           "settingsDict": "settings_dict"}) 
     1329                          "settingsDict": "settings_dict", 
     1330                          "useAnchorData": "use_anchor_data", 
     1331                          "XAnchors": "xanchors", 
     1332                          "YAnchors": "yanchors"}) 
    12841333    def get_projected_point_position(self, attr_indices, values, **settings_dict): 
    12851334        # load the elements from the settings dict 
    1286         attributeReverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
    1287         useAnchorData = settings_dict.get("useAnchorData") 
    1288         XAnchors = settings_dict.get("XAnchors") 
    1289         YAnchors = settings_dict.get("YAnchors") 
    1290      
    1291         if XAnchors != None and YAnchors != None: 
    1292             XAnchors = numpy.array(XAnchors) 
    1293             YAnchors = numpy.array(YAnchors) 
    1294         elif useAnchorData: 
    1295             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    1296             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    1297         else: 
    1298             XAnchors = self.create_xanchors(len(attr_indices)) 
    1299             YAnchors = self.create_yanchors(len(attr_indices)) 
     1335        attribute_reverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
     1336        use_anchor_data = settings_dict.get("use_anchor_data") 
     1337        xanchors = settings_dict.get("xanchors") 
     1338        yanchors = settings_dict.get("yanchors") 
     1339     
     1340        if xanchors != None and yanchors != None: 
     1341            xanchors = numpy.array(xanchors) 
     1342            yanchors = numpy.array(yanchors) 
     1343        elif use_anchor_data: 
     1344            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     1345            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     1346        else: 
     1347            xanchors = self.create_xanchors(len(attr_indices)) 
     1348            yanchors = self.create_yanchors(len(attr_indices)) 
    13001349 
    13011350        m = min(values); M = max(values) 
     
    13131362        yanchors = numpy.zeros(length, numpy.float) 
    13141363        for i in range(length): 
    1315             if attributeReverse[i]: 
    1316                 xanchors[i] = values[i] * XAnchors[i] + (1-values[i]) * XAnchors[(i+1)%length] 
    1317                 yanchors[i] = values[i] * YAnchors[i] + (1-values[i]) * YAnchors[(i+1)%length] 
     1364            if attribute_reverse[i]: 
     1365                xanchors[i] = values[i] * xanchors[i] + (1-values[i]) * xanchors[(i+1)%length] 
     1366                yanchors[i] = values[i] * yanchors[i] + (1-values[i]) * yanchors[(i+1)%length] 
    13181367            else: 
    1319                 xanchors[i] = (1-values[i]) * XAnchors[i] + values[i] * XAnchors[(i+1)%length] 
    1320                 yanchors[i] = (1-values[i]) * YAnchors[i] + values[i] * YAnchors[(i+1)%length] 
     1368                xanchors[i] = (1-values[i]) * xanchors[i] + values[i] * xanchors[(i+1)%length] 
     1369                yanchors[i] = (1-values[i]) * yanchors[i] + values[i] * yanchors[(i+1)%length] 
    13211370 
    13221371        x_positions = numpy.sum(numpy.dot(xanchors, values), axis=0) / float(s) 
     
    14711520 
    14721521    @deprecated_keywords({"attrIndices": "attr_indices", 
    1473                           "settingsDict": "settings_dict"}) 
     1522                          "settingsDict": "settings_dict", 
     1523                          "validData": "valid_data", 
     1524                          "classList": "class_list", 
     1525                          "jutterSize": "jitter_size"}) 
    14741526    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    1475         validData = settings_dict.get("validData") 
    1476         classList = settings_dict.get("classList") 
    1477         jitterSize = settings_dict.get("jitter_size", 0.0) 
    1478  
    1479         if validData == None: 
    1480             validData = self.get_valid_list(attr_indices) 
    1481         if sum(validData) == 0: 
     1527        valid_data = settings_dict.get("valid_data") 
     1528        class_list = settings_dict.get("class_list") 
     1529        jitter_size = settings_dict.get("jitter_size", 0.0) 
     1530 
     1531        if valid_data == None: 
     1532            valid_data = self.get_valid_list(attr_indices) 
     1533        if sum(valid_data) == 0: 
    14821534            return None 
    14831535 
    1484         if classList == None and self.data_has_class: 
    1485             classList = self.original_data[self.data_class_index] 
    1486  
    1487         xArray = self.no_jittering_scaled_data[attr_indices[0]] 
    1488         yArray = self.no_jittering_scaled_data[attr_indices[1]] 
    1489         if jitterSize > 0.0: 
    1490             xArray += (numpy.random.random(len(xArray))-0.5)*jitterSize 
    1491             yArray += (numpy.random.random(len(yArray))-0.5)*jitterSize 
    1492         if classList != None: 
    1493             data = numpy.compress(validData, numpy.array((xArray, yArray, classList)), axis = 1) 
    1494         else: 
    1495             data = numpy.compress(validData, numpy.array((xArray, yArray)), axis = 1) 
     1536        if class_list == None and self.data_has_class: 
     1537            class_list = self.original_data[self.data_class_index] 
     1538 
     1539        xarray = self.no_jittering_scaled_data[attr_indices[0]] 
     1540        yarray = self.no_jittering_scaled_data[attr_indices[1]] 
     1541        if jitter_size > 0.0: 
     1542            xarray += (numpy.random.random(len(xarray))-0.5)*jitter_size 
     1543            yarray += (numpy.random.random(len(yarray))-0.5)*jitter_size 
     1544        if class_list != None: 
     1545            data = numpy.compress(valid_data, numpy.array((xarray, yarray, class_list)), axis = 1) 
     1546        else: 
     1547            data = numpy.compress(valid_data, numpy.array((xarray, yarray)), axis = 1) 
    14961548        data = numpy.transpose(data) 
    14971549        return data 
     
    15001552 
    15011553    @deprecated_keywords({"attrIndices": "attr_indices", 
    1502                           "settingsDict": "settings_dict"}) 
     1554                          "settingsDict": "settings_dict", 
     1555                          "validData": "valid_data", 
     1556                          "classList": "class_list", 
     1557                          "jutterSize": "jitter_size"}) 
    15031558    def create_projection_as_numeric_array_3D(self, attr_indices, **settings_dict): 
    1504         validData = settings_dict.get("validData") 
    1505         classList = settings_dict.get("classList") 
    1506         jitterSize = settings_dict.get("jitter_size", 0.0) 
    1507  
    1508         if validData == None: 
    1509             validData = self.get_valid_list(attr_indices) 
    1510         if sum(validData) == 0: 
     1559        valid_data = settings_dict.get("valid_data") 
     1560        class_list = settings_dict.get("class_list") 
     1561        jitter_size = settings_dict.get("jitter_size", 0.0) 
     1562 
     1563        if valid_data == None: 
     1564            valid_data = self.get_valid_list(attr_indices) 
     1565        if sum(valid_data) == 0: 
    15111566            return None 
    15121567 
    1513         if classList == None and self.data_has_class: 
    1514             classList = self.original_data[self.data_class_index] 
    1515  
    1516         xArray = self.no_jittering_scaled_data[attr_indices[0]] 
    1517         yArray = self.no_jittering_scaled_data[attr_indices[1]] 
    1518         zArray = self.no_jittering_scaled_data[attr_indices[2]] 
    1519         if jitterSize > 0.0: 
    1520             xArray += (numpy.random.random(len(xArray))-0.5)*jitterSize 
    1521             yArray += (numpy.random.random(len(yArray))-0.5)*jitterSize 
    1522             zArray += (numpy.random.random(len(zArray))-0.5)*jitterSize 
    1523         if classList != None: 
    1524             data = numpy.compress(validData, numpy.array((xArray, yArray, zArray, classList)), axis = 1) 
    1525         else: 
    1526             data = numpy.compress(validData, numpy.array((xArray, yArray, zArray)), axis = 1) 
     1568        if class_list == None and self.data_has_class: 
     1569            class_list = self.original_data[self.data_class_index] 
     1570 
     1571        xarray = self.no_jittering_scaled_data[attr_indices[0]] 
     1572        yarray = self.no_jittering_scaled_data[attr_indices[1]] 
     1573        zarray = self.no_jittering_scaled_data[attr_indices[2]] 
     1574        if jitter_size > 0.0: 
     1575            xarray += (numpy.random.random(len(xarray))-0.5)*jitter_size 
     1576            yarray += (numpy.random.random(len(yarray))-0.5)*jitter_size 
     1577            zarray += (numpy.random.random(len(zarray))-0.5)*jitter_size 
     1578        if class_list != None: 
     1579            data = numpy.compress(valid_data, numpy.array((xarray, yarray, zarray, class_list)), axis = 1) 
     1580        else: 
     1581            data = numpy.compress(valid_data, numpy.array((xarray, yarray, zarray)), axis = 1) 
    15271582        data = numpy.transpose(data) 
    15281583        return data 
     
    15431598        # init again, in case that the attribute ordering took too much time 
    15441599        self.scatterWidget.progressBarInit() 
    1545         startTime = time.time() 
     1600        start_time = time.time() 
    15461601        count = len(attribute_name_order)*(len(attribute_name_order)-1)/2 
    1547         testIndex = 0 
     1602        test_index = 0 
    15481603 
    15491604        for i in range(len(attribute_name_order)): 
     
    15521607                    attr1 = self.attribute_name_index[attribute_name_order[j]] 
    15531608                    attr2 = self.attribute_name_index[attribute_name_order[i]] 
    1554                     testIndex += 1 
     1609                    test_index += 1 
    15551610                    if self.clusterOptimization.isOptimizationCanceled(): 
    1556                         secs = time.time() - startTime 
     1611                        secs = time.time() - start_time 
    15571612                        self.clusterOptimization.setStatusBarText("Evaluation stopped (evaluated %d projections in %d min, %d sec)" 
    1558                                                                   % (testIndex, secs/60, secs%60)) 
     1613                                                                  % (test_index, secs/60, secs%60)) 
    15591614                        self.scatterWidget.progressBarFinished() 
    15601615                        return 
     
    15631618                                                                   domain = domain, 
    15641619                                                                   jitter_size = jitter_size) 
    1565                     graph, valueDict, closureDict, polygonVerticesDict, enlargedClosureDict, otherDict = self.clusterOptimization.evaluateClusters(data) 
    1566  
    1567                     allValue = 0.0 
    1568                     classesDict = {} 
    1569                     for key in valueDict.keys(): 
    1570                         add_result_funct(valueDict[key], closureDict[key], 
    1571                                          polygonVerticesDict[key], 
     1620                    graph, valuedict, closuredict, polygon_vertices_dict, enlarged_closure_dict, other_dict = self.clusterOptimization.evaluateClusters(data) 
     1621 
     1622                    all_value = 0.0 
     1623                    classes_dict = {} 
     1624                    for key in valuedict.keys(): 
     1625                        add_result_funct(valuedict[key], closuredict[key], 
     1626                                         polygon_vertices_dict[key], 
    15721627                                         [attribute_name_order[i], 
    15731628                                          attribute_name_order[j]], 
    1574                                           int(graph.objects[polygonVerticesDict[key][0]].getclass()), 
    1575                                           enlargedClosureDict[key], otherDict[key]) 
    1576                         classesDict[key] = int(graph.objects[polygonVerticesDict[key][0]].getclass()) 
    1577                         allValue += valueDict[key] 
    1578                     add_result_funct(allValue, closureDict, polygonVerticesDict, 
     1629                                          int(graph.objects[polygon_vertices_dict[key][0]].getclass()), 
     1630                                          enlarged_closure_dict[key], other_dict[key]) 
     1631                        classes_dict[key] = int(graph.objects[polygon_vertices_dict[key][0]].getclass()) 
     1632                        all_value += valuedict[key] 
     1633                    add_result_funct(all_value, closuredict, polygon_vertices_dict, 
    15791634                                     [attribute_name_order[i], attribute_name_order[j]], 
    1580                                      classesDict, enlargedClosureDict, otherDict)     # add all the clusters 
     1635                                     classes_dict, enlarged_closure_dict, other_dict)     # add all the clusters 
    15811636                     
    15821637                    self.clusterOptimization.setStatusBarText("Evaluated %d projections..." 
    1583                                                               % (testIndex)) 
    1584                     self.scatterWidget.progressBarSet(100.0*testIndex/float(count)) 
    1585                     del data, graph, valueDict, closureDict, polygonVerticesDict, enlargedClosureDict, otherDict, classesDict 
     1638                                                              % (test_index)) 
     1639                    self.scatterWidget.progressBarSet(100.0*test_index/float(count)) 
     1640                    del data, graph, valuedict, closuredict, polygon_vertices_dict, enlarged_closure_dict, other_dict, classes_dict 
    15861641                except: 
    15871642                    type, val, traceback = sys.exc_info() 
    15881643                    sys.excepthook(type, val, traceback)  # print the exception 
    15891644         
    1590         secs = time.time() - startTime 
    1591         self.clusterOptimization.setStatusBarText("Finished evaluation (evaluated %d projections in %d min, %d sec)" % (testIndex, secs/60, secs%60)) 
     1645        secs = time.time() - start_time 
     1646        self.clusterOptimization.setStatusBarText("Finished evaluation (evaluated %d projections in %d min, %d sec)" % (test_index, secs/60, secs%60)) 
    15921647        self.scatterWidget.progressBarFinished() 
    15931648     
Note: See TracChangeset for help on using the changeset viewer.