Example usage for java.awt.geom AffineTransform transform

Introduction

In this page you can find the example usage for java.awt.geom AffineTransform transform.

Prototype

public Point2D transform(Point2D ptSrc, Point2D ptDst) 

Source Link

Document

Transforms the specified ptSrc and stores the result in ptDst .

Usage

From source file:org.jhotdraw.samples.svg.figures.SVGImage.java

public void basicTransform(AffineTransform tx) {
    Point2D.Double anchor = getStartPoint();
    Point2D.Double lead = getEndPoint();
    basicSetBounds((Point2D.Double) tx.transform(anchor, anchor), (Point2D.Double) tx.transform(lead, lead));
}

---

From source file:org.mapfish.print.map.renderers.BitmapMapRenderer.java

private boolean isTileVisible(float x, float y, long w, long h, AffineTransform bitmapTransformer,
        Transformer transformer) {
    GeometryFactory gf = new GeometryFactory();
    Polygon page = gf.createPolygon(gf.createLinearRing(new Coordinate[] {
            new Coordinate(transformer.getPaperPosX(), transformer.getPaperPosY()),
            new Coordinate(transformer.getPaperPosX() + transformer.getPaperW(), transformer.getPaperPosY()),
            new Coordinate(transformer.getPaperPosX() + transformer.getPaperW(),
                    transformer.getPaperPosY() + transformer.getPaperH()),
            new Coordinate(transformer.getPaperPosX(), transformer.getPaperPosY() + transformer.getPaperH()),
            new Coordinate(transformer.getPaperPosX(), transformer.getPaperPosY()), }), null);

    Point2D.Float ll = new Point2D.Float();
    Point2D.Float lr = new Point2D.Float();
    Point2D.Float ur = new Point2D.Float();
    Point2D.Float ul = new Point2D.Float();
    bitmapTransformer.transform(new Point2D.Float(x, y), ll);
    bitmapTransformer.transform(new Point2D.Float(x + w, y), lr);
    bitmapTransformer.transform(new Point2D.Float(x + w, y + h), ur);
    bitmapTransformer.transform(new Point2D.Float(x, y + h), ul);
    Polygon tile = gf// w w w . ja v a  2s  . c o  m
            .createPolygon(
                    gf.createLinearRing(new Coordinate[] { new Coordinate(ll.getX(), ll.getY()),
                            new Coordinate(lr.getX(), lr.getY()), new Coordinate(ur.getX(), ur.getY()),
                            new Coordinate(ul.getX(), ul.getY()), new Coordinate(ll.getX(), ll.getY()), }),
                    null);

    return page.intersects(tile);
}

---

From source file:org.mapfish.print.map.renderers.BitmapTileRenderer.java

private boolean isTileVisible(double x, double y, long w, long h, AffineTransform bitmapTransformer,
        Transformer transformer) {
    GeometryFactory gf = new GeometryFactory();
    Polygon page = gf.createPolygon(gf.createLinearRing(new Coordinate[] {
            new Coordinate(transformer.getPaperPosX(), transformer.getPaperPosY()),
            new Coordinate(transformer.getPaperPosX() + transformer.getPaperW(), transformer.getPaperPosY()),
            new Coordinate(transformer.getPaperPosX() + transformer.getPaperW(),
                    transformer.getPaperPosY() + transformer.getPaperH()),
            new Coordinate(transformer.getPaperPosX(), transformer.getPaperPosY() + transformer.getPaperH()),
            new Coordinate(transformer.getPaperPosX(), transformer.getPaperPosY()), }), null);

    Point2D.Float ll = new Point2D.Float();
    Point2D.Float lr = new Point2D.Float();
    Point2D.Float ur = new Point2D.Float();
    Point2D.Float ul = new Point2D.Float();
    bitmapTransformer.transform(new Point2D.Float((float) x, (float) y), ll);
    bitmapTransformer.transform(new Point2D.Float((float) x + w, (float) y), lr);
    bitmapTransformer.transform(new Point2D.Float((float) x + w, (float) y + h), ur);
    bitmapTransformer.transform(new Point2D.Float((float) x, (float) y + h), ul);
    Polygon tile = gf/*ww  w.jav  a2 s .c om*/
            .createPolygon(
                    gf.createLinearRing(new Coordinate[] { new Coordinate(ll.getX(), ll.getY()),
                            new Coordinate(lr.getX(), lr.getY()), new Coordinate(ur.getX(), ur.getY()),
                            new Coordinate(ul.getX(), ul.getY()), new Coordinate(ll.getX(), ll.getY()), }),
                    null);

    return page.intersects(tile);
}

