AI വിഷൻ സെൻസർ#

ആമുഖം#

EXP AI വിഷൻ സെൻസറിൽ നിന്നുള്ള ഡാറ്റ നിയന്ത്രിക്കാനും ആക്‌സസ് ചെയ്യാനും aivision ക്ലാസ് ഉപയോഗിക്കുന്നു. AI വിഷൻ സെൻസറിന് ഇവ കണ്ടെത്താനാകും:

  • AI വർഗ്ഗീകരണങ്ങൾ (ഗെയിം വസ്തുക്കൾ പോലുള്ളവ)

  • ഏപ്രിൽടാഗ് ഐഡികൾ

  • ഇഷ്ടാനുസൃത വർണ്ണ ഒപ്പുകൾ

  • ഇഷ്ടാനുസൃത വർണ്ണ കോഡുകൾ

സ്ഥാനം, വലിപ്പം, ഓറിയന്റേഷൻ, വർഗ്ഗീകരണ ഐഡി, കോൺഫിഡൻസ് സ്കോർ എന്നിവയുൾപ്പെടെയുള്ള ഒബ്ജക്റ്റ് ഡാറ്റ ഇത് നൽകുന്നു.

VEXcode-ലെ AI Vision Utility-ൽ തിരഞ്ഞെടുത്ത ഒരു ഓൺബോർഡ് AI മോഡൽ ഉപയോഗിച്ചാണ് സെൻസർ ദൃശ്യ വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നത്. തിരഞ്ഞെടുത്ത മോഡൽ സെൻസറിന് ഏതൊക്കെ AI ക്ലാസിഫിക്കേഷനുകളാണ് കണ്ടെത്താൻ കഴിയുക എന്ന് നിർണ്ണയിക്കുന്നു. VS കോഡ് ഉപയോഗിക്കുമ്പോൾ, നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഉപയോഗിക്കുന്നതിന് മുമ്പ് AI മോഡൽ ആദ്യം VEXcode-ൽ കോൺഫിഗർ ചെയ്യണം. takeSnapshot വിളിച്ചതിന് ശേഷം കണ്ടെത്തിയ വസ്തുക്കൾ objects അറേ വഴി തിരികെ നൽകും.

ക്ലാസ് കൺസ്ട്രക്‌ടറുകൾ#

aivision(
  int32_t index,
  Args&... sigs );

പാരാമീറ്ററുകൾ#

പാരാമീറ്റർ

ടൈപ്പ് ചെയ്യുക

വിവരണം

index

int32_t

AI വിഷൻ സെൻസർ ബന്ധിപ്പിച്ചിരിക്കുന്ന സ്മാർട്ട് പോർട്ട്, PORTxഎന്ന് എഴുതിയിരിക്കുന്നു, ഇവിടെ x എന്നത് പോർട്ട് നമ്പറാണ് (ഉദാഹരണത്തിന്, PORT1).

sigs

colordesc, codedesc, or AI constants

സെൻസറിൽ രജിസ്റ്റർ ചെയ്യേണ്ട ഒന്നോ അതിലധികമോ ഡിറ്റക്ഷൻ തരങ്ങൾ:

  • aivision::ALL_AIOBJS — എല്ലാ AI ക്ലാസിഫിക്കേഷനുകളും
  • aivision::ALL_TAGS — എല്ലാ AprilTag ഐഡികളും
  • aivision::colordesc — കസ്റ്റം കളർ സിഗ്നേച്ചർ
  • aivision::codedesc — കസ്റ്റം കളർ കോഡ്

AI മോഡലുകളും വർഗ്ഗീകരണങ്ങളും#

ചില AI ക്ലാസിഫിക്കേഷനുകൾ ഉപയോഗിച്ച് AI വിഷൻ സെൻസറിന് വ്യത്യസ്ത വസ്തുക്കളെ കണ്ടെത്താൻ കഴിയും. ഡിവൈസസ് വിൻഡോയിൽ AI വിഷൻ സെൻസർ കോൺഫിഗർ ചെയ്യുമ്പോൾ തിരഞ്ഞെടുത്ത AI ക്ലാസിഫിക്കേഷൻ മോഡലിനെ ആശ്രയിച്ച്, വ്യത്യസ്ത വസ്തുക്കൾ കണ്ടെത്താൻ കഴിയും. നിലവിൽ ലഭ്യമായ മോഡലുകൾ ഇവയാണ്:

