MareArts ANPR Mobile App - Professional License Plate Recognition in Your Pocket

📱 Introducing MareArts ANPR Mobile App - AI-Powered License Plate Recognition

We're excited to announce the MareArts ANPR Mobile App - bringing professional-grade license plate recognition to iOS! Experience the power of on-device AI for parking management, security checkpoints, and vehicle tracking, all in your pocket.

🎁 One License, Everything Included!

No additional license required! When you purchase a MareArts ANPR license, you get:

• ✅ Python SDK (unlimited desktop/server usage)
• ✅ iOS Mobile App (unlimited mobile usage)
• ✅ Road Objects Detection
• ✅ All future updates

One license = Use everywhere!

📲 Download Now

iOS: Download on App Store

Android: Coming Soon! 🚀

Search "marearts anpr" in the App Store

🎉 Free Trial Available!

• ✅ 100 scans per day - FREE forever!
• ✅ No credit card required
• ✅ No registration needed
• ✅ Try before you buy
• ✅ Login for unlimited scans (with license)

✨ Key Features

🔒 100% Privacy First

• On-Device AI Processing - All recognition happens on your iPhone
• No Cloud Upload - Your data stays on your device
• No Analytics Tracking - We don't track your usage
• Local Storage - Complete privacy and security

⚡ Lightning Fast

• Real-time Detection - Instant plate recognition
• Continuous Scanning - Auto-capture mode for busy entrances
• Optimized for iOS - Smooth 60 FPS camera
• No Internet Needed - Works completely offline

🌍 Multi-Region Support

• 🌍 Universal - All regions (default)
• 🇪🇺 Europe+ - EU, UK, Switzerland, Norway
• 🇰🇷 Korea - South Korea (한국)
• 🇺🇸 North America - USA, Canada, Mexico
• 🇨🇳 China - China (中国)

🧭 Five Powerful Tabs

1. 📷 Scan Page - Fast Recognition

Camera Modes:

• Single Capture (⭕) - Take one photo at a time
• Continuous Mode (🔄) - Auto-scan continuously
• Cloud Mode (☁️) - Use cloud API for processing
• Swipe left/right - Quick switch between modes

Smart Controls:

• 🔦 Flash toggle for low light
• 🔍 1x-5x zoom (pinch or tap)
• 📷 Front/back camera switch
• ✅ Tap to focus anywhere

Live Feedback:

• Green/Red boxes show detected plates
• Real-time plate number display
• Confidence percentage shown
• Whitelist/Blacklist status indicator

2. 🕐 Detections Page - Complete History

Three View Modes:

📋 List View

• All captured plates chronologically
• Grouped by: Today, Yesterday, This Week, etc.
• Swipe left-to-right - Quick status change menu
• Color badges: Green (whitelist), Red (blacklist), Orange (unknown)
• Shows: Plate number, time, location, thumbnail

📸 Full Preview

• Large plate image
• Edit plate number (tap ✏️)
• Detection + OCR confidence
• GPS location & address
• Quick actions: Copy, Delete, Add to Whitelist/Blacklist

🗺️ Map View

• See all plates on interactive map
• Smart clustering for nearby detections
• Satellite/Road view toggle
• Show all plate numbers as labels
• Search by plate number
• Tap markers for details

3. ✅ Rules Page - Whitelist & Blacklist

Smart Access Control:

• Whitelist (Green) - Approved vehicles, success sound
• Blacklist (Red) - Blocked vehicles, alert sound
• Search in Real-time - Filter plates instantly
• Partial matching: "ABC" finds "ABC-123"
• Tab counters show totals
• Swipe left to delete
• + button to add new plates

Use Cases:

• 🏢 Parking: Whitelist residents, blacklist violators
• 🔐 Security: Whitelist staff, blacklist banned vehicles
• 🚚 Delivery: Track known vehicles

4. 📊 Stats Page - Analytics & Insights

Overview Cards:

• Total Scans (all-time)
• Today's count
• This Week / Month / Year

Top 10 Vehicles:

• Most frequently detected plates
• Tap to see all scans for that vehicle

Time Period Selector:

• Today - Hourly breakdown
• This Week - Monday to today
• This Month - Current month
• Year - Full year with year selector
• Custom Range - Pick any dates

Status Filter:

• View All, Whitelist only, Blacklist only, or Unknown

5. ⚙️ Settings Page - Fine-Tune Everything

Account:

• Login with email + signature → Infinite scans!
• Free trial: 100 scans/day (no login)
• Shows expiry date

Notifications:

• 🔊 Sound alerts (success/alert/unknown)
• 📳 Vibration patterns (different for whitelist/blacklist)

Detection Settings:

• Sync Thresholds - Link detection + OCR together
• Detection Threshold (60-95%) - Minimum confidence
• OCR Threshold (60-95%) - Text recognition confidence
• Max Detections (1-10) - Plates per scan
• Ignore Duplicates (0-60s) - Prevent repeated saves
• Plate Region - Select specific region for accuracy

Storage:

• Save images toggle
• Clear history
• Data retention: 7-365 days or Never

Location:

• Enable GPS for map view
• Shows address with detections

🎯 Real-World Use Cases

🏢 Parking Management

1. Add residents to Whitelist
2. Scan vehicles at entrance
3. Green = Allowed, Red = Blocked
4. Review violations in history
5. View statistics monthly

🔐 Security Checkpoint

1. Add approved vehicles to Whitelist
2. Add banned vehicles to Blacklist
3. Use Continuous Mode at gate
4. Audio/vibration alerts instantly
5. GPS tracking of all entries

🚗 Vehicle Tracking

1. Scan vehicles continuously
2. View complete history
3. Use Map to see locations
4. Export data for reports
5. Track Top 10 frequent visitors

🚚 Delivery Management

1. Track delivery vehicle arrivals
2. Time-stamped records
3. GPS location logging
4. Statistics for optimization
5. Whitelist known carriers

💡 Pro Tips for Best Results

✅ Best Practices:

• Distance: 2-3 meters from vehicle
• Angle: Perpendicular to plate (90 degrees)
• Lighting: Good outdoor light (daytime best)
• Focus: Tap plate area to focus before scanning
• Stability: Hold steady while capturing

❌ Avoid:

• Too far away (>5 meters)
• Extreme angles
• Low light conditions
• Motion blur (moving vehicle)
• Dirty or damaged plates

⚙️ Settings Recommendations:

Use Case	Detection	OCR	Max Plates	Region
High Accuracy (Parking/Security)	90%	90%	1	Specific
High Recall (Traffic Monitoring)	70%	70%	5	Universal
Balanced (General Use)	80%	80%	2	Specific

🔄 Latest Update (v1.5.16)

What's New:

• ✨ Year selector in Stats page
• 📅 Custom date range picker
• 🔍 Search in Rules page (real-time filtering)
• 👆 Swipe navigation between modes
• 🎨 UI improvements
• 🐛 Bug fixes and performance enhancements

🆚 Free vs Paid License

Feature	Free Trial	Paid License
Daily Scans	100/day	Unlimited ∞
All Features	✅	✅
5 Regions	✅	✅
Whitelist/Blacklist	✅	✅
History & Stats	✅	✅
Map View	✅	✅
Python SDK	❌	✅
Commercial Use	❌	✅
Support	Community	Priority

🌟 Why Choose MareArts ANPR Mobile App?

• ✅ Professional Grade - Same AI as enterprise SDK
• ✅ 100% Privacy - All processing on-device
• ✅ Lightning Fast - Real-time recognition
• ✅ Free Trial - 100 scans/day forever
• ✅ Multi-Region - Works worldwide
• ✅ Complete Solution - Whitelist, history, map, stats
• ✅ One License - Mobile + SDK included
• ✅ Regular Updates - New features monthly

📊 Technical Specs

• Platform: iOS 14.0+ (Android coming soon)
• AI Engine: On-device CoreML
• Processing Time: ~0.1s per frame
• Accuracy: 95%+ (optimal conditions)
• Storage: ~200MB (with models)
• Internet: Not required (offline capable)
• Camera: All iOS cameras supported

🚀 Get Started in 3 Steps

# Step 1: Download from App Store
Search "marearts anpr" → Install

# Step 2: Open app and start scanning
Tap Scan → Point at license plate → Capture!

# Step 3 (Optional): Login for unlimited
Settings → Login → Enter email + signature → ∞ scans!

💼 Perfect For:

• 🏢 Parking Lot Managers - Automate access control
• 🔐 Security Guards - Quick vehicle verification
• 🏠 Residential Communities - Resident/visitor tracking
• 🏗️ Construction Sites - Authorized vehicle entry
• 🏨 Hotels - Valet parking management
• 🚚 Logistics - Delivery vehicle tracking
• 👮 Law Enforcement - Field plate scanning
• 🎓 Universities - Campus parking control

📞 Support & Resources