---

From source file:org.micromanager.plugins.magellan.propsandcovariants.LaserPredNet.java

public byte[] getExcitations(AcquisitionEvent e, SurfaceInterpolator surf) throws InterruptedException {
    XYStagePosition xyPos = e.xyPosition_;
    double zPos = e.zPosition_;
    Point2D.Double[] corners = xyPos.getFullTileCorners();
    double tileSize = Math.abs(corners[2].x - corners[0].x);
    int pixelDim = JavaLayerImageConstructor.getInstance().getImageHeight();

    AffineTransform posTransform = AffineUtils.getAffineTransform(getCurrentPixelSizeConfig(),
            xyPos.getCenter().x, xyPos.getCenter().y);

    double[][] designMat = new double[FOV_LASER_MODULATION_RESOLUTION
            * FOV_LASER_MODULATION_RESOLUTION][N_HIST_BINS + 3];
    //      designMatrix = [designMatrix tilePosition brightness];
    for (int r = 0; r < designMat.length; r++) {
        //calculate position for this point in FOV
        int xPosPix = (int) (((r % FOV_LASER_MODULATION_RESOLUTION)
                / (double) (FOV_LASER_MODULATION_RESOLUTION - 1) - 0.5) * pixelDim);
        int yPosPix = (int) (((r / FOV_LASER_MODULATION_RESOLUTION)
                / (double) (FOV_LASER_MODULATION_RESOLUTION - 1) - 0.5) * pixelDim);
        Point2D.Double stageCoordPos = new Point2D.Double();
        posTransform.transform(new Point2D.Double(xPosPix, yPosPix), stageCoordPos);
        //calculate histogram
        double[] hist = new double[N_HIST_BINS];
        for (int thetaIndex = 0; thetaIndex < N_THETA_ANGLES; thetaIndex++) {
            double dist = getSampledDistancesToSurface(thetaIndex, stageCoordPos.x, stageCoordPos.y, zPos,
                    surf);//from  w w w . ja  v  a2 s  . c  om
            //add count to hist
            for (int binIndex = 0; binIndex < N_HIST_BINS; binIndex++) {
                if (dist < binedges_[binIndex + 1]) {
                    hist[binIndex]++;
                    break;
                }
            }
        }
        //standardize histogram
        for (int i = 0; i < hist.length; i++) {
            hist[i] = (hist[i] - distanceMeans_[i]) / distanceSDs_[i];
        }

        for (int c = 0; c < designMat[0].length; c++) {
            if (c < N_HIST_BINS) {
                //add in normalized distance histogram
                designMat[r][c] = hist[c];
            } else if (c < N_HIST_BINS + 1) { // x position                        
                double xPos = (r % FOV_LASER_MODULATION_RESOLUTION)
                        / (double) (FOV_LASER_MODULATION_RESOLUTION - 1);
                designMat[r][c] = xPos - 0.5;
            } else if (c < N_HIST_BINS + 2) { // y position                            
                double yPos = (r / FOV_LASER_MODULATION_RESOLUTION)
                        / (double) (FOV_LASER_MODULATION_RESOLUTION - 1);
                designMat[r][c] = yPos - 0.5;
            } else {
                designMat[r][c] = brightness_;
            }
        }
    }
    //use NN to predict       
    return forwardPass(designMat);
}

---

From source file:org.micromanager.plugins.magellan.propsandcovariants.SurfaceData.java

