एआई विज़न#

परिचय #

VEX AIM कोडिंग रोबोट का AI विज़न सेंसर वस्तुओं, रंगों और AprilTag ID का पता लगाता है और उन्हें ट्रैक करता है। इससे रोबोट अपने आसपास के वातावरण का विश्लेषण कर पाता है, वस्तुओं का पीछा कर पाता है और प्राप्त दृश्य डेटा के आधार पर प्रतिक्रिया करता है।

एआई विज़न सेंसर का रिज़ॉल्यूशन 320×240 पिक्सल है। मूल बिंदु (0, 0) ऊपरी-बाएँ कोने में स्थित है, जिससे सेंसर का केंद्र (160, 120) पर स्थित होता है, जैसा कि नीचे दिए गए चित्र में दिखाया गया है:

AIM AI विज़न सेंसर के रिज़ॉल्यूशन को दर्शाने वाला आरेख, जिसमें 0, 0 निर्देशांक आरेख के ऊपरी बाएँ कोने में, 320, 0 ऊपरी दाएँ कोने में, और 0, 240 निचले बाएँ कोने में है, जबकि 160, 120 ठीक केंद्र में है।

नीचे सभी विधियों और गुणों की सूची दी गई है:

कार्य — एआई विज़न कैमरा फ़ीड दिखाएं या छिपाएं।

show_aivision — रोबोट की स्क्रीन पर एआई विज़न फ़ीड प्रदर्शित करता है।
hide_aivision — स्क्रीन से एआई विज़न फ़ीड छुपाता है।
tag_detection — अप्रैलटैग आईडी डिटेक्शन को चालू या बंद करता है।

गेटर्स — यह पता लगाते हैं कि रोबोट ने कोई वस्तु पकड़ी हुई है या नहीं।

get_data — एक विशिष्ट हस्ताक्षर के लिए पता लगाए गए ऑब्जेक्ट्स का एक टपल लौटाता है।
has_sports_ball — यह बताता है कि रोबोट के पास स्पोर्ट्स बॉल है या नहीं।
has_any_barrel — यह बताता है कि रोबोट के पास किसी प्रकार का बैरल है या नहीं।
has_blue_barrel — यह बताता है कि रोबोट के पास नीला बैरल है या नहीं।
has_orange_barrel — यह बताता है कि रोबोट के पास नारंगी रंग का बैरल है या नहीं।

गुणधर्म — get_data से प्राप्त ऑब्जेक्ट डेटा।

exists — क्या वस्तु वर्तमान पहचान में बूलियन के रूप में मौजूद है।
width — पता लगाए गए ऑब्जेक्ट की चौड़ाई।
height — पता लगाई गई वस्तु की ऊंचाई।
centerX — वस्तु के केंद्र की X स्थिति।
centerY — वस्तु के केंद्र की Y स्थिति।
bearing — रोबोट के सामने के सापेक्ष क्षैतिज कोण।
rotation — वस्तु का अभिविन्यास।
originX — वस्तु के शीर्ष-बाएँ कोने की X स्थिति।
originY — वस्तु के शीर्ष-बाएँ कोने की Y स्थिति।
id — वस्तु का वर्गीकरण या टैग आईडी।
score — एआई वर्गीकरण के लिए आत्मविश्वास स्कोर।
type — ऑब्जेक्ट का प्रकार लौटाता है (एआई, टैग, रंग, या कोड)।

कंस्ट्रक्टर — रंग सिग्नेचर और कोड परिभाषित करते हैं।

कलर सिग्नेचर बनाएं — आरजीबी और ह्यू/संतृप्ति श्रेणियों के आधार पर एक नया कलर सिग्नेचर बनाता है।
कलर कोड बनाएं — एकाधिक कलर सिग्नेचर को एक सिंगल कलर कोड में संयोजित करता है।

कार्रवाई #

show_aivision #

show_aivision कमांड रोबोट की स्क्रीन पर AI विज़न सेंसर का लाइव डेटा फीड प्रदर्शित करता है। लाइव डेटा फीड स्क्रीन पर मौजूद किसी भी अन्य छवि या टेक्स्ट को ढक देगा।

नोट: स्क्रीन पर कोई अन्य चित्र या पाठ प्रदर्शित नहीं होगा जब तक कि फ़ीड को छिपाने के लिए hide_aivision का उपयोग नहीं किया जाता है।

