001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcwebservices/wpvs/j3d/ViewPoint.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.ogcwebservices.wpvs.j3d;
037    
038    import javax.media.j3d.Transform3D;
039    import javax.vecmath.Point3d;
040    import javax.vecmath.Vector3d;
041    
042    import org.deegree.framework.log.ILogger;
043    import org.deegree.framework.log.LoggerFactory;
044    import org.deegree.model.crs.CoordinateSystem;
045    import org.deegree.model.spatialschema.Envelope;
046    import org.deegree.model.spatialschema.GeometryException;
047    import org.deegree.model.spatialschema.GeometryFactory;
048    import org.deegree.model.spatialschema.Position;
049    import org.deegree.model.spatialschema.Surface;
050    import org.deegree.model.spatialschema.WKTAdapter;
051    import org.deegree.ogcwebservices.wpvs.operation.GetView;
052    
053    /**
054     * This class represents the view point for a WPVS request. That is, it represents the point where the observer is at,
055     * and looking to a target point. An angle of view must be also given.
056     *
057     * @author <a href="mailto:bezema@lat-lon.de">Rutger Bezema</a>
058     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
059     *
060     * @author last edited by: $Author: mschneider $
061     * @version $Revision: 18195 $ $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
062     */
063    public class ViewPoint {
064    
065        private static final ILogger LOG = LoggerFactory.getLogger( ViewPoint.class );
066    
067        private static final double rad90 = Math.toRadians( 90 );
068    
069        private static final double rad180 = Math.toRadians( 180 );
070    
071        private static final double rad270 = Math.toRadians( 270 );
072    
073        private static final double rad360 = Math.toRadians( 360 );
074    
075        private CoordinateSystem crs;
076    
077        private Point3d observerPosition;
078    
079        private Point3d pointOfInterest;
080    
081        private Point3d[] footprint;
082    
083        private Point3d[] fakeFootprint;
084    
085        private Point3d[] oldFootprint;
086    
087        private double angleOfView = 0;
088    
089        private double yaw = 0;
090    
091        private double pitch = 0;
092    
093        private double terrainDistanceToSeaLevel = 0;
094    
095        private double viewerToPOIDistance = 0;
096    
097        private double farClippingPlane = 0;
098    
099        private Transform3D simpleTransform = null;
100    
101        private Transform3D viewMatrix = null;
102    
103        /**
104         * @return the oldFootprint.
105         */
106        public Point3d[] getOldFootprint() {
107            return oldFootprint;
108        }
109    
110        /**
111         * @return the fakeFootprint.
112         */
113        public Point3d[] getFakeFootprint() {
114            return fakeFootprint;
115        }
116    
117        /**
118         * Creates a new instance of ViewPoint_Impl
119         *
120         * @param yaw
121         *            rotation on the Z-Axis in radians of the viewer
122         * @param pitch
123         *            rotation on the X-Axis in radians
124         * @param viewerToPOIDistance
125         *            from the point of interest to the viewersposition
126         * @param pointOfInterest
127         *            the point of interest
128         * @param angleOfView
129         * @param farClippingPlane
130         *            where the view ends
131         * @param distanceToSealevel
132         * @param crs
133         *            The Coordinatesystem in which the given reside
134         */
135        public ViewPoint( double yaw, double pitch, double viewerToPOIDistance, Point3d pointOfInterest,
136                          double angleOfView, double farClippingPlane, double distanceToSealevel, CoordinateSystem crs ) {
137            this.yaw = yaw;
138            this.pitch = pitch;
139    
140            this.angleOfView = angleOfView;
141            this.pointOfInterest = pointOfInterest;
142    
143            this.viewerToPOIDistance = viewerToPOIDistance;
144    
145            this.farClippingPlane = farClippingPlane;
146    
147            this.terrainDistanceToSeaLevel = distanceToSealevel;
148    
149            this.crs = crs;
150    
151            simpleTransform = new Transform3D();
152    
153            viewMatrix = new Transform3D();
154            observerPosition = new Point3d();
155    
156            footprint = new Point3d[4];
157            fakeFootprint = new Point3d[4];
158            oldFootprint = new Point3d[4];
159            calcObserverPosition();
160    
161        }
162    
163        /**
164         * @param request
165         *            a server request.
166         */
167        public ViewPoint( GetView request ) {
168            this( request.getYaw(), request.getPitch(), request.getDistance(), request.getPointOfInterest(),
169                  request.getAngleOfView(), request.getFarClippingPlane(), 0, request.getCrs() );
170        }
171    
172        /**
173         * @param request
174         *            a server request.
175         * @param distanceToSeaLevel
176         */
177        public ViewPoint( GetView request, double distanceToSeaLevel ) {
178            this( request.getYaw(), request.getPitch(), request.getDistance(), request.getPointOfInterest(),
179                  request.getAngleOfView(), request.getFarClippingPlane(), distanceToSeaLevel, request.getCrs() );
180        }
181    
182        /**
183         * Calculates the observers position for a given pointOfInterest, distance and view direction( as semi polar
184         * coordinates, yaw & pitch ). also recalculating the viewmatrix and the footprint, for they are affected by the
185         * change of position.
186         *
187         */
188        private void calcObserverPosition() {
189    
190            double z = Math.sin( pitch ) * this.viewerToPOIDistance;
191    
192            double groundLength = Math.sqrt( ( viewerToPOIDistance * viewerToPOIDistance ) - ( z * z ) );
193            double x = 0;
194            double y = 0;
195            // -1-> if yaw is null, we're looking to the north
196            if ( yaw >= 0 && yaw < rad90 ) {
197                x = -1 * ( Math.sin( yaw ) * groundLength );
198                y = -1 * ( Math.cos( yaw ) * groundLength );
199            } else if ( yaw >= rad90 && yaw < rad180 ) {
200                double littleYaw = yaw - rad90;
201                y = Math.sin( littleYaw ) * groundLength;
202                x = -1 * ( Math.cos( littleYaw ) * groundLength );
203            } else if ( yaw >= rad180 && yaw < rad270 ) {
204                double littleYaw = yaw - rad180;
205                x = Math.sin( littleYaw ) * groundLength;
206                y = Math.cos( littleYaw ) * groundLength;
207            } else if ( yaw >= rad270 && yaw < rad360 ) {
208                double littleYaw = yaw - rad270;
209                y = -1 * ( Math.sin( littleYaw ) * groundLength );
210                x = Math.cos( littleYaw ) * groundLength;
211            }
212    
213            observerPosition.x = pointOfInterest.x + x;
214            observerPosition.y = pointOfInterest.y + y;
215            observerPosition.z = pointOfInterest.z + z;
216    
217            calculateViewMatrix();
218            calcFootprint();
219        }
220    
221        /**
222         * Calculates the field of view aka footprint, the corner points of the intersection of the field of view with the
223         * terrain as follows, <br/>
224         * <ul>
225         * <li> f[0] = farclippingplane right side fo viewDirection </li>
226         * <li> f[1] = farclippingplane left side fo viewDirection </li>
227         * <li> f[2] = nearclippingplane right side fo viewDirection, note it can be behind the viewPosition </li>
228         * <li> f[3] = nearclippingplane left side fo viewDirection, note it can be behind the viewPosition </li>
229         * </ul>
230         * <br/> the are rotated and translated according to the simpleTranform
231         *
232         */
233        private void calcFootprint() {
234    
235            // make the aov a little bigger, therefor the footprint is larger and no visual errors can
236            // be seen at the sides of the view (at the expense of a little larger/more requests)
237            double halfAngleOfView = ( angleOfView + ( Math.toRadians( 6 ) ) ) * 0.5;
238            if ( halfAngleOfView >= ( rad90 * 0.5 ) ) {
239                halfAngleOfView = rad90 * 0.5;
240            }
241            if ( Math.abs( ( halfAngleOfView + rad90 ) % rad180 ) < 0.000001 ) {
242                LOG.logError( "The angle of view can't be a multiple of rad180" );
243                return;
244            }
245    
246            double heightAboveGround = observerPosition.z - ( pointOfInterest.z - terrainDistanceToSeaLevel );
247            if ( heightAboveGround < 0 ) { // beneath the ground
248                LOG.logError( "the Observer is below the terrain" );
249                return;
250            }
251    
252            if ( pitch >= 0 ) { // the eye is looking down on the poi
253    
254                // caluclate the viewFrustums farClippinplane points
255                double otherCornerOffset = farClippingPlane * Math.sin( halfAngleOfView );
256                double yCornerOffset = farClippingPlane * Math.cos( halfAngleOfView );
257    
258                // farclippin plane top right
259                Point3d topRight = new Point3d( otherCornerOffset, otherCornerOffset, -yCornerOffset );
260                viewMatrix.transform( topRight );
261                footprint[0] = findIntersectionWithTerrain( new Vector3d( topRight ) );
262    
263                // farclippin plane top left
264                Point3d topLeft = new Point3d( -otherCornerOffset, otherCornerOffset, -yCornerOffset );
265                viewMatrix.transform( topLeft );
266                footprint[1] = findIntersectionWithTerrain( new Vector3d( topLeft ) );
267    
268                // farclippin plane bottom right
269                Point3d bottomRight = new Point3d( otherCornerOffset, -otherCornerOffset, -yCornerOffset );
270                viewMatrix.transform( bottomRight );
271                footprint[2] = findIntersectionWithTerrain( new Vector3d( bottomRight ) );
272    
273                // farclippin plane bottom left
274                Point3d bottomLeft = new Point3d( -otherCornerOffset, -otherCornerOffset, -yCornerOffset );
275                viewMatrix.transform( bottomLeft );
276                footprint[3] = findIntersectionWithTerrain( new Vector3d( bottomLeft ) );
277    
278            } else {
279                // TODO looking up to the poi
280            }
281            simpleTransform.rotZ( rad360 - yaw );
282            // translate to the viewersposition.
283            simpleTransform.setTranslation( new Vector3d( observerPosition.x, observerPosition.y,
284                                                          ( pointOfInterest.z - terrainDistanceToSeaLevel ) ) );
285        }
286    
287        /**
288         * For all points (x,y,z) on a plane (the terrain), the following equation defines the plane: <code>
289         * --> ax + by + cz + d = 0
290         * - (a, b, c) the normal vector of the plane, here it is (0, 0, 1)
291         * - d the offset of the plane (terrainDistanceToSeaLevel)
292         * </code>
293         * a ray can be parametrized as follows: <code>
294         * R(s) = eye + s * normalized_Direction
295         * -s is a scaling vector,
296         * </code>
297         * The intersection of each ray going from the eye through the farclippinplane's cornerpoints with the terrain can
298         * be calculated as follows: <code>
299         * s= (a*eye_x + b*eye_y + c*eye_z + d ) / -1* (a*norm_dir + b*norm_dir + c*norm_dir)
300         * </code>
301         * if the denominator == 0, we are parrallel (or strifing) the plane in either case no real intersection. if s < 0
302         * or s > 1 the intersection is outside the ray_length. Applying the found s to the ray's equation results in the
303         * intersectionpoint.
304         *
305         * @param farClippingplaneCorner
306         *            one the corners of the farclippingplane of the viewfrustum
307         * @return the intersection point with the given ray (observerposition and a farclippingplane cornerpoint) with the
308         *         terrain)
309         */
310        private Point3d findIntersectionWithTerrain( final Vector3d farClippingplaneCorner ) {
311            final Vector3d rayDir = new Vector3d( farClippingplaneCorner );
312            rayDir.sub( observerPosition );
313            final double planeDir = -terrainDistanceToSeaLevel;
314            final double numerator = -( observerPosition.z + planeDir );
315    
316            if ( Math.abs( rayDir.z ) < 0.0001f ) {
317                // Ray is paralell to plane
318                return new Point3d( farClippingplaneCorner.x, farClippingplaneCorner.y, terrainDistanceToSeaLevel );
319            }
320            // Find distance to intersection
321            final double s = numerator / rayDir.z;
322    
323            // If the value of s is out of [0; 1], the intersection liese before or after the line
324            if ( s < 0.0f ) {
325                return new Point3d( farClippingplaneCorner.x, farClippingplaneCorner.y, terrainDistanceToSeaLevel );
326            }
327            if ( s > 1.0f ) {
328                return new Point3d( farClippingplaneCorner.x, farClippingplaneCorner.y, terrainDistanceToSeaLevel );
329            }
330            // Finally a real intersection
331            return new Point3d( observerPosition.x + ( s * rayDir.x ), observerPosition.y + ( s * rayDir.y ),
332                                terrainDistanceToSeaLevel );
333    
334        }
335    
336        /**
337         * Sets the viewMatrix according to the given yaw, pitch and the calculated observerPosition.
338         */
339        private void calculateViewMatrix() {
340            viewMatrix.setIdentity();
341            viewMatrix.lookAt( observerPosition, pointOfInterest, new Vector3d( 0, 0, 1 ) );
342            viewMatrix.invert();
343    
344        }
345    
346        /**
347         * @return true if the near clippingplane is behind the viewposition.
348         */
349        public boolean isNearClippingplaneBehindViewPoint() {
350            if ( pitch > 0 ) { // the eye is looking down on the poi
351                // pitch equals angle between upper and viewaxis, angleOfView is centered around the
352                // viewaxis
353                double angleToZ = pitch + ( angleOfView * 0.5 );
354                if ( Math.abs( angleToZ - rad90 ) > 0.00001 ) {
355                    // footprint front border distance
356                    if ( angleToZ > rad90 ) {
357                        return true;
358                    }
359                }
360            } else {
361                // TODO looking up to the poi
362            }
363    
364            return false;
365        }
366    
367        /**
368         *
369         * @return the field of view of the observer in radians
370         */
371        public double getAngleOfView() {
372            return angleOfView;
373        }
374    
375        /**
376         * @param aov
377         *            the field of view of the observer in radians
378         */
379        public void setAngleOfView( double aov ) {
380            this.angleOfView = aov;
381            calcFootprint();
382        }
383    
384        /**
385         *
386         * @return the horizontal direction in radians the observer looks
387         */
388        public double getYaw() {
389            return yaw;
390        }
391    
392        /**
393         *
394         * @param yaw
395         *            the horizontal direction in radians the observer looks
396         */
397        public void setYaw( double yaw ) {
398            this.yaw = yaw;
399            calcObserverPosition();
400        }
401    
402        /**
403         * @return vertical direction in radians the observer looks
404         */
405        public double getPitch() {
406            return pitch;
407        }
408    
409        /**
410         * @param pitch
411         *            the vertical direction in radians the observer looks
412         *
413         */
414        public void setPitch( double pitch ) {
415            this.pitch = ( pitch % rad90 );
416            calcObserverPosition();
417        }
418    
419        /**
420         * @return Returns the distanceToSeaLevel of the terrain beneath the viewpoint.
421         */
422        public double getTerrainDistanceToSeaLevel() {
423            return terrainDistanceToSeaLevel;
424        }
425    
426        /**
427         * @param distanceToSeaLevel
428         *            of the terrain beneath the viewpoint
429         */
430        public void setTerrainDistanceToSeaLevel( double distanceToSeaLevel ) {
431            this.terrainDistanceToSeaLevel = distanceToSeaLevel;
432            calcFootprint();
433        }
434    
435        /**
436         * @return the position of the observer, the directions he looks and his field of view in radians
437         *
438         */
439        public Point3d getObserverPosition() {
440            return observerPosition;
441        }
442    
443        /**
444         * @param observerPosition
445         *            the position of the observer, the directions he looks and his field of view in radians
446         *
447         */
448        public void setObserverPosition( Point3d observerPosition ) {
449            this.observerPosition = observerPosition;
450            calcFootprint();
451            calculateViewMatrix();
452        }
453    
454        /**
455         * @return the point of interest to which the viewer is looking
456         */
457        public Point3d getPointOfInterest() {
458            return pointOfInterest;
459        }
460    
461        /**
462         * @param pointOfInterest
463         *            the directions the observer looks and his field of view in radians
464         *
465         */
466        public void setPointOfInterest( Point3d pointOfInterest ) {
467            this.pointOfInterest = pointOfInterest;
468            calcObserverPosition();
469        }
470    
471        /**
472         * The footprint in object space: <br/>f[0] = (FarclippingPlaneRight) = angleOfView/2 + viewDirection.x,
473         * farclippingplaneDistance, distanceToSealevel <br/>f[1] = (FarclippingPlaneLeft) = angleOfView/2 -
474         * viewDirection.x, farclippingplaneDistance, distanceToSealevel <br/>f[2] = (NearclippingPlaneRight) =
475         * angleOfView/2 + viewDirection.x, nearclippingplaneDistance, distanceToSealevel <br/>f[3] =
476         * (NearclippingPlaneLeft) = angleOfView/2 - viewDirection.x, nearclippingplaneDistance, distanceToSealevel
477         *
478         * @return footprint or rather the field of view
479         */
480        public Point3d[] getFootprint() {
481            return footprint;
482        }
483    
484        /**
485         * @param distanceToSeaLevel
486         *            the new height for which the footprint should be calculated
487         * @return footprint or rather the field of view
488         */
489        public Point3d[] getFootprint( double distanceToSeaLevel ) {
490            this.terrainDistanceToSeaLevel = distanceToSeaLevel;
491            calcFootprint();
492            return footprint;
493        }
494    
495        @Override
496        public String toString() {
497            StringBuffer sb = new StringBuffer();
498            sb.append( "observerPosition: " + observerPosition + "\n" );
499            sb.append( "targetPoint: " + pointOfInterest + "\n" );
500            sb.append( "distance: " + this.viewerToPOIDistance + "\n" );
501            sb.append( "footprint: " );
502            sb.append( footprint[0] + ", " );
503            sb.append( footprint[1] + ", " );
504            sb.append( footprint[2] + ", " );
505            sb.append( footprint[3] + "\n" );
506            sb.append( "aov: " + Math.toDegrees( angleOfView ) + "\n" );
507            sb.append( "yaw: " + Math.toDegrees( yaw ) + "\n" );
508            sb.append( "pitch: " + Math.toDegrees( pitch ) + "\n" );
509            sb.append( "distanceToSeaLevel: " + terrainDistanceToSeaLevel + "\n" );
510            sb.append( "farClippingPlane: " + farClippingPlane + "\n" );
511    
512            return sb.toString();
513        }
514    
515        /**
516         * @return Returns the farClippingPlane.
517         */
518        public double getFarClippingPlane() {
519            return farClippingPlane;
520        }
521    
522        /**
523         * @return Returns a new transform3D Object which contains the transformations to place the viewers Position and his
524         *         yaw viewing angle relativ to the 0,0 coordinates and the poi.
525         */
526        public Transform3D getSimpleTransform() {
527            return new Transform3D( simpleTransform );
528        }
529    
530        /**
531         * @param transform
532         *            The transform to set.
533         */
534        public void setSimpleTransform( Transform3D transform ) {
535            this.simpleTransform = transform;
536        }
537    
538        /**
539         * @return Returns the viewMatrix.
540         */
541        public Transform3D getViewMatrix() {
542            return viewMatrix;
543        }
544    
545        /**
546         * @return the viewerToPOIDistance value.
547         */
548        public double getViewerToPOIDistance() {
549            return viewerToPOIDistance;
550        }
551    
552        /**
553         * @param viewerToPOIDistance
554         *            An other viewerToPOIDistance value.
555         */
556        public void setViewerToPOIDistance( double viewerToPOIDistance ) {
557            this.viewerToPOIDistance = viewerToPOIDistance;
558            calcObserverPosition();
559        }
560    
561        /**
562         *
563         * @return the Footprint as a Surface (bbox)
564         */
565        public Surface getVisibleArea() {
566            double minX = Double.MAX_VALUE;
567            double minY = Double.MAX_VALUE;
568            double maxX = Double.MIN_VALUE;
569            double maxY = Double.MIN_VALUE;
570            for ( Point3d point : footprint ) {
571                if ( point.x < minX )
572                    minX = point.x;
573                if ( point.x > maxX )
574                    maxX = point.x;
575                if ( point.y < minY )
576                    minY = point.y;
577                if ( point.y > maxY )
578                    maxY = point.y;
579            }
580            Envelope env = GeometryFactory.createEnvelope( minX, minY, maxX, maxY, crs );
581            Surface s = null;
582            try {
583                s = GeometryFactory.createSurface( env, crs );
584            } catch ( GeometryException e ) {
585                e.printStackTrace();
586            }
587            return s;
588        }
589    
590        /**
591         * @return A String representation of the Footprint, so that it can be easily used in another programm e.g. deejump
592         * @throws GeometryException
593         *             if the footprint could not be transformed to wkt.
594         */
595        public String getFootPrintAsWellKnownText()
596                                throws GeometryException {
597            Position[] pos = new Position[footprint.length + 1];
598    
599            for ( int i = 0; i < footprint.length; ++i ) {
600                Point3d point = footprint[i];
601                pos[i] = GeometryFactory.createPosition( point.x, point.y, point.z );
602            }
603            Point3d point = footprint[0];
604            pos[footprint.length] = GeometryFactory.createPosition( point.x, point.y, point.z );
605    
606            return WKTAdapter.export( GeometryFactory.createSurface( pos, null, null, crs ) ).toString();
607        }
608    
609        /**
610         * @return the ObserverPosition as a well known text String.
611         * @throws GeometryException
612         *             if the conversion fails.
613         */
614        public String getObserverPositionAsWKT()
615                                throws GeometryException {
616            return WKTAdapter.export(
617                                      GeometryFactory.createPoint( observerPosition.x, observerPosition.y,
618                                                                   observerPosition.z, crs ) ).toString();
619        }
620    
621        /**
622         * @return the crs value.
623         */
624        public CoordinateSystem getCrs() {
625            return crs;
626        }
627    
628    }