visión#

El sensor de visión para VEX EXP detecta y rastrea firmas y códigos de color. Esto le permite analizar su entorno y reaccionar según los datos visuales detectados. A continuación, se muestra una lista de todos los métodos:

Métodos – Obtener datos del sensor de visión.

takeSnapshot – Captura datos para una firma de color o un código de color específico.
largestObject – Selecciona inmediatamente el objeto más grande de la instantánea.
objectCount – Devuelve la cantidad de objetos detectados como un entero.
objects – Devuelve una matriz que contiene las propiedades de los objetos detectados.
instalado – Si el sensor de visión está conectado al EXP Brain.

Propiedades: datos del objeto devueltos desde takeSnapshot.

.exists – Si el objeto existe en la detección actual como un valor booleano.
.width – Ancho del objeto detectado en píxeles.
.height – Altura del objeto detectado en píxeles.
.centerX – Posición X del centro del objeto en píxeles.
.centerY – Posición Y del centro del objeto en píxeles.
.angle – Orientación del código de color en grados.
.originX – Posición X de la esquina superior izquierda del objeto en píxeles.
.originY – Posición Y de la esquina superior izquierda del objeto en píxeles.

Constructores: inicializan y configuran manualmente el sensor de visión.

visión – Crea un sensor de visión.
vision::signature – Crea una firma de color.
vision::code – Crea un código de color.

En VEXcode, la inicialización del sensor de visión y sus Firmas de color y Códigos de color configurados se realiza automáticamente. En los ejemplos a continuación, el sensor de visión configurado se llamará Vision1. Para inicializar y construir manualmente un sensor de visión y sus firmas y códigos de color, consulte la sección Constructores en esta página.

Métodos #

Tomar instantánea #

takeSnapshot captura una imagen del sensor de visión, la procesa según las firmas y códigos de color configurados y actualiza la matriz objects. Este método también puede limitar la cantidad de objetos capturados en la instantánea.

Las Firmas de color y los Códigos de color deben configurarse primero en la Utilidad de visión antes de poder usarse con este método.

La matriz objects almacena objetos ordenados del más grande al más pequeño por ancho, comenzando en el índice 0. Se puede acceder a las propiedades de cada objeto usando su índice. objects es una matriz vacía si no se detectan objetos coincidentes.

Uso predeterminado:
Vision1.takeSnapshot(signature)

Parámetro	Descripción
`firma`	¿De qué objeto de firma o código se obtienen los datos? Su nombre debe pasarse como una cadena con el formato: el nombre del sensor de visión, seguido de dos guiones bajos y, a continuación, el nombre del objeto. Por ejemplo: `Vision1__REDBOX` o `Vision1__BOXCODE`.

while (true) {
  // Take a snapshot to check for detected objects.
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  // If objects were found, print the location.
  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Center X: %d", Vision1.largestObject.centerX);
  } 
  else {
    Brain.Screen.print("no object");
  }

  wait(0.5, seconds);
}

Sobrecarga

Vision1.takeSnapshot(firma, recuento)

Parámetro de sobrecarga	Descripción
`contar`	La cantidad de objetos a devolver como `uint32_t` donde se incluirán los objetos más grandes.

Ejemplos de sobrecarga

// Display a location if a blue box is detected
while (true) {
  // Take a snapshot of only one object
  Vision1.takeSnapshot(Vision1__BLUEBOX, 1);

  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  // If object was found, print the location.
  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Center X: %d", Vision1.largestObject.centerX);
  } 
  else {
    Brain.Screen.print("no object");
  }

  wait(0.5, seconds);
}

Firmas de color #

Una firma de color es un color único que el sensor de visión puede reconocer. Estas firmas permiten al sensor detectar y rastrear objetos según su color. Una vez configurada una firma de color, el sensor puede identificar objetos con ese color específico en su campo de visión. Las firmas de color se utilizan con take_snapshot para procesar y detectar objetos de color en tiempo real.

Para usar una Firma de Color configurada en un proyecto, su nombre debe pasarse como una cadena con el formato: el nombre del sensor de visión, seguido de dos guiones bajos y, a continuación, el nombre de la Firma de Color. Por ejemplo: vision_1__REDBOX.

//Display if any objects match the REDBOX signature
while (true) {
  // Take a snapshot to check for detected objects.
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearScreen();
  // Change to any configured Color Signature
  Vision1.takeSnapshot(Vision1__REDBOX);
  if (Vision1.objects[0].exists){
    Brain.Screen.print("Color signature");
    Brain.Screen.newLine();
    Brain.Screen.print("detected!");
    wait(0.1,seconds);
  }
}

Códigos de color #

