AI വിഷൻ സെൻസർ#

ആമുഖം#

IQ AI വിഷൻ സെൻസറിന് വസ്തുക്കൾ, നിറങ്ങൾ, AprilTag ഐഡികൾ എന്നിവ കണ്ടെത്താനും ട്രാക്ക് ചെയ്യാനും കഴിയും. ഇത് റോബോട്ടിനെ അതിന്റെ ചുറ്റുപാടുകൾ വിശകലനം ചെയ്യാനും, വസ്തുക്കളെ പിന്തുടരാനും, കണ്ടെത്തിയ ദൃശ്യ ഡാറ്റയെ അടിസ്ഥാനമാക്കി പ്രതികരിക്കാനും അനുവദിക്കുന്നു.

താഴെയുള്ള ഉദാഹരണങ്ങൾക്ക്, കോൺഫിഗർ ചെയ്ത IQ AI വിഷൻ സെൻസറിന് ai_vision_1എന്ന് പേരിടും, കൂടാതെ AiVision ക്ലാസ് രീതികൾ പരാമർശിക്കുമ്പോൾ, RED_BOXപോലുള്ള കോൺഫിഗർ ചെയ്ത കളർ സിഗ്നേച്ചർ ഒബ്‌ജക്റ്റുകൾ ഈ API ഡോക്യുമെന്റേഷനിലുടനീളം തുടർന്നുള്ള എല്ലാ ഉദാഹരണങ്ങളിലും ഉപയോഗിക്കും.

എല്ലാ രീതികളുടെയും ഒരു ലിസ്റ്റ് താഴെ കൊടുക്കുന്നു:

ഗെറ്ററുകൾ — IQ AI വിഷൻ സെൻസറിൽ നിന്ന് ഡാറ്റ നേടുക.

  • take_snapshot — ഒരു പ്രത്യേക ഒപ്പിനായി ഡാറ്റ പിടിച്ചെടുക്കുന്നു.

  • installed — IQ AI വിഷൻ സെൻസർ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന്.

പ്രോപ്പർട്ടികൾ — take_snapshot ൽ നിന്ന് ലഭിച്ച ഒബ്ജക്റ്റ് ഡാറ്റ.

  • .exists — നിലവിലെ ഡിറ്റക്ഷനിൽ വസ്തു നിലവിലുണ്ടോ എന്ന്.

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

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

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

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

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

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

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

  • .id — വസ്തുവിന്റെ വർഗ്ഗീകരണം അല്ലെങ്കിൽ ടാഗ് ഐഡി.

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

കൺസ്ട്രക്റ്റർമാർ — സെൻസറുകൾ സ്വമേധയാ ഇനീഷ്യലൈസ് ചെയ്ത് കോൺഫിഗർ ചെയ്യുക.

  • AiVision — ഒരു ഐക്യു എഐ വിഷൻ സെൻസർ സൃഷ്ടിക്കുന്നു.

  • Colordesc — ഒരു കളർ സിഗ്നേച്ചർ സൃഷ്ടിക്കുന്നു.

  • Codedesc — ഒരു കളർ കോഡ് സൃഷ്ടിക്കുന്നു.

ഗെറ്ററുകൾ#

take_snapshot#

take_snapshot , IQ AI വിഷൻ സെൻസറിന്റെ ഫ്രെയിമിൽ നിന്ന് ഡാറ്റ ഒരു സിംഗിൾ സിഗ്നേച്ചറിലേക്ക് ഫിൽട്ടർ ചെയ്യുന്നു — മുൻകൂട്ടി പരിശീലിപ്പിച്ച ഒബ്‌ജക്റ്റ്, ഒരു AprilTag ID, അല്ലെങ്കിൽ കോൺഫിഗർ ചെയ്‌ത കളർ സിഗ്നേച്ചർ അല്ലെങ്കിൽ കളർ കോഡ് പോലുള്ള സെൻസറിന് തിരിച്ചറിയാൻ കഴിയുന്ന ഒന്നിന്റെ സംരക്ഷിച്ച വിവരണം — കൂടാതെ ഒരു tuple തിരികെ നൽകുന്നു.

കളർ സിഗ്നേച്ചറുകൾ ഉം കളർ കോഡുകൾ ഉം ഈ രീതി ഉപയോഗിച്ച് ഉപയോഗിക്കുന്നതിന് മുമ്പ് വിഷൻ യൂട്ടിലിറ്റിയിൽ ആദ്യം കോൺഫിഗർ ചെയ്യണം.

