sensornetwork.java

Sensor net work simulator in Java

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Point;
import java.util.ArrayList;

/**
 *
 * @author Dhiraj
 * @date Jan 26, 2009
 *
 */
public class SensorNetwork {

    private int iNumOfNodes,  iNetworkWidth,  iNetworkHeight,  iNumClusters;
    private SensorNode sensorNode;
    private Graphics gDraw;
    private ArrayList<SensorNode> alAllNodes;
    private ArrayList<Cluster> alClusters;
    private static int iNodeSize = 10;
    private static int iRadioSize = iNodeSize * 20;

    public SensorNetwork(int iNumOfNodes, int iNetworkWidth, int iNetworkHeight, int iNumClusters) {
        this.iNumOfNodes = iNumOfNodes;
        this.iNetworkWidth = iNetworkWidth;
        this.iNetworkHeight = iNetworkHeight;
        this.iNumClusters = iNumClusters;
        alAllNodes = new ArrayList<SensorNode>();
        alClusters = new ArrayList<Cluster>();
    }

    public void setGDraw(Graphics gDraw) {
        this.gDraw = gDraw;
    }

    public void initializeNetwork() {
        int iXCord, iYCord, iIPAdd;
        Point ptCluster, ptNodeCords;
        Color cCluster;

        iIPAdd = 0;

        for (int iCounter = 0; iCounter < iNumOfNodes; iCounter++) {
            iXCord = (int) (Math.random() * iNetworkWidth);
            iYCord = (int) (Math.random() * iNetworkHeight);

            ptNodeCords = new Point(iXCord, iYCord);

            sensorNode = new SensorNode(ptNodeCords, iIPAdd, 100, Color.BLACK);
            alAllNodes.add(sensorNode);

            iIPAdd++;
        }

        for (int iCounter = 0; iCounter < iNumClusters; iCounter++) {
            iXCord = (int) (Math.random() * iNetworkWidth);
            iYCord = (int) (Math.random() * iNetworkHeight);

            ptCluster = new Point(iXCord, iYCord);
            cCluster = new Color((int) (Math.random() * 255), (int) (Math.random() * 255), (int) (Math.random() * 255));

            alClusters.add(new Cluster(ptCluster, cCluster));
        }
    }

    public void drawNetwork() {

        for (SensorNode sn : alAllNodes) {
            gDraw.setColor(sn.getCCluster());
            gDraw.fillOval(sn.getPtCords().x,
                    sn.getPtCords().y,
                    iNodeSize, iNodeSize);

            gDraw.setFont(new Font("Arial", 10, 10));
            gDraw.setColor(Color.black);
            /*gDraw.drawString(Integer.toString(sn.getIBatteryLevel()),
            sn.getPtCords().x,
            sn.getPtCords().y - 2);*/

            gDraw.drawString(Integer.toString(sn.getIIPAdd()),
                    sn.getPtCords().x,
                    sn.getPtCords().y - 2);

        /*gDraw.setColor(sn.getCCluster());
        gDraw.drawOval(sn.getPtCords().x - (iRadioSize / 2) + (iNodeSize / 2),
        sn.getPtCords().y - (iRadioSize / 2) + (iNodeSize / 2),
        iRadioSize, iRadioSize);*/
        }

        for (Cluster clus : alClusters) {
            gDraw.setColor(clus.getCClusterColor());
            gDraw.fillOval(clus.getPCentroid().x,
                    clus.getPCentroid().y,
                    iNodeSize / 2, iNodeSize / 2);

        /*Point pt1 = clus.getAlNodes().get(0).getPtCords();
        Point pt2 = clus.getAlNodes().get(1).getPtCords();

        gDraw.drawLine(pt1.x + (iNodeSize / 2), pt1.y + (iNodeSize / 2), pt2.x + (iNodeSize / 2), pt2.y + (iNodeSize / 2));*/
        }
    }

