001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/model/spatialschema/MultiCurveImpl.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.model.spatialschema;
037
038 import java.io.Serializable;
039
040 import org.deegree.framework.log.ILogger;
041 import org.deegree.framework.log.LoggerFactory;
042 import org.deegree.model.crs.CoordinateSystem;
043
044 /**
045 * default implementation of the MultiCurve interface from package deegree.model.spatialschema.
046 *
047 * ------------------------------------------------------------
048 *
049 * @version 12.6.2001
050 * @author Andreas Poth
051 */
052 public class MultiCurveImpl extends MultiPrimitiveImpl implements MultiCurve, Serializable {
053 /** Use serialVersionUID for interoperability. */
054 private final static long serialVersionUID = 2730942874409216686L;
055
056 private static final ILogger LOG = LoggerFactory.getLogger( MultiCurveImpl.class );
057
058 /**
059 * Creates a new MultiCurveImpl object.
060 *
061 * @param crs
062 */
063 protected MultiCurveImpl( CoordinateSystem crs ) {
064 super( crs );
065 }
066
067 /**
068 * Creates a new MultiCurveImpl object.
069 *
070 * @param curve
071 */
072 protected MultiCurveImpl( Curve[] curve ) {
073 super( curve[0].getCoordinateSystem() );
074
075 for ( int i = 0; i < curve.length; i++ ) {
076 aggregate.add( curve[i] );
077 }
078
079 }
080
081 /**
082 * Creates a new MultiCurveImpl object.
083 *
084 * @param curve
085 * @param crs
086 */
087 protected MultiCurveImpl( Curve[] curve, CoordinateSystem crs ) {
088 super( crs );
089
090 for ( int i = 0; i < curve.length; i++ ) {
091 aggregate.add( curve[i] );
092 }
093
094 }
095
096 /**
097 * adds a Curve to the aggregation
098 */
099 public void addCurve( Curve curve ) {
100 super.add( curve );
101 }
102
103 /**
104 * inserts a Curve in the aggregation. all elements with an index equal or larger index will be moved. if index is
105 * larger then getSize() - 1 or smaller then 0 or curve equals null an exception will be thrown.
106 *
107 * @param curve
108 * Curve to insert.
109 * @param index
110 * position where to insert the new Curve
111 */
112 public void insertCurveAt( Curve curve, int index )
113 throws GeometryException {
114 super.insertObjectAt( curve, index );
115 }
116
117 /**
118 * sets the submitted Curve at the submitted index. the element at the position <code>index</code> will be
119 * removed. if index is larger then getSize() - 1 or smaller then 0 or curve equals null an exception will be
120 * thrown.
121 *
122 * @param curve
123 * Curve to set.
124 * @param index
125 * position where to set the new Curve
126 */
127 public void setCurveAt( Curve curve, int index )
128 throws GeometryException {
129 setObjectAt( curve, index );
130 }
131
132 /**
133 * removes the submitted Curve from the aggregation
134 *
135 * @return the removed Curve
136 */
137 public Curve removeCurve( Curve curve ) {
138 return (Curve) super.removeObject( curve );
139 }
140
141 /**
142 * removes the Curve at the submitted index from the aggregation. if index is larger then getSize() - 1 or smaller
143 * then 0 an exception will be thrown.
144 *
145 * @return the removed Curve
146 */
147 public Curve removeCurveAt( int index )
148 throws GeometryException {
149 return (Curve) super.removeObjectAt( index );
150 }
151
152 /**
153 * removes all Curve from the aggregation.
154 */
155 @Override
156 public void removeAll() {
157 super.removeAll();
158 }
159
160 /**
161 * returns the Curve at the submitted index.
162 */
163 public Curve getCurveAt( int index ) {
164 return (Curve) super.getPrimitiveAt( index );
165 }
166
167 /**
168 * returns all Curves as array
169 */
170 public Curve[] getAllCurves() {
171 return aggregate.toArray( new Curve[getSize()] );
172 }
173
174 /**
175 * returns true if the submitted Curve is within the aggregation
176 *
177 * @param curve
178 * @return true if the submitted Curve is within the aggregation
179 */
180 public boolean isMember( Curve curve ) {
181 return super.isMember( curve );
182 }
183
184 /**
185 * returns the boundary of the MultiCurve
186 * <p>
187 * not implemented yet
188 *
189 * @return <code>null</code>
190 */
191 @Override
192 public Boundary getBoundary() {
193 return null;
194 }
195
196 /**
197 * calculates the bounding box / envelope of the aggregation
198 */
199 protected void calculateEnvelope() {
200 Envelope bb = getCurveAt( 0 ).getEnvelope();
201
202 double[] min = bb.getMin().getAsArray().clone();
203 double[] max = bb.getMax().getAsArray().clone();
204
205 for ( int i = 1; i < getSize(); i++ ) {
206 double[] pos1 = getCurveAt( i ).getEnvelope().getMin().getAsArray();
207 double[] pos2 = getCurveAt( i ).getEnvelope().getMax().getAsArray();
208
209 for ( int j = 0; j < pos1.length; j++ ) {
210 if ( pos1[j] < min[j] ) {
211 min[j] = pos1[j];
212 } else if ( pos1[j] > max[j] ) {
213 max[j] = pos1[j];
214 }
215
216 if ( pos2[j] < min[j] ) {
217 min[j] = pos2[j];
218 } else if ( pos2[j] > max[j] ) {
219 max[j] = pos2[j];
220 }
221 }
222 }
223
224 envelope = new EnvelopeImpl( new PositionImpl( min ), new PositionImpl( max ), this.crs );
225 }
226
227 /**
228 * calculates the centroid of the aggregation
229 */
230 protected void calculateCentroid() {
231 try {
232 double cnt = 0;
233 Point gmp = getCurveAt( 0 ).getCentroid();
234
235 double[] cen = new double[gmp.getAsArray().length];
236
237 for ( int i = 0; i < getSize(); i++ ) {
238 cnt += getCurveAt( i ).getNumberOfCurveSegments();
239
240 double[] pos = getCurveAt( i ).getCentroid().getAsArray();
241
242 for ( int j = 0; j < getCoordinateDimension(); j++ ) {
243 cen[j] += pos[j];
244 }
245 }
246
247 for ( int j = 0; j < getCoordinateDimension(); j++ ) {
248 cen[j] = cen[j] / cnt / getSize();
249 }
250
251 centroid = new PointImpl( new PositionImpl( cen ), null );
252 } catch ( Exception ex ) {
253 LOG.logError( "", ex );
254 }
255 }
256
257 /**
258 * calculates the centroid and envelope of the aggregation
259 */
260 @Override
261 protected void calculateParam() {
262 calculateCentroid();
263 calculateEnvelope();
264 setValid( true );
265 }
266
267 @Override
268 public int getDimension() {
269 return 1;
270 }
271
272 @Override
273 public int getCoordinateDimension() {
274 return getCurveAt( 0 ).getCoordinateDimension();
275 }
276
277 @Override
278 public Object clone() {
279 MultiCurve mc = null;
280
281 try {
282 mc = new MultiCurveImpl( getCoordinateSystem() );
283
284 for ( int i = 0; i < this.getSize(); i++ ) {
285 CurveImpl ci = (CurveImpl) getCurveAt( i );
286 mc.addCurve( (Curve) ci.clone() );
287 }
288 } catch ( Exception ex ) {
289 LOG.logError( "MultiCurve_Impl.clone: ", ex );
290 }
291
292 return mc;
293 }
294 }