public double[] curvedSurfacePower(AcquisitionEvent event, double multiplier) {
    XYStagePosition xyPos = event.xyPosition_;
    double zPosition = event.zPosition_;
    Point2D.Double[] corners = xyPos.getFullTileCorners();
    //square is aligned with axes in pixel space, so convert to pixel space to generate test points
    double xSpan = corners[2].getX() - corners[0].getX();
    double ySpan = corners[2].getY() - corners[0].getY();
    Point2D.Double pixelSpan = new Point2D.Double();
    AffineTransform transform = AffineUtils.getAffineTransform(surface_.getCurrentPixelSizeConfig(), 0, 0);
    try {//from   w  w  w  .ja va2 s  .c  o m
        transform.inverseTransform(new Point2D.Double(xSpan, ySpan), pixelSpan);
    } catch (NoninvertibleTransformException ex) {
        Log.log("Problem inverting affine transform");
    }

    double[] relativePower = new double[FOV_LASER_MODULATION_RESOLUTION * FOV_LASER_MODULATION_RESOLUTION];
    for (int xInd = 0; xInd < FOV_LASER_MODULATION_RESOLUTION; xInd++) {
        for (int yInd = 0; yInd < FOV_LASER_MODULATION_RESOLUTION; yInd++) {

            double x = ((0.5 + pixelSpan.x) / (double) FOV_LASER_MODULATION_RESOLUTION) * xInd;
            double y = ((0.5 + pixelSpan.y) / (double) FOV_LASER_MODULATION_RESOLUTION) * yInd;
            //convert these abritray pixel coordinates back to stage coordinates
            double[] transformMaxtrix = new double[6];
            transform.getMatrix(transformMaxtrix);
            transformMaxtrix[4] = corners[0].getX();
            transformMaxtrix[5] = corners[0].getY();
            //create new transform with translation applied
            transform = new AffineTransform(transformMaxtrix);
            Point2D.Double stageCoords = new Point2D.Double();
            transform.transform(new Point2D.Double(x, y), stageCoords);

            //Index in the way Teensy expects data
            int flatIndex = xInd + FOV_LASER_MODULATION_RESOLUTION * yInd;
            try {
                //test point for inclusion of position
                if (!surface_.waitForCurentInterpolation().isInterpDefined(stageCoords.x, stageCoords.y)) {
                    //if position is outside of convex hull, use minimum laser power
                    relativePower[flatIndex] = basePower_;
                } else {
                    float interpVal = surface_.waitForCurentInterpolation().getInterpolatedValue(stageCoords.x,
                            stageCoords.y);
                    float normalAngle = surface_.waitForCurentInterpolation()
                            .getNormalAngleToVertical(stageCoords.x, stageCoords.y);
                    relativePower[flatIndex] = basePower_
                            * CurvedSurfaceCalculations.getRelativePower(meanFreePath_,
                                    Math.max(0, zPosition - interpVal), normalAngle, radiusOfCurvature_)
                            * multiplier;
                }
            } catch (InterruptedException ex) {
                Log.log("Couldn't calculate curved surface power");
                Log.log(ex);
                return null;
            }
        }
    }
    return relativePower;
}

---

From source file:org.micromanager.plugins.magellan.propsandcovariants.SurfaceData.java

/**
  *//from www. j ava 2 s .  c om
  * @param corners
  * @param min true to get min, false to get max
  * @return {minDistance,maxDistance, minNormalAngle, maxNormalAngle)
  */
private double[] distanceAndNormalCalc(Point2D.Double[] corners, double zVal) throws InterruptedException {
    //check a grid of points spanning entire position        
    //square is aligned with axes in pixel space, so convert to pixel space to generate test points
    double xSpan = corners[2].getX() - corners[0].getX();
    double ySpan = corners[2].getY() - corners[0].getY();
    Point2D.Double pixelSpan = new Point2D.Double();
    AffineTransform transform = AffineUtils.getAffineTransform(surface_.getCurrentPixelSizeConfig(), 0, 0);
    try {
        transform.inverseTransform(new Point2D.Double(xSpan, ySpan), pixelSpan);
    } catch (NoninvertibleTransformException ex) {
        Log.log("Problem inverting affine transform");
    }
    double minDistance = Integer.MAX_VALUE;
    double maxDistance = 0;
    double minNormalAngle = 90;
    double maxNormalAngle = 0;
    for (double x = 0; x <= pixelSpan.x; x += pixelSpan.x / (double) NUM_XY_TEST_POINTS) {
        for (double y = 0; y <= pixelSpan.y; y += pixelSpan.y / (double) NUM_XY_TEST_POINTS) {
            //convert these abritray pixel coordinates back to stage coordinates
            double[] transformMaxtrix = new double[6];
            transform.getMatrix(transformMaxtrix);
            transformMaxtrix[4] = corners[0].getX();
            transformMaxtrix[5] = corners[0].getY();
            //create new transform with translation applied
            transform = new AffineTransform(transformMaxtrix);
            Point2D.Double stageCoords = new Point2D.Double();
            transform.transform(new Point2D.Double(x, y), stageCoords);
            //test point for inclusion of position
            if (!surface_.waitForCurentInterpolation().isInterpDefined(stageCoords.x, stageCoords.y)) {
                //if position is outside of convex hull, assume min distance is 0
                minDistance = 0;
                //get extrapolated value for max distance
                float interpVal = surface_.getExtrapolatedValue(stageCoords.x, stageCoords.y);
                maxDistance = Math.max(zVal - interpVal, maxDistance);
                //only take actual values for normals
            } else {
                float interpVal = surface_.waitForCurentInterpolation().getInterpolatedValue(stageCoords.x,
                        stageCoords.y);
                float normalAngle = surface_.waitForCurentInterpolation()
                        .getNormalAngleToVertical(stageCoords.x, stageCoords.y);
                minDistance = Math.min(Math.max(0, zVal - interpVal), minDistance);
                maxDistance = Math.max(zVal - interpVal, maxDistance);
                minNormalAngle = Math.min(minNormalAngle, normalAngle);
                maxNormalAngle = Math.max(maxNormalAngle, normalAngle);
            }
        }
    }
    return new double[] { minDistance, maxDistance, minNormalAngle, maxNormalAngle };
}

