1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2011 Association for Decentralized Information Management in
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.trend.impl;
\r
14 import java.awt.BasicStroke;
\r
15 import java.awt.Color;
\r
16 import java.awt.Font;
\r
17 import java.awt.Graphics2D;
\r
18 import java.awt.Rectangle;
\r
19 import java.awt.RenderingHints;
\r
20 import java.awt.font.GlyphVector;
\r
21 import java.awt.geom.Rectangle2D;
\r
22 import java.util.ArrayList;
\r
23 import java.util.Collections;
\r
24 import java.util.Comparator;
\r
25 import java.util.HashMap;
\r
26 import java.util.HashSet;
\r
27 import java.util.List;
\r
28 import java.util.Map;
\r
29 import java.util.Set;
\r
30 import java.util.TreeSet;
\r
32 import org.simantics.databoard.Bindings;
\r
33 import org.simantics.databoard.accessor.error.AccessorException;
\r
34 import org.simantics.databoard.binding.error.BindingException;
\r
35 import org.simantics.databoard.util.Bean;
\r
36 import org.simantics.g2d.utils.GridUtil;
\r
37 import org.simantics.history.Collector;
\r
38 import org.simantics.history.History;
\r
39 import org.simantics.history.HistoryException;
\r
40 import org.simantics.history.HistoryManager;
\r
41 import org.simantics.history.ItemManager;
\r
42 import org.simantics.history.impl.CollectorImpl;
\r
43 import org.simantics.history.util.Stream;
\r
44 import org.simantics.history.util.ValueBand;
\r
45 import org.simantics.scenegraph.g2d.G2DParentNode;
\r
46 import org.simantics.scenegraph.utils.QualityHints;
\r
47 import org.simantics.trend.configuration.ItemPlacement;
\r
48 import org.simantics.trend.configuration.LineQuality;
\r
49 import org.simantics.trend.configuration.Scale;
\r
50 import org.simantics.trend.configuration.TimeFormat;
\r
51 import org.simantics.trend.configuration.TimeWindow;
\r
52 import org.simantics.trend.configuration.TrendItem;
\r
53 import org.simantics.trend.configuration.TrendItem.Renderer;
\r
54 import org.simantics.trend.configuration.TrendQualitySpec;
\r
55 import org.simantics.trend.configuration.TrendSpec;
\r
56 import org.simantics.trend.configuration.Viewport;
\r
57 import org.simantics.trend.configuration.Viewport.AxisViewport;
\r
58 import org.simantics.trend.configuration.YAxisMode;
\r
59 import org.simantics.utils.format.ValueFormat;
\r
61 import gnu.trove.map.TObjectIntMap;
\r
62 import gnu.trove.map.hash.TObjectIntHashMap;
\r
63 import gnu.trove.procedure.TObjectProcedure;
\r
65 public class TrendNode extends G2DParentNode implements TrendLayout {
\r
67 private static final long serialVersionUID = -8339696405893626168L;
\r
70 public TextNode titleNode;
\r
74 public HorizRuler horizRuler;
\r
75 VertRuler vertRuler; // Selected vertical ruler, null if there are no analog items
\r
76 int vertRulerIndex; // Index of the selected vertical ruler
\r
77 List<VertRuler> vertRulers = new ArrayList<VertRuler>();
\r
78 SelectionNode selection;
\r
79 public MilestoneSpec milestones;
\r
81 /** Control bounds */
\r
82 Rectangle2D bounds = new Rectangle2D.Double();
\r
85 public TrendSpec spec;
\r
86 public ViewRenderingProfile renderingProfile = new ViewRenderingProfile();
\r
87 public TrendQualitySpec quality = TrendQualitySpec.DEFAULT;
\r
88 public boolean printing = false;
\r
92 List<ItemNode> analogItems = new ArrayList<ItemNode>();
\r
93 List<ItemNode> binaryItems = new ArrayList<ItemNode>();
\r
94 List<ItemNode> allItems = new ArrayList<ItemNode>();
\r
97 static HistoryManager DUMMY_HISTORY = History.createMemoryHistory();
\r
98 public HistoryManager historian = DUMMY_HISTORY;
\r
100 // Collector - set for flushing the stream, right before drawing
\r
101 public Collector collector = null;
\r
102 Set<String> itemIds = new HashSet<String>();
\r
104 // Signal to indicate history has changed.
\r
105 public boolean datadirty = false;
\r
106 // Signal to indicate the cached shapes are dirty. This will cause reloading of data.
\r
107 public boolean shapedirty = false;
\r
109 public boolean autoscaletime = true;
\r
111 public TimeFormat timeFormat = TimeFormat.Time;
\r
112 public ValueFormat valueFormat = ValueFormat.Default;
\r
113 public boolean drawSamples = false;
\r
115 /** Time at mouse, when mouse hovers over trend. This value is set by TrendParticipant. NaN is mouse is not hovering */
\r
116 public double mouseHoverTime = Double.NaN, lastMouseHoverTime = 0.0;
\r
118 /** If set, valueTip is drawn at the time */
\r
119 public Double valueTipTime = null, prevValueTipTime = null;
\r
120 public boolean valueTipHover = false;
\r
122 public ItemPlacement itemPlacement = ItemPlacement.Overlapping;
\r
125 public void init() {
\r
126 spec = new TrendSpec();
\r
129 milestones = new MilestoneSpec();
\r
132 //// Create title node
\r
133 titleNode = addNode( "Title", TextNode.class );
\r
134 titleNode.setFont( new Font("Arial", 0, 30) );
\r
135 titleNode.setColor( Color.BLACK );
\r
136 titleNode.setText( "<title here>");
\r
137 titleNode.setSize(300, 40);
\r
139 plot = addNode( "Plot", Plot.class );
\r
141 horizRuler = addNode("HorizRuler", HorizRuler.class);
\r
142 vertRuler = addNode("VertRuler", VertRuler.class);
\r
143 vertRulers.add( vertRuler );
\r
145 /// Set some bounds
\r
146 horizRuler.setFromEnd(0, 100);
\r
147 vertRuler.setMinMax(0, 100);
\r
152 * Set source of data
\r
154 * @param collector (Optional) Used for flushing collectors
\r
156 public void setHistorian(HistoryManager historian, Collector collector) {
\r
157 this.historian = historian==null?DUMMY_HISTORY:historian;
\r
158 this.collector = collector;
\r
160 ItemManager allFiles = ItemManager.createUnchecked( getHistoryItems() );
\r
161 for (ItemNode item : allItems) {
\r
162 item.setTrendItem(item.item, allFiles);
\r
163 for (Bean historyItem : item.historyItems ) {
\r
165 itemIds.add( (String) historyItem.getField("id") );
\r
166 } catch (BindingException e) {
\r
173 * Get info of all history items.
\r
174 * This util is created for polling strategy.
\r
178 Bean[] getHistoryItems() {
\r
179 Bean[] result = null;
\r
180 HistoryException e = null;
\r
181 for (int attempt=0; attempt<10; attempt++) {
\r
183 result = historian.getItems();
\r
185 } catch (HistoryException e2) {
\r
186 if (e==null) e = e2;
\r
189 } catch (InterruptedException e1) {
\r
193 if (result!=null) return result;
\r
194 //throw new RuntimeException(e);
\r
195 return new Bean[0];
\r
198 public void setMilestones(Bean milestones) {
\r
199 if (this.milestones.equals(milestones)) return;
\r
200 this.milestones.readFrom( milestones );
\r
201 boolean hasBaseline = this.milestones.baseline>=0;
\r
203 // Sort by first, put baseline on top
\r
204 final Milestone baseline = this.milestones.baseline>=0 ? this.milestones.milestones.get( this.milestones.baseline ) : null;
\r
205 Collections.sort(this.milestones.milestones, new Comparator<Milestone>() {
\r
206 public int compare(Milestone o1, Milestone o2) {
\r
207 if (o1==baseline) return -1;
\r
208 if (o2==baseline) return 1;
\r
209 return Double.compare(o1.time, o1.time);
\r
212 this.milestones.baseline = hasBaseline ? 0 : -1;
\r
213 double newBasetime = hasBaseline ? this.milestones.milestones.get(this.milestones.baseline).time : 0.;
\r
214 if (newBasetime != horizRuler.basetime) {
\r
215 horizRuler.basetime = newBasetime;
\r
216 horizRuler.layout();
\r
221 public void selectVertRuler(int index) {
\r
222 vertRulerIndex = index;
\r
223 if (index<0 || index>=vertRulers.size()) {
\r
224 vertRuler = vertRulers.get(0);
\r
226 vertRuler = vertRulers.get(index);
\r
232 public void cleanup() {
\r
233 spec = new TrendSpec();
\r
235 analogItems.clear();
\r
236 binaryItems.clear();
\r
238 historian = DUMMY_HISTORY;
\r
242 private static TObjectIntMap<String> itemIndexMap(List<TrendItem> items) {
\r
243 TObjectIntMap<String> map = new TObjectIntHashMap<>(items.size(), 0.5f, -1);
\r
244 for (int i = 0; i < items.size(); ++i) {
\r
245 TrendItem it = items.get(i);
\r
246 map.put(it.groupItemId, i);
\r
251 private static <T> TObjectIntMap<T> subtract(TObjectIntMap<T> a, TObjectIntMap<T> b) {
\r
252 TObjectIntMap<T> r = new TObjectIntHashMap<>(a);
\r
253 b.forEachKey(new TObjectProcedure<T>() {
\r
255 public boolean execute(T key) {
\r
265 * new trending specification, cannot not be <code>null</code>.
\r
266 * Use {@link TrendSpec#EMPTY} instead of <code>null</code>.
\r
268 public void setTrendSpec(TrendSpec newSpec) {
\r
269 //System.out.println(newSpec);
\r
270 // Check if equal & Read spec
\r
271 if (newSpec.equals(this.spec)) return;
\r
273 boolean timeWindowChange = !this.spec.viewProfile.timeWindow.equals( newSpec.viewProfile.timeWindow );
\r
274 boolean yaxisModeChanged = this.spec.axisMode != newSpec.axisMode;
\r
276 TObjectIntMap<String> newItemMap = itemIndexMap(newSpec.items);
\r
277 TObjectIntMap<String> currentItemMap = itemIndexMap(spec.items);
\r
278 TObjectIntMap<String> removedItemMap = subtract(currentItemMap, newItemMap);
\r
279 Map<String, VertRuler> existingRulers = new HashMap<>();
\r
280 if (this.spec.axisMode == YAxisMode.MultiAxis) {
\r
281 for (ItemNode item : analogItems)
\r
282 if (item.ruler != null)
\r
283 existingRulers.put(item.item.groupItemId, item.ruler);
\r
286 this.spec.readFrom( newSpec );
\r
287 this.spec.sortItems();
\r
288 this.renderingProfile.read(this.spec.viewProfile);
\r
291 if (titleNode != null) titleNode.setText( spec.name );
\r
293 // Setup trend item nodes
\r
295 for (ItemNode item : allItems) removeNode(item);
\r
296 analogItems.clear();
\r
297 binaryItems.clear();
\r
300 ItemManager itemManager = ItemManager.createUnchecked( getHistoryItems() );
\r
301 for (int i = 0; i<spec.items.size(); i++) {
\r
302 TrendItem item = spec.items.get(i);
\r
306 ItemNode node = createItemNode(item, itemManager);
\r
307 for (Bean historyItem : node.historyItems) {
\r
309 itemIds.add( (String) historyItem.getField("id") );
\r
310 } catch (BindingException e) {
\r
314 if (item.renderer == Renderer.Analog) {
\r
315 analogItems.add(node);
\r
317 binaryItems.add(node);
\r
319 allItems.add(node);
\r
322 // Setup vertical ruler nodes
\r
323 singleAxis = spec.axisMode == YAxisMode.SingleAxis;
\r
325 if (yaxisModeChanged || vertRulers.size() != 1 || vertRuler == null) {
\r
326 for (VertRuler vr : vertRulers) removeNode(vr);
\r
327 vertRulers.clear();
\r
329 vertRuler = addNode("VertRuler", VertRuler.class);
\r
330 vertRulers.add( vertRuler );
\r
333 vertRuler.manualscale = true;
\r
334 for (int i=0; i<analogItems.size(); i++) {
\r
335 ItemNode item = analogItems.get(i);
\r
336 item.ruler = vertRuler;
\r
337 item.trendNode = this;
\r
338 if (item.item.scale instanceof Scale.Manual == false) vertRuler.manualscale = false;
\r
341 if (yaxisModeChanged) {
\r
342 // Recreate all rulers
\r
343 for (VertRuler vr : vertRulers) removeNode(vr);
\r
344 vertRulers.clear();
\r
345 for (int i=0; i<analogItems.size(); i++)
\r
346 vertRulers.add( addNode(VertRuler.class) );
\r
348 // Remove rulers of the items that were removed
\r
349 // and add new rulers to have enough of them for
\r
350 // each separate analog signal.
\r
351 removedItemMap.forEachKey(new TObjectProcedure<String>() {
\r
353 public boolean execute(String id) {
\r
354 VertRuler vr = existingRulers.get(id);
\r
357 vertRulers.remove(vr);
\r
362 // Ensure TODO: validate that this works also for keeping ruler settings
\r
363 for (int i = vertRulers.size(); i < analogItems.size(); ++i) {
\r
364 VertRuler ruler = addNode(VertRuler.class);
\r
365 vertRulers.add(ruler);
\r
369 for (int i = 0; i < analogItems.size(); i++) {
\r
370 ItemNode item = analogItems.get(i);
\r
371 VertRuler vr = vertRulers.get(i);
\r
372 vr.setZIndex(1000 + i);
\r
373 vr.color = item.color;
\r
374 vr.label = item.item.label;
\r
375 vr.manualscale = item.item.scale instanceof Scale.Manual;
\r
377 item.trendNode = this;
\r
379 // Select vert ruler
\r
380 vertRuler = vertRulers.isEmpty() ? null : vertRulers.get( vertRulerIndex <= 0 || vertRulerIndex >= vertRulers.size() ? 0 : vertRulerIndex );
\r
384 TimeWindow tw = spec.viewProfile.timeWindow;
\r
385 horizRuler.manualscale = tw.timeWindowLength!=null && tw.timeWindowStart!=null;
\r
387 if (timeWindowChange) {
\r
388 horizRuler.autoscale();
\r
393 private ItemNode createItemNode(TrendItem item, ItemManager itemManager) {
\r
394 ItemNode node = addNode( ItemNode.class );
\r
395 //node.trendNode = this;
\r
396 node.setTrendItem(item, itemManager);
\r
397 node.color = toColor(item.customColor);
\r
398 if (node.color == null)
\r
399 node.color = JarisPaints.getColor( item.index );
\r
400 node.stroke = item.customStrokeWidth != null
\r
401 ? withStrokeWidth(item.customStrokeWidth, Plot.TREND_LINE_STROKE)
\r
402 : Plot.TREND_LINE_STROKE;
\r
406 private static BasicStroke withStrokeWidth(float width, BasicStroke stroke) {
\r
407 return new BasicStroke(width,
\r
408 stroke.getEndCap(), stroke.getLineJoin(), stroke.getMiterLimit(),
\r
409 stroke.getDashArray(), stroke.getDashPhase());
\r
412 private static Color toColor(float[] components) {
\r
413 if (components == null)
\r
415 switch (components.length) {
\r
416 case 3: return new Color(components[0], components[1], components[2]);
\r
417 case 4: return new Color(components[0], components[1], components[2], components[3]);
\r
418 default: return null;
\r
423 * Layout graphical nodes based on bounds
\r
425 public void layout() {
\r
426 double w = bounds.getWidth();
\r
427 double h = bounds.getHeight();
\r
428 if ( titleNode != null ) {
\r
429 titleNode.setSize(w, h * 0.02);
\r
430 titleNode.setTranslate(0, VERT_MARGIN);
\r
431 titleNode.layout();
\r
434 // Plot-Ruler area width
\r
435 double praw = w-HORIZ_MARGIN*2;
\r
438 double ph = h-VERT_MARGIN*2-MILESTONE_HEIGHT-HORIZ_RULER_HEIGHT;
\r
439 if ( titleNode != null ) {
\r
440 ph -= titleNode.th;
\r
443 // Analog & Binary area height
\r
445 if (!analogItems.isEmpty()) {
\r
446 bah = binaryItems.size() * BINARY[3];
\r
447 aah = Math.max(0, ph-bah);
\r
448 if (aah+bah>ph) bah = ph-aah;
\r
455 for (VertRuler vertRuler : vertRulers) {
\r
456 vertRuler.setHeight(aah);
\r
457 vertRuler.layout();
\r
459 plot.analogAreaHeight = aah;
\r
460 plot.binaryAreaHeight = bah;
\r
462 // Vertical ruler widths
\r
464 for (VertRuler vertRuler : vertRulers) {
\r
465 vrws += vertRuler.getWidth();
\r
468 // Add room for Binary label
\r
469 if ( !binaryItems.isEmpty() ) {
\r
470 double maxLabelWidth = BINARY_LABEL_WIDTH;
\r
471 for (ItemNode node : binaryItems) {
\r
472 if (node.item != null) {
\r
473 GlyphVector glyphVector = RULER_FONT.createGlyphVector(GridUtil.frc, node.item.label);
\r
474 double labelWidth = glyphVector.getVisualBounds().getWidth();
\r
475 maxLabelWidth = Math.max( maxLabelWidth, labelWidth );
\r
478 vrws = Math.max(maxLabelWidth, vrws);
\r
482 double pw = praw - vrws;
\r
483 plot.setTranslate(HORIZ_MARGIN, (titleNode!=null?titleNode.th:0)+VERT_MARGIN+MILESTONE_HEIGHT);
\r
484 plot.setSize(pw, ph);
\r
486 horizRuler.layout();
\r
487 horizRuler.setTranslate(HORIZ_MARGIN, plot.getY()+plot.getHeight()+3);
\r
488 boolean l = horizRuler.setWidth(pw);
\r
489 l |= horizRuler.setFromEnd(horizRuler.from, horizRuler.end);
\r
490 if (l) horizRuler.layout();
\r
492 // Move vertical rulers
\r
493 double vrx = plot.getX() + plot.getWidth() + 3;
\r
494 for (VertRuler vertRuler : vertRulers) {
\r
495 vertRuler.setTranslate(vrx, plot.getY());
\r
496 vrx += vertRuler.getWidth() + 3;
\r
501 public void setSize(double width, double height) {
\r
502 bounds.setFrame(0, 0, width, height);
\r
506 public void render(Graphics2D g2d) {
\r
507 // Set Quality High
\r
508 QualityHints qh = QualityHints.getQuality(g2d);
\r
509 g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, quality.textQuality==LineQuality.Antialias?RenderingHints.VALUE_TEXT_ANTIALIAS_ON:RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
\r
512 Rectangle bounds = g2d.getClipBounds();
\r
513 if (bounds.getWidth()!=this.bounds.getWidth() || bounds.getHeight()!=this.bounds.getHeight()) {
\r
514 setSize(bounds.getWidth(), bounds.getHeight());
\r
518 // Flush history subscriptions
\r
524 // Render plot's value tip
\r
525 plot.renderValueTip(g2d);
\r
528 qh.setQuality(g2d);
\r
532 public Rectangle2D getBoundsInLocal() {
\r
537 * Return true if the viewport is not moving and shows only past values
\r
540 public boolean allPast() {
\r
541 TimeWindow timeWindow = spec.viewProfile.timeWindow;
\r
542 boolean fixedWindow = !horizRuler.autoscroll || (timeWindow.timeWindowStart!=null && timeWindow.timeWindowLength!=null);
\r
544 for (ItemNode item : allItems) {
\r
545 if (item.end <= horizRuler.end) return false;
\r
553 public void flushHistory() {
\r
554 if (collector == null || collector instanceof CollectorImpl == false) return;
\r
555 CollectorImpl fh = (CollectorImpl) collector;
\r
556 fh.flush( itemIds );
\r
560 * Read values of min,max,from,end to all items.
\r
561 * Put iMin,iMax,iFrom,iEnd to all axes.
\r
563 public void readMinMaxFromEnd() {
\r
565 // Read min,max,from,end from all items - Gather collective ranges
\r
566 for (ItemNode item : allItems) {
\r
567 item.readMinMaxFromEnd();
\r
569 horizRuler.setKnownFromEnd();
\r
570 for (VertRuler vertRuler : vertRulers) vertRuler.setKnownMinMax();
\r
576 * Flushes history, resets streams,
\r
577 * reads the latest time and value ranges from disc.
\r
579 * Sets dirty true if there was change in axis.
\r
581 public boolean autoscale(boolean timeAxis, boolean valueAxis) {
\r
582 if (!timeAxis && !valueAxis) return false;
\r
584 readMinMaxFromEnd();
\r
585 boolean changed = false;
\r
589 changed |= horizRuler.autoscale();
\r
590 if ( changed && !printing ) horizRuler.fireListener();
\r
595 for (VertRuler vertRuler : vertRulers) changed |= vertRuler.autoscale();
\r
601 public boolean updateValueTipTime() {
\r
602 if (valueTipTime != null && spec.experimentIsRunning && spec.viewProfile.trackExperimentTime) {
\r
603 double endTime = horizRuler.getItemEndTime();
\r
604 if (!Double.isNaN(endTime)) {
\r
605 boolean changed = Double.compare(valueTipTime, endTime) != 0;
\r
606 valueTipTime = endTime;
\r
613 public void zoomIn(double x, double y, double width, double height, boolean horiz, boolean vert) {
\r
615 horizRuler.zoomIn(x, width);
\r
619 for (VertRuler vertRuler : vertRulers) {
\r
620 vertRuler.zoomIn(y, height);
\r
626 public void zoomOut() {
\r
627 horizRuler.zoomOut();
\r
628 for (VertRuler vertRuler : vertRulers) {
\r
629 vertRuler.zoomOut();
\r
634 public TrendSpec getTrendSpec() {
\r
638 public Viewport getViewport()
\r
640 Viewport vp = new Viewport();
\r
642 vp.from = horizRuler.from;
\r
643 vp.end = horizRuler.end;
\r
644 for (VertRuler vr : vertRulers) {
\r
645 AxisViewport avp = new AxisViewport();
\r
648 vp.axesports.add( avp );
\r
653 public void setViewport( Viewport vp )
\r
655 horizRuler.from = vp.from;
\r
656 horizRuler.end = vp.end;
\r
658 for ( AxisViewport avp : vp.axesports ) {
\r
659 if ( i>=vertRulers.size() ) break;
\r
660 VertRuler vr = vertRulers.get(i++);
\r
666 public void setQuality(TrendQualitySpec quality)
\r
668 this.quality = quality;
\r
671 public TrendQualitySpec getQuality()
\r
676 public Double snapToValue(double time, double snapToleranceInTime) throws HistoryException, AccessorException
\r
678 double from = horizRuler.from;
\r
679 double end = horizRuler.end;
\r
680 double pixelsPerSecond = (end-from) / plot.getWidth();
\r
682 TreeSet<Double> values = new TreeSet<Double>(Bindings.DOUBLE);
\r
683 for (ItemNode item : allItems) {
\r
684 Stream s = item.openStream( pixelsPerSecond );
\r
685 if ( s==null ) continue;
\r
686 int pos = s.binarySearch(Bindings.DOUBLE, time);
\r
687 ValueBand vb = new ValueBand(s.sampleBinding, s.sampleBinding.createDefaultUnchecked());
\r
695 int count = s.count();
\r
696 Double prevTime = null, nextTime = null;
\r
698 if ( prev>=0 && prev<count ) {
\r
699 s.accessor.get(prev, s.sampleBinding, vb.getSample());
\r
700 if ( !vb.isNanSample() ) {
\r
701 prevTime = vb.getTimeDouble();
\r
702 if ( vb.hasEndTime() ) {
\r
703 Double nTime = vb.getEndTimeDouble();
\r
704 if (nTime!=null && nTime+snapToleranceInTime>time) nextTime = nTime;
\r
709 if ( nextTime==null && next>=0 && next<count ) {
\r
710 s.accessor.get(next, s.sampleBinding, vb.getSample());
\r
711 if ( !vb.isNanSample() ) {
\r
712 nextTime = vb.getTimeDouble();
\r
716 if (prevTime==null && nextTime==null) continue;
\r
718 if (prevTime==null) {
\r
719 if ( nextTime - time < snapToleranceInTime )
\r
720 values.add(nextTime);
\r
721 } else if (nextTime==null) {
\r
722 if ( time - prevTime < snapToleranceInTime )
\r
723 values.add(prevTime);
\r
725 values.add(nextTime);
\r
726 values.add(prevTime);
\r
729 if (values.isEmpty()) return null;
\r
731 Double lower = values.floor( time );
\r
732 Double higher = values.ceiling( time );
\r
734 if ( lower == null ) return higher;
\r
735 if ( higher == null ) return lower;
\r
736 double result = time-lower < higher-time ? lower : higher;
\r