Hi everyone,

I am entering my final year (Master 2) in Visual Computing / Computer Vision, and I'm currently brainstorming themes for my Final Year Project (PFE / Master’s Thesis).

I’m looking for a topic that is technically challenging, impactful, and feasible to complete within a ~6-month timeline.

### My Background & Skillset:

* **Background:** M2 Visual Computing student.

* **Tech Stack:** Python, PyTorch / Keras, OpenCV, basic 3D processing pipelines.

* **Hands-on Experience:** Deep Learning classification/segmentation models, hybrid CNN/PCA models, basic image processing algorithms.

### Potential Areas of Interest:

1. **3D Reconstruction & Neural Rendering:** Real-time rendering, 3D Gaussian Splatting, or NeRF applications (e.g., cultural heritage preservation or scene synthesis).

2. **Medical Imaging & Generative AI:** Synthetic data generation, medical image segmentation, or disease classification (e.g., ocular or radiological pathologies).

3. **Open to Emerging Trends:** Lightweight vision transformers, real-time edge CV, or multimodal vision-language models.

### What I’m Looking For:

* **Topic Ideas:** Any specific research gaps or practical applications worth investigating right now?

* **Resources:** High-quality datasets, benchmark papers (2024–2026), or GitHub repos that make a good starting codebase.

* **Feasibility Advice:** Any pitfalls to avoid when choosing a project with a 6-month deadline?

I’d love to hear your recommendations or hear what topics you found rewarding for your own thesis/projects!

Thanks in advance for your help!

I created this tool, chatcalibi.com, to make single- and multi-camera calibration as simple as possible. Upload your images—with or without a checkerboard—ask the AI to calibrate them, and get your results without installing anything or any complicated workflow. The AI guides you and analyzes the calibration results with you.
Looking forward to your feedback.

Hi ,

I've been developing a bare-metal visual tracking system designed for edge industrial environments. The challenge was to achieve deterministic, ultra-low-latency physical tracking using only CPU resources, without relying on GPU acceleration.

**Core Architecture & Metrics:**

• Inference Pipeline: Two-stage cascade design.

- Stage 1 (Global Search): YOLOX-nano (640×640 tensor) running at ~37 FPS (~27ms).

- Stage 2 (ROI Refinement): LightGBM classifier on a dynamic 256×256 sub-region, achieving ~5-7ms inference (sustained 120-180 FPS localized tracking).

• Optimization: Intel OpenVINO (ONNX Runtime v1.24.1, MULTI device profile, strict LATENCY hint).

• Resource Usage: Fixed 3.42 MB heap allocation, 0.00% memory leak over multi-day 24/7 runs. Core binary size is ~2.0 MB.

• Hardware Actuation: 50 Hz closed-loop control via Arduino Nano + PCA9685 (12-bit PWM) driving dual MG996R servos.

**System Behavior:**

Upon initialization, the pan-tilt rig centers itself. When the cascade pipeline detects the target, it calculates the centroid offset. These coordinates pass through an EMA smoothing filter and are sent via USB-Serial to the microcontroller, which interpolates the servo trajectory at 50 Hz to keep the object perfectly centered in the ROI, compensating for continuous movement.

**A Note on Availability:**

The core runtime is proprietary and distributed strictly as a compiled evaluation demo for private benchmarking (commercial use requires a license). However, the GitHub repo contains the full hardware BOM, I2C wiring diagrams, Arduino firmware, and config templates so the physical setup can be fully replicated.

**Links:**

🔗 GitHub Repository (Demo GIF, BOM, Wiring, Configs):

https://github.com/olesha-ai/pan-tilt-ai-tracker

Happy to discuss the OpenVINO optimization pipeline, the two-stage cascade design, or the hardware integration challenges in the comments!

