00e563a0a527bc8bc0b215f407382945dee9af31
[scilab.git] / scilab / modules / scirenderer / src / org / scilab / forge / scirenderer / ruler / DefaultRulerModel.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009-2011 - DIGITEO - Pierre Lando
4  * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  */
12
13 package org.scilab.forge.scirenderer.ruler;
14
15 import org.scilab.forge.scirenderer.ruler.graduations.Graduations;
16 import org.scilab.forge.scirenderer.ruler.graduations.LinearGraduations;
17 import org.scilab.forge.scirenderer.ruler.graduations.LogarithmicGraduations;
18 import org.scilab.forge.scirenderer.shapes.appearance.Color;
19 import org.scilab.forge.scirenderer.tranformations.Vector3d;
20
21 /**
22  * Default ruler model.
23  *
24  * @author Pierre Lando
25  */
26 public final class DefaultRulerModel implements RulerModel {
27
28     /**
29      * Value associated with the first point.
30      */
31     private double firstValue = DEFAULT_FIRST_VALUE;
32
33     /**
34      * Value associated with the second point.
35      */
36     private double secondValue = DEFAULT_SECOND_VALUE;
37
38     /**
39      * First point position in world coordinate.
40      */
41     private Vector3d firstPoint = DEFAULT_FIRST_POINT;
42
43     /**
44      * Second point position in world coordinate.
45      */
46     private Vector3d secondPoint = DEFAULT_SECOND_POINT;
47
48     /**
49      * Ticks direction, in world coordinate.
50      */
51     private Vector3d ticksDirection = DEFAULT_TICKS_DIRECTION;
52
53     /**
54      * Ticks length, in pixel.
55      */
56     private int ticksLength = DEFAULT_TICK_LENGTH;
57
58     /**
59      * Sub ticks length, in pixel.
60      */
61     private int subTicksLength = DEFAULT_SUB_TICK_LENGTH;
62
63     /**
64      * Minimal sub-ticks distance.
65      */
66     private double minimalSubTicksDistance = DEFAULT_MINIMAL_SUB_TICKS_DISTANCE;
67
68     /**
69      * Sprite distance to segment, in pixel.
70
71      */
72     private int spriteDistance = DEFAULT_SPRITE_DISTANCE;
73
74     /**
75      * The graduations.
76      */
77     private Graduations graduations;
78
79     /**
80      * Current margin.
81      * The margin is the minimal allowed distance between to sprite of the same ruler.
82      */
83     private double margin = DEFAULT_MARGIN;
84
85     /**
86      * Current line visibility.
87      */
88     private boolean lineVisible = DEFAULT_LINE_VISIBLE;
89
90     /**
91      * Auto-ticks status.
92      */
93     private boolean isAutoTicks = DEFAULT_AUTO_TICKS_STATUS;
94
95     /**
96      * Logarithmic status.
97      */
98     private boolean isLogarithmic = DEFAULT_LOGARITHMIC_STATUS;
99
100     /**
101      * Current color.
102      */
103     private Color color = DEFAULT_COLOR;
104
105     /**
106      * Used graduations when {@link this#isAutoTicks} is false.
107      */
108     private Graduations userGraduation;
109
110     /**
111      * Line width
112      */
113     private double lineWidth = DEFAULT_LINE_WIDTH;
114
115     private int subticksNumber = -1;
116
117     /**
118      * Default constructor.
119      */
120     public DefaultRulerModel() {
121     }
122
123     @Override
124     public double getFirstValue() {
125         return firstValue;
126     }
127
128     /**
129      * First value setter.
130      * @param firstValue the new first value.
131      */
132     public void setFirstValue(double firstValue) {
133         graduations = null;
134         this.firstValue = (Double.isInfinite(firstValue) ? Double.MAX_VALUE : firstValue);
135     }
136
137     @Override
138     public double getSecondValue() {
139         return secondValue;
140     }
141
142     /**
143      * Second value setter.
144      * @param secondValue the new second value.
145      */
146     public void setSecondValue(double secondValue) {
147         graduations = null;
148         this.secondValue = (Double.isInfinite(secondValue) ? Double.MAX_VALUE : secondValue);
149     }
150
151     /**
152      * Set the first and second value in one call.
153      * @param firstValue the first value.
154      * @param secondValue the second value.
155      */
156     public void setValues(double firstValue, double secondValue) {
157         setFirstValue(firstValue);
158         setSecondValue(secondValue);
159     }
160
161     @Override
162     public Vector3d getFirstPoint() {
163         return firstPoint;
164     }
165
166     /**
167      * First point setter.
168      * @param firstPoint the new first point.
169      */
170     public void setFirstPoint(Vector3d firstPoint) {
171         this.firstPoint = firstPoint;
172     }
173
174     @Override
175     public Vector3d getSecondPoint() {
176         return secondPoint;
177     }
178
179     /**
180      * Second point setter.
181      * @param secondPoint the new second point.
182      */
183     public void setSecondPoint(Vector3d secondPoint) {
184         this.secondPoint = secondPoint;
185     }
186
187     /**
188      * Point setter.
189      * @param firstPoint the new first point.
190      * @param secondPoint the new second point.
191      */
192     public void setPoints(Vector3d firstPoint, Vector3d secondPoint) {
193         this.firstPoint = firstPoint;
194         this.secondPoint = secondPoint;
195     }
196
197     @Override
198     public Vector3d getTicksDirection() {
199         return ticksDirection;
200     }
201
202     /**
203      * Ticks direction setter.
204      * @param ticksDirection the new ticks direction.
205      */
206     public void setTicksDirection(Vector3d ticksDirection) {
207         this.ticksDirection = ticksDirection;
208     }
209
210     @Override
211     public int getTicksLength() {
212         return ticksLength;
213     }
214
215     /**
216      * Ticks length setter.
217      * @param ticksLength the new tick length in pixels.
218      */
219     public void setTicksLength(int ticksLength) {
220         this.ticksLength = ticksLength;
221     }
222
223     @Override
224     public int getSubTicksLength() {
225         return subTicksLength;
226     }
227
228     /**
229      * Sub-ticks length setter.
230      * @param subTicksLength the new sub-tick length in pixels.
231      */
232     public void setSubTicksLength(int subTicksLength) {
233         this.subTicksLength = subTicksLength;
234     }
235
236     @Override
237     public Graduations getGraduations() {
238         if (isAutoTicks) {
239             if (graduations == null) {
240                 if (isLogarithmic) {
241                     graduations = LogarithmicGraduations.create(getFirstValue(), getSecondValue());
242                 } else {
243                     graduations = LinearGraduations.create(getFirstValue(), getSecondValue());
244                 }
245             }
246             return graduations;
247         } else {
248             return userGraduation;
249         }
250     }
251
252     /**
253      * User graduation setter.
254      * @param graduations the new user-defined graduations.
255      */
256     public void setUserGraduation(Graduations graduations) {
257         this.userGraduation = graduations;
258     }
259
260     @Override
261     public Vector3d getPosition(double value) {
262         if ((firstPoint != null) && (secondPoint != null)) {
263             if (isLogarithmic()) {
264                 double valueLog = Math.log10(value);
265                 double firstValueLog = Math.log10(firstValue);
266                 double secondValueLog = Math.log10(secondValue);
267                 double s = (secondValueLog - firstValueLog);
268                 double k1 = (valueLog - firstValueLog) / s;
269                 double k2 = (secondValueLog - valueLog) / s;
270                 return firstPoint.times(k2).plus(secondPoint.times(k1));
271             } else {
272                 double s = (secondValue - firstValue);
273                 return firstPoint.times((secondValue - value) / s).plus(secondPoint.times((value - firstValue) / s));
274             }
275         } else {
276             return null;
277         }
278     }
279
280     @Override
281     public double getMargin() {
282         return margin;
283     }
284
285     /**
286      * Margin setter.
287      * The margin is minimal distance accepted between ticks labels.
288      * @param margin the new margin value.
289      */
290     public void setMargin(double margin) {
291         this.margin = margin;
292     }
293
294     @Override
295     public boolean isLineVisible() {
296         return lineVisible;
297     }
298
299     /**
300      * Line visibility setter.
301      * @param lineVisible the new line visibility status.
302      */
303     public void setLineVisible(boolean lineVisible) {
304         this.lineVisible = lineVisible;
305     }
306
307     @Override
308     public boolean isAutoTicks() {
309         return isAutoTicks;
310     }
311
312     /**
313      * Auto-ticks parameter setter.
314      * If it set to {@code false}, the user defined graduation will be used.
315      * @param isAutoTicks the new auto-ticks status.
316      */
317     public void setAutoTicks(boolean isAutoTicks) {
318         this.isAutoTicks = isAutoTicks;
319     }
320
321     @Override
322     public boolean isLogarithmic() {
323         return isLogarithmic;
324     }
325
326     /**
327      * Logarithmic or linear setter
328      * @param isLogarithmic the new logarithmic status.
329      */
330     public void setLogarithmic(boolean isLogarithmic) {
331         if (isLogarithmic != this.isLogarithmic) {
332             this.isLogarithmic = isLogarithmic;
333             graduations = null;
334         }
335     }
336
337     @Override
338     public int getSpriteDistance() {
339         return spriteDistance;
340     }
341
342     /**
343      * Sprite distance setter.
344      * @param spriteDistance the new sprite distance to the main ticks in pixel.
345      */
346     public void setSpriteDistance(int spriteDistance) {
347         this.spriteDistance = spriteDistance;
348     }
349
350     @Override
351     public double getMinimalSubTicksDistance() {
352         return minimalSubTicksDistance;
353     }
354
355     /**
356      * Minimal accepted distance between sub-ticks setter.
357      * @param minimalSubTicksDistance the new minimal accepted distance between sub-ticks.
358      */
359     public void setMinimalSubTicksDistance(double minimalSubTicksDistance) {
360         this.minimalSubTicksDistance = minimalSubTicksDistance;
361     }
362
363     @Override
364     public Color getColor() {
365         return color;
366     }
367
368     /**
369      * Ruler color setter.
370      * @param color the new rule color.
371      */
372     public void setColor(Color color) {
373         this.color = color;
374     }
375
376     @Override
377     public double getLineWidth() {
378         return lineWidth;
379     }
380
381     /**
382      * Ruler line width setter
383      * @param lineWidth the new line width
384      */
385     public void setLineWidth(double lineWidth) {
386         this.lineWidth = lineWidth;
387     }
388
389     @Override
390     public int getSubticksNumber() {
391         return subticksNumber;
392     }
393
394     /**
395      * Set number of subticks.
396      * @param N the number of subticks or -1 if the computation is automatic.
397      */
398     public void setSubticksNumber(int N) {
399         this.subticksNumber = N;
400     }
401
402 }