Java NIVision.MeasureParticle方法代码示例

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes a score (0-100) comparing the aspect ratio to the ideal aspect
 * ratio for the target. This method uses the equivalent rectangle sides to
 * determine aspect ratio as it performs better as the target gets skewed by
 * moving to the left or right. The equivalent rectangle is the rectangle
 * with sides x and y where particle area= x*y and particle perimeter= 2x+2y
 *
 * @param image The image containing the particle to score, needed to
 * performa additional measurements
 * @param report The Particle Analysis Report for the particle, used for the
 * width, height, and particle number
 * @param outer	Indicates whether the particle aspect ratio should be
 * compared to the ratio for the inner target or the outer
 * @return The aspect ratio score (0-100)
 */
public static double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean outer) throws NIVisionException {
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    //idealAspectRatio = outer ? (62/29) : (62/20);	//Dimensions of goal opening + 4 inches on all 4 sides for reflective tape
    idealAspectRatio = outer ? (43 / 32) : (39 / 28);
    //Divide width by height to measure aspect ratio
    aspectRatio = report.boundingRectWidth / (double) report.boundingRectHeight;
    /*if(report.boundingRectWidth > report.boundingRectHeight){
     //particle is wider than it is tall, divide long by short
     aspectRatio = 100*(1-Math.abs((1-((rectLong/rectShort)/idealAspectRatio))));
     } else {
     //particle is taller than it is wide, divide short by long
     aspectRatio = 100*(1-Math.abs((1-((rectShort/rectLong)/idealAspectRatio))));
     }*/
    return aspectRatio;
    //return (Math.max(0, Math.min(aspectRatio, 100.0)));		//force to be in range 0-100
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes a score (0-100) comparing the aspect ratio to the ideal aspect
 * ratio for the target. This method uses the equivalent rectangle sides to
 * determine aspect ratio as it performs better as the target gets skewed by
 * moving to the left or right. The equivalent rectangle is the rectangle
 * with sides x and y where particle area, xy and particle perimeter, 2x+2y
 *
 * @param image The image containing the particle to score, needed to
 * perform additional measurements
 * @param report The Particle Analysis Report for the particle, used for the
 * width, height, and particle number
 * @param outer Indicates whether the particle aspect ratio should be
 * compared to the ratio for the inner target or the outer
 * @return The aspect ratio score (0-100)
 */
private double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport 
        report, int particleNumber, boolean vertical) throws 
        NIVisionException {
    
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, 
            MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, 
            MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    idealAspectRatio = vertical ? (4.0 / 32) : (23.5 / 4);
    
    if (report.boundingRectWidth > report.boundingRectHeight) {
        aspectRatio = ratioToScore((rectLong / rectShort)/idealAspectRatio);
    } else {
        aspectRatio = ratioToScore((rectShort / rectLong)/idealAspectRatio);
    }
    return aspectRatio;
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
public double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean vertical) throws NIVisionException
   {
       double rectLong, rectShort, aspectRatio, idealAspectRatio;

       rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
       rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
       idealAspectRatio = vertical ? (4.0/32) : (23.5/4);	//Vertical reflector 4" wide x 32" tall, horizontal 23.5" wide x 4" tall

       //Divide width by height to measure aspect ratio
       if(report.boundingRectWidth > report.boundingRectHeight){
           //particle is wider than it is tall, divide long by short
           aspectRatio = ratioToScore((rectLong/rectShort)/idealAspectRatio);
       } else {
           //particle is taller than it is wide, divide short by long
           aspectRatio = ratioToScore((rectShort/rectLong)/idealAspectRatio);
       }
return aspectRatio;
   }
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes a score (0-100) comparing the aspect ratio to the ideal aspect
 * ratio for the target. This method uses the equivalent rectangle sides to
 * determine aspect ratio as it performs better as the target gets skewed by
 * moving to the left or right. The equivalent rectangle is the rectangle
 * with sides x and y where particle area= x*y and particle perimeter= 2x+2y
 *
 * @param image The image containing the particle to score, needed to
 * perform additional measurements
 * @param report The Particle Analysis Report for the particle, used for the
 * width, height, and particle number
 * @param outer	Indicates whether the particle aspect ratio should be
 * compared to the ratio for the inner target or the outer
 * @return The aspect ratio score (0-100)
 */