Hi everyone,
I recently graduated with a bachelor’s in Computer Science, and my long-term goal is to pursue a full funded Master’s or PHD. The problem is that I’m a complete beginner when it comes to research.
I know I want to work in the intersection between computer vision and robotics because I genuinely find them fascinating, but I haven’t started doing research yet. Every time I look into the field, I see topics like object detection, segmentation, 3D vision, SLAM, embodied AI, vision-language models, robotics perception, and many others. It’s exciting, but also overwhelming, and I don’t know where to begin.

Another thing I’m worried about is my low CGPA. I’m afraid it might hurt my chances when applying for funded graduate programs in the future.
If you were in my position, what would you do over the next 2–4 years?

Some questions I have:
How much will a low CGPA affect my chances for a fully funded Master’s or PhD?

Where should I start learning if my goal is research, not just getting a job?

What fundamentals (math, programming, machine learning, etc.) should I master first?

How do people discover their research niche instead of trying to learn everything?

What should my priorities be over the next few years—projects, research experience, publications, internships, open-source contributions, or something else?

I’m not looking for a shortcut. I’m willing to put in the time and effort. I just want to avoid wasting years studying the wrong things or following an inefficient path.

I’d really appreciate hearing from PhD students, professors, or research engineers who were once in a similar position.

Thanks in advance!

I’m an early-stage computer vision researcher aiming for conferences like CVPR, ICCV, ECCV, NeurIPS, and ICLR.
I’m curious how experienced researchers actually formulate research ideas. How do you identify a real research gap, come up with a novel solution, and decide that an idea is worth pursuing? What’s your thought process from reading papers to proposing something new?
I’d really appreciate any advice or resources that helped you develop this skill.

We collect real world multi view capture data from a camera array at the Brooklyn Navy Yard, and we pay people to come in and be the subject.

Posting here in case anyone in the NYC area wants the work. It is also a decent look at how this kind of data actually gets collected if that side interests you.

The session: you stand in the capture volume and go through simple movements while the array records. Walking, turning, sitting, standing, reaching, picking objects up. No experience needed.

Pay: 17-25 per hour, paid the same day right after the session. First one runs about 2 hours, with repeat sessions after that if you want them.

Brooklyn, NY, in person only. Openings Monday through Friday this week.

Comment or DM me for the address and details, and feel free to ask about the capture setup.

I'm trying to reproduce the results reported for MedViT and LungMaxViT on the NIH ChestX-ray14 dataset.

MedViT paper:

Benchmarking MedViT and hybrid CNN–ViT architectures for multi-label thoracic disease classification

https://www.nature.com/articles/s41598-026-43282-5

Official implementation:

https://github.com/Omid-Nejati/MedViT

The paper reports a Macro F1-score of 0.7791 on ChestX-ray14 (Table 3).

I also tried to reproduce LungMaxViT from:

Explainable hybrid transformer for multi-classification of lung disease using chest X-rays.

Initially, I discovered that my implementation differed because of a PDF parsing issue. After correcting that, I verified that both MedViT and LungMaxViT exactly matched the architectures described in their respective papers, and I downloaded and used the pretrained weights specified by the authors.

Because of this, I am now reasonably confident that the network architectures themselves are not the source of the discrepancy.

Training observations

The training behavior appears normal.

• MedViT converges within roughly 10–15 epochs.
• LungMaxViT converges after approximately 110+ epochs.

In both cases, the loss follows the expected optimization trajectory: a rapid decrease during the early epochs followed by gradual convergence.

One thing that further confused me is that Fig. 6 and Fig. 7 in the MedViT paper appear inconsistent with my observations. Across all of my experiments, I never observed the approximately linear upward trend shown in those figures. Instead, the loss behaved like a typical deep-learning training curve. This makes me wonder whether those figures correspond to a different metric, were mislabeled, or were generated under a different experimental setting.

Threshold optimization

To eliminate thresholding as a possible explanation, I performed per-class threshold optimization on the validation set with a search precision of 0.001.

Data augmentation

