വിഷൻ സെൻസർ#

ആമുഖം#

EXP വിഷൻ സെൻസറിൽ നിന്നുള്ള ഡാറ്റ നിയന്ത്രിക്കാനും ആക്‌സസ് ചെയ്യാനും vision ക്ലാസ് ഉപയോഗിക്കുന്നു. ഈ സെൻസർ അതിന്റെ വ്യൂ ഫീൽഡിനുള്ളിൽ കളർ സിഗ്നേച്ചറുകൾ കണ്ടെത്തി ട്രാക്ക് ചെയ്യുന്നു, ഇത് നിങ്ങളുടെ റോബോട്ടിന് ലക്ഷ്യങ്ങൾ തിരിച്ചറിയാനും ദൃശ്യ വിവരങ്ങളോട് തത്സമയം പ്രതികരിക്കാനും അനുവദിക്കുന്നു.

വിഷൻ സെൻസറിന് ഒന്നിലധികം സിഗ്നേച്ചർ ഒബ്‌ജക്റ്റുകളെ ഒരേസമയം കണ്ടെത്താനും ഒബ്‌ജക്റ്റ് സ്ഥാനം, വീതി, ഉയരം, മധ്യ കോർഡിനേറ്റുകൾ തുടങ്ങിയ വിവരങ്ങൾ നൽകാനും കഴിയും.

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

vision(
  int32_t  index,
  uint8_t  bright,
  Args&... sigs );

ക്ലാസ് ഡിസ്ട്രക്റ്റർ#

vision വസ്തുവിനെ നശിപ്പിക്കുകയും അനുബന്ധ വിഭവങ്ങൾ പുറത്തുവിടുകയും ചെയ്യുന്നു.

~vision();

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

പാരാമീറ്റർ

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

വിവരണം

index

int32_t

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

bright

uint8_t

വിഷൻ സെൻസറിന്റെ തെളിച്ച നില.

sigs

vision::signature or vision::code objects

സെൻസറിൽ രജിസ്റ്റർ ചെയ്യേണ്ട ഒന്നോ അതിലധികമോ vision::signature അല്ലെങ്കിൽ vision::code വസ്തുക്കൾ.

ഉദാഹരണങ്ങൾ#

// Create Color Signatures
vision::signature Vision1__REDBOX = vision::signature(
    1,      // signature id
    10121,  // uMin
    10757,  // uMax
    10439,  // uMean
    -1657,  // vMin
    -1223,  // vMax
    -1440,  // vMean
    2.5,    // range
    1 );    // type

vision::signature Vision1__BLUEBOX = vision::signature(
    2,      // signature id
    -4479,  // uMin
    -3277,  // uMax
    -3878,  // uMean
    5869,   // vMin
    7509,   // vMax
    6689,   // vMean
    2.5,    // range
    1 );    // type

// Create a Color Code from two signatures
vision::code Vision1__BOXCODE = vision::code(
    Vision1__REDBOX,  // first signature
    Vision1__BLUEBOX  // second signature
);

// Create the Vision Sensor instance
vision Vision1 = vision(
    PORT1,                  // Smart Port
    50,                     // brightness
    Vision1__REDBOX,        // signature
    Vision1__BOXCODE );     // Color Code

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

vision ക്ലാസ്സിൽ ഇനിപ്പറയുന്ന അംഗ പ്രവർത്തനങ്ങൾ ഉൾപ്പെടുന്നു:

  • takeSnapshot — ഒരു പ്രത്യേക കളർ സിഗ്നേച്ചറിനോ കളർ കോഡിനോ വേണ്ടി ഡാറ്റ ക്യാപ്‌ചർ ചെയ്യുന്നു.

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

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

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

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


// Create Color Signatures
vision::signature Vision1__REDBOX = vision::signature(
    1,      // signature id
    10121,  // uMin
    10757,  // uMax
    10439,  // uMean
    -1657,  // vMin
    -1223,  // vMax
    -1440,  // vMean
    2.5,    // range
    1 );    // type

