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