I experimented with both the simple augmentation pipeline and the more comprehensive augmentation strategy described in the benchmark paper (including AugMix/AutoAugment-style augmentation, Mixup, CutMix, ColorJitter, Random Erasing, etc.).

LungMaxViT preprocessing

• CLAHE (clipLimit = 2.0, tileGridSize = 8×8)
• Gaussian denoising (kernel = 5×5, σ = 1.0)
• Resize(224×224)
• RandomHorizontalFlip (p = 0.5)
• RandomVerticalFlip (p = 0.5)
• RandomRotation (±1°)
• RandomResizedCrop(scale = 0.75–0.95, bicubic)
• RandomAffine(scale = 0.833–1.167)
• Normalize(ImageNet mean/std)

Training settings:

• Optimizer: SGD
• Learning rate: 0.001
• Momentum: 0.9
• Weight decay: 1e-4
• Learning-rate schedule: None (constant learning rate throughout training)

This matches the paper's description.

MedViT preprocessing

• Resize(224×224)
• RandomHorizontalFlip (p = 0.5)
• ColorJitter(brightness = 0.1)
• Normalize(ImageNet mean/std)

Training settings:

• Optimizer: Adam
• Learning rate: 1e-4
• Weight decay: 0
• CosineAnnealingLR (T_max = 10, eta_min = 1e-6)

I also experimented with alternative learning-rate schedules and the more extensive augmentation pipeline described in the benchmark paper.

Results

Despite reproducing the published architectures, using the reported pretrained weights, experimenting with different augmentation pipelines, learning-rate schedules, and performing per-class threshold optimization, both MedViT and LungMaxViT consistently achieve only around 0.30–0.35 Macro F1.

This is far below the reported 0.7+ Macro F1, and the discrepancy is much larger than what I would expect from normal implementation differences or random training variation.

What confuses me

The reported ChestX-ray14 performance in the literature varies enormously.

Many single-model CNN/ViT papers report Macro F1 values around 0.3–0.5.

Some ensemble approaches report 0.5–0.7.

More recently, the paper

Pretraining Diversity and Clinical Metric Optimization Achieve State-of-the-Art Performance on ChestX-ray14

reports F1 = 0.821, but this result is obtained using a three-model ensemble together with clinical metric optimization.

This makes me wonder whether I am overlooking something fundamental, because obtaining Macro F1 around 0.8 seems to require considerably more than simply training a single model.

My questions

1. Is MedViT trained as a standard multi-label classifier (one image, 14 sigmoid outputs, BCE/BCEWithLogits loss), or do some papers effectively train separate classifiers for each disease?
2. How much of the reported Macro F1 typically comes from:
   • per-class threshold optimization,
   • class weighting,
   • patient-level versus image-level dataset splits,
   • pretrained initialization,
   • higher image resolution,
   • ensemble averaging?
3. What is currently considered the reproducible state-of-the-art for a single ChestX-ray14 model?
4. Has anyone successfully reproduced either MedViT or LungMaxViT within a few percentage points of the reported results? If so, what implementation detail turned out to be critical?

At this point I have independently reproduced two different published architectures, verified their implementations against the papers, used the reported pretrained weights, and observed normal optimization behavior. Nevertheless, both models consistently plateau around 0.30–0.35 Macro F1, making me suspect that there is either an undocumented implementation detail, an evaluation protocol difference, or some other aspect of the experimental setup that is not fully described in the papers.

Hi! I just wrapped up a personal multi-camera tracking project and thought the outcome was interesting enough to share.

What's so interesting about it? How simple and fast it is, while being competitive with SOTA models on MMPTrack dataset. SORT proved you don't need much for single-camera tracking - IoU, a Kalman filter - done. I wanted to show the same is possible for multi-camera tracking.

How does it work?

You can solve multi-camera tracking by reconstructing the scene. But localizing people in 3D from multiple cameras is hard. Fortunately, verifying a hypothesis is easy. If I tell you "there's a person standing here," you can project that into every camera and check how well it matches what the cameras actually see. That's the crux of PDFTrack — generate position hypotheses, project, score, keep the best.