Un código de color es un patrón estructurado compuesto por firmas de color dispuestas en un orden específico. Estos códigos permiten al sensor de visión reconocer patrones de color predefinidos. Los códigos de color son útiles para identificar objetos complejos o crear marcadores únicos para la navegación autónoma.

Para usar un código de color configurado en un proyecto, su nombre debe pasarse como una cadena con el formato: el nombre del sensor de visión, seguido de dos guiones bajos y, a continuación, el nombre del código de color. Por ejemplo: vision_1__BOXCODE.

// Display if any objects match the BOXCODE code
while (true) {
  // Take a snapshot to check for detected objects.
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearLine(1);
  // Change to any configured Color Code
  Vision1.takeSnapshot(Vision1__BOXCODE);
  if (Vision1.objects[0].exists){
    Brain.Screen.print("Color Code Detected!");
    wait(0.1, seconds);
  }
}

objeto más grande #

largestObject recupera el objeto más grande detectado de la matriz objects.

Este método se puede utilizar para obtener siempre el objeto más grande de objetos sin especificar un índice.

Uso predeterminado:
Vision1.largestObject

while (true){
  // Take a snapshot to check for detected objects.
  Vision1.takeSnapshot(Vision1__BLUEBOX);
  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  // If objects were found, print the location 
  // of largest.
  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Center X: %d", Vision1.largestObject.centerX);
  } 
  else {
    Brain.Screen.print("no object");
  }
  wait(0.5, seconds);
}

objectCount #

objectCount devuelve el número de elementos dentro de la matriz objects como un entero.

Uso predeterminado:
Vision1.objectCount

while (true) {
  // Take a snapshot to check for detected objects.
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  // Print how many objects were detected.
  Brain.Screen.print("object count: %d", Vision1.objectCount);

  wait(0.5, seconds);
}

instalado #

installed devuelve un entero que indica si el sensor de visión está conectado actualmente al EXP Brain.

1 – El sensor de visión está conectado al cerebro EXP.
0 – El sensor de visión no está conectado al cerebro EXP.

Parámetros	Descripción
	Este método no tiene parámetros.

// Display a message if the Vision Sensor is detected
if (Vision1.installed()){
  Brain.Screen.print("Vision Sensor");
  Brain.Screen.newLine();
  Brain.Screen.print("Installed!");
}

objetos #

objects devuelve una matriz de propiedades de objetos detectados. Use la matriz para acceder a valores específicos de propiedad de objetos individuales.

Uso predeterminado:
Vision1.objects

Propiedades #

Hay ocho propiedades que se incluyen con cada objeto almacenado en la matriz objects después de utilizar takeSnapshot.

Algunos valores de propiedad se basan en la posición del objeto detectado en la vista del sensor de visión al momento de usar takeSnapshot. El sensor de visión tiene una resolución de 316 x 212 píxeles.

.existe #

.exists devuelve un entero que indica si el índice existe en la matriz objects o no.

1: El índice existe.
0: El índice no existe.

// Check if at least one object is detected
while (true) {
  // Take a snapshot to check for detected objects.
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  // If an object exists, print its location.
  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Center X: %d", Vision1.objects[0].centerX);
  } 
  else {
    Brain.Screen.print("No objects detected.");
  }

  wait(0.5, seconds);
}

.ancho #

.width devuelve el ancho del objeto detectado en píxeles, que es un número entero entre 1 y 316.

// Move towards a blue box until its width is
// larger than 100 pixels
while (true){
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].width < 100) {
    Drivetrain.driveFor(forward, 10, mm);
  } 
  else {
    Drivetrain.stop();
  }

  wait(0.5, seconds);
}

.altura #

.height devuelve la altura del objeto detectado en píxeles, que es un número entero entre 1 y 212.

// Move towards a blue box until its height is
// larger than 100 pixels
while (true){
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].height < 100) {
    Drivetrain.driveFor(forward, 10, mm);
  } 
  else {
    Drivetrain.stop();
  }

  wait(0.5, seconds);
}

.centroX #

.centerX devuelve la coordenada x del centro del objeto detectado en píxeles, que es un número entero entre 0 y 316.

// Turn slowly until a blue box is centered in
// front of the robot
Drivetrain.setTurnVelocity(10,percent);
Drivetrain.turn(right);

while (true){
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].exists){
    if (140 < Vision1.largestObject.centerX && Vision1.largestObject.centerX < 180){
      Drivetrain.stop();
    }
  }
  wait(0.5,seconds);
}

.centerY #

.centerY devuelve la coordenada y del centro del objeto detectado en píxeles, que es un número entero entre 0 y 212.

// Move towards a blue object until its
// center y-coordinate is more than 140 pixels
while (true){
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].exists){
    if (Vision1.largestObject.centerY < 140){
      Drivetrain.drive(forward);
    }
  }
  else{
    Drivetrain.stop();
  }
  wait(0.5,seconds);
}