ക്ലാസ്റൂം ഘടകങ്ങൾ

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

blueBall

1

greenBall

2

redBall

3

blueRing

4

greenRing

5

redRing

6

blueCube

7

greenCube

8

redCube

VEX V5 റോബോട്ടിക്സ് മത്സരത്തിൽ വൻ വെല്ലുവിളികൾ

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

mobileGoal

1

redRing

2

blueRing

VEX V5 റോബോട്ടിക്സ് മത്സരം പുഷ് ബാക്ക്

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

blueBlock

1

redBlock

VEX V5 റോബോട്ടിക്സ് മത്സര ഓവർറൈഡ്

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

redBluePin

1

blueYellowPin

2

redYellowPin

3

yellowPin

4

cup

ഉദാഹരണങ്ങൾ#

// Create Color Signatures
aivision::colordesc AIVision1__greenBox(
    1,      // index
    85,     // red
    149,    // green
    46,     // blue
    23,     // hangle
    0.23 ); // hdsat

aivision::colordesc AIVision1__blueBox(
    2,      // index
    77,     // red
    135,    // green
    125,    // blue
    27,     // hangle
    0.29 ); // hdsat

// Create a Color Code from two color signatures
aivision::codedesc AIVision1__greenBlue(
    1,                    // code index
    AIVision1__greenBox,  // first color signature
    AIVision1__blueBox ); // second color signature

// Create the AI Vision Sensor instance
aivision AIVision1(
    PORT11,                  // Smart Port
    AIVision1__greenBlue,    // color code
    aivision::ALL_AIOBJS );  // enable AI Classifications

അംഗ പ്രവർത്തനങ്ങൾ#

aivision ക്ലാസ്സിൽ ഇനിപ്പറയുന്ന അംഗ ഫംഗ്‌ഷനുകൾ ഉൾപ്പെടുന്നു:

  • takeSnapshot — ഒരു പ്രത്യേക കളർ സിഗ്നേച്ചർ, കളർ കോഡ്, AI ക്ലാസിഫിക്കേഷൻ ഗ്രൂപ്പ് അല്ലെങ്കിൽ AprilTag ID ഗ്രൂപ്പ് എന്നിവയ്‌ക്കായി ഡാറ്റ ക്യാപ്‌ചർ ചെയ്യുന്നു.

  • installed — AI വിഷൻ സെൻസർ EXP ബ്രെയിനുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് നൽകുന്നു.

takeSnapshot വിളിച്ചതിന് ശേഷം കണ്ടെത്തിയ ഒബ്‌ജക്റ്റ് ഡാറ്റ ആക്‌സസ് ചെയ്യാൻ, ലഭ്യമായ Properties ഉപയോഗിക്കുക.

ഏതെങ്കിലും aivision അംഗ ഫംഗ്ഷനുകൾ വിളിക്കുന്നതിന് മുമ്പ്, താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ ഒരു aivision ഉദാഹരണം സൃഷ്ടിക്കണം:

/* This constructor is required when using VS Code.
AI Vision Sensor configuration is generated automatically
in VEXcode using the Device Menu. Replace the values
as needed. */


// Create Color Signatures
aivision::colordesc AIVision1__greenBox(
    1,      // index
    85,     // red
    149,    // green
    46,     // blue
    23,     // hangle
    0.23 ); // hdsat

aivision::colordesc AIVision1__blueBox(
    2,      // index
    77,     // red
    135,    // green
    125,    // blue
    27,     // hangle
    0.29 ); // hdsat

// Create a Color Code from two color signatures
aivision::codedesc AIVision1__greenBlue(
    1,                    // code index
    AIVision1__greenBox,  // first color signature
    AIVision1__blueBox ); // second color signature

