Object Counting via Camera: Mobile AI for iOS and Android

Object Counting via Camera: From Detection to Tracking

Real-time object counting via camera is a tricky task. Overlapping objects, varying scale, and the main pitfall — double counting when the camera moves. An industrial warehouse, a herd of animals, coins on a table — each scenario demands its own strategy. We have been doing mobile AI computer vision for over 5 years and have delivered 30+ projects. We offer turnkey solutions for iOS and Android using the latest versions of frameworks.

When is Automatic Object Counting Needed?

Typical use cases: inventory in a warehouse (warehouse logistics), livestock monitoring in agriculture, visitor counting in a store. Anywhere you need quick and accurate counts without manual recounting. Automation reduces costs by up to 15% and eliminates human error.

Two Approaches: Detection vs. Density Map

Detection-based counting — YOLOv8 mobile or RT-DETR detects each object; count = number of detections. Works well at low density (up to 50–100 objects per frame) with minimal overlap.

Density map estimation — A CNN predicts a density map; integrating the map gives the count. Used for high density: crowds, grain in a bin, cells under a microscope. CSRNet, DMCount, BL-model are current architectures.

// iOS: choose method based on expected density enum CountingStrategy { case detection(model: VNCoreMLModel) // < 100 objects case densityMap(model: VNCoreMLModel) // > 100 objects per frame case hybrid // mixed, determined adaptively } class AdaptiveObjectCounter { func selectStrategy(for objectClass: CountableObject) -> CountingStrategy { switch objectClass { case .vehicle, .person_sparse: return .detection(model: vehicleDetector) case .crowd, .grain, .cell: return .densityMap(model: densityEstimator) case .product_shelf: return .hybrid } } } 

How to Avoid Double Counting When the Camera Moves?

If the user pans the camera smoothly (warehouse, auditorium), tracking is needed to avoid counting the same object twice. ByteTracker is one of the best algorithms for this task, robust to occlusions. We have implemented integration on iOS and Android using non-maximum suppression to filter duplicates.

class TrackingObjectCounter { private var tracker = ByteTracker() // BYTE tracking algorithm private var countedIds: Set<Int> = [] // unique IDs per session func processFrame(_ detections: [Detection]) -> TrackingCountResult { let tracks = tracker.update(detections: detections) // New IDs — new objects that entered the frame let newIds = tracks.map { $0.trackId }.filter { !countedIds.contains($0) } countedIds.formUnion(newIds) return TrackingCountResult( currentFrameCount: tracks.count, // currently in frame totalUniqueCount: countedIds.count // total this session ) } } 

Why Density Map is More Accurate than Detection at High Density?

Detection-based methods fail when objects overlap: one bounding box covers multiple objects, or one object is split into parts. Density map solves this — the neural network predicts a distribution map, and the sum gives the exact count. For example, when counting grains in a bin (1000+ objects), density map is off by 2-5%, while detection has an error of 20-30%. Density map estimation is 4-10 times more accurate than detection under heavy occlusion.

// Android: density map estimation via TFLite class DensityMapCounter(context: Context) { private val interpreter: Interpreter by lazy { val model = FileUtil.loadMappedFile(context, "csrnet_lite.tflite") Interpreter(model, Interpreter.Options().apply { addDelegate(GpuDelegate()) numThreads = 4 }) } fun estimate(bitmap: Bitmap): Int { // Model input size — typically 512×512 or multiple of 16 val resized = Bitmap.createScaledBitmap(bitmap, 512, 512, true) val inputBuffer = TensorImage.fromBitmap(resized).buffer // Output tensor — density map of same resolution val outputBuffer = TensorBuffer.createFixedSize( intArrayOf(1, 512, 512, 1), DataType.FLOAT32 ) interpreter.run(inputBuffer, outputBuffer.buffer) // Sum over all density map pixels = estimated count val densitySum = outputBuffer.floatArray.sum() // Scaling: sum corresponds to number of objects return densitySum.roundToInt() } } 

What’s Included in Object Counting Implementation

• Scenario analysis — evaluate density, object types, shooting conditions (lighting, static/moving).
• Model selection — train/fine-tune YOLOv8, CSRNet, or a custom architecture.
• Integration — connect Vision (iOS) / TFLite (Android), implement pipeline: detection → NMS → tracking.
• Counter UI — display current and total count, animations, sound alerts.
• Optimization — quantization, GPU delegate, descriptor caching.
• Documentation and support — deliver source code, API description, team training.

We guarantee counting accuracy of 90-97% depending on conditions (verified on 10+ projects for warehouses and agricultural monitoring). Contact us to assess your scenario — we’ll determine the strategy and timeline within 1-2 days.

Process for Implementing Object Counting

1. Analysis — you send video or description of the task. We select the architecture.
2. Prototype — in 3-5 days we build a working demo build for iOS and Android.
3. Integration — embed the module into your app, configure the pipeline.
4. Test — measure accuracy on your data, fine-tune the model if needed.
5. Deploy — publish to App Store / Google Play, monitor in production.

Timeline: from 5 days to 2 weeks depending on complexity. Exact cost calculated individually after task analysis. Request a consultation — we’ll analyze your task and propose the optimal strategy.