Usage:
robot.screen.show_aivision()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

# Watch the AI Vision Sensor detect AI Classifications
# and AprilTag IDs as you move the robot
robot.screen.show_aivision()

hide_aivision #

hide_aivision रोबोट की स्क्रीन से एआई विज़न सेंसर के लाइव डेटा फ़ीड को हटा देता है।

Usage:
robot.screen.hide_aivision()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

# View the AI Vision Sensor's feed for five seconds
robot.screen.show_aivision()
wait(5, SECONDS)
robot.screen.hide_aivision()

tag_detection #

tag_detection अप्रैलटैग आईडी डिटेक्शन को सक्षम या अक्षम करता है, जहां स्थिति एक बूलियन मान है।

यह सेंसर Circle21h7 परिवार के AprilTag ID 0 से 36 तक का पता लगा सकता है।

Usage:
robot.vision.tag_detection(state)

पैरामीटर	विवरण
`state`	मान हैं: `True`, जो अप्रैलटैग आईडी का पता लगाने को सक्षम करता है, या `False`, जो अप्रैलटैग आईडी का पता लगाने को अक्षम करता है।

robot.screen.set_font(PROP30)

# Cut off AprilTag ID detection after 5 seconds
while True:
    if timer.time(SECONDS) > 5:
        robot.vision.tag_detection(False)

    robot.screen.clear_screen()
    robot.screen.set_cursor(3, 1)
    apriltags = robot.vision.get_data(ALL_TAGS)

    if apriltags[0].exists:
        robot.screen.print("AprilTag ID detected!")
    else:
        robot.screen.print("Nothing detected!")

    wait(0.1, SECONDS)

टिककर खेल #

get_data #

get_data एआई विज़न सेंसर फ्रेम से डेटा को एक एकल हस्ताक्षर में फ़िल्टर करता है - सेंसर द्वारा पहचाने जा सकने वाली किसी चीज़ का सहेजा गया विवरण, जैसे कि एक पूर्व-प्रशिक्षित वस्तु, एक अप्रैलटैग आईडी, या एक कॉन्फ़िगर किया गया रंग हस्ताक्षर या रंग कोड - और एक टपल लौटाता है।

रंग हस्ताक्षर और रंग कोड को इस विधि के साथ उपयोग करने से पहले एआई विज़न यूटिलिटी में पहले कॉन्फ़िगर किया जाना चाहिए।

टपल में ऑब्जेक्ट्स को चौड़ाई के अनुसार सबसे बड़े से सबसे छोटे क्रम में, इंडेक्स 0 से शुरू करके, संग्रहित किया जाता है। प्रत्येक ऑब्जेक्ट के गुण को उसके इंडेक्स का उपयोग करके एक्सेस किया जा सकता है। यदि कोई मेल खाने वाले ऑब्जेक्ट्स नहीं मिलते हैं, तो एक खाली टपल लौटाया जाता है।

Usage:
robot.vision.get_data(signature, count)

पैरामीटर	विवरण
`signature`	यह डेटासेट को फ़िल्टर करता है ताकि इसमें केवल दिए गए हस्ताक्षर का डेटा ही शामिल हो। उपलब्ध सिग्नेचर हैं: `ALL_VISION` - स्पोर्ट्स बॉल, बैरल, VEX AIM कोडिंग रोबोट, AprilTag ID, रंग और रंग कोड `ALL_CARGO` - स्पोर्ट्स बॉल और बैरल `ALL_TAGS` - सभी AprilTag ID `ALL_COLORS` - सभी कॉन्फ़िगर किए गए रंग सिग्नेचर और रंग कोड `SPORTS_BALL` - केवल स्पोर्ट्स बॉल `BLUE_BARREL` - केवल नीले बैरल `ORANGE_BARREL` - केवल नारंगी बैरल `AIM_ROBOT` - सभी VEX AIM कोडिंग रोबोट `TAG0` से `TAG37` - एक अप्रैल टैग आईडी 0 से 37 तक `NAME` - रंग हस्ताक्षर या रंग कोड जहां `NAME` एआई विज़न यूटिलिटी में कॉन्फ़िगर किया गया नाम है।
`count`	यह वैकल्पिक है। यह 1 से 24 तक लौटाए जा सकने वाले ऑब्जेक्ट की अधिकतम संख्या निर्धारित करता है (डिफ़ॉल्ट: 8)।

पैरामीटर