സൂചിക 0 മുതൽ വീതി അനുസരിച്ച് ഏറ്റവും വലുത് മുതൽ ചെറുത് വരെ ക്രമീകരിച്ച വസ്തുക്കളെ ട്യൂപ്പിൾ സംഭരിക്കുന്നു. ഓരോ വസ്തുവിന്റെയും പ്രോപ്പർട്ടികൾ അതിന്റെ സൂചിക ഉപയോഗിച്ച് ആക്‌സസ് ചെയ്യാൻ കഴിയും. പൊരുത്തപ്പെടുന്ന വസ്തുക്കളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ ഒരു ശൂന്യമായ ട്യൂപ്പിൾ തിരികെ നൽകും.

Usage:
ai_vision_1.take_snapshot(SIGNATURE)

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

വിവരണം

SIGNATURE

നൽകിയിരിക്കുന്ന ഒപ്പിന്റെ ഡാറ്റ മാത്രം ഉൾപ്പെടുത്തുന്നതിനായി ഡാറ്റാസെറ്റ് ഫിൽട്ടർ ചെയ്യുന്നു. ലഭ്യമായ ഒപ്പുകൾ ഇവയാണ്:

  • കളർ സിഗ്നേച്ചറുകൾ അല്ലെങ്കിൽ കളർ കോഡുകൾ - IQ AI വിഷൻ സെൻസറിന്റെ പേര്, രണ്ട് അണ്ടർസ്കോറുകൾ, തുടർന്ന് കളർ സിഗ്നേച്ചറിന്റെയോ കളർ കോഡിന്റെയോ പേര്. ഉദാഹരണത്തിന്: ai_vision_1__RED_BOX.
  • AiVision.ALL_AIOBJS - AI വിഷൻ യൂട്ടിലിറ്റിയിൽ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന മോഡലിനെ ആശ്രയിച്ച് എല്ലാം AI ക്ലാസിഫിക്കേഷനുകൾ കണ്ടെത്തി.
  • AiVision.ALL_TAGS - എല്ലാ AprilTag ഐഡികളും.

count

ഓപ്ഷണൽ. 1 മുതൽ 24 വരെ തിരികെ നൽകാവുന്ന പരമാവധി ഒബ്‌ജക്റ്റുകളുടെ എണ്ണം സജ്ജമാക്കുന്നു (സ്ഥിരസ്ഥിതി: 8).

 
# Move forward if an object is detected
while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)
    if objects[0].exists:
        drivetrain.drive_for(FORWARD, 50, MM)
    wait(50, MSEC)

കുറിപ്പ്: റിട്ടേൺ ചെയ്ത ട്യൂപ്പിൾ, പൈത്തണിന്റെ sorted ഫംഗ്ഷൻ ഉപയോഗിച്ച് വീതി മാത്രമല്ല, ഏതൊരു പ്രോപ്പർട്ടി ഉപയോഗിച്ചും അടുക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, ഏപ്രിൽ ടാഗ് ഐഡി ഉപയോഗിച്ച് അടുക്കുക:

# Print each detected AprilTag ID in ascending order by ID
while True:
    apriltags = sorted(ai_vision_1.take_snapshot(AiVision.ALL_TAGS), key=id)
    for tag in apriltags:
        print(tag.id)
    wait(1, SECONDS)

അല്ലെങ്കിൽ പകരം ഉയരം അനുസരിച്ച് അടുക്കുക:

# Print each detected AprilTag ID in ascending order by height
while True:
    apriltags_by_height = sorted(ai_vision_1.take_snapshot(AiVision.ALL_TAGS), key=lambda tag: tag.height)
    for tag in apriltags_by_height:
        print(tag.height)
    wait(1, SECONDS)

AI വർഗ്ഗീകരണങ്ങൾ#

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

ക്ലാസ് മുറിയിലെ വസ്തുക്കൾ

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

ClassroomElements.BLUE_BALL

1

ClassroomElements.GREEN_BALL

2

ClassroomElements.RED_BALL

3

ClassroomElements.BLUE_RING

4

ClassroomElements.GREEN_RING

5

ClassroomElements.RED_RING

6

