Java Code Examples for java.awt.Rectangle#grow()

/**
 * Detect any section which is too far from the other ones.
 *
 * @param seedSection the initial seed section
 * @param collected   the sections collected, including seed section
 * @return the collection of isolated sections found
 */
private List<Section> detectIsolatedSections (Section seedSection,
                                              List<Section> collected)
{
    final List<Section> isolated = new ArrayList<>(collected);
    final Rectangle slurBox = seedSection.getBounds();
    boolean makingProgress;

    do {
        makingProgress = false;

        for (Iterator<Section> it = isolated.iterator(); it.hasNext();) {
            Section section = it.next();
            Rectangle sectBox = section.getBounds();
            sectBox.grow(params.slurBoxDx, params.slurBoxDy);

            if (sectBox.intersects(slurBox)) {
                slurBox.add(sectBox);
                it.remove();
                makingProgress = true;
            }
        }
    } while (makingProgress);

    return isolated;
}
 

/**
 * Liga uma linha a um objeto manualmente (sem o uso do mouse).
 *
 * @param res
 * @return
 */
public boolean LigarA(Elementar res) {
    boolean sn = false;
    if (res instanceof Forma) {
        setEm((Forma) res);
        if (getEm() != null) {
            getEm().PosicionePonto(this);
            getDono().OrganizeLinha();
            sn = true;
        }
    }
    getDono().reSetBounds();
    ReenquadreLinha();
    Rectangle rec = getBounds();
    rec.grow(5, 5);
    InvalidateArea(rec);
    //ProcessaOverDraw(true);
    return sn;
}
 

public void process (SIGraph sig)
{
    final int bracketGrowth = 2 * sig.getSystem().getSheet().getInterline();

    // Use a COPY of vertices, to reduce risks of concurrent modifications (but not all...)
    Set<Inter> copy = new LinkedHashSet<>(sig.vertexSet());

    for (Inter inter : copy) {
        if (!inter.isRemoved()) {
            Rectangle bounds = inter.getBounds();

            if (bounds != null) {
                // Dirty hack to make sure bracket serifs are fully painted
                // (despite the fact that bracket serif is not included in their bounds)
                if (inter.getShape() == Shape.BRACKET) {
                    bounds.grow(bracketGrowth, bracketGrowth);
                }

                if ((clip == null) || clip.intersects(bounds)) {
                    inter.accept(this);
                }
            }
        }
    }
}
 

private TableColumn getResizingColumn(Point p, int column) {
  if (column == -1) {
    return null;
  }
  int row = table.rowAtPoint(p);
  Rectangle r = table.getCellRect(row, column, true);
  r.grow(-3, 0);
  if (r.contains(p)) {
    return null;
  }
  int midPoint = r.x + r.width / 2;
  int columnIndex;
  if (table.getTableHeader().getComponentOrientation().isLeftToRight()) {
    columnIndex = (p.x < midPoint) ? column - 1 : column;
  } else {
    columnIndex = (p.x < midPoint) ? column : column - 1;
  }
  if (columnIndex == -1) {
    return null;
  }
  return table.getTableHeader().getColumnModel().getColumn(columnIndex);
}
 

private void paintRect(int x, int y, int w, int h, int t) {
    if (w != 0 && h != 0) {
        Rectangle rect = new Rectangle(x, y, w, h);
        rect.grow(t, t);
        paintImmediately(rect);
    }
}
 

/**
 * Find the first point of the current sequence which is close to the provided point
 * (less than sticky distance).
 *
 * @param point the provided point
 * @return the point found, or null if not found
 */
public Point findPoint (Point point)
{
    Rectangle window = new Rectangle(point);
    window.grow(getStickyDistance(), getStickyDistance());

    for (Point pt : points) {
        if (window.contains(pt)) {
            return pt;
        }
    }

    return null;
}
 

@Override
public void mouseExited(MouseEvent e) {
    super.mouseExited(e); //To change body of generated methods, choose Tools | Templates.
    entrou = false;
    Rectangle r = getBounds();
    int x = r.width / 2;
    int y = r.height / 2;
    //r = new Rectangle(r.x - x, r.y - y, r.width * 2, r.height * 2);
    r.grow(x + 2, y + 2);
    InvalidateArea(r);
}
 