// Create the AI Vision Sensor instance
aivision AIVision1(
    PORT1,                   // Smart Port
    AIVision1__greenBlue,    // color code
    aivision::ALL_AIOBJS );  // enable AI Classifications

takeSnapshot#

AI വിഷൻ സെൻസറിൽ നിന്ന് ഒരു ചിത്രം പകർത്തുന്നു, തിരഞ്ഞെടുത്ത AI മോഡൽ അല്ലെങ്കിൽ കോൺഫിഗർ ചെയ്ത കളർ സിഗ്നേച്ചറുകൾ ഉപയോഗിച്ച് അത് പ്രോസസ്സ് ചെയ്യുന്നു, കൂടാതെ objects അറേ അപ്ഡേറ്റ് ചെയ്യുന്നു.

ഓരോ കോളും ഏറ്റവും പുതിയ കണ്ടെത്തൽ ഫലങ്ങളോടെ objects അറേ പുതുക്കുന്നു. ഒബ്‌ജക്‌റ്റുകൾ ഏറ്റവും വലുതിൽ നിന്ന് ചെറുതിലേക്ക് (വീതി അനുസരിച്ച്) ക്രമീകരിച്ചിരിക്കുന്നു, സൂചിക 0മുതൽ ആരംഭിക്കുന്നു. ഒബ്‌ജക്‌റ്റുകൾ കണ്ടെത്തിയില്ലെങ്കിൽ objectCount 0 ഉം objects[i].exists ആയിരിക്കും false false

1 — ഒരു ഒബ്ജക്റ്റ് ഐഡിയും ഒബ്ജക്റ്റ് തരവും ഉപയോഗിച്ച് ഒരു സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു.

int32_t takeSnapshot(
  uint32_t id,
  objectType type,
  uint32_t count );

2 — കളർ സിഗ്നേച്ചർ ഉപയോഗിച്ച് ഒരു സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു.

int32_t takeSnapshot(
  const colordesc &desc,
  int32_t count = 8 );

3 — കളർ കോഡ് ഉപയോഗിച്ച് ഒരു സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു.

int32_t takeSnapshot(
  const codedesc &desc,
  int32_t count = 8 );

4 — AprilTag ID ഉപയോഗിച്ച് ഒരു സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു.

int32_t takeSnapshot(
  const tagdesc &desc,
  int32_t count = 8 );

5 — AI വർഗ്ഗീകരണം ഉപയോഗിച്ച് ഒരു സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു.

int32_t takeSnapshot(
  const aiobjdesc &desc,
  int32_t count = 8 );

6 — ഒരു ഒബ്ജക്റ്റ് ഡിസ്ക്രിപ്റ്റർ ഉപയോഗിച്ച് ഒരു സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു.

int32_t takeSnapshot(
  const objdesc &desc,
  int32_t count = 8 );
Parameters

പാരാമീറ്റർ

ടൈപ്പ് ചെയ്യുക

വിവരണം

id

uint32_t

(id, type, count) ഫംഗ്ഷൻ ഉപയോഗിക്കുമ്പോൾ കണ്ടെത്തേണ്ട വസ്തുവിന്റെ ഐഡന്റിഫയർ. അർത്ഥം type:

  • colorObject — കളർ ഡിസ്ക്രിപ്റ്റർ സൂചിക (1–7)
  • codeObject — കളർ കോഡ് സൂചിക (1–8)
  • modelObject — AI ക്ലാസിഫിക്കേഷൻ ഐഡി
  • tagObject — ഏപ്രിൽടാഗ് ഐഡി (0–36)

കുറിപ്പ്: VEXcode-ൽ, AI ക്ലാസിഫിക്കേഷൻ നാമങ്ങൾ ( blueBallപോലുള്ളവ) നേരിട്ട് ഉപയോഗിക്കാം. VS കോഡിൽ, സംഖ്യാ ഐഡി ഉപയോഗിക്കണം.

type

objectType

id:

desc

