@Override public void redraw() { timer.reset(); tmpWidth = getWidth(); tmpHeight = getHeight(); double coveredWidth = tmpWidth / scale; double coveredHeight = tmpHeight / scale; coordsBounds = new BoundingBox(mapCenter.getX() - coveredHeight / 2, mapCenter.getY() - coveredWidth / 2, coveredHeight, coveredWidth); heightDistance = MathUtils.convertUnitsToKilometres(coordsBounds.getWidth()); widthDistance = MathUtils.convertUnitsToKilometres(coordsBounds.getHeight()); // clear view gc.clearRect(0, 0, tmpWidth, tmpHeight); // draw map content if (!isInDragMode()) { drawScoringValues(); } drawGrid(); drawElements(); drawInfo(); timer.logInfo(); }
static Boolean isInWindow(final NodeWrap<? extends Node> node, final Point p) { return new FutureAction<>(node.getEnvironment(), () -> { Window window = node.getControl().getScene().getWindow(); if (Double.isNaN(window.getX())) { // TODO: temporary stub for RT-12736 return true; } Bounds bounds = new BoundingBox(window.getX(), window.getY(), 0, window.getWidth(), window.getHeight(), 0); double x = node.getScreenBounds().getX(); double y = node.getScreenBounds().getY(); if (p == null) { x += node.getClickPoint().getX(); y += node.getClickPoint().getY(); } else { x += p.getX(); y += p.getY(); } return (bounds.contains(x, y)); }).get(); }
@Test public void createCompositeObservableBoundsWithValidBounds() { final Bounds b1 = new BoundingBox(10, 20, 30, 100, 200, 300); final ObjectProperty<Bounds> boundsProperty = new SimpleObjectProperty<>(b1); final CompositeObservableBounds cut = new CompositeObservableBounds(boundsProperty); assertEquals("minX value", 10, cut.minXProperty().get(), Precision.EPSILON); assertEquals("minY value", 20, cut.minYProperty().get(), Precision.EPSILON); assertEquals("minZ value", 30, cut.minZProperty().get(), Precision.EPSILON); assertEquals("centerX value", 60, cut.centerXProperty().get(), Precision.EPSILON); assertEquals("centerY value", 120, cut.centerYProperty().get(), Precision.EPSILON); assertEquals("centerZ value", 180, cut.centerZProperty().get(), Precision.EPSILON); assertEquals("maxX value", 110, cut.maxXProperty().get(), Precision.EPSILON); assertEquals("maxY value", 220, cut.maxYProperty().get(), Precision.EPSILON); assertEquals("maxZ value", 330, cut.maxZProperty().get(), Precision.EPSILON); }
/** Scans for and attaches to a new container, if any */ public void refreshContainer() { Bounds myBounds = this.getBodyBounds(); Point2D center = new Point2D((myBounds.getMinX()+myBounds.getMaxX())/2, (myBounds.getMinY()+myBounds.getMaxY())/2); List<Point2D> corners = ImmutableList.of( new Point2D(myBounds.getMinX(), myBounds.getMinY()), new Point2D(myBounds.getMaxX(), myBounds.getMinY()), new Point2D(myBounds.getMinX(), myBounds.getMaxY()), new Point2D(myBounds.getMaxX(), myBounds.getMaxY())); // use center point plus one corner to determine wherein this block is, to ease moving a block into a small container Predicate<Bounds> within = bounds -> bounds.contains(center) && corners.stream().anyMatch(bounds::contains); // a container may never end up in itself or its children List<? extends WrappedContainer> internals = this.getInternalContainers(); Predicate<BlockContainer> notInSelf = con -> internals.stream().noneMatch(con::isContainedWithin); BlockContainer newContainer = toplevel.getAllBlockContainers(). filter(container -> within.test(container.containmentBoundsInScene()) && notInSelf.test(container)). reduce((a, b) -> !a.containmentBoundsInScene().contains(b.containmentBoundsInScene()) ? a : b). orElse(this.toplevel); Bounds fitBounds = this.localToParent(this.sceneToLocal(myBounds)); this.moveIntoContainer(newContainer); newContainer.expandToFit(new BoundingBox(fitBounds.getMinX()-10, fitBounds.getMinY()-10, fitBounds.getWidth()+20, fitBounds.getHeight()+20)); }
/** Add and initializes a resizer element to this block */ private void setupResizer() { Polygon triangle = new Polygon(); triangle.getPoints().addAll(new Double[]{20.0, 20.0, 20.0, 0.0, 0.0, 20.0}); triangle.setFill(Color.BLUE); this.resizer = new Pane(triangle); triangle.setLayoutX(10); triangle.setLayoutY(10); this.resizer.setManaged(false); this.getChildren().add(this.resizer); this.resizer.relocate(240-20, 320-20); DragContext sizeDrag = new DragContext(this.resizer); sizeDrag.setDragLimits(new BoundingBox(200, 200, Integer.MAX_VALUE, Integer.MAX_VALUE)); }
protected boolean validWidth(BoundingBox box, Region region, double cellW, double gutterX, double gutterY) { boolean valid = false; if (region.getMinWidth() != -1 && box.getWidth() * cellW + (box.getWidth() - 1) * 2 * gutterX < region.getMinWidth()) { return false; } if (region.getPrefWidth() == USE_COMPUTED_SIZE && box.getWidth() * cellW + (box.getWidth() - 1) * 2 * gutterX >= region .prefWidth(-1)) { valid = true; } if (region.getPrefWidth() != USE_COMPUTED_SIZE && box.getWidth() * cellW + (box.getWidth() - 1) * 2 * gutterX >= region .getPrefWidth()) { valid = true; } return valid; }
protected boolean validHeight(BoundingBox box, Region region, double cellH, double gutterX, double gutterY) { boolean valid = false; if (region.getMinHeight() != -1 && box.getHeight() * cellH + (box.getHeight() - 1) * 2 * gutterY < region.getMinHeight()) { return false; } if (region.getPrefHeight() == USE_COMPUTED_SIZE && box.getHeight() * cellH + (box.getHeight() - 1) * 2 * gutterY >= region .prefHeight(region.prefWidth(-1))) { valid = true; } if (region.getPrefHeight() != USE_COMPUTED_SIZE && box.getHeight() * cellH + (box.getHeight() - 1) * 2 * gutterY >= region .getPrefHeight()) { valid = true; } return valid; }
public Bounds translateCameraToCanvas(Bounds bounds) { if (config.getDisplayWidth() == cameraManager.getFeedWidth() && config.getDisplayHeight() == cameraManager.getFeedHeight()) return bounds; final double scaleX = (double) config.getDisplayWidth() / (double) cameraManager.getFeedWidth(); final double scaleY = (double) config.getDisplayHeight() / (double) cameraManager.getFeedHeight(); final double minX = (bounds.getMinX() * scaleX); final double minY = (bounds.getMinY() * scaleY); final double width = (bounds.getWidth() * scaleX); final double height = (bounds.getHeight() * scaleY); logger.trace("translateCameraToCanvas {} {} {} {} - {} {} {} {}", bounds.getMinX(), bounds.getMinY(), bounds.getWidth(), bounds.getHeight(), minX, minY, width, height); return new BoundingBox(minX, minY, width, height); }
public Bounds translateCanvasToCamera(Bounds bounds) { if (config.getDisplayWidth() == cameraManager.getFeedWidth() && config.getDisplayHeight() == cameraManager.getFeedHeight()) return bounds; final double scaleX = (double) cameraManager.getFeedWidth() / (double) config.getDisplayWidth(); final double scaleY = (double) cameraManager.getFeedHeight() / (double) config.getDisplayHeight(); final double minX = (bounds.getMinX() * scaleX); final double minY = (bounds.getMinY() * scaleY); final double width = (bounds.getWidth() * scaleX); final double height = (bounds.getHeight() * scaleY); logger.trace("translateCanvasToCamera {} {} {} {} - {} {} {} {}", bounds.getMinX(), bounds.getMinY(), bounds.getWidth(), bounds.getHeight(), minX, minY, width, height); return new BoundingBox(minX, minY, width, height); }
@Test // DARK public void testPS3EyeHardwareDefaultsBrightRoomLimitedBounds() { // Turn off the top sectors because they are all just noise. for (int x = 0; x < JavaShotDetector.SECTOR_ROWS; x++) { sectorStatuses[0][x] = false; } Bounds projectionBounds = new BoundingBox(109, 104, 379, 297); List<DisplayShot> shots = findShots("/shotsearcher/ps3eye_hardware_defaults_bright_room.mp4", Optional.of(projectionBounds), mockManager, config, sectorStatuses); List<Shot> requiredShots = new ArrayList<Shot>(); requiredShots.add(new Shot(ShotColor.RED, 176.5, 251.3, 0, 2)); List<Shot> optionalShots = new ArrayList<Shot>(); optionalShots.add(new Shot(ShotColor.RED, 236.5, 169.5, 0, 2)); optionalShots.add(new Shot(ShotColor.RED, 175, 191.5, 0, 2)); optionalShots.add(new Shot(ShotColor.RED, 229.5, 227.5, 0, 2)); super.checkShots(collector, shots, requiredShots, optionalShots, false); }
@Test // DARK public void testPS3EyeHardwareDefaultsRedLaserRoomLightOnSafariLimitedBounds() { Bounds projectionBounds = new BoundingBox(131, 77, 390, 265); List<DisplayShot> shots = findShots("/shotsearcher/ps3eye_hardware_defaults_safari_red_laser_lights_on.mp4", Optional.of(projectionBounds), mockManager, config, sectorStatuses); List<Shot> requiredShots = new ArrayList<Shot>(); requiredShots.add(new Shot(ShotColor.RED, 473.6, 126.5, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 349.2, 130.5, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 207.3, 113.5, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 183.1, 226.9, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 310.5, 228.5, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 468.7, 219.8, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 469.8, 268.5, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 339.9, 291.8, 0, 2)); requiredShots.add(new Shot(ShotColor.RED, 201.5, 297.7, 0, 2)); super.checkShots(collector, shots, requiredShots, new ArrayList<Shot>(), true); }
@Test public void testTwo() throws ConfigurationException { PerspectiveManager pm = new PerspectiveManager(new BoundingBox(0, 0, 422, 316)); pm.setCameraParameters(4, 3.125, 2.32); pm.setCameraFeedSize(640, 480); pm.setCameraDistance(3406); pm.setShooterDistance(3406); pm.setProjectorResolution(1024, 768); pm.calculateUnknown(); assertEquals(1753.0, pm.getProjectionWidth(), 1); assertEquals(1299.0, pm.getProjectionHeight(), 1); Optional<Dimension2D> dims = pm.calculateObjectSize(300, 200, 3406); assertTrue(dims.isPresent()); assertEquals(175.3, dims.get().getWidth(), 1); assertEquals(118.2, dims.get().getHeight(), 1); }
@Test public void testThree() throws ConfigurationException { PerspectiveManager pm = new PerspectiveManager(new BoundingBox(0, 0, 422, 316)); pm.setProjectionSize(1753, 1299); pm.setCameraFeedSize(640, 480); pm.setCameraDistance(3406); pm.setShooterDistance(3406); pm.setProjectorResolution(1024, 768); pm.calculateUnknown(); assertEquals(4, pm.getFocalLength(), 1); assertEquals(3.122, pm.getSensorWidth(), .01); assertEquals(2.317, pm.getSensorHeight(), .01); Optional<Dimension2D> dims = pm.calculateObjectSize(300, 200, 3406); assertTrue(dims.isPresent()); assertEquals(175.3, dims.get().getWidth(), 1); assertEquals(118.2, dims.get().getHeight(), 1); }
@Test public void testPaperPixelsCalcParams() throws ConfigurationException { PerspectiveManager pm = new PerspectiveManager(new BoundingBox(0, 0, 422, 316), new Dimension2D(640, 480), new Dimension2D(67, 53), new Dimension2D(1024, 768)); pm.setCameraDistance(3498); pm.setShooterDistance(3498); pm.calculateUnknown(); assertEquals(4, pm.getFocalLength(), 1); assertEquals(3.047, pm.getSensorWidth(), .01); assertEquals(2.235, pm.getSensorHeight(), .01); Optional<Dimension2D> dims = pm.calculateObjectSize(279, 216, pm.getCameraDistance()); assertTrue(dims.isPresent()); assertEquals(162.6, dims.get().getWidth(), 1); assertEquals(128.9, dims.get().getHeight(), 1); }
/** * Invoked if the state property changes. * * @param pObservable the observable. * @param pOldValue the old value. * @param pNewValue the new value. */ private void onStateChanged(ObservableValue<? extends State> pObservable, State pOldValue, State pNewValue) { if (pOldValue != pNewValue) { // We need to construct the bounds ourselves, because // the given bounds are not always up to date. Bounds bounds = new BoundingBox(getLayoutX(), getLayoutY(), getWidth(), getHeight()); previousBounds.put(pOldValue, bounds); previousState = pOldValue; pseudoClassStateChanged(MAXIMIZED_PSEUDO_CLASS, pNewValue == State.MAXIMIZED); pseudoClassStateChanged(MINIMIZED_PSEUDO_CLASS, pNewValue == State.MINIMIZED); zoomReset(); fireEvent(new WindowStateChangedEvent(this, pOldValue, pNewValue), onStateChanged); } }
/** * {@inheritDoc} */ @Override protected void layoutChildren() { Insets padding = getPadding(); if (padding == null) { padding = Insets.EMPTY; } Bounds baseBounds = new BoundingBox( snapPosition(padding.getLeft()), snapPosition(padding.getTop()), snapPosition(getWidth() - padding.getLeft() - padding.getRight()), snapPosition(getHeight() - padding.getTop() - padding.getBottom())); double fromTop = layoutTop(baseBounds); double fromBottom = layoutBottom(baseBounds); double fromLeft = layoutLeft(baseBounds, fromTop, fromBottom); double fromRight = layoutRight(baseBounds, fromTop, fromBottom); layoutCenter(baseBounds, fromTop, fromBottom, fromLeft, fromRight); }
@Test public void constructors() { PointPair[] pairs = new PointPair[] { new PointPair(50d, 150d, 200d, 400d), new PointPair(new Point(50d, 150d), new Point(200d, 400d)), new PointPair(new BoundingBox(50d, 150d, 150d, 250d)), new PointPair(new Rectangle(50d, 150d, 150d, 250d)) }; for (PointPair pair : pairs) { assertEquals(50d, pair.from.x, 0.0001); assertEquals(150d, pair.from.y, 0.0001); assertEquals(200d, pair.to.x, 0.0001); assertEquals(400d, pair.to.y, 0.0001); } }
final Optional<Bounds> getSelectionBoundsOnScreen(Selection selection) { if (selection.getLength() == 0) { return Optional.empty(); } List<Bounds> bounds = new ArrayList<>(selection.getParagraphSpan()); for (int i = selection.getStartParagraphIndex(); i <= selection.getEndParagraphIndex(); i++) { final int i0 = i; virtualFlow.getCellIfVisible(i).ifPresent(c -> { IndexRange rangeWithinPar = getParagraphSelection(selection, i0); Bounds b = c.getNode().getRangeBoundsOnScreen(rangeWithinPar); bounds.add(b); }); } if(bounds.size() == 0) { return Optional.empty(); } double minX = bounds.stream().mapToDouble(Bounds::getMinX).min().getAsDouble(); double maxX = bounds.stream().mapToDouble(Bounds::getMaxX).max().getAsDouble(); double minY = bounds.stream().mapToDouble(Bounds::getMinY).min().getAsDouble(); double maxY = bounds.stream().mapToDouble(Bounds::getMaxY).max().getAsDouble(); return Optional.of(new BoundingBox(minX, minY, maxX-minX, maxY-minY)); }
private Bounds getParagraphBoundsOnScreen(Cell<Paragraph<PS, SEG, S>, ParagraphBox<PS, SEG, S>> cell) { Bounds nodeLocal = cell.getNode().getBoundsInLocal(); Bounds nodeScreen = cell.getNode().localToScreen(nodeLocal); Bounds areaLocal = getBoundsInLocal(); Bounds areaScreen = localToScreen(areaLocal); // use area's minX if scrolled right and paragraph's left is not visible double minX = nodeScreen.getMinX() < areaScreen.getMinX() ? areaScreen.getMinX() : nodeScreen.getMinX(); // use area's minY if scrolled down vertically and paragraph's top is not visible double minY = nodeScreen.getMinY() < areaScreen.getMinY() ? areaScreen.getMinY() : nodeScreen.getMinY(); // use area's width whether paragraph spans outside of it or not // so that short or long paragraph takes up the entire space double width = areaScreen.getWidth(); // use area's maxY if scrolled up vertically and paragraph's bottom is not visible double maxY = nodeScreen.getMaxY() < areaScreen.getMaxY() ? nodeScreen.getMaxY() : areaScreen.getMaxY(); return new BoundingBox(minX, minY, width, maxY - minY); }
@Test public void testContainerBoundChanged() throws Exception { pane.setScrollBarEnabled(false); pane.getScene().getWindow().setWidth(256); pane.getScene().getWindow().setHeight(256); Thread.sleep(150); // wait for layout assertThat(pane.getViewportBound()).isEqualTo(new BoundingBox(0, 0, 256, 256)); assertThat(pane.viewportCentre()).isEqualTo(new Point2D(128, 128)); }
public static Bounds union(Bounds first, Bounds second) { if (first == null) { return second; } else if (second == null) { return first; } double minX = Math.min(first.getMinX(), second.getMinX()); double minY = Math.min(first.getMinY(), second.getMinY()); double maxX = Math.max(first.getMaxX(), second.getMaxX()); double maxY = Math.max(first.getMaxY(), second.getMaxY()); return new BoundingBox(minX, minY, maxX - minX, maxY - minY); }
public void addRect(Node ref, double x, double y, double w, double h) { BoundingBox screenr = new BoundingBox(x, y, w, h); Bounds b = ref.localToScreen(screenr); b = target.screenToLocal(b); Region r = new Region(); r.relocate(b.getMinX(), b.getMinY()); r.resize(b.getWidth(), b.getHeight()); r.setBackground(FX.background(Color.color(0, 0, 0, 0.3))); add(r); }
public void addOutline(Node ref, double x, double y, double w, double h) { BoundingBox screenr = new BoundingBox(x, y, w, h); Bounds b = ref.localToScreen(screenr); b = target.screenToLocal(b); Region r = new Region(); r.relocate(b.getMinX(), b.getMinY()); r.resize(b.getWidth(), b.getHeight()); r.setBackground(FX.background(Color.color(0, 0, 0, 0.1))); add(r); }
@Test(expected = NullPointerException.class) public void callAddWithNullBounds() { final Bounds b1 = new BoundingBox(10, 20, 30, 100, 200, 300); final ObjectProperty<Bounds> boundsProperty = new SimpleObjectProperty<>(b1); final CompositeObservableBounds cut = new CompositeObservableBounds(boundsProperty); cut.add(null); }
@Test public void callClear() { final Bounds b1 = new BoundingBox(10, 20, 30, 100, 200, 300); final ObjectProperty<Bounds> boundsProperty = new SimpleObjectProperty<>(b1); final CompositeObservableBounds cut = new CompositeObservableBounds(boundsProperty); assertEquals("minX value", 10, cut.minXProperty().get(), Precision.EPSILON); assertEquals("minY value", 20, cut.minYProperty().get(), Precision.EPSILON); assertEquals("minZ value", 30, cut.minZProperty().get(), Precision.EPSILON); assertEquals("centerX value", 60, cut.centerXProperty().get(), Precision.EPSILON); assertEquals("centerY value", 120, cut.centerYProperty().get(), Precision.EPSILON); assertEquals("centerZ value", 180, cut.centerZProperty().get(), Precision.EPSILON); assertEquals("maxX value", 110, cut.maxXProperty().get(), Precision.EPSILON); assertEquals("maxY value", 220, cut.maxYProperty().get(), Precision.EPSILON); assertEquals("maxZ value", 330, cut.maxZProperty().get(), Precision.EPSILON); cut.clear(); assertEquals("minX value", 0, cut.minXProperty().get(), Precision.EPSILON); assertEquals("minY value", 0, cut.minYProperty().get(), Precision.EPSILON); assertEquals("minZ value", 0, cut.minZProperty().get(), Precision.EPSILON); assertEquals("centerX value", 0, cut.centerXProperty().get(), Precision.EPSILON); assertEquals("centerY value", 0, cut.centerYProperty().get(), Precision.EPSILON); assertEquals("centerZ value", 0, cut.centerZProperty().get(), Precision.EPSILON); assertEquals("maxX value", 0, cut.maxXProperty().get(), Precision.EPSILON); assertEquals("maxY value", 0, cut.maxYProperty().get(), Precision.EPSILON); assertEquals("maxZ value", 0, cut.maxZProperty().get(), Precision.EPSILON); }
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { name = (String) in.readObject(); bounds = new BoundingBox(in.readDouble(), in.readDouble(), in.readDouble(), in.readDouble()); Dimension2D size = new Dimension2D(in.readDouble(), in.readDouble()); ShapeType type = (ShapeType) in.readObject(); switch (type) { case CIRCLE: shape = BoundingShape.circle(size.getWidth() / 2); break; case POLYGON: shape = BoundingShape.box(size.getWidth(), size.getHeight()); break; case CHAIN: int length = in.readInt(); Point2D[] points = new Point2D[length]; for (int i = 0; i < length; i++) { points[i] = new Point2D(in.readDouble(), in.readDouble()); } shape = BoundingShape.chain(points); break; default: throw new IllegalArgumentException("Unknown shape type"); } }
/** Return the union of two Bounds, i.e. a Bound that contains both. */ static Bounds union(Bounds a, Bounds b) { double left = Math.min(a.getMinX(), b.getMinX()); double right = Math.max(a.getMaxX(), b.getMaxX()); double top = Math.min(a.getMinY(), b.getMinY()); double bottom = Math.max(a.getMaxY(), b.getMaxY()); return new BoundingBox(left, top, right - left, bottom - top); }
/** * @param pos the position to look around in coordinate system of this pane. * @param distance the maximum 'nearby' distance. */ public List<ConnectionAnchor> allNearbyFreeAnchors(Point2D pos, double distance) { ArrayList<ConnectionAnchor> anchors = new ArrayList<>(); Bounds testBounds = new BoundingBox(pos.getX()-distance, pos.getY()-distance, distance*2, distance*2); for (Block nearBlock : this.streamChildren().filter(n -> n instanceof Block).map(n -> (Block)n).filter(b -> b.getBoundsInParent().intersects(testBounds)).collect(Collectors.toList())) { for (ConnectionAnchor anchor : nearBlock.getAllAnchors()) { Point2D anchorPos = anchor.getAttachmentPoint(); if (pos.distance(anchorPos) < distance && anchor.getWireInProgress() == null && !anchor.hasConnection()) { anchors.add(anchor); } } } return anchors; }
@Override public Bounds containmentBoundsInScene() { Bounds local = this.getBoundsInLocal(); // include border area around this lane BoundingBox withBorders = new BoundingBox(local.getMinX()-10, local.getMinY()-25, local.getWidth()+20, local.getHeight()+50); return this.localToScene(withBorders); }
@Override public void expandToFit(Bounds blockBounds) { Bounds containerBounds = this.parent.getToplevel().sceneToLocal(this.getCenter().localToScene(this.getCenter().getBoundsInLocal())); double shiftX = Math.min(0, blockBounds.getMinX() - containerBounds.getMinX()); double shiftY = Math.min(0, blockBounds.getMinY() - containerBounds.getMinY()); double extraX = Math.max(0, blockBounds.getMaxX() - containerBounds.getMaxX()) + Math.abs(shiftX); double extraY = Math.max(0, blockBounds.getMaxY() - containerBounds.getMaxY()) + Math.abs(shiftY); this.resizer.relocate(this.resizer.getLayoutX() + extraX, this.resizer.getLayoutY() + extraY); double shiftXForRights = extraX + shiftX; this.parent.shiftAllBut(shiftX, shiftY, this, shiftXForRights); // also resize its parent in case of nested containers Bounds fitBounds = this.parent.getBoundsInParent(); this.getParentContainer().expandToFit(new BoundingBox(fitBounds.getMinX()-10, fitBounds.getMinY()-10, fitBounds.getWidth()+20, fitBounds.getHeight()+20)); }
@Override public Bounds containmentBoundsInScene() { Bounds local = this.getBoundsInLocal(); // include top and bottom border of the DefinitionBlock BoundingBox withBorders = new BoundingBox(local.getMinX(), local.getMinY()-25, local.getWidth(), local.getHeight()+50); return this.localToScene(withBorders); }
@Override public void expandToFit(Bounds blockBounds) { Bounds containerBounds = this.wrapper.getToplevel().sceneToLocal(this.getCenter().localToScene(this.getCenter().getBoundsInLocal())); double shiftX = Math.min(0, blockBounds.getMinX() - containerBounds.getMinX()); double shiftY = Math.min(0, blockBounds.getMinY() - containerBounds.getMinY()); double extraX = Math.max(0, blockBounds.getMaxX() - containerBounds.getMaxX()) + Math.abs(shiftX); double extraY = Math.max(0, blockBounds.getMaxY() - containerBounds.getMaxY()) + Math.abs(shiftY); this.wrapper.shiftAndGrow(shiftX, shiftY, extraX, extraY); // also resize its parent in case of nested containers Bounds fitBounds = this.wrapper.getBoundsInParent(); this.getParentContainer().expandToFit(new BoundingBox(fitBounds.getMinX()-10, fitBounds.getMinY()-10, fitBounds.getWidth()+20, fitBounds.getHeight()+20)); }
private static MarkerFeedback handleOutline(Pane layoutNode, FeedbackData data) { TabOutlineMarker marker = null; for (Node n : layoutNode.getChildren()) { if (n instanceof TabOutlineMarker) { marker = (TabOutlineMarker) n; } } if (marker == null) { marker = new TabOutlineMarker(layoutNode.getBoundsInLocal(), new BoundingBox(data.bounds.getMinX(), data.bounds.getMinY(), data.bounds.getWidth(), data.bounds.getHeight()), data.dropType == DropType.BEFORE); marker.setManaged(false); marker.setMouseTransparent(true); layoutNode.getChildren().add(marker); } else { marker.updateBounds(layoutNode.getBoundsInLocal(), new BoundingBox(data.bounds.getMinX(), data.bounds.getMinY(), data.bounds.getWidth(), data.bounds.getHeight()), data.dropType == DropType.BEFORE); marker.setVisible(true); } final TabOutlineMarker fmarker = marker; return new MarkerFeedback(data) { @Override public void hide() { fmarker.setVisible(false); } }; }
public void configureView() { view = new BreakingNewsDemoView(); view.autoModeProperty().addListener((v, o, n) -> { this.mode = n; }); this.mode = view.autoModeProperty().get(); view.startActionProperty().addListener((v, o, n) -> { if(n) { if(mode == Mode.AUTO) cursor++; start(); }else{ stop(); } }); view.runOneProperty().addListener((v, o, n) -> { this.cursor += n.intValue(); runOne(jsonList.get(cursor), cursor); }); view.flipStateProperty().addListener((v, o, n) -> { view.flipPaneProperty().get().flip(); }); view.setPrefSize(1370, 1160); view.setMinSize(1370, 1160); mainViewScroll = new ScrollPane(); mainViewScroll.setViewportBounds(new BoundingBox(0, 0, 1370, 1160)); mainViewScroll.setHbarPolicy(ScrollBarPolicy.NEVER); mainViewScroll.setVbarPolicy(ScrollBarPolicy.AS_NEEDED); mainViewScroll.setContent(view); mainViewScroll.viewportBoundsProperty().addListener((v, o, n) -> { view.setPrefSize(Math.max(1370, n.getMaxX()), Math.max(1160, n.getMaxY()));//1370, 1160); }); createDataStream(); createAlgorithm(); }
/** * returns the available box at the cell (x,y) of the grid that fits the block if existed * * @param x * @param y * @param block * @return */ protected BoundingBox getFreeArea(int[][] matrix, int x, int y, Region block, double cellWidth, double cellHeight, int limitRow, int limitCol, double gutterX, double gutterY) { double blockHeight = getBLockHeight(block); double blockWidth = getBLockWidth(block); int rowsNeeded = (int) Math.ceil(blockHeight / (cellHeight + gutterY)); if (cellHeight * rowsNeeded + (rowsNeeded - 1) * 2 * gutterY < blockHeight) { rowsNeeded++; } int maxRow = Math.min(x + rowsNeeded, limitRow); int colsNeeded = (int) Math.ceil(blockWidth / (cellWidth + gutterX)); if (cellWidth * colsNeeded + (colsNeeded - 1) * 2 * gutterX < blockWidth) { colsNeeded++; } int maxCol = Math.min(y + colsNeeded, limitCol); int minRow = maxRow; int minCol = maxCol; for (int i = x; i < minRow; i++) { for (int j = y; j < maxCol; j++) { if (matrix[i][j] != 0) { if (y < j && j < minCol) { minCol = j; } } } } for (int i = x; i < maxRow; i++) { for (int j = y; j < minCol; j++) { if (matrix[i][j] != 0) { if (x < i && i < minRow) { minRow = i; } } } } return new BoundingBox(x, y, minCol - y, minRow - x); }
@Test public void testOne() throws ConfigurationException { assertTrue(PerspectiveManager.isCameraSupported("C270", new Dimension2D(1280, 720))); PerspectiveManager pm = new PerspectiveManager("C270", new Dimension2D(1280, 720), new BoundingBox(0, 0, 736, 544)); pm.setCameraFeedSize(1280, 720); pm.setCameraDistance(3406); pm.setShooterDistance(3406); pm.setProjectorResolution(1024, 768); pm.calculateUnknown(); assertEquals(1753.0, pm.getProjectionWidth(), 1); assertEquals(1299.0, pm.getProjectionHeight(), 1); Optional<Dimension2D> dims = pm.calculateObjectSize(300, 200, 3406); assertTrue(dims.isPresent()); assertEquals(175.3, dims.get().getWidth(), 1); assertEquals(118.2, dims.get().getHeight(), 1); dims = pm.calculateObjectSize(300, 200, 3406*2); assertTrue(dims.isPresent()); assertEquals(87.7, dims.get().getWidth(), 1); assertEquals(59.1, dims.get().getHeight(), 1); dims = pm.calculateObjectSize(300, 200, 3406 / 2); assertTrue(dims.isPresent()); assertEquals(350.7, dims.get().getWidth(), 1); assertEquals(236.5, dims.get().getHeight(), 1); pm.setShooterDistance(3406 * 2); dims = pm.calculateObjectSize(300, 200, 3406); assertTrue(dims.isPresent()); assertEquals(350.7, dims.get().getWidth(), 1); assertEquals(236.5, dims.get().getHeight(), 1); }
@Test(expected = IllegalArgumentException.class) public void testDesiredDistanceCannotBeZero() { PerspectiveManager pm = new PerspectiveManager("C270", new Dimension2D(1280, 720), new BoundingBox(0, 0, 736, 544)); pm.setCameraFeedSize(1280, 720); pm.setCameraDistance(3406); pm.setShooterDistance(3406); pm.setProjectorResolution(1024, 768); pm.calculateUnknown(); pm.calculateObjectSize(10, 10, 0); }
@Before public void setUp() throws ConfigurationException { System.setProperty("shootoff.home", System.getProperty("user.dir")); TextToSpeech.silence(true); TrainingExerciseBase.silence(true); config = new Configuration(new String[0]); canvasManager = new MockCanvasManager(config); cameraManager = new MockCameraManager(); bounds = new BoundingBox(100, 100, 540, 260); cameraManager.setProjectionBounds(bounds); canvasManager.setCameraManager(cameraManager); ProjectorArenaPane projectorArenaPane = new MockProjectorArenaController(config, canvasManager); canvasManager.setProjectorArena(projectorArenaPane, bounds); canvasManager.getCanvasGroup().getChildren().clear(); targets = new ArrayList<Target>(); TargetComponents poiComponents = TargetIO.loadTarget(new File("targets/POI_Offset_Adjustment.target")).get(); poiTarget = (TargetView) canvasManager.addTarget( new TargetView(poiComponents.getTargetGroup(), poiComponents.getTargetTags(), targets)); targets.add(poiTarget); canvasManager.addTarget(new File("targets/POI_Offset_Adjustment.target")); canvasManager.getTargets().get(0).setDimensions(640, 360); canvasManager.getTargets().get(0).setPosition(0, 0); }
public BoundedReferential2D(BoundaryBox _objFX, BoundaryBox _objMAX, double _maxScale) { sceneFX = new BoundingBox(0, 0, _objFX.getWidth(), _objFX.getHeight()); max2D = new BoundingBox(_objMAX.getMinX(), _objMAX.getMinY(), _objMAX.getWidth(), _objMAX.getHeight()); scene2D = new BoundingBox(_objMAX.getMinX(), _objMAX.getMinY(), _objMAX.getWidth(), _objMAX.getHeight()); maxScale = new SimpleDoubleProperty(_maxScale); curScale = new SimpleDoubleProperty(1.0); maxScale.addListener((_obs, _old, _new) -> setScaleMax(maxScale.getValue()) ); curScale.addListener((_obs, _old, _new) -> setScale(curScale.getValue()) ); }
public Curve2DView(int _w, int _h) { super(); displayArea = new BoundingBox(0, -1, 1, 1); setPrefSize(_w, _h); canvas = new Canvas(_w, _h); gc2 = canvas.getGraphicsContext2D(); getChildren().addAll(canvas); }