ClassroomElements.BLUE_CUBE

7

ClassroomElements.GREEN_CUBE

8

ClassroomElements.RED_CUBE

VEX IQ റോബോട്ടിക്സ് മത്സരം മിക്സ് & മാച്ച്

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

GameElementsMixAndMatch.BEAM

1

GameElementsMixAndMatch.BLUE_PIN

2

GameElementsMixAndMatch.RED_PIN

3

GameElementsMixAndMatch.ORANGE_PIN

VEX IQ റോബോട്ടിക്സ് മത്സര ലെവൽ അപ്പ്

ഐഡി നമ്പർ

AI വർഗ്ഗീകരണം

0

GameElementsLevelUp.BLUE_BEANBAG

1

GameElementsLevelUp.RED_BEANBAG

2

GameElementsLevelUp.YELLOW_BEANBAG

വർണ്ണ ഒപ്പുകൾ#

IQ AI വിഷൻ സെൻസറിന് തിരിച്ചറിയാൻ കഴിയുന്ന ഒരു സവിശേഷ നിറമാണ് കളർ സിഗ്നേച്ചർ. ഈ സിഗ്നേച്ചറുകൾ IQ AI വിഷൻ സെൻസറിനെ അവയുടെ നിറത്തെ അടിസ്ഥാനമാക്കി വസ്തുക്കളെ കണ്ടെത്താനും ട്രാക്ക് ചെയ്യാനും അനുവദിക്കുന്നു. ഒരു കളർ സിഗ്നേച്ചർ കോൺഫിഗർ ചെയ്തുകഴിഞ്ഞാൽ, സെൻസറിന് അതിന്റെ വ്യൂ ഫീൽഡിൽ ആ പ്രത്യേക നിറമുള്ള വസ്തുക്കളെ തിരിച്ചറിയാൻ കഴിയും. നിറമുള്ള വസ്തുക്കളെ തത്സമയം പ്രോസസ്സ് ചെയ്യുന്നതിനും കണ്ടെത്തുന്നതിനും take_snapshot ഉപയോഗിച്ച് കളർ സിഗ്നേച്ചറുകൾ ഉപയോഗിക്കുന്നു.

ഒരു പ്രോജക്റ്റിൽ കോൺഫിഗർ ചെയ്‌ത കളർ സിഗ്നേച്ചർ ഉപയോഗിക്കുന്നതിന്, അതിന്റെ പേര് സെൻസറിന്റെ പേരും, രണ്ട് അണ്ടർസ്കോറുകളും, തുടർന്ന് കളർ സിഗ്നേച്ചറിന്റെ പേരും ആയിരിക്കണം. ഉദാഹരണത്തിന്: ai_vision_1__RED_BOX.

# Display if any objects match the RED_BOX signature
while True:
    brain.screen.set_cursor(1, 1)
    brain.screen.clear_row(1)
    # Change to any configured Color Signature
    red_box = ai_vision_1.take_snapshot(ai_vision_1__RED_BOX)
    if red_box[0].exists:
        brain.screen.print("Color detected!")
        wait(100, MSEC)

കളർ കോഡുകൾ#

ഒരു പ്രത്യേക ക്രമത്തിൽ ക്രമീകരിച്ചിരിക്കുന്ന വർണ്ണ സിഗ്നേച്ചറുകൾ കൊണ്ട് നിർമ്മിച്ച ഒരു ഘടനാപരമായ പാറ്റേണാണ് കളർ കോഡ്. ഈ കോഡുകൾ IQ AI വിഷൻ സെൻസറിനെ മുൻകൂട്ടി നിശ്ചയിച്ച നിറങ്ങളുടെ പാറ്റേണുകൾ തിരിച്ചറിയാൻ അനുവദിക്കുന്നു. സങ്കീർണ്ണമായ വസ്തുക്കളെ തിരിച്ചറിയുന്നതിനോ സ്വയംഭരണ നാവിഗേഷനായി അതുല്യമായ മാർക്കറുകൾ സൃഷ്ടിക്കുന്നതിനോ കളർ കോഡുകൾ ഉപയോഗപ്രദമാണ്.