private static double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean vertical) throws NIVisionException {
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    idealAspectRatio = vertical ? (4.0 / 32) : (23.5 / 4);	//Vertical reflector 4" wide x 32" tall, horizontal 23.5" wide x 4" tall

    //Divide width by height to measure aspect ratio
    if (report.boundingRectWidth > report.boundingRectHeight) {
        //particle is wider than it is tall, divide long by short
        aspectRatio = ratioToScore((rectLong / rectShort) / idealAspectRatio);
    } else {
        //particle is taller than it is wide, divide short by long
        aspectRatio = ratioToScore((rectShort / rectLong) / idealAspectRatio);
    }
    return aspectRatio;
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
public double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean vertical) throws NIVisionException
{
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    idealAspectRatio = vertical ? (4.0 / 32) : (23.5 / 4);	//Vertical reflector 4" wide x 32" tall, horizontal 23.5" wide x 4" tall

    if (report.boundingRectWidth > report.boundingRectHeight)
    {
        aspectRatio = ratioToScore((rectLong / rectShort) / idealAspectRatio);
    }
    else
    {
        aspectRatio = ratioToScore((rectShort / rectLong) / idealAspectRatio);
    }
    return aspectRatio;
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
public double scoreAspectRatioOnRotatedImage(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean vertical) throws NIVisionException
{
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    idealAspectRatio = vertical ? (32.0 / 4) : (4/23.5);	//Vertical reflector 4" wide x 32" tall, horizontal 23.5" wide x 4" tall

    if (report.boundingRectWidth > report.boundingRectHeight)
    {
        aspectRatio = ratioToScore((rectLong / rectShort) / idealAspectRatio);
    }
    else
    {
        aspectRatio = ratioToScore((rectShort / rectLong) / idealAspectRatio);
    }
    return aspectRatio;
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes a score (0-100) comparing the aspect ratio to the ideal aspect
 * ratio for the target. This method uses the equivalent rectangle sides to
 * determine aspect ratio as it performs better as the target gets skewed by
 * moving to the left or right. The equivalent rectangle is the rectangle
 * with sides x and y where particle area= x*y and particle perimeter= 2x+2y
 *
 * @param image The image containing the particle to score, needed to
 * perform additional measurements
 * @param report The Particle Analysis Report for the particle, used for the
 * width, height, and particle number
 * @param outer	Indicates whether the particle aspect ratio should be
 * compared to the ratio for the inner target or the outer
 * @return The aspect ratio score (0-100)
 */
private double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean vertical) throws NIVisionException {
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    idealAspectRatio = vertical ? (4.0 / 32) : (23.5 / 4);	//Vertical reflector 4" wide x 32" tall, horizontal 23.5" wide x 4" tall

    //Divide width by height to measure aspect ratio
    if (report.boundingRectWidth > report.boundingRectHeight) {
        //particle is wider than it is tall, divide long by short
        aspectRatio = ratioToScore((rectLong / rectShort) / idealAspectRatio);
    } else {
        //particle is taller than it is wide, divide short by long
        aspectRatio = ratioToScore((rectShort / rectLong) / idealAspectRatio);
    }
    return aspectRatio;
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes a score (0-100) comparing the aspect ratio to the ideal aspect ratio for the target. This method uses
 * the equivalent rectangle sides to determine aspect ratio as it performs better as the target gets skewed by moving
 * to the left or right. The equivalent rectangle is the rectangle with sides x and y where particle area= x*y
 * and particle perimeter= 2x+2y
 * 
 * @param image The image containing the particle to score, needed to performa additional measurements
 * @param report The Particle Analysis Report for the particle, used for the width, height, and particle number
 * @param outer	Indicates whether the particle aspect ratio should be compared to the ratio for the inner target or the outer
 * @return The aspect ratio score (0-100)
 */
public double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean outer) throws NIVisionException
{
    double rectLong, rectShort, aspectRatio, idealAspectRatio;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
    //idealAspectRatio = outer ? (62/29) : (62/20);	//Dimensions of goal opening + 4 inches on all 4 sides for reflective tape

    //yonatan - change back
    idealAspectRatio = outer ? (62/29) : (62/40);	//Dimensions of goal opening + 4 inches on all 4 sides for reflective tape

    //Divide width by height to measure aspect ratio
    if(report.boundingRectWidth > report.boundingRectHeight){
        //particle is wider than it is tall, divide long by short
        aspectRatio = 100*(1-Math.abs((1-((rectLong/rectShort)/idealAspectRatio))));
    } else {
        //particle is taller than it is wide, divide short by long
        aspectRatio = 100*(1-Math.abs((1-((rectShort/rectLong)/idealAspectRatio))));
    }
    return (Math.max(0, Math.min(aspectRatio, 100.0)));		//force to be in range 0-100
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
    * Computes a score (0-100) comparing the aspect ratio to the ideal aspect ratio for the target. This method uses
    * the equivalent rectangle sides to determine aspect ratio as it performs better as the target gets skewed by moving
    * to the left or right. The equivalent rectangle is the rectangle with sides x and y where particle area= x*y
    * and particle perimeter= 2x+2y
    * 
    * @param image The image containing the particle to score, needed to perform additional measurements
    * @param report The Particle Analysis Report for the particle, used for the width, height, and particle number
    * @param outer	Indicates whether the particle aspect ratio should be compared to the ratio for the inner target or the outer
    * @return The aspect ratio score (0-100)
    */
   public double scoreAspectRatio(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean vertical) throws NIVisionException
   {
       double rectLong, rectShort, aspectRatio, idealAspectRatio;

       rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
       rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
       idealAspectRatio = vertical ? (4.0/32) : (23.5/4);	//Vertical reflector 4" wide x 32" tall, horizontal 23.5" wide x 4" tall

       //Divide width by height to measure aspect ratio
       if(report.boundingRectWidth > report.boundingRectHeight){
           //particle is wider than it is tall, divide long by short
           aspectRatio = ratioToScore((rectLong/rectShort)/idealAspectRatio);
       } else {
           //particle is taller than it is wide, divide short by long
           aspectRatio = ratioToScore((rectShort/rectLong)/idealAspectRatio);
       }
return aspectRatio;
   }
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes the estimated distance to a target using the height of the
 * particle in the image. For more information and graphics showing the math
 * behind this approach see the Vision Processing section of the
 * ScreenStepsLive documentation.
 *
 * @param image The image to use for measuring the particle estimated
 * rectangle.
 * @param report The particle analysis report for the particle.
 * @param outer True if the particle should be treated as an outer target,
 * false to treat it as a center target.
 * @return The estimated distance to the target in inches.
 */
private double computeDistance(BinaryImage image, ParticleAnalysisReport 
        report, int particleNumber) throws NIVisionException {
    double rectLong, height;
    int targetHeight;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, 
            MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
    height = Math.min(report.boundingRectHeight, rectLong);
    targetHeight = 32;

    return Y_IMAGE_RES * targetHeight / (height * 12 * 2 
            * Math.tan(VIEW_ANGLE * Math.PI / (180 * 2)));
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
double computeDistance (BinaryImage image, ParticleAnalysisReport report, int particleNumber) throws NIVisionException {
        double rectLong, height;
        int targetHeight;

        rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
        //using the smaller of the estimated rectangle long side and the bounding rectangle height results in better performance
        //on skewed rectangles
        height = Math.min(report.boundingRectHeight, rectLong);
        targetHeight = 32;

        return Y_IMAGE_RES * targetHeight / (height * 12 * 2 * Math.tan(VIEW_ANGLE*Math.PI/(180*2)));
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
double computeDistance(BinaryImage image, ParticleAnalysisReport report, int particleNumber) throws NIVisionException
{
    double rectLong, height;
    int targetHeight;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);

    height = Math.min(report.boundingRectHeight, rectLong);
    targetHeight = 32;

    return Y_IMAGE_RES * targetHeight / (height * 12 * 2 * Math.tan(VIEW_ANGLE * Math.PI / (180 * 2)));
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
double computeDistanceOnRotatedImage(BinaryImage image, ParticleAnalysisReport report, int particleNumber) throws NIVisionException
{
    double rectLong, height;
    int targetHeight;

    rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);

    height = Math.min(report.boundingRectWidth, rectLong);
    targetHeight = 32;

    return X_IMAGE_RES * targetHeight / (height * 12 * 2 * Math.tan(HORIZ_VIEW_ANGLE * Math.PI / (180 * 2)));
}
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
     * Computes the estimated distance to a target using the height of the particle in the image. For more information and graphics
     * showing the math behind this approach see the Vision Processing section of the ScreenStepsLive documentation.
     * 
     * @param image The image to use for measuring the particle estimated rectangle
     * @param report The Particle Analysis Report for the particle
     * @param outer True if the particle should be treated as an outer target, false to treat it as a center target
     * @return The estimated distance to the target in Inches.
     */
    double computeDistance (BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean outer) throws NIVisionException {
        double rectShort, width, height;
        double targetWidth, targetHeight;
        

        rectShort = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_SHORT_SIDE);
        //using the smaller of the estimated rectangle short side and the bounding rectangle height results in better performance
        //on skewed rectangles
        //height = Math.min(report.boundingRectHeight, rectShort);
        width = report.boundingRectWidth;
        height = report.boundingRectHeight;
        //targetHeight = outer ? 29 : 21;
        //changed by Yonatan Oren//
        //need to change this back to 29/21 for for real ultimate ascent//
        targetWidth = 16;
        targetHeight = 9.75;
        
////
//         System.out.println("rectShort: " + rectShort);
//         System.out.println("height: " + height);
//         System.out.println("boundingRectHeight: " + report.boundingRectHeight);

         //changed by Yonatan Oren//
        //return X_IMAGE_RES * targetHeight / (height * 12 * 2 * Math.tan(VIEW_ANGLE*Math.PI/(180*2)));
         //return 240.0 * targetWidth / (width * Math.tan(VIEW_ANGLE*Math.PI/(180*2)));
         return 360.0 * targetHeight / (height * Math.tan(VIEW_ANGLE*Math.PI/(180*2)));
         //4800 / 62 * tan(
    }
 

import edu.wpi.first.wpilibj.image.NIVision; //导入方法依赖的package包/类
/**
 * Computes the estimated distance to a target using the height of the particle in the image. For more information and graphics
 * showing the math behind this approach see the Vision Processing section of the ScreenStepsLive documentation.
 * 
 * @param image The image to use for measuring the particle estimated rectangle
 * @param report The Particle Analysis Report for the particle
 * @param outer True if the particle should be treated as an outer target, false to treat it as a center target
 * @return The estimated distance to the target in Inches.
 */
double computeDistance (BinaryImage image, ParticleAnalysisReport report, int particleNumber) throws NIVisionException {
        double rectLong, height;
        int targetHeight;

        rectLong = NIVision.MeasureParticle(image.image, particleNumber, false, NIVision.MeasurementType.IMAQ_MT_EQUIVALENT_RECT_LONG_SIDE);
        //using the smaller of the estimated rectangle long side and the bounding rectangle height results in better performance
        //on skewed rectangles
        height = Math.min(report.boundingRectHeight, rectLong);
        targetHeight = 32;

        return Y_IMAGE_RES * targetHeight / (height * 12 * 2 * Math.tan(VIEW_ANGLE*Math.PI/(180*2)));
}