Revision 27215 branches/v2_0_0_prep/libraries/libGeocoding/src/org/gvsig/geocoding/geommatches/MatcherUtils.java

View differences:

MatcherUtils.java
31 31
import java.util.ArrayList;
32 32
import java.util.HashMap;
33 33
import java.util.Iterator;
34
import java.util.LinkedList;
34 35
import java.util.List;
35 36

  
37
import org.gvsig.fmap.dal.exception.DataException;
38
import org.gvsig.fmap.dal.feature.Feature;
36 39
import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
37 40
import org.gvsig.fmap.geom.Geometry;
38 41
import org.gvsig.fmap.geom.primitive.Curve2D;
......
60 63

  
61 64
	private static final Logger log = LoggerFactory
62 65
			.getLogger(MatcherUtils.class);
66
	
67
	public static final String LINES = "LINES";
68
	public static final String POLYS = "POLYS";
63 69

  
64 70
	/**
65 71
	 * Get internal point from one geometry (polygon)
......
69 75
	 */
70 76
	public static Point2D internalPointGeometry(Geometry geomGV) {
71 77

  
72
		com.vividsolutions.jts.geom.Geometry geomJTS = parseGeomGVToJTS(geomGV);
73
		if (geomJTS != null) {
74
			com.vividsolutions.jts.geom.Point pto = geomJTS.getInteriorPoint();
75
			return new Point2D(pto.getX(), pto.getY());
78
		if (geomGV != null) {
79
			com.vividsolutions.jts.geom.Geometry geomJTS = parseGeomGVToJTS(geomGV);
80
			if (geomJTS != null) {
81
				com.vividsolutions.jts.geom.Point pto = geomJTS
82
						.getInteriorPoint();
83
				if (pto != null) {
84
					return new Point2D(pto.getX(), pto.getY());
85
				}
86
			}
76 87
		}
77
		log.debug("Internal Point NULL ......");
78 88
		return null;
79 89
	}
80 90

  
......
88 98
	public static List<com.vividsolutions.jts.geom.Geometry> parseGeomsGVToJTS(
89 99
			List<Geometry> geoms) {
90 100

  
101
		List<com.vividsolutions.jts.geom.Geometry> list = new ArrayList<com.vividsolutions.jts.geom.Geometry>();
102

  
91 103
		if (geoms != null && geoms.size() > 0) {
92
			List<com.vividsolutions.jts.geom.Geometry> list = new ArrayList<com.vividsolutions.jts.geom.Geometry>();
93 104
			com.vividsolutions.jts.geom.Geometry ge = null;
94 105
			for (Geometry geometry : geoms) {
95 106
				ge = Converter.geometryToJts(geometry);
96 107
				list.add(ge);
97 108
			}
98
			return list;
99
		} else {
100
			log.debug("List of geometries is NULL  ......");
101
			return null;
102 109
		}
110
		return list;
103 111
	}
104 112

  
105 113
	/**
......
113 121
			Geometry geom) {
114 122

  
115 123
		if (geom != null) {
116
			com.vividsolutions.jts.geom.Geometry ge = Converter
117
					.geometryToJts(geom);
118
			return ge;
119
		} else {
120
			log.debug("Geometry is NULL  ......");
121
			return null;
124
			return Converter.geometryToJts(geom);
122 125
		}
126
		return null;
123 127
	}
124 128

  
125 129
	/**
......
131 135
	 */
132 136
	public static List<Geometry> parseGeomsJTSToGV(
133 137
			List<com.vividsolutions.jts.geom.Geometry> geoms) {
138

  
139
		List<Geometry> list = new ArrayList<Geometry>();
140

  
134 141
		if (geoms != null && geoms.size() > 0) {
135
			List<Geometry> list = new ArrayList<Geometry>();
136
			Geometry ge = null;
137 142
			for (com.vividsolutions.jts.geom.Geometry geometry : geoms) {
138
				ge = Converter.jtsToGeometry(geometry);
139
				list.add(ge);
143
				list.add(Converter.jtsToGeometry(geometry));
140 144
			}
141
			return list;
142
		} else {
143
			log.debug("List of geometries is NULL  ......");
144
			return null;
145 145
		}
146
		return list;
146 147
	}
147 148

  
148 149
	/**
......
155 156
	public static Geometry parseGeomJTSToGV(
156 157
			com.vividsolutions.jts.geom.Geometry geom) {
157 158
		if (geom != null) {
158
			Geometry ge = Converter.jtsToGeometry(geom);
159
			return ge;
160
		} else {
161
			log.debug("Geometry is NULL  ......");
162
			return null;
159
			return Converter.jtsToGeometry(geom);
163 160
		}
161
		return null;
164 162
	}
165 163

  
166 164
	/**
......
209 207
	}
210 208

  
211 209
	/**
212
	 * This method does the union the lines geometries (Features) with a
210
	 * This method does the union the geometries (Features) with a
213 211
	 * attribute common
214 212
	 * 
215
	 * @param scoreFeats
213
	 * @param sFeats
214
	 * @param geomType LINES, POLYS
216 215
	 * @return
216
	 * @throws DataException
217 217
	 */
218
	public static List<DissolveResult> dissolveLinesJTS(
219
			List<ScoredFeature> scoreFeats) {
218
	public static List<DissolveResult> dissolveGeomsJTS(
219
			List<ScoredFeature> sFeats, String geomType) throws DataException {
220 220

  
221
		List<DissolveResult> result = new ArrayList<DissolveResult>();
221
		List<DissolveResult> results = new ArrayList<DissolveResult>();
222 222

  
223
		// Used array
224
		boolean[] used = new boolean[scoreFeats.size()];
225
		for (int i = 0; i < used.length; i++) {
226
			used[i] = false;
223
		// None elements
224
		if (sFeats.size() == 0) {
225
			return results;
227 226
		}
228 227

  
229
		// None elements
230
		if (scoreFeats.size() == 0) {
231
			return null;
232
		}
233 228
		// Only one element
234
		else if (scoreFeats.size() == 1) {
235
			DissolveResult res = new DissolveResult();
236
			res.setGeom(scoreFeats.get(0).getDefaultGeometry());
237
			List<ScoredFeature> list = new ArrayList<ScoredFeature>();
238
			list.add(scoreFeats.get(0));
239
			res.setScoredFeatures(list);
240
			result.add(res);
241
			return result;
229
		else if (sFeats.size() == 1) {
230
			DissolveResult result = new DissolveResult();
231
			Feature feat = null;
232
			try {
233
				feat = sFeats.get(0).getFeature();
234
				result.setGeom(feat.getDefaultGeometry());
235
				List<ScoredFeature> list = new ArrayList<ScoredFeature>();
236
				list.add(sFeats.get(0));
237
				result.setScoredFeatures(list);
238
				results.add(result);
239
			} catch (DataException e) {
240
				log.debug("Error getting the feature", e);
241
			}
242
			return results;
242 243
		}
244

  
243 245
		// more elements
244 246
		else {
245
			for (int i = 0; i < scoreFeats.size(); i++) {
246
				ScoredFeature sfea1 = null;
247
				ScoredFeature sfea2 = null;
248
				com.vividsolutions.jts.geom.Geometry ge1 = null;
249
				com.vividsolutions.jts.geom.Geometry ge2 = null;
250
				List<ScoredFeature> feats = new ArrayList<ScoredFeature>();
251
				DissolveResult res = new DissolveResult();
252
				if (!used[i]) {
253
					sfea1 = scoreFeats.get(i);
254
					ge1 = MatcherUtils.parseGeomGVToJTS(sfea1
255
							.getDefaultGeometry());
256
					used[i] = true;
257
					feats.add(sfea1);
258
					for (int j = 0; j < scoreFeats.size(); j++) {
259
						if (!used[j]) {
260
							sfea2 = scoreFeats.get(j);
261
							ge2 = MatcherUtils.parseGeomGVToJTS(sfea2
262
									.getDefaultGeometry());
263
							if (ge1.touches(ge2)) {
264
								used[j] = true;
265
								ge1 = OverlayOp.overlayOp(ge1, ge2,
266
										OverlayOp.UNION);
267
								feats.add(sfea2);
268
							}
269
						}
270
					}
271
					res.setJTSGeom(ge1);
272
					res.setScoredFeatures(feats);
247

  
248
			LinkedList<ScoredFeature> list = new LinkedList<ScoredFeature>();
249
			com.vividsolutions.jts.geom.Geometry geo1, geo2;
250

  
251
			for (ScoredFeature scoredFeature : sFeats) {
252
				list.add(scoredFeature);
253
			}
254

  
255
			// Iterate over the linked list
256
			while (list.size() > 0) {
257
				// Remove the first element of the list
258
				ScoredFeature sFeat = list.poll();
259

  
260
				// create first dissolve result and add it to the list
261
				DissolveResult result = new DissolveResult();
262
				ArrayList<ScoredFeature> dissolveList = new ArrayList<ScoredFeature>();
263
				dissolveList.add(sFeat);
264

  
265
				geo1 = MatcherUtils.parseGeomGVToJTS(sFeat.getFeature()
266
						.getDefaultGeometry());
267
				
268
				ScoredFeature touchingSFeat = null;
269
				// LINES
270
				
271
				if (geomType.compareTo(LINES)==0) {
272
					touchingSFeat = getFirstLineTouchingSF(geo1, list);
273 273
				}
274
			}
275
		}
276
		return result;
274
				// POLYS
275
				if (geomType.compareTo(POLYS)==0) {
276
					touchingSFeat = getFirstPolyTouchingSF(geo1, list);
277
				}				
278

  
279
				while (touchingSFeat != null) {
280
					list.remove(touchingSFeat);
281
					geo2 = MatcherUtils.parseGeomGVToJTS(touchingSFeat
282
							.getFeature().getDefaultGeometry());
283

  
284
					geo1 = OverlayOp.overlayOp(geo1, geo2, OverlayOp.UNION);
285

  
286
					dissolveList.add(touchingSFeat);
287

  
288
					touchingSFeat = getFirstLineTouchingSF(geo1, list);
289
				}
290
				result.setJTSGeom(geo1);
291
				result.setScoredFeatures(dissolveList);
292
				results.add(result);
293
			}			
294
		}		
295
		return results;
277 296
	}
278 297

  
279 298
	/**
280
	 * This method does the union the polygon geometries with a attribute
281
	 * common.
282
	 * 
283
	 * @param geomsJts
299
	 * Get first line of the list that it is touching the in geometry
300
	 * @param geometry
301
	 * @param list
284 302
	 * @return
303
	 * @throws DataException
285 304
	 */
286
	public static List<DissolveResult> dissolvePolysJTS(
287
			List<ScoredFeature> scoreFeats) {
305
	private static ScoredFeature getFirstLineTouchingSF(
306
			com.vividsolutions.jts.geom.Geometry geometry,
307
			LinkedList<ScoredFeature> list) throws DataException {
288 308

  
289
		List<DissolveResult> result = new ArrayList<DissolveResult>();
290

  
291
		// Used array
292
		boolean[] used = new boolean[scoreFeats.size()];
293
		for (int i = 0; i < used.length; i++) {
294
			used[i] = false;
309
		com.vividsolutions.jts.geom.Geometry geo2;
310
		for (ScoredFeature listedSF : list) {
311
			geo2 = MatcherUtils.parseGeomGVToJTS(listedSF.getFeature()
312
					.getDefaultGeometry());
313
			if (geometry.touches(geo2))
314
				return listedSF;
295 315
		}
296
		// None elements
297
		if (scoreFeats.size() == 0) {
298
			return null;
299
		}
300
		// One element
301
		else if (scoreFeats.size() == 1) {
302
			DissolveResult res = new DissolveResult();
303
			res.setGeom(scoreFeats.get(0).getDefaultGeometry());
304
			List<ScoredFeature> list = new ArrayList<ScoredFeature>();
305
			list.add(scoreFeats.get(0));
306
			res.setScoredFeatures(list);
307
			result.add(res);
308
			return result;
316
		return null;
317
	}
309 318

  
310
		}
311
		// More elements
312
		else {
313
			for (int i = 0; i < scoreFeats.size(); i++) {
314
				ScoredFeature sfea1 = null;
315
				ScoredFeature sfea2 = null;
316
				com.vividsolutions.jts.geom.Geometry ge1 = null;
317
				com.vividsolutions.jts.geom.Geometry ge2 = null;
318
				com.vividsolutions.jts.geom.Geometry ge3 = null;
319
				List<ScoredFeature> feats = new ArrayList<ScoredFeature>();
320
				DissolveResult res = new DissolveResult();
319
	/**
320
	 * Get first poly of the list that it is touching the in geometry
321
	 * @param geometry
322
	 * @param list
323
	 * @return
324
	 * @throws DataException
325
	 */
326
	private static ScoredFeature getFirstPolyTouchingSF(
327
			com.vividsolutions.jts.geom.Geometry geometry,
328
			LinkedList<ScoredFeature> list) throws DataException {
321 329

  
322
				if (!used[i]) {
323
					sfea1 = scoreFeats.get(i);
324
					ge1 = MatcherUtils.parseGeomGVToJTS(sfea1
325
							.getDefaultGeometry());
326
					used[i] = true;
327
					feats.add(sfea1);
328

  
329
					for (int j = 0; j < scoreFeats.size(); j++) {
330

  
331
						if (!used[j]) {
332
							sfea2 = scoreFeats.get(j);
333
							ge2 = MatcherUtils.parseGeomGVToJTS(sfea2
334
									.getDefaultGeometry());
335
							ge3 = ge1.intersection(ge2);
336
							for (int k = 0; k < ge3.getNumGeometries(); k++) {
337
								int dim = ge3.getGeometryN(k).getDimension();
338
								if (dim == 1) {
339
									used[j] = true;
340
									ge1 = ge1.union(ge2);
341
									feats.add(sfea2);
342
									break;
343
								}
344
							}
345
						}
346
					}
347
					res.setJTSGeom(ge1);
348
					res.setScoredFeatures(feats);
330
		com.vividsolutions.jts.geom.Geometry geo2;
331
		com.vividsolutions.jts.geom.Geometry geo3;
332
		for (ScoredFeature listedSF : list) {
333
			geo2 = MatcherUtils.parseGeomGVToJTS(listedSF.getFeature()
334
					.getDefaultGeometry());
335
			geo3 = geometry.intersection(geo2);
336
			for (int i = 0; i < geo3.getNumGeometries(); i++) {
337
				int dim = geo3.getGeometryN(i).getDimension();
338
				if (dim == 1) {
339
					return listedSF;
349 340
				}
350
			}
341
			}			
351 342
		}
352
		return result;
343
		return null;
353 344
	}
354 345

  
355 346
	/**
......
367 358
		// Go for all geometries of the collection
368 359
		while (it.hasNext()) {
369 360
			// Get feature
370
			ScoredFeature feat = (ScoredFeature) it.next();
371
			String key = feat.get(desc.getIndex()).toString();
372
			// Store the geometries for attribute in the List
373
			boolean contiene = groups.containsKey(key);
374
			if (!contiene) {
375
				List<ScoredFeature> featss = new ArrayList<ScoredFeature>();
376
				featss.add(feat);
377
				groups.put(key, featss);
378
			} else {
379
				((List<ScoredFeature>) groups.get(key)).add(feat);
361
			ScoredFeature sFeat = (ScoredFeature) it.next();
362
			Feature feat = null;
363
			try {
364
				feat = sFeat.getFeature();
365
				String key = feat.get(desc.getIndex()).toString();
366
				// Store the geometries for attribute in the List
367
				boolean contiene = groups.containsKey(key);
368
				if (!contiene) {
369
					List<ScoredFeature> featss = new ArrayList<ScoredFeature>();
370
					featss.add(sFeat);
371
					groups.put(key, featss);
372
				} else {
373
					((List<ScoredFeature>) groups.get(key)).add(sFeat);
374
				}
375
			} catch (DataException e) {
376
				log.debug("Error clustering element", e);
377
				continue;
380 378
			}
381 379
		}
382 380
		return groups;
......
392 390
	public static Point2D getLinePositionFromDistance(
393 391
			com.vividsolutions.jts.geom.Geometry geomJTS, double distance) {
394 392

  
395
		LengthIndexedLine lenline = new LengthIndexedLine(geomJTS);
396

  
397
		if (lenline.isValidIndex(distance)) {
398
			Coordinate coors = lenline.extractPoint(distance);
399
			return new Point2D(coors.x, coors.y);
393
		if (geomJTS != null) {
394
			LengthIndexedLine lenline = new LengthIndexedLine(geomJTS);
395
			if (distance < 0) {
396
				distance = 0.0;
397
			}
398
			if (distance > geomJTS.getLength()) {
399
				distance = geomJTS.getLength();
400
			}
401
			if (lenline.isValidIndex(distance)) {
402
				Coordinate coors = lenline.extractPoint(distance);
403
				return new Point2D(coors.x, coors.y);
404
			}
400 405
		}
401 406
		return null;
402 407
	}
......
410 415
	 */
411 416
	public static Point2D getLinePositionFromRelativeDistance(
412 417
			com.vividsolutions.jts.geom.Geometry geomJTS, int relative) {
418
		if (geomJTS != null) {
419
			double totaldistance = geomJTS.getLength();
420
			LengthIndexedLine lenline = new LengthIndexedLine(geomJTS);
413 421

  
414
		double totaldistance = geomJTS.getLength();
415
		LengthIndexedLine lenline = new LengthIndexedLine(geomJTS);
422
			Coordinate coors = null;
416 423

  
417
		Coordinate coors = null;
418

  
419
		if (relative < 0) {
420
			coors = lenline.extractPoint(0);
421
			return new Point2D(coors.x, coors.y);
422
		} else if (relative <= 100 && relative >= 0) {
423
			double dist = (relative * totaldistance) / 100.0;
424
			coors = lenline.extractPoint(dist);
425
			return new Point2D(coors.x, coors.y);
426
		} else {
427
			coors = lenline.extractPoint(totaldistance);
428
			return new Point2D(coors.x, coors.y);
424
			if (relative < 0) {
425
				coors = lenline.extractPoint(0);
426
				return new Point2D(coors.x, coors.y);
427
			} else if (relative <= 100 && relative >= 0) {
428
				double dist = (relative * totaldistance) / 100.0;
429
				coors = lenline.extractPoint(dist);
430
				return new Point2D(coors.x, coors.y);
431
			} else {
432
				coors = lenline.extractPoint(totaldistance);
433
				return new Point2D(coors.x, coors.y);
434
			}
429 435
		}
436
		return null;
430 437
	}
431 438

  
432 439
	/**
......
462 469

  
463 470
	/**
464 471
	 * Calculate the position in the line with offset
472
	 * 
465 473
	 * @param geoms
466 474
	 * @param linePoint
467 475
	 * @param dist

Also available in: Unified diff