ഒരു പ്രോജക്റ്റിൽ കോൺഫിഗർ ചെയ്‌ത കളർ കോഡ് ഉപയോഗിക്കുന്നതിന്, അതിന്റെ പേര് സെൻസറിന്റെ പേരും, രണ്ട് അണ്ടർസ്കോറുകളും, തുടർന്ന് കളർ കോഡിന്റെ പേരും ആയിരിക്കണം. ഉദാഹരണത്തിന്: ai_vision_1__BOX_CODE.

# Display if any objects match the BOX_CODE code
while True:
    brain.screen.set_cursor(1, 1)
    brain.screen.clear_row(1)
    # Change to any configured Color Code
    box_code = ai_vision_1.take_snapshot(ai_vision_1__BOX_CODE)
    if box_code[0].exists:
        brain.screen.print("Code detected!")
        wait(100, MSEC)

installed#

installed IQ AI വിഷൻ സെൻസർ നിലവിൽ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.

  • True — IQ AI വിഷൻ സെൻസർ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.

  • False — IQ AI വിഷൻ സെൻസർ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.

Usage:
ai_vision_1.installed()

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

വിവരണം

ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

 
# Display a message if the AI Vision Sensor is connected
if ai_vision_1.installed():
    brain.screen.print("Installed!")

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

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

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

.exists#

ട്യൂപ്പിളിൽ സൂചിക നിലവിലുണ്ടോ ഇല്ലയോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ .exists നൽകുന്നു.

  • True — സൂചിക നിലവിലുണ്ട്.

  • False — സൂചിക നിലവിലില്ല.

# Check if at least two objects are detected
while True:
    brain.screen.clear_screen()
    brain.screen.set_cursor(1, 1)
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if objects[1].exists:
            brain.screen.print("At least 2")

        else:
            brain.screen.print("Less than 2")
    wait(50, MSEC)

.width#

.width കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി പിക്സലുകളിൽ നൽകുന്നു, ഇത് 1 നും 320 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Approach an object until it's at least 100 pixels wide
while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if objects[0].width < 100:
            drivetrain.drive(FORWARD)
    else:
        drivetrain.stop()
    wait(50, MSEC)

.height#

.height കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ നൽകുന്നു, ഇത് 1 നും 240 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Approach an object until it's at least 90 pixels tall
while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if objects[0].height < 90:
            drivetrain.drive(FORWARD)
    else:
        drivetrain.stop()
    wait(50, MSEC)

.centerX#

.centerX കണ്ടെത്തിയ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ x-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 320 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Turn until an object is directly in front of the sensor
drivetrain.set_turn_velocity(10, PERCENT)
drivetrain.turn(RIGHT)

while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if 140 < objects[0].centerX < 180:
            drivetrain.stop()
    wait(10,MSEC)

.centerY#

.centerY കണ്ടെത്തിയ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ y-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 240 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Approach an object until the object's center is
# high enough in the field of view
while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if objects[0].centerY < 150:
            drivetrain.drive(FORWARD)
    else:
        drivetrain.stop()
    wait(50, MSEC)

.angle#

.angle കണ്ടെത്തിയ കളർ കോഡിന്റെയോ ഏപ്രിൽ ടാഗ് ഐഡിയുടെയോ ഓറിയന്റേഷൻ ഡിഗ്രികളിൽ നൽകുന്നു, ഇത് 0 നും 359 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Turn left or right depending on how a
# configured Color Code is rotated
while True:
    box_code = ai_vision_1.take_snapshot(ai_vision_1__BOX_CODE)

    if box_code[0].exists:
        if 50 < box_code[0].angle < 100:
            drivetrain.turn(RIGHT)

        elif 270 < box_code[0].angle < 330:
            drivetrain.turn(LEFT)

        else:
            drivetrain.stop()
    else:
        drivetrain.stop()
    wait(50, MSEC)

.originX#

.originX കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള x-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 320 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Display if an object is to the left or the right
while True:
    brain.screen.clear_screen()
    brain.screen.set_cursor(1,1)

    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if 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#

.originY കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള y-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 240 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

# Display if an object is close or far
while True:
    brain.screen.clear_screen()
    brain.screen.set_cursor(1,1)

    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)

    if objects[0].exists:
        if objects[0].originY < 110:
            brain.screen.print("Close")
        else:
            brain.screen.print("Far")

.id#

