Technical implementation

Building the evaluation engine

While analytics provide contextual intelligence, real-time compliance validation requires a different approach. It must extract, classify, and evaluate creative elements within seconds.

Logo placement and sizing represent one of the most critical compliance requirements across brand guidelines. A misplaced or incorrectly sized logo can undermine brand recognition and violate strict corporate identity standards.

Turns out, logo detection isn't straightforward. We implemented two complementary approaches, each optimized for different accuracy-speed trade-offs.

Approach 1 - Advanced SIFT-based detection

The sophisticated approach combines text matching, Scale-Invariant Feature Transform (SIFT) feature detection, and geometric shape analysis for precise logo identification in challenging conditions like rotated images, distorted perspectives, and partial occlusions.

1. Text region detection

Extract text annotations from Google Vision API, identifying potential logo text components. For multi-word logos (e.g., "Mercedes Benz"), the system merges adjacent bounding boxes.

# For multi-word logos, merge adjacent bounding boxes
if i > 0:
    merged_box = merge_bounding_boxes(matched_regions[-1], matching_annotations[0])
    matched_regions[-1] = merged_box

2. Expanded cutout creation

Generate expanded regions around matched text using logo proportions. This accounts for graphic elements surrounding logo text.

Expansion distance formulas

For rotated bounding boxes, the system calculates rotation angle and applies perspective transformation.

Rotation angle

Rotated bounding box dimensions

3. SIFT feature extraction and matching

SIFT (Scale-Invariant Feature Transform) identifies distinctive keypoints invariant to scale, rotation, and illumination changes. The algorithm extracts features from both reference logo and candidate cutouts, then matches them.

SIFT similarity score calculation

