source: orange/source/orangeom/network.cpp @ 11395:480384789e76

Revision 11395:480384789e76, 42.2 KB checked in by Ales Erjavec <ales.erjavec@…>, 13 months ago (diff)

Replaced the use of PyOrange_AsGraphAsList, with a dynamic cast (fixed a linker error with msvc).

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);
463
464PyObject *Network_new(PyTypeObject *type, PyObject *args, PyObject *kwds) BASED_ON (GraphAsList, "(nVertices, directed[, nEdgeTypes])")
465{
466    PyTRY
467        int nVertices = 1, directed = 0, nEdgeTypes = 1;
468    PyObject *pygraph;
469    if (PyArg_ParseTuple(args, "O:Network", &pygraph))
470    {
471        if (PyOrNetwork_Check(pygraph))
472        {
473            //cout << "1" << endl;
474            TNetwork *net = PyOrange_AsNetwork(pygraph).getUnwrappedPtr();
475            TNetwork *network = mlnew TNetwork(net);
476            // set graphs attribut items of type ExampleTable to subgraph
477            //*
478            PyObject *strItems = PyString_FromString("items");
479            if (PyObject_HasAttr(pygraph, strItems) == 1)
480            {
481                PyObject* items = PyObject_GetAttr(pygraph, strItems);
482                network->items = &dynamic_cast<TExampleTable &>(PyOrange_AsOrange(items).getReference());
483            }
484            Py_DECREF(strItems);
485            /**/
486            return WrapNewOrange(network, type);
487        }
488        else if (PyOrGraphAsList_Check(pygraph))
489        {
490            //cout << "2" << endl;
491            TGraphAsList *graph = dynamic_cast<TGraphAsList *>(PyOrange_AsOrange(pygraph).getUnwrappedPtr());
492            TNetwork *network = mlnew TNetwork(graph);
493           
494            // set graphs attribut items of type ExampleTable to subgraph
495            PyObject *strItems = PyString_FromString("items");
496            if (PyObject_HasAttr(pygraph, strItems) == 1)
497            {
498                PyObject* items = PyObject_GetAttr(pygraph, strItems);
499                network->items = &dynamic_cast<TExampleTable &>(PyOrange_AsOrange(items).getReference());
500            }
501            Py_DECREF(strItems);
502            return WrapNewOrange(network, type);
503      }
504        else
505        {
506            //cout << "3" << endl;
507            PyErr_Format(PyExc_TypeError, "Network.__new__: an instance of GraphAsList expected got '%s'", pygraph->ob_type->tp_name);
508            return PYNULL;
509        }
510    }
511
512    PyErr_Clear();
513
514    if (PyArg_ParseTuple(args, "|iii:Network", &nVertices, &directed, &nEdgeTypes))
515    {
516          return WrapNewOrange(mlnew TNetwork(nVertices, nEdgeTypes, directed != 0), type);
517    }
518
519    PYERROR(PyExc_TypeError, "Network.__new__: number of vertices directedness and optionaly, number of edge types expected", PYNULL);
520
521    PyCATCH
522}
523
524
525PyObject *Network_fromSymMatrix(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(matrix, lower, upper, kNN, andor) -> noConnectedNodes")
526{
527    PyTRY
528    CAST_TO(TNetwork, network);
529
530    PyObject *pyMatrix;
531    double lower;
532    double upper;
533    int kNN = 0;
534    int andor = 0;
535
536    if (!PyArg_ParseTuple(args, "Odd|ii:Network.fromDistanceMatrix", &pyMatrix, &lower, &upper, &kNN, &andor))
537        return PYNULL;
538
539    TSymMatrix *matrix = &dynamic_cast<TSymMatrix &>(PyOrange_AsOrange(pyMatrix).getReference());
540
541    if (matrix->dim != network->nVertices)
542        PYERROR(PyExc_TypeError, "DistanceMatrix dimension should equal number of vertices.", PYNULL);
543
544    int i,j;
545    int nConnected = 0;
546
547    if (matrix->matrixType == 0) {
548        // lower
549        for (i = 0; i < matrix->dim; i++) {
550            bool connected = false;
551            for (j = i+1; j < matrix->dim; j++) {
552                //cout << "i " << i << " j " << j;
553                double value = matrix->getitem(j,i);
554                //cout << " value " << value << endl;
555                if (lower <=  value && value <= upper) {
556                    //cout << "value: " << value << endl;
557                    double* w = network->getOrCreateEdge(j, i);
558                    *w = value;
559
560                    connected = true;
561                }
562            }
563
564            if (connected)
565                nConnected++;
566        }
567
568        vector<int> neighbours;
569        network->getNeighbours(0, neighbours);
570        if (neighbours.size() > 0)
571            nConnected++;
572    }
573    else {
574        // upper
575        for (i = 0; i < matrix->dim; i++) {
576            bool connected = false;
577            for (j = i+1; j < matrix->dim; j++) {
578                double value = matrix->getitem(i,j);
579                if (lower <=  value && value <= upper) {
580                    double* w = network->getOrCreateEdge(i, j);
581                    *w = value;
582                    connected = true;
583                }
584            }
585
586            if (connected)
587                nConnected++;
588
589            vector<int> neighbours;
590            network->getNeighbours(matrix->dim - 1, neighbours);
591            if (neighbours.size() > 0)
592                nConnected++;
593        }
594    }
595
596    return Py_BuildValue("i", nConnected);
597    PyCATCH;
598}
599
600typedef std::pair<int, int> coord_t;
601PyObject *Network_fromDistanceMatrix(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(matrix, lower, upper, kNN, andor) -> noConnectedNodes")
602{
603    PyTRY
604    CAST_TO(TNetwork, network);
605
606    PyObject *pyMatrix;
607    double lower;
608    double upper;
609    int kNN = 0;
610    int andor = 0;
611
612    if (!PyArg_ParseTuple(args, "Odd|ii:Network.fromDistanceMatrix", &pyMatrix, &lower, &upper, &kNN, &andor))
613        return PYNULL;
614
615    TSymMatrix *matrix = &dynamic_cast<TSymMatrix &>(PyOrange_AsOrange(pyMatrix).getReference());
616    //cout << "kNN: " << kNN << endl;
617    //cout << "andor: " << andor << endl;
618
619    if (matrix->dim != network->nVertices)
620        PYERROR(PyExc_TypeError, "DistanceMatrix dimension should equal number of vertices.", PYNULL);
621
622    int i,j;
623    int nConnected = 0;
624    vector<coord_t> edges_interval;
625
626    if (matrix->matrixType == 0) {
627        // lower
628        for (i = 0; i < matrix->dim; i++) {
629            bool connected = false;
630            for (j = i+1; j < matrix->dim; j++) {
631                //cout << "i " << i << " j " << j;
632                double value = matrix->getitem(j,i);
633                //cout << " value " << value << endl;
634                if (lower <=  value && value <= upper) {
635                    connected = true;
636                    edges_interval.push_back(coord_t(j, i));
637                }
638            }
639
640            if (connected)
641                nConnected++;
642        }
643
644        vector<int> neighbours;
645        network->getNeighbours(0, neighbours);
646        if (neighbours.size() > 0)
647            nConnected++;
648    }
649    else {
650        // upper
651        for (i = 0; i < matrix->dim; i++) {
652            bool connected = false;
653            for (j = i+1; j < matrix->dim; j++) {
654                double value = matrix->getitem(i,j);
655                if (lower <=  value && value <= upper) {
656                    connected = true;
657                    edges_interval.push_back(coord_t(i, j));
658                }
659            }
660
661            if (connected)
662                nConnected++;
663
664            vector<int> neighbours;
665            network->getNeighbours(matrix->dim - 1, neighbours);
666            if (neighbours.size() > 0)
667                nConnected++;
668        }
669    }
670    //cout << "calculating knn, dim: " << matrix->dim << endl;
671    vector<coord_t> edges_knn;
672
673    if (kNN > 0) {
674        for (i = 0; i < matrix->dim; i++) {
675            vector<int> closest;
676            matrix->getknn(i, kNN, closest);
677
678            for (j = 0; j < closest.size(); j++) {
679                edges_knn.push_back(coord_t(i, closest[j]));
680            }
681        }
682    }
683
684    //cout << "n edges: " << edges_interval.size() + edges_knn.size() << endl;
685
686    if (andor == 0) {
687        //cout << "insert interval" << endl;
688        for (i=0; i < edges_interval.size(); i++) {
689            //cout << edges_interval[i].first << ", " << edges_interval[i].second << endl;
690            double* w = network->getOrCreateEdge(edges_interval[i].first, edges_interval[i].second);
691            double value = matrix->getitem(edges_interval[i].first, edges_interval[i].second);
692            *w = value;
693            //cout << edges_interval[i].first << "," << edges_interval[i].second << "," << *w << endl;
694        }
695        //cout << "insert knn" << endl;
696        for (i = 0; i < edges_knn.size(); i++) {
697            //cout << edges_knn[i].first << ", " << edges_knn[i].second << endl;
698            double* w = network->getOrCreateEdge(edges_knn[i].first, edges_knn[i].second);
699            double value = matrix->getitem(edges_knn[i].first, edges_knn[i].second);
700            *w = value;
701            //cout << edges_interval[i].first << "," << edges_interval[i].second << "," << *w << endl;
702
703        }
704
705    }
706
707    return Py_BuildValue("i", nConnected);
708    PyCATCH;
709}
710
711PyObject *Network_printHierarchy(PyObject *self, PyObject *) PYARGS(METH_NOARGS, "None -> None")
712{
713  PyTRY
714    CAST_TO(TNetwork, network);
715    network->printHierarchy();
716    RETURN_NONE
717  PyCATCH;
718}
719
720PyObject *Network_printNodeByVertex(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(vertex) -> None")
721{
722  PyTRY
723    int vertexNdx;
724
725    if (!PyArg_ParseTuple(args, "i:Network.printNodeByVertex", &vertexNdx))
726          return PYNULL;
727
728    CAST_TO(TNetwork, network);
729    TNetworkHierarchyNode* vertex = network->hierarchy.getNodeByVertex(vertexNdx);
730    cout << "vertex: " << vertex->vertex << endl;
731    cout << "n of childs: " << vertex->childs.size() << endl;
732    cout << "level: " << vertex->getLevel() << endl;
733    RETURN_NONE
734  PyCATCH;
735}
736
737PyObject *Network_groupVerticesInHierarchy(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(List of vertices) -> None")
738{
739  PyTRY
740    PyObject *pyVertices;
741
742    if (!PyArg_ParseTuple(args, "O:Network.groupVerticesInHierarchy", &pyVertices))
743          return PYNULL;
744
745    int size = PyList_Size(pyVertices);
746    int i;
747        vector<int> vertices;
748        for (i = 0; i < size; i++)
749        {
750      int vertex = PyInt_AsLong(PyList_GetItem(pyVertices, i));
751      vertices.push_back(vertex);
752    }
753
754    CAST_TO(TNetwork, network);
755    network->hierarchy.addToNewMeta(vertices);
756    RETURN_NONE
757  PyCATCH;
758}
759
760PyObject *Network_expandMeta(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(index) -> None")
761{
762  PyTRY
763    int meta;
764
765    if (!PyArg_ParseTuple(args, "i:Network.groupVerticesInHierarchy", &meta))
766          return PYNULL;
767
768    CAST_TO(TNetwork, network);
769    network->hierarchy.expandMeta(meta);
770    RETURN_NONE
771  PyCATCH;
772}
773
774PyObject *Network_hideVertices(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(List of vertices) -> None")
775{
776  PyTRY
777    PyObject *pyVertices;
778
779    if (!PyArg_ParseTuple(args, "O:Network.hideVertices", &pyVertices))
780          return PYNULL;
781
782    int size = PyList_Size(pyVertices);
783    int i;
784        vector<int> vertices;
785        for (i = 0; i < size; i++)
786        {
787      int vertex = PyInt_AsLong(PyList_GetItem(pyVertices, i));
788      vertices.push_back(vertex);
789    }
790
791    CAST_TO(TNetwork, network);
792    network->hideVertices(vertices);
793    RETURN_NONE
794  PyCATCH;
795}
796
797PyObject *Network_showVertices(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(List of vertices) -> None")
798{
799  PyTRY
800    PyObject *pyVertices;
801
802    if (!PyArg_ParseTuple(args, "O:Network.showVertices", &pyVertices))
803          return PYNULL;
804
805    int size = PyList_Size(pyVertices);
806    int i;
807        vector<int> vertices;
808        for (i = 0; i < size; i++)
809        {
810      int vertex = PyInt_AsLong(PyList_GetItem(pyVertices, i));
811      vertices.push_back(vertex);
812    }
813
814    CAST_TO(TNetwork, network);
815    network->showVertices(vertices);
816    RETURN_NONE
817  PyCATCH;
818}
819
820PyObject *Network_showAll(PyObject *self, PyObject *) PYARGS(METH_NOARGS, "None -> None")
821{
822  PyTRY
823    CAST_TO(TNetwork, network);
824    network->showAll();
825    RETURN_NONE
826  PyCATCH;
827}
828
829PyObject *Network_getVisible(PyObject *self, PyObject *) PYARGS(METH_NOARGS, "None -> None")
830{
831  PyTRY
832    CAST_TO(TNetwork, network);
833
834    PyObject *pyVisible = PyList_New(0);
835
836    for (set<int>::iterator it = network->optimize.begin(); it != network->optimize.end(); ++it)
837      {
838      PyObject *nel = Py_BuildValue("i", *it);
839            PyList_Append(pyVisible, nel);
840            Py_DECREF(nel);
841    }
842
843      return pyVisible;
844  PyCATCH;
845}
846
847PyObject *Network_get_coors(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> Coors")*/
848{
849  PyTRY
850    CAST_TO(TNetwork, graph);
851    Py_INCREF(graph->coors);
852    return (PyObject *)graph->coors;
853  PyCATCH
854}
855
856PyObject *Network_get_description(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> desc")*/
857{
858  PyTRY
859    CAST_TO(TNetwork, graph);
860    //Py_INCREF(graph->desc);
861    return PyString_FromString(graph->desc.c_str());
862  PyCATCH
863}
864
865PyObject *Network_get_name(PyObject *self, PyObject *args) /*P Y A RGS(METH_VARARGS, "() -> name")*/
866{
867  PyTRY
868    CAST_TO(TNetwork, graph);
869    //Py_INCREF(graph->desc);
870    return PyString_FromString(graph->name.c_str());
871  PyCATCH
872}
873
874int getWords(string const& s, vector<string> &container)
875{
876    int n = 0;
877    bool quotation = false;
878    container.clear();
879    string::const_iterator it = s.begin(), end = s.end(), first;
880    for (first = it; it != end; ++it) {
881        // Examine each character and if it matches the delimiter
882        if ((!quotation && (' ' == *it || '\t' == *it || '\r' == *it || '\f' == *it || '\v' == *it || ',' == *it)) || ('\n' == *it)) {
883            if (first != it) {
884                // extract the current field from the string and
885                // append the current field to the given container
886                container.push_back(string(first, it));
887                ++n;
888
889                // skip the delimiter
890                first = it + 1;
891            } else {
892                ++first;
893            }
894        }
895        else if (('\"' == *it) || ('\'' == *it) || ('(' == *it) || (')' == *it)) {
896            if (quotation) {
897                quotation = false;
898
899                // extract the current field from the string and
900                // append the current field to the given container
901                container.push_back(string(first, it));
902                ++n;
903
904                // skip the delimiter
905                first = it + 1;
906            } else {
907                quotation = true;
908
909                // skip the quotation
910                first = it + 1;
911            }
912        }
913    }
914    if (first != it) {
915        // extract the last field from the string and
916        // append the last field to the given container
917        container.push_back(string(first, it));
918        ++n;
919    }
920    return n;
921}
922
923WRAPPER(ExampleTable)
924
925PyObject *Network_readGML(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(fn) -> Network")
926{
927  PyTRY
928
929    TNetwork *graph;
930    TDomain *domain = new TDomain();
931    PDomain wdomain = domain;
932    TExampleTable *table;
933    PExampleTable wtable;
934    char *fn;
935
936    if (!PyArg_ParseTuple(args, "s:Network.readGML", &fn))
937        return NULL;
938   
939    struct GML_pair* list;
940    struct GML_stat* stat=(struct GML_stat*)malloc(sizeof(struct GML_stat));
941    stat->key_list = NULL;
942   
943    FILE* file = fopen (fn, "r");
944   
945    if (file == 0) { 
946        printf ("\n No such file: %s", fn);
947    } else {
948        GML_init();
949       
950        list = GML_parser(file, stat, 0);
951       
952        if (stat->err.err_num != GML_OK) {
953            printf ("An error occured while reading line %d column %d of %s:\n", stat->err.line, stat->err.column, fn);
954       
955            switch (stat->err.err_num) {
956                case GML_UNEXPECTED:
957                    printf ("UNEXPECTED CHARACTER");
958                    break;
959           
960                case GML_SYNTAX:
961                    printf ("SYNTAX ERROR"); 
962                    break;
963           
964                case GML_PREMATURE_EOF:
965                    printf ("PREMATURE EOF IN STRING");
966                    break;
967           
968                case GML_TOO_MANY_DIGITS:
969                    printf ("NUMBER WITH TOO MANY DIGITS");
970                    break;
971           
972                case GML_OPEN_BRACKET:
973                    printf ("OPEN BRACKETS LEFT AT EOF");
974                    break;
975           
976                case GML_TOO_MANY_BRACKETS:
977                    printf ("TOO MANY CLOSING BRACKETS");
978                    break;
979       
980                default:
981                    break;
982            }   
983            printf ("\n");
984        }     
985   
986        while (list) {
987            if (strcmp(list->key, "graph") == 0) {
988                int nVertices = 0;
989                int directed = 0;
990                map<int, int> nodes;
991                vector< vector<int> > edges;
992                string graphName = "";
993
994                TFloatVariable *indexVar = new TFloatVariable("index");
995                indexVar->numberOfDecimals = 0;
996                TFloatVariable *idVar = new TFloatVariable("id");
997                idVar->numberOfDecimals = 0;
998                domain->addVariable(indexVar);
999                domain->addVariable(idVar);
1000                domain->addVariable(new TStringVariable("label"));
1001                table = new TExampleTable(domain);
1002                wtable = table;
1003
1004                struct GML_pair* graph_obj = list->value.list;
1005                while (graph_obj) {
1006                    if (strcmp(graph_obj->key, "node") == 0) {
1007                        float index = nVertices;
1008                        float id;
1009                        char* label;
1010                        struct GML_pair* tmp = graph_obj->value.list;
1011                        while (tmp) {
1012                            if (strcmp(tmp->key, "id") == 0)
1013                                id = tmp->value.integer;
1014                            if (strcmp(tmp->key, "label") == 0)
1015                                label = tmp->value.string;
1016                            tmp = tmp->next;
1017                        }
1018                        TExample *example = new TExample(domain);
1019                        (*example)[0] = TValue(index);
1020                        (*example)[1] = TValue(id);
1021                        (*example)[2] = TValue(new TStringValue(label), STRINGVAR);
1022                        table->push_back(example);
1023                        nodes[id] = nVertices;
1024                        nVertices++;
1025                    }
1026                    if (strcmp(graph_obj->key, "edge") == 0) {
1027                        long target;
1028                        long source;
1029
1030                        struct GML_pair* tmp = graph_obj->value.list;
1031                        while (tmp) {
1032                            if (strcmp(tmp->key, "source") == 0)
1033                                source = tmp->value.integer;
1034                            if (strcmp(tmp->key, "target") == 0)
1035                                target = tmp->value.integer;
1036                            tmp = tmp->next;
1037                        }
1038
1039                        vector<int> v;
1040                        v.push_back(source);
1041                        v.push_back(target);
1042                        edges.push_back(v);
1043                    }
1044                    if (strcmp(graph_obj->key, "directed") == 0) {
1045                        directed = graph_obj->value.integer;
1046                    }
1047                    if (strcmp(graph_obj->key, "label") == 0) {
1048                        graphName = graph_obj->value.string;
1049                    }
1050
1051
1052                    graph_obj = graph_obj->next;
1053                }
1054
1055                graph = mlnew TNetwork(nodes.size(), 1, directed == 1);
1056                graph->name = graphName;
1057
1058                for (vector< vector<int> >::iterator it = edges.begin(); it!=edges.end(); ++it) {
1059                    int u = nodes[(*it)[0]];
1060                    int v = nodes[(*it)[1]];
1061                    double *w = graph->getOrCreateEdge(u, v);
1062                    *w = 1.0;
1063                }
1064            }
1065
1066            list = list->next;
1067        }
1068        GML_free_list (list, stat->key_list);
1069        graph->items = wtable;
1070        return WrapNewOrange(graph, self->ob_type); // WrapOrange(graph);
1071    }
1072    return NULL;
1073  PyCATCH
1074}
1075
1076PyObject *Network_readPajek(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(fn) -> Network")
1077{
1078  PyTRY
1079
1080    TNetwork *graph;
1081    TDomain *domain = new TDomain();
1082    PDomain wdomain = domain;
1083    TExampleTable *table;
1084    PExampleTable wtable;
1085    int directed = 0;
1086    //cout << "readNetwork" << endl;
1087    char *fn;
1088
1089    if (!PyArg_ParseTuple(args, "s|i:Network.readPajek", &fn, &directed))
1090        return NULL;
1091
1092    //cout << "File: " << fn << endl;
1093
1094    string line;
1095    ifstream file(fn);
1096    string graphName = "";
1097    string description = "";
1098    int nVertices = 0;
1099    int nEdges = 0;
1100
1101    if (file.is_open())
1102    {
1103        // read head
1104        while (!file.eof())
1105        {
1106            getline (file, line);
1107            vector<string> words;
1108            int n = getWords(line, words);
1109            //cout << line << "  -  " << n << endl;
1110            if (n > 0)
1111            {
1112                if (stricmp(words[0].c_str(), "*network") == 0)
1113                {
1114                    //cout << "Network" << endl;
1115                    if (n > 1)
1116                    {
1117                        graphName = words[1];
1118                        //cout << "Graph name: " << graphName << endl;
1119                    }
1120                    else
1121                    {
1122                        file.close();
1123                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1124                    }
1125                }
1126                else if (stricmp(words[0].c_str(), "*description") == 0)
1127                {
1128                    //cout << "Network" << endl;
1129                    if (n > 1)
1130                    {
1131                        description = words[1];
1132                        //cout << "description: " << description << endl;
1133                    }
1134                    else
1135                    {
1136                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1137                    }
1138                }
1139                else if (stricmp(words[0].c_str(), "*vertices") == 0) {
1140                    //cout << "Vertices" << endl;
1141                    if (n > 1) {
1142                        istringstream strVertices(words[1]);
1143                        strVertices >> nVertices;
1144                        if (nVertices == 0) {
1145                            file.close();
1146                            PYERROR(PyExc_SystemError, "invalid file format", NULL);
1147                        }
1148                    } else {
1149                        file.close();
1150                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1151                    }
1152                    if (n > 2) {
1153                        istringstream strEdges(words[2]);
1154                        strEdges >> nEdges;
1155                    }
1156                }
1157                else if (stricmp(words[0].c_str(), "*arcs") == 0) {
1158                    directed = 1;
1159                    break;
1160                }
1161            }
1162        }
1163        file.close();
1164    }
1165
1166    ifstream file1(fn);
1167    if (file1.is_open())
1168    {
1169        // read head
1170        while (!file1.eof())
1171        {
1172            getline (file1, line);
1173            vector<string> words;
1174            int n = getWords(line, words);
1175            //cout << line << "  -  " << n << endl;
1176            if (n > 0)
1177            {
1178                if (stricmp(words[0].c_str(), "*vertices") == 0)
1179                {
1180                    //cout << "Vertices" << endl;
1181                    if (n > 1)
1182                    {
1183                        istringstream strVertices(words[1]);
1184                        strVertices >> nVertices;
1185                        if (nVertices == 0)
1186                        {
1187                            file1.close();
1188                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1189                        }
1190
1191                        //cout << "nVertices: " << nVertices << endl;
1192                    }
1193                    else
1194                    {
1195                        file1.close();
1196                        PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1197                    }
1198
1199                    break;
1200                }
1201            }
1202        }
1203
1204        if (nVertices <= 1) {
1205            file1.close();
1206            PYERROR(PyExc_SystemError, "invalid file1 format; invalid number of vertices (less than 1)", NULL);
1207        }
1208
1209        graph = mlnew TNetwork(nVertices, nEdges, directed == 1);
1210        graph->desc = description;
1211        graph->name = graphName;
1212
1213        TFloatVariable *indexVar = new TFloatVariable("index");
1214        indexVar->numberOfDecimals = 0;
1215        domain->addVariable(indexVar);
1216        domain->addVariable(new TStringVariable("label"));
1217        domain->addVariable(new TFloatVariable("x"));
1218        domain->addVariable(new TFloatVariable("y"));
1219        domain->addVariable(new TFloatVariable("z"));
1220        domain->addVariable(new TStringVariable("ic"));
1221        domain->addVariable(new TStringVariable("bc"));
1222        domain->addVariable(new TStringVariable("bw"));
1223        table = new TExampleTable(domain);
1224        wtable = table;
1225
1226        // read vertex descriptions
1227        int row = 0;
1228        while (!file1.eof())
1229        {
1230            getline(file1, line);
1231            vector<string> words;
1232            int n = getWords(line, words);
1233            //cout << line << "  -  " << n << endl;
1234            if (n > 0)
1235            {
1236                TExample *example = new TExample(domain);
1237
1238                if ((stricmp(words[0].c_str(), "*arcs") == 0) || (stricmp(words[0].c_str(), "*edges") == 0))
1239                    break;
1240
1241                float index = -1;
1242                istringstream strIndex(words[0]);
1243                strIndex >> index;
1244                if ((index <= 0) || (index > nVertices))
1245                {
1246                    file1.close();
1247                    PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1248                }
1249
1250                //cout << "index: " << index << " n: " << n << endl;
1251                (*example)[0] = TValue(index);
1252
1253                if (n > 1)
1254                {
1255                    string label = words[1];
1256                    //cout << "label: " << label << endl;
1257                    (*example)[1] = TValue(new TStringValue(label), STRINGVAR);
1258
1259                    int i = 2;
1260                    char *xyz = "  xyz";
1261                    // read coordinates
1262                    while ((i <= 4) && (i < n))
1263                    {
1264                        double coor = -1;
1265                        istringstream strCoor(words[i]);
1266                        strCoor >> coor;
1267
1268                        //if ((coor < 0) || (coor > 1))
1269                        //  break;
1270
1271                        //cout << xyz[i] << ": " << coor << endl;
1272                        (*example)[i] = TValue((float)coor);
1273
1274                        if (i == 2)
1275                            graph->pos[0][row] = coor;
1276
1277                        if (i == 3)
1278                            graph->pos[1][row] = coor;
1279
1280                        i++;
1281                    }
1282                    // read attributes
1283                    while (i < n)
1284                    {
1285                        if (stricmp(words[i].c_str(), "ic") == 0)
1286                        {
1287                            if (i + 1 < n)
1288                                i++;
1289                            else
1290                            {
1291                                file1.close();
1292                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1293                            }
1294
1295                            //cout << "ic: " << words[i] << endl;
1296                            (*example)[5] = TValue(new TStringValue(words[i]), STRINGVAR);
1297                        }
1298                        else if (stricmp(words[i].c_str(), "bc") == 0)
1299                        {
1300                            if (i + 1 < n)
1301                                i++;
1302                            else
1303                            {
1304                                file1.close();
1305                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1306                            }
1307
1308                            //cout << "bc: " << words[i] << endl;
1309                            (*example)[6] = TValue(new TStringValue(words[i]), STRINGVAR);
1310                        }
1311                        else if (stricmp(words[i].c_str(), "bw") == 0)
1312                        {
1313                            if (i + 1 < n)
1314                                i++;
1315                            else
1316                            {
1317                                file1.close();
1318                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1319                            }
1320
1321                            //cout << "bw: " << words[i] << endl;
1322                            (*example)[7] = TValue(new TStringValue(words[i]), STRINGVAR);
1323                        }
1324                        i++;
1325                    }
1326
1327                }
1328                example->id = getExampleId();
1329                table->push_back(example);
1330                //cout << "push back" <<endl;
1331            }
1332
1333            row++;
1334        }
1335        // read arcs
1336        vector<string> words;
1337        int n = getWords(line, words);
1338        if (n > 0)
1339        {
1340            if (stricmp(words[0].c_str(), "*arcs") == 0)
1341            {
1342                while (!file1.eof())
1343                {
1344                    getline (file1, line);
1345                    vector<string> words;
1346                    int n = getWords(line, words);
1347                    if (n > 0)
1348                    {
1349                        if (stricmp(words[0].c_str(), "*edges") == 0)
1350                            break;
1351
1352                        if (n > 1)
1353                        {
1354                            int i1 = -1;
1355                            int i2 = -1;
1356                            istringstream strI1(words[0]);
1357                            istringstream strI2(words[1]);
1358                            strI1 >> i1;
1359                            strI2 >> i2;
1360                           
1361                            if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices))
1362                            {
1363                                file1.close();
1364                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1365                            }
1366
1367                            if (i1 == i2) continue;
1368
1369                            if (n > 2) {
1370                                vector<string> weights;
1371                                int m = getWords(words[2], weights);
1372                                int i;
1373                                for (i=0; i < m; i++) {
1374                                    double i3 = 0;
1375                                    istringstream strI3(weights[i]);
1376                                    strI3 >> i3;
1377                                    *(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1378                                    if (!directed) {
1379                                        *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1380                                    }
1381                                }
1382                            }
1383                        }
1384                    }
1385                }
1386            }
1387        }
1388        // read edges
1389        n = getWords(line, words);
1390        if (n > 0) {
1391            if (stricmp(words[0].c_str(), "*edges") == 0) {
1392                while (!file1.eof()) {
1393                    getline (file1, line);
1394                    vector<string> words;
1395                    int n = getWords(line, words);
1396                    if (n > 1) {
1397                        int i1 = -1;
1398                        int i2 = -1;
1399                        istringstream strI1(words[0]);
1400                        istringstream strI2(words[1]);
1401                        strI1 >> i1;
1402                        strI2 >> i2;
1403                       
1404                        if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices)) {
1405                            file1.close();
1406                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1407                        }
1408
1409                        if (i1 == i2) continue;
1410                       
1411                        if (n > 2) {
1412                            vector<string> weights;
1413                            int m = getWords(words[2], weights);
1414                            int i;
1415                            for (i=0; i < m; i++) {
1416                                double i3 = 0;
1417                                istringstream strI3(weights[i]);
1418                                strI3 >> i3;
1419                                *(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1420                                if (!directed) {
1421                                    *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1422                                }
1423                               
1424                            }
1425                        }
1426                    }
1427                }
1428            }
1429        }
1430        file1.close();
1431    } else {
1432      PyErr_Format(PyExc_SystemError, "unable to open file1 '%s'", fn);
1433      return NULL;
1434    }
1435
1436    graph->items = wtable;
1437    return WrapNewOrange(graph, self->ob_type); // WrapOrange(graph);
1438
1439  PyCATCH
1440}
1441
1442PyObject *Network_parseNetwork(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(network_string) -> Network")
1443{
1444  PyTRY
1445
1446    TNetwork *graph;
1447    TDomain *domain = new TDomain();
1448    PDomain wdomain = domain;
1449    TExampleTable *table;
1450    PExampleTable wtable;
1451    int directed = 0;
1452    //cout << "readNetwork" << endl;
1453    char *fn;
1454
1455    if (!PyArg_ParseTuple(args, "s|i:Network.parseNetwork", &fn, &directed))
1456        return NULL;
1457
1458    //cout << "File: " << fn << endl;
1459
1460    string line;
1461    istringstream file(fn, istringstream::in);
1462    string graphName = "";
1463    string description = "";
1464    int nVertices = 0;
1465    int nEdges = 0;
1466
1467    if (file.good())
1468    {
1469        // read head
1470        while (!file.eof())
1471        {
1472            getline (file, line);
1473            vector<string> words;
1474            int n = getWords(line, words);
1475            //cout << line << "  -  " << n << endl;
1476            if (n > 0)
1477            {
1478                if (stricmp(words[0].c_str(), "*network") == 0)
1479                {
1480                    //cout << "Network" << endl;
1481                    if (n > 1)
1482                    {
1483                        graphName = words[1];
1484                        //cout << "Graph name: " << graphName << endl;
1485                    }
1486                    else
1487                    {
1488                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1489                    }
1490                }
1491                else if (stricmp(words[0].c_str(), "*description") == 0)
1492                {
1493                    //cout << "Network" << endl;
1494                    if (n > 1)
1495                    {
1496                        description = words[1];
1497                        //cout << "description: " << description << endl;
1498                    }
1499                    else
1500                    {
1501                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1502                    }
1503                }
1504                else if (stricmp(words[0].c_str(), "*vertices") == 0) {
1505                    //cout << "Vertices" << endl;
1506                    if (n > 1) {
1507                        istringstream strVertices(words[1]);
1508                        strVertices >> nVertices;
1509                        if (nVertices == 0) {
1510                            PYERROR(PyExc_SystemError, "invalid file format", NULL);
1511                        }
1512                    } else {
1513                        PYERROR(PyExc_SystemError, "invalid file format", NULL);
1514                    }
1515                    if (n > 2) {
1516                        istringstream strEdges(words[2]);
1517                        strEdges >> nEdges;
1518                    }
1519                }
1520                else if (stricmp(words[0].c_str(), "*arcs") == 0) {
1521                    directed = 1;
1522                    break;
1523                }
1524            }
1525        }
1526    }
1527
1528    istringstream file1(fn, istringstream::in);
1529    if (file1.good())
1530    {
1531        // read head
1532        while (!file1.eof())
1533        {
1534            getline (file1, line);
1535            vector<string> words;
1536            int n = getWords(line, words);
1537            //cout << line << "  -  " << n << endl;
1538            if (n > 0)
1539            {
1540                if (stricmp(words[0].c_str(), "*vertices") == 0)
1541                {
1542                    //cout << "Vertices" << endl;
1543                    if (n > 1)
1544                    {
1545                        istringstream strVertices(words[1]);
1546                        strVertices >> nVertices;
1547                        if (nVertices == 0)
1548                        {
1549                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1550                        }
1551
1552                        //cout << "nVertices: " << nVertices << endl;
1553                    }
1554                    else
1555                    {
1556                        PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1557                    }
1558
1559                    break;
1560                }
1561            }
1562        }
1563
1564        if (nVertices <= 1) {
1565            PYERROR(PyExc_SystemError, "invalid file1 format; invalid number of vertices (less than 1)", NULL);
1566        }
1567
1568        graph = mlnew TNetwork(nVertices, nEdges, directed == 1);
1569
1570        TFloatVariable *indexVar = new TFloatVariable("index");
1571        indexVar->numberOfDecimals = 0;
1572        domain->addVariable(indexVar);
1573        domain->addVariable(new TStringVariable("label"));
1574        domain->addVariable(new TFloatVariable("x"));
1575        domain->addVariable(new TFloatVariable("y"));
1576        domain->addVariable(new TFloatVariable("z"));
1577        domain->addVariable(new TStringVariable("ic"));
1578        domain->addVariable(new TStringVariable("bc"));
1579        domain->addVariable(new TStringVariable("bw"));
1580        table = new TExampleTable(domain);
1581        wtable = table;
1582
1583        // read vertex descriptions
1584        int row = 0;
1585        while (!file1.eof())
1586        {
1587            getline(file1, line);
1588            vector<string> words;
1589            int n = getWords(line, words);
1590            //cout << line << "  -  " << n << endl;
1591            if (n > 0)
1592            {
1593                TExample *example = new TExample(domain);
1594
1595                if ((stricmp(words[0].c_str(), "*arcs") == 0) || (stricmp(words[0].c_str(), "*edges") == 0))
1596                    break;
1597
1598                float index = -1;
1599                istringstream strIndex(words[0]);
1600                strIndex >> index;
1601                if ((index <= 0) || (index > nVertices))
1602                {
1603                    PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1604                }
1605
1606                //cout << "index: " << index << " n: " << n << endl;
1607                (*example)[0] = TValue(index);
1608
1609                if (n > 1)
1610                {
1611                    string label = words[1];
1612                    //cout << "label: " << label << endl;
1613                    (*example)[1] = TValue(new TStringValue(label), STRINGVAR);
1614
1615                    int i = 2;
1616                    char *xyz = "  xyz";
1617                    // read coordinates
1618                    while ((i <= 4) && (i < n))
1619                    {
1620                        double coor = -1;
1621                        istringstream strCoor(words[i]);
1622                        strCoor >> coor;
1623
1624                        //if ((coor < 0) || (coor > 1))
1625                        //  break;
1626
1627                        //cout << xyz[i] << ": " << coor << endl;
1628                        (*example)[i] = TValue((float)coor);
1629
1630                        if (i == 2)
1631                            graph->pos[0][row] = coor;
1632
1633                        if (i == 3)
1634                            graph->pos[1][row] = coor;
1635
1636                        i++;
1637                    }
1638                    // read attributes
1639                    while (i < n)
1640                    {
1641                        if (stricmp(words[i].c_str(), "ic") == 0)
1642                        {
1643                            if (i + 1 < n)
1644                                i++;
1645                            else
1646                            {
1647                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1648                            }
1649
1650                            //cout << "ic: " << words[i] << endl;
1651                            (*example)[5] = TValue(new TStringValue(words[i]), STRINGVAR);
1652                        }
1653                        else if (stricmp(words[i].c_str(), "bc") == 0)
1654                        {
1655                            if (i + 1 < n)
1656                                i++;
1657                            else
1658                            {
1659                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1660                            }
1661
1662                            //cout << "bc: " << words[i] << endl;
1663                            (*example)[6] = TValue(new TStringValue(words[i]), STRINGVAR);
1664                        }
1665                        else if (stricmp(words[i].c_str(), "bw") == 0)
1666                        {
1667                            if (i + 1 < n)
1668                                i++;
1669                            else
1670                            {
1671                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1672                            }
1673
1674                            //cout << "bw: " << words[i] << endl;
1675                            (*example)[7] = TValue(new TStringValue(words[i]), STRINGVAR);
1676                        }
1677                        i++;
1678                    }
1679
1680                }
1681                example->id = getExampleId();
1682                table->push_back(example);
1683                //cout << "push back" <<endl;
1684            }
1685
1686            row++;
1687        }
1688        // read arcs
1689        vector<string> words;
1690        int n = getWords(line, words);
1691        if (n > 0)
1692        {
1693            if (stricmp(words[0].c_str(), "*arcs") == 0)
1694            {
1695                while (!file1.eof())
1696                {
1697                    getline (file1, line);
1698                    vector<string> words;
1699                    int n = getWords(line, words);
1700                    if (n > 0)
1701                    {
1702                        if (stricmp(words[0].c_str(), "*edges") == 0)
1703                            break;
1704
1705                        if (n > 1)
1706                        {
1707                            int i1 = -1;
1708                            int i2 = -1;
1709                            istringstream strI1(words[0]);
1710                            istringstream strI2(words[1]);
1711                            strI1 >> i1;
1712                            strI2 >> i2;
1713                           
1714                            if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices))
1715                            {
1716                                PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1717                            }
1718
1719                            if (i1 == i2) continue;
1720
1721                            if (n > 2) {
1722                                vector<string> weights;
1723                                int m = getWords(words[2], weights);
1724                                int i;
1725                                for (i=0; i < m; i++) {
1726                                    double i3 = 0;
1727                                    istringstream strI3(weights[i]);
1728                                    strI3 >> i3;
1729                                    /**(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1730
1731                                    if (directed == 1) {
1732                                        *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1733                                    }*/
1734                                }
1735                            }
1736                        }
1737                    }
1738                }
1739            }
1740        }
1741        // read edges
1742        n = getWords(line, words);
1743        if (n > 0) {
1744            if (stricmp(words[0].c_str(), "*edges") == 0) {
1745                while (!file1.eof()) {
1746                    getline (file1, line);
1747                    vector<string> words;
1748                    int n = getWords(line, words);
1749                    if (n > 1) {
1750                        int i1 = -1;
1751                        int i2 = -1;
1752                        istringstream strI1(words[0]);
1753                        istringstream strI2(words[1]);
1754                        strI1 >> i1;
1755                        strI2 >> i2;
1756                       
1757                        if ((i1 <= 0) || (i1 > nVertices) || (i2 <= 0) || (i2 > nVertices)) {
1758                            PYERROR(PyExc_SystemError, "invalid file1 format", NULL);
1759                        }
1760
1761                        if (i1 == i2) continue;
1762                       
1763                        if (n > 2) {
1764                            vector<string> weights;
1765                            int m = getWords(words[2], weights);
1766                            int i;
1767                            for (i=0; i < m; i++) {
1768                                double i3 = 0;
1769                                istringstream strI3(weights[i]);
1770                                strI3 >> i3;
1771                                *(graph->getOrCreateEdge(i1 - 1, i2 - 1) + i) = i3;
1772                                if (!directed) {
1773                                    *(graph->getOrCreateEdge(i2 - 1, i1 - 1) + i) = i3;
1774                                }
1775                            }
1776                        }
1777                    }
1778                }
1779            }
1780        }
1781    } else {
1782      PyErr_Format(PyExc_SystemError, "unable to open file1 '%s'", fn);
1783      return NULL;
1784    }
1785
1786    graph->items = wtable;
1787    return WrapNewOrange(graph, self->ob_type); // WrapOrange(graph);
1788
1789  PyCATCH
1790}
1791
1792#include "network.px"
Note: See TracBrowser for help on using the repository browser.