विवरण

signature

यह डेटासेट को फ़िल्टर करता है ताकि इसमें केवल दिए गए हस्ताक्षर का डेटा ही शामिल हो। उपलब्ध सिग्नेचर हैं:

ALL_VISION - स्पोर्ट्स बॉल, बैरल, VEX AIM कोडिंग रोबोट, AprilTag ID, रंग और रंग कोड
ALL_CARGO - स्पोर्ट्स बॉल और बैरल
ALL_TAGS - सभी AprilTag ID
ALL_COLORS - सभी कॉन्फ़िगर किए गए रंग सिग्नेचर और रंग कोड
SPORTS_BALL - केवल स्पोर्ट्स बॉल
BLUE_BARREL - केवल नीले बैरल
ORANGE_BARREL - केवल नारंगी बैरल
AIM_ROBOT - सभी VEX AIM कोडिंग रोबोट
TAG0 से TAG37 - एक अप्रैल टैग आईडी 0 से 37 तक
NAME - रंग हस्ताक्षर या रंग कोड जहां NAME एआई विज़न यूटिलिटी में कॉन्फ़िगर किया गया नाम है।

count

यह वैकल्पिक है। यह 1 से 24 तक लौटाए जा सकने वाले ऑब्जेक्ट की अधिकतम संख्या निर्धारित करता है (डिफ़ॉल्ट: 8)।

नोट: अप्रैलटैग आईडी 5 से 37 तक AIM प्रिंट करने योग्य से मुद्रित अप्रैलटैग आईडी का उपयोग करके प्राप्त की जा सकती हैं।

# Move forward if a sports ball is detected
while True:
    ball = robot.vision.get_data(SPORTS_BALL)
    if ball[0].exists:
        robot.move_for(10, 0)
    wait(50, MSEC)

नोट: लौटाए गए टपल को केवल चौड़ाई के आधार पर ही नहीं, बल्कि किसी भी प्रॉपर्टी के आधार पर सॉर्ट किया जा सकता है, इसके लिए Python के sorted फ़ंक्शन का उपयोग किया जाता है। उदाहरण के लिए, अप्रैल टैग आईडी के आधार पर सॉर्ट करना:

# Print each detected AprilTag ID in ascending order by ID
while True:
    apriltags = sorted(robot.vision.get_data(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(robot.vision.get_data(ALL_TAGS), key=lambda tag: tag.height)
    for tag in apriltags_by_height:
        print(tag.height)
    wait(1, SECONDS)

डेटा देखना #

get_data द्वारा लौटाए गए टपल को प्रिंट करने पर सभी पहचाने गए ऑब्जेक्ट्स के सभी गुणों की एक सूची प्रदर्शित होती है:

exists
type
id
centerX
centerY
originX
originY
width
height
bearing
rotation

# Display properties of all detected AprilTag IDs
while True:
    vision_data = robot.vision.get_data(ALL_TAGS)

    if vision_data[0].exists:
        break

    wait(0.25, SECONDS)

print(vision_data)

एआई वर्गीकरण #

AIM AI विज़न सेंसर इन AI वर्गीकरणों का पता लगा सकता है:

आईडी नंबर	एआई वर्गीकरण	हस्ताक्षर
0	गेंद	`SPORTS_BALL`
1	नीला बैरल	`BLUE_BARREL`
2	नारंगी बैरल	`ORANGE_BARREL`
3	एआईएम रोबोट	`AIM_ROBOT`

रंग हस्ताक्षर #

कलर सिग्नेचर एक विशिष्ट रंग होता है जिसे एआई विज़न सेंसर पहचान सकता है। ये सिग्नेचर सेंसर को वस्तुओं को उनके रंग के आधार पर पहचानने और ट्रैक करने में सक्षम बनाते हैं। एक बार कलर सिग्नेचर कॉन्फ़िगर हो जाने पर, सेंसर अपने दृश्य क्षेत्र में उस विशिष्ट रंग वाली वस्तुओं की पहचान कर सकता है। कलर सिग्नेचर का उपयोग get_data के साथ वास्तविक समय में रंगीन वस्तुओं को संसाधित करने और पहचानने के लिए किया जाता है।

# Display if any objects match the Red_Box signature
while True:
    robot.screen.set_cursor(1, 1)
    robot.screen.clear_row(1)
    # Change to any configured Color Signature
    ai_objects = robot.vision.get_data(Red_Box)
    if ai_objects[0].exists:
        robot.screen.print("Color signature detected!")

रंग कोड #

कलर कोड एक संरचित पैटर्न होता है जो 2 से 4 रंगों के संकेतों से मिलकर बना होता है और एक विशिष्ट क्रम में व्यवस्थित होता है। ये कोड एआई विज़न सेंसर को रंगों के पूर्वनिर्धारित पैटर्न को पहचानने में मदद करते हैं। कलर कोड जटिल वस्तुओं की पहचान करने या स्वचालित नेविगेशन के लिए विशिष्ट मार्कर बनाने में उपयोगी होते हैं।

# Display if any objects match the BlueRed code
while True:
    robot.screen.set_cursor(1, 1)
    robot.screen.clear_row(1)
    # Change to any configured Color Code
    ai_objects = robot.vision.get_data(BlueRed)
    if ai_objects[0].exists:
        robot.screen.print("Color code detected!")

has_sports_ball #

has_sports_ball एक बूलियन मान लौटाता है जो यह दर्शाता है कि रोबोट के पास वर्तमान में स्पोर्ट्स बॉल है या नहीं।

True — रोबोट के पास एक स्पोर्ट्स बॉल है।
False — रोबोट के पास स्पोर्ट्स बॉल नहीं है।

Usage:
robot.has_sports_ball()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

# Kick when the robot has a sports ball
while True:
    if robot.has_sports_ball():
        robot.kicker.kick(MEDIUM)

    wait(50, MSEC)

has_any_barrel #

has_any_barrel एक बूलियन मान लौटाता है जो यह दर्शाता है कि रोबोट के पास वर्तमान में किसी भी प्रकार का बैरल है या नहीं।

True — रोबोट के पास एक बैरल है।
False — रोबोट के पास बैरल नहीं है।

Usage:
robot.has_any_barrel()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

# Push a barrel away when detected
while True:
    if robot.has_any_barrel():
        robot.kicker.place()

    wait(50, MSEC)

has_blue_barrel #

has_blue_barrel एक बूलियन मान लौटाता है जो यह दर्शाता है कि रोबोट के पास वर्तमान में एक नीला बैरल है या नहीं।

True — रोबोट का बैरल नीला है।
False — रोबोट के पास नीला बैरल नहीं है।

Usage:
robot.has_blue_barrel()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

# Push a blue barrel away when detected
while True:
    if robot.has_blue_barrel():
        robot.kicker.place()

    wait(50, MSEC)

has_orange_barrel #

has_orange_barrel एक बूलियन मान लौटाता है जो यह दर्शाता है कि रोबोट के पास वर्तमान में एक नारंगी बैरल है या नहीं।

True — रोबोट के पास एक नारंगी रंग का बैरल है।
False — रोबोट के पास नारंगी रंग का बैरल नहीं है।

Usage:
robot.has_orange_barrel()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

# Push an orange barrel away when detected
while True:
    if robot.has_orange_barrel():
        robot.kicker.place()

    wait(50, MSEC)

गुण #

बारह गुण हैं जो robot.vision.get_data विधि का उपयोग करने के बाद टपल में संग्रहीत प्रत्येक ऑब्जेक्ट के साथ शामिल होते हैं।

.id, .scoreऔर .type को छोड़कर सभी प्रॉपर्टी मान, robot.vision.get_data का उपयोग किए जाने के समय पता लगाए गए ऑब्जेक्ट की स्थिति, आकार, अभिविन्यास या दिशा का वर्णन करते हैं। ये मान सेंसर के 320 x 240 पिक्सेल रिज़ॉल्यूशन के आधार पर पिक्सेल या डिग्री में मापे जाते हैं।

.exists #

.exists एक बूलियन लौटाता है जो इंगित करता है कि टपल में इंडेक्स मौजूद है या नहीं।

True — सूचकांक मौजूद है।
False — इंडेक्स मौजूद नहीं है।

# Check if at least two objects are detected
while True:
    robot.screen.clear_screen()
    robot.screen.set_cursor(1, 1)
    ai_objects = robot.vision.get_data(ALL_CARGO)

    if ai_objects[0].exists:
        if ai_objects[1].exists:
            robot.screen.print("At least 2")
        else:
            robot.screen.print("Less than 2")
    wait(0.1, SECONDS)

.width #

.width पिक्सेल में पता लगाए गए ऑब्जेक्ट की चौड़ाई लौटाता है, जो 1 और 320 के बीच एक पूर्णांक है।

नोट: पिक्सेल मान सेंसर के समन्वय प्रणाली के सापेक्ष हैं। संदर्भ के लिए परिचय में दिए गए आरेख को देखें।

फ्रेम के केंद्र में एक नारंगी धारी वाला नीला बैरल है, जो एक काले बाउंडिंग बॉक्स से घिरा हुआ है। फ्रेम के शीर्ष से बाउंडिंग बॉक्स के बाएँ और दाएँ किनारों तक दो ऊर्ध्वाधर लाल डैश वाली रेखाएँ फैली हुई हैं। इन रेखाओं के बीच एक दोहरे सिर वाला काला तीर चौड़ाई माप दर्शाता है।

# Move towards a Blue Barrel until its width is
# larger than 100 pixels
while True:
    barrel = robot.vision.get_data(BLUE_BARREL)

    if barrel[0].exists:
        if barrel[0].width < 100:
            robot.move_at(0)
    else:
        robot.stop_all_movement()

    wait(50, MSEC)

.height #

.height पिक्सेल में पता लगाए गए ऑब्जेक्ट की ऊंचाई लौटाता है, जो 1 और 240 के बीच एक पूर्णांक है।

फ्रेम के केंद्र में एक नारंगी धारी वाला नीला बैरल है, जो एक काले बाउंडिंग बॉक्स से घिरा हुआ है। फ्रेम के बाईं ओर से बाउंडिंग बॉक्स के ऊपरी और किनारों तक दो क्षैतिज लाल डैश वाली रेखाएँ फैली हुई हैं। इन रेखाओं के बीच एक दोहरे सिर वाला काला तीर ऊंचाई माप को दर्शाता है।

# Move towards a Blue Barrel until its height is
# larger than 100 pixels
while True:
    barrel = robot.vision.get_data(BLUE_BARREL)

    if barrel[0].exists:
        if barrel[0].height < 100:
            robot.move_at(0)
    else:
        robot.stop_all_movement()

    wait(50, MSEC)

.centerX #

.centerX पता लगाए गए ऑब्जेक्ट के केंद्र का x-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 320 के बीच एक पूर्णांक है।

एक नीले रंग का बैरल जिस पर नारंगी रंग की पट्टी है, फ्रेम के केंद्र में स्थित है, जो एक काले रंग के बाउंडिंग बॉक्स से घिरा हुआ है। एक ऊर्ध्वाधर लाल रंग की डैश वाली रेखा फ्रेम के शीर्ष से बाउंडिंग बॉक्स के केंद्र तक फैली हुई है, जो केंद्र के X-निर्देशांक को दर्शाती है।

# Turn slowly until a Blue Barrel is centered in
# front of the robot
robot.set_turn_velocity(30)
robot.turn(RIGHT)

while True:
    barrel = robot.vision.get_data(BLUE_BARREL)

    if barrel[0].exists:
        if 140 < barrel[0].centerX < 180:
            robot.stop_all_movement()

    wait(10,MSEC)

.centerY #

.centerY पता लगाए गए ऑब्जेक्ट के केंद्र का y-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 240 के बीच एक पूर्णांक है।

एक नीले रंग का बैरल जिस पर नारंगी रंग की पट्टी है, फ्रेम के केंद्र में स्थित है, जो एक काले रंग के बाउंडिंग बॉक्स से घिरा हुआ है। फ्रेम के बाईं ओर से बाउंडिंग बॉक्स के केंद्र तक एक क्षैतिज लाल रंग की डैश वाली रेखा फैली हुई है, जो केंद्र के Y-निर्देशांक को दर्शाती है।

# Move towards a Blue Barrel until its
# center y-coordinate is more than 140 pixels
while True:
    barrel = robot.vision.get_data(BLUE_BARREL)

    if barrel[0].exists:
        if barrel[0].centerY < 140:
            robot.move_at(0)
    else:
        robot.stop_all_movement()

    wait(50, MSEC)

.bearing #

.bearing एक दशमलव (फ्लोट) लौटाता है जो दर्शाता है कि कोई वस्तु एआई विज़न सेंसर के दृश्य के केंद्र से कितनी दूर (डिग्री में) बाईं या दाईं ओर है। 0 का मान केंद्र में होने का संकेत देता है, धनात्मक मान का अर्थ है कि वस्तु दाईं ओर है, और ऋणात्मक मान का अर्थ है कि वस्तु बाईं ओर है।

ऊपर से नीचे की ओर दर्शाया गया आरेख एक वृत्ताकार आधार के केंद्र में स्थित VEX AIM कोडिंग रोबोट को दर्शाता है, जिसमें एक ऊर्ध्वाधर संदर्भ रेखा और बाईं ओर एक खेल गेंद की ओर झुकी हुई एक लाल रेखा है, जिसे -30 डिग्री के कोण पर अंकित किया गया है।

ऊपर से नीचे की ओर दिखाया गया आरेख एक वृत्ताकार आधार के केंद्र में स्थित VEX AIM कोडिंग रोबोट को दर्शाता है, जिसमें एक ऊर्ध्वाधर संदर्भ रेखा और दाईं ओर एक स्पोर्ट्स बॉल की ओर झुकी हुई एक लाल रेखा है, जिस पर 30 डिग्री का निशान लगा हुआ है।

# Turn to keep the Blue Barrel directly in front
robot.set_turn_velocity(40)
while True:
    vision_data = robot.vision.get_data(BLUE_BARREL)

    if vision_data[0].exists:

        if vision_data[0].bearing > 5:
            robot.turn(RIGHT)
        elif vision_data[0].bearing < -5:
            robot.turn(LEFT)
        else:
            robot.stop_all_movement()

    else:
        robot.stop_all_movement()

    wait(0.1, SECONDS)

.rotation #

.rotation एआई विज़न सेंसर के व्यूइंग प्लेन पर ऑब्जेक्ट का ओरिएंटेशन लौटाता है, जिसे 0 से 359 डिग्री तक मापा जाता है। एक कलर कोड 0° होता है जब उसके रंग एक क्षैतिज रेखा में व्यवस्थित होते हैं (जैसे, लाल-नीला)। यदि रंगों को घुमाया जाता है, तो कोण बदल जाता है (जैसे, नीले-लाल को व्यवस्थित करने पर 180° प्राप्त होता है)।

नीचे दिए गए उदाहरण के लिए, कलर कोड को इस प्रकार कॉन्फ़िगर किया गया है कि बाईं ओर लाल और दाईं ओर नीला रंग है।

इस चित्र में, लाल रंग के ऊपर नीला रंग लगाने का अर्थ है मूल रंग कोड को दाईं ओर 270 डिग्री घुमाना।

# Slide left or right depending on how a Color Code (BlueRed)
# is rotated on the vertical plane
while True:
    # Original Color Code is Red to the left, Blue to the right
    code = robot.vision.get_data(BlueRed)

    if code[0].exists:
        # Check if Color Code is now Red on top of Blue
        if 50 < code[0].rotation < 100 :
            robot.move_at(90)

        # Check if Color Code is now Blue on top of Red
        elif 270 < code[0].rotation < 330 :
            robot.move_at(270)

        else:
            robot.stop_all_movement()
    else:
        robot.stop_all_movement()

    wait(50, MSEC)

.originX #

.originX पता लगाए गए ऑब्जेक्ट के बाउंडिंग बॉक्स के ऊपरी-बाएँ कोने का x-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 320 के बीच एक पूर्णांक है।

एक नीले रंग का बैरल जिस पर नारंगी रंग की पट्टी है, फ्रेम के केंद्र में स्थित है, और एक काले रंग के बाउंडिंग बॉक्स से घिरा हुआ है। फ्रेम के शीर्ष से बाउंडिंग बॉक्स के बाएँ किनारे तक एक ऊर्ध्वाधर लाल रंग की डैश वाली रेखा फैली हुई है, जो बाउंडिंग बॉक्स के मूल बिंदु के X-निर्देशांक को दर्शाती है।

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

    orange_barrel = robot.vision.get_data(ORANGE_BARREL)

    if orange_barrel[0].exists:
        if orange_barrel[0].originX < 160:
            robot.screen.print("To the left!")
        else:
            robot.screen.print("To the right!")

    wait(50, MSEC)

.originY #

.originY पता लगाए गए ऑब्जेक्ट के बाउंडिंग बॉक्स के ऊपरी-बाएँ कोने का y-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 240 के बीच एक पूर्णांक है।

एक नीले रंग का बैरल जिस पर नारंगी रंग की पट्टी है, फ्रेम के केंद्र में स्थित है, जो एक काले रंग के बाउंडिंग बॉक्स से घिरा हुआ है। फ्रेम के बाईं ओर से बाउंडिंग बॉक्स के ऊपरी किनारे तक एक क्षैतिज लाल रंग की डैश वाली रेखा फैली हुई है, जो बाउंडिंग बॉक्स के मूल बिंदु के Y-निर्देशांक को दर्शाती है।

# Display if an Orange Barrel is close or far
# from the robot
while True:
    robot.screen.clear_screen()
    robot.screen.set_cursor(1, 1)

    orange_barrel = robot.vision.get_data(ORANGE_BARREL)

    if orange_barrel[0].exists:
        if orange_barrel[0].originY < 80:
            robot.screen.print("Far")
        else:
            robot.screen.print("Close")

    wait(50, MSEC)

.id #

.id पता लगाए गए एआई वर्गीकरण या अप्रैलटैग आईडी को पूर्णांक के रूप में लौटाता है।

अप्रैलटैग आईडी के लिए, .id प्रॉपर्टी 0 से 37 की सीमा में पता लगाए गए अप्रैलटैग आईडी नंबर को दर्शाती है। एआई वर्गीकरण के लिए, .id प्रॉपर्टी एआई वर्गीकरण अनुभाग में पूर्वनिर्धारित आईडी से मेल खाती है।

# Move forward when AprilTag ID 1 is detected
while True:
    apriltags = robot.vision.get_data(ALL_TAGS)

    if apriltags[0].exists:
        if apriltags[0].id == 1:
            robot.move_at(0)
    else:
        robot.stop_all_movement()

    wait(50, MSEC)

.score #

.score पता लगाए गए एआई वर्गीकरण का आत्मविश्वास स्कोर 1 और 100 के बीच एक पूर्णांक के रूप में लौटाता है।

कम स्कोर का मतलब है कि सेंसर को पता लगाए गए ऑब्जेक्ट के बारे में कम भरोसा है, जबकि उच्च स्कोर का मतलब है कि सेंसर को अधिक भरोसा है।

# Look confident if an Orange Barrel is detected
while True:
    barrel = robot.vision.get_data(ORANGE_BARREL)

    if barrel[0].exists:
        if barrel[0].score > 95:
            robot.screen.show_emoji(CONFIDENT)
        else:
            robot.screen.hide_emoji()

    wait(50, MSEC)

.type #

.type एक पूर्णांक लौटाता है जो पता लगाए गए ऑब्जेक्ट के प्रकार को दर्शाता है। आप इस मान की तुलना टाइप नंबर या संबंधित नाम वाले स्थिरांक का उपयोग करके कर सकते हैं:

ऑब्जेक्ट प्रकार	शामिल वस्तुएँ
`AiVision.AI_OBJECT`	— खेल की गेंदें — नीले बैरल — नारंगी बैरल
`AiVision.TAG_OBJECT`	— अप्रैलटैग आईडी
`AiVision.COLOR_OBJECT`	— रंगीन हस्ताक्षर
`AiVision.CODE_OBJECT`	— रंग कोड

# Display if an AprilTag ID or AI Classification
# is detected
while True:
    robot.screen.clear_screen()
    robot.screen.set_cursor(1, 1)
    vision_data = robot.vision.get_data(ALL_VISION)
    if vision_data[0].exists:
        if vision_data[0].type == AiVision.AI_OBJECT:
            robot.screen.print("AI Object!")
        elif vision_data[0].type == AiVision.TAG_OBJECT:
            robot.screen.print("AprilTag ID!")
    wait(0.1, SECONDS)

# Display a list of all detected objects
while True:
    robot.screen.clear_screen()
    robot.screen.set_cursor(1, 1)
    vision_data = robot.vision.get_data(ALL_VISION)

    if vision_data[0].exists:
        for obj in vision_data:
            if obj.type == AiVision.AI_OBJECT:
                robot.screen.print("- AI Object")
            elif obj.type == AiVision.TAG_OBJECT:
                robot.screen.print("- AprilTag ID")
            robot.screen.next_row()

    wait(0.1, SECONDS)

कंस्ट्रक्टर्स #

Creating a Color Signature #

Colordesc उपयोग करके एक नया कलर सिग्नेचर बनाया जाता है और फिर Colordesc का उपयोग करके AI विज़न सेंसर के साथ पंजीकृत किया जाता है। color_description सेंसर के लिए अधिकतम 7 पता लगाने योग्य कलर सिग्नेचर में से 1 को परिभाषित करता है, लेकिन इसे प्रभावी होने के लिए color_description उपयोग करके स्पष्ट रूप से सेट किया जाना चाहिए।

कलरडेस्क उपयोग:
Colordesc(index, red, green, blue, hangle, hdsat)

पैरामीटर	विवरण
`index`	1 से 7 तक की एक पूर्णांक संख्या जो कलर सिग्नेचर इंडेक्स को दर्शाती है। यदि दो कलर सिग्नेचर एक ही इंडेक्स का उपयोग करते हैं, तो दूसरा पहले वाले को ओवरराइड कर देगा।
`red`	रंग के लाल घटक के लिए 0 से 255 तक का एक पूर्णांक।
`green`	रंग के हरे घटक के लिए 0 से 255 तक का एक पूर्णांक।
`blue`	रंग के नीले घटक के लिए 0 से 255 तक का एक पूर्णांक।
`hangle`	1 से 40 तक का एक फ्लोट मान जो डिग्री में रंग सीमा को दर्शाता है।
`hdsat`	संतृप्ति सीमा को दर्शाने वाला 0.10 से 1.00 तक का एक फ्लोट मान।

रंग_विवरण उपयोग:
robot.vision.color_description(object)

पैरामीटर	विवरण
`object`	`Colordesc` ऑब्जेक्ट को एक पहचान योग्य रंग हस्ताक्षर के रूप में सेट किया जाना है।

# Detect a red object
red_box = Colordesc(1, 207, 19, 25, 10.00, 0.20)
robot.vision.color_description(red_box)

while True:
    robot.screen.clear_screen()
    robot.screen.set_cursor(1, 1)

    red_boxes = robot.vision.get_data(red_box)

    if red_boxes[0].exists:
        robot.screen.print("Red detected!")
    else:
        robot.screen.print("No red detected.")

    wait(0.2, SECONDS)

Creating a Color Code #

Codedesc कंस्ट्रक्टर का उपयोग करके एक नया कलर कोड बनाया जाता है और फिर code_description विधि का उपयोग करके इसे सक्रिय किया जाता है। एक कलर कोड 2 से 4 मौजूदा Colordesc ऑब्जेक्ट्स को एक एकल पहचानकर्ता में समूहित करता है जिसे AI विज़न सेंसर एक अनुक्रम के रूप में पहचान सकता है, लेकिन इसे प्रभावी होने के लिए code_description का उपयोग करके स्पष्ट रूप से सेट किया जाना चाहिए।

कोडडेस्क उपयोग:
Codedesc(index, c1, c2, c3, c4, c5)

पैरामीटर	विवरण
`index`	कलर कोड का इंडेक्स, 1 से 8 तक। नोट: यदि आप एक ही इंडेक्स वाले दो `Codedesc` ऑब्जेक्ट बनाते हैं, तो दूसरा पहले वाले को ओवरराइड कर देगा।
`c1`	कोड में पहला `Colordesc` ऑब्जेक्ट।
`c2`	कोड में दूसरा `Colordesc` ऑब्जेक्ट।
`c3`	वैकल्पिक। एक तीसरा `Colordesc` ऑब्जेक्ट।
`c4`	वैकल्पिक। चौथा `Colordesc` ऑब्जेक्ट।

कोड_विवरण उपयोग:
robot.vision.code_description(object)

पैरामीटर	विवरण
`object`	एक `Codedesc` ऑब्जेक्ट को एक पहचान योग्य रंग कोड के रूप में पंजीकृत करने के लिए।

# Create Color Signatures
red_box = Colordesc(1, 207, 19, 25, 10.00, 0.20)
purple_box = Colordesc(2, 98, 18, 227, 10.00, 0.20)

robot.vision.color_description(red_box)
robot.vision.color_description(purple_box)

# Detect a red_purple Color Code
red_purple = Codedesc(1, red_box, purple_box)
robot.vision.code_description(red_purple)

while True:
    robot.screen.clear_screen()
    robot.screen.set_cursor(1, 1)

    code_objects = robot.vision.get_data(red_purple)

    if code_objects[0].exists:
        robot.screen.print("Code detected!")
    else:
        robot.screen.print("No code detected.")

    wait(0.2, SECONDS)