---

From source file:org.micromanager.plugins.magellan.surfacesandregions.MultiPosRegion.java

@Override
public ArrayList<XYStagePosition> getXYPositionsNoUpdate() {
    try {/*from  w  w w . java2 s  .c  o  m*/
        AffineTransform transform = AffineUtils
                .getAffineTransform(Magellan.getCore().getCurrentPixelSizeConfig(), center_.x, center_.y);
        ArrayList<XYStagePosition> positions = new ArrayList<XYStagePosition>();
        int fullTileWidth = JavaLayerImageConstructor.getInstance().getImageWidth();
        int fullTileHeight = JavaLayerImageConstructor.getInstance().getImageHeight();
        int tileWidthMinusOverlap = fullTileWidth - overlapX_;
        int tileHeightMinusOverlap = fullTileHeight - overlapY_;
        for (int col = 0; col < cols_; col++) {
            double xPixelOffset = (col - (cols_ - 1) / 2.0) * tileWidthMinusOverlap;
            for (int row = 0; row < rows_; row++) {
                double yPixelOffset = (row - (rows_ - 1) / 2.0) * tileHeightMinusOverlap;
                Point2D.Double pixelPos = new Point2D.Double(xPixelOffset, yPixelOffset);
                Point2D.Double stagePos = new Point2D.Double();
                transform.transform(pixelPos, stagePos);
                AffineTransform posTransform = AffineUtils.getAffineTransform(pixelSizeConfig_, stagePos.x,
                        stagePos.y);
                positions.add(new XYStagePosition(stagePos, tileWidthMinusOverlap, tileHeightMinusOverlap,
                        fullTileWidth, fullTileHeight, row, col, posTransform));
            }
        }
        return positions;
    } catch (Exception ex) {
        Log.log("Couldn't get affine transform");
        throw new RuntimeException();
    }
}

---

From source file:org.micromanager.plugins.magellan.surfacesandregions.MultiPosRegion.java

@Override
public ArrayList<XYStagePosition> getXYPositions(double tileOverlapPercent) {
    try {/* w  w  w . j a v  a2s  .co  m*/
        AffineTransform transform = AffineUtils
                .getAffineTransform(Magellan.getCore().getCurrentPixelSizeConfig(), center_.x, center_.y);
        ArrayList<XYStagePosition> positions = new ArrayList<XYStagePosition>();
        int fullTileWidth = JavaLayerImageConstructor.getInstance().getImageWidth();
        int fullTileHeight = JavaLayerImageConstructor.getInstance().getImageHeight();
        updateOverlap(tileOverlapPercent / 100);
        int tileWidthMinusOverlap = fullTileWidth - overlapX_;
        int tileHeightMinusOverlap = fullTileHeight - overlapY_;
        for (int col = 0; col < cols_; col++) {
            double xPixelOffset = (col - (cols_ - 1) / 2.0) * tileWidthMinusOverlap;
            for (int row = 0; row < rows_; row++) {
                double yPixelOffset = (row - (rows_ - 1) / 2.0) * tileHeightMinusOverlap;
                Point2D.Double pixelPos = new Point2D.Double(xPixelOffset, yPixelOffset);
                Point2D.Double stagePos = new Point2D.Double();
                transform.transform(pixelPos, stagePos);
                AffineTransform posTransform = AffineUtils.getAffineTransform(pixelSizeConfig_, stagePos.x,
                        stagePos.y);
                positions.add(new XYStagePosition(stagePos, tileWidthMinusOverlap, tileHeightMinusOverlap,
                        fullTileWidth, fullTileHeight, row, col, posTransform));
            }
        }
        return positions;
    } catch (Exception ex) {
        Log.log("Couldn't get affine transform");
        throw new RuntimeException();
    }
}