    public void clustering() {
        Point ptNewCentroid, ptOldCentroid;

        System.out.println("Clustering started");

        this.classifyNodes();

        for (Cluster clus : alClusters) {

            System.out.println("===========================================================================");
//            System.out.println("Initial Centroid: " + clus.getPCentroid().x + "," + clus.getPCentroid().y);

            ptNewCentroid = null;
            ptOldCentroid = ptNewCentroid;

            while (true) {

                ptNewCentroid = calculateNewCentroid(clus);

                System.out.println("Old Centroid: " + clus.getPCentroid().x + "," + clus.getPCentroid().y);

                clus.setPCentroid(ptNewCentroid);

                System.out.println("New Centroid: " + clus.getPCentroid().x + "," + clus.getPCentroid().y);
                clearClusters();
                this.classifyNodes();



                if (ptNewCentroid.equals(ptOldCentroid)) {
                    break;
                } else {
                    ptOldCentroid = ptNewCentroid;
                }
            }

        }

        System.out.println("Clustering Finished");

        this.discoverNeighbor();
    }

    public void classifyNodes() {

        double dDistance, dMinDistance;
        Cluster cNearestCluster;

//        System.out.println("Classifying started");

        for (SensorNode sn : alAllNodes) {

            dMinDistance = 1000000;
            cNearestCluster = null;

            for (Cluster clus : alClusters) {
                dDistance = sn.getPtCords().distance(clus.getPCentroid());

                if (dDistance < dMinDistance) {
                    dMinDistance = dDistance;
                    cNearestCluster = clus;
                }
            }

            sn.setCCluster(cNearestCluster.getCClusterColor());
            cNearestCluster.getAlNodes().add(sn);
        }
    }

    public void clearClusters() {
        //Clear all nodes
        for (Cluster clus : alClusters) {
            clus.getAlNodes().clear();
        }
    }

    public Point calculateNewCentroid(Cluster clus) {
        Point ptNewCentroid;
        double dMeanXCords = 0, dMeanYCords = 0;
        int iSumXCords = 0, iSumYCords = 0, iTotalNodes = 0;

        iSumXCords = 0;
        iSumYCords = 0;
        iTotalNodes = 0;
        for (SensorNode sn : clus.getAlNodes()) {
            iSumXCords = iSumXCords + sn.getPtCords().x;
            iSumYCords = iSumYCords + sn.getPtCords().y;
            iTotalNodes++;
            System.out.println("Node ID: " + sn.getIIPAdd() + "-> " + sn.getPtCords().x + "," + sn.getPtCords().y);
        }

        System.out.println("Total nodes: " + iTotalNodes);
        if (iTotalNodes > 0) {
            dMeanXCords = iSumXCords / iTotalNodes;
            dMeanYCords = iSumYCords / iTotalNodes;
        } else {
            dMeanXCords = 0;
            dMeanYCords = 0;
        }
        ptNewCentroid = new Point((int) dMeanXCords, (int) dMeanYCords);
        return ptNewCentroid;
    }

    public void discoverNeighbor() {

        int iNumNodesInCluster;
        double dDistance;
        Point ptPoint1, ptPoint2;

        //For each cluster
        for (Cluster clus : alClusters) {

            iNumNodesInCluster = clus.getAlNodes().size();
            dDistance = 0;

            //For each node in a cluster
            for (SensorNode sn : clus.getAlNodes()) {

//                System.out.println("Node: " + sn.getIIPAdd());
                ptPoint1 = sn.getPtCords();
                ptPoint1.setLocation(ptPoint1.x + (iNodeSize / 2), ptPoint1.y + (iNodeSize / 2));

                //Get distance between this node and all other nodes in cluster
                for (int iCounter = 0; iCounter < iNumNodesInCluster; iCounter++) {
                    ptPoint2 = clus.getAlNodes().get(iCounter).getPtCords();
                    ptPoint2.setLocation(ptPoint2.x + (iNodeSize / 2), ptPoint2.y + (iNodeSize / 2));

                    dDistance = ptPoint1.distance(ptPoint2);
                    if ((dDistance > 0) && (dDistance <= iRadioSize)) {
                        sn.getAlNeighbors().add(clus.getAlNodes().get(iCounter));
//                        System.out.println("Neighbors: " + clus.getAlNodes().get(iCounter).getIIPAdd());
                    }
                }
            }
        }
    }
}