.ángulo #

.angle devuelve la orientación del objeto detectado en grados, que es un doble entre 0 y 316.

// Turn right or left depending on how the
// configured box code is rotated.
while (true){
  Vision1.takeSnapshot(Vision1__BOXCODE);

  if (Vision1.objects[0].exists){
    if (70 < Vision1.objects[0].angle && Vision1.objects[0].angle < 110){
      Drivetrain.turnFor(right, 45, degrees);
    }
    else if (250 < Vision1.objects[0].angle && Vision1.objects[0].angle < 290){
      Drivetrain.turnFor(left, 45, degrees);
    }
    else{
      Drivetrain.stop();
    }
  }
  wait(0.5,seconds);
}

.origenX #

.originX devuelve la coordenada x de la esquina superior izquierda del cuadro delimitador del objeto detectado en píxeles, que es un número entero entre 0 y 316.

// Display if a red box is to the
// left or the right
while (true){
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1,1);
    
  Vision1.takeSnapshot(Vision1__REDBOX);
    
  if (Vision1.objects[0].exists){
    if (Vision1.objects[0].originX < 160){
      Brain.Screen.print("To the left!");
    }
    else{ 
      Brain.Screen.print("To the right!");
    }
  }
  wait(0.5,seconds);
}

.origenY #

.originY devuelve la coordenada y de la esquina superior izquierda del cuadro delimitador del objeto detectado en píxeles, que es un número entero entre 0 y 212.

// Display if a red box is close or far
// from the robot.
while (true){
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1,1);
    
  Vision1.takeSnapshot(Vision1__REDBOX);

  if (Vision1.objects[0].exists){
    if (Vision1.objects[0].originY < 80){
      Brain.Screen.print("Far");
    }
    else{
      Brain.Screen.print("Close");
    }
  }
  wait(0.5,seconds);
}

Constructores #

Los constructores se utilizan para crear manualmente los objetos vision, signature y code, necesarios para configurar el sensor de visión fuera de VEXcode. Si se proporcionan menos argumentos, se deben usar los predeterminados o la sobrecarga de funciones en la definición del constructor.

Para los ejemplos a continuación, el sensor de visión configurado se llamará “Vision1” y los objetos de firma de color configurados, como “Vision1__BLUEBOX”, se utilizarán en todos los ejemplos posteriores en esta documentación de API cuando se haga referencia a los métodos de la clase “vision”.

Sensor de visión #

vision crea un sensor de visión y configura el nivel de brillo y las firmas que se utilizarán con el sensor.

Uso predeterminado: vision( int32_t index, uint8_t bright, Args &... sigs )

Parámetros predeterminados	Descripción
`puerto`	Un Puerto inteligente válido al que está conectado el sensor de visión.
`brillo`	El valor de brillo del sensor de visión, de 10 a 150.
`sigs`	El nombre de uno o más objetos Firma de color o Código de color creados previamente.

// Construct a vision object Vision1 with 1 color
// Vision1__REDBOX.
vision::signature Vision1__REDBOX = vision::signature (1, 10121, 10757, 10439,-1657, -1223, -1440,2.5, 1);
vision Vision1 = vision (PORT1, 50, Vision1__REDBOX);

while (true) {
  // Take a snapshot to check for detected objects.
  Vision1.takeSnapshot(Vision1__REDBOX);

  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  // If objects were found, print the location.
  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Center X: %d", Vision1.largestObject.centerX);
  } else {
    Brain.Screen.print("no object");
  }

  wait(0.5, seconds);
}

Firma de color #

La función signature crea una firma de color. Se pueden almacenar hasta siete firmas de color diferentes en un sensor de visión simultáneamente.

Uso predeterminado:

firma(índice, uMín, uMáx, uMedia, vMín, vMáx, vMedia, rgb, tipo)

Parámetro	Descripción
`índice`	El índice del objeto `signature`, de 1 a 7. Nota: La creación de dos objetos `signature` con el mismo número de índice hará que el segundo objeto creado anule al primero.
`uMin`	El valor de `uMin` en la Utilidad de Visión.
`uMax`	El valor de `uMax` en la Utilidad de Visión.
`uMean`	El valor de `uMean` en la Utilidad de Visión.
`vMin`	El valor de `vMin` en la Utilidad de Visión.
`vMáx`	El valor de `vMax` en la Utilidad de Visión.
`vMean`	El valor de `vMean` en la Utilidad de Visión.
`rgb`	El valor de `rgb` en la Utilidad de Visión.
`tipo`	El valor de `type` en la Utilidad de Visión.

Para obtener los valores necesarios para crear una Firma de Color, acceda a la Utilidad de Visión. Una vez configurada la Firma de Color, copie los valores de los parámetros desde la ventana de Configuración.