.id കണ്ടെത്തിയ AI ക്ലാസിഫിക്കേഷൻ അല്ലെങ്കിൽ ഏപ്രിൽ ടാഗ് ഐഡിയുടെ ഐഡി ഒരു പൂർണ്ണസംഖ്യയായി നൽകുന്നു. AI വിഷൻ യൂട്ടിലിറ്റിയിൽ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന മോഡലിനെ ആശ്രയിച്ചിരിക്കും AI ക്ലാസിഫിക്കേഷനുകൾ.

ഒരു AprilTag ഐഡിക്ക്, 0 മുതൽ 36 വരെയുള്ള ശ്രേണിയിലുള്ള കണ്ടെത്തിയ AprilTag ഐഡി നമ്പറിനെ .id പ്രോപ്പർട്ടി പ്രതിനിധീകരിക്കുന്നു. ഒരു AI ക്ലാസിഫിക്കേഷന്, .id പ്രോപ്പർട്ടി AI ക്ലാസിഫിക്കേഷനുകൾ വിഭാഗത്തിലെ മുൻനിർവചിച്ച ഐഡിയുമായി യോജിക്കുന്നു.

# Move forward when AprilTag ID 1 is detected
while True:
    apriltags = ai_vision_1.take_snapshot(AiVision.ALL_TAGS)

    if apriltags[0].exists:
        if apriltags[0].id == 1:
            robot.drive(FORWARD)
    else:
        drivetrain.stop()

    wait(50, MSEC)

.score#

.score കണ്ടെത്തിയ AI വർഗ്ഗീകരണത്തിന്റെ കോൺഫിഡൻസ് സ്കോർ 1 നും 100 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയായി നൽകുന്നു.

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

# Display if a score is confident
while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)
    brain.screen.clear_screen()
    brain.screen.set_cursor(1, 1)
    if objects[0].exists:
        if objects[0].score > 95:
            brain.screen.print("Confident")
    else:
        brain.screen.print("Not confident")

    wait(50, MSEC)

കൺസ്ട്രക്‌ടർമാർ#

കൺസ്ട്രക്‌ടറുകൾ ഉപയോഗിച്ച് AiVision, Colordesc, Codedesc ഒബ്‌ജക്റ്റുകൾ സ്വമേധയാ സൃഷ്ടിക്കാൻ കഴിയും, ഇവ VEXcode-ന് പുറത്ത് IQ AI വിഷൻ സെൻസർ കോൺഫിഗർ ചെയ്യുന്നതിന് ആവശ്യമാണ്.

AI Vision Sensor#

AiVision ഒരു ഐക്യു എഐ വിഷൻ സെൻസർ സൃഷ്ടിക്കുന്നു.

ഉപയോഗം

Vision(port, sigs)

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

വിവരണം

port

1 മുതൽ 12 വരെയുള്ള ഏത് സ്മാർട്ട് പോർട്ടിലേക്കാണ് IQ AI വിഷൻ സെൻസർ ബന്ധിപ്പിച്ചിരിക്കുന്നത്?

sigs

ഓപ്ഷണൽ. ഒന്നോ അതിലധികമോ ഒപ്പുകളുടെ പേര്:

ഉദാഹരണം

ai_vision_1 = AiVision(Ports.PORT1, AiVision.ALL_AIOBJS)

# Move forward if an object is detected
while True:
    objects = ai_vision_1.take_snapshot(AiVision.ALL_AIOBJS)
    if objects[0].exists:
        drivetrain.drive_for(FORWARD, 50, MM)
    wait(50, MSEC)

Color Signature#

Colordesc ഒരു കളർ സിഗ്നേച്ചർ സൃഷ്ടിക്കുന്നു. ഒരു IQ AI വിഷൻ സെൻസറിൽ ഒരേസമയം ഏഴ് വ്യത്യസ്ത കളർ സിഗ്നേച്ചറുകൾ വരെ സംഭരിക്കാൻ കഴിയും.

ഉപയോഗം:

Colordesc(index, uMin, uMax, uMean, vMin, vMax, vMean, rgb, type)

പാരാമീറ്റർ

വിവരണം

index

Colordesc ഒബ്ജക്റ്റിന്റെ സൂചിക, 1 മുതൽ 7 വരെ. കുറിപ്പ്: ഒരേ സൂചിക നമ്പറുള്ള രണ്ട് Colordesc ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നത് രണ്ടാമത്തെ സൃഷ്ടിച്ച ഒബ്ജക്റ്റ് ആദ്യത്തേതിനെ മറികടക്കാൻ കാരണമാകും.