• 📧 Email: hello@marearts.com
• 🌐 Website: https://www.marearts.com
• 🛒 Buy License: ANPR Solution
• 📚 Full Guide: APP_GUIDE.md
• 🐛 Report Issues: GitHub Issues

🎁 Special Offer

Buy one license, get everything:

• ✅ Python SDK (desktop/server)
• ✅ iOS Mobile App (unlimited scans)
• ✅ Road Objects Detection
• ✅ All future updates
• ✅ Priority support

One payment, lifetime access!

💬 What Users Are Saying

"Perfect for our parking lot! 100 free scans/day is enough for testing, and the paid version is unlimited." - Parking Manager

"Finally, professional ANPR on mobile! On-device processing means no privacy concerns." - Security Director

"The whitelist/blacklist feature saves us so much time at our security gate." - Facility Manager

"Map view is genius! We can see exactly where each vehicle was spotted." - Operations Manager

🎯 Start Today!

1. 📲 Download: Search "marearts anpr" on App Store
2. 📷 Try Free: 100 scans/day, no credit card
3. 🚀 Upgrade: Login for unlimited scans
4. 💼 Deploy: Use in production with confidence

Professional license plate recognition is now in your pocket! 📱🚗

---

FREE ANPR/ALPR/LPR API - Try Before You Buy (1000 Requests/Day)

🎁 FREE License Plate Recognition API - No Credit Card Required!

Want to try ANPR (Automatic Number Plate Recognition) / ALPR (Automatic License Plate Recognition) / LPR (License Plate Recognition) without buying a license? We offer a completely FREE test API with 1000 requests per day!

✨ What You Get (FREE!)

• ✅ 1000 requests/day - Perfect for testing and evaluation
• ✅ No credit card required
• ✅ No registration needed
• ✅ 5 regions supported: Korea, Europe, USA/Canada, China, Universal
• ✅ Multiple models to test (pico to large)
• ✅ Works instantly - just install and run!

🚀 Quick Start (30 Seconds)

# Install
pip install marearts-anpr

# Test immediately (NO CONFIG NEEDED!)
ma-anpr test-api your-plate.jpg --region eup

# That's it! 🎉

🌍 Supported Regions

Region Code	Coverage	Example
kr	South Korea	123가4567
eup	Europe (EU standards)	AB-123-CD
na	USA, Canada, Mexico	ABC-1234
cn	China	京A·12345
univ	Universal (all)	Any format

💻 Usage Examples

Command Line (Easiest!)

# European plates
ma-anpr test-api eu-plate.jpg --region eup

# Korean plates
ma-anpr test-api kr-plate.jpg --region kr

# US plates
ma-anpr test-api us-plate.jpg --region na

# Chinese plates
ma-anpr test-api cn-plate.jpg --region cn

# Unknown region? Use universal
ma-anpr test-api unknown-plate.jpg --region univ

Python Script

#!/usr/bin/env python3
import subprocess

def test_free_anpr(image_path, region='eup'):
    """Test free ANPR API - no credentials needed!"""
    
    cmd = f'ma-anpr test-api "{image_path}" --region {region}'
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    
    if result.returncode == 0:
        print(result.stdout)
        return True
    else:
        print(f"Error: {result.stderr}")
        return False

# Test European plate
test_free_anpr("plate.jpg", "eup")

# Test Korean plate
test_free_anpr("plate2.jpg", "kr")

Test Multiple Regions

# Test same image with different regions
for region in eup kr na cn univ; do
    echo "Testing $region..."
    ma-anpr test-api plate.jpg --region $region
done

🎯 Advanced Options

Try Different Models

# List all available models
ma-anpr test-api --list-models

# Try different detector models
ma-anpr test-api plate.jpg --region eup --detector small_640p_fp32
ma-anpr test-api plate.jpg --region eup --detector medium_640p_fp32
ma-anpr test-api plate.jpg --region eup --detector large_640p_fp32

# Try different OCR models
ma-anpr test-api plate.jpg --region eup --ocr small_fp32
ma-anpr test-api plate.jpg --region eup --ocr medium_fp32
ma-anpr test-api plate.jpg --region eup --ocr large_fp32

Batch Testing

