/** * 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 void getImages(String imageAppend) { try { ColorImage image = camera.getImage(); if(imageWriteLevel >= 1 && imageWriteLevel <= 3) { NIVision.writeFile(image.image, "/ColorImage" + imageAppend + ".jpg"); System.out.println("Saving Color Image"); } } catch(Throwable t) { t.printStackTrace(); } }
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))); }
public void init() { cc = new CriteriaCollection(); cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, AREA_MINIMUM, 65535, false); ledState = Relay.Value.kOff; }
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))); }
private VisionController() { camera = AxisCamera.getInstance(); cc = new CriteriaCollection(); // create the criteria for the particle filter cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, AREA_MINIMUM, 65535, false); target = new TargetReport(); verticalTargets = new int[MAX_PARTICLES]; horizontalTargets = new int[MAX_PARTICLES]; }
public GRTVisionTracker(AxisCamera cam) { super("Vision Tracker", NUM_DATA); this.camera = cam; this.cc = new CriteriaCollection(); // create the criteria for the particle filter cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, 500, 65535, false); X_IMAGE_RES = camera.getResolution().width; listeners = new Vector(); }
/** * 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 CameraSubsystem() { // super(kp, ki, kd); try { cam = AxisCamera.getInstance(); cam.writeResolution(AxisCamera.ResolutionT.k320x240); } catch(Exception e) { cam = null; System.out.println("Could not connect to camera."); } cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_BOUNDING_RECT_HEIGHT, MIN_HEIGHT, MAX_HEIGHT, true); cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_BOUNDING_RECT_WIDTH, MIN_WIDTH, MAX_WIDTH, true); // this.setSetpoint(160); // this.setAbsoluteTolerance(.03); }
/** * 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))); }
public AxisCameraM1101() { camera = AxisCamera.getInstance(); criteriaCollection = new CriteriaCollection(); criteriaCollection.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, AREA_MINIMUM, 65535, true); }
public CameraDetection(){ //camera = AxisCamera.getInstance(); System.out.println("Started Camera."); cc = new CriteriaCollection(); // create the criteria for the particle filter cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, AREA_MINIMUM, 65535, false); }
public void init() { camera = AxisCamera.getInstance(); cc = new CriteriaCollection(); cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, 200, 65536, false); }
vision() { camera = AxisCamera.getInstance("10.14.82.12"); cc = new CriteriaCollection(); // create the criteria for the particle filter cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, 500, 65535, false); }
public void robotInit() { //camera = AxisCamera.getInstance(); // get an instance of the camera cc = new CriteriaCollection(); // create the criteria for the particle filter cc.addCriteria(NIVision.MeasurementType.IMAQ_MT_AREA, AREA_MINIMUM, 65535, false); }
/** * 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))); }