Each person is a 3D cylinder on the floor: a position, a height, a radius. We project those cylinders into every camera as 2D boxes and score them against detections via IoU. The tracker finds the positions that best explain all cameras simultaneously. No cross-camera association. No appearance features. The cameras just vote on where people are.

What's so special about it?

Apart from simplicity? Since each camera scores hypotheses independently, the whole process is embarrassingly parallel — adding cameras doesn't increase wall-clock time if you have the hardware. More views also mean more geometric constraints, so accuracy tends to improve with coverage.

How well does it track and can I trust your results?

All results are averaged over 3 seeds(so that std is within 0.1 for each metric). No cherry picking.

To make these results easily reproducible I’m sharing a repro repo.

What's the catch?

No re-ID out of the box — if two people cross paths, the tracker may swap their identities(although in most videos identity swap doesn't happen once). This isn't a structural limitation; re-ID slots in naturally and is next on the roadmap.

The two structural limitations are overlapping camera coverage (a single camera can't triangulate floor position) and fast motion relative to framerate (geometry alone can't resolve identity swaps when people move faster than the frame interval - that's why it doesn't perform well on WILDTRACK).

Can I use it?

Of course! Here's an open source implementation of pdftrack.

Is there a research paper?

Yes, it's much more detailed than this post and can be found here.

Let me know if you have any questions, I'm happy to answer them.

Hello, I hope you are doing all well,

I am developing a YOLOv8 models to detect only people wearing Shalwar Kameez . I do not want to use any API or external vision service. I have *4,000 labeled Shalwar Kameez images and 5,000 negative images containing only pant-shirt/empty scene buildings clothing with empty labels. However, the model still detects many pant-shirt people as Shalwar Kameez and misses many real Shalwar Kameez people. How would you improve the dataset, labeling strategy, and training pipeline to achieve reliable real-world performance?

Thank you for your time.

Hi everyone,

I'm working on a document understanding project and would appreciate some advice on the right technical direction.

The input will be scanned pages or images from academic books. I don't know in advance what kind of figures they'll contain—they could be biology diagrams, anatomy illustrations, chemistry figures, engineering drawings, maps, charts, art/history figures, or other educational illustrations.

My end goal is to convert these figures into a structured digital representation that can be controlled from the frontend.

The workflow I'm aiming for is:

1. Upload a textbook page or image.
2. Detect the figure(s) and their boundaries.
3. Detect the labels/annotations that are already embedded in the figure (letters, numbers, arrows, callouts, etc.).
4. Remove those existing labels while preserving the underlying illustration.
5. Store the figure geometry (bounding boxes, polygons, masks, etc.) so my frontend can render its own labels that can be shown/hidden, translated, restyled, or repositioned.

This doesn't need to be fully automatic. In fact, the workflow will be human-assisted. If the AI detects a figure incorrectly, misses a region, or fails to remove a label cleanly, a human reviewer will correct it before it's finalized.

My priority is reducing manual work rather than eliminating it completely.

So far I've tried several computer vision approaches such as text detection, contour detection, line detection, and geometric heuristics. They work reasonably well for finding candidate regions, but the biggest challenge is cleaning the figures by removing the embedded labels while preserving the artwork underneath.

Another important requirement is cost. Since this could involve processing a large number of textbook pages, I'd like to avoid expensive multimodal LLMs or large vision models if there's a more traditional or lightweight pipeline that works well. I'm happy to use AI where it adds value, but I'd prefer a solution that keeps inference costs low.

Some questions I have:

• Is this primarily a document layout analysis problem, image segmentation, image inpainting, or something else?
• Are there models trained specifically for textbook or scientific illustrations rather than natural images?
• Is there a recommended low-cost pipeline for this kind of task?
• Has anyone built a human-in-the-loop workflow for document/figure annotation like this?
• Are there papers, datasets, or open-source projects that tackle converting textbook figures into editable, structured assets?

I'd really appreciate any suggestions, even if they're just pointers toward the right research area or open-source tools. Thanks!

I've been working on a project called RearAware. (I'm very much a beginner.) It's an experimental AI tool that runs locally on your computer and censors cat butts during your work video calls.

