001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/io/shpapi/shape_new/ShapePolyline.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036 package org.deegree.io.shpapi.shape_new;
037
038 import java.util.Arrays;
039 import java.util.List;
040
041 import org.deegree.framework.log.ILogger;
042 import org.deegree.framework.log.LoggerFactory;
043 import org.deegree.model.crs.CoordinateSystem;
044 import org.deegree.model.spatialschema.ByteUtils;
045 import org.deegree.model.spatialschema.Curve;
046 import org.deegree.model.spatialschema.Geometry;
047 import org.deegree.model.spatialschema.GeometryException;
048 import org.deegree.model.spatialschema.GeometryFactory;
049 import org.deegree.model.spatialschema.LineString;
050 import org.deegree.model.spatialschema.Position;
051 import org.deegree.model.spatialschema.WKTAdapter;
052
053 /**
054 * <code>ShapePolyline</code> corresponds to the Polyline, PolylineM and PolylineZ shapes of the shapefile spec.
055 *
056 * @author <a href="mailto:schmitz@lat-lon.de">Andreas Schmitz</a>
057 * @author last edited by: $Author: mschneider $
058 *
059 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
060 */
061 public class ShapePolyline implements Shape {
062
063 private static final ILogger LOG = LoggerFactory.getLogger( ShapePolyline.class );
064
065 protected CoordinateSystem crs; // optional crs for geometry
066
067 protected boolean isM, isZ;
068
069 private ShapeEnvelope envelope;
070
071 protected ShapePoint[][] points;
072
073 /**
074 * Empty constructor. Should be used in concert with read().
075 */
076 public ShapePolyline() {
077 // all default
078 }
079
080 /**
081 * Creates a new Polyline/M/Z.
082 *
083 * @param z
084 * @param m
085 */
086 public ShapePolyline( boolean z, boolean m ) {
087 isM = m;
088 isZ = z;
089 }
090
091 /**
092 * Creates a new Polyline/M/Z.
093 *
094 * @param z
095 * @param m
096 * @param crs
097 * CoordinateSystem for shape
098 */
099 public ShapePolyline( boolean z, boolean m, CoordinateSystem crs ) {
100 isM = m;
101 isZ = z;
102 this.crs = crs;
103 }
104
105 /**
106 * Creates a new PolylineZ from deegree Curves.
107 *
108 * @param cs
109 */
110 public ShapePolyline( List<Curve> cs ) {
111 try {
112 points = new ShapePoint[cs.size()][];
113 int partNum = 0;
114 for ( Curve c : cs ) {
115
116 if ( envelope == null ) {
117 envelope = new ShapeEnvelope( c.getEnvelope() );
118 }
119 LineString ls = c.getAsLineString();
120
121 points[partNum] = new ShapePoint[ls.getNumberOfPoints()];
122
123 ShapePoint p;
124 for ( int i = 0; i < ls.getNumberOfPoints(); i++ ) {
125 p = new ShapePoint( ls.getPositionAt( i ) );
126 points[partNum][i] = p;
127 envelope.fit( p.x, p.y, p.z );
128 }
129 ++partNum;
130
131 // uses only the last one, but whatever will happen if they're not consistent anyway...
132 if ( c.getDimension() == 3 ) {
133 isZ = true;
134 }
135 }
136 } catch ( GeometryException e ) {
137 LOG.logError( "Something was wrong with a Curve object. " + "This will probably lead to followup errors, "
138 + "better check your input data. Stack Trace:", e );
139 }
140 }
141
142 /**
143 * Creates a new PolylineZ from deegree Curve.
144 *
145 * @param c
146 */
147 public ShapePolyline( Curve c ) {
148 this( Arrays.asList( new Curve[] { c } ) );
149 }
150
151 private int numPoints() {
152 int num = 0;
153
154 for ( ShapePoint[] ps : points ) {
155 num += ps.length;
156 }
157
158 return num;
159 }
160
161 /*
162 * (non-Javadoc)
163 *
164 * @see org.deegree.io.shpapi.Shape#getByteLength()
165 */
166 public int getByteLength() {
167 int numPoints = numPoints();
168
169 int len = 44 + 4 * points.length + 16 * numPoints;
170
171 if ( isM ) {
172 len += 8 * numPoints + 16;
173 }
174
175 if ( isZ ) {
176 len += 16 * numPoints + 32;
177 }
178
179 return len;
180 }
181
182 protected int readPolyline( byte[] bytes, int offset ) {
183 int off = offset;
184 envelope = new ShapeEnvelope( false, false );
185 off = envelope.read( bytes, off );
186
187 int numParts = ByteUtils.readLEInt( bytes, off );
188 off += 4;
189
190 int numPoints = ByteUtils.readLEInt( bytes, off );
191 off += 4;
192
193 points = new ShapePoint[numParts][];
194 int[] partStart = new int[numParts];
195
196 for ( int i = 0; i < numParts; ++i ) {
197 partStart[i] = ByteUtils.readLEInt( bytes, off );
198 off += 4;
199 }
200
201 for ( int i = 0; i < numParts; ++i ) {
202
203 // calculate number of points for current part
204 int len;
205 if ( i == numParts - 1 ) {
206 len = numPoints - partStart[i];
207 } else {
208 len = partStart[i + 1] - partStart[i];
209 }
210
211 points[i] = new ShapePoint[len];
212 for ( int j = 0; j < len; ++j ) {
213 points[i][j] = new ShapePoint( bytes, off );
214 off += 16;
215 }
216 }
217
218 return off;
219 }
220
221 protected int readPolylineZ( byte[] bytes, int offset ) {
222 isZ = true;
223
224 int off = readPolyline( bytes, offset );
225
226 int numPoints = numPoints();
227
228 double zmin, zmax, mmin, mmax;
229 zmin = ByteUtils.readLEDouble( bytes, off );
230 off += 8;
231 zmax = ByteUtils.readLEDouble( bytes, off );
232 off += 8;
233
234 double[] zVals = new double[numPoints];
235 for ( int i = 0; i < numPoints; ++i ) {
236 zVals[i] = ByteUtils.readLEDouble( bytes, off );
237 off += 8;
238 }
239
240 mmin = ByteUtils.readLEDouble( bytes, off );
241 off += 8;
242 mmax = ByteUtils.readLEDouble( bytes, off );
243 off += 8;
244
245 double[] mVals = new double[numPoints];
246 for ( int i = 0; i < numPoints; ++i ) {
247 mVals[i] = ByteUtils.readLEDouble( bytes, off );
248 off += 8;
249 }
250
251 int i = 0;
252 for ( ShapePoint[] ps : points ) {
253 for ( ShapePoint p : ps ) {
254 p.extend( zVals[i], mVals[i] );
255 ++i;
256 }
257 }
258
259 envelope.extend( zmin, zmax, mmin, mmax );
260
261 return off;
262 }
263
264 protected int readPolylineM( byte[] bytes, int offset ) {
265 isM = true;
266
267 int off = readPolyline( bytes, offset );
268
269 int numPoints = numPoints();
270
271 double mmin, mmax;
272 mmin = ByteUtils.readLEDouble( bytes, off );
273 off += 8;
274 mmax = ByteUtils.readLEDouble( bytes, off );
275 off += 8;
276
277 envelope.extend( mmin, mmax );
278
279 double[] mVals = new double[numPoints];
280 for ( int i = 0; i < numPoints; ++i ) {
281 mVals[i] = ByteUtils.readLEDouble( bytes, off );
282 off += 8;
283 }
284
285 int i = 0;
286 for ( ShapePoint[] ps : points ) {
287 for ( ShapePoint p : ps ) {
288 p.extend( mVals[i] );
289 ++i;
290 }
291 }
292
293 return off;
294 }
295
296 /*
297 * (non-Javadoc)
298 *
299 * @see org.deegree.io.shpapi.Shape#read(byte[], int)
300 */
301 public int read( byte[] bytes, int offset ) {
302 int off = offset;
303
304 int type = ByteUtils.readLEInt( bytes, off );
305 off += 4;
306
307 if ( type == ShapeFile.NULL ) {
308 return off;
309 }
310
311 if ( type == ShapeFile.POLYLINE ) {
312 isZ = false;
313 isM = false;
314 return readPolyline( bytes, off );
315 }
316
317 if ( type == ShapeFile.POLYLINEZ ) {
318 isZ = true;
319 isM = false;
320 return readPolylineZ( bytes, off );
321 }
322
323 if ( type == ShapeFile.POLYLINEM ) {
324 isZ = false;
325 isM = true;
326 return readPolylineM( bytes, off );
327 }
328
329 return -1;
330 }
331
332 protected int writePolyline( byte[] bytes, int offset ) {
333 int off = envelope.write( bytes, offset );
334
335 ByteUtils.writeLEInt( bytes, off, points.length );
336 off += 4;
337
338 int numPoints = numPoints();
339 ByteUtils.writeLEInt( bytes, off, numPoints );
340 off += 4;
341
342 int pos = 0;
343 for ( ShapePoint[] ps : points ) {
344 ByteUtils.writeLEInt( bytes, off, pos );
345 off += 4;
346 pos += ps.length;
347 }
348
349 for ( ShapePoint[] ps : points ) {
350 for ( ShapePoint p : ps ) {
351 ByteUtils.writeLEDouble( bytes, off, p.x );
352 off += 8;
353 ByteUtils.writeLEDouble( bytes, off, p.y );
354 off += 8;
355 }
356 }
357
358 return off;
359 }
360
361 protected int writePolylineZ( byte[] bytes, int offset ) {
362 int off = writePolyline( bytes, offset );
363
364 ByteUtils.writeLEDouble( bytes, off, envelope.zmin );
365 off += 8;
366 ByteUtils.writeLEDouble( bytes, off, envelope.zmax );
367 off += 8;
368
369 for ( ShapePoint[] ps : points ) {
370 for ( ShapePoint p : ps ) {
371 ByteUtils.writeLEDouble( bytes, off, p.z );
372 off += 8;
373 }
374 }
375
376 ByteUtils.writeLEDouble( bytes, off, envelope.mmin );
377 off += 8;
378 ByteUtils.writeLEDouble( bytes, off, envelope.mmax );
379 off += 8;
380
381 for ( ShapePoint[] ps : points ) {
382 for ( ShapePoint p : ps ) {
383 ByteUtils.writeLEDouble( bytes, off, p.m );
384 off += 8;
385 }
386 }
387
388 return off;
389 }
390
391 protected int writePolylineM( byte[] bytes, int offset ) {
392 int off = writePolyline( bytes, offset );
393
394 ByteUtils.writeLEDouble( bytes, off, envelope.mmin );
395 off += 8;
396 ByteUtils.writeLEDouble( bytes, off, envelope.mmax );
397 off += 8;
398
399 for ( ShapePoint[] ps : points ) {
400 for ( ShapePoint p : ps ) {
401 ByteUtils.writeLEDouble( bytes, off, p.m );
402 off += 8;
403 }
404 }
405
406 return off;
407 }
408
409 /*
410 * (non-Javadoc)
411 *
412 * @see org.deegree.io.shpapi.Shape#write(byte[], int)
413 */
414 public int write( byte[] bytes, int offset ) {
415 if ( isZ ) {
416 ByteUtils.writeLEInt( bytes, offset, ShapeFile.POLYLINEZ );
417 return writePolylineZ( bytes, offset + 4 );
418 }
419 if ( isM ) {
420 ByteUtils.writeLEInt( bytes, offset, ShapeFile.POLYLINEM );
421 return writePolylineM( bytes, offset + 4 );
422 }
423 ByteUtils.writeLEInt( bytes, offset, ShapeFile.POLYLINE );
424 return writePolyline( bytes, offset + 4 );
425 }
426
427 /*
428 * (non-Javadoc)
429 *
430 * @see org.deegree.io.shpapi.shape_new.Shape#getType()
431 */
432 public int getType() {
433 if ( isZ ) {
434 return ShapeFile.POLYLINEZ;
435 }
436 if ( isM ) {
437 return ShapeFile.POLYLINEM;
438 }
439 return ShapeFile.POLYLINE;
440 }
441
442 /*
443 * (non-Javadoc)
444 *
445 * @see org.deegree.io.shpapi.shape_new.Shape#getEnvelope()
446 */
447 public ShapeEnvelope getEnvelope() {
448 return envelope;
449 }
450
451 /**
452 * This creates a MultiCurve object.
453 *
454 * @see org.deegree.io.shpapi.shape_new.Shape#getGeometry()
455 */
456 public Geometry getGeometry()
457 throws ShapeGeometryException {
458 if ( points == null ) {
459 return null;
460 }
461 try {
462 Curve[] cs = new Curve[points.length];
463
464 for ( int i = 0; i < points.length; ++i ) {
465 Position[] ps = new Position[points[i].length];
466 for ( int k = 0; k < points[i].length; ++k ) {
467 if ( isZ ) {
468 ps[k] = GeometryFactory.createPosition( points[i][k].x, points[i][k].y, points[i][k].z );
469 } else {
470 ps[k] = GeometryFactory.createPosition( points[i][k].x, points[i][k].y );
471 }
472 }
473 cs[i] = GeometryFactory.createCurve( ps, crs );
474 }
475
476 return GeometryFactory.createMultiCurve( cs, crs );
477 } catch ( GeometryException e ) {
478 throw new ShapeGeometryException( "MultiCurve could not be constructed" + " from ShapePolyline.", e );
479 }
480 }
481
482 @Override
483 public String toString() {
484 try {
485 return WKTAdapter.export( getGeometry() ).toString();
486 } catch ( GeometryException e ) {
487 return "(unknown)";
488 }
489 }
490
491 }