/**
 * Check that note heads do not appear on both stem head and tail.
 * On tail we can have nothing or beams or flags, but no heads
 *
 * @param chord the chord to check
 */
private void checkHeadLocations (Chord chord)
{
    // This test applies only to chords with stem
    Glyph stem = chord.getStem();
    if (stem == null) {
        return;
    }

    Rectangle tailBox = new Rectangle(chord.getTailLocation());
    int halfTailBoxSide = chord.getScale().toPixels(constants.halfTailBoxSide);
    tailBox.grow(halfTailBoxSide, halfTailBoxSide);

    for (TreeNode node : chord.getNotes()) {
        Note note = (Note) node;

        // If note is close to tail, it can't be a note
        if (note.getBox().intersects(tailBox)) {
            for (Glyph glyph : note.getGlyphs()) {
                if (logger.isDebugEnabled() || glyph.isVip()) {
                    logger.info("Note {} too close to tail of stem {}",
                            note, stem);
                }
                glyph.setShape(null);
            }
            modified.set(true);
        }
    }
}
 

private void grow (int h,
                   int v)
{
    for (Rectangle rect : boxes) {
        rect.grow(h, v);
    }
}
 

private void checkOutOfBounds(Point point) {
	Rectangle bounds = map.getBounds();
	bounds.grow(-shrinkViewPort, -shrinkViewPort);

	outOfBounds = !bounds.contains(point);
	if (outOfBounds)
		outOfBoundsPoint = point;
}
 

/**
 * Detect if the provided section is a thick one.
 * (as seen in the context of the factory orientation)
 *
 * @param section the section to check
 * @return true if fat
 */
public boolean isSectionFat (Section section)
{
    if (section.isFat() == null) {
        try {
            if (section.getMeanThickness(orientation) <= 1) {
                section.setFat(false);

                return section.isFat();
            }

            // Check global slimness
            if (section.getMeanAspect(orientation) < params.minSectionAspect) {
                section.setFat(true);

                return section.isFat();
            }

            // Check thickness
            Rectangle bounds = orientation.oriented(section.getBounds());
            Line line = orientation.switchRef(
                    section.getAbsoluteLine());

            if (Math.abs(line.getSlope()) < (Math.PI / 4)) {
                // Measure mean thickness on each half
                int startCoord = bounds.x + (bounds.width / 4);
                int startPos = line.yAtX(startCoord);
                int stopCoord = bounds.x + ((3 * bounds.width) / 4);
                int stopPos = line.yAtX(stopCoord);

                // Start side
                Rectangle oRoi = new Rectangle(startCoord, startPos, 0, 0);
                final int halfWidth = Math.min(
                        params.probeWidth / 2,
                        bounds.width / 4);
                oRoi.grow(halfWidth, params.maxSectionThickness);

                PointsCollector collector = new PointsCollector(
                        orientation.absolute(oRoi));
                section.cumulate(collector);

                int startThickness = (int) Math.rint(
                        (double) collector.getSize() / oRoi.width);

                // Stop side
                oRoi.translate(stopCoord - startCoord, stopPos - startPos);
                collector = new PointsCollector(orientation.absolute(oRoi));
                section.cumulate(collector);

                int stopThickness = (int) Math.rint(
                        (double) collector.getSize() / oRoi.width);

                section.setFat(
                        (startThickness > params.maxSectionThickness)
                        || (stopThickness > params.maxSectionThickness));
            } else {
                section.setFat(bounds.height > params.maxSectionThickness);
            }
        } catch (Exception ex) {
            logger.warn("Error in checking fatness of " + section, ex);
            section.setFat(true);
        }
    }

    return section.isFat();
}
 