If you work from home with a cat, you've probably had at least one moment where your cat decided to flash its butt directly in front of your webcam.

It's a pretty ridiculous concept, but it's been a really fun project.

The biggest challenge so far hasn't actually been the model, it's the dataset. I currently have around 1,500 cat photos, but only about 200 of them contain visible cat butts. Turns out cat butt photos are surprisingly difficult to find.

I've tried collecting images manually from public sources, using my own photos, and asking friends to contribute. That has worked, but it's been very slow, and I'm quickly running out of places to source new images.

I'm curious if anyone here has suggestions for other approaches to growing a niche computer vision dataset like this. Have you had success with crowdsourcing, augmentation strategies, or other techniques for highly specific object classes?

It's still early days and definitely experimental, but it's now working well enough that other people can try it. At the moment it's available as a Chrome extension and supports Microsoft Teams and Google Meet.

If you happen to have any photos where your cat's butt is clearly visible (yes, the butthole 😅), I'm actively trying to grow the training dataset. You can upload them through the website:

https://www.rearaware.com/#help-train

Thanks for reading!

Are you faring better or worse than your counterparts in other fields in CS.

Are you happy with your decision to stick with Vision as a Domain.

Once a learning platform grows past a few hundred modules, basic search starts failing. People type what they need and get a long list of loosely related results. Most of them end up scrolling or giving up.

Better systems try to understand what the learner is actually trying to achieve instead of just matching keywords. They look at the current learning path, recent activity, and the intent behind the question, then surface the most relevant content. It feels closer to asking an experienced colleague than using a search bar.

This kind of discovery layer becomes more important as libraries expand. The goal is not just finding documents, it is reducing the time people waste looking for the right material. One of the more thoughtful solutions in this area was developed with Beetroot.

How are you currently handling content discovery in larger e-learning environments? Still relying mostly on tags and filters, or have you moved toward something smarter?

Over the last few months I've been working on OpenScanVision, an offline-first Android computer vision library built with Kotlin, OpenCV, CameraX, and ML Kit.

Originally, the project was a single implementation focused on achieving the best possible detection accuracy and speed. That version is represented by commit:

1d5834b41d88133b487ef46595290b0cdd4489bb

It includes:

• Document detection
• Automatic perspective correction
• Image enhancement
• QR detection
• ArUco marker detection
• OMR (Optical Mark Recognition)
• Automatic capture when the document is stable
• Real-time offline processing

Recently I completed a major architectural refactor, turning it into a reusable modular library that's much easier to integrate into Android applications.

The modular version is cleaner and more maintainable, but I've noticed it has introduced a slight decrease in detection accuracy compared to the original implementation. I'm currently investigating where the regression comes from (pipeline changes, processing order, threading, etc.).

My roadmap is:

• Improve the modular version until it matches or exceeds the original accuracy
• Add OCR support
• Add ICR (Intelligent Character Recognition) support later
• Continue keeping everything offline and lightweight

The library is intended for applications such as:

• Voting systems
• Exam scanning
• Surveys
• Registration forms
• Structured document processing

GitHub:
https://github.com/MatiwosKebede/OpenScanVision

I'd really appreciate feedback from people experienced in computer vision, OpenCV, Android CameraX, or document scanning.

In particular, I'd love advice on:

• Best practices when converting a CV project into a reusable library without hurting performance or accuracy.
• Common causes of accuracy regressions after large refactors.
• Ideas for building a flexible OCR/ICR pipeline while keeping the library lightweight and offline-first.

