]> dev.renevier.net Git - syp.git/blob - openlayers/tests/Geometry/LineString.html
reset openlayers directory to its original state at the end of build.sh
[syp.git] / openlayers / tests / Geometry / LineString.html
1 <html>
2 <head>
3   <script src="../../lib/OpenLayers.js"></script>
4   <script type="text/javascript">
5     var line;
6     var components = [new OpenLayers.Geometry.Point(10,15), 
7                 new OpenLayers.Geometry.Point(0,0)];
8         
9     function test_LineString_constructor (t) {
10         t.plan( 3 );
11         line = new OpenLayers.Geometry.LineString();
12         t.ok( line instanceof OpenLayers.Geometry.LineString, "new OpenLayers.Geometry.LineString returns line object" );
13         t.eq( line.CLASS_NAME, "OpenLayers.Geometry.LineString", "line.CLASS_NAME is set correctly");
14         t.eq( line.components, [], "line.components is set correctly");
15     }
16
17     function test_LineString_constructor (t) {
18         t.plan( 3 );
19         line = new OpenLayers.Geometry.LineString(components);
20         t.ok( line instanceof OpenLayers.Geometry.LineString, "new OpenLayers.Geometry.LineString returns line object" );
21         t.eq( line.CLASS_NAME, "OpenLayers.Geometry.LineString", "line.CLASS_NAME is set correctly");
22         // TBD FIXME, recursion
23         // t.eq( line.components, components, "line.components is set correctly");
24         t.eq( line.components.length, 2, "line.components.length is set correctly");
25     }
26     
27     function test_LineString_toString(t) {
28         t.plan(1);
29         
30         line = new OpenLayers.Geometry.LineString(components);
31         t.eq(line.toString(),
32              "LINESTRING(10 15,0 0)",
33              "toString() returns WKT");
34     }
35     
36     function test_LineString_removeComponent(t) {
37         t.plan(2);
38         
39         OpenLayers.Geometry.Collection.prototype._removeComponent = 
40             OpenLayers.Geometry.Collection.prototype.removeComponent;
41         OpenLayers.Geometry.Collection.prototype.removeComponent = 
42             function(point) { g_removeComponent = point; };
43         
44         line = new OpenLayers.Geometry.LineString(components);
45
46         g_removeComponent = null;
47         line.removeComponent(components[0]);
48         t.ok(g_removeComponent == null, "point not removed if only 2 points in components");
49
50         line.components.push(new OpenLayers.Geometry.Point(4,4));
51         line.removeComponent(components[0]);
52         t.ok(g_removeComponent, components[0], "point removed if 3 points in components");
53         
54         OpenLayers.Geometry.Collection.prototype.removeComponent = 
55             OpenLayers.Geometry.Collection.prototype._removeComponent;
56     }
57     
58     function test_LineString_move(t) {
59         t.plan(4);
60         
61         var components = [new OpenLayers.Geometry.Point(10,15), 
62                 new OpenLayers.Geometry.Point(0,0)];
63         var line = new OpenLayers.Geometry.LineString(components);
64         
65         var x0 = components[0].x;
66         var y0 = components[0].y;
67         var x1 = components[1].x;
68         var y1 = components[1].y;
69         
70         var dx = 10 * Math.random();
71         var dy = 10 * Math.random();
72         line.move(dx, dy);
73         
74         t.eq(line.components[0].x, x0 + dx, "move() correctly modifies first x");
75         t.eq(line.components[0].y, y0 + dy, "move() correctly modifies first y");
76         t.eq(line.components[1].x, x1 + dx, "move() correctly modifies second x");
77         t.eq(line.components[1].y, y1 + dy, "move() correctly modifies second y");
78     }
79
80     function test_LineString_rotate(t) {
81         t.plan(6);
82         
83         var components = [new OpenLayers.Geometry.Point(10,15), 
84                           new OpenLayers.Geometry.Point(0,0)];
85         var geometry = new OpenLayers.Geometry.LineString(components);
86         
87         var originals = [];
88         var comp;
89         var angle = 2 * Math.PI * Math.random();
90         var origin = new OpenLayers.Geometry.Point(10 * Math.random(),
91                                                    10 * Math.random());
92         for(var i=0; i<geometry.components.length; ++i) {
93             comp = geometry.components[i];
94             originals[i] = comp.rotate;
95             comp.rotate = function(a, o) {
96                 t.ok(true, "rotate called for component " + i);
97                 t.ok(a == angle, "rotate called with correct angle");
98                 t.ok(o == origin, "rotate called with correct origin");
99             }
100         }
101         geometry.rotate(angle, origin);
102         
103         // restore the original rotate defs
104         for(var i=0; i<geometry.components.length; ++i) {
105             comp.rotate = originals[i];
106         }
107     }
108
109     function test_LineString_resize(t) {
110         t.plan(8);
111         
112         var tolerance = 1e-10;
113
114         var components = [new OpenLayers.Geometry.Point(10 * Math.random(),
115                                                         10 * Math.random()), 
116                           new OpenLayers.Geometry.Point(10 * Math.random(),
117                                                         10 * Math.random())];
118         var geometry = new OpenLayers.Geometry.LineString(components);
119
120         var origin = new OpenLayers.Geometry.Point(10 * Math.random(),
121                                                    10 * Math.random());
122         
123         var scale = 10 * Math.random();
124         
125         var oldLength = geometry.getLength();
126         var ret = geometry.resize(scale, origin);
127         t.ok(ret === geometry, "resize returns geometry");
128         var newLength = geometry.getLength();
129         t.ok((((newLength / oldLength) - scale) / scale) < tolerance,
130              "resize correctly changes the length of a linestring")
131
132         var originals = [];
133         var comp;
134         for(var i=0; i<geometry.components.length; ++i) {
135             comp = geometry.components[i];
136             originals[i] = comp.resize;
137             comp.resize = function(s, o) {
138                 t.ok(true, "resize called for component " + i);
139                 t.ok(s == scale, "resize called with correct scale");
140                 t.ok(o == origin, "resize called with correct origin");
141             }
142         }
143         geometry.resize(scale, origin);
144         
145         // restore the original resize defs
146         for(var i=0; i<geometry.components.length; ++i) {
147             comp.resize = originals[i];
148         }
149         
150     }
151     
152     function test_split(t) {
153         var wkt = OpenLayers.Geometry.fromWKT;
154         
155         var cases = [{
156             msg: "no intersection",
157             g1: "LINESTRING(0 0, 0 1)",
158             g2: "LINESTRING(1 0, 1 1)",
159             exp: null
160         } , {
161             msg: "intersection at midpoint",
162             g1: "LINESTRING(0 0, 1 1)",
163             g2: "LINESTRING(1 0, 0 1)",
164             exp: ["LINESTRING(1 0, 0.5 0.5)", "LINESTRING(0.5 0.5, 0 1)"]
165         }, {
166             msg: "intersection at midpoint (reverse source/target)",
167             g1: "LINESTRING(1 0, 0 1)",
168             g2: "LINESTRING(0 0, 1 1)",
169             exp: ["LINESTRING(0 0, 0.5 0.5)", "LINESTRING(0.5 0.5, 1 1)"]
170         }, {
171             msg: "intersection at endpoint",
172             g1: "LINESTRING(0 0, 1 1)",
173             g2: "LINESTRING(1 0, 1 1)",
174             exp: null
175         }, {
176             msg: "midpoint intersection, no options",
177             g1: "LINESTRING(0 0, 2 2)",
178             g2: "LINESTRING(0 2, 2 0)",
179             exp: ["LINESTRING(0 2, 1 1)", "LINESTRING(1 1, 2 0)"]
180         }, {
181             msg: "midpoint intersection, edge false",
182             opt: {edge: false},
183             g1: "LINESTRING(0 0, 2 2)",
184             g2: "LINESTRING(0 2, 2 0)",
185             exp: null
186         }, {
187             msg: "midpoint intersection, mutual",
188             opt: {mutual: true},
189             g1: "LINESTRING(0 0, 2 2)",
190             g2: "LINESTRING(0 2, 2 0)",
191             exp: [["LINESTRING(0 0, 1 1)", "LINESTRING(1 1, 2 2)"], ["LINESTRING(0 2, 1 1)", "LINESTRING(1 1, 2 0)"]]
192         }, {
193             msg: "close intersection, no tolerance",
194             g1: "LINESTRING(0 0, 0.9 0.9)",
195             g2: "LINESTRING(0 2, 2 0)",
196             exp: null
197         }, {
198             msg: "close intersection, within tolerance",
199             opt: {tolerance: 0.2},
200             g1: "LINESTRING(0 0, 0.9 0.9)",
201             g2: "LINESTRING(0 2, 2 0)",
202             exp: ["LINESTRING(0 2, 0.9 0.9)", "LINESTRING(0.9 0.9, 2 0)"]
203         }];
204         
205         t.plan(cases.length);
206         var c, parts, part, midparts;
207         for(var i=0; i<cases.length; ++i) {
208             c = cases[i];
209             var g1 = wkt(c.g1);
210             var g2 = wkt(c.g2);
211             var got = g1.split(g2, c.opt);
212             var exp = c.exp;
213             if(got instanceof Array) {
214                 parts = [];
215                 for(var j=0; j<got.length; ++j) {
216                     part = got[j];
217                     if(part instanceof Array) {
218                         midparts = [];
219                         for(var k=0; k<part.length; ++k) {
220                             midparts.push(part[k].toString());
221                         }
222                         parts.push("[" + midparts.join(", ") + "]");
223                     } else {
224                         parts.push(got[j].toString());
225                     }
226                 }
227                 got = parts.join(", ");
228             }
229             if(exp instanceof Array) {
230                 parts = [];
231                 for(var j=0; j<exp.length; ++j) {
232                     part = exp[j];
233                     if(part instanceof Array) {
234                         midparts = [];
235                         for(var k=0; k<part.length; ++k) {
236                             midparts.push(wkt(part[k]).toString());
237                         }
238                         parts.push("[" + midparts.join(", ") + "]");
239                     } else {
240                         parts.push(wkt(exp[j]).toString());
241                     }
242                 }
243                 exp = parts.join(", ");
244             }
245             t.eq(got, exp, "case " + i + ": " +  c.msg);
246         }
247         
248     }
249     
250
251     function test_distanceTo(t) {
252         var wkt = OpenLayers.Geometry.fromWKT;
253         var geoms = [
254             wkt("POINT(0 0)"),
255             wkt("LINESTRING(-2 0, 0 -2, 2 -1, 2 0)")
256         ];
257
258         var cases = [{
259             got: geoms[1].distanceTo(geoms[0]),
260             expected: Math.sqrt(2)
261         }, {
262             got: geoms[1].distanceTo(geoms[0], {details: true}),
263             expected: {
264                 distance: Math.sqrt(2),
265                 x0: -1, y0: -1,
266                 x1: 0, y1: 0
267             }
268         }];
269         
270         t.plan(cases.length);
271         for(var i=0; i<cases.length; ++i) {
272             t.eq(cases[i].got, cases[i].expected, "case " + i);
273         }
274         
275     }
276
277     function test_LineString_equals(t) {
278         t.plan(3);
279         
280         var x0 = Math.random() * 100;
281         var y0 = Math.random() * 100;
282         var x1 = Math.random() * 100;
283         var y1 = Math.random() * 100;
284         var point0 = new OpenLayers.Geometry.Point(x0, y0);
285         var point1 = new OpenLayers.Geometry.Point(x1, y1);
286         var geometry = new OpenLayers.Geometry.LineString([point0, point1]);
287         var equal = new OpenLayers.Geometry.LineString([point0, point1]);
288         var offX =  new OpenLayers.Geometry.LineString([
289                             new OpenLayers.Geometry.Point(x0 + 1, y0),
290                             new OpenLayers.Geometry.Point(x1 + 1, y1)]);
291         var offY =  new OpenLayers.Geometry.LineString([
292                             new OpenLayers.Geometry.Point(x0, y0 + 1),
293                             new OpenLayers.Geometry.Point(x1, y1 + 1)]);
294         t.ok(geometry.equals(equal),
295              "equals() returns true for a geometry with equivalent coordinates");
296         t.ok(!geometry.equals(offX),
297              "equals() returns false for a geometry with offset x");
298         t.ok(!geometry.equals(offY),
299              "equals() returns false for a geometry with offset y");
300     }
301
302     
303     function test_getVertices(t) {
304         t.plan(14);
305         
306         var points = [
307             new OpenLayers.Geometry.Point(10, 20),
308             new OpenLayers.Geometry.Point(20, 30),
309             new OpenLayers.Geometry.Point(30, 40),
310             new OpenLayers.Geometry.Point(40, 50)
311         ];
312         var line = new OpenLayers.Geometry.LineString(points);
313         
314         var verts = line.getVertices();
315         t.ok(verts instanceof Array, "got back an array");
316         t.eq(verts.length, points.length, "of correct length length");
317         t.geom_eq(verts[0], points[0], "0: correct geometry");
318         t.geom_eq(verts[1], points[1], "1: correct geometry");
319         t.geom_eq(verts[2], points[2], "2: correct geometry");
320         t.geom_eq(verts[3], points[3], "3: correct geometry");
321         
322         // get nodes only
323         var nodes = line.getVertices(true);
324         t.ok(nodes instanceof Array, "[nodes only] got back an array");
325         t.eq(nodes.length, 2, "[nodes only] of correct length length");
326         t.geom_eq(nodes[0], points[0], "[nodes only] first: correct geometry");
327         t.geom_eq(nodes[1], points[points.length-1], "[nodes only] last: correct geometry");
328
329         // no nodes
330         var nodes = line.getVertices(false);
331         t.ok(nodes instanceof Array, "[no nodes] got back an array");
332         t.eq(nodes.length, 2, "[no nodes] of correct length length");
333         t.geom_eq(nodes[0], points[1], "[no nodes] first: correct geometry");
334         t.geom_eq(nodes[1], points[2], "[no nodes] last: correct geometry");
335
336     }
337     
338     
339     function test_LineString_clone(t) {
340         t.plan(2);
341         
342         var x0 = Math.random() * 100;
343         var y0 = Math.random() * 100;
344         var x1 = Math.random() * 100;
345         var y1 = Math.random() * 100;
346         var point0 = new OpenLayers.Geometry.Point(x0, y0);
347         var point1 = new OpenLayers.Geometry.Point(x1, y1);
348         var geometry = new OpenLayers.Geometry.LineString([point0, point1]);
349         var clone = geometry.clone();
350         t.ok(clone instanceof OpenLayers.Geometry.LineString,
351              "clone() creates an OpenLayers.Geometry.LineString");
352         t.ok(geometry.equals(clone), "clone has equivalent coordinates");
353     }
354     
355     function test_getGeodesicLength(t) {
356         
357         // expected values from http://www.movable-type.co.uk/scripts/latlong-vincenty.html
358         var cases = [{
359             wkt: "LINESTRING(0 0, -10 45)",
360             exp: 5081689.690
361         }, {
362             wkt: "LINESTRING(-10 45, 0 0)",
363             exp: 5081689.690
364         }, {
365             wkt: "LINESTRING(0 0, -10 45, -20 50)",
366             exp: 5081689.690 + 935018.062
367         }];
368         t.plan(cases.length);
369         
370         var geom, got;
371         for(var i=0; i<cases.length; ++i) {
372             geom = new OpenLayers.Geometry.fromWKT(cases[i].wkt);
373             got = geom.getGeodesicLength();
374             t.eq(Math.round(got), Math.round(cases[i].exp), "[case " + i + "] length calculated");
375         }
376         
377     }   
378
379   </script>
380 </head>
381 <body>
382 </body>
383 </html>