source: orange/source/orangeom/network.cpp @ 10312:6dce056d056b

Revision 10312:6dce056d056b, 42.2 KB checked in by Miha Stajdohar <miha.stajdohar@…>, 2 years ago (diff)

Test Jenkins.

Line 
1/*
2    This file is part of Orange.
3   
4    Copyright 1996-2010 Faculty of Computer and Information Science, University of Ljubljana
5    Author: Miha Stajdohar, 1996--2010
6    Contact: janez.demsar@fri.uni-lj.si
7
8    Orange is free software: you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation, either version 3 of the License, or
11    (at your option) any later version.
12
13    Orange is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with Orange.  If not, see <http://www.gnu.org/licenses/>.
20*/
21
22#include "ppp/network.ppp"
23
24TNetwork::TNetwork(TNetwork *net)
25: TGraphAsList(net->nVertices, net->nEdgeTypes, net->directed)
26{
27    import_array();
28    optimize.clear();
29    vector<int> vertices;
30    vector<int> neighbours;
31    desc = "";
32    name = "";
33    int v1;
34    for(v1 = 0; v1 < net->nVertices; v1++) {
35        net->getNeighboursFrom_Single(v1, neighbours);
36
37        ITERATE(vector<int>, ni, neighbours) {
38            double *w = getOrCreateEdge(v1, *ni);
39            *w = *net->getEdge(v1, *ni);
40        }
41        vertices.push_back(v1);
42        optimize.insert(v1);
43    }
44   
45    hierarchy.setTop(vertices);
46
47    npy_intp dims[2];
48    dims[0] = 2;
49    dims[1] = net->nVertices;
50    coors = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
51    pos = pymatrix_to_Carrayptrs(coors);
52   
53    int i;
54    /*
55    srand(time(NULL));
56    for (i = 0; i < net->nVertices; i++)
57    {
58        pos[0][i] = rand() % 10000;
59        pos[1][i] = rand() % 10000;
60    }
61    /**/
62    //*
63    if (net->pos == NULL || net->pos[0] == NULL || net->pos[1] == NULL) {
64        srand(time(NULL));
65        //cout << "null" << endl;
66        for (i = 0; i < net->nVertices; i++)
67        {
68            pos[0][i] = rand() % 10000;
69            pos[1][i] = rand() % 10000;
70        }
71    } else {
72        //cout << "not null" << endl;
73        for (i = 0; i < net->nVertices; i++) {
74            pos[0][i] = net->pos[0][i];
75            pos[1][i] = net->pos[1][i];
76        }
77    }
78    /**/
79}
80
81TNetwork::TNetwork(TGraphAsList *graph)
82: TGraphAsList(graph->nVertices, graph->nEdgeTypes, graph->directed)
83{
84    import_array();
85    optimize.clear();
86    vector<int> vertices;
87    vector<int> neighbours;
88    desc = "";
89    name = "";
90
91    for(int v1 = 0; v1 < graph->nVertices; v1++) {
92        graph->getNeighboursFrom_Single(v1, neighbours);
93
94        ITERATE(vector<int>, ni, neighbours) {
95            double *w = getOrCreateEdge(v1, *ni);
96            *w = *graph->getEdge(v1, *ni);
97        }
98
99        vertices.push_back(v1);
100        optimize.insert(v1);
101    }
102
103    hierarchy.setTop(vertices);
104
105    npy_intp dims[2];
106    dims[0] = 2;
107    dims[1] = graph->nVertices;
108    coors = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
109    pos = pymatrix_to_Carrayptrs(coors);
110
111    srand(time(NULL));
112    int i;
113    for (i = 0; i < graph->nVertices; i++)
114    {
115        pos[0][i] = rand() % 10000;
116        pos[1][i] = rand() % 10000;
117    }
118}
119
120TNetwork::TNetwork(const int &nVert, const int &nEdge, const bool dir)
121: TGraphAsList(nVert, nEdge, dir)
122{
123    import_array();
124    optimize.clear();
125    vector<int> vertices;
126    desc = "";
127    name = "";
128
129    int i;
130    for (i = 0; i < nVert; i++)
131    {
132        vertices.push_back(i);
133        optimize.insert(i);
134    }
135
136    hierarchy.setTop(vertices);
137
138    npy_intp dims[2];
139    dims[0] = 2;
140    dims[1] = nVert;
141    coors = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
142    pos = pymatrix_to_Carrayptrs(coors);
143
144    srand(time(NULL));
145    for (i = 0; i < nVert; i++)
146    {
147        pos[0][i] = rand() % 10000;
148        pos[1][i] = rand() % 10000;
149    }
150}
151
152TNetwork::~TNetwork()
153{
154    free_Carrayptrs(pos);
155    Py_DECREF(coors);
156}
157
158void TNetwork::hideVertices(vector<int> vertices)
159{
160  for (vector<int>::iterator it = vertices.begin(); it != vertices.end(); ++it)
161    {
162    optimize.erase(*it);
163  }
164}
165
166void TNetwork::showVertices(vector<int> vertices)
167{
168  for (vector<int>::iterator it = vertices.begin(); it != vertices.end(); ++it)
169    {
170    optimize.insert(*it);
171  }
172}
173
174void TNetwork::showAll()
175{
176  optimize.clear();
177  int i;
178  for (i = 0; i < nVertices; i++)
179  {
180    optimize.insert(i);
181  }
182}
183
184void TNetwork::printHierarchy()
185{
186  hierarchy.printChilds(hierarchy.top);
187  cout << endl;
188}
189
190
191/* ==== Free a double *vector (vec of pointers) ========================== */
192void TNetwork::free_Carrayptrs(double **v)  {
193
194    free((char*) v);
195}
196
197/* ==== Allocate a double *vector (vec of pointers) ======================
198    Memory is Allocated!  See void free_Carray(double ** )                  */
199double **TNetwork::ptrvector(int n)  {
200    double **v;
201    v=(double **)malloc((size_t) (n*sizeof(double *)));
202
203    if (!v)   {
204        printf("In **ptrvector. Allocation of memory for double array failed.");
205        exit(0);
206    }
207    return v;
208}
209
210/* ==== Create Carray from PyArray ======================
211    Assumes PyArray is contiguous in memory.
212    Memory is allocated!                                    */
213double **TNetwork::pymatrix_to_Carrayptrs(PyArrayObject *arrayin)  {
214    double **c, *a;
215    int i,n,m;
216
217    n = arrayin->dimensions[0];
218    m = arrayin->dimensions[1];
219    c = ptrvector(n);
220    a = (double *) arrayin->data;  /* pointer to arrayin data as double */
221
222    for (i = 0; i < n; i++) {
223        c[i] = a + i * m;
224    }
225
226    return c;
227}
228
229/* ==== Create 1D Carray from PyArray ======================
230 129     Assumes PyArray is contiguous in memory.             */
231bool *TNetwork::pyvector_to_Carrayptrs(PyArrayObject *arrayin)  {
232    int n;
233
234    n = arrayin->dimensions[0];
235    return (bool *) arrayin->data;  /* pointer to arrayin data as double */
236}
237
238TNetworkHierarchyNode::TNetworkHierarchyNode()
239{
240    parent = NULL;
241  vertex = INT_MIN;
242}
243
244TNetworkHierarchyNode::~TNetworkHierarchyNode()
245{
246  int i;
247  for (i = 0; i < childs.size(); i++)
248  {
249    if (childs[i])
250    {
251      delete childs[i];
252    }
253  }
254}
255
256int TNetworkHierarchyNode::getLevel()
257{
258  int level = 0;
259  TNetworkHierarchyNode *next_parent = parent;
260
261  while (next_parent != NULL)
262  {
263    if (next_parent->parent == NULL)
264      next_parent = NULL;
265    else
266      next_parent = next_parent->parent;
267    level++;
268  }
269
270  return level;
271}
272
273TNetworkHierarchy::TNetworkHierarchy()
274{
275    top = new TNetworkHierarchyNode();
276  meta_index = 0;
277  top->vertex = getNextMetaIndex();
278  top->parent = NULL;
279}
280
281TNetworkHierarchy::TNetworkHierarchy(vector<int> &topVertices)
282{
283    top = new TNetworkHierarchyNode();
284  meta_index = 0;
285  top->vertex = getNextMetaIndex();
286  top->parent = NULL;
287    setTop(topVertices);
288}
289
290TNetworkHierarchy::~TNetworkHierarchy()
291{
292    if (top)
293    {
294        delete top;
295    }
296}
297
298int TNetworkHierarchy::getNextMetaIndex()
299{
300  meta_index--;
301  return meta_index;
302}
303
304int TNetworkHierarchy::getMetaChildsCount(TNetworkHierarchyNode *node)
305{
306  int rv = 0;
307  int i;
308
309  for (i = 0; i < node->childs.size(); i++)
310  {
311    if (node->childs[i]->vertex < 0)
312      rv++;
313
314    rv += getMetaChildsCount(node->childs[i]);
315  }
316
317  return rv;
318}
319
320int TNetworkHierarchy::getMetasCount()
321{
322  return getMetaChildsCount(top);
323}
324
325void TNetworkHierarchy::printChilds(TNetworkHierarchyNode *node)
326{
327  if (node->childs.size() > 0)
328  {
329    cout << node->vertex << " | ";
330    int i;
331    for (i = 0; i < node->childs.size(); i++)
332    {
333      cout << node->childs[i]->vertex << " ";
334    }
335
336    cout << endl;
337
338    for (i = 0; i < node->childs.size(); i++)
339    {
340      printChilds(node->childs[i]);
341    }
342  }
343}
344
345void TNetworkHierarchy::setTop(vector<int> &vertices)
346{
347    top->childs.clear();
348  top->parent = NULL;
349
350    for (vector<int>::iterator it = vertices.begin(); it != vertices.end(); ++it)
351    {
352    TNetworkHierarchyNode *child = new TNetworkHierarchyNode();
353
354    child->vertex = *it;
355    child->parent = top;
356
357    top->childs.push_back(child);
358    }
359}
360
361void TNetworkHierarchy::addToNewMeta(vector<int> &vertices)
362{
363  vector<TNetworkHierarchyNode *> nodes;
364  int i;
365  TNetworkHierarchyNode *highest_parent = NULL;
366  for (i = 0; i < vertices.size(); i++)
367  {
368    TNetworkHierarchyNode *node = getNodeByVertex(vertices[i]);
369    nodes.push_back(node);
370    if (highest_parent)
371    {
372      if (node->parent && highest_parent->getLevel() > node->parent->getLevel())
373      {
374        highest_parent = node->parent;
375      }
376    }
377    else
378    {
379      highest_parent = node->parent;
380    }
381  }
382
383  TNetworkHierarchyNode *meta = new TNetworkHierarchyNode();
384  meta->parent = highest_parent;
385  meta->vertex = getNextMetaIndex();
386  highest_parent->childs.push_back(meta);
387
388  for (i = 0; i < nodes.size(); i++)
389  {
390    for (vector<TNetworkHierarchyNode *>::iterator it = nodes[i]->parent->childs.begin(); it != nodes[i]->parent->childs.end(); ++it)
391      {
392      if ((*it)->vertex == nodes[i]->vertex)
393      {
394        nodes[i]->parent->childs.erase(it);
395
396        // TODO: erase meta-nodes with 1 or 0 childs
397      }
398    }
399
400    nodes[i]->parent = meta;
401    meta->childs.push_back(nodes[i]);
402  }
403}
404
405void TNetworkHierarchy::expandMeta(int meta)
406{
407  TNetworkHierarchyNode *metaNode = getNodeByVertex(meta);
408
409  int i;
410  for (i = 0; i < metaNode->childs.size(); i++)
411  {
412    TNetworkHierarchyNode *node = node->childs[i];
413
414    node->parent = metaNode->parent;
415    metaNode->parent->childs.push_back(node);
416  }
417
418  // erase meta from parent
419  for (vector<TNetworkHierarchyNode *>::iterator it = metaNode->parent->childs.begin(); it != metaNode->parent->childs.end(); ++it)
420  {
421    if ((*it)->vertex == metaNode->vertex)
422    {
423      metaNode->parent->childs.erase(it);
424      break;
425    }
426  }
427
428  metaNode->childs.clear();
429  metaNode->parent = NULL;
430}
431
432TNetworkHierarchyNode *TNetworkHierarchy::getNodeByVertex(int vertex, TNetworkHierarchyNode &start)
433{
434  int i;
435  for (i = 0; i < start.childs.size(); i++)
436  {
437    if (start.childs[i]->vertex == vertex)
438    {
439      return start.childs[i];
440    }
441    else
442    {
443      TNetworkHierarchyNode *child = getNodeByVertex(vertex, *start.childs[i]);
444
445      if (child)
446      {
447        return child;
448      }
449    }
450  }
451
452  return NULL;
453}
454
455TNetworkHierarchyNode *TNetworkHierarchy::getNodeByVertex(int vertex)
456{
457  return getNodeByVertex(vertex, *top);
458}
459
460#include "externs.px"
461#include "orange_api.hpp"
462WRAPPER(GraphAsList);
463PyObject *Network_new(PyTypeObject *type, PyObject *args, PyObject *kwds) BASED_ON (GraphAsList, "(nVertices, directed[, nEdgeTypes])")
464{
465    PyTRY
466        int nVertices = 1, directed = 0, nEdgeTypes = 1;
467    PyObject *pygraph;
468    if (PyArg_ParseTuple(args, "O:Network", &pygraph))
469    {
470        if (PyOrNetwork_Check(pygraph))
471        {
472            //cout << "1" << endl;
473            TNetwork *net = PyOrange_AsNetwork(pygraph).getUnwrappedPtr();
474            TNetwork *network = mlnew TNetwork(net);
475            // set graphs attribut items of type ExampleTable to subgraph
476            //*
477            PyObject *strItems = PyString_FromString("items");
478            if (PyObject_HasAttr(pygraph, strItems) == 1)
479            {
480                PyObject* items = PyObject_GetAttr(pygraph, strItems);
481                network->items = &dynamic_cast<TExampleTable &>(PyOrange_AsOrange(items).getReference());
482            }
483            Py_DECREF(strItems);
484            /**/
485            return WrapNewOrange(network, type);
486        }
487        else if (PyOrGraphAsList_Check(pygraph))
488        {
489            //cout << "2" << endl;
490        TGraphAsList *graph = PyOrange_AsGraphAsList(pygraph).getUnwrappedPtr();
491            TNetwork *network = mlnew TNetwork(graph);
492           
493            // set graphs attribut items of type ExampleTable to subgraph
494            PyObject *strItems = PyString_FromString("items");
495            if (PyObject_HasAttr(pygraph, strItems) == 1)
496            {
497                PyObject* items = PyObject_GetAttr(pygraph, strItems);
498                network->items = &dynamic_cast<TExampleTable &>(PyOrange_AsOrange(items).getReference());
499            }
500            Py_DECREF(strItems);
501            return WrapNewOrange(network, type);
502      }
503        else
504        {
505            //cout << "3" << endl;
506            PyErr_Format(PyExc_TypeError, "Network.__new__: an instance of GraphAsList expected got '%s'", pygraph->ob_type->tp_name);
507            return PYNULL;
508        }
509    }
510
511    PyErr_Clear();
512
513    if (PyArg_ParseTuple(args, "|iii:Network", &nVertices, &directed, &nEdgeTypes))
514    {
515          return WrapNewOrange(mlnew TNetwork(nVertices, nEdgeTypes, directed != 0), type);
516    }
517
518    PYERROR(PyExc_TypeError, "Network.__new__: number of vertices directedness and optionaly, number of edge types expected", PYNULL);
519
520    PyCATCH
521}
522
523
524PyObject *Network_fromSymMatrix(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(matrix, lower, upper, kNN, andor) -> noConnectedNodes")
525{
526    PyTRY
527    CAST_TO(TNetwork, network);
528
529    PyObject *pyMatrix;
530    double lower;
531    double upper;
532    int kNN = 0;
533    int andor = 0;
534
535    if (!PyArg_ParseTuple(args, "Odd|ii:Network.fromDistanceMatrix", &pyMatrix, &lower, &upper, &kNN, &andor))
536        return PYNULL;
537
538    TSymMatrix *matrix = &dynamic_cast<TSymMatrix &>(PyOrange_AsOrange(pyMatrix).getReference());
539
540    if (matrix->dim != network->nVertices)
541        PYERROR(PyExc_TypeError, "DistanceMatrix dimension should equal number of vertices.", PYNULL);
542
543    int i,j;
544    int nConnected = 0;
545
546    if (matrix->matrixType == 0) {
547        // lower
548        for (i = 0; i < matrix->dim; i++) {
549            bool connected = false;
550            for (j = i+1; j < matrix->dim; j++) {
551                //cout << "i " << i << " j " << j;
552                double value = matrix->getitem(j,i);
553                //cout << " value " << value << endl;
554                if (lower <=  value && value <= upper) {
555                    //cout << "value: " << value << endl;
556                    double* w = network->getOrCreateEdge(j, i);
557                    *w = value;
558
559                    connected = true;
560                }
561            }
562
563            if (connected)
564                nConnected++;
565        }
566
567        vector<int> neighbours;
568        network->getNeighbours(0, neighbours);
569        if (neighbours.size() > 0)
570            nConnected++;
571    }
572    else {
573        // upper
574        for (i = 0; i < matrix->dim; i++) {
575            bool connected = false;
576            for (j = i+1; j < matrix->dim; j++) {
577                double value = matrix->getitem(i,j);
578                if (lower <=  value && value <= upper) {
579                    double* w = network->getOrCreateEdge(i, j);
580                    *w = value;
581                    connected = true;
582                }
583            }
584
585            if (connected)
586                nConnected++;
587
588            vector<int> neighbours;
589            network->getNeighbours(matrix->dim - 1, neighbours);
590            if (neighbours.size() > 0)
591                nConnected++;
592        }
593    }
594
595    return Py_BuildValue("i", nConnected);
596    PyCATCH;
597}
598
599typedef std::pair<int, int> coord_t;
600PyObject *Network_fromDistanceMatrix(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(matrix, lower, upper, kNN, andor) -> noConnectedNodes")
601{
602    PyTRY
603    CAST_TO(TNetwork, network);
604
605    PyObject *pyMatrix;
606    double lower;
607    double upper;
608    int kNN = 0;
609    int andor = 0;
610
611    if (!PyArg_ParseTuple(args, "Odd|ii:Network.fromDistanceMatrix", &pyMatrix, &lower, &upper, &kNN, &andor))
612        return PYNULL;
613
614    TSymMatrix *matrix = &dynamic_cast<TSymMatrix &>(PyOrange_AsOrange(pyMatrix).getReference());
615    //cout << "kNN: " << kNN << endl;
616    //cout << "andor: " << andor << endl;
617
618    if (matrix->dim != network->nVertices)
619        PYERROR(PyExc_TypeError, "DistanceMatrix dimension should equal number of vertices.", PYNULL);
620
621    int i,j;
622    int nConnected = 0;
623    vector<coord_t> edges_interval;
624
625    if (matrix->matrixType == 0) {
626        // lower
627        for (i = 0; i < matrix->dim; i++) {
628            bool connected = false;
629            for (j = i+1; j < matrix->dim; j++) {
630                //cout << "i " << i << " j " << j;
631                double value = matrix->getitem(j,i);
632                //cout << " value " << value << endl;
633                if (lower <=  value && value <= upper) {
634                    connected = true;
635                    edges_interval.push_back(coord_t(j, i));
636                }
637            }
638
639            if (connected)
640                nConnected++;
641        }
642
643        vector<int> neighbours;
644        network->getNeighbours(0, neighbours);
645        if (neighbours.size() > 0)
646            nConnected++;
647    }
648    else {
649        // upper
650        for (i = 0; i < matrix->dim; i++) {
651            bool connected = false;
652            for (j = i+1; j < matrix->dim; j++) {
653                double value = matrix->getitem(i,j);
654                if (lower <=  value && value <= upper) {
655                    connected = true;
656                    edges_interval.push_back(coord_t(i, j));
657                }
658            }
659
660            if (connected)
661                nConnected++;
662
663            vector<int> neighbours;
664            network->getNeighbours(matrix->dim - 1, neighbours);
665            if (neighbours.size() > 0)
666                nConnected++;
667        }
668    }
669    //cout << "calculating knn, dim: " << matrix->dim << endl;
670    vector<coord_t> edges_knn;
671
672    if (kNN > 0) {
673        for (i = 0; i < matrix->dim; i++) {
674            vector<int> closest;
675            matrix->getknn(i, kNN, closest);
676
677            for (j = 0; j < closest.size(); j++) {
678                edges_knn.push_back(coord_t(i, closest[j]));
679            }
680        }
681    }
682
683    //cout << "n edges: " << edges_interval.size() + edges_knn.size() << endl;
684
685    if (andor == 0) {
686        //cout << "insert interval" << endl;
687        for (i=0; i < edges_interval.size(); i++) {
688            //cout << edges_interval[i].first << ", " << edges_interval[i].second << endl;
689            double* w = network->getOrCreateEdge(edges_interval[i].first, edges_interval[i].second);
690            double value = matrix->getitem(edges_interval[i].first, edges_interval[i].second);
691            *w = value;
692            //cout << edges_interval[i].first << "," << edges_interval[i].second << "," << *w << endl;
693        }
694        //cout << "insert knn" << endl;
695        for (i = 0; i < edges_knn.size(); i++) {
696            //cout << edges_knn[i].first << ", " << edges_knn[i].second << endl;
697            double* w = network->getOrCreateEdge(edges_knn[i].first, edges_knn[i].second);
698            double value = matrix->getitem(edges_knn[i].first, edges_knn[i].second);
699            *w = value;
700            //cout << edges_interval[i].first << "," << edges_interval[i].second << "," << *w << endl;
701
702        }
703
704    }
705
706    return Py_BuildValue("i", nConnected);
707    PyCATCH;
708}
709
710PyObject *Network_printHierarchy(PyObject *self, PyObject *) PYARGS(METH_NOARGS, "None -> None")
711{
712  PyTRY
713    CAST_TO(TNetwork, network);
714    network->printHierarchy();
715    RETURN_NONE
716  PyCATCH;
717}
718
719PyObject *Network_printNodeByVertex(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(vertex) -> None")
720{
721  PyTRY
722    int vertexNdx;
723
724    if (!PyArg_ParseTuple(args, "i:Network.printNodeByVertex", &vertexNdx))
725          return PYNULL;
726
727    CAST_TO(TNetwork, network);
728    TNetworkHierarchyNode* vertex = network->hierarchy.getNodeByVertex(vertexNdx);
729    cout << "vertex: " << vertex->vertex << endl;
730    cout << "n of childs: " << vertex->childs.size() << endl;
731    cout << "level: " << vertex->getLevel() << endl;
732    RETURN_NONE
733  PyCATCH;
734}
735
736PyObject *Network_groupVerticesInHierarchy(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(List of vertices) -> None")
737{
738  PyTRY
739    PyObject *pyVertices;
740
741    if (!PyArg_ParseTuple(args, "O:Network.groupVerticesInHierarchy", &pyVertices))
742          return PYNULL;
743
744    int size = PyList_Size(pyVertices);
745    int i;
746        vector<int> vertices;
747        for (i = 0; i < size; i++)
748        {
749      int vertex = PyInt_AsLong(PyList_GetItem(pyVertices, i));
750      vertices.push_back(vertex);
751    }
752
753    CAST_TO(TNetwork, network);
754    network->hierarchy.addToNewMeta(vertices);
755    RETURN_NONE
756  PyCATCH;
757}
758
759PyObject *Network_expandMeta(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(index) -> None")
760{
761  PyTRY
762    int meta;
763
764    if (!PyArg_ParseTuple(args, "i:Network.groupVerticesInHierarchy", &meta))
765          return PYNULL;
766
767    CAST_TO(TNetwork, network);
768    network->hierarchy.expandMeta(meta);
769    RETURN_NONE
770  PyCATCH;
771}
772
773PyObject *Network_hideVertices(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(List of vertices) -> None")
774{
775  PyTRY
776    PyObject *pyVertices;
777
778    if (!PyArg_ParseTuple(args, "O:Network.hideVertices", &pyVertices))
779          return PYNULL;
780
781    int size = PyList_Size(pyVertices);
782    int i;
783        vector<int> vertices;
784        for (i = 0; i < size; i++)
785        {
786      int vertex = PyInt_AsLong(PyList_GetItem(pyVertices, i));
787      vertices.push_back(vertex);
788    }
789
790    CAST_TO(TNetwork, network);
791    network->hideVertices(vertices);
792    RETURN_NONE
793  PyCATCH;
794}
795
796PyObject *Network_showVertices(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(List of vertices) -> None")
797{
798  PyTRY
799    PyObject *pyVertices;
800
801    if (!PyArg_ParseTuple(args, "O:Network.showVertices", &pyVertices))
802          return PYNULL;
803
804    int size = PyList_Size(pyVertices);
805    int i;
806        vector<int> vertices;
807        for (i = 0; i < size; i++)
808        {
809      int vertex = PyInt_AsLong(PyList_GetItem(pyVertices, i));
810      vertices.push_back(vertex);
811    }
812
813    CAST_TO(TNetwork, network);
814    network->showVertices(vertices);
815    RETURN_NONE
816  PyCATCH;
817}
818
819PyObject *Network_showAll(PyObject *self, PyObject *) PYARGS(METH_NOARGS, "None -> None")
820{
821  PyTRY
822    CAST_TO(TNetwork, network);
823    network->showAll();
824    RETURN_NONE
825  PyCATCH;
826}
827
828PyObject *Network_getVisible(PyObject *self, PyObject *) PYARGS(METH_NOARGS, "None -> None")
829{
830  PyTRY
831    CAST_TO(TNetwork, network);
832
833    PyObject *pyVisible = PyList_New(0);
834
835    for (set<int>::iterator it = network->optimize.begin(); it != network->optimize.end(); ++it)
836      {
837      PyObject *nel = Py_BuildValue("i", *it);
838            PyList_Append(pyVisible, nel);
839            Py_DECREF(nel);
840    }
841
842      return pyVisible;
843  PyCATCH;
844}
845
846PyObject *Network_get_coors(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> Coors")*/
847{
848  PyTRY
849    CAST_TO(TNetwork, graph);
850    Py_INCREF(graph->coors);
851    return (PyObject *)graph->coors;
852  PyCATCH
853}
854
855PyObject *Network_get_description(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> desc")*/
856{
857  PyTRY
858    CAST_TO(TNetwork, graph);
859    //Py_INCREF(graph->desc);
860    return PyString_FromString(graph->desc.c_str());
861  PyCATCH
862}
863
864PyObject *Network_get_name(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> name")*/
865{
866  PyTRY
867    CAST_TO(TNetwork, graph);
868    //Py_INCREF(graph->desc);
869    return PyString_FromString(graph->name.c_str());
870  PyCATCH
871}
872
873int getWords(string const& s, vector<string> &container)
874{
875    int n = 0;
876    bool quotation = false;
877    container.clear();
878    string::const_iterator it = s.begin(), end = s.end(), first;
879    for (first = it; it != end; ++it) {
880        // Examine each character and if it matches the delimiter
881        if ((!quotation && (' ' == *it || '\t' == *it || '\r' == *it || '\f' == *it || '\v' == *it || ',' == *it)) || ('\n' == *it)) {
882            if (first != it) {
883                // extract the current field from the string and
884                // append the current field to the given container
885                container.push_back(string(first, it));
886                ++n;
887
888                // skip the delimiter
889                first = it + 1;
890            } else {
891                ++first;
892            }
893        }
894        else if (('\"' == *it) || ('\'' == *it) || ('(' == *it) || (')' == *it)) {
895            if (quotation) {
896                quotation = false;
897
898                // extract the current field from the string and
899                // append the current field to the given container
900                container.push_back(string(first, it));
901                ++n;
902
903                // skip the delimiter
904                first = it + 1;
905            } else {
906                quotation = true;
907
908                // skip the quotation
909                first = it + 1;
910            }
911        }
912    }
913    if (first != it) {
914        // extract the last field from the string and
915        // append the last field to the given container
916        container.push_back(string(first, it));
917        ++n;
918    }
919    return n;
920}
921
922WRAPPER(ExampleTable)
923
924PyObject *Network_readGML(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(fn) -> Network")
925{
926  PyTRY
927
928    TNetwork *graph;
929    TDomain *domain = new TDomain();
930    PDomain wdomain = domain;
931    TExampleTable *table;
932    PExampleTable wtable;
933    char *fn;
934
935    if (!PyArg_ParseTuple(args, "s:Network.readGML", &fn))
936        return NULL;
937   
938    struct GML_pair* list;
939    struct GML_stat* stat=(struct GML_stat*)malloc(sizeof(struct GML_stat));
940    stat->key_list = NULL;
941   
942    FILE* file = fopen (fn, "r");
943   
944    if (file == 0) { 
945        printf ("\n No such file: %s", fn);
946    } else {
947        GML_init();
948       
949        list = GML_parser(file, stat, 0);
950       
951        if (stat->err.err_num != GML_OK) {
952            printf ("An error occured while reading line %d column %d of %s:\n", stat->err.line, stat->err.column, fn);
953       
954            switch (stat->err.err_num) {
955                case GML_UNEXPECTED:
956                    printf ("UNEXPECTED CHARACTER");
957                    break;
958           
959                case GML_SYNTAX:
960                    printf ("SYNTAX ERROR"); 
961                    break;
962           
963                case GML_PREMATURE_EOF:
964                    printf ("PREMATURE EOF IN STRING");
965                    break;
966           
967                case GML_TOO_MANY_DIGITS:
968                    printf ("NUMBER WITH TOO MANY DIGITS");
969                    break;
970           
971                case GML_OPEN_BRACKET:
972                    printf ("OPEN BRACKETS LEFT AT EOF");
973                    break;
974           
975                case GML_TOO_MANY_BRACKETS:
976                    printf ("TOO MANY CLOSING BRACKETS");
977                    break;
978       
979                default:
980                    break;
981            }   
982            printf ("\n");
983        }     
984   
985        while (list) {
986            if (strcmp(list->key, "graph") == 0) {
987                int nVertices = 0;
988                int directed = 0;
989                map<int, int> nodes;
990                vector< vector<int> > edges;
991                string graphName = "";
992
993                TFloatVariable *indexVar = new TFloatVariable("index");
994                indexVar->numberOfDecimals = 0;
995                TFloatVariable *idVar = new TFloatVariable("id");
996                idVar->numberOfDecimals = 0;
997                domain->addVariable(indexVar);
998                domain->addVariable(idVar);
999                domain->addVariable(new TStringVariable("label"));
1000                table = new TExampleTable(domain);
1001                wtable = table;
1002
1003                struct GML_pair* graph_obj = list->value.list;
1004                while (graph_obj) {
1005                    if (strcmp(graph_obj->key, "node") == 0) {
1006                        float index = nVertices;
1007                        float id;
1008                        char* label;
1009                        struct GML_pair* tmp = graph_obj->value.list;
1010                        while (tmp) {
1011                            if (strcmp(tmp->key, "id") == 0)
1012                                id = tmp->value.integer;
1013                            if (strcmp(tmp->key, "label") == 0)
1014                                label = tmp->value.string;
1015                            tmp = tmp->next;
1016                        }
1017                        TExample *example = new TExample(domain);
1018                        (*example)[0] = TValue(index);
1019                        (*example)[1] = TValue(id);
1020                        (*example)[2] = TValue(new TStringValue(label), STRINGVAR);
1021                        table->push_back(example);
1022                        nodes[id] = nVertices;
1023                        nVertices++;
1024                    }
1025                    if (strcmp(graph_obj->key, "edge") == 0) {
1026                        long target;
1027                        long source;
1028
1029                        struct GML_pair* tmp = graph_obj->value.list;
1030                        while (tmp) {
1031                            if (strcmp(tmp->key, "source") == 0)
1032                                source = tmp->value.integer;
1033                            if (strcmp(tmp->key, "target") == 0)
1034                                target = tmp->value.integer;
1035                            tmp = tmp->next;
1036                        }
1037
1038                        vector<int> v;
1039                        v.push_back(source);
1040                        v.push_back(target);
1041                        edges.push_back(v);
1042                    }
1043                    if (strcmp(graph_obj->key, "directed") == 0) {
1044                        directed = graph_obj->value.integer;
1045                    }
1046                    if (strcmp(graph_obj->key, "label") == 0) {
1047                        graphName = graph_obj->value.string;
1048                    }
1049
1050
1051                    graph_obj = graph_obj->next;
1052                }
1053
1054                graph = mlnew TNetwork(nodes.size(), 1, directed == 1);
1055                graph->name = graphName;
1056
1057                for (vector< vector<int> >::iterator it = edges.begin(); it!=edges.end(); ++it) {
1058                    int u = nodes[(*it)[0]];
1059                    int v = nodes[(*it)[1]];
1060                    double *w = graph->getOrCreateEdge(u, v);
1061                    *w = 1.0;
1062                }
1063            }
1064
1065            list = list->next;
1066        }
1067        GML_free_list (list, stat->key_list);
1068        graph->items = wtable;
1069        return WrapNewOrange(graph, self->ob_type); // WrapOrange(graph);
1070    }
1071    return NULL;
1072  PyCATCH
1073}
1074
1075PyObject *Network_readPajek(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(fn) -> Network")
1076{
1077  PyTRY
1078
1079    TNetwork *graph;
1080    TDomain *domain = new TDomain();
1081    PDomain wdomain = domain;
1082    TExampleTable *table;
1083    PExampleTable wtable;
1084    int directed = 0;
1085    //cout << "readNetwork" << endl;
1086    char *fn;
1087
1088    if (!PyArg_ParseTuple(args, "s|i:Network.readPajek", &fn, &directed))
1089        return NULL;
1090
1091    //cout << "File: " << fn << endl;
1092
1093    string line;
1094    ifstream file(fn);
1095    string graphName = "";
1096    string description = "";
1097    int nVertices = 0;
1098    int nEdges = 0;
1099
1100    if (file.is_open())
1101    {
1102        // read head
1103        while (!file.eof())
1104        {
1105            getline (file, line);
1106            vector<string> words;
1107            int n = getWords(line, words);
1108            //cout << line << "  -  " << n << endl;
1109            if (n > 0)
1110            {
1111                if (stricmp(words[0].c_str(), "*network") == 0)
1112                {
1113                    //cout << "Network" << endl;
1114                    if (n > 1)
1115                    {
1116                        graphName = words[1];
1117                        //cout << "Graph name: " << graphName << endl;
1118                    }
1119                    else
1120                    {
1121                        file.close();
1122                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1123                    }
1124                }
1125                else if (stricmp(words[0].c_str(), "*description") == 0)
1126                {
1127                    //cout << "Network" << endl;
1128                    if (n > 1)
1129                    {
1130                        description = words[1];
1131                        //cout << "description: " << description << endl;
1132                    }
1133                    else
1134                    {
1135                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1136                    }
1137                }
1138                else if (stricmp(words[0].c_str(), "*vertices") == 0) {
1139                    //cout << "Vertices" << endl;
1140                    if (n > 1) {
1141                        istringstream strVertices(words[1]);
1142                        strVertices >> nVertices;
1143                        if (nVertices == 0) {
1144                            file.close();
1145                            PYERROR(PyExc_SystemError, "invalid file format", NULL);
1146                        }
1147                    } else {
1148                        file.close();
1149                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1150                    }
1151                    if (n > 2) {
1152                        istringstream strEdges(words[2]);
1153                        strEdges >> nEdges;
1154                    }
1155                }
1156                else if (stricmp(words[0].c_str(), "*arcs") == 0) {
1157                    directed = 1;
1158                    break;
1159                }
1160            }
1161        }
1162        file.close();
1163    }
1164
1165    ifstream file1(fn);
1166    if (file1.is_open())
1167    {
1168        // read head
1169        while (!file1.eof())
1170        {
1171            getline (file1, line);
1172            vector<string> words;
1173            int n = getWords(line, words);
1174            //cout << line << "  -  " << n << endl;
1175            if (n > 0)
1176            {
1177                if (stricmp(words[0].c_str(), "*vertices") == 0)
1178                {
1179                    //cout << "Vertices" << endl;
1180                    if (n > 1)
1181                    {
1182                        istringstream strVertices(words[1]);
1183                        strVertices >> nVertices;
1184                        if (nVertices == 0)
1185                        {
1186                            file1.close();
1187                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1188                        }
1189
1190                        //cout << "nVertices: " << nVertices << endl;
1191                    }
1192                    else
1193                    {
1194                        file1.close();
1195                        PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1196                    }
1197
1198                    break;
1199                }
1200            }
1201        }
1202
1203        if (nVertices <= 1) {
1204            file1.close();
1205            PYERROR(PyExc_SystemError, "invalid file1 format; invalid number of vertices (less than 1)", NULL);
1206        }
1207
1208        graph = mlnew TNetwork(nVertices, nEdges, directed == 1);
1209        graph->desc = description;
1210        graph->name = graphName;
1211
1212        TFloatVariable *indexVar = new TFloatVariable("index");
1213        indexVar->numberOfDecimals = 0;
1214        domain->addVariable(indexVar);
1215        domain->addVariable(new TStringVariable("label"));
1216        domain->addVariable(new TFloatVariable("x"));
1217        domain->addVariable(new TFloatVariable("y"));
1218        domain->addVariable(new TFloatVariable("z"));
1219        domain->addVariable(new TStringVariable("ic"));
1220        domain->addVariable(new TStringVariable("bc"));
1221        domain->addVariable(new TStringVariable("bw"));
1222        table = new TExampleTable(domain);
1223        wtable = table;
1224
1225        // read vertex descriptions
1226        int row = 0;
1227        while (!file1.eof())
1228        {
1229            getline(file1, line);
1230            vector<string> words;
1231            int n = getWords(line, words);
1232            //cout << line << "  -  " << n << endl;
1233            if (n > 0)
1234            {
1235                TExample *example = new TExample(domain);
1236
1237                if ((stricmp(words[0].c_str(), "*arcs") == 0) || (stricmp(words[0].c_str(), "*edges") == 0))
1238                    break;
1239
1240                float index = -1;
1241                istringstream strIndex(words[0]);
1242                strIndex >> index;
1243                if ((index <= 0) || (index > nVertices))
1244                {
1245                    file1.close();
1246                    PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1247                }
1248
1249                //cout << "index: " << index << " n: " << n << endl;
1250                (*example)[0] = TValue(index);
1251
1252                if (n > 1)
1253                {
1254                    string label = words[1];
1255                    //cout << "label: " << label << endl;
1256                    (*example)[1] = TValue(new TStringValue(label), STRINGVAR);
1257
1258                    int i = 2;
1259                    char *xyz = "  xyz";
1260                    // read coordinates
1261                    while ((i <= 4) && (i < n))
1262                    {
1263                        double coor = -1;
1264                        istringstream strCoor(words[i]);
1265                        strCoor >> coor;
1266
1267                        //if ((coor < 0) || (coor > 1))
1268                        //  break;
1269
1270                        //cout << xyz[i] << ": " << coor << endl;
1271                        (*example)[i] = TValue((float)coor);
1272
1273                        if (i == 2)
1274                            graph->pos[0][row] = coor;
1275
1276                        if (i == 3)
1277                            graph->pos[1][row] = coor;
1278
1279                        i++;
1280                    }
1281                    // read attributes
1282                    while (i < n)
1283                    {
1284                        if (stricmp(words[i].c_str(), "ic") == 0)
1285                        {
1286                            if (i + 1 < n)
1287                                i++;
1288                            else
1289                            {
1290                                file1.close();
1291                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1292                            }
1293
1294                            //cout << "ic: " << words[i] << endl;
1295                            (*example)[5] = TValue(new TStringValue(words[i]), STRINGVAR);
1296                        }
1297                        else if (stricmp(words[i].c_str(), "bc") == 0)
1298                        {
1299                            if (i + 1 < n)
1300                                i++;
1301                            else
1302                            {
1303                                file1.close();
1304                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1305                            }
1306
1307                            //cout << "bc: " << words[i] << endl;
1308                            (*example)[6] = TValue(new TStringValue(words[i]), STRINGVAR);
1309                        }
1310                        else if (stricmp(words[i].c_str(), "bw") == 0)
1311                        {
1312                            if (i + 1 < n)
1313                                i++;
1314                            else
1315                            {
1316                                file1.close();
1317                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1318                            }
1319
1320                            //cout << "bw: " << words[i] << endl;
1321                            (*example)[7] = TValue(new TStringValue(words[i]), STRINGVAR);
1322                        }
1323                        i++;
1324                    }
1325
1326                }
1327                example->id = getExampleId();
1328                table->push_back(example);
1329                //cout << "push back" <<endl;
1330            }
1331
1332            row++;
1333        }
1334        // read arcs
1335        vector<string> words;
1336        int n = getWords(line, words);
1337        if (n > 0)
1338        {
1339            if (stricmp(words[0].c_str(), "*arcs") == 0)
1340            {
1341                while (!file1.eof())
1342                {
1343                    getline (file1, line);
1344                    vector<string> words;
1345                    int n = getWords(line, words);
1346                    if (n > 0)
1347                    {
1348                        if (stricmp(words[0].c_str(), "*edges") == 0)
1349                            break;
1350
1351                        if (n > 1)
1352                        {
1353                            int i1 = -1;
1354                            int i2 = -1;
1355                            istringstream strI1(words[0]);
1356                            istringstream strI2(words[1]);
1357                            strI1 >> i1;
1358                            strI2 >> i2;
1359                           
1360                            if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices))
1361                            {
1362                                file1.close();
1363                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1364                            }
1365
1366                            if (i1 == i2) continue;
1367
1368                            if (n > 2) {
1369                                vector<string> weights;
1370                                int m = getWords(words[2], weights);
1371                                int i;
1372                                for (i=0; i < m; i++) {
1373                                    double i3 = 0;
1374                                    istringstream strI3(weights[i]);
1375                                    strI3 >> i3;
1376                                    *(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1377                                    if (!directed) {
1378                                        *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1379                                    }
1380                                }
1381                            }
1382                        }
1383                    }
1384                }
1385            }
1386        }
1387        // read edges
1388        n = getWords(line, words);
1389        if (n > 0) {
1390            if (stricmp(words[0].c_str(), "*edges") == 0) {
1391                while (!file1.eof()) {
1392                    getline (file1, line);
1393                    vector<string> words;
1394                    int n = getWords(line, words);
1395                    if (n > 1) {
1396                        int i1 = -1;
1397                        int i2 = -1;
1398                        istringstream strI1(words[0]);
1399                        istringstream strI2(words[1]);
1400                        strI1 >> i1;
1401                        strI2 >> i2;
1402                       
1403                        if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices)) {
1404                            file1.close();
1405                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1406                        }
1407
1408                        if (i1 == i2) continue;
1409                       
1410                        if (n > 2) {
1411                            vector<string> weights;
1412                            int m = getWords(words[2], weights);
1413                            int i;
1414                            for (i=0; i < m; i++) {
1415                                double i3 = 0;
1416                                istringstream strI3(weights[i]);
1417                                strI3 >> i3;
1418                                *(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1419                                if (!directed) {
1420                                    *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1421                                }
1422                               
1423                            }
1424                        }
1425                    }
1426                }
1427            }
1428        }
1429        file1.close();
1430    } else {
1431      PyErr_Format(PyExc_SystemError, "unable to open file1 '%s'", fn);
1432      return NULL;
1433    }
1434
1435    graph->items = wtable;
1436    return WrapNewOrange(graph, self->ob_type); // WrapOrange(graph);
1437
1438  PyCATCH
1439}
1440
1441PyObject *Network_parseNetwork(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(network_string) -> Network")
1442{
1443  PyTRY
1444
1445    TNetwork *graph;
1446    TDomain *domain = new TDomain();
1447    PDomain wdomain = domain;
1448    TExampleTable *table;
1449    PExampleTable wtable;
1450    int directed = 0;
1451    //cout << "readNetwork" << endl;
1452    char *fn;
1453
1454    if (!PyArg_ParseTuple(args, "s|i:Network.parseNetwork", &fn, &directed))
1455        return NULL;
1456
1457    //cout << "File: " << fn << endl;
1458
1459    string line;
1460    istringstream file(fn, istringstream::in);
1461    string graphName = "";
1462    string description = "";
1463    int nVertices = 0;
1464    int nEdges = 0;
1465
1466    if (file.good())
1467    {
1468        // read head
1469        while (!file.eof())
1470        {
1471            getline (file, line);
1472            vector<string> words;
1473            int n = getWords(line, words);
1474            //cout << line << "  -  " << n << endl;
1475            if (n > 0)
1476            {
1477                if (stricmp(words[0].c_str(), "*network") == 0)
1478                {
1479                    //cout << "Network" << endl;
1480                    if (n > 1)
1481                    {
1482                        graphName = words[1];
1483                        //cout << "Graph name: " << graphName << endl;
1484                    }
1485                    else
1486                    {
1487                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1488                    }
1489                }
1490                else if (stricmp(words[0].c_str(), "*description") == 0)
1491                {
1492                    //cout << "Network" << endl;
1493                    if (n > 1)
1494                    {
1495                        description = words[1];
1496                        //cout << "description: " << description << endl;
1497                    }
1498                    else
1499                    {
1500                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1501                    }
1502                }
1503                else if (stricmp(words[0].c_str(), "*vertices") == 0) {
1504                    //cout << "Vertices" << endl;
1505                    if (n > 1) {
1506                        istringstream strVertices(words[1]);
1507                        strVertices >> nVertices;
1508                        if (nVertices == 0) {
1509                            PYERROR(PyExc_SystemError, "invalid file format", NULL);
1510                        }
1511                    } else {
1512                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1513                    }
1514                    if (n > 2) {
1515                        istringstream strEdges(words[2]);
1516                        strEdges >> nEdges;
1517                    }
1518                }
1519                else if (stricmp(words[0].c_str(), "*arcs") == 0) {
1520                    directed = 1;
1521                    break;
1522                }
1523            }
1524        }
1525    }
1526
1527    istringstream file1(fn, istringstream::in);
1528    if (file1.good())
1529    {
1530        // read head
1531        while (!file1.eof())
1532        {
1533            getline (file1, line);
1534            vector<string> words;
1535            int n = getWords(line, words);
1536            //cout << line << "  -  " << n << endl;
1537            if (n > 0)
1538            {
1539                if (stricmp(words[0].c_str(), "*vertices") == 0)
1540                {
1541                    //cout << "Vertices" << endl;
1542                    if (n > 1)
1543                    {
1544                        istringstream strVertices(words[1]);
1545                        strVertices >> nVertices;
1546                        if (nVertices == 0)
1547                        {
1548                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1549                        }
1550
1551                        //cout << "nVertices: " << nVertices << endl;
1552                    }
1553                    else
1554                    {
1555                        PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1556                    }
1557
1558                    break;
1559                }
1560            }
1561        }
1562
1563        if (nVertices <= 1) {
1564            PYERROR(PyExc_SystemError, "invalid file1 format; invalid number of vertices (less than 1)", NULL);
1565        }
1566
1567        graph = mlnew TNetwork(nVertices, nEdges, directed == 1);
1568
1569        TFloatVariable *indexVar = new TFloatVariable("index");
1570        indexVar->numberOfDecimals = 0;
1571        domain->addVariable(indexVar);
1572        domain->addVariable(new TStringVariable("label"));
1573        domain->addVariable(new TFloatVariable("x"));
1574        domain->addVariable(new TFloatVariable("y"));
1575        domain->addVariable(new TFloatVariable("z"));
1576        domain->addVariable(new TStringVariable("ic"));
1577        domain->addVariable(new TStringVariable("bc"));
1578        domain->addVariable(new TStringVariable("bw"));
1579        table = new TExampleTable(domain);
1580        wtable = table;
1581
1582        // read vertex descriptions
1583        int row = 0;
1584        while (!file1.eof())
1585        {
1586            getline(file1, line);
1587            vector<string> words;
1588            int n = getWords(line, words);
1589            //cout << line << "  -  " << n << endl;
1590            if (n > 0)
1591            {
1592                TExample *example = new TExample(domain);
1593
1594                if ((stricmp(words[0].c_str(), "*arcs") == 0) || (stricmp(words[0].c_str(), "*edges") == 0))
1595                    break;
1596
1597                float index = -1;
1598                istringstream strIndex(words[0]);
1599                strIndex >> index;
1600                if ((index <= 0) || (index > nVertices))
1601                {
1602                    PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1603                }
1604
1605                //cout << "index: " << index << " n: " << n << endl;
1606                (*example)[0] = TValue(index);
1607
1608                if (n > 1)
1609                {
1610                    string label = words[1];
1611                    //cout << "label: " << label << endl;
1612                    (*example)[1] = TValue(new TStringValue(label), STRINGVAR);
1613
1614                    int i = 2;
1615                    char *xyz = "  xyz";
1616                    // read coordinates
1617                    while ((i <= 4) && (i < n))
1618                    {
1619                        double coor = -1;
1620                        istringstream strCoor(words[i]);
1621                        strCoor >> coor;
1622
1623                        //if ((coor < 0) || (coor > 1))
1624                        //  break;
1625
1626                        //cout << xyz[i] << ": " << coor << endl;
1627                        (*example)[i] = TValue((float)coor);
1628
1629                        if (i == 2)
1630                            graph->pos[0][row] = coor;
1631
1632                        if (i == 3)
1633                            graph->pos[1][row] = coor;
1634
1635                        i++;
1636                    }
1637                    // read attributes
1638                    while (i < n)
1639                    {
1640                        if (stricmp(words[i].c_str(), "ic") == 0)
1641                        {
1642                            if (i + 1 < n)
1643                                i++;
1644                            else
1645                            {
1646                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1647                            }
1648
1649                            //cout << "ic: " << words[i] << endl;
1650                            (*example)[5] = TValue(new TStringValue(words[i]), STRINGVAR);
1651                        }
1652                        else if (stricmp(words[i].c_str(), "bc") == 0)
1653                        {
1654                            if (i + 1 < n)
1655                                i++;
1656                            else
1657                            {
1658                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1659                            }
1660
1661                            //cout << "bc: " << words[i] << endl;
1662                            (*example)[6] = TValue(new TStringValue(words[i]), STRINGVAR);
1663                        }
1664                        else if (stricmp(words[i].c_str(), "bw") == 0)
1665                        {
1666                            if (i + 1 < n)
1667                                i++;
1668                            else
1669                            {
1670                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1671                            }
1672
1673                            //cout << "bw: " << words[i] << endl;
1674                            (*example)[7] = TValue(new TStringValue(words[i]), STRINGVAR);
1675                        }
1676                        i++;
1677                    }
1678
1679                }
1680                example->id = getExampleId();
1681                table->push_back(example);
1682                //cout << "push back" <<endl;
1683            }
1684
1685            row++;
1686        }
1687        // read arcs
1688        vector<string> words;
1689        int n = getWords(line, words);
1690        if (n > 0)
1691        {
1692            if (stricmp(words[0].c_str(), "*arcs") == 0)
1693            {
1694                while (!file1.eof())
1695                {
1696                    getline (file1, line);
1697                    vector<string> words;
1698                    int n = getWords(line, words);
1699                    if (n > 0)
1700                    {
1701                        if (stricmp(words[0].c_str(), "*edges") == 0)
1702                            break;
1703
1704                        if (n > 1)
1705                        {
1706                            int i1 = -1;
1707                            int i2 = -1;
1708                            istringstream strI1(words[0]);
1709                            istringstream strI2(words[1]);
1710                            strI1 >> i1;
1711                            strI2 >> i2;
1712                           
1713                            if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices))
1714                            {
1715                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1716                            }
1717
1718                            if (i1 == i2) continue;
1719
1720                            if (n > 2) {
1721                                vector<string> weights;
1722                                int m = getWords(words[2], weights);
1723                                int i;
1724                                for (i=0; i < m; i++) {
1725                                    double i3 = 0;
1726                                    istringstream strI3(weights[i]);
1727                                    strI3 >> i3;
1728                                    /**(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1729
1730                                    if (directed == 1) {
1731                                        *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1732                                    }*/
1733                                }
1734                            }
1735                        }
1736                    }
1737                }
1738            }
1739        }
1740        // read edges
1741        n = getWords(line, words);
1742        if (n > 0) {
1743            if (stricmp(words[0].c_str(), "*edges") == 0) {
1744                while (!file1.eof()) {
1745                    getline (file1, line);
1746                    vector<string> words;
1747                    int n = getWords(line, words);
1748                    if (n > 1) {
1749                        int i1 = -1;
1750                        int i2 = -1;
1751                        istringstream strI1(words[0]);
1752                        istringstream strI2(words[1]);
1753                        strI1 >> i1;
1754                        strI2 >> i2;
1755                       
1756                        if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices)) {
1757                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1758                        }
1759
1760                        if (i1 == i2) continue;
1761                       
1762                        if (n > 2) {
1763                            vector<string> weights;
1764                            int m = getWords(words[2], weights);
1765                            int i;
1766                            for (i=0; i < m; i++) {
1767                                double i3 = 0;
1768                                istringstream strI3(weights[i]);
1769                                strI3 >> i3;
1770                                *(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1771                                if (!directed) {
1772                                    *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1773                                }
1774                            }
1775                        }
1776                    }
1777                }
1778            }
1779        }
1780    } else {
1781      PyErr_Format(PyExc_SystemError, "unable to open file1 '%s'", fn);
1782      return NULL;
1783    }
1784
1785    graph->items = wtable;
1786    return WrapNewOrange(graph, self->ob_type); // WrapOrange(graph);
1787
1788  PyCATCH
1789}
1790
1791#include "network.px"
Note: See TracBrowser for help on using the repository browser.