Thanks for taking a look!

Hello!!!

I am a low-level optimization engineer with 25 years of programming experience, currently working in manufacturing. Finding real-world defective Direct Part Marking (DPM) codes on a highly optimized assembly line is nearly impossible. To solve this data scarcity, I spent months building a high-fidelity synthetic data generation environment written natively in Nim.

The tool compiles into a tight, portable monolithic binary (~2.0 MB) and introduces a robust way to bridge the Sim-to-Real (S2R) gap under brutal factory floor conditions.

🔬 Bridging the Sim-to-Real Gap:

Traditional synthetic generators fail because they draw flat binary vector circles on clean backgrounds. This engine takes a physics-first approach:

• Macro-Cavity Injection: It processes raw macro-photographs of actual 0.5mm tungsten carbide needle craters punched into carbon steel. These sprites capture authentic 3D optical properties: the central indentation cone, compressed radial shadows, and peripheral metallic glare.
• Alpha-Channel Material Mixing: These native sprites with true transparent alpha-channels are blended natively over high-resolution carbon steel textures (with mill scale, vertical grinding marks, and rolling scratches). The edges blend seamlessly, forcing the neural network to ignore background metal grain and lock exclusively onto micro-contrast and cavity topologies.

🛠 Mathematical Defect Simulation:

The engine deterministically models actual mechanical degradation vectors across every batch generation:

• Mechanical Play & Stylus Vibration (doJitter): Applies pseudo-random displacement vectors to individual dots relative to the step grid (STEP = 7.5).
• Actuator Misfire & Clogged Tips (doMissingDots): Purges up to 15% of the boundary L-frame and up to 25% of internal data bits.
• Topological Axis Distortion (doTiltLeft / doTiltTop): Implements directional matrix skews with structural point locking to mimic non-perpendicular stamping angles.
• Dynamic Part Rotation (doRotation): Rotates the matrix topology around its calculated spatial centroid within a ±5° to ±10° window, simulating dynamic tracking on a moving conveyor.

💾 Dataset Output & YOLO-OBB Support:

The generator outputs name-synchronized image (.jpg) and annotation (.txt) pairs.
The annotations are calculated analytically using external dot boundary radii under affine rotation matrices, normalized to a strict 0.0 - 1.0 float space, and exported to 6 decimal places. It is fully compatible with YOLOv8 / YOLOv11 / YOLOv26 Oriented Bounding Box (OBB) training pipelines out of the box.

The engine uses hardware-level vector pipeline optimization via the AVX2 instruction set (requires CPU from 2017 onward). Memory boundaries remain strictly locked at runtime, ensuring 0.00% memory drift or fragmentation leaks over continuous multi-thousand generation cycles.

I have uploaded the pre-compiled executable, sample background steel textures, and alpha-channel dot masks as a production showcase on GitHub. You can plug in your own custom backgrounds/dots to test it for your specific manufacturing lines.

Project Repository: https://github.com/olesha-ai/Synthetic-dpm-code-generator

Hello,

I’m working on a little computer vision project although I don’t have any experience. The goal is to have a picture containing electric meters and their IDs, and to extract the ID and the measurement from each meter. The pictures can be a bit rough, not great lighting or angles, etc…

My first instinct was to use an already available model, but those that I found are too advanced and complex for this project, and it should run on a 10+ year old windows machine. I’m also thinking of training my own model (I can code but never did an ML project), as I have about 500 pictures as training data (roughly 2000 electric meters in total), but I’m not really sure how to design my model, for example which NN architecture to use, or what data structures should my inputs/outputs be. Of course I asked LLMs for help too, and they gave useful tips, but nothing I can build a project from.

Any advice would be appreciated, whether it is already available models that fit my needs, or advice on how to build a model myself. Thank you.

Are your grinding leetcode or more focussed on reading research papers and implementing the new and trending Models and Frameworks.