vision::signature Vision1__BLUEBOX = vision::signature(
    2,      // signature id
    -4479,  // uMin
    -3277,  // uMax
    -3878,  // uMean
    5869,   // vMin
    7509,   // vMax
    6689,   // vMean
    2.5,    // range
    1 );    // type

// Create a Color Code from two signatures
vision::code Vision1__BOXCODE = vision::code(
    Vision1__REDBOX,  // first signature
    Vision1__BLUEBOX  // second signature
);

// Create the Vision Sensor instance
vision Vision1 = vision(
    PORT1,                  // Smart Port
    50,                     // brightness
    Vision1__REDBOX,        // signature
    Vision1__BOXCODE );     // Color Code

takeSnapshot#

വിഷൻ സെൻസറിൽ നിന്ന് ഒരു ചിത്രം പകർത്തുന്നു, ഒപ്പിനെ അടിസ്ഥാനമാക്കി അത് പ്രോസസ്സ് ചെയ്യുന്നു, objects അറേ അപ്‌ഡേറ്റ് ചെയ്യുന്നു. സ്നാപ്പ്ഷോട്ടിൽ പകർത്തിയ ഒബ്‌ജക്‌റ്റുകളുടെ അളവ് പരിമിതപ്പെടുത്താനും ഈ രീതിക്ക് കഴിയും.

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

Available Functions

1 — ഒരു സ്നാപ്പ്ഷോട്ട് എടുത്ത് നിർദ്ദിഷ്ട സിഗ്നേച്ചർ ഐഡിയുമായി പൊരുത്തപ്പെടുന്ന വസ്തുക്കൾക്കായി തിരയുന്നു.

int32_t takeSnapshot( uint32_t id );

2 — ഒരു സ്നാപ്പ്ഷോട്ട് എടുത്ത് നിർദ്ദിഷ്ട vision::code ഒബ്ജക്റ്റുമായി പൊരുത്തപ്പെടുന്ന വസ്തുക്കൾക്കായി തിരയുന്നു.

int32_t takeSnapshot( code &cc );

3 — ഒരു സ്നാപ്പ്ഷോട്ട് എടുത്ത് നിർദ്ദിഷ്ട vision::signature ഒബ്ജക്റ്റുമായി പൊരുത്തപ്പെടുന്ന വസ്തുക്കൾക്കായി തിരയുന്നു.

int32_t takeSnapshot( signature &sig );

4 — ഒരു സ്നാപ്പ്ഷോട്ട് എടുത്ത് സിഗ്നേച്ചർ ഐഡിയുമായി പൊരുത്തപ്പെടുന്ന ഏറ്റവും വലിയ എണ്ണം ഒബ്‌ജക്റ്റുകൾ മാത്രം സംഭരിക്കുന്നു.

int32_t takeSnapshot( uint32_t id, uint32_t count );

5 — ഒരു സ്നാപ്പ്ഷോട്ട് എടുത്ത് നിർദ്ദിഷ്ട vision::code ഒബ്ജക്റ്റ്.

int32_t takeSnapshot( code &cc, uint32_t count );

6 — ഒരു സ്നാപ്പ്ഷോട്ട് എടുത്ത് നിർദ്ദിഷ്ട vision::signature ഒബ്‌ജക്റ്റ്.

int32_t takeSnapshot( signature &sig, uint32_t count );
Parameters

പാരാമീറ്റർ

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

വിവരണം

id

uint32_t

തിരയേണ്ട ഒപ്പ് ഐഡി നമ്പർ.

cc

code &

തിരയേണ്ട vision::code ഒബ്‌ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസ്.

sig

signature &

തിരയേണ്ട vision::signature ഒബ്‌ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസ്.

count

uint32_t

കണ്ടെത്താനുള്ള പരമാവധി വസ്തുക്കളുടെ എണ്ണം.
Return Values

