root / org.gvsig.toolbox / trunk / org.gvsig.toolbox / org.gvsig.toolbox.algorithm / src / main / java / es / unex / sextante / vectorize / vectorize / VectorizeAlgorithm.java @ 59
History | View | Annotate | Download (18.5 KB)
1 |
//package es.unex.sextante.vectorize.vectorize;
|
---|---|
2 |
//
|
3 |
//import java.awt.geom.Point2D;
|
4 |
//import java.util.ArrayList;
|
5 |
//
|
6 |
//import com.vividsolutions.jts.geom.Coordinate;
|
7 |
//import com.vividsolutions.jts.geom.Geometry;
|
8 |
//import com.vividsolutions.jts.geom.GeometryFactory;
|
9 |
//import com.vividsolutions.jts.geom.LinearRing;
|
10 |
//import com.vividsolutions.jts.geom.Polygon;
|
11 |
//
|
12 |
//import es.unex.sextante.core.AnalysisExtent;
|
13 |
//import es.unex.sextante.core.GeoAlgorithm;
|
14 |
//import es.unex.sextante.core.Sextante;
|
15 |
//import es.unex.sextante.dataObjects.IRasterLayer;
|
16 |
//import es.unex.sextante.dataObjects.IVectorLayer;
|
17 |
//import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;
|
18 |
//import es.unex.sextante.exceptions.RepeatedParameterNameException;
|
19 |
//import es.unex.sextante.exceptions.UnsupportedOutputChannelException;
|
20 |
//import es.unex.sextante.outputs.OutputVectorLayer;
|
21 |
//
|
22 |
//public class VectorizeAlgorithm
|
23 |
// extends
|
24 |
// GeoAlgorithm {
|
25 |
//
|
26 |
// public static final String LAYER = "LAYER";
|
27 |
// public static final String RESULT = "RESULT";
|
28 |
//
|
29 |
// private IRasterLayer m_Input;
|
30 |
// private IRasterLayer m_Edge;
|
31 |
// private IVectorLayer m_Polygons;
|
32 |
// private int m_iNX, m_iNY;
|
33 |
// private char[][] m_Lock;
|
34 |
// private ArrayList<Coordinate> m_Coords;
|
35 |
// private ArrayList<Geometry> m_Polyg;
|
36 |
//
|
37 |
// private static final int m_IX[] = { 0, 1, 1, 1, 0, -1, -1, -1 };
|
38 |
// private static final int m_IY[] = { -1, -1, 0, 1, 1, 1, 0, -1 };
|
39 |
//
|
40 |
//
|
41 |
// @Override
|
42 |
// public void defineCharacteristics() {
|
43 |
//
|
44 |
// setName(Sextante.getText("Vectorize_raster_layer__polygons"));
|
45 |
// setGroup(Sextante.getText("Vectorization"));
|
46 |
// setUserCanDefineAnalysisExtent(true);
|
47 |
//
|
48 |
// try {
|
49 |
// m_Parameters.addInputRasterLayer(LAYER, Sextante.getText("Input_layer"), true);
|
50 |
// addOutputVectorLayer(RESULT, Sextante.getText("Result"), OutputVectorLayer.SHAPE_TYPE_POLYGON);
|
51 |
// }
|
52 |
// catch (final RepeatedParameterNameException e) {
|
53 |
// Sextante.addErrorToLog(e);
|
54 |
// }
|
55 |
//
|
56 |
// }
|
57 |
//
|
58 |
//
|
59 |
// @Override
|
60 |
// public boolean processAlgorithm() throws GeoAlgorithmExecutionException {
|
61 |
//
|
62 |
// final String sFields[] = new String[2];
|
63 |
// final Class types[] = { Integer.class, Double.class };
|
64 |
//
|
65 |
// m_Input = m_Parameters.getParameterValueAsRasterLayer(LAYER);
|
66 |
// m_Input.setWindowExtent(m_AnalysisExtent);
|
67 |
//
|
68 |
// sFields[0] = "ID";
|
69 |
// sFields[1] = m_Input.getName();
|
70 |
//
|
71 |
// m_Polygons = getNewVectorLayer(RESULT, Sextante.getText("Result"), IVectorLayer.SHAPE_TYPE_POLYGON, types, sFields);
|
72 |
//
|
73 |
// createPolygons();
|
74 |
//
|
75 |
// return !m_Task.isCanceled();
|
76 |
//
|
77 |
// }
|
78 |
//
|
79 |
//
|
80 |
// private void createPolygons() throws UnsupportedOutputChannelException {
|
81 |
//
|
82 |
// int x, y, ID;
|
83 |
// double dValue;
|
84 |
//
|
85 |
// m_iNX = m_Input.getNX();
|
86 |
// m_iNY = m_Input.getNY();
|
87 |
//
|
88 |
// m_Coords = new ArrayList<Coordinate>();
|
89 |
// m_Polyg = new ArrayList<Geometry>();
|
90 |
//
|
91 |
// m_Lock = new char[m_iNY][m_iNX];
|
92 |
//
|
93 |
// final AnalysisExtent ge = new AnalysisExtent();
|
94 |
// final AnalysisExtent wge = m_Input.getWindowGridExtent();
|
95 |
// ge.setCellSize(wge.getCellSize() * .5);
|
96 |
// ge.setXRange(wge.getXMin() - wge.getCellSize() * .5, wge.getXMax() + wge.getCellSize() * .5, true);
|
97 |
// ge.setYRange(wge.getYMin() - wge.getCellSize() * .5, wge.getYMax() + wge.getCellSize() * .5, true);
|
98 |
// m_Edge = getTempRasterLayer(IRasterLayer.RASTER_DATA_TYPE_BYTE, ge);
|
99 |
//
|
100 |
// //m_Area = new char[m_iNY + 1][m_iNX + 1];
|
101 |
//
|
102 |
// for (y = 0, ID = 1; (y < m_iNY) && setProgress(y, m_iNY); y++) {
|
103 |
// for (x = 0; x < m_iNX; x++) {
|
104 |
// dValue = m_Input.getCellValueAsDouble(x, y);
|
105 |
// if (!m_Input.isNoDataValue(dValue) && (m_Lock[y][x] == 0)) {
|
106 |
// Get_Class(dValue);
|
107 |
// final Object values[] = new Object[2];
|
108 |
// values[0] = new Integer(ID++);
|
109 |
// values[1] = new Double(dValue);
|
110 |
// final GeometryFactory gf = new GeometryFactory();
|
111 |
// m_Polygons.addFeature(gf.createMultiPolygon(m_Polyg.toArray(new Polygon[0])), values);
|
112 |
// }
|
113 |
// }
|
114 |
// }
|
115 |
//
|
116 |
// }
|
117 |
//
|
118 |
//
|
119 |
// private void Get_Class(final double dClassValue) {
|
120 |
//
|
121 |
// int x, y, i, ix, iy, n, nEdgeCells;
|
122 |
//
|
123 |
// m_Polyg.clear();
|
124 |
//
|
125 |
// for (y = 0, nEdgeCells = 0; (y < m_iNY) && !this.m_Task.isCanceled(); y++) {
|
126 |
// for (x = 0; x < m_iNX; x++) {
|
127 |
// double dValue = m_Input.getCellValueAsDouble(x, y);
|
128 |
// if ((m_Lock[y][x] == 0) && (dValue == dClassValue)) {
|
129 |
// m_Lock[y][x] = 1;
|
130 |
// for (i = 0, n = 0; i < 8; i += 2) {
|
131 |
// ix = Get_xTo(i, x);
|
132 |
// iy = Get_yTo(i, y);
|
133 |
// dValue = m_Input.getCellValueAsDouble(ix, iy);
|
134 |
// if (dValue != dClassValue) {
|
135 |
// ix = Get_xTo(i, 1 + 2 * x);
|
136 |
// iy = Get_yTo(i, 1 + 2 * y);
|
137 |
// m_Edge.setCellValue(ix, iy, i + 2);
|
138 |
//
|
139 |
// ix = Get_xTo(i - 1, 1 + 2 * x);
|
140 |
// iy = Get_yTo(i - 1, 1 + 2 * y);
|
141 |
// m_Edge.setCellValue(ix, iy, m_Edge.getCellValueAsInt(ix, iy) != 0 ? -1 : i + 2);
|
142 |
//
|
143 |
// n++;
|
144 |
// }
|
145 |
// }
|
146 |
//
|
147 |
// if (n == 4) {
|
148 |
// Get_Square(1 + 2 * x, 1 + 2 * y);
|
149 |
// }
|
150 |
// else {
|
151 |
// nEdgeCells++;
|
152 |
// }
|
153 |
// }
|
154 |
// }
|
155 |
// }
|
156 |
//
|
157 |
// if (nEdgeCells > 0) {
|
158 |
// Get_Polygons();
|
159 |
// }
|
160 |
//
|
161 |
// }
|
162 |
//
|
163 |
//
|
164 |
// private void Get_Square(final int x,
|
165 |
// final int y) {
|
166 |
//
|
167 |
// int i, ix, iy;
|
168 |
// final double dCellSize = m_Edge.getWindowCellSize() * .5;
|
169 |
//
|
170 |
// for (i = 0; i < 8; i++) {
|
171 |
// ix = Get_xTo(i, x);
|
172 |
// iy = Get_yTo(i, y);
|
173 |
//
|
174 |
// m_Edge.setCellValue(ix, iy, m_Edge.getCellValueAsInt(ix, iy) > 0 ? 0 : (i > 1 ? i - 1 : i + 7));
|
175 |
//
|
176 |
// if (i % 2 != 0) {
|
177 |
// Point2D pt;
|
178 |
// pt = m_Edge.getWindowGridExtent().getWorldCoordsFromGridCoords(ix, iy);
|
179 |
// m_Coords.add(new Coordinate(pt.getX() + dCellSize, pt.getY() - dCellSize));
|
180 |
// }
|
181 |
// }
|
182 |
// }
|
183 |
//
|
184 |
//
|
185 |
// private void Get_Polygons() {
|
186 |
//
|
187 |
// for (int y = 0; (y < m_Edge.getNY()) && !m_Task.isCanceled(); y++) {
|
188 |
// for (int x = 0; x < m_Edge.getNX(); x++) {
|
189 |
// if (m_Edge.getCellValueAsInt(x, y) > 0) {
|
190 |
// m_Coords.clear();
|
191 |
// Get_Polygon(x, y);
|
192 |
// final Coordinate coord = m_Coords.get(0);
|
193 |
// m_Coords.add(new Coordinate(coord.x, coord.y));
|
194 |
// final Coordinate[] coords = m_Coords.toArray(new Coordinate[0]);
|
195 |
// final GeometryFactory gf = new GeometryFactory();
|
196 |
// try {
|
197 |
// final LinearRing ring = gf.createLinearRing(coords);
|
198 |
// m_Polyg.add(gf.createPolygon(ring, null));
|
199 |
// }
|
200 |
// catch (final Exception e) {
|
201 |
// // might reach this if we try to create a polygon with less than 3 coords.
|
202 |
// // we just ignore it
|
203 |
// }
|
204 |
// }
|
205 |
// }
|
206 |
// }
|
207 |
//
|
208 |
// }
|
209 |
//
|
210 |
//
|
211 |
// private void Get_Polygon(int x,
|
212 |
// int y) {
|
213 |
//
|
214 |
// int i, iLast = -1;
|
215 |
// final double dCellSize = m_Edge.getWindowCellSize() * .5;
|
216 |
//
|
217 |
// while ((i = m_Edge.getCellValueAsInt(x, y)) != 0) {
|
218 |
// if (i < 0) {
|
219 |
// i = iLast + 2;
|
220 |
// m_Edge.setCellValue(x, y, (iLast == 2 ? 8 : iLast - 2));
|
221 |
// }
|
222 |
// else {
|
223 |
// m_Edge.setCellValue(x, y, 0);
|
224 |
// }
|
225 |
//
|
226 |
// if (i != iLast) {
|
227 |
// final Point2D pt = m_Edge.getWindowGridExtent().getWorldCoordsFromGridCoords(x, y);
|
228 |
// iLast = i;
|
229 |
// m_Coords.add(new Coordinate(pt.getX() + dCellSize, pt.getY() - dCellSize));
|
230 |
// }
|
231 |
//
|
232 |
// x = Get_xTo(i, x);
|
233 |
// y = Get_yTo(i, y);
|
234 |
// }
|
235 |
// }
|
236 |
//
|
237 |
//
|
238 |
// private int Get_xTo(int Direction,
|
239 |
// final int x) {
|
240 |
//
|
241 |
// Direction %= 8;
|
242 |
//
|
243 |
// if (Direction < 0) {
|
244 |
// Direction += 8;
|
245 |
// }
|
246 |
//
|
247 |
// return (x + m_IX[Direction]);
|
248 |
//
|
249 |
// }
|
250 |
//
|
251 |
//
|
252 |
// private int Get_yTo(int Direction,
|
253 |
// final int x) {
|
254 |
//
|
255 |
// Direction %= 8;
|
256 |
//
|
257 |
// if (Direction < 0) {
|
258 |
// Direction += 8;
|
259 |
// }
|
260 |
//
|
261 |
// return (x + m_IY[Direction]);
|
262 |
//
|
263 |
// }
|
264 |
//
|
265 |
//
|
266 |
//}
|
267 |
|
268 |
package es.unex.sextante.vectorize.vectorize; |
269 |
|
270 |
import java.util.ArrayList; |
271 |
|
272 |
import com.vividsolutions.jts.geom.Coordinate; |
273 |
import com.vividsolutions.jts.geom.GeometryFactory; |
274 |
import com.vividsolutions.jts.geom.LinearRing; |
275 |
import com.vividsolutions.jts.geom.Polygon; |
276 |
|
277 |
import es.unex.sextante.core.GeoAlgorithm; |
278 |
import es.unex.sextante.core.Sextante; |
279 |
import es.unex.sextante.dataObjects.IRasterLayer; |
280 |
import es.unex.sextante.dataObjects.IVectorLayer; |
281 |
import es.unex.sextante.exceptions.GeoAlgorithmExecutionException; |
282 |
import es.unex.sextante.exceptions.RepeatedParameterNameException; |
283 |
import es.unex.sextante.outputs.OutputVectorLayer; |
284 |
|
285 |
public class VectorizeAlgorithm |
286 |
extends
|
287 |
GeoAlgorithm { |
288 |
|
289 |
public static final String LAYER = "LAYER"; |
290 |
public static final String RESULT = "RESULT"; |
291 |
|
292 |
private IRasterLayer m_Window;
|
293 |
private IVectorLayer m_Polygons;
|
294 |
private int m_iNX, m_iNY; |
295 |
private int[][] m_Lock; |
296 |
private char[][] m_Area; |
297 |
|
298 |
|
299 |
@Override
|
300 |
public void defineCharacteristics() { |
301 |
|
302 |
setName(Sextante.getText("Vectorize_raster_layer__polygons"));
|
303 |
setGroup(Sextante.getText("Vectorization"));
|
304 |
setUserCanDefineAnalysisExtent(false);
|
305 |
|
306 |
try {
|
307 |
m_Parameters.addInputRasterLayer(LAYER, Sextante.getText("Input_layer"), true); |
308 |
addOutputVectorLayer(RESULT, Sextante.getText("Result"), OutputVectorLayer.SHAPE_TYPE_POLYGON);
|
309 |
} |
310 |
catch (final RepeatedParameterNameException e) { |
311 |
Sextante.addErrorToLog(e); |
312 |
} |
313 |
|
314 |
} |
315 |
|
316 |
|
317 |
@Override
|
318 |
public boolean processAlgorithm() throws GeoAlgorithmExecutionException { |
319 |
|
320 |
final String sFields[] = new String[2]; |
321 |
final Class types[] = { Integer.class, Double.class }; |
322 |
|
323 |
m_Window = m_Parameters.getParameterValueAsRasterLayer(LAYER); |
324 |
|
325 |
m_Window.setFullExtent(); |
326 |
|
327 |
sFields[0] = "ID"; |
328 |
sFields[1] = m_Window.getName();
|
329 |
|
330 |
m_Polygons = getNewVectorLayer(RESULT, Sextante.getText("Resultado"), IVectorLayer.SHAPE_TYPE_POLYGON, types, sFields);
|
331 |
|
332 |
createPolygons(); |
333 |
|
334 |
return !m_Task.isCanceled();
|
335 |
|
336 |
} |
337 |
|
338 |
|
339 |
private void createPolygons() { |
340 |
|
341 |
int x, y, ID;
|
342 |
double dValue;
|
343 |
|
344 |
m_iNX = m_Window.getNX(); |
345 |
m_iNY = m_Window.getNY(); |
346 |
|
347 |
m_Lock = new int[m_iNY][m_iNX]; |
348 |
m_Area = new char[m_iNY + 1][m_iNX + 1]; |
349 |
|
350 |
for (y = 0, ID = 1; (y < m_iNY) && setProgress(y, m_iNY); y++) { |
351 |
for (x = 0; x < m_iNX; x++) { |
352 |
dValue = m_Window.getCellValueAsDouble(x, y); |
353 |
if (!m_Window.isNoDataValue(dValue) && (m_Lock[y][x] == 0)) { |
354 |
Discrete_Lock(x, y, ID); |
355 |
Discrete_Area(x, y, ID); |
356 |
ID++; |
357 |
} |
358 |
} |
359 |
} |
360 |
|
361 |
} |
362 |
|
363 |
|
364 |
private void Discrete_Lock(int x, |
365 |
int y,
|
366 |
final int ID) { |
367 |
|
368 |
final int xTo[] = { 0, 1, 0, -1 }, yTo[] = { 1, 0, -1, 0 }; |
369 |
|
370 |
final char goDir[] = { 1, 2, 4, 8 }; |
371 |
|
372 |
boolean isBorder, doRecurse;
|
373 |
|
374 |
char goTemp = 0; |
375 |
|
376 |
char[] goStack = new char[50]; |
377 |
int[] xStack = new int[50]; |
378 |
int[] yStack = new int[50]; |
379 |
|
380 |
int i, ix, iy, iStack = 0; |
381 |
|
382 |
double dValue, dValue2;
|
383 |
|
384 |
dValue = m_Window.getCellValueAsDouble(x, y); |
385 |
|
386 |
for (iy = 0; iy <= m_iNY; iy++) { |
387 |
for (ix = 0; ix <= m_iNX; ix++) { |
388 |
m_Area[iy][ix] = 0;
|
389 |
} |
390 |
} |
391 |
|
392 |
do {
|
393 |
if (m_Lock[y][x] == 0) { |
394 |
|
395 |
if (goStack.length <= iStack) {
|
396 |
final char[] cAux = new char[goStack.length + 50]; |
397 |
System.arraycopy(goStack, 0, cAux, 0, goStack.length); |
398 |
goStack = cAux; |
399 |
int[] iAux = new int[xStack.length + 50]; |
400 |
System.arraycopy(xStack, 0, iAux, 0, xStack.length); |
401 |
xStack = iAux; |
402 |
iAux = new int[yStack.length + 50]; |
403 |
System.arraycopy(yStack, 0, iAux, 0, yStack.length); |
404 |
yStack = iAux; |
405 |
} |
406 |
|
407 |
goStack[iStack] = 0;
|
408 |
m_Lock[y][x] = ID; |
409 |
|
410 |
for (i = 0; i < 4; i++) { |
411 |
ix = x + xTo[i]; |
412 |
iy = y + yTo[i]; |
413 |
|
414 |
isBorder = true;
|
415 |
|
416 |
dValue2 = m_Window.getCellValueAsDouble(ix, iy); |
417 |
if ((ix >= 0) && (ix < m_iNX) && (iy >= 0) && (iy < m_iNY) && (dValue == dValue2)) { |
418 |
isBorder = false;
|
419 |
if (m_Lock[iy][ix] == 0) { |
420 |
goStack[iStack] |= goDir[i]; |
421 |
} |
422 |
} |
423 |
|
424 |
if (isBorder) {
|
425 |
switch (i) {
|
426 |
case 0: |
427 |
m_Area[y + 1][x]++;
|
428 |
m_Area[y + 1][x + 1]++; |
429 |
break;
|
430 |
|
431 |
case 1: |
432 |
m_Area[y][x + 1]++;
|
433 |
m_Area[y + 1][x + 1]++; |
434 |
break;
|
435 |
|
436 |
case 2: |
437 |
m_Area[y][x]++; |
438 |
m_Area[y][x + 1]++;
|
439 |
break;
|
440 |
|
441 |
case 3: |
442 |
m_Area[y][x]++; |
443 |
m_Area[y + 1][x]++;
|
444 |
break;
|
445 |
} |
446 |
} |
447 |
} |
448 |
} |
449 |
|
450 |
doRecurse = false;
|
451 |
|
452 |
for (i = 0; i < 4; i++) { |
453 |
if ((goStack[iStack] & goDir[i]) != 0) { |
454 |
if (doRecurse) {
|
455 |
goTemp |= goDir[i]; |
456 |
} |
457 |
else {
|
458 |
goTemp = 0;
|
459 |
doRecurse = true;
|
460 |
xStack[iStack] = x; |
461 |
yStack[iStack] = y; |
462 |
x = x + xTo[i]; |
463 |
y = y + yTo[i]; |
464 |
} |
465 |
} |
466 |
} |
467 |
|
468 |
if (doRecurse) {
|
469 |
goStack[iStack++] = goTemp; |
470 |
} |
471 |
else if (iStack > 0) { |
472 |
iStack--; |
473 |
x = xStack[iStack]; |
474 |
y = yStack[iStack]; |
475 |
} |
476 |
} |
477 |
while (iStack > 0); |
478 |
|
479 |
} |
480 |
|
481 |
|
482 |
private void Discrete_Area(int x, |
483 |
int y,
|
484 |
final int ID) { |
485 |
|
486 |
final int xTo[] = { 0, 1, 0, -1 }, yTo[] = { 1, 0, -1, 0 }; |
487 |
|
488 |
final int xLock[] = { 0, 0, -1, -1 }, yLock[] = { 0, -1, -1, 0 }; |
489 |
|
490 |
boolean bContinue, bStart;
|
491 |
|
492 |
int i, ix, iy, ix1, iy1, dir, iStart;
|
493 |
|
494 |
final double xMin = m_Window.getWindowGridExtent().getXMin(), yMax = m_Window.getWindowGridExtent().getYMax(); |
495 |
final double dCellSize = m_Window.getWindowCellSize(); |
496 |
double xFirst = 0, yFirst = 0; |
497 |
|
498 |
final ArrayList coordinates = new ArrayList(); |
499 |
final Object values[] = new Object[2]; |
500 |
values[0] = new Integer(ID); |
501 |
values[1] = new Double(m_Window.getCellValueAsDouble(x, y)); |
502 |
|
503 |
xFirst = xMin + (x) * dCellSize; |
504 |
yFirst = yMax - (y) * dCellSize; |
505 |
coordinates.add(new Coordinate(xFirst, yFirst));
|
506 |
|
507 |
iStart = 0;
|
508 |
bStart = true;
|
509 |
|
510 |
do {
|
511 |
coordinates.add(new Coordinate(xMin + (x) * dCellSize, yMax - (y) * dCellSize));
|
512 |
|
513 |
m_Area[y][x] = 0;
|
514 |
bContinue = false;
|
515 |
|
516 |
while (true) { |
517 |
// assure clockwise direction at starting point
|
518 |
if (bStart) {
|
519 |
for (i = 0; i < 4; i++) { |
520 |
ix = x + xTo[i]; |
521 |
iy = y + yTo[i]; |
522 |
|
523 |
if ((ix >= 0) && (ix <= m_iNX) && (iy >= 0) && (iy <= m_iNY) && (m_Area[iy][ix] > 0)) { |
524 |
// check, if inside situated cell (according to current direction) is locked
|
525 |
ix1 = x + xLock[i]; |
526 |
iy1 = y + yLock[i]; |
527 |
|
528 |
if ((ix1 >= 0) && (ix1 <= m_iNX) && (iy1 >= 0) && (iy1 <= m_iNY) && (m_Lock[iy1][ix1] == ID)) { |
529 |
x = ix; |
530 |
y = iy; |
531 |
iStart = (i + 3) % 4; |
532 |
bContinue = true;
|
533 |
bStart = false;
|
534 |
break;
|
535 |
} |
536 |
} |
537 |
} |
538 |
} |
539 |
else {
|
540 |
for (i = iStart; i < iStart + 4; i++) { |
541 |
dir = i % 4;
|
542 |
ix = x + xTo[dir]; |
543 |
iy = y + yTo[dir]; |
544 |
|
545 |
if ((ix >= 0) && (ix <= m_iNX) && (iy >= 0) && (iy <= m_iNY) && (m_Area[iy][ix] > 0)) { |
546 |
if (i < iStart + 3) { |
547 |
// check, if inside situated cell (according to current direction) is locked
|
548 |
ix1 = x + xLock[dir]; |
549 |
iy1 = y + yLock[dir]; |
550 |
|
551 |
if ((ix1 >= 0) && (ix1 <= m_iNX) && (iy1 >= 0) && (iy1 <= m_iNY) && (m_Lock[iy1][ix1] == ID)) { |
552 |
x = ix; |
553 |
y = iy; |
554 |
iStart = (i + 3) % 4; |
555 |
bContinue = true;
|
556 |
break;
|
557 |
} |
558 |
} |
559 |
else {
|
560 |
x = ix; |
561 |
y = iy; |
562 |
bContinue = true;
|
563 |
iStart = (i + 3) % 4; |
564 |
break;
|
565 |
} |
566 |
} |
567 |
} |
568 |
} |
569 |
|
570 |
break;
|
571 |
}; |
572 |
} |
573 |
while (bContinue);
|
574 |
|
575 |
coordinates.add(new Coordinate(xFirst, yFirst));
|
576 |
|
577 |
final Coordinate[] coords = new Coordinate[coordinates.size()]; |
578 |
for (i = 0; i < coords.length; i++) { |
579 |
coords[i] = (Coordinate) coordinates.get(i); |
580 |
} |
581 |
|
582 |
final GeometryFactory gf = new GeometryFactory(); |
583 |
|
584 |
if (coords.length > 1) { |
585 |
final LinearRing ring = gf.createLinearRing(coords);
|
586 |
final Polygon polyg = gf.createPolygon(ring, null); |
587 |
m_Polygons.addFeature(polyg, values); |
588 |
} |
589 |
|
590 |
} |
591 |
|
592 |
} |