public void runTests() {
        GraphicsConfiguration gc = getGraphicsConfiguration();
        for (Image srcIm :
            new Image[] {
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, true),
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, false),
                // commented out due to 6593406
//                getBMImage(gc, IMAGEW, IMAGEH),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, true),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, false),
                getVImage(gc, IMAGEW, IMAGEH),
            })
        {
            System.out.println("Testing source: " + srcIm);
            // wiggle the source and dest rectangles
            try {
                for (int locationVar = -10; locationVar < 20; locationVar += 10)
                {
                    for (int sizeVar = -10; sizeVar < 20; sizeVar += 10) {
                        Rectangle srcRect = (Rectangle)IMAGE_BOUNDS.clone();
                        srcRect.translate(locationVar, locationVar);
                        srcRect.grow(sizeVar, sizeVar);

                        Rectangle dstRect =
                                new Rectangle(sizeVar, sizeVar,
                                srcRect.width, srcRect.height);
                        System.out.println("testing blit rect src: " + srcRect);
                        System.out.println("                  dst: " + dstRect);
                        render(getGraphics(), srcIm, srcRect, dstRect);
                        test(srcRect, dstRect);
                    }
                }
                System.out.println("Test passed.");
            } finally {
                synchronized (lock) {
                    done = true;
                    lock.notifyAll();
                }
            }
        }
    }
 

public void runTests() {
        GraphicsConfiguration gc = getGraphicsConfiguration();
        for (Image srcIm :
            new Image[] {
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, true),
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, false),
                // commented out due to 6593406
//                getBMImage(gc, IMAGEW, IMAGEH),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, true),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, false),
                getVImage(gc, IMAGEW, IMAGEH),
            })
        {
            System.out.println("Testing source: " + srcIm);
            // wiggle the source and dest rectangles
            try {
                for (int locationVar = -10; locationVar < 20; locationVar += 10)
                {
                    for (int sizeVar = -10; sizeVar < 20; sizeVar += 10) {
                        Rectangle srcRect = (Rectangle)IMAGE_BOUNDS.clone();
                        srcRect.translate(locationVar, locationVar);
                        srcRect.grow(sizeVar, sizeVar);

                        Rectangle dstRect =
                                new Rectangle(sizeVar, sizeVar,
                                srcRect.width, srcRect.height);
                        System.out.println("testing blit rect src: " + srcRect);
                        System.out.println("                  dst: " + dstRect);
                        render(getGraphics(), srcIm, srcRect, dstRect);
                        test(srcRect, dstRect);
                    }
                }
                System.out.println("Test passed.");
            } finally {
                synchronized (lock) {
                    done = true;
                    lock.notifyAll();
                }
            }
        }
    }
 

@Override
public MouseEvent mouseMoved(MouseEvent mouseEvent)
{
	if (!inOverlayManagingMode)
	{
		return mouseEvent;
	}

	final Point mousePoint = mouseEvent.getPoint();
	mousePosition.setLocation(mousePoint);

	if (!inOverlayResizingMode && !inOverlayDraggingMode)
	{
		currentManagedOverlay = null;

		synchronized (overlayManager)
		{
			for (Overlay overlay : overlayManager.getOverlays())
			{
				final Rectangle bounds = overlay.getBounds();
				if (bounds.contains(mousePoint))
				{
					currentManagedOverlay = overlay;
					break;
				}
			}
		}
	}

	if (currentManagedOverlay == null || !currentManagedOverlay.isResizable())
	{
		clientUI.setCursor(clientUI.getDefaultCursor());
		return mouseEvent;
	}

	final Rectangle toleranceRect = new Rectangle(currentManagedOverlay.getBounds());
	toleranceRect.grow(-OVERLAY_RESIZE_TOLERANCE, -OVERLAY_RESIZE_TOLERANCE);
	final int outcode = toleranceRect.outcode(mouseEvent.getPoint());

	switch (outcode)
	{
		case Rectangle.OUT_TOP:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_TOP | Rectangle.OUT_LEFT:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_LEFT:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_LEFT | Rectangle.OUT_BOTTOM:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_BOTTOM:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_BOTTOM | Rectangle.OUT_RIGHT:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_RIGHT:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));
			break;
		case Rectangle.OUT_RIGHT | Rectangle.OUT_TOP:
			clientUI.setCursor(Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));
			break;
		default:
			// center
			clientUI.setCursor(clientUI.getDefaultCursor());
	}

	return mouseEvent;
}
 