---

From source file:org.micromanager.plugins.magellan.surfacesandregions.SurfaceInterpolator.java

/**
 * test whether XY position is completely abve or completely below surface
 * @throws InterruptedException //from   www .j  a  v a 2 s  .c  om
 */
public boolean testPositionRelativeToSurface(XYStagePosition pos, SurfaceInterpolator surface, double zPos,
        int mode, boolean extrapolate) throws InterruptedException {
    //get the corners with padding added in
    Point2D.Double[] corners = getPositionCornersWithPadding(pos, surface.xyPadding_um_);
    //First check position corners before going into a more detailed set of test points
    for (Point2D.Double point : corners) {
        float interpVal;
        if (!surface.waitForCurentInterpolation().isInterpDefined(point.x, point.y)) {
            if (extrapolate) {
                interpVal = surface.getExtrapolatedValue(point.x, point.y);
            } else {
                continue;
            }
        } else {
            interpVal = surface.waitForCurentInterpolation().getInterpolatedValue(point.x, point.y);
        }
        if ((towardsSampleIsPositive_ && mode == ABOVE_SURFACE && zPos >= interpVal)
                || (towardsSampleIsPositive_ && mode == BELOW_SURFACE && zPos <= interpVal)
                || (!towardsSampleIsPositive_ && mode == ABOVE_SURFACE && zPos <= interpVal)
                || (!towardsSampleIsPositive_ && mode == BELOW_SURFACE) && zPos >= interpVal) {
            return false;
        }
    }
    //then check a grid of points spanning entire position        
    //9x9 square of points to check for each position
    //square is aligned with axes in pixel space, so convert to pixel space to generate test points
    double xSpan = corners[2].getX() - corners[0].getX();
    double ySpan = corners[2].getY() - corners[0].getY();
    Point2D.Double pixelSpan = new Point2D.Double();
    AffineTransform transform = AffineUtils.getAffineTransform(getCurrentPixelSizeConfig(), 0, 0);
    try {
        transform.inverseTransform(new Point2D.Double(xSpan, ySpan), pixelSpan);
    } catch (NoninvertibleTransformException ex) {
        Log.log("Problem inverting affine transform");
    }
    outerloop: for (double x = 0; x <= pixelSpan.x; x += pixelSpan.x / (double) NUM_XY_TEST_POINTS) {
        for (double y = 0; y <= pixelSpan.y; y += pixelSpan.y / (double) NUM_XY_TEST_POINTS) {
            //convert these abritray pixel coordinates back to stage coordinates
            double[] transformMaxtrix = new double[6];
            transform.getMatrix(transformMaxtrix);
            transformMaxtrix[4] = corners[0].getX();
            transformMaxtrix[5] = corners[0].getY();
            //create new transform with translation applied
            transform = new AffineTransform(transformMaxtrix);
            Point2D.Double stageCoords = new Point2D.Double();
            transform.transform(new Point2D.Double(x, y), stageCoords);
            //test point for inclusion of position
            float interpVal;
            if (!surface.waitForCurentInterpolation().isInterpDefined(stageCoords.x, stageCoords.y)) {
                if (extrapolate) {
                    interpVal = surface.getExtrapolatedValue(stageCoords.x, stageCoords.y);
                } else {
                    continue;
                }
            } else {
                interpVal = surface.waitForCurentInterpolation().getInterpolatedValue(stageCoords.x,
                        stageCoords.y);
            }
            if ((towardsSampleIsPositive_ && mode == ABOVE_SURFACE && zPos >= interpVal)
                    || (towardsSampleIsPositive_ && mode == BELOW_SURFACE && zPos <= interpVal)
                    || (!towardsSampleIsPositive_ && mode == ABOVE_SURFACE && zPos <= interpVal)
                    || (!towardsSampleIsPositive_ && mode == BELOW_SURFACE) && zPos >= interpVal) {
                return false;
            }
        }
    }
    return true;
}