colordesc &, codedesc &, tagdesc &, aiobjdesc &, or objdesc &

Descriptor used to detect a specific object. Passed directly to takeSnapshot, for example:

  • AIVision1.takeSnapshot(AIVision1__greenBox);
  • AIVision1.takeSnapshot(aivision::ALL_AIOBJS);
Predefined descriptor constants:
  • aivision::ALL_TAGS — Detects all AprilTag IDs
  • aivision::ALL_COLORS — Detects all configured Color Signatures
  • aivision::ALL_CODES — Detects all configured Color Codes
  • aivision::ALL_AIOBJS — Detects all AI Classifications
  • aivision::ALL_OBJECTS — Detects everything the sensor can recognize

count

uint32_t / int32_t

സ്നാപ്പ്ഷോട്ടിൽ നിന്ന് സംഭരിക്കാവുന്ന പരമാവധി വസ്തുക്കളുടെ എണ്ണം. ഡിഫോൾട്ടായി 8 ആണ്.

റിട്ടേൺ മൂല്യങ്ങൾ

നിർദ്ദിഷ്ട ഒപ്പുമായോ കണ്ടെത്തൽ തരവുമായോ പൊരുത്തപ്പെടുന്ന കണ്ടെത്തിയ വസ്തുക്കളുടെ എണ്ണത്തെ പ്രതിനിധീകരിക്കുന്ന int32_t നൽകുന്നു.

കുറിപ്പുകൾ

  • ഒബ്ജക്റ്റ് ഡാറ്റ ആക്‌സസ് ചെയ്യുന്നതിന് മുമ്പ് AI വിഷൻ സെൻസർ ഒരു സ്‌നാപ്പ്ഷോട്ട് എടുക്കണം.

  • ഓരോ കോളിലും objects അറേ പുതുക്കപ്പെടും.

  • count വ്യക്തമാക്കുമ്പോൾ, കണ്ടെത്തിയ ഏറ്റവും വലിയ വസ്തുക്കൾ (നിർദ്ദിഷ്ട അളവ് വരെ) മാത്രമേ സംഭരിക്കൂ.

VEXcode-ലെ AI വിഷൻ യൂട്ടിലിറ്റിയിൽ തിരഞ്ഞെടുത്ത മോഡലിനെ ആശ്രയിച്ചിരിക്കും AI വർഗ്ഗീകരണങ്ങൾ.

ഉദാഹരണങ്ങൾ 

// Move forward if an object is detected
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);
  if (AIVision1.objects[0].exists) {
    Drivetrain.driveFor(forward, 50, mm);
  }
  wait(50, msec);
}

installed#

AI വിഷൻ സെൻസർ EXP ബ്രെയിനുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് നൽകുന്നു.

ലഭ്യമായ ഫംഗ്‌ഷനുകൾ 

bool installed();

പാരാമീറ്ററുകൾ

ഈ ഫംഗ്ഷൻ ഒരു പാരാമീറ്ററുകളും എടുക്കുന്നില്ല.

റിട്ടേൺ മൂല്യങ്ങൾ

AI വിഷൻ സെൻസർ ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു:

  • true — AI വിഷൻ സെൻസർ ബന്ധിപ്പിച്ചിരിക്കുന്നു.

  • false — AI വിഷൻ സെൻസർ ബന്ധിപ്പിച്ചിട്ടില്ല.

// Display a message if the AI Vision Sensor is connected
if (AIVision1.installed()){
  Brain.Screen.print("Installed!");
}

പ്രോപ്പർട്ടികൾ#

takeSnapshot എന്ന് വിളിക്കുന്നത് AI വിഷൻ സെൻസറിന്റെ കണ്ടെത്തൽ ഫലങ്ങൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നു. ഓരോ സ്നാപ്പ്ഷോട്ടും objects അറേ പുതുക്കുന്നു, അതിൽ അഭ്യർത്ഥിച്ച AI ക്ലാസിഫിക്കേഷൻ, കളർ സിഗ്നേച്ചർ, കളർ കോഡ് അല്ലെങ്കിൽ ഏപ്രിൽ ടാഗ് ഐഡി എന്നിവയ്‌ക്കായി കണ്ടെത്തിയ ഒബ്‌ജക്‌റ്റുകൾ അടങ്ങിയിരിക്കുന്നു.