public void runTests() {
        GraphicsConfiguration gc = getGraphicsConfiguration();
        for (Image srcIm :
            new Image[] {
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, true),
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, false),
                // commented out due to 6593406
//                getBMImage(gc, IMAGEW, IMAGEH),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, true),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, false),
                getVImage(gc, IMAGEW, IMAGEH),
            })
        {
            System.out.println("Testing source: " + srcIm);
            // wiggle the source and dest rectangles
            try {
                for (int locationVar = -10; locationVar < 20; locationVar += 10)
                {
                    for (int sizeVar = -10; sizeVar < 20; sizeVar += 10) {
                        Rectangle srcRect = (Rectangle)IMAGE_BOUNDS.clone();
                        srcRect.translate(locationVar, locationVar);
                        srcRect.grow(sizeVar, sizeVar);

                        Rectangle dstRect =
                                new Rectangle(sizeVar, sizeVar,
                                srcRect.width, srcRect.height);
                        System.out.println("testing blit rect src: " + srcRect);
                        System.out.println("                  dst: " + dstRect);
                        render(getGraphics(), srcIm, srcRect, dstRect);
                        test(srcRect, dstRect);
                    }
                }
                System.out.println("Test passed.");
            } finally {
                synchronized (lock) {
                    done = true;
                    lock.notifyAll();
                }
            }
        }
    }
 

/**
 * Detect if the provided section is a thick one.
 * (as seen in the context of the factory orientation)
 *
 * @param section the section to check
 * @return true if fat
 */
public boolean isSectionFat (Section section)
{
    final Boolean fat = fatSections.get(section);

    if (fat != null) {
        return fat;
    }

    try {
        if (section.getMeanThickness(orientation) <= 1) {
            return setFat(section, false);
        }

        // Check global slimness
        if (section.getMeanAspect(orientation) < params.minSectionAspect) {
            return setFat(section, true);
        }

        // Check thickness
        Rectangle bounds = orientation.oriented(section.getBounds());
        Line line = orientation.switchRef(section.getAbsoluteLine());

        if (Math.abs(line.getSlope()) < (Math.PI / 4)) {
            // Measure mean thickness on each half
            int startCoord = bounds.x + (bounds.width / 4);
            int startPos = line.yAtX(startCoord);
            int stopCoord = bounds.x + ((3 * bounds.width) / 4);
            int stopPos = line.yAtX(stopCoord);

            // Start side
            Rectangle oRoi = new Rectangle(startCoord, startPos, 0, 0);
            final int halfWidth = Math.min(params.probeWidth / 2, bounds.width / 4);
            oRoi.grow(halfWidth, params.maxThickness);

            PointsCollector collector = new PointsCollector(orientation.absolute(oRoi));
            section.cumulate(collector);

            int startThickness = (int) Math.rint((double) collector.getSize() / oRoi.width);

            // Stop side
            oRoi.translate(stopCoord - startCoord, stopPos - startPos);
            collector = new PointsCollector(orientation.absolute(oRoi));
            section.cumulate(collector);

            int stopThickness = (int) Math.rint((double) collector.getSize() / oRoi.width);

            return setFat(
                    section,
                    (startThickness > params.maxThickness)
                            || (stopThickness > params.maxThickness));
        } else {
            return setFat(section, bounds.height > params.maxThickness);
        }
    } catch (Exception ex) {
        logger.warn("Error in checking fatness of " + section, ex);

        return setFat(section, true);
    }
}
 

/**
 * Last attempt to include discarded (and sloped) filaments to retrieved staff lines.
 */
private void includeDiscardedFilaments ()
{
    List<StaffFilament> candidates = new ArrayList<>();
    candidates.addAll(discardedFilaments);
    candidates.addAll(slopedFilaments);

    // Sort candidates filaments by top ordinate
    Collections.sort(candidates, Filament.topComparator);

    final int iMax = candidates.size() - 1;

    for (SystemInfo system : sheet.getSystems()) {
        // Systems may be side by side, so restart from top
        int iMin = 0;

        for (Staff staff : system.getStaves()) {
            for (LineInfo line : staff.getLines()) {
                final StaffFilament filament = (StaffFilament) line;
                final Point2D startPt = filament.getStartPoint();
                final Point2D stopPt = filament.getStopPoint();
                final double minX = startPt.getX();
                final double maxX = stopPt.getX();
                final Rectangle lineBox = filament.getBounds();
                lineBox.grow(0, scale.getFore());

                final int minY = lineBox.y;
                final int maxY = lineBox.y + lineBox.height;
                boolean filamentModified = false;

                // Browse discarded filaments
                for (int i = iMin; i <= iMax; i++) {
                    Filament fil = candidates.get(i);

                    if (fil.getPartOf() != null) {
                        continue;
                    }

                    int firstPos = fil.getBounds().y;

                    if (firstPos < minY) {
                        iMin = i;

                        continue;
                    }

                    if (firstPos > maxY) {
                        break;
                    }

                    Point center = fil.getCentroid();

                    if ((center.x >= minX) && (center.x <= maxX)) {
                        if (canIncludeFilament(filament, fil)) {
                            filament.stealSections(fil);
                            filamentModified = true;
                        }
                    }
                }

                if (filamentModified) {
                    filament.setEndingPoints(startPt, stopPt); // Recompute line
                }
            }
        }
    }
}
 