The algorithm calculates a match ratio based on good matches (those passing Lowe's ratio test):

It computes a quality factor based on average matching distance:

These combine into a raw score:

A sigmoid transformation normalizes the score to [-1, 1] range:

This sigmoid normalization makes scores cluster near -1 (poor match) or +1 (excellent match), creating clear decision boundaries.

4. Geometric shape detection

Supplement feature matching with shape analysis to detect logo containers (circles, rectangles, ellipses, triangles).

Circularity calculation (distinguishes circles from other shapes).

• Perfect circle: circularity ~ 1.0

• Rectangle or irregular shape: circularity < 0.8

Ellipse eccentricity (measures elongation).

• Circle: eccentricity = 0

• Elongated ellipse: eccentricity approaches 1

For detected ellipses, the system calculates parametric boundary points.

where α represents rotation angle in radians.

5. Confidence scoring and output

Combine SIFT scores, shape detection results, and text matching confidence into final logo detection output.

{
  "logo_found": true,
  "position": {
    "x": 0.12,
    "y": 0.05,
    "width": 0.15,
    "height": 0.08
  },
  "confidence": 0.94,
  "sift_score": 0.89,
  "shape_detected": "rectangle",
  "text_matched": true
}

Approach 2 - Fast Google Vision API detection

For real-time workflows requiring immediate feedback, the streamlined approach uses Google Vision API's built-in logo detection with intelligent post-processing.

1. API logo detection

const [logoDetection] = await visionClient.logoDetection(imageBuffer);
const logos = logoDetection.logoAnnotations;

2. Confidence filtering

Apply minimum confidence threshold (80%) to eliminate false positives.

const LOGO_DETECTION_OCR_CONFIDENCE = 0.8;
const highConfidenceLogos = logos.filter(
  logo => logo.score >= LOGO_DETECTION_OCR_CONFIDENCE
);

3. Intersection-based filtering

Remove logos incorrectly detected within other objects (except persons and specific edge cases). This prevents false positives where brand elements on clothing or products get misidentified.

Rectangle overlap calculation

Overlapping area

Overlap percentage

Subset determination

A logo is considered a subset of another object if:

This 90% threshold filters only truly contained logos, while maintaining boundary logos.

4. Normalized position extraction

Convert absolute pixel coordinates to normalized percentages for size-independent representation:

Area percentage calculation

When to use each approach

Use Fast Vision API for real-time designer feedback, standard orientations, and high-quality source images. Use Advanced SIFT for batch processing, rotated or distorted images, custom logo databases, and cost-sensitive workflows.

Three core technologies work together.

• Pillar 1: Optical Character Recognition (OCR) - Extracts all text content from creatives, including position, size, and formatting information. OCR excels at comprehensive text detection but can't classify element purpose.

• Pillar 2: Machine Learning Image Classification - Identifies and labels visual elements (logo, hero image, call-to-action button, terms and conditions, background). Classification gives structure but not content understanding.

• Pillar 3: Natural Language Processing (NLP) - Analyzes extracted text for semantic violations (designation mentions, non-inclusive language, alcohol references, prohibited claims). NLP understands content but lacks visual context.

Each technology has distinct strengths and limitations. The challenge lies in combining them to multiply strengths while minimizing compounded errors.

Here's the problem: combining three independent technologies with individual error rates creates multiplicative error. If OCR has 95% accuracy, classification has 92% accuracy, and NLP has 94% accuracy, naive combination yields:

0.95 × 0.92 × 0.94 = 0.822 (82.2% combined accuracy)

This 18% error rate isn't acceptable for brand compliance. The solution lies in intelligent intersection rather than simple concatenation. The solution lies in intelligent intersection. OCR extracts all text with bounding boxes:

{
  "text": "Limited Time Offer",
  "confidence": 0.97,
  "boundingBox": {
    "x": 120,
    "y": 80,
    "width": 340,
    "height": 60
  }
}

ML classification identifies element regions and labels:

{
  "elementType": "call_to_action",
  "confidence": 0.94,
  "boundingBox": {
    "x": 100,
    "y": 70,
    "width": 380,
    "height": 80
  }
}

Geometric intersection matches OCR text blocks with ML element regions through overlap calculation. This uses multiple algorithms to ensure accurate element association.

Geometric matching algorithms

Several computational geometry techniques match OCR text blocks with ML-classified element regions:

• Point-in-polygon test (ray casting) - Determines if text center points fall within classified element boundaries using O(n) ray casting. Odd intersection count indicates point inside polygon; even count indicates outside.

• Rectangle overlap calculation - Computes the percentage of overlap between two bounding boxes by finding the intersection area and dividing by the smaller box's area.

// Calculate overlap area as percentage of first box
const xOverlap = Math.max(0, Math.min(box1.x + box1.width, box2.x + box2.width) - Math.max(box1.x, box2.x));
const yOverlap = Math.max(0, Math.min(box1.y + box1.height, box2.y + box2.height) - Math.max(box1.y, box2.y));
return (xOverlap * yOverlap) / (box1.width * box1.height);

• Line intersection (determinant method) - For rotated bounding boxes, uses 2x2 determinants to calculate line segment intersections. This method handles parallel lines gracefully without special cases.

• Angle calculations - When matching rotated text blocks with classified elements, the system calculates relative angles to ensure orientation alignment (typically requiring <15° difference).

• Perpendicular line calculation - For creating parallel boundaries around text regions, the system calculates perpendicular unit vectors by rotating the segment vector 90 degrees and normalizing by its Euclidean length.

Merging intersection results

// Match OCR text blocks with classified elements
const matchingElements = mlResults
  .map(element => ({
    element,
    overlap: calculateOverlap(textBlock.boundingBox, element.boundingBox),
    angleAlignment: calculateAngleAlignment(textBlock.rotation, element.rotation)
  }))
  .filter(match => match.overlap > 0.7 && match.angleAlignment < 15)
  .sort((a, b) => b.overlap - a.overlap);

Confidence-weighted filtering happens next. Only process elements meeting combined confidence thresholds:

• Individual technology confidence > 90%

• Geometric overlap > 70%

• Combined confidence (minimum of individual scores) > 85%

This approach reduces error multiplication by rejecting low-confidence matches rather than compounding uncertainty. NLP semantic analysis completes the process. Apply NLP only to high-confidence text-element pairs:

// Example: Check for designation mentions
if (containsDesignation(element.text)) {
  violations.push({
    type: 'designation_mention',
    severity: 'high',
    message: 'Text contains job titles/designations which may violate guidelines'
  });
}
// Similar checks for alcohol references, case requirements, etc.

Calibration mechanisms enable continuous improvement. Calibration happens through:

• Overlap threshold tuning - Initial deployment used 60% overlap threshold, resulting in false positives where partial text overlap incorrectly associated unrelated elements. Analysis of 10,000 creatives determined 70% overlap optimal for balancing precision (minimize false positives) and recall (minimize false negatives).

• Confidence threshold adaptation - Different element types exhibit different baseline confidence scores. CTA buttons consistently achieve 95%+ classification confidence, while decorative elements average 78%. We maintain element-type-specific thresholds rather than global thresholds.

• Iterative testing - Each calibration adjustment undergoes A/B testing:

  • Process 1,000 creatives with current thresholds

  • Process same 1,000 with adjusted thresholds

  • Human expert review of differences

  • Adopt configuration minimizing false positives while maintaining recall

The rule engine for flexible compliance

After extracting and enriching creative data, the final component validates compliance through configurable rules. Traditional hard-coded validation logic becomes unmaintainable as brands add, modify, or remove guidelines. A declarative rule engine solves this problem.

We use a declarative rule engine built on the json-rules-engine library.

Built on the json-rules-engine library, the system extends basic boolean logic with custom operators for creative-specific evaluations.

Core principles

1. Declarative configuration - Rules defined in JSON, not code

2. Composable operations - Complex rules built from simple primitives

3. Extensible operators - Custom logic for spatial relationships, aggregations

4. Performance optimization - Compiled rule sets for repeated execution

Rules execute in two-phase workflows:

Phase 1 - Filter

Select relevant elements based on criteria:

{
  "type": "filter",
  "key": "styles",
  "outputKey": "textElements",
  "ruleJson": {
    "all": [
      {
        "any": [
          { "fact": "elementType", "operator": "equal", "value": "text" },
          { "fact": "elementType", "operator": "equal", "value": "headline" }
        ]
      },
      { "fact": "area", "operator": "greaterThan", "value": 0 }
    ]
  }
}

What this filter does

• Selects elements where elementType is "text" OR "headline"

• AND where calculated area exceeds 0

• Stores results in textElements array

Phase 2 - Aggregate

Perform calculations on filtered elements:

{
  "type": "aggregate",
  "ruleJson": {
    "any": [
      { "fact": "sum_value", "operator": "greaterThan", "value": 50,
        "params": { "array": "textElements", "key": "area", "groupBy": "size", "groupByVal": "max" }
      },
      { "fact": "sum_value", "operator": "lessThan", "value": 30,
        "params": { "array": "textElements", "key": "area", "groupBy": "size", "groupByVal": "min" }
      }
    ]
  }
}

What this aggregation does

• Sums area values from textElements

• Groups by creative size (e.g., 1080x1920, 1200x628)

• Takes maximum sum per group OR minimum sum per group

• Triggers violation if max exceeds 50% OR min falls below 30%

Here's a complete example.

A common requirement states: "Text elements must not overlap with person images." Implementation requires spatial relationship evaluation.

Creating a custom position intersection operator

// Check if two rectangles overlap
const horizontalOverlap = !(pos1.left + pos1.width < pos2.left || pos2.left + pos2.width < pos1.left);
const verticalOverlap = !(pos1.top + pos1.height < pos2.top || pos2.top + pos2.height < pos1.top);
return horizontalOverlap && verticalOverlap;

// Register as custom operator
engine.addOperator('intersects', (factValue, jsonValue) => checkIntersection(factValue, jsonValue));

Rule definition

{
  "_id": "noTextPersonOverlap",
  "name": "Text-Person Separation",
  "message": "Text elements should not overlap with person images",
  "severity": "high",
  "rules": [
    { "type": "filter", "key": "styles", "outputKey": "textElements",
      "ruleJson": { "fact": "elementType", "operator": "equal", "value": "text" }
    },
    { "type": "filter", "key": "styles", "outputKey": "personImages",
      "ruleJson": {
        "all": [
          { "fact": "elementType", "operator": "equal", "value": "image" },
          { "fact": "contentTag", "operator": "contains", "value": "person" }
        ]
      }
    },
    { "type": "validate",
      "ruleJson": {
        "all": [{ "fact": "textElements", "operator": "notIntersects", "value": "personImages" }]
      }
    }
  ]
}

Execution flow

Filter all text elements -> textElements array

1. Filter all person images -> personImages array

2. For each text element, check intersection with each person image

3. If any intersection exists, rule fails

Rules stored in the database enable runtime updates without deployment.

Rules stored in MongoDB enable runtime updates without deployment:

// Fetch active rules for this brand
const rules = await db.collection('complianceRules').find({
  ownerId: creativeData.teamId,
  isDeleted: false
}).toArray();

// Initialize engine and execute evaluation
const engine = new Engine();
rules.forEach(rule => engine.addRule(rule));
const results = await engine.run(creativeData);

return {
  compliant: results.events.length === 0,
  violations: results.events.map(event => ({
    ruleName: event.params.rule.name,
    message: event.params.rule.message
  }))
};

Brands can add new rules through UI without engineering involvement:

1. Designer defines requirement: "Logos must not exceed 8% of canvas"

2. System translates to rule JSON

3. Rule activates immediately for new creative evaluations

4. Historical creatives remain unaffected (rules apply prospectively)

Cost optimization strategies

AI-powered compliance systems involve significant computational expense. We've found that strategic optimization balances cost against user experience.

Two prediction modes are available:

• Online prediction provides immediate feedback during design. Higher per-request cost (~$0.002 per creative), but enables interactive workflows. Best for real-time designer validation.

• Batch prediction offers delayed feedback (15-30 minutes) at lower per-request cost (~$0.0003 per creative via batching). Requires accumulated workload. Best for overnight campaign validation and historical audits.

• Hybrid approach combines both. Priority creatives (designer actively editing) use online prediction. Background validation (automated generations) uses batch. This reduces costs by ~60% compared to pure online.

Different deployment strategies suit different scales.

Managed ML services

• Simplest deployment (Google AutoML, AWS SageMaker)

• Highest cost ($0.50-$2.00 per 1000 predictions)

• Minimal maintenance burden

Self-hosted models on Kubernetes

• Custom model deployment

• Lowest variable cost ($0.05-$0.15 per 1000 predictions)

• Higher fixed cost (infrastructure, DevOps)

• Optimal when: >100,000 validations/month

Cost crossover analysis

Managed service: Fixed=$0, Variable=$1.00 per 1000
Self-hosted: Fixed=$2000/month, Variable=$0.10 per 1000

Break-even volume: Fixed / (Managed_Variable - SelfHosted_Variable)
= $2000 / ($1.00 - $0.10)
= 2,222,222 predictions/month
= ~74,000 predictions/day

Recommendation: Self-hosted justified at >75k daily validations

Rocketium's scale (10,000+ creatives/day, each requiring 2-3 model calls) justifies self-hosted infrastructure, achieving 73% cost reduction compared to managed services.