AIVisionSensor.objects[index]-ൽ സംഭരിച്ചിരിക്കുന്ന വസ്തുക്കളുടെ ഗുണങ്ങളിലൂടെയാണ് AI വിഷൻ ഡാറ്റ ആക്‌സസ് ചെയ്യുന്നത്, ഇവിടെ index 0 -ൽ ആരംഭിക്കുന്നു.

വസ്തുക്കളെ ഏറ്റവും വലുതിൽ നിന്ന് ചെറുതിലേക്ക് (വിസ്തീർണ്ണം അനുസരിച്ച്) ക്രമീകരിച്ചിരിക്കുന്നു.

AI വിഷൻ സെൻസർ ഇമേജ് റെസല്യൂഷൻ 320 × 240 പിക്സലുകൾആണ്. സെൻസറിന്റെ നിലവിലെ കാഴ്ചയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഒബ്ജക്റ്റ് സ്ഥാനവും വലുപ്പ മൂല്യങ്ങളും പിക്സൽ യൂണിറ്റുകളിലാണ് റിപ്പോർട്ട് ചെയ്തിരിക്കുന്നത്.

ഇനിപ്പറയുന്ന പ്രോപ്പർട്ടികൾ ലഭ്യമാണ്:

  • objectCount — ഏറ്റവും പുതിയ സ്നാപ്പ്ഷോട്ടിൽ നിന്ന് കണ്ടെത്തിയ വസ്തുക്കളുടെ എണ്ണം നൽകുന്നു.

  • largestObject — ഏറ്റവും പുതിയ സ്നാപ്പ്ഷോട്ടിൽ നിന്ന് കണ്ടെത്തിയ ഏറ്റവും വലിയ വസ്തു തിരഞ്ഞെടുക്കുന്നു.

  • objects — takeSnapshot അപ്ഡേറ്റ് ചെയ്ത കണ്ടെത്തിയ വസ്തുക്കൾ അടങ്ങിയ ശ്രേണി.

  • .exists — ഒബ്ജക്റ്റ് എൻട്രിയിൽ സാധുവായ ഡാറ്റ അടങ്ങിയിട്ടുണ്ടോ എന്ന്.

  • .width — കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി പിക്സലുകളിൽ.

  • .height — കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ.

  • .centerX — പിക്സലുകളിൽ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ X സ്ഥാനം.

  • .centerY — വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ Y സ്ഥാനം പിക്സലുകളിൽ.

  • .originX — പിക്സലുകളിൽ വസ്തുവിന്റെ മുകളിൽ ഇടത് കോണിന്റെ X സ്ഥാനം.

  • .originY — പിക്സലുകളിൽ വസ്തുവിന്റെ മുകളിൽ ഇടത് കോണിന്റെ Y സ്ഥാനം.

  • .angle — ഡിഗ്രികളിൽ ഒരു കളർ കോഡിന്റെയോ ഏപ്രിൽ ടാഗ് ഐഡിയുടെയോ ഓറിയന്റേഷൻ.

  • .id — ക്ലാസിഫിക്കേഷൻ ഐഡി അല്ലെങ്കിൽ ഏപ്രിൽ ടാഗ് ഐഡി.

  • .score — AI ക്ലാസിഫിക്കേഷനുകൾക്കുള്ള കോൺഫിഡൻസ് സ്കോർ.

objectCount#

objectCount objects അറേയ്ക്കുള്ളിലെ ഇനങ്ങളുടെ എണ്ണം ഒരു പൂർണ്ണസംഖ്യയായി നൽകുന്നു.

Syntax 
AIVisionSensor.objectCount
Components

ഘടകം

വിവരണം

AIVisionSensor

നിങ്ങളുടെ AI വിഷൻ സെൻസർ ഉദാഹരണത്തിന്റെ പേര്.

