java类com.vividsolutions.jts.geom.util.AffineTransformation的实例源码

public void addObstacles(Geometry ... geom) {
    if (this.mapFilename == null) throw new Error("Please set a map file first!");
    BufferedImage img = null;
    try {
        img = ImageIO.read(new File(mapFilename)); 
        System.out.println("IMGTYPE: " + img.getType());
        Graphics2D g2 = img.createGraphics();
        ShapeWriter writer = new ShapeWriter();
        g2.setPaint(Color.black);
        for (Geometry g : geom) {
            AffineTransformation at = new AffineTransformation();
            at.scale(1.0/mapResolution, -1.0/mapResolution);
            at.translate(0, img.getHeight());
            Geometry scaledGeom = at.transform(g);
            Shape shape = writer.toShape(scaledGeom);
            System.out.println("Shape: " + shape.getBounds2D());
            g2.fill(shape);
        }
        File outputfile = new File(TEMP_MAP_DIR + File.separator + "tempMap" + (numObstacles++) + ".png");
        ImageIO.write(img, "png", outputfile);
        this.mapFilename = outputfile.getAbsolutePath();
    }
    catch (IOException e) { e.printStackTrace(); }      
}

public void addObstacles(Geometry geom, Pose ... poses) {
    if (this.mapFilename == null) throw new Error("Please set a map file first!");
    BufferedImage img = null;
    try {
        img = ImageIO.read(new File(mapFilename)); 
        Graphics2D g2 = img.createGraphics();
        ShapeWriter writer = new ShapeWriter();
        g2.setPaint(Color.black);
        for (Pose pose : poses) {
            AffineTransformation at = new AffineTransformation();
            at.rotate(pose.getTheta());
            at.translate(pose.getX(), pose.getY());
            at.scale(1.0/mapResolution, -1.0/mapResolution);
            at.translate(0, img.getHeight());
            Geometry scaledGeom = at.transform(geom);
            Shape shape = writer.toShape(scaledGeom);
            System.out.println("Shape: " + shape.getBounds2D());
            g2.fill(shape);
        }
        File outputfile = new File(TEMP_MAP_DIR + File.separator + "tempMap" + (numObstacles++) + ".png");
        ImageIO.write(img, "png", outputfile);
        this.mapFilename = outputfile.getAbsolutePath();
    }
    catch (IOException e) { e.printStackTrace(); }
}

private Geometry makeObstacle(Pose p) {
    GeometryFactory gf = new GeometryFactory();
    Geometry geom = null;
    if (obstacleFootprint == null) {
        geom = gf.createPolygon(new Coordinate[] { new Coordinate(0.0,0.0), new Coordinate(0.0,OBSTACLE_SIZE), new Coordinate(OBSTACLE_SIZE,OBSTACLE_SIZE), new Coordinate(OBSTACLE_SIZE,0.0), new Coordinate(0.0,0.0) });
    }
    else {
        geom = gf.createPolygon(obstacleFootprint);
    }       
    AffineTransformation at = new AffineTransformation();
    at.rotate(p.getTheta());
    at.translate(p.getX(), p.getY());
    Geometry transGeom = at.transform(geom);
    Pose center = new Pose(p.getX(), p.getY(), p.getTheta());
    obstacles.add(transGeom);
    obstacleCenters.add(center);
    return transGeom;
}

/**
 * If the user mutate the geometry of the object, the object cache must not
 * be updated.
 */
private void testInPlaceUpdate() throws SQLException {
    Connection conn = getConnection(url);
    try {
        ResultSet rs = conn.createStatement().executeQuery(
                "SELECT 'POINT(1 1)'::geometry");
        assertTrue(rs.next());
        // Mutate the geometry
        ((Geometry) rs.getObject(1)).apply(new AffineTransformation(1, 0,
                1, 1, 0, 1));
        rs.close();
        rs = conn.createStatement().executeQuery(
                "SELECT 'POINT(1 1)'::geometry");
        assertTrue(rs.next());
        // Check if the geometry is the one requested
        assertEquals(1, ((Point) rs.getObject(1)).getX());
        assertEquals(1, ((Point) rs.getObject(1)).getY());
        rs.close();
    } finally {
        conn.close();
    }
}