# Test all images in a folder
for img in ./plates/*.jpg; do
    echo "Processing $img..."
    ma-anpr test-api "$img" --region eup
done

📊 Sample Output

{
  "results": [
    {
      "ocr": "AB-123-CD",
      "ocr_conf": 98.5,
      "ltrb": [120, 230, 380, 290],
      "ltrb_conf": 95
    }
  ],
  "ltrb_proc_sec": 0.15,
  "ocr_proc_sec": 0.03,
  "status": "success"
}

🆓 FREE vs PAID Comparison

Feature	FREE Test API	Paid License
Requests/Day	1000	Unlimited
Speed	~0.5s (cloud)	~0.02s (local GPU)
Internet Required	Yes	No (offline OK)
Configuration	None	One-time setup
Regions	All 5	All 5
Models	All	All
Price	$0	Contact sales

🎓 Use Cases for Free API

• ✅ Evaluation: Try before buying a license
• ✅ Prototyping: Build POC applications
• ✅ Testing: Test accuracy on your specific plates
• ✅ Education: Learn ANPR/ALPR/LPR technology
• ✅ Small Projects: Personal projects under 1000/day
• ✅ Region Testing: Find which region works best
• ✅ Model Comparison: Compare different model sizes

📈 When to Upgrade to Paid License?

Consider upgrading when you need:

• 🚀 Unlimited requests (no daily limit)
• ⚡ 10-100x faster processing (local GPU)
• 🔒 Offline operation (no internet needed)
• 🏢 Commercial deployment
• 📹 Real-time video processing
• 🎯 High-volume applications (>1000/day)

💡 Pro Tips

# 1. Use specific regions for best accuracy
ma-anpr test-api plate.jpg --region eup  # ✅ Better
ma-anpr test-api plate.jpg --region univ # ⚠️ OK but less accurate

# 2. Test different models to find best speed/accuracy balance
ma-anpr test-api plate.jpg --region eup --detector small_640p_fp32   # Faster
ma-anpr test-api plate.jpg --region eup --detector large_640p_fp32   # More accurate

# 3. Check remaining quota
ma-anpr test-api --check-quota

# 4. Get help
ma-anpr test-api --help

# 5. See all options
ma-anpr test-api --list-models

🔍 Troubleshooting

Rate limit exceeded?

# Wait until midnight UTC (resets daily)
# OR upgrade to paid license for unlimited requests

No plates detected?

# Try different detector models
ma-anpr test-api plate.jpg --region eup --detector large_640p_fp32

# Try universal region
ma-anpr test-api plate.jpg --region univ

Wrong text recognized?

# Make sure you're using correct region!
ma-anpr test-api plate.jpg --region kr   # For Korean plates
ma-anpr test-api plate.jpg --region eup  # For European plates

# Try larger OCR model
ma-anpr test-api plate.jpg --region eup --ocr large_fp32

📖 Complete Example Script

#!/usr/bin/env python3
"""
Free ANPR Test Script
Test license plate recognition with different regions and models
"""
import subprocess
import json

def test_anpr_free(image_path, region='eup', detector='medium_640p_fp32', ocr='medium_fp32'):
    """Test free ANPR API"""
    
    cmd = [
        'ma-anpr', 'test-api', image_path,
        '--region', region,
        '--detector', detector,
        '--ocr', ocr
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode == 0:
        try:
            data = json.loads(result.stdout)
            return data
        except:
            return result.stdout
    else:
        return {"error": result.stderr}

# Test European plate with different models
image = "eu-plate.jpg"

print("Testing different detector models...")
for detector in ['small_640p_fp32', 'medium_640p_fp32', 'large_640p_fp32']:
    result = test_anpr_free(image, 'eup', detector)
    print(f"{detector}: {result}")

print("\nTesting different regions...")
for region in ['eup', 'kr', 'na', 'univ']:
    result = test_anpr_free(image, region)
    print(f"{region}: {result}")

🎯 Real-World Example

# Parking lot monitoring (Europe)
ma-anpr test-api parking-cam.jpg --region eup

# Toll booth (USA)
ma-anpr test-api toll-booth.jpg --region na

# Security gate (Korea)
ma-anpr test-api security-cam.jpg --region kr

# Traffic enforcement (China)
ma-anpr test-api traffic.jpg --region cn

# Multi-national (airport parking)
ma-anpr test-api airport.jpg --region univ

🌟 Why Choose MareArts ANPR?

• ✅ FREE tier available - Try before you buy!
• ✅ State-of-the-art AI - Latest deep learning models
• ✅ Multi-region support - Works worldwide
• ✅ Fast processing - ~0.02s with GPU
• ✅ Easy integration - Python, HTTP API, CLI
• ✅ Regular updates - New models and features
• ✅ Commercial ready - Production-grade quality

🚀 Get Started Now!

# Install (takes 10 seconds)
pip install marearts-anpr

# Test (takes 20 seconds)
ma-anpr test-api your-plate.jpg --region eup

# Celebrate! 🎉
# You just recognized your first license plate!

📞 Need More?

• 🌐 Website: https://www.marearts.com
• 🛒 Purchase: https://www.marearts.com/products/anpr
• 📚 Documentation: Full examples included with package
• 💬 Support: Technical support with paid license

💬 What People Are Saying

"Finally, an ANPR API I can test without entering my credit card!" - Developer

"1000 requests/day is perfect for my small parking lot project." - Small Business Owner

"Tested all 5 regions before buying. Confident in my purchase!" - System Integrator

🎁 Summary

MareArts ANPR offers a completely FREE test API with 1000 requests per day. No credit card, no registration, no strings attached. Just install and start recognizing license plates!

• ✅ Install: pip install marearts-anpr
• ✅ Test: ma-anpr test-api plate.jpg --region eup
• ✅ Evaluate: Try all regions and models
• ✅ Upgrade: When ready for unlimited use

Start your ANPR/ALPR/LPR journey today - completely FREE! 🚗📸

---

MareArts ANPR V14 - Advanced Manual Processing & Performance Tuning

 

⚡ MareArts ANPR V14 - Advanced Manual Processing

Ready to take control? In this advanced guide, I'll show you how to manually process detections, measure performance, and optimize for your specific use case.

🎯 Why Manual Processing?

• Full control over detection pipeline
• Custom filtering and post-processing
• Performance measurement and optimization
• Integration with existing computer vision pipelines
• Custom confidence thresholds per stage

🔧 Manual Detection & OCR Pipeline

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
import cv2
from PIL import Image
import time

# Initialize models
detector = ma_anpr_detector_v14(
    "medium_640p_fp32",
    user_name, serial_key, signature,
    backend="cpu",
    conf_thres=0.25,
    iou_thres=0.5
)

ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Load image
img = cv2.imread("plate.jpg")

# Step 1: Detect license plates
start = time.time()
detections = detector.detector(img)
detection_time = time.time() - start

print(f"Detection time: {detection_time:.4f}s")
print(f"Found {len(detections)} plate(s)")

# Step 2: Process each detection
results = []
ocr_time = 0

for i, box_info in enumerate(detections):
    # Get bounding box
    bbox = box_info['bbox']  # [x1, y1, x2, y2]
    score = box_info['score']  # Detection confidence
    
    # Crop plate region
    x1, y1, x2, y2 = int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])
    crop = img[y1:y2, x1:x2]
    
    if crop.size == 0:
        continue
    
    # Convert to PIL for OCR
    pil_img = Image.fromarray(crop)
    if pil_img.mode != "RGB":
        pil_img = pil_img.convert("RGB")
    
    # Run OCR
    start = time.time()
    text, confidence = ocr.predict(pil_img)
    elapsed = time.time() - start
    ocr_time += elapsed
    
    print(f"Plate {i+1}: {text} ({confidence}%) - {elapsed:.4f}s")
    
    results.append({
        "ocr": text,
        "ocr_conf": confidence,
        "bbox": [x1, y1, x2, y2],
        "det_conf": int(score * 100)
    })

print(f"\nTotal time: {detection_time + ocr_time:.4f}s")

📊 Detection Object Structure

# detector.detector(img) returns list of dictionaries:
[
    {
        'bbox': [x1, y1, x2, y2],  # Bounding box coordinates
        'score': 0.95,              # Detection confidence (0-1)
        'class': 'license_plate'    # Object class
    },
    ...
]

# ocr.predict(pil_image) returns tuple:
("ABC1234", 98.5)  # (text, confidence_percentage)

🚀 Backend Performance Comparison

backends = ["cpu", "cuda"]  # Add "directml" on Windows

for backend_name in backends:
    try:
        print(f"\n🔧 Testing {backend_name}...")
        
        # Initialize with specific backend
        test_detector = ma_anpr_detector_v14(
            "medium_640p_fp32",
            user_name, serial_key, signature,
            backend=backend_name,
            conf_thres=0.25
        )
        
        # Measure performance
        start = time.time()
        detections = test_detector.detector(img)
        elapsed = time.time() - start
        
        print(f"Detected {len(detections)} plates in {elapsed:.4f}s")
        print(f"Speed: {1/elapsed:.1f} FPS")
        
    except Exception as e:
        print(f"⚠️ {backend_name} not available: {e}")

⚙️ Performance Results (Typical)

Backend	Detection	OCR	Total	FPS
CPU (i7)	~0.15s	~0.03s	~0.18s	~5.5
CUDA (RTX 3060)	~0.008s	~0.002s	~0.01s	~100

Result: GPU acceleration = 18x faster! 🚀

🎛️ Custom Filtering

# Filter detections by confidence
min_detection_conf = 0.50
min_ocr_conf = 80.0

filtered_results = []

for box_info in detections:
    if box_info['score'] < min_detection_conf:
        continue  # Skip low confidence detections
    
    # Process with OCR...
    text, conf = ocr.predict(plate_crop)
    
    if conf < min_ocr_conf:
        continue  # Skip low confidence OCR
    
    filtered_results.append({
        "text": text,
        "confidence": conf,
        "bbox": bbox
    })

print(f"After filtering: {len(filtered_results)} high-confidence plates")

🎨 Custom Visualization

import cv2

# Draw boxes and text on image
for result in results:
    x1, y1, x2, y2 = result['bbox']
    text = result['ocr']
    conf = result['ocr_conf']
    
    # Draw rectangle
    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
    
    # Draw text
    label = f"{text} ({conf}%)"
    cv2.putText(img, label, (x1, y1-10), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imwrite("result.jpg", img)

📹 Video Processing Pipeline

import cv2

# Open video
cap = cv2.VideoCapture("traffic.mp4")

frame_count = 0
plate_history = {}

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    frame_count += 1
    
    # Process every N frames (skip frames for speed)
    if frame_count % 5 != 0:
        continue
    
    # Detect plates
    detections = detector.detector(frame)
    
    for det in detections:
        bbox = det['bbox']
        x1, y1, x2, y2 = int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])
        crop = frame[y1:y2, x1:x2]
        
        if crop.size == 0:
            continue
        
        # OCR
        pil_crop = Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB))
        text, conf = ocr.predict(pil_crop)
        
        # Track plates (simple tracking by position)
        plate_id = f"{x1//50}_{y1//50}"
        
        if plate_id not in plate_history:
            plate_history[plate_id] = []
        plate_history[plate_id].append(text)
        
        # Draw
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(frame, text, (x1, y1-10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    cv2.imshow('ANPR', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

# Print detected plates
print("\nDetected plates:")
for plate_id, texts in plate_history.items():
    # Most common text for this plate
    most_common = max(set(texts), key=texts.count)
    print(f"  {most_common} (seen {len(texts)} times)")

💾 Batch Processing from Directory

import os
from pathlib import Path

image_dir = Path("./images")
results_all = {}

for img_path in image_dir.glob("*.jpg"):
    print(f"Processing {img_path.name}...")
    
    img = cv2.imread(str(img_path))
    detections = detector.detector(img)
    
    plates = []
    for det in detections:
        bbox = det['bbox']
        x1, y1, x2, y2 = int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])
        crop = img[y1:y2, x1:x2]
        
        if crop.size > 0:
            pil_crop = Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB))
            text, conf = ocr.predict(pil_crop)
            plates.append({"text": text, "conf": conf})
    
    results_all[img_path.name] = plates

# Save results
import json
with open("results.json", "w") as f:
    json.dump(results_all, f, indent=2)

print(f"\nProcessed {len(results_all)} images")

🎓 Advanced Tips

• GPU Memory: Use cuda backend for 10-100x speedup
• Confidence Tuning: Lower conf_thres to 0.15-0.20 for difficult images
• IOU Threshold: Increase iou_thres to reduce duplicate detections
• Batch Processing: Process multiple crops at once with ocr.predict([img1, img2, ...])
• Frame Skipping: Process every Nth frame in videos for speed
• Multi-threading: Run detector and OCR in separate threads

🔍 Troubleshooting

No detections?

• Lower conf_thres to 0.15
• Try larger model (large_640p_fp32)
• Check image quality and resolution

Wrong OCR results?

• Verify correct region (kr, eup, na, cn)
• Try larger OCR model (large_fp32)
• Check plate crop quality

Slow performance?

• Use GPU backend (cuda or directml)
• Use smaller models (small_640p_fp32, small_fp32)
• Skip video frames
• Batch process multiple images

💡 Conclusion

Manual processing gives you complete control over the ANPR pipeline. Use it for:

• ✅ Custom filtering and validation
• ✅ Performance optimization
• ✅ Video stream processing
• ✅ Integration with existing CV pipelines
• ✅ Advanced visualization and tracking

Happy optimizing! ⚡🚗

---

MareArts ANPR V14 - Easy 3-Method Integration (File, OpenCV, PIL)

🚀 MareArts ANPR V14 - Getting Started in 3 Easy Ways

Welcome to MareArts ANPR V14! Today I'll show you how to process license plates using three different methods: from files, OpenCV, or PIL. Plus, the new multi-region switching feature that saves memory.

📦 Quick Setup

pip install marearts-anpr
ma-anpr config  # Enter your credentials

🎯 Basic Usage - Three Input Methods

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
from marearts_anpr import marearts_anpr_from_image_file, marearts_anpr_from_cv2, marearts_anpr_from_pil
import cv2
from PIL import Image

# Initialize detector and OCR (once)
detector = ma_anpr_detector_v14(
    "medium_640p_fp32",
    user_name, serial_key, signature,
    backend="cpu",
    conf_thres=0.25
)

ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Method 1: From file (easiest!)
result = marearts_anpr_from_image_file(detector, ocr, "plate.jpg")
print(result)

# Method 2: From OpenCV
img = cv2.imread("plate.jpg")
result = marearts_anpr_from_cv2(detector, ocr, img)
print(result)

# Method 3: From PIL
pil_img = Image.open("plate.jpg")
result = marearts_anpr_from_pil(detector, ocr, pil_img)
print(result)

🌍 NEW: Dynamic Region Switching (Saves 180MB!)

Previously, you needed separate OCR instances for each region. Now use set_region():

# Initialize once with any region
ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Switch regions instantly!
ocr.set_region('eup')   # European plates
result = marearts_anpr_from_image_file(detector, ocr, "eu-plate.jpg")

ocr.set_region('kr')    # Korean plates  
result = marearts_anpr_from_image_file(detector, ocr, "kr-plate.jpg")

ocr.set_region('na')    # North American plates
result = marearts_anpr_from_image_file(detector, ocr, "us-plate.jpg")

ocr.set_region('cn')    # Chinese plates
ocr.set_region('univ')  # Universal

Memory savings: Single instance vs multiple = ~180MB saved per additional region!

📊 Available Regions

• kr - Korean plates (123가4567)
• eup - European plates (EU standards)
• na - North American plates (USA, Canada, Mexico)
• cn - Chinese plates (京A·12345)
• univ - Universal (all regions, slightly lower accuracy)

🎨 Batch Processing

# Detect plates from multiple images
img1 = cv2.imread("plate1.jpg")
img2 = cv2.imread("plate2.jpg")

detections1 = detector.detector(img1)
detections2 = detector.detector(img2)

# Collect plate crops
plates = []
for det in detections1:
    bbox = det['bbox']
    crop = img1[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])]
    plates.append(Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)))

for det in detections2:
    bbox = det['bbox']
    crop = img2[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])]
    plates.append(Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)))

# Process all plates at once!
results = ocr.predict(plates)  # Pass list of images

for i, (text, conf) in enumerate(results):
    print(f"Plate {i+1}: {text} ({conf}%)")

🔧 Model Options

Detector models:

• pico_640p_fp32 - Smallest, fastest
• micro_640p_fp32
• small_640p_fp32
• medium_640p_fp32 - Recommended balance
• large_640p_fp32 - Most accurate

OCR models:

• pico_fp32 - Fastest
• micro_fp32
• small_fp32
• medium_fp32 - Recommended
• large_fp32 - Best accuracy

Backends:

• cpu - Works everywhere
• cuda - NVIDIA GPU (10-100x faster!)
• directml - Windows GPU

📝 Complete Example

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
from marearts_anpr import marearts_anpr_from_image_file
import os

# Load credentials
user_name = os.getenv('MAREARTS_ANPR_USERNAME')
serial_key = os.getenv('MAREARTS_ANPR_SERIAL_KEY')
signature = os.getenv('MAREARTS_ANPR_SIGNATURE')

# Initialize models
detector = ma_anpr_detector_v14(
    "medium_640p_fp32",
    user_name, serial_key, signature,
    backend="cpu",
    conf_thres=0.25,
    iou_thres=0.5
)

ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Process European plate
print("Processing European plate...")
result = marearts_anpr_from_image_file(detector, ocr, "eu-plate.jpg")
print(result)

# Switch to Korean region
ocr.set_region('kr')
print("\nProcessing Korean plate...")
result = marearts_anpr_from_image_file(detector, ocr, "kr-plate.jpg")
print(result)

💡 Key Takeaways

• ✅ Three input methods: file, OpenCV, PIL
• ✅ Dynamic region switching saves memory
• ✅ Batch processing for efficiency
• ✅ Multiple model sizes for different needs
• ✅ GPU acceleration available

🔗 Try It Free!

No license yet? Try the free API (1000 requests/day):

ma-anpr test-api your-plate.jpg --region eup

Happy coding! 🚗📸

---

Labels:

ANPR python SDK (ANPR, LPR, ALPR solution)

 

🚙🚙 AUTOMATIC NUMBER PLATE RECOGNITION (ANPR, LPR, ALPR) solution 🏡 detail here : ANPR iOS APP https://apps.apple.com/app/marearts-anpr/id6753904859 ANPR SDK https://www.marearts.com/pages/marearts-anpr-sdk 🤖 Live Test : http://live.marearts.com 🔗 GitHub Repository : https://github.com/MareArts/MareArts-ANPR 🇪🇺 ANPR EU (European Union) Auto Number Plate Recognition for EU countries 🦋 Available Countries: (We are adding more contries.) 🇦🇱 Albania 🇦🇩 Andorra 🇦🇹 Austria 🇧🇪 Belgium 🇧🇦 Bosnia and Herzegovina 🇧🇬 Bulgaria 🇭🇷 Croatia 🇨🇾 Cyprus 🇨🇿 Czechia 🇩🇰 Denmark 🇫🇮 Finland 🇫🇷 France 🇩🇪 Germany 🇬🇷 Greece 🇭🇺 Hungary 🇮🇪 Ireland 🇮🇹 Italy 🇱🇮 Liechtenstein 🇱🇺 Luxembourg 🇲🇹 Malta 🇲🇨 Monaco 🇲🇪 Montenegro 🇳🇱 Netherlands 🇲🇰 North Macedonia 🇳🇴 Norway 🇵🇱 Poland 🇵🇹 Portugal 🇷🇴 Romania 🇸🇲 San Marino 🇷🇸 Serbia 🇸🇰 Slovakia 🇸🇮 Slovenia 🇪🇸 Spain 🇸🇪 Sweden 🇨🇭 Switzerland 🇬🇧 United Kingdom 🇮🇩 Indonesia,.. 🇰🇷 ANPR KR (Korea) 🇨🇳 China ANPR North America 🇺🇸 🇨🇦🇲🇽 📧 Email us: hello@marearts.com, ask.marearts@gmail.com for further information. 📺 ANPR Result Videos https://www.youtube.com/playlist?list=PLvX6vpRszMkxJBJf4EjQ5VCnmkjfE59-J #anpr, #lpr, #marearts, #marearts-anpr, #licensepalterecognition anpr, lpr, marearts, marearts-anpr, licensepalterecognition

MareArts ANPR mobile app

MareArts ANPR mobile app 

Download on App Store https://apps.apple.com/app/marearts-anpr/id6753904859 Experience the power of MareArts ANPR directly on your mobile device! Fast, accurate, on-device license plate recognition for parking management, security, and vehicle tracking. ✨ Key Features: 🚀 Fast on-device AI processing 🔒 100% offline - privacy first 📊 Statistics and analytics 🗺️ Map view with GPS tracking ✅ Whitelist/Blacklist management 🌍 Multi-region support Home page: www.marearts.com GitHub : https://github.com/MareArts/MareArts-ANPR 🤖 Live Test : http://live.marearts.com Supported countries 🇪🇺 ANPR EU (European Union) Auto Number Plate Recognition for EU countries 🦋 Available Countries: (We are adding more contries.) 🇦🇱 Albania 🇦🇩 Andorra 🇦🇹 Austria 🇧🇪 Belgium 🇧🇦 Bosnia and Herzegovina 🇧🇬 Bulgaria 🇭🇷 Croatia 🇨🇾 Cyprus 🇨🇿 Czechia 🇩🇰 Denmark 🇫🇮 Finland 🇫🇷 France 🇩🇪 Germany 🇬🇷 Greece 🇭🇺 Hungary 🇮🇪 Ireland 🇮🇹 Italy 🇱🇮 Liechtenstein 🇱🇺 Luxembourg 🇲🇹 Malta 🇲🇨 Monaco 🇲🇪 Montenegro 🇳🇱 Netherlands 🇲🇰 North Macedonia 🇳🇴 Norway 🇵🇱 Poland 🇵🇹 Portugal 🇷🇴 Romania 🇸🇲 San Marino 🇷🇸 Serbia 🇸🇰 Slovakia 🇸🇮 Slovenia 🇪🇸 Spain 🇸🇪 Sweden 🇨🇭 Switzerland 🇬🇧 United Kingdom 🇮🇩 Indonesia,.. 🇰🇷 ANPR KR (Korea) 🇨🇳 China ANPR North America 🇺🇸 🇨🇦🇲🇽 Thank you!