com.juankysoriano.rainbow.core.graphics.RainbowImage Java Examples

public List<RVector> extractPoints(RainbowImage img) {
    List<RVector> vertices = new ArrayList<>();
    int col = 0, colSum = 0, W = img.width - 1, H = img.height - 1;

    // For any pixel in the image excepting borders
    for (int Y = 1; Y < H; Y += step) {
        for (int X = 1; X < W; X += step, colSum = 0) {
            // Convolute surrounding pixels with desired operator
            for (int y = -1; y <= 1; y++) {
                for (int x = -1; x <= 1; x++, col = img.get((X + x), (Y + y))) {
                    colSum += OPERATOR[op][x + 1][y + 1] * ((col >> 16 & 0xFF) + (col >> 8 & 0xFF) + (col & 0xFF));
                }
            }
            // And if the resulting sum is over the treshold add pixel
            // position to the list
            if (RainbowMath.abs(colSum) > treshold) {
                vertices.add(new RVector(X, Y));
            }
        }
    }
    return vertices;
}
 

private void loadImage(Bitmap bitmap, RainbowImage.LoadPictureListener listener) {
    if (bitmap == null) {
        listener.onLoadFail();
    } else {
        RainbowImage image = new RainbowImage(bitmap);
        image.parent = graphics.parent;
        listener.onLoadSucceed(image);
    }
}
 

@Test
public void testThatPaintFlowerPerformsImagePaintOnRainbowDrawer() {
    givenThatHasImages();
    Branch branch = givenABranch();
    flowerDrawer.paintFlowerFor(branch);

    verify(rainbowDrawer).image(any(RainbowImage.class), anyFloat(), anyFloat(), anyFloat(), anyFloat());
}
 

@Test
public void testThatPaintFlowerPerformsTranslationBeforePaintingImage() {
    givenThatHasImages();
    Branch branch = givenABranch();
    flowerDrawer.paintFlowerFor(branch);

    InOrder drawingOperation = inOrder(rainbowDrawer);

    drawingOperation.verify(rainbowDrawer).translate(anyFloat(), anyFloat());
    drawingOperation.verify(rainbowDrawer).image(any(RainbowImage.class), anyFloat(), anyFloat(), anyFloat(), anyFloat());
}
 

private void disableRainbowDrawerInvocations() {
    Mockito.doNothing().when(rainbowDrawer).noStroke();
    Mockito.doNothing().when(rainbowDrawer).smooth();
    Mockito.doNothing().when(rainbowDrawer).tint(anyInt());
    Mockito.doNothing().when(rainbowDrawer).pushMatrix();
    Mockito.doNothing().when(rainbowDrawer).translate(anyFloat(), anyFloat());
    Mockito.doNothing().when(rainbowDrawer).rotate(anyFloat());
    Mockito.doNothing().when(rainbowDrawer).image(any(RainbowImage.class), anyFloat(), anyFloat(), anyFloat(), anyFloat());
    Mockito.doNothing().when(rainbowDrawer).tint(anyInt());
    Mockito.doNothing().when(rainbowDrawer).stroke(anyInt(), anyFloat());
    Mockito.doNothing().when(rainbowDrawer).strokeWeight(anyFloat());
    Mockito.doNothing().when(rainbowDrawer).line(anyFloat(), anyFloat(), anyFloat(), anyFloat());

}
 

int getCellStateFrom(RainbowImage image, int cellX, int cellY) {
    int color = image.get(cellX * SCALE_FACTOR, cellY * SCALE_FACTOR);
    int red = (int) rainbowDrawer.red(color);
    int green = (int) rainbowDrawer.green(color);
    int blue = (int) rainbowDrawer.blue(color);
    int grey = (red + green + blue) / THREE;

    return grey < ALIVE_CELL_THRESHOLD ? GameOfLife.DEAD : GameOfLife.ALIVE;
}
 

public void loadWorldFrom(RainbowImage image) {
    for (int i = 0; i < gameOfLifeAutomata.getWidth(); i++) {
        for (int j = 0; j < gameOfLifeAutomata.getHeight(); j++) {
            gameOfLifeAutomata.getCells()[i][j] = gameOfLifeDrawer.getCellStateFrom(image, i, j);
        }
    }
}
 

static LuminanceMap newInstance(RainbowImage rainbowImage) {
    int width = rainbowImage.getWidth();
    int height = rainbowImage.getHeight();
    rainbowImage.loadPixels();
    int[] pixels = rainbowImage.pixels;
    boolean[] luminanceValues = new boolean[width * height];
    boolean[] visitedPixels = new boolean[width * height];
    return new LuminanceMap(pixels, width, height, luminanceValues, visitedPixels);
}
 