ഉദാഹരണങ്ങൾ 

// Display the number of detected objects
while (true) {
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearLine(1);
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);
  if (AIVision1.objects[0].exists) {
    Brain.Screen.print("%d", AIVision1.objectCount);
  }
  wait(50, msec);
}

largestObject#

largestObject , objects ശ്രേണിയിൽ നിന്ന് കണ്ടെത്തിയ ഏറ്റവും വലിയ ഒബ്ജക്റ്റിനെ വീണ്ടെടുക്കുന്നു.

ഒരു സൂചിക വ്യക്തമാക്കാതെ തന്നെ objects ൽ നിന്ന് ഏറ്റവും വലിയ ഒബ്ജക്റ്റ് എപ്പോഴും ലഭിക്കാൻ ഈ രീതി ഉപയോഗിക്കാം.

Syntax 
AIVisionSensor.largestObject
Components

ഘടകം

വിവരണം

AIVisionSensor

നിങ്ങളുടെ AI വിഷൻ സെൻസർ ഉദാഹരണത്തിന്റെ പേര്.

ഉദാഹരണങ്ങൾ 

// Display the closest AprilTag ID
while (true) {
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearLine(1);
  AIVision1.takeSnapshot(aivision::ALL_TAGS);
  if (AIVision1.objects[0].exists) {
    Brain.Screen.print("%d", AIVision1.largestObject.id);
  }
  wait(50, msec);
}

objects#

objects കണ്ടെത്തിയ ഒബ്‌ജക്റ്റ് പ്രോപ്പർട്ടികളുടെ ഒരു ശ്രേണി നൽകുന്നു. വ്യക്തിഗത ഒബ്‌ജക്‌റ്റുകളുടെ നിർദ്ദിഷ്ട പ്രോപ്പർട്ടി മൂല്യങ്ങൾ ആക്‌സസ് ചെയ്യാൻ അറേ ഉപയോഗിക്കുക.

takeSnapshot ഉപയോഗിച്ചതിന് ശേഷം objects array-യിൽ സംഭരിച്ചിരിക്കുന്ന ഓരോ ഒബ്‌ജക്റ്റിലും പത്ത് പ്രോപ്പർട്ടികൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

takeSnapshot ഉപയോഗിച്ച സമയത്ത്, AI Vision Sensor-ന്റെ വ്യൂവിൽ കണ്ടെത്തിയ വസ്തുവിന്റെ സ്ഥാനവും വലുപ്പവും id ഉം score ഒഴികെയുള്ള എല്ലാ പ്രോപ്പർട്ടി മൂല്യങ്ങളും വിവരിക്കുന്നു. സെൻസറിന്റെ 320 ബൈ 240 പിക്സൽ റെസല്യൂഷനെ അടിസ്ഥാനമാക്കി, ഈ മൂല്യങ്ങൾ പിക്സലുകളിലാണ് അളക്കുന്നത്.

Syntax 
AIVisionSensor.objects[index].property
Components

ഘടകം

വിവരണം

AIVisionSensor

നിങ്ങളുടെ AI വിഷൻ സെൻസർ ഉദാഹരണത്തിന്റെ പേര്.

index

അറേയിലെ ഒബ്ജക്റ്റ് സൂചിക. സൂചിക 0 ൽ ആരംഭിക്കുന്നു.

property

One of the available object properties.

.നിലവിലുണ്ട്#

നിർദ്ദിഷ്ട ഒബ്‌ജക്റ്റ് സൂചികയിൽ സാധുവായ ഒരു കണ്ടെത്തിയ ഒബ്‌ജക്റ്റ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് .exists നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].exists

റിട്ടേൺ മൂല്യങ്ങൾ

നിർദ്ദിഷ്ട ഒബ്‌ജക്റ്റ് സൂചികയിൽ സാധുവായ ഒരു കണ്ടെത്തിയ ഒബ്‌ജക്റ്റ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു:

  • true — A valid object exists at the specified index.
  • false — No object exists at the specified index.

