daoas/fulddaekning/LookupWorker.java

package dk.daoas.fulddaekning;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

import ags.utils.dataStructures.MaxHeap;
import ags.utils.dataStructures.trees.thirdGenKD.DistanceFunction;
import ags.utils.dataStructures.trees.thirdGenKD.KdTree;
import ags.utils.dataStructures.trees.thirdGenKD.SquareEuclideanDistanceFunction;
import dk.daoas.fulddaekning.osrm.OSRMHelper;

public class LookupWorker implements Runnable {

        static final int MAX_RESULTS = 99;


        final static Logger logger = Logger.getLogger( LookupWorker.class.toString() );

        OSRMHelper osrmHelper = new OSRMHelper();

        CyclicBarrier barrier;
        Queue<Adresse> ikkeDaekkede;
        Map<Short, KdTree<Adresse>> hoTrees;
        Database db;
        Constants consts;
        ProgressBar progressBar;
        
        AtomicInteger antalFundne;

        int workerID;
        boolean verbose;
        
        DistanceFunction dist = new SquareEuclideanDistanceFunction();
        
        public LookupWorker(int workerID, 
                                CyclicBarrier barrier, 
                                Queue<Adresse> ikkeDaekkede, 
                                Map<Short, KdTree<Adresse>> hoTrees, 
                                AtomicInteger antalFundne,
                                Database db,
                                boolean verbose,
                                Constants consts,
                                ProgressBar progressBar) {
                
                this.workerID = workerID;
                this.barrier = barrier;
                this.ikkeDaekkede = ikkeDaekkede;
                this.hoTrees = hoTrees;
                this.antalFundne = antalFundne;
                this.db = db;
                this.verbose = verbose;
                this.consts = consts;
                this.progressBar = progressBar;
                
        }


