parallel/test/AverageNeighborhoodTestTask.java

package appl.parallel.test;

import java.awt.Rectangle;

import appl.parallel.spmd.AbstractSPMDTask;
import appl.parallel.spmd.SPMDServerInterface;
import appl.util.RasterUtil;
import de.schmitzm.geotools.data.WritableGrid;

/**
 * @author Dominik Appl
 */
public class AverageNeighborhoodTestTask extends AbstractSPMDTask {

        /**
         * 
         */
        private static final long serialVersionUID = 13L;

    /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDTask#run()
         */
        public Object run(Object...parameters) {
                
                SPMDServerInterface controller = getSPMDServerController();
                WritableGrid gridInput = (WritableGrid) controller
                                .getPartition("inputGrid");
                WritableGrid gridOutput = (WritableGrid) controller
                                .getPartition("outputGrid");
                int neighborhoodRange = (Integer) parameters[0];
                /********************** START REMOTE ALGORITHM *********************
                 * start the calculation (notice that only the outer loop variables have changed)
                 * *****************************************************************/
                float overallSum = 0;
                Rectangle partition = controller.getLocalBounds();
                //System.out.println("290,64: " + gridInput.getRasterSampleAsFloat(controller.getLocalCalcMinX()+289,64));
                for (int y = controller.getLocalCalcMinY(); y < controller
                                .getLocalCalcMaxY() + 1; y++)
                        for (int x = controller.getLocalCalcMinX(); x < controller
                                        .getLocalCalcMaxX() + 1; x++) {
                                float tmp = gridInput.getRasterSampleAsFloat(x,y);
                                if(!Float.isNaN(tmp))
                                        overallSum += tmp;
                                //the local sum is simply the sum over all elements in the neighborhood
                                float localSum = 0;
                                //number of cells over which the sum is calculated
                                int noOfCells = 0;
                                //for each cell: calculate the sum of all neighbors
                                for (int y2 = y - neighborhoodRange; y2 <= y
                                                + neighborhoodRange; y2++)
                                        for (int x2 = x - neighborhoodRange; x2 <= x
                                                        + neighborhoodRange; x2++)
                                                //check if the coordinates are valid (inside the grid and not NaN)
                                                if (partition.contains(x2, y2))
                                                        if (!Float.isNaN(gridInput
                                                                        .getRasterSampleAsFloat(x2, y2))) {
                                                                localSum += gridInput.getRasterSampleAsFloat(
                                                                                x2, y2);
                                                                noOfCells++;
                                                        }
                                gridOutput.setRasterSample(localSum / (float) (noOfCells), x,y);

                        }
        //copy values into results from output to input (for next step)
        RasterUtil.copyInto(gridOutput, gridInput);
        return overallSum;
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.AbstractSPMDTask#init()
         */
        @Override
        public void init() {
                // TODO Auto-generated method stub
                
        }

        
        
}
1	package appl.parallel.test;
2
3	import java.awt.Rectangle;
4
5	import appl.parallel.spmd.AbstractSPMDTask;
6	import appl.parallel.spmd.SPMDServerInterface;
7	import appl.util.RasterUtil;
8	import de.schmitzm.geotools.data.WritableGrid;
9
10	/**
11	* @author Dominik Appl
12	*/
13	public class AverageNeighborhoodTestTask extends AbstractSPMDTask {
14
15	/**
16	*
17	*/
18	private static final long serialVersionUID = 13L;
19
20	/* (non-Javadoc)
21	* @see appl.parallel.spmd.SPMDTask#run()
22	*/
23	public Object run(Object...parameters) {
24
25	SPMDServerInterface controller = getSPMDServerController();
26	WritableGrid gridInput = (WritableGrid) controller
27	.getPartition("inputGrid");
28	WritableGrid gridOutput = (WritableGrid) controller
29	.getPartition("outputGrid");
30	int neighborhoodRange = (Integer) parameters[0];
31	/******************** START REMOTE ALGORITHM *******************
32	* start the calculation (notice that only the outer loop variables have changed)
33	* *****************************************************************/
34	float overallSum = 0;
35	Rectangle partition = controller.getLocalBounds();
36	//System.out.println("290,64: " + gridInput.getRasterSampleAsFloat(controller.getLocalCalcMinX()+289,64));
37	for (int y = controller.getLocalCalcMinY(); y < controller
38	.getLocalCalcMaxY() + 1; y++)
39	for (int x = controller.getLocalCalcMinX(); x < controller
40	.getLocalCalcMaxX() + 1; x++) {
41	float tmp = gridInput.getRasterSampleAsFloat(x,y);
42	if(!Float.isNaN(tmp))
43	overallSum += tmp;
44	//the local sum is simply the sum over all elements in the neighborhood
45	float localSum = 0;
46	//number of cells over which the sum is calculated
47	int noOfCells = 0;
48	//for each cell: calculate the sum of all neighbors
49	for (int y2 = y - neighborhoodRange; y2 <= y
50	+ neighborhoodRange; y2++)
51	for (int x2 = x - neighborhoodRange; x2 <= x
52	+ neighborhoodRange; x2++)
53	//check if the coordinates are valid (inside the grid and not NaN)
54	if (partition.contains(x2, y2))
55	if (!Float.isNaN(gridInput
56	.getRasterSampleAsFloat(x2, y2))) {
57	localSum += gridInput.getRasterSampleAsFloat(
58	x2, y2);
59	noOfCells++;
60	}
61	gridOutput.setRasterSample(localSum / (float) (noOfCells), x,y);
62
63	}
64	//copy values into results from output to input (for next step)
65	RasterUtil.copyInto(gridOutput, gridInput);
66	return overallSum;
67	}
68
69	/* (non-Javadoc)
70	* @see appl.parallel.spmd.AbstractSPMDTask#init()
71	*/
72	@Override
73	public void init() {
74	// TODO Auto-generated method stub
75
76	}
77
78
79
80	}