ഉദാഹരണങ്ങൾ 

// Move forward if an object is detected
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);
  if (AIVision1.objects[0].exists) {
    Drivetrain.driveFor(forward, 50, mm);
  }
  wait(50, msec);
}

.വീതി#

.width കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].width

റിട്ടേൺ മൂല്യങ്ങൾ

കണ്ടെത്തിയ വസ്തുവിന്റെ വീതിയെ പിക്സലുകളിൽ പ്രതിനിധീകരിക്കുന്ന int16_t നൽകുന്നു. മൂല്യം 1 മുതൽ 320 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Approach an object until it's at least 100 pixels wide
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);

  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].width < 100) {
      Drivetrain.drive(forward);
    } else {
      Drivetrain.stop();
    }
  } else {
    Drivetrain.stop();
  }
  wait(50, msec);
}

.ഉയരം#

.height കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].height

റിട്ടേൺ മൂല്യങ്ങൾ

കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ പ്രതിനിധീകരിക്കുന്ന int16_t നൽകുന്നു. മൂല്യം 1 മുതൽ 240 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Approach an object until it's at least 90 pixels tall
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);

  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].height < 90) {
      Drivetrain.drive(forward);
    } else {
      Drivetrain.stop();
    }
  } else {
    Drivetrain.stop();
  }
  wait(50, msec);
}

.സെന്റർഎക്സ്#

.centerX കണ്ടെത്തിയ വസ്തുവിന്റെ മധ്യഭാഗത്തിന്റെ x-കോർഡിനേറ്റ് തിരികെ നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].centerX

റിട്ടേൺ മൂല്യങ്ങൾ

വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ x-കോർഡിനേറ്റിനെ പിക്സലുകളിൽ പ്രതിനിധീകരിക്കുന്ന int16_t നൽകുന്നു. മൂല്യം 0 മുതൽ 320 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Turn until an object is directly in front of the sensor
Drivetrain.setTurnVelocity(10, percent);
Drivetrain.turn(right);
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);

  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].centerX > 140 && AIVision1.objects[0].centerX < 180) {
      Drivetrain.stop();
    }
  }
  wait(10, msec);
}

.സെന്റർവൈ#

.centerY കണ്ടെത്തിയ വസ്തുവിന്റെ മധ്യഭാഗത്തിന്റെ y-കോർഡിനേറ്റ് നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].centerY

റിട്ടേൺ മൂല്യങ്ങൾ

വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ y-കോർഡിനേറ്റിനെ പിക്സലുകളിൽ പ്രതിനിധീകരിക്കുന്ന int16_t നൽകുന്നു. മൂല്യം 0 മുതൽ 240 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Approach an object until it's close to the sensor
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);

  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].centerY < 150) {
      Drivetrain.drive(forward);
    } else {
      Drivetrain.stop();
    }
  } else {
    Drivetrain.stop();
  }
  wait(50, msec);
}

.ആംഗിൾ#

.angle കണ്ടെത്തിയ കളർ കോഡിന്റെയോ ഏപ്രിൽ ടാഗ് ഐഡിയുടെയോ ഓറിയന്റേഷൻ നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].angle

റിട്ടേൺ മൂല്യങ്ങൾ

കണ്ടെത്തിയ കളർ കോഡിന്റെയോ ഏപ്രിൽ ടാഗ് ഐഡിയുടെയോ ഡിഗ്രിയിലെ ഭ്രമണത്തെ പ്രതിനിധീകരിക്കുന്ന float നൽകുന്നു. മൂല്യം 0 മുതൽ 359.9 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Turn left or right depending on how a configured
// Color Code is rotated
while (true) {
  AIVision1.takeSnapshot(AIVision1__redBlue);
  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].angle > 50 && AIVision1.objects[0].angle < 100) {
      Drivetrain.turn(right);
    }
    else if (AIVision1.objects[0].angle > 270 && AIVision1.objects[0].angle < 330) {
      Drivetrain.turn(left);
    }
    else {
      Drivetrain.stop();
    }
  } else {
    Drivetrain.stop();
  }
  wait(50, msec);
}