        @Override
        public void run() {
                System.out.println( "Worker/" + workerID + " starting");

                try {
                        while ( ! ikkeDaekkede.isEmpty() ) {
                        
                                Adresse qAdresse = ikkeDaekkede.remove();

                                short ho = qAdresse.ho;
                                KdTree<Adresse> addressTree = hoTrees.get(ho);

                                MaxHeap<Adresse> res = addressTree.findNearestNeighbors(qAdresse.xyz, MAX_RESULTS, dist);
                                //Collection<Adresse> res = addressTree.nearestNeighbourSearch(MAX_RESULTS, qAdresse);
                                int size = res.size();
                                if (size > MAX_RESULTS ) {
                                        System.out.println("Returnerede mere end MAX_RESULTS> " + res.size() );
                                        System.exit(0);
                                }
                                
                                ArrayList<Adresse> adrList = new ArrayList<Adresse>();

                                for (int i=0; i<size; i++) {
                                        Adresse a = res.getMax();
                                        adrList.add(a);
                                        res.removeMax();
                                }
                                Adresse bedsteAdr = adrList.get(size-1); //da det er en max-heap er det elementet med størst distance der er først og dermed den sidste der er tættest
                                double bedsteAfstand = GeoPointHelper.beregnAfstand(qAdresse, bedsteAdr);


                        if ( LookupMain.use_osrm == true) {
                                //Hvis at den er inden for afstand, så prøver vi at lave findNærmste på vej distancen
                                if (bedsteAfstand <= consts.getMaxDistance()) {
                                        //Adresse bedsteAdr2 = osrmHelper.getNearestViarouteHttp(qAdresse, res);  
                                        Adresse bedsteAdr2 = osrmHelper.getNearestTableHttp(qAdresse, adrList); 
  
                                        if (bedsteAdr2 != null) {
                                                bedsteAdr = bedsteAdr2;
                                                bedsteAfstand = GeoPointHelper.beregnAfstand(qAdresse, bedsteAdr);
                                        } else {
                                                logger.info("OSRM returned null for " + qAdresse);
                                        }
                                }
                        }


                        if (bedsteAfstand <= consts.getMaxDistance() ) { //Gem kun hvis distancen er under max_distance for distributøren
                                if (verbose == true) {
                                        logger.fine("(" +workerID + ") Bedste: " + qAdresse + "==>" + bedsteAdr + " ::: " + bedsteAfstand );
                                }

                                antalFundne.incrementAndGet();

                                try {
                                        db.gemResultat(qAdresse, bedsteAdr, bedsteAfstand);
                                } catch (SQLException e) {
                                        logger.log(Level.WARNING, "Error saving result", e);
                                        logger.warning("Shutting down");

                                        System.exit(0); //hvis at indsættelsen fejler skal vi afbryde med det samme
                                }
                        } else {
                                if (verbose == true) {
                                        System.out.println("For stor afstand: " + qAdresse + " > " + bedsteAfstand);
                                }
                        }
                
                        progressBar.tick();

                        }

                } catch (Exception e) {
                        logger.log( Level.SEVERE, "Worker/" + workerID, e);
                }


                try {
                        logger.info( "Worker/" + workerID + " afventer barrier");
                        barrier.await();
                } catch (BrokenBarrierException e) {
                        logger.log(Level.SEVERE, e.getMessage(), e);
                        System.exit(-1);
                } catch(InterruptedException e) {
                        logger.log(Level.SEVERE, e.getMessage(), e);
                }


                System.out.println( "Worker/" + workerID + " stopping");
        }

}
1	torben	2711	package dk.daoas.fulddaekning;
2
3			import java.sql.SQLException;
4	torben	2744	import java.util.ArrayList;
5	torben	2711	import java.util.Map;
6			import java.util.Queue;
7			import java.util.concurrent.BrokenBarrierException;
8			import java.util.concurrent.CyclicBarrier;
9			import java.util.concurrent.atomic.AtomicInteger;
10			import java.util.logging.Level;
11			import java.util.logging.Logger;
12
13	torben	2744	import ags.utils.dataStructures.MaxHeap;
14			import ags.utils.dataStructures.trees.thirdGenKD.DistanceFunction;
15			import ags.utils.dataStructures.trees.thirdGenKD.KdTree;
16			import ags.utils.dataStructures.trees.thirdGenKD.SquareEuclideanDistanceFunction;
17	torben	2711	import dk.daoas.fulddaekning.osrm.OSRMHelper;
18
19			public class LookupWorker implements Runnable {
20
21	torben	2755	static final int MAX_RESULTS = 99;
22	torben	2711
23
24
25			final static Logger logger = Logger.getLogger( LookupWorker.class.toString() );
26
27			OSRMHelper osrmHelper = new OSRMHelper();
28
29			CyclicBarrier barrier;
30			Queue<Adresse> ikkeDaekkede;
31			Map<Short, KdTree<Adresse>> hoTrees;
32			Database db;
33			Constants consts;
34	torben	2797	ProgressBar progressBar;
35	torben	2711
36			AtomicInteger antalFundne;
37
38			int workerID;
39			boolean verbose;
40
41	torben	2744	DistanceFunction dist = new SquareEuclideanDistanceFunction();
42
43	torben	2711	public LookupWorker(int workerID,
44			CyclicBarrier barrier,
45			Queue<Adresse> ikkeDaekkede,
46			Map<Short, KdTree<Adresse>> hoTrees,
47			AtomicInteger antalFundne,
48			Database db,
49			boolean verbose,
50	torben	2797	Constants consts,
51			ProgressBar progressBar) {
52	torben	2711
53			this.workerID = workerID;
54			this.barrier = barrier;
55			this.ikkeDaekkede = ikkeDaekkede;
56			this.hoTrees = hoTrees;
57			this.antalFundne = antalFundne;
58			this.db = db;
59			this.verbose = verbose;
60			this.consts = consts;
61	torben	2797	this.progressBar = progressBar;
62	torben	2711
63			}
64
65
66			@Override
67			public void run() {
68			System.out.println( "Worker/" + workerID + " starting");
69
70	torben	2722	try {
71			while ( ! ikkeDaekkede.isEmpty() ) {
72	torben	2713
73	torben	2722	Adresse qAdresse = ikkeDaekkede.remove();
74	torben	2711
75	torben	2722	short ho = qAdresse.ho;
76			KdTree<Adresse> addressTree = hoTrees.get(ho);
77	torben	2711
78	torben	2744	MaxHeap<Adresse> res = addressTree.findNearestNeighbors(qAdresse.xyz, MAX_RESULTS, dist);
79			//Collection<Adresse> res = addressTree.nearestNeighbourSearch(MAX_RESULTS, qAdresse);
80			int size = res.size();
81			if (size > MAX_RESULTS ) {
82	torben	2722	System.out.println("Returnerede mere end MAX_RESULTS> " + res.size() );
83			System.exit(0);
84			}
85	torben	2744
86			ArrayList<Adresse> adrList = new ArrayList<Adresse>();
87	torben	2711
88	torben	2744	for (int i=0; i<size; i++) {
89			Adresse a = res.getMax();
90			adrList.add(a);
91			res.removeMax();
92			}
93			Adresse bedsteAdr = adrList.get(size-1); //da det er en max-heap er det elementet med størst distance der er først og dermed den sidste der er tættest
94			double bedsteAfstand = GeoPointHelper.beregnAfstand(qAdresse, bedsteAdr);
95	torben	2711
96	torben	2722
97	torben	2753	if ( LookupMain.use_osrm == true) {
98			//Hvis at den er inden for afstand, så prøver vi at lave findNærmste på vej distancen
99			if (bedsteAfstand <= consts.getMaxDistance()) {
100	torben	2795	//Adresse bedsteAdr2 = osrmHelper.getNearestViarouteHttp(qAdresse, res);
101			Adresse bedsteAdr2 = osrmHelper.getNearestTableHttp(qAdresse, adrList);
102
103	torben	2753	if (bedsteAdr2 != null) {
104			bedsteAdr = bedsteAdr2;
105			bedsteAfstand = GeoPointHelper.beregnAfstand(qAdresse, bedsteAdr);
106			} else {
107			logger.info("OSRM returned null for " + qAdresse);
108			}
109	torben	2722	}
110	torben	2718	}
111	torben	2711
112	torben	2753
113	torben	2718
114	torben	2711
115	torben	2718
116	torben	2711	if (bedsteAfstand <= consts.getMaxDistance() ) { //Gem kun hvis distancen er under max_distance for distributøren
117			if (verbose == true) {
118			logger.fine("(" +workerID + ") Bedste: " + qAdresse + "==>" + bedsteAdr + " ::: " + bedsteAfstand );
119			}
120
121			antalFundne.incrementAndGet();
122
123			try {
124			db.gemResultat(qAdresse, bedsteAdr, bedsteAfstand);
125			} catch (SQLException e) {
126			logger.log(Level.WARNING, "Error saving result", e);
127			logger.warning("Shutting down");
128
129			System.exit(0); //hvis at indsættelsen fejler skal vi afbryde med det samme
130			}
131			} else {
132			if (verbose == true) {
133			System.out.println("For stor afstand: " + qAdresse + " > " + bedsteAfstand);
134			}
135			}
136	torben	2797
137			progressBar.tick();
138	torben	2711
139	torben	2722	}
140
141			} catch (Exception e) {
142			logger.log( Level.SEVERE, "Worker/" + workerID, e);
143	torben	2711	}
144
145	torben	2722
146
147	torben	2711	try {
148	torben	2722	logger.info( "Worker/" + workerID + " afventer barrier");
149	torben	2711	barrier.await();
150			} catch (BrokenBarrierException e) {
151			logger.log(Level.SEVERE, e.getMessage(), e);
152			System.exit(-1);
153			} catch(InterruptedException e) {
154	torben	2719	logger.log(Level.SEVERE, e.getMessage(), e);
155	torben	2711	}
156
157
158			System.out.println( "Worker/" + workerID + " stopping");
159			}
160
161			}