private Geometry createArrow(Pose pose1, Pose pose2) {      
    GeometryFactory gf = new GeometryFactory();
    double aux = 1.8;
    double distance = (1.6/targetArrowHeadWidth)*Math.sqrt(Math.pow((pose2.getX()-pose1.getX()),2)+Math.pow((pose2.getY()-pose1.getY()),2));
    double theta = Math.atan2(pose2.getY() - pose1.getY(), pose2.getX() - pose1.getX());
    Coordinate[] coords = new Coordinate[8];
    coords[0] = new Coordinate(0.0,-0.3);
    coords[1] = new Coordinate(distance-aux,-0.3);
    coords[2] = new Coordinate(distance-aux,-0.8);
    coords[3] = new Coordinate(distance,0.0);
    coords[4] = new Coordinate(distance-aux,0.8);
    coords[5] = new Coordinate(distance-aux,0.3);
    coords[6] = new Coordinate(0.0,0.3);
    coords[7] = new Coordinate(0.0,-0.3);
    Polygon arrow = gf.createPolygon(coords);
    AffineTransformation at = new AffineTransformation();
    at.scale(targetArrowHeadWidth/1.6, targetArrowHeadWidth/1.6);
    at.rotate(theta);
    at.translate(pose1.getX(), pose1.getY());
    Geometry ret = at.transform(arrow);
    return ret;
}

private Geometry createArrow(Pose pose) {
    GeometryFactory gf = new GeometryFactory();
    Coordinate[] coords = new Coordinate[8];
    coords[0] = new Coordinate(0.0,-0.3);
    coords[1] = new Coordinate(2.0,-0.3);
    coords[2] = new Coordinate(2.0,-0.8);
    coords[3] = new Coordinate(3.0,0.0);
    coords[4] = new Coordinate(2.0,0.8);
    coords[5] = new Coordinate(2.0,0.3);
    coords[6] = new Coordinate(0.0,0.3);
    coords[7] = new Coordinate(0.0,-0.3);
    Polygon arrow = gf.createPolygon(coords);
    AffineTransformation at = new AffineTransformation();
    at.scale(1.6/targetArrowHeadWidth, 1.6/targetArrowHeadWidth);
    at.rotate(pose.getTheta());
    at.translate(pose.getX(), pose.getY());
    Geometry ret = at.transform(arrow);
    return ret;
}

public AsteroidsSprite getNearestIntersected(Point loc, double rot, GameState world) {

  // Create worldTransform to transform to the local-space shape to world-space:
  AffineTransformation trans = new AffineTransformation();
  trans.rotate(-rot);
  trans.translate(loc.getX(), loc.getY());
  worldShape = new PolyWrapper((Polygon)trans.transform(localShape));

  // List of AsteroidsSprites that intersect with a circle described by
  // <loc, distanceToNearest>
  List<AsteroidsSprite> intersected = world.intersects(worldShape);

  // Nearest AsteroidsSprite:
  AsteroidsSprite nearest = AsteroidsSprite.nearest(loc, intersected);

  return nearest;
}

public static AffineTransformation getWorldToRectangle( Envelope worldEnvelope, Rectangle pixelRectangle ) {
    int cols = (int) pixelRectangle.getWidth();
    int rows = (int) pixelRectangle.getHeight();
    double worldWidth = worldEnvelope.getWidth();
    double worldHeight = worldEnvelope.getHeight();

    double x = -worldEnvelope.getMinX();
    double y = -worldEnvelope.getMinY();
    AffineTransformation translate = AffineTransformation.translationInstance(x, y);
    double xScale = cols / worldWidth;
    double yScale = rows / worldHeight;
    AffineTransformation scale = AffineTransformation.scaleInstance(xScale, yScale);

    int m00 = 1;
    int m10 = 0;
    int m01 = 0;
    int m11 = -1;
    int m02 = 0;
    int m12 = rows;
    AffineTransformation mirror_y = new AffineTransformation(m00, m01, m02, m10, m11, m12);

    AffineTransformation world2pixel = new AffineTransformation(translate);
    world2pixel.compose(scale);
    world2pixel.compose(mirror_y);
    return world2pixel;
}

public void testTransformationUtils2() throws Exception {
    Envelope env = new Envelope(100, 200, 1000, 5000);
    Rectangle rect = new Rectangle(0, 0, 100, 4000);

    AffineTransformation worldToPixel = TransformationUtils.getWorldToRectangle(env, rect);

    Coordinate srcPt = new Coordinate(150.0, 3000.0);
    Coordinate transformed = worldToPixel.transform(srcPt, new Coordinate());
    assertEquals(50, (int) transformed.x);
    assertEquals(2000, (int) transformed.y);

    srcPt = new Coordinate(100.0, 1000.0);
    transformed = worldToPixel.transform(srcPt, new Coordinate());
    assertEquals(0, (int) transformed.x);
    assertEquals(4000, (int) transformed.y);
}

protected Geometry rotate(Geometry geom) {
    if (this.rotationAngle != 0.0) {
        AffineTransformation trans = AffineTransformation.rotationInstance(this.rotationAngle,
                this.dim.getCentre().x, this.dim.getCentre().y);
        geom.apply(trans);
    }
    return geom;
}

public static void transformTest() {
    /*
     * 37.5116785 127.1021436
     * 
     * 37.5119898 127.1025482
     * 
     * 37.5134122 127.1025103
     */
    /*
     * 
     */
    Coordinate coord1 = new Coordinate(0.14195979899497488, 0.056451612903225756);
    Coordinate coord2 = new Coordinate(0.44597989949748745, 0.1088709677419355);
    Coordinate coord3 = new Coordinate(0.9849246231155779, 0.9905913978494624);
    Coordinate coord4 = new Coordinate(37.5116785, 127.1021436);
    Coordinate coord5 = new Coordinate(37.5119898, 127.1025482);
    Coordinate coord6 = new Coordinate(37.5134122, 127.1025103);

    Coordinate test = new Coordinate(0.9510050251256281, 0.728494623655914);

    Point p = JTSFactoryFinder.getGeometryFactory().createPoint(test);

    AffineTransformation affine = new AffineTransformationBuilder(coord1, coord2, coord3,
            coord4, coord5, coord6).getTransformation();
    Geometry geom = affine.transform(p);
    System.out.println(geom.toText());
}

/**
 * Returns a {@link Geometry} representing the footprint of the robot in a given pose.
 * @param x The x coordinate of the pose used to create the footprint.
 * @param y The y coordinate of the pose used to create the footprint.
 * @param theta The orientation of the pose used to create the footprint.
 * @return A {@link Geometry} representing the footprint of the robot in a given pose.
 */
public Geometry makeFootprint(double x, double y, double theta) {
    AffineTransformation at = new AffineTransformation();
    at.rotate(theta);
    at.translate(x,y);
    Geometry rect = at.transform(footprint);
    return rect;
}

/**
 * Returns a {@link Geometry} representing the inner footprint of the robot in a given pose.
 * @param x The x coordinate of the pose used to create the inner footprint.
 * @param y The y coordinate of the pose used to create the inner footprint.
 * @param theta The orientation of the pose used to create the inner footprint.
 * @return A {@link Geometry} representing the footprint of the inner robot in a given pose.
 */
public Geometry makeInnerFootprint(double x, double y, double theta) {
    AffineTransformation at = new AffineTransformation();
    at.rotate(theta);
    at.translate(x,y);
    Geometry rect = at.transform(innerFootprint);
    return rect;
}

@Override
public List<Geometry> listToroidalGeometries(final Geometry geom) {
    final Geometry copy = (Geometry) geom.clone();
    final List<Geometry> geoms = new ArrayList<Geometry>();
    final AffineTransformation at = new AffineTransformation();
    geoms.add(copy);
    for (int cnt = 0; cnt < 8; cnt++) {
        at.setToTranslation(adjustedXVector[cnt], adjustedYVector[cnt]);
        geoms.add(at.transform(copy));
    }
    return geoms;
}

public Geometry returnToroidalGeom(final GamaPoint loc) {
    final List<Geometry> geoms = new ArrayList<Geometry>();
    final Point pt = GeometryUtils.GEOMETRY_FACTORY.createPoint(loc);
    final AffineTransformation at = new AffineTransformation();
    geoms.add(pt);
    for (int cnt = 0; cnt < 8; cnt++) {
        at.setToTranslation(adjustedXVector[cnt], adjustedYVector[cnt]);
        geoms.add(at.transform(pt));
    }
    return GeometryUtils.GEOMETRY_FACTORY.buildGeometry(geoms);
}

protected Geometry rotate(Geometry geom) {
    if (rotationAngle != 0.0) {
        AffineTransformation trans = AffineTransformation.rotationInstance(rotationAngle,
                dim.getCentre().x, dim.getCentre().y);
        geom.apply(trans);
    }
    return geom;
}

/**
 * Helper function to run the Vectorize operation with given parameters and
 * retrieve the vectors.
 * 
 * @param src the source {@link GridCoverage2D}.
 * @param args a {@code Map} of parameter names and values or <code>null</code>.
 * 
 * @return the generated vectors as JTS Polygons
 */
@SuppressWarnings("unchecked")
public static Collection<Polygon> doVectorize( GridCoverage2D src, Map<String, Object> args ) {
    if (args == null) {
        args = new HashMap<String, Object>();
    }

    ParameterBlockJAI pb = new ParameterBlockJAI("Vectorize");
    pb.setSource("source0", src.getRenderedImage());

    // Set any parameters that were passed in
    for( Entry<String, Object> e : args.entrySet() ) {
        pb.setParameter(e.getKey(), e.getValue());
    }

    // Get the desintation image: this is the unmodified source image data
    // plus a property for the generated vectors
    RenderedOp dest = JAI.create("Vectorize", pb);

    // Get the vectors
    Collection<Polygon> polygons = (Collection<Polygon>) dest.getProperty(VectorizeDescriptor.VECTOR_PROPERTY_NAME);

    RegionMap regionParams = CoverageUtilities.getRegionParamsFromGridCoverage(src);
    double xRes = regionParams.getXres();
    double yRes = regionParams.getYres();
    final AffineTransform mt2D = (AffineTransform) src.getGridGeometry().getGridToCRS2D(PixelOrientation.CENTER);
    final AffineTransformation jtsTransformation = new AffineTransformation(mt2D.getScaleX(), mt2D.getShearX(),
            mt2D.getTranslateX() - xRes / 2.0, mt2D.getShearY(), mt2D.getScaleY(), mt2D.getTranslateY() + yRes / 2.0);
    for( Polygon polygon : polygons ) {
        polygon.apply(jtsTransformation);
    }
    return polygons;
}

protected Geometry rotate(Geometry geom)
{
  if (rotationAngle != 0.0) {
    AffineTransformation trans = AffineTransformation.rotationInstance(rotationAngle, 
        dim.getCentre().x, dim.getCentre().y);
    geom.apply(trans);
  }
  return geom;
}

public static Geometry translate(Geometry g, double x, double y)
{
  AffineTransformation trans = AffineTransformation.translationInstance(x, y);

  Geometry newG = (Geometry) g.clone();
  newG.apply(trans);
  return newG;
}

/**
 * Rotates the geometry around the point (x,y)
 * @param g
 * @param angle
 * @param x
 * @param y
 * @return
 */
public static Geometry rotate(Geometry g, double angle, double x, double y)
{
  AffineTransformation trans = AffineTransformation.translationInstance(-x, -y);
  trans.rotate(angle);
  trans.translate(x, y);

  Geometry newG = (Geometry) g.clone();
  newG.apply(trans);
  return newG;
}

/**
 * Reflects the geometry around the line x=y.
 * 
 * @param g
 * @param angle
 * @return
 */
public static Geometry reflect(Geometry g)
{
  AffineTransformation trans = AffineTransformation.reflectionInstance(1, 1);

  Geometry newG = (Geometry) g.clone();
  newG.apply(trans);
  return newG;
}

protected Geometry rotate(Geometry geom)
{
  if (rotationAngle != 0.0) {
    AffineTransformation trans = AffineTransformation.rotationInstance(rotationAngle, 
        dim.getCentre().x, dim.getCentre().y);
    geom.apply(trans);
  }
  return geom;
}

/**
 * <p>Create geometry clipped and then converted to MVT 'extent' coordinates. Result
 * contains both clipped geometry (intersection) and transformed geometry for encoding to
 * MVT.</p>
 * <p>Allows specifying separate tile and clipping coordinates. {@code clipEnvelope} can be bigger
 * than {@code tileEnvelope} to have geometry exist outside the MVT tile extent.</p>
 *
 * @param geometryList   original 'source' geometry, passed through
 *                       {@link #flatFeatureList(Geometry)}
 * @param tileEnvelope   world coordinate bounds for tile, used for transforms
 * @param clipEnvelope   world coordinates to clip tile by
 * @param geomFactory    creates a geometry for the tile envelope
 * @param mvtLayerParams specifies vector tile properties
 * @param filter         geometry values that fail filter after transforms are removed
 * @return tile geometry result
 * @see TileGeomResult
 */
public static TileGeomResult createTileGeom(List<Geometry> geometryList,
                                            Envelope tileEnvelope,
                                            Envelope clipEnvelope,
                                            GeometryFactory geomFactory,
                                            MvtLayerParams mvtLayerParams,
                                            IGeometryFilter filter) {

  final Geometry tileClipGeom = geomFactory.toGeometry(clipEnvelope);

  final AffineTransformation t = new AffineTransformation();
  final double xDiff = tileEnvelope.getWidth();
  final double yDiff = tileEnvelope.getHeight();

  final double xOffset = -tileEnvelope.getMinX();
  final double yOffset = -tileEnvelope.getMinY();

  // Transform Setup: Shift to 0 as minimum value
  t.translate(xOffset, yOffset);

  // Transform Setup: Scale X and Y to tile extent values, flip Y values
  t.scale(1d / (xDiff / (double) mvtLayerParams.extent),
      -1d / (yDiff / (double) mvtLayerParams.extent));

  // Transform Setup: Bump Y values to positive quadrant
  t.translate(0d, (double) mvtLayerParams.extent);


  // The area contained in BOTH the 'original geometry', g, AND the 'clip envelope geometry' is
  // the 'tile geometry'
  final List<Geometry> intersectedGeoms = flatIntersection(tileClipGeom, geometryList);
  final List<Geometry> transformedGeoms = new ArrayList<>(intersectedGeoms.size());

  // Transform intersected geometry
  Geometry nextTransformGeom;
  Object nextUserData;
  for (Geometry nextInterGeom : intersectedGeoms) {
    nextUserData = nextInterGeom.getUserData();

    nextTransformGeom = t.transform(nextInterGeom);

    // Floating --> Integer, still contained within doubles
    nextTransformGeom.apply(RoundingFilter.INSTANCE);

    // TODO: Refactor line simplification
    // Can't use 0d, specify value < .5d
    nextTransformGeom = TopologyPreservingSimplifier.simplify(nextTransformGeom, .1d);

    nextTransformGeom.setUserData(nextUserData);

    // Apply filter on transformed geometry
    if (filter.accept(nextTransformGeom)) {
      transformedGeoms.add(nextTransformGeom);
    }
  }

  return new TileGeomResult(intersectedGeoms, transformedGeoms);
}

@Override
public ILocation normalizeLocation(final ILocation point, final boolean nullIfOutside) {

    // TODO Subclass (or rewrite) this naive implementation to take care of
    // irregular
    // geometries.

    // TODO Take into account the fact that some topologies may consider
    // invalid locations.
    if (environment.getGeometry().covers(point)) { return point; }

    if (isTorus()) {
        final Point pt = GeometryUtils.GEOMETRY_FACTORY.createPoint(GeometryUtils.toCoordinate(point));

        for (int cnt = 0; cnt < 8; cnt++) {
            final AffineTransformation at = new AffineTransformation();
            at.translate(adjustedXVector[cnt], adjustedYVector[cnt]);
            final GamaPoint newPt = new GamaPoint(at.transform(pt).getCoordinate());
            if (environment.getGeometry().covers(newPt)) { return newPt; }
        }
    }
    // See if rounding errors of double do not interfere with the
    // computation.
    // In which case, the use of Maths.approxEquals(value1, value2,
    // tolerance) could help.

    // if ( envWidth == 0.0 ) {
    // xx = xx != envMinX ? nullIfOutside ? nil : envMinX : xx;
    // } else if ( xx < envMinX /* && xx > hostMinX - precision */) {
    // xx = /* !isTorus ? */nullIfOutside ? nil : envMinX /* : xx % envWidth
    // + envWidth */;
    // } else if ( xx >= envMaxX /*- precision*/) {
    // xx = /* !isTorus ? */nullIfOutside ? nil : envMaxX /* : xx % envWidth
    // */;
    // }
    // if ( xx == nil ) { return null; }
    // if ( envHeight == 0.0 ) {
    // yy = yy != envMinY ? nullIfOutside ? nil : envMinY : yy;
    // } else if ( yy < envMinY/* && yy > hostMinY - precision */) {
    // yy = /* !isTorus ? */nullIfOutside ? nil : envMinY /* : yy %
    // envHeight + envHeight */;
    // } else if ( yy >= envMaxY /*- precision*/) {
    // yy = /* !isTorus ? */nullIfOutside ? nil : envMaxY /* : yy %
    // envHeight */;
    // }
    // if ( yy == nil ) { return null; }
    // point.setLocation(xx, yy, point.getZ());

    return null;
}

public static AffineTransformation getRectangleToWorld( Rectangle pixelRectangle, Envelope worldEnvelope )
        throws NoninvertibleTransformationException {
    return getWorldToRectangle(worldEnvelope, pixelRectangle).getInverse();
}

/**
 * Extracts traversal sections of a given with from the supplied {@link Coordinate}s.
 * 
 * @param coordinates the list of coordinates.
 * @param width the total with of the sections.
 * @return the list of {@link LineString sections}. 
 */
public static List<LineString> getSectionsFromCoordinates( List<Coordinate> coordinates, double width ) {

    if (coordinates.size() < 3) {
        throw new IllegalArgumentException("This method works only on lines with at least 3 coordinates.");
    }
    double halfWidth = width / 2.0;
    List<LineString> linesList = new ArrayList<LineString>();
    // first section
    Coordinate centerCoordinate = coordinates.get(0);
    LineSegment l1 = new LineSegment(centerCoordinate, coordinates.get(1));
    Coordinate leftCoordinate = l1.pointAlongOffset(0.0, halfWidth);
    Coordinate rightCoordinate = l1.pointAlongOffset(0.0, -halfWidth);
    LineString lineString = geomFactory.createLineString(new Coordinate[]{leftCoordinate, centerCoordinate, rightCoordinate});
    linesList.add(lineString);

    for( int i = 1; i < coordinates.size() - 1; i++ ) {
        Coordinate previous = coordinates.get(i - 1);
        Coordinate current = coordinates.get(i);
        Coordinate after = coordinates.get(i + 1);

        double firstAngle = azimuth(current, previous);
        double secondAngle = azimuth(current, after);

        double a1 = min(firstAngle, secondAngle);
        double a2 = max(firstAngle, secondAngle);

        double centerAngle = a1 + (a2 - a1) / 2.0;

        AffineTransformation rotationInstance = AffineTransformation.rotationInstance(-toRadians(centerAngle), current.x,
                current.y);

        LineString vertical = geomFactory.createLineString(new Coordinate[]{new Coordinate(current.x, current.y + halfWidth),
                current, new Coordinate(current.x, current.y - halfWidth)});
        Geometry transformed = rotationInstance.transform(vertical);
        linesList.add((LineString) transformed);
    }

    // last section
    centerCoordinate = coordinates.get(coordinates.size() - 1);
    LineSegment l2 = new LineSegment(centerCoordinate, coordinates.get(coordinates.size() - 2));
    leftCoordinate = l2.pointAlongOffset(0.0, halfWidth);
    rightCoordinate = l2.pointAlongOffset(0.0, -halfWidth);
    lineString = geomFactory.createLineString(new Coordinate[]{leftCoordinate, centerCoordinate, rightCoordinate});
    linesList.add(lineString);

    return linesList;
}

/**
 * Returns a {@link Geometry} representing the footprint of a robot in a given pose.
 * @param fp A polygon representing the footprint of the robot centered in (0,0)
 * and appropriately oriented (can be obtained from a {@link TrajectoryEnvelope} instance
 * via method {@link TrajectoryEnvelope#getFootprint()}).
 * @param x The x coordinate of the pose used to create the footprint.
 * @param y The y coordinate of the pose used to create the footprint.
 * @param theta The orientation of the pose used to create the footprint.
 * @return A {@link Geometry} representing the footprint of the robot in a given pose.
 */
public static Geometry getFootprint(Polygon fp, double x, double y, double theta) {
    AffineTransformation at = new AffineTransformation();
    at.rotate(theta);
    at.translate(x,y);
    Geometry rect = at.transform(fp);
    return rect;
}