Example usage for java.awt.image BufferedImage TYPE_4BYTE_ABGR

List of usage examples for java.awt.image BufferedImage TYPE_4BYTE_ABGR

Introduction

In this page you can find the example usage for java.awt.image BufferedImage TYPE_4BYTE_ABGR.

Prototype

int TYPE_4BYTE_ABGR

To view the source code for java.awt.image BufferedImage TYPE_4BYTE_ABGR.

Click Source Link

Document

Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha.

Usage

From source file:org.shaman.terrain.vegetation.ImpositorCreator.java

public TreeInfo createTree(Biome biome, String treeName, int variation, float prob) throws IOException {
    LOG.info("create tree from " + treeName);

    File folder = new File(OUTPUT_FOLDER + treeName + "_v" + variation);
    if (!folder.exists() && !folder.mkdir()) {
        LOG.log(Level.SEVERE, "unable to make directory {0}", folder);
        return null;
    }//from  ww  w  .  j  a v  a2 s.c o  m

    //create tree
    Params params = new Params();
    params.prepare(13);
    params.clearParams();
    params.readFromXML(new FileInputStream(INPUT_FOLDER + treeName + ".xml"));
    params.prepare(rand.nextInt(Short.MAX_VALUE));
    TreeGenerator treeGenerator = TreeGeneratorFactory.createTreeGenerator(params);
    treeGenerator.setSeed(rand.nextInt(Short.MAX_VALUE));
    treeGenerator.setParam("Smooth", params.getParam("Smooth").toString());
    ExporterFactory.setRenderW(1024);
    ExporterFactory.setRenderH(1024);
    ExporterFactory.setExportFormat(-1);
    ExporterFactory.setOutputStemUVs(true);
    ExporterFactory.setOutputLeafUVs(true);
    Progress progress = new Progress();
    Tree treeData = treeGenerator.makeTree(progress);
    MeshGenerator meshGenerator = MeshGeneratorFactory.createMeshGenerator(/*params,*/ true);
    ArbaroToJmeExporter exporter = new ArbaroToJmeExporter(assetManager, treeData, meshGenerator);
    exporter.setBarkTexture("org/shaman/terrain/textures2/" + params.getParam("BarkTexture").getValue());
    exporter.setLeafTexture("org/shaman/terrain/textures2/" + params.getParam("LeafTexture").getValue());
    exporter.setLeafRotation(Float.parseFloat(params.getParam("LeafTextureRotation").getValue()));
    exporter.doWrite();
    Spatial tree = exporter.getSpatial();
    LOG.log(Level.INFO, "tree generated, vertices:{0}, triangles:{1}",
            new Object[] { tree.getVertexCount(), tree.getTriangleCount() });

    //save tree
    BinaryExporter binaryExporter = new BinaryExporter();
    binaryExporter.save(tree, new File(folder, "Tree.j3o"));

    //compute bounding cylinder
    List<Geometry> geometries = new ArrayList<>();
    listGeometries(tree, geometries);
    System.out.println("count of geometries: " + geometries.size());
    //compute bounding cylinder, assuming that the tree starts at the origin and grows in z-direction
    BoundingVolume oldBoundingVolume = tree.getWorldBound();
    System.out.println("original bounding volume: " + oldBoundingVolume);
    float radius = 0;
    float height = 0;
    Vector3f pos = new Vector3f();
    Vector3f pos2 = new Vector3f();
    for (Geometry geom : geometries) {
        Mesh mesh = geom.getMesh();
        Transform trafo = geom.getWorldTransform();
        VertexBuffer buffer = mesh.getBuffer(VertexBuffer.Type.Position);
        FloatBuffer fbuf = (FloatBuffer) buffer.getData();
        fbuf.rewind();
        for (int i = 0; i < buffer.getNumElements(); ++i) {
            pos.x = fbuf.get();
            pos.y = fbuf.get();
            pos.z = fbuf.get();
            pos2 = trafo.transformVector(pos, pos2);
            radius = Math.max(radius, pos2.x * pos2.x + pos2.y * pos2.y);
            height = Math.max(height, pos2.z);
        }
        fbuf.rewind();
    }
    radius = FastMath.sqrt(radius);
    System.out.println("cylinder radius: " + radius + ", height: " + height);

    //setup scene
    Node sceneNode = new Node("scene");
    sceneNode.attachChild(tree);
    DirectionalLight light = new DirectionalLight();
    Vector3f lightDir = new Vector3f(-0.1f, -0.1f, -0.1f);
    light.setDirection(lightDir.normalize());
    AmbientLight ambientLight = new AmbientLight(new ColorRGBA(0.6f, 0.6f, 0.6f, 1));
    sceneNode.addLight(ambientLight);
    sceneNode.setQueueBucket(RenderQueue.Bucket.Gui);
    for (Geometry geom : geometries) {
        geom.setQueueBucket(RenderQueue.Bucket.Gui);
        geom.getMaterial().setFloat("FadeNear", 2000);
        geom.getMaterial().setFloat("FadeFar", 3000);
    }
    //transform to match texture size
    Node sceneNode2 = new Node("scene2");
    sceneNode2.attachChild(sceneNode);
    sceneNode2.rotate(-FastMath.HALF_PI, 0, 0);
    float scale = TEXTURE_SIZE / Math.max(height, 2 * radius);
    sceneNode2.scale(scale);
    Node sceneNode3 = new Node("scene3");
    sceneNode3.attachChild(sceneNode2);
    sceneNode3.setLocalTranslation(TEXTURE_SIZE / 2, 0, 0);
    //create offscreen surface
    ByteBuffer data = BufferUtils.createByteBuffer(TEXTURE_SIZE * TEXTURE_SIZE * 4);
    BufferedImage image = new BufferedImage(TEXTURE_SIZE, TEXTURE_SIZE, BufferedImage.TYPE_4BYTE_ABGR);
    Camera camera = new Camera(TEXTURE_SIZE, TEXTURE_SIZE);
    camera.setParallelProjection(true);
    final ViewPort view = new ViewPort("Off", camera);
    view.setBackgroundColor(ColorRGBA.BlackNoAlpha);
    view.setClearFlags(true, true, true);
    final FrameBuffer buffer = new FrameBuffer(TEXTURE_SIZE, TEXTURE_SIZE, 1);
    buffer.setDepthBuffer(Image.Format.Depth);
    buffer.setColorBuffer(Image.Format.RGBA32F);
    view.setOutputFrameBuffer(buffer);
    view.attachScene(sceneNode3);
    sceneNode3.setCullHint(Spatial.CullHint.Never);
    sceneNode2.setCullHint(Spatial.CullHint.Never);
    sceneNode.setCullHint(Spatial.CullHint.Never);
    tree.setCullHint(Spatial.CullHint.Never);
    view.setEnabled(true);
    //render
    sceneNode.addLight(light);
    for (int i = 0; i < IMPOSITOR_COUNT; ++i) {
        sceneNode3.updateGeometricState();

        renderManager.renderViewPort(view, 0);
        renderer.readFrameBuffer(buffer, data);
        sceneNode.rotate(0, 0, FastMath.TWO_PI / IMPOSITOR_COUNT);
        Quaternion rot = new Quaternion();
        rot.fromAngles(0, 0, i * FastMath.TWO_PI / IMPOSITOR_COUNT);
        light.setDirection(rot.mult(lightDir).normalizeLocal());

        try {
            convertScreenShot(data, image);
            BufferedImage img = new BufferedImage(OUTPUT_TEXTURE_SIZE, OUTPUT_TEXTURE_SIZE,
                    BufferedImage.TYPE_4BYTE_ABGR);
            Graphics2D G = img.createGraphics();
            G.drawImage(image, 0, 0, OUTPUT_TEXTURE_SIZE, OUTPUT_TEXTURE_SIZE, null);
            G.dispose();
            ImageIO.write(img, "png", new File(folder, i + ".png"));
        } catch (IOException ex) {
            Logger.getLogger(ImpositorCreator.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        }
    }
    view.clearScenes();

    //create tree info
    TreeInfo info = new TreeInfo();
    info.biome = biome;
    info.name = treeName + "_v" + variation;
    info.treeSize = height;
    info.probability = prob;
    info.impostorCount = IMPOSITOR_COUNT;
    info.impostorFadeNear = 30;
    info.impostorFadeFar = 50;
    info.highResStemFadeNear = 30;
    info.highResStemFadeFar = 50;
    info.highResLeavesFadeNear = 35;
    info.highResLeavesFadeFar = 55;

    System.out.println("impostors created");
    Runtime.getRuntime().gc();
    assetManager.clearCache();

    return info;
}

From source file:pl.edu.icm.visnow.lib.utils.ImageUtilities.java

public static RegularField bufferedImage2RegularField(BufferedImage inImage, boolean vFlip) {
    if (inImage == null) {
        return null;
    }//ww  w .  jav a 2 s .  c o m

    int[] dims = new int[2];
    dims[0] = inImage.getWidth();
    dims[1] = inImage.getHeight();

    RegularField field = new RegularField(dims);

    WritableRaster raster = inImage.getRaster();
    byte[][] samples = null;
    int[][] samples32 = null;
    int i = 0;
    switch (inImage.getType()) {
    case BufferedImage.TYPE_BYTE_GRAY:
        samples = new byte[1][];
        samples[0] = new byte[dims[0] * dims[1]];
        if (vFlip) {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i++] = (byte) raster.getSample(x, dims[1] - y - 1, 0);
                }
            }
        } else {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i++] = (byte) raster.getSample(x, y, 0);
                }
            }
        }
        field.addData(DataArray.create(samples[0], 1, "grayscaleData"));
        break;
    case BufferedImage.TYPE_USHORT_GRAY:
        samples32 = new int[1][];
        samples32[0] = new int[dims[0] * dims[1]];
        if (vFlip) {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples32[0][i++] = (int) raster.getSample(x, dims[1] - y - 1, 0);
                }
            }
        } else {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples32[0][i++] = (int) raster.getSample(x, y, 0);
                }
            }
        }
        field.addData(DataArray.create(samples32[0], 1, "grayscaleData"));
        break;
    case BufferedImage.TYPE_INT_RGB:
        samples = new byte[3][];
        samples[0] = new byte[dims[0] * dims[1]];
        samples[1] = new byte[dims[0] * dims[1]];
        samples[2] = new byte[dims[0] * dims[1]];
        if (vFlip) {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i] = (byte) raster.getSample(x, dims[1] - y - 1, 0);
                    samples[1][i] = (byte) raster.getSample(x, dims[1] - y - 1, 1);
                    samples[2][i] = (byte) raster.getSample(x, dims[1] - y - 1, 2);
                    i++;
                }
            }
        } else {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i] = (byte) raster.getSample(x, y, 0);
                    samples[1][i] = (byte) raster.getSample(x, y, 1);
                    samples[2][i] = (byte) raster.getSample(x, y, 2);
                    i++;
                }
            }
        }
        field.addData(DataArray.create(samples[0], 1, "redData"));
        field.addData(DataArray.create(samples[1], 1, "greenData"));
        field.addData(DataArray.create(samples[2], 1, "blueData"));
        break;
    case BufferedImage.TYPE_3BYTE_BGR:
    case BufferedImage.TYPE_INT_BGR:
        samples = new byte[3][];
        samples[0] = new byte[dims[0] * dims[1]];
        samples[1] = new byte[dims[0] * dims[1]];
        samples[2] = new byte[dims[0] * dims[1]];
        if (vFlip) {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i] = (byte) raster.getSample(x, dims[1] - y - 1, 0);
                    samples[1][i] = (byte) raster.getSample(x, dims[1] - y - 1, 1);
                    samples[2][i] = (byte) raster.getSample(x, dims[1] - y - 1, 2);
                    i++;
                }
            }
        } else {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i] = (byte) raster.getSample(x, y, 0);
                    samples[1][i] = (byte) raster.getSample(x, y, 1);
                    samples[2][i] = (byte) raster.getSample(x, y, 2);
                    i++;
                }
            }
        }
        field.addData(DataArray.create(samples[0], 1, "blueData"));
        field.addData(DataArray.create(samples[1], 1, "greenData"));
        field.addData(DataArray.create(samples[2], 1, "redData"));
        break;
    case BufferedImage.TYPE_INT_ARGB:
        samples = new byte[4][];
        samples[0] = new byte[dims[0] * dims[1]];
        samples[1] = new byte[dims[0] * dims[1]];
        samples[2] = new byte[dims[0] * dims[1]];
        samples[3] = new byte[dims[0] * dims[1]];
        for (int y = 0; y < dims[1]; y++) {
            for (int x = 0; x < dims[0]; x++) {
                samples[0][i] = (byte) raster.getSample(x, dims[1] - y - 1, 0);
                samples[1][i] = (byte) raster.getSample(x, dims[1] - y - 1, 1);
                samples[2][i] = (byte) raster.getSample(x, dims[1] - y - 1, 2);
                samples[3][i] = (byte) raster.getSample(x, dims[1] - y - 1, 3);
                i++;
            }
        }
        field.addData(DataArray.create(samples[0], 1, "redData"));
        field.addData(DataArray.create(samples[1], 1, "greenData"));
        field.addData(DataArray.create(samples[2], 1, "blueData"));
        field.addData(DataArray.create(samples[3], 1, "alphaData"));
        break;
    case BufferedImage.TYPE_4BYTE_ABGR:
        samples = new byte[4][];
        samples[0] = new byte[dims[0] * dims[1]];
        samples[1] = new byte[dims[0] * dims[1]];
        samples[2] = new byte[dims[0] * dims[1]];
        samples[3] = new byte[dims[0] * dims[1]];
        for (int y = 0; y < dims[1]; y++) {
            for (int x = 0; x < dims[0]; x++) {
                samples[0][i] = (byte) raster.getSample(x, dims[1] - y - 1, 0);
                samples[1][i] = (byte) raster.getSample(x, dims[1] - y - 1, 1);
                samples[2][i] = (byte) raster.getSample(x, dims[1] - y - 1, 2);
                samples[3][i] = (byte) raster.getSample(x, dims[1] - y - 1, 3);
                i++;
            }
        }
        field.addData(DataArray.create(samples[0], 1, "alphaData"));
        field.addData(DataArray.create(samples[1], 1, "redData"));
        field.addData(DataArray.create(samples[2], 1, "greenData"));
        field.addData(DataArray.create(samples[3], 1, "blueData"));
        break;
    default:
        BufferedImage newImg = new BufferedImage(inImage.getWidth(), inImage.getHeight(),
                BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = newImg.createGraphics();
        g2d.drawImage(inImage, null, 0, 0);
        g2d.dispose();
        raster = newImg.getRaster();
        samples = new byte[3][];
        samples[0] = new byte[dims[0] * dims[1]];
        samples[1] = new byte[dims[0] * dims[1]];
        samples[2] = new byte[dims[0] * dims[1]];
        if (vFlip) {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i] = (byte) raster.getSample(x, dims[1] - y - 1, 0);
                    samples[1][i] = (byte) raster.getSample(x, dims[1] - y - 1, 1);
                    samples[2][i] = (byte) raster.getSample(x, dims[1] - y - 1, 2);
                    i++;
                }
            }
        } else {
            for (int y = 0; y < dims[1]; y++) {
                for (int x = 0; x < dims[0]; x++) {
                    samples[0][i] = (byte) raster.getSample(x, y, 0);
                    samples[1][i] = (byte) raster.getSample(x, y, 1);
                    samples[2][i] = (byte) raster.getSample(x, y, 2);
                    i++;
                }
            }
        }
        field.addData(DataArray.create(samples[0], 1, "redData"));
        field.addData(DataArray.create(samples[1], 1, "greenData"));
        field.addData(DataArray.create(samples[2], 1, "blueData"));
    }

    float[][] affine = new float[4][3];
    for (int j = 0; j < 3; j++) {
        for (int k = 0; k < 3; k++) {
            affine[j][k] = 0.0f;
            if (j == k)
                affine[j][k] = 1.0f;
        }
    }

    affine[3][0] = -(float) dims[0] / 2.0f;
    affine[3][1] = -(float) dims[1] / 2.0f;
    affine[3][2] = 0.0f;
    field.setAffine(affine);
    return field;
}