Bug 12496 fixed: zoom_rect could lead to a crash in log scale
[scilab.git] / scilab / modules / renderer / src / java / org / scilab / modules / renderer / JoGLView / util / ScaleUtils.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - DIGITEO - Manuel JULIACHS
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  */
11
12 package org.scilab.modules.renderer.JoGLView.util;
13
14 import org.scilab.forge.scirenderer.tranformations.Vector3d;
15
16 /**
17  * Class ScaleUtils
18  * A set of utility methods for logarithmic scaling and unscaling.
19  *
20  * @author Manuel JULIACHS
21  */
22 public class ScaleUtils {
23
24     /**
25      * Applies logarithmic scaling to a point and returns the result.
26      * @param point the point.
27      * @param logFlags the flags indicating whether scaling must be applied for respectively the x,y,z axes (3 elements).
28      * @return the transformed point.
29      */
30     public static Vector3d applyLogScale(Vector3d point, boolean[] logFlags) {
31         double[] coords = point.getData();
32
33         if (logFlags[0]) {
34             coords[0] = Math.log10(coords[0]);
35         }
36
37         if (logFlags[1]) {
38             coords[1] = Math.log10(coords[1]);
39         }
40
41         if (logFlags[2]) {
42             coords[2] = Math.log10(coords[2]);
43         }
44
45         return new Vector3d(coords);
46     }
47
48     /**
49      * Applies logarithmic scaling to a coords array.
50      * @param coords the coords (a 3-array).
51      * @param logFlags the flags indicating whether scaling must be applied for respectively the x,y,z axes (3 elements).
52      */
53     public static void applyLogScale(double[] coords, boolean[] logFlags) {
54         if (logFlags[0]) {
55             coords[0] = Math.log10(coords[0]);
56         }
57
58         if (logFlags[1]) {
59             coords[1] = Math.log10(coords[1]);
60         }
61
62         if (logFlags[2]) {
63             coords[2] = Math.log10(coords[2]);
64         }
65     }
66
67     /**
68      * Applies inverse logarithmic scaling to a point and returns the result.
69      * @param point the point.
70      * @param logFlags the flags indicating whether inverse scaling must be applied for respectively the x,y,z axes (3 elements).
71      * @return the transformed point.
72      */
73     public static Vector3d applyInverseLogScale(Vector3d point, boolean[] logFlags) {
74         double[] coords = point.getData();
75
76         if (logFlags[0]) {
77             coords[0] = Math.pow(10.0, coords[0]);
78         }
79
80         if (logFlags[1]) {
81             coords[1] = Math.pow(10.0, coords[1]);
82         }
83
84         if (logFlags[2]) {
85             coords[2] = Math.pow(10.0, coords[2]);
86         }
87
88         return new Vector3d(coords);
89     }
90
91     /**
92      * Applies inverse logarithmic scaling to a coords array.
93      * @param coords the coords (a 3-array).
94      * @param logFlags the flags indicating whether inverse scaling must be applied for respectively the x,y,z axes (3 elements).
95      */
96     public static void applyInverseLogScale(double[] coords, boolean[] logFlags) {
97         if (logFlags[0]) {
98             coords[0] = Math.pow(10.0, coords[0]);
99         }
100
101         if (logFlags[1]) {
102             coords[1] = Math.pow(10.0, coords[1]);
103         }
104
105         if (logFlags[2]) {
106             coords[2] = Math.pow(10.0, coords[2]);
107         }
108     }
109
110     /**
111      * Applies inverse logarithmic scaling to a bounds array.
112      * @param bounds the bounds (a 6-array).
113      * @param logFlags the flags indicating whether inverse scaling must be applied for respectively the x,y,z axes (3 elements).
114      */
115     public static void applyInverseLogScaleToBounds(Double[] bounds, boolean[] logFlags) {
116         if (logFlags[0]) {
117             bounds[0] = Math.pow(10, bounds[0]);
118             bounds[1] = Math.pow(10, bounds[1]);
119         }
120
121         if (logFlags[1]) {
122             bounds[2] = Math.pow(10, bounds[2]);
123             bounds[3] = Math.pow(10, bounds[3]);
124         }
125
126         if (logFlags[2]) {
127             bounds[4] = Math.pow(10, bounds[4]);
128             bounds[5] = Math.pow(10, bounds[5]);
129         }
130     }
131 }