---

From source file:org.micromanager.plugins.magellan.surfacesandregions.SurfaceInterpolator.java

private void fitXYPositionsToConvexHull(double overlap) throws InterruptedException {
    int fullTileWidth = JavaLayerImageConstructor.getInstance().getImageWidth();
    int fullTileHeight = JavaLayerImageConstructor.getInstance().getImageHeight();
    int overlapX = (int) (JavaLayerImageConstructor.getInstance().getImageWidth() * overlap / 100);
    int overlapY = (int) (JavaLayerImageConstructor.getInstance().getImageHeight() * overlap / 100);
    int tileWidthMinusOverlap = fullTileWidth - overlapX;
    int tileHeightMinusOverlap = fullTileHeight - overlapY;
    int pixelPadding = (int) (xyPadding_um_ / Magellan.getCore().getPixelSizeUm());
    numRows_ = (int) Math
            .ceil((boundYPixelMax_ - boundYPixelMin_ + pixelPadding) / (double) tileHeightMinusOverlap);
    numCols_ = (int) Math
            .ceil((boundXPixelMax_ - boundXPixelMin_ + pixelPadding) / (double) tileWidthMinusOverlap);

    //take center of bounding box and create grid
    int pixelCenterX = boundXPixelMin_ + (boundXPixelMax_ - boundXPixelMin_) / 2;
    int pixelCenterY = boundYPixelMin_ + (boundYPixelMax_ - boundYPixelMin_) / 2;

    AffineTransform transform = AffineUtils.getAffineTransform(getCurrentPixelSizeConfig(), 0, 0);
    ArrayList<XYStagePosition> positions = new ArrayList<XYStagePosition>();
    Point2D.Double gridCenterStageCoords = new Point2D.Double();
    transform.transform(new Point2D.Double(pixelCenterX, pixelCenterY), gridCenterStageCoords);
    gridCenterStageCoords.x += convexHullVertices_[0].getX();
    gridCenterStageCoords.y += convexHullVertices_[0].getY();
    //set affine transform translation relative to grid center
    double[] transformMaxtrix = new double[6];
    transform.getMatrix(transformMaxtrix);
    transformMaxtrix[4] = gridCenterStageCoords.x;
    transformMaxtrix[5] = gridCenterStageCoords.y;
    //create new transform with translation applied
    transform = new AffineTransform(transformMaxtrix);
    //add all positions of rectangle around convex hull
    for (int col = 0; col < numCols_; col++) {
        double xPixelOffset = (col - (numCols_ - 1) / 2.0) * (tileWidthMinusOverlap);
        for (int row = 0; row < numRows_; row++) {
            if (Thread.interrupted()) {
                throw new InterruptedException();
            }/*from  w w  w  .  j  a  v a 2  s . c  om*/
            double yPixelOffset = (row - (numRows_ - 1) / 2.0) * (tileHeightMinusOverlap);
            Point2D.Double pixelPos = new Point2D.Double(xPixelOffset, yPixelOffset);
            Point2D.Double stagePos = new Point2D.Double();
            transform.transform(pixelPos, stagePos);
            AffineTransform posTransform = AffineUtils.getAffineTransform(getCurrentPixelSizeConfig(),
                    stagePos.x, stagePos.y);
            positions.add(new XYStagePosition(stagePos, tileWidthMinusOverlap, tileHeightMinusOverlap,
                    fullTileWidth, fullTileHeight, row, col, posTransform));
        }
    }
    //delete positions squares (+padding) that do not overlap convex hull
    for (int i = positions.size() - 1; i >= 0; i--) {
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        XYStagePosition pos = positions.get(i);
        //create square region correpsonding to stage pos
        Region<Euclidean2D> square = getStagePositionRegion(pos);
        //if convex hull and position have no intersection, delete
        Region<Euclidean2D> intersection = regionFacotry_.intersection(square, convexHullRegion_);
        if (intersection.isEmpty()) {
            positions.remove(i);
        }
        square.getBoundarySize();
    }
    if (Thread.interrupted()) {
        throw new InterruptedException();
    }
    synchronized (xyPositionLock_) {
        xyPositions_ = positions;
        xyPositionLock_.notifyAll();
    }

    //let manger know new parmas caluclated
    manager_.updateSurfaceTableAndCombos();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »