410  WSN Coverage: Worked Examples and Practice

410.1 Learning Objectives

By the end of this chapter, you will be able to:

• Perform k-Coverage Analysis: Calculate coverage levels and identify gaps in sensor deployments
• Design Energy-Efficient Schedules: Compute duty cycling parameters for multi-year deployments
• Analyze Sensing Range Trade-offs: Evaluate total cost of ownership for different sensor options
• Apply Coverage Theory: Use worked examples as templates for real-world deployment planning
• Experiment with Coverage: Use interactive tools to visualize and optimize sensor placement

TipFor Beginners: Understanding Coverage Worked Examples

What is this chapter? This chapter provides step-by-step worked examples that show how to apply coverage theory to real-world problems.

Key Examples:

Example	Focus	Application
k-Coverage Analysis	Coverage gaps and remediation	Water treatment facility
Duty Cycling Budget	Energy-efficient scheduling	Wildlife tracking WSN
Sensing Range Trade-off	Total cost of ownership	Building automation

Why Practice Matters: - Theory without practice doesn’t solve real problems - Worked examples show complete solution workflows - Interactive tools let you experiment without costly mistakes

410.2 Prerequisites

Before diving into this chapter, you should be familiar with:

• WSN Coverage: Core Concepts: Coverage fundamentals and the Zhang-Hou theorem
• WSN Coverage: Problem Types: Area, point, and barrier coverage formulations

410.3 Worked Example: k-Coverage Analysis for Critical Infrastructure

NoteProblem Statement: Water Treatment Facility Monitoring

A water treatment facility requires continuous monitoring of chemical processes, water quality, and equipment status. Due to the critical nature of water safety, the facility mandates 2-coverage (every point monitored by at least 2 sensors) to ensure no blind spots exist even if one sensor fails.

Given Parameters:

Parameter	Value
Monitoring area	100m x 100m (10,000 m²)
Sensor sensing range (Rs)	20m (circular)
Communication range (Rc)	50m (satisfies Zhang-Hou: Rc ≥ 2Rs)
Deployed sensors	12 sensors
Coverage requirement	2-coverage (k = 2)

Sensor Deployment Positions:

Sensor	X (m)	Y (m)	Sensor	X (m)	Y (m)
S1	20	20	S7	20	80
S2	50	20	S8	50	80
S3	80	20	S9	80	80
S4	20	50	S10	35	50
S5	50	50	S11	65	50
S6	80	50	S12	50	50

410.3.1 Solution Step 1: Individual Sensor Coverage Area

First, calculate the coverage area of each sensor using the Boolean sensing model:

\[ A_{sensor} = \pi \times R_s^2 = \pi \times 20^2 = 1,257 \text{ m}^2 \]

Total theoretical coverage (no overlap): \[ A_{total} = 12 \times 1,257 = 15,084 \text{ m}^2 \]

Coverage ratio (theoretical): \[ \frac{A_{total}}{A_{facility}} = \frac{15,084}{10,000} = 1.51 \]

This 151% theoretical coverage suggests adequate sensors for 1-coverage, but does not guarantee 2-coverage due to overlap distribution.

410.3.2 Solution Step 2: Grid Point Analysis Method

To verify k-coverage, we discretize the facility into a grid and count covering sensors for each point.

Grid Configuration: - Grid spacing: 5m x 5m - Grid points: 21 x 21 = 441 points (including boundaries) - Analysis points: 400 interior points (20 x 20)

For each grid point (x, y), count sensors within range:

\[ \text{Coverage count at } (x,y) = \sum_{i=1}^{12} \mathbf{1}\left[\sqrt{(x - x_i)^2 + (y - y_i)^2} \leq 20\right] \]

Sample Calculations:

Grid Point	Distance to S1	Distance to S2	Distance to S5	Distance to S10	Distance to S12	Coverage Count
(25, 25)	7.07m ✓	25.5m ✗	35.4m ✗	27.0m ✗	35.4m ✗	1
(35, 35)	21.2m ✗	21.2m ✗	21.2m ✗	15.0m ✓	21.2m ✗	1
(50, 50)	42.4m ✗	30.0m ✗	0.0m ✓	15.0m ✓	0.0m ✓	3*

*Note: S5 and S12 are at the same position (50,50), so point (50,50) is covered by S5, S10, S11, and S12 = 4 sensors.

410.3.3 Solution Step 3: Complete k-Coverage Analysis

Graph diagram

Figure 410.1: k-Coverage distribution for water treatment facility: 12 sensors achieve 46% 2-coverage (green) and 12% 3+-coverage (blue), totaling 58% meeting the 2-coverage requirement. 39% has only 1-coverage (orange), and 3% has coverage holes (red).

{fig-alt=“k-Coverage analysis diagram showing water treatment facility area of 100m x 100m with 400 grid points distributed into four coverage levels: 0-coverage holes (12 points, 3%, red), 1-coverage single (156 points, 39%, orange), 2-coverage target (184 points, 46%, teal), and 3+-coverage redundant (48 points, 12%, blue), with final result showing 58% 2-coverage achievement”}

Detailed Coverage Distribution:

Coverage Level	Grid Points	Percentage	Status
0-coverage (holes)	12	3.0%	CRITICAL - No monitoring
1-coverage	156	39.0%	WARNING - Single point of failure
2-coverage	184	46.0%	ACCEPTABLE - Meets requirement
3+-coverage	48	12.0%	REDUNDANT - Fault tolerant

2-Coverage Achievement: 184 + 48 = 232 points (58%) meet the 2-coverage requirement.

410.3.4 Solution Step 4: Gap Analysis and Location

The 12 coverage holes (0-coverage points) and 156 single-coverage points are concentrated in specific regions:

Graph diagram

Figure 410.2: Coverage gap locations: The four corners of the facility have insufficient coverage because edge sensors (like S1 at position 20,20) are placed 20m from walls, leaving corner regions beyond their 20m sensing range.

{fig-alt=“Gap analysis diagram showing coverage holes concentrated in facility corners: Northwest corner (0-10, 90-100) with 4 hole points, Northeast corner (90-100, 90-100) with 4 hole points, Southwest corner (0-10, 0-10) with 2 hole points, and Southeast corner (90-100, 0-10) with 2 hole points. Root cause identified as edge sensors placed 20m from walls leaving corners uncovered. Recommended fix: add sensors at (10,10) and (90,90).”}

Gap Location Summary:

Region	Coordinates	Hole Points	1-Coverage Points	Issue
NW Corner	(0-10, 90-100)	4	15	Nearest sensor S7 at (20,80)
NE Corner	(90-100, 90-100)	4	18	Nearest sensor S9 at (80,80)
SW Corner	(0-10, 0-10)	2	12	Nearest sensor S1 at (20,20)
SE Corner	(90-100, 0-10)	2	14	Nearest sensor S3 at (80,20)
Total Gaps	—	12	59	Corners beyond Rs from edge sensors

410.3.5 Solution Step 5: Remediation Plan

To achieve 100% 2-coverage, we need to add sensors to cover corner regions:

Proposed Additional Sensors:

New Sensor	Position	Coverage Contribution
S13	(10, 10)	Covers SW corner, overlaps with S1, S4
S14	(90, 90)	Covers NE corner, overlaps with S9, S6
S15	(10, 90)	Covers NW corner, overlaps with S7, S4
S16	(90, 10)	Covers SE corner, overlaps with S3, S6

After Adding 4 Corner Sensors:

Coverage Level	Before	After	Change
0-coverage	12 (3%)	0 (0%)	-12 points
1-coverage	156 (39%)	48 (12%)	-108 points
2-coverage	184 (46%)	304 (76%)	+120 points
3+-coverage	48 (12%)	48 (12%)	No change

Final 2-Coverage: 304 + 48 = 352 points (88%) — significant improvement but still not 100%.

For Full 100% 2-Coverage: Add 2 more sensors at (50, 10) and (50, 90) to cover edge midpoints:

Sensor	Position	Purpose
S17	(50, 10)	South edge midpoint
S18	(50, 90)	North edge midpoint

Final Configuration: 18 sensors achieve 100% 2-coverage for the water treatment facility.

410.3.6 Final Answer

Importantk-Coverage Analysis Summary

Initial State (12 sensors): - 2-coverage achieved: 58% of facility area - Coverage holes: 3% (12 grid points) — unacceptable for critical infrastructure - Single coverage risk: 39% (156 points) — vulnerable to single sensor failure

Remediation Required: - Minimum fix: Add 2 sensors at (10,10) and (90,90) to eliminate coverage holes - Full 2-coverage fix: Add 6 sensors (4 corners + 2 edge midpoints) → 18 total sensors

Cost-Benefit Analysis: | Configuration | Sensors | 2-Coverage | Investment | Risk Level | |————–|———|————|————|————| | Current | 12 | 58% | Baseline | HIGH | | +2 corners | 14 | 72% | +17% cost | MEDIUM | | +4 corners | 16 | 88% | +33% cost | LOW | | +6 (full) | 18 | 100% | +50% cost | MINIMAL |

Recommendation: For critical water treatment infrastructure, the +50% sensor investment to achieve 100% 2-coverage is justified by: 1. Regulatory compliance — water safety standards require redundant monitoring 2. Liability protection — documented 2-coverage demonstrates due diligence 3. Operational continuity — any sensor failure still maintains 1-coverage

410.3.7 Interpretation: Why k-Coverage Matters for Critical Infrastructure

This worked example illustrates several key principles:

1. Theoretical vs. Practical Coverage: Even with 151% theoretical coverage ratio, only 58% of the area achieved the required 2-coverage level. Sensor placement geometry matters more than raw sensor count.

2. Edge Effects: Corner regions are inherently problematic in rectangular deployments. Sensors must be positioned closer to boundaries than their sensing range to eliminate corner gaps.

3. Fault Tolerance Quantification: In the original deployment, 42% of the facility would have no backup monitoring if a single sensor failed — unacceptable for water treatment where chemical leaks or contamination events require immediate detection.

4. Cost-Coverage Trade-off: Achieving 100% k-coverage typically requires 30-50% more sensors than 100% 1-coverage. This premium is justified for critical infrastructure but may be excessive for non-critical applications.

5. Grid Analysis Method: The 5m grid discretization provides sufficient resolution (400 analysis points) to identify coverage patterns while remaining computationally tractable. Finer grids (2m spacing = 2,500 points) provide more precision but may be overkill for planning purposes.

---

410.4 Worked Example: Duty Cycling Energy Budget for Multi-Year Deployment

NoteScenario: Wildlife Tracking WSN

A wildlife tracking WSN monitors animal migration corridors in a remote forest preserve. The deployment must operate for 5 years without battery replacement due to access constraints (helicopter-only site access costs $15,000 per visit).

Given:

Parameter	Value
Sensor nodes	50
Sensing range (Rs)	15 m (PIR motion + temperature)
Battery capacity	19,000 mAh (D-cell lithium)
Active mode current	28 mA (sensor + radio TX)
Receive mode current	18 mA (radio listening)
Sleep mode current	12 uA
Sensing event frequency	3 detections/day average
Data packet size	200 bytes
Transmission time	50 ms per packet
Target lifetime	5 years (43,800 hours)

Steps:

1. Calculate required average current for 5-year lifetime:
   • Target lifetime = 5 years = 43,800 hours
   • Required average current: I_avg = 19,000 mAh / 43,800 h = 0.434 mA = 434 uA
2. Calculate energy budget per day:
   • Daily energy = 19,000 mAh / (5 x 365 days) = 10.4 mAh per day
   • In mA-hours: 10.4 mAh = 10,400 uAh available daily
3. Calculate fixed daily active time for sensing events:
   • 3 events/day x 50 ms TX time = 150 ms TX per day
   • TX energy: 28 mA x (150 ms / 3,600,000 ms/h) = 0.00117 mAh per day
   • This is negligible (<0.02% of budget)
4. Calculate maximum duty cycle for listening mode:
   • Remaining budget: 10.4 mAh - 0.00117 mAh = ~10.4 mAh for duty cycling
   • Let D = duty cycle (fraction)
   • Average current = D x I_receive + (1-D) x I_sleep
   • 434 uA = D x 18,000 uA + (1-D) x 12 uA
   • 434 = 18,000D + 12 - 12D
   • 422 = 17,988D
   • D = 422 / 17,988 = 0.0235 = 2.35%
5. Calculate wake schedule from duty cycle:
   • 2.35% duty cycle = 2.35% of each hour awake
   • Active time per hour: 0.0235 x 3,600 s = 84.6 seconds per hour
   • Sleep time per hour: 3,515.4 seconds
   • Schedule: Wake for 85 seconds, sleep for 3,515 seconds, repeat
6. Verify energy calculation:
   • Average current = (0.0235 x 18 mA) + (0.9765 x 0.012 mA)
   • Average current = 0.423 mA + 0.0117 mA = 0.435 mA (matches target)
7. Calculate detection latency:
   • Maximum time between wake-ups: 3,515 seconds = 58.6 minutes
   • Average detection latency: 3,515 / 2 = 29.3 minutes
   • For wildlife tracking (slow-moving animals), this latency is acceptable

Result:

Metric	Value	Assessment
Duty cycle	2.35%	Achievable with standard protocols
Wake time per hour	85 seconds	Sufficient for RX + TX
Maximum detection latency	58.6 minutes	Acceptable for migration tracking
Battery lifetime	5 years	Meets requirement
Cost savings	$75,000	Avoids 5 battery replacement visits

Key Insight: The 2.35% duty cycle provides a practical balance for wildlife monitoring. The key realization is that receive mode dominates energy consumption, not transmission. Even though TX current (28 mA) exceeds RX current (18 mA), the sensor spends far more time listening for coordination messages than transmitting data. For event-driven applications with low event rates (3/day), the event sensing and TX energy is negligible compared to the duty-cycling RX overhead. Designers should optimize listening schedules first, then worry about transmission efficiency.

---

410.5 Worked Example: Sensing Range vs Communication Range Trade-off

NoteScenario: Building Automation System

A building automation system monitors occupancy across a 3-floor office building. The architect must decide between two sensor options with different sensing and communication range characteristics.

Given:

Parameter	Option A (Short-Range Sensor)	Option B (Long-Range Sensor)
Sensing range (Rs)	8 m	15 m
Communication range (Rc)	25 m	35 m
Cost per sensor	$45	$85
Power consumption	12 mA active	22 mA active
Floor dimensions	50m x 30m per floor (1,500 m^2 each)
Total area	4,500 m^2 (3 floors)

Steps:

1. Verify Zhang-Hou connectivity condition:
   • Option A: Rc = 25m, 2Rs = 16m. Since 25 >= 16, connectivity guaranteed if coverage achieved
   • Option B: Rc = 35m, 2Rs = 30m. Since 35 >= 30, connectivity guaranteed if coverage achieved
2. Calculate minimum sensors for 1-coverage per floor:
   • Option A (Rs = 8m):
     • Sensor coverage area: pi x 8^2 = 201 m^2
     • Minimum per floor (theoretical): 1,500 / 201 = 7.5 sensors
     • With triangular lattice packing efficiency (~90.7%): 7.5 / 0.907 = 8.3 ~ 9 sensors per floor
     • Total for 3 floors: 27 sensors
   • Option B (Rs = 15m):
     • Sensor coverage area: pi x 15^2 = 707 m^2
     • Minimum per floor (theoretical): 1,500 / 707 = 2.1 sensors
     • With packing efficiency: 2.1 / 0.907 = 2.3 ~ 3 sensors per floor
     • Total for 3 floors: 9 sensors
3. Calculate actual sensors needed (accounting for room layout):
   • Option A: Office has 6 rooms per floor (5 offices + 1 open area)
     • Need at least 1 sensor per room for full coverage
     • Minimum: 6 sensors per floor x 3 floors = 18 sensors
     • With 8m range, larger rooms need 2 sensors: 24 sensors total
   • Option B: With 15m range, most rooms covered by single sensor
     • Open area (30m x 20m) needs 2 sensors
     • Offices (5 x 10m x 6m each) each need 1 sensor
     • Per floor: 2 + 5 = 7 sensors, but shared coverage reduces to 5
     • Total: 15 sensors
4. Calculate deployment cost:

Metric	Option A	Option B
Sensors needed	24	15
Hardware cost	24 x $45 = $1,080	15 x $85 = $1,275
Installation (est. $30/sensor)	$720	$450
Total deployment cost	$1,800	$1,725

5. Calculate operational cost (1-year, 1% duty cycle):

   • Option A: 24 sensors x 12 mA x 0.01 duty = 2.88 mA average x 24 = 69.1 mAh/day

   • With 2,000 mAh batteries: replacement every 29 days

   • Battery replacements/year: 365/29 = 12.6 cycles x 24 sensors = 302 batteries

   • Battery cost: 302 x $3 = $906/year

   • Option B: 15 sensors x 22 mA x 0.01 duty = 3.3 mA average x 15 = 49.5 mAh/day

   • With 2,000 mAh batteries: replacement every 40 days

   • Battery replacements/year: 365/40 = 9.1 cycles x 15 sensors = 137 batteries

   • Battery cost: 137 x $3 = $411/year

6. Calculate 3-year Total Cost of Ownership (TCO):

Cost Component	Option A	Option B
Initial deployment	$1,800	$1,725
3-year batteries	$2,718	$1,233
3-Year TCO	$4,518	$2,958
Savings	—	$1,560 (35%)

Result:

Decision Factor	Option A (Short-Range)	Option B (Long-Range)	Winner
Sensors required	24	15	Option B
Initial cost	$1,800	$1,725	Option B
Annual battery cost	$906	$411	Option B
3-year TCO	$4,518	$2,958	Option B
Installation complexity	Higher (more nodes)	Lower	Option B
Failure points	24	15	Option B

Key Insight: Despite Option B sensors costing 89% more per unit ($85 vs $45), the total cost of ownership is 35% lower because fewer sensors are needed. The Zhang-Hou condition (Rc >= 2Rs) is satisfied by both options, ensuring connectivity follows from coverage. For building automation, Option B’s longer sensing range reduces total sensor count by 38%, which compounds into maintenance savings over the deployment lifetime. The lesson: evaluate WSN economics on TCO, not unit cost. Longer-range sensors often provide better value despite higher per-unit pricing.

---

410.6 Visual Reference Gallery

NoteWSN Coverage Visualizations

These AI-generated figures provide alternative visual representations of WSN coverage concepts covered in this chapter.

410.6.1 Area Coverage

Coverage

410.6.2 Barrier Coverage

Barrier Coverage

410.6.3 Coverage Optimization

Coverage Optimization

410.7 Practice Exercises

Apply your knowledge of WSN coverage concepts with these hands-on exercises.

NoteExercise 1: Coverage Area Calculation

Objective: Calculate sensor requirements for different coverage scenarios using Boolean and probabilistic models.

Scenario: You need to deploy sensors to monitor a rectangular field (500m × 300m). Sensors have sensing radius Rs = 25m.

Tasks: 1. Boolean Coverage Model: Calculate minimum number of sensors needed for 100% coverage assuming perfect circular sensing ranges 2. Grid Deployment: Design a regular grid deployment and calculate actual coverage percentage 3. Probabilistic Model: If detection probability at radius r is P(r) = e^(-0.1r), calculate required sensor density for 90% detection probability at any point 4. Coverage Holes: Identify potential coverage gaps in your grid design and propose solutions

Expected Outcome: - Understand difference between theoretical and practical coverage - Learn to calculate sensor density for different coverage models - Recognize trade-offs between coverage guarantee and sensor count

Solution Hints: - Theoretical minimum: Area / (π × Rs²) ≈ 500×300 / (π × 25²) ≈ 76 sensors - Grid spacing: For overlapping coverage, space sensors at √3 × Rs ≈ 43m intervals - Probabilistic: Requires integral calculus or numerical simulation - Coverage holes appear at grid cell corners furthest from sensors

NoteExercise 2: Barrier Coverage Design

Objective: Design k-barrier coverage for border surveillance applications.

Scenario: Secure a 2km border using motion sensors. Each sensor has 40m detection range. Detect any crossing with 99% probability (requires 2-barrier coverage).

Tasks: 1. Calculate minimum sensors needed for weak 1-barrier coverage 2. Calculate sensors for strong 2-barrier coverage 3. Design sensor placement: create deployment map showing sensor positions 4. Analyze robustness: if 10% of sensors fail randomly, what is probability of creating a gap in barrier? 5. Propose redundancy strategy to maintain coverage under node failures

Expected Outcome: - Understand weak vs. strong barrier coverage - Learn to design fault-tolerant barrier deployments - Develop skills in reliability analysis

Solution Approach: - Weak 1-barrier: 2000m / (2 × 40m) = 25 sensors (single line) - Strong 2-barrier: Need overlapping coverage belts, ~50-60 sensors in staggered rows - Reliability: Use binomial probability to calculate gap formation - Redundancy: Deploy 30% extra sensors or use mobile backup sensors

NoteExercise 3: Coverage vs. Connectivity Trade-off Analysis

Objective: Explore the relationship between coverage and connectivity using simulation.

Scenario: Random deployment of N sensors in 500m × 500m area. Sensing range Rs = 30m, communication range Rc varies.

Tasks: 1. For Rc/Rs ratios of [1.0, 1.5, 2.0, 2.5, 3.0], simulate 100 random deployments with N = 100 sensors 2. For each deployment, calculate: (a) Coverage percentage, (b) Connectivity (largest connected component size) 3. Plot coverage vs. connectivity for different Rc/Rs ratios 4. Verify Zhang-Hou theorem: does coverage → connectivity when Rc ≥ 2Rs? 5. Identify minimum Rc/Rs ratio that ensures connectivity for your deployments

Expected Outcome: - Understand coverage-connectivity relationship empirically - Gain experience with Monte Carlo simulation methods - Learn to validate theoretical results through experimentation

Implementation (Python + matplotlib):

import random
import matplotlib.pyplot as plt

def random_deployment(N, area_size, Rs, Rc):
    nodes = [(random.uniform(0, area_size),
              random.uniform(0, area_size)) for _ in range(N)]
    coverage = calculate_coverage(nodes, Rs, area_size)
    connectivity = calculate_connectivity(nodes, Rc)
    return coverage, connectivity

# Run simulations and plot results

NoteExercise 4: Optimal Sensor Activation for Energy Efficiency

Objective: Implement and evaluate coverage-preserving sleep scheduling algorithms.

Scenario: Over-deployed WSN with 200 sensors covering 400m × 400m area. Rs = 20m, Rc = 50m. Goal: Maximize network lifetime while maintaining 100% coverage.

Tasks: 1. Coverage Redundancy Analysis: For each point in area, count how many sensors cover it. Create heat map. 2. Greedy Selection Algorithm: Implement algorithm to select minimum sensor set for full coverage: - Start with all sensors OFF - Iteratively add sensor that covers most uncovered area - Stop when 100% coverage achieved 3. Distributed Sleep Scheduling: Implement protocol where sensors decide locally to sleep if their coverage area is redundantly covered 4. Lifetime Simulation: Simulate 1000 rounds of data collection with rotation. Compare active sensor count and network lifetime vs. always-on approach

Expected Outcome: - Learn to implement coverage-preserving scheduling algorithms - Understand centralized vs. distributed approaches - Develop optimization skills for energy-coverage trade-offs

Algorithm Pseudocode:

def greedy_coverage(sensors, area, Rs):
    active = []
    uncovered = get_grid_points(area)

    while uncovered:
        best_sensor = max(sensors,
                         key=lambda s: count_covered(s, uncovered, Rs))
        active.append(best_sensor)
        uncovered = remove_covered(uncovered, best_sensor, Rs)

    return active

# Expected: 40-60% sensor reduction with full coverage

---

410.8 Interactive: Sensor Coverage Playground

NoteInteractive Coverage Visualization

Explore WSN coverage concepts hands-on with this interactive simulation. Place sensors on a 2D grid, adjust sensing radius, and visualize coverage metrics including k-coverage, coverage holes, and redundant areas.

Instructions: - Click on the grid to place/remove sensors - Adjust the sensing radius slider to change detection range - Toggle k-coverage mode to see areas covered by 1, 2, or more sensors - Observe real-time coverage statistics

gridSize = 100
cellSize = 5
canvasWidth = gridSize * cellSize
canvasHeight = gridSize * cellSize

// Reactive inputs
viewof sensingRadius = Inputs.range([5, 30], {
  value: 15,
  step: 1,
  label: "Sensing Radius (units)"
})

viewof kCoverageLevel = Inputs.range([1, 4], {
  value: 1,
  step: 1,
  label: "K-Coverage Level"
})

viewof showCoverageHoles = Inputs.toggle({
  label: "Highlight Coverage Holes",
  value: true
})

viewof showRedundancy = Inputs.toggle({
  label: "Show Redundant Coverage",
  value: true
})

viewof clearSensors = Inputs.button("Clear All Sensors")

// Mutable sensor positions
mutable sensors = []

// Clear sensors when button clicked
{
  clearSensors;
  mutable sensors = [];
}

function calculateCoverageGrid(sensors, radius, gridSize, cellSize) {
  const coverageCount = new Array(gridSize * gridSize).fill(0);

  for (let y = 0; y < gridSize; y++) {
    for (let x = 0; x < gridSize; x++) {
      const px = (x + 0.5) * cellSize;
      const py = (y + 0.5) * cellSize;

      for (const sensor of sensors) {
        const dx = px - sensor.x;
        const dy = py - sensor.y;
        const dist = Math.sqrt(dx * dx + dy * dy);
        if (dist <= radius * cellSize) {
          coverageCount[y * gridSize + x]++;
        }
      }
    }
  }

  return coverageCount;
}

function calculateMetrics(coverageCount, kLevel) {
  const totalCells = coverageCount.length;
  let coveredCells = 0;
  let kCoveredCells = 0;
  let redundantCells = 0;
  let holeCells = 0;

  for (const count of coverageCount) {
    if (count > 0) coveredCells++;
    if (count >= kLevel) kCoveredCells++;
    if (count > 1) redundantCells++;
    if (count === 0) holeCells++;
  }

  return {
    totalCoverage: ((coveredCells / totalCells) * 100).toFixed(1),
    kCoverage: ((kCoveredCells / totalCells) * 100).toFixed(1),
    redundancy: ((redundantCells / totalCells) * 100).toFixed(1),
    holes: ((holeCells / totalCells) * 100).toFixed(1),
    sensorCount: sensors.length
  };
}

// Calculate coverage grid
coverageGrid = calculateCoverageGrid(sensors, sensingRadius, gridSize, cellSize)
metrics = calculateMetrics(coverageGrid, kCoverageLevel)

// Color functions
function getCoverageColor(count, kLevel, showHoles, showRedund) {
  if (count === 0) {
    return showHoles ? "rgba(231, 76, 60, 0.6)" : "rgba(236, 240, 241, 0.3)";
  }
  if (count >= kLevel) {
    if (count > kLevel && showRedund) {
      // Gradient for redundancy: more sensors = darker teal
      const intensity = Math.min(count / 4, 1);
      return `rgba(22, 160, 133, ${0.3 + intensity * 0.5})`;
    }
    return "rgba(22, 160, 133, 0.4)"; // k-covered: teal
  }
  // Below k-coverage: orange warning
  return "rgba(230, 126, 34, 0.5)";
}

// SVG Visualization
coverageViz = {
  const svg = d3.create("svg")
    .attr("width", canvasWidth + 120)
    .attr("height", canvasHeight + 60)
    .attr("viewBox", `0 0 ${canvasWidth + 120} ${canvasHeight + 60}`)
    .style("max-width", "100%")
    .style("border", "2px solid #2C3E50")
    .style("border-radius", "8px")
    .style("background", "#ECF0F1")
    .style("cursor", "crosshair");

  // Main group with margin
  const g = svg.append("g")
    .attr("transform", "translate(10, 10)");

  // Draw coverage cells
  for (let y = 0; y < gridSize; y++) {
    for (let x = 0; x < gridSize; x++) {
      const count = coverageGrid[y * gridSize + x];
      g.append("rect")
        .attr("x", x * cellSize)
        .attr("y", y * cellSize)
        .attr("width", cellSize)
        .attr("height", cellSize)
        .attr("fill", getCoverageColor(count, kCoverageLevel, showCoverageHoles, showRedundancy))
        .attr("stroke", "none");
    }
  }

  // Draw grid lines (sparse)
  for (let i = 0; i <= gridSize; i += 10) {
    g.append("line")
      .attr("x1", i * cellSize)
      .attr("y1", 0)
      .attr("x2", i * cellSize)
      .attr("y2", canvasHeight)
      .attr("stroke", "#BDC3C7")
      .attr("stroke-width", 0.5);
    g.append("line")
      .attr("x1", 0)
      .attr("y1", i * cellSize)
      .attr("x2", canvasWidth)
      .attr("y2", i * cellSize)
      .attr("stroke", "#BDC3C7")
      .attr("stroke-width", 0.5);
  }

  // Draw sensor coverage circles
  for (const sensor of sensors) {
    g.append("circle")
      .attr("cx", sensor.x)
      .attr("cy", sensor.y)
      .attr("r", sensingRadius * cellSize)
      .attr("fill", "rgba(22, 160, 133, 0.15)")
      .attr("stroke", "#16A085")
      .attr("stroke-width", 2)
      .attr("stroke-dasharray", "5,3");
  }

  // Draw sensor nodes
  for (const sensor of sensors) {
    g.append("circle")
      .attr("cx", sensor.x)
      .attr("cy", sensor.y)
      .attr("r", 8)
      .attr("fill", "#2C3E50")
      .attr("stroke", "#16A085")
      .attr("stroke-width", 3);

    // Sensor ID label
    g.append("text")
      .attr("x", sensor.x)
      .attr("y", sensor.y + 3)
      .attr("text-anchor", "middle")
      .attr("fill", "white")
      .attr("font-size", "8px")
      .attr("font-weight", "bold")
      .text(sensors.indexOf(sensor) + 1);
  }

  // Legend
  const legend = svg.append("g")
    .attr("transform", `translate(${canvasWidth + 20}, 20)`);

  legend.append("text")
    .attr("x", 0)
    .attr("y", 0)
    .attr("font-size", "12px")
    .attr("font-weight", "bold")
    .attr("fill", "#2C3E50")
    .text("Legend");

  const legendItems = [
    { color: "rgba(22, 160, 133, 0.4)", label: `${kCoverageLevel}-covered` },
    { color: "rgba(22, 160, 133, 0.8)", label: "Redundant" },
    { color: "rgba(230, 126, 34, 0.5)", label: `< ${kCoverageLevel}-coverage` },
    { color: "rgba(231, 76, 60, 0.6)", label: "Hole" },
    { color: "#2C3E50", label: "Sensor" }
  ];

  legendItems.forEach((item, i) => {
    if (item.label === "Sensor") {
      legend.append("circle")
        .attr("cx", 8)
        .attr("cy", 25 + i * 22)
        .attr("r", 6)
        .attr("fill", item.color)
        .attr("stroke", "#16A085")
        .attr("stroke-width", 2);
    } else {
      legend.append("rect")
        .attr("x", 0)
        .attr("y", 17 + i * 22)
        .attr("width", 16)
        .attr("height", 16)
        .attr("fill", item.color)
        .attr("stroke", "#2C3E50")
        .attr("stroke-width", 1);
    }
    legend.append("text")
      .attr("x", 22)
      .attr("y", 28 + i * 22)
      .attr("font-size", "10px")
      .attr("fill", "#2C3E50")
      .text(item.label);
  });

  // Click handler for adding/removing sensors
  svg.on("click", function(event) {
    const [mx, my] = d3.pointer(event);
    const x = mx - 10;
    const y = my - 10;

    // Check if within grid bounds
    if (x < 0 || x > canvasWidth || y < 0 || y > canvasHeight) return;

    // Check if clicking on existing sensor (to remove)
    const clickRadius = 15;
    const existingIndex = sensors.findIndex(s => {
      const dx = s.x - x;
      const dy = s.y - y;
      return Math.sqrt(dx * dx + dy * dy) < clickRadius;
    });

    if (existingIndex >= 0) {
      // Remove sensor
      mutable sensors = sensors.filter((_, i) => i !== existingIndex);
    } else {
      // Add new sensor
      mutable sensors = [...sensors, { x, y }];
    }
  });

  return svg.node();
}

// Display the visualization
coverageViz

Coverage Metrics:

html`
<div style="display: grid; grid-template-columns: repeat(5, 1fr); gap: 10px; margin: 15px 0; text-align: center;">
  <div style="background: #2C3E50; color: white; padding: 12px; border-radius: 8px;">
    <div style="font-size: 24px; font-weight: bold;">${metrics.sensorCount}</div>
    <div style="font-size: 11px;">Sensors</div>
  </div>
  <div style="background: #16A085; color: white; padding: 12px; border-radius: 8px;">
    <div style="font-size: 24px; font-weight: bold;">${metrics.totalCoverage}%</div>
    <div style="font-size: 11px;">Total Coverage</div>
  </div>
  <div style="background: ${parseFloat(metrics.kCoverage) >= 90 ? '#16A085' : '#E67E22'}; color: white; padding: 12px; border-radius: 8px;">
    <div style="font-size: 24px; font-weight: bold;">${metrics.kCoverage}%</div>
    <div style="font-size: 11px;">${kCoverageLevel}-Coverage</div>
  </div>
  <div style="background: #3498DB; color: white; padding: 12px; border-radius: 8px;">
    <div style="font-size: 24px; font-weight: bold;">${metrics.redundancy}%</div>
    <div style="font-size: 11px;">Redundant</div>
  </div>
  <div style="background: ${parseFloat(metrics.holes) > 10 ? '#E74C3C' : '#27AE60'}; color: white; padding: 12px; border-radius: 8px;">
    <div style="font-size: 24px; font-weight: bold;">${metrics.holes}%</div>
    <div style="font-size: 11px;">Holes</div>
  </div>
</div>
`

Analysis Guide:

Coverage Level	Status	Interpretation
1-coverage 100%	Minimum viable	Every point monitored by at least 1 sensor
2-coverage 100%	Fault tolerant	Network survives 1 sensor failure
Redundancy > 30%	Energy inefficient	Consider duty cycling to extend lifetime
Holes > 5%	Coverage gaps	Add sensors or increase radius

Try These Experiments:

1. Minimum Coverage: Place sensors to achieve 100% 1-coverage with fewest sensors
2. Barrier Coverage: Create a line of sensors across the grid - can you cover a “border”?
3. K-Coverage Trade-off: Achieve 2-coverage and note how many more sensors are needed
4. Redundancy Analysis: Over-deploy sensors and observe redundancy percentage for duty cycling potential

---

NotePhantom Figure Gallery

The following AI-generated figures provide alternative visual representations of concepts covered in this chapter. These “phantom figures” offer different artistic interpretations to help reinforce understanding.

410.8.1 Coverage Types

Barrier Coverage

Coverage

Coverage Optimization

Crossings

Crossings Not Covered

410.8.2 Coverage Algorithms

ODIN

ODIN2

OGDC2

OGDC3

Select a Starting Node

410.9 Summary

This chapter provided comprehensive worked examples for applying WSN coverage theory:

• k-Coverage Analysis: Grid-based method to evaluate coverage levels and identify gaps in water treatment facility deployment
• Duty Cycling Budget: Energy calculation showing 2.35% duty cycle achieves 5-year lifetime for wildlife tracking
• Sensing Range Trade-off: TCO analysis demonstrating 35% savings with longer-range sensors despite higher unit cost
• Practice Exercises: Hands-on problems for coverage calculation, barrier design, Monte Carlo simulation, and sleep scheduling
• Interactive Playground: OJS-based coverage visualization for experimentation with sensor placement and k-coverage

410.10 Knowledge Check

NoteQuestion 1: k-Coverage Analysis

Question: In the water treatment facility example, what was the main reason only 58% of the area achieved 2-coverage despite 151% theoretical coverage ratio?

💡 Explanation: C. The theoretical coverage ratio only considers total area covered, not overlap distribution. Edge sensors placed 20m from walls left corners beyond their 20m sensing range, creating systematic gaps.

NoteQuestion 2: Duty Cycling

Question: In the wildlife tracking example, what dominated the energy budget?

💡 Explanation: B. Even though TX current (28 mA) exceeded RX current (18 mA), sensors spend far more time listening for coordination messages than transmitting data. Event sensing and TX were negligible (<0.02% of budget).

NoteQuestion 3: TCO Analysis

Question: Why did Option B (long-range sensors at $85 each) have lower 3-year TCO than Option A ($45 each)?

💡 Explanation: D. Option B needed only 15 sensors vs 24 for Option A. Despite 89% higher unit cost, the 38% reduction in sensor count led to 35% lower total cost of ownership including deployment and battery replacement.

410.11 What’s Next

The next chapter explores WSN Coverage Implementations, covering practical coverage algorithms including OGDC (Optimal Geographical Density Control), CCP (Coverage Configuration Protocol), and energy-efficient rotation scheduling for maximizing network lifetime.