]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/utils/GridUtils.java
Removed print
[simantics/platform.git] / bundles / org.simantics.scenegraph / src / org / simantics / scenegraph / utils / GridUtils.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
3  * in Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.scenegraph.utils;
13
14 import java.awt.geom.AffineTransform;
15 import java.awt.geom.Point2D;
16 import java.util.Arrays;
17
18 /**
19  * A set of utilities for calculating even spacings. Useful for grid/rules
20  * spacing calculations.
21  * 
22  * @author Tuukka Lehtonen
23  * @author Marko Luukkainen (original)
24  */
25 public final class GridUtils {
26
27     private static double gridLineEvenSpacings[] = new double[] { 1.0, 2.0, 5.0, 10.0 };
28
29     /**
30      * Returns next even grid spacing for value.
31      * 
32      * @param value to round to nearest even grid spacing
33      * @param gridSize the base grid size that will multiply the even spacings
34      *        returned by this method
35      * @param lessThan <code>true</code> to select the nearest even spacing <=
36      *        value or <code>false</code> to select the nearest even spacing >=
37      *        value
38      * @return the calculated nearest even grid spacing
39      */
40     public static double getEvenGridSpacing(double value, double gridSize, boolean lessThan) {
41         double exp = Math.floor(Math.log10(value));
42         double gs = Math.pow(10.0, exp) * gridSize;
43 //        System.out.println("getEvenGridSpacing(" + value + ", " + gridSize + ", " + lessThan + "): " + exp + ", " + gs);
44         int i = lessThan ? 1 : 0;
45         int max = lessThan ? gridLineEvenSpacings.length : gridLineEvenSpacings.length - 1;
46         while (i < max) {
47 //            System.out.println("COMPARE(" + gridLineEvenSpacings[i] + "): " + gridLineEvenSpacings[i]*gs + " >= " + value);
48             if (gridLineEvenSpacings[i] * gs >= value) {
49                 if (lessThan)
50                     --i;
51                 break;
52             }
53             i++;
54         }
55         // FIXME: this is a workaround to keep the next line from causing an NPE
56         // Need to check the calculations and make some sense into this code once
57         // again to be sure.
58         if (i >= gridLineEvenSpacings.length)
59             return 2 * gridLineEvenSpacings[gridLineEvenSpacings.length - 1] * gs;
60         return gridLineEvenSpacings[i] * gs;
61     }
62
63     /**
64      * Returns next even grid spacing for value with the assumed grid size of
65      * <code>1.0</code>.
66      * 
67      * @param value to round to nearest even grid spacing
68      * @param lessThan <code>true</code> to select the nearest even spacing <=
69      *        value or <code>false</code> to select the nearest even spacing >=
70      *        value
71      * @return the calculated nearest even grid spacing
72      */
73     public static double getEvenGridSpacing(double value, boolean lessThan) {
74         return getEvenGridSpacing(value, 1.0, lessThan);
75     }
76
77     /**
78      * Returns next even number for value and exponent of the value.
79      * 
80      * @param value in units
81      * @param array of at least two elements where the results will be put
82      * @return the specified array, where even number is element [0] and
83      *         exponent is element [1]
84      */
85     public static double[] getEvenGridSpacingWithExp(double value, double[] array) {
86         if (array == null)
87             throw new NullPointerException("null array");
88         if (array.length < 2)
89             throw new NullPointerException("");
90         
91         /* TODO Time-Spacing        
92         1s 5s 10s 20s 30s        
93         1m 5m 10m 20m 30m   
94         1h 2h 6h 12h         
95          */
96
97         double sig = Math.signum( value );
98         double exp = Math.floor(Math.log10( Math.abs(value) ));
99         double gs = Math.pow(10.0, exp);
100         int i = 0;
101         while (i < gridLineEvenSpacings.length - 1) {
102             if (gridLineEvenSpacings[i] * gs >= value) {
103                 break;
104             }
105             i++;
106         }
107         array[0] = gridLineEvenSpacings[i] * gs * sig;
108         array[1] = exp;
109         return array;
110     }
111
112     /**
113      * Returns next even number for value and exponent of the value.
114      * 
115      * @param value in units
116      * @return array where even number is [0] element and exponent is [1]
117      *         element
118      */
119     public static double[] getEvenGridSpacingWithExp(double value) {
120         return getEvenGridSpacingWithExp(value, new double[2]);
121     }
122
123     /**
124      * @param fromCoord
125      * @param gridSpacing
126      * @return
127      */
128     public static double distanceToNextGridCoord(double fromCoord, double gridSpacing) {
129         double mod = Math.IEEEremainder(fromCoord, gridSpacing);
130         if (mod < 0) {
131             return -mod;
132         } else if (mod > 0) {
133             return (gridSpacing - mod);
134         }
135         return 0;
136     }
137
138     /**
139      * @param fromCoord
140      * @param gridSpacing
141      * @return
142      */
143     public static double distanceToPrevGridCoord(double fromCoord, double gridSpacing) {
144         double mod = Math.IEEEremainder(fromCoord, gridSpacing);
145         if (mod < 0) {
146             return (gridSpacing + mod);
147         } else if (mod > 0) {
148             return mod;
149         }
150         return 0;
151     }
152     
153     /**
154      * @param coord
155      * @param gridSpacing
156      * @param scale
157      * @return
158      */
159     public static double distanceToNextGridCoordScaled(double coord, double gridSpacing, double scale) {
160         double result = distanceToNextGridCoord(coord, gridSpacing);
161         return result * scale;
162     }
163
164     /**
165      * @param coord
166      * @param gridSpacing
167      * @param scale
168      * @return
169      */
170     public static double distanceToPrevGridCoordScaled(double coord, double gridSpacing, double scale) {
171         double result = distanceToPrevGridCoord(coord, gridSpacing);
172         return result * scale;
173     }
174     
175     /**
176      * @param coord
177      * @param gridSpacing
178      * @return
179      */
180     public static double distanceToNearestGridCoord(double coord, double gridSpacing) {
181         double dist = GridUtils.distanceToNextGridCoord(coord, gridSpacing);
182         if (dist > gridSpacing / 2)
183             dist = dist - gridSpacing;
184         return dist;
185     }
186
187     /**
188      * @param tr
189      * @param gridSpacing
190      */
191     public static void snapToGrid(AffineTransform tr, double gridSpacing) {
192         double gdx = GridUtils.distanceToNearestGridCoord(tr.getTranslateX(), gridSpacing);
193         double gdy = GridUtils.distanceToNearestGridCoord(tr.getTranslateY(), gridSpacing);
194         //System.out.println("SNAP TO GRID: delta=(" + gdx + ", " + gdy + "), tr = " + tr);
195         tr.translate(gdx, gdy);
196     }
197
198     /**
199      * @param p
200      * @param gridSpacing
201      */
202     public static void snapToGrid(Point2D p, double gridSpacing) {
203         snapToGrid(p, gridSpacing, gridSpacing);
204     }
205
206     /**
207      * @param p
208      * @param gridXSpacing
209      * @param gridYSpacing
210      */
211     public static void snapToGrid(Point2D p, double gridXSpacing, double gridYSpacing) {
212         double x = p.getX();
213         double y = p.getY();
214         double gdx = GridUtils.distanceToNearestGridCoord(x, gridXSpacing);
215         double gdy = GridUtils.distanceToNearestGridCoord(y, gridYSpacing);
216         p.setLocation(x + gdx, y + gdy);
217     }
218
219     /**
220      * @param t
221      * @param gridSpacing
222      * @return
223      */
224     public static double snapToGrid(double t, double gridSpacing) {
225         double dt = GridUtils.distanceToNearestGridCoord(t, gridSpacing);
226         return t + dt;
227     }
228
229     /**
230      * Returns an even grid spacing where initialValue*scale <= limit.
231      * 
232      * @param initialValue
233      * @param scale
234      * @param limit
235      * @param gridSize
236      * @param lessThan <code>true</code> to select the nearest even spacing <=
237      *        limit/scale or <code>false</code> to select the nearest even spacing >=
238      *        limit/scale
239      * @return
240      */
241     public static double limitedEvenGridSpacing(double initialValue, double scale, double limit, double gridSize, boolean lessThan) {
242         while (initialValue * scale > limit)
243             initialValue /= 2;
244         return getEvenGridSpacing(initialValue, gridSize, lessThan);
245     }
246
247     /**
248      * Returns an even grid spacing where initialValue*scale <= limit
249      * 
250      * @param initialValue
251      * @param scale
252      * @param limit
253      * @param lessThan <code>true</code> to select the nearest even spacing <=
254      *        limit/scale or <code>false</code> to select the nearest even spacing >=
255      *        limit/scale
256      * @return
257      */
258     public static double limitedEvenGridSpacing(double initialValue, double scale, double limit, boolean lessThan) {
259         return limitedEvenGridSpacing(initialValue, scale, limit, 1.0, lessThan);
260     }
261
262     /**
263      * A simple test for these routines.
264      */
265     public static void main(String[] args) {
266         System.out.println(Arrays.toString(getEvenGridSpacingWithExp(15)));
267         System.out.println(Arrays.toString(getEvenGridSpacingWithExp(16.3)));
268         System.out.println(Arrays.toString(getEvenGridSpacingWithExp(143.41)));
269         System.out.println(Arrays.toString(getEvenGridSpacingWithExp(500.0)));
270         System.out.println(Arrays.toString(getEvenGridSpacingWithExp(10000.0)));
271         System.out.println(Arrays.toString(getEvenGridSpacingWithExp(0.5)));
272
273         //double aa[] = new double[2];
274         System.out.println(getEvenGridSpacing(15, true));
275         System.out.println(getEvenGridSpacing(15, false));
276         System.out.println(getEvenGridSpacing(16.3, true));
277         System.out.println(getEvenGridSpacing(16.3, false));
278         System.out.println(getEvenGridSpacing(143.41, true));
279         System.out.println(getEvenGridSpacing(143.41, false));
280         System.out.println(getEvenGridSpacing(500.0, true));
281         System.out.println(getEvenGridSpacing(500.0, false));
282         System.out.println(getEvenGridSpacing(10000.0, true));
283         System.out.println(getEvenGridSpacing(10000.0, false));
284         System.out.println(getEvenGridSpacing(0.5, true));
285         System.out.println(getEvenGridSpacing(0.5, false));
286         System.out.println(getEvenGridSpacing(0.045, true));
287         System.out.println(getEvenGridSpacing(0.045, false));
288         System.out.println(getEvenGridSpacing(0.000605, true));
289         System.out.println(getEvenGridSpacing(0.000605, false));
290
291         System.out.println(getEvenGridSpacing(143, 2.54, true));
292         System.out.println(getEvenGridSpacing(143, 2.54, false));
293     }
294
295 }