/** * 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 }
/** * Computes a score based on the match between a template profile and the * particle profile in the X direction. This method uses the the column * averages and the profile defined at the top of the sample to look for the * solid vertical edges with a hollow center. * * @param image The image to use, should be the image before the convex hull * is performed * @param report The Particle Analysis Report for the particle * * @return The X Edge Score (0-100) */ public static double scoreXEdge(BinaryImage image, ParticleAnalysisReport report) throws NIVisionException { double total = 0; LinearAverages averages; NIVision.Rect rect = new NIVision.Rect(report.boundingRectTop, report.boundingRectLeft, report.boundingRectHeight, report.boundingRectWidth); averages = NIVision.getLinearAverages(image.image, LinearAverages.LinearAveragesMode.IMAQ_COLUMN_AVERAGES, rect); float columnAverages[] = averages.getColumnAverages(); for (int i = 0; i < (columnAverages.length); i++) { if (xMin[(i * (XMINSIZE - 1) / columnAverages.length)] < columnAverages[i] && columnAverages[i] < xMax[i * (XMAXSIZE - 1) / columnAverages.length]) { total++; } } total = 100 * total / (columnAverages.length); return total; }
/** * Computes a score based on the match between a template profile and the * particle profile in the Y direction. This method uses the the row * averages and the profile defined at the top of the sample to look for the * solid horizontal edges with a hollow center * * @param image The image to use, should be the image before the convex hull * is performed * @param report The Particle Analysis Report for the particle * * @return The Y Edge score (0-100) * */ public static double scoreYEdge(BinaryImage image, ParticleAnalysisReport report) throws NIVisionException { double total = 0; LinearAverages averages; NIVision.Rect rect = new NIVision.Rect(report.boundingRectTop, report.boundingRectLeft, report.boundingRectHeight, report.boundingRectWidth); averages = NIVision.getLinearAverages(image.image, LinearAverages.LinearAveragesMode.IMAQ_ROW_AVERAGES, rect); float rowAverages[] = averages.getRowAverages(); for (int i = 0; i < (rowAverages.length); i++) { if (yMin[(i * (YMINSIZE - 1) / rowAverages.length)] < rowAverages[i] && rowAverages[i] < yMax[i * (YMAXSIZE - 1) / rowAverages.length]) { total++; } } total = 100 * total / (rowAverages.length); return total; }
/** * 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; }
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; }
/** * 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; }
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; }
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; }
/** * 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; }
/** * 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 }
/** * Computes a score based on the match between a template profile and the particle profile in the X direction. This method uses the * the column averages and the profile defined at the top of the sample to look for the solid vertical edges with * a hollow center. * * @param image The image to use, should be the image before the convex hull is performed * @param report The Particle Analysis Report for the particle * * @return The X Edge Score (0-100) */ public double scoreXEdge(BinaryImage image, ParticleAnalysisReport report) throws NIVisionException { double total = 0; LinearAverages averages; NIVision.Rect rect = new NIVision.Rect(report.boundingRectTop, report.boundingRectLeft, report.boundingRectHeight, report.boundingRectWidth); averages = NIVision.getLinearAverages(image.image, LinearAverages.LinearAveragesMode.IMAQ_COLUMN_AVERAGES, rect); float columnAverages[] = averages.getColumnAverages(); for(int i=0; i < (columnAverages.length); i++){ if(xMin[(i*(XMINSIZE-1)/columnAverages.length)] < columnAverages[i] && columnAverages[i] < xMax[i*(XMAXSIZE-1)/columnAverages.length]){ total++; } } total = 100*total/(columnAverages.length); return total; }
/** * Computes a score based on the match between a template profile and the particle profile in the Y direction. This method uses the * the row averages and the profile defined at the top of the sample to look for the solid horizontal edges with * a hollow center * * @param image The image to use, should be the image before the convex hull is performed * @param report The Particle Analysis Report for the particle * * @return The Y Edge score (0-100) * */ public double scoreYEdge(BinaryImage image, ParticleAnalysisReport report) throws NIVisionException { double total = 0; LinearAverages averages; NIVision.Rect rect = new NIVision.Rect(report.boundingRectTop, report.boundingRectLeft, report.boundingRectHeight, report.boundingRectWidth); averages = NIVision.getLinearAverages(image.image, LinearAverages.LinearAveragesMode.IMAQ_ROW_AVERAGES, rect); float rowAverages[] = averages.getRowAverages(); for(int i=0; i < (rowAverages.length); i++){ if(yMin[(i*(YMINSIZE-1)/rowAverages.length)] < rowAverages[i] && rowAverages[i] < yMax[i*(YMAXSIZE-1)/rowAverages.length]){ total++; } } total = 100*total/(rowAverages.length); return total; }
/** * 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; }
/** * 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))); }
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))); }
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))); }
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))); }
public VisionTarget [] processFrame() { if (enableVision) { lastFrame = System.currentTimeMillis(); try { ColorImage image = camera.getImage(); BinaryImage bImage = image.thresholdRGB( redLow, redHigh, greenLow, greenHigh, blueLow, blueHigh); BinaryImage fImage = bImage.particleFilter(cc); ParticleAnalysisReport [] report = fImage.getOrderedParticleAnalysisReports(); VisionTarget [] targets = new VisionTarget[report.length]; for (int i = 0; i < report.length; i++) { double centerX = report[i].center_mass_x; double centerY = report[i].center_mass_y; double width = report[i].boundingRectWidth; double height = report[i].boundingRectHeight; int area = (int)report[i].particleArea; targets[i] = new VisionTarget(centerX, centerY, width, height, area); } frameProcess = System.currentTimeMillis() - lastFrame; image.free(); bImage.free(); fImage.free(); return targets; } catch (AxisCameraException e) { System.out.println("No Image From Camera: "); frameProcess = System.currentTimeMillis() - lastFrame; return new VisionTarget[0]; } catch (Exception ex) { System.out.println("Camera Exception Thrown: " + ex.getMessage()); frameProcess = System.currentTimeMillis() - lastFrame; return new VisionTarget[0]; } } else { // Vision is not enabled return new VisionTarget[0]; } }
/** * 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( }
public BinaryImage getFilteredImage() throws Exception { ColorImage ci = getImage(); bi = ci.thresholdRGB(RED_LOW, RED_HIGH, GREEN_LOW, GREEN_HIGH, BLUE_LOW, BLUE_HIGH); bi = bi.convexHull(false); bi = bi.removeSmallObjects(true, 3); bi = bi.particleFilter(cc); ci.free(); return bi; }
public BinaryImage getHSVimage(ColorImage image){ try{ this.HSVimage = image.thresholdHSV(92, 196, 19, 100, 30, 100); } catch (NIVisionException ex) { ex.printStackTrace(); } System.out.println("Processed HSV image"); return this.HSVimage; }
public BinaryImage getRGBimage(ColorImage image) { try{ this.RGBimage = image.thresholdRGB(0, 150, 145, 230, 120, 225); } catch (NIVisionException ex) { ex.printStackTrace(); } System.out.println("Processing RGB image"); return this.RGBimage; }
/** * 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))); }
/** * 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. */ public static double computeDistance(BinaryImage image, ParticleAnalysisReport report, int particleNumber, boolean outer) throws NIVisionException { double rectShort, height; int 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); targetHeight = outer ? 29 : 21; return X_IMAGE_RES * targetHeight / (height * 12 * 2 * Math.tan(VIEW_ANGLE * Math.PI / (180 * 2))); }
/** * 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 static 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))); }
/** * 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))); }