@Override
public void onSketchSetup() {
    super.onSketchSetup();
    getRainbowDrawer().smooth();
    getRainbowDrawer().noFill();
    getRainbowDrawer().background(0, 0, 0);
    getRainbowDrawer().loadImage(
            R.drawable.winnie,
            (getWidth() / RESIZE_FACTOR),
            (getHeight() / RESIZE_FACTOR),
            Modes.LoadMode.LOAD_CENTER_CROP,
            new RainbowImage.LoadPictureListener() {

                @Override
                public void onLoadSucceed(RainbowImage image) {
                    rainbowImage = image;
                    mediaPlayer.start();
                    blobDetection = new BlobDetection(rainbowImage);
                    resetThreshold();
                    startNextBunchDetection();
                }

                @Override
                public void onLoadFail() {
                    //no-op
                }
            }
    );
}
 

public void loadImage(String path, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(path, width, height, mode);
    loadImage(bitmap, listener);
}
 

public BlobDetection(RainbowImage rainbowImage) {
    this(rainbowImage, DEFAULT_MAX_NUMBER_OF_BLOBS);
}
 

public void loadImage(String path, int width, int height, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(path, width, height, mode);
    loadImage(bitmap, listener);
}
 

public void loadImage(int resID, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(resID, width, height, mode);
    loadImage(bitmap, listener);
}
 

public void loadImage(int resID, int width, int height, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(resID, width, height, mode);
    loadImage(bitmap, listener);
}
 

public void loadImage(File file, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(file, width, height, mode);
    loadImage(bitmap, listener);
}
 

public void loadImage(Uri uri, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(uri, width, height, mode);
    loadImage(bitmap, listener);
}
 

public void loadImage(Uri uri, int width, int height, Modes.LoadMode mode, RainbowImage.LoadPictureListener listener) {
    Bitmap bitmap = RainbowBitmapUtils.getBitmap(uri, width, height, mode);
    loadImage(bitmap, listener);
}
 

/**
 * Copies area of one image into another PImage object.
 */
public void copy(RainbowImage src, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh) {
    graphics.copy(src, sx, sy, sw, sh, dx, dy, dw, dh);
}
 

/**
 * Set alpha channel for an image using another image as the source.
 */
public void mask(RainbowImage alpha) {
    graphics.mask(alpha);
}
 

public void setOverlay(RainbowImage rainbowImage) {
    graphics.setOverlay(rainbowImage);
}
 

/**
 * Returns a copy of this PImage. Equivalent to get(0, 0, width, height).
 */
public RainbowImage get() {
    return graphics.get();
}
 

public RainbowImage createImage(int wide, int high, Modes.Image format) {
    RainbowImage image = new RainbowImage(wide, high, format);
    image.parent = graphics.parent;
    return image;
}
 

FlowerDrawer(Flower flower, List<RainbowImage> flowerImages, RainbowDrawer rainbowDrawer) {
    this.flower = flower;
    this.flowerImages = flowerImages;
    this.rainbowDrawer = rainbowDrawer;
}
 

private BlobDetection(RainbowImage rainbowImage, int maxNumberOfBlobs) {
    this.luminanceMap = LuminanceMap.newInstance(rainbowImage);
    this.maxNumberOfBlobs = maxNumberOfBlobs;
    scheduler = RainbowSchedulers.singleForRecursion("BlobDetection", RainbowSchedulers.Priority.NORMAL);
}
 

public static RainbowImage[] expand(final RainbowImage list[], final int newSize) {
    final RainbowImage temp[] = new RainbowImage[newSize];
    System.arraycopy(list, 0, temp, 0, Math.min(newSize, list.length));
    return temp;
}
 

public static RainbowImage[] expand(final RainbowImage list[]) {
    return RainbowMath.expand(list, list.length << 1);
}
 

@Override
public void onLoadSucceed(RainbowImage image) {
    gameOfLife.loadWorldFrom(image);
}
 

@Test
public void testThatPaintFlowerForBranchDoesNothingIfHasNoFlowersToPaint() {
    flowerDrawer.paintFlowerFor(givenABranch());

    verify(rainbowDrawer, never()).image(any(RainbowImage.class), anyFloat(), anyFloat(), anyFloat(), anyFloat());
}
 

@Override
public void onLoadSucceed(RainbowImage imageLoaded) {
    image = imageLoaded;
}
 

private RainbowImage getRandomFlower() {
    return flowerImages.get((int) RainbowMath.random(flowerImages.size()));
}