Mercurial > hg > digilib
annotate webapp/src/main/webapp/jquery/jquery.digilib.vector.js @ 1610:f425f00bf5e3 geom_prototype
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
author | robcast |
---|---|
date | Sun, 12 Mar 2017 15:53:01 +0100 |
parents | f322ac84adf7 |
children |
rev | line source |
---|---|
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1 /* |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
2 * #%L |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
3 * digilib vector plugin |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
4 * %% |
1246 | 5 * Copyright (C) 2014 MPIWG Berlin, Bibliotheca Hertziana |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
6 * %% |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
7 * This program is free software: you can redistribute it and/or modify |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
8 * it under the terms of the GNU Lesser General Public License as |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
9 * published by the Free Software Foundation, either version 3 of the |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
10 * License, or (at your option) any later version. |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
11 * |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
12 * This program is distributed in the hope that it will be useful, |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
15 * GNU General Lesser Public License for more details. |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
16 * |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
17 * You should have received a copy of the GNU General Lesser Public |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
18 * License along with this program. If not, see |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
19 * <http://www.gnu.org/licenses/lgpl-3.0.html>. |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
20 * #L% |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
21 * Authors: Robert Casties, Martin Raspe |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
22 */ |
1246 | 23 |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
24 /** |
1246 | 25 * digilib vector plugin. |
26 * | |
27 * Displays vector shapes on top of the image. | |
28 * | |
29 * Shapes are objects with "geometry" and "properties" members. | |
1261 | 30 * geometry is an object with "type" and "coordinates" members. |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
31 * Currently supported types: "Point", "Line", "LineString", "Rectangle", "Polygon", "Circle". |
1282 | 32 * coordinates is a list of pairs of relative coordinates. |
1261 | 33 * properties are the SVG properties "stroke", "stroke-width", "fill" and other properties. |
1260 | 34 * A property 'editable':true will display drag-handles to change the shape. |
35 * Editing the shape will send a "changeShape"(shape) event. | |
1246 | 36 * If a shape has an "id" member its value will be used in SVG. |
37 * | |
38 * shape = { | |
39 * 'geometry' : { | |
40 * 'type' : 'Line', | |
41 * 'coordinates' : [[0.1, 0.2], [0.3, 0.4]] | |
42 * }, | |
43 * 'properties' : { | |
1260 | 44 * 'stroke' : 'blue', |
45 * 'editable' : true | |
1246 | 46 * } |
47 * } | |
48 * | |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
49 */ |
1355 | 50 (function ($) { |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
51 |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
52 // affine geometry |
1241 | 53 var geom = null; |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
54 // plugin object with digilib data |
1253 | 55 var digilib = null; |
56 // SVG namespace | |
57 var svgNS = 'http://www.w3.org/2000/svg'; | |
1338 | 58 |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
59 var defaults = { |
1239 | 60 // is vector active? |
1241 | 61 'isVectorActive' : true, |
62 // default SVG stroke | |
63 'defaultStroke' : 'red', | |
64 // default SVG stroke-width | |
1249 | 65 'defaultStrokeWidth' : '2', |
1241 | 66 // default SVG fill |
1253 | 67 'defaultFill' : 'none', |
68 // grab handle size | |
1556 | 69 'editHandleSize' : 10, |
70 // handle type (square, diamond, circle, cross) | |
1585 | 71 'editHandleType' : 'square', |
72 // add or remove polygon points? | |
73 'editPolygonPoints' : true | |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
74 }; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
75 |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
76 var actions = { |
1239 | 77 /** |
1241 | 78 * set list of vector objects (shapes). |
79 * | |
1304 | 80 * replaces all existing shapes on layer. |
1239 | 81 * |
82 * @param data | |
83 * @param shapes | |
1304 | 84 * @param layer |
1239 | 85 */ |
1355 | 86 setShapes : function (data, shapes, layer) { |
1304 | 87 if (layer == null) { |
88 // assume shape layer is 0 | |
89 layer = data.vectorLayers[0]; | |
90 } | |
91 layer.shapes = shapes; | |
1239 | 92 renderShapes(data); |
93 }, | |
94 | |
1241 | 95 /** |
1247 | 96 * add vector object (shape) or create one by clicking. |
97 * | |
98 * For interactive use shape has to be initialized with a shape object with | |
1260 | 99 * type but no coordinates, e.g {'geometry':{'type':'Line'}}. |
100 * onComplete(data, newShape) will be called when done. | |
1241 | 101 * |
102 * @param data | |
103 * @param shape | |
1244
8cb0faad875a
interactive creation of vector lines and rectangles.
robcast
parents:
1241
diff
changeset
|
104 * @param onComplete |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
105 * @param layer |
1241 | 106 */ |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
107 addShape : function (data, shape, layer, onComplete) { |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
108 if (layer == null) { |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
109 // assume shape layer is 0 |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
110 layer = data.vectorLayers[0]; |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
111 } |
1304 | 112 if (layer.shapes == null) { |
113 layer.shapes = []; | |
114 } | |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
115 if (shape.geometry == null) { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
116 shape.geometry = {}; |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
117 } |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
118 if (shape.geometry.coordinates == null) { |
1244
8cb0faad875a
interactive creation of vector lines and rectangles.
robcast
parents:
1241
diff
changeset
|
119 // define shape interactively |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
120 defineShape(data, shape, layer, onComplete); |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
121 console.debug('addShape', shape); |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
122 } else { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
123 layer.shapes.push(shape); |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
124 renderShapes(data, layer); |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
125 } |
1241 | 126 }, |
1354 | 127 |
1241 | 128 /** |
129 * get vector object (shape) by id. | |
130 * | |
131 * @param data | |
132 * @param id | |
1244
8cb0faad875a
interactive creation of vector lines and rectangles.
robcast
parents:
1241
diff
changeset
|
133 * @returns shape |
1241 | 134 */ |
1355 | 135 getShapeById : function (data, id, layer) { |
1308 | 136 if (layer == null) { |
137 // assume shape layer is 0 | |
138 layer = data.vectorLayers[0]; | |
139 } | |
140 var shapes = layer.shapes; | |
1241 | 141 if (shapes == null) return null; |
142 for (var i in shapes) { | |
143 if (shapes[i].id === id) { | |
144 return shapes[i]; | |
145 } | |
146 } | |
147 return null; | |
148 }, | |
1354 | 149 |
1241 | 150 /** |
151 * remove vector object (shape) by id. | |
152 * | |
153 * @param data | |
154 * @param id | |
155 */ | |
1355 | 156 removeShapeById : function (data, id, layer) { |
1308 | 157 if (layer == null) { |
158 // assume shape layer is 0 | |
159 layer = data.vectorLayers[0]; | |
160 } | |
161 var shapes = layer.shapes; | |
162 if (shapes == null) return; | |
1323 | 163 for (var i = 0; i < shapes.length; ++i) { |
1241 | 164 if (shapes[i].id === id) { |
165 shapes.splice(i, 1); | |
166 } | |
167 } | |
1308 | 168 renderShapes(data, layer); |
1261 | 169 }, |
1354 | 170 |
1261 | 171 /** |
172 * add vector layer. | |
173 * | |
1265
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
174 * Layer is an object with a "projection" member. |
1261 | 175 * projection can be "relative": relative (0..1) coordinates, |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
176 * "screen": on-screen coordinates (needs renderFn(data, layer)). |
1265
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
177 * A SVG layer is specified by the jQuery-HTML element "$elem" and the SVG-element "svgElem". |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
178 * |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
179 * layer : { |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
180 * projection : relative, |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
181 * $elem : $(...), |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
182 * svgElem : ... |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
183 * } |
1261 | 184 * |
185 * @param date | |
186 * @param layer | |
187 */ | |
188 addVectorLayer : function (data, layer) { | |
1265
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
189 if (layer.projection === 'relative') { |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
190 var svg = layer.svgElem; |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
191 // set defaults for SVG in relative coordinates |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
192 svg.setAttributeNS(null, 'viewBox', '0 0 1 1'); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
193 svg.setAttributeNS(null, 'preserveAspectRatio', 'none'); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
194 var $elem = layer.$elem; |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
195 // set defaults for HTML element |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
196 $elem.css({'position':'absolute', 'z-index': 9, 'pointer-events':'none'}); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
197 $elem.addClass(data.settings.cssPrefix+'overlay'); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
198 } |
1306 | 199 // add layer |
200 data.vectorLayers.push(layer); | |
201 renderLayers(data); | |
1261 | 202 } |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
203 }; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
204 |
1260 | 205 /** |
206 * plugin installation routine, called by digilib on each plugin object. | |
207 */ | |
1355 | 208 var install = function (plugin) { |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
209 digilib = plugin; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
210 console.debug('installing vector plugin. digilib:', digilib); |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
211 // import geometry classes |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
212 geom = digilib.fn.geometry; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
213 // add defaults, actions, buttons to the main digilib object |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
214 $.extend(digilib.defaults, defaults); |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
215 $.extend(digilib.actions, actions); |
1304 | 216 // export functions |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
217 $.extend(digilib.fn, { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
218 vectorDefaultRenderFn: renderShapes, |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
219 svgElement: svgElement, |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
220 svgAttr: svgAttr, |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
221 createScreenCoords: createScreenCoords, |
1584
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
222 startShapeEdit: startShapeEdit, |
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
223 undoShapeEdit: undoShapeEdit, |
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
224 finishShapeEdit: finishShapeEdit, |
1556 | 225 redrawShape: redrawShape |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
226 }); |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
227 }; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
228 |
1260 | 229 /** |
230 * plugin initialization | |
231 */ | |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
232 var init = function (data) { |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
233 console.debug('initialising vector plugin. data:', data); |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
234 var $data = $(data); |
1261 | 235 // create default shapes layer |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
236 var shapeLayer = { |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
237 'projection': 'screen', |
1304 | 238 'renderFn': renderShapes, |
239 'shapes': [] | |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
240 }; |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
241 // shapes layer is first |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
242 data.vectorLayers = [shapeLayer]; |
1355 | 243 // pluggable SVG create functions |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
244 data.shapeFactory = getShapeFactory(data); |
1354 | 245 setupHandleFactory(data); |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
246 // install event handlers |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
247 $data.bind('update', handleUpdate); |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
248 }; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
249 |
1260 | 250 /** |
251 * handle update event | |
252 */ | |
253 var handleUpdate = function (evt) { | |
254 console.debug("vector: handleUpdate"); | |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
255 var data = this; |
1261 | 256 if (data.imgTrafo == null || !data.settings.isVectorActive) return; |
257 if (data.imgTrafo != data._vectorImgTrafo) { | |
258 // imgTrafo changed -- redraw | |
259 renderLayers(data); | |
260 // save new imgTrafo | |
261 data._vectorImgTrafo = data.imgTrafo; | |
1260 | 262 } |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
263 }; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
264 |
1251 | 265 /** |
1261 | 266 * render all layers on screen |
267 */ | |
1355 | 268 var renderLayers = function (data) { |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
269 if (data.imgRect == null) |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
270 return; |
1310 | 271 for (var i in data.vectorLayers) { |
1261 | 272 var layer = data.vectorLayers[i]; |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
273 if (layer.projection === 'screen') { |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
274 // screen layers have render function |
1361
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
275 if (layer.renderFn == null) { |
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
276 // user renderShapes as default |
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
277 layer.renderFn = renderShapes; |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
278 } |
1361
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
279 layer.renderFn(data, layer); |
1261 | 280 } else if (layer.projection === 'relative') { |
1265
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
281 var svg = layer.svgElem; |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
282 if (svg != null) { |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
283 // set current viewBox (jQuery lowercases attributes) |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
284 svg.setAttribute('viewBox', data.zoomArea.getAsSvg()); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
285 } |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
286 var $elem = layer.$elem; |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
287 if ($elem != null) { |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
288 // adjust layer element size and position (doesn't work with .adjustDiv()) |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
289 $elem.css(data.imgRect.getAsCss()); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
290 $elem.show(); |
cc1decb4c941
loading additional (relative coordinate) SVG layers works now.
robcast
parents:
1263
diff
changeset
|
291 } |
1261 | 292 } |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
293 } |
1261 | 294 }; |
1354 | 295 |
1261 | 296 /** |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
297 * render all shapes on the layer. |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
298 * |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
299 * @param data |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
300 * @param layer |
1251 | 301 */ |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
302 var renderShapes = function (data, layer) { |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
303 if (layer == null) { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
304 // assume shape layer is 0 |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
305 layer = data.vectorLayers[0]; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
306 } |
1304 | 307 var shapes = layer.shapes || data.shapes; |
308 if (shapes == null || data.imgTrafo == null || !data.settings.isVectorActive) | |
1249 | 309 return; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
310 // set up shapes |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
311 for (var i = 0; i < shapes.length; ++i) { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
312 var shape = shapes[i]; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
313 data.shapeFactory[shape.geometry.type].setup(data, shape); |
1546 | 314 // console.debug('render', shape); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
315 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
316 // sort shapes by size descending |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
317 shapes.sort(function (a, b) { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
318 return (b.properties.sorta - a.properties.sorta); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
319 }); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
320 // set up SVG |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
321 var $svg = layer.$elem; |
1261 | 322 if ($svg != null) { |
323 $svg.remove(); | |
1244
8cb0faad875a
interactive creation of vector lines and rectangles.
robcast
parents:
1241
diff
changeset
|
324 } |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
325 var svgElem = svgElement('svg', { |
1253 | 326 'viewBox': data.imgRect.getAsSvg(), |
1261 | 327 'class': data.settings.cssPrefix+'overlay', |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
328 'style': 'position:absolute; z-index:10; pointer-events:none;'}); |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
329 $svg = $(svgElem); |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
330 layer.svgElem = svgElem; |
1347
668a62a873b2
store screen positions on drag; trigger positionShape event
hertzhaft
parents:
1344
diff
changeset
|
331 layer.$elem = $svg; |
1304 | 332 for (var i = 0; i < shapes.length; ++i) { |
333 var shape = shapes[i]; | |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
334 renderShape(data, shape, layer); |
1239 | 335 } |
336 data.$elem.append($svg); | |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
337 // adjust layer element size and position (doesn't work with .adjustDiv()) |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
338 $svg.css(data.imgRect.getAsCss()); |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
339 $svg.show(); |
1239 | 340 }; |
1353 | 341 |
342 /** | |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
343 * set standard SVG attributes |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
344 * |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
345 * @param data |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
346 */ |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
347 var svgAttr = function (data, shape) { |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
348 var settings = data.settings; |
1545 | 349 var css = settings.cssPrefix; |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
350 var props = shape.properties; |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
351 return { |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
352 'id': shape.id || digilib.fn.createId(shape.id, css+'svg-'), |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
353 'stroke': props['stroke'] || settings.defaultStroke, |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
354 'stroke-width' : props['stroke-width'] || settings.defaultStrokeWidth, |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
355 'fill' : props['fill'] || settings.defaultFill, |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
356 'class' : props['cssclass'], |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
357 'style' : props['style'] |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
358 }; |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
359 }; |
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
360 /** |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
361 * setup Shape SVG creation functions |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
362 * (more functions can be plugged into data.settings.ShapeFactory) |
1355 | 363 * |
364 * @param data | |
365 */ | |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
366 var getShapeFactory = function (data) { |
1355 | 367 var settings = data.settings; |
368 var hs = settings.editHandleSize; | |
369 var factory = { | |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
370 'Point' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
371 'setup' : function (data, shape) { |
1390 | 372 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
373 shape.properties.maxvtx = 1; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
374 shape.properties.sorta = 0; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
375 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
376 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
377 var $s = $(svgElement('path', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
378 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
379 // point uses pin-like path of size 3*pu |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
380 var p = shape.properties.screenpos[0]; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
381 var pu = hs / 3; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
382 this.attr({'d': 'M '+p.x+','+p.y+' l '+2*pu+','+pu+' c '+2*pu+','+pu+' '+0+','+3*pu+' '+(-pu)+','+pu+' Z'}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
383 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
384 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
385 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
386 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
387 'Line' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
388 'setup' : function (data, shape) { |
1390 | 389 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
390 shape.properties.maxvtx = 2; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
391 shape.properties.bbox = getBboxRect(data, shape); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
392 shape.properties.sorta = 0; |
1355 | 393 }, |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
394 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
395 var $s = $(svgElement('line', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
396 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
397 var p = shape.properties.screenpos; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
398 this.attr({'x1': p[0].x, 'y1': p[0].y, 'x2': p[1].x, 'y2': p[1].y}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
399 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
400 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
401 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
402 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
403 'Rectangle' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
404 'setup' : function (data, shape) { |
1390 | 405 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
406 shape.properties.maxvtx = 2; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
407 shape.properties.bbox = getBboxRect(data, shape); |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
408 if (shape.properties.bbox != null) { |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
409 shape.properties.sorta = shape.properties.bbox.getArea(); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
410 } |
1355 | 411 }, |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
412 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
413 var $s = $(svgElement('rect', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
414 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
415 var p = shape.properties.screenpos; |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
416 var r = new geom.Rectangle(p[0], p[1]); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
417 this.attr({'x': r.x, 'y': r.y, 'width': r.width, 'height': r.height}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
418 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
419 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
420 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
421 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
422 'Polygon' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
423 'setup' : function (data, shape) { |
1390 | 424 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
425 shape.properties.bbox = getBboxRect(data, shape); |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
426 if (shape.properties.bbox != null) { |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
427 shape.properties.sorta = shape.properties.bbox.getArea(); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
428 } |
1355 | 429 }, |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
430 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
431 var $s = $(svgElement('polygon', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
432 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
433 var p = shape.properties.screenpos; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
434 this.attr({'points': p.join(" ")}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
435 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
436 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
437 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
438 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
439 'LineString' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
440 'setup' : function (data, shape) { |
1390 | 441 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
442 shape.properties.bbox = getBboxRect(data, shape); |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
443 if (shape.properties.bbox != null) { |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
444 shape.properties.sorta = shape.properties.bbox.getArea(); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
445 } |
1355 | 446 }, |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
447 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
448 var $s = $(svgElement('polyline', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
449 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
450 var p = shape.properties.screenpos; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
451 this.attr({'points': p.join(" ")}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
452 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
453 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
454 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
455 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
456 'Circle' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
457 'setup' : function (data, shape) { |
1390 | 458 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
459 shape.properties.maxvtx = 2; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
460 // TODO: bbox not really accurate |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
461 shape.properties.bbox = getBboxRect(data, shape); |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
462 if (shape.properties.bbox != null) { |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
463 shape.properties.sorta = shape.properties.bbox.getArea(); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
464 } |
1355 | 465 }, |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
466 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
467 var $s = $(svgElement('circle', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
468 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
469 var p = shape.properties.screenpos; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
470 this.attr({'cx': p[0].x, 'cy': p[0].y, 'r': p[0].distance(p[1])}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
471 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
472 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
473 } |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
474 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
475 'Ellipse' : { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
476 'setup' : function (data, shape) { |
1390 | 477 if (shape.properties == null) shape.properties = {}; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
478 shape.properties.maxvtx = 2; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
479 // TODO: bbox not really accurate |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
480 shape.properties.bbox = getBboxRect(data, shape); |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
481 if (shape.properties.bbox != null) { |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
482 shape.properties.sorta = shape.properties.bbox.getArea(); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
483 } |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
484 }, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
485 'svg' : function (shape) { |
1544
020739227ffd
measure plugin: define the event interactor element for composite svg elements
hertzhaft
parents:
1538
diff
changeset
|
486 var $s = $(svgElement('ellipse', svgAttr(data, shape))); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
487 $s.place = function () { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
488 var p = shape.properties.screenpos; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
489 this.attr({'cx': p[0].x, 'cy': p[0].y, |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
490 'rx' : Math.abs(p[0].x - p[1].x), |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
491 'ry' : Math.abs(p[0].y - p[1].y)}); |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
492 }; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
493 return $s; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
494 } |
1355 | 495 } |
496 }; | |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
497 |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
498 return factory; |
1355 | 499 }; |
500 | |
501 /** | |
1354 | 502 * setup handle creation functions |
503 * (more functions can be plugged into data.settings.handleFactory) | |
1353 | 504 * |
1354 | 505 * @param data |
1353 | 506 */ |
1354 | 507 var setupHandleFactory = function (data) { |
508 var settings = data.settings; | |
509 var css = settings.cssPrefix; | |
510 var hs = settings.editHandleSize; | |
1353 | 511 var d = hs/2; |
1354 | 512 var attr = { |
513 'stroke': 'darkgrey', | |
514 'stroke-width': 1, | |
515 'fill': 'none', | |
516 'class': css+'svg-handle', | |
517 'style': 'pointer-events:all' | |
1353 | 518 }; |
1354 | 519 var factory = { |
1355 | 520 'square' : function () { |
1354 | 521 var $h = $(svgElement('rect', attr)); |
522 $h.attr({'width': hs, 'height': hs}); | |
1355 | 523 $h.moveTo = function (p) { |
1537 | 524 this.attr({'x': p.x-d, 'y': p.y-d}); |
525 }; | |
526 return $h; | |
527 }, | |
528 'circle' : function () { | |
529 var $h = $(svgElement('circle', attr)); | |
530 $h.moveTo = function (p) { | |
531 this.attr({'cx': p.x, 'cy': p.y, 'r': d}); | |
1354 | 532 }; |
533 return $h; | |
534 }, | |
1355 | 535 'diamond' : function () { |
1354 | 536 var $h = $(svgElement('polygon', attr)); |
1355 | 537 $h.moveTo = function (p) { |
1354 | 538 this.attr('points', (p.x-d) +','+ p.y+ ' '+p.x +','+(p.y+d)+' '+(p.x+d)+','+p.y+' '+p.x+','+(p.y-d)); |
539 }; | |
540 return $h; | |
541 }, | |
1355 | 542 'cross' : function () { |
1354 | 543 var $h = $(svgElement('path', attr)); |
1355 | 544 $h.moveTo = function (p) { |
1354 | 545 this.attr('d', 'M'+(p.x-d) +','+ p.y+ ' L'+(p.x+d)+','+p.y+' M'+p.x+','+(p.y+d)+' L'+p.x+','+(p.y-d)); |
546 }; | |
547 return $h; | |
548 } | |
1353 | 549 }; |
1354 | 550 data.handleFactory = factory; |
1353 | 551 }; |
552 | |
553 /** | |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
554 * add adjustment handles to a shape. |
1353 | 555 * |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
556 * Creates a SVG element for each screen point and append them to the SVG element. |
1353 | 557 * |
558 * @param data | |
559 * @param shape | |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
560 * @param layer |
1353 | 561 */ |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
562 var addEditHandles = function (data, shape, layer) { |
1354 | 563 var $svg = $(layer.svgElem); |
1353 | 564 var trafo = data.imgTrafo; |
1556 | 565 // type of handle can be stated in layer or in settings |
566 var type = layer.handleType || data.settings.editHandleType; | |
1354 | 567 var handles = []; |
1556 | 568 var createHandle = data.handleFactory[type]; |
569 var insertHandle = function (i, item) { | |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
570 var p = trafo.transform(new geom.Position(item)); |
1556 | 571 var $handle = createHandle(); |
1585 | 572 $handle.data('vertex', i); |
1354 | 573 $handle.moveTo(p); |
574 handles.push($handle); | |
1353 | 575 $svg.append($handle); |
1354 | 576 return $handle; |
1353 | 577 }; |
1556 | 578 $.each(shape.geometry.coordinates, insertHandle); |
1354 | 579 shape.$vertexElems = handles; |
1556 | 580 // not needed? |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
581 var done = function (data, shape, evt) { |
1556 | 582 redrawShape(data, shape, layer); |
583 }; | |
584 // vertexElems must be defined before calling getVertexDragHandler() | |
1354 | 585 var attachEvent = function (i, item) { |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
586 item.one("mousedown.dlVertexDrag", getVertexDragHandler(data, shape, i, done)); |
1354 | 587 }; |
588 $.each(handles, attachEvent); | |
589 }; | |
1353 | 590 |
591 /** | |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
592 * remove SVG adjustment handles from a shape. |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
593 * |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
594 * @param data |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
595 * @param shape |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
596 */ |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
597 var removeEditHandles = function (data, shape) { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
598 // remove vertex handles |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
599 if (shape.$vertexElems != null) { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
600 for (var i = 0; i < shape.$vertexElems.length; ++i) { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
601 shape.$vertexElems[i].remove(); |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
602 } |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
603 delete shape.$vertexElems; |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
604 } |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
605 }; |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
606 |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
607 /** |
1582 | 608 * make shape editable, add handles and events |
609 * | |
610 * @param data | |
611 * @param shape | |
612 */ | |
1584
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
613 var startShapeEdit = function (data, shape) { |
1582 | 614 shape.properties.editable = true; |
615 shape.savecoords = shape.geometry.coordinates.slice(0); // clone coords | |
616 redrawShape(data, shape); | |
617 }; | |
618 | |
619 /** | |
620 * end editing shape | |
621 * | |
622 * @param data | |
623 * @param shape | |
624 */ | |
1584
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
625 var finishShapeEdit = function (data, shape) { |
1582 | 626 shape.properties.editable = false; |
627 redrawShape(data, shape); | |
628 }; | |
629 | |
630 /** | |
631 * restore edited shape to previous state | |
632 * | |
633 * @param data | |
634 * @param shape | |
635 */ | |
1584
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
636 var undoShapeEdit = function (data, shape) { |
1582 | 637 shape.geometry.coordinates = shape.savecoords; |
1584
817a5c42cb1b
annotator plugin: render annotations only on store event, include annotation data created on storage (e.g. id)
hertzhaft
parents:
1582
diff
changeset
|
638 finishShapeEdit(data, shape); |
1585 | 639 }; |
640 | |
641 /** | |
642 * shape has a polygon type | |
643 * | |
644 * @param shape | |
645 */ | |
646 var hasPolygonType = function (shape) { | |
647 var type = shape.geometry.type; | |
648 return (type === 'Polygon' || type === 'LineString'); | |
649 }; | |
650 | |
651 /** | |
652 * activate polygon edit (add/remove points) | |
653 * | |
654 * @param data | |
655 * @param shape | |
656 */ | |
657 var enablePolygonEdit = function (data, shape) { | |
658 var $w = polygonPointWidget(data); | |
659 var onHandleMouseDown = function (event) { | |
660 $w.fadeOut(); | |
661 }; | |
662 var onHandleMouseLeave = function (event) { | |
663 $w.data.timer = setTimeout(onHandleMouseDown, 500); | |
664 }; | |
665 var onHandleMouseEnter = function (event) { | |
666 $w.data({ vertex: $(this).data('vertex'), shape: shape, timer: false }); | |
667 $w.fadeIn().offset({ | |
668 left : event.pageX + 5, | |
669 top : event.pageY + 5 | |
670 }); | |
671 }; | |
672 var addEventsToHandle = function(i, $handle) { | |
673 $handle | |
674 .on('mouseenter.handle', onHandleMouseEnter) | |
675 .on('mouseleave.handle', onHandleMouseLeave) | |
676 .on('mousedown.handle', onHandleMouseDown); | |
677 }; | |
678 $.each(shape.$vertexElems, addEventsToHandle); | |
679 }; | |
680 | |
681 /** | |
682 * deactivate polygon edit (add/remove points) | |
683 * | |
684 * @param data | |
685 * @param shape | |
686 */ | |
687 var disablePolygonEdit = function (data) { | |
688 var $w = data.$polygonPointWidget; | |
689 if ($w == null) { | |
690 return; | |
691 } | |
692 $w.data({ vertex: null, shape: null, timer: false }); | |
693 $w.fadeOut(); | |
694 }; | |
695 | |
696 /** | |
697 * create HTML div to add/remove polygon points | |
698 * | |
699 * @param data | |
700 */ | |
701 var polygonPointWidget = function (data) { | |
702 var css = data.settings.cssPrefix; | |
703 var $w = data.$polygonPointWidget; | |
704 if ($w == null) { | |
705 // setup html | |
706 var html = '\ | |
707 <div id="'+css+'polygonPointWidget">\ | |
708 <div id="'+css+'iconplus"><div class="icon plus" /></div>\ | |
709 <div id="'+css+'iconminus"><div class="icon minus" /></div>\ | |
710 </div>'; | |
711 $w = $(html); | |
712 $w.appendTo(data.$elem); | |
713 // setup mouse bindings | |
714 var onPlusClick = function (event) { | |
715 var vertex = $w.data('vertex'); | |
716 var shape = $w.data('shape'); | |
717 var coords = shape.geometry.coordinates; | |
718 var v1 = parseInt(vertex) > 0 ? vertex-1 : coords.length-1; | |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
719 var pt = new geom.Position(coords[vertex]).mid(new geom.Position(coords[v1])); |
1585 | 720 console.debug('+ point', coords[vertex], pt); |
721 coords.splice(vertex, 0, pt); | |
722 redrawShape(data, shape); | |
723 }; | |
724 var onMinusClick = function (event) { | |
725 var vertex = $w.data('vertex'); | |
726 var shape = $w.data('shape'); | |
727 var coords = shape.geometry.coordinates; | |
728 if (vertex == null || coords.length < 4) { return; } | |
729 console.debug('- point', coords[vertex]); | |
730 coords.splice(vertex, 1); | |
731 redrawShape(data, shape); | |
732 }; | |
733 var onEnter = function (event) { | |
734 clearTimeout($w.data.timer); | |
735 }; | |
736 var onLeave = function (event) { | |
737 $w.fadeOut(); | |
738 }; | |
739 var $plus = $w.children().first(); | |
740 var $minus = $w.children().last(); | |
741 $plus.on('click', onPlusClick); | |
742 $minus.on('click', onMinusClick); | |
743 $w.on('mouseenter', onEnter).on('mouseleave', onLeave); | |
744 data.$polygonPointWidget = $w; | |
745 } | |
746 return $w; | |
747 }; | |
1582 | 748 |
749 /** | |
1353 | 750 * calculate screen positions from coordinates for a shape. |
751 * | |
752 * @param data | |
753 * @param shape | |
754 */ | |
755 var createScreenCoords = function (data, shape) { | |
756 var coords = shape.geometry.coordinates; | |
757 var trafo = data.imgTrafo; | |
1355 | 758 var screenpos = $.map(coords, function (coord) { |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
759 return trafo.transform(new geom.Position(coord)); |
1353 | 760 }); |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
761 if (shape.properties == null) { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
762 shape.properties = {}; |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
763 } |
1353 | 764 shape.properties.screenpos = screenpos; |
765 return screenpos; | |
766 }; | |
767 | |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
768 var getBboxRect = function (data, shape) { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
769 var coords = shape.geometry.coordinates; |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
770 if (coords == null) return null; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
771 var xmin = 1; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
772 var xmax = 0; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
773 var ymin = 1; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
774 var ymax = 0; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
775 var x, y; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
776 for (var i = 0; i < coords.length; ++i) { |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
777 x = coords[i][0]; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
778 y = coords[i][1]; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
779 xmin = (x < xmin) ? x : xmin; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
780 xmax = (x > xmax) ? x : xmax; |
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
781 ymin = (y < ymin) ? y : ymin; |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
782 ymax = (y > ymax) ? y : ymax; |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
783 } |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
784 return new geom.Rectangle(xmin, ymin, xmax-xmin, ymax-ymin); |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
785 }; |
1556 | 786 |
1253 | 787 /** |
788 * render a shape on screen. | |
789 * | |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
790 * Creates a SVG element and adds it to the layer. |
1260 | 791 * Puts a reference $elem in the shape object. |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
792 * |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
793 * @param data |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
794 * @param shape |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
795 * @param layer |
1253 | 796 */ |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
797 var renderShape = function (data, shape, layer) { |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
798 // make sure we have a SVG element |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
799 if (layer.svgElem == null) { |
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
800 renderShapes(data, layer); |
1312
444c5e250a4c
vector plugin sends renderShape event when shapes are (re)rendered into SVG elements.
robcast
parents:
1310
diff
changeset
|
801 return; |
1253 | 802 } |
1356 | 803 var shapeType = shape.geometry.type; |
1357
c176dca2b62b
added Proportion shape (LineString with only 3 vertices)
hertzhaft
parents:
1356
diff
changeset
|
804 if (!isSupported(data, shapeType)) { |
1356 | 805 console.error("renderShape: unsupported shape type: "+shapeType); |
806 return; | |
807 } | |
1355 | 808 // create the SVG |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
809 var $elem = data.shapeFactory[shapeType].svg(shape); |
1556 | 810 // let shape know where it is rendered |
1353 | 811 shape.$elem = $elem; |
1556 | 812 shape.layer = layer; |
1356 | 813 // place the SVG on screen |
1355 | 814 createScreenCoords(data, shape); |
815 $elem.place(); | |
816 // render the SVG | |
817 $(layer.svgElem).append($elem); | |
1556 | 818 // add adjustment handles |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
819 if (shape.properties.editable) { |
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
820 addEditHandles(data, shape, layer); |
1585 | 821 if (hasPolygonType(shape) && data.settings.editPolygonPoints) { |
822 enablePolygonEdit(data, shape); | |
823 } | |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
824 } |
1312
444c5e250a4c
vector plugin sends renderShape event when shapes are (re)rendered into SVG elements.
robcast
parents:
1310
diff
changeset
|
825 $(data).trigger("renderShape", shape); |
1253 | 826 }; |
827 | |
1303 | 828 /** |
829 * remove rendered shape from screen. | |
830 * | |
831 * Removes the SVG elements from the layer. | |
832 * | |
833 * @param data | |
834 * @param shape | |
835 */ | |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
836 var unrenderShape = function (data, shape) { |
1538
747ed0af8663
annotations: some refactoring in shape creation; enable shape editing
hertzhaft
parents:
1537
diff
changeset
|
837 removeEditHandles(data, shape); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
838 // remove SVG element |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
839 if (shape.$elem != null) { |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
840 shape.$elem.remove(); |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
841 delete shape.$elem; |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
842 } |
1585 | 843 if (hasPolygonType(shape) && data.settings.editPolygonPoints) { |
844 disablePolygonEdit(data); | |
845 } | |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
846 }; |
1351
76b72fa16012
immediate reaction on when dragging and keys x or y are pressed
hertzhaft
parents:
1350
diff
changeset
|
847 |
1260 | 848 /** |
1556 | 849 * re-render a shape. |
850 * | |
851 * Removes the SVG element from layer and renders the (updated) shape again. | |
852 * | |
853 * @param data | |
854 * @param shape | |
855 * @param layer | |
856 */ | |
857 var redrawShape = function (data, shape, layer) { | |
858 unrenderShape(data, shape); | |
859 renderShape(data, shape, layer || shape.layer); | |
860 }; | |
861 | |
862 /** | |
1260 | 863 * return a vertexDragHandler function. |
864 * | |
865 * @param data | |
866 * @param shape shape to drag | |
867 * @param vtx vertex number on shape | |
1355 | 868 * @onComplete function (data, shape) |
1260 | 869 */ |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
870 var getVertexDragHandler = function (data, shape, vtx, onComplete) { |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
871 var $document = $(document); |
1368 | 872 var imgRect = data.imgRect; |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
873 var $shape = shape.$elem; |
1361
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
874 var $handle = (shape.$vertexElems != null) ? shape.$vertexElems[vtx] : null; |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
875 var shapeType = shape.geometry.type; |
1368 | 876 var props = shape.properties; |
877 var pos = props.screenpos; | |
1356 | 878 var pStart; // save startpoint |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
879 |
1368 | 880 var placeHandle = function (i, $handle) { |
881 $handle.moveTo(pos[i]); | |
882 }; | |
883 | |
884 var placeHandles = function () { | |
885 $.each(shape.$vertexElems, placeHandle); | |
886 }; | |
887 | |
1342 | 888 var dragStart = function (evt) { // start dragging |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
889 // cancel if not left-click |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
890 if (evt.which != 1) return; |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
891 pStart = new geom.Position(evt); |
1368 | 892 props.startpos = pStart; |
893 props.vtx = vtx; | |
1347
668a62a873b2
store screen positions on drag; trigger positionShape event
hertzhaft
parents:
1344
diff
changeset
|
894 $(data).trigger('positionShape', shape); |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
895 $document.on("mousemove.dlVertexDrag", dragMove); |
1337 | 896 $document.on("mouseup.dlVertexDrag", dragEnd); |
897 $document.on("dblclick.dlVertexDrag", dragEnd); | |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
898 return false; |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
899 }; |
1337 | 900 |
1342 | 901 var dragMove = function (evt) { // dragging |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
902 var pt = new geom.Position(evt); |
1351
76b72fa16012
immediate reaction on when dragging and keys x or y are pressed
hertzhaft
parents:
1350
diff
changeset
|
903 pt.clipTo(imgRect); |
1384 | 904 pos[vtx].moveTo(pt); |
1344
3ec94ec07930
toggle SVG and key handler according to visibility of measure bar
hertzhaft
parents:
1342
diff
changeset
|
905 if (isSupported(data, shapeType)) { |
1384 | 906 // trigger drag event (may manipulate screen position) |
907 $(data).trigger('positionShape', shape); | |
908 // update vertex coords of shape | |
909 shape.geometry.coordinates[vtx] = data.imgTrafo.invtransform(pos[vtx]).toArray(); | |
1356 | 910 // update shape SVG element |
1361
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
911 $shape.place(); |
1368 | 912 // move handles accordingly |
1376 | 913 if (shape.$vertexElems != null) placeHandles(); |
1337 | 914 $(data).trigger('dragShape', shape); |
915 } | |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
916 return false; |
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
917 }; |
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
918 |
1342 | 919 var dragEnd = function (evt) { // end dragging |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
920 var pt = new geom.Position(evt); |
1342 | 921 if ((pt.distance(pStart) < 5) && evt.type === 'mouseup') { |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
922 // not drag but click to start |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
923 return false; |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
924 } |
1356 | 925 dragMove(evt); |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
926 // remove move/end handler |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
927 $document.off("mousemove.dlVertexDrag", dragMove); |
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
928 $document.off("mouseup.dlVertexDrag", dragEnd); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
929 $document.off("dblclick.dlVertexDrag", dragEnd); |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
930 // call setup to update bbox |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
931 data.shapeFactory[shapeType].setup(data, shape); |
1258 | 932 // rearm start handler |
1361
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
933 if ($handle != null) { |
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
934 $handle.one("mousedown.dlVertexDrag", dragStart); |
ddc086449463
fix bug with defineShape if shape is non-editable (no handles). automatically use renderShapes as default renderFn.
robcast
parents:
1360
diff
changeset
|
935 } |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
936 if (onComplete != null) { |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
937 onComplete(data, shape, evt); |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
938 } else { |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
939 $(data).trigger('changeShape', shape); |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
940 } |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
941 return false; |
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
942 }; |
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
943 |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
944 // return drag start handler |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
945 return dragStart; |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
946 }; |
1337 | 947 |
1338 | 948 |
949 /** | |
950 * returns true if shapeType is supported | |
951 * | |
952 * @param shapeType shapeType to test | |
953 */ | |
1355 | 954 var isSupported = function (data, shapeType) { |
1386
d8beafc1df41
sort image areas by size so that smaller areas are not eclipsed by bigger ones.
robcast
parents:
1384
diff
changeset
|
955 return data.shapeFactory[shapeType] != null; |
1338 | 956 }; |
957 | |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
958 /** |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
959 * define a shape by click and drag. |
1260 | 960 * |
961 * The given shape object has to have a type, but its coordinates will be overwritten. | |
962 * | |
963 * @param data | |
964 * @param shape the shape to define | |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
965 * @param layer the layer to draw on |
1355 | 966 * @onComplete function (data, shape) |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
967 */ |
1355 | 968 var defineShape = function (data, shape, layer, onComplete) { |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
969 var shapeType = shape.geometry.type; |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
970 // call setup to make sure maxvtx is set |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
971 data.shapeFactory[shapeType].setup(data, shape); |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
972 var $elem = data.$elem; |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
973 var $body = $('body'); |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
974 var bodyRect = new geom.Rectangle($body); |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
975 // overlay div prevents other elements from reacting to mouse events |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
976 var $overlayDiv = $('<div class="'+data.settings.cssPrefix+'shapeOverlay" style="position:absolute; z-index:100;"/>'); |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
977 $elem.append($overlayDiv); |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
978 bodyRect.adjustDiv($overlayDiv); |
1342 | 979 |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
980 var shapeStart = function (evt) { |
1610
f425f00bf5e3
changed digilib.geometry to use new and prototypes instead of adding methods to objects.
robcast
parents:
1585
diff
changeset
|
981 var pt = new geom.Position(evt); |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
982 // setup shape |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
983 var p1 = data.imgTrafo.invtransform(pt).toArray(); |
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
984 var p2 = p1.slice(0); |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
985 var vtx = 1; |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
986 if (shapeType === 'Point') { |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
987 shape.geometry.coordinates = [p1]; |
1344
3ec94ec07930
toggle SVG and key handler according to visibility of measure bar
hertzhaft
parents:
1342
diff
changeset
|
988 } else if (isSupported(data, shapeType)) { |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
989 shape.geometry.coordinates = [p1, p2]; |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
990 } else { |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
991 console.error("defineShape: unsupported shape type: "+shapeType); |
1258 | 992 $overlayDiv.remove(); |
993 return false; | |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
994 } |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
995 // shape is not editable by default |
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
996 if (shape.properties == null) { |
1303 | 997 shape.properties = {'editable' : false}; |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
998 } |
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
999 // save first mousedown position |
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1000 shape.properties.screenpos = [pt]; |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
1001 shape.properties.vtx = vtx; |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
1002 // draw shape |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
1003 renderShape(data, shape, layer); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1004 // vertex drag end handler |
1323 | 1005 var vertexDragDone = function (data, shape, evt) { |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1006 var coords = shape.geometry.coordinates; |
1356 | 1007 var max = shape.properties.maxvtx; |
1008 if (max == null || vtx < max-1) { | |
1009 // multipoint shape (e. g. Polygon, LineString) | |
1323 | 1010 if (evt.type === 'mouseup') { |
1356 | 1011 // single click adds next point |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1012 unrenderShape(data, shape); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1013 // copy last vertex as starting point |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1014 coords.push(coords[vtx].slice()); |
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1015 vtx += 1; |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1016 // draw shape |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
1017 shape.properties.vtx = vtx; |
1337 | 1018 renderShape(data, shape, layer); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1019 // execute vertex drag handler on next vertex |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1020 getVertexDragHandler(data, shape, vtx, vertexDragDone)(evt); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1021 return false; |
1323 | 1022 } else if (evt.type === 'dblclick') { |
1356 | 1023 // double click ends multipoint shape |
1024 var rerender = false; | |
1323 | 1025 // remove duplicate vertices (from mouseup) |
1356 | 1026 while (coords[vtx][0] === coords[vtx-1][0] && |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1027 coords[vtx][1] === coords[vtx-1][1]) { |
1323 | 1028 coords.pop(); |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1029 vtx -= 1; |
1323 | 1030 rerender = true; |
1031 } | |
1032 if (rerender) { | |
1359
647bd1686fa6
added Rect shape (rectangle drawn from a base line)
hertzhaft
parents:
1358
diff
changeset
|
1033 shape.properties.vtx = vtx; |
1556 | 1034 redrawShape(data, shape, layer); |
1303 | 1035 } |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1036 } else { |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1037 console.error("unknown event type!"); |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1038 return false; |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1039 } |
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1040 } |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1041 shapeDone(data, shape); |
1302
fe413f88f3b6
linestring and polygon can now be created interactively with defineShape. doubleclick to end shape.
robcast
parents:
1282
diff
changeset
|
1042 }; |
1356 | 1043 if (vtx === shape.properties.maxvtx) { |
1044 // last vertex | |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1045 shapeDone(data, shape); |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1046 } else { |
1356 | 1047 // execute vertex drag handler on next vertex |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1048 getVertexDragHandler(data, shape, vtx, vertexDragDone)(evt); |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1049 } |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
1050 return false; |
1258 | 1051 }; |
1353 | 1052 |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1053 var shapeDone = function (data, shape) { |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1054 // defining shape done |
1387
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
1055 unrenderShape(data, shape); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
1056 // call setup to update bbox |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
1057 data.shapeFactory[shapeType].setup(data, shape); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
1058 renderShape(data, shape, layer); |
2540222b6dfe
fixed bug with creating shapes that broke the measure tool.
robcast
parents:
1386
diff
changeset
|
1059 // save shape |
1317
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1060 layer.shapes.push(shape); |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1061 $overlayDiv.remove(); |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1062 if (onComplete != null) { |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1063 onComplete(data, shape); |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1064 } |
cac657d25ba9
use vector plugin defineShape method for annotation shapes.
robcast
parents:
1316
diff
changeset
|
1065 }; |
1352
d8271e1e9ce2
seems we need not save editable state when drawing a shape
hertzhaft
parents:
1351
diff
changeset
|
1066 |
1257
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
1067 // start by clicking |
4f8f960a4bea
createShape now uses vertexDragHandler too. vertex dragging also works with single clicks.
robcast
parents:
1255
diff
changeset
|
1068 $overlayDiv.one('mousedown.dlShape', shapeStart); |
1254
7410a158ca7b
vector shapes can be editable now (properties:{editable:true}).
robcast
parents:
1253
diff
changeset
|
1069 }; |
1339
8a0cdf624dc2
refactored the creation of drag handles for shapes
hertzhaft
parents:
1338
diff
changeset
|
1070 |
1253 | 1071 /** |
1260 | 1072 * create a SVG element with attributes. |
1073 * | |
1074 * @param name tag name | |
1075 * @param attrs object with attributes | |
1253 | 1076 */ |
1266
52aeee70d2af
fixed svg layer offset by updating imgRect more often.
robcast
parents:
1265
diff
changeset
|
1077 var svgElement = function (name, attrs) { |
1253 | 1078 var elem = document.createElementNS(svgNS, name); |
1079 if (attrs != null) { | |
1080 for (var att in attrs) { | |
1304 | 1081 if (attrs[att] != null) { |
1082 elem.setAttributeNS(null, att, attrs[att]); | |
1083 } | |
1253 | 1084 }; |
1085 } | |
1086 return elem; | |
1087 }; | |
1088 | |
1238
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1089 // plugin object, containing name, install and init routines |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1090 // all shared objects are filled by digilib on registration |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1091 var plugin = { |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1092 name : 'vector', |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1093 install : install, |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1094 init : init, |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1095 buttons : {}, |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1096 actions : {}, |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1097 fn : {}, |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1098 plugins : {} |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1099 }; |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1100 |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1101 if ($.fn.digilib == null) { |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1102 $.error("jquery.digilib.vector.js must be loaded after jquery.digilib!"); |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1103 } else { |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1104 $.fn.digilib('plugin', plugin); |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1105 } |
f863da95ed6e
working on new vector plugin for zoomable vector (SVG) overlays.
robcast
parents:
diff
changeset
|
1106 })(jQuery); |