Changeset 3684:4ab0920a9899 in orange


Ignore:
Timestamp:
05/22/07 15:31:49 (7 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
9a0f215caddc79df9063e9b77016d6dc08ec8fe2
Message:

basic subgraph optimization

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Prototypes/OWGraphDrawerCanvas.py

    r3609 r3684  
    4646            self.setCurveSymbol(self.vertices[ndx], newSymbol) 
    4747            self.selection.append(ndx); 
     48            self.visualizer.filter[ndx] = True 
    4849            self.replot() 
    4950            return True 
     
    5960             
    6061        self.selection = [] 
     62        self.visualizer.unselectAll() 
    6163        self.selectionStyles = {} 
    6264        self.replot() 
     
    8789         
    8890    def selectHubs(self, no): 
     91        print "start selecting..." 
    8992        if self.vertexDegree == []: 
    9093            self.generateVertexPower() 
    91              
     94        print "generated generateVertexPower" 
    9295        count = 0 
    9396        old_power = -1 
     
    104107            #print "old_power: " + str(old_power) + " new_power: " + str(next_power) 
    105108            count += 1 
     109        print "selected." 
    106110             
    107111    def selectConnectedNodes(self, distance): 
  • orange/OrangeWidgets/Prototypes/OWNetwork.py

    r3682 r3684  
    273273        print "OWNetwork/random.." 
    274274        if self.visualize == None:   #grafa se ni 
    275             return 
    276          
     275            return     
     276             
    277277        self.visualize.random() 
    278278         
     
    303303            if (initTemp <= tolerance): 
    304304                #self.visualize.postProcess() 
     305                print "OWNetwork/ff: updating canvas..." 
    305306                self.updateCanvas() 
    306307                return 
    307              
     308            print "OWNetwork/ff: updating canvas..." 
    308309            self.updateCanvas() 
     310        print "done." 
    309311         
    310312    def circular(self): 
  • source/orangeom/networkoptimization.cpp

    r3664 r3684  
    3535    height = 1000; 
    3636    links = NULL; 
     37    nodes = NULL; 
    3738    pos = NULL; 
    3839    temperature = sqrt((double)(width*width + height*height)) / 10; 
     
    5253    free_Links(); 
    5354    free_Carrayptrs(pos); 
     55    free((char*) nodes); 
    5456    Py_DECREF(coors); 
     57    Py_DECREF(filter); 
    5558} 
    5659 
     
    9093} 
    9194 
    92  
    93 void TNetworkOptimization::random() 
    94 { 
    95     srand(time(NULL)); 
     95bool TNetworkOptimization::isFilter() 
     96{ 
    9697    int i; 
    9798    for (i = 0; i < nVertices; i++) 
    98     { 
    99         pos[i][0] = rand() % width; 
    100         pos[i][1] = rand() % height; 
     99        if (nodes[i]) 
     100            return true; 
     101 
     102    return false; 
     103} 
     104 
     105void TNetworkOptimization::random() 
     106{ 
     107    srand(time(NULL)); 
     108    bool _isFilter = isFilter(); 
     109 
     110    int i; 
     111    for (i = 0; i < nVertices; i++) 
     112    { 
     113        if (!_isFilter || nodes[i]) 
     114        { 
     115            pos[i][0] = rand() % width; 
     116            pos[i][1] = rand() % height; 
     117        } 
    101118    } 
    102119} 
     
    108125    dumpCoordinates(pos, nVertices, 2); 
    109126    /**/ 
     127    bool _isFilter = isFilter(); 
    110128    int i = 0; 
    111129    int count = 0; 
     
    146164            for (int u = v + 1; u < nVertices; u++) 
    147165            { 
     166                if (!_isFilter || (nodes[u] && nodes[v])) 
     167                { 
     168                    double difX = pos[v][0] - pos[u][0]; 
     169                    double difY = pos[v][1] - pos[u][1]; 
     170 
     171                    double dif = sqrt(difX * difX + difY * difY); 
     172 
     173                    if (dif == 0) 
     174                        dif = 1; 
     175 
     176                    if (dif < kk) 
     177                    { 
     178                        disp[v][0] = disp[v][0] + ((difX / dif) * repulsiveForce(dif)); 
     179                        disp[v][1] = disp[v][1] + ((difY / dif) * repulsiveForce(dif)); 
     180 
     181                        disp[u][0] = disp[u][0] - ((difX / dif) * repulsiveForce(dif)); 
     182                        disp[u][1] = disp[u][1] - ((difY / dif) * repulsiveForce(dif)); 
     183                    } 
     184                } 
     185            } 
     186        } 
     187 
     188        // calculate attractive forces 
     189        for (j = 0; j < nLinks; j++) 
     190        { 
     191            int v = links[j][0]; 
     192            int u = links[j][1]; 
     193 
     194            //cout << "v: " << v << " u: " << u << endl; 
     195 
     196            // cout << "     v: " << v << " u: " << u << " w: " << edge->weights << endl; 
     197            if (!_isFilter || (nodes[u] && nodes[v])) 
     198            { 
    148199                double difX = pos[v][0] - pos[u][0]; 
    149200                double difY = pos[v][1] - pos[u][1]; 
     
    154205                    dif = 1; 
    155206 
    156                 if (dif < kk) 
    157                 { 
    158                     disp[v][0] = disp[v][0] + ((difX / dif) * repulsiveForce(dif)); 
    159                     disp[v][1] = disp[v][1] + ((difY / dif) * repulsiveForce(dif)); 
    160  
    161                     disp[u][0] = disp[u][0] - ((difX / dif) * repulsiveForce(dif)); 
    162                     disp[u][1] = disp[u][1] - ((difY / dif) * repulsiveForce(dif)); 
    163                 } 
    164             } 
    165         } 
    166  
    167         // calculate attractive forces 
    168         for (j = 0; j < nLinks; j++) 
    169         { 
    170             int v = links[j][0]; 
    171             int u = links[j][1]; 
    172  
    173             //cout << "v: " << v << " u: " << u << endl; 
    174  
    175             // cout << "     v: " << v << " u: " << u << " w: " << edge->weights << endl; 
    176              
    177             double difX = pos[v][0] - pos[u][0]; 
    178             double difY = pos[v][1] - pos[u][1]; 
    179  
    180             double dif = sqrt(difX * difX + difY * difY); 
    181  
    182             if (dif == 0) 
    183                 dif = 1; 
    184  
    185             disp[v][0] = disp[v][0] - ((difX / dif) * attractiveForce(dif)); 
    186             disp[v][1] = disp[v][1] - ((difY / dif) * attractiveForce(dif)); 
    187  
    188             disp[u][0] = disp[u][0] + ((difX / dif) * attractiveForce(dif)); 
    189             disp[u][1] = disp[u][1] + ((difY / dif) * attractiveForce(dif)); 
     207                disp[v][0] = disp[v][0] - ((difX / dif) * attractiveForce(dif)); 
     208                disp[v][1] = disp[v][1] - ((difY / dif) * attractiveForce(dif)); 
     209 
     210                disp[u][0] = disp[u][0] + ((difX / dif) * attractiveForce(dif)); 
     211                disp[u][1] = disp[u][1] + ((difY / dif) * attractiveForce(dif)); 
     212            } 
    190213        } 
    191214 
     
    194217        for (v = 0; v < nVertices; v++) 
    195218        { 
    196             double dif = sqrt(disp[v][0] * disp[v][0] + disp[v][1] * disp[v][1]); 
    197  
    198             if (dif == 0) 
    199                 dif = 1; 
    200  
    201             pos[v][0] = pos[v][0] + ((disp[v][0] / dif) * min(fabs(disp[v][0]), temperature)); 
    202             pos[v][1] = pos[v][1] + ((disp[v][1] / dif) * min(fabs(disp[v][1]), temperature)); 
    203  
    204             //pos[v][0] = min((double)width,  max((double)0, pos[v][0])); 
    205             //pos[v][1] = min((double)height, max((double)0, pos[v][1])); 
     219            if (!_isFilter || nodes[v]) 
     220            { 
     221                double dif = sqrt(disp[v][0] * disp[v][0] + disp[v][1] * disp[v][1]); 
     222 
     223                if (dif == 0) 
     224                    dif = 1; 
     225 
     226                pos[v][0] = pos[v][0] + ((disp[v][0] / dif) * min(fabs(disp[v][0]), temperature)); 
     227                pos[v][1] = pos[v][1] + ((disp[v][1] / dif) * min(fabs(disp[v][1]), temperature)); 
     228 
     229                //pos[v][0] = min((double)width,  max((double)0, pos[v][0])); 
     230                //pos[v][1] = min((double)height, max((double)0, pos[v][1])); 
     231            } 
    206232        } 
    207233 
     
    281307} 
    282308 
     309/* ==== Create 1D Carray from PyArray ====================== 
     310 129     Assumes PyArray is contiguous in memory.             */ 
     311bool *TNetworkOptimization::pyvector_to_Carrayptrs(PyArrayObject *arrayin)  { 
     312    int n; 
     313 
     314    n = arrayin->dimensions[0]; 
     315    return (bool *) arrayin->data;  /* pointer to arrayin data as double */ 
     316} 
    283317 
    284318int TNetworkOptimization::setGraph(TGraphAsList *graph) 
     
    294328    //cout << "0" << endl; 
    295329    coors = (PyArrayObject *) PyArray_FromDims(2, dims, NPY_DOUBLE); 
     330    filter = (PyArrayObject *) PyArray_FromDims(1, dims, NPY_BOOL); 
    296331    pos = pymatrix_to_Carrayptrs(coors); 
     332    nodes = pyvector_to_Carrayptrs(filter); 
     333 
    297334    random(); 
    298335  
     
    464501} 
    465502 
     503PyObject *NetworkOptimization_get_filter(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> Filter")*/ 
     504{ 
     505    CAST_TO(TNetworkOptimization, graph);    
     506    Py_INCREF(graph->filter); 
     507    return (PyObject *)graph->filter;   
     508} 
     509 
    466510PyObject *NetworkOptimization_random(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "() -> None") 
    467511{ 
     
    469513 
    470514    graph->random(); 
     515     
     516    RETURN_NONE; 
     517} 
     518 
     519PyObject *NetworkOptimization_selectAll(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "() -> None") 
     520{ 
     521    CAST_TO(TNetworkOptimization, graph); 
     522 
     523    int i; 
     524    for (i = 0; i < graph->nVertices; i++) 
     525        graph->nodes[i] = true; 
     526     
     527    RETURN_NONE; 
     528} 
     529 
     530PyObject *NetworkOptimization_unselectAll(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "() -> None") 
     531{ 
     532    CAST_TO(TNetworkOptimization, graph); 
     533 
     534    int i; 
     535    for (i = 0; i < graph->nVertices; i++) 
     536        graph->nodes[i] = false; 
    471537     
    472538    RETURN_NONE; 
  • source/orangeom/networkoptimization.hpp

    r3664 r3684  
    6565    double **ptrvector(long n); 
    6666    double **pymatrix_to_Carrayptrs(PyArrayObject *arrayin); 
     67    bool *pyvector_to_Carrayptrs(PyArrayObject *arrayin); 
    6768    void free_Carrayptrs(double **v); 
    6869    void free_Links() 
     
    9192    int height; //PR 
    9293    PyArrayObject *coors; 
     94    PyArrayObject *filter; 
    9395 
    9496    int nLinks; 
    9597    int nVertices; 
    9698    int **links; 
    97  
     99    bool *nodes; 
    98100    double **pos; 
    99101    double attractiveForce(double x); 
    100102    double repulsiveForce(double x); 
    101103    double cool(double t); 
     104    bool isFilter(); 
    102105}; 
    103106 
Note: See TracChangeset for help on using the changeset viewer.