@Override
protected Rectangle calculateClientArea() {
    Rectangle result = new Rectangle(clientArea);
    result.grow(10, 10);
    return result;
}
 

public void runTests() {
        GraphicsConfiguration gc = getGraphicsConfiguration();
        for (Image srcIm :
            new Image[] {
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, true),
                getBufferedImage(gc, IMAGEW, IMAGEH,
                        BufferedImage.TYPE_INT_RGB, false),
                // commented out due to 6593406
//                getBMImage(gc, IMAGEW, IMAGEH),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, true),
//                getBufferedImage(gc, IMAGEW, IMAGEH,
//                        BufferedImage.TYPE_INT_ARGB, false),
                getVImage(gc, IMAGEW, IMAGEH),
            })
        {
            System.out.println("Testing source: " + srcIm);
            // wiggle the source and dest rectangles
            try {
                for (int locationVar = -10; locationVar < 20; locationVar += 10)
                {
                    for (int sizeVar = -10; sizeVar < 20; sizeVar += 10) {
                        Rectangle srcRect = (Rectangle)IMAGE_BOUNDS.clone();
                        srcRect.translate(locationVar, locationVar);
                        srcRect.grow(sizeVar, sizeVar);

                        Rectangle dstRect =
                                new Rectangle(sizeVar, sizeVar,
                                srcRect.width, srcRect.height);
                        System.out.println("testing blit rect src: " + srcRect);
                        System.out.println("                  dst: " + dstRect);
                        render(getGraphics(), srcIm, srcRect, dstRect);
                        test(srcRect, dstRect);
                    }
                }
                System.out.println("Test passed.");
            } finally {
                synchronized (lock) {
                    done = true;
                    lock.notifyAll();
                }
            }
        }
    }
 

private List<Inter> buildStaffBarlineClosure (StaffBarlineInter oneBar)
{
    final Rectangle oneBounds = oneBar.getBounds();
    final Staff staff = oneBar.getStaff();
    final SystemInfo system = staff.getSystem();

    // Include a staffBarline per system staff, properly positioned in abscissa
    final Skew skew = sheet.getSkew();
    final Point center = GeoUtil.centerOf(oneBounds);
    final double slope = skew.getSlope();
    final List<Inter> closure = new ArrayList<>();

    for (Staff st : system.getStaves()) {
        if (st == staff) {
            closure.add(oneBar);
        } else {
            double y1 = st.getFirstLine().yAt(center.getX());
            double y2 = st.getLastLine().yAt(center.getX());
            double y = (y1 + y2) / 2;
            double x = center.x - ((y - center.y) * slope);
            Rectangle box = new Rectangle((int) Math.rint(x), (int) Math.rint(y), 0, 0);
            box.grow(oneBounds.width / 2, oneBounds.height / 2);

            StaffBarlineInter g = new StaffBarlineInter(oneBar.getShape(), 1);
            g.setManual(true);
            g.setStaff(st);
            g.setBounds(box);
            closure.add(g);
        }
    }

    // Display closure staff barlines to user
    sheet.getInterIndex().getEntityService().publish(
            new EntityListEvent<>(
                    this,
                    SelectionHint.ENTITY_INIT,
                    MouseMovement.PRESSING,
                    closure));

    if (OMR.gui.displayConfirmation(
            "Do you confirm whole system-height addition?",
            "Insertion of " + closure.size() + " barline(s)")) {
        return closure;
    } else {
        return Collections.EMPTY_LIST;
    }
}