1
2
3
4
5
6
7
8
9
10 package nl.tudelft.simulation.dsol.animation.D2;
11
12 import java.awt.Dimension;
13 import java.awt.Graphics2D;
14 import java.awt.MediaTracker;
15 import java.awt.geom.Point2D;
16 import java.awt.image.ImageObserver;
17 import java.net.URL;
18 import java.rmi.RemoteException;
19 import java.util.HashMap;
20 import java.util.Map;
21
22 import javax.swing.ImageIcon;
23
24 import nl.tudelft.simulation.dsol.animation.LocatableInterface;
25 import nl.tudelft.simulation.dsol.animation.StaticLocation;
26 import nl.tudelft.simulation.dsol.simulators.SimulatorInterface;
27 import nl.tudelft.simulation.language.d3.BoundingBox;
28 import nl.tudelft.simulation.language.d3.BoundsUtil;
29 import nl.tudelft.simulation.language.d3.DirectedPoint;
30
31 /***
32 * An abstract class for state-dependent image renderables.
33 * <p>
34 * (c) copyright 2003 <a href="http://www.simulation.tudelft.nl">Delft
35 * University of Technology </a>, the Netherlands. <br>
36 * See for project information <a
37 * href="http://www.simulation.tudelft.nl">www.simulation.tudelft.nl </a> <br>
38 * License of use: <a href="http://www.gnu.org/copyleft/gpl.html">General Public
39 * License (GPL) </a>, no warranty <br>
40 *
41 * @author <a href="http://www.tbm.tudelft.nl/webstaf/peterja/index.htm">Peter
42 * Jacobs </a>
43 * @version 1.2 Apr 30, 2004
44 * @since 1.4
45 */
46 public abstract class ImageRenderable extends Renderable2D
47 {
48 /*** the cache of images */
49 private static Map cache = new HashMap();
50
51 /*** LEFT-BOTTOM location */
52 public static final short LB = -4;
53
54 /*** CENTER-BOTTOM location */
55 public static final short CB = -3;
56
57 /*** RIGHT-BOTTOM location */
58 public static final short RB = -2;
59
60 /*** LEFT-CENTER location */
61 public static final short LC = -1;
62
63 /*** CENTER-CENTER location */
64 public static final short CC = 0;
65
66 /*** RIGHT-CENTER location */
67 public static final short RC = 1;
68
69 /*** LEFT-TOP location */
70 public static final short LT = 2;
71
72 /*** CENTER-TOP location */
73 public static final short CT = 3;
74
75 /*** RIGHT-TOP location */
76 public static final short RT = 4;
77
78 /*** the images to be used */
79 protected ImageIcon[] images = null;
80
81 /*** the origin of the image */
82 protected short orientation = ImageRenderable.CC;
83
84 /***
85 * constructs a new ImageRenderable
86 *
87 * @param source the source to be animated.
88 * @param simulator the simulator to be used.
89 * @param images the image urls.
90 */
91 public ImageRenderable(final LocatableInterface source,
92 final SimulatorInterface simulator, final URL[] images)
93 {
94 super(source, simulator);
95 this.images = new ImageIcon[images.length];
96 for (int i = 0; i < images.length; i++)
97 {
98 if (ImageRenderable.cache.containsKey(images[i]))
99 {
100 this.images[i] = (ImageIcon) ImageRenderable.cache
101 .get(images[i]);
102 } else
103 {
104 this.images[i] = new ImageIcon(images[i]);
105 ImageRenderable.cache.put(images[i], this.images[i]);
106 }
107 }
108 this.setOrientation(ImageRenderable.CC);
109 }
110
111 /***
112 * constructs a new ImageRenderable
113 *
114 * @param staticLocation the static location of the set of images
115 * @param size the size of the images in world coordinates.
116 * @param simulator the simulator to be used
117 * @param images the images to display.
118 */
119 public ImageRenderable(final DirectedPoint staticLocation, final Dimension size,
120 final SimulatorInterface simulator, final URL[] images)
121 {
122 this(new StaticLocation(staticLocation, new BoundingBox(
123 size.getWidth(), size.getHeight(), 0.0)), simulator, images);
124 }
125
126 /***
127 * constructs a new ImageRenderable
128 *
129 * @param staticLocation the static location of the set of images
130 * @param size the size of the images in world coordinates.
131 * @param simulator the simulator to be used
132 * @param images the images to display.
133 */
134 public ImageRenderable(final Point2D staticLocation, final Dimension size,
135 final SimulatorInterface simulator, final URL[] images)
136 {
137 this(new StaticLocation(new DirectedPoint(staticLocation), new BoundingBox(
138 size.getWidth(), size.getHeight(), 0.0)), simulator, images);
139 }
140
141 /***
142 * @see nl.tudelft.simulation.dsol.animation.D2.Renderable2D#paint(java.awt.Graphics2D,
143 * java.awt.image.ImageObserver)
144 */
145 public void paint(final Graphics2D graphics, final ImageObserver observer)
146 throws RemoteException
147 {
148 int image = this.selectImage();
149 if (this.images[image].getImageLoadStatus() != MediaTracker.COMPLETE)
150 {
151 return;
152 }
153 Dimension size = BoundsUtil.getIntersect(this.source.getLocation(),
154 this.source.getBounds(), this.source.getLocation().z)
155 .getBounds().getSize();
156 Point2D origin = this.resolveOrigin(this.orientation, size);
157 graphics.translate(origin.getX(), origin.getY());
158 graphics.scale(0.001, 0.001);
159 graphics.drawImage(this.images[image].getImage(), 0, 0,
160 (int) (1000 * size.getWidth()),
161 (int) (1000 * size.getHeight()), observer);
162 graphics.scale(1000, 1000);
163 graphics.translate(-origin.getX(), -origin.getY());
164 }
165
166 /***
167 * selects the image. This methods makes the ImageRenderable state
168 * dependent. One is required to return the index number of the images[]
169 * which has to be drawn.
170 *
171 * @return int the current (state-dependent) image.
172 */
173 public abstract int selectImage();
174
175 /***
176 * @param orientation The orientation to set.
177 */
178 public void setOrientation(final short orientation)
179 {
180 this.orientation = orientation;
181 }
182
183 /***
184 * @return Returns the images.
185 */
186 public ImageIcon[] getImages()
187 {
188 return this.images;
189 }
190
191 /***
192 * resolves the origin of the image
193 *
194 * @param orientation the orientation (CC,..)
195 * @return Point2D the location
196 * @param size the size of the image.
197 */
198 protected Point2D resolveOrigin(final short orientation,
199 final Dimension size)
200 {
201 Point2D imageOrigin = new Point2D.Double(0.0, 0.0);
202 switch (orientation)
203 {
204 case ImageRenderable.LB :
205 imageOrigin.setLocation(imageOrigin.getX(), imageOrigin.getY()
206 - size.getHeight());
207 return imageOrigin;
208 case ImageRenderable.CB :
209 imageOrigin.setLocation(imageOrigin.getX() - 0.5
210 * size.getWidth(), imageOrigin.getY()
211 - size.getHeight());
212 return imageOrigin;
213 case ImageRenderable.RB :
214 imageOrigin.setLocation(imageOrigin.getX() - 1.0
215 * size.getWidth(), imageOrigin.getY()
216 - size.getHeight());
217 return imageOrigin;
218 case ImageRenderable.LC :
219 imageOrigin.setLocation(imageOrigin.getX(), imageOrigin.getY()
220 - 0.5 * size.getHeight());
221 return imageOrigin;
222 case ImageRenderable.CC :
223 imageOrigin.setLocation(imageOrigin.getX() - 0.5
224 * size.getWidth(), imageOrigin.getY() - 0.5
225 * size.getHeight());
226 return imageOrigin;
227 case ImageRenderable.RC :
228 imageOrigin.setLocation(imageOrigin.getX() - 1.0
229 * size.getWidth(), imageOrigin.getY() - 0.5
230 * size.getHeight());
231 return imageOrigin;
232 case ImageRenderable.LT :
233 imageOrigin.setLocation(imageOrigin.getX(), imageOrigin.getY());
234 return imageOrigin;
235 case ImageRenderable.CT :
236 imageOrigin.setLocation(imageOrigin.getX() - 0.5
237 * size.getWidth(), imageOrigin.getY());
238 return imageOrigin;
239 case ImageRenderable.RT :
240 imageOrigin.setLocation(imageOrigin.getX() - 1.0
241 * size.getWidth(), imageOrigin.getY());
242 return imageOrigin;
243 default :
244 throw new IllegalArgumentException("unknown origin location");
245 }
246 }
247 }