Java Code Examples for processing.core.PApplet#constrain()

/**
 * Get a square of pixels centered at the coord location of radius size.
 * WARNING: Unsafe to use, this will be updated/moved
 *
 * @param coord
 * @param cameraImage
 * @param radius
 * @return
 */
public int[] getPixelsFrom(PVector coord, PImage cameraImage, int radius) {
    int[] px = new int[radius * radius];
    int x = (int) coord.x;
    int y = (int) coord.y;
    int minX = PApplet.constrain(x - radius, 0, cameraTracking.width() - 1);
    int maxX = PApplet.constrain(x + radius, 0, cameraTracking.width() - 1);
    int minY = PApplet.constrain(y - radius, 0, cameraTracking.height() - 1);
    int maxY = PApplet.constrain(y + radius, 0, cameraTracking.height() - 1);

    int k = 0;
    for (int j = minY; j <= maxY; j++) {
        for (int i = minX; i <= maxX; i++) {
            int offset = i + j * cameraTracking.width();
            px[k++] = cameraImage.pixels[offset];
        }
    }
    return px;
}
 

/**
 * Handle distorsions
 *
 * @param pt
 * @return
 */
public PVector worldToPixelCoord(PVector pt, boolean undist) {

    // Reprojection 
    float invZ = 1.0f / pt.z;

    int px = PApplet.constrain(PApplet.round((pt.x * invZ * fx) + cx), 0, w - 1);
    int py = PApplet.constrain(PApplet.round((pt.y * invZ * fy) + cy), 0, h - 1);

    if (this.handleDistorsion && undist) {
        double[] out = device.undistort(px, py);
        px = (int) (out[0]);
        py = (int) (out[1]);
    }

    return new PVector(px, py);
}
 

@Deprecated
protected void setPrecisionFrom(int firstPoint) {

    Vec3D currentPoint = depthData.depthPoints[firstPoint];
    PVector coordinates = depthData.projectiveDevice.getCoordinates(firstPoint);

    // Find a point. 
    int x = (int) coordinates.x;
    int y = (int) coordinates.y;
    int minX = PApplet.constrain(x - precision, 0, depthData.projectiveDevice.getWidth() - 1);
    int maxX = PApplet.constrain(x + precision, 0, depthData.projectiveDevice.getWidth() - 1);
    int minY = PApplet.constrain(y - precision, 0, depthData.projectiveDevice.getHeight() - 1);
    int maxY = PApplet.constrain(y + precision, 0, depthData.projectiveDevice.getHeight() - 1);

    for (int j = minY; j <= maxY; j += precision) {
        for (int i = minX; i <= maxX; i += precision) {
            Vec3D nearbyPoint = depthData.projectiveDevice.pixelToWorld(i,
                    j, currentPoint.z);

            // Set the distance. 
            setDistance(currentPoint.distanceTo(nearbyPoint));
            return;
        }
    } // for i
}
 

/**
 * Unsafe do not use unless you are sure.
 */
public static int getColorOccurencesFrom(Camera camera, PVector coord, int radius, int col, int threshold, PaperTouchScreen paperTouchScreen) {
    int x = (int) coord.x;
    int y = (int) coord.y;
    int minX = PApplet.constrain(x - radius, 0, camera.width() - 1);
    int maxX = PApplet.constrain(x + radius, 0, camera.width() - 1);
    int minY = PApplet.constrain(y - radius, 0, camera.height() - 1);
    int maxY = PApplet.constrain(y + radius, 0, camera.height() - 1);
    ByteBuffer buff = camera.getIplImage().getByteBuffer();
    int k = 0;
    for (int j = minY; j <= maxY; j++) {
        for (int i = minX; i <= maxX; i++) {
            int offset = i + j * camera.width();
            int pxCol = getColor(buff, offset);
            if (MathUtils.colorDistRGB(col, pxCol, threshold)) {
                k++;
            }
        }
    }
    return k;
}
 

/**
 * Unsafe do not use unless you are sure.
 */
public int getColorOccurencesFrom(PVector coord, PImage cameraImage, int radius, int col, int threshold, PaperTouchScreen paperTouchScreen) {
    int x = (int) coord.x;
    int y = (int) coord.y;
    int minX = PApplet.constrain(x - radius, 0, cameraImage.width - 1);
    int maxX = PApplet.constrain(x + radius, 0, cameraImage.width - 1);
    int minY = PApplet.constrain(y - radius, 0, cameraImage.height - 1);
    int maxY = PApplet.constrain(y + radius, 0, cameraImage.height - 1);
    int k = 0;
    for (int j = minY; j <= maxY; j++) {
        for (int i = minX; i <= maxX; i++) {
            int offset = i + j * cameraImage.width;
            int pxCol = cameraImage.pixels[offset];
            if (colorDistRGB(col, pxCol, threshold)) {
                k++;
            }
        }
    }
    return k;
}
 

public int worldToPixel(float x, float y, float z) {
    // Reprojection 
    float invZ = 1.0f / z;

    int px = PApplet.constrain(PApplet.round((x * invZ * fx) + cx), 0, w - 1);
    int py = PApplet.constrain(PApplet.round((y * invZ * fy) + cy), 0, h - 1);

    return (int) (py * w + px);
}
 

public PVector worldToPixel(PVector pt, boolean undistort) {

        // Reprojection 
        float invZ = 1.0f / pt.z;

        int px = PApplet.constrain(PApplet.round((pt.x * invZ * fx) + cx), 0, w - 1);
        int py = PApplet.constrain(PApplet.round((pt.y * invZ * fy) + cy), 0, h - 1);

        if (undistort && this.handleDistorsion) {
            double[] out = device.distort(px, py);
            return new PVector((float) out[0], (float) out[1]);
        } else {
            return new PVector(px, py);
        }
    }
 

public PVector worldToPixelCoord(Vec3D pt) {

        // Reprojection 
        float invZ = 1.0f / pt.z();

        int px = PApplet.constrain(PApplet.round((pt.x() * invZ * fx) + cx), 0, w - 1);
        int py = PApplet.constrain(PApplet.round((pt.y() * invZ * fy) + cy), 0, h - 1);

        return new PVector(px, py);
    }
 

public int worldToPixel(PVector pt) {

        // Reprojection 
        float invZ = 1.0f / pt.z;

        int px = PApplet.constrain(PApplet.round((pt.x * invZ * fx) + cx), 0, w - 1);
        int py = PApplet.constrain(PApplet.round((pt.y * invZ * fy) + cy), 0, h - 1);

        return (int) (py * w + px);
    }