uMin

വിഷൻ യൂട്ടിലിറ്റിയിൽ uMin ൽ നിന്നുള്ള മൂല്യം.

uMax

വിഷൻ യൂട്ടിലിറ്റിയിലെ uMax ൽ നിന്നുള്ള മൂല്യം.

uMean

വിഷൻ യൂട്ടിലിറ്റിയിൽ uMean ൽ നിന്നുള്ള മൂല്യം.

vMin

വിഷൻ യൂട്ടിലിറ്റിയിൽ vMin ൽ നിന്നുള്ള മൂല്യം.

vMax

വിഷൻ യൂട്ടിലിറ്റിയിൽ vMax ൽ നിന്നുള്ള മൂല്യം.

vMean

വിഷൻ യൂട്ടിലിറ്റിയിൽ vMean ൽ നിന്നുള്ള മൂല്യം.

rgb

വിഷൻ യൂട്ടിലിറ്റിയിൽ rgb ൽ നിന്നുള്ള മൂല്യം.

type

വിഷൻ യൂട്ടിലിറ്റിയിൽ type ൽ നിന്നുള്ള മൂല്യം.

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

ഉദാഹരണം

# Create a new Signature RED_BOX with the Colordesc class
RED_BOX = Colordesc(1, 10121, 10757, 10439,-1657, -1223, -1440,2.5, 1)
# Create a new AI Vision Sensor "ai_vision_1" with the AiVision
# class, with the RED_BOX Signature.
ai_vision_1 = AiVision(Ports.PORT1, 100, RED_BOX)

# Move forward if a red object is detected
while True:
    red_object = ai_vision_1.take_snapshot(RED_BOX)
    if red_object[0].exists:
        drivetrain.drive_for(FORWARD, 10, MM)
    wait(5, MSEC)

Color Code#

Codedesc ഒരു കളർ കോഡ് സൃഷ്ടിക്കുന്നു. ഇത് ഉപയോഗിക്കുന്നതിന് കുറഞ്ഞത് രണ്ട് നിർവചിക്കപ്പെട്ട കളർ സിഗ്നേച്ചറുകൾ ആവശ്യമാണ്. ഒരു വിഷൻ സെൻസറിൽ ഒരേസമയം എട്ട് വ്യത്യസ്ത കളർ കോഡുകൾ വരെ സംഭരിക്കാൻ കഴിയും.

ഉപയോഗം:

Codedesc(sig1, sig2, sig3, sig4, sig5)

പാരാമീറ്റർ

വിവരണം

sig1

മുമ്പ് സൃഷ്ടിച്ച ഒരു കളർ സിഗ്നേച്ചർ.

sig2

മുമ്പ് സൃഷ്ടിച്ച ഒരു കളർ സിഗ്നേച്ചർ.

sig3

ഓപ്ഷണൽ. മുമ്പ് സൃഷ്ടിച്ച കളർ സിഗ്നേച്ചർ.

sig4

ഓപ്ഷണൽ. മുമ്പ് സൃഷ്ടിച്ച കളർ സിഗ്നേച്ചർ.

sig5

ഓപ്ഷണൽ. മുമ്പ് സൃഷ്ടിച്ച കളർ സിഗ്നേച്ചർ.

ഉദാഹരണം

# Create two new Signatures for a red and blue box
RED_BOX = Colordesc(1, 10121, 10757, 10439,-1657, -1223, -1440, 2.5, 1)
BLUE_BOX = Colordesc(2, -4443, -3373, -3908,6253, 7741, 6997, 2.5, 1)
# Create a Color Code for a red box to the left of a blue box
RED_BLUE = Codedesc(RED_BOX, BLUE_BOX)
# Create a new AI Vision Sensor "ai_vision_1" with the AiVision
# class, with the RED_BOX and BLUE_BOX Signatures.
ai_vision_1 = AiVision(Ports.PORT1, RED_BOX, BLUE_BOX)

# Display a message if Color Code is detected
while True:
    brain.screen.set_cursor(1, 1)
    brain.screen.clear_row(1)
    # Change to any configured Color Code
    box_code = ai_vision_1.take_snapshot(RED_BLUE)
    if box_code[0].exists:
        brain.screen.print("Code detected!")
        wait(100, MSEC)
On this page