Beispiel #1
0
int Cluster::cluster(const Points &points, int clusterNum, double mergeLength,
		vector<Points> &clusteredPts, Points &centers) {

	kMeans(points, clusterNum, clusteredPts);
	getClusterCenters(clusteredPts, centers);

	return mergeClusters(mergeLength, centers, clusteredPts);
}
Beispiel #2
0
static void rBoxJoin(struct boxRef *refList, 
	int qStart, int qEnd, int tStart, int tEnd)
/* Recursively cluster boxes. */
{
int boxCount = slCount(refList);

if (boxCount <= 1)
    {
    /* Easy: no merging required. */
    }
else if (boxCount == 2)
    {
    /* Decide if pair overlaps and if so merge. */
    struct box *a = refList->box;
    struct box *b = refList->next->box;
    if (rangeIntersection(a->in->qStart, a->in->qEnd, b->in->qStart, b->in->qEnd) > 0 &&
        rangeIntersection(a->in->tStart, a->in->tEnd, b->in->tStart, b->in->tEnd) > 0 )
	{
	mergeClusters(a->cluster, b->cluster);
	}
    else
        {
	/* Two non-overlapping boxes, we don't have to do anything. */
	}
    }
else if (allStartBy(refList, qStart, tStart))
    {
    /* If everybody contains the upper left corner, then they all can 
     * be merged.   This is the route taken often by clumps with lots
     * of overlap. */
    struct cluster *aCluster = refList->box->cluster;
    struct boxRef *ref;
    for (ref = refList->next; ref != NULL; ref = ref->next)
        {
	struct cluster *bCluster = ref->box->cluster;
	mergeClusters(aCluster, bCluster);
	}
    }
else if (allSameCluster(refList))
    {
    /* Everything is in the same cluster, no action required. */
    }
else
    {
    /* We can't yet figure out clumping, so break
     * up our window in two along larger dimension and
     * recurse on both subwindows. */
    struct boxRef *list1 = NULL, *list2 = NULL, *ref, *next;
    if (qEnd - qStart > tEnd - tStart)
        {
	int mid = (qStart + qEnd)>>1;
	for (ref = refList; ref != NULL; ref = next)
	    {
	    struct box *box = ref->box;
	    next = ref->next;
	    if (box->in->qEnd <= mid)
	        {
		slAddHead(&list1, ref);
		}
	    else if (box->in->qStart >= mid)
	        {
		slAddHead(&list2, ref);
		}
	    else
	        {
		/* Box crosses boundary, have to put it on both lists. */
		slAddHead(&list1, ref);
		lmAllocVar(lm, ref);
		ref->box = box;
		slAddHead(&list2, ref);
		}
	    }
	rBoxJoin(list1, qStart, mid, tStart, tEnd);
	rBoxJoin(list2, mid, qEnd, tStart, tEnd);
	}
    else
        {
int main()
{
    FILE *fp;
    int nVertices = 0,nBits = 0, nEdges = 0,count = 0,maxSpace = 0;
    Vertex *vertices;

    int c,sum=0;

    fp = fopen("clustering_big.txt","r");

    if(fp == NULL)
    {
        printf("%d\n"," Error opening file");
        return 0;
    }


    fscanf(fp,"%d",&nVertices);
    fscanf(fp,"%d",&nBits);

    vertices = (Vertex *)malloc((nVertices+1)*sizeof(struct vertice));


    for(int i = 1; i <= nVertices; i++)
    {
        vertices[i].node = i;
        vertices[i].bits = (int *)malloc(nBits*sizeof(int));
    }



    for(int i = 1; i <= nVertices; i++)
    {
        for(int j = 0; j < nBits; j ++)
        {
            fscanf(fp,"%d",&c);
            vertices[i].bits[j] = c;
        }
    }

    fclose(fp);

    nClusters = nVertices;

    clusters = (int *)malloc(sizeof(int)*(nVertices+1));
    size = (int *)malloc(sizeof(int)*(nVertices+1));

    for(int i = 1; i <= nVertices; i++)
    {
        clusters[i] = i;
        size[i] = 1;
    }


    for(int i = 1; i <= nVertices; i++)
    {
        for(int j = i+1; j <=nVertices; j++)
        {
            for(int k = 0; k < nBits; k++)
            {
                if(vertices[i].bits[k] != vertices[j].bits[k])
                    sum++;
            }
            if(sum <= 2)
            {
                if(!isConnected(i,j))
                {
                    mergeClusters(i,j);
                }
            }
            sum = 0;
        }
    }

    printf("%d\n",nClusters);


    getchar();
    return 0;

}