001 package fr.isae.geometry.more;
002
003 import fr.isae.observer.Observable;
004
005 /**
006 * <code>Point</code> definit une classe point mathematique dans un
007 * plan qui peut est dans un repere cartesien.<BR>
008 * Un point peut etre translate. Sa distance par rapport a un autre
009 * point peut etre obtenue.
010 *
011 * @author <a href="mailto:garion@isae.fr">Christophe Garion</a>
012 * @version 1.0
013 */
014 public class Point extends Observable {
015 private double x;
016 private double y;
017
018 /**
019 * La valeur servant a comparer des <code>double</code> entre eux.
020 */
021 public static final double EPS = 10E-9;
022
023 /**
024 * Une constante representant le point a l'origine.
025 */
026 public static final Point ORIGINE = new Point(0.0, 0.0);
027
028 /**
029 * Cree une nouvelle instance de <code>Point</code>.
030 *
031 * @param x un <code>double</code> representant l'abscisse du
032 * point a creer
033 * @param y un <code>double</code> representant l'ordonnee du
034 * point a creer
035 */
036 public Point(double x, double y) {
037 super();
038 this.x = x;
039 this.y = y;
040 }
041
042 /**
043 * La valeur de l'abscisse du point.
044 *
045 * @return un <code>double</code> qui est l'abscisse du point
046 */
047 public double getX() {
048 return this.x;
049 }
050
051 /**
052 * Changer la valeur de l'abscisse du point.
053 *
054 * @param x un <code>double</code> qui est la nouvelle abscisse
055 */
056 public void setX(double x) {
057 this.x = x;
058 this.avertir();
059 }
060
061 /**
062 * La valeur de l'ordonnee du point.
063 *
064 * @return un <code>double</code> qui est l'ordonnee du point
065 */
066 public double getY() {
067 return this.y;
068 }
069
070 /**
071 * Changer la valeur de l'ordonnee du point.
072 *
073 * @param y un <code>double</code> qui est la nouvelle ordonnee
074 */
075 public void setY(double y) {
076 this.y = y;
077 this.avertir();
078 }
079
080 /**
081 * La valeur du module du point.
082 *
083 * @return un <code>double</code> qui est la valeur du module.
084 */
085 public double getModule() {
086 return (Math.sqrt(this.x * this.x + this.y * this.y));
087 }
088
089 /**
090 * Changer la valeur du module du point.
091 *
092 * @param module la nouvelle valeur du module du point. <b>Elle
093 * doit etre positive.</b>
094 */
095 public void setModule(double module) {
096 double ancienModule = getModule();
097
098 if (ancienModule < EPS) {
099 this.x = module;
100 } else {
101 this.x = (this.x * module) / ancienModule;
102 this.y = (this.y * module) / ancienModule;
103 }
104 }
105
106 /**
107 * La valeur de l'argument du point.
108 *
109 * @return un <code>double</code> qui est la valeur de l'argument.
110 */
111 public double getArgument() {
112 if (this.getModule() < EPS) {
113 return 0;
114 }
115
116 double ancienArg = Math.acos(this.x / this.getModule());
117
118 if (this.y < 0) {
119 return (-1.0 * ancienArg);
120 }
121
122 return ancienArg;
123 }
124
125 /**
126 * Changer la valeur de l'argument du point.
127 *
128 * @param argument la nouvelle valeur de l'argument du point.
129 */
130 public void setArgument(double argument) {
131 double ancienModule = this.getModule();
132 x = ancienModule * Math.cos(argument);
133 y = ancienModule * Math.sin(argument);
134 }
135
136 /**
137 * <code>translater</code> permet de translater le point.
138 *
139 * @param dx un <code>double</code> qui represente l'abscisse du
140 * vecteur de translation
141 * @param dy un <code>double</code> qui represente l'ordonnee du
142 * vecteur de translation
143 */
144 public void translater(double dx, double dy) {
145 this.x = this.x + dx;
146 this.y = this.y + dy;
147 this.avertir();
148 }
149
150 /**
151 * <code>afficher</code> permet d'afficher les coordonnees du point.
152 */
153 public void afficher() {
154 System.out.println(this);
155 }
156
157 /**
158 * <code>toString</code> renvoie un objet de type <code>String</code>
159 * qui represente une chaine de caracteres representant le point.
160 *
161 * <p> Nous verrons plus tard (cf. cours sur l'heritage) que
162 * cette methode nous permet d'utiliser un objet comme un type
163 * primitif et d'ecrire par exemple <code>System.out.println("Le
164 * point est : " + p)</code> ou <code>p</code> est une poignee
165 * sur un objet de type <code>Point</code>.
166 *
167 * @return un objet de type <code>String</code> representant
168 * le point. Pour un point de coordonnees (2,3), cet objet
169 * representera la chaine <code>(2,3)</code>.
170 */
171 public String toString() {
172 return ("(" + this.x + "," + this.y + ")");
173 }
174
175 /**
176 * <code>distance</code> permet de calculer la distance entre deux
177 * points.
178 *
179 * @param p un <code>Point</code> qui est l'autre point pour calculer
180 * la distance
181 * @return un <code>double</code> qui est la distance entre les deux
182 * point
183 */
184 public double distance(Point p) {
185 return (Math.sqrt(((this.x - p.x) * (this.x - p.x)) +
186 ((this.y - p.y) * (this.y - p.y))));
187 }
188
189 /**
190 * <code>equals</code> permet de verifier si deux points sont egaux, i.e.
191 * s'ils ont les memes coordonnees.
192 *
193 * @param o un <code>Object</code> qui est l'objet dont on veut verifier s'il
194 * est egal a <code>this</code>
195 * @return un <code>boolean</code> qui est <code>true</code> si <code>o</code>
196 * est un point egal a <code>this</code>
197 */
198 @Override public boolean equals(Object o) {
199 if (!(o instanceof Point)) {
200 return false;
201 }
202
203 return (this.x == ((Point) o).x) && (this.y == ((Point) o).y);
204 }
205
206 /**
207 * <code>clone</code> permet d'obtenir une copie de <code>this</code>. On obtient
208 * un nouveau point avec des coordonnees identiques.
209 *
210 * @return un <code>Point p</code> tel que <code>this != p</code> et
211 * <code>this.equals(p)</code>
212 */
213 public Point clone() {
214 return new Point(this.x, this.y);
215 }
216 }
|