കണ്ടെത്തിയ പൊരുത്തമുള്ള വസ്തുക്കളുടെ എണ്ണത്തെ പ്രതിനിധീകരിക്കുന്ന int32_t നൽകുന്നു.

Notes

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

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

ഉദാഹരണങ്ങൾ 

while (true) {
  // Display if a blue object is detected
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);

  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Blue detected");
  } 
  else {
    Brain.Screen.print("No blue");
  }

  wait(0.5, seconds);
}


// Display when a blue object is detected
while (true) {
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearLine(1);

  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Color detected!");
  }

  wait(100, msec); 
}


// Display when BOXCODE is detected
while (true) {
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearLine(1);

  Vision1.takeSnapshot(Vision1__BOXCODE);

  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Code detected!");
  }
  wait( 100, msec);
}

installed#

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

Available Functions 
bool installed();
Parameters

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

Return Values

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

  • true — The Vision Sensor is connected.
  • false — The Vision Sensor is not connected.

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

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

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

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

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

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

  • objectCount — objects ൽ സംഭരിച്ചിരിക്കുന്ന സാധുവായ ഒബ്‌ജക്‌റ്റുകളുടെ എണ്ണം നൽകുന്നു.

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

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

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

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

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

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

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

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

  • .angle — Orientation of the detected Color Code in degrees (when applicable).

largestObject#

objects അറേയിൽ നിന്ന് കണ്ടെത്തിയ ഏറ്റവും വലിയ ഒബ്‌ജക്‌റ്റിനെ വീണ്ടെടുക്കുന്നു.

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

Syntax 
VisionSensor.largestObject
Components

ഘടകം

വിവരണം

VisionSensor

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

ഉദാഹരണങ്ങൾ 

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  // Display the largest detected object's width
  while (true) {
    Vision1.takeSnapshot(Vision1__BLUEBOX);

    Brain.Screen.clearScreen();
    Brain.Screen.setCursor(1, 1);

    if (Vision1.objects[0].exists) {
      Brain.Screen.print("%d", Vision1.largestObject.width);
    } 
    wait(0.5, seconds);
  }
}

objectCount#

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

Syntax 
VisionSensor.objectCount
Components

ഘടകം

വിവരണം

VisionSensor

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

ഉദാഹരണങ്ങൾ 

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  // Display how many blue objects are detected
  while (true) {
    Vision1.takeSnapshot(Vision1__BLUEBOX);

    Brain.Screen.clearScreen();
    Brain.Screen.setCursor(1, 1);

    Brain.Screen.print("Object Count: %d", Vision1.objectCount);

    wait(0.5, seconds);
  }
}

objects#

objects എന്നത് takeSnapshot ലേക്കുള്ള ഏറ്റവും പുതിയ കോളിൽ നിന്ന് കണ്ടെത്തിയ ഒബ്‌ജക്‌റ്റുകൾ അടങ്ങിയ ഒരു അറേയാണ്.

അറേയിലെ ഓരോ എലമെന്റും കണ്ടെത്തിയ ഒരു വസ്തുവിനെ പ്രതിനിധീകരിക്കുകയും width, height, centerX, തുടങ്ങിയ അതിന്റെ ഗുണങ്ങളിലേക്ക് പ്രവേശനം നൽകുകയും ചെയ്യുന്നു.

വസ്തുക്കളെ ഏറ്റവും വലുത് മുതൽ ചെറുത് വരെ (വീതി അനുസരിച്ച്) ക്രമീകരിച്ചിരിക്കുന്നു, സൂചിക 0 മുതൽ ആരംഭിക്കുന്നു.

Syntax 
VisionSensor.objects[index].property
Components

ഘടകം

വിവരണം

VisionSensor

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

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.

ഉദാഹരണങ്ങൾ 

// Display when a blue object is detected
while (true) {
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.clearLine(1);

  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].exists) {
    Brain.Screen.print("Color detected!");
  }

  wait(100, msec); 
}