.ഒറിജിൻഎക്സ്#

.originX കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള x-കോർഡിനേറ്റ് നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].originX

റിട്ടേൺ മൂല്യങ്ങൾ

ഒബ്‌ജക്റ്റിന്റെ ബൗണ്ടിംഗ് ബോക്‌സ് ഒറിജിനലിന്റെ x-കോർഡിനേറ്റിനെ പിക്‌സലുകളിൽ പ്രതിനിധീകരിക്കുന്ന int16_t നൽകുന്നു. മൂല്യം 0 മുതൽ 320 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Display if an object is to the left or the right
while (true) {
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);
  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].originX < 120) {
      Brain.Screen.print("To the left!");
    } else {
      Brain.Screen.print("To the right!");
    }
  } else {
    Brain.Screen.print("No objects");
  }
  wait(100, msec);
}

.ഒറിജിൻവൈ#

.originY കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള y-കോർഡിനേറ്റ് നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].originY

റിട്ടേൺ മൂല്യങ്ങൾ

ഒബ്‌ജക്റ്റിന്റെ ബൗണ്ടിംഗ് ബോക്‌സ് ഒറിജിനലിന്റെ y-കോർഡിനേറ്റിനെ പിക്‌സലുകളിൽ പ്രതിനിധീകരിക്കുന്ന int16_t നൽകുന്നു. മൂല്യം 0 മുതൽ 240 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Display if an object is close or far
while (true) {
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);
  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].originY < 110) {
      Brain.Screen.print("Close");
    } else {
      Brain.Screen.print("Far");
    }
  }
  wait(100, msec);
}

.ഐഡി#

.id കണ്ടെത്തിയ AprilTag ID അല്ലെങ്കിൽ AI ക്ലാസിഫിക്കേഷൻ ID നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].id

റിട്ടേൺ മൂല്യങ്ങൾ

കണ്ടെത്തിയ വസ്തുവിന്റെ ഐഡിയെ പ്രതിനിധീകരിക്കുന്ന int32_t നൽകുന്നു:

ഉദാഹരണങ്ങൾ 

// Move forward when AprilTag ID 1 is detected
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_TAGS);
  if (AIVision1.objects[0].exists) {
    if (AIVision1.objects[0].id == 1) {
      Drivetrain.drive(forward);
    }
  } else {
    Drivetrain.stop();
  }
  wait(50, msec);
}

.സ്കോർ#

.score കണ്ടെത്തിയ AI ക്ലാസിഫിക്കേഷന്റെ കോൺഫിഡൻസ് സ്കോർ നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].score

റിട്ടേൺ മൂല്യങ്ങൾ

കണ്ടെത്തിയ AI ക്ലാസിഫിക്കേഷന്റെ കോൺഫിഡൻസ് സ്‌കോർ 1 നും 100 നും ഇടയിലാണെന്ന് സൂചിപ്പിക്കുന്ന int16_t നൽകുന്നു.

കുറഞ്ഞ സ്കോർ എന്നാൽ കണ്ടെത്തിയ വസ്തുവിനെക്കുറിച്ച് സെൻസറിന് ആത്മവിശ്വാസം കുറവാണെന്നാണ് അർത്ഥമാക്കുന്നത്, അതേസമയം ഉയർന്ന സ്കോർ എന്നാൽ സെൻസറിന് കൂടുതൽ ആത്മവിശ്വാസമുണ്ടെന്നാണ് അർത്ഥമാക്കുന്നത്.

ഉദാഹരണങ്ങൾ 

// Display if a score is confident
while (true) {
  AIVision1.takeSnapshot(aivision::ALL_AIOBJS);

  if (AIVision1.objects[0].exists) {
    Brain.screen.clearScreen();
    Brain.screen.setCursor(1, 1);

    if (AIVision1.objects[0].score > 95) {
      Brain.Screen.print("Confident");
    } else {
      Brain.Screen.print("Not confident");
    }
  }
  wait(50, msec);
}
On this page