void fdp_init_node_edge(graph_t * g)
{
attrsym_t *E_len;
node_t *n;
edge_t *e;
int nn = agnnodes(g);
int i;
ndata* alg = N_NEW(nn, ndata);
processClusterEdges(g);
GD_neato_nlist(g) = N_NEW(nn + 1, node_t *);
for (i = 0, n = agfstnode(g); n; n = agnxtnode(g, n)) {
neato_init_node (n);
ND_alg(n) = alg + i;
GD_neato_nlist(g)[i] = n;
ND_id(n) = i++;
}
E_len = agfindattr(g->proto->e, "len");
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
init_edge(e, E_len);
}
}
initialPositions(g);
}
Graph init_graph()
{
Graph *g = (Graph *)malloc(sizeof(Graph));
g->vexnum = 0;
g->edgnum = 0;
init_vertex(g);
init_edge(g);
return *g;
}
int add_edge(int first_id, int second_id, double weight, network *net) {
vertex *src_vrtx = get_vertex(first_id, net);
vertex *dest_vrtx = get_vertex(second_id, net);
edge *e = NULL;
init_edge(&e, first_id, second_id, weight);
if ((add_edge_to_vertex(&src_vrtx, &dest_vrtx, e) == 2))
return 2;
return 0;
}
void init_global(long process_id)
{
/* Clear BSP root pointer */
global->index = 1; /* ****** */
global->bsp_root = 0 ;
LOCKINIT(global->index_lock);
LOCKINIT(global->bsp_tree_lock);
/* Initialize radiosity statistics variables */
LOCKINIT(global->avg_radiosity_lock);
global->converged = 0 ;
global->prev_total_energy.r = 0.0 ;
global->prev_total_energy.g = 0.0 ;
global->prev_total_energy.b = 0.0 ;
global->total_energy.r = 1.0 ;
global->total_energy.g = 1.0 ;
global->total_energy.b = 1.0 ;
global->total_patch_area = 1.0 ;
global->iteration_count = -1 ; /* init_ray_task() increments to 0 */
/* Initialize the cost sum */
LOCKINIT(global->cost_sum_lock);
global->cost_sum = 0 ;
global->cost_estimate_sum = 0 ;
/* Initialize the barrier */
BARINIT(global->barrier, n_processors);
LOCKINIT(global->pbar_lock);
global->pbar_count = 0 ;
/* Initialize task counter */
global->task_counter = 0 ;
LOCKINIT(global->task_counter_lock);
/* Initialize task queue */
init_taskq(process_id) ;
/* Initialize Patch, Element, Interaction free lists */
init_patchlist(process_id) ;
init_elemlist(process_id) ;
init_interactionlist(process_id) ;
init_elemvertex(process_id) ;
init_edge(process_id) ;
/* Initialize statistical info */
init_stat_info(process_id) ;
}
int main(int argc,char* argv[])
{
if(argc!=4)
{
printf("Wrong Arguments!");
return 1;
}
FILE * fhand=fopen ( argv[1], "r" );
if(fhand==0)
{
printf("File Open Error.");
return 1;
}
int i,len; fscanf(fhand,"%d",&len);
Matrix edgeMat; int edgeCount= readMatrix(&edgeMat,fhand,len);
fclose(fhand);
if(strcmp(argv[2],"-p")==0)
{
int *parent= (int*) malloc(len*sizeof(int)); //holds MST tree as parent array
int *intree= (int*) malloc(len*sizeof(int));//holds edges in MST
int *near= (int*) malloc(len*sizeof(int)); //holds distance to MST
if(parent==0||intree==0||near==0)
{
printf("Memory Allocation Error!");
exit(1);
}
fhand=fopen ( argv[3], "w" );
if(fhand==0){
printf("File Write Protected or In Use!");
return 1;
}
prim(parent,near,intree,&edgeMat);
int sum=0;
Matrix result; createMatrix(&result,len);
for(i=1;i<len;i++)
{
if(parent[i]!=-1)
{
result.data[i][parent[i]]=1;result.data[parent[i]][i]=1;
sum+=edgeMat.data[i][parent[i]];
}
}
fprintf(fhand,"%d\n%d\n",len,sum);
writeMatrix(&result,fhand);
clearMatrix(&result);
fclose(fhand);
}
else if(strcmp(argv[2],"-k")==0)
{
//Edge_heap eheap; init_heap(&eheap,len*len/2);
edge *ex= (edge*) malloc(edgeCount*sizeof(edge));
if(ex==0){ printf("Memory Allocation Error!"); exit(1);}
int n,m,k=0;
for(n=0;n<len-1;n++)
{ //just travels upper triangular of matrix
for (m=n+1;m<len;m++)
{
if(edgeMat.data[n][m]!=0)
{
init_edge(&ex[k],n,m,&edgeMat);
//insert(&edgeMat,&eheap,&ex[k]);
if(++k==edgeCount) break;
}
}
if(k==edgeCount) break;
}
clearMatrix(&edgeMat);
Matrix result; createMatrix(&result,len);
DisjSets dset; init_DisjSets(&dset,len);
fhand=fopen ( argv[3], "w" );
if(fhand==0){
printf("File Write Protected or In Use!");
return 1;
}
fprintf(fhand,"%d\n%d\n",len,kruskal(&result,&dset,ex,edgeCount));
writeMatrix(&result,fhand);
clearMatrix(&result);
fclose(fhand);
}
else
{
printf("Wrong Arguments!");
return 1;
}
return 0;
}
void gp_fill_polygon_raw(gp_pixmap *pixmap, unsigned int nvert,
const gp_coord *xy, gp_pixel pixel)
{
unsigned int i;
struct edge *e;
if (nvert < 3)
return; /* not enough vertices */
gp_point const *vert = (gp_point const *) xy;
/* find first and last scanline */
gp_coord ymin = INT_MAX, ymax = -INT_MAX;
for (i = 0; i < nvert; i++) {
ymax = GP_MAX(ymax, vert[i].y);
ymin = GP_MIN(ymin, vert[i].y);
}
/* build a list of edges */
struct edge edges[nvert];
unsigned int nedges = 0; /* number of edges in list */
for (i = 0; i < nvert; i++) {
/*
* next vertex index (wraps to 0 at end to connect
* the last vertex with the first one)
*/
unsigned int nexti = (i+1) % nvert;
/* add new edge record */
e = edges + nedges++;
init_edge(e, vert[i], vert[nexti]);
}
if (nedges < 2)
return; /* not really a polygon */
/* initially sort edges by Y, then X */
qsort(edges, nedges, sizeof(struct edge),
(gp_sort_callback) edges_compare_initial);
/*
* for each scanline, compute intersections with all edges
* and draw a horizontal line segment between the intersections.
*/
float inter[nedges];
unsigned int ninter;
int y;
for (y = ymin; y <= ymax; y++) {
/* mark edges we have just reached as active */
for (i = 0; i < nedges; i++) {
e = edges + i;
if (e->state == EDGE_READY && (y == e->y)) {
e->state = EDGE_ACTIVE;
}
}
qsort(edges, nedges, sizeof(struct edge),
(gp_sort_callback) edges_compare_runtime);
/* record intersections with active edges */
ninter = 0;
for (i = 0; i < nedges; i++) {
e = edges + i;
if (e->state == EDGE_ACTIVE) {
inter[ninter++] = e->x;
}
}
/* draw each even range between intersections */
for (i = 0; i < ninter; i += 2) {
float start = inter[i];
/* odd number of intersections - skip last */
if (i+1 == ninter)
break;
float end = inter[i+1];
gp_hline_raw(pixmap, start, end, y, pixel);
}
/* update active edges for next step */
for (i = 0; i < nedges; i++) {
e = edges + i;
if (e->state == EDGE_ACTIVE) {
if (e->dy == 0) {
e->state = EDGE_FINISHED;
} else {
e->x += e->dxy;
e->dy--;
}
}
}
}
/* finishing touch: draw all horizontal edges that were skipped
* in the main loop
*/
for (i = 0; i < nedges; i++) {
e = edges + i;
if (e->state == EDGE_HORIZONTAL) {
gp_hline_raw(pixmap, e->x, e->x + e->dxy, e->y,
pixel);
}
}
}