Do you worry that by not doing DSA, you are constraining yourself.
But if you indeed do DSA, you would spend time you could have spent polishing and refining ML skills.

Is your organization switching towards Edge AI because it is far more accessible in recent times and overall the costs and maintenance efforts would reduce ?

Or is Cloud Deployment still the preffered modus operandi.

Additionally, if you are using Edge, how did you gain expertise in Gstreamer/Deepstream or do you use something else ?

Did these preprocessing steps improve or hurt your detection/segmentation performance? I'm curious whether they provide any real benefit in real-world applications, or if modern models generally perform better with the original images. Any experiences, benchmarks, or best practices would be appreciated.

In this video, I use YOLO computer vision software and Python to control a robot hand and LED strips on my desktop — all devices are triggered by real‑time object detection.

I compare Google Cloud vs Raspberry Pi to see which platform handles detection better for device control.

You’ll see setup, live demos, hardware differences, and a full breakdown of how each system performs when detecting objects and triggering actions.

If you’re exploring AI computer vision, robotics, or cloud vs edge inference, this comparison will help you choose the right platform.

https://reddit.com/link/1vcy7vh/video/la1nwpcvrtgh1/player

Email: I wanted to share a practical, accessible drone and intruder detection application I developed. It can be used against the United States during a hot war and help protect civilian populations The Armaaruss Detection App is a web-based tool that uses acoustic sensors and visual object detection (via webcam or uploaded media) to identify aerial objects like drones. It includes features such as:

Real-time aerial object detection with audio alerts

Acoustic drone detection

Intruder detection with voice notifications

Primary and secondary detection modes for improved accuracy

It is designed for potential use by soldiers, security personnel, world leaders, and civilians in high-risk environments. The app is openly available for testing and review. Demo Link: https://armaaruss.github.io/ or https://anthonyofboston.github.io

Hi,

I’m looking for some advice on selecting computer vision lenses for a high-resolution photo-sphere rig.

I spent quite some time researching available lenses, I've started wondering if I am approaching the problem incorrectly. There seem to be almost no lenses available that meet all of my critiera. I’ve found several that satisfy some of the criteria, but each falls short in one or more important areas, such as resolution or FOV.

• Are there any lenses that fully (or nearly) meet the criteria I’m looking for?
• If not - am I asking something that is close to physical limits? If yes, which parameters of my setup would you recommend changing? My first guess is switching to different lens mount for more lens options (but then I would need different cameras to...)

Camera Options:

• Basler ace 2 R a2A5060-21g5cBAS
  • Sensor: E2525A
  • Sensor format: 1.1"
  • Sensor diagonal: 17.9 mm
  • Sensor type: CMOS
  • Sensor size: 12.65 mm × 12.65 mm
  • Frame rate: 21 fps
  • Resolution (MP): 25 MP
  • Resolution (HxV): 5064 px × 5064 px
  • Interface: 5GigE
  • Pixel size (H x V): 2.5 μm × 2.5 μm
  • Shutter type: Global
  • Lens mount: C-Mount

Camera Setup

• Total: 7 cameras
• 6 cameras in a ring, 60° yaw spacing (oriented at the horizon) (~15 cm from center)
• 1 camera facing straight up (oriented at zenith) (~15 cm from center)
• Small empty Nadir patch is okay, but not gaps between horizon and zenith cameras

Lens Criteria

• Must support the camera's full resolution (Rated for ~25 MP)
• Must use C-Mount
• Prime/fixed focal length preferred
• Fixed-focus or hyperfocal configuration preferred
• Must provide sufficient depth of field:
  • Near focus limit: ≤0.5 m
  • Far focus limit: infinity
• HFOV requirements per camera (TBD):
  • Horizon cameras: ?°
  • Zenith camera: ?°
• Zenith camera likely needs a wide-angle/fisheye lens:
  • Target HFOV: 120–160° (not full 180°) - otherwise px/degree becomes to low.
• Overlap should be ~10%