VisionEye-Ansicht zur Objektzuordnung mit Ultralytics YOLO26
Was ist die VisionEye-Objektzuordnung?#
VisionEye von Ultralytics YOLO26 ermöglicht es Computern, Objekte zu erkennen und zu lokalisieren, und ahmt dabei die Beobachtungsgenauigkeit des menschlichen Auges nach. Diese Funktion ermöglicht es Computern, bestimmte Objekte zu erkennen und sich darauf zu konzentrieren – ähnlich wie das menschliche Auge Details aus einem bestimmten Blickwinkel wahrnimmt.
Objekte mit YOLO26 zuordnen#
VisionEye legt einen einzelnen Beobachtungspunkt im Bild fest und zeichnet von dort aus einen Strahl zu jedem verfolgten Objekt. So kannst du visualisieren, wie eine Szene aus einer bestimmten Perspektive aussieht. Lege vision_point auf die Pixelkoordinaten des Beobachters fest und führe die Lösung anschließend mit der Python-API oder der CLI über dein Video aus.
# Monitor objects position with visioneye
yolo solutions visioneye show=True
# Pass a source video
yolo solutions visioneye source="path/to/video.mp4"
# Monitor the specific classes
yolo solutions visioneye classes="[0, 5]"Argumente für VisionEye#
Hier ist eine Tabelle mit den Argumenten für VisionEye:
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
model | str | None | Pfad zu einer Ultralytics-YOLO-Modelldatei. |
vision_point | tuple[int, int] | (20, 20) | Der Punkt, an dem VisionEye Objekte verfolgt und mithilfe der VisionEye-Lösung Pfade zeichnet. |
line_width | int | 2 | Linienstärke für die Boxen, Keypoints und Zählwerte, die von der Lösung eingezeichnet werden. |
verbose | bool | True | Aktiviert das Protokoll der Lösung für jedes Bild, das Eingabeform, Klassenanzahlen und Verarbeitungsgeschwindigkeit enthält. Der Tracking-Aufruf selbst gibt grundsätzlich keine Meldungen aus. |
Du kannst in der Lösung VisionEye auch verschiedene Argumente für track verwenden:
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
tracker | str | 'tracktrack.yaml' | Legt den zu verwendenden Verfolgungsalgorithmus fest. Integrierte Optionen: botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml. |
conf | float | 0.25 | Legt den Konfidenzschwellenwert für Erkennungen fest. Niedrigere Werte ermöglichen die Verfolgung weiterer Objekte, können aber auch falsch positive Ergebnisse einschließen. |
iou | float | 0.5 | Legt den Schwellenwert für die Schnittmenge über Vereinigung (IoU) fest, um überlappende Erkennungen herauszufiltern. |
classes | list | None | Filtert die Ergebnisse nach Klassenindex. Beispielsweise verfolgt classes=[0, 2, 3] nur die angegebenen Klassen. |
device | str | None | Legt das Gerät für die Inferenz fest (z. B. cpu, cuda:0 oder 0). So kannst du für die Modellausführung zwischen CPU, einer bestimmten GPU oder anderen Rechengeräten wählen. |
imgsz | int or tuple | 640 | Zielbildgröße für die Inferenz: eine Ganzzahl für ein quadratisches Bild oder ein (height, width)-Paar. Die Formen werden an den Modellschritt angepasst. |
max_det | int | 300 | Maximale Anzahl der Erkennungen, die pro Bild vor der Verfolgung beibehalten werden. Dadurch wird die Anzahl der Objekte begrenzt, die eine Lösung in dichten Szenen verarbeitet. |
quantize | int or str | None | Inferenzpräzision: 16 (FP16) oder 32/unset (FP32) für PyTorch- und TorchScript-Modelle außerhalb der CPU; andere Formate verwenden die Präzision, die ihr Artefakt und ihre Laufzeitumgebung vorgeben. Ersetzt das veraltete Argument half. |
Außerdem werden einige Argumente zur Visualisierung unterstützt, wie unten aufgeführt:
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
show | bool | False | Wenn True aktiviert ist, werden die annotierten Bilder oder Videos in einem Fenster angezeigt. Nützlich für unmittelbares visuelles Feedback während der Entwicklung oder beim Testen. |
show_conf | bool | True | Zeigt neben der Bezeichnung den Konfidenzwert jeder Erkennung an. Gibt Aufschluss darüber, wie sicher sich das Modell bei der jeweiligen Erkennung ist. |
show_labels | bool | True | Zeigt für jede Erkennung eine Bezeichnung in der visuellen Ausgabe an. So lassen sich erkannte Objekte sofort erkennen. |
So funktioniert VisionEye#
VisionEye legt einen festen Blickpunkt im Bild fest und zeichnet Linien von diesem Punkt zu den erkannten Objekten. Damit wird nachgeahmt, wie das menschliche Auge mehrere Objekte aus einer einzigen Perspektive betrachtet. Die Lösung nutzt Objektverfolgung, um Objekte über mehrere Bilder hinweg zuverlässig wiederzuerkennen. So entsteht eine visuelle Darstellung der räumlichen Beziehung zwischen dem Beobachter (Blickpunkt) und den Objekten in der Szene.
Die Methode process der VisionEye-Klasse führt mehrere wichtige Schritte aus:
- Extrahiert Tracks (Begrenzungsrahmen, Klassen und Track-IDs) aus dem Eingabebild
- Erstellt einen Annotator zum Zeichnen von Begrenzungsrahmen und Beschriftungen
- Zeichnet für jedes erkannte Objekt eine Beschriftung am Rahmen und eine Sichtlinie vom Blickpunkt aus
- Gibt das annotierte Bild mit Verfolgungsstatistiken zurück
Dieser Ansatz eignet sich besonders für Anwendungen, die räumliches Bewusstsein und die Visualisierung von Objektbeziehungen erfordern, etwa Überwachungssysteme, autonome Navigation und interaktive Installationen.
Anwendungsbereiche von VisionEye#
Die VisionEye-Objektzuordnung bietet zahlreiche praktische Anwendungsmöglichkeiten in verschiedenen Branchen:
- Sicherheit und Überwachung: Mehrere interessante Objekte von einer festen Kameraposition aus überwachen
- Einzelhandelsanalysen: Bewegungsmuster von Kunden im Verhältnis zu den Ladenauslagen verfolgen
- Sportanalyse: Positionierung und Bewegung von Spielern aus der Sicht eines Trainers analysieren
- Autonome Fahrzeuge: Visualisieren, wie ein Fahrzeug Objekte in seiner Umgebung „sieht“ und priorisiert
- Mensch-Computer-Interaktion: Intuitivere Schnittstellen erstellen, die auf räumliche Beziehungen reagieren
Wenn du VisionEye mit anderen Ultralytics-Lösungen wie der Distanzberechnung oder der Geschwindigkeitsschätzung kombinierst, kannst du umfassende Systeme erstellen, die Objekte nicht nur verfolgen, sondern auch ihre räumlichen Beziehungen und ihr Verhalten erfassen.
Häufig gestellte Fragen#
Um VisionEye Object Mapping mit Ultralytics YOLO26 zu verwenden, installiere zunächst das Ultralytics-Paket mit pip. Anschließend kannst du den Beispielsode aus der Dokumentation verwenden, um die Objekterkennung mit VisionEye einzurichten. Hier ist ein einfaches Beispiel für den Einstieg:
import cv2 from ultralytics import solutions cap = cv2.VideoCapture("path/to/video.mp4") assert cap.isOpened(), "Error reading video file" # Video-Writer w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS)) video_writer = cv2.VideoWriter("vision-eye-mapping.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h)) # VisionEye-Objekt initialisieren visioneye = solutions.VisionEye( show=True, # # Ausgabe anzeigen model="yolo26n.pt", # Verwende ein beliebiges von Ultralytics unterstütztes Modell, z. B. yolo26s.pt classes=[0, 2], # VisionEye-Ansicht für bestimmte Klassen erzeugen ) # Video verarbeiten while cap.isOpened(): success, im0 = cap.read() if not success: print("Video frame is empty or video processing has been successfully completed.") break results = visioneye(im0) print(results) # auf die Ausgabe zugreifen video_writer.write(results.plot_im) # Videodatei schreiben cap.release() video_writer.release() cv2.destroyAllWindows() # Alle geöffneten Fenster schließenUltralytics YOLO26 vereint Geschwindigkeit, Genauigkeit und einfache Integration und eignet sich dadurch besonders gut für die Objektzuordnung und -verfolgung. Zu den wichtigsten Vorteilen gehören:
- Echtzeitleistung: Bietet eine hohe Genauigkeit bei der Objekterkennung in Echtzeit.
- Flexibilität: Unterstützt Erkennung, Verfolgung und Distanzberechnung in einer einzigen Verarbeitungskette.
- Community und Support: Umfassende Dokumentation und eine aktive GitHub-Community helfen bei der Fehlerbehebung und Weiterentwicklung.
- Einfache Anwendung: Die intuitive API vereinfacht komplexe Aufgaben und ermöglicht eine schnelle Bereitstellung und Weiterentwicklung.
Weitere Informationen zu Anwendungsbereichen und Vorteilen findest du in der Ultralytics-YOLO26-Dokumentation.
Ultralytics YOLO26 lässt sich für Machine Learning, Experimentverfolgung, Zusammenarbeit und Reproduzierbarkeit in verschiedene Tools wie Comet und ClearML integrieren. Folge den ausführlichen Anleitungen zur Integration von YOLO26 mit Comet und zur Integration von YOLO26 mit ClearML, um loszulegen.
Weitere Beispiele zur Erkundung und Integration findest du in unserem Leitfaden zu Ultralytics-Integrationen.
Kommentare60
Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.
TranDHoa
Hey, you can adjust the viewing angle of the eyes and make it measure the distance from the center of an object instead of from the edge.
Glenn JocherUltralyticsVisionEye already draws the ray from
vision_pointto the bounding-box centroid (not the edge) viaSolutionAnnotator.visioneye()as shown in the VisionEye guide and the SolutionAnnotatorvisioneye()reference; there isn’t a separate “viewing angle” parameter today since it’s a 2D overlay, so the intended control is movingvision_point, and if you need an actual distance value (vs just a line), please use the Distance Calculation solution and share your desired behavior here (plus a short clip/frame +vision_point) so the team can advise the cleanest extension.
dixroby
What dependencies are included in the requirements.txt file?
Glenn JocherUltralytics@dixroby the
requirements.txtfile typically includes dependencies liketorch,opencv-python, and other libraries necessary for running Ultralytics YOLO models. For a detailed list, please check the file directly in the repository.
FarrelCulbert
Hi, I would like to know if this is only compatible with YOLOv8, or can I use it with all models?
Glenn JocherUltralytics(bearbeitet)@FarrelCulbert VisionEye Object Mapping is not limited to YOLOv8: it works with the tracking-capable Ultralytics models you pass via
model=, including YOLO26 (recommended) and YOLO11. For more detailed information and examples, you can refer to the VisionEye documentation at https://docs.ultralytics.com/guides/vision-eye/.
skp4595
rather than taking video as input fro testing, I want to test for an image, how can I do that? guide me on this.
Glenn JocherUltralytics(bearbeitet)Hi there!
Great question! If you want to test an image instead of a video using Ultralytics YOLO, it's quite straightforward. Below is a simple example to guide you through the process:
Testing on an Image
First, ensure you have the latest versions of
torchandultralyticsinstalled. If not, please update them:pip install --upgrade torch ultralyticsNext, you can use the following code to test an image:
import cv2 from ultralytics import YOLO from ultralytics.utils.plotting import Annotator, colors # Load the model model = YOLO("yolo26n.pt") # Load the image image_path = "path/to/your/image.jpg" im0 = cv2.imread(image_path) # Perform prediction results = model.predict(im0) boxes = results[0].boxes.xyxy.cpu() clss = results[0].boxes.cls.cpu().tolist() # Annotate the image annotator = Annotator(im0, line_width=2) names = model.model.names for box, cls in zip(boxes, clss): annotator.box_label(box, label=names[int(cls)], color=colors(int(cls))) # Display the annotated image cv2.imshow("YOLO Image Prediction", im0) cv2.waitKey(0) cv2.destroyAllWindows()Explanation
- Load the Model: We load the YOLO model.
- Load the Image: Read the image using OpenCV.
- Perform Prediction: Use the model to predict objects in the image.
- Annotate the Image: Draw bounding boxes and labels on the image.
- Display the Image: Show the annotated image using OpenCV.
This should help you get started with testing images. If you encounter any issues or have further questions, feel free to ask! 😊
For more detailed information, you can refer to the VisionEye Object Mapping Guide.
Happy coding! 🚀
skp4595
I want to run VisionEye Object Mapping using YOLOv8 code on KITTI data set. the KITTI dataset is labeled as <class_name1, truncation, occlusion, observation angle alpha, bbox cordinantes, Dimension of object, Location, rotation_y, score > for each image. While model training, I'm getting this error train: WARNING ⚠️ /content/dataset/train/images/005936.png: ignoring corrupt image/label: could not convert string to float: 'Car' train: WARNING ⚠️ /content/dataset/train/images/005937.png: ignoring corrupt image/label: could not convert string to float: 'Pedestrian' train: WARNING ⚠️ /content/dataset/train/images/005938.png: ignoring corrupt image/label: could not convert string to float: 'Truck'
with these args { EPOCHS = 5 !yolo
task=detect
mode=train
model=yolov8s.pt
imgsz=640
data=depth_estimation_using_YOLOv8.yaml
epochs={EPOCHS}
batch=16
name=yolov8s
exist_ok=True
amp=False } how do I fix this?skp4595
how is this model trained? some details on dataset would be great help
Paula DerrengerUltralytics(bearbeitet)Hi! The model is trained using the YOLOv8 framework. You can train it on custom datasets like KITTI by converting the dataset to the YOLO format. The dataset should have labels in the format
<class_id> <x_center> <y_center> <width> <height>.For more details on VisionEye Object Mapping, check out the Ultralytics VisionEye guide. If you have any specific questions, feel free to ask! 🚀
Here's a sample training command:
yolo task=detect mode=train model=yolo26s.pt data=your_dataset.yaml epochs=5 batch=16Happy training! 😊
1
skp4595
what does this mean "It calculates this distance by analyzing the size and position of the object within the frame, using the camera's field of view and other calibration parameters if available"? what do you mean by 'other calibration parameter if possible'? The model is not a blackbox. Is it? there must be some calibration, some ground truth from where model must have learned. please explain this.
Glenn JocherUltralytics(bearbeitet)Hello! Great questions about the VisionEye Object Mapping using Ultralytics YOLOv8.
-
Distance Calculation: The phrase "It calculates this distance by analyzing the size and position of the object within the frame, using the camera's field of view and other calibration parameters if available" was inaccurate. The VisionEye distance example does not estimate camera-to-object distance from object size or field of view. It computes the pixel distance between the vision point and the bounding-box centroid and divides it by the
pixel_per_metervalue you set, so you calibrate that scale yourself. -
Other Calibration Parameters: The example uses none of these. You would need data such as camera intrinsic parameters (focal length, optical centers), extrinsic parameters (orientation and position of the camera), object size references, or a depth sensor only if you build a true camera-to-object distance estimate yourself.
-
Model Transparency: YOLOv8 models are not black boxes in the sense that their architecture and training processes are open for examination and modification. They learn from labeled data (ground truth) where objects are manually annotated in images, teaching the model how to recognize similar objects in new images.
For further details or specific implementations, feel free to check out our guide on VisionEye Object Mapping at Ultralytics VisionEye Guide. If you have more questions or need clarification, don't hesitate to reach out! 😊
-
mirhasnainsiba
i am getting version incompatiblity issues, tell me your system's python version
Paula DerrengerUltralytics(bearbeitet)Hey there! 😊 It sounds like you're encountering some version compatibility issues. For Ultralytics YOLOv8, we generally recommend using Python 3.8 or newer as it strikes a good balance between being up-to-date and maintaining compatibility with most dependencies.
If you're using a Python version older than 3.7, you might run into issues, and it's a good idea to update to at least version 3.7 or newer if possible. Here's a quick way to check your current Python version from your terminal:
python --version # or if you have Python 3 installed as 'python3' python3 --versionAnd if you need to update Python, the official Python Downloads page is a great place to start.
If you're still facing issues after checking your Python version, could you please provide more details about the error messages you're seeing? This information can help us pinpoint the problem more accurately. Thanks!
mirhasnainsiba
it is telling distance 61m while object is almost 1 m far
Paula DerrengerUltralytics@mirhasnainsiba hi there! 👋 It seems there might be a discrepancy with the distance calculation in your setup. Typically, the distance calculated by the model would depend on the scale set in your system (for example,
pixel_per_meterin the example). If the object is being reported as 61m away while it's actually about 1m away, you might want to adjust this scale factor accordingly. Here's a brief example:pixel_per_meter = 100 # Adjust this value based on your actual scaleThis adjustment helps calibrate the distance calculation to more accurately reflect real-world distances. If you continue to experience issues, double-check the calibration process or consider revisiting the portion of your code responsible for calculating distances. If further assistance is needed, feel free to reach out! 🛠️
mirhasnainsiba
thanks
Paula DerrengerUltralyticsHey there! 😊 Thanks for reaching out. If you're observing an object distance as 61m while it's almost 1m away, you might want to adjust the
pixel_per_meterscaling factor in your VisionEye implementation. This adjustment is crucial for accurate distance calculation.Here's a simplified approach:
pixel_per_meter = 100 # This is just an example value. # You'll need to calibrate this based on your specific setup and camera properties.By fine-tuning this variable, you can achieve more accurate distance measurements. Calibration involves comparing known distances with the pixel distances detected by your model to find the most suitable
pixel_per_metervalue. 🛠️Hope this helps! Let us know if you have any further questions or if there are more details you'd like to dive into.
magickoo
where is the dataset(video file)?
Paula DerrengerUltralyticsHey there! 🌟
The video files used in our examples are not provided in the repository. You can use any video file that you have access to by placing it in an accessible directory and then modifying the
"path/to/video/file.mp4"placeholder in the code snippets to point to your video file's location.For example:
cap = cv2.VideoCapture("your/video/path/here.mp4")Just replace
"your/video/path/here.mp4"with the actual path to your video. If you're looking for sample videos, online resources like Pexels Video or Pixabay Videos offer free footage that you might find useful for your projects.If you have any more questions or need further assistance, don't hesitate to reach out. Happy coding! 🚀
1magickoo
Okay thankyou!
Paula DerrengerUltralyticsHey! Thank you for checking out the VisionEye Object Mapping with Ultralytics YOLOv8. 🚀 If you're keen to dive into VisionEye Object Mapping for pinpoint precision or even integrate object tracking and distance calculation, the provided Python examples can guide you seamlessly through the process.
Just remember to replace
"path/to/video/file.mp4"with the specific path to your video file, and you’re all set to explore the amazing capabilities of YOLOv8 with VisionEye!For pinpoint object mapping:
model = YOLO("yolov8n.pt") # Adjust model as needed cap = cv2.VideoCapture("your/video/path.mp4") # Your video path hereFor any additional queries or discussions, feel free to drop a message in our GitHub Issue Section. Happy coding! 🎉
AdadAlShabab
Hi, I just wanted to know about "VisionEye View with Distance". What does this 'Distance' means? I mean does it measure the distance from the camera to object? Please let me know. TIA.
Paula DerrengerUltralytics(bearbeitet)@AdadAlShabab hey there! 👋
No, the "Distance" in the VisionEye example is not a camera-to-object distance. It is the pixel distance between the vision point and the detected object's bounding-box centroid, divided by a
pixel_per_meterscale that you set and calibrate yourself. Here's a simplified example of how you might calculate distance in a custom script:import cv2 import math from ultralytics import YOLO model = YOLO("yolo26s.pt") cap = cv2.VideoCapture("path/to/video.mp4") while True: ret, im0 = cap.read() if not ret: break results = model.track(im0, persist=True) for box in results[0].boxes.xyxy.cpu(): # Example: Calculate distance based on object size or position here # This is a placeholder for actual distance calculation logic distance = calculate_distance(box) print(f"Distance: {distance} meters")In this example,
calculate_distancewould be a function you define based on your specific distance estimation method. Keep in mind, accurate distance measurement might require camera calibration and knowing the actual size of the object or using depth sensors in conjunction with the camera.Hope this helps! Let us know if you have any more questions. 😊
AdadAlShabab
Hi @pderrenger. Thanks a lot for your reply. I just wanted to know how can I divide the results by 10 ( ex: distance/10)? I'm dropping the code, please let me know in which line/lines I should make the changes? TIA.
Code:
if results[0].boxes.id is not None: track_ids = results[0].boxes.id.int().cpu().tolist() for box, track_id in zip(boxes, track_ids): annotator.box_label(box, label=str(track_id), color=bbox_clr) annotator.visioneye(box, center_point) x1, y1 = int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2) # Bounding box centroid distance = (math.sqrt((x1 - center_point[0]) ** 2 + (y1 - center_point[1]) ** 2))/pixel_per_meter text_size, _ = cv2.getTextSize(f"Distance: {distance:.2f} m", cv2.FONT_HERSHEY_SIMPLEX,1.2, 3) cv2.rectangle(im0, (x1, y1 - text_size[1] - 10),(x1 + text_size[0] + 10, y1), txt_background, -1) cv2.putText(im0, f"Distance: {distance:.2f} m",(x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 1.2,txt_color, 3)
Paula DerrengerUltralyticsHi @AdadAlShabab! 👋
To divide the calculated distance by 10, you can adjust the line where
distanceis calculated. Here's how you can modify it:distance = (math.sqrt((x1 - center_point[0]) ** 2 + (y1 - center_point[1]) ** 2)) / pixel_per_meter / 10This change will effectively scale down the calculated distance by a factor of 10. Just add
/ 10at the end of the existing distance calculation line in your code.Hope this helps! Let me know if there's anything else you need. 😊
skp4595
what does this mean "It calculates this distance by analyzing the size and position of the object within the frame, using the camera's field of view and other calibration parameters if available"? what do you mean by 'other calibration parameter if possible'? The model is not a blackbox. Is it? there must be some calibration, some ground truth from where model must have learned. please explain this.
skp4595
why are we dividing "distance " by 'pixel_per_meter' ? what is the logic or explaination for this ?
Paula DerrengerUltralyticsHey there! 👋
The division by
pixel_per_meteris used to convert the measured pixel distance into real-world units like meters. This conversion factor helps translate the scale of the image to actual distances based on how many pixels represent one meter in the image. It's essential for applications where you need to know the physical separation between objects or from the camera to an object, not just the distance in pixels.If you have more questions or need further clarification, feel free to ask! 😊
skp4595
you mean to say, if there's 1 unit Euclidean distance between two pixels in an image, than it'd be 10m in real world scenarios? And this scale can be adjusted according to our will as per "pixel_per_meter = 10" this code. Isn't it?
if so, how is this calibration done? where's the ground truth?
Paula DerrengerUltralyticsHey there! 👋
Yes, exactly! If the
pixel_per_meteris set to 10, it means that 1 pixel in the image corresponds to 0.1 meters in the real world. You can adjust this scale to fit the specific context or calibration of your camera setup.Calibration is typically done by measuring known distances in the real world and adjusting the
pixel_per_metervalue so that the distances in the image accurately reflect these measurements. Ground truth data for calibration might come from physical measurements or known dimensions within the scene.If you have any more questions or need further clarification, feel free to ask! 😊
skp4595
Thank you @pderrenger
Paula DerrengerUltralytics(bearbeitet)You're welcome! 😊
The "VisionEye View with Distance" feature calculates the pixel distance between a reference point and the detected object's centroid, not a true camera-to-object distance. The
pixel_per_metervalue is used to convert pixel measurements to real-world distances. Calibration involves setting this value based on known distances in your scene.To divide the distance by 10, modify the distance calculation line like this:
distance = (math.sqrt((x1 - center_point[0]) ** 2 + (y1 - center_point[1]) ** 2)) / pixel_per_meter / 10For more details, check out the VisionEye guide.
1
leongjy2005
Traceback (most recent call last): File "d:\Random_YOLO8_Tutorials\Human_Detection\visioneye.py", line 28, in annotator.visioneye(box, center_point) ^^^^^^^^^^^^^^^^^^^ AttributeError: 'Annotator' object has no attribute 'visioneye'
leongjy2005
I'm facing this issue, PLEASE HELP. Much Appreciated
Glenn JocherUltralytics(bearbeitet)@leongjy2005
visioneyeis not a method of the baseAnnotator; it lives onSolutionAnnotator. Usefrom ultralytics.solutions.solutions import SolutionAnnotatorandannotator = SolutionAnnotator(im0, line_width=2), or use thesolutions.VisionEyesolution from the VisionEye guide.1leongjy2005
Problem Solved! Thanks!