.വീതി#

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

ആക്സസ് 

SensorName.objects[index].width

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

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

ഉദാഹരണങ്ങൾ 

// Approach an object until it's at least 100 pixels wide
while (true) {
  Vision1.takeSnapshot(Vision1__BLUEBOX);
  if (Vision1.objects[0].exists && Vision1.objects[0].width < 100) {
    Drivetrain.driveFor(forward, 10, mm);
  } 
  else {
    Drivetrain.stop();
  }
  wait(0.5, seconds);
}

.ഉയരം#

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

ആക്സസ് 

SensorName.objects[index].height

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

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

ഉദാഹരണങ്ങൾ 

// Approach an object until it's at least 100 pixels tall
while (true) {
  Vision1.takeSnapshot(Vision1__BLUEBOX);

  if (Vision1.objects[0].exists && Vision1.objects[0].height < 100) {
    Drivetrain.driveFor(forward, 10, mm);
  } 
  else {
    Drivetrain.stop();
  }
  wait(0.5, seconds);  // Avoid over-processing
}

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

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

ആക്സസ് 

SensorName.objects[index].centerX

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

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

ഉദാഹരണങ്ങൾ 

// Turn until an object is directly in front of the sensor
Drivetrain.setTurnVelocity(10, percent);
Drivetrain.turn(right);
while (true) {
  Vision1.takeSnapshot(Vision1__BLUEBOX);
  if (Vision1.objects[0].exists) {
    int centerX = Vision1.largestObject.centerX;
    if (140 < centerX && centerX < 180) {
      Drivetrain.stop();
    }
  }
  wait(0.5, seconds);
}

.സെന്റർവൈ#

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

ആക്സസ് 

SensorName.objects[index].centerY

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

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

ഉദാഹരണങ്ങൾ 

// Approach an object until it's at least 90 pixels tall
while (true) {
  Vision1.takeSnapshot(Vision1__BLUEBOX);

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

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

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

ആക്സസ് 

SensorName.objects[index].originX

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

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

ഉദാഹരണങ്ങൾ 

// Display if an object is to the left or the right
while (true) {
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Vision1.takeSnapshot(Vision1__BLUEBOX);
  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); 
}

.ഒറിജിൻവൈ#

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

ആക്സസ് 

SensorName.objects[index].originY

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

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

ഉദാഹരണങ്ങൾ 

// Display if an object is close or far
while (true) {
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Vision1.takeSnapshot(Vision1__BLUEBOX);
  if (Vision1.objects[0].exists) {
    if (Vision1.objects[0].originY < 80) {
      Brain.Screen.print("Far");
    } else {
      Brain.Screen.print("Close");
    }
  }
  wait(0.5, seconds);
}

.ആംഗിൾ#

.angle കണ്ടെത്തിയ കളർ കോഡിന്റെ ഓറിയന്റേഷൻ നൽകുന്നു.

ആക്സസ് 

SensorName.objects[index].angle

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

കണ്ടെത്തിയ കളർ കോഡിന്റെ ഓറിയന്റേഷൻ ഡിഗ്രികളിൽ പ്രതിനിധീകരിക്കുന്ന double നൽകുന്നു. മൂല്യം 0 മുതൽ 359.9 വരെയാണ്.

ഉദാഹരണങ്ങൾ 

// Turn left or right depending on how a configured
// Color Code is rotated
while (true) {
  Vision1.takeSnapshot(Vision1__BOXCODE);
  if (Vision1.objects[0].exists) {
    double angle = Vision1.objects[0].angle;
    if (70 < angle && angle < 110) {
      Drivetrain.turnFor(right, 45, degrees);
    }
    else if (250 < angle && angle < 290) {
      Drivetrain.turnFor(left, 45, degrees);
    }
    else {
      Drivetrain.stop();
    }
  }
  wait(0.5, seconds);
}
On this page