// Construct a vision object Vision1 with two Color
// Signatures, Vision1__REDBOX and Vision1__BLUEBOX.
vision::signature Vision1__REDBOX = vision::signature (1, 10121, 10757, 10439,-1657, -1223, -1440,2.5, 1);
vision::signature Vision1__BLUEBOX = vision::signature (2, -4479, -3277, -3878,5869, 7509, 6689,2.5, 1);
vision Vision1 = vision (PORT1, 50, Vision1__REDBOX, Vision1__BLUEBOX);

while (true) {
  // Take a snapshot to check for detected objects.
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  // Clear the screen/reset so that we can display
  // new information.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  // If objects were found, print the location.
  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Center X: %d", Vision1.largestObject.centerX);
  } else {
    Brain.Screen.print("no object");
  }

  wait(0.5, seconds);
}

Código de colores #

«Código» crea un código de color. Requiere al menos dos firmas de color predefinidas para su uso. Se pueden almacenar hasta ocho códigos de color diferentes en un sensor de visión simultáneamente.

Uso predeterminado:

código(sig1, sig2)

Parámetros	Descripción
`sig1`	Un objeto de `firma` creado previamente, o el índice `int32_t` de un objeto de firma creado previamente.
`sig2`	Un objeto de `firma` creado previamente, o el índice `int32_t` de un objeto de firma creado previamente.

// Construct a vision object Vision1 with two Color
// Signatures, Vision1__REDBOX and Vision1__BLUEBOX,
// Alongside a Color Code for a red box to the left of
// a blue box, Vision1__BOXCODE.
vision::signature Vision1__REDBOX = vision::signature (1, 10121, 10757, 10439,-1657, -1223, -1440,2.5, 1);
vision::signature Vision1__BLUEBOX = vision::signature (2, -4479, -3277, -3878,5869, 7509, 6689,2.5, 1);
vision::code Vision1__BOXCODE = vision::code (Vision1__REDBOX, Vision1__BLUEBOX);
vision Vision1 = vision (PORT1, 50, Vision1__REDBOX, Vision1__BLUEBOX);

// Turn right or left depending on how the
// configured box code is rotated.
while (true){
  Vision1.takeSnapshot(Vision1__BOXCODE);

  if (Vision1.objects[0].exists){
    if (70 < Vision1.objects[0].angle && Vision1.objects[0].angle < 110){
      Drivetrain.turnFor(right, 45, degrees);
    }
    else if (250 < Vision1.objects[0].angle && Vision1.objects[0].angle < 290){
      Drivetrain.turnFor(left, 45, degrees);
    }
    else{
      Drivetrain.stop();
    }
  }
  wait(0.5,seconds);
}

Sobrecargas

código(sig1, sig2, sig3)
código(sig1, sig2, sig3, sig4)
código(sig1, sig2, sig3, sig4, sig5)

Parámetros de sobrecarga	Descripción
`sig3`	Un objeto de `firma` creado previamente, o el índice `int32_t` de un objeto de firma creado previamente.
`sig4`	Un objeto de `firma` creado previamente, o el índice `int32_t` de un objeto de firma creado previamente.
`sig5`	Un objeto de `firma` creado previamente, o el índice `int32_t` de un objeto de firma creado previamente.

// Construct a vision object Vision1 with two Color
// Signatures, Vision1__REDBOX and Vision1__BLUEBOX,
// Alongside a Color Code for a red box to the left of
// a blue box alternating for 5 boxes, Vision1__BOXCODE.
vision::signature Vision1__REDBOX = vision::signature (1, 10121, 10757, 10439,-1657, -1223, -1440,2.5, 1);
vision::signature Vision1__BLUEBOX = vision::signature (2, -4479, -3277, -3878,5869, 7509, 6689,2.5, 1);
vision::code Vision1__BOXCODE = vision::code (Vision1__REDBOX, Vision1__BLUEBOX, Vision1__REDBOX, Vision1__BLUEBOX, Vision1__REDBOX);
vision Vision1 = vision (PORT1, 50, Vision1__REDBOX, Vision1__BLUEBOX);

// Turn right or left depending on how the
// configured box code is rotated.
while (true){
  Vision1.takeSnapshot(Vision1__BOXCODE);

  if (Vision1.objects[0].exists){
    if (70 < Vision1.objects[0].angle && Vision1.objects[0].angle < 110){
      Drivetrain.turnFor(right, 45, degrees);
    }
    else if (250 < Vision1.objects[0].angle && Vision1.objects[0].angle < 290){
      Drivetrain.turnFor(left, 45, degrees);
    }
    else{
      Drivetrain.stop();
